PageTemplate 1.2.0 → 2.0.0

data/TC_PageTemplate.rb~

@@ -1,965 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-require 'test/unit'
-require './lib/PageTemplate.rb'
-
-require "date"
-
-class TC_Namespace < Test::Unit::TestCase
-  @@namespace = Namespace.new()
-  
-  def testNamespaceSet
-    assert(@@namespace.set("name", "Frank"))
-  end
-  
-  def testNamespaceGet
-    @@namespace.set("name", "Frank")
-    assert_equal("Frank", @@namespace.get("name"))
-  end
-  
-  def testTrue
-    assert_not_nil(@@namespace.true?("name"))
-    assert_nil(@@namespace.true?("null"))
-    @@namespace.set("falseFlag", false)
-    assert_nil(@@namespace.true?("falseFlag"))
-  end
-  
-  def testNamespacePush
-    assert_equal("Frank", @@namespace.get("name"))
-    names = { 'name' => "Eddie Baby" }
-    
-    # Pushing a hash (and nested namespace)
-    assert(@@namespace.push(names))
-    assert_equal("Eddie Baby", @@namespace.get("name"))
-    
-    # Pushing an object
-    date = Date.today()
-    date2 = Date.today()
-    
-    @@namespace.push(date)
-    assert_equal(date2.year, @@namespace.get("year"))
-  end
-  
-  def testNamespacePop
-    names = { 'name' => "Eddie Baby" }
-    @@namespace.push(names)
-    assert_equal("Eddie Baby", @@namespace.get("name"))
-    assert(@@namespace.pop())
-    assert_equal("Frank", @@namespace.get("name"))
-    assert_nil(@@namespace.pop())
-  end
-  
-end
-
-class TC_Command < Test::Unit::TestCase
-  @@command = Command.new()
-  
-  def testCommandOutput
-    assert_raises(NotImplementedError) { @@command.output() }
-  end
-  
-end
-
-class TC_CommentCommand < Test::Unit::TestCase
-  @@command = CommentCommand.new()
-
-  def testCommentCommand
-    assert_equal(nil, @@command.output,
-                 "CommentCommands don't have any output")
-  end
-
-end
-
-class TC_BlockCommand < Test::Unit::TestCase
-  @@command = BlockCommand.new()
-  
-  def testAddCommand
-    aCommand = TextCommand.new("Hello")
-    assert(@@command.add(aCommand))
-    
-    assert_raises(TypeError) { @@command.add("Hello") }
-  end
-  
-  def testOutput
-    bCommand = TextCommand.new(", ")
-    cCommand = TextCommand.new("World")
-    
-    @@command.add(bCommand)
-    @@command.add(cCommand)
-    
-    assert_equal("Hello, World", @@command.output)
-  end
-end
-
-class TC_TextCommand < Test::Unit::TestCase
-  @@command = TextCommand.new("Just testing")
-  
-  def testCommandOutput
-    assert_equal("Just testing", @@command.output)
-  end
-  
-end
-
-class TC_ValueCommand < Test::Unit::TestCase
-  @@valueCommand = ValueCommand.new("name")
-  
-  def testOutput
-    ns = Namespace.new()
-    ns.set("name", "Frank")
-    assert_equal(ns.get("name"), @@valueCommand.output(ns))
-  end
-end
-
-class TC_IfCommand < Test::Unit::TestCase
-  
-  def testOutput
-    aCommand = TextCommand.new("Programming ")
-    bCommand = TextCommand.new("Ruby")
-    commandBlock = BlockCommand.new()
-    commandBlock.add(aCommand)
-    commandBlock.add(bCommand)
-    
-    ns = Namespace.new()
-    ns.set("testing", 1)
-    
-    # First test for output with true condition
-    ifCommand = IfCommand.new("testing", commandBlock)
-    assert_equal("Programming Ruby", ifCommand.output(ns))
-    
-    # Test for nil output with false condition
-    ifCommand = IfCommand.new("production", commandBlock)
-    assert_nil(ifCommand.output(ns))
-    
-    ns.set("production", false)
-    assert_nil(ifCommand.output(ns))
-  end
-end
-
-class TC_UnlessCommand < Test::Unit::TestCase
-  def testOutput
-    aCommand = TextCommand.new("Dude!")
-    bCommand = TextCommand.new("Sweet!")
-    commandBlock = BlockCommand.new()
-    commandBlock.add(aCommand)
-    commandBlock.add(bCommand)
-    ns = Namespace.new()
-    ns["testing"] = false
-
-    # First test for output with false condition
-    unlessCommand = UnlessCommand.new("testing", commandBlock)
-    assert_equal("Dude!Sweet!", unlessCommand.output(ns))
-    ns["testing"] = true
-    assert_nil(unlessCommand.output(ns))
-  end
-end
-
-class TC_IfElseCommand < Test::Unit::TestCase
-  
-  def testOutput
-    aCommand = TextCommand.new("This is ")
-    bCommand = TextCommand.new("True")
-    cCommand = TextCommand.new("False")
-    ifBlock = BlockCommand.new()
-    ifBlock.add(aCommand)
-    ifBlock.add(bCommand)
-    elseBlock = BlockCommand.new()
-    elseBlock.add(aCommand)
-    elseBlock.add(cCommand)
-    
-    ns = Namespace.new()
-    ns.set("testing", 1)
-    
-    # First test for output with true condition
-    ifElseCommand = IfElseCommand.new("testing", ifBlock, elseBlock)
-    assert_equal("This is True", ifElseCommand.output(ns))
-    
-    # Test for output with false condition
-    ifElseCommand = IfElseCommand.new("live", ifBlock, elseBlock)
-    assert_equal("This is False", ifElseCommand.output(ns))
-  end
-  
-end
-
-class TC_LoopCommand < Test::Unit::TestCase
-  
-  def testOutput
-    # Build a list of hashes for the namespace
-    loopItems = [
-      { 'x'=> '1 ', 'y'=> '2 ', 'z'=> '3' },
-      { 'x'=> 'a ', 'y'=> 'b ', 'z'=> 'c' },
-    ]
-    ns = Namespace.new()
-    ns.set('list', loopItems)
-    
-    # Build a command list
-    xCommand = ValueCommand.new('x')
-    yCommand = ValueCommand.new('y')
-    zCommand = ValueCommand.new('z')
-    commandBlock = BlockCommand.new()
-    commandBlock.add(xCommand)
-    commandBlock.add(yCommand)
-    commandBlock.add(zCommand)
-    
-    loopCommand = LoopCommand.new('list', commandBlock)
-    assert_equal("1 2 3a b c", loopCommand.output(ns))
-    loopCommand = LoopCommand.new('noshow', commandBlock)
-    assert_nil(loopCommand.output(ns))
-    ns.set("string", "hello")
-    loopCommand = LoopCommand.new("string", commandBlock)
-    assert_raises(TypeError) { loopCommand.output(ns) }
-  end
-end
-
-class TC_LoopElseCommand < Test::Unit::TestCase
-  
-  def testOutput
-    # Build a list of hashes for the namespace
-    loopItems = [
-      { 'x'=> '1 ', 'y'=> '2 ', 'z'=> '3' },
-      { 'x'=> 'a ', 'y'=> 'b ', 'z'=> 'c' },
-    ]
-    ns = Namespace.new()
-    ns.set('list', loopItems)
-    
-    # Build a command list
-    xCommand = ValueCommand.new('x')
-    yCommand = ValueCommand.new('y')
-    zCommand = ValueCommand.new('z')
-    commandBlock = BlockCommand.new()
-    commandBlock.add(xCommand)
-    commandBlock.add(yCommand)
-    commandBlock.add(zCommand)
-    
-    # Build a command list for the else block
-    aCommand = TextCommand.new("In the else block")
-    elseCommands = BlockCommand.new()
-    elseCommands.add(aCommand)
-    
-    # Build the LoopCommand
-    loopCommand = 
-                 LoopElseCommand.new('list', commandBlock, elseCommands)
-    
-    # Test for output when loop variable is true
-    assert_equal("1 2 3a b c", loopCommand.output(ns))
-    
-    # Test for nil when loop variable is false
-    loopCommand = 
-                 LoopElseCommand.new('noshow', commandBlock, elseCommands)
-    assert_equal("In the else block", loopCommand.output(ns))
-  end
-  
-end
-
-
-class TC_NestedCommands < Test::Unit::TestCase
-  
-  def testNestedIfs
-    ns = Namespace.new()
-    
-    innerBlock = BlockCommand.new()
-    innerBlock.add(TextCommand.new("Inner"))
-    innerIf = IfCommand.new("inner", innerBlock)
-    
-    outerBlock = BlockCommand.new()
-    outerBlock.add(TextCommand.new("Outer"))
-    outerBlock.add(innerIf)
-    outerIf = IfCommand.new("outer", outerBlock)
-    
-    mainBlock = BlockCommand.new()
-    mainBlock.add(outerIf)
-    
-    # True in a true should yield result of both command lists
-    ns.set("outer", 1)
-    ns.set("inner", 1)
-    assert_equal("OuterInner", mainBlock.output(ns))
-    
-    # False in a true should yield result of outside list
-    ns.set("inner", false)
-    assert_equal("Outer", mainBlock.output(ns))
-    
-    # False in a false should yield nil
-    ns.set("outer", false)
-    assert_nil(mainBlock.output(ns))
-    
-    # True in a false should yield nil
-    ns.set("inner", 1)
-    ns.set("outer", false)
-    assert_nil(mainBlock.output(ns))
-  end
-  
-  def testNestedLoops
-    loop1 = [
-      { 'a' => 'o1 ', 'b' => 'o2 ', 'c' => [
-          { 'x' => 'i1 ', 'y' => 'i2 ', 'z' => 'i3 ' },
-          { 'x' => 'i4 ', 'y' => 'i5 ', 'z' => 'i6 ' } ]
-      },
-      { 'a' => 'o3 ', 'b' => 'o4 ', 'c' => [
-          { 'x' => 'j1 ', 'y' => 'j2 ', 'z' => 'j3 ' },
-          { 'x' => 'j4 ', 'y' => 'j5 ', 'z' => 'j6 ' } ]
-      }
-    ]
-    ns = Namespace.new()
-    ns.set("loop", loop1)
-    
-    aCommand = ValueCommand.new('a')
-    bCommand = ValueCommand.new('b')
-    xCommand = ValueCommand.new('x')
-    yCommand = ValueCommand.new('y')
-    zCommand = ValueCommand.new('z')
-    innerBlock = BlockCommand.new()
-    innerBlock.add(xCommand)
-    innerBlock.add(yCommand)
-    innerBlock.add(zCommand)
-    cCommand = LoopCommand.new('c', innerBlock)
-    outerBlock = BlockCommand.new()
-    outerBlock.add(aCommand)
-    outerBlock.add(bCommand)
-    outerBlock.add(cCommand)
-    loopCommand = LoopCommand.new('loop', outerBlock)
-    
-    # Loop in a loop should yield lots of text ;-)
-    # 'o1 o2 i1 i2 i3 i4 i5 i6 o3 o4 j1 j2 j3 j4 j5 j6 '
-    assert_equal('o1 o2 i1 i2 i3 i4 i5 i6 o3 o4 j1 j2 j3 j4 j5 j6 ',
-                 loopCommand.output(ns))
-    
-    # False in a loop should yield outside loop
-    # 'o1 o2 o3 o4 '
-    loop1.each { |item| item['c'] = [] }
-    assert_equal('o1 o2 o3 o4 ', loopCommand.output(ns))
-  end
-  
-  def testMixedNesting
-    # Loop in If
-    loop1 = [
-      { 'a' => '1 ', 'b' => '2 ', 'c' => '3 ' },
-      { 'a' => 'x ', 'b' => 'y ', 'c' => 'z ' }
-    ]
-    
-    aCommand = ValueCommand.new('a')
-    bCommand = ValueCommand.new('b')
-    cCommand = ValueCommand.new('c')
-    loopBlock = BlockCommand.new()
-    loopBlock.add(aCommand)
-    loopBlock.add(bCommand)
-    loopBlock.add(cCommand)
-    loopCommand = LoopCommand.new("loop", loopBlock)
-    ifBlock = BlockCommand.new()
-    ifBlock.add(loopCommand)
-    ifCommand = IfCommand.new("flag", ifBlock)
-    
-    ns = Namespace.new()
-    ns.set("loop", loop1)
-    ns.set("flag", 1)
-    assert_equal("1 2 3 x y z ", ifCommand.output(ns))
-    ns.set("flag", false)
-    assert_nil(ifCommand.output(ns))
-    
-    # If in Loop
-    
-    dCommand = TextCommand.new("(true)")
-    ifBlock = BlockCommand.new()
-    ifBlock.add(dCommand)
-    ifCommand = IfCommand.new("flag", ifBlock)
-    loopBlock = BlockCommand.new()
-    loopBlock.add(aCommand)
-    loopBlock.add(bCommand)
-    loopBlock.add(cCommand)
-    loopBlock.add(ifCommand)
-    loopCommand = LoopCommand.new("loop", loopBlock)
-    
-    loop1[-1]['flag'] = 1
-    assert_equal("1 2 3 x y z (true)", loopCommand.output(ns))
-    loop1[-1]['flag'] = false
-    assert_equal("1 2 3 x y z ", loopCommand.output(ns))
-  end
-  
-end
-
-class TC_SyntaxGlossary < Test::Unit::TestCase
-  @@syntax = Syntax::Glossary.new( /\[%(.+?)%\]/,
-                                   'value'       => /var (\w+)/,
-                                   'ifopen'      => /if (\w+)/,
-                                   'ifclose'     => /endif/,
-                                   'unlessopen'  => /unless (\w+)/,
-                                   'unlessclose' => /endunless/,
-                                   'ifbranch'    => /else/,
-                                   'loopopen'    => /in (\w+)/,
-                                   'loopclose'   => /endin/,
-                                   'loopbranch'  => /no/,
-                                   'include'     => /include (\w+)/,
-                                   'comment'     => /--.+?--/
-                                   )
-  
-  def testGlossary
-    assert_equal(/\[%(.+?)%\]/, @@syntax.directive)
-    assert_equal(/in (\w+)/, @@syntax.glossary['loopopen'])
-    
-    badSyntax = {
-      'flargle' => /flargle/
-    }
-    assert_raises(ArgumentError) { 
-      Syntax::Glossary.new(/%(.+?)%/, badSyntax)
-    }
-  end
-  
-  def testLookup
-    assert_equal(["value", "name"], @@syntax.lookup("var name"))
-    assert_equal(["ifopen", "name"], @@syntax.lookup("if name"))
-    assert_equal(["ifclose", nil], @@syntax.lookup("endif"))
-    assert_equal(["ifbranch", nil], @@syntax.lookup("else"))
-    assert_equal(["loopopen", "x"], @@syntax.lookup("in x"))
-    assert_equal(["loopclose", nil], @@syntax.lookup("endin"))
-    assert_equal(["loopbranch", nil], @@syntax.lookup("no"))
-    assert_equal(["include", "foo"], @@syntax.lookup("include foo"))
-    assert_equal(["comment", nil], @@syntax.lookup("-- blarg! --"))
-    assert_nil(@@syntax.lookup("foo"))
-    assert_nil(@@syntax.lookup("foo bar"))
-  end
-  
-end
-
-class TC_SyntaxParser < Test::Unit::TestCase
-  @@parser = Syntax::Parser.new(Syntax::DEFAULT)
-  
-  def testParse
-    assert_equal([[1, ""]], @@parser.parse([""]))
-    assert_equal([
-                   [1, "Hello "], 
-                   [1, ["value", "world"]],
-                   [1, ""]
-                 ], @@parser.parse(["Hello [%var world%]"])
-                 )
-    
-    assert_equal([
-                   [1, ""],
-                   [1, ["value", "articleno"]],
-                   [1, ""]
-                 ], @@parser.parse(["[%var articleno%]"]))
-    assert_equal([
-                   [1, ""],
-                   [1, ["value", "articleno"]],
-                   [1, ""]
-                 ], @@parser.parse(["[%  var articleno  %\]"]))
-    
-    multiline = [
-      "Hello [%var world%\]",
-      "[%if return%]",
-      "Welcome Back!",
-      "[%endif%]"
-    ]
-    
-    mResult = [
-      [1, "Hello "],
-      [1, ["value", "world"]],
-      [1, ""],
-      [2, ""],
-      [2, ["ifopen", "return"]],
-      [2, ""],
-      [3, "Welcome Back!"],
-      [4, ""],
-      [4, ["ifclose", nil]],
-      [4, ""]
-    ]
-    
-    assert_equal(mResult, @@parser.parse(multiline))
-
-    multiline = [
-      "Hello [%var world%\]",
-      "[%unless return%]",
-      "Welcome!",
-      "[%endunless%]"
-    ]
-    
-    mResult = [
-      [1, "Hello "],
-      [1, ["value", "world"]],
-      [1, ""],
-      [2, ""],
-      [2, ["unlessopen", "return"]],
-      [2, ""],
-      [3, "Welcome!"],
-      [4, ""],
-      [4, ["unlessclose", nil]],
-      [4, ""]
-    ]
-    
-    assert_equal(mResult, @@parser.parse(multiline))
-
-  end
-  
-  def testCompile
-    directives = [
-      "Hello [%var world%]",
-      "[%if return%]",
-      "Welcome Back!",
-      "[%endif%]"
-    ]
-    assert(@@parser.compile(@@parser.parse(directives)))
-
-    directives = [
-      "Hello [%var world%]",
-      "[%unless return%]",
-      "Welcome!",
-      "[%endunless%]"
-    ]
-    assert(@@parser.compile(@@parser.parse(directives)))
-  end
-  
-  def testBuild
-    assert(@@parser.build("tdata/p/b1.txt"))
-    # Make sure nothing panics if we ask for the commands again.
-    assert(@@parser.build("tdata/p/b1.txt"))
-  end
-end
-
-class TC_SyntaxCachedParser < Test::Unit::TestCase
-  @@parser = Syntax::CachedParser.new(Syntax::DEFAULT)
-  
-  def testBuild
-    assert(@@parser.build("tdata/p/b1.txt"))
-    assert(File.exists?("tdata/p/_b1.txt"))
-    
-    ns = Namespace.new()
-    ns["world"] = "World"
-    assert(@@parser.output(ns))
-  end
-  
-  def testCachedBuild
-    assert(@@parser.build("tdata/p/cb1.txt"))
-    assert(File.exists?("tdata/p/_cb1.txt"))
-    assert(@@parser.reset)
-    assert(@@parser.build("tdata/p/cb1.txt"))
-  end
-  
-  def testCachedRebuild
-    # Create a new parser and build with the cached information.
-    p2 = Syntax::CachedParser.new(Syntax::DEFAULT)
-    assert(p2.build("tdata/p/cb1.txt"))
-    
-    # Clean up after ourselves.
-    system("rm -f tdata/p/_cb1.txt")
-  end
-end
-
-class TC_PageTemplate < Test::Unit::TestCase
-  @@template = PageTemplate.new( 'syntax' => Syntax::DEFAULT )
-  
-  def testLoadFile
-    assert(@@template.load("tdata/t.txt"))
-    assert_equal("tdata/t.txt", @@template.file)
-    assert_raises(ArgumentError) { @@template.load("tdata/null") }
-  end
-  
-  def testInitializeTemplate
-    assert(PageTemplate.new())
-    assert(PageTemplate.new("filename" => "tdata/t.txt"))
-    assert_raises(ArgumentError) { PageTemplate.new("filename" => "tdata/null") }
-  end
-  
-  def testSetParameter
-    assert(@@template.setParameter("name", "PageTemplate"))
-  end
-  
-  def testGetParameter
-    @@template.setParameter("name", "PageTemplate")
-    assert_equal("PageTemplate", @@template.getParameter("name"))
-    assert_nil(@@template.getParameter("null"))
-  end
-  
-  def testHashAccess
-    @@template['hash'] = 'test'
-    assert_equal('test', @@template['hash'])
-  end
-  
-  def testOutputNoMarkup
-    @@template.load("tdata/nm.txt")
-    cmpFile = File.open("tdata/nm.txt").read()
-    assert_equal(cmpFile, @@template.output())
-  end
-
-  def testOutputCommentMarkup
-    @@template.load("tdata/cm.txt")
-    assert(@@template.output !~ /\[%--/)
-  end
-  
-  def testOutputValueMarkup
-    
-    # Valid markup, value exists.
-    @@template['title'] = "ValueMarkup"
-    @@template.load("tdata/v1.txt")
-    assert(@@template.output =~ /<h1>ValueMarkup<\/h1>/)
-    
-    # Valid markup, value does not exist.
-    @@template['title'] = ""
-    assert(@@template.output =~ /<h1><\/h1>/)
-    
-    # Invalid markup.
-    @@template.load("tdata/v2.txt")
-    assert(@@template.output =~ /<h1>title%\]<\/h1>/)
-  end
-  
-  def testOutputIfMarkup
-    @@template['flag'] = true
-    @@template.load("tdata/i1.txt")
-    assert(@@template.output =~ /It's all true!/)
-    
-    @@template['flag'] = false
-    assert(@@template.output !~ /It's all true!/)
-    
-    # Nested if expressions
-    @@template.load("tdata/i2.txt")
-    
-    # 1. Both true.
-    @@template['outer'] = true
-    @@template['inner'] = true
-    assert(@@template.output =~ /This is outer text/)
-    assert(@@template.output =~ /This is inner text/)
-    
-    # 2. Outer true, inner false.
-    @@template['outer'] = true
-    @@template['inner'] = false
-    assert(@@template.output =~ /This is outer text/)
-    assert(@@template.output !~ /This is inner text/)
-    
-    # 3. Inner true, outer false.
-    @@template['outer'] = false
-    @@template['inner'] = true
-    assert(@@template.output !~ /This is outer text/)
-    assert(@@template.output !~ /This is inner text/)
-  end
-  
-  def testOutputIfBranchMarkup
-    @@template.load("tdata/ie1.txt")
-    
-    # True: if block executes, not else block
-    @@template["flag"] = true
-    assert(@@template.output =~ /It's all true!/)
-    assert(@@template.output !~ /Nothing is true/)
-    
-    # False: else block executes, not if block
-    @@template["flag"] = false
-    assert(@@template.output =~ /Nothing is true/)
-    assert(@@template.output !~ /It's all true!/)
-  end
-  
-  def testOutputNestedIfBranchMarkup
-    @@template.load("tdata/ie2.txt")
-    
-    # Outer true, inner true
-    @@template['outer'] = true
-    @@template['inner'] = true
-    assert(@@template.output =~ /Outer is true/)
-    assert(@@template.output =~ /Inner is true/)
-    
-    # Outer true, inner false
-    @@template['outer'] = true
-    @@template['inner'] = false
-    assert(@@template.output =~ /Outer is true/)
-    assert(@@template.output =~ /Inner is false/)
-    
-    # Outer false, inner true
-    @@template['outer'] = false
-    @@template['inner'] = true
-    assert(@@template.output =~ /Outer is false/)
-    assert(@@template.output =~ /Inner is true/)
-    
-    # Outer false, inner false
-    @@template['outer'] = false
-    @@template['inner'] = false
-    assert(@@template.output =~ /Outer is false/)
-    assert(@@template.output =~ /Inner is false/)
-  end
-  
-  def testOutputLoopMarkup
-    @@template.load("tdata/l1.txt")
-    
-    # Loop Exists
-    myLoop = []
-    1.upto(5) { |v| myLoop << {'value' => v} }
-    
-    @@template['loop'] = myLoop
-    assert(@@template.output =~ /<li>3<\/li>/)
-    
-    # Loop Doesn't Exist
-    @@template['loop'] = false
-    assert(@@template.output !~ /<li>3<\/li>/)
-    
-    # Loop Is Empty List
-    @@template['loop'] = []
-    assert(@@template.output !~ /<li>.*?<\/li>/)
-  end
-  
-  def testLoopMetavariables
-    @@template.load("tdata/metadata.1.txt")
-    myLoop = []
-    1.upto(5) { |v| myLoop << {'v' => v} }
-    
-    @@template['loop'] = myLoop
-    assert(@@template.output =~ /<li>--1--<\/li>/,
-           "__FIRST__ is set for the first iteration through a loop")
-    assert(@@template.output =~ /<li>5<\/li>/,
-           "__FIRST__ is unset after the first iteration through a loop")
-
-    @@template.load("tdata/metadata.2.txt")
-    assert(@@template.output =~ /<li>--5--<\/li>/,
-           "__LAST__ is set for the last iteration through a loop")
-    assert(@@template.output =~ /<li>1<\/li>/,
-           "__LAST__ is unset before the last iteration through a loop")
-
-    @@template.load("tdata/metadata.3.txt")
-    assert(@@template.output =~ /<li>--1--<\/li>/,
-           "__ODD__ is set for odd-numbered iterations through a loop (1st, 3rd, etc)")
-    assert(@@template.output =~ /<li>2<\/li>/,
-           "__ODD__ is unset for even-numbered iterations through a loop (2nd, 4th, etc)")
-  end
-  
-  def testOutputNestedLoopMarkup
-    @@template.load("tdata/l2.txt")
-    
-    # Outer Loop Exists, Inner Loop Exists
-    innerLoop = []
-    'a'.upto('f') { |v| innerLoop << { 'value' => v } }
-    outerLoop = []
-    1.upto(5) do |v| 
-      outerLoop << {'value' => v, 'inner' => innerLoop}
-    end
-    @@template['loop'] = outerLoop
-    assert(@@template.output =~ /<li>\d/)
-    assert(@@template.output =~ /<li>[a-f]<\/li>/)
-    
-    # Outer Loop Exists, Inner Loop Empty
-    outerLoop.each { |x| x['inner'] = [] }
-    assert(@@template.output !~ /<li>[a-f]<\/li>/)
-    
-    # Outer Loop Exists, Alternate Inner Loops Empty
-    outerLoop.each_with_index do |x, i|
-      x['inner'] = innerLoop if i % 2 == 0
-    end
-    assert(@@template.output =~ /<li>4\s+?<ul><\/ul>/m)
-    assert(@@template.output =~ /<li>3\s+?<ul><li>a/m)
-    
-    # Outer Loop Empty
-    @@template['loop'] = false
-    assert(@@template.output !~ /<li>/)
-  end
-  
-  def testOutputLoopBranchMarkup
-    @@template.load("tdata/ib1.txt")
-    
-    # Loop exists
-    myLoop = []
-    1.upto(5) { |v| myLoop << {'value' => v} }
-    @@template['loop'] = myLoop
-    assert(@@template.output =~ /<li>\d<\/li>/)
-    assert(@@template.output !~ /No values/)
-    
-    # No loop
-    @@template['loop'] = []
-    assert(@@template.output !~ /<li>\d<\/li>/)
-    assert(@@template.output =~ /No values/)
-  end
-  
-  def testOutputNestedLoopBranchMarkup
-    @@template.load("tdata/ib2.txt")
-    # Outer Loop Exists, Inner Loop Exists
-    innerLoop = []
-    'a'.upto('f') { |v| innerLoop << { 'value' => v } }
-    outerLoop = []
-    1.upto(5) do |v| 
-      outerLoop << {'value' => v, 'inner' => innerLoop}
-    end
-    @@template['loop'] = outerLoop
-    assert(@@template.output =~ /<li>\d/)
-    assert(@@template.output =~ /<li>[a-f]<\/li>/)
-    
-    # Outer Loop Exists, Inner Loop Empty
-    outerLoop.each { |x| x['inner'] = [] }
-    assert(@@template.output =~ /No inner values/)
-    
-    # Outer Loop Exists, Alternate Inner Loops Empty
-    outerLoop.each_with_index do |x, i|
-      x['inner'] = innerLoop if i % 2 == 0
-    end
-    assert(@@template.output =~ /<li>4\s+?<ul>.+?No inner values/m)
-    assert(@@template.output =~ /<li>3\s+?<ul>.+?<li>a/m)
-    
-    # Outer Loop Empty
-    @@template['loop'] = false
-    assert(@@template.output =~ /No values/)
-  end
-  
-  def testOutputComplexMarkup
-    title = "Testing"
-    reverse = true
-    
-    languages = [
-      { 'name'=> 'C', 'author'=> 'Dennis Ritchie' },
-      { 'name'=> 'C++', 'author'=> 'Bjarne Stroustrup' },
-      { 'name'=> 'Perl', 'author'=> 'Larry Wall',
-       'guideline'=> 'TMTOWTDI - There\'s More Than One Way To Do It'},
-      { 'name'=> 'Python', 'author'=> 'Guido van Rossum',
-       'guideline'=> 'There Should Be One Obvious Way To Do It' },
-      { 'name'=> 'Ruby', 'author'=> 'Yukihiro Matsumoto',
-       'guideline'=> 'TPOL - The Principle Of Least Surprise'}
-    ]
-    
-    favorites = [
-      { 'topic'=> 'Interesting Comic Books',
-       'items'=> [
-          {'title'=> 'Dropsie Avenue', 
-           'creator'=> 'Will Eisner'},
-          {'title'=> 'Cerebus', 
-           'creator'=> 'Dave Sim'},
-          {'title'=> 'Jar Of Fools', 
-           'creator'=> 'Jason Lutes'}]},
-      { 'topic'=> 'Favorite Albums',
-       'items'=> [
-          {'title'=> 'Amnesiac', 
-           'creator'=> 'Radiohead'},
-          {'title'=> 'The Moon and Antarctica', 
-           'creator'=> 'Modest Mouse'},
-          {'title'=> 'Dirt Track Date', 
-           'creator'=> 'Southern Culture On The Skids'},
-          {'title'=> 'My Motor', 
-           'creator'=> 'Dorkweed'},
-          {'title'=> 'Swordfishtrombones', 
-           'creator'=> 'Tom Waits'}]}
-    ]
-    
-    page = PageTemplate.new('filename' => "tdata/complex.txt")
-    page.setParameter("title", title)
-    page.setParameter("ifTest", 1)
-    page.setParameter("languages", languages)
-    page.setParameter("favorites", favorites)
-    if reverse == 1
-      page.setParameter("reverse", 1)
-	end
-    
-    assert(page.output)
-  end
-  
-  def testCachedTemplate
-    assert(ct = PageTemplate.new('filename' => "tdata/complex.txt",
-                                 'use_cache' => true
-                                 ))
-    
-    languages = [
-      { 'name'=> 'C', 'author'=> 'Dennis Ritchie' },
-      { 'name'=> 'C++', 'author'=> 'Bjarne Stroustrup' },
-      { 'name'=> 'Perl', 'author'=> 'Larry Wall',
-       'guideline'=> 'TMTOWTDI - There\'s More Than One Way To Do It'},
-      { 'name'=> 'Python', 'author'=> 'Guido van Rossum',
-       'guideline'=> 'There Should Be One Obvious Way To Do It' },
-      { 'name'=> 'Ruby', 'author'=> 'Yukihiro Matsumoto',
-       'guideline'=> 'TPOL - The Principle Of Least Surprise'}
-    ]
-    
-    favorites = [
-      { 'topic'=> 'Interesting Comic Books',
-       'items'=> [
-          {'title'=> 'Dropsie Avenue', 
-           'creator'=> 'Will Eisner'},
-          {'title'=> 'Cerebus', 
-           'creator'=> 'Dave Sim'},
-          {'title'=> 'Jar Of Fools', 
-           'creator'=> 'Jason Lutes'}]},
-      { 'topic'=> 'Favorite Albums',
-       'items'=> [
-          {'title'=> 'Amnesiac', 
-           'creator'=> 'Radiohead'},
-          {'title'=> 'The Moon and Antarctica', 
-           'creator'=> 'Modest Mouse'},
-          {'title'=> 'Dirt Track Date', 
-           'creator'=> 'Southern Culture On The Skids'},
-          {'title'=> 'My Motor', 
-           'creator'=> 'Dorkweed'},
-          {'title'=> 'Swordfishtrombones', 
-           'creator'=> 'Tom Waits'}]}
-    ]
-    ct["languages"] = languages
-    ct["favorites"] = favorites
-    assert(ct.output)
-    assert(File.exists?("tdata/_complex.txt"))
-    system("rm -f tdata/_complex.txt")
-    
-  end
-  
-  def testClearFile
-    assert(@@template.clearFile)
-  end
-end
-
-class TC_Include < Test::Unit::TestCase
-  def testIncludeCommand()
-    ns = Namespace.new()
-
-    incCommand = IncludeCommand.new("tdata/include.1.txt")
-    text = File.open("tdata/include.1.txt").read()
-    assert_equal(text, incCommand.output(ns),
-                 "IncludeCommands can be initialized with relative filenames")
-
-    text = File.open("tdata/include.2.txt").read()
-    incCommand = IncludeCommand.new("tdata/include.2.txt")
-    assert_equal(text, incCommand.output(ns))
-
-    # Including text with template markup.
-    ns["x"] = "Dude!"
-    pt = PageTemplate.new()
-    pt.load("tdata/include.3.txt")
-    pt["x"] = "Dude!"
-    incCommand = IncludeCommand.new("tdata/include.3.txt")
-    assert_equal(pt.output(), incCommand.output(ns),
-                 "Include Commands can parse standard Template markup")
-  end
-
-  def testIncludePath
-    incCommand = IncludeCommand.new("include.4.txt", [ "tdata" ])
-    text = File.open("tdata/include.4.out.txt").read()
-    assert_equal(text, incCommand.output,
-                 "IncludeCommand accepts an array of paths as a second arg")
-
-    incCommand = IncludeCommand.new("include.4.txt", [ "/etc", "tdata" ])
-    text = File.open("tdata/include.4.out.txt").read()
-    assert_equal(text, incCommand.output,
-                 "IncludeCommand accepts an array of paths as a second arg")
-
-    pt = PageTemplate.new('include_path' => "tdata")
-    pt.load("tdata/include.4b.txt")
-    pt["file"] = "include.4a.txt"
-    text = File.open("tdata/include.4.out.txt").read()
-    assert_equal(text, pt.output,
-                 "Include Commands can be given a variable name as an argument")
-
-    pt = PageTemplate.new('include_path' => "tdata")
-    pt.load("tdata/include.4b.txt")
-    pt["file"] = "secret-of-life.txt"
-    text = File.open("tdata/include.4.nf.out.txt").read()
-    assert_equal(text, pt.output,
-                 "Include Commands will output a warning if file isn't found.")
-
-    # Support for multiple include paths.
-    pt = PageTemplate.new()
-    assert_equal([ Dir.getwd() ], pt.path)
-    assert(pt.add_path('tdata'),
-           "Use #add_path(path) to add an include path.")
-    assert_equal([ Dir.getwd(), 'tdata'], pt.path)
-    pt.add_path('tdata/inc-1')
-    assert_equal([ Dir.getwd, "tdata", "tdata/inc-1"], pt.path)
-    pt = PageTemplate.new('include_path' => %w{tdata tdata/inc-1})
-    assert_equal([ Dir.getwd, "tdata", "tdata/inc-1"], pt.path)
-  end
-
-  def testIncludeSyntax
-    text = File.open("tdata/include.4.out.txt").read()
-    pt = PageTemplate.new("include_path" => "tdata")
-    pt.load("include.4.txt")
-    assert_equal(text, pt.output(),
-                 "PageTemplate supports 'include' syntax")
-    pt = PageTemplate.new('include_path' => "tdata")
-    pt.load("include.5.txt")
-    assert_equal(text, pt.output(),
-                 "PageTemplate supports 'include' syntax")
-
-  end
-
-end