f97af21af25d8e1eb6911ed4f7aee14247e860e8
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
.FrozenError
, 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
836 def _assert_expecting_bool(self
):
837 return self
.assertRaisesRegex(TypeError, r
"expecting a 'bool' object")
839 def test_create_default(self
):
843 def test_create_false(self
):
844 self
.assertFalse(self
._f
.value
)
845 self
.assertFalse(self
._f
)
847 def test_create_true(self
):
848 self
.assertTrue(self
._t
.value
)
849 self
.assertTrue(self
._t
)
851 def test_create_from_vfalse(self
):
852 b
= bt2
.BoolValue(self
._f
)
853 self
.assertFalse(b
.value
)
856 def test_create_from_vtrue(self
):
857 b
= bt2
.BoolValue(self
._t
)
858 self
.assertTrue(b
.value
)
861 def test_create_from_int_non_zero(self
):
862 with self
.assertRaises(TypeError):
863 b
= bt2
.BoolValue(23)
865 def test_create_from_int_zero(self
):
866 with self
.assertRaises(TypeError):
869 def test_assign_true(self
):
874 def test_assign_false(self
):
879 def test_assign_vtrue(self
):
884 def test_assign_vfalse(self
):
889 def test_assign_int(self
):
890 with self
.assertRaises(TypeError):
894 def test_bool_op(self
):
895 self
.assertEqual(bool(self
._def
), bool(self
._def
_value
))
897 def test_str_op(self
):
898 self
.assertEqual(str(self
._def
), str(self
._def
_value
))
900 def test_eq_none(self
):
901 self
.assertFalse(self
._def
== None)
903 def test_ne_none(self
):
904 self
.assertTrue(self
._def
!= None)
906 def test_vfalse_eq_false(self
):
907 self
.assertEqual(self
._f
, False)
909 def test_vfalse_ne_true(self
):
910 self
.assertNotEqual(self
._f
, True)
912 def test_vtrue_eq_true(self
):
913 self
.assertEqual(self
._t
, True)
915 def test_vtrue_ne_false(self
):
916 self
.assertNotEqual(self
._t
, False)
919 class IntegerValueTestCase(_TestNumericValue
, unittest
.TestCase
):
923 self
._ip
= bt2
.IntegerValue(self
._pv
)
924 self
._in
= bt2
.IntegerValue(self
._nv
)
926 self
._def
_value
= self
._pv
927 self
._def
_new
_value
= -101
929 def _assert_expecting_int(self
):
930 return self
.assertRaisesRegex(TypeError, r
'expecting a number object')
932 def _assert_expecting_int64(self
):
933 return self
.assertRaisesRegex(ValueError, r
"expecting a signed 64-bit integral value")
935 def _assert_expecting_uint64(self
):
936 return self
.assertRaisesRegex(ValueError, r
"expecting an unsigned 64-bit integral value")
938 def test_create_default(self
):
939 i
= bt2
.IntegerValue()
940 self
.assertEqual(i
.value
, 0)
942 def test_create_pos(self
):
943 self
.assertEqual(self
._ip
.value
, self
._pv
)
944 self
.assertEqual(self
._ip
, self
._pv
)
946 def test_create_neg(self
):
947 self
.assertEqual(self
._in
.value
, self
._nv
)
948 self
.assertEqual(self
._in
, self
._nv
)
950 def test_create_pos_too_big(self
):
951 with self
._assert
_expecting
_int
64():
952 i
= bt2
.IntegerValue(2 ** 63)
954 def test_create_neg_too_big(self
):
955 with self
._assert
_expecting
_int
64():
956 i
= bt2
.IntegerValue(-(2 ** 63) - 1)
958 def test_create_from_vint(self
):
959 i
= bt2
.IntegerValue(self
._ip
)
960 self
.assertEqual(i
, self
._pv
)
962 def test_create_from_false(self
):
963 i
= bt2
.IntegerValue(False)
964 self
.assertFalse(i
.value
)
967 def test_create_from_true(self
):
968 i
= bt2
.IntegerValue(True)
969 self
.assertTrue(i
.value
)
972 def test_create_from_float(self
):
973 i
= bt2
.IntegerValue(99.6)
974 self
.assertEqual(i
, 99)
976 def test_create_from_vfloat(self
):
977 f
= bt2
.create_value(17.5)
978 i
= bt2
.IntegerValue(f
)
979 self
.assertEqual(i
, 17)
981 def test_create_from_unknown(self
):
985 with self
._assert
_expecting
_int
():
986 i
= bt2
.IntegerValue(A())
988 def test_create_from_varray(self
):
989 with self
._assert
_expecting
_int
():
990 i
= bt2
.IntegerValue(bt2
.ArrayValue())
992 def test_assign_true(self
):
994 self
._def
.value
= raw
995 self
.assertEqual(self
._def
, raw
)
996 self
.assertEqual(self
._def
.value
, raw
)
998 def test_assign_false(self
):
1000 self
._def
.value
= raw
1001 self
.assertEqual(self
._def
, raw
)
1002 self
.assertEqual(self
._def
.value
, raw
)
1004 def test_assign_pos_int(self
):
1006 self
._def
.value
= raw
1007 self
.assertEqual(self
._def
, raw
)
1008 self
.assertEqual(self
._def
.value
, raw
)
1010 def test_assign_neg_int(self
):
1012 self
._def
.value
= raw
1013 self
.assertEqual(self
._def
, raw
)
1014 self
.assertEqual(self
._def
.value
, raw
)
1016 def test_assign_vint(self
):
1018 self
._def
.value
= bt2
.create_value(raw
)
1019 self
.assertEqual(self
._def
, raw
)
1020 self
.assertEqual(self
._def
.value
, raw
)
1022 def test_assign_vfloat(self
):
1024 self
._def
.value
= bt2
.create_value(raw
)
1025 self
.assertEqual(self
._def
, int(raw
))
1026 self
.assertEqual(self
._def
.value
, int(raw
))
1029 _inject_numeric_testing_methods(IntegerValueTestCase
)
1032 class FloatValueTestCase(_TestNumericValue
, unittest
.TestCase
):
1036 self
._fp
= bt2
.FloatValue(self
._pv
)
1037 self
._fn
= bt2
.FloatValue(self
._nv
)
1038 self
._def
= self
._fp
1039 self
._def
_value
= self
._pv
1040 self
._def
_new
_value
= -101.88
1042 def _assert_expecting_float(self
):
1043 return self
.assertRaisesRegex(TypeError, r
"expecting a real number object")
1045 def _test_invalid_op(self
, cb
):
1046 with self
.assertRaises(TypeError):
1049 def test_create_default(self
):
1050 f
= bt2
.FloatValue()
1051 self
.assertEqual(f
.value
, 0.0)
1053 def test_create_pos(self
):
1054 self
.assertEqual(self
._fp
.value
, self
._pv
)
1055 self
.assertEqual(self
._fp
, self
._pv
)
1057 def test_create_neg(self
):
1058 self
.assertEqual(self
._fn
.value
, self
._nv
)
1059 self
.assertEqual(self
._fn
, self
._nv
)
1061 def test_create_from_vint(self
):
1062 f
= bt2
.FloatValue(self
._fp
)
1063 self
.assertEqual(f
, self
._pv
)
1065 def test_create_from_false(self
):
1066 f
= bt2
.FloatValue(False)
1067 self
.assertFalse(f
.value
)
1070 def test_create_from_true(self
):
1071 f
= bt2
.FloatValue(True)
1072 self
.assertTrue(f
.value
)
1075 def test_create_from_int(self
):
1077 f
= bt2
.FloatValue(raw
)
1078 self
.assertEqual(f
.value
, float(raw
))
1080 def test_create_from_vint(self
):
1082 f
= bt2
.FloatValue(bt2
.create_value(raw
))
1083 self
.assertEqual(f
.value
, float(raw
))
1085 def test_create_from_vfloat(self
):
1087 f
= bt2
.FloatValue(bt2
.create_value(raw
))
1088 self
.assertEqual(f
.value
, raw
)
1090 def test_create_from_unknown(self
):
1094 with self
._assert
_expecting
_float
():
1095 f
= bt2
.FloatValue(A())
1097 def test_create_from_varray(self
):
1098 with self
._assert
_expecting
_float
():
1099 f
= bt2
.FloatValue(bt2
.ArrayValue())
1101 def test_assign_true(self
):
1102 self
._def
.value
= True
1103 self
.assertTrue(self
._def
)
1104 self
.assertTrue(self
._def
.value
)
1106 def test_assign_false(self
):
1107 self
._def
.value
= False
1108 self
.assertFalse(self
._def
)
1109 self
.assertFalse(self
._def
.value
)
1111 def test_assign_pos_int(self
):
1113 self
._def
.value
= raw
1114 self
.assertEqual(self
._def
, float(raw
))
1115 self
.assertEqual(self
._def
.value
, float(raw
))
1117 def test_assign_neg_int(self
):
1119 self
._def
.value
= raw
1120 self
.assertEqual(self
._def
, float(raw
))
1121 self
.assertEqual(self
._def
.value
, float(raw
))
1123 def test_assign_vint(self
):
1125 self
._def
.value
= bt2
.create_value(raw
)
1126 self
.assertEqual(self
._def
, float(raw
))
1127 self
.assertEqual(self
._def
.value
, float(raw
))
1129 def test_assign_float(self
):
1131 self
._def
.value
= raw
1132 self
.assertEqual(self
._def
, raw
)
1133 self
.assertEqual(self
._def
.value
, raw
)
1135 def test_assign_vfloat(self
):
1137 self
._def
.value
= bt2
.create_value(raw
)
1138 self
.assertEqual(self
._def
, raw
)
1139 self
.assertEqual(self
._def
.value
, raw
)
1141 def test_invalid_lshift(self
):
1142 self
._test
_invalid
_op
(lambda: self
._def
<< 23)
1144 def test_invalid_rshift(self
):
1145 self
._test
_invalid
_op
(lambda: self
._def
>> 23)
1147 def test_invalid_and(self
):
1148 self
._test
_invalid
_op
(lambda: self
._def
& 23)
1150 def test_invalid_or(self
):
1151 self
._test
_invalid
_op
(lambda: self
._def |
23)
1153 def test_invalid_xor(self
):
1154 self
._test
_invalid
_op
(lambda: self
._def ^
23)
1156 def test_invalid_invert(self
):
1157 self
._test
_invalid
_op
(lambda: ~self
._def
)
1160 _inject_numeric_testing_methods(FloatValueTestCase
)
1163 class StringValueTestCase(_TestCopySimple
, _TestFrozenSimple
, unittest
.TestCase
):
1165 self
._def
_value
= 'Hello, World!'
1166 self
._def
= bt2
.StringValue(self
._def
_value
)
1167 self
._def
_new
_value
= 'Yes!'
1169 def _assert_expecting_str(self
):
1170 return self
.assertRaises(TypeError)
1172 def test_create_default(self
):
1173 s
= bt2
.StringValue()
1174 self
.assertEqual(s
.value
, '')
1176 def test_create_from_str(self
):
1178 s
= bt2
.StringValue(raw
)
1179 self
.assertEqual(s
.value
, raw
)
1181 def test_create_from_vstr(self
):
1183 s
= bt2
.StringValue(bt2
.create_value(raw
))
1184 self
.assertEqual(s
.value
, raw
)
1186 def test_create_from_unknown(self
):
1190 with self
._assert
_expecting
_str
():
1191 i
= bt2
.StringValue(A())
1193 def test_create_from_varray(self
):
1194 with self
._assert
_expecting
_str
():
1195 i
= bt2
.StringValue(bt2
.ArrayValue())
1197 def test_assign_int(self
):
1198 with self
._assert
_expecting
_str
():
1199 self
._def
.value
= 283
1201 def test_assign_str(self
):
1204 self
.assertEqual(self
._def
, raw
)
1206 def test_assign_vstr(self
):
1208 self
._def
= bt2
.create_value(raw
)
1209 self
.assertEqual(self
._def
, raw
)
1212 self
.assertEqual(self
._def
, self
._def
_value
)
1215 self
.assertNotEqual(self
._def
, 23)
1217 def test_lt_vstring(self
):
1218 s1
= bt2
.StringValue('allo')
1219 s2
= bt2
.StringValue('bateau')
1220 self
.assertLess(s1
, s2
)
1222 def test_lt_string(self
):
1223 s1
= bt2
.StringValue('allo')
1224 self
.assertLess(s1
, 'bateau')
1226 def test_le_vstring(self
):
1227 s1
= bt2
.StringValue('allo')
1228 s2
= bt2
.StringValue('bateau')
1229 self
.assertLessEqual(s1
, s2
)
1231 def test_le_string(self
):
1232 s1
= bt2
.StringValue('allo')
1233 self
.assertLessEqual(s1
, 'bateau')
1235 def test_gt_vstring(self
):
1236 s1
= bt2
.StringValue('allo')
1237 s2
= bt2
.StringValue('bateau')
1238 self
.assertGreater(s2
, s1
)
1240 def test_gt_string(self
):
1241 s1
= bt2
.StringValue('allo')
1242 self
.assertGreater('bateau', s1
)
1244 def test_ge_vstring(self
):
1245 s1
= bt2
.StringValue('allo')
1246 s2
= bt2
.StringValue('bateau')
1247 self
.assertGreaterEqual(s2
, s1
)
1249 def test_ge_string(self
):
1250 s1
= bt2
.StringValue('allo')
1251 self
.assertGreaterEqual('bateau', s1
)
1253 def test_bool_op(self
):
1254 self
.assertEqual(bool(self
._def
), bool(self
._def
_value
))
1256 def test_str_op(self
):
1257 self
.assertEqual(str(self
._def
), str(self
._def
_value
))
1260 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1262 def test_getitem(self
):
1263 self
.assertEqual(self
._def
[5], self
._def
_value
[5])
1265 def test_append_str(self
):
1266 to_append
= 'meow meow meow'
1267 self
._def
+= to_append
1268 self
._def
_value
+= to_append
1269 self
.assertEqual(self
._def
, self
._def
_value
)
1271 def test_append_vstr(self
):
1272 to_append
= 'meow meow meow'
1273 self
._def
+= bt2
.create_value(to_append
)
1274 self
._def
_value
+= to_append
1275 self
.assertEqual(self
._def
, self
._def
_value
)
1278 class ArrayValueTestCase(_TestFrozen
, unittest
.TestCase
):
1280 self
._def
_value
= [None, False, True, -23, 0, 42, -42.4, 23.17, 'yes']
1281 self
._def
= bt2
.ArrayValue(copy
.deepcopy(self
._def
_value
))
1283 def _modify_def(self
):
1284 self
._def
[2] = 'xyz'
1286 def _assert_type_error(self
):
1287 return self
.assertRaises(TypeError)
1289 def test_create_default(self
):
1290 a
= bt2
.ArrayValue()
1291 self
.assertEqual(len(a
), 0)
1293 def test_create_from_array(self
):
1294 self
.assertEqual(self
._def
, self
._def
_value
)
1296 def test_create_from_tuple(self
):
1297 t
= 1, 2, False, None
1298 a
= bt2
.ArrayValue(t
)
1299 self
.assertEqual(a
, t
)
1301 def test_create_from_varray(self
):
1302 va
= bt2
.ArrayValue(copy
.deepcopy(self
._def
_value
))
1303 a
= bt2
.ArrayValue(va
)
1304 self
.assertEqual(va
, a
)
1306 def test_create_from_unknown(self
):
1310 with self
._assert
_type
_error
():
1311 a
= bt2
.ArrayValue(A())
1313 def test_bool_op_true(self
):
1314 self
.assertTrue(bool(self
._def
))
1316 def test_bool_op_false(self
):
1317 self
.assertFalse(bool(bt2
.ArrayValue()))
1320 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1322 def test_copy(self
):
1323 to_copy
= (1, 2, 'hello', (4, 5.2))
1324 a
= bt2
.ArrayValue(to_copy
)
1326 self
.assertEqual(a
, cpy
)
1327 self
.assertNotEqual(a
.addr
, cpy
.addr
)
1328 self
.assertEqual(a
[3].addr
, cpy
[3].addr
)
1330 def test_deepcopy(self
):
1331 to_copy
= (1, 2, 'hello', (4, 5.2))
1332 a
= bt2
.ArrayValue(to_copy
)
1333 cpy
= copy
.deepcopy(a
)
1334 self
.assertEqual(a
, cpy
)
1335 self
.assertNotEqual(a
.addr
, cpy
.addr
)
1336 self
.assertNotEqual(a
[3].addr
, cpy
[3].addr
)
1338 def test_eq_int(self
):
1339 self
.assertNotEqual(self
._def
, 23)
1341 def test_eq_diff_len(self
):
1342 a1
= bt2
.create_value([1, 2, 3])
1343 a2
= bt2
.create_value([1, 2])
1344 self
.assertNotEqual(a1
, a2
)
1346 def test_eq_diff_content_same_len(self
):
1347 a1
= bt2
.create_value([1, 2, 3])
1348 a2
= bt2
.create_value([4, 5, 6])
1349 self
.assertNotEqual(a1
, a2
)
1351 def test_eq_same_content_same_len(self
):
1352 raw
= (3, True, [1, 2.5, None, {'a': 17.6, 'b': None}])
1353 a1
= bt2
.ArrayValue(raw
)
1354 a2
= bt2
.ArrayValue(copy
.deepcopy(raw
))
1355 self
.assertEqual(a1
, a2
)
1357 def test_setitem_int(self
):
1360 self
.assertEqual(self
._def
[2], raw
)
1362 def test_setitem_vint(self
):
1364 self
._def
[2] = bt2
.create_value(raw
)
1365 self
.assertEqual(self
._def
[2], raw
)
1367 def test_setitem_none(self
):
1369 self
.assertIsNone(self
._def
[2])
1371 def test_setitem_index_wrong_type(self
):
1372 with self
._assert
_type
_error
():
1373 self
._def
['yes'] = 23
1375 def test_setitem_index_neg(self
):
1376 with self
.assertRaises(IndexError):
1379 def test_setitem_index_out_of_range(self
):
1380 with self
.assertRaises(IndexError):
1381 self
._def
[len(self
._def
)] = 23
1383 def test_append_none(self
):
1384 self
._def
.append(None)
1385 self
.assertIsNone(self
._def
[len(self
._def
) - 1])
1387 def test_append_int(self
):
1389 self
._def
.append(raw
)
1390 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
)
1392 def test_append_vint(self
):
1394 self
._def
.append(bt2
.create_value(raw
))
1395 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
)
1397 def test_append_unknown(self
):
1401 with self
._assert
_type
_error
():
1402 self
._def
.append(A())
1404 def test_iadd(self
):
1407 self
.assertEqual(self
._def
[len(self
._def
) - 3], raw
[0])
1408 self
.assertEqual(self
._def
[len(self
._def
) - 2], raw
[1])
1409 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
[2])
1411 def test_iadd_unknown(self
):
1415 with self
._assert
_type
_error
():
1418 def test_iadd_list_unknown(self
):
1422 with self
._assert
_type
_error
():
1425 def test_iter(self
):
1426 for velem
, elem
in zip(self
._def
, self
._def
_value
):
1427 self
.assertEqual(velem
, elem
)
1430 class MapValueTestCase(_TestFrozen
, unittest
.TestCase
):
1443 self
._def
= bt2
.MapValue(copy
.deepcopy(self
._def
_value
))
1445 def _modify_def(self
):
1446 self
._def
['zero'] = 1
1448 def test_create_default(self
):
1450 self
.assertEqual(len(m
), 0)
1452 def test_create_from_dict(self
):
1453 self
.assertEqual(self
._def
, self
._def
_value
)
1455 def test_create_from_vmap(self
):
1456 vm
= bt2
.MapValue(copy
.deepcopy(self
._def
_value
))
1457 m
= bt2
.MapValue(vm
)
1458 self
.assertEqual(vm
, m
)
1460 def test_create_from_unknown(self
):
1464 with self
.assertRaises(AttributeError):
1465 m
= bt2
.MapValue(A())
1467 def test_bool_op_true(self
):
1468 self
.assertTrue(bool(self
._def
))
1470 def test_bool_op_false(self
):
1471 self
.assertFalse(bool(bt2
.MapValue()))
1474 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1476 def test_copy(self
):
1483 m
= bt2
.MapValue(to_copy
)
1485 self
.assertEqual(m
, cpy
)
1486 self
.assertNotEqual(m
.addr
, cpy
.addr
)
1487 self
.assertEqual(m
['inner'].addr
, cpy
['inner'].addr
)
1489 def test_deepcopy(self
):
1496 m
= bt2
.MapValue(to_copy
)
1497 cpy
= copy
.deepcopy(m
)
1498 self
.assertEqual(m
, cpy
)
1499 self
.assertNotEqual(m
.addr
, cpy
.addr
)
1500 self
.assertNotEqual(m
['inner'].addr
, cpy
['inner'].addr
)
1502 def test_eq_int(self
):
1503 self
.assertNotEqual(self
._def
, 23)
1505 def test_eq_diff_len(self
):
1506 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1507 a2
= bt2
.create_value({'a': 1, 'b': 2})
1508 self
.assertNotEqual(a1
, a2
)
1510 def test_eq_diff_content_same_len(self
):
1511 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1512 a2
= bt2
.create_value({'a': 4, 'b': 2, 'c': 3})
1513 self
.assertNotEqual(a1
, a2
)
1515 def test_eq_same_content_diff_keys(self
):
1516 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1517 a2
= bt2
.create_value({'a': 1, 'k': 2, 'c': 3})
1518 self
.assertNotEqual(a1
, a2
)
1520 def test_eq_same_content_same_len(self
):
1524 'array': [1, 2.5, None, {'a': 17.6, 'b': None}]
1526 a1
= bt2
.MapValue(raw
)
1527 a2
= bt2
.MapValue(copy
.deepcopy(raw
))
1528 self
.assertEqual(a1
, a2
)
1529 self
.assertEqual(a1
, raw
)
1531 def test_setitem_int(self
):
1533 self
._def
['pos-int'] = raw
1534 self
.assertEqual(self
._def
['pos-int'], raw
)
1536 def test_setitem_vint(self
):
1538 self
._def
['pos-int'] = bt2
.create_value(raw
)
1539 self
.assertEqual(self
._def
['pos-int'], raw
)
1541 def test_setitem_none(self
):
1542 self
._def
['none'] = None
1543 self
.assertIsNone(self
._def
['none'])
1545 def test_setitem_new_int(self
):
1546 old_len
= len(self
._def
)
1547 self
._def
['new-int'] = 23
1548 self
.assertEqual(self
._def
['new-int'], 23)
1549 self
.assertEqual(len(self
._def
), old_len
+ 1)
1551 def test_setitem_index_wrong_type(self
):
1552 with self
.assertRaises(TypeError):
1555 def test_iter(self
):
1556 for vkey
, vval
in self
._def
.items():
1557 val
= self
._def
_value
[vkey
]
1558 self
.assertEqual(vval
, val
)
1560 def test_getitem_wrong_key(self
):
1561 with self
.assertRaises(KeyError):
1562 self
._def
['kilojoule']
This page took 0.087229 seconds and 4 git commands to generate.