module builder

import os
import v2.ast
import v2.pref

fn collect_cflags_for_test_source(source string, mut prefs pref.Preferences) string {
	tmp_dir := os.join_path(os.vtmp_dir(), 'v2_builder_flag_target_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source_path := os.join_path(tmp_dir, 'main.v')
	os.write_file(source_path, source) or { panic(err) }
	prefs.skip_builtin = true
	mut b := new_builder(&prefs)
	b.files = [
		ast.File{
			name: source_path
		},
	]
	return b.collect_cflags_from_sources()
}

fn collect_cflags_for_flat_only_test_source(source string, mut prefs pref.Preferences) string {
	tmp_dir := os.join_path(os.vtmp_dir(), 'v2_builder_flag_target_flat_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source_path := os.join_path(tmp_dir, 'main.v')
	os.write_file(source_path, source) or { panic(err) }
	prefs.skip_builtin = true
	mut b := new_builder(&prefs)
	b.flat = ast.flatten_files([
		ast.File{
			name: source_path
			mod:  'main'
		},
	])
	b.files = []ast.File{}
	return b.collect_cflags_from_sources()
}

fn freestanding_test_call_name(name string, user_defines []string) string {
	return freestanding_test_call_name_with_hooks(name, user_defines, [])
}

fn freestanding_test_call_name_with_hooks(name string, user_defines []string, hooks []string) string {
	return freestanding_restricted_call_in_expr(ast.Expr(ast.CallExpr{
		lhs: ast.Expr(ast.Ident{
			name: name
		})
	}), FreestandingScanContext{
		user_defines:       user_defines
		target_os:          'linux'
		freestanding_hooks: hooks
	})
}

fn test_flag_directives_match_cross_and_freestanding_preferences() {
	mut cross_prefs := pref.new_preferences()
	cross_prefs.target_os = 'cross'
	cross_prefs.user_defines = ['cross']
	cross_flag := parse_flag_directive_line_with_pref('#flag cross -DCROSS_DIRECT',
		'/tmp/source.v', &cross_prefs) or { '' }
	linux_flag := parse_flag_directive_line_with_pref('#flag linux -DLINUX_DIRECT',
		'/tmp/source.v', &cross_prefs) or { '' }
	assert cross_flag == '-DCROSS_DIRECT'
	assert linux_flag == ''

	mut free_prefs := pref.new_preferences()
	free_prefs.target_os = 'linux'
	free_prefs.user_defines = ['freestanding']
	free_flag := parse_flag_directive_line_with_pref('#flag freestanding -DFREE_DIRECT',
		'/tmp/source.v', &free_prefs) or { '' }
	linux_in_free_flag := parse_flag_directive_line_with_pref('#flag linux -DLINUX_DIRECT',
		'/tmp/source.v', &free_prefs) or { '' }
	assert free_flag == '-DFREE_DIRECT'
	assert linux_in_free_flag == '-DLINUX_DIRECT'
}

fn test_comptime_flag_blocks_match_cross_and_freestanding_preferences() {
	mut cross_prefs := pref.new_preferences()
	cross_prefs.target_os = 'cross'
	cross_prefs.user_defines = ['cross']
	assert comptime_cond_matches_with_pref('cross', &cross_prefs)
	assert !comptime_cond_matches_with_pref('linux', &cross_prefs)
	assert !comptime_cond_matches_with_pref('linux ?', &cross_prefs)
	assert comptime_cond_matches_with_pref('cross && !linux', &cross_prefs)

	mut optional_linux_prefs := pref.new_preferences()
	optional_linux_prefs.target_os = 'cross'
	optional_linux_prefs.user_defines = ['cross', 'linux']
	optional_linux_prefs.explicit_user_defines = ['linux']
	assert comptime_cond_matches_with_pref('linux ?', &optional_linux_prefs)

	mut linux_prefs := pref.new_preferences()
	linux_prefs.target_os = 'linux'
	assert comptime_cond_matches_with_pref('linux', &linux_prefs)
	assert !comptime_cond_matches_with_pref('linux ?', &linux_prefs)
	assert !comptime_cond_matches_with_pref('linux ? || windows', &linux_prefs)
	linux_prefs.user_defines = ['linux']
	linux_prefs.explicit_user_defines = ['linux']
	assert comptime_cond_matches_with_pref('linux ?', &linux_prefs)
	assert comptime_cond_matches_with_pref('linux ? || windows', &linux_prefs)

	mut termux_prefs := pref.new_preferences()
	termux_prefs.target_os = 'termux'
	assert comptime_cond_matches_with_pref('termux', &termux_prefs)
	assert comptime_cond_matches_with_pref('linux || termux', &termux_prefs)
	assert !comptime_cond_matches_with_pref('android', &termux_prefs)
	assert !comptime_cond_matches_with_pref('android && !termux', &termux_prefs)

	mut free_prefs := pref.new_preferences()
	free_prefs.target_os = 'linux'
	free_prefs.user_defines = ['freestanding']
	assert comptime_cond_matches_with_pref('freestanding', &free_prefs)
	assert !comptime_cond_matches_with_pref('freestanding ?', &free_prefs)
	assert comptime_cond_matches_with_pref('linux', &free_prefs)
	assert comptime_cond_matches_with_pref('freestanding && linux', &free_prefs)
}

fn test_comptime_pkgconfig_condition_matches_available_package() {
	mut prefs := pref.new_preferences()
	prefs.target_os = os.user_os()
	assert !comptime_cond_matches_with_pref(r"$pkgconfig('__v2_definitely_missing_pkgconfig_test_package__')",
		&prefs)
	if pref.comptime_pkgconfig_value('sqlite3') {
		assert comptime_cond_matches_with_pref(r"$pkgconfig('sqlite3')", &prefs)
	}
}

fn test_pkgconfig_directive_collects_flags_for_active_native_branch() {
	mut prefs := pref.new_preferences()
	prefs.target_os = os.user_os()
	if pref.comptime_pkgconfig_value('sqlite3') {
		flag := parse_flag_directive_line_with_pref('#pkgconfig sqlite3', '/tmp/source.v', &prefs) or {
			''
		}
		assert flag.contains('sqlite3')
	}

	mut cross_prefs := pref.new_preferences()
	cross_prefs.target_os = 'cross'
	cross_prefs.output_cross_c = true
	flag := parse_flag_directive_line_with_pref('#pkgconfig sqlite3', '/tmp/source.v', &cross_prefs) or {
		''
	}
	assert flag == ''
}

fn test_comptime_optional_target_mode_flags_require_explicit_define() {
	mut cross_prefs := pref.new_preferences()
	cross_prefs.target_os = 'cross'
	cross_prefs.user_defines = ['cross']
	assert comptime_cond_matches_with_pref('cross', &cross_prefs)
	assert !comptime_cond_matches_with_pref('cross ?', &cross_prefs)
	cross_prefs.explicit_user_defines = ['cross']
	assert comptime_cond_matches_with_pref('cross ?', &cross_prefs)

	mut free_prefs := pref.new_preferences()
	free_prefs.target_os = 'linux'
	free_prefs.user_defines = ['freestanding']
	assert comptime_cond_matches_with_pref('freestanding', &free_prefs)
	assert !comptime_cond_matches_with_pref('freestanding ?', &free_prefs)
	free_prefs.explicit_user_defines = ['freestanding']
	assert comptime_cond_matches_with_pref('freestanding ?', &free_prefs)

	mut none_prefs := pref.new_preferences()
	none_prefs.target_os = 'none'
	none_prefs.user_defines = ['freestanding']
	assert comptime_cond_matches_with_pref('none', &none_prefs)
	assert !comptime_cond_matches_with_pref('none ?', &none_prefs)
	none_prefs.explicit_user_defines = ['none']
	assert comptime_cond_matches_with_pref('none ?', &none_prefs)
}

fn test_comptime_flag_blocks_use_or_and_not_precedence() {
	mut linux_prefs := pref.new_preferences()
	linux_prefs.target_os = 'linux'
	assert comptime_cond_matches_with_pref('!windows && linux', &linux_prefs)
	assert comptime_cond_matches_with_pref('linux || windows && macos', &linux_prefs)

	mut macos_prefs := pref.new_preferences()
	macos_prefs.target_os = 'macos'
	assert !comptime_cond_matches_with_pref('!windows && linux', &macos_prefs)
	assert !comptime_cond_matches_with_pref('linux || windows && macos', &macos_prefs)

	mut windows_prefs := pref.new_preferences()
	windows_prefs.target_os = 'windows'
	assert !comptime_cond_matches_with_pref('!windows && linux', &windows_prefs)
	assert !comptime_cond_matches_with_pref('linux || windows && macos', &windows_prefs)
}

fn test_parser_level_comptime_flags_match_cross_and_accepted_targets() {
	assert ast_comptime_flag_matches('cross', [], 'cross')
	assert ast_comptime_flag_matches('solaris', [], 'solaris')
	assert ast_comptime_flag_matches('qnx', [], 'qnx')
	assert ast_comptime_flag_matches('serenity', [], 'serenity')
	assert ast_comptime_flag_matches('plan9', [], 'plan9')
	assert ast_comptime_flag_matches('vinix', [], 'vinix')
	assert ast_comptime_flag_matches('ios', [], 'ios')
	assert ast_comptime_flag_matches('termux', [], 'termux')
	assert ast_comptime_flag_matches('none', [], 'none')
	assert !ast_comptime_flag_matches('linux', [], 'cross')
	assert !ast_comptime_flag_matches('linux', ['linux'], 'windows')
	assert !ast_comptime_flag_matches('none', ['none'], 'linux')
}

fn test_flag_directives_match_all_accepted_target_os_names() {
	for target in ['android', 'termux', 'ios', 'solaris', 'qnx', 'serenity', 'plan9', 'vinix'] {
		flag := parse_flag_directive_line('#flag ${target} -D${target.to_upper()}',
			'/tmp/source.v', target) or { '' }
		assert flag == '-D${target.to_upper()}'
		assert comptime_cond_matches(target, target)
	}
}

fn test_collect_cflags_from_sources_matches_cross_and_freestanding_blocks() {
	cross_source := 'module main

$if cross {
#flag -DCROSS_BLOCK
}
$if cross ? {
#flag -DOPTIONAL_CROSS_BLOCK
}
$if linux {
#flag -DLINUX_BLOCK
}
$if linux ? {
#flag -DOPTIONAL_LINUX_BLOCK
}
$if macos {
#flag -DMACOS_BLOCK
}
$if windows {
#flag -DWINDOWS_BLOCK
}
#flag cross -DCROSS_DIRECT
#flag linux -DLINUX_DIRECT
#flag macos -DMACOS_DIRECT
#flag windows -DWINDOWS_DIRECT
'
	mut cross_prefs := pref.new_preferences()
	cross_prefs.target_os = 'cross'
	cross_prefs.user_defines = ['cross']
	cross_flags := collect_cflags_for_test_source(cross_source, mut cross_prefs)
	assert cross_flags.contains('-DCROSS_BLOCK')
	assert cross_flags.contains('-DCROSS_DIRECT')
	assert !cross_flags.contains('-DOPTIONAL_CROSS_BLOCK')
	assert !cross_flags.contains('-DOPTIONAL_LINUX_BLOCK')
	host_os := normalize_target_os_name(os.user_os())
	if host_os in ['linux', 'macos', 'windows'] {
		assert cross_flags.contains(match host_os {
			'macos' { '-DMACOS_BLOCK' }
			'windows' { '-DWINDOWS_BLOCK' }
			else { '-DLINUX_BLOCK' }
		})
		assert cross_flags.contains(match host_os {
			'macos' { '-DMACOS_DIRECT' }
			'windows' { '-DWINDOWS_DIRECT' }
			else { '-DLINUX_DIRECT' }
		})
	}
	if host_os != 'linux' {
		assert !cross_flags.contains('-DLINUX_BLOCK')
		assert !cross_flags.contains('-DLINUX_DIRECT')
	}
	if host_os != 'macos' {
		assert !cross_flags.contains('-DMACOS_BLOCK')
		assert !cross_flags.contains('-DMACOS_DIRECT')
	}
	if host_os != 'windows' {
		assert !cross_flags.contains('-DWINDOWS_BLOCK')
		assert !cross_flags.contains('-DWINDOWS_DIRECT')
	}
	mut cross_with_optional_linux_prefs := pref.new_preferences()
	cross_with_optional_linux_prefs.target_os = 'cross'
	cross_with_optional_linux_prefs.user_defines = ['cross', 'linux']
	cross_with_optional_linux_prefs.explicit_user_defines = ['linux']
	cross_with_optional_linux_flags := collect_cflags_for_test_source(cross_source, mut
		cross_with_optional_linux_prefs)
	assert cross_with_optional_linux_flags.contains('-DOPTIONAL_LINUX_BLOCK')
	assert !cross_with_optional_linux_flags.contains('-DOPTIONAL_CROSS_BLOCK')

	mut cross_explicit_prefs := pref.new_preferences()
	cross_explicit_prefs.target_os = 'cross'
	cross_explicit_prefs.user_defines = ['cross']
	cross_explicit_prefs.explicit_user_defines = ['cross']
	cross_explicit_flags := collect_cflags_for_test_source(cross_source, mut cross_explicit_prefs)
	assert cross_explicit_flags.contains('-DOPTIONAL_CROSS_BLOCK')

	free_source := 'module main

$if freestanding {
#flag -DFREE_BLOCK
}
$if freestanding ? {
#flag -DOPTIONAL_FREE_BLOCK
}
$if linux {
#flag -DLINUX_BLOCK
}
#flag freestanding -DFREE_DIRECT
#flag linux -DLINUX_DIRECT
'
	mut free_prefs := pref.new_preferences()
	free_prefs.target_os = 'linux'
	free_prefs.user_defines = ['freestanding']
	free_flags := collect_cflags_for_test_source(free_source, mut free_prefs)
	assert free_flags.contains('-DFREE_BLOCK')
	assert !free_flags.contains('-DOPTIONAL_FREE_BLOCK')
	assert free_flags.contains('-DFREE_DIRECT')
	assert free_flags.contains('-DLINUX_BLOCK')
	assert free_flags.contains('-DLINUX_DIRECT')

	mut free_explicit_prefs := pref.new_preferences()
	free_explicit_prefs.target_os = 'linux'
	free_explicit_prefs.user_defines = ['freestanding']
	free_explicit_prefs.explicit_user_defines = ['freestanding']
	free_explicit_flags := collect_cflags_for_test_source(free_source, mut free_explicit_prefs)
	assert free_explicit_flags.contains('-DOPTIONAL_FREE_BLOCK')
}

fn test_collect_cflags_from_sources_reads_flat_file_names() {
	source := 'module main

#flag -DFLAT_ONLY_FLAG
'
	mut prefs := pref.new_preferences()
	flags := collect_cflags_for_flat_only_test_source(source, mut prefs)
	assert flags.contains('-DFLAT_ONLY_FLAG')
}

fn test_collect_cflags_from_sources_keeps_optional_os_flags_custom_only() {
	source := 'module main

$if linux {
#flag -DLINUX_BLOCK
}
$if linux ? {
#flag -DOPTIONAL_LINUX_BLOCK
}
$if linux ? || windows {
#flag -DOPTIONAL_LINUX_OR_WINDOWS_BLOCK
}
'
	mut linux_prefs := pref.new_preferences()
	linux_prefs.target_os = 'linux'
	linux_flags := collect_cflags_for_test_source(source, mut linux_prefs)
	assert linux_flags.contains('-DLINUX_BLOCK')
	assert !linux_flags.contains('-DOPTIONAL_LINUX_BLOCK')
	assert !linux_flags.contains('-DOPTIONAL_LINUX_OR_WINDOWS_BLOCK')

	mut linux_defined_prefs := pref.new_preferences()
	linux_defined_prefs.target_os = 'linux'
	linux_defined_prefs.user_defines = ['linux']
	linux_defined_prefs.explicit_user_defines = ['linux']
	linux_defined_flags := collect_cflags_for_test_source(source, mut linux_defined_prefs)
	assert linux_defined_flags.contains('-DLINUX_BLOCK')
	assert linux_defined_flags.contains('-DOPTIONAL_LINUX_BLOCK')
	assert linux_defined_flags.contains('-DOPTIONAL_LINUX_OR_WINDOWS_BLOCK')

	mut windows_prefs := pref.new_preferences()
	windows_prefs.target_os = 'windows'
	windows_flags := collect_cflags_for_test_source(source, mut windows_prefs)
	assert !windows_flags.contains('-DLINUX_BLOCK')
	assert !windows_flags.contains('-DOPTIONAL_LINUX_BLOCK')
	assert windows_flags.contains('-DOPTIONAL_LINUX_OR_WINDOWS_BLOCK')
}

fn test_collect_cflags_from_sources_keeps_optional_none_custom_only() {
	source := 'module main

$if none {
#flag -DNONE_BLOCK
}
$if none ? {
#flag -DOPTIONAL_NONE_BLOCK
}
'
	mut none_prefs := pref.new_preferences()
	none_prefs.target_os = 'none'
	none_prefs.user_defines = ['freestanding']
	none_flags := collect_cflags_for_test_source(source, mut none_prefs)
	assert none_flags.contains('-DNONE_BLOCK')
	assert !none_flags.contains('-DOPTIONAL_NONE_BLOCK')

	mut none_explicit_prefs := pref.new_preferences()
	none_explicit_prefs.target_os = 'none'
	none_explicit_prefs.user_defines = ['freestanding']
	none_explicit_prefs.explicit_user_defines = ['none']
	none_explicit_flags := collect_cflags_for_test_source(source, mut none_explicit_prefs)
	assert none_explicit_flags.contains('-DOPTIONAL_NONE_BLOCK')
}

fn test_collect_cflags_from_sources_matches_termux_blocks_and_directives() {
	source := 'module main

$if termux {
#flag -DTERMUX_BLOCK
}
$if linux || termux {
#flag -DTERMUX_OR_LINUX_BLOCK
}
$if android && !termux {
#flag -DANDROID_OUTSIDE_TERMUX_BLOCK
}
#flag termux -DTERMUX_DIRECT
#flag android -DANDROID_DIRECT
'
	mut termux_prefs := pref.new_preferences()
	termux_prefs.target_os = 'termux'
	flags := collect_cflags_for_test_source(source, mut termux_prefs)
	assert flags.contains('-DTERMUX_BLOCK')
	assert flags.contains('-DTERMUX_OR_LINUX_BLOCK')
	assert flags.contains('-DTERMUX_DIRECT')
	assert !flags.contains('-DANDROID_OUTSIDE_TERMUX_BLOCK')
	assert !flags.contains('-DANDROID_DIRECT')
}

fn test_freestanding_diagnostics_gate_direct_builtins_by_capability() {
	for name in ['print', 'println', 'eprint', 'eprintln'] {
		assert freestanding_test_call_name(name, ['freestanding_hooks']) == name
		assert freestanding_test_call_name_with_hooks(name, ['freestanding_hooks',
			'freestanding_output'], ['output']) == ''
	}
	assert freestanding_test_call_name('panic', ['freestanding_hooks']) == 'panic'
	assert freestanding_test_call_name_with_hooks('panic', ['freestanding_hooks',
		'freestanding_panic'], ['panic']) == ''
}

fn test_freestanding_diagnostics_leave_runtime_helpers_to_cleanc() {
	for name in ['_write_buf_to_fd', '_writeln_to_fd', 'flush_stdout', 'flush_stderr'] {
		assert freestanding_test_call_name(name, ['freestanding_hooks']) == ''
	}

	assert freestanding_test_call_name_with_hooks('arguments', ['freestanding_hooks',
		'freestanding_output'], ['output']) == ''
	assert freestanding_test_call_name_with_hooks('arguments', ['freestanding_hooks',
		'freestanding_alloc'], ['alloc']) == ''
	assert freestanding_test_call_name('malloc_noscan',
		['freestanding_hooks', 'freestanding_alloc']) == ''
	assert freestanding_test_call_name_with_hooks('malloc_noscan', [
		'freestanding_hooks',
		'freestanding_alloc',
	], ['alloc']) == ''
	assert freestanding_restricted_call_in_expr(ast.Expr(ast.CallExpr{
		lhs:  ast.Expr(ast.Ident{
			name: 'println'
		})
		args: [
			ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '123'
			}),
		]
	}), FreestandingScanContext{
		user_defines:       ['freestanding_hooks', 'freestanding_output']
		target_os:          'linux'
		freestanding_hooks: ['output']
	}) == ''
	assert freestanding_restricted_call_in_expr(ast.Expr(ast.CallExpr{
		lhs:  ast.Expr(ast.Ident{
			name: 'println'
		})
		args: [
			ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '123'
			}),
		]
	}), FreestandingScanContext{
		user_defines:       ['freestanding_hooks', 'freestanding_output', 'freestanding_alloc']
		target_os:          'linux'
		freestanding_hooks: ['output', 'alloc']
	}) == ''
}

fn test_freestanding_diagnostics_skip_inactive_conditional_functions() {
	ctx := FreestandingScanContext{
		user_defines: ['freestanding']
		target_os:    'linux'
	}
	hosted_call := ast.Stmt(ast.ExprStmt{
		expr: ast.Expr(ast.CallExpr{
			lhs: ast.Expr(ast.Ident{
				name: 'println'
			})
		})
	})
	inactive_windows_fn := ast.Stmt(ast.FnDecl{
		attributes: [
			ast.Attribute{
				comptime_cond: ast.Expr(ast.Ident{
					name: 'windows'
				})
			},
		]
		stmts:      [hosted_call]
	})
	inactive_not_freestanding_fn := ast.Stmt(ast.FnDecl{
		attributes: [
			ast.Attribute{
				comptime_cond: ast.Expr(ast.PrefixExpr{
					op:   .not
					expr: ast.Expr(ast.Ident{
						name: 'freestanding'
					})
				})
			},
		]
		stmts:      [hosted_call]
	})
	active_fn := ast.Stmt(ast.FnDecl{
		attributes: [
			ast.Attribute{
				comptime_cond: ast.Expr(ast.Ident{
					name: 'freestanding'
				})
			},
		]
		stmts:      [hosted_call]
	})
	assert freestanding_restricted_call_in_stmt(inactive_windows_fn, ctx) == ''
	assert freestanding_restricted_call_in_stmt(inactive_not_freestanding_fn, ctx) == ''
	assert freestanding_restricted_call_in_stmt(active_fn, ctx) == 'println'
}

fn test_freestanding_diagnostics_leave_array_allocation_to_cleanc() {
	ctx := FreestandingScanContext{
		user_defines: ['freestanding']
		target_os:    'linux'
	}
	fixed_array := ast.Expr(ast.ArrayInitExpr{
		typ: ast.Expr(ast.Type(ast.ArrayFixedType{
			len:       ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '3'
			})
			elem_type: ast.Expr(ast.Ident{
				name: 'int'
			})
		}))
	})
	dynamic_array := ast.Expr(ast.ArrayInitExpr{
		typ: ast.Expr(ast.Type(ast.ArrayType{
			elem_type: ast.Expr(ast.Ident{
				name: 'int'
			})
		}))
	})
	fixed_literal_array := ast.Expr(ast.ArrayInitExpr{
		exprs: [
			ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '1'
			}),
			ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '2'
			}),
			ast.Expr(ast.BasicLiteral{
				kind:  .number
				value: '3'
			}),
		]
		len:   ast.Expr(ast.PostfixExpr{
			op:   .not
			expr: ast.empty_expr
		})
	})
	assert freestanding_restricted_call_in_expr(fixed_array, ctx) == ''
	assert freestanding_restricted_call_in_expr(fixed_literal_array, ctx) == ''
	assert freestanding_restricted_call_in_expr(dynamic_array, ctx) == ''
}

fn test_collect_cflags_from_sources_uses_or_and_not_precedence() {
	source := 'module main

$if !windows && linux {
#flag -DNEGATED_AND_LINUX
}

$if linux || windows && macos {
#flag -DOR_AND_LINUX
}
'
	mut linux_prefs := pref.new_preferences()
	linux_prefs.target_os = 'linux'
	linux_flags := collect_cflags_for_test_source(source, mut linux_prefs)
	assert linux_flags.contains('-DNEGATED_AND_LINUX')
	assert linux_flags.contains('-DOR_AND_LINUX')

	mut macos_prefs := pref.new_preferences()
	macos_prefs.target_os = 'macos'
	macos_flags := collect_cflags_for_test_source(source, mut macos_prefs)
	assert !macos_flags.contains('-DNEGATED_AND_LINUX')
	assert !macos_flags.contains('-DOR_AND_LINUX')

	mut windows_prefs := pref.new_preferences()
	windows_prefs.target_os = 'windows'
	windows_flags := collect_cflags_for_test_source(source, mut windows_prefs)
	assert !windows_flags.contains('-DNEGATED_AND_LINUX')
	assert !windows_flags.contains('-DOR_AND_LINUX')
}