Update Util tests to follow reference implementation patterns

Author: Kyle-Ye

Tests/OpenAttributeGraphCxxTests/Util/ForwardListTests.swift

@@ -5,44 +5,71 @@
 import OpenAttributeGraphCxx_Private.Util
 import Testing
 
+@Suite("List tests")
 struct ForwardListTests {
-    @Test
-    func forwardListBasicOperations() {
+
+    @Test("Initialize empty list")
+    func initEmpty() {
         let list = util.UInt64ForwardList.create()
-        defer { util.UInt64ForwardList.destroy(list) }
-        
-        // Test empty list
+        defer {
+            util.UInt64ForwardList.destroy(list)
+        }
+
         #expect(list.empty())
-        
-        // Test push_front and empty state
-        list.push_front(42)
-        #expect(!list.empty())
-        
-        // Test front access
-        #expect(list.front() == 42)
-        
-        // Test multiple push_front operations
-        list.push_front(100)
-        #expect(list.front() == 100)
-        
-        list.push_front(200)
-        #expect(list.front() == 200)
-        
-        // Test pop_front
-        list.pop_front()
-        #expect(list.front() == 100)
-        
-        list.pop_front()
-        #expect(list.front() == 42)
-        
+    }
+
+    @Test("Push element")
+    func pushElement() {
+        let list = util.UInt64ForwardList.create()
+        defer {
+            util.UInt64ForwardList.destroy(list)
+        }
+
+        list.push_front(1)
+
+        #expect(list.empty() == false)
+
+        let front = list.front()
+        #expect(front == 1)
+    }
+
+    @Test("Push multiple elements")
+    func pushMultipleElements() {
+        let list = util.UInt64ForwardList.create()
+        defer {
+            util.UInt64ForwardList.destroy(list)
+        }
+
+        list.push_front(1)
+        list.push_front(2)
+        list.push_front(3)
+
+        let front = list.front()
+        #expect(front == 3)
+    }
+
+    @Test("Remove element")
+    func removeElement() {
+        let list = util.UInt64ForwardList.create()
+        defer {
+            util.UInt64ForwardList.destroy(list)
+        }
+
+        list.push_front(1)
+        list.push_front(2)
+        list.push_front(3)
         list.pop_front()
-        #expect(list.empty())
+
+        let front = list.front()
+        #expect(front == 2)
     }
 
-    @Test
-    func forwardListSequentialOperations() {
+    @Test("Sequential operations")
+    func sequentialOperations() {
         let list = util.UInt64ForwardList.create()
-        defer { util.UInt64ForwardList.destroy(list) }
+        defer {
+            util.UInt64ForwardList.destroy(list)
+        }
 
         // Add multiple elements
         for i in 0..<5 {

Tests/OpenAttributeGraphCxxTests/Util/HeapTests.swift

@@ -5,69 +5,82 @@
 import OpenAttributeGraphCxx_Private.Util
 import Testing
 
+@Suite("Heap tests")
 struct HeapTests {
-    @Test
-    func heapBasicOperations() {
-        let heap = util.Heap.create(nil, 0, 1024)
-        defer { util.Heap.destroy(heap) }
-        
-        // Test heap creation and basic properties
-        #expect(heap.increment() == 1024)
-        #expect(heap.num_nodes() >= 0)
-        #expect(heap.capacity() >= 0)
+
+    let nodeSize = 16
+
+    @Test("Initializing with default arguments")
+    func initDefault() {
+        let heap = util.Heap.create(nil, 0, 0)
+        defer {
+            util.Heap.destroy(heap)
+        }
+
+        #expect(heap.capacity() == 0)
+        #expect(heap.increment() == 0x2000)
+        #expect(heap.num_nodes() == 0)
     }
 
-    @Test
-    func heapMinimumIncrement() {
-        // Test with minimum increment constant (0x400 = 1024 bytes)
-        let minimumIncrement = 0x400
-        
-        // Create heap with minimum increment
-        let heap = util.Heap.create(nil, 0, minimumIncrement)
-        defer { util.Heap.destroy(heap) }
-        
-        #expect(heap.increment() == minimumIncrement)
+    @Test("Initializing with custom increment")
+    func initWithCustomIncrement() {
+        let customIncrement = 4096
+        let heap = util.Heap.create(nil, 0, customIncrement)
+        defer {
+            util.Heap.destroy(heap)
+        }
+
+        #expect(heap.capacity() == 0)
+        #expect(heap.increment() == customIncrement)
+        #expect(heap.num_nodes() == 0)
     }
-    
-    @Test
-    func heapWithInitialBuffer() {
+
+    @Test("Creating heap with initial buffer")
+    func createWithInitialBuffer() {
         var buffer = Array<UInt8>(repeating: 0, count: 1024)
 
         let heap = buffer.withUnsafeMutableBytes { bufferPtr in
             let charPtr = bufferPtr.bindMemory(to: CChar.self)
             return util.Heap.create(charPtr.baseAddress, 1024, 2048)
         }
-        defer { util.Heap.destroy(heap) }
+        defer {
+            util.Heap.destroy(heap)
+        }
 
         #expect(heap.capacity() == 1024)
         #expect(heap.increment() == 2048)
+        #expect(heap.num_nodes() == 0)
     }
-    
-    @Test
-    func heapReset() {
+
+    @Test("Reset heap functionality")
+    func resetHeap() {
         let heap = util.Heap.create(nil, 0, 1024)
-        defer { util.Heap.destroy(heap) }
+        defer {
+            util.Heap.destroy(heap)
+        }
 
-        // Reset heap
+        // Reset heap to different configuration
         heap.reset(nil, 0)
 
-        // Verify heap is still operational after reset
+        // Verify heap properties after reset
         #expect(heap.increment() == 1024)
-        #expect(heap.num_nodes() >= 0)
+        #expect(heap.capacity() == 0)
+        #expect(heap.num_nodes() == 0)
     }
-    
-    @Test
-    func heapPrint() {
+
+    @Test("Print heap debug information")
+    func printHeapInfo() {
         let heap = util.Heap.create(nil, 0, 1024)
-        defer { util.Heap.destroy(heap) }
+        defer {
+            util.Heap.destroy(heap)
+        }
 
-        // Test print method doesn't crash and can be called
-        // This method prints debug information to stdout
+        // Test that print method can be called without crashing
         heap.print()
 
         // Verify heap is still functional after print
         #expect(heap.increment() == 1024)
-        #expect(heap.num_nodes() >= 0)
-        #expect(heap.capacity() >= 0)
+        #expect(heap.num_nodes() == 0)
+        #expect(heap.capacity() == 0)
     }
 }