Initial project import

tools/v/vlib/x/atomics/i32_test.v

@@ -0,0 +1,221 @@
+// vtest build: !(macos || windows)
+
+module atomics
+
+fn test_cas_i32_basic() {
+	mut x := i32(10)
+	ok := cas_i32(&x, 10, 20)
+	assert ok == true
+	assert x == 20
+}
+
+fn test_cas_fail() {
+	mut x := i32(5)
+	assert !cas_i32(&x, 10, 42)
+	assert x == 5
+}
+
+fn test_cas_fail_memory_unchanged() {
+	mut x := i32(7)
+	cas_i32(&x, 1, 2)
+	assert x == 7
+}
+
+fn test_cas_exact_match() {
+	mut x := i32(-1)
+	assert !cas_i32(&x, 0, 999)
+	assert x == -1
+}
+
+fn test_cas_twice() {
+	mut x := i32(1)
+	assert cas_i32(&x, 1, 2)
+	assert cas_i32(&x, 2, 3)
+	assert x == 3
+}
+
+fn test_cas_with_negative() {
+	mut x := i32(-123)
+	assert cas_i32(&x, -123, 8)
+	assert x == 8
+}
+
+fn test_add_i32_basic() {
+	mut x := i32(0)
+	for _ in 0 .. 1000 {
+		add_i32(&x, 1)
+	}
+	assert x == 1000
+}
+
+fn test_add_i32_negative() {
+	mut x := i32(10)
+	add_i32(&x, -3)
+	assert x == 7
+}
+
+fn test_add_i32_return_value() {
+	mut x := i32(5)
+	r := add_i32(&x, 7)
+	assert r == 12
+	assert x == 12
+}
+
+fn test_add_i32_overflow_wraps() {
+	mut x := i32(2147483647)
+	add_i32(&x, 1)
+	assert x == -2147483648
+}
+
+fn test_swap_i32_basic() {
+	mut x := i32(5)
+	old := swap_i32(&x, 99)
+	assert old == 5
+	assert x == 99
+}
+
+fn test_swap_i32_twice() {
+	mut x := i32(1)
+	assert swap_i32(&x, 2) == 1
+	assert swap_i32(&x, 3) == 2
+	assert x == 3
+}
+
+fn test_swap_i32_with_cas() {
+	mut x := i32(10)
+	assert cas_i32(&x, 10, 20)
+	old := swap_i32(&x, 30)
+	assert old == 20
+	assert x == 30
+}
+
+fn test_load_i32_basic() {
+	mut x := i32(123456)
+	assert load_i32(&x) == 123456
+}
+
+fn test_store_i32_basic() {
+	mut x := i32(5)
+	store_i32(&x, 777)
+	assert x == 777
+}
+
+fn test_add_i32_concurrent() {
+	mut x := i32(0)
+	mut threads := []thread{}
+
+	for _ in 0 .. 9 {
+		threads << spawn fn (ptr &i32) {
+			for _ in 0 .. 100_000 {
+				add_i32(ptr, 1)
+			}
+		}(&x)
+	}
+
+	for t in threads {
+		t.wait()
+	}
+
+	assert x == 900_000
+}
+
+fn test_swap_i32_concurrent() {
+	mut x := i32(0)
+	mut threads := []thread{}
+
+	for _ in 0 .. 8 {
+		threads << spawn fn (ptr &i32) {
+			for _ in 0 .. 50_000 {
+				swap_i32(ptr, 123)
+			}
+		}(&x)
+	}
+
+	for t in threads {
+		t.wait()
+	}
+
+	assert x == 123
+}
+
+fn test_cas_i32_concurrent() {
+	mut x := i32(0)
+	mut threads := []thread{}
+
+	for _ in 0 .. 8 {
+		threads << spawn fn (ptr &i32) {
+			for _ in 0 .. 100_000 {
+				for {
+					old := load_i32(ptr)
+					if cas_i32(ptr, old, old + 1) {
+						break
+					}
+				}
+			}
+		}(&x)
+	}
+
+	for t in threads {
+		t.wait()
+	}
+
+	assert x == 800_000
+}
+
+fn test_load_store_i32_concurrent() {
+	mut x := i32(0)
+	mut threads := []thread{}
+
+	for _ in 0 .. 4 {
+		threads << spawn fn (px &i32) {
+			for _ in 0 .. 50_000 {
+				add_i32(px, 1)
+			}
+		}(&x)
+	}
+	for _ in 0 .. 4 {
+		threads << spawn fn (px &i32) {
+			for _ in 0 .. 50_000 {
+				_ = load_i32(px)
+			}
+		}(&x)
+	}
+
+	for t in threads {
+		t.wait()
+	}
+
+	assert x == 4 * 50_000
+}
+
+fn test_and_i32_concurrent() {
+	mut x := i32(0x7fffffff)
+	mut threads := []thread{}
+	for _ in 0 .. 8 {
+		threads << spawn fn (px &i32) {
+			for _ in 0 .. 100_000 {
+				and_i32(px, 0x0fffffff)
+			}
+		}(&x)
+	}
+	for t in threads {
+		t.wait()
+	}
+	assert x == 0x0fffffff
+}
+
+fn test_or_i32_concurrent() {
+	mut x := i32(0)
+	mut threads := []thread{}
+	for _ in 0 .. 8 {
+		threads << spawn fn (px &i32) {
+			for _ in 0 .. 100_000 {
+				or_i32(px, 0x12345678)
+			}
+		}(&x)
+	}
+	for t in threads {
+		t.wait()
+	}
+	assert x == 0x12345678
+}