updated

.coveragerc

@@ -1,5 +1,6 @@
 [report]
 omit =
+    */tests/*
     */python?.?/*
     */site-packages/nose/*
     *__init__*

algorithms/dp/word_break.py

@@ -17,6 +17,14 @@
 """
 
 
+# TC: O(N^2)  SC: O(N)
+branch_coverage = {
+    "check_5": False,  
+    "check_6": False,   
+    "check_7": False,
+    "check_8": False,
+
+}
 # TC: O(N^2)  SC: O(N)
 def word_break(word, word_dict):
     """
@@ -27,15 +35,29 @@ def word_break(word, word_dict):
     dp_array = [False] * (len(word)+1)
     dp_array[0] = True
     for i in range(1, len(word)+1):
+        branch_coverage["check_5"] = True
         for j in range(0, i):
+            branch_coverage["check_6"] = True
             if dp_array[j] and word[j:i] in word_dict:
+                branch_coverage["check_7"] = True
                 dp_array[i] = True
                 break
+            branch_coverage["check_8"] = True
     return dp_array[-1]
 
 
-if __name__ == "__main__":
-    STR = "keonkim"
-    dic = ["keon", "kim"]
+def print_coverage():
+    total = len(branch_coverage)
+    reached = sum(branch_coverage.values())
+    coverage_percentage = (reached / total) * 100
+    for branch, hit in branch_coverage.items():
+        print(f"{branch} was {'hit' if hit else 'not hit'}")
+    print(f"coverage_percentage: {coverage_percentage}%")
+
+
+result = word_break("keonkim", {"keon", "kim"})
+print_coverage()
+
+
+
 
-    print(word_break(str, dic))

algorithms/maths/euler_totient.py

@@ -4,15 +4,37 @@
 which are coprime to n.
 (Two numbers are coprime if their greatest common divisor (GCD) equals 1).
 """
+branch_coverage = {
+    "check_1": False,  # if branch for x > 0
+    "check_2": False,   # else branch
+    "check_2": False,
+    "check_2": False,
+}
 def euler_totient(n):
     """Euler's totient function or Phi function.
     Time Complexity: O(sqrt(n))."""
     result = n
     for i in range(2, int(n ** 0.5) + 1):
+        branch_coverage["check_1"] = True
         if n % i == 0:
+            branch_coverage["check_2"] = True
             while n % i == 0:
+                branch_coverage["check_3"] = True
                 n //= i
             result -= result // i
     if n > 1:
+        branch_coverage["check_4"] = True
         result -= result // n
     return result
+
+def print_coverage():
+    total = len(branch_coverage)
+    reached = sum(branch_coverage.values())
+    coverage_percentage = (reached / total) * 100 
+    for branch, hit in branch_coverage.items():
+        print(f"{branch} was {'hit' if hit else 'not hit'}")
+    print(f"coverage_percentage: {coverage_percentage}%")
+
+
+result = euler_totient(21)
+print_coverage()

algorithms/maths/find_order_simple.py

@@ -11,17 +11,42 @@
 
 import math
 
+branch_coverage = {
+    "branch_6": False,
+    "branch_7": False,
+    "branch_8": False,
+    "branch_9": False,
+    "branch_10": False   
+}
+
 def find_order(a, n):
     """
     Find order for positive integer n and given integer a that satisfies gcd(a, n) = 1.
     """
+
     if (a == 1) & (n == 1):
         # Exception Handeling : 1 is the order of of 1
+        branch_coverage["branch_6"] = True
+        print("branch_6")
         return 1
     if math.gcd(a, n) != 1:
+        branch_coverage["branch_7"] = True
+        print("branch_7")
         print ("a and n should be relative prime!")
         return -1
     for i in range(1, n):
+        branch_coverage["branch_8"] = True
+        print("branch_8")
         if pow(a, i) % n == 1:
+            branch_coverage["branch_9"] = True
+            print("branch_9")
             return i
+    branch_coverage["branch_10"] = True
+    print("branch_10")
     return -1
+
+def print_coverage():
+    for branch, hit in branch_coverage.items():
+        print(f"{branch} was {'hit' if hit else 'not hit'}")
+
+print_coverage()

algorithms/maths/prime_check.py

@@ -1,17 +1,42 @@
+branch_coverage = {
+    "branch_1": False,  # n <= 1
+    "branch_2": False,  # n == 2 or n == 3
+    "branch_3": False,  # n % 2 == 0 or n % 3 == 0
+    "branch_4": False,  # while j * j <= n
+    "branch_5": False   # n % j == 0 or n % (j + 2) == 0
+}
 def prime_check(n):
     """Return True if n is a prime number
     Else return False.
     """
+    print(f"Checking {n}")  # Debugging statement
 
     if n <= 1:
+        branch_coverage["branch_1"] = True
+        print("branch_1")
         return False
+
     if n == 2 or n == 3:
+        branch_coverage["branch_2"] = True
+        print("branch_2")
         return True
     if n % 2 == 0 or n % 3 == 0:
+        branch_coverage["branch_3"] = True
+        print("branch_3")
         return False
     j = 5
     while j * j <= n:
+        branch_coverage["branch_4"] = True
+        print("branch_4")
         if n % j == 0 or n % (j + 2) == 0:
+            branch_coverage["branch_5"] = True
+            print("branch_5")
             return False
         j += 6
     return True
+
+def print_coverage():
+    for branch, hit in branch_coverage.items():
+        print(f"{branch} was {'hit' if hit else 'not hit'}")
+
+print_coverage()

algorithms/maths/pythagoras.py

@@ -2,6 +2,13 @@
 Given the lengths of two of the three sides of a right angled triangle, this function returns the
 length of the third side.
 """
+branch_coverage = {
+    "branch_31": False,
+    "branch_32": False,
+    "branch_33": False,
+    "branch_34": False,
+    "branch_35": False 
+}
 
 def pythagoras(opposite, adjacent, hypotenuse):
     """
@@ -10,11 +17,25 @@ def pythagoras(opposite, adjacent, hypotenuse):
     """
     try:
         if opposite == str("?"):
+            branch_coverage["branch_31"] = True
             return ("Opposite = " + str(((hypotenuse**2) - (adjacent**2))**0.5))
         if adjacent == str("?"):
+            branch_coverage["branch_32"] = True
             return ("Adjacent = " + str(((hypotenuse**2) - (opposite**2))**0.5))
         if hypotenuse == str("?"):
+            branch_coverage["branch_33"] = True
             return ("Hypotenuse = " + str(((opposite**2) + (adjacent**2))**0.5))
+        branch_coverage["branch_34"] = True
         return "You already know the answer!"
     except:
+        branch_coverage["branch_35"] = True
         raise ValueError("invalid argument(s) were given.")
+
+def print_coverage():
+    for branch, hit in branch_coverage.items():
+        print(f"{branch} was {'hit' if hit else 'not hit'}")
+
+pythagoras(3, 2, "?")
+
+print_coverage()
+

algorithms/matrix/rotate_image.py

@@ -7,6 +7,14 @@
 Could you do this in-place?
 """
 
+branch_coverage = {
+    "rotate_matrix_1": False,  # if not branch for mat
+    "rotate_matrix_2": False,  # invisible else branch
+    "rotate_matrix_3": False,  # for branch
+    "rotate_matrix_4": False,  # for branch
+
+}
+
 
 # clockwise rotate
 # first reverse up to down, then swap the symmetry
@@ -16,18 +24,38 @@
 
 def rotate(mat):
     if not mat:
+        branch_coverage["rotate_matrix_1"] = True
         return mat
+
+    branch_coverage["rotate_matrix_2"] = True
+
     mat.reverse()
     for i in range(len(mat)):
+        branch_coverage["rotate_matrix_3"] = True
+
         for j in range(i):
+            branch_coverage["rotate_matrix_4"] = True
+
             mat[i][j], mat[j][i] = mat[j][i], mat[i][j]
     return mat
 
 
-if __name__ == "__main__":
-    mat = [[1, 2, 3],
-           [4, 5, 6],
-           [7, 8, 9]]
-    print(mat)
-    rotate(mat)
-    print(mat)
+def print_coverage():
+    for branch, hit in branch_coverage.items():
+        print(f"{branch} was {'hit' if hit else 'not hit'}")
+        total = len(branch_coverage)
+        hit = sum(branch_coverage.values())
+        result = hit / total * 100
+
+    print("The total branch coverage is:", result, "%")
+
+
+rotate([])
+print_coverage()
+print("\n")
+print_coverage()
+rotate([[1, 2], [3, 4]])
+print("\n")
+print_coverage()
+rotate([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+print("\n")

algorithms/search/interpolation_search.py

@@ -13,6 +13,15 @@
 
 from typing import List
 
+branch_coverage = {
+    "branch_60": False,
+    "branch_61": False,
+    "branch_62": False,
+    "branch_63": False,
+    "branch_64": False,
+
+}
+
 
 def interpolation_search(array: List[int], search_key: int) -> int:
     """
@@ -38,24 +47,36 @@ def interpolation_search(array: List[int], search_key: int) -> int:
 
     while (low <= high) and (array[low] <= search_key <= array[high]):
         # calculate the search position
+        branch_coverage["branch_60"] = True
         pos = low + int(((search_key - array[low]) *
                          (high - low) / (array[high] - array[low])))
 
         # search_key is found
         if array[pos] == search_key:
+            branch_coverage["branch_61"] = True
             return pos
 
         # if search_key is larger, search_key is in upper part
         if array[pos] < search_key:
+            branch_coverage["branch_62"] = True
             low = pos + 1
 
         # if search_key is smaller, search_key is in lower part
         else:
+            branch_coverage["branch_63"] = True
             high = pos - 1
-
+
+    branch_coverage["branch_64"] = True
     return -1
 
+def print_coverage():
+    for branch, hit in branch_coverage.items():
+        print(f"{branch} was {'hit' if hit else 'not hit'}")
+
+
 
 if __name__ == "__main__":
     import doctest
     doctest.testmod()
+print_coverage()
+

algorithms/sort/insertion_sort.py

@@ -1,25 +1,53 @@
+branch_coverage = {
+    "simulation": False,
+    "for": False,
+    "while": False,
+    "simulation-nested": False,
+}
+
 def insertion_sort(arr, simulation=False):
     """ Insertion Sort
         Complexity: O(n^2)
     """
 
     iteration = 0
     if simulation:
+        branch_coverage["simulation"] = True
         print("iteration",iteration,":",*arr)
 
     for i in range(len(arr)):
+        branch_coverage["for"] = True
         cursor = arr[i]
         pos = i
 
         while pos > 0 and arr[pos - 1] > cursor:
+            branch_coverage["while"] = True
             # Swap the number down the list
             arr[pos] = arr[pos - 1]
             pos = pos - 1
         # Break and do the final swap
         arr[pos] = cursor
 
         if simulation:
+                branch_coverage["simulation-nested"] = True
                 iteration = iteration + 1
                 print("iteration",iteration,":",*arr)
 
     return arr
+
+def print_coverage():
+    covered = 0
+    print("branch coverage for `insertion_sort`:")
+    for branch, hit in branch_coverage.items():
+        print(f"{branch} was {'hit' if hit else 'not hit'}")
+        if hit: covered += 1;
+    print(f"Branch coverage: {covered / len(branch_coverage) * 100}")
+
+insertion_sort([])
+insertion_sort([1])
+insertion_sort([69, 420])
+insertion_sort([420, 69])
+insertion_sort([0, 1, 2, 3, 4, 3, 2, 1, 0])
+insertion_sort([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], True)
+insertion_sort([0, 1, 2, 3, 4, 3, 2, 1, 0], True)
+print_coverage()