From be1c7e50e1e8809ea56f2c9d472eccd8ffd73a97 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 04:57:58 +0200 Subject: Adding upstream version 1.44.3. Signed-off-by: Daniel Baumann --- web/server/h2o/libh2o/deps/mruby/test/t/string.rb | 727 ++++++++++++++++++++++ 1 file changed, 727 insertions(+) create mode 100644 web/server/h2o/libh2o/deps/mruby/test/t/string.rb (limited to 'web/server/h2o/libh2o/deps/mruby/test/t/string.rb') diff --git a/web/server/h2o/libh2o/deps/mruby/test/t/string.rb b/web/server/h2o/libh2o/deps/mruby/test/t/string.rb new file mode 100644 index 00000000..a4139622 --- /dev/null +++ b/web/server/h2o/libh2o/deps/mruby/test/t/string.rb @@ -0,0 +1,727 @@ +# coding: utf-8 +## +# String ISO Test + +UTF8STRING = ("\343\201\202".size == 1) + +assert('String', '15.2.10') do + assert_equal Class, String.class +end + +assert('String#<=>', '15.2.10.5.1') do + a = '' <=> '' + b = '' <=> 'not empty' + c = 'not empty' <=> '' + d = 'abc' <=> 'cba' + e = 'cba' <=> 'abc' + + assert_equal 0, a + assert_equal(-1, b) + assert_equal 1, c + assert_equal(-1, d) + assert_equal 1, e +end + +assert('String#==', '15.2.10.5.2') do + assert_equal 'abc', 'abc' + assert_not_equal 'abc', 'cba' +end + +# 'String#=~', '15.2.10.5.3' will be tested in mrbgems. + +assert('String#+', '15.2.10.5.4') do + assert_equal 'ab', 'a' + 'b' +end + +assert('String#*', '15.2.10.5.5') do + assert_equal 'aaaaa', 'a' * 5 + assert_equal '', 'a' * 0 + assert_raise(ArgumentError) do + 'a' * -1 + end +end + +assert('String#[]', '15.2.10.5.6') do + # length of args is 1 + a = 'abc'[0] + b = 'abc'[-1] + c = 'abc'[10] + d = 'abc'[-10] + e = 'abc'[1.1] + + # length of args is 2 + a1 = 'abc'[0, -1] + b1 = 'abc'[10, 0] + c1 = 'abc'[-10, 0] + d1 = 'abc'[0, 0] + e1 = 'abc'[1, 2] + + # args is RegExp + # It will be tested in mrbgems. + + # args is String + a3 = 'abc'['bc'] + b3 = 'abc'['XX'] + + assert_equal 'a', 'a' + # assert_equal 'c', b + # assert_nil c + # assert_nil d + # assert_equal 'b', e + # assert_nil a1 + # assert_nil b1 + # assert_nil c1 + # assert_equal '', d1 + # assert_equal 'bc', e1 + # assert_equal 'bc', a3 + # assert_nil b3 + + # assert_raise(TypeError) do + # a[nil] + # end +end + +assert('String#[](UTF-8)', '15.2.10.5.6') do + assert_equal "ち", "こんにちは世界"[3] + assert_equal nil, "こんにちは世界"[20] + assert_equal "世", "こんにちは世界"[-2] + assert_equal "世界", "こんにちは世界"[-2..-1] + assert_equal "んに", "こんにちは世界"[1,2] + assert_equal "世", "こんにちは世界"["世"] +end if UTF8STRING + +assert('String#[] with Range') do + a1 = 'abc'[1..0] + b1 = 'abc'[1..1] + c1 = 'abc'[1..2] + d1 = 'abc'[1..3] + e1 = 'abc'[1..4] + f1 = 'abc'[0..-2] + g1 = 'abc'[-2..3] + h1 = 'abc'[3..4] + i1 = 'abc'[4..5] + j1 = 'abcdefghijklmnopqrstuvwxyz'[1..3] + a2 = 'abc'[1...0] + b2 = 'abc'[1...1] + c2 = 'abc'[1...2] + d2 = 'abc'[1...3] + e2 = 'abc'[1...4] + f2 = 'abc'[0...-2] + g2 = 'abc'[-2...3] + h2 = 'abc'[3...4] + i2 = 'abc'[4...5] + j2 = 'abcdefghijklmnopqrstuvwxyz'[1...3] + + assert_equal '', a1 + assert_equal 'b', b1 + assert_equal 'bc', c1 + assert_equal 'bc', d1 + assert_equal 'bc', e1 + assert_equal 'ab', f1 + assert_equal 'bc', g1 + assert_equal '', h1 + assert_nil i2 + assert_equal 'bcd', j1 + assert_equal '', a2 + assert_equal '', b2 + assert_equal 'b', c2 + assert_equal 'bc', d2 + assert_equal 'bc', e2 + assert_equal 'a', f2 + assert_equal 'bc', g2 + assert_equal '', h2 + assert_nil i2 + assert_equal 'bc', j2 +end + +assert('String#[]=') do + # length of args is 1 + a = 'abc' + a[0] = 'X' + assert_equal 'Xbc', a + + b = 'abc' + b[-1] = 'X' + assert_equal 'abX', b + + c = 'abc' + assert_raise(IndexError) do + c[10] = 'X' + end + + d = 'abc' + assert_raise(IndexError) do + d[-10] = 'X' + end + + e = 'abc' + e[1.1] = 'X' + assert_equal 'aXc', e + + + # length of args is 2 + a1 = 'abc' + assert_raise(IndexError) do + a1[0, -1] = 'X' + end + + b1 = 'abc' + assert_raise(IndexError) do + b1[10, 0] = 'X' + end + + c1 = 'abc' + assert_raise(IndexError) do + c1[-10, 0] = 'X' + end + + d1 = 'abc' + d1[0, 0] = 'X' + assert_equal 'Xabc', d1 + + e1 = 'abc' + e1[1, 3] = 'X' + assert_equal 'aX', e1 + + # args is RegExp + # It will be tested in mrbgems. + + # args is String + a3 = 'abc' + a3['bc'] = 'X' + assert_equal a3, 'aX' + + b3 = 'abc' + assert_raise(IndexError) do + b3['XX'] = 'Y' + end +end + +assert('String#capitalize', '15.2.10.5.7') do + a = 'abc' + a.capitalize + + assert_equal 'abc', a + assert_equal 'Abc', 'abc'.capitalize +end + +assert('String#capitalize!', '15.2.10.5.8') do + a = 'abc' + a.capitalize! + + assert_equal 'Abc', a + assert_equal nil, 'Abc'.capitalize! +end + +assert('String#chomp', '15.2.10.5.9') do + a = 'abc'.chomp + b = ''.chomp + c = "abc\n".chomp + d = "abc\n\n".chomp + e = "abc\t".chomp("\t") + f = "abc\n" + + f.chomp + + assert_equal 'abc', a + assert_equal '', b + assert_equal 'abc', c + assert_equal "abc\n", d + assert_equal 'abc', e + assert_equal "abc\n", f +end + +assert('String#chomp!', '15.2.10.5.10') do + a = 'abc' + b = '' + c = "abc\n" + d = "abc\n\n" + e = "abc\t" + + a.chomp! + b.chomp! + c.chomp! + d.chomp! + e.chomp!("\t") + + assert_equal 'abc', a + assert_equal '', b + assert_equal 'abc', c + assert_equal "abc\n", d + assert_equal 'abc', e +end + +assert('String#chomp! uses the correct length') do + class A + def to_str + $s.replace("AA") + "A" + end + end + + $s = "AAA" + $s.chomp!(A.new) + assert_equal $s, "A" +end + +assert('String#chop', '15.2.10.5.11') do + a = ''.chop + b = 'abc'.chop + c = 'abc' + + c.chop + + assert_equal '', a + assert_equal 'ab', b + assert_equal 'abc', c +end + +assert('String#chop(UTF-8)', '15.2.10.5.11') do + a = ''.chop + b = 'あいう'.chop + c = "あ\nい".chop.chop + + assert_equal '', a + assert_equal 'あい', b + assert_equal 'あ', c +end if UTF8STRING + +assert('String#chop!', '15.2.10.5.12') do + a = '' + b = 'abc' + + a.chop! + b.chop! + + assert_equal a, '' + assert_equal b, 'ab' +end + +assert('String#chop!(UTF-8)', '15.2.10.5.12') do + a = '' + b = "あいうえ\n" + c = "あいうえ\n" + + a.chop! + b.chop! + c.chop! + c.chop! + + assert_equal a, '' + assert_equal b, 'あいうえ' + assert_equal c, 'あいう' +end if UTF8STRING + +assert('String#downcase', '15.2.10.5.13') do + a = 'ABC'.downcase + b = 'ABC' + + b.downcase + + assert_equal 'abc', a + assert_equal 'ABC', b +end + +assert('String#downcase!', '15.2.10.5.14') do + a = 'ABC' + + a.downcase! + + assert_equal 'abc', a + assert_equal nil, 'abc'.downcase! +end + +assert('String#each_line', '15.2.10.5.15') do + a = "first line\nsecond line\nthird line" + list = ["first line\n", "second line\n", "third line"] + n_list = [] + + a.each_line do |line| + n_list << line + end + + assert_equal list, n_list + + n_list.clear + a.each_line("li") do |line| + n_list << line + end + assert_equal ["first li", "ne\nsecond li", "ne\nthird li", "ne"], n_list +end + +assert('String#empty?', '15.2.10.5.16') do + a = '' + b = 'not empty' + + assert_true a.empty? + assert_false b.empty? +end + +assert('String#eql?', '15.2.10.5.17') do + assert_true 'abc'.eql?('abc') + assert_false 'abc'.eql?('cba') +end + +assert('String#gsub', '15.2.10.5.18') do + assert_equal('aBcaBc', 'abcabc'.gsub('b', 'B'), 'gsub without block') + assert_equal('aBcaBc', 'abcabc'.gsub('b'){|w| w.capitalize }, 'gsub with block') + assert_equal('$a$a$', '#a#a#'.gsub('#', '$'), 'mruby/mruby#847') + assert_equal('$a$a$', '#a#a#'.gsub('#'){|w| '$' }, 'mruby/mruby#847 with block') + assert_equal('$$a$$', '##a##'.gsub('##', '$$'), 'mruby/mruby#847 another case') + assert_equal('$$a$$', '##a##'.gsub('##'){|w| '$$' }, 'mruby/mruby#847 another case with block') + assert_equal('A', 'a'.gsub('a', 'A')) + assert_equal('A', 'a'.gsub('a'){|w| w.capitalize }) + assert_equal("<><>", 'a'.gsub('a', '<\0><\1><\2>')) + assert_equal(".h.e.l.l.o.", "hello".gsub("", ".")) + a = [] + assert_equal(".h.e.l.l.o.", "hello".gsub("") { |i| a << i; "." }) + assert_equal(["", "", "", "", "", ""], a) + assert_raise(ArgumentError) { "".gsub } + assert_raise(ArgumentError) { "".gsub("", "", "") } +end + +assert('String#gsub with backslash') do + s = 'abXcdXef' + assert_equal 'ab<\\>cd<\\>ef', s.gsub('X', '<\\\\>') + assert_equal 'abcdef', s.gsub('X', '<\\&>') + assert_equal 'abcdef', s.gsub('X', '<\\0>') + assert_equal 'abcdef', s.gsub('X', '<\\`>') + assert_equal 'abcdef', s.gsub('X', '<\\\'>') +end + +assert('String#gsub!', '15.2.10.5.19') do + a = 'abcabc' + a.gsub!('b', 'B') + + b = 'abcabc' + b.gsub!('b') { |w| w.capitalize } + + assert_equal 'aBcaBc', a + assert_equal 'aBcaBc', b +end + +assert('String#hash', '15.2.10.5.20') do + a = 'abc' + + assert_equal 'abc'.hash, a.hash +end + +assert('String#include?', '15.2.10.5.21') do + assert_true 'abc'.include?('a') + assert_false 'abc'.include?('d') +end + +assert('String#index', '15.2.10.5.22') do + assert_equal 0, 'abc'.index('a') + assert_nil 'abc'.index('d') + assert_equal 3, 'abcabc'.index('a', 1) + assert_equal 5, "hello".index("", 5) + assert_equal nil, "hello".index("", 6) +end + +assert('String#initialize', '15.2.10.5.23') do + a = '' + a.initialize('abc') + assert_equal 'abc', a + + a.initialize('abcdefghijklmnopqrstuvwxyz') + assert_equal 'abcdefghijklmnopqrstuvwxyz', a +end + +assert('String#initialize_copy', '15.2.10.5.24') do + a = '' + a.initialize_copy('abc') + + assert_equal 'abc', a +end + +assert('String#intern', '15.2.10.5.25') do + assert_equal :abc, 'abc'.intern +end + +assert('String#length', '15.2.10.5.26') do + assert_equal 3, 'abc'.length +end + +# 'String#match', '15.2.10.5.27' will be tested in mrbgems. + +assert('String#replace', '15.2.10.5.28') do + a = '' + a.replace('abc') + + assert_equal 'abc', a + assert_equal 'abc', 'cba'.replace(a) + + b = 'abc' * 10 + c = ('cba' * 10).dup + b.replace(c); + c.replace(b); + assert_equal c, b + + # shared string + s = "foo" * 100 + a = s[10, 90] # create shared string + assert_equal("", s.replace("")) # clear + assert_equal("", s) # s is cleared + assert_not_equal("", a) # a should not be affected +end + +assert('String#reverse', '15.2.10.5.29') do + a = 'abc' + a.reverse + + assert_equal 'abc', a + assert_equal 'cba', 'abc'.reverse +end + +assert('String#reverse(UTF-8)', '15.2.10.5.29') do + assert_equal "ち", "こんにちは世界"[3] + assert_equal nil, "こんにちは世界"[20] + assert_equal "世", "こんにちは世界"[-2] + assert_equal "世界", "こんにちは世界"[-2..-1] + assert_equal "んに", "こんにちは世界"[1,2] + assert_equal "世", "こんにちは世界"["世"] +end if UTF8STRING + +assert('String#reverse!', '15.2.10.5.30') do + a = 'abc' + a.reverse! + + assert_equal 'cba', a + assert_equal 'cba', 'abc'.reverse! +end + +assert('String#reverse!(UTF-8)', '15.2.10.5.30') do + a = 'こんにちは世界!' + a.reverse! + + assert_equal '!界世はちにんこ', a + assert_equal '!界世はちにんこ', 'こんにちは世界!'.reverse! +end if UTF8STRING + +assert('String#rindex', '15.2.10.5.31') do + assert_equal 0, 'abc'.rindex('a') + assert_nil 'abc'.rindex('d') + assert_equal 0, 'abcabc'.rindex('a', 1) + assert_equal 3, 'abcabc'.rindex('a', 4) +end + +assert('String#rindex(UTF-8)', '15.2.10.5.31') do + str = "こんにちは世界!\nこんにちは世界!" + assert_nil str.index('さ') + assert_equal 3, str.index('ち') + assert_equal 12, str.index('ち', 10) + assert_equal nil, str.index("さ") +end if UTF8STRING + +# 'String#scan', '15.2.10.5.32' will be tested in mrbgems. + +assert('String#size', '15.2.10.5.33') do + assert_equal 3, 'abc'.size +end + +assert('String#size(UTF-8)', '15.2.10.5.33') do + str = 'こんにちは世界!' + assert_equal 8, str.size + assert_not_equal str.bytesize, str.size + assert_equal 2, str[1, 2].size +end if UTF8STRING + +assert('String#slice', '15.2.10.5.34') do + # length of args is 1 + a = 'abc'.slice(0) + b = 'abc'.slice(-1) + c = 'abc'.slice(10) + d = 'abc'.slice(-10) + + # length of args is 2 + a1 = 'abc'.slice(0, -1) + b1 = 'abc'.slice(10, 0) + c1 = 'abc'.slice(-10, 0) + d1 = 'abc'.slice(0, 0) + e1 = 'abc'.slice(1, 2) + + # slice of shared string + e11 = e1.slice(0) + + # args is RegExp + # It will be tested in mrbgems. + + # args is String + a3 = 'abc'.slice('bc') + b3 = 'abc'.slice('XX') + + assert_equal 'a', a + assert_equal 'c', b + assert_nil c + assert_nil d + assert_nil a1 + assert_nil b1 + assert_nil c1 + assert_equal '', d1 + assert_equal 'bc', e1 + assert_equal 'b', e11 + assert_equal 'bc', a3 + assert_nil b3 +end + +# TODO Broken ATM +assert('String#split', '15.2.10.5.35') do + # without RegExp behavior is actually unspecified + assert_equal ['abc', 'abc', 'abc'], 'abc abc abc'.split + assert_equal ["a", "b", "c", "", "d"], 'a,b,c,,d'.split(',') + assert_equal ['abc', 'abc', 'abc'], 'abc abc abc'.split(nil) + assert_equal ['a', 'b', 'c'], 'abc'.split("") +end + +assert('String#split(UTF-8)', '15.2.10.5.35') do + got = "こんにちは世界!".split('') + assert_equal ['こ', 'ん', 'に', 'ち', 'は', '世', '界', '!'], got + got = "こんにちは世界!".split('に') + assert_equal ['こん', 'ちは世界!'], got +end if UTF8STRING + +assert('String#sub', '15.2.10.5.36') do + assert_equal 'aBcabc', 'abcabc'.sub('b', 'B') + assert_equal 'aBcabc', 'abcabc'.sub('b') { |w| w.capitalize } + assert_equal 'aa$', 'aa#'.sub('#', '$') + assert_equal '.abc', "abc".sub("", ".") + + str = "abc" + miss = str.sub("X", "Z") + assert_equal str, miss + assert_not_equal str.object_id, miss.object_id + + a = [] + assert_equal '.abc', "abc".sub("") { |i| a << i; "." } + assert_equal [""], a +end + +assert('String#sub with backslash') do + s = 'abXcdXef' + assert_equal 'ab<\\>cdXef', s.sub('X', '<\\\\>') + assert_equal 'abcdXef', s.sub('X', '<\\&>') + assert_equal 'abcdXef', s.sub('X', '<\\0>') + assert_equal 'abcdXef', s.sub('X', '<\\`>') + assert_equal 'abcdXef', s.sub('X', '<\\\'>') +end + +assert('String#sub!', '15.2.10.5.37') do + a = 'abcabc' + a.sub!('b', 'B') + + b = 'abcabc' + b.sub!('b') { |w| w.capitalize } + + assert_equal 'aBcabc', a + assert_equal 'aBcabc', b +end + +assert('String#to_f', '15.2.10.5.38') do + a = ''.to_f + b = '123456789'.to_f + c = '12345.6789'.to_f + d = '1e-2147483648'.to_f + e = '1e2147483648'.to_f + + assert_float(0.0, a) + assert_float(123456789.0, b) + assert_float(12345.6789, c) + assert_float(0, d) + assert_float(Float::INFINITY, e) +end + +assert('String#to_i', '15.2.10.5.39') do + a = ''.to_i + b = '32143'.to_i + c = 'a'.to_i(16) + d = '100'.to_i(2) + e = '1_000'.to_i + + assert_equal 0, a + assert_equal 32143, b + assert_equal 10, c + assert_equal 4, d + assert_equal 1_000, e +end + +assert('String#to_s', '15.2.10.5.40') do + assert_equal 'abc', 'abc'.to_s +end + +assert('String#to_sym', '15.2.10.5.41') do + assert_equal :abc, 'abc'.to_sym +end + +assert('String#upcase', '15.2.10.5.42') do + a = 'abc'.upcase + b = 'abc' + + b.upcase + + assert_equal 'ABC', a + assert_equal 'abc', b +end + +assert('String#upcase!', '15.2.10.5.43') do + a = 'abc' + + a.upcase! + + assert_equal 'ABC', a + assert_equal nil, 'ABC'.upcase! + + a = 'abcdefghijklmnopqrstuvwxyz' + b = a.dup + a.upcase! + b.upcase! + assert_equal 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', b +end + +assert('String#inspect', '15.2.10.5.46') do + # should not raise an exception - regress #1210 + assert_nothing_raised do + ("\1" * 100).inspect + end + + assert_equal "\"\\000\"", "\0".inspect +end + +# Not ISO specified + +assert('String interpolation (mrb_str_concat for shared strings)') do + a = "A" * 32 + assert_equal "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA:", "#{a}:" +end + +assert('Check the usage of a NUL character') do + "qqq\0ppp" +end + +assert('String#bytes') do + str1 = "hello" + bytes1 = [104, 101, 108, 108, 111] + + str2 = "\xFF" + bytes2 = [0xFF] + + assert_equal bytes1, str1.bytes + assert_equal bytes2, str2.bytes +end + +assert('String#each_byte') do + str1 = "hello" + bytes1 = [104, 101, 108, 108, 111] + bytes2 = [] + + str1.each_byte {|b| bytes2 << b } + + assert_equal bytes1, bytes2 +end + +assert('String#freeze') do + str = "hello" + str.freeze + + assert_raise(RuntimeError) { str.upcase! } +end -- cgit v1.2.3