path: root/test_suite.py

# coding: UTF8
# Copyright 2009 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 unittest
import cairo
import ka_debug
import ka_factory
import ka_random
import ka_extensionpoint
import model_protozoon
import model_constraintpool
import model_population
import model_locus
import exon_color
import exon_buzzword
import exon_direction
import exon_position

EPSILON = 0.00001

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('/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)
        
    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 cc in ka_extensionpoint.list_extensions(key+'constraint'):
            cpool.set('/'+key.capitalize(), key+'constraint', [cc])
            a_color = exon_color.Color('/', 0.5, 0.6, 0.7, 0.8)
            formater.color_item(a_color, 'Color ' + str(cc))
        formater.end_list()

        formater.end_list()
        formater.footer()
        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_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:
            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]))
        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(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)
        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)

    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 = ka_random.copy_list(list1)
        self.assertEqual(len(list1), len(list2))
        for index, i 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)):
            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

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

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

    def _run_ep_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 fa in [1, 2, population_size-1]:
            model.fade_away = fa
            for i in range(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 i in range(population_size):
                    model.fitness[i] = ft
                self._check_classification(population_size, model)

    def _check_classification(self, population_size, model):
        good, moderate, poor = model.classify()
        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 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))

    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):
        ka_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])
            element1 = constructor('/', *params)
            element2 = element1.copy()
            for i in range(32):
                element3 = element1.crossingover(element2)
                self.assertEqual(element1, element2)
                self.assertEqual(element1, element3)
            equal = True
            for i in range(32):
                element2.randomize()
                element2.mutate()
                element2.shuffle()
                equal = equal and element1 == element2
            self.assertFalse(equal)
            self.assertEqual(element1, element3)
            
    def test_exon_color(self):
        ka_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])
            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 i 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 i 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):
            color4.mutate()
            color4.shuffle()
            eq = eq and color4 == color3
        self.assertFalse(eq)
        
    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):
        ka_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.shuffle()
            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 i in range(32):
                layer4.shuffle()
#            self.assertFalse(layer4 == layer3)

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

        protozoon1 = model_protozoon.Protozoon()
        protozoon1.randomize()
        protozoon2 = protozoon1.copy()
        self.assertTrue(protozoon2 is not protozoon1)
        self.assertTrue(protozoon2 == protozoon1)
        protozoon1.randomize()
        protozoon1.shuffle()
        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()
#        self.assertFalse(protozoon4 == protozoon3)

    def test_draw(self):
        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.draw(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 = 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()
            layer.draw(ctx, width, height)
            surface.write_to_png(outname + '.png')

ka_debug.info('starting TestSuite')
ka_debug.err('testing error message channel.')
alltests = unittest.TestSuite((\
                 unittest.makeSuite(TestKandidModel), \
                             ))
unittest.TextTestRunner(verbosity=2).run(alltests)