Edgewall Software

source: trunk/genshi/template/tests/eval.py

Last change on this file was 1250, checked in by hodgestar, 10 years ago

Add support for kwonlyargs and kw_defaults attributes of AST argument nodes.
  • Property svn:eol-style set to native
File size: 31.2 KB
Line 
1# -*- coding: utf-8 -*-
2#
3# Copyright (C) 2006-2010 Edgewall Software
4# All rights reserved.
5#
6# This software is licensed as described in the file COPYING, which
7# you should have received as part of this distribution. The terms
8# are also available at http://genshi.edgewall.org/wiki/License.
9#
10# This software consists of voluntary contributions made by many
11# individuals. For the exact contribution history, see the revision
12# history and logs, available at http://genshi.edgewall.org/log/.
13
14import doctest
15import os
16import pickle
17import sys
18from tempfile import mkstemp
19import unittest
20
21from genshi.core import Markup
22from genshi.template.base import Context
23from genshi.template.eval import Expression, Suite, Undefined, UndefinedError, \
24                                 UNDEFINED
25from genshi.compat import BytesIO, IS_PYTHON2, wrapped_bytes
26
27
28class ExpressionTestCase(unittest.TestCase):
29
30    def test_eq(self):
31        expr = Expression('x,y')
32        self.assertEqual(expr, Expression('x,y'))
33        self.assertNotEqual(expr, Expression('y, x'))
34
35    def test_hash(self):
36        expr = Expression('x,y')
37        self.assertEqual(hash(expr), hash(Expression('x,y')))
38        self.assertNotEqual(hash(expr), hash(Expression('y, x')))
39
40    def test_pickle(self):
41        expr = Expression('1 < 2')
42        buf = BytesIO()
43        pickle.dump(expr, buf, 2)
44        buf.seek(0)
45        unpickled = pickle.load(buf)
46        assert unpickled.evaluate({}) is True
47
48    def test_name_lookup(self):
49        self.assertEqual('bar', Expression('foo').evaluate({'foo': 'bar'}))
50        self.assertEqual(id, Expression('id').evaluate({}))
51        self.assertEqual('bar', Expression('id').evaluate({'id': 'bar'}))
52        self.assertEqual(None, Expression('id').evaluate({'id': None}))
53
54    def test_builtins(self):
55        expr = Expression('Markup')
56        self.assertEqual(expr.evaluate({}), Markup)
57
58    def test_str_literal(self):
59        self.assertEqual('foo', Expression('"foo"').evaluate({}))
60        self.assertEqual('foo', Expression('"""foo"""').evaluate({}))
61        self.assertEqual(u'foo'.encode('utf-8'),
62                         Expression(wrapped_bytes("b'foo'")).evaluate({}))
63        self.assertEqual('foo', Expression("'''foo'''").evaluate({}))
64        self.assertEqual('foo', Expression("u'foo'").evaluate({}))
65        self.assertEqual('foo', Expression("r'foo'").evaluate({}))
66
67    def test_str_literal_non_ascii(self):
68        expr = Expression(u"u'\xfe'")
69        self.assertEqual(u'þ', expr.evaluate({}))
70        expr = Expression("u'\xfe'")
71        self.assertEqual(u'þ', expr.evaluate({}))
72        # On Python2 strings are converted to unicode if they contained
73        # non-ASCII characters.
74        # On Py3k, we have no need to do this as non-prefixed strings aren't
75        # raw.
76        expr = Expression(wrapped_bytes(r"b'\xc3\xbe'"))
77        if IS_PYTHON2:
78            self.assertEqual(u'þ', expr.evaluate({}))
79        else:
80            self.assertEqual(u'þ'.encode('utf-8'), expr.evaluate({}))
81
82    def test_num_literal(self):
83        self.assertEqual(42, Expression("42").evaluate({}))
84        if IS_PYTHON2:
85            self.assertEqual(42L, Expression("42L").evaluate({}))
86        self.assertEqual(.42, Expression(".42").evaluate({}))
87        if IS_PYTHON2:
88            self.assertEqual(07, Expression("07").evaluate({}))
89        self.assertEqual(0xF2, Expression("0xF2").evaluate({}))
90        self.assertEqual(0XF2, Expression("0XF2").evaluate({}))
91
92    def test_dict_literal(self):
93        self.assertEqual({}, Expression("{}").evaluate({}))
94        self.assertEqual({'key': True},
95                         Expression("{'key': value}").evaluate({'value': True}))
96
97    def test_list_literal(self):
98        self.assertEqual([], Expression("[]").evaluate({}))
99        self.assertEqual([1, 2, 3], Expression("[1, 2, 3]").evaluate({}))
100        self.assertEqual([True],
101                         Expression("[value]").evaluate({'value': True}))
102
103    def test_tuple_literal(self):
104        self.assertEqual((), Expression("()").evaluate({}))
105        self.assertEqual((1, 2, 3), Expression("(1, 2, 3)").evaluate({}))
106        self.assertEqual((True,),
107                         Expression("(value,)").evaluate({'value': True}))
108
109    def test_unaryop_pos(self):
110        self.assertEqual(1, Expression("+1").evaluate({}))
111        self.assertEqual(1, Expression("+x").evaluate({'x': 1}))
112
113    def test_unaryop_neg(self):
114        self.assertEqual(-1, Expression("-1").evaluate({}))
115        self.assertEqual(-1, Expression("-x").evaluate({'x': 1}))
116
117    def test_unaryop_not(self):
118        self.assertEqual(False, Expression("not True").evaluate({}))
119        self.assertEqual(False, Expression("not x").evaluate({'x': True}))
120
121    def test_unaryop_inv(self):
122        self.assertEqual(-2, Expression("~1").evaluate({}))
123        self.assertEqual(-2, Expression("~x").evaluate({'x': 1}))
124
125    def test_binop_add(self):
126        self.assertEqual(3, Expression("2 + 1").evaluate({}))
127        self.assertEqual(3, Expression("x + y").evaluate({'x': 2, 'y': 1}))
128
129    def test_binop_sub(self):
130        self.assertEqual(1, Expression("2 - 1").evaluate({}))
131        self.assertEqual(1, Expression("x - y").evaluate({'x': 1, 'y': 1}))
132
133    def test_binop_sub(self):
134        self.assertEqual(1, Expression("2 - 1").evaluate({}))
135        self.assertEqual(1, Expression("x - y").evaluate({'x': 2, 'y': 1}))
136
137    def test_binop_mul(self):
138        self.assertEqual(4, Expression("2 * 2").evaluate({}))
139        self.assertEqual(4, Expression("x * y").evaluate({'x': 2, 'y': 2}))
140
141    def test_binop_pow(self):
142        self.assertEqual(4, Expression("2 ** 2").evaluate({}))
143        self.assertEqual(4, Expression("x ** y").evaluate({'x': 2, 'y': 2}))
144
145    def test_binop_div(self):
146        self.assertEqual(2, Expression("4 / 2").evaluate({}))
147        self.assertEqual(2, Expression("x / y").evaluate({'x': 4, 'y': 2}))
148
149    def test_binop_floordiv(self):
150        self.assertEqual(1, Expression("3 // 2").evaluate({}))
151        self.assertEqual(1, Expression("x // y").evaluate({'x': 3, 'y': 2}))
152
153    def test_binop_mod(self):
154        self.assertEqual(1, Expression("3 % 2").evaluate({}))
155        self.assertEqual(1, Expression("x % y").evaluate({'x': 3, 'y': 2}))
156
157    def test_binop_and(self):
158        self.assertEqual(0, Expression("1 & 0").evaluate({}))
159        self.assertEqual(0, Expression("x & y").evaluate({'x': 1, 'y': 0}))
160
161    def test_binop_or(self):
162        self.assertEqual(1, Expression("1 | 0").evaluate({}))
163        self.assertEqual(1, Expression("x | y").evaluate({'x': 1, 'y': 0}))
164
165    def test_binop_xor(self):
166        self.assertEqual(1, Expression("1 ^ 0").evaluate({}))
167        self.assertEqual(1, Expression("x ^ y").evaluate({'x': 1, 'y': 0}))
168
169    def test_binop_contains(self):
170        self.assertEqual(True, Expression("1 in (1, 2, 3)").evaluate({}))
171        self.assertEqual(True, Expression("x in y").evaluate({'x': 1,
172                                                              'y': (1, 2, 3)}))
173
174    def test_binop_not_contains(self):
175        self.assertEqual(True, Expression("4 not in (1, 2, 3)").evaluate({}))
176        self.assertEqual(True, Expression("x not in y").evaluate({'x': 4,
177                                                                  'y': (1, 2, 3)}))
178
179    def test_binop_is(self):
180        self.assertEqual(True, Expression("1 is 1").evaluate({}))
181        self.assertEqual(True, Expression("x is y").evaluate({'x': 1, 'y': 1}))
182        self.assertEqual(False, Expression("1 is 2").evaluate({}))
183        self.assertEqual(False, Expression("x is y").evaluate({'x': 1, 'y': 2}))
184
185    def test_binop_is_not(self):
186        self.assertEqual(True, Expression("1 is not 2").evaluate({}))
187        self.assertEqual(True, Expression("x is not y").evaluate({'x': 1,
188                                                                  'y': 2}))
189        self.assertEqual(False, Expression("1 is not 1").evaluate({}))
190        self.assertEqual(False, Expression("x is not y").evaluate({'x': 1,
191                                                                   'y': 1}))
192
193    def test_boolop_and(self):
194        self.assertEqual(False, Expression("True and False").evaluate({}))
195        self.assertEqual(False, Expression("x and y").evaluate({'x': True,
196                                                                'y': False}))
197
198    def test_boolop_or(self):
199        self.assertEqual(True, Expression("True or False").evaluate({}))
200        self.assertEqual(True, Expression("x or y").evaluate({'x': True,
201                                                              'y': False}))
202
203    def test_compare_eq(self):
204        self.assertEqual(True, Expression("1 == 1").evaluate({}))
205        self.assertEqual(True, Expression("x == y").evaluate({'x': 1, 'y': 1}))
206
207    def test_compare_ne(self):
208        self.assertEqual(False, Expression("1 != 1").evaluate({}))
209        self.assertEqual(False, Expression("x != y").evaluate({'x': 1, 'y': 1}))
210        if sys.version < '3':
211            self.assertEqual(False, Expression("1 <> 1").evaluate({}))
212            self.assertEqual(False, Expression("x <> y").evaluate({'x': 1, 'y': 1}))
213
214    def test_compare_lt(self):
215        self.assertEqual(True, Expression("1 < 2").evaluate({}))
216        self.assertEqual(True, Expression("x < y").evaluate({'x': 1, 'y': 2}))
217
218    def test_compare_le(self):
219        self.assertEqual(True, Expression("1 <= 1").evaluate({}))
220        self.assertEqual(True, Expression("x <= y").evaluate({'x': 1, 'y': 1}))
221
222    def test_compare_gt(self):
223        self.assertEqual(True, Expression("2 > 1").evaluate({}))
224        self.assertEqual(True, Expression("x > y").evaluate({'x': 2, 'y': 1}))
225
226    def test_compare_ge(self):
227        self.assertEqual(True, Expression("1 >= 1").evaluate({}))
228        self.assertEqual(True, Expression("x >= y").evaluate({'x': 1, 'y': 1}))
229
230    def test_compare_multi(self):
231        self.assertEqual(True, Expression("1 != 3 == 3").evaluate({}))
232        self.assertEqual(True, Expression("x != y == y").evaluate({'x': 1,
233                                                                   'y': 3}))
234
235    def test_call_function(self):
236        self.assertEqual(42, Expression("foo()").evaluate({'foo': lambda: 42}))
237        data = {'foo': 'bar'}
238        self.assertEqual('BAR', Expression("foo.upper()").evaluate(data))
239        data = {'foo': {'bar': range(42)}}
240        self.assertEqual(42, Expression("len(foo.bar)").evaluate(data))
241
242    def test_call_keywords(self):
243        self.assertEqual(42, Expression("foo(x=bar)").evaluate({'foo': lambda x: x,
244                                                                'bar': 42}))
245
246    def test_call_star_args(self):
247        self.assertEqual(42, Expression("foo(*bar)").evaluate({'foo': lambda x: x,
248                                                               'bar': [42]}))
249
250    def test_call_dstar_args(self):
251        def foo(x):
252            return x
253        expr = Expression("foo(**bar)")
254        self.assertEqual(42, expr.evaluate({'foo': foo, 'bar': {"x": 42}}))
255
256    def test_lambda(self):
257        data = {'items': range(5)}
258        expr = Expression("filter(lambda x: x > 2, items)")
259        self.assertEqual([3, 4], list(expr.evaluate(data)))
260
261    def test_lambda_tuple_arg(self):
262        # This syntax goes away in Python 3
263        if not IS_PYTHON2:
264            return
265        data = {'items': [(1, 2), (2, 1)]}
266        expr = Expression("filter(lambda (x, y): x > y, items)")
267        self.assertEqual([(2, 1)], list(expr.evaluate(data)))
268
269    def test_list_comprehension(self):
270        expr = Expression("[n for n in numbers if n < 2]")
271        self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
272
273        expr = Expression("[(i, n + 1) for i, n in enumerate(numbers)]")
274        self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
275                         expr.evaluate({'numbers': range(5)}))
276
277        expr = Expression("[offset + n for n in numbers]")
278        self.assertEqual([2, 3, 4, 5, 6],
279                         expr.evaluate({'numbers': range(5), 'offset': 2}))
280
281        expr = Expression("[n for group in groups for n in group]")
282        self.assertEqual([0, 1, 0, 1, 2],
283                         expr.evaluate({'groups': [range(2), range(3)]}))
284
285        expr = Expression("[(a, b) for a in x for b in y]")
286        self.assertEqual([('x0', 'y0'), ('x0', 'y1'), ('x1', 'y0'), ('x1', 'y1')],
287                         expr.evaluate({'x': ['x0', 'x1'], 'y': ['y0', 'y1']}))
288
289    def test_list_comprehension_with_getattr(self):
290        items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
291        expr = Expression("[i.name for i in items if i.value > 1]")
292        self.assertEqual(['b'], expr.evaluate({'items': items}))
293
294    def test_list_comprehension_with_getitem(self):
295        items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
296        expr = Expression("[i['name'] for i in items if i['value'] > 1]")
297        self.assertEqual(['b'], expr.evaluate({'items': items}))
298
299    def test_generator_expression(self):
300        expr = Expression("list(n for n in numbers if n < 2)")
301        self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
302
303        expr = Expression("list((i, n + 1) for i, n in enumerate(numbers))")
304        self.assertEqual([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
305                         expr.evaluate({'numbers': range(5)}))
306
307        expr = Expression("list(offset + n for n in numbers)")
308        self.assertEqual([2, 3, 4, 5, 6],
309                         expr.evaluate({'numbers': range(5), 'offset': 2}))
310
311        expr = Expression("list(n for group in groups for n in group)")
312        self.assertEqual([0, 1, 0, 1, 2],
313                         expr.evaluate({'groups': [range(2), range(3)]}))
314
315        expr = Expression("list((a, b) for a in x for b in y)")
316        self.assertEqual([('x0', 'y0'), ('x0', 'y1'), ('x1', 'y0'), ('x1', 'y1')],
317                         expr.evaluate({'x': ['x0', 'x1'], 'y': ['y0', 'y1']}))
318
319    def test_generator_expression_with_getattr(self):
320        items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
321        expr = Expression("list(i.name for i in items if i.value > 1)")
322        self.assertEqual(['b'], expr.evaluate({'items': items}))
323
324    def test_generator_expression_with_getitem(self):
325        items = [{'name': 'a', 'value': 1}, {'name': 'b', 'value': 2}]
326        expr = Expression("list(i['name'] for i in items if i['value'] > 1)")
327        self.assertEqual(['b'], expr.evaluate({'items': items}))
328
329    if sys.version_info >= (2, 5):
330        def test_conditional_expression(self):
331            expr = Expression("'T' if foo else 'F'")
332            self.assertEqual('T', expr.evaluate({'foo': True}))
333            self.assertEqual('F', expr.evaluate({'foo': False}))
334
335    def test_slice(self):
336        expr = Expression("numbers[0:2]")
337        self.assertEqual([0, 1], expr.evaluate({'numbers': range(5)}))
338
339    def test_slice_with_vars(self):
340        expr = Expression("numbers[start:end]")
341        self.assertEqual([0, 1], expr.evaluate({'numbers': range(5), 'start': 0,
342                                                'end': 2}))
343
344    def test_slice_copy(self):
345        expr = Expression("numbers[:]")
346        self.assertEqual([0, 1, 2, 3, 4], expr.evaluate({'numbers': range(5)}))
347
348    def test_slice_stride(self):
349        expr = Expression("numbers[::stride]")
350        self.assertEqual([0, 2, 4], expr.evaluate({'numbers': range(5),
351                                                   'stride': 2}))
352
353    def test_slice_negative_start(self):
354        expr = Expression("numbers[-1:]")
355        self.assertEqual([4], expr.evaluate({'numbers': range(5)}))
356
357    def test_slice_negative_end(self):
358        expr = Expression("numbers[:-1]")
359        self.assertEqual([0, 1, 2, 3], expr.evaluate({'numbers': range(5)}))
360
361    def test_access_undefined(self):
362        expr = Expression("nothing", filename='index.html', lineno=50,
363                          lookup='lenient')
364        retval = expr.evaluate({})
365        assert isinstance(retval, Undefined)
366        self.assertEqual('nothing', retval._name)
367        assert retval._owner is UNDEFINED
368
369    def test_getattr_undefined(self):
370        class Something(object):
371            def __repr__(self):
372                return '<Something>'
373        something = Something()
374        expr = Expression('something.nil', filename='index.html', lineno=50,
375                          lookup='lenient')
376        retval = expr.evaluate({'something': something})
377        assert isinstance(retval, Undefined)
378        self.assertEqual('nil', retval._name)
379        assert retval._owner is something
380
381    def test_getattr_exception(self):
382        class Something(object):
383            def prop_a(self):
384                raise NotImplementedError
385            prop_a = property(prop_a)
386            def prop_b(self):
387                raise AttributeError
388            prop_b = property(prop_b)
389        self.assertRaises(NotImplementedError,
390                          Expression('s.prop_a').evaluate, {'s': Something()})
391        self.assertRaises(AttributeError,
392                          Expression('s.prop_b').evaluate, {'s': Something()})
393
394    def test_getitem_undefined_string(self):
395        class Something(object):
396            def __repr__(self):
397                return '<Something>'
398        something = Something()
399        expr = Expression('something["nil"]', filename='index.html', lineno=50,
400                          lookup='lenient')
401        retval = expr.evaluate({'something': something})
402        assert isinstance(retval, Undefined)
403        self.assertEqual('nil', retval._name)
404        assert retval._owner is something
405
406    def test_getitem_exception(self):
407        class Something(object):
408            def __getitem__(self, key):
409                raise NotImplementedError
410        self.assertRaises(NotImplementedError,
411                          Expression('s["foo"]').evaluate, {'s': Something()})
412
413    def test_error_access_undefined(self):
414        expr = Expression("nothing", filename='index.html', lineno=50,
415                          lookup='strict')
416        try:
417            expr.evaluate({})
418            self.fail('Expected UndefinedError')
419        except UndefinedError, e:
420            exc_type, exc_value, exc_traceback = sys.exc_info()
421            frame = exc_traceback.tb_next
422            frames = []
423            while frame.tb_next:
424                frame = frame.tb_next
425                frames.append(frame)
426            self.assertEqual('"nothing" not defined', str(e))
427            self.assertEqual("<Expression 'nothing'>",
428                             frames[-3].tb_frame.f_code.co_name)
429            self.assertEqual('index.html',
430                             frames[-3].tb_frame.f_code.co_filename)
431            self.assertEqual(50, frames[-3].tb_lineno)
432
433    def test_error_getattr_undefined(self):
434        class Something(object):
435            def __repr__(self):
436                return '<Something>'
437        expr = Expression('something.nil', filename='index.html', lineno=50,
438                          lookup='strict')
439        try:
440            expr.evaluate({'something': Something()})
441            self.fail('Expected UndefinedError')
442        except UndefinedError, e:
443            self.assertEqual('<Something> has no member named "nil"', str(e))
444            exc_type, exc_value, exc_traceback = sys.exc_info()
445            search_string = "<Expression 'something.nil'>"
446            frame = exc_traceback.tb_next
447            while frame.tb_next:
448                frame = frame.tb_next
449                code = frame.tb_frame.f_code
450                if code.co_name == search_string:
451                    break
452            else:
453                self.fail("never found the frame I was looking for")
454            self.assertEqual('index.html', code.co_filename)
455            self.assertEqual(50, frame.tb_lineno)
456
457    def test_error_getitem_undefined_string(self):
458        class Something(object):
459            def __repr__(self):
460                return '<Something>'
461        expr = Expression('something["nil"]', filename='index.html', lineno=50,
462                          lookup='strict')
463        try:
464            expr.evaluate({'something': Something()})
465            self.fail('Expected UndefinedError')
466        except UndefinedError, e:
467            self.assertEqual('<Something> has no member named "nil"', str(e))
468            exc_type, exc_value, exc_traceback = sys.exc_info()
469            search_string = '''<Expression 'something["nil"]'>'''
470            frame = exc_traceback.tb_next
471            while frame.tb_next:
472                frame = frame.tb_next
473                code = frame.tb_frame.f_code
474                if code.co_name == search_string:
475                    break
476            else:
477                self.fail("never found the frame I was looking for")
478            self.assertEqual('index.html', code.co_filename)
479            self.assertEqual(50, frame.tb_lineno)
480
481
482class SuiteTestCase(unittest.TestCase):
483
484    def test_pickle(self):
485        suite = Suite('foo = 42')
486        buf = BytesIO()
487        pickle.dump(suite, buf, 2)
488        buf.seek(0)
489        unpickled = pickle.load(buf)
490        data = {}
491        unpickled.execute(data)
492        self.assertEqual(42, data['foo'])
493
494    def test_internal_shadowing(self):
495        # The context itself is stored in the global execution scope of a suite
496        # It used to get stored under the name 'data', which meant the
497        # following test would fail, as the user defined 'data' variable
498        # shadowed the Genshi one. We now use the name '__data__' to avoid
499        # conflicts
500        suite = Suite("""data = []
501bar = foo
502""")
503        data = {'foo': 42}
504        suite.execute(data)
505        self.assertEqual(42, data['bar'])
506
507    def test_assign(self):
508        suite = Suite("foo = 42")
509        data = {}
510        suite.execute(data)
511        self.assertEqual(42, data['foo'])
512
513    def test_def(self):
514        suite = Suite("def donothing(): pass")
515        data = {}
516        suite.execute(data)
517        assert 'donothing' in data
518        self.assertEqual(None, data['donothing']())
519
520    def test_def_with_multiple_statements(self):
521        suite = Suite("""
522def donothing():
523    if True:
524        return foo
525""")
526        data = {'foo': 'bar'}
527        suite.execute(data)
528        assert 'donothing' in data
529        self.assertEqual('bar', data['donothing']())
530
531    def test_def_using_nonlocal(self):
532        suite = Suite("""
533values = []
534def add(value):
535    if value not in values:
536        values.append(value)
537add('foo')
538add('bar')
539""")
540        data = {}
541        suite.execute(data)
542        self.assertEqual(['foo', 'bar'], data['values'])
543
544    def test_def_some_defaults(self):
545        suite = Suite("""
546def difference(v1, v2=10):
547    return v1 - v2
548x = difference(20, 19)
549y = difference(20)
550""")
551        data = {}
552        suite.execute(data)
553        self.assertEqual(1, data['x'])
554        self.assertEqual(10, data['y'])
555
556    def test_def_all_defaults(self):
557        suite = Suite("""
558def difference(v1=100, v2=10):
559    return v1 - v2
560x = difference(20, 19)
561y = difference(20)
562z = difference()
563""")
564        data = {}
565        suite.execute(data)
566        self.assertEqual(1, data['x'])
567        self.assertEqual(10, data['y'])
568        self.assertEqual(90, data['z'])
569
570    def test_def_vararg(self):
571        suite = Suite("""
572def mysum(*others):
573    rv = 0
574    for n in others:
575        rv = rv + n
576    return rv
577x = mysum(1, 2, 3)
578""")
579        data = {}
580        suite.execute(data)
581        self.assertEqual(6, data['x'])
582
583    def test_def_kwargs(self):
584        suite = Suite("""
585def smash(**kw):
586    return [''.join(i) for i in kw.items()]
587x = smash(foo='abc', bar='def')
588""")
589        data = {}
590        suite.execute(data)
591        self.assertEqual(['bardef', 'fooabc'], sorted(data['x']))
592
593    if not IS_PYTHON2:
594        def test_def_kwonlyarg(self):
595            suite = Suite("""
596def kwonly(*args, k):
597    return k
598x = kwonly(k="foo")
599""")
600            data = {}
601            suite.execute(data)
602            self.assertEqual("foo", data['x'])
603
604        def test_def_kwonlyarg_with_default(self):
605            suite = Suite("""
606def kwonly(*args, k="bar"):
607    return k
608x = kwonly(k="foo")
609y = kwonly()
610""")
611            data = {}
612            suite.execute(data)
613            self.assertEqual("foo", data['x'])
614            self.assertEqual("bar", data['y'])
615
616    def test_def_nested(self):
617        suite = Suite("""
618def doit():
619    values = []
620    def add(value):
621        if value not in values:
622            values.append(value)
623    add('foo')
624    add('bar')
625    return values
626x = doit()
627""")
628        data = {}
629        suite.execute(data)
630        self.assertEqual(['foo', 'bar'], data['x'])
631
632    def test_def_with_decorator(self):
633        suite = Suite("""
634def lower(fun):
635    return lambda: fun().lower()
636
637@lower
638def say_hi():
639    return 'Hi!'
640
641result = say_hi()
642""")
643        data = {}
644        suite.execute(data)
645        self.assertEqual('hi!', data['result'])
646
647    def test_delete(self):
648        suite = Suite("""foo = 42
649del foo
650""")
651        data = {}
652        suite.execute(data)
653        assert 'foo' not in data
654
655    def test_class(self):
656        suite = Suite("class plain(object): pass")
657        data = {}
658        suite.execute(data)
659        assert 'plain' in data
660
661    def test_class_in_def(self):
662        suite = Suite("""
663def create():
664    class Foobar(object):
665        def __str__(self):
666            return 'foobar'
667    return Foobar()
668x = create()
669""")
670        data = {}
671        suite.execute(data)
672        self.assertEqual('foobar', str(data['x']))
673
674    def test_class_with_methods(self):
675        suite = Suite("""class plain(object):
676    def donothing():
677        pass
678""")
679        data = {}
680        suite.execute(data)
681        assert 'plain' in data
682
683    def test_import(self):
684        suite = Suite("from itertools import repeat")
685        data = {}
686        suite.execute(data)
687        assert 'repeat' in data
688
689    def test_import_star(self):
690        suite = Suite("from itertools import *")
691        data = Context()
692        suite.execute(data)
693        assert 'repeat' in data
694
695    def test_import_in_def(self):
696        suite = Suite("""def fun():
697    from itertools import repeat
698    return repeat(1, 3)
699""")
700        data = Context()
701        suite.execute(data)
702        assert 'repeat' not in data
703        self.assertEqual([1, 1, 1], list(data['fun']()))
704
705    def test_for(self):
706        suite = Suite("""x = []
707for i in range(3):
708    x.append(i**2)
709""")
710        data = {}
711        suite.execute(data)
712        self.assertEqual([0, 1, 4], data['x'])
713
714    def test_for_in_def(self):
715        suite = Suite("""def loop():
716    for i in range(10):
717        if i == 5:
718            break
719    return i
720""")
721        data = {}
722        suite.execute(data)
723        assert 'loop' in data
724        self.assertEqual(5, data['loop']())
725
726    def test_if(self):
727        suite = Suite("""if foo == 42:
728    x = True
729""")
730        data = {'foo': 42}
731        suite.execute(data)
732        self.assertEqual(True, data['x'])
733
734    def test_raise(self):
735        suite = Suite("""raise NotImplementedError""")
736        self.assertRaises(NotImplementedError, suite.execute, {})
737
738    def test_try_except(self):
739        suite = Suite("""try:
740    import somemod
741except ImportError:
742    somemod = None
743else:
744    somemod.dosth()""")
745        data = {}
746        suite.execute(data)
747        self.assertEqual(None, data['somemod'])
748
749    def test_finally(self):
750        suite = Suite("""try:
751    x = 2
752finally:
753    x = None
754""")
755        data = {}
756        suite.execute(data)
757        self.assertEqual(None, data['x'])
758
759    def test_while_break(self):
760        suite = Suite("""x = 0
761while x < 5:
762    x += step
763    if x == 4:
764        break
765""")
766        data = {'step': 2}
767        suite.execute(data)
768        self.assertEqual(4, data['x'])
769
770    def test_augmented_attribute_assignment(self):
771        suite = Suite("d['k'] += 42")
772        d = {"k": 1}
773        suite.execute({"d": d})
774        self.assertEqual(43, d["k"])
775
776    def test_local_augmented_assign(self):
777        Suite("x = 1; x += 42; assert x == 43").execute({})
778
779    def test_augmented_assign_in_def(self):
780        d = {}
781        Suite("""def foo():
782    i = 1
783    i += 1
784    return i
785x = foo()""").execute(d)
786        self.assertEqual(2, d['x'])
787
788    def test_augmented_assign_in_loop_in_def(self):
789        d = {}
790        Suite("""def foo():
791    i = 0
792    for n in range(5):
793        i += n
794    return i
795x = foo()""").execute(d)
796        self.assertEqual(10, d['x'])
797
798    def test_assign_in_list(self):
799        suite = Suite("[d['k']] = 'foo',; assert d['k'] == 'foo'")
800        d = {"k": "bar"}
801        suite.execute({"d": d})
802        self.assertEqual("foo", d["k"])
803
804    def test_exec(self):
805        suite = Suite("x = 1; exec(d['k']); assert x == 42, x")
806        suite.execute({"d": {"k": "x = 42"}})
807
808    def test_return(self):
809        suite = Suite("""
810def f():
811    return v
812
813assert f() == 42
814""")
815        suite.execute({"v": 42})
816
817    def test_assign_to_dict_item(self):
818        suite = Suite("d['k'] = 'foo'")
819        data = {'d': {}}
820        suite.execute(data)
821        self.assertEqual('foo', data['d']['k'])
822
823    def test_assign_to_attribute(self):
824        class Something(object): pass
825        something = Something()
826        suite = Suite("obj.attr = 'foo'")
827        data = {"obj": something}
828        suite.execute(data)
829        self.assertEqual('foo', something.attr)
830
831    def test_delattr(self):
832        class Something(object):
833            def __init__(self):
834                self.attr = 'foo'
835        obj = Something()
836        Suite("del obj.attr").execute({'obj': obj})
837        self.failIf(hasattr(obj, 'attr'))
838
839    def test_delitem(self):
840        d = {'k': 'foo'}
841        Suite("del d['k']").execute({'d': d})
842        self.failIf('k' in d, repr(d))
843
844    if sys.version_info >= (2, 5):
845        def test_with_statement(self):
846            fd, path = mkstemp()
847            f = os.fdopen(fd, "w")
848            try:
849                f.write('foo\nbar\n')
850                f.seek(0)
851                f.close()
852
853                d = {'path': path}
854                suite = Suite("""from __future__ import with_statement
855lines = []
856with open(path) as file:
857    for line in file:
858        lines.append(line)
859""")
860                suite.execute(d)
861                self.assertEqual(['foo\n', 'bar\n'], d['lines'])
862            finally:
863                os.remove(path)
864
865        def test_yield_expression(self):
866            d = {}
867            suite = Suite("""from genshi.compat import next
868results = []
869def counter(maximum):
870    i = 0
871    while i < maximum:
872        val = (yield i)
873        if val is not None:
874            i = val
875        else:
876            i += 1
877it = counter(5)
878results.append(next(it))
879results.append(it.send(3))
880results.append(next(it))
881""")
882            suite.execute(d)
883            self.assertEqual([0, 3, 4], d['results'])
884
885    if sys.version_info >= (3, 3):
886        def test_with_statement_with_multiple_items(self):
887            fd, path = mkstemp()
888            f = os.fdopen(fd, "w")
889            try:
890                f.write('foo\n')
891                f.seek(0)
892                f.close()
893
894                d = {'path': path}
895                suite = Suite("""from __future__ import with_statement
896lines = []
897with open(path) as file1, open(path) as file2:
898    for line in file1:
899        lines.append(line)
900    for line in file2:
901        lines.append(line)
902""")
903                suite.execute(d)
904                self.assertEqual(['foo\n', 'foo\n'], d['lines'])
905            finally:
906                os.remove(path)
907
908
909def suite():
910    suite = unittest.TestSuite()
911    suite.addTest(doctest.DocTestSuite(Expression.__module__))
912    suite.addTest(unittest.makeSuite(ExpressionTestCase, 'test'))
913    suite.addTest(unittest.makeSuite(SuiteTestCase, 'test'))
914    return suite
915
916if __name__ == '__main__':
917    unittest.main(defaultTest='suite')
Note: See TracBrowser for help on using the repository browser.