module builder

import os
import time
import v.pref

fn test_ccompiler_is_available_with_existing_absolute_path() {
    assert ccompiler_is_available(@VEXE)
}

fn test_ccompiler_is_available_with_missing_compiler() {
    assert !ccompiler_is_available('missing_compiler_17126_for_builder_test')
}

fn test_c_error_looks_like_cpp_header_with_clang_style_output() {
    clang_output := "error: unknown type name 'namespace'\nerror: expected ';' after top level declarator"
    assert c_error_looks_like_cpp_header(clang_output)
}

fn test_c_error_looks_like_cpp_header_with_source_excerpt() {
    gcc_output := '/usr/include/H5File.h:18: error: \';\' expected (got "H5")\n| namespace H5 {\n'
    assert c_error_looks_like_cpp_header(gcc_output)
}

fn test_c_error_looks_like_cpp_header_with_imgui_style_operator_overload() {
    imgui_output := "/tmp/fake_imgui.h:3:16: error: 'operator' declared as array of functions of type 'float (unsigned long)'\n    3 |     float operator[](unsigned long idx) const { return (&x)[idx]; }\n"
    assert c_error_looks_like_cpp_header(imgui_output)
}

fn test_c_error_looks_like_cpp_header_with_class_keyword() {
    class_output := "/usr/include/foo.hpp:4:1: error: unknown type name 'class'\n    4 | class Foo {\n"
    assert c_error_looks_like_cpp_header(class_output)
}

fn test_c_error_looks_like_cpp_header_with_regular_c_error() {
    c_output := "error: unknown type name 'my_missing_type'"
    assert !c_error_looks_like_cpp_header(c_output)
}

fn test_c_output_suggests_missing_sokol_shader_symbol_with_clang_style_output() {
    c_output := [
        "/tmp/v_501/simple_shader.tmp.c:21250:43: error: use of undeclared identifier 'ATTR_vs_aposition'",
        '        pipeline_desc.layout.attrs[v_fixed_index(ATTR_vs_aposition, 16)].format = 1;',
    ].join('\n')
    assert c_output_suggests_missing_sokol_shader_symbol(c_output) == 'ATTR_vs_aposition'
}

fn test_c_output_suggests_missing_sokol_shader_symbol_with_gcc_style_output() {
    c_output := [
        "/tmp/v_501/simple_shader.tmp.c:21250:43: error: 'SLOT_fs_params' undeclared (first use in this function)",
        '        gfx_apply_uniforms(SLOT_fs_params);',
    ].join('\n')
    assert c_output_suggests_missing_sokol_shader_symbol(c_output) == 'SLOT_fs_params'
}

fn test_c_output_suggests_missing_sokol_shader_symbol_ignores_regular_c_errors() {
    c_output := "error: use of undeclared identifier 'my_missing_type'"
    assert c_output_suggests_missing_sokol_shader_symbol(c_output) == ''
}

fn test_c_output_suggests_missing_c_function_with_clang_style_output() {
    c_output := "/tmp/v_501/main.tmp.c:4111:2: error: call to undeclared function 'bad_fn'; ISO C99 and later do not support implicit function declarations"
    known_c_functions := {
        'bad_fn': 'C.bad_fn'
    }
    assert c_output_suggests_missing_c_function(c_output, known_c_functions) == 'C.bad_fn'
}

fn test_c_output_suggests_missing_c_function_with_tcc_style_output() {
    c_output := "/tmp/v_501/main.tmp.c:4111: warning: implicit declaration of function 'bad_fn'"
    known_c_functions := {
        'bad_fn': 'C.bad_fn'
    }
    assert c_output_suggests_missing_c_function(c_output, known_c_functions) == 'C.bad_fn'
}

fn test_c_output_suggests_missing_c_function_ignores_unknown_symbols() {
    c_output := "/tmp/v_501/main.tmp.c:4111:2: error: call to undeclared function 'bad_fn'"
    known_c_functions := {
        'other_fn': 'C.other_fn'
    }
    assert c_output_suggests_missing_c_function(c_output, known_c_functions) == ''
}

fn test_macos_compile_args_do_not_force_version_min_by_default() {
    compile_args := macos_compile_args(['-os', 'macos', '-cc', 'clang', hello_world_example()])
    assert macos_version_min_flags(compile_args) == []string{}
}

fn test_macos_compile_args_keep_explicit_cflag_version_min() {
    compile_args := macos_compile_args([
        '-os',
        'macos',
        '-cc',
        'clang',
        '-cflags',
        '-mmacosx-version-min=11.0',
        hello_world_example(),
    ])
    assert macos_version_min_flags(compile_args) == ['-mmacosx-version-min=11.0']
}

fn test_macos_compile_args_append_macosx_version_min_after_cflags() {
    compile_args := macos_compile_args([
        '-os',
        'macos',
        '-cc',
        'clang',
        '-cflags',
        '-mmacosx-version-min=10.7',
        '-macosx-version-min',
        '11.0',
        hello_world_example(),
    ])
    assert macos_version_min_flags(compile_args) == [
        '-mmacosx-version-min=10.7',
        '-mmacosx-version-min=11.0',
    ]
}

fn test_cc_from_string_detects_cl_as_msvc() {
    assert pref.cc_from_string('cl') == .msvc
    assert pref.cc_from_string('C:/Program Files/Microsoft Visual Studio/cl.exe') == .msvc
}

fn test_cc_from_string_detects_tiny_gcc_as_tinyc() {
    assert pref.cc_from_string('tiny_gcc') == .tinyc
    assert pref.cc_from_string('/usr/local/bin/tiny_gcc') == .tinyc
}

fn test_ccompiler_type_from_version_output_detects_openbsd_clang() {
    detected := ccompiler_type_from_version_output('OpenBSD clang version 16.0.6') or { panic(err) }
    assert detected == .clang
}

fn test_ccompiler_type_from_version_output_detects_tcc() {
    detected := ccompiler_type_from_version_output('tcc version 0.9.27 (x86_64 Linux)') or {
        panic(err)
    }
    assert detected == .tinyc
}

fn test_ccompiler_type_from_name_detects_tiny_gcc() {
    detected := ccompiler_type_from_name('/opt/tiny_gcc') or { panic(err) }
    assert detected == .tinyc
}

fn test_ccompiler_type_from_version_output_detects_tiny_gcc() {
    detected := ccompiler_type_from_version_output('tiny_gcc version 0.9.27') or { panic(err) }
    assert detected == .tinyc
}

fn test_is_tcc_compilation_failure_detects_tiny_gcc_compiler_name() {
    assert is_tcc_compilation_failure('/opt/bin/tiny_gcc', .unknown, '')
}

fn test_resolve_ccompiler_type_detects_cc_alias_path_as_clang() {
    $if windows {
        return
    }
    test_root := os.join_path(os.vtmp_dir(), 'v_builder_cc_alias_${os.getpid()}')
    alias_cc := prepare_test_ccompiler_alias(test_root, 'cc', 'OpenBSD clang version 16.0.6')
    defer {
        os.rmdir_all(test_root) or {}
    }
    assert resolve_ccompiler_type(alias_cc, pref.cc_from_string(alias_cc)) == .clang
}

fn test_resolve_ccompiler_type_detects_real_path_without_running_alias() {
    $if windows {
        return
    }
    test_root := os.join_path(os.vtmp_dir(), 'v_builder_cc_symlink_${os.getpid()}')
    os.rmdir_all(test_root) or {}
    os.mkdir_all(test_root) or { panic(err) }
    defer {
        os.rmdir_all(test_root) or {}
    }
    clang_path := os.join_path(test_root, 'clang')
    os.write_file(clang_path, '#!/bin/sh
exit 1
') or { panic(err) }
    os.chmod(clang_path, 0o700) or { panic(err) }
    link_path := os.join_path(test_root, 'cc')
    os.symlink(clang_path, link_path) or { panic(err) }
    assert resolve_ccompiler_type(link_path, pref.cc_from_string(link_path)) == .clang
}

fn test_ccompiler_type_from_resolved_path_detects_macos_cc_wrapper_as_clang() {
    $if macos {
        detected := ccompiler_type_from_resolved_path('/usr/bin/cc') or { panic(err) }
        assert detected == .clang
    }
}

fn test_setup_ccompiler_options_detects_cl_path_as_msvc() {
    mut full_args := ['']
    full_args << hello_world_example()
    mut prefs, _ := pref.parse_args_and_show_errors([], full_args, false)
    prefs.ccompiler = 'C:/Program Files/Microsoft Visual Studio/cl.exe'
    prefs.ccompiler_type = pref.cc_from_string(prefs.ccompiler)
    mut builder := new_builder(prefs)
    builder.out_name_c = os.join_path(os.vtmp_dir(), 'builder_cc_test.tmp.c')
    builder.setup_ccompiler_options(prefs.ccompiler)
    assert builder.ccoptions.cc == .msvc
}

fn test_msvc_thirdparty_obj_path_uses_cached_location_for_target_arch() {
    obj_file := os.join_path(@VEXEROOT, 'thirdparty', 'mbedtls', 'library', 'bignum.o')
    mut builder64 := new_builder_for_args(['-cc', 'msvc', '-m64', hello_world_example()])
    mut builder32 := new_builder_for_args(['-cc', 'msvc', '-m32', hello_world_example()])
    obj64 := builder64.msvc_thirdparty_obj_path('mbedtls', obj_file, '')
    obj32 := builder32.msvc_thirdparty_obj_path('mbedtls', obj_file, '')
    source_obj := os.real_path(obj_file.all_before_last('.o') + '.obj')
    assert obj64 != obj32
    assert obj64 != source_obj
    assert obj32 != source_obj
    assert obj64.ends_with('.obj')
    assert obj32.ends_with('.obj')
}

fn test_msvc_thirdparty_obj_path_keeps_debug_objects_separate() {
    obj_file := os.join_path(@VEXEROOT, 'thirdparty', 'mbedtls', 'library', 'bignum.o')
    mut release_builder := new_builder_for_args(['-cc', 'msvc', '-m64', hello_world_example()])
    mut debug_builder := new_builder_for_args(['-cc', 'msvc', '-m64', '-g', hello_world_example()])
    release_obj := release_builder.msvc_thirdparty_obj_path('mbedtls', obj_file, '')
    debug_obj := debug_builder.msvc_thirdparty_obj_path('mbedtls', obj_file, '')
    assert debug_obj.ends_with('.debug.obj')
    assert release_obj != debug_obj
}

fn test_sqlite_thirdparty_validation_error_for_missing_amalgamation() {
    obj_path := os.join_path(@VEXEROOT, 'thirdparty', 'sqlite', 'sqlite3.o')
    msg := sqlite_thirdparty_validation_error('db.sqlite', obj_path, '', .unknown)
    assert msg.contains('sqlite3.c')
    assert msg.contains('sqlite3.h')
    assert msg.contains('install_thirdparty_sqlite.vsh')
}

fn test_sqlite_thirdparty_validation_error_for_sqlite3_cpp() {
    obj_path := os.join_path(@VEXEROOT, 'thirdparty', 'sqlite', 'sqlite3.o')
    source_path := obj_path.all_before_last('.o') + '.cpp'
    msg := sqlite_thirdparty_validation_error('db.sqlite', obj_path, source_path, .cpp)
    assert msg.contains('Do not rename `sqlite3.c` to `sqlite3.cpp`')
    assert msg.contains('SQLite amalgamation package')
}

fn test_sqlite_thirdparty_validation_error_ignores_sqlite3_c() {
    obj_path := os.join_path(@VEXEROOT, 'thirdparty', 'sqlite', 'sqlite3.o')
    source_path := obj_path.all_before_last('.o') + '.c'
    assert sqlite_thirdparty_validation_error('db.sqlite', obj_path, source_path, .c) == ''
}

fn test_sqlite_thirdparty_validation_error_ignores_other_modules() {
    obj_path := os.join_path(@VEXEROOT, 'thirdparty', 'sqlite', 'sqlite3.o')
    source_path := obj_path.all_before_last('.o') + '.cpp'
    assert sqlite_thirdparty_validation_error('json.cjson', obj_path, source_path, .cpp) == ''
}

fn test_linux_cross_target_for_amd64() {
    target := linux_cross_target_for_arch(.amd64) or { panic(err) }
    assert target.triple == 'x86_64-linux-gnu'
    assert target.lib_dir == 'x86_64-linux-gnu'
    assert target.dynamic_linker == '/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2'
    assert target.linker_emulation == 'elf_x86_64'
}

fn test_linux_cross_target_for_arm64_errors() {
    if target := linux_cross_target_for_arch(.arm64) {
        assert false, 'unexpected target: ${target}'
    } else {
        assert err.msg().contains('only `-arch amd64`')
        assert err.msg().contains('linuxroot')
    }
}

fn test_git_symlink_target_path_detects_placeholder_file() {
    test_root := os.join_path(os.vtmp_dir(), 'v_builder_git_symlink_target_${os.getpid()}')
    os.rmdir_all(test_root) or {}
    defer {
        os.rmdir_all(test_root) or {}
    }
    lib_dir := os.join_path(test_root, 'lib', 'x86_64-linux-gnu')
    os.mkdir_all(lib_dir)!
    target_file := os.join_path(lib_dir, 'libm-2.31.so')
    placeholder := os.join_path(lib_dir, 'libm.so.6')
    os.write_file(target_file, 'ELF PLACEHOLDER')!
    os.write_file(placeholder, 'libm-2.31.so\n')!
    assert git_symlink_target_path(placeholder) or { panic(err) } == target_file
}

fn test_git_symlink_target_path_ignores_linker_script() {
    test_root := os.join_path(os.vtmp_dir(), 'v_builder_git_symlink_script_${os.getpid()}')
    os.rmdir_all(test_root) or {}
    defer {
        os.rmdir_all(test_root) or {}
    }
    lib_dir := os.join_path(test_root, 'lib', 'x86_64-linux-gnu')
    os.mkdir_all(lib_dir)!
    linker_script := os.join_path(lib_dir, 'libm.so')
    os.write_file(linker_script, '/* GNU ld script */\nGROUP ( /lib/x86_64-linux-gnu/libm.so.6 )\n')!
    assert git_symlink_target_path(linker_script) == none
}

fn test_git_symlink_materialization_source_follows_placeholder_chain() {
    test_root := os.join_path(os.vtmp_dir(), 'v_builder_git_symlink_chain_${os.getpid()}')
    os.rmdir_all(test_root) or {}
    defer {
        os.rmdir_all(test_root) or {}
    }
    lib_dir := os.join_path(test_root, 'lib', 'x86_64-linux-gnu')
    os.mkdir_all(lib_dir)!
    final_target := os.join_path(lib_dir, 'libm-2.31.so')
    first_link := os.join_path(lib_dir, 'libm.so.6')
    second_link := os.join_path(lib_dir, 'libm.so')
    os.write_file(final_target, 'ELF FINAL')!
    os.write_file(first_link, 'libm-2.31.so\n')!
    os.write_file(second_link, 'libm.so.6\n')!
    assert git_symlink_materialization_source(second_link) or { panic(err) } == final_target
}

fn test_repair_cross_sysroot_git_symlink_placeholders_in_paths_materializes_target_copy() {
    test_root := os.join_path(os.vtmp_dir(), 'v_builder_git_symlink_repair_${os.getpid()}')
    os.rmdir_all(test_root) or {}
    defer {
        os.rmdir_all(test_root) or {}
    }
    lib_dir := os.join_path(test_root, 'lib', 'x86_64-linux-gnu')
    os.mkdir_all(lib_dir)!
    final_target := os.join_path(lib_dir, 'libm-2.31.so')
    placeholder := os.join_path(lib_dir, 'libm.so.6')
    final_bytes := 'ELF DATA BINARY'
    os.write_file(final_target, final_bytes)!
    os.write_file(placeholder, 'libm-2.31.so\n')!
    repaired := repair_cross_sysroot_git_symlink_placeholders_in_paths([placeholder], true) or {
        panic(err)
    }
    assert repaired == 1
    assert os.read_file(placeholder)! == final_bytes
}

fn test_msvc_should_use_rsp_for_ascii_args() {
    builder := new_builder_for_args(['-cc', 'msvc', hello_world_example()])
    assert builder.msvc_should_use_rsp(['/OUT:"C:\\Users\\russo\\Desktop\\main.exe"'])
}

fn test_msvc_should_not_use_rsp_for_non_ascii_args() {
    builder := new_builder_for_args(['-cc', 'msvc', hello_world_example()])
    assert !builder.msvc_should_use_rsp([
        '/OUT:"C:\\Users\\russo\\OneDrive\\Рабочий стол\\main.exe"',
    ])
}

fn test_msvc_should_not_use_rsp_when_no_rsp_is_requested() {
    builder := new_builder_for_args(['-cc', 'msvc', '-no-rsp', hello_world_example()])
    assert !builder.msvc_should_use_rsp(['/OUT:"C:\\Users\\russo\\Desktop\\main.exe"'])
}

fn test_live_termux_linker_args_include_rdynamic_without_debug() {
    linker_args := builder_linker_args([
        '-os',
        'termux',
        '-cc',
        'clang',
        '-live',
        hello_world_example(),
    ])
    assert linker_args.contains('-rdynamic')
}

fn test_thirdparty_cross_compile_config_for_linux_matches_target() {
    builder := new_builder_for_args(['-os', 'linux', hello_world_example()])
    cfg := builder.thirdparty_cross_compile_config()
    if current_os == 'linux' {
        assert cfg.sysroot == ''
        assert cfg.target_args == []string{}
        assert cfg.trailing_include_args == []string{}
        return
    }
    assert cfg.target_args == ['-target x86_64-linux-gnu']
    assert normalized_test_path(cfg.sysroot).ends_with('/linuxroot')
    assert cfg.trailing_include_args == [
        '-I',
        os.quoted_path('${cfg.sysroot}/include'),
    ]
}

fn test_thirdparty_cross_compile_config_for_freebsd_matches_target() {
    builder := new_builder_for_args(['-os', 'freebsd', hello_world_example()])
    cfg := builder.thirdparty_cross_compile_config()
    if current_os == 'freebsd' {
        assert cfg.sysroot == ''
        assert cfg.target_args == []string{}
        assert cfg.trailing_include_args == []string{}
        return
    }
    assert cfg.target_args == ['-target x86_64-unknown-freebsd14.0']
    assert normalized_test_path(cfg.sysroot).ends_with('/freebsdroot')
    assert cfg.trailing_include_args == [
        '-I',
        os.quoted_path('${cfg.sysroot}/include'),
        '-I',
        os.quoted_path('${cfg.sysroot}/usr/include'),
    ]
}

fn test_linux_tcc_arm64_stdatomic_does_not_add_atomic_s() {
    $if !linux {
        return
    }
    test_dir := os.join_path(os.vtmp_dir(), 'v_builder_stdatomic_tcc_arm64_${os.getpid()}')
    os.mkdir_all(test_dir) or { panic(err) }
    defer {
        os.rmdir_all(test_dir) or {}
    }
    src_file := os.join_path(test_dir, 'main.v')
    os.write_file(src_file, 'import sync.stdatomic
fn main() {
    mut x := u64(0)
    stdatomic.store_u64(&x, 1)
}
') or {
        panic(err)
    }
    res :=
        os.execute('${os.quoted_path(@VEXE)} -dump-c-flags - -os linux -cc tcc -arch arm64 ${os.quoted_path(src_file)}')
    assert res.exit_code == 0, res.output
    assert !res.output.contains('thirdparty/stdatomic/nix/atomic.S')
    // libatomic.so is only emitted when the host has the aarch64 cross-compile gcc toolchain installed.
    matches := os.glob('/usr/lib/gcc/aarch64-linux-gnu/*/libatomic.so') or { []string{} }
    if matches.len > 0 {
        assert res.output.contains('libatomic.so')
    }
}

fn test_live_windows_main_linker_args_export_host_symbols() {
    linker_args := builder_linker_args_with_cc([
        '-os',
        'windows',
        '-cc',
        'gcc',
        '-live',
        hot_reload_graph_example(),
    ], .gcc)
    assert linker_args.contains('-Wl,--export-all-symbols')
    assert linker_args.contains('-Wl,--out-implib,')
    expected_import_lib := os.file_name(live_windows_import_lib_path(hot_reload_graph_example()))
    assert linker_args.contains(expected_import_lib), 'linker_args should contain ${expected_import_lib}'
}

fn test_live_windows_shared_linker_args_include_host_import_lib() {
    linker_args := builder_linker_args_with_cc([
        '-os',
        'windows',
        '-cc',
        'gcc',
        '-sharedlive',
        '-shared',
        hot_reload_graph_example(),
    ], .gcc)
    expected_import_lib := os.file_name(live_windows_import_lib_path(hot_reload_graph_example()))
    assert linker_args.contains(expected_import_lib), 'linker_args should contain ${expected_import_lib}'
}

fn test_windows_cross_compile_args_match_shared_prod_args() {
    $if windows {
        return
    }
    mut builder := new_test_builder(['-os', 'windows', '-prod', hello_world_example()])
    all_args := builder.windows_cross_compile_args('')
    assert all_args == builder.all_args(builder.ccoptions)
    assert all_args.contains('-O3')
    assert all_args.contains('-fwrapv')
    assert all_args.contains('-fno-strict-aliasing')
    assert all_args.contains('-DNDEBUG')
    assert all_args.contains('-DNO_DEBUGGING')
}

fn test_shared_windows_builds_do_not_add_subsystem_flags() {
    mut builder := new_test_builder(['-os', 'windows', '-shared', hello_world_example()])
    assert builder.get_subsystem_flag() == ''
    compile_args := builder.get_compile_args().join(' ')
    assert !compile_args.contains('-municode')
    assert !compile_args.contains('-mwindows')
    assert !compile_args.contains('-mconsole')
}

fn test_windows_gcc_compile_args_force_generated_source_to_c_mode() {
    compile_args := builder_compile_args(['-os', 'windows', '-cc', 'gcc', hello_world_example()])
    assert compile_args.contains('-x c')
}

fn test_shared_tcc_compile_args_skip_bt25_after_late_compiler_resolution() {
    mut full_args := ['']
    full_args << ['-shared', hello_world_example()]
    mut prefs, _ := pref.parse_args_and_show_errors([], full_args, false)
    prefs.ccompiler = 'tcc'
    prefs.ccompiler_type = .tinyc
    prefs.normalize_gc_defaults_for_resolved_ccompiler()
    assert 'no_backtrace' in prefs.compile_defines_all

    mut builder := new_builder(prefs)
    builder.out_name_c = os.join_path(os.vtmp_dir(), 'builder_cc_test.tmp.c')
    builder.setup_ccompiler_options(prefs.ccompiler)

    assert !builder.get_compile_args().contains('-bt25')
}

fn test_linux_shared_boehm_linker_args_hide_static_gc_archive_symbols() {
    linker_args := builder_linker_args_with_cc([
        '-os',
        'linux',
        '-shared',
        '-gc',
        'boehm',
        hello_world_example(),
    ], .gcc)
    assert linker_args.contains('-Wl,-Bsymbolic')
    assert linker_args.contains('-Wl,--exclude-libs,ALL')
}

fn test_linux_shared_boehm_tcc_linker_args_skip_gnu_exclude_libs() {
    linker_args := builder_linker_args_with_cc([
        '-os',
        'linux',
        '-shared',
        '-gc',
        'boehm',
        hello_world_example(),
    ], .tcc)
    assert linker_args.contains('-Wl,-Bsymbolic')
    assert !linker_args.contains('-Wl,--exclude-libs,ALL')
}

fn test_should_use_rsp_for_linux_by_default() {
    builder := new_test_builder([hello_world_example()])
    assert builder.should_use_rsp(['-o', builder.out_name_c])
}

fn test_should_not_use_rsp_for_termux() {
    builder := new_test_builder(['-os', 'termux', hello_world_example()])
    assert !builder.should_use_rsp(['-o', builder.out_name_c])
}

fn test_should_not_use_rsp_for_args_with_embedded_single_quotes() {
    builder := new_test_builder([hello_world_example()])
    assert !builder.should_use_rsp(["'\\''"])
}

fn test_setup_ccompiler_options_detects_cc_alias_path_as_clang() {
    $if windows {
        return
    }
    test_root := os.join_path(os.vtmp_dir(), 'v_builder_cc_setup_${os.getpid()}')
    alias_cc := prepare_test_ccompiler_alias(test_root, 'cc', 'OpenBSD clang version 16.0.6')
    defer {
        os.rmdir_all(test_root) or {}
    }
    mut full_args := ['']
    full_args << hello_world_example()
    mut prefs, _ := pref.parse_args_and_show_errors([], full_args, false)
    prefs.ccompiler = alias_cc
    prefs.ccompiler_type = pref.cc_from_string(prefs.ccompiler)
    mut builder := new_builder(prefs)
    builder.out_name_c = os.join_path(os.vtmp_dir(), 'builder_cc_test.tmp.c')
    builder.setup_ccompiler_options(prefs.ccompiler)
    assert builder.pref.ccompiler_type == .clang
    assert builder.ccoptions.cc == .clang
}

fn macos_compile_args(args []string) string {
    return builder_compile_args(args)
}

fn builder_compile_args(args []string) string {
    builder := new_test_builder(args)
    return builder.get_compile_args().join(' ')
}

fn builder_linker_args(args []string) string {
    builder := new_test_builder(args)
    return builder.get_linker_args().join(' ')
}

fn builder_linker_args_with_cc(args []string, cc CC) string {
    mut builder := new_test_builder_without_cc_setup(args)
    ccompiler := ccompiler_name_for_test_cc(cc)
    builder.pref.ccompiler = ccompiler
    builder.pref.ccompiler_type = pref.cc_from_string(ccompiler)
    builder.setup_ccompiler_options(ccompiler)
    builder.setup_output_name()
    return builder.get_linker_args().join(' ')
}

fn new_test_builder(args []string) Builder {
    mut builder := new_test_builder_without_cc_setup(args)
    builder.setup_ccompiler_options(builder.pref.ccompiler)
    builder.setup_output_name()
    return builder
}

fn new_test_builder_without_cc_setup(args []string) Builder {
    mut full_args := ['']
    full_args << args
    prefs, _ := pref.parse_args_and_show_errors([], full_args, false)
    mut builder := new_builder(prefs)
    builder.out_name_c = os.join_path(os.vtmp_dir(), 'builder_cc_test.tmp.c')
    return builder
}

fn ccompiler_name_for_test_cc(cc CC) string {
    return match cc {
        .tcc { 'tcc' }
        .gcc { 'gcc' }
        .icc { 'icc' }
        .msvc { 'msvc' }
        .clang { 'clang' }
        .emcc { 'emcc' }
        .unknown { '' }
    }
}

fn new_builder_for_args(args []string) Builder {
    mut full_args := ['']
    full_args << args
    prefs, _ := pref.parse_args_and_show_errors([], full_args, false)
    return new_builder(prefs)
}

fn macos_version_min_flags(compile_args string) []string {
    return compile_args.split(' ').filter(it.starts_with('-mmacosx-version-min='))
}

fn hello_world_example() string {
    return os.join_path(@VEXEROOT, 'examples', 'hello_world.v')
}

fn hot_reload_graph_example() string {
    return os.join_path(@VEXEROOT, 'examples', 'hot_reload', 'graph.v')
}

fn normalized_test_path(path string) string {
    mut normalized := path.replace('\\', '/')
    for normalized.contains('//') {
        normalized = normalized.replace('//', '/')
    }
    return normalized
}

fn test_c_output_suggests_missing_typedef_for_c_struct_with_issue_19050_output() {
    c_output := [
        "/tmp/v_501/c_struct.6580681062929530137.tmp.c:12966:17: error: incomplete result type 'struct string_c' in function definition",
        'struct string_c main__convert(string s) {',
        '                ^',
        "/tmp/v_501/c_struct.6580681062929530137.tmp.c:1962:8: note: forward declaration of 'struct string_c'",
        'struct string_c main__convert(string s);',
        '       ^',
        "/tmp/v_501/c_struct.6580681062929530137.tmp.c:12967:25: error: variable has incomplete type 'struct string_c'",
        '        struct string_c _t1 = ((struct string_c){.content = s.str,.len = ((u32)(s.len)),});',
        '                               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~',
    ].join('\n')
    assert c_output_suggests_missing_typedef_for_c_struct(c_output, {
        'string_c': true
    }) == 'string_c'
}

fn test_c_output_suggests_missing_typedef_for_c_struct_requires_matching_redeclaration() {
    c_output := [
        "/tmp/v_501/c_struct.tmp.c:1:1: error: incomplete result type 'struct string_c' in function definition",
        "/tmp/v_501/c_struct.tmp.c:2:1: note: forward declaration of 'struct string_c'",
    ].join('\n')
    assert c_output_suggests_missing_typedef_for_c_struct(c_output, {
        'other_c_struct': true
    }) == ''
}

fn test_c_output_suggests_missing_typedef_for_c_struct_with_issue_17101_output() {
    c_output := [
        "C:\\Users\\USER\\AppData\\Local\\Temp\\v_0\\main2.3589850650208729523.tmp.c:12338:99: error: 'tilengine__TLN_Affine' {aka 'struct TLN_Affine'} has no member named 'angle'",
        '12338 |         tilengine__TLN_Affine* affine = ((tilengine__TLN_Affine*)memdup(&(tilengine__TLN_Affine){.angle = 10,.dx = 1,.dy = 1,.sx = 1,.sy = 1,}, sizeof(tilengine__TLN_Affine)));',
        '      |                                                                                                   ^~~~~',
    ].join('\n')
    assert c_output_suggests_missing_typedef_for_c_struct(c_output, {
        'TLN_Affine': true
    }) == 'TLN_Affine'
}

fn test_extract_quoted_identifier_supports_double_quotes() {
    assert extract_quoted_identifier('error: \';\' expected (got "glfw__GLFWwindow")') == 'glfw__GLFWwindow'
}

fn test_c_output_suggests_missing_header_for_typedef_c_struct_with_issue_25384_tcc_output() {
    c_output := 'C:/Users/si_z_/AppData/Local/Temp/v_0/TestV.tmp.c:904: error: \';\' expected (got "glfw__GLFWwindow")'
    assert c_output_suggests_missing_header_for_typedef_c_struct(c_output, {
        'GLFWwindow': true
    }, {
        'glfw__GLFWwindow': 'GLFWwindow'
    }) == 'GLFWwindow'
}

fn test_c_output_suggests_missing_header_for_typedef_c_struct_with_issue_25384_gcc_output() {
    c_output := [
        "/tmp/v_502/issue25384_windows.exe.tmp.c:1198:9: error: unknown type name 'GLFWwindow'",
        ' 1198 | typedef GLFWwindow glfw__GLFWwindow;',
    ].join('\n')
    assert c_output_suggests_missing_header_for_typedef_c_struct(c_output, {
        'GLFWwindow': true
    }, {
        'glfw__GLFWwindow': 'GLFWwindow'
    }) == 'GLFWwindow'
}

fn test_c_output_suggests_missing_header_for_typedef_c_struct_requires_known_type() {
    c_output := 'C:/Users/si_z_/AppData/Local/Temp/v_0/TestV.tmp.c:904: error: \';\' expected (got "glfw__GLFWwindow")'
    assert c_output_suggests_missing_header_for_typedef_c_struct(c_output, {}, {}) == ''
}

fn test_c_output_suggests_missing_header_for_typedef_c_struct_with_issue_23648_tcc_output() {
    c_output := 'D:/Temp/Temp/v_0/main.tmp.c:1028: error: \';\' expected (got "duarteroso__glfw__GLFWmonitor")'
    assert c_output_suggests_missing_header_for_typedef_c_struct(c_output, {
        'GLFWmonitor': true
    }, {}) == 'GLFWmonitor'
}

fn test_c_error_missing_library_name_detects_tcc_output() {
    tcc_output := "tcc: error: library 'pq' not found"
    lib_name := c_error_missing_library_name(tcc_output)
    assert lib_name == 'pq'
}

fn test_c_error_missing_libatomic_marker_with_tcc_output() {
    c_output := "/tmp/v/vdoc.tmp.c:24184: warning: assignment makes pointer from integer without a cast\ntcc: error: library 'atomic' not found\n"
    assert c_error_missing_libatomic_marker(c_output) == "library 'atomic' not found"
    assert c_error_looks_like_missing_libatomic(c_output)
}

fn test_c_error_missing_libatomic_marker_with_ld_output() {
    c_output := '/usr/bin/ld: cannot find -latomic\ncollect2: error: ld returned 1 exit status\n'
    assert c_error_missing_libatomic_marker(c_output) == 'cannot find -latomic'
    assert c_error_looks_like_missing_libatomic(c_output)
}

fn test_c_error_missing_libatomic_marker_with_regular_c_error() {
    c_output := "error: unknown type name 'my_missing_type'"
    assert c_error_missing_libatomic_marker(c_output) == ''
    assert !c_error_looks_like_missing_libatomic(c_output)
}

fn test_c_error_missing_library_name_with_macos_ld_output() {
    c_output := "ld: library 'mbedtls' not found\nclang: error: linker command failed with exit code 1\n"
    assert c_error_missing_library_name(c_output) == 'mbedtls'
}

fn test_c_error_missing_library_name_with_gnu_ld_output() {
    c_output := '/usr/bin/ld: cannot find -lssl\ncollect2: error: ld returned 1 exit status\n'
    assert c_error_missing_library_name(c_output) == 'ssl'
}

fn test_c_error_missing_library_name_with_mingw_ld_output() {
    c_output := 'C:/msys64/ucrt64/bin/ld.exe: cannot find libv_missing_lib_25499.dll.a: No such file or directory\ncollect2.exe: error: ld returned 1 exit status\n'
    assert c_error_missing_library_name(c_output) == 'v_missing_lib_25499'
}

fn test_c_error_missing_library_name_with_mingw_lflag_suffix_output() {
    c_output := 'C:/msys64/ucrt64/bin/ld.exe: cannot find -lv_missing_lib_25499.dll.a: No such file or directory\ncollect2.exe: error: ld returned 1 exit status\n'
    assert c_error_missing_library_name(c_output) == 'v_missing_lib_25499'
}

fn test_c_error_missing_library_name_with_mingw_plain_library_output() {
    c_output := 'C:/msys64/ucrt64/bin/ld.exe: cannot find v_missing_lib_25499: No such file or directory\ncollect2.exe: error: ld returned 1 exit status\n'
    assert c_error_missing_library_name(c_output) == 'v_missing_lib_25499'
}

fn test_c_error_missing_library_name_with_mingw_driver_missing_file_output() {
    c_output := 'x86_64-w64-mingw32-gcc.exe: error: libv_missing_lib_25499.dll.a: No such file or directory\n'
    assert c_error_missing_library_name(c_output) == 'v_missing_lib_25499'
}

fn test_c_error_missing_library_name_ignores_missing_object_file() {
    c_output := '/usr/bin/ld: cannot find crt1.o: No such file or directory\ncollect2: error: ld returned 1 exit status\n'
    assert c_error_missing_library_name(c_output) == ''
}

fn test_c_error_missing_library_name_with_regular_c_error() {
    c_output := "error: unknown type name 'my_missing_type'"
    assert c_error_missing_library_name(c_output) == ''
}

fn test_c_error_should_send_bug_report_skips_libatomic() {
    c_output := '/usr/bin/ld: cannot find -latomic\ncollect2: error: ld returned 1 exit status\n'
    assert !c_error_should_send_bug_report(c_output)
}

fn test_c_error_should_send_bug_report_skips_missing_library() {
    c_output := '/usr/bin/ld: cannot find -lllvm\ncollect2: error: ld returned 1 exit status\n'
    assert !c_error_should_send_bug_report(c_output)
}

fn test_c_error_should_send_bug_report_for_regular_c_error() {
    c_output := "error: unknown type name 'my_missing_type'"
    assert c_error_should_send_bug_report(c_output)
}

fn test_thirdparty_module_root_spans_library_and_include() {
    // A source under library/ resolves to the whole `thirdparty/<mod>` root, so a
    // sibling include/ tree (e.g. mbedtls config headers) is in scope when
    // computing the object's header-dependency mtime.
    assert thirdparty_module_root('/x/y/thirdparty/mbedtls/library/aes.c') == '/x/y/thirdparty/mbedtls'
    // Windows-style separators are normalized to forward slashes.
    assert thirdparty_module_root('S:\\repo\\thirdparty\\mbedtls\\include\\mbedtls\\cfg.h') == 'S:/repo/thirdparty/mbedtls'
    // A path that is not under a thirdparty/ tree falls back to the source dir.
    assert thirdparty_module_root('/tmp/foo/bar.c') == os.dir('/tmp/foo/bar.c')
}

// Regression guard for vlang/v#27437: thirdparty objects must rebuild when a
// header anywhere in the module changes, including config headers under
// include/ (not just siblings of the .c). thirdparty_deps_mtime is the shared
// cache key for both the C and MSVC object paths, so this protects both.
fn test_thirdparty_deps_mtime_includes_module_include_headers() {
    test_root := os.join_path(os.vtmp_dir(), 'v_builder_thirdparty_deps_${os.getpid()}')
    os.rmdir_all(test_root) or {}
    defer {
        os.rmdir_all(test_root) or {}
    }
    lib_dir := os.join_path(test_root, 'thirdparty', 'mymod', 'library')
    inc_dir := os.join_path(test_root, 'thirdparty', 'mymod', 'include', 'mymod')
    os.mkdir_all(lib_dir) or { panic(err) }
    os.mkdir_all(inc_dir) or { panic(err) }
    source := os.join_path(lib_dir, 'foo.c')
    sibling := os.join_path(lib_dir, 'foo.h')
    os.write_file(source, 'int foo(void){return 0;}') or { panic(err) }
    os.write_file(sibling, '/* sibling header */') or { panic(err) }
    // file_last_mod_unix is second-resolution, so a >1s gap is needed for the
    // config header to be observably newer than the source.
    time.sleep(1100 * time.millisecond)
    config := os.join_path(inc_dir, 'mymod_config.h')
    os.write_file(config, '#define MYMOD 1') or { panic(err) }

    mut b := new_builder_for_args([hello_world_example()])
    deps := b.thirdparty_deps_mtime(source)
    config_mtime := os.file_last_mod_unix(config)
    source_mtime := os.file_last_mod_unix(source)
    assert config_mtime > source_mtime, 'precondition: the include/ config header must be newer than the source'
    // The config header lives under include/, not in the source directory, yet
    // the dependency mtime must still reflect it — otherwise stale objects are
    // reused after a config-header change (the bug this fix addresses).
    assert deps == config_mtime, 'thirdparty_deps_mtime must fold in include/ headers; got ${deps}, want ${config_mtime}'
    // Memoized per module root: a second call returns the same value.
    assert b.thirdparty_deps_mtime(source) == config_mtime
}

fn prepare_test_ccompiler_alias(test_root string, compiler_name string, version_output string) string {
    os.rmdir_all(test_root) or {}
    os.mkdir_all(test_root) or { panic(err) }
    compiler_path := os.join_path(test_root, compiler_name)
    os.write_file(compiler_path, '#!/bin/sh
if [ "\$1" = "--version" ] || [ "\$1" = "-v" ]; then
    echo "${version_output}"
    exit 0
fi
exit 1
') or {
        panic(err)
    }
    os.chmod(compiler_path, 0o700) or { panic(err) }
    return compiler_path
}