Added tests for tasks 335-3132

src/test/java/g0301_0400/s0335_self_crossing/SolutionTest.java

@@ -35,4 +35,60 @@ void isSelfCrossing5() {
     void isSelfCrossing6() {
         assertThat(new Solution().isSelfCrossing(new int[] {1, 1, 1}), equalTo(false));
     }
+
+    @Test
+    void isSelfCrossing7() {
+        assertThat(new Solution().isSelfCrossing(new int[] {3, 3, 3, 2, 1, 1}), equalTo(false));
+    }
+
+    @Test
+    void isSelfCrossing8() {
+        assertThat(new Solution().isSelfCrossing(new int[] {2, 3, 4, 5, 6, 7}), equalTo(false));
+    }
+
+    @Test
+    void isSelfCrossing9() {
+        assertThat(new Solution().isSelfCrossing(new int[] {2, 2, 3, 2, 2}), equalTo(true));
+    }
+
+    @Test
+    void isSelfCrossing10() {
+        assertThat(new Solution().isSelfCrossing(new int[] {1, 1, 2, 1, 2, 1}), equalTo(true));
+    }
+
+    @Test
+    void isSelfCrossing11() {
+        assertThat(new Solution().isSelfCrossing(new int[] {10, 20, 30, 40, 50}), equalTo(false));
+    }
+
+    @Test
+    void isSelfCrossing12() {
+        assertThat(new Solution().isSelfCrossing(new int[] {3, 3, 4, 2, 2}), equalTo(false));
+    }
+
+    @Test
+    void isSelfCrossing13() {
+        assertThat(new Solution().isSelfCrossing(new int[] {2, 1, 2, 1}), equalTo(true));
+    }
+
+    @Test
+    void isSelfCrossing14() {
+        assertThat(
+                new Solution().isSelfCrossing(new int[] {1, 2, 3, 4, 5, 6, 7, 8}), equalTo(false));
+    }
+
+    @Test
+    void isSelfCrossing15() {
+        assertThat(new Solution().isSelfCrossing(new int[] {2, 2, 2, 2, 2, 2}), equalTo(true));
+    }
+
+    @Test
+    void isSelfCrossing16() {
+        assertThat(new Solution().isSelfCrossing(new int[] {1, 1, 2, 1, 1}), equalTo(true));
+    }
+
+    @Test
+    void isSelfCrossing17() {
+        assertThat(new Solution().isSelfCrossing(new int[] {1, 1, 2, 2, 1, 1}), equalTo(true));
+    }
 }

src/test/java/g0601_0700/s0641_design_circular_deque/MyCircularDequeTest.java

@@ -19,4 +19,75 @@ void myCircularDequeTest() {
         assertThat(myCircularDeque.insertFront(4), equalTo(true));
         assertThat(myCircularDeque.getFront(), equalTo(4));
     }
+
+    @Test
+    void myCircularDequeTest2() {
+        MyCircularDeque deque = new MyCircularDeque(2);
+        assertThat(deque.insertFront(10), equalTo(true));
+        assertThat(deque.insertFront(20), equalTo(true));
+        assertThat(deque.insertFront(30), equalTo(false));
+        assertThat(deque.getFront(), equalTo(20));
+        assertThat(deque.deleteFront(), equalTo(true));
+        assertThat(deque.getFront(), equalTo(10));
+    }
+
+    @Test
+    void myCircularDequeTest3() {
+        MyCircularDeque deque = new MyCircularDeque(1);
+        assertThat(deque.deleteFront(), equalTo(false));
+        assertThat(deque.deleteLast(), equalTo(false));
+        assertThat(deque.getFront(), equalTo(-1));
+        assertThat(deque.getRear(), equalTo(-1));
+        assertThat(deque.isEmpty(), equalTo(true));
+        assertThat(deque.isFull(), equalTo(false));
+    }
+
+    @Test
+    void myCircularDequeTest4() {
+        MyCircularDeque deque = new MyCircularDeque(2);
+        assertThat(deque.insertLast(5), equalTo(true));
+        assertThat(deque.insertFront(6), equalTo(true));
+        assertThat(deque.isFull(), equalTo(true));
+        assertThat(deque.insertFront(7), equalTo(false));
+        assertThat(deque.getFront(), equalTo(6));
+        assertThat(deque.getRear(), equalTo(5));
+    }
+
+    @Test
+    void myCircularDequeTest5() {
+        MyCircularDeque deque = new MyCircularDeque(3);
+        assertThat(deque.insertFront(10), equalTo(true));
+        assertThat(deque.deleteFront(), equalTo(true));
+        assertThat(deque.insertLast(20), equalTo(true));
+        assertThat(deque.deleteLast(), equalTo(true));
+        assertThat(deque.isEmpty(), equalTo(true));
+    }
+
+    @Test
+    void myCircularDequeTest6() {
+        MyCircularDeque deque = new MyCircularDeque(1);
+        assertThat(deque.insertFront(100), equalTo(true));
+        assertThat(deque.isFull(), equalTo(true));
+        assertThat(deque.getFront(), equalTo(100));
+        assertThat(deque.getRear(), equalTo(100));
+        assertThat(deque.deleteFront(), equalTo(true));
+        assertThat(deque.isEmpty(), equalTo(true));
+    }
+
+    @Test
+    void myCircularDequeTest7() {
+        MyCircularDeque deque = new MyCircularDeque(5);
+        deque.insertFront(1);
+        deque.insertLast(2);
+        deque.insertFront(3);
+        deque.insertLast(4);
+        deque.insertFront(5);
+        assertThat(deque.isFull(), equalTo(true));
+        deque.deleteFront();
+        deque.deleteLast();
+        assertThat(deque.insertFront(6), equalTo(true));
+        assertThat(deque.insertLast(7), equalTo(true));
+        assertThat(deque.getFront(), equalTo(6));
+        assertThat(deque.getRear(), equalTo(7));
+    }
 }

src/test/java/g2801_2900/s2839_check_if_strings_can_be_made_equal_with_operations_i/SolutionTest.java

@@ -15,4 +15,44 @@ void canBeEqual() {
     void canBeEqual2() {
         assertThat(new Solution().canBeEqual("abcd", "cdab"), equalTo(true));
     }
+
+    @Test
+    void canBeEqual3() {
+        assertThat(new Solution().canBeEqual("abcd", "abcd"), equalTo(true));
+    }
+
+    @Test
+    void canBeEqual4() {
+        assertThat(new Solution().canBeEqual("abcd", "cbad"), equalTo(true));
+    }
+
+    @Test
+    void canBeEqual5() {
+        assertThat(new Solution().canBeEqual("abcd", "adcb"), equalTo(true));
+    }
+
+    @Test
+    void canBeEqual6() {
+        assertThat(new Solution().canBeEqual("abcd", "abdc"), equalTo(false));
+    }
+
+    @Test
+    void canBeEqual7() {
+        assertThat(new Solution().canBeEqual("abcd", "wxyz"), equalTo(false));
+    }
+
+    @Test
+    void canBeEqual8() {
+        assertThat(new Solution().canBeEqual("aabb", "bbaa"), equalTo(true));
+    }
+
+    @Test
+    void canBeEqual9() {
+        assertThat(new Solution().canBeEqual("abcd", "cdab"), equalTo(true));
+    }
+
+    @Test
+    void canBeEqual10() {
+        assertThat(new Solution().canBeEqual("abba", "baab"), equalTo(true));
+    }
 }

src/test/java/g3001_3100/s3024_type_of_triangle/SolutionTest.java

@@ -15,4 +15,70 @@ void triangleType() {
     void triangleType2() {
         assertThat(new Solution().triangleType(new int[] {3, 4, 5}), equalTo("scalene"));
     }
+
+    @Test
+    void triangleType3() {
+        assertThat(new Solution().triangleType(new int[] {5, 5, 3}), equalTo("isosceles"));
+    }
+
+    @Test
+    void triangleType4() {
+        assertThat(new Solution().triangleType(new int[] {1, 2, 3}), equalTo("none"));
+    }
+
+    @Test
+    void triangleType5() {
+        assertThat(new Solution().triangleType(new int[] {100, 100, 100}), equalTo("equilateral"));
+    }
+
+    @Test
+    void triangleType6() {
+        assertThat(new Solution().triangleType(new int[] {7, 10, 7}), equalTo("isosceles"));
+    }
+
+    @Test
+    void triangleType7() {
+        assertThat(new Solution().triangleType(new int[] {0, 4, 4}), equalTo("none"));
+    }
+
+    @Test
+    void triangleType8() {
+        assertThat(new Solution().triangleType(new int[] {-3, 4, 5}), equalTo("none"));
+    }
+
+    @Test
+    void triangleType9() {
+        // 2 + 3 = 5 → equals, not greater → invalid
+        assertThat(new Solution().triangleType(new int[] {2, 3, 5}), equalTo("none"));
+    }
+
+    @Test
+    void triangleType10() {
+        assertThat(new Solution().triangleType(new int[] {5, 3, 4}), equalTo("scalene"));
+    }
+
+    @Test
+    void triangleType11() {
+        assertThat(new Solution().triangleType(new int[] {4, 6, 6}), equalTo("isosceles"));
+    }
+
+    @Test
+    void triangleType12() {
+        assertThat(new Solution().triangleType(new int[] {0, 0, 0}), equalTo("none"));
+    }
+
+    @Test
+    void triangleType13() {
+        assertThat(new Solution().triangleType(new int[] {5, 5, 6}), equalTo("isosceles"));
+    }
+
+    @Test
+    void triangleType14() {
+        assertThat(new Solution().triangleType(new int[] {10, 11, 12}), equalTo("scalene"));
+    }
+
+    @Test
+    void triangleType15() {
+        assertThat(new Solution().triangleType(new int[] {1, 10, 12}), equalTo("none"));
+    }
 }

src/test/java/g3101_3200/s3132_find_the_integer_added_to_array_ii/SolutionTest.java

@@ -20,4 +20,42 @@ void minimumAddedInteger2() {
                 new Solution().minimumAddedInteger(new int[] {3, 5, 5, 3}, new int[] {7, 7}),
                 equalTo(2));
     }
+
+    @Test
+    void minimumAddedInteger3() {
+        assertThat(
+                new Solution().minimumAddedInteger(new int[] {10, 20, 30, 40}, new int[] {35, 45}),
+                equalTo(5));
+    }
+
+    @Test
+    void minimumAddedInteger4() {
+        assertThat(
+                new Solution().minimumAddedInteger(new int[] {2, 5, 7, 8}, new int[] {9, 10}),
+                equalTo(2));
+    }
+
+    @Test
+    void minimumAddedInteger5() {
+        assertThat(
+                new Solution().minimumAddedInteger(new int[] {2, 2, 2, 4, 4}, new int[] {6, 6, 8}),
+                equalTo(4));
+    }
+
+    @Test
+    void minimumAddedInteger6() {
+        assertThat(
+                new Solution().minimumAddedInteger(new int[] {5, 5, 5, 5}, new int[] {5, 5}),
+                equalTo(0));
+    }
+
+    @Test
+    void minimumAddedInteger7() {
+        assertThat(
+                new Solution()
+                        .minimumAddedInteger(
+                                new int[] {1_000_000, 2_000_000, 3_000_000, 4_000_000},
+                                new int[] {3_000_002, 4_000_002}),
+                equalTo(2));
+    }
 }