third-party/mruby/test/t/string.rb

   1 # coding: utf-8
   2 ##
   3 # String ISO Test
   4
   5 UTF8STRING = ("\343\201\202".size == 1)
   6
   7 assert('String', '15.2.10') do
   8   assert_equal Class, String.class
   9 end
  10
  11 assert('String#<=>', '15.2.10.5.1') do
  12   a = '' <=> ''
  13   b = '' <=> 'not empty'
  14   c = 'not empty' <=> ''
  15   d = 'abc' <=> 'cba'
  16   e = 'cba' <=> 'abc'
  17
  18   assert_equal  0, a
  19   assert_equal(-1, b)
  20   assert_equal  1, c
  21   assert_equal(-1, d)
  22   assert_equal  1, e
  23   assert_nil 'a' <=> 1024
  24 end
  25
  26 assert('String#==', '15.2.10.5.2') do
  27   assert_equal 'abc', 'abc'
  28   assert_not_equal 'abc', 'cba'
  29 end
  30
  31 # 'String#=~', '15.2.10.5.3' will be tested in mrbgems.
  32
  33 assert('String#+', '15.2.10.5.4') do
  34   assert_equal 'ab', 'a' + 'b'
  35 end
  36
  37 assert('String#*', '15.2.10.5.5') do
  38   assert_equal 'aaaaa', 'a' * 5
  39   assert_equal '', 'a' * 0
  40   assert_raise(ArgumentError) do
  41     'a' * -1
  42   end
  43 end
  44
  45 assert('String#[]', '15.2.10.5.6') do
  46   # length of args is 1
  47   a = 'abc'[0]
  48   b = 'abc'[-1]
  49   c = 'abc'[10]
  50   d = 'abc'[-10]
  51   e = 'abc'[1.1]
  52
  53   # length of args is 2
  54   a1 = 'abc'[0, -1]
  55   b1 = 'abc'[10, 0]
  56   c1 = 'abc'[-10, 0]
  57   d1 = 'abc'[0, 0]
  58   e1 = 'abc'[1, 2]
  59
  60   # args is RegExp
  61   # It will be tested in mrbgems.
  62
  63   # args is String
  64   a3 = 'abc'['bc']
  65   b3 = 'abc'['XX']
  66
  67   assert_equal 'a', 'a'
  68   # assert_equal 'c', b
  69   # assert_nil c
  70   # assert_nil d
  71   # assert_equal 'b', e
  72   # assert_nil a1
  73   # assert_nil b1
  74   # assert_nil c1
  75   # assert_equal '', d1
  76   # assert_equal 'bc', e1
  77   # assert_equal 'bc', a3
  78   # assert_nil b3
  79
  80   # assert_raise(TypeError) do
  81   #   a[nil]
  82   # end
  83 end
  84
  85 assert('String#[](UTF-8)', '15.2.10.5.6') do
  86   assert_equal "ち", "こんにちは世界"[3]
  87   assert_equal nil, "こんにちは世界"[20]
  88   assert_equal "世", "こんにちは世界"[-2]
  89   assert_equal "世界", "こんにちは世界"[-2..-1]
  90   assert_equal "んに", "こんにちは世界"[1,2]
  91   assert_equal "世", "こんにちは世界"["世"]
  92 end if UTF8STRING
  93
  94 assert('String#[] with Range') do
  95   a1 = 'abc'[1..0]
  96   b1 = 'abc'[1..1]
  97   c1 = 'abc'[1..2]
  98   d1 = 'abc'[1..3]
  99   e1 = 'abc'[1..4]
 100   f1 = 'abc'[0..-2]
 101   g1 = 'abc'[-2..3]
 102   h1 = 'abc'[3..4]
 103   i1 = 'abc'[4..5]
 104   j1 = 'abcdefghijklmnopqrstuvwxyz'[1..3]
 105   a2 = 'abc'[1...0]
 106   b2 = 'abc'[1...1]
 107   c2 = 'abc'[1...2]
 108   d2 = 'abc'[1...3]
 109   e2 = 'abc'[1...4]
 110   f2 = 'abc'[0...-2]
 111   g2 = 'abc'[-2...3]
 112   h2 = 'abc'[3...4]
 113   i2 = 'abc'[4...5]
 114   j2 = 'abcdefghijklmnopqrstuvwxyz'[1...3]
 115
 116   assert_equal '', a1
 117   assert_equal 'b', b1
 118   assert_equal 'bc', c1
 119   assert_equal 'bc', d1
 120   assert_equal 'bc', e1
 121   assert_equal 'ab', f1
 122   assert_equal 'bc', g1
 123   assert_equal '', h1
 124   assert_nil i2
 125   assert_equal 'bcd', j1
 126   assert_equal '', a2
 127   assert_equal '', b2
 128   assert_equal 'b', c2
 129   assert_equal 'bc', d2
 130   assert_equal 'bc', e2
 131   assert_equal 'a', f2
 132   assert_equal 'bc', g2
 133   assert_equal '', h2
 134   assert_nil i2
 135   assert_equal 'bc', j2
 136 end
 137
 138 assert('String#[]=') do
 139   # length of args is 1
 140   a = 'abc'
 141   a[0] = 'X'
 142   assert_equal 'Xbc', a
 143
 144   b = 'abc'
 145   b[-1] = 'X'
 146   assert_equal 'abX', b
 147
 148   c = 'abc'
 149   assert_raise(IndexError) do
 150     c[10] = 'X'
 151   end
 152
 153   d = 'abc'
 154   assert_raise(IndexError) do
 155     d[-10] = 'X'
 156   end
 157
 158   if Object.const_defined?(:Float)
 159    e = 'abc'
 160    e[1.1] = 'X'
 161    assert_equal 'aXc', e
 162   end
 163
 164   # length of args is 2
 165   a1 = 'abc'
 166   assert_raise(IndexError) do
 167     a1[0, -1] = 'X'
 168   end
 169
 170   b1 = 'abc'
 171   assert_raise(IndexError) do
 172     b1[10, 0] = 'X'
 173   end
 174
 175   c1 = 'abc'
 176   assert_raise(IndexError) do
 177     c1[-10, 0] = 'X'
 178   end
 179
 180   d1 = 'abc'
 181   d1[0, 0] = 'X'
 182   assert_equal 'Xabc', d1
 183
 184   e1 = 'abc'
 185   e1[1, 3] = 'X'
 186   assert_equal 'aX', e1
 187
 188   # args is RegExp
 189   # It will be tested in mrbgems.
 190
 191   # args is String
 192   a3 = 'abc'
 193   a3['bc'] = 'X'
 194   assert_equal a3, 'aX'
 195
 196   b3 = 'abc'
 197   assert_raise(IndexError) do
 198     b3['XX'] = 'Y'
 199   end
 200 end
 201
 202 assert('String#capitalize', '15.2.10.5.7') do
 203   a = 'abc'
 204   a.capitalize
 205
 206   assert_equal 'abc', a
 207   assert_equal 'Abc', 'abc'.capitalize
 208 end
 209
 210 assert('String#capitalize!', '15.2.10.5.8') do
 211   a = 'abc'
 212   a.capitalize!
 213
 214   assert_equal 'Abc', a
 215   assert_equal nil, 'Abc'.capitalize!
 216 end
 217
 218 assert('String#chomp', '15.2.10.5.9') do
 219   a = 'abc'.chomp
 220   b = ''.chomp
 221   c = "abc\n".chomp
 222   d = "abc\n\n".chomp
 223   e = "abc\t".chomp("\t")
 224   f = "abc\n"
 225
 226   f.chomp
 227
 228   assert_equal 'abc', a
 229   assert_equal '', b
 230   assert_equal 'abc', c
 231   assert_equal "abc\n", d
 232   assert_equal 'abc', e
 233   assert_equal "abc\n", f
 234 end
 235
 236 assert('String#chomp!', '15.2.10.5.10') do
 237   a = 'abc'
 238   b = ''
 239   c = "abc\n"
 240   d = "abc\n\n"
 241   e = "abc\t"
 242
 243   a.chomp!
 244   b.chomp!
 245   c.chomp!
 246   d.chomp!
 247   e.chomp!("\t")
 248
 249   assert_equal 'abc', a
 250   assert_equal '', b
 251   assert_equal 'abc', c
 252   assert_equal "abc\n", d
 253   assert_equal 'abc', e
 254 end
 255
 256 assert('String#chop', '15.2.10.5.11') do
 257   a = ''.chop
 258   b = 'abc'.chop
 259   c = 'abc'
 260
 261   c.chop
 262
 263   assert_equal '', a
 264   assert_equal 'ab', b
 265   assert_equal 'abc', c
 266 end
 267
 268 assert('String#chop(UTF-8)', '15.2.10.5.11') do
 269   a = ''.chop
 270   b = 'あいう'.chop
 271   c = "あ\nい".chop.chop
 272
 273   assert_equal '', a
 274   assert_equal 'あい', b
 275   assert_equal 'あ', c
 276 end if UTF8STRING
 277
 278 assert('String#chop!', '15.2.10.5.12') do
 279   a = ''
 280   b = 'abc'
 281
 282   a.chop!
 283   b.chop!
 284
 285   assert_equal a, ''
 286   assert_equal b, 'ab'
 287 end
 288
 289 assert('String#chop!(UTF-8)', '15.2.10.5.12') do
 290   a = ''
 291   b = "あいうえ\n"
 292   c = "あいうえ\n"
 293
 294   a.chop!
 295   b.chop!
 296   c.chop!
 297   c.chop!
 298
 299   assert_equal a, ''
 300   assert_equal b, 'あいうえ'
 301   assert_equal c, 'あいう'
 302 end if UTF8STRING
 303
 304 assert('String#downcase', '15.2.10.5.13') do
 305   a = 'ABC'.downcase
 306   b = 'ABC'
 307
 308   b.downcase
 309
 310   assert_equal 'abc', a
 311   assert_equal 'ABC', b
 312 end
 313
 314 assert('String#downcase!', '15.2.10.5.14') do
 315   a = 'ABC'
 316
 317   a.downcase!
 318
 319   assert_equal 'abc', a
 320   assert_equal nil, 'abc'.downcase!
 321 end
 322
 323 assert('String#each_line', '15.2.10.5.15') do
 324   a = "first line\nsecond line\nthird line"
 325   list = ["first line\n", "second line\n", "third line"]
 326   n_list = []
 327
 328   a.each_line do |line|
 329     n_list << line
 330   end
 331
 332   assert_equal list, n_list
 333
 334   n_list.clear
 335   a.each_line("li") do |line|
 336     n_list << line
 337   end
 338   assert_equal ["first li", "ne\nsecond li", "ne\nthird li", "ne"], n_list
 339 end
 340
 341 assert('String#empty?', '15.2.10.5.16') do
 342   a = ''
 343   b = 'not empty'
 344
 345   assert_true a.empty?
 346   assert_false b.empty?
 347 end
 348
 349 assert('String#eql?', '15.2.10.5.17') do
 350   assert_true 'abc'.eql?('abc')
 351   assert_false 'abc'.eql?('cba')
 352 end
 353
 354 assert('String#gsub', '15.2.10.5.18') do
 355   assert_equal('aBcaBc', 'abcabc'.gsub('b', 'B'), 'gsub without block')
 356   assert_equal('aBcaBc', 'abcabc'.gsub('b'){|w| w.capitalize }, 'gsub with block')
 357   assert_equal('$a$a$',  '#a#a#'.gsub('#', '$'), 'mruby/mruby#847')
 358   assert_equal('$a$a$',  '#a#a#'.gsub('#'){|_w| '$' }, 'mruby/mruby#847 with block')
 359   assert_equal('$$a$$',  '##a##'.gsub('##', '$$'), 'mruby/mruby#847 another case')
 360   assert_equal('$$a$$',  '##a##'.gsub('##'){|_w| '$$' }, 'mruby/mruby#847 another case with block')
 361   assert_equal('A',      'a'.gsub('a', 'A'))
 362   assert_equal('A',      'a'.gsub('a'){|w| w.capitalize })
 363   assert_equal("<a><><>", 'a'.gsub('a', '<\0><\1><\2>'))
 364   assert_equal(".h.e.l.l.o.", "hello".gsub("", "."))
 365   a = []
 366   assert_equal(".h.e.l.l.o.", "hello".gsub("") { |i| a << i; "." })
 367   assert_equal(["", "", "", "", "", ""], a)
 368   assert_raise(ArgumentError) { "".gsub }
 369   assert_raise(ArgumentError) { "".gsub("", "", "") }
 370 end
 371
 372 assert('String#gsub with backslash') do
 373   s = 'abXcdXef'
 374   assert_equal 'ab<\\>cd<\\>ef',    s.gsub('X', '<\\\\>')
 375   assert_equal 'ab<X>cd<X>ef',      s.gsub('X', '<\\&>')
 376   assert_equal 'ab<X>cd<X>ef',      s.gsub('X', '<\\0>')
 377   assert_equal 'ab<ab>cd<abXcd>ef', s.gsub('X', '<\\`>')
 378   assert_equal 'ab<cdXef>cd<ef>ef', s.gsub('X', '<\\\'>')
 379 end
 380
 381 assert('String#gsub!', '15.2.10.5.19') do
 382   a = 'abcabc'
 383   a.gsub!('b', 'B')
 384
 385   b = 'abcabc'
 386   b.gsub!('b') { |w| w.capitalize }
 387
 388   assert_equal 'aBcaBc', a
 389   assert_equal 'aBcaBc', b
 390 end
 391
 392 assert('String#hash', '15.2.10.5.20') do
 393   a = 'abc'
 394
 395   assert_equal 'abc'.hash, a.hash
 396 end
 397
 398 assert('String#include?', '15.2.10.5.21') do
 399   assert_true 'abc'.include?('a')
 400   assert_false 'abc'.include?('d')
 401 end
 402
 403 assert('String#index', '15.2.10.5.22') do
 404   assert_equal 0, 'abc'.index('a')
 405   assert_nil 'abc'.index('d')
 406   assert_equal 3, 'abcabc'.index('a', 1)
 407   assert_equal 5, "hello".index("", 5)
 408   assert_equal nil, "hello".index("", 6)
 409 end
 410
 411 assert('String#initialize', '15.2.10.5.23') do
 412   a = ''
 413   a.initialize('abc')
 414   assert_equal 'abc', a
 415
 416   a.initialize('abcdefghijklmnopqrstuvwxyz')
 417   assert_equal 'abcdefghijklmnopqrstuvwxyz', a
 418 end
 419
 420 assert('String#initialize_copy', '15.2.10.5.24') do
 421   a = ''
 422   a.initialize_copy('abc')
 423
 424   assert_equal 'abc', a
 425 end
 426
 427 assert('String#intern', '15.2.10.5.25') do
 428   assert_equal :abc, 'abc'.intern
 429 end
 430
 431 assert('String#length', '15.2.10.5.26') do
 432   assert_equal 3, 'abc'.length
 433 end
 434
 435 # 'String#match', '15.2.10.5.27' will be tested in mrbgems.
 436
 437 assert('String#replace', '15.2.10.5.28') do
 438   a = ''
 439   a.replace('abc')
 440
 441   assert_equal 'abc', a
 442   assert_equal 'abc', 'cba'.replace(a)
 443
 444   b = 'abc' * 10
 445   c = ('cba' * 10).dup
 446   b.replace(c);
 447   c.replace(b);
 448   assert_equal c, b
 449
 450   # shared string
 451   s = "foo" * 100
 452   a = s[10, 90]                # create shared string
 453   assert_equal("", s.replace(""))    # clear
 454   assert_equal("", s)          # s is cleared
 455   assert_not_equal("", a)      # a should not be affected
 456 end
 457
 458 assert('String#reverse', '15.2.10.5.29') do
 459   a = 'abc'
 460   a.reverse
 461
 462   assert_equal 'abc', a
 463   assert_equal 'cba', 'abc'.reverse
 464 end
 465
 466 assert('String#reverse(UTF-8)', '15.2.10.5.29') do
 467   a = 'こんにちは世界!'
 468   a.reverse
 469
 470   assert_equal 'こんにちは世界!', a
 471   assert_equal '!界世はちにんこ', 'こんにちは世界!'.reverse
 472 end if UTF8STRING
 473
 474 assert('String#reverse!', '15.2.10.5.30') do
 475   a = 'abc'
 476   a.reverse!
 477
 478   assert_equal 'cba', a
 479   assert_equal 'cba', 'abc'.reverse!
 480 end
 481
 482 assert('String#reverse!(UTF-8)', '15.2.10.5.30') do
 483   a = 'こんにちは世界!'
 484   a.reverse!
 485
 486   assert_equal '!界世はちにんこ', a
 487   assert_equal '!界世はちにんこ', 'こんにちは世界!'.reverse!
 488 end if UTF8STRING
 489
 490 assert('String#rindex', '15.2.10.5.31') do
 491   assert_equal 0, 'abc'.rindex('a')
 492   assert_nil 'abc'.rindex('d')
 493   assert_equal 0, 'abcabc'.rindex('a', 1)
 494   assert_equal 3, 'abcabc'.rindex('a', 4)
 495 end
 496
 497 assert('String#rindex(UTF-8)', '15.2.10.5.31') do
 498   str = "こんにちは世界!\nこんにちは世界!"
 499   assert_nil str.index('さ')
 500   assert_equal 3, str.index('ち')
 501   assert_equal 12, str.index('ち', 10)
 502   assert_equal nil, str.index("さ")
 503 end if UTF8STRING
 504
 505 # 'String#scan', '15.2.10.5.32' will be tested in mrbgems.
 506
 507 assert('String#size', '15.2.10.5.33') do
 508   assert_equal 3, 'abc'.size
 509 end
 510
 511 assert('String#size(UTF-8)', '15.2.10.5.33') do
 512   str = 'こんにちは世界!'
 513   assert_equal 8, str.size
 514   assert_not_equal str.bytesize, str.size
 515   assert_equal 2, str[1, 2].size
 516 end if UTF8STRING
 517
 518 assert('String#slice', '15.2.10.5.34') do
 519   # length of args is 1
 520   a = 'abc'.slice(0)
 521   b = 'abc'.slice(-1)
 522   c = 'abc'.slice(10)
 523   d = 'abc'.slice(-10)
 524
 525   # length of args is 2
 526   a1 = 'abc'.slice(0, -1)
 527   b1 = 'abc'.slice(10, 0)
 528   c1 = 'abc'.slice(-10, 0)
 529   d1 = 'abc'.slice(0, 0)
 530   e1 = 'abc'.slice(1, 2)
 531
 532   # slice of shared string
 533   e11 = e1.slice(0)
 534
 535   # args is RegExp
 536   # It will be tested in mrbgems.
 537
 538   # args is String
 539   a3 = 'abc'.slice('bc')
 540   b3 = 'abc'.slice('XX')
 541
 542   assert_equal 'a', a
 543   assert_equal 'c', b
 544   assert_nil c
 545   assert_nil d
 546   assert_nil a1
 547   assert_nil b1
 548   assert_nil c1
 549   assert_equal '', d1
 550   assert_equal 'bc', e1
 551   assert_equal 'b', e11
 552   assert_equal 'bc', a3
 553   assert_nil b3
 554 end
 555
 556 # TODO Broken ATM
 557 assert('String#split', '15.2.10.5.35') do
 558   # without RegExp behavior is actually unspecified
 559   assert_equal ['abc', 'abc', 'abc'], 'abc abc abc'.split
 560   assert_equal ["a", "b", "c", "", "d"], 'a,b,c,,d'.split(',')
 561   assert_equal ['abc', 'abc', 'abc'], 'abc abc abc'.split(nil)
 562   assert_equal ['a', 'b', 'c'], 'abc'.split("")
 563 end
 564
 565 assert('String#split(UTF-8)', '15.2.10.5.35') do
 566   got = "こんにちは世界!".split('')
 567   assert_equal ['こ', 'ん', 'に', 'ち', 'は', '世', '界', '!'], got
 568   got = "こんにちは世界!".split('に')
 569   assert_equal ['こん', 'ちは世界!'], got
 570 end if UTF8STRING
 571
 572 assert('String#sub', '15.2.10.5.36') do
 573   assert_equal 'aBcabc', 'abcabc'.sub('b', 'B')
 574   assert_equal 'aBcabc', 'abcabc'.sub('b') { |w| w.capitalize }
 575   assert_equal 'aa$', 'aa#'.sub('#', '$')
 576   assert_equal '.abc', "abc".sub("", ".")
 577
 578   str = "abc"
 579   miss = str.sub("X", "Z")
 580   assert_equal str, miss
 581   assert_not_same str, miss
 582
 583   a = []
 584   assert_equal '.abc', "abc".sub("") { |i| a << i; "." }
 585   assert_equal [""], a
 586 end
 587
 588 assert('String#sub with backslash') do
 589   s = 'abXcdXef'
 590   assert_equal 'ab<\\>cdXef',    s.sub('X', '<\\\\>')
 591   assert_equal 'ab<X>cdXef',     s.sub('X', '<\\&>')
 592   assert_equal 'ab<X>cdXef',     s.sub('X', '<\\0>')
 593   assert_equal 'ab<ab>cdXef',    s.sub('X', '<\\`>')
 594   assert_equal 'ab<cdXef>cdXef', s.sub('X', '<\\\'>')
 595 end
 596
 597 assert('String#sub!', '15.2.10.5.37') do
 598   a = 'abcabc'
 599   a.sub!('b', 'B')
 600
 601   b = 'abcabc'
 602   b.sub!('b') { |w| w.capitalize }
 603
 604   assert_equal 'aBcabc', a
 605   assert_equal 'aBcabc', b
 606 end
 607
 608 assert('String#to_f', '15.2.10.5.38') do
 609   a = ''.to_f
 610   b = '123456789'.to_f
 611   c = '12345.6789'.to_f
 612   d = '1e-2147483648'.to_f
 613   e = '1e2147483648'.to_f
 614
 615   assert_float(0.0, a)
 616   assert_float(123456789.0, b)
 617   assert_float(12345.6789, c)
 618   assert_float(0, d)
 619   assert_float(Float::INFINITY, e)
 620 end if Object.const_defined?(:Float)
 621
 622 assert('String#to_i', '15.2.10.5.39') do
 623   a = ''.to_i
 624   b = '32143'.to_i
 625   c = 'a'.to_i(16)
 626   d = '100'.to_i(2)
 627   e = '1_000'.to_i
 628
 629   assert_equal 0, a
 630   assert_equal 32143, b
 631   assert_equal 10, c
 632   assert_equal 4, d
 633   assert_equal 1_000, e
 634 end
 635
 636 assert('String#to_s', '15.2.10.5.40') do
 637   assert_equal 'abc', 'abc'.to_s
 638 end
 639
 640 assert('String#to_sym', '15.2.10.5.41') do
 641   assert_equal :abc, 'abc'.to_sym
 642 end
 643
 644 assert('String#upcase', '15.2.10.5.42') do
 645   a = 'abc'.upcase
 646   b = 'abc'
 647
 648   b.upcase
 649
 650   assert_equal 'ABC', a
 651   assert_equal 'abc', b
 652 end
 653
 654 assert('String#upcase!', '15.2.10.5.43') do
 655   a = 'abc'
 656
 657   a.upcase!
 658
 659   assert_equal 'ABC', a
 660   assert_equal nil, 'ABC'.upcase!
 661
 662   a = 'abcdefghijklmnopqrstuvwxyz'
 663   b = a.dup
 664   a.upcase!
 665   b.upcase!
 666   assert_equal 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', b
 667 end
 668
 669 assert('String#inspect', '15.2.10.5.46') do
 670   # should not raise an exception - regress #1210
 671   assert_nothing_raised do
 672   ("\1" * 100).inspect
 673   end
 674
 675   assert_equal "\"\\x00\"", "\0".inspect
 676 end
 677
 678 # Not ISO specified
 679
 680 assert('String interpolation (mrb_str_concat for shared strings)') do
 681   a = "A" * 32
 682   assert_equal "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA:", "#{a}:"
 683 end
 684
 685 assert('Check the usage of a NUL character') do
 686   "qqq\0ppp"
 687 end
 688
 689 assert('String#bytes') do
 690   str1 = "hello"
 691   bytes1 = [104, 101, 108, 108, 111]
 692
 693   str2 = "\xFF"
 694   bytes2 = [0xFF]
 695
 696   assert_equal bytes1, str1.bytes
 697   assert_equal bytes2, str2.bytes
 698 end
 699
 700 assert('String#each_byte') do
 701   str1 = "hello"
 702   bytes1 = [104, 101, 108, 108, 111]
 703   bytes2 = []
 704
 705   str1.each_byte {|b| bytes2 << b }
 706
 707   assert_equal bytes1, bytes2
 708 end
 709
 710 assert('String#freeze') do
 711   str = "hello"
 712   str.freeze
 713
 714   assert_raise(FrozenError) { str.upcase! }
 715 end
 716
 717 assert('String literal concatenation') do
 718   assert_equal 2, ("A" "B").size
 719   assert_equal 3, ('A' "B" 'C').size
 720   assert_equal 4, (%(A) "B#{?C}" "D").size
 721 end