import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import { uint32atomic } from 'moroutine';

describe('Uint32Atomic', () => {
  it('self-allocates and initializes to zero', () => {
    const a = uint32atomic();
    assert.equal(a.load(), 0);
  });

  it('stores and loads a value', () => {
    const a = uint32atomic();
    a.store(3000000000);
    assert.equal(a.load(), 3000000000);
  });

  it('exposes byteSize of 4', () => {
    assert.equal(uint32atomic.byteSize, 4);
  });

  it('add returns previous value and updates', () => {
    const a = uint32atomic();
    a.store(10);
    const prev = a.add(5);
    assert.equal(prev, 10);
    assert.equal(a.load(), 15);
  });

  it('sub returns previous value and updates', () => {
    const a = uint32atomic();
    a.store(10);
    const prev = a.sub(3);
    assert.equal(prev, 10);
    assert.equal(a.load(), 7);
  });

  it('and returns previous value and updates', () => {
    const a = uint32atomic();
    a.store(0b1100);
    const prev = a.and(0b1010);
    assert.equal(prev, 0b1100);
    assert.equal(a.load(), 0b1000);
  });

  it('or returns previous value and updates', () => {
    const a = uint32atomic();
    a.store(0b1100);
    const prev = a.or(0b0011);
    assert.equal(prev, 0b1100);
    assert.equal(a.load(), 0b1111);
  });

  it('xor returns previous value and updates', () => {
    const a = uint32atomic();
    a.store(0b1100);
    const prev = a.xor(0b1010);
    assert.equal(prev, 0b1100);
    assert.equal(a.load(), 0b0110);
  });

  it('exchange returns previous value and sets new', () => {
    const a = uint32atomic();
    a.store(3000000000);
    const prev = a.exchange(99);
    assert.equal(prev, 3000000000);
    assert.equal(a.load(), 99);
  });

  it('compareExchange succeeds when expected matches', () => {
    const a = uint32atomic();
    a.store(3000000000);
    const actual = a.compareExchange(3000000000, 99);
    assert.equal(actual, 3000000000);
    assert.equal(a.load(), 99);
  });

  it('compareExchange fails when expected does not match', () => {
    const a = uint32atomic();
    a.store(3000000000);
    const actual = a.compareExchange(0, 99);
    assert.equal(actual, 3000000000);
    assert.equal(a.load(), 3000000000);
  });
});