PageTemplate 1.1.2 → 1.2.0

data/TC_PageTemplate.rb~

@@ -0,0 +1,965 @@
+#!/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