fix tests

Author: djeada

src/3_Stack_Queue/.min_in_stack.cpp.swp

@@ -30,6 +30,7 @@
 
 #include <iostream>
 #include <optional>
+#include <cassert>
 #include <stack>
 #include <string>
 
@@ -117,28 +118,179 @@ struct TestRunner {
 // Test cases to ensure correctness of StackWithMin operations.
 void test() {
   TestRunner runner;
+
+  // 1) Empty stack behavior
+  {
+    StackWithMin<int> stack;
+    runner.expectEqual(stack.min(), std::optional<int>{}, "min on empty");
+    runner.expectEqual(stack.top(), std::optional<int>{}, "top on empty");
+
+    // If pop() is supposed to be safe on empty, this should not crash.
+    stack.pop();
+    runner.expectEqual(stack.min(), std::optional<int>{}, "min still empty after pop on empty");
+    runner.expectEqual(stack.top(), std::optional<int>{}, "top still empty after pop on empty");
+  }
+
+  // 2) Basic push/pop + popping all the way to empty
   {
     StackWithMin<int> stack;
     stack.push(10);
     stack.push(5);
     stack.push(2);
     runner.expectEqual(stack.min(), std::optional<int>(2), "min after push");
     runner.expectEqual(stack.top(), std::optional<int>(2), "top after push");
+
     stack.pop();
     runner.expectEqual(stack.min(), std::optional<int>(5), "min after pop");
     runner.expectEqual(stack.top(), std::optional<int>(5), "top after pop");
+
+    stack.pop(); // removes 5
+    runner.expectEqual(stack.min(), std::optional<int>(10), "min after pop to single");
+    runner.expectEqual(stack.top(), std::optional<int>(10), "top after pop to single");
+
+    stack.pop(); // removes 10 -> empty
+    runner.expectEqual(stack.min(), std::optional<int>{}, "min after popping to empty");
+    runner.expectEqual(stack.top(), std::optional<int>{}, "top after popping to empty");
   }
+
+  // 3) Negative values + restore
   {
     StackWithMin<int> stack;
     stack.push(-1);
     stack.push(7);
     stack.push(-2);
-    runner.expectEqual(stack.min(), std::optional<int>(-2),
-                       "min with negative");
+    runner.expectEqual(stack.min(), std::optional<int>(-2), "min with negative");
+
     stack.pop();
     runner.expectEqual(stack.min(), std::optional<int>(-1), "min restored");
     runner.expectEqual(stack.top(), std::optional<int>(7), "top restored");
   }
+
+  // 4) Duplicate minimums (min should persist until ALL mins are popped)
+  {
+    StackWithMin<int> stack;
+    stack.push(3);
+    stack.push(1);
+    stack.push(1);
+    stack.push(2);
+
+    runner.expectEqual(stack.min(), std::optional<int>(1), "min with duplicates");
+    runner.expectEqual(stack.top(), std::optional<int>(2), "top with duplicates");
+
+    stack.pop(); // pop 2
+    runner.expectEqual(stack.min(), std::optional<int>(1), "min after popping non-min");
+    runner.expectEqual(stack.top(), std::optional<int>(1), "top after popping non-min");
+
+    stack.pop(); // pop 1 (still another 1 remains)
+    runner.expectEqual(stack.min(), std::optional<int>(1), "min remains after popping one duplicate min");
+    runner.expectEqual(stack.top(), std::optional<int>(1), "top now duplicate min");
+
+    stack.pop(); // pop last 1, min should restore to 3
+    runner.expectEqual(stack.min(), std::optional<int>(3), "min restores after all duplicate mins removed");
+    runner.expectEqual(stack.top(), std::optional<int>(3), "top restores after all duplicate mins removed");
+  }
+
+  // 5) All equal values
+  {
+    StackWithMin<int> stack;
+    stack.push(4);
+    stack.push(4);
+    stack.push(4);
+
+    runner.expectEqual(stack.min(), std::optional<int>(4), "min with all equal");
+    runner.expectEqual(stack.top(), std::optional<int>(4), "top with all equal");
+
+    stack.pop();
+    runner.expectEqual(stack.min(), std::optional<int>(4), "min after pop with all equal");
+    stack.pop();
+    runner.expectEqual(stack.min(), std::optional<int>(4), "min after second pop with all equal");
+    stack.pop();
+    runner.expectEqual(stack.min(), std::optional<int>{}, "min after popping all equal to empty");
+  }
+
+  // 6) Monotonic increasing: min should stay first element until empty
+  {
+    StackWithMin<int> stack;
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+    stack.push(4);
+
+    runner.expectEqual(stack.min(), std::optional<int>(1), "min in increasing sequence");
+    stack.pop(); // 4
+    runner.expectEqual(stack.min(), std::optional<int>(1), "min after pop in increasing sequence");
+    stack.pop(); // 3
+    runner.expectEqual(stack.min(), std::optional<int>(1), "min after second pop in increasing sequence");
+  }
+
+  // 7) Monotonic decreasing: min updates each push, restores each pop
+  {
+    StackWithMin<int> stack;
+    stack.push(4);
+    runner.expectEqual(stack.min(), std::optional<int>(4), "min after push 4 (decreasing)");
+
+    stack.push(3);
+    runner.expectEqual(stack.min(), std::optional<int>(3), "min after push 3 (decreasing)");
+
+    stack.push(2);
+    runner.expectEqual(stack.min(), std::optional<int>(2), "min after push 2 (decreasing)");
+
+    stack.push(1);
+    runner.expectEqual(stack.min(), std::optional<int>(1), "min after push 1 (decreasing)");
+
+    stack.pop(); // 1
+    runner.expectEqual(stack.min(), std::optional<int>(2), "min restores to 2 after popping 1");
+    stack.pop(); // 2
+    runner.expectEqual(stack.min(), std::optional<int>(3), "min restores to 3 after popping 2");
+    stack.pop(); // 3
+    runner.expectEqual(stack.min(), std::optional<int>(4), "min restores to 4 after popping 3");
+  }
+
+  // 8) Longer deterministic sequence: validate min after every push and pop
+  {
+    StackWithMin<int> stack;
+
+    // Push a sequence where the min changes a few times.
+    // Values: 50, 49, ..., 26, 0, 25, 24, ..., 1
+    int expectedMin = 1e9;
+    for (int i = 50; i >= 26; --i) {
+      stack.push(i);
+      expectedMin = std::min(expectedMin, i);
+      runner.expectEqual(stack.min(), std::optional<int>(expectedMin), "min after push in long sequence (part 1)");
+    }
+
+    stack.push(0);
+    expectedMin = 0;
+    runner.expectEqual(stack.min(), std::optional<int>(0), "min after pushing 0 in long sequence");
+
+    for (int i = 25; i >= 1; --i) {
+      stack.push(i);
+      runner.expectEqual(stack.min(), std::optional<int>(0), "min stays 0 in long sequence (part 2)");
+    }
+
+    // Now pop everything above 0; min should stay 0 until 0 is popped.
+    for (int i = 1; i <= 25; ++i) {
+      stack.pop();
+      runner.expectEqual(stack.min(), std::optional<int>(0), "min stays 0 while popping down to 0");
+    }
+
+    // Pop 0; min should restore to 26 (the smallest remaining from 26..50)
+    stack.pop();
+    runner.expectEqual(stack.min(), std::optional<int>(26), "min restores after popping 0");
+
+    // Pop remaining; min should climb upward as we remove 26,27,...
+    for (int expected = 27; expected <= 50; ++expected) {
+      stack.pop();
+      runner.expectEqual(stack.min(),
+                         (expected <= 50 ? std::optional<int>(expected) : std::optional<int>{}),
+                         "min after popping in long sequence tail");
+    }
+
+    // After all popped, empty
+    runner.expectEqual(stack.min(), std::optional<int>{}, "min empty at end of long sequence");
+    runner.expectEqual(stack.top(), std::optional<int>{}, "top empty at end of long sequence");
+  }
+
   runner.summary();
 }
 

src/3_Stack_Queue/min_in_stack.cpp

@@ -95,14 +95,6 @@ class TreeWithVector : public BinaryTree {
   }
 };
 
-// Simple test function using assertions
-void testTreeWithVector(TestRunner &runner, const TreeWithVector &tree,
-                        const std::vector<int> &inorderExpected,
-                        const std::vector<int> &preorderExpected) {
-  runner.expectEqual(tree.inorder(), inorderExpected, "inorder traversal");
-  runner.expectEqual(tree.preorder(), preorderExpected, "preorder traversal");
-}
-
 namespace {
 struct TestRunner {
   int total = 0;
@@ -140,6 +132,14 @@ struct TestRunner {
 };
 } // namespace
 
+// Simple test function using assertions
+void testTreeWithVector(TestRunner &runner, const TreeWithVector &tree,
+                        const std::vector<int> &inorderExpected,
+                        const std::vector<int> &preorderExpected) {
+  runner.expectEqual(tree.inorder(), inorderExpected, "inorder traversal");
+  runner.expectEqual(tree.preorder(), preorderExpected, "preorder traversal");
+}
+
 int main() {
   TestRunner runner;
   testTreeWithVector(runner,

src/8_Trees/convert_to_list.cpp

@@ -57,12 +57,6 @@ class TreeWithDepth : public BinaryTree {
   }
 };
 
-// Test function to verify that the computed depth matches the expected depth.
-void testTreeWithDepth(TestRunner &runner, const TreeWithDepth &tree,
-                       unsigned int expectedDepth, const std::string &label) {
-  runner.expectEqual(tree.depth(), expectedDepth, label);
-}
-
 namespace {
 struct TestRunner {
   int total = 0;
@@ -87,6 +81,12 @@ struct TestRunner {
 };
 } // namespace
 
+// Test function to verify that the computed depth matches the expected depth.
+void testTreeWithDepth(TestRunner &runner, const TreeWithDepth &tree,
+                       unsigned int expectedDepth, const std::string &label) {
+  runner.expectEqual(tree.depth(), expectedDepth, label);
+}
+
 int main() {
   TestRunner runner;
   {

src/8_Trees/depth.cpp

@@ -82,13 +82,6 @@ class TreeWithSubtree : public BinaryTree {
   }
 };
 
-// Test function to ensure that the computed largest BST subtree size matches
-// the expected size.
-void testTreeWithSubtree(TestRunner &runner, const TreeWithSubtree &tree,
-                         int expectedSize, const std::string &label) {
-  runner.expectEqual(tree.largestBST(), expectedSize, label);
-}
-
 namespace {
 struct TestRunner {
   int total = 0;
@@ -112,6 +105,13 @@ struct TestRunner {
 };
 } // namespace
 
+// Test function to ensure that the computed largest BST subtree size matches
+// the expected size.
+void testTreeWithSubtree(TestRunner &runner, const TreeWithSubtree &tree,
+                         int expectedSize, const std::string &label) {
+  runner.expectEqual(tree.largestBST(), expectedSize, label);
+}
+
 int main() {
   TestRunner runner;
   {