* lib/optparse.rb (OptionParser#order, #permute, #parse): allow an

  array as argument.

* test/ruby/test_*.rb: moved invariants to left side in
  assert_equal, and use assert_nil, assert_raises and so on.


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

1 files changed, 64 insertions, 64 deletions

diff --git a/test/ruby/test_stringchar.rb b/test/ruby/test_stringchar.rb
index 78ec39d56c..9e22bb35a0 100644
--- a/test/ruby/test_stringchar.rb
+++ b/test/ruby/test_stringchar.rb
@@ -8,78 +8,78 @@ class TestStringchar < Test::Unit::TestCase
     assert("abcd" =~ /abcd/)
     assert("abcd" === "abcd")
     # compile time string concatenation
-    assert_equal("ab" "cd", "abcd")
-    assert_equal("#{22}aa" "cd#{44}", "22aacd44")
-    assert_equal("#{22}aa" "cd#{44}" "55" "#{66}", "22aacd445566")
+    assert_equal("abcd", "ab" "cd")
+    assert_equal("22aacd44", "#{22}aa" "cd#{44}")
+    assert_equal("22aacd445566", "#{22}aa" "cd#{44}" "55" "#{66}")
     assert("abc" !~ /^$/)
     assert("abc\n" !~ /^$/)
     assert("abc" !~ /^d*$/)
-    assert_equal(("abc" =~ /d*$/), 3)
+    assert_equal(3, ("abc" =~ /d*$/))
     assert("" =~ /^$/)
     assert("\n" =~ /^$/)
     assert("a\n\n" =~ /^$/)
-    assert("abcabc" =~ /.*a/ && $& == "abca")
-    assert("abcabc" =~ /.*c/ && $& == "abcabc")
-    assert("abcabc" =~ /.*?a/ && $& == "a")
-    assert("abcabc" =~ /.*?c/ && $& == "abc")
-    assert(/(.|\n)*?\n(b|\n)/ =~ "a\nb\n\n" && $& == "a\nb")
-    
-    assert(/^(ab+)+b/ =~ "ababb" && $& == "ababb")
-    assert(/^(?:ab+)+b/ =~ "ababb" && $& == "ababb")
-    assert(/^(ab+)+/ =~ "ababb" && $& == "ababb")
-    assert(/^(?:ab+)+/ =~ "ababb" && $& == "ababb")
-    
-    assert(/(\s+\d+){2}/ =~ " 1 2" && $& == " 1 2")
-    assert(/(?:\s+\d+){2}/ =~ " 1 2" && $& == " 1 2")
-    
+    assert("abcabc" =~ /.*a/); assert_equal("abca", $&)
+    assert("abcabc" =~ /.*c/); assert_equal("abcabc", $&)
+    assert("abcabc" =~ /.*?a/); assert_equal("a", $&)
+    assert("abcabc" =~ /.*?c/); assert_equal("abc", $&)
+    assert(/(.|\n)*?\n(b|\n)/ =~ "a\nb\n\n"); assert_equal("a\nb", $&)
+
+    assert(/^(ab+)+b/ =~ "ababb"); assert_equal("ababb", $&)
+    assert(/^(?:ab+)+b/ =~ "ababb"); assert_equal("ababb", $&)
+    assert(/^(ab+)+/ =~ "ababb"); assert_equal("ababb", $&)
+    assert(/^(?:ab+)+/ =~ "ababb"); assert_equal("ababb", $&)
+
+    assert(/(\s+\d+){2}/ =~ " 1 2"); assert_equal(" 1 2", $&)
+    assert(/(?:\s+\d+){2}/ =~ " 1 2"); assert_equal(" 1 2", $&)
+
     $x = <<END;
 ABCD
 ABCD
 END
     $x.gsub!(/((.|\n)*?)B((.|\n)*?)D/){$1+$3}
-    assert_equal($x, "AC\nAC\n")
-    
+    assert_equal("AC\nAC\n", $x)
+
     assert("foobar" =~ /foo(?=(bar)|(baz))/)
     assert("foobaz" =~ /foo(?=(bar)|(baz))/)
-    
+
     $foo = "abc"
-    assert_equal("#$foo = abc", "abc = abc")
-    assert_equal("#{$foo} = abc", "abc = abc")
-    
+    assert_equal("abc = abc", "#$foo = abc")
+    assert_equal("abc = abc", "#{$foo} = abc")
+
     foo = "abc"
-    assert_equal("#{foo} = abc", "abc = abc")
-    
-    assert_equal('-' * 5, '-----')
-    assert_equal('-' * 1, '-')
-    assert_equal('-' * 0, '')
-    
+    assert_equal("abc = abc", "#{foo} = abc")
+
+    assert_equal('-----', '-' * 5)
+    assert_equal('-', '-' * 1)
+    assert_equal('', '-' * 0)
+
     foo = '-'
-    assert_equal(foo * 5, '-----')
-    assert_equal(foo * 1, '-')
-    assert_equal(foo * 0, '')
-    
+    assert_equal('-----', foo * 5)
+    assert_equal('-', foo * 1)
+    assert_equal('', foo * 0)
+
     $x = "a.gif"
-    assert_equal($x.sub(/.*\.([^\.]+)$/, '\1'), "gif")
-    assert_equal($x.sub(/.*\.([^\.]+)$/, 'b.\1'), "b.gif")
-    assert_equal($x.sub(/.*\.([^\.]+)$/, '\2'), "")
-    assert_equal($x.sub(/.*\.([^\.]+)$/, 'a\2b'), "ab")
-    assert_equal($x.sub(/.*\.([^\.]+)$/, '<\&>'), "<a.gif>")
+    assert_equal("gif", $x.sub(/.*\.([^\.]+)$/, '\1'))
+    assert_equal("b.gif", $x.sub(/.*\.([^\.]+)$/, 'b.\1'))
+    assert_equal("", $x.sub(/.*\.([^\.]+)$/, '\2'))
+    assert_equal("ab", $x.sub(/.*\.([^\.]+)$/, 'a\2b'))
+    assert_equal("<a.gif>", $x.sub(/.*\.([^\.]+)$/, '<\&>'))
   end
 
   def test_char
     # character constants(assumes ASCII)
-    assert_equal("a"[0], ?a)
+    assert_equal(?a, "a"[0])
     assert_equal(?a, ?a)
-    assert_equal(?\C-a, 1)
-    assert_equal(?\M-a, 225)
-    assert_equal(?\M-\C-a, 129)
-    assert_equal("a".upcase![0], ?A)
-    assert_equal("A".downcase![0], ?a)
-    assert_equal("abc".tr!("a-z", "A-Z"), "ABC")
-    assert_equal("aabbcccc".tr_s!("a-z", "A-Z"), "ABC")
-    assert_equal("abcc".squeeze!("a-z"), "abc")
-    assert_equal("abcd".delete!("bc"), "ad")
-    
+    assert_equal(1, ?\C-a)
+    assert_equal(225, ?\M-a)
+    assert_equal(129, ?\M-\C-a)
+    assert_equal(?A, "a".upcase![0])
+    assert_equal(?a, "A".downcase![0])
+    assert_equal("ABC", "abc".tr!("a-z", "A-Z"))
+    assert_equal("ABC", "aabbcccc".tr_s!("a-z", "A-Z"))
+    assert_equal("abc", "abcc".squeeze!("a-z"))
+    assert_equal("ad", "abcd".delete!("bc"))
+
     $x = "abcdef"
     $y = [ ?a, ?b, ?c, ?d, ?e, ?f ]
     $bad = false
@@ -90,29 +90,29 @@ END
       end
     }
     assert(!$bad)
-    
+
     s = "a string"
     s[0..s.size]="another string"
-    assert_equal(s, "another string")
-    
+    assert_equal("another string", s)
+
     s = <<EOS
 #{
 [1,2,3].join(",")
 }
 EOS
-    assert_equal(s, "1,2,3\n")
-    assert_equal("Just".to_i(36), 926381)
-    assert_equal("-another".to_i(36), -23200231779)
-    assert_equal(1299022.to_s(36), "ruby")
-    assert_equal(-1045307475.to_s(36), "-hacker")
-    assert_equal("Just_another_Ruby_hacker".to_i(36), 265419172580680477752431643787347)
-    assert_equal(-265419172580680477752431643787347.to_s(36), "-justanotherrubyhacker")
-    
+    assert_equal("1,2,3\n", s)
+    assert_equal(926381, "Just".to_i(36))
+    assert_equal(-23200231779, "-another".to_i(36))
+    assert_equal("ruby", 1299022.to_s(36))
+    assert_equal("-hacker", -1045307475.to_s(36))
+    assert_equal(265419172580680477752431643787347, "Just_another_Ruby_hacker".to_i(36))
+    assert_equal("-justanotherrubyhacker", -265419172580680477752431643787347.to_s(36))
+
     a = []
     (0..255).each {|n|
-      ch = [n].pack("C")                     
-      a.push ch if /a#{Regexp.quote ch}b/x =~ "ab" 
+      ch = [n].pack("C")
+      a.push ch if /a#{Regexp.quote ch}b/x =~ "ab"
     }
-    assert_equal(a.size, 0)
+    assert_equal(0, a.size)
   end
 end