Only define #positive? and #negative? on Ruby 2.2

The feature was accepted and added to Ruby 2.3+ so we don't need to
define it again.

See https://bugs.ruby-lang.org/issues/11151

1 files changed, 78 insertions, 6 deletions

diff --git a/activesupport/test/core_ext/numeric_ext_test.rb b/activesupport/test/core_ext/numeric_ext_test.rb
index 623c64d050..2d8796179e 100644
--- a/activesupport/test/core_ext/numeric_ext_test.rb
+++ b/activesupport/test/core_ext/numeric_ext_test.rb
@@ -390,15 +390,87 @@ class NumericExtFormattingTest < ActiveSupport::TestCase
     assert_equal 10_000, 10.seconds.in_milliseconds
   end
 
+  # TODO: Remove positive and negative tests when we drop support to ruby < 2.3
+  b = 2**64
+  b *= b until Bignum === b
+
+  T_ZERO = b.coerce(0).first
+  T_ONE  = b.coerce(1).first
+  T_MONE = b.coerce(-1).first
+
   def test_positive
-    assert 1.positive?
-    assert_not 0.positive?
-    assert_not -1.positive?
+    assert_predicate(1, :positive?)
+    assert_not_predicate(0, :positive?)
+    assert_not_predicate(-1, :positive?)
+    assert_predicate(+1.0, :positive?)
+    assert_not_predicate(+0.0, :positive?)
+    assert_not_predicate(-0.0, :positive?)
+    assert_not_predicate(-1.0, :positive?)
+    assert_predicate(+(0.0.next_float), :positive?)
+    assert_not_predicate(-(0.0.next_float), :positive?)
+    assert_predicate(Float::INFINITY, :positive?)
+    assert_not_predicate(-Float::INFINITY, :positive?)
+    assert_not_predicate(Float::NAN, :positive?)
+
+    a = Class.new(Numeric) do
+      def >(x); true; end
+    end.new
+    assert_predicate(a, :positive?)
+
+    a = Class.new(Numeric) do
+      def >(x); false; end
+    end.new
+    assert_not_predicate(a, :positive?)
+
+    assert_predicate(1/2r, :positive?)
+    assert_not_predicate(-1/2r, :positive?)
+
+    assert_predicate(T_ONE, :positive?)
+    assert_not_predicate(T_MONE, :positive?)
+    assert_not_predicate(T_ZERO, :positive?)
+
+    e = assert_raises(NoMethodError) do
+      Complex(1).positive?
+    end
+
+    assert_match(/positive\?/, e.message)
   end
 
   def test_negative
-    assert(-1.negative?)
-    assert_not 0.negative?
-    assert_not 1.negative?
+    assert_predicate(-1, :negative?)
+    assert_not_predicate(0, :negative?)
+    assert_not_predicate(1, :negative?)
+    assert_predicate(-1.0, :negative?)
+    assert_not_predicate(-0.0, :negative?)
+    assert_not_predicate(+0.0, :negative?)
+    assert_not_predicate(+1.0, :negative?)
+    assert_predicate(-(0.0.next_float), :negative?)
+    assert_not_predicate(+(0.0.next_float), :negative?)
+    assert_predicate(-Float::INFINITY, :negative?)
+    assert_not_predicate(Float::INFINITY, :negative?)
+    assert_not_predicate(Float::NAN, :negative?)
+
+    a = Class.new(Numeric) do
+      def <(x); true; end
+    end.new
+    assert_predicate(a, :negative?)
+
+    a = Class.new(Numeric) do
+      def <(x); false; end
+    end.new
+    assert_not_predicate(a, :negative?)
+
+    assert_predicate(-1/2r, :negative?)
+    assert_not_predicate(1/2r, :negative?)
+
+    assert_not_predicate(T_ONE, :negative?)
+    assert_predicate(T_MONE, :negative?)
+    assert_not_predicate(T_ZERO, :negative?)
+
+    e = assert_raises(NoMethodError) do
+      Complex(1).negative?
+    end
+
+    assert_match(/negative\?/, e.message)
   end
 end