docdiff 0.6.7 → 0.7.0

data/test/charstring_test.rb

@@ -110,853 +110,853 @@ class TestCharString < Test::Unit::TestCase
     assert_equal(expected, str.eol_char)
   end
 
-  # test eol split_to_line() method
-  def test_cr_split_to_line
+  # test eol to_lines method
+  def test_cr_to_lines
     str = "foo\rbar\r".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CR"
     expected = ["foo\r", "bar\r"]
-    assert_equal(expected, str.split_to_line)
+    assert_equal(expected, str.to_lines)
   end
 
-  def test_cr_split_to_line_chomped_lastline
+  def test_cr_to_lines_chomped_lastline
     str = "foo\rbar".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CR"
     expected = ["foo\r", "bar"]
-    assert_equal(expected, str.split_to_line)
+    assert_equal(expected, str.to_lines)
   end
 
-  def test_cr_split_to_line_empty_line
+  def test_cr_to_lines_empty_line
     str = "foo\r\rbar\r".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CR"
     expected = ["foo\r", "\r", "bar\r"]
-    assert_equal(expected, str.split_to_line)
+    assert_equal(expected, str.to_lines)
   end
 
-  def test_lf_split_to_line
+  def test_lf_to_lines
     str = "foo\nbar\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "LF"
     expected = ["foo\n", "bar\n"]
-    assert_equal(expected, str.split_to_line)
+    assert_equal(expected, str.to_lines)
   end
 
-  def test_lf_split_to_line_chomped_lastline
+  def test_lf_to_lines_chomped_lastline
     str = "foo\nbar".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "LF"
     expected = ["foo\n", "bar"]
-    assert_equal(expected, str.split_to_line)
+    assert_equal(expected, str.to_lines)
   end
 
-  def test_lf_split_to_line_empty_line
+  def test_lf_to_lines_empty_line
     str = "foo\n\nbar\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "LF"
     expected = ["foo\n", "\n", "bar\n"]
-    assert_equal(expected, str.split_to_line)
+    assert_equal(expected, str.to_lines)
   end
 
-  def test_crlf_split_to_line
+  def test_crlf_to_lines
     str = "foo\r\nbar\r\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = ["foo\r\n", "bar\r\n"]
-    assert_equal(expected, str.split_to_line)
+    assert_equal(expected, str.to_lines)
   end
 
-  def test_crlf_split_to_line_chomped_lastline
+  def test_crlf_to_lines_chomped_lastline
     str = "foo\r\nbar".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = ["foo\r\n", "bar"]
-    assert_equal(expected, str.split_to_line)
+    assert_equal(expected, str.to_lines)
   end
 
-  def test_crlf_split_to_line_empty_line
+  def test_crlf_to_lines_empty_line
     str = "foo\r\n\r\nbar\r\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = ["foo\r\n", "\r\n", "bar\r\n"]
-    assert_equal(expected, str.split_to_line)
+    assert_equal(expected, str.to_lines)
   end
 
   # test ASCII module
-  def test_ascii_split_to_word
+  def test_ascii_to_words
     str = "foo bar".extend(CharString)
     str.encoding = "US-ASCII"
     expected = ["foo ", "bar"]
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_ascii_split_to_word_withsymbol
+  def test_ascii_to_words_withsymbol
     str = "foo (bar) baz-baz".extend(CharString)
     str.encoding = "US-ASCII"
     expected = ["foo ", "(bar) ", "baz-baz"]
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_ascii_split_to_word_withquote
+  def test_ascii_to_words_withquote
     str = "foo's 'foo' \"bar\" 'baz.'".extend(CharString)
     str.encoding = "US-ASCII"
     expected = ["foo's ", "'foo' ", "\"bar\" ", "'baz.'"]
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_ascii_split_to_word_withlongspace
+  def test_ascii_to_words_withlongspace
     str = " foo  bar".extend(CharString)
     str.encoding = "US-ASCII"
     expected = [" ", "foo ", " ", "bar"]
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_ascii_split_to_word_withdash
+  def test_ascii_to_words_withdash
     str = "foo -- bar, baz - quux".extend(CharString)
     str.encoding = "US-ASCII"
     expected = ["foo ", "-- ", "bar, ", "baz ", "- ", "quux"]
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_ascii_split_to_char
+  def test_ascii_to_chars
     str = "foo bar".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "LF"
     expected = ["f", "o", "o", " ", "b", "a", "r"]
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_ascii_split_to_char_with_eol_cr
+  def test_ascii_to_chars_with_eol_cr
     str = "foo bar\r".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CR"
     expected = ["f", "o", "o", " ", "b", "a", "r", "\r"]
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_ascii_split_to_char_with_eol_lf
+  def test_ascii_to_chars_with_eol_lf
     str = "foo bar\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "LF"
     expected = ["f", "o", "o", " ", "b", "a", "r", "\n"]
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_ascii_split_to_char_with_eol_crlf
+  def test_ascii_to_chars_with_eol_crlf
     str = "foo bar\r\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = ["f", "o", "o", " ", "b", "a", "r", "\r\n"]
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_ascii_split_to_byte
+  def test_ascii_to_bytes
     str = "foo bar\r\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = ["f", "o", "o", " ", "b", "a", "r", "\r", "\n"]
-    assert_equal(expected, str.split_to_byte)
+    assert_equal(expected, str.to_bytes)
   end
 
-  def test_ascii_count_byte
+  def test_ascii_count_bytes
     str = "foo bar\r\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = 9
-    assert_equal(expected, str.count_byte)
+    assert_equal(expected, str.count_bytes)
   end
 
-  def test_ascii_count_char
+  def test_ascii_count_chars
     str = "foo bar\r\nbaz quux\r\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = 17
-    assert_equal(expected, str.count_char)
+    assert_equal(expected, str.count_chars)
   end
 
-  def test_ascii_count_latin_graph_char
+  def test_ascii_count_latin_graph_chars
     str = "foo bar\r\nbaz quux\r\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = 13
-    assert_equal(expected, str.count_latin_graph_char)
+    assert_equal(expected, str.count_latin_graph_chars)
   end
 
-  def test_ascii_count_graph_char
+  def test_ascii_count_graph_chars
     str = "foo bar\r\nbaz quux\r\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = 13
-    assert_equal(expected, str.count_graph_char)
+    assert_equal(expected, str.count_graph_chars)
   end
 
-  def test_ascii_count_latin_blank_char
+  def test_ascii_count_latin_blank_chars
     str = "foo bar\r\nbaz\tquux\r\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = 2
-    assert_equal(expected, str.count_latin_blank_char)
+    assert_equal(expected, str.count_latin_blank_chars)
   end
 
-  def test_ascii_count_blank_char
+  def test_ascii_count_blank_chars
     str = "foo bar\r\nbaz\tquux\r\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = 2
-    assert_equal(expected, str.count_blank_char)
+    assert_equal(expected, str.count_blank_chars)
   end
 
-  def test_ascii_count_word
+  def test_ascii_count_words
     str = "foo bar   \r\nbaz quux\r\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = 6
-    assert_equal(expected, str.count_word)
+    assert_equal(expected, str.count_words)
   end
 
-  def test_ascii_count_latin_word
+  def test_ascii_count_latin_words
     str = "foo bar   \r\nbaz quux\r\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = 5 # "  " is also counted as a word
-    assert_equal(expected, str.count_latin_word)
+    assert_equal(expected, str.count_latin_words)
   end
 
-  def test_ascii_count_latin_valid_word
+  def test_ascii_count_latin_valid_words
     str = "1 foo   \r\n%%% ()\r\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = 2
-    assert_equal(expected, str.count_latin_valid_word)
+    assert_equal(expected, str.count_latin_valid_words)
   end
 
-  def test_ascii_count_line
+  def test_ascii_count_lines
     str = "foo\r\nbar".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = 2
-    assert_equal(expected, str.count_line)
+    assert_equal(expected, str.count_lines)
   end
 
-  def test_ascii_count_graph_line
+  def test_ascii_count_graph_lines
     str = "foo\r\n ".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = 1
-    assert_equal(expected, str.count_graph_line)
+    assert_equal(expected, str.count_graph_lines)
   end
 
-  def test_ascii_count_empty_line
+  def test_ascii_count_empty_lines
     str = "foo\r\n \r\n\t\r\n\r\n".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = 1
-    assert_equal(expected, str.count_empty_line)
+    assert_equal(expected, str.count_empty_lines)
   end
 
-  def test_ascii_count_blank_line
+  def test_ascii_count_blank_lines
     str = "\r\n \r\n\t\r\n ".extend(CharString)
     str.encoding = "US-ASCII"
     str.eol = "CRLF"
     expected = 3
-    assert_equal(expected, str.count_blank_line)
+    assert_equal(expected, str.count_blank_lines)
   end
 
   # test EUCJP module
-  def test_eucjp_split_to_word
+  def test_eucjp_to_words
     str = NKF.nkf("--euc", "日本語の文字foo bar").extend(CharString)
     str.encoding = "EUC-JP"
     expected = ["日本語の", "文字", "foo ", "bar"].map { |c| NKF.nkf("--euc", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_eucjp_split_to_word_kanhira
+  def test_eucjp_to_words_kanhira
     str = NKF.nkf("--euc", "日本語の文字").extend(CharString)
     str.encoding = "EUC-JP"
     expected = ["日本語の", "文字"].map { |c| NKF.nkf("--euc", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_eucjp_split_to_word_katahira
+  def test_eucjp_to_words_katahira
     str = NKF.nkf("--euc", "カタカナの文字").extend(CharString)
     str.encoding = "EUC-JP"
     expected = ["カタカナの", "文字"].map { |c| NKF.nkf("--euc", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_eucjp_split_to_word_kataonbiki
+  def test_eucjp_to_words_kataonbiki
     str = NKF.nkf("--euc", "ルビー色の石").extend(CharString)
     expected = ["ルビー", "色の", "石"].map { |c| NKF.nkf("--euc", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_eucjp_split_to_word_hiraonbiki
+  def test_eucjp_to_words_hiraonbiki
     str = NKF.nkf("--euc", "わールビーだ").extend(CharString)
     expected = ["わー", "ルビーだ"].map { |c| NKF.nkf("--euc", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_eucjp_split_to_word_latinmix
+  def test_eucjp_to_words_latinmix
     str = NKF.nkf("--euc", "日本語とLatinの文字").extend(CharString)
     str.encoding = "EUC-JP"
     expected = ["日本語と", "Latin", "の", "文字"].map { |c| NKF.nkf("--euc", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_eucjp_split_to_char
+  def test_eucjp_to_chars
     str = NKF.nkf("--euc", "日本語a b").extend(CharString)
     str.encoding = "EUC-JP"
     expected = ["日", "本", "語", "a", " ", "b"].map { |c| NKF.nkf("--euc", c) }
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_eucjp_split_to_char_with_cr
+  def test_eucjp_to_chars_with_cr
     str = NKF.nkf("--euc", "日本語a b\r").extend(CharString)
     str.encoding = "EUC-JP"
     str.eol = "CR"
     expected = ["日", "本", "語", "a", " ", "b", "\r"].map { |c| NKF.nkf("--euc", c) }
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_eucjp_split_to_char_with_lf
+  def test_eucjp_to_chars_with_lf
     str = NKF.nkf("--euc", "日本語a b\n").extend(CharString)
     str.encoding = "EUC-JP"
     str.eol = "LF"
     expected = ["日", "本", "語", "a", " ", "b", "\n"].map { |c| NKF.nkf("--euc", c) }
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_eucjp_split_to_char_with_crlf
+  def test_eucjp_to_chars_with_crlf
     str = NKF.nkf("--euc", "日本語a b\r\n").extend(CharString)
     str.encoding = "EUC-JP"
     str.eol = "CRLF"
     expected = ["日", "本", "語", "a", " ", "b", "\r\n"].map { |c| NKF.nkf("--euc", c) }
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_eucjp_count_char
+  def test_eucjp_count_chars
     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)
+    assert_equal(expected, str.count_chars)
   end
 
-  def test_eucjp_count_latin_graph_char
+  def test_eucjp_count_latin_graph_chars
     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)
+    assert_equal(expected, str.count_latin_graph_chars)
   end
 
-  def test_eucjp_count_ja_graph_char
+  def test_eucjp_count_ja_graph_chars
     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)
+    assert_equal(expected, str.count_ja_graph_chars)
   end
 
-  def test_eucjp_count_graph_char
+  def test_eucjp_count_graph_chars
     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)
+    assert_equal(expected, str.count_graph_chars)
   end
 
-  def test_eucjp_count_latin_blank_char
+  def test_eucjp_count_latin_blank_chars
     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)
+    assert_equal(expected, str.count_latin_blank_chars)
   end
 
-  def test_eucjp_count_ja_blank_char
+  def test_eucjp_count_ja_blank_chars
     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)
+    assert_equal(expected, str.count_ja_blank_chars)
   end
 
-  def test_eucjp_count_blank_char
+  def test_eucjp_count_blank_chars
     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)
+    assert_equal(expected, str.count_blank_chars)
   end
 
-  def test_eucjp_count_word
+  def test_eucjp_count_words
     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)
+    assert_equal(expected, str.count_words)
   end
 
-  def test_eucjp_count_ja_word
+  def test_eucjp_count_ja_words
     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)
+    assert_equal(expected, str.count_ja_words)
   end
 
-  def test_eucjp_count_latin_valid_word
+  def test_eucjp_count_latin_valid_words
     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)
+    assert_equal(expected, str.count_latin_valid_words)
   end
 
-  def test_eucjp_count_ja_valid_word
+  def test_eucjp_count_ja_valid_words
     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)
+    assert_equal(expected, str.count_ja_valid_words)
   end
 
-  def test_eucjp_count_valid_word
+  def test_eucjp_count_valid_words
     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)
+    assert_equal(expected, str.count_valid_words)
   end
 
-  def test_eucjp_count_line
+  def test_eucjp_count_lines
     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)
+    assert_equal(expected, str.count_lines)
   end
 
-  def test_eucjp_count_graph_line
+  def test_eucjp_count_graph_lines
     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)
+    assert_equal(expected, str.count_graph_lines)
   end
 
-  def test_eucjp_count_empty_line
+  def test_eucjp_count_empty_lines
     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)
+    assert_equal(expected, str.count_empty_lines)
   end
 
-  def test_eucjp_count_blank_line
+  def test_eucjp_count_blank_lines
     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
-    assert_equal(expected, str.count_blank_line)
+    assert_equal(expected, str.count_blank_lines)
   end
 
   # test SJIS module
-  def test_sjis_split_to_word
+  def test_sjis_to_words
     str = NKF.nkf("--sjis", "日本語の文字foo bar").extend(CharString)
     str.encoding = "Shift_JIS"
     expected = ["日本語の", "文字", "foo ", "bar"].map { |c| NKF.nkf("--sjis", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_sjisplit_s_to_word_kanhira
+  def test_sjis_to_words_kanhira
     str = NKF.nkf("--sjis", "日本語の文字").extend(CharString)
     str.encoding = "Shift_JIS"
     expected = ["日本語の", "文字"].map { |c| NKF.nkf("--sjis", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_sjis_split_to_word_katahira
+  def test_sjis_to_words_katahira
     str = NKF.nkf("--sjis", "カタカナの文字").extend(CharString)
     str.encoding = "Shift_JIS"
     expected = ["カタカナの", "文字"].map { |c| NKF.nkf("--sjis", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_sjis_split_to_word_kataonbiki
+  def test_sjis_to_words_kataonbiki
     str = NKF.nkf("--sjis", "ルビーの指輪").extend(CharString)
     str.encoding = "Shift_JIS"
     expected = ["ルビーの", "指輪"].map { |c| NKF.nkf("--sjis", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_sjis_split_to_word_hiraonbiki
+  def test_sjis_to_words_hiraonbiki
     str = NKF.nkf("--sjis", "わールビーだ").extend(CharString)
     str.encoding = "Shift_JIS"
     expected = ["わー", "ルビーだ"].map { |c| NKF.nkf("--sjis", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_sjis_split_to_word_latinmix
+  def test_sjis_to_words_latinmix
     str = NKF.nkf("--sjis", "日本語とLatinの文字").extend(CharString)
     str.encoding = "Shift_JIS"
     expected = ["日本語と", "Latin", "の", "文字"].map { |c| NKF.nkf("--sjis", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_sjis_split_to_char
+  def test_sjis_to_chars
     str = NKF.nkf("--sjis", "表計算a b").extend(CharString)
     str.encoding = "Shift_JIS"
     expected = ["表", "計", "算", "a", " ", "b"].map { |c| NKF.nkf("--sjis", c) }
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_sjis_split_to_char_with_cr
+  def test_sjis_to_chars_with_cr
     str = NKF.nkf("--sjis", "表計算a b\r").extend(CharString)
     str.encoding = "Shift_JIS"
     str.eol = "CR"
     expected = ["表", "計", "算", "a", " ", "b", "\r"].map { |c| NKF.nkf("--sjis", c) }
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_sjis_split_to_char_with_lf
+  def test_sjis_to_chars_with_lf
     str = NKF.nkf("--sjis", "表計算a b\n").extend(CharString)
     str.encoding = "Shift_JIS"
     str.eol = "LF"
     expected = ["表", "計", "算", "a", " ", "b", "\n"].map { |c| NKF.nkf("--sjis", c) }
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_sjis_split_to_char_with_crlf
+  def test_sjis_to_chars_with_crlf
     str = NKF.nkf("--sjis", "表計算a b\r\n").extend(CharString)
     str.encoding = "Shift_JIS"
     str.eol = "CRLF"
     expected = ["表", "計", "算", "a", " ", "b", "\r\n"].map { |c| NKF.nkf("--sjis", c) }
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_sjis_count_char
+  def test_sjis_count_chars
     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)
+    assert_equal(expected, str.count_chars)
   end
 
-  def test_sjis_count_latin_graph_char
+  def test_sjis_count_latin_graph_chars
     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)
+    assert_equal(expected, str.count_latin_graph_chars)
   end
 
-  def test_sjis_count_ja_graph_char
+  def test_sjis_count_ja_graph_chars
     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)
+    assert_equal(expected, str.count_ja_graph_chars)
   end
 
-  def test_sjis_count_graph_char
+  def test_sjis_count_graph_chars
     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)
+    assert_equal(expected, str.count_graph_chars)
   end
 
-  def test_sjis_count_latin_blank_char
+  def test_sjis_count_latin_blank_chars
     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)
+    assert_equal(expected, str.count_latin_blank_chars)
   end
 
-  def test_sjis_count_ja_blank_char
+  def test_sjis_count_ja_blank_chars
     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)
+    assert_equal(expected, str.count_ja_blank_chars)
   end
 
-  def test_sjis_count_blank_char
+  def test_sjis_count_blank_chars
     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)
+    assert_equal(expected, str.count_blank_chars)
   end
 
-  def test_sjis_count_word
+  def test_sjis_count_words
     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)
+    assert_equal(expected, str.count_words)
   end
 
-  def test_sjis_count_ja_word
+  def test_sjis_count_ja_words
     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)
+    assert_equal(expected, str.count_ja_words)
   end
 
-  def test_sjis_count_latin_valid_word
+  def test_sjis_count_latin_valid_words
     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)
+    assert_equal(expected, str.count_latin_valid_words)
   end
 
-  def test_sjis_count_ja_valid_word
+  def test_sjis_count_ja_valid_words
     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)
+    assert_equal(expected, str.count_ja_valid_words)
   end
 
-  def test_sjis_count_valid_word
+  def test_sjis_count_valid_words
     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)
+    assert_equal(expected, str.count_valid_words)
   end
 
-  def test_sjis_count_line
+  def test_sjis_count_lines
     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)
+    assert_equal(expected, str.count_lines)
   end
 
-  def test_sjis_count_graph_line
+  def test_sjis_count_graph_lines
     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)
+    assert_equal(expected, str.count_graph_lines)
   end
 
-  def test_sjis_count_empty_line
+  def test_sjis_count_empty_lines
     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)
+    assert_equal(expected, str.count_empty_lines)
   end
 
-  def test_sjis_count_blank_line
+  def test_sjis_count_blank_lines
     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
-    assert_equal(expected, str.count_blank_line)
+    assert_equal(expected, str.count_blank_lines)
   end
 
   # test UTF8 module
-  def test_utf8_split_to_word
+  def test_utf8_to_words
     str = NKF.nkf("--utf8", "日本語の文字foo bar").extend(CharString)
     str.encoding = "UTF-8"
     expected = ["日本語の", "文字", "foo ", "bar"].map { |c| NKF.nkf("--utf8", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_utf8_split_to_word_kanhira
+  def test_utf8_to_words_kanhira
     str = NKF.nkf("--utf8", "日本語の文字").extend(CharString)
     str.encoding = "UTF-8"
     expected = ["日本語の", "文字"].map { |c| NKF.nkf("--utf8", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_utf8_split_to_word_katahira
+  def test_utf8_to_words_katahira
     str = NKF.nkf("--utf8", "カタカナの文字").extend(CharString)
     str.encoding = "UTF-8"
     expected = ["カタカナの", "文字"].map { |c| NKF.nkf("--utf8", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_utf8_split_to_word_kataonbiki
+  def test_utf8_to_words_kataonbiki
     str = NKF.nkf("--utf8", "ルビーの指輪").extend(CharString)
     str.encoding = "UTF-8"
     expected = ["ルビーの", "指輪"].map { |c| NKF.nkf("--utf8", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_utf8_split_to_word_hiraonbiki
+  def test_utf8_to_words_hiraonbiki
     str = NKF.nkf("--utf8", "わールビーだ").extend(CharString)
     str.encoding = "UTF-8"
     expected = ["わー", "ルビーだ"].map { |c| NKF.nkf("--utf8", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_utf8_split_to_word_latinmix
+  def test_utf8_to_words_latinmix
     str = NKF.nkf("--utf8", "日本語とLatinの文字").extend(CharString)
     str.encoding = "UTF-8"
     expected = ["日本語と", "Latin", "の", "文字"].map { |c| NKF.nkf("--utf8", c) }
-    assert_equal(expected, str.split_to_word)
+    assert_equal(expected, str.to_words)
   end
 
-  def test_utf8_split_to_char
+  def test_utf8_to_chars
     str = NKF.nkf("--utf8", "日本語a b").extend(CharString)
     expected = ["日", "本", "語", "a", " ", "b"].map { |c| NKF.nkf("--utf8", c) }
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_utf8_split_to_char_with_cr
+  def test_utf8_to_chars_with_cr
     str = NKF.nkf("--utf8", "日本語a b\r").extend(CharString)
     str.eol = "CR"
     expected = ["日", "本", "語", "a", " ", "b", "\r"].map { |c| NKF.nkf("--utf8", c) }
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_utf8_split_to_char_with_lf
+  def test_utf8_to_chars_with_lf
     str = NKF.nkf("--utf8", "日本語a b\n").extend(CharString)
     str.eol = "LF"
     expected = ["日", "本", "語", "a", " ", "b", "\n"].map { |c| NKF.nkf("--utf8", c) }
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_utf8_split_to_char_with_crlf
+  def test_utf8_to_chars_with_crlf
     str = NKF.nkf("--utf8", "日本語a b\r\n").extend(CharString)
     str.eol = "CRLF"
     expected = ["日", "本", "語", "a", " ", "b", "\r\n"].map { |c| NKF.nkf("--utf8", c) }
-    assert_equal(expected, str.split_to_char)
+    assert_equal(expected, str.to_chars)
   end
 
-  def test_utf8_count_char
+  def test_utf8_count_chars
     str = NKF.nkf("--utf8", "日本語a b\r\n").extend(CharString)
     str.eol = "CRLF"
     expected = 7
-    assert_equal(expected, str.count_char)
+    assert_equal(expected, str.count_chars)
   end
 
-  def test_utf8_count_latin_graph_char
+  def test_utf8_count_latin_graph_chars
     str = NKF.nkf("--utf8", "日本語a b\r\n").extend(CharString)
     str.eol = "CRLF"
     expected = 2
-    assert_equal(expected, str.count_latin_graph_char)
+    assert_equal(expected, str.count_latin_graph_chars)
   end
 
-  def test_utf8_count_ja_graph_char
+  def test_utf8_count_ja_graph_chars
     str = NKF.nkf("--utf8", "日本語a b\r\n").extend(CharString)
     str.eol = "CRLF"
     expected = 3
-    assert_equal(expected, str.count_ja_graph_char)
+    assert_equal(expected, str.count_ja_graph_chars)
   end
 
-  def test_utf8_count_graph_char
+  def test_utf8_count_graph_chars
     str = NKF.nkf("--utf8", "日本語a b\r\n").extend(CharString)
     str.eol = "CRLF"
     expected = 5
-    assert_equal(expected, str.count_graph_char)
+    assert_equal(expected, str.count_graph_chars)
   end
 
-  def test_utf8_count_latin_blank_char
+  def test_utf8_count_latin_blank_chars
     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)
+    assert_equal(expected, str.count_latin_blank_chars)
   end
 
-  def test_utf8_count_ja_blank_char
+  def test_utf8_count_ja_blank_chars
     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)
+    assert_equal(expected, str.count_ja_blank_chars)
   end
 
-  def test_utf8_count_blank_char
+  def test_utf8_count_blank_chars
     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)
+    assert_equal(expected, str.count_blank_chars)
   end
 
-  def test_utf8_count_word
+  def test_utf8_count_words
     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)
+    assert_equal(expected, str.count_words)
   end
 
-  def test_utf8_count_ja_word
+  def test_utf8_count_ja_words
     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)
+    assert_equal(expected, str.count_ja_words)
   end
 
-  def test_utf8_count_latin_valid_word
+  def test_utf8_count_latin_valid_words
     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)
+    assert_equal(expected, str.count_latin_valid_words)
   end
 
-  def test_utf8_count_ja_valid_word
+  def test_utf8_count_ja_valid_words
     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)
+    assert_equal(expected, str.count_ja_valid_words)
   end
 
-  def test_utf8_count_valid_word
+  def test_utf8_count_valid_words
     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)
+    assert_equal(expected, str.count_valid_words)
   end
 
-  def test_utf8_count_line
+  def test_utf8_count_lines
     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)
+    assert_equal(expected, str.count_lines)
   end
 
-  def test_utf8_count_graph_line
+  def test_utf8_count_graph_lines
     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)
+    assert_equal(expected, str.count_graph_lines)
   end
 
-  def test_utf8_count_empty_line
+  def test_utf8_count_empty_lines
     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)
+    assert_equal(expected, str.count_empty_lines)
   end
 
-  def test_utf8_count_blank_line
+  def test_utf8_count_blank_lines
     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
-    assert_equal(expected, str.count_blank_line)
+    assert_equal(expected, str.count_blank_lines)
   end
 
   # test module functions