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