7 class CtfWriterClockTestCase(unittest
.TestCase
):
9 self
._clock
= bt2
.CtfWriterClock('salut')
11 def test_create_default(self
):
12 self
.assertEqual(self
._clock
.name
, 'salut')
14 def test_create_invalid_no_name(self
):
15 with self
.assertRaises(TypeError):
18 def test_create_full(self
):
19 my_uuid
= uuid
.uuid1()
20 cc
= bt2
.CtfWriterClock(name
='name', description
='some description',
21 frequency
=1001, precision
=176,
22 offset
=bt2
.ClockClassOffset(45, 3003),
23 is_absolute
=True, uuid
=my_uuid
)
24 self
.assertEqual(cc
.name
, 'name')
25 self
.assertEqual(cc
.description
, 'some description')
26 self
.assertEqual(cc
.frequency
, 1001)
27 self
.assertEqual(cc
.precision
, 176)
28 self
.assertEqual(cc
.offset
, bt2
.ClockClassOffset(45, 3003))
29 self
.assertEqual(cc
.is_absolute
, True)
30 self
.assertEqual(cc
.uuid
, copy
.deepcopy(my_uuid
))
32 def test_assign_description(self
):
33 self
._clock
.description
= 'hi people'
34 self
.assertEqual(self
._clock
.description
, 'hi people')
36 def test_assign_invalid_description(self
):
37 with self
.assertRaises(TypeError):
38 self
._clock
.description
= 23
40 def test_assign_frequency(self
):
41 self
._clock
.frequency
= 987654321
42 self
.assertEqual(self
._clock
.frequency
, 987654321)
44 def test_assign_invalid_frequency(self
):
45 with self
.assertRaises(TypeError):
46 self
._clock
.frequency
= 'lel'
48 def test_assign_precision(self
):
49 self
._clock
.precision
= 12
50 self
.assertEqual(self
._clock
.precision
, 12)
52 def test_assign_invalid_precision(self
):
53 with self
.assertRaises(TypeError):
54 self
._clock
.precision
= 'lel'
56 def test_assign_offset(self
):
57 self
._clock
.offset
= bt2
.ClockClassOffset(12, 56)
58 self
.assertEqual(self
._clock
.offset
, bt2
.ClockClassOffset(12, 56))
60 def test_assign_invalid_offset(self
):
61 with self
.assertRaises(TypeError):
62 self
._clock
.offset
= object()
64 def test_assign_absolute(self
):
65 self
._clock
.is_absolute
= True
66 self
.assertTrue(self
._clock
.is_absolute
)
68 def test_assign_invalid_absolute(self
):
69 with self
.assertRaises(TypeError):
70 self
._clock
.is_absolute
= 23
72 def test_assign_uuid(self
):
73 the_uuid
= uuid
.uuid1()
74 self
._clock
.uuid
= the_uuid
75 self
.assertEqual(self
._clock
.uuid
, the_uuid
)
77 def test_assign_invalid_uuid(self
):
78 with self
.assertRaises(TypeError):
79 self
._clock
.uuid
= object()
81 def test_assign_time(self
):
82 self
._clock
.time
= 41232
84 def test_assign_invalid_time(self
):
85 with self
.assertRaises(TypeError):
86 self
._clock
.time
= object()
88 def _test_copy(self
, cpy
):
89 self
.assertIsNot(cpy
, self
._clock
)
90 self
.assertNotEqual(cpy
.addr
, self
._clock
.addr
)
91 self
.assertEqual(cpy
, self
._clock
)
94 cpy
= copy
.copy(self
._clock
)
97 def test_deepcopy(self
):
98 cpy
= copy
.deepcopy(self
._clock
)
102 my_uuid
= uuid
.uuid1()
103 cc1
= bt2
.CtfWriterClock(name
='name', description
='some description',
104 frequency
=1001, precision
=176,
105 offset
=bt2
.ClockClassOffset(45, 3003),
106 is_absolute
=True, uuid
=my_uuid
)
107 cc2
= bt2
.CtfWriterClock(name
='name', description
='some description',
108 frequency
=1001, precision
=176,
109 offset
=bt2
.ClockClassOffset(45, 3003),
110 is_absolute
=True, uuid
=my_uuid
)
111 self
.assertEqual(cc1
, cc2
)
113 def test_ne_name(self
):
114 my_uuid
= uuid
.uuid1()
115 cc1
= bt2
.CtfWriterClock(name
='mane', description
='some description',
116 frequency
=1001, precision
=176,
117 offset
=bt2
.ClockClassOffset(45, 3003),
118 is_absolute
=True, uuid
=my_uuid
)
119 cc2
= bt2
.CtfWriterClock(name
='name', description
='some description',
120 frequency
=1001, precision
=176,
121 offset
=bt2
.ClockClassOffset(45, 3003),
122 is_absolute
=True, uuid
=my_uuid
)
123 self
.assertNotEqual(cc1
, cc2
)
125 def test_ne_description(self
):
126 my_uuid
= uuid
.uuid1()
127 cc1
= bt2
.CtfWriterClock(name
='name', description
='some descripti2',
128 frequency
=1001, precision
=176,
129 offset
=bt2
.ClockClassOffset(45, 3003),
130 is_absolute
=True, uuid
=my_uuid
)
131 cc2
= bt2
.CtfWriterClock(name
='name', description
='some description',
132 frequency
=1001, precision
=176,
133 offset
=bt2
.ClockClassOffset(45, 3003),
134 is_absolute
=True, uuid
=my_uuid
)
135 self
.assertNotEqual(cc1
, cc2
)
137 def test_ne_frequency(self
):
138 my_uuid
= uuid
.uuid1()
139 cc1
= bt2
.CtfWriterClock(name
='name', description
='some description',
140 frequency
=1003, precision
=176,
141 offset
=bt2
.ClockClassOffset(45, 3003),
142 is_absolute
=True, uuid
=my_uuid
)
143 cc2
= bt2
.CtfWriterClock(name
='name', description
='some description',
144 frequency
=1001, precision
=176,
145 offset
=bt2
.ClockClassOffset(45, 3003),
146 is_absolute
=True, uuid
=my_uuid
)
147 self
.assertNotEqual(cc1
, cc2
)
149 def test_ne_precision(self
):
150 my_uuid
= uuid
.uuid1()
151 cc1
= bt2
.CtfWriterClock(name
='name', description
='some description',
152 frequency
=1001, precision
=171,
153 offset
=bt2
.ClockClassOffset(45, 3003),
154 is_absolute
=True, uuid
=my_uuid
)
155 cc2
= bt2
.CtfWriterClock(name
='name', description
='some description',
156 frequency
=1001, precision
=176,
157 offset
=bt2
.ClockClassOffset(45, 3003),
158 is_absolute
=True, uuid
=my_uuid
)
159 self
.assertNotEqual(cc1
, cc2
)
161 def test_ne_offset(self
):
162 my_uuid
= uuid
.uuid1()
163 cc1
= bt2
.CtfWriterClock(name
='name', description
='some description',
164 frequency
=1001, precision
=176,
165 offset
=bt2
.ClockClassOffset(45, 3001),
166 is_absolute
=True, uuid
=my_uuid
)
167 cc2
= bt2
.CtfWriterClock(name
='name', description
='some description',
168 frequency
=1001, precision
=176,
169 offset
=bt2
.ClockClassOffset(45, 3003),
170 is_absolute
=True, uuid
=my_uuid
)
171 self
.assertNotEqual(cc1
, cc2
)
173 def test_ne_absolute(self
):
174 my_uuid
= uuid
.uuid1()
175 cc1
= bt2
.CtfWriterClock(name
='name', description
='some description',
176 frequency
=1001, precision
=176,
177 offset
=bt2
.ClockClassOffset(45, 3003),
178 is_absolute
=True, uuid
=my_uuid
)
179 cc2
= bt2
.CtfWriterClock(name
='name', description
='some description',
180 frequency
=1001, precision
=176,
181 offset
=bt2
.ClockClassOffset(45, 3003),
182 is_absolute
=False, uuid
=my_uuid
)
183 self
.assertNotEqual(cc1
, cc2
)
185 def test_ne_uuid(self
):
186 cc1
= bt2
.CtfWriterClock(name
='name', description
='some description',
187 frequency
=1001, precision
=176,
188 offset
=bt2
.ClockClassOffset(45, 3003),
189 is_absolute
=True, uuid
=uuid
.uuid1())
190 cc2
= bt2
.CtfWriterClock(name
='name', description
='some description',
191 frequency
=1001, precision
=176,
192 offset
=bt2
.ClockClassOffset(45, 3003),
193 is_absolute
=True, uuid
=uuid
.uuid1())
194 self
.assertNotEqual(cc1
, cc2
)
196 def test_eq_invalid(self
):
197 self
.assertFalse(self
._clock
== 23)
This page took 0.043096 seconds and 5 git commands to generate.