bee_python 0.0.1

data/tools/common/common/test/unittest_date.py

@@ -0,0 +1,154 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common 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 Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""
+Unittests for date helpers
+"""
+from logilab.common.testlib import TestCase, unittest_main
+
+from logilab.common.date import date_range, endOfMonth
+from logilab.common.date import add_days_worked, nb_open_days, \
+         get_national_holidays
+
+from datetime import date, datetime, timedelta
+
+try:
+    from mx.DateTime import Date as mxDate, DateTime as mxDateTime, \
+         now as mxNow, RelativeDateTime, RelativeDate
+except ImportError:
+    mxDate = mxDateTime = RelativeDateTime = mxNow = None
+
+class DateTC(TestCase):
+    datecls = date
+    datetimecls = datetime
+    timedeltacls = timedelta
+    now = datetime.now
+
+    def test_day(self):
+        """enumerate days"""
+        r = list(date_range(self.datecls(2000,1,1), self.datecls(2000,1,4)))
+        expected = [self.datecls(2000,1,1), self.datecls(2000,1,2), self.datecls(2000,1,3)]
+        self.assertListEquals(r, expected)
+        r = list(date_range(self.datecls(2000,1,31), self.datecls(2000,2,3)))
+        expected = [self.datecls(2000,1,31), self.datecls(2000,2,1), self.datecls(2000,2,2)]
+        self.assertListEquals(r, expected)
+        r = list(date_range(self.datecls(2000,1,1), self.datecls(2000,1,6), 2))
+        expected = [self.datecls(2000,1,1), self.datecls(2000,1,3), self.datecls(2000,1,5)]
+        self.assertListEquals(r, expected)
+
+    def test_add_days_worked(self):
+        add = add_days_worked
+        # normal
+        self.assertEquals(add(self.datecls(2008, 1, 3), 1), self.datecls(2008, 1, 4))
+        # skip week-end
+        self.assertEquals(add(self.datecls(2008, 1, 3), 2), self.datecls(2008, 1, 7))
+        # skip 2 week-ends
+        self.assertEquals(add(self.datecls(2008, 1, 3), 8), self.datecls(2008, 1, 15))
+        # skip holiday + week-end
+        self.assertEquals(add(self.datecls(2008, 4, 30), 2), self.datecls(2008, 5, 5))
+
+    def test_get_national_holidays(self):
+        holidays = get_national_holidays
+        yield self.assertEquals, holidays(self.datecls(2008, 4, 29), self.datecls(2008, 5, 2)), \
+              [self.datecls(2008, 5, 1)]
+        yield self.assertEquals, holidays(self.datecls(2008, 5, 7), self.datecls(2008, 5, 8)), []
+        x = self.datetimecls(2008, 5, 7, 12, 12, 12)
+        yield self.assertEquals, holidays(x, x + self.timedeltacls(days=1)), []
+
+    def test_open_days_now_and_before(self):
+        nb = nb_open_days
+        x = self.now()
+        y = x - self.timedeltacls(seconds=1)
+        self.assertRaises(AssertionError, nb, x, y)
+
+    def assertOpenDays(self, start, stop, expected):
+        got = nb_open_days(start, stop)
+        self.assertEquals(got, expected)
+
+    def test_open_days_tuesday_friday(self):
+        self.assertOpenDays(self.datecls(2008, 3, 4), self.datecls(2008, 3, 7), 3)
+
+    def test_open_days_day_nextday(self):
+        self.assertOpenDays(self.datecls(2008, 3, 4), self.datecls(2008, 3, 5), 1)
+
+    def test_open_days_friday_monday(self):
+        self.assertOpenDays(self.datecls(2008, 3, 7), self.datecls(2008, 3, 10), 1)
+
+    def test_open_days_friday_monday_with_two_weekends(self):
+        self.assertOpenDays(self.datecls(2008, 3, 7), self.datecls(2008, 3, 17), 6)
+
+    def test_open_days_tuesday_wednesday(self):
+        """week-end + easter monday"""
+        self.assertOpenDays(self.datecls(2008, 3, 18), self.datecls(2008, 3, 26), 5)
+
+    def test_open_days_friday_saturday(self):
+        self.assertOpenDays(self.datecls(2008, 3, 7), self.datecls(2008, 3, 8), 1)
+
+    def test_open_days_friday_sunday(self):
+        self.assertOpenDays(self.datecls(2008, 3, 7), self.datecls(2008, 3, 9), 1)
+
+    def test_open_days_saturday_sunday(self):
+        self.assertOpenDays(self.datecls(2008, 3, 8), self.datecls(2008, 3, 9), 0)
+
+    def test_open_days_saturday_monday(self):
+        self.assertOpenDays(self.datecls(2008, 3, 8), self.datecls(2008, 3, 10), 0)
+
+    def test_open_days_saturday_tuesday(self):
+        self.assertOpenDays(self.datecls(2008, 3, 8), self.datecls(2008, 3, 11), 1)
+
+    def test_open_days_now_now(self):
+        x = self.now()
+        self.assertOpenDays(x, x, 0)
+
+    def test_open_days_now_now2(self):
+        x = self.datetimecls(2010, 5, 24)
+        self.assertOpenDays(x, x, 0)
+
+    def test_open_days_afternoon_before_holiday(self):
+        self.assertOpenDays(self.datetimecls(2008, 5, 7, 14), self.datetimecls(2008, 5, 8, 0), 1)
+
+    def test_open_days_afternoon_before_saturday(self):
+        self.assertOpenDays(self.datetimecls(2008, 5, 9, 14), self.datetimecls(2008, 5, 10, 14), 1)
+
+    def test_open_days_afternoon(self):
+        self.assertOpenDays(self.datetimecls(2008, 5, 6, 14), self.datetimecls(2008, 5, 7, 14), 1)
+
+
+class MxDateTC(DateTC):
+    datecls = mxDate
+    datetimecls = mxDateTime
+    timedeltacls = RelativeDateTime
+    now = mxNow
+
+    def check_mx(self):
+        if mxDate is None:
+            self.skip('mx.DateTime is not installed')
+
+    def setUp(self):
+        self.check_mx()
+
+    def test_month(self):
+        """enumerate months"""
+        r = list(date_range(self.datecls(2000,1,2), self.datecls(2000,4,4), endOfMonth))
+        expected = [self.datecls(2000,1,2), self.datecls(2000,2,29), self.datecls(2000,3,31)]
+        self.assertListEquals(r, expected)
+        r = list(date_range(self.datecls(2000,11,30), self.datecls(2001,2,3), endOfMonth))
+        expected = [self.datecls(2000,11,30), self.datecls(2000,12,31), self.datecls(2001,1,31)]
+        self.assertListEquals(r, expected)
+
+if __name__ == '__main__':
+    unittest_main()

data/tools/common/common/test/unittest_decorators.py

@@ -0,0 +1,62 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common 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 Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""unit tests for the decorators module
+"""
+
+from logilab.common.testlib import TestCase, unittest_main
+from logilab.common.decorators import monkeypatch, cached
+
+class DecoratorsTC(TestCase):
+
+    def test_monkeypatch_with_same_name(self):
+        class MyClass: pass
+        @monkeypatch(MyClass)
+        def meth1(self):
+            return 12
+        self.assertEquals([attr for attr in dir(MyClass) if attr[:2] != '__'],
+                          ['meth1'])
+        inst = MyClass()
+        self.assertEquals(inst.meth1(), 12)
+
+    def test_monkeypatch_with_custom_name(self):
+        class MyClass: pass
+        @monkeypatch(MyClass, 'foo')
+        def meth2(self, param):
+            return param + 12
+        self.assertEquals([attr for attr in dir(MyClass) if attr[:2] != '__'],
+                          ['foo'])
+        inst = MyClass()
+        self.assertEquals(inst.foo(4), 16)
+
+    def test_cached_preserves_docstrings(self):
+        class Foo(object):
+            @cached
+            def foo(self):
+                """ what's up doc ? """
+            def bar(self, zogzog):
+                """ what's up doc ? """
+            bar = cached(bar, 1)
+            @cached
+            def quux(self, zogzog):
+                """ what's up doc ? """
+        self.assertEquals(Foo.foo.__doc__, """ what's up doc ? """)
+        self.assertEquals(Foo.bar.__doc__, """ what's up doc ? """)
+        self.assertEquals(Foo.quux.__doc__, """ what's up doc ? """)
+
+if __name__ == '__main__':
+    unittest_main()

data/tools/common/common/test/unittest_deprecation.py

@@ -0,0 +1,76 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common 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 Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""unit tests for logilab.common.deprecation"""
+
+import warnings
+
+from logilab.common.testlib import TestCase, unittest_main
+from logilab.common import deprecation
+
+def moving_target():
+    pass
+
+class RawInputTC(TestCase):
+
+    # XXX with 2.6 we could test warnings
+    # http://docs.python.org/library/warnings.html#testing-warnings
+    # instead we just make sure it does not crash
+    def setUp(self):
+        warnings.simplefilter("ignore")
+    def tearDown(self):
+        warnings.simplefilter("default")
+
+    def mk_func(self):
+        def any_func():
+            pass
+        return any_func
+
+    def test_class_deprecated(self):
+        class AnyClass:
+            __metaclass__ = deprecation.class_deprecated
+
+    def test_deprecated_func(self):
+        any_func = deprecation.deprecated()(self.mk_func())
+        any_func()
+        any_func = deprecation.deprecated('message')(self.mk_func())
+        any_func()
+
+    def test_deprecated_decorator(self):
+        @deprecation.deprecated_function
+        def any_func():
+            pass
+        any_func()
+
+        @deprecation.deprecated()
+        def any_func():
+            pass
+        any_func()
+
+        @deprecation.deprecated('message')
+        def any_func():
+            pass
+        any_func()
+
+    def test_moved(self):
+        # this test needs l.c.test.__init__
+        module = 'logilab.common.test.unittest_deprecation'
+        any_func = deprecation.moved(module, 'moving_target')
+        any_func()
+
+if __name__ == '__main__':
+    unittest_main()

data/tools/common/common/test/unittest_fileutils.py

@@ -0,0 +1,133 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common 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 Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""unit tests for logilab.common.fileutils"""
+
+import sys, os, tempfile, shutil
+from os.path import join
+
+from logilab.common.testlib import TestCase, unittest_main
+
+from logilab.common.fileutils import *
+
+
+DATA_DIR = 'data'
+NEWLINES_TXT = join(DATA_DIR,'newlines.txt')
+
+class FirstleveldirectoryTC(TestCase):
+
+    def test_known_values_first_level_directory(self):
+        """return the first level directory of a path"""
+        self.assertEqual(first_level_directory('truc/bidule/chouette'), 'truc', None)
+        self.assertEqual(first_level_directory('/truc/bidule/chouette'), '/', None)
+
+class IsBinaryTC(TestCase):
+    def test(self):
+        self.assertEqual(is_binary('toto.txt'), 0)
+        #self.assertEqual(is_binary('toto.xml'), 0)
+        self.assertEqual(is_binary('toto.bin'), 1)
+        self.assertEqual(is_binary('toto.sxi'), 1)
+        self.assertEqual(is_binary('toto.whatever'), 1)
+
+class GetModeTC(TestCase):
+    def test(self):
+        self.assertEqual(write_open_mode('toto.txt'), 'w')
+        #self.assertEqual(write_open_mode('toto.xml'), 'w')
+        self.assertEqual(write_open_mode('toto.bin'), 'wb')
+        self.assertEqual(write_open_mode('toto.sxi'), 'wb')
+
+class NormReadTC(TestCase):
+    def test_known_values_norm_read(self):
+        data = norm_read(NEWLINES_TXT)
+        self.assertEqual(data.strip(), '\n'.join(['# mixed new lines', '1', '2', '3']))
+
+
+class LinesTC(TestCase):
+    def test_known_values_lines(self):
+        self.assertEqual(lines(NEWLINES_TXT),
+                         ['# mixed new lines', '1', '2', '3'])
+
+    def test_known_values_lines_comment(self):
+        self.assertEqual(lines(NEWLINES_TXT, comments='#'),
+                         ['1', '2', '3'])
+
+class ExportTC(TestCase):
+    def setUp(self):
+        self.tempdir = tempfile.mktemp()
+        os.mkdir(self.tempdir)
+
+    def test(self):
+        export('data', self.tempdir, verbose=0)
+        self.assert_(exists(join(self.tempdir, '__init__.py')))
+        self.assert_(exists(join(self.tempdir, 'sub')))
+        self.assert_(not exists(join(self.tempdir, '__init__.pyc')))
+        self.assert_(not exists(join(self.tempdir, 'CVS')))
+
+    def tearDown(self):
+        shutil.rmtree(self.tempdir)
+
+class ProtectedFileTC(TestCase):
+    def setUp(self):
+        self.rpath = 'data/write_protected_file.txt'
+        self.rwpath = 'data/normal_file.txt'
+        # Make sure rpath is not writable !
+        os.chmod(self.rpath, 33060)
+        # Make sure rwpath is writable !
+        os.chmod(self.rwpath, 33188)
+
+    def test_mode_change(self):
+        """tests that mode is changed when needed"""
+        # test on non-writable file
+        self.assert_(not os.access(self.rpath, os.W_OK))
+        wp_file = ProtectedFile(self.rpath, 'w')
+        self.assert_(os.access(self.rpath, os.W_OK))
+        # test on writable-file
+        self.assert_(os.access(self.rwpath, os.W_OK))
+        wp_file = ProtectedFile(self.rwpath, 'w')
+        self.assert_(os.access(self.rwpath, os.W_OK))
+
+    def test_restore_on_close(self):
+        """tests original mode is restored on close"""
+        # test on non-writable file
+        self.assert_(not os.access(self.rpath, os.W_OK))
+        ProtectedFile(self.rpath, 'w').close()
+        self.assert_(not os.access(self.rpath, os.W_OK))
+        # test on writable-file
+        self.assert_(os.access(self.rwpath, os.W_OK))
+        ProtectedFile(self.rwpath, 'w').close()
+        self.assert_(os.access(self.rwpath, os.W_OK))
+
+    def test_mode_change_on_append(self):
+        """tests that mode is changed when file is opened in 'a' mode"""
+        self.assert_(not os.access(self.rpath, os.W_OK))
+        wp_file = ProtectedFile(self.rpath, 'a')
+        self.assert_(os.access(self.rpath, os.W_OK))
+        wp_file.close()
+        self.assert_(not os.access(self.rpath, os.W_OK))
+
+
+from logilab.common.testlib import DocTest
+class ModuleDocTest(DocTest):
+    """relative_path embed tests in docstring"""
+    from logilab.common import fileutils as module
+    skipped = ('abspath_listdir',)
+
+
+del DocTest # necessary if we don't want it to be executed (we don't...)
+
+if __name__ == '__main__':
+    unittest_main()

data/tools/common/common/test/unittest_graph.py

@@ -0,0 +1,50 @@
+# unit tests for the cache module
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common 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 Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+
+from logilab.common.testlib import TestCase, unittest_main
+from logilab.common.graph import get_cycles, has_path
+
+class getCyclesTC(TestCase):
+
+    def test_known0(self):
+        self.assertEqual(get_cycles({1:[2], 2:[3], 3:[1]}), [[1, 2, 3]])
+
+    def test_known1(self):
+        self.assertEqual(get_cycles({1:[2], 2:[3], 3:[1, 4], 4:[3]}), [[1, 2, 3], [3, 4]])
+
+    def test_known2(self):
+        self.assertEqual(get_cycles({1:[2], 2:[3], 3:[0], 0:[]}), [])
+
+
+class hasPathTC(TestCase):
+
+    def test_direct_connection(self):
+        self.assertEquals(has_path({'A': ['B'], 'B': ['A']}, 'A', 'B'), ['B'])
+
+    def test_indirect_connection(self):
+        self.assertEquals(has_path({'A': ['B'], 'B': ['A', 'C'], 'C': ['B']}, 'A', 'C'), ['B', 'C'])
+
+    def test_no_connection(self):
+        self.assertEquals(has_path({'A': ['B'], 'B': ['A']}, 'A', 'C'), None)
+
+    def test_cycle(self):
+        self.assertEquals(has_path({'A': ['A']}, 'A', 'B'), None)
+
+if __name__ == "__main__":
+    unittest_main()

data/tools/common/common/test/unittest_html.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common 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 Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""unittests for logilab.common.html
+
+:organization: Logilab
+
+
+
+"""
+
+__docformat__ = "restructuredtext en"
+
+from logilab.common.testlib import TestCase, unittest_main
+from logilab.common.tree import Node
+
+from logilab.common import html
+
+tree = ('root', (
+    ('child_1_1', (
+    ('child_2_1', ()), ('child_2_2', (
+    ('child_3_1', ()),
+    ('child_3_2', ()),
+    ('child_3_3', ()),
+    )))),
+    ('child_1_2', (('child_2_3', ()),))))
+
+generated_html = """\
+<table class="tree">
+<tr><td class="tree_cell" rowspan="2"><div class="tree_cell">root</div></td><td class="tree_cell_1_1">&nbsp;</td><td class="tree_cell_1_2">&nbsp;</td><td class="tree_cell" rowspan="2"><div class="tree_cell">child_1_1</div></td><td class="tree_cell_1_1">&nbsp;</td><td class="tree_cell_1_2">&nbsp;</td><td class="tree_cell" rowspan="2"><div class="tree_cell">child_2_1</div></td><td class="tree_cell_0_1">&nbsp;</td><td class="tree_cell_0_2">&nbsp;</td><td rowspan="2">&nbsp;</td></tr>
+<tr><td class="tree_cell_1_3">&nbsp;</td><td class="tree_cell_1_4">&nbsp;</td><td class="tree_cell_1_3">&nbsp;</td><td class="tree_cell_1_4">&nbsp;</td><td class="tree_cell_0_3">&nbsp;</td><td class="tree_cell_0_4">&nbsp;</td></tr>
+<tr><td rowspan="2">&nbsp;</td><td class="tree_cell_2_1">&nbsp;</td><td class="tree_cell_2_2">&nbsp;</td><td rowspan="2">&nbsp;</td><td class="tree_cell_4_1">&nbsp;</td><td class="tree_cell_4_2">&nbsp;</td><td class="tree_cell" rowspan="2"><div class="selected tree_cell">child_2_2</div></td><td class="tree_cell_1_1">&nbsp;</td><td class="tree_cell_1_2">&nbsp;</td><td class="tree_cell" rowspan="2"><div class="tree_cell">child_3_1</div></td></tr>
+<tr><td class="tree_cell_2_3">&nbsp;</td><td class="tree_cell_2_4">&nbsp;</td><td class="tree_cell_4_3">&nbsp;</td><td class="tree_cell_4_4">&nbsp;</td><td class="tree_cell_1_3">&nbsp;</td><td class="tree_cell_1_4">&nbsp;</td></tr>
+<tr><td rowspan="2">&nbsp;</td><td class="tree_cell_2_1">&nbsp;</td><td class="tree_cell_2_2">&nbsp;</td><td rowspan="2">&nbsp;</td><td class="tree_cell_0_1">&nbsp;</td><td class="tree_cell_0_2">&nbsp;</td><td rowspan="2">&nbsp;</td><td class="tree_cell_3_1">&nbsp;</td><td class="tree_cell_3_2">&nbsp;</td><td class="tree_cell" rowspan="2"><div class="tree_cell">child_3_2</div></td></tr>
+<tr><td class="tree_cell_2_3">&nbsp;</td><td class="tree_cell_2_4">&nbsp;</td><td class="tree_cell_0_3">&nbsp;</td><td class="tree_cell_0_4">&nbsp;</td><td class="tree_cell_3_3">&nbsp;</td><td class="tree_cell_3_4">&nbsp;</td></tr>
+<tr><td rowspan="2">&nbsp;</td><td class="tree_cell_2_1">&nbsp;</td><td class="tree_cell_2_2">&nbsp;</td><td rowspan="2">&nbsp;</td><td class="tree_cell_0_1">&nbsp;</td><td class="tree_cell_0_2">&nbsp;</td><td rowspan="2">&nbsp;</td><td class="tree_cell_4_1">&nbsp;</td><td class="tree_cell_4_2">&nbsp;</td><td class="tree_cell" rowspan="2"><div class="tree_cell">child_3_3</div></td></tr>
+<tr><td class="tree_cell_2_3">&nbsp;</td><td class="tree_cell_2_4">&nbsp;</td><td class="tree_cell_0_3">&nbsp;</td><td class="tree_cell_0_4">&nbsp;</td><td class="tree_cell_4_3">&nbsp;</td><td class="tree_cell_4_4">&nbsp;</td></tr>
+<tr><td rowspan="2">&nbsp;</td><td class="tree_cell_4_1">&nbsp;</td><td class="tree_cell_4_2">&nbsp;</td><td class="tree_cell" rowspan="2"><div class="tree_cell">child_1_2</div></td><td class="tree_cell_5_1">&nbsp;</td><td class="tree_cell_5_2">&nbsp;</td><td class="tree_cell" rowspan="2"><div class="tree_cell">child_2_3</div></td><td class="tree_cell_0_1">&nbsp;</td><td class="tree_cell_0_2">&nbsp;</td><td rowspan="2">&nbsp;</td></tr>
+<tr><td class="tree_cell_4_3">&nbsp;</td><td class="tree_cell_4_4">&nbsp;</td><td class="tree_cell_5_3">&nbsp;</td><td class="tree_cell_5_4">&nbsp;</td><td class="tree_cell_0_3">&nbsp;</td><td class="tree_cell_0_4">&nbsp;</td></tr>
+</table>\
+"""
+
+def make_tree(tupletree):
+    n = Node(tupletree[0])
+    for child in tupletree[1]:
+        n.append(make_tree(child))
+    return n
+
+class UIlibHTMLGenerationTC(TestCase):
+    """ a basic tree node, caracterised by an id"""
+    def setUp(self):
+        """ called before each test from this class """
+        self.o = make_tree(tree)
+
+    def test_generated_html(self):
+        s = html.render_HTML_tree(self.o, selected_node="child_2_2")
+        self.assertTextEqual(s, generated_html)
+
+
+if __name__ == '__main__':
+    unittest_main()

data/tools/common/common/test/unittest_interface.py

@@ -0,0 +1,87 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common 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 Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+from logilab.common.testlib import TestCase, unittest_main
+from logilab.common.interface import *
+
+class IFace1(Interface): pass
+class IFace2(Interface): pass
+class IFace3(Interface): pass
+
+
+class A(object):
+    __implements__ = (IFace1,)
+
+
+class B(A): pass
+
+
+class C1(B):
+    __implements__ = list(B.__implements__) + [IFace3]
+
+class C2(B):
+    __implements__ = B.__implements__ + (IFace2,)
+
+class D(C1):
+    __implements__ = ()
+
+class Z(object): pass
+
+class ExtendTC(TestCase):
+
+    def setUp(self):
+        global aimpl, c1impl, c2impl, dimpl
+        aimpl = A.__implements__
+        c1impl = C1.__implements__
+        c2impl = C2.__implements__
+        dimpl = D.__implements__
+
+    def test_base(self):
+        extend(A, IFace2)
+        self.failUnlessEqual(A.__implements__, (IFace1, IFace2))
+        self.failUnlessEqual(B.__implements__, (IFace1, IFace2))
+        self.failUnless(B.__implements__ is A.__implements__)
+        self.failUnlessEqual(C1.__implements__, [IFace1, IFace3, IFace2])
+        self.failUnlessEqual(C2.__implements__, (IFace1, IFace2))
+        self.failUnless(C2.__implements__ is c2impl)
+        self.failUnlessEqual(D.__implements__, (IFace2,))
+
+    def test_already_impl(self):
+        extend(A, IFace1)
+        self.failUnless(A.__implements__ is aimpl)
+
+    def test_no_impl(self):
+        extend(Z, IFace1)
+        self.failUnlessEqual(Z.__implements__, (IFace1,))
+
+    def test_notimpl_explicit(self):
+        extend(C1, IFace3)
+        self.failUnless(C1.__implements__ is c1impl)
+        self.failUnless(D.__implements__ is dimpl)
+
+
+    def test_nonregr_implements_baseinterface(self):
+        class SubIFace(IFace1): pass
+        class X(object):
+            __implements__ = (SubIFace,)
+
+        self.failUnless(SubIFace.is_implemented_by(X))
+        self.failUnless(IFace1.is_implemented_by(X))
+
+
+if __name__ == '__main__':
+    unittest_main()