path: root/test_suite.py

# coding: UTF-8
# Copyright 2009, 2010 Thomas Jourdan
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# 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 os
import sys
import traceback
import unittest
import cairo
import gtk
import time
import string

import ka_debug
import ka_factory
import ka_task
import ka_extensionpoint
import ka_incoming
import ka_widget
import ka_status
import ka_importer
import ka_controller
import model_random
import model_protozoon
import model_constraintpool
import model_population
import model_locus
import exon_color
import exon_buzzword
import exon_direction
import exon_position
import ep_page_intro

import test_enumerator

import kandid

EPSILON = 0.00001
_test_task_completed_count = 0

class TestKandidModel(unittest.TestCase):


    def setUp(self):
        pass

    def tearDown(self):
        pass

    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('*/positionconstraint',
                  exon_position.POSITION_CONSTRAINT, permitted)
        permitted = ['colorconstraint_none']
        cpool.set('*/colorconstraint',
                  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_backward(self):
        for release in range(2, ka_extensionpoint.revision_number):
            file_path = kandid.REFFERENCEMODEL + str(release)
            model = model_population.read_file(file_path)
            self.assertTrue(model is not None)
            result = model.copy().dot()
            # Hope to reach this point without an exception
            for protozoon in model.protozoans:
                formater = ka_extensionpoint.create('formater_html', 'index',
                                                    'test', '/dev/shm/')
                class DummyTask:
                    def __init__(self):
                        self.quit = False
                protozoon.explain(DummyTask(), formater)
            # Hope to reach this point without an exception

    def test_importer(self):
        import_path = ka_importer.get_import_path()
        install_marker = os.path.join(ka_debug.DEBUG_PROFILE_PATH,
                          'net.sourceforge.kandid/data/collection/install.inf')
        self._write_file(install_marker, 'v1')
        ka_importer._post_install()
        self.assertEqual(os.path.join(ka_debug.DEBUG_PROFILE_PATH,
                                      'net.sourceforge.kandid/data/collection'),
                         import_path)
        self.assertTrue(os.path.exists(import_path))
        statinfo = os.stat(import_path+'/segment_of_a_circle/stamp_halfcircle_top.svg')
        mt = statinfo.st_mtime
        self.assertTrue('segment_of_a_circle' in ka_importer.get_theme_list())
        dummy = ka_importer.get_rgb_image_list('')
        dummy = ka_importer.get_alpha_image_list('')
        svg_image_list = ka_importer.get_svg_image_list('segment_of_a_circle')
        self.assertTrue(len(svg_image_list) > 0)
        print mt

    def test_task(self):
        global _test_task_completed_count
        _test_task_completed_count = 0
        ka_task.GeneratorTask(self.task_1, self.on_completed, 'n1').start()
        time.sleep(5)
        self.assertTrue(ka_task.GeneratorTask.is_completed())
        ka_task.GeneratorTask(self.task_2, self.on_completed, 'n2').start()
        time.sleep(5)
        self.assertTrue(ka_task.GeneratorTask.is_completed())
        #TODO gtk main loop is not running. on_completed will not be executed
        #self.assertEqual(1, _test_task_completed_count)

    def task_1(self, task, *args, **kwargs):
        print 'leave 1', _test_task_completed_count

    def task_2(self, task, *args, **kwargs):
        raise Exception
        print 'leave 2', _test_task_completed_count

    def on_completed(self, *args):
        global _test_task_completed_count
        _test_task_completed_count +=1
        print 'on_completed', _test_task_completed_count

    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 _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()
            diff = not (mm3 == mm1 and mm3 == mm2)
            if not diff:
                print mm1, mm2, mm3
            self.assertTrue(diff)

    def test_stamp(self):
        cpool = model_constraintpool.ConstraintPool.get_pool()
        for theme in ka_importer.get_theme_list():
            cpool.set('*/themeconstraint',
                      'themeconstraint', theme)
            self._run_stamp_breed_test(2)
        cpool.set('*/themeconstraint',
                  'hemeconstraint', 'non_existing_theme')
        self._run_stamp_breed_test(99)
        cpool.set('*/themeconstraint',
                  'themeconstraint', ka_importer.get_theme_list())
        self._run_stamp_breed_test(0)

    def _run_stamp_breed_test(self, max_states):
        model_random.set_flurry(9)
        for flavor in ka_extensionpoint.list_extensions('stamp'):
            mm1 = ka_extensionpoint.create(flavor, '/', max_states)
            mm1.randomize()
            mm1.mutate()
            mm1.swap_places()
            mm2 = ka_extensionpoint.create(flavor, '/', max_states)
            mm2.randomize()
            mm2.mutate()
            mm2.swap_places()
            mm3 = mm1.crossingover(mm2)
            mm3.mutate()

    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()
            
            file_path = self.explain(ep_key, a_protozoon,
                                           'index', '/dev/shm/')
            exit_code = os.spawnvp(os.P_WAIT, 'tidy', ['tidy', '-i', '-q', '-w', '255', file_path])
            self.assertEqual(0, exit_code)

    def explain(self, ep_key, a_protozoon, base_name, base_folder):
        formater = ka_extensionpoint.create(ep_key, base_name,
                                            a_protozoon.get_unique_id(),
                                            base_folder)
        class DummyTask:
            def __init__(self):
                self.quit = False
        a_protozoon.explain(DummyTask(), formater)
        file_path = formater.get_absolutename(ep_key)
        formater.write_html_file(file_path)
        return file_path

    def test_locus(self):
        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.header('Test title')
        formater.begin_list('l1')
        a_text = '&<>'
        formater.text_item(a_text)

        formater.begin_list('l2')
        cpool = model_constraintpool.ConstraintPool.get_pool()
        key = 'color'
        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(constraint))
        formater.end_list()

        formater.end_list()
        formater.footer()
        file_path = formater.get_absolutename('html')
        formater.write_html_file(file_path)
        self.assertEqual(4, len(formater.produced_files_list))
        self.assertEqual(base_folder+'test/'+base_name+'.html',
                         formater.produced_files_list[3])
        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:
            out_file = open(file_path, 'w')
            out_file.write(page)
        except:
            self.fail('failed writing [%s] [%s] [%s]' % \
                       (out_file.name, sys.exc_info()[0], sys.exc_info()[1]))
            traceback.print_exc(file=sys.__stderr__)
        finally:
            if out_file:
                out_file.close()

    def test_constrain_pool(self):
        position = exon_position.Position('/', 0.1, 0.2)
        cpool = model_constraintpool.ConstraintPool.get_pool()
        cpool.get(position, exon_position.POSITION_CONSTRAINT)
        print cpool

    def test_limit(self):
        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 <= 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()
        ep_types = ka_extensionpoint.list_extension_types()
        self.assertTrue(len(ep_types) > 0)

        ep_list = ka_extensionpoint.list_extensions('colorconstraint')
        self.assertTrue(len(ep_list) > 0)
        for ep_key in ep_list:
            colorconstraint = ka_extensionpoint.create(ep_key, '/')
            self.assertEqual(4, len(colorconstraint.filter((.5, .5, .5, 1.))))

    def test_deepcopy(self):
        self._neutral()
        list1 = [exon_buzzword.Buzzword('/', [u'sugar', u'kandid', u'']), \
                 exon_color.Color('/', 0.1, 0.2, 0.3, 1.0), \
                 exon_direction.Direction('/', 0.1, 0.2), \
                 exon_position.Position('/', 0.1, 0.2), \
                ]
        list2 = model_random.copy_list(list1)
        self.assertEqual(len(list1), len(list2))
        for index, dummy in enumerate(list1):
            self.assertEqual(list1[index], list2[index])
            self.assertTrue(list1[index] is not list2[index])
        
    def test_random(self):
        model_random.set_flurry(0)
        seq = model_random.crossing_sequence(10)
        for index in range(1, len(seq)):
            self.assertEqual(seq[0], seq[index])
        model_random.set_flurry(9)

    def test_positionconstraint(self):
        self._run_ep_constarint_test('position')

    def test_directionconstraint(self):
        self._run_ep_constarint_test('direction')

    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)
            x_pos, y_pos = constraint.randomize()
            x_pos, y_pos = constraint.mutate(x_pos, y_pos)
            self.assertTrue(isinstance(x_pos, float))
            self.assertTrue(isinstance(y_pos, float))

    def test_classification(self):
        population_size = 12
        model = model_population.KandidModel(population_size)
        self.assertEqual(population_size, len(model.fitness))
        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)
            self._check_classification(population_size, model)
            for fit in [0.0, 5.0, 9.0]:
                for i in range(population_size):
                    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.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 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)
            
    def test_exon_direction(self):
        self._run_exon_test('direction', exon_direction.Direction, 0.3, 0.4)
            
    def test_exon_buzzword(self):
        self._run_exon_test('buzzword', exon_buzzword.Buzzword, [u'a', u'b'])
            
    def _run_exon_test(self, key, constructor, *params):
        model_random.set_flurry(9)
        self._neutral()
        
        cpool = model_constraintpool.ConstraintPool.get_pool()
        for constraint in ka_extensionpoint.list_extensions(key + 'constraint'):
            cpool.set('/' + key.capitalize(), key + 'constraint', [constraint])
            element1 = constructor('/', *params)
            element2 = element1.copy()
            for dummy in range(32):
                element3 = element1.crossingover(element2)
                self.assertEqual(element1, element2)
                self.assertEqual(element1, element3)
            equal = True
            for dummy in range(32):
                element2.randomize()
                element2.mutate()
                element2.swap_places()
                equal = equal and element1 == element2
            self.assertFalse(equal)
            self.assertEqual(element1, element3)
            
    def test_exon_color(self):
        model_random.set_flurry(9)
        cpool = model_constraintpool.ConstraintPool.get_pool()
        cpool.clear_all()

        key = 'color'
        cpool = model_constraintpool.ConstraintPool.get_pool()

        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.assertEqual(4, len(a_color.copy().rgba))
            a_color.randomize()
            self.assertEqual(4, len(a_color.rgba))
            for dummy in range(32):
                a_color.mutate()
            self.assertEqual(4, len(a_color.rgba))

        self._neutral()
        color1 = exon_color.Color('/', 1.0, 1.0, 1.0, 1.0)
        color2 = color1.copy()
        self.assertTrue(color2 is not color1)
        self.assertTrue(color2 == color1)
        color1.randomize()
        self.assertFalse(color2 == color1)
        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()
        eql = True
        for dummy in range(32):
            color4.mutate()
            color4.swap_places()
            eql = eql and color4 == color3
        self.assertFalse(eql)
        
    def test_layer_factory(self):
        self._neutral()
        layer_factory = ka_factory.get_factory('layer')
        keys = layer_factory.keys()
        self.assertTrue(layer_factory.count() >= 1)
        self.assertEqual(len(keys), layer_factory.count())
        for layer_key in keys:
            self.assertTrue(layer_factory.create(layer_key, '/') is not None)
        self.assertTrue(layer_factory.create_random([keys[0]], '/') is not None)
        
    def test_layer(self):
        model_random.set_flurry(9)
        self._neutral()
        
        layer_factory = ka_factory.get_factory('layer')
        for layer_key in layer_factory.keys():
            layer1 = layer_factory.create(layer_key, '/')
            layer2 = layer1.copy()
            self.assertTrue(layer2 is not layer1)
            self.assertTrue(layer2 == layer1)
            layer1.randomize()
            layer1.swap_places()
            if layer2 == layer1:
                pass
            self.assertFalse(layer2 == layer1)
            layer3 = layer1.crossingover(layer2)
            self.assertTrue(layer3 is not layer1)
            self.assertTrue(layer3 is not layer2)
            layer4 = layer3.copy()
            layer4.mutate()
            for dummy in range(32):
                layer4.swap_places()
#            self.assertFalse(layer4 == layer3)

    def test_protozoon(self):
        model_random.set_flurry(9)
        self._neutral()

        protozoon1 = model_protozoon.Protozoon()
        protozoon1.randomize()
        protozoon2 = protozoon1.copy()
        self.assertTrue(protozoon2 is not protozoon1)
        if not protozoon2 == protozoon1:
            print protozoon2 == protozoon1
        self.assertTrue(protozoon2 == protozoon1)
        protozoon1.randomize()
        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 dummy in range(32):
            protozoon4.swap_places()
#        self.assertFalse(protozoon4 == protozoon3)

    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_generation()
        self.assertTrue(5 in new_indices)
        self.assertTrue(1 in new_indices)
        model.fitness[2] = 0.0
        new_indices = model.random()
        self.assertTrue(2 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())
        
        model.fitness[7] = 1.0
        new_indices = model.breed_single(7)
        self.assertEqual(1, len(new_indices))
        self.assertEqual(7, new_indices[0])
        self.assertEqual(4.0, model.fitness[7])

        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}'    
        plain_file = open(kandid.TESTMODEL+'.dot', 'w')
        if plain_file:
            plain_file.write(result)
            plain_file.close()
        red_count = result.count('color=red')
        unicode_count = result.count('"unicode ')
        self.assertTrue(unicode_count > red_count)    

        model_population.write_file(kandid.TESTMODEL, model)
        recalled_model = model_population.read_file(kandid.TESTMODEL)
        
    def test_incomming1(self):
        main_view = gtk.HBox()
        widget = ka_widget.KandidWidget(main_view)
        #TODO gtk main loop is not running. KandidIncoming.task_render will not be executed
        incoming = ka_incoming.KandidIncoming(3, widget.getWidget_tree())
        self.assertEqual(0, len(incoming.incoming_id))
        protozoon1 = model_protozoon.Protozoon()
        protozoon1.randomize()
        incoming.append_protozoon(protozoon1)
        self.assertEqual(1, len(incoming.incoming_id))
        self.assertEqual(protozoon1.get_unique_id(), 
                         incoming.at_index(0)[0].get_unique_id())
        incoming.decline_protozoon(0)
        self.assertEqual(0, len(incoming.incoming_id))

    def test_incomming3(self):
        protozoon1 = model_protozoon.Protozoon()
        protozoon1.randomize()
        protozoon2 = model_protozoon.Protozoon()
        protozoon2.randomize()
        protozoon3 = model_protozoon.Protozoon()
        protozoon3.randomize()

        capacity = 3
        main_view = gtk.HBox()
        widget = ka_widget.KandidWidget(main_view)
        incoming = ka_incoming.KandidIncoming(capacity, widget.getWidget_tree())
        self.assertEqual(0, len(incoming.incoming_id))

        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_id))
        self.assertEqual(protozoon1.get_unique_id(), 
                         incoming.at_index(0)[0].get_unique_id())
        self.assertEqual(protozoon2.get_unique_id(), 
                         incoming.at_index(1)[0].get_unique_id())
        self.assertEqual(protozoon3.get_unique_id(), 
                         incoming.at_index(2)[0].get_unique_id())
        
        incoming.decline_protozoon(0)
        self.assertEqual(2, len(incoming.incoming_id))
        self.assertEqual(protozoon2.get_unique_id(), 
                         incoming.at_index(0)[0].get_unique_id())
        self.assertEqual(protozoon3.get_unique_id(), 
                         incoming.at_index(1)[0].get_unique_id())

        incoming.decline_protozoon(1)
        self.assertEqual(1, len(incoming.incoming_id))
        self.assertEqual(protozoon2.get_unique_id(), 
                         incoming.at_index(0)[0].get_unique_id())

        incoming.decline_protozoon(0)
        self.assertEqual(0, len(incoming.incoming_id))

        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_id))
        self.assertEqual(protozoon2.get_unique_id(), 
                         incoming.at_index(0)[0].get_unique_id())
        self.assertEqual(protozoon3.get_unique_id(), 
                         incoming.at_index(1)[0].get_unique_id())
        self.assertEqual(protozoon4.get_unique_id(), 
                         incoming.at_index(2)[0].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
        surface = cairo.SVGSurface('testoutput_p.svg', width, height)
        ctx = cairo.Context(surface)
        protozoon1 = model_protozoon.Protozoon()
        protozoon1.randomize()
        protozoon1.render(ctx, width, height)

        layer_factory = ka_factory.get_factory('layer')
        for strategy in layer_factory.keys():
            layer = layer_factory.create(strategy, '/')
            layer.randomize()
            outname = 'testoutput_' + strategy
#            surface = cairo.SVGSurface(outname + '.svg', width, height)
            surface, ctx = self._create_context(width, height)
            layer.render(ctx, width, height)
            surface.write_to_png(outname + '.png')

    def test_localization(self):
        locale, territory = ka_widget.KandidWidget.get_localization()
        for lc in locale:
            self.assertTrue(lc in string.ascii_lowercase)
        for tc in territory:
            self.assertTrue(tc in string.ascii_uppercase)
        file_path = ep_page_intro.IntroController.get_localized_path(locale,
                                                                   territory)
        self.assertTrue(file_path.endswith('/Kandid.activity/locale/'
                                            + locale + '/intro.html'))

    def test_render2(self):
        self.assertEqual(0, test_enumerator.explain())

    def test_status(self):
        status = ka_status.Status()
        status.set(ka_status.TOPIC_TASK,
                      ka_status.SUB_UNFINISHED,
                      '5')
        self.assertTrue(status.isDirty())
        status.set(ka_status.TOPIC_COLLABORATION,
                      ka_status.SUB_BUDDIES_JOINED, '2')
        expected = '''
Collaboration
  Buddies joined: 2

Tasks
  Unfinished tasks: 5

Activity
  Running: Kandid, release v4, DoB activated
'''
        self.assertEqual(expected, status.recall())
        self.assertFalse(status.isDirty())

    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.')
gtk.gdk.threads_init()
alltests = unittest.TestSuite((\
                 unittest.makeSuite(TestKandidModel), \
                             ))
unittest.TextTestRunner(verbosity=2).run(alltests)