def test_def_check(self):
self.assertNotIn('foo', self.env)
self.runExpr([KW('def?'), KW('foo')], False)
self.env['foo'] = 1
self.runExpr([KW('def?'), KW('foo')], True)
self.runExprFail([KW('def?'), 'foo'], TypeError)
def test_cat(self):
self.runExpr([
KW('cat'),
[KW('list'), 'foo'],
[KW('tuple'), 'bar'],
[KW('dict'), 'foo', 'bar'],
], ['foo', 'bar', ('foo', 'bar')])
def test_def(self):
self.assertNotIn('foo', self.env)
self.runExpr([KW('def'), KW('foo'), 1])
self.assertEqual(self.env['foo'], 1)
self.runExprFail([KW('def')], TypeError)
self.runExprFail([KW('def'), 'foo', 1], AssertionError)
def test_def_match_dict(self):
self.assertNotIn('foo', self.env)
self.runExpr([
KW('def'),
[KW('dict'), True, KW('foo')],
[KW('dict'), True, 1],
])
self.assertEqual(self.env['foo'], 1)
def setUp(self):
self.env = Env()
self.identity = RunCountedFunc(
[KW('list'), KW('x')],
KW('x'),
self.env,
'id',
)
def test_quote(self):
self.runExpr([KW('quote'), [1, 2, 3]], [1, 2, 3])
self.runExprFail([KW('quote')], TypeError)
self.runExpr(
[KW('quote'), [1, 2, [KW('unquote'), [KW('+'), 1, 2]]]],
[1, 2, 3],
)
def test_undef(self):
self.env['foo'] = 1
self.runExpr([KW('undef'), KW('foo')])
self.assertNotIn('foo', self.env)
self.assertIn('list', self.env)
self.runExpr([KW('undef'), KW('list')])
self.assertNotIn('list', self.env)
self.runExprFail([KW('undef'), 'foo'], TypeError)
def test_def_match_into_set(self):
self.runExpr([
KW('def'),
[
KW('into_set'),
[KW('set'), "foo"],
KW('other'),
],
[KW('set'), "foo", "bar", "baz"],
])
self.assertEqual(self.env['other'], {"bar", "baz"})
def test_def_match_into_tuple(self):
self.runExpr([
KW('def'),
[
KW('into_tuple'),
[KW('tuple'), 1, 2, 3],
KW('foo'),
],
[KW('tuple'), 1, 2, 3, 4, 5],
])
self.assertEqual(self.env['foo'], (4, 5))
def test_def_match_into_list(self):
self.runExpr([
KW('def'),
[
KW('into_list'),
[KW('list'), 1, 2, 3],
KW('foo'),
],
[KW('list'), 1, 2, 3, 4, 5],
])
self.assertEqual(self.env['foo'], [4, 5])
def test_serialize_spread(self):
self.assertEqual(
serialize([
KW('into_list'),
[KW('list'), 1, 2, 3],
KW('foo'),
[KW('list'), 4, 5],
KW('bar'),
]),
'[1 2 3 &foo 4 5 &bar]',
)
def test_into_set(self):
self.runExpr(
[
KW('into_set'),
[KW('quote'), [1, 2, 3]],
[KW('quote'), (4, 5, 6)],
[KW('quote'), {
'foo': 'bar'
}],
[KW('quote'), {'baz'}],
],
{1, 2, 3, 4, 5, 6, ('foo', 'bar'), 'baz'},
)
def test_into_tuple(self):
self.runExpr(
[
KW('into_tuple'),
[KW('quote'), [1, 2, 3]],
[KW('quote'), (4, 5, 6)],
[KW('quote'), {
'foo': 'bar'
}],
[KW('quote'), {'baz'}],
],
(1, 2, 3, 4, 5, 6, ('foo', 'bar'), 'baz'),
)
def test_exception(self):
with self.assertRaises(LangException) as cm:
run([KW('/'), 1, 0])
self.assertEqual(
str(cm.exception),
'ZeroDivisionError: division by zero',
)
def test_into_dict(self):
self.runExpr(
[
KW('into_dict'),
[KW('quote'), [(1, 2), (3, 4)]],
[KW('quote'), ((5, 6), )],
[KW('quote'), {
'foo': 'bar'
}],
],
{
1: 2,
3: 4,
5: 6,
'foo': 'bar'
},
)
def test_typechecks(self):
type_checks = {
'null?': lambda x: x is None,
'not_null?': lambda x: x is not None,
'int?': lambda x: isinstance(x, int),
'not_int?': lambda x: not isinstance(x, int),
'float?': lambda x: isinstance(x, float),
'not_float?': lambda x: not isinstance(x, float),
'bool?': lambda x: isinstance(x, bool),
'not_bool?': lambda x: not isinstance(x, bool),
'str?': lambda x: isinstance(x, str),
'not_str?': lambda x: not isinstance(x, str),
'list?': lambda x: isinstance(x, list),
'not_list?': lambda x: not isinstance(x, list),
'dict?': lambda x: isinstance(x, dict),
'not_dict?': lambda x: not isinstance(x, dict),
'tuple?': lambda x: isinstance(x, tuple),
'not_tuple?': lambda x: not isinstance(x, tuple),
'set?': lambda x: isinstance(x, set),
'not_set?': lambda x: not isinstance(x, set),
'kw?': lambda x: isinstance(x, KW),
'not_kw?': lambda x: not isinstance(x, KW),
'func?': lambda x: isinstance(x, Func),
'not_func?': lambda x: not isinstance(x, Func),
}
values = [
None,
KW('foo'),
'foo',
1,
1.5,
{
'foo': 1
},
['bar'],
('foo', 'bar'),
{'foo', 'bar', 'baz'},
Func([KW('foo')], KW('foo'), self.env),
]
for name, type_check in type_checks.items():
with self.subTest(name):
for value in values:
self.runExpr(
[KW(name), [KW('quote'), value]],
type_check(value),
)
def test_not(self):
self.runExpr([KW('not')], True)
self.runExpr([KW('not'), True, True], False)
self.runExpr([KW('not'), False, True], False)
self.runExpr([KW('not'), False, False], True)
self.runExpr([KW('not'), False, True, True, False], False)
self.assertIdCallCount(0)
self.runExpr([KW('not'), [KW('id'), True], [KW('id'), True]])
self.assertIdCallCount(1)
def test_geq(self):
self.runExpr([KW('>='), 1, 2], False)
self.runExpr([KW('>='), 2, 1], True)
self.runExpr([KW('>='), 1, 1], True)
self.runExpr([KW('>='), 1, 2, 1], False)
self.runExpr([KW('>='), 3, 2, 1], True)
self.assertIdCallCount(0)
self.runExpr([
KW('>='),
[KW('id'), 0],
[KW('id'), 1],
[KW('id'), 2],
])
self.assertIdCallCount(2)
self.runExprFail([KW('>=')], TypeError)
def test_neq(self):
self.runExpr([KW('!='), 1, 1], False)
self.runExpr([KW('!='), 1, 2], True)
self.runExpr([KW('!='), None, None], False)
self.runExpr([KW('!='), 1, 'foo'], True)
self.runExprFail([KW('!=')], TypeError)
self.assertIdCallCount(0)
self.runExpr([
KW('!='),
[KW('id'), 0],
[KW('id'), 0],
[KW('id'), 0],
])
self.assertIdCallCount(2)
def test_thread(self):
self.runExpr([
KW('->'),
10,
[KW('-'), 2],
[KW('*'), 3],
[KW('/'), 4],
], 6)
self.runExprFail([KW('->')], TypeError)
self.runExprFail([KW('->'), 'foo', 'bar'], TypeError)
def test_def_match_into_dict(self):
self.runExpr([
KW('def'),
[
KW('into_dict'),
[KW('dict'), "foo", KW('foo')],
KW('other'),
],
[KW('dict'), "foo", 1, "bar", 2, "baz", 3],
])
self.assertEqual(self.env['foo'], 1)
self.assertEqual(self.env['other'], {"bar": 2, "baz": 3})
def test_parse_spread(self):
self.assertEqual(
list(parse('[&foo 1 2 3 &bar 4 5 6 &baz]'))[0],
[
KW('into_list'),
KW('foo'),
[KW('list'), 1, 2, 3],
KW('bar'),
[KW('list'), 4, 5, 6],
KW('baz'),
],
)
def test_instance_wapper(self):
foo = Foo(value=5)
foo.save()
baz = Baz(foo=foo)
baz.save()
wrapped_baz = InstanceWrapper(baz)
self.assertEqual(wrapped_baz[KW('__class__')], 'Baz')
self.assertEqual(wrapped_baz[KW('id')], baz.id)
self.assertEqual(wrapped_baz[KW('file')], None)
with self.assertRaises(KeyError):
wrapped_baz[KW('foobar')]
wrapped_foo = wrapped_baz[KW('foo')]
self.assertEqual(wrapped_foo[KW('__class__')], 'Foo')
self.assertEqual(wrapped_foo[KW('value')], 5)
wrapped_bazs = wrapped_foo[KW('bazs')]
self.assertEqual(len(wrapped_bazs), 1)
self.assertEqual(
wrapped_bazs[0][KW('__class__')],
wrapped_baz[KW('__class__')],
)
self.assertEqual(
wrapped_bazs[0][KW('id')],
wrapped_baz[KW('id')],
)
def setUp(self):
self.counter = UserDefTally(db_name='counter')
self.counter.base = encode([
KW('defn'),
KW('transform'),
[KW('list'), KW('instance')],
[
KW('if'),
[
KW('and'),
[KW('not_null?'), KW('instance')],
[
KW('='),
[KW('instance'), [KW('quote'),
KW('__class__')]], 'Foo'
],
],
[KW('instance'), [KW('quote'), KW('value')]],
0,
],
])
self.counter.get_tally = encode(0)
self.counter.get_value = encode(KW('instance'))
self.counter.filter_value = encode(
[KW('>='), [KW('transform'), KW('value')], 3])
self.counter.handle_change = encode([
KW('->'),
KW('tally'),
[KW('-'), [KW('transform'), KW('old_value')]],
[KW('+'), [KW('transform'), KW('new_value')]],
])
self.counter.save()
def test_listen(self):
sub = listen(Foo)
# Initial value
self.assertStored('counter', 0)
# Create model
foo = Foo(value=5)
foo.save()
self.assertStored('counter', 5)
# Make values count twice
self.counter.base = encode([
KW('defn'),
KW('transform'),
[KW('list'), KW('instance')],
[
KW('if'),
[
KW('and'),
[KW('not_null?'), KW('instance')],
[
KW('='),
[KW('instance'), [KW('quote'),
KW('__class__')]], 'Foo'
],
],
[KW('*'), [KW('instance'), [KW('quote'),
KW('value')]], 2],
0,
],
])
self.counter.save()
# Update foo
foo.value = 6
foo.save()
# Note: tally does not know how it used to handle the value so we only
# get the difference in value *2 added to the tally.
self.assertStored('counter', 7)
# Delete foo
foo.delete()
self.assertStored('counter', -5)
sub.close()
def test_kw_eq(self):
self.assertEqual(KW('foo'), KW('foo'))
self.assertNotEqual(KW('foo'), KW('bar'))
self.assertNotEqual(KW('foo'), 'foo')
def test_kw_repr(self):
self.assertEqual(repr([KW('foo'), 'bar', 'baz']),
'[foo, \'bar\', \'baz\']')
def test_kw(self):
self.runExpr([KW('kw'), 'foo'], KW('foo'))
self.runExpr([KW('kw'), 'foo', 'bar'], KW('foobar'))
def test_for(self):
self.env['foo'] = 0
self.runExpr([
KW('for'),
[KW('tuple'), KW('_'), KW('n')],
[KW('dict'), 1, 1, 2, 2, 3, 3],
[KW('def'), KW('foo'), [KW('+'), KW('foo'),
KW('n')]],
[KW('def'), KW('foo'), [KW('+'), KW('foo'),
KW('n')]],
])
self.assertEqual(self.env['foo'], 12)
self.runExprFail([KW('for')], TypeError)
def test_run_log(self):
# Without log
with self.assertRaises(LangException):
run([KW('/'), 1, 0])
# With log
run([KW('/'), 1, 0], log=True)