Added tests for tasks 564-2420

src/test/java/g0501_0600/s0564_find_the_closest_palindrome/SolutionTest.java

@@ -15,4 +15,59 @@ void nearestPalindromic() {
     void nearestPalindromic2() {
         assertThat(new Solution().nearestPalindromic("1"), equalTo("0"));
     }
+
+    @Test
+    void nearestPalindromic3() {
+        assertThat(new Solution().nearestPalindromic("121"), equalTo("111"));
+    }
+
+    @Test
+    void nearestPalindromic4() {
+        assertThat(new Solution().nearestPalindromic("100"), equalTo("99"));
+    }
+
+    @Test
+    void nearestPalindromic5() {
+        assertThat(new Solution().nearestPalindromic("2"), equalTo("1"));
+    }
+
+    @Test
+    void nearestPalindromic6() {
+        assertThat(new Solution().nearestPalindromic("999"), equalTo("1001"));
+    }
+
+    @Test
+    void nearestPalindromic7() {
+        assertThat(new Solution().nearestPalindromic("1221"), equalTo("1111"));
+    }
+
+    @Test
+    void nearestPalindromic8() {
+        assertThat(new Solution().nearestPalindromic("12321"), equalTo("12221"));
+    }
+
+    @Test
+    void nearestPalindromic9() {
+        assertThat(new Solution().nearestPalindromic("1000001"), equalTo("999999"));
+    }
+
+    @Test
+    void nearestPalindromic10() {
+        assertThat(new Solution().nearestPalindromic("10"), equalTo("9"));
+    }
+
+    @Test
+    void nearestPalindromic11() {
+        assertThat(new Solution().nearestPalindromic("11"), equalTo("9"));
+    }
+
+    @Test
+    void nearestPalindromic12() {
+        assertThat(new Solution().nearestPalindromic("807"), equalTo("808"));
+    }
+
+    @Test
+    void nearestPalindromic13() {
+        assertThat(new Solution().nearestPalindromic("1000"), equalTo("999"));
+    }
 }

src/test/java/g0701_0800/s0707_design_linked_list/MyLinkedListTest.java

@@ -27,4 +27,88 @@ void myLinkedList2() {
         myLinkedList.deleteAtIndex(0);
         assertThat(myLinkedList.get(0), equalTo(2));
     }
+
+    @Test
+    void myLinkedList3() {
+        MyLinkedList list = new MyLinkedList();
+        list.addAtHead(1);
+        list.addAtTail(2);
+        list.addAtIndex(5, 3);
+        assertThat(list.get(2), equalTo(-1));
+    }
+
+    @Test
+    void myLinkedList4() {
+        MyLinkedList list = new MyLinkedList();
+        list.addAtIndex(0, 10);
+        assertThat(list.get(0), equalTo(10));
+    }
+
+    @Test
+    void myLinkedList5() {
+        MyLinkedList list = new MyLinkedList();
+        list.addAtTail(5);
+        assertThat(list.get(0), equalTo(5));
+    }
+
+    @Test
+    void myLinkedList6() {
+        MyLinkedList list = new MyLinkedList();
+        list.addAtHead(1);
+        list.deleteAtIndex(5);
+        assertThat(list.get(0), equalTo(1));
+    }
+
+    @Test
+    void myLinkedList7() {
+        MyLinkedList list = new MyLinkedList();
+        list.addAtHead(1);
+        list.addAtTail(2);
+        list.addAtTail(3);
+        list.deleteAtIndex(0);
+        assertThat(list.get(0), equalTo(2));
+        list.deleteAtIndex(1);
+        assertThat(list.get(1), equalTo(-1));
+    }
+
+    @Test
+    void myLinkedList8() {
+        MyLinkedList list = new MyLinkedList();
+        list.addAtHead(1);
+        list.addAtTail(2);
+        list.addAtTail(3);
+        list.deleteAtIndex(1);
+        assertThat(list.get(1), equalTo(3));
+    }
+
+    @Test
+    void myLinkedList9() {
+        MyLinkedList list = new MyLinkedList();
+        list.addAtHead(1);
+        list.addAtTail(2);
+        assertThat(list.get(5), equalTo(-1));
+        assertThat(list.get(-1), equalTo(2));
+    }
+
+    @Test
+    void myLinkedList10() {
+        MyLinkedList list = new MyLinkedList();
+        list.addAtHead(1);
+        list.addAtTail(2);
+        list.addAtIndex(1, 3);
+        list.deleteAtIndex(0);
+        list.addAtTail(4);
+        assertThat(list.get(0), equalTo(3));
+        assertThat(list.get(1), equalTo(2));
+        assertThat(list.get(2), equalTo(4));
+    }
+
+    @Test
+    void myLinkedList11() {
+        MyLinkedList list = new MyLinkedList();
+        list.addAtHead(1);
+        list.addAtHead(2);
+        assertThat(list.get(0), equalTo(2));
+        assertThat(list.get(1), equalTo(1));
+    }
 }

src/test/java/g0901_1000/s0925_long_pressed_name/SolutionTest.java

@@ -15,4 +15,79 @@ void isLongPressedName() {
     void isLongPressedName2() {
         assertThat(new Solution().isLongPressedName("saeed", "ssaaedd"), equalTo(false));
     }
+
+    @Test
+    void isLongPressedName3() {
+        assertThat(new Solution().isLongPressedName("alex", "ale"), equalTo(false));
+    }
+
+    @Test
+    void isLongPressedName4() {
+        assertThat(new Solution().isLongPressedName("alex", "alex"), equalTo(true));
+    }
+
+    @Test
+    void isLongPressedName5() {
+        assertThat(new Solution().isLongPressedName("alex", "alexxxxx"), equalTo(true));
+    }
+
+    @Test
+    void isLongPressedName6() {
+        assertThat(new Solution().isLongPressedName("alex", "alexy"), equalTo(false));
+    }
+
+    @Test
+    void isLongPressedName7() {
+        assertThat(new Solution().isLongPressedName("aabb", "aaabbb"), equalTo(true));
+    }
+
+    @Test
+    void isLongPressedName8() {
+        assertThat(new Solution().isLongPressedName("alex", "paalex"), equalTo(false));
+    }
+
+    @Test
+    void isLongPressedName9() {
+        assertThat(new Solution().isLongPressedName("alex", "allez"), equalTo(false));
+    }
+
+    @Test
+    void isLongPressedName10() {
+        assertThat(new Solution().isLongPressedName("a", "aaaaaa"), equalTo(true));
+    }
+
+    @Test
+    void isLongPressedName11() {
+        assertThat(new Solution().isLongPressedName("a", "b"), equalTo(false));
+    }
+
+    @Test
+    void isLongPressedName12() {
+        assertThat(new Solution().isLongPressedName("le", "leeex"), equalTo(false));
+    }
+
+    @Test
+    void isLongPressedName13() {
+        assertThat(new Solution().isLongPressedName("n", "nnnnn"), equalTo(true));
+    }
+
+    @Test
+    void isLongPressedName14() {
+        assertThat(new Solution().isLongPressedName("vtkgn", "vttkgnn"), equalTo(true));
+    }
+
+    @Test
+    void isLongPressedName15() {
+        assertThat(new Solution().isLongPressedName("ab", "aabb"), equalTo(true));
+    }
+
+    @Test
+    void isLongPressedName16() {
+        assertThat(new Solution().isLongPressedName("ab", "aa"), equalTo(false));
+    }
+
+    @Test
+    void isLongPressedName17() {
+        assertThat(new Solution().isLongPressedName("abc", "aab"), equalTo(false));
+    }
 }

src/test/java/g1101_1200/s1154_day_of_the_year/SolutionTest.java

@@ -15,4 +15,54 @@ void dayOfYear() {
     void dayOfYear2() {
         assertThat(new Solution().dayOfYear("2019-02-10"), equalTo(41));
     }
+
+    @Test
+    void dayOfYear3() {
+        assertThat(new Solution().dayOfYear("2020-02-01"), equalTo(32));
+    }
+
+    @Test
+    void dayOfYear4() {
+        assertThat(new Solution().dayOfYear("2020-03-01"), equalTo(61));
+    }
+
+    @Test
+    void dayOfYear5() {
+        assertThat(new Solution().dayOfYear("2019-02-28"), equalTo(59));
+    }
+
+    @Test
+    void dayOfYear6() {
+        assertThat(new Solution().dayOfYear("2020-02-29"), equalTo(60));
+    }
+
+    @Test
+    void dayOfYear7() {
+        assertThat(new Solution().dayOfYear("2019-12-31"), equalTo(365));
+    }
+
+    @Test
+    void dayOfYear8() {
+        assertThat(new Solution().dayOfYear("2020-12-31"), equalTo(366));
+    }
+
+    @Test
+    void dayOfYear9() {
+        assertThat(new Solution().dayOfYear("2021-01-01"), equalTo(1));
+    }
+
+    @Test
+    void dayOfYear10() {
+        assertThat(new Solution().dayOfYear("2021-07-04"), equalTo(185));
+    }
+
+    @Test
+    void dayOfYear11() {
+        assertThat(new Solution().dayOfYear("2000-02-29"), equalTo(60));
+    }
+
+    @Test
+    void dayOfYear12() {
+        assertThat(new Solution().dayOfYear("1900-03-01"), equalTo(60));
+    }
 }

src/test/java/g2401_2500/s2420_find_all_good_indices/SolutionTest.java

@@ -5,6 +5,7 @@
 
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.List;
 import org.junit.jupiter.api.Test;
 
 class SolutionTest {
@@ -21,4 +22,57 @@ void goodIndices2() {
                 new Solution().goodIndices(new int[] {2, 1, 1, 2}, 2),
                 equalTo(Collections.emptyList()));
     }
+
+    @Test
+    void goodIndices3() {
+        assertThat(
+                new Solution().goodIndices(new int[] {5, 3, 4, 2, 1}, 1),
+                equalTo(Arrays.asList(1, 2, 3)));
+    }
+
+    @Test
+    void goodIndices4() {
+        assertThat(new Solution().goodIndices(new int[] {5, 4, 3, 2, 1}, 2), equalTo(List.of()));
+    }
+
+    @Test
+    void goodIndices5() {
+        assertThat(
+                new Solution().goodIndices(new int[] {1, 2, 3, 4, 5}, 2),
+                equalTo(Collections.emptyList()));
+    }
+
+    @Test
+    void goodIndices6() {
+        assertThat(
+                new Solution().goodIndices(new int[] {1, 2}, 2), equalTo(Collections.emptyList()));
+    }
+
+    @Test
+    void goodIndices7() {
+        assertThat(
+                new Solution().goodIndices(new int[] {5, 4, 4, 3, 2, 2, 3, 4, 4, 3, 2}, 2),
+                equalTo(Arrays.asList(3, 4, 5, 6)));
+    }
+
+    @Test
+    void goodIndices8() {
+        assertThat(
+                new Solution().goodIndices(new int[] {3, 2, 1, 2, 3, 2, 1, 2, 3}, 2),
+                equalTo(Arrays.asList(2, 6)));
+    }
+
+    @Test
+    void goodIndices9() {
+        assertThat(
+                new Solution().goodIndices(new int[] {3, 2, 1, 1, 2, 3}, 2),
+                equalTo(Arrays.asList(2, 3)));
+    }
+
+    @Test
+    void goodIndices10() {
+        assertThat(
+                new Solution().goodIndices(new int[] {2, 2, 2, 2, 2}, 2),
+                equalTo(Arrays.asList(2)));
+    }
 }