rockit 0.7.1

data/tests/unit/parse/utest_grammar.rb

@@ -0,0 +1,160 @@
+require 'test/unit'
+
+require 'parse/grammar'
+include Parse::Grammar
+
+class UT_Parse_Grammar < Test::Unit::TestCase
+  def test_01_Symbol
+    s = Parse::Grammar::GrammarSymbol.new "name"
+    assert_equal("name", s.name)
+    assert_equal("name", s.inspect)
+    assert_equal(s, s.to_grammar_symbol)
+  end
+
+  def test_02_Symbol_name_not_needed
+    s = Parse::Grammar::GrammarSymbol.new
+    assert_equal(nil, s.name)
+    assert_equal(s, s.to_grammar_symbol)
+  end
+
+  def test_03_NonTerminal
+    s = NonTerminal.new :name
+    assert_equal(:name, s.name)
+    assert_equal("name", s.inspect)
+    assert_kind_of(Parse::Grammar::GrammarSymbol, s)
+    assert_equal(s, s.to_grammar_symbol)
+  end
+
+  def test_04_Terminal
+    s = Terminal.new
+    assert_kind_of(Parse::Grammar::GrammarSymbol, s)
+  end
+
+  def test_05_Production
+    p = Production.new(n = NonTerminal.new(:N), [t = Terminal.new(:T)])
+    assert_equal(n, p.symbol)
+    assert_equal(t, p.rhs.first)
+    assert_equal(t, p.right_hand_side.first)
+  end
+
+  def test_06_Production_short_hand
+    p = Prod[n = NonTerminal.new(:N), [t = Terminal.new(:T)]]
+    assert_equal(n, p.symbol)
+    assert_equal(t, p.rhs.first)
+    assert_equal(t, p.right_hand_side.first)
+
+    p2 = Prod[:N, [t]]
+    assert_equal("N", p2.symbol.inspect)
+  end
+
+  def test_07_nonterminal_equality
+    n1 = NonTerminal.new(:N)
+    n2 = NonTerminal.new(:N)
+    assert(n1 == n2)
+    assert(n2 == n1)
+  end
+
+  def test_08_Rule
+    p1 = Prod[n = NonTerminal.new(:N), [Terminal.new(:T1)]]
+    p2 = Prod[:N, [Terminal.new(:T2)]]
+    r = Rule[p1]
+
+    assert(n == r.symbol)
+    assert_equal(1, r.productions.length)
+
+    r.add_production p2
+    assert_equal(n, r.symbol)
+    assert_equal(2, r.productions.length)
+
+    assert_raises(ArgumentError) {r.add_production(Prod[:N2, [Terminal[:T3]]])}
+  end
+
+  def test_09_Grammar
+    g = Grammar.new(:name => "Test Grammar 1", :author => "Robert")
+    assert_kind_of(Grammar, g)
+    assert_equal("Test Grammar 1", g.meta[:name])
+    assert_equal("Robert", g.meta[:author])
+    assert_equal(0, g.rules.length)
+    assert_equal(0, g.nonterminals.length)
+    assert_equal(0, g.terminals.length)
+    assert_equal(0, g.symbols.length)
+
+    g.add_rule(Rule[Prod[:N, [Terminal[:T1]]]])
+    assert_equal(1, g.rules.length)
+    assert_equal(1, g.nonterminals.length)
+    assert_equal(1, g.terminals.length)
+    assert_equal(2, g.symbols.length)
+  end
+
+  def test_10_symbol_predicates
+    nt = NonTerminal[:N]
+    assert_equal(true, nt.nonterminal?)
+    assert_equal(false, nt.terminal?)
+    assert_equal(false, nt.action?)
+
+    t = Terminal[:T]
+    assert_equal(false, t.nonterminal?)
+    assert_equal(true, t.terminal?)
+    assert_equal(false, t.action?)
+
+    a = Action[:A]
+    assert_equal(false, a.nonterminal?)
+    assert_equal(false, a.terminal?)
+    assert_equal(true, a.action?)
+  end
+
+  class TestGrammar < Grammar
+    r :S, [[:B]]
+    r :B, [
+      [Terminal.new(:T1)],
+      [Terminal.new(:T2), Terminal.new(:T3)],
+    ]
+    t :CT1, ["A"]
+  end
+
+  def test_11_embedded_grammar_def
+    t = TestGrammar.new
+
+    assert_equal(2, t.rules.length)
+
+    assert_equal(:S, t.rules.first.symbol.name)
+    assert_equal(1, t.rules.first.productions.length)
+
+    assert_equal(:B, t.rules.last.symbol.name)
+    assert_equal(2, t.rules.last.productions.length)
+    assert_equal(:T1, t.rules.last.productions.first.rhs.first.name)
+    assert_equal(:T2, t.rules.last.productions.last.rhs.first.name)
+    assert_equal(:T3, t.rules.last.productions.last.rhs.last.name)
+
+    assert_equal(1, t.complex_terminals.length)
+
+    assert_equal(:CT1, t.complex_terminals.first.name)
+  end
+
+  TestDeepClone = Struct.new(:a)
+
+  def test_12_deep_clone
+    a = [1,2,3]
+    t1 = TestDeepClone.new(a)
+    t1a = t1.clone
+    t1b = t1.deep_clone
+    assert_equal(t1.a.object_id, t1a.a.object_id)
+    assert_not_equal(t1.a.object_id, t1b.a.object_id)
+  end
+
+  def test_13_define_grammar_in_a_block
+    g = Grammar.new do
+      r :S, [["a", :B]]
+      r :B, [["b"]]
+    end
+    assert_equal(2, g.nonterminals.length)
+  end
+
+  def test_14_extending_a_grammar_with_a_block
+    g = TestGrammar.new do
+      r :A, [["a"]]
+    end
+    # Two nonterminals in the original grammar and one new here => 3
+    assert_equal(3, g.nonterminals.length)
+  end
+end

data/tests/unit/rockit/assembler/llvm/utest_instructions.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+
+require 'rockit/assembler/llvm/instructions'
+include Rockit::Assembler::LLVM
+
+class UTestLLVMInstructions < Test::Unit::TestCase
+  def test_01_NamedValue_valid
+    nv1 = NamedValue.new("foo")
+    assert_equal("%foo", nv1.to_llvm)
+
+    nv2 = NamedValue.new("DivByZero")
+    assert_equal("%DivByZero", nv2.to_llvm)
+
+    nv3 = NamedValue.new("a.really.long.identifier")
+    assert_equal("%a.really.long.identifier", nv3.to_llvm)
+  end
+
+  def test_02_NamedValue_invalid
+    assert_raises(ArgumentError) {NamedValue.new("12")}
+    assert_raises(ArgumentError) {NamedValue.new("%")}
+  end
+
+  def test_03_UnnamedValue_valid
+    u1 = UnnamedValue.new(0)
+    assert_equal("%0", u1.to_llvm)
+
+    u2 = UnnamedValue.new(12)
+    assert_equal("%12", u2.to_llvm)
+
+    u3 = UnnamedValue.new(2)
+    assert_equal("%2", u3.to_llvm)
+
+    u4 = UnnamedValue.new(44)
+    assert_equal("%44", u4.to_llvm)
+  end
+
+  def test_04_UnnamedValue_invalid
+    assert_raises(ArgumentError) {UnnamedValue.new(-1)}
+    assert_raises(ArgumentError) {UnnamedValue.new(-18743)}
+  end
+end

data/tests/unit/rockit/assembler/llvm/utest_module.rb

@@ -0,0 +1,19 @@
+require 'test/unit'
+
+require 'rockit/assembler/llvm/module'
+include Rockit::Assembler::LLVM
+
+class UTestLLVMInstructions < Test::Unit::TestCase
+  # Hello world example module
+  class TestModule1 < LLVM::Module
+    LC0 = internal constant '[13 x sbyte]' c("hello world\0A")
+
+    declare int "puts", [sbytep]
+
+    defmethod("main", int, []) do
+      
+    end
+  end
+
+  def te
+end

data/tests/unit/rockit/prettyprint/utest_box.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+
+require 'rockit/prettyprint/box'
+include Rockit::PrettyPrint
+
+class UTestBox < Test::Unit::TestCase
+  def setup
+    @h = Box::H.new(1, "a") 
+    @h1 = Box::H.new(1, "a", "b") 
+    @h2 = Box::H.new(2, "a", "b") 
+    @h3 = Box::H.new(3, "a", "b", "c") 
+    @v = Box::V.new("a", "2 2", "c") 
+    @e = Box::Epsilon.new("x", "   ", ":=") 
+  end
+  
+  def test_01_creation
+    assert_kind_of(Box::H, @h)
+    assert_equal(1, @h.num_spaces)
+    assert_equal(["a"], @h.elements)
+
+    assert_kind_of(Box::H, @h3)
+    assert_equal(3, @h3.num_spaces)
+    assert_equal(["a", "b", "c"], @h3.elements)
+
+    assert_kind_of(Box::V, @v)
+    assert_equal(["a", "2 2", "c"], @v.elements)
+
+    assert_kind_of(Box::Epsilon, @e)
+  end
+
+  def test_02_render
+    assert_equal("a", @h.render)
+    assert_equal("a b", @h1.render)
+    assert_equal("a  b", @h2.render)
+    assert_equal("a   b   c", @h3.render)
+    assert_equal("a\n2 2\nc", @v.render)
+    assert_equal("x   :=", @e.render)
+  end
+
+  def test_03_prepend
+    p = Box::Prepend["#", "A comment"]
+    assert_equal("# A comment", p.render)
+  end
+end

data/tests/unit/rockit/tree/utest_tree_base.rb

@@ -0,0 +1,301 @@
+require 'test/unit'
+
+require 'rockit/tree/base'
+require 'samples/rockit/ruby/sample_ruby_ast_trees/mr_1'
+
+class UTestTreeBase < Test::Unit::TestCase
+  def setup
+    @a = Rockit::Tree::Base.new_tree_class(:A)
+    @b = Rockit::Tree::Base.new_tree_class(:B, [:c1])
+    @c = Rockit::Tree::Base.new_tree_class(:C, [:c1, :c2])
+  end
+
+  def test_01_subclass_with_no_named_children
+    t = @a[1]
+    assert_kind_of(@a, t)
+    assert_equal(1, t.children.length)
+    assert_equal(1, t[0])
+
+    t2 = @a["1", 2]
+    assert_kind_of(@a, t2)
+    assert_equal(2, t2.children.length)
+    assert_equal("1", t2[0])
+    assert_equal(2, t2[1])
+  end
+
+  def test_02_subclass_with_one_named_child
+    t = @b[:a]
+    assert_kind_of(@b, t)
+    assert_equal(1, t.children.length)
+    assert_equal(:a, t[0])
+    assert_equal(:a, t.c1)
+  end
+
+  def test_03_subclass_with_two_named_children
+    t = @c[3.0, 4]
+    assert_kind_of(@c, t)
+    assert_equal(2, t.children.length)
+    assert_equal(3.0, t[0])
+    assert_equal(3.0, t.c1)
+    assert_equal(4, t[1])
+    assert_equal(4, t.c2)
+
+    t.c1 = 5
+    assert_equal(5, t[0])
+    assert_equal(5, t.c1)
+
+    t.c2 = 6
+    assert_equal(6, t[1])
+    assert_equal(6, t.c2)
+  end
+
+  def test_04_complex_tree
+    t = @a[@b[@c[1, 2]], @c[3, 4]]
+    assert_kind_of(@a, t)
+    assert_kind_of(@b, t[0])
+    assert_kind_of(@c, t[1])
+    assert_kind_of(@c, t[0][0])
+    assert_equal(1, t[0][0][0])
+    assert_equal(2, t[0][0][1])
+    assert_equal(3, t[1][0])
+    assert_equal(4, t[1][1])
+  end
+
+  def test_05_subclass_of_tree
+    @d = @a.new_tree_class(:D, [:d1, :d2])
+
+    t = @d["sub", /a/]
+    assert_kind_of(@d, t)
+    assert_kind_of(@a, t)
+    assert_equal("sub", t[0])
+    assert_equal("sub", t.d1)
+    assert_equal(/a/, t[1])
+    assert_equal(/a/, t.d2)
+  end
+
+  def test_06_upcase_symbols_to_patternvar
+    t = @a[:X]
+    nt = t.upcase_symbols_to_pattern_vars
+    assert_kind_of(@a, nt)
+    pvar = nt[0]
+    assert_kind_of(Rockit::Tree::Base::PatternVar, pvar)
+    assert_equal(:X, pvar.name)
+
+    t2 = @c[@b[:X], @a[:Y, :Z]]
+    nt2 = t2.upcase_symbols_to_pattern_vars
+    assert_kind_of(@c, nt2)
+    xvar = nt2[0][0]
+    assert_kind_of(Rockit::Tree::Base::PatternVar, xvar)
+    assert_equal(:X, pvar.name)
+    yvar = nt2[1][0]
+    assert_kind_of(Rockit::Tree::Base::PatternVar, yvar)
+    assert_equal(:Y, yvar.name)
+    zvar = nt2[1][1]
+    assert_kind_of(Rockit::Tree::Base::PatternVar, zvar)
+    assert_equal(:Z, zvar.name)
+  end
+
+  def assert_match_result(expected, tree, pattern)
+    actual = pattern.upcase_symbols_to_pattern_vars.match_tree(tree)
+    assert_equal(expected, actual)
+  end
+
+  def test_07_match_tree_simple
+    pattern = @a[:X].upcase_symbols_to_pattern_vars
+    tree = @a[1]
+    res = pattern.match_tree(tree)
+    assert_kind_of(Hash, res)
+    assert_equal(1, res[:X])
+
+    t2 = @a[t3 = @b[1]]
+    assert_match_result({:X => t3}, t2, pattern)
+  end
+
+  def test_08_match_tree_complex
+    pattern = @c[@b[:X], @a[:Y]].upcase_symbols_to_pattern_vars
+    tree = @c[@b["23"], @a[/a/]]
+    res = pattern.match_tree(tree)
+    assert_kind_of(Hash, res)
+    assert_equal("23", res[:X])
+    assert_equal(/a/, res[:Y])
+
+    pattern = @b[@c[:L, :R]].upcase_symbols_to_pattern_vars
+    t2 = @b[t3 = @c[3, 4]]
+    res = pattern.match_tree(t2)
+    assert_equal({:L => 3, :R => 4}, res)
+  end
+
+  def test_09_match_tree_complex_with_subtrees
+    pattern = @c[@b[:ARNE], @a[:STree]].upcase_symbols_to_pattern_vars
+    stree = @c[3, 4]
+    tree = @c[@b[1.4], @a[stree]]
+    res = pattern.match_tree(tree)
+    assert_kind_of(Hash, res)
+    assert_equal(1.4, res[:ARNE])
+    assert_equal(stree, res[:STree])
+  end
+
+  def test_10_regexp_style_matching
+    stree = @a[]
+    res = @b[@c[stree, 2]] =~ @b[@c[:First, :Second]]
+    assert_kind_of(Hash, res)
+    assert_equal(2, res[:Second])
+    assert_equal(stree, res[:First])
+  end
+
+  def test_11_failing_match_tree
+    assert_match_result(nil, @b[1], @a[])
+    assert_match_result(nil, @a[1], @b[])
+    assert_match_result(nil, @a[1], @a[2])
+    assert_match_result(nil, @c[@a[], 1], @c[@a[], 2])
+    assert_match_result(nil, @c[@a[], "1"], @c[@a[], "2"])
+  end
+
+  def assert_pp(expected, tree, width = 79)
+    actual = ""
+    PP.pp(tree, actual, width)
+    assert_equal(expected, actual)
+  end
+
+  def test_12_pretty_print
+    assert_pp("A[1]\n", @a[1])
+    assert_pp("A[B[2]]\n", @a[@b[2]])
+    assert_pp("C[B[3.0], /a/]\n", @c[@b[3.0], /a/])
+    lstr = "." * 75
+    assert_pp("C[\n B[3.0],\n #{lstr.inspect}]\n", @c[@b[3.0], lstr])
+  end
+
+  def collect_trees(tree)
+    ary = []
+    tree.each_tree {|t| ary << t}
+    ary
+  end
+
+  def test_13_each_tree_simple
+    t = @a[]
+    assert_equal([t], collect_trees(t))
+  end
+
+  def test_14_each_tree_complex
+    t = @c[t2 = @b[t3 = @a[1]], t4 = @b[2]]
+    assert_equal([t, t2, t3, 1, t4, 2], collect_trees(t))
+  end
+
+  def collect_trees_of_class(tree, klass, recursive = false)
+    ary = []
+    tree.each_tree_of_class(klass, recursive) {|t| ary << t}
+    ary
+  end
+
+  def test_15_each_tree_of_klass
+    t = @c[t2 = @b[t3 = @a[t4 = @b[1]]], t5 = @b[t6 = @c[3, 4]]]
+    assert_equal([t2, t5], collect_trees_of_class(t, @b))    
+    assert_equal([t2, t4, t5], collect_trees_of_class(t, @b, true))    
+    assert_equal([t3], collect_trees_of_class(t, @a))    
+    assert_equal([t], collect_trees_of_class(t, @c))
+    assert_equal([t, t6], collect_trees_of_class(t, @c, true))
+  end
+
+  def test_16_set_parents_and_parent
+    t = @c[t2 = @b[t3 = @a[t4 = @b[1]]], t5 = @b[t6 = @c[3, 4]]]
+
+    assert_equal(nil, t.parent)
+    assert_equal(nil, t2.parent)
+    assert_equal(nil, t3.parent)
+    assert_equal(nil, t4.parent)
+    assert_equal(nil, t5.parent)
+    assert_equal(nil, t6.parent)
+
+    t.set_parents
+
+    assert_equal(nil, t.parent)
+    assert_equal(t, t2.parent)
+    assert_equal(t2, t3.parent)
+    assert_equal(t3, t4.parent)
+    assert_equal(t, t5.parent)
+    assert_equal(t5, t6.parent)
+  end
+
+  def test_17_all_matching_trees
+    t = @c[t2 = @b[t3 = @a[t4 = @b[1]]], t5 = @b[t6 = @c[3, 4]]]
+
+    pattern = @a[:X]
+    res = pattern.all_matching_trees(t)
+    assert_kind_of(Array, res)
+    assert_equal(1, res.length)
+    mapping, subtree = res[0]
+    assert_kind_of(Hash, mapping)
+    assert_equal({:X => t4}, mapping)
+    assert_kind_of(Rockit::Tree::Base, subtree)
+    assert_equal(t3, subtree)
+
+    pattern = @b[:X]
+    res = pattern.all_matching_trees(t)
+    assert_equal(3, res.length)
+    assert_equal({:X => t3}, res[0][0])
+    assert_equal(t2, res[0][1])
+    assert_equal({:X => 1}, res[1][0])
+    assert_equal(t4, res[1][1])
+    assert_equal({:X => t6}, res[2][0])
+    assert_equal(t5, res[2][1])
+
+    pattern = @c[:Left, :Right]
+    res = pattern.all_matching_trees(t)
+    assert_equal(2, res.length)
+    assert_equal({:Left => t2, :Right => t5}, res[0][0])
+    assert_equal(t, res[0][1])
+    assert_equal({:Left => 3, :Right => 4}, res[1][0])
+    assert_equal(t6, res[1][1])
+
+    pattern = @b[@a[:Z]]
+    res = pattern.all_matching_trees(t)
+    assert_equal(1, res.length)
+    assert_equal({:Z => t4}, res[0][0])
+    assert_equal(t2, res[0][1])
+
+    pattern = @b[@c[:L, :R]]
+    res = pattern.all_matching_trees(t)
+    assert_equal(1, res.length)
+    assert_equal({:L => 3, :R => 4}, res[0][0])
+    assert_equal(t5, res[0][1])
+  end
+
+  def test_18_bug_with_nested_string_child
+    t = @a["y", 1]
+    res = @a["y", :X].upcase_symbols_to_pattern_vars.match_tree(t)
+    assert_equal({:X => 1}, res)
+
+    t = @a[@b["y"], 1]
+    res = @a[@b["y"], :X].upcase_symbols_to_pattern_vars.match_tree(t)
+    assert_equal({:X => 1}, res)
+
+    res = @a[@b["y"], :X].all_matching_trees(t)
+    assert_equal(1, res.length)
+  end
+
+  def test_18_complex_tree_binop_bug
+    pattern = BinOpCall[:X, "-", :Y]
+    res = pattern.all_matching_trees(MR1Tree)
+    assert_equal(1, res.length)
+
+    res = BinOpCall[:X, "/", :Y].all_matching_trees(MR1Tree)
+    assert_equal(1, res.length)
+
+    res = BinOpCall[:X, "+", :Y].all_matching_trees(MR1Tree)
+    assert_equal(1, res.length)
+
+    res = BinOpCall[:X, "*", :Y].all_matching_trees(MR1Tree)
+    assert_equal(0, res.length)
+
+    res = Assign[LVar["y"], :X].all_matching_trees(MR1Tree)
+    assert_equal(4, res.length)
+  end
+
+  def test_19_should_traverse_into_arrays
+    # We need this since it is quite common that a collection of statements
+    # are simply given in an Array. It might be a design smell though!
+    tree = @a[[@b[1]]]
+    bs = tree.select_trees_of_class(@b)
+    assert_equal(1, bs.length)
+  end
+end

data/tests/unit/rockit/tree/utest_tree_enter_leave_visitor.rb

@@ -0,0 +1,69 @@
+require 'test/unit'
+
+require 'rockit/tree/enter_leave_visitor'
+
+class UTestTreeEnterLeaveVisitor < Test::Unit::TestCase
+  def setup
+    @a = Rockit::Tree::Base.new_tree_class(:A)
+    @b = Rockit::Tree::Base.new_tree_class(:B, [:c1])
+    @c = Rockit::Tree::Base.new_tree_class(:C, [:c1, :c2])
+    @d = Rockit::Tree::Base.new_tree_class(:D)
+    @e = Rockit::Tree::Base.new_tree_class(:E)
+  end
+
+  # Visits a node both on the way down in the tree and on the way up.
+  # Still a depth-first search.
+  class TreeELVisitor
+    include EnterLeaveVisitor
+
+    def initialize
+      @visited = []
+    end
+
+    def [](index); @visited[index]; end
+
+    def enter_A(obj); @visited << obj; end
+    def leave_A(obj); @visited << obj; end
+    def enter_B(obj); @visited << obj; end
+    def leave_B(obj); @visited << obj; end
+    def enter_C(obj); @visited << obj; end
+    def leave_C(obj); @visited << obj; end
+    def visit_E(obj); @visited << obj; end
+  end
+
+  class TreeAndFixnumELVisitor < TreeELVisitor
+    def enter_Fixnum(obj); @visited << obj; end
+  end
+
+  def test_01_visitor
+    tree = @c[tb1 = @b[ta = @a[@d[te = @e[]]]], tb2 = @b[t1 = 1]]
+    visitor = TreeELVisitor.new
+    tree.accept_visitor(visitor)
+
+    assert_equal(tree, visitor[0])
+    assert_equal(tb1, visitor[1])
+    assert_equal(ta, visitor[2])
+    # D is never visited sine we have no enter, visit or leave method for it.
+    # E is visited even though we only have a visit method but no enter or 
+    # leave methods.
+    assert_equal(te, visitor[3])
+    assert_equal(ta, visitor[4])
+    assert_equal(tb1, visitor[5])
+    assert_equal(tb2, visitor[6])
+    assert_equal(tb2, visitor[7])
+    assert_equal(tree, visitor[8])
+
+    visitor2 = TreeAndFixnumELVisitor.new
+    tree.accept_visitor(visitor2)
+    assert_equal(tree, visitor2[0])
+    assert_equal(tb1, visitor2[1])
+    assert_equal(ta, visitor2[2])
+    assert_equal(te, visitor[3])
+    assert_equal(ta, visitor2[4])
+    assert_equal(tb1, visitor2[5])
+    assert_equal(tb2, visitor2[6])
+    assert_equal(1, visitor2[7])
+    assert_equal(tb2, visitor2[8])
+    assert_equal(tree, visitor2[9])
+  end
+end

data/tests/unit/rockit/tree/utest_tree_visitor.rb

@@ -0,0 +1,63 @@
+require 'test/unit'
+
+require 'rockit/tree/visitor'
+
+class UTestTreeVisitor < Test::Unit::TestCase
+  def setup
+    @a = Rockit::Tree::Base.new_tree_class(:A)
+    @b = Rockit::Tree::Base.new_tree_class(:B, [:c1])
+    @c = Rockit::Tree::Base.new_tree_class(:C, [:c1, :c2])
+  end
+
+  class TreeVisitor
+    include Visitor
+
+    def initialize
+      @visited = []
+    end
+
+    def [](index); @visited[index]; end
+
+    def visit_A(obj)
+      @visited << obj
+    end
+
+    def visit_B(obj)
+      @visited << obj
+    end
+
+    def visit_C(obj)
+      @visited << obj
+    end
+  end
+
+  class TreeAndFixnumVisitor < TreeVisitor
+    def visit_Fixnum(obj)
+      @visited << obj
+    end
+  end
+
+  def test_01_visitor
+    tree = @c[tb1 = @b[ta = @a[]], tb2 = @b[t1 = 1]]
+    visitor = TreeVisitor.new
+    tree.accept_visitor(visitor)
+    # The visitor pattern by default does a depth-first visit of the nodes
+    # in the tree. Note that the 1 is not in the visited list since the visitor
+    # has no method to visit Fixnums.
+    assert_equal(tree, visitor[0])
+    assert_equal(tb1, visitor[1])
+    assert_equal(ta, visitor[2])
+    assert_equal(tb2, visitor[3])
+
+    # This visitor has a method to visit Fixnums so it should have the same
+    # obj's in the visited array as the previous one but then followed by
+    # the 1 that is the child of the tb2 tree above.
+    visitor2 = TreeAndFixnumVisitor.new
+    tree.accept_visitor(visitor2)
+    assert_equal(tree, visitor2[0])
+    assert_equal(tb1, visitor2[1])
+    assert_equal(ta, visitor2[2])
+    assert_equal(tb2, visitor2[3])
+    assert_equal(t1, visitor2[4])
+  end
+end