c667e4ffab8420fa36b6426188f0656f1038b641
7 class ClockClassOffsetTestCase(unittest
.TestCase
):
8 def test_create_default(self
):
9 cco
= bt2
.ClockClassOffset()
10 self
.assertEqual(cco
.seconds
, 0)
11 self
.assertEqual(cco
.cycles
, 0)
13 def test_create(self
):
14 cco
= bt2
.ClockClassOffset(23, 4871232)
15 self
.assertEqual(cco
.seconds
, 23)
16 self
.assertEqual(cco
.cycles
, 4871232)
18 def test_create_kwargs(self
):
19 cco
= bt2
.ClockClassOffset(seconds
=23, cycles
=4871232)
20 self
.assertEqual(cco
.seconds
, 23)
21 self
.assertEqual(cco
.cycles
, 4871232)
23 def test_create_invalid_seconds(self
):
24 with self
.assertRaises(TypeError):
25 bt2
.ClockClassOffset('hello', 4871232)
27 def test_create_invalid_cycles(self
):
28 with self
.assertRaises(TypeError):
29 bt2
.ClockClassOffset(23, 'hello')
32 cco1
= bt2
.ClockClassOffset(23, 42)
33 cco2
= bt2
.ClockClassOffset(23, 42)
34 self
.assertEqual(cco1
, cco2
)
36 def test_ne_seconds(self
):
37 cco1
= bt2
.ClockClassOffset(23, 42)
38 cco2
= bt2
.ClockClassOffset(24, 42)
39 self
.assertNotEqual(cco1
, cco2
)
41 def test_ne_cycles(self
):
42 cco1
= bt2
.ClockClassOffset(23, 42)
43 cco2
= bt2
.ClockClassOffset(23, 43)
44 self
.assertNotEqual(cco1
, cco2
)
46 def test_eq_invalid(self
):
47 self
.assertFalse(bt2
.ClockClassOffset() == 23)
50 class ClockClassTestCase(unittest
.TestCase
):
52 self
._cc
= bt2
.ClockClass('salut', 1000000)
57 def test_create_default(self
):
58 self
.assertEqual(self
._cc
.name
, 'salut')
60 def test_create_invalid_no_name(self
):
61 with self
.assertRaises(TypeError):
64 def test_create_full(self
):
65 my_uuid
= uuid
.uuid1()
66 cc
= bt2
.ClockClass(name
='name', description
='some description',
67 frequency
=1001, precision
=176,
68 offset
=bt2
.ClockClassOffset(45, 3003),
69 is_absolute
=True, uuid
=my_uuid
)
70 self
.assertEqual(cc
.name
, 'name')
71 self
.assertEqual(cc
.description
, 'some description')
72 self
.assertEqual(cc
.frequency
, 1001)
73 self
.assertEqual(cc
.precision
, 176)
74 self
.assertEqual(cc
.offset
, bt2
.ClockClassOffset(45, 3003))
75 self
.assertEqual(cc
.is_absolute
, True)
76 self
.assertEqual(cc
.uuid
, copy
.deepcopy(my_uuid
))
78 def test_assign_name(self
):
79 self
._cc
.name
= 'the_clock'
80 self
.assertEqual(self
._cc
.name
, 'the_clock')
82 def test_assign_invalid_name(self
):
83 with self
.assertRaises(TypeError):
86 def test_assign_description(self
):
87 self
._cc
.description
= 'hi people'
88 self
.assertEqual(self
._cc
.description
, 'hi people')
90 def test_assign_invalid_description(self
):
91 with self
.assertRaises(TypeError):
92 self
._cc
.description
= 23
94 def test_assign_frequency(self
):
95 self
._cc
.frequency
= 987654321
96 self
.assertEqual(self
._cc
.frequency
, 987654321)
98 def test_assign_invalid_frequency(self
):
99 with self
.assertRaises(TypeError):
100 self
._cc
.frequency
= 'lel'
102 def test_assign_precision(self
):
103 self
._cc
.precision
= 12
104 self
.assertEqual(self
._cc
.precision
, 12)
106 def test_assign_invalid_precision(self
):
107 with self
.assertRaises(TypeError):
108 self
._cc
.precision
= 'lel'
110 def test_assign_offset(self
):
111 self
._cc
.offset
= bt2
.ClockClassOffset(12, 56)
112 self
.assertEqual(self
._cc
.offset
, bt2
.ClockClassOffset(12, 56))
114 def test_assign_invalid_offset(self
):
115 with self
.assertRaises(TypeError):
116 self
._cc
.offset
= object()
118 def test_assign_absolute(self
):
119 self
._cc
.is_absolute
= True
120 self
.assertTrue(self
._cc
.is_absolute
)
122 def test_assign_invalid_absolute(self
):
123 with self
.assertRaises(TypeError):
124 self
._cc
.is_absolute
= 23
126 def test_assign_uuid(self
):
127 the_uuid
= uuid
.uuid1()
128 self
._cc
.uuid
= the_uuid
129 self
.assertEqual(self
._cc
.uuid
, the_uuid
)
131 def test_assign_invalid_uuid(self
):
132 with self
.assertRaises(TypeError):
133 self
._cc
.uuid
= object()
135 def test_create_clock_value(self
):
137 self
.assertEqual(cv
.clock_class
.addr
, self
._cc
.addr
)
139 def _test_copy(self
, cpy
):
140 self
.assertIsNot(cpy
, self
._cc
)
141 self
.assertNotEqual(cpy
.addr
, self
._cc
.addr
)
142 self
.assertEqual(cpy
, self
._cc
)
145 cpy
= copy
.copy(self
._cc
)
148 def test_deepcopy(self
):
149 cpy
= copy
.deepcopy(self
._cc
)
153 my_uuid
= uuid
.uuid1()
154 cc1
= bt2
.ClockClass(name
='name', description
='some description',
155 frequency
=1001, precision
=176,
156 offset
=bt2
.ClockClassOffset(45, 3003),
157 is_absolute
=True, uuid
=my_uuid
)
158 cc2
= bt2
.ClockClass(name
='name', description
='some description',
159 frequency
=1001, precision
=176,
160 offset
=bt2
.ClockClassOffset(45, 3003),
161 is_absolute
=True, uuid
=my_uuid
)
162 self
.assertEqual(cc1
, cc2
)
164 def test_ne_name(self
):
165 my_uuid
= uuid
.uuid1()
166 cc1
= bt2
.ClockClass(name
='mane', description
='some description',
167 frequency
=1001, precision
=176,
168 offset
=bt2
.ClockClassOffset(45, 3003),
169 is_absolute
=True, uuid
=my_uuid
)
170 cc2
= bt2
.ClockClass(name
='name', description
='some description',
171 frequency
=1001, precision
=176,
172 offset
=bt2
.ClockClassOffset(45, 3003),
173 is_absolute
=True, uuid
=my_uuid
)
174 self
.assertNotEqual(cc1
, cc2
)
176 def test_ne_description(self
):
177 my_uuid
= uuid
.uuid1()
178 cc1
= bt2
.ClockClass(name
='name', description
='some descripti2',
179 frequency
=1001, precision
=176,
180 offset
=bt2
.ClockClassOffset(45, 3003),
181 is_absolute
=True, uuid
=my_uuid
)
182 cc2
= bt2
.ClockClass(name
='name', description
='some description',
183 frequency
=1001, precision
=176,
184 offset
=bt2
.ClockClassOffset(45, 3003),
185 is_absolute
=True, uuid
=my_uuid
)
186 self
.assertNotEqual(cc1
, cc2
)
188 def test_ne_frequency(self
):
189 my_uuid
= uuid
.uuid1()
190 cc1
= bt2
.ClockClass(name
='name', description
='some description',
191 frequency
=1003, precision
=176,
192 offset
=bt2
.ClockClassOffset(45, 3003),
193 is_absolute
=True, uuid
=my_uuid
)
194 cc2
= bt2
.ClockClass(name
='name', description
='some description',
195 frequency
=1001, precision
=176,
196 offset
=bt2
.ClockClassOffset(45, 3003),
197 is_absolute
=True, uuid
=my_uuid
)
198 self
.assertNotEqual(cc1
, cc2
)
200 def test_ne_precision(self
):
201 my_uuid
= uuid
.uuid1()
202 cc1
= bt2
.ClockClass(name
='name', description
='some description',
203 frequency
=1001, precision
=171,
204 offset
=bt2
.ClockClassOffset(45, 3003),
205 is_absolute
=True, uuid
=my_uuid
)
206 cc2
= bt2
.ClockClass(name
='name', description
='some description',
207 frequency
=1001, precision
=176,
208 offset
=bt2
.ClockClassOffset(45, 3003),
209 is_absolute
=True, uuid
=my_uuid
)
210 self
.assertNotEqual(cc1
, cc2
)
212 def test_ne_offset(self
):
213 my_uuid
= uuid
.uuid1()
214 cc1
= bt2
.ClockClass(name
='name', description
='some description',
215 frequency
=1001, precision
=176,
216 offset
=bt2
.ClockClassOffset(45, 3001),
217 is_absolute
=True, uuid
=my_uuid
)
218 cc2
= bt2
.ClockClass(name
='name', description
='some description',
219 frequency
=1001, precision
=176,
220 offset
=bt2
.ClockClassOffset(45, 3003),
221 is_absolute
=True, uuid
=my_uuid
)
222 self
.assertNotEqual(cc1
, cc2
)
224 def test_ne_absolute(self
):
225 my_uuid
= uuid
.uuid1()
226 cc1
= bt2
.ClockClass(name
='name', description
='some description',
227 frequency
=1001, precision
=176,
228 offset
=bt2
.ClockClassOffset(45, 3003),
229 is_absolute
=True, uuid
=my_uuid
)
230 cc2
= bt2
.ClockClass(name
='name', description
='some description',
231 frequency
=1001, precision
=176,
232 offset
=bt2
.ClockClassOffset(45, 3003),
233 is_absolute
=False, uuid
=my_uuid
)
234 self
.assertNotEqual(cc1
, cc2
)
236 def test_ne_uuid(self
):
237 cc1
= bt2
.ClockClass(name
='name', description
='some description',
238 frequency
=1001, precision
=176,
239 offset
=bt2
.ClockClassOffset(45, 3003),
240 is_absolute
=True, uuid
=uuid
.uuid1())
241 cc2
= bt2
.ClockClass(name
='name', description
='some description',
242 frequency
=1001, precision
=176,
243 offset
=bt2
.ClockClassOffset(45, 3003),
244 is_absolute
=True, uuid
=uuid
.uuid1())
245 self
.assertNotEqual(cc1
, cc2
)
247 def test_eq_invalid(self
):
248 self
.assertFalse(self
._cc
== 23)
251 class ClockValueTestCase(unittest
.TestCase
):
253 self
._cc
= bt2
.ClockClass('salut', 1000,
254 offset
=bt2
.ClockClassOffset(45, 354))
255 self
._cv
= self
._cc
(123)
261 def test_create_default(self
):
262 self
.assertEqual(self
._cv
.clock_class
.addr
, self
._cc
.addr
)
263 self
.assertEqual(self
._cv
.cycles
, 123)
265 def test_create_invalid_cycles_type(self
):
266 with self
.assertRaises(TypeError):
269 def test_ns_from_epoch(self
):
270 s_from_epoch
= 45 + ((354 + 123) / 1000)
271 ns_from_epoch
= int(s_from_epoch
* 1e9
)
272 self
.assertEqual(self
._cv
.ns_from_epoch
, ns_from_epoch
)
277 self
.assertEqual(cv1
, cv2
)
279 def test_eq_int(self
):
281 self
.assertEqual(cv1
, 123)
283 def test_ne_clock_class(self
):
284 cc1
= bt2
.ClockClass('yes', 1500)
285 cc2
= bt2
.ClockClass('yes', 1501)
288 self
.assertNotEqual(cv1
, cv2
)
290 def test_ne_cycles(self
):
293 self
.assertNotEqual(cv1
, cv2
)
295 def test_eq_invalid(self
):
296 self
.assertFalse(self
._cv
== 23)
298 def _test_copy(self
, cpy
):
299 self
.assertIsNot(cpy
, self
._cv
)
300 self
.assertNotEqual(cpy
.addr
, self
._cv
.addr
)
301 self
.assertEqual(cpy
, self
._cv
)
304 cpy
= copy
.copy(self
._cv
)
307 def test_deepcopy(self
):
308 cpy
= copy
.deepcopy(self
._cv
)
This page took 0.043647 seconds and 4 git commands to generate.