jactive_support 1.0.0-universal-java-1.6

data/spec/java_ext/map/initialize_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Hash#initialize" do
+=begin private
+  it "is private" do
+    hash_class.should have_private_instance_method("initialize")
+  end
+=end
+
+=begin default
+  it "can be used to reset default_proc" do
+    h = new_hash("foo" => 1, "bar" => 2)
+    h.default_proc.should == nil
+    h.instance_eval { initialize { |h, k| k * 2 } }
+    h.default_proc.should_not == nil
+    h["a"].should == "aa"
+  end
+=end
+
+  it "receives the arguments passed to Hash#new" do
+    NewHash.new(:one, :two)[0].should == :one
+    NewHash.new(:one, :two)[1].should == :two
+  end
+
+  it "returns self" do
+    h = hash_class.new
+    h.send(:initialize).should equal(h)
+  end
+
+=begin frozen
+  ruby_version_is ""..."1.9" do
+    it "raises a TypeError if called on a frozen instance" do
+      block = lambda { HashSpecs.frozen_hash.instance_eval { initialize() }}
+      block.should raise_error(TypeError)
+
+      block = lambda { HashSpecs.frozen_hash.instance_eval { initialize(nil) }  }
+      block.should raise_error(TypeError)
+
+      block = lambda { HashSpecs.frozen_hash.instance_eval { initialize(5) }    }
+      block.should raise_error(TypeError)
+
+      block = lambda { HashSpecs.frozen_hash.instance_eval { initialize { 5 } } }
+      block.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError if called on a frozen instance" do
+      block = lambda { HashSpecs.frozen_hash.instance_eval { initialize() }}
+      block.should raise_error(RuntimeError)
+
+      block = lambda { HashSpecs.frozen_hash.instance_eval { initialize(nil) }  }
+      block.should raise_error(RuntimeError)
+
+      block = lambda { HashSpecs.frozen_hash.instance_eval { initialize(5) }    }
+      block.should raise_error(RuntimeError)
+
+      block = lambda { HashSpecs.frozen_hash.instance_eval { initialize { 5 } } }
+      block.should raise_error(RuntimeError)
+    end
+  end
+=end
+end

data/spec/java_ext/map/inspect_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/to_s', __FILE__)
+
+describe "Hash#inspect" do
+=begin stack level to deep
+  it_behaves_like :to_s, :inspect
+=end
+end

data/spec/java_ext/map/invert_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Hash#invert" do
+  it "returns a new hash where keys are values and vice versa" do
+    new_hash(1 => 'a', 2 => 'b', 3 => 'c').invert.should ==
+      new_hash('a' => 1, 'b' => 2, 'c' => 3)
+  end
+
+  it "handles collisions by overriding with the key coming later in keys()" do
+    h = new_hash(:a => 1, :b => 1)
+    override_key = h.keys.last
+    h.invert[1].should == override_key
+  end
+
+  it "compares new keys with eql? semantics" do
+    h = new_hash(:a => 1.0, :b => 1)
+    i = h.invert
+    i[1.0].should == :a
+    i[1].should == :b
+  end
+
+  it "does not return subclass instances for subclasses" do
+    MyHash[1 => 2, 3 => 4].invert.class.should == ruby_hash_class
+    MyHash[].invert.class.should == ruby_hash_class
+  end
+end

data/spec/java_ext/map/keep_if_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/iteration', __FILE__)
+
+ruby_version_is "1.9" do
+  describe "Hash#keep_if" do
+    it "yields two arguments: key and value" do
+      all_args = []
+      new_hash(1 => 2, 3 => 4).keep_if { |*args| all_args << args }
+      all_args.should == [[1, 2], [3, 4]]
+    end
+
+    it "keeps every entry for which block is true and returns self" do
+      h = new_hash(:a => 1, :b => 2, :c => 3, :d => 4)
+      h.keep_if { |k,v| v % 2 == 0 }.should equal(h.to_hash)
+      h.should == new_hash(:b => 2, :d => 4)
+    end
+
+    it "returns self even if unmodified" do
+      h = new_hash(1 => 2, 3 => 4)
+      h.keep_if { true }.should equal(h.to_hash)
+    end
+
+=begin frozen
+    it "raises an RuntimeError if called on a frozen instance" do
+      lambda { HashSpecs.frozen_hash.keep_if { true } }.should raise_error(RuntimeError)
+      lambda { HashSpecs.empty_frozen_hash.keep_if { false } }.should raise_error(RuntimeError)
+    end
+=end
+
+    it_behaves_like(:hash_iteration_no_block, :keep_if)
+  end
+end

data/spec/java_ext/map/key_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/key', __FILE__)
+require File.expand_path('../shared/index', __FILE__)
+
+describe "Hash#key?" do
+  it_behaves_like(:hash_key_p, :key?)
+end
+
+ruby_version_is "1.8.8" do
+  describe "Hash#key" do
+    it_behaves_like(:hash_index, :key)
+  end
+end

data/spec/java_ext/map/keys_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Hash#keys" do
+
+  ruby_version_is ""..."1.9" do
+    it "returns an array populated with keys" do
+      new_hash.keys.should == []
+      new_hash.keys.should be_kind_of(Array)
+      new_hash(5).keys.should == []
+      new_hash { 5 }.keys.should == []
+      new_hash(1 => 2, 2 => 4, 4 => 8).keys.sort.should == [1, 2, 4]
+      new_hash(1 => 2, 2 => 4, 4 => 8).keys.should be_kind_of(Array)
+      new_hash(nil => nil).keys.should == [nil]
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "returns an array with the keys in the order they were inserted" do
+      new_hash.keys.should == []
+      new_hash.keys.should be_kind_of(Array)
+      new_hash(5).keys.should == []
+      new_hash { 5 }.keys.should == []
+      new_hash(1 => 2, 4 => 8, 2 => 4).keys.should == [1, 4, 2]
+      new_hash(1 => 2, 2 => 4, 4 => 8).keys.should be_kind_of(Array)
+      new_hash(nil => nil).keys.should == [nil]
+    end
+  end
+
+
+  it "it uses the same order as #values" do
+    h = new_hash(1 => "1", 2 => "2", 3 => "3", 4 => "4")
+
+    values = h.values.to_a
+    h.size.times do |i|
+      h[h.keys[i]].should == values[i]
+    end
+  end
+end

data/spec/java_ext/map/length_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/length', __FILE__)
+
+describe "Hash#length" do
+  it_behaves_like(:hash_length, :length)
+end

data/spec/java_ext/map/member_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/key', __FILE__)
+
+describe "Hash#member?" do
+  it_behaves_like(:hash_key_p, :member?)
+end

data/spec/java_ext/map/merge_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/iteration', __FILE__)
+require File.expand_path('../shared/update', __FILE__)
+
+describe "Hash#merge" do
+  it "returns a new hash by combining self with the contents of other" do
+    h = new_hash(1 => :a, 2 => :b, 3 => :c).merge(:a => 1, :c => 2)
+    h.should == new_hash(:c => 2, 1 => :a, 2 => :b, :a => 1, 3 => :c)
+  end
+
+  it "sets any duplicate key to the value of block if passed a block" do
+    h1 = new_hash(:a => 2, :b => 1, :d => 5)
+    h2 = new_hash(:a => -2, :b => 4, :c => -3)
+    r = h1.merge(h2) { |k,x,y| nil }
+    r.should == new_hash(:a => nil, :b => nil, :c => -3, :d => 5)
+
+    r = h1.merge(h2) { |k,x,y| "#{k}:#{x+2*y}" }
+    r.should == new_hash(:a => "a:-2", :b => "b:9", :c => -3, :d => 5)
+
+    lambda {
+      h1.merge(h2) { |k, x, y| raise(IndexError) }
+    }.should raise_error(IndexError)
+
+    r = h1.merge(h1) { |k,x,y| :x }
+    r.should == new_hash(:a => :x, :b => :x, :d => :x)
+  end
+
+  it "tries to convert the passed argument to a hash using #to_hash" do
+    obj = mock('{1=>2}')
+    obj.should_receive(:to_hash).and_return(new_hash(1 => 2).to_hash)
+    new_hash(3 => 4).merge(obj).should == new_hash(1 => 2, 3 => 4)
+  end
+
+  it "does not call to_hash on hash subclasses" do
+    new_hash(3 => 4).merge(ToHashHash[1 => 2]).should == new_hash(1 => 2, 3 => 4)
+  end
+
+=begin subclass
+  it "returns subclass instance for subclasses" do
+    MyHash[1 => 2, 3 => 4].merge(new_hash(1 => 2)).should be_kind_of(MyHash)
+    MyHash[].merge(new_hash(1 => 2)).should be_kind_of(MyHash)
+
+    new_hash(1 => 2, 3 => 4).merge(MyHash[1 => 2]).class.should == hash_class
+    new_hash.merge(MyHash[1 => 2]).class.should == hash_class
+  end
+=end
+
+  it "processes entries with same order as each()" do
+    h = new_hash(1 => 2, 3 => 4, 5 => 6, "x" => nil, nil => 5, [] => [])
+    merge_pairs = []
+    each_pairs = []
+    h.each_pair { |k, v| each_pairs << [k, v] }
+    h.merge(h) { |k, v1, v2| merge_pairs << [k, v1] }
+    merge_pairs.should == each_pairs
+  end
+
+end
+
+describe "Hash#merge!" do
+  it_behaves_like(:hash_update, :merge!)
+
+  it "does not raise an exception if changing the value of an existing key during iteration" do
+      hash = {1 => 2, 3 => 4, 5 => 6}
+      hash2 = {1 => :foo, 3 => :bar}
+      hash.each { hash.merge!(hash2) }
+      hash.should == {1 => :foo, 3 => :bar, 5 => 6}
+  end
+end

data/spec/java_ext/map/rassoc_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+ruby_version_is "1.9" do
+  describe "Hash#rassoc" do
+    before(:each) do
+      @h = {:apple => :green, :orange => :orange, :grape => :green, :banana => :yellow}
+    end
+
+    it "returns an Array if the argument is a value of the Hash" do
+      @h.rassoc(:green).should be_an_instance_of(Array)
+    end
+
+    it "returns a 2-element Array if the argument is a value of the Hash" do
+      @h.rassoc(:orange).size.should == 2
+    end
+
+    it "sets the first element of the Array to the key of the located value" do
+      @h.rassoc(:yellow).first.should == :banana
+    end
+
+    it "sets the last element of the Array to the located value" do
+      @h.rassoc(:yellow).last.should == :yellow
+    end
+
+    it "only returns the first matching key-value pair" do
+      @h.rassoc(:green).should == [:apple, :green]
+    end
+
+    it "uses #== to compare the argument to the values" do
+      @h[:key] = 1.0
+      1.should == 1.0
+      @h.rassoc(1).should == [:key, 1.0]
+    end
+
+    it "returns nil if the argument is not a value of the Hash" do
+      @h.rassoc(:banana).should be_nil
+    end
+  end
+end

data/spec/java_ext/map/reject_spec.rb

@@ -0,0 +1,123 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/iteration', __FILE__)
+
+describe "Hash#reject" do
+  it "is equivalent to hsh.dup.delete_if" do
+    h = new_hash(:a => 'a', :b => 'b', :c => 'd')
+    h.reject { |k,v| k == 'd' }.should == (h.dup.delete_if { |k, v| k == 'd' })
+
+    all_args_reject = []
+    all_args_delete_if = []
+    h = new_hash(1 => 2, 3 => 4)
+    h.reject { |*args| all_args_reject << args }
+    h.delete_if { |*args| all_args_delete_if << args }
+    all_args_reject.should == all_args_delete_if
+
+    h = new_hash(1 => 2)
+    # dup doesn't copy singleton methods
+    def h.to_a() end
+    h.reject { false }.to_a.should == [[1, 2]]
+  end
+
+=begin subclass
+  it "returns subclass instance for subclasses" do
+    MyHash[1 => 2, 3 => 4].reject { false }.should be_kind_of(MyHash)
+    MyHash[1 => 2, 3 => 4].reject { true }.should be_kind_of(MyHash)
+  end
+=end
+
+=begin taint
+  it "taints the resulting hash" do
+    h = new_hash(:a => 1).taint
+    h.reject {false}.tainted?.should == true
+  end
+=end
+
+  it "processes entries with the same order as reject!" do
+    h = new_hash(:a => 1, :b => 2, :c => 3, :d => 4)
+
+    reject_pairs = []
+    reject_bang_pairs = []
+    h.dup.reject { |*pair| reject_pairs << pair }
+    h.reject! { |*pair| reject_bang_pairs << pair }
+
+    reject_pairs.should == reject_bang_pairs
+  end
+
+  it_behaves_like(:hash_iteration_no_block, :reject)
+end
+
+describe "Hash#reject!" do
+  before(:each) do
+    @hsh = new_hash(1 => 2, 3 => 4, 5 => 6)
+    @empty = new_hash
+  end
+
+  it "is equivalent to delete_if if changes are made" do
+    new_hash(:a => 2).reject! { |k,v| v > 1 }.should ==
+      new_hash(:a => 2).delete_if { |k, v| v > 1 }
+
+    h = new_hash(1 => 2, 3 => 4)
+    all_args_reject = []
+    all_args_delete_if = []
+    h.dup.reject! { |*args| all_args_reject << args }
+    h.dup.delete_if { |*args| all_args_delete_if << args }
+    all_args_reject.should == all_args_delete_if
+  end
+
+  it "returns nil if no changes were made" do
+    new_hash(:a => 1).reject! { |k,v| v > 1 }.should == nil
+  end
+
+  it "processes entries with the same order as delete_if" do
+    h = new_hash(:a => 1, :b => 2, :c => 3, :d => 4)
+
+    reject_bang_pairs = []
+    delete_if_pairs = []
+    h.dup.reject! { |*pair| reject_bang_pairs << pair }
+    h.dup.delete_if { |*pair| delete_if_pairs << pair }
+
+    reject_bang_pairs.should == delete_if_pairs
+  end
+
+=begin frozen
+  ruby_version_is ""..."1.9" do
+    it "raises a TypeError if called on a frozen instance" do
+      lambda { HashSpecs.frozen_hash.reject! { false } }.should raise_error(TypeError)
+      lambda { HashSpecs.empty_frozen_hash.reject! { true } }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError if called on a frozen instance that is modified" do
+      lambda { HashSpecs.empty_frozen_hash.reject! { true } }.should raise_error(RuntimeError)
+    end
+
+    it "raises a RuntimeError if called on a frozen instance that would not be modified" do
+      lambda { HashSpecs.frozen_hash.reject! { false } }.should raise_error(RuntimeError)
+    end
+  end
+=end
+
+  ruby_version_is "" ... "1.8.7" do
+    it "raises a LocalJumpError when called on a non-empty hash without a block" do
+      lambda { @hsh.reject! }.should raise_error(LocalJumpError)
+    end
+
+    it "does not raise a LocalJumpError when called on an empty hash without a block" do
+      @empty.reject!.should == nil
+    end
+  end
+
+  ruby_version_is "1.8.7" do
+    it "returns an Enumerator when called on a non-empty hash without a block" do
+      @hsh.reject!.should be_an_instance_of(enumerator_class)
+    end
+
+    it "returns an Enumerator when called on an empty hash without a block" do
+      @empty.reject!.should be_an_instance_of(enumerator_class)
+    end
+  end
+
+end

data/spec/java_ext/map/replace_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/replace', __FILE__)
+
+describe "Hash#replace" do
+  it_behaves_like(:hash_replace, :replace)
+end

data/spec/java_ext/map/select_spec.rb

@@ -0,0 +1,98 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/iteration', __FILE__)
+
+describe "Hash#select" do
+  before(:each) do
+    @hsh = new_hash(1 => 2, 3 => 4, 5 => 6)
+    @empty = new_hash
+  end
+
+  it "yields two arguments: key and value" do
+    all_args = []
+    new_hash(1 => 2, 3 => 4).select { |*args| all_args << args }
+    all_args.sort.should == [[1, 2], [3, 4]]
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "returns an Array of entries for which block is true" do
+      a_pairs = new_hash('a' => 9, 'c' => 4, 'b' => 5, 'd' => 2).select { |k,v| v % 2 == 0 }
+      a_pairs.should be_an_instance_of(Array)
+      a_pairs.sort.should == [['c', 4], ['d', 2]]
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "returns a Hash of entries for which block is true" do
+      a_pairs = new_hash('a' => 9, 'c' => 4, 'b' => 5, 'd' => 2).select { |k,v| v % 2 == 0 }
+      a_pairs.should be_an_instance_of(Hash)
+      a_pairs.sort.should == [['c', 4], ['d', 2]]
+    end
+  end
+
+  it "processes entries with the same order as reject" do
+    h = new_hash(:a => 9, :c => 4, :b => 5, :d => 2)
+
+    select_pairs = []
+    reject_pairs = []
+    h.dup.select { |*pair| select_pairs << pair }
+    h.reject { |*pair| reject_pairs << pair }
+
+    select_pairs.should == reject_pairs
+  end
+
+  ruby_version_is "" ... "1.8.7" do
+    it "raises a LocalJumpError when called on a non-empty hash without a block" do
+      lambda { @hsh.select }.should raise_error(LocalJumpError)
+    end
+
+    it "does not raise a LocalJumpError when called on an empty hash without a block" do
+      @empty.select.should == []
+    end
+  end
+
+  ruby_version_is "1.8.7" do
+    it "returns an Enumerator when called on a non-empty hash without a block" do
+      @hsh.select.should be_an_instance_of(enumerator_class)
+    end
+
+    it "returns an Enumerator when called on an empty hash without a block" do
+      @empty.select.should be_an_instance_of(enumerator_class)
+    end
+  end
+
+end
+
+ruby_version_is "1.9" do
+  describe "Hash#select!" do
+    before(:each) do
+      @hsh = new_hash(1 => 2, 3 => 4, 5 => 6)
+      @empty = new_hash
+    end
+
+    it "is equivalent to keep_if if changes are made" do
+      new_hash(:a => 2).select! { |k,v| v <= 1 }.should ==
+        new_hash(:a => 2).keep_if { |k, v| v <= 1 }
+
+      h = new_hash(1 => 2, 3 => 4)
+      all_args_select = []
+      all_args_keep_if = []
+      h.dup.select! { |*args| all_args_select << args }
+      h.dup.keep_if { |*args| all_args_keep_if << args }
+      all_args_select.should == all_args_keep_if
+    end
+
+    it "returns nil if no changes were made" do
+      new_hash(:a => 1).select! { |k,v| v <= 1 }.should == nil
+    end
+=begin frozen
+    it "raises a RuntimeError if called on a frozen instance that is modified" do
+      lambda { HashSpecs.empty_frozen_hash.select! { false } }.should raise_error(RuntimeError)
+    end
+
+    it "raises a RuntimeError if called on a frozen instance that would not be modified" do
+      lambda { HashSpecs.frozen_hash.select! { true } }.should raise_error(RuntimeError)
+    end
+=end
+  end
+end

data/spec/java_ext/map/shared/each.rb

@@ -0,0 +1,77 @@
+shared_examples_for :hash_each do |method|
+  before { @method = method }
+
+=begin self
+  it "returns self" do
+    h = new_hash(:a => 1, :b => 2, :c => 3, :d => 5)
+    h.send(@method) { |k,v| }.should equal(h)
+  end
+=end
+
+  it "yields a [[key, value]] Array for each pair to a block expecting |*args|" do
+    all_args = []
+    new_hash(1 => 2, 3 => 4).send(@method) { |*args| all_args << args }
+    all_args.sort.should == [[[1, 2]], [[3, 4]]]
+  end
+
+  it "yields the key and value of each pair to a block expecting |key, value|" do
+    r = new_hash
+    h = new_hash(:a => 1, :b => 2, :c => 3, :d => 5)
+    h.send(@method) { |k,v| r[k.to_s] = v.to_s }
+    r.should == new_hash("a" => "1", "b" => "2", "c" => "3", "d" => "5")
+  end
+
+  it "yields the key only to a block expecting |key,|" do
+    ary = []
+    h = new_hash("a" => 1, "b" => 2, "c" => 3)
+    h.send(@method) { |k,| ary << k }
+    ary.sort.should == ["a", "b", "c"]
+  end
+
+  it "uses the same order as keys() and values()" do
+    h = new_hash(:a => 1, :b => 2, :c => 3, :d => 5)
+    keys = []
+    values = []
+
+    h.send(@method) do |k, v|
+      keys << k
+      values << v
+    end
+
+    keys.should == h.keys
+    values.should == h.values.to_a
+  end
+  
+  # Confirming the argument-splatting works from child class for both k, v and [k, v]
+  it "properly expands (or not) child class's 'each'-yielded args" do
+    cls1 = Class.new(Hash) do
+      attr_accessor :k_v
+      def each
+        super do |k, v|
+          @k_v = [k, v]
+          yield k, v
+        end
+      end
+    end
+    
+    cls2 = Class.new(Hash) do
+      attr_accessor :k_v
+      def each
+        super do |k, v|
+          @k_v = [k, v]
+          yield([k, v])
+        end
+      end
+    end
+    
+    obj1 = cls1.new
+    obj1['a'] = 'b'
+    obj1.map {|k, v| [k, v]}.should == [['a', 'b']]
+    obj1.k_v.should == ['a', 'b']
+    
+    obj2 = cls2.new
+    obj2['a'] = 'b'
+    obj2.map {|k, v| [k, v]}.should == [['a', 'b']]
+    obj2.k_v.should == ['a', 'b']
+  end
+end