def test_assert_eq_with_deferrables(self): self.assertTrue(assert_eq(1, make_deferrable(1))) self.assertTrue(assert_eq(make_deferrable(1), True)) self.assertRaisesRegex(SanityError, '1 != 2', evaluate, assert_eq(make_deferrable(1), 2)) self.assertRaisesRegex(SanityError, '1 != False', evaluate, assert_eq(make_deferrable(1), False))
def test_assert_ne_with_deferrables(self): self.assertTrue(assert_ne(1, make_deferrable(2))) self.assertTrue(assert_ne(make_deferrable(1), False)) self.assertRaisesRegex(SanityError, '1 == 1', evaluate, assert_ne(make_deferrable(1), 1)) self.assertRaisesRegex(SanityError, '1 == True', evaluate, assert_ne(make_deferrable(1), True))
def test_getitem_with_deferrables(self): l = make_deferrable([1, 2, 3]) d = make_deferrable({'a': 1, 'b': 2, 'c': 3}) self.assertEqual(2, getitem(l, 1)) self.assertEqual(2, getitem(d, 'b')) self.assertRaisesRegex(SanityError, 'index out of bounds: 10', evaluate, getitem(l, 10)) self.assertRaisesRegex(SanityError, 'key not found: k', evaluate, getitem(d, 'k'))
def test_min(self): l = [1, 2] dl = make_deferrable(l) self.assertEqual(1, min(dl)) l.append(0) self.assertEqual(0, min(dl))
def test_assert_found(self): tempfile = self._write_tempfile() self.assertTrue(assert_found('Step: \d+', tempfile)) self.assertTrue(assert_found('Step: \d+', make_deferrable(tempfile))) self.assertRaises(SanityError, evaluate, assert_found('foo: \d+', tempfile)) os.remove(tempfile)
def test_chain(self): list1 = ['A', 'B', 'C'] list2 = ['D', 'E', 'F'] chain1 = evaluate(chain(make_deferrable(list1), list2)) chain2 = itertools.chain(list1, list2) self.assertTrue( builtins.all((a == b for a, b in builtins.zip(chain1, chain2))))
def test_max(self): l = [1, 2] dl = make_deferrable(l) self.assertEqual(2, sn.max(dl)) l.append(3) self.assertEqual(3, sn.max(dl))
def test_len(self): l = [1, 2] dl = make_deferrable(l) self.assertEqual(2, len(dl)) l.append(3) self.assertEqual(3, len(dl))
def __init__(self): self.valid_systems = ['*'] self.valid_prog_environs = ['*'] self.sourcesdir = None self.executable = 'echo' self._count = int(type(self).__name__[1:]) self.sanity_patterns = make_deferrable(True) self.keep_files = ['out.txt']
def test_filter(self): df = filter(lambda x: x if x % 2 else None, make_deferrable([1, 2, 3, 4, 5])) for i, x in enumerate(df, start=1): self.assertEqual(2 * i - 1, x) # Alternative testing self.assertEqual([1, 3, 5], list(evaluate(df)))
def test_divmod(self): a = make_deferrable(3) q, r = divmod(a, 2) self.assertEqual(1, q) self.assertEqual(1, r) # Test rdivmod here q, r = divmod(2, a) self.assertEqual(0, q) self.assertEqual(2, r)
def test_zip(self): la = [1, 2, 3] lb = make_deferrable(['a', 'b', 'c']) la_new = [] lb_new = [] for a, b in zip(la, lb): la_new.append(a) lb_new.append(b) self.assertEqual([1, 2, 3], la_new) self.assertEqual(['a', 'b', 'c'], lb_new)
def test_assert_false_with_deferrables(self): self.assertTrue(assert_false(make_deferrable(False))) self.assertTrue(assert_false(make_deferrable(0))) self.assertTrue(assert_false(make_deferrable([]))) self.assertRaisesRegex(SanityError, 'True is not False', evaluate, assert_false(make_deferrable(True))) self.assertRaisesRegex(SanityError, '1 is not False', evaluate, assert_false(make_deferrable(1))) self.assertRaisesRegex(SanityError, '\[1\] is not False', evaluate, assert_false(make_deferrable([1])))
def test_assert_true_with_deferrables(self): self.assertTrue(sn.assert_true(make_deferrable(True))) self.assertTrue(sn.assert_true(make_deferrable(1))) self.assertTrue(sn.assert_true(make_deferrable([1]))) self.assertRaisesRegex(SanityError, 'False is not True', evaluate, sn.assert_true(make_deferrable(False))) self.assertRaisesRegex(SanityError, '0 is not True', evaluate, sn.assert_true(make_deferrable(0))) self.assertRaisesRegex(SanityError, '\[\] is not True', evaluate, sn.assert_true(make_deferrable([])))
def test_count_uniq(self): # Use a custom generator for testing def my_mod_range(n, mod=2): for i in range(n): yield i % mod self.assertEqual(4, sn.count_uniq([1, 2, 3, 4, 4, 3, 2, 1])) self.assertEqual(1, sn.count_uniq((1, 1, 1))) self.assertEqual(3, sn.count_uniq({1, 2, 3, 2, 3})) self.assertEqual(3, sn.count_uniq({'a': 1, 'b': 2, 'c': 3})) self.assertEqual(2, sn.count_uniq(my_mod_range(10))) self.assertEqual(3, sn.count_uniq(my_mod_range(10, 3))) # Test empty sequences self.assertEqual(0, sn.count_uniq([])) self.assertEqual(0, sn.count_uniq({})) self.assertEqual(0, sn.count_uniq(set())) self.assertEqual(0, sn.count_uniq(my_mod_range(0))) self.assertEqual(0, sn.count_uniq(range(0))) # Test deferred expressions d = [1, 2, 2, 1] self.assertEqual(2, sn.count_uniq(make_deferrable(d)))
def test_iglob(self): filepatt = os.path.join(TEST_RESOURCES, '*.py') self.assertTrue(count(iglob(filepatt))) self.assertTrue(count(iglob(make_deferrable(filepatt))))
def test_make_deferrable(self): from reframe.core.deferrable import _DeferredExpression a = make_deferrable(3) self.assertIsInstance(a, _DeferredExpression)
def test_list_getitem(self): l = [1, 2] expr = make_deferrable(l)[1] == 3 l[1] = 3 self.assertTrue(expr)
def test_assert_not_in_with_deferrables(self): self.assertTrue(assert_not_in(0, make_deferrable([1, 2, 3]))) self.assertRaisesRegex(SanityError, '1 is in \[1, 2, 3\]', evaluate, assert_not_in(1, make_deferrable([1, 2, 3])))
def test_abs(self): self.assertEqual(1.0, abs(1.0)) self.assertEqual(0.0, abs(0.0)) self.assertEqual(1.0, abs(-1.0)) self.assertEqual(2.0, abs(make_deferrable(-2.0)))
def test_assert_ge_with_deferrables(self): self.assertTrue(sn.assert_ge(3, make_deferrable(1))) self.assertTrue(sn.assert_ge(3, make_deferrable(3))) self.assertRaisesRegex(SanityError, '1 < 3', evaluate, sn.assert_ge(1, make_deferrable(3)))
def test_ixor(self): v = V(7) dv = make_deferrable(v) dv ^= V(7) evaluate(dv) self.assertEqual(0, v._value)
def test_iand(self): v = V(7) dv = make_deferrable(v) dv &= V(2) evaluate(dv) self.assertEqual(2, v._value)
def test_round(self): self.assertEqual(1.0, round(make_deferrable(1.4)))
def test_glob(self): filepatt = os.path.join(TEST_RESOURCES_CHECKS, '*.py') self.assertTrue(sn.glob(filepatt)) self.assertTrue(sn.glob(make_deferrable(filepatt)))
def test_ior(self): v = V(2) dv = make_deferrable(v) dv |= V(5) evaluate(dv) self.assertEqual(7, v._value)
def test_enumerate(self): de = enumerate(make_deferrable([1, 2]), start=1) for i, e in de: self.assertEqual(i, e)
def test_list_contains(self): l = [1, 2] self.assertIn(2, make_deferrable(l))
def test_sum(self): self.assertEqual(3, sum([1, 1, 1])) self.assertEqual(3, sum(make_deferrable([1, 1, 1])))
def test_assert_le_with_deferrables(self): self.assertTrue(assert_le(1, make_deferrable(3))) self.assertTrue(assert_le(3, make_deferrable(3))) self.assertRaisesRegex(SanityError, '3 > 1', evaluate, assert_le(3, make_deferrable(1)))