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

activesupport/lib/active_support/core_ext/numeric/inquiry.rb

@@ -1,3 +1,4 @@
+unless 1.respond_to?(:positive?) # TODO: Remove this file when we drop support to ruby < 2.3
 class Numeric
   # Returns true if the number is positive.
   #
@@ -17,3 +18,9 @@ class Numeric
     self < 0
   end
 end
+
+class Complex
+  undef :positive?
+  undef :negative?
+end
+end

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_predicate(1, :positive?)
-    assert_not 0.positive?
+    assert_not_predicate(0, :positive?)
-    assert_not -1.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_predicate(-1, :negative?)
-    assert_not 0.negative?
+    assert_not_predicate(0, :negative?)
-    assert_not 1.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