From 823fdbc3074a64de3b42132af47e63207f64d9d1 Mon Sep 17 00:00:00 2001
From: Richard Feistenauer <richard.feistenauer@gmx.de>
Date: Sat, 9 Feb 2019 18:16:19 +0100
Subject: [PATCH] some more tests and improvements

---
 performance.txt                              |   8 ++-
 scripts/main_ui.py                           |   5 +-
 scripts/performance_test                     | Bin 0 -> 3861 bytes
 src/cellular_automaton/__init__.py           |   7 +++
 src/cellular_automaton/ca_cell.py            |  22 +++----
 src/cellular_automaton/ca_display.py         |   8 ++-
 src/cellular_automaton/ca_factory.py         |  60 ++++++-------------
 src/cellular_automaton/cellular_automaton.py |   3 +-
 test/test_factory.py                         |  50 ++++++++++++++++
 test/test_neighborhood.py                    |   5 +-
 10 files changed, 104 insertions(+), 64 deletions(-)
 create mode 100644 scripts/performance_test
 create mode 100644 test/test_factory.py

diff --git a/performance.txt b/performance.txt
index 3bf28aa..c9fec8b 100644
--- a/performance.txt
+++ b/performance.txt
@@ -8,4 +8,10 @@ TOTAL TIME: 0.1171s   	# Only set on change
 SIZE: 21.7525MB			# process size 51,4 / main(75,9)
 
 TOTAL TIME: 0.1161s
-SIZE: 20.3338MB         # removed grid
\ No newline at end of file
+SIZE: 20.3338MB         # removed grid
+
+TOTAL TIME: 0.1792s 	# probably wrong calculated (asizeof was in there)
+SIZE: 20.2575MB			# Factory instead of grid
+
+TOTAL TIME: 0.1152s		# dict instead of list for cells
+SIZE: 20.2575MB			# process size 53 / 75,8
\ No newline at end of file
diff --git a/scripts/main_ui.py b/scripts/main_ui.py
index 80c85a3..a01e5cc 100644
--- a/scripts/main_ui.py
+++ b/scripts/main_ui.py
@@ -4,7 +4,7 @@ from cellular_automaton.ca_cell_state import CellState
 from cellular_automaton.ca_rule import Rule
 
 from cellular_automaton.cellular_automaton import CellularAutomaton, CellularAutomatonProcessor
-from cellular_automaton.ca_factory import Factory
+from cellular_automaton.ca_factory import CAFactory
 
 
 class TestRule(Rule):
@@ -35,8 +35,7 @@ class MyState(CellState):
 
 
 def make_cellular_automaton(dimension, neighborhood, rule, state_class):
-    ca_factory = Factory()
-    cells = ca_factory.make_cellular_automaton(dimension=dimension, neighborhood=neighborhood, state_class=state_class)
+    cells = CAFactory.make_cellular_automaton(dimension=dimension, neighborhood=neighborhood, state_class=state_class)
     return CellularAutomaton(cells, dimension, rule)
 
 
diff --git a/scripts/performance_test b/scripts/performance_test
new file mode 100644
index 0000000000000000000000000000000000000000..112495e103f620ce1aa9a7d2fc78540540b2e869
GIT binary patch
literal 3861
zcmbtXTWl0n7%rCHZK=quV(D@zwX|I;HP(<iqZ9}V7`zn0Y%-bdo*qWd&MaqUd$GpG
z*hH+vKBzASMTtg@M(_dSLx}+s0whLjFu`*15-%*&rb$&~YsCM|?3|r5vn3?<;q-Lo
zoB#X%bN*YW>+{oF+Sf!nOhnB{CrKiOBy~0NKq9eDwbaOFBdU_fR%&3X#?8pqK5M6;
zXMVM`Hnpsd5Un#}?W9PJX*v!k`ch}|^76)t6-CoEOHt|zQl;>K&V~gK#u`g^3@(!S
zrvHO{It$)tQ?Sx}*wxRrp)=r{>m7V*5};!xih^_tQO4r=s-$Y;)jiwJNO<t{%2|JH
z%#%6Gf}7y0**&Ue2{eHZIL#EJ0bfwB<BNyo^?$23ow{^c!lf^+ovd9vDfQE0zy1J*
z8@|d6mn#$zq?$-E)ozsAhgCmM?JFDjUgAC!vy&?EGjSJOJZJicF;yyRbazst2pCPv
zpt;B{N_e>7$7oU6AK*$wZUPU66I^2iC5mP$MvsnSf*Vil8J+)9<pl{(ZTPP3WO*u=
z<p9RDtYuyGUT?$XN26ceJzvH{Pw#po^vj5x<KP1rZZjKbUYpMG{Vier)S8pORoAkR
zNpJt(c@a+%OG{8AicAx-Ba$!-0x6>PKpY06Js^UMo`yRgD})m^ktLk(@dMLeJowBd
z3A>wqNRWAOA=&^7^#YcbeL}3eK>h_MVaeeHmiJ^nIk&#;;Z&uJ3l3KuL*sDTF2f5P
z?@ieN9_*({j+0zxM3ZqyUnnY0b&1<2WEU8v$DkypV5B3eLbygu8jVB|AxWZAMNL{p
z93JaA9<c(nm<417>NZF>QhF6jiz5@t5UVrvHdwF|aT5~m7~g*WLh}*k(^zqvX;F|M
z*%<gUZp4xVNpO1XqZz(rr?(JZr)ppsD|ASOE4pXj+#_#oSS{ld_vP)FxYH)HKcS15
z*(z9s3ku*F1#`)faXZ5ocqCoivah2sJPIMOmcF+9F57;3*0U+V<)v%dI+Gf)nlwEW
zM^L(BA^UGlH^ZnGMMdWVmKd`gOhqjI^5bek@T}qSiC5llFOqR%L;Gj%ReL<EW^$J>
zrQXm8;JN)CX1`Pc0!20Z^r%1+fAaos9@<eYXL57BUCy~Iy39`#z-MV##M({98{rLm
zcg?v{n=j*w!^b}VHnA!j;qP#~;D#U1?X#St3z#0S{lUhAFP9z|m+-r|qkh%!v|Y+=
z{X>8s%g2z@Ui$$&x1Y^8uYKNR{wybp*8k4xVXgm60vK+SX`n0pnt3Vuvh_{#`AKGT
zh2LfX!)<2I&8u_%!A(c!Jqn3Xa;5R@fgw42kL>#Ca=-lmp4n$<MnkZqo7*xGU8g1z
zNRQQpjIK~!)F1>!EzN)kkD=X31dltPf+wbw<5EUoMzC*ZBv)f{UvbP#0%Dq}b`nMf
z3KU{O#qSD3RqN6SqJn^IB>@-gAM9@WMeB`O_ngk1vF?moVPZsgc`c{z06Vk+7W~u4
zefO?7KO*xDtJrq&o5L`bun6(yP7K)HxbRyTe6Anv%m}C5Vd1otnH5qjq-i58c=*Gn
z%5CRBfxDT>waoZ)eb+oQSKvmtYd16Ua=+F9UKA4MXUqr58<yhq(X`un(-N0b$fOkc
zr3CPzlqRnfd)T~TB~IBsDq(lSmDq!KnO}(u<9Ja?U7%$snV3@vM4f8Ee+UqKES=b8
zJ2&oh)CxJ%S}UMl1SZHsU+*m%YJq{--OvKRG~OZHjVNttKpO96F|8Z=wV2}$&smr7
zEaZ5dpD}<D80k`m_jcRR<xdZ9+`mx9&mG#2%UYr52_K}F%`9=JYO0n+MU9(>Uk#sV
z{#C;6CWl7%6~~B_OJ=4dNN04cEI75{T20y9<J~_<*xhit>tIB>>x>jS>a|4o_(<Vy
z`suCyD{x<B;&D_G`LaoxNLrbsfV!SU;m5Rif}ls(9-il_@@~h?w%%X_1Tf9b{{fI9
BV37a-

literal 0
HcmV?d00001

diff --git a/src/cellular_automaton/__init__.py b/src/cellular_automaton/__init__.py
index e69de29..0f1e175 100644
--- a/src/cellular_automaton/__init__.py
+++ b/src/cellular_automaton/__init__.py
@@ -0,0 +1,7 @@
+from .ca_cell import *
+from .ca_cell_state import *
+from .ca_display import *
+from .ca_factory import *
+from .ca_neighborhood import *
+from .ca_rule import *
+from .cellular_automaton import *
diff --git a/src/cellular_automaton/ca_cell.py b/src/cellular_automaton/ca_cell.py
index 53f1e82..b072e14 100644
--- a/src/cellular_automaton/ca_cell.py
+++ b/src/cellular_automaton/ca_cell.py
@@ -3,34 +3,34 @@ from typing import Type
 
 
 class Cell:
-    def __init__(self, state_class: Type[CellState], coordinate: list):
+    def __init__(self, state_class: Type[CellState], coordinate):
         self._coordinate = coordinate
-        self._state = state_class()
-        self._neighbours = []
+        self.state = state_class()
+        self.neighbours = []
 
     def set_neighbours(self, neighbours):
-        self._neighbours = neighbours
+        self.neighbours = neighbours
 
     def get_state(self):
-        return self._state
+        return self.state
 
     def get_coordinate(self):
         return self._coordinate
 
     def evolve_if_ready(self, rule, iteration):
-        if self._state.is_active(iteration):
-            new_state = rule(self._state.get_state_of_last_iteration(iteration), self.get_neighbour_states(iteration))
+        if self.state.is_active(iteration):
+            new_state = rule(self.state.get_state_of_last_iteration(iteration), self.get_neighbour_states(iteration))
             self.set_new_state_and_activate(new_state, iteration)
 
     def get_neighbour_states(self, index):
-        return [n.get_state_of_last_iteration(index) for n in self._neighbours]
+        return [n.get_state_of_last_iteration(index) for n in self.neighbours]
 
     def set_new_state_and_activate(self, new_state: CellState, iteration):
-        changed = self._state.set_state_of_iteration(new_state, iteration)
+        changed = self.state.set_state_of_iteration(new_state, iteration)
         if changed:
             self._set_active_for_next_iteration(iteration)
 
     def _set_active_for_next_iteration(self, iteration):
-        self._state.set_active_for_next_iteration(iteration)
-        for n in self._neighbours:
+        self.state.set_active_for_next_iteration(iteration)
+        for n in self.neighbours:
             n.set_active_for_next_iteration(iteration)
diff --git a/src/cellular_automaton/ca_display.py b/src/cellular_automaton/ca_display.py
index 77de284..84d01cb 100644
--- a/src/cellular_automaton/ca_display.py
+++ b/src/cellular_automaton/ca_display.py
@@ -60,11 +60,12 @@ class PyGameFor2D:
         running = True
         cellular_automaton_processor.evolve()
         first = True
+
         while running:
             pygame.event.get()
             time_ca_start = time.time()
             if first:
-                self._evolve_with_performance(cellular_automaton_processor, time_ca_start)
+                self._evolve_with_performance(cellular_automaton_processor)
                 first = False
             else:
                 cellular_automaton_processor.evolve()
@@ -73,9 +74,11 @@ class PyGameFor2D:
             time_ds_end = time.time()
             self._print_process_duration(time_ca_end, time_ca_start, time_ds_end)
 
-    def _evolve_with_performance(self, cap, time_ca_start):
+    def _evolve_with_performance(self, cap):
         size = asizeof.asizeof(self._cellular_automaton)
+        time_ca_start = time.time()
         cProfile.runctx("cap.evolve_x_times(10)", None, locals(), "performance_test")
+        time_ca_end = time.time()
         print("PERFORMANCE")
         p = pstats.Stats('performance_test')
         p.strip_dirs()
@@ -83,7 +86,6 @@ class PyGameFor2D:
         p.sort_stats('cumulative').print_stats(10)
         # sort by time spent in a function
         p.sort_stats('time').print_stats(10)
-        time_ca_end = time.time()
         print("TOTAL TIME: " + "{0:.4f}".format(time_ca_end - time_ca_start) + "s")
         print("SIZE: " + "{0:.4f}".format(size / (1024 * 1024)) + "MB")
 
diff --git a/src/cellular_automaton/ca_factory.py b/src/cellular_automaton/ca_factory.py
index cdec237..d70723d 100644
--- a/src/cellular_automaton/ca_factory.py
+++ b/src/cellular_automaton/ca_factory.py
@@ -1,61 +1,35 @@
 from cellular_automaton.ca_cell import Cell, CellState
 from cellular_automaton.ca_neighborhood import Neighborhood
 from typing import Type
+import itertools
 
 
-class Factory:
-    def __init__(self):
-        self._dimension = None
-        self._state_class = None
-        self._cells = {}
-
-    def make_cellular_automaton(self,
-                                dimension,
+class CAFactory:
+    @staticmethod
+    def make_cellular_automaton(dimension,
                                 neighborhood: Type[Neighborhood],
                                 state_class: Type[CellState]):
-        self._dimension = dimension
-        self._state_class = state_class
 
-        self.__create_cells()
-        self.__set_cell_neighbours(self._cells, neighborhood)
-        return tuple(self._cells.values())
+        cells = CAFactory._make_cells(dimension, state_class)
+        CAFactory._apply_neighbourhood_to_cells(cells, neighborhood, dimension)
+        return tuple(cells.values())
 
-    def __create_cells(self, dimension_index=0, coordinate=None):
-        """ Recursively steps down the dimensions to create cells in n dimensions and adds them to a dict.
-        :param dimension_index:     The index indicating which dimension is currently traversed.
-        :param coordinate:          The coordinate generated so far.
-                                    (each recursion adds one dimension to the coordinate.
-        """
-        coordinate = _instantiate_coordinate_if_necessary(coordinate)
+    @staticmethod
+    def _make_cells(dimension, state_class):
+        cells = {}
+        for c in itertools.product(*[range(d) for d in dimension]):
+            coordinate_string = _join_coordinate(c)
+            cells[coordinate_string] = Cell(state_class, c)
+        return cells
 
-        try:
-            self.__recursive_step_down_dimensions(coordinate, dimension_index)
-        except IndexError:
-            coordinate_string = _join_coordinate(coordinate)
-            self._cells[coordinate_string] = Cell(self._state_class, coordinate)
-
-    def __recursive_step_down_dimensions(self, coordinate, dimension_index):
-        """ For the range of the current dimension, recalls the recursion method.
-        :param coordinate:          The coordinate so far.
-        :param dimension_index:     The current dimension lvl.
-        """
-        for cell_index in range(self._dimension[dimension_index]):
-            new_cod = coordinate + [cell_index]
-            self.__create_cells(dimension_index + 1, new_cod)
-
-    def __set_cell_neighbours(self, cells, neighborhood):
+    @staticmethod
+    def _apply_neighbourhood_to_cells(cells, neighborhood, dimension):
         for cell in cells.values():
             n_coordinates = neighborhood.calculate_cell_neighbor_coordinates(cell.get_coordinate(),
-                                                                             self._dimension)
+                                                                             dimension)
             cell.set_neighbours([cells[_join_coordinate(coordinate)].get_state() for coordinate in n_coordinates])
 
 
-def _instantiate_coordinate_if_necessary(coordinate):
-    if coordinate is None:
-        coordinate = []
-    return coordinate
-
-
 def _join_coordinate(coordinate):
     return '-'.join(str(x) for x in coordinate)
 
diff --git a/src/cellular_automaton/cellular_automaton.py b/src/cellular_automaton/cellular_automaton.py
index 11eca46..f7bf9c7 100644
--- a/src/cellular_automaton/cellular_automaton.py
+++ b/src/cellular_automaton/cellular_automaton.py
@@ -14,10 +14,11 @@ class CellularAutomaton:
 class CellularAutomatonProcessor:
     def __init__(self, cellular_automaton, process_count: int = 1):
         self.ca = cellular_automaton
+        cells = {i: self.ca.cells[i] for i in range(len(self.ca.cells))}
         self.evolve_range = range(len(self.ca.cells))
         self.pool = multiprocessing.Pool(processes=process_count,
                                          initializer=_init_process,
-                                         initargs=(self.ca.cells,
+                                         initargs=(cells,
                                                    self.ca.evolution_rule,
                                                    self.ca.evolution_iteration_index))
         for cell in self.ca.cells:
diff --git a/test/test_factory.py b/test/test_factory.py
new file mode 100644
index 0000000..30b8083
--- /dev/null
+++ b/test/test_factory.py
@@ -0,0 +1,50 @@
+import sys
+sys.path.append('../src')
+
+from cellular_automaton import *
+import unittest
+import mock
+
+
+class TestFac(CAFactory):
+    @staticmethod
+    def make_cells(dimension, state_class):
+        return CAFactory._make_cells(dimension, state_class)
+
+    @staticmethod
+    def apply_neighbourhood(cells, neighborhood, dimension):
+        return CAFactory._apply_neighbourhood_to_cells(cells, neighborhood, dimension)
+
+
+class TestCAFactory(unittest.TestCase):
+    def test_make_ca_calls_correct_methods(self):
+        with mock.patch.object(CAFactory, '_make_cells', return_value={1: True}) as m1:
+            with mock.patch.object(CAFactory, '_apply_neighbourhood_to_cells') as m2:
+                CAFactory.make_cellular_automaton([10], Neighborhood, CellState)
+                m1.assert_called_once_with([10], CellState)
+                m2.assert_called_once_with({1: True}, Neighborhood, [10])
+
+    def test_make_ca_returns_correct_values(self):
+        with mock.patch.object(CAFactory, '_make_cells', return_value={1: True}):
+            with mock.patch.object(CAFactory, '_apply_neighbourhood_to_cells'):
+                cells = CAFactory.make_cellular_automaton([10], Neighborhood, CellState)
+                self.assertEqual(cells, (True, ))
+
+    def test_1dimension_coordinates(self):
+        fac = TestFac()
+        c = fac.make_cells([3], CellState)
+        self.assertEqual(list(c.keys()), ['0', '1', '2'])
+
+    def test_2dimension_coordinates(self):
+        fac = TestFac()
+        c = fac.make_cells([2, 2], CellState)
+        self.assertEqual(list(c.keys()), ['0-0', '0-1', '1-0', '1-1'])
+
+    def test_3dimension_coordinates(self):
+        fac = TestFac()
+        c = fac.make_cells([2, 2, 2], CellState)
+        self.assertEqual(list(c.keys()), ['0-0-0', '0-0-1', '0-1-0', '0-1-1', '1-0-0', '1-0-1', '1-1-0', '1-1-1'])
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test/test_neighborhood.py b/test/test_neighborhood.py
index 06bcd9e..6a95dfc 100644
--- a/test/test_neighborhood.py
+++ b/test/test_neighborhood.py
@@ -5,8 +5,9 @@ import cellular_automaton.ca_neighborhood as csn
 import unittest
 
 
-class TestCellState(unittest.TestCase):
-    def check_neighbors(self, neighborhood, neighborhood_sets):
+class TestNeighborhood(unittest.TestCase):
+    @staticmethod
+    def check_neighbors(neighborhood, neighborhood_sets):
         for neighborhood_set in neighborhood_sets:
             neighbors = neighborhood.calculate_cell_neighbor_coordinates(neighborhood_set[0], [3, 3])
             if neighborhood_set[1] != neighbors: