2 # Copyright (C) 2019 EfficiOS Inc.
4 # This program is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU General Public License
6 # as published by the Free Software Foundation; only version 2
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 # GNU General Public License for more details.
14 # You should have received a copy of the GNU General Public License
15 # along with this program; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 from functools
import partial
, partialmethod
28 class _TestCopySimple
:
30 with self
.assertRaises(NotImplementedError):
33 def test_deepcopy(self
):
34 with self
.assertRaises(NotImplementedError):
35 copy
.deepcopy(self
._def
)
44 class _TestNumericValue(_TestCopySimple
):
45 def _binop(self
, op
, rhs
):
51 r
= op(self
._def
, rhs
)
52 except Exception as e
:
56 rv
= op(self
._def
_value
, comp_value
)
57 except Exception as e
:
60 if rexc
is not None or rvexc
is not None:
61 # at least one of the operations raised an exception: in
62 # this case both operations should have raised the same
63 # type of exception (division by zero, bit shift with a
64 # floating point number operand, etc.)
65 self
.assertIs(type(rexc
), type(rvexc
))
70 def _unaryop(self
, op
):
76 except Exception as e
:
80 rv
= op(self
._def
_value
)
81 except Exception as e
:
84 if rexc
is not None or rvexc
is not None:
85 # at least one of the operations raised an exception: in
86 # this case both operations should have raised the same
87 # type of exception (division by zero, bit shift with a
88 # floating point number operand, etc.)
89 self
.assertIs(type(rexc
), type(rvexc
))
94 def _test_unaryop_type(self
, op
):
95 r
, rv
= self
._unaryop
(op
)
100 self
.assertIsInstance(r
, type(rv
))
102 def _test_unaryop_value(self
, op
):
103 r
, rv
= self
._unaryop
(op
)
108 self
.assertEqual(r
, rv
)
110 def _test_unaryop_addr_same(self
, op
):
111 addr_before
= self
._def
.addr
113 self
.assertEqual(self
._def
.addr
, addr_before
)
115 def _test_unaryop_value_same(self
, op
):
116 value_before
= self
._def
.__class
__(self
._def
)
118 self
.assertEqual(self
._def
, value_before
)
120 def _test_binop_type(self
, op
, rhs
):
121 r
, rv
= self
._binop
(op
, rhs
)
126 if op
in _COMP_BINOPS
:
127 # __eq__() and __ne__() always return a 'bool' object
128 self
.assertIsInstance(r
, bool)
130 self
.assertIsInstance(r
, type(rv
))
132 def _test_binop_value(self
, op
, rhs
):
133 r
, rv
= self
._binop
(op
, rhs
)
138 self
.assertEqual(r
, rv
)
140 def _test_binop_lhs_addr_same(self
, op
, rhs
):
141 addr_before
= self
._def
.addr
142 r
, rv
= self
._binop
(op
, rhs
)
143 self
.assertEqual(self
._def
.addr
, addr_before
)
145 def _test_binop_lhs_value_same(self
, op
, rhs
):
146 value_before
= self
._def
.__class
__(self
._def
)
147 r
, rv
= self
._binop
(op
, rhs
)
148 self
.assertEqual(self
._def
, value_before
)
150 def _test_binop_invalid_unknown(self
, op
):
151 if op
in _COMP_BINOPS
:
152 self
.skipTest('not testing')
157 with self
.assertRaises(TypeError):
160 def _test_binop_invalid_none(self
, op
):
161 if op
in _COMP_BINOPS
:
162 self
.skipTest('not testing')
164 with self
.assertRaises(TypeError):
167 def _test_ibinop_value(self
, op
, rhs
):
168 r
, rv
= self
._binop
(op
, rhs
)
173 # The inplace operators are special for value objects because
174 # they do not return a new, immutable object like it's the case
175 # for Python numbers. In Python, `a += 2`, where `a` is a number
176 # object, assigns a new number object reference to `a`, dropping
177 # the old reference. Since BT's value objects are mutable, we
178 # modify their internal value with the inplace operators. This
179 # means however that we can lose data in the process, for
182 # int_value_obj += 3.3
184 # Here, if `int_value_obj` is a Python `int` with the value 2,
185 # it would be a `float` object after this, holding the value
186 # 5.3. In our case, if `int_value_obj` is an integer value
187 # object, 3.3 is converted to an `int` object (3) and added to
188 # the current value of `int_value_obj`, so after this the value
189 # of the object is 5. This does not compare to 5.3, which is
190 # why we also use the `int()` type here.
191 if isinstance(self
._def
, bt2
._IntegerValue
):
194 self
.assertEqual(r
, rv
)
196 def _test_ibinop_type(self
, op
, rhs
):
197 r
, rv
= self
._binop
(op
, rhs
)
202 self
.assertIs(r
, self
._def
)
204 def _test_ibinop_invalid_unknown(self
, op
):
208 with self
.assertRaises(TypeError):
211 def _test_ibinop_invalid_none(self
, op
):
212 with self
.assertRaises(TypeError):
215 def _test_binop_rhs_false(self
, test_cb
, op
):
218 def _test_binop_rhs_true(self
, test_cb
, op
):
221 def _test_binop_rhs_pos_int(self
, test_cb
, op
):
224 def _test_binop_rhs_neg_int(self
, test_cb
, op
):
227 def _test_binop_rhs_zero_int(self
, test_cb
, op
):
230 def _test_binop_rhs_pos_vint(self
, test_cb
, op
):
231 test_cb(op
, bt2
.create_value(2))
233 def _test_binop_rhs_neg_vint(self
, test_cb
, op
):
234 test_cb(op
, bt2
.create_value(-23))
236 def _test_binop_rhs_zero_vint(self
, test_cb
, op
):
237 test_cb(op
, bt2
.create_value(0))
239 def _test_binop_rhs_pos_float(self
, test_cb
, op
):
242 def _test_binop_rhs_neg_float(self
, test_cb
, op
):
245 def _test_binop_rhs_zero_float(self
, test_cb
, op
):
248 def _test_binop_rhs_pos_vfloat(self
, test_cb
, op
):
249 test_cb(op
, bt2
.create_value(2.2))
251 def _test_binop_rhs_neg_vfloat(self
, test_cb
, op
):
252 test_cb(op
, bt2
.create_value(-23.4))
254 def _test_binop_rhs_zero_vfloat(self
, test_cb
, op
):
255 test_cb(op
, bt2
.create_value(0.0))
257 def _test_binop_type_false(self
, op
):
258 self
._test
_binop
_rhs
_false
(self
._test
_binop
_type
, op
)
260 def _test_binop_type_true(self
, op
):
261 self
._test
_binop
_rhs
_true
(self
._test
_binop
_type
, op
)
263 def _test_binop_type_pos_int(self
, op
):
264 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_type
, op
)
266 def _test_binop_type_neg_int(self
, op
):
267 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_type
, op
)
269 def _test_binop_type_zero_int(self
, op
):
270 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_type
, op
)
272 def _test_binop_type_pos_vint(self
, op
):
273 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_type
, op
)
275 def _test_binop_type_neg_vint(self
, op
):
276 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_type
, op
)
278 def _test_binop_type_zero_vint(self
, op
):
279 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_type
, op
)
281 def _test_binop_type_pos_float(self
, op
):
282 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_type
, op
)
284 def _test_binop_type_neg_float(self
, op
):
285 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_type
, op
)
287 def _test_binop_type_zero_float(self
, op
):
288 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_type
, op
)
290 def _test_binop_type_pos_vfloat(self
, op
):
291 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_type
, op
)
293 def _test_binop_type_neg_vfloat(self
, op
):
294 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_type
, op
)
296 def _test_binop_type_zero_vfloat(self
, op
):
297 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_type
, op
)
299 def _test_binop_value_false(self
, op
):
300 self
._test
_binop
_rhs
_false
(self
._test
_binop
_value
, op
)
302 def _test_binop_value_true(self
, op
):
303 self
._test
_binop
_rhs
_true
(self
._test
_binop
_value
, op
)
305 def _test_binop_value_pos_int(self
, op
):
306 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_value
, op
)
308 def _test_binop_value_neg_int(self
, op
):
309 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_value
, op
)
311 def _test_binop_value_zero_int(self
, op
):
312 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_value
, op
)
314 def _test_binop_value_pos_vint(self
, op
):
315 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_value
, op
)
317 def _test_binop_value_neg_vint(self
, op
):
318 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_value
, op
)
320 def _test_binop_value_zero_vint(self
, op
):
321 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_value
, op
)
323 def _test_binop_value_pos_float(self
, op
):
324 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_value
, op
)
326 def _test_binop_value_neg_float(self
, op
):
327 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_value
, op
)
329 def _test_binop_value_zero_float(self
, op
):
330 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_value
, op
)
332 def _test_binop_value_pos_vfloat(self
, op
):
333 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_value
, op
)
335 def _test_binop_value_neg_vfloat(self
, op
):
336 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_value
, op
)
338 def _test_binop_value_zero_vfloat(self
, op
):
339 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_value
, op
)
341 def _test_binop_lhs_addr_same_false(self
, op
):
342 self
._test
_binop
_rhs
_false
(self
._test
_binop
_lhs
_addr
_same
, op
)
344 def _test_binop_lhs_addr_same_true(self
, op
):
345 self
._test
_binop
_rhs
_true
(self
._test
_binop
_lhs
_addr
_same
, op
)
347 def _test_binop_lhs_addr_same_pos_int(self
, op
):
348 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_lhs
_addr
_same
, op
)
350 def _test_binop_lhs_addr_same_neg_int(self
, op
):
351 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_lhs
_addr
_same
, op
)
353 def _test_binop_lhs_addr_same_zero_int(self
, op
):
354 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_lhs
_addr
_same
, op
)
356 def _test_binop_lhs_addr_same_pos_vint(self
, op
):
357 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_lhs
_addr
_same
, op
)
359 def _test_binop_lhs_addr_same_neg_vint(self
, op
):
360 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_lhs
_addr
_same
, op
)
362 def _test_binop_lhs_addr_same_zero_vint(self
, op
):
363 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_lhs
_addr
_same
, op
)
365 def _test_binop_lhs_addr_same_pos_float(self
, op
):
366 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_lhs
_addr
_same
, op
)
368 def _test_binop_lhs_addr_same_neg_float(self
, op
):
369 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_lhs
_addr
_same
, op
)
371 def _test_binop_lhs_addr_same_zero_float(self
, op
):
372 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_lhs
_addr
_same
, op
)
374 def _test_binop_lhs_addr_same_pos_vfloat(self
, op
):
375 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_lhs
_addr
_same
, op
)
377 def _test_binop_lhs_addr_same_neg_vfloat(self
, op
):
378 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_lhs
_addr
_same
, op
)
380 def _test_binop_lhs_addr_same_zero_vfloat(self
, op
):
381 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_lhs
_addr
_same
, op
)
383 def _test_binop_lhs_value_same_false(self
, op
):
384 self
._test
_binop
_rhs
_false
(self
._test
_binop
_lhs
_value
_same
, op
)
386 def _test_binop_lhs_value_same_true(self
, op
):
387 self
._test
_binop
_rhs
_true
(self
._test
_binop
_lhs
_value
_same
, op
)
389 def _test_binop_lhs_value_same_pos_int(self
, op
):
390 self
._test
_binop
_rhs
_pos
_int
(self
._test
_binop
_lhs
_value
_same
, op
)
392 def _test_binop_lhs_value_same_neg_int(self
, op
):
393 self
._test
_binop
_rhs
_neg
_int
(self
._test
_binop
_lhs
_value
_same
, op
)
395 def _test_binop_lhs_value_same_zero_int(self
, op
):
396 self
._test
_binop
_rhs
_zero
_int
(self
._test
_binop
_lhs
_value
_same
, op
)
398 def _test_binop_lhs_value_same_pos_vint(self
, op
):
399 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_binop
_lhs
_value
_same
, op
)
401 def _test_binop_lhs_value_same_neg_vint(self
, op
):
402 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_binop
_lhs
_value
_same
, op
)
404 def _test_binop_lhs_value_same_zero_vint(self
, op
):
405 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_binop
_lhs
_value
_same
, op
)
407 def _test_binop_lhs_value_same_pos_float(self
, op
):
408 self
._test
_binop
_rhs
_pos
_float
(self
._test
_binop
_lhs
_value
_same
, op
)
410 def _test_binop_lhs_value_same_neg_float(self
, op
):
411 self
._test
_binop
_rhs
_neg
_float
(self
._test
_binop
_lhs
_value
_same
, op
)
413 def _test_binop_lhs_value_same_zero_float(self
, op
):
414 self
._test
_binop
_rhs
_zero
_float
(self
._test
_binop
_lhs
_value
_same
, op
)
416 def _test_binop_lhs_value_same_pos_vfloat(self
, op
):
417 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_binop
_lhs
_value
_same
, op
)
419 def _test_binop_lhs_value_same_neg_vfloat(self
, op
):
420 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_binop
_lhs
_value
_same
, op
)
422 def _test_binop_lhs_value_same_zero_vfloat(self
, op
):
423 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_binop
_lhs
_value
_same
, op
)
425 def _test_ibinop_type_false(self
, op
):
426 self
._test
_binop
_rhs
_false
(self
._test
_ibinop
_type
, op
)
428 def _test_ibinop_type_true(self
, op
):
429 self
._test
_binop
_rhs
_true
(self
._test
_ibinop
_type
, op
)
431 def _test_ibinop_type_pos_int(self
, op
):
432 self
._test
_binop
_rhs
_pos
_int
(self
._test
_ibinop
_type
, op
)
434 def _test_ibinop_type_neg_int(self
, op
):
435 self
._test
_binop
_rhs
_neg
_int
(self
._test
_ibinop
_type
, op
)
437 def _test_ibinop_type_zero_int(self
, op
):
438 self
._test
_binop
_rhs
_zero
_int
(self
._test
_ibinop
_type
, op
)
440 def _test_ibinop_type_pos_vint(self
, op
):
441 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_ibinop
_type
, op
)
443 def _test_ibinop_type_neg_vint(self
, op
):
444 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_ibinop
_type
, op
)
446 def _test_ibinop_type_zero_vint(self
, op
):
447 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_ibinop
_type
, op
)
449 def _test_ibinop_type_pos_float(self
, op
):
450 self
._test
_binop
_rhs
_pos
_float
(self
._test
_ibinop
_type
, op
)
452 def _test_ibinop_type_neg_float(self
, op
):
453 self
._test
_binop
_rhs
_neg
_float
(self
._test
_ibinop
_type
, op
)
455 def _test_ibinop_type_zero_float(self
, op
):
456 self
._test
_binop
_rhs
_zero
_float
(self
._test
_ibinop
_type
, op
)
458 def _test_ibinop_type_pos_vfloat(self
, op
):
459 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_ibinop
_type
, op
)
461 def _test_ibinop_type_neg_vfloat(self
, op
):
462 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_ibinop
_type
, op
)
464 def _test_ibinop_type_zero_vfloat(self
, op
):
465 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_ibinop
_type
, op
)
467 def _test_ibinop_value_false(self
, op
):
468 self
._test
_binop
_rhs
_false
(self
._test
_ibinop
_value
, op
)
470 def _test_ibinop_value_true(self
, op
):
471 self
._test
_binop
_rhs
_true
(self
._test
_ibinop
_value
, op
)
473 def _test_ibinop_value_pos_int(self
, op
):
474 self
._test
_binop
_rhs
_pos
_int
(self
._test
_ibinop
_value
, op
)
476 def _test_ibinop_value_neg_int(self
, op
):
477 self
._test
_binop
_rhs
_neg
_int
(self
._test
_ibinop
_value
, op
)
479 def _test_ibinop_value_zero_int(self
, op
):
480 self
._test
_binop
_rhs
_zero
_int
(self
._test
_ibinop
_value
, op
)
482 def _test_ibinop_value_pos_vint(self
, op
):
483 self
._test
_binop
_rhs
_pos
_vint
(self
._test
_ibinop
_value
, op
)
485 def _test_ibinop_value_neg_vint(self
, op
):
486 self
._test
_binop
_rhs
_neg
_vint
(self
._test
_ibinop
_value
, op
)
488 def _test_ibinop_value_zero_vint(self
, op
):
489 self
._test
_binop
_rhs
_zero
_vint
(self
._test
_ibinop
_value
, op
)
491 def _test_ibinop_value_pos_float(self
, op
):
492 self
._test
_binop
_rhs
_pos
_float
(self
._test
_ibinop
_value
, op
)
494 def _test_ibinop_value_neg_float(self
, op
):
495 self
._test
_binop
_rhs
_neg
_float
(self
._test
_ibinop
_value
, op
)
497 def _test_ibinop_value_zero_float(self
, op
):
498 self
._test
_binop
_rhs
_zero
_float
(self
._test
_ibinop
_value
, op
)
500 def _test_ibinop_value_pos_vfloat(self
, op
):
501 self
._test
_binop
_rhs
_pos
_vfloat
(self
._test
_ibinop
_value
, op
)
503 def _test_ibinop_value_neg_vfloat(self
, op
):
504 self
._test
_binop
_rhs
_neg
_vfloat
(self
._test
_ibinop
_value
, op
)
506 def _test_ibinop_value_zero_vfloat(self
, op
):
507 self
._test
_binop
_rhs
_zero
_vfloat
(self
._test
_ibinop
_value
, op
)
509 def test_bool_op(self
):
510 self
.assertEqual(bool(self
._def
), bool(self
._def
_value
))
512 def test_int_op(self
):
513 self
.assertEqual(int(self
._def
), int(self
._def
_value
))
515 def test_float_op(self
):
516 self
.assertEqual(float(self
._def
), float(self
._def
_value
))
518 def test_complex_op(self
):
519 self
.assertEqual(complex(self
._def
), complex(self
._def
_value
))
521 def test_str_op(self
):
522 self
.assertEqual(str(self
._def
), str(self
._def
_value
))
524 def test_eq_none(self
):
525 self
.assertFalse(self
._def
== None)
527 def test_ne_none(self
):
528 self
.assertTrue(self
._def
!= None)
538 ('add', operator
.add
),
539 ('radd', lambda a
, b
: operator
.add(b
, a
)),
540 ('and', operator
.and_
),
541 ('rand', lambda a
, b
: operator
.and_(b
, a
)),
542 ('floordiv', operator
.floordiv
),
543 ('rfloordiv', lambda a
, b
: operator
.floordiv(b
, a
)),
544 ('lshift', operator
.lshift
),
545 ('rlshift', lambda a
, b
: operator
.lshift(b
, a
)),
546 ('mod', operator
.mod
),
547 ('rmod', lambda a
, b
: operator
.mod(b
, a
)),
548 ('mul', operator
.mul
),
549 ('rmul', lambda a
, b
: operator
.mul(b
, a
)),
550 ('or', operator
.or_
),
551 ('ror', lambda a
, b
: operator
.or_(b
, a
)),
552 ('pow', operator
.pow),
553 ('rpow', lambda a
, b
: operator
.pow(b
, a
)),
554 ('rshift', operator
.rshift
),
555 ('rrshift', lambda a
, b
: operator
.rshift(b
, a
)),
556 ('sub', operator
.sub
),
557 ('rsub', lambda a
, b
: operator
.sub(b
, a
)),
558 ('truediv', operator
.truediv
),
559 ('rtruediv', lambda a
, b
: operator
.truediv(b
, a
)),
560 ('xor', operator
.xor
),
561 ('rxor', lambda a
, b
: operator
.xor(b
, a
)),
566 ('iadd', operator
.iadd
),
567 ('iand', operator
.iand
),
568 ('ifloordiv', operator
.ifloordiv
),
569 ('ilshift', operator
.ilshift
),
570 ('imod', operator
.imod
),
571 ('imul', operator
.imul
),
572 ('ior', operator
.ior
),
573 ('ipow', operator
.ipow
),
574 ('irshift', operator
.irshift
),
575 ('isub', operator
.isub
),
576 ('itruediv', operator
.itruediv
),
577 ('ixor', operator
.ixor
),
582 ('neg', operator
.neg
),
583 ('pos', operator
.pos
),
584 ('abs', operator
.abs),
585 ('invert', operator
.invert
),
587 ('round_0', partial(round, ndigits
=0)),
588 ('round_1', partial(round, ndigits
=1)),
589 ('round_2', partial(round, ndigits
=2)),
590 ('round_3', partial(round, ndigits
=3)),
592 ('floor', math
.floor
),
593 ('trunc', math
.trunc
),
597 def _inject_numeric_testing_methods(cls
, has_neg
=True):
598 def test_binop_name(suffix
):
599 return 'test_binop_{}_{}'.format(name
, suffix
)
601 def test_ibinop_name(suffix
):
602 return 'test_ibinop_{}_{}'.format(name
, suffix
)
604 def test_unaryop_name(suffix
):
605 return 'test_unaryop_{}_{}'.format(name
, suffix
)
607 # inject testing methods for each binary operation
608 for name
, binop
in _BINOPS
:
609 setattr(cls
, test_binop_name('invalid_unknown'), partialmethod(_TestNumericValue
._test
_binop
_invalid
_unknown
, op
=binop
))
610 setattr(cls
, test_binop_name('invalid_none'), partialmethod(_TestNumericValue
._test
_binop
_invalid
_none
, op
=binop
))
611 setattr(cls
, test_binop_name('type_true'), partialmethod(_TestNumericValue
._test
_binop
_type
_true
, op
=binop
))
612 setattr(cls
, test_binop_name('type_pos_int'), partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_int
, op
=binop
))
613 setattr(cls
, test_binop_name('type_pos_vint'), partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_vint
, op
=binop
))
614 setattr(cls
, test_binop_name('value_true'), partialmethod(_TestNumericValue
._test
_binop
_value
_true
, op
=binop
))
615 setattr(cls
, test_binop_name('value_pos_int'), partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_int
, op
=binop
))
616 setattr(cls
, test_binop_name('value_pos_vint'), partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_vint
, op
=binop
))
617 setattr(cls
, test_binop_name('lhs_addr_same_true'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_true
, op
=binop
))
618 setattr(cls
, test_binop_name('lhs_addr_same_pos_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_int
, op
=binop
))
619 setattr(cls
, test_binop_name('lhs_addr_same_pos_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_vint
, op
=binop
))
620 setattr(cls
, test_binop_name('lhs_value_same_true'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_true
, op
=binop
))
621 setattr(cls
, test_binop_name('lhs_value_same_pos_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_int
, op
=binop
))
622 setattr(cls
, test_binop_name('lhs_value_same_pos_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_vint
, op
=binop
))
625 setattr(cls
, test_binop_name('type_neg_int'), partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_int
, op
=binop
))
626 setattr(cls
, test_binop_name('type_neg_vint'), partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_vint
, op
=binop
))
627 setattr(cls
, test_binop_name('value_neg_int'), partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_int
, op
=binop
))
628 setattr(cls
, test_binop_name('value_neg_vint'), partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_vint
, op
=binop
))
629 setattr(cls
, test_binop_name('lhs_addr_same_neg_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_int
, op
=binop
))
630 setattr(cls
, test_binop_name('lhs_addr_same_neg_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_vint
, op
=binop
))
631 setattr(cls
, test_binop_name('lhs_value_same_neg_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_int
, op
=binop
))
632 setattr(cls
, test_binop_name('lhs_value_same_neg_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_vint
, op
=binop
))
634 setattr(cls
, test_binop_name('type_false'), partialmethod(_TestNumericValue
._test
_binop
_type
_false
, op
=binop
))
635 setattr(cls
, test_binop_name('type_zero_int'), partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_int
, op
=binop
))
636 setattr(cls
, test_binop_name('type_zero_vint'), partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_vint
, op
=binop
))
637 setattr(cls
, test_binop_name('value_false'), partialmethod(_TestNumericValue
._test
_binop
_value
_false
, op
=binop
))
638 setattr(cls
, test_binop_name('value_zero_int'), partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_int
, op
=binop
))
639 setattr(cls
, test_binop_name('value_zero_vint'), partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_vint
, op
=binop
))
640 setattr(cls
, test_binop_name('lhs_addr_same_false'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_false
, op
=binop
))
641 setattr(cls
, test_binop_name('lhs_addr_same_zero_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_int
, op
=binop
))
642 setattr(cls
, test_binop_name('lhs_addr_same_zero_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_vint
, op
=binop
))
643 setattr(cls
, test_binop_name('lhs_value_same_false'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_false
, op
=binop
))
644 setattr(cls
, test_binop_name('lhs_value_same_zero_int'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_int
, op
=binop
))
645 setattr(cls
, test_binop_name('lhs_value_same_zero_vint'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_vint
, op
=binop
))
648 setattr(cls
, test_binop_name('type_neg_float'), partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_float
, op
=binop
))
649 setattr(cls
, test_binop_name('type_neg_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_type
_neg
_vfloat
, op
=binop
))
650 setattr(cls
, test_binop_name('value_neg_float'), partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_float
, op
=binop
))
651 setattr(cls
, test_binop_name('value_neg_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_value
_neg
_vfloat
, op
=binop
))
652 setattr(cls
, test_binop_name('lhs_addr_same_neg_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_float
, op
=binop
))
653 setattr(cls
, test_binop_name('lhs_addr_same_neg_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_neg
_vfloat
, op
=binop
))
654 setattr(cls
, test_binop_name('lhs_value_same_neg_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_float
, op
=binop
))
655 setattr(cls
, test_binop_name('lhs_value_same_neg_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_neg
_vfloat
, op
=binop
))
657 setattr(cls
, test_binop_name('type_pos_float'), partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_float
, op
=binop
))
658 setattr(cls
, test_binop_name('type_pos_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_type
_pos
_vfloat
, op
=binop
))
659 setattr(cls
, test_binop_name('value_pos_float'), partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_float
, op
=binop
))
660 setattr(cls
, test_binop_name('value_pos_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_value
_pos
_vfloat
, op
=binop
))
661 setattr(cls
, test_binop_name('lhs_addr_same_pos_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_float
, op
=binop
))
662 setattr(cls
, test_binop_name('lhs_addr_same_pos_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_pos
_vfloat
, op
=binop
))
663 setattr(cls
, test_binop_name('lhs_value_same_pos_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_float
, op
=binop
))
664 setattr(cls
, test_binop_name('lhs_value_same_pos_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_pos
_vfloat
, op
=binop
))
665 setattr(cls
, test_binop_name('type_zero_float'), partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_float
, op
=binop
))
666 setattr(cls
, test_binop_name('type_zero_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_type
_zero
_vfloat
, op
=binop
))
667 setattr(cls
, test_binop_name('value_zero_float'), partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_float
, op
=binop
))
668 setattr(cls
, test_binop_name('value_zero_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_value
_zero
_vfloat
, op
=binop
))
669 setattr(cls
, test_binop_name('lhs_addr_same_zero_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_float
, op
=binop
))
670 setattr(cls
, test_binop_name('lhs_addr_same_zero_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_addr
_same
_zero
_vfloat
, op
=binop
))
671 setattr(cls
, test_binop_name('lhs_value_same_zero_float'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_float
, op
=binop
))
672 setattr(cls
, test_binop_name('lhs_value_same_zero_vfloat'), partialmethod(_TestNumericValue
._test
_binop
_lhs
_value
_same
_zero
_vfloat
, op
=binop
))
674 # inject testing methods for each unary operation
675 for name
, unaryop
in _UNARYOPS
:
676 setattr(cls
, test_unaryop_name('type'), partialmethod(_TestNumericValue
._test
_unaryop
_type
, op
=unaryop
))
677 setattr(cls
, test_unaryop_name('value'), partialmethod(_TestNumericValue
._test
_unaryop
_value
, op
=unaryop
))
678 setattr(cls
, test_unaryop_name('addr_same'), partialmethod(_TestNumericValue
._test
_unaryop
_addr
_same
, op
=unaryop
))
679 setattr(cls
, test_unaryop_name('value_same'), partialmethod(_TestNumericValue
._test
_unaryop
_value
_same
, op
=unaryop
))
681 # inject testing methods for each inplace binary operation
682 for name
, ibinop
in _IBINOPS
:
683 setattr(cls
, test_ibinop_name('invalid_unknown'), partialmethod(_TestNumericValue
._test
_ibinop
_invalid
_unknown
, op
=ibinop
))
684 setattr(cls
, test_ibinop_name('invalid_none'), partialmethod(_TestNumericValue
._test
_ibinop
_invalid
_none
, op
=ibinop
))
685 setattr(cls
, test_ibinop_name('type_true'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_true
, op
=ibinop
))
686 setattr(cls
, test_ibinop_name('value_true'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_true
, op
=ibinop
))
687 setattr(cls
, test_ibinop_name('type_pos_int'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_pos
_int
, op
=ibinop
))
688 setattr(cls
, test_ibinop_name('type_pos_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_pos
_vint
, op
=ibinop
))
689 setattr(cls
, test_ibinop_name('value_pos_int'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_pos
_int
, op
=ibinop
))
690 setattr(cls
, test_ibinop_name('value_pos_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_pos
_vint
, op
=ibinop
))
693 setattr(cls
, test_ibinop_name('type_neg_int'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_neg
_int
, op
=ibinop
))
694 setattr(cls
, test_ibinop_name('type_neg_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_neg
_vint
, op
=ibinop
))
695 setattr(cls
, test_ibinop_name('value_neg_int'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_neg
_int
, op
=ibinop
))
696 setattr(cls
, test_ibinop_name('value_neg_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_neg
_vint
, op
=ibinop
))
698 setattr(cls
, test_ibinop_name('type_false'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_false
, op
=ibinop
))
699 setattr(cls
, test_ibinop_name('value_false'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_false
, op
=ibinop
))
700 setattr(cls
, test_ibinop_name('type_zero_int'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_zero
_int
, op
=ibinop
))
701 setattr(cls
, test_ibinop_name('type_zero_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_zero
_vint
, op
=ibinop
))
702 setattr(cls
, test_ibinop_name('value_zero_int'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_zero
_int
, op
=ibinop
))
703 setattr(cls
, test_ibinop_name('value_zero_vint'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_zero
_vint
, op
=ibinop
))
704 setattr(cls
, test_ibinop_name('type_pos_float'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_pos
_float
, op
=ibinop
))
707 setattr(cls
, test_ibinop_name('type_neg_float'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_neg
_float
, op
=ibinop
))
708 setattr(cls
, test_ibinop_name('type_neg_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_neg
_vfloat
, op
=ibinop
))
709 setattr(cls
, test_ibinop_name('value_neg_float'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_neg
_float
, op
=ibinop
))
710 setattr(cls
, test_ibinop_name('value_neg_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_neg
_vfloat
, op
=ibinop
))
712 setattr(cls
, test_ibinop_name('type_pos_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_pos
_vfloat
, op
=ibinop
))
713 setattr(cls
, test_ibinop_name('value_pos_float'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_pos
_float
, op
=ibinop
))
714 setattr(cls
, test_ibinop_name('value_pos_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_pos
_vfloat
, op
=ibinop
))
715 setattr(cls
, test_ibinop_name('type_zero_float'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_zero
_float
, op
=ibinop
))
716 setattr(cls
, test_ibinop_name('type_zero_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_type
_zero
_vfloat
, op
=ibinop
))
717 setattr(cls
, test_ibinop_name('value_zero_float'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_zero
_float
, op
=ibinop
))
718 setattr(cls
, test_ibinop_name('value_zero_vfloat'), partialmethod(_TestNumericValue
._test
_ibinop
_value
_zero
_vfloat
, op
=ibinop
))
721 class CreateValueFuncTestCase(unittest
.TestCase
):
722 def test_create_none(self
):
723 v
= bt2
.create_value(None)
726 def test_create_bool_false(self
):
727 v
= bt2
.create_value(False)
728 self
.assertIsInstance(v
, bt2
.BoolValue
)
731 def test_create_bool_true(self
):
732 v
= bt2
.create_value(True)
733 self
.assertIsInstance(v
, bt2
.BoolValue
)
736 def test_create_int_pos(self
):
738 v
= bt2
.create_value(raw
)
739 self
.assertIsInstance(v
, bt2
.SignedIntegerValue
)
740 self
.assertEqual(v
, raw
)
742 def test_create_int_neg(self
):
744 v
= bt2
.create_value(raw
)
745 self
.assertIsInstance(v
, bt2
.SignedIntegerValue
)
746 self
.assertEqual(v
, raw
)
748 def test_create_float_pos(self
):
750 v
= bt2
.create_value(raw
)
751 self
.assertIsInstance(v
, bt2
.RealValue
)
752 self
.assertEqual(v
, raw
)
754 def test_create_float_neg(self
):
756 v
= bt2
.create_value(raw
)
757 self
.assertIsInstance(v
, bt2
.RealValue
)
758 self
.assertEqual(v
, raw
)
760 def test_create_string(self
):
762 v
= bt2
.create_value(raw
)
763 self
.assertIsInstance(v
, bt2
.StringValue
)
764 self
.assertEqual(v
, raw
)
766 def test_create_string_empty(self
):
768 v
= bt2
.create_value(raw
)
769 self
.assertIsInstance(v
, bt2
.StringValue
)
770 self
.assertEqual(v
, raw
)
772 def test_create_array_from_list(self
):
774 v
= bt2
.create_value(raw
)
775 self
.assertIsInstance(v
, bt2
.ArrayValue
)
776 self
.assertEqual(v
, raw
)
778 def test_create_array_from_tuple(self
):
780 v
= bt2
.create_value(raw
)
781 self
.assertIsInstance(v
, bt2
.ArrayValue
)
782 self
.assertEqual(v
, raw
)
784 def test_create_array_from_empty_list(self
):
786 v
= bt2
.create_value(raw
)
787 self
.assertIsInstance(v
, bt2
.ArrayValue
)
788 self
.assertEqual(v
, raw
)
790 def test_create_array_from_empty_tuple(self
):
792 v
= bt2
.create_value(raw
)
793 self
.assertIsInstance(v
, bt2
.ArrayValue
)
794 self
.assertEqual(v
, raw
)
796 def test_create_map(self
):
798 v
= bt2
.create_value(raw
)
799 self
.assertIsInstance(v
, bt2
.MapValue
)
800 self
.assertEqual(v
, raw
)
802 def test_create_map_empty(self
):
804 v
= bt2
.create_value(raw
)
805 self
.assertIsInstance(v
, bt2
.MapValue
)
806 self
.assertEqual(v
, raw
)
808 def test_create_vfalse(self
):
809 v
= bt2
.create_value(bt2
.create_value(False))
810 self
.assertIsInstance(v
, bt2
.BoolValue
)
813 def test_create_invalid(self
):
819 with self
.assertRaisesRegex(TypeError, "cannot create value object from 'A' object") as cm
:
820 v
= bt2
.create_value(a
)
823 class BoolValueTestCase(_TestCopySimple
, unittest
.TestCase
):
825 self
._f
= bt2
.BoolValue(False)
826 self
._t
= bt2
.BoolValue(True)
828 self
._def
_value
= False
829 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
)
846 def test_create_true(self
):
847 self
.assertTrue(self
._t
)
849 def test_create_from_vfalse(self
):
850 b
= bt2
.BoolValue(self
._f
)
853 def test_create_from_vtrue(self
):
854 b
= bt2
.BoolValue(self
._t
)
857 def test_create_from_int_non_zero(self
):
858 with self
.assertRaises(TypeError):
859 b
= bt2
.BoolValue(23)
861 def test_create_from_int_zero(self
):
862 with self
.assertRaises(TypeError):
865 def test_assign_true(self
):
870 def test_assign_false(self
):
875 def test_assign_vtrue(self
):
880 def test_assign_vfalse(self
):
885 def test_assign_int(self
):
886 with self
.assertRaises(TypeError):
890 def test_bool_op(self
):
891 self
.assertEqual(bool(self
._def
), bool(self
._def
_value
))
893 def test_str_op(self
):
894 self
.assertEqual(str(self
._def
), str(self
._def
_value
))
896 def test_eq_none(self
):
897 self
.assertFalse(self
._def
== None)
899 def test_ne_none(self
):
900 self
.assertTrue(self
._def
!= None)
902 def test_vfalse_eq_false(self
):
903 self
.assertEqual(self
._f
, False)
905 def test_vfalse_ne_true(self
):
906 self
.assertNotEqual(self
._f
, True)
908 def test_vtrue_eq_true(self
):
909 self
.assertEqual(self
._t
, True)
911 def test_vtrue_ne_false(self
):
912 self
.assertNotEqual(self
._t
, False)
915 class _TestIntegerValue(_TestNumericValue
):
918 self
._ip
= self
._CLS
(self
._pv
)
920 self
._def
_value
= self
._pv
921 self
._def
_new
_value
= 101
928 def _assert_expecting_int(self
):
929 return self
.assertRaisesRegex(TypeError, r
'expecting a number object')
931 def _assert_expecting_int64(self
):
932 return self
.assertRaisesRegex(ValueError, r
"expecting a signed 64-bit integral value")
934 def _assert_expecting_uint64(self
):
935 return self
.assertRaisesRegex(ValueError, r
"expecting an unsigned 64-bit integral value")
937 def test_create_default(self
):
939 self
.assertEqual(i
, 0)
941 def test_create_pos(self
):
942 self
.assertEqual(self
._ip
, self
._pv
)
944 def test_create_neg(self
):
945 self
.assertEqual(self
._in
, self
._nv
)
947 def test_create_from_vint(self
):
948 i
= self
._CLS
(self
._ip
)
949 self
.assertEqual(i
, self
._pv
)
951 def test_create_from_false(self
):
955 def test_create_from_true(self
):
959 def test_create_from_float(self
):
961 self
.assertEqual(i
, 99)
963 def test_create_from_vfloat(self
):
964 f
= bt2
.create_value(17.5)
966 self
.assertEqual(i
, 17)
968 def test_create_from_unknown(self
):
972 with self
._assert
_expecting
_int
():
975 def test_create_from_varray(self
):
976 with self
._assert
_expecting
_int
():
977 i
= self
._CLS
(bt2
.ArrayValue())
979 def test_assign_true(self
):
981 self
._def
.value
= raw
982 self
.assertEqual(self
._def
, raw
)
984 def test_assign_false(self
):
986 self
._def
.value
= raw
987 self
.assertEqual(self
._def
, raw
)
989 def test_assign_pos_int(self
):
991 self
._def
.value
= raw
992 self
.assertEqual(self
._def
, raw
)
994 def test_assign_vint(self
):
996 self
._def
.value
= bt2
.create_value(raw
)
997 self
.assertEqual(self
._def
, raw
)
999 def test_assign_vfloat(self
):
1001 self
._def
.value
= bt2
.create_value(raw
)
1002 self
.assertEqual(self
._def
, int(raw
))
1005 class SignedIntegerValueTestCase(_TestIntegerValue
, unittest
.TestCase
):
1006 _CLS
= bt2
.SignedIntegerValue
1011 self
._in
= self
._CLS
(self
._nv
)
1012 self
._def
_new
_value
= -101
1018 def test_create_neg(self
):
1019 self
.assertEqual(self
._in
, self
._nv
)
1021 def test_create_pos_too_big(self
):
1022 with self
._assert
_expecting
_int
64():
1023 i
= self
._CLS
(2 ** 63)
1025 def test_create_neg_too_big(self
):
1026 with self
._assert
_expecting
_int
64():
1027 i
= self
._CLS
(-(2 ** 63) - 1)
1029 def test_assign_neg_int(self
):
1031 self
._def
.value
= raw
1032 self
.assertEqual(self
._def
, raw
)
1034 def test_compare_big_int(self
):
1035 # Larger than the IEEE 754 double-precision exact representation of
1038 v
= bt2
.create_value(raw
)
1039 self
.assertEqual(v
, raw
)
1042 _inject_numeric_testing_methods(SignedIntegerValueTestCase
)
1045 class UnsignedIntegerValueTestCase(_TestIntegerValue
, unittest
.TestCase
):
1046 _CLS
= bt2
.UnsignedIntegerValue
1048 def test_create_pos_too_big(self
):
1049 with self
._assert
_expecting
_uint
64():
1050 i
= self
._CLS
(2 ** 64)
1052 def test_create_neg(self
):
1053 with self
._assert
_expecting
_uint
64():
1057 _inject_numeric_testing_methods(UnsignedIntegerValueTestCase
, False)
1060 class RealValueTestCase(_TestNumericValue
, unittest
.TestCase
):
1064 self
._fp
= bt2
.RealValue(self
._pv
)
1065 self
._fn
= bt2
.RealValue(self
._nv
)
1066 self
._def
= self
._fp
1067 self
._def
_value
= self
._pv
1068 self
._def
_new
_value
= -101.88
1076 def _assert_expecting_float(self
):
1077 return self
.assertRaisesRegex(TypeError, r
"expecting a real number object")
1079 def _test_invalid_op(self
, cb
):
1080 with self
.assertRaises(TypeError):
1083 def test_create_default(self
):
1085 self
.assertEqual(f
, 0.0)
1087 def test_create_pos(self
):
1088 self
.assertEqual(self
._fp
, self
._pv
)
1090 def test_create_neg(self
):
1091 self
.assertEqual(self
._fn
, self
._nv
)
1093 def test_create_from_vint(self
):
1094 f
= bt2
.RealValue(self
._fp
)
1095 self
.assertEqual(f
, self
._pv
)
1097 def test_create_from_false(self
):
1098 f
= bt2
.RealValue(False)
1101 def test_create_from_true(self
):
1102 f
= bt2
.RealValue(True)
1105 def test_create_from_int(self
):
1107 f
= bt2
.RealValue(raw
)
1108 self
.assertEqual(f
, float(raw
))
1110 def test_create_from_vint(self
):
1112 f
= bt2
.RealValue(bt2
.create_value(raw
))
1113 self
.assertEqual(f
, float(raw
))
1115 def test_create_from_vfloat(self
):
1117 f
= bt2
.RealValue(bt2
.create_value(raw
))
1118 self
.assertEqual(f
, raw
)
1120 def test_create_from_unknown(self
):
1124 with self
._assert
_expecting
_float
():
1125 f
= bt2
.RealValue(A())
1127 def test_create_from_varray(self
):
1128 with self
._assert
_expecting
_float
():
1129 f
= bt2
.RealValue(bt2
.ArrayValue())
1131 def test_assign_true(self
):
1132 self
._def
.value
= True
1133 self
.assertTrue(self
._def
)
1135 def test_assign_false(self
):
1136 self
._def
.value
= False
1137 self
.assertFalse(self
._def
)
1139 def test_assign_pos_int(self
):
1141 self
._def
.value
= raw
1142 self
.assertEqual(self
._def
, float(raw
))
1144 def test_assign_neg_int(self
):
1146 self
._def
.value
= raw
1147 self
.assertEqual(self
._def
, float(raw
))
1149 def test_assign_vint(self
):
1151 self
._def
.value
= bt2
.create_value(raw
)
1152 self
.assertEqual(self
._def
, float(raw
))
1154 def test_assign_float(self
):
1156 self
._def
.value
= raw
1157 self
.assertEqual(self
._def
, raw
)
1159 def test_assign_vfloat(self
):
1161 self
._def
.value
= bt2
.create_value(raw
)
1162 self
.assertEqual(self
._def
, raw
)
1164 def test_invalid_lshift(self
):
1165 self
._test
_invalid
_op
(lambda: self
._def
<< 23)
1167 def test_invalid_rshift(self
):
1168 self
._test
_invalid
_op
(lambda: self
._def
>> 23)
1170 def test_invalid_and(self
):
1171 self
._test
_invalid
_op
(lambda: self
._def
& 23)
1173 def test_invalid_or(self
):
1174 self
._test
_invalid
_op
(lambda: self
._def |
23)
1176 def test_invalid_xor(self
):
1177 self
._test
_invalid
_op
(lambda: self
._def ^
23)
1179 def test_invalid_invert(self
):
1180 self
._test
_invalid
_op
(lambda: ~self
._def
)
1183 _inject_numeric_testing_methods(RealValueTestCase
)
1186 class StringValueTestCase(_TestCopySimple
, unittest
.TestCase
):
1188 self
._def
_value
= 'Hello, World!'
1189 self
._def
= bt2
.StringValue(self
._def
_value
)
1190 self
._def
_new
_value
= 'Yes!'
1195 def _assert_expecting_str(self
):
1196 return self
.assertRaises(TypeError)
1198 def test_create_default(self
):
1199 s
= bt2
.StringValue()
1200 self
.assertEqual(s
, '')
1202 def test_create_from_str(self
):
1204 s
= bt2
.StringValue(raw
)
1205 self
.assertEqual(s
, raw
)
1207 def test_create_from_vstr(self
):
1209 s
= bt2
.StringValue(bt2
.create_value(raw
))
1210 self
.assertEqual(s
, raw
)
1212 def test_create_from_unknown(self
):
1216 with self
._assert
_expecting
_str
():
1217 i
= bt2
.StringValue(A())
1219 def test_create_from_varray(self
):
1220 with self
._assert
_expecting
_str
():
1221 i
= bt2
.StringValue(bt2
.ArrayValue())
1223 def test_assign_int(self
):
1224 with self
._assert
_expecting
_str
():
1225 self
._def
.value
= 283
1227 def test_assign_str(self
):
1230 self
.assertEqual(self
._def
, raw
)
1232 def test_assign_vstr(self
):
1234 self
._def
= bt2
.create_value(raw
)
1235 self
.assertEqual(self
._def
, raw
)
1238 self
.assertEqual(self
._def
, self
._def
_value
)
1241 self
.assertNotEqual(self
._def
, 23)
1243 def test_lt_vstring(self
):
1244 s1
= bt2
.StringValue('allo')
1245 s2
= bt2
.StringValue('bateau')
1246 self
.assertLess(s1
, s2
)
1248 def test_lt_string(self
):
1249 s1
= bt2
.StringValue('allo')
1250 self
.assertLess(s1
, 'bateau')
1252 def test_le_vstring(self
):
1253 s1
= bt2
.StringValue('allo')
1254 s2
= bt2
.StringValue('bateau')
1255 self
.assertLessEqual(s1
, s2
)
1257 def test_le_string(self
):
1258 s1
= bt2
.StringValue('allo')
1259 self
.assertLessEqual(s1
, 'bateau')
1261 def test_gt_vstring(self
):
1262 s1
= bt2
.StringValue('allo')
1263 s2
= bt2
.StringValue('bateau')
1264 self
.assertGreater(s2
, s1
)
1266 def test_gt_string(self
):
1267 s1
= bt2
.StringValue('allo')
1268 self
.assertGreater('bateau', s1
)
1270 def test_ge_vstring(self
):
1271 s1
= bt2
.StringValue('allo')
1272 s2
= bt2
.StringValue('bateau')
1273 self
.assertGreaterEqual(s2
, s1
)
1275 def test_ge_string(self
):
1276 s1
= bt2
.StringValue('allo')
1277 self
.assertGreaterEqual('bateau', s1
)
1279 def test_bool_op(self
):
1280 self
.assertEqual(bool(self
._def
), bool(self
._def
_value
))
1282 def test_str_op(self
):
1283 self
.assertEqual(str(self
._def
), str(self
._def
_value
))
1286 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1288 def test_getitem(self
):
1289 self
.assertEqual(self
._def
[5], self
._def
_value
[5])
1291 def test_append_str(self
):
1292 to_append
= 'meow meow meow'
1293 self
._def
+= to_append
1294 self
._def
_value
+= to_append
1295 self
.assertEqual(self
._def
, self
._def
_value
)
1297 def test_append_vstr(self
):
1298 to_append
= 'meow meow meow'
1299 self
._def
+= bt2
.create_value(to_append
)
1300 self
._def
_value
+= to_append
1301 self
.assertEqual(self
._def
, self
._def
_value
)
1304 class ArrayValueTestCase(_TestCopySimple
, unittest
.TestCase
):
1306 self
._def
_value
= [None, False, True, -23, 0, 42, -42.4, 23.17, 'yes']
1307 self
._def
= bt2
.ArrayValue(copy
.deepcopy(self
._def
_value
))
1312 def _modify_def(self
):
1313 self
._def
[2] = 'xyz'
1315 def _assert_type_error(self
):
1316 return self
.assertRaises(TypeError)
1318 def test_create_default(self
):
1319 a
= bt2
.ArrayValue()
1320 self
.assertEqual(len(a
), 0)
1322 def test_create_from_array(self
):
1323 self
.assertEqual(self
._def
, self
._def
_value
)
1325 def test_create_from_tuple(self
):
1326 t
= 1, 2, False, None
1327 a
= bt2
.ArrayValue(t
)
1328 self
.assertEqual(a
, t
)
1330 def test_create_from_varray(self
):
1331 va
= bt2
.ArrayValue(copy
.deepcopy(self
._def
_value
))
1332 a
= bt2
.ArrayValue(va
)
1333 self
.assertEqual(va
, a
)
1335 def test_create_from_unknown(self
):
1339 with self
._assert
_type
_error
():
1340 a
= bt2
.ArrayValue(A())
1342 def test_bool_op_true(self
):
1343 self
.assertTrue(bool(self
._def
))
1345 def test_bool_op_false(self
):
1346 self
.assertFalse(bool(bt2
.ArrayValue()))
1349 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1351 def test_eq_int(self
):
1352 self
.assertNotEqual(self
._def
, 23)
1354 def test_eq_diff_len(self
):
1355 a1
= bt2
.create_value([1, 2, 3])
1356 a2
= bt2
.create_value([1, 2])
1357 self
.assertNotEqual(a1
, a2
)
1359 def test_eq_diff_content_same_len(self
):
1360 a1
= bt2
.create_value([1, 2, 3])
1361 a2
= bt2
.create_value([4, 5, 6])
1362 self
.assertNotEqual(a1
, a2
)
1364 def test_eq_same_content_same_len(self
):
1365 raw
= (3, True, [1, 2.5, None, {'a': 17.6, 'b': None}])
1366 a1
= bt2
.ArrayValue(raw
)
1367 a2
= bt2
.ArrayValue(copy
.deepcopy(raw
))
1368 self
.assertEqual(a1
, a2
)
1370 def test_setitem_int(self
):
1373 self
.assertEqual(self
._def
[2], raw
)
1375 def test_setitem_vint(self
):
1377 self
._def
[2] = bt2
.create_value(raw
)
1378 self
.assertEqual(self
._def
[2], raw
)
1380 def test_setitem_none(self
):
1382 self
.assertIsNone(self
._def
[2])
1384 def test_setitem_index_wrong_type(self
):
1385 with self
._assert
_type
_error
():
1386 self
._def
['yes'] = 23
1388 def test_setitem_index_neg(self
):
1389 with self
.assertRaises(IndexError):
1392 def test_setitem_index_out_of_range(self
):
1393 with self
.assertRaises(IndexError):
1394 self
._def
[len(self
._def
)] = 23
1396 def test_append_none(self
):
1397 self
._def
.append(None)
1398 self
.assertIsNone(self
._def
[len(self
._def
) - 1])
1400 def test_append_int(self
):
1402 self
._def
.append(raw
)
1403 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
)
1405 def test_append_vint(self
):
1407 self
._def
.append(bt2
.create_value(raw
))
1408 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
)
1410 def test_append_unknown(self
):
1414 with self
._assert
_type
_error
():
1415 self
._def
.append(A())
1417 def test_iadd(self
):
1420 self
.assertEqual(self
._def
[len(self
._def
) - 3], raw
[0])
1421 self
.assertEqual(self
._def
[len(self
._def
) - 2], raw
[1])
1422 self
.assertEqual(self
._def
[len(self
._def
) - 1], raw
[2])
1424 def test_iadd_unknown(self
):
1428 with self
._assert
_type
_error
():
1431 def test_iadd_list_unknown(self
):
1435 with self
._assert
_type
_error
():
1438 def test_iter(self
):
1439 for velem
, elem
in zip(self
._def
, self
._def
_value
):
1440 self
.assertEqual(velem
, elem
)
1443 class MapValueTestCase(_TestCopySimple
, unittest
.TestCase
):
1456 self
._def
= bt2
.MapValue(copy
.deepcopy(self
._def
_value
))
1461 def _modify_def(self
):
1462 self
._def
['zero'] = 1
1464 def test_create_default(self
):
1466 self
.assertEqual(len(m
), 0)
1468 def test_create_from_dict(self
):
1469 self
.assertEqual(self
._def
, self
._def
_value
)
1471 def test_create_from_vmap(self
):
1472 vm
= bt2
.MapValue(copy
.deepcopy(self
._def
_value
))
1473 m
= bt2
.MapValue(vm
)
1474 self
.assertEqual(vm
, m
)
1476 def test_create_from_unknown(self
):
1480 with self
.assertRaises(AttributeError):
1481 m
= bt2
.MapValue(A())
1483 def test_bool_op_true(self
):
1484 self
.assertTrue(bool(self
._def
))
1486 def test_bool_op_false(self
):
1487 self
.assertFalse(bool(bt2
.MapValue()))
1490 self
.assertEqual(len(self
._def
), len(self
._def
_value
))
1492 def test_eq_int(self
):
1493 self
.assertNotEqual(self
._def
, 23)
1495 def test_eq_diff_len(self
):
1496 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1497 a2
= bt2
.create_value({'a': 1, 'b': 2})
1498 self
.assertNotEqual(a1
, a2
)
1500 def test_eq_diff_content_same_len(self
):
1501 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1502 a2
= bt2
.create_value({'a': 4, 'b': 2, 'c': 3})
1503 self
.assertNotEqual(a1
, a2
)
1505 def test_eq_same_content_diff_keys(self
):
1506 a1
= bt2
.create_value({'a': 1, 'b': 2, 'c': 3})
1507 a2
= bt2
.create_value({'a': 1, 'k': 2, 'c': 3})
1508 self
.assertNotEqual(a1
, a2
)
1510 def test_eq_same_content_same_len(self
):
1514 'array': [1, 2.5, None, {'a': 17.6, 'b': None}]
1516 a1
= bt2
.MapValue(raw
)
1517 a2
= bt2
.MapValue(copy
.deepcopy(raw
))
1518 self
.assertEqual(a1
, a2
)
1519 self
.assertEqual(a1
, raw
)
1521 def test_setitem_int(self
):
1523 self
._def
['pos-int'] = raw
1524 self
.assertEqual(self
._def
['pos-int'], raw
)
1526 def test_setitem_vint(self
):
1528 self
._def
['pos-int'] = bt2
.create_value(raw
)
1529 self
.assertEqual(self
._def
['pos-int'], raw
)
1531 def test_setitem_none(self
):
1532 self
._def
['none'] = None
1533 self
.assertIsNone(self
._def
['none'])
1535 def test_setitem_new_int(self
):
1536 old_len
= len(self
._def
)
1537 self
._def
['new-int'] = 23
1538 self
.assertEqual(self
._def
['new-int'], 23)
1539 self
.assertEqual(len(self
._def
), old_len
+ 1)
1541 def test_setitem_index_wrong_type(self
):
1542 with self
.assertRaises(TypeError):
1545 def test_iter(self
):
1546 for vkey
, vval
in self
._def
.items():
1547 val
= self
._def
_value
[vkey
]
1548 self
.assertEqual(vval
, val
)
1550 def test_getitem_wrong_key(self
):
1551 with self
.assertRaises(KeyError):
1552 self
._def
['kilojoule']