test/ruby: better assertions

* test/ruby: use better assertions instead of mere assert.

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

1 files changed, 69 insertions, 69 deletions

diff --git a/test/ruby/test_m17n_comb.rb b/test/ruby/test_m17n_comb.rb
index fd715240e8..446ceccc4a 100644
--- a/test/ruby/test_m17n_comb.rb
+++ b/test/ruby/test_m17n_comb.rb
@@ -124,7 +124,7 @@ class TestM17NComb < Test::Unit::TestCase
     elsif !s2.ascii_only?
       assert_equal(s2.encoding, t.encoding)
     else
-      assert([s1.encoding, s2.encoding].include?(t.encoding))
+      assert_include([s1.encoding, s2.encoding], t.encoding)
     end
   end
 
@@ -211,7 +211,7 @@ class TestM17NComb < Test::Unit::TestCase
         assert_raise(Encoding::CompatibilityError) { s1 + s2 }
       else
         t = enccall(s1, :+, s2)
-        assert(t.valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
+        assert_predicate(t, :valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
         assert_equal(b(s1) + b(s2), b(t))
         assert_str_enc_propagation(t, s1, s2)
       end
@@ -222,7 +222,7 @@ class TestM17NComb < Test::Unit::TestCase
     STRINGS.each {|s|
       [0,1,2].each {|n|
         t = s * n
-        assert(t.valid_encoding?) if s.valid_encoding?
+        assert_predicate(t, :valid_encoding?) if s.valid_encoding?
         assert_strenc(b(s) * n, s.encoding, t)
       }
     }
@@ -240,16 +240,16 @@ class TestM17NComb < Test::Unit::TestCase
 
   def test_str_eq_reflexive
     STRINGS.each {|s|
-      assert(s == s, "#{encdump s} == #{encdump s}")
+      assert_equal(s, s, "#{encdump s} == #{encdump s}")
     }
   end
 
   def test_str_eq_symmetric
     combination(STRINGS, STRINGS) {|s1, s2|
       if s1 == s2
-        assert(s2 == s1, "#{encdump s2} == #{encdump s1}")
+        assert_equal(s2, s1, "#{encdump s2} == #{encdump s1}")
       else
-        assert(!(s2 == s1), "!(#{encdump s2} == #{encdump s1})")
+        assert_not_equal(s2, s1, "!(#{encdump s2} == #{encdump s1})")
       end
     }
   end
@@ -257,7 +257,7 @@ class TestM17NComb < Test::Unit::TestCase
   def test_str_eq_transitive
     combination(STRINGS, STRINGS, STRINGS) {|s1, s2, s3|
       if s1 == s2 && s2 == s3
-        assert(s1 == s3, "transitive: #{encdump s1} == #{encdump s2} == #{encdump s3}")
+        assert_equal(s1, s3, "transitive: #{encdump s1} == #{encdump s2} == #{encdump s3}")
       end
     }
   end
@@ -268,15 +268,15 @@ class TestM17NComb < Test::Unit::TestCase
       if b(s1) == b(s2) and
           (s1.ascii_only? && s2.ascii_only? or
            s1.encoding == s2.encoding) then
-        assert(s1 == s2, desc_eq)
-        assert(!(s1 != s2))
+        assert_operator(s1, :==, s2, desc_eq)
+        assert_not_operator(s1, :!=, s2)
         assert_equal(0, s1 <=> s2)
-        assert(s1.eql?(s2), desc_eq)
+        assert_operator(s1, :eql?, s2, desc_eq)
       else
-        assert(!(s1 == s2), "!(#{desc_eq})")
-        assert(s1 != s2)
+        assert_not_operator(s1, :==, s2, "!(#{desc_eq})")
+        assert_operator(s1, :!=, s2)
         assert_not_equal(0, s1 <=> s2)
-        assert(!s1.eql?(s2))
+        assert_not_operator(s1, :eql?, s2)
       end
     }
   end
@@ -286,7 +286,7 @@ class TestM17NComb < Test::Unit::TestCase
       s = s1.dup
       if s1.ascii_only? || s2.ascii_only? || s1.encoding == s2.encoding
         s << s2
-        assert(s.valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
+        assert_predicate(s, :valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
         assert_equal(b(s), b(s1) + b(s2))
         assert_str_enc_propagation(s, s1, s2)
       else
@@ -300,7 +300,7 @@ class TestM17NComb < Test::Unit::TestCase
       t = ''.force_encoding(s.encoding)
       0.upto(s.length-1) {|i|
         u = s[i]
-        assert(u.valid_encoding?) if s.valid_encoding?
+        assert_predicate(u, :valid_encoding?) if s.valid_encoding?
         t << u
       }
       assert_equal(t, s)
@@ -312,7 +312,7 @@ class TestM17NComb < Test::Unit::TestCase
       t = ''.force_encoding(s.encoding)
       0.upto(s.length-1) {|i|
         u = s[i,1]
-        assert(u.valid_encoding?) if s.valid_encoding?
+        assert_predicate(u, :valid_encoding?) if s.valid_encoding?
         t << u
       }
       assert_equal(t, s)
@@ -322,7 +322,7 @@ class TestM17NComb < Test::Unit::TestCase
       t = ''.force_encoding(s.encoding)
       0.step(s.length-1, 2) {|i|
         u = s[i,2]
-        assert(u.valid_encoding?) if s.valid_encoding?
+        assert_predicate(u, :valid_encoding?) if s.valid_encoding?
         t << u
       }
       assert_equal(t, s)
@@ -334,7 +334,7 @@ class TestM17NComb < Test::Unit::TestCase
       if s1.ascii_only? || s2.ascii_only? || s1.encoding == s2.encoding
         t = enccall(s1, :[], s2)
         if t != nil
-          assert(t.valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
+          assert_predicate(t, :valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
           assert_equal(s2, t)
           assert_match(/#{Regexp.escape(b(s2))}/, b(s1))
           if s1.valid_encoding?
@@ -362,7 +362,7 @@ class TestM17NComb < Test::Unit::TestCase
         assert_nil(t, desc)
         next
       end
-      assert(t.valid_encoding?) if s.valid_encoding?
+      assert_predicate(t, :valid_encoding?) if s.valid_encoding?
       if last < 0
         last += s.length
       end
@@ -393,7 +393,7 @@ class TestM17NComb < Test::Unit::TestCase
       if last < 0
         last += s.length
       end
-      assert(t.valid_encoding?) if s.valid_encoding?
+      assert_predicate(t, :valid_encoding?) if s.valid_encoding?
       t2 = ''
       first.upto(last-1) {|i|
         c = s[i]
@@ -412,8 +412,8 @@ class TestM17NComb < Test::Unit::TestCase
             assert_raise(IndexError) { t[i] = s2 }
           else
             t[i] = s2
-            assert(t.valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
-            assert(b(t).index(b(s2)))
+            assert_predicate(t, :valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
+            assert_send([b(t), :index, b(s2)])
             if s1.valid_encoding? && s2.valid_encoding?
               if i == s1.length && s2.empty?
                 assert_nil(t[i])
@@ -440,9 +440,9 @@ class TestM17NComb < Test::Unit::TestCase
         if i < -s1.length || s1.length < i
           assert_raise(IndexError) { t[i,len] = s2 }
         else
-          assert(t.valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
+          assert_predicate(t, :valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
           t[i,len] = s2
-          assert(b(t).index(b(s2)))
+          assert_send([b(t), :index, b(s2)])
           if s1.valid_encoding? && s2.valid_encoding?
             if i == s1.length && s2.empty?
               assert_nil(t[i])
@@ -486,7 +486,7 @@ class TestM17NComb < Test::Unit::TestCase
         if !t[s2]
         else
           enccall(t, :[]=, s2, s3)
-          assert(t.valid_encoding?) if s1.valid_encoding? && s2.valid_encoding? && s3.valid_encoding?
+          assert_predicate(t, :valid_encoding?) if s1.valid_encoding? && s2.valid_encoding? && s3.valid_encoding?
         end
       end
     }
@@ -500,8 +500,8 @@ class TestM17NComb < Test::Unit::TestCase
           assert_raise(RangeError) { t[first..last] = s2 }
         else
           enccall(t, :[]=, first..last, s2)
-          assert(t.valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
-          assert(b(t).index(b(s2)))
+          assert_predicate(t, :valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
+          assert_send([b(t), :index, b(s2)])
           if s1.valid_encoding? && s2.valid_encoding?
             if first < 0
               assert_equal(s2, t[s1.length+first, s2.length])
@@ -527,8 +527,8 @@ class TestM17NComb < Test::Unit::TestCase
           assert_raise(RangeError) { t[first...last] = s2 }
         else
           enccall(t, :[]=, first...last, s2)
-          assert(t.valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
-          assert(b(t).index(b(s2)))
+          assert_predicate(t, :valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
+          assert_send([b(t), :index, b(s2)])
           if s1.valid_encoding? && s2.valid_encoding?
             if first < 0
               assert_equal(s2, t[s1.length+first, s2.length])
@@ -563,11 +563,11 @@ class TestM17NComb < Test::Unit::TestCase
       begin
         t1 = s.capitalize
       rescue ArgumentError
-        assert(!s.valid_encoding?)
+        assert_not_predicate(s, :valid_encoding?)
         next
       end
-      assert(t1.valid_encoding?) if s.valid_encoding?
-      assert(t1.casecmp(s))
+      assert_predicate(t1, :valid_encoding?) if s.valid_encoding?
+      assert_operator(t1, :casecmp, s)
       t2 = s.dup
       t2.capitalize!
       assert_equal(t1, t2)
@@ -589,7 +589,7 @@ class TestM17NComb < Test::Unit::TestCase
   def test_str_center
     combination(STRINGS, [0,1,2,3,10]) {|s1, width|
       t = s1.center(width)
-      assert(b(t).index(b(s1)))
+      assert_send([b(t), :index, b(s1)])
     }
     combination(STRINGS, [0,1,2,3,10], STRINGS) {|s1, width, s2|
       if s2.empty?
@@ -601,8 +601,8 @@ class TestM17NComb < Test::Unit::TestCase
         next
       end
       t = enccall(s1, :center, width, s2)
-      assert(t.valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
-      assert(b(t).index(b(s1)))
+      assert_predicate(t, :valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
+      assert_send([b(t), :index, b(s1)])
       assert_str_enc_propagation(t, s1, s2) if (t != s1)
     }
   end
@@ -610,7 +610,7 @@ class TestM17NComb < Test::Unit::TestCase
   def test_str_ljust
     combination(STRINGS, [0,1,2,3,10]) {|s1, width|
       t = s1.ljust(width)
-      assert(b(t).index(b(s1)))
+      assert_send([b(t), :index, b(s1)])
     }
     combination(STRINGS, [0,1,2,3,10], STRINGS) {|s1, width, s2|
       if s2.empty?
@@ -622,8 +622,8 @@ class TestM17NComb < Test::Unit::TestCase
         next
       end
       t = enccall(s1, :ljust, width, s2)
-      assert(t.valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
-      assert(b(t).index(b(s1)))
+      assert_predicate(t, :valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
+      assert_send([b(t), :index, b(s1)])
       assert_str_enc_propagation(t, s1, s2) if (t != s1)
     }
   end
@@ -631,7 +631,7 @@ class TestM17NComb < Test::Unit::TestCase
   def test_str_rjust
     combination(STRINGS, [0,1,2,3,10]) {|s1, width|
       t = s1.rjust(width)
-      assert(b(t).index(b(s1)))
+      assert_send([b(t), :index, b(s1)])
     }
     combination(STRINGS, [0,1,2,3,10], STRINGS) {|s1, width, s2|
       if s2.empty?
@@ -643,8 +643,8 @@ class TestM17NComb < Test::Unit::TestCase
         next
       end
       t = enccall(s1, :rjust, width, s2)
-      assert(t.valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
-      assert(b(t).index(b(s1)))
+      assert_predicate(t, :valid_encoding?) if s1.valid_encoding? && s2.valid_encoding?
+      assert_send([b(t), :index, b(s1)])
       assert_str_enc_propagation(t, s1, s2) if (t != s1)
     }
   end
@@ -658,7 +658,7 @@ class TestM17NComb < Test::Unit::TestCase
         next
       end
       t = enccall(s1, :chomp, s2)
-      assert(t.valid_encoding?, "#{encdump(s1)}.chomp(#{encdump(s2)})") if s1.valid_encoding? && s2.valid_encoding?
+      assert_predicate(t, :valid_encoding?, "#{encdump(s1)}.chomp(#{encdump(s2)})") if s1.valid_encoding? && s2.valid_encoding?
       assert_equal(s1.encoding, t.encoding)
       t2 = s1.dup
       t2.chomp!(s2)
@@ -672,8 +672,8 @@ class TestM17NComb < Test::Unit::TestCase
       desc = "#{encdump s}.chop"
       t = nil
       assert_nothing_raised(desc) { t = s.chop }
-      assert(t.valid_encoding?) if s.valid_encoding?
-      assert(b(s).index(b(t)))
+      assert_predicate(t, :valid_encoding?) if s.valid_encoding?
+      assert_send([b(s), :index, b(t)])
       t2 = s.dup
       t2.chop!
       assert_equal(t, t2)
@@ -684,8 +684,8 @@ class TestM17NComb < Test::Unit::TestCase
     STRINGS.each {|s|
       t = s.dup
       t.clear
-      assert(t.valid_encoding?)
-      assert(t.empty?)
+      assert_predicate(t, :valid_encoding?)
+      assert_empty(t)
     }
   end
 
@@ -761,7 +761,7 @@ class TestM17NComb < Test::Unit::TestCase
         next
       end
       t = enccall(s1, :delete, s2)
-      assert(t.valid_encoding?)
+      assert_predicate(t, :valid_encoding?)
       assert_equal(t.encoding, s1.encoding)
       assert_operator(t.length, :<=, s1.length)
       t2 = s1.dup
@@ -777,9 +777,9 @@ class TestM17NComb < Test::Unit::TestCase
         next
       end
       t = s.downcase
-      assert(t.valid_encoding?)
+      assert_predicate(t, :valid_encoding?)
       assert_equal(t.encoding, s.encoding)
-      assert(t.casecmp(s))
+      assert_operator(t, :casecmp, s)
       t2 = s.dup
       t2.downcase!
       assert_equal(t, t2)
@@ -789,8 +789,8 @@ class TestM17NComb < Test::Unit::TestCase
   def test_str_dump
     STRINGS.each {|s|
       t = s.dump
-      assert(t.valid_encoding?)
-      assert(t.ascii_only?)
+      assert_predicate(t, :valid_encoding?)
+      assert_predicate(t, :ascii_only?)
       u = eval(t)
       assert_equal(b(s), b(u))
     }
@@ -829,9 +829,9 @@ class TestM17NComb < Test::Unit::TestCase
   def test_str_empty?
     STRINGS.each {|s|
       if s.length == 0
-        assert(s.empty?)
+        assert_empty(s)
       else
-        assert(!s.empty?)
+        assert_not_empty(s)
       end
     }
   end
@@ -854,12 +854,12 @@ class TestM17NComb < Test::Unit::TestCase
       end
       t = enccall(s1, :include?, s2)
       if t
-        assert(b(s1).include?(b(s2)))
-        assert(s1.index(s2))
-        assert(s1.rindex(s2))
+        assert_include(b(s1), b(s2))
+        assert_send([s1, :index, s2])
+        assert_send([s1, :rindex, s2])
       else
-        assert(!s1.index(s2))
-        assert(!s1.rindex(s2), "!#{encdump(s1)}.rindex(#{encdump(s2)})")
+        assert_not_send([s1, :index, s2])
+        assert_not_send([s1, :rindex, s2], "!#{encdump(s1)}.rindex(#{encdump(s2)})")
       end
       if s2.empty?
         assert_equal(true, t)
@@ -935,7 +935,7 @@ class TestM17NComb < Test::Unit::TestCase
       end
       if t
         #puts "#{encdump s1}.rindex(#{encdump s2}, #{pos}) => #{t}"
-        assert(b(s1).index(b(s2)))
+        assert_send([b(s1), :index, b(s2)])
         pos2 = pos
         pos2 += s1.length if pos < 0
         re = /\A(.{0,#{pos2}})#{Regexp.escape(s2)}/m
@@ -1093,8 +1093,8 @@ class TestM17NComb < Test::Unit::TestCase
                     "#{encdump s}.slice!#{encdumpargs args}.encoding")
       end
       if [s, *args].all? {|o| !(String === o) || o.valid_encoding? }
-        assert(r.valid_encoding?)
-        assert(t.valid_encoding?)
+        assert_predicate(r, :valid_encoding?)
+        assert_predicate(t, :valid_encoding?)
         assert_equal(s.length, r.length + t.length)
       end
     }
@@ -1116,13 +1116,13 @@ class TestM17NComb < Test::Unit::TestCase
       end
       t = enccall(s1, :split, s2)
       t.each {|r|
-        assert(b(s1).include?(b(r)))
+        assert_include(b(s1), b(r))
         assert_equal(s1.encoding, r.encoding)
       }
-      assert(b(s1).include?(t.map {|u| b(u) }.join(b(s2))))
+      assert_include(b(s1), t.map {|u| b(u) }.join(b(s2)))
       if s1.valid_encoding? && s2.valid_encoding?
         t.each {|r|
-          assert(r.valid_encoding?)
+          assert_predicate(r, :valid_encoding?)
         }
       end
     }
@@ -1184,8 +1184,8 @@ class TestM17NComb < Test::Unit::TestCase
         next
       end
       t1 = s.swapcase
-      assert(t1.valid_encoding?) if s.valid_encoding?
-      assert(t1.casecmp(s))
+      assert_predicate(t1, :valid_encoding?) if s.valid_encoding?
+      assert_operator(t1, :casecmp, s)
       t2 = s.dup
       t2.swapcase!
       assert_equal(t1, t2)
@@ -1298,8 +1298,8 @@ class TestM17NComb < Test::Unit::TestCase
         next
       end
       t1 = s.upcase
-      assert(t1.valid_encoding?)
-      assert(t1.casecmp(s))
+      assert_predicate(t1, :valid_encoding?)
+      assert_operator(t1, :casecmp, s)
       t2 = s.dup
       t2.upcase!
       assert_equal(t1, t2)
@@ -1321,7 +1321,7 @@ class TestM17NComb < Test::Unit::TestCase
         #puts encdump(s)
         t = s.succ
         if s.valid_encoding?
-          assert(t.valid_encoding?, "#{encdump s}.succ.valid_encoding?")
+          assert_predicate(t, :valid_encoding?, "#{encdump s}.succ.valid_encoding?")
         end
         s = t
       }