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

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