import v.pref
import v.vmod
import os

const vexe = @VEXE
const vroot = os.dir(vexe)

fn test_check_parametes() {
    // reproducing issue https://github.com/vlang/v/issues/13983
    _, cmd := pref.parse_args_and_show_errors(['help'], [''], true)
    // no command found from args
    assert cmd == ''
}

fn test_version_flag() {
    v_ver := vmod.from_file(os.join_path(vroot, 'v.mod'))!.version
    v_ver_cmd_res := os.execute_opt('${vexe} --version')!.output
    assert v_ver_cmd_res.starts_with('V ${v_ver}'), v_ver_cmd_res

    v_retry_ver_cmd_res := os.execute_opt('${vexe} retry --version')!.output
    assert v_retry_ver_cmd_res != v_ver_cmd_res

    v_git_ver_subcmd_res := os.execute_opt('${vexe} retry -- git --version')!.output
    assert v_git_ver_subcmd_res !in [v_ver_cmd_res, v_retry_ver_cmd_res]

    // Test version / verbosity toggle.
    assert os.execute_opt('${vexe} -v')!.output == v_ver_cmd_res
    assert os.execute_opt('${vexe} -cc tcc -v')!.output == v_ver_cmd_res

    example_path := os.join_path(vroot, 'examples', 'hello_world.v')
    v_verbose_cmd_res := os.execute_opt('${vexe} -v run ${example_path}')!.output
    assert v_verbose_cmd_res != v_ver_cmd_res
    assert v_verbose_cmd_res.contains('v.pref.lookup_path:')

    v_verbose_cmd_with_additional_args_res := os.execute_opt('${vexe} -g -v run ${example_path}')!.output
    assert v_verbose_cmd_with_additional_args_res != v_ver_cmd_res
    assert v_verbose_cmd_with_additional_args_res.contains('v.pref.lookup_path:')
}

fn test_cross_compile_keeps_explicit_cc() {
    target_os := if pref.get_host_os() == .linux { 'macos' } else { 'linux' }
    custom_cc := 'cosmocc'

    first, _ := pref.parse_args_and_show_errors(['help'], ['', '-cc', custom_cc, '-os', target_os],
        false)
    assert first.ccompiler_set_by_flag
    assert first.ccompiler == custom_cc

    second, _ := pref.parse_args_and_show_errors(['help'],
        ['', '-os', target_os, '-cc', custom_cc], false)
    assert second.ccompiler_set_by_flag
    assert second.ccompiler == custom_cc
}

fn test_mac_is_alias_for_macos() {
    os_kind := pref.os_from_string('mac') or {
        assert false, err.msg()
        return
    }
    assert os_kind == .macos
    assert pref.OS.macos.is_target_of('mac')
    assert !pref.OS.linux.is_target_of('mac')
}

fn test_bsd_target_matches_macos_and_bsd_systems() {
    for os_kind in [pref.OS.macos, .freebsd, .openbsd, .netbsd, .dragonfly] {
        assert os_kind.is_target_of('bsd')
    }
    assert !pref.OS.linux.is_target_of('bsd')
    assert !pref.OS.windows.is_target_of('bsd')
}

fn test_disable_explicit_mutability_flag() {
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    prefs, _ := pref.parse_args_and_show_errors([], ['-disable-explicit-mutability', target], false)
    assert prefs.disable_explicit_mutability
    assert prefs.build_options.contains('-disable-explicit-mutability')

    prefs2, _ := pref.parse_args_and_show_errors([], ['--disable-explicit-mutability', target],
        false)
    assert prefs2.disable_explicit_mutability
    assert prefs2.build_options.contains('--disable-explicit-mutability')
}

fn test_profile_flag_does_not_consume_direct_compile_target() {
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    prefs, command := pref.parse_args_and_show_errors([], ['-profile', target], false)
    assert command == target
    assert prefs.path == target
    assert prefs.is_prof
    assert prefs.profile_file == '-'
}

fn test_profile_flag_does_not_consume_run_command() {
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    prefs, command := pref.parse_args_and_show_errors([], ['-profile', 'run', target], false)
    assert command == 'run'
    assert prefs.path == target
    assert prefs.is_run
    assert prefs.is_prof
    assert prefs.profile_file == '-'
}

fn test_profile_flag_still_accepts_explicit_output_file() {
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    prefs, command := pref.parse_args_and_show_errors([], ['-profile', 'profile.txt', target],
        false)
    assert command == target
    assert prefs.path == target
    assert prefs.is_prof
    assert prefs.profile_file == 'profile.txt'
}

fn new_wasm_preferences() pref.Preferences {
    return pref.Preferences{
        backend: .wasm
        os:      .browser
        arch:    .wasm32
    }
}

fn new_c_preferences() pref.Preferences {
    return pref.Preferences{
        backend: .c
        os:      .linux
        arch:    .amd64
    }
}

fn test_c_backend_filters_backend_specific_files() {
    prefs := new_c_preferences()
    dir := os.join_path(os.vtmp_dir(), 'c_backend_filters')
    filtered := prefs.should_compile_filtered_files(dir, [
        'mod.c.v',
        'mod.js.v',
        'mod.v',
        'mod.wasm.v',
    ])
    assert filtered == [
        os.join_path(dir, 'mod.c.v'),
        os.join_path(dir, 'mod.v'),
    ]
}

fn test_c_backend_skips_modules_with_only_non_c_variants() {
    prefs := new_c_preferences()
    filtered := prefs.should_compile_filtered_files('sus', ['sus.js.v', 'sus.wasm.v'])
    assert filtered.len == 0
}

fn test_wasm_backend_filters_backend_specific_files() {
    prefs := new_wasm_preferences()
    dir := os.join_path(os.vtmp_dir(), 'wasm_backend_filters')
    filtered := prefs.should_compile_filtered_files(dir, [
        'mod.c.v',
        'mod.js.v',
        'mod.v',
        'mod.wasm.v',
    ])
    assert filtered == [
        os.join_path(dir, 'mod.v'),
        os.join_path(dir, 'mod.wasm.v'),
    ]
}

fn test_wasm_backend_skips_modules_with_only_c_and_js_variants() {
    prefs := new_wasm_preferences()
    filtered := prefs.should_compile_filtered_files('sus', ['sus.c.v', 'sus.js.v'])
    assert filtered.len == 0
}

fn filtered_file_names_for_os(os_kind pref.OS, files []string) []string {
    prefs := pref.Preferences{
        os: os_kind
    }
    dir := os.join_path(os.vtmp_dir(), 'environment_specific_files')
    mut res := []string{}
    for file in prefs.should_compile_filtered_files(dir, files) {
        res << os.base(file)
    }
    return res
}

fn test_bsd_specific_files_are_filtered_by_target_os() {
    for os_kind in [pref.OS.macos, .freebsd, .openbsd, .netbsd, .dragonfly] {
        assert filtered_file_names_for_os(os_kind, ['mod_bsd.c.v', 'mod_bsd.v']) == [
            'mod_bsd.c.v',
            'mod_bsd.v',
        ]
    }
    assert filtered_file_names_for_os(.linux, ['mod_bsd.c.v', 'mod_bsd.v']).len == 0
    assert filtered_file_names_for_os(.windows, ['mod_bsd.c.v', 'mod_bsd.v']).len == 0
}

fn test_bsd_specific_files_prefer_more_specific_variants() {
    mut files := [
        'main.v',
        'something_default.c.v',
        'something_windows.c.v',
    ]
    assert filtered_file_names_for_os(.freebsd, files) == ['main.v', 'something_default.c.v']

    files << 'something_nix.c.v'
    assert filtered_file_names_for_os(.freebsd, files) == ['main.v', 'something_nix.c.v']

    files << 'something_bsd.c.v'
    assert filtered_file_names_for_os(.freebsd, files) == ['main.v', 'something_bsd.c.v']

    files << 'something_freebsd.c.v'
    assert filtered_file_names_for_os(.freebsd, files) == ['main.v', 'something_freebsd.c.v']
}

fn test_bsd_specific_files_prefer_darwin_on_macos() {
    files := [
        'main.v',
        'something_nix.c.v',
        'something_bsd.v',
        'something_darwin.v',
    ]
    assert filtered_file_names_for_os(.macos, files) == ['main.v', 'something_darwin.v']
}

fn test_explicit_gc_mode_is_forwarded_to_build_module() {
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    for gc_mode in ['none', 'boehm', 'boehm_full', 'boehm_incr', 'boehm_full_opt', 'boehm_incr_opt',
        'boehm_leak'] {
        prefs, _ := pref.parse_args_and_show_errors([], ['-usecache', '-gc', gc_mode, target],
            false)
        assert prefs.build_options.contains('-gc ${gc_mode}')
    }
}

fn test_cross_compile_defaults_windows_to_the_cross_compiler_arch() {
    if pref.get_host_os() == .windows {
        return
    }
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    prefs, _ := pref.parse_args_and_show_errors([], ['', '-os', 'windows', target], false)
    assert prefs.arch == .amd64
    assert prefs.ccompiler == 'x86_64-w64-mingw32-gcc'
}

fn test_cross_compile_windows_m32_uses_i386_arch_and_compiler() {
    if pref.get_host_os() == .windows {
        return
    }
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    prefs, _ := pref.parse_args_and_show_errors([], ['', '-os', 'windows', '-m32', target], false)
    assert !prefs.m64
    assert prefs.arch == .i386
    assert prefs.ccompiler == 'i686-w64-mingw32-gcc'
    assert prefs.build_options.contains('-m32')
}

fn test_cross_compile_defaults_linux_to_amd64() {
    if pref.get_host_os() == .linux {
        return
    }
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    prefs, _ := pref.parse_args_and_show_errors([], ['', '-os', 'linux', target], false)
    assert prefs.arch == .amd64
    assert prefs.ccompiler == 'clang'
}

fn test_cross_compile_infers_android_arch_from_vcross_compiler_name() {
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    old_cross_compiler := os.getenv('VCROSS_COMPILER_NAME')
    defer {
        os.setenv('VCROSS_COMPILER_NAME', old_cross_compiler, true)
    }
    for compiler_name, expected_arch in {
        'aarch64-linux-android21-clang':    pref.Arch.arm64
        'armv7a-linux-androideabi21-clang': pref.Arch.arm32
        'i686-linux-android21-clang':       pref.Arch.i386
        'x86_64-linux-android21-clang':     pref.Arch.amd64
    } {
        os.setenv('VCROSS_COMPILER_NAME', compiler_name, true)
        prefs, _ := pref.parse_args_and_show_errors([], ['', '-os', 'android', target], false)
        assert prefs.arch == expected_arch
        assert prefs.ccompiler == compiler_name
    }
}

fn test_musl_defaults_to_no_gc() {
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    prefs, _ := pref.parse_args_and_show_errors([], ['', '-musl', target], false)
    assert prefs.is_musl
    assert prefs.gc_mode == .no_gc
}

fn test_musl_keeps_explicit_gc_selection() {
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    prefs, _ := pref.parse_args_and_show_errors([], ['', '-musl', '-gc', 'boehm', target], false)
    assert prefs.is_musl
    assert prefs.gc_mode == .boehm_full_opt
}

fn test_prealloc_defaults_to_no_gc() {
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    prefs, _ := pref.parse_args_and_show_errors([], ['', '-prealloc', target], false)
    assert prefs.prealloc
    assert prefs.gc_mode == .no_gc
}

fn test_prealloc_overrides_explicit_gc_selection() {
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    prefs, _ := pref.parse_args_and_show_errors([], ['', '-gc', 'boehm', '-prealloc', target],
        false)
    assert prefs.prealloc
    assert prefs.gc_mode == .no_gc
    assert 'gcboehm' !in prefs.compile_defines
    assert prefs.build_options.join(' ').contains('-gc none')
}

fn stale_windows_gc_prefs(gc_set_by_flag bool) pref.Preferences {
    mut prefs := pref.Preferences{
        os:                  .windows
        ccompiler_type:      .msvc
        gc_mode:             .boehm_full_opt
        gc_set_by_flag:      gc_set_by_flag
        compile_defines:     ['gcboehm', 'gcboehm_full', 'gcboehm_opt', 'custom']
        compile_defines_all: ['gcboehm', 'gcboehm_full', 'gcboehm_opt', 'custom']
        compile_values:      map[string]string{}
        build_options:       ['-prod', '-d gcboehm', '-d gcboehm_full', '-d gcboehm_opt']
    }
    prefs.compile_values['gcboehm'] = 'true'
    prefs.compile_values['gcboehm_full'] = 'true'
    prefs.compile_values['gcboehm_opt'] = 'true'
    prefs.compile_values['custom'] = 'true'
    return prefs
}

fn test_windows_msvc_gc_defaults_are_cleared_after_compiler_resolution() {
    mut prefs := stale_windows_gc_prefs(false)

    prefs.normalize_gc_defaults_for_resolved_ccompiler()

    assert prefs.gc_mode == .no_gc
    assert prefs.build_options == ['-prod', '-gc', 'none']
    assert prefs.compile_defines == ['custom']
    assert prefs.compile_defines_all == ['custom']
    assert prefs.compile_values == {
        'custom': 'true'
    }
}

fn test_windows_msvc_gc_defaults_keep_explicit_gc_selection() {
    mut prefs := stale_windows_gc_prefs(true)
    prefs.build_options = ['-prod', '-gc', 'boehm', '-d gcboehm', '-d gcboehm_full', '-d gcboehm_opt']

    prefs.normalize_gc_defaults_for_resolved_ccompiler()

    assert prefs.gc_mode == .boehm_full_opt
    assert prefs.build_options == ['-prod', '-gc', 'boehm', '-d gcboehm', '-d gcboehm_full',
        '-d gcboehm_opt']
    assert prefs.compile_defines == ['gcboehm', 'gcboehm_full', 'gcboehm_opt', 'custom']
    assert prefs.compile_defines_all == ['gcboehm', 'gcboehm_full', 'gcboehm_opt', 'custom']
    assert prefs.compile_values == {
        'custom':       'true'
        'gcboehm':      'true'
        'gcboehm_full': 'true'
        'gcboehm_opt':  'true'
    }
}

fn test_m32_sets_i386_arch_when_not_explicitly_set() {
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    prefs, _ := pref.parse_args_and_show_errors([], ['', '-m32', target], false)
    assert !prefs.m64
    assert prefs.arch == .i386
    assert prefs.build_options.contains('-m32')
}

fn test_m32_does_not_override_explicit_arch() {
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    prefs, _ := pref.parse_args_and_show_errors([], ['', '-arch', 'amd64', '-m32', target], false)
    assert !prefs.m64
    assert prefs.arch == .amd64
    assert prefs.build_options.contains('-m32')
}

fn test_v_cmds_and_flags() {
    build_cmd_res := os.execute('${vexe} build ${vroot}/examples/hello_world.v')
    assert build_cmd_res.output.trim_space() == 'Use `v ${vroot}/examples/hello_world.v` instead.'

    too_many_targets_res :=
        os.execute('${vexe} ${vroot}/examples/hello_world.v ${vroot}/examples/fizz_buzz.v')
    assert too_many_targets_res.output.trim_space() == 'Too many targets. Specify just one target: <target.v|target_directory>.'

    unknown_arg_res := os.execute('${vexe} -xyz')
    assert unknown_arg_res.output.trim_space() == 'Unknown argument `-xyz`'

    unknown_arg_for_cmd_res := os.execute('${vexe} build-module -xyz ${vroot}/vlib/math')
    assert unknown_arg_for_cmd_res.output.trim_space() == 'Unknown argument `-xyz` for command `build-module`'

    eval_removed_message := 'use v -v2 -eval file.v'
    eval_flag_res := os.execute('${vexe} -eval ${vroot}/examples/hello_world.v')
    assert eval_flag_res.exit_code == 1
    assert eval_flag_res.output.trim_space() == eval_removed_message

    eval_backend_res := os.execute('${vexe} -backend eval ${vroot}/examples/hello_world.v')
    assert eval_backend_res.exit_code == 1
    assert eval_backend_res.output.trim_space() == eval_removed_message

    interpret_flag_res := os.execute('${vexe} -interpret ${vroot}/examples/hello_world.v')
    assert interpret_flag_res.exit_code == 1
    assert interpret_flag_res.output.trim_space() == eval_removed_message

    interpret_command_res := os.execute('${vexe} interpret ${vroot}/examples/hello_world.v')
    assert interpret_command_res.exit_code == 1
    assert interpret_command_res.output.trim_space() == eval_removed_message

    no_run_files_res := os.execute('${vexe} run')
    assert no_run_files_res.output.trim_space() == 'v run: no v files listed'

    no_bm_files_res := os.execute('${vexe} build-module')
    assert no_bm_files_res.output.trim_space() == 'v build-module: no module specified'
}

fn test_build_command_compiles_vsh_without_running_it() {
    test_dir := os.join_path(os.vtmp_dir(), 'v_pref_build_vsh_${os.getpid()}')
    os.rmdir_all(test_dir) or {}
    os.mkdir_all(test_dir)!
    defer {
        os.rmdir_all(test_dir) or {}
    }
    script_path := os.join_path(test_dir, 'build_only.vsh')
    marker_path := os.join_path(test_dir, 'marker.txt')
    mut exe_path := os.join_path(test_dir, 'build_only')
    $if windows {
        exe_path += '.exe'
    }
    os.write_file(script_path, "import os

fn main() {
    marker_path := os.join_path(@DIR, 'marker.txt')
    os.write_file(marker_path, 'ran') or { panic(err) }
    println('ran')
}
")!
    build_res := os.execute('${os.quoted_path(vexe)} -silent build ${os.quoted_path(script_path)}')
    assert build_res.exit_code == 0, build_res.output
    assert build_res.output == ''
    assert !os.exists(marker_path)
    assert os.is_file(exe_path)

    run_res := os.execute(os.quoted_path(exe_path))
    assert run_res.exit_code == 0, run_res.output
    assert run_res.output.trim_space() == 'ran'
    assert os.read_file(marker_path)! == 'ran'
}

const tfile = os.join_path(os.vtmp_dir(), 'unknown_options_output.c')

fn test_unknown_option_flags_no_run() {
    os.chdir(os.dir(@VEXE))!
    os.rm(tfile) or {}

    res1 :=
        os.execute('${os.quoted_path(@VEXE)} -o ${os.quoted_path(tfile)} examples/hello_world.v --an-unknown-option')
    assert res1.exit_code == 1, res1.output
    assert res1.output.starts_with('Unknown argument')
    assert res1.output.contains('--an-unknown-option')
    assert !os.exists(tfile)

    res2 :=
        os.execute('${os.quoted_path(@VEXE)} -o ${os.quoted_path(tfile)} --an-unknown-option examples/hello_world.v')
    assert res2.exit_code == 1, res2.output
    assert res2.output.starts_with('Unknown argument')
    assert res2.output.contains('--an-unknown-option')
    assert !os.exists(tfile)
}

fn test_unknown_option_flags_with_run() {
    res_run_o :=
        os.execute('${os.quoted_path(@VEXE)} -o ${os.quoted_path(tfile)} run examples/hello_world.v --an-unknown-option')
    assert res_run_o.exit_code == 0, res_run_o.output
    assert res_run_o.output == '' // because of -o, there should not be an actual run, since compilation stopped after generating the .c file
    assert os.exists(tfile)
    os.rm(tfile) or {}

    res_run_no_o_unknown_before_run :=
        os.execute('${os.quoted_path(@VEXE)} --an-unknown-option run examples/hello_world.v ')
    assert res_run_no_o_unknown_before_run.exit_code == 1, res_run_no_o_unknown_before_run.output
    assert res_run_no_o_unknown_before_run.output.starts_with('Unknown argument')
    assert res_run_no_o_unknown_before_run.output.contains('--an-unknown-option')
    assert !os.exists(tfile)

    res_run_no_o :=
        os.execute('${os.quoted_path(@VEXE)} run examples/hello_world.v --an-unknown-option')
    assert res_run_no_o.exit_code == 0, res_run_no_o.output
    assert res_run_no_o.output.trim_space() == 'Hello, World!'
    assert !os.exists(tfile)
}

fn test_missing_explicit_ccompiler_reports_error() {
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    missing_cc := 'missing_compiler_17126_for_pref_test'
    output := os.join_path(os.vtmp_dir(), 'missing_explicit_ccompiler_output')
    mut expected_output := output
    $if windows {
        expected_output += '.exe'
    }
    os.rm(expected_output) or {}
    res :=
        os.execute('${os.quoted_path(@VEXE)} -cc ${missing_cc} -o ${os.quoted_path(output)} ${os.quoted_path(target)}')
    assert res.exit_code != 0
    assert res.output.contains(missing_cc), res.output
    assert res.output.to_lower().contains('not found') || res.output.to_lower().contains('missing'), res.output

    assert !os.exists(expected_output)
}

fn test_generate_c_project_flag_parsing() {
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    prefs, _ := pref.parse_args_and_show_errors([], ['-generate-c-project', 'cproj', target], false)
    assert prefs.generate_c_project == 'cproj'
    assert prefs.use_cache == false
}

fn test_generate_c_project_creates_build_files() {
    output_dir := os.join_path(os.vtmp_dir(), 'v_generate_c_project_json')
    os.rmdir_all(output_dir) or {}
    defer {
        os.rmdir_all(output_dir) or {}
    }
    target := os.join_path(vroot, 'examples', 'json.v')
    cmd := '${os.quoted_path(vexe)} -generate-c-project ${os.quoted_path(output_dir)} ${os.quoted_path(target)}'
    res := os.execute(cmd)
    assert res.exit_code == 0, res.output
    for rel_path in ['json.c', 'build_command.txt', 'build.sh', 'build.bat', 'Makefile'] {
        assert os.is_file(os.join_path(output_dir, rel_path))
    }
    build_command := os.read_file(os.join_path(output_dir, 'build_command.txt')) or { panic(err) }
    generated_c_path := os.join_path(output_dir, 'json.c')
    normalized_build_command := normalized_build_path(build_command)
    assert normalized_build_command.contains(normalized_build_path(generated_c_path))
        || normalized_build_command.contains(normalized_build_path(os.short_path(generated_c_path)))
    assert build_command.contains('cJSON.c')
    assert !build_command.contains('.tmp.c')
    assert !build_command.contains('.module.')
}

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

fn test_output_flag_accepts_directory_path() {
    output_dir := os.join_path(os.vtmp_dir(), 'v_output_flag_directory')
    os.rmdir_all(output_dir) or {}
    defer {
        os.rmdir_all(output_dir) or {}
    }
    target := os.join_path(vroot, 'examples', 'hello_world.v')
    output_arg := output_dir + os.path_separator
    res :=
        os.execute('${os.quoted_path(vexe)} -o ${os.quoted_path(output_arg)} ${os.quoted_path(target)}')
    assert res.exit_code == 0, res.output
    assert os.is_dir(output_dir)
    mut expected_output := os.join_path(output_dir, 'hello_world')
    $if windows {
        expected_output += '.exe'
    }
    assert os.is_file(expected_output)
}

fn test_tcc_shared_builds_disable_backtraces() {
    mut shared_prefs := &pref.Preferences{
        path:      'libfoo.v'
        is_shared: true
        ccompiler: 'tinyc'
    }
    shared_prefs.fill_with_defaults()
    assert 'no_backtrace' in shared_prefs.compile_defines_all

    mut regular_prefs := &pref.Preferences{
        path:      'main.v'
        ccompiler: 'tinyc'
    }
    regular_prefs.fill_with_defaults()
    assert 'no_backtrace' !in regular_prefs.compile_defines_all
}

fn test_late_resolved_tcc_shared_builds_disable_backtraces() {
    mut shared_prefs := &pref.Preferences{
        path:      'libfoo.v'
        is_shared: true
        ccompiler: 'gcc'
    }
    shared_prefs.fill_with_defaults()
    assert 'no_backtrace' !in shared_prefs.compile_defines_all

    shared_prefs.ccompiler_type = .tinyc
    shared_prefs.normalize_gc_defaults_for_resolved_ccompiler()

    assert 'no_backtrace' in shared_prefs.compile_defines_all
    assert shared_prefs.build_options.contains('-d no_backtrace')
}

fn test_wayland_only_linux_session_surfaces_a_v_error_for_gg() {
    if os.user_os() == 'windows' {
        return
    }
    pid := os.getpid()
    test_dir := os.join_path(os.vtmp_dir(), 'v_issue_18030_gg_wayland_${pid}')
    source_path := os.join_path(test_dir, 'main.v')
    exe_path := os.join_path(test_dir, 'app')
    source := 'import gg as _\n\nfn main() {}\n'
    os.mkdir_all(test_dir) or { panic(err) }
    os.write_file(source_path, source) or { panic(err) }
    defer {
        os.rmdir_all(test_dir) or {}
    }
    cmd := 'DISPLAY= WAYLAND_DISPLAY=wayland-0 XDG_SESSION_TYPE=wayland ${os.quoted_path(vexe)} -os linux -o ${os.quoted_path(exe_path)} ${os.quoted_path(source_path)}'
    res := os.execute(cmd)
    output := res.output.replace('\r', '')
    if res.exit_code == 0 {
        eprintln('> failed command: ${cmd}')
    }
    assert res.exit_code != 0
    assert output.contains('Wayland-only Linux session without `-d sokol_wayland`')
    assert !output.contains('C error. This should never happen.')
}