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

module atomics

fn test_load_u64_basic() {
    mut x := u64(1234567890123)
    assert load_u64(&x) == 1234567890123
}

fn test_store_u64_basic() {
    mut x := u64(1)
    store_u64(&x, 999999)
    assert x == 999999
}

fn test_swap_u64_basic() {
    mut x := u64(123)
    old := swap_u64(&x, 999)
    assert old == 123
    assert x == 999
}

fn test_swap_u64_same() {
    mut x := u64(777777)
    old := swap_u64(&x, 777777)
    assert old == 777777
    assert x == 777777
}

fn test_add_u64_basic() {
    mut x := u64(0)
    for _ in 0 .. 1000 {
        add_u64(&x, 2)
    }
    assert x == 2000
}

fn test_add_u64_wraparound() {
    mut x := u64(0xffffffffffffffff)
    add_u64(&x, 1)
    assert x == 0
}

fn test_add_u64_return() {
    mut x := u64(10)
    r := add_u64(&x, 100)
    assert r == 110
    assert x == 110
}

fn test_cas_u64_basic() {
    mut x := u64(111)
    assert cas_u64(&x, 111, 222)
    assert x == 222
}

fn test_cas_u64_fail() {
    mut x := u64(500)
    assert !cas_u64(&x, 100, 200)
    assert x == 500
}

fn test_cas_u64_nochange_fail() {
    mut x := u64(999)
    cas_u64(&x, 1, 2)
    assert x == 999
}

fn test_cas_u64_boundary() {
    mut x := u64(0xffffffffffffffff)
    assert cas_u64(&x, 0xffffffffffffffff, 0)
    assert x == 0
}

fn test_add_u64_concurrent() {
    mut x := u64(0)
    mut threads := []thread{}

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

    for t in threads {
        t.wait()
    }

    assert x == 800_000
}

fn test_swap_u64_concurrent() {
    mut x := u64(0)
    mut threads := []thread{}

    for _ in 0 .. 8 {
        threads << spawn fn (px &u64) {
            for _ in 0 .. 50_000 {
                swap_u64(px, 123456)
            }
        }(&x)
    }

    for t in threads {
        t.wait()
    }

    assert x == 123456
}

fn test_cas_u64_concurrent_inc() {
    mut x := u64(0)
    mut threads := []thread{}

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

    for t in threads {
        t.wait()
    }

    assert x == 400_000
}

fn test_cas_u64_contended_flip() {
    mut x := u64(0)
    mut threads := []thread{}

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

    for t in threads {
        t.wait()
    }

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

fn test_and_u64_concurrent() {
    mut x := u64(0xffffffffffffffff)
    mut threads := []thread{}
    for _ in 0 .. 8 {
        threads << spawn fn (px &u64) {
            for _ in 0 .. 100_000 {
                and_u64(px, 0x00ff00ff00ff00ff)
            }
        }(&x)
    }
    for t in threads {
        t.wait()
    }
    assert x == 0x00ff00ff00ff00ff
}

fn test_or_u64_concurrent() {
    mut x := u64(0)
    mut threads := []thread{}
    for _ in 0 .. 8 {
        threads << spawn fn (px &u64) {
            for _ in 0 .. 100_000 {
                or_u64(px, 0xfedcba9876543210)
            }
        }(&x)
    }
    for t in threads {
        t.wait()
    }
    assert x == u64(0xfedcba9876543210)
}