path: root/test_model.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 time
import string

import ka_debug
import ka_factory
import ka_task
import ka_extensionpoint
import ka_incoming
import ka_widget
import ka_importer
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 test_enumerator

import kandid
import test_utils

EPSILON = 0.00001
_test_task_completed_count = 0

class TestKandidModel(unittest.TestCase):


    def setUp(self):
        pass

    def tearDown(self):
        pass

    def test_incomming1(self):
        widget = ka_widget.KandidWidget()
        widget.get_widget_tree()
        #TODO gtk main loop is not running. KandidIncoming.task_render will not be executed
        incoming = ka_incoming.KandidIncoming(None, widget.widget_list)
        incoming.create_gui()
        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
        widget = ka_widget.KandidWidget()
        widget.get_widget_tree()
        incoming = ka_incoming.KandidIncoming(None, widget.widget_list)
        incoming.create_gui()
        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.accept_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 test_importer(self):
        import_path = ka_importer.get_import_path()
        if os.path.exists(import_path):
            os.rename(import_path, import_path+str(time.clock()))

        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_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):
        test_utils.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_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 _explain_protozoon(self, protozoon, key):
        base_name = 'index'
        base_folder = '/dev/shm/'
        explain_id = '_' + key
        ep_list = ka_extensionpoint.list_extensions('formater')
        formater = ka_extensionpoint.create(ep_list[0],
                                            base_name, 
                                            explain_id,
                                            base_folder)
        class DummyTask:
            def __init__(self):
                self.quit = False
        protozoon.explain(DummyTask(), formater)
        file_path = formater.get_absolutename('html')
        formater.write_html_file(file_path)
        return formater._page[:]
        
    def test_protozoon(self):
        model_random.set_flurry(9)
        test_utils.neutral()

        protozoon1 = model_protozoon.Protozoon()
        protozoon1.randomize()
        protozoon2 = protozoon1.copy()
        self.assertTrue(protozoon2 is not protozoon1)
        if not protozoon2 == protozoon1:
            str1 = self._explain_protozoon(protozoon1, '1')
            str2 = self._explain_protozoon(protozoon2, '2')
            print protozoon2 == protozoon1
#            print str1
#            print str2
        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="2.5"; 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 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 ????
        test_utils.neutral()

        width, height = 200, 200
        surface = cairo.SVGSurface('testoutput_p.svg', width, height)
        ctx = cairo.Context(surface)
        protozoon1 = model_protozoon.Protozoon()
        protozoon1.randomize()
        class DummyTask:
            def __init__(self):
                self.quit = False
        protozoon1.render(DummyTask(), 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 = ka_widget.KandidWidget.get_localized_path()
        self.assertTrue(file_path.endswith('/Kandid.activity/locale/'
                                            + locale + '/'))

#!!    def test_enumerator_explain(self):
#!!        self.assertEqual(0, test_enumerator.explain())

    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, file_path)
            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 _create_context(self, width, height):
        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
        ctx = cairo.Context(surface)
        ctx.scale(float(width), float(height))
#        ka_debug.matrix(ctx.get_matrix())
        # paint background
        ctx.set_operator(cairo.OPERATOR_SOURCE)
        ctx.set_source_rgb(0.0, 0.0, 0.0)
        ctx.paint()
        return surface, ctx