class TestUnicodeUtils

# File test/test_unicode_utils.rb, line 126
def test_canonical_decomposition
  assert_equal "\u{61}\u{301}",
    UnicodeUtils.canonical_decomposition("\u{E1}")
  assert_equal "\u{61}\u{301}\u{63}\u{327}\u{301}",
    UnicodeUtils.canonical_decomposition("\u{e1}\u{63}\u{301}\u{327}")
  assert_equal "\u{fb01}",
    UnicodeUtils.canonical_decomposition("\u{fb01}")
end

# File test/test_unicode_utils.rb, line 139
def test_canonical_equivalents?
  assert_equal true, UnicodeUtils.canonical_equivalents?("Äste", "A\u{308}ste")
  assert_equal false, UnicodeUtils.canonical_equivalents?("Äste", "Aste")
end

# File test/test_unicode_utils.rb, line 96
def test_case_ignorable_char?
  assert_equal true, UnicodeUtils.case_ignorable_char?(":")
  assert_equal true, UnicodeUtils.case_ignorable_char?("\u{302}")
  assert_equal true, UnicodeUtils.case_ignorable_char?("\u{20dd}")
  assert_equal true, UnicodeUtils.case_ignorable_char?("\u{600}")
  assert_equal true, UnicodeUtils.case_ignorable_char?("\u{2b0}")
  assert_equal true, UnicodeUtils.case_ignorable_char?("\u{2c2}")
  assert_equal false, UnicodeUtils.case_ignorable_char?("a")
  assert_equal false, UnicodeUtils.case_ignorable_char?("1")
end

# File test/test_unicode_utils.rb, line 89
def test_cased_char?
  assert_equal true, UnicodeUtils.cased_char?("a")
  assert_equal true, UnicodeUtils.cased_char?("Ä")
  assert_equal true, UnicodeUtils.cased_char?("ß")
  assert_equal false, UnicodeUtils.cased_char?("2")
end

# File test/test_unicode_utils.rb, line 176
def test_casefold
  assert_equal "abc123", UnicodeUtils.casefold("ABC123")
  assert UnicodeUtils.casefold("ÜMIT") ==
    UnicodeUtils.casefold("ümit")
  assert UnicodeUtils.casefold("WEISS") ==
    UnicodeUtils.casefold("weiß")
end

# File test/test_unicode_utils.rb, line 289
def test_char_display_width
  assert_equal 2, UnicodeUtils.char_display_width("別")
  assert_equal 0, UnicodeUtils.char_display_width(0x308)
  assert_equal 1, UnicodeUtils.char_display_width("a")
end

# File test/test_unicode_utils.rb, line 409
def test_char_type
  assert_equal :Letter, UnicodeUtils.char_type("Ä")
  assert_equal :Letter, UnicodeUtils.char_type("ä")
  assert_equal :Other, UnicodeUtils.char_type(0x0)
  assert_equal :Number, UnicodeUtils.char_type("1")
  assert_equal nil, UnicodeUtils.char_type(-1)
end

# File test/test_unicode_utils.rb, line 461
def test_code_point_type
  assert_equal :Graphic, UnicodeUtils.code_point_type("A")
  assert_equal :Graphic, UnicodeUtils.code_point_type("a")
  assert_equal :Graphic, UnicodeUtils.code_point_type(0x1cb)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0x2b5)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0x10923)

  assert_equal :Graphic, UnicodeUtils.code_point_type(0x5a0)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0x93f)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0x20dd)

  assert_equal :Graphic, UnicodeUtils.code_point_type(0xa901)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0x10144)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0x10917)

  assert_equal :Graphic, UnicodeUtils.code_point_type(0x5f)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0x2011)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0x2329)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0xfe38)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0x201c)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0x201d)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0x2e10)

  assert_equal :Graphic, UnicodeUtils.code_point_type(0xff0b)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0xa3)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0x2c2)
  assert_equal :Graphic, UnicodeUtils.code_point_type(0x60f)

  assert_equal :Graphic, UnicodeUtils.code_point_type(0x2001)
  assert_equal :Format, UnicodeUtils.code_point_type(0x2028)
  assert_equal :Format, UnicodeUtils.code_point_type(0x2029)

  assert_equal :Control, UnicodeUtils.code_point_type(0x0)
  assert_equal :Format, UnicodeUtils.code_point_type(0x70f)
  assert_equal :Surrogate, UnicodeUtils.code_point_type(0xdb82)
  assert_equal :Private_Use, UnicodeUtils.code_point_type(0xf1020)
  assert_equal :Private_Use, UnicodeUtils.code_point_type(0x10fffd)
  assert_equal :Noncharacter, UnicodeUtils.code_point_type(0x10ffff)
  assert_equal :Noncharacter, UnicodeUtils.code_point_type(0xfffe)
  assert_equal :Noncharacter, UnicodeUtils.code_point_type(0xffff)
  assert_equal :Noncharacter, UnicodeUtils.code_point_type(0xbfffe)
  assert_equal :Noncharacter, UnicodeUtils.code_point_type(0xbffff)
  assert_equal :Reserved, UnicodeUtils.code_point_type(0x380)
  assert_equal :Reserved, UnicodeUtils.code_point_type(0xeeb)
  assert_equal :Reserved, UnicodeUtils.code_point_type(0xfff)
  assert_equal :Reserved, UnicodeUtils.code_point_type(0x7fffd)
  assert_equal :Reserved, UnicodeUtils.code_point_type(0xeffef)
  ### above is at least one assertion for every general category ###

  assert_equal nil, UnicodeUtils.code_point_type(-1)
  assert_equal nil, UnicodeUtils.code_point_type(0x110000)
end

# File test/test_unicode_utils.rb, line 107
def test_combining_class
  assert_equal 0, UnicodeUtils.combining_class("a")
  assert_equal 230, UnicodeUtils.combining_class("\u{1b6e}")
end

# File test/test_unicode_utils.rb, line 148
def test_compatibility_decomposition
  # the following two calls have the same results with
  # canonical_decomposition
  assert_equal "\u{61}\u{301}",
    UnicodeUtils.compatibility_decomposition("\u{E1}")
  assert_equal "\u{61}\u{301}\u{63}\u{327}\u{301}",
    UnicodeUtils.compatibility_decomposition("\u{e1}\u{63}\u{301}\u{327}")
  # this case differs from canonical decomposition
  assert_equal "\u{66}\u{69}",
    UnicodeUtils.compatibility_decomposition("\u{fb01}")
end

# File test/test_unicode_utils.rb, line 424
  def test_debug
    io = StringIO.new
    UnicodeUtils.debug("", io: io)
    assert_equal <<-'EOF', io.string
 Char | Ordinal | Sid | General Category | UTF-8
------+---------+-----+------------------+-------
    EOF
    io = StringIO.new
    UnicodeUtils.debug("一 \u{100000}\n", io: io)
    assert_equal <<-'EOF', io.string
 Char | Ordinal | Sid                        | General Category | UTF-8
------+---------+----------------------------+------------------+-------------
 "一" |    4E00 | CJK UNIFIED IDEOGRAPH-4E00 | Other_Letter     | E4 B8 80
 " "  |      20 | SPACE                      | Space_Separator  | 20
 N/A  |  100000 | <private-use-100000>       | Private_Use      | F4 80 80 80
 "\n" |       A | LINE FEED                  | Control          | 0A
    EOF
    io = StringIO.new
    UnicodeUtils.debug(0xd800, io: io)
    # Early Ruby 1.9 versions encoded surrogates in UTF-8,
    # although the Unicode standard does not allow it.
    begin
      0xd800.chr('utf-8')
      assert_equal <<-'EOF', io.string
 Char | Ordinal | Sid              | General Category | UTF-8
------+---------+------------------+------------------+----------
 N/A  |    D800 | <surrogate-D800> | Surrogate        | ED A0 80
      EOF
    rescue RangeError
      assert_equal <<-'EOF', io.string
 Char | Ordinal | Sid              | General Category | UTF-8
------+---------+------------------+------------------+-------
 N/A  |    D800 | <surrogate-D800> | Surrogate        | N/A
      EOF
    end
  end

# File test/test_unicode_utils.rb, line 295
def test_default_ignorable_char?
  assert_equal true, UnicodeUtils.default_ignorable_char?(0xad)
  assert_equal true, UnicodeUtils.default_ignorable_char?(0x34f)
  assert_equal true, UnicodeUtils.default_ignorable_char?(0x115f)
  assert_equal true, UnicodeUtils.default_ignorable_char?(0x1160)
  assert_equal true, UnicodeUtils.default_ignorable_char?(0x2065)
  assert_equal true, UnicodeUtils.default_ignorable_char?(0x2069)
  assert_equal true, UnicodeUtils.default_ignorable_char?(0xe008a)
  assert_equal true, UnicodeUtils.default_ignorable_char?(0xffa0)
  assert_equal true, UnicodeUtils.default_ignorable_char?(0xe0fff)
  assert_equal false, UnicodeUtils.default_ignorable_char?("a")
  assert_equal false, UnicodeUtils.default_ignorable_char?("語")
  assert_equal false, UnicodeUtils.default_ignorable_char?(" ")
  assert_equal false, UnicodeUtils.default_ignorable_char?("\u{308}")
end

# File test/test_unicode_utils.rb, line 273
def test_display_width
  assert_equal 0, UnicodeUtils.display_width("")
  assert_equal 18, UnicodeUtils.display_width("別れる時に発する語")
  assert_equal 18, UnicodeUtils.display_width("123456789aBcDeFgHi")
  assert_equal 6, UnicodeUtils.display_width("Straße")
  assert_equal 1, UnicodeUtils.display_width("a\u{308}")
  assert_equal 5, UnicodeUtils.display_width("Now！")
  assert_equal 2, UnicodeUtils.display_width("a̦b") # General Category Mn
  assert_equal 4, UnicodeUtils.display_width("a\u{93b}bc") # General Category Mc
  assert_equal 3, UnicodeUtils.display_width("ab\u{20dd}c") # General Category Me
  assert_equal 4, UnicodeUtils.display_width("ab\u{a8}c") # General Category Sk
  assert_equal 4, UnicodeUtils.display_width("ab\u{2000}c") # General Category Zs
  assert_equal 3, UnicodeUtils.display_width("a b") # Zs
  assert_equal 3, UnicodeUtils.display_width("a\u{1680}b") # Zs
end

# File test/test_unicode_utils.rb, line 50
def test_downcase
  # LATIN CAPITAL LETTER I WITH DOT ABOVE
  assert_equal "\u0069\u0307", UnicodeUtils.downcase("\u0130")
  assert_equal "\u0069\u0307", UnicodeUtils.downcase("\u0130", :de)
  assert_equal "\u0069", UnicodeUtils.downcase("\u0130", :tr)
  assert_equal "\u0069", UnicodeUtils.downcase("\u0130", :az)
  assert_equal "ab\u{131}\u{3c3}\u{df}\u{3c2}/\u{5ffff}\u{1042d}",
    UnicodeUtils.downcase("aBI\u{3a3}\u{df}\u{3a3}/\u{5ffff}\u{10405}", :tr)
  # tests After_I and Not_Before_Dot
  assert_equal "abi", UnicodeUtils.downcase("aBI\u{307}", :tr)
  assert_equal "ia\u{300}", UnicodeUtils.downcase("Ia\u{300}", :lt)
  # this is probably unrealistic, because I don't understand a word Lithuanian
  assert_equal "i\u{307}\u{300}", UnicodeUtils.downcase("I\u{300}", :lt)
end

# File test/test_unicode_utils.rb, line 65
def test_downcase_final_sigma
  assert_equal "abi\u{3c3}\u{df}\u{3c2}/\u{5ffff}\u{1042d}",
    UnicodeUtils.downcase("aBI\u{3a3}\u{df}\u{3a3}/\u{5ffff}\u{10405}")
end

# File test/test_unicode_utils.rb, line 184
def test_each_grapheme
  graphemes = []
  UnicodeUtils.each_grapheme("word") { |g| graphemes << g }
  assert_equal ["w", "o", "r", "d"], graphemes
  UnicodeUtils.each_grapheme("") { |g| flunk }
  graphemes = []
  UnicodeUtils.each_grapheme("u\u{308}mit") { |g| graphemes << g }
  # diaeresis
  assert_equal ["u\u{308}", "m", "i", "t"], graphemes
  # hangul syllable
  graphemes = []
  UnicodeUtils.each_grapheme("\u{1111}\u{1171}\u{11b6}\u{d4db}") { |g| graphemes << g }
  assert_equal ["\u{1111}\u{1171}\u{11b6}", "\u{d4db}"], graphemes
  assert_equal ["a", "\r\n", "b"], UnicodeUtils.each_grapheme("a\r\nb").to_a
end

# File test/test_unicode_utils.rb, line 200
def test_each_word
  words = []
  UnicodeUtils.each_word("two words") { |w| words << w }
  assert_equal ["two", " ", "words"], words
  assert_equal ["a", " ", "b"], UnicodeUtils.each_word("a b").to_a
  assert_equal [" ", "b"], UnicodeUtils.each_word(" b").to_a
  assert_equal ["a", " "], UnicodeUtils.each_word("a ").to_a
  assert_equal [" "], UnicodeUtils.each_word(" ").to_a
  assert_equal ["a"], UnicodeUtils.each_word("a").to_a
  assert_equal [], UnicodeUtils.each_word("").to_a
  assert_equal ["Hello", ",", " ", "world", "!"],
    UnicodeUtils.each_word("Hello, world!").to_a
  assert_equal ["o\u{308}12"],
    UnicodeUtils.each_word("o\u{308}12").to_a
  assert_equal ["o\u{308}1"],
    UnicodeUtils.each_word("o\u{308}1").to_a
  assert_equal ["o\u{308}"],
    UnicodeUtils.each_word("o\u{308}").to_a
  assert_equal ["\u{308}", "o"],
    UnicodeUtils.each_word("\u{308}o").to_a
end

# File test/test_unicode_utils.rb, line 230
def test_east_asian_width
  assert_equal :Neutral, UnicodeUtils.east_asian_width("\u{0}")
  assert_equal :Neutral, UnicodeUtils.east_asian_width("\u{10FFFF}")
  assert_equal :Neutral, UnicodeUtils.east_asian_width("\u{C5}")
  # from Wide to Neutral in Unicode 6.2.0
  assert_equal :Neutral, UnicodeUtils.east_asian_width(0x11A5)
  assert_equal :Ambiguous, UnicodeUtils.east_asian_width(0xA1)
  assert_equal :Ambiguous, UnicodeUtils.east_asian_width(0xE000)
  assert_equal :Ambiguous, UnicodeUtils.east_asian_width(0xF8FF)
  assert_equal :Ambiguous, UnicodeUtils.east_asian_width(0xFE05)
  assert_equal :Ambiguous, UnicodeUtils.east_asian_width("ß")
  assert_equal :Halfwidth, UnicodeUtils.east_asian_width(0xFFA5)
  assert_equal :Halfwidth, UnicodeUtils.east_asian_width(0xFFEE)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0xB116)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0x1100)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0x2E94)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0x3400)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0x4E05)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0x4FCD)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0xFA2E)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0x3FFFD)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0x4DB6)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0x4DBF)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0x9FCC)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0x9FFF)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0xFA2E)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0xFA2F)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0xFA6E)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0xFA6F)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0xFADA)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0xFAFF)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0x2A6D7)
  assert_equal :Wide, UnicodeUtils.east_asian_width(0x2A6FF)
  assert_equal :Fullwidth, UnicodeUtils.east_asian_width(0x3000)
  assert_equal :Fullwidth, UnicodeUtils.east_asian_width(0xFF0D)
  assert_equal :Fullwidth, UnicodeUtils.east_asian_width(0xFFE6)
  assert_equal :Narrow, UnicodeUtils.east_asian_width(0x20)
  assert_equal :Narrow, UnicodeUtils.east_asian_width(0x2C)
  assert_equal :Narrow, UnicodeUtils.east_asian_width(0x7E)
  assert_equal :Narrow, UnicodeUtils.east_asian_width(0xA6)
  assert_equal :Narrow, UnicodeUtils.east_asian_width(0x2986)
end

# File test/test_unicode_utils.rb, line 311
def test_gc
  assert_equal :Lu, UnicodeUtils.gc("A")
  assert_equal :Ll, UnicodeUtils.gc("a")
  assert_equal :Lt, UnicodeUtils.gc(0x1cb)
  assert_equal :Lm, UnicodeUtils.gc(0x2b5)
  assert_equal :Lo, UnicodeUtils.gc(0x10923)

  assert_equal :Mn, UnicodeUtils.gc(0x5a0)
  assert_equal :Mc, UnicodeUtils.gc(0x93f)
  assert_equal :Me, UnicodeUtils.gc(0x20dd)

  assert_equal :Nd, UnicodeUtils.gc(0xa901)
  assert_equal :Nl, UnicodeUtils.gc(0x10144)
  assert_equal :No, UnicodeUtils.gc(0x10917)

  assert_equal :Pc, UnicodeUtils.gc(0x5f)
  assert_equal :Pd, UnicodeUtils.gc(0x2011)
  assert_equal :Ps, UnicodeUtils.gc(0x2329)
  assert_equal :Pe, UnicodeUtils.gc(0xfe38)
  assert_equal :Pi, UnicodeUtils.gc(0x201c)
  assert_equal :Pf, UnicodeUtils.gc(0x201d)
  assert_equal :Po, UnicodeUtils.gc(0x2e10)

  assert_equal :Sm, UnicodeUtils.gc(0xff0b)
  assert_equal :Sc, UnicodeUtils.gc(0xa3)
  assert_equal :Sk, UnicodeUtils.gc(0x2c2)
  assert_equal :So, UnicodeUtils.gc(0x60f)

  assert_equal :Zs, UnicodeUtils.gc(0x2001)
  assert_equal :Zl, UnicodeUtils.gc(0x2028)
  assert_equal :Zp, UnicodeUtils.gc(0x2029)

  assert_equal :Cc, UnicodeUtils.gc(0x0)
  assert_equal :Cf, UnicodeUtils.gc(0x70f)
  assert_equal :Cs, UnicodeUtils.gc(0xdb82)
  assert_equal :Co, UnicodeUtils.gc(0xf1020)
  assert_equal :Cn, UnicodeUtils.gc(0x10ffff)
  ### 30 general categories ###

  assert_equal :Lo, UnicodeUtils.gc(0x3400)
  assert_equal :Lo, UnicodeUtils.gc(0x4000)
  assert_equal :Lo, UnicodeUtils.gc(0x4db5)

  assert_equal :Lo, UnicodeUtils.gc(0x4e00)
  assert_equal :Lo, UnicodeUtils.gc(0x9fcb)
  assert_equal :Lo, UnicodeUtils.gc(0x7111)

  assert_equal :Lo, UnicodeUtils.gc(0xac00)
  assert_equal :Lo, UnicodeUtils.gc(0xd7a3)
  assert_equal :Lo, UnicodeUtils.gc(0xb70f)

  assert_equal :Cs, UnicodeUtils.gc(0xd800)
  assert_equal :Cs, UnicodeUtils.gc(0xdb7f)
  assert_equal :Cs, UnicodeUtils.gc(0xda00)

  assert_equal :Cs, UnicodeUtils.gc(0xdb80)
  assert_equal :Cs, UnicodeUtils.gc(0xdbff)
  assert_equal :Cs, UnicodeUtils.gc(0xdb90)

  assert_equal :Cs, UnicodeUtils.gc(0xdc00)
  assert_equal :Cs, UnicodeUtils.gc(0xdfff)
  assert_equal :Cs, UnicodeUtils.gc(0xdc01)

  assert_equal :Co, UnicodeUtils.gc(0xe000)
  assert_equal :Co, UnicodeUtils.gc(0xf8ff)
  assert_equal :Co, UnicodeUtils.gc(0xf8fe)

  assert_equal :Lo, UnicodeUtils.gc(0x20000)
  assert_equal :Lo, UnicodeUtils.gc(0x2a6d6)
  assert_equal :Lo, UnicodeUtils.gc(0x2b000)

  assert_equal :Lo, UnicodeUtils.gc(0x2a700)
  assert_equal :Lo, UnicodeUtils.gc(0x2b734)
  assert_equal :Lo, UnicodeUtils.gc(0x2b800)

  assert_equal :Lo, UnicodeUtils.gc(0x2b740)
  assert_equal :Lo, UnicodeUtils.gc(0x2b81d)
  assert_equal :Lo, UnicodeUtils.gc(0x2b810)

  assert_equal :Co, UnicodeUtils.gc(0xf0000)
  assert_equal :Co, UnicodeUtils.gc(0xffffd)
  assert_equal :Co, UnicodeUtils.gc(0xffafd)

  assert_equal :Co, UnicodeUtils.gc(0x100000)
  assert_equal :Co, UnicodeUtils.gc(0x10fffd)
  assert_equal :Co, UnicodeUtils.gc(0x100ffd)

  assert_equal nil, UnicodeUtils.gc(-1)
  assert_equal nil, UnicodeUtils.gc(0x110000)
end

# File test/test_unicode_utils.rb, line 402
def test_general_category
  assert_equal :Uppercase_Letter, UnicodeUtils.general_category("B")
  assert_equal :Lowercase_Letter, UnicodeUtils.general_category("b")
  assert_equal :Control, UnicodeUtils.general_category(0x0)
  assert_equal nil, UnicodeUtils.general_category(-1)
end

# File test/test_unicode_utils.rb, line 417
def test_graphic_char?
  assert_equal true, UnicodeUtils.graphic_char?("a")
  assert_equal true, UnicodeUtils.graphic_char?(0x308)
  assert_equal false, UnicodeUtils.graphic_char?("\n")
  assert_equal false, UnicodeUtils.graphic_char?(0x0)
end

# File test/test_unicode_utils.rb, line 118
def test_hangul_syllable_decomposition
  assert_equal "\u{1111}\u{1171}\u{11b6}", UnicodeUtils.hangul_syllable_decomposition("\u{d4db}")
end

# File test/test_unicode_utils.rb, line 122
def test_jamo_short_name
  assert_equal "GG", UnicodeUtils.jamo_short_name("\u{1101}")
end

# File test/test_unicode_utils.rb, line 75
def test_lowercase_char?
  assert_equal true, UnicodeUtils.lowercase_char?("c")
  assert_equal true, UnicodeUtils.lowercase_char?("ö")
  assert_equal false, UnicodeUtils.lowercase_char?("C")
  assert_equal false, UnicodeUtils.lowercase_char?("2")
end

# File test/test_unicode_utils.rb, line 14
def test_name
  assert_equal "LATIN SMALL LETTER F", UnicodeUtils.char_name("f")
  assert_equal Encoding::US_ASCII, UnicodeUtils.char_name("f").encoding
  assert_equal nil, UnicodeUtils.char_name("\u{e000}") # private use
  assert_equal "<control>", UnicodeUtils.char_name("\t")
  assert_equal "CJK UNIFIED IDEOGRAPH-4E00", UnicodeUtils.char_name("\u{4e00}")
  assert_equal "CJK UNIFIED IDEOGRAPH-2A6D6", UnicodeUtils.char_name("\u{2a6d6}")
  assert_equal "CJK UNIFIED IDEOGRAPH-2A3D6", UnicodeUtils.char_name("\u{2a3d6}")
  assert_equal "HANGUL SYLLABLE PWILH", UnicodeUtils.char_name("\u{d4db}")
end

# File test/test_unicode_utils.rb, line 514
def test_name_aliases
  assert_equal [UnicodeUtils::NameAlias.new("NULL", :control),
                UnicodeUtils::NameAlias.new("NUL", :abbreviation)],
               UnicodeUtils.name_aliases(0x0)
  assert_equal [UnicodeUtils::NameAlias.new("LATIN CAPITAL LETTER GHA", :correction)],
               UnicodeUtils.name_aliases(0x1a2)
  assert_equal [UnicodeUtils::NameAlias.new("BYTE ORDER MARK", :alternate),
                UnicodeUtils::NameAlias.new("BOM", :abbreviation),
                UnicodeUtils::NameAlias.new("ZWNBSP", :abbreviation)],
               UnicodeUtils.name_aliases(0xfeff)
  assert_equal [UnicodeUtils::NameAlias.new("PADDING CHARACTER", :figment),
                UnicodeUtils::NameAlias.new("PAD", :abbreviation)],
               UnicodeUtils.name_aliases(0x80)
  assert_equal [UnicodeUtils::NameAlias.new("VS256", :abbreviation)],
               UnicodeUtils.name_aliases(0xe01ef)
  assert_equal [UnicodeUtils::NameAlias.new("LINE FEED", :control),
                UnicodeUtils::NameAlias.new("NEW LINE", :control),
                UnicodeUtils::NameAlias.new("END OF LINE", :control),
                UnicodeUtils::NameAlias.new("LF", :abbreviation),
                UnicodeUtils::NameAlias.new("NL", :abbreviation),
                UnicodeUtils::NameAlias.new("EOL", :abbreviation)],
               UnicodeUtils.name_aliases(0xa)
  assert_equal [UnicodeUtils::NameAlias.new("CHARACTER TABULATION", :control),
                UnicodeUtils::NameAlias.new("HORIZONTAL TABULATION", :control),
                UnicodeUtils::NameAlias.new("HT", :abbreviation),
                UnicodeUtils::NameAlias.new("TAB", :abbreviation)],
               UnicodeUtils.name_aliases("\t")
  assert_equal [],
               UnicodeUtils.name_aliases("a")
end

# File test/test_unicode_utils.rb, line 144
def test_nfc
  assert_equal "Häschen", UnicodeUtils.nfc("Ha\u{308}schen")
end

# File test/test_unicode_utils.rb, line 135
def test_nfd
  assert_equal "\u{61}\u{301}", UnicodeUtils.nfd("\u{E1}")
end

# File test/test_unicode_utils.rb, line 164
def test_nfkc
  assert_equal "\u{66}\u{69}\u{e4}", UnicodeUtils.nfkc("\u{fb01}\u{e4}")
end

# File test/test_unicode_utils.rb, line 160
def test_nfkd
  assert_equal "\u{66}\u{69}", UnicodeUtils.nfkd("\u{fb01}")
end

# File test/test_unicode_utils.rb, line 545
def test_sid
  assert_equal nil, UnicodeUtils.sid(-1)
  assert_equal "NULL", UnicodeUtils.sid(0x0)
  assert_equal "LATIN CAPITAL LETTER GHA", UnicodeUtils.sid(0x1a2)
  assert_equal "LINE FEED", UnicodeUtils.sid(0xa)
  assert_equal "PADDING CHARACTER", UnicodeUtils.sid(0x80)
  assert_equal "BYTE ORDER MARK", UnicodeUtils.sid(0xfeff)
  assert_equal "SPACE", UnicodeUtils.sid(0x20)
  assert_equal "<reserved-0380>", UnicodeUtils.sid(0x380)
  assert_equal "<surrogate-D800>", UnicodeUtils.sid(0xd800)
  assert_equal "<private-use-F0000>", UnicodeUtils.sid(0xf0000)
  assert_equal "<private-use-10FFFD>", UnicodeUtils.sid(0x10fffd)
  assert_equal "<noncharacter-10FFFF>", UnicodeUtils.sid(UnicodeUtils::Codepoint::RANGE.end)
  assert_equal nil, UnicodeUtils.sid(UnicodeUtils::Codepoint::RANGE.end + 1)
end

# File test/test_unicode_utils.rb, line 168
def test_simple_casefold
  assert_equal "abc123", UnicodeUtils.simple_casefold("ABC123")
  assert UnicodeUtils.simple_casefold("ÜMIT") ==
    UnicodeUtils.simple_casefold("ümit")
  assert UnicodeUtils.simple_casefold("WEISS") !=
    UnicodeUtils.simple_casefold("weiß")
end

# File test/test_unicode_utils.rb, line 30
def test_simple_downcase
  assert_equal "ümit", UnicodeUtils.simple_downcase("ÜMIT")
  assert_equal "strasse", UnicodeUtils.simple_downcase("STRASSE")
end

# File test/test_unicode_utils.rb, line 25
def test_simple_upcase
  assert_equal "ÜMIT", UnicodeUtils.simple_upcase("ümit")
  assert_equal "WEIß", UnicodeUtils.simple_upcase("weiß")
end

# File test/test_unicode_utils.rb, line 112
def test_soft_dotted_char?
  assert_equal true, UnicodeUtils.soft_dotted_char?("j")
  assert_equal true, UnicodeUtils.soft_dotted_char?("\u{2c7c}")
  assert_equal false, UnicodeUtils.soft_dotted_char?("a")
end

# File test/test_unicode_utils.rb, line 222
def test_titlecase
  assert_equal "Hello, World!", UnicodeUtils.titlecase("heLlo, world!")
  assert_equal "Find", UnicodeUtils.titlecase("finD")
  assert_equal "Ümit Huber Jandl", UnicodeUtils.titlecase("ümit huber jandl")
  assert_equal "İ Can Has 1Kg Cheesburger",
    UnicodeUtils.titlecase("i can has 1kg CHEESBURGER", :tr)
end

# File test/test_unicode_utils.rb, line 70
def test_titlecase?
  assert_equal true, UnicodeUtils.titlecase_char?("\u{01F2}")
  assert_equal false, UnicodeUtils.titlecase_char?("\u{0041}")
end

# File test/test_unicode_utils.rb, line 10
def test_unicode_version
  assert_match /\A\d+\.\d+\.\d+\z/, UnicodeUtils::UNICODE_VERSION
end

# File test/test_unicode_utils.rb, line 35
def test_upcase
  assert_equal "WEISS 123", UnicodeUtils.upcase("Weiß 123")
  assert_equal "WEISS 123", UnicodeUtils.upcase("Weiß 123", :de)
  assert_equal "I", UnicodeUtils.upcase("i")
  assert_equal "I", UnicodeUtils.upcase("i", :de)
  assert_equal "\u{130}", UnicodeUtils.upcase("i", :tr)
  assert_equal "\u{130}", UnicodeUtils.upcase("i", :az)
  assert_equal "ABI\u{3a3}SS\u{3a3}/FFI\u{5ffff}\u{10405}",
    UnicodeUtils.upcase("aBi\u{3c3}\u{df}\u{3c2}/\u{fb03}\u{5ffff}\u{1042d}")
  assert_equal "AB\u{130}\u{3a3}SS\u{3a3}/FFI\u{5ffff}\u{10405}",
    UnicodeUtils.upcase("aBi\u{3c3}\u{df}\u{3c2}/\u{fb03}\u{5ffff}\u{1042d}", :az)
  assert_equal "I\u{307}", UnicodeUtils.upcase("i\u{307}")
  assert_equal "I", UnicodeUtils.upcase("i\u{307}", :lt)
end

# File test/test_unicode_utils.rb, line 82
def test_uppercase_char?
  assert_equal true, UnicodeUtils.uppercase_char?("C")
  assert_equal true, UnicodeUtils.uppercase_char?("Ö")
  assert_equal false, UnicodeUtils.uppercase_char?("2")
  assert_equal false, UnicodeUtils.uppercase_char?("c")
end

# File test/test_unicode_utils.rb, line 561
def test_white_space_char?
  assert_equal true, UnicodeUtils.white_space_char?(" ")
  assert_equal true, UnicodeUtils.white_space_char?("\n")
  assert_equal true, UnicodeUtils.white_space_char?("\r")
  assert_equal true, UnicodeUtils.white_space_char?("\t")
  assert_equal true, UnicodeUtils.white_space_char?(0xa0)
  assert_equal true, UnicodeUtils.white_space_char?(0x180e)
  assert_equal true, UnicodeUtils.white_space_char?(0x2000)
  assert_equal true, UnicodeUtils.white_space_char?(0x2009)
  assert_equal true, UnicodeUtils.white_space_char?(0x200a)
  assert_equal true, UnicodeUtils.white_space_char?(0x2028)
  assert_equal true, UnicodeUtils.white_space_char?(0x2029)
  assert_equal true, UnicodeUtils.white_space_char?(0x3000)
  assert_equal false, UnicodeUtils.white_space_char?("a")
  assert_equal false, UnicodeUtils.white_space_char?("_")
end