archive/ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2025-08-28 07:26:00 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 11

Add String#byteindex, String#byterindex, and MatchData#byteoffset (#5518)

Browse source 
* Add String#byteindex, String#byterindex, and MatchData#byteoffset [Feature #13110]

Co-authored-by: NARUSE, Yui <naruse@airemix.jp>
This commit is contained in:
Shugo Maeda 2022-02-19 19:10:00 +09:00 • committed by GitHub
parent db6b23c76c
commit c8817d6a3e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
Notes: git 2022-02-19 19:10:20 +09:00 
Merged-By: shugo <shugo@ruby-lang.org>
5 changed files with 451 additions and 9 deletions
Download patch file Download diff file Expand all files Collapse all files

140
test/ruby/test_string.rb
View file

@ -1340,6 +1340,15 @@ CODE
assert_nil($~)
assert_equal(2, S("abcdbce").index(/b\Kc/))
assert_equal(0, S("こんにちは").index(?こ))
assert_equal(1, S("こんにちは").index(S("んにち")))
assert_equal(2, S("こんにちは").index(/にち./))
assert_equal(0, S("にんにちは").index(?に, 0))
assert_equal(2, S("にんにちは").index(?に, 1))
assert_equal(2, S("にんにちは").index(?に, 2))
assert_nil(S("にんにちは").index(?に, 3))
end
def test_insert
@ -1502,6 +1511,11 @@ CODE
assert_nil(S("hello").rindex(S("z")))
assert_nil(S("hello").rindex(/z./))
assert_equal(5, S("hello").rindex(S("")))
assert_equal(5, S("hello").rindex(S(""), 5))
assert_equal(4, S("hello").rindex(S(""), 4))
assert_equal(0, S("hello").rindex(S(""), 0))
o = Object.new
def o.to_str; "bar"; end
assert_equal(6, S("foobarbarbaz").rindex(o))
@ -1514,6 +1528,24 @@ CODE
assert_equal([3, 3], $~.offset(0))
assert_equal(5, S("abcdbce").rindex(/b\Kc/))
assert_equal(2, S("こんにちは").rindex(?に))
assert_equal(6, S("にちは、こんにちは").rindex(S("にちは")))
assert_equal(6, S("にちは、こんにちは").rindex(/にち./))
assert_equal(6, S("にちは、こんにちは").rindex(S("にちは"), 7))
assert_equal(6, S("にちは、こんにちは").rindex(S("にちは"), -2))
assert_equal(6, S("にちは、こんにちは").rindex(S("にちは"), 6))
assert_equal(6, S("にちは、こんにちは").rindex(S("にちは"), -3))
assert_equal(0, S("にちは、こんにちは").rindex(S("にちは"), 5))
assert_equal(0, S("にちは、こんにちは").rindex(S("にちは"), -4))
assert_equal(0, S("にちは、こんにちは").rindex(S("にちは"), 1))
assert_equal(0, S("にちは、こんにちは").rindex(S("にちは"), 0))
assert_equal(0, S("こんにちは").rindex(S("こんにちは")))
assert_nil(S("こんにち").rindex(S("こんにちは")))
assert_nil(S("こ").rindex(S("こんにちは")))
assert_nil(S("").rindex(S("こんにちは")))
end
def test_rjust
@ -3254,6 +3286,114 @@ CODE
assert_not_predicate(data, :valid_encoding?)
assert_predicate(data[100..-1], :valid_encoding?)
end
def test_byteindex
assert_equal(0, S("hello").byteindex(?h))
assert_equal(1, S("hello").byteindex(S("ell")))
assert_equal(2, S("hello").byteindex(/ll./))
assert_equal(3, S("hello").byteindex(?l, 3))
assert_equal(3, S("hello").byteindex(S("l"), 3))
assert_equal(3, S("hello").byteindex(/l./, 3))
assert_nil(S("hello").byteindex(?z, 3))
assert_nil(S("hello").byteindex(S("z"), 3))
assert_nil(S("hello").byteindex(/z./, 3))
assert_nil(S("hello").byteindex(?z))
assert_nil(S("hello").byteindex(S("z")))
assert_nil(S("hello").byteindex(/z./))
assert_equal(0, S("").byteindex(S("")))
assert_equal(0, S("").byteindex(//))
assert_nil(S("").byteindex(S("hello")))
assert_nil(S("").byteindex(/hello/))
assert_equal(0, S("hello").byteindex(S("")))
assert_equal(0, S("hello").byteindex(//))
s = S("long") * 1000 << "x"
assert_nil(s.byteindex(S("y")))
assert_equal(4 * 1000, s.byteindex(S("x")))
s << "yx"
assert_equal(4 * 1000, s.byteindex(S("x")))
assert_equal(4 * 1000, s.byteindex(S("xyx")))
o = Object.new
def o.to_str; "bar"; end
assert_equal(3, S("foobarbarbaz").byteindex(o))
assert_raise(TypeError) { S("foo").byteindex(Object.new) }
assert_nil(S("foo").byteindex(//, -100))
assert_nil($~)
assert_equal(2, S("abcdbce").byteindex(/b\Kc/))
assert_equal(0, S("こんにちは").byteindex(?こ))
assert_equal(3, S("こんにちは").byteindex(S("んにち")))
assert_equal(6, S("こんにちは").byteindex(/にち./))
assert_equal(0, S("にんにちは").byteindex(?に, 0))
assert_raise(IndexError) { S("にんにちは").byteindex(?に, 1) }
assert_raise(IndexError) { S("にんにちは").byteindex(?に, 5) }
assert_equal(6, S("にんにちは").byteindex(?に, 6))
assert_equal(6, S("にんにちは").byteindex(S("に"), 6))
assert_equal(6, S("にんにちは").byteindex(/に./, 6))
assert_raise(IndexError) { S("にんにちは").byteindex(?に, 7) }
end
def test_byterindex
assert_equal(3, S("hello").byterindex(?l))
assert_equal(6, S("ell, hello").byterindex(S("ell")))
assert_equal(7, S("ell, hello").byterindex(/ll./))
assert_equal(3, S("hello,lo").byterindex(?l, 3))
assert_equal(3, S("hello,lo").byterindex(S("l"), 3))
assert_equal(3, S("hello,lo").byterindex(/l./, 3))
assert_nil(S("hello").byterindex(?z, 3))
assert_nil(S("hello").byterindex(S("z"), 3))
assert_nil(S("hello").byterindex(/z./, 3))
assert_nil(S("hello").byterindex(?z))
assert_nil(S("hello").byterindex(S("z")))
assert_nil(S("hello").byterindex(/z./))
assert_equal(5, S("hello").byterindex(S("")))
assert_equal(5, S("hello").byterindex(S(""), 5))
assert_equal(4, S("hello").byterindex(S(""), 4))
assert_equal(0, S("hello").byterindex(S(""), 0))
o = Object.new
def o.to_str; "bar"; end
assert_equal(6, S("foobarbarbaz").byterindex(o))
assert_raise(TypeError) { S("foo").byterindex(Object.new) }
assert_nil(S("foo").byterindex(//, -100))
assert_nil($~)
assert_equal(3, S("foo").byterindex(//))
assert_equal([3, 3], $~.offset(0))
assert_equal(5, S("abcdbce").byterindex(/b\Kc/))
assert_equal(6, S("こんにちは").byterindex(?に))
assert_equal(18, S("にちは、こんにちは").byterindex(S("にちは")))
assert_equal(18, S("にちは、こんにちは").byterindex(/にち./))
assert_raise(IndexError) { S("にちは、こんにちは").byterindex(S("にちは"), 19) }
assert_raise(IndexError) { S("にちは、こんにちは").byterindex(S("にちは"), -2) }
assert_equal(18, S("にちは、こんにちは").byterindex(S("にちは"), 18))
assert_equal(18, S("にちは、こんにちは").byterindex(S("にちは"), -3))
assert_raise(IndexError) { S("にちは、こんにちは").byterindex(S("にちは"), 17) }
assert_raise(IndexError) { S("にちは、こんにちは").byterindex(S("にちは"), -4) }
assert_raise(IndexError) { S("にちは、こんにちは").byterindex(S("にちは"), 1) }
assert_equal(0, S("にちは、こんにちは").byterindex(S("にちは"), 0))
assert_equal(0, S("こんにちは").byterindex(S("こんにちは")))
assert_nil(S("こんにち").byterindex(S("こんにちは")))
assert_nil(S("こ").byterindex(S("こんにちは")))
assert_nil(S("").byterindex(S("こんにちは")))
end
end
class TestString2 < TestString