Added tests for tasks 564-2420

src/test/kotlin/g0501_0600/s0564_find_the_closest_palindrome/SolutionTest.kt

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

src/test/kotlin/g0701_0800/s0707_design_linked_list/MyLinkedListTest.kt

@@ -26,4 +26,88 @@ internal class MyLinkedListTest {
         myLinkedList.deleteAtIndex(0)
         assertThat(myLinkedList[0], equalTo(2))
     }
+
+    @Test
+    fun myLinkedList3() {
+        val list = MyLinkedList()
+        list.addAtHead(1)
+        list.addAtTail(2)
+        list.addAtIndex(5, 3)
+        assertThat(list.get(2), equalTo(-1))
+    }
+
+    @Test
+    fun myLinkedList4() {
+        val list = MyLinkedList()
+        list.addAtIndex(0, 10)
+        assertThat(list.get(0), equalTo(10))
+    }
+
+    @Test
+    fun myLinkedList5() {
+        val list = MyLinkedList()
+        list.addAtTail(5)
+        assertThat(list.get(0), equalTo(5))
+    }
+
+    @Test
+    fun myLinkedList6() {
+        val list = MyLinkedList()
+        list.addAtHead(1)
+        list.deleteAtIndex(5)
+        assertThat(list.get(0), equalTo(1))
+    }
+
+    @Test
+    fun myLinkedList7() {
+        val list = 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
+    fun myLinkedList8() {
+        val list = MyLinkedList()
+        list.addAtHead(1)
+        list.addAtTail(2)
+        list.addAtTail(3)
+        list.deleteAtIndex(1)
+        assertThat(list.get(1), equalTo(3))
+    }
+
+    @Test
+    fun myLinkedList9() {
+        val list = MyLinkedList()
+        list.addAtHead(1)
+        list.addAtTail(2)
+        assertThat(list.get(5), equalTo(-1))
+        assertThat(list.get(-1), equalTo(2))
+    }
+
+    @Test
+    fun myLinkedList10() {
+        val list = 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
+    fun myLinkedList11() {
+        val list = MyLinkedList()
+        list.addAtHead(1)
+        list.addAtHead(2)
+        assertThat(list.get(0), equalTo(2))
+        assertThat(list.get(1), equalTo(1))
+    }
 }

src/test/kotlin/g0901_1000/s0925_long_pressed_name/SolutionTest.kt

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

src/test/kotlin/g1101_1200/s1154_day_of_the_year/SolutionTest.kt

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

src/test/kotlin/g2401_2500/s2420_find_all_good_indices/SolutionTest.kt

@@ -20,4 +20,68 @@ internal class SolutionTest {
             equalTo(emptyList<Any>()),
         )
     }
+
+    @Test
+    fun goodIndices3() {
+        assertThat(
+            Solution().goodIndices(intArrayOf(5, 3, 4, 2, 1), 1),
+            equalTo(listOf(1, 2, 3)),
+        )
+    }
+
+    @Test
+    fun goodIndices4() {
+        assertThat(
+            Solution().goodIndices(intArrayOf(5, 4, 3, 2, 1), 2),
+            equalTo(emptyList<Int>()),
+        )
+    }
+
+    @Test
+    fun goodIndices5() {
+        assertThat(
+            Solution().goodIndices(intArrayOf(1, 2, 3, 4, 5), 2),
+            equalTo(emptyList<Int>()),
+        )
+    }
+
+    @Test
+    fun goodIndices6() {
+        assertThat(
+            Solution().goodIndices(intArrayOf(1, 2), 2),
+            equalTo(emptyList<Int>()),
+        )
+    }
+
+    @Test
+    fun goodIndices7() {
+        assertThat(
+            Solution().goodIndices(intArrayOf(5, 4, 4, 3, 2, 2, 3, 4, 4, 3, 2), 2),
+            equalTo(listOf(3, 4, 5, 6)),
+        )
+    }
+
+    @Test
+    fun goodIndices8() {
+        assertThat(
+            Solution().goodIndices(intArrayOf(3, 2, 1, 2, 3, 2, 1, 2, 3), 2),
+            equalTo(listOf(2, 6)),
+        )
+    }
+
+    @Test
+    fun goodIndices9() {
+        assertThat(
+            Solution().goodIndices(intArrayOf(3, 2, 1, 1, 2, 3), 2),
+            equalTo(listOf(2, 3)),
+        )
+    }
+
+    @Test
+    fun goodIndices10() {
+        assertThat(
+            Solution().goodIndices(intArrayOf(2, 2, 2, 2, 2), 2),
+            equalTo(listOf(2)),
+        )
+    }
 }