import os

const directive_order_vexe = @VEXE
const directive_order_tests_dir = os.dir(@FILE)
const directive_order_v3_dir = os.dir(directive_order_tests_dir)
const directive_order_vlib_dir = os.dir(directive_order_v3_dir)
const directive_order_v3_src = os.join_path(directive_order_v3_dir, 'v3.v')

fn directive_order_build_v3() string {
	v3_bin := os.join_path(os.temp_dir(), 'v3_c_directive_order_test')
	build :=
		os.execute('${directive_order_vexe} -gc none -path "${directive_order_vlib_dir}|@vlib|@vmodules" -o ${v3_bin} ${directive_order_v3_src}')
	assert build.exit_code == 0, build.output
	return v3_bin
}

fn directive_order_write_file(root string, rel string, src string) {
	path := os.join_path(root, rel)
	os.mkdir_all(os.dir(path)) or { panic(err) }
	os.write_file(path, src) or { panic(err) }
}

fn directive_order_gen_c(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod', "Module { name: 'directive_order' }\n")
	directive_order_write_file(root, 'main.v', 'module main

import sokol.f as _

fn main() {}
')
	directive_order_write_file(root, 'sokol/c/c.v', 'module c

#define SOKOL_GFX_IMPL
#include "sokol_gfx.h"
')
	directive_order_write_file(root, 'sokol/f/f.v', 'module f

import sokol.c as _

#define SOKOL_FONTSTASH_IMPL
#include "util/sokol_fontstash.h"
#include "sokol_gfx.h"
#ifdef KEEP_DUPLICATE_INCLUDE
#include "sokol_gfx.h"
#endif
')
	c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order.c')
	os.rm(c_out) or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
	assert result.exit_code == 0, result.output
	return os.read_file(c_out) or { panic(err) }
}

fn directive_order_gen_c_dotted_collision(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_dotted_collision_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod',
		"Module { name: 'directive_order_dotted_collision' }\n")
	directive_order_write_file(root, 'main.v', 'module main

import foo.user as _
import bar as _

fn main() {}
')
	directive_order_write_file(root, 'bar/bar.v', 'module bar

#define SHORT_BAR
')
	directive_order_write_file(root, 'foo/bar/bar.v', 'module bar

#define FOO_BAR
')
	directive_order_write_file(root, 'foo/user/user.v', 'module user

import foo.bar as _

#define FOO_USER
')
	c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_dotted_collision.c')
	os.rm(c_out) or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
	assert result.exit_code == 0, result.output
	return os.read_file(c_out) or { panic(err) }
}

fn directive_order_gen_and_run_importer_macro(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_importer_macro_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod', "Module { name: 'directive_order_importer_macro' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#define USE_FOO

import wrapper

fn main() {
	println(wrapper.value().str())
}
')
	directive_order_write_file(root, 'wrapper/wrapper.v', 'module wrapper

#insert "foo.h"

fn C.foo_value() int

pub fn value() int {
	return C.foo_value()
}
')
	directive_order_write_file(root, 'wrapper/foo.h', '#ifndef USE_FOO
#error "USE_FOO must be defined before foo.h"
#endif

static inline int foo_value(void) {
	return 42;
}
')
	bin_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_importer_macro')
	os.rm(bin_out) or {}
	os.rm(bin_out + '.c') or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${bin_out}')
	assert result.exit_code == 0, result.output
	run := os.execute(bin_out)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == '42', run.output
	return os.read_file(bin_out + '.c') or { panic(err) }
}

fn directive_order_gen_and_run_dir_header(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_dir_header_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod', "Module { name: 'directive_order_dir_header' }\n")
	directive_order_write_file(root, 'main.v', 'module main

import wrapper

fn main() {
	println(wrapper.value().str())
}
')
	directive_order_write_file(root, 'wrapper/wrapper.v', 'module wrapper

#insert "@DIR/dir_value.h"

fn C.dir_value() int

pub fn value() int {
	return C.dir_value()
}
')
	directive_order_write_file(root, 'wrapper/dir_value.h', 'static inline int dir_value(void) {
	return 24;
}
')
	bin_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_dir_header')
	os.rm(bin_out) or {}
	os.rm(bin_out + '.c') or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${bin_out}')
	assert result.exit_code == 0, result.output
	run := os.execute(bin_out)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == '24', run.output
	return os.read_file(bin_out + '.c') or { panic(err) }
}

fn directive_order_gen_and_run_flag_include_dir_header(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_flag_include_dir_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod',
		"Module { name: 'directive_order_flag_include_dir' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#flag -I @DIR/include
#insert "flag_value.c"

fn C.flag_value() int

fn main() {
	println(C.flag_value().str())
}
')
	directive_order_write_file(root, 'include/flag_value.c', '#include <flag_value.h>

static inline int flag_value(void) {
	return flag_value_inner();
}
')
	directive_order_write_file(root, 'include/flag_value.h', 'static inline int flag_value_inner(void) {
	return 52;
}
')
	bin_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_flag_include_dir')
	os.rm(bin_out) or {}
	os.rm(bin_out + '.c') or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${bin_out}')
	assert result.exit_code == 0, result.output
	run := os.execute(bin_out)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == '52', run.output
	return os.read_file(bin_out + '.c') or { panic(err) }
}

fn directive_order_gen_and_run_late_flag_include_dir_header(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_late_flag_include_dir_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod',
		"Module { name: 'directive_order_late_flag_include_dir' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#insert "late_flag_value.c"
#flag -I @DIR/include

fn C.late_flag_value() int

fn main() {
	println(C.late_flag_value().str())
}
')
	directive_order_write_file(root, 'include/late_flag_value.c', '#include <late_flag_value.h>

static inline int late_flag_value(void) {
	return late_flag_value_inner();
}
')
	directive_order_write_file(root, 'include/late_flag_value.h', 'static inline int late_flag_value_inner(void) {
	return 63;
}
')
	bin_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_late_flag_include_dir')
	os.rm(bin_out) or {}
	os.rm(bin_out + '.c') or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${bin_out}')
	assert result.exit_code == 0, result.output
	run := os.execute(bin_out)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == '63', run.output
	return os.read_file(bin_out + '.c') or { panic(err) }
}

fn directive_order_gen_and_run_multiline_static_inline(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_multiline_static_inline_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod',
		"Module { name: 'directive_order_multiline_static_inline' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#insert "multiline_value.h"

fn C.multiline_value() int

fn main() {
	println(C.multiline_value().str())
}
')
	directive_order_write_file(root, 'multiline_value.h', 'static inline
int multiline_value(void) {
	return 33;
}
')
	bin_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_multiline_static_inline')
	os.rm(bin_out) or {}
	os.rm(bin_out + '.c') or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${bin_out}')
	assert result.exit_code == 0, result.output
	run := os.execute(bin_out)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == '33', run.output
	return os.read_file(bin_out + '.c') or { panic(err) }
}

fn directive_order_gen_c_extern_after_header(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_extern_after_header_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod',
		"Module { name: 'directive_order_extern_after_header' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#insert "native_thing.h"

@[typedef]
struct C.NativeThing {
	value int
}

fn C.native_use(item &C.NativeThing) int

fn main() {
	mut item := C.NativeThing{
		value: 7
	}
	_ := C.native_use(&item)
}
')
	directive_order_write_file(root, 'native_thing.h', 'typedef struct NativeThing {
	int value;
} NativeThing;
')
	c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_extern_after_header.c')
	os.rm(c_out) or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
	assert result.exit_code == 0, result.output
	return os.read_file(c_out) or { panic(err) }
}

fn directive_order_gen_c_header_declared_prototype(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_header_declared_proto_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod',
		"Module { name: 'directive_order_header_declared_proto' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#insert "declared_proto.h"

fn C.declared_text() &char

fn main() {
	_ := C.declared_text()
}
')
	directive_order_write_file(root, 'declared_proto.h', 'const char* declared_text(void);
')
	c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_header_declared_proto.c')
	os.rm(c_out) or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
	assert result.exit_code == 0, result.output
	return os.read_file(c_out) or { panic(err) }
}

fn directive_order_gen_c_struct_field_after_header(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_struct_field_after_header_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod',
		"Module { name: 'directive_order_struct_field_after_header' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#insert "field_thing.h"

@[typedef]
struct C.FieldThing {
	value int
}

struct Wrap {
	item C.FieldThing
}

fn main() {
	_ := Wrap{}
}
')
	directive_order_write_file(root, 'field_thing.h', 'typedef struct {
	int value;
} FieldThing;
')
	c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_struct_field_after_header.c')
	os.rm(c_out) or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
	assert result.exit_code == 0, result.output
	return os.read_file(c_out) or { panic(err) }
}

fn directive_order_gen_and_run_anonymous_typedef(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_anonymous_typedef_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod',
		"Module { name: 'directive_order_anonymous_typedef' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#insert "anonymous_thing.h"

@[typedef]
struct C.AnonymousThing {
	value int
}

fn C.anonymous_value(item &C.AnonymousThing) int

fn main() {
	mut item := C.AnonymousThing{
		value: 31
	}
	println(C.anonymous_value(&item).str())
}
')
	directive_order_write_file(root, 'anonymous_thing.h', 'typedef struct {
	int value;
} AnonymousThing;

static inline int anonymous_value(AnonymousThing* item) {
	return item->value;
}
')
	bin_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_anonymous_typedef')
	os.rm(bin_out) or {}
	os.rm(bin_out + '.c') or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${bin_out}')
	assert result.exit_code == 0, result.output
	run := os.execute(bin_out)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == '31', run.output
	return os.read_file(bin_out + '.c') or { panic(err) }
}

fn directive_order_gen_and_run_tagged_typedef_alias(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_tagged_typedef_alias_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod',
		"Module { name: 'directive_order_tagged_typedef_alias' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#insert "tagged_thing.h"

@[typedef]
struct C.TaggedAlias {
	value int
}

fn C.tagged_value(item &C.TaggedAlias) int

fn main() {
	mut item := C.TaggedAlias{
		value: 43
	}
	println(C.tagged_value(&item).str())
}
')
	directive_order_write_file(root, 'tagged_thing.h', 'typedef struct TaggedImpl {
	int value;
} TaggedAlias;

static inline int tagged_value(TaggedAlias* item) {
	return item->value;
}
')
	bin_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_tagged_typedef_alias')
	os.rm(bin_out) or {}
	os.rm(bin_out + '.c') or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${bin_out}')
	assert result.exit_code == 0, result.output
	run := os.execute(bin_out)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == '43', run.output
	return os.read_file(bin_out + '.c') or { panic(err) }
}

fn directive_order_gen_c_union_typedef_aliases(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_union_typedef_aliases_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod',
		"Module { name: 'directive_order_union_typedef_aliases' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#insert "union_thing.h"

@[typedef]
union C.AnonymousUnion {
	value int
}

@[typedef]
union C.TaggedUnionAlias {
	value int
}

struct WrapUnion {
	anonymous C.AnonymousUnion
	tagged    C.TaggedUnionAlias
}

fn main() {
	_ := WrapUnion{}
}
')
	directive_order_write_file(root, 'union_thing.h', 'typedef union {
	int value;
} AnonymousUnion;

typedef union TaggedUnionImpl {
	int value;
} TaggedUnionAlias;
')
	c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_union_typedef_aliases.c')
	os.rm(c_out) or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
	assert result.exit_code == 0, result.output
	return os.read_file(c_out) or { panic(err) }
}

fn directive_order_gen_and_run_nested_include(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_nested_include_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod', "Module { name: 'directive_order_nested_include' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#insert "outer.h"

@[typedef]
struct C.NestedThing {
	value int
}

fn C.nested_value(item &C.NestedThing) int

fn main() {
	mut item := C.NestedThing{
		value: 11
	}
	println(C.nested_value(&item).str())
}
')
	directive_order_write_file(root, 'outer.h', '#include "types.h"

static inline int nested_value(NestedThing* item) {
	return NESTED_BIAS + item->value;
}
')
	directive_order_write_file(root, 'types.h', '#include <stdint.h>

#define NESTED_BIAS 5

typedef struct {
	uint32_t value;
} NestedThing;
')
	bin_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_nested_include')
	os.rm(bin_out) or {}
	os.rm(bin_out + '.c') or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${bin_out}')
	assert result.exit_code == 0, result.output
	run := os.execute(bin_out)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == '16', run.output
	return os.read_file(bin_out + '.c') or { panic(err) }
}

fn directive_order_gen_c_unresolved_system_include(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_unresolved_system_include_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod',
		"Module { name: 'directive_order_unresolved_system_include' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#include <platform_user_header.h>
#define USE_DLFCN
#define PLATFORM_API_COMPAT 7
#ifdef USE_DLFCN
#include <dlfcn.h>
#endif
#include <stdint.h>

fn C.dlopen(filename &char, flags i32) voidptr

fn main() {
	nil_cstr := &char(unsafe { nil })
	_ = C.dlopen(nil_cstr, 0)
}
')
	c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_unresolved_system_include.c')
	os.rm(c_out) or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
	assert result.exit_code == 0, result.output
	return os.read_file(c_out) or { panic(err) }
}

fn directive_order_gen_c_nested_preserved_system_include(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_nested_preserved_include_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod',
		"Module { name: 'directive_order_nested_preserved_include' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#insert "nested_preserved.h"

fn main() {}
')
	directive_order_write_file(root, 'nested_preserved.h', '#if defined(__linux__)
#define NESTED_PLATFORM_HEADER 1
#include <nested_platform_header.h>
#endif

#include <stdint.h>

typedef uint64_t NestedWord;
')
	c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_nested_preserved_include.c')
	os.rm(c_out) or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
	assert result.exit_code == 0, result.output
	return os.read_file(c_out) or { panic(err) }
}

fn directive_order_gen_c_preserved_x11_aggregates(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_x11_aggregates_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod', "Module { name: 'directive_order_x11_aggregates' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#include <X11/Xlib.h>

@[typedef]
union C.XClientMessageData {
mut:
	l [5]i64
}

@[typedef]
union C.XEvent {
mut:
	@type   int
	xclient C.XClientMessageData
}

struct Wrap {
	event C.XEvent
}

fn main() {
	_ := Wrap{}
}
')
	c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_x11_aggregates.c')
	os.rm(c_out) or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
	assert result.exit_code == 0, result.output
	return os.read_file(c_out) or { panic(err) }
}

fn directive_order_gen_c_preserved_bcrypt_fn(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_bcrypt_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod', "Module { name: 'directive_order_bcrypt' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#include <bcrypt.h>

fn C.BCryptGenRandom(alg int, buffer voidptr, len int, flags int) int

fn main() {
	_ := C.BCryptGenRandom(0, voidptr(0), 0, 0)
}
')
	c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_bcrypt.c')
	os.rm(c_out) or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
	assert result.exit_code == 0, result.output
	return os.read_file(c_out) or { panic(err) }
}

fn directive_order_gen_c_preserved_mach_headers(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_mach_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod', "Module { name: 'directive_order_mach' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#include <mach/mach.h>
#include <mach/mach_time.h>

@[typedef]
struct C.mach_timebase_info_data_t {
	numer u32
	denom u32
}

fn C.mach_timebase_info(&C.mach_timebase_info_data_t)

fn main() {
	mut tb := C.mach_timebase_info_data_t{}
	C.mach_timebase_info(&tb)
}
')
	c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_mach.c')
	os.rm(c_out) or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
	assert result.exit_code == 0, result.output
	return os.read_file(c_out) or { panic(err) }
}

fn directive_order_gen_and_run_stdarg_header(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_stdarg_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod', "Module { name: 'directive_order_stdarg' }\n")
	directive_order_write_file(root, 'main.v', 'module main

#include "stdarg_user.h"

fn C.stdarg_sum(count int, ...int) int

fn main() {
	println(C.stdarg_sum(3, 1, 2, 3).str())
}
')
	directive_order_write_file(root, 'stdarg_user.h', '#include <stdarg.h>
#include <stddef.h>

struct StdargThing {
	char tag;
	int value;
};

static inline int stdarg_sum(int count, ...) {
	va_list ap;
	va_start(ap, count);
	int total = (int)offsetof(struct StdargThing, value);
	total -= (int)offsetof(struct StdargThing, value);
	for (int i = 0; i < count; i++) {
		total += va_arg(ap, int);
	}
	va_end(ap);
	return total;
}
')
	bin_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_stdarg')
	os.rm(bin_out) or {}
	os.rm(bin_out + '.c') or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${bin_out}')
	assert result.exit_code == 0, result.output
	run := os.execute(bin_out)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == '6', run.output
	return os.read_file(bin_out + '.c') or { panic(err) }
}

fn directive_order_gen_c_rwmutex(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_rwmutex_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod', "Module { name: 'directive_order_rwmutex' }\n")
	directive_order_write_file(root, 'main.v', 'module main

import sync

fn main() {
	mut m := sync.new_rwmutex()
	m.lock()
	m.unlock()
}
')
	c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_rwmutex.c')
	os.rm(c_out) or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
	assert result.exit_code == 0, result.output
	return os.read_file(c_out) or { panic(err) }
}

fn directive_order_gen_c_request_extern(v3_bin string) string {
	root := os.join_path(os.temp_dir(), 'v3_c_directive_order_request_extern_project')
	os.rmdir_all(root) or {}
	os.mkdir_all(root) or { panic(err) }
	directive_order_write_file(root, 'v.mod', "Module { name: 'directive_order_request_extern' }\n")
	directive_order_write_file(root, 'main.v', 'module main

fn C.request(code int) int

fn main() {
	_ := C.request(7)
}
')
	c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_request_extern.c')
	os.rm(c_out) or {}
	result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
	assert result.exit_code == 0, result.output
	return os.read_file(c_out) or { panic(err) }
}

fn directive_order_index(c_code string, needle string) int {
	return c_code.index(needle) or { -1 }
}

fn directive_order_count(c_code string, needle string) int {
	mut count := 0
	mut rest := c_code
	for {
		idx := rest.index(needle) or { break }
		count++
		rest = rest[idx + needle.len..]
	}
	return count
}

fn directive_order_has_include_directive(c_code string) bool {
	for line in c_code.split_into_lines() {
		if line.trim_space().starts_with('#include') {
			return true
		}
	}
	return false
}

fn test_c_directives_follow_import_dependency_order() {
	c_code := directive_order_gen_c(directive_order_build_v3())
	gfx_define := directive_order_index(c_code, '#define SOKOL_GFX_IMPL')
	fontstash_define := directive_order_index(c_code, '#define SOKOL_FONTSTASH_IMPL')
	block_start := directive_order_index(c_code, '#ifdef KEEP_DUPLICATE_INCLUDE')
	assert gfx_define >= 0, c_code
	assert fontstash_define >= 0, c_code
	assert block_start >= 0, c_code
	assert gfx_define < fontstash_define, c_code
	assert !directive_order_has_include_directive(c_code), c_code
	block_tail := c_code[block_start..]
	block_end := directive_order_index(block_tail, '#endif')
	assert block_end >= 0, c_code
}

fn test_c_directives_preserve_dotted_import_module_identity() {
	c_code := directive_order_gen_c_dotted_collision(directive_order_build_v3())
	short_bar := directive_order_index(c_code, '#define SHORT_BAR')
	foo_bar := directive_order_index(c_code, '#define FOO_BAR')
	foo_user := directive_order_index(c_code, '#define FOO_USER')
	assert short_bar >= 0, c_code
	assert foo_bar >= 0, c_code
	assert foo_user >= 0, c_code
	assert foo_bar < foo_user, c_code
}

fn test_importer_macro_is_emitted_before_dependency_include() {
	c_code := directive_order_gen_and_run_importer_macro(directive_order_build_v3())
	use_foo := directive_order_index(c_code, '#define USE_FOO')
	foo_header := directive_order_index(c_code, 'static inline int foo_value')
	assert use_foo >= 0, c_code
	assert foo_header >= 0, c_code
	assert use_foo < foo_header, c_code
	assert !c_code.contains('int foo_value(void);'), c_code
	assert !directive_order_has_include_directive(c_code), c_code
}

fn test_dir_include_is_expanded_before_header_probe() {
	c_code := directive_order_gen_and_run_dir_header(directive_order_build_v3())
	dir_header := directive_order_index(c_code, 'static inline int dir_value')
	assert dir_header >= 0, c_code
	assert !c_code.contains('int dir_value(void);'), c_code
	assert !directive_order_has_include_directive(c_code), c_code
}

fn test_quoted_include_uses_flag_include_dirs() {
	c_code := directive_order_gen_and_run_flag_include_dir_header(directive_order_build_v3())
	flag_header := directive_order_index(c_code, 'static inline int flag_value')
	assert flag_header >= 0, c_code
	assert directive_order_index(c_code, 'static inline int flag_value_inner') >= 0, c_code
	assert !c_code.contains('int flag_value(void);'), c_code
	assert !directive_order_has_include_directive(c_code), c_code
}

fn test_quoted_include_uses_later_flag_include_dirs() {
	c_code := directive_order_gen_and_run_late_flag_include_dir_header(directive_order_build_v3())
	flag_header := directive_order_index(c_code, 'static inline int late_flag_value')
	assert flag_header >= 0, c_code
	assert directive_order_index(c_code, 'static inline int late_flag_value_inner') >= 0, c_code

	assert !c_code.contains('int late_flag_value(void);'), c_code
	assert !directive_order_has_include_directive(c_code), c_code
}

fn test_multiline_static_inline_header_is_not_redeclared() {
	c_code := directive_order_gen_and_run_multiline_static_inline(directive_order_build_v3())
	header_idx := directive_order_index(c_code, 'static inline\nint multiline_value')
	assert header_idx >= 0, c_code
	assert !c_code.contains('int multiline_value(void);'), c_code
	assert !directive_order_has_include_directive(c_code), c_code
}

fn test_inlined_headers_are_emitted_before_extern_prototypes() {
	c_code := directive_order_gen_c_extern_after_header(directive_order_build_v3())
	header_idx := directive_order_index(c_code, 'typedef struct NativeThing')
	proto_idx := directive_order_index(c_code, 'int native_use(NativeThing*')
	assert header_idx >= 0, c_code
	assert proto_idx >= 0, c_code
	assert header_idx < proto_idx, c_code
	assert !directive_order_has_include_directive(c_code), c_code
}

fn test_header_declared_prototypes_are_not_redeclared() {
	c_code := directive_order_gen_c_header_declared_prototype(directive_order_build_v3())
	header_idx := directive_order_index(c_code, 'const char* declared_text(void);')
	assert header_idx >= 0, c_code
	assert directive_order_count(c_code, 'declared_text(void);') == 1, c_code
	assert !directive_order_has_include_directive(c_code), c_code
}

fn test_inlined_headers_are_emitted_before_type_declarations() {
	c_code := directive_order_gen_c_struct_field_after_header(directive_order_build_v3())
	header_idx := directive_order_index(c_code, '} FieldThing;')
	wrap_idx := directive_order_index(c_code, 'struct Wrap {')
	assert header_idx >= 0, c_code
	assert wrap_idx >= 0, c_code
	assert header_idx < wrap_idx, c_code
	assert !c_code.contains('typedef struct FieldThing'), c_code
	assert !directive_order_has_include_directive(c_code), c_code
}

fn test_anonymous_typedef_struct_header_is_not_duplicated() {
	c_code := directive_order_gen_and_run_anonymous_typedef(directive_order_build_v3())
	assert c_code.contains('} AnonymousThing;'), c_code
	assert c_code.contains('static inline int anonymous_value'), c_code
	assert !c_code.contains('typedef struct AnonymousThing'), c_code
	assert !directive_order_has_include_directive(c_code), c_code
}

fn test_tagged_typedef_struct_alias_header_is_not_duplicated() {
	c_code := directive_order_gen_and_run_tagged_typedef_alias(directive_order_build_v3())
	assert c_code.contains('} TaggedAlias;'), c_code
	assert c_code.contains('static inline int tagged_value'), c_code
	assert !c_code.contains('typedef struct TaggedAlias'), c_code
	assert !directive_order_has_include_directive(c_code), c_code
}

fn test_inlined_typedef_union_headers_are_not_duplicated() {
	c_code := directive_order_gen_c_union_typedef_aliases(directive_order_build_v3())
	assert c_code.contains('} AnonymousUnion;'), c_code
	assert c_code.contains('} TaggedUnionAlias;'), c_code
	assert !c_code.contains('typedef union AnonymousUnion'), c_code
	assert !c_code.contains('union AnonymousUnion {\n'), c_code
	assert !c_code.contains('typedef union TaggedUnionAlias'), c_code
	assert !c_code.contains('union TaggedUnionAlias {\n'), c_code
	assert !directive_order_has_include_directive(c_code), c_code
}

fn test_nested_local_header_includes_are_inlined_recursively() {
	c_code := directive_order_gen_and_run_nested_include(directive_order_build_v3())
	bias_idx := directive_order_index(c_code, '#define NESTED_BIAS 5')
	stdint_idx := directive_order_index(c_code, 'typedef unsigned int uint32_t;')
	typedef_idx := directive_order_index(c_code, '} NestedThing;')
	outer_fn_idx := directive_order_index(c_code, 'static inline int nested_value')
	assert bias_idx >= 0, c_code
	assert stdint_idx >= 0, c_code
	assert typedef_idx >= 0, c_code
	assert outer_fn_idx >= 0, c_code
	assert stdint_idx < typedef_idx, c_code
	assert bias_idx < outer_fn_idx, c_code
	assert typedef_idx < outer_fn_idx, c_code
	assert !c_code.contains('typedef struct NestedThing'), c_code
	assert !directive_order_has_include_directive(c_code), c_code
}

fn test_unresolved_system_include_is_preserved() {
	c_code := directive_order_gen_c_unresolved_system_include(directive_order_build_v3())
	assert c_code.contains('#include <platform_user_header.h>'), c_code
	assert c_code.contains('#include <dlfcn.h>'), c_code
	assert !c_code.contains('#include <stdint.h>'), c_code
	assert c_code.contains('typedef unsigned int uint32_t;'), c_code
	assert !c_code.contains('void* dlopen(char* filename, int flags);'), c_code
	api_compat_idx := directive_order_index(c_code, '#define PLATFORM_API_COMPAT 7')
	guard_idx := directive_order_index(c_code, '#ifdef USE_DLFCN')
	dlfcn_idx := directive_order_index(c_code, '#include <dlfcn.h>')
	time_t_idx := directive_order_index(c_code, 'typedef long long time_t;')
	off_t_idx := directive_order_index(c_code, 'typedef long long off_t;')
	wchar_idx := directive_order_index(c_code, 'typedef unsigned int wchar_t;')
	fd_set_idx := directive_order_index(c_code, '#ifndef FD_SET')
	assert api_compat_idx >= 0, c_code
	assert guard_idx >= 0, c_code
	assert dlfcn_idx >= 0, c_code
	assert time_t_idx >= 0, c_code
	assert off_t_idx >= 0, c_code
	assert wchar_idx >= 0, c_code
	assert fd_set_idx >= 0, c_code
	assert c_code.contains('#if !defined(_TIME_T) && !defined(_TIME_T_DEFINED) && !defined(__time_t_defined)'), c_code
	assert c_code.contains('#if !defined(_OFF_T) && !defined(_OFF_T_DEFINED) && !defined(__off_t_defined)'), c_code
	assert api_compat_idx < dlfcn_idx, c_code
	assert guard_idx < dlfcn_idx, c_code
	assert dlfcn_idx < time_t_idx, c_code
	assert dlfcn_idx < off_t_idx, c_code
	assert dlfcn_idx < wchar_idx, c_code
	assert dlfcn_idx < fd_set_idx, c_code
}

fn test_nested_preserved_system_include_is_lifted_before_preamble() {
	c_code := directive_order_gen_c_nested_preserved_system_include(directive_order_build_v3())
	include_idx := directive_order_index(c_code, '#include <nested_platform_header.h>')
	preamble_idx := directive_order_index(c_code, 'typedef signed char i8;')
	stdint_guard_idx := directive_order_index(c_code,
		'#if !defined(__V_HEADERLESS_STDINT_H) && !defined(_STDINT_H)')
	nested_word_idx := directive_order_index(c_code, 'typedef uint64_t NestedWord;')
	assert include_idx >= 0, c_code
	assert preamble_idx >= 0, c_code
	assert stdint_guard_idx >= 0, c_code
	assert nested_word_idx >= 0, c_code
	assert include_idx < preamble_idx, c_code
	assert preamble_idx < stdint_guard_idx, c_code
	assert stdint_guard_idx < nested_word_idx, c_code
	assert c_code.contains('#if defined(__linux__)\n#define NESTED_PLATFORM_HEADER 1\n#include <nested_platform_header.h>\n#endif'), c_code
}

fn test_preserved_system_header_aggregates_are_not_redeclared() {
	c_code := directive_order_gen_c_preserved_x11_aggregates(directive_order_build_v3())
	assert c_code.contains('#include <X11/Xlib.h>'), c_code
	assert !c_code.contains('typedef union XEvent XEvent;'), c_code
	assert !c_code.contains('union XEvent {\n'), c_code
	assert !c_code.contains('typedef union XClientMessageData XClientMessageData;'), c_code
	assert !c_code.contains('union XClientMessageData {\n'), c_code
}

fn test_preserved_system_header_functions_are_not_redeclared() {
	c_code := directive_order_gen_c_preserved_bcrypt_fn(directive_order_build_v3())
	assert c_code.contains('#include <bcrypt.h>'), c_code
	assert directive_order_count(c_code, 'BCryptGenRandom(') == 1, c_code
}

fn test_preserved_mach_headers_are_wrapped_with_panic_alias() {
	c_code := directive_order_gen_c_preserved_mach_headers(directive_order_build_v3())
	preamble_idx := directive_order_index(c_code, 'typedef signed char i8;')
	assert preamble_idx >= 0, c_code
	assert c_code.contains('#define panic mach_panic\n#include <mach/mach.h>\n#undef panic'), c_code
	assert c_code.contains('#define panic mach_panic\n#include <mach/mach_time.h>\n#undef panic'), c_code
	assert directive_order_index(c_code, '#undef panic') < preamble_idx, c_code
	assert !c_code.contains('typedef struct mach_timebase_info_data_t mach_timebase_info_data_t;'), c_code

	assert directive_order_count(c_code, 'mach_timebase_info(') == 1, c_code
}

fn test_stdarg_in_inlined_header_uses_headerless_va_defs() {
	c_code := directive_order_gen_and_run_stdarg_header(directive_order_build_v3())
	assert !c_code.contains('#include <stdarg.h>'), c_code
	assert !c_code.contains('#include <stddef.h>'), c_code
	assert c_code.contains('typedef __builtin_va_list va_list;'), c_code
	assert c_code.contains('#define va_start(ap, last) __builtin_va_start(ap, last)'), c_code
	assert c_code.contains('#define va_arg(ap, type) __builtin_va_arg(ap, type)'), c_code
	assert c_code.contains('#define offsetof(type, member) __builtin_offsetof(type, member)'), c_code
	assert c_code.contains('offsetof(struct StdargThing, value)'), c_code
	assert c_code.contains('static inline int stdarg_sum(int count, ...)'), c_code
}

fn test_rwmutex_keeps_linux_rwlockattr_prototype() {
	c_code := directive_order_gen_c_rwmutex(directive_order_build_v3())
	assert c_code.contains('int pthread_rwlockattr_setkind_np('), c_code
}

fn test_request_named_c_function_keeps_extern_prototype() {
	c_code := directive_order_gen_c_request_extern(directive_order_build_v3())
	assert c_code.contains('int request(int'), c_code
}