1 from functools
import partial
, partialmethod
10 class _TestCopySimple
:
12 with self
.assertRaises(NotImplementedError):
15 def test_deepcopy(self
):
16 with self
.assertRaises(NotImplementedError):
17 copy
.deepcopy(self
._def
)
26 class _TestNumericValue(_TestCopySimple
):
27 def _binop(self
, op
, rhs
):
33 r
= op(self
._def
, rhs
)
34 except Exception as e
:
38 rv
= op(self
._def
_value
, comp_value
)
39 except Exception as e
:
42 if rexc
is not None or rvexc
is not None:
43 # at least one of the operations raised an exception: in
44 # this case both operations should have raised the same
45 # type of exception (division by zero, bit shift with a
46 # floating point number operand, etc.)
47 self
.assertIs(type(rexc
), type(rvexc
))
52 def _unaryop(self
, op
):
58 except Exception as e
:
62 rv
= op(self
._def
_value
)
63 except Exception as e
:
66 if rexc
is not None or rvexc
is not None:
67 # at least one of the operations raised an exception: in
68 # this case both operations should have raised the same
69 # type of exception (division by zero, bit shift with a
70 # floating point number operand, etc.)
71 self
.assertIs(type(rexc
), type(rvexc
))
76 def _test_unaryop_type(self
, op
):
77 r
, rv
= self
._unaryop
(op
)
82 self
.assertIsInstance(r
, type(rv
))
84 def _test_unaryop_value(self
, op
):
85 r
, rv
= self
._unaryop
(op
)
90 self
.assertEqual(r
, rv
)
92 def _test_unaryop_addr_same(self
, op
):
93 addr_before
= self
._def
.addr
95 self
.assertEqual(self
._def
.addr
, addr_before
)
97 def _test_unaryop_value_same(self
, op
):
98 value_before
= self
._def
.__class
__(self
._def
)
100 self
.assertEqual(self
._def
, value_before
)
102 def _test_binop_type(self
, op
, rhs
):
103 r
, rv
= self
._binop
(op
, rhs
)
108 if op
in _COMP_BINOPS
:
109 # __eq__() and __ne__() always return a 'bool' object
110 self
.assertIsInstance(r
, bool)
112 self
.assertIsInstance(r
, type(rv
))
114 def _test_binop_value(self
, op
, rhs
):
115 r
, rv
= self
._binop
(op
, rhs
)
120 self
.assertEqual(r
, rv
)
122 def _test_binop_lhs_addr_same(self
, op
, rhs
):
123 addr_before
= self
._def
.addr
124 r
, rv
= self
._binop
(op
, rhs
)
125 self
.assertEqual(self
._def
.addr
, addr_before
)
127 def _test_binop_lhs_value_same(self
, op
, rhs
):
128 value_before
= self
._def
.__class
__(self
._def
)
129 r
, rv
= self
._binop
(op
, rhs
)
130 self
.assertEqual(self
._def
, value_before
)
132 def _test_binop_invalid_unknown(self
, op
):
133 if op
in _COMP_BINOPS
:
134 self
.skipTest('not testing')
139 with self
.assertRaises(TypeError):
142 def _test_binop_invalid_none(self
, op
):
143 if op
in _COMP_BINOPS
:
144 self
.skipTest('not testing')
146 with self
.assertRaises(TypeError):
149 def _test_ibinop_value(self
, op
, rhs
):
150 r
, rv
= self
._binop
(op
, rhs
)
155 # The inplace operators are special for value objects because
156 # they do not return a new, immutable object like it's the case
157 # for Python numbers. In Python, `a += 2`, where `a` is a number
158 # object, assigns a new number object reference to `a`, dropping
159 # the old reference. Since BT's value objects are mutable, we
160 # modify their internal value with the inplace operators. This
161 # means however that we can lose data in the process, for
164 # int_value_obj += 3.3
166 # Here, if `int_value_obj` is a Python `int` with the value 2,
167 # it would be a `float` object after this, holding the value
168 # 5.3. In our case, if `int_value_obj` is an integer value
169 # object, 3.3 is converted to an `int` object (3) and added to
170 # the current value of `int_value_obj`, so after this the value
171 # of the object is 5. This does not compare to 5.3, which is
172 # why we also use the `int()` type here.
173 if type(self
._def
) is bt2
.IntegerValue
:
176 self
.assertEqual(r
, rv
)
178 def _test_ibinop_type(self
, op
, rhs
):
179 r
, rv
= self
._binop
(op
, rhs
)
184 self
.assertIs(r
, self
._def
)
186 def _test_ibinop_invalid_unknown(self
, op
):
190 with self
.assertRaises(TypeError):
193 def _test_ibinop_invalid_none(self
, op
):
194 with self
.assertRaises(TypeError):
197 def _test_binop_rhs_false(self
, test_cb
, op
):
200 def _test_binop_rhs_true(self
, test_cb
, op
):
203 def _test_binop_rhs_pos_int(self
, test_cb
, op
):
206 def _test_binop_rhs_neg_int(self
, test_cb
, op
):
209 def _test_binop_rhs_zero_int(self
, test_cb
, op
):
212 def _test_binop_rhs_pos_vint(self
, test_cb
, op
):
213 test_cb(op
, bt2
.create_value(2))
215 def _test_binop_rhs_neg_vint(self
, test_cb
, op
):
216 test_cb(op
, bt2
.create_value(-23))
218 def _test_binop_rhs_zero_vint(self
, test_cb
, op
):
219 test_cb(op
, bt2
.create_value(0))
221 def _test_binop_rhs_pos_float(self
, test_cb
, op
):
224 def _test_binop_rhs_neg_float(self
, test_cb
, op
):
227 def _test_binop_rhs_zero_float(self
, test_cb
, op
):
230 def _test_binop_rhs_pos_vfloat(self
, test_cb
, op
):
231 test_cb(op
, bt2
.create_value(2.2))
233 def _test_binop_rhs_neg_vfloat(self
, test_cb
, op
):
234 test_cb(op
, bt2
.create_value(-23.4))
236 def _test_binop_rhs_zero_vfloat(self
, test_cb
, op
):
237 test_cb(op
, bt2
.create_value(0.0))
239 def _test_binop_type_false(self
, op
):
240 self
._test
_binop
_rhs
_false
(self
._test
_binop
_type
, op
)
242 def _test_binop_type_true(self
, op
):
243 self
._test
_binop
_rhs
_true
(self
._test
_binop
_type
, op
)
245 def _test_binop_type_pos_int(self
, op
):
246 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_type
, op
)
248 def _test_binop_type_neg_int(self
, op
):
249 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_type
, op
)
251 def _test_binop_type_zero_int(self
, op
):
252 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_type
, op
)
254 def _test_binop_type_pos_vint(self
, op
):
255 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_type
, op
)
257 def _test_binop_type_neg_vint(self
, op
):
258 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_type
, op
)
260 def _test_binop_type_zero_vint(self
, op
):
261 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_type
, op
)
263 def _test_binop_type_pos_float(self
, op
):
264 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_type
, op
)
266 def _test_binop_type_neg_float(self
, op
):
267 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_type
, op
)
269 def _test_binop_type_zero_float(self
, op
):
270 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_type
, op
)
272 def _test_binop_type_pos_vfloat(self
, op
):
273 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_type
, op
)
275 def _test_binop_type_neg_vfloat(self
, op
):
276 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_type
, op
)
278 def _test_binop_type_zero_vfloat(self
, op
):
279 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_type
, op
)
281 def _test_binop_value_false(self
, op
):
282 self
._test
_binop
_rhs
_false
(self
._test
_binop
_value
, op
)
284 def _test_binop_value_true(self
, op
):
285 self
._test
_binop
_rhs
_true
(self
._test
_binop
_value
, op
)
287 def _test_binop_value_pos_int(self
, op
):
288 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_value
, op
)
290 def _test_binop_value_neg_int(self
, op
):
291 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_value
, op
)
293 def _test_binop_value_zero_int(self
, op
):
294 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_value
, op
)
296 def _test_binop_value_pos_vint(self
, op
):
297 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_value
, op
)
299 def _test_binop_value_neg_vint(self
, op
):
300 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_value
, op
)
302 def _test_binop_value_zero_vint(self
, op
):
303 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_value
, op
)
305 def _test_binop_value_pos_float(self
, op
):
306 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_value
, op
)
308 def _test_binop_value_neg_float(self
, op
):
309 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_value
, op
)
311 def _test_binop_value_zero_float(self
, op
):
312 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_value
, op
)
314 def _test_binop_value_pos_vfloat(self
, op
):
315 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_value
, op
)
317 def _test_binop_value_neg_vfloat(self
, op
):
318 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_value
, op
)
320 def _test_binop_value_zero_vfloat(self
, op
):
321 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_value
, op
)
323 def _test_binop_lhs_addr_same_false(self
, op
):
324 self
._test
_binop
_rhs
_false
(self
._test
_binop
_lhs
_addr
_same
, op
)
326 def _test_binop_lhs_addr_same_true(self
, op
):
327 self
._test
_binop
_rhs
_true
(self
._test
_binop
_lhs
_addr
_same
, op
)
329 def _test_binop_lhs_addr_same_pos_int(self
, op
):
330 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_lhs
_addr
_same
, op
)
332 def _test_binop_lhs_addr_same_neg_int(self
, op
):
333 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_lhs
_addr
_same
, op
)
335 def _test_binop_lhs_addr_same_zero_int(self
, op
):
336 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_lhs
_addr
_same
, op
)
338 def _test_binop_lhs_addr_same_pos_vint(self
, op
):
339 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_lhs
_addr
_same
, op
)
341 def _test_binop_lhs_addr_same_neg_vint(self
, op
):
342 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_lhs
_addr
_same
, op
)
344 def _test_binop_lhs_addr_same_zero_vint(self
, op
):
345 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_lhs
_addr
_same
, op
)
347 def _test_binop_lhs_addr_same_pos_float(self
, op
):
348 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_lhs
_addr
_same
, op
)
350 def _test_binop_lhs_addr_same_neg_float(self
, op
):
351 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_lhs
_addr
_same
, op
)
353 def _test_binop_lhs_addr_same_zero_float(self
, op
):
354 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_lhs
_addr
_same
, op
)
356 def _test_binop_lhs_addr_same_pos_vfloat(self
, op
):
357 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_lhs
_addr
_same
, op
)
359 def _test_binop_lhs_addr_same_neg_vfloat(self
, op
):
360 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_lhs
_addr
_same
, op
)
362 def _test_binop_lhs_addr_same_zero_vfloat(self
, op
):
363 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_lhs
_addr
_same
, op
)
365 def _test_binop_lhs_value_same_false(self
, op
):
366 self
._test
_binop
_rhs
_false
(self
._test
_binop
_lhs
_value
_same
, op
)
368 def _test_binop_lhs_value_same_true(self
, op
):
369 self
._test
_binop
_rhs
_true
(self
._test
_binop
_lhs
_value
_same
, op
)
371 def _test_binop_lhs_value_same_pos_int(self
, op
):
372 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_lhs
_value
_same
, op
)
374 def _test_binop_lhs_value_same_neg_int(self
, op
):
375 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_lhs
_value
_same
, op
)
377 def _test_binop_lhs_value_same_zero_int(self
, op
):
378 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_lhs
_value
_same
, op
)
380 def _test_binop_lhs_value_same_pos_vint(self
, op
):
381 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_lhs
_value
_same
, op
)
383 def _test_binop_lhs_value_same_neg_vint(self
, op
):
384 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_lhs
_value
_same
, op
)
386 def _test_binop_lhs_value_same_zero_vint(self
, op
):
387 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_lhs
_value
_same
, op
)
389 def _test_binop_lhs_value_same_pos_float(self
, op
):
390 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_lhs
_value
_same
, op
)
392 def _test_binop_lhs_value_same_neg_float(self
, op
):
393 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_lhs
_value
_same
, op
)
395 def _test_binop_lhs_value_same_zero_float(self
, op
):
396 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_lhs
_value
_same
, op
)
398 def _test_binop_lhs_value_same_pos_vfloat(self
, op
):
399 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_lhs
_value
_same
, op
)
401 def _test_binop_lhs_value_same_neg_vfloat(self
, op
):
402 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_lhs
_value
_same
, op
)
404 def _test_binop_lhs_value_same_zero_vfloat(self
, op
):
405 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_lhs
_value
_same
, op
)
407 def _test_ibinop_type_false(self
, op
):
408 self
._test
_binop
_rhs
_false
(self
._test
_ibinop
_type
, op
)
410 def _test_ibinop_type_true(self
, op
):
411 self
._test
_binop
_rhs
_true
(self
._test
_ibinop
_type
, op
)
413 def _test_ibinop_type_pos_int(self
, op
):
414 self
._test
_binop
_rhs
_pos
_int
(self
._test
_ibinop
_type
, op
)
416 def _test_ibinop_type_neg_int(self
, op
):
417 self
._test
_binop
_rhs
_neg
_int
(self
._test
_ibinop
_type
, op
)
419 def _test_ibinop_type_zero_int(self
, op
):
420 self
._test
_binop
_rhs
_zero
_int
(self
._test
_ibinop
_type
, op
)
422 def _test_ibinop_type_pos_vint(self
, op
):
423 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_ibinop
_type
, op
)
425 def _test_ibinop_type_neg_vint(self
, op
):
426 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_ibinop
_type
, op
)
428 def _test_ibinop_type_zero_vint(self
, op
):
429 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_ibinop
_type
, op
)
431 def _test_ibinop_type_pos_float(self
, op
):
432 self
._test
_binop
_rhs
_pos
_float
(self
._test
_ibinop
_type
, op
)
434 def _test_ibinop_type_neg_float(self
, op
):
435 self
._test
_binop
_rhs
_neg
_float
(self
._test
_ibinop
_type
, op
)
437 def _test_ibinop_type_zero_float(self
, op
):
438 self
._test
_binop
_rhs
_zero
_float
(self
._test
_ibinop
_type
, op
)
440 def _test_ibinop_type_pos_vfloat(self
, op
):
441 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_ibinop
_type
, op
)
443 def _test_ibinop_type_neg_vfloat(self
, op
):
444 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_ibinop
_type
, op
)
446 def _test_ibinop_type_zero_vfloat(self
, op
):
447 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_ibinop
_type
, op
)
449 def _test_ibinop_value_false(self
, op
):
450 self
._test
_binop
_rhs
_false
(self
._test
_ibinop
_value
, op
)
452 def _test_ibinop_value_true(self
, op
):
453 self
._test
_binop
_rhs
_true
(self
._test
_ibinop
_value
, op
)
455 def _test_ibinop_value_pos_int(self
, op
):
456 self
._test
_binop
_rhs
_pos
_int
(self
._test
_ibinop
_value
, op
)
458 def _test_ibinop_value_neg_int(self
, op
):
459 self
._test
_binop
_rhs
_neg
_int
(self
._test
_ibinop
_value
, op
)
461 def _test_ibinop_value_zero_int(self
, op
):
462 self
._test
_binop
_rhs
_zero
_int
(self
._test
_ibinop
_value
, op
)
464 def _test_ibinop_value_pos_vint(self
, op
):
465 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_ibinop
_value
, op
)
467 def _test_ibinop_value_neg_vint(self
, op
):
468 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_ibinop
_value
, op
)
470 def _test_ibinop_value_zero_vint(self
, op
):
471 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_ibinop
_value
, op
)
473 def _test_ibinop_value_pos_float(self
, op
):
474 self
._test
_binop
_rhs
_pos
_float
(self
._test
_ibinop
_value
, op
)
476 def _test_ibinop_value_neg_float(self
, op
):
477 self
._test
_binop
_rhs
_neg
_float
(self
._test
_ibinop
_value
, op
)
479 def _test_ibinop_value_zero_float(self
, op
):
480 self
._test
_binop
_rhs
_zero
_float
(self
._test
_ibinop
_value
, op
)
482 def _test_ibinop_value_pos_vfloat(self
, op
):
483 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_ibinop
_value
, op
)
485 def _test_ibinop_value_neg_vfloat(self
, op
):
486 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_ibinop
_value
, op
)
488 def _test_ibinop_value_zero_vfloat(self
, op
):
489 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_ibinop
_value
, op
)
491 def test_bool_op(self
):
492 self
.assertEqual(bool(self
._def
), bool(self
._def
_value
))
494 def test_int_op(self
):
495 self
.assertEqual(int(self
._def
), int(self
._def
_value
))
497 def test_float_op(self
):
498 self
.assertEqual(float(self
._def
), float(self
._def
_value
))
500 def test_complex_op(self
):
501 self
.assertEqual(complex(self
._def
), complex(self
._def
_value
))
503 def test_str_op(self
):
504 self
.assertEqual(str(self
._def
), str(self
._def
_value
))
506 def test_eq_none(self
):
507 self
.assertFalse(self
._def
== None)
509 def test_ne_none(self
):
510 self
.assertTrue(self
._def
!= None)
520 ('add', operator
.add
),
521 ('radd', lambda a
, b
: operator
.add(b
, a
)),
522 ('and', operator
.and_
),
523 ('rand', lambda a
, b
: operator
.and_(b
, a
)),
524 ('floordiv', operator
.floordiv
),
525 ('rfloordiv', lambda a
, b
: operator
.floordiv(b
, a
)),
526 ('lshift', operator
.lshift
),
527 ('rlshift', lambda a
, b
: operator
.lshift(b
, a
)),
528 ('mod', operator
.mod
),
529 ('rmod', lambda a
, b
: operator
.mod(b
, a
)),
530 ('mul', operator
.mul
),
531 ('rmul', lambda a
, b
: operator
.mul(b
, a
)),
532 ('or', operator
.or_
),
533 ('ror', lambda a
, b
: operator
.or_(b
, a
)),
534 ('pow', operator
.pow),
535 ('rpow', lambda a
, b
: operator
.pow(b
, a
)),
536 ('rshift', operator
.rshift
),
537 ('rrshift', lambda a
, b
: operator
.rshift(b
, a
)),
538 ('sub', operator
.sub
),
539 ('rsub', lambda a
, b
: operator
.sub(b
, a
)),
540 ('truediv', operator
.truediv
),
541 ('rtruediv', lambda a
, b
: operator
.truediv(b
, a
)),
542 ('xor', operator
.xor
),
543 ('rxor', lambda a
, b
: operator
.xor(b
, a
)),
548 ('iadd', operator
.iadd
),
549 ('iand', operator
.iand
),
550 ('ifloordiv', operator
.ifloordiv
),
551 ('ilshift', operator
.ilshift
),
552 ('imod', operator
.imod
),
553 ('imul', operator
.imul
),
554 ('ior', operator
.ior
),
555 ('ipow', operator
.ipow
),
556 ('irshift', operator
.irshift
),
557 ('isub', operator
.isub
),
558 ('itruediv', operator
.itruediv
),
559 ('ixor', operator
.ixor
),
564 ('neg', operator
.neg
),
565 ('pos', operator
.pos
),
566 ('abs', operator
.abs),
567 ('invert', operator
.invert
),
569 ('round_0', partial(round, ndigits
=0)),
570 ('round_1', partial(round, ndigits
=1)),
571 ('round_2', partial(round, ndigits
=2)),
572 ('round_3', partial(round, ndigits
=3)),
574 ('floor', math
.floor
),
575 ('trunc', math
.trunc
),
579 def _inject_numeric_testing_methods(cls
):
580 def test_binop_name(suffix
):
581 return 'test_binop_{}_{}'.format(name
, suffix
)
583 def test_ibinop_name(suffix
):
584 return 'test_ibinop_{}_{}'.format(name
, suffix
)
586 def test_unaryop_name(suffix
):
587 return 'test_unaryop_{}_{}'.format(name
, suffix
)
589 # inject testing methods for each binary operation
590 for name
, binop
in _BINOPS
:
592 setattr(cls
, test_binop_name('invalid_unknown'), partialmethod(_TestNumericValue
._test
_binop
_invalid
_unknown
, op
=binop
))
593 setattr(cls
, test_binop_name('invalid_none'), partialmethod(_TestNumericValue
._test
_binop
_invalid
_none
, op
=binop
))
594 setattr(cls
, test_binop_name('type_true'), partialmethod(_TestNumericValue
._test
_binop
_type
_true
, op
=binop
))
595 setattr(cls
, test_binop_name('type_pos_int'), partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_int
, op
=binop
))
596 setattr(cls
, test_binop_name('type_pos_vint'), partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_vint
, op
=binop
))
597 setattr(cls
, test_binop_name('value_true'), partialmethod(_TestNumericValue
._test
_binop
_value
_true
, op
=binop
))
598 setattr(cls
, test_binop_name('value_pos_int'), partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_int
, op
=binop
))
599 setattr(cls
, test_binop_name('value_pos_vint'), partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_vint
, op
=binop
))
600 setattr(cls
, test_binop_name('lhs_addr_same_true'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_true
, op
=binop
))
601 setattr(cls
, test_binop_name('lhs_addr_same_pos_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_int
, op
=binop
))
602 setattr(cls
, test_binop_name('lhs_addr_same_pos_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_vint
, op
=binop
))
603 setattr(cls
, test_binop_name('lhs_value_same_true'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_true
, op
=binop
))
604 setattr(cls
, test_binop_name('lhs_value_same_pos_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_int
, op
=binop
))
605 setattr(cls
, test_binop_name('lhs_value_same_pos_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_vint
, op
=binop
))
606 setattr(cls
, test_binop_name('type_neg_int'), partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_int
, op
=binop
))
607 setattr(cls
, test_binop_name('type_neg_vint'), partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_vint
, op
=binop
))
608 setattr(cls
, test_binop_name('value_neg_int'), partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_int
, op
=binop
))
609 setattr(cls
, test_binop_name('value_neg_vint'), partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_vint
, op
=binop
))
610 setattr(cls
, test_binop_name('lhs_addr_same_neg_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_int
, op
=binop
))
611 setattr(cls
, test_binop_name('lhs_addr_same_neg_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_vint
, op
=binop
))
612 setattr(cls
, test_binop_name('lhs_value_same_neg_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_int
, op
=binop
))
613 setattr(cls
, test_binop_name('lhs_value_same_neg_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_vint
, op
=binop
))
614 setattr(cls
, test_binop_name('type_false'), partialmethod(_TestNumericValue
._test
_binop
_type
_false
, op
=binop
))
615 setattr(cls
, test_binop_name('type_zero_int'), partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_int
, op
=binop
))
616 setattr(cls
, test_binop_name('type_zero_vint'), partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_vint
, op
=binop
))
617 setattr(cls
, test_binop_name('value_false'), partialmethod(_TestNumericValue
._test
_binop
_value
_false
, op
=binop
))
618 setattr(cls
, test_binop_name('value_zero_int'), partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_int
, op
=binop
))
619 setattr(cls
, test_binop_name('value_zero_vint'), partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_vint
, op
=binop
))
620 setattr(cls
, test_binop_name('lhs_addr_same_false'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_false
, op
=binop
))
621 setattr(cls
, test_binop_name('lhs_addr_same_zero_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_int
, op
=binop
))
622 setattr(cls
, test_binop_name('lhs_addr_same_zero_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_vint
, op
=binop
))
623 setattr(cls
, test_binop_name('lhs_value_same_false'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_false
, op
=binop
))
624 setattr(cls
, test_binop_name('lhs_value_same_zero_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_int
, op
=binop
))
625 setattr(cls
, test_binop_name('lhs_value_same_zero_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_vint
, op
=binop
))
626 setattr(cls
, test_binop_name('type_pos_float'), partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_float
, op
=binop
))
627 setattr(cls
, test_binop_name('type_neg_float'), partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_float
, op
=binop
))
628 setattr(cls
, test_binop_name('type_pos_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_vfloat
, op
=binop
))
629 setattr(cls
, test_binop_name('type_neg_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_vfloat
, op
=binop
))
630 setattr(cls
, test_binop_name('value_pos_float'), partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_float
, op
=binop
))
631 setattr(cls
, test_binop_name('value_neg_float'), partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_float
, op
=binop
))
632 setattr(cls
, test_binop_name('value_pos_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_vfloat
, op
=binop
))
633 setattr(cls
, test_binop_name('value_neg_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_vfloat
, op
=binop
))
634 setattr(cls
, test_binop_name('lhs_addr_same_pos_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_float
, op
=binop
))
635 setattr(cls
, test_binop_name('lhs_addr_same_neg_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_float
, op
=binop
))
636 setattr(cls
, test_binop_name('lhs_addr_same_pos_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_vfloat
, op
=binop
))
637 setattr(cls
, test_binop_name('lhs_addr_same_neg_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_vfloat
, op
=binop
))
638 setattr(cls
, test_binop_name('lhs_value_same_pos_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_float
, op
=binop
))
639 setattr(cls
, test_binop_name('lhs_value_same_neg_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_float
, op
=binop
))
640 setattr(cls
, test_binop_name('lhs_value_same_pos_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_vfloat
, op
=binop
))
641 setattr(cls
, test_binop_name('lhs_value_same_neg_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_vfloat
, op
=binop
))
642 setattr(cls
, test_binop_name('type_zero_float'), partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_float
, op
=binop
))
643 setattr(cls
, test_binop_name('type_zero_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_vfloat
, op
=binop
))
644 setattr(cls
, test_binop_name('value_zero_float'), partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_float
, op
=binop
))
645 setattr(cls
, test_binop_name('value_zero_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_vfloat
, op
=binop
))
646 setattr(cls
, test_binop_name('lhs_addr_same_zero_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_float
, op
=binop
))
647 setattr(cls
, test_binop_name('lhs_addr_same_zero_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_vfloat
, op
=binop
))
648 setattr(cls
, test_binop_name('lhs_value_same_zero_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_float
, op
=binop
))
649 setattr(cls
, test_binop_name('lhs_value_same_zero_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_vfloat
, op
=binop
))
651 # inject testing methods for each unary operation
652 for name
, unaryop
in _UNARYOPS
:
653 setattr(cls
, test_unaryop_name('type'), partialmethod(_TestNumericValue
._test
_unaryop
_type
, op
=unaryop
))
654 setattr(cls
, test_unaryop_name('value'), partialmethod(_TestNumericValue
._test
_unaryop
_value
, op
=unaryop
))
655 setattr(cls
, test_unaryop_name('addr_same'), partialmethod(_TestNumericValue
._test
_unaryop
_addr
_same
, op
=unaryop
))
656 setattr(cls
, test_unaryop_name('value_same'), partialmethod(_TestNumericValue
._test
_unaryop
_value
_same
, op
=unaryop
))
658 # inject testing methods for each inplace binary operation
659 for name
, ibinop
in _IBINOPS
:
660 setattr(cls
, test_ibinop_name('invalid_unknown'), partialmethod(_TestNumericValue
._test
_ibinop
_invalid
_unknown
, op
=ibinop
))
661 setattr(cls
, test_ibinop_name('invalid_none'), partialmethod(_TestNumericValue
._test
_ibinop
_invalid
_none
, op
=ibinop
))
662 setattr(cls
, test_ibinop_name('type_true'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_true
, op
=ibinop
))
663 setattr(cls
, test_ibinop_name('value_true'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_true
, op
=ibinop
))
664 setattr(cls
, test_ibinop_name('type_pos_int'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_pos
_int
, op
=ibinop
))
665 setattr(cls
, test_ibinop_name('type_pos_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_pos
_vint
, op
=ibinop
))
666 setattr(cls
, test_ibinop_name('value_pos_int'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_pos
_int
, op
=ibinop
))
667 setattr(cls
, test_ibinop_name('value_pos_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_pos
_vint
, op
=ibinop
))
668 setattr(cls
, test_ibinop_name('type_neg_int'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_neg
_int
, op
=ibinop
))
669 setattr(cls
, test_ibinop_name('type_neg_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_neg
_vint
, op
=ibinop
))
670 setattr(cls
, test_ibinop_name('value_neg_int'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_neg
_int
, op
=ibinop
))
671 setattr(cls
, test_ibinop_name('value_neg_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_neg
_vint
, op
=ibinop
))
672 setattr(cls
, test_ibinop_name('type_false'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_false
, op
=ibinop
))
673 setattr(cls
, test_ibinop_name('value_false'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_false
, op
=ibinop
))
674 setattr(cls
, test_ibinop_name('type_zero_int'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_zero
_int
, op
=ibinop
))
675 setattr(cls
, test_ibinop_name('type_zero_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_zero
_vint
, op
=ibinop
))
676 setattr(cls
, test_ibinop_name('value_zero_int'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_zero
_int
, op
=ibinop
))
677 setattr(cls
, test_ibinop_name('value_zero_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_zero
_vint
, op
=ibinop
))
678 setattr(cls
, test_ibinop_name('type_pos_float'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_pos
_float
, op
=ibinop
))
679 setattr(cls
, test_ibinop_name('type_neg_float'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_neg
_float
, op
=ibinop
))
680 setattr(cls
, test_ibinop_name('type_pos_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_pos
_vfloat
, op
=ibinop
))
681 setattr(cls
, test_ibinop_name('type_neg_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_neg
_vfloat
, op
=ibinop
))
682 setattr(cls
, test_ibinop_name('value_pos_float'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_pos
_float
, op
=ibinop
))
683 setattr(cls
, test_ibinop_name('value_neg_float'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_neg
_float
, op
=ibinop
))
684 setattr(cls
, test_ibinop_name('value_pos_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_pos
_vfloat
, op
=ibinop
))
685 setattr(cls
, test_ibinop_name('value_neg_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_neg
_vfloat
, op
=ibinop
))
686 setattr(cls
, test_ibinop_name('type_zero_float'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_zero
_float
, op
=ibinop
))
687 setattr(cls
, test_ibinop_name('type_zero_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_zero
_vfloat
, op
=ibinop
))
688 setattr(cls
, test_ibinop_name('value_zero_float'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_zero
_float
, op
=ibinop
))
689 setattr(cls
, test_ibinop_name('value_zero_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_zero
_vfloat
, op
=ibinop
))
692 class CreateValueFuncTestCase(unittest
.TestCase
):
693 def test_create_none(self
):
694 v
= bt2
.create_value(None)
697 def test_create_bool_false(self
):
698 v
= bt2
.create_value(False)
699 self
.assertIsInstance(v
, bt2
.BoolValue
)
702 def test_create_bool_true(self
):
703 v
= bt2
.create_value(True)
704 self
.assertIsInstance(v
, bt2
.BoolValue
)
707 def test_create_int_pos(self
):
709 v
= bt2
.create_value(raw
)
710 self
.assertIsInstance(v
, bt2
.IntegerValue
)
711 self
.assertEqual(v
, raw
)
713 def test_create_int_neg(self
):
715 v
= bt2
.create_value(raw
)
716 self
.assertIsInstance(v
, bt2
.IntegerValue
)
717 self
.assertEqual(v
, raw
)
719 def test_create_float_pos(self
):
721 v
= bt2
.create_value(raw
)
722 self
.assertIsInstance(v
, bt2
.RealValue
)
723 self
.assertEqual(v
, raw
)
725 def test_create_float_neg(self
):
727 v
= bt2
.create_value(raw
)
728 self
.assertIsInstance(v
, bt2
.RealValue
)
729 self
.assertEqual(v
, raw
)
731 def test_create_string(self
):
733 v
= bt2
.create_value(raw
)
734 self
.assertIsInstance(v
, bt2
.StringValue
)
735 self
.assertEqual(v
, raw
)
737 def test_create_string_empty(self
):
739 v
= bt2
.create_value(raw
)
740 self
.assertIsInstance(v
, bt2
.StringValue
)
741 self
.assertEqual(v
, raw
)
743 def test_create_array_from_list(self
):
745 v
= bt2
.create_value(raw
)
746 self
.assertIsInstance(v
, bt2
.ArrayValue
)
747 self
.assertEqual(v
, raw
)
749 def test_create_array_from_tuple(self
):
751 v
= bt2
.create_value(raw
)
752 self
.assertIsInstance(v
, bt2
.ArrayValue
)
753 self
.assertEqual(v
, raw
)
755 def test_create_array_from_empty_list(self
):
757 v
= bt2
.create_value(raw
)
758 self
.assertIsInstance(v
, bt2
.ArrayValue
)
759 self
.assertEqual(v
, raw
)
761 def test_create_array_from_empty_tuple(self
):
763 v
= bt2
.create_value(raw
)
764 self
.assertIsInstance(v
, bt2
.ArrayValue
)
765 self
.assertEqual(v
, raw
)
767 def test_create_map(self
):
769 v
= bt2
.create_value(raw
)
770 self
.assertIsInstance(v
, bt2
.MapValue
)
771 self
.assertEqual(v
, raw
)
773 def test_create_map_empty(self
):
775 v
= bt2
.create_value(raw
)
776 self
.assertIsInstance(v
, bt2
.MapValue
)
777 self
.assertEqual(v
, raw
)
779 def test_create_vfalse(self
):
780 v
= bt2
.create_value(bt2
.create_value(False))
781 self
.assertIsInstance(v
, bt2
.BoolValue
)
784 def test_create_invalid(self
):
790 with self
.assertRaisesRegex(TypeError, "cannot create value object from 'A' object") as cm
:
791 v
= bt2
.create_value(a
)
794 class BoolValueTestCase(_TestCopySimple
, unittest
.TestCase
):
796 self
._f
= bt2
.BoolValue(False)
797 self
._t
= bt2
.BoolValue(True)
799 self
._def
_value
= False
800 self
._def
_new
_value
= True
807 def _assert_expecting_bool(self
):
808 return self
.assertRaisesRegex(TypeError, r
"expecting a 'bool' object")
810 def test_create_default(self
):
814 def test_create_false(self
):
815 self
.assertFalse(self
._f
)
817 def test_create_true(self
):
818 self
.assertTrue(self
._t
)
820 def test_create_from_vfalse(self
):
821 b
= bt2
.BoolValue(self
._f
)
824 def test_create_from_vtrue(self
):
825 b
= bt2
.BoolValue(self
._t
)
828 def test_create_from_int_non_zero(self
):
829 with self
.assertRaises(TypeError):
830 b
= bt2
.BoolValue(23)
832 def test_create_from_int_zero(self
):
833 with self
.assertRaises(TypeError):
836 def test_assign_true(self
):
841 def test_assign_false(self
):
846 def test_assign_vtrue(self
):
851 def test_assign_vfalse(self
):
856 def test_assign_int(self
):
857 with self
.assertRaises(TypeError):
861 def test_bool_op(self
):
862 self
.assertEqual(bool(self
._def
), bool(self
._def
_value
))
864 def test_str_op(self
):
865 self
.assertEqual(str(self
._def
), str(self
._def
_value
))
867 def test_eq_none(self
):
868 self
.assertFalse(self
._def
== None)
870 def test_ne_none(self
):
871 self
.assertTrue(self
._def
!= None)
873 def test_vfalse_eq_false(self
):
874 self
.assertEqual(self
._f
, False)
876 def test_vfalse_ne_true(self
):
877 self
.assertNotEqual(self
._f
, True)
879 def test_vtrue_eq_true(self
):
880 self
.assertEqual(self
._t
, True)
882 def test_vtrue_ne_false(self
):
883 self
.assertNotEqual(self
._t
, False)
886 class IntegerValueTestCase(_TestNumericValue
, unittest
.TestCase
):
890 self
._ip
= bt2
.IntegerValue(self
._pv
)
891 self
._in
= bt2
.IntegerValue(self
._nv
)
893 self
._def
_value
= self
._pv
894 self
._def
_new
_value
= -101
902 def _assert_expecting_int(self
):
903 return self
.assertRaisesRegex(TypeError, r
'expecting a number object')
905 def _assert_expecting_int64(self
):
906 return self
.assertRaisesRegex(ValueError, r
"expecting a signed 64-bit integral value")
908 def _assert_expecting_uint64(self
):
909 return self
.assertRaisesRegex(ValueError, r
"expecting an unsigned 64-bit integral value")
911 def test_create_default(self
):
912 i
= bt2
.IntegerValue()
913 self
.assertEqual(i
, 0)
915 def test_create_pos(self
):
916 self
.assertEqual(self
._ip
, self
._pv
)
918 def test_create_neg(self
):
919 self
.assertEqual(self
._in
, self
._nv
)
921 def test_create_pos_too_big(self
):
922 with self
._assert
_expecting
_int
64():
923 i
= bt2
.IntegerValue(2 ** 63)
925 def test_create_neg_too_big(self
):
926 with self
._assert
_expecting
_int
64():
927 i
= bt2
.IntegerValue(-(2 ** 63) - 1)
929 def test_create_from_vint(self
):
930 i
= bt2
.IntegerValue(self
._ip
)
931 self
.assertEqual(i
, self
._pv
)
933 def test_create_from_false(self
):
934 i
= bt2
.IntegerValue(False)
937 def test_create_from_true(self
):
938 i
= bt2
.IntegerValue(True)
941 def test_create_from_float(self
):
942 i
= bt2
.IntegerValue(99.6)
943 self
.assertEqual(i
, 99)
945 def test_create_from_vfloat(self
):
946 f
= bt2
.create_value(17.5)
947 i
= bt2
.IntegerValue(f
)
948 self
.assertEqual(i
, 17)
950 def test_create_from_unknown(self
):
954 with self
._assert
_expecting
_int
():
955 i
= bt2
.IntegerValue(A())
957 def test_create_from_varray(self
):
958 with self
._assert
_expecting
_int
():
959 i
= bt2
.IntegerValue(bt2
.ArrayValue())
961 def test_assign_true(self
):
963 self
._def
.value
= raw
964 self
.assertEqual(self
._def
, raw
)
966 def test_assign_false(self
):
968 self
._def
.value
= raw
969 self
.assertEqual(self
._def
, raw
)
971 def test_assign_pos_int(self
):
973 self
._def
.value
= raw
974 self
.assertEqual(self
._def
, raw
)
976 def test_assign_neg_int(self
):
978 self
._def
.value
= raw
979 self
.assertEqual(self
._def
, raw
)
981 def test_assign_vint(self
):
983 self
._def
.value
= bt2
.create_value(raw
)
984 self
.assertEqual(self
._def
, raw
)
986 def test_assign_vfloat(self
):
988 self
._def
.value
= bt2
.create_value(raw
)
989 self
.assertEqual(self
._def
, int(raw
))
992 _inject_numeric_testing_methods(IntegerValueTestCase
)
995 class RealValueTestCase(_TestNumericValue
, unittest
.TestCase
):
999 self
._fp
= bt2
.RealValue(self
._pv
)
1000 self
._fn
= bt2
.RealValue(self
._nv
)
1001 self
._def
= self
._fp
1002 self
._def
_value
= self
._pv
1003 self
._def
_new
_value
= -101.88
1011 def _assert_expecting_float(self
):
1012 return self
.assertRaisesRegex(TypeError, r
"expecting a real number object")
1014 def _test_invalid_op(self
, cb
):
1015 with self
.assertRaises(TypeError):
1018 def test_create_default(self
):
1020 self
.assertEqual(f
, 0.0)
1022 def test_create_pos(self
):
1023 self
.assertEqual(self
._fp
, self
._pv
)
1025 def test_create_neg(self
):
1026 self
.assertEqual(self
._fn
, self
._nv
)
1028 def test_create_from_vint(self
):
1029 f
= bt2
.RealValue(self
._fp
)
1030 self
.assertEqual(f
, self
._pv
)
1032 def test_create_from_false(self
):
1033 f
= bt2
.RealValue(False)
1036 def test_create_from_true(self
):
1037 f
= bt2
.RealValue(True)
1040 def test_create_from_int(self
):
1042 f
= bt2
.RealValue(raw
)
1043 self
.assertEqual(f
, float(raw
))
1045 def test_create_from_vint(self
):
1047 f
= bt2
.RealValue(bt2
.create_value(raw
))
1048 self
.assertEqual(f
, float(raw
))
1050 def test_create_from_vfloat(self
):
1052 f
= bt2
.RealValue(bt2
.create_value(raw
))
1053 self
.assertEqual(f
, raw
)
1055 def test_create_from_unknown(self
):
1059 with self
._assert
_expecting
_float
():
1060 f
= bt2
.RealValue(A())
1062 def test_create_from_varray(self
):
1063 with self
._assert
_expecting
_float
():
1064 f
= bt2
.RealValue(bt2
.ArrayValue())
1066 def test_assign_true(self
):
1067 self
._def
.value
= True
1068 self
.assertTrue(self
._def
)
1070 def test_assign_false(self
):
1071 self
._def
.value
= False
1072 self
.assertFalse(self
._def
)
1074 def test_assign_pos_int(self
):
1076 self
._def
.value
= raw
1077 self
.assertEqual(self
._def
, float(raw
))
1079 def test_assign_neg_int(self
):
1081 self
._def
.value
= raw
1082 self
.assertEqual(self
._def
, float(raw
))
1084 def test_assign_vint(self
):
1086 self
._def
.value
= bt2
.create_value(raw
)
1087 self
.assertEqual(self
._def
, float(raw
))
1089 def test_assign_float(self
):
1091 self
._def
.value
= raw
1092 self
.assertEqual(self
._def
, raw
)
1094 def test_assign_vfloat(self
):
1096 self
._def
.value
= bt2
.create_value(raw
)
1097 self
.assertEqual(self
._def
, raw
)
1099 def test_invalid_lshift(self
):
1100 self
._test
_invalid
_op
(lambda: self
._def
<< 23)
1102 def test_invalid_rshift(self
):
1103 self
._test
_invalid
_op
(lambda: self
._def
>> 23)
1105 def test_invalid_and(self
):
1106 self
._test
_invalid
_op
(lambda: self
._def
& 23)
1108 def test_invalid_or(self
):
1109 self
._test
_invalid
_op
(lambda: self
._def |
23)
1111 def test_invalid_xor(self
):
1112 self
._test
_invalid
_op
(lambda: self
._def ^
23)
1114 def test_invalid_invert(self
):
1115 self
._test
_invalid
_op
(lambda: ~self
._def
)
1118 _inject_numeric_testing_methods(RealValueTestCase
)
1121 class StringValueTestCase(_TestCopySimple
, unittest
.TestCase
):
1123 self
._def
_value
= 'Hello, World!'
1124 self
._def
= bt2
.StringValue(self
._def
_value
)
1125 self
._def
_new
_value
= 'Yes!'
1130 def _assert_expecting_str(self
):
1131 return self
.assertRaises(TypeError)
1133 def test_create_default(self
):
1134 s
= bt2
.StringValue()
1135 self
.assertEqual(s
, '')
1137 def test_create_from_str(self
):
1139 s
= bt2
.StringValue(raw
)
1140 self
.assertEqual(s
, raw
)
1142 def test_create_from_vstr(self
):
1144 s
= bt2
.StringValue(bt2
.create_value(raw
))
1145 self
.assertEqual(s
, raw
)
1147 def test_create_from_unknown(self
):
1151 with self
._assert
_expecting
_str
():
1152 i
= bt2
.StringValue(A())
1154 def test_create_from_varray(self
):
1155 with self
._assert
_expecting
_str
():
1156 i
= bt2
.StringValue(bt2
.ArrayValue())
1158 def test_assign_int(self
):
1159 with self
._assert
_expecting
_str
():
1160 self
._def
.value
= 283
1162 def test_assign_str(self
):
1165 self
.assertEqual(self
._def
, raw
)
1167 def test_assign_vstr(self
):
1169 self
._def
= bt2
.create_value(raw
)
1170 self
.assertEqual(self
._def
, raw
)
1173 self
.assertEqual(self
._def
, self
._def
_value
)
1176 self
.assertNotEqual(self
._def
, 23)
1178 def test_lt_vstring(self
):
1179 s1
= bt2
.StringValue('allo')
1180 s2
= bt2
.StringValue('bateau')
1181 self
.assertLess(s1
, s2
)
1183 def test_lt_string(self
):
1184 s1
= bt2
.StringValue('allo')
1185 self
.assertLess(s1
, 'bateau')
1187 def test_le_vstring(self
):
1188 s1
= bt2
.StringValue('allo')
1189 s2
= bt2
.StringValue('bateau')
1190 self
.assertLessEqual(s1
, s2
)
1192 def test_le_string(self
):
1193 s1
= bt2
.StringValue('allo')
1194 self
.assertLessEqual(s1
, 'bateau')
1196 def test_gt_vstring(self
):
1197 s1
= bt2
.StringValue('allo')
1198 s2
= bt2
.StringValue('bateau')
1199 self
.assertGreater(s2
, s1
)
1201 def test_gt_string(self
):
1202 s1
= bt2
.StringValue('allo')
1203 self
.assertGreater('bateau', s1
)
1205 def test_ge_vstring(self
):
1206 s1
= bt2
.StringValue('allo')
1207 s2
= bt2
.StringValue('bateau')
1208 self
.assertGreaterEqual(s2
, s1
)
1210 def test_ge_string(self
):
1211 s1
= bt2
.StringValue('allo')
1212 self
.assertGreaterEqual('bateau', s1
)
1214 def test_bool_op(self
):
1215 self
.assertEqual(bool(self
._def
), bool(self
._def
_value
))
1217 def test_str_op(self
):
1218 self
.assertEqual(str(self
._def
), str(self
._def
_value
))
1221 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1223 def test_getitem(self
):
1224 self
.assertEqual(self
._def
[5], self
._def
_value
[5])
1226 def test_append_str(self
):
1227 to_append
= 'meow meow meow'
1228 self
._def
+= to_append
1229 self
._def
_value
+= to_append
1230 self
.assertEqual(self
._def
, self
._def
_value
)
1232 def test_append_vstr(self
):
1233 to_append
= 'meow meow meow'
1234 self
._def
+= bt2
.create_value(to_append
)
1235 self
._def
_value
+= to_append
1236 self
.assertEqual(self
._def
, self
._def
_value
)
1239 class ArrayValueTestCase(_TestCopySimple
, unittest
.TestCase
):
1241 self
._def
_value
= [None, False, True, -23, 0, 42, -42.4, 23.17, 'yes']
1242 self
._def
= bt2
.ArrayValue(copy
.deepcopy(self
._def
_value
))
1247 def _modify_def(self
):
1248 self
._def
[2] = 'xyz'
1250 def _assert_type_error(self
):
1251 return self
.assertRaises(TypeError)
1253 def test_create_default(self
):
1254 a
= bt2
.ArrayValue()
1255 self
.assertEqual(len(a
), 0)
1257 def test_create_from_array(self
):
1258 self
.assertEqual(self
._def
, self
._def
_value
)
1260 def test_create_from_tuple(self
):
1261 t
= 1, 2, False, None
1262 a
= bt2
.ArrayValue(t
)
1263 self
.assertEqual(a
, t
)
1265 def test_create_from_varray(self
):
1266 va
= bt2
.ArrayValue(copy
.deepcopy(self
._def
_value
))
1267 a
= bt2
.ArrayValue(va
)
1268 self
.assertEqual(va
, a
)
1270 def test_create_from_unknown(self
):
1274 with self
._assert
_type
_error
():
1275 a
= bt2
.ArrayValue(A())
1277 def test_bool_op_true(self
):
1278 self
.assertTrue(bool(self
._def
))
1280 def test_bool_op_false(self
):
1281 self
.assertFalse(bool(bt2
.ArrayValue()))
1284 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1286 def test_eq_int(self
):
1287 self
.assertNotEqual(self
._def
, 23)
1289 def test_eq_diff_len(self
):
1290 a1
= bt2
.create_value([1, 2, 3])
1291 a2
= bt2
.create_value([1, 2])
1292 self
.assertNotEqual(a1
, a2
)
1294 def test_eq_diff_content_same_len(self
):
1295 a1
= bt2
.create_value([1, 2, 3])
1296 a2
= bt2
.create_value([4, 5, 6])
1297 self
.assertNotEqual(a1
, a2
)
1299 def test_eq_same_content_same_len(self
):
1300 raw
= (3, True, [1, 2.5, None, {'a': 17.6, 'b': None}])
1301 a1
= bt2
.ArrayValue(raw
)
1302 a2
= bt2
.ArrayValue(copy
.deepcopy(raw
))
1303 self
.assertEqual(a1
, a2
)
1305 def test_setitem_int(self
):
1308 self
.assertEqual(self
._def
[2], raw
)
1310 def test_setitem_vint(self
):
1312 self
._def
[2] = bt2
.create_value(raw
)
1313 self
.assertEqual(self
._def
[2], raw
)
1315 def test_setitem_none(self
):
1317 self
.assertIsNone(self
._def
[2])
1319 def test_setitem_index_wrong_type(self
):
1320 with self
._assert
_type
_error
():
1321 self
._def
['yes'] = 23
1323 def test_setitem_index_neg(self
):
1324 with self
.assertRaises(IndexError):
1327 def test_setitem_index_out_of_range(self
):
1328 with self
.assertRaises(IndexError):
1329 self
._def
[len(self
._def
)] = 23
1331 def test_append_none(self
):
1332 self
._def
.append(None)
1333 self
.assertIsNone(self
._def
[len(self
._def
) - 1])
1335 def test_append_int(self
):
1337 self
._def
.append(raw
)
1338 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
)
1340 def test_append_vint(self
):
1342 self
._def
.append(bt2
.create_value(raw
))
1343 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
)
1345 def test_append_unknown(self
):
1349 with self
._assert
_type
_error
():
1350 self
._def
.append(A())
1352 def test_iadd(self
):
1355 self
.assertEqual(self
._def
[len(self
._def
) - 3], raw
[0])
1356 self
.assertEqual(self
._def
[len(self
._def
) - 2], raw
[1])
1357 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
[2])
1359 def test_iadd_unknown(self
):
1363 with self
._assert
_type
_error
():
1366 def test_iadd_list_unknown(self
):
1370 with self
._assert
_type
_error
():
1373 def test_iter(self
):
1374 for velem
, elem
in zip(self
._def
, self
._def
_value
):
1375 self
.assertEqual(velem
, elem
)
1378 class MapValueTestCase(_TestCopySimple
, unittest
.TestCase
):
1391 self
._def
= bt2
.MapValue(copy
.deepcopy(self
._def
_value
))
1396 def _modify_def(self
):
1397 self
._def
['zero'] = 1
1399 def test_create_default(self
):
1401 self
.assertEqual(len(m
), 0)
1403 def test_create_from_dict(self
):
1404 self
.assertEqual(self
._def
, self
._def
_value
)
1406 def test_create_from_vmap(self
):
1407 vm
= bt2
.MapValue(copy
.deepcopy(self
._def
_value
))
1408 m
= bt2
.MapValue(vm
)
1409 self
.assertEqual(vm
, m
)
1411 def test_create_from_unknown(self
):
1415 with self
.assertRaises(AttributeError):
1416 m
= bt2
.MapValue(A())
1418 def test_bool_op_true(self
):
1419 self
.assertTrue(bool(self
._def
))
1421 def test_bool_op_false(self
):
1422 self
.assertFalse(bool(bt2
.MapValue()))
1425 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1427 def test_eq_int(self
):
1428 self
.assertNotEqual(self
._def
, 23)
1430 def test_eq_diff_len(self
):
1431 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1432 a2
= bt2
.create_value({'a': 1, 'b': 2})
1433 self
.assertNotEqual(a1
, a2
)
1435 def test_eq_diff_content_same_len(self
):
1436 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1437 a2
= bt2
.create_value({'a': 4, 'b': 2, 'c': 3})
1438 self
.assertNotEqual(a1
, a2
)
1440 def test_eq_same_content_diff_keys(self
):
1441 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1442 a2
= bt2
.create_value({'a': 1, 'k': 2, 'c': 3})
1443 self
.assertNotEqual(a1
, a2
)
1445 def test_eq_same_content_same_len(self
):
1449 'array': [1, 2.5, None, {'a': 17.6, 'b': None}]
1451 a1
= bt2
.MapValue(raw
)
1452 a2
= bt2
.MapValue(copy
.deepcopy(raw
))
1453 self
.assertEqual(a1
, a2
)
1454 self
.assertEqual(a1
, raw
)
1456 def test_setitem_int(self
):
1458 self
._def
['pos-int'] = raw
1459 self
.assertEqual(self
._def
['pos-int'], raw
)
1461 def test_setitem_vint(self
):
1463 self
._def
['pos-int'] = bt2
.create_value(raw
)
1464 self
.assertEqual(self
._def
['pos-int'], raw
)
1466 def test_setitem_none(self
):
1467 self
._def
['none'] = None
1468 self
.assertIsNone(self
._def
['none'])
1470 def test_setitem_new_int(self
):
1471 old_len
= len(self
._def
)
1472 self
._def
['new-int'] = 23
1473 self
.assertEqual(self
._def
['new-int'], 23)
1474 self
.assertEqual(len(self
._def
), old_len
+ 1)
1476 def test_setitem_index_wrong_type(self
):
1477 with self
.assertRaises(TypeError):
1480 def test_iter(self
):
1481 for vkey
, vval
in self
._def
.items():
1482 val
= self
._def
_value
[vkey
]
1483 self
.assertEqual(vval
, val
)
1485 def test_getitem_wrong_key(self
):
1486 with self
.assertRaises(KeyError):
1487 self
._def
['kilojoule']
This page took 0.065826 seconds and 5 git commands to generate.