Move spec/rubyspec to spec/ruby for consistency

* Other ruby implementations use the spec/ruby directory.
  [Misc #13792] [ruby-core:82287]

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

spec/ruby/core/comparable/between_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Comparable#between?" do
+  it "returns true if self is greater than or equal to the first and less than or equal to the second argument" do
+    a = ComparableSpecs::Weird.new(-1)
+    b = ComparableSpecs::Weird.new(0)
+    c = ComparableSpecs::Weird.new(1)
+    d = ComparableSpecs::Weird.new(2)
+
+    a.between?(a, a).should == true
+    a.between?(a, b).should == true
+    a.between?(a, c).should == true
+    a.between?(a, d).should == true
+    c.between?(c, d).should == true
+    d.between?(d, d).should == true
+    c.between?(a, d).should == true
+
+    a.between?(b, b).should == false
+    a.between?(b, c).should == false
+    a.between?(b, d).should == false
+    c.between?(a, a).should == false
+    c.between?(a, b).should == false
+  end
+end

spec/ruby/core/comparable/clamp_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+ruby_version_is '2.4' do
+  describe 'Comparable#clamp' do
+    it 'raises an Argument error unless given 2 parameters' do
+      c = ComparableSpecs::Weird.new(0)
+      lambda { c.clamp(c) }.should raise_error(ArgumentError)
+      lambda { c.clamp(c, c, c) }.should raise_error(ArgumentError)
+    end
+
+    it 'raises an Argument error unless the 2 parameters are correctly ordered' do
+      one = ComparableSpecs::WithOnlyCompareDefined.new(1)
+      two = ComparableSpecs::WithOnlyCompareDefined.new(2)
+      c = ComparableSpecs::Weird.new(3)
+
+      lambda { c.clamp(two, one) }.should raise_error(ArgumentError)
+      one.should_receive(:<=>).any_number_of_times.and_return(nil)
+      lambda { c.clamp(one, two) }.should raise_error(ArgumentError)
+    end
+
+    it 'returns self if within the given parameters' do
+      one = ComparableSpecs::WithOnlyCompareDefined.new(1)
+      two = ComparableSpecs::WithOnlyCompareDefined.new(2)
+      three = ComparableSpecs::WithOnlyCompareDefined.new(3)
+      c = ComparableSpecs::Weird.new(2)
+
+      c.clamp(one, two).should equal(c)
+      c.clamp(two, two).should equal(c)
+      c.clamp(one, three).should equal(c)
+      c.clamp(two, three).should equal(c)
+    end
+
+    it 'returns the min parameter if smaller than it' do
+      one = ComparableSpecs::WithOnlyCompareDefined.new(1)
+      two = ComparableSpecs::WithOnlyCompareDefined.new(2)
+      c = ComparableSpecs::Weird.new(0)
+
+      c.clamp(one, two).should equal(one)
+    end
+
+    it 'returns the max parameter if greater than it' do
+      one = ComparableSpecs::WithOnlyCompareDefined.new(1)
+      two = ComparableSpecs::WithOnlyCompareDefined.new(2)
+      c = ComparableSpecs::Weird.new(3)
+
+      c.clamp(one, two).should equal(two)
+    end
+  end
+end

spec/ruby/core/comparable/equal_value_spec.rb

@@ -0,0 +1,139 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Comparable#==" do
+  a = b = nil
+  before :each do
+    a = ComparableSpecs::Weird.new(0)
+    b = ComparableSpecs::Weird.new(10)
+  end
+
+  it "returns true if other is the same as self" do
+    (a == a).should == true
+    (b == b).should == true
+  end
+
+  it "calls #<=> on self with other and returns true if #<=> returns 0" do
+    a.should_receive(:<=>).once.and_return(0)
+    (a == b).should == true
+  end
+
+  it "calls #<=> on self with other and returns true if #<=> returns 0.0" do
+    a.should_receive(:<=>).once.and_return(0.0)
+    (a == b).should == true
+  end
+
+  it "returns false if calling #<=> on self returns a positive Integer" do
+    a.should_receive(:<=>).once.and_return(1)
+    (a == b).should == false
+  end
+
+  it "returns false if calling #<=> on self returns a negative Integer" do
+    a.should_receive(:<=>).once.and_return(-1)
+    (a == b).should == false
+  end
+
+  context "when #<=> returns nil" do
+    before :each do
+      a.should_receive(:<=>).once.and_return(nil)
+    end
+
+    it "returns false" do
+      (a == b).should be_false
+    end
+  end
+
+  context "when #<=> returns nor nil neither an Integer" do
+    before :each do
+      a.should_receive(:<=>).once.and_return("abc")
+    end
+
+    ruby_version_is ""..."2.3" do
+      it "returns false" do
+        (a == b).should be_false
+      end
+    end
+
+    ruby_version_is "2.3" do
+      it "raises an ArgumentError" do
+        lambda { (a == b) }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context "when #<=> raises an exception" do
+    context "if it is a StandardError" do
+      before :each do
+        a.should_receive(:<=>).once.and_raise(StandardError)
+      end
+
+      ruby_version_is ""..."2.3" do
+        # Behaviour confirmed by MRI test suite
+        it "returns false" do
+          (a == b).should be_false
+        end
+      end
+
+      ruby_version_is "2.3" do
+        it "lets it go through" do
+          lambda { (a == b) }.should raise_error(StandardError)
+        end
+      end
+    end
+
+    context "if it is a subclass of StandardError" do
+      # TypeError < StandardError
+      before :each do
+        a.should_receive(:<=>).once.and_raise(TypeError)
+      end
+
+      ruby_version_is ""..."2.3" do
+        it "returns false" do
+          (a == b).should be_false
+        end
+      end
+
+      ruby_version_is "2.3" do
+        it "lets it go through" do
+          lambda { (a == b) }.should raise_error(TypeError)
+        end
+      end
+    end
+
+    it "lets it go through if it is not a StandardError" do
+      a.should_receive(:<=>).once.and_raise(Exception)
+      lambda { (a == b) }.should raise_error(Exception)
+    end
+  end
+
+  context "when #<=> is not defined" do
+    before :each do
+      @a = ComparableSpecs::WithoutCompareDefined.new
+      @b = ComparableSpecs::WithoutCompareDefined.new
+    end
+
+    it "returns true for identical objects" do
+      @a.should == @a
+    end
+
+    it "returns false and does not recurse infinitely" do
+      @a.should_not == @b
+    end
+  end
+
+  context "when #<=> calls super" do
+    before :each do
+      @a = ComparableSpecs::CompareCallingSuper.new
+      @b = ComparableSpecs::CompareCallingSuper.new
+    end
+
+    it "returns true for identical objects" do
+      @a.should == @a
+    end
+
+    it "calls the defined #<=> only once for different objects" do
+      @a.should_not == @b
+      @a.calls.should == 1
+    end
+  end
+end

spec/ruby/core/comparable/fixtures/classes.rb

@@ -0,0 +1,36 @@
+module ComparableSpecs
+  class WithOnlyCompareDefined
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def <=>(other)
+      self.value <=> other.value
+    end
+  end
+
+  class Weird < WithOnlyCompareDefined
+    include Comparable
+  end
+
+  class WithoutCompareDefined
+    include Comparable
+  end
+
+  class CompareCallingSuper
+    include Comparable
+
+    attr_reader :calls
+
+    def initialize
+      @calls = 0
+    end
+
+    def <=>(other)
+      @calls += 1
+      super(other)
+    end
+  end
+end

spec/ruby/core/comparable/gt_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Comparable#>" do
+  it "calls #<=> on self with other and returns true if #<=> returns any Integer greater than 0" do
+    a = ComparableSpecs::Weird.new(0)
+    b = ComparableSpecs::Weird.new(20)
+
+    a.should_receive(:<=>).any_number_of_times.and_return(1)
+    (a > b).should == true
+
+    a.should_receive(:<=>).any_number_of_times.and_return(0.1)
+    (a > b).should == true
+
+    a.should_receive(:<=>).any_number_of_times.and_return(10000000)
+    (a > b).should == true
+  end
+
+  it "returns false if calling #<=> on self returns 0 or any Integer less than 0" do
+    a = ComparableSpecs::Weird.new(0)
+    b = ComparableSpecs::Weird.new(10)
+
+    a.should_receive(:<=>).any_number_of_times.and_return(0)
+    (a > b).should == false
+
+    a.should_receive(:<=>).any_number_of_times.and_return(0.0)
+    (a > b).should == false
+
+    a.should_receive(:<=>).any_number_of_times.and_return(-1.0)
+    (a > b).should == false
+
+    a.should_receive(:<=>).any_number_of_times.and_return(-10000000)
+    (a > b).should == false
+  end
+
+  it "raises an ArgumentError if calling #<=> on self returns nil" do
+    a = ComparableSpecs::Weird.new(0)
+    b = ComparableSpecs::Weird.new(20)
+
+    a.should_receive(:<=>).any_number_of_times.and_return(nil)
+    lambda { (a > b) }.should raise_error(ArgumentError)
+  end
+end

spec/ruby/core/comparable/gte_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path('../fixtures/classes', __FILE__)
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "Comparable#>=" do
+  it "calls #<=> on self with other and returns true if #<=> returns 0 or any Integer greater than 0" do
+    a = ComparableSpecs::Weird.new(0)
+    b = ComparableSpecs::Weird.new(20)
+
+    a.should_receive(:<=>).any_number_of_times.and_return(0)
+    (a >= b).should == true
+
+    a.should_receive(:<=>).any_number_of_times.and_return(0.0)
+    (a >= b).should == true
+
+    a.should_receive(:<=>).any_number_of_times.and_return(1)
+    (a >= b).should == true
+
+    a.should_receive(:<=>).any_number_of_times.and_return(0.1)
+    (a >= b).should == true
+
+    a.should_receive(:<=>).any_number_of_times.and_return(10000000)
+    (a >= b).should == true
+  end
+
+  it "returns false if calling #<=> on self returns any Integer less than 0" do
+    a = ComparableSpecs::Weird.new(0)
+    b = ComparableSpecs::Weird.new(10)
+
+
+    a.should_receive(:<=>).any_number_of_times.and_return(-0.1)
+    (a >= b).should == false
+
+    a.should_receive(:<=>).any_number_of_times.and_return(-1.0)
+    (a >= b).should == false
+
+    a.should_receive(:<=>).any_number_of_times.and_return(-10000000)
+    (a >= b).should == false
+  end
+
+  it "raises an ArgumentError if calling #<=> on self returns nil" do
+    a = ComparableSpecs::Weird.new(0)
+    b = ComparableSpecs::Weird.new(20)
+
+    a.should_receive(:<=>).any_number_of_times.and_return(nil)
+    lambda { (a >= b) }.should raise_error(ArgumentError)
+  end
+end

spec/ruby/core/comparable/lt_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Comparable#<" do
+  it "calls #<=> on self with other and returns true if #<=> returns any Integer less than 0" do
+    a = ComparableSpecs::Weird.new(0)
+    b = ComparableSpecs::Weird.new(20)
+
+    a.should_receive(:<=>).any_number_of_times.and_return(-1)
+    (a < b).should == true
+
+    a.should_receive(:<=>).any_number_of_times.and_return(-0.1)
+    (a < b).should == true
+
+    a.should_receive(:<=>).any_number_of_times.and_return(-10000000)
+    (a < b).should == true
+  end
+
+  it "returns false if calling #<=> on self returns 0 or any Integer greater than 0" do
+    a = ComparableSpecs::Weird.new(0)
+    b = ComparableSpecs::Weird.new(10)
+
+    a.should_receive(:<=>).any_number_of_times.and_return(0)
+    (a < b).should == false
+
+    a.should_receive(:<=>).any_number_of_times.and_return(0.0)
+    (a < b).should == false
+
+    a.should_receive(:<=>).any_number_of_times.and_return(1.0)
+    (a < b).should == false
+
+    a.should_receive(:<=>).any_number_of_times.and_return(10000000)
+    (a < b).should == false
+  end
+
+  it "raises an ArgumentError if calling #<=> on self returns nil" do
+    a = ComparableSpecs::Weird.new(0)
+    b = ComparableSpecs::Weird.new(20)
+
+    a.should_receive(:<=>).any_number_of_times.and_return(nil)
+    lambda { (a < b) }.should raise_error(ArgumentError)
+  end
+end

spec/ruby/core/comparable/lte_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Comparable#<=" do
+  it "calls #<=> on self with other and returns true if #<=> returns 0 or any Integer less than 0" do
+    a = ComparableSpecs::Weird.new(0)
+    b = ComparableSpecs::Weird.new(20)
+
+    a.should_receive(:<=>).any_number_of_times.and_return(0)
+    (a <= b).should == true
+
+    a.should_receive(:<=>).any_number_of_times.and_return(0.0)
+    (a <= b).should == true
+
+    a.should_receive(:<=>).any_number_of_times.and_return(-1)
+    (a <= b).should == true
+
+    a.should_receive(:<=>).any_number_of_times.and_return(-0.1)
+    (a <= b).should == true
+
+    a.should_receive(:<=>).any_number_of_times.and_return(-10000000)
+    (a <= b).should == true
+  end
+
+  it "returns false if calling #<=> on self returns any Integer greater than 0" do
+    a = ComparableSpecs::Weird.new(0)
+    b = ComparableSpecs::Weird.new(10)
+
+    a.should_receive(:<=>).any_number_of_times.and_return(0.1)
+    (a <= b).should == false
+
+    a.should_receive(:<=>).any_number_of_times.and_return(1.0)
+    (a <= b).should == false
+
+    a.should_receive(:<=>).any_number_of_times.and_return(10000000)
+    (a <= b).should == false
+  end
+
+  it "raises an ArgumentError if calling #<=> on self returns nil" do
+    a = ComparableSpecs::Weird.new(0)
+    b = ComparableSpecs::Weird.new(20)
+
+    a.should_receive(:<=>).any_number_of_times.and_return(nil)
+    lambda { (a <= b) }.should raise_error(ArgumentError)
+  end
+end