tests/bindings/python/bt2/test_value.py

   1 # SPDX-License-Identifier: GPL-2.0-only
   2 #
   3 # Copyright (C) 2019 EfficiOS Inc.
   4 #
   5
   6 import copy
   7 import math
   8 import operator
   9 import unittest
  10 import collections
  11 from functools import partial, partialmethod
  12
  13 import bt2
  14
  15
  16 # The value object classes explicitly do not implement the copy methods,
  17 # raising `NotImplementedError`, just in case we decide to implement
  18 # them someday.
  19 class _TestCopySimple:
  20     def test_copy(self):
  21         with self.assertRaises(NotImplementedError):
  22             copy.copy(self._def)
  23
  24     def test_deepcopy(self):
  25         with self.assertRaises(NotImplementedError):
  26             copy.deepcopy(self._def)
  27
  28
  29 _COMP_BINOPS = (operator.eq, operator.ne)
  30
  31
  32 # Base class for numeric value test cases.
  33 #
  34 # To be compatible with this base class, a derived class must, in its
  35 # setUp() method:
  36 #
  37 # * Set `self._def` to a value object with an arbitrary raw value.
  38 # * Set `self._def_value` to the equivalent raw value of `self._def`.
  39 class _TestNumericValue(_TestCopySimple):
  40     # Tries the binary operation `op`:
  41     #
  42     # 1. Between `self._def`, which is a value object, and `rhs`.
  43     # 2. Between `self._def_value`, which is the raw value of
  44     #    `self._def`, and `rhs`.
  45     #
  46     # Returns the results of 1. and 2.
  47     #
  48     # If there's an exception while performing 1. or 2., asserts that
  49     # both operations raised exceptions, that both exceptions have the
  50     # same type, and returns `None` for both results.
  51     def _binop(self, op, rhs):
  52         type_rexc = None
  53         type_rvexc = None
  54         comp_value = rhs
  55
  56         # try with value object
  57         try:
  58             r = op(self._def, rhs)
  59         except Exception as e:
  60             type_rexc = type(e)
  61
  62         # try with raw value
  63         try:
  64             rv = op(self._def_value, comp_value)
  65         except Exception as e:
  66             type_rvexc = type(e)
  67
  68         if type_rexc is not None or type_rvexc is not None:
  69             # at least one of the operations raised an exception: in
  70             # this case both operations should have raised the same
  71             # type of exception (division by zero, bit shift with a
  72             # floating point number operand, etc.)
  73             self.assertIs(type_rexc, type_rvexc)
  74             return None, None
  75
  76         return r, rv
  77
  78     # Tries the unary operation `op`:
  79     #
  80     # 1. On `self._def`, which is a value object.
  81     # 2. On `self._def_value`, which is the raw value of `self._def`.
  82     #
  83     # Returns the results of 1. and 2.
  84     #
  85     # If there's an exception while performing 1. or 2., asserts that
  86     # both operations raised exceptions, that both exceptions have the
  87     # same type, and returns `None` for both results.
  88     def _unaryop(self, op):
  89         type_rexc = None
  90         type_rvexc = None
  91
  92         # try with value object
  93         try:
  94             r = op(self._def)
  95         except Exception as e:
  96             type_rexc = type(e)
  97
  98         # try with raw value
  99         try:
 100             rv = op(self._def_value)
 101         except Exception as e:
 102             type_rvexc = type(e)
 103
 104         if type_rexc is not None or type_rvexc is not None:
 105             # at least one of the operations raised an exception: in
 106             # this case both operations should have raised the same
 107             # type of exception (division by zero, bit shift with a
 108             # floating point number operand, etc.)
 109             self.assertIs(type_rexc, type_rvexc)
 110             return None, None
 111
 112         return r, rv
 113
 114     # Tests that the unary operation `op` gives results with the same
 115     # type for both `self._def` and `self._def_value`.
 116     def _test_unaryop_type(self, op):
 117         r, rv = self._unaryop(op)
 118
 119         if r is None:
 120             return
 121
 122         self.assertIsInstance(r, type(rv))
 123
 124     # Tests that the unary operation `op` gives results with the same
 125     # value for both `self._def` and `self._def_value`. This uses the
 126     # __eq__() operator of `self._def`.
 127     def _test_unaryop_value(self, op):
 128         r, rv = self._unaryop(op)
 129
 130         if r is None:
 131             return
 132
 133         self.assertEqual(r, rv)
 134
 135     # Tests that the unary operation `op`, when applied to `self._def`,
 136     # does not change its underlying BT object address.
 137     def _test_unaryop_addr_same(self, op):
 138         addr_before = self._def.addr
 139         self._unaryop(op)
 140         self.assertEqual(self._def.addr, addr_before)
 141
 142     # Tests that the unary operation `op`, when applied to `self._def`,
 143     # does not change its value.
 144     def _test_unaryop_value_same(self, op):
 145         value_before = self._def.__class__(self._def)
 146         self._unaryop(op)
 147         self.assertEqual(self._def, value_before)
 148
 149     # Tests that the binary operation `op` gives results with the same
 150     # type for both `self._def` and `self._def_value`.
 151     def _test_binop_type(self, op, rhs):
 152         r, rv = self._binop(op, rhs)
 153
 154         if r is None:
 155             return
 156
 157         if op in _COMP_BINOPS:
 158             # __eq__() and __ne__() always return a 'bool' object
 159             self.assertIsInstance(r, bool)
 160         else:
 161             self.assertIsInstance(r, type(rv))
 162
 163     # Tests that the binary operation `op` gives results with the same
 164     # value for both `self._def` and `self._def_value`. This uses the
 165     # __eq__() operator of `self._def`.
 166     def _test_binop_value(self, op, rhs):
 167         r, rv = self._binop(op, rhs)
 168
 169         if r is None:
 170             return
 171
 172         self.assertEqual(r, rv)
 173
 174     # Tests that the binary operation `op`, when applied to `self._def`,
 175     # does not change its underlying BT object address.
 176     def _test_binop_lhs_addr_same(self, op, rhs):
 177         addr_before = self._def.addr
 178         r, rv = self._binop(op, rhs)
 179         self.assertEqual(self._def.addr, addr_before)
 180
 181     # Tests that the binary operation `op`, when applied to `self._def`,
 182     # does not change its value.
 183     def _test_binop_lhs_value_same(self, op, rhs):
 184         value_before = self._def.__class__(self._def)
 185         r, rv = self._binop(op, rhs)
 186         self.assertEqual(self._def, value_before)
 187
 188     # The methods below which take the `test_cb` and `op` parameters
 189     # are meant to be used with one of the _test_binop_*() functions
 190     # above as `test_cb` and a binary operator function as `op`.
 191     #
 192     # For example:
 193     #
 194     #     self._test_binop_rhs_pos_int(self._test_binop_value,
 195     #                                  operator.add)
 196     #
 197     # This tests that a numeric value object added to a positive integer
 198     # raw value gives a result with the expected value.
 199     #
 200     # `vint` and `vfloat` mean a signed integer value object and a real
 201     # value object.
 202
 203     def _test_binop_unknown(self, op):
 204         if op is operator.eq:
 205             self.assertIs(op(self._def, object()), False)
 206         elif op is operator.ne:
 207             self.assertIs(op(self._def, object()), True)
 208         else:
 209             with self.assertRaises(TypeError):
 210                 op(self._def, object())
 211
 212     def _test_binop_none(self, op):
 213         if op is operator.eq:
 214             self.assertIs(op(self._def, None), False)
 215         elif op is operator.ne:
 216             self.assertIs(op(self._def, None), True)
 217         else:
 218             with self.assertRaises(TypeError):
 219                 op(self._def, None)
 220
 221     def _test_binop_rhs_false(self, test_cb, op):
 222         test_cb(op, False)
 223
 224     def _test_binop_rhs_true(self, test_cb, op):
 225         test_cb(op, True)
 226
 227     def _test_binop_rhs_pos_int(self, test_cb, op):
 228         test_cb(op, 2)
 229
 230     def _test_binop_rhs_neg_int(self, test_cb, op):
 231         test_cb(op, -23)
 232
 233     def _test_binop_rhs_zero_int(self, test_cb, op):
 234         test_cb(op, 0)
 235
 236     def _test_binop_rhs_pos_vint(self, test_cb, op):
 237         test_cb(op, bt2.create_value(2))
 238
 239     def _test_binop_rhs_neg_vint(self, test_cb, op):
 240         test_cb(op, bt2.create_value(-23))
 241
 242     def _test_binop_rhs_zero_vint(self, test_cb, op):
 243         test_cb(op, bt2.create_value(0))
 244
 245     def _test_binop_rhs_pos_float(self, test_cb, op):
 246         test_cb(op, 2.2)
 247
 248     def _test_binop_rhs_neg_float(self, test_cb, op):
 249         test_cb(op, -23.4)
 250
 251     def _test_binop_rhs_zero_float(self, test_cb, op):
 252         test_cb(op, 0.0)
 253
 254     def _test_binop_rhs_complex(self, test_cb, op):
 255         test_cb(op, -23 + 19j)
 256
 257     def _test_binop_rhs_zero_complex(self, test_cb, op):
 258         test_cb(op, 0j)
 259
 260     def _test_binop_rhs_pos_vfloat(self, test_cb, op):
 261         test_cb(op, bt2.create_value(2.2))
 262
 263     def _test_binop_rhs_neg_vfloat(self, test_cb, op):
 264         test_cb(op, bt2.create_value(-23.4))
 265
 266     def _test_binop_rhs_zero_vfloat(self, test_cb, op):
 267         test_cb(op, bt2.create_value(0.0))
 268
 269     def _test_binop_type_false(self, op):
 270         self._test_binop_rhs_false(self._test_binop_type, op)
 271
 272     def _test_binop_type_true(self, op):
 273         self._test_binop_rhs_true(self._test_binop_type, op)
 274
 275     def _test_binop_type_pos_int(self, op):
 276         self._test_binop_rhs_pos_int(self._test_binop_type, op)
 277
 278     def _test_binop_type_neg_int(self, op):
 279         self._test_binop_rhs_neg_int(self._test_binop_type, op)
 280
 281     def _test_binop_type_zero_int(self, op):
 282         self._test_binop_rhs_zero_int(self._test_binop_type, op)
 283
 284     def _test_binop_type_pos_vint(self, op):
 285         self._test_binop_rhs_pos_vint(self._test_binop_type, op)
 286
 287     def _test_binop_type_neg_vint(self, op):
 288         self._test_binop_rhs_neg_vint(self._test_binop_type, op)
 289
 290     def _test_binop_type_zero_vint(self, op):
 291         self._test_binop_rhs_zero_vint(self._test_binop_type, op)
 292
 293     def _test_binop_type_pos_float(self, op):
 294         self._test_binop_rhs_pos_float(self._test_binop_type, op)
 295
 296     def _test_binop_type_neg_float(self, op):
 297         self._test_binop_rhs_neg_float(self._test_binop_type, op)
 298
 299     def _test_binop_type_zero_float(self, op):
 300         self._test_binop_rhs_zero_float(self._test_binop_type, op)
 301
 302     def _test_binop_type_pos_vfloat(self, op):
 303         self._test_binop_rhs_pos_vfloat(self._test_binop_type, op)
 304
 305     def _test_binop_type_neg_vfloat(self, op):
 306         self._test_binop_rhs_neg_vfloat(self._test_binop_type, op)
 307
 308     def _test_binop_type_zero_vfloat(self, op):
 309         self._test_binop_rhs_zero_vfloat(self._test_binop_type, op)
 310
 311     def _test_binop_type_complex(self, op):
 312         self._test_binop_rhs_complex(self._test_binop_type, op)
 313
 314     def _test_binop_type_zero_complex(self, op):
 315         self._test_binop_rhs_zero_complex(self._test_binop_type, op)
 316
 317     def _test_binop_value_false(self, op):
 318         self._test_binop_rhs_false(self._test_binop_value, op)
 319
 320     def _test_binop_value_true(self, op):
 321         self._test_binop_rhs_true(self._test_binop_value, op)
 322
 323     def _test_binop_value_pos_int(self, op):
 324         self._test_binop_rhs_pos_int(self._test_binop_value, op)
 325
 326     def _test_binop_value_neg_int(self, op):
 327         self._test_binop_rhs_neg_int(self._test_binop_value, op)
 328
 329     def _test_binop_value_zero_int(self, op):
 330         self._test_binop_rhs_zero_int(self._test_binop_value, op)
 331
 332     def _test_binop_value_pos_vint(self, op):
 333         self._test_binop_rhs_pos_vint(self._test_binop_value, op)
 334
 335     def _test_binop_value_neg_vint(self, op):
 336         self._test_binop_rhs_neg_vint(self._test_binop_value, op)
 337
 338     def _test_binop_value_zero_vint(self, op):
 339         self._test_binop_rhs_zero_vint(self._test_binop_value, op)
 340
 341     def _test_binop_value_pos_float(self, op):
 342         self._test_binop_rhs_pos_float(self._test_binop_value, op)
 343
 344     def _test_binop_value_neg_float(self, op):
 345         self._test_binop_rhs_neg_float(self._test_binop_value, op)
 346
 347     def _test_binop_value_zero_float(self, op):
 348         self._test_binop_rhs_zero_float(self._test_binop_value, op)
 349
 350     def _test_binop_value_pos_vfloat(self, op):
 351         self._test_binop_rhs_pos_vfloat(self._test_binop_value, op)
 352
 353     def _test_binop_value_neg_vfloat(self, op):
 354         self._test_binop_rhs_neg_vfloat(self._test_binop_value, op)
 355
 356     def _test_binop_value_zero_vfloat(self, op):
 357         self._test_binop_rhs_zero_vfloat(self._test_binop_value, op)
 358
 359     def _test_binop_value_complex(self, op):
 360         self._test_binop_rhs_complex(self._test_binop_value, op)
 361
 362     def _test_binop_value_zero_complex(self, op):
 363         self._test_binop_rhs_zero_complex(self._test_binop_value, op)
 364
 365     def _test_binop_lhs_addr_same_false(self, op):
 366         self._test_binop_rhs_false(self._test_binop_lhs_addr_same, op)
 367
 368     def _test_binop_lhs_addr_same_true(self, op):
 369         self._test_binop_rhs_true(self._test_binop_lhs_addr_same, op)
 370
 371     def _test_binop_lhs_addr_same_pos_int(self, op):
 372         self._test_binop_rhs_pos_int(self._test_binop_lhs_addr_same, op)
 373
 374     def _test_binop_lhs_addr_same_neg_int(self, op):
 375         self._test_binop_rhs_neg_int(self._test_binop_lhs_addr_same, op)
 376
 377     def _test_binop_lhs_addr_same_zero_int(self, op):
 378         self._test_binop_rhs_zero_int(self._test_binop_lhs_addr_same, op)
 379
 380     def _test_binop_lhs_addr_same_pos_vint(self, op):
 381         self._test_binop_rhs_pos_vint(self._test_binop_lhs_addr_same, op)
 382
 383     def _test_binop_lhs_addr_same_neg_vint(self, op):
 384         self._test_binop_rhs_neg_vint(self._test_binop_lhs_addr_same, op)
 385
 386     def _test_binop_lhs_addr_same_zero_vint(self, op):
 387         self._test_binop_rhs_zero_vint(self._test_binop_lhs_addr_same, op)
 388
 389     def _test_binop_lhs_addr_same_pos_float(self, op):
 390         self._test_binop_rhs_pos_float(self._test_binop_lhs_addr_same, op)
 391
 392     def _test_binop_lhs_addr_same_neg_float(self, op):
 393         self._test_binop_rhs_neg_float(self._test_binop_lhs_addr_same, op)
 394
 395     def _test_binop_lhs_addr_same_zero_float(self, op):
 396         self._test_binop_rhs_zero_float(self._test_binop_lhs_addr_same, op)
 397
 398     def _test_binop_lhs_addr_same_pos_vfloat(self, op):
 399         self._test_binop_rhs_pos_vfloat(self._test_binop_lhs_addr_same, op)
 400
 401     def _test_binop_lhs_addr_same_neg_vfloat(self, op):
 402         self._test_binop_rhs_neg_vfloat(self._test_binop_lhs_addr_same, op)
 403
 404     def _test_binop_lhs_addr_same_zero_vfloat(self, op):
 405         self._test_binop_rhs_zero_vfloat(self._test_binop_lhs_addr_same, op)
 406
 407     def _test_binop_lhs_addr_same_complex(self, op):
 408         self._test_binop_rhs_complex(self._test_binop_lhs_addr_same, op)
 409
 410     def _test_binop_lhs_addr_same_zero_complex(self, op):
 411         self._test_binop_rhs_zero_complex(self._test_binop_lhs_addr_same, op)
 412
 413     def _test_binop_lhs_value_same_false(self, op):
 414         self._test_binop_rhs_false(self._test_binop_lhs_value_same, op)
 415
 416     def _test_binop_lhs_value_same_true(self, op):
 417         self._test_binop_rhs_true(self._test_binop_lhs_value_same, op)
 418
 419     def _test_binop_lhs_value_same_pos_int(self, op):
 420         self._test_binop_rhs_pos_int(self._test_binop_lhs_value_same, op)
 421
 422     def _test_binop_lhs_value_same_neg_int(self, op):
 423         self._test_binop_rhs_neg_int(self._test_binop_lhs_value_same, op)
 424
 425     def _test_binop_lhs_value_same_zero_int(self, op):
 426         self._test_binop_rhs_zero_int(self._test_binop_lhs_value_same, op)
 427
 428     def _test_binop_lhs_value_same_pos_vint(self, op):
 429         self._test_binop_rhs_pos_vint(self._test_binop_lhs_value_same, op)
 430
 431     def _test_binop_lhs_value_same_neg_vint(self, op):
 432         self._test_binop_rhs_neg_vint(self._test_binop_lhs_value_same, op)
 433
 434     def _test_binop_lhs_value_same_zero_vint(self, op):
 435         self._test_binop_rhs_zero_vint(self._test_binop_lhs_value_same, op)
 436
 437     def _test_binop_lhs_value_same_pos_float(self, op):
 438         self._test_binop_rhs_pos_float(self._test_binop_lhs_value_same, op)
 439
 440     def _test_binop_lhs_value_same_neg_float(self, op):
 441         self._test_binop_rhs_neg_float(self._test_binop_lhs_value_same, op)
 442
 443     def _test_binop_lhs_value_same_zero_float(self, op):
 444         self._test_binop_rhs_zero_float(self._test_binop_lhs_value_same, op)
 445
 446     def _test_binop_lhs_value_same_pos_vfloat(self, op):
 447         self._test_binop_rhs_pos_vfloat(self._test_binop_lhs_value_same, op)
 448
 449     def _test_binop_lhs_value_same_neg_vfloat(self, op):
 450         self._test_binop_rhs_neg_vfloat(self._test_binop_lhs_value_same, op)
 451
 452     def _test_binop_lhs_value_same_zero_vfloat(self, op):
 453         self._test_binop_rhs_zero_vfloat(self._test_binop_lhs_value_same, op)
 454
 455     def _test_binop_lhs_value_same_complex(self, op):
 456         self._test_binop_rhs_complex(self._test_binop_lhs_value_same, op)
 457
 458     def _test_binop_lhs_value_same_zero_complex(self, op):
 459         self._test_binop_rhs_zero_complex(self._test_binop_lhs_value_same, op)
 460
 461     def test_bool_op(self):
 462         self.assertEqual(bool(self._def), bool(self._def_value))
 463
 464     def test_int_op(self):
 465         self.assertEqual(int(self._def), int(self._def_value))
 466
 467     def test_float_op(self):
 468         self.assertEqual(float(self._def), float(self._def_value))
 469
 470     def test_complex_op(self):
 471         self.assertEqual(complex(self._def), complex(self._def_value))
 472
 473     def test_str_op(self):
 474         self.assertEqual(str(self._def), str(self._def_value))
 475
 476     def test_eq_none(self):
 477         # Disable the "comparison to None" warning, as this is precisely what
 478         # we want to test here.
 479         self.assertFalse(self._def == None)  # noqa: E711
 480
 481     def test_ne_none(self):
 482         # Disable the "comparison to None" warning, as this is precisely what
 483         # we want to test here.
 484         self.assertTrue(self._def != None)  # noqa: E711
 485
 486
 487 # This is a list of binary operators used for
 488 # _inject_numeric_testing_methods().
 489 #
 490 # Each entry is a pair of binary operator name (used as part of the
 491 # created testing method's name) and operator function.
 492 _BINOPS = (
 493     ("lt", operator.lt),
 494     ("le", operator.le),
 495     ("eq", operator.eq),
 496     ("ne", operator.ne),
 497     ("ge", operator.ge),
 498     ("gt", operator.gt),
 499     ("add", operator.add),
 500     ("radd", lambda a, b: operator.add(b, a)),
 501     ("and", operator.and_),
 502     ("rand", lambda a, b: operator.and_(b, a)),
 503     ("floordiv", operator.floordiv),
 504     ("rfloordiv", lambda a, b: operator.floordiv(b, a)),
 505     ("lshift", operator.lshift),
 506     ("rlshift", lambda a, b: operator.lshift(b, a)),
 507     ("mod", operator.mod),
 508     ("rmod", lambda a, b: operator.mod(b, a)),
 509     ("mul", operator.mul),
 510     ("rmul", lambda a, b: operator.mul(b, a)),
 511     ("or", operator.or_),
 512     ("ror", lambda a, b: operator.or_(b, a)),
 513     ("pow", operator.pow),
 514     ("rpow", lambda a, b: operator.pow(b, a)),
 515     ("rshift", operator.rshift),
 516     ("rrshift", lambda a, b: operator.rshift(b, a)),
 517     ("sub", operator.sub),
 518     ("rsub", lambda a, b: operator.sub(b, a)),
 519     ("truediv", operator.truediv),
 520     ("rtruediv", lambda a, b: operator.truediv(b, a)),
 521     ("xor", operator.xor),
 522     ("rxor", lambda a, b: operator.xor(b, a)),
 523 )
 524
 525
 526 # This is a list of unary operators used for
 527 # _inject_numeric_testing_methods().
 528 #
 529 # Each entry is a pair of unary operator name (used as part of the
 530 # created testing method's name) and operator function.
 531 _UNARYOPS = (
 532     ("neg", operator.neg),
 533     ("pos", operator.pos),
 534     ("abs", operator.abs),
 535     ("invert", operator.invert),
 536     ("round", round),
 537     ("round_0", partial(round, ndigits=0)),
 538     ("round_1", partial(round, ndigits=1)),
 539     ("round_2", partial(round, ndigits=2)),
 540     ("round_3", partial(round, ndigits=3)),
 541     ("ceil", math.ceil),
 542     ("floor", math.floor),
 543     ("trunc", math.trunc),
 544 )
 545
 546
 547 # This function injects a bunch of testing methods to a numeric
 548 # value test case.
 549 #
 550 # It is meant to be used like this:
 551 #
 552 #     _inject_numeric_testing_methods(MyNumericValueTestCase)
 553 #
 554 # This function injects:
 555 #
 556 # * One testing method for each _TestNumericValue._test_binop_*()
 557 #   method, for each binary operator in the _BINOPS tuple.
 558 #
 559 # * One testing method for each _TestNumericValue._test_unaryop*()
 560 #   method, for each unary operator in the _UNARYOPS tuple.
 561 def _inject_numeric_testing_methods(cls):
 562     def test_binop_name(suffix):
 563         return "test_binop_{}_{}".format(name, suffix)
 564
 565     def test_unaryop_name(suffix):
 566         return "test_unaryop_{}_{}".format(name, suffix)
 567
 568     # inject testing methods for each binary operation
 569     for name, binop in _BINOPS:
 570         setattr(
 571             cls,
 572             test_binop_name("unknown"),
 573             partialmethod(_TestNumericValue._test_binop_unknown, op=binop),
 574         )
 575         setattr(
 576             cls,
 577             test_binop_name("none"),
 578             partialmethod(_TestNumericValue._test_binop_none, op=binop),
 579         )
 580         setattr(
 581             cls,
 582             test_binop_name("type_true"),
 583             partialmethod(_TestNumericValue._test_binop_type_true, op=binop),
 584         )
 585         setattr(
 586             cls,
 587             test_binop_name("type_pos_int"),
 588             partialmethod(_TestNumericValue._test_binop_type_pos_int, op=binop),
 589         )
 590         setattr(
 591             cls,
 592             test_binop_name("type_pos_vint"),
 593             partialmethod(_TestNumericValue._test_binop_type_pos_vint, op=binop),
 594         )
 595         setattr(
 596             cls,
 597             test_binop_name("value_true"),
 598             partialmethod(_TestNumericValue._test_binop_value_true, op=binop),
 599         )
 600         setattr(
 601             cls,
 602             test_binop_name("value_pos_int"),
 603             partialmethod(_TestNumericValue._test_binop_value_pos_int, op=binop),
 604         )
 605         setattr(
 606             cls,
 607             test_binop_name("value_pos_vint"),
 608             partialmethod(_TestNumericValue._test_binop_value_pos_vint, op=binop),
 609         )
 610         setattr(
 611             cls,
 612             test_binop_name("lhs_addr_same_true"),
 613             partialmethod(_TestNumericValue._test_binop_lhs_addr_same_true, op=binop),
 614         )
 615         setattr(
 616             cls,
 617             test_binop_name("lhs_addr_same_pos_int"),
 618             partialmethod(
 619                 _TestNumericValue._test_binop_lhs_addr_same_pos_int, op=binop
 620             ),
 621         )
 622         setattr(
 623             cls,
 624             test_binop_name("lhs_addr_same_pos_vint"),
 625             partialmethod(
 626                 _TestNumericValue._test_binop_lhs_addr_same_pos_vint, op=binop
 627             ),
 628         )
 629         setattr(
 630             cls,
 631             test_binop_name("lhs_value_same_true"),
 632             partialmethod(_TestNumericValue._test_binop_lhs_value_same_true, op=binop),
 633         )
 634         setattr(
 635             cls,
 636             test_binop_name("lhs_value_same_pos_int"),
 637             partialmethod(
 638                 _TestNumericValue._test_binop_lhs_value_same_pos_int, op=binop
 639             ),
 640         )
 641         setattr(
 642             cls,
 643             test_binop_name("lhs_value_same_pos_vint"),
 644             partialmethod(
 645                 _TestNumericValue._test_binop_lhs_value_same_pos_vint, op=binop
 646             ),
 647         )
 648         setattr(
 649             cls,
 650             test_binop_name("type_neg_int"),
 651             partialmethod(_TestNumericValue._test_binop_type_neg_int, op=binop),
 652         )
 653         setattr(
 654             cls,
 655             test_binop_name("type_neg_vint"),
 656             partialmethod(_TestNumericValue._test_binop_type_neg_vint, op=binop),
 657         )
 658         setattr(
 659             cls,
 660             test_binop_name("value_neg_int"),
 661             partialmethod(_TestNumericValue._test_binop_value_neg_int, op=binop),
 662         )
 663         setattr(
 664             cls,
 665             test_binop_name("value_neg_vint"),
 666             partialmethod(_TestNumericValue._test_binop_value_neg_vint, op=binop),
 667         )
 668         setattr(
 669             cls,
 670             test_binop_name("lhs_addr_same_neg_int"),
 671             partialmethod(
 672                 _TestNumericValue._test_binop_lhs_addr_same_neg_int, op=binop
 673             ),
 674         )
 675         setattr(
 676             cls,
 677             test_binop_name("lhs_addr_same_neg_vint"),
 678             partialmethod(
 679                 _TestNumericValue._test_binop_lhs_addr_same_neg_vint, op=binop
 680             ),
 681         )
 682         setattr(
 683             cls,
 684             test_binop_name("lhs_value_same_neg_int"),
 685             partialmethod(
 686                 _TestNumericValue._test_binop_lhs_value_same_neg_int, op=binop
 687             ),
 688         )
 689         setattr(
 690             cls,
 691             test_binop_name("lhs_value_same_neg_vint"),
 692             partialmethod(
 693                 _TestNumericValue._test_binop_lhs_value_same_neg_vint, op=binop
 694             ),
 695         )
 696         setattr(
 697             cls,
 698             test_binop_name("type_false"),
 699             partialmethod(_TestNumericValue._test_binop_type_false, op=binop),
 700         )
 701         setattr(
 702             cls,
 703             test_binop_name("type_zero_int"),
 704             partialmethod(_TestNumericValue._test_binop_type_zero_int, op=binop),
 705         )
 706         setattr(
 707             cls,
 708             test_binop_name("type_zero_vint"),
 709             partialmethod(_TestNumericValue._test_binop_type_zero_vint, op=binop),
 710         )
 711         setattr(
 712             cls,
 713             test_binop_name("value_false"),
 714             partialmethod(_TestNumericValue._test_binop_value_false, op=binop),
 715         )
 716         setattr(
 717             cls,
 718             test_binop_name("value_zero_int"),
 719             partialmethod(_TestNumericValue._test_binop_value_zero_int, op=binop),
 720         )
 721         setattr(
 722             cls,
 723             test_binop_name("value_zero_vint"),
 724             partialmethod(_TestNumericValue._test_binop_value_zero_vint, op=binop),
 725         )
 726         setattr(
 727             cls,
 728             test_binop_name("lhs_addr_same_false"),
 729             partialmethod(_TestNumericValue._test_binop_lhs_addr_same_false, op=binop),
 730         )
 731         setattr(
 732             cls,
 733             test_binop_name("lhs_addr_same_zero_int"),
 734             partialmethod(
 735                 _TestNumericValue._test_binop_lhs_addr_same_zero_int, op=binop
 736             ),
 737         )
 738         setattr(
 739             cls,
 740             test_binop_name("lhs_addr_same_zero_vint"),
 741             partialmethod(
 742                 _TestNumericValue._test_binop_lhs_addr_same_zero_vint, op=binop
 743             ),
 744         )
 745         setattr(
 746             cls,
 747             test_binop_name("lhs_value_same_false"),
 748             partialmethod(_TestNumericValue._test_binop_lhs_value_same_false, op=binop),
 749         )
 750         setattr(
 751             cls,
 752             test_binop_name("lhs_value_same_zero_int"),
 753             partialmethod(
 754                 _TestNumericValue._test_binop_lhs_value_same_zero_int, op=binop
 755             ),
 756         )
 757         setattr(
 758             cls,
 759             test_binop_name("lhs_value_same_zero_vint"),
 760             partialmethod(
 761                 _TestNumericValue._test_binop_lhs_value_same_zero_vint, op=binop
 762             ),
 763         )
 764         setattr(
 765             cls,
 766             test_binop_name("type_neg_float"),
 767             partialmethod(_TestNumericValue._test_binop_type_neg_float, op=binop),
 768         )
 769         setattr(
 770             cls,
 771             test_binop_name("type_neg_vfloat"),
 772             partialmethod(_TestNumericValue._test_binop_type_neg_vfloat, op=binop),
 773         )
 774         setattr(
 775             cls,
 776             test_binop_name("value_neg_float"),
 777             partialmethod(_TestNumericValue._test_binop_value_neg_float, op=binop),
 778         )
 779         setattr(
 780             cls,
 781             test_binop_name("value_neg_vfloat"),
 782             partialmethod(_TestNumericValue._test_binop_value_neg_vfloat, op=binop),
 783         )
 784         setattr(
 785             cls,
 786             test_binop_name("lhs_addr_same_neg_float"),
 787             partialmethod(
 788                 _TestNumericValue._test_binop_lhs_addr_same_neg_float, op=binop
 789             ),
 790         )
 791         setattr(
 792             cls,
 793             test_binop_name("lhs_addr_same_neg_vfloat"),
 794             partialmethod(
 795                 _TestNumericValue._test_binop_lhs_addr_same_neg_vfloat, op=binop
 796             ),
 797         )
 798         setattr(
 799             cls,
 800             test_binop_name("lhs_value_same_neg_float"),
 801             partialmethod(
 802                 _TestNumericValue._test_binop_lhs_value_same_neg_float, op=binop
 803             ),
 804         )
 805         setattr(
 806             cls,
 807             test_binop_name("lhs_value_same_neg_vfloat"),
 808             partialmethod(
 809                 _TestNumericValue._test_binop_lhs_value_same_neg_vfloat, op=binop
 810             ),
 811         )
 812         setattr(
 813             cls,
 814             test_binop_name("type_pos_float"),
 815             partialmethod(_TestNumericValue._test_binop_type_pos_float, op=binop),
 816         )
 817         setattr(
 818             cls,
 819             test_binop_name("type_pos_vfloat"),
 820             partialmethod(_TestNumericValue._test_binop_type_pos_vfloat, op=binop),
 821         )
 822         setattr(
 823             cls,
 824             test_binop_name("value_pos_float"),
 825             partialmethod(_TestNumericValue._test_binop_value_pos_float, op=binop),
 826         )
 827         setattr(
 828             cls,
 829             test_binop_name("value_pos_vfloat"),
 830             partialmethod(_TestNumericValue._test_binop_value_pos_vfloat, op=binop),
 831         )
 832         setattr(
 833             cls,
 834             test_binop_name("lhs_addr_same_pos_float"),
 835             partialmethod(
 836                 _TestNumericValue._test_binop_lhs_addr_same_pos_float, op=binop
 837             ),
 838         )
 839         setattr(
 840             cls,
 841             test_binop_name("lhs_addr_same_pos_vfloat"),
 842             partialmethod(
 843                 _TestNumericValue._test_binop_lhs_addr_same_pos_vfloat, op=binop
 844             ),
 845         )
 846         setattr(
 847             cls,
 848             test_binop_name("lhs_value_same_pos_float"),
 849             partialmethod(
 850                 _TestNumericValue._test_binop_lhs_value_same_pos_float, op=binop
 851             ),
 852         )
 853         setattr(
 854             cls,
 855             test_binop_name("lhs_value_same_pos_vfloat"),
 856             partialmethod(
 857                 _TestNumericValue._test_binop_lhs_value_same_pos_vfloat, op=binop
 858             ),
 859         )
 860         setattr(
 861             cls,
 862             test_binop_name("type_zero_float"),
 863             partialmethod(_TestNumericValue._test_binop_type_zero_float, op=binop),
 864         )
 865         setattr(
 866             cls,
 867             test_binop_name("type_zero_vfloat"),
 868             partialmethod(_TestNumericValue._test_binop_type_zero_vfloat, op=binop),
 869         )
 870         setattr(
 871             cls,
 872             test_binop_name("value_zero_float"),
 873             partialmethod(_TestNumericValue._test_binop_value_zero_float, op=binop),
 874         )
 875         setattr(
 876             cls,
 877             test_binop_name("value_zero_vfloat"),
 878             partialmethod(_TestNumericValue._test_binop_value_zero_vfloat, op=binop),
 879         )
 880         setattr(
 881             cls,
 882             test_binop_name("lhs_addr_same_zero_float"),
 883             partialmethod(
 884                 _TestNumericValue._test_binop_lhs_addr_same_zero_float, op=binop
 885             ),
 886         )
 887         setattr(
 888             cls,
 889             test_binop_name("lhs_addr_same_zero_vfloat"),
 890             partialmethod(
 891                 _TestNumericValue._test_binop_lhs_addr_same_zero_vfloat, op=binop
 892             ),
 893         )
 894         setattr(
 895             cls,
 896             test_binop_name("lhs_value_same_zero_float"),
 897             partialmethod(
 898                 _TestNumericValue._test_binop_lhs_value_same_zero_float, op=binop
 899             ),
 900         )
 901         setattr(
 902             cls,
 903             test_binop_name("lhs_value_same_zero_vfloat"),
 904             partialmethod(
 905                 _TestNumericValue._test_binop_lhs_value_same_zero_vfloat, op=binop
 906             ),
 907         )
 908         setattr(
 909             cls,
 910             test_binop_name("type_complex"),
 911             partialmethod(_TestNumericValue._test_binop_type_complex, op=binop),
 912         )
 913         setattr(
 914             cls,
 915             test_binop_name("type_zero_complex"),
 916             partialmethod(_TestNumericValue._test_binop_type_zero_complex, op=binop),
 917         )
 918         setattr(
 919             cls,
 920             test_binop_name("value_complex"),
 921             partialmethod(_TestNumericValue._test_binop_value_complex, op=binop),
 922         )
 923         setattr(
 924             cls,
 925             test_binop_name("value_zero_complex"),
 926             partialmethod(_TestNumericValue._test_binop_value_zero_complex, op=binop),
 927         )
 928         setattr(
 929             cls,
 930             test_binop_name("lhs_addr_same_complex"),
 931             partialmethod(
 932                 _TestNumericValue._test_binop_lhs_addr_same_complex, op=binop
 933             ),
 934         )
 935         setattr(
 936             cls,
 937             test_binop_name("lhs_addr_same_zero_complex"),
 938             partialmethod(
 939                 _TestNumericValue._test_binop_lhs_addr_same_zero_complex, op=binop
 940             ),
 941         )
 942         setattr(
 943             cls,
 944             test_binop_name("lhs_value_same_complex"),
 945             partialmethod(
 946                 _TestNumericValue._test_binop_lhs_value_same_complex, op=binop
 947             ),
 948         )
 949         setattr(
 950             cls,
 951             test_binop_name("lhs_value_same_zero_complex"),
 952             partialmethod(
 953                 _TestNumericValue._test_binop_lhs_value_same_zero_complex, op=binop
 954             ),
 955         )
 956
 957     # inject testing methods for each unary operation
 958     for name, unaryop in _UNARYOPS:
 959         setattr(
 960             cls,
 961             test_unaryop_name("type"),
 962             partialmethod(_TestNumericValue._test_unaryop_type, op=unaryop),
 963         )
 964         setattr(
 965             cls,
 966             test_unaryop_name("value"),
 967             partialmethod(_TestNumericValue._test_unaryop_value, op=unaryop),
 968         )
 969         setattr(
 970             cls,
 971             test_unaryop_name("addr_same"),
 972             partialmethod(_TestNumericValue._test_unaryop_addr_same, op=unaryop),
 973         )
 974         setattr(
 975             cls,
 976             test_unaryop_name("value_same"),
 977             partialmethod(_TestNumericValue._test_unaryop_value_same, op=unaryop),
 978         )
 979
 980
 981 class CreateValueFuncTestCase(unittest.TestCase):
 982     def test_create_none(self):
 983         v = bt2.create_value(None)
 984         self.assertIsNone(v)
 985
 986     def test_create_bool_false(self):
 987         v = bt2.create_value(False)
 988         self.assertIsInstance(v, bt2.BoolValue)
 989         self.assertFalse(v)
 990
 991     def test_create_bool_true(self):
 992         v = bt2.create_value(True)
 993         self.assertIsInstance(v, bt2.BoolValue)
 994         self.assertTrue(v)
 995
 996     def test_create_int_pos(self):
 997         raw = 23
 998         v = bt2.create_value(raw)
 999         self.assertIsInstance(v, bt2.SignedIntegerValue)
1000         self.assertEqual(v, raw)
1001
1002     def test_create_int_neg(self):
1003         raw = -23
1004         v = bt2.create_value(raw)
1005         self.assertIsInstance(v, bt2.SignedIntegerValue)
1006         self.assertEqual(v, raw)
1007
1008     def test_create_float_pos(self):
1009         raw = 17.5
1010         v = bt2.create_value(raw)
1011         self.assertIsInstance(v, bt2.RealValue)
1012         self.assertEqual(v, raw)
1013
1014     def test_create_float_neg(self):
1015         raw = -17.5
1016         v = bt2.create_value(raw)
1017         self.assertIsInstance(v, bt2.RealValue)
1018         self.assertEqual(v, raw)
1019
1020     def test_create_string(self):
1021         raw = "salut"
1022         v = bt2.create_value(raw)
1023         self.assertIsInstance(v, bt2.StringValue)
1024         self.assertEqual(v, raw)
1025
1026     def test_create_string_empty(self):
1027         raw = ""
1028         v = bt2.create_value(raw)
1029         self.assertIsInstance(v, bt2.StringValue)
1030         self.assertEqual(v, raw)
1031
1032     def test_create_array_from_list(self):
1033         raw = [1, 2, 3]
1034         v = bt2.create_value(raw)
1035         self.assertIsInstance(v, bt2.ArrayValue)
1036         self.assertEqual(v, raw)
1037
1038     def test_create_array_from_tuple(self):
1039         raw = 4, 5, 6
1040         v = bt2.create_value(raw)
1041         self.assertIsInstance(v, bt2.ArrayValue)
1042         self.assertEqual(v, raw)
1043
1044     def test_create_array_from_empty_list(self):
1045         raw = []
1046         v = bt2.create_value(raw)
1047         self.assertIsInstance(v, bt2.ArrayValue)
1048         self.assertEqual(v, raw)
1049
1050     def test_create_array_from_empty_tuple(self):
1051         raw = ()
1052         v = bt2.create_value(raw)
1053         self.assertIsInstance(v, bt2.ArrayValue)
1054         self.assertEqual(v, raw)
1055
1056     def test_create_map(self):
1057         raw = {"salut": 23}
1058         v = bt2.create_value(raw)
1059         self.assertIsInstance(v, bt2.MapValue)
1060         self.assertEqual(v, raw)
1061
1062     def test_create_map_empty(self):
1063         raw = {}
1064         v = bt2.create_value(raw)
1065         self.assertIsInstance(v, bt2.MapValue)
1066         self.assertEqual(v, raw)
1067
1068     def test_create_vfalse(self):
1069         v = bt2.create_value(bt2.create_value(False))
1070         self.assertIsInstance(v, bt2.BoolValue)
1071         self.assertFalse(v)
1072
1073     def test_create_invalid(self):
1074         class A:
1075             pass
1076
1077         a = A()
1078
1079         with self.assertRaisesRegex(
1080             TypeError, "cannot create value object from 'A' object"
1081         ):
1082             bt2.create_value(a)
1083
1084
1085 def _create_const_value(value):
1086     class MySink(bt2._UserSinkComponent):
1087         def _user_consume(self):
1088             pass
1089
1090         @classmethod
1091         def _user_query(cls, priv_query_exec, obj, params, method_obj):
1092             nonlocal value
1093             return {"my_value": value}
1094
1095     res = bt2.QueryExecutor(MySink, "obj", None).query()
1096     return res["my_value"]
1097
1098
1099 class BoolValueTestCase(_TestNumericValue, unittest.TestCase):
1100     def setUp(self):
1101         self._f = bt2.BoolValue(False)
1102         self._t = bt2.BoolValue(True)
1103         self._def = self._f
1104         self._def_value = False
1105         self._def_new_value = True
1106
1107     def tearDown(self):
1108         del self._f
1109         del self._t
1110         del self._def
1111
1112     def _assert_expecting_bool(self):
1113         return self.assertRaisesRegex(TypeError, r"expecting a 'bool' object")
1114
1115     def test_create_default(self):
1116         b = bt2.BoolValue()
1117         self.assertFalse(b)
1118
1119     def test_create_false(self):
1120         self.assertFalse(self._f)
1121
1122     def test_create_true(self):
1123         self.assertTrue(self._t)
1124
1125     def test_create_from_vfalse(self):
1126         b = bt2.BoolValue(self._f)
1127         self.assertFalse(b)
1128
1129     def test_create_from_vtrue(self):
1130         b = bt2.BoolValue(self._t)
1131         self.assertTrue(b)
1132
1133     def test_create_from_int_non_zero(self):
1134         with self.assertRaises(TypeError):
1135             bt2.BoolValue(23)
1136
1137     def test_create_from_int_zero(self):
1138         with self.assertRaises(TypeError):
1139             bt2.BoolValue(0)
1140
1141     def test_assign_true(self):
1142         b = bt2.BoolValue()
1143         b.value = True
1144         self.assertTrue(b)
1145
1146     def test_assign_false(self):
1147         b = bt2.BoolValue()
1148         b.value = False
1149         self.assertFalse(b)
1150
1151     def test_assign_vtrue(self):
1152         b = bt2.BoolValue()
1153         b.value = self._t
1154         self.assertTrue(b)
1155
1156     def test_assign_vfalse(self):
1157         b = bt2.BoolValue()
1158         b.value = False
1159         self.assertFalse(b)
1160
1161     def test_assign_int(self):
1162         with self.assertRaises(TypeError):
1163             b = bt2.BoolValue()
1164             b.value = 23
1165
1166     def test_bool_op(self):
1167         self.assertEqual(bool(self._def), bool(self._def_value))
1168
1169     def test_str_op(self):
1170         self.assertEqual(str(self._def), str(self._def_value))
1171
1172     def test_eq_none(self):
1173         # Disable the "comparison to None" warning, as this is precisely what
1174         # we want to test here.
1175         self.assertFalse(self._def == None)  # noqa: E711
1176
1177     def test_ne_none(self):
1178         # Disable the "comparison to None" warning, as this is precisely what
1179         # we want to test here.
1180         self.assertTrue(self._def != None)  # noqa: E711
1181
1182     def test_vfalse_eq_false(self):
1183         self.assertEqual(self._f, False)
1184
1185     def test_vfalse_ne_true(self):
1186         self.assertNotEqual(self._f, True)
1187
1188     def test_vtrue_eq_true(self):
1189         self.assertEqual(self._t, True)
1190
1191     def test_vtrue_ne_false(self):
1192         self.assertNotEqual(self._t, False)
1193
1194
1195 _inject_numeric_testing_methods(BoolValueTestCase)
1196
1197
1198 class _TestIntegerValue(_TestNumericValue):
1199     def setUp(self):
1200         self._pv = 23
1201         self._ip = self._CLS(self._pv)
1202         self._def = self._ip
1203         self._def_value = self._pv
1204         self._def_new_value = 101
1205
1206     def tearDown(self):
1207         del self._ip
1208         del self._def
1209         del self._def_value
1210
1211     def _assert_expecting_int(self):
1212         return self.assertRaisesRegex(TypeError, r"expecting an integral number object")
1213
1214     def _assert_expecting_int64(self):
1215         return self.assertRaisesRegex(
1216             ValueError, r"expecting a signed 64-bit integral value"
1217         )
1218
1219     def _assert_expecting_uint64(self):
1220         return self.assertRaisesRegex(
1221             ValueError, r"expecting an unsigned 64-bit integral value"
1222         )
1223
1224     def test_create_default(self):
1225         i = self._CLS()
1226         self.assertEqual(i, 0)
1227
1228     def test_create_pos(self):
1229         self.assertEqual(self._ip, self._pv)
1230
1231     def test_create_from_vint(self):
1232         i = self._CLS(self._ip)
1233         self.assertEqual(i, self._pv)
1234
1235     def test_create_from_false(self):
1236         i = self._CLS(False)
1237         self.assertFalse(i)
1238
1239     def test_create_from_true(self):
1240         i = self._CLS(True)
1241         self.assertTrue(i)
1242
1243     def test_create_from_unknown(self):
1244         class A:
1245             pass
1246
1247         with self._assert_expecting_int():
1248             self._CLS(A())
1249
1250     def test_create_from_varray(self):
1251         with self._assert_expecting_int():
1252             self._CLS(bt2.ArrayValue())
1253
1254     def test_assign_true(self):
1255         raw = True
1256         self._def.value = raw
1257         self.assertEqual(self._def, raw)
1258
1259     def test_assign_false(self):
1260         raw = False
1261         self._def.value = raw
1262         self.assertEqual(self._def, raw)
1263
1264     def test_assign_pos_int(self):
1265         raw = 477
1266         self._def.value = raw
1267         self.assertEqual(self._def, raw)
1268
1269     def test_assign_vint(self):
1270         raw = 999
1271         self._def.value = bt2.create_value(raw)
1272         self.assertEqual(self._def, raw)
1273
1274
1275 class SignedIntegerValueTestCase(_TestIntegerValue, unittest.TestCase):
1276     _CLS = bt2.SignedIntegerValue
1277
1278     def setUp(self):
1279         super().setUp()
1280         self._nv = -52
1281         self._in = self._CLS(self._nv)
1282         self._def_new_value = -101
1283
1284     def tearDown(self):
1285         super().tearDown()
1286         del self._in
1287
1288     def test_create_neg(self):
1289         self.assertEqual(self._in, self._nv)
1290
1291     def test_create_pos_too_big(self):
1292         with self._assert_expecting_int64():
1293             self._CLS(2**63)
1294
1295     def test_create_neg_too_big(self):
1296         with self._assert_expecting_int64():
1297             self._CLS(-(2**63) - 1)
1298
1299     def test_assign_neg_int(self):
1300         raw = -13
1301         self._def.value = raw
1302         self.assertEqual(self._def, raw)
1303
1304     def test_compare_big_int(self):
1305         # Larger than the IEEE 754 double-precision exact representation of
1306         # integers.
1307         raw = (2**53) + 1
1308         v = bt2.create_value(raw)
1309         self.assertEqual(v, raw)
1310
1311
1312 _inject_numeric_testing_methods(SignedIntegerValueTestCase)
1313
1314
1315 class UnsignedIntegerValueTestCase(_TestIntegerValue, unittest.TestCase):
1316     _CLS = bt2.UnsignedIntegerValue
1317
1318     def test_create_pos_too_big(self):
1319         with self._assert_expecting_uint64():
1320             self._CLS(2**64)
1321
1322     def test_create_neg(self):
1323         with self._assert_expecting_uint64():
1324             self._CLS(-1)
1325
1326
1327 _inject_numeric_testing_methods(UnsignedIntegerValueTestCase)
1328
1329
1330 class RealValueTestCase(_TestNumericValue, unittest.TestCase):
1331     def setUp(self):
1332         self._pv = 23.4
1333         self._nv = -52.7
1334         self._fp = bt2.RealValue(self._pv)
1335         self._fn = bt2.RealValue(self._nv)
1336         self._def = self._fp
1337         self._def_value = self._pv
1338         self._def_new_value = -101.88
1339
1340     def tearDown(self):
1341         del self._fp
1342         del self._fn
1343         del self._def
1344         del self._def_value
1345
1346     def _assert_expecting_float(self):
1347         return self.assertRaisesRegex(TypeError, r"expecting a real number object")
1348
1349     def _test_invalid_op(self, cb):
1350         with self.assertRaises(TypeError):
1351             cb()
1352
1353     def test_create_default(self):
1354         f = bt2.RealValue()
1355         self.assertEqual(f, 0.0)
1356
1357     def test_create_pos(self):
1358         self.assertEqual(self._fp, self._pv)
1359
1360     def test_create_neg(self):
1361         self.assertEqual(self._fn, self._nv)
1362
1363     def test_create_from_false(self):
1364         f = bt2.RealValue(False)
1365         self.assertFalse(f)
1366
1367     def test_create_from_true(self):
1368         f = bt2.RealValue(True)
1369         self.assertTrue(f)
1370
1371     def test_create_from_int(self):
1372         raw = 17
1373         f = bt2.RealValue(raw)
1374         self.assertEqual(f, float(raw))
1375
1376     def test_create_from_vint(self):
1377         raw = 17
1378         f = bt2.RealValue(bt2.create_value(raw))
1379         self.assertEqual(f, float(raw))
1380
1381     def test_create_from_vfloat(self):
1382         raw = 17.17
1383         f = bt2.RealValue(bt2.create_value(raw))
1384         self.assertEqual(f, raw)
1385
1386     def test_create_from_unknown(self):
1387         class A:
1388             pass
1389
1390         with self._assert_expecting_float():
1391             bt2.RealValue(A())
1392
1393     def test_create_from_varray(self):
1394         with self._assert_expecting_float():
1395             bt2.RealValue(bt2.ArrayValue())
1396
1397     def test_assign_true(self):
1398         self._def.value = True
1399         self.assertTrue(self._def)
1400
1401     def test_assign_false(self):
1402         self._def.value = False
1403         self.assertFalse(self._def)
1404
1405     def test_assign_pos_int(self):
1406         raw = 477
1407         self._def.value = raw
1408         self.assertEqual(self._def, float(raw))
1409
1410     def test_assign_neg_int(self):
1411         raw = -13
1412         self._def.value = raw
1413         self.assertEqual(self._def, float(raw))
1414
1415     def test_assign_vint(self):
1416         raw = 999
1417         self._def.value = bt2.create_value(raw)
1418         self.assertEqual(self._def, float(raw))
1419
1420     def test_assign_float(self):
1421         raw = -19.23
1422         self._def.value = raw
1423         self.assertEqual(self._def, raw)
1424
1425     def test_assign_vfloat(self):
1426         raw = 101.32
1427         self._def.value = bt2.create_value(raw)
1428         self.assertEqual(self._def, raw)
1429
1430     def test_invalid_lshift(self):
1431         self._test_invalid_op(lambda: self._def << 23)
1432
1433     def test_invalid_rshift(self):
1434         self._test_invalid_op(lambda: self._def >> 23)
1435
1436     def test_invalid_and(self):
1437         self._test_invalid_op(lambda: self._def & 23)
1438
1439     def test_invalid_or(self):
1440         self._test_invalid_op(lambda: self._def | 23)
1441
1442     def test_invalid_xor(self):
1443         self._test_invalid_op(lambda: self._def ^ 23)
1444
1445     def test_invalid_invert(self):
1446         self._test_invalid_op(lambda: ~self._def)
1447
1448
1449 _inject_numeric_testing_methods(RealValueTestCase)
1450
1451
1452 class StringValueTestCase(_TestCopySimple, unittest.TestCase):
1453     def setUp(self):
1454         self._def_value = "Hello, World!"
1455         self._def = bt2.StringValue(self._def_value)
1456         self._def_const = _create_const_value(self._def_value)
1457         self._def_new_value = "Yes!"
1458
1459     def tearDown(self):
1460         del self._def
1461
1462     def _assert_expecting_str(self):
1463         return self.assertRaises(TypeError)
1464
1465     def test_create_default(self):
1466         s = bt2.StringValue()
1467         self.assertEqual(s, "")
1468
1469     def test_create_from_str(self):
1470         raw = "liberté"
1471         s = bt2.StringValue(raw)
1472         self.assertEqual(s, raw)
1473
1474     def test_create_from_vstr(self):
1475         raw = "liberté"
1476         s = bt2.StringValue(bt2.create_value(raw))
1477         self.assertEqual(s, raw)
1478
1479     def test_create_from_unknown(self):
1480         class A:
1481             pass
1482
1483         with self._assert_expecting_str():
1484             bt2.StringValue(A())
1485
1486     def test_create_from_varray(self):
1487         with self._assert_expecting_str():
1488             bt2.StringValue(bt2.ArrayValue())
1489
1490     def test_assign_int(self):
1491         with self._assert_expecting_str():
1492             self._def.value = 283
1493
1494     def test_assign_str(self):
1495         raw = "zorg"
1496         self._def = raw
1497         self.assertEqual(self._def, raw)
1498
1499     def test_assign_vstr(self):
1500         raw = "zorg"
1501         self._def = bt2.create_value(raw)
1502         self.assertEqual(self._def, raw)
1503
1504     def test_eq(self):
1505         self.assertEqual(self._def, self._def_value)
1506
1507     def test_const_eq(self):
1508         self.assertEqual(self._def_const, self._def_value)
1509
1510     def test_eq_raw(self):
1511         self.assertNotEqual(self._def, 23)
1512
1513     def test_lt_vstring(self):
1514         s1 = bt2.StringValue("allo")
1515         s2 = bt2.StringValue("bateau")
1516         self.assertLess(s1, s2)
1517
1518     def test_lt_string(self):
1519         s1 = bt2.StringValue("allo")
1520         self.assertLess(s1, "bateau")
1521
1522     def test_le_vstring(self):
1523         s1 = bt2.StringValue("allo")
1524         s2 = bt2.StringValue("bateau")
1525         self.assertLessEqual(s1, s2)
1526
1527     def test_le_string(self):
1528         s1 = bt2.StringValue("allo")
1529         self.assertLessEqual(s1, "bateau")
1530
1531     def test_gt_vstring(self):
1532         s1 = bt2.StringValue("allo")
1533         s2 = bt2.StringValue("bateau")
1534         self.assertGreater(s2, s1)
1535
1536     def test_gt_string(self):
1537         s1 = bt2.StringValue("allo")
1538         self.assertGreater("bateau", s1)
1539
1540     def test_ge_vstring(self):
1541         s1 = bt2.StringValue("allo")
1542         s2 = bt2.StringValue("bateau")
1543         self.assertGreaterEqual(s2, s1)
1544
1545     def test_ge_string(self):
1546         s1 = bt2.StringValue("allo")
1547         self.assertGreaterEqual("bateau", s1)
1548
1549     def test_in_string(self):
1550         s1 = bt2.StringValue("beau grand bateau")
1551         self.assertIn("bateau", s1)
1552
1553     def test_in_vstring(self):
1554         s1 = bt2.StringValue("beau grand bateau")
1555         s2 = bt2.StringValue("bateau")
1556         self.assertIn(s2, s1)
1557
1558     def test_bool_op(self):
1559         self.assertEqual(bool(self._def), bool(self._def_value))
1560
1561     def test_str_op(self):
1562         self.assertEqual(str(self._def), str(self._def_value))
1563
1564     def test_len(self):
1565         self.assertEqual(len(self._def), len(self._def_value))
1566
1567     def test_getitem(self):
1568         self.assertEqual(self._def[5], self._def_value[5])
1569
1570     def test_const_getitem(self):
1571         self.assertEqual(self._def_const[5], self._def_value[5])
1572
1573     def test_iadd_str(self):
1574         to_append = "meow meow meow"
1575         self._def += to_append
1576         self._def_value += to_append
1577         self.assertEqual(self._def, self._def_value)
1578
1579     def test_const_iadd_str(self):
1580         to_append = "meow meow meow"
1581         with self.assertRaises(TypeError):
1582             self._def_const += to_append
1583
1584         self.assertEqual(self._def_const, self._def_value)
1585
1586     def test_append_vstr(self):
1587         to_append = "meow meow meow"
1588         self._def += bt2.create_value(to_append)
1589         self._def_value += to_append
1590         self.assertEqual(self._def, self._def_value)
1591
1592
1593 class ArrayValueTestCase(_TestCopySimple, unittest.TestCase):
1594     def setUp(self):
1595         self._def_value = [None, False, True, -23, 0, 42, -42.4, 23.17, "yes"]
1596         self._def = bt2.ArrayValue(copy.deepcopy(self._def_value))
1597         self._def_const = _create_const_value(copy.deepcopy(self._def_value))
1598
1599     def tearDown(self):
1600         del self._def
1601
1602     def _modify_def(self):
1603         self._def[2] = "xyz"
1604
1605     def _assert_type_error(self):
1606         return self.assertRaises(TypeError)
1607
1608     def test_create_default(self):
1609         a = bt2.ArrayValue()
1610         self.assertEqual(len(a), 0)
1611
1612     def test_create_from_array(self):
1613         self.assertEqual(self._def, self._def_value)
1614
1615     def test_create_from_tuple(self):
1616         t = 1, 2, False, None
1617         a = bt2.ArrayValue(t)
1618         self.assertEqual(a, t)
1619
1620     def test_create_from_varray(self):
1621         va = bt2.ArrayValue(copy.deepcopy(self._def_value))
1622         a = bt2.ArrayValue(va)
1623         self.assertEqual(va, a)
1624
1625     def test_create_from_unknown(self):
1626         class A:
1627             pass
1628
1629         with self._assert_type_error():
1630             bt2.ArrayValue(A())
1631
1632     def test_bool_op_true(self):
1633         self.assertTrue(bool(self._def))
1634
1635     def test_bool_op_false(self):
1636         self.assertFalse(bool(bt2.ArrayValue()))
1637
1638     def test_len(self):
1639         self.assertEqual(len(self._def), len(self._def_value))
1640
1641     def test_eq_int(self):
1642         self.assertNotEqual(self._def, 23)
1643
1644     def test_const_eq(self):
1645         a1 = _create_const_value([1, 2, 3])
1646         a2 = [1, 2, 3]
1647         self.assertEqual(a1, a2)
1648
1649     def test_eq_diff_len(self):
1650         a1 = bt2.create_value([1, 2, 3])
1651         a2 = bt2.create_value([1, 2])
1652         self.assertIs(type(a1), bt2.ArrayValue)
1653         self.assertIs(type(a2), bt2.ArrayValue)
1654         self.assertNotEqual(a1, a2)
1655
1656     def test_eq_diff_content_same_len(self):
1657         a1 = bt2.create_value([1, 2, 3])
1658         a2 = bt2.create_value([4, 5, 6])
1659         self.assertNotEqual(a1, a2)
1660
1661     def test_eq_same_content_same_len(self):
1662         raw = (3, True, [1, 2.5, None, {"a": 17.6, "b": None}])
1663         a1 = bt2.ArrayValue(raw)
1664         a2 = bt2.ArrayValue(copy.deepcopy(raw))
1665         self.assertEqual(a1, a2)
1666
1667     def test_eq_non_sequence_iterable(self):
1668         dct = collections.OrderedDict([(1, 2), (3, 4), (5, 6)])
1669         a = bt2.ArrayValue((1, 3, 5))
1670         self.assertEqual(a, list(dct.keys()))
1671         self.assertNotEqual(a, dct)
1672
1673     def test_setitem_int(self):
1674         raw = 19
1675         self._def[2] = raw
1676         self.assertEqual(self._def[2], raw)
1677
1678     def test_setitem_vint(self):
1679         raw = 19
1680         self._def[2] = bt2.create_value(raw)
1681         self.assertEqual(self._def[2], raw)
1682
1683     def test_setitem_none(self):
1684         self._def[2] = None
1685         self.assertIsNone(self._def[2])
1686
1687     def test_setitem_index_wrong_type(self):
1688         with self._assert_type_error():
1689             self._def["yes"] = 23
1690
1691     def test_setitem_index_neg(self):
1692         with self.assertRaises(IndexError):
1693             self._def[-2] = 23
1694
1695     def test_setitem_index_out_of_range(self):
1696         with self.assertRaises(IndexError):
1697             self._def[len(self._def)] = 23
1698
1699     def test_const_setitem(self):
1700         with self.assertRaises(TypeError):
1701             self._def_const[2] = 19
1702
1703     def test_append_none(self):
1704         self._def.append(None)
1705         self.assertIsNone(self._def[len(self._def) - 1])
1706
1707     def test_append_int(self):
1708         raw = 145
1709         self._def.append(raw)
1710         self.assertEqual(self._def[len(self._def) - 1], raw)
1711
1712     def test_const_append(self):
1713         with self.assertRaises(AttributeError):
1714             self._def_const.append(12194)
1715
1716     def test_append_vint(self):
1717         raw = 145
1718         self._def.append(bt2.create_value(raw))
1719         self.assertEqual(self._def[len(self._def) - 1], raw)
1720
1721     def test_append_unknown(self):
1722         class A:
1723             pass
1724
1725         with self._assert_type_error():
1726             self._def.append(A())
1727
1728     def test_iadd(self):
1729         raw = 4, 5, True
1730         self._def += raw
1731         self.assertEqual(self._def[len(self._def) - 3], raw[0])
1732         self.assertEqual(self._def[len(self._def) - 2], raw[1])
1733         self.assertEqual(self._def[len(self._def) - 1], raw[2])
1734
1735     def test_const_iadd(self):
1736         with self.assertRaises(TypeError):
1737             self._def_const += 12194
1738
1739     def test_iadd_unknown(self):
1740         class A:
1741             pass
1742
1743         with self._assert_type_error():
1744             self._def += A()
1745
1746     def test_iadd_list_unknown(self):
1747         class A:
1748             pass
1749
1750         with self._assert_type_error():
1751             self._def += [A()]
1752
1753     def test_iter(self):
1754         for velem, elem in zip(self._def, self._def_value):
1755             self.assertEqual(velem, elem)
1756
1757     def test_const_iter(self):
1758         for velem, elem in zip(self._def_const, self._def_value):
1759             self.assertEqual(velem, elem)
1760
1761     def test_const_get_item(self):
1762         item1 = self._def_const[0]
1763         item2 = self._def_const[2]
1764         item3 = self._def_const[5]
1765         item4 = self._def_const[7]
1766         item5 = self._def_const[8]
1767
1768         self.assertEqual(item1, None)
1769
1770         self.assertIs(type(item2), bt2._BoolValueConst)
1771         self.assertEqual(item2, True)
1772
1773         self.assertIs(type(item3), bt2._SignedIntegerValueConst)
1774         self.assertEqual(item3, 42)
1775
1776         self.assertIs(type(item4), bt2._RealValueConst)
1777         self.assertEqual(item4, 23.17)
1778
1779         self.assertIs(type(item5), bt2._StringValueConst)
1780         self.assertEqual(item5, "yes")
1781
1782
1783 class MapValueTestCase(_TestCopySimple, unittest.TestCase):
1784     def setUp(self):
1785         self._def_value = {
1786             "none": None,
1787             "false": False,
1788             "true": True,
1789             "neg-int": -23,
1790             "zero": 0,
1791             "pos-int": 42,
1792             "neg-float": -42.4,
1793             "pos-float": 23.17,
1794             "str": "yes",
1795         }
1796         self._def = bt2.MapValue(copy.deepcopy(self._def_value))
1797         self._def_const = _create_const_value(self._def_value)
1798
1799     def tearDown(self):
1800         del self._def
1801
1802     def _modify_def(self):
1803         self._def["zero"] = 1
1804
1805     def test_create_default(self):
1806         m = bt2.MapValue()
1807         self.assertEqual(len(m), 0)
1808
1809     def test_create_from_dict(self):
1810         self.assertEqual(self._def, self._def_value)
1811
1812     def test_create_from_vmap(self):
1813         vm = bt2.MapValue(copy.deepcopy(self._def_value))
1814         m = bt2.MapValue(vm)
1815         self.assertEqual(vm, m)
1816
1817     def test_create_from_unknown(self):
1818         class A:
1819             pass
1820
1821         with self.assertRaises(AttributeError):
1822             bt2.MapValue(A())
1823
1824     def test_bool_op_true(self):
1825         self.assertTrue(bool(self._def))
1826
1827     def test_bool_op_false(self):
1828         self.assertFalse(bool(bt2.MapValue()))
1829
1830     def test_len(self):
1831         self.assertEqual(len(self._def), len(self._def_value))
1832
1833     def test_const_eq(self):
1834         a1 = _create_const_value({"a": 1, "b": 2, "c": 3})
1835         a2 = {"a": 1, "b": 2, "c": 3}
1836         self.assertEqual(a1, a2)
1837
1838     def test_eq_int(self):
1839         self.assertNotEqual(self._def, 23)
1840
1841     def test_eq_diff_len(self):
1842         a1 = bt2.create_value({"a": 1, "b": 2, "c": 3})
1843         a2 = bt2.create_value({"a": 1, "b": 2})
1844         self.assertNotEqual(a1, a2)
1845
1846     def test_const_eq_diff_len(self):
1847         a1 = _create_const_value({"a": 1, "b": 2, "c": 3})
1848         a2 = _create_const_value({"a": 1, "b": 2})
1849         self.assertNotEqual(a1, a2)
1850
1851     def test_eq_diff_content_same_len(self):
1852         a1 = bt2.create_value({"a": 1, "b": 2, "c": 3})
1853         a2 = bt2.create_value({"a": 4, "b": 2, "c": 3})
1854         self.assertNotEqual(a1, a2)
1855
1856     def test_const_eq_diff_content_same_len(self):
1857         a1 = _create_const_value({"a": 1, "b": 2, "c": 3})
1858         a2 = _create_const_value({"a": 4, "b": 2, "c": 3})
1859         self.assertNotEqual(a1, a2)
1860
1861     def test_eq_same_content_diff_keys(self):
1862         a1 = bt2.create_value({"a": 1, "b": 2, "c": 3})
1863         a2 = bt2.create_value({"a": 1, "k": 2, "c": 3})
1864         self.assertNotEqual(a1, a2)
1865
1866     def test_const_eq_same_content_diff_keys(self):
1867         a1 = _create_const_value({"a": 1, "b": 2, "c": 3})
1868         a2 = _create_const_value({"a": 1, "k": 2, "c": 3})
1869         self.assertNotEqual(a1, a2)
1870
1871     def test_eq_same_content_same_len(self):
1872         raw = {"3": 3, "True": True, "array": [1, 2.5, None, {"a": 17.6, "b": None}]}
1873         a1 = bt2.MapValue(raw)
1874         a2 = bt2.MapValue(copy.deepcopy(raw))
1875         self.assertEqual(a1, a2)
1876         self.assertEqual(a1, raw)
1877
1878     def test_const_eq_same_content_same_len(self):
1879         raw = {"3": 3, "True": True, "array": [1, 2.5, None, {"a": 17.6, "b": None}]}
1880         a1 = _create_const_value(raw)
1881         a2 = _create_const_value(copy.deepcopy(raw))
1882         self.assertEqual(a1, a2)
1883         self.assertEqual(a1, raw)
1884
1885     def test_setitem_int(self):
1886         raw = 19
1887         self._def["pos-int"] = raw
1888         self.assertEqual(self._def["pos-int"], raw)
1889
1890     def test_const_setitem_int(self):
1891         with self.assertRaises(TypeError):
1892             self._def_const["pos-int"] = 19
1893
1894     def test_setitem_vint(self):
1895         raw = 19
1896         self._def["pos-int"] = bt2.create_value(raw)
1897         self.assertEqual(self._def["pos-int"], raw)
1898
1899     def test_setitem_none(self):
1900         self._def["none"] = None
1901         self.assertIsNone(self._def["none"])
1902
1903     def test_setitem_new_int(self):
1904         old_len = len(self._def)
1905         self._def["new-int"] = 23
1906         self.assertEqual(self._def["new-int"], 23)
1907         self.assertEqual(len(self._def), old_len + 1)
1908
1909     def test_setitem_index_wrong_type(self):
1910         with self.assertRaises(TypeError):
1911             self._def[18] = 23
1912
1913     def test_iter(self):
1914         for vkey, vval in self._def.items():
1915             val = self._def_value[vkey]
1916             self.assertEqual(vval, val)
1917
1918     def test_const_iter(self):
1919         for vkey, vval in self._def_const.items():
1920             val = self._def_value[vkey]
1921             self.assertEqual(vval, val)
1922
1923     def test_get_item(self):
1924         i = self._def["pos-float"]
1925         self.assertIs(type(i), bt2.RealValue)
1926         self.assertEqual(i, 23.17)
1927
1928     def test_const_get_item(self):
1929         item1 = self._def_const["none"]
1930         item2 = self._def_const["true"]
1931         item3 = self._def_const["pos-int"]
1932         item4 = self._def_const["pos-float"]
1933         item5 = self._def_const["str"]
1934
1935         self.assertEqual(item1, None)
1936
1937         self.assertIs(type(item2), bt2._BoolValueConst)
1938         self.assertEqual(item2, True)
1939
1940         self.assertIs(type(item3), bt2._SignedIntegerValueConst)
1941         self.assertEqual(item3, 42)
1942
1943         self.assertIs(type(item4), bt2._RealValueConst)
1944         self.assertEqual(item4, 23.17)
1945
1946         self.assertIs(type(item5), bt2._StringValueConst)
1947         self.assertEqual(item5, "yes")
1948
1949     def test_getitem_wrong_key(self):
1950         with self.assertRaises(KeyError):
1951             self._def["kilojoule"]
1952
1953
1954 if __name__ == "__main__":
1955     unittest.main()