dymokomi/luce-browser-foundation
Source of release 0.6.0
0.6.0 / src / ak / tests_intrusive_list.lucb
#==============================================================================================
#
# tests_intrusive_list - IntrusiveList<&T::member>
#
# DESCRIPTION:
# Port of Tests/AK/TestIntrusiveList.cpp. The RefPtr/NonnullRefPtr container cases
# count references the intrusive list takes on its values; containers are raw pointers
# here (DESIGN.md ยง2.6), so they reduce to insertion and removal, which are tested.
#
#==============================================================================================
struct IntrusiveTestItem:
var value: i32
var m_list_node: IntrusiveListNode[IntrusiveTestItem, IntrusiveTestItem*?]
type IntrusiveTestList = IntrusiveList[IntrusiveTestItem, IntrusiveTestItem*?]
func test_item_member() -> usize:
return memory.offset_of(IntrusiveTestItem, m_list_node)
func test_new_item(value: i32) -> IntrusiveTestItem*:
let item = new IntrusiveTestItem else trap("out of memory")
item.value = value
return item
test "intrusive_list: construct":
var empty: IntrusiveTestList
assert(intrusive_list_is_empty(&empty))
test "intrusive_list: insert":
var list: IntrusiveTestList
intrusive_list_append(&list, test_new_item(0), test_item_member())
assert(not intrusive_list_is_empty(&list))
let last = intrusive_list_take_last(&list) else trap("empty")
free(last)
assert(intrusive_list_is_empty(&list))
test "intrusive_list: insert_before":
var list: IntrusiveTestList
let two = test_new_item(2)
intrusive_list_append(&list, two, test_item_member())
let zero = test_new_item(0)
intrusive_list_append(&list, zero, test_item_member())
let one = test_new_item(1)
intrusive_list_insert_before(&list, zero, one, test_item_member())
assert(intrusive_list_first(&list) == (IntrusiveTestItem*?)two)
assert(intrusive_list_last(&list) == (IntrusiveTestItem*?)zero)
assert(intrusive_list_contains(&list, zero, test_item_member()))
assert(intrusive_list_contains(&list, one, test_item_member()))
assert(intrusive_list_contains(&list, two, test_item_member()))
assert(intrusive_list_node_is_in_list(&zero.m_list_node))
assert(intrusive_list_node_is_in_list(&one.m_list_node))
assert(intrusive_list_node_is_in_list(&two.m_list_node))
assert(intrusive_list_size_slow(&list) == 3)
let order: i32[3] = [2, 1, 0]
var index: usize = 0
for item in intrusive_list_begin(&list):
assert(item.value == order[index])
index += 1
while let elem = intrusive_list_take_first(&list):
free(elem)
test "intrusive_list: enumeration":
let expected_size: usize = 10
var list: IntrusiveTestList
for i in 0..<expected_size:
intrusive_list_append(&list, test_new_item((i32)i), test_item_member())
var actual_size: usize = 0
for elem in intrusive_list_begin(&list):
_ = elem
actual_size += 1
assert(expected_size == actual_size)
assert(expected_size == intrusive_list_size_slow(&list))
var reverse_actual_size: usize = 0
var it = intrusive_list_rbegin(&list)
while it.m_value != none:
reverse_actual_size += 1
_ = intrusive_list_reverse_iterator_inc(&it)
assert(expected_size == reverse_actual_size)
while let elem = intrusive_list_take_first(&list):
free(elem)
test "intrusive_list: remove, prepend, erase and clear":
var list: IntrusiveTestList
var items: IntrusiveTestItem*[4] = [test_new_item(0), test_new_item(1), test_new_item(2), test_new_item(3)]
for item in items:
intrusive_list_prepend(&list, item, test_item_member())
assert((intrusive_list_first(&list) else trap("empty")).value == 3)
intrusive_list_remove(&list, items[2], test_item_member())
assert(not intrusive_list_contains(&list, items[2], test_item_member()))
assert(intrusive_list_size_slow(&list) == 3)
# Appending a value that is in the list moves it to the end.
intrusive_list_append(&list, items[3], test_item_member())
assert((intrusive_list_last(&list) else trap("empty")).value == 3)
var it = intrusive_list_begin(&list)
_ = intrusive_list_iterator_erase(&it)
assert(intrusive_list_iterator_deref(&it).value == 0)
assert(intrusive_list_size_slow(&list) == 2)
intrusive_list_clear(&list)
assert(intrusive_list_is_empty(&list))
assert(not intrusive_list_node_is_in_list(&items[3].m_list_node))