Layers are now arranged as a tree data structure.

1 files changed, 311 insertions, 115 deletions

diff --git a/test_suite.py b/test_suite.py
index e15ddbc..5314f89 100644
--- a/test_suite.py
+++ b/test_suite.py
@@ -14,15 +14,20 @@
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+import test_enumerator
 
 import os
 import sys
 import unittest
 import cairo
+import gtk
+import time
 import ka_debug
 import ka_factory
-import ka_random
+import ka_task
+import model_random
 import ka_extensionpoint
+import ka_incoming
 import model_protozoon
 import model_constraintpool
 import model_population
@@ -33,6 +38,7 @@ import exon_direction
 import exon_position
 
 EPSILON = 0.00001
+_test_task_completed_count = 0
 
 class TestKandidModel(unittest.TestCase):
 
@@ -44,32 +50,118 @@ class TestKandidModel(unittest.TestCase):
 
     def _neutral(self):
         cpool = model_constraintpool.ConstraintPool.get_pool()
-        permitted = [x for x in ka_extensionpoint.list_extensions(exon_position.POSITION_CONSTRAINT) if x not in ['positionconstraint_centered']]
-        cpool.set('/Position', exon_position.POSITION_CONSTRAINT, permitted)
-        cpool.set('/LetterPress/Position', exon_position.POSITION_CONSTRAINT, permitted)
-        cpool.set('/Protozoon/LetterPress/Position', exon_position.POSITION_CONSTRAINT, permitted)
+        permitted = [x for x in ka_extensionpoint.list_extensions(exon_position.POSITION_CONSTRAINT)
+                                  if x not in ['positionconstraint_centered']]
+        cpool.set('/Position',
+                  exon_position.POSITION_CONSTRAINT, permitted)
+        cpool.set('/LetterPress/Position',
+                  exon_position.POSITION_CONSTRAINT, permitted)
+        cpool.set('/Protozoon/LetterPress/Position',
+                  exon_position.POSITION_CONSTRAINT, permitted)
         permitted = ['colorconstraint_none']
-        cpool.set('/Color', exon_color.COLOR_CONSTRAINT, permitted)
-        cpool.set('/Protozoon/Color/', exon_color.COLOR_CONSTRAINT, permitted)
-        cpool.set('/MarkovChainLayer/Color', exon_color.COLOR_CONSTRAINT, permitted)
-        cpool.set('/LetterPress/Color', exon_color.COLOR_CONSTRAINT, permitted)
-        cpool.set('/Protozoon/LetterPress/Color', exon_color.COLOR_CONSTRAINT, permitted)
-        cpool.set('/Protozoon/MarkovChainLayer/Color', exon_color.COLOR_CONSTRAINT, permitted)
-
-        #/Protozoon/mergertypeconstraint ['flip', 'mask', 'rectangulartile', 'straight']
-        permitted = [x for x in ka_factory.get_factory('merger').keys() if x not in ['straight', ]]
-        cpool.set('/Protozoon', model_protozoon.MERGER_CONSTRAINT, permitted)
+        cpool.set('/Color',
+                  exon_color.COLOR_CONSTRAINT, permitted)
+        cpool.set('/Protozoon/Color/',
+                  exon_color.COLOR_CONSTRAINT, permitted)
+        cpool.set('/MarkovChainLayer/Color',
+                  exon_color.COLOR_CONSTRAINT, permitted)
+        cpool.set('/LetterPress/Color',
+                  exon_color.COLOR_CONSTRAINT, permitted)
+        cpool.set('/Protozoon/LetterPress/Color',
+                  exon_color.COLOR_CONSTRAINT, permitted)
+        cpool.set('/Protozoon/MarkovChainLayer/Color',
+                  exon_color.COLOR_CONSTRAINT, permitted)
+
+#        permitted = [x for x in ka_factory.get_factory('merger').keys()
+#                                                  if x not in ['straight', ]]
+#        cpool.set('/Protozoon', model_protozoon.MERGER_CONSTRAINT, permitted)
         
+    def test_task(self):
+        global _test_task_completed_count
+        _test_task_completed_count = 0
+        gtk.gdk.threads_init()
+        ka_task.GeneratorTask(self.task_1, self.on_completed).start()
+        time.sleep(5)
+        self.assertTrue(ka_task.GeneratorTask.is_completed())
+        ka_task.GeneratorTask(self.task_2, self.on_completed).start()
+        time.sleep(5)
+        self.assertTrue(ka_task.GeneratorTask.is_completed())
+        time.sleep(5)
+        self.assertEqual(1, _test_task_completed_count)
+
+    def task_1(self, *args, **kwargs):
+        ka_task.GeneratorTask.leave()
+
+    def task_2(self, *args, **kwargs):
+        raise Exception
+
+    def on_completed(self, *args):
+        global _test_task_completed_count
+        _test_task_completed_count +=1
+
+    def test_merger(self):
+        self._run_ep_breed_test('merger')
+
+    def test_modifier(self):
+        self._run_ep_breed_test('modifier')
+
+    def test_sampler(self):
+        self._run_ep_breed_test('sampler')
+
+    def test_stamp(self):
+        self._run_ep_breed_test('stamp')
+
+    def _run_ep_breed_test(self, key):
+        model_random.set_flurry(9)
+        for flavor in ka_extensionpoint.list_extensions(key):
+            mm1 = ka_extensionpoint.create(flavor, '/')
+            mm1.randomize()
+            mm1.mutate()
+            mm1.swap_places()
+            mm2 = ka_extensionpoint.create(flavor, '/')
+            mm2.randomize()
+            mm2.mutate()
+            mm2.swap_places()
+            mm3 = mm1.crossingover(mm2)
+            mm3.mutate()
+            mm3.swap_places()
+            self.assertFalse(mm3 == mm1 and mm3 == mm2)
+
+    def test_protozon_formater(self):
+        model_random.set_flurry(9)
+        cpool = model_constraintpool.ConstraintPool.get_pool()
+        cpool.clear_all()
+
+        ep_list = ka_extensionpoint.list_extensions('formater')
+        self.assertTrue(len(ep_list) > 0)
+        for ep_key in ep_list:
+            a_protozoon = model_protozoon.Protozoon()
+            a_protozoon.randomize()
+            
+            base_name = 'index'
+            base_folder = '/dev/shm/'
+            formater = ka_extensionpoint.create(ep_key, base_name,
+                                                a_protozoon.get_unique_id(),
+                                                base_folder)
+            a_protozoon.explain(formater)
+
+            file_path = formater.get_pathname('html')
+            formater.write_html_file(file_path)
+            exit_code = os.spawnvp(os.P_WAIT,
+                                   'tidy', ['tidy', '-i', file_path])
+            self.assertEqual(0, exit_code)
+
     def test_locus(self):
-        self.assertEqual('/Locus',  model_locus.Locus('/').path)
-        self.assertEqual('/A/Locus',  model_locus.Locus('/A').path)
+        self.assertEqual('/Locus', model_locus.Locus('/').path)
+        self.assertEqual('/A/Locus', model_locus.Locus('/A').path)
         self.assertEqual('/A', model_locus.Locus('/A').get_trunk())
         self.assertEqual('/A/B', model_locus.Locus('/A/B').get_trunk())
 
     def test_html_formater(self):
         base_name = 'test_html_formater'
         base_folder = '/dev/shm/'
-        formater = ka_extensionpoint.create('formater_html', base_name, 'test', base_folder)
+        formater = ka_extensionpoint.create('formater_html', base_name,
+                                            'test', base_folder)
         formater.header('Test title')
         formater.begin_list('l1')
         a_text = '&<>'
@@ -78,10 +170,10 @@ class TestKandidModel(unittest.TestCase):
         formater.begin_list('l2')
         cpool = model_constraintpool.ConstraintPool.get_pool()
         key = 'color'
-        for cc in ka_extensionpoint.list_extensions(key+'constraint'):
-            cpool.set('/'+key.capitalize(), key+'constraint', [cc])
+        for constraint in ka_extensionpoint.list_extensions(key + 'constraint'):
+            cpool.set('/' + key.capitalize(), key + 'constraint', [constraint])
             a_color = exon_color.Color('/', 0.5, 0.6, 0.7, 0.8)
-            formater.color_item(a_color, 'Color ' + str(cc))
+            formater.color_item(a_color, 'Color ' + str(constraint))
         formater.end_list()
 
         formater.end_list()
@@ -91,27 +183,6 @@ class TestKandidModel(unittest.TestCase):
         exit_code = os.spawnvp(os.P_WAIT, 'tidy', ['tidy', '-i', file_path])
         self.assertEqual(0, exit_code)
 
-    def test_protozon_formater(self):
-        ka_random.set_flurry(9)
-        cpool = model_constraintpool.ConstraintPool.get_pool()
-        cpool.clear_all()
-
-        ep_list = ka_extensionpoint.list_extensions('formater')
-        self.assertTrue(len(ep_list) > 0)
-        for ep_key in ep_list:
-            a_protozoon = model_protozoon.Protozoon()
-            a_protozoon.randomize()
-            
-            base_name = 'index'
-            base_folder = '/dev/shm/'
-            formater = ka_extensionpoint.create(ep_key, base_name, a_protozoon.get_unique_id(), base_folder)
-            a_protozoon.explain(formater)
-
-            file_path = formater.get_pathname('html')
-            formater.write_html_file(file_path)
-            exit_code = os.spawnvp(os.P_WAIT, 'tidy', ['tidy', '-i', file_path])
-            self.assertEqual(0, exit_code)
-
     def _write_file(self, file_path, page):
         out_file = None
         try:
@@ -131,18 +202,18 @@ class TestKandidModel(unittest.TestCase):
         print cpool
 
     def test_limit(self):
-        self.assertTrue(ka_random.limitate(-0.01) == 0.0)
-        self.assertTrue(ka_random.limitate(0.01) == 0.01)
-        self.assertTrue(ka_random.limitate(1.01) == 1.0)
-        self.assertTrue(ka_random.limitate_range(-0.02, -0.01, 0.01) == -0.01)
-        self.assertTrue(ka_random.limitate_range(0.01, -0.01, 0.01) == 0.01)
-        self.assertTrue(ka_random.limitate_range(0.011, -0.01, 0.01) == 0.01)
-        self.assertTrue(abs(ka_random.cyclic_limitate(-0.01) - 0.99) < EPSILON)
-        self.assertTrue(abs(ka_random.cyclic_limitate(0.01) - 0.01) < EPSILON)
-        self.assertTrue(abs(ka_random.cyclic_limitate(1.01) - 0.01) < EPSILON)
+        self.assertTrue(model_random.limit(-0.01) == 0.0)
+        self.assertTrue(model_random.limit(0.01) == 0.01)
+        self.assertTrue(model_random.limit(1.01) == 1.0)
+        self.assertTrue(model_random.limit_range(-0.02, -0.01, 0.01) == -0.01)
+        self.assertTrue(model_random.limit_range(0.01, -0.01, 0.01) == 0.01)
+        self.assertTrue(model_random.limit_range(0.011, -0.01, 0.01) == 0.01)
+        self.assertTrue(abs(model_random.cyclic_limit(-0.01) - 0.99) < EPSILON)
+        self.assertTrue(abs(model_random.cyclic_limit(0.01) - 0.01) < EPSILON)
+        self.assertTrue(abs(model_random.cyclic_limit(1.01) - 0.01) < EPSILON)
         for value in range(-20, 20):
-            self.assertTrue(0.0 <= ka_random.limitate(0.1 * value) <= 1.0)
-            self.assertTrue(0.0 <= ka_random.cyclic_limitate(0.1 * value) <= 1.0)
+            self.assertTrue(0.0 <= model_random.limit(0.1 * value) <= 1.0)
+            self.assertTrue(0.0 <= model_random.cyclic_limit(0.1*value) <= 1.0)
 
     def test_extensionpoint(self):
 #        ka_extensionpoint.scann()
@@ -162,33 +233,27 @@ class TestKandidModel(unittest.TestCase):
                  exon_direction.Direction('/', 0.1, 0.2), \
                  exon_position.Position('/', 0.1, 0.2), \
                 ]
-        list2 = ka_random.copy_list(list1)
+        list2 = model_random.copy_list(list1)
         self.assertEqual(len(list1), len(list2))
-        for index, i in enumerate(list1):
+        for index, dummy in enumerate(list1):
             self.assertEqual(list1[index], list2[index])
             self.assertTrue(list1[index] is not list2[index])
         
     def test_random(self):
-        ka_random.set_flurry(0)
-        seq = ka_random.crossing_sequence(10)
-        for index in range(1,len(seq)):
+        model_random.set_flurry(0)
+        seq = model_random.crossing_sequence(10)
+        for index in range(1, len(seq)):
             self.assertEqual(seq[0], seq[index])
-        ka_random.set_flurry(9)
-        seq = ka_random.crossingover([11], [21, 22, 23, 24, 25])
-        print seq
-        seq = ka_random.crossingover([11, 12, 13], [21, 22, 23, 24, 25])
-        print seq
-        seq = ka_random.crossingover([11, 12, 13], [21])
-        print seq
+        model_random.set_flurry(9)
 
     def test_positionconstraint(self):
-        self._run_ep_test('position')
+        self._run_ep_constarint_test('position')
 
     def test_directionconstraint(self):
-        self._run_ep_test('direction')
+        self._run_ep_constarint_test('direction')
 
-    def _run_ep_test(self, key):
-        for flavor in ka_extensionpoint.list_extensions(key+'constraint'):
+    def _run_ep_constarint_test(self, key):
+        for flavor in ka_extensionpoint.list_extensions(key + 'constraint'):
             constraint = ka_extensionpoint.create(flavor, '/')
             x_pos, y_pos = 0.1, 0.2
             x_pos, y_pos = constraint.filter(x_pos, y_pos)
@@ -201,30 +266,31 @@ class TestKandidModel(unittest.TestCase):
         population_size = 12
         model = model_population.KandidModel(population_size)
         self.assertEqual(population_size, len(model.fitness))
-        for fa in [1, 2, population_size-1]:
-            model.fade_away = fa
+        for fade in [1, 2, population_size - 1]:
+            model.fade_away = fade
             for i in range(population_size):
-                model.fitness[i] = (population_size-i-1)*(1.0 / population_size)
+                model.fitness[i] = \
+                           (population_size - i - 1) * (1.0 / population_size)
             self._check_classification(population_size, model)
-            for ft in [0.0, 5.0, 9.0]:
+            for fit in [0.0, 5.0, 9.0]:
                 for i in range(population_size):
-                    model.fitness[i] = ft
+                    model.fitness[i] = fit
                 self._check_classification(population_size, model)
 
     def _check_classification(self, population_size, model):
         good, moderate, poor = model.classify()
         print model.fade_away, len(poor)
 #        self.assertEqual(model.fade_away, len(poor))
-        self.assertEqual(population_size, len(good) + len(moderate) + len(poor))
+        self.assertEqual(population_size, len(good)+len(moderate)+len(poor))
         self.assertTrue(good[0] in model.protozoans)
         self.assertFalse(model_population.contains_reference(good[0], moderate))
         self.assertFalse(model_population.contains_reference(good[0], poor))
-        for mo in moderate:
-            self.assertFalse(model_population.contains_reference(mo, poor))
-            self.assertFalse(model_population.contains_reference(mo, good))
-        for po in poor:
-            self.assertFalse(model_population.contains_reference(po, moderate))
-            self.assertFalse(model_population.contains_reference(po, good))
+        for mod in moderate:
+            self.assertFalse(model_population.contains_reference(mod, poor))
+            self.assertFalse(model_population.contains_reference(mod, good))
+        for poo in poor:
+            self.assertFalse(model_population.contains_reference(poo, moderate))
+            self.assertFalse(model_population.contains_reference(poo, good))
 
     def test_exon_position(self):
         self._run_exon_test('position', exon_position.Position, 0.5, 0.5)
@@ -236,44 +302,44 @@ class TestKandidModel(unittest.TestCase):
         self._run_exon_test('buzzword', exon_buzzword.Buzzword, [u'a', u'b'])
             
     def _run_exon_test(self, key, constructor, *params):
-        ka_random.set_flurry(9)
+        model_random.set_flurry(9)
         self._neutral()
         
         cpool = model_constraintpool.ConstraintPool.get_pool()
-        for cc in ka_extensionpoint.list_extensions(key+'constraint'):
-            cpool.set('/'+key.capitalize(), key+'constraint', [cc])
+        for constraint in ka_extensionpoint.list_extensions(key + 'constraint'):
+            cpool.set('/' + key.capitalize(), key + 'constraint', [constraint])
             element1 = constructor('/', *params)
             element2 = element1.copy()
-            for i in range(32):
+            for dummy in range(32):
                 element3 = element1.crossingover(element2)
                 self.assertEqual(element1, element2)
                 self.assertEqual(element1, element3)
             equal = True
-            for i in range(32):
+            for dummy in range(32):
                 element2.randomize()
                 element2.mutate()
-                element2.shuffle()
+                element2.swap_places()
                 equal = equal and element1 == element2
             self.assertFalse(equal)
             self.assertEqual(element1, element3)
             
     def test_exon_color(self):
-        ka_random.set_flurry(9)
+        model_random.set_flurry(9)
         cpool = model_constraintpool.ConstraintPool.get_pool()
         cpool.clear_all()
 
         key = 'color'
         cpool = model_constraintpool.ConstraintPool.get_pool()
 
-        for cc in ka_extensionpoint.list_extensions(key+'constraint'):
-            cpool.set('/'+key.capitalize(), key+'constraint', [cc])
+        for constraint in ka_extensionpoint.list_extensions(key + 'constraint'):
+            cpool.set('/' + key.capitalize(), key + 'constraint', [constraint])
             a_color = exon_color.Color('/', 0.5, 0.5, 0.5, 1.0)
-            self.assertFalse(a_color is a_color.crossingover( \
-                                        exon_color.Color('/', 0.5, 0.5, 0.5, 1.0)))
+            self.assertFalse(a_color is a_color.crossingover(\
+                                    exon_color.Color('/', 0.5, 0.5, 0.5, 1.0)))
             self.assertEqual(4, len(a_color.copy().rgba))
             a_color.randomize()
             self.assertEqual(4, len(a_color.rgba))
-            for i in range(32):
+            for dummy in range(32):
                 a_color.mutate()
             self.assertEqual(4, len(a_color.rgba))
 
@@ -284,18 +350,18 @@ class TestKandidModel(unittest.TestCase):
         self.assertTrue(color2 == color1)
         color1.randomize()
         self.assertFalse(color2 == color1)
-        for i in range(32):
+        for dummy in range(32):
             color3 = color1.crossingover(color2)
             self.assertTrue(color3 is not color1)
             self.assertTrue(color3 is not color2)
             self.assertTrue(color3 == color1 or color3 == color2)
         color4 = color3.copy()
-        eq = True
-        for i in range(32):
+        eql = True
+        for dummy in range(32):
             color4.mutate()
-            color4.shuffle()
-            eq = eq and color4 == color3
-        self.assertFalse(eq)
+            color4.swap_places()
+            eql = eql and color4 == color3
+        self.assertFalse(eql)
         
     def test_layer_factory(self):
         self._neutral()
@@ -308,7 +374,7 @@ class TestKandidModel(unittest.TestCase):
         self.assertTrue(layer_factory.create_random([keys[0]], '/') is not None)
         
     def test_layer(self):
-        ka_random.set_flurry(9)
+        model_random.set_flurry(9)
         self._neutral()
         
         layer_factory = ka_factory.get_factory('layer')
@@ -318,7 +384,7 @@ class TestKandidModel(unittest.TestCase):
             self.assertTrue(layer2 is not layer1)
             self.assertTrue(layer2 == layer1)
             layer1.randomize()
-            layer1.shuffle()
+            layer1.swap_places()
             if layer2 == layer1:
                 pass
             self.assertFalse(layer2 == layer1)
@@ -327,12 +393,12 @@ class TestKandidModel(unittest.TestCase):
             self.assertTrue(layer3 is not layer2)
             layer4 = layer3.copy()
             layer4.mutate()
-            for i in range(32):
-                layer4.shuffle()
+            for dummy in range(32):
+                layer4.swap_places()
 #            self.assertFalse(layer4 == layer3)
 
     def test_protozoon(self):
-        ka_random.set_flurry(9)
+        model_random.set_flurry(9)
         self._neutral()
 
         protozoon1 = model_protozoon.Protozoon()
@@ -343,18 +409,139 @@ class TestKandidModel(unittest.TestCase):
             print protozoon2 == protozoon1
         self.assertTrue(protozoon2 == protozoon1)
         protozoon1.randomize()
-        protozoon1.shuffle()
+        protozoon1.swap_places()
         self.assertFalse(protozoon2 == protozoon1)
         protozoon3 = protozoon1.crossingover(protozoon2)
         self.assertTrue(protozoon3 is not protozoon1)
         self.assertTrue(protozoon3 is not protozoon2)
         protozoon4 = protozoon3.copy()
         protozoon4.mutate()
-        for i in range(32):
-            protozoon4.shuffle()
+        for dummy in range(32):
+            protozoon4.swap_places()
 #        self.assertFalse(protozoon4 == protozoon3)
 
-    def test_render(self):
+    def test_population(self):
+        model = model_population.KandidModel(12)
+        model.set_flurry_rate(9)
+        self.assertEqual(9, model.get_flurry_rate())
+        
+        model.randomize()
+        model.reduce_fitness(0)
+        model.raise_fitness(1)
+        model.raise_fitness(2)
+        self.assertEqual(0.0, model.fitness[0])
+        self.assertEqual(9.0, model.fitness[2])
+        self.assertTrue(model.fitness[1] < model.fitness[2])
+        
+        for fit in range(len(model.fitness)):
+            model.fitness[fit] = 5.0
+        model.fitness[5] = 0.0
+        model.fitness[1] = 0.0
+        model.fitness[3] = 9.0
+        new_indices = model.breed()
+        self.assertTrue(5 in new_indices)
+        self.assertTrue(1 in new_indices)
+
+        model.fitness[7] = 0.0
+        model.fitness[5] = 1.0
+        model.fitness[1] = 1.0
+        protozoon1 = model_protozoon.Protozoon()
+        protozoon1.randomize()
+        self.assertEqual(7, model.replace(protozoon1))
+        
+        stored_model = model_population.to_buffer(model)
+        protozoon2 = model_protozoon.Protozoon()
+        protozoon2.randomize()
+        model.fitness[7] = 0.0
+        model.replace(protozoon2)
+        self.assertEqual(protozoon2.get_unique_id(), 
+                         model.protozoans[7].get_unique_id())
+        model = model_population.from_buffer(stored_model)
+        self.assertEqual(protozoon1.get_unique_id(), 
+                         model.protozoans[7].get_unique_id())
+        
+        ka_debug.dot_start()
+        result = 'digraph persister_objects { rankdir=LR; ranksep="5.0"; node [shape=none,fontname=Sans, fontsize=9, fixedsize=true, height=0.05, width=1.0];\n' 
+        result += model.dot()    
+        result += '\n}'
+        self.assertEqual(0, result.count('=red'))    
+
+    def test_incomming1(self):
+        incoming = ka_incoming.KandidIncoming(3)
+        self.assertEqual(0, len(incoming.incoming_protozoans))
+        protozoon1 = model_protozoon.Protozoon()
+        protozoon1.randomize()
+        incoming.append_protozoon(protozoon1)
+        self.assertEqual(1, len(incoming.incoming_protozoans))
+        self.assertEqual(protozoon1.get_unique_id(), 
+                         incoming.incoming_protozoans[0].get_unique_id())
+        incoming.decline_protozoon(0)
+        self.assertEqual(0, len(incoming.incoming_protozoans))
+
+    def test_incomming3(self):
+        protozoon1 = model_protozoon.Protozoon()
+        protozoon1.randomize()
+        protozoon2 = model_protozoon.Protozoon()
+        protozoon2.randomize()
+        protozoon3 = model_protozoon.Protozoon()
+        protozoon3.randomize()
+
+        capacity = 3
+        incoming = ka_incoming.KandidIncoming(capacity)
+        self.assertEqual(0, len(incoming.incoming_protozoans))
+
+        self.render_incoming(incoming, capacity)
+        incoming.append_protozoon(protozoon1)
+        self.render_incoming(incoming, capacity)
+        incoming.append_protozoon(protozoon2)
+        self.render_incoming(incoming, capacity)
+        incoming.append_protozoon(protozoon3)
+        self.render_incoming(incoming, capacity)
+        self.assertEqual(3, len(incoming.incoming_protozoans))
+        self.assertEqual(protozoon1.get_unique_id(), 
+                         incoming.incoming_protozoans[0].get_unique_id())
+        self.assertEqual(protozoon2.get_unique_id(), 
+                         incoming.incoming_protozoans[1].get_unique_id())
+        self.assertEqual(protozoon3.get_unique_id(), 
+                         incoming.incoming_protozoans[2].get_unique_id())
+        
+        incoming.decline_protozoon(0)
+        self.assertEqual(2, len(incoming.incoming_protozoans))
+        self.assertEqual(protozoon2.get_unique_id(), 
+                         incoming.incoming_protozoans[0].get_unique_id())
+        self.assertEqual(protozoon3.get_unique_id(), 
+                         incoming.incoming_protozoans[1].get_unique_id())
+
+        incoming.decline_protozoon(1)
+        self.assertEqual(1, len(incoming.incoming_protozoans))
+        self.assertEqual(protozoon2.get_unique_id(), 
+                         incoming.incoming_protozoans[0].get_unique_id())
+
+        incoming.decline_protozoon(0)
+        self.assertEqual(0, len(incoming.incoming_protozoans))
+
+        protozoon4 = model_protozoon.Protozoon()
+        protozoon4.randomize()
+        incoming.append_protozoon(protozoon1)
+        incoming.append_protozoon(protozoon2)
+        incoming.append_protozoon(protozoon3)
+        incoming.append_protozoon(protozoon4)
+        self.assertEqual(3, len(incoming.incoming_protozoans))
+        self.assertEqual(protozoon2.get_unique_id(), 
+                         incoming.incoming_protozoans[0].get_unique_id())
+        self.assertEqual(protozoon3.get_unique_id(), 
+                         incoming.incoming_protozoans[1].get_unique_id())
+        self.assertEqual(protozoon4.get_unique_id(), 
+                         incoming.incoming_protozoans[2].get_unique_id())
+        
+    def render_incoming(self, incoming, capacity):
+        for index in range(capacity):
+            width, height = 200, 200
+            dummy, ctx = self.create_context(width, height)
+            incoming.draw(index, ctx, width, height)
+
+    def test_renderSVG(self):
+        return #TODO support SVG ????
         self._neutral()
 
         width, height = 200, 200
@@ -370,16 +557,25 @@ class TestKandidModel(unittest.TestCase):
             layer.randomize()
             outname = 'testoutput_' + strategy
 #            surface = cairo.SVGSurface(outname + '.svg', width, height)
-            surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
-            ctx = cairo.Context(surface)
-            ctx.scale(width, height)
-            # paint background
-            ctx.set_operator(cairo.OPERATOR_SOURCE)
-            ctx.set_source_rgb(0.0, 0.0, 0.0)
-            ctx.paint()
+            surface, ctx = self.create_context(width, height)
             layer.render(ctx, width, height)
             surface.write_to_png(outname + '.png')
 
+    def test_render2(self):
+        return #TODO
+        test_enumerator.explain()
+
+    def create_context(self, width, height):
+        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
+        ctx = cairo.Context(surface)
+        ctx.scale(width, height)
+        # paint background
+        ctx.set_operator(cairo.OPERATOR_SOURCE)
+        ctx.set_source_rgb(0.0, 0.0, 0.0)
+        ctx.paint()
+        return surface, ctx
+
+
 ka_debug.info('starting TestSuite')
 ka_debug.err('testing error message channel.')
 alltests = unittest.TestSuite((\