caruby-core 1.5.5 → 2.1.1

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

@@ -1,50 +0,0 @@
-$:.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

@@ -1,18 +0,0 @@
-$:.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

@@ -1,69 +0,0 @@
-$:.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

@@ -1,67 +0,0 @@
-$:.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
-
-  # 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 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
-end

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

@@ -1,23 +0,0 @@
-$:.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

@@ -1,14 +0,0 @@
-$:.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/visitor_test.rb

@@ -1,278 +0,0 @@
-$:.unshift 'lib'
-
-# JRuby SyncEnumerator moved from generator to REXML in JRuby 1.5
-require 'rexml/document'
-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| REXML::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