jinx 2.1.1

data/test/lib/jinx/helpers/file_separator_test.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require 'test/unit'
+require 'jinx/helpers/file_separator'
+
+class FileSeparatorTest < Test::Unit::TestCase
+  FIXTURES = File.dirname(__FILE__) + '/../../../fixtures/line_separator'
+  LF_FILE = File.join(FIXTURES, 'lf_line_sep.txt')
+  CR_FILE = File.join(FIXTURES, 'cr_line_sep.txt')
+  CRLF_FILE = File.join(FIXTURES, 'crlf_line_sep.txt')
+
+  def test_lf_line_separator
+    verify_read(LF_FILE, "LF")
+  end
+
+  def test_cr_line_separator
+    verify_read(CR_FILE, "CR")
+  end
+
+  def test_crlf_line_separator
+    verify_read(CRLF_FILE, "CRLF")
+  end
+
+  def verify_read(file, type)
+    lines = File.open(file) { |io| io.readlines }
+    assert_equal(3, lines.size, "#{type} line separator not recognized in readlines")
+    lines = File.open(file) { |io| io.to_a }
+    assert_equal(3, lines.size, "#{type} line separator not recognized in to_a")
+  end
+end

data/test/lib/jinx/helpers/inflector_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require 'test/unit'
+require 'jinx/helpers/inflector'
+
+class InflectorTest < Test::Unit::TestCase
+   def test_quantified_s
+    assert_equal("1 person", "person".quantify(1))
+    assert_equal("2 people", "person".quantify(2))
+    assert_equal("0 people", "person".quantify(0))
+  end
+end

data/test/lib/jinx/helpers/lazy_hash_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require "test/unit"
+require 'jinx/helpers/lazy_hash'
+
+class LazyHastTest < Test::Unit::TestCase
+
+  def test_value_factory
+    hash = Jinx::LazyHash.new { |key| key.to_s }
+    assert_equal('1', hash[1], "Factory return value is incorrect")
+  end
+
+  def test_default_value_factory
+    hash = Jinx::LazyHash.new
+    assert_nil(hash[1], "Default factory does not return")
+    assert(hash.has_key?(1), "Default entry not created")
+  end
+
+  def test_nil_key
+    hash = Jinx::LazyHash.new
+    assert_nil(hash[nil], "nil key does not return")
+    assert(!hash.has_key?(nil), "Entry created for nil key")
+  end
+
+  def test_reject_missing_value
+    hash = Jinx::LazyHash.new(:compact => true)
+    assert(!hash.has_key?(1), "Default entry created for nil value")
+  end
+
+  def test_fetch
+    assert_raises(IndexError, "Fetch non-existent doesn't raise IndexError") { Jinx::LazyHash.new.fetch(:a) }
+  end
+end

data/test/lib/jinx/helpers/module_test.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require "test/unit"
+require 'jinx/helpers/module'
+
+module Outer
+  module Middle
+    class C; end
+  end
+end
+
+class ModuleTest < Test::Unit::TestCase
+  def test_module_with_name
+    assert_equal(Outer::Middle, Outer.module_with_name('Middle'), "Unqualified module incorrect")
+    assert_nil(Outer.module_with_name('Zed'), "Missing module incorrectly resolves to non-nil value")
+    assert_equal(Outer::Middle::C, Outer.module_with_name('Middle::C'), "Qualified module incorrect")
+    assert_equal(Outer, Kernel.module_with_name('Outer'), "Top-level module incorrect")
+  end
+  
+  def test_parent_module
+    assert_equal(Outer, Outer::Middle.parent_module, "Middle parent module incorrect")
+    assert_equal(Outer::Middle, Outer::Middle::C.parent_module, "Inner parent module incorrect")
+    assert_equal(Kernel, Outer.parent_module, "Outer parent module incorrect")
+  end
+end

data/test/lib/jinx/helpers/options_test.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require "test/unit"
+require 'jinx/helpers/options'
+
+class OptionsTest < Test::Unit::TestCase
+  def test_present
+    assert(Options.get(:key, {:key => true}), "Option true value not returned")
+    assert(!Options.get(:key, {:key => false}), "Option true value not returned")
+  end
+
+  def test_nil_value
+    assert_equal(:a, Options.get(:key, {:key => nil}, :a), "Options nil value not returned")
+  end
+
+  def test_false_with_true_default
+    assert_equal(false, Options.get(:key, {:key => false}, true), "Option false value with true default doesn't return false")
+  end
+
+  def test_missing
+    assert_nil(Options.get(:key, {}), "Missing option incorrectly found")
+  end
+
+  def test_default_value
+    assert_equal(:a, Options.get(:key, {}, :a), "Option default value not used")
+  end
+
+  def test_nil_with_false_default
+    assert_equal(false, Options.get(:key, nil, false), "Option default value not used")
+  end
+
+  def test_default_block
+    assert_equal(:b, Options.get(:key, {}) { :b }, "Option default block not called")
+  end
+
+  def test_symbol
+    assert(Options.get(:key, :key), "Option not found in singleton options")
+  end
+
+  def test_array
+    assert(Options.get(:b, [:a, :b]), "Option not found in array options")
+  end
+
+  def test_array_with_hash
+    assert_equal(:c, Options.get(:b, [:a, {:b => :c}]), "Option not found in array options")
+  end
+
+  def test_collection_value
+    assert_equal([:a], Options.get(:key, {:key => [:a]}, []), "Option array value not returned")
+  end
+  
+  def test_empty_to_hash
+    assert_equal({}, Options.to_hash(), "Option to_hash with empty argument list not an empty hash")
+  end
+  
+  def test_nil_to_hash
+    assert_equal({}, Options.to_hash(nil), "Option to_hash with nil argument list not an empty hash")
+  end
+  
+  def test_hash_to_hash
+    assert_equal({:a => 1}, Options.to_hash({:a => 1}), "Option to_hash with hash argument list not an empty hash")
+  end
+  
+  def test_list_to_hash
+    assert_equal({:a => 1, :b => true, :c => 2}, Options.to_hash({:a => 1}, :b, :c => 2), "Option to_hash with list argument list incorrect")
+  end
+end

data/test/lib/jinx/helpers/partial_order_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require "test/unit"
+require 'jinx/helpers/partial_order'
+
+class Queued
+  include Jinx::PartialOrder
+
+  attr_reader :queue
+
+  def initialize(on)
+    @queue = on.push(self)
+  end
+
+  def <=>(other)
+    queue.index(self) <=> other.queue.index(other) if queue.equal?(other.queue)
+  end
+end
+
+class PartialOrderTest < Test::Unit::TestCase
+  def test_same_queue
+    q = []
+    a = Queued.new(q)
+    assert_equal(a, a, "Same value, queue not equal")
+  end
+
+  def test_different_eql_queue
+    a = Queued.new([])
+    @b = Queued.new([])
+    assert_nil(a <=> @b, "Same value, different queue <=> not nil")
+    assert_not_equal(a, @b, "Same value, different queue is equal")
+  end
+
+  def test_less_than
+    q = []
+    a = Queued.new(q)
+    b = Queued.new(q)
+    c = Queued.new([])
+    assert(a < b, "Comparison incorrect")
+    assert_nil(a < c, "Comparison incorrect")
+  end
+end

data/test/lib/jinx/helpers/pretty_print_test.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require "test/unit"
+require 'set'
+require 'date'
+require 'jinx/helpers/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/jinx/helpers/stopwatch_test.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require "test/unit"
+require 'jinx/helpers/stopwatch'
+
+class StopwatchTest < Test::Unit::TestCase
+  def setup
+    @timer = Jinx::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/jinx/helpers/transitive_closure_test.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require "test/unit"
+require 'jinx/helpers/collections'
+
+require 'jinx/helpers/transitive_closure'
+
+class TransitiveClosureTest < Test::Unit::TestCase
+ # Verifies closure iteration for the following hierarchy:
+  #  root -> a, e
+  #  a -> b, c
+  #  c -> d
+  # The expected iteration is +root+ preceding +a+ and +e+, +a+ preceding +b+ and +c+, +c+ preceding +d+.
+  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)
+    verify_closure([root, a, b, c, d, e], root.transitive_closure(:children))
+  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)
+    verify_closure([a, b, c, d], a.transitive_closure(:children))
+  end
+
+  def test_leaf
+    leaf = Node.new(1)
+    verify_closure([leaf], leaf.transitive_closure(:children))
+  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)
+    verify_closure([a, b, c, d, e], [a, b].transitive_closure(:children))
+  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
+    verify_closure([root, a, b, c], root.transitive_closure(:children))
+  end
+  
+  def test_class_hierarchy
+    result = [C, D].transitive_closure { |k| [k.superclass] }
+    assert_equal([D, C].to_set, result[0..1].to_set, "Class hierarchy closure incomparable leaf class order incorrect")
+    assert_equal([B, A, Object], result[2..-1], "Class hierarchy closure comparable non-leaf class order incorrect")
+  end
+  
+  def verify_closure(content, closure)
+    assert_equal(content.to_set, closure.to_set, "Hierarchy closure incorrect")
+    # Verify that no child succeeds the parent.
+    closure.each_with_index do |node, index|
+      par = node.parent
+      if content.include?(par) then
+        assert(closure.index(par) < index, "Child #{node} precedes parent #{par}")
+      end
+    end
+  end
+  
+  private
+  
+  class A; end
+  class B < A; end
+  class C < B; end
+  class D < A; end
+  
+  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
+end

data/test/lib/jinx/helpers/visitor_test.rb

@@ -0,0 +1,288 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require "test/unit"
+
+# JRuby SyncEnumerator moved from generator to REXML in JRuby 1.5.
+require 'rexml/document'
+require 'jinx/helpers/collections'
+
+require 'jinx/helpers/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
+    visitor = Jinx::Visitor.new { |node| node.children }
+    result = visitor.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
+    visitor = Jinx::Visitor.new { |node| node.children }
+    visitor.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
+    visitor = Jinx::Visitor.new(:depth_first) { |node| node.children }
+    visitor.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
+    visitor = Jinx::Visitor.new { |node| node.children }
+    visitor.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 = Jinx::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)
+    visitor = Jinx::Visitor.new { |node| node.children }
+    visitor.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
+    visitor = Jinx::Visitor.new { |pair| REXML::SyncEnumerator.new(pair.first.children, pair.last.children).to_a }
+    result = visitor.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)
+    visitor = Jinx::Visitor.new { |node| node.children }
+    result = visitor.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
+    visitor = Jinx::Visitor.new(:prune_cycle) { |node| node.children }
+    result = visitor.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 = Jinx::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 = Jinx::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 = Jinx::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 = Jinx::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 = Jinx::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 = Jinx::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
+    visitor = Jinx::Visitor.new { |node| node.children unless node == child }
+    visitor.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
+    Jinx::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 = Jinx::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 = Jinx::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 = Jinx::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 = Jinx::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