Cheetah.Tests.SyntaxAndOutput module

Syntax and Output tests.

TODO - #finally - #filter - #errorCatcher - #echo - #silent

class Cheetah.Tests.SyntaxAndOutput.AssertDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

simple #assert

test2()

simple #assert that fails

test3()

simple #assert with WS

class Cheetah.Tests.SyntaxAndOutput.AttrDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

#break with a #while

test2()

#break with a #for

class Cheetah.Tests.SyntaxAndOutput.BreakpointDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

#breakpoint part way through source code

test2()

#breakpoint at BOF

test3()

#breakpoint at EOF

class Cheetah.Tests.SyntaxAndOutput.CGI(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

simple #capture

test2()

slightly more complex #capture

class Cheetah.Tests.SyntaxAndOutput.Comments_MultiLine(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.OutputTest

Note: Multiline comments don’t gobble whitespace!

test1()

#* *# followed by WS Should gobble WS

test10()

text around #* *# containing #for directive and trailing whitespace which should be gobbled

test11()

Text around #* *# containing #for directive and newlines: trailing whitespace which should be gobbled.

test2()

#* *# preceded and followed by WS Should gobble WS

test3()

#* *# followed by WS, with NEWLINE Shouldn’t gobble WS

test4()

#* *# preceded and followed by WS, with NEWLINE Shouldn’t gobble WS

test5()

#* *# containing nothing

test6()

#* *# containing only NEWLINES

test7()

#* *# containing $placeholders

test8()

#* *# containing #for directive

test9()

text around #* *# containing #for directive

class Cheetah.Tests.SyntaxAndOutput.Comments_MultiLine_NoGobble(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.OutputTest

Multiline comments used to not gobble whitespace

They do now, but this can be turned off with a compilerSetting.

test1()

#* *# followed by WS Shouldn’t gobble WS

test2()

#* *# preceded and followed by WS Shouldn’t gobble WS

test3()

#* *# followed by WS, with NEWLINE Shouldn’t gobble WS

test4()

#* *# preceded and followed by WS, with NEWLINE Shouldn’t gobble WS

class Cheetah.Tests.SyntaxAndOutput.Comments_SingleLine(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

overriding the commentStartToken

test2()

overriding and resetting the commentStartToken

class Cheetah.Tests.SyntaxAndOutput.CompilerSettingsDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

overriding the cheetahVarStartToken

test2()

overriding the directiveStartToken

test3()

overriding the commentStartToken

class Cheetah.Tests.SyntaxAndOutput.ContinueDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

#continue with a #while

test2()

#continue with a #for

class Cheetah.Tests.SyntaxAndOutput.DecoratorDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

single line #def with decorator

test2()

#def with multiple decorators

class Cheetah.Tests.SyntaxAndOutput.DefDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

#def without argstring

test10()

#def with *args + **KWs, gobble WS

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

test7()

#def with *args, gobble WS

test8()

#def with **KWs, gobble WS

test9()

#def with *args + **KWs, gobble WS

class Cheetah.Tests.SyntaxAndOutput.DefmacroDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

test2()

class Cheetah.Tests.SyntaxAndOutput.DummyClass

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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

#echo 1234

class Cheetah.Tests.SyntaxAndOutput.EmptyTemplate(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.OutputTest

convertEOLs = False

test1()

an empty string for the template

class Cheetah.Tests.SyntaxAndOutput.EncodingDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.OutputTest

class Cheetah.Tests.SyntaxAndOutput.ExtendsDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

simple #call

class Cheetah.Tests.SyntaxAndOutput.IfDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

how to make a comma-delimited list

class Cheetah.Tests.SyntaxAndOutput.IncludeDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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.MiscComplexSyntax(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

#set $c = {‘A’:0}[{}.get(‘a’, {‘a’ : ‘A’}[‘a’])] $c

class Cheetah.Tests.SyntaxAndOutput.NameMapper(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: unittest.case.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

#pass in a #try / #except block

test2()

#pass in a #try / #except block + WS

class Cheetah.Tests.SyntaxAndOutput.PlaceholderStrings(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

1 placeholder

test10()

1 placeholder enclosed in () + WS + * cache

Test to make sure that $*(<WS><identifier>.. matches

test11()

1 placeholder enclosed in {} + WS + *cache

test12()

1 placeholder enclosed in [] + WS + *cache

test13()

1 placeholder enclosed in {} + WS + *<int>*cache

test14()

1 placeholder enclosed in [] + WS + *<int>*cache

test15()

1 placeholder enclosed in {} + WS + *<float>*cache

test16()

1 placeholder enclosed in [] + WS + *<float>*cache

test17()

1 placeholder + *<int>*cache

test18()

1 placeholder *<float>*cache

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: Cheetah.Tests.SyntaxAndOutput.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

test24()

deeply nested argstring, () enclosure + *cache

test25()

deeply nested argstring, () enclosure + *15*cache

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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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.

test12()

simple #set global with a list and *<int>*cache

test13()

simple #set with a list and *<float>*cache

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: Cheetah.Tests.SyntaxAndOutput.OutputTest

test4()

#silent 1234

class Cheetah.Tests.SyntaxAndOutput.SlurpDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

class Cheetah.Tests.SyntaxAndOutput.TryDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

basic #unicode

class Cheetah.Tests.SyntaxAndOutput.UnicodeStrings(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

unicode data in placeholder

test2()

unicode data in body

class Cheetah.Tests.SyntaxAndOutput.UnlessDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.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: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

simple #while with a counter

class Cheetah.Tests.SyntaxAndOutput.WhitespaceAfterDirectiveTokens(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.OutputTest

test1()

class Cheetah.Tests.SyntaxAndOutput.YieldDirective(methodName='runTest')

Bases: Cheetah.Tests.SyntaxAndOutput.OutputTest

convertEOLs = False

test1()

simple #yield

Cheetah.Tests.SyntaxAndOutput.dummyFunc(arg='Scooby')

Cheetah.Tests.SyntaxAndOutput.install_eols()

Cheetah.Tests.SyntaxAndOutput.testdecorator(func)