tests/bindings/python/bt2/test_ctf_writer_clock.py

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