cmlenz@1: # -*- coding: utf-8 -*-
cmlenz@1: #
cmlenz@66: # Copyright (C) 2006 Edgewall Software
cmlenz@1: # All rights reserved.
cmlenz@1: #
cmlenz@1: # This software is licensed as described in the file COPYING, which
cmlenz@1: # you should have received as part of this distribution. The terms
cmlenz@66: # are also available at http://markup.edgewall.org/wiki/License.
cmlenz@1: #
cmlenz@1: # This software consists of voluntary contributions made by many
cmlenz@1: # individuals. For the exact contribution history, see the revision
cmlenz@66: # history and logs, available at hhttp://markup.edgewall.org/log/.
cmlenz@1: 
cmlenz@1: import doctest
cmlenz@131: import sys
cmlenz@1: import unittest
cmlenz@1: 
cmlenz@27: from markup.eval import Expression
cmlenz@1: 
cmlenz@30: 
cmlenz@30: class ExpressionTestCase(unittest.TestCase):
cmlenz@30: 
cmlenz@30:     def test_str_literal(self):
cmlenz@30:         self.assertEqual('foo', Expression('"foo"').evaluate({}))
cmlenz@30:         self.assertEqual('foo', Expression('"""foo"""').evaluate({}))
cmlenz@30:         self.assertEqual('foo', Expression("'foo'").evaluate({}))
cmlenz@30:         self.assertEqual('foo', Expression("'''foo'''").evaluate({}))
cmlenz@30:         self.assertEqual('foo', Expression("u'foo'").evaluate({}))
cmlenz@30:         self.assertEqual('foo', Expression("r'foo'").evaluate({}))
cmlenz@30: 
cmlenz@167:     def test_str_literal_non_ascii(self):
cmlenz@167:         expr = Expression(u"u'\xfe'")
cmlenz@167:         self.assertEqual(u'þ', expr.evaluate({}))
cmlenz@167:         expr = Expression("u'\xfe'")
cmlenz@167:         self.assertEqual(u'þ', expr.evaluate({}))
cmlenz@167: 
cmlenz@30:     def test_num_literal(self):
cmlenz@30:         self.assertEqual(42, Expression("42").evaluate({}))
cmlenz@30:         self.assertEqual(42L, Expression("42L").evaluate({}))
cmlenz@30:         self.assertEqual(.42, Expression(".42").evaluate({}))
cmlenz@30:         self.assertEqual(07, Expression("07").evaluate({}))
cmlenz@30:         self.assertEqual(0xF2, Expression("0xF2").evaluate({}))
cmlenz@30:         self.assertEqual(0XF2, Expression("0XF2").evaluate({}))
cmlenz@30: 
cmlenz@30:     def test_dict_literal(self):
cmlenz@30:         self.assertEqual({}, Expression("{}").evaluate({}))
cmlenz@30:         self.assertEqual({'key': True},
cmlenz@30:                          Expression("{'key': value}").evaluate({'value': True}))
cmlenz@30: 
cmlenz@30:     def test_list_literal(self):
cmlenz@30:         self.assertEqual([], Expression("[]").evaluate({}))
cmlenz@30:         self.assertEqual([1, 2, 3], Expression("[1, 2, 3]").evaluate({}))
cmlenz@30:         self.assertEqual([True],
cmlenz@30:                          Expression("[value]").evaluate({'value': True}))
cmlenz@30: 
cmlenz@30:     def test_tuple_literal(self):
cmlenz@30:         self.assertEqual((), Expression("()").evaluate({}))
cmlenz@30:         self.assertEqual((1, 2, 3), Expression("(1, 2, 3)").evaluate({}))
cmlenz@30:         self.assertEqual((True,),
cmlenz@30:                          Expression("(value,)").evaluate({'value': True}))
cmlenz@30: 
cmlenz@31:     def test_unaryop_pos(self):
cmlenz@31:         self.assertEqual(1, Expression("+1").evaluate({}))
cmlenz@31:         self.assertEqual(1, Expression("+x").evaluate({'x': 1}))
cmlenz@31: 
cmlenz@31:     def test_unaryop_neg(self):
cmlenz@31:         self.assertEqual(-1, Expression("-1").evaluate({}))
cmlenz@31:         self.assertEqual(-1, Expression("-x").evaluate({'x': 1}))
cmlenz@31: 
cmlenz@31:     def test_unaryop_not(self):
cmlenz@31:         self.assertEqual(False, Expression("not True").evaluate({}))
cmlenz@31:         self.assertEqual(False, Expression("not x").evaluate({'x': True}))
cmlenz@31: 
cmlenz@32:     def test_unaryop_inv(self):
cmlenz@32:         self.assertEqual(-2, Expression("~1").evaluate({}))
cmlenz@32:         self.assertEqual(-2, Expression("~x").evaluate({'x': 1}))
cmlenz@32: 
cmlenz@31:     def test_binop_add(self):
cmlenz@31:         self.assertEqual(3, Expression("2 + 1").evaluate({}))
cmlenz@31:         self.assertEqual(3, Expression("x + y").evaluate({'x': 2, 'y': 1}))
cmlenz@31: 
cmlenz@31:     def test_binop_sub(self):
cmlenz@31:         self.assertEqual(1, Expression("2 - 1").evaluate({}))
cmlenz@31:         self.assertEqual(1, Expression("x - y").evaluate({'x': 1, 'y': 1}))
cmlenz@31: 
cmlenz@31:     def test_binop_sub(self):
cmlenz@31:         self.assertEqual(1, Expression("2 - 1").evaluate({}))
cmlenz@31:         self.assertEqual(1, Expression("x - y").evaluate({'x': 2, 'y': 1}))
cmlenz@31: 
cmlenz@31:     def test_binop_mul(self):
cmlenz@31:         self.assertEqual(4, Expression("2 * 2").evaluate({}))
cmlenz@31:         self.assertEqual(4, Expression("x * y").evaluate({'x': 2, 'y': 2}))
cmlenz@31: 
cmlenz@31:     def test_binop_pow(self):
cmlenz@31:         self.assertEqual(4, Expression("2 ** 2").evaluate({}))
cmlenz@31:         self.assertEqual(4, Expression("x ** y").evaluate({'x': 2, 'y': 2}))
cmlenz@31: 
cmlenz@31:     def test_binop_div(self):
cmlenz@31:         self.assertEqual(2, Expression("4 / 2").evaluate({}))
cmlenz@31:         self.assertEqual(2, Expression("x / y").evaluate({'x': 4, 'y': 2}))
cmlenz@31: 
cmlenz@31:     def test_binop_floordiv(self):
cmlenz@31:         self.assertEqual(1, Expression("3 // 2").evaluate({}))
cmlenz@31:         self.assertEqual(1, Expression("x // y").evaluate({'x': 3, 'y': 2}))
cmlenz@31: 
cmlenz@31:     def test_binop_mod(self):
cmlenz@31:         self.assertEqual(1, Expression("3 % 2").evaluate({}))
cmlenz@31:         self.assertEqual(1, Expression("x % y").evaluate({'x': 3, 'y': 2}))
cmlenz@31: 
cmlenz@32:     def test_binop_and(self):
cmlenz@32:         self.assertEqual(0, Expression("1 & 0").evaluate({}))
cmlenz@32:         self.assertEqual(0, Expression("x & y").evaluate({'x': 1, 'y': 0}))
cmlenz@32: 
cmlenz@32:     def test_binop_or(self):
cmlenz@32:         self.assertEqual(1, Expression("1 | 0").evaluate({}))
cmlenz@32:         self.assertEqual(1, Expression("x | y").evaluate({'x': 1, 'y': 0}))
cmlenz@32: 
cmlenz@31:     def test_binop_contains(self):
cmlenz@31:         self.assertEqual(True, Expression("1 in (1, 2, 3)").evaluate({}))
cmlenz@31:         self.assertEqual(True, Expression("x in y").evaluate({'x': 1,
cmlenz@31:                                                               'y': (1, 2, 3)}))
cmlenz@31: 
cmlenz@31:     def test_binop_not_contains(self):
cmlenz@31:         self.assertEqual(True, Expression("4 not in (1, 2, 3)").evaluate({}))
cmlenz@31:         self.assertEqual(True, Expression("x not in y").evaluate({'x': 4,
cmlenz@31:                                                                   'y': (1, 2, 3)}))
cmlenz@31: 
cmlenz@32:     def test_binop_is(self):
cmlenz@32:         self.assertEqual(True, Expression("1 is 1").evaluate({}))
cmlenz@32:         self.assertEqual(True, Expression("x is y").evaluate({'x': 1, 'y': 1}))
cmlenz@32:         self.assertEqual(False, Expression("1 is 2").evaluate({}))
cmlenz@32:         self.assertEqual(False, Expression("x is y").evaluate({'x': 1, 'y': 2}))
cmlenz@32: 
cmlenz@32:     def test_binop_is_not(self):
cmlenz@32:         self.assertEqual(True, Expression("1 is not 2").evaluate({}))
cmlenz@32:         self.assertEqual(True, Expression("x is not y").evaluate({'x': 1,
cmlenz@32:                                                                   'y': 2}))
cmlenz@32:         self.assertEqual(False, Expression("1 is not 1").evaluate({}))
cmlenz@32:         self.assertEqual(False, Expression("x is not y").evaluate({'x': 1,
cmlenz@32:                                                                    'y': 1}))
cmlenz@32: 
cmlenz@31:     def test_boolop_and(self):
cmlenz@31:         self.assertEqual(False, Expression("True and False").evaluate({}))
cmlenz@31:         self.assertEqual(False, Expression("x and y").evaluate({'x': True,
cmlenz@31:                                                                 'y': False}))
cmlenz@31: 
cmlenz@31:     def test_boolop_or(self):
cmlenz@31:         self.assertEqual(True, Expression("True or False").evaluate({}))
cmlenz@31:         self.assertEqual(True, Expression("x or y").evaluate({'x': True,
cmlenz@31:                                                               'y': False}))
cmlenz@31: 
cmlenz@31:     def test_compare_eq(self):
cmlenz@31:         self.assertEqual(True, Expression("1 == 1").evaluate({}))
cmlenz@31:         self.assertEqual(True, Expression("x == y").evaluate({'x': 1, 'y': 1}))
cmlenz@31: 
cmlenz@31:     def test_compare_ne(self):
cmlenz@31:         self.assertEqual(False, Expression("1 != 1").evaluate({}))
cmlenz@31:         self.assertEqual(False, Expression("x != y").evaluate({'x': 1, 'y': 1}))
cmlenz@32:         self.assertEqual(False, Expression("1 <> 1").evaluate({}))
cmlenz@32:         self.assertEqual(False, Expression("x <> y").evaluate({'x': 1, 'y': 1}))
cmlenz@31: 
cmlenz@31:     def test_compare_lt(self):
cmlenz@31:         self.assertEqual(True, Expression("1 < 2").evaluate({}))
cmlenz@31:         self.assertEqual(True, Expression("x < y").evaluate({'x': 1, 'y': 2}))
cmlenz@31: 
cmlenz@31:     def test_compare_le(self):
cmlenz@31:         self.assertEqual(True, Expression("1 <= 1").evaluate({}))
cmlenz@31:         self.assertEqual(True, Expression("x <= y").evaluate({'x': 1, 'y': 1}))
cmlenz@31: 
cmlenz@31:     def test_compare_gt(self):
cmlenz@31:         self.assertEqual(True, Expression("2 > 1").evaluate({}))
cmlenz@31:         self.assertEqual(True, Expression("x > y").evaluate({'x': 2, 'y': 1}))
cmlenz@31: 
cmlenz@31:     def test_compare_ge(self):
cmlenz@31:         self.assertEqual(True, Expression("1 >= 1").evaluate({}))
cmlenz@31:         self.assertEqual(True, Expression("x >= y").evaluate({'x': 1, 'y': 1}))
cmlenz@31: 
cmlenz@31:     def test_compare_multi(self):
cmlenz@31:         self.assertEqual(True, Expression("1 != 3 == 3").evaluate({}))
cmlenz@81:         self.assertEqual(True, Expression("x != y == y").evaluate({'x': 1,
cmlenz@31:                                                                    'y': 3}))
cmlenz@31: 
cmlenz@87:     def test_call_function(self):
cmlenz@87:         self.assertEqual(42, Expression("foo()").evaluate({'foo': lambda: 42}))
cmlenz@87:         data = {'foo': 'bar'}
cmlenz@87:         self.assertEqual('BAR', Expression("foo.upper()").evaluate(data))
cmlenz@87:         data = {'foo': {'bar': range(42)}}
cmlenz@87:         self.assertEqual(42, Expression("len(foo.bar)").evaluate(data))
cmlenz@87: 
jonas@102:     def test_call_keywords(self):
jonas@102:         self.assertEqual(42, Expression("foo(x=bar)").evaluate({'foo': lambda x: x,
jonas@102:                                                                 'bar': 42}))
jonas@102: 
cmlenz@90:     def test_call_function_without_params(self):
cmlenz@90:         self.assertEqual(42, Expression("foo").evaluate({'foo': lambda: 42}))
cmlenz@90:         data = {'foo': 'bar'}
cmlenz@90:         self.assertEqual('BAR', Expression("foo.upper").evaluate(data))
cmlenz@90:         data = {'foo': {'bar': range(42)}}
cmlenz@90: 
cmlenz@118:     def test_lambda(self):
cmlenz@118:         # Define a custom `sorted` function cause the builtin isn't available
cmlenz@118:         # on Python 2.3
cmlenz@118:         def sorted(items, compfunc):
cmlenz@118:             items.sort(compfunc)
cmlenz@118:             return items
cmlenz@118:         data = {'items': [{'name': 'b', 'value': 0}, {'name': 'a', 'value': 1}],
cmlenz@118:                 'sorted': sorted}
cmlenz@118:         expr = Expression("sorted(items, lambda a, b: cmp(a.name, b.name))")
cmlenz@118:         self.assertEqual([{'name': 'a', 'value': 1}, {'name': 'b', 'value': 0}],
cmlenz@118:                          expr.evaluate(data))
cmlenz@118: 
cmlenz@88:     def test_list_comprehension(self):
cmlenz@88:         expr = Expression("[n for n in numbers if n < 2]")
cmlenz@88:         self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
cmlenz@88: 
cmlenz@88:         expr = Expression("[(i, n + 1) for i, n in enumerate(numbers)]")
cmlenz@88:         self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
cmlenz@88:                          expr.evaluate({'numbers': range(5)}))
cmlenz@88: 
cmlenz@88:         expr = Expression("[offset + n for n in numbers]")
cmlenz@88:         self.assertEqual([2, 3, 4, 5, 6],
cmlenz@88:                          expr.evaluate({'numbers': range(5), 'offset': 2}))
cmlenz@81: 
cmlenz@131:     def test_list_comprehension_with_getattr(self):
cmlenz@131:         items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
cmlenz@131:         expr = Expression("[i.name for i in items if i.value > 1]")
cmlenz@131:         self.assertEqual(['b'], expr.evaluate({'items': items}))
cmlenz@131: 
cmlenz@131:     def test_list_comprehension_with_getitem(self):
cmlenz@131:         items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
cmlenz@131:         expr = Expression("[i['name'] for i in items if i['value'] > 1]")
cmlenz@131:         self.assertEqual(['b'], expr.evaluate({'items': items}))
cmlenz@131: 
cmlenz@131:     def test_error_position(self):
cmlenz@131:         expr = Expression("nothing()", filename='index.html', lineno=50)
cmlenz@131:         try:
cmlenz@131:             expr.evaluate({})
cmlenz@131:             self.fail('Expected TypeError')
cmlenz@131:         except TypeError, e:
cmlenz@131:             exc_type, exc_value, exc_traceback = sys.exc_info()
cmlenz@131:             frame = exc_traceback.tb_next
cmlenz@131:             while frame.tb_next:
cmlenz@131:                 frame = frame.tb_next
cmlenz@134:             self.assertEqual('<Expression "nothing()">',
cmlenz@134:                              frame.tb_frame.f_code.co_name)
cmlenz@131:             self.assertEqual('index.html', frame.tb_frame.f_code.co_filename)
cmlenz@131:             self.assertEqual(50, frame.tb_lineno)
cmlenz@131: 
cmlenz@30: 
cmlenz@1: def suite():
cmlenz@1:     suite = unittest.TestSuite()
cmlenz@30:     suite.addTest(unittest.makeSuite(ExpressionTestCase, 'test'))
cmlenz@27:     suite.addTest(doctest.DocTestSuite(Expression.__module__))
cmlenz@1:     return suite
cmlenz@1: 
cmlenz@1: if __name__ == '__main__':
cmlenz@1:     unittest.main(defaultTest='suite')