range_extd 1.1.1 → 2.0

data/test/test_range_extd.rb

@@ -2,46 +2,23 @@
 
 $stdout.sync=true
 $stderr.sync=true
+
 # print '$LOAD_PATH=';p $LOAD_PATH
-arlibrelpath = []
 arlibbase = %w(range_extd range_extd/infinity)	# range_extd/infinity is actually loaded from range_extd.  But by writing here, the absolute path will be displayed.
 
-arlibbase.each do |elibbase|
-  arAllPaths = []
-  er=nil
-  pathnow = nil
-  (['../lib/', 'lib/', ''].map{|i| i+elibbase+'/'} + ['']).each do |dir|
-    # eg., pathcand = %w(../lib/rangesmaller/ lib/rangesmaller/ rangesmaller/) + ['']
-    begin
-      s = dir+File.basename(elibbase)
-      arAllPaths.push(s)
-#print "Trying: "; puts s
-      require s
-      pathnow = s
-      break
-    rescue LoadError => er
-    end
-  end	# (['../lib/', 'lib/', ''].map{|i| i+elibbase+'/'} + '').each do |dir|
-
-  if pathnow.nil?
-    warn "Warning: All the attempts to load the following files have failed.  Abort..."
-    warn arAllPaths.inspect
-    warn " NOTE: It may be because a require statement in that file failed, 
-rather than requiring the file itself.
- Check with  % ruby -r#{File.basename(elibbase)} -e p
- or maybe add  env RUBYLIB=$RUBYLIB:`pwd`"
-    # p $LOADED_FEATURES.grep(/#{Regexp.quote(File.basename(elibbase)+'.rb')}$/)
-    raise er
-  else
-#print pathnow," is loaded!\n"
-    arlibrelpath.push pathnow
-  end
+arlibrelbase = arlibbase.map{|i| "../lib/"+i}
+
+arlibrelbase.each do |elibbase|
+  require_relative elibbase
 end	# arlibbase.each do |elibbase|
 
-print "NOTE: Library relative paths: "; p arlibrelpath
-print "NOTE: Library full paths:\n"
-arlibbase.each do |elibbase|
-  p $LOADED_FEATURES.grep(/#{Regexp.quote(File.basename(elibbase)+'.rb')}$/)
+print "NOTE: Running: "; p File.basename(__FILE__)
+print "NOTE: Library relative paths: "; p arlibrelbase
+arlibbase4full = arlibbase.map{|i| i.sub(%r@^(../)+@, "")}+%w(range_extd)
+puts  "NOTE: Library full paths for #{arlibbase4full.inspect}: "
+arlibbase4full.each do |elibbase|
+  ar = $LOADED_FEATURES.grep(/(^|\/)#{Regexp.quote(File.basename(elibbase))}(\.rb)?$/).uniq
+  print elibbase+": " if ar.empty?; p ar
 end
 
 
@@ -72,6 +49,8 @@ gem "minitest"
       Xs.new(@length + 1)
     end
     def <=>(other)
+      # Apparently, this affects :== as well!!
+      # Therefore, (Xs.new(4) == Object.new) would raise NoMethodError, whereas (Object.new == Xs.new(4)) just returns false.
       @length <=> other.length
     end
     def to_s
@@ -145,12 +124,13 @@ gem "minitest"
     RangeExtd(*rest)
   end
 
-  class TestUnitFoo < MiniTest::Unit::TestCase
+  class TestUnitFoo < MiniTest::Test
     T = true
     F = false
     InfF = Float::INFINITY
     InfP = RangeExtd::Infinity::POSITIVE
     InfN = RangeExtd::Infinity::NEGATIVE
+    NOWHERE = RangeExtd::Nowhere::NOWHERE
 
     def setup
       @ib = 1
@@ -167,6 +147,10 @@ gem "minitest"
       @foo = nil
     end
 
+    ####################################
+    # Ruby behaviours (to check out)
+    ####################################
+
     def test_object_compare
       assert_equal 0, (3 <=> 3)
       assert_equal 1, (4 <=> 3)
@@ -176,19 +160,174 @@ gem "minitest"
       assert_equal 0, (IO <=> IO)
     end	# def test_object_compare
 
+    # Ruby-2.7 (and 3.1) default behaviours.
+    def test_ruby27_range01
+      num1 = (5..InfF)
+      num2 = (5..)
+      assert( num1.end != num2.end )
+      assert_equal InfF, num1.size
+      assert_equal InfF, num2.size
+
+      str1 = (?a..)
+      assert( str1.end != num1.end )
+      assert( str1.end == num2.end )
+      assert_nil str1.size, "For some reason, this is nil in Ruby 3.1"
+      assert_equal InfF, (..?z).size
+    end	# def test_ruby27_range
+
+    # Ruby-2.7 (and 3.1) default behaviours.
+    def test_ruby27_range_nil
+      assert_equal "..3", (..3).to_s
+      assert_equal "3..", (3..).to_s
+      assert_equal "3..", (3..nil).to_s
+      assert_equal "..3", (nil..3).to_s
+
+      assert( (nil..) == (..nil) )  # 
+      assert( (nil..) != (...nil))  # (because (I guess) exclude_end? differ)
+      assert( (...nil).exclude_end? )  # (because (I guess) exclude_end? differ)
+      assert_equal "abcdef", "abcdef"[..nil] # (i.e., it is interpreted as (0..IntegerInfinity)
+                           #    (n.b., nil.to_i==0; Integer(nil) #=> TypeError))
+      assert_raises(TypeError){ "abcdef"[..?a] } # raise: no implicit conversion of String into Integer (TypeError)
+      assert_equal "abcdef", "abcdef"[0..100]
+      assert_nil   "abcdef"[-100..100]
+
+      assert_equal InfF, (..nil).size
+
+      assert_nil (..nil).begin
+      assert_raises(RangeError){ (..nil).first} # raise: cannot get the first element of beginless range (RangeError)
+      assert_raises(RangeError){ (..nil).last } # raise: cannot get the last element of endless range (RangeError)
+      assert_nil (..nil).end
+
+      assert( (..nil).cover? 5   )
+      assert( (..nil).cover? ?a  )
+      assert( (..nil).cover? [?a])
+      assert( (..nil).cover? nil )
+    end	# def test_ruby27_range_nil
+
+    # Ruby-2.7 (and 3.1) default behaviours.
+    def test_ruby27_range_int
+      num1 = (5..Float::INFINITY)
+      num2 = (5..)
+      assert( num1.end != num2.end)  # (because I guess (Float::INFINITY != nil))
+      assert_equal InfF, num1.size
+      assert_equal InfF, num2.size
+
+      assert (3...) == (3...nil)
+      assert (3..)  != (3...nil) #  (because I guess exclude_end? differ)
+
+      assert_equal InfF, (3..).size
+      assert_nil   (..3).begin  # => nil
+      assert_raises(RangeError){ (..3).first} # raise: cannot get the first element of beginless range (RangeError)
+      assert_raises(RangeError){ (3..).last } # raise: cannot get the last element of endless range (RangeError)
+      assert_nil   (3..).end    # => nil
+      assert_raises(TypeError){ (..3).each{}} # raise: `each': can't iterate from NilClass (TypeError)
+      assert_raises(TypeError){ (..3).to_a  } # raise: `each': can't iterate from NilClass (TypeError)
+      assert_raises(RangeError){ (3..).to_a } # raise: `to_a': cannot convert endless range to an array (RangeError)
+      # (3..Float::INFINITY).to_a    # => Infinite loop!
+
+      assert_equal(-InfF, (-Float::INFINITY..4).first)
+      assert_equal  InfF, (4..Float::INFINITY).last
+      assert_raises(TypeError){ (-Float::INFINITY..4).first(2)} # raise: can't iterate from Float (TypeError)
+      # (4..Float::INFINITY).last(2) # Infinite loop!
+    end # def test_ruby27_range_int
+
+    # Ruby-2.7 (and 3.1) default behaviours.
+    def test_ruby27_range_string
+      assert((?a..).end   == (5..).end)   # (because both are nil)
+      assert((?a..).end   != (5..Float::INFINITY).end)
+      assert((..?a).begin == (..5).begin) # (because both are nil)
+      assert((..?a).begin != ((-Float::INFINITY)..5).begin)
+      assert_nil (?a..?b).size  # Range#size is nil except for Numeric Ranges (specification).
+      assert_equal InfF, (..?a).size  # Therefore, this contradicts the specification.
+      assert_nil (?a..).size
+
+      assert_nil (..?a).begin
+      assert_raises(RangeError){ (..?a).first} # raise: cannot get the first element of beginless range (RangeError)
+      assert_raises(RangeError){ (?a..).last } # raise: cannot get the last element of endless range (RangeError)
+      assert_nil (?a..).end
+      assert_raises(TypeError){ (..?a).each{}} # raise: `each': can't iterate from NilClass (TypeError)
+      assert_raises(TypeError){ (..?a).to_a  } # raise: `each': can't iterate from NilClass (TypeError)
+      assert_raises(RangeError){(?a..).to_a  } # raise: `to_a': cannot convert endless range to an array (RangeError)
+      assert_raises(ArgumentError){ (?a..Float::INFINITY).to_a } # raise: bad value for range (ArgumentError)  # b/c it is not String!
+    end # def test_ruby27_range_string
+
+    ####################################
+    # RangeExtd behaviours
+    ####################################
+
+    # Tests listed in the doc
+    def test_doc_first
+      assert_equal Float::INFINITY, RaE(..nil).size
+      assert_nil   RaE(..nil).begin
+      assert_raises(RangeError){RaE(..nil).first} # raise: cannot get the first element of beginless range (RangeError)
+      assert_raises(RangeError){RaE(..nil).last}  # raise: cannot get the last element of endless range (RangeError)
+      assert_nil RaE(..nil).end
+      assert     RaE(..nil).cover? 5
+      assert     RaE(..nil).cover? ?a
+      assert     RaE(..nil).cover? [?a]
+      assert     RaE(..nil).cover? nil
+    end
+
+    # Tests listed in the doc
+    def test_doc_integer
+      assert_equal((3...), RaE(3...nil))
+      refute_equal((3..),  RaE(3...nil))  #  (because exclude_end? differ))
+      assert_equal(RaE(3...nil), (3...))
+      refute_equal(RaE(3...nil), (3..) )  #  (because exclude_end? differ))
+      assert_equal Float::INFINITY, RaE(3..).size
+      assert_nil  RaE(..3).begin
+      assert_raises(RangeError, "first() should raise RangeError"){RaE(..3).first} # raise: cannot get the first element of beginless range (RangeError)
+      assert_raises(RangeError, "last() should raise RangeError"){RaE(3..).last}  # raise: cannot get the last element of endless range (RangeError)
+      assert_nil  RaE(3..).end
+      assert_raises(TypeError){RaE(..3).each{}} # raise: `each': can't iterate from NilClass (TypeError)
+      assert_raises(TypeError){RaE(..3).to_a}   # raise: `each': can't iterate from NilClass (TypeError)
+      assert_raises(RangeError){RaE(3..).to_a}  # raise: `to_a': cannot convert endless range to an array (RangeError)
+      #  (3..Float::INFINITY).to_a  # Infinite loop!
+    end
+
+    # Tests listed in the doc
+    def test_doc_string
+      assert(    (5..).end == RaE(?a..).end)  # for direct comparison, assert_nil is required!
+      assert( RaE(5..).end ==    (?a..).end)
+      assert( RaE(5..).end == RaE(?a..).end)
+      refute_equal(   (5..Float::INFINITY).end, RaE(?a..).end)
+      refute_equal(RaE(5..Float::INFINITY).end,    (?a..).end)
+      refute_equal(RaE(5..Float::INFINITY).end, RaE(?a..).end)
+      assert(    (..5).begin == RaE(..?a).begin)  # (because both are nil)
+      assert( RaE(..5).begin ==    (..?a).begin)
+      assert( RaE(..5).begin == RaE(..?a).begin)
+      refute_equal(   ((-Float::INFINITY)..5).begin, RaE(..?a).begin)
+      refute_equal(RaE((-Float::INFINITY)..5).begin,    (..?a).begin)
+      refute_equal(RaE((-Float::INFINITY)..5).begin, RaE(..?a).begin)
+      assert_equal Float::INFINITY, RaE(..?a).size
+      assert_nil RaE(?a..).size
+
+      assert_nil RaE(..?a).begin
+      assert_raises(RangeError){RaE(..?a).first} # raise: cannot get the first element of beginless range (RangeError)
+      assert_raises(RangeError){RaE(?a..).last}  # raise: cannot get the last element of endless range (RangeError)
+      assert_nil RaE(?a..).end
+      assert_raises(TypeError){RaE(..?a).each{}} # raise: `each': can't iterate from NilClass (TypeError)
+      assert_raises(TypeError){RaE(..?a).to_a}   # raise: `each': can't iterate from NilClass (TypeError)
+      assert_raises(RangeError){RaE(?a..).to_a}  # raise: `to_a': cannot convert endless range to an array (RangeError)
+      assert_raises(ArgumentError){RaE(?a..Float::INFINITY).to_a}  # raise: bad value for range (ArgumentError)  # b/c it is not String!
+    end
+
+    # IF and only if "range_extd/numeric" is required,
     # InfP (RangeExtd::Infinity::POSITIVE) and InfN (RangeExtd::Infinity::NEGATIVE)
     # are always comparable with any comparable objects except for
     # Float::INFINITY, in which case ArgumentError is raised.
+    #
+    # In this case, the file is not required.
     def test_infinity_compare
       assert_operator            7.7, '<', InfF
-      assert_operator            7.7, '<', InfP
-      assert_operator            7.7, '>', InfN
+      assert_raises(ArgumentError){ 7.7 < InfP }
+      assert_raises(ArgumentError){ 7.7 > InfN }
       assert_operator           InfP, '>', 7.7
       assert_operator           InfN, '<', 7.7
       assert_operator              8, '<', InfF
-      assert_operator              8, '<', InfP
+      assert_raises(ArgumentError){ 8 < InfP }
       assert_operator Rational(2, 3), '<', InfF
-      assert_operator Rational(2, 3), '<', InfP
+      assert_raises(ArgumentError){ Rational(2, 3) < InfP }
       assert_operator           InfP, '>', Rational(2, 3)
       assert_operator           InfN, '<', Rational(2, 3)
       assert_operator 'h', '<',  InfP
@@ -204,12 +343,12 @@ gem "minitest"
       assert_raises(ArgumentError) { InfP < Object.new }
       assert_nil     (InfF <=> InfP)
       assert_nil     (InfP <=> InfF)
-      assert_equal(-1,  7.7 <=> InfP)
-      assert_equal( 1,  7.7 <=> InfN)
+      assert_nil( 7.7 <=> InfP)
+      assert_nil( 7.7 <=> InfN)
       assert_equal( 1, InfP <=> 7.7)
       assert_equal(-1, InfN <=> 7.7)
-      assert_equal(-1,    5 <=> InfP)
-      assert_equal( 1,    5 <=> InfN)
+      assert_nil( 5 <=> InfP)
+      assert_nil( 5 <=> InfN)
       assert_equal( 1, InfP <=> 5)
       assert_equal(-1, InfN <=> 5)
       assert_equal(-1,  'h' <=> InfP)
@@ -262,11 +401,10 @@ gem "minitest"
     def test_rangeextd_new_infinity_c2
       c2 = CLC2.new
       assert_nil  (c2 <=> 1)	# Object#<=>
-      assert_equal(-1, (c2 <=> RangeExtd::Infinity::POSITIVE))
-      assert_equal  1, (c2 <=> RangeExtd::Infinity::NEGATIVE)
-      r=(c2..RangeExtd::Infinity::POSITIVE)
-      assert_equal RangeExtd::Infinity::POSITIVE, r.end
-      r=(RangeExtd::Infinity::NEGATIVE..c2)
+      assert_nil(c2 <=> RangeExtd::Infinity::POSITIVE)
+      assert_nil(c2 <=> RangeExtd::Infinity::NEGATIVE)
+      assert_raises(ArgumentError, '"bad value for range" should be raised when object.rb is not required'){ (c2..RangeExtd::Infinity::POSITIVE) }
+      r=(RangeExtd::Infinity::NEGATIVE..c2)  # This is OK at least in Ruby-3.1 because (RangeExtd::Infinity::NEGATIVE <=> c2) is valid.
       assert_equal RangeExtd::Infinity::NEGATIVE, r.begin
 
       assert_raises(ArgumentError){ (true..RangeExtd::Infinity::POSITIVE) }	# => bad value for range
@@ -293,12 +431,11 @@ gem "minitest"
 
     def test_rangeextd_new_infinity_c3
       c3 = CLC3.new
-      assert_equal(-1, (c3 <=> RangeExtd::Infinity::POSITIVE))
-      assert_equal  1, (c3 <=> RangeExtd::Infinity::NEGATIVE)
+      assert_nil(c3 <=> RangeExtd::Infinity::POSITIVE)
+      assert_nil(c3 <=> RangeExtd::Infinity::NEGATIVE)
 
-      r=(c3..RangeExtd::Infinity::POSITIVE)
-      assert_equal RangeExtd::Infinity::POSITIVE, r.end
-      r=(RangeExtd::Infinity::NEGATIVE..c3)
+      assert_raises(ArgumentError, '"bad value for range" should be raised when object.rb is not required'){(c3..RangeExtd::Infinity::POSITIVE) }
+      r=(RangeExtd::Infinity::NEGATIVE..c3)  # This is OK at least in Ruby-3.1 because (RangeExtd::Infinity::NEGATIVE <=> c3) is valid.
       assert_equal RangeExtd::Infinity::NEGATIVE, r.begin
     end	# def test_rangeextd_new_infinity_c3
 
@@ -311,7 +448,7 @@ gem "minitest"
       arout = RangeExtd.class_eval{ _get_init_args(3, nil) }	# class_eval from Ruby 1.8.7 (?)
       assert_equal [3, nil, F, F], arout
       arout = RangeExtd.class_eval{ _get_init_args(3, nil, F, T) }  # true == exclude_end?
-      assert_equal [3, nil, T, F], arout
+      assert_equal [3, nil, F, T], arout
     end
 
     def test_new
@@ -393,8 +530,10 @@ gem "minitest"
       assert_equal ra00.exclude_end?, rae0.exclude_end?
       refute                          rae0.exclude_begin?
 
-      assert_equal Float::INFINITY, RangeExtd.new(?d, RangeExtd::Infinity::POSITIVE).size
-      assert_equal Float::INFINITY, RangeExtd.new(RangeExtd::Infinity::NEGATIVE, ?d).size
+      # https://ruby-doc.org/core-3.1.2/Range.html#method-i-size],
+      # > Returns the count of elements in self if both begin and end values are numeric; otherwise, returns nil
+      assert( (?d..).size == RangeExtd.new(?d, RangeExtd::Infinity::POSITIVE).size )
+      assert( (..?d).size == RangeExtd.new(RangeExtd::Infinity::NEGATIVE, ?d).size )
 
       rae0 = RangeExtd.new(?d, nil, false, true)
       assert rae0.valid?
@@ -426,6 +565,32 @@ gem "minitest"
       refute                           rae0.exclude_begin?
     end
 
+    def test_new_endless_range04
+      # Ruby 2.7 and later
+      #
+      # Note this would raise a SytaxError for the versions before 2.7.
+
+      assert_equal  9, RangeExtd(..9).end
+      assert_equal ?d, RangeExtd(..?d).end
+      assert_equal ?d, RangeExtd(..?d).last
+      assert_equal ?d, RangeExtd(..?d, true).last
+      assert_nil       RangeExtd(..9).begin
+      assert_raises(RangeError){ RangeExtd(..9).first} # raise: cannot get the first element of beginless range (RangeError)
+      assert_nil       RangeExtd(..?d).begin
+      assert_raises(RangeError){ (..?d).first} # raise: cannot get the first element of beginless range (RangeError)
+
+      # (nil..nil).size is Infininty, even thouth it does not agree with Ruby's doc's specification.
+      assert_equal (nil..).size, RaE(InfN...InfP, true).size
+      assert_equal (nil..).size,    (InfN..InfP).size
+      assert_equal (nil..).size,    (InfN...InfP).size
+      assert_equal (-InfF..InfF).size, RaE(-InfF..InfF, true).size
+      assert_equal    0,    (InfP..InfN).size
+      assert_raises(FloatDomainError){ (InfP..InfP).size} # NaN
+      assert_raises(FloatDomainError){ (InfN..InfN).size} # NaN
+      assert( (nil..?a).size == (InfN..?a).size )
+      assert( (?a..nil).size == (?a..InfP).size )
+    end
+
     def test_new_middle_strings
       aru = ['[','(in)','(ex)',', ','(ex)','(in)',']']
       ark = [nil, :math, aru, :default]
@@ -519,7 +684,8 @@ gem "minitest"
 
       # Wrong range (Object input)
       assert_raises(re){ RaE(2, -1) }
-      assert_raises(re){ RaE(nil, nil) }
+      assert( RaE(nil, nil).valid?, 'RangeExtd(nil,nil) should be valid now, but..' )
+      assert( RaE(nil..nil).valid?, 'RangeExtd(nil..nil) should be valid now, but..' )
       assert_raises(re){ RaE(nil, false) }
       assert_raises(re){ RaE(?d..?a) }
       assert_raises(re){ RaE(?a, 5) }
@@ -556,7 +722,6 @@ gem "minitest"
 
       # Wrong range (Range input)
       assert_raises(re){ RangeExtd(2..-1) }
-      assert_raises(re){ RangeExtd(nil..nil) }
       assert_raises(re){ RangeExtd(?d..?a) }
 
       # Range with contradictory boundary
@@ -570,13 +735,22 @@ gem "minitest"
     end
 
     def test_new_invalid_endless_range01
-      ra00 = (nil..)  # This raises the uncapturable SyntaxError for Ruby 2.5 and before anyway.
-      refute RangeExtd.valid?(ra00)
-      assert_raises(RangeError){ RangeExtd.new(ra00) }
-
       ra01 = (true..)
       refute RangeExtd.valid?(ra01)
-      assert_raises(RangeError){ RangeExtd.new(ra01) }
+      assert_raises(RangeError){ RangeExtd.new(ra01)} # the combination of the arguments does not constitute a valid RangeExtd instance.
+      ra02 = (..true)
+      refute RangeExtd.valid?(ra02)
+      assert_raises(RangeError){ RangeExtd.new(ra02)} # the combination of the arguments does not constitute a valid RangeExtd instance.
+    end
+
+    def test_new_valid_endless_range02
+      ras = [(nil..nil), (nil...nil), RangeExtd((..nil), true), RangeExtd((...nil), true)] 
+      # These raise the uncapturable SyntaxError for Ruby 2.5 and earlier.
+      # However, the former two are a meaningful expression in Ruby-2.7+
+      ras.each do |er|
+        assert RangeExtd.valid?(er), er.inspect+" should be valid now."
+        RangeExtd.new(er)  # Nothing should be raised
+      end
     end
 
     def test_new_exclude_begin_end
@@ -674,32 +848,50 @@ gem "minitest"
       assert_raises ArgumentError do
         RangeExtd.new(5)
       end
-      assert_raises RangeError do
-        RangeExtd.new(nil,5)
-      end
-      assert_raises RangeError do
-        RangeExtd.new(nil,5,true)
-      end
-    end	# def test_exclude_begin
 
+      RangeExtd.new(nil,5)      # used to be RangeError (in RangeExtd Ver.1), but nothing should be raised now.
+      RangeExtd.new(nil,5,true) # used to be RangeError (in RangeExtd Ver.1), but nothing should be raised now.
+    end	# def test_exclude_begin
 
-    # Test of Range(Extd)#is_none?
-    def test_is_none
-      assert  (RangeExtd::NONE.is_none?)
-      assert !(RangeExtd( 1, 1,true,true).is_none?)
-      assert !(RangeExtd(?a,?a,true,true).is_none?)
-      assert !((1...1).is_none?)
-    end
 
-    # Test of Range(Extd)#is_all?
+    # Test of Range(Extd)#is_all? and Range#equiv_all?
     def test_is_all
       assert  (RangeExtd::ALL.is_all?)
+      refute  (RangeExtd::NONE.is_all?)
       assert  (RangeExtd(RangeExtd::Infinity::NEGATIVE, RangeExtd::Infinity::POSITIVE).is_all?)	# You can create it, if you want.
-      assert !((RangeExtd::Infinity::NEGATIVE..RangeExtd::Infinity::POSITIVE).is_all?)	# Not the standard Range, though.
-      assert !(RangeExtd(-Float::INFINITY, Float::INFINITY).is_all?)	# Different from Numeric, though.
+      assert  (RangeExtd(RangeExtd::Infinity::NEGATIVE, RangeExtd::Infinity::POSITIVE).equiv_all?)
+      refute  (RangeExtd::Infinity::NEGATIVE..RangeExtd::Infinity::POSITIVE).is_all?	# Not the standard Range, though.
+      assert  (RangeExtd::Infinity::NEGATIVE..RangeExtd::Infinity::POSITIVE).equiv_all?
+      refute  (-Float::INFINITY..Float::INFINITY).is_all?
+      refute  (RangeExtd(-Float::INFINITY, Float::INFINITY).is_all?)	# Different from Numeric, though.
+      assert  (RangeExtd(-Float::INFINITY, Float::INFINITY).equiv_all?)
+      assert  (-Float::INFINITY..Float::INFINITY).equiv_all?
+      assert   (nil..).equiv_all?, '(nil..) should not be *equivalent* to RangeExtd::ALL.'
+      assert  ((..nil).equiv_all?)
+      assert  ((nil..nil).equiv_all?)
+      refute  ((nil...).equiv_all?) # because of exclude_end
+      refute   (nil..).is_all?, '(nil..) should not be *identical* to RangeExtd::ALL.'
+      refute  ((..nil).is_all?)
+      refute  ((nil..nil).is_all?)
+      refute  ((nil...).is_all?)
+      assert  (nil..nil).equiv?( RangeExtd::ALL)
+      refute  (nil...nil).equiv?(RangeExtd::ALL)
+      assert_equal    (nil..), (..nil)
+      assert_operator (nil..), :eql?, (..nil)
+      assert_equal    (nil..), (RangeExtd::Infinity::NEGATIVE..RangeExtd::Infinity::POSITIVE)
+      assert_equal    (RangeExtd::Infinity::NEGATIVE..RangeExtd::Infinity::POSITIVE), (nil..)
+      assert_equal RangeExtd::ALL, (nil..)
+      refute_equal RangeExtd::ALL, (nil...)
+      assert_equal((nil..),  RangeExtd::ALL)
+      refute_equal((nil...), RangeExtd::ALL)
+      assert_equal RangeExtd::ALL, RaE((nil..))
+      refute_equal RangeExtd::ALL, RaE((nil...))
+      assert_equal RaE(nil..),  RangeExtd::ALL
+      refute_equal RaE((nil..), true), RangeExtd::ALL
+      refute_operator RangeExtd::ALL, :eql?, (nil..)  # They are NOT eql? (but :==)
+      refute_operator (nil..), :eql?, RangeExtd::ALL
     end
 
-
     # Test of Range#== because it has changed first!
     def test_eql_range
       assert       (@r11 == (@ib..@ie))
@@ -776,6 +968,21 @@ gem "minitest"
       assert_equal false, ((?a...?a) == RangeExtd(?a...?b, true))
     end
 
+    def test_eql4
+      assert_equal((NOWHERE..nil), (NOWHERE..))
+      refute_equal((..nil), (..NOWHERE))
+      refute_equal((..nil), (NOWHERE..))
+
+      # The following is in fact unexpected...
+      # NOWHERE behaves like nil, and so I would expect it would be the same as (nil..?a).
+      # Note RangeExtd::Infinity::NEGATIVE is accepted.  It seems that
+      # the begin object must have <=> method, unless it is *literally* NilClass nil.
+      #
+      # In this particular case, this is not a problem, because
+      # NOWHERE desirably should not be used in conjunction with other objects
+      # in the first place.
+      assert_raises(ArgumentError, '"bad value for range" would be raised'){(NOWHERE..?a)}
+    end
 
     def test_begin
       assert_equal(@ib, @s11.begin)
@@ -801,7 +1008,6 @@ gem "minitest"
       # irb> (5.2...9).first(1)	# => TypeError: can't iterate from Float
       # irb> RangeExtd(5.2,9,:exclude_begin=>true).first(1)	# => [6]	# Not right!
       #
-
       assert_equal(@ib,   @s11.first)
       assert_equal(@ib,   @s12.first)
       assert_equal(@ib,   @s21.first)
@@ -813,9 +1019,6 @@ gem "minitest"
       assert_raises RangeError do
         RangeExtd(9, 3, true)
       end
-      assert_raises ArgumentError do
-        @s22.first(1, 3)
-      end
 
       ## String
       sc1 = RangeExtd.new("D".."F", false)
@@ -841,10 +1044,17 @@ gem "minitest"
         sf2.first(1)
       end
 
-      ## Else
-      assert_raises RangeError do
-        RangeExtd.new(nil..nil, true)
-      end
+      ## Infinity
+      rain = RaE(InfN, InfP, true)
+      assert( rain.begin.eql?(InfN) )
+      assert( rain.end.eql?(  InfP) )
+      assert( rain.first.eql?(InfN) )
+      assert( rain.last.eql?( InfP) )
+      assert_raises(TypeError){ rain.first(1) }
+      # assert_raises(TypeError){ rain.last(1) }  # => infinite loop!
+
+      ## beginless/endless
+      RangeExtd.new(nil..nil, true) # used to be RangeError (in RangeExtd Ver.1), but nothing should be raised now.
 
       assert_raises ArgumentError do
         @s22.first(-7)	# "negative array size (or size too big)"
@@ -855,6 +1065,18 @@ gem "minitest"
       assert_raises TypeError do
         @s22.first(nil)
       end
+
+      # (..nil).first : cannot get the first element of beginless range (RangeError)
+      # (2..2).first(-1) : negative array size (or size too big) (ArgumentError)
+      # (2..2).first(1,2) : wrong number of arguments (given 2, expected 1) (ArgumentError)
+      # (2..2).first(?a) : no implicit conversion of String into Integer (TypeError)
+      # (true..true).first(1) : can't iterate from TrueClass (TypeError)
+      assert_raises(RangeError){ RangeExtd::NONE.first }
+      assert_equal RangeExtd::NONE, RaE(3...3, true)
+      assert_equal 3, RaE(3...3, true).first, 'Alghough (3<...3) == NONE, (3<...3).first should return a value (in the same way as  (-Float::INFINITY..5).first returns -Infinity)'
+      assert_raises(RangeError){ RangeExtd::NONE.first(2) }
+      assert_raises(ArgumentError){ RaE(2,3,true).first(1,2) }  # Wrong number of arguments
+      assert_raises(ArgumentError){ RaE(2,3,true).first(-1) }   # Negative index
     end	# def test_first
 
 
@@ -885,6 +1107,7 @@ gem "minitest"
     end
 
 
+    # alias to :===, :member?
     def test_include
       assert  @s11.include?(@ib)
       assert  @s11.include?(@ie)
@@ -909,6 +1132,13 @@ gem "minitest"
       assert !(RangeExtd.new("a", "z", 777) === "a")
       assert  (RangeExtd.new("a", "z", nil) === "a")
       assert  (RangeExtd.new("a", "z", 777) === "b")
+
+      assert  (RaE(..nil, true) === "b")
+      assert  (RaE(..nil, true) === nil)
+      assert  (RangeExtd::ALL  === ?b)
+      refute  (RangeExtd::NONE === ?b)
+      refute  (RangeExtd::NONE === nil)     # NONE includes nothing
+      refute  (RangeExtd::NONE === NOWHERE) # NONE includes nothing, even NOWHERE (because of exclude_begin/end)
     end	# def test_include
 
 
@@ -977,10 +1207,41 @@ gem "minitest"
     end	# def test_cover
 
 
+    # No redefinition of the method, because super() works fine!
+    def test_count
+      assert_equal 5, RaE(1..5).count
+      assert_equal 4, RaE(1...5).count
+      assert_equal 3, RaE(1...5, true).count
+      assert_equal 5, RaE(1...5.1).count
+      assert_equal 4, RaE(1...5.1, true).count
+      assert_raises(TypeError){ RaE(1.0..5).count }  # can't iterate from Float
+      assert_equal 0, RaE(1..5.1).count(5.1)
+      assert_equal 1, RaE(1..5.1).count(1)
+      assert_equal 0, RaE(1..5.1, true).count(1)
+      assert_equal 2, RaE(1..5.1).count{|i| i<3}
+      assert_equal 1, RaE(1..5.1, true).count{|i| i<3}
+      assert_raises(TypeError){    (..5).count{|i| i<3} }  # can't iterate from NilClass
+      assert_raises(TypeError){ RaE(..5).count{|i| i<3} }
+      # (1..).count{|i| i<3}  # => infinite loop
+      assert_equal InfF, RaE(5..).count
+      assert_equal InfF, RaE(..5).count
+      assert_equal InfF,        (..nil).count
+      assert_raises(TypeError){ (..nil).count(3) }  # can't iterate from NilClass
+      assert_raises(TypeError){ (..nil).count{|i| i<3} }
+      assert_equal InfF,    (-Float::INFINITY..nil).count
+      assert_equal InfF, RaE(-Float::INFINITY..nil, true).count
+      assert_raises(TypeError){    (-Float::INFINITY..Float::INFINITY).count } # can't iterate from Float (TypeError)
+      assert_raises(TypeError){ RaE(-Float::INFINITY..Float::INFINITY).count }
+      assert_equal InfF, RangeExtd::ALL.count  # A special case, like (..nil).
+    end
+
+
     def test_hash
       assert_equal(@r11.hash, @s11.hash)
       assert_equal(@r12.hash, @s12.hash)
-      assert (@r12.hash != @s22.hash)
+      refute_equal(@r12.hash, @s22.hash)
+      refute_equal RangeExtd::NONE.hash,     (...nil).hash
+      refute_equal RangeExtd::NONE.hash, RaE((...nil), true).hash
     end	# def test_hash
 
     def test_min
@@ -991,17 +1252,25 @@ gem "minitest"
 
       assert_equal(@ie-1, @s22.min{|a,b| -a <=> -b})
 
-      assert_raises TypeError do
-        RangeExtd.new(1.0, 5, :exclude_begin => true).min
-      end
+      assert_raises(TypeError){ RangeExtd.new(1.0, 5, :exclude_begin => true).min }
+      assert_raises(RangeError){ (..3).min } # cannot get the minimum of beginless range
+
+      assert_equal(?b,    (?b...).min)
+      assert_equal(?b,    (?b...InfP).min)
+      assert_equal(?b, RaE(?b...InfP).min)
+      assert_equal(?c, RaE(?b...InfP, true).min)
+      assert_raises(RangeError){ RaE(..?z).min }
+      assert_equal(-InfF, RaE(-InfF..9.2).min)
+      assert_equal InfN,  RaE(InfN..?z).min
     end	# def test_min
 
     def test_min_by
       assert_equal(@ib+1, @s22.min_by.each{|i| i})
 
-      assert_raises TypeError do
-        RangeExtd.new(1.0, 5, :exclude_begin => true).min_by
-      end
+      assert_equal Enumerator,  RangeExtd.new(1.0, 5, true).min_by.class
+      assert_raises(TypeError){ RangeExtd.new(1.0, 5, true).min_by{|i|} }
+      assert_raises(TypeError){ RangeExtd.new(1.0, 5, true).min_by.each{|i| i} } # can't iterate from Float (TypeError)
+      assert_equal 2,  RangeExtd.new(1..5, exclude_begin: true).min_by.each{|i| i}
 
       assert_equal(@ie-1, @s22.min_by{|a| -a })
     end	# def test_min_by
@@ -1015,24 +1284,26 @@ gem "minitest"
 
       assert_equal([@ie-1,@ib+1], @s22.minmax{|a,b| -a <=> -b})	# Not the best test...
 
-      assert_raises TypeError do
-        RangeExtd.new(1.0, 5, true).minmax
-      end
+      assert_raises(TypeError){ RangeExtd.new(1.0, 5, true).minmax }
+      assert_raises(RangeError){    (?b...).minmax } # cannot get the maximum of endless range
+      assert_raises(RangeError){ RaE(?b...).minmax }
     end	# def test_minmax
 
 
     def test_minmax_by
       assert_equal([@ib+1,@ie-1], @s22.minmax_by.each{|i| i})
 
-      assert_raises TypeError do
-        RangeExtd.new(1.0, 5, true).minmax_by
-      end
+      assert_raises(TypeError){ (1.0...5).minmax_by{|i| } }
+      assert_raises(TypeError){ RangeExtd.new(1.0, 5, true).minmax_by{|i| } }
+      assert_equal Enumerator,  RangeExtd.new(1.0, 5, true).minmax_by.class
 
       assert_equal([@ie-1,@ib+1], @s22.minmax_by{|a| -a })
     end	# def test_minmax_by
 
 
     def test_max
+      assert_raises(TypeError){ (2.0...4.9).max } # cannot exclude non Integer end value
+      assert_raises(TypeError){ (1.3...5).max }   # cannot exclude end value with non Integer begin value
       assert_equal(@ie,   @s11.max)
       assert_equal(@ie-1, @s12.max)
       assert_equal(@ie,   @s21.max)
@@ -1040,20 +1311,22 @@ gem "minitest"
 
       assert_equal(@ib+1, @s22.max{|a,b| -a <=> -b})	# Not the best test...
 
-      assert_raises TypeError do
-        RangeExtd.new(1.0, 5, true).max
-      end
+      assert_equal 5, RaE(1.0, 5, true).max
+
+      assert_raises(RangeError){    (...?z).max } # cannot get the maximum of beginless range with custom comparison method
+      assert_raises(RangeError){ RaE(...?z, true).max }
+      assert_equal(?z, RaE(InfN..?z).max)
+      assert_nil  RaE(5...6, true).max
     end	# def test_max
 
 
     def test_max_by
       assert_equal(@ie-1, @s22.max_by.each{|i| i})
-
-      assert_raises TypeError do
-        RangeExtd.new(1.0, 5, true).max_by
-      end
+      assert_equal Enumerator,  RaE(1.0, 5, true).max_by.class
+      assert_raises(TypeError){ RaE(1.0, 5, true).max_by{|i|} } # can't iterate from Float
 
       assert_equal(@ib+1, @s22.max_by{|a| -a })
+      assert_equal(3, RaE(3...6).max_by{|a| -a })
     end	# def test_max_by
 
 
@@ -1121,6 +1394,28 @@ gem "minitest"
       end
     end	# def test_size
 
+    # Following the main doc...
+    def test_size2
+      assert_equal InfF, RaE(5..InfF).size
+      assert_equal InfF, RaE(..?z).size            # This contradicts the specification. Should be nil.
+      assert_equal InfF, RaE(...?z, true).size
+      assert_equal InfF, RaE(..nil).size           # This may contradict the specification?
+      assert_equal InfF, RaE(...nil, true).size
+      assert_equal InfF, RaE(3.., true).size
+      assert_equal InfF, RaE(..?a, true).size      # This contradicts the specification. Should be nil.
+      assert_equal InfF, RaE(InfN...?a, true).size
+      assert_nil         RaE(?a.., true).size
+      assert_nil         RaE(?a...InfP, true).size
+      assert_equal    0, RangeExtd::NONE.size  # This specification may change.
+      assert_nil         RaE(?a...?a, true).size   # Any size with non-Numeric Range is nil.
+
+      # More perplexing standard Ruby behaviours.
+      # Bug #18993: https://bugs.ruby-lang.org/issues/18993
+      assert_equal    3, (5.quo(3)...5).size      # => 3
+      assert_equal    4, (5.quo(3).to_f...5).size # => 4
+      assert_equal    4, (5.quo(3)..5).size       # => 4
+      assert_equal    4, (5.quo(3).to_f..5).size  # => 4
+    end	# def test_size2
 
     def test_step
       ns=0; @s11.step(2){|i| ns+=i}
@@ -1166,8 +1461,8 @@ gem "minitest"
       assert_equal(-1, (RangeExtd::Infinity::NEGATIVE <=> RangeExtd::Infinity::POSITIVE))
       assert_equal RangeExtd::Infinity::NEGATIVE, RangeExtd::Infinity::NEGATIVE
       assert_equal RangeExtd::Infinity::NEGATIVE, RangeExtd::Infinity::NEGATIVE
-      assert_equal RangeExtd::Infinity::POSITIVE, RangeExtd::Infinity::POSITIVE.succ
-      assert_equal RangeExtd::Infinity::NEGATIVE, RangeExtd::Infinity::NEGATIVE.succ
+      refute RangeExtd::Infinity::POSITIVE.respond_to? :succ
+      refute RangeExtd::Infinity::NEGATIVE.respond_to? :succ
       refute_equal(-Float::INFINITY, RangeExtd::Infinity::NEGATIVE)
       refute_equal  Float::INFINITY, RangeExtd::Infinity::POSITIVE
       assert_raises(ArgumentError) { Float::INFINITY < RangeExtd::Infinity::POSITIVE }
@@ -1226,9 +1521,9 @@ gem "minitest"
     end
 
     def test_RangeExtdClass_valid
-      assert !RangeExtd.valid?(nil, nil, 9,9)	# All 3 were true up to Version 0.1.0
-      assert !RangeExtd.valid?(nil...nil,9,9)
-      assert !RangeExtd.valid?(nil..nil, 9,9)
+      assert RangeExtd.valid?(nil, nil, 9,9)	# All 3 were true up to Version 0.1.0 and at 2.0+
+      assert RangeExtd.valid?(nil...nil,9,9)
+      assert RangeExtd.valid?(nil..nil, 9,9)
     end	# def test_RangeExtdClass_valid
 
     def test_Range_valid
@@ -1239,7 +1534,7 @@ gem "minitest"
       assert  (?a..?a).valid?	# single element
       assert !(?a...?a).valid?	# less than empty
       assert  (?a...?b).valid?	# single element
-      assert !(nil..nil).valid?
+      assert  (nil..nil).valid?
       assert !(true...true).valid?
       assert  RangeExtd(0..0).valid?
       #assert !RangeExtd(0...0).valid?
@@ -1260,8 +1555,8 @@ gem "minitest"
       assert  (0..).valid?  # This raises the uncapturable SyntaxError for Ruby 2.5 and before anyway.
       assert  (0...).valid?
       refute  (true..).valid?
-      refute  (nil...).valid?
-      refute  (nil..nil).valid?
+      assert  (nil...).valid?   # false in Ver.1 (Ruby 2.6)
+      assert  (nil..nil).valid? # false in Ver.1 (Ruby 2.6)
       assert   (Float::INFINITY..Float::INFINITY).valid?
       assert  (-Float::INFINITY..Float::INFINITY).valid?
       assert  (-Float::INFINITY...Float::INFINITY).valid?
@@ -1276,7 +1571,8 @@ gem "minitest"
       assert_nil (?a...?a).empty?	# less than empty
       assert    !(?a...?b).empty?	# single element
       assert     RangeExtd(?a...?b, :exclude_begin => true).empty?	# empty
-      assert_nil (nil..nil).empty?
+      refute     (nil..nil).empty?
+      refute     (nil..3).empty?
       assert_nil (true...true).empty?
       assert    !RangeExtd(0..0).empty?	# single element
       assert_nil (0...0).empty?
@@ -1305,7 +1601,7 @@ gem "minitest"
       assert     (?a...?a).null?	# less than empty
       assert    !(?a...?b).null?	# single element
       assert     RangeExtd(?a...?b, :exclude_begin => true).null?	# empty
-      assert     (nil..nil).null?
+      refute     (nil..nil).null?
       assert     (true...true).null?
       assert    !RangeExtd(0..0).null?	# single element
       assert     (0...0).null?
@@ -1404,23 +1700,64 @@ gem "minitest"
     end	# def test_RangeExtd_equiv
 
 
+    # Test of Range(Extd)#is_none? and RangeExtd::NONE
     def test_RangeExtd_none
+      # From examples in RangeExtd#is_none?
+      assert  RaE(0,0,true,true).valid?
+      assert (RaE(0,0,true,true) == RangeExtd::NONE)
+      assert  RaE(0,0,true,true).empty?
+      refute  RaE(0,0,true,true).is_none?
+
+      refute  (RangeExtd( 1, 1,true,true).is_none?)
+      refute  (RangeExtd(?a,?a,true,true).is_none?)
+      refute  ((1...1).is_none?)
+
       assert  RangeExtd::NONE.is_none?
       assert  RangeExtd::NONE.valid?
       assert  RangeExtd::NONE.null?
       assert  RangeExtd::NONE.empty?
-      assert !RangeExtd(0...0, true).is_none?
-      assert !(nil..nil).is_none?
-      assert !(nil...nil).is_none?
-      assert_equal RaE(0...1, true), RangeExtd::NONE
+      assert_raises(RangeError){ RaE(NOWHERE...NOWHERE, true) }
+      refute((NOWHERE...NOWHERE).valid?, "RangeExtd::Nowhere::NOWHERE should not reside anywhere but in RangeExtd::NONE")
+      #assert_equal RaE(NOWHERE...NOWHERE, true), RangeExtd::NONE
+      #refute       RaE(NOWHERE...NOWHERE, true).is_none?, "Even an equivalent RangeExtd to NONE should NOT be true==is_none?"
+
+      assert_nil  RangeExtd::NONE.begin
+      assert      RangeExtd::NONE.begin.nowhere?, "RangeExtd::NONE.begin should be RangeExtd::Nowhere::NOWHERE"
+      assert_nil  RangeExtd::NONE.end
+      assert      RangeExtd::NONE.end.nowhere?
+
+      refute RaE(0...0, true).is_none?
+      refute (nil..nil).is_none?
+      refute (nil...nil).is_none?
+      assert RaE(...nil, true).valid?
+      refute RaE(...nil, true).null?
+      refute RaE(...nil, true).empty?
+
+      refute_equal RaE(0...0, true),   RaE(?a...?a, true)
+      assert_equal RaE(0...1, true),   RaE(5...6, true)
+      refute      (RaE(0...1, true).eql?(RaE(5...6, true)))
+      assert_equal RaE(0...1, true),   RaE(1...1, true)
+      assert_equal RaE(0...1, true),   RangeExtd::NONE
+      assert_equal RaE(?a...?b, true), RangeExtd::NONE
+      refute_equal((1...1), RangeExtd::NONE, "comparison with invalid Range should return false")
       assert_equal RaE(0, 0, true, true), RangeExtd::NONE
       assert_equal RaE(?a, ?a, true, true), RangeExtd::NONE
       assert_equal RaE(?a, ?b, true, true), RangeExtd::NONE
       assert      !RaE(?a, ?b, true, true).is_none?
       assert       RaE(?a, ?b, true, true).empty?
       assert       RaE(?a, ?b, true, true).null?
-      assert_nil  RangeExtd::NONE.begin
-      assert_nil  RangeExtd::NONE.end
+
+      assert( RangeExtd::NONE ==  RangeExtd::NONE )
+      refute( RangeExtd::NONE === RangeExtd::NONE )
+      refute_equal(   (..nil),        RangeExtd::NONE)
+      refute      (RaE(...nil, true).eql?(RangeExtd::NONE))
+      refute_equal(RaE(...nil, true), RangeExtd::NONE)
+      refute_equal RangeExtd::NONE,    (..nil)
+      refute_equal RangeExtd::NONE, RaE(...nil, true)
+      refute_equal RangeExtd::NONE, RangeExtd::ALL
+      refute_equal RangeExtd::ALL,  RangeExtd::NONE
+      assert_equal RangeExtd::ALL, (..nil)
+      assert_equal((..nil), RangeExtd::ALL)
     end
 
 
@@ -1432,9 +1769,9 @@ gem "minitest"
       assert  RaE(?a, ?b, 5, 5) == RaE(?c, ?d, 5, 5)
       assert  RaE(11, 12, 5, 5) == RaE(11, 11, 5, 5)
       assert  RaE(11, 12, 5, 5) == RaE(1, 2, 5, 5)
-      assert  RaE(11, 12, 5, 5).eql?( RaE(1, 2, 5, 5) )
+      refute  RaE(11, 12, 5, 5).eql?( RaE(1, 2, 5, 5) )
       assert  RaE(11, 12, 5, 5) == RaE(3.0, 3.0, 5, 5)
-      assert !RaE(11, 12, 5, 5).eql?( RaE(3.0, 3.0, 5, 5) )
+      refute  RaE(11, 12, 5, 5).eql?( RaE(3.0, 3.0, 5, 5) )
       #assert_equal RangeExtd::NONE, RangeExtd(0...0, :exclude_begin => true)	# => ArgumentError 
       #assert_equal RangeExtd(0...0, :exclude_begin => true), RangeExtd::NONE
     end
@@ -1477,9 +1814,8 @@ gem "minitest"
       assert_raises TypeError do
         r.first(?a)
       end
-      assert_raises TypeError do
-        r.last(3)
-      end
+
+      # r.last(3)  # goes into an infinite loop!
     end
 
 
@@ -1517,14 +1853,12 @@ gem "minitest"
       assert_equal 'z', rs.last
       assert      !rs.cover?(?z)
       assert       rs.cover?(?x)
-      assert_nil  (rs === ?x)
+      assert      (rs === ?x)  # This used to be nil.
       assert_equal RangeExtd::Infinity::NEGATIVE, rs.begin	# It is Infinity,
       refute_equal(-Float::INFINITY, rs.begin)
       assert     ! rs.begin.positive?
-      assert_equal  Float::INFINITY, rs.size
-      assert_raises TypeError do
-        rs.last(3)
-      end
+      assert( (..?z).size == rs.size )
+      #assert_raises(TypeError){ rs.last(3) }  # => infiite loop
     end
 
     def test_infinity_unary_operators
@@ -1549,13 +1883,13 @@ gem "minitest"
       assert      (RaE(?c,?c,T,T) != RaE(1, 1, T, T))	# (1<...1) != (?c<...?c)   # - because of Fixnum and String
       assert_equal RaE(3, 4, T, T), RaE(1.0, 1.0, T, T)	# (1.0<...1.0) == (3<...4) # => true
 
-      # RangeExtd#eql?
+      # RangeExtd#eql?  (removed from doc)
       assert_equal (1.0...5.0), (1...5)			# (1...5) ==  (1.0...5.0)  # => true
-      assert !(1...5).eql?(1.0...5.0)			# (1...5).eql?(1.0...5.0)  # => false
-      assert  RaE(1,  1,  T,T).eql?(RangeExtd::NONE)	# (1<...1).eql?(  RangeExtd::NONE)  # => true
-      assert  RaE(?a, ?b, T,T).eql?(RangeExtd::NONE)	# (?a<...?b).eql?(RangeExtd::NONE)  # => true
-      assert  RaE(1,  1,  T,T).eql?(RaE(3,4,T,T))	# (1<...1).eql?(    3<...4)  # => true
-      assert !RaE(1.0,1.0,T,T).eql?(RaE(3,4,T,T))	#  (1.0<...1.0).eql?(3<...4)  # => false
+      refute (1...5).eql?(1.0...5.0)			# (1...5).eql?(1.0...5.0)  # => false
+      refute RaE(1,  1,  T,T).eql?(RangeExtd::NONE)	# (1<...1).eql?(  RangeExtd::NONE)  # => true
+      refute RaE(?a, ?b, T,T).eql?(RangeExtd::NONE)	# (?a<...?b).eql?(RangeExtd::NONE)  # => true
+      refute RaE(1,  1,  T,T).eql?(RaE(3,4,T,T))	# (1<...1).eql?(    3<...4)  # => true
+      refute RaE(1.0,1.0,T,T).eql?(RaE(3,4,T,T))	#  (1.0<...1.0).eql?(3<...4)  # => false
 
       # RangeExtd#===
       assert  ((?D..?z) === ?c)
@@ -1656,8 +1990,8 @@ gem "minitest"
       # RangeExtd#step	# => the same as each
 
       # RangeExtd.valid?
-      assert !RangeExtd.valid?(nil..nil)     # => false
-      assert !RangeExtd.valid?(nil...nil)    # => false
+      assert  RangeExtd.valid?(nil..nil)
+      assert  RangeExtd.valid?(nil...nil)
       assert  RangeExtd.valid?(0..0)         # => true
       assert !RangeExtd.valid?(0...0)        # => false
       assert !RangeExtd.valid?(0..0,  true)  # => false
@@ -1702,11 +2036,11 @@ gem "minitest"
 
       # Range#==
       assert !(1...1).valid?
-      assert !(nil...nil).valid?
+      assert  (nil...nil).valid?
       assert !((1...1) == RangeExtd(1, 1, true, true))	# => false.
 
       # Range#valid?
-      assert !(nil..nil).valid? # => false
+      assert  (nil..nil).valid?
       assert  (0..0).valid?     # => true
       assert !(0...0).valid?    # => false
       assert !(2..-1).valid?    # => false
@@ -1716,7 +2050,7 @@ gem "minitest"
       assert  RangeExtd::ALL.valid?  # => true
 
       # Range#empty?
-      assert_nil       (nil..nil).empty?  # => nil
+      refute           (nil..nil).empty?
       assert_nil       (1...1).empty?     # => nil
       assert !(1..1).empty?      # => false
       assert  RangeExtd(1...1,   true).empty? # => true
@@ -1737,7 +2071,7 @@ gem "minitest"
       # class Infinity
       assert_equal( -1, (?z <=> RangeExtd::Infinity::POSITIVE))
       assert_equal   1, (RangeExtd::Infinity::POSITIVE <=> ?z)
-      assert_equal( -1, (50 <=> RangeExtd::Infinity::POSITIVE))
+      assert_nil(       (50 <=> RangeExtd::Infinity::POSITIVE), 'When "range_extd/numeric" is NOT required, 50 is not comparable with POSITIVE-infinity.')
       assert_equal   1, (RangeExtd::Infinity::POSITIVE <=> 50)
     end	# def test_in_document