genshi/genshi-test: markup/tests/eval.py annotate

annotate markup/tests/eval.py @ 226:09f869a98149

Add reStructuredText documentation files.

author	cmlenz
date	Fri, 08 Sep 2006 08:44:31 +0000
parents	0edf663b97d6
children	98b8e1a92df8

rev	line source
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	1 # -- coding: utf-8 --
821114ec4f69 Initial import. cmlenz parents: diff changeset	2 #
66 822089ae65ce Switch copyright to Edgewall and URLs to markup.edgewall.org. cmlenz parents: 32 diff changeset	3 # Copyright (C) 2006 Edgewall Software
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	4 # All rights reserved.
821114ec4f69 Initial import. cmlenz parents: diff changeset	5 #
821114ec4f69 Initial import. cmlenz parents: diff changeset	6 # This software is licensed as described in the file COPYING, which
821114ec4f69 Initial import. cmlenz parents: diff changeset	7 # you should have received as part of this distribution. The terms
66 822089ae65ce Switch copyright to Edgewall and URLs to markup.edgewall.org. cmlenz parents: 32 diff changeset	8 # are also available at http://markup.edgewall.org/wiki/License.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	9 #
821114ec4f69 Initial import. cmlenz parents: diff changeset	10 # This software consists of voluntary contributions made by many
821114ec4f69 Initial import. cmlenz parents: diff changeset	11 # individuals. For the exact contribution history, see the revision
66 822089ae65ce Switch copyright to Edgewall and URLs to markup.edgewall.org. cmlenz parents: 32 diff changeset	12 # history and logs, available at hhttp://markup.edgewall.org/log/.
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	13
821114ec4f69 Initial import. cmlenz parents: diff changeset	14 import doctest
131 203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	15 import sys
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	16 import unittest
821114ec4f69 Initial import. cmlenz parents: diff changeset	17
195 a180441acbff Fix missing import in unit test added in [244]. cmlenz parents: 194 diff changeset	18 from markup.eval import Expression, Undefined
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	19
30 2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	20
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	21 class ExpressionTestCase(unittest.TestCase):
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	22
192 cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	23 def test_name_lookup(self):
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	24 self.assertEqual('bar', Expression('foo').evaluate({'foo': 'bar'}))
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	25 self.assertEqual(id, Expression('id').evaluate({}, nocall=True))
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	26 self.assertEqual('bar', Expression('id').evaluate({'id': 'bar'}))
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	27 self.assertEqual(None, Expression('id').evaluate({'id': None},
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	28 nocall=True))
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	29
30 2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	30 def test_str_literal(self):
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	31 self.assertEqual('foo', Expression('"foo"').evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	32 self.assertEqual('foo', Expression('"""foo"""').evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	33 self.assertEqual('foo', Expression("'foo'").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	34 self.assertEqual('foo', Expression("'''foo'''").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	35 self.assertEqual('foo', Expression("u'foo'").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	36 self.assertEqual('foo', Expression("r'foo'").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	37
167 7888f4104cc0 Handle non-ASCII characters in expressions. Closes #29. Thanks to Arnar Birgisson for reporting the problem and comping up with a patch! cmlenz parents: 134 diff changeset	38 def test_str_literal_non_ascii(self):
7888f4104cc0 Handle non-ASCII characters in expressions. Closes #29. Thanks to Arnar Birgisson for reporting the problem and comping up with a patch! cmlenz parents: 134 diff changeset	39 expr = Expression(u"u'\xfe'")
7888f4104cc0 Handle non-ASCII characters in expressions. Closes #29. Thanks to Arnar Birgisson for reporting the problem and comping up with a patch! cmlenz parents: 134 diff changeset	40 self.assertEqual(u'þ', expr.evaluate({}))
7888f4104cc0 Handle non-ASCII characters in expressions. Closes #29. Thanks to Arnar Birgisson for reporting the problem and comping up with a patch! cmlenz parents: 134 diff changeset	41 expr = Expression("u'\xfe'")
7888f4104cc0 Handle non-ASCII characters in expressions. Closes #29. Thanks to Arnar Birgisson for reporting the problem and comping up with a patch! cmlenz parents: 134 diff changeset	42 self.assertEqual(u'þ', expr.evaluate({}))
180 194025141c89 String literals in XPath expressions are assumed to be UTF-8 encoded. cmlenz parents: 167 diff changeset	43 expr = Expression("'\xc3\xbe'")
194025141c89 String literals in XPath expressions are assumed to be UTF-8 encoded. cmlenz parents: 167 diff changeset	44 self.assertEqual(u'þ', expr.evaluate({}))
167 7888f4104cc0 Handle non-ASCII characters in expressions. Closes #29. Thanks to Arnar Birgisson for reporting the problem and comping up with a patch! cmlenz parents: 134 diff changeset	45
30 2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	46 def test_num_literal(self):
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	47 self.assertEqual(42, Expression("42").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	48 self.assertEqual(42L, Expression("42L").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	49 self.assertEqual(.42, Expression(".42").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	50 self.assertEqual(07, Expression("07").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	51 self.assertEqual(0xF2, Expression("0xF2").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	52 self.assertEqual(0XF2, Expression("0XF2").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	53
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	54 def test_dict_literal(self):
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	55 self.assertEqual({}, Expression("{}").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	56 self.assertEqual({'key': True},
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	57 Expression("{'key': value}").evaluate({'value': True}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	58
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	59 def test_list_literal(self):
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	60 self.assertEqual([], Expression("[]").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	61 self.assertEqual([1, 2, 3], Expression("[1, 2, 3]").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	62 self.assertEqual([True],
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	63 Expression("[value]").evaluate({'value': True}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	64
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	65 def test_tuple_literal(self):
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	66 self.assertEqual((), Expression("()").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	67 self.assertEqual((1, 2, 3), Expression("(1, 2, 3)").evaluate({}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	68 self.assertEqual((True,),
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	69 Expression("(value,)").evaluate({'value': True}))
2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	70
31 9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	71 def test_unaryop_pos(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	72 self.assertEqual(1, Expression("+1").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	73 self.assertEqual(1, Expression("+x").evaluate({'x': 1}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	74
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	75 def test_unaryop_neg(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	76 self.assertEqual(-1, Expression("-1").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	77 self.assertEqual(-1, Expression("-x").evaluate({'x': 1}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	78
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	79 def test_unaryop_not(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	80 self.assertEqual(False, Expression("not True").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	81 self.assertEqual(False, Expression("not x").evaluate({'x': True}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	82
32 3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	83 def test_unaryop_inv(self):
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	84 self.assertEqual(-2, Expression("~1").evaluate({}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	85 self.assertEqual(-2, Expression("~x").evaluate({'x': 1}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	86
31 9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	87 def test_binop_add(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	88 self.assertEqual(3, Expression("2 + 1").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	89 self.assertEqual(3, Expression("x + y").evaluate({'x': 2, 'y': 1}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	90
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	91 def test_binop_sub(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	92 self.assertEqual(1, Expression("2 - 1").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	93 self.assertEqual(1, Expression("x - y").evaluate({'x': 1, 'y': 1}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	94
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	95 def test_binop_sub(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	96 self.assertEqual(1, Expression("2 - 1").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	97 self.assertEqual(1, Expression("x - y").evaluate({'x': 2, 'y': 1}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	98
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	99 def test_binop_mul(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	100 self.assertEqual(4, Expression("2 * 2").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	101 self.assertEqual(4, Expression("x * y").evaluate({'x': 2, 'y': 2}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	102
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	103 def test_binop_pow(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	104 self.assertEqual(4, Expression("2 ** 2").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	105 self.assertEqual(4, Expression("x ** y").evaluate({'x': 2, 'y': 2}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	106
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	107 def test_binop_div(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	108 self.assertEqual(2, Expression("4 / 2").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	109 self.assertEqual(2, Expression("x / y").evaluate({'x': 4, 'y': 2}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	110
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	111 def test_binop_floordiv(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	112 self.assertEqual(1, Expression("3 // 2").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	113 self.assertEqual(1, Expression("x // y").evaluate({'x': 3, 'y': 2}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	114
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	115 def test_binop_mod(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	116 self.assertEqual(1, Expression("3 % 2").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	117 self.assertEqual(1, Expression("x % y").evaluate({'x': 3, 'y': 2}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	118
32 3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	119 def test_binop_and(self):
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	120 self.assertEqual(0, Expression("1 & 0").evaluate({}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	121 self.assertEqual(0, Expression("x & y").evaluate({'x': 1, 'y': 0}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	122
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	123 def test_binop_or(self):
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	124 self.assertEqual(1, Expression("1 \| 0").evaluate({}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	125 self.assertEqual(1, Expression("x \| y").evaluate({'x': 1, 'y': 0}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	126
31 9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	127 def test_binop_contains(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	128 self.assertEqual(True, Expression("1 in (1, 2, 3)").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	129 self.assertEqual(True, Expression("x in y").evaluate({'x': 1,
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	130 'y': (1, 2, 3)}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	131
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	132 def test_binop_not_contains(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	133 self.assertEqual(True, Expression("4 not in (1, 2, 3)").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	134 self.assertEqual(True, Expression("x not in y").evaluate({'x': 4,
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	135 'y': (1, 2, 3)}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	136
32 3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	137 def test_binop_is(self):
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	138 self.assertEqual(True, Expression("1 is 1").evaluate({}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	139 self.assertEqual(True, Expression("x is y").evaluate({'x': 1, 'y': 1}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	140 self.assertEqual(False, Expression("1 is 2").evaluate({}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	141 self.assertEqual(False, Expression("x is y").evaluate({'x': 1, 'y': 2}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	142
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	143 def test_binop_is_not(self):
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	144 self.assertEqual(True, Expression("1 is not 2").evaluate({}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	145 self.assertEqual(True, Expression("x is not y").evaluate({'x': 1,
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	146 'y': 2}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	147 self.assertEqual(False, Expression("1 is not 1").evaluate({}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	148 self.assertEqual(False, Expression("x is not y").evaluate({'x': 1,
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	149 'y': 1}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	150
31 9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	151 def test_boolop_and(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	152 self.assertEqual(False, Expression("True and False").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	153 self.assertEqual(False, Expression("x and y").evaluate({'x': True,
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	154 'y': False}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	155
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	156 def test_boolop_or(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	157 self.assertEqual(True, Expression("True or False").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	158 self.assertEqual(True, Expression("x or y").evaluate({'x': True,
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	159 'y': False}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	160
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	161 def test_compare_eq(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	162 self.assertEqual(True, Expression("1 == 1").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	163 self.assertEqual(True, Expression("x == y").evaluate({'x': 1, 'y': 1}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	164
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	165 def test_compare_ne(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	166 self.assertEqual(False, Expression("1 != 1").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	167 self.assertEqual(False, Expression("x != y").evaluate({'x': 1, 'y': 1}))
32 3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	168 self.assertEqual(False, Expression("1 <> 1").evaluate({}))
3b8c41bbf83d A couple more operators supported in expressions. cmlenz parents: 31 diff changeset	169 self.assertEqual(False, Expression("x <> y").evaluate({'x': 1, 'y': 1}))
31 9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	170
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	171 def test_compare_lt(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	172 self.assertEqual(True, Expression("1 < 2").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	173 self.assertEqual(True, Expression("x < y").evaluate({'x': 1, 'y': 2}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	174
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	175 def test_compare_le(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	176 self.assertEqual(True, Expression("1 <= 1").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	177 self.assertEqual(True, Expression("x <= y").evaluate({'x': 1, 'y': 1}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	178
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	179 def test_compare_gt(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	180 self.assertEqual(True, Expression("2 > 1").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	181 self.assertEqual(True, Expression("x > y").evaluate({'x': 2, 'y': 1}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	182
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	183 def test_compare_ge(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	184 self.assertEqual(True, Expression("1 >= 1").evaluate({}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	185 self.assertEqual(True, Expression("x >= y").evaluate({'x': 1, 'y': 1}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	186
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	187 def test_compare_multi(self):
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	188 self.assertEqual(True, Expression("1 != 3 == 3").evaluate({}))
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 66 diff changeset	189 self.assertEqual(True, Expression("x != y == y").evaluate({'x': 1,
31 9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	190 'y': 3}))
9a958398bed9 * More test cases for expression evaluation. cmlenz parents: 30 diff changeset	191
87 c6f07b7cd3ea Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13. cmlenz parents: 81 diff changeset	192 def test_call_function(self):
c6f07b7cd3ea Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13. cmlenz parents: 81 diff changeset	193 self.assertEqual(42, Expression("foo()").evaluate({'foo': lambda: 42}))
c6f07b7cd3ea Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13. cmlenz parents: 81 diff changeset	194 data = {'foo': 'bar'}
c6f07b7cd3ea Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13. cmlenz parents: 81 diff changeset	195 self.assertEqual('BAR', Expression("foo.upper()").evaluate(data))
c6f07b7cd3ea Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13. cmlenz parents: 81 diff changeset	196 data = {'foo': {'bar': range(42)}}
c6f07b7cd3ea Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13. cmlenz parents: 81 diff changeset	197 self.assertEqual(42, Expression("len(foo.bar)").evaluate(data))
c6f07b7cd3ea Fix some problems in expression evaluation by transforming the AST and compiling that to bytecode, instead of generating bytecode directly. Invalidates #13. cmlenz parents: 81 diff changeset	198
102 12efdfe8af47 Ported [118] to trunk jonas parents: 90 diff changeset	199 def test_call_keywords(self):
12efdfe8af47 Ported [118] to trunk jonas parents: 90 diff changeset	200 self.assertEqual(42, Expression("foo(x=bar)").evaluate({'foo': lambda x: x,
12efdfe8af47 Ported [118] to trunk jonas parents: 90 diff changeset	201 'bar': 42}))
12efdfe8af47 Ported [118] to trunk jonas parents: 90 diff changeset	202
203 6addf7af09f6 Fix for handling function calls with star/dstar arguments in expressions. Closes #42. Many thanks to David Fraser for reporting the problem and providing a patch! cmlenz parents: 198 diff changeset	203 def test_call_star_args(self):
6addf7af09f6 Fix for handling function calls with star/dstar arguments in expressions. Closes #42. Many thanks to David Fraser for reporting the problem and providing a patch! cmlenz parents: 198 diff changeset	204 self.assertEqual(42, Expression("foo(*bar)").evaluate({'foo': lambda x: x,
6addf7af09f6 Fix for handling function calls with star/dstar arguments in expressions. Closes #42. Many thanks to David Fraser for reporting the problem and providing a patch! cmlenz parents: 198 diff changeset	205 'bar': [42]}))
6addf7af09f6 Fix for handling function calls with star/dstar arguments in expressions. Closes #42. Many thanks to David Fraser for reporting the problem and providing a patch! cmlenz parents: 198 diff changeset	206
6addf7af09f6 Fix for handling function calls with star/dstar arguments in expressions. Closes #42. Many thanks to David Fraser for reporting the problem and providing a patch! cmlenz parents: 198 diff changeset	207 def test_call_dstar_args(self):
6addf7af09f6 Fix for handling function calls with star/dstar arguments in expressions. Closes #42. Many thanks to David Fraser for reporting the problem and providing a patch! cmlenz parents: 198 diff changeset	208 def foo(x):
6addf7af09f6 Fix for handling function calls with star/dstar arguments in expressions. Closes #42. Many thanks to David Fraser for reporting the problem and providing a patch! cmlenz parents: 198 diff changeset	209 return x
6addf7af09f6 Fix for handling function calls with star/dstar arguments in expressions. Closes #42. Many thanks to David Fraser for reporting the problem and providing a patch! cmlenz parents: 198 diff changeset	210 self.assertEqual(42, Expression("foo(**bar)").evaluate({'foo': foo,
6addf7af09f6 Fix for handling function calls with star/dstar arguments in expressions. Closes #42. Many thanks to David Fraser for reporting the problem and providing a patch! cmlenz parents: 198 diff changeset	211 'bar': {"x": 42}}))
6addf7af09f6 Fix for handling function calls with star/dstar arguments in expressions. Closes #42. Many thanks to David Fraser for reporting the problem and providing a patch! cmlenz parents: 198 diff changeset	212
90 242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 88 diff changeset	213 def test_call_function_without_params(self):
242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 88 diff changeset	214 self.assertEqual(42, Expression("foo").evaluate({'foo': lambda: 42}))
242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 88 diff changeset	215 data = {'foo': 'bar'}
242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 88 diff changeset	216 self.assertEqual('BAR', Expression("foo.upper").evaluate(data))
242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 88 diff changeset	217 data = {'foo': {'bar': range(42)}}
242610137d1f When an expression evaluates to a callable, it is called implicitly. cmlenz parents: 88 diff changeset	218
118 226613431921 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case). cmlenz parents: 102 diff changeset	219 def test_lambda(self):
226613431921 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case). cmlenz parents: 102 diff changeset	220 # Define a custom `sorted` function cause the builtin isn't available
226613431921 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case). cmlenz parents: 102 diff changeset	221 # on Python 2.3
226613431921 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case). cmlenz parents: 102 diff changeset	222 def sorted(items, compfunc):
226613431921 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case). cmlenz parents: 102 diff changeset	223 items.sort(compfunc)
226613431921 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case). cmlenz parents: 102 diff changeset	224 return items
226613431921 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case). cmlenz parents: 102 diff changeset	225 data = {'items': [{'name': 'b', 'value': 0}, {'name': 'a', 'value': 1}],
226613431921 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case). cmlenz parents: 102 diff changeset	226 'sorted': sorted}
226613431921 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case). cmlenz parents: 102 diff changeset	227 expr = Expression("sorted(items, lambda a, b: cmp(a.name, b.name))")
226613431921 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case). cmlenz parents: 102 diff changeset	228 self.assertEqual([{'name': 'a', 'value': 1}, {'name': 'b', 'value': 0}],
226613431921 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case). cmlenz parents: 102 diff changeset	229 expr.evaluate(data))
226613431921 Add basic support for using `lambda`s in expressions. Closes #21. (Not sure about default arguments, need a test case). cmlenz parents: 102 diff changeset	230
88 9ecae580dd93 Add support for list comprehension in expressions (see #12). cmlenz parents: 87 diff changeset	231 def test_list_comprehension(self):
9ecae580dd93 Add support for list comprehension in expressions (see #12). cmlenz parents: 87 diff changeset	232 expr = Expression("[n for n in numbers if n < 2]")
9ecae580dd93 Add support for list comprehension in expressions (see #12). cmlenz parents: 87 diff changeset	233 self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
9ecae580dd93 Add support for list comprehension in expressions (see #12). cmlenz parents: 87 diff changeset	234
9ecae580dd93 Add support for list comprehension in expressions (see #12). cmlenz parents: 87 diff changeset	235 expr = Expression("[(i, n + 1) for i, n in enumerate(numbers)]")
9ecae580dd93 Add support for list comprehension in expressions (see #12). cmlenz parents: 87 diff changeset	236 self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
9ecae580dd93 Add support for list comprehension in expressions (see #12). cmlenz parents: 87 diff changeset	237 expr.evaluate({'numbers': range(5)}))
9ecae580dd93 Add support for list comprehension in expressions (see #12). cmlenz parents: 87 diff changeset	238
9ecae580dd93 Add support for list comprehension in expressions (see #12). cmlenz parents: 87 diff changeset	239 expr = Expression("[offset + n for n in numbers]")
9ecae580dd93 Add support for list comprehension in expressions (see #12). cmlenz parents: 87 diff changeset	240 self.assertEqual([2, 3, 4, 5, 6],
9ecae580dd93 Add support for list comprehension in expressions (see #12). cmlenz parents: 87 diff changeset	241 expr.evaluate({'numbers': range(5), 'offset': 2}))
81 cc034182061e Template expressions are now compiled to Python bytecode. cmlenz parents: 66 diff changeset	242
131 203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	243 def test_list_comprehension_with_getattr(self):
203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	244 items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	245 expr = Expression("[i.name for i in items if i.value > 1]")
203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	246 self.assertEqual(['b'], expr.evaluate({'items': items}))
203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	247
203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	248 def test_list_comprehension_with_getitem(self):
203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	249 items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	250 expr = Expression("[i['name'] for i in items if i['value'] > 1]")
203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	251 self.assertEqual(['b'], expr.evaluate({'items': items}))
203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	252
198 d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	253 # generator expressions only supported in Python 2.4 and up
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	254 if sys.version_info >= (2, 4):
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	255 def test_generator_expression(self):
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	256 expr = Expression("list(n for n in numbers if n < 2)")
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	257 self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	258
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	259 expr = Expression("list((i, n + 1) for i, n in enumerate(numbers))")
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	260 self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	261 expr.evaluate({'numbers': range(5)}))
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	262
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	263 expr = Expression("list(offset + n for n in numbers)")
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	264 self.assertEqual([2, 3, 4, 5, 6],
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	265 expr.evaluate({'numbers': range(5), 'offset': 2}))
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	266
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	267 def test_generator_expression_with_getattr(self):
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	268 items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	269 expr = Expression("list(i.name for i in items if i.value > 1)")
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	270 self.assertEqual(['b'], expr.evaluate({'items': items}))
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	271
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	272 def test_generator_expression_with_getitem(self):
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	273 items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	274 expr = Expression("list(i['name'] for i in items if i['value'] > 1)")
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	275 self.assertEqual(['b'], expr.evaluate({'items': items}))
d7c0a7d65783 Implemented support for generator expressions (fixes #16) mgood parents: 195 diff changeset	276
225 0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	277 def test_slice(self):
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	278 expr = Expression("numbers[0:2]")
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	279 self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	280
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	281 def test_slice_with_vars(self):
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	282 expr = Expression("numbers[start:end]")
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	283 self.assertEqual([0, 1], expr.evaluate({'numbers': range(5), 'start': 0, 'end': 2}))
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	284
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	285 def test_slice_copy(self):
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	286 expr = Expression("numbers[:]")
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	287 self.assertEqual([0, 1, 2, 3, 4], expr.evaluate({'numbers': range(5)}))
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	288
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	289 def test_slice_stride(self):
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	290 expr = Expression("numbers[::stride]")
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	291 self.assertEqual([0, 2, 4], expr.evaluate({'numbers': range(5), 'stride': 2}))
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	292
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	293 def test_slice_negative_start(self):
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	294 expr = Expression("numbers[-1:]")
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	295 self.assertEqual([4], expr.evaluate({'numbers': range(5)}))
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	296
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	297 def test_slice_negative_end(self):
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	298 expr = Expression("numbers[:-1]")
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	299 self.assertEqual([0, 1, 2, 3], expr.evaluate({'numbers': range(5)}))
0edf663b97d6 support slices in expressions (fixes #51) mgood parents: 203 diff changeset	300
194 eb5c8200f49b Fix regression introduced in [242]: any reference to an undefined name would result in a `NameError`. cmlenz parents: 192 diff changeset	301 def test_error_access_undefined(self):
eb5c8200f49b Fix regression introduced in [242]: any reference to an undefined name would result in a `NameError`. cmlenz parents: 192 diff changeset	302 expr = Expression("nothing", filename='index.html', lineno=50)
eb5c8200f49b Fix regression introduced in [242]: any reference to an undefined name would result in a `NameError`. cmlenz parents: 192 diff changeset	303 self.assertEqual(Undefined, type(expr.evaluate({})))
eb5c8200f49b Fix regression introduced in [242]: any reference to an undefined name would result in a `NameError`. cmlenz parents: 192 diff changeset	304
192 cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	305 def test_error_call_undefined(self):
131 203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	306 expr = Expression("nothing()", filename='index.html', lineno=50)
203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	307 try:
203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	308 expr.evaluate({})
192 cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	309 self.fail('Expected NameError')
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	310 except NameError, e:
131 203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	311 exc_type, exc_value, exc_traceback = sys.exc_info()
203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	312 frame = exc_traceback.tb_next
192 cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	313 frames = []
131 203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	314 while frame.tb_next:
203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	315 frame = frame.tb_next
192 cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	316 frames.append(frame)
134 df44110ca91d * Improve the accuracy of line numbers for text nodes, so that reported errors about syntax or evaluation errors in expressions point to the right line (not quite perfect yet, though). cmlenz parents: 131 diff changeset	317 self.assertEqual('<Expression "nothing()">',
192 cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	318 frames[-3].tb_frame.f_code.co_name)
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	319 self.assertEqual('index.html',
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	320 frames[-3].tb_frame.f_code.co_filename)
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	321 self.assertEqual(50, frames[-3].tb_lineno)
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	322
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	323 def test_error_getattr_undefined(self):
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	324 expr = Expression("nothing.nil", filename='index.html', lineno=50)
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	325 try:
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	326 expr.evaluate({})
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	327 self.fail('Expected NameError')
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	328 except NameError, e:
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	329 exc_type, exc_value, exc_traceback = sys.exc_info()
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	330 frame = exc_traceback.tb_next
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	331 frames = []
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	332 while frame.tb_next:
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	333 frame = frame.tb_next
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	334 frames.append(frame)
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	335 self.assertEqual('<Expression "nothing.nil">',
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	336 frames[-3].tb_frame.f_code.co_name)
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	337 self.assertEqual('index.html',
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	338 frames[-3].tb_frame.f_code.co_filename)
cda3bdfc19ed Expression evaluation now differentiates between undefined variables and variables that are defined but set to `None`. cmlenz parents: 180 diff changeset	339 self.assertEqual(50, frames[-3].tb_lineno)
131 203f459e7e26 * Support for line numbers in exceptions in expression evaluation (#22). cmlenz parents: 118 diff changeset	340
30 2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	341
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	342 def suite():
821114ec4f69 Initial import. cmlenz parents: diff changeset	343 suite = unittest.TestSuite()
30 2ee9f28e16e5 Experimental support for using the new native AST in Python 2.5 instead of the `compiler` package. cmlenz parents: 27 diff changeset	344 suite.addTest(unittest.makeSuite(ExpressionTestCase, 'test'))
27 b8456279c444 * Fix the boilerplate in the Python source files. cmlenz parents: 1 diff changeset	345 suite.addTest(doctest.DocTestSuite(Expression.__module__))
1 821114ec4f69 Initial import. cmlenz parents: diff changeset	346 return suite
821114ec4f69 Initial import. cmlenz parents: diff changeset	347
821114ec4f69 Initial import. cmlenz parents: diff changeset	348 if __name__ == '__main__':
821114ec4f69 Initial import. cmlenz parents: diff changeset	349 unittest.main(defaultTest='suite')

Mercurial > genshi > genshi-test

annotate markup/tests/eval.py @ 226:09f869a98149