test: test more solutions

Author: wisarootl

leetcode/binary_tree_right_side_view/test_solution.py

@@ -3,14 +3,15 @@
 from leetcode_py.test_utils import logged_test
 
 from .helpers import assert_right_side_view, run_right_side_view
-from .solution import Solution
+from .solution import Solution, SolutionBFS, SolutionDFS
 
 
 class TestBinaryTreeRightSideView:
     def setup_method(self):
         self.solution = Solution()
 
     @logged_test
+    @pytest.mark.parametrize("solution_class", [Solution, SolutionDFS, SolutionBFS])
     @pytest.mark.parametrize(
         "root_list, expected",
         [
@@ -30,6 +31,8 @@ def setup_method(self):
             ([10, 5, 15, None, 6, 12, 20], [10, 15, 20]),
         ],
     )
-    def test_right_side_view(self, root_list: list[int | None], expected: list[int]):
-        result = run_right_side_view(Solution, root_list)
+    def test_right_side_view(
+        self, solution_class: type, root_list: list[int | None], expected: list[int]
+    ):
+        result = run_right_side_view(solution_class, root_list)
         assert_right_side_view(result, expected)

leetcode/invert_binary_tree/test_solution.py

@@ -3,14 +3,15 @@
 from leetcode_py.test_utils import logged_test
 
 from .helpers import assert_invert_tree, run_invert_tree
-from .solution import Solution
+from .solution import Solution, SolutionBFS, SolutionDFS
 
 
 class TestInvertBinaryTree:
     def setup_method(self):
         self.solution = Solution()
 
     @logged_test
+    @pytest.mark.parametrize("solution_class", [Solution, SolutionDFS, SolutionBFS])
     @pytest.mark.parametrize(
         "root_list, expected_list",
         [
@@ -31,6 +32,8 @@ def setup_method(self):
             ([1, 2, 3, None, 4, None, 5], [1, 3, 2, 5, None, 4]),
         ],
     )
-    def test_invert_tree(self, root_list: list[int | None], expected_list: list[int | None]):
-        result = run_invert_tree(Solution, root_list)
+    def test_invert_tree(
+        self, solution_class: type, root_list: list[int | None], expected_list: list[int | None]
+    ):
+        result = run_invert_tree(solution_class, root_list)
         assert_invert_tree(result, expected_list)

leetcode/longest_palindromic_substring/test_solution.py

@@ -3,14 +3,15 @@
 from leetcode_py.test_utils import logged_test
 
 from .helpers import assert_longest_palindrome, run_longest_palindrome
-from .solution import Solution
+from .solution import Solution, SolutionManacher
 
 
 class TestLongestPalindromicSubstring:
     def setup_method(self):
         self.solution = Solution()
 
     @logged_test
+    @pytest.mark.parametrize("solution_class", [Solution, SolutionManacher])
     @pytest.mark.parametrize(
         "s, expected",
         [
@@ -28,6 +29,6 @@ def setup_method(self):
             ("abcba", {"abcba"}),
         ],
     )
-    def test_longest_palindrome(self, s: str, expected: set[str]):
-        result = run_longest_palindrome(Solution, s)
+    def test_longest_palindrome(self, solution_class: type, s: str, expected: set[str]):
+        result = run_longest_palindrome(solution_class, s)
         assert_longest_palindrome(result, expected)

leetcode/lru_cache/test_solution.py

@@ -3,12 +3,13 @@
 from leetcode_py.test_utils import logged_test
 
 from .helpers import assert_lru_cache, run_lru_cache
-from .solution import LRUCache
+from .solution import LRUCache, LRUCacheWithDoublyList
 
 
 class TestLRUCache:
 
     @logged_test
+    @pytest.mark.parametrize("solution_class", [LRUCache, LRUCacheWithDoublyList])
     @pytest.mark.parametrize(
         "operations, inputs, expected",
         [
@@ -66,6 +67,12 @@ class TestLRUCache:
             ),
         ],
     )
-    def test_lru_cache(self, operations: list[str], inputs: list[list[int]], expected: list[int | None]):
-        result, _ = run_lru_cache(LRUCache, operations, inputs)
+    def test_lru_cache(
+        self,
+        solution_class: type,
+        operations: list[str],
+        inputs: list[list[int]],
+        expected: list[int | None],
+    ):
+        result, _ = run_lru_cache(solution_class, operations, inputs)
         assert_lru_cache(result, expected)

leetcode/partition_equal_subset_sum/test_solution.py

@@ -3,14 +3,15 @@
 from leetcode_py.test_utils import logged_test
 
 from .helpers import assert_can_partition, run_can_partition
-from .solution import Solution
+from .solution import Solution, SolutionBitset
 
 
 class TestPartitionEqualSubsetSum:
     def setup_method(self):
         self.solution = Solution()
 
     @logged_test
+    @pytest.mark.parametrize("solution_class", [Solution, SolutionBitset])
     @pytest.mark.parametrize(
         "nums, expected",
         [
@@ -31,6 +32,6 @@ def setup_method(self):
             ([4, 4, 4, 4, 4, 4], True),
         ],
     )
-    def test_can_partition(self, nums: list[int], expected: bool):
-        result = run_can_partition(Solution, nums)
+    def test_can_partition(self, solution_class: type, nums: list[int], expected: bool):
+        result = run_can_partition(solution_class, nums)
         assert_can_partition(result, expected)

leetcode/validate_binary_search_tree/test_solution.py

@@ -3,14 +3,15 @@
 from leetcode_py.test_utils import logged_test
 
 from .helpers import assert_is_valid_bst, run_is_valid_bst
-from .solution import Solution
+from .solution import Solution, SolutionBFS, SolutionDFS
 
 
 class TestValidateBinarySearchTree:
     def setup_method(self):
         self.solution = Solution()
 
     @logged_test
+    @pytest.mark.parametrize("solution_class", [Solution, SolutionDFS, SolutionBFS])
     @pytest.mark.parametrize(
         "root_list, expected",
         [
@@ -28,6 +29,6 @@ def setup_method(self):
             ([3, 1, 5, 0, 2, 4, 6], True),
         ],
     )
-    def test_is_valid_bst(self, root_list: list[int | None], expected: bool):
-        result = run_is_valid_bst(Solution, root_list)
+    def test_is_valid_bst(self, solution_class: type, root_list: list[int | None], expected: bool):
+        result = run_is_valid_bst(solution_class, root_list)
         assert_is_valid_bst(result, expected)