jactive_support 1.0.2

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

@@ -0,0 +1,224 @@
+shared_examples_for :hash_eql do |method|
+  before { @method = method }
+
+  it "does not compare values when keys don't match" do
+    value = mock('x')
+    value.should_not_receive(:==)
+    value.should_not_receive(:eql?)
+    new_hash(1 => value).send(@method, new_hash(2 => value)).should be_false
+  end
+
+  it "returns false when the numbers of keys differ without comparing any elements" do
+    obj = mock('x')
+    h = new_hash(obj => obj)
+
+    obj.should_not_receive(:==)
+    obj.should_not_receive(:eql?)
+
+    new_hash.send(@method, h).should be_false
+    h.send(@method, new_hash).should be_false
+  end
+
+  it "first compares keys via hash" do
+    x = mock('x')
+    x.should_receive(:hash).any_number_of_times.and_return(0)
+    y = mock('y')
+    y.should_receive(:hash).any_number_of_times.and_return(0)
+
+    new_hash(x => 1).send(@method, new_hash(y => 1)).should be_false
+  end
+
+  it "does not compare keys with different hash codes via eql?" do
+    x = mock('x')
+    y = mock('y')
+    x.should_not_receive(:eql?)
+    y.should_not_receive(:eql?)
+
+    x.should_receive(:hash).any_number_of_times.and_return(0)
+    y.should_receive(:hash).any_number_of_times.and_return(1)
+
+    new_hash(x => 1).send(@method, new_hash(y => 1)).should be_false
+  end
+
+  it "computes equality for recursive hashes" do
+    h = new_hash
+    h[:a] = h
+    h.send(@method, h[:a]).should be_true
+    (h == h[:a]).should be_true
+  end
+
+  it "doesn't call to_hash on objects" do
+    mock_hash = mock("fake hash")
+    def mock_hash.to_hash() new_hash end
+    new_hash.send(@method, mock_hash).should be_false
+  end
+
+  ruby_bug "redmine #2448", "1.9.1" do
+    it "computes equality for complex recursive hashes" do
+      a, b = {}, {}
+      a.merge! :self => a, :other => b
+      b.merge! :self => b, :other => a
+      a.send(@method, b).should be_true # they both have the same structure!
+
+      c = {}
+      c.merge! :other => c, :self => c
+      c.send(@method, a).should be_true # subtle, but they both have the same structure!
+      a[:delta] = c[:delta] = a
+      c.send(@method, a).should be_false # not quite the same structure, as a[:other][:delta] = nil
+      c[:delta] = 42
+      c.send(@method, a).should be_false
+      a[:delta] = 42
+      c.send(@method, a).should be_false
+      b[:delta] = 42
+      c.send(@method, a).should be_true
+    end
+
+    it "computes equality for recursive hashes & arrays" do
+      x, y, z = [], [], []
+      a, b, c = {:foo => x, :bar => 42}, {:foo => y, :bar => 42}, {:foo => z, :bar => 42}
+      x << a
+      y << c
+      z << b
+      b.send(@method, c).should be_true # they clearly have the same structure!
+      y.send(@method, z).should be_true
+      a.send(@method, b).should be_true # subtle, but they both have the same structure!
+      x.send(@method, y).should be_true
+      y << x
+      y.send(@method, z).should be_false
+      z << x
+      y.send(@method, z).should be_true
+
+      a[:foo], a[:bar] = a[:bar], a[:foo]
+      a.send(@method, b).should be_false
+      b[:bar] = b[:foo]
+      b.send(@method, c).should be_false
+    end
+  end # ruby_bug
+end
+
+# All these tests are true for ==, and for eql? when Ruby >= 1.8.7
+shared_examples_for :hash_eql_additional do |method|
+  before { @method = method }
+
+  it "compares values when keys match" do
+    x = mock('x')
+    y = mock('y')
+    def x.==(o) false end
+    def y.==(o) false end
+    def x.eql?(o) false end
+    def y.eql?(o) false end
+    new_hash(1 => x).send(@method, new_hash(1 => y)).should be_false
+
+    x = mock('x')
+    y = mock('y')
+    def x.==(o) true end
+    def y.==(o) true end
+    def x.eql?(o) true end
+    def y.eql?(o) true end
+    new_hash(1 => x).send(@method, new_hash(1 => y)).should be_true
+  end
+
+  it "compares keys with eql? semantics" do
+    new_hash(1.0 => "x").send(@method, new_hash(1.0 => "x")).should be_true
+    new_hash(1.0 => "x").send(@method, new_hash(1.0 => "x")).should be_true
+    new_hash(1 => "x").send(@method, new_hash(1.0 => "x")).should be_false
+    new_hash(1.0 => "x").send(@method, new_hash(1 => "x")).should be_false
+  end
+
+  it "returns true iff other Hash has the same number of keys and each key-value pair matches" do
+    a = new_hash(:a => 5)
+    b = new_hash
+    a.send(@method, b).should be_false
+
+    b[:a] = 5
+    a.send(@method, b).should be_true
+
+    c = new_hash("a" => 5)
+    a.send(@method, c).should be_false
+  end
+
+  it "does not call to_hash on hash subclasses" do
+    new_hash(5 => 6).send(@method, ToHashHash[5 => 6]).should be_true
+  end
+
+  it "ignores hash class differences" do
+    h = new_hash(1 => 2, 3 => 4)
+    MyHash[h].send(@method, h).should be_true
+    MyHash[h].send(@method, MyHash[h]).should be_true
+    h.send(@method, MyHash[h]).should be_true
+  end
+
+=begin eql
+  # Why isn't this true of eql? too ?
+  it "compares keys with matching hash codes via eql?" do
+    # Can't use should_receive because it uses hash and eql? internally
+    a = Array.new(2) do
+      obj = mock('0')
+
+      def obj.hash()
+        return 0
+      end
+      # It's undefined whether the impl does a[0].eql?(a[1]) or
+      # a[1].eql?(a[0]) so we taint both.
+      def obj.equals(o)
+        return true if self == o
+        taint
+        o.taint
+        false
+      end
+
+      obj
+    end
+
+    new_hash(a[0] => 1).send(@method, new_hash(a[1] => 1)).should be_false
+    a[0].tainted?.should be_true
+    a[1].tainted?.should be_true
+
+    a = Array.new(2) do
+      obj = mock('0')
+
+      def obj.hash()
+        # It's undefined whether the impl does a[0].send(@method, a[1]) or
+        # a[1].send(@method, a[0]) so we taint both.
+        def self.equals(o) taint; o.taint; true; end
+        return 0
+      end
+
+      obj
+    end
+
+    new_hash(a[0] => 1).send(@method, new_hash(a[1] => 1)).should be_true
+    a[0].tainted?.should be_true
+    a[1].tainted?.should be_true
+  end
+
+  # The specs above all pass in 1.8.6p287 for Hash#== but not Hash#eql
+  # except this one, which does not pass for Hash#==.
+  ruby_version_is "1.8.7" do
+    it "compares the values in self to values in other hash" do
+      l_val = mock("left")
+      r_val = mock("right")
+
+      l_val.should_receive(:equals).with(r_val).and_return(true)
+
+      new_hash(1 => l_val).eql?(new_hash(1 => r_val)).should be_true
+    end
+  end
+=end
+end
+
+shared_examples_for :hash_eql_additional_more do |method|
+  before { @method = method }
+
+  it "returns true if other Hash has the same number of keys and each key-value pair matches, even though the default-value are not same" do
+    new_hash(5).send(@method, new_hash(1)).should be_true
+    new_hash {|h, k| 1}.send(@method, new_hash {}).should be_true
+    new_hash {|h, k| 1}.send(@method, new_hash(2)).should be_true
+
+    d = new_hash {|h, k| 1}
+    e = new_hash {}
+    d[1] = 2
+    e[1] = 2
+    d.send(@method, e).should be_true
+  end
+end

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

@@ -0,0 +1,94 @@
+shared_examples_for :hash_equal do |method|
+  before { @method = method }
+
+  it "does not compare values when keys don't match" do
+    value = mock('x')
+    value.should_not_receive(:==)
+    value.should_not_receive(:eql?)
+    new_hash(1 => value).send(@method, new_hash(2 => value)).should be_false
+  end
+
+  it "returns false when the numbers of keys differ without comparing any elements" do
+    obj = mock('x')
+    h = new_hash(obj => obj)
+
+    obj.should_not_receive(:==)
+    obj.should_not_receive(:eql?)
+
+    new_hash.send(@method, h).should be_false
+    h.send(@method, new_hash).should be_false
+  end
+
+  it "first compares keys via hash" do
+    x = mock('x')
+    x.should_receive(:hash).and_return(0)
+    y = mock('y')
+    y.should_receive(:hash).and_return(0)
+
+    new_hash(x => 1).send(@method, new_hash(y => 1)).should be_false
+  end
+
+  it "does not compare keys with different hash codes via eql?" do
+    x = mock('x')
+    y = mock('y')
+    x.should_not_receive(:eql?)
+    y.should_not_receive(:eql?)
+
+    x.should_receive(:hash).and_return(0)
+    y.should_receive(:hash).and_return(1)
+
+    def x.hash() 0 end
+    def y.hash() 1 end
+
+    new_hash(x => 1).send(@method, new_hash(y => 1)).should be_false
+  end
+
+  it "computes equality for recursive hashes" do
+    h = new_hash
+    h[:a] = h
+    h.send(@method, h[:a]).should be_true
+    (h == h[:a]).should be_true
+  end
+
+  ruby_bug "redmine #2448", "1.9.1" do
+    it "computes equality for complex recursive hashes" do
+      a, b = {}, {}
+      a.merge! :self => a, :other => b
+      b.merge! :self => b, :other => a
+      a.send(@method, b).should be_true # they both have the same structure!
+
+      c = {}
+      c.merge! :other => c, :self => c
+      c.send(@method, a).should be_true # subtle, but they both have the same structure!
+      a[:delta] = c[:delta] = a
+      c.send(@method, a).should be_false # not quite the same structure, as a[:other][:delta] = nil
+      c[:delta] = 42
+      c.send(@method, a).should be_false
+      a[:delta] = 42
+      c.send(@method, a).should be_false
+      b[:delta] = 42
+      c.send(@method, a).should be_true
+    end
+
+    it "computes equality for recursive hashes & arrays" do
+      x, y, z = [], [], []
+      a, b, c = {:foo => x, :bar => 42}, {:foo => y, :bar => 42}, {:foo => z, :bar => 42}
+      x << a
+      y << c
+      z << b
+      b.send(@method, c).should be_true # they clearly have the same structure!
+      y.send(@method, z).should be_true
+      a.send(@method, b).should be_true # subtle, but they both have the same structure!
+      x.send(@method, y).should be_true
+      y << x
+      y.send(@method, z).should be_false
+      z << x
+      y.send(@method, z).should be_true
+
+      a[:foo], a[:bar] = a[:bar], a[:foo]
+      a.send(@method, b).should be_false
+      b[:bar] = b[:foo]
+      b.send(@method, c).should be_false
+    end
+  end # ruby_bug
+end

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

@@ -0,0 +1,29 @@
+require File.expand_path('../../../../spec_helper', __FILE__)
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+shared_examples_for :hash_index do |method|
+  before { @method = method }
+
+  it "returns the corresponding key for value" do
+    new_hash(2 => 'a', 1 => 'b').send(@method, 'b').should == 1
+  end
+
+  it "returns nil if the value is not found" do
+    new_hash(:a => -1, :b => 3.14, :c => 2.718).send(@method, 1).should be_nil
+  end
+
+  it "doesn't return default value if the value is not found" do
+    new_hash(5).send(@method, 5).should be_nil
+  end
+
+  it "compares values using ==" do
+    new_hash(1 => 0).send(@method, 0.0).should == 1
+    new_hash(1 => 0.0).send(@method, 0).should == 1
+
+    needle = mock('needle')
+    inhash = mock('inhash')
+    inhash.should_receive(:==).with(needle).and_return(true)
+
+    new_hash(1 => inhash).send(@method, needle).should == 1
+  end
+end

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

@@ -0,0 +1,28 @@
+shared_examples_for :hash_iteration_no_block do |method|
+  before { @method = method }
+
+  before(:each) do
+    @hsh = new_hash(1 => 2, 3 => 4, 5 => 6)
+    @empty = new_hash
+  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.send(@method) }.should raise_error(LocalJumpError)
+    end
+
+    it "does not raise a LocalJumpError when called on an empty hash without a block" do
+      @empty.send(@method).should == @empty
+    end
+  end
+
+  ruby_version_is "1.8.7" do
+    it "returns an Enumerator if called on a non-empty hash without a block" do
+      @hsh.send(@method).should be_an_instance_of(enumerator_class)
+    end
+
+    it "returns an Enumerator if called on an empty hash without a block" do
+      @empty.send(@method).should be_an_instance_of(enumerator_class)
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+shared_examples_for :hash_key_p do |method|
+  before { @method = method }
+
+  it "returns true if argument is a key" do
+    h = new_hash(:a => 1, :b => 2, :c => 3, 4 => 0)
+    h.send(@method, :a).should == true
+    h.send(@method, :b).should == true
+    h.send(@method, 'b').should == false
+    h.send(@method, 2).should == false
+    h.send(@method, 4).should == true
+    h.send(@method, 4.0).should == false
+  end
+
+=begin nil
+  it "returns true if the key's matching value was nil" do
+    new_hash(:xyz => nil).send(@method, :xyz).should == true
+  end
+=end
+
+  it "returns true if the key's matching value was false" do
+    new_hash(:xyz => false).send(@method, :xyz).should == true
+  end
+
+=begin nil
+  it "returns true if the key is nil" do
+    new_hash(nil => 'b').send(@method, nil).should == true
+    new_hash(nil => nil).send(@method, nil).should == true
+  end
+=end
+
+=begin hashCode equals
+  it "compares keys with the same #hashCode value via #equals" do
+    x = mock('x')
+    x.stub!(:hashCode).and_return(42)
+
+    y = mock('y')
+    y.stub!(:hashCode).and_return(42)
+    y.should_receive(:equals).and_return(false)
+
+    new_hash(x => nil).send(@method, y).should == false
+  end
+=end
+end

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

@@ -0,0 +1,12 @@
+shared_examples_for :hash_length do |method|
+  before { @method = method }
+
+  it "returns the number of entries" do
+    new_hash(:a => 1, :b => 'c').send(@method).should == 2
+    new_hash(:a => 1, :b => 2, :a => 2).send(@method).should == 2
+    new_hash(:a => 1, :b => 1, :c => 1).send(@method).should == 3
+    new_hash().send(@method).should == 0
+    new_hash(5).send(@method).should == 0
+    new_hash { 5 }.send(@method).should == 0
+  end
+end

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

@@ -0,0 +1,82 @@
+shared_examples_for :hash_replace do |method|
+  before { @method = method }
+
+=begin self
+  it "returns self" do
+    h = new_hash(:a => 1, :b => 2)
+    h.send(@method, :c => -1, :d => -2).should equal(h)
+  end
+=end
+
+  it "replaces the contents of self with other" do
+    h = new_hash(:a => 1, :b => 2)
+    h.send(@method, :c => -1, :d => -2)
+    h.should == new_hash(:c => -1, :d => -2)
+  end
+
+  it "tries to convert the passed argument to a hash using #to_hash" do
+    obj = mock('{1=>2,3=>4}')
+    obj.should_receive(:to_hash).and_return(new_hash(1 => 2, 3 => 4).to_hash)
+
+    h = new_hash
+    h.send(@method, obj)
+    h.should == new_hash(1 => 2, 3 => 4)
+  end
+
+  it "calls to_hash on hash subclasses" do
+    h = new_hash
+    h.send(@method, ToHashHash[1 => 2])
+    h.should == new_hash(1 => 2)
+  end
+
+=begin default
+  it "does not transfer default values" do
+    hash_a = new_hash
+    hash_b = new_hash 5
+    hash_a.send(@method, hash_b)
+    hash_a.default.should == 5
+
+    hash_a = new_hash
+    hash_b = new_hash { |h, k| k * 2 }
+    hash_a.send(@method, hash_b)
+    hash_a.default(5).should == 10
+
+    hash_a = new_hash { |h, k| k * 5 }
+    hash_b = new_hash(lambda { raise "Should not invoke lambda" })
+    hash_a.send(@method, hash_b)
+    hash_a.default.should == hash_b.default
+  end
+=end
+
+=begin frozen
+  ruby_version_is ""..."1.9" do
+    it "raises a RuntimeError if called on a frozen instance that is modified" do
+      lambda do
+        HashSpecs.frozen_hash.send(@method, HashSpecs.empty_frozen_hash)
+      end.should raise_error(TypeError)
+    end
+
+    ruby_bug "#1571, [ruby-core:23714]", "1.8.8" do
+      it "raises a RuntimeError if called on a frozen instance that would not be modified" do
+        lambda do
+          HashSpecs.frozen_hash.send(@method, HashSpecs.frozen_hash)
+        end.should raise_error(TypeError)
+      end
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError if called on a frozen instance that is modified" do
+      lambda do
+        HashSpecs.frozen_hash.send(@method, HashSpecs.frozen_hash)
+      end.should raise_error(RuntimeError)
+    end
+
+    it "raises a RuntimeError if called 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