Add unit tests for UInt64LinkedList contract

Author: holyfuchs

cadence/tests/scripts/uint64-linked-list/contains.cdc

@@ -0,0 +1,13 @@
+import "UInt64LinkedList"
+
+/// Returns true if contains is accurate for present and absent ids.
+access(all) fun main(): Bool {
+    let list <- UInt64LinkedList.createList()
+    list.insertAtHead(id: 10)
+    list.insertAtHead(id: 20)
+    let ok = list.contains(id: 10)
+        && list.contains(id: 20)
+        && !list.contains(id: 99)
+    destroy list
+    return ok
+}

cadence/tests/scripts/uint64-linked-list/empty_list_state.cdc

@@ -0,0 +1,11 @@
+import "UInt64LinkedList"
+
+/// Returns true if a freshly created list has nil head, nil tail, and contains nothing.
+access(all) fun main(): Bool {
+    let list <- UInt64LinkedList.createList()
+    let ok = list.head == nil
+        && list.tail == nil
+        && !list.contains(id: 1)
+    destroy list
+    return ok
+}

cadence/tests/scripts/uint64-linked-list/insert_duplicate_panics.cdc

@@ -0,0 +1,9 @@
+import "UInt64LinkedList"
+
+/// Expected to fail — inserting a duplicate id violates the pre-condition.
+access(all) fun main() {
+    let list <- UInt64LinkedList.createList()
+    list.insertAtHead(id: 1)
+    list.insertAtHead(id: 1)
+    destroy list
+}

cadence/tests/scripts/uint64-linked-list/insert_multiple_order.cdc

@@ -0,0 +1,13 @@
+import "UInt64LinkedList"
+
+/// Returns true if head is the most recently inserted element and tail is the oldest.
+access(all) fun main(): Bool {
+    let list <- UInt64LinkedList.createList()
+    list.insertAtHead(id: 1)
+    list.insertAtHead(id: 2)
+    list.insertAtHead(id: 3)
+    // head = 3 (most recent), tail = 1 (oldest)
+    let ok = list.head == 3 && list.tail == 1
+    destroy list
+    return ok
+}

cadence/tests/scripts/uint64-linked-list/insert_single.cdc

@@ -0,0 +1,12 @@
+import "UInt64LinkedList"
+
+/// Returns true if a single inserted element becomes both head and tail.
+access(all) fun main(): Bool {
+    let list <- UInt64LinkedList.createList()
+    list.insertAtHead(id: 42)
+    let ok = list.contains(id: 42)
+        && list.head == 42
+        && list.tail == 42
+    destroy list
+    return ok
+}

cadence/tests/scripts/uint64-linked-list/remove_absent.cdc

@@ -0,0 +1,10 @@
+import "UInt64LinkedList"
+
+/// Returns true if removing a non-existent id returns false without panicking.
+access(all) fun main(): Bool {
+    let list <- UInt64LinkedList.createList()
+    list.insertAtHead(id: 5)
+    let removed = list.remove(id: 999)
+    destroy list
+    return !removed
+}

cadence/tests/scripts/uint64-linked-list/remove_from_empty.cdc

@@ -0,0 +1,9 @@
+import "UInt64LinkedList"
+
+/// Returns true if removing from an empty list returns false without panicking.
+access(all) fun main(): Bool {
+    let list <- UInt64LinkedList.createList()
+    let removed = list.remove(id: 42)
+    destroy list
+    return !removed
+}

cadence/tests/scripts/uint64-linked-list/remove_head.cdc

@@ -0,0 +1,15 @@
+import "UInt64LinkedList"
+
+/// Returns true if removing the head promotes the next element to head.
+access(all) fun main(): Bool {
+    let list <- UInt64LinkedList.createList()
+    list.insertAtHead(id: 1)
+    list.insertAtHead(id: 2)
+    list.insertAtHead(id: 3)
+    // list: 3 <-> 2 <-> 1  (head=3, tail=1)
+    let removed = list.remove(id: 3)
+    // list: 2 <-> 1
+    let ok = removed && list.head == 2 && list.tail == 1
+    destroy list
+    return ok
+}

cadence/tests/scripts/uint64-linked-list/remove_middle.cdc

@@ -0,0 +1,20 @@
+import "UInt64LinkedList"
+
+/// Returns true if removing a middle element re-links its neighbors correctly.
+access(all) fun main(): Bool {
+    let list <- UInt64LinkedList.createList()
+    list.insertAtHead(id: 1)
+    list.insertAtHead(id: 2)
+    list.insertAtHead(id: 3)
+    // list: 3 <-> 2 <-> 1
+    let removed = list.remove(id: 2)
+    // list: 3 <-> 1
+    let ok = removed
+        && list.head == 3
+        && list.tail == 1
+        && !list.contains(id: 2)
+        && list.contains(id: 3)
+        && list.contains(id: 1)
+    destroy list
+    return ok
+}

cadence/tests/scripts/uint64-linked-list/remove_single.cdc

@@ -0,0 +1,14 @@
+import "UInt64LinkedList"
+
+/// Returns true if removing the only element leaves an empty list.
+access(all) fun main(): Bool {
+    let list <- UInt64LinkedList.createList()
+    list.insertAtHead(id: 7)
+    let removed = list.remove(id: 7)
+    let ok = removed
+        && list.head == nil
+        && list.tail == nil
+        && !list.contains(id: 7)
+    destroy list
+    return ok
+}