third-party/mruby/mrbgems/mruby-string-ext/test/string.rb

   1 # coding: utf-8
   2 ##
   3 # String(Ext) Test
   4
   5 UTF8STRING = __ENCODING__ == "UTF-8"
   6
   7 def assert_upto(exp, receiver, *args)
   8   act = []
   9   receiver.upto(*args) { |v| act << v }
  10   assert_equal exp, act
  11 end
  12
  13 assert('String#dump') do
  14   assert_equal("\"\\x00\"", "\0".dump)
  15   assert_equal("\"foo\"", "foo".dump)
  16   assert_equal('"\xe3\x82\x8b"', "る".dump)
  17   assert_nothing_raised { ("\1" * 100).dump }   # regress #1210
  18 end
  19
  20 assert('String#strip') do
  21   s = "  abc  "
  22   assert_equal("abc", s.strip)
  23   assert_equal("  abc  ", s)
  24   assert_equal("", "".strip)
  25   assert_equal("", " \t\r\n\f\v".strip)
  26   assert_equal("\0a", "\0a\0".strip)
  27   assert_equal("abc", "abc".strip)
  28   assert_equal("abc", "  abc".strip)
  29   assert_equal("abc", "abc  ".strip)
  30 end
  31
  32 assert('String#lstrip') do
  33   s = "  abc  "
  34   assert_equal("abc  ", s.lstrip)
  35   assert_equal("  abc  ", s)
  36   assert_equal("", "".lstrip)
  37   assert_equal("", " \t\r\n\f\v".lstrip)
  38   assert_equal("\0a\0", "\0a\0".lstrip)
  39   assert_equal("abc", "abc".lstrip)
  40   assert_equal("abc", "  abc".lstrip)
  41   assert_equal("abc  ", "abc  ".lstrip)
  42 end
  43
  44 assert('String#rstrip') do
  45   s = "  abc  "
  46   assert_equal("  abc", s.rstrip)
  47   assert_equal("  abc  ", s)
  48   assert_equal("", "".rstrip)
  49   assert_equal("", " \t\r\n\f\v".rstrip)
  50   assert_equal("\0a", "\0a\0".rstrip)
  51   assert_equal("abc", "abc".rstrip)
  52   assert_equal("  abc", "  abc".rstrip)
  53   assert_equal("abc", "abc  ".rstrip)
  54 end
  55
  56 assert('String#strip!') do
  57   s = "  abc  "
  58   t = "abc"
  59   assert_equal("abc", s.strip!)
  60   assert_equal("abc", s)
  61   assert_nil(t.strip!)
  62   assert_equal("abc", t)
  63 end
  64
  65 assert('String#lstrip!') do
  66   s = "  abc  "
  67   t = "abc  "
  68   assert_equal("abc  ", s.lstrip!)
  69   assert_equal("abc  ", s)
  70   assert_nil(t.lstrip!)
  71   assert_equal("abc  ", t)
  72 end
  73
  74 assert('String#rstrip!') do
  75   s = "  abc  "
  76   t = "  abc"
  77   assert_equal("  abc", s.rstrip!)
  78   assert_equal("  abc", s)
  79   assert_nil(t.rstrip!)
  80   assert_equal("  abc", t)
  81 end
  82
  83 assert('String#swapcase') do
  84   assert_equal "hELLO", "Hello".swapcase
  85   assert_equal "CyBeR_pUnK11", "cYbEr_PuNk11".swapcase
  86 end
  87
  88 assert('String#swapcase!') do
  89   s = "Hello"
  90   t = s.clone
  91   t.swapcase!
  92   assert_equal s.swapcase, t
  93 end
  94
  95 assert('String#concat') do
  96   assert_equal "Hello World!", "Hello " << "World" << 33
  97   assert_equal "Hello World!", "Hello ".concat("World").concat(33)
  98   assert_raise(TypeError) { "".concat(Object.new) }
  99
 100   if UTF8STRING
 101     assert_equal "H«", "H" << 0xab
 102     assert_equal "Hは", "H" << 12399
 103   else
 104     assert_equal "H\xab", "H" << 0xab
 105     assert_raise(RangeError) { "H" << 12399 }
 106   end
 107 end
 108
 109 assert('String#casecmp') do
 110   assert_equal 1, "abcdef".casecmp("abcde")
 111   assert_equal 0, "aBcDeF".casecmp("abcdef")
 112   assert_equal(-1, "abcdef".casecmp("abcdefg"))
 113   assert_equal 0, "abcdef".casecmp("ABCDEF")
 114 end
 115
 116 assert('String#count') do
 117   s = "abccdeff123"
 118   assert_equal 0, s.count("")
 119   assert_equal 1, s.count("a")
 120   assert_equal 2, s.count("ab")
 121   assert_equal 9, s.count("^c")
 122   assert_equal 8, s.count("a-z")
 123   assert_equal 4, s.count("a0-9")
 124 end
 125
 126 assert('String#tr') do
 127   assert_equal "ABC", "abc".tr('a-z', 'A-Z')
 128   assert_equal "hippo", "hello".tr('el', 'ip')
 129   assert_equal "Ruby", "Lisp".tr("Lisp", "Ruby")
 130   assert_equal "*e**o", "hello".tr('^aeiou', '*')
 131   assert_equal "heo", "hello".tr('l', '')
 132 end
 133
 134 assert('String#tr!') do
 135   s = "abcdefghijklmnopqR"
 136   assert_equal "ab12222hijklmnopqR", s.tr!("cdefg", "12")
 137   assert_equal "ab12222hijklmnopqR", s
 138 end
 139
 140 assert('String#tr_s') do
 141   assert_equal "hero", "hello".tr_s('l', 'r')
 142   assert_equal "h*o", "hello".tr_s('el', '*')
 143   assert_equal "hhxo", "hello".tr_s('el', 'hx')
 144 end
 145
 146 assert('String#tr_s!') do
 147   s = "hello"
 148   assert_equal "hero", s.tr_s!('l', 'r')
 149   assert_equal "hero", s
 150   assert_nil s.tr_s!('l', 'r')
 151 end
 152
 153 assert('String#squeeze') do
 154   assert_equal "yelow mon", "yellow moon".squeeze
 155   assert_equal " now is the", "  now   is  the".squeeze(" ")
 156   assert_equal "puters shot balls", "putters shoot balls".squeeze("m-z")
 157 end
 158
 159 assert('String#squeeze!') do
 160   s = "  now   is  the"
 161   assert_equal " now is the", s.squeeze!(" ")
 162   assert_equal " now is the", s
 163 end
 164
 165 assert('String#delete') do
 166   assert_equal "he", "hello".delete("lo")
 167   assert_equal "hll", "hello".delete("aeiou")
 168   assert_equal "ll", "hello".delete("^l")
 169   assert_equal "ho", "hello".delete("ej-m")
 170 end
 171
 172 assert('String#delete!') do
 173   s = "hello"
 174   assert_equal "he", s.delete!("lo")
 175   assert_equal "he", s
 176   assert_nil s.delete!("lz")
 177 end
 178
 179 assert('String#start_with?') do
 180   assert_true "hello".start_with?("heaven", "hell")
 181   assert_true !"hello".start_with?("heaven", "paradise")
 182   assert_true !"h".start_with?("heaven", "hell")
 183   assert_raise TypeError do "hello".start_with?(true) end
 184 end
 185
 186 assert('String#end_with?') do
 187   assert_true "string".end_with?("ing", "mng")
 188   assert_true !"string".end_with?("str", "tri")
 189   assert_true !"ng".end_with?("ing", "mng")
 190   assert_raise TypeError do "hello".end_with?(true) end
 191 end
 192
 193 assert('String#partition') do
 194   assert_equal ["a", "x", "axa"], "axaxa".partition("x")
 195   assert_equal ["aaaaa", "", ""], "aaaaa".partition("x")
 196   assert_equal ["", "", "aaaaa"], "aaaaa".partition("")
 197   assert_equal ["", "a", "aaaa"], "aaaaa".partition("a")
 198   assert_equal ["aaaa", "b", ""], "aaaab".partition("b")
 199   assert_equal ["", "b", "aaaa"], "baaaa".partition("b")
 200   assert_equal ["", "", ""],      "".partition("a")
 201 end
 202
 203 assert('String#rpartition') do
 204   assert_equal ["axa", "x", "a"], "axaxa".rpartition("x")
 205   assert_equal ["", "", "aaaaa"], "aaaaa".rpartition("x")
 206   assert_equal ["aaaaa", "", ""], "aaaaa".rpartition("")
 207   assert_equal ["aaaa", "a", ""], "aaaaa".rpartition("a")
 208   assert_equal ["aaaa", "b", ""], "aaaab".rpartition("b")
 209   assert_equal ["", "b", "aaaa"], "baaaa".rpartition("b")
 210   assert_equal ["", "", ""],      "".rpartition("a")
 211 end
 212
 213 assert('String#hex') do
 214   assert_equal 16, "10".hex
 215   assert_equal 255, "ff".hex
 216   assert_equal 16, "0x10".hex
 217   assert_equal (-16), "-0x10".hex
 218   assert_equal 0, "xyz".hex
 219   assert_equal 16, "10z".hex
 220   assert_equal 16, "1_0".hex
 221   assert_equal 0, "".hex
 222 end
 223
 224 assert('String#oct') do
 225   assert_equal 8, "10".oct
 226   assert_equal 7, "7".oct
 227   assert_equal 0, "8".oct
 228   assert_equal 0, "9".oct
 229   assert_equal 0, "xyz".oct
 230   assert_equal 8, "10z".oct
 231   assert_equal 8, "1_0".oct
 232   assert_equal 8, "010".oct
 233   assert_equal (-8), "-10".oct
 234 end
 235
 236 assert('String#lines') do
 237   assert_equal ["Hel\n", "lo\n", "World!"], "Hel\nlo\nWorld!".lines
 238   assert_equal ["Hel\n", "lo\n", "World!\n"], "Hel\nlo\nWorld!\n".lines
 239   assert_equal ["\n", "\n", "\n"], "\n\n\n".lines
 240   assert_equal [], "".lines
 241 end
 242
 243 assert('String#clear') do
 244   # embed string
 245   s = "foo"
 246   assert_equal("", s.clear)
 247   assert_equal("", s)
 248
 249   # not embed string and not shared string
 250   s = "foo" * 100
 251   a = s
 252   assert_equal("", s.clear)
 253   assert_equal("", s)
 254   assert_equal("", a)
 255
 256   # shared string
 257   s = "foo" * 100
 258   a = s[10, 90]                # create shared string
 259   assert_equal("", s.clear)    # clear
 260   assert_equal("", s)          # s is cleared
 261   assert_not_equal("", a)      # a should not be affected
 262 end
 263
 264 assert('String#slice!') do
 265   a = "AooBar"
 266   b = a.dup
 267   assert_equal "A", a.slice!(0)
 268   assert_equal "AooBar", b
 269
 270   a = "FooBar"
 271   assert_equal "r", a.slice!(-1)
 272   assert_equal "FooBa", a
 273
 274   a = "FooBar"
 275   assert_nil a.slice!(6)
 276   assert_nil a.slice!(-7)
 277   assert_equal "FooBar", a
 278
 279   a = "FooBar"
 280   assert_equal "Foo", a.slice!(0, 3)
 281   assert_equal "Bar", a
 282
 283   a = "FooBar"
 284   assert_equal "Bar", a.slice!(-3, 3)
 285   assert_equal "Foo", a
 286
 287   a = "FooBar"
 288   assert_equal "", a.slice!(6, 2)
 289   assert_equal "FooBar", a
 290
 291   a = "FooBar"
 292   assert_nil a.slice!(-7,10)
 293   assert_equal "FooBar", a
 294
 295   a = "FooBar"
 296   assert_equal "Foo", a.slice!(0..2)
 297   assert_equal "Bar", a
 298
 299   a = "FooBar"
 300   assert_equal "Bar", a.slice!(-3..-1)
 301   assert_equal "Foo", a
 302
 303   a = "FooBar"
 304   assert_equal "", a.slice!(6..2)
 305   assert_equal "FooBar", a
 306
 307   a = "FooBar"
 308   assert_nil a.slice!(-10..-7)
 309   assert_equal "FooBar", a
 310
 311   a = "FooBar"
 312   assert_equal "Foo", a.slice!("Foo")
 313   assert_equal "Bar", a
 314
 315   a = "FooBar"
 316   assert_nil a.slice!("xyzzy")
 317   assert_equal "FooBar", a
 318
 319   assert_raise(ArgumentError) { "foo".slice! }
 320 end
 321
 322 assert('String#succ') do
 323   assert_equal "", "".succ
 324   assert_equal "1", "0".succ
 325   assert_equal "10", "9".succ
 326   assert_equal "01", "00".succ
 327   assert_equal "a1", "a0".succ
 328   assert_equal "A1", "A0".succ
 329   assert_equal "10", "09".succ
 330   assert_equal "b0", "a9".succ
 331   assert_equal "B0", "A9".succ
 332
 333   assert_equal "b", "a".succ
 334   assert_equal "aa", "z".succ
 335   assert_equal "ab", "aa".succ
 336   assert_equal "Ab", "Aa".succ
 337   assert_equal "0b", "0a".succ
 338   assert_equal "ba", "az".succ
 339   assert_equal "Ba", "Az".succ
 340   assert_equal "1a", "0z".succ
 341
 342   assert_equal "B", "A".succ
 343   assert_equal "AA", "Z".succ
 344   assert_equal "AB", "AA".succ
 345   assert_equal "aB", "aA".succ
 346   assert_equal "0B", "0A".succ
 347   assert_equal "BA", "AZ".succ
 348   assert_equal "bA", "aZ".succ
 349   assert_equal "1A", "0Z".succ
 350
 351   assert_equal ".", "-".succ
 352   assert_equal "\x01\x00", "\xff".succ
 353   assert_equal "-b", "-a".succ
 354   assert_equal "-aa", "-z".succ
 355   assert_equal "-a-b-", "-a-a-".succ
 356   assert_equal "-b-", "-a-".succ
 357   assert_equal "-aa-", "-z-".succ
 358   assert_equal "あb", "あa".succ
 359   assert_equal "あba", "あaz".succ
 360
 361   a = ""; a.succ!
 362   assert_equal "", a
 363   a = "0"; a.succ!
 364   assert_equal "1", a
 365   a = "9"; a.succ!
 366   assert_equal "10", a
 367   a = "00"; a.succ!
 368   assert_equal "01", a
 369   a = "a0"; a.succ!
 370   assert_equal "a1", a
 371   a = "A0"; a.succ!
 372   assert_equal "A1", a
 373   a = "09"; a.succ!
 374   assert_equal "10", a
 375   a = "a9"; a.succ!
 376   assert_equal "b0", a
 377   a = "A9"; a.succ!
 378   assert_equal "B0", a
 379
 380   a = "a"; a.succ!
 381   assert_equal "b", a
 382   a = "z"; a.succ!
 383   assert_equal "aa", a
 384   a = "aa"; a.succ!
 385   assert_equal "ab", a
 386   a = "Aa"; a.succ!
 387   assert_equal "Ab", a
 388   a = "0a"; a.succ!
 389   assert_equal "0b", a
 390   a = "az"; a.succ!
 391   assert_equal "ba", a
 392   a = "Az"; a.succ!
 393   assert_equal "Ba", a
 394   a = "0z"; a.succ!
 395   assert_equal "1a", a
 396
 397   a = "A"; a.succ!
 398   assert_equal "B", a
 399   a = "Z"; a.succ!
 400   assert_equal "AA", a
 401   a = "AA"; a.succ!
 402   assert_equal "AB", a
 403   a = "aA"; a.succ!
 404   assert_equal "aB", a
 405   a = "0A"; a.succ!
 406   assert_equal "0B", a
 407   a = "AZ"; a.succ!
 408   assert_equal "BA", a
 409   a = "aZ"; a.succ!
 410   assert_equal "bA", a
 411   a = "0Z"; a.succ!
 412   assert_equal "1A", a
 413
 414   a = "-"; a.succ!
 415   assert_equal ".", a
 416   a = "\xff"; a.succ!
 417   assert_equal "\x01\x00", a
 418   a = "-a"; a.succ!
 419   assert_equal "-b", a
 420   a = "-z"; a.succ!
 421   assert_equal "-aa", a
 422   a = "-a-a-"; a.succ!
 423   assert_equal "-a-b-", a
 424   a = "-a-"; a.succ!
 425   assert_equal "-b-", a
 426   a = "-z-"; a.succ!
 427   assert_equal "-aa-", a
 428   a = "あb"; a.succ!
 429   assert_equal "あc", a
 430   a = "あaz"; a.succ!
 431   assert_equal "あba", a
 432 end
 433
 434 assert('String#next') do
 435   assert_equal "01", "00".next
 436
 437   a = "00"; a.next!
 438   assert_equal "01", a
 439 end
 440
 441 assert('String#insert') do
 442   assert_equal "Xabcd", "abcd".insert(0, 'X')
 443   assert_equal "abcXd", "abcd".insert(3, 'X')
 444   assert_equal "abcdX", "abcd".insert(4, 'X')
 445   assert_equal "abXcd", "abcd".insert(-3, 'X')
 446   assert_equal "abcdX", "abcd".insert(-1, 'X')
 447   assert_raise(IndexError) { "abcd".insert(5, 'X') }
 448   assert_raise(IndexError) { "abcd".insert(-6, 'X') }
 449
 450   a = "abcd"
 451   a.insert(0, 'X')
 452   assert_equal "Xabcd", a
 453 end
 454
 455 assert('String#prepend') do
 456   a = "world"
 457   assert_equal "hello world", a.prepend("hello ")
 458   assert_equal "hello world", a
 459 end
 460
 461 assert('String#ljust') do
 462   assert_equal "hello", "hello".ljust(4)
 463   assert_equal "hello               ", "hello".ljust(20)
 464   assert_equal 20, "hello".ljust(20).length
 465   assert_equal "hello123412341234123", "hello".ljust(20, '1234')
 466   assert_equal "hello", "hello".ljust(-3)
 467 end
 468
 469 assert('String#rjust') do
 470   assert_equal "hello", "hello".rjust(4)
 471   assert_equal "               hello", "hello".rjust(20)
 472   assert_equal 20, "hello".rjust(20).length
 473   assert_equal "123412341234123hello", "hello".rjust(20, '1234')
 474   assert_equal "hello", "hello".rjust(-3)
 475 end
 476
 477 if UTF8STRING
 478   assert('String#ljust with UTF8') do
 479     assert_equal "helloん              ", "helloん".ljust(20)
 480     assert_equal "helloó                            ", "helloó".ljust(34)
 481     assert_equal 34, "helloó".ljust(34).length
 482     assert_equal "helloんんんんんんんんんんんんんん", "hello".ljust(19, 'ん')
 483     assert_equal "helloんんんんんんんんんんんんんんん", "hello".ljust(20, 'ん')
 484   end
 485
 486   assert('String#rjust with UTF8') do
 487     assert_equal "              helloん", "helloん".rjust(20)
 488     assert_equal "                            helloó", "helloó".rjust(34)
 489     # assert_equal 34, "helloó".rjust(34).length
 490     assert_equal "んんんんんんんんんんんんんんhello", "hello".rjust(19, 'ん')
 491     assert_equal "んんんんんんんんんんんんんんんhello", "hello".rjust(20, 'ん')
 492   end
 493
 494   assert('UTF8 byte counting') do
 495     ret = '                                  '
 496     ret[-6..-1] = "helloó"
 497     assert_equal 34, ret.length
 498   end
 499 end
 500
 501 assert('String#ljust should not change string') do
 502   a = "hello"
 503   a.ljust(20)
 504   assert_equal "hello", a
 505 end
 506
 507 assert('String#rjust should not change string') do
 508   a = "hello"
 509   a.rjust(20)
 510   assert_equal "hello", a
 511 end
 512
 513 assert('String#ljust should raise on zero width padding') do
 514   assert_raise(ArgumentError) { "foo".ljust(10, '') }
 515 end
 516
 517 assert('String#rjust should raise on zero width padding') do
 518   assert_raise(ArgumentError) { "foo".rjust(10, '') }
 519 end
 520
 521 assert('String#upto') do
 522   assert_upto %w(a8 a9 b0 b1 b2 b3 b4 b5 b6), "a8", "b6"
 523   assert_upto ["9", "10", "11"], "9", "11"
 524   assert_upto [], "25", "5"
 525   assert_upto ["07", "08", "09", "10", "11"], "07", "11"
 526   assert_upto ["9", ":", ";", "<", "=", ">", "?", "@", "A"], "9", "A"
 527
 528   if UTF8STRING
 529     assert_upto %w(あ ぃ い ぅ う ぇ え ぉ お), "あ", "お"
 530   end
 531
 532   a     = "aa"
 533   start = "aa"
 534   count = 0
 535   assert_equal("aa", a.upto("zz") {|s|
 536     assert_equal(start, s)
 537     start.succ!
 538     count += 1
 539   })
 540   assert_equal(676, count)
 541
 542   a     = "a"
 543   start = "a"
 544   count = 0
 545   assert_equal("a", a.upto("a") {|s|
 546     assert_equal(start, s)
 547     start.succ!
 548     count += 1
 549   })
 550   assert_equal(1, count)
 551
 552   a     = "a"
 553   start = "a"
 554   count = 0
 555   assert_equal("a", a.upto("b", true) {|s|
 556     assert_equal(start, s)
 557     start.succ!
 558     count += 1
 559   })
 560   assert_equal(1, count)
 561
 562   a     = "0"
 563   start = "0"
 564   count = 0
 565   assert_equal("0", a.upto("0") {|s|
 566     assert_equal(start, s)
 567     start.succ!
 568     count += 1
 569   })
 570   assert_equal(1, count)
 571
 572   a     = "0"
 573   start = "0"
 574   count = 0
 575   assert_equal("0", a.upto("-1") {|s|
 576     assert_equal(start, s)
 577     start.succ!
 578     count += 1
 579   })
 580   assert_equal(0, count)
 581
 582   a     = "-1"
 583   start = "-1"
 584   count = 0
 585   assert_equal("-1", a.upto("-2") {|s|
 586     assert_equal(start, s)
 587     start.succ!
 588     count += 1
 589   })
 590   assert_equal(2, count)
 591
 592   assert_raise(TypeError) { "a".upto(:c) {} }
 593 end
 594
 595 assert('String#ord') do
 596   got = "hello!".split('').map {|x| x.ord}
 597   expect = [104, 101, 108, 108, 111, 33]
 598   unless UTF8STRING
 599     got << "\xff".ord
 600     expect << 0xff
 601   end
 602   assert_equal expect, got
 603 end
 604
 605 assert('String#ord(UTF-8)') do
 606   got = "こんにちは世界!".split('').map {|x| x.ord}
 607   expect = [0x3053,0x3093,0x306b,0x3061,0x306f,0x4e16,0x754c,0x21]
 608   assert_equal expect, got
 609 end if UTF8STRING
 610
 611 assert('String#chr') do
 612   assert_equal "a", "abcde".chr
 613   assert_equal "h", "hello!".chr
 614   assert_equal "", "".chr
 615 end
 616
 617 assert('String#chr(UTF-8)') do
 618   assert_equal "こ", "こんにちは世界!".chr
 619 end if UTF8STRING
 620
 621 assert('String#chars') do
 622   expect = ["h", "e", "l", "l", "o", "!"]
 623   assert_equal expect, "hello!".chars
 624   s = ""
 625   "hello!".chars do |x|
 626     s += x
 627   end
 628   assert_equal "hello!", s
 629 end
 630
 631 assert('String#chars(UTF-8)') do
 632   expect = ['こ', 'ん', 'に', 'ち', 'は', '世', '界', '!']
 633   assert_equal expect, "こんにちは世界!".chars
 634   s = ""
 635   "こんにちは世界!".chars do |x|
 636     s += x
 637   end
 638   assert_equal "こんにちは世界!", s
 639 end if UTF8STRING
 640
 641 assert('String#each_char') do
 642   chars = []
 643   "hello!".each_char do |x|
 644     chars << x
 645   end
 646   assert_equal ["h", "e", "l", "l", "o", "!"], chars
 647 end
 648
 649 assert('String#each_char(UTF-8)') do
 650   chars = []
 651   "こんにちは世界!".each_char do |x|
 652     chars << x
 653   end
 654   assert_equal ["こ", "ん", "に", "ち", "は", "世", "界", "!"], chars
 655 end if UTF8STRING
 656
 657 assert('String#codepoints') do
 658   expect = [104, 101, 108, 108, 111, 33]
 659   assert_equal expect, "hello!".codepoints
 660   cp = []
 661   "hello!".codepoints do |x|
 662     cp << x
 663   end
 664   assert_equal expect, cp
 665 end
 666
 667 assert('String#codepoints(UTF-8)') do
 668   expect = [12371, 12435, 12395, 12385, 12399, 19990, 30028, 33]
 669   assert_equal expect, "こんにちは世界!".codepoints
 670   cp = []
 671   "こんにちは世界!".codepoints do |x|
 672     cp << x
 673   end
 674   assert_equal expect, cp
 675 end if UTF8STRING
 676
 677 assert('String#each_codepoint') do
 678   expect = [104, 101, 108, 108, 111, 33]
 679   cp = []
 680   "hello!".each_codepoint do |x|
 681     cp << x
 682   end
 683   assert_equal expect, cp
 684 end
 685
 686 assert('String#each_codepoint(UTF-8)') do
 687   expect = [12371, 12435, 12395, 12385, 12399, 19990, 30028, 33]
 688   cp = []
 689   "こんにちは世界!".each_codepoint do |x|
 690     cp << x
 691   end
 692   assert_equal expect, cp
 693 end if UTF8STRING
 694
 695 assert('String#delete_prefix') do
 696   assert_equal "llo", "hello".delete_prefix("he")
 697   assert_equal "hello", "hello".delete_prefix("llo")
 698   assert_equal "llo", "hello".delete_prefix!("he")
 699   assert_nil "hello".delete_prefix!("llo")
 700 end
 701
 702 assert('String#delete_suffix') do
 703   assert_equal "he", "hello".delete_suffix("llo")
 704   assert_equal "hello", "hello".delete_suffix("he")
 705   assert_equal "he", "hello".delete_suffix!("llo")
 706   assert_nil "hello".delete_suffix!("he")
 707 end