tests/bindings/python/bt2/test_stream_class.py

   1 from bt2 import values
   2 import unittest
   3 import copy
   4 import bt2
   5
   6
   7 class StreamClassTestCase(unittest.TestCase):
   8     def setUp(self):
   9         self._packet_context_ft = bt2.StructureFieldType()
  10         self._packet_context_ft.append_field('menu', bt2.FloatingPointNumberFieldType())
  11         self._packet_context_ft.append_field('sticker', bt2.StringFieldType())
  12         self._event_header_ft = bt2.StructureFieldType()
  13         self._event_header_ft.append_field('id', bt2.IntegerFieldType(19))
  14         self._event_context_ft = bt2.StructureFieldType()
  15         self._event_context_ft.append_field('msg', bt2.StringFieldType())
  16         self._ec1, self._ec2 = self._create_event_classes()
  17         self._sc = bt2.StreamClass(name='my_stream_class', id=12,
  18                                    packet_context_field_type=self._packet_context_ft,
  19                                    event_header_field_type=self._event_header_ft,
  20                                    event_context_field_type=self._event_context_ft,
  21                                    event_classes=(self._ec1, self._ec2))
  22
  23     def tearDown(self):
  24         del self._packet_context_ft
  25         del self._event_header_ft
  26         del self._event_context_ft
  27         del self._ec1
  28         del self._sc
  29
  30     def _create_event_classes(self):
  31         context_ft = bt2.StructureFieldType()
  32         context_ft.append_field('allo', bt2.StringFieldType())
  33         context_ft.append_field('zola', bt2.IntegerFieldType(18))
  34         payload_ft = bt2.StructureFieldType()
  35         payload_ft.append_field('zoom', bt2.StringFieldType())
  36         ec1 = bt2.EventClass('event23', id=23, context_field_type=context_ft,
  37                              payload_field_type=payload_ft)
  38         ec2 = bt2.EventClass('event17', id=17, context_field_type=payload_ft,
  39                              payload_field_type=context_ft)
  40         return ec1, ec2
  41
  42     def test_create(self):
  43         self.assertEqual(self._sc.name, 'my_stream_class')
  44         self.assertEqual(self._sc.id, 12)
  45         self.assertEqual(self._sc.packet_context_field_type, self._packet_context_ft)
  46         self.assertEqual(self._sc.event_header_field_type, self._event_header_ft)
  47         self.assertEqual(self._sc.event_context_field_type, self._event_context_ft)
  48         self.assertEqual(self._sc[23], self._ec1)
  49         self.assertEqual(self._sc[17], self._ec2)
  50         self.assertEqual(len(self._sc), 2)
  51
  52     def test_assign_name(self):
  53         self._sc.name = 'lel'
  54         self.assertEqual(self._sc.name, 'lel')
  55
  56     def test_assign_invalid_name(self):
  57         with self.assertRaises(TypeError):
  58             self._sc.name = 17
  59
  60     def test_assign_id(self):
  61         self._sc.id = 1717
  62         self.assertEqual(self._sc.id, 1717)
  63
  64     def test_assign_invalid_id(self):
  65         with self.assertRaises(TypeError):
  66             self._sc.id = 'lel'
  67
  68     def test_no_id(self):
  69         sc = bt2.StreamClass()
  70         self.assertIsNone(sc.id)
  71
  72     def test_assign_packet_context_field_type(self):
  73         self._sc.packet_context_field_type = self._event_context_ft
  74         self.assertEqual(self._sc.packet_context_field_type, self._event_context_ft)
  75
  76     def test_assign_no_packet_context_field_type(self):
  77         self._sc.packet_context_field_type = None
  78         self.assertIsNone(self._sc.packet_context_field_type)
  79
  80     def test_assign_invalid_packet_context_field_type(self):
  81         with self.assertRaises(TypeError):
  82             self._sc.packet_context_field_type = 'lel'
  83
  84     def test_assign_event_header_field_type(self):
  85         self._sc.event_header_field_type = self._event_header_ft
  86         self.assertEqual(self._sc.event_header_field_type, self._event_header_ft)
  87
  88     def test_assign_no_event_header_field_type(self):
  89         self._sc.event_header_field_type = None
  90         self.assertIsNone(self._sc.event_header_field_type)
  91
  92     def test_assign_invalid_event_header_field_type(self):
  93         with self.assertRaises(TypeError):
  94             self._sc.event_header_field_type = 'lel'
  95
  96     def test_assign_event_context_field_type(self):
  97         self._sc.event_context_field_type = self._packet_context_ft
  98         self.assertEqual(self._sc.event_context_field_type, self._packet_context_ft)
  99
 100     def test_assign_no_event_context_field_type(self):
 101         self._sc.event_context_field_type = None
 102         self.assertIsNone(self._sc.event_context_field_type)
 103
 104     def test_assign_invalid_event_context_field_type(self):
 105         with self.assertRaises(TypeError):
 106             self._sc.event_context_field_type = 'lel'
 107
 108     def test_trace_prop_no_tc(self):
 109         self.assertIsNone(self._sc.trace)
 110
 111     def test_trace_prop(self):
 112         tc = bt2.Trace()
 113         tc.add_stream_class(self._sc)
 114         self.assertEqual(self._sc.trace.addr, tc.addr)
 115
 116     def _test_copy(self, cpy):
 117         self.assertIsNot(cpy, self._sc)
 118         self.assertNotEqual(cpy.addr, self._sc.addr)
 119         self.assertEqual(cpy, self._sc)
 120
 121     def test_copy(self):
 122         cpy = copy.copy(self._sc)
 123         self._test_copy(cpy)
 124         self.assertEqual(self._sc.packet_context_field_type.addr, cpy.packet_context_field_type.addr)
 125         self.assertEqual(self._sc.event_header_field_type.addr, cpy.event_header_field_type.addr)
 126         self.assertEqual(self._sc.event_context_field_type.addr, cpy.event_context_field_type.addr)
 127
 128     def test_deepcopy(self):
 129         cpy = copy.deepcopy(self._sc)
 130         self._test_copy(cpy)
 131         self.assertNotEqual(self._sc.packet_context_field_type.addr, cpy.packet_context_field_type.addr)
 132         self.assertNotEqual(self._sc.event_header_field_type.addr, cpy.event_header_field_type.addr)
 133         self.assertNotEqual(self._sc.event_context_field_type.addr, cpy.event_context_field_type.addr)
 134
 135     def test_getitem(self):
 136         self.assertEqual(self._sc[23], self._ec1)
 137         self.assertEqual(self._sc[17], self._ec2)
 138
 139     def test_getitem_wrong_key_type(self):
 140         with self.assertRaises(TypeError):
 141             self._sc['event23']
 142
 143     def test_getitem_wrong_key(self):
 144         with self.assertRaises(KeyError):
 145             self._sc[19]
 146
 147     def test_len(self):
 148         self.assertEqual(len(self._sc), 2)
 149
 150     def test_iter(self):
 151         for ec_id, event_class in self._sc.items():
 152             self.assertIsInstance(event_class, bt2.EventClass)
 153
 154             if ec_id == 23:
 155                 self.assertEqual(event_class, self._ec1)
 156             elif ec_id == 17:
 157                 self.assertEqual(event_class, self._ec2)
 158
 159     def test_eq(self):
 160         ec1, ec2 = self._create_event_classes()
 161         sc1 = bt2.StreamClass(name='my_stream_class', id=12,
 162                               packet_context_field_type=self._packet_context_ft,
 163                               event_header_field_type=self._event_header_ft,
 164                               event_context_field_type=self._event_context_ft,
 165                               event_classes=(ec1, ec2))
 166         ec1, ec2 = self._create_event_classes()
 167         sc2 = bt2.StreamClass(name='my_stream_class', id=12,
 168                               packet_context_field_type=self._packet_context_ft,
 169                               event_header_field_type=self._event_header_ft,
 170                               event_context_field_type=self._event_context_ft,
 171                               event_classes=(ec1, ec2))
 172         self.assertEqual(sc1, sc2)
 173
 174     def test_ne_name(self):
 175         ec1, ec2 = self._create_event_classes()
 176         sc1 = bt2.StreamClass(name='my_stream_class1', id=12,
 177                               packet_context_field_type=self._packet_context_ft,
 178                               event_header_field_type=self._event_header_ft,
 179                               event_context_field_type=self._event_context_ft,
 180                               event_classes=(ec1, ec2))
 181         ec1, ec2 = self._create_event_classes()
 182         sc2 = bt2.StreamClass(name='my_stream_class', id=12,
 183                               packet_context_field_type=self._packet_context_ft,
 184                               event_header_field_type=self._event_header_ft,
 185                               event_context_field_type=self._event_context_ft,
 186                               event_classes=(ec1, ec2))
 187         self.assertNotEqual(sc1, sc2)
 188
 189     def test_ne_id(self):
 190         ec1, ec2 = self._create_event_classes()
 191         sc1 = bt2.StreamClass(name='my_stream_class', id=13,
 192                               packet_context_field_type=self._packet_context_ft,
 193                               event_header_field_type=self._event_header_ft,
 194                               event_context_field_type=self._event_context_ft,
 195                               event_classes=(ec1, ec2))
 196         ec1, ec2 = self._create_event_classes()
 197         sc2 = bt2.StreamClass(name='my_stream_class', id=12,
 198                               packet_context_field_type=self._packet_context_ft,
 199                               event_header_field_type=self._event_header_ft,
 200                               event_context_field_type=self._event_context_ft,
 201                               event_classes=(ec1, ec2))
 202         self.assertNotEqual(sc1, sc2)
 203
 204     def test_ne_packet_context_field_type(self):
 205         ec1, ec2 = self._create_event_classes()
 206         sc1 = bt2.StreamClass(name='my_stream_class', id=12,
 207                               packet_context_field_type=self._event_context_ft,
 208                               event_header_field_type=self._event_header_ft,
 209                               event_context_field_type=self._event_context_ft,
 210                               event_classes=(ec1, ec2))
 211         ec1, ec2 = self._create_event_classes()
 212         sc2 = bt2.StreamClass(name='my_stream_class', id=12,
 213                               packet_context_field_type=self._packet_context_ft,
 214                               event_header_field_type=self._event_header_ft,
 215                               event_context_field_type=self._event_context_ft,
 216                               event_classes=(ec1, ec2))
 217         self.assertNotEqual(sc1, sc2)
 218
 219     def test_ne_event_header_field_type(self):
 220         ec1, ec2 = self._create_event_classes()
 221         sc1 = bt2.StreamClass(name='my_stream_class', id=12,
 222                               packet_context_field_type=self._packet_context_ft,
 223                               event_context_field_type=self._event_context_ft,
 224                               event_classes=(ec1, ec2))
 225         ec1, ec2 = self._create_event_classes()
 226         sc2 = bt2.StreamClass(name='my_stream_class', id=12,
 227                               packet_context_field_type=self._packet_context_ft,
 228                               event_header_field_type=self._event_header_ft,
 229                               event_context_field_type=self._event_context_ft,
 230                               event_classes=(ec1, ec2))
 231         self.assertNotEqual(sc1, sc2)
 232
 233     def test_ne_event_context_field_type(self):
 234         ec1, ec2 = self._create_event_classes()
 235         sc1 = bt2.StreamClass(name='my_stream_class', id=12,
 236                               packet_context_field_type=self._packet_context_ft,
 237                               event_header_field_type=self._event_header_ft,
 238                               event_context_field_type=self._packet_context_ft,
 239                               event_classes=(ec1, ec2))
 240         ec1, ec2 = self._create_event_classes()
 241         sc2 = bt2.StreamClass(name='my_stream_class', id=12,
 242                               packet_context_field_type=self._packet_context_ft,
 243                               event_header_field_type=self._event_header_ft,
 244                               event_context_field_type=self._event_context_ft,
 245                               event_classes=(ec1, ec2))
 246         self.assertNotEqual(sc1, sc2)
 247
 248     def test_ne_event_class(self):
 249         ec1, ec2 = self._create_event_classes()
 250         sc1 = bt2.StreamClass(name='my_stream_class', id=12,
 251                               packet_context_field_type=self._packet_context_ft,
 252                               event_header_field_type=self._event_header_ft,
 253                               event_context_field_type=self._event_context_ft,
 254                               event_classes=(ec1,))
 255         ec1, ec2 = self._create_event_classes()
 256         sc2 = bt2.StreamClass(name='my_stream_class', id=12,
 257                               packet_context_field_type=self._packet_context_ft,
 258                               event_header_field_type=self._event_header_ft,
 259                               event_context_field_type=self._event_context_ft,
 260                               event_classes=(ec1, ec2))
 261         self.assertNotEqual(sc1, sc2)
 262
 263     def test_eq_invalid(self):
 264         self.assertFalse(self._sc == 23)