Commit | Line | Data |
---|---|---|
d2d857a8 MJ |
1 | # |
2 | # Copyright (C) 2019 EfficiOS Inc. | |
3 | # | |
4 | # This program is free software; you can redistribute it and/or | |
5 | # modify it under the terms of the GNU General Public License | |
6 | # as published by the Free Software Foundation; only version 2 | |
7 | # of the License. | |
8 | # | |
9 | # This program is distributed in the hope that it will be useful, | |
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | # GNU General Public License for more details. | |
13 | # | |
14 | # You should have received a copy of the GNU General Public License | |
15 | # along with this program; if not, write to the Free Software | |
16 | # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
17 | # | |
18 | ||
9cf643d1 PP |
19 | import unittest |
20 | import uuid | |
21 | import copy | |
22 | import bt2 | |
23 | ||
24 | ||
976c241d | 25 | @unittest.skip("this is broken") |
9cf643d1 PP |
26 | class CtfWriterClockTestCase(unittest.TestCase): |
27 | def setUp(self): | |
28 | self._clock = bt2.CtfWriterClock('salut') | |
29 | ||
811644b8 PP |
30 | def tearDown(self): |
31 | del self._clock | |
32 | ||
9cf643d1 PP |
33 | def test_create_default(self): |
34 | self.assertEqual(self._clock.name, 'salut') | |
35 | ||
36 | def test_create_invalid_no_name(self): | |
37 | with self.assertRaises(TypeError): | |
38 | bt2.CtfWriterClock() | |
39 | ||
40 | def test_create_full(self): | |
41 | my_uuid = uuid.uuid1() | |
cfbd7cf3 FD |
42 | cc = bt2.CtfWriterClock( |
43 | name='name', | |
44 | description='some description', | |
45 | frequency=1001, | |
46 | precision=176, | |
47 | offset=bt2.ClockClassOffset(45, 3003), | |
48 | is_absolute=True, | |
49 | uuid=my_uuid, | |
50 | ) | |
9cf643d1 PP |
51 | self.assertEqual(cc.name, 'name') |
52 | self.assertEqual(cc.description, 'some description') | |
53 | self.assertEqual(cc.frequency, 1001) | |
54 | self.assertEqual(cc.precision, 176) | |
55 | self.assertEqual(cc.offset, bt2.ClockClassOffset(45, 3003)) | |
56 | self.assertEqual(cc.is_absolute, True) | |
57 | self.assertEqual(cc.uuid, copy.deepcopy(my_uuid)) | |
58 | ||
59 | def test_assign_description(self): | |
60 | self._clock.description = 'hi people' | |
61 | self.assertEqual(self._clock.description, 'hi people') | |
62 | ||
63 | def test_assign_invalid_description(self): | |
64 | with self.assertRaises(TypeError): | |
65 | self._clock.description = 23 | |
66 | ||
67 | def test_assign_frequency(self): | |
68 | self._clock.frequency = 987654321 | |
69 | self.assertEqual(self._clock.frequency, 987654321) | |
70 | ||
71 | def test_assign_invalid_frequency(self): | |
72 | with self.assertRaises(TypeError): | |
73 | self._clock.frequency = 'lel' | |
74 | ||
75 | def test_assign_precision(self): | |
76 | self._clock.precision = 12 | |
77 | self.assertEqual(self._clock.precision, 12) | |
78 | ||
79 | def test_assign_invalid_precision(self): | |
80 | with self.assertRaises(TypeError): | |
81 | self._clock.precision = 'lel' | |
82 | ||
83 | def test_assign_offset(self): | |
84 | self._clock.offset = bt2.ClockClassOffset(12, 56) | |
85 | self.assertEqual(self._clock.offset, bt2.ClockClassOffset(12, 56)) | |
86 | ||
87 | def test_assign_invalid_offset(self): | |
88 | with self.assertRaises(TypeError): | |
89 | self._clock.offset = object() | |
90 | ||
91 | def test_assign_absolute(self): | |
92 | self._clock.is_absolute = True | |
93 | self.assertTrue(self._clock.is_absolute) | |
94 | ||
95 | def test_assign_invalid_absolute(self): | |
96 | with self.assertRaises(TypeError): | |
97 | self._clock.is_absolute = 23 | |
98 | ||
99 | def test_assign_uuid(self): | |
100 | the_uuid = uuid.uuid1() | |
101 | self._clock.uuid = the_uuid | |
102 | self.assertEqual(self._clock.uuid, the_uuid) | |
103 | ||
104 | def test_assign_invalid_uuid(self): | |
105 | with self.assertRaises(TypeError): | |
106 | self._clock.uuid = object() | |
107 | ||
108 | def test_assign_time(self): | |
109 | self._clock.time = 41232 | |
110 | ||
111 | def test_assign_invalid_time(self): | |
112 | with self.assertRaises(TypeError): | |
113 | self._clock.time = object() | |
114 | ||
115 | def _test_copy(self, cpy): | |
116 | self.assertIsNot(cpy, self._clock) | |
117 | self.assertNotEqual(cpy.addr, self._clock.addr) | |
118 | self.assertEqual(cpy, self._clock) | |
119 | ||
120 | def test_copy(self): | |
121 | cpy = copy.copy(self._clock) | |
122 | self._test_copy(cpy) | |
123 | ||
124 | def test_deepcopy(self): | |
125 | cpy = copy.deepcopy(self._clock) | |
126 | self._test_copy(cpy) | |
127 | ||
128 | def test_eq(self): | |
129 | my_uuid = uuid.uuid1() | |
cfbd7cf3 FD |
130 | cc1 = bt2.CtfWriterClock( |
131 | name='name', | |
132 | description='some description', | |
133 | frequency=1001, | |
134 | precision=176, | |
135 | offset=bt2.ClockClassOffset(45, 3003), | |
136 | is_absolute=True, | |
137 | uuid=my_uuid, | |
138 | ) | |
139 | cc2 = bt2.CtfWriterClock( | |
140 | name='name', | |
141 | description='some description', | |
142 | frequency=1001, | |
143 | precision=176, | |
144 | offset=bt2.ClockClassOffset(45, 3003), | |
145 | is_absolute=True, | |
146 | uuid=my_uuid, | |
147 | ) | |
9cf643d1 PP |
148 | self.assertEqual(cc1, cc2) |
149 | ||
150 | def test_ne_name(self): | |
151 | my_uuid = uuid.uuid1() | |
cfbd7cf3 FD |
152 | cc1 = bt2.CtfWriterClock( |
153 | name='mane', | |
154 | description='some description', | |
155 | frequency=1001, | |
156 | precision=176, | |
157 | offset=bt2.ClockClassOffset(45, 3003), | |
158 | is_absolute=True, | |
159 | uuid=my_uuid, | |
160 | ) | |
161 | cc2 = bt2.CtfWriterClock( | |
162 | name='name', | |
163 | description='some description', | |
164 | frequency=1001, | |
165 | precision=176, | |
166 | offset=bt2.ClockClassOffset(45, 3003), | |
167 | is_absolute=True, | |
168 | uuid=my_uuid, | |
169 | ) | |
9cf643d1 PP |
170 | self.assertNotEqual(cc1, cc2) |
171 | ||
172 | def test_ne_description(self): | |
173 | my_uuid = uuid.uuid1() | |
cfbd7cf3 FD |
174 | cc1 = bt2.CtfWriterClock( |
175 | name='name', | |
176 | description='some descripti2', | |
177 | frequency=1001, | |
178 | precision=176, | |
179 | offset=bt2.ClockClassOffset(45, 3003), | |
180 | is_absolute=True, | |
181 | uuid=my_uuid, | |
182 | ) | |
183 | cc2 = bt2.CtfWriterClock( | |
184 | name='name', | |
185 | description='some description', | |
186 | frequency=1001, | |
187 | precision=176, | |
188 | offset=bt2.ClockClassOffset(45, 3003), | |
189 | is_absolute=True, | |
190 | uuid=my_uuid, | |
191 | ) | |
9cf643d1 PP |
192 | self.assertNotEqual(cc1, cc2) |
193 | ||
194 | def test_ne_frequency(self): | |
195 | my_uuid = uuid.uuid1() | |
cfbd7cf3 FD |
196 | cc1 = bt2.CtfWriterClock( |
197 | name='name', | |
198 | description='some description', | |
199 | frequency=1003, | |
200 | precision=176, | |
201 | offset=bt2.ClockClassOffset(45, 3003), | |
202 | is_absolute=True, | |
203 | uuid=my_uuid, | |
204 | ) | |
205 | cc2 = bt2.CtfWriterClock( | |
206 | name='name', | |
207 | description='some description', | |
208 | frequency=1001, | |
209 | precision=176, | |
210 | offset=bt2.ClockClassOffset(45, 3003), | |
211 | is_absolute=True, | |
212 | uuid=my_uuid, | |
213 | ) | |
9cf643d1 PP |
214 | self.assertNotEqual(cc1, cc2) |
215 | ||
216 | def test_ne_precision(self): | |
217 | my_uuid = uuid.uuid1() | |
cfbd7cf3 FD |
218 | cc1 = bt2.CtfWriterClock( |
219 | name='name', | |
220 | description='some description', | |
221 | frequency=1001, | |
222 | precision=171, | |
223 | offset=bt2.ClockClassOffset(45, 3003), | |
224 | is_absolute=True, | |
225 | uuid=my_uuid, | |
226 | ) | |
227 | cc2 = bt2.CtfWriterClock( | |
228 | name='name', | |
229 | description='some description', | |
230 | frequency=1001, | |
231 | precision=176, | |
232 | offset=bt2.ClockClassOffset(45, 3003), | |
233 | is_absolute=True, | |
234 | uuid=my_uuid, | |
235 | ) | |
9cf643d1 PP |
236 | self.assertNotEqual(cc1, cc2) |
237 | ||
238 | def test_ne_offset(self): | |
239 | my_uuid = uuid.uuid1() | |
cfbd7cf3 FD |
240 | cc1 = bt2.CtfWriterClock( |
241 | name='name', | |
242 | description='some description', | |
243 | frequency=1001, | |
244 | precision=176, | |
245 | offset=bt2.ClockClassOffset(45, 3001), | |
246 | is_absolute=True, | |
247 | uuid=my_uuid, | |
248 | ) | |
249 | cc2 = bt2.CtfWriterClock( | |
250 | name='name', | |
251 | description='some description', | |
252 | frequency=1001, | |
253 | precision=176, | |
254 | offset=bt2.ClockClassOffset(45, 3003), | |
255 | is_absolute=True, | |
256 | uuid=my_uuid, | |
257 | ) | |
9cf643d1 PP |
258 | self.assertNotEqual(cc1, cc2) |
259 | ||
260 | def test_ne_absolute(self): | |
261 | my_uuid = uuid.uuid1() | |
cfbd7cf3 FD |
262 | cc1 = bt2.CtfWriterClock( |
263 | name='name', | |
264 | description='some description', | |
265 | frequency=1001, | |
266 | precision=176, | |
267 | offset=bt2.ClockClassOffset(45, 3003), | |
268 | is_absolute=True, | |
269 | uuid=my_uuid, | |
270 | ) | |
271 | cc2 = bt2.CtfWriterClock( | |
272 | name='name', | |
273 | description='some description', | |
274 | frequency=1001, | |
275 | precision=176, | |
276 | offset=bt2.ClockClassOffset(45, 3003), | |
277 | is_absolute=False, | |
278 | uuid=my_uuid, | |
279 | ) | |
9cf643d1 PP |
280 | self.assertNotEqual(cc1, cc2) |
281 | ||
282 | def test_ne_uuid(self): | |
cfbd7cf3 FD |
283 | cc1 = bt2.CtfWriterClock( |
284 | name='name', | |
285 | description='some description', | |
286 | frequency=1001, | |
287 | precision=176, | |
288 | offset=bt2.ClockClassOffset(45, 3003), | |
289 | is_absolute=True, | |
290 | uuid=uuid.uuid1(), | |
291 | ) | |
292 | cc2 = bt2.CtfWriterClock( | |
293 | name='name', | |
294 | description='some description', | |
295 | frequency=1001, | |
296 | precision=176, | |
297 | offset=bt2.ClockClassOffset(45, 3003), | |
298 | is_absolute=True, | |
299 | uuid=uuid.uuid1(), | |
300 | ) | |
9cf643d1 PP |
301 | self.assertNotEqual(cc1, cc2) |
302 | ||
303 | def test_eq_invalid(self): | |
304 | self.assertFalse(self._clock == 23) |