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 test_create_default(self):
  12         self.assertEqual(self._clock.name, 'salut')
  13
  14     def test_create_invalid_no_name(self):
  15         with self.assertRaises(TypeError):
  16             bt2.CtfWriterClock()
  17
  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))
  31
  32     def test_assign_description(self):
  33         self._clock.description = 'hi people'
  34         self.assertEqual(self._clock.description, 'hi people')
  35
  36     def test_assign_invalid_description(self):
  37         with self.assertRaises(TypeError):
  38             self._clock.description = 23
  39
  40     def test_assign_frequency(self):
  41         self._clock.frequency = 987654321
  42         self.assertEqual(self._clock.frequency, 987654321)
  43
  44     def test_assign_invalid_frequency(self):
  45         with self.assertRaises(TypeError):
  46             self._clock.frequency = 'lel'
  47
  48     def test_assign_precision(self):
  49         self._clock.precision = 12
  50         self.assertEqual(self._clock.precision, 12)
  51
  52     def test_assign_invalid_precision(self):
  53         with self.assertRaises(TypeError):
  54             self._clock.precision = 'lel'
  55
  56     def test_assign_offset(self):
  57         self._clock.offset = bt2.ClockClassOffset(12, 56)
  58         self.assertEqual(self._clock.offset, bt2.ClockClassOffset(12, 56))
  59
  60     def test_assign_invalid_offset(self):
  61         with self.assertRaises(TypeError):
  62             self._clock.offset = object()
  63
  64     def test_assign_absolute(self):
  65         self._clock.is_absolute = True
  66         self.assertTrue(self._clock.is_absolute)
  67
  68     def test_assign_invalid_absolute(self):
  69         with self.assertRaises(TypeError):
  70             self._clock.is_absolute = 23
  71
  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)
  76
  77     def test_assign_invalid_uuid(self):
  78         with self.assertRaises(TypeError):
  79             self._clock.uuid = object()
  80
  81     def test_assign_time(self):
  82         self._clock.time = 41232
  83
  84     def test_assign_invalid_time(self):
  85         with self.assertRaises(TypeError):
  86             self._clock.time = object()
  87
  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)
  92
  93     def test_copy(self):
  94         cpy = copy.copy(self._clock)
  95         self._test_copy(cpy)
  96
  97     def test_deepcopy(self):
  98         cpy = copy.deepcopy(self._clock)
  99         self._test_copy(cpy)
 100
 101     def test_eq(self):
 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)
 112
 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)
 124
 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)
 136
 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)
 148
 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)
 160
 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)
 172
 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)
 184
 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)
 195
 196     def test_eq_invalid(self):
 197         self.assertFalse(self._clock == 23)