root/galaxy-central/eggs/Cheetah-2.2.2-py2.6-macosx-10.6-universal-ucs2.egg/Cheetah/Tests/SyntaxAndOutput.py

リビジョン 3, 90.3 KB (コミッタ: kohda, 14 年 前)

Install Unix tools  http://hannonlab.cshl.edu/galaxy_unix_tools/galaxy.html

行番号 
1#!/usr/bin/env python
2# -*- coding: latin-1 -*-
3
4'''
5Syntax and Output tests.
6
7TODO
8- #finally
9- #filter
10- #errorCatcher
11- #echo
12- #silent
13'''
14
15
16##################################################
17## DEPENDENCIES ##
18
19import sys
20import types
21import re
22from copy import deepcopy
23import os
24import os.path
25import new
26import warnings
27import unittest
28
29from Cheetah.NameMapper import NotFound
30from Cheetah.NameMapper import C_VERSION as NameMapper_C_VERSION
31from Cheetah.Template import Template
32from Cheetah.Parser import ParseError
33from Cheetah.Compiler import Compiler, DEFAULT_COMPILER_SETTINGS
34
35class Unspecified(object):
36    pass
37
38majorVer, minorVer = sys.version_info[0], sys.version_info[1]
39versionTuple = (majorVer, minorVer)
40
41def testdecorator(func):
42    return func
43
44class DummyClass:
45    _called = False
46    def __str__(self):
47        return 'object'
48
49    def meth(self, arg="arff"):
50        return str(arg)
51
52    def meth1(self, arg="doo"):
53        return arg
54
55    def meth2(self, arg1="a1", arg2="a2"):
56        return str(arg1) + str(arg2)
57
58    def methWithPercentSignDefaultArg(self, arg1="110%"):
59        return str(arg1)
60
61    def callIt(self, arg=1234):
62        self._called = True
63        self._callArg = arg
64       
65
66def dummyFunc(arg="Scooby"):
67    return arg
68
69defaultTestNameSpace = {
70    'aStr':'blarg',
71    'anInt':1,
72    'aFloat':1.5,
73    'aList': ['item0','item1','item2'],
74    'aDict': {'one':'item1',
75              'two':'item2',
76              'nestedDict':{1:'nestedItem1',
77                          'two':'nestedItem2'
78                          },
79              'nestedFunc':dummyFunc,
80              },
81    'aFunc': dummyFunc,
82    'anObj': DummyClass(),
83    'aMeth': DummyClass().meth1,
84    'aStrToBeIncluded': "$aStr $anInt",
85    'none' : None, 
86    'emptyString':'',
87    'numOne':1,
88    'numTwo':2,
89    'zero':0,
90    'tenDigits': 1234567890,
91    'webSafeTest': 'abc <=> &',
92    'strip1': '  \t   strippable whitespace   \t\t  \n',
93    'strip2': '  \t   strippable whitespace   \t\t  ',
94    'strip3': '  \t   strippable whitespace   \t\t\n1 2  3\n',
95   
96    'blockToBeParsed':"""$numOne $numTwo""",
97    'includeBlock2':"""$numOne $numTwo $aSetVar""",
98   
99    'includeFileName':'parseTest.txt',
100    'listOfLambdas':[lambda x: x, lambda x: x, lambda x: x,],
101    'list': [
102        {'index': 0, 'numOne': 1, 'numTwo': 2},
103        {'index': 1, 'numOne': 1, 'numTwo': 2},
104        ],
105    'nameList': [('john', 'doe'), ('jane', 'smith')],
106    'letterList': ['a', 'b', 'c'],
107    '_': lambda x: 'Translated: ' + x,
108    'unicodeData':u'aoeu12345\u1234',
109    }
110
111
112##################################################
113## TEST BASE CLASSES
114
115class OutputTest(unittest.TestCase):
116    report = '''
117Template output mismatch:
118
119    Input Template =
120%(template)s%(end)s
121
122    Expected Output =
123%(expected)s%(end)s
124
125    Actual Output =
126%(actual)s%(end)s'''
127
128    convertEOLs = True
129    _EOLreplacement = None
130    _debugEOLReplacement = False
131
132    DEBUGLEV = 0
133    _searchList = [defaultTestNameSpace]
134
135    _useNewStyleCompilation = True
136    #_useNewStyleCompilation = False
137
138    _extraCompileKwArgs = None
139
140    def searchList(self):
141        return self._searchList
142
143    def verify(self, input, expectedOutput,
144               inputEncoding=None,
145               outputEncoding=None,
146               convertEOLs=Unspecified):
147        if self._EOLreplacement:
148            if convertEOLs is Unspecified:
149                convertEOLs = self.convertEOLs
150            if convertEOLs:
151                input = input.replace('\n', self._EOLreplacement)
152                expectedOutput = expectedOutput.replace('\n', self._EOLreplacement)
153
154        self._input = input
155        if self._useNewStyleCompilation:
156            extraKwArgs = self._extraCompileKwArgs or {}
157           
158            templateClass = Template.compile(
159                source=input,
160                compilerSettings=self._getCompilerSettings(),
161                keepRefToGeneratedCode=True,
162                **extraKwArgs
163                )
164            moduleCode = templateClass._CHEETAH_generatedModuleCode
165            self.template = templateObj = templateClass(searchList=self.searchList())
166        else:
167            self.template = templateObj = Template(
168                input,
169                searchList=self.searchList(),
170                compilerSettings=self._getCompilerSettings(),
171                )
172            moduleCode = templateObj._CHEETAH_generatedModuleCode
173        if self.DEBUGLEV >= 1:
174            print moduleCode
175        try:
176            output = templateObj.respond() # rather than __str__, because of unicode
177            assert output==expectedOutput, self._outputMismatchReport(output, expectedOutput)
178        finally:
179            templateObj.shutdown()
180
181    def _getCompilerSettings(self):
182        return {}
183           
184    def _outputMismatchReport(self, output, expectedOutput):
185        if self._debugEOLReplacement and self._EOLreplacement:
186            EOLrepl = self._EOLreplacement
187            marker = '*EOL*'
188            return self.report % {'template': self._input.replace(EOLrepl,marker),
189                                  'expected': expectedOutput.replace(EOLrepl,marker),
190                                  'actual': output.replace(EOLrepl,marker),
191                                  'end': '(end)'}
192        else:
193            return self.report % {'template': self._input,
194                                  'expected': expectedOutput,
195                                  'actual': output,
196                                  'end': '(end)'}
197       
198    def genClassCode(self):
199        if hasattr(self, 'template'):
200            return self.template.generatedClassCode()
201
202    def genModuleCode(self):
203        if hasattr(self, 'template'):
204            return self.template.generatedModuleCode()
205
206##################################################
207## TEST CASE CLASSES
208
209class EmptyTemplate(OutputTest):
210    convertEOLs = False
211    def test1(self):
212        """an empty string for the template"""
213       
214        warnings.filterwarnings('error',
215                                'You supplied an empty string for the source!',
216                                UserWarning)
217        try:
218            self.verify("", "")
219        except UserWarning:
220            pass
221        else:
222            self.fail("Should warn about empty source strings.")
223       
224        try:
225            self.verify("#implements foo", "")
226        except NotImplementedError:
227            pass
228        else:
229            self.fail("This should barf about respond() not being implemented.")
230
231        self.verify("#implements respond", "")
232
233        self.verify("#implements respond(foo=1234)", "")
234
235
236class Backslashes(OutputTest):
237    convertEOLs = False
238
239    def setUp(self):
240        fp = open('backslashes.txt','w')
241        fp.write(r'\ #LogFormat "%h %l %u %t \"%r\" %>s %b"' + '\n\n\n\n\n\n\n')
242        fp.flush()
243        fp.close
244   
245    def tearDown(self):
246        if os.path.exists('backslashes.txt'):
247            os.remove('backslashes.txt')
248       
249    def test1(self):
250        """ a single \\ using rawstrings"""
251        self.verify(r"\ ",
252                    r"\ ")
253
254    def test2(self):
255        """ a single \\ using rawstrings and lots of lines"""
256        self.verify(r"\ " + "\n\n\n\n\n\n\n\n\n",
257                    r"\ " + "\n\n\n\n\n\n\n\n\n")
258
259    def test3(self):
260        """ a single \\ without using rawstrings"""
261        self.verify("\ \ ",
262                    "\ \ ")
263
264    def test4(self):
265        """ single line from an apache conf file"""
266        self.verify(r'#LogFormat "%h %l %u %t \"%r\" %>s %b"',
267                    r'#LogFormat "%h %l %u %t \"%r\" %>s %b"')
268
269    def test5(self):
270        """ single line from an apache conf file with many NEWLINES
271
272        The NEWLINES are used to make sure that MethodCompiler.commitStrConst()
273        is handling long and short strings in the same fashion.  It uses
274        triple-quotes for strings with lots of \\n in them and repr(theStr) for
275        shorter strings with only a few newlines."""
276       
277        self.verify(r'#LogFormat "%h %l %u %t \"%r\" %>s %b"' + '\n\n\n\n\n\n\n',
278                    r'#LogFormat "%h %l %u %t \"%r\" %>s %b"' + '\n\n\n\n\n\n\n')
279
280    def test6(self):
281        """ test backslash handling in an included file"""
282        self.verify(r'#include "backslashes.txt"',
283                    r'\ #LogFormat "%h %l %u %t \"%r\" %>s %b"' + '\n\n\n\n\n\n\n')
284
285    def test7(self):
286        """ a single \\ without using rawstrings plus many NEWLINES"""
287        self.verify("\ \ " + "\n\n\n\n\n\n\n\n\n",
288                    "\ \ " + "\n\n\n\n\n\n\n\n\n")
289
290    def test8(self):
291        """ single line from an apache conf file with single quotes and many NEWLINES
292        """
293       
294        self.verify(r"""#LogFormat '%h %l %u %t \"%r\" %>s %b'""" + '\n\n\n\n\n\n\n',
295                    r"""#LogFormat '%h %l %u %t \"%r\" %>s %b'""" + '\n\n\n\n\n\n\n')
296       
297class NonTokens(OutputTest):
298    def test1(self):
299        """dollar signs not in Cheetah $vars"""
300        self.verify("$ $$ $5 $. $ test",
301                    "$ $$ $5 $. $ test")
302
303    def test2(self):
304        """hash not in #directives"""
305        self.verify("# \# #5 ",
306                    "# # #5 ")
307
308    def test3(self):
309        """escapted comments"""
310        self.verify("  \##escaped comment  ",
311                    "  ##escaped comment  ")
312
313    def test4(self):
314        """escapted multi-line comments"""
315        self.verify("  \#*escaped comment \n*#  ",
316                    "  #*escaped comment \n*#  ")
317
318    def test5(self):
319        """1 dollar sign"""
320        self.verify("$",
321                    "$")
322    def _X_test6(self):
323        """1 dollar sign followed by hash"""
324        self.verify("\n$#\n",
325                    "\n$#\n")
326
327    def test6(self):
328        """1 dollar sign followed by EOL Slurp Token"""
329        if DEFAULT_COMPILER_SETTINGS['EOLSlurpToken']:
330            self.verify("\n$%s\n"%DEFAULT_COMPILER_SETTINGS['EOLSlurpToken'],
331                        "\n$")
332        else:
333            self.verify("\n$#\n",
334                        "\n$#\n")
335           
336class Comments_SingleLine(OutputTest):
337    def test1(self):
338        """## followed by WS"""
339        self.verify("##    ",
340                    "")
341
342    def test2(self):
343        """## followed by NEWLINE"""
344        self.verify("##\n",
345                    "")
346
347    def test3(self):
348        """## followed by text then NEWLINE"""
349        self.verify("## oeuao aoe uaoe \n",
350                    "")
351    def test4(self):
352        """## gobbles leading WS"""
353        self.verify("    ## oeuao aoe uaoe \n",
354                    "")
355
356    def test5(self):
357        """## followed by text then NEWLINE, + leading WS"""
358        self.verify("    ## oeuao aoe uaoe \n",
359                    "")
360
361    def test6(self):
362        """## followed by EOF"""
363        self.verify("##",
364                    "")
365       
366    def test7(self):
367        """## followed by EOF with leading WS"""
368        self.verify("    ##",
369                    "")
370       
371    def test8(self):
372        """## gobble line
373        with text on previous and following lines"""
374        self.verify("line1\n   ## aoeu 1234   \nline2",
375                    "line1\nline2")
376
377    def test9(self):
378        """## don't gobble line
379        with text on previous and following lines"""
380        self.verify("line1\n 12 ## aoeu 1234   \nline2",
381                    "line1\n 12 \nline2")
382
383    def test10(self):
384        """## containing $placeholders
385        """
386        self.verify("##$a$b $c($d)",
387                    "")
388
389    def test11(self):
390        """## containing #for directive
391        """
392        self.verify("##for $i in range(15)",
393                    "")
394
395
396class Comments_MultiLine_NoGobble(OutputTest):
397    """
398    Multiline comments used to not gobble whitespace.  They do now, but this can
399    be turned off with a compilerSetting   
400    """
401
402    def _getCompilerSettings(self):
403        return {'gobbleWhitespaceAroundMultiLineComments':False}
404
405    def test1(self):
406        """#* *# followed by WS
407        Shouldn't gobble WS
408        """
409        self.verify("#* blarg *#   ",
410                    "   ")
411       
412    def test2(self):
413        """#* *# preceded and followed by WS
414        Shouldn't gobble WS
415        """
416        self.verify("   #* blarg *#   ",
417                    "      ")
418       
419    def test3(self):
420        """#* *# followed by WS, with NEWLINE
421        Shouldn't gobble WS
422        """
423        self.verify("#* \nblarg\n *#   ",
424                    "   ")
425       
426    def test4(self):
427        """#* *# preceded and followed by WS, with NEWLINE
428        Shouldn't gobble WS
429        """
430        self.verify("   #* \nblarg\n *#   ",
431                    "      ")
432
433class Comments_MultiLine(OutputTest):
434    """
435    Note: Multiline comments don't gobble whitespace!
436    """
437   
438    def test1(self):
439        """#* *# followed by WS
440        Should gobble WS
441        """
442        self.verify("#* blarg *#   ",
443                    "")
444       
445    def test2(self):
446        """#* *# preceded and followed by WS
447        Should gobble WS
448        """
449        self.verify("   #* blarg *#   ",
450                    "")
451       
452    def test3(self):
453        """#* *# followed by WS, with NEWLINE
454        Shouldn't gobble WS
455        """
456        self.verify("#* \nblarg\n *#   ",
457                    "")
458       
459    def test4(self):
460        """#* *# preceded and followed by WS, with NEWLINE
461        Shouldn't gobble WS
462        """
463        self.verify("   #* \nblarg\n *#   ",
464                    "")
465
466    def test5(self):
467        """#* *# containing nothing
468        """
469        self.verify("#**#",
470                    "")
471       
472    def test6(self):
473        """#* *# containing only NEWLINES
474        """
475        self.verify("  #*\n\n\n\n\n\n\n\n*#  ",
476                    "")
477
478    def test7(self):
479        """#* *# containing $placeholders
480        """
481        self.verify("#* $var $var(1234*$c) *#",
482                    "")
483       
484    def test8(self):
485        """#* *# containing #for directive
486        """
487        self.verify("#* #for $i in range(15) *#",
488                    "")
489
490    def test9(self):
491        """ text around #* *# containing #for directive
492        """
493        self.verify("foo\nfoo bar #* #for $i in range(15) *# foo\n",
494                    "foo\nfoo bar  foo\n")
495
496    def test9(self):
497        """ text around #* *# containing #for directive and trailing whitespace
498        which should be gobbled
499        """
500        self.verify("foo\nfoo bar #* #for $i in range(15) *#   \ntest",
501                    "foo\nfoo bar \ntest")
502
503    def test10(self):
504        """ text around #* *# containing #for directive and newlines: trailing whitespace
505        which should be gobbled.
506        """
507        self.verify("foo\nfoo bar #* \n\n#for $i in range(15) \n\n*#   \ntest",
508                    "foo\nfoo bar \ntest")
509
510class Placeholders(OutputTest):
511    def test1(self):
512        """1 placeholder"""
513        self.verify("$aStr", "blarg")
514       
515    def test2(self):
516        """2 placeholders"""
517        self.verify("$aStr $anInt", "blarg 1")
518
519    def test3(self):
520        """2 placeholders, back-to-back"""
521        self.verify("$aStr$anInt", "blarg1")
522
523    def test4(self):
524        """1 placeholder enclosed in ()"""
525        self.verify("$(aStr)", "blarg")
526       
527    def test5(self):
528        """1 placeholder enclosed in {}"""
529        self.verify("${aStr}", "blarg")
530
531    def test6(self):
532        """1 placeholder enclosed in []"""
533        self.verify("$[aStr]", "blarg")
534
535    def test7(self):
536        """1 placeholder enclosed in () + WS
537
538        Test to make sure that $(<WS><identifier>.. matches
539        """
540        self.verify("$( aStr   )", "blarg")
541
542    def test8(self):
543        """1 placeholder enclosed in {} + WS"""
544        self.verify("${ aStr   }", "blarg")
545
546    def test9(self):
547        """1 placeholder enclosed in [] + WS"""
548        self.verify("$[ aStr   ]", "blarg")
549
550    def test10(self):
551        """1 placeholder enclosed in () + WS + * cache
552
553        Test to make sure that $*(<WS><identifier>.. matches
554        """
555        self.verify("$*( aStr   )", "blarg")
556
557    def test11(self):
558        """1 placeholder enclosed in {} + WS + *cache"""
559        self.verify("$*{ aStr   }", "blarg")
560
561    def test12(self):
562        """1 placeholder enclosed in [] + WS + *cache"""
563        self.verify("$*[ aStr   ]", "blarg")
564
565    def test13(self):
566        """1 placeholder enclosed in {} + WS + *<int>*cache"""
567        self.verify("$*5*{ aStr   }", "blarg")
568
569    def test14(self):
570        """1 placeholder enclosed in [] + WS + *<int>*cache"""
571        self.verify("$*5*[ aStr   ]", "blarg")
572
573    def test15(self):
574        """1 placeholder enclosed in {} + WS + *<float>*cache"""
575        self.verify("$*0.5d*{ aStr   }", "blarg")
576
577    def test16(self):
578        """1 placeholder enclosed in [] + WS + *<float>*cache"""
579        self.verify("$*.5*[ aStr   ]", "blarg")
580
581    def test17(self):
582        """1 placeholder + *<int>*cache"""
583        self.verify("$*5*aStr", "blarg")
584
585    def test18(self):
586        """1 placeholder *<float>*cache"""
587        self.verify("$*0.5h*aStr", "blarg")
588
589    def test19(self):
590        """1 placeholder surrounded by single quotes and multiple newlines"""
591        self.verify("""'\n\n\n\n'$aStr'\n\n\n\n'""",
592                    """'\n\n\n\n'blarg'\n\n\n\n'""")
593
594    def test20(self):
595        """silent mode $!placeholders """
596        self.verify("$!aStr$!nonExistant$!*nonExistant$!{nonExistant}", "blarg")
597
598        try:
599            self.verify("$!aStr$nonExistant",
600            "blarg")
601        except NotFound:
602            pass
603        else:
604            self.fail('should raise NotFound exception')
605
606    def test21(self):
607        """Make sure that $*caching is actually working"""
608        namesStr = 'You Me Them Everyone'
609        names = namesStr.split()
610
611        tmpl = Template.compile('#for name in $names: $name ', baseclass=dict)
612        assert str(tmpl({'names':names})).strip()==namesStr
613
614        tmpl = tmpl.subclass('#for name in $names: $*name ')
615        assert str(tmpl({'names':names}))=='You '*len(names)
616
617        tmpl = tmpl.subclass('#for name in $names: $*1*name ')
618        assert str(tmpl({'names':names}))=='You '*len(names)
619
620        tmpl = tmpl.subclass('#for name in $names: $*1*(name) ')
621        assert str(tmpl({'names':names}))=='You '*len(names)
622
623        if versionTuple > (2,2):
624            tmpl = tmpl.subclass('#for name in $names: $*1*(name) ')
625            assert str(tmpl(names=names))=='You '*len(names)
626
627class Placeholders_Vals(OutputTest):
628    convertEOLs = False
629    def test1(self):
630        """string"""
631        self.verify("$aStr", "blarg")
632
633    def test2(self):
634        """string - with whitespace"""
635        self.verify(" $aStr ", " blarg ")
636
637    def test3(self):
638        """empty string - with whitespace"""
639        self.verify("$emptyString", "")
640
641    def test4(self):
642        """int"""
643        self.verify("$anInt", "1")
644
645    def test5(self):
646        """float"""
647        self.verify("$aFloat", "1.5")
648
649    def test6(self):
650        """list"""
651        self.verify("$aList", "['item0', 'item1', 'item2']")
652
653    def test7(self):
654        """None
655
656        The default output filter is ReplaceNone.
657        """
658        self.verify("$none", "")
659
660    def test8(self):
661        """True, False
662        """
663        self.verify("$True $False", "%s %s"%(repr(True), repr(False)))
664
665    def test9(self):
666        """$_
667        """
668        self.verify("$_('foo')", "Translated: foo")
669
670class PlaceholderStrings(OutputTest):
671    def test1(self):
672        """some c'text $placeholder text' strings"""
673        self.verify("$str(c'$aStr')", "blarg")
674
675    def test2(self):
676        """some c'text $placeholder text' strings"""
677        self.verify("$str(c'$aStr.upper')", "BLARG")
678
679    def test3(self):
680        """some c'text $placeholder text' strings"""
681        self.verify("$str(c'$(aStr.upper.replace(c\"A$str()\",\"\"))')", "BLRG")
682
683    def test4(self):
684        """some c'text $placeholder text' strings"""
685        self.verify("#echo $str(c'$(aStr.upper)')", "BLARG")
686
687    def test5(self):
688        """some c'text $placeholder text' strings"""
689        self.verify("#if 1 then $str(c'$(aStr.upper)') else 0", "BLARG")
690
691    def test6(self):
692        """some c'text $placeholder text' strings"""
693        self.verify("#if 1\n$str(c'$(aStr.upper)')#slurp\n#else\n0#end if", "BLARG")
694
695    def test7(self):
696        """some c'text $placeholder text' strings"""
697        self.verify("#def foo(arg=c'$(\"BLARG\")')\n"
698                    "$arg#slurp\n"
699                    "#end def\n"
700                    "$foo()$foo(c'$anInt')#slurp",
701                   
702                    "BLARG1")
703
704
705
706class UnicodeStrings(OutputTest):
707    def test1(self):
708        """unicode data in placeholder
709        """
710        #self.verify(u"$unicodeData", defaultTestNameSpace['unicodeData'], outputEncoding='utf8')
711        self.verify(u"$unicodeData", defaultTestNameSpace['unicodeData'])
712
713    def test2(self):
714        """unicode data in body
715        """
716        self.verify(u"aoeu12345\u1234", u"aoeu12345\u1234")
717        #self.verify(u"#encoding utf8#aoeu12345\u1234", u"aoeu12345\u1234")
718
719class EncodingDirective(OutputTest):
720    def test1(self):
721        """basic #encoding """
722        self.verify("#encoding utf-8\n1234",
723                    "1234")
724
725    def test2(self):
726        """basic #encoding """
727        self.verify("#encoding ascii\n1234",
728                    "1234")
729
730    def test3(self):
731        """basic #encoding """
732        self.verify("#encoding utf-8\n\xe1\x88\xb4",
733                    u'\u1234', outputEncoding='utf8')
734
735    def test4(self):
736        """basic #encoding """
737        self.verify("#encoding latin-1\n\xe1\x88\xb4",
738                    u"\xe1\x88\xb4")
739
740    def test5(self):
741        """basic #encoding """
742        self.verify("#encoding latin-1\nAndr\202",
743                    u'Andr\202')
744
745class UnicodeDirective(OutputTest):
746    def test1(self):
747        """basic #unicode """
748        self.verify("#unicode utf-8\n1234",
749                    u"1234")
750       
751        self.verify("#unicode ascii\n1234",
752                    u"1234")
753
754        self.verify("#unicode latin-1\n1234",
755                    u"1234")
756
757        self.verify("#unicode latin-1\n1234�,
758                    u"1234�)
759        self.verify("#unicode: latin-1\n1234�,
760                    u"1234�)
761        self.verify("#  unicode  : latin-1\n1234�,
762                    u"1234�)
763
764        self.verify(u"#unicode latin-1\n1234�,
765                    u"1234�)
766
767        self.verify("#encoding latin-1\n1234�,
768                    u"1234�)
769
770class Placeholders_Esc(OutputTest):
771    convertEOLs = False
772    def test1(self):
773        """1 escaped placeholder"""
774        self.verify("\$var",
775                    "$var")
776   
777    def test2(self):
778        """2 escaped placeholders"""
779        self.verify("\$var \$_",
780                    "$var $_")
781
782    def test3(self):
783        """2 escaped placeholders - back to back"""
784        self.verify("\$var\$_",
785                    "$var$_")
786
787    def test4(self):
788        """2 escaped placeholders - nested"""
789        self.verify("\$var(\$_)",
790                    "$var($_)")
791
792    def test5(self):
793        """2 escaped placeholders - nested and enclosed"""
794        self.verify("\$(var(\$_)",
795                    "$(var($_)")
796
797
798class Placeholders_Calls(OutputTest):
799    def test1(self):
800        """func placeholder - no ()"""
801        self.verify("$aFunc",
802                    "Scooby")
803
804    def test2(self):
805        """func placeholder - with ()"""
806        self.verify("$aFunc()",
807                    "Scooby")
808
809    def test3(self):
810        r"""func placeholder - with (\n\n)"""
811        self.verify("$aFunc(\n\n)",
812                    "Scooby", convertEOLs=False)
813
814    def test4(self):
815        r"""func placeholder - with (\n\n) and $() enclosure"""
816        self.verify("$(aFunc(\n\n))",
817                    "Scooby", convertEOLs=False)
818
819    def test5(self):
820        r"""func placeholder - with (\n\n) and ${} enclosure"""
821        self.verify("${aFunc(\n\n)}",
822                    "Scooby", convertEOLs=False)
823       
824    def test6(self):
825        """func placeholder - with (int)"""
826        self.verify("$aFunc(1234)",
827                    "1234")
828
829    def test7(self):
830        r"""func placeholder - with (\nint\n)"""
831        self.verify("$aFunc(\n1234\n)",
832                    "1234", convertEOLs=False)
833    def test8(self):
834        """func placeholder - with (string)"""
835        self.verify("$aFunc('aoeu')",
836                    "aoeu")
837       
838    def test9(self):
839        """func placeholder - with ('''string''')"""
840        self.verify("$aFunc('''aoeu''')",
841                    "aoeu")
842    def test10(self):
843        r"""func placeholder - with ('''\nstring\n''')"""
844        self.verify("$aFunc('''\naoeu\n''')",
845                    "\naoeu\n")
846
847    def test11(self):
848        r"""func placeholder - with ('''\nstring'\n''')"""
849        self.verify("$aFunc('''\naoeu'\n''')",
850                    "\naoeu'\n")
851
852    def test12(self):
853        r'''func placeholder - with ("""\nstring\n""")'''
854        self.verify('$aFunc("""\naoeu\n""")',
855                    "\naoeu\n")
856
857    def test13(self):
858        """func placeholder - with (string*int)"""
859        self.verify("$aFunc('aoeu'*2)",
860                    "aoeuaoeu")
861
862    def test14(self):
863        """func placeholder - with (int*int)"""
864        self.verify("$aFunc(2*2)",
865                    "4")
866
867    def test15(self):
868        """func placeholder - with (int*float)"""
869        self.verify("$aFunc(2*2.0)",
870                    "4.0")
871
872    def test16(self):
873        r"""func placeholder - with (int\n*\nfloat)"""
874        self.verify("$aFunc(2\n*\n2.0)",
875                    "4.0", convertEOLs=False)
876
877    def test17(self):
878        """func placeholder - with ($arg=float)"""
879        self.verify("$aFunc($arg=4.0)",
880                    "4.0")
881
882    def test18(self):
883        """func placeholder - with (arg=float)"""
884        self.verify("$aFunc(arg=4.0)",
885                    "4.0")
886
887    def test19(self):
888        """deeply nested argstring, no enclosure"""
889        self.verify("$aFunc($arg=$aMeth($arg=$aFunc(1)))",
890                    "1")
891
892    def test20(self):
893        """deeply nested argstring, no enclosure + with WS"""
894        self.verify("$aFunc(  $arg = $aMeth( $arg = $aFunc( 1 ) ) )",
895                    "1")
896    def test21(self):
897        """deeply nested argstring, () enclosure + with WS"""
898        self.verify("$(aFunc(  $arg = $aMeth( $arg = $aFunc( 1 ) ) ) )",
899                    "1")
900       
901    def test22(self):
902        """deeply nested argstring, {} enclosure + with WS"""
903        self.verify("${aFunc(  $arg = $aMeth( $arg = $aFunc( 1 ) ) ) }",
904                    "1")
905
906    def test23(self):
907        """deeply nested argstring, [] enclosure + with WS"""
908        self.verify("$[aFunc(  $arg = $aMeth( $arg = $aFunc( 1 ) ) ) ]",
909                    "1")
910
911    def test24(self):
912        """deeply nested argstring, () enclosure + *cache"""
913        self.verify("$*(aFunc(  $arg = $aMeth( $arg = $aFunc( 1 ) ) ) )",
914                    "1")
915    def test25(self):
916        """deeply nested argstring, () enclosure + *15*cache"""
917        self.verify("$*15*(aFunc(  $arg = $aMeth( $arg = $aFunc( 1 ) ) ) )",
918                    "1")
919
920    def test26(self):
921        """a function call with the Python None kw."""
922        self.verify("$aFunc(None)",
923                    "")
924
925class NameMapper(OutputTest):
926    def test1(self):
927        """autocalling"""
928        self.verify("$aFunc! $aFunc().",
929                    "Scooby! Scooby.")
930
931    def test2(self):
932        """nested autocalling"""
933        self.verify("$aFunc($aFunc).",
934                    "Scooby.")
935
936    def test3(self):
937        """list subscription"""
938        self.verify("$aList[0]",
939                    "item0")
940
941    def test4(self):
942        """list slicing"""
943        self.verify("$aList[:2]",
944                    "['item0', 'item1']")
945       
946    def test5(self):
947        """list slicing and subcription combined"""
948        self.verify("$aList[:2][0]",
949                    "item0")
950
951    def test6(self):
952        """dictionary access - NameMapper style"""
953        self.verify("$aDict.one",
954                    "item1")
955       
956    def test7(self):
957        """dictionary access - Python style"""
958        self.verify("$aDict['one']",
959                    "item1")
960
961    def test8(self):
962        """dictionary access combined with autocalled string method"""
963        self.verify("$aDict.one.upper",
964                    "ITEM1")
965
966    def test9(self):
967        """dictionary access combined with string method"""
968        self.verify("$aDict.one.upper()",
969                    "ITEM1")
970
971    def test10(self):
972        """nested dictionary access - NameMapper style"""
973        self.verify("$aDict.nestedDict.two",
974                    "nestedItem2")
975       
976    def test11(self):
977        """nested dictionary access - Python style"""
978        self.verify("$aDict['nestedDict']['two']",
979                    "nestedItem2")
980
981    def test12(self):
982        """nested dictionary access - alternating style"""
983        self.verify("$aDict['nestedDict'].two",
984                    "nestedItem2")
985
986    def test13(self):
987        """nested dictionary access using method - alternating style"""
988        self.verify("$aDict.get('nestedDict').two",
989                    "nestedItem2")
990
991    def test14(self):
992        """nested dictionary access - NameMapper style - followed by method"""
993        self.verify("$aDict.nestedDict.two.upper",
994                    "NESTEDITEM2")
995
996    def test15(self):
997        """nested dictionary access - alternating style - followed by method"""
998        self.verify("$aDict['nestedDict'].two.upper",
999                    "NESTEDITEM2")
1000
1001    def test16(self):
1002        """nested dictionary access - NameMapper style - followed by method, then slice"""
1003        self.verify("$aDict.nestedDict.two.upper[:4]",
1004                    "NEST")
1005
1006    def test17(self):
1007        """nested dictionary access - Python style using a soft-coded key"""
1008        self.verify("$aDict[$anObj.meth('nestedDict')].two",
1009                    "nestedItem2")
1010
1011    def test18(self):
1012        """object method access"""
1013        self.verify("$anObj.meth1",
1014                    "doo")
1015
1016    def test19(self):
1017        """object method access, followed by complex slice"""
1018        self.verify("$anObj.meth1[0: ((4/4*2)*2)/$anObj.meth1(2) ]",
1019                    "do")
1020
1021    def test20(self):
1022        """object method access, followed by a very complex slice
1023        If it can pass this one, it's safe to say it works!!"""
1024        self.verify("$( anObj.meth1[0:\n (\n(4/4*2)*2)/$anObj.meth1(2)\n ] )",
1025                    "do")
1026
1027    def test21(self):
1028        """object method access with % in the default arg for the meth.
1029
1030        This tests a bug that Jeff Johnson found and submitted a patch to SF
1031        for."""
1032       
1033        self.verify("$anObj.methWithPercentSignDefaultArg",
1034                    "110%")
1035
1036
1037#class NameMapperDict(OutputTest):
1038#
1039#    _searchList = [{"update": "Yabba dabba doo!"}]
1040#
1041#    def test1(self):
1042#        if NameMapper_C_VERSION:
1043#            return # This feature is not in the C version yet.
1044#        self.verify("$update", "Yabba dabba doo!")
1045#
1046
1047class CacheDirective(OutputTest):
1048   
1049    def test1(self):
1050        r"""simple #cache """
1051        self.verify("#cache:$anInt",
1052                    "1")
1053
1054    def test2(self):
1055        r"""simple #cache + WS"""
1056        self.verify("  #cache  \n$anInt#end cache",
1057                    "1")
1058
1059    def test3(self):
1060        r"""simple #cache ... #end cache"""
1061        self.verify("""#cache id='cache1', timer=150m
1062$anInt
1063#end cache
1064$aStr""",
1065                    "1\nblarg")
1066       
1067    def test4(self):
1068        r"""2 #cache ... #end cache blocks"""
1069        self.verify("""#slurp
1070#def foo
1071#cache ID='cache1', timer=150m
1072$anInt
1073#end cache
1074#cache id='cache2', timer=15s
1075 #for $i in range(5)
1076$i#slurp
1077 #end for
1078#end cache
1079$aStr#slurp
1080#end def
1081$foo$foo$foo$foo$foo""",
1082                    "1\n01234blarg"*5)
1083
1084
1085    def test5(self):
1086        r"""nested #cache blocks"""
1087        self.verify("""#slurp
1088#def foo     
1089#cache ID='cache1', timer=150m
1090$anInt
1091#cache id='cache2', timer=15s
1092 #for $i in range(5)
1093$i#slurp
1094 #end for
1095$*(6)#slurp
1096#end cache
1097#end cache
1098$aStr#slurp
1099#end def
1100$foo$foo$foo$foo$foo""",
1101                    "1\n012346blarg"*5)
1102       
1103    def test6(self):
1104        r"""Make sure that partial directives don't match"""
1105        self.verify("#cache_foo",
1106                    "#cache_foo")
1107        self.verify("#cached",
1108                    "#cached")
1109
1110class CallDirective(OutputTest):
1111   
1112    def test1(self):
1113        r"""simple #call """
1114        self.verify("#call int\n$anInt#end call",
1115                    "1")
1116        # single line version
1117        self.verify("#call int: $anInt",
1118                    "1")
1119        self.verify("#call int: 10\n$aStr",
1120                    "10\nblarg")
1121
1122    def test2(self):
1123        r"""simple #call + WS"""
1124        self.verify("#call int\n$anInt  #end call",
1125                    "1")
1126
1127    def test3(self):
1128        r"""a longer #call"""
1129        self.verify('''\
1130#def meth(arg)
1131$arg.upper()#slurp
1132#end def
1133#call $meth
1134$(1234+1) foo#slurp
1135#end call''',
1136        "1235 FOO")
1137
1138    def test4(self):
1139        r"""#call with keyword #args"""
1140        self.verify('''\
1141#def meth(arg1, arg2)
1142$arg1.upper() - $arg2.lower()#slurp
1143#end def
1144#call self.meth
1145#arg arg1
1146$(1234+1) foo#slurp
1147#arg arg2
1148UPPER#slurp
1149#end call''',
1150        "1235 FOO - upper")
1151
1152    def test5(self):
1153        r"""#call with single-line keyword #args """
1154        self.verify('''\
1155#def meth(arg1, arg2)
1156$arg1.upper() - $arg2.lower()#slurp
1157#end def
1158#call self.meth
1159#arg arg1:$(1234+1) foo#slurp
1160#arg arg2:UPPER#slurp
1161#end call''',
1162        "1235 FOO - upper")
1163       
1164    def test6(self):
1165        """#call with python kwargs and cheetah output for the 1s positional
1166        arg"""
1167       
1168        self.verify('''\
1169#def meth(arg1, arg2)
1170$arg1.upper() - $arg2.lower()#slurp
1171#end def
1172#call self.meth arg2="UPPER"
1173$(1234+1) foo#slurp
1174#end call''',
1175        "1235 FOO - upper")
1176
1177    def test7(self):
1178        """#call with python kwargs and #args"""
1179        self.verify('''\
1180#def meth(arg1, arg2, arg3)
1181$arg1.upper() - $arg2.lower() - $arg3#slurp
1182#end def
1183#call self.meth arg2="UPPER", arg3=999
1184#arg arg1:$(1234+1) foo#slurp
1185#end call''',
1186        "1235 FOO - upper - 999")
1187       
1188    def test8(self):
1189        """#call with python kwargs and #args, and using a function to get the
1190        function that will be called"""
1191        self.verify('''\
1192#def meth(arg1, arg2, arg3)
1193$arg1.upper() - $arg2.lower() - $arg3#slurp
1194#end def
1195#call getattr(self, "meth") arg2="UPPER", arg3=999
1196#arg arg1:$(1234+1) foo#slurp
1197#end call''',
1198        "1235 FOO - upper - 999")
1199
1200    def test9(self):
1201        """nested #call directives"""
1202        self.verify('''\
1203#def meth(arg1)
1204$arg1#slurp
1205#end def
1206#def meth2(x,y)
1207$x$y#slurp
1208#end def
1209##
1210#call self.meth
12111#slurp
1212#call self.meth
12132#slurp
1214#call self.meth
12153#slurp
1216#end call 3
1217#set two = 2
1218#call self.meth2 y=c"$(10/$two)"
1219#arg x
12204#slurp
1221#end call 4
1222#end call 2
1223#end call 1''',
1224        "12345")
1225
1226
1227
1228class I18nDirective(OutputTest):   
1229    def test1(self):
1230        r"""simple #call """
1231        self.verify("#i18n \n$anInt#end i18n",
1232                    "1")
1233       
1234        # single line version
1235        self.verify("#i18n: $anInt",
1236                    "1")
1237        self.verify("#i18n: 10\n$aStr",
1238                    "10\nblarg")
1239
1240
1241class CaptureDirective(OutputTest):
1242    def test1(self):
1243        r"""simple #capture"""
1244        self.verify('''\
1245#capture cap1
1246$(1234+1) foo#slurp
1247#end capture
1248$cap1#slurp
1249''',
1250        "1235 foo")
1251
1252
1253    def test2(self):
1254        r"""slightly more complex #capture"""
1255        self.verify('''\
1256#def meth(arg)
1257$arg.upper()#slurp
1258#end def
1259#capture cap1
1260$(1234+1) $anInt $meth("foo")#slurp
1261#end capture
1262$cap1#slurp
1263''',
1264        "1235 1 FOO")
1265
1266
1267class SlurpDirective(OutputTest):
1268    def test1(self):
1269        r"""#slurp with 1 \n """
1270        self.verify("#slurp\n",
1271                    "")
1272
1273    def test2(self):
1274        r"""#slurp with 1 \n, leading whitespace
1275        Should gobble"""
1276        self.verify("       #slurp\n",
1277                    "")
1278       
1279    def test3(self):
1280        r"""#slurp with 1 \n, leading content
1281        Shouldn't gobble"""
1282        self.verify(" 1234 #slurp\n",
1283                    " 1234 ")
1284       
1285    def test4(self):
1286        r"""#slurp with WS then \n, leading content
1287        Shouldn't gobble"""
1288        self.verify(" 1234 #slurp    \n",
1289                    " 1234 ")
1290
1291    def test5(self):
1292        r"""#slurp with garbage chars then \n, leading content
1293        Should eat the garbage"""
1294        self.verify(" 1234 #slurp garbage   \n",
1295                    " 1234 ")
1296
1297
1298
1299class EOLSlurpToken(OutputTest):
1300    _EOLSlurpToken = DEFAULT_COMPILER_SETTINGS['EOLSlurpToken']
1301    def test1(self):
1302        r"""#slurp with 1 \n """
1303        self.verify("%s\n"%self._EOLSlurpToken,
1304                    "")
1305
1306    def test2(self):
1307        r"""#slurp with 1 \n, leading whitespace
1308        Should gobble"""
1309        self.verify("       %s\n"%self._EOLSlurpToken,
1310                    "")
1311    def test3(self):
1312        r"""#slurp with 1 \n, leading content
1313        Shouldn't gobble"""
1314        self.verify(" 1234 %s\n"%self._EOLSlurpToken,
1315                    " 1234 ")
1316       
1317    def test4(self):
1318        r"""#slurp with WS then \n, leading content
1319        Shouldn't gobble"""
1320        self.verify(" 1234 %s    \n"%self._EOLSlurpToken,
1321                    " 1234 ")
1322
1323    def test5(self):
1324        r"""#slurp with garbage chars then \n, leading content
1325        Should NOT eat the garbage"""
1326        self.verify(" 1234 %s garbage   \n"%self._EOLSlurpToken,
1327                    " 1234 %s garbage   \n"%self._EOLSlurpToken)
1328
1329if not DEFAULT_COMPILER_SETTINGS['EOLSlurpToken']:
1330    del EOLSlurpToken
1331
1332class RawDirective(OutputTest):
1333    def test1(self):
1334        """#raw till EOF"""
1335        self.verify("#raw\n$aFunc().\n\n",
1336                    "$aFunc().\n\n")
1337
1338    def test2(self):
1339        """#raw till #end raw"""
1340        self.verify("#raw\n$aFunc().\n#end raw\n$anInt",
1341                    "$aFunc().\n1")
1342       
1343    def test3(self):
1344        """#raw till #end raw gobble WS"""
1345        self.verify("  #raw  \n$aFunc().\n   #end raw  \n$anInt",
1346                    "$aFunc().\n1")
1347
1348    def test4(self):
1349        """#raw till #end raw using explicit directive closure
1350        Shouldn't gobble"""
1351        self.verify("  #raw  #\n$aFunc().\n   #end raw  #\n$anInt",
1352                    "  \n$aFunc().\n\n1")
1353
1354    def test5(self):
1355        """single-line short form #raw: """
1356        self.verify("#raw: $aFunc().\n\n",
1357                    "$aFunc().\n\n")
1358
1359        self.verify("#raw: $aFunc().\n$anInt",
1360                    "$aFunc().\n1")
1361
1362class BreakpointDirective(OutputTest):
1363    def test1(self):
1364        """#breakpoint part way through source code"""
1365        self.verify("$aFunc(2).\n#breakpoint\n$anInt",
1366                    "2.\n")
1367
1368    def test2(self):
1369        """#breakpoint at BOF"""
1370        self.verify("#breakpoint\n$anInt",
1371                    "")
1372
1373    def test3(self):
1374        """#breakpoint at EOF"""
1375        self.verify("$anInt\n#breakpoint",
1376                    "1\n")
1377
1378
1379class StopDirective(OutputTest):
1380    def test1(self):
1381        """#stop part way through source code"""
1382        self.verify("$aFunc(2).\n#stop\n$anInt",
1383                    "2.\n")
1384
1385    def test2(self):
1386        """#stop at BOF"""
1387        self.verify("#stop\n$anInt",
1388                    "")
1389
1390    def test3(self):
1391        """#stop at EOF"""
1392        self.verify("$anInt\n#stop",
1393                    "1\n")
1394
1395    def test4(self):
1396        """#stop in pos test block"""
1397        self.verify("""$anInt
1398#if 1
1399inside the if block
1400#stop
1401#end if
1402blarg""",
1403        "1\ninside the if block\n")
1404
1405    def test5(self):
1406        """#stop in neg test block"""
1407        self.verify("""$anInt
1408#if 0
1409inside the if block
1410#stop
1411#end if
1412blarg""",
1413        "1\nblarg")
1414
1415
1416class ReturnDirective(OutputTest):
1417   
1418    def test1(self):
1419        """#return'ing an int """
1420        self.verify("""1
1421$str($test-6)
14223
1423#def test
1424#if 1
1425#return (3   *2)  \
1426  + 2
1427#else
1428aoeuoaeu
1429#end if
1430#end def
1431""",
1432                    "1\n2\n3\n")
1433
1434    def test2(self):
1435        """#return'ing an string """
1436        self.verify("""1
1437$str($test[1])
14383
1439#def test
1440#if 1
1441#return '123'
1442#else
1443aoeuoaeu
1444#end if
1445#end def
1446""",
1447                    "1\n2\n3\n")
1448
1449    def test3(self):
1450        """#return'ing an string AND streaming other output via the transaction"""
1451        self.verify("""1
1452$str($test(trans=trans)[1])
14533
1454#def test
14551.5
1456#if 1
1457#return '123'
1458#else
1459aoeuoaeu
1460#end if
1461#end def
1462""",
1463                    "1\n1.5\n2\n3\n")
1464
1465
1466class YieldDirective(OutputTest):
1467    convertEOLs = False
1468    def test1(self):
1469        """simple #yield """
1470       
1471        src1 = """#for i in range(10)\n#yield i\n#end for"""
1472        src2 = """#for i in range(10)\n$i#slurp\n#yield\n#end for"""
1473        src3 = ("#def iterator\n"
1474               "#for i in range(10)\n#yield i\n#end for\n"
1475               "#end def\n"
1476               "#for i in $iterator\n$i#end for"
1477               )
1478
1479
1480        for src in (src1,src2,src3):
1481            klass = Template.compile(src, keepRefToGeneratedCode=True)
1482            #print klass._CHEETAH_generatedModuleCode
1483            iter = klass().respond()
1484            output = [str(i) for i in iter]
1485            assert ''.join(output)=='0123456789'
1486            #print ''.join(output)
1487
1488        # @@TR: need to expand this to cover error conditions etc.
1489
1490if versionTuple < (2,3):
1491    del YieldDirective
1492       
1493class ForDirective(OutputTest):
1494
1495    def test1(self):
1496        """#for loop with one local var"""
1497        self.verify("#for $i in range(5)\n$i\n#end for",
1498                    "0\n1\n2\n3\n4\n")
1499
1500        self.verify("#for $i in range(5):\n$i\n#end for",
1501                    "0\n1\n2\n3\n4\n")
1502
1503        self.verify("#for $i in range(5): ##comment\n$i\n#end for",
1504                    "0\n1\n2\n3\n4\n")
1505
1506        self.verify("#for $i in range(5) ##comment\n$i\n#end for",
1507                    "0\n1\n2\n3\n4\n")
1508
1509
1510    def test2(self):
1511        """#for loop with WS in loop"""
1512        self.verify("#for $i in range(5)\n$i \n#end for",
1513                    "0 \n1 \n2 \n3 \n4 \n")
1514       
1515    def test3(self):
1516        """#for loop gobble WS"""
1517        self.verify("   #for $i in range(5)   \n$i \n   #end for   ",
1518                    "0 \n1 \n2 \n3 \n4 \n")
1519
1520    def test4(self):
1521        """#for loop over list"""
1522        self.verify("#for $i, $j in [(0,1),(2,3)]\n$i,$j\n#end for",
1523                    "0,1\n2,3\n")
1524       
1525    def test5(self):
1526        """#for loop over list, with #slurp"""
1527        self.verify("#for $i, $j in [(0,1),(2,3)]\n$i,$j#slurp\n#end for",
1528                    "0,12,3")
1529
1530    def test6(self):
1531        """#for loop with explicit closures"""
1532        self.verify("#for $i in range(5)#$i#end for#",
1533                    "01234")
1534
1535    def test7(self):
1536        """#for loop with explicit closures and WS"""
1537        self.verify("  #for $i in range(5)#$i#end for#  ",
1538                    "  01234  ")
1539
1540    def test8(self):
1541        """#for loop using another $var"""
1542        self.verify("  #for $i in range($aFunc(5))#$i#end for#  ",
1543                    "  01234  ")
1544
1545    def test9(self):
1546        """test methods in for loops"""
1547        self.verify("#for $func in $listOfLambdas\n$func($anInt)\n#end for",
1548                    "1\n1\n1\n")
1549
1550
1551    def test10(self):
1552        """#for loop over list, using methods of the items"""
1553        self.verify("#for i, j in [('aa','bb'),('cc','dd')]\n$i.upper,$j.upper\n#end for",
1554                    "AA,BB\nCC,DD\n")
1555        self.verify("#for $i, $j in [('aa','bb'),('cc','dd')]\n$i.upper,$j.upper\n#end for",
1556                    "AA,BB\nCC,DD\n")
1557
1558    def test11(self):
1559        """#for loop over list, using ($i,$j) style target list"""
1560        self.verify("#for (i, j) in [('aa','bb'),('cc','dd')]\n$i.upper,$j.upper\n#end for",
1561                    "AA,BB\nCC,DD\n")
1562        self.verify("#for ($i, $j) in [('aa','bb'),('cc','dd')]\n$i.upper,$j.upper\n#end for",
1563                    "AA,BB\nCC,DD\n")
1564
1565    def test12(self):
1566        """#for loop over list, using i, (j,k) style target list"""
1567        self.verify("#for i, (j, k) in enumerate([('aa','bb'),('cc','dd')])\n$j.upper,$k.upper\n#end for",
1568                    "AA,BB\nCC,DD\n")
1569        self.verify("#for $i, ($j, $k) in enumerate([('aa','bb'),('cc','dd')])\n$j.upper,$k.upper\n#end for",
1570                    "AA,BB\nCC,DD\n")
1571
1572    def test13(self):
1573        """single line #for"""
1574        self.verify("#for $i in range($aFunc(5)): $i",
1575                    "01234")
1576
1577    def test14(self):
1578        """single line #for with 1 extra leading space"""
1579        self.verify("#for $i in range($aFunc(5)):  $i",
1580                    " 0 1 2 3 4")
1581
1582    def test15(self):
1583        """2 times single line #for"""
1584        self.verify("#for $i in range($aFunc(5)): $i#slurp\n"*2,
1585                    "01234"*2)
1586
1587    def test16(self):
1588        """false single line #for """
1589        self.verify("#for $i in range(5): \n$i\n#end for",
1590                    "0\n1\n2\n3\n4\n")
1591
1592if versionTuple < (2,3):
1593    del ForDirective.test12
1594
1595class RepeatDirective(OutputTest):
1596
1597    def test1(self):
1598        """basic #repeat"""
1599        self.verify("#repeat 3\n1\n#end repeat",
1600                    "1\n1\n1\n")
1601        self.verify("#repeat 3: \n1\n#end repeat",
1602                    "1\n1\n1\n")
1603
1604        self.verify("#repeat 3 ##comment\n1\n#end repeat",
1605                    "1\n1\n1\n")
1606
1607        self.verify("#repeat 3: ##comment\n1\n#end repeat",
1608                    "1\n1\n1\n")
1609
1610    def test2(self):
1611        """#repeat with numeric expression"""
1612        self.verify("#repeat 3*3/3\n1\n#end repeat",
1613                    "1\n1\n1\n")
1614   
1615    def test3(self):
1616        """#repeat with placeholder"""
1617        self.verify("#repeat $numTwo\n1\n#end repeat",
1618                    "1\n1\n")
1619   
1620    def test4(self):
1621        """#repeat with placeholder * num"""
1622        self.verify("#repeat $numTwo*1\n1\n#end repeat",
1623                    "1\n1\n")
1624       
1625    def test5(self):
1626        """#repeat with placeholder and WS"""
1627        self.verify("   #repeat $numTwo   \n1\n   #end repeat   ",
1628                    "1\n1\n")
1629
1630    def test6(self):
1631        """single-line #repeat"""
1632        self.verify("#repeat $numTwo: 1",
1633                    "11")
1634        self.verify("#repeat $numTwo: 1\n"*2,
1635                    "1\n1\n"*2)
1636
1637        #false single-line
1638        self.verify("#repeat 3:  \n1\n#end repeat",
1639                    "1\n1\n1\n")
1640
1641
1642class AttrDirective(OutputTest):
1643
1644    def test1(self):
1645        """#attr with int"""
1646        self.verify("#attr $test = 1234\n$test",
1647                    "1234")
1648
1649    def test2(self):
1650        """#attr with string"""
1651        self.verify("#attr $test = 'blarg'\n$test",
1652                    "blarg")
1653
1654    def test3(self):
1655        """#attr with expression"""
1656        self.verify("#attr $test = 'blarg'.upper()*2\n$test",
1657                    "BLARGBLARG")
1658
1659    def test4(self):
1660        """#attr with string + WS
1661        Should gobble"""
1662        self.verify("     #attr $test = 'blarg'   \n$test",
1663                    "blarg")
1664
1665    def test5(self):
1666        """#attr with string + WS + leading text
1667        Shouldn't gobble"""
1668        self.verify("  --   #attr $test = 'blarg'   \n$test",
1669                    "  --   \nblarg")
1670
1671
1672class DefDirective(OutputTest):
1673
1674    def test1(self):
1675        """#def without argstring"""
1676        self.verify("#def testMeth\n1234\n#end def\n$testMeth",
1677                    "1234\n")
1678
1679        self.verify("#def testMeth ## comment\n1234\n#end def\n$testMeth",
1680                    "1234\n")
1681
1682        self.verify("#def testMeth: ## comment\n1234\n#end def\n$testMeth",
1683                    "1234\n")
1684
1685    def test2(self):
1686        """#def without argstring, gobble WS"""
1687        self.verify("   #def testMeth  \n1234\n    #end def   \n$testMeth",
1688                    "1234\n")
1689
1690    def test3(self):
1691        """#def with argstring, gobble WS"""
1692        self.verify("  #def testMeth($a=999)   \n1234-$a\n  #end def\n$testMeth",
1693                    "1234-999\n")
1694
1695    def test4(self):
1696        """#def with argstring, gobble WS, string used in call"""
1697        self.verify("  #def testMeth($a=999)   \n1234-$a\n  #end def\n$testMeth('ABC')",
1698                    "1234-ABC\n")
1699
1700    def test5(self):
1701        """#def with argstring, gobble WS, list used in call"""
1702        self.verify("  #def testMeth($a=999)   \n1234-$a\n  #end def\n$testMeth([1,2,3])",
1703                    "1234-[1, 2, 3]\n")
1704
1705    def test6(self):
1706        """#def with 2 args, gobble WS, list used in call"""
1707        self.verify("  #def testMeth($a, $b='default')   \n1234-$a$b\n  #end def\n$testMeth([1,2,3])",
1708                    "1234-[1, 2, 3]default\n")
1709
1710    def test7(self):
1711        """#def with *args, gobble WS"""
1712        self.verify("  #def testMeth($*args)   \n1234-$args\n  #end def\n$testMeth",
1713                    "1234-()\n")
1714
1715    def test8(self):
1716        """#def with **KWs, gobble WS"""
1717        self.verify("  #def testMeth($**KWs)   \n1234-$KWs\n  #end def\n$testMeth",
1718                    "1234-{}\n")
1719
1720    def test9(self):
1721        """#def with *args + **KWs, gobble WS"""
1722        self.verify("  #def testMeth($*args, $**KWs)   \n1234-$args-$KWs\n  #end def\n$testMeth",
1723                    "1234-()-{}\n")
1724
1725    def test10(self):
1726        """#def with *args + **KWs, gobble WS"""
1727        self.verify(
1728            "  #def testMeth($*args, $**KWs)   \n1234-$args-$KWs.a\n  #end def\n$testMeth(1,2, a=1)",
1729            "1234-(1, 2)-1\n")
1730
1731
1732    def test11(self):
1733        """single line #def with extra WS"""
1734        self.verify(
1735            "#def testMeth: aoeuaoeu\n- $testMeth -",
1736            "- aoeuaoeu -")
1737
1738    def test12(self):
1739        """single line #def with extra WS and nested $placeholders"""
1740        self.verify(
1741            "#def testMeth: $anInt $aFunc(1234)\n- $testMeth -",
1742            "- 1 1234 -")
1743
1744    def test13(self):
1745        """single line #def escaped $placeholders"""
1746        self.verify(
1747            "#def testMeth: \$aFunc(\$anInt)\n- $testMeth -",
1748            "- $aFunc($anInt) -")
1749
1750    def test14(self):
1751        """single line #def 1 escaped $placeholders"""
1752        self.verify(
1753            "#def testMeth: \$aFunc($anInt)\n- $testMeth -",
1754            "- $aFunc(1) -")
1755
1756    def test15(self):
1757        """single line #def 1 escaped $placeholders + more WS"""
1758        self.verify(
1759            "#def testMeth    : \$aFunc($anInt)\n- $testMeth -",
1760            "- $aFunc(1) -")
1761
1762    def test16(self):
1763        """multiline #def with $ on methodName"""
1764        self.verify("#def $testMeth\n1234\n#end def\n$testMeth",
1765                    "1234\n")
1766
1767    def test17(self):
1768        """single line #def with $ on methodName"""
1769        self.verify("#def $testMeth:1234\n$testMeth",
1770                    "1234")
1771
1772    def test18(self):
1773        """single line #def with an argument"""
1774        self.verify("#def $testMeth($arg=1234):$arg\n$testMeth",
1775                    "1234")
1776
1777    def test19(self):
1778        """#def that extends over two lines with arguments"""
1779        self.verify("#def $testMeth($arg=1234,\n"
1780                    +"  $arg2=5678)\n"
1781                    +"$arg $arg2\n"
1782                    +"#end def\n"
1783                    +"$testMeth",
1784                    "1234 5678\n")
1785
1786class DecoratorDirective(OutputTest):
1787    def test1(self):
1788        """single line #def with decorator"""
1789
1790        self.verify("#@ blah", "#@ blah")
1791        self.verify("#@23 blah", "#@23 blah")
1792        self.verify("#@@TR: comment", "#@@TR: comment")
1793
1794        self.verify("#from Cheetah.Tests.SyntaxAndOutput import testdecorator\n"
1795                    +"#@testdecorator"
1796                    +"\n#def $testMeth():1234\n$testMeth",
1797                   
1798                    "1234")
1799
1800        self.verify("#from Cheetah.Tests.SyntaxAndOutput import testdecorator\n"
1801                    +"#@testdecorator"
1802                    +"\n#block $testMeth():1234",
1803                   
1804                    "1234")
1805
1806        try:
1807            self.verify(
1808                "#from Cheetah.Tests.SyntaxAndOutput import testdecorator\n"
1809                +"#@testdecorator\n sdf"
1810                +"\n#def $testMeth():1234\n$testMeth",                       
1811
1812                "1234")
1813        except ParseError:
1814            pass
1815        else:
1816            self.fail('should raise a ParseError')
1817
1818    def test2(self):
1819        """#def with multiple decorators"""
1820        self.verify("#from Cheetah.Tests.SyntaxAndOutput import testdecorator\n"
1821                    +"#@testdecorator\n"
1822                    +"#@testdecorator\n"
1823                    +"#def testMeth\n"
1824                    +"1234\n"
1825                    "#end def\n"
1826                    "$testMeth",
1827                    "1234\n")
1828
1829if versionTuple < (2,4):
1830    del DecoratorDirective
1831
1832class BlockDirective(OutputTest):
1833
1834    def test1(self):
1835        """#block without argstring"""
1836        self.verify("#block testBlock\n1234\n#end block",
1837                    "1234\n")
1838
1839        self.verify("#block testBlock ##comment\n1234\n#end block",
1840                    "1234\n")
1841
1842    def test2(self):
1843        """#block without argstring, gobble WS"""
1844        self.verify("  #block testBlock   \n1234\n  #end block  ",
1845                    "1234\n")
1846
1847    def test3(self):
1848        """#block with argstring, gobble WS
1849
1850        Because blocks can be reused in multiple parts of the template arguments
1851        (!!with defaults!!) can be given."""
1852       
1853        self.verify("  #block testBlock($a=999)   \n1234-$a\n  #end block  ",
1854                    "1234-999\n")
1855
1856    def test4(self):
1857        """#block with 2 args, gobble WS"""
1858        self.verify("  #block testBlock($a=999, $b=444)   \n1234-$a$b\n  #end block  ",
1859                    "1234-999444\n")
1860
1861
1862    def test5(self):
1863        """#block with 2 nested blocks
1864
1865        Blocks can be nested to any depth and the name of the block is optional
1866        for the #end block part: #end block OR #end block [name] """
1867       
1868        self.verify("""#block testBlock
1869this is a test block
1870#block outerNest
1871outer
1872#block innerNest
1873inner
1874#end block innerNest
1875#end block outerNest
1876---
1877#end block testBlock
1878""",
1879                    "this is a test block\nouter\ninner\n---\n")
1880
1881
1882    def test6(self):
1883        """single line #block """
1884        self.verify(
1885            "#block testMeth: This is my block",
1886            "This is my block")
1887
1888    def test7(self):
1889        """single line #block with WS"""
1890        self.verify(
1891            "#block testMeth: This is my block",
1892            "This is my block")
1893
1894    def test8(self):
1895        """single line #block 1 escaped $placeholders"""
1896        self.verify(
1897            "#block testMeth: \$aFunc($anInt)",
1898            "$aFunc(1)")
1899
1900    def test9(self):
1901        """single line #block 1 escaped $placeholders + WS"""
1902        self.verify(
1903            "#block testMeth: \$aFunc( $anInt )",
1904            "$aFunc( 1 )")
1905
1906    def test10(self):
1907        """single line #block 1 escaped $placeholders + more WS"""
1908        self.verify(
1909            "#block testMeth  : \$aFunc( $anInt )",
1910            "$aFunc( 1 )")
1911
1912    def test11(self):
1913        """multiline #block $ on argstring"""
1914        self.verify("#block $testBlock\n1234\n#end block",
1915                    "1234\n")
1916
1917    def test12(self):
1918        """single line #block with $ on methodName """
1919        self.verify(
1920            "#block $testMeth: This is my block",
1921            "This is my block")
1922
1923    def test13(self):
1924        """single line #block with an arg """
1925        self.verify(
1926            "#block $testMeth($arg='This is my block'): $arg",
1927            "This is my block")
1928
1929    def test14(self):
1930        """single line #block with None for content"""
1931        self.verify(
1932            """#block $testMeth: $None\ntest $testMeth-""",
1933            "test -")
1934
1935    def test15(self):
1936        """single line #block with nothing for content"""
1937        self.verify(
1938            """#block $testMeth: \nfoo\n#end block\ntest $testMeth-""",
1939            "foo\ntest foo\n-")
1940
1941class IncludeDirective(OutputTest):
1942
1943    def setUp(self):
1944        fp = open('parseTest.txt','w')
1945        fp.write("$numOne $numTwo")
1946        fp.flush()
1947        fp.close
1948
1949    def tearDown(self):
1950        if os.path.exists('parseTest.txt'):
1951            os.remove('parseTest.txt')
1952
1953    def test1(self):
1954        """#include raw of source $emptyString"""
1955        self.verify("#include raw source=$emptyString",
1956                    "")
1957
1958    def test2(self):
1959        """#include raw of source $blockToBeParsed"""
1960        self.verify("#include raw source=$blockToBeParsed",
1961                    "$numOne $numTwo")
1962
1963    def test3(self):
1964        """#include raw of 'parseTest.txt'"""
1965        self.verify("#include raw 'parseTest.txt'",
1966                    "$numOne $numTwo")
1967
1968    def test4(self):
1969        """#include raw of $includeFileName"""
1970        self.verify("#include raw $includeFileName",
1971                    "$numOne $numTwo")
1972
1973    def test5(self):
1974        """#include raw of $includeFileName, with WS"""
1975        self.verify("       #include raw $includeFileName      ",
1976                    "$numOne $numTwo")
1977
1978    def test6(self):
1979        """#include raw of source= , with WS"""
1980        self.verify("       #include raw source='This is my $Source '*2      ",
1981                    "This is my $Source This is my $Source ")
1982
1983    def test7(self):
1984        """#include of $blockToBeParsed"""
1985        self.verify("#include source=$blockToBeParsed",
1986                    "1 2")
1987       
1988    def test8(self):
1989        """#include of $blockToBeParsed, with WS"""
1990        self.verify("   #include source=$blockToBeParsed   ",
1991                    "1 2")
1992
1993    def test9(self):
1994        """#include of 'parseTest.txt', with WS"""
1995        self.verify("   #include source=$blockToBeParsed   ",
1996                    "1 2")
1997
1998    def test10(self):
1999        """#include of "parseTest.txt", with WS"""
2000        self.verify("   #include source=$blockToBeParsed   ",
2001                    "1 2")
2002       
2003    def test11(self):
2004        """#include of 'parseTest.txt', with WS and surrounding text"""
2005        self.verify("aoeu\n  #include source=$blockToBeParsed  \naoeu",
2006                    "aoeu\n1 2aoeu")
2007
2008    def test12(self):
2009        """#include of 'parseTest.txt', with WS and explicit closure"""
2010        self.verify("  #include source=$blockToBeParsed#  ",
2011                    "  1 2  ")
2012
2013
2014class SilentDirective(OutputTest):
2015
2016    def test1(self):
2017        """simple #silent"""
2018        self.verify("#silent $aFunc",
2019                    "")
2020
2021    def test2(self):
2022        """simple #silent"""
2023        self.verify("#silent $anObj.callIt\n$anObj.callArg",
2024                    "1234")
2025
2026        self.verify("#silent $anObj.callIt ##comment\n$anObj.callArg",
2027                    "1234")
2028
2029    def test3(self):
2030        """simple #silent"""
2031        self.verify("#silent $anObj.callIt(99)\n$anObj.callArg",
2032                    "99")
2033
2034class SetDirective(OutputTest):
2035
2036    def test1(self):
2037        """simple #set"""
2038        self.verify("#set $testVar = 'blarg'\n$testVar",
2039                    "blarg")
2040        self.verify("#set testVar = 'blarg'\n$testVar",
2041                    "blarg")
2042
2043
2044        self.verify("#set testVar = 'blarg'##comment\n$testVar",
2045                    "blarg")
2046
2047    def test2(self):
2048        """simple #set with no WS between operands"""
2049        self.verify("#set       $testVar='blarg'",
2050                    "")
2051    def test3(self):
2052        """#set + use of var"""
2053        self.verify("#set $testVar = 'blarg'\n$testVar",
2054                    "blarg")
2055       
2056    def test4(self):
2057        """#set + use in an #include"""
2058        self.verify("#set global $aSetVar = 1234\n#include source=$includeBlock2",
2059                    "1 2 1234")
2060
2061    def test5(self):
2062        """#set with a dictionary"""
2063        self.verify(     """#set $testDict = {'one':'one1','two':'two2','three':'three3'}
2064$testDict.one
2065$testDict.two""",
2066                         "one1\ntwo2")
2067
2068    def test6(self):
2069        """#set with string, then used in #if block"""
2070   
2071        self.verify("""#set $test='a string'\n#if $test#blarg#end if""",
2072                    "blarg")
2073
2074    def test7(self):
2075        """simple #set, gobble WS"""
2076        self.verify("   #set $testVar = 'blarg'   ",
2077                    "")
2078
2079    def test8(self):
2080        """simple #set, don't gobble WS"""
2081        self.verify("  #set $testVar = 'blarg'#---",
2082                    "  ---")
2083
2084    def test9(self):
2085        """simple #set with a list"""
2086        self.verify("   #set $testVar = [1, 2, 3]  \n$testVar",
2087                    "[1, 2, 3]")
2088
2089    def test10(self):
2090        """simple #set global with a list"""
2091        self.verify("   #set global $testVar = [1, 2, 3]  \n$testVar",
2092                    "[1, 2, 3]")
2093
2094    def test11(self):
2095        """simple #set global with a list and *cache
2096
2097        Caching only works with global #set vars.  Local vars are not accesible
2098        to the cache namespace.
2099        """
2100       
2101        self.verify("   #set global $testVar = [1, 2, 3]  \n$*testVar",
2102                    "[1, 2, 3]")
2103
2104    def test12(self):
2105        """simple #set global with a list and *<int>*cache"""
2106        self.verify("   #set global $testVar = [1, 2, 3]  \n$*5*testVar",
2107                    "[1, 2, 3]")
2108
2109    def test13(self):
2110        """simple #set with a list and *<float>*cache"""
2111        self.verify("   #set global $testVar = [1, 2, 3]  \n$*.5*testVar",
2112                    "[1, 2, 3]")
2113
2114    def test14(self):
2115        """simple #set without NameMapper on"""
2116        self.verify("""#compiler useNameMapper = 0\n#set $testVar = 1 \n$testVar""",
2117                    "1")
2118
2119    def test15(self):
2120        """simple #set without $"""
2121        self.verify("""#set testVar = 1 \n$testVar""",
2122                    "1")
2123
2124    def test16(self):
2125        """simple #set global without $"""
2126        self.verify("""#set global testVar = 1 \n$testVar""",
2127                    "1")
2128
2129    def test17(self):
2130        """simple #set module without $"""
2131        self.verify("""#set module __foo__ = 'bar'\n$__foo__""",
2132                    "bar")
2133
2134    def test18(self):
2135        """#set with i,j=list style assignment"""
2136        self.verify("""#set i,j = [1,2]\n$i$j""",
2137                    "12")
2138        self.verify("""#set $i,$j = [1,2]\n$i$j""",
2139                    "12")
2140
2141    def test19(self):
2142        """#set with (i,j)=list style assignment"""
2143        self.verify("""#set (i,j) = [1,2]\n$i$j""",
2144                    "12")
2145        self.verify("""#set ($i,$j) = [1,2]\n$i$j""",
2146                    "12")
2147
2148    def test20(self):
2149        """#set with i, (j,k)=list style assignment"""
2150        self.verify("""#set i, (j,k) = [1,(2,3)]\n$i$j$k""",
2151                    "123")
2152        self.verify("""#set $i, ($j,$k) = [1,(2,3)]\n$i$j$k""",
2153                    "123")
2154
2155
2156class IfDirective(OutputTest):
2157
2158    def test1(self):
2159        """simple #if block"""
2160        self.verify("#if 1\n$aStr\n#end if\n",
2161                    "blarg\n")
2162
2163        self.verify("#if 1:\n$aStr\n#end if\n",
2164                    "blarg\n")
2165
2166        self.verify("#if 1:   \n$aStr\n#end if\n",
2167                    "blarg\n")
2168
2169        self.verify("#if 1: ##comment \n$aStr\n#end if\n",
2170                        "blarg\n")
2171
2172        self.verify("#if 1 ##comment \n$aStr\n#end if\n",
2173                        "blarg\n")
2174
2175        self.verify("#if 1##for i in range(10)#$i#end for##end if",
2176                    '0123456789')
2177
2178        self.verify("#if 1: #for i in range(10)#$i#end for",
2179                    '0123456789')
2180
2181        self.verify("#if 1: #for i in range(10):$i",
2182                    '0123456789')
2183
2184    def test2(self):
2185        """simple #if block, with WS"""
2186        self.verify("   #if 1\n$aStr\n  #end if  \n",
2187                    "blarg\n")
2188    def test3(self):
2189        """simple #if block, with WS and explicit closures"""
2190        self.verify("   #if 1#\n$aStr\n  #end if #--\n",
2191                    "   \nblarg\n  --\n")
2192
2193    def test4(self):
2194        """#if block using $numOne"""
2195        self.verify("#if $numOne\n$aStr\n#end if\n",
2196                    "blarg\n")
2197
2198    def test5(self):
2199        """#if block using $zero"""
2200        self.verify("#if $zero\n$aStr\n#end if\n",
2201                    "")
2202    def test6(self):
2203        """#if block using $emptyString"""
2204        self.verify("#if $emptyString\n$aStr\n#end if\n",
2205                    "")
2206    def test7(self):
2207        """#if ... #else ... block using a $emptyString"""
2208        self.verify("#if $emptyString\n$anInt\n#else\n$anInt - $anInt\n#end if",
2209                    "1 - 1\n")
2210       
2211    def test8(self):
2212        """#if ... #elif ... #else ... block using a $emptyString"""
2213        self.verify("#if $emptyString\n$c\n#elif $numOne\n$numOne\n#else\n$c - $c\n#end if",
2214                    "1\n")
2215
2216    def test9(self):
2217        """#if 'not' test, with #slurp"""
2218        self.verify("#if not $emptyString\n$aStr#slurp\n#end if\n",
2219                    "blarg")
2220
2221    def test10(self):
2222        """#if block using $*emptyString
2223
2224        This should barf
2225        """
2226        try:
2227            self.verify("#if $*emptyString\n$aStr\n#end if\n",
2228                        "")
2229        except ParseError:
2230            pass
2231        else:
2232            self.fail('This should barf')
2233
2234    def test11(self):
2235        """#if block using invalid top-level $(placeholder) syntax - should barf"""
2236
2237        for badSyntax in ("#if $*5*emptyString\n$aStr\n#end if\n",
2238                          "#if ${emptyString}\n$aStr\n#end if\n",
2239                          "#if $(emptyString)\n$aStr\n#end if\n",
2240                          "#if $[emptyString]\n$aStr\n#end if\n",
2241                          "#if $!emptyString\n$aStr\n#end if\n",
2242                          ):
2243            try:
2244                self.verify(badSyntax, "")
2245            except ParseError:
2246                pass
2247            else:
2248                self.fail('This should barf')
2249           
2250    def test12(self):
2251        """#if ... #else if ... #else ... block using a $emptyString
2252        Same as test 8 but using else if instead of elif"""
2253        self.verify("#if $emptyString\n$c\n#else if $numOne\n$numOne\n#else\n$c - $c\n#end if",
2254                    "1\n")
2255
2256
2257    def test13(self):
2258        """#if# ... #else # ... block using a $emptyString with """
2259        self.verify("#if $emptyString# $anInt#else#$anInt - $anInt#end if",
2260                    "1 - 1")
2261
2262    def test14(self):
2263        """single-line #if: simple"""
2264        self.verify("#if $emptyString then 'true' else 'false'",
2265                    "false")
2266
2267    def test15(self):
2268        """single-line #if: more complex"""
2269        self.verify("#if $anInt then 'true' else 'false'",
2270                    "true")
2271
2272    def test16(self):
2273        """single-line #if: with the words 'else' and 'then' in the output """
2274        self.verify("#if ($anInt and not $emptyString==''' else ''') then $str('then') else 'else'",
2275                    "then")
2276
2277    def test17(self):
2278        """single-line #if:  """
2279        self.verify("#if 1: foo\n#if 0: bar\n#if 1: foo",
2280                    "foo\nfoo")
2281
2282
2283        self.verify("#if 1: foo\n#if 0: bar\n#if 1: foo",
2284                    "foo\nfoo")
2285
2286    def test18(self):
2287        """single-line #if: \n#else: """
2288        self.verify("#if 1: foo\n#elif 0: bar",
2289                    "foo\n")
2290
2291        self.verify("#if 1: foo\n#elif 0: bar\n#else: blarg\n",
2292                    "foo\n")
2293
2294        self.verify("#if 0: foo\n#elif 0: bar\n#else: blarg\n",
2295                    "blarg\n")
2296
2297class UnlessDirective(OutputTest):
2298   
2299    def test1(self):
2300        """#unless 1"""
2301        self.verify("#unless 1\n 1234 \n#end unless",
2302                    "")
2303
2304        self.verify("#unless 1:\n 1234 \n#end unless",
2305                    "")
2306
2307        self.verify("#unless 1: ##comment\n 1234 \n#end unless",
2308                    "")
2309
2310        self.verify("#unless 1 ##comment\n 1234 \n#end unless",
2311                    "")
2312
2313
2314    def test2(self):
2315        """#unless 0"""
2316        self.verify("#unless 0\n 1234 \n#end unless",
2317                    " 1234 \n")
2318
2319    def test3(self):
2320        """#unless $none"""
2321        self.verify("#unless $none\n 1234 \n#end unless",
2322                    " 1234 \n")
2323
2324    def test4(self):
2325        """#unless $numTwo"""
2326        self.verify("#unless $numTwo\n 1234 \n#end unless",
2327                    "")
2328
2329    def test5(self):
2330        """#unless $numTwo with WS"""
2331        self.verify("   #unless $numTwo   \n 1234 \n    #end unless   ",
2332                    "")
2333
2334    def test6(self):
2335        """single-line #unless"""
2336        self.verify("#unless 1: 1234", "")
2337        self.verify("#unless 0: 1234", "1234")
2338        self.verify("#unless 0: 1234\n"*2, "1234\n"*2)
2339       
2340class PSP(OutputTest):
2341   
2342    def test1(self):
2343        """simple <%= [int] %>"""
2344        self.verify("<%= 1234 %>",  "1234")
2345
2346    def test2(self):
2347        """simple <%= [string] %>"""
2348        self.verify("<%= 'blarg' %>", "blarg")
2349
2350    def test3(self):
2351        """simple <%= None %>"""
2352        self.verify("<%= None %>", "")
2353    def test4(self):
2354        """simple <%= [string] %> + $anInt"""
2355        self.verify("<%= 'blarg' %>$anInt", "blarg1")
2356
2357    def test5(self):
2358        """simple <%= [EXPR] %> + $anInt"""
2359        self.verify("<%= ('blarg'*2).upper() %>$anInt", "BLARGBLARG1")
2360
2361    def test6(self):
2362        """for loop in <%%>"""
2363        self.verify("<% for i in range(5):%>1<%end%>", "11111")
2364
2365    def test7(self):
2366        """for loop in <%%> and using <%=i%>"""
2367        self.verify("<% for i in range(5):%><%=i%><%end%>", "01234")
2368
2369    def test8(self):
2370        """for loop in <% $%> and using <%=i%>"""
2371        self.verify("""<% for i in range(5):
2372    i=i*2$%><%=i%><%end%>""", "02468")
2373
2374    def test9(self):
2375        """for loop in <% $%> and using <%=i%> plus extra text"""
2376        self.verify("""<% for i in range(5):
2377    i=i*2$%><%=i%>-<%end%>""", "0-2-4-6-8-")
2378
2379
2380class WhileDirective(OutputTest):
2381    def test1(self):
2382        """simple #while with a counter"""
2383        self.verify("#set $i = 0\n#while $i < 5\n$i#slurp\n#set $i += 1\n#end while",
2384                    "01234")
2385
2386class ContinueDirective(OutputTest):
2387    def test1(self):
2388        """#continue with a #while"""
2389        self.verify("""#set $i = 0
2390#while $i < 5
2391#if $i == 3
2392  #set $i += 1       
2393  #continue
2394#end if
2395$i#slurp
2396#set $i += 1
2397#end while""",
2398        "0124")
2399
2400    def test2(self):
2401        """#continue with a #for"""
2402        self.verify("""#for $i in range(5)
2403#if $i == 3
2404  #continue
2405#end if
2406$i#slurp
2407#end for""",
2408        "0124")
2409
2410class BreakDirective(OutputTest):
2411    def test1(self):
2412        """#break with a #while"""
2413        self.verify("""#set $i = 0
2414#while $i < 5
2415#if $i == 3
2416  #break
2417#end if
2418$i#slurp
2419#set $i += 1
2420#end while""",
2421        "012")
2422
2423    def test2(self):
2424        """#break with a #for"""
2425        self.verify("""#for $i in range(5)
2426#if $i == 3
2427  #break
2428#end if
2429$i#slurp
2430#end for""",
2431        "012")
2432
2433
2434class TryDirective(OutputTest):
2435
2436    def test1(self):
2437        """simple #try
2438        """
2439        self.verify("#try\n1234\n#except\nblarg\n#end try",
2440                    "1234\n")
2441
2442    def test2(self):
2443        """#try / #except with #raise
2444        """
2445        self.verify("#try\n#raise ValueError\n#except\nblarg\n#end try",
2446                    "blarg\n")
2447       
2448    def test3(self):
2449        """#try / #except with #raise + WS
2450
2451        Should gobble
2452        """
2453        self.verify("  #try  \n  #raise ValueError \n  #except \nblarg\n  #end try",
2454                    "blarg\n")
2455
2456
2457    def test4(self):
2458        """#try / #except with #raise + WS and leading text
2459       
2460        Shouldn't gobble
2461        """
2462        self.verify("--#try  \n  #raise ValueError \n  #except \nblarg\n  #end try#--",
2463                    "--\nblarg\n  --")
2464
2465    def test5(self):
2466        """nested #try / #except with #raise
2467        """
2468        self.verify(
2469"""#try
2470  #raise ValueError
2471#except
2472  #try
2473   #raise ValueError
2474  #except
2475blarg
2476  #end try
2477#end try""",
2478                    "blarg\n")
2479
2480class PassDirective(OutputTest):
2481    def test1(self):
2482        """#pass in a #try / #except block
2483        """
2484        self.verify("#try\n#raise ValueError\n#except\n#pass\n#end try",
2485                    "")
2486
2487    def test2(self):
2488        """#pass in a #try / #except block + WS
2489        """
2490        self.verify("  #try  \n  #raise ValueError  \n  #except  \n   #pass   \n   #end try",
2491                    "")
2492
2493
2494class AssertDirective(OutputTest):
2495    def test1(self):
2496        """simple #assert
2497        """
2498        self.verify("#set $x = 1234\n#assert $x == 1234",
2499                    "")
2500
2501    def test2(self):
2502        """simple #assert that fails
2503        """
2504        def test(self=self):
2505            self.verify("#set $x = 1234\n#assert $x == 999",
2506                        ""),
2507        self.failUnlessRaises(AssertionError, test)
2508       
2509    def test3(self):
2510        """simple #assert with WS
2511        """
2512        self.verify("#set $x = 1234\n   #assert $x == 1234   ",
2513                    "")
2514
2515
2516class RaiseDirective(OutputTest):
2517    def test1(self):
2518        """simple #raise ValueError
2519
2520        Should raise ValueError
2521        """
2522        def test(self=self):
2523            self.verify("#raise ValueError",
2524                        ""),
2525        self.failUnlessRaises(ValueError, test)
2526                             
2527    def test2(self):
2528        """#raise ValueError in #if block
2529
2530        Should raise ValueError
2531        """
2532        def test(self=self):
2533            self.verify("#if 1\n#raise ValueError\n#end if\n",
2534                        "")
2535        self.failUnlessRaises(ValueError, test)
2536
2537
2538    def test3(self):
2539        """#raise ValueError in #if block
2540
2541        Shouldn't raise ValueError
2542        """
2543        self.verify("#if 0\n#raise ValueError\n#else\nblarg#end if\n",
2544                    "blarg\n")
2545
2546
2547
2548class ImportDirective(OutputTest):
2549    def test1(self):
2550        """#import math
2551        """
2552        self.verify("#import math",
2553                    "")
2554
2555    def test2(self):
2556        """#import math + WS
2557
2558        Should gobble
2559        """
2560        self.verify("    #import math    ",
2561                    "")
2562
2563    def test3(self):
2564        """#import math + WS + leading text
2565       
2566        Shouldn't gobble
2567        """
2568        self.verify("  --  #import math    ",
2569                    "  --  ")
2570       
2571    def test4(self):
2572        """#from math import syn
2573        """
2574        self.verify("#from math import cos",
2575                    "")
2576
2577    def test5(self):
2578        """#from math import cos  + WS
2579        Should gobble
2580        """
2581        self.verify("    #from math import cos  ",
2582                    "")
2583
2584    def test6(self):
2585        """#from math import cos  + WS + leading text
2586        Shouldn't gobble
2587        """
2588        self.verify("  --  #from math import cos  ",
2589                    "  --  ")
2590
2591    def test7(self):
2592        """#from math import cos -- use it
2593        """
2594        self.verify("#from math import cos\n$cos(0)",
2595                    "1.0")
2596
2597    def test8(self):
2598        """#from math import cos,tan,sin -- and use them
2599        """
2600        self.verify("#from math import cos, tan, sin\n$cos(0)-$tan(0)-$sin(0)",
2601                    "1.0-0.0-0.0")
2602
2603    def test9(self):
2604        """#import os.path -- use it
2605        """
2606       
2607        self.verify("#import os.path\n$os.path.exists('.')",
2608                    repr(True))
2609
2610    def test10(self):
2611        """#import os.path -- use it with NameMapper turned off
2612        """
2613        self.verify("""##
2614#compiler-settings
2615useNameMapper=False
2616#end compiler-settings
2617#import os.path
2618$os.path.exists('.')""",
2619                    repr(True))
2620
2621    def test11(self):
2622        """#from math import *
2623        """
2624       
2625        self.verify("#from math import *\n$pow(1,2) $log10(10)",
2626                    "1.0 1.0")
2627
2628class CompilerDirective(OutputTest):
2629    def test1(self):
2630        """overriding the commentStartToken
2631        """
2632        self.verify("""$anInt##comment
2633#compiler commentStartToken = '//'
2634$anInt//comment
2635""",
2636                    "1\n1\n")
2637
2638    def test2(self):
2639        """overriding and resetting the commentStartToken
2640        """
2641        self.verify("""$anInt##comment
2642#compiler commentStartToken = '//'
2643$anInt//comment
2644#compiler reset
2645$anInt//comment
2646""",
2647                    "1\n1\n1//comment\n")
2648
2649
2650class CompilerSettingsDirective(OutputTest):
2651   
2652    def test1(self):
2653        """overriding the cheetahVarStartToken
2654        """
2655        self.verify("""$anInt
2656#compiler-settings
2657cheetahVarStartToken = @
2658#end compiler-settings
2659@anInt
2660#compiler-settings reset
2661$anInt
2662""",
2663                    "1\n1\n1\n")
2664
2665    def test2(self):
2666        """overriding the directiveStartToken
2667        """
2668        self.verify("""#set $x = 1234
2669$x
2670#compiler-settings
2671directiveStartToken = @
2672#end compiler-settings
2673@set $x = 1234
2674$x
2675""",
2676                    "1234\n1234\n")
2677
2678    def test3(self):
2679        """overriding the commentStartToken
2680        """
2681        self.verify("""$anInt##comment
2682#compiler-settings
2683commentStartToken = //
2684#end compiler-settings
2685$anInt//comment
2686""",
2687                    "1\n1\n")
2688
2689if sys.platform.startswith('java'):
2690    del CompilerDirective
2691    del CompilerSettingsDirective
2692
2693class ExtendsDirective(OutputTest):
2694
2695    def test1(self):
2696        """#extends Cheetah.Templates._SkeletonPage"""
2697        self.verify("""#from Cheetah.Templates._SkeletonPage import _SkeletonPage
2698#extends _SkeletonPage
2699#implements respond
2700$spacer()
2701""",
2702                    '<img src="spacer.gif" width="1" height="1" alt="" />\n')
2703
2704
2705        self.verify("""#from Cheetah.Templates._SkeletonPage import _SkeletonPage
2706#extends _SkeletonPage
2707#implements respond(foo=1234)
2708$spacer()$foo
2709""",
2710                    '<img src="spacer.gif" width="1" height="1" alt="" />1234\n')
2711
2712    def test2(self):
2713        """#extends Cheetah.Templates.SkeletonPage without #import"""
2714        self.verify("""#extends Cheetah.Templates.SkeletonPage
2715#implements respond
2716$spacer()
2717""",
2718                    '<img src="spacer.gif" width="1" height="1" alt="" />\n')
2719
2720    def test3(self):
2721        """#extends Cheetah.Templates.SkeletonPage.SkeletonPage without #import"""
2722        self.verify("""#extends Cheetah.Templates.SkeletonPage.SkeletonPage
2723#implements respond
2724$spacer()
2725""",
2726                    '<img src="spacer.gif" width="1" height="1" alt="" />\n')
2727
2728    def test4(self):
2729        """#extends with globals and searchList test"""
2730        self.verify("""#extends Cheetah.Templates.SkeletonPage
2731#set global g="Hello"
2732#implements respond
2733$g $numOne
2734""",
2735                    'Hello 1\n')
2736
2737
2738class SuperDirective(OutputTest):
2739    def test1(self):
2740        tmpl1 = Template.compile('''$foo $bar(99)
2741        #def foo: this is base foo
2742        #def bar(arg): super-$arg''')
2743
2744        tmpl2 = tmpl1.subclass('''
2745        #implements dummy
2746        #def foo
2747          #super
2748          This is child foo
2749          #super(trans=trans)
2750          $bar(1234)
2751        #end def
2752        #def bar(arg): #super($arg)
2753        ''')
2754        expected = ('this is base foo          '
2755                    'This is child foo\nthis is base foo          '
2756                    'super-1234\n super-99')
2757        assert str(tmpl2()).strip()==expected
2758
2759
2760class ImportantExampleCases(OutputTest):
2761    def test1(self):
2762        """how to make a comma-delimited list"""
2763        self.verify("""#set $sep = ''
2764#for $letter in $letterList
2765$sep$letter#slurp
2766#set $sep = ', '
2767#end for
2768""",
2769                    "a, b, c")
2770
2771class FilterDirective(OutputTest):
2772    convertEOLs=False
2773
2774    def _getCompilerSettings(self):
2775        return {'useFilterArgsInPlaceholders':True}
2776   
2777    def test1(self):
2778        """#filter Filter
2779        """
2780        self.verify("#filter Filter\n$none#end filter",
2781                    "")
2782
2783        self.verify("#filter Filter: $none",
2784                    "")
2785
2786    def test2(self):
2787        """#filter ReplaceNone with WS
2788        """
2789        self.verify("#filter Filter  \n$none#end filter",
2790                    "")
2791
2792    def test3(self):
2793        """#filter MaxLen -- maxlen of 5"""
2794
2795        self.verify("#filter MaxLen  \n${tenDigits, $maxlen=5}#end filter",
2796                    "12345")
2797
2798    def test4(self):
2799        """#filter MaxLen -- no maxlen
2800        """
2801        self.verify("#filter MaxLen  \n${tenDigits}#end filter",
2802                    "1234567890")
2803
2804    def test5(self):
2805        """#filter WebSafe -- basic usage
2806        """
2807        self.verify("#filter WebSafe  \n$webSafeTest#end filter",
2808                    "abc &lt;=&gt; &amp;")
2809
2810    def test6(self):
2811        """#filter WebSafe -- also space
2812        """
2813        self.verify("#filter WebSafe  \n${webSafeTest, $also=' '}#end filter",
2814                    "abc&nbsp;&lt;=&gt;&nbsp;&amp;")
2815       
2816    def test7(self):
2817        """#filter WebSafe -- also space, without $ on the args
2818        """
2819        self.verify("#filter WebSafe  \n${webSafeTest, also=' '}#end filter",
2820                    "abc&nbsp;&lt;=&gt;&nbsp;&amp;")
2821
2822    def test8(self):
2823        """#filter Strip -- trailing newline
2824        """
2825        self.verify("#filter Strip\n$strip1#end filter",
2826                    "strippable whitespace\n")
2827
2828    def test9(self):
2829        """#filter Strip -- no trailing newine
2830        """
2831        self.verify("#filter Strip\n$strip2#end filter",
2832                    "strippable whitespace")
2833
2834    def test10(self):
2835        """#filter Strip -- multi-line
2836        """
2837        self.verify("#filter Strip\n$strip3#end filter",
2838                    "strippable whitespace\n1 2  3\n")
2839
2840    def test11(self):
2841        """#filter StripSqueeze -- canonicalize all whitespace to ' '
2842        """
2843        self.verify("#filter StripSqueeze\n$strip3#end filter",
2844                    "strippable whitespace 1 2 3")
2845
2846
2847class EchoDirective(OutputTest):
2848    def test1(self):
2849        """#echo 1234
2850        """
2851        self.verify("#echo 1234",
2852                    "1234")
2853
2854class SilentDirective(OutputTest):
2855    def test1(self):
2856        """#silent 1234
2857        """
2858        self.verify("#silent 1234",
2859                    "")
2860
2861class ErrorCatcherDirective(OutputTest):
2862    pass
2863
2864
2865class VarExists(OutputTest):               # Template.varExists()
2866   
2867    def test1(self):
2868        """$varExists('$anInt')
2869        """
2870        self.verify("$varExists('$anInt')",
2871                    repr(True))
2872
2873    def test2(self):
2874        """$varExists('anInt')
2875        """
2876        self.verify("$varExists('anInt')",
2877                    repr(True))
2878
2879    def test3(self):
2880        """$varExists('$anInt')
2881        """
2882        self.verify("$varExists('$bogus')",
2883                    repr(False))
2884
2885    def test4(self):
2886        """$varExists('$anInt') combined with #if false
2887        """
2888        self.verify("#if $varExists('$bogus')\n1234\n#else\n999\n#end if",
2889                    "999\n")
2890
2891    def test5(self):
2892        """$varExists('$anInt') combined with #if true
2893        """
2894        self.verify("#if $varExists('$anInt')\n1234\n#else\n999#end if",
2895                    "1234\n")
2896
2897class GetVar(OutputTest):               # Template.getVar()
2898    def test1(self):
2899        """$getVar('$anInt')
2900        """
2901        self.verify("$getVar('$anInt')",
2902                    "1")
2903
2904    def test2(self):
2905        """$getVar('anInt')
2906        """
2907        self.verify("$getVar('anInt')",
2908                    "1")
2909
2910    def test3(self):
2911        """$self.getVar('anInt')
2912        """
2913        self.verify("$self.getVar('anInt')",
2914                    "1")
2915       
2916    def test4(self):
2917        """$getVar('bogus', 1234)
2918        """
2919        self.verify("$getVar('bogus',  1234)",
2920                    "1234")
2921       
2922    def test5(self):
2923        """$getVar('$bogus', 1234)
2924        """
2925        self.verify("$getVar('$bogus',  1234)",
2926                    "1234")
2927
2928
2929class MiscComplexSyntax(OutputTest):
2930    def test1(self):
2931        """Complex use of {},[] and () in a #set expression
2932        ----
2933        #set $c = {'A':0}[{}.get('a', {'a' : 'A'}['a'])]
2934        $c
2935        """
2936        self.verify("#set $c = {'A':0}[{}.get('a', {'a' : 'A'}['a'])]\n$c",
2937                    "0")
2938
2939
2940class CGI(OutputTest):
2941    """CGI scripts with(out) the CGI environment and with(out) GET variables.
2942    """
2943    convertEOLs=False
2944   
2945    def _beginCGI(self): 
2946        os.environ['REQUEST_METHOD'] = "GET"
2947    def _endCGI(self): 
2948        try:
2949            del os.environ['REQUEST_METHOD']
2950        except KeyError:
2951            pass
2952    _guaranteeNoCGI = _endCGI
2953
2954
2955    def test1(self):
2956        """A regular template."""
2957        self._guaranteeNoCGI()
2958        source = "#extends Cheetah.Tools.CGITemplate\n" + \
2959                 "#implements respond\n" + \
2960                 "$cgiHeaders#slurp\n" + \
2961                 "Hello, world!"
2962        self.verify(source, "Hello, world!")
2963
2964
2965    def test2(self):
2966        """A CGI script."""
2967        self._beginCGI()
2968        source = "#extends Cheetah.Tools.CGITemplate\n" + \
2969                 "#implements respond\n" + \
2970                 "$cgiHeaders#slurp\n" + \
2971                 "Hello, world!"
2972        self.verify(source, "Content-type: text/html\n\nHello, world!")
2973        self._endCGI()
2974
2975
2976    def test3(self):
2977        """A (pseudo) Webware servlet.
2978           
2979           This uses the Python syntax escape to set
2980           self._CHEETAH__isControlledByWebKit.           
2981           We could instead do '#silent self._CHEETAH__isControlledByWebKit = True',
2982           taking advantage of the fact that it will compile unchanged as long
2983           as there's no '$' in the statement.  (It won't compile with an '$'
2984           because that would convert to a function call, and you can't assign
2985           to a function call.)  Because this isn't really being called from
2986           Webware, we'd better not use any Webware services!  Likewise, we'd
2987           better not call $cgiImport() because it would be misled.
2988        """
2989        self._beginCGI()
2990        source = "#extends Cheetah.Tools.CGITemplate\n" + \
2991                 "#implements respond\n" + \
2992                 "<% self._CHEETAH__isControlledByWebKit = True %>#slurp\n" + \
2993                 "$cgiHeaders#slurp\n" + \
2994                 "Hello, world!"
2995        self.verify(source, "Hello, world!")
2996        self._endCGI()
2997
2998
2999    def test4(self):
3000        """A CGI script with a GET variable."""
3001        self._beginCGI()
3002        os.environ['QUERY_STRING'] = "cgiWhat=world"
3003        source = "#extends Cheetah.Tools.CGITemplate\n" + \
3004                 "#implements respond\n" + \
3005                 "$cgiHeaders#slurp\n" + \
3006                 "#silent $webInput(['cgiWhat'])##slurp\n" + \
3007                 "Hello, $cgiWhat!"
3008        self.verify(source,
3009                    "Content-type: text/html\n\nHello, world!")
3010        del os.environ['QUERY_STRING']
3011        self._endCGI()
3012
3013
3014
3015class WhitespaceAfterDirectiveTokens(OutputTest):
3016    def _getCompilerSettings(self):
3017        return {'allowWhitespaceAfterDirectiveStartToken':True}
3018
3019    def test1(self):
3020        self.verify("# for i in range(10): $i",
3021                    "0123456789")
3022        self.verify("# for i in range(10)\n$i# end for",
3023                    "0123456789")
3024        self.verify("# for i in range(10)#$i#end for",
3025                    "0123456789")
3026
3027
3028
3029class DefmacroDirective(OutputTest):
3030    def _getCompilerSettings(self):
3031        def aMacro(src):
3032            return '$aStr'
3033       
3034        return {'macroDirectives':{'aMacro':aMacro
3035                                   }}
3036
3037    def test1(self):
3038        self.verify("""\
3039#defmacro inc: #set @src +=1
3040#set i = 1
3041#inc: $i
3042$i""",
3043                    "2")
3044
3045
3046
3047        self.verify("""\
3048#defmacro test
3049#for i in range(10): @src
3050#end defmacro
3051#test: $i-foo#slurp
3052#for i in range(3): $i""",
3053                    "0-foo1-foo2-foo3-foo4-foo5-foo6-foo7-foo8-foo9-foo012")
3054
3055        self.verify("""\
3056#defmacro test
3057#for i in range(10): @src
3058#end defmacro
3059#test: $i-foo
3060#for i in range(3): $i""",
3061  "0-foo\n1-foo\n2-foo\n3-foo\n4-foo\n5-foo\n6-foo\n7-foo\n8-foo\n9-foo\n012")
3062
3063
3064        self.verify("""\
3065#defmacro test: #for i in range(10): @src
3066#test: $i-foo#slurp
3067-#for i in range(3): $i""",
3068                    "0-foo1-foo2-foo3-foo4-foo5-foo6-foo7-foo8-foo9-foo-012")
3069
3070        self.verify("""\
3071#defmacro test##for i in range(10): @src#end defmacro##slurp
3072#test: $i-foo#slurp
3073-#for i in range(3): $i""",
3074                    "0-foo1-foo2-foo3-foo4-foo5-foo6-foo7-foo8-foo9-foo-012")
3075
3076        self.verify("""\
3077#defmacro testFoo: nothing
3078#defmacro test(foo=1234): #for i in range(10): @src
3079#test foo=234: $i-foo#slurp
3080-#for i in range(3): $i""",
3081                    "0-foo1-foo2-foo3-foo4-foo5-foo6-foo7-foo8-foo9-foo-012")
3082
3083        self.verify("""\
3084#defmacro testFoo: nothing
3085#defmacro test(foo=1234): #for i in range(10): @src@foo
3086#test foo='-foo'#$i#end test#-#for i in range(3): $i""",
3087                    "0-foo1-foo2-foo3-foo4-foo5-foo6-foo7-foo8-foo9-foo-012")
3088
3089        self.verify("""\
3090#defmacro testFoo: nothing
3091#defmacro test(foo=1234): #for i in range(10): @src.strip()@foo
3092#test foo='-foo': $i
3093-#for i in range(3): $i""",
3094                    "0-foo1-foo2-foo3-foo4-foo5-foo6-foo7-foo8-foo9-foo-012")
3095
3096    def test2(self):
3097        self.verify("#aMacro: foo",
3098                    "blarg")
3099        self.verify("#defmacro nested: @macros.aMacro(@src)\n#nested: foo",
3100                    "blarg")
3101
3102
3103class Indenter(OutputTest):
3104    convertEOLs=False
3105   
3106    source = """
3107public class X
3108{
3109    #for $method in $methods
3110        $getMethod($method)
3111       
3112    #end for
3113}
3114//end of class
3115
3116#def getMethod($method)
3117    #indent ++
3118    public $getType($method) ${method.Name}($getParams($method.Params));
3119    #indent --
3120#end def
3121
3122#def getParams($params)
3123    #indent off
3124
3125    #for $counter in $range($len($params))
3126        #if $counter == len($params) - 1
3127                       $params[$counter]#slurp
3128        #else:
3129                       $params[$counter],
3130        #end if
3131    #end for
3132    #indent on
3133#end def
3134
3135#def getType($method)
3136    #indent push
3137    #indent=0
3138    #if $method.Type == "VT_VOID"
3139        void#slurp
3140    #elif $method.Type == "VT_INT"
3141        int#slurp
3142    #elif $method.Type == "VT_VARIANT"
3143        Object#slurp
3144    #end if
3145    #indent pop
3146#end def
3147"""
3148
3149    control = """
3150public class X
3151{
3152    public void Foo(
3153                       _input,
3154                       _output);
3155
3156
3157    public int Bar(
3158                       _str1,
3159                       str2,
3160                       _str3);
3161
3162
3163    public Object Add(
3164                       value1,
3165                       value);
3166
3167
3168}
3169//end of class
3170
3171
3172
3173"""
3174    def _getCompilerSettings(self):
3175        return {'useFilterArgsInPlaceholders':True}
3176
3177    def searchList(self):    # Inside Indenter class.
3178        class Method:
3179            def __init__(self, _name, _type, *_params):
3180                self.Name = _name
3181                self.Type = _type
3182                self.Params = _params
3183        methods = [Method("Foo", "VT_VOID", "_input", "_output"),
3184                   Method("Bar", "VT_INT", "_str1", "str2", "_str3"),
3185                   Method("Add", "VT_VARIANT", "value1", "value")]
3186        return [{"methods": methods}]
3187
3188    def test1(self):    # Inside Indenter class.
3189        self.verify(self.source, self.control)
3190
3191
3192##################################################
3193## CREATE CONVERTED EOL VERSIONS OF THE TEST CASES
3194
3195if OutputTest._useNewStyleCompilation and versionTuple >= (2,3):
3196    extraCompileKwArgsForDiffBaseclass = {'baseclass':dict}
3197else:
3198    extraCompileKwArgsForDiffBaseclass = {'baseclass':object}
3199   
3200
3201def install_eols():
3202    klasses = [v for v in globals().values() if isinstance(v, (types.ClassType, types.TypeType)) and issubclass(v, unittest.TestCase)]
3203    for klass in klasses:
3204        name = klass.__name__       
3205        if hasattr(klass,'convertEOLs') and klass.convertEOLs:
3206            win32Src = r"class %(name)s_Win32EOL(%(name)s): _EOLreplacement = '\r\n'"%locals()
3207            macSrc = r"class %(name)s_MacEOL(%(name)s): _EOLreplacement = '\r'"%locals()
3208            exec win32Src in globals()
3209            exec macSrc in globals()
3210
3211        if versionTuple >= (2,3):
3212            src = r"class %(name)s_DiffBaseClass(%(name)s): "%locals()
3213            src += " _extraCompileKwArgs = extraCompileKwArgsForDiffBaseclass"
3214            exec src in globals()
3215
3216        del name
3217        del klass
3218
3219##################################################
3220## if run from the command line ##
3221       
3222if __name__ == '__main__':
3223    install_eols()
3224    unittest.main()
3225
3226# vim: shiftwidth=4 tabstop=4 expandtab
Note: リポジトリブラウザについてのヘルプは TracBrowser を参照してください。