diff options
author | nobu <nobu@b2dd03c8-39d4-4d8f-98ff-823fe69b080e> | 2013-12-13 09:18:05 +0000 |
---|---|---|
committer | nobu <nobu@b2dd03c8-39d4-4d8f-98ff-823fe69b080e> | 2013-12-13 09:18:05 +0000 |
commit | 3ac0ec4ecdea849143ed64e8935e6675b341e44b (patch) | |
tree | fe18c8213610bfdbca51b687133caf5ab297b882 /test/ruby/test_m17n_comb.rb | |
parent | 287d2adab0ce45018ada9941ce4eaf67ba6a4d3a (diff) | |
download | ruby-3ac0ec4ecdea849143ed64e8935e6675b341e44b.tar.gz |
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
Diffstat (limited to 'test/ruby/test_m17n_comb.rb')
-rw-r--r-- | test/ruby/test_m17n_comb.rb | 138 |
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 } |