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)))
