tests/bindings/python/bt2/test_ctf_writer_clock.py

   1 import unittest
   2 import uuid
   3 import copy
   4 import bt2
   5
   6
   7 class CtfWriterClockTestCase(unittest.TestCase):
   8     def setUp(self):
   9         self._clock = bt2.CtfWriterClock('salut')
  10
  11     def tearDown(self):
  12         del self._clock
  13
  14     def test_create_default(self):
  15         self.assertEqual(self._clock.name, 'salut')
  16
  17     def test_create_invalid_no_name(self):
  18         with self.assertRaises(TypeError):
  19             bt2.CtfWriterClock()
  20
  21     def test_create_full(self):
  22         my_uuid = uuid.uuid1()
  23         cc = bt2.CtfWriterClock(name='name', description='some description',
  24                                 frequency=1001, precision=176,
  25                                 offset=bt2.ClockClassOffset(45, 3003),
  26                                 is_absolute=True, uuid=my_uuid)
  27         self.assertEqual(cc.name, 'name')
  28         self.assertEqual(cc.description, 'some description')
  29         self.assertEqual(cc.frequency, 1001)
  30         self.assertEqual(cc.precision, 176)
  31         self.assertEqual(cc.offset, bt2.ClockClassOffset(45, 3003))
  32         self.assertEqual(cc.is_absolute, True)
  33         self.assertEqual(cc.uuid, copy.deepcopy(my_uuid))
  34
  35     def test_assign_description(self):
  36         self._clock.description = 'hi people'
  37         self.assertEqual(self._clock.description, 'hi people')
  38
  39     def test_assign_invalid_description(self):
  40         with self.assertRaises(TypeError):
  41             self._clock.description = 23
  42
  43     def test_assign_frequency(self):
  44         self._clock.frequency = 987654321
  45         self.assertEqual(self._clock.frequency, 987654321)
  46
  47     def test_assign_invalid_frequency(self):
  48         with self.assertRaises(TypeError):
  49             self._clock.frequency = 'lel'
  50
  51     def test_assign_precision(self):
  52         self._clock.precision = 12
  53         self.assertEqual(self._clock.precision, 12)
  54
  55     def test_assign_invalid_precision(self):
  56         with self.assertRaises(TypeError):
  57             self._clock.precision = 'lel'
  58
  59     def test_assign_offset(self):
  60         self._clock.offset = bt2.ClockClassOffset(12, 56)
  61         self.assertEqual(self._clock.offset, bt2.ClockClassOffset(12, 56))
  62
  63     def test_assign_invalid_offset(self):
  64         with self.assertRaises(TypeError):
  65             self._clock.offset = object()
  66
  67     def test_assign_absolute(self):
  68         self._clock.is_absolute = True
  69         self.assertTrue(self._clock.is_absolute)
  70
  71     def test_assign_invalid_absolute(self):
  72         with self.assertRaises(TypeError):
  73             self._clock.is_absolute = 23
  74
  75     def test_assign_uuid(self):
  76         the_uuid = uuid.uuid1()
  77         self._clock.uuid = the_uuid
  78         self.assertEqual(self._clock.uuid, the_uuid)
  79
  80     def test_assign_invalid_uuid(self):
  81         with self.assertRaises(TypeError):
  82             self._clock.uuid = object()
  83
  84     def test_assign_time(self):
  85         self._clock.time = 41232
  86
  87     def test_assign_invalid_time(self):
  88         with self.assertRaises(TypeError):
  89             self._clock.time = object()
  90
  91     def _test_copy(self, cpy):
  92         self.assertIsNot(cpy, self._clock)
  93         self.assertNotEqual(cpy.addr, self._clock.addr)
  94         self.assertEqual(cpy, self._clock)
  95
  96     def test_copy(self):
  97         cpy = copy.copy(self._clock)
  98         self._test_copy(cpy)
  99
 100     def test_deepcopy(self):
 101         cpy = copy.deepcopy(self._clock)
 102         self._test_copy(cpy)
 103
 104     def test_eq(self):
 105         my_uuid = uuid.uuid1()
 106         cc1 = bt2.CtfWriterClock(name='name', description='some description',
 107                                  frequency=1001, precision=176,
 108                                  offset=bt2.ClockClassOffset(45, 3003),
 109                                  is_absolute=True, uuid=my_uuid)
 110         cc2 = bt2.CtfWriterClock(name='name', description='some description',
 111                                  frequency=1001, precision=176,
 112                                  offset=bt2.ClockClassOffset(45, 3003),
 113                                  is_absolute=True, uuid=my_uuid)
 114         self.assertEqual(cc1, cc2)
 115
 116     def test_ne_name(self):
 117         my_uuid = uuid.uuid1()
 118         cc1 = bt2.CtfWriterClock(name='mane', description='some description',
 119                                  frequency=1001, precision=176,
 120                                  offset=bt2.ClockClassOffset(45, 3003),
 121                                  is_absolute=True, uuid=my_uuid)
 122         cc2 = bt2.CtfWriterClock(name='name', description='some description',
 123                                  frequency=1001, precision=176,
 124                                  offset=bt2.ClockClassOffset(45, 3003),
 125                                  is_absolute=True, uuid=my_uuid)
 126         self.assertNotEqual(cc1, cc2)
 127
 128     def test_ne_description(self):
 129         my_uuid = uuid.uuid1()
 130         cc1 = bt2.CtfWriterClock(name='name', description='some descripti2',
 131                                  frequency=1001, precision=176,
 132                                  offset=bt2.ClockClassOffset(45, 3003),
 133                                  is_absolute=True, uuid=my_uuid)
 134         cc2 = bt2.CtfWriterClock(name='name', description='some description',
 135                                  frequency=1001, precision=176,
 136                                  offset=bt2.ClockClassOffset(45, 3003),
 137                                  is_absolute=True, uuid=my_uuid)
 138         self.assertNotEqual(cc1, cc2)
 139
 140     def test_ne_frequency(self):
 141         my_uuid = uuid.uuid1()
 142         cc1 = bt2.CtfWriterClock(name='name', description='some description',
 143                                  frequency=1003, precision=176,
 144                                  offset=bt2.ClockClassOffset(45, 3003),
 145                                  is_absolute=True, uuid=my_uuid)
 146         cc2 = bt2.CtfWriterClock(name='name', description='some description',
 147                                  frequency=1001, precision=176,
 148                                  offset=bt2.ClockClassOffset(45, 3003),
 149                                  is_absolute=True, uuid=my_uuid)
 150         self.assertNotEqual(cc1, cc2)
 151
 152     def test_ne_precision(self):
 153         my_uuid = uuid.uuid1()
 154         cc1 = bt2.CtfWriterClock(name='name', description='some description',
 155                                  frequency=1001, precision=171,
 156                                  offset=bt2.ClockClassOffset(45, 3003),
 157                                  is_absolute=True, uuid=my_uuid)
 158         cc2 = bt2.CtfWriterClock(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.assertNotEqual(cc1, cc2)
 163
 164     def test_ne_offset(self):
 165         my_uuid = uuid.uuid1()
 166         cc1 = bt2.CtfWriterClock(name='name', description='some description',
 167                                  frequency=1001, precision=176,
 168                                  offset=bt2.ClockClassOffset(45, 3001),
 169                                  is_absolute=True, uuid=my_uuid)
 170         cc2 = bt2.CtfWriterClock(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)
 175
 176     def test_ne_absolute(self):
 177         my_uuid = uuid.uuid1()
 178         cc1 = bt2.CtfWriterClock(name='name', description='some description',
 179                                  frequency=1001, precision=176,
 180                                  offset=bt2.ClockClassOffset(45, 3003),
 181                                  is_absolute=True, uuid=my_uuid)
 182         cc2 = bt2.CtfWriterClock(name='name', description='some description',
 183                                  frequency=1001, precision=176,
 184                                  offset=bt2.ClockClassOffset(45, 3003),
 185                                  is_absolute=False, uuid=my_uuid)
 186         self.assertNotEqual(cc1, cc2)
 187
 188     def test_ne_uuid(self):
 189         cc1 = bt2.CtfWriterClock(name='name', description='some description',
 190                                  frequency=1001, precision=176,
 191                                  offset=bt2.ClockClassOffset(45, 3003),
 192                                  is_absolute=True, uuid=uuid.uuid1())
 193         cc2 = bt2.CtfWriterClock(name='name', description='some description',
 194                                  frequency=1001, precision=176,
 195                                  offset=bt2.ClockClassOffset(45, 3003),
 196                                  is_absolute=True, uuid=uuid.uuid1())
 197         self.assertNotEqual(cc1, cc2)
 198
 199     def test_eq_invalid(self):
 200         self.assertFalse(self._clock == 23)