cmlenz@336: # -*- coding: utf-8 -*-
cmlenz@336: #
cmlenz@408: # Copyright (C) 2006-2007 Edgewall Software
cmlenz@336: # All rights reserved.
cmlenz@336: #
cmlenz@336: # This software is licensed as described in the file COPYING, which
cmlenz@336: # you should have received as part of this distribution. The terms
cmlenz@336: # are also available at http://genshi.edgewall.org/wiki/License.
cmlenz@336: #
cmlenz@336: # This software consists of voluntary contributions made by many
cmlenz@336: # individuals. For the exact contribution history, see the revision
cmlenz@336: # history and logs, available at http://genshi.edgewall.org/log/.
cmlenz@336: 
cmlenz@336: import doctest
cmlenz@336: import sys
cmlenz@336: import unittest
cmlenz@336: 
cmlenz@401: from genshi.core import Markup
cmlenz@442: from genshi.template.eval import Expression, Suite, Undefined, UndefinedError, \
cmlenz@442:                                  UNDEFINED
cmlenz@336: 
cmlenz@336: 
cmlenz@336: class ExpressionTestCase(unittest.TestCase):
cmlenz@336: 
cmlenz@340:     def test_eq(self):
cmlenz@340:         expr = Expression('x,y')
cmlenz@340:         self.assertEqual(expr, Expression('x,y'))
cmlenz@340:         self.assertNotEqual(expr, Expression('y, x'))
cmlenz@340: 
cmlenz@340:     def test_hash(self):
cmlenz@340:         expr = Expression('x,y')
cmlenz@340:         self.assertEqual(hash(expr), hash(Expression('x,y')))
cmlenz@340:         self.assertNotEqual(hash(expr), hash(Expression('y, x')))
cmlenz@340: 
cmlenz@336:     def test_name_lookup(self):
cmlenz@336:         self.assertEqual('bar', Expression('foo').evaluate({'foo': 'bar'}))
cmlenz@343:         self.assertEqual(id, Expression('id').evaluate({}))
cmlenz@336:         self.assertEqual('bar', Expression('id').evaluate({'id': 'bar'}))
cmlenz@343:         self.assertEqual(None, Expression('id').evaluate({'id': None}))
cmlenz@336: 
cmlenz@401:     def test_builtins(self):
cmlenz@401:         expr = Expression('Markup')
cmlenz@401:         self.assertEqual(expr.evaluate({}), Markup)
cmlenz@401: 
cmlenz@336:     def test_str_literal(self):
cmlenz@336:         self.assertEqual('foo', Expression('"foo"').evaluate({}))
cmlenz@336:         self.assertEqual('foo', Expression('"""foo"""').evaluate({}))
cmlenz@336:         self.assertEqual('foo', Expression("'foo'").evaluate({}))
cmlenz@336:         self.assertEqual('foo', Expression("'''foo'''").evaluate({}))
cmlenz@336:         self.assertEqual('foo', Expression("u'foo'").evaluate({}))
cmlenz@336:         self.assertEqual('foo', Expression("r'foo'").evaluate({}))
cmlenz@336: 
cmlenz@336:     def test_str_literal_non_ascii(self):
cmlenz@336:         expr = Expression(u"u'\xfe'")
cmlenz@336:         self.assertEqual(u'þ', expr.evaluate({}))
cmlenz@336:         expr = Expression("u'\xfe'")
cmlenz@336:         self.assertEqual(u'þ', expr.evaluate({}))
cmlenz@336:         expr = Expression("'\xc3\xbe'")
cmlenz@336:         self.assertEqual(u'þ', expr.evaluate({}))
cmlenz@336: 
cmlenz@336:     def test_num_literal(self):
cmlenz@336:         self.assertEqual(42, Expression("42").evaluate({}))
cmlenz@336:         self.assertEqual(42L, Expression("42L").evaluate({}))
cmlenz@336:         self.assertEqual(.42, Expression(".42").evaluate({}))
cmlenz@336:         self.assertEqual(07, Expression("07").evaluate({}))
cmlenz@336:         self.assertEqual(0xF2, Expression("0xF2").evaluate({}))
cmlenz@336:         self.assertEqual(0XF2, Expression("0XF2").evaluate({}))
cmlenz@336: 
cmlenz@336:     def test_dict_literal(self):
cmlenz@336:         self.assertEqual({}, Expression("{}").evaluate({}))
cmlenz@336:         self.assertEqual({'key': True},
cmlenz@336:                          Expression("{'key': value}").evaluate({'value': True}))
cmlenz@336: 
cmlenz@336:     def test_list_literal(self):
cmlenz@336:         self.assertEqual([], Expression("[]").evaluate({}))
cmlenz@336:         self.assertEqual([1, 2, 3], Expression("[1, 2, 3]").evaluate({}))
cmlenz@336:         self.assertEqual([True],
cmlenz@336:                          Expression("[value]").evaluate({'value': True}))
cmlenz@336: 
cmlenz@336:     def test_tuple_literal(self):
cmlenz@336:         self.assertEqual((), Expression("()").evaluate({}))
cmlenz@336:         self.assertEqual((1, 2, 3), Expression("(1, 2, 3)").evaluate({}))
cmlenz@336:         self.assertEqual((True,),
cmlenz@336:                          Expression("(value,)").evaluate({'value': True}))
cmlenz@336: 
cmlenz@336:     def test_unaryop_pos(self):
cmlenz@336:         self.assertEqual(1, Expression("+1").evaluate({}))
cmlenz@336:         self.assertEqual(1, Expression("+x").evaluate({'x': 1}))
cmlenz@336: 
cmlenz@336:     def test_unaryop_neg(self):
cmlenz@336:         self.assertEqual(-1, Expression("-1").evaluate({}))
cmlenz@336:         self.assertEqual(-1, Expression("-x").evaluate({'x': 1}))
cmlenz@336: 
cmlenz@336:     def test_unaryop_not(self):
cmlenz@336:         self.assertEqual(False, Expression("not True").evaluate({}))
cmlenz@336:         self.assertEqual(False, Expression("not x").evaluate({'x': True}))
cmlenz@336: 
cmlenz@336:     def test_unaryop_inv(self):
cmlenz@336:         self.assertEqual(-2, Expression("~1").evaluate({}))
cmlenz@336:         self.assertEqual(-2, Expression("~x").evaluate({'x': 1}))
cmlenz@336: 
cmlenz@336:     def test_binop_add(self):
cmlenz@336:         self.assertEqual(3, Expression("2 + 1").evaluate({}))
cmlenz@336:         self.assertEqual(3, Expression("x + y").evaluate({'x': 2, 'y': 1}))
cmlenz@336: 
cmlenz@336:     def test_binop_sub(self):
cmlenz@336:         self.assertEqual(1, Expression("2 - 1").evaluate({}))
cmlenz@336:         self.assertEqual(1, Expression("x - y").evaluate({'x': 1, 'y': 1}))
cmlenz@336: 
cmlenz@336:     def test_binop_sub(self):
cmlenz@336:         self.assertEqual(1, Expression("2 - 1").evaluate({}))
cmlenz@336:         self.assertEqual(1, Expression("x - y").evaluate({'x': 2, 'y': 1}))
cmlenz@336: 
cmlenz@336:     def test_binop_mul(self):
cmlenz@336:         self.assertEqual(4, Expression("2 * 2").evaluate({}))
cmlenz@336:         self.assertEqual(4, Expression("x * y").evaluate({'x': 2, 'y': 2}))
cmlenz@336: 
cmlenz@336:     def test_binop_pow(self):
cmlenz@336:         self.assertEqual(4, Expression("2 ** 2").evaluate({}))
cmlenz@336:         self.assertEqual(4, Expression("x ** y").evaluate({'x': 2, 'y': 2}))
cmlenz@336: 
cmlenz@336:     def test_binop_div(self):
cmlenz@336:         self.assertEqual(2, Expression("4 / 2").evaluate({}))
cmlenz@336:         self.assertEqual(2, Expression("x / y").evaluate({'x': 4, 'y': 2}))
cmlenz@336: 
cmlenz@336:     def test_binop_floordiv(self):
cmlenz@336:         self.assertEqual(1, Expression("3 // 2").evaluate({}))
cmlenz@336:         self.assertEqual(1, Expression("x // y").evaluate({'x': 3, 'y': 2}))
cmlenz@336: 
cmlenz@336:     def test_binop_mod(self):
cmlenz@336:         self.assertEqual(1, Expression("3 % 2").evaluate({}))
cmlenz@336:         self.assertEqual(1, Expression("x % y").evaluate({'x': 3, 'y': 2}))
cmlenz@336: 
cmlenz@336:     def test_binop_and(self):
cmlenz@336:         self.assertEqual(0, Expression("1 & 0").evaluate({}))
cmlenz@336:         self.assertEqual(0, Expression("x & y").evaluate({'x': 1, 'y': 0}))
cmlenz@336: 
cmlenz@336:     def test_binop_or(self):
cmlenz@336:         self.assertEqual(1, Expression("1 | 0").evaluate({}))
cmlenz@336:         self.assertEqual(1, Expression("x | y").evaluate({'x': 1, 'y': 0}))
cmlenz@336: 
mgood@396:     def test_binop_xor(self):
mgood@396:         self.assertEqual(1, Expression("1 ^ 0").evaluate({}))
mgood@396:         self.assertEqual(1, Expression("x ^ y").evaluate({'x': 1, 'y': 0}))
mgood@396: 
cmlenz@336:     def test_binop_contains(self):
cmlenz@336:         self.assertEqual(True, Expression("1 in (1, 2, 3)").evaluate({}))
cmlenz@336:         self.assertEqual(True, Expression("x in y").evaluate({'x': 1,
cmlenz@336:                                                               'y': (1, 2, 3)}))
cmlenz@336: 
cmlenz@336:     def test_binop_not_contains(self):
cmlenz@336:         self.assertEqual(True, Expression("4 not in (1, 2, 3)").evaluate({}))
cmlenz@336:         self.assertEqual(True, Expression("x not in y").evaluate({'x': 4,
cmlenz@336:                                                                   'y': (1, 2, 3)}))
cmlenz@336: 
cmlenz@336:     def test_binop_is(self):
cmlenz@336:         self.assertEqual(True, Expression("1 is 1").evaluate({}))
cmlenz@336:         self.assertEqual(True, Expression("x is y").evaluate({'x': 1, 'y': 1}))
cmlenz@336:         self.assertEqual(False, Expression("1 is 2").evaluate({}))
cmlenz@336:         self.assertEqual(False, Expression("x is y").evaluate({'x': 1, 'y': 2}))
cmlenz@336: 
cmlenz@336:     def test_binop_is_not(self):
cmlenz@336:         self.assertEqual(True, Expression("1 is not 2").evaluate({}))
cmlenz@336:         self.assertEqual(True, Expression("x is not y").evaluate({'x': 1,
cmlenz@336:                                                                   'y': 2}))
cmlenz@336:         self.assertEqual(False, Expression("1 is not 1").evaluate({}))
cmlenz@336:         self.assertEqual(False, Expression("x is not y").evaluate({'x': 1,
cmlenz@336:                                                                    'y': 1}))
cmlenz@336: 
cmlenz@336:     def test_boolop_and(self):
cmlenz@336:         self.assertEqual(False, Expression("True and False").evaluate({}))
cmlenz@336:         self.assertEqual(False, Expression("x and y").evaluate({'x': True,
cmlenz@336:                                                                 'y': False}))
cmlenz@336: 
cmlenz@336:     def test_boolop_or(self):
cmlenz@336:         self.assertEqual(True, Expression("True or False").evaluate({}))
cmlenz@336:         self.assertEqual(True, Expression("x or y").evaluate({'x': True,
cmlenz@336:                                                               'y': False}))
cmlenz@336: 
cmlenz@336:     def test_compare_eq(self):
cmlenz@336:         self.assertEqual(True, Expression("1 == 1").evaluate({}))
cmlenz@336:         self.assertEqual(True, Expression("x == y").evaluate({'x': 1, 'y': 1}))
cmlenz@336: 
cmlenz@336:     def test_compare_ne(self):
cmlenz@336:         self.assertEqual(False, Expression("1 != 1").evaluate({}))
cmlenz@336:         self.assertEqual(False, Expression("x != y").evaluate({'x': 1, 'y': 1}))
cmlenz@336:         self.assertEqual(False, Expression("1 <> 1").evaluate({}))
cmlenz@336:         self.assertEqual(False, Expression("x <> y").evaluate({'x': 1, 'y': 1}))
cmlenz@336: 
cmlenz@336:     def test_compare_lt(self):
cmlenz@336:         self.assertEqual(True, Expression("1 < 2").evaluate({}))
cmlenz@336:         self.assertEqual(True, Expression("x < y").evaluate({'x': 1, 'y': 2}))
cmlenz@336: 
cmlenz@336:     def test_compare_le(self):
cmlenz@336:         self.assertEqual(True, Expression("1 <= 1").evaluate({}))
cmlenz@336:         self.assertEqual(True, Expression("x <= y").evaluate({'x': 1, 'y': 1}))
cmlenz@336: 
cmlenz@336:     def test_compare_gt(self):
cmlenz@336:         self.assertEqual(True, Expression("2 > 1").evaluate({}))
cmlenz@336:         self.assertEqual(True, Expression("x > y").evaluate({'x': 2, 'y': 1}))
cmlenz@336: 
cmlenz@336:     def test_compare_ge(self):
cmlenz@336:         self.assertEqual(True, Expression("1 >= 1").evaluate({}))
cmlenz@336:         self.assertEqual(True, Expression("x >= y").evaluate({'x': 1, 'y': 1}))
cmlenz@336: 
cmlenz@336:     def test_compare_multi(self):
cmlenz@336:         self.assertEqual(True, Expression("1 != 3 == 3").evaluate({}))
cmlenz@336:         self.assertEqual(True, Expression("x != y == y").evaluate({'x': 1,
cmlenz@336:                                                                    'y': 3}))
cmlenz@336: 
cmlenz@336:     def test_call_function(self):
cmlenz@336:         self.assertEqual(42, Expression("foo()").evaluate({'foo': lambda: 42}))
cmlenz@336:         data = {'foo': 'bar'}
cmlenz@336:         self.assertEqual('BAR', Expression("foo.upper()").evaluate(data))
cmlenz@336:         data = {'foo': {'bar': range(42)}}
cmlenz@336:         self.assertEqual(42, Expression("len(foo.bar)").evaluate(data))
cmlenz@336: 
cmlenz@336:     def test_call_keywords(self):
cmlenz@336:         self.assertEqual(42, Expression("foo(x=bar)").evaluate({'foo': lambda x: x,
cmlenz@336:                                                                 'bar': 42}))
cmlenz@336: 
cmlenz@336:     def test_call_star_args(self):
cmlenz@336:         self.assertEqual(42, Expression("foo(*bar)").evaluate({'foo': lambda x: x,
cmlenz@336:                                                                'bar': [42]}))
cmlenz@336: 
cmlenz@336:     def test_call_dstar_args(self):
cmlenz@336:         def foo(x):
cmlenz@336:             return x
cmlenz@343:         expr = Expression("foo(**bar)")
cmlenz@343:         self.assertEqual(42, expr.evaluate({'foo': foo, 'bar': {"x": 42}}))
cmlenz@336: 
cmlenz@336:     def test_lambda(self):
cmlenz@336:         # Define a custom `sorted` function cause the builtin isn't available
cmlenz@336:         # on Python 2.3
cmlenz@336:         def sorted(items, compfunc):
cmlenz@336:             items.sort(compfunc)
cmlenz@336:             return items
cmlenz@336:         data = {'items': [{'name': 'b', 'value': 0}, {'name': 'a', 'value': 1}],
cmlenz@336:                 'sorted': sorted}
cmlenz@336:         expr = Expression("sorted(items, lambda a, b: cmp(a.name, b.name))")
cmlenz@336:         self.assertEqual([{'name': 'a', 'value': 1}, {'name': 'b', 'value': 0}],
cmlenz@336:                          expr.evaluate(data))
cmlenz@336: 
cmlenz@336:     def test_list_comprehension(self):
cmlenz@336:         expr = Expression("[n for n in numbers if n < 2]")
cmlenz@336:         self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
cmlenz@336: 
cmlenz@336:         expr = Expression("[(i, n + 1) for i, n in enumerate(numbers)]")
cmlenz@336:         self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
cmlenz@336:                          expr.evaluate({'numbers': range(5)}))
cmlenz@336: 
cmlenz@336:         expr = Expression("[offset + n for n in numbers]")
cmlenz@336:         self.assertEqual([2, 3, 4, 5, 6],
cmlenz@336:                          expr.evaluate({'numbers': range(5), 'offset': 2}))
cmlenz@336: 
cmlenz@336:     def test_list_comprehension_with_getattr(self):
cmlenz@336:         items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
cmlenz@336:         expr = Expression("[i.name for i in items if i.value > 1]")
cmlenz@336:         self.assertEqual(['b'], expr.evaluate({'items': items}))
cmlenz@336: 
cmlenz@336:     def test_list_comprehension_with_getitem(self):
cmlenz@336:         items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
cmlenz@336:         expr = Expression("[i['name'] for i in items if i['value'] > 1]")
cmlenz@336:         self.assertEqual(['b'], expr.evaluate({'items': items}))
cmlenz@336: 
cmlenz@336:     if sys.version_info >= (2, 4):
cmlenz@336:         # Generator expressions only supported in Python 2.4 and up
cmlenz@336: 
cmlenz@336:         def test_generator_expression(self):
cmlenz@336:             expr = Expression("list(n for n in numbers if n < 2)")
cmlenz@336:             self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
cmlenz@336: 
cmlenz@336:             expr = Expression("list((i, n + 1) for i, n in enumerate(numbers))")
cmlenz@336:             self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
cmlenz@336:                              expr.evaluate({'numbers': range(5)}))
cmlenz@336: 
cmlenz@336:             expr = Expression("list(offset + n for n in numbers)")
cmlenz@336:             self.assertEqual([2, 3, 4, 5, 6],
cmlenz@336:                              expr.evaluate({'numbers': range(5), 'offset': 2}))
cmlenz@336: 
cmlenz@336:         def test_generator_expression_with_getattr(self):
cmlenz@336:             items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
cmlenz@336:             expr = Expression("list(i.name for i in items if i.value > 1)")
cmlenz@336:             self.assertEqual(['b'], expr.evaluate({'items': items}))
cmlenz@336: 
cmlenz@336:         def test_generator_expression_with_getitem(self):
cmlenz@336:             items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
cmlenz@336:             expr = Expression("list(i['name'] for i in items if i['value'] > 1)")
cmlenz@336:             self.assertEqual(['b'], expr.evaluate({'items': items}))
cmlenz@336: 
mgood@393:     if sys.version_info >= (2, 5):
mgood@393:         def test_conditional_expression(self):
mgood@393:             expr = Expression("'T' if foo else 'F'")
mgood@393:             self.assertEqual('T', expr.evaluate({'foo': True}))
mgood@393:             self.assertEqual('F', expr.evaluate({'foo': False}))
mgood@393: 
cmlenz@336:     def test_slice(self):
cmlenz@336:         expr = Expression("numbers[0:2]")
cmlenz@336:         self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
cmlenz@336: 
cmlenz@336:     def test_slice_with_vars(self):
cmlenz@336:         expr = Expression("numbers[start:end]")
cmlenz@336:         self.assertEqual([0, 1], expr.evaluate({'numbers': range(5), 'start': 0,
cmlenz@336:                                                 'end': 2}))
cmlenz@336: 
cmlenz@336:     def test_slice_copy(self):
cmlenz@336:         expr = Expression("numbers[:]")
cmlenz@336:         self.assertEqual([0, 1, 2, 3, 4], expr.evaluate({'numbers': range(5)}))
cmlenz@336: 
cmlenz@336:     def test_slice_stride(self):
cmlenz@336:         expr = Expression("numbers[::stride]")
cmlenz@336:         self.assertEqual([0, 2, 4], expr.evaluate({'numbers': range(5),
cmlenz@336:                                                    'stride': 2}))
cmlenz@336: 
cmlenz@336:     def test_slice_negative_start(self):
cmlenz@336:         expr = Expression("numbers[-1:]")
cmlenz@336:         self.assertEqual([4], expr.evaluate({'numbers': range(5)}))
cmlenz@336: 
cmlenz@336:     def test_slice_negative_end(self):
cmlenz@336:         expr = Expression("numbers[:-1]")
cmlenz@336:         self.assertEqual([0, 1, 2, 3], expr.evaluate({'numbers': range(5)}))
cmlenz@336: 
cmlenz@442:     def test_access_undefined(self):
cmlenz@606:         expr = Expression("nothing", filename='index.html', lineno=50,
cmlenz@606:                           lookup='lenient')
cmlenz@442:         retval = expr.evaluate({})
cmlenz@442:         assert isinstance(retval, Undefined)
cmlenz@442:         self.assertEqual('nothing', retval._name)
cmlenz@442:         assert retval._owner is UNDEFINED
cmlenz@442: 
cmlenz@442:     def test_getattr_undefined(self):
cmlenz@442:         class Something(object):
cmlenz@442:             def __repr__(self):
cmlenz@442:                 return '<Something>'
cmlenz@442:         something = Something()
cmlenz@606:         expr = Expression('something.nil', filename='index.html', lineno=50,
cmlenz@606:                           lookup='lenient')
cmlenz@442:         retval = expr.evaluate({'something': something})
cmlenz@442:         assert isinstance(retval, Undefined)
cmlenz@442:         self.assertEqual('nil', retval._name)
cmlenz@442:         assert retval._owner is something
cmlenz@442: 
cmlenz@569:     def test_getattr_exception(self):
cmlenz@569:         class Something(object):
aflett@703:             def prop_a(self):
cmlenz@569:                 raise NotImplementedError
aflett@703:             prop_a = property(prop_a)
aflett@703:             def prop_b(self):
aflett@703:                 raise AttributeError
aflett@703:             prop_b = property(prop_b)
cmlenz@569:         self.assertRaises(NotImplementedError,
aflett@703:                           Expression('s.prop_a').evaluate, {'s': Something()})
aflett@703:         self.assertRaises(AttributeError,
aflett@703:                           Expression('s.prop_b').evaluate, {'s': Something()})
cmlenz@569: 
cmlenz@442:     def test_getitem_undefined_string(self):
cmlenz@442:         class Something(object):
cmlenz@442:             def __repr__(self):
cmlenz@442:                 return '<Something>'
cmlenz@442:         something = Something()
cmlenz@606:         expr = Expression('something["nil"]', filename='index.html', lineno=50,
cmlenz@606:                           lookup='lenient')
cmlenz@442:         retval = expr.evaluate({'something': something})
cmlenz@442:         assert isinstance(retval, Undefined)
cmlenz@442:         self.assertEqual('nil', retval._name)
cmlenz@442:         assert retval._owner is something
cmlenz@442: 
cmlenz@569:     def test_getitem_exception(self):
cmlenz@569:         class Something(object):
cmlenz@569:             def __getitem__(self, key):
cmlenz@569:                 raise NotImplementedError
cmlenz@569:         self.assertRaises(NotImplementedError,
cmlenz@569:                           Expression('s["foo"]').evaluate, {'s': Something()})
cmlenz@569: 
cmlenz@336:     def test_error_access_undefined(self):
cmlenz@442:         expr = Expression("nothing", filename='index.html', lineno=50,
cmlenz@442:                           lookup='strict')
cmlenz@336:         try:
cmlenz@336:             expr.evaluate({})
cmlenz@418:             self.fail('Expected UndefinedError')
cmlenz@418:         except UndefinedError, e:
cmlenz@336:             exc_type, exc_value, exc_traceback = sys.exc_info()
cmlenz@336:             frame = exc_traceback.tb_next
cmlenz@336:             frames = []
cmlenz@336:             while frame.tb_next:
cmlenz@336:                 frame = frame.tb_next
cmlenz@336:                 frames.append(frame)
cmlenz@418:             self.assertEqual('"nothing" not defined', str(e))
cmlenz@418:             self.assertEqual("<Expression 'nothing'>",
cmlenz@442:                              frames[-3].tb_frame.f_code.co_name)
cmlenz@336:             self.assertEqual('index.html',
cmlenz@442:                              frames[-3].tb_frame.f_code.co_filename)
cmlenz@442:             self.assertEqual(50, frames[-3].tb_lineno)
cmlenz@336: 
cmlenz@418:     def test_error_getattr_undefined(self):
cmlenz@418:         class Something(object):
cmlenz@418:             def __repr__(self):
cmlenz@418:                 return '<Something>'
cmlenz@442:         expr = Expression('something.nil', filename='index.html', lineno=50,
cmlenz@442:                           lookup='strict')
cmlenz@336:         try:
cmlenz@418:             expr.evaluate({'something': Something()})
cmlenz@418:             self.fail('Expected UndefinedError')
cmlenz@418:         except UndefinedError, e:
cmlenz@473:             self.assertEqual('<Something> has no member named "nil"', str(e))
cmlenz@336:             exc_type, exc_value, exc_traceback = sys.exc_info()
cmlenz@473:             search_string = "<Expression 'something.nil'>"
cmlenz@336:             frame = exc_traceback.tb_next
cmlenz@336:             while frame.tb_next:
cmlenz@336:                 frame = frame.tb_next
cmlenz@473:                 code = frame.tb_frame.f_code
cmlenz@473:                 if code.co_name == search_string:
cmlenz@473:                     break
cmlenz@473:             else:
cmlenz@473:                 self.fail("never found the frame I was looking for")
cmlenz@473:             self.assertEqual('index.html', code.co_filename)
cmlenz@473:             self.assertEqual(50, frame.tb_lineno)
cmlenz@336: 
cmlenz@418:     def test_error_getitem_undefined_string(self):
cmlenz@418:         class Something(object):
cmlenz@418:             def __repr__(self):
cmlenz@418:                 return '<Something>'
cmlenz@442:         expr = Expression('something["nil"]', filename='index.html', lineno=50,
cmlenz@442:                           lookup='strict')
cmlenz@418:         try:
cmlenz@418:             expr.evaluate({'something': Something()})
cmlenz@418:             self.fail('Expected UndefinedError')
cmlenz@418:         except UndefinedError, e:
cmlenz@473:             self.assertEqual('<Something> has no member named "nil"', str(e))
cmlenz@418:             exc_type, exc_value, exc_traceback = sys.exc_info()
cmlenz@473:             search_string = '''<Expression 'something["nil"]'>'''
cmlenz@418:             frame = exc_traceback.tb_next
cmlenz@418:             while frame.tb_next:
cmlenz@418:                 frame = frame.tb_next
cmlenz@473:                 code = frame.tb_frame.f_code
cmlenz@473:                 if code.co_name == search_string:
cmlenz@473:                     break
cmlenz@473:             else:
cmlenz@473:                 self.fail("never found the frame I was looking for")
cmlenz@473:             self.assertEqual('index.html', code.co_filename)
cmlenz@473:             self.assertEqual(50, frame.tb_lineno)
cmlenz@336: 
cmlenz@336: 
cmlenz@405: class SuiteTestCase(unittest.TestCase):
cmlenz@405: 
cmlenz@682:     def test_internal_shadowing(self):
cmlenz@682:         # The context itself is stored in the global execution scope of a suite
cmlenz@682:         # It used to get stored under the name 'data', which meant the
cmlenz@682:         # following test would fail, as the user defined 'data' variable
cmlenz@682:         # shadowed the Genshi one. We now use the name '__data__' to avoid
cmlenz@682:         # conflicts
cmlenz@682:         suite = Suite("""data = []
cmlenz@682: bar = foo
cmlenz@682: """)
cmlenz@682:         data = {'foo': 42}
cmlenz@682:         suite.execute(data)
cmlenz@682:         self.assertEqual(42, data['bar'])
cmlenz@682: 
cmlenz@405:     def test_assign(self):
cmlenz@405:         suite = Suite("foo = 42")
cmlenz@405:         data = {}
cmlenz@405:         suite.execute(data)
cmlenz@405:         self.assertEqual(42, data['foo'])
cmlenz@405: 
cmlenz@405:     def test_def(self):
cmlenz@405:         suite = Suite("def donothing(): pass")
cmlenz@405:         data = {}
cmlenz@405:         suite.execute(data)
cmlenz@405:         assert 'donothing' in data
cmlenz@405:         self.assertEqual(None, data['donothing']())
cmlenz@405: 
cmlenz@473:     def test_def_with_multiple_statements(self):
cmlenz@586:         suite = Suite("""
cmlenz@586: def donothing():
cmlenz@473:     if True:
cmlenz@473:         return foo
cmlenz@473: """)
cmlenz@473:         data = {'foo': 'bar'}
cmlenz@473:         suite.execute(data)
cmlenz@473:         assert 'donothing' in data
cmlenz@473:         self.assertEqual('bar', data['donothing']())
cmlenz@473: 
cmlenz@586:     def test_def_using_nonlocal(self):
cmlenz@586:         suite = Suite("""
cmlenz@586: values = []
cmlenz@586: def add(value):
cmlenz@586:     if value not in values:
cmlenz@586:         values.append(value)
cmlenz@586: add('foo')
cmlenz@586: add('bar')
cmlenz@586: """)
cmlenz@586:         data = {}
cmlenz@586:         suite.execute(data)
cmlenz@586:         self.assertEqual(['foo', 'bar'], data['values'])
cmlenz@586: 
cmlenz@586:     def test_def_nested(self):
cmlenz@586:         suite = Suite("""
cmlenz@586: def doit():
cmlenz@586:     values = []
cmlenz@586:     def add(value):
cmlenz@586:         if value not in values:
cmlenz@586:             values.append(value)
cmlenz@586:     add('foo')
cmlenz@586:     add('bar')
cmlenz@586:     return values
cmlenz@586: x = doit()
cmlenz@586: """)
cmlenz@586:         data = {}
cmlenz@586:         suite.execute(data)
cmlenz@586:         self.assertEqual(['foo', 'bar'], data['x'])
cmlenz@586: 
cmlenz@405:     def test_delete(self):
cmlenz@405:         suite = Suite("""foo = 42
cmlenz@405: del foo
cmlenz@405: """)
cmlenz@405:         data = {}
cmlenz@405:         suite.execute(data)
cmlenz@405:         assert 'foo' not in data
cmlenz@405: 
cmlenz@405:     def test_class(self):
cmlenz@405:         suite = Suite("class plain(object): pass")
cmlenz@405:         data = {}
cmlenz@405:         suite.execute(data)
cmlenz@405:         assert 'plain' in data
cmlenz@405: 
cmlenz@586:     def test_class_in_def(self):
cmlenz@586:         suite = Suite("""
cmlenz@586: def create():
cmlenz@586:     class Foobar(object):
cmlenz@586:         def __str__(self):
cmlenz@586:             return 'foobar'
cmlenz@586:     return Foobar()
cmlenz@586: x = create()
cmlenz@586: """)
cmlenz@586:         data = {}
cmlenz@586:         suite.execute(data)
cmlenz@586:         self.assertEqual('foobar', str(data['x']))
cmlenz@586: 
cmlenz@568:     def test_class_with_methods(self):
cmlenz@568:         suite = Suite("""class plain(object):
cmlenz@568:     def donothing():
cmlenz@568:         pass
cmlenz@568: """)
cmlenz@568:         data = {}
cmlenz@568:         suite.execute(data)
cmlenz@568:         assert 'plain' in data
cmlenz@568: 
cmlenz@405:     def test_import(self):
cmlenz@405:         suite = Suite("from itertools import ifilter")
cmlenz@405:         data = {}
cmlenz@405:         suite.execute(data)
cmlenz@405:         assert 'ifilter' in data
cmlenz@405: 
cmlenz@405:     def test_for(self):
cmlenz@405:         suite = Suite("""x = []
cmlenz@405: for i in range(3):
cmlenz@405:     x.append(i**2)
cmlenz@405: """)
cmlenz@405:         data = {}
cmlenz@405:         suite.execute(data)
cmlenz@405:         self.assertEqual([0, 1, 4], data['x'])
cmlenz@405: 
cmlenz@405:     def test_if(self):
cmlenz@405:         suite = Suite("""if foo == 42:
cmlenz@405:     x = True
cmlenz@405: """)
cmlenz@405:         data = {'foo': 42}
cmlenz@405:         suite.execute(data)
cmlenz@405:         self.assertEqual(True, data['x'])
cmlenz@405: 
cmlenz@405:     def test_raise(self):
cmlenz@405:         suite = Suite("""raise NotImplementedError""")
cmlenz@405:         self.assertRaises(NotImplementedError, suite.execute, {})
cmlenz@405: 
cmlenz@405:     def test_try_except(self):
cmlenz@405:         suite = Suite("""try:
cmlenz@405:     import somemod
cmlenz@405: except ImportError:
cmlenz@405:     somemod = None
cmlenz@405: else:
cmlenz@405:     somemod.dosth()""")
cmlenz@405:         data = {}
cmlenz@405:         suite.execute(data)
cmlenz@405:         self.assertEqual(None, data['somemod'])
cmlenz@405: 
cmlenz@405:     def test_finally(self):
cmlenz@405:         suite = Suite("""try:
cmlenz@405:     x = 2
cmlenz@405: finally:
cmlenz@405:     x = None
cmlenz@405: """)
cmlenz@405:         data = {}
cmlenz@405:         suite.execute(data)
cmlenz@405:         self.assertEqual(None, data['x'])
cmlenz@405: 
cmlenz@405:     def test_while_break(self):
cmlenz@405:         suite = Suite("""x = 0
cmlenz@405: while x < 5:
cmlenz@405:     x += step
cmlenz@405:     if x == 4:
cmlenz@405:         break
cmlenz@405: """)
cmlenz@405:         data = {'step': 2}
cmlenz@405:         suite.execute(data)
cmlenz@405:         self.assertEqual(4, data['x'])
cmlenz@405: 
cmlenz@473:     def test_augmented_attribute_assignment(self):
cmlenz@473:         suite = Suite("d['k'] += 42")
cmlenz@473:         d = {"k": 1}
cmlenz@473:         suite.execute({"d": d})
cmlenz@473:         self.assertEqual(43, d["k"])
cmlenz@473: 
cmlenz@473:     def test_local_augmented_assign(self):
cmlenz@473:         Suite("x = 1; x += 42; assert x == 43").execute({})
cmlenz@473: 
cmlenz@579:     def test_augmented_assign_in_def(self):
cmlenz@579:         d = {}
cmlenz@579:         Suite("""def foo():
cmlenz@579:     i = 1
cmlenz@579:     i += 1
cmlenz@579:     return i
cmlenz@579: x = foo()""").execute(d)
cmlenz@579:         self.assertEqual(2, d['x'])
cmlenz@579: 
cmlenz@582:     def test_augmented_assign_in_loop_in_def(self):
cmlenz@582:         d = {}
cmlenz@582:         Suite("""def foo():
cmlenz@582:     i = 0
cmlenz@582:     for n in range(5):
cmlenz@582:         i += n
cmlenz@582:     return i
cmlenz@582: x = foo()""").execute(d)
cmlenz@582:         self.assertEqual(10, d['x'])
cmlenz@582: 
cmlenz@473:     def test_assign_in_list(self):
cmlenz@473:         suite = Suite("[d['k']] = 'foo',; assert d['k'] == 'foo'")
cmlenz@473:         d = {"k": "bar"}
cmlenz@473:         suite.execute({"d": d})
cmlenz@473:         self.assertEqual("foo", d["k"])
cmlenz@473: 
cmlenz@473:     def test_exec(self):
cmlenz@473:         suite = Suite("x = 1; exec d['k']; assert x == 42, x")
cmlenz@473:         suite.execute({"d": {"k": "x = 42"}})
cmlenz@473: 
cmlenz@473:     def test_return(self):
cmlenz@473:         suite = Suite("""
cmlenz@473: def f():
cmlenz@473:     return v
cmlenz@473: 
cmlenz@473: assert f() == 42
cmlenz@473: """)
cmlenz@473:         suite.execute({"v": 42})
cmlenz@473: 
cmlenz@473:     def test_assign_to_dict_item(self):
cmlenz@473:         suite = Suite("d['k'] = 'foo'")
cmlenz@473:         data = {'d': {}}
cmlenz@473:         suite.execute(data)
cmlenz@473:         self.assertEqual('foo', data['d']['k'])
cmlenz@473: 
cmlenz@473:     def test_assign_to_attribute(self):
cmlenz@473:         class Something(object): pass
cmlenz@473:         something = Something()
cmlenz@473:         suite = Suite("obj.attr = 'foo'")
cmlenz@473:         data = {"obj": something}
cmlenz@473:         suite.execute(data)
cmlenz@473:         self.assertEqual('foo', something.attr)
cmlenz@473: 
cmlenz@473:     def test_delattr(self):
cmlenz@473:         class Something(object):
cmlenz@473:             def __init__(self):
cmlenz@473:                 self.attr = 'foo'
cmlenz@473:         obj = Something()
cmlenz@473:         Suite("del obj.attr").execute({'obj': obj})
cmlenz@473:         self.failIf(hasattr(obj, 'attr'))
cmlenz@473: 
cmlenz@473:     def test_delitem(self):
cmlenz@473:         d = {'k': 'foo'}
cmlenz@473:         Suite("del d['k']").execute({'d': d})
cmlenz@473:         self.failIf('k' in d, `d`)
cmlenz@473: 
cmlenz@405: 
cmlenz@336: def suite():
cmlenz@336:     suite = unittest.TestSuite()
cmlenz@336:     suite.addTest(doctest.DocTestSuite(Expression.__module__))
cmlenz@336:     suite.addTest(unittest.makeSuite(ExpressionTestCase, 'test'))
cmlenz@405:     suite.addTest(unittest.makeSuite(SuiteTestCase, 'test'))
cmlenz@336:     return suite
cmlenz@336: 
cmlenz@336: if __name__ == '__main__':
cmlenz@336:     unittest.main(defaultTest='suite')