docdiff 0.6.2 → 0.6.4

data/test/charstring_test.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/ruby
-# -*- coding: euc-jp; -*-
+# -*- coding: utf-8; -*-
 
 # frozen_string_literal: false
 
@@ -90,12 +90,12 @@ class TC_DocDiff_CharString < Test::Unit::TestCase
     assert_equal(expected, str.eol_char)
   end
   def test_eol_char_none_eucjp()
-    str = NKF.nkf("-e", "���ܸ�a b").extend CharString
+    str = NKF.nkf("--euc", "日本語a b").extend CharString
     expected = nil
     assert_equal(expected, str.eol_char)
   end
   def test_eol_char_none_sjis()
-    str = NKF.nkf("-s", "���ܸ�a b").extend CharString
+    str = NKF.nkf("--sjis", "日本語a b").extend CharString
     expected = nil
     assert_equal(expected, str.eol_char)
   end
@@ -325,176 +325,176 @@ class TC_DocDiff_CharString < Test::Unit::TestCase
 
   # test EUCJP module
   def test_eucjp_split_to_word()
-    str = NKF.nkf("-e", "���ܸ��ʸ��foo bar").extend CharString
+    str = NKF.nkf("--euc", "日本語の文字foo bar").extend CharString
     str.encoding = "EUC-JP"
-    expected = ["���ܸ��","ʸ��","foo ","bar"].collect{|c| NKF.nkf("-e", c)}
+    expected = ["日本語の","文字","foo ","bar"].map{|c| NKF.nkf("--euc", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_eucjp_split_to_word_kanhira()
-    str = NKF.nkf("-e", "���ܸ��ʸ��").extend CharString
+    str = NKF.nkf("--euc", "日本語の文字").extend CharString
     str.encoding = "EUC-JP"
-    expected = ["���ܸ��", "ʸ��"].collect{|c| NKF.nkf("-e", c)}
+    expected = ["日本語の", "文字"].map{|c| NKF.nkf("--euc", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_eucjp_split_to_word_katahira()
-    str = NKF.nkf("-e", "�������ʤ�ʸ��").extend CharString
+    str = NKF.nkf("--euc", "カタカナの文字").extend CharString
     str.encoding = "EUC-JP"
-    expected = ["�������ʤ�", "ʸ��"].collect{|c| NKF.nkf("-e", c)}
+    expected = ["カタカナの", "文字"].map{|c| NKF.nkf("--euc", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_eucjp_split_to_word_kataonbiki()
-    str = NKF.nkf("-e", "��ӡ�������").extend CharString
+    str = NKF.nkf("--euc", "ルビー色の石").extend CharString
     str.encoding = "EUC-JP" #<= needed to pass the test
-    expected = ["��ӡ�", "����", "��"].collect{|c| NKF.nkf("-e", c)}
+    expected = ["ルビー", "色の", "石"].map{|c| NKF.nkf("--euc", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_eucjp_split_to_word_hiraonbiki()
-    str = NKF.nkf("-e", "���ӡ���").extend CharString
+    str = NKF.nkf("--euc", "わールビーだ").extend CharString
     str.encoding = "EUC-JP" #<= needed to pass the test
-    expected = ["�", "��ӡ���"].collect{|c| NKF.nkf("-e", c)}
+    expected = ["わー", "ルビーだ"].map{|c| NKF.nkf("--euc", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_eucjp_split_to_word_latinmix()
-    str = NKF.nkf("-e", "���ܸ��Latin��ʸ��").extend CharString
+    str = NKF.nkf("--euc", "日本語とLatinの文字").extend CharString
     str.encoding = "EUC-JP"
-    expected = ["���ܸ��", "Latin", "��", "ʸ��"].collect{|c| NKF.nkf("-e", c)}
+    expected = ["日本語と", "Latin", "の", "文字"].map{|c| NKF.nkf("--euc", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_eucjp_split_to_char()
-    str = NKF.nkf("-e", "���ܸ�a b").extend CharString
+    str = NKF.nkf("--euc", "日本語a b").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "LF" #<= needed to pass the test
-    expected = ["��","��","��","a"," ","b"].collect{|c|NKF.nkf("-e",c)}
+    expected = ["日","本","語","a"," ","b"].map{|c|NKF.nkf("--euc",c)}
     assert_equal(expected, str.split_to_char)
   end
   def test_eucjp_split_to_char_with_cr()
-    str = NKF.nkf("-e", "���ܸ�a b\r").extend CharString
+    str = NKF.nkf("--euc", "日本語a b\r").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CR"
-    expected = ["��","��","��","a"," ","b","\r"].collect{|c|NKF.nkf("-e",c)}
+    expected = ["日","本","語","a"," ","b","\r"].map{|c|NKF.nkf("--euc",c)}
     assert_equal(expected, str.split_to_char)
   end
   def test_eucjp_split_to_char_with_lf()
-    str = NKF.nkf("-e", "���ܸ�a b\n").extend CharString
+    str = NKF.nkf("--euc", "日本語a b\n").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "LF"
-    expected = ["��","��","��","a"," ","b","\n"].collect{|c|NKF.nkf("-e",c)}
+    expected = ["日","本","語","a"," ","b","\n"].map{|c|NKF.nkf("--euc",c)}
     assert_equal(expected, str.split_to_char)
   end
   def test_eucjp_split_to_char_with_crlf()
-    str = NKF.nkf("-e", "���ܸ�a b\r\n").extend CharString
+    str = NKF.nkf("--euc", "日本語a b\r\n").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
-    expected = ["��","��","��","a"," ","b","\r\n"].collect{|c|NKF.nkf("-e",c)}
+    expected = ["日","本","語","a"," ","b","\r\n"].map{|c|NKF.nkf("--euc",c)}
     assert_equal(expected, str.split_to_char)
   end
   def test_eucjp_count_char()
-    str = NKF.nkf("-e", "���ܸ�a b\r\n").extend CharString
+    str = NKF.nkf("--euc", "日本語a b\r\n").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 7
     assert_equal(expected, str.count_char)
   end
   def test_eucjp_count_latin_graph_char()
-    str = NKF.nkf("-e", "���ܸ�a b\r\n").extend CharString
+    str = NKF.nkf("--euc", "日本語a b\r\n").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 2
     assert_equal(expected, str.count_latin_graph_char)
   end
   def test_eucjp_count_ja_graph_char()
-    str = NKF.nkf("-e", "���ܸ�a b\r\n").extend CharString
+    str = NKF.nkf("--euc", "日本語a b\r\n").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 3
     assert_equal(expected, str.count_ja_graph_char)
   end
   def test_eucjp_count_graph_char()
-    str = NKF.nkf("-e", "���ܸ�a b\r\n").extend CharString
+    str = NKF.nkf("--euc", "日本語a b\r\n").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 5
     assert_equal(expected, str.count_graph_char)
   end
   def test_eucjp_count_latin_blank_char()
-    str = NKF.nkf("-e", "���ܸ�\ta b\r\n").extend CharString
+    str = NKF.nkf("--euc", "日本語\ta b\r\n").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 2
     assert_equal(expected, str.count_latin_blank_char)
   end
   def test_eucjp_count_ja_blank_char()
-    str = NKF.nkf("-e", "���ܡ���\ta b\r\n").extend CharString
+    str = NKF.nkf("--euc", "日本　語\ta b\r\n").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 1
     assert_equal(expected, str.count_ja_blank_char)
   end
   def test_eucjp_count_blank_char()
-    str = NKF.nkf("-e", "���ܡ���\ta b\r\n").extend CharString
+    str = NKF.nkf("--euc", "日本　語\ta b\r\n").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 3
     assert_equal(expected, str.count_blank_char)
   end
   def test_eucjp_count_word()
-    str = NKF.nkf("-e", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--euc", "日本　語a b --\r\n").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 7 # "--" and "\r\n" are counted as word here (though not "valid")
     assert_equal(expected, str.count_word)
   end
   def test_eucjp_count_ja_word()
-    str = NKF.nkf("-e", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--euc", "日本　語a b --\r\n").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 3
     assert_equal(expected, str.count_ja_word)
   end
   def test_eucjp_count_latin_valid_word()
-    str = NKF.nkf("-e", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--euc", "日本　語a b --\r\n").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 2
     assert_equal(expected, str.count_latin_valid_word)
   end
   def test_eucjp_count_ja_valid_word()
-    str = NKF.nkf("-e", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--euc", "日本　語a b --\r\n").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 2
     assert_equal(expected, str.count_ja_valid_word)
   end
   def test_eucjp_count_valid_word()
-    str = NKF.nkf("-e", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--euc", "日本　語a b --\r\n").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 4
     assert_equal(expected, str.count_valid_word)
   end
   def test_eucjp_count_line()
-    str = NKF.nkf("-e", "���ܸ�\r\n��\r\n \r\n\r\nfoo\r\nbar").extend CharString
+    str = NKF.nkf("--euc", "日本語\r\n　\r\n \r\n\r\nfoo\r\nbar").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 6
     assert_equal(expected, str.count_line)
   end
   def test_eucjp_count_graph_line()
-    str = NKF.nkf("-e", "���ܸ�\r\n��\r\n \r\n\r\nfoo\r\nbar").extend CharString
+    str = NKF.nkf("--euc", "日本語\r\n　\r\n \r\n\r\nfoo\r\nbar").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 3
     assert_equal(expected, str.count_graph_line)
   end
   def test_eucjp_count_empty_line()
-    str = NKF.nkf("-e", "���ܸ�\r\n��\r\n \r\n\r\nfoo\r\nbar").extend CharString
+    str = NKF.nkf("--euc", "日本語\r\n　\r\n \r\n\r\nfoo\r\nbar").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 1
     assert_equal(expected, str.count_empty_line)
   end
   def test_eucjp_count_blank_line()
-    str = NKF.nkf("-e", "���ܸ�\r\n��\r\n \r\n\r\nfoo\r\nbar").extend CharString
+    str = NKF.nkf("--euc", "日本語\r\n　\r\n \r\n\r\nfoo\r\nbar").extend CharString
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = 2
@@ -503,176 +503,176 @@ class TC_DocDiff_CharString < Test::Unit::TestCase
 
   # test SJIS module
   def test_sjis_split_to_word()
-    str = NKF.nkf("-s", "���ܸ��ʸ��foo bar").extend CharString
+    str = NKF.nkf("--sjis", "日本語の文字foo bar").extend CharString
     str.encoding = "Shift_JIS"
-    expected = ["���ܸ��", "ʸ��", "foo ", "bar"].collect{|c|NKF.nkf("-s",c)}
+    expected = ["日本語の", "文字", "foo ", "bar"].map{|c|NKF.nkf("--sjis",c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_sjisplit_s_to_word_kanhira()
-    str = NKF.nkf("-s", "���ܸ��ʸ��").extend CharString
+    str = NKF.nkf("--sjis", "日本語の文字").extend CharString
     str.encoding = "Shift_JIS"
-    expected = ["���ܸ��", "ʸ��"].collect{|c| NKF.nkf("-s", c)}
+    expected = ["日本語の", "文字"].map{|c| NKF.nkf("--sjis", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_sjis_split_to_word_katahira()
-    str = NKF.nkf("-s", "�������ʤ�ʸ��").extend CharString
+    str = NKF.nkf("--sjis", "カタカナの文字").extend CharString
     str.encoding = "Shift_JIS"
-    expected = ["�������ʤ�", "ʸ��"].collect{|c| NKF.nkf("-s", c)}
+    expected = ["カタカナの", "文字"].map{|c| NKF.nkf("--sjis", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_sjis_split_to_word_kataonbiki()
-    str = NKF.nkf("-s", "��ӡ��λ���").extend CharString
+    str = NKF.nkf("--sjis", "ルビーの指輪").extend CharString
     str.encoding = "Shift_JIS"
-    expected = ["��ӡ���", "����"].collect{|c| NKF.nkf("-s", c)}
+    expected = ["ルビーの", "指輪"].map{|c| NKF.nkf("--sjis", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_sjis_split_to_word_hiraonbiki()
-    str = NKF.nkf("-s", "���ӡ���").extend CharString
+    str = NKF.nkf("--sjis", "わールビーだ").extend CharString
     str.encoding = "Shift_JIS"
-    expected = ["�", "��ӡ���"].collect{|c| NKF.nkf("-s", c)}
+    expected = ["わー", "ルビーだ"].map{|c| NKF.nkf("--sjis", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_sjis_split_to_word_latinmix()
-    str = NKF.nkf("-s", "���ܸ��Latin��ʸ��").extend CharString
+    str = NKF.nkf("--sjis", "日本語とLatinの文字").extend CharString
     str.encoding = "Shift_JIS"
-    expected = ["���ܸ��","Latin","��","ʸ��"].collect{|c| NKF.nkf("-s", c)}
+    expected = ["日本語と","Latin","の","文字"].map{|c| NKF.nkf("--sjis", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_sjis_split_to_char()
-    str = NKF.nkf("-s", "ɽ�׻�a b").extend CharString
+    str = NKF.nkf("--sjis", "表計算a b").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "LF" #<= needed to pass the test
-    expected = ["ɽ","��","��","a"," ","b"].collect{|c|NKF.nkf("-s",c)}
+    expected = ["表","計","算","a"," ","b"].map{|c|NKF.nkf("--sjis",c)}
     assert_equal(expected, str.split_to_char)
   end
   def test_sjis_split_to_char_with_cr()
-    str = NKF.nkf("-s", "ɽ�׻�a b\r").extend CharString
+    str = NKF.nkf("--sjis", "表計算a b\r").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CR"
-    expected = ["ɽ","��","��","a"," ","b","\r"].collect{|c|NKF.nkf("-s",c)}
+    expected = ["表","計","算","a"," ","b","\r"].map{|c|NKF.nkf("--sjis",c)}
     assert_equal(expected, str.split_to_char)
   end
   def test_sjis_split_to_char_with_lf()
-    str = NKF.nkf("-s", "ɽ�׻�a b\n").extend CharString
+    str = NKF.nkf("--sjis", "表計算a b\n").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "LF"
-    expected = ["ɽ","��","��","a"," ","b","\n"].collect{|c|NKF.nkf("-s",c)}
+    expected = ["表","計","算","a"," ","b","\n"].map{|c|NKF.nkf("--sjis",c)}
     assert_equal(expected, str.split_to_char)
   end
   def test_sjis_split_to_char_with_crlf()
-    str = NKF.nkf("-s", "ɽ�׻�a b\r\n").extend CharString
+    str = NKF.nkf("--sjis", "表計算a b\r\n").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
-    expected = ["ɽ","��","��","a"," ","b","\r\n"].collect{|c|NKF.nkf("-s",c)}
+    expected = ["表","計","算","a"," ","b","\r\n"].map{|c|NKF.nkf("--sjis",c)}
     assert_equal(expected, str.split_to_char)
   end
   def test_sjis_count_char()
-    str = NKF.nkf("-s", "���ܸ�a b\r\n").extend CharString
+    str = NKF.nkf("--sjis", "日本語a b\r\n").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 7
     assert_equal(expected, str.count_char)
   end
   def test_sjis_count_latin_graph_char()
-    str = NKF.nkf("-s", "���ܸ�a b\r\n").extend CharString
+    str = NKF.nkf("--sjis", "日本語a b\r\n").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 2
     assert_equal(expected, str.count_latin_graph_char)
   end
   def test_sjis_count_ja_graph_char()
-    str = NKF.nkf("-s", "���ܸ�a b\r\n").extend CharString
+    str = NKF.nkf("--sjis", "日本語a b\r\n").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 3
     assert_equal(expected, str.count_ja_graph_char)
   end
   def test_sjis_count_graph_char()
-    str = NKF.nkf("-s", "���ܸ�a b\r\n").extend CharString
+    str = NKF.nkf("--sjis", "日本語a b\r\n").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 5
     assert_equal(expected, str.count_graph_char)
   end
   def test_sjis_count_latin_blank_char()
-    str = NKF.nkf("-s", "���ܸ�\ta b\r\n").extend CharString
+    str = NKF.nkf("--sjis", "日本語\ta b\r\n").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 2
     assert_equal(expected, str.count_latin_blank_char)
   end
   def test_sjis_count_ja_blank_char()
-    str = NKF.nkf("-s", "���ܡ���\ta b\r\n").extend CharString
+    str = NKF.nkf("--sjis", "日本　語\ta b\r\n").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 1
     assert_equal(expected, str.count_ja_blank_char)
   end
   def test_sjis_count_blank_char()
-    str = NKF.nkf("-s", "���ܡ���\ta b\r\n").extend CharString
+    str = NKF.nkf("--sjis", "日本　語\ta b\r\n").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 3
     assert_equal(expected, str.count_blank_char)
   end
   def test_sjis_count_word()
-    str = NKF.nkf("-s", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--sjis", "日本　語a b --\r\n").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 7 # "--" and "\r\n" are counted as word here (though not "valid")
     assert_equal(expected, str.count_word)
   end
   def test_sjis_count_ja_word()
-    str = NKF.nkf("-s", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--sjis", "日本　語a b --\r\n").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 3
     assert_equal(expected, str.count_ja_word)
   end
   def test_sjis_count_latin_valid_word()
-    str = NKF.nkf("-s", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--sjis", "日本　語a b --\r\n").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 2
     assert_equal(expected, str.count_latin_valid_word)
   end
   def test_sjis_count_ja_valid_word()
-    str = NKF.nkf("-s", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--sjis", "日本　語a b --\r\n").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 2
     assert_equal(expected, str.count_ja_valid_word)
   end
   def test_sjis_count_valid_word()
-    str = NKF.nkf("-s", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--sjis", "日本　語a b --\r\n").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 4
     assert_equal(expected, str.count_valid_word)
   end
   def test_sjis_count_line()
-    str = NKF.nkf("-s", "���ܸ�\r\n��\r\n \r\n\r\nfoo\r\nbar").extend CharString
+    str = NKF.nkf("--sjis", "日本語\r\n　\r\n \r\n\r\nfoo\r\nbar").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 6
     assert_equal(expected, str.count_line)
   end
   def test_sjis_count_graph_line()
-    str = NKF.nkf("-s", "���ܸ�\r\n��\r\n \r\n\r\nfoo\r\nbar").extend CharString
+    str = NKF.nkf("--sjis", "日本語\r\n　\r\n \r\n\r\nfoo\r\nbar").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 3
     assert_equal(expected, str.count_graph_line)
   end
   def test_sjis_count_empty_line()
-    str = NKF.nkf("-s", "���ܸ�\r\n��\r\n \r\n\r\nfoo\r\nbar").extend CharString
+    str = NKF.nkf("--sjis", "日本語\r\n　\r\n \r\n\r\nfoo\r\nbar").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 1
     assert_equal(expected, str.count_empty_line)
   end
   def test_sjis_count_blank_line()
-    str = NKF.nkf("-s", "���ܸ�\r\n��\r\n \r\n\r\nfoo\r\nbar").extend CharString
+    str = NKF.nkf("--sjis", "日本語\r\n　\r\n \r\n\r\nfoo\r\nbar").extend CharString
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = 2
@@ -681,176 +681,176 @@ class TC_DocDiff_CharString < Test::Unit::TestCase
 
   # test UTF8 module
   def test_utf8_split_to_word()
-    str = NKF.nkf("-E -w", "���ܸ��ʸ��foo bar").extend CharString
+    str = NKF.nkf("--utf8", "日本語の文字foo bar").extend CharString
     str.encoding = "UTF-8"
-    expected = ["���ܸ��", "ʸ��", "foo ", "bar"].collect{|c| NKF.nkf("-E -w", c)}
+    expected = ["日本語の", "文字", "foo ", "bar"].map{|c| NKF.nkf("--utf8", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_utf8_split_to_word_kanhira()
-    str = NKF.nkf("-E -w", "���ܸ��ʸ��").extend CharString
+    str = NKF.nkf("--utf8", "日本語の文字").extend CharString
     str.encoding = "UTF-8"
-    expected = ["���ܸ��", "ʸ��"].collect{|c| NKF.nkf("-E -w", c)}
+    expected = ["日本語の", "文字"].map{|c| NKF.nkf("--utf8", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_utf8_split_to_word_katahira()
-    str = NKF.nkf("-E -w", "�������ʤ�ʸ��").extend CharString
+    str = NKF.nkf("--utf8", "カタカナの文字").extend CharString
     str.encoding = "UTF-8"
-    expected = ["�������ʤ�", "ʸ��"].collect{|c| NKF.nkf("-E -w", c)}
+    expected = ["カタカナの", "文字"].map{|c| NKF.nkf("--utf8", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_utf8_split_to_word_kataonbiki()
-    str = NKF.nkf("-E -w", "��ӡ��λ���").extend CharString
+    str = NKF.nkf("--utf8", "ルビーの指輪").extend CharString
     str.encoding = "UTF-8"
-    expected = ["��ӡ���", "����"].collect{|c| NKF.nkf("-E -w", c)}
+    expected = ["ルビーの", "指輪"].map{|c| NKF.nkf("--utf8", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_utf8_split_to_word_hiraonbiki()
-    str = NKF.nkf("-E -w", "���ӡ���").extend CharString
+    str = NKF.nkf("--utf8", "わールビーだ").extend CharString
     str.encoding = "UTF-8"
-    expected = ["�", "��ӡ���"].collect{|c| NKF.nkf("-E -w", c)}
+    expected = ["わー", "ルビーだ"].map{|c| NKF.nkf("--utf8", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_utf8_split_to_word_latinmix()
-    str = NKF.nkf("-E -w", "���ܸ��Latin��ʸ��").extend CharString
+    str = NKF.nkf("--utf8", "日本語とLatinの文字").extend CharString
     str.encoding = "UTF-8"
-    expected = ["���ܸ��", "Latin", "��", "ʸ��"].collect{|c| NKF.nkf("-E -w", c)}
+    expected = ["日本語と", "Latin", "の", "文字"].map{|c| NKF.nkf("--utf8", c)}
     assert_equal(expected, str.split_to_word)
   end
   def test_utf8_split_to_char()
-    str = NKF.nkf("-E -w", "���ܸ�a b").extend CharString
+    str = NKF.nkf("--utf8", "日本語a b").extend CharString
     str.encoding = "UTF-8" #<= needed to pass the test
     str.eol = "LF"        #<= needed to pass the test
-    expected = ["��", "��", "��", "a", " ", "b"].collect{|c| NKF.nkf("-E -w", c)}
+    expected = ["日", "本", "語", "a", " ", "b"].map{|c| NKF.nkf("--utf8", c)}
     assert_equal(expected, str.split_to_char)
   end
   def test_utf8_split_to_char_with_cr()
-    str = NKF.nkf("-E -w", "���ܸ�a b\r").extend CharString
+    str = NKF.nkf("--utf8", "日本語a b\r").extend CharString
     str.encoding = "UTF-8" #<= needed to pass the test
     str.eol = "CR"
-    expected = ["��","��","��","a"," ","b","\r"].collect{|c| NKF.nkf("-E -w", c)}
+    expected = ["日","本","語","a"," ","b","\r"].map{|c| NKF.nkf("--utf8", c)}
     assert_equal(expected, str.split_to_char)
   end
   def test_utf8_split_to_char_with_lf()
-    str = NKF.nkf("-E -w", "���ܸ�a b\n").extend CharString
+    str = NKF.nkf("--utf8", "日本語a b\n").extend CharString
     str.encoding = "UTF-8" #<= needed to pass the test
     str.eol = "LF"
-    expected = ["��","��","��","a"," ","b","\n"].collect{|c| NKF.nkf("-E -w", c)}
+    expected = ["日","本","語","a"," ","b","\n"].map{|c| NKF.nkf("--utf8", c)}
     assert_equal(expected, str.split_to_char)
   end
   def test_utf8_split_to_char_with_crlf()
-    str = NKF.nkf("-E -w", "���ܸ�a b\r\n").extend CharString
+    str = NKF.nkf("--utf8", "日本語a b\r\n").extend CharString
     str.encoding = "UTF-8"#<= needed to pass the test
     str.eol = "CRLF"
-    expected = ["��","��","��","a"," ","b","\r\n"].collect{|c| NKF.nkf("-E -w", c)}
+    expected = ["日","本","語","a"," ","b","\r\n"].map{|c| NKF.nkf("--utf8", c)}
     assert_equal(expected, str.split_to_char)
   end
   def test_utf8_count_char()
-    str = NKF.nkf("-E -w", "���ܸ�a b\r\n").extend CharString
+    str = NKF.nkf("--utf8", "日本語a b\r\n").extend CharString
     str.encoding = "UTF-8" #<= needed to pass the test
     str.eol = "CRLF"
     expected = 7
     assert_equal(expected, str.count_char)
   end
   def test_utf8_count_latin_graph_char()
-    str = NKF.nkf("-E -w", "���ܸ�a b\r\n").extend CharString
+    str = NKF.nkf("--utf8", "日本語a b\r\n").extend CharString
     str.encoding = "UTF-8" #<= needed to pass the test
     str.eol = "CRLF"
     expected = 2
     assert_equal(expected, str.count_latin_graph_char)
   end
   def test_utf8_count_ja_graph_char()
-    str = NKF.nkf("-E -w", "���ܸ�a b\r\n").extend CharString
+    str = NKF.nkf("--utf8", "日本語a b\r\n").extend CharString
     str.encoding = "UTF-8" #<= needed to pass the test
     str.eol = "CRLF"
     expected = 3
     assert_equal(expected, str.count_ja_graph_char)
   end
   def test_utf8_count_graph_char()
-    str = NKF.nkf("-E -w", "���ܸ�a b\r\n").extend CharString
+    str = NKF.nkf("--utf8", "日本語a b\r\n").extend CharString
     str.encoding = "UTF-8" #<= needed to passs the test
     str.eol = "CRLF"
     expected = 5
     assert_equal(expected, str.count_graph_char)
   end
   def test_utf8_count_latin_blank_char()
-    str = NKF.nkf("-E -w", "���ܸ�\ta b\r\n").extend CharString
+    str = NKF.nkf("--utf8", "日本語\ta b\r\n").extend CharString
     str.encoding = "UTF-8"
     str.eol = "CRLF"
     expected = 2
     assert_equal(expected, str.count_latin_blank_char)
   end
   def test_utf8_count_ja_blank_char()
-    str = NKF.nkf("-E -w", "���ܡ���\ta b\r\n").extend CharString
+    str = NKF.nkf("--utf8", "日本　語\ta b\r\n").extend CharString
     str.encoding = "UTF-8"
     str.eol = "CRLF"
     expected = 1
     assert_equal(expected, str.count_ja_blank_char)
   end
   def test_utf8_count_blank_char()
-    str = NKF.nkf("-E -w", "���ܡ���\ta b\r\n").extend CharString
+    str = NKF.nkf("--utf8", "日本　語\ta b\r\n").extend CharString
     str.encoding = "UTF-8"
     str.eol = "CRLF"
     expected = 3
     assert_equal(expected, str.count_blank_char)
   end
   def test_utf8_count_word()
-    str = NKF.nkf("-E -w", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--utf8", "日本　語a b --\r\n").extend CharString
     str.encoding = "UTF-8"
     str.eol = "CRLF"
     expected = 7 # "--" and "\r\n" are counted as word here (though not "valid")
     assert_equal(expected, str.count_word)
   end
   def test_utf8_count_ja_word()
-    str = NKF.nkf("-E -w", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--utf8", "日本　語a b --\r\n").extend CharString
     str.encoding = "UTF-8"
     str.eol = "CRLF"
     expected = 3
     assert_equal(expected, str.count_ja_word)
   end
   def test_utf8_count_latin_valid_word()
-    str = NKF.nkf("-E -w", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--utf8", "日本　語a b --\r\n").extend CharString
     str.encoding = "UTF-8"
     str.eol = "CRLF"
     expected = 2
     assert_equal(expected, str.count_latin_valid_word)
   end
   def test_utf8_count_ja_valid_word()
-    str = NKF.nkf("-E -w", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--utf8", "日本　語a b --\r\n").extend CharString
     str.encoding = "UTF-8"
     str.eol = "CRLF"
     expected = 2
     assert_equal(expected, str.count_ja_valid_word)
   end
   def test_utf8_count_valid_word()
-    str = NKF.nkf("-E -w", "���ܡ���a b --\r\n").extend CharString
+    str = NKF.nkf("--utf8", "日本　語a b --\r\n").extend CharString
     str.encoding = "UTF-8"
     str.eol = "CRLF"
     expected = 4
     assert_equal(expected, str.count_valid_word)
   end
   def test_utf8_count_line()
-    str = NKF.nkf("-E -w", "���ܸ�\r\n��\r\n \r\n\r\nfoo\r\nbar").extend CharString
+    str = NKF.nkf("--utf8", "日本語\r\n　\r\n \r\n\r\nfoo\r\nbar").extend CharString
     str.encoding = "UTF-8"
     str.eol = "CRLF"
     expected = 6
     assert_equal(expected, str.count_line)
   end
   def test_utf8_count_graph_line()
-    str = NKF.nkf("-E -w", "���ܸ�\r\n��\r\n \r\n\r\nfoo\r\nbar").extend CharString
+    str = NKF.nkf("--utf8", "日本語\r\n　\r\n \r\n\r\nfoo\r\nbar").extend CharString
     str.encoding = "UTF-8"
     str.eol = "CRLF"
     expected = 3
     assert_equal(expected, str.count_graph_line)
   end
   def test_utf8_count_empty_line()
-    str = NKF.nkf("-E -w", "���ܸ�\r\n��\r\n \r\n\r\nfoo\r\nbar").extend CharString
+    str = NKF.nkf("--utf8", "日本語\r\n　\r\n \r\n\r\nfoo\r\nbar").extend CharString
     str.encoding = "UTF-8"
     str.eol = "CRLF"
     expected = 1
     assert_equal(expected, str.count_empty_line)
   end
   def test_utf8_count_blank_line()
-    str = NKF.nkf("-E -w", "���ܸ�\r\n��\r\n \r\n\r\nfoo\r\nbar").extend CharString
+    str = NKF.nkf("--utf8", "日本語\r\n　\r\n \r\n\r\nfoo\r\nbar").extend CharString
     str.encoding = "UTF-8"
     str.eol = "CRLF"
     expected = 2
@@ -890,52 +890,52 @@ class TC_DocDiff_CharString < Test::Unit::TestCase
   end
 # CharString.guess_encoding mistakes JIS for ASCII sometimes, due to Iconv.
 #   def test_guess_encoding_jis_1()
-#     str = NKF.nkf("-j", "�����ȥ������ʤȤҤ餬��\n")
+#     str = NKF.nkf("--jis", "漢字とカタカナとひらがな\n")
 #     expected = "JIS"
 #     assert_guess_encoding(expected, str)
 #   end
 #   def test_guess_encoding_jis_2()
-#     str = NKF.nkf("-j", "�����ȥ������ʤȤҤ餬�ʤ�Latin��ʸ���ȶ���( )�ȵ���@\n" * 100)
+#     str = NKF.nkf("--jis", "漢字とカタカナとひらがなとLatinの文字と空白( )と記号@\n" * 100)
 #     expected = "JIS"
 #     assert_guess_encoding(expected, str)
 #   end
   def test_guess_encoding_eucjp_1()
-    str = NKF.nkf("-e", "���ܸ��Latin��ʸ��")
+    str = NKF.nkf("--euc", "日本語とLatinの文字")
     expected = "EUC-JP"
     assert_guess_encoding(expected, str)
   end
   def test_guess_encoding_eucjp_2()
-    str = NKF.nkf('-e', "�����ȥ������ʤȤҤ餬�ʤ�Latin��ʸ���ȶ���( )\n" * 10)
+    str = NKF.nkf("--euc", "漢字とカタカナとひらがなとLatinの文字と空白( )\n" * 10)
     expected = "EUC-JP"
     assert_guess_encoding(expected, str)
   end
   def test_guess_encoding_eucjp_3()
-    str = NKF.nkf('-e', "����Ф�ϡ����̾���ϤޤĤ�ȤǤ���\nRuby���ä��Τϻ�Ǥ������Ruby Hacker�Ǥ���\n")
+    str = NKF.nkf("--euc", "こんばんは、私の名前はまつもとです。\nRubyを作ったのは私です。私はRuby Hackerです。\n")
     expected = "EUC-JP"
     assert_guess_encoding(expected, str)
   end
   def test_guess_encoding_sjis_1()
-    str = NKF.nkf("-s", "���ܸ��Latin��ʸ��")
+    str = NKF.nkf("--sjis", "日本語とLatinの文字")
     expected = "Shift_JIS"
     assert_guess_encoding(expected, str)
   end
   def test_guess_encoding_sjis_2()
-    str = NKF.nkf('-s', "������\n�������ʤ�\n�Ҥ餬�ʤ�\nLatin")
+    str = NKF.nkf("--sjis", "漢字と\nカタカナと\nひらがなと\nLatin")
     expected = "Shift_JIS"
     assert_guess_encoding(expected, str)
   end
   def test_guess_encoding_cp932_1()
-    str = NKF.nkf('--oc=CP932', "\\u2460") # CIRCLED DIGIT ONE
+    str = NKF.nkf("--oc=CP932", "\\u2460") # CIRCLED DIGIT ONE
     expected = "Windows-31J" # CP932 == Windows-31J in Ruby 1.9+
     assert_guess_encoding(expected, str)
   end
   def test_guess_encoding_utf8_1()
-    str = NKF.nkf("-E -w", "���ܸ��Latin��ʸ��")
+    str = NKF.nkf("--utf8", "日本語とLatinの文字")
     expected = "UTF-8"
     assert_guess_encoding(expected, str)
   end
   def test_guess_encoding_utf8_2()
-    str = NKF.nkf("-E -w", "������\n�ˤۤؤ�\n")
+    str = NKF.nkf("--utf8", "いろは\nにほへと\n")
     expected = "UTF-8"
     assert_guess_encoding(expected, str)
   end