Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-foundation

Source of release 0.6.0

0.6.0 / src / ak / tests_atomic.lucb

#==============================================================================================
#
#   tests_atomic - the atomic free functions and AtomicRefCounted
#
#   DESCRIPTION:
#       Port of Tests/AK/TestAtomic.cpp (the operations on plain locations; the Atomic<T>
#       class is `@T`) and focused cases pinned to AtomicRefCounted.h.
#
#==============================================================================================

test "atomic: do_exchange":
    var a_bool = false
    assert(atomic_exchange_bool(&a_bool, true) == false)
    assert(atomic_load_bool(&a_bool) == true)
    var a_u32: u32 = 2
    assert(atomic_exchange_u32(&a_u32, 22) == 2)
    assert(atomic_load_u32(&a_u32) == 22)
    var a_u16: u16 = 3
    assert(atomic_exchange_u16(&a_u16, 33) == 3)
    assert(atomic_load_u16(&a_u16) == 33)
    var a_u8: u8 = 4
    assert(atomic_exchange_u8(&a_u8, 44) == 4)
    assert(atomic_load_u8(&a_u8) == 44)
    var v_u16: u16[6]
    var a_pu16: u16*? = &v_u16[2]
    assert(atomic_load_2(&a_pu16) == (u16*?)&v_u16[2])
    assert(atomic_exchange_v(&a_pu16, &v_u16[4]) == (u16*?)&v_u16[2])
    assert(atomic_exchange_void(&a_pu16) == (u16*?)&v_u16[4])
    assert(a_pu16 == none)

test "atomic: do_compare_exchange":
    var a_bool = false
    var e_bool = true
    assert(not atomic_compare_exchange_strong_bool(&a_bool, &e_bool, true))
    assert(e_bool == false)
    assert(atomic_load_bool(&a_bool) == false)
    e_bool = false
    assert(atomic_compare_exchange_strong_bool(&a_bool, &e_bool, true))
    assert(atomic_load_bool(&a_bool) == true)
    var a_u32: u32 = 2
    var e_u32: u32 = 99
    assert(not atomic_compare_exchange_strong_u32(&a_u32, &e_u32, 22))
    assert(e_u32 == 2)
    e_u32 = 2
    assert(atomic_compare_exchange_strong_u32(&a_u32, &e_u32, 22, MemoryOrder.memory_order_acq_rel))
    assert(a_u32 == 22)
    var a_u8: u8 = 4
    var e_u8: u8 = 99
    assert(not atomic_compare_exchange_strong_u8(&a_u8, &e_u8, 44, MemoryOrder.memory_order_release))
    assert(e_u8 == 4)
    var v: i64[2]
    var p: i64*? = none
    var expected: i64*? = &v[0]
    assert(not atomic_compare_exchange_strong_v_v(&p, &expected, &v[1]))
    assert(expected == none)
    assert(atomic_compare_exchange_strong_v_v(&p, &expected, &v[1]))
    assert(p == (i64*?)&v[1])
    expected = &v[1]
    assert(atomic_compare_exchange_strong_v_void(&p, &expected))
    assert(p == none)

test "atomic: fetch_add, fetch_sub, fetch_and, fetch_or, fetch_xor":
    var a_u32: u32 = 5
    assert(atomic_fetch_add_u32(&a_u32, 2) == 5)
    assert(atomic_load_u32(&a_u32) == 7)
    var a_u16: u16 = 5
    assert(atomic_fetch_add_u16(&a_u16, 2) == 5)
    assert(a_u16 == 7)
    var a_u8: u8 = 5
    assert(atomic_fetch_sub_u8(&a_u8, 2) == 5)
    assert(a_u8 == 3)
    var a_i64: i64 = -1
    assert(atomic_fetch_add_i64(&a_i64, 3, MemoryOrder.memory_order_relaxed) == -1)
    assert(a_i64 == 2)
    var bits: u32 = 0b1100
    assert(atomic_fetch_and_u32(&bits, 0b0110) == 0b1100)
    assert(bits == 0b0100)
    assert(atomic_fetch_or_u32(&bits, 0b0001) == 0b0100)
    assert(bits == 0b0101)
    assert(atomic_fetch_xor_u32(&bits, 0b0111) == 0b0101)
    assert(bits == 0b0010)

test "atomic: load, store, fences":
    var value: usize = 1
    atomic_store_usize(&value, 9, MemoryOrder.memory_order_release)
    assert(atomic_load_usize(&value, MemoryOrder.memory_order_acquire) == 9)
    var p: u8*? = none
    var byte: u8 = 1
    atomic_store_v(&p, &byte)
    assert(atomic_load_2(&p, MemoryOrder.memory_order_consume) == (u8*?)&byte)
    atomic_store_void(&p)
    assert(p == none)
    atomic_thread_fence(MemoryOrder.memory_order_seq_cst)
    atomic_signal_fence(MemoryOrder.memory_order_acq_rel)
    full_memory_barrier()
    atomic_pause()
    assert(atomic_is_lock_free_u64())

struct TestAtomicObject:
    var base: AtomicRefCounted[TestAtomicObject]

test "atomic_ref_counted: ref, try_ref, unref":
    var object: TestAtomicObject
    atomic_ref_counted_base_init_fields(&object.base.atomic_ref_counted_base)
    let base = &object.base.atomic_ref_counted_base
    assert(atomic_ref_counted_base_ref_count(base) == 1)
    atomic_ref_counted_base_ref(base)
    assert(atomic_ref_counted_base_ref_count(base) == 2)
    assert(atomic_ref_counted_base_try_ref(base))
    assert(atomic_ref_counted_base_ref_count(base) == 3)
    assert(not atomic_ref_counted_unref(&object.base))
    assert(not atomic_ref_counted_unref(&object.base))
    assert(atomic_ref_counted_unref(&object.base))
    assert(not atomic_ref_counted_base_try_ref(base))