diff options
Diffstat (limited to 'test')
| -rw-r--r-- | test/tc_direction.py | 80 | ||||
| -rw-r--r-- | test/tc_signal.py | 134 |
2 files changed, 214 insertions, 0 deletions
diff --git a/test/tc_direction.py b/test/tc_direction.py new file mode 100644 index 00000000..f1078b2d --- /dev/null +++ b/test/tc_direction.py @@ -0,0 +1,80 @@ +# Copyright (C) 2009, 2010 Roman Zimbelmann <romanz@lavabit.com> +# +# 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, see <http://www.gnu.org/licenses/>. + +if __name__ == '__main__': from __init__ import init; init() + +import unittest +from ranger.ext.direction import Direction +from ranger.ext.openstruct import OpenStruct + +class TestDirections(unittest.TestCase): + def test_symmetry(self): + d1 = Direction(right=4, down=7, relative=True) + d2 = Direction(left=-4, up=-7, absolute=False) + + def subtest(d): + self.assertEqual(4, d.right()) + self.assertEqual(7, d.down()) + self.assertEqual(-4, d.left()) + self.assertEqual(-7, d.up()) + self.assertEqual(True, d.relative()) + self.assertEqual(False, d.absolute()) + + self.assertTrue(d.horizontal()) + self.assertTrue(d.vertical()) + + subtest(d1) + subtest(d2) + + def test_conflicts(self): + d3 = Direction(right=5, left=2, up=3, down=6, + absolute=True, relative=True) + self.assertEqual(d3.right(), -d3.left()) + self.assertEqual(d3.left(), -d3.right()) + self.assertEqual(d3.up(), -d3.down()) + self.assertEqual(d3.down(), -d3.up()) + self.assertEqual(d3.absolute(), not d3.relative()) + self.assertEqual(d3.relative(), not d3.absolute()) + + def test_copy(self): + d = Direction(right=5) + c = d.copy() + self.assertEqual(c.right(), d.right()) + d['right'] += 3 + self.assertNotEqual(c.right(), d.right()) + c['right'] += 3 + self.assertEqual(c.right(), d.right()) + + self.assertFalse(d.vertical()) + self.assertTrue(d.horizontal()) + + def test_duck_typing(self): + dct = dict(right=7, down=-3) + self.assertEqual(-7, Direction.left(dct)) + self.assertEqual(3, Direction.up(dct)) + + def test_move(self): + d = Direction(pages=True) + self.assertEqual(3, d.move(direction=3)) + self.assertEqual(5, d.move(direction=3, current=2)) + self.assertEqual(15, d.move(direction=3, pagesize=5)) + self.assertEqual(10, d.move(direction=3, pagesize=5, maximum=10)) + self.assertEqual(18, d.move(direction=9, override=2)) + d2 = Direction(absolute=True) + self.assertEqual(5, d2.move(direction=9, override=5)) + +if __name__ == '__main__': + unittest.main() + diff --git a/test/tc_signal.py b/test/tc_signal.py new file mode 100644 index 00000000..35b4eebe --- /dev/null +++ b/test/tc_signal.py @@ -0,0 +1,134 @@ +# Copyright (C) 2009, 2010 Roman Zimbelmann <romanz@lavabit.com> +# +# 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, see <http://www.gnu.org/licenses/>. + +if __name__ == '__main__': from __init__ import init; init() +import unittest +import gc +from ranger.ext.signal_dispatcher import * + +class TestSignal(unittest.TestCase): + def setUp(self): + self.sd = SignalDispatcher() + + def test_signal_register_emit(self): + sd = self.sd + def poo(sig): + self.assert_('works' in sig) + self.assertEqual('yes', sig.works) + handler = sd.signal_bind('x', poo) + + sd.signal_emit('x', works='yes') + sd.signal_unbind(handler) + sd.signal_emit('x') + + def test_signal_order(self): + sd = self.sd + lst = [] + def addn(n): + return lambda _: lst.append(n) + + sd.signal_bind('x', addn(6)) + sd.signal_bind('x', addn(3), priority=1) + sd.signal_bind('x', addn(2), priority=1) + sd.signal_bind('x', addn(9), priority=0) + sd.signal_bind('x', addn(1337), priority=0.7) + sd.signal_emit('x') + + self.assert_(lst.index(3) < lst.index(6)) + self.assert_(lst.index(2) < lst.index(6)) + self.assert_(lst.index(6) < lst.index(9)) + self.assert_(lst.index(1337) < lst.index(6)) + self.assert_(lst.index(1337) < lst.index(9)) + self.assert_(lst.index(1337) > lst.index(2)) + + def test_modifying_arguments(self): + sd = self.sd + lst = [] + def modify(s): + s.number = 5 + def set_number(s): + lst.append(s.number) + def stopit(s): + s.stop() + + sd.signal_bind('setnumber', set_number) + sd.signal_emit('setnumber', number=100) + self.assertEqual(100, lst[-1]) + + sd.signal_bind('setnumber', modify, priority=1) + sd.signal_emit('setnumber', number=100) + self.assertEqual(5, lst[-1]) + + lst.append(None) + sd.signal_bind('setnumber', stopit, priority=1) + sd.signal_emit('setnumber', number=100) + self.assertEqual(None, lst[-1]) + + def test_weak_refs(self): + sd = self.sd + is_deleted = [False] + + class Foo(object): + def __init__(self): + self.alphabet = ['a'] + def calc(self, signal): + self.alphabet.append(chr(ord(self.alphabet[-1]) + 1)) + def __del__(self): + is_deleted[0] = True + + foo = Foo() + alphabet = foo.alphabet + calc = foo.calc + + del foo + self.assertEqual('a', ''.join(alphabet)) + sd.signal_bind('mysignal', calc, weak=True) + sd.signal_emit('mysignal') + self.assertEqual('ab', ''.join(alphabet)) + self.assertFalse(is_deleted[0]) + + del calc + self.assertTrue(is_deleted[0]) + + def test_weak_refs_dead_on_arrival(self): + sd = self.sd + is_deleted = [False] + + class Foo(object): + def __init__(self): + self.alphabet = ['a'] + def calc(self, signal): + self.alphabet.append(chr(ord(self.alphabet[-1]) + 1)) + def __del__(self): + is_deleted[0] = True + + foo = Foo() + alphabet = foo.alphabet + + self.assertEqual('a', ''.join(alphabet)) + sd.signal_bind('mysignal', foo.calc, weak=True) + + sd.signal_emit('mysignal') + self.assertEqual('ab', ''.join(alphabet)) + self.assertFalse(is_deleted[0]) + + del foo + + sd.signal_emit('mysignal') + self.assertEqual('ab', ''.join(alphabet)) + self.assertTrue(is_deleted[0]) + +if __name__ == '__main__': + unittest.main() |