caruby-core 1.5.5 → 2.1.1

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

@@ -1,55 +0,0 @@
-$:.unshift 'lib'
-
-require "test/unit"
-
-require 'caruby/cli/command'
-require 'set'
-
-module CaRuby
-  class CommandTest < Test::Unit::TestCase
-    def test_empty
-      verify_execution(Command.new, "test", {})
-    end
-    
-    def test_args_only
-      verify_execution(Command.new(:arg), "test arg", :arg => 'arg')
-    end
-    
-    def test_nonmandatory_argument_option
-      verify_execution(Command.new(:opt => :none), "test --opt", :opt => true)
-    end
-    
-    def test_mandatory_argument_option
-      verify_execution(Command.new(:opt => :mandatory), "test --opt opt", {:opt => 'opt'})
-    end
-    
-    def test_integer_argument_option
-      verify_execution(Command.new(:opt => :integer), "test --opt 1", {:opt => 1})
-    end
-    
-    def test_array_argument_option
-      verify_execution(Command.new(:opt => :array), "test --opt a,b", {:opt => ['a', 'b']})
-    end
-    
-    def test_complex
-      verify_execution(Command.new(:arg1, :opt1 => :none, :opt2 => :optional, :opt3 => :mandatory),
-        "test --opt1 --opt3 opt3 arg1 arg2",
-        {:opt1 => true, :opt3 => 'opt3', :arg1 => 'arg1'},
-        'arg2')
-    end
-    
-    private
-    
-    def verify_execution(cmd, s, opts, *args)
-      ARGV.clear.concat(s.split[1..-1])
-      cmd.start do |copts, *cargs|
-        opts.each do |opt, expected|
-          actual = copts[opt]
-          assert_not_nil(actual, "Command option #{opt} not found.")
-          assert_equal(expected, actual, "Command option #{opt} parsed incorrectly.")
-        end
-        assert_equal(cargs, args, "Command arguments differ.")
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-$:.unshift 'lib'
-
-require "test/unit"
-
-require 'caruby/util/domain_extent'
-
-class DomainExtentTest < Test::Unit::TestCase
-  # Test composite key class
-  class Composite
-    attr_reader :a, :b, :c
-
-    def initialize(a, b, c=3)
-      super()
-      @a = a; @b = b; @c = c
-    end
-
-    def ==(other)
-      a == other.a && b == other.b && c == other.c
-    end
-  end
-
-  attr_reader :extent
-
-  def setup
-    @extent = DomainExtent.new
-  end
-
-  def test_create_on_demand
-    assert(!extent.has_key?(String), 'New domain extent not empty')
-    assert_not_nil(extent[String], 'Entry not created on demand')
-  end
-
-  def test_existing_fetch
-    expected = extent[String][1] = 'a'
-    target = extent.get(String, 1)
-    assert_equal(expected, target, 'Existing entry not found')
-  end
-
-  def test_missing_fetch
-    assert_nil(DomainExtent.new.get(Symbol, :a), 'Default factory instance not nil')
-  end
-
-  def test_simple_key_factory
-    extent = DomainExtent.new
-    # the String extent key is a number
-    # the String extent value is the number as a string
-    extent.set_factory(String) { |key| key.to_s }
-    assert_equal('1', extent.get(String, 1), 'Simple key instance not found')
-  end
-
-  def test_composite_key_factory
-    extent = DomainExtent.new
-    # the String extent key is a number
-    # the String extent value is the number as a string
-    extent.set_factory(Composite) { |key| Composite.new(key[:a], key[:b], key[:c]) }
-    key = {:a => 1, :b => 2, :c => 3}
-    expected = Composite.new(1, 2, 3)
-    assert_equal(expected, extent.get(Composite, key), 'Composite key instance not found')
-  end
-end

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

@@ -1,30 +0,0 @@
-$:.unshift 'lib'
-
-require "test/unit"
-require 'caruby/util/file_separator'
-
-class FileSeparatorTest < Test::Unit::TestCase
-  FIXTURES_DIR = 'test/fixtures/caruby/util'
-  LF_FILE = File.join(FIXTURES_DIR, 'lf_line_sep.txt')
-  CR_FILE = File.join(FIXTURES_DIR, 'cr_line_sep.txt')
-  CRLF_FILE = File.join(FIXTURES_DIR, '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/caruby/util/inflector_test.rb

@@ -1,12 +0,0 @@
-$:.unshift 'lib'
-
-require "test/unit"
-require 'caruby/util/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/caruby/util/lazy_hash_test.rb

@@ -1,34 +0,0 @@
-$:.unshift 'lib'
-
-require "test/unit"
-
-require 'caruby/util/domain_extent'
-
-class LazyHastTest < Test::Unit::TestCase
-
-  def test_value_factory
-    hash = LazyHash.new { |key| key.to_s }
-    assert_equal('1', hash[1], "Factory return value is incorrect")
-  end
-
-  def test_default_value_factory
-    hash = 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 = 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 = 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") { LazyHash.new.fetch(:a) }
-  end
-end

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

@@ -1,83 +0,0 @@
-$:.unshift 'lib'
-
-require "test/unit"
-require 'caruby/util/merge'
-require 'caruby/util/log'
-
-class MergeTest < Test::Unit::TestCase
-  LogCaRuby::Log.instance.open(File.join('test', 'results', 'log', 'caruby.log'), :debug => true)
-
-  class Target
-    include Mergeable
-
-    attr_accessor :a, :b, :c, :array
-
-    def self.mergeable_attributes
-      [:a, :b]
-    end
-  end
-
-  class Partial
-    attr_accessor :a, :c, :d
-  end
-
-  attr_reader :target
-
-  def setup
-    @target = Target.new
-  end
-
-  def test_merge_attributes_hash
-    target.merge_attributes(:a => 1, :b => 2, :c => 3)
-    assert_equal(1, target.a, 'Attribute not merged')
-    assert_equal(2, target.b, 'Attribute not merged')
-    assert_equal(3, target.c, 'Attribute not merged')
-  end
-
-  def test_merge_attributes_other
-    other = Target.new
-    other.a = 1
-    other.b = 2
-    other.c = 3
-    target.merge_attributes(other)
-    assert_equal(1, target.a, 'Attribute not merged')
-    assert_equal(2, target.b, 'Attribute not merged')
-    assert_nil(target.c, 'Non-mergeable attribute merged')
-  end
-
-  def test_merge_attributes_other_partial
-    other = Partial.new
-    other.a = 1
-    other.c = 3
-    other.d = 4
-    target.merge_attributes(other)
-    assert_equal(1, target.a, 'Attribute not merged')
-    assert_nil(target.c, 'Non-mergeable attribute merged')
-  end
-
-  def test_array_merge
-    array = [1]
-    array.merge([1, 2])
-    assert_equal([1, 2], array, 'Array deep merge incorrect')
-  end
-
-  def test_array_attribute_merge
-    target.a = [1]
-    target.merge_attributes(:array => [1, 2])
-    assert_equal([1, 2], target.array, 'Array attribute not merged correctly')
-  end
-
-  def test_hash_deep_merge
-    assert_equal({:a => [1], :b => [2, 3]}, {:a => [1], :b => [2]}.merge({:b => [3]}, :deep), 'Hash deep merge incorrect')
-  end
-
-  def test_hash_in_place_deep_merge
-    hash = {:a => [1], :b => [2]}
-    hash.merge!({:b => [3], :c => 4}, :deep)
-    assert_equal({:a => [1], :b => [2, 3], :c => 4}, hash, 'Hash deep merge incorrect')
-  end
-
-  def test_nested_hash_deep_merge
-    assert_equal({:a => {:b => [1, 2]}, :c => 3}, {:a => {:b => [1]}}.merge({:a => {:b => [2]}, :c => 3}, :deep), 'Hash deep merge incorrect')
-  end
-end

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

@@ -1,25 +0,0 @@
-$:.unshift 'lib'
-
-require "test/unit"
-require 'caruby/util/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/caruby/util/options_test.rb

@@ -1,59 +0,0 @@
-$:.unshift 'lib'
-
-require "test/unit"
-require 'caruby/util/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_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_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_lish_to_hash
-    assert_equal({:a => 1, :b => true, :c => [2, 3]}, Options.to_hash(:a, 1, :b, :c, 2, 3), "Option to_hash with list argument list incorrect")
-  end
-end

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

@@ -1,42 +0,0 @@
-$:.unshift 'lib'
-
-require "test/unit"
-require 'caruby/util/partial_order'
-
-class Queued
-  include 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/caruby/util/pretty_print_test.rb

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