2 # Copyright (C) 2019 EfficiOS Inc.
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
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.
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.
19 from functools
import partial
, partialmethod
28 # The value object classes explicitly do not implement the copy methods,
29 # raising `NotImplementedError`, just in case we decide to implement
31 class _TestCopySimple
:
33 with self
.assertRaises(NotImplementedError):
36 def test_deepcopy(self
):
37 with self
.assertRaises(NotImplementedError):
38 copy
.deepcopy(self
._def
)
41 _COMP_BINOPS
= (operator
.eq
, operator
.ne
)
44 # Base class for numeric value test cases.
46 # To be compatible with this base class, a derived class must, in its
49 # * Set `self._def` to a value object with an arbitrary raw value.
50 # * Set `self._def_value` to the equivalent raw value of `self._def`.
51 class _TestNumericValue(_TestCopySimple
):
52 # Tries the binary operation `op`:
54 # 1. Between `self._def`, which is a value object, and `rhs`.
55 # 2. Between `self._def_value`, which is the raw value of
56 # `self._def`, and `rhs`.
58 # Returns the results of 1. and 2.
60 # If there's an exception while performing 1. or 2., asserts that
61 # both operations raised exceptions, that both exceptions have the
62 # same type, and returns `None` for both results.
63 def _binop(self
, op
, rhs
):
68 # try with value object
70 r
= op(self
._def
, rhs
)
71 except Exception as e
:
76 rv
= op(self
._def
_value
, comp_value
)
77 except Exception as e
:
80 if type_rexc
is not None or type_rvexc
is not None:
81 # at least one of the operations raised an exception: in
82 # this case both operations should have raised the same
83 # type of exception (division by zero, bit shift with a
84 # floating point number operand, etc.)
85 self
.assertIs(type_rexc
, type_rvexc
)
90 # Tries the unary operation `op`:
92 # 1. On `self._def`, which is a value object.
93 # 2. On `self._def_value`, which is the raw value of `self._def`.
95 # Returns the results of 1. and 2.
97 # If there's an exception while performing 1. or 2., asserts that
98 # both operations raised exceptions, that both exceptions have the
99 # same type, and returns `None` for both results.
100 def _unaryop(self
, op
):
104 # try with value object
107 except Exception as e
:
112 rv
= op(self
._def
_value
)
113 except Exception as e
:
116 if type_rexc
is not None or type_rvexc
is not None:
117 # at least one of the operations raised an exception: in
118 # this case both operations should have raised the same
119 # type of exception (division by zero, bit shift with a
120 # floating point number operand, etc.)
121 self
.assertIs(type_rexc
, type_rvexc
)
126 # Tests that the unary operation `op` gives results with the same
127 # type for both `self._def` and `self._def_value`.
128 def _test_unaryop_type(self
, op
):
129 r
, rv
= self
._unaryop
(op
)
134 self
.assertIsInstance(r
, type(rv
))
136 # Tests that the unary operation `op` gives results with the same
137 # value for both `self._def` and `self._def_value`. This uses the
138 # __eq__() operator of `self._def`.
139 def _test_unaryop_value(self
, op
):
140 r
, rv
= self
._unaryop
(op
)
145 self
.assertEqual(r
, rv
)
147 # Tests that the unary operation `op`, when applied to `self._def`,
148 # does not change its underlying BT object address.
149 def _test_unaryop_addr_same(self
, op
):
150 addr_before
= self
._def
.addr
152 self
.assertEqual(self
._def
.addr
, addr_before
)
154 # Tests that the unary operation `op`, when applied to `self._def`,
155 # does not change its value.
156 def _test_unaryop_value_same(self
, op
):
157 value_before
= self
._def
.__class
__(self
._def
)
159 self
.assertEqual(self
._def
, value_before
)
161 # Tests that the binary operation `op` gives results with the same
162 # type for both `self._def` and `self._def_value`.
163 def _test_binop_type(self
, op
, rhs
):
164 r
, rv
= self
._binop
(op
, rhs
)
169 if op
in _COMP_BINOPS
:
170 # __eq__() and __ne__() always return a 'bool' object
171 self
.assertIsInstance(r
, bool)
173 self
.assertIsInstance(r
, type(rv
))
175 # Tests that the binary operation `op` gives results with the same
176 # value for both `self._def` and `self._def_value`. This uses the
177 # __eq__() operator of `self._def`.
178 def _test_binop_value(self
, op
, rhs
):
179 r
, rv
= self
._binop
(op
, rhs
)
184 self
.assertEqual(r
, rv
)
186 # Tests that the binary operation `op`, when applied to `self._def`,
187 # does not change its underlying BT object address.
188 def _test_binop_lhs_addr_same(self
, op
, rhs
):
189 addr_before
= self
._def
.addr
190 r
, rv
= self
._binop
(op
, rhs
)
191 self
.assertEqual(self
._def
.addr
, addr_before
)
193 # Tests that the binary operation `op`, when applied to `self._def`,
194 # does not change its value.
195 def _test_binop_lhs_value_same(self
, op
, rhs
):
196 value_before
= self
._def
.__class
__(self
._def
)
197 r
, rv
= self
._binop
(op
, rhs
)
198 self
.assertEqual(self
._def
, value_before
)
200 # The methods below which take the `test_cb` and `op` parameters
201 # are meant to be used with one of the _test_binop_*() functions
202 # above as `test_cb` and a binary operator function as `op`.
206 # self._test_binop_rhs_pos_int(self._test_binop_value,
209 # This tests that a numeric value object added to a positive integer
210 # raw value gives a result with the expected value.
212 # `vint` and `vfloat` mean a signed integer value object and a real
215 def _test_binop_unknown(self
, op
):
216 if op
is operator
.eq
:
217 self
.assertIs(op(self
._def
, object()), False)
218 elif op
is operator
.ne
:
219 self
.assertIs(op(self
._def
, object()), True)
221 with self
.assertRaises(TypeError):
222 op(self
._def
, object())
224 def _test_binop_none(self
, op
):
225 if op
is operator
.eq
:
226 self
.assertIs(op(self
._def
, None), False)
227 elif op
is operator
.ne
:
228 self
.assertIs(op(self
._def
, None), True)
230 with self
.assertRaises(TypeError):
233 def _test_binop_rhs_false(self
, test_cb
, op
):
236 def _test_binop_rhs_true(self
, test_cb
, op
):
239 def _test_binop_rhs_pos_int(self
, test_cb
, op
):
242 def _test_binop_rhs_neg_int(self
, test_cb
, op
):
245 def _test_binop_rhs_zero_int(self
, test_cb
, op
):
248 def _test_binop_rhs_pos_vint(self
, test_cb
, op
):
249 test_cb(op
, bt2
.create_value(2))
251 def _test_binop_rhs_neg_vint(self
, test_cb
, op
):
252 test_cb(op
, bt2
.create_value(-23))
254 def _test_binop_rhs_zero_vint(self
, test_cb
, op
):
255 test_cb(op
, bt2
.create_value(0))
257 def _test_binop_rhs_pos_float(self
, test_cb
, op
):
260 def _test_binop_rhs_neg_float(self
, test_cb
, op
):
263 def _test_binop_rhs_zero_float(self
, test_cb
, op
):
266 def _test_binop_rhs_complex(self
, test_cb
, op
):
267 test_cb(op
, -23 + 19j
)
269 def _test_binop_rhs_zero_complex(self
, test_cb
, op
):
272 def _test_binop_rhs_pos_vfloat(self
, test_cb
, op
):
273 test_cb(op
, bt2
.create_value(2.2))
275 def _test_binop_rhs_neg_vfloat(self
, test_cb
, op
):
276 test_cb(op
, bt2
.create_value(-23.4))
278 def _test_binop_rhs_zero_vfloat(self
, test_cb
, op
):
279 test_cb(op
, bt2
.create_value(0.0))
281 def _test_binop_type_false(self
, op
):
282 self
._test
_binop
_rhs
_false
(self
._test
_binop
_type
, op
)
284 def _test_binop_type_true(self
, op
):
285 self
._test
_binop
_rhs
_true
(self
._test
_binop
_type
, op
)
287 def _test_binop_type_pos_int(self
, op
):
288 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_type
, op
)
290 def _test_binop_type_neg_int(self
, op
):
291 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_type
, op
)
293 def _test_binop_type_zero_int(self
, op
):
294 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_type
, op
)
296 def _test_binop_type_pos_vint(self
, op
):
297 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_type
, op
)
299 def _test_binop_type_neg_vint(self
, op
):
300 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_type
, op
)
302 def _test_binop_type_zero_vint(self
, op
):
303 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_type
, op
)
305 def _test_binop_type_pos_float(self
, op
):
306 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_type
, op
)
308 def _test_binop_type_neg_float(self
, op
):
309 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_type
, op
)
311 def _test_binop_type_zero_float(self
, op
):
312 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_type
, op
)
314 def _test_binop_type_pos_vfloat(self
, op
):
315 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_type
, op
)
317 def _test_binop_type_neg_vfloat(self
, op
):
318 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_type
, op
)
320 def _test_binop_type_zero_vfloat(self
, op
):
321 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_type
, op
)
323 def _test_binop_type_complex(self
, op
):
324 self
._test
_binop
_rhs
_complex
(self
._test
_binop
_type
, op
)
326 def _test_binop_type_zero_complex(self
, op
):
327 self
._test
_binop
_rhs
_zero
_complex
(self
._test
_binop
_type
, op
)
329 def _test_binop_value_false(self
, op
):
330 self
._test
_binop
_rhs
_false
(self
._test
_binop
_value
, op
)
332 def _test_binop_value_true(self
, op
):
333 self
._test
_binop
_rhs
_true
(self
._test
_binop
_value
, op
)
335 def _test_binop_value_pos_int(self
, op
):
336 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_value
, op
)
338 def _test_binop_value_neg_int(self
, op
):
339 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_value
, op
)
341 def _test_binop_value_zero_int(self
, op
):
342 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_value
, op
)
344 def _test_binop_value_pos_vint(self
, op
):
345 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_value
, op
)
347 def _test_binop_value_neg_vint(self
, op
):
348 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_value
, op
)
350 def _test_binop_value_zero_vint(self
, op
):
351 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_value
, op
)
353 def _test_binop_value_pos_float(self
, op
):
354 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_value
, op
)
356 def _test_binop_value_neg_float(self
, op
):
357 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_value
, op
)
359 def _test_binop_value_zero_float(self
, op
):
360 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_value
, op
)
362 def _test_binop_value_pos_vfloat(self
, op
):
363 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_value
, op
)
365 def _test_binop_value_neg_vfloat(self
, op
):
366 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_value
, op
)
368 def _test_binop_value_zero_vfloat(self
, op
):
369 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_value
, op
)
371 def _test_binop_value_complex(self
, op
):
372 self
._test
_binop
_rhs
_complex
(self
._test
_binop
_value
, op
)
374 def _test_binop_value_zero_complex(self
, op
):
375 self
._test
_binop
_rhs
_zero
_complex
(self
._test
_binop
_value
, op
)
377 def _test_binop_lhs_addr_same_false(self
, op
):
378 self
._test
_binop
_rhs
_false
(self
._test
_binop
_lhs
_addr
_same
, op
)
380 def _test_binop_lhs_addr_same_true(self
, op
):
381 self
._test
_binop
_rhs
_true
(self
._test
_binop
_lhs
_addr
_same
, op
)
383 def _test_binop_lhs_addr_same_pos_int(self
, op
):
384 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_lhs
_addr
_same
, op
)
386 def _test_binop_lhs_addr_same_neg_int(self
, op
):
387 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_lhs
_addr
_same
, op
)
389 def _test_binop_lhs_addr_same_zero_int(self
, op
):
390 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_lhs
_addr
_same
, op
)
392 def _test_binop_lhs_addr_same_pos_vint(self
, op
):
393 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_lhs
_addr
_same
, op
)
395 def _test_binop_lhs_addr_same_neg_vint(self
, op
):
396 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_lhs
_addr
_same
, op
)
398 def _test_binop_lhs_addr_same_zero_vint(self
, op
):
399 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_lhs
_addr
_same
, op
)
401 def _test_binop_lhs_addr_same_pos_float(self
, op
):
402 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_lhs
_addr
_same
, op
)
404 def _test_binop_lhs_addr_same_neg_float(self
, op
):
405 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_lhs
_addr
_same
, op
)
407 def _test_binop_lhs_addr_same_zero_float(self
, op
):
408 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_lhs
_addr
_same
, op
)
410 def _test_binop_lhs_addr_same_pos_vfloat(self
, op
):
411 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_lhs
_addr
_same
, op
)
413 def _test_binop_lhs_addr_same_neg_vfloat(self
, op
):
414 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_lhs
_addr
_same
, op
)
416 def _test_binop_lhs_addr_same_zero_vfloat(self
, op
):
417 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_lhs
_addr
_same
, op
)
419 def _test_binop_lhs_addr_same_complex(self
, op
):
420 self
._test
_binop
_rhs
_complex
(self
._test
_binop
_lhs
_addr
_same
, op
)
422 def _test_binop_lhs_addr_same_zero_complex(self
, op
):
423 self
._test
_binop
_rhs
_zero
_complex
(self
._test
_binop
_lhs
_addr
_same
, op
)
425 def _test_binop_lhs_value_same_false(self
, op
):
426 self
._test
_binop
_rhs
_false
(self
._test
_binop
_lhs
_value
_same
, op
)
428 def _test_binop_lhs_value_same_true(self
, op
):
429 self
._test
_binop
_rhs
_true
(self
._test
_binop
_lhs
_value
_same
, op
)
431 def _test_binop_lhs_value_same_pos_int(self
, op
):
432 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_lhs
_value
_same
, op
)
434 def _test_binop_lhs_value_same_neg_int(self
, op
):
435 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_lhs
_value
_same
, op
)
437 def _test_binop_lhs_value_same_zero_int(self
, op
):
438 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_lhs
_value
_same
, op
)
440 def _test_binop_lhs_value_same_pos_vint(self
, op
):
441 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_lhs
_value
_same
, op
)
443 def _test_binop_lhs_value_same_neg_vint(self
, op
):
444 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_lhs
_value
_same
, op
)
446 def _test_binop_lhs_value_same_zero_vint(self
, op
):
447 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_lhs
_value
_same
, op
)
449 def _test_binop_lhs_value_same_pos_float(self
, op
):
450 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_lhs
_value
_same
, op
)
452 def _test_binop_lhs_value_same_neg_float(self
, op
):
453 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_lhs
_value
_same
, op
)
455 def _test_binop_lhs_value_same_zero_float(self
, op
):
456 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_lhs
_value
_same
, op
)
458 def _test_binop_lhs_value_same_pos_vfloat(self
, op
):
459 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_lhs
_value
_same
, op
)
461 def _test_binop_lhs_value_same_neg_vfloat(self
, op
):
462 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_lhs
_value
_same
, op
)
464 def _test_binop_lhs_value_same_zero_vfloat(self
, op
):
465 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_lhs
_value
_same
, op
)
467 def _test_binop_lhs_value_same_complex(self
, op
):
468 self
._test
_binop
_rhs
_complex
(self
._test
_binop
_lhs
_value
_same
, op
)
470 def _test_binop_lhs_value_same_zero_complex(self
, op
):
471 self
._test
_binop
_rhs
_zero
_complex
(self
._test
_binop
_lhs
_value
_same
, op
)
473 def test_bool_op(self
):
474 self
.assertEqual(bool(self
._def
), bool(self
._def
_value
))
476 def test_int_op(self
):
477 self
.assertEqual(int(self
._def
), int(self
._def
_value
))
479 def test_float_op(self
):
480 self
.assertEqual(float(self
._def
), float(self
._def
_value
))
482 def test_complex_op(self
):
483 self
.assertEqual(complex(self
._def
), complex(self
._def
_value
))
485 def test_str_op(self
):
486 self
.assertEqual(str(self
._def
), str(self
._def
_value
))
488 def test_eq_none(self
):
489 # Disable the "comparison to None" warning, as this is precisely what
490 # we want to test here.
491 self
.assertFalse(self
._def
== None) # noqa: E711
493 def test_ne_none(self
):
494 # Disable the "comparison to None" warning, as this is precisely what
495 # we want to test here.
496 self
.assertTrue(self
._def
!= None) # noqa: E711
499 # This is a list of binary operators used for
500 # _inject_numeric_testing_methods().
502 # Each entry is a pair of binary operator name (used as part of the
503 # created testing method's name) and operator function.
511 ('add', operator
.add
),
512 ('radd', lambda a
, b
: operator
.add(b
, a
)),
513 ('and', operator
.and_
),
514 ('rand', lambda a
, b
: operator
.and_(b
, a
)),
515 ('floordiv', operator
.floordiv
),
516 ('rfloordiv', lambda a
, b
: operator
.floordiv(b
, a
)),
517 ('lshift', operator
.lshift
),
518 ('rlshift', lambda a
, b
: operator
.lshift(b
, a
)),
519 ('mod', operator
.mod
),
520 ('rmod', lambda a
, b
: operator
.mod(b
, a
)),
521 ('mul', operator
.mul
),
522 ('rmul', lambda a
, b
: operator
.mul(b
, a
)),
523 ('or', operator
.or_
),
524 ('ror', lambda a
, b
: operator
.or_(b
, a
)),
525 ('pow', operator
.pow),
526 ('rpow', lambda a
, b
: operator
.pow(b
, a
)),
527 ('rshift', operator
.rshift
),
528 ('rrshift', lambda a
, b
: operator
.rshift(b
, a
)),
529 ('sub', operator
.sub
),
530 ('rsub', lambda a
, b
: operator
.sub(b
, a
)),
531 ('truediv', operator
.truediv
),
532 ('rtruediv', lambda a
, b
: operator
.truediv(b
, a
)),
533 ('xor', operator
.xor
),
534 ('rxor', lambda a
, b
: operator
.xor(b
, a
)),
538 # This is a list of unary operators used for
539 # _inject_numeric_testing_methods().
541 # Each entry is a pair of unary operator name (used as part of the
542 # created testing method's name) and operator function.
544 ('neg', operator
.neg
),
545 ('pos', operator
.pos
),
546 ('abs', operator
.abs),
547 ('invert', operator
.invert
),
549 ('round_0', partial(round, ndigits
=0)),
550 ('round_1', partial(round, ndigits
=1)),
551 ('round_2', partial(round, ndigits
=2)),
552 ('round_3', partial(round, ndigits
=3)),
554 ('floor', math
.floor
),
555 ('trunc', math
.trunc
),
559 # This function injects a bunch of testing methods to a numeric
562 # It is meant to be used like this:
564 # _inject_numeric_testing_methods(MyNumericValueTestCase)
566 # This function injects:
568 # * One testing method for each _TestNumericValue._test_binop_*()
569 # method, for each binary operator in the _BINOPS tuple.
571 # * One testing method for each _TestNumericValue._test_unaryop*()
572 # method, for each unary operator in the _UNARYOPS tuple.
573 def _inject_numeric_testing_methods(cls
):
574 def test_binop_name(suffix
):
575 return 'test_binop_{}_{}'.format(name
, suffix
)
577 def test_unaryop_name(suffix
):
578 return 'test_unaryop_{}_{}'.format(name
, suffix
)
580 # inject testing methods for each binary operation
581 for name
, binop
in _BINOPS
:
584 test_binop_name('unknown'),
585 partialmethod(_TestNumericValue
._test
_binop
_unknown
, op
=binop
),
589 test_binop_name('none'),
590 partialmethod(_TestNumericValue
._test
_binop
_none
, op
=binop
),
594 test_binop_name('type_true'),
595 partialmethod(_TestNumericValue
._test
_binop
_type
_true
, op
=binop
),
599 test_binop_name('type_pos_int'),
600 partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_int
, op
=binop
),
604 test_binop_name('type_pos_vint'),
605 partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_vint
, op
=binop
),
609 test_binop_name('value_true'),
610 partialmethod(_TestNumericValue
._test
_binop
_value
_true
, op
=binop
),
614 test_binop_name('value_pos_int'),
615 partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_int
, op
=binop
),
619 test_binop_name('value_pos_vint'),
620 partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_vint
, op
=binop
),
624 test_binop_name('lhs_addr_same_true'),
625 partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_true
, op
=binop
),
629 test_binop_name('lhs_addr_same_pos_int'),
631 _TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_int
, op
=binop
636 test_binop_name('lhs_addr_same_pos_vint'),
638 _TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_vint
, op
=binop
643 test_binop_name('lhs_value_same_true'),
644 partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_true
, op
=binop
),
648 test_binop_name('lhs_value_same_pos_int'),
650 _TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_int
, op
=binop
655 test_binop_name('lhs_value_same_pos_vint'),
657 _TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_vint
, op
=binop
662 test_binop_name('type_neg_int'),
663 partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_int
, op
=binop
),
667 test_binop_name('type_neg_vint'),
668 partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_vint
, op
=binop
),
672 test_binop_name('value_neg_int'),
673 partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_int
, op
=binop
),
677 test_binop_name('value_neg_vint'),
678 partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_vint
, op
=binop
),
682 test_binop_name('lhs_addr_same_neg_int'),
684 _TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_int
, op
=binop
689 test_binop_name('lhs_addr_same_neg_vint'),
691 _TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_vint
, op
=binop
696 test_binop_name('lhs_value_same_neg_int'),
698 _TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_int
, op
=binop
703 test_binop_name('lhs_value_same_neg_vint'),
705 _TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_vint
, op
=binop
710 test_binop_name('type_false'),
711 partialmethod(_TestNumericValue
._test
_binop
_type
_false
, op
=binop
),
715 test_binop_name('type_zero_int'),
716 partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_int
, op
=binop
),
720 test_binop_name('type_zero_vint'),
721 partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_vint
, op
=binop
),
725 test_binop_name('value_false'),
726 partialmethod(_TestNumericValue
._test
_binop
_value
_false
, op
=binop
),
730 test_binop_name('value_zero_int'),
731 partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_int
, op
=binop
),
735 test_binop_name('value_zero_vint'),
736 partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_vint
, op
=binop
),
740 test_binop_name('lhs_addr_same_false'),
741 partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_false
, op
=binop
),
745 test_binop_name('lhs_addr_same_zero_int'),
747 _TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_int
, op
=binop
752 test_binop_name('lhs_addr_same_zero_vint'),
754 _TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_vint
, op
=binop
759 test_binop_name('lhs_value_same_false'),
760 partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_false
, op
=binop
),
764 test_binop_name('lhs_value_same_zero_int'),
766 _TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_int
, op
=binop
771 test_binop_name('lhs_value_same_zero_vint'),
773 _TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_vint
, op
=binop
778 test_binop_name('type_neg_float'),
779 partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_float
, op
=binop
),
783 test_binop_name('type_neg_vfloat'),
784 partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_vfloat
, op
=binop
),
788 test_binop_name('value_neg_float'),
789 partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_float
, op
=binop
),
793 test_binop_name('value_neg_vfloat'),
794 partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_vfloat
, op
=binop
),
798 test_binop_name('lhs_addr_same_neg_float'),
800 _TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_float
, op
=binop
805 test_binop_name('lhs_addr_same_neg_vfloat'),
807 _TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_vfloat
, op
=binop
812 test_binop_name('lhs_value_same_neg_float'),
814 _TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_float
, op
=binop
819 test_binop_name('lhs_value_same_neg_vfloat'),
821 _TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_vfloat
, op
=binop
826 test_binop_name('type_pos_float'),
827 partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_float
, op
=binop
),
831 test_binop_name('type_pos_vfloat'),
832 partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_vfloat
, op
=binop
),
836 test_binop_name('value_pos_float'),
837 partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_float
, op
=binop
),
841 test_binop_name('value_pos_vfloat'),
842 partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_vfloat
, op
=binop
),
846 test_binop_name('lhs_addr_same_pos_float'),
848 _TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_float
, op
=binop
853 test_binop_name('lhs_addr_same_pos_vfloat'),
855 _TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_vfloat
, op
=binop
860 test_binop_name('lhs_value_same_pos_float'),
862 _TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_float
, op
=binop
867 test_binop_name('lhs_value_same_pos_vfloat'),
869 _TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_vfloat
, op
=binop
874 test_binop_name('type_zero_float'),
875 partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_float
, op
=binop
),
879 test_binop_name('type_zero_vfloat'),
880 partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_vfloat
, op
=binop
),
884 test_binop_name('value_zero_float'),
885 partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_float
, op
=binop
),
889 test_binop_name('value_zero_vfloat'),
890 partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_vfloat
, op
=binop
),
894 test_binop_name('lhs_addr_same_zero_float'),
896 _TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_float
, op
=binop
901 test_binop_name('lhs_addr_same_zero_vfloat'),
903 _TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_vfloat
, op
=binop
908 test_binop_name('lhs_value_same_zero_float'),
910 _TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_float
, op
=binop
915 test_binop_name('lhs_value_same_zero_vfloat'),
917 _TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_vfloat
, op
=binop
922 test_binop_name('type_complex'),
923 partialmethod(_TestNumericValue
._test
_binop
_type
_complex
, op
=binop
),
927 test_binop_name('type_zero_complex'),
928 partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_complex
, op
=binop
),
932 test_binop_name('value_complex'),
933 partialmethod(_TestNumericValue
._test
_binop
_value
_complex
, op
=binop
),
937 test_binop_name('value_zero_complex'),
938 partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_complex
, op
=binop
),
942 test_binop_name('lhs_addr_same_complex'),
944 _TestNumericValue
._test
_binop
_lhs
_addr
_same
_complex
, op
=binop
949 test_binop_name('lhs_addr_same_zero_complex'),
951 _TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_complex
, op
=binop
956 test_binop_name('lhs_value_same_complex'),
958 _TestNumericValue
._test
_binop
_lhs
_value
_same
_complex
, op
=binop
963 test_binop_name('lhs_value_same_zero_complex'),
965 _TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_complex
, op
=binop
969 # inject testing methods for each unary operation
970 for name
, unaryop
in _UNARYOPS
:
973 test_unaryop_name('type'),
974 partialmethod(_TestNumericValue
._test
_unaryop
_type
, op
=unaryop
),
978 test_unaryop_name('value'),
979 partialmethod(_TestNumericValue
._test
_unaryop
_value
, op
=unaryop
),
983 test_unaryop_name('addr_same'),
984 partialmethod(_TestNumericValue
._test
_unaryop
_addr
_same
, op
=unaryop
),
988 test_unaryop_name('value_same'),
989 partialmethod(_TestNumericValue
._test
_unaryop
_value
_same
, op
=unaryop
),
993 class CreateValueFuncTestCase(unittest
.TestCase
):
994 def test_create_none(self
):
995 v
= bt2
.create_value(None)
998 def test_create_bool_false(self
):
999 v
= bt2
.create_value(False)
1000 self
.assertIsInstance(v
, bt2
.BoolValue
)
1003 def test_create_bool_true(self
):
1004 v
= bt2
.create_value(True)
1005 self
.assertIsInstance(v
, bt2
.BoolValue
)
1008 def test_create_int_pos(self
):
1010 v
= bt2
.create_value(raw
)
1011 self
.assertIsInstance(v
, bt2
.SignedIntegerValue
)
1012 self
.assertEqual(v
, raw
)
1014 def test_create_int_neg(self
):
1016 v
= bt2
.create_value(raw
)
1017 self
.assertIsInstance(v
, bt2
.SignedIntegerValue
)
1018 self
.assertEqual(v
, raw
)
1020 def test_create_float_pos(self
):
1022 v
= bt2
.create_value(raw
)
1023 self
.assertIsInstance(v
, bt2
.RealValue
)
1024 self
.assertEqual(v
, raw
)
1026 def test_create_float_neg(self
):
1028 v
= bt2
.create_value(raw
)
1029 self
.assertIsInstance(v
, bt2
.RealValue
)
1030 self
.assertEqual(v
, raw
)
1032 def test_create_string(self
):
1034 v
= bt2
.create_value(raw
)
1035 self
.assertIsInstance(v
, bt2
.StringValue
)
1036 self
.assertEqual(v
, raw
)
1038 def test_create_string_empty(self
):
1040 v
= bt2
.create_value(raw
)
1041 self
.assertIsInstance(v
, bt2
.StringValue
)
1042 self
.assertEqual(v
, raw
)
1044 def test_create_array_from_list(self
):
1046 v
= bt2
.create_value(raw
)
1047 self
.assertIsInstance(v
, bt2
.ArrayValue
)
1048 self
.assertEqual(v
, raw
)
1050 def test_create_array_from_tuple(self
):
1052 v
= bt2
.create_value(raw
)
1053 self
.assertIsInstance(v
, bt2
.ArrayValue
)
1054 self
.assertEqual(v
, raw
)
1056 def test_create_array_from_empty_list(self
):
1058 v
= bt2
.create_value(raw
)
1059 self
.assertIsInstance(v
, bt2
.ArrayValue
)
1060 self
.assertEqual(v
, raw
)
1062 def test_create_array_from_empty_tuple(self
):
1064 v
= bt2
.create_value(raw
)
1065 self
.assertIsInstance(v
, bt2
.ArrayValue
)
1066 self
.assertEqual(v
, raw
)
1068 def test_create_map(self
):
1070 v
= bt2
.create_value(raw
)
1071 self
.assertIsInstance(v
, bt2
.MapValue
)
1072 self
.assertEqual(v
, raw
)
1074 def test_create_map_empty(self
):
1076 v
= bt2
.create_value(raw
)
1077 self
.assertIsInstance(v
, bt2
.MapValue
)
1078 self
.assertEqual(v
, raw
)
1080 def test_create_vfalse(self
):
1081 v
= bt2
.create_value(bt2
.create_value(False))
1082 self
.assertIsInstance(v
, bt2
.BoolValue
)
1085 def test_create_invalid(self
):
1091 with self
.assertRaisesRegex(
1092 TypeError, "cannot create value object from 'A' object"
1097 def _create_const_value(value
):
1098 class MySink(bt2
._UserSinkComponent
):
1099 def _user_consume(self
):
1103 def _user_query(cls
, priv_query_exec
, obj
, params
, method_obj
):
1105 return {'my_value': value
}
1107 res
= bt2
.QueryExecutor(MySink
, 'obj', None).query()
1108 return res
['my_value']
1111 class BoolValueTestCase(_TestNumericValue
, unittest
.TestCase
):
1113 self
._f
= bt2
.BoolValue(False)
1114 self
._t
= bt2
.BoolValue(True)
1116 self
._def
_value
= False
1117 self
._def
_new
_value
= True
1124 def _assert_expecting_bool(self
):
1125 return self
.assertRaisesRegex(TypeError, r
"expecting a 'bool' object")
1127 def test_create_default(self
):
1131 def test_create_false(self
):
1132 self
.assertFalse(self
._f
)
1134 def test_create_true(self
):
1135 self
.assertTrue(self
._t
)
1137 def test_create_from_vfalse(self
):
1138 b
= bt2
.BoolValue(self
._f
)
1141 def test_create_from_vtrue(self
):
1142 b
= bt2
.BoolValue(self
._t
)
1145 def test_create_from_int_non_zero(self
):
1146 with self
.assertRaises(TypeError):
1149 def test_create_from_int_zero(self
):
1150 with self
.assertRaises(TypeError):
1153 def test_assign_true(self
):
1158 def test_assign_false(self
):
1163 def test_assign_vtrue(self
):
1168 def test_assign_vfalse(self
):
1173 def test_assign_int(self
):
1174 with self
.assertRaises(TypeError):
1178 def test_bool_op(self
):
1179 self
.assertEqual(bool(self
._def
), bool(self
._def
_value
))
1181 def test_str_op(self
):
1182 self
.assertEqual(str(self
._def
), str(self
._def
_value
))
1184 def test_eq_none(self
):
1185 # Disable the "comparison to None" warning, as this is precisely what
1186 # we want to test here.
1187 self
.assertFalse(self
._def
== None) # noqa: E711
1189 def test_ne_none(self
):
1190 # Disable the "comparison to None" warning, as this is precisely what
1191 # we want to test here.
1192 self
.assertTrue(self
._def
!= None) # noqa: E711
1194 def test_vfalse_eq_false(self
):
1195 self
.assertEqual(self
._f
, False)
1197 def test_vfalse_ne_true(self
):
1198 self
.assertNotEqual(self
._f
, True)
1200 def test_vtrue_eq_true(self
):
1201 self
.assertEqual(self
._t
, True)
1203 def test_vtrue_ne_false(self
):
1204 self
.assertNotEqual(self
._t
, False)
1207 _inject_numeric_testing_methods(BoolValueTestCase
)
1210 class _TestIntegerValue(_TestNumericValue
):
1213 self
._ip
= self
._CLS
(self
._pv
)
1214 self
._def
= self
._ip
1215 self
._def
_value
= self
._pv
1216 self
._def
_new
_value
= 101
1223 def _assert_expecting_int(self
):
1224 return self
.assertRaisesRegex(TypeError, r
'expecting an integral number object')
1226 def _assert_expecting_int64(self
):
1227 return self
.assertRaisesRegex(
1228 ValueError, r
"expecting a signed 64-bit integral value"
1231 def _assert_expecting_uint64(self
):
1232 return self
.assertRaisesRegex(
1233 ValueError, r
"expecting an unsigned 64-bit integral value"
1236 def test_create_default(self
):
1238 self
.assertEqual(i
, 0)
1240 def test_create_pos(self
):
1241 self
.assertEqual(self
._ip
, self
._pv
)
1243 def test_create_neg(self
):
1244 self
.assertEqual(self
._in
, self
._nv
)
1246 def test_create_from_vint(self
):
1247 i
= self
._CLS
(self
._ip
)
1248 self
.assertEqual(i
, self
._pv
)
1250 def test_create_from_false(self
):
1251 i
= self
._CLS
(False)
1254 def test_create_from_true(self
):
1258 def test_create_from_unknown(self
):
1262 with self
._assert
_expecting
_int
():
1265 def test_create_from_varray(self
):
1266 with self
._assert
_expecting
_int
():
1267 self
._CLS
(bt2
.ArrayValue())
1269 def test_assign_true(self
):
1271 self
._def
.value
= raw
1272 self
.assertEqual(self
._def
, raw
)
1274 def test_assign_false(self
):
1276 self
._def
.value
= raw
1277 self
.assertEqual(self
._def
, raw
)
1279 def test_assign_pos_int(self
):
1281 self
._def
.value
= raw
1282 self
.assertEqual(self
._def
, raw
)
1284 def test_assign_vint(self
):
1286 self
._def
.value
= bt2
.create_value(raw
)
1287 self
.assertEqual(self
._def
, raw
)
1290 class SignedIntegerValueTestCase(_TestIntegerValue
, unittest
.TestCase
):
1291 _CLS
= bt2
.SignedIntegerValue
1296 self
._in
= self
._CLS
(self
._nv
)
1297 self
._def
_new
_value
= -101
1303 def test_create_neg(self
):
1304 self
.assertEqual(self
._in
, self
._nv
)
1306 def test_create_pos_too_big(self
):
1307 with self
._assert
_expecting
_int
64():
1310 def test_create_neg_too_big(self
):
1311 with self
._assert
_expecting
_int
64():
1312 self
._CLS
(-(2 ** 63) - 1)
1314 def test_assign_neg_int(self
):
1316 self
._def
.value
= raw
1317 self
.assertEqual(self
._def
, raw
)
1319 def test_compare_big_int(self
):
1320 # Larger than the IEEE 754 double-precision exact representation of
1323 v
= bt2
.create_value(raw
)
1324 self
.assertEqual(v
, raw
)
1327 _inject_numeric_testing_methods(SignedIntegerValueTestCase
)
1330 class UnsignedIntegerValueTestCase(_TestIntegerValue
, unittest
.TestCase
):
1331 _CLS
= bt2
.UnsignedIntegerValue
1333 def test_create_pos_too_big(self
):
1334 with self
._assert
_expecting
_uint
64():
1337 def test_create_neg(self
):
1338 with self
._assert
_expecting
_uint
64():
1342 _inject_numeric_testing_methods(UnsignedIntegerValueTestCase
)
1345 class RealValueTestCase(_TestNumericValue
, unittest
.TestCase
):
1349 self
._fp
= bt2
.RealValue(self
._pv
)
1350 self
._fn
= bt2
.RealValue(self
._nv
)
1351 self
._def
= self
._fp
1352 self
._def
_value
= self
._pv
1353 self
._def
_new
_value
= -101.88
1361 def _assert_expecting_float(self
):
1362 return self
.assertRaisesRegex(TypeError, r
"expecting a real number object")
1364 def _test_invalid_op(self
, cb
):
1365 with self
.assertRaises(TypeError):
1368 def test_create_default(self
):
1370 self
.assertEqual(f
, 0.0)
1372 def test_create_pos(self
):
1373 self
.assertEqual(self
._fp
, self
._pv
)
1375 def test_create_neg(self
):
1376 self
.assertEqual(self
._fn
, self
._nv
)
1378 def test_create_from_false(self
):
1379 f
= bt2
.RealValue(False)
1382 def test_create_from_true(self
):
1383 f
= bt2
.RealValue(True)
1386 def test_create_from_int(self
):
1388 f
= bt2
.RealValue(raw
)
1389 self
.assertEqual(f
, float(raw
))
1391 def test_create_from_vint(self
):
1393 f
= bt2
.RealValue(bt2
.create_value(raw
))
1394 self
.assertEqual(f
, float(raw
))
1396 def test_create_from_vfloat(self
):
1398 f
= bt2
.RealValue(bt2
.create_value(raw
))
1399 self
.assertEqual(f
, raw
)
1401 def test_create_from_unknown(self
):
1405 with self
._assert
_expecting
_float
():
1408 def test_create_from_varray(self
):
1409 with self
._assert
_expecting
_float
():
1410 bt2
.RealValue(bt2
.ArrayValue())
1412 def test_assign_true(self
):
1413 self
._def
.value
= True
1414 self
.assertTrue(self
._def
)
1416 def test_assign_false(self
):
1417 self
._def
.value
= False
1418 self
.assertFalse(self
._def
)
1420 def test_assign_pos_int(self
):
1422 self
._def
.value
= raw
1423 self
.assertEqual(self
._def
, float(raw
))
1425 def test_assign_neg_int(self
):
1427 self
._def
.value
= raw
1428 self
.assertEqual(self
._def
, float(raw
))
1430 def test_assign_vint(self
):
1432 self
._def
.value
= bt2
.create_value(raw
)
1433 self
.assertEqual(self
._def
, float(raw
))
1435 def test_assign_float(self
):
1437 self
._def
.value
= raw
1438 self
.assertEqual(self
._def
, raw
)
1440 def test_assign_vfloat(self
):
1442 self
._def
.value
= bt2
.create_value(raw
)
1443 self
.assertEqual(self
._def
, raw
)
1445 def test_invalid_lshift(self
):
1446 self
._test
_invalid
_op
(lambda: self
._def
<< 23)
1448 def test_invalid_rshift(self
):
1449 self
._test
_invalid
_op
(lambda: self
._def
>> 23)
1451 def test_invalid_and(self
):
1452 self
._test
_invalid
_op
(lambda: self
._def
& 23)
1454 def test_invalid_or(self
):
1455 self
._test
_invalid
_op
(lambda: self
._def |
23)
1457 def test_invalid_xor(self
):
1458 self
._test
_invalid
_op
(lambda: self
._def ^
23)
1460 def test_invalid_invert(self
):
1461 self
._test
_invalid
_op
(lambda: ~self
._def
)
1464 _inject_numeric_testing_methods(RealValueTestCase
)
1467 class StringValueTestCase(_TestCopySimple
, unittest
.TestCase
):
1469 self
._def
_value
= 'Hello, World!'
1470 self
._def
= bt2
.StringValue(self
._def
_value
)
1471 self
._def
_const
= _create_const_value(self
._def
_value
)
1472 self
._def
_new
_value
= 'Yes!'
1477 def _assert_expecting_str(self
):
1478 return self
.assertRaises(TypeError)
1480 def test_create_default(self
):
1481 s
= bt2
.StringValue()
1482 self
.assertEqual(s
, '')
1484 def test_create_from_str(self
):
1486 s
= bt2
.StringValue(raw
)
1487 self
.assertEqual(s
, raw
)
1489 def test_create_from_vstr(self
):
1491 s
= bt2
.StringValue(bt2
.create_value(raw
))
1492 self
.assertEqual(s
, raw
)
1494 def test_create_from_unknown(self
):
1498 with self
._assert
_expecting
_str
():
1499 bt2
.StringValue(A())
1501 def test_create_from_varray(self
):
1502 with self
._assert
_expecting
_str
():
1503 bt2
.StringValue(bt2
.ArrayValue())
1505 def test_assign_int(self
):
1506 with self
._assert
_expecting
_str
():
1507 self
._def
.value
= 283
1509 def test_assign_str(self
):
1512 self
.assertEqual(self
._def
, raw
)
1514 def test_assign_vstr(self
):
1516 self
._def
= bt2
.create_value(raw
)
1517 self
.assertEqual(self
._def
, raw
)
1520 self
.assertEqual(self
._def
, self
._def
_value
)
1522 def test_const_eq(self
):
1523 self
.assertEqual(self
._def
_const
, self
._def
_value
)
1525 def test_eq_raw(self
):
1526 self
.assertNotEqual(self
._def
, 23)
1528 def test_lt_vstring(self
):
1529 s1
= bt2
.StringValue('allo')
1530 s2
= bt2
.StringValue('bateau')
1531 self
.assertLess(s1
, s2
)
1533 def test_lt_string(self
):
1534 s1
= bt2
.StringValue('allo')
1535 self
.assertLess(s1
, 'bateau')
1537 def test_le_vstring(self
):
1538 s1
= bt2
.StringValue('allo')
1539 s2
= bt2
.StringValue('bateau')
1540 self
.assertLessEqual(s1
, s2
)
1542 def test_le_string(self
):
1543 s1
= bt2
.StringValue('allo')
1544 self
.assertLessEqual(s1
, 'bateau')
1546 def test_gt_vstring(self
):
1547 s1
= bt2
.StringValue('allo')
1548 s2
= bt2
.StringValue('bateau')
1549 self
.assertGreater(s2
, s1
)
1551 def test_gt_string(self
):
1552 s1
= bt2
.StringValue('allo')
1553 self
.assertGreater('bateau', s1
)
1555 def test_ge_vstring(self
):
1556 s1
= bt2
.StringValue('allo')
1557 s2
= bt2
.StringValue('bateau')
1558 self
.assertGreaterEqual(s2
, s1
)
1560 def test_ge_string(self
):
1561 s1
= bt2
.StringValue('allo')
1562 self
.assertGreaterEqual('bateau', s1
)
1564 def test_in_string(self
):
1565 s1
= bt2
.StringValue('beau grand bateau')
1566 self
.assertIn('bateau', s1
)
1568 def test_in_vstring(self
):
1569 s1
= bt2
.StringValue('beau grand bateau')
1570 s2
= bt2
.StringValue('bateau')
1571 self
.assertIn(s2
, s1
)
1573 def test_bool_op(self
):
1574 self
.assertEqual(bool(self
._def
), bool(self
._def
_value
))
1576 def test_str_op(self
):
1577 self
.assertEqual(str(self
._def
), str(self
._def
_value
))
1580 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1582 def test_getitem(self
):
1583 self
.assertEqual(self
._def
[5], self
._def
_value
[5])
1585 def test_const_getitem(self
):
1586 self
.assertEqual(self
._def
_const
[5], self
._def
_value
[5])
1588 def test_iadd_str(self
):
1589 to_append
= 'meow meow meow'
1590 self
._def
+= to_append
1591 self
._def
_value
+= to_append
1592 self
.assertEqual(self
._def
, self
._def
_value
)
1594 def test_const_iadd_str(self
):
1595 to_append
= 'meow meow meow'
1596 with self
.assertRaises(TypeError):
1597 self
._def
_const
+= to_append
1599 self
.assertEqual(self
._def
_const
, self
._def
_value
)
1601 def test_append_vstr(self
):
1602 to_append
= 'meow meow meow'
1603 self
._def
+= bt2
.create_value(to_append
)
1604 self
._def
_value
+= to_append
1605 self
.assertEqual(self
._def
, self
._def
_value
)
1608 class ArrayValueTestCase(_TestCopySimple
, unittest
.TestCase
):
1610 self
._def
_value
= [None, False, True, -23, 0, 42, -42.4, 23.17, 'yes']
1611 self
._def
= bt2
.ArrayValue(copy
.deepcopy(self
._def
_value
))
1612 self
._def
_const
= _create_const_value(copy
.deepcopy(self
._def
_value
))
1617 def _modify_def(self
):
1618 self
._def
[2] = 'xyz'
1620 def _assert_type_error(self
):
1621 return self
.assertRaises(TypeError)
1623 def test_create_default(self
):
1624 a
= bt2
.ArrayValue()
1625 self
.assertEqual(len(a
), 0)
1627 def test_create_from_array(self
):
1628 self
.assertEqual(self
._def
, self
._def
_value
)
1630 def test_create_from_tuple(self
):
1631 t
= 1, 2, False, None
1632 a
= bt2
.ArrayValue(t
)
1633 self
.assertEqual(a
, t
)
1635 def test_create_from_varray(self
):
1636 va
= bt2
.ArrayValue(copy
.deepcopy(self
._def
_value
))
1637 a
= bt2
.ArrayValue(va
)
1638 self
.assertEqual(va
, a
)
1640 def test_create_from_unknown(self
):
1644 with self
._assert
_type
_error
():
1647 def test_bool_op_true(self
):
1648 self
.assertTrue(bool(self
._def
))
1650 def test_bool_op_false(self
):
1651 self
.assertFalse(bool(bt2
.ArrayValue()))
1654 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1656 def test_eq_int(self
):
1657 self
.assertNotEqual(self
._def
, 23)
1659 def test_const_eq(self
):
1660 a1
= _create_const_value([1, 2, 3])
1662 self
.assertEqual(a1
, a2
)
1664 def test_eq_diff_len(self
):
1665 a1
= bt2
.create_value([1, 2, 3])
1666 a2
= bt2
.create_value([1, 2])
1667 self
.assertIs(type(a1
), bt2
.ArrayValue
)
1668 self
.assertIs(type(a2
), bt2
.ArrayValue
)
1669 self
.assertNotEqual(a1
, a2
)
1671 def test_eq_diff_content_same_len(self
):
1672 a1
= bt2
.create_value([1, 2, 3])
1673 a2
= bt2
.create_value([4, 5, 6])
1674 self
.assertNotEqual(a1
, a2
)
1676 def test_eq_same_content_same_len(self
):
1677 raw
= (3, True, [1, 2.5, None, {'a': 17.6, 'b': None}])
1678 a1
= bt2
.ArrayValue(raw
)
1679 a2
= bt2
.ArrayValue(copy
.deepcopy(raw
))
1680 self
.assertEqual(a1
, a2
)
1682 def test_eq_non_sequence_iterable(self
):
1683 dct
= collections
.OrderedDict([(1, 2), (3, 4), (5, 6)])
1684 a
= bt2
.ArrayValue((1, 3, 5))
1685 self
.assertEqual(a
, list(dct
.keys()))
1686 self
.assertNotEqual(a
, dct
)
1688 def test_setitem_int(self
):
1691 self
.assertEqual(self
._def
[2], raw
)
1693 def test_setitem_vint(self
):
1695 self
._def
[2] = bt2
.create_value(raw
)
1696 self
.assertEqual(self
._def
[2], raw
)
1698 def test_setitem_none(self
):
1700 self
.assertIsNone(self
._def
[2])
1702 def test_setitem_index_wrong_type(self
):
1703 with self
._assert
_type
_error
():
1704 self
._def
['yes'] = 23
1706 def test_setitem_index_neg(self
):
1707 with self
.assertRaises(IndexError):
1710 def test_setitem_index_out_of_range(self
):
1711 with self
.assertRaises(IndexError):
1712 self
._def
[len(self
._def
)] = 23
1714 def test_const_setitem(self
):
1715 with self
.assertRaises(TypeError):
1716 self
._def
_const
[2] = 19
1718 def test_append_none(self
):
1719 self
._def
.append(None)
1720 self
.assertIsNone(self
._def
[len(self
._def
) - 1])
1722 def test_append_int(self
):
1724 self
._def
.append(raw
)
1725 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
)
1727 def test_const_append(self
):
1728 with self
.assertRaises(AttributeError):
1729 self
._def
_const
.append(12194)
1731 def test_append_vint(self
):
1733 self
._def
.append(bt2
.create_value(raw
))
1734 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
)
1736 def test_append_unknown(self
):
1740 with self
._assert
_type
_error
():
1741 self
._def
.append(A())
1743 def test_iadd(self
):
1746 self
.assertEqual(self
._def
[len(self
._def
) - 3], raw
[0])
1747 self
.assertEqual(self
._def
[len(self
._def
) - 2], raw
[1])
1748 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
[2])
1750 def test_const_iadd(self
):
1751 with self
.assertRaises(TypeError):
1752 self
._def
_const
+= 12194
1754 def test_iadd_unknown(self
):
1758 with self
._assert
_type
_error
():
1761 def test_iadd_list_unknown(self
):
1765 with self
._assert
_type
_error
():
1768 def test_iter(self
):
1769 for velem
, elem
in zip(self
._def
, self
._def
_value
):
1770 self
.assertEqual(velem
, elem
)
1772 def test_const_iter(self
):
1773 for velem
, elem
in zip(self
._def
_const
, self
._def
_value
):
1774 self
.assertEqual(velem
, elem
)
1776 def test_const_get_item(self
):
1777 item1
= self
._def
_const
[0]
1778 item2
= self
._def
_const
[2]
1779 item3
= self
._def
_const
[5]
1780 item4
= self
._def
_const
[7]
1781 item5
= self
._def
_const
[8]
1783 self
.assertEqual(item1
, None)
1785 self
.assertIs(type(item2
), bt2
._BoolValueConst
)
1786 self
.assertEqual(item2
, True)
1788 self
.assertIs(type(item3
), bt2
._SignedIntegerValueConst
)
1789 self
.assertEqual(item3
, 42)
1791 self
.assertIs(type(item4
), bt2
._RealValueConst
)
1792 self
.assertEqual(item4
, 23.17)
1794 self
.assertIs(type(item5
), bt2
._StringValueConst
)
1795 self
.assertEqual(item5
, 'yes')
1798 class MapValueTestCase(_TestCopySimple
, unittest
.TestCase
):
1811 self
._def
= bt2
.MapValue(copy
.deepcopy(self
._def
_value
))
1812 self
._def
_const
= _create_const_value(self
._def
_value
)
1817 def _modify_def(self
):
1818 self
._def
['zero'] = 1
1820 def test_create_default(self
):
1822 self
.assertEqual(len(m
), 0)
1824 def test_create_from_dict(self
):
1825 self
.assertEqual(self
._def
, self
._def
_value
)
1827 def test_create_from_vmap(self
):
1828 vm
= bt2
.MapValue(copy
.deepcopy(self
._def
_value
))
1829 m
= bt2
.MapValue(vm
)
1830 self
.assertEqual(vm
, m
)
1832 def test_create_from_unknown(self
):
1836 with self
.assertRaises(AttributeError):
1839 def test_bool_op_true(self
):
1840 self
.assertTrue(bool(self
._def
))
1842 def test_bool_op_false(self
):
1843 self
.assertFalse(bool(bt2
.MapValue()))
1846 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1848 def test_const_eq(self
):
1849 a1
= _create_const_value({'a': 1, 'b': 2, 'c': 3})
1850 a2
= {'a': 1, 'b': 2, 'c': 3}
1851 self
.assertEqual(a1
, a2
)
1853 def test_eq_int(self
):
1854 self
.assertNotEqual(self
._def
, 23)
1856 def test_eq_diff_len(self
):
1857 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1858 a2
= bt2
.create_value({'a': 1, 'b': 2})
1859 self
.assertNotEqual(a1
, a2
)
1861 def test_const_eq_diff_len(self
):
1862 a1
= _create_const_value({'a': 1, 'b': 2, 'c': 3})
1863 a2
= _create_const_value({'a': 1, 'b': 2})
1864 self
.assertNotEqual(a1
, a2
)
1866 def test_eq_diff_content_same_len(self
):
1867 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1868 a2
= bt2
.create_value({'a': 4, 'b': 2, 'c': 3})
1869 self
.assertNotEqual(a1
, a2
)
1871 def test_const_eq_diff_content_same_len(self
):
1872 a1
= _create_const_value({'a': 1, 'b': 2, 'c': 3})
1873 a2
= _create_const_value({'a': 4, 'b': 2, 'c': 3})
1874 self
.assertNotEqual(a1
, a2
)
1876 def test_eq_same_content_diff_keys(self
):
1877 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1878 a2
= bt2
.create_value({'a': 1, 'k': 2, 'c': 3})
1879 self
.assertNotEqual(a1
, a2
)
1881 def test_const_eq_same_content_diff_keys(self
):
1882 a1
= _create_const_value({'a': 1, 'b': 2, 'c': 3})
1883 a2
= _create_const_value({'a': 1, 'k': 2, 'c': 3})
1884 self
.assertNotEqual(a1
, a2
)
1886 def test_eq_same_content_same_len(self
):
1887 raw
= {'3': 3, 'True': True, 'array': [1, 2.5, None, {'a': 17.6, 'b': None}]}
1888 a1
= bt2
.MapValue(raw
)
1889 a2
= bt2
.MapValue(copy
.deepcopy(raw
))
1890 self
.assertEqual(a1
, a2
)
1891 self
.assertEqual(a1
, raw
)
1893 def test_const_eq_same_content_same_len(self
):
1894 raw
= {'3': 3, 'True': True, 'array': [1, 2.5, None, {'a': 17.6, 'b': None}]}
1895 a1
= _create_const_value(raw
)
1896 a2
= _create_const_value(copy
.deepcopy(raw
))
1897 self
.assertEqual(a1
, a2
)
1898 self
.assertEqual(a1
, raw
)
1900 def test_setitem_int(self
):
1902 self
._def
['pos-int'] = raw
1903 self
.assertEqual(self
._def
['pos-int'], raw
)
1905 def test_const_setitem_int(self
):
1906 with self
.assertRaises(TypeError):
1907 self
._def
_const
['pos-int'] = 19
1909 def test_setitem_vint(self
):
1911 self
._def
['pos-int'] = bt2
.create_value(raw
)
1912 self
.assertEqual(self
._def
['pos-int'], raw
)
1914 def test_setitem_none(self
):
1915 self
._def
['none'] = None
1916 self
.assertIsNone(self
._def
['none'])
1918 def test_setitem_new_int(self
):
1919 old_len
= len(self
._def
)
1920 self
._def
['new-int'] = 23
1921 self
.assertEqual(self
._def
['new-int'], 23)
1922 self
.assertEqual(len(self
._def
), old_len
+ 1)
1924 def test_setitem_index_wrong_type(self
):
1925 with self
.assertRaises(TypeError):
1928 def test_iter(self
):
1929 for vkey
, vval
in self
._def
.items():
1930 val
= self
._def
_value
[vkey
]
1931 self
.assertEqual(vval
, val
)
1933 def test_const_iter(self
):
1934 for vkey
, vval
in self
._def
_const
.items():
1935 val
= self
._def
_value
[vkey
]
1936 self
.assertEqual(vval
, val
)
1938 def test_get_item(self
):
1939 i
= self
._def
['pos-float']
1940 self
.assertIs(type(i
), bt2
.RealValue
)
1941 self
.assertEqual(i
, 23.17)
1943 def test_const_get_item(self
):
1944 item1
= self
._def
_const
['none']
1945 item2
= self
._def
_const
['true']
1946 item3
= self
._def
_const
['pos-int']
1947 item4
= self
._def
_const
['pos-float']
1948 item5
= self
._def
_const
['str']
1950 self
.assertEqual(item1
, None)
1952 self
.assertIs(type(item2
), bt2
._BoolValueConst
)
1953 self
.assertEqual(item2
, True)
1955 self
.assertIs(type(item3
), bt2
._SignedIntegerValueConst
)
1956 self
.assertEqual(item3
, 42)
1958 self
.assertIs(type(item4
), bt2
._RealValueConst
)
1959 self
.assertEqual(item4
, 23.17)
1961 self
.assertIs(type(item5
), bt2
._StringValueConst
)
1962 self
.assertEqual(item5
, 'yes')
1964 def test_getitem_wrong_key(self
):
1965 with self
.assertRaises(KeyError):
1966 self
._def
['kilojoule']
1969 if __name__
== '__main__':