Cheetah.Tests.SyntaxAndOutput module¶
Syntax and Output tests.
TODO - #finally - #filter - #errorCatcher - #echo - #silent
- class Cheetah.Tests.SyntaxAndOutput.AssertDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- simple #assert 
 - test2()¶
- simple #assert that fails 
 - test3()¶
- simple #assert with WS 
 
- class Cheetah.Tests.SyntaxAndOutput.AttrDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #attr with int 
 - test2()¶
- #attr with string 
 - test3()¶
- #attr with expression 
 - test4()¶
- #attr with string + WS Should gobble 
 - test5()¶
- #attr with string + WS + leading text Shouldn’t gobble 
 
- class Cheetah.Tests.SyntaxAndOutput.Backslashes(methodName='runTest')¶
- Bases: - OutputTest- convertEOLs = False¶
 - setUp()¶
- Hook method for setting up the test fixture before exercising it. 
 - tearDown()¶
- Hook method for deconstructing the test fixture after testing it. 
 - test1()¶
- a single using rawstrings 
 - test2()¶
- a single using rawstrings and lots of lines 
 - test3()¶
- a single without using rawstrings 
 - test4()¶
- single line from an apache conf file 
 - test5()¶
- single line from an apache conf file with many NEWLINES - The NEWLINES are used to make sure that MethodCompiler.commitStrConst() is handling long and short strings in the same fashion. It uses triple-quotes for strings with lots of n in them and repr(theStr) for shorter strings with only a few newlines. 
 - test6()¶
- test backslash handling in an included file 
 - test7()¶
- a single without using rawstrings plus many NEWLINES 
 - test8()¶
- Single line from an apache conf file with single quotes and many NEWLINES 
 
- class Cheetah.Tests.SyntaxAndOutput.BlockDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #block without argstring 
 - test10()¶
- single line #block 1 escaped $placeholders + more WS 
 - test11()¶
- multiline #block $ on argstring 
 - test12()¶
- single line #block with $ on methodName 
 - test13()¶
- single line #block with an arg 
 - test14()¶
- single line #block with None for content 
 - test15()¶
- single line #block with nothing for content 
 - test2()¶
- #block without argstring, gobble WS 
 - test3()¶
- #block with argstring, gobble WS - Because blocks can be reused in multiple parts of the template arguments (!!with defaults!!) can be given. 
 - test4()¶
- #block with 2 args, gobble WS 
 - test5()¶
- #block with 2 nested blocks - Blocks can be nested to any depth and the name of the block is optional for the #end block part: #end block OR #end block [name] 
 - test6()¶
- single line #block 
 - test7()¶
- single line #block with WS 
 - test8()¶
- single line #block 1 escaped $placeholders 
 - test9()¶
- single line #block 1 escaped $placeholders + WS 
 
- class Cheetah.Tests.SyntaxAndOutput.BreakDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #break with a #while 
 - test2()¶
- #break with a #for 
 
- class Cheetah.Tests.SyntaxAndOutput.BreakpointDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #breakpoint part way through source code 
 - test2()¶
- #breakpoint at BOF 
 - test3()¶
- #breakpoint at EOF 
 
- class Cheetah.Tests.SyntaxAndOutput.CGI(methodName='runTest')¶
- Bases: - OutputTest- CGI scripts with(out) the CGI environment and with(out) GET variables. - convertEOLs = False¶
 - test1()¶
- A regular template. 
 - test2()¶
- A CGI script. 
 - test3()¶
- A (pseudo) Webware servlet. - This uses the Python syntax escape to set self._CHEETAH__isControlledByWebKit. We could instead do ‘#silent self._CHEETAH__isControlledByWebKit = True’, taking advantage of the fact that it will compile unchanged as long as there’s no ‘$’ in the statement. (It won’t compile with an ‘$’ because that would convert to a function call, and you can’t assign to a function call.) Because this isn’t really being called from Webware, we’d better not use any Webware services! Likewise, we’d better not call $cgiImport() because it would be misled. 
 - test4()¶
- A CGI script with a GET variable. 
 
- class Cheetah.Tests.SyntaxAndOutput.CacheDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- simple #cache 
 - test2()¶
- simple #cache + WS 
 - test3()¶
- simple #cache … #end cache 
 - test4()¶
- 2 #cache … #end cache blocks 
 - test5()¶
- nested #cache blocks 
 - test6()¶
- Make sure that partial directives don’t match 
 
- class Cheetah.Tests.SyntaxAndOutput.CallDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- simple #call 
 - test2()¶
- simple #call + WS 
 - test3()¶
- a longer #call 
 - test4()¶
- #call with keyword #args 
 - test5()¶
- #call with single-line keyword #args 
 - test6()¶
- #call with python kwargs and cheetah output for the 1s positional arg 
 - test7()¶
- #call with python kwargs and #args 
 - test8()¶
- #call with python kwargs and #args, and using a function to get the function that will be called 
 - test9()¶
- nested #call directives 
 
- class Cheetah.Tests.SyntaxAndOutput.CaptureDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- simple #capture 
 - test2()¶
- slightly more complex #capture 
 
- class Cheetah.Tests.SyntaxAndOutput.Comments_MultiLine(methodName='runTest')¶
- Bases: - OutputTest- Note: Multiline comments don’t gobble whitespace! - test10()¶
- text around #* *# containing #for directive and trailing whitespace which should be gobbled 
 
- class Cheetah.Tests.SyntaxAndOutput.Comments_MultiLine_NoGobble(methodName='runTest')¶
- Bases: - OutputTest- Multiline comments used to not gobble whitespace - They do now, but this can be turned off with a compilerSetting. 
- class Cheetah.Tests.SyntaxAndOutput.Comments_SingleLine(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- ## followed by WS 
 - test10()¶
- ## containing $placeholders 
 - test11()¶
- ## containing #for directive 
 - test2()¶
- ## followed by NEWLINE 
 - test3()¶
- ## followed by text then NEWLINE 
 - test4()¶
- ## gobbles leading WS 
 - test5()¶
- ## followed by text then NEWLINE, + leading WS 
 - test6()¶
- ## followed by EOF 
 - test7()¶
- ## followed by EOF with leading WS 
 - test8()¶
- ## gobble line with text on previous and following lines 
 - test9()¶
- ## don’t gobble line with text on previous and following lines 
 
- class Cheetah.Tests.SyntaxAndOutput.CompilerDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- overriding the commentStartToken 
 - test2()¶
- overriding and resetting the commentStartToken 
 
- class Cheetah.Tests.SyntaxAndOutput.CompilerSettingsDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- overriding the cheetahVarStartToken 
 - test2()¶
- overriding the directiveStartToken 
 - test3()¶
- overriding the commentStartToken 
 
- class Cheetah.Tests.SyntaxAndOutput.ContinueDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #continue with a #while 
 - test2()¶
- #continue with a #for 
 
- class Cheetah.Tests.SyntaxAndOutput.DecoratorDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- single line #def with decorator 
 - test2()¶
- #def with multiple decorators 
 
- class Cheetah.Tests.SyntaxAndOutput.DefDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #def without argstring 
 - test11()¶
- single line #def with extra WS 
 - test12()¶
- single line #def with extra WS and nested $placeholders 
 - test13()¶
- single line #def escaped $placeholders 
 - test14()¶
- single line #def 1 escaped $placeholders 
 - test15()¶
- single line #def 1 escaped $placeholders + more WS 
 - test16()¶
- multiline #def with $ on methodName 
 - test17()¶
- single line #def with $ on methodName 
 - test18()¶
- single line #def with an argument 
 - test19()¶
- #def that extends over two lines with arguments 
 - test2()¶
- #def without argstring, gobble WS 
 - test3()¶
- #def with argstring, gobble WS 
 - test4()¶
- #def with argstring, gobble WS, string used in call 
 - test5()¶
- #def with argstring, gobble WS, list used in call 
 - test6()¶
- #def with 2 args, gobble WS, list used in call 
 
- class Cheetah.Tests.SyntaxAndOutput.DefmacroDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
 - test2()¶
 
- class Cheetah.Tests.SyntaxAndOutput.DummyClass¶
- Bases: - object- callIt(arg=1234)¶
 - meth(arg='arff')¶
 - meth1(arg='doo')¶
 - meth2(arg1='a1', arg2='a2')¶
 - methWithPercentSignDefaultArg(arg1='110%')¶
 
- class Cheetah.Tests.SyntaxAndOutput.EOLSlurpToken(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #slurp with 1 n 
 - test2()¶
- #slurp with 1 n, leading whitespace Should gobble 
 - test3()¶
- #slurp with 1 n, leading content Shouldn’t gobble 
 - test4()¶
- #slurp with WS then n, leading content Shouldn’t gobble 
 - test5()¶
- #slurp with garbage chars then n, leading content Should NOT eat the garbage 
 
- class Cheetah.Tests.SyntaxAndOutput.EchoDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #echo 1234 
 
- class Cheetah.Tests.SyntaxAndOutput.EmptyTemplate(methodName='runTest')¶
- Bases: - OutputTest- convertEOLs = False¶
 - test1()¶
- an empty string for the template 
 
- class Cheetah.Tests.SyntaxAndOutput.EncodingDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- basic #encoding 
 - test2()¶
- basic #encoding 
 - test3()¶
- basic #encoding 
 - test4()¶
- basic #encoding 
 - test5()¶
- basic #encoding 
 - test6()¶
- Using #encoding on the second line 
 
- class Cheetah.Tests.SyntaxAndOutput.ErrorCatcherDirective(methodName='runTest')¶
- Bases: - OutputTest
- class Cheetah.Tests.SyntaxAndOutput.ExtendsDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #extends Cheetah.Templates._SkeletonPage 
 - test2()¶
- #extends Cheetah.Templates.SkeletonPage without #import 
 - test3()¶
- #extends Cheetah.Templates.SkeletonPage.SkeletonPage without #import 
 - test4()¶
- #extends with globals and searchList test 
 
- class Cheetah.Tests.SyntaxAndOutput.FilterDirective(methodName='runTest')¶
- Bases: - OutputTest- convertEOLs = False¶
 - test1()¶
- #filter Filter 
 - test10()¶
- #filter Strip – multi-line 
 - test11()¶
- #filter StripSqueeze – canonicalize all whitespace to ‘ ‘ 
 - test2()¶
- #filter ReplaceNone with WS 
 - test3()¶
- #filter MaxLen – maxlen of 5 
 - test4()¶
- #filter MaxLen – no maxlen 
 - test5()¶
- #filter WebSafe – basic usage 
 - test6()¶
- #filter WebSafe – also space 
 - test7()¶
- #filter WebSafe – also space, without $ on the args 
 - test8()¶
- #filter Strip – trailing newline 
 - test9()¶
- #filter Strip – no trailing newine 
 
- class Cheetah.Tests.SyntaxAndOutput.ForDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #for loop with one local var 
 - test10()¶
- #for loop over list, using methods of the items 
 - test11()¶
- #for loop over list, using ($i,$j) style target list 
 - test12()¶
- #for loop over list, using i, (j,k) style target list 
 - test13()¶
- single line #for 
 - test14()¶
- single line #for with 1 extra leading space 
 - test15()¶
- 2 times single line #for 
 - test16()¶
- false single line #for 
 - test2()¶
- #for loop with WS in loop 
 - test3()¶
- #for loop gobble WS 
 - test4()¶
- #for loop over list 
 - test5()¶
- #for loop over list, with #slurp 
 - test6()¶
- #for loop with explicit closures 
 - test7()¶
- #for loop with explicit closures and WS 
 - test8()¶
- #for loop using another $var 
 - test9()¶
- test methods in for loops 
 
- class Cheetah.Tests.SyntaxAndOutput.GetVar(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- $getVar(‘$anInt’) 
 - test2()¶
- $getVar(‘anInt’) 
 - test3()¶
- $self.getVar(‘anInt’) 
 - test4()¶
- $getVar(‘bogus’, 1234) 
 - test5()¶
- $getVar(‘$bogus’, 1234) 
 - test6()¶
- $getVar(‘$’) raises ValueError or NotFound(LookupError) 
 
- class Cheetah.Tests.SyntaxAndOutput.I18nDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- simple #call 
 
- class Cheetah.Tests.SyntaxAndOutput.IfDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- simple #if block 
 - test10()¶
- #if block using $*emptyString - This should barf 
 - test11()¶
- #if block using invalid top-level $(placeholder) syntax - should barf 
 - test12()¶
- #if … #else if … #else … block using a $emptyString Same as test 8 but using else if instead of elif 
 - test13()¶
- #if# … #else # … block using a $emptyString with 
 - test14()¶
- single-line #if: simple 
 - test15()¶
- single-line #if: more complex 
 - test16()¶
- single-line #if: with the words ‘else’ and ‘then’ in the output 
 - test17()¶
- single-line #if: 
 - test18()¶
- single-line #if: #else: 
 - test2()¶
- simple #if block, with WS 
 - test3()¶
- simple #if block, with WS and explicit closures 
 - test4()¶
- #if block using $numOne 
 - test5()¶
- #if block using $zero 
 - test6()¶
- #if block using $emptyString 
 - test7()¶
- #if … #else … block using a $emptyString 
 - test8()¶
- #if … #elif … #else … block using a $emptyString 
 - test9()¶
- #if ‘not’ test, with #slurp 
 
- class Cheetah.Tests.SyntaxAndOutput.ImportDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #import math 
 - test10()¶
- #import os.path – use it with NameMapper turned off 
 - test11()¶
- #from math import * 
 - test2()¶
- #import math + WS - Should gobble 
 - test3()¶
- #import math + WS + leading text - Shouldn’t gobble 
 - test4()¶
- #from math import syn 
 - test5()¶
- #from math import cos + WS Should gobble 
 - test6()¶
- #from math import cos + WS + leading text Shouldn’t gobble 
 - test7()¶
- #from math import cos – use it 
 - test8()¶
- #from math import cos,tan,sin – and use them 
 - test9()¶
- #import os.path – use it 
 
- class Cheetah.Tests.SyntaxAndOutput.ImportantExampleCases(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- how to make a comma-delimited list 
 
- class Cheetah.Tests.SyntaxAndOutput.IncludeDirective(methodName='runTest')¶
- Bases: - OutputTest- setUp()¶
- Hook method for setting up the test fixture before exercising it. 
 - tearDown()¶
- Hook method for deconstructing the test fixture after testing it. 
 - test1()¶
- #include raw of source $emptyString 
 - test10()¶
- #include of “parseTest.txt”, with WS 
 - test11()¶
- #include of ‘parseTest.txt’, with WS and surrounding text 
 - test12()¶
- #include of ‘parseTest.txt’, with WS and explicit closure 
 - test2()¶
- #include raw of source $blockToBeParsed 
 - test3()¶
- #include raw of ‘parseTest.txt’ 
 - test4()¶
- #include raw of $includeFileName 
 - test5()¶
- #include raw of $includeFileName, with WS 
 - test6()¶
- #include raw of source= , with WS 
 - test7()¶
- #include of $blockToBeParsed 
 - test8()¶
- #include of $blockToBeParsed, with WS 
 - test9()¶
- #include of ‘parseTest.txt’, with WS 
 
- class Cheetah.Tests.SyntaxAndOutput.Indenter(methodName='runTest')¶
- Bases: - OutputTest- control = '\npublic class X\n{\n public void Foo(\n _input,\n _output);\n\n\n public int Bar(\n _str1,\n str2,\n _str3);\n\n\n public Object Add(\n value1,\n value);\n\n\n}\n//end of class\n\n\n\n'¶
 - convertEOLs = False¶
 - searchList()¶
 - source = '\npublic class X\n{\n #for $method in $methods\n $getMethod($method)\n\n #end for\n}\n//end of class\n\n#def getMethod($method)\n #indent ++\n public $getType($method) ${method.Name}($getParams($method.Params));\n #indent --\n#end def\n\n#def getParams($params)\n #indent off\n\n #for $counter in $range($len($params))\n #if $counter == len($params) - 1\n $params[$counter]#slurp\n #else:\n $params[$counter],\n #end if\n #end for\n #indent on\n#end def\n\n#def getType($method)\n #indent push\n #indent=0\n #if $method.Type == "VT_VOID"\n void#slurp\n #elif $method.Type == "VT_INT"\n int#slurp\n #elif $method.Type == "VT_VARIANT"\n Object#slurp\n #end if\n #indent pop\n#end def\n'¶
 - test1()¶
 
- class Cheetah.Tests.SyntaxAndOutput.MatchObject(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- re Match objects implement both attribute access and index access; match[2] is equivalent to match.group(2). That confuses NameMapper and requires special handling. 
 
- class Cheetah.Tests.SyntaxAndOutput.MiscComplexSyntax(methodName='runTest')¶
- Bases: - OutputTest
- class Cheetah.Tests.SyntaxAndOutput.NameMapper(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- autocalling 
 - test10()¶
- nested dictionary access - NameMapper style 
 - test11()¶
- nested dictionary access - Python style 
 - test12()¶
- nested dictionary access - alternating style 
 - test13()¶
- nested dictionary access using method - alternating style 
 - test14()¶
- nested dictionary access - NameMapper style - followed by method 
 - test15()¶
- nested dictionary access - alternating style - followed by method 
 - test16()¶
- Nested dictionary access - NameMapper style - followed by method, then slice. 
 - test17()¶
- nested dictionary access - Python style using a soft-coded key 
 - test18()¶
- object method access 
 - test19()¶
- object method access, followed by complex slice 
 - test2()¶
- nested autocalling 
 - test20()¶
- object method access, followed by a very complex slice If it can pass this one, it’s safe to say it works!! 
 - test21()¶
- object method access with % in the default arg for the meth. - This tests a bug that Jeff Johnson found and submitted a patch to SF for. 
 - test3()¶
- list subscription 
 - test4()¶
- list slicing 
 - test5()¶
- list slicing and subcription combined 
 - test6()¶
- dictionary access - NameMapper style 
 - test7()¶
- dictionary access - Python style 
 - test8()¶
- dictionary access combined with autocalled string method 
 - test9()¶
- dictionary access combined with string method 
 
- class Cheetah.Tests.SyntaxAndOutput.NonTokens(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- dollar signs not in Cheetah $vars 
 - test2()¶
- hash not in #directives 
 - test3()¶
- escapted comments 
 - test4()¶
- escapted multi-line comments 
 - test5()¶
- 1 dollar sign 
 - test6()¶
- 1 dollar sign followed by EOL Slurp Token 
 
- class Cheetah.Tests.SyntaxAndOutput.OutputTest(methodName='runTest')¶
- Bases: - TestCase- DEBUGLEV = 0¶
 - convertEOLs = True¶
 - genClassCode()¶
 - genModuleCode()¶
 - report = '\nTemplate output mismatch:\n\n Input Template =\n%(template)s%(end)s\n\n Expected Output =\n%(expected)s%(end)s\n\n Actual Output =\n%(actual)s%(end)s'¶
 - searchList()¶
 - verify(input, expectedOutput, inputEncoding=None, outputEncoding=None, convertEOLs=<class 'Cheetah.Tests.SyntaxAndOutput.Unspecified'>)¶
 
- class Cheetah.Tests.SyntaxAndOutput.PSP(methodName='runTest')¶
- Bases: - OutputTest- searchList()¶
 - test1()¶
- simple <%= [int] %> 
 - test10()¶
- Using getVar and write within a PSP 
 - test2()¶
- simple <%= [string] %> 
 - test3()¶
- simple <%= None %> 
 - test4()¶
- simple <%= [string] %> + $anInt 
 - test5()¶
- simple <%= [EXPR] %> + $anInt 
 - test6()¶
- for loop in <%%> 
 - test7()¶
- for loop in <%%> and using <%=i%> 
 - test8()¶
- for loop in <% $%> and using <%=i%> 
 - test9()¶
- for loop in <% $%> and using <%=i%> plus extra text 
 
- class Cheetah.Tests.SyntaxAndOutput.PassDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #pass in a #try / #except block 
 - test2()¶
- #pass in a #try / #except block + WS 
 
- class Cheetah.Tests.SyntaxAndOutput.PlaceholderStrings(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- some c’text $placeholder text’ strings 
 - test2()¶
- some c’text $placeholder text’ strings 
 - test3()¶
- some c’text $placeholder text’ strings 
 - test4()¶
- some c’text $placeholder text’ strings 
 - test5()¶
- some c’text $placeholder text’ strings 
 - test6()¶
- some c’text $placeholder text’ strings 
 - test7()¶
- some c’text $placeholder text’ strings 
 
- class Cheetah.Tests.SyntaxAndOutput.Placeholders(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- 1 placeholder 
 - test10()¶
- 1 placeholder enclosed in () + WS + * cache - Test to make sure that $*(<WS><identifier>.. matches 
 - test19()¶
- 1 placeholder surrounded by single quotes and multiple newlines 
 - test2()¶
- 2 placeholders 
 - test20()¶
- silent mode $!placeholders 
 - test21()¶
- Make sure that $*caching is actually working 
 - test3()¶
- 2 placeholders, back-to-back 
 - test4()¶
- 1 placeholder enclosed in () 
 - test5()¶
- 1 placeholder enclosed in {} 
 - test6()¶
- 1 placeholder enclosed in [] 
 - test7()¶
- 1 placeholder enclosed in () + WS - Test to make sure that $(<WS><identifier>.. matches 
 - test8()¶
- 1 placeholder enclosed in {} + WS 
 - test9()¶
- 1 placeholder enclosed in [] + WS 
 
- class Cheetah.Tests.SyntaxAndOutput.Placeholders_Calls(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- func placeholder - no () 
 - test10()¶
- func placeholder - with (‘’’nstringn’’’) 
 - test11()¶
- func placeholder - with (‘’’nstring’n’’’) 
 - test12()¶
- func placeholder - with (“””nstringn”””) 
 - test13()¶
- func placeholder - with (string*int) 
 - test14()¶
- func placeholder - with (int*int) 
 - test15()¶
- func placeholder - with (int*float) 
 - test16()¶
- func placeholder - with (intn*nfloat) 
 - test17()¶
- func placeholder - with ($arg=float) 
 - test18()¶
- func placeholder - with (arg=float) 
 - test19()¶
- deeply nested argstring, no enclosure 
 - test2()¶
- func placeholder - with () 
 - test20()¶
- deeply nested argstring, no enclosure + with WS 
 - test21()¶
- deeply nested argstring, () enclosure + with WS 
 - test22()¶
- deeply nested argstring, {} enclosure + with WS 
 - test23()¶
- deeply nested argstring, [] enclosure + with WS 
 - test26()¶
- a function call with the Python None kw. 
 - test3()¶
- func placeholder - with (nn) 
 - test4()¶
- func placeholder - with (nn) and $() enclosure 
 - test5()¶
- func placeholder - with (nn) and ${} enclosure 
 - test6()¶
- func placeholder - with (int) 
 - test7()¶
- func placeholder - with (nintn) 
 - test8()¶
- func placeholder - with (string) 
 - test9()¶
- func placeholder - with (‘’’string’’’) 
 
- class Cheetah.Tests.SyntaxAndOutput.Placeholders_Esc(methodName='runTest')¶
- Bases: - OutputTest- convertEOLs = False¶
 - test1()¶
- 1 escaped placeholder 
 - test2()¶
- 2 escaped placeholders 
 - test3()¶
- 2 escaped placeholders - back to back 
 - test4()¶
- 2 escaped placeholders - nested 
 - test5()¶
- 2 escaped placeholders - nested and enclosed 
 
- class Cheetah.Tests.SyntaxAndOutput.Placeholders_Vals(methodName='runTest')¶
- Bases: - OutputTest- convertEOLs = False¶
 - test1()¶
- string 
 - test2()¶
- string - with whitespace 
 - test3()¶
- empty string - with whitespace 
 - test4()¶
- int 
 - test5()¶
- float 
 - test6()¶
- list 
 - test7()¶
- None - The default output filter is ReplaceNone. 
 - test8()¶
- True, False 
 - test9()¶
- $_ 
 
- class Cheetah.Tests.SyntaxAndOutput.RaiseDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- simple #raise ValueError - Should raise ValueError 
 - test2()¶
- #raise ValueError in #if block - Should raise ValueError 
 - test3()¶
- #raise ValueError in #if block - Shouldn’t raise ValueError 
 
- class Cheetah.Tests.SyntaxAndOutput.RawDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #raw till EOF 
 - test2()¶
- #raw till #end raw 
 - test3()¶
- #raw till #end raw gobble WS 
 - test4()¶
- #raw till #end raw using explicit directive closure Shouldn’t gobble 
 - test5()¶
- single-line short form #raw: 
 - test6()¶
- Escape characters in a #raw block 
 
- class Cheetah.Tests.SyntaxAndOutput.RepeatDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- basic #repeat 
 - test2()¶
- #repeat with numeric expression 
 - test3()¶
- #repeat with placeholder 
 - test4()¶
- #repeat with placeholder * num 
 - test5()¶
- #repeat with placeholder and WS 
 - test6()¶
- single-line #repeat 
 
- class Cheetah.Tests.SyntaxAndOutput.ReturnDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #return’ing an int 
 - test2()¶
- #return’ing an string 
 - test3()¶
- #return’ing an string AND streaming other output via the transaction 
 
- class Cheetah.Tests.SyntaxAndOutput.SetDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- simple #set 
 - test10()¶
- simple #set global with a list 
 - test11()¶
- simple #set global with a list and *cache - Caching only works with global #set vars. Local vars are not accesible to the cache namespace. 
 - test14()¶
- simple #set without NameMapper on 
 - test15()¶
- simple #set without $ 
 - test16()¶
- simple #set global without $ 
 - test17()¶
- simple #set module without $ 
 - test18()¶
- #set with i,j=list style assignment 
 - test19()¶
- #set with (i,j)=list style assignment 
 - test2()¶
- simple #set with no WS between operands 
 - test20()¶
- #set with i, (j,k)=list style assignment 
 - test3()¶
- #set + use of var 
 - test4()¶
- #set + use in an #include 
 - test5()¶
- #set with a dictionary 
 - test6()¶
- #set with string, then used in #if block 
 - test7()¶
- simple #set, gobble WS 
 - test8()¶
- simple #set, don’t gobble WS 
 - test9()¶
- simple #set with a list 
 
- class Cheetah.Tests.SyntaxAndOutput.SilentDirective(methodName='runTest')¶
- Bases: - OutputTest- test4()¶
- #silent 1234 
 
- class Cheetah.Tests.SyntaxAndOutput.SlurpDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #slurp with 1 n 
 - test2()¶
- #slurp with 1 n, leading whitespace Should gobble 
 - test3()¶
- #slurp with 1 n, leading content Shouldn’t gobble 
 - test4()¶
- #slurp with WS then n, leading content Shouldn’t gobble 
 - test5()¶
- #slurp with garbage chars then n, leading content Should eat the garbage 
 
- class Cheetah.Tests.SyntaxAndOutput.StopDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #stop part way through source code 
 - test2()¶
- #stop at BOF 
 - test3()¶
- #stop at EOF 
 - test4()¶
- #stop in pos test block 
 - test5()¶
- #stop in neg test block 
 
- class Cheetah.Tests.SyntaxAndOutput.SuperDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
 
- class Cheetah.Tests.SyntaxAndOutput.TryDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- simple #try 
 - test2()¶
- #try / #except with #raise 
 - test3()¶
- #try / #except with #raise + WS - Should gobble 
 - test4()¶
- #try / #except with #raise + WS and leading text - Shouldn’t gobble 
 - test5()¶
- nested #try / #except with #raise 
 
- class Cheetah.Tests.SyntaxAndOutput.UnicodeDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- basic #unicode 
 
- class Cheetah.Tests.SyntaxAndOutput.UnicodeStrings(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- unicode data in placeholder 
 - test2()¶
- unicode data in body 
 
- class Cheetah.Tests.SyntaxAndOutput.UnlessDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- #unless 1 
 - test2()¶
- #unless 0 
 - test3()¶
- #unless $none 
 - test4()¶
- #unless $numTwo 
 - test5()¶
- #unless $numTwo with WS 
 - test6()¶
- single-line #unless 
 
- class Cheetah.Tests.SyntaxAndOutput.Unspecified¶
- Bases: - object
- class Cheetah.Tests.SyntaxAndOutput.VarExists(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- $varExists(‘$anInt’) 
 - test2()¶
- $varExists(‘anInt’) 
 - test3()¶
- $varExists(‘$anInt’) 
 - test4()¶
- $varExists(‘$anInt’) combined with #if false 
 - test5()¶
- $varExists(‘$anInt’) combined with #if true 
 
- class Cheetah.Tests.SyntaxAndOutput.WhileDirective(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
- simple #while with a counter 
 
- class Cheetah.Tests.SyntaxAndOutput.WhitespaceAfterDirectiveTokens(methodName='runTest')¶
- Bases: - OutputTest- test1()¶
 
- class Cheetah.Tests.SyntaxAndOutput.YieldDirective(methodName='runTest')¶
- Bases: - OutputTest- convertEOLs = False¶
 - test1()¶
- simple #yield 
 
- Cheetah.Tests.SyntaxAndOutput.dummyFunc(arg='Scooby')¶
- Cheetah.Tests.SyntaxAndOutput.install_eols()¶
- Cheetah.Tests.SyntaxAndOutput.testdecorator(func)¶