Merge branch 'the-kid89-add_test_to_unittests'

'Updated tests/test_searching.py'

Author: OmkarPathak

.gitignore

@@ -55,3 +55,4 @@ docs/_build/
 
 # PyBuilder
 target/
+.idea/

tests/searching_tests.py renamed to tests/test_searching.py

@@ -1,11 +1,13 @@
 import unittest
 
-from pygorithm.searching import (linear_search,
-                                  binary_search,
-                                  breadth_first_search,
-                                  depth_first_search)
+from pygorithm.searching import (
+    linear_search,
+    binary_search,
+    breadth_first_search,
+    depth_first_search)
 
-class SearchingAlgorithmTest(unittest.TestCase):
+
+class TestSearchingAlgorithm(unittest.TestCase):
     def setUp(self):
         # to test numeric numbers
         self.array = list(range(15))
@@ -14,7 +16,8 @@ def setUp(self):
         string = 'pythonisawesome'
         self.alphaArray = list(string)
 
-class LinearSearch(SearchingAlgorithmTest):
+
+class TestLinearSearch(TestSearchingAlgorithm):
     def test_linear_search(self):
         result = linear_search.search(self.array, 7)
         self.assertIs(result, 7)
@@ -25,7 +28,8 @@ def test_linear_search(self):
         alpha_result = linear_search.search(self.array, 'n')
         self.assertIs(alpha_result, -1)
 
-class BinarySearch(SearchingAlgorithmTest):
+
+class TestBinarySearch(TestSearchingAlgorithm):
     def test_binary_search(self):
         result = binary_search.search(self.array, 7)
         self.assertIs(result, 7)
@@ -36,7 +40,8 @@ def test_binary_search(self):
         alpha_result = binary_search.search(self.array, 'n')
         self.assertIs(alpha_result, -1)
 
-class BFSSearch(unittest.TestCase):
+
+class TestBFSSearch(unittest.TestCase):
     def test_bfs(self):
         self.graph = {
             'A': {'B', 'C', 'E'},
@@ -52,7 +57,8 @@ def test_bfs(self):
         result = breadth_first_search.search(self.graph, 'G')
         self.assertEqual(result, {'G', 'C', 'A', 'B', 'D', 'F', 'E'})
 
-class DFSSearch(unittest.TestCase):
+
+class TestDFSSearch(unittest.TestCase):
     def test_dfs(self):
         self.graph = {
             'A': ['B', 'C', 'E'],
@@ -68,5 +74,6 @@ def test_dfs(self):
         result = depth_first_search.search(self.graph, 'G')
         self.assertEqual(result, ['G', 'C', 'A', 'B', 'D', 'F', 'E'])
 
+
 if __name__ == '__main__':
     unittest.main()

tests/sorting_tests.py renamed to tests/test_sorting.py

@@ -1,17 +1,19 @@
 import unittest
 import random
 
-from pygorithm.sorting import (bubble_sort,
-                                insertion_sort,
-                                selection_sort,
-                                merge_sort,
-                                quick_sort,
-                                counting_sort,
-                                bucket_sort,
-                                shell_sort,
-                                heap_sort)
-
-class SortingAlgorithmTests(unittest.TestCase):
+from pygorithm.sorting import (
+    bubble_sort,
+    insertion_sort,
+    selection_sort,
+    merge_sort,
+    quick_sort,
+    counting_sort,
+    bucket_sort,
+    shell_sort,
+    heap_sort)
+
+
+class TestSortingAlgorithm(unittest.TestCase):
     def setUp(self):
         # to test numeric numbers
         self.array = list(range(15))
@@ -24,69 +26,78 @@ def setUp(self):
         random.shuffle(self.alphaArray)
         self.sorted_alpha_array = sorted(string)
 
-class BubbleSortTest(SortingAlgorithmTests):
+
+class TestBubbleSortTest(TestSortingAlgorithm):
     def test_bubble_sort(self):
         self.result = bubble_sort.sort(self.array)
         self.assertEqual(self.result, self.sorted_array)
 
         self.alphaResult = bubble_sort.sort(self.alphaArray)
         self.assertEqual(self.alphaResult, self.sorted_alpha_array)
 
-class InsertionSortTest(SortingAlgorithmTests):
+
+class TestInsertionSortTest(TestSortingAlgorithm):
     def test_insertion_sort(self):
         self.result = insertion_sort.sort(self.array)
         self.assertEqual(self.result, self.sorted_array)
 
         self.alphaResult = insertion_sort.sort(self.alphaArray)
         self.assertEqual(self.alphaResult, self.sorted_alpha_array)
 
-class SelectionSortTest(SortingAlgorithmTests):
+
+class TestSelectionSortTest(TestSortingAlgorithm):
     def test_selection_sort(self):
         self.result = selection_sort.sort(self.array)
         self.assertEqual(self.result, self.sorted_array)
 
         self.alphaResult = selection_sort.sort(self.alphaArray)
         self.assertEqual(self.alphaResult, self.sorted_alpha_array)
 
-class MergeSortTest(SortingAlgorithmTests):
+
+class TestMergeSortTest(TestSortingAlgorithm):
     def test_merge_sort(self):
         self.result = merge_sort.sort(self.array)
         self.assertEqual(self.result, self.sorted_array)
 
         self.alphaResult = merge_sort.sort(self.alphaArray)
         self.assertEqual(self.alphaResult, self.sorted_alpha_array)
 
-class QuickSortTest(SortingAlgorithmTests):
+
+class TestQuickSortTest(TestSortingAlgorithm):
     def test_quick_sort(self):
         self.result = quick_sort.sort(self.array)
         self.assertEqual(self.result, self.sorted_array)
 
         self.alphaResult = quick_sort.sort(self.alphaArray)
         self.assertEqual(self.alphaResult, self.sorted_alpha_array)
 
-class CountingSortTest(SortingAlgorithmTests):
+
+class TestCountingSortTest(TestSortingAlgorithm):
     def test_counting_sort(self):
         # counting sort is an integer based sort
         self.result = counting_sort.sort(self.array)
         self.assertEqual(self.result, self.sorted_array)
 
-class BucketSortTest(SortingAlgorithmTests):
+
+class TestBucketSortTest(TestSortingAlgorithm):
     def test_bucket_sort(self):
         self.result = bucket_sort.sort(self.array)
         self.assertEqual(self.result, self.sorted_array)
 
         self.alphaResult = bucket_sort.sort(self.alphaArray)
         self.assertEqual(self.alphaResult, self.sorted_alpha_array)
 
-class ShellSortTest(SortingAlgorithmTests):
+
+class TestShellSortTest(TestSortingAlgorithm):
     def test_shell_sort(self):
         self.result = shell_sort.sort(self.array)
         self.assertEqual(self.result, self.sorted_array)
 
         self.alphaResult = shell_sort.sort(self.alphaArray)
         self.assertEqual(self.alphaResult, self.sorted_alpha_array)
 
-class HeapSortTest(SortingAlgorithmTests):
+
+class TestHeapSortTest(TestSortingAlgorithm):
     def test_heap_sort(self):
         self.result = heap_sort.sort(self.array)
         self.assertEqual(self.result, self.sorted_array)