jactive_support 1.0.0-universal-java-1.6

data/spec/java_ext/list/clear_spec.rb

@@ -0,0 +1,56 @@
+require 'jactive_support/java_ext/list'
+require File.expand_path('../shared/fixtures', __FILE__)
+
+describe "java::util::List#clear" do
+  it "removes all elements" do
+    a = List[1, 2, 3, 4]
+    a.clear.should equal(a)
+    a.should == List[]
+  end
+
+  it "returns self" do
+    a = List[1]
+    oid = a.object_id
+    a.clear.object_id.should == oid
+  end
+
+  it "leaves the List empty" do
+    a = List[1]
+    a.clear
+    a.empty?.should == true
+  end
+
+  it "keeps tainted status" do
+    a = List[1]
+    a.taint
+    a.tainted?.should be_true
+    a.clear
+    a.tainted?.should be_true
+  end
+
+  it "does not accept any arguments" do
+    lambda { List[1].clear(true) }.should raise_error(ArgumentError)
+  end
+
+  ruby_version_is '1.9' do
+    it "keeps untrusted status" do
+      a = List[1]
+      a.untrust
+      a.untrusted?.should be_true
+      a.clear
+      a.untrusted?.should be_true
+    end
+  end
+
+  ruby_version_is '' ... '1.9' do
+    it "raises a TypeError on a frozen array" do
+      lambda { ListSpecs.frozen_list.clear }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is '1.9' do
+    it "raises a RuntimeError on a frozen array" do
+      lambda { ListSpecs.frozen_list.clear }.should raise_error(RuntimeError)
+    end
+  end
+end

data/spec/java_ext/list/collect_spec.rb

@@ -0,0 +1,11 @@
+require 'jactive_support/java_ext/list'
+require File.expand_path('../shared/fixtures', __FILE__)
+require File.expand_path('../shared/collect', __FILE__)
+
+describe "java::util::List#collect" do
+  it_behaves_like(:list_collect, :collect)
+end
+
+describe "java::util::List#collect!" do
+  it_behaves_like(:list_collect_b, :collect!)
+end

data/spec/java_ext/list/last_spec.rb

@@ -0,0 +1,87 @@
+require 'jactive_support/java_ext/list'
+require File.expand_path('../shared/fixtures', __FILE__)
+
+describe "java::util::List#last" do
+  it "returns the last element" do
+    List[1, 1, 1, 1, 2].last.should == 2
+  end
+
+  it "returns nil if self is empty" do
+    List[].last.should == nil
+  end
+
+  it "returns the last count elements if given a count" do
+    List[1, 2, 3, 4, 5, 9].last(3).should == [4, 5, 9]
+  end
+
+  it "returns an empty list when passed a count on an empty list" do
+    List[].last(0).should == []
+    List[].last(1).should == []
+  end
+
+  it "returns an empty list when count == 0" do
+    List[1, 2, 3, 4, 5].last(0).should == []
+  end
+
+  it "returns an list containing the last element when passed count == 1" do
+    List[1, 2, 3, 4, 5].last(1).should == [5]
+  end
+
+  it "raises an ArgumentError when count is negative" do
+    lambda { List[1, 2].last(-1) }.should raise_error(ArgumentError)
+  end
+
+  it "returns the entire list when count > length" do
+    List[1, 2, 3, 4, 5, 9].last(10).should == [1, 2, 3, 4, 5, 9]
+  end
+
+  it "returns an list which is independent to the original when passed count" do
+    ary = List[1, 2, 3, 4, 5]
+    ary.last(0).replace([1,2])
+    ary.should == List[1, 2, 3, 4, 5]
+    ary.last(1).replace([1,2])
+    ary.should == List[1, 2, 3, 4, 5]
+    ary.last(6).replace([1,2])
+    ary.should == List[1, 2, 3, 4, 5]
+  end
+
+  it "properly handles recursive lists" do
+    empty = ListSpecs.empty_recursive_list
+    empty.last.should equal(empty)
+
+    list = ListSpecs.recursive_list
+    list.last.should equal(list)
+  end
+
+  it "tries to convert the passed argument to an Integer usinig #to_int" do
+    obj = mock('to_int')
+    obj.should_receive(:to_int).and_return(2)
+    List[1, 2, 3, 4, 5].last(obj).should == [4, 5]
+  end
+
+  it "raises a TypeError if the passed argument is not numeric" do
+    lambda { List[1,2].last(nil) }.should raise_error(TypeError)
+    lambda { List[1,2].last("a") }.should raise_error(TypeError)
+
+    obj = mock("nonnumeric")
+    lambda { List[1,2].last(obj) }.should raise_error(TypeError)
+  end
+
+  it "does not return subclass instance on List subclasses" do
+    List[].last(0).should be_kind_of(Array)
+    List[].last(2).should be_kind_of(Array)
+    List[1, 2, 3].last(0).should be_kind_of(Array)
+    List[1, 2, 3].last(1).should be_kind_of(Array)
+    List[1, 2, 3].last(2).should be_kind_of(Array)
+  end
+
+  it "is not destructive" do
+    a = List[1, 2, 3]
+    a.last
+    a.should == List[1, 2, 3]
+    a.last(2)
+    a.should == List[1, 2, 3]
+    a.last(3)
+    a.should == List[1, 2, 3]
+  end
+end

data/spec/java_ext/list/map_spec.rb

@@ -0,0 +1,11 @@
+require 'jactive_support/java_ext/list'
+require File.expand_path('../shared/fixtures', __FILE__)
+require File.expand_path('../shared/collect', __FILE__)
+
+describe "java::util::List#map" do
+  it_behaves_like(:list_collect, :map)
+end
+
+describe "java::util::List#map!" do
+  it_behaves_like(:list_collect_b, :map!)
+end

data/spec/java_ext/list/push_spec.rb

@@ -0,0 +1,44 @@
+require 'jactive_support/java_ext/list'
+require File.expand_path('../shared/fixtures', __FILE__)
+
+describe "java::util::List#push" do
+  it "appends the arguments to the list" do
+    a = List[ "a", "b", "c" ]
+    a.push("d", "e", "f").should equal(a)
+    a.push().should == List["a", "b", "c", "d", "e", "f"]
+    a.push(5)
+    a.should == List["a", "b", "c", "d", "e", "f", 5]
+  end
+
+  it "isn't confused by previous shift" do
+    a = List[ "a", "b", "c" ]
+    a.shift
+    a.push("foo")
+    a.should == List["b", "c", "foo"]
+  end
+
+  it "properly handles recursive lists" do
+    empty = ListSpecs.empty_recursive_list
+    empty.push(:last).should == List[empty, :last]
+
+    list = ListSpecs.recursive_list
+    list.push(:last).should == List[1, 'two', 3.0, list, list, list, list, list, :last]
+  end
+
+  ruby_version_is "" ... "1.9" do
+    it "raises a TypeError on a frozen list if modification takes place" do
+      lambda { ListSpecs.frozen_list.push(1) }.should raise_error(TypeError)
+    end
+
+    it "does not raise on a frozen list if no modification is made" do
+      ListSpecs.frozen_list.push.should == List[1, 2, 3]
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a RuntimeError on a frozen list" do
+      lambda { ListSpecs.frozen_list.push(1) }.should raise_error(RuntimeError)
+      lambda { ListSpecs.frozen_list.push }.should raise_error(RuntimeError)
+    end
+  end
+end

data/spec/java_ext/list/shared/collect.rb

@@ -0,0 +1,133 @@
+shared_examples_for :list_collect do |method|
+  it "returns a copy of list with each element replaced by the value returned by block" do
+    a = List['a', 'b', 'c', 'd']
+    b = a.send(method) { |i| i + '!' }
+    b.should == ["a!", "b!", "c!", "d!"]
+    b.object_id.should_not == a.object_id
+  end
+
+  it "does not return subclass instance" do
+    List[1, 2, 3].send(method) { |x| x + 1 }.should be_kind_of(Array)
+  end
+
+  it "does not change self" do
+    a = List['a', 'b', 'c', 'd']
+    b = a.send(method) { |i| i + '!' }
+    a.should == List['a', 'b', 'c', 'd']
+  end
+
+  it "returns the evaluated value of block if it broke in the block" do
+    a = List['a', 'b', 'c', 'd']
+    b = a.send(method) {|i|
+      if i == 'c'
+        break 0
+      else
+        i + '!'
+      end
+    }
+    b.should == 0
+  end
+
+  ruby_version_is '' ... '1.9' do
+    it 'returns a copy of self if no block given' do
+      a = List[1, 2, 3]
+
+      copy = a.send(method)
+      copy.should == a.to_a
+      copy.should_not equal(a)
+    end
+  end
+  ruby_version_is '1.9' do
+    it "returns an Enumerator when no block given" do
+      a = List[1, 2, 3]
+      a.send(method).should be_an_instance_of(enumerator_class)
+    end
+  end
+
+  it "does not copy tainted status" do
+    a = List[1, 2, 3]
+    a.taint
+    a.send(method){|x| x}.tainted?.should be_false
+  end
+
+  ruby_version_is '1.9' do
+    it "does not copy untrusted status" do
+      a = List[1, 2, 3]
+      a.untrust
+      a.send(method){|x| x}.untrusted?.should be_false
+    end
+  end
+end
+
+shared_examples_for :list_collect_b do |method|
+  it "replaces each element with the value returned by block" do
+    a = List[7, 9, 3, 5]
+    a.send(method) { |i| i - 1 }.should equal(a)
+    a.should == List[6, 8, 2, 4]
+  end
+
+  it "returns self" do
+    a = List[1, 2, 3, 4, 5]
+    b = a.send(method) {|i| i+1 }
+    a.object_id.should == b.object_id
+  end
+
+  it "returns the evaluated value of block but its contents is partially modified, if it broke in the block" do
+    a = List['a', 'b', 'c', 'd']
+    b = a.send(method) {|i|
+      if i == 'c'
+        break 0
+      else
+        i + '!'
+      end
+    }
+    b.should == 0
+    a.should == List['a!', 'b!', 'c', 'd']
+  end
+
+  ruby_version_is '' ... '1.8.7' do
+    it 'raises LocalJumpError if no block given' do
+      a = List[1, 2, 3]
+      lambda { a.send(method) }.should raise_error(LocalJumpError)
+    end
+  end
+
+  ruby_version_is '1.8.7' do
+    it "returns an Enumerator when no block given, and the enumerator can modify the original list" do
+      a = List[1, 2, 3]
+      enum = a.send(method)
+      enum.should be_an_instance_of(enumerator_class)
+      enum.each{|i| "#{i}!" }
+      a.should == List["1!", "2!", "3!"]
+    end
+  end
+
+  it "keeps tainted status" do
+    a = List[1, 2, 3]
+    a.taint
+    a.tainted?.should be_true
+    a.send(method){|x| x}
+    a.tainted?.should be_true
+  end
+
+  ruby_version_is '1.9' do
+    it "keeps untrusted status" do
+      a = List[1, 2, 3]
+      a.untrust
+      a.send(method){|x| x}
+      a.untrusted?.should be_true
+    end
+  end
+
+  ruby_version_is '' ... '1.9' do
+    it "raises a TypeError on a frozen list" do
+      lambda { ListSpecs.frozen_list.send(method) {} }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is '1.9' do
+    it "raises a RuntimeError on a frozen list" do
+      lambda { ListSpecs.frozen_list.send(method) {} }.should raise_error(RuntimeError)
+    end
+  end
+end

data/spec/java_ext/list/shared/fixtures.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../../../../shared/version', __FILE__)
+require File.expand_path('../../../../shared/fixtures', __FILE__)
+
+class List < java::util::ArrayList
+  def self.[](*args)
+    new(args)
+  end
+end
+
+module ListSpecs
+  def self.frozen_list
+    frozen_array = List[1,2,3]
+    frozen_array.freeze
+    frozen_array
+  end
+
+  def self.empty_frozen_list
+    frozen_array = List[]
+    frozen_array.freeze
+    frozen_array
+  end
+
+  def self.recursive_list
+    a = List[1, 'two', 3.0]
+    5.times { a << a }
+    a
+  end
+
+  def self.empty_recursive_list
+    a = List[]
+    a << a
+    a
+  end
+end

data/spec/java_ext/map/assoc_spec.rb

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

data/spec/java_ext/map/clear_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Hash#clear" do
+  #it "returns itself" do
+  #  h = new_hash(1 => 2, 3 => 4)
+  #  h.clear.should equal(h)
+  #end
+
+  it "removes all key, value pairs" do
+    h = new_hash(1 => 2, 3 => 4)
+    h.clear
+    h.should == new_hash
+  end
+
+=begin default
+  it "does not remove default values" do
+    h = new_hash 5
+    h.clear
+    h.default.should == 5
+
+    h = new_hash("a" => 100, "b" => 200)
+    h.default = "Go fish"
+    h.clear
+    h["z"].should == "Go fish"
+  end
+
+  it "does not remove default procs" do
+    h = new_hash { 5 }
+    h.clear
+    h.default_proc.should_not == nil
+  end
+=end
+
+=begin frozen
+  ruby_version_is ""..."1.9" do
+    it "raises a TypeError if called on a frozen instance" do
+      lambda { HashSpecs.frozen_hash.clear  }.should raise_error(TypeError)
+      lambda { HashSpecs.empty_frozen_hash.clear }.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.clear  }.should raise_error(RuntimeError)
+      lambda { HashSpecs.empty_frozen_hash.clear }.should raise_error(RuntimeError)
+    end
+  end
+=end
+end

data/spec/java_ext/map/clone_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "Hash#clone" do
+  it "copies instance variable but not the objects they refer to" do
+    hash = new_hash('key' => 'value')
+
+    clone = hash.clone
+
+    clone.should == hash
+    clone.object_id.should_not == hash.object_id
+  end
+end
+

data/spec/java_ext/map/compare_by_identity_spec.rb

@@ -0,0 +1,111 @@
+=begin compare_by_identity
+ruby_version_is "1.9" do
+  describe "Hash#compare_by_identity" do
+    before(:each) do
+      @h = new_hash
+      @idh = new_hash.compare_by_identity
+    end
+
+    it "causes future comparisons on the receiver to be made by identity" do
+      @h["a"] = :a
+      @h["a"].should == :a
+      @h.compare_by_identity
+      @h["a"].should be_nil
+    end
+
+    it "causes #compare_by_identity? to return true" do
+      @idh.compare_by_identity?.should be_true
+    end
+
+    it "returns self" do
+      h = new_hash
+      h[:foo] = :bar
+      h.compare_by_identity.should == h
+    end
+
+    it "uses the semantics of BasicObject#equal? to determine key identity" do
+      1.1.should_not equal(1.1)
+      @idh[1.1] = :a
+      @idh[1.1] = :b
+      [1].should_not equal([1])
+      @idh[[1]] = :c
+      @idh[[1]] = :d
+      :bar.should equal(:bar)
+      @idh[:bar] = :e
+      @idh[:bar] = :f
+      "bar".should_not equal('bar')
+      @idh["bar"] = :g
+      @idh["bar"] = :h
+      @idh.values.should == [:a, :b, :c, :d, :f, :g, :h]
+    end
+
+    it "doesn't call #equal? on keys to determine their identity" do
+      obj = mock('equal')
+      obj.should_not_receive(:equal?)
+      @idh[:foo] = :glark
+      @idh[obj] = :a
+      @idh[obj.dup].should == nil
+    end
+
+    it "regards #dup'd objects as having different identities" do
+      str = 'foo'
+      @idh[str.dup] = :str
+      @idh[str].should be_nil
+    end
+
+    it "regards #clone'd objects as having different identities" do
+      str = 'foo'
+      @idh[str.clone] = :str
+      @idh[str].should be_nil
+    end
+
+    it "regards references to the same object as having the same identity" do
+      o = Object.new
+      @h[o] = :o
+      @h[:a] = :a
+      @h[o].should == :o
+    end
+
+    it "raises a RuntimeError on frozen hashes" do
+      @h = @h.freeze
+      lambda { @h.compare_by_identity }.should raise_error(RuntimeError)
+    end
+
+    # Behaviour confirmed in bug #1871
+    it "perists over #dups" do
+      @idh['foo'] = :bar
+      @idh['foo'] = :glark
+      @idh.dup.should == @idh
+      @idh.dup.size.should == @idh.size
+    end
+
+    it "persists over #clones" do
+      @idh['foo'] = :bar
+      @idh['foo'] = :glark
+      @idh.clone.should == @idh
+      @idh.clone.size.should == @idh.size
+    end
+  end
+
+  describe "Hash#compare_by_identity?" do
+    it "returns false by default" do
+      h = new_hash
+      h.compare_by_identity?.should be_false
+    end
+
+    it "returns true once #compare_by_identity has been invoked on self" do
+      h = new_hash
+      h.compare_by_identity
+      h.compare_by_identity?.should be_true
+    end
+
+    it "returns true when called multiple times on the same ident hash" do
+      h = new_hash
+      h.compare_by_identity
+      h.compare_by_identity?.should be_true
+      h.compare_by_identity?.should be_true
+      h.compare_by_identity?.should be_true
+    end
+  end
+end
+=end

data/spec/java_ext/map/constructor_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Hash.[]" do
+  it "creates a Hash; values can be provided as the argument list" do
+    hash_class[:a, 1, :b, 2].should == new_hash(:a => 1, :b => 2)
+    hash_class[].should == new_hash
+    hash_class[:a, 1, :b, new_hash(:c => 2)].should ==
+      new_hash(:a => 1, :b => new_hash(:c => 2))
+  end
+
+  it "creates a Hash; values can be provided as one single hash" do
+    hash_class[:a => 1, :b => 2].should == new_hash(:a => 1, :b => 2)
+    hash_class[new_hash(1 => 2, 3 => 4)].should == new_hash(1 => 2, 3 => 4)
+    hash_class[new_hash].should == new_hash
+  end
+
+=begin nil
+  ruby_version_is '1.8.7' do
+    # Not officially documented yet, see http://redmine.ruby-lang.org/issues/show/1385
+    ruby_bug "[ruby-core:21249]", "1.8.7.167" do
+      it "creates a Hash; values can be provided as a list of value-pairs in an array" do
+        hash_class[[[:a, 1], [:b, 2]]].should == new_hash(:a => 1, :b => 2)
+        hash_class[[[:a, 1], [:b], 42, [:d, 2], [:e, 2, 3], []]].should == new_hash(:a => 1, :b => nil, :d => 2)
+        obj = mock('x')
+        def obj.to_ary() [:b, 2] end
+        hash_class[[[:a, 1], obj]].should == new_hash(:a => 1, :b => 2)
+      end
+    end
+  end
+=end
+
+  it "raises an ArgumentError when passed an odd number of arguments" do
+    lambda { hash_class[1, 2, 3] }.should raise_error(ArgumentError)
+    lambda { hash_class[1, 2, new_hash(3 => 4)] }.should raise_error(ArgumentError)
+  end
+
+  ruby_version_is '1.8.7' do
+    it "calls to_hash" do
+      obj = mock('x')
+      def obj.to_hash() new_hash(1 => 2, 3 => 4) end
+      hash_class[obj].should == new_hash(1 => 2, 3 => 4)
+    end
+
+    it "returns an instance of a subclass when passed an Array" do
+      MyHash[[1,2,3,4]].should be_kind_of(MyHash)
+    end
+  end
+
+  it "returns an instance of the class it's called on" do
+    hash_class[MyHash[1, 2]].class.should == hash_class
+    MyHash[hash_class[1, 2]].should be_kind_of(MyHash)
+  end
+end