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)