// 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
}