Added tests for tasks 101-2929

src/test/java/g0101_0200/s0101_symmetric_tree/SolutionTest.java

@@ -20,4 +20,33 @@ void symmetricTree2() {
         TreeNode root = TreeUtils.constructBinaryTree(Arrays.asList(1, 2, 2, null, 3, null, 3));
         assertThat(new Solution().isSymmetric(root), equalTo(false));
     }
+
+    @Test
+    void symmetricTree3() {
+        assertThat(new Solution().isSymmetric(null), equalTo(true));
+    }
+
+    @Test
+    void symmetricTree4() {
+        TreeNode root = new TreeNode(1);
+        assertThat(new Solution().isSymmetric(root), equalTo(true));
+    }
+
+    @Test
+    void symmetricTree5() {
+        TreeNode root = new TreeNode(1, new TreeNode(2), null);
+        assertThat(new Solution().isSymmetric(root), equalTo(false));
+    }
+
+    @Test
+    void symmetricTree6() {
+        TreeNode root = new TreeNode(1, null, new TreeNode(2));
+        assertThat(new Solution().isSymmetric(root), equalTo(false));
+    }
+
+    @Test
+    void symmetricTree7() {
+        TreeNode root = TreeUtils.constructBinaryTree(Arrays.asList(1, 2, 2, 3, 4, 5, 3));
+        assertThat(new Solution().isSymmetric(root), equalTo(false));
+    }
 }

src/test/java/g0101_0200/s0198_house_robber/SolutionTest.java

@@ -15,4 +15,34 @@ void rob() {
     void rob2() {
         assertThat(new Solution().rob(new int[] {2, 7, 9, 3, 1}), equalTo(12));
     }
+
+    @Test
+    void rob3() {
+        assertThat(new Solution().rob(new int[] {5}), equalTo(5));
+    }
+
+    @Test
+    void rob4() {
+        assertThat(new Solution().rob(new int[] {5, 10}), equalTo(10));
+    }
+
+    @Test
+    void rob5() {
+        assertThat(new Solution().rob(new int[] {2, 1, 1, 2}), equalTo(4));
+    }
+
+    @Test
+    void rob6() {
+        assertThat(new Solution().rob(new int[] {3, 3, 3, 3, 3}), equalTo(9));
+    }
+
+    @Test
+    void rob7() {
+        assertThat(new Solution().rob(new int[] {100, 1, 100, 1, 100}), equalTo(300));
+    }
+
+    @Test
+    void rob8() {
+        assertThat(new Solution().rob(new int[] {}), equalTo(0));
+    }
 }

src/test/java/g0201_0300/s0232_implement_queue_using_stacks/MyQueueTest.java

@@ -15,4 +15,66 @@ void queueUsingStacks() {
         assertThat(myQueue.pop(), equalTo(1));
         assertThat(myQueue.empty(), equalTo(false));
     }
+
+    @Test
+    void queuePushPopPeekMultiple() {
+        MyQueue myQueue = new MyQueue();
+        myQueue.push(10);
+        myQueue.push(20);
+        myQueue.push(30);
+
+        assertThat(myQueue.peek(), equalTo(10));
+        assertThat(myQueue.pop(), equalTo(10));
+        assertThat(myQueue.peek(), equalTo(20));
+        assertThat(myQueue.pop(), equalTo(20));
+        assertThat(myQueue.peek(), equalTo(30));
+        assertThat(myQueue.pop(), equalTo(30));
+        assertThat(myQueue.empty(), equalTo(true));
+    }
+
+    @Test
+    void queueEmptyInitially() {
+        MyQueue myQueue = new MyQueue();
+        assertThat(myQueue.empty(), equalTo(true));
+    }
+
+    @Test
+    void queuePushAfterPopAll() {
+        MyQueue myQueue = new MyQueue();
+        myQueue.push(1);
+        myQueue.push(2);
+        assertThat(myQueue.pop(), equalTo(1));
+        assertThat(myQueue.pop(), equalTo(2));
+        assertThat(myQueue.empty(), equalTo(true));
+
+        myQueue.push(3);
+        assertThat(myQueue.peek(), equalTo(3));
+        assertThat(myQueue.empty(), equalTo(false));
+    }
+
+    @Test
+    void queuePeekDoesNotRemove() {
+        MyQueue myQueue = new MyQueue();
+        myQueue.push(5);
+        myQueue.push(6);
+        assertThat(myQueue.peek(), equalTo(5));
+        assertThat(myQueue.peek(), equalTo(5));
+        assertThat(myQueue.pop(), equalTo(5));
+        assertThat(myQueue.peek(), equalTo(6));
+    }
+
+    @Test
+    void pushAfterPopTriggersRightToLeft() {
+        MyQueue myQueue = new MyQueue();
+        myQueue.push(1);
+        myQueue.push(2);
+
+        assertThat(myQueue.pop(), equalTo(1));
+
+        myQueue.push(3);
+
+        assertThat(myQueue.pop(), equalTo(2));
+        assertThat(myQueue.pop(), equalTo(3));
+        assertThat(myQueue.empty(), equalTo(true));
+    }
 }

src/test/java/g0201_0300/s0235_lowest_common_ancestor_of_a_binary_search_tree/SolutionTest.java

@@ -42,4 +42,36 @@ void lowestCommonAncestor3() {
                         .val,
                 equalTo(2));
     }
+
+    @Test
+    void lowestCommonAncestor4() {
+        TreeNode root = new TreeNode(1);
+        assertThat(
+                new Solution().lowestCommonAncestor(root, new TreeNode(1), new TreeNode(1)).val,
+                equalTo(1));
+    }
+
+    @Test
+    void lowestCommonAncestor5() {
+        TreeNode root = new TreeNode(3, new TreeNode(1), new TreeNode(4));
+        assertThat(
+                new Solution().lowestCommonAncestor(root, new TreeNode(1), new TreeNode(1)).val,
+                equalTo(1));
+    }
+
+    @Test
+    void lowestCommonAncestor6() {
+        TreeNode root = new TreeNode(3, new TreeNode(1), new TreeNode(4));
+        assertThat(
+                new Solution().lowestCommonAncestor(root, new TreeNode(4), new TreeNode(4)).val,
+                equalTo(4));
+    }
+
+    @Test
+    void lowestCommonAncestor7() {
+        TreeNode root = new TreeNode(5, new TreeNode(3), new TreeNode(8));
+        assertThat(
+                new Solution().lowestCommonAncestor(root, new TreeNode(3), new TreeNode(8)).val,
+                equalTo(5));
+    }
 }

src/test/java/g2901_3000/s2929_distribute_candies_among_children_ii/SolutionTest.java

@@ -15,4 +15,39 @@ void distributeCandies() {
     void distributeCandies2() {
         assertThat(new Solution().distributeCandies(3, 3), equalTo(10L));
     }
+
+    @Test
+    void distributeCandies3() {
+        assertThat(new Solution().distributeCandies(2, 5), equalTo(6L));
+    }
+
+    @Test
+    void distributeCandies4() {
+        assertThat(new Solution().distributeCandies(4, 4), equalTo(15L));
+    }
+
+    @Test
+    void distributeCandies5() {
+        assertThat(new Solution().distributeCandies(7, 5), equalTo(27L));
+    }
+
+    @Test
+    void distributeCandies6() {
+        assertThat(new Solution().distributeCandies(12, 5), equalTo(10L));
+    }
+
+    @Test
+    void distributeCandies7() {
+        assertThat(new Solution().distributeCandies(20, 5), equalTo(0L));
+    }
+
+    @Test
+    void distributeCandies8() {
+        assertThat(new Solution().distributeCandies(10, 5), equalTo(21L));
+    }
+
+    @Test
+    void distributeCandies9() {
+        assertThat(new Solution().distributeCandies(15, 5), equalTo(1L));
+    }
 }