import os

const vexe = @VEXE

fn testsuite_begin() {
	$if rv64 {
		skip_test('closure lifetime API tests are too slow under riscv64 emulation')
	}
}

@[noreturn]
fn skip_test(reason string) {
	println('skipping test, because ${reason} .')
	exit(0)
}

fn missing_boehm_lib(output string) bool {
	mentions_gc := output.contains('libgc') || output.contains('-lgc')
		|| output.contains("library 'gc'") || output.contains('bdw-gc')
	return mentions_gc && (output.contains('was not found')
		|| output.contains('cannot find') || output.contains('not found')
		|| output.contains('No such file'))
}

// assert_run_succeeds_or_missing_boehm runs the program with the given gc mode and
// asserts success, but skips gracefully when a `boehm`/`boehm_leak` build fails only
// because the Boehm GC library is unavailable (e.g. musl images without musl libgc).
fn assert_run_succeeds_or_missing_boehm(tmp_dir string, name string, source string, mode string) {
	res := run_program_with_gc(tmp_dir, name, source, mode)
	if mode != 'none' && res.exit_code != 0 && missing_boehm_lib(res.output) {
		eprintln('skipping ${mode} run for ${name}: missing libgc')
		return
	}
	assert res.exit_code == 0, res.output
}

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

fn write_program(tmp_dir string, name string, source string) string {
	source_path := os.join_path(tmp_dir, '${name}.v')
	os.write_file(source_path, source) or { panic(err) }
	return source_path
}

fn run_program_with_gc(tmp_dir string, name string, source string, mode string) os.Result {
	source_path := write_program(tmp_dir, '${name}_${mode}', source)
	return os.execute('${os.quoted_path(vexe)} -gc ${mode} run ${os.quoted_path(source_path)}')
}

fn compile_program_with_gc(tmp_dir string, name string, source string, mode string) os.Result {
	source_path := write_program(tmp_dir, '${name}_${mode}', source)
	binary_path := os.join_path(tmp_dir, '${name}_${mode}')
	return os.execute('${os.quoted_path(vexe)} -gc ${mode} -o ${os.quoted_path(binary_path)} ${os.quoted_path(source_path)}')
}

fn compile_freestanding_object(tmp_dir string, name string, source string) os.Result {
	source_path := write_program(tmp_dir, name, source)
	object_path := os.join_path(tmp_dir, '${name}.o')
	return os.execute('${os.quoted_path(vexe)} -gc none -freestanding -no-std -is_o -o ${os.quoted_path(object_path)} ${os.quoted_path(source_path)}')
}

fn run_program_with_track_heap(tmp_dir string, name string, source string) os.Result {
	source_path := write_program(tmp_dir, name, source)
	return os.execute('${os.quoted_path(vexe)} -gc none -d track_heap run ${os.quoted_path(source_path)}')
}

fn c_output_for_program(tmp_dir string, name string, source string) os.Result {
	source_path := write_program(tmp_dir, name, source)
	return os.execute('${os.quoted_path(vexe)} -o - ${os.quoted_path(source_path)}')
}

fn assert_boehm_leak_compile_or_missing_lib(tmp_dir string, name string, source string) {
	res := compile_program_with_gc(tmp_dir, name, source, 'boehm_leak')
	if res.exit_code != 0 && missing_boehm_lib(res.output) {
		eprintln('skipping boehm_leak compile for ${name}: missing libgc')
		return
	}
	assert res.exit_code == 0, res.output
}

fn assert_boehm_leak_runtime_or_compile_only(tmp_dir string, name string, source string) {
	res := run_program_with_gc(tmp_dir, name, source, 'boehm_leak')
	if res.exit_code == 0 {
		return
	}
	if missing_boehm_lib(res.output) {
		eprintln('skipping boehm_leak runtime for ${name}: missing libgc')
		return
	}
	if res.output.contains('leaked objects') || res.output.contains('Found ') {
		eprintln('boehm_leak runtime reported runtime allocations for ${name}; keeping compile-only coverage')
		assert_boehm_leak_compile_or_missing_lib(tmp_dir, '${name}_compile_only', source)
		return
	}
	assert false, res.output
}

fn no_captured_closure_lifetime_source() string {
	return [
		'module main',
		'import builtin.closure',
		'',
		'fn no_capture_work() {',
		'\tassert true',
		'}',
		'',
		'fn run() ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tlifetime.frame(no_capture_work)!',
		'\tlifetime.suspend(no_capture_work)!',
		'\tlifetime.untracked(no_capture_work)!',
		'\tlifetime.reclaim_all()!',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n')
}

fn closure_lifetime_runtime_source() string {
	return [
		'module main',
		'import builtin.closure',
		'',
		'fn no_capture_work() {}',
		'',
		'@[heap]',
		'struct CallbackBox {',
		'mut:',
		'\tcb fn () int = fn () int { return -1 }',
		'}',
		'',
		'@[heap]',
		'struct IntBox {',
		'mut:',
		'\tvalue int',
		'}',
		'',
		'fn make_cb(value int) fn () int {',
		'\tpayload := []int{len: 64, init: value + index}',
		'\treturn fn [payload] () int {',
		'\t\treturn payload[0] + payload[payload.len - 1]',
		'\t}',
		'}',
		'',
		'fn call_cb(cb fn () int) int {',
		'\treturn cb()',
		'}',
		'',
		'fn collect_and_churn() {',
		'\tgc_collect()',
		'\tfor _ in 0 .. 512 {',
		'\t\tunsafe {',
		'\t\t\tp := malloc(32)',
		'\t\t\tvmemset(p, 0x55, 32)',
		'\t\t}',
		'\t}',
		'\tgc_collect()',
		'}',
		'',
		'fn outside_lifetime_closure_survives_lifetime_reclaim() ! {',
		'\toutside := make_cb(10)',
		'\tmut lifetime := closure.new_lifetime()',
		'\tlifetime.frame(fn () {',
		'\t\tinside := make_cb(100)',
		'\t\tassert inside() == 263',
		'\t})!',
		'\tlifetime.reclaim_all()!',
		'\tcollect_and_churn()',
		'\tassert outside() == 83',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn reclaim_keeps_requested_recent_frame() ! {',
		'\tmut first := &CallbackBox{}',
		'\tmut second := &CallbackBox{}',
		'\tmut lifetime := closure.new_lifetime()',
		'\tlifetime.frame(fn [mut first] () {',
		'\t\tfirst.cb = make_cb(1)',
		'\t\tassert first.cb() == 65',
		'\t})!',
		'\tlifetime.frame(fn [mut second] () {',
		'\t\tsecond.cb = make_cb(2)',
		'\t\tassert second.cb() == 67',
		'\t})!',
		'\tlifetime.reclaim(1)!',
		'\tcollect_and_churn()',
		'\tassert second.cb() == 67',
		'\tlifetime.reclaim_all()!',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn two_lifetimes_reclaim_independently() ! {',
		'\tmut first := &CallbackBox{}',
		'\tmut second := &CallbackBox{}',
		'\tmut lifetime_a := closure.new_lifetime()',
		'\tmut lifetime_b := closure.new_lifetime()',
		'\tlifetime_a.frame(fn [mut first] () {',
		'\t\tfirst.cb = make_cb(20)',
		'\t\tassert first.cb() == 103',
		'\t})!',
		'\tlifetime_b.frame(fn [mut second] () {',
		'\t\tsecond.cb = make_cb(30)',
		'\t\tassert second.cb() == 123',
		'\t})!',
		'\tlifetime_a.reclaim_all()!',
		'\tcollect_and_churn()',
		'\tassert second.cb() == 123',
		'\tlifetime_b.reclaim_all()!',
		'\tlifetime_a.dispose()!',
		'\tlifetime_b.dispose()!',
		'}',
		'',
		'fn suspended_persistent_callbacks_survive_reclaim_and_spawn() ! {',
		'\tmut persisted := &CallbackBox{}',
		'\tmut spawned_value := &IntBox{value: -1}',
		'\tmut lifetime := closure.new_lifetime()',
		'\tlifetime.frame(fn [mut lifetime, mut persisted, mut spawned_value] () {',
		'\t\tshort := make_cb(5)',
		'\t\tassert short() == 73',
		'\t\tlifetime.suspend(fn [mut persisted, mut spawned_value] () {',
		'\t\t\tpersisted.cb = make_cb(40)',
		'\t\t\tth := spawn call_cb(persisted.cb)',
		'\t\t\tspawned_value.value = th.wait()',
		'\t\t}) or { panic(err) }',
		'\t})!',
		'\tlifetime.reclaim_all()!',
		'\tcollect_and_churn()',
		'\tassert persisted.cb() == 143',
		'\tassert spawned_value.value == 143',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn stale_reused_slot_does_not_release_suspended_newer_closure() ! {',
		'\tmut survivor := &CallbackBox{}',
		'\tmut lifetime := closure.new_lifetime()',
		'\tlifetime.frame(fn [mut lifetime, mut survivor] () {',
		'\t\tfor i in 0 .. 96 {',
		'\t\t\th := fn [i] () int { return i }',
		'\t\t\tassert h() == i',
		'\t\t}',
		'\t\tlifetime.suspend(fn [mut survivor] () {',
		'\t\t\tsurvivor.cb = make_cb(70)',
		'\t\t\tassert survivor.cb() == 203',
		'\t\t}) or { panic(err) }',
		'\t})!',
		'\tlifetime.reclaim_all()!',
		'\tcollect_and_churn()',
		'\tassert survivor.cb() == 203',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn direct_untracked_callback_is_public_api() ! {',
		'\tmut marker := &IntBox{value: -1}',
		'\tmut lifetime := closure.new_lifetime()',
		'\tlifetime.frame(fn [mut lifetime, mut marker] () {',
		'\t\tlifetime.untracked(fn [mut marker] () {',
		'\t\t\tmarker.value = 91',
		'\t\t}) or { panic(err) }',
		'\t})!',
		'\tlifetime.reclaim_all()!',
		'\tassert marker.value == 91',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn local_cleanup_and_lifetime_reclaim_do_not_double_release() ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tfor i in 0 .. 1024 {',
		'\t\tlifetime.frame(fn [i] () {',
		'\t\t\th := fn [i] () int { return i + 1 }',
		'\t\t\tassert h() == i + 1',
		'\t\t})!',
		'\t\tlifetime.reclaim_all()!',
		'\t}',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn lifetime_reclaim_does_not_accumulate_owned_escaping_closures() ! {',
		'\t$if gcboehm ? {',
		'\t\tmut cb := &CallbackBox{}',
		'\t\tmut lifetime := closure.new_lifetime()',
		'\t\tgc_collect()',
		'\t\tstart_mb := gc_memory_use() / 1024 / 1024',
		'\t\tfor n in 0 .. 20_000 {',
		'\t\t\tlifetime.frame(fn [mut cb, n] () {',
		'\t\t\t\tbig := []int{len: 512, init: n + index}',
		'\t\t\t\tcb.cb = fn [big] () int {',
		'\t\t\t\t\treturn big[0] + big[big.len - 1]',
		'\t\t\t\t}',
		'\t\t\t\tassert cb.cb() == 2 * n + 511',
		'\t\t\t})!',
		'\t\t\tlifetime.reclaim_all()!',
		'\t\t\tif n % 5000 == 0 {',
		'\t\t\t\tgc_collect()',
		'\t\t\t}',
		'\t\t}',
		'\t\tgc_collect()',
		'\t\tend_mb := gc_memory_use() / 1024 / 1024',
		'\t\tassert end_mb <= start_mb + 24',
		'\t}',
		'}',
		'',
		'fn external_captured_frame_callback_survives_reclaim_all() ! {',
		'\tpayload := []int{len: 64, init: 200 + index}',
		'\tcb := fn [payload] () {',
		'\t\tassert payload[0] == 200',
		'\t\tassert payload[payload.len - 1] == 263',
		'\t}',
		'\tmut lifetime := closure.new_lifetime()',
		'\tlifetime.frame(cb)!',
		'\tlifetime.reclaim_all()!',
		'\tcollect_and_churn()',
		'\tcb()',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn parenthesized_frame_return_with_captured_callback() ! {',
		'\tx := 37',
		'\tmut lifetime := closure.new_lifetime()',
		'\tdefer {',
		'\t\tlifetime.dispose() or {}',
		'\t}',
		'\treturn (lifetime.frame(fn [x] () {',
		'\t\tassert x == 37',
		'\t}))',
		'}',
		'',
		'fn frame_end_uses_original_token_state_after_lifetime_reassign() ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tmut original := lifetime',
		'\tlifetime.frame(fn [mut lifetime] () {',
		'\t\tlifetime = closure.new_lifetime()',
		'\t})!',
		'\tmut next := closure.new_lifetime()',
		'\tnext.frame(no_capture_work)!',
		'\tnext.dispose()!',
		'\toriginal.dispose()!',
		'}',
		'',
		'fn lifetime_copies_after_dispose_report_error() ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tmut copy := lifetime',
		'\tlifetime.dispose()!',
		'\tcollect_and_churn()',
		'\tmut replacement := closure.new_lifetime()',
		'\treplacement.frame(no_capture_work)!',
		'\tmut saw_frame := false',
		'\tmut saw_reclaim := false',
		'\tmut saw_suspend := false',
		'\tmut saw_untracked := false',
		'\tmut saw_dispose := false',
		'\tcopy.frame(no_capture_work) or {',
		"\t\tassert err.msg().contains('dispose') || err.msg().contains('after')",
		'\t\tsaw_frame = true',
		'\t}',
		'\tcopy.reclaim_all() or {',
		"\t\tassert err.msg().contains('dispose') || err.msg().contains('after')",
		'\t\tsaw_reclaim = true',
		'\t}',
		'\tcopy.suspend(no_capture_work) or {',
		"\t\tassert err.msg().contains('dispose') || err.msg().contains('after')",
		'\t\tsaw_suspend = true',
		'\t}',
		'\tcopy.untracked(no_capture_work) or {',
		"\t\tassert err.msg().contains('dispose') || err.msg().contains('after')",
		'\t\tsaw_untracked = true',
		'\t}',
		'\tcopy.dispose() or {',
		"\t\tassert err.msg().contains('dispose') || err.msg().contains('after')",
		'\t\tsaw_dispose = true',
		'\t}',
		'\tassert saw_frame',
		'\tassert saw_reclaim',
		'\tassert saw_suspend',
		'\tassert saw_untracked',
		'\tassert saw_dispose',
		'\treplacement.dispose()!',
		'}',
		'',
		'fn run() ! {',
		'\toutside_lifetime_closure_survives_lifetime_reclaim()!',
		'\treclaim_keeps_requested_recent_frame()!',
		'\ttwo_lifetimes_reclaim_independently()!',
		'\tsuspended_persistent_callbacks_survive_reclaim_and_spawn()!',
		'\tstale_reused_slot_does_not_release_suspended_newer_closure()!',
		'\tdirect_untracked_callback_is_public_api()!',
		'\tlocal_cleanup_and_lifetime_reclaim_do_not_double_release()!',
		'\tlifetime_reclaim_does_not_accumulate_owned_escaping_closures()!',
		'\texternal_captured_frame_callback_survives_reclaim_all()!',
		'\tparenthesized_frame_return_with_captured_callback()!',
		'\tframe_end_uses_original_token_state_after_lifetime_reassign()!',
		'\tlifetime_copies_after_dispose_report_error()!',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n')
}

fn boehm_leak_clean_lifetime_source() string {
	return [
		'module main',
		'import builtin.closure',
		'',
		'fn make_cb(value int) fn () int {',
		'\treturn fn [value] () int {',
		'\t\treturn value + 1',
		'\t}',
		'}',
		'',
		'fn run() ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tfor n in 0 .. 128 {',
		'\t\tlifetime.frame(fn [n] () {',
		'\t\t\tcb := make_cb(n)',
		'\t\t\tassert cb() == n + 1',
		'\t\t})!',
		'\t\tlifetime.reclaim_all()!',
		'\t}',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n')
}

fn gc_none_lifetime_reclaim_memory_source() string {
	return [
		'module main',
		'import builtin.closure',
		'import runtime',
		'',
		'fn used_mb() u64 {',
		'\tused := runtime.used_memory() or { return 0 }',
		'\treturn used / 1024 / 1024',
		'}',
		'',
		'fn frame_callback_context_is_reclaimed() ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tmut start_mb := u64(0)',
		'\tfor n in 0 .. 220000 {',
		'\t\ta0 := n',
		'\t\ta1 := n + 1',
		'\t\ta2 := n + 2',
		'\t\ta3 := n + 3',
		'\t\ta4 := n + 4',
		'\t\ta5 := n + 5',
		'\t\ta6 := n + 6',
		'\t\ta7 := n + 7',
		'\t\ta8 := n + 8',
		'\t\ta9 := n + 9',
		'\t\ta10 := n + 10',
		'\t\ta11 := n + 11',
		'\t\ta12 := n + 12',
		'\t\ta13 := n + 13',
		'\t\ta14 := n + 14',
		'\t\ta15 := n + 15',
		'\t\tlifetime.frame(fn [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15] () {',
		'\t\t\tassert a0 + a1 + a2 + a3 + a4 + a5 + a6 + a7 == 8 * a0 + 28',
		'\t\t\tassert a8 + a9 + a10 + a11 + a12 + a13 + a14 + a15 == 8 * a0 + 92',
		'\t\t})!',
		'\t\tlifetime.reclaim_all()!',
		'\t\tif n == 2048 {',
		'\t\t\tstart_mb = used_mb()',
		'\t\t}',
		'\t}',
		'\tend_mb := used_mb()',
		'\tif start_mb > 0 && end_mb > start_mb + 64 {',
		"\t\tpanic('closure frame callback memory grew too much')",
		'\t}',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn run() ! {',
		'\tframe_callback_context_is_reclaimed()!',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n')
}

fn gc_none_lifetime_bookkeeping_track_heap_source(header_path string) string {
	c_header_path := header_path.replace('\\', '/')
	return [
		'module main',
		'import builtin.closure',
		'',
		'#include "${c_header_path}"',
		'',
		'fn no_capture_work() {}',
		'',
		'fn exercise(rounds int) ! {',
		'\tfor _ in 0 .. rounds {',
		'\t\tmut lifetime := closure.new_lifetime()',
		'\t\tmut copy := lifetime',
		'\t\tlifetime.dispose()!',
		'\t\tcopy.frame(no_capture_work) or {',
		'\t\t\tcontinue',
		'\t\t}',
		"\t\treturn error('disposed lifetime copy was accepted')",
		'\t}',
		'}',
		'',
		'fn main() {',
		'\tmut warmup := closure.new_lifetime()',
		'\twarmup.dispose() or { panic(err) }',
		'\texercise(128) or { panic(err) }',
		'\tmut start := u64(0)',
		'\tunsafe { closure.lifetime_state_allocs(&start) }',
		'\texercise(1000) or { panic(err) }',
		'\tmut end := u64(0)',
		'\tunsafe { closure.lifetime_state_allocs(&end) }',
		'\tif end != start {',
		"\t\tpanic('leaked lifetime state recycling bookkeeping: start=\${start} end=\${end}')",
		'\t}',
		'}',
	].join('\n')
}

fn lazy_concurrent_lifetime_init_source() string {
	return [
		'module main',
		'import builtin.closure',
		'',
		'@[heap]',
		'struct IntBox {',
		'mut:',
		'\tvalue int',
		'}',
		'',
		'fn worker(id int, ready chan bool, start chan bool) ! {',
		'\tready <- true',
		"\t_ := <-start or { return error('start channel closed') }",
		'\tfor round in 0 .. 32 {',
		'\t\tmut box := &IntBox{}',
		'\t\texpected := id * 1000 + round',
		'\t\tmut lifetime := closure.new_lifetime()',
		'\t\tlifetime.frame(fn [mut box, expected] () {',
		'\t\t\tmake_value := fn [expected] () int { return expected }',
		'\t\t\tbox.value = make_value()',
		'\t\t})!',
		'\t\tassert box.value == expected',
		'\t\tlifetime.dispose()!',
		'\t}',
		'}',
		'',
		'fn run() ! {',
		'\tthread_count := 16',
		'\tready := chan bool{cap: thread_count}',
		'\tstart := chan bool{cap: thread_count}',
		'\tmut threads := []thread !{cap: thread_count}',
		'\tfor i in 0 .. thread_count {',
		'\t\tthreads << spawn worker(i, ready, start)',
		'\t}',
		'\tfor _ in 0 .. thread_count {',
		"\t\t_ := <-ready or { return error('ready channel closed') }",
		'\t}',
		'\tfor _ in 0 .. thread_count {',
		'\t\tstart <- true',
		'\t}',
		'\tthreads.wait()!',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n')
}

fn assert_misuse_program_passes(tmp_dir string, name string, source string) {
	source_path := write_program(tmp_dir, name, source)
	res := os.execute('${os.quoted_path(vexe)} run ${os.quoted_path(source_path)}')
	assert res.exit_code == 0, res.output
}

fn test_lifetime_public_api_without_captured_closure() {
	$if gcboehm_leak ? {
		return
	}
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_closure_lifetime_no_capture_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source := no_captured_closure_lifetime_source()
	c_res := c_output_for_program(tmp_dir, 'no_captured_lifetime_codegen', source)
	assert c_res.exit_code == 0, c_res.output
	assert !c_res.output.contains('builtin__closure__closure_create')
	assert !c_res.output.contains('_V_closure_main__')
	for mode in ['boehm', 'none'] {
		assert_run_succeeds_or_missing_boehm(tmp_dir, 'no_captured_lifetime', source, mode)
	}
	assert_boehm_leak_compile_or_missing_lib(tmp_dir, 'no_captured_lifetime', source)
}

fn test_closure_lifetime_runtime_api_contract() {
	$if gcboehm_leak ? {
		return
	}
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_closure_lifetime_runtime_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source := closure_lifetime_runtime_source()
	for mode in ['boehm', 'none'] {
		assert_run_succeeds_or_missing_boehm(tmp_dir, 'closure_lifetime_runtime', source, mode)
	}
	assert_boehm_leak_compile_or_missing_lib(tmp_dir, 'closure_lifetime_runtime', source)
}

fn test_closure_lifetime_boehm_leak_runtime_without_persistent_callbacks() {
	$if gcboehm_leak ? {
		return
	}
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_closure_lifetime_boehm_leak_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	assert_boehm_leak_runtime_or_compile_only(tmp_dir, 'closure_lifetime_boehm_leak_clean',
		boehm_leak_clean_lifetime_source())
}

fn test_closure_lifetime_gc_none_does_not_leak_frame_callback_or_bookkeeping() {
	$if gcboehm_leak ? {
		return
	}
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_closure_lifetime_gc_none_memory_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	res := run_program_with_gc(tmp_dir, 'closure_lifetime_gc_none_memory',
		gc_none_lifetime_reclaim_memory_source(), 'none')
	assert res.exit_code == 0, res.output
}

fn test_closure_lifetime_gc_none_reuses_disposed_state_bookkeeping() {
	$if gcboehm_leak ? {
		return
	}
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_closure_lifetime_gc_none_state_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	header_path := os.join_path(tmp_dir, 'track_heap_hooks.h')
	os.write_file(header_path, [
		'void vheap_alloc(void* p, unsigned long long n) { (void)p; (void)n; }',
		'void vheap_free(void* p) { (void)p; }',
	].join('\n')) or { panic(err) }
	res := run_program_with_track_heap(tmp_dir, 'closure_lifetime_gc_none_state',
		gc_none_lifetime_bookkeeping_track_heap_source(header_path))
	assert res.exit_code == 0, res.output
}

fn test_closure_lifetime_dispose_recycles_state_for_later_lifetimes() {
	source_path := os.join_path(os.dir(vexe), 'vlib/builtin/closure/closure.c.v')
	source := os.read_file(source_path) or { panic(err) }
	start := source.index('pub fn (mut lifetime Lifetime) dispose() !') or {
		panic('missing dispose helper')
	}
	end := source[start..].index('pub fn (mut lifetime Lifetime) suspend') or {
		panic('missing dispose helper end')
	}
	helper := source[start..start + end]
	assert helper.contains('closure_lifetime_recycle_state_no_lock(mut state)')
	assert helper.contains('lifetime.state = unsafe { nil }')
	assert helper.contains('lifetime.disposed = true')
	assert !helper.contains('free(state)')
}

fn test_closure_lifetime_freestanding_no_std_object_compile() {
	$if !linux {
		return
	}
	$if !amd64 {
		return
	}
	$if gcboehm_leak ? {
		return
	}
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_closure_lifetime_freestanding_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source := [
		'module main',
		'import builtin.closure',
		'',
		'fn main() {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tlifetime.dispose() or { panic(err) }',
		'}',
	].join('\n')
	res := compile_freestanding_object(tmp_dir, 'closure_lifetime_freestanding', source)
	assert res.exit_code == 0, res.output
}

fn test_closure_lifetime_lazy_concurrent_runtime_init() {
	$if gcboehm_leak ? {
		return
	}
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_closure_lifetime_lazy_init_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source := lazy_concurrent_lifetime_init_source()
	for mode in ['none', 'boehm'] {
		assert_run_succeeds_or_missing_boehm(tmp_dir, 'closure_lifetime_lazy_init', source, mode)
	}
}

fn test_closure_lifetime_reclaim_helper_reuses_buffers_without_clone() {
	source_path := os.join_path(os.dir(vexe), 'vlib/builtin/closure/closure.c.v')
	source := os.read_file(source_path) or { panic(err) }
	start := source.index('fn closure_lifetime_reclaim_no_lock') or {
		panic('missing reclaim helper')
	}
	end := source[start..].index('fn closure_ensure_initialized') or {
		panic('missing reclaim helper end')
	}
	helper := source[start..start + end]
	assert !helper.contains('.clone()')
	assert helper.contains('delete_many(0, reclaim_count)')
	assert helper.contains('delete_many(0, cutoff)')
}

fn test_closure_lifetime_dispose_frees_bookkeeping_buffers_but_keeps_state() {
	source_path := os.join_path(os.dir(vexe), 'vlib/builtin/closure/closure.c.v')
	source := os.read_file(source_path) or { panic(err) }
	start := source.index('fn closure_lifetime_recycle_state_no_lock') or {
		panic('missing recycle helper')
	}
	end := source[start..].index('fn closure_lifetime_error') or {
		panic('missing recycle helper end')
	}
	helper := source[start..start + end]
	assert helper.contains('state.disposed = true')
	assert helper.contains('state.records.free()')
	assert helper.contains('state.frames.free()')
	assert helper.contains('state.records = []ClosureLifetimeRecord{}')
	assert helper.contains('state.frames = []ClosureLifetimeFrame{}')
	assert helper.contains('state.next_free = g_closure.free_lifetime_states')
	assert helper.contains('g_closure.free_lifetime_states = state')
	assert !helper.contains('free(state)')
}

fn test_closure_lifetime_once_headers_keep_helper_internal() {
	for header_name in ['closure_once_nix.h', 'closure_once_windows.h'] {
		source_path := os.join_path(os.dir(vexe), 'vlib/builtin/closure/${header_name}')
		source := os.read_file(source_path) or { panic(err) }
		assert source.contains('V_CLOSURE_STATIC_INLINE void v_closure_init_once')
		assert !source.contains('\nvoid v_closure_init_once')
	}
}

fn test_closure_lifetime_codegen_emits_single_local_destroy() {
	$if gcboehm_leak ? {
		return
	}
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_closure_lifetime_codegen_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source := [
		'module main',
		'import builtin.closure',
		'',
		'fn run() ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tlifetime.frame(fn () {',
		'\t\tvalue := 7',
		'\t\th := fn [value] () int { return value }',
		'\t\tassert h() == 7',
		'\t})!',
		'\tlifetime.reclaim_all()!',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n')
	res := c_output_for_program(tmp_dir, 'closure_lifetime_single_destroy', source)
	assert res.exit_code == 0, res.output
	assert count_occurrences(res.output, 'builtin__closure__closure_try_destroy((voidptr)h);') == 1
}

fn test_closure_lifetime_inline_callback_codegen_cleanup() {
	$if gcboehm_leak ? {
		return
	}
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_closure_lifetime_inline_codegen_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source := [
		'module main',
		'import builtin.closure',
		'',
		'struct View {',
		'\tvalue int',
		'}',
		'',
		'fn (view View) draw() {',
		'\tassert view.value == 41',
		'}',
		'',
		'fn frame_bound_method() ! {',
		'\tview := View{value: 41}',
		'\tmut lifetime := closure.new_lifetime()',
		'\tlifetime.frame(view.draw)!',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn outside_suspend_untracked() ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tvalue := 7',
		'\tlifetime.suspend(fn [value] () {',
		'\t\tassert value == 7',
		'\t})!',
		'\tlifetime.untracked(fn [value] () {',
		'\t\tassert value == 7',
		'\t})!',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn parenthesized_inline_frame() ! {',
		'\tvalue := 12',
		'\tmut lifetime := closure.new_lifetime()',
		'\tlifetime.frame((fn [value] () {',
		'\t\tassert value == 12',
		'\t}))!',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn tail_return_frame(value int) ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\treturn lifetime.frame(fn [value] () {',
		'\t\tassert value == 9',
		'\t})',
		'}',
		'',
		'fn main() {',
		'\tframe_bound_method() or { panic(err) }',
		'\toutside_suspend_untracked() or { panic(err) }',
		'\tparenthesized_inline_frame() or { panic(err) }',
		'\ttail_return_frame(9) or { panic(err) }',
		'}',
	].join('\n')
	res := c_output_for_program(tmp_dir, 'closure_lifetime_inline_cleanup', source)
	assert res.exit_code == 0, res.output
	destroy_count := count_occurrences(res.output,
		'builtin__closure__closure_try_destroy((voidptr)')
	assert destroy_count == 5, res.output
	parenthesized_start := res.output.index('VV_LOC _result_void main__parenthesized_inline_frame(void) {') or {
		panic(res.output)
	}
	parenthesized_end := if parenthesized_start + 1200 < res.output.len {
		parenthesized_start + 1200
	} else {
		res.output.len
	}
	parenthesized_fn := res.output[parenthesized_start..parenthesized_end]
	frame_pos := parenthesized_fn.index('builtin__closure__Lifetime_frame') or {
		panic(parenthesized_fn)
	}
	destroy_pos := parenthesized_fn.index('builtin__closure__closure_try_destroy((voidptr)') or {
		panic(parenthesized_fn)
	}
	assert destroy_pos > frame_pos, parenthesized_fn
	assert !res.output.contains('return builtin__closure__Lifetime_frame(')
}

fn test_closure_lifetime_borrowed_callback_result_is_not_destroyed() {
	$if gcboehm_leak ? {
		return
	}
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_closure_lifetime_borrowed_callback_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	source := [
		'module main',
		'import builtin.closure',
		'',
		'fn identity(cb fn ()) fn () {',
		'\treturn cb',
		'}',
		'',
		'fn run() ! {',
		'\tpayload := []int{len: 32, init: index}',
		'\tstored := fn [payload] () {',
		'\t\tassert payload[0] == 0',
		'\t\tassert payload[payload.len - 1] == 31',
		'\t}',
		'\tmut lifetime := closure.new_lifetime()',
		'\tlifetime.frame(identity(stored))!',
		'\tlifetime.dispose()!',
		'\tstored()',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n')
	c_res := c_output_for_program(tmp_dir, 'closure_lifetime_borrowed_callback_cgen', source)
	assert c_res.exit_code == 0, c_res.output
	run_start := c_res.output.index('VV_LOC _result_void main__run(void) {') or {
		panic(c_res.output)
	}
	run_end := c_res.output.index_after('VV_LOC void main__main(void) {', run_start) or {
		panic(c_res.output)
	}
	run_fn := c_res.output[run_start..run_end]
	assert !run_fn.contains('builtin__closure__closure_try_destroy((voidptr)'), run_fn
	res := run_program_with_gc(tmp_dir, 'closure_lifetime_borrowed_callback', source, 'none')
	assert res.exit_code == 0, res.output
}

fn test_lifetime_rejects_misuse_with_errors() {
	$if gcboehm_leak ? {
		return
	}
	tmp_dir := os.join_path(os.vtmp_dir(), 'v_closure_lifetime_api_${os.getpid()}')
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	assert_misuse_program_passes(tmp_dir, 'wrong_thread_reclaim', [
		'import builtin.closure',
		'',
		'fn reclaim_from_thread(lifetime closure.Lifetime) ! {',
		'\tmut local := lifetime',
		'\tlocal.reclaim_all()!',
		'}',
		'',
		'fn main() {',
		'\tlifetime := closure.new_lifetime()',
		'\tth := spawn reclaim_from_thread(lifetime)',
		'\tth.wait() or {',
		"\t\tassert err.msg().contains('different thread')",
		'\t\treturn',
		'\t}',
		'\tassert false',
		'}',
	].join('\n'))
	assert_misuse_program_passes(tmp_dir, 'wrong_thread_dispose', [
		'import builtin.closure',
		'',
		'fn dispose_from_thread(lifetime closure.Lifetime) ! {',
		'\tmut local := lifetime',
		'\tlocal.dispose()!',
		'}',
		'',
		'fn main() {',
		'\tlifetime := closure.new_lifetime()',
		'\tth := spawn dispose_from_thread(lifetime)',
		'\tth.wait() or {',
		"\t\tassert err.msg().contains('different thread')",
		'\t\treturn',
		'\t}',
		'\tassert false',
		'}',
	].join('\n'))
	assert_misuse_program_passes(tmp_dir, 'wrong_thread_suspend', [
		'import builtin.closure',
		'',
		'fn no_capture_work() {}',
		'',
		'fn suspend_from_thread(lifetime closure.Lifetime) ! {',
		'\tmut local := lifetime',
		'\tlocal.suspend(no_capture_work)!',
		'}',
		'',
		'fn main() {',
		'\tlifetime := closure.new_lifetime()',
		'\tth := spawn suspend_from_thread(lifetime)',
		'\tth.wait() or {',
		"\t\tassert err.msg().contains('different thread')",
		'\t\treturn',
		'\t}',
		'\tassert false',
		'}',
	].join('\n'))
	assert_misuse_program_passes(tmp_dir, 'wrong_thread_frame', [
		'import builtin.closure',
		'',
		'fn no_capture_work() {}',
		'',
		'fn frame_from_thread(lifetime closure.Lifetime) ! {',
		'\tmut local := lifetime',
		'\tlocal.frame(no_capture_work)!',
		'}',
		'',
		'fn main() {',
		'\tlifetime := closure.new_lifetime()',
		'\tth := spawn frame_from_thread(lifetime)',
		'\tth.wait() or {',
		"\t\tassert err.msg().contains('different thread')",
		'\t\treturn',
		'\t}',
		'\tassert false',
		'}',
	].join('\n'))
	assert_misuse_program_passes(tmp_dir, 'nested_same_lifetime_frame', [
		'import builtin.closure',
		'',
		'@[heap]',
		'struct BoolBox {',
		'mut:',
		'\tvalue bool',
		'}',
		'',
		'fn no_capture_work() {}',
		'',
		'fn run() ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tmut saw := &BoolBox{}',
		'\tlifetime.frame(fn [mut lifetime, mut saw] () {',
		'\t\tlifetime.frame(no_capture_work) or {',
		"\t\t\tassert err.msg().contains('active') || err.msg().contains('nested')",
		'\t\t\tsaw.value = true',
		'\t\t\treturn',
		'\t\t}',
		'\t\tassert false',
		'\t})!',
		'\tassert saw.value',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n'))
	assert_misuse_program_passes(tmp_dir, 'second_active_lifetime', [
		'import builtin.closure',
		'',
		'@[heap]',
		'struct BoolBox {',
		'mut:',
		'\tvalue bool',
		'}',
		'',
		'fn no_capture_work() {}',
		'',
		'fn run() ! {',
		'\tmut first := closure.new_lifetime()',
		'\tmut second := closure.new_lifetime()',
		'\tmut saw := &BoolBox{}',
		'\tfirst.frame(fn [mut second, mut saw] () {',
		'\t\tsecond.frame(no_capture_work) or {',
		"\t\t\tassert err.msg().contains('active') || err.msg().contains('another')",
		'\t\t\tsaw.value = true',
		'\t\t\treturn',
		'\t\t}',
		'\t\tassert false',
		'\t})!',
		'\tassert saw.value',
		'\tfirst.dispose()!',
		'\tsecond.dispose()!',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n'))
	assert_misuse_program_passes(tmp_dir, 'second_suspend_inside_first_frame', [
		'import builtin.closure',
		'',
		'@[heap]',
		'struct BoolBox {',
		'mut:',
		'\tvalue bool',
		'}',
		'',
		'fn no_capture_work() {}',
		'',
		'fn run() ! {',
		'\tmut first := closure.new_lifetime()',
		'\tmut second := closure.new_lifetime()',
		'\tmut saw := &BoolBox{}',
		'\tfirst.frame(fn [mut second, mut saw] () {',
		'\t\tsecond.suspend(no_capture_work) or {',
		"\t\t\tassert err.msg().contains('active') || err.msg().contains('another')",
		'\t\t\tsaw.value = true',
		'\t\t\treturn',
		'\t\t}',
		'\t\tassert false',
		'\t})!',
		'\tassert saw.value',
		'\tfirst.dispose()!',
		'\tsecond.dispose()!',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n'))
	assert_misuse_program_passes(tmp_dir, 'reclaim_dispose_while_active', [
		'import builtin.closure',
		'',
		'@[heap]',
		'struct BoolBox {',
		'mut:',
		'\tvalue bool',
		'}',
		'',
		'fn run() ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tmut saw_reclaim := &BoolBox{}',
		'\tmut saw_dispose := &BoolBox{}',
		'\tlifetime.frame(fn [mut lifetime, mut saw_reclaim, mut saw_dispose] () {',
		'\t\tlifetime.reclaim_all() or {',
		"\t\t\tassert err.msg().contains('active')",
		'\t\t\tsaw_reclaim.value = true',
		'\t\t}',
		'\t\tlifetime.dispose() or {',
		"\t\t\tassert err.msg().contains('active')",
		'\t\t\tsaw_dispose.value = true',
		'\t\t\treturn',
		'\t\t}',
		'\t\tassert false',
		'\t})!',
		'\tassert saw_reclaim.value',
		'\tassert saw_dispose.value',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n'))
	assert_misuse_program_passes(tmp_dir, 'dispose_while_suspended', [
		'import builtin.closure',
		'',
		'@[heap]',
		'struct BoolBox {',
		'mut:',
		'\tvalue bool',
		'}',
		'',
		'fn run() ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tmut saw := &BoolBox{}',
		'\tlifetime.suspend(fn [mut lifetime, mut saw] () {',
		'\t\tlifetime.dispose() or {',
		"\t\t\tassert err.msg().contains('suspend')",
		'\t\t\tsaw.value = true',
		'\t\t\treturn',
		'\t\t}',
		'\t\tassert false',
		'\t})!',
		'\tassert saw.value',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n'))
	assert_misuse_program_passes(tmp_dir, 'dispose_while_untracked', [
		'import builtin.closure',
		'',
		'@[heap]',
		'struct BoolBox {',
		'mut:',
		'\tvalue bool',
		'}',
		'',
		'fn run() ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tmut saw := &BoolBox{}',
		'\tlifetime.untracked(fn [mut lifetime, mut saw] () {',
		'\t\tlifetime.dispose() or {',
		"\t\t\tassert err.msg().contains('suspend')",
		'\t\t\tsaw.value = true',
		'\t\t\treturn',
		'\t\t}',
		'\t\tassert false',
		'\t})!',
		'\tassert saw.value',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n'))
	assert_misuse_program_passes(tmp_dir, 'frame_while_suspended', [
		'import builtin.closure',
		'',
		'@[heap]',
		'struct BoolBox {',
		'mut:',
		'\tvalue bool',
		'}',
		'',
		'fn no_capture_work() {}',
		'',
		'fn run() ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tmut saw := &BoolBox{}',
		'\tlifetime.suspend(fn [mut lifetime, mut saw] () {',
		'\t\tlifetime.frame(no_capture_work) or {',
		"\t\t\tassert err.msg().contains('suspend')",
		'\t\t\tsaw.value = true',
		'\t\t\treturn',
		'\t\t}',
		'\t\tassert false',
		'\t})!',
		'\tassert saw.value',
		'\tlifetime.dispose()!',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n'))
	assert_misuse_program_passes(tmp_dir, 'use_after_dispose', [
		'import builtin.closure',
		'',
		'fn no_capture_work() {}',
		'',
		'fn run() ! {',
		'\tmut lifetime := closure.new_lifetime()',
		'\tlifetime.dispose()!',
		'\tmut saw_frame := false',
		'\tmut saw_reclaim := false',
		'\tmut saw_suspend := false',
		'\tmut saw_untracked := false',
		'\tmut saw_dispose := false',
		'\tlifetime.frame(no_capture_work) or {',
		"\t\tassert err.msg().contains('dispose') || err.msg().contains('after')",
		'\t\tsaw_frame = true',
		'\t}',
		'\tlifetime.reclaim_all() or {',
		"\t\tassert err.msg().contains('dispose') || err.msg().contains('after')",
		'\t\tsaw_reclaim = true',
		'\t}',
		'\tlifetime.suspend(no_capture_work) or {',
		"\t\tassert err.msg().contains('dispose') || err.msg().contains('after')",
		'\t\tsaw_suspend = true',
		'\t}',
		'\tlifetime.untracked(no_capture_work) or {',
		"\t\tassert err.msg().contains('dispose') || err.msg().contains('after')",
		'\t\tsaw_untracked = true',
		'\t}',
		'\tlifetime.dispose() or {',
		"\t\tassert err.msg().contains('dispose') || err.msg().contains('after')",
		'\t\tsaw_dispose = true',
		'\t}',
		'\tassert saw_frame',
		'\tassert saw_reclaim',
		'\tassert saw_suspend',
		'\tassert saw_untracked',
		'\tassert saw_dispose',
		'}',
		'',
		'fn main() {',
		'\trun() or { panic(err) }',
		'}',
	].join('\n'))
}