summaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/collections/test_vec_suite.zc177
-rw-r--r--tests/std/test_vec.zc168
2 files changed, 168 insertions, 177 deletions
diff --git a/tests/collections/test_vec_suite.zc b/tests/collections/test_vec_suite.zc
deleted file mode 100644
index 9722972..0000000
--- a/tests/collections/test_vec_suite.zc
+++ /dev/null
@@ -1,177 +0,0 @@
-
-import "std.zc"
-
-@derive(Eq, Clone)
-struct Point {
- x: int;
- y: int;
-}
-
-test "test_vec_methods" {
- println "Testing Vec methods...";
-
- // Insert at beginning
- var v = Vec<int>::new();
- v.push(10);
- v.push(20);
- v.push(30);
- v.insert(0, 5);
-
- if (v.get(0) == 5 && v.get(1) == 10 && v.length() == 4) {
- println " -> insert(0, 5): Passed";
- } else {
- assert(false, "insert(0, 5) failed");
- }
-
- // Insert in middle
- v.insert(2, 15);
- if (v.get(2) == 15 && v.get(3) == 20 && v.length() == 5) {
- println " -> insert(2, 15): Passed";
- } else {
- assert(false, "insert(2, 15) failed");
- }
-
- // Insert at end
- v.insert(5, 35);
- if (v.get(5) == 35 && v.length() == 6) {
- println " -> insert(5, 35): Passed";
- } else {
- assert(false, "insert(5, 35) failed");
- }
-
- // Remove from beginning
- var removed = v.remove(0);
- if (removed == 5 && v.get(0) == 10 && v.length() == 5) {
- println " -> remove(0): Passed";
- } else {
- assert(false, "remove(0) failed");
- }
-
- // Remove from middle
- var removed2 = v.remove(1);
- if (removed2 == 15 && v.get(1) == 20 && v.length() == 4) {
- println " -> remove(1): Passed";
- } else {
- assert(false, "remove(1) failed");
- }
-
- // Remove from end
- var removed3 = v.remove(3);
- if (removed3 == 35 && v.length() == 3) {
- println " -> remove(3): Passed";
- } else {
- assert(false, "remove(3) failed");
- }
-
- // Verify final state
- if (v.get(0) == 10 && v.get(1) == 20 && v.get(2) == 30) {
- println " -> final state: Passed";
- } else {
- assert(false, "final state failed");
- }
-
- println "All Vec methods passed!";
-}
-
-test "test_vec_extensions" {
- println "Testing Vec extensions (pop, clear, etc)...";
- var v = Vec<int>::new();
- v.push(10);
- v.push(20);
- v.push(30);
-
- assert(v.length() == 3, "Length should be 3");
- assert(v.last() == 30, "Last should be 30");
-
- var popped = v.pop();
- println "Popped: {popped}";
- assert(popped == 30, "Popped value mismatch");
- assert(v.length() == 2, "Length after pop mismatch");
-
- assert(!v.is_empty(), "Vector should not be empty");
-
- v.clear();
- assert(v.is_empty(), "Vector should be empty after clear");
- assert(v.length() == 0, "Length should be 0");
-
- v.free();
-}
-
-test "test_vec_basic" {
- var v = Vec<int>::new();
- v.push(10);
- v.push(10);
- v.push(20);
- var v0 = v.get(0);
- var v1 = v.get(1);
- println "Vec: {v0}, {v1}";
-
- var s1 = String::from("Hello ");
- var s2 = String::from("World");
- var s3 = s1 + s2;
-
- println "{s3.c_str()}";
-}
-
-test "test_vec_clone" {
- var v = Vec<int>::new();
- v.push(10);
- v.push(20);
- v.push(30);
-
- println "Vec has {(int)v.len} elements";
- println "First: {v.first()}";
- println "Last: {v.last()}";
-
- v.free();
- "Done";
-}
-
-test "test_vec_contains" {
- println "Testing Vec::contains with structs...";
-
- var v = Vec<Point>::new();
- v.push(Point { x: 1, y: 2 });
- v.push(Point { x: 3, y: 4 });
-
- var p1 = Point { x: 1, y: 2 };
- if (v.contains(p1)) {
- println " -> contains((1, 2)): Passed";
- } else {
- assert(false, "contains({1, 2}) failed");
- }
-
- var p2 = Point { x: 3, y: 4 };
- if (v.contains(p2)) {
- println " -> contains((3, 4)): Passed";
- } else {
- assert(false, "contains({3, 4}) failed");
- }
-
- var p3 = Point { x: 5, y: 6 };
- if (!v.contains(p3)) {
- println " -> !contains((5, 6)): Passed";
- } else {
- assert(false, "!contains({5, 6}) failed");
- }
-
- var vi = Vec<int>::new();
- vi.push(10);
- vi.push(20);
-
- if (vi.contains(10)) {
- println " -> Vec<int>::contains(10): Passed";
- } else {
- assert(false, "Vec<int>::contains(10) failed");
- }
-
- if (!vi.contains(30)) {
- println " -> !Vec<int>::contains(30): Passed";
- } else {
- assert(false, "!Vec<int>::contains(30) failed");
- }
-
- v.free();
- vi.free();
- println "All tests passed!";
-}
diff --git a/tests/std/test_vec.zc b/tests/std/test_vec.zc
new file mode 100644
index 0000000..4787e06
--- /dev/null
+++ b/tests/std/test_vec.zc
@@ -0,0 +1,168 @@
+import "std/vec.zc"
+import "std/io.zc"
+
+// Helper for assertions
+fn assert_true(cond: bool, msg: char*) {
+ if (!cond) {
+ print "Assertion failed: {msg}\n";
+ exit(1);
+ }
+}
+
+fn assert_eq(a: int, b: int, msg: char*) {
+ if (a != b) {
+ print "Assertion failed: {msg} (Expected {a}, Got {b})\n";
+ exit(1);
+ }
+}
+
+@derive(Eq, Clone)
+struct Point {
+ x: int;
+ y: int;
+}
+
+test "Vec Basics (Construction, Push, Pop, Access)" {
+ print "Testing Vec basics...\n";
+ var v = Vec<int>::new();
+ assert_eq(v.len, 0, "Initial len");
+ assert_eq(v.cap, 0, "Initial cap");
+
+ v.push(10);
+ v.push(20);
+ v.push(30);
+
+ assert_eq(v.len, 3, "Len after push");
+ assert_eq(v.get(0), 10, "get(0)");
+ assert_eq(v.get(1), 20, "get(1)");
+ assert_eq(v.get(2), 30, "get(2)");
+ assert_eq(v.last(), 30, "last()");
+ assert_eq(v.first(), 10, "first()");
+
+ assert_eq(v.pop(), 30, "pop()");
+ assert_eq(v.len, 2, "Len after pop");
+
+ v.set(0, 99);
+ assert_eq(v.get(0), 99, "set()");
+
+ // Explicit clean up check (safe idempotent free)
+ v.free();
+ assert_eq(v.len, 0, "Len after free");
+}
+
+test "Vec Capacity and Allocation" {
+ print "Testing Vec capacity...\n";
+ // with_capacity
+ var v1 = Vec<int>::with_capacity(10);
+ assert_eq(v1.len, 0, "with_capacity len");
+ assert_eq(v1.cap, 10, "with_capacity cap");
+ v1.push(1);
+ assert_eq(v1.cap, 10, "Cap should not change yet");
+
+ // Implicit grow
+ var v2 = Vec<int>::new();
+ // Force grow logic: 0 -> 8 -> 16...
+ var i = 0;
+ while i < 9 {
+ v2.push(i);
+ i = i + 1;
+ }
+ assert_true(v2.cap >= 9, "Capacity grew to hold 9 items");
+ // Expected strategy: 0 -> 8 -> 16
+ assert_eq(v2.cap, 16, "Growth strategy check (8->16)");
+}
+
+test "Vec Modification (Insert, Remove, Clear)" {
+ print "Testing Vec modification...\n";
+ var v = Vec<int>::new();
+ v.push(1);
+ v.push(3);
+
+ v.insert(1, 2); // [1, 2, 3]
+ assert_eq(v.get(1), 2, "insert middle");
+ assert_eq(v.len, 3, "insert len");
+
+ var val = v.remove(0); // [2, 3]
+ assert_eq(val, 1, "remove return");
+ assert_eq(v.get(0), 2, "remove shift");
+ assert_eq(v.len, 2, "remove len");
+
+ v.clear();
+ assert_eq(v.len, 0, "clear len");
+ assert_true(v.is_empty(), "is_empty");
+}
+
+test "Vec Extensions (pop_opt)" {
+ print "Testing Vec extensions...\n";
+ var v = Vec<int>::new();
+ v.push(42);
+
+ var opt = v.pop_opt();
+ assert_true(!opt.is_none(), "pop_opt some");
+ assert_eq(opt.unwrap(), 42, "pop_opt val");
+
+ var empty = v.pop_opt();
+ assert_true(empty.is_none(), "pop_opt none");
+}
+
+test "Vec Iteration (Reference and Value)" {
+ print "Testing Vec iteration...\n";
+ var v = Vec<Point>::new();
+ v.push(Point { x: 10, y: 10 });
+ v.push(Point { x: 20, y: 20 });
+
+ // 1. Value Iteration
+ var sum_val = 0;
+ for p in v {
+ sum_val = sum_val + p.x;
+ }
+ assert_eq(sum_val, 30, "Value iteration sum");
+
+ // 2. Reference Iteration (Sugar &v) - In-place modification
+ for p in &v {
+ (*p).x = (*p).x + 1;
+ }
+ assert_eq(v.get(0).x, 11, "Ref iter mod 0");
+ assert_eq(v.get(1).x, 21, "Ref iter mod 1");
+
+ // 3. Explicit iter_ref()
+ for p in v.iter_ref() {
+ (*p).y = (*p).y + 2;
+ }
+ assert_eq(v.get(0).y, 12, "Explicit ref iter mod 0");
+ assert_eq(v.get(1).y, 22, "Explicit ref iter mod 1");
+}
+
+test "Vec Clone and Drop" {
+ print "Testing Vec clone and drop...\n";
+ var v = Vec<int>::new();
+ v.push(100);
+ v.push(200);
+
+ var v2 = v.clone();
+ assert_eq(v2.len, 2, "Clone len");
+ assert_eq(v2.get(0), 100, "Clone val 0");
+
+ v.set(0, 999);
+ assert_eq(v.get(0), 999, "Original mod");
+ assert_eq(v2.get(0), 100, "Clone independent");
+
+ // Drop is implicit at end of scope.
+ // We trust valgrind/previous verification for actual memory free.
+ // This test ensures no double-free crashes or logic errors.
+}
+
+test "Vec Utils (Reverse, Contains)" {
+ print "Testing Vec utils...\n";
+ var v = Vec<int>::new();
+ v.push(1);
+ v.push(2);
+ v.push(3);
+
+ v.reverse(); // [3, 2, 1]
+ assert_eq(v.get(0), 3, "Reverse 0");
+ assert_eq(v.get(2), 1, "Reverse 2");
+
+ assert_true(v.contains(2), "Contains true");
+ assert_true(!v.contains(99), "Contains false");
+}
generated by cgit v1.2.3 (git 2.46.0) at 2026-02-02 10:27:37 +0000