From ae43495cee8cc8026abf1532a4a676037c39da23 Mon Sep 17 00:00:00 2001 From: ThanhNIT Date: Sat, 29 Nov 2025 09:14:09 +0700 Subject: [PATCH] Added tests for tasks 564-2420 --- .../SolutionTest.kt | 55 ++++++++++++ .../MyLinkedListTest.kt | 84 +++++++++++++++++++ .../s0925_long_pressed_name/SolutionTest.kt | 75 +++++++++++++++++ .../s1154_day_of_the_year/SolutionTest.kt | 50 +++++++++++ .../SolutionTest.kt | 64 ++++++++++++++ 5 files changed, 328 insertions(+) diff --git a/src/test/kotlin/g0501_0600/s0564_find_the_closest_palindrome/SolutionTest.kt b/src/test/kotlin/g0501_0600/s0564_find_the_closest_palindrome/SolutionTest.kt index 52b554d00..cdd145eb0 100644 --- a/src/test/kotlin/g0501_0600/s0564_find_the_closest_palindrome/SolutionTest.kt +++ b/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")) + } } diff --git a/src/test/kotlin/g0701_0800/s0707_design_linked_list/MyLinkedListTest.kt b/src/test/kotlin/g0701_0800/s0707_design_linked_list/MyLinkedListTest.kt index f83b20b6a..5d495958d 100644 --- a/src/test/kotlin/g0701_0800/s0707_design_linked_list/MyLinkedListTest.kt +++ b/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)) + } } diff --git a/src/test/kotlin/g0901_1000/s0925_long_pressed_name/SolutionTest.kt b/src/test/kotlin/g0901_1000/s0925_long_pressed_name/SolutionTest.kt index 86cec2c22..6c3e40e2f 100644 --- a/src/test/kotlin/g0901_1000/s0925_long_pressed_name/SolutionTest.kt +++ b/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)) + } } diff --git a/src/test/kotlin/g1101_1200/s1154_day_of_the_year/SolutionTest.kt b/src/test/kotlin/g1101_1200/s1154_day_of_the_year/SolutionTest.kt index 16ce0d3ec..da1635ad2 100644 --- a/src/test/kotlin/g1101_1200/s1154_day_of_the_year/SolutionTest.kt +++ b/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)) + } } diff --git a/src/test/kotlin/g2401_2500/s2420_find_all_good_indices/SolutionTest.kt b/src/test/kotlin/g2401_2500/s2420_find_all_good_indices/SolutionTest.kt index 10948d16a..761084eef 100644 --- a/src/test/kotlin/g2401_2500/s2420_find_all_good_indices/SolutionTest.kt +++ b/src/test/kotlin/g2401_2500/s2420_find_all_good_indices/SolutionTest.kt @@ -20,4 +20,68 @@ internal class SolutionTest { equalTo(emptyList()), ) } + + @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()), + ) + } + + @Test + fun goodIndices5() { + assertThat( + Solution().goodIndices(intArrayOf(1, 2, 3, 4, 5), 2), + equalTo(emptyList()), + ) + } + + @Test + fun goodIndices6() { + assertThat( + Solution().goodIndices(intArrayOf(1, 2), 2), + equalTo(emptyList()), + ) + } + + @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)), + ) + } }