analyzed new_generation

Author: gustawsi

cellular_automata/conways_game_of_life.py

@@ -21,6 +21,30 @@
 # Define blinker example
 BLINKER = [[0, 1, 0], [0, 1, 0], [0, 1, 0]]
 
+flags = {
+    1: False,
+    2: False,
+    3: False,
+    4: False,
+    5: False,
+    6: False,
+    7: False,
+    8: False,
+    9: False,
+    10: False,
+    11: False,
+    12: False,
+    13: False,
+    14: False,
+    15: False,
+    16: False,
+    17: False,
+    18: False,
+    19: False,
+    20: False,
+    21: False,
+    22: False,
+}
 
 def new_generation(cells: list[list[int]]) -> list[list[int]]:
     """
@@ -29,44 +53,89 @@ def new_generation(cells: list[list[int]]) -> list[list[int]]:
     [[0, 0, 0], [1, 1, 1], [0, 0, 0]]
     """
     next_generation = []
-    for i in range(len(cells)):
+    enter_outer_for = False
+    for i in range(len(cells)): #ID 1
+        flags[1] = True
+        enter_outer_for = True
+
         next_generation_row = []
-        for j in range(len(cells[i])):
+        enter_inner_for = False
+        for j in range(len(cells[i])): #ID 2
             # Get the number of live neighbours
+            flags[2] = True
+            enter_inner_for = True
             neighbour_count = 0
-            if i > 0 and j > 0:
+            if i > 0 and j > 0: #ID 3
+                flags[3] = True
                 neighbour_count += cells[i - 1][j - 1]
-            if i > 0:
+            else: #ID 4
+                flags[4] = True
+
+            if i > 0: #ID 5
+                flags[5] = True
                 neighbour_count += cells[i - 1][j]
-            if i > 0 and j < len(cells[i]) - 1:
+            else: #ID 6
+                flags[6] = True
+
+            if i > 0 and j < len(cells[i]) - 1: #ID 7
+                flags[7] = True
                 neighbour_count += cells[i - 1][j + 1]
-            if j > 0:
+            else: #ID 8
+                flags[8] = True
+
+            if j > 0: #ID 9
+                flags[9] = True
                 neighbour_count += cells[i][j - 1]
-            if j < len(cells[i]) - 1:
+            else: #ID 10
+                flags[10] = True
+
+            if j < len(cells[i]) - 1: #ID 11
+                flags[11] = True
                 neighbour_count += cells[i][j + 1]
-            if i < len(cells) - 1 and j > 0:
+            else: #ID 12
+                flags[12] = True
+
+            if i < len(cells) - 1 and j > 0: #ID 13
+                flags[13] = True
                 neighbour_count += cells[i + 1][j - 1]
-            if i < len(cells) - 1:
+            else: #ID 14
+                flags[14] = True
+
+            if i < len(cells) - 1: #ID 15
+                flags[15] = True
                 neighbour_count += cells[i + 1][j]
-            if i < len(cells) - 1 and j < len(cells[i]) - 1:
+            else: #ID 16
+                flags[16] = True
+
+            if i < len(cells) - 1 and j < len(cells[i]) - 1: #ID 17
+                flags[17] = True
                 neighbour_count += cells[i + 1][j + 1]
+            else: #ID 18
+                flags[18] = True
 
             # Rules of the game of life (excerpt from Wikipedia):
             # 1. Any live cell with two or three live neighbours survives.
             # 2. Any dead cell with three live neighbours becomes a live cell.
             # 3. All other live cells die in the next generation.
             #    Similarly, all other dead cells stay dead.
             alive = cells[i][j] == 1
-            if (
+            if ( #ID 19
                 (alive and 2 <= neighbour_count <= 3)
                 or not alive
                 and neighbour_count == 3
             ):
+                flags[19] = True
                 next_generation_row.append(1)
-            else:
+            else: #ID 20
+                flags[20] = True
                 next_generation_row.append(0)
+        if not enter_inner_for: #id 21 - if did not enter inner for loop
+            flags[21] = True
 
         next_generation.append(next_generation_row)
+    if not enter_outer_for: #ID 22 - if did not enter outer for loop
+        flags[22] = True
+
     return next_generation
 
 
@@ -95,3 +164,13 @@ def generate_images(cells: list[list[int]], frames: int) -> list[Image.Image]:
 if __name__ == "__main__":
     images = generate_images(GLIDER, 16)
     images[0].save("out.gif", save_all=True, append_images=images[1:])
+
+    import doctest
+    doctest.testmod()
+
+    print(flags)
+    sum = 0
+    for i in range(len(flags)):
+        if flags[i+1] == True:
+            sum+=1
+    print ("Branch coverage: " + "{:.2f}".format(sum/len(flags)))