tests/bindings/python/bt2/test_integer_range_set.py

   1 #
   2 # Copyright (C) 2019 EfficiOS Inc.
   3 #
   4 # This program is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU General Public License
   6 # as published by the Free Software Foundation; only version 2
   7 # of the License.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17 #
  18
  19 import bt2
  20 import unittest
  21
  22 from utils import (
  23     get_default_trace_class,
  24     TestOutputPortMessageIterator,
  25     create_const_field,
  26 )
  27
  28
  29 def get_const_signed_integer_range(int_ranges):
  30     def range_setter(field):
  31         field.value = 12
  32
  33     tc = get_default_trace_class()
  34     fc = tc.create_signed_enumeration_field_class(32)
  35     fc.add_mapping('something', bt2.SignedIntegerRangeSet(int_ranges))
  36
  37     return create_const_field(tc, fc, range_setter).cls['something'].ranges
  38
  39
  40 def get_const_unsigned_integer_range(int_ranges):
  41     def range_setter(field):
  42         field.value = 12
  43
  44     tc = get_default_trace_class()
  45     fc = tc.create_unsigned_enumeration_field_class(32)
  46     fc.add_mapping('something', bt2.UnsignedIntegerRangeSet(int_ranges))
  47
  48     return create_const_field(tc, fc, range_setter).cls['something'].ranges
  49
  50
  51 class _IntegerRangeTestCase:
  52     def setUp(self):
  53         self._rg = self._CLS(self._def_lower, self._def_upper)
  54         self._const_rg = list(
  55             self._GET_CONST_RANGE_SET([(self._def_lower, self._def_upper)])
  56         )[0]
  57
  58     def test_create(self):
  59         self.assertEqual(self._rg.lower, self._def_lower)
  60         self.assertEqual(self._rg.upper, self._def_upper)
  61         self.assertIs(type(self._rg), self._CLS)
  62
  63     def test_const_create(self):
  64         self.assertEqual(self._const_rg.lower, self._def_lower)
  65         self.assertEqual(self._const_rg.upper, self._def_upper)
  66         self.assertIs(type(self._const_rg), self._CONST_CLS)
  67
  68     def test_create_same(self):
  69         rg = self._CLS(self._def_lower, self._def_lower)
  70         self.assertEqual(rg.lower, self._def_lower)
  71         self.assertEqual(rg.upper, self._def_lower)
  72
  73     def test_create_single(self):
  74         rg = self._CLS(self._def_lower)
  75         self.assertEqual(rg.lower, self._def_lower)
  76         self.assertEqual(rg.upper, self._def_lower)
  77
  78     def test_create_wrong_type_lower(self):
  79         with self.assertRaises(TypeError):
  80             self._CLS(19.3, self._def_upper)
  81
  82     def test_create_wrong_type_upper(self):
  83         with self.assertRaises(TypeError):
  84             self._CLS(self._def_lower, 19.3)
  85
  86     def test_create_out_of_bound_lower(self):
  87         with self.assertRaises(ValueError):
  88             self._CLS(self._oob_lower, self._def_upper)
  89
  90     def test_create_out_of_bound_upper(self):
  91         with self.assertRaises(ValueError):
  92             self._CLS(self._def_lower, self._oob_upper)
  93
  94     def test_create_lower_gt_upper(self):
  95         with self.assertRaises(ValueError):
  96             self._CLS(self._def_lower, self._def_lower - 1)
  97
  98     def test_contains_lower(self):
  99         self.assertTrue(self._rg.contains(self._def_lower))
 100
 101     def test_contains_upper(self):
 102         self.assertTrue(self._rg.contains(self._def_upper))
 103
 104     def test_contains_avg(self):
 105         avg = (self._def_lower + self._def_upper) // 2
 106         self.assertTrue(self._rg.contains(avg))
 107
 108     def test_contains_wrong_type(self):
 109         with self.assertRaises(TypeError):
 110             self._rg.contains('allo')
 111
 112     def test_contains_out_of_bound(self):
 113         with self.assertRaises(ValueError):
 114             self._rg.contains(self._oob_upper)
 115
 116     def test_eq(self):
 117         rg = self._CLS(self._def_lower, self._def_upper)
 118         self.assertEqual(rg, self._rg)
 119
 120     def test_const_eq(self):
 121         rg = list(self._GET_CONST_RANGE_SET([(self._def_lower, self._def_upper)]))[0]
 122         self.assertEqual(rg, self._const_rg)
 123
 124     def test_const_nonconst_eq(self):
 125         self.assertEqual(self._rg, self._const_rg)
 126
 127     def test_ne(self):
 128         rg = self._CLS(self._def_lower, self._def_upper - 1)
 129         self.assertNotEqual(rg, self._rg)
 130
 131     def test_const_ne(self):
 132         rg = list(self._GET_CONST_RANGE_SET([(self._def_lower, self._def_upper - 1)]))[
 133             0
 134         ]
 135         self.assertNotEqual(rg, self._const_rg)
 136
 137     def test_ne_other_type(self):
 138         self.assertNotEqual(self._rg, 48)
 139
 140
 141 class UnsignedIntegerRangeTestCase(_IntegerRangeTestCase, unittest.TestCase):
 142     _CLS = bt2.UnsignedIntegerRange
 143     _CONST_CLS = bt2._UnsignedIntegerRangeConst
 144     _GET_CONST_RANGE_SET = staticmethod(get_const_unsigned_integer_range)
 145     _def_lower = 23
 146     _def_upper = 18293
 147     _oob_lower = -1
 148     _oob_upper = 1 << 64
 149
 150
 151 class SignedIntegerRangeTestCase(_IntegerRangeTestCase, unittest.TestCase):
 152     _CLS = bt2.SignedIntegerRange
 153     _CONST_CLS = bt2._SignedIntegerRangeConst
 154     _GET_CONST_RANGE_SET = staticmethod(get_const_signed_integer_range)
 155     _def_lower = -184
 156     _def_upper = 11547
 157     _oob_lower = -(1 << 63) - 1
 158     _oob_upper = 1 << 63
 159
 160
 161 class _IntegerRangeSetTestCase:
 162     def setUp(self):
 163         self._rs = self._CLS((self._range1, self._range2, self._range3))
 164         self._const_rs = self._GET_CONST_RANGE_SET(
 165             [self._range1, self._range2, self._range3]
 166         )
 167
 168     def test_create(self):
 169         self.assertEqual(len(self._rs), 3)
 170         self.assertIn(self._range1, self._rs)
 171         self.assertIn(self._range2, self._rs)
 172         self.assertIn(self._range3, self._rs)
 173         self.assertIs(type(self._range1), self._RANGE_CLS)
 174
 175     def test_const_create(self):
 176         self.assertEqual(len(self._const_rs), 3)
 177         self.assertIn(self._range1, self._const_rs)
 178         self.assertIn(self._range2, self._const_rs)
 179         self.assertIn(self._range3, self._const_rs)
 180         self.assertIs(type(self._range1), self._RANGE_CLS)
 181
 182     def test_create_tuples(self):
 183         rs = self._CLS(
 184             (
 185                 (self._range1.lower, self._range1.upper),
 186                 (self._range2.lower, self._range2.upper),
 187                 (self._range3.lower, self._range3.upper),
 188             )
 189         )
 190         self.assertEqual(len(rs), 3)
 191         self.assertIn(self._range1, rs)
 192         self.assertIn(self._range2, rs)
 193         self.assertIn(self._range3, rs)
 194
 195     def test_create_single(self):
 196         rs = self._CLS((self._range_same.lower,))
 197         self.assertEqual(len(rs), 1)
 198         self.assertIn(self._range_same, rs)
 199
 200     def test_create_non_iter(self):
 201         with self.assertRaises(TypeError):
 202             self._rs = self._CLS(23)
 203
 204     def test_create_wrong_elem_type(self):
 205         with self.assertRaises(TypeError):
 206             self._rs = self._CLS((self._range1, self._range2, 'lel'))
 207
 208     def test_len(self):
 209         self.assertEqual(len(self._rs), 3)
 210
 211     def test_contains(self):
 212         rs = self._CLS((self._range1, self._range2))
 213         self.assertIn(self._range1, rs)
 214         self.assertIn(self._range2, rs)
 215         self.assertNotIn(self._range3, rs)
 216
 217     def test_contains_value(self):
 218         rs = self._CLS((self._range1, self._range2))
 219         self.assertTrue(rs.contains_value(self._range1.upper))
 220         self.assertTrue(rs.contains_value(self._range2.lower))
 221         self.assertFalse(rs.contains_value(self._range3.upper))
 222
 223     def test_contains_value_wrong_type(self):
 224         with self.assertRaises(TypeError):
 225             self._rs.contains_value('meow')
 226
 227     def test_iter(self):
 228         range_list = list(self._rs)
 229         self.assertIn(self._range1, range_list)
 230         self.assertIn(self._range2, range_list)
 231         self.assertIn(self._range3, range_list)
 232
 233         for rg in range_list:
 234             self.assertIs(type(rg), self._RANGE_CLS)
 235
 236     def test_const_iter(self):
 237         range_list = list(self._const_rs)
 238         self.assertIn(self._range1, range_list)
 239         self.assertIn(self._range2, range_list)
 240         self.assertIn(self._range3, range_list)
 241
 242         for rg in range_list:
 243             self.assertIs(type(rg), self._CONST_RANGE_CLS)
 244
 245     def test_empty(self):
 246         rs = self._CLS()
 247         self.assertEqual(len(rs), 0)
 248         self.assertEqual(len(list(rs)), 0)
 249
 250     def test_add_range_obj(self):
 251         rs = self._CLS((self._range1,))
 252         self.assertEqual(len(rs), 1)
 253         rs.add(self._range2)
 254         self.assertEqual(len(rs), 2)
 255         self.assertIn(self._range2, rs)
 256
 257     def test_const_add_range_obj(self):
 258         with self.assertRaises(AttributeError):
 259             self._const_rs.add((12, 4434))
 260
 261     def test_discard_not_implemented(self):
 262         with self.assertRaises(NotImplementedError):
 263             self._rs.discard(self._range2)
 264
 265     def test_eq_same_order(self):
 266         rs = self._CLS((self._range1, self._range2, self._range3))
 267         self.assertEqual(self._rs, rs)
 268
 269     def test_eq_diff_order(self):
 270         rs = self._CLS((self._range1, self._range3, self._range2))
 271         self.assertEqual(self._rs, rs)
 272
 273     def test_eq_same_addr(self):
 274         self.assertEqual(self._rs, self._rs)
 275
 276     def test_ne_diff_len(self):
 277         rs = self._CLS((self._range1, self._range2))
 278         self.assertNotEqual(self._rs, rs)
 279
 280     def test_ne_diff_values(self):
 281         rs1 = self._CLS((self._range1, self._range2))
 282         rs2 = self._CLS((self._range1, self._range3))
 283         self.assertNotEqual(rs1, rs2)
 284
 285     def test_ne_incompatible_type(self):
 286         self.assertNotEqual(self._rs, object())
 287
 288
 289 class UnsignedIntegerRangeSetTestCase(_IntegerRangeSetTestCase, unittest.TestCase):
 290     _CLS = bt2.UnsignedIntegerRangeSet
 291     _CONST_CLS = bt2._UnsignedIntegerRangeSetConst
 292     _RANGE_CLS = bt2.UnsignedIntegerRange
 293     _CONST_RANGE_CLS = bt2._UnsignedIntegerRangeConst
 294     _GET_CONST_RANGE_SET = staticmethod(get_const_unsigned_integer_range)
 295
 296     def setUp(self):
 297         self._range1 = bt2.UnsignedIntegerRange(4, 192)
 298         self._range2 = bt2.UnsignedIntegerRange(17, 228)
 299         self._range3 = bt2.UnsignedIntegerRange(1000, 2000)
 300         self._range_same = bt2.UnsignedIntegerRange(1300, 1300)
 301         super().setUp()
 302
 303
 304 class SignedIntegerRangeSetTestCase(_IntegerRangeSetTestCase, unittest.TestCase):
 305     _CLS = bt2.SignedIntegerRangeSet
 306     _CONST_CLS = bt2._SignedIntegerRangeSetConst
 307     _RANGE_CLS = bt2.SignedIntegerRange
 308     _CONST_RANGE_CLS = bt2._SignedIntegerRangeConst
 309     _GET_CONST_RANGE_SET = staticmethod(get_const_signed_integer_range)
 310
 311     def setUp(self):
 312         self._range1 = bt2.SignedIntegerRange(-1484, -17)
 313         self._range2 = bt2.SignedIntegerRange(-101, 1500)
 314         self._range3 = bt2.SignedIntegerRange(1948, 2019)
 315         self._range_same = bt2.SignedIntegerRange(-1300, -1300)
 316         super().setUp()
 317
 318
 319 if __name__ == '__main__':
 320     unittest.main()