Update to ruby/spec@83063a3

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@62094 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

spec/ruby/.rubocop.yml

@@ -60,6 +60,11 @@ Lint/EmptyWhen:
     - language/case_spec.rb
     - optional/capi/spec_helper.rb
 
+Lint/NestedMethodDefinition:
+  Exclude:
+    - language/def_spec.rb
+    - language/fixtures/def.rb
+
 Lint/UriRegexp:
   Exclude:
     - 'library/uri/regexp_spec.rb'

spec/ruby/.rubocop_todo.yml

@@ -89,11 +89,6 @@ Lint/MultipleCompare:
   Exclude:
     - 'language/precedence_spec.rb'
 
-# Offense count: 8
-Lint/NestedMethodDefinition:
-  Exclude:
-    - 'language/def_spec.rb'
-
 # Offense count: 12
 Lint/ParenthesesAsGroupedExpression:
   Exclude:

spec/ruby/CONTRIBUTING.md

@@ -166,6 +166,76 @@ Use the implementation test suite for these.
 
 If an implementation does not support some feature, simply tag the related specs as failing instead.
 
+### Shared Specs
+
+Often throughout Ruby, identical functionality is used by different methods and modules. In order 
+to avoid duplication of specs, we have shared specs that are re-used in other specs.  The use is a
+bit tricky however, so let's go over it.
+
+Commonly, if a shared spec is only reused within its own module, the shared spec will live within a
+shared directory inside that module's directory. For example, the `core/hash/shared/key.rb` spec is 
+only used by `Hash` specs, and so it lives inside `core/hash/shared/`.
+
+When a shared spec is used across multiple modules or classes, it lives within the `shared/` directory.
+An example of this is the `shared/file/socket.rb` which is used by `core/file/socket_spec.rb`, 
+`core/filetest/socket_spec.rb`, and `core/file/state/socket_spec.rb` and so it lives in the root `shared/`.
+
+Defining a shared spec involves adding a `shared: true` option to the top-level `describe` block. This
+will signal not to run the specs directly by the runner.  Shared specs have access to two instance 
+variables from the implementor spec: `@method` and `@object`, which the implementor spec will pass in.
+
+Here's an example of a snippet of a shared spec and two specs which integrates it:
+
+``` ruby
+# core/hash/shared/key.rb
+describe :hash_key_p, shared: true do
+  it "returns true if the key's matching value was false" do
+    { xyz: false }.send(@method, :xyz).should == true
+  end
+end
+
+# core/hash/key_spec.rb
+describe "Hash#key?" do
+  it_behaves_like :hash_key_p, :key?
+end
+
+# core/hash/include_spec.rb
+describe "Hash#include?" do
+  it_behaves_like :hash_key_p, :include?
+end
+```
+
+In the example, the first `describe` defines the shared spec `:hash_key_p`, which defines a spec that
+calls the `@method` method with an expectation.  In the implementor spec, we use `it_behaves_like` to
+integrate the shared spec.  `it_behaves_like` takes 3 parameters: the key of the shared spec, a method,
+and an object.  These last two parameters are accessible via `@method` and `@object` in the shared spec.
+
+Sometimes, shared specs require more context from the implementor class than a simple object. We can address
+this by passing a lambda as the method, which will have the scope of the implementor.  Here's an example of
+how this is used currently:
+
+``` ruby
+describe :kernel_sprintf, shared: true do
+  it "raises TypeError exception if cannot convert to Integer" do
+    -> { @method.call("%b", Object.new) }.should raise_error(TypeError)
+  end
+end
+
+describe "Kernel#sprintf" do
+  it_behaves_like :kernel_sprintf, -> (format, *args) {
+    sprintf(format, *args)
+  }
+end
+
+describe "Kernel.sprintf" do
+  it_behaves_like :kernel_sprintf, -> (format, *args) {
+    Kernel.sprintf(format, *args)
+  }
+end
+```
+
+In the above example, the method being passed is a lambda that triggers the specific conditions of the shared spec.
+
 ### Style
 
-Do not leave any trailing space and respect the existing style.
+Do not leave any trailing space and follow the existing style.

spec/ruby/core/array/append_spec.rb

@@ -37,6 +37,6 @@ end
 
 ruby_version_is "2.5" do
   describe "Array#append" do
-    it_behaves_like(:array_push, :append)
+    it_behaves_like :array_push, :append
   end
 end

spec/ruby/core/array/collect_spec.rb

@@ -3,9 +3,9 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/collect', __FILE__)
 
 describe "Array#collect" do
-  it_behaves_like(:array_collect, :collect)
+  it_behaves_like :array_collect, :collect
 end
 
 describe "Array#collect!" do
-  it_behaves_like(:array_collect_b, :collect!)
+  it_behaves_like :array_collect_b, :collect!
 end

spec/ruby/core/array/element_reference_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/slice', __FILE__)
 
 describe "Array#[]" do
-  it_behaves_like(:array_slice, :[])
+  it_behaves_like :array_slice, :[]
 end
 
 describe "Array.[]" do

spec/ruby/core/array/element_set_spec.rb

@@ -350,11 +350,13 @@ describe "Array#[]= with [m..n]" do
   it "returns non-array value if non-array value assigned" do
     a = [1, 2, 3, 4, 5]
     (a[2..4] = 10).should == 10
+    (a.[]=(2..4, 10)).should == 10
   end
 
   it "returns array if array assigned" do
     a = [1, 2, 3, 4, 5]
     (a[2..4] = [7, 8]).should == [7, 8]
+    (a.[]=(2..4, [7, 8])).should == [7, 8]
   end
 
   it "just sets the section defined by range to nil even if the rhs is nil" do
@@ -394,15 +396,32 @@ describe "Array#[]= with [m..n]" do
     a.should == [1, 2, 3, 8, 4, 5]
   end
 
-  it "accepts Range subclasses" do
+  describe "Range subclasses" do
-    a = [1, 2, 3, 4]
+    before :each do
-    range_incl = ArraySpecs::MyRange.new(1, 2)
+      @range_incl = ArraySpecs::MyRange.new(1, 2)
-    range_excl = ArraySpecs::MyRange.new(-3, -1, true)
+      @range_excl = ArraySpecs::MyRange.new(-3, -1, true)
+    end
 
-    a[range_incl] = ["a", "b"]
+    it "accepts Range subclasses" do
-    a.should == [1, "a", "b", 4]
+      a = [1, 2, 3, 4]
-    a[range_excl] = ["A", "B"]
+
-    a.should == [1, "A", "B", 4]
+      a[@range_incl] = ["a", "b"]
+      a.should == [1, "a", "b", 4]
+      a[@range_excl] = ["A", "B"]
+      a.should == [1, "A", "B", 4]
+    end
+
+    it "returns non-array value if non-array value assigned" do
+      a = [1, 2, 3, 4, 5]
+      (a[@range_incl] = 10).should == 10
+      (a.[]=(@range_incl, 10)).should == 10
+    end
+
+    it "returns array if array assigned" do
+      a = [1, 2, 3, 4, 5]
+      (a[@range_incl] = [7, 8]).should == [7, 8]
+      a.[]=(@range_incl, [7, 8]).should == [7, 8]
+    end
   end
 end
 

spec/ruby/core/array/index_spec.rb

@@ -2,5 +2,5 @@ require File.expand_path('../../../spec_helper', __FILE__)
 require File.expand_path('../shared/index', __FILE__)
 
 describe "Array#index" do
-  it_behaves_like(:array_index, :index)
+  it_behaves_like :array_index, :index
 end

spec/ruby/core/array/length_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/length', __FILE__)
 
 describe "Array#length" do
-  it_behaves_like(:array_length, :length)
+  it_behaves_like :array_length, :length
 end

spec/ruby/core/array/map_spec.rb

@@ -3,9 +3,9 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/collect', __FILE__)
 
 describe "Array#map" do
-  it_behaves_like(:array_collect, :map)
+  it_behaves_like :array_collect, :map
 end
 
 describe "Array#map!" do
-  it_behaves_like(:array_collect_b, :map!)
+  it_behaves_like :array_collect_b, :map!
 end

spec/ruby/core/array/prepend_spec.rb

@@ -4,6 +4,6 @@ require File.expand_path('../shared/unshift', __FILE__)
 
 ruby_version_is "2.5" do
   describe "Array#prepend" do
-    it_behaves_like(:array_unshift, :prepend)
+    it_behaves_like :array_unshift, :prepend
   end
 end

spec/ruby/core/array/push_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/push', __FILE__)
 
 describe "Array#push" do
-  it_behaves_like(:array_push, :push)
+  it_behaves_like :array_push, :push
 end

spec/ruby/core/array/replace_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/replace', __FILE__)
 
 describe "Array#replace" do
-  it_behaves_like(:array_replace, :replace)
+  it_behaves_like :array_replace, :replace
 end

spec/ruby/core/array/size_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/length', __FILE__)
 
 describe "Array#size" do
-  it_behaves_like(:array_length, :size)
+  it_behaves_like :array_length, :size
 end

spec/ruby/core/array/slice_spec.rb

@@ -156,5 +156,5 @@ describe "Array#slice!" do
 end
 
 describe "Array#slice" do
-  it_behaves_like(:array_slice, :slice)
+  it_behaves_like :array_slice, :slice
 end

spec/ruby/core/array/unshift_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/unshift', __FILE__)
 
 describe "Array#unshift" do
-  it_behaves_like(:array_unshift, :unshift)
+  it_behaves_like :array_unshift, :unshift
 end

spec/ruby/core/basicobject/__send___spec.rb

@@ -6,5 +6,5 @@ describe "BasicObject#__send__" do
     BasicObject.should have_public_instance_method(:__send__)
   end
 
-  it_behaves_like(:basicobject_send, :__send__)
+  it_behaves_like :basicobject_send, :__send__
 end

spec/ruby/core/bignum/bignum_spec.rb

@@ -1,31 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum" do
-  it "includes Comparable" do
-    Bignum.include?(Comparable).should == true
-  end
-
-  it ".allocate raises a TypeError" do
-    lambda do
-      Bignum.allocate
-    end.should raise_error(TypeError)
-  end
-
-  it ".new is undefined" do
-    lambda do
-      Bignum.new
-    end.should raise_error(NoMethodError)
-  end
-
-  ruby_version_is '2.4' do
-    it "unified into Integer" do
-      Bignum.should equal(Integer)
-    end
-
-    it "is deprecated" do
-      -> {
-        Bignum
-      }.should complain(/constant ::Bignum is deprecated/)
-    end
-  end
-end

spec/ruby/core/bignum/bit_and_spec.rb

@@ -1,50 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#&" do
-  before :each do
-    @bignum = bignum_value(5)
-  end
-
-  it "returns self bitwise AND other" do
-    @bignum = bignum_value(5)
-    (@bignum & 3).should == 1
-    (@bignum & 52).should == 4
-    (@bignum & bignum_value(9921)).should == 9223372036854775809
-
-    ((2*bignum_value) & 1).should == 0
-    ((2*bignum_value) & (2*bignum_value)).should == 18446744073709551616
-  end
-
-  it "returns self bitwise AND other when one operand is negative" do
-    ((2*bignum_value) & -1).should == (2*bignum_value)
-    ((4*bignum_value) & -1).should == (4*bignum_value)
-    (@bignum & -0xffffffffffffff5).should == 9223372036854775809
-    (@bignum & -@bignum).should == 1
-    (@bignum & -0x8000000000000000).should == 9223372036854775808
-  end
-
-  it "returns self bitwise AND other when both operands are negative" do
-    (-@bignum & -0x4000000000000005).should == -13835058055282163717
-    (-@bignum & -@bignum).should == -9223372036854775813
-    (-@bignum & -0x4000000000000000).should == -13835058055282163712
-  end
-
-  it "returns self bitwise AND other when both are negative and a multiple in bitsize of Fixnum::MIN" do
-    val = - ((1 << 93) - 1)
-    (val & val).should == val
-
-    val = - ((1 << 126) - 1)
-    (val & val).should == val
-  end
-
-  it "raises a TypeError when passed a Float" do
-    lambda { (@bignum & 3.4) }.should raise_error(TypeError)
-  end
-
-  it "raises a TypeError and does not call #to_int when defined on an object" do
-    obj = mock("bignum bit and")
-    obj.should_not_receive(:to_int)
-
-    lambda { @bignum & obj }.should raise_error(TypeError)
-  end
-end

spec/ruby/core/bignum/bit_length_spec.rb

@@ -1,33 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#bit_length" do
-  it "returns the position of the leftmost bit of a positive number" do
-    (2**1000-1).bit_length.should == 1000
-    (2**1000).bit_length.should == 1001
-    (2**1000+1).bit_length.should == 1001
-
-    (2**10000-1).bit_length.should == 10000
-    (2**10000).bit_length.should == 10001
-    (2**10000+1).bit_length.should == 10001
-
-    (1 << 100).bit_length.should == 101
-    (1 << 100).succ.bit_length.should == 101
-    (1 << 100).pred.bit_length.should == 100
-    (1 << 10000).bit_length.should == 10001
-  end
-
-  it "returns the position of the leftmost 0 bit of a negative number" do
-    (-2**10000-1).bit_length.should == 10001
-    (-2**10000).bit_length.should == 10000
-    (-2**10000+1).bit_length.should == 10000
-
-    (-2**1000-1).bit_length.should == 1001
-    (-2**1000).bit_length.should == 1000
-    (-2**1000+1).bit_length.should == 1000
-
-    ((-1 << 100)-1).bit_length.should == 101
-    ((-1 << 100)-1).succ.bit_length.should == 100
-    ((-1 << 100)-1).pred.bit_length.should == 101
-    ((-1 << 10000)-1).bit_length.should == 10001
-  end
-end

spec/ruby/core/bignum/bit_or_spec.rb

@@ -1,41 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#|" do
-  before :each do
-    @bignum = bignum_value(11)
-  end
-
-  it "returns self bitwise OR other" do
-    (@bignum | 2).should == 9223372036854775819
-    (@bignum | 9).should == 9223372036854775819
-    (@bignum | bignum_value).should == 9223372036854775819
-  end
-
-  it "returns self bitwise OR other when one operand is negative" do
-    (@bignum | -0x40000000000000000).should == -64563604257983430645
-    (@bignum | -@bignum).should == -1
-    (@bignum | -0x8000000000000000).should == -9223372036854775797
-  end
-
-  it "returns self bitwise OR other when both operands are negative" do
-    (-@bignum | -0x4000000000000005).should == -1
-    (-@bignum | -@bignum).should == -9223372036854775819
-    (-@bignum | -0x4000000000000000).should == -11
-  end
-
-  it "raises a TypeError when passed a Float" do
-    not_supported_on :opal do
-      lambda {
-        bignum_value | bignum_value(0xffff).to_f
-      }.should raise_error(TypeError)
-    end
-    lambda { @bignum | 9.9 }.should raise_error(TypeError)
-  end
-
-  it "raises a TypeError and does not call #to_int when defined on an object" do
-    obj = mock("bignum bit or")
-    obj.should_not_receive(:to_int)
-
-    lambda { @bignum | obj }.should raise_error(TypeError)
-  end
-end

spec/ruby/core/bignum/bit_xor_spec.rb

@@ -1,47 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#^" do
-  before :each do
-    @bignum = bignum_value(18)
-  end
-
-  it "returns self bitwise EXCLUSIVE OR other" do
-    (@bignum ^ 2).should == 9223372036854775824
-    (@bignum ^ @bignum).should == 0
-    (@bignum ^ 14).should == 9223372036854775836
-  end
-
-  it "returns self bitwise EXCLUSIVE OR other when one operand is negative" do
-    (@bignum ^ -0x40000000000000000).should == -64563604257983430638
-    (@bignum ^ -@bignum).should == -4
-    (@bignum ^ -0x8000000000000000).should == -18446744073709551598
-  end
-
-  it "returns self bitwise EXCLUSIVE OR other when both operands are negative" do
-    (-@bignum ^ -0x40000000000000000).should == 64563604257983430638
-    (-@bignum ^ -@bignum).should == 0
-    (-@bignum ^ -0x4000000000000000).should == 13835058055282163694
-  end
-
-  it "returns self bitwise EXCLUSIVE OR other when all bits are 1 and other value is negative" do
-    (9903520314283042199192993791 ^ -1).should == -9903520314283042199192993792
-    (784637716923335095479473677900958302012794430558004314111 ^ -1).should ==
-      -784637716923335095479473677900958302012794430558004314112
-  end
-
-  it "raises a TypeError when passed a Float" do
-    not_supported_on :opal do
-      lambda {
-        bignum_value ^ bignum_value(0xffff).to_f
-      }.should raise_error(TypeError)
-    end
-    lambda { @bignum ^ 14.5 }.should raise_error(TypeError)
-  end
-
-  it "raises a TypeError and does not call #to_int when defined on an object" do
-    obj = mock("bignum bit xor")
-    obj.should_not_receive(:to_int)
-
-    lambda { @bignum ^ obj }.should raise_error(TypeError)
-  end
-end

spec/ruby/core/bignum/case_compare_spec.rb

@@ -1,6 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../shared/equal', __FILE__)
-
-describe "Bignum#===" do
-  it_behaves_like :bignum_equal, :===
-end

spec/ruby/core/bignum/coerce_spec.rb

@@ -1,65 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#coerce" do
-  it "coerces other to a Bignum and returns [other, self] when passed a Fixnum" do
-    a = bignum_value
-    ary = a.coerce(2)
-
-    ary[0].should be_kind_of(Bignum)
-    ary[1].should be_kind_of(Bignum)
-    ary.should == [2, a]
-  end
-
-  it "returns [other, self] when passed a Bignum" do
-    a = bignum_value
-    b = bignum_value
-    ary = a.coerce(b)
-
-    ary[0].should be_kind_of(Bignum)
-    ary[1].should be_kind_of(Bignum)
-    ary.should == [b, a]
-  end
-
-  it "raises a TypeError when not passed a Fixnum or Bignum" do
-    a = bignum_value
-
-    lambda { a.coerce(nil)         }.should raise_error(TypeError)
-    lambda { a.coerce(mock('str')) }.should raise_error(TypeError)
-    lambda { a.coerce(1..4)        }.should raise_error(TypeError)
-    lambda { a.coerce(:test)       }.should raise_error(TypeError)
-  end
-
-  ruby_version_is ""..."2.4" do
-    it "raises a TypeError when passed a String" do
-      a = bignum_value
-      lambda { a.coerce("123") }.should raise_error(TypeError)
-    end
-
-    it "raises a TypeError when passed a Float" do
-      a = bignum_value
-      lambda { a.coerce(12.3) }.should raise_error(TypeError)
-    end
-  end
-
-  ruby_version_is "2.4" do
-    it "coerces both values to Floats and returns [other, self] when passed a Float" do
-      a = bignum_value
-      a.coerce(1.2).should == [1.2, a.to_f]
-    end
-
-    it "coerces both values to Floats and returns [other, self] when passed a String" do
-      a = bignum_value
-      a.coerce("123").should == [123.0, a.to_f]
-    end
-
-    it "calls #to_f to coerce other to a Float" do
-      b = mock("bignum value")
-      b.should_receive(:to_f).and_return(1.2)
-
-      a = bignum_value
-      ary = a.coerce(b)
-
-      ary.should == [1.2, a.to_f]
-    end
-  end
-end

spec/ruby/core/bignum/comparison_spec.rb

@@ -1,162 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#<=>" do
-  describe "with a Fixnum" do
-    it "returns -1 when other is larger" do
-      (-bignum_value <=> 2).should == -1
-    end
-
-    it "returns 1 when other is smaller" do
-      (bignum_value <=> 2).should == 1
-    end
-  end
-
-  describe "with a Bignum" do
-    describe "when other is negative" do
-      it "returns -1 when self is negative and other is larger" do
-        (-bignum_value(42) <=> -bignum_value).should == -1
-      end
-
-      it "returns 0 when other is equal" do
-        (-bignum_value <=> -bignum_value).should == 0
-      end
-
-      it "returns 1 when self is negative and other is smaller" do
-        (-bignum_value <=> -bignum_value(94)).should == 1
-      end
-
-      it "returns 1 when self is positive" do
-        (bignum_value <=> -bignum_value).should == 1
-      end
-    end
-
-    describe "when other is positive" do
-      it "returns -1 when self is negative" do
-        (-bignum_value <=> bignum_value).should == -1
-      end
-
-      it "returns -1 when self is positive and other is larger" do
-        (bignum_value <=> bignum_value(38)).should == -1
-      end
-
-      it "returns 0 when other is equal" do
-        (bignum_value <=> bignum_value).should == 0
-      end
-
-      it "returns 1 when other is smaller" do
-        (bignum_value(56) <=> bignum_value).should == 1
-      end
-    end
-  end
-
-  describe "with a Float" do
-    describe "when other is negative" do
-      it "returns -1 when self is negative and other is larger" do
-        (-bignum_value(0xffff) <=> -bignum_value.to_f).should == -1
-      end
-
-      it "returns 0 when other is equal" do
-        (-bignum_value <=> -bignum_value.to_f).should == 0
-      end
-
-      it "returns 1 when self is negative and other is smaller" do
-        (-bignum_value <=> -bignum_value(0xffef).to_f).should == 1
-      end
-
-      it "returns 1 when self is positive" do
-        (bignum_value <=> -bignum_value.to_f).should == 1
-      end
-    end
-
-    describe "when other is positive" do
-      it "returns -1 when self is negative" do
-        (-bignum_value <=> bignum_value.to_f).should == -1
-      end
-
-      it "returns -1 when self is positive and other is larger" do
-        (bignum_value <=> bignum_value(0xfffe).to_f).should == -1
-      end
-
-      it "returns 0 when other is equal" do
-        (bignum_value <=> bignum_value.to_f).should == 0
-      end
-
-      it "returns 1 when other is smaller" do
-        (bignum_value(0xfeff) <=> bignum_value.to_f).should == 1
-      end
-    end
-  end
-
-  describe "with an Object" do
-    before :each do
-      @big = bignum_value
-      @num = mock("value for Bignum#<=>")
-    end
-
-    it "calls #coerce on other" do
-      @num.should_receive(:coerce).with(@big).and_return([@big.to_f, 2.5])
-      @big <=> @num
-    end
-
-    ruby_version_is ""..."2.5" do
-      it "returns nil if #coerce raises an exception" do
-        @num.should_receive(:coerce).with(@big).and_raise(RuntimeError)
-        lambda {
-          @result = (@big <=> @num)
-        }.should complain(/Numerical comparison operators will no more rescue exceptions/)
-        @result.should be_nil
-      end
-    end
-
-    ruby_version_is "2.5" do
-      it "lets the exception go through if #coerce raises an exception" do
-        @num.should_receive(:coerce).with(@big).and_raise(RuntimeError.new("my error"))
-        lambda {
-          @big <=> @num
-        }.should raise_error(RuntimeError, "my error")
-      end
-    end
-
-    it "raises an exception if #coerce raises a non-StandardError exception" do
-      @num.should_receive(:coerce).with(@big).and_raise(Exception)
-      lambda { @big <=> @num }.should raise_error(Exception)
-    end
-
-    it "returns nil if #coerce does not return an Array" do
-      @num.should_receive(:coerce).with(@big).and_return(nil)
-      (@big <=> @num).should be_nil
-    end
-
-    it "returns -1 if the coerced value is larger" do
-      @num.should_receive(:coerce).with(@big).and_return([@big, bignum_value(10)])
-      (@big <=> @num).should == -1
-    end
-
-    it "returns 0 if the coerced value is equal" do
-      @num.should_receive(:coerce).with(@big).and_return([@big, bignum_value])
-      (@big <=> @num).should == 0
-    end
-
-    it "returns 1 if the coerced value is smaller" do
-      @num.should_receive(:coerce).with(@big).and_return([@big, 22])
-      (@big <=> @num).should == 1
-    end
-  end
-
-  # The tests below are taken from matz's revision 23730 for Ruby trunk
-  it "returns 1 when self is Infinity and other is a Bignum" do
-    (infinity_value <=> Float::MAX.to_i*2).should == 1
-  end
-
-  it "returns -1 when self is negative and other is Infinty" do
-    (-Float::MAX.to_i*2 <=> infinity_value).should == -1
-  end
-
-  it "returns 1 when self is negative and other is -Infinity" do
-    (-Float::MAX.to_i*2 <=> -infinity_value).should == 1
-  end
-
-  it "returns -1 when self is -Infinity and other is negative" do
-    (-infinity_value <=> -Float::MAX.to_i*2).should == -1
-  end
-end

spec/ruby/core/bignum/complement_spec.rb

@@ -1,9 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#~" do
-  it "returns self with each bit flipped" do
-    (~bignum_value(48)).should == -9223372036854775857
-    (~(-bignum_value(21))).should == 9223372036854775828
-    (~bignum_value(1)).should == -9223372036854775810
-  end
-end

spec/ruby/core/bignum/div_spec.rb

@@ -1,21 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../shared/divide', __FILE__)
-
-describe "Bignum#div" do
-  it_behaves_like(:bignum_divide, :div)
-
-  it "returns a result of integer division of self by a float argument" do
-    bignum_value(88).div(4294967295.5).should eql(2147483648)
-    not_supported_on :opal do
-      bignum_value(88).div(4294967295.0).should eql(2147483648)
-      bignum_value(88).div(bignum_value(88).to_f).should eql(1)
-      bignum_value(88).div(-bignum_value(88).to_f).should eql(-1)
-    end
-  end
-
-  # #5490
-  it "raises ZeroDivisionError if the argument is Float zero" do
-    lambda { bignum_value(88).div(0.0) }.should raise_error(ZeroDivisionError)
-    lambda { bignum_value(88).div(-0.0) }.should raise_error(ZeroDivisionError)
-  end
-end

spec/ruby/core/bignum/divide_spec.rb

@@ -1,18 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../shared/divide', __FILE__)
-
-describe "Bignum#/" do
-  it_behaves_like(:bignum_divide, :/)
-
-  it "returns self divided by float" do
-    not_supported_on :opal do
-      (bignum_value(88) / 4294967295.0).should be_close(2147483648.5, TOLERANCE)
-    end
-    (bignum_value(88) / 4294967295.5).should be_close(2147483648.25, TOLERANCE)
-  end
-
-  it "does NOT raise ZeroDivisionError if other is zero and is a Float" do
-    (bignum_value / 0.0).to_s.should == 'Infinity'
-    (bignum_value / -0.0).to_s.should == '-Infinity'
-  end
-end

spec/ruby/core/bignum/divmod_spec.rb

@@ -1,81 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#divmod" do
-  before :each do
-    @bignum = bignum_value(55)
-  end
-
-  # Based on MRI's test/test_integer.rb (test_divmod),
-  # MRI maintains the following property:
-  # if q, r = a.divmod(b) ==>
-  # assert(0 < b ? (0 <= r && r < b) : (b < r && r <= 0))
-  # So, r is always between 0 and b.
-  it "returns an Array containing quotient and modulus obtained from dividing self by the given argument" do
-    @bignum.divmod(4).should == [2305843009213693965, 3]
-    @bignum.divmod(13).should == [709490156681136604, 11]
-
-    @bignum.divmod(4.5).should == [2049638230412172288, 3.5]
-
-    not_supported_on :opal do
-      @bignum.divmod(4.0).should == [2305843009213693952, 0.0]
-      @bignum.divmod(13.0).should == [709490156681136640, 8.0]
-
-      @bignum.divmod(2.0).should == [4611686018427387904, 0.0]
-    end
-
-    @bignum.divmod(bignum_value).should == [1, 55]
-
-    (-(10**50)).divmod(-(10**40 + 1)).should == [9999999999, -9999999999999999999999999999990000000001]
-    (10**50).divmod(10**40 + 1).should == [9999999999, 9999999999999999999999999999990000000001]
-
-    (-10**50).divmod(10**40 + 1).should == [-10000000000, 10000000000]
-    (10**50).divmod(-(10**40 + 1)).should == [-10000000000, -10000000000]
-  end
-
-  describe "with q = floor(x/y), a = q*b + r," do
-    it "returns [q,r] when a < 0, b > 0 and |a| < b" do
-      a = -@bignum + 1
-      b =  @bignum
-      a.divmod(b).should == [-1, 1]
-    end
-
-    it "returns [q,r] when a > 0, b < 0 and a > |b|" do
-      b = -@bignum + 1
-      a =  @bignum
-      a.divmod(b).should == [-2, -@bignum + 2]
-    end
-
-    it "returns [q,r] when a > 0, b < 0 and a < |b|" do
-      a =  @bignum - 1
-      b = -@bignum
-      a.divmod(b).should == [-1, -1]
-    end
-
-    it "returns [q,r] when a < 0, b < 0 and |a| < |b|" do
-      a = -@bignum + 1
-      b = -@bignum
-      a.divmod(b).should == [0, -@bignum + 1]
-    end
-  end
-
-  it "raises a ZeroDivisionError when the given argument is 0" do
-    lambda { @bignum.divmod(0) }.should raise_error(ZeroDivisionError)
-    lambda { (-@bignum).divmod(0) }.should raise_error(ZeroDivisionError)
-  end
-
-  # Behaviour established as correct in r23953
-  it "raises a FloatDomainError if other is NaN" do
-    lambda { @bignum.divmod(nan_value) }.should raise_error(FloatDomainError)
-  end
-
-  it "raises a ZeroDivisionError when the given argument is 0 and a Float" do
-    lambda { @bignum.divmod(0.0) }.should raise_error(ZeroDivisionError)
-    lambda { (-@bignum).divmod(0.0) }.should raise_error(ZeroDivisionError)
-  end
-
-  it "raises a TypeError when the given argument is not an Integer" do
-    lambda { @bignum.divmod(mock('10')) }.should raise_error(TypeError)
-    lambda { @bignum.divmod("10") }.should raise_error(TypeError)
-    lambda { @bignum.divmod(:symbol) }.should raise_error(TypeError)
-  end
-end

spec/ruby/core/bignum/element_reference_spec.rb

@@ -1,30 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#[]" do
-  before :each do
-    @bignum = bignum_value(4996)
-  end
-
-  it "returns the nth bit in the binary representation of self" do
-    @bignum[2].should == 1
-    @bignum[9.2].should == 1
-    @bignum[21].should == 0
-    @bignum[0xffffffff].should == 0
-    @bignum[-0xffffffff].should == 0
-  end
-
-  it "tries to convert the given argument to an Integer using #to_int" do
-    @bignum[1.3].should == @bignum[1]
-
-    (obj = mock('2')).should_receive(:to_int).at_least(1).and_return(2)
-    @bignum[obj].should == 1
-  end
-
-  it "raises a TypeError when the given argument can't be converted to Integer" do
-    obj = mock('asdf')
-    lambda { @bignum[obj] }.should raise_error(TypeError)
-
-    obj.should_receive(:to_int).and_return("asdf")
-    lambda { @bignum[obj] }.should raise_error(TypeError)
-  end
-end

spec/ruby/core/bignum/eql_spec.rb

@@ -1,22 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#eql? when given a Bignum" do
-  it "returns true if the given argument has the same value" do
-    a = bignum_value(13)
-    a.should eql(bignum_value(13))
-    (-a).should eql(-bignum_value(13))
-  end
-end
-
-describe "Bignum#eql? when given a non-Bignum" do
-  it "returns false" do
-    a = bignum_value(13)
-    a.should_not eql(a.to_f)
-
-    a.should_not eql(2)
-    a.should_not eql(3.14)
-    a.should_not eql(:symbol)
-    a.should_not eql("String")
-    a.should_not eql(mock('str'))
-  end
-end

spec/ruby/core/bignum/equal_value_spec.rb

@@ -1,6 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../shared/equal', __FILE__)
-
-describe "Bignum#==" do
-  it_behaves_like :bignum_equal, :==
-end

spec/ruby/core/bignum/even_spec.rb

@@ -1,19 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#even?" do
-  it "returns true if self is even and positive" do
-    (10000**10).even?.should be_true
-  end
-
-  it "returns true if self is even and negative" do
-    (-10000**10).even?.should be_true
-  end
-
-  it "returns false if self is odd and positive" do
-    (9879**976).even?.should be_false
-  end
-
-  it "returns false if self is odd and negative" do
-    (-9879**976).even?.should be_false
-  end
-end

spec/ruby/core/bignum/exponent_spec.rb

@@ -1,29 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#**" do
-  before :each do
-    @bignum = bignum_value(47)
-  end
-
-  it "returns self raised to other power" do
-    (@bignum ** 4).should == 7237005577332262361485077344629993318496048279512298547155833600056910050625
-    (@bignum ** 1.2).should be_close(57262152889751597425762.57804, TOLERANCE)
-  end
-
-  it "raises a TypeError when given a non-Integer" do
-    lambda { @bignum ** mock('10') }.should raise_error(TypeError)
-    lambda { @bignum ** "10" }.should raise_error(TypeError)
-    lambda { @bignum ** :symbol }.should raise_error(TypeError)
-  end
-
-  it "switch to a Float when the values is too big" do
-    flt = (@bignum ** @bignum)
-    flt.should be_kind_of(Float)
-    flt.infinite?.should == 1
-  end
-
-  it "returns a complex number when negative and raised to a fractional power" do
-    ((-@bignum) ** (1.0/3))      .should be_close(Complex(1048576,1816186.907597341), TOLERANCE)
-    ((-@bignum) ** Rational(1,3)).should be_close(Complex(1048576,1816186.907597341), TOLERANCE)
-  end
-end

spec/ruby/core/bignum/fdiv_spec.rb

@@ -1,5 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#fdiv" do
-  it "needs to be reviewed for spec completeness"
-end

spec/ruby/core/bignum/gt_spec.rb

@@ -1,20 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#>" do
-  before :each do
-    @bignum = bignum_value(732)
-  end
-
-  it "returns true if self is greater than the given argument" do
-    (@bignum > (@bignum - 1)).should == true
-    (@bignum > 14.6).should == true
-    (@bignum > 10).should == true
-
-    (@bignum > (@bignum + 500)).should == false
-  end
-
-  it "raises an ArgumentError when given a non-Integer" do
-    lambda { @bignum > "4" }.should raise_error(ArgumentError)
-    lambda { @bignum > mock('str') }.should raise_error(ArgumentError)
-  end
-end

spec/ruby/core/bignum/gte_spec.rb

@@ -1,19 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#>=" do
-  before :each do
-    @bignum = bignum_value(14)
-  end
-
-  it "returns true if self is greater than or equal to other" do
-    (@bignum >= @bignum).should == true
-    (@bignum >= (@bignum + 2)).should == false
-    (@bignum >= 5664.2).should == true
-    (@bignum >= 4).should == true
-  end
-
-  it "raises an ArgumentError when given a non-Integer" do
-    lambda { @bignum >= "4" }.should raise_error(ArgumentError)
-    lambda { @bignum >= mock('str') }.should raise_error(ArgumentError)
-  end
-end

spec/ruby/core/bignum/hash_spec.rb

@@ -1,12 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#hash" do
-  it "is provided" do
-    bignum_value.respond_to?(:hash).should == true
-  end
-
-  it "is stable" do
-    bignum_value.hash.should == bignum_value.hash
-    bignum_value.hash.should_not == bignum_value(1).hash
-  end
-end

spec/ruby/core/bignum/left_shift_spec.rb

@@ -1,73 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#<< with n << m" do
-  before :each do
-    @bignum = bignum_value * 16
-  end
-
-  it "returns n shifted left m bits when n > 0, m > 0" do
-    (@bignum << 4).should == 2361183241434822606848
-  end
-
-  it "returns n shifted left m bits when n < 0, m > 0" do
-    (-@bignum << 9).should == -75557863725914323419136
-  end
-
-  it "returns n shifted right m bits when n > 0, m < 0" do
-    (@bignum << -1).should == 73786976294838206464
-  end
-
-  it "returns n shifted right m bits when n < 0, m < 0" do
-    (-@bignum << -2).should == -36893488147419103232
-  end
-
-  it "returns n when n > 0, m == 0" do
-    (@bignum << 0).should == @bignum
-  end
-
-  it "returns n when n < 0, m == 0" do
-    (-@bignum << 0).should == -@bignum
-  end
-
-  it "returns 0 when m < 0 and m == p where 2**p > n >= 2**(p-1)" do
-    (@bignum << -68).should == 0
-  end
-
-  it "returns 0 when m < 0 and m is a Bignum" do
-    (@bignum << -bignum_value).should == 0
-  end
-
-  it "returns a Fixnum == fixnum_max when (fixnum_max * 2) << -1 and n > 0" do
-    result = (fixnum_max * 2) << -1
-    result.should be_an_instance_of(Fixnum)
-    result.should == fixnum_max
-  end
-
-  it "returns a Fixnum == fixnum_min when (fixnum_min * 2) << -1 and n < 0" do
-    result = (fixnum_min * 2) << -1
-    result.should be_an_instance_of(Fixnum)
-    result.should == fixnum_min
-  end
-
-  it "calls #to_int to convert the argument to an Integer" do
-    obj = mock("4")
-    obj.should_receive(:to_int).and_return(4)
-
-    (@bignum << obj).should == 2361183241434822606848
-  end
-
-  it "raises a TypeError when #to_int does not return an Integer" do
-    obj = mock("a string")
-    obj.should_receive(:to_int).and_return("asdf")
-
-    lambda { @bignum << obj }.should raise_error(TypeError)
-  end
-
-  it "raises a TypeError when passed nil" do
-    lambda { @bignum << nil }.should raise_error(TypeError)
-  end
-
-  it "raises a TypeError when passed a String" do
-    lambda { @bignum << "4" }.should raise_error(TypeError)
-  end
-end

spec/ruby/core/bignum/lt_spec.rb

@@ -1,22 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#<" do
-  before :each do
-    @bignum = bignum_value(32)
-  end
-
-  it "returns true if self is less than the given argument" do
-    (@bignum < @bignum + 1).should == true
-    (-@bignum < -(@bignum - 1)).should == true
-
-    (@bignum < 1).should == false
-    (@bignum < 5).should == false
-
-    (@bignum < 4.999).should == false
-  end
-
-  it "raises an ArgumentError when given a non-Integer" do
-    lambda { @bignum < "4" }.should raise_error(ArgumentError)
-    lambda { @bignum < mock('str') }.should raise_error(ArgumentError)
-  end
-end

spec/ruby/core/bignum/lte_spec.rb

@@ -1,24 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#<=" do
-  before :each do
-    @bignum = bignum_value(39)
-  end
-
-  it "returns true if self is less than or equal to other" do
-    (@bignum <= @bignum).should == true
-    (-@bignum <= -(@bignum - 1)).should == true
-
-    (@bignum <= 4.999).should == false
-  end
-
-  it "returns false if compares with near float" do
-    (@bignum <= (@bignum + 0.0)).should == false
-    (@bignum <= (@bignum + 0.5)).should == false
-  end
-
-  it "raises an ArgumentError when given a non-Integer" do
-    lambda { @bignum <= "4" }.should raise_error(ArgumentError)
-    lambda { @bignum <= mock('str') }.should raise_error(ArgumentError)
-  end
-end

spec/ruby/core/bignum/magnitude_spec.rb

@@ -1,6 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../shared/abs', __FILE__)
-
-describe "Bignum#magnitude" do
-  it_behaves_like(:bignum_abs, :magnitude)
-end

spec/ruby/core/bignum/minus_spec.rb

@@ -1,19 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#-" do
-  before :each do
-    @bignum = bignum_value(314)
-  end
-
-  it "returns self minus the given Integer" do
-    (@bignum - 9).should == 9223372036854776113
-    (@bignum - 12.57).should be_close(9223372036854776109.43, TOLERANCE)
-    (@bignum - bignum_value(42)).should == 272
-  end
-
-  it "raises a TypeError when given a non-Integer" do
-    lambda { @bignum - mock('10') }.should raise_error(TypeError)
-    lambda { @bignum - "10" }.should raise_error(TypeError)
-    lambda { @bignum - :symbol }.should raise_error(TypeError)
-  end
-end

spec/ruby/core/bignum/modulo_spec.rb

@@ -1,10 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../shared/modulo', __FILE__)
-
-describe "Bignum#%" do
-  it_behaves_like(:bignum_modulo, :%)
-end
-
-describe "Bignum#modulo" do
-  it_behaves_like(:bignum_modulo, :modulo)
-end

spec/ruby/core/bignum/multiply_spec.rb

@@ -1,20 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#*" do
-  before :each do
-    @bignum = bignum_value(772)
-  end
-
-  it "returns self multiplied by the given Integer" do
-    (@bignum * (1/bignum_value(0xffff).to_f)).should be_close(1.0, TOLERANCE)
-    (@bignum * (1/bignum_value(0xffff).to_f)).should be_close(1.0, TOLERANCE)
-    (@bignum * 10).should == 92233720368547765800
-    (@bignum * (@bignum - 40)).should == 85070591730234629737795195287525433200
-  end
-
-  it "raises a TypeError when given a non-Integer" do
-    lambda { @bignum * mock('10') }.should raise_error(TypeError)
-    lambda { @bignum * "10" }.should raise_error(TypeError)
-    lambda { @bignum * :symbol }.should raise_error(TypeError)
-  end
-end

spec/ruby/core/bignum/odd_spec.rb

@@ -1,19 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#odd?" do
-  it "returns true if self is odd and positive" do
-    (987279**19).odd?.should be_true
-  end
-
-  it "returns true if self is odd and negative" do
-    (-9873389**97).odd?.should be_true
-  end
-
-  it "returns false if self is even and positive" do
-    (10000000**10).odd?.should be_false
-  end
-
-  it "returns false if self is even and negative" do
-    (-1000000**100).odd?.should be_false
-  end
-end

spec/ruby/core/bignum/plus_spec.rb

@@ -1,19 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#+" do
-  before :each do
-    @bignum = bignum_value(76)
-  end
-
-  it "returns self plus the given Integer" do
-    (@bignum + 4).should == 9223372036854775888
-    (@bignum + 4.2).should be_close(9223372036854775888.2, TOLERANCE)
-    (@bignum + bignum_value(3)).should == 18446744073709551695
-  end
-
-  it "raises a TypeError when given a non-Integer" do
-    lambda { @bignum + mock('10') }.should raise_error(TypeError)
-    lambda { @bignum + "10" }.should raise_error(TypeError)
-    lambda { @bignum + :symbol}.should raise_error(TypeError)
-  end
-end

spec/ruby/core/bignum/remainder_spec.rb

@@ -1,21 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#remainder" do
-  it "returns the remainder of dividing self by other" do
-    a = bignum_value(79)
-    a.remainder(2).should == 1
-    a.remainder(97.345).should be_close(46.5674996147722, TOLERANCE)
-    a.remainder(bignum_value).should == 79
-  end
-
-  it "raises a ZeroDivisionError if other is zero and not a Float" do
-    lambda { bignum_value(66).remainder(0) }.should raise_error(ZeroDivisionError)
-  end
-
-  it "does raises ZeroDivisionError if other is zero and a Float" do
-    a = bignum_value(7)
-    b = bignum_value(32)
-    lambda { a.remainder(0.0) }.should raise_error(ZeroDivisionError)
-    lambda { b.remainder(-0.0) }.should raise_error(ZeroDivisionError)
-  end
-end

spec/ruby/core/bignum/right_shift_spec.rb

@@ -1,99 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#>> with n >> m" do
-  before :each do
-    @bignum = bignum_value * 16
-  end
-
-  it "returns n shifted right m bits when n > 0, m > 0" do
-    (@bignum >> 1).should == 73786976294838206464
-  end
-
-  it "returns n shifted right m bits when n < 0, m > 0" do
-    (-@bignum >> 2).should == -36893488147419103232
-  end
-
-  it "respects twos complement signed shifting" do
-    # This explicit left hand value is important because it is the
-    # exact bit pattern that matters, so it's important it's right
-    # here to show the significance.
-    #
-
-    (-42949672980000000000000 >> 14).should == -2621440001220703125
-    (-42949672980000000000001 >> 14).should == -2621440001220703126
-    # Note the off by one -------------------- ^^^^^^^^^^^^^^^^^^^^
-    # This is because even though we discard the lowest bit, in twos
-    # complement it would influence the bits to the left of it.
-
-    (-42949672980000000000000 >> 15).should == -1310720000610351563
-    (-42949672980000000000001 >> 15).should == -1310720000610351563
-
-    (-0xfffffffffffffffff >> 32).should == -68719476736
-  end
-
-  it "respects twos complement signed shifting for very large values" do
-    giant = 42949672980000000000000000000000000000000000000000000000000000000000000000000000000000000000
-    neg = -giant
-
-    (giant >> 84).should == 2220446050284288846538547929770901490087453566957265138626098632812
-    (neg >> 84).should == -2220446050284288846538547929770901490087453566957265138626098632813
-  end
-
-  it "returns n shifted left m bits when  n > 0, m < 0" do
-    (@bignum >> -2).should == 590295810358705651712
-  end
-
-  it "returns n shifted left m bits when  n < 0, m < 0" do
-    (-@bignum >> -3).should == -1180591620717411303424
-  end
-
-  it "returns n when n > 0, m == 0" do
-    (@bignum >> 0).should == @bignum
-  end
-
-  it "returns n when n < 0, m == 0" do
-    (-@bignum >> 0).should == -@bignum
-  end
-
-  it "returns 0 when m > 0 and m == p where 2**p > n >= 2**(p-1)" do
-    (@bignum >> 68).should == 0
-  end
-
-  it "returns 0 when m is a Bignum" do
-    (@bignum >> bignum_value).should == 0
-  end
-
-  it "returns a Fixnum == fixnum_max when (fixnum_max * 2) >> 1 and n > 0" do
-    result = (fixnum_max * 2) >> 1
-    result.should be_an_instance_of(Fixnum)
-    result.should == fixnum_max
-  end
-
-  it "returns a Fixnum == fixnum_min when (fixnum_min * 2) >> 1 and n < 0" do
-    result = (fixnum_min * 2) >> 1
-    result.should be_an_instance_of(Fixnum)
-    result.should == fixnum_min
-  end
-
-  it "calls #to_int to convert the argument to an Integer" do
-    obj = mock("2")
-    obj.should_receive(:to_int).and_return(2)
-
-    (@bignum >> obj).should == 36893488147419103232
-  end
-
-  it "raises a TypeError when #to_int does not return an Integer" do
-    obj = mock("a string")
-    obj.should_receive(:to_int).and_return("asdf")
-
-    lambda { @bignum >> obj }.should raise_error(TypeError)
-  end
-
-  it "raises a TypeError when passed nil" do
-    lambda { @bignum >> nil }.should raise_error(TypeError)
-  end
-
-  it "raises a TypeError when passed a String" do
-    lambda { @bignum >> "4" }.should raise_error(TypeError)
-  end
-end

spec/ruby/core/bignum/shared/abs.rb

@@ -1,6 +0,0 @@
-describe :bignum_abs, shared: true do
-  it "returns the absolute value" do
-    bignum_value(39).send(@method).should == 9223372036854775847
-    (-bignum_value(18)).send(@method).should == 9223372036854775826
-  end
-end

spec/ruby/core/bignum/shared/divide.rb

@@ -1,27 +0,0 @@
-describe :bignum_divide, shared: true do
-  before :each do
-    @bignum = bignum_value(88)
-  end
-
-  it "returns self divided by other" do
-    @bignum.send(@method, 4).should == 2305843009213693974
-
-    @bignum.send(@method, bignum_value(2)).should be_close(1, TOLERANCE)
-
-    (-(10**50)).send(@method, -(10**40 + 1)).should == 9999999999
-    (10**50).send(@method, 10**40 + 1).should == 9999999999
-
-    (-10**50).send(@method, 10**40 + 1).should == -10000000000
-    (10**50).send(@method, -(10**40 + 1)).should == -10000000000
-  end
-
-  it "raises a ZeroDivisionError if other is zero and not a Float" do
-    lambda { @bignum.send(@method, 0) }.should raise_error(ZeroDivisionError)
-  end
-
-  it "raises a TypeError when given a non-Integer" do
-    lambda { @bignum.send(@method, mock('10')) }.should raise_error(TypeError)
-    lambda { @bignum.send(@method, "2") }.should raise_error(TypeError)
-    lambda { @bignum.send(@method, :symbol) }.should raise_error(TypeError)
-  end
-end

spec/ruby/core/bignum/shared/equal.rb

@@ -1,31 +0,0 @@
-describe :bignum_equal, shared: true do
-  before :each do
-    @bignum = bignum_value
-  end
-
-  it "returns true if self has the same value as the given argument" do
-    @bignum.send(@method, @bignum).should == true
-    @bignum.send(@method, @bignum.to_f).should == true
-
-    @bignum.send(@method, @bignum + 1).should == false
-    (@bignum + 1).send(@method, @bignum).should == false
-
-    @bignum.send(@method, 9).should == false
-    @bignum.send(@method, 9.01).should == false
-
-    @bignum.send(@method, bignum_value(10)).should == false
-  end
-
-  it "calls 'other == self' if the given argument is not an Integer" do
-    obj = mock('not integer')
-    obj.should_receive(:==).and_return(true)
-    @bignum.send(@method, obj).should == true
-  end
-
-  it "returns the result of 'other == self' as a boolean" do
-    obj = mock('not integer')
-    obj.should_receive(:==).exactly(2).times.and_return("woot", nil)
-    @bignum.send(@method, obj).should == true
-    @bignum.send(@method, obj).should == false
-  end
-end

spec/ruby/core/bignum/shared/modulo.rb

@@ -1,29 +0,0 @@
-describe :bignum_modulo, shared: true do
-  before :each do
-    @bignum = bignum_value
-  end
-
-  it "returns the modulus obtained from dividing self by the given argument" do
-    @bignum.send(@method, 5).should == 3
-    @bignum.send(@method, -5).should == -2
-    @bignum.send(@method, -100).should == -92
-    @bignum.send(@method, 2.22).should be_close(0.780180180180252, TOLERANCE)
-    @bignum.send(@method, bignum_value(10)).should == 9223372036854775808
-  end
-
-  it "raises a ZeroDivisionError when the given argument is 0" do
-    lambda { @bignum.send(@method, 0) }.should raise_error(ZeroDivisionError)
-    lambda { (-@bignum).send(@method, 0) }.should raise_error(ZeroDivisionError)
-  end
-
-  it "raises a ZeroDivisionError when the given argument is 0 and a Float" do
-    lambda { @bignum.send(@method, 0.0) }.should raise_error(ZeroDivisionError)
-    lambda { -@bignum.send(@method, 0.0) }.should raise_error(ZeroDivisionError)
-  end
-
-  it "raises a TypeError when given a non-Integer" do
-    lambda { @bignum.send(@method, mock('10')) }.should raise_error(TypeError)
-    lambda { @bignum.send(@method, "10") }.should raise_error(TypeError)
-    lambda { @bignum.send(@method, :symbol) }.should raise_error(TypeError)
-  end
-end

spec/ruby/core/bignum/size_spec.rb

@@ -1,16 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#size" do
-  it "returns the number of bytes required to hold the unsigned bignum data" do
-    # that is, n such that 256 * n <= val.abs < 256 * (n+1)
-    (256**7).size.should == 8
-    (256**8).size.should == 9
-    (256**9).size.should == 10
-    (256**10).size.should == 11
-    (256**10-1).size.should == 10
-    (256**11).size.should == 12
-    (256**12).size.should == 13
-    (256**20-1).size.should == 20
-    (256**40-1).size.should == 40
-  end
-end

spec/ruby/core/bignum/to_f_spec.rb

@@ -1,13 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#to_f" do
-  it "returns self converted to a Float" do
-    bignum_value(0x4000_0aa0_0bb0_0000).to_f.should eql(13_835_069_737_789_292_544.00)
-    bignum_value(0x8000_0000_0000_0ccc).to_f.should eql(18_446_744_073_709_555_712.00)
-    (-bignum_value(99)).to_f.should eql(-9_223_372_036_854_775_808.00)
-  end
-
-  it "converts number close to Float::MAX without exceeding MAX or producing NaN" do
-    (10**308).to_f.should == 10.0 ** 308
-  end
-end

spec/ruby/core/bignum/to_s_spec.rb

@@ -1,48 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#to_s when given a base" do
-  it "returns self converted to a String using the given base" do
-    a = 2**64
-    a.to_s(2).should == "10000000000000000000000000000000000000000000000000000000000000000"
-    a.to_s(8).should == "2000000000000000000000"
-    a.to_s(16).should == "10000000000000000"
-    a.to_s(32).should == "g000000000000"
-  end
-
-  it "raises an ArgumentError if the base is less than 2 or higher than 36" do
-    lambda { 123.to_s(-1) }.should raise_error(ArgumentError)
-    lambda { 123.to_s(0) }.should raise_error(ArgumentError)
-    lambda { 123.to_s(1) }.should raise_error(ArgumentError)
-    lambda { 123.to_s(37) }.should raise_error(ArgumentError)
-  end
-end
-
-describe "Bignum#to_s when given no base" do
-  it "returns self converted to a String using base 10" do
-    bignum_value(9).to_s.should == "9223372036854775817"
-    bignum_value.to_s.should == "9223372036854775808"
-    (-bignum_value(675)).to_s.should == "-9223372036854776483"
-  end
-end
-
-with_feature :encoding do
-  describe "Bignum#to_s" do
-    before :each do
-      @internal = Encoding.default_internal
-    end
-
-    after :each do
-      Encoding.default_internal = @internal
-    end
-
-    it "returns a String in US-ASCII encoding when Encoding.default_internal is nil" do
-      Encoding.default_internal = nil
-      bignum_value.to_s.encoding.should equal(Encoding::US_ASCII)
-    end
-
-    it "returns a String in US-ASCII encoding when Encoding.default_internal is not nil" do
-      Encoding.default_internal = Encoding::IBM437
-      bignum_value.to_s.encoding.should equal(Encoding::US_ASCII)
-    end
-  end
-end

spec/ruby/core/bignum/uminus_spec.rb

@@ -1,11 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Bignum#-@" do
-  it "returns self as a negative value" do
-    bignum_value.send(:-@).should == -9223372036854775808
-    (-bignum_value).send(:-@).should == 9223372036854775808
-
-    bignum_value(921).send(:-@).should == -9223372036854776729
-    (-bignum_value(921).send(:-@)).should == 9223372036854776729
-  end
-end

spec/ruby/core/binding/clone_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/clone', __FILE__)
 
 describe "Binding#clone" do
-  it_behaves_like(:binding_clone, :clone)
+  it_behaves_like :binding_clone, :clone
 end

spec/ruby/core/binding/dup_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/clone', __FILE__)
 
 describe "Binding#dup" do
-  it_behaves_like(:binding_clone, :dup)
+  it_behaves_like :binding_clone, :dup
 end

spec/ruby/core/complex/abs2_spec.rb

@@ -1,5 +1,5 @@
 require File.expand_path('../../../shared/complex/abs2', __FILE__)
 
 describe "Complex#abs2" do
-  it_behaves_like(:complex_abs2, :abs2)
+  it_behaves_like :complex_abs2, :abs2
 end

spec/ruby/core/complex/abs_spec.rb

@@ -1,5 +1,5 @@
 require File.expand_path('../../../shared/complex/abs', __FILE__)
 
 describe "Complex#abs" do
-  it_behaves_like(:complex_abs, :abs)
+  it_behaves_like :complex_abs, :abs
 end

spec/ruby/core/complex/angle_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../../../spec_helper', __FILE__)
 require File.expand_path('../../../shared/complex/arg', __FILE__)
 
 describe "Complex#angle" do
-  it_behaves_like(:complex_arg, :angle)
+  it_behaves_like :complex_arg, :angle
 end

spec/ruby/core/complex/arg_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../../../spec_helper', __FILE__)
 require File.expand_path('../../../shared/complex/arg', __FILE__)
 
 describe "Complex#arg" do
-  it_behaves_like(:complex_arg, :arg)
+  it_behaves_like :complex_arg, :arg
 end

spec/ruby/core/complex/coerce_spec.rb

@@ -1,5 +1,5 @@
 require File.expand_path('../../../shared/complex/coerce', __FILE__)
 
 describe "Complex#coerce" do
-  it_behaves_like(:complex_coerce, :coerce)
+  it_behaves_like :complex_coerce, :coerce
 end

spec/ruby/core/complex/conj_spec.rb

@@ -2,5 +2,5 @@ require File.expand_path('../../../spec_helper', __FILE__)
 require File.expand_path('../../../shared/complex/conjugate', __FILE__)
 
 describe "Complex#conj" do
-  it_behaves_like(:complex_conjugate, :conj)
+  it_behaves_like :complex_conjugate, :conj
 end

spec/ruby/core/complex/conjugate_spec.rb

@@ -2,5 +2,5 @@ require File.expand_path('../../../spec_helper', __FILE__)
 require File.expand_path('../../../shared/complex/conjugate', __FILE__)
 
 describe "Complex#conjugate" do
-  it_behaves_like(:complex_conjugate, :conjugate)
+  it_behaves_like :complex_conjugate, :conjugate
 end

spec/ruby/core/complex/denominator_spec.rb

@@ -1,5 +1,5 @@
 require File.expand_path('../../../shared/complex/denominator', __FILE__)
 
 describe "Complex#denominator" do
-  it_behaves_like(:complex_denominator, :denominator)
+  it_behaves_like :complex_denominator, :denominator
 end

spec/ruby/core/complex/hash_spec.rb

@@ -1,6 +1,16 @@
 require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../../../shared/complex/hash', __FILE__)
 
 describe "Complex#hash" do
-  it_behaves_like(:complex_hash, :hash)
+  it "is static" do
+    Complex(1).hash.should == Complex(1).hash
+    Complex(1, 0).hash.should == Complex(1).hash
+    Complex(1, 1).hash.should == Complex(1, 1).hash
+  end
+
+  it "is different for different instances" do
+    Complex(1, 2).hash.should_not == Complex(1, 1).hash
+    Complex(2, 1).hash.should_not == Complex(1, 1).hash
+
+    Complex(1, 2).hash.should_not == Complex(2, 1).hash
+  end
 end

spec/ruby/core/complex/imag_spec.rb

@@ -1,5 +1,5 @@
 require File.expand_path('../../../shared/complex/image', __FILE__)
 
 describe "Complex#imag" do
-  it_behaves_like(:complex_image, :imag)
+  it_behaves_like :complex_image, :imag
 end

spec/ruby/core/complex/inspect_spec.rb

@@ -1,5 +1,5 @@
 require File.expand_path('../../../shared/complex/inspect', __FILE__)
 
 describe "Complex#inspect" do
-  it_behaves_like(:complex_inspect, :inspect)
+  it_behaves_like :complex_inspect, :inspect
 end

spec/ruby/core/complex/magnitude_spec.rb

@@ -1,5 +1,5 @@
 require File.expand_path('../../../shared/complex/abs', __FILE__)
 
 describe "Complex#magnitude" do
-  it_behaves_like(:complex_abs, :magnitude)
+  it_behaves_like :complex_abs, :magnitude
 end

spec/ruby/core/complex/numerator_spec.rb

@@ -1,5 +1,5 @@
 require File.expand_path('../../../shared/complex/numerator', __FILE__)
 
 describe "Complex#numerator" do
-  it_behaves_like(:complex_numerator, :numerator)
+  it_behaves_like :complex_numerator, :numerator
 end

spec/ruby/core/complex/polar_spec.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../../../shared/complex/polar', __FILE__)
 
 describe "Complex.polar" do
-  it_behaves_like(:complex_polar_class, :polar)
+  it_behaves_like :complex_polar_class, :polar
 
   it "raises a TypeError when given non real arguments" do
     lambda{ Complex.polar(nil)      }.should raise_error(TypeError)
@@ -10,5 +10,5 @@ describe "Complex.polar" do
 end
 
 describe "Complex#polar" do
-  it_behaves_like(:complex_polar, :polar)
+  it_behaves_like :complex_polar, :polar
 end

spec/ruby/core/complex/real_spec.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../../../shared/complex/real', __FILE__)
 
 describe "Complex#real" do
-  it_behaves_like(:complex_real, :real)
+  it_behaves_like :complex_real, :real
 end
 
 describe "Complex#real?" do

spec/ruby/core/complex/rect_spec.rb

@@ -1,9 +1,9 @@
 require File.expand_path('../../../shared/complex/rect', __FILE__)
 
 describe "Complex#rect" do
-  it_behaves_like(:complex_rect, :rect)
+  it_behaves_like :complex_rect, :rect
 end
 
 describe "Complex.rect" do
-  it_behaves_like(:complex_rect_class, :rect)
+  it_behaves_like :complex_rect_class, :rect
 end

spec/ruby/core/complex/rectangular_spec.rb

@@ -1,9 +1,9 @@
 require File.expand_path('../../../shared/complex/rect', __FILE__)
 
 describe "Complex#rectangular" do
-  it_behaves_like(:complex_rect, :rectangular)
+  it_behaves_like :complex_rect, :rectangular
 end
 
 describe "Complex.rectangular" do
-  it_behaves_like(:complex_rect_class, :rectangular)
+  it_behaves_like :complex_rect_class, :rectangular
 end

spec/ruby/core/complex/to_s_spec.rb

@@ -1,5 +1,5 @@
 require File.expand_path('../../../shared/complex/to_s', __FILE__)
 
 describe "Complex#to_s" do
-  it_behaves_like(:complex_to_s, :to_s)
+  it_behaves_like :complex_to_s, :to_s
 end

spec/ruby/core/dir/exist_spec.rb

@@ -11,5 +11,5 @@ describe "Dir.exist?" do
     DirSpecs.delete_mock_dirs
   end
 
-  it_behaves_like(:dir_exist, :exist?)
+  it_behaves_like :dir_exist, :exist?
 end

spec/ruby/core/dir/exists_spec.rb

@@ -11,5 +11,5 @@ describe "Dir.exists?" do
     DirSpecs.delete_mock_dirs
   end
 
-  it_behaves_like(:dir_exist, :exists?)
+  it_behaves_like :dir_exist, :exists?
 end

spec/ruby/core/dir/path_spec.rb

@@ -11,5 +11,5 @@ describe "Dir#path" do
     DirSpecs.delete_mock_dirs
   end
 
-  it_behaves_like(:dir_path, :path)
+  it_behaves_like :dir_path, :path
 end

spec/ruby/core/dir/to_path_spec.rb

@@ -11,5 +11,5 @@ describe "Dir#to_path" do
     DirSpecs.delete_mock_dirs
   end
 
-  it_behaves_like(:dir_path, :to_path)
+  it_behaves_like :dir_path, :to_path
 end

spec/ruby/core/encoding/name_spec.rb

@@ -2,6 +2,6 @@ require File.expand_path('../shared/name', __FILE__)
 
 with_feature :encoding do
   describe "Encoding#name" do
-    it_behaves_like(:encoding_name, :name)
+    it_behaves_like :encoding_name, :name
   end
 end

spec/ruby/core/encoding/to_s_spec.rb

@@ -2,6 +2,6 @@ require File.expand_path('../shared/name', __FILE__)
 
 with_feature :encoding do
   describe "Encoding#to_s" do
-    it_behaves_like(:encoding_name, :to_s)
+    it_behaves_like :encoding_name, :to_s
   end
 end

spec/ruby/core/enumerable/collect_concat_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/collect_concat', __FILE__)
 
 describe "Enumerable#collect_concat" do
-  it_behaves_like(:enumerable_collect_concat , :collect_concat)
+  it_behaves_like :enumerable_collect_concat , :collect_concat
 end

spec/ruby/core/enumerable/collect_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/collect', __FILE__)
 
 describe "Enumerable#collect" do
-  it_behaves_like(:enumerable_collect , :collect)
+  it_behaves_like :enumerable_collect , :collect
 end

spec/ruby/core/enumerable/detect_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/find', __FILE__)
 
 describe "Enumerable#detect" do
-  it_behaves_like(:enumerable_find , :detect)
+  it_behaves_like :enumerable_find , :detect
 end

spec/ruby/core/enumerable/entries_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/entries', __FILE__)
 
 describe "Enumerable#entries" do
-  it_behaves_like(:enumerable_entries , :entries)
+  it_behaves_like :enumerable_entries , :entries
 end

spec/ruby/core/enumerable/find_all_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/find_all', __FILE__)
 
 describe "Enumerable#find_all" do
-  it_behaves_like(:enumerable_find_all , :find_all)
+  it_behaves_like :enumerable_find_all , :find_all
 end

spec/ruby/core/enumerable/find_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/find', __FILE__)
 
 describe "Enumerable#find" do
-  it_behaves_like(:enumerable_find , :find)
+  it_behaves_like :enumerable_find , :find
 end

spec/ruby/core/enumerable/flat_map_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/collect_concat', __FILE__)
 
 describe "Enumerable#flat_map" do
-  it_behaves_like(:enumerable_collect_concat , :flat_map)
+  it_behaves_like :enumerable_collect_concat , :flat_map
 end

spec/ruby/core/enumerable/include_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/include', __FILE__)
 
 describe "Enumerable#include?" do
-  it_behaves_like(:enumerable_include, :include?)
+  it_behaves_like :enumerable_include, :include?
 end

spec/ruby/core/enumerable/map_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/collect', __FILE__)
 
 describe "Enumerable#map" do
-  it_behaves_like(:enumerable_collect , :map)
+  it_behaves_like :enumerable_collect , :map
 end

spec/ruby/core/enumerable/member_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/include', __FILE__)
 
 describe "Enumerable#member?" do
-  it_behaves_like(:enumerable_include, :member?)
+  it_behaves_like :enumerable_include, :member?
 end

spec/ruby/core/enumerable/select_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/find_all', __FILE__)
 
 describe "Enumerable#select" do
-  it_behaves_like(:enumerable_find_all , :select)
+  it_behaves_like :enumerable_find_all , :select
 end

spec/ruby/core/enumerable/to_a_spec.rb

@@ -3,5 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/entries', __FILE__)
 
 describe "Enumerable#to_a" do
-  it_behaves_like(:enumerable_entries , :to_a)
+  it_behaves_like :enumerable_entries , :to_a
 end

spec/ruby/core/enumerator/each_spec.rb

@@ -1,5 +1,5 @@
 require File.expand_path('../../../shared/enumerator/each', __FILE__)
 
 describe "Enumerator#each" do
-  it_behaves_like(:enum_each, :each)
+  it_behaves_like :enum_each, :each
 end

spec/ruby/core/enumerator/each_with_index_spec.rb

@@ -3,8 +3,8 @@ require File.expand_path('../../../shared/enumerator/with_index', __FILE__)
 require File.expand_path('../../enumerable/shared/enumeratorized', __FILE__)
 
 describe "Enumerator#each_with_index" do
-  it_behaves_like(:enum_with_index, :each_with_index)
+  it_behaves_like :enum_with_index, :each_with_index
-  it_behaves_like(:enumeratorized_with_origin_size, :each_with_index, [1,2,3].select)
+  it_behaves_like :enumeratorized_with_origin_size, :each_with_index, [1,2,3].select
 
   it "returns a new Enumerator when no block is given" do
     enum1 = [1,2,3].select

spec/ruby/core/enumerator/inject_spec.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../../../shared/enumerator/each', __FILE__)
 
 describe "Enumerator#inject" do
-  it_behaves_like(:enum_each, :each)
+  it_behaves_like :enum_each, :each
 
   it "works when chained against each_with_index" do
     passed_values = []

spec/ruby/core/enumerator/lazy/chunk_spec.rb

@@ -0,0 +1,71 @@
+# -*- encoding: us-ascii -*-
+
+require File.expand_path('../../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Enumerator::Lazy#chunk" do
+
+  before :each do
+    @yieldsmixed = EnumeratorLazySpecs::YieldsMixed.new.to_enum.lazy
+    @eventsmixed = EnumeratorLazySpecs::EventsMixed.new.to_enum.lazy
+    ScratchPad.record []
+  end
+
+  after :each do
+    ScratchPad.clear
+  end
+
+  it "returns a new instance of Enumerator::Lazy" do
+    ret = @yieldsmixed.chunk {}
+    ret.should be_an_instance_of(Enumerator::Lazy)
+    ret.should_not equal(@yieldsmixed)
+  end
+
+  it "sets #size to nil" do
+    Enumerator::Lazy.new(Object.new, 100) {}.chunk { |v| v }.size.should == nil
+  end
+
+  ruby_version_is ""..."2.4" do
+    it "raises an ArgumentError if called without a block" do
+      lambda do
+        @yieldsmixed.chunk
+      end.should raise_error(ArgumentError)
+    end
+  end
+
+  ruby_version_is "2.4" do
+    it "returns an Enumerator if called without a block" do
+      chunk = @yieldsmixed.chunk
+      chunk.should be_an_instance_of(Enumerator::Lazy)
+
+      res = chunk.each { |v| true }.force
+      res.should == [[true, EnumeratorLazySpecs::YieldsMixed.gathered_yields]]
+    end
+  end
+
+  describe "when the returned lazy enumerator is evaluated by Enumerable#first" do
+    it "stops after specified times" do
+      first_two = (0..Float::INFINITY).lazy.chunk { |n| n.even? }.first(2)
+      first_two.should == [[true, [0]], [false, [1]]]
+    end
+  end
+
+  it "calls the block with gathered values when yield with multiple arguments" do
+    yields = []
+    @yieldsmixed.chunk { |v| yields << v; true }.force
+    yields.should == EnumeratorLazySpecs::YieldsMixed.gathered_yields
+  end
+
+  describe "on a nested Lazy" do
+    it "sets #size to nil" do
+      Enumerator::Lazy.new(Object.new, 100) {}.take(20).chunk { |v| v }.size.should == nil
+    end
+
+    describe "when the returned lazy enumerator is evaluated by Enumerable#first" do
+      it "stops after specified times" do
+        remains_lazy = (0..Float::INFINITY).lazy.chunk { |n| n }
+        remains_lazy.chunk { |n| n }.first(2).size.should == 2
+      end
+    end
+  end
+end

spec/ruby/core/enumerator/new_spec.rb

@@ -2,5 +2,5 @@ require File.expand_path('../../../spec_helper', __FILE__)
 require File.expand_path('../../../shared/enumerator/new', __FILE__)
 
 describe "Enumerator.new" do
-  it_behaves_like(:enum_new, :new)
+  it_behaves_like :enum_new, :new
 end