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