v0.0.9.8.4

Fix test_all and pytest.fixture

bigO/BigO.py

@@ -469,7 +469,7 @@ class BigO:
 
         print(f"Running {function.__name__}(tests)")
         for test in result:
-            cplx, _ = self.test(function, test, prtResult=False)
+            cplx = self.test(function, test, prtResult=False)
             result[test] = cplx
             cplxInt = self._complexity2int(cplx)
 

bigO/__init__.py

@@ -6,4 +6,4 @@ __all__ = [
     "utils",
 ]
 
-__version__ = "0.0.9.8.3"
+__version__ = "0.0.9.8.4"

bigO/version.py

-__version__ = "0.0.9.8.3"
+__version__ = "0.0.9.8.4"

tests/test_array.py

+import pytest
+
+
+@pytest.fixture
+def BigO():
     from bigO import BigO
 
+    lib = BigO()
+    return lib
 
-def test_gen():
-    gen = BigO()
-    print(gen.genRandomArray(20))
-    print(gen.genRandomString(5, 20))
-    print(gen.genSortedArray(20))
-    print(gen.genReversedArray(20))
-    print(gen.genPartialArray(20))
-    print(gen.genKsortedArray(20, 6))
+
+def test_BigO(BigO):
+    print(BigO.genRandomArray(20))
+    print(BigO.genRandomString(5, 20))
+    print(BigO.genSortedArray(20))
+    print(BigO.genReversedArray(20))
+    print(BigO.genPartialArray(20))
+    print(BigO.genKsortedArray(20, 6))
 
     for i in range(21):
-        arr = gen.genKsortedArray(20, i)
+        arr = BigO.genKsortedArray(20, i)
         assert isKSortedArray(arr, i) == True
 
-    print(gen.genAlmostEqualArray(9))
-    print(gen.genAlmostEqualArray(20))
-    print(gen.genEqualArray(20))
-    print(gen.genHoleArray(20))
-    print(gen.genRandomBigArray(20))
-
+    print(BigO.genAlmostEqualArray(9))
+    print(BigO.genAlmostEqualArray(20))
+    print(BigO.genEqualArray(20))
+    print(BigO.genHoleArray(20))
+    print(BigO.genRandomBigArray(20))
 
-def test_Ksorted():
-    gen = BigO()
 
-    arr = gen.genKsortedArray(9, 1)
+def test_Ksorted(BigO):
+    arr = BigO.genKsortedArray(9, 1)
     assert isKSortedArray(arr, 1) == True
 
-    arr = gen.genKsortedArray(100, 9)
+    arr = BigO.genKsortedArray(100, 9)
     assert isKSortedArray(arr, 9) == True
 
-    arr = gen.genKsortedArray(9, 9)
+    arr = BigO.genKsortedArray(9, 9)
     assert isKSortedArray(arr, 9) == True
 
-    arr = gen.genKsortedArray(10, 5)
+    arr = BigO.genKsortedArray(10, 5)
     assert isKSortedArray(arr, 5) == True
 
-    arr = gen.genKsortedArray(1000, 100)
+    arr = BigO.genKsortedArray(1000, 100)
     assert isKSortedArray(arr, 100) == True
 
 

tests/test_bigO.py

-from bigO import BigO
+import pytest
+
 
+@pytest.fixture
+def BigO():
+    from bigO import BigO
 
-def test_cplx():
     lib = BigO()
-    assert lib._complexity2str(0) == "f(n)"
-    assert lib._complexity2str(2) == "O(n)"
-    assert lib._complexity2str(5) == "O(n^2)"
+    return lib
 
 
-def test_fitting():
-    lib = BigO()
-    assert lib._fittingCurve(1)(100) == 1.0
-    assert lib._fittingCurve(5)(2) == 4  # O(n^2)
-    assert lib._fittingCurve(6)(2) == 8  # O(n^3)
+def test_cplx(BigO):
+    assert BigO._complexity2str(0) == "f(n)"
+    assert BigO._complexity2str(2) == "O(n)"
+    assert BigO._complexity2str(5) == "O(n^2)"
 
 
-def test_estimate():
-    lib = BigO()
+def test_fitting(BigO):
+    assert BigO._fittingCurve(1)(100) == 1.0
+    assert BigO._fittingCurve(5)(2) == 4  # O(n^2)
+    assert BigO._fittingCurve(6)(2) == 8  # O(n^3)
+
+
+def test_estimate(BigO):
     n = [10, 100, 1000, 10000]
     times = [
         3.959999999736397e-06,
@@ -24,5 +29,5 @@ def test_estimate():
         0.015288159999999884,
         1.62602698,
     ]
-    result = lib._estimate(n, times)
+    result = BigO._estimate(n, times)
     assert result._to_str() == "O(n^2)", "Estimation is wrong."

tests/test_compare.py

-from bigO import BigO
+import pytest
 from bigO import algorithm
 
 
-def test_run():
+@pytest.fixture
+def BigO():
+    from bigO import BigO
+
     lib = BigO()
+    return lib
+
 
-    result = lib.compare(algorithm.bubbleSort, algorithm.insertSort, "reversed", 5000)
-    result = lib.compare(
+def test_run(BigO):
+    result = BigO.compare(algorithm.bubbleSort, algorithm.insertSort, "reversed", 5000)
+    result = BigO.compare(
         algorithm.insertSort, algorithm.insertSortOptimized, "reversed", 5000
     )
-    result = lib.compare(
+    result = BigO.compare(
         algorithm.quickSort, algorithm.quickSortHoare, "reversed", 50000
     )
-    result = lib.compare(algorithm.timSort, algorithm.introSort, "reversed", 50000)
-    result = lib.compare(sorted, algorithm.introSort, "reversed", 50000)
+    result = BigO.compare(algorithm.timSort, algorithm.introSort, "reversed", 50000)
+    result = BigO.compare(sorted, algorithm.introSort, "reversed", 50000)
 
-    result = lib.compare(algorithm.heapSort, algorithm.heapSort2, "all", 50000)
-    result = lib.compare(algorithm.introSort, algorithm.quickSortHeap, "all", 50000)
+    result = BigO.compare(algorithm.heapSort, algorithm.heapSort2, "all", 50000)
+    result = BigO.compare(algorithm.introSort, algorithm.quickSortHeap, "all", 50000)
 
 
-def test_quickcomp():
-    lib = BigO()
-
+def test_quickcomp(BigO):
     # Hoare + Tail recur should be faster than random pivot choosing recursive one
-    result = lib.compare(algorithm.quickSort, algorithm.quickSortHoare, "random", 50000)
-    result = lib.compare(
+    result = BigO.compare(
+        algorithm.quickSort, algorithm.quickSortHoare, "random", 50000
+    )
+    result = BigO.compare(
         algorithm.quickSortHoare, algorithm.quickSortHeap, "random", 50000
     )
 
-    result = lib.compare(
+    result = BigO.compare(
         algorithm.quickSort, algorithm.quickSortHoare, "reversed", 50000
     )
-    result = lib.compare(
+    result = BigO.compare(
         algorithm.quickSortHoare, algorithm.quickSortHeap, "reversed", 50000
     )
 
-    result = lib.compare(algorithm.quickSort, algorithm.quickSortHoare, "sorted", 50000)
-    result = lib.compare(
+    result = BigO.compare(
+        algorithm.quickSort, algorithm.quickSortHoare, "sorted", 50000
+    )
+    result = BigO.compare(
         algorithm.quickSortHoare, algorithm.quickSortHeap, "sorted", 50000
     )
 
-    result = lib.compare(
+    result = BigO.compare(
         algorithm.quickSort, algorithm.quickSortHoare, "partial", 50000
     )
-    result = lib.compare(
+    result = BigO.compare(
         algorithm.quickSortHoare, algorithm.quickSortHeap, "partial", 50000
     )
 
-    result = lib.compare(
+    result = BigO.compare(
         algorithm.quickSort, algorithm.quickSortHoare, "Ksorted", 50000
     )
-    result = lib.compare(
+    result = BigO.compare(
         algorithm.quickSortHoare, algorithm.quickSortHeap, "Ksorted", 50000
     )
 
     print(result)
 
 
-def test_go():
-    lib = BigO()
-
-    lib.compare(algorithm.goSort, algorithm.introSort, "random", 100000)
-    lib.compare(algorithm.goSort, algorithm.quickSortHoare, "random", 10000)
+def test_go(BigO):
+    BigO.compare(algorithm.goSort, algorithm.introSort, "random", 100000)
+    BigO.compare(algorithm.goSort, algorithm.quickSortHoare, "random", 10000)
 
-    lib.compare(algorithm.goSort, algorithm.heapSort, "random", 10000)
-    lib.compare(algorithm.goSort, algorithm.timSort, "random", 10000)
+    BigO.compare(algorithm.goSort, algorithm.heapSort, "random", 10000)
+    BigO.compare(algorithm.goSort, algorithm.timSort, "random", 10000)
 
-    lib.compare(algorithm.goSort, algorithm.quickSortHoare, "Ksorted", 10000)
-    lib.compare(algorithm.goSort, algorithm.quickSortHoare, "Ksorted", 10000)
+    BigO.compare(algorithm.goSort, algorithm.quickSortHoare, "Ksorted", 10000)
+    BigO.compare(algorithm.goSort, algorithm.quickSortHoare, "Ksorted", 10000)
 
 
-def test_mini():
-    lib = BigO()
-
-    lib.compare(algorithm.insertSortOptimized, algorithm.insertSort, "random", 16)
+def test_mini(BigO):
+    BigO.compare(algorithm.insertSortOptimized, algorithm.insertSort, "random", 16)
 
-    lib.compare(algorithm.bubbleSort, algorithm.insertSort, "random", 16)
-    lib.compare(algorithm.insertSort, algorithm.selectionSort, "random", 16)
-    lib.compare(algorithm.bubbleSort, algorithm.selectionSort, "random", 16)
+    BigO.compare(algorithm.bubbleSort, algorithm.insertSort, "random", 16)
+    BigO.compare(algorithm.insertSort, algorithm.selectionSort, "random", 16)
+    BigO.compare(algorithm.bubbleSort, algorithm.selectionSort, "random", 16)
 
-    lib.compare(algorithm.bubbleSort, algorithm.insertSort, "reversed", 16)
-    lib.compare(algorithm.insertSort, algorithm.selectionSort, "reversed", 16)
-    lib.compare(algorithm.bubbleSort, algorithm.selectionSort, "reversed", 16)
+    BigO.compare(algorithm.bubbleSort, algorithm.insertSort, "reversed", 16)
+    BigO.compare(algorithm.insertSort, algorithm.selectionSort, "reversed", 16)
+    BigO.compare(algorithm.bubbleSort, algorithm.selectionSort, "reversed", 16)
 
 
-def test_all():
-    lib = BigO()
-    result = lib.compare(
+def test_all(BigO):
+    result = BigO.compare(
         algorithm.quickSortHoare, algorithm.quickSortHeap, "all", 50000
     )
 
-    result = lib.compare(algorithm.insertSort, algorithm.bubbleSort, "all", 5000)
+    result = BigO.compare(algorithm.insertSort, algorithm.bubbleSort, "all", 5000)
     print(result)
 
-    result = lib.compare(algorithm.quickSortHoare, algorithm.insertSort, "all", 5000)
-
+    result = BigO.compare(algorithm.quickSortHoare, algorithm.insertSort, "all", 5000)
 
-def test_custom():
-    lib = BigO()
-    lib.compare(algorithm.doubleSelectionSort, algorithm.selectionSort, "all", 5000)
 
+def test_custom(BigO):
+    BigO.compare(algorithm.doubleSelectionSort, algorithm.selectionSort, "all", 5000)

tests/test_runtime.py

-from bigO import BigO
+import pytest
 from bigO import algorithm
 
 
-def test_run():
+@pytest.fixture
+def BigO():
+    from bigO import BigO
+
     lib = BigO()
+    return lib
 
-    lib.runtime(sorted, "random", 5000)
-    lib.runtime(algorithm.bubbleSort, "random", 5000)
-    lib.runtime(algorithm.countSort, "random", 5000)
-    lib.runtime(algorithm.binaryInsertSort, "random", 5000)
-    lib.runtime(algorithm.gnomeSort, "random", 5000)
-    lib.runtime(algorithm.heapSort, "random", 5000)
-    lib.runtime(algorithm.insertSort, "random", 5000)
-    lib.runtime(algorithm.insertSortOptimized, "random", 5000)
-    lib.runtime(algorithm.introSort, "random", 5000)
-    lib.runtime(algorithm.mergeSort, "random", 5000)
-    lib.runtime(algorithm.timSort, "random", 5000)
-    lib.runtime(algorithm.selectionSort, "random", 5000)
+
+def test_run(BigO):
+    BigO.runtime(sorted, "random", 5000)
+    BigO.runtime(algorithm.bubbleSort, "random", 5000)
+    BigO.runtime(algorithm.countSort, "random", 5000)
+    BigO.runtime(algorithm.binaryInsertSort, "random", 5000)
+    BigO.runtime(algorithm.gnomeSort, "random", 5000)
+    BigO.runtime(algorithm.heapSort, "random", 5000)
+    BigO.runtime(algorithm.insertSort, "random", 5000)
+    BigO.runtime(algorithm.insertSortOptimized, "random", 5000)
+    BigO.runtime(algorithm.introSort, "random", 5000)
+    BigO.runtime(algorithm.mergeSort, "random", 5000)
+    BigO.runtime(algorithm.timSort, "random", 5000)
+    BigO.runtime(algorithm.selectionSort, "random", 5000)
 
 
 def brokenBubble(array):
@@ -35,41 +41,34 @@ def brokenBubble(array):
     return array
 
 
-def test_custom():
-    lib = BigO()
-
+def test_custom(BigO):
     arr = ["dbc", "bbc", "ccd", "ef", "az"]
-    time, result = lib.runtime(brokenBubble, arr)
+    time, result = BigO.runtime(brokenBubble, arr)
 
     print(time)
     print(result)
 
 
-def test_str_array():
-    lib = BigO()
-
-    time, result = lib.runtime(algorithm.bubbleSort, "string", 10)
+def test_str_array(BigO):
+    time, result = BigO.runtime(algorithm.bubbleSort, "string", 10)
     print(result)
 
-    time, result = lib.runtime(algorithm.introSort, "string", 10)
+    time, result = BigO.runtime(algorithm.introSort, "string", 10)
     print(result)
 
-    time, result = lib.runtime(algorithm.quickSort, "string", 10)
+    time, result = BigO.runtime(algorithm.quickSort, "string", 10)
     print(result)
 
 
-def test_big():
-    lib = BigO()
-    lib.runtime(algorithm.bubbleSort, "random", 5000)
-    lib.runtime(algorithm.bubbleSort, "big", 5000)
+def test_big(BigO):
+    BigO.runtime(algorithm.bubbleSort, "random", 5000)
+    BigO.runtime(algorithm.bubbleSort, "big", 5000)
 
 
-def test_epoch():
-    lib = BigO()
-    lib.runtime(algorithm.quickSort, "random", 5000, 3, True)
-    lib.runtime(algorithm.quickSortHoare, "random", 5000, 3, True)
+def test_epoch(BigO):
+    BigO.runtime(algorithm.quickSort, "random", 5000, 3, True)
+    BigO.runtime(algorithm.quickSortHoare, "random", 5000, 3, True)
 
 
-def test_heap():
-    lib = BigO()
-    lib.runtime(algorithm.heapSort2, "random", 500)
+def test_heap(BigO):
+    BigO.runtime(algorithm.heapSort2, "random", 500)

tests/test_sort.py

+import pytest
 from bigO import algorithm
+
+
+@pytest.fixture
+def BigO():
     from bigO import BigO
-import pytest
+
+    lib = BigO()
+    return lib
 
 
 def empty(array):
@@ -23,9 +30,7 @@ def brokenBubble(array):
     return array
 
 
-def test_none():
-    tester = BigO()
-
+def test_none(BigO):
     def countSort(arr):  # stable
         # Time Complexity : O(n) | Space Complexity : O(n)
         minValue = min(arr)
@@ -43,164 +48,139 @@ def test_none():
                 index += 1
                 buckets[i] -= 1
 
-    _, _ = tester.test(countSort, "random")  # will return a warning
-
+    _, _ = BigO.test(countSort, "random")  # will return a warning
 
-def test_Ksorted():
-    tester = BigO()
 
+def test_Ksorted(BigO):
     # Results may vary, O(n) possible
-    complexity = tester.test(algorithm.introSort, "Ksorted")
-    complexity = tester.test(algorithm.quickSort, "Ksorted")
-    complexity = tester.test(algorithm.timSort, "Ksorted")
-    complexity = tester.test(algorithm.countSort, "Ksorted")
+    complexity = BigO.test(algorithm.introSort, "Ksorted")
+    complexity = BigO.test(algorithm.quickSort, "Ksorted")
+    complexity = BigO.test(algorithm.timSort, "Ksorted")
+    complexity = BigO.test(algorithm.countSort, "Ksorted")
 
 
-def test_empty():
-    big = BigO()
+def test_empty(BigO):
     cplx = big.test(empty, "random")
 
 
 @pytest.mark.timeout(600)
-def test_bubble():
-    tester = BigO()
-
-    complexity = tester.test(algorithm.bubbleSort, "random")
-    # complexity = tester.test(algorithm.bubbleSort, "sorted")
-    # complexity = tester.test(algorithm.bubbleSort, "reversed")
-    # complexity = tester.test(algorithm.bubbleSort, "partial")
-    # complexity = tester.test(algorithm.bubbleSort, "Ksorted")
-    # complexity = tester.test(algorithm.bubbleSort, "almost_equal")
-    # complexity = tester.test(algorithm.bubbleSort, "equal")
-    # complexity = tester.test(algorithm.bubbleSort, "hole")
-
-
-def test_brokenBubble():
-    tester = BigO()
-    _ = tester.test(brokenBubble, "random")
+def test_bubble(BigO):
+    complexity = BigO.test(algorithm.bubbleSort, "random")
+    complexity = BigO.test(algorithm.bubbleSort, "sorted")
+    complexity = BigO.test(algorithm.bubbleSort, "reversed")
+    complexity = BigO.test(algorithm.bubbleSort, "partial")
+    complexity = BigO.test(algorithm.bubbleSort, "Ksorted")
+    complexity = BigO.test(algorithm.bubbleSort, "almost_equal")
+    complexity = BigO.test(algorithm.bubbleSort, "equal")
+    complexity = BigO.test(algorithm.bubbleSort, "hole")
+
+
+def test_brokenBubble(BigO):
+    _ = BigO.test(brokenBubble, "random")
     # will assert at index 0
 
 
-def test_count():
-    tester = BigO()
-
+def test_count(BigO):
     # Results may vary
-    complexity = tester.test(algorithm.countSort, "random")
+    complexity = BigO.test(algorithm.countSort, "random")
     assert complexity == "O(n)"
-    complexity = tester.test(algorithm.countSort, "sorted")
+    complexity = BigO.test(algorithm.countSort, "sorted")
     assert complexity == "O(n)"
-    complexity = tester.test(algorithm.countSort, "reversed")
+    complexity = BigO.test(algorithm.countSort, "reversed")
     assert complexity == "O(n)"
-    complexity = tester.test(algorithm.countSort, "partial")
+    complexity = BigO.test(algorithm.countSort, "partial")
     assert complexity == "O(n)"
-    complexity = tester.test(algorithm.countSort, "Ksorted")
+    complexity = BigO.test(algorithm.countSort, "Ksorted")
     assert complexity == "O(n)"
 
 
 @pytest.mark.timeout(600)
-def test_insertion():
-    tester = BigO()
-
-    complexity = tester.test(algorithm.insertSort, "random")
-    complexity = tester.test(algorithm.insertSort, "sorted")
-    complexity = tester.test(algorithm.insertSort, "reversed")
-    complexity = tester.test(algorithm.insertSort, "partial")
-    complexity = tester.test(algorithm.insertSort, "Ksorted")
-    complexity = tester.test(algorithm.insertSort, "string")
+def test_insertion(BigO):
+    complexity = BigO.test(algorithm.insertSort, "random")
+    complexity = BigO.test(algorithm.insertSort, "sorted")
+    complexity = BigO.test(algorithm.insertSort, "reversed")
+    complexity = BigO.test(algorithm.insertSort, "partial")
+    complexity = BigO.test(algorithm.insertSort, "Ksorted")
+    complexity = BigO.test(algorithm.insertSort, "string")
 
 
-def test_intro():
-    tester = BigO()
-
+def test_intro(BigO):
     # Results may vary, O(n) possible
-    complexity = tester.test(algorithm.introSort, "random")
-    complexity = tester.test(algorithm.introSort, "sorted")
-    complexity = tester.test(algorithm.introSort, "reversed")
-    complexity = tester.test(algorithm.introSort, "partial")
-    complexity = tester.test(algorithm.introSort, "Ksorted")
+    complexity = BigO.test(algorithm.introSort, "random")
+    complexity = BigO.test(algorithm.introSort, "sorted")
+    complexity = BigO.test(algorithm.introSort, "reversed")
+    complexity = BigO.test(algorithm.introSort, "partial")
+    complexity = BigO.test(algorithm.introSort, "Ksorted")
     # median of three won't work on string array
 
 
 @pytest.mark.timeout(600)
-def test_selection():
-    tester = BigO()
-
-    tester.test(algorithm.selectionSort, "random")
-    tester.test(algorithm.selectionSort, "reversed")
-    tester.test(algorithm.selectionSort, "sorted")
-    tester.test(algorithm.selectionSort, "partial")
-    tester.test(algorithm.selectionSort, "Ksorted")
-    tester.test(algorithm.selectionSort, "string")
+def test_selection(BigO):
+    BigO.test(algorithm.selectionSort, "random")
+    BigO.test(algorithm.selectionSort, "reversed")
+    BigO.test(algorithm.selectionSort, "sorted")
+    BigO.test(algorithm.selectionSort, "partial")
+    BigO.test(algorithm.selectionSort, "Ksorted")
+    BigO.test(algorithm.selectionSort, "string")
 
 
-def test_timsort():
-    tester = BigO()
-
+def test_timsort(BigO):
     # Results may vary
-    complexity = tester.test(algorithm.timSort, "random")
-    complexity = tester.test(algorithm.timSort, "sorted")
-    complexity = tester.test(algorithm.timSort, "reversed")
-    complexity = tester.test(algorithm.timSort, "partial")
-    complexity = tester.test(algorithm.timSort, "Ksorted")
-    complexity = tester.test(algorithm.timSort, "hole")
-
-
-def test_heap():
-    tester = BigO()
-    complexity = tester.test(algorithm.heapSort2, "random")
-    complexity = tester.test(algorithm.heapSort2, "sorted")
-    complexity = tester.test(algorithm.heapSort2, "reversed")
-    complexity = tester.test(algorithm.heapSort2, "partial")
-    complexity = tester.test(algorithm.heapSort2, "Ksorted")
-
-
-def test_quickSort():
-    tester = BigO()
-
-    complexity = tester.test(algorithm.quickSort, "random")
-    complexity = tester.test(algorithm.quickSort, "sorted")
-    complexity = tester.test(algorithm.quickSort, "reversed")
-    complexity = tester.test(algorithm.quickSort, "partial")
-    complexity = tester.test(algorithm.quickSort, "Ksorted")
-    complexity = tester.test(algorithm.quickSort, "string")
-
-
-def test_quickSort():
-    tester = BigO()
-
-    complexity = tester.test(algorithm.quickSortHoare, "random")
-    complexity = tester.test(algorithm.quickSortHoare, "sorted")
-    complexity = tester.test(algorithm.quickSortHoare, "reversed")
-    complexity = tester.test(algorithm.quickSortHoare, "partial")
-    complexity = tester.test(algorithm.quickSortHoare, "Ksorted")
-    complexity = tester.test(algorithm.quickSortHoare, "hole")
-    complexity = tester.test(algorithm.quickSortHoare, "equal")
-    complexity = tester.test(algorithm.quickSortHoare, "almost_equal")
-    complexity = tester.test(algorithm.quickSortHoare, "string")
-
-
-def test_sort():
-    lib = BigO()
-
-    lib.test(sorted, "random")
-    lib.test(sorted, "sorted")
-    lib.test(sorted, "reversed")
-    lib.test(sorted, "partial")
-    lib.test(sorted, "Ksorted")
-    lib.test(sorted, "string")
-    lib.test(sorted, "hole")
-    lib.test(sorted, "euqal")
-    lib.test(sorted, "almost_equal")
-
-
-def test_all_cases():
-    lib = BigO()
-
-    lib.test_all(sorted)
-    lib.test_all(algorithm.bubbleSort)
-    lib.test_all(algorithm.insertSort)
-    lib.test_all(algorithm.selectionSort)
-    lib.test_all(algorithm.doubleSelectionSort)
-    lib.test_all(algorithm.timSort)
-    lib.test_all(algorithm.heapSort2)
-    lib.test_all(algorithm.quickSort)
+    complexity = BigO.test(algorithm.timSort, "random")
+    complexity = BigO.test(algorithm.timSort, "sorted")
+    complexity = BigO.test(algorithm.timSort, "reversed")
+    complexity = BigO.test(algorithm.timSort, "partial")
+    complexity = BigO.test(algorithm.timSort, "Ksorted")
+    complexity = BigO.test(algorithm.timSort, "hole")
+
+
+def test_heap(BigO):
+    complexity = BigO.test(algorithm.heapSort2, "random")
+    complexity = BigO.test(algorithm.heapSort2, "sorted")
+    complexity = BigO.test(algorithm.heapSort2, "reversed")
+    complexity = BigO.test(algorithm.heapSort2, "partial")
+    complexity = BigO.test(algorithm.heapSort2, "Ksorted")
+
+
+def test_quickSort(BigO):
+    complexity = BigO.test(algorithm.quickSort, "random")
+    complexity = BigO.test(algorithm.quickSort, "sorted")
+    complexity = BigO.test(algorithm.quickSort, "reversed")
+    complexity = BigO.test(algorithm.quickSort, "partial")
+    complexity = BigO.test(algorithm.quickSort, "Ksorted")
+    complexity = BigO.test(algorithm.quickSort, "string")
+
+
+def test_quickSort(BigO):
+    complexity = BigO.test(algorithm.quickSortHoare, "random")
+    complexity = BigO.test(algorithm.quickSortHoare, "sorted")
+    complexity = BigO.test(algorithm.quickSortHoare, "reversed")
+    complexity = BigO.test(algorithm.quickSortHoare, "partial")
+    complexity = BigO.test(algorithm.quickSortHoare, "Ksorted")
+    complexity = BigO.test(algorithm.quickSortHoare, "hole")
+    complexity = BigO.test(algorithm.quickSortHoare, "equal")
+    complexity = BigO.test(algorithm.quickSortHoare, "almost_equal")
+    complexity = BigO.test(algorithm.quickSortHoare, "string")
+
+
+def test_sort(BigO):
+    BigO.test(sorted, "random")
+    BigO.test(sorted, "sorted")
+    BigO.test(sorted, "reversed")
+    BigO.test(sorted, "partial")
+    BigO.test(sorted, "Ksorted")
+    BigO.test(sorted, "string")
+    BigO.test(sorted, "hole")
+    BigO.test(sorted, "euqal")
+    BigO.test(sorted, "almost_equal")
+
+
+def test_all_cases(BigO):
+    BigO.test_all(sorted)
+    # BigO.test_all(algorithm.bubbleSort)
+    # BigO.test_all(algorithm.insertSort)
+    # BigO.test_all(algorithm.selectionSort)
+    # BigO.test_all(algorithm.doubleSelectionSort)
+    # BigO.test_all(algorithm.timSort)
+    # BigO.test_all(algorithm.heapSort2)
+    # BigO.test_all(algorithm.quickSort)