caruby-core 1.4.4 → 1.4.5

data/test/lib/caruby/util/pretty_print_test.rb

@@ -0,0 +1,85 @@
+$:.unshift 'lib'
+
+require "test/unit"
+
+require 'set'
+require 'date'
+require 'caruby/util/pretty_print'
+
+class PrettyPrintTest < Test::Unit::TestCase
+  def test_nil
+    assert_equal('nil', nil.pp_s, 'Nil pretty print incorrect')
+  end
+
+  def test_date_time
+    date = DateTime.civil(2009, 4, 15, 5, 55, 55)
+    assert_equal(date.strftime, date.pp_s, 'Date pretty print incorrect')
+  end
+
+  def test_array
+    assert_equal('[:a, :b]', [:a, :b].pp_s, 'Array pretty print incorrect')
+  end
+
+  def test_java_collection
+    a = Java::JavaUtil::ArrayList.new
+    a << :a << :b
+    assert_equal(a.to_a.pp_s, a.pp_s, 'Java collection pretty print incorrect')
+  end
+
+  def test_java_collection_cycle
+    a = Java::JavaUtil::ArrayList.new
+    a << :a << a
+    assert_equal('[:a, [...]]', a.pp_s(:single_line), 'Cyclic set pretty print incorrect')
+  end
+
+  def test_hash
+    assert_equal('{:a => a, :b => b}', {:a => 'a', :b => 'b'}.pp_s(:single_line), 'Hash pretty print incorrect')
+  end
+
+  def test_qp
+    assert_equal('1', 1.qp, 'Numeric quick print incorrect')
+    assert_equal('nil', nil.qp, 'nil quick print incorrect')
+    assert_equal('a', 'a'.qp, 'String quick print incorrect')
+    assert_equal(':a', :a.qp, 'Symbol quick print incorrect')
+    assert_equal('[:a]', [:a].qp, 'Array quick print incorrect')
+    assert_equal('TestCase', Test::Unit::TestCase.qp, 'Class quick print incorrect')
+    
+    x = {:a => 'a', :b => 'b'}
+    x.qp
+    
+    
+    assert_equal('{:a => a, :b => b}', {:a => 'a', :b => 'b'}.qp, 'Hash quick print incorrect')
+  end
+
+  def test_set
+    assert_equal([:a].pp_s, [:a].to_set.pp_s, 'Set pretty print incorrect')
+  end
+
+  def test_set_cycle
+    a = [:a].to_set
+    a << a
+    assert_equal('[:a, [...]]', a.pp_s(:single_line), 'Cyclic set pretty print incorrect')
+  end
+
+  def test_single_line_argument
+    a = [].fill(:a, 0, 80)
+    assert(a.pp_s =~ /\n/, 'Test array not long enough')
+    assert(!a.pp_s(:single_line).include?("\n"), 'Single line option ignored')
+  end
+
+  def test_single_line_option
+    a = [].fill(:a, 0, 80)
+    assert_equal(a.pp_s(:single_line => true), a.pp_s(:single_line), 'Single line option ignored')
+  end
+
+  def test_print_wrapper_block
+    tuples = [[:a, :b], [:c]]
+    wrapper = PrintWrapper.new { |tuple| "<#{tuple.join(',')}>" }
+    wrappers = tuples.wrap{ |tuple| wrapper.wrap(tuple) }
+    assert_equal("[<a,b>, <c>]", wrappers.pp_s)
+  end
+
+  def test_wrapper_block
+    assert_equal("[<a,b>, <c>]", [[:a, :b], [:c]].pp_s { |tuple| "<#{tuple.join(',')}>" })
+  end
+end

data/test/lib/caruby/util/properties_test.rb

@@ -0,0 +1,50 @@
+$:.unshift('lib')
+
+require "test/unit"
+require 'caruby/util/properties'
+require 'caruby/util/log'
+
+class PropertiesTest < Test::Unit::TestCase
+  LOG_FILE = File.join('test', 'results', 'log', 'caruby.log')
+  FIXTURES_DIR = File.join('test', 'fixtures', 'caruby', 'util', 'properties')
+  INPUT_FILE = File.join(FIXTURES_DIR, 'properties.yaml')
+  MERGE_FILE = File.join(FIXTURES_DIR, 'merge_properties.yaml')
+  MERGE_PROPERTIES = ['short', 'nested']
+
+  def setup
+    CaRuby::Log.instance.open(LOG_FILE, :debug => true)
+    @properties = CaRuby::Properties.new(INPUT_FILE, :merge => MERGE_PROPERTIES)
+  end
+
+  def test_short_name
+    assert_equal('short', @properties['short'], 'Short property incorrect')
+  end
+
+  def test_dotted_name
+    assert_equal('dot', @properties['dot.property'], 'Dotted property incorrect')
+  end
+
+  def test_symbol
+    assert_equal('short', @properties[:short], 'Symbol key lookup incorrect')
+  end
+
+  def test_nested
+    assert_not_nil(@properties['nested'], 'Nested property not found')
+    assert_equal('A', @properties['nested']['a'], 'Nested property value incorrect')
+    assert_equal('B', @properties['nested']['b'], 'Nested property value incorrect')
+    assert_not_nil(@properties['nested']['deep'], 'Nested deep property not found')
+    assert_equal('U', @properties['nested']['deep']['u'], 'Nested deep property value incorrect')
+  end
+
+  def test_merge
+    @properties.load_properties_file(MERGE_FILE)
+    assert_equal('long', @properties['short'], 'Merge property value not overridden')
+    assert_equal('dash', @properties['dot.property'], 'Non-merge property value not overridden')
+    assert_not_nil(@properties['nested'], 'Nested property override incorrect')
+    assert_equal('X', @properties['nested']['a'], 'Nested property value not overridden')
+    assert_equal('B', @properties['nested']['b'], 'Nested property value not retained')
+    assert_equal('C', @properties['nested']['c'], 'Nested property value not added')
+    assert_equal('U', @properties['nested']['deep']['u'], 'Nested deep property value not retained')
+    assert_equal('V', @properties['nested']['deep']['v'], 'Nested deep property value not added')
+  end
+end

data/test/lib/caruby/util/stopwatch_test.rb

@@ -0,0 +1,18 @@
+$:.unshift 'lib'
+
+require 'caruby/util/stopwatch'
+require "test/unit"
+
+class StopwatchTest < Test::Unit::TestCase
+  
+  def setup
+    @timer = Stopwatch.new
+  end
+  
+  def test_run
+    t1 = @timer.run { 1000000.times { " " * 100 } }
+    t2 = @timer.run { 1000000.times { " " * 100 } }
+    assert_equal(t1.elapsed + t2.elapsed, @timer.elapsed, "Elapsed time incorrectly accumulated")
+    assert_equal(t1.cpu + t2.cpu, @timer.cpu, "CPU time incorrectly accumulated")
+  end
+end

data/test/lib/caruby/util/topological_sync_enumerator_test.rb

@@ -0,0 +1,69 @@
+$:.unshift 'lib'
+
+require "test/unit"
+require 'caruby/util/topological_sync_enumerator'
+
+class TopologicalSyncEnumeratorTest < Test::Unit::TestCase
+  class Node
+    attr_reader :value, :parent
+    
+    def initialize(value, parent=nil)
+      super()
+      @value = value
+      @parent = parent
+    end
+    
+    def to_s
+      value.to_s
+    end
+    
+    alias :inspect :to_s
+  end
+  
+  def test_simple
+    a = Node.new(:a)
+    b = Node.new(:b)
+    c = Node.new(:c, a)
+    d = Node.new(:d, b)
+    enum = TopologicalSyncEnumerator.new([a, c], [b, d], :parent)
+    assert_equal([[a, b], [c, d]], enum.to_a, "Enumeration incorrect")
+  end
+  
+  def test_many
+    a = Node.new(:a)
+    b = Node.new(:b)
+    c1 = Node.new(:c1, a)
+    c2 = Node.new(:c2, a)
+    d1 = Node.new(:d1, b)
+    d2 = Node.new(:d2, b)
+    enum = TopologicalSyncEnumerator.new([a, c1, c2], [b, d1, d2], :parent)
+    assert_equal([[a, b], [c1, d1], [c2, d2]], enum.to_a, "Enumeration incorrect")
+  end
+  
+  def test_matcher
+    a = Node.new(:a)
+    b = Node.new(:b)
+    c1 = Node.new(:c1, a)
+    c2 = Node.new(:c2, a)
+    d1 = Node.new(:d1, b)
+    d2 = Node.new(:d2, b)
+    enum = TopologicalSyncEnumerator.new([a, c1, c2], [b, d1, d2], :parent) { |t, srcs| srcs.last }
+    assert_equal([[a, b], [c1, d2], [c2, d1]], enum.to_a, "Enumeration incorrect")
+  end
+  
+  def test_excess_target
+    a = Node.new(:a)
+    b = Node.new(:b)
+    c = Node.new(:c, a)
+    enum = TopologicalSyncEnumerator.new([a, c], [b], :parent)
+    assert_equal([[a, b]], enum.to_a, "Enumeration incorrect")
+  end
+  
+  def test_excess_source
+    a = Node.new(:a)
+    b = Node.new(:b)
+    d = Node.new(:d, b)
+    enum = TopologicalSyncEnumerator.new([a], [b, d], :parent)
+    assert_equal([[a, b]], enum.to_a, "Enumeration incorrect")
+  end
+end

data/test/lib/caruby/util/transitive_closure_test.rb

@@ -0,0 +1,59 @@
+$:.unshift 'lib'
+
+require "test/unit"
+require 'caruby/util/collection'
+require 'caruby/util/transitive_closure'
+
+class TransitiveClosureTest < Test::Unit::TestCase
+  class Node
+    attr_reader :parent, :children, :value
+
+    def initialize(value, parent=nil)
+      super()
+      @value = value
+      @parent = parent
+      @children = []
+      parent.children << self if parent
+    end
+
+    def to_s
+      value.to_s
+    end
+
+    alias :inspect :to_s
+  end
+
+  def test_hierarchy
+    root= Node.new('root'); a = Node.new('a', root); b = Node.new('b', a); c = Node.new('c', a); d = Node.new('d', c); e = Node.new('e', root)
+    expected = [root, a, b, c, d, e].to_set
+    closure = root.transitive_closure(:children)
+    assert_equal(expected, closure.to_set, "Hierarchy closure incorrect")
+    closure.each_with_index { |node, index| closure[index..-1].each { |other| assert(!other.children.include?(node), "Order incorrect") } }
+    closure.reject { |node| node.parent.nil? }.each_with_index { |node, index| assert(closure[0..index].detect { |other| other.children.include?(node) }, "Order incorrect") }
+  end
+
+  def test_internal
+    root= Node.new('root'); a = Node.new('a', root); b = Node.new('b', a); c = Node.new('c', a); d = Node.new('d', c); e = Node.new('e', root)
+    expected = [a, b, c, d].to_set
+    closure = a.transitive_closure(:children)
+    assert_equal(expected, closure.to_set, "Hierarchy closure incorrect")
+  end
+
+  def test_leaf
+    leaf = Node.new(1)
+    assert_equal([leaf], leaf.transitive_closure(:children), "Leaf closure incorrect")
+  end
+
+  def test_collection
+    a = Node.new('a'); b = Node.new('b'); c = Node.new('c', a); d = Node.new('d', b); e = Node.new('e', c)
+    expected = [a, b, c, d, e].to_set
+    closure = [a, b].transitive_closure(:children)
+    assert_equal(expected, closure.to_set, "Hierarchy closure incorrect")
+  end
+
+  def test_cycle
+    root= Node.new('root'); a = Node.new('a', root); b = Node.new('b', a); c = Node.new('c', a); c.children << root
+    expected = [root, a, b, c].to_set
+    assert_equal(expected, a.transitive_closure(:children).to_set, "Cycle closure incorrect")
+  end
+end

data/test/lib/caruby/util/tree_test.rb

@@ -0,0 +1,23 @@
+$:.unshift 'lib'
+
+require "test/unit"
+require 'caruby/util/tree'
+
+class TreeTest < Test::Unit::TestCase
+  def test_tree
+    a = Tree.new(:a)
+    assert_equal(a.root, :a, "Tree root incorrect")
+    a << :b
+    b = a[:b]
+    assert_not_nil(b, "Subtree not found")
+    assert_equal(b, a.children.first, "Subtree child not found")
+    assert_equal(:b, b.root, "Subtree root incorrect")
+    assert_nil(a[:b, :c], "Subtree at non-existing path incorrect")
+    b << :c
+    assert_equal(b[:c], a[:b, :c], "Subtree at path incorrect")
+  end
+
+  def test_fill
+    assert_equal(Tree.new(:a).fill(:b, :c).root, :c, "Fill result incorrect")
+  end
+end

data/test/lib/caruby/util/trie_test.rb

@@ -0,0 +1,14 @@
+$:.unshift 'lib'
+
+require "test/unit"
+require 'caruby/util/trie'
+
+class TrieTest < Test::Unit::TestCase
+  def test_trie
+    trie = Trie.new
+    assert_nil(trie[:a], "Non-existing node value incorrect")
+    trie[:a, :b] = 1
+    assert_nil(trie[:a], "Existing unvalued node value incorrect")
+    assert_equal(1, trie[:a, :b], "Trie value incorrect")
+  end
+end

data/test/lib/caruby/util/validation_test.rb

@@ -0,0 +1,14 @@
+$:.unshift 'lib'
+
+require "test/unit"
+require 'caruby/util/validation'
+
+class ValidationTest < Test::Unit::TestCase
+  include Validation
+
+  def test_validate_type
+    assert_nothing_raised(TypeError, 'Valid argument declared invalid') { || validate_type(1 => Integer) }
+    assert_raises(ArgumentError, 'Missing argument declared valid') { || validate_type(nil => Integer) }
+    assert_raises(TypeError, 'Miscast argument declared valid') { || validate_type('a'=>Integer) }
+  end
+end

data/test/lib/caruby/util/version_test.rb

@@ -0,0 +1,31 @@
+$:.unshift 'lib'
+
+require "test/unit"
+require 'caruby/util/version'
+
+class VersionTest < Test::Unit::TestCase
+  def test_major
+    assert_equal(0, "1".to_version <=> "1".to_version, "Version major comparison incorrect")
+    assert_equal(-1, "1".to_version <=> "2".to_version, "Version major comparison incorrect")
+    assert_equal(1, "2".to_version <=> "1".to_version, "Version major comparison incorrect")
+  end
+
+  def test_minor
+    assert_equal(0, "1.1".to_version <=> "1.1".to_version, "Version minor comparison incorrect")
+    assert_equal(-1, "1".to_version <=> "1.1".to_version, "Version minor comparison incorrect")
+    assert_equal(-1, "1.1".to_version <=> "1.2".to_version, "Version minor comparison incorrect")
+    assert_equal(1, "1.2".to_version <=> "1.1".to_version, "Version minor comparison incorrect")
+    assert_equal(1, "1.1".to_version <=> "1".to_version, "Version minor comparison incorrect")
+  end
+
+  def test_string_components
+    assert_equal(0, "1.1alpha".to_version <=> "1.1alpha".to_version, "Version string comparison incorrect")
+    assert_equal(1, "1.1alpha".to_version <=> "1.1".to_version, "Version string comparison incorrect")
+    assert_equal(-1, "1.1alpha".to_version <=> "1.2".to_version, "Version string comparison incorrect")
+  end
+
+  def test_predecessor
+    alpha = Version.new(1, '1alpha')
+    assert_equal(1, Version.new(1, 1, alpha) <=> alpha, "Version predecessor comparison incorrect")
+  end
+end

data/test/lib/caruby/util/visitor_test.rb

@@ -0,0 +1,277 @@
+$:.unshift 'lib'
+
+require 'generator'
+require "test/unit"
+require 'caruby/util/collection'
+require 'caruby/util/visitor'
+
+class Node
+  attr_reader :parent, :children, :friends
+
+  attr_accessor :value
+
+  def initialize(value, parent=nil)
+    @value = value
+    @children = []
+    @friends = []
+    @parent = parent
+    @parent.children << self if @parent
+  end
+
+  def <=>(other)
+    value <=> other.value if other
+  end
+
+  def to_s
+    "#{self.class.name}@#{hash}{value => #{value}}"
+  end
+
+  alias :inspect :to_s
+end
+
+class VistorTest < Test::Unit::TestCase
+  def test_visit
+    parent = Node.new(1)
+    child = Node.new(2, parent)
+    multiplier = 1
+    result = CaRuby::Visitor.new { |node| node.children }.visit(parent) { |node| node.value *= (multiplier *= 2) }
+    assert_equal(2, parent.value, "Visit parent value incorrect")
+    assert_equal(8, child.value, "Visit child value incorrect")
+    assert_equal(2, result, "Visit result incorrect")
+  end
+
+  def test_cycle
+    parent = Node.new(1)
+    child = Node.new(2, parent)
+    child.children << parent
+    multiplier = 2
+    CaRuby::Visitor.new { |node| node.children }.visit(parent) { |node| node.value *= multiplier }
+    assert_equal(2, parent.value, "Cycle parent value incorrect")
+    assert_equal(4, child.value, "Cycle child value incorrect")
+  end
+
+  def test_depth_first
+    parent = Node.new(1)
+    child = Node.new(2, parent)
+    multiplier = 1
+    CaRuby::Visitor.new(:depth_first) { |node| node.children }.visit(parent) { |node| node.value *= (multiplier *= 2) }
+    assert_equal(4, parent.value, "Depth-first parent value incorrect")
+    assert_equal(4, child.value, "Depth-first child value incorrect")
+  end
+
+  def test_return
+    parent = Node.new(1)
+    child = Node.new(2, parent)
+    result = increment(parent, 2)
+    assert_nil(result, "Pre-emptive return incorrect")
+    assert_equal(2, parent.value, "Pre-emptive return parent value incorrect")
+    assert_equal(2, child.value, "Pre-emptive return child value incorrect")
+  end
+
+  def test_visited_detection
+    parent = Node.new(1)
+    child = Node.new(2, parent)
+    c2 = Node.new(3, parent)
+    c2.children << child
+    result = CaRuby::Visitor.new { |node| node.children }.visit(parent) { |node| node.value += 1 }
+    assert_equal(3, child.value, "Child visited twice")
+  end
+
+  def test_root_cycle
+    parent = Node.new(1)
+    c1 = Node.new(2, parent)
+    c2 = Node.new(3, parent)
+    c2.children << parent
+    gc11 = Node.new(4, c1)
+    gc12 = Node.new(5, c1)
+    gc12.children << c1
+    gc121 = Node.new(6, gc12)
+    gc121.children << parent
+    visitor = CaRuby::Visitor.new { |node| node.children }
+    result = visitor.visit(parent)
+    assert_equal([[2, 5, 2], [1, 2, 5, 6, 1], [1, 3, 1]], visitor.cycles.map { |cycle| cycle.map { |node| node.value } }, "Root cycles incorrect")
+  end
+
+  def increment(parent, limit)
+    CaRuby::Visitor.new { |node| node.children }.visit(parent) { |node| node.value < limit ? node.value += 1 : return }
+  end
+
+  def test_collection
+    p1 = Node.new(1)
+    child = Node.new(2, p1)
+    p2 = Node.new(3)
+    p2.children << child
+    result = CaRuby::Visitor.new { |pair| SyncEnumerator.new(pair.first.children, pair.last.children).to_a }.to_enum([p1, p2]).map { |pair| [pair.first.value, pair.last.value] }
+    assert_equal([[1, 3], [2, 2]], result.to_a, "Collection visit result incorrect")
+  end
+
+  def node_value(node)
+    node.value if node
+  end
+
+  def test_enumeration
+    parent = Node.new(1)
+    c1 = Node.new(2, parent)
+    c2 = Node.new(3, parent)
+    result = CaRuby::Visitor.new { |node| node.children }.to_enum(parent).map { |node| node.value }
+    assert_equal([1, 2, 3], result, "Enumeration result incorrect")
+  end
+
+  def test_exclude_cycles
+    parent = Node.new(1)
+    c1 = Node.new(2, parent)
+    gc11 = Node.new(3, c1)
+    gc11.children << c1
+    c2 = Node.new(4, parent)
+    gc21 = Node.new(5, c2)
+    gc21.children << parent
+    result = CaRuby::Visitor.new(:prune_cycle) { |node| node.children }.to_enum(parent).map { |node| node.value }
+    assert_equal([1, 2, 3], result, "Exclude result incorrect")
+  end
+
+  def test_missing_block
+    parent = Node.new(1)
+    c1 = Node.new(2, parent)
+    c2 = Node.new(3, parent)
+    visitor = CaRuby::Visitor.new { |node| node.children }
+    visitor.visit(parent)
+    assert_equal([parent, c1, c2], visitor.visited.values.sort, "Missing visit operator result incorrect")
+  end
+
+  def test_filter
+    parent = Node.new(1)
+    c1 = Node.new(2, parent)
+    c2 = Node.new(3, parent)
+    gc1 = Node.new(4, c1)
+    gc2 = Node.new(5, c1)
+    visitor = CaRuby::Visitor.new { |node| node.children }.filter { |parent, children| children.first if parent.value < 4 }
+    result = visitor.to_enum(parent).map { |node| node.value }
+    assert_equal([1, 2, 4], result, "Filter result incorrect")
+  end
+
+  def test_sync_without_block
+    p1 = Node.new(1)
+    c11 = Node.new(2, p1)
+    c12 = Node.new(3, p1)
+    gc111 = Node.new(4, c11)
+    gc121 = Node.new(5, c12)
+    p2 = Node.new(6)
+    c21 = Node.new(7, p2)
+    c22 = Node.new(8, p2)
+    gc211 = Node.new(9, c21)
+    visitor = CaRuby::Visitor.new { |node| node.children }.sync
+    result = visitor.to_enum(p1, p2).map { |pair| pair.map { |node| node.value unless node.nil? } }
+    assert_equal([[1, 6], [2, 7], [4, 9], [3, 8], [5, nil]], result, "Sync without block result incorrect")
+  end
+
+  def test_sync_with_matcher
+    p1 = Node.new(1)
+    c11 = Node.new(2, p1)
+    c12 = Node.new(3, p1)
+    gc111 = Node.new(4, c11)
+    gc121 = Node.new(5, c12)
+    p2 = Node.new(1)
+    c21 = Node.new(2, p2)
+    c22 = Node.new(3, p2)
+    gc211 = Node.new(5, c21)
+    visitor = CaRuby::Visitor.new { |node| node.children }
+    synced = visitor.sync { |nodes, others| nodes.to_compact_hash { |n| others.detect { |o| n.value == o.value } } }
+    result = synced.to_enum(p1, p2).map { |pair| pair.map { |node| node.value if node } }
+    assert_equal([[1, 1], [2, 2], [4, nil], [3, 3], [5, nil]], result, "Sync with block result incorrect")
+  end
+
+  def test_sync_noncollection
+    p1 = Node.new(1)
+    child = Node.new(2, p1)
+    p2 = Node.new(3)
+    p2.children << child
+    visitor = CaRuby::Visitor.new { |node| node.children.first }.sync
+    value_hash = {}
+    result = visitor.visit(p1, p2) { |first, last| value_hash[node_value(first)] = node_value(last) }
+    assert_equal({1 => 3, 2 => 2}, value_hash, "Sync with non-collection children result incorrect")
+    result = visitor.to_enum(p1, p2).map { |first, last| [node_value(first), node_value(last)] }
+    assert_equal([[1, 3], [2, 2]], result.to_a, "Sync with non-collection children result incorrect")
+  end
+
+  def test_sync_missing
+    p1 = Node.new(1)
+    p2 = Node.new(2)
+    c1 = Node.new(3, p1)
+    c2 = Node.new(4, p2)
+    gcren = Node.new(5, c2)
+    visitor = CaRuby::Visitor.new { |node| node.children.first }.sync
+    result = visitor.to_enum(p1, p2).map { |pair| [node_value(pair.first), node_value(pair.last)] }
+    assert_equal([[1, 2], [3, 4]], result.to_a, "Sync with missing children result incorrect")
+  end
+
+  def test_missing_node
+    parent = Node.new(1)
+    child = Node.new(2, parent)
+    multiplier = 2
+    CaRuby::Visitor.new { |node| node.children unless node == child }.visit(parent) { |node| node.value *= multiplier }
+    assert_equal(2, parent.value, "Missing node parent value incorrect")
+    assert_equal(4, child.value, "Missing node child value incorrect")
+  end
+
+  def test_noncollection_traversal
+    parent = Node.new(1)
+    child = Node.new(2, parent)
+    multiplier = 2
+    CaRuby::Visitor.new { |node| node.parent }.visit(child) { |node| node.value *= multiplier }
+    assert_equal(2, parent.value, "Non-collection parent value incorrect")
+    assert_equal(4, child.value, "Non-collection child value incorrect")
+  end
+
+  def test_parent
+    parent = Node.new(1)
+    c1 = Node.new(2, parent)
+    c2 = Node.new(3, parent)
+    gc = Node.new(4, c1)
+    visitor = CaRuby::Visitor.new { |node| node.children }
+    visitor.visit(parent) { |node| node.value = visitor.parent.nil? ? 0 : visitor.parent.value + 1 }
+    assert_equal(0, parent.value, "Parent value incorrect")
+    assert_equal(1, c1.value, "Child value incorrect")
+    assert_equal(1, c2.value, "Child value incorrect")
+    assert_equal(2, gc.value, "gc value incorrect")
+  end
+
+  def test_parent_depth_first
+    # An interesting variant: the parent node value is not reset until after the children are visited
+    parent = Node.new(1)
+    c1 = Node.new(2, parent)
+    c2 = Node.new(3, parent)
+    gc = Node.new(4, c1)
+    visitor = CaRuby::Visitor.new(:depth_first) { |node| node.children }
+    visitor.visit(parent) { |node| node.value = visitor.parent.nil? ? 0 : visitor.parent.value + 1 }
+    assert_equal(0, parent.value, "Parent value incorrect")
+    assert_equal(2, c1.value, "Child value incorrect")
+    assert_equal(2, c2.value, "Child value incorrect")
+    assert_equal(3, gc.value, "gc value incorrect")
+  end
+
+  def test_visited
+    parent = Node.new(1)
+    c1 = Node.new(nil, parent)
+    c2 = Node.new(nil, parent)
+    gc = Node.new(nil, c1)
+    visitor = CaRuby::Visitor.new { |node| node.children }
+    visitor.visit(parent) { |node| node.value ||= visitor.visited[node.parent] + 1 }
+    assert_equal(1, parent.value, "Parent value incorrect")
+    assert_equal(2, c1.value, "Child value incorrect")
+    assert_equal(2, c2.value, "Child value incorrect")
+    assert_equal(3, gc.value, "gc value incorrect")
+  end
+
+  def test_visited_result
+    parent = Node.new(1)
+    c1 = Node.new(2, parent)
+    c2 = Node.new(3, parent)
+    gc = Node.new(4, c1)
+    visitor = CaRuby::Visitor.new { |node| node.children }
+    visitor.visit(parent) { |node| node.value + 1 }
+    assert_equal(2, visitor.visited[parent], "Parent visited value incorrect")
+    assert_equal(3, visitor.visited[c1], "Child visited value incorrect")
+    assert_equal(4, visitor.visited[c2], "Child visited value incorrect")
+    assert_equal(5, visitor.visited[gc], "gc visited value incorrect")
+  end
+end