jinx 2.1.1

data/spec/mandatory_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+module Model
+  describe 'Mandatory' do
+    before(:all) do
+      Model.definitions BASE, MANDATORY
+    end
+
+    it "should recognize the mandatory property" do
+      Child.property(:flag).mandatory?.should be true
+    end
+
+    it "should fail to validate a missing mandatory property value" do
+      c = Child.new
+      expect { c.validate }.to raise_error(Jinx::ValidationError)
+    end
+
+    it "should validate an existing mandatory property value" do
+      c = Child.new(:name => 'Sam')
+      c.flag = true
+      expect { c.validate }.to_not raise_error
+    end
+
+    it "should validate a mandatory property set to false" do
+      c = Child.new(:name => 'Sam')
+      c.flag = false
+      expect { c.validate }.to_not raise_error
+    end
+
+    it "should not revalidate a property" do
+      c = Child.new(:name => 'Sam')
+      c.flag = true
+      expect { c.validate }.to_not raise_error
+      c.flag = nil
+      expect { c.validate }.to_not raise_error
+    end
+  
+    private
+
+    # The defaults fixture model definitions.
+    MANDATORY = File.dirname(__FILE__) + '/definitions/model/mandatory'
+  end
+end

data/spec/metadata_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+module Model
+  describe 'Metadata' do
+    before(:all) do
+      Model.definitions BASE, ALIAS
+    end
+
+    it "should import a resource class" do
+      Parent.should be < Jinx::Resource
+    end
+
+    it "should import a resource superclass in the same package" do
+      Child.superclass.should be < Jinx::Resource
+      Child.superclass.superclass.should_not be < Jinx::Resource
+    end
+  
+    it "should introspect the properties" do
+      expect { Child.property(:cardinal) }.to_not raise_error
+    end
+
+    it "should alias the reserved id attribute" do
+      Child.attributes.should include :identifier
+      Child.attributes.should_not include :id
+    end
+
+    it "should set the collection property flag" do
+      Parent.property(:children).collection?.should be true
+    end
+    
+    it "should set the collection property type" do
+      Independent.property(:others).type.should be Independent
+    end
+
+    it "should infer the collection property type" do
+      Parent.property(:children).type.should be Child
+    end
+    
+    it "should make an empty collection value" do
+      Parent.empty_value(:children).class.should < Java::JavaUtil::Collection
+    end
+
+    it "should recognize a domain property type" do
+      Parent.domain_type(:children).should be Child
+      Child.domain_type(:cardinal).should be nil
+    end
+
+    it "should recognize a property alias" do
+      Child.property(:pals).should be Child.property(:friends)
+    end
+    
+    it "should set the primary key" do
+      DomainObject.primary_key_attributes.should == [:identifier]
+    end
+    
+    it "should inherit the primary key" do
+      Child.primary_key_attributes.should be DomainObject.primary_key_attributes
+    end
+    
+    it "should set the secondary key" do
+      Child.secondary_key_attributes.should == [:name]
+    end
+  
+    private
+
+    ALIAS = File.dirname(__FILE__) + '/definitions/model/alias'
+  end
+end

data/spec/resource_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+module Model
+  describe 'Resource' do
+    before(:all) do
+      Model.definitions BASE
+    end
+
+    it "should have a resource attribute => value constructor" do
+      Child.new(:name => 'Test').name.should == 'Test'
+    end
+
+    it "should merge an attribute => value hash" do
+      c = Child.new(:name => 'Test')
+      p = Parent.new
+      c.merge({:name => 'Other', :cardinal => 1, :parent => p})
+      c.name.should == 'Test'
+      c.cardinal.should be 1
+      c.parent.should be p
+    end
+
+    it "should merge another resource" do
+      c = Child.new(:name => 'Test')
+      other = Child.new(:name => 'Other', :cardinal => 1)
+      c.merge(other)
+      c.name.should == 'Test'
+      c.cardinal.should be 1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require File.dirname(__FILE__) + '/../test/helper'
+
+Dir.glob(File.dirname(__FILE__) + '/support/**/*.rb').each { |f| require f }

data/spec/support/model.rb

@@ -0,0 +1,19 @@
+# Add the Java jar file to the Java path.
+require File.dirname(__FILE__) + '/../../examples/model/ext/bin/model.jar'
+
+# The Jinx Model example application domain module.
+module Model
+  include Jinx::Resource
+  
+  extend Jinx::Importer
+  
+  # The Java package name.
+  packages 'domain'
+  
+  # expose the definitions for testing
+  public_class_method :definitions
+
+  # The base fixture model definitions.
+  BASE = File.dirname(__FILE__) + '/../definitions/model/base'
+end
+

data/test/fixtures/line_separator/cr_line_sep.txt

@@ -0,0 +1 @@
+A

data/test/fixtures/line_separator/crlf_line_sep.txt

@@ -0,0 +1,3 @@
+A
+B
+C

data/test/fixtures/line_separator/lf_line_sep.txt

@@ -0,0 +1,3 @@
+A
+B
+C

data/test/fixtures/mixed/ext/build.xml

@@ -0,0 +1,35 @@
+<?xml version ="1.0"?>
+
+<project name="import Jinx test fixture" default="jar">
+
+  <!--build locations -->
+  <property name="base.dir" value="." />
+  <property name="source.dir" value="src" />
+  <property name="target.dir" value="classes" />
+  <property name="bin.dir" value="bin" />
+
+  <target name="init">
+    <tstamp />
+    <mkdir dir="${target.dir}" />
+    <mkdir dir="${bin.dir}" />
+  </target>
+
+  <!-- Compile all files in the source directory -->
+  <target name="compile" depends="init">
+    <javac destdir="${target.dir}" includes="**/*.*">
+      <src path="${source.dir}" />
+      <compilerarg value="-Xlint:unchecked"/>
+    </javac>
+  </target>
+
+  <target name="jar" depends="compile">
+    <jar destfile="${bin.dir}/mixed_case.jar" basedir="${target.dir}" includes="**/*.*" />
+  </target>
+
+  <!-- Remove build directories -->
+  <target name="clean">
+    <delete dir="${bin.dir}" />
+    <delete dir="${target.dir}" />
+  </target>
+
+</project>

data/test/fixtures/mixed/ext/src/mixed/Case/Example.java

@@ -0,0 +1,5 @@
+package mixed.Case;
+
+public class Example
+{
+}

data/test/helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler/setup'
+Bundler.require(:test, :development)
+require 'jinx/helpers/log'
+
+# Open the logger.
+Jinx::Log.instance.open(File.dirname(__FILE__) + '/results/log/jinx.log', :debug => true)

data/test/lib/jinx/command_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../../helper'
+require 'test/unit'
+require 'jinx/cli/command'
+require 'set'
+
+module Jinx
+  class CommandTest < Test::Unit::TestCase
+    def test_empty
+      verify_execution(CLI::Command.new, '', {})
+    end
+    
+    def test_arg
+      verify_execution(CLI::Command.new([[:arg, 'ARG']]), '4', {:arg => '4'})
+    end
+    
+    def test_option
+      verify_execution(CLI::Command.new([[:opt, '--opt N', 'option']]), '--opt 4', {:opt => '4'})
+    end
+    
+    def test_typed_option
+      verify_execution(CLI::Command.new([[:opt, '--opt N', Integer, 'option']]), '--opt 4', {:opt => 4})
+    end
+    
+    def test_both
+      verify_execution(CLI::Command.new([[:arg, 'ARG'], [:opt, '--opt N', 'option']]), '4 --opt 5', {:arg => '4', :opt => '5'})
+    end
+   
+    private
+    
+    def verify_execution(cmd, s, expected)
+      ARGV.clear.concat(s.split)
+      cmd.start do |actual|
+        actual.each do |opt, aval|
+          eval = expected[opt]
+          assert_not_nil(aval, "Command option #{opt} not found.")
+          assert_equal(eval, aval, "Command option #{opt} parsed incorrectly.")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require 'test/unit'
+require 'jinx/helpers/boolean'
+
+class BooleanTest < Test::Unit::TestCase
+  def test_marker
+    assert(Jinx::Boolean === true, "true is not a Jinx::Boolean")
+    assert(Jinx::Boolean === false, "false is not a Jinx::Boolean")
+    assert(!nil.is_a?(Jinx::Boolean), "nil is a Jinx::Boolean")
+  end
+  
+  def test_string
+    ['true', 'True', 't', 'T', 'yes', 'Yes', 'y', 'Y', '1'].each do |s|
+      assert_equal(true, Jinx::Boolean.for(s), "#{s} is not converted to true")
+    end
+    ['false', 'False', 'f', 'F', 'no', 'No', 'n', 'N', '0'].each do |s|
+      assert_equal(false, Jinx::Boolean.for(s), "#{s} is not converted to false")
+    end
+    assert_raises(ArgumentError, "Invalid boolean string was converted") { Jinx::Boolean.for('Maybe') }
+  end
+  
+  def test_integer
+    assert_equal(true, Jinx::Boolean.for(1), "#{self} is not converted to true")
+    assert_equal(false, Jinx::Boolean.for(0), "#{self} is not converted to false")
+    assert_raises(ArgumentError, "Invalid boolean integer was converted") { Jinx::Boolean.for(3) }
+  end
+end

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

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require 'test/unit'
+require 'jinx/helpers/class'
+
+class ClassTest < Test::Unit::TestCase
+  def ssn
+    '555-55-555'
+  end
+
+  def self.redefine_ssn
+    redefine_method(:ssn) { |old_method| lambda { send(old_method).delete('-').to_i } }
+  end
+
+  def test_redefine_method
+    self.class.redefine_ssn
+    assert_equal(55555555, ssn, "Method not redefined correctly")
+  end
+
+  def test_class_hierarchy
+    assert_equal([Array, Object], Array.class_hierarchy.to_a, "Class ancestors incorrect")
+  end
+
+  class Person
+    attr_reader :social_security_number
+    attr_accessor :postal_code
+    alias_attribute(:ssn, :social_security_number)
+    alias_attribute(:zip_code, :postal_code)
+  end
+
+  def test_attribute_alias
+    assert(Person.method_defined?(:ssn), "Reader alias not defined")
+    assert(!Person.method_defined?(:ssn=), "Writer alias incorrectly defined")
+    assert(Person.method_defined?(:zip_code), "Reader alias not defined")
+    assert(Person.method_defined?(:zip_code=), "Writer alias not defined")
+  end
+
+  class A; end
+  class B < A; end
+
+  def test_range
+    assert_equal([B, A, Object],  (B..Object).to_a, "Class range incorrect")
+  end
+
+  class OneBased
+    attr_accessor :index
+    offset_attr_accessor :zero_based_index => :index
+    offset_attr_accessor({:two_based_index => :index}, 1)
+  end
+
+  def test_offset_attr_accessor
+    x = OneBased.new
+    x.index = 1
+    assert_equal(0, x.zero_based_index, "Offset reader incorrect")
+    x.zero_based_index = 1
+    assert_equal(2, x.index, "Offset writer incorrect")
+    assert_equal(3, x.two_based_index, "Offset reader incorrect")
+    x.two_based_index = 1
+    assert_equal(0, x.index, "Offset writer incorrect")
+  end
+end

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

@@ -0,0 +1,402 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require 'test/unit'
+require 'jinx/helpers/collections'
+require 'jinx/helpers/lazy_hash'
+require 'jinx/helpers/case_insensitive_hash'
+require 'jinx/helpers/key_transformer_hash'
+require 'jinx/helpers/conditional_enumerator'
+require 'jinx/helpers/multi_enumerator'
+
+class CollectionsTest < Test::Unit::TestCase
+  def test_collection_classifier
+    assert([].collection?, "array is not a collecton")
+    assert(!nil.collection?, "nil is a collecton")
+    assert(!'a'.collection?, "String is a collecton")
+  end
+
+  def test_hashify
+    actual = [1, 2, 3].hashify { |key| key + 1 unless key == 2 }
+    expected = {1 => 2, 2 => nil, 3 => 4}
+    assert_equal(expected, actual, 'Hashify result incorrect')
+  end
+
+  def test_to_compact_hash
+    actual = [1, 2, 3].to_compact_hash { |key| key + 1 unless key == 2 }
+    expected = {1 => 2, 3 => 4}
+    assert_equal(expected, actual, 'Compact hash incorrect')
+  end
+  
+  def test_lazy_hash
+    hash = Jinx::LazyHash.new { |n| n * 2 }
+    assert_equal(2, hash[1], "Lazy hash value incorrect")
+    hash.merge!(2 => 3)
+    assert_equal({1 => 2, 2 => 3}, hash, "Lazy hash merge incorrect")
+  end
+
+  def test_array_operator_set_argument
+    array = [1, 2, 3]
+    set = [3, 4].to_set
+    assert_equal([3], array & set, "Array | Set result incorrect")
+    assert_equal([1, 2, 3, 4], array | set, "Array | Set result incorrect")
+    assert_equal([1, 2], array - set, "Array - Set result incorrect")
+  end
+
+  def test_empty_hash
+    assert_raises(NotImplementedError, "Assigment to empty hash succeeds") { Hash::EMPTY_HASH[:a] = 2 }
+  end
+
+  def test_set_first
+    assert_equal(1, [1, 2].to_set.first, "first of set incorrect")
+    assert_nil(Set.new.first, "first of empty set incorrect")
+  end
+
+  def test_assoc_values_single
+    expected = {:a => [1, 3], :b => [2, nil], :c => [nil, 4]}
+    actual = {:a => 1, :b => 2}.assoc_values({:a => 3, :c => 4})
+    assert_equal(expected, actual, "Association hash incorrect")
+  end
+
+  def test_assoc_values_multiple
+    expected = {:a => [1, 3, 4], :b => [2, nil, 5]}
+    actual = {:a => 1, :b => 2}.assoc_values({:a => 3}, { :a => 4, :b => 5 })
+    assert_equal(expected, actual, "Multiple association hash incorrect")
+  end
+
+  def test_detect_value
+   assert_equal(4, [1, 2, 3].detect_value { |item| item * 2 if item > 1 }, "Detect value incorrect")
+   assert_nil([1, 2, 3].detect_value { |item| item * 2 if item > 3 }, "Value incorrectly detected")
+  end
+
+  def test_detect_with_value
+    assert_equal([2, 1], [1, 2].detect_with_value { |item| item / 2 if item % 2 == 0 }, "Detect with value incorrect")
+  end
+
+  def test_array_filter
+    base = [1, 2, 3]
+    filter = base.filter { |n| n != 2 }
+    assert_equal([1, 3], filter.to_a, 'Filter incorrect')
+    base << 4
+    assert_equal([1, 3, 4], filter.to_a, 'Filter does not reflect operand modification')
+    filter << 5
+    assert_equal([1, 2, 3, 4, 5], base.to_a, 'Filter does not modify the base')
+  end
+
+  def test_enum_join
+    assert_equal("1", [1].filter { true }.join, "Enumerable singleton join incorrect")
+    assert_equal("1,2", [1, 2].filter { true }.join(','), "Enumerable join incorrect")
+  end
+
+  def test_array_filter_without_block
+    assert_equal([1, 3], [1, nil, 3, false].filter.to_a, 'Filter incorrect')
+  end
+
+  def test_set_filter_include
+    assert([1, 2, 3].to_set.filter { |n| n > 1 }.include?(2), 'Set filter include? incorrect')
+    assert(false == [1, 2, 3].to_set.filter { |n| n > 1 }.include?(1), 'Set filter include? incorrect')
+  end
+
+  def test_union
+    base = [1, 2]
+    sum = base.union([4])
+    assert_equal([1, 2, 4], sum.to_a, 'Enumerator union incorrect')
+    assert(sum.include?(2), "Enumerator union missing first array element")
+    assert(sum.include?(4), "Enumerator union missing second array element")
+    base << 3
+    assert_equal([1, 2, 3, 4], sum.to_a, 'Enumerator union does not reflect operand modification')
+  end
+
+  def test_intersection
+    base = [1, 2, 3, 4]
+    other = [3]
+    intersection = base.intersect(other)
+    assert_equal([3], intersection.to_a, 'Enumerator intersection incorrect')
+    other << 4 << 5
+    assert_equal([3, 4], intersection.to_a, 'Enumerator intersection does not reflect operand modification')
+  end
+
+  def test_difference
+    base = [1, 2, 3]
+    diff = base.difference([3])
+    assert_equal([1, 2], diff.to_a, 'Enumerator subtraction incorrect')
+    base << 4
+    assert_equal([1, 2, 4], diff.to_a, 'Enumerator subtraction does not reflect operand modification')
+  end
+
+  def test_wrap
+    assert_equal([2, 4, 6], [1, 2, 3].wrap { |n| n * 2 }.to_a, 'Wrap incorrect')
+  end
+
+  def test_enum_addition
+    a = [1, 2].filter { true }
+    b = [3, 4].filter { true }
+    ab = a + b
+    assert_equal([1, 2, 3, 4], ab.to_a, "Composite array incorrect")
+    a << 3
+    assert_equal([1, 2, 3, 3, 4], ab.to_a, "Addition does not reflect change to first enumerable")
+    b << 5
+    assert_equal([1, 2, 3, 3, 4, 5], ab.to_a, "Addition does not reflect change to second enumerable")
+  end
+  
+  def test_partial_sort
+    sorted = [Array, Object, Numeric, Enumerable, Set].partial_sort
+    assert(sorted.index(Array) < sorted.index(Enumerable), "Partial sort order incorrect")
+    assert(sorted.index(Set) < sorted.index(Enumerable), "Partial sort order incorrect")
+  end
+
+  def test_hash_union
+    a = {:a => 1, :b => 2}
+    b = {:b => 3, :c => 4}
+    ab = a + b
+    assert_equal({:a => 1, :b => 2, :c => 4}, ab.keys.to_compact_hash { |k| ab[k] }, "Hash union incorrect")
+    assert_equal([1, 2, 4], ab.values.sort, "Hash union values incorrect")
+    a.delete(:b)
+    assert_equal({:a => 1, :b => 3, :c => 4}, ab.keys.to_compact_hash { |k| ab[k] }, "Hash union does not reflect underlying change")
+  end
+
+  def test_hash_compose
+    x = {:a => :c, :b => :d}
+    y = {:c => 1}
+    xy = x.compose(y)
+    assert_equal({:a => {:c => 1}}, xy.keys.to_compact_hash { |k| xy[k] }, "Composed hash incorrect")
+    y[:d] = 2
+    assert_equal({:a => {:c => 1}, :b => {:d => 2}}, xy.keys.to_compact_hash { |k| xy[k] }, "Composed hash does not reflect underlying change")
+  end
+
+  def test_hash_join
+    x = {:a => :c, :b => :d}
+    y = {:c => 1}
+    xy = x.join(y)
+    assert_equal({:a => 1}, xy.keys.to_compact_hash { |k| xy[k] }, "Joined hash incorrect")
+    y[:d] = 2
+    assert_equal({:a => 1, :b => 2}, xy.keys.to_compact_hash { |k| xy[k] }, "Joined hash does not reflect underlying change")
+  end
+  
+  def test_hash_diff
+    x = {:a => 1, :b => 2, :c => 3}
+    y = {:b => 2, :c => 4, :d => 5}
+    assert_equal({:a => [1,nil], :c => [3,4], :d => [nil,5]}, x.diff(y), "Hash diff incorrect")
+  end
+
+  def test_to_assoc_hash
+    actual = [[:a, 1], [:b, 2, 3], [:c], []].to_assoc_hash
+    expected = {:a => 1, :b => [2,3], :c => nil}
+    assert_equal(expected, actual, 'Association hash incorrect')
+  end
+
+  def test_hashable_equal
+    assert_equal({:a => 1}, {:a => 1}.filter, "Hash equal incorrect")
+  end
+
+  def test_hash_enum_keys
+    hash = { 1 => :a, 2 => :b }
+    ek = hash.enum_keys
+    assert_equal([1, 2], ek.sort, "Hash key enumerator incorrect")
+    hash[3] = :c
+    assert_equal([1, 2, 3], ek.sort, "Hash key enumerator does not reflect hash change")
+  end
+
+  def test_hash_enum_keys_with_value
+    assert_equal([:b, :c], {:a => 1, :b => 2, :c => 2}.enum_keys_with_value(2).to_a, "Hash filtered value keys incorrect")
+  end
+
+  def test_hash_enum_keys_with_value_block
+    assert_equal([:b, :c], {:a => 1, :b => 2, :c => 3}.enum_keys_with_value { |v| v > 1 }.to_a, "Hash filtered value block keys incorrect")
+  end
+
+  def test_hash_enum_values
+    hash = { :a => 1, :b => 2 }
+    ev = hash.enum_values
+    assert_equal([1, 2], ev.sort, "Hash value enumerator incorrect")
+    hash[:c] = 3
+    assert_equal([1, 2, 3], ev.sort, "Hash value enumerator does not reflect hash change")
+  end
+
+  def test_hash_flatten
+    assert_equal([:a, :b, :c, :d, :e, :f, :g], {:a => {:b => :c}, :d => :e, :f => [:g]}.flatten, "Hash flatten incorrect")
+  end
+
+  def test_hash_first
+    assert_equal([:a, 1], {:a => 1, :b => 2}.first, "Hash first incorrect")
+  end
+
+  def test_hash_filter
+    assert_equal({:a => 1, :c => 3}, {:a => 1, :b => 2, :c => 3}.filter { |k, v| k != :b }, "Hash filter incorrect")
+  end
+
+  def test_hash_sort
+    assert_equal([['a', 1], ['b', 2]], {'a'=>1, 'b'=>2}.sort.to_a, "Hash sort incorrect")
+  end
+  
+  def test_hash_sort_with_comparator
+    assert_equal([[:a, 1], [:b, 2]], {:a => 1, :b => 2}.sort { |k1, k2| k1.to_s <=> k2.to_s }, "Hash sort with comparator incorrect")
+  end
+
+  def test_hash_default_filter
+    assert_equal({:a => 1, :c => 3}, {:a => 1, :b => nil, :c => 3}.filter, "Hash default filter incorrect")
+  end
+
+  def test_hash_partition
+    assert_equal([{:a => 1, :c => 3}, {:b => 2}], {:a => 1, :b => 2, :c => 3}.split { |k, v| k == :a or v == 3 }, "Hash partition incorrect")
+  end
+
+  def test_hash_filter_on_key
+    filtered = {:a => 1, :b => 2, :c => 3}.filter_on_key { |k| k != :b }
+    assert_equal({:a => 1, :c => 3}, filtered.to_hash, "Hash on key filter incorrect")
+    assert_equal(1, filtered[:a], "Access on key filter inclusion incorrect")
+    assert_nil(filtered[:b], "Access on key filter exclusion incorrect")
+  end
+
+  def test_hash_filter_on_value
+    filtered = {:a => 1, :b => 2, :c => 3}.filter_on_value { |v| v != 2 }
+    assert_equal({:a => 1, :c => 3}, filtered.to_hash, "Hash on value filter incorrect")
+  end
+  
+  def test_hash_compact
+    assert_equal({:a => 1, :c => 3}, {:a => 1, :b => nil, :c => 3}.compact.to_hash, "Compact hash incorrect")
+  end
+
+  def test_set_flatten
+    inner = Set.new << :a
+    actual = [inner, 'b'].flatten
+    expected = [:a, 'b']
+    assert_equal(expected, actual, 'Inner set not flattened')
+  end
+
+  def test_to_compact_hash
+    assert_equal({1 => 2, 2 => 3}, [1, 2].to_compact_hash { |item| item + 1 }, 'to_compact_hash result incorrect')
+  end
+
+  def test_to_compact_hash_with_index
+    assert_equal({:a => 1, :b => 2}, [:a, :b].to_compact_hash_with_index { |item, index| index + 1 }, 'to_compact_hash_with_index result incorrect')
+  end
+
+  def test_to_compact_hash_reject_missing
+    assert_equal({1 => 2, 2 => 3}, [1, 2, 3].to_compact_hash { |item| item + 1 unless item > 2 }, 'to_compact_hash maps a key with a nil value')
+  end
+
+  def test_series
+    actual = [1, 2, 3].to_series
+    assert_equal('1, 2 and 3', actual, 'Print string incorrect')
+  end
+
+  def test_empty_series
+    actual = [].to_series
+    assert_equal('', actual, 'Print string incorrect')
+  end
+
+  def test_singleton_series
+    actual = [1].to_series
+    assert_equal('1', actual, 'Print string incorrect')
+  end
+
+  def test_copy_recursive
+    hash = {1 => { 2 => 3 }, 4 => 5 }
+    copy = hash.copy_recursive
+    assert_equal(hash, copy, 'Copy not equal')
+    hash[1][2] = 6
+    assert_equal(3, copy[1][2], 'Copy reflects change to original')
+    hash[4] = 7
+    assert_equal(5, copy[4], 'Copy reflects change to original')
+  end
+
+  def test_case_insensitive_hash
+    hash = Jinx::CaseInsensitiveHash.new
+    hash[:UP] = :down
+    assert_equal(:down, hash['up'], "Case-insensitive hash look-up incorrect")
+  end
+
+  def test_key_transformer_hash
+    hash = Jinx::KeyTransformerHash.new { |k| k % 2 }
+    hash[1] = :a
+    assert_equal(:a, hash[1], 'Key transformer hash entered value not found')
+    assert_nil(hash[2], 'Transformed hash unentered value found')
+    assert_equal(:a, hash[3], 'Key transformer hash equivalent value not found')
+  end
+
+  def test_transformed_hash
+    hash = {:a => 1, :b => 2}
+    xfm = hash.transform_value { |v| v * 2 }
+    assert_equal(2, xfm[:a], 'Transformed hash accessor incorrect')
+    assert_equal([2, 4], xfm.values.sort, 'Transformed hash values incorrect')
+    assert(xfm.has_value?(4), 'Transformed hash value query incorrect')
+    assert(!xfm.has_value?(1), 'Transformed hash value query incorrect')
+    # base hash should be reflected in transformed hash
+    hash[:b] = 3; hash[:c] = 4
+    assert_equal(6, xfm[:b], 'Transformed hash does not reflect base hash change')
+    assert_equal(8, xfm[:c], 'Transformed hash does not reflect base hash change')
+  end
+
+  def test_hashinator
+    base = {:a => 1, :b => 2}.to_a
+    hash = Jinx::Hashinator.new(base)
+    assert_equal(base.to_set, hash.to_set, "Hashinator enumeration invalid")
+    assert_equal(1, hash[:a], "Hashinator a value invalid")
+    assert_equal(2, hash[:b], "Hashinator b value invalid")
+    assert_nil(hash[:c], "Hashinator has association not in the base")
+    base.first[1] = 3
+    assert_equal(3, hash[:a], "Hashinator does not reflect change to underlying Enumerator")
+    assert_equal(base, hash.to_hash.to_a, "Hashable to_hash incorrect")
+  end
+
+  def test_collector
+    assert_equal([2, [3, 4]], Jinx::Collector.on([1, [2, 3]]) { |n| n + 1 }, "Collector on nested array incorrect")
+    assert_nil(Jinx::Collector.on(nil) { |n| n + 1 }, "Collector on nil incorrect")
+    assert_equal(2, Jinx::Collector.on(1) { |n| n + 1 }, "Collector on non-collection incorrect")
+  end
+
+  def test_enumerate
+    counter = 0
+    nil.enumerate { |item| counter += item }
+    assert_equal(0, counter, "Enumerate on nil incorrect")
+    [1, 2, 3].enumerate { |item| counter += item }
+    assert_equal(6, counter, "Enumerate on array incorrect")
+    [1, [2, 3]].enumerate { |item| counter += 1 }
+    assert_equal(8, counter, "Enumerate on nested array incorrect")
+    2.enumerate { |item| counter += item }
+    assert_equal(10, counter, "Enumerate on non-collection incorrect")
+  end
+
+  def test_to_enum
+    assert_equal([], nil.to_enum.to_a, "to_enum on nil incorrect")
+    assert_equal([1], 1.to_enum.to_a, "to_enum on non-collection incorrect")
+    array = [1, 2]
+    assert_same(array, array.to_enum, "to_enum on array incorrect")
+    s = 'a'
+    assert_same(s, s.to_enum, "to_enum on String incorrect")
+  end
+
+  def test_flattener
+    assert_equal([1, 2, 3], Jinx::Flattener.new([1, [2, 3]]).to_a, "Flattener on nested array incorrect")
+    assert_equal([], Jinx::Flattener.new(nil).to_a, "Flattener on nil incorrect")
+    assert_equal([1], Jinx::Flattener.new(1).to_a, "Flattener on non-collection incorrect")
+    assert(Jinx::Flattener.new(nil).all?, "Flattener all? on nil incorrect")
+    assert_equal([:b, :c, :e], {:a => {:b => :c}, :d => [:e]}.enum_values.flatten.to_a, "Enumerable flatten incorrect")
+  end
+
+  def test_hash_flattener
+    assert_equal([:a, :b, :c], {:a => {:b => :c}}.flatten.to_a, "Hash flatten incorrect")
+    assert_equal([:b, :c, :e], {:a => {:b => :c}, :d => [:e]}.enum_values.flatten.to_a, "Enumerable flatten incorrect")
+  end
+
+
+  def test_conditional_enumerator
+    assert_equal([1, 2], Jinx::ConditionalEnumerator.new([1, 2, 3]) { |i| i < 3 }.to_a, "ConditionalEnumerator filter not applied")
+  end
+
+  def test_enumerable_size
+   assert_equal(2, {:a => 1, :b => 2}.enum_keys.size, "Enumerable size incorrect")
+  end
+
+  def test_set_merge
+    set = [1, 2].to_set
+    merged = set.merge!([3])
+    assert_equal([1, 2, 3].to_set, merged, "Merged set incorrect")
+    assert_same(set, merged, "Set merge! did not return same set")
+  end
+
+  def test_set_add_all
+    actual = [1, 2].add_all([3])
+    expected = [1, 2, 3]
+    assert_equal(expected, actual, 'Set content not added')
+  end
+end