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
  23 class _IntegerRangeTestCase:
  24     def setUp(self):
  25         self._rg = self._CLS(self._def_lower, self._def_upper)
  26
  27     def test_create(self):
  28         self.assertEqual(self._rg.lower, self._def_lower)
  29         self.assertEqual(self._rg.upper, self._def_upper)
  30
  31     def test_create_same(self):
  32         rg = self._CLS(self._def_lower, self._def_lower)
  33         self.assertEqual(rg.lower, self._def_lower)
  34         self.assertEqual(rg.upper, self._def_lower)
  35
  36     def test_create_single(self):
  37         rg = self._CLS(self._def_lower)
  38         self.assertEqual(rg.lower, self._def_lower)
  39         self.assertEqual(rg.upper, self._def_lower)
  40
  41     def test_create_wrong_type_lower(self):
  42         with self.assertRaises(TypeError):
  43             self._CLS(19.3, self._def_upper)
  44
  45     def test_create_wrong_type_upper(self):
  46         with self.assertRaises(TypeError):
  47             self._CLS(self._def_lower, 19.3)
  48
  49     def test_create_out_of_bound_lower(self):
  50         with self.assertRaises(ValueError):
  51             self._CLS(self._oob_lower, self._def_upper)
  52
  53     def test_create_out_of_bound_upper(self):
  54         with self.assertRaises(ValueError):
  55             self._CLS(self._def_lower, self._oob_upper)
  56
  57     def test_create_lower_gt_upper(self):
  58         with self.assertRaises(ValueError):
  59             self._CLS(self._def_lower, self._def_lower - 1)
  60
  61     def test_contains_lower(self):
  62         self.assertTrue(self._rg.contains(self._def_lower))
  63
  64     def test_contains_upper(self):
  65         self.assertTrue(self._rg.contains(self._def_upper))
  66
  67     def test_contains_avg(self):
  68         avg = (self._def_lower + self._def_upper) // 2
  69         self.assertTrue(self._rg.contains(avg))
  70
  71     def test_contains_wrong_type(self):
  72         with self.assertRaises(TypeError):
  73             self._rg.contains('allo')
  74
  75     def test_contains_out_of_bound(self):
  76         with self.assertRaises(ValueError):
  77             self._rg.contains(self._oob_upper)
  78
  79     def test_eq(self):
  80         rg = self._CLS(self._def_lower, self._def_upper)
  81         self.assertEqual(rg, self._rg)
  82
  83     def test_ne(self):
  84         rg = self._CLS(self._def_lower, self._def_upper - 1)
  85         self.assertNotEqual(rg, self._rg)
  86
  87     def test_ne_other_type(self):
  88         self.assertNotEqual(self._rg, 48)
  89
  90
  91 class UnsignedIntegerRangeTestCase(_IntegerRangeTestCase, unittest.TestCase):
  92     _CLS = bt2.UnsignedIntegerRange
  93     _def_lower = 23
  94     _def_upper = 18293
  95     _oob_lower = -1
  96     _oob_upper = 1 << 64
  97
  98
  99 class SignedIntegerRangeTestCase(_IntegerRangeTestCase, unittest.TestCase):
 100     _CLS = bt2.SignedIntegerRange
 101     _def_lower = -184
 102     _def_upper = 11547
 103     _oob_lower = -(1 << 63) - 1
 104     _oob_upper = 1 << 63
 105
 106
 107 class _IntegerRangeSetTestCase:
 108     def setUp(self):
 109         self._rs = self._CLS((self._range1, self._range2, self._range3))
 110
 111     def test_create(self):
 112         self.assertEqual(len(self._rs), 3)
 113         self.assertIn(self._range1, self._rs)
 114         self.assertIn(self._range2, self._rs)
 115         self.assertIn(self._range3, self._rs)
 116
 117     def test_create_tuples(self):
 118         rs = self._CLS(
 119             (
 120                 (self._range1.lower, self._range1.upper),
 121                 (self._range2.lower, self._range2.upper),
 122                 (self._range3.lower, self._range3.upper),
 123             )
 124         )
 125         self.assertEqual(len(rs), 3)
 126         self.assertIn(self._range1, rs)
 127         self.assertIn(self._range2, rs)
 128         self.assertIn(self._range3, rs)
 129
 130     def test_create_single(self):
 131         rs = self._CLS((self._range_same.lower,))
 132         self.assertEqual(len(rs), 1)
 133         self.assertIn(self._range_same, rs)
 134
 135     def test_create_non_iter(self):
 136         with self.assertRaises(TypeError):
 137             self._rs = self._CLS(23)
 138
 139     def test_create_wrong_elem_type(self):
 140         with self.assertRaises(TypeError):
 141             self._rs = self._CLS((self._range1, self._range2, 'lel'))
 142
 143     def test_len(self):
 144         self.assertEqual(len(self._rs), 3)
 145
 146     def test_contains(self):
 147         rs = self._CLS((self._range1, self._range2))
 148         self.assertIn(self._range1, rs)
 149         self.assertIn(self._range2, rs)
 150         self.assertNotIn(self._range3, rs)
 151
 152     def test_contains_value(self):
 153         rs = self._CLS((self._range1, self._range2))
 154         self.assertTrue(rs.contains_value(self._range1.upper))
 155         self.assertTrue(rs.contains_value(self._range2.lower))
 156         self.assertFalse(rs.contains_value(self._range3.upper))
 157
 158     def test_contains_value_wrong_type(self):
 159         with self.assertRaises(TypeError):
 160             self._rs.contains_value('meow')
 161
 162     def test_iter(self):
 163         range_list = list(self._rs)
 164         self.assertIn(self._range1, range_list)
 165         self.assertIn(self._range2, range_list)
 166         self.assertIn(self._range3, range_list)
 167
 168     def test_empty(self):
 169         rs = self._CLS()
 170         self.assertEqual(len(rs), 0)
 171         self.assertEqual(len(list(rs)), 0)
 172
 173     def test_add_range_obj(self):
 174         rs = self._CLS((self._range1,))
 175         self.assertEqual(len(rs), 1)
 176         rs.add(self._range2)
 177         self.assertEqual(len(rs), 2)
 178         self.assertIn(self._range2, rs)
 179
 180     def test_discard_not_implemented(self):
 181         with self.assertRaises(NotImplementedError):
 182             self._rs.discard(self._range2)
 183
 184     def test_eq_same_order(self):
 185         rs = self._CLS((self._range1, self._range2, self._range3))
 186         self.assertEqual(self._rs, rs)
 187
 188     def test_eq_diff_order(self):
 189         rs = self._CLS((self._range1, self._range3, self._range2))
 190         self.assertEqual(self._rs, rs)
 191
 192     def test_eq_same_addr(self):
 193         self.assertEqual(self._rs, self._rs)
 194
 195     def test_ne_diff_len(self):
 196         rs = self._CLS((self._range1, self._range2))
 197         self.assertNotEqual(self._rs, rs)
 198
 199     def test_ne_diff_values(self):
 200         rs1 = self._CLS((self._range1, self._range2))
 201         rs2 = self._CLS((self._range1, self._range3))
 202         self.assertNotEqual(rs1, rs2)
 203
 204     def test_ne_incompatible_type(self):
 205         self.assertNotEqual(self._rs, object())
 206
 207
 208 class UnsignedIntegerRangeSetTestCase(_IntegerRangeSetTestCase, unittest.TestCase):
 209     _CLS = bt2.UnsignedIntegerRangeSet
 210
 211     def setUp(self):
 212         self._range1 = bt2.UnsignedIntegerRange(4, 192)
 213         self._range2 = bt2.UnsignedIntegerRange(17, 228)
 214         self._range3 = bt2.UnsignedIntegerRange(1000, 2000)
 215         self._range_same = bt2.UnsignedIntegerRange(1300, 1300)
 216         super().setUp()
 217
 218
 219 class SignedIntegerRangeSetTestCase(_IntegerRangeSetTestCase, unittest.TestCase):
 220     _CLS = bt2.SignedIntegerRangeSet
 221
 222     def setUp(self):
 223         self._range1 = bt2.SignedIntegerRange(-1484, -17)
 224         self._range2 = bt2.SignedIntegerRange(-101, 1500)
 225         self._range3 = bt2.SignedIntegerRange(1948, 2019)
 226         self._range_same = bt2.SignedIntegerRange(-1300, -1300)
 227         super().setUp()
 228
 229
 230 if __name__ == '__main__':
 231     unittest.main()