1 from functools
import partial
, partialmethod
11 def test_is_frozen(self
):
13 self
.assertTrue(self
._def
.is_frozen
)
15 def test_frozen(self
):
17 self
.assertTrue(self
._def
.frozen
)
19 def test_frozen_exc(self
):
22 with self
.assertRaisesRegex(bt2
.Frozen
, r
'.* value object is frozen$') as cm
:
25 self
.assertEqual(self
._def
, self
._def
_value
)
27 def test_get_value_when_frozen(self
):
29 self
.assertEqual(self
._def
, self
._def
_value
)
32 class _TestFrozenSimple(_TestFrozen
):
33 def _modify_def(self
):
34 self
._def
.value
= self
._def
_new
_value
37 class _TestCopySimple
:
39 cpy
= copy
.copy(self
._def
)
40 self
.assertIsNot(cpy
, self
._def
)
41 self
.assertNotEqual(cpy
.addr
, self
._def
.addr
)
42 self
.assertEqual(cpy
, self
._def
)
44 def test_deepcopy(self
):
45 cpy
= copy
.deepcopy(self
._def
)
46 self
.assertIsNot(cpy
, self
._def
)
47 self
.assertNotEqual(cpy
.addr
, self
._def
.addr
)
48 self
.assertEqual(cpy
, self
._def
)
57 class _TestNumericValue(_TestFrozenSimple
, _TestCopySimple
):
58 def _binop(self
, op
, rhs
):
63 if type(rhs
) in (bt2
.BoolValue
, bt2
.IntegerValue
, bt2
.FloatValue
):
64 comp_value
= rhs
.value
67 r
= op(self
._def
, rhs
)
68 except Exception as e
:
72 rv
= op(self
._def
_value
, comp_value
)
73 except Exception as e
:
76 if rexc
is not None or rvexc
is not None:
77 # at least one of the operations raised an exception: in
78 # this case both operations should have raised the same
79 # type of exception (division by zero, bit shift with a
80 # floating point number operand, etc.)
81 self
.assertIs(type(rexc
), type(rvexc
))
86 def _unaryop(self
, op
):
92 except Exception as e
:
96 rv
= op(self
._def
_value
)
97 except Exception as e
:
100 if rexc
is not None or rvexc
is not None:
101 # at least one of the operations raised an exception: in
102 # this case both operations should have raised the same
103 # type of exception (division by zero, bit shift with a
104 # floating point number operand, etc.)
105 self
.assertIs(type(rexc
), type(rvexc
))
110 def _test_unaryop_type(self
, op
):
111 r
, rv
= self
._unaryop
(op
)
116 self
.assertIsInstance(r
, type(rv
))
118 def _test_unaryop_value(self
, op
):
119 r
, rv
= self
._unaryop
(op
)
124 self
.assertEqual(r
, rv
)
126 def _test_unaryop_addr_same(self
, op
):
127 addr_before
= self
._def
.addr
129 self
.assertEqual(self
._def
.addr
, addr_before
)
131 def _test_unaryop_value_same(self
, op
):
132 value_before
= self
._def
.value
134 self
.assertEqual(self
._def
.value
, value_before
)
136 def _test_binop_type(self
, op
, rhs
):
137 r
, rv
= self
._binop
(op
, rhs
)
142 if op
in _COMP_BINOPS
:
143 # __eq__() and __ne__() always return a 'bool' object
144 self
.assertIsInstance(r
, bool)
146 self
.assertIsInstance(r
, type(rv
))
148 def _test_binop_value(self
, op
, rhs
):
149 r
, rv
= self
._binop
(op
, rhs
)
154 self
.assertEqual(r
, rv
)
156 def _test_binop_lhs_addr_same(self
, op
, rhs
):
157 addr_before
= self
._def
.addr
158 r
, rv
= self
._binop
(op
, rhs
)
159 self
.assertEqual(self
._def
.addr
, addr_before
)
161 def _test_binop_lhs_value_same(self
, op
, rhs
):
162 value_before
= self
._def
.value
163 r
, rv
= self
._binop
(op
, rhs
)
164 self
.assertEqual(self
._def
.value
, value_before
)
166 def _test_binop_invalid_unknown(self
, op
):
167 if op
in _COMP_BINOPS
:
168 self
.skipTest('not testing')
173 with self
.assertRaises(TypeError):
176 def _test_binop_invalid_none(self
, op
):
177 if op
in _COMP_BINOPS
:
178 self
.skipTest('not testing')
180 with self
.assertRaises(TypeError):
183 def _test_ibinop_value(self
, op
, rhs
):
184 r
, rv
= self
._binop
(op
, rhs
)
189 # The inplace operators are special for value objects because
190 # they do not return a new, immutable object like it's the case
191 # for Python numbers. In Python, `a += 2`, where `a` is a number
192 # object, assigns a new number object reference to `a`, dropping
193 # the old reference. Since BT's value objects are mutable, we
194 # modify their internal value with the inplace operators. This
195 # means however that we can lose data in the process, for
198 # int_value_obj += 3.3
200 # Here, if `int_value_obj` is a Python `int` with the value 2,
201 # it would be a `float` object after this, holding the value
202 # 5.3. In our case, if `int_value_obj` is an integer value
203 # object, 3.3 is converted to an `int` object (3) and added to
204 # the current value of `int_value_obj`, so after this the value
205 # of the object is 5. This does not compare to 5.3, which is
206 # why we also use the `int()` type here.
207 if type(self
._def
) is bt2
.IntegerValue
:
210 self
.assertEqual(r
, rv
)
212 def _test_ibinop_type(self
, op
, rhs
):
213 r
, rv
= self
._binop
(op
, rhs
)
218 self
.assertIs(r
, self
._def
)
220 def _test_ibinop_invalid_unknown(self
, op
):
224 with self
.assertRaises(TypeError):
227 def _test_ibinop_invalid_none(self
, op
):
228 with self
.assertRaises(TypeError):
231 def _test_binop_rhs_false(self
, test_cb
, op
):
234 def _test_binop_rhs_true(self
, test_cb
, op
):
237 def _test_binop_rhs_pos_int(self
, test_cb
, op
):
240 def _test_binop_rhs_neg_int(self
, test_cb
, op
):
243 def _test_binop_rhs_zero_int(self
, test_cb
, op
):
246 def _test_binop_rhs_pos_vint(self
, test_cb
, op
):
247 test_cb(op
, bt2
.create_value(2))
249 def _test_binop_rhs_neg_vint(self
, test_cb
, op
):
250 test_cb(op
, bt2
.create_value(-23))
252 def _test_binop_rhs_zero_vint(self
, test_cb
, op
):
253 test_cb(op
, bt2
.create_value(0))
255 def _test_binop_rhs_pos_float(self
, test_cb
, op
):
258 def _test_binop_rhs_neg_float(self
, test_cb
, op
):
261 def _test_binop_rhs_zero_float(self
, test_cb
, op
):
264 def _test_binop_rhs_pos_vfloat(self
, test_cb
, op
):
265 test_cb(op
, bt2
.create_value(2.2))
267 def _test_binop_rhs_neg_vfloat(self
, test_cb
, op
):
268 test_cb(op
, bt2
.create_value(-23.4))
270 def _test_binop_rhs_zero_vfloat(self
, test_cb
, op
):
271 test_cb(op
, bt2
.create_value(0.0))
273 def _test_binop_type_false(self
, op
):
274 self
._test
_binop
_rhs
_false
(self
._test
_binop
_type
, op
)
276 def _test_binop_type_true(self
, op
):
277 self
._test
_binop
_rhs
_true
(self
._test
_binop
_type
, op
)
279 def _test_binop_type_pos_int(self
, op
):
280 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_type
, op
)
282 def _test_binop_type_neg_int(self
, op
):
283 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_type
, op
)
285 def _test_binop_type_zero_int(self
, op
):
286 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_type
, op
)
288 def _test_binop_type_pos_vint(self
, op
):
289 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_type
, op
)
291 def _test_binop_type_neg_vint(self
, op
):
292 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_type
, op
)
294 def _test_binop_type_zero_vint(self
, op
):
295 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_type
, op
)
297 def _test_binop_type_pos_float(self
, op
):
298 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_type
, op
)
300 def _test_binop_type_neg_float(self
, op
):
301 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_type
, op
)
303 def _test_binop_type_zero_float(self
, op
):
304 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_type
, op
)
306 def _test_binop_type_pos_vfloat(self
, op
):
307 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_type
, op
)
309 def _test_binop_type_neg_vfloat(self
, op
):
310 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_type
, op
)
312 def _test_binop_type_zero_vfloat(self
, op
):
313 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_type
, op
)
315 def _test_binop_value_false(self
, op
):
316 self
._test
_binop
_rhs
_false
(self
._test
_binop
_value
, op
)
318 def _test_binop_value_true(self
, op
):
319 self
._test
_binop
_rhs
_true
(self
._test
_binop
_value
, op
)
321 def _test_binop_value_pos_int(self
, op
):
322 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_value
, op
)
324 def _test_binop_value_neg_int(self
, op
):
325 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_value
, op
)
327 def _test_binop_value_zero_int(self
, op
):
328 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_value
, op
)
330 def _test_binop_value_pos_vint(self
, op
):
331 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_value
, op
)
333 def _test_binop_value_neg_vint(self
, op
):
334 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_value
, op
)
336 def _test_binop_value_zero_vint(self
, op
):
337 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_value
, op
)
339 def _test_binop_value_pos_float(self
, op
):
340 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_value
, op
)
342 def _test_binop_value_neg_float(self
, op
):
343 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_value
, op
)
345 def _test_binop_value_zero_float(self
, op
):
346 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_value
, op
)
348 def _test_binop_value_pos_vfloat(self
, op
):
349 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_value
, op
)
351 def _test_binop_value_neg_vfloat(self
, op
):
352 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_value
, op
)
354 def _test_binop_value_zero_vfloat(self
, op
):
355 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_value
, op
)
357 def _test_binop_lhs_addr_same_false(self
, op
):
358 self
._test
_binop
_rhs
_false
(self
._test
_binop
_lhs
_addr
_same
, op
)
360 def _test_binop_lhs_addr_same_true(self
, op
):
361 self
._test
_binop
_rhs
_true
(self
._test
_binop
_lhs
_addr
_same
, op
)
363 def _test_binop_lhs_addr_same_pos_int(self
, op
):
364 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_lhs
_addr
_same
, op
)
366 def _test_binop_lhs_addr_same_neg_int(self
, op
):
367 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_lhs
_addr
_same
, op
)
369 def _test_binop_lhs_addr_same_zero_int(self
, op
):
370 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_lhs
_addr
_same
, op
)
372 def _test_binop_lhs_addr_same_pos_vint(self
, op
):
373 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_lhs
_addr
_same
, op
)
375 def _test_binop_lhs_addr_same_neg_vint(self
, op
):
376 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_lhs
_addr
_same
, op
)
378 def _test_binop_lhs_addr_same_zero_vint(self
, op
):
379 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_lhs
_addr
_same
, op
)
381 def _test_binop_lhs_addr_same_pos_float(self
, op
):
382 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_lhs
_addr
_same
, op
)
384 def _test_binop_lhs_addr_same_neg_float(self
, op
):
385 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_lhs
_addr
_same
, op
)
387 def _test_binop_lhs_addr_same_zero_float(self
, op
):
388 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_lhs
_addr
_same
, op
)
390 def _test_binop_lhs_addr_same_pos_vfloat(self
, op
):
391 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_lhs
_addr
_same
, op
)
393 def _test_binop_lhs_addr_same_neg_vfloat(self
, op
):
394 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_lhs
_addr
_same
, op
)
396 def _test_binop_lhs_addr_same_zero_vfloat(self
, op
):
397 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_lhs
_addr
_same
, op
)
399 def _test_binop_lhs_value_same_false(self
, op
):
400 self
._test
_binop
_rhs
_false
(self
._test
_binop
_lhs
_value
_same
, op
)
402 def _test_binop_lhs_value_same_true(self
, op
):
403 self
._test
_binop
_rhs
_true
(self
._test
_binop
_lhs
_value
_same
, op
)
405 def _test_binop_lhs_value_same_pos_int(self
, op
):
406 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_lhs
_value
_same
, op
)
408 def _test_binop_lhs_value_same_neg_int(self
, op
):
409 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_lhs
_value
_same
, op
)
411 def _test_binop_lhs_value_same_zero_int(self
, op
):
412 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_lhs
_value
_same
, op
)
414 def _test_binop_lhs_value_same_pos_vint(self
, op
):
415 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_lhs
_value
_same
, op
)
417 def _test_binop_lhs_value_same_neg_vint(self
, op
):
418 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_lhs
_value
_same
, op
)
420 def _test_binop_lhs_value_same_zero_vint(self
, op
):
421 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_lhs
_value
_same
, op
)
423 def _test_binop_lhs_value_same_pos_float(self
, op
):
424 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_lhs
_value
_same
, op
)
426 def _test_binop_lhs_value_same_neg_float(self
, op
):
427 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_lhs
_value
_same
, op
)
429 def _test_binop_lhs_value_same_zero_float(self
, op
):
430 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_lhs
_value
_same
, op
)
432 def _test_binop_lhs_value_same_pos_vfloat(self
, op
):
433 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_lhs
_value
_same
, op
)
435 def _test_binop_lhs_value_same_neg_vfloat(self
, op
):
436 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_lhs
_value
_same
, op
)
438 def _test_binop_lhs_value_same_zero_vfloat(self
, op
):
439 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_lhs
_value
_same
, op
)
441 def _test_ibinop_type_false(self
, op
):
442 self
._test
_binop
_rhs
_false
(self
._test
_ibinop
_type
, op
)
444 def _test_ibinop_type_true(self
, op
):
445 self
._test
_binop
_rhs
_true
(self
._test
_ibinop
_type
, op
)
447 def _test_ibinop_type_pos_int(self
, op
):
448 self
._test
_binop
_rhs
_pos
_int
(self
._test
_ibinop
_type
, op
)
450 def _test_ibinop_type_neg_int(self
, op
):
451 self
._test
_binop
_rhs
_neg
_int
(self
._test
_ibinop
_type
, op
)
453 def _test_ibinop_type_zero_int(self
, op
):
454 self
._test
_binop
_rhs
_zero
_int
(self
._test
_ibinop
_type
, op
)
456 def _test_ibinop_type_pos_vint(self
, op
):
457 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_ibinop
_type
, op
)
459 def _test_ibinop_type_neg_vint(self
, op
):
460 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_ibinop
_type
, op
)
462 def _test_ibinop_type_zero_vint(self
, op
):
463 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_ibinop
_type
, op
)
465 def _test_ibinop_type_pos_float(self
, op
):
466 self
._test
_binop
_rhs
_pos
_float
(self
._test
_ibinop
_type
, op
)
468 def _test_ibinop_type_neg_float(self
, op
):
469 self
._test
_binop
_rhs
_neg
_float
(self
._test
_ibinop
_type
, op
)
471 def _test_ibinop_type_zero_float(self
, op
):
472 self
._test
_binop
_rhs
_zero
_float
(self
._test
_ibinop
_type
, op
)
474 def _test_ibinop_type_pos_vfloat(self
, op
):
475 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_ibinop
_type
, op
)
477 def _test_ibinop_type_neg_vfloat(self
, op
):
478 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_ibinop
_type
, op
)
480 def _test_ibinop_type_zero_vfloat(self
, op
):
481 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_ibinop
_type
, op
)
483 def _test_ibinop_value_false(self
, op
):
484 self
._test
_binop
_rhs
_false
(self
._test
_ibinop
_value
, op
)
486 def _test_ibinop_value_true(self
, op
):
487 self
._test
_binop
_rhs
_true
(self
._test
_ibinop
_value
, op
)
489 def _test_ibinop_value_pos_int(self
, op
):
490 self
._test
_binop
_rhs
_pos
_int
(self
._test
_ibinop
_value
, op
)
492 def _test_ibinop_value_neg_int(self
, op
):
493 self
._test
_binop
_rhs
_neg
_int
(self
._test
_ibinop
_value
, op
)
495 def _test_ibinop_value_zero_int(self
, op
):
496 self
._test
_binop
_rhs
_zero
_int
(self
._test
_ibinop
_value
, op
)
498 def _test_ibinop_value_pos_vint(self
, op
):
499 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_ibinop
_value
, op
)
501 def _test_ibinop_value_neg_vint(self
, op
):
502 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_ibinop
_value
, op
)
504 def _test_ibinop_value_zero_vint(self
, op
):
505 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_ibinop
_value
, op
)
507 def _test_ibinop_value_pos_float(self
, op
):
508 self
._test
_binop
_rhs
_pos
_float
(self
._test
_ibinop
_value
, op
)
510 def _test_ibinop_value_neg_float(self
, op
):
511 self
._test
_binop
_rhs
_neg
_float
(self
._test
_ibinop
_value
, op
)
513 def _test_ibinop_value_zero_float(self
, op
):
514 self
._test
_binop
_rhs
_zero
_float
(self
._test
_ibinop
_value
, op
)
516 def _test_ibinop_value_pos_vfloat(self
, op
):
517 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_ibinop
_value
, op
)
519 def _test_ibinop_value_neg_vfloat(self
, op
):
520 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_ibinop
_value
, op
)
522 def _test_ibinop_value_zero_vfloat(self
, op
):
523 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_ibinop
_value
, op
)
525 def test_bool_op(self
):
526 self
.assertEqual(bool(self
._def
), bool(self
._def
_value
))
528 def test_int_op(self
):
529 self
.assertEqual(int(self
._def
), int(self
._def
_value
))
531 def test_float_op(self
):
532 self
.assertEqual(float(self
._def
), float(self
._def
_value
))
534 def test_complex_op(self
):
535 self
.assertEqual(complex(self
._def
), complex(self
._def
_value
))
537 def test_str_op(self
):
538 self
.assertEqual(str(self
._def
), str(self
._def
_value
))
540 def test_eq_none(self
):
541 self
.assertFalse(self
._def
== None)
543 def test_ne_none(self
):
544 self
.assertTrue(self
._def
!= None)
554 ('add', operator
.add
),
555 ('radd', lambda a
, b
: operator
.add(b
, a
)),
556 ('and', operator
.and_
),
557 ('rand', lambda a
, b
: operator
.and_(b
, a
)),
558 ('floordiv', operator
.floordiv
),
559 ('rfloordiv', lambda a
, b
: operator
.floordiv(b
, a
)),
560 ('lshift', operator
.lshift
),
561 ('rlshift', lambda a
, b
: operator
.lshift(b
, a
)),
562 ('mod', operator
.mod
),
563 ('rmod', lambda a
, b
: operator
.mod(b
, a
)),
564 ('mul', operator
.mul
),
565 ('rmul', lambda a
, b
: operator
.mul(b
, a
)),
566 ('or', operator
.or_
),
567 ('ror', lambda a
, b
: operator
.or_(b
, a
)),
568 ('pow', operator
.pow),
569 ('rpow', lambda a
, b
: operator
.pow(b
, a
)),
570 ('rshift', operator
.rshift
),
571 ('rrshift', lambda a
, b
: operator
.rshift(b
, a
)),
572 ('sub', operator
.sub
),
573 ('rsub', lambda a
, b
: operator
.sub(b
, a
)),
574 ('truediv', operator
.truediv
),
575 ('rtruediv', lambda a
, b
: operator
.truediv(b
, a
)),
576 ('xor', operator
.xor
),
577 ('rxor', lambda a
, b
: operator
.xor(b
, a
)),
582 ('iadd', operator
.iadd
),
583 ('iand', operator
.iand
),
584 ('ifloordiv', operator
.ifloordiv
),
585 ('ilshift', operator
.ilshift
),
586 ('imod', operator
.imod
),
587 ('imul', operator
.imul
),
588 ('ior', operator
.ior
),
589 ('ipow', operator
.ipow
),
590 ('irshift', operator
.irshift
),
591 ('isub', operator
.isub
),
592 ('itruediv', operator
.itruediv
),
593 ('ixor', operator
.ixor
),
598 ('neg', operator
.neg
),
599 ('pos', operator
.pos
),
600 ('abs', operator
.abs),
601 ('invert', operator
.invert
),
603 ('round_0', partial(round, ndigits
=0)),
604 ('round_1', partial(round, ndigits
=1)),
605 ('round_2', partial(round, ndigits
=2)),
606 ('round_3', partial(round, ndigits
=3)),
608 ('floor', math
.floor
),
609 ('trunc', math
.trunc
),
613 def _inject_numeric_testing_methods(cls
):
614 def test_binop_name(suffix
):
615 return 'test_binop_{}_{}'.format(name
, suffix
)
617 def test_ibinop_name(suffix
):
618 return 'test_ibinop_{}_{}'.format(name
, suffix
)
620 def test_unaryop_name(suffix
):
621 return 'test_unaryop_{}_{}'.format(name
, suffix
)
623 # inject testing methods for each binary operation
624 for name
, binop
in _BINOPS
:
626 setattr(cls
, test_binop_name('invalid_unknown'), partialmethod(_TestNumericValue
._test
_binop
_invalid
_unknown
, op
=binop
))
627 setattr(cls
, test_binop_name('invalid_none'), partialmethod(_TestNumericValue
._test
_binop
_invalid
_none
, op
=binop
))
628 setattr(cls
, test_binop_name('type_true'), partialmethod(_TestNumericValue
._test
_binop
_type
_true
, op
=binop
))
629 setattr(cls
, test_binop_name('type_pos_int'), partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_int
, op
=binop
))
630 setattr(cls
, test_binop_name('type_pos_vint'), partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_vint
, op
=binop
))
631 setattr(cls
, test_binop_name('value_true'), partialmethod(_TestNumericValue
._test
_binop
_value
_true
, op
=binop
))
632 setattr(cls
, test_binop_name('value_pos_int'), partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_int
, op
=binop
))
633 setattr(cls
, test_binop_name('value_pos_vint'), partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_vint
, op
=binop
))
634 setattr(cls
, test_binop_name('lhs_addr_same_true'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_true
, op
=binop
))
635 setattr(cls
, test_binop_name('lhs_addr_same_pos_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_int
, op
=binop
))
636 setattr(cls
, test_binop_name('lhs_addr_same_pos_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_vint
, op
=binop
))
637 setattr(cls
, test_binop_name('lhs_value_same_true'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_true
, op
=binop
))
638 setattr(cls
, test_binop_name('lhs_value_same_pos_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_int
, op
=binop
))
639 setattr(cls
, test_binop_name('lhs_value_same_pos_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_vint
, op
=binop
))
640 setattr(cls
, test_binop_name('type_neg_int'), partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_int
, op
=binop
))
641 setattr(cls
, test_binop_name('type_neg_vint'), partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_vint
, op
=binop
))
642 setattr(cls
, test_binop_name('value_neg_int'), partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_int
, op
=binop
))
643 setattr(cls
, test_binop_name('value_neg_vint'), partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_vint
, op
=binop
))
644 setattr(cls
, test_binop_name('lhs_addr_same_neg_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_int
, op
=binop
))
645 setattr(cls
, test_binop_name('lhs_addr_same_neg_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_vint
, op
=binop
))
646 setattr(cls
, test_binop_name('lhs_value_same_neg_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_int
, op
=binop
))
647 setattr(cls
, test_binop_name('lhs_value_same_neg_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_vint
, op
=binop
))
648 setattr(cls
, test_binop_name('type_false'), partialmethod(_TestNumericValue
._test
_binop
_type
_false
, op
=binop
))
649 setattr(cls
, test_binop_name('type_zero_int'), partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_int
, op
=binop
))
650 setattr(cls
, test_binop_name('type_zero_vint'), partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_vint
, op
=binop
))
651 setattr(cls
, test_binop_name('value_false'), partialmethod(_TestNumericValue
._test
_binop
_value
_false
, op
=binop
))
652 setattr(cls
, test_binop_name('value_zero_int'), partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_int
, op
=binop
))
653 setattr(cls
, test_binop_name('value_zero_vint'), partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_vint
, op
=binop
))
654 setattr(cls
, test_binop_name('lhs_addr_same_false'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_false
, op
=binop
))
655 setattr(cls
, test_binop_name('lhs_addr_same_zero_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_int
, op
=binop
))
656 setattr(cls
, test_binop_name('lhs_addr_same_zero_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_vint
, op
=binop
))
657 setattr(cls
, test_binop_name('lhs_value_same_false'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_false
, op
=binop
))
658 setattr(cls
, test_binop_name('lhs_value_same_zero_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_int
, op
=binop
))
659 setattr(cls
, test_binop_name('lhs_value_same_zero_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_vint
, op
=binop
))
660 setattr(cls
, test_binop_name('type_pos_float'), partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_float
, op
=binop
))
661 setattr(cls
, test_binop_name('type_neg_float'), partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_float
, op
=binop
))
662 setattr(cls
, test_binop_name('type_pos_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_vfloat
, op
=binop
))
663 setattr(cls
, test_binop_name('type_neg_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_vfloat
, op
=binop
))
664 setattr(cls
, test_binop_name('value_pos_float'), partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_float
, op
=binop
))
665 setattr(cls
, test_binop_name('value_neg_float'), partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_float
, op
=binop
))
666 setattr(cls
, test_binop_name('value_pos_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_vfloat
, op
=binop
))
667 setattr(cls
, test_binop_name('value_neg_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_vfloat
, op
=binop
))
668 setattr(cls
, test_binop_name('lhs_addr_same_pos_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_float
, op
=binop
))
669 setattr(cls
, test_binop_name('lhs_addr_same_neg_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_float
, op
=binop
))
670 setattr(cls
, test_binop_name('lhs_addr_same_pos_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_vfloat
, op
=binop
))
671 setattr(cls
, test_binop_name('lhs_addr_same_neg_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_vfloat
, op
=binop
))
672 setattr(cls
, test_binop_name('lhs_value_same_pos_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_float
, op
=binop
))
673 setattr(cls
, test_binop_name('lhs_value_same_neg_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_float
, op
=binop
))
674 setattr(cls
, test_binop_name('lhs_value_same_pos_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_vfloat
, op
=binop
))
675 setattr(cls
, test_binop_name('lhs_value_same_neg_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_vfloat
, op
=binop
))
676 setattr(cls
, test_binop_name('type_zero_float'), partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_float
, op
=binop
))
677 setattr(cls
, test_binop_name('type_zero_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_vfloat
, op
=binop
))
678 setattr(cls
, test_binop_name('value_zero_float'), partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_float
, op
=binop
))
679 setattr(cls
, test_binop_name('value_zero_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_vfloat
, op
=binop
))
680 setattr(cls
, test_binop_name('lhs_addr_same_zero_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_float
, op
=binop
))
681 setattr(cls
, test_binop_name('lhs_addr_same_zero_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_vfloat
, op
=binop
))
682 setattr(cls
, test_binop_name('lhs_value_same_zero_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_float
, op
=binop
))
683 setattr(cls
, test_binop_name('lhs_value_same_zero_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_vfloat
, op
=binop
))
685 # inject testing methods for each unary operation
686 for name
, unaryop
in _UNARYOPS
:
687 setattr(cls
, test_unaryop_name('type'), partialmethod(_TestNumericValue
._test
_unaryop
_type
, op
=unaryop
))
688 setattr(cls
, test_unaryop_name('value'), partialmethod(_TestNumericValue
._test
_unaryop
_value
, op
=unaryop
))
689 setattr(cls
, test_unaryop_name('addr_same'), partialmethod(_TestNumericValue
._test
_unaryop
_addr
_same
, op
=unaryop
))
690 setattr(cls
, test_unaryop_name('value_same'), partialmethod(_TestNumericValue
._test
_unaryop
_value
_same
, op
=unaryop
))
692 # inject testing methods for each inplace binary operation
693 for name
, ibinop
in _IBINOPS
:
694 setattr(cls
, test_ibinop_name('invalid_unknown'), partialmethod(_TestNumericValue
._test
_ibinop
_invalid
_unknown
, op
=ibinop
))
695 setattr(cls
, test_ibinop_name('invalid_none'), partialmethod(_TestNumericValue
._test
_ibinop
_invalid
_none
, op
=ibinop
))
696 setattr(cls
, test_ibinop_name('type_true'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_true
, op
=ibinop
))
697 setattr(cls
, test_ibinop_name('value_true'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_true
, op
=ibinop
))
698 setattr(cls
, test_ibinop_name('type_pos_int'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_pos
_int
, op
=ibinop
))
699 setattr(cls
, test_ibinop_name('type_pos_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_pos
_vint
, op
=ibinop
))
700 setattr(cls
, test_ibinop_name('value_pos_int'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_pos
_int
, op
=ibinop
))
701 setattr(cls
, test_ibinop_name('value_pos_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_pos
_vint
, op
=ibinop
))
702 setattr(cls
, test_ibinop_name('type_neg_int'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_neg
_int
, op
=ibinop
))
703 setattr(cls
, test_ibinop_name('type_neg_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_neg
_vint
, op
=ibinop
))
704 setattr(cls
, test_ibinop_name('value_neg_int'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_neg
_int
, op
=ibinop
))
705 setattr(cls
, test_ibinop_name('value_neg_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_neg
_vint
, op
=ibinop
))
706 setattr(cls
, test_ibinop_name('type_false'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_false
, op
=ibinop
))
707 setattr(cls
, test_ibinop_name('value_false'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_false
, op
=ibinop
))
708 setattr(cls
, test_ibinop_name('type_zero_int'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_zero
_int
, op
=ibinop
))
709 setattr(cls
, test_ibinop_name('type_zero_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_zero
_vint
, op
=ibinop
))
710 setattr(cls
, test_ibinop_name('value_zero_int'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_zero
_int
, op
=ibinop
))
711 setattr(cls
, test_ibinop_name('value_zero_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_zero
_vint
, op
=ibinop
))
712 setattr(cls
, test_ibinop_name('type_pos_float'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_pos
_float
, op
=ibinop
))
713 setattr(cls
, test_ibinop_name('type_neg_float'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_neg
_float
, op
=ibinop
))
714 setattr(cls
, test_ibinop_name('type_pos_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_pos
_vfloat
, op
=ibinop
))
715 setattr(cls
, test_ibinop_name('type_neg_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_neg
_vfloat
, op
=ibinop
))
716 setattr(cls
, test_ibinop_name('value_pos_float'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_pos
_float
, op
=ibinop
))
717 setattr(cls
, test_ibinop_name('value_neg_float'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_neg
_float
, op
=ibinop
))
718 setattr(cls
, test_ibinop_name('value_pos_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_pos
_vfloat
, op
=ibinop
))
719 setattr(cls
, test_ibinop_name('value_neg_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_neg
_vfloat
, op
=ibinop
))
720 setattr(cls
, test_ibinop_name('type_zero_float'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_zero
_float
, op
=ibinop
))
721 setattr(cls
, test_ibinop_name('type_zero_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_zero
_vfloat
, op
=ibinop
))
722 setattr(cls
, test_ibinop_name('value_zero_float'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_zero
_float
, op
=ibinop
))
723 setattr(cls
, test_ibinop_name('value_zero_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_zero
_vfloat
, op
=ibinop
))
726 class CreateValueFuncTestCase(unittest
.TestCase
):
727 def test_create_none(self
):
728 v
= bt2
.create_value(None)
731 def test_create_bool_false(self
):
732 v
= bt2
.create_value(False)
733 self
.assertIsInstance(v
, bt2
.BoolValue
)
736 def test_create_bool_true(self
):
737 v
= bt2
.create_value(True)
738 self
.assertIsInstance(v
, bt2
.BoolValue
)
741 def test_create_int_pos(self
):
743 v
= bt2
.create_value(raw
)
744 self
.assertIsInstance(v
, bt2
.IntegerValue
)
745 self
.assertEqual(v
, raw
)
747 def test_create_int_neg(self
):
749 v
= bt2
.create_value(raw
)
750 self
.assertIsInstance(v
, bt2
.IntegerValue
)
751 self
.assertEqual(v
, raw
)
753 def test_create_float_pos(self
):
755 v
= bt2
.create_value(raw
)
756 self
.assertIsInstance(v
, bt2
.FloatValue
)
757 self
.assertEqual(v
, raw
)
759 def test_create_float_neg(self
):
761 v
= bt2
.create_value(raw
)
762 self
.assertIsInstance(v
, bt2
.FloatValue
)
763 self
.assertEqual(v
, raw
)
765 def test_create_string(self
):
767 v
= bt2
.create_value(raw
)
768 self
.assertIsInstance(v
, bt2
.StringValue
)
769 self
.assertEqual(v
, raw
)
771 def test_create_string_empty(self
):
773 v
= bt2
.create_value(raw
)
774 self
.assertIsInstance(v
, bt2
.StringValue
)
775 self
.assertEqual(v
, raw
)
777 def test_create_array_from_list(self
):
779 v
= bt2
.create_value(raw
)
780 self
.assertIsInstance(v
, bt2
.ArrayValue
)
781 self
.assertEqual(v
, raw
)
783 def test_create_array_from_tuple(self
):
785 v
= bt2
.create_value(raw
)
786 self
.assertIsInstance(v
, bt2
.ArrayValue
)
787 self
.assertEqual(v
, raw
)
789 def test_create_array_from_empty_list(self
):
791 v
= bt2
.create_value(raw
)
792 self
.assertIsInstance(v
, bt2
.ArrayValue
)
793 self
.assertEqual(v
, raw
)
795 def test_create_array_from_empty_tuple(self
):
797 v
= bt2
.create_value(raw
)
798 self
.assertIsInstance(v
, bt2
.ArrayValue
)
799 self
.assertEqual(v
, raw
)
801 def test_create_map(self
):
803 v
= bt2
.create_value(raw
)
804 self
.assertIsInstance(v
, bt2
.MapValue
)
805 self
.assertEqual(v
, raw
)
807 def test_create_map_empty(self
):
809 v
= bt2
.create_value(raw
)
810 self
.assertIsInstance(v
, bt2
.MapValue
)
811 self
.assertEqual(v
, raw
)
813 def test_create_vfalse(self
):
814 v
= bt2
.create_value(bt2
.create_value(False))
815 self
.assertIsInstance(v
, bt2
.BoolValue
)
818 def test_create_invalid(self
):
824 with self
.assertRaisesRegex(TypeError, "cannot create value object from 'A' object") as cm
:
825 v
= bt2
.create_value(a
)
828 class BoolValueTestCase(_TestFrozenSimple
, _TestCopySimple
, unittest
.TestCase
):
830 self
._f
= bt2
.BoolValue(False)
831 self
._t
= bt2
.BoolValue(True)
833 self
._def
_value
= False
834 self
._def
_new
_value
= True
841 def _assert_expecting_bool(self
):
842 return self
.assertRaisesRegex(TypeError, r
"expecting a 'bool' object")
844 def test_create_default(self
):
848 def test_create_false(self
):
849 self
.assertFalse(self
._f
.value
)
850 self
.assertFalse(self
._f
)
852 def test_create_true(self
):
853 self
.assertTrue(self
._t
.value
)
854 self
.assertTrue(self
._t
)
856 def test_create_from_vfalse(self
):
857 b
= bt2
.BoolValue(self
._f
)
858 self
.assertFalse(b
.value
)
861 def test_create_from_vtrue(self
):
862 b
= bt2
.BoolValue(self
._t
)
863 self
.assertTrue(b
.value
)
866 def test_create_from_int_non_zero(self
):
867 with self
.assertRaises(TypeError):
868 b
= bt2
.BoolValue(23)
870 def test_create_from_int_zero(self
):
871 with self
.assertRaises(TypeError):
874 def test_assign_true(self
):
879 def test_assign_false(self
):
884 def test_assign_vtrue(self
):
889 def test_assign_vfalse(self
):
894 def test_assign_int(self
):
895 with self
.assertRaises(TypeError):
899 def test_bool_op(self
):
900 self
.assertEqual(bool(self
._def
), bool(self
._def
_value
))
902 def test_str_op(self
):
903 self
.assertEqual(str(self
._def
), str(self
._def
_value
))
905 def test_eq_none(self
):
906 self
.assertFalse(self
._def
== None)
908 def test_ne_none(self
):
909 self
.assertTrue(self
._def
!= None)
911 def test_vfalse_eq_false(self
):
912 self
.assertEqual(self
._f
, False)
914 def test_vfalse_ne_true(self
):
915 self
.assertNotEqual(self
._f
, True)
917 def test_vtrue_eq_true(self
):
918 self
.assertEqual(self
._t
, True)
920 def test_vtrue_ne_false(self
):
921 self
.assertNotEqual(self
._t
, False)
924 class IntegerValueTestCase(_TestNumericValue
, unittest
.TestCase
):
928 self
._ip
= bt2
.IntegerValue(self
._pv
)
929 self
._in
= bt2
.IntegerValue(self
._nv
)
931 self
._def
_value
= self
._pv
932 self
._def
_new
_value
= -101
940 def _assert_expecting_int(self
):
941 return self
.assertRaisesRegex(TypeError, r
'expecting a number object')
943 def _assert_expecting_int64(self
):
944 return self
.assertRaisesRegex(ValueError, r
"expecting a signed 64-bit integral value")
946 def _assert_expecting_uint64(self
):
947 return self
.assertRaisesRegex(ValueError, r
"expecting an unsigned 64-bit integral value")
949 def test_create_default(self
):
950 i
= bt2
.IntegerValue()
951 self
.assertEqual(i
.value
, 0)
953 def test_create_pos(self
):
954 self
.assertEqual(self
._ip
.value
, self
._pv
)
955 self
.assertEqual(self
._ip
, self
._pv
)
957 def test_create_neg(self
):
958 self
.assertEqual(self
._in
.value
, self
._nv
)
959 self
.assertEqual(self
._in
, self
._nv
)
961 def test_create_pos_too_big(self
):
962 with self
._assert
_expecting
_int
64():
963 i
= bt2
.IntegerValue(2 ** 63)
965 def test_create_neg_too_big(self
):
966 with self
._assert
_expecting
_int
64():
967 i
= bt2
.IntegerValue(-(2 ** 63) - 1)
969 def test_create_from_vint(self
):
970 i
= bt2
.IntegerValue(self
._ip
)
971 self
.assertEqual(i
, self
._pv
)
973 def test_create_from_false(self
):
974 i
= bt2
.IntegerValue(False)
975 self
.assertFalse(i
.value
)
978 def test_create_from_true(self
):
979 i
= bt2
.IntegerValue(True)
980 self
.assertTrue(i
.value
)
983 def test_create_from_float(self
):
984 i
= bt2
.IntegerValue(99.6)
985 self
.assertEqual(i
, 99)
987 def test_create_from_vfloat(self
):
988 f
= bt2
.create_value(17.5)
989 i
= bt2
.IntegerValue(f
)
990 self
.assertEqual(i
, 17)
992 def test_create_from_unknown(self
):
996 with self
._assert
_expecting
_int
():
997 i
= bt2
.IntegerValue(A())
999 def test_create_from_varray(self
):
1000 with self
._assert
_expecting
_int
():
1001 i
= bt2
.IntegerValue(bt2
.ArrayValue())
1003 def test_assign_true(self
):
1005 self
._def
.value
= raw
1006 self
.assertEqual(self
._def
, raw
)
1007 self
.assertEqual(self
._def
.value
, raw
)
1009 def test_assign_false(self
):
1011 self
._def
.value
= raw
1012 self
.assertEqual(self
._def
, raw
)
1013 self
.assertEqual(self
._def
.value
, raw
)
1015 def test_assign_pos_int(self
):
1017 self
._def
.value
= raw
1018 self
.assertEqual(self
._def
, raw
)
1019 self
.assertEqual(self
._def
.value
, raw
)
1021 def test_assign_neg_int(self
):
1023 self
._def
.value
= raw
1024 self
.assertEqual(self
._def
, raw
)
1025 self
.assertEqual(self
._def
.value
, raw
)
1027 def test_assign_vint(self
):
1029 self
._def
.value
= bt2
.create_value(raw
)
1030 self
.assertEqual(self
._def
, raw
)
1031 self
.assertEqual(self
._def
.value
, raw
)
1033 def test_assign_vfloat(self
):
1035 self
._def
.value
= bt2
.create_value(raw
)
1036 self
.assertEqual(self
._def
, int(raw
))
1037 self
.assertEqual(self
._def
.value
, int(raw
))
1040 _inject_numeric_testing_methods(IntegerValueTestCase
)
1043 class FloatValueTestCase(_TestNumericValue
, unittest
.TestCase
):
1047 self
._fp
= bt2
.FloatValue(self
._pv
)
1048 self
._fn
= bt2
.FloatValue(self
._nv
)
1049 self
._def
= self
._fp
1050 self
._def
_value
= self
._pv
1051 self
._def
_new
_value
= -101.88
1059 def _assert_expecting_float(self
):
1060 return self
.assertRaisesRegex(TypeError, r
"expecting a real number object")
1062 def _test_invalid_op(self
, cb
):
1063 with self
.assertRaises(TypeError):
1066 def test_create_default(self
):
1067 f
= bt2
.FloatValue()
1068 self
.assertEqual(f
.value
, 0.0)
1070 def test_create_pos(self
):
1071 self
.assertEqual(self
._fp
.value
, self
._pv
)
1072 self
.assertEqual(self
._fp
, self
._pv
)
1074 def test_create_neg(self
):
1075 self
.assertEqual(self
._fn
.value
, self
._nv
)
1076 self
.assertEqual(self
._fn
, self
._nv
)
1078 def test_create_from_vint(self
):
1079 f
= bt2
.FloatValue(self
._fp
)
1080 self
.assertEqual(f
, self
._pv
)
1082 def test_create_from_false(self
):
1083 f
= bt2
.FloatValue(False)
1084 self
.assertFalse(f
.value
)
1087 def test_create_from_true(self
):
1088 f
= bt2
.FloatValue(True)
1089 self
.assertTrue(f
.value
)
1092 def test_create_from_int(self
):
1094 f
= bt2
.FloatValue(raw
)
1095 self
.assertEqual(f
.value
, float(raw
))
1097 def test_create_from_vint(self
):
1099 f
= bt2
.FloatValue(bt2
.create_value(raw
))
1100 self
.assertEqual(f
.value
, float(raw
))
1102 def test_create_from_vfloat(self
):
1104 f
= bt2
.FloatValue(bt2
.create_value(raw
))
1105 self
.assertEqual(f
.value
, raw
)
1107 def test_create_from_unknown(self
):
1111 with self
._assert
_expecting
_float
():
1112 f
= bt2
.FloatValue(A())
1114 def test_create_from_varray(self
):
1115 with self
._assert
_expecting
_float
():
1116 f
= bt2
.FloatValue(bt2
.ArrayValue())
1118 def test_assign_true(self
):
1119 self
._def
.value
= True
1120 self
.assertTrue(self
._def
)
1121 self
.assertTrue(self
._def
.value
)
1123 def test_assign_false(self
):
1124 self
._def
.value
= False
1125 self
.assertFalse(self
._def
)
1126 self
.assertFalse(self
._def
.value
)
1128 def test_assign_pos_int(self
):
1130 self
._def
.value
= raw
1131 self
.assertEqual(self
._def
, float(raw
))
1132 self
.assertEqual(self
._def
.value
, float(raw
))
1134 def test_assign_neg_int(self
):
1136 self
._def
.value
= raw
1137 self
.assertEqual(self
._def
, float(raw
))
1138 self
.assertEqual(self
._def
.value
, float(raw
))
1140 def test_assign_vint(self
):
1142 self
._def
.value
= bt2
.create_value(raw
)
1143 self
.assertEqual(self
._def
, float(raw
))
1144 self
.assertEqual(self
._def
.value
, float(raw
))
1146 def test_assign_float(self
):
1148 self
._def
.value
= raw
1149 self
.assertEqual(self
._def
, raw
)
1150 self
.assertEqual(self
._def
.value
, raw
)
1152 def test_assign_vfloat(self
):
1154 self
._def
.value
= bt2
.create_value(raw
)
1155 self
.assertEqual(self
._def
, raw
)
1156 self
.assertEqual(self
._def
.value
, raw
)
1158 def test_invalid_lshift(self
):
1159 self
._test
_invalid
_op
(lambda: self
._def
<< 23)
1161 def test_invalid_rshift(self
):
1162 self
._test
_invalid
_op
(lambda: self
._def
>> 23)
1164 def test_invalid_and(self
):
1165 self
._test
_invalid
_op
(lambda: self
._def
& 23)
1167 def test_invalid_or(self
):
1168 self
._test
_invalid
_op
(lambda: self
._def |
23)
1170 def test_invalid_xor(self
):
1171 self
._test
_invalid
_op
(lambda: self
._def ^
23)
1173 def test_invalid_invert(self
):
1174 self
._test
_invalid
_op
(lambda: ~self
._def
)
1177 _inject_numeric_testing_methods(FloatValueTestCase
)
1180 class StringValueTestCase(_TestCopySimple
, _TestFrozenSimple
, unittest
.TestCase
):
1182 self
._def
_value
= 'Hello, World!'
1183 self
._def
= bt2
.StringValue(self
._def
_value
)
1184 self
._def
_new
_value
= 'Yes!'
1189 def _assert_expecting_str(self
):
1190 return self
.assertRaises(TypeError)
1192 def test_create_default(self
):
1193 s
= bt2
.StringValue()
1194 self
.assertEqual(s
.value
, '')
1196 def test_create_from_str(self
):
1198 s
= bt2
.StringValue(raw
)
1199 self
.assertEqual(s
.value
, raw
)
1201 def test_create_from_vstr(self
):
1203 s
= bt2
.StringValue(bt2
.create_value(raw
))
1204 self
.assertEqual(s
.value
, raw
)
1206 def test_create_from_unknown(self
):
1210 with self
._assert
_expecting
_str
():
1211 i
= bt2
.StringValue(A())
1213 def test_create_from_varray(self
):
1214 with self
._assert
_expecting
_str
():
1215 i
= bt2
.StringValue(bt2
.ArrayValue())
1217 def test_assign_int(self
):
1218 with self
._assert
_expecting
_str
():
1219 self
._def
.value
= 283
1221 def test_assign_str(self
):
1224 self
.assertEqual(self
._def
, raw
)
1226 def test_assign_vstr(self
):
1228 self
._def
= bt2
.create_value(raw
)
1229 self
.assertEqual(self
._def
, raw
)
1232 self
.assertEqual(self
._def
, self
._def
_value
)
1235 self
.assertNotEqual(self
._def
, 23)
1237 def test_lt_vstring(self
):
1238 s1
= bt2
.StringValue('allo')
1239 s2
= bt2
.StringValue('bateau')
1240 self
.assertLess(s1
, s2
)
1242 def test_lt_string(self
):
1243 s1
= bt2
.StringValue('allo')
1244 self
.assertLess(s1
, 'bateau')
1246 def test_le_vstring(self
):
1247 s1
= bt2
.StringValue('allo')
1248 s2
= bt2
.StringValue('bateau')
1249 self
.assertLessEqual(s1
, s2
)
1251 def test_le_string(self
):
1252 s1
= bt2
.StringValue('allo')
1253 self
.assertLessEqual(s1
, 'bateau')
1255 def test_gt_vstring(self
):
1256 s1
= bt2
.StringValue('allo')
1257 s2
= bt2
.StringValue('bateau')
1258 self
.assertGreater(s2
, s1
)
1260 def test_gt_string(self
):
1261 s1
= bt2
.StringValue('allo')
1262 self
.assertGreater('bateau', s1
)
1264 def test_ge_vstring(self
):
1265 s1
= bt2
.StringValue('allo')
1266 s2
= bt2
.StringValue('bateau')
1267 self
.assertGreaterEqual(s2
, s1
)
1269 def test_ge_string(self
):
1270 s1
= bt2
.StringValue('allo')
1271 self
.assertGreaterEqual('bateau', s1
)
1273 def test_bool_op(self
):
1274 self
.assertEqual(bool(self
._def
), bool(self
._def
_value
))
1276 def test_str_op(self
):
1277 self
.assertEqual(str(self
._def
), str(self
._def
_value
))
1280 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1282 def test_getitem(self
):
1283 self
.assertEqual(self
._def
[5], self
._def
_value
[5])
1285 def test_append_str(self
):
1286 to_append
= 'meow meow meow'
1287 self
._def
+= to_append
1288 self
._def
_value
+= to_append
1289 self
.assertEqual(self
._def
, self
._def
_value
)
1291 def test_append_vstr(self
):
1292 to_append
= 'meow meow meow'
1293 self
._def
+= bt2
.create_value(to_append
)
1294 self
._def
_value
+= to_append
1295 self
.assertEqual(self
._def
, self
._def
_value
)
1298 class ArrayValueTestCase(_TestFrozen
, unittest
.TestCase
):
1300 self
._def
_value
= [None, False, True, -23, 0, 42, -42.4, 23.17, 'yes']
1301 self
._def
= bt2
.ArrayValue(copy
.deepcopy(self
._def
_value
))
1306 def _modify_def(self
):
1307 self
._def
[2] = 'xyz'
1309 def _assert_type_error(self
):
1310 return self
.assertRaises(TypeError)
1312 def test_create_default(self
):
1313 a
= bt2
.ArrayValue()
1314 self
.assertEqual(len(a
), 0)
1316 def test_create_from_array(self
):
1317 self
.assertEqual(self
._def
, self
._def
_value
)
1319 def test_create_from_tuple(self
):
1320 t
= 1, 2, False, None
1321 a
= bt2
.ArrayValue(t
)
1322 self
.assertEqual(a
, t
)
1324 def test_create_from_varray(self
):
1325 va
= bt2
.ArrayValue(copy
.deepcopy(self
._def
_value
))
1326 a
= bt2
.ArrayValue(va
)
1327 self
.assertEqual(va
, a
)
1329 def test_create_from_unknown(self
):
1333 with self
._assert
_type
_error
():
1334 a
= bt2
.ArrayValue(A())
1336 def test_bool_op_true(self
):
1337 self
.assertTrue(bool(self
._def
))
1339 def test_bool_op_false(self
):
1340 self
.assertFalse(bool(bt2
.ArrayValue()))
1343 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1345 def test_copy(self
):
1346 to_copy
= (1, 2, 'hello', (4, 5.2))
1347 a
= bt2
.ArrayValue(to_copy
)
1349 self
.assertEqual(a
, cpy
)
1350 self
.assertNotEqual(a
.addr
, cpy
.addr
)
1351 self
.assertEqual(a
[3].addr
, cpy
[3].addr
)
1353 def test_deepcopy(self
):
1354 to_copy
= (1, 2, 'hello', (4, 5.2))
1355 a
= bt2
.ArrayValue(to_copy
)
1356 cpy
= copy
.deepcopy(a
)
1357 self
.assertEqual(a
, cpy
)
1358 self
.assertNotEqual(a
.addr
, cpy
.addr
)
1359 self
.assertNotEqual(a
[3].addr
, cpy
[3].addr
)
1361 def test_eq_int(self
):
1362 self
.assertNotEqual(self
._def
, 23)
1364 def test_eq_diff_len(self
):
1365 a1
= bt2
.create_value([1, 2, 3])
1366 a2
= bt2
.create_value([1, 2])
1367 self
.assertNotEqual(a1
, a2
)
1369 def test_eq_diff_content_same_len(self
):
1370 a1
= bt2
.create_value([1, 2, 3])
1371 a2
= bt2
.create_value([4, 5, 6])
1372 self
.assertNotEqual(a1
, a2
)
1374 def test_eq_same_content_same_len(self
):
1375 raw
= (3, True, [1, 2.5, None, {'a': 17.6, 'b': None}])
1376 a1
= bt2
.ArrayValue(raw
)
1377 a2
= bt2
.ArrayValue(copy
.deepcopy(raw
))
1378 self
.assertEqual(a1
, a2
)
1380 def test_setitem_int(self
):
1383 self
.assertEqual(self
._def
[2], raw
)
1385 def test_setitem_vint(self
):
1387 self
._def
[2] = bt2
.create_value(raw
)
1388 self
.assertEqual(self
._def
[2], raw
)
1390 def test_setitem_none(self
):
1392 self
.assertIsNone(self
._def
[2])
1394 def test_setitem_index_wrong_type(self
):
1395 with self
._assert
_type
_error
():
1396 self
._def
['yes'] = 23
1398 def test_setitem_index_neg(self
):
1399 with self
.assertRaises(IndexError):
1402 def test_setitem_index_out_of_range(self
):
1403 with self
.assertRaises(IndexError):
1404 self
._def
[len(self
._def
)] = 23
1406 def test_append_none(self
):
1407 self
._def
.append(None)
1408 self
.assertIsNone(self
._def
[len(self
._def
) - 1])
1410 def test_append_int(self
):
1412 self
._def
.append(raw
)
1413 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
)
1415 def test_append_vint(self
):
1417 self
._def
.append(bt2
.create_value(raw
))
1418 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
)
1420 def test_append_unknown(self
):
1424 with self
._assert
_type
_error
():
1425 self
._def
.append(A())
1427 def test_iadd(self
):
1430 self
.assertEqual(self
._def
[len(self
._def
) - 3], raw
[0])
1431 self
.assertEqual(self
._def
[len(self
._def
) - 2], raw
[1])
1432 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
[2])
1434 def test_iadd_unknown(self
):
1438 with self
._assert
_type
_error
():
1441 def test_iadd_list_unknown(self
):
1445 with self
._assert
_type
_error
():
1448 def test_iter(self
):
1449 for velem
, elem
in zip(self
._def
, self
._def
_value
):
1450 self
.assertEqual(velem
, elem
)
1453 class MapValueTestCase(_TestFrozen
, unittest
.TestCase
):
1466 self
._def
= bt2
.MapValue(copy
.deepcopy(self
._def
_value
))
1471 def _modify_def(self
):
1472 self
._def
['zero'] = 1
1474 def test_create_default(self
):
1476 self
.assertEqual(len(m
), 0)
1478 def test_create_from_dict(self
):
1479 self
.assertEqual(self
._def
, self
._def
_value
)
1481 def test_create_from_vmap(self
):
1482 vm
= bt2
.MapValue(copy
.deepcopy(self
._def
_value
))
1483 m
= bt2
.MapValue(vm
)
1484 self
.assertEqual(vm
, m
)
1486 def test_create_from_unknown(self
):
1490 with self
.assertRaises(AttributeError):
1491 m
= bt2
.MapValue(A())
1493 def test_bool_op_true(self
):
1494 self
.assertTrue(bool(self
._def
))
1496 def test_bool_op_false(self
):
1497 self
.assertFalse(bool(bt2
.MapValue()))
1500 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1502 def test_copy(self
):
1509 m
= bt2
.MapValue(to_copy
)
1511 self
.assertEqual(m
, cpy
)
1512 self
.assertNotEqual(m
.addr
, cpy
.addr
)
1513 self
.assertEqual(m
['inner'].addr
, cpy
['inner'].addr
)
1515 def test_deepcopy(self
):
1522 m
= bt2
.MapValue(to_copy
)
1523 cpy
= copy
.deepcopy(m
)
1524 self
.assertEqual(m
, cpy
)
1525 self
.assertNotEqual(m
.addr
, cpy
.addr
)
1526 self
.assertNotEqual(m
['inner'].addr
, cpy
['inner'].addr
)
1528 def test_eq_int(self
):
1529 self
.assertNotEqual(self
._def
, 23)
1531 def test_eq_diff_len(self
):
1532 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1533 a2
= bt2
.create_value({'a': 1, 'b': 2})
1534 self
.assertNotEqual(a1
, a2
)
1536 def test_eq_diff_content_same_len(self
):
1537 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1538 a2
= bt2
.create_value({'a': 4, 'b': 2, 'c': 3})
1539 self
.assertNotEqual(a1
, a2
)
1541 def test_eq_same_content_diff_keys(self
):
1542 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1543 a2
= bt2
.create_value({'a': 1, 'k': 2, 'c': 3})
1544 self
.assertNotEqual(a1
, a2
)
1546 def test_eq_same_content_same_len(self
):
1550 'array': [1, 2.5, None, {'a': 17.6, 'b': None}]
1552 a1
= bt2
.MapValue(raw
)
1553 a2
= bt2
.MapValue(copy
.deepcopy(raw
))
1554 self
.assertEqual(a1
, a2
)
1555 self
.assertEqual(a1
, raw
)
1557 def test_setitem_int(self
):
1559 self
._def
['pos-int'] = raw
1560 self
.assertEqual(self
._def
['pos-int'], raw
)
1562 def test_setitem_vint(self
):
1564 self
._def
['pos-int'] = bt2
.create_value(raw
)
1565 self
.assertEqual(self
._def
['pos-int'], raw
)
1567 def test_setitem_none(self
):
1568 self
._def
['none'] = None
1569 self
.assertIsNone(self
._def
['none'])
1571 def test_setitem_new_int(self
):
1572 old_len
= len(self
._def
)
1573 self
._def
['new-int'] = 23
1574 self
.assertEqual(self
._def
['new-int'], 23)
1575 self
.assertEqual(len(self
._def
), old_len
+ 1)
1577 def test_setitem_index_wrong_type(self
):
1578 with self
.assertRaises(TypeError):
1581 def test_iter(self
):
1582 for vkey
, vval
in self
._def
.items():
1583 val
= self
._def
_value
[vkey
]
1584 self
.assertEqual(vval
, val
)
1586 def test_getitem_wrong_key(self
):
1587 with self
.assertRaises(KeyError):
1588 self
._def
['kilojoule']
This page took 0.124678 seconds and 5 git commands to generate.