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

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

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

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

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

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

  it('and returns previous value and updates', () => {
    const a = uint64atomic();
    a.store(0b1100n);
    const prev = a.and(0b1010n);
    assert.equal(prev, 0b1100n);
    assert.equal(a.load(), 0b1000n);
  });

  it('or returns previous value and updates', () => {
    const a = uint64atomic();
    a.store(0b1100n);
    const prev = a.or(0b0011n);
    assert.equal(prev, 0b1100n);
    assert.equal(a.load(), 0b1111n);
  });

  it('xor returns previous value and updates', () => {
    const a = uint64atomic();
    a.store(0b1100n);
    const prev = a.xor(0b1010n);
    assert.equal(prev, 0b1100n);
    assert.equal(a.load(), 0b0110n);
  });

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

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

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