#!/usr/bin/env python3
"""Fault-inject the production provisioning coordinator and domain start functions.

Uses host stubs for RTOS/BLE/storage only; policy, startup, error handling,
recovery-boot consumption and factory save are compiled from production code.
"""
from pathlib import Path
import re
import subprocess
import tempfile

ROOT = Path(__file__).resolve().parents[1]
CP = (ROOT / 'components/control_plane/src/runtime/control_plane_connectivity_runtime.c').read_text()
DOMAIN = (ROOT / 'components/domain/src/runtime/domain_mini_program_provisioning.c').read_text()
CLI = (ROOT / 'components/control_plane/src/runtime/control_plane_factory_cli.c').read_text()
FACADE = (ROOT / 'components/domain/include/domain.h').read_text()


def extract(source, name):
    match = re.search(r'^(?:static )?(?:esp_err_t|bool|void|uint32_t|const char \*|domain_wifi_provisioning_start_status_t)\s*' + name + r'\([^;]*?\)\s*\{', source, re.M)
    if not match:
        raise ValueError(name)
    pos, depth = match.end(), 1
    while depth:
        depth += (source[pos] == '{') - (source[pos] == '}')
        pos += 1
    return source[match.start():pos]


EVENTS = re.search(r'typedef enum \{\s*DOMAIN_WIFI_PROVISIONING_EVENT_CREDENTIALS.*?\} domain_wifi_provisioning_event_type_t;', FACADE, re.S).group()
NOTIFY = re.search(r'typedef enum \{\s*DOMAIN_WIFI_PROVISIONING_STATUS_WIFI_CONNECTING.*?\} domain_wifi_provisioning_status_t;', FACADE, re.S).group()
STATUS = re.search(r'typedef enum \{\s*DOMAIN_WIFI_PROVISIONING_START_READY.*?\} domain_wifi_provisioning_start_status_t;', FACADE, re.S).group()
CONSTANTS = '\n'.join(re.findall(r'^#define CONTROL_PLANE_PROVISIONING_.*$', CP, re.M))
STUBS = r'''
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include "control_plane_provisioning_policy.h"
typedef int esp_err_t;
typedef void *TaskHandle_t;
typedef void *QueueHandle_t;
typedef void *EventGroupHandle_t;
typedef int BaseType_t;
typedef struct {int type; struct {char ssid[33], password[65];} credentials;} domain_wifi_provisioning_event_t;
typedef uint32_t TickType_t;
typedef uint32_t EventBits_t;
typedef void (*domain_wifi_provisioning_event_callback_t)(const void *, void *);
typedef struct {uint32_t free_internal, largest_internal, largest_dma;} domain_ota_memory_headroom_t;
#define ESP_OK 0
#define ESP_ERR_INVALID_ARG 1
#define ESP_ERR_NO_MEM 2
#define ESP_ERR_TIMEOUT 3
#define ESP_ERR_NOT_FOUND 4
#define ESP_ERR_NOT_SUPPORTED 5
#define ESP_ERR_INVALID_STATE 6
#define ESP_FAIL 7
#define BIT0 1
#define BIT1 2
#define BIT2 4
#define CONFIG_TQ_MINI_PROGRAM_PROVISIONING_ENABLE 1
#define CONFIG_TQ_MINI_PROGRAM_PROVISIONING_MIN_FREE_INTERNAL_BYTES 49152
#define CONFIG_TQ_MINI_PROGRAM_PROVISIONING_MIN_LARGEST_DMA_BYTES 12288
#define DOMAIN_PROVISIONING_ID_MAX_LEN 64
#define DOMAIN_PROVISIONING_SERIAL_MAX_LEN 64
#define DOMAIN_PROVISIONING_INFO_MAX_LEN 512
#define PLATFORM_BLE_GATT_NAME_MAX_LEN 32
#define FACTORY_CLI_DEVICE_ID_MAX_LEN 64
#define FACTORY_CLI_SERIAL_MAX_LEN 64
#define pdMS_TO_TICKS(ms) (ms)
#define pdPASS 1
#define pdTRUE 1
#define pdFALSE 0
#define CONFIG_TQ_MINI_PROGRAM_PROVISIONING_CONNECT_TIMEOUT_MS 30000
static int lock_depth;
#define portENTER_CRITICAL(lock) do {assert(lock_depth++ == 0);} while(0)
#define portEXIT_CRITICAL(lock) do {assert(--lock_depth == 0);} while(0)
static char logs[32768];
static void record(const char *fmt, ...) {
    va_list ap; va_start(ap, fmt);
    vsnprintf(logs+strlen(logs), sizeof(logs)-strlen(logs), fmt, ap);
    va_end(ap);
}
#define ESP_LOGI(tag, ...) record(__VA_ARGS__)
#define ESP_LOGW(tag, ...) record(__VA_ARGS__)
#define ESP_LOGE(tag, ...) record(__VA_ARGS__)
static const char *esp_err_to_name(int err) {return err==ESP_ERR_NOT_FOUND ? "NOT_FOUND" : "error";}
static uint64_t now_ms;
static int restarts, memory_calls, quiesce_calls, audio_deinits, ble_calls, ble_stops, notifications;
static int ble_error, stop_error, memory_error_after, create_error, queue_error, local_wake_error, sta_error, save_error;
static int cli_ok, cli_errors, config_notifications;
static bool identity_ready, keep_awake;
static unsigned event_bits;
static int runtime_starts, task_deletes, connect_calls, connect_failures, wifi_failed_notifications;
static domain_ota_memory_headroom_t memory;
static cp_provisioning_policy_t s_provisioning_policy;
static bool s_provisioning_recovery_boot;
static uint32_t s_provisioning_recovery_marker, s_provisioning_recovery_marker_inverse;
static TaskHandle_t s_provisioning_task;
static QueueHandle_t s_provisioning_queue;
static EventGroupHandle_t s_provisioning_events;
static domain_wifi_provisioning_event_callback_t s_event_callback;
static void *s_event_user_data;
static char s_pending_device_id[64], s_pending_serial_number[64];
static uint64_t esp_timer_get_time(void) {return now_ms*1000;}
static void vTaskDelay(unsigned ms) {now_ms+=ms;}
static void domain_runtime_restart(void) {++restarts;}
static esp_err_t domain_runtime_ota_get_memory_headroom(domain_ota_memory_headroom_t *out) {
    assert(!lock_depth); ++memory_calls;
    if (memory_error_after && memory_calls >= memory_error_after) return ESP_FAIL;
    *out=memory; return ESP_OK;
}
static void domain_runtime_read_device_identity(char *id, size_t id_len, char *sn, size_t sn_len) {
    snprintf(id,id_len,"%s",identity_ready?"device":"");
    snprintf(sn,sn_len,"%s",identity_ready?"serial":"");
}
static void control_plane_request_wifi_reconnect_now(void) {++config_notifications;}
static void control_plane_wifi_set_keep_awake(bool value) {keep_awake=value;}
static void control_plane_set_ptt_active(bool active) {assert(!active);}
static int wake_restarts;
static bool control_plane_ota_voice_services_allowed(void) {return !s_provisioning_policy.runtime_quiesced;}
static esp_err_t control_plane_local_wake_start(void) {++wake_restarts; return ESP_OK;}
static esp_err_t control_plane_local_wake_stop(int ms) {assert(ms==2000); ++quiesce_calls; return local_wake_error;}
static esp_err_t control_plane_stop_multimodal_client(void) {return ESP_OK;}
static esp_err_t domain_runtime_multimodal_audio_stop_downstream_playback(void) {return ESP_OK;}
static void domain_runtime_multimodal_audio_deinit(void) {++audio_deinits;}
static void control_plane_show_provisioning_ui(void) {}
static esp_err_t domain_runtime_wifi_portal_stop_sta(void) {return sta_error;}
static void *xQueueCreate(unsigned len, unsigned size) {return queue_error ? NULL : (void*)1;}
static void *xEventGroupCreate(void) {return (void*)2;}
static void xQueueReset(void *queue) {assert(queue);}
static void xEventGroupClearBits(void *events, unsigned bits) {assert(events);}
static void control_plane_provisioning_event_callback(const void *event, void *user) {}
static uint32_t xTaskGetTickCount(void) {return (uint32_t)now_ms;}
static unsigned xEventGroupGetBits(void *events) {return event_bits;}
static unsigned xEventGroupWaitBits(void *events, unsigned bits, int clear, int all, unsigned timeout) {return event_bits;}
static int xQueueReceive(void *queue, domain_wifi_provisioning_event_t *event, unsigned timeout) {
    event->type=DOMAIN_WIFI_PROVISIONING_EVENT_CREDENTIALS; return pdTRUE;
}
static void vTaskDelete(void *task) {++task_deletes;}
static void control_plane_provisioning_notify(domain_wifi_provisioning_status_t status) {
    if (status==DOMAIN_WIFI_PROVISIONING_STATUS_FAIL_CONNECT || status==DOMAIN_WIFI_PROVISIONING_STATUS_FAIL_TIMEOUT)
        ++wifi_failed_notifications;
}
static esp_err_t domain_runtime_wifi_portal_connect_sta_with_credentials(const char *ssid, const char *password, int timeout) {
    ++connect_calls; return connect_calls<=connect_failures ? ESP_FAIL : ESP_OK;
}
static void control_plane_play_wifi_success_prompt(void) {}
static void control_plane_finish_provisioning_ui(void) {}
static esp_err_t control_plane_start_runtime_workers(void) {
    assert(!s_provisioning_policy.runtime_quiesced); ++runtime_starts; return ESP_OK;
}
static int xTaskCreate(void (*fn)(void*), const char *name, unsigned stack, void *arg, unsigned priority, void **task) {
    if (create_error) return 0;
    *task=(void*)3; return pdPASS;
}
static void xEventGroupSetBits(void *events, unsigned bits) {
    assert(events==s_provisioning_events);
    event_bits |= bits;
    if (bits==BIT2) {
        assert(s_provisioning_task && s_provisioning_policy.phase==CP_PROVISIONING_ACTIVE);
        ++notifications;
    }
}
static void domain_provisioning_reset_write_buffer(void) {}
static void domain_provisioning_handle_write(void) {}
static const char *s_service_uuid="service", *s_wifi_write_uuid="write", *s_status_uuid="status", *s_device_info_uuid="info";
typedef struct {
    const char *advertised_name, *service_uuid, *write_uuid, *notify_uuid, *read_notify_uuid;
    const uint8_t *read_value; size_t read_value_len;
    void (*on_write)(void); void *user_data;
} platform_ble_gatt_server_config_t;
static esp_err_t platform_ble_gatt_server_start(const platform_ble_gatt_server_config_t *cfg) {++ble_calls; return ble_error;}
static esp_err_t domain_runtime_mini_program_provisioning_stop(int timeout) {assert(timeout==2000); ++ble_stops; return stop_error;}
static esp_err_t domain_provisioning_build_device_info(char *name, size_t n, char *info, size_t i) {
    name[0]=0; snprintf(info,i,"{}"); return identity_ready?ESP_OK:ESP_ERR_NOT_FOUND;
}
static void control_plane_register_wifi_behavior_hooks(void) {}
static esp_err_t domain_runtime_wifi_portal_init_defaults(const char *ssid, const char *password) {return ESP_OK;}
static bool domain_runtime_wifi_portal_has_saved_credentials(void) {return false;}
static int control_plane_normalize_connect_timeout_ms(int ms, int unused) {return ms;}
static esp_err_t control_plane_connect_sta_with_feedback(int ms, bool feedback) {return ESP_FAIL;}
static esp_err_t control_plane_start_lcd_render_worker(void) {return ESP_OK;}
static bool is_text_empty(const char *s) {return !s || !s[0];}
#define strlcpy test_strlcpy
static size_t test_strlcpy(char *dst, const char *src, size_t len) {size_t n=strlen(src); snprintf(dst,len,"%s",src); return n;}
static void trim_text(char *s) {}
static esp_err_t domain_runtime_write_device_identity(const char *id, const char *sn) {
    if (save_error) return save_error;
    identity_ready=id[0] && sn[0]; return ESP_OK;
}
static void control_plane_multimodal_device_auth_invalidate(unsigned unused) {}
static void cli_write_error(const char *error) {++cli_errors;}
static void cli_write_ok(void) {++cli_ok;}
'''

TESTS = r'''
static void reset(void) {
    memset(&s_provisioning_policy,0,sizeof(s_provisioning_policy));
    s_provisioning_recovery_boot=false;
    s_provisioning_recovery_marker=s_provisioning_recovery_marker_inverse=0;
    s_provisioning_task=s_provisioning_queue=s_provisioning_events=NULL;
    now_ms=0; restarts=memory_calls=quiesce_calls=audio_deinits=ble_calls=ble_stops=notifications=0;
    ble_error=stop_error=memory_error_after=create_error=queue_error=local_wake_error=sta_error=save_error=0;
    cli_ok=cli_errors=config_notifications=0;
    wake_restarts=0; event_bits=0; runtime_starts=task_deletes=connect_calls=connect_failures=wifi_failed_notifications=0;
    identity_ready=false; keep_awake=false;
    s_pending_device_id[0]=s_pending_serial_number[0]=logs[0]=0;
    memory=(domain_ota_memory_headroom_t){135167,73728,73728};
}
int main(void) {
    reset();
    assert(control_plane_bootstrap_connectivity("","",20000)==ESP_ERR_NOT_FOUND);
    assert(s_provisioning_policy.phase==CP_PROVISIONING_WAIT_IDENTITY);
    for (unsigned i=0;i<10000;i++) {now_ms+=1000; assert(!control_plane_provisioning_retry_due());}
    assert(!restarts && !ble_calls && !quiesce_calls && !audio_deinits);
    assert(control_plane_provisioning_allows_voice());
    assert(strstr(logs,"identity_required"));
    /* Failed save cannot wake policy; successful save only notifies, BLE runs later. */
    snprintf(s_pending_device_id,64,"new-id"); snprintf(s_pending_serial_number,64,"new-sn");
    save_error=ESP_FAIL; handle_save_config();
    assert(cli_errors==1 && !config_notifications && !control_plane_provisioning_retry_due());
    save_error=0; handle_save_config();
    assert(cli_ok==1 && config_notifications==1 && !ble_calls);
    assert(control_plane_provisioning_retry_due());
    assert(control_plane_enter_mini_program_reprovisioning("identity_saved")==ESP_OK);
    assert(ble_calls==1 && quiesce_calls==1 && notifications==1 && !restarts);
    assert(!control_plane_provisioning_allows_voice() && !control_plane_provisioning_retry_due());

    /* Actual timeout classification and exact bounded backoff, including uint32 wrap. */
    reset(); identity_ready=true; ble_error=ESP_ERR_TIMEOUT; now_ms=UINT32_MAX-500;
    const unsigned delays[]={1000,3000,10000};
    for (unsigned i=0;i<3;i++) {
        assert(control_plane_enter_mini_program_reprovisioning("timeout")==ESP_ERR_TIMEOUT);
        assert(s_provisioning_policy.phase==CP_PROVISIONING_BACKOFF);
        assert(s_provisioning_policy.retry_delay_ms==delays[i]);
        assert(!control_plane_provisioning_retry_due()); now_ms+=delays[i]-1;
        assert(!control_plane_provisioning_retry_due()); ++now_ms;
        assert(control_plane_provisioning_retry_due());
    }
    assert(control_plane_enter_mini_program_reprovisioning("timeout")==ESP_ERR_TIMEOUT);
    assert(s_provisioning_policy.phase==CP_PROVISIONING_BLOCKED && !restarts && ble_calls==4);
    now_ms+=100000; assert(!control_plane_provisioning_retry_due());
    control_plane_provisioning_configuration_changed(); ble_error=ESP_OK;
    assert(control_plane_enter_mini_program_reprovisioning("manual")==ESP_OK);

    const int permanent[]={ESP_ERR_INVALID_ARG,ESP_ERR_NOT_SUPPORTED,ESP_ERR_NOT_FOUND,ESP_FAIL};
    for (unsigned i=0;i<4;i++) {
        reset(); identity_ready=true; ble_error=permanent[i];
        assert(control_plane_enter_mini_program_reprovisioning("permanent")==permanent[i]);
        assert(s_provisioning_policy.phase==CP_PROVISIONING_BLOCKED);
        assert(!restarts && !control_plane_provisioning_retry_due());
        assert(!s_event_callback && !s_event_user_data);
    }
    /* Memory threshold and actual allocator failure both permit only ONE recovery. */
    for (unsigned scenario=0;scenario<5;scenario++) {
        reset(); identity_ready=true;
        if (scenario==0) memory.free_internal=49151;
        if (scenario==1) memory.largest_dma=12287;
        if (scenario==2) ble_error=ESP_ERR_NO_MEM;
        if (scenario==3) create_error=1;
        if (scenario==4) queue_error=1;
        assert(control_plane_bootstrap_connectivity("","",20000)==ESP_ERR_NO_MEM);
        assert(restarts==1 && s_provisioning_policy.recovery_attempted);
        assert(control_plane_take_mini_program_recovery_boot_request());
        assert(!control_plane_take_mini_program_recovery_boot_request());
        assert(s_provisioning_policy.recovery_attempted);
        /* Simulate fresh globals after RTC consumption, retaining the attempt latch. */
        s_provisioning_policy.phase=CP_PROVISIONING_IDLE;
        assert(control_plane_bootstrap_connectivity("","",20000)==ESP_ERR_NO_MEM);
        assert(!s_provisioning_recovery_boot && s_provisioning_policy.recovery_attempted);
        assert(restarts==1 && !control_plane_provisioning_retry_due());
        for (unsigned retry=0;retry<20;retry++) {
            control_plane_provisioning_configuration_changed();
            assert(control_plane_enter_mini_program_reprovisioning("explicit")==ESP_ERR_NO_MEM);
            assert(restarts==1);
        }
    }
    reset(); identity_ready=true; memory.free_internal=49152; memory.largest_dma=12288;
    assert(control_plane_enter_mini_program_reprovisioning("boundary")==ESP_OK && !restarts);
    reset(); identity_ready=true; memory_error_after=1;
    assert(control_plane_enter_mini_program_reprovisioning("measurement_error")==ESP_FAIL);
    assert(!restarts && !ble_calls && !control_plane_provisioning_retry_due());
    /* Snapshot failure after a confirmed BLE allocation failure prints unknown, never fake zeros. */
    reset(); identity_ready=true; ble_error=ESP_ERR_NO_MEM; memory_error_after=2;
    assert(control_plane_enter_mini_program_reprovisioning("allocation")==ESP_ERR_NO_MEM);
    assert(restarts==1 && strstr(logs,"memory=unknown") && !strstr(logs,"free_internal=0"));
    reset(); identity_ready=true; local_wake_error=ESP_ERR_TIMEOUT;
    assert(control_plane_enter_mini_program_reprovisioning("stop_timeout")==ESP_ERR_TIMEOUT);
    assert(!audio_deinits && !ble_calls && !restarts);
    reset(); identity_ready=true; create_error=1; stop_error=ESP_ERR_TIMEOUT;
    assert(control_plane_enter_mini_program_reprovisioning("cleanup_timeout")==ESP_ERR_TIMEOUT);
    assert(ble_stops==1 && !restarts && s_provisioning_policy.phase==CP_PROVISIONING_BLOCKED);
    /* Run the real worker: bad Wi-Fi credentials retain BLE; success restores runtime. */
    reset(); identity_ready=true; connect_failures=1;
    assert(control_plane_enter_mini_program_reprovisioning("normal")==ESP_OK);
    control_plane_provisioning_worker(NULL);
    assert(connect_calls==2 && wifi_failed_notifications==1 && ble_calls==1 && ble_stops==1);
    assert(runtime_starts==1 && !restarts && !s_provisioning_task && task_deletes==1);
    assert(control_plane_provisioning_allows_voice() && !keep_awake);
    reset(); identity_ready=true; stop_error=ESP_ERR_TIMEOUT;
    assert(control_plane_enter_mini_program_reprovisioning("teardown")==ESP_OK);
    control_plane_provisioning_worker(NULL);
    assert(!runtime_starts && !restarts && s_provisioning_policy.phase==CP_PROVISIONING_BLOCKED);
    assert(!control_plane_provisioning_allows_voice() && s_provisioning_policy.cleanup_required);
    control_plane_provisioning_sta_connected();
    assert(!control_plane_provisioning_allows_voice() && !wake_restarts);
    control_plane_provisioning_configuration_changed();
    assert(control_plane_enter_mini_program_reprovisioning("cleanup_still_fails")==ESP_ERR_TIMEOUT);
    assert(ble_calls==1 && !restarts && !control_plane_provisioning_retry_due());
    stop_error=ESP_OK;
    control_plane_provisioning_configuration_changed();
    assert(control_plane_enter_mini_program_reprovisioning("cleanup_then_retry")==ESP_OK);
    assert(ble_stops==3 && ble_calls==2);
    reset(); identity_ready=true;
    assert(control_plane_enter_mini_program_reprovisioning("cancel")==ESP_OK);
    event_bits |= BIT0;
    control_plane_provisioning_worker(NULL);
    assert(!runtime_starts && !restarts && !control_plane_provisioning_retry_due());
    reset(); identity_ready=true;
    assert(control_plane_enter_mini_program_reprovisioning("gate_timeout")==ESP_OK);
    event_bits=0;
    control_plane_provisioning_worker(NULL);
    assert(!s_provisioning_task && !restarts && ble_stops==1 && !control_plane_provisioning_retry_due());
    reset(); identity_ready=true; ble_error=ESP_ERR_TIMEOUT;
    assert(control_plane_enter_mini_program_reprovisioning("direct_sta_recovery")==ESP_ERR_TIMEOUT);
    control_plane_provisioning_sta_connected();
    assert(control_plane_provisioning_allows_voice() && wake_restarts==1);
    /* One failure-recovery reboot, then the existing success-mode-switch reboot. */
    reset(); identity_ready=true; memory.free_internal=1;
    assert(control_plane_bootstrap_connectivity("","",20000)==ESP_ERR_NO_MEM && restarts==1);
    assert(control_plane_take_mini_program_recovery_boot_request());
    s_provisioning_policy.phase=CP_PROVISIONING_IDLE; memory.free_internal=135167;
    assert(control_plane_bootstrap_connectivity("","",20000)==ESP_OK);
    control_plane_provisioning_worker(NULL);
    assert(restarts==2 && !runtime_starts && !s_provisioning_task);
    assert(control_plane_provisioning_allows_voice() && !s_provisioning_recovery_marker);
    puts("PASS: worker Wi-Fi failure/success, teardown failure, cancellation and bounded start gate");
    puts("PASS: identity wait/save resume, production BLE error classification, bounded retry/wrap, memory thresholds/allocation failures, recovery-boot loop prevention, cleanup and truthful diagnostics");
}
'''


def main():
    domain_functions = ['domain_runtime_mini_program_provisioning_preflight',
                        'domain_provisioning_classify_start_error',
                        'domain_runtime_mini_program_provisioning_start']
    cp_functions = ['control_plane_provisioning_now_ms', 'control_plane_provisioning_is_recovery_boot',
                    'control_plane_provisioning_retry_due', 'control_plane_provisioning_configuration_changed',
                    'control_plane_provisioning_allows_voice', 'control_plane_provisioning_sta_connected',
                    'control_plane_take_mini_program_recovery_boot_request',
                    'control_plane_request_provisioning_recovery_restart', 'control_plane_provisioning_failure_name',
                    'control_plane_provisioning_start_failed', 'control_plane_check_provisioning_memory_headroom',
                    'control_plane_provisioning_stop_requested', 'control_plane_provisioning_worker',
                    'control_plane_start_provisioning_transport', 'control_plane_is_mini_program_provisioning_running',
                    'control_plane_try_provisioning', 'control_plane_enter_mini_program_reprovisioning',
                    'control_plane_bootstrap_connectivity']
    with tempfile.TemporaryDirectory(prefix='provisioning-recovery-') as tmp:
        tmp = Path(tmp)
        (tmp / 'domain.h').write_text('#pragma once\n'+STATUS+'\n'+EVENTS+'\n'+NOTIFY+'\n')
        source = STUBS+'\n'+CONSTANTS+'\n'
        source += '\n'.join(extract(DOMAIN, name) for name in domain_functions)+'\n'
        source += 'bool control_plane_is_mini_program_provisioning_running(void);\n'
        source += '\n'.join(extract(CP, name) for name in cp_functions)+'\n'
        source += extract(CLI, 'handle_save_config')+'\n'+TESTS
        (tmp / 'test.c').write_text(source)
        subprocess.run(['clang', '-std=c11', '-Wall', '-Wextra', '-Werror',
                        '-Wno-unused-parameter', '-Wno-unused-function',
                        '-fsanitize=address,undefined', '-I',str(tmp),
                        '-I',str(ROOT/'components/control_plane/internal'),
                        str(tmp/'test.c'), '-o',str(tmp/'test')],check=True)
        subprocess.run([str(tmp/'test')],check=True)


if __name__ == '__main__':
    main()