// vtest build: !(macos || windows)

module atomics

fn test_load_i64_basic() {
	mut x := i64(1234567890123)
	assert load_i64(&x) == 1234567890123
}

fn test_store_i64_basic() {
	mut x := i64(1)
	store_i64(&x, 9999999)
	assert x == 9999999
}

fn test_swap_i64_basic() {
	mut x := i64(50)
	old := swap_i64(&x, 777)
	assert old == 50
	assert x == 777
}

fn test_swap_i64_same_value() {
	mut x := i64(-123)
	old := swap_i64(&x, -123)
	assert old == -123
	assert x == -123
}

fn test_add_i64_basic() {
	mut x := i64(0)
	for _ in 0 .. 1000 {
		add_i64(&x, 3)
	}
	assert x == 3000
}

fn test_add_i64_negative_delta() {
	mut x := i64(100)
	add_i64(&x, -7)
	assert x == 93
}

fn test_add_i64_wraparound_behavior() {
	mut x := i64(0x7fffffffffffffff)
	add_i64(&x, 1)
	assert x == -0x8000000000000000
}

fn test_add_i64_return_value() {
	mut x := i64(10)
	r := add_i64(&x, 100)
	assert r == 110
	assert x == 110
}

fn test_cas_i64_basic() {
	mut x := i64(111)
	assert cas_i64(&x, 111, 222)
	assert x == 222
}

fn test_cas_i64_fail() {
	mut x := i64(555)
	assert !cas_i64(&x, 123, 999)
	assert x == 555
}

fn test_cas_i64_nochange_on_fail() {
	mut x := i64(-999)
	cas_i64(&x, 1, 5)
	assert x == -999
}

fn test_cas_i64_negative_values() {
	mut x := i64(-123456)
	assert cas_i64(&x, -123456, 777)
	assert x == 777
}

fn test_add_i64_concurrent() {
	mut x := i64(0)
	mut threads := []thread{}

	for _ in 0 .. 8 {
		threads << spawn fn (px &i64) {
			for _ in 0 .. 100_000 {
				add_i64(px, 1)
			}
		}(&x)
	}

	for t in threads {
		t.wait()
	}

	assert x == 800_000
}

fn test_swap_i64_concurrent() {
	mut x := i64(0)
	mut threads := []thread{}

	for _ in 0 .. 8 {
		threads << spawn fn (px &i64) {
			for _ in 0 .. 50_000 {
				swap_i64(px, 12345)
			}
		}(&x)
	}

	for t in threads {
		t.wait()
	}

	assert x == 12345
}

fn test_cas_i64_concurrent_inc() {
	mut x := i64(0)
	mut threads := []thread{}

	for _ in 0 .. 8 {
		threads << spawn fn (px &i64) {
			for _ in 0 .. 50_000 {
				for {
					old := load_i64(px)
					if cas_i64(px, old, old + 1) {
						break
					}
				}
			}
		}(&x)
	}

	for t in threads {
		t.wait()
	}

	assert x == 400_000
}

fn test_cas_i64_contended_flip() {
	mut x := i64(0)
	mut threads := []thread{}

	for _ in 0 .. 4 {
		threads << spawn fn (px &i64) {
			for _ in 0 .. 200_000 {
				cas_i64(px, 0, 1)
				cas_i64(px, 1, 0)
			}
		}(&x)
	}

	for t in threads {
		t.wait()
	}

	assert x == 0 || x == 1
}

fn test_and_i64_concurrent() {
	mut x := i64(0x7fffffffffffffff)
	mut threads := []thread{}
	for _ in 0 .. 8 {
		threads << spawn fn (px &i64) {
			for _ in 0 .. 100_000 {
				and_i64(px, 0x00ffffffffffffff)
			}
		}(&x)
	}
	for t in threads {
		t.wait()
	}
	assert x == 0x00ffffffffffffff
}

fn test_or_i64_concurrent() {
	mut x := i64(0)
	mut threads := []thread{}
	for _ in 0 .. 8 {
		threads << spawn fn (px &i64) {
			for _ in 0 .. 100_000 {
				or_i64(px, 0x0123456789abcdef)
			}
		}(&x)
	}
	for t in threads {
		t.wait()
	}
	assert x == 0x0123456789abcdef
}