← Back to branch summary

~jaap.karssenberg/zim/pyzim-gtk3

« back to all changes in this revision

Viewing changes to tests/utils.py

  • Committer: Jaap Karssenberg
  • Date: 2014-03-08 11:47:43 UTC
  • mfrom: (668.1.49 pyzim-refactor)
  • Revision ID: jaap.karssenberg@gmail.com-20140308114743-fero6uvy9zirbb4o
Merge branch with refactoring

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/utils.py
 
1
# -*- coding: utf-8 -*-
 
2
 
 
3
# Copyright 2012-2013 Jaap Karssenberg <jaap.karssenberg@gmail.com>
 
4
 
1
5
 
2
6
import tests
3
7
 
33
37
                result = natural_sorted(input, key=lambda t: t[1])
34
38
                self.assertEqual(result, wanted)
35
39
                self.assertTrue(id(result) != id(input))
 
40
 
 
41
 
 
42
class TestOrderedDict(tests.TestCase):
 
43
 
 
44
        def runTest(self):
 
45
                items = [('foo', 1), ('bar', 2), ('baz', 3)]
 
46
                mydict = OrderedDict(items)
 
47
 
 
48
                self.assertIsInstance(repr(mydict), str)
 
49
 
 
50
                self.assertEqual(mydict.items(), items)
 
51
                self.assertEqual(list(mydict), [i[0] for i in items])
 
52
                self.assertEqual(mydict.keys(), [i[0] for i in items])
 
53
 
 
54
                mydict['bar'] = 'X'
 
55
                mydict.setdefault('foo', 'dus')
 
56
                items = [('foo', 1), ('bar', 'X'), ('baz', 3)]
 
57
                self.assertEqual(mydict.items(), items)
 
58
                self.assertEqual(list(mydict), [i[0] for i in items])
 
59
                self.assertEqual(mydict.keys(), [i[0] for i in items])
 
60
 
 
61
                del mydict['bar']
 
62
                mydict['bar'] = 'Y'
 
63
                items = [('foo', 1), ('baz', 3), ('bar', 'Y')]
 
64
                self.assertEqual(mydict.items(), items)
 
65
                self.assertEqual(list(mydict), [i[0] for i in items])
 
66
                self.assertEqual(mydict.keys(), [i[0] for i in items])
 
67
 
 
68
                mydict.pop('foo')
 
69
                mydict.setdefault('foo', 'dus')
 
70
                items = [('baz', 3), ('bar', 'Y'), ('foo', 'dus')]
 
71
                self.assertEqual(mydict.items(), items)
 
72
                self.assertEqual(list(mydict), [i[0] for i in items])
 
73
                self.assertEqual(mydict.keys(), [i[0] for i in items])
 
74
 
 
75
 
 
76
import threading
 
77
 
 
78
class TestFunctionThread(tests.TestCase):
 
79
 
 
80
        def runTest(self):
 
81
 
 
82
                def foo(*args):
 
83
                        return 'FOO: ' + ', '.join(args)
 
84
 
 
85
                # Function OK, no lock
 
86
                func = FunctionThread(foo, ('a', 'b', 'c'))
 
87
                self.assertFalse(func.done)
 
88
                func.start()
 
89
 
 
90
                func.join()
 
91
                self.assertTrue(func.done)
 
92
                self.assertFalse(func.error)
 
93
                self.assertEqual(func.result, 'FOO: a, b, c')
 
94
 
 
95
                # Function OK, with lock
 
96
                lock = threading.Lock()
 
97
 
 
98
                func = FunctionThread(foo, ('a', 'b', 'c'), lock=lock)
 
99
                self.assertFalse(func.done)
 
100
                func.start()
 
101
 
 
102
                lock.acquire()
 
103
                self.assertTrue(func.done)
 
104
                self.assertFalse(func.error)
 
105
                self.assertEqual(func.result, 'FOO: a, b, c')
 
106
 
 
107
                ###
 
108
 
 
109
                def error(*args):
 
110
                        raise AssertionError, 'FOO'
 
111
 
 
112
                # Function raises, no lock
 
113
                func = FunctionThread(error, ('a', 'b', 'c'))
 
114
                self.assertFalse(func.done)
 
115
                func.start()
 
116
 
 
117
                func.join()
 
118
                self.assertTrue(func.done)
 
119
                self.assertTrue(func.error)
 
120
                self.assertEqual(func.exc_info[0], AssertionError)
 
121
 
 
122
                # Function raises, with lock
 
123
                #~ lock = threading.Lock()
 
124
 
 
125
                #~ func = FunctionThread(error, ('a', 'b', 'c'))
 
126
                #~ self.assertFalse(func.done)
 
127
                #~ func.start()
 
128
 
 
129
                #~ lock.acquire()
 
130
                #~ self.assertTrue(func.done)
 
131
                #~ self.assertTrue(func.error)
 
132
                #~ self.assertEqual(func.exc_info[0], AssertionError)