jactive_support 1.0.2

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

@@ -0,0 +1,68 @@
+shared_examples_for :hash_store do |method|
+  before { @method = method }
+
+  it "associates the key with the value and return the value" do
+    h = new_hash(:a => 1)
+    h.send(@method, :b, 2).should == 2
+    h.should == new_hash(:b=>2, :a=>1)
+  end
+
+  it "duplicates string keys using dup semantics" do
+    # dup doesn't copy singleton methods
+    key = "foo"
+    def key.reverse() "bar" end
+    h = new_hash
+    h.send(@method, key, 0)
+    h.keys[0].reverse.should == "oof"
+  end
+
+  it "stores unequal keys that hash to the same value" do
+    h = new_hash
+    k1 = ["x"]
+    k2 = ["y"]
+    # So they end up in the same bucket
+    k1.should_receive(:hash).and_return(0)
+    k2.should_receive(:hash).and_return(0)
+
+    h[k1] = 1
+    h[k2] = 2
+    h.size.should == 2
+  end
+
+=begin frozen
+  it "duplicates and freezes string keys" do
+    key = "foo"
+    h = new_hash
+    h.send(@method, key, 0)
+    key << "bar"
+
+    h.should == new_hash("foo" => 0)
+    h.keys[0].frozen?.should == true
+  end
+
+  it "doesn't duplicate and freeze already frozen string keys" do
+    key = "foo".freeze
+    h = new_hash
+    h.send(@method, key, 0)
+    h.keys[0].should equal(key)
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "raises a TypeError if called on a frozen instance" do
+      lambda { HashSpecs.frozen_hash.send(@method, 1, 2) }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError if called on a frozen instance" do
+      lambda { HashSpecs.frozen_hash.send(@method, 1, 2) }.should raise_error(RuntimeError)
+    end
+  end
+=end
+
+  it "does not raise an exception if changing the value of an existing key during iteration" do
+      hash = {1 => 2, 3 => 4, 5 => 6}
+      hash.each { hash.send(@method, 1, :foo) }
+      hash.should == {1 => :foo, 3 => 4, 5 => 6}
+  end
+end

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

@@ -0,0 +1,68 @@
+require File.expand_path('../../../../spec_helper', __FILE__)
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+shared_examples_for :to_s do |method|
+  before { @method = method }
+
+  it "returns a string representation with same order as each()" do
+    h = new_hash(:a => [1, 2], :b => -2, :d => -6, nil => nil)
+
+    pairs = []
+    h.each do |key, value|
+      pairs << key.inspect + '=>' + value.inspect
+    end
+
+    str = '{' + pairs.join(', ') + '}'
+    h.send(@method).should == str
+  end
+
+  it "calls inspect on keys and values" do
+    key = mock('key')
+    val = mock('val')
+    key.should_receive(:inspect).and_return('key')
+    val.should_receive(:inspect).and_return('val')
+
+    new_hash(key => val).send(@method).should == '{key=>val}'
+  end
+
+  it "handles hashes with recursive values" do
+    x = new_hash
+    x[0] = x
+    x.send(@method).should == '{0=>{...}}'
+
+    x = new_hash
+    y = new_hash
+    x[0] = y
+    y[1] = x
+    x.send(@method).should == "{0=>{1=>{...}}}"
+    y.send(@method).should == "{1=>{0=>{...}}}"
+  end
+
+  # Recursive hash keys are disallowed on 1.9
+  ruby_version_is ""..."1.9" do
+    it "handles hashes with recursive keys" do
+      x = new_hash
+      x[x] = 0
+      x.send(@method).should == '{{...}=>0}'
+
+      x = new_hash
+      x[x] = x
+      x.send(@method).should == '{{...}=>{...}}'
+
+
+      x = new_hash
+      y = new_hash
+      x[y] = 0
+      y[x] = 1
+      x.send(@method).should == "{{{...}=>1}=>0}"
+      y.send(@method).should == "{{{...}=>0}=>1}"
+
+      x = new_hash
+      y = new_hash
+      x[y] = x
+      y[x] = y
+      x.send(@method).should == "{{{...}=>{...}}=>{...}}"
+      y.send(@method).should == "{{{...}=>{...}}=>{...}}"
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+shared_examples_for :hash_update do |method|
+  before { @method = method }
+
+=begin self
+  it "returns self" do
+    h = new_hash(:_1 => 'a', :_2 => '3')
+    h.send(@method, :_1 => '9', :_9 => 2).should equal(h)
+  end
+=end
+
+  it "adds the entries from other, overwriting duplicate keys" do
+    h = new_hash(:_1 => 'a', :_2 => '3')
+    h.send(@method, :_1 => '9', :_9 => 2)
+    h.should == new_hash(:_1 => "9", :_2 => "3", :_9 => 2)
+  end
+
+=begin self
+  it "returns self with block" do
+    h1 = new_hash(:a => 2, :b => -1)
+    h2 = new_hash(:a => -2, :c => 1)
+    h1.send(@method, h2) { |k,x,y| 3.14 }.should equal(h1)
+  end
+=end
+
+=begin nil
+  it "sets any duplicate key to the value of block if passed a block" do
+    h1 = new_hash(:a => 2, :b => -1)
+    h2 = new_hash(:a => -2, :c => 1)
+    h1.send(@method, h2) { |k,x,y| 3.14 }
+    h1.should == new_hash(:c => 1, :b => -1, :a => 3.14)
+
+    h1.send(@method, h1) { nil }
+    h1.should == new_hash(:a => nil, :b => nil, :c => nil)
+  end
+=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).send(@method, obj).should == new_hash(1 => 2, 3 => 4)
+  end
+
+  it "does not call to_hash on hash subclasses" do
+    new_hash(3 => 4).send(@method, ToHashHash[1 => 2]).should == new_hash(1 => 2, 3 => 4)
+  end
+
+=begin nil
+  it "processes entries with same order as merge()" do
+    h = new_hash(1 => 2, 3 => 4, 5 => 6, "x" => nil, nil => 5, [] => [])
+    merge_bang_pairs = []
+    merge_pairs = []
+    h.merge(h) { |*arg| merge_pairs << arg }
+    h.send(@method, h) { |*arg| merge_bang_pairs << arg }
+    merge_bang_pairs.should == merge_pairs
+  end
+=end
+
+=begin frozen
+  ruby_version_is ""..."1.9" do
+    it "raises a TypeError if called on a non-empty, frozen instance" do
+      lambda { HashSpecs.frozen_hash.send(@method, 1 => 2) }.should raise_error(TypeError)
+    end
+
+    it "does not raise an exception on a frozen instance that would not be modified" do
+      hash = HashSpecs.frozen_hash.send(@method, HashSpecs.empty_frozen_hash)
+      hash.should == HashSpecs.frozen_hash
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError on a frozen instance that is modified" do
+      lambda do
+        HashSpecs.frozen_hash.send(@method, 1 => 2)
+      end.should raise_error(RuntimeError)
+    end
+
+    it "checks frozen status before coercing an object with #to_hash" do
+      obj = mock("to_hash frozen")
+      # This is necessary because mock cleanup code cannot run on the frozen
+      # object.
+      def obj.to_hash() raise Exception, "should not receive #to_hash" end
+      obj.freeze
+
+      lambda { HashSpecs.frozen_hash.send(@method, obj) }.should raise_error(RuntimeError)
+    end
+
+    # see redmine #1571
+    it "raises a RuntimeError on a frozen instance that would not be modified" do
+      lambda do
+        HashSpecs.frozen_hash.send(@method, HashSpecs.empty_frozen_hash)
+      end.should raise_error(RuntimeError)
+    end
+  end
+=end
+end

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

@@ -0,0 +1,16 @@
+shared_examples_for :hash_value_p do |method|
+  before { @method = method }
+
+  it "returns true if the value exists in the hash" do
+    new_hash(:a => :b).send(@method, :a).should == false
+    new_hash(1 => 2).send(@method, 2).should == true
+    h = new_hash 5
+    h.send(@method, 5).should == false
+    h = new_hash { 5 }
+    h.send(@method, 5).should == false
+  end
+
+  it "uses == semantics for comparing values" do
+    new_hash(5 => 2.0).send(@method, 2).should == true
+  end
+end

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

@@ -0,0 +1,12 @@
+shared_examples_for :hash_values_at do |method|
+  before { @method = method }
+
+  it "returns an array of values for the given keys" do
+    h = new_hash(:a => 9, :b => 'a', :c => -10, :d => nil)
+    h.send(@method).should be_kind_of(Array)
+    h.send(@method).should == []
+    h.send(@method, :a, :d, :b).should be_kind_of(Array)
+    h.send(@method, :a, :d, :b).should == [9, nil, 'a']
+  end
+end
+

data/spec/java_ext/map/shift_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Hash#shift" do
+=begin shift
+  it "removes a pair from hash and return it" do
+    h = new_hash(:a => 1, :b => 2, "c" => 3, nil => 4, [] => 5)
+    h2 = h.dup
+
+    h.size.times do |i|
+      r = h.shift
+      r.should be_kind_of(Array)
+      h2[r.first].should == r.last
+      h.size.should == h2.size - i - 1
+    end
+
+    h.should == new_hash
+  end
+
+  it "returns nil from an empty hash " do
+    new_hash.shift.should == nil
+  end
+
+  it "returns (computed) default for empty hashes" do
+    new_hash(5).shift.should == 5
+    h = new_hash { |*args| args }
+    h.shift.should == [h, nil]
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "raises a TypeError if called on a frozen instance" do
+      lambda { HashSpecs.frozen_hash.shift  }.should raise_error(TypeError)
+      lambda { HashSpecs.empty_frozen_hash.shift }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError if called on a frozen instance" do
+      lambda { HashSpecs.frozen_hash.shift  }.should raise_error(RuntimeError)
+      lambda { HashSpecs.empty_frozen_hash.shift }.should raise_error(RuntimeError)
+    end
+  end
+=end
+end

data/spec/java_ext/map/size_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#size" do
+  it_behaves_like(:hash_length, :size)
+end

data/spec/java_ext/map/sort_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Hash#sort" do
+  it "converts self to a nested array of [key, value] arrays and sort with Array#sort" do
+    new_hash('a' => 'b', '1' => '2', 'b' => 'a').sort.should ==
+      [["1", "2"], ["a", "b"], ["b", "a"]]
+  end
+
+  it "works when some of the keys are themselves arrays" do
+    new_hash([1,2] => 5, [1,1] => 5).sort.should == [[[1,1],5], [[1,2],5]]
+  end
+
+  it "uses block to sort array if passed a block" do
+    new_hash(1 => 2, 2 => 9, 3 => 4).sort { |a,b| b <=> a }.should == [[3, 4], [2, 9], [1, 2]]
+  end
+end

data/spec/java_ext/map/store_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/store', __FILE__)
+
+describe "Hash#store" do
+  it_behaves_like(:hash_store, :store)
+end

data/spec/java_ext/map/to_a_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Hash#to_a" do
+  it "returns a list of [key, value] pairs with same order as each()" do
+    h = new_hash(:a => 1, 1 => :a, 3 => :b, :b => 5)
+    pairs = []
+
+    h.each_pair do |key, value|
+      pairs << [key, value]
+    end
+
+    h.to_a.should be_kind_of(Array)
+    h.to_a.should == pairs
+  end
+
+  it "is called for Enumerable#entries" do
+    h = new_hash(:a => 1, 1 => :a, 3 => :b, :b => 5)
+    pairs = []
+
+    h.each_pair do |key, value|
+      pairs << [key, value]
+    end
+
+    ent = h.entries
+    ent.should be_kind_of(Array)
+    ent.should == pairs
+  end
+end

data/spec/java_ext/map/to_hash_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Hash#to_hash" do
+=begin self
+  it "returns self" do
+    h = new_hash
+    h.to_hash.should equal(h)
+  end
+=end
+end

data/spec/java_ext/map/to_s_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../shared/to_s', __FILE__)
+
+describe "Hash#to_s" do
+
+  ruby_version_is "1.9" do
+    it_behaves_like :to_s, :to_s
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "returns a string by calling Hash#to_a and using Array#join with default separator" do
+      h = new_hash(:fun => 'x', 1 => 3, nil => "ok", [] => :y)
+      h.to_a.to_s.should == h.to_s
+      old, $, = $,, ':'
+      h.to_a.to_s.should == h.to_s
+      $, = old
+    end
+  end
+end

data/spec/java_ext/map/try_convert_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+ruby_version_is "1.8.8" do
+  describe "Hash.try_convert" do
+    it "returns the argument if passed a Hash" do
+      h = {:foo => :glark}
+      Hash.try_convert(h).should == h
+    end
+
+    it "returns nil if the argument can't be coerced into a Hash" do
+      Hash.try_convert(Object.new).should be_nil
+    end
+
+    it "does not rescue exceptions raised by #to_hash" do
+      obj = mock("to_hash raises")
+      obj.should_receive(:to_hash).and_raise(RuntimeError)
+      lambda { Hash.try_convert obj }.should raise_error(RuntimeError)
+    end
+
+    it "coerces the argument with #to_hash" do
+      obj = mock('to_hash')
+      obj.should_receive(:to_hash).and_return({:foo => :bar})
+      Hash.try_convert(obj).should == {:foo => :bar}
+    end
+
+    it "raises a TypeError if #to_hash does not return a Hash" do
+      obj = mock("to_hash invalid")
+      obj.should_receive(:to_hash).and_return(:invalid_to_hash)
+      lambda { Hash.try_convert obj }.should raise_error(TypeError)
+    end
+  end
+end

data/spec/java_ext/map/update_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/update', __FILE__)
+
+describe "Hash#update" do
+  it_behaves_like(:hash_update, :update)
+end