PageRenderTime 48ms CodeModel.GetById 7ms RepoModel.GetById 0ms app.codeStats 0ms

/test/ruby/test_regexp.rb

http://github.com/ruby/ruby
Ruby | 1309 lines | 1258 code | 48 blank | 3 comment | 0 complexity | 5dfbadab43ed63bd0d3b5c9f7de87ac6 MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause, AGPL-3.0 
    

  1. # coding: US-ASCII
    2. 

  2. # frozen_string_literal: false
    3. 

  3. require 'test/unit'
    4. 

  4. 

  5. class TestRegexp < Test::Unit::TestCase
    6. 

  6.   def setup
    7. 

  7.     @verbose = $VERBOSE
    8. 

  8.     $VERBOSE = nil
    9. 

  9.   end
    10. 

  10. 

  11.   def teardown
    12. 

  12.     $VERBOSE = @verbose
    13. 

  13.   end
    14. 

  14. 

  15.   def test_has_NOENCODING
    16. 

  16.     assert Regexp::NOENCODING
    17. 

  17.     re = //n
    18. 

  18.     assert_equal Regexp::NOENCODING, re.options
    19. 

  19.   end
    20. 

  20. 

  21.   def test_ruby_dev_999
    22. 

  22.     assert_match(/(?<=a).*b/, "aab")
    23. 

  23.     assert_match(/(?<=\u3042).*b/, "\u3042ab")
    24. 

  24.   end
    25. 

  25. 

  26.   def test_ruby_core_27247
    27. 

  27.     assert_match(/(a){2}z/, "aaz")
    28. 

  28.   end
    29. 

  29. 

  30.   def test_ruby_dev_24643
    31. 

  31.     assert_nothing_raised("[ruby-dev:24643]") {
    32. 

  32.       /(?:(?:[a]*[a])?b)*a*$/ =~ "aabaaca"
    33. 

  33.     }
    34. 

  34.   end
    35. 

  35. 

  36.   def test_ruby_talk_116455
    37. 

  37.     assert_match(/^(\w{2,}).* ([A-Za-z\xa2\xc0-\xff]{2,}?)$/n, "Hallo Welt")
    38. 

  38.   end
    39. 

  39. 

  40.   def test_ruby_dev_24887
    41. 

  41.     assert_equal("a".gsub(/a\Z/, ""), "")
    42. 

  42.   end
    43. 

  43. 

  44.   def test_yoshidam_net_20041111_1
    45. 

  45.     s = "[\xC2\xA0-\xC3\xBE]"
    46. 

  46.     assert_match(Regexp.new(s, nil, "u"), "\xC3\xBE")
    47. 

  47.   end
    48. 

  48. 

  49.   def test_yoshidam_net_20041111_2
    50. 

  50.     assert_raise(RegexpError) do
    51. 

  51.       s = "[\xFF-\xFF]".force_encoding("utf-8")
    52. 

  52.       Regexp.new(s, nil, "u")
    53. 

  53.     end
    54. 

  54.   end
    55. 

  55. 

  56.   def test_ruby_dev_31309
    57. 

  57.     assert_equal('Ruby', 'Ruby'.sub(/[^a-z]/i, '-'))
    58. 

  58.   end
    59. 

  59. 

  60.   def test_assert_normal_exit
    61. 

  61.     # moved from knownbug.  It caused core.
    62. 

  62.     Regexp.union("a", "a")
    63. 

  63.   end
    64. 

  64. 

  65.   def test_to_s
    66. 

  66.     assert_equal '(?-mix:\x00)', Regexp.new("\0").to_s
    67. 

  67. 

  68.     str = "abcd\u3042"
    69. 

  69.     [:UTF_16BE, :UTF_16LE, :UTF_32BE, :UTF_32LE].each do |es|
    70. 

  70.       enc = Encoding.const_get(es)
    71. 

  71.       rs = Regexp.new(str.encode(enc)).to_s
    72. 

  72.       assert_equal("(?-mix:abcd\u3042)".encode(enc), rs)
    73. 

  73.       assert_equal(enc, rs.encoding)
    74. 

  74.     end
    75. 

  75.   end
    76. 

  76. 

  77.   def test_to_s_extended_subexp
    78. 

  78.     re = /#\g#{"\n"}/x
    79. 

  79.     re = /#{re}/
    80. 

  80.     assert_warn('', '[ruby-core:82328] [Bug #13798]') {re.to_s}
    81. 

  81.   end
    82. 

  82. 

  83.   def test_union
    84. 

  84.     assert_equal :ok, begin
    85. 

  85.       Regexp.union(
    86. 

  86.         "a",
    87. 

  87.         Regexp.new("\xc2\xa1".force_encoding("euc-jp")),
    88. 

  88.         Regexp.new("\xc2\xa1".force_encoding("utf-8")))
    89. 

  89.       :ng
    90. 

  90.     rescue ArgumentError
    91. 

  91.       :ok
    92. 

  92.     end
    93. 

  93.     re = Regexp.union(/\//, "")
    94. 

  94.     re2 = eval(re.inspect)
    95. 

  95.     assert_equal(re.to_s, re2.to_s)
    96. 

  96.     assert_equal(re.source, re2.source)
    97. 

  97.     assert_equal(re, re2)
    98. 

  98.   end
    99. 

  99. 

  100.   def test_word_boundary
    101. 

  101.     assert_match(/\u3042\b /, "\u3042 ")
    102. 

  102.     assert_not_match(/\u3042\ba/, "\u3042a")
    103. 

  103.   end
    104. 

  104. 

  105.   def test_named_capture
    106. 

  106.     m = /&(?<foo>.*?);/.match("aaa &amp; yyy")
    107. 

  107.     assert_equal("amp", m["foo"])
    108. 

  108.     assert_equal("amp", m[:foo])
    109. 

  109.     assert_equal(5, m.begin(:foo))
    110. 

  110.     assert_equal(8, m.end(:foo))
    111. 

  111.     assert_equal([5,8], m.offset(:foo))
    112. 

  112. 

  113.     assert_equal("aaa [amp] yyy",
    114. 

  114.       "aaa &amp; yyy".sub(/&(?<foo>.*?);/, '[\k<foo>]'))
    115. 

  115. 

  116.     assert_equal('#<MatchData "&amp; y" foo:"amp">',
    117. 

  117.       /&(?<foo>.*?); (y)/.match("aaa &amp; yyy").inspect)
    118. 

  118.     assert_equal('#<MatchData "&amp; y" 1:"amp" 2:"y">',
    119. 

  119.       /&(.*?); (y)/.match("aaa &amp; yyy").inspect)
    120. 

  120.     assert_equal('#<MatchData "&amp; y" foo:"amp" bar:"y">',
    121. 

  121.       /&(?<foo>.*?); (?<bar>y)/.match("aaa &amp; yyy").inspect)
    122. 

  122.     assert_equal('#<MatchData "&amp; y" foo:"amp" foo:"y">',
    123. 

  123.       /&(?<foo>.*?); (?<foo>y)/.match("aaa &amp; yyy").inspect)
    124. 

  124. 

  125.     /(?<_id>[A-Za-z_]+)/ =~ "!abc"
    126. 

  126.     assert_not_nil(Regexp.last_match)
    127. 

  127.     assert_equal("abc", Regexp.last_match(1))
    128. 

  128.     assert_equal("abc", Regexp.last_match(:_id))
    129. 

  129. 

  130.     /a/ =~ "b" # doesn't match.
    131. 

  131.     assert_equal(nil, Regexp.last_match)
    132. 

  132.     assert_equal(nil, Regexp.last_match(1))
    133. 

  133.     assert_equal(nil, Regexp.last_match(:foo))
    134. 

  134. 

  135.     bug11825_name = "\u{5b9d 77f3}"
    136. 

  136.     bug11825_str = "\u{30eb 30d3 30fc}"
    137. 

  137.     bug11825_re = /(?<#{bug11825_name}>)#{bug11825_str}/
    138. 

  138. 

  139.     assert_equal(["foo", "bar"], /(?<foo>.)(?<bar>.)/.names)
    140. 

  140.     assert_equal(["foo"], /(?<foo>.)(?<foo>.)/.names)
    141. 

  141.     assert_equal([], /(.)(.)/.names)
    142. 

  142.     assert_equal([bug11825_name], bug11825_re.names)
    143. 

  143. 

  144.     assert_equal(["foo", "bar"], /(?<foo>.)(?<bar>.)/.match("ab").names)
    145. 

  145.     assert_equal(["foo"], /(?<foo>.)(?<foo>.)/.match("ab").names)
    146. 

  146.     assert_equal([], /(.)(.)/.match("ab").names)
    147. 

  147.     assert_equal([bug11825_name], bug11825_re.match(bug11825_str).names)
    148. 

  148. 

  149.     assert_equal({"foo"=>[1], "bar"=>[2]},
    150. 

  150.                  /(?<foo>.)(?<bar>.)/.named_captures)
    151. 

  151.     assert_equal({"foo"=>[1, 2]},
    152. 

  152.                  /(?<foo>.)(?<foo>.)/.named_captures)
    153. 

  153.     assert_equal({}, /(.)(.)/.named_captures)
    154. 

  154. 

  155.     assert_equal("a[b]c", "abc".sub(/(?<x>[bc])/, "[\\k<x>]"))
    156. 

  156. 

  157.     assert_equal("o", "foo"[/(?<bar>o)/, "bar"])
    158. 

  158.     assert_equal("o", "foo"[/(?<@bar>o)/, "@bar"])
    159. 

  159.     assert_equal("o", "foo"[/(?<@bar>.)\g<@bar>\k<@bar>/, "@bar"])
    160. 

  160. 

  161.     s = "foo"
    162. 

  162.     s[/(?<bar>o)/, "bar"] = "baz"
    163. 

  163.     assert_equal("fbazo", s)
    164. 

  164. 

  165.     /.*/ =~ "abc"
    166. 

  166.     "a".sub("a", "")
    167. 

  167.     assert_raise(IndexError) {Regexp.last_match(:_id)}
    168. 

  168.   end
    169. 

  169. 

  170.   def test_named_capture_with_nul
    171. 

  171.     bug9902 = '[ruby-dev:48275] [Bug #9902]'
    172. 

  172. 

  173.     m = /(?<a>.*)/.match("foo")
    174. 

  174.     assert_raise(IndexError, bug9902) {m["a\0foo"]}
    175. 

  175.     assert_raise(IndexError, bug9902) {m["a\0foo".to_sym]}
    176. 

  176. 

  177.     m = Regexp.new("(?<foo\0bar>.*)").match("xxx")
    178. 

  178.     assert_raise(IndexError, bug9902) {m["foo"]}
    179. 

  179.     assert_raise(IndexError, bug9902) {m["foo".to_sym]}
    180. 

  180.     assert_nothing_raised(IndexError, bug9902) {
    181. 

  181.       assert_equal("xxx", m["foo\0bar"], bug9902)
    182. 

  182.       assert_equal("xxx", m["foo\0bar".to_sym], bug9902)
    183. 

  183.     }
    184. 

  184.   end
    185. 

  185. 

  186.   def test_named_capture_nonascii
    187. 

  187.     bug9903 = '[ruby-dev:48278] [Bug #9903]'
    188. 

  188. 

  189.     key = "\xb1\xb2".force_encoding(Encoding::EUC_JP)
    190. 

  190.     m = /(?<#{key}>.*)/.match("xxx")
    191. 

  191.     assert_equal("xxx", m[key])
    192. 

  192.     assert_raise(IndexError, bug9903) {m[key.dup.force_encoding(Encoding::Shift_JIS)]}
    193. 

  193.   end
    194. 

  194. 

  195.   def test_match_data_named_captures
    196. 

  196.     assert_equal({'a' => '1', 'b' => '2', 'c' => nil}, /^(?<a>.)(?<b>.)(?<c>.)?/.match('12').named_captures)
    197. 

  197.     assert_equal({'a' => '1', 'b' => '2', 'c' => '3'}, /^(?<a>.)(?<b>.)(?<c>.)?/.match('123').named_captures)
    198. 

  198.     assert_equal({'a' => '1', 'b' => '2', 'c' => ''}, /^(?<a>.)(?<b>.)(?<c>.?)/.match('12').named_captures)
    199. 

  199. 

  200.     assert_equal({'a' => 'x'}, /(?<a>x)|(?<a>y)/.match('x').named_captures)
    201. 

  201.     assert_equal({'a' => 'y'}, /(?<a>x)|(?<a>y)/.match('y').named_captures)
    202. 

  202. 

  203.     assert_equal({'a' => '1', 'b' => '2'}, /^(.)(?<a>.)(?<b>.)/.match('012').named_captures)
    204. 

  204.     assert_equal({'a' => '2'}, /^(?<a>.)(?<a>.)/.match('12').named_captures)
    205. 

  205. 

  206.     assert_equal({}, /^(.)/.match('123').named_captures)
    207. 

  207.   end
    208. 

  208. 

  209.   def test_assign_named_capture
    210. 

  210.     assert_equal("a", eval('/(?<foo>.)/ =~ "a"; foo'))
    211. 

  211.     assert_equal(nil, eval('/(?<@foo>.)/ =~ "a"; defined?(@foo)'))
    212. 

  212.     assert_equal("a", eval('foo = 1; /(?<foo>.)/ =~ "a"; foo'))
    213. 

  213.     assert_equal("a", eval('1.times {|foo| /(?<foo>.)/ =~ "a"; break foo }'))
    214. 

  214.     assert_nothing_raised { eval('/(?<Foo>.)/ =~ "a"') }
    215. 

  215.     assert_nil(eval('/(?<Foo>.)/ =~ "a"; defined? Foo'))
    216. 

  216.   end
    217. 

  217. 

  218.   def test_assign_named_capture_to_reserved_word
    219. 

  219.     /(?<nil>.)/ =~ "a"
    220. 

  220.     assert_not_include(local_variables, :nil, "[ruby-dev:32675]")
    221. 

  221.   end
    222. 

  222. 

  223.   def test_assign_named_capture_to_const
    224. 

  224.     %W[C \u{1d402}].each do |name|
    225. 

  225.       assert_equal(:ok, Class.new.class_eval("#{name} = :ok; /(?<#{name}>.*)/ =~ 'ng'; #{name}"))
    226. 

  226.     end
    227. 

  227.   end
    228. 

  228. 

  229.   def test_assign_named_capture_trace
    230. 

  230.     bug = '[ruby-core:79940] [Bug #13287]'
    231. 

  231.     assert_normal_exit("#{<<-"begin;"}\n#{<<-"end;"}", bug)
    232. 

  232.     begin;
    233. 

  233.       / (?<foo>.*)/ =~ "bar" &&
    234. 

  234.         true
    235. 

  235.     end;
    236. 

  236.   end
    237. 

  237. 

  238.   def test_match_regexp
    239. 

  239.     r = /./
    240. 

  240.     m = r.match("a")
    241. 

  241.     assert_equal(r, m.regexp)
    242. 

  242.     re = /foo/
    243. 

  243.     assert_equal(re, re.match("foo").regexp)
    244. 

  244.   end
    245. 

  245. 

  246.   def test_source
    247. 

  247.     bug5484 = '[ruby-core:40364]'
    248. 

  248.     assert_equal('', //.source)
    249. 

  249.     assert_equal('\:', /\:/.source, bug5484)
    250. 

  250.     assert_equal(':', %r:\::.source, bug5484)
    251. 

  251.   end
    252. 

  252. 

  253.   def test_source_escaped
    254. 

  254.     expected, result = "$*+.?^|".each_char.map {|c|
    255. 

  255.       [
    256. 

  256.         ["\\#{c}", "\\#{c}", 1],
    257. 

  257.         begin
    258. 

  258.           re = eval("%r#{c}\\#{c}#{c}", nil, __FILE__, __LINE__)
    259. 

  259.           t = eval("/\\#{c}/", nil, __FILE__, __LINE__).source
    260. 

  260.         rescue SyntaxError => e
    261. 

  261.           [e, t, nil]
    262. 

  262.         else
    263. 

  263.           [re.source, t, re =~ "a#{c}a"]
    264. 

  264.         end
    265. 

  265.       ]
    266. 

  266.     }.transpose
    267. 

  267.     assert_equal(expected, result)
    268. 

  268.   end
    269. 

  269. 

  270.   def test_source_escaped_paren
    271. 

  271.     bug7610 = '[ruby-core:51088] [Bug #7610]'
    272. 

  272.     bug8133 = '[ruby-core:53578] [Bug #8133]'
    273. 

  273.     [
    274. 

  274.      ["(", ")", bug7610], ["[", "]", bug8133],
    275. 

  275.      ["{", "}", bug8133], ["<", ">", bug8133],
    276. 

  276.     ].each do |lparen, rparen, bug|
    277. 

  277.       s = "\\#{lparen}a\\#{rparen}"
    278. 

  278.       assert_equal(/#{s}/, eval("%r#{lparen}#{s}#{rparen}"), bug)
    279. 

  279.     end
    280. 

  280.   end
    281. 

  281. 

  282.   def test_source_unescaped
    283. 

  283.     expected, result = "!\"#%&',-/:;=@_`~".each_char.map {|c|
    284. 

  284.       [
    285. 

  285.         ["#{c}", "\\#{c}", 1],
    286. 

  286.         begin
    287. 

  287.           re = eval("%r#{c}\\#{c}#{c}", nil, __FILE__, __LINE__)
    288. 

  288.           t = eval("%r{\\#{c}}", nil, __FILE__, __LINE__).source
    289. 

  289.         rescue SyntaxError => e
    290. 

  290.           [e, t, nil]
    291. 

  291.         else
    292. 

  292.           [re.source, t, re =~ "a#{c}a"]
    293. 

  293.         end
    294. 

  294.       ]
    295. 

  295.     }.transpose
    296. 

  296.     assert_equal(expected, result)
    297. 

  297.   end
    298. 

  298. 

  299.   def test_inspect
    300. 

  300.     assert_equal('//', //.inspect)
    301. 

  301.     assert_equal('//i', //i.inspect)
    302. 

  302.     assert_equal('/\//i', /\//i.inspect)
    303. 

  303.     assert_equal('/\//i', %r"#{'/'}"i.inspect)
    304. 

  304.     assert_equal('/\/x/i', /\/x/i.inspect)
    305. 

  305.     assert_equal('/\x00/i', /#{"\0"}/i.inspect)
    306. 

  306.     assert_equal("/\n/i", /#{"\n"}/i.inspect)
    307. 

  307.     s = [0xf1, 0xf2, 0xf3].pack("C*")
    308. 

  308.     assert_equal('/\/\xF1\xF2\xF3/i', /\/#{s}/i.inspect)
    309. 

  309.   end
    310. 

  310. 

  311.   def test_char_to_option
    312. 

  312.     assert_equal("BAR", "FOOBARBAZ"[/b../i])
    313. 

  313.     assert_equal("bar", "foobarbaz"[/  b  .  .  /x])
    314. 

  314.     assert_equal("bar\n", "foo\nbar\nbaz"[/b.../m])
    315. 

  315.     assert_raise(SyntaxError) { eval('//z') }
    316. 

  316.   end
    317. 

  317. 

  318.   def test_char_to_option_kcode
    319. 

  319.     assert_equal("bar", "foobarbaz"[/b../s])
    320. 

  320.     assert_equal("bar", "foobarbaz"[/b../e])
    321. 

  321.     assert_equal("bar", "foobarbaz"[/b../u])
    322. 

  322.   end
    323. 

  323. 

  324.   def test_to_s2
    325. 

  325.     assert_equal('(?-mix:foo)', /(?:foo)/.to_s)
    326. 

  326.     assert_equal('(?m-ix:foo)', /(?:foo)/m.to_s)
    327. 

  327.     assert_equal('(?mi-x:foo)', /(?:foo)/mi.to_s)
    328. 

  328.     assert_equal('(?mix:foo)', /(?:foo)/mix.to_s)
    329. 

  329.     assert_equal('(?m-ix:foo)', /(?m-ix:foo)/.to_s)
    330. 

  330.     assert_equal('(?mi-x:foo)', /(?mi-x:foo)/.to_s)
    331. 

  331.     assert_equal('(?mix:foo)', /(?mix:foo)/.to_s)
    332. 

  332.     assert_equal('(?mix:)', /(?mix)/.to_s)
    333. 

  333.     assert_equal('(?-mix:(?mix:foo) )', /(?mix:foo) /.to_s)
    334. 

  334.   end
    335. 

  335. 

  336.   def test_casefold_p
    337. 

  337.     assert_equal(false, /a/.casefold?)
    338. 

  338.     assert_equal(true, /a/i.casefold?)
    339. 

  339.     assert_equal(false, /(?i:a)/.casefold?)
    340. 

  340.   end
    341. 

  341. 

  342.   def test_options
    343. 

  343.     assert_equal(Regexp::IGNORECASE, /a/i.options)
    344. 

  344.     assert_equal(Regexp::EXTENDED, /a/x.options)
    345. 

  345.     assert_equal(Regexp::MULTILINE, /a/m.options)
    346. 

  346.   end
    347. 

  347. 

  348.   def test_match_init_copy
    349. 

  349.     m = /foo/.match("foo")
    350. 

  350.     assert_equal(/foo/, m.dup.regexp)
    351. 

  351.     assert_raise(TypeError) do
    352. 

  352.       m.instance_eval { initialize_copy(nil) }
    353. 

  353.     end
    354. 

  354.     assert_equal([0, 3], m.offset(0))
    355. 

  355.     assert_equal(/foo/, m.dup.regexp)
    356. 

  356.   end
    357. 

  357. 

  358.   def test_match_size
    359. 

  359.     m = /(.)(.)(\d+)(\d)/.match("THX1138.")
    360. 

  360.     assert_equal(5, m.size)
    361. 

  361.   end
    362. 

  362. 

  363.   def test_match_offset_begin_end
    364. 

  364.     m = /(?<x>b..)/.match("foobarbaz")
    365. 

  365.     assert_equal([3, 6], m.offset("x"))
    366. 

  366.     assert_equal(3, m.begin("x"))
    367. 

  367.     assert_equal(6, m.end("x"))
    368. 

  368.     assert_raise(IndexError) { m.offset("y") }
    369. 

  369.     assert_raise(IndexError) { m.offset(2) }
    370. 

  370.     assert_raise(IndexError) { m.begin(2) }
    371. 

  371.     assert_raise(IndexError) { m.end(2) }
    372. 

  372. 

  373.     m = /(?<x>q..)?/.match("foobarbaz")
    374. 

  374.     assert_equal([nil, nil], m.offset("x"))
    375. 

  375.     assert_equal(nil, m.begin("x"))
    376. 

  376.     assert_equal(nil, m.end("x"))
    377. 

  377. 

  378.     m = /\A\u3042(.)(.)?(.)\z/.match("\u3042\u3043\u3044")
    379. 

  379.     assert_equal([1, 2], m.offset(1))
    380. 

  380.     assert_equal([nil, nil], m.offset(2))
    381. 

  381.     assert_equal([2, 3], m.offset(3))
    382. 

  382.   end
    383. 

  383. 

  384.   def test_match_to_s
    385. 

  385.     m = /(?<x>b..)/.match("foobarbaz")
    386. 

  386.     assert_equal("bar", m.to_s)
    387. 

  387.   end
    388. 

  388. 

  389.   def test_match_pre_post
    390. 

  390.     m = /(?<x>b..)/.match("foobarbaz")
    391. 

  391.     assert_equal("foo", m.pre_match)
    392. 

  392.     assert_equal("baz", m.post_match)
    393. 

  393.   end
    394. 

  394. 

  395.   def test_match_array
    396. 

  396.     m = /(...)(...)(...)(...)?/.match("foobarbaz")
    397. 

  397.     assert_equal(["foobarbaz", "foo", "bar", "baz", nil], m.to_a)
    398. 

  398.   end
    399. 

  399. 

  400.   def test_match_captures
    401. 

  401.     m = /(...)(...)(...)(...)?/.match("foobarbaz")
    402. 

  402.     assert_equal(["foo", "bar", "baz", nil], m.captures)
    403. 

  403.   end
    404. 

  404. 

  405.   def test_match_aref
    406. 

  406.     m = /(...)(...)(...)(...)?/.match("foobarbaz")
    407. 

  407.     assert_equal("foobarbaz", m[0])
    408. 

  408.     assert_equal("foo", m[1])
    409. 

  409.     assert_equal("foo", m[-4])
    410. 

  410.     assert_nil(m[-1])
    411. 

  411.     assert_nil(m[-11])
    412. 

  412.     assert_nil(m[-11, 1])
    413. 

  413.     assert_nil(m[-11..1])
    414. 

  414.     assert_nil(m[5])
    415. 

  415.     assert_nil(m[9])
    416. 

  416.     assert_equal(["foo", "bar", "baz"], m[1..3])
    417. 

  417.     assert_equal(["foo", "bar", "baz"], m[1, 3])
    418. 

  418.     assert_equal([], m[3..1])
    419. 

  419.     assert_equal([], m[3, 0])
    420. 

  420.     assert_equal(nil, m[3, -1])
    421. 

  421.     assert_equal(nil, m[9, 1])
    422. 

  422.     assert_equal(["baz"], m[3, 1])
    423. 

  423.     assert_equal(["baz", nil], m[3, 5])
    424. 

  424.     assert_nil(m[5])
    425. 

  425.     assert_raise(IndexError) { m[:foo] }
    426. 

  426.     assert_raise(TypeError) { m[nil] }
    427. 

  427.   end
    428. 

  428. 

  429.   def test_match_values_at
    430. 

  430.     idx = Object.new
    431. 

  431.     def idx.to_int; 2; end
    432. 

  432.     m = /(...)(...)(...)(...)?/.match("foobarbaz")
    433. 

  433.     assert_equal(["foo", "bar", "baz"], m.values_at(1, 2, 3))
    434. 

  434.     assert_equal(["foo", "bar", "baz"], m.values_at(1..3))
    435. 

  435.     assert_equal(["foo", "bar", "baz", nil, nil], m.values_at(1..5))
    436. 

  436.     assert_equal([], m.values_at(3..1))
    437. 

  437.     assert_equal([nil, nil, nil, nil, nil], m.values_at(5..9))
    438. 

  438.     assert_equal(["bar"], m.values_at(idx))
    439. 

  439.     assert_raise(RangeError){ m.values_at(-11..1) }
    440. 

  440.     assert_raise(TypeError){ m.values_at(nil) }
    441. 

  441. 

  442.     m = /(?<a>\d+) *(?<op>[+\-*\/]) *(?<b>\d+)/.match("1 + 2")
    443. 

  443.     assert_equal(["1", "2", "+"], m.values_at(:a, 'b', :op))
    444. 

  444.     assert_equal(["+"], m.values_at(idx))
    445. 

  445.     assert_raise(TypeError){ m.values_at(nil) }
    446. 

  446.     assert_raise(IndexError){ m.values_at(:foo) }
    447. 

  447.   end
    448. 

  448. 

  449.   def test_match_string
    450. 

  450.     m = /(?<x>b..)/.match("foobarbaz")
    451. 

  451.     assert_equal("foobarbaz", m.string)
    452. 

  452.   end
    453. 

  453. 

  454.   def test_match_inspect
    455. 

  455.     m = /(...)(...)(...)(...)?/.match("foobarbaz")
    456. 

  456.     assert_equal('#<MatchData "foobarbaz" 1:"foo" 2:"bar" 3:"baz" 4:nil>', m.inspect)
    457. 

  457.   end
    458. 

  458. 

  459.   def test_initialize
    460. 

  460.     assert_raise(ArgumentError) { Regexp.new }
    461. 

  461.     assert_equal(/foo/, Regexp.new(/foo/, Regexp::IGNORECASE))
    462. 

  462. 

  463.     assert_equal(Encoding.find("US-ASCII"), Regexp.new("b..", nil, "n").encoding)
    464. 

  464.     assert_equal("bar", "foobarbaz"[Regexp.new("b..", nil, "n")])
    465. 

  465.     assert_equal(//n, Regexp.new("", nil, "n"))
    466. 

  466. 

  467.     arg_encoding_none = 32 # ARG_ENCODING_NONE is implementation defined value
    468. 

  468.     assert_equal(arg_encoding_none, Regexp.new("", nil, "n").options)
    469. 

  469.     assert_equal(arg_encoding_none, Regexp.new("", nil, "N").options)
    470. 

  470. 

  471.     assert_raise(RegexpError) { Regexp.new(")(") }
    472. 

  472.     assert_raise(RegexpError) { Regexp.new('[\\40000000000') }
    473. 

  473.     assert_raise(RegexpError) { Regexp.new('[\\600000000000.') }
    474. 

  474.     assert_raise(RegexpError) { Regexp.new("((?<v>))\\g<0>") }
    475. 

  475.   end
    476. 

  476. 

  477.   def test_unescape
    478. 

  478.     assert_raise(ArgumentError) { s = '\\'; /#{ s }/ }
    479. 

  479.     assert_equal(/\xFF/n, /#{ s="\\xFF" }/n)
    480. 

  480.     assert_equal(/\177/, (s = '\177'; /#{ s }/))
    481. 

  481.     assert_raise(ArgumentError) { s = '\u'; /#{ s }/ }
    482. 

  482.     assert_raise(ArgumentError) { s = '\u{ ffffffff }'; /#{ s }/ }
    483. 

  483.     assert_raise(ArgumentError) { s = '\u{ ffffff }'; /#{ s }/ }
    484. 

  484.     assert_raise(ArgumentError) { s = '\u{ ffff X }'; /#{ s }/ }
    485. 

  485.     assert_raise(ArgumentError) { s = '\u{ }'; /#{ s }/ }
    486. 

  486.     assert_equal("b", "abc"[(s = '\u{0062}'; /#{ s }/)])
    487. 

  487.     assert_equal("b", "abc"[(s = '\u0062'; /#{ s }/)])
    488. 

  488.     assert_raise(ArgumentError) { s = '\u0'; /#{ s }/ }
    489. 

  489.     assert_raise(ArgumentError) { s = '\u000X'; /#{ s }/ }
    490. 

  490.     assert_raise(ArgumentError) { s = "\xff" + '\u3042'; /#{ s }/ }
    491. 

  491.     assert_raise(ArgumentError) { s = '\u3042' + [0xff].pack("C"); /#{ s }/ }
    492. 

  492.     assert_raise(SyntaxError) { s = ''; eval(%q(/\u#{ s }/)) }
    493. 

  493. 

  494.     assert_equal(/a/, eval(%q(s="\u0061";/#{s}/n)))
    495. 

  495.     assert_raise(RegexpError) { s = "\u3042"; eval(%q(/#{s}/n)) }
    496. 

  496.     assert_raise(RegexpError) { s = "\u0061"; eval(%q(/\u3042#{s}/n)) }
    497. 

  497.     assert_raise(RegexpError) { s1=[0xff].pack("C"); s2="\u3042"; eval(%q(/#{s1}#{s2}/)); [s1, s2] }
    498. 

  498. 

  499.     assert_raise(ArgumentError) { s = '\x'; /#{ s }/ }
    500. 

  500. 

  501.     assert_equal("\xe1", [0x00, 0xe1, 0xff].pack("C*")[/\M-a/])
    502. 

  502.     assert_equal("\xdc", [0x00, 0xdc, 0xff].pack("C*")[/\M-\\/])
    503. 

  503.     assert_equal("\x8a", [0x00, 0x8a, 0xff].pack("C*")[/\M-\n/])
    504. 

  504.     assert_equal("\x89", [0x00, 0x89, 0xff].pack("C*")[/\M-\t/])
    505. 

  505.     assert_equal("\x8d", [0x00, 0x8d, 0xff].pack("C*")[/\M-\r/])
    506. 

  506.     assert_equal("\x8c", [0x00, 0x8c, 0xff].pack("C*")[/\M-\f/])
    507. 

  507.     assert_equal("\x8b", [0x00, 0x8b, 0xff].pack("C*")[/\M-\v/])
    508. 

  508.     assert_equal("\x87", [0x00, 0x87, 0xff].pack("C*")[/\M-\a/])
    509. 

  509.     assert_equal("\x9b", [0x00, 0x9b, 0xff].pack("C*")[/\M-\e/])
    510. 

  510.     assert_equal("\x01", [0x00, 0x01, 0xff].pack("C*")[/\C-a/])
    511. 

  511. 

  512.     assert_raise(ArgumentError) { s = '\M'; /#{ s }/ }
    513. 

  513.     assert_raise(ArgumentError) { s = '\M-\M-a'; /#{ s }/ }
    514. 

  514.     assert_raise(ArgumentError) { s = '\M-\\'; /#{ s }/ }
    515. 

  515. 

  516.     assert_raise(ArgumentError) { s = '\C'; /#{ s }/ }
    517. 

  517.     assert_raise(ArgumentError) { s = '\c'; /#{ s }/ }
    518. 

  518.     assert_raise(ArgumentError) { s = '\C-\C-a'; /#{ s }/ }
    519. 

  519. 

  520.     assert_raise(ArgumentError) { s = '\M-\z'; /#{ s }/ }
    521. 

  521.     assert_raise(ArgumentError) { s = '\M-\777'; /#{ s }/ }
    522. 

  522. 

  523.     assert_equal("\u3042\u3042", "\u3042\u3042"[(s = "\u3042" + %q(\xe3\x81\x82); /#{s}/)])
    524. 

  524.     assert_raise(ArgumentError) { s = "\u3042" + %q(\xe3); /#{s}/ }
    525. 

  525.     assert_raise(ArgumentError) { s = "\u3042" + %q(\xe3\xe3); /#{s}/ }
    526. 

  526.     assert_raise(ArgumentError) { s = '\u3042' + [0xff].pack("C"); /#{s}/ }
    527. 

  527. 

  528.     assert_raise(SyntaxError) { eval("/\u3042/n") }
    529. 

  529. 

  530.     s = ".........."
    531. 

  531.     5.times { s.sub!(".", "") }
    532. 

  532.     assert_equal(".....", s)
    533. 

  533. 

  534.     assert_equal("\\\u{3042}", Regexp.new("\\\u{3042}").source)
    535. 

  535.   end
    536. 

  536. 

  537.   def test_equal
    538. 

  538.     bug5484 = '[ruby-core:40364]'
    539. 

  539.     assert_equal(/abc/, /abc/)
    540. 

  540.     assert_not_equal(/abc/, /abc/m)
    541. 

  541.     assert_not_equal(/abc/, /abd/)
    542. 

  542.     assert_equal(/\/foo/, Regexp.new('/foo'), bug5484)
    543. 

  543.   end
    544. 

  544. 

  545.   def test_match
    546. 

  546.     assert_nil(//.match(nil))
    547. 

  547.     assert_equal("abc", /.../.match(:abc)[0])
    548. 

  548.     assert_raise(TypeError) { /.../.match(Object.new)[0] }
    549. 

  549.     assert_equal("bc", /../.match('abc', 1)[0])
    550. 

  550.     assert_equal("bc", /../.match('abc', -2)[0])
    551. 

  551.     assert_nil(/../.match("abc", -4))
    552. 

  552.     assert_nil(/../.match("abc", 4))
    553. 

  553.     assert_equal('\x', /../n.match("\u3042" + '\x', 1)[0])
    554. 

  554. 

  555.     r = nil
    556. 

  556.     /.../.match("abc") {|m| r = m[0] }
    557. 

  557.     assert_equal("abc", r)
    558. 

  558. 

  559.     $_ = "abc"; assert_equal(1, ~/bc/)
    560. 

  560.     $_ = "abc"; assert_nil(~/d/)
    561. 

  561.     $_ = nil; assert_nil(~/./)
    562. 

  562.   end
    563. 

  563. 

  564.   def test_match_p
    565. 

  565.     /backref/ =~ 'backref'
    566. 

  566.     # must match here, but not in a separate method, e.g., assert_send,
    567. 

  567.     # to check if $~ is affected or not.
    568. 

  568.     assert_equal(false, //.match?(nil))
    569. 

  569.     assert_equal(true, //.match?(""))
    570. 

  570.     assert_equal(true, /.../.match?(:abc))
    571. 

  571.     assert_raise(TypeError) { /.../.match?(Object.new) }
    572. 

  572.     assert_equal(true, /b/.match?('abc'))
    573. 

  573.     assert_equal(true, /b/.match?('abc', 1))
    574. 

  574.     assert_equal(true, /../.match?('abc', 1))
    575. 

  575.     assert_equal(true, /../.match?('abc', -2))
    576. 

  576.     assert_equal(false, /../.match?("abc", -4))
    577. 

  577.     assert_equal(false, /../.match?("abc", 4))
    578. 

  578.     assert_equal(true, /../.match?("\u3042xx", 1))
    579. 

  579.     assert_equal(false, /../.match?("\u3042x", 1))
    580. 

  580.     assert_equal(true, /\z/.match?(""))
    581. 

  581.     assert_equal(true, /\z/.match?("abc"))
    582. 

  582.     assert_equal(true, /R.../.match?("Ruby"))
    583. 

  583.     assert_equal(false, /R.../.match?("Ruby", 1))
    584. 

  584.     assert_equal(false, /P.../.match?("Ruby"))
    585. 

  585.     assert_equal('backref', $&)
    586. 

  586.   end
    587. 

  587. 

  588.   def test_eqq
    589. 

  589.     assert_equal(false, /../ === nil)
    590. 

  590.   end
    591. 

  591. 

  592.   def test_quote
    593. 

  593.     assert_equal("\xff", Regexp.quote([0xff].pack("C")))
    594. 

  594.     assert_equal("\\ ", Regexp.quote("\ "))
    595. 

  595.     assert_equal("\\t", Regexp.quote("\t"))
    596. 

  596.     assert_equal("\\n", Regexp.quote("\n"))
    597. 

  597.     assert_equal("\\r", Regexp.quote("\r"))
    598. 

  598.     assert_equal("\\f", Regexp.quote("\f"))
    599. 

  599.     assert_equal("\\v", Regexp.quote("\v"))
    600. 

  600.     assert_equal("\u3042\\t", Regexp.quote("\u3042\t"))
    601. 

  601.     assert_equal("\\t\xff", Regexp.quote("\t" + [0xff].pack("C")))
    602. 

  602. 

  603.     bug13034 = '[ruby-core:78646] [Bug #13034]'
    604. 

  604.     str = "\x00".force_encoding("UTF-16BE")
    605. 

  605.     assert_equal(str, Regexp.quote(str), bug13034)
    606. 

  606.   end
    607. 

  607. 

  608.   def test_try_convert
    609. 

  609.     assert_equal(/re/, Regexp.try_convert(/re/))
    610. 

  610.     assert_nil(Regexp.try_convert("re"))
    611. 

  611. 

  612.     o = Object.new
    613. 

  613.     assert_nil(Regexp.try_convert(o))
    614. 

  614.     def o.to_regexp() /foo/ end
    615. 

  615.     assert_equal(/foo/, Regexp.try_convert(o))
    616. 

  616.   end
    617. 

  617. 

  618.   def test_union2
    619. 

  619.     assert_equal(/(?!)/, Regexp.union)
    620. 

  620.     assert_equal(/foo/, Regexp.union(/foo/))
    621. 

  621.     assert_equal(/foo/, Regexp.union([/foo/]))
    622. 

  622.     assert_equal(/\t/, Regexp.union("\t"))
    623. 

  623.     assert_equal(/(?-mix:\u3042)|(?-mix:\u3042)/, Regexp.union(/\u3042/, /\u3042/))
    624. 

  624.     assert_equal("\u3041", "\u3041"[Regexp.union(/\u3042/, "\u3041")])
    625. 

  625.   end
    626. 

  626. 

  627.   def test_dup
    628. 

  628.     assert_equal(//, //.dup)
    629. 

  629.     assert_raise(TypeError) { //.dup.instance_eval { initialize_copy(nil) } }
    630. 

  630.   end
    631. 

  631. 

  632.   def test_regsub
    633. 

  633.     assert_equal("fooXXXbaz", "foobarbaz".sub!(/bar/, "XXX"))
    634. 

  634.     s = [0xff].pack("C")
    635. 

  635.     assert_equal(s, "X".sub!(/./, s))
    636. 

  636.     assert_equal('\\' + s, "X".sub!(/./, '\\' + s))
    637. 

  637.     assert_equal('\k', "foo".sub!(/.../, '\k'))
    638. 

  638.     assert_raise(RuntimeError) { "foo".sub!(/(?<x>o)/, '\k<x') }
    639. 

  639.     assert_equal('foo[bar]baz', "foobarbaz".sub!(/(b..)/, '[\0]'))
    640. 

  640.     assert_equal('foo[foo]baz', "foobarbaz".sub!(/(b..)/, '[\`]'))
    641. 

  641.     assert_equal('foo[baz]baz', "foobarbaz".sub!(/(b..)/, '[\\\']'))
    642. 

  642.     assert_equal('foo[r]baz', "foobarbaz".sub!(/(b)(.)(.)/, '[\+]'))
    643. 

  643.     assert_equal('foo[\\]baz', "foobarbaz".sub!(/(b..)/, '[\\\\]'))
    644. 

  644.     assert_equal('foo[\z]baz', "foobarbaz".sub!(/(b..)/, '[\z]'))
    645. 

  645.   end
    646. 

  646. 

  647.   def test_regsub_K
    648. 

  648.     bug8856 = '[ruby-dev:47694] [Bug #8856]'
    649. 

  649.     result = "foobarbazquux/foobarbazquux".gsub(/foo\Kbar/, "")
    650. 

  650.     assert_equal('foobazquux/foobazquux', result, bug8856)
    651. 

  651.   end
    652. 

  652. 

  653.   def test_KCODE
    654. 

  654.     assert_nil($KCODE)
    655. 

  655.     assert_nothing_raised { $KCODE = nil }
    656. 

  656.     assert_equal(false, $=)
    657. 

  657.     assert_nothing_raised { $= = nil }
    658. 

  658.   end
    659. 

  659. 

  660.   def test_KCODE_warning
    661. 

  661.     assert_warning(/variable \$KCODE is no longer effective; ignored/) { $KCODE = nil }
    662. 

  662.     assert_warning(/variable \$KCODE is no longer effective/) { $KCODE = nil }
    663. 

  663.   end
    664. 

  664. 

  665.   def test_ignorecase_warning
    666. 

  666.     assert_warning(/variable \$= is no longer effective; ignored/) { $= = nil }
    667. 

  667.     assert_warning(/variable \$= is no longer effective/) { $= }
    668. 

  668.   end
    669. 

  669. 

  670.   def test_match_setter
    671. 

  671.     /foo/ =~ "foo"
    672. 

  672.     m = $~
    673. 

  673.     /bar/ =~ "bar"
    674. 

  674.     $~ = m
    675. 

  675.     assert_equal("foo", $&)
    676. 

  676.   end
    677. 

  677. 

  678.   def test_match_without_regexp
    679. 

  679.     # create a MatchData for each assertion because the internal state may change
    680. 

  680.     test = proc {|&blk| "abc".sub("a", ""); blk.call($~) }
    681. 

  681. 

  682.     bug10877 = '[ruby-core:68209] [Bug #10877]'
    683. 

  683.     test.call {|m| assert_raise_with_message(IndexError, /foo/, bug10877) {m["foo"]} }
    684. 

  684.     key = "\u{3042}"
    685. 

  685.     [Encoding::UTF_8, Encoding::Shift_JIS, Encoding::EUC_JP].each do |enc|
    686. 

  686.       idx = key.encode(enc)
    687. 

  687.       test.call {|m| assert_raise_with_message(IndexError, /#{idx}/, bug10877) {m[idx]} }
    688. 

  688.     end
    689. 

  689.     test.call {|m| assert_equal(/a/, m.regexp) }
    690. 

  690.     test.call {|m| assert_equal("abc", m.string) }
    691. 

  691.     test.call {|m| assert_equal(1, m.size) }
    692. 

  692.     test.call {|m| assert_equal(0, m.begin(0)) }
    693. 

  693.     test.call {|m| assert_equal(1, m.end(0)) }
    694. 

  694.     test.call {|m| assert_equal([0, 1], m.offset(0)) }
    695. 

  695.     test.call {|m| assert_equal([], m.captures) }
    696. 

  696.     test.call {|m| assert_equal([], m.names) }
    697. 

  697.     test.call {|m| assert_equal({}, m.named_captures) }
    698. 

  698.     test.call {|m| assert_equal(/a/.match("abc"), m) }
    699. 

  699.     test.call {|m| assert_equal(/a/.match("abc").hash, m.hash) }
    700. 

  700.     test.call {|m| assert_equal("bc", m.post_match) }
    701. 

  701.     test.call {|m| assert_equal("", m.pre_match) }
    702. 

  702.     test.call {|m| assert_equal(["a", nil], m.values_at(0, 1)) }
    703. 

  703.   end
    704. 

  704. 

  705.   def test_last_match
    706. 

  706.     /(...)(...)(...)(...)?/.match("foobarbaz")
    707. 

  707.     assert_equal("foobarbaz", Regexp.last_match(0))
    708. 

  708.     assert_equal("foo", Regexp.last_match(1))
    709. 

  709.     assert_nil(Regexp.last_match(5))
    710. 

  710.     assert_nil(Regexp.last_match(-1))
    711. 

  711.   end
    712. 

  712. 

  713.   def test_getter
    714. 

  714.     alias $__REGEXP_TEST_LASTMATCH__ $&
    715. 

  715.     alias $__REGEXP_TEST_PREMATCH__ $`
    716. 

  716.     alias $__REGEXP_TEST_POSTMATCH__ $'
    717. 

  717.     alias $__REGEXP_TEST_LASTPARENMATCH__ $+
    718. 

  718.     /(b)(.)(.)/.match("foobarbaz")
    719. 

  719.     assert_equal("bar", $__REGEXP_TEST_LASTMATCH__)
    720. 

  720.     assert_equal("foo", $__REGEXP_TEST_PREMATCH__)
    721. 

  721.     assert_equal("baz", $__REGEXP_TEST_POSTMATCH__)
    722. 

  722.     assert_equal("r", $__REGEXP_TEST_LASTPARENMATCH__)
    723. 

    724. 

  724.     /(...)(...)(...)/.match("foobarbaz")
    725. 

  725.     assert_equal("baz", $+)
    726. 

  726.   end
    727. 

    728. 

  728.   def test_rindex_regexp
    729. 

  729.     assert_equal(3, "foobarbaz\u3042".rindex(/b../n, 5))
    730. 

  730.   end
    731. 

    732. 

  732.   def assert_regexp(re, ss, fs = [], msg = nil)
    733. 

  733.     re = Regexp.new(re) unless re.is_a?(Regexp)
    734. 

  734.     ss = [ss] unless ss.is_a?(Array)
    735. 

  735.     ss.each do |e, s|
    736. 

  736.       s ||= e
    737. 

  737.       assert_match(re, s, msg)
    738. 

  738.       m = re.match(s)
    739. 

  739.       assert_equal(e, m[0], msg)
    740. 

  740.     end
    741. 

  741.     fs = [fs] unless fs.is_a?(Array)
    742. 

  742.     fs.each {|s| assert_no_match(re, s, msg) }
    743. 

  743.   end
    744. 

  744.   alias check assert_regexp
    745. 

    746. 

  746.   def assert_fail(re)
    747. 

  747.     assert_raise(RegexpError) { %r"#{ re }" }
    748. 

  748.   end
    749. 

  749.   alias failcheck assert_fail
    750. 

    751. 

  751.   def test_parse
    752. 

  752.     check(/\*\+\?\{\}\|\(\)\<\>\`\'/, "*+?{}|()<>`'")
    753. 

  753.     check(/\A\w\W\z/, %w(a. b!), %w(.. ab))
    754. 

  754.     check(/\A.\b.\b.\B.\B.\z/, %w(a.aaa .a...), %w(aaaaa .....))
    755. 

  755.     check(/\A\s\S\z/, [' a', "\n."], ['  ', "\n\n", 'a '])
    756. 

  756.     check(/\A\d\D\z/, '0a', %w(00 aa))
    757. 

  757.     check(/\A\h\H\z/, %w(0g ag BH), %w(a0 af GG))
    758. 

  758.     check(/\Afoo\Z\s\z/, "foo\n", ["foo", "foo\nbar"])
    759. 

  759.     assert_equal(%w(a b c), "abc def".scan(/\G\w/))
    760. 

  760.     check(/\A\u3042\z/, "\u3042", ["", "\u3043", "a"])
    761. 

  761.     check(/\A(..)\1\z/, %w(abab ....), %w(abba aba))
    762. 

  762.     failcheck('\1')
    763. 

  763.     check(/\A\80\z/, "80", ["\100", ""])
    764. 

  764.     check(/\A\77\z/, "?")
    765. 

  765.     check(/\A\78\z/, "\7" + '8', ["\100", ""])
    766. 

  766.     check(eval('/\A\Qfoo\E\z/'), "QfooE")
    767. 

  767.     check(/\Aa++\z/, "aaa")
    768. 

  768.     check('\Ax]\z', "x]")
    769. 

  769.     check(/x#foo/x, "x", "#foo")
    770. 

  770.     check(/\Ax#foo#{ "\n" }x\z/x, "xx", ["x", "x#foo\nx"])
    771. 

  771.     check(/\A\p{Alpha}\z/, ["a", "z"], [".", "", ".."])
    772. 

  772.     check(/\A\p{^Alpha}\z/, [".", "!"], ["!a", ""])
    773. 

  773.     check(/\A\n\z/, "\n")
    774. 

  774.     check(/\A\t\z/, "\t")
    775. 

  775.     check(/\A\r\z/, "\r")
    776. 

  776.     check(/\A\f\z/, "\f")
    777. 

  777.     check(/\A\a\z/, "\007")
    778. 

  778.     check(/\A\e\z/, "\033")
    779. 

  779.     check(/\A\v\z/, "\v")
    780. 

  780.     failcheck('(')
    781. 

  781.     failcheck('(?foo)')
    782. 

  782.     failcheck('/\p{foobarbazqux}/')
    783. 

  783.     failcheck('/\p{foobarbazqux' + 'a' * 1000 + '}/')
    784. 

  784.     failcheck('/[1-\w]/')
    785. 

  785.   end
    786. 

  786. 

  787.   def test_exec
    788. 

  788.     check(/A*B/, %w(B AB AAB AAAB), %w(A))
    789. 

  789.     check(/\w*!/, %w(! a! ab! abc!), %w(abc))
    790. 

  790.     check(/\w*\W/, %w(! a" ab# abc$), %w(abc))
    791. 

  791.     check(/\w*\w/, %w(z az abz abcz), %w(!))
    792. 

  792.     check(/[a-z]*\w/, %w(z az abz abcz), %w(!))
    793. 

  793.     check(/[a-z]*\W/, %w(! a" ab# abc$), %w(A))
    794. 

  794.     check(/((a|bb|ccc|dddd)(1|22|333|4444))/i, %w(a1 bb1 a22), %w(a2 b1))
    795. 

  795.     check(/\u0080/, (1..4).map {|i| ["\u0080", "\u0080" * i] }, ["\u0081"])
    796. 

  796.     check(/\u0080\u0080/, (2..4).map {|i| ["\u0080" * 2, "\u0080" * i] }, ["\u0081"])
    797. 

  797.     check(/\u0080\u0080\u0080/, (3..4).map {|i| ["\u0080" * 3, "\u0080" * i] }, ["\u0081"])
    798. 

  798.     check(/\u0080\u0080\u0080\u0080/, (4..4).map {|i| ["\u0080" * 4, "\u0080" * i] }, ["\u0081"])
    799. 

  799.     check(/[^\u3042\u3043\u3044]/, %W(a b \u0080 \u3041 \u3045), %W(\u3042 \u3043 \u3044))
    800. 

  800.     check(/a.+/m, %W(a\u0080 a\u0080\u0080 a\u0080\u0080\u0080), %W(a))
    801. 

  801.     check(/a.+z/m, %W(a\u0080z a\u0080\u0080z a\u0080\u0080\u0080z), %W(az))
    802. 

  802.     check(/abc\B.\Bxyz/, %w(abcXxyz abc0xyz), %w(abc|xyz abc-xyz))
    803. 

  803.     check(/\Bxyz/, [%w(xyz abcXxyz), %w(xyz abc0xyz)], %w(abc xyz abc-xyz))
    804. 

  804.     check(/abc\B/, [%w(abc abcXxyz), %w(abc abc0xyz)], %w(abc xyz abc-xyz))
    805. 

  805.     failcheck('(?<foo>abc)\1')
    806. 

  806.     check(/^(A+|B+)(?>\g<1>)*[BC]$/, %w(AC BC ABC BAC AABBC), %w(AABB))
    807. 

  807.     check(/^(A+|B(?>\g<1>)*)[AC]$/, %w(AAAC BBBAAAAC), %w(BBBAAA))
    808. 

  808.     check(/^()(?>\g<1>)*$/, "", "a")
    809. 

  809.     check(/^(?>(?=a)(#{ "a" * 1000 }|))++$/, ["a" * 1000, "a" * 2000, "a" * 3000], ["", "a" * 500, "b" * 1000])
    810. 

  810.     check(eval('/^(?:a?)?$/'), ["", "a"], ["aa"])
    811. 

  811.     check(eval('/^(?:a+)?$/'), ["", "a", "aa"], ["ab"])
    812. 

  812.     check(/^(?:a?)+?$/, ["", "a", "aa"], ["ab"])
    813. 

  813.     check(/^a??[ab]/, [["a", "a"], ["a", "aa"], ["b", "b"], ["a", "ab"]], ["c"])
    814. 

  814.     check(/^(?:a*){3,5}$/, ["", "a", "aa", "aaa", "aaaa", "aaaaa", "aaaaaa"], ["b"])
    815. 

  815.     check(/^(?:a+){3,5}$/, ["aaa", "aaaa", "aaaaa", "aaaaaa"], ["", "a", "aa", "b"])
    816. 

  816.   end
    817. 

  817. 

  818.   def test_parse_look_behind
    819. 

  819.     check(/(?<=A)B(?=C)/, [%w(B ABC)], %w(aBC ABc aBc))
    820. 

  820.     check(/(?<!A)B(?!C)/, [%w(B aBc)], %w(ABC aBC ABc))
    821. 

  821.     failcheck('(?<=.*)')
    822. 

  822.     failcheck('(?<!.*)')
    823. 

  823.     check(/(?<=A|B.)C/, [%w(C AC), %w(C BXC)], %w(C BC))
    824. 

  824.     check(/(?<!A|B.)C/, [%w(C C), %w(C BC)], %w(AC BXC))
    825. 

  825. 

  826.     assert_not_match(/(?<!aa|b)c/i, "Aac")
    827. 

  827.     assert_not_match(/(?<!b|aa)c/i, "Aac")
    828. 

  828.   end
    829. 

  829. 

  830.   def test_parse_kg
    831. 

  831.     check(/\A(.)(.)\k<1>(.)\z/, %w(abac abab ....), %w(abcd aaba xxx))
    832. 

  832.     check(/\A(.)(.)\k<-1>(.)\z/, %w(abbc abba ....), %w(abcd aaba xxx))
    833. 

  833.     check(/\A(?<n>.)(?<x>\g<n>){0}(?<y>\k<n+0>){0}\g<x>\g<y>\z/, "aba", "abb")
    834. 

  834.     check(/\A(?<n>.)(?<x>\g<n>){0}(?<y>\k<n+1>){0}\g<x>\g<y>\z/, "abb", "aba")
    835. 

  835.     check(/\A(?<x>..)\k<x>\z/, %w(abab ....), %w(abac abba xxx))
    836. 

  836.     check(/\A(.)(..)\g<-1>\z/, "abcde", %w(.... ......))
    837. 

  837.     failcheck('\k<x>')
    838. 

  838.     failcheck('\k<')
    839. 

  839.     failcheck('\k<>')
    840. 

  840.     failcheck('\k<.>')
    841. 

  841.     failcheck('\k<x.>')
    842. 

  842.     failcheck('\k<1.>')
    843. 

  843.     failcheck('\k<x')
    844. 

  844.     failcheck('\k<x+')
    845. 

  845.     failcheck('()\k<-2>')
    846. 

  846.     failcheck('()\g<-2>')
    847. 

  847.     check(/\A(?<x>.)(?<x>.)\k<x>\z/, %w(aba abb), %w(abc .. ....))
    848. 

  848.     check(/\A(?<x>.)(?<x>.)\k<x>\z/i, %w(aba ABa abb ABb), %w(abc .. ....))
    849. 

  849.     check('\k\g', "kg")
    850. 

  850.     failcheck('(.\g<1>)')
    851. 

  851.     failcheck('(.\g<2>)')
    852. 

  852.     failcheck('(?=\g<1>)')
    853. 

  853.     failcheck('((?=\g<1>))')
    854. 

  854.     failcheck('(\g<1>|.)')
    855. 

  855.     failcheck('(.|\g<1>)')
    856. 

  856.     check(/(!)(?<=(a)|\g<1>)/, ["!"], %w(a))
    857. 

  857.     check(/^(a|b\g<1>c)$/, %w(a bac bbacc bbbaccc), %w(bbac bacc))
    858. 

  858.     check(/^(a|b\g<2>c)(B\g<1>C){0}$/, %w(a bBaCc bBbBaCcCc bBbBbBaCcCcCc), %w(bBbBaCcC BbBaCcCc))
    859. 

  859.     check(/\A(?<n>.|X\g<n>)(?<x>\g<n>){0}(?<y>\k<n+0>){0}\g<x>\g<y>\z/, "XXaXbXXa", %w(XXabXa abb))
    860. 

  860.     check(/\A(?<n>.|X\g<n>)(?<x>\g<n>){0}(?<y>\k<n+1>){0}\g<x>\g<y>\z/, "XaXXbXXb", %w(aXXbXb aba))
    861. 

  861.     failcheck('(?<x>)(?<x>)(\g<x>)')
    862. 

  862.     check(/^(?<x>foo)(bar)\k<x>/, %w(foobarfoo), %w(foobar barfoo))
    863. 

  863.     check(/^(?<a>f)(?<a>o)(?<a>o)(?<a>b)(?<a>a)(?<a>r)(?<a>b)(?<a>a)(?<a>z)\k<a>{9}$/, %w(foobarbazfoobarbaz foobarbazbazbarfoo foobarbazzabraboof), %w(foobar barfoo))
    864. 

  864.   end
    865. 

  865. 

  866.   def test_parse_curly_brace
    867. 

  867.     check(/\A{/, ["{", ["{", "{x"]])
    868. 

  868.     check(/\A{ /, ["{ ", ["{ ", "{ x"]])
    869. 

  869.     check(/\A{,}\z/, "{,}")
    870. 

  870.     check(/\A{}\z/, "{}")
    871. 

  871.     check(/\Aa{0}+\z/, "", %w(a aa aab))
    872. 

  872.     check(/\Aa{1}+\z/, %w(a aa), ["", "aab"])
    873. 

  873.     check(/\Aa{1,2}b{1,2}\z/, %w(ab aab abb aabb), ["", "aaabb", "abbb"])
    874. 

  874.     check(/(?!x){0,1}/, [ ['', 'ab'], ['', ''] ])
    875. 

  875.     check(/c\z{0,1}/, [ ['c', 'abc'], ['c', 'cab']], ['abd'])
    876. 

  876.     check(/\A{0,1}a/, [ ['a', 'abc'], ['a', '____abc']], ['bcd'])
    877. 

  877.     failcheck('.{100001}')
    878. 

  878.     failcheck('.{0,100001}')
    879. 

  879.     failcheck('.{1,0}')
    880. 

  880.     failcheck('{0}')
    881. 

  881.   end
    882. 

  882. 

  883.   def test_parse_comment
    884. 

  884.     check(/\A(?#foo\)bar)\z/, "", "a")
    885. 

  885.     failcheck('(?#')
    886. 

  886.   end
    887. 

  887. 

  888.   def test_char_type
    889. 

  889.     check(/\u3042\d/, ["\u30421", "\u30422"])
    890. 

  890. 

  891.     # CClassTable cache test
    892. 

  892.     assert_match(/\u3042\d/, "\u30421")
    893. 

  893.     assert_match(/\u3042\d/, "\u30422")
    894. 

  894.   end
    895. 

  895. 

  896.   def test_char_class
    897. 

  897.     failcheck('[]')
    898. 

  898.     failcheck('[x')
    899. 

  899.     check('\A[]]\z', "]", "")
    900. 

  900.     check('\A[]\.]+\z', %w(] . ]..]), ["", "["])
    901. 

  901.     check(/\A[\u3042]\z/, "\u3042", "\u3042aa")
    902. 

  902.     check(/\A[\u3042\x61]+\z/, ["aa\u3042aa", "\u3042\u3042", "a"], ["", "b"])
    903. 

  903.     check(/\A[\u3042\x61\x62]+\z/, "abab\u3042abab\u3042")
    904. 

  904.     check(/\A[abc]+\z/, "abcba", ["", "ada"])
    905. 

  905.     check(/\A[\w][\W]\z/, %w(a. b!), %w(.. ab))
    906. 

  906.     check(/\A[\s][\S]\z/, [' a', "\n."], ['  ', "\n\n", 'a '])
    907. 

  907.     check(/\A[\d][\D]\z/, '0a', %w(00 aa))
    908. 

  908.     check(/\A[\h][\H]\z/, %w(0g ag BH), %w(a0 af GG))
    909. 

  909.     check(/\A[\p{Alpha}]\z/, ["a", "z"], [".", "", ".."])
    910. 

  910.     check(/\A[\p{^Alpha}]\z/, [".", "!"], ["!a", ""])
    911. 

  911.     check(/\A[\xff]\z/, "\xff", ["", "\xfe"])
    912. 

  912.     check(/\A[\80]+\z/, "8008", ["\\80", "\100", "\1000"])
    913. 

  913.     check(/\A[\77]+\z/, "???")
    914. 

  914.     check(/\A[\78]+\z/, "\788\7")
    915. 

  915.     check(/\A[\0]\z/, "\0")
    916. 

  916.     check(/\A[[:0]]\z/, [":", "0"], ["", ":0"])
    917. 

  917.     check(/\A[0-]\z/, ["0", "-"], "0-")
    918. 

  918.     check('\A[a-&&\w]\z', "a", "-")
    919. 

  919.     check('\A[--0]\z', ["-", "/", "0"], ["", "1"])
    920. 

  920.     check('\A[\'--0]\z', %w(* + \( \) 0 ,), ["", ".", "1"])
    921. 

  921.     check(/\A[a-b-]\z/, %w(a b -), ["", "c"])
    922. 

  922.     check('\A[a-b-&&\w]\z', %w(a b), ["", "-"])
    923. 

  923.     check('\A[a-b-&&\W]\z', "-", ["", "a", "b"])
    924. 

  924.     check('\A[a-c-e]\z', %w(a b c e -), %w(d))
    925. 

  925.     check(/\A[a-f&&[^b-c]&&[^e]]\z/, %w(a d f), %w(b c e g 0))
    926. 

  926.     check(/\A[[^b-c]&&[^e]&&a-f]\z/, %w(a d f), %w(b c e g 0))
    927. 

  927.     check(/\A[\n\r\t]\z/, ["\n", "\r", "\t"])
    928. 

  928.     failcheck('[9-1]')
    929. 

  929. 

  930.     assert_match(/\A\d+\z/, "0123456789")
    931. 

  931.     assert_no_match(/\d/, "\uff10\uff11\uff12\uff13\uff14\uff15\uff16\uff17\uff18\uff19")
    932. 

  932.     assert_match(/\A\w+\z/, "09azAZ_")
    933. 

  933.     assert_no_match(/\w/, "\uff10\uff19\uff41\uff5a\uff21\uff3a")
    934. 

  934.     assert_match(/\A\s+\z/, "\r\n\v\f\r\s")
    935. 

  935.     assert_no_match(/\s/, "\u0085")
    936. 

  936.   end
    937. 

  937. 

  938.   def test_posix_bracket
    939. 

  939.     check(/\A[[:alpha:]0]\z/, %w(0 a), %w(1 .))
    940. 

  940.     check(eval('/\A[[:^alpha:]0]\z/'), %w(0 1 .), "a")
    941. 

  941.     check(eval('/\A[[:alpha\:]]\z/'), %w(a l p h a :), %w(b 0 1 .))
    942. 

  942.     check(eval('/\A[[:alpha:foo]0]\z/'), %w(0 a), %w(1 .))
    943. 

  943.     check(/\A[[:xdigit:]&&[:alpha:]]\z/, "a", %w(g 0))
    944. 

  944.     check('\A[[:abcdefghijklmnopqrstu:]]+\z', "[]")
    945. 

  945.     failcheck('[[:alpha')
    946. 

  946.     failcheck('[[:alpha:')
    947. 

  947.     failcheck('[[:alp:]]')
    948. 

  948. 

  949.     assert_match(/\A[[:digit:]]+\z/, "\uff10\uff11\uff12\uff13\uff14\uff15\uff16\uff17\uff18\uff19")
    950. 

  950.     assert_match(/\A[[:alnum:]]+\z/, "\uff10\uff19\uff41\uff5a\uff21\uff3a")
    951. 

  951.     assert_match(/\A[[:space:]]+\z/, "\r\n\v\f\r\s\u0085")
    952. 

  952.     assert_match(/\A[[:ascii:]]+\z/, "\x00\x7F")
    953. 

  953.     assert_no_match(/[[:ascii:]]/, "\x80\xFF")
    954. 

  954.   end
    955. 

  955. 

  956.   def test_cclass_R
    957. 

  957.     assert_match(/\A\R\z/, "\r")
    958. 

  958.     assert_match(/\A\R\z/, "\n")
    959. 

  959.     assert_match(/\A\R\z/, "\f")
    960. 

  960.     assert_match(/\A\R\z/, "\v")
    961. 

  961.     assert_match(/\A\R\z/, "\r\n")
    962. 

  962.     assert_match(/\A\R\z/, "\u0085")
    963. 

  963.     assert_match(/\A\R\z/, "\u2028")
    964. 

  964.     assert_match(/\A\R\z/, "\u2029")
    965. 

  965.   end
    966. 

  966. 

  967.   def test_cclass_X
    968. 

  968.     assert_match(/\A\X\z/, "\u{20 200d}")
    969. 

  969.     assert_match(/\A\X\z/, "\u{600 600}")
    970. 

  970.     assert_match(/\A\X\z/, "\u{600 20}")
    971. 

  971.     assert_match(/\A\X\z/, "\u{261d 1F3FB}")
    972. 

  972.     assert_match(/\A\X\z/, "\u{1f600}")
    973. 

  973.     assert_match(/\A\X\z/, "\u{20 324}")
    974. 

  974.     assert_match(/\A\X\X\z/, "\u{a 324}")
    975. 

  975.     assert_match(/\A\X\X\z/, "\u{d 324}")
    976. 

  976.     assert_match(/\A\X\z/, "\u{1F477 1F3FF 200D 2640 FE0F}")
    977. 

  977.     assert_match(/\A\X\z/, "\u{1F468 200D 1F393}")
    978. 

  978.     assert_match(/\A\X\z/, "\u{1F46F 200D 2642 FE0F}")
    979. 

  979.     assert_match(/\A\X\z/, "\u{1f469 200d 2764 fe0f 200d 1f469}")
    980. 

  980. 

  981.     assert_warning('') {/\X/ =~ "\u{a0}"}
    982. 

  982.   end
    983. 

  983. 

  984.   def test_backward
    985. 

  985.     assert_equal(3, "foobar".rindex(/b.r/i))
    986. 

  986.     assert_equal(nil, "foovar".rindex(/b.r/i))
    987. 

  987.     assert_equal(3, ("foo" + "bar" * 1000).rindex(/#{"bar"*1000}/))
    988. 

  988.     assert_equal(4, ("foo\nbar\nbaz\n").rindex(/bar/i))
    989. 

  989.   end
    990. 

  990. 

  991.   def test_uninitialized
    992. 

  992.     assert_raise(TypeError) { Regexp.allocate.hash }
    993. 

  993.     assert_raise(TypeError) { Regexp.allocate.eql? Regexp.allocate }
    994. 

  994.     assert_raise(TypeError) { Regexp.allocate == Regexp.allocate }
    995. 

  995.     assert_raise(TypeError) { Regexp.allocate =~ "" }
    996. 

  996.     assert_equal(false, Regexp.allocate === Regexp.allocate)
    997. 

  997.     assert_nil(~Regexp.allocate)
    998. 

  998.     assert_raise(TypeError) { Regexp.allocate.match("") }
    999. 

  999.     assert_raise(TypeError) { Regexp.allocate.to_s }
    1000. 

  1000.     assert_match(/^#<Regexp:.*>$/, Regexp.allocate.inspect)
    1001. 

  1001.     assert_raise(TypeError) { Regexp.allocate.source }
    1002. 

  1002.     assert_raise(TypeError) { Regexp.allocate.casefold? }
    1003. 

  1003.     assert_raise(TypeError) { Regexp.allocate.options }
    1004. 

  1004.     assert_equal(Encoding.find("ASCII-8BIT"), Regexp.allocate.encoding)
    1005. 

  1005.     assert_equal(false, Regexp.allocate.fixed_encoding?)
    1006. 

  1006.     assert_raise(TypeError) { Regexp.allocate.names }
    1007. 

  1007.     assert_raise(TypeError) { Regexp.allocate.named_captures }
    1008. 

  1008. 

  1009.     assert_not_respond_to(MatchData, :allocate)
    1010. 

  1010. =begin
    1011. 

  1011.     assert_raise(TypeError) { MatchData.allocate.hash }
    1012. 

  1012.     assert_raise(TypeError) { MatchData.allocate.regexp }
    1013. 

  1013.     assert_raise(TypeError) { MatchData.allocate.names }
    1014. 

  1014.     assert_raise(TypeError) { MatchData.allocate.size }
    1015. 

  1015.     assert_raise(TypeError) { MatchData.allocate.length }
    1016. 

  1016.     assert_raise(TypeError) { MatchData.allocate.offset(0) }
    1017. 

  1017.     assert_raise(TypeError) { MatchData.allocate.begin(0) }
    1018. 

  1018.     assert_raise(TypeError) { MatchData.allocate.end(0) }
    1019. 

  1019.     assert_raise(TypeError) { MatchData.allocate.to_a }
    1020. 

  1020.     assert_raise(TypeError) { MatchData.allocate[:foo] }
    1021. 

  1021.     assert_raise(TypeError) { MatchData.allocate.captures }
    1022. 

  1022.     assert_raise(TypeError) { MatchData.allocate.values_at }
    1023. 

  1023.     assert_raise(TypeError) { MatchData.allocate.pre_match }
    1024. 

  1024.     assert_raise(TypeError) { MatchData.allocate.post_match }
    1025. 

  1025.     assert_raise(TypeError) { MatchData.allocate.to_s }
    1026. 

  1026.     assert_match(/^#<MatchData:.*>$/, MatchData.allocate.inspect)
    1027. 

  1027.     assert_raise(TypeError) { MatchData.allocate.string }
    1028. 

  1028.     $~ = MatchData.allocate
    1029. 

  1029.     assert_raise(TypeError) { $& }
    1030. 

  1030.     assert_raise(TypeError) { $` }
    1031. 

  1031.     assert_raise(TypeError) { $' }
    1032. 

  1032.     assert_raise(TypeError) { $+ }
    1033. 

  1033. =end
    1034. 

  1034.   end
    1035. 

    1036. 

  1036.   def test_unicode
    1037. 

  1037.     assert_match(/^\u3042{0}\p{Any}$/, "a")
    1038. 

  1038.     assert_match(/^\u3042{0}\p{Any}$/, "\u3041")
    1039. 

  1039.     assert_match(/^\u3042{0}\p{Any}$/, "\0")
    1040. 

  1040.     assert_match(/^\p{Lo}{4}$/u, "\u3401\u4E01\u{20001}\u{2A701}")
    1041. 

  1041.     assert_no_match(/^\u3042{0}\p{Any}$/, "\0\0")
    1042. 

  1042.     assert_no_match(/^\u3042{0}\p{Any}$/, "")
    1043. 

  1043.     assert_raise(SyntaxError) { eval('/^\u3042{0}\p{' + "\u3042" + '}$/') }
    1044. 

  1044.     assert_raise(SyntaxError) { eval('/^\u3042{0}\p{' + 'a' * 1000 + '}$/') }
    1045. 

  1045.     assert_raise(SyntaxError) { eval('/^\u3042{0}\p{foobarbazqux}$/') }
    1046. 

  1046.     assert_match(/^(\uff21)(a)\1\2$/i, "\uff21A\uff41a")
    1047. 

  1047.     assert_no_match(/^(\uff21)\1$/i, "\uff21A")
    1048. 

  1048.     assert_no_match(/^(\uff41)\1$/i, "\uff41a")
    1049. 

  1049.     assert_match(/^\u00df$/i, "\u00df")
    1050. 

  1050.     assert_match(/^\u00df$/i, "ss")
    1051. 

  1051.     #assert_match(/^(\u00df)\1$/i, "\u00dfss") # this must be bug...
    1052. 

  1052.     assert_match(/^\u00df{2}$/i, "\u00dfss")
    1053. 

  1053.     assert_match(/^\u00c5$/i, "\u00c5")
    1054. 

  1054.     assert_match(/^\u00c5$/i, "\u00e5")
    1055. 

  1055.     assert_match(/^\u00c5$/i, "\u212b")
    1056. 

  1056.     assert_match(/^(\u00c5)\1\1$/i, "\u00c5\u00e5\u212b")
    1057. 

  1057.     assert_match(/^\u0149$/i, "\u0149")
    1058. 

  1058.     assert_match(/^\u0149$/i, "\u02bcn")
    1059. 

  1059.     #assert_match(/^(\u0149)\1$/i, "\u0149\u02bcn") # this must be bug...
    1060. 

  1060.     assert_match(/^\u0149{2}$/i, "\u0149\u02bcn")
    1061. 

  1061.     assert_match(/^\u0390$/i, "\u0390")
    1062. 

  1062.     assert_match(/^\u0390$/i, "\u03b9\u0308\u0301")
    1063. 

  1063.     #assert_match(/^(\u0390)\1$/i, "\u0390\u03b9\u0308\u0301") # this must be bug...
    1064. 

  1064.     assert_match(/^\u0390{2}$/i, "\u0390\u03b9\u0308\u0301")
    1065. 

  1065.     assert_match(/^\ufb05$/i, "\ufb05")
    1066. 

  1066.     assert_match(/^\ufb05$/i, "\ufb06")
    1067. 

  1067.     assert_match(/^\ufb05$/i, "st")
    1068. 

  1068.     #assert_match(/^(\ufb05)\1\1$/i, "\ufb05\ufb06st") # this must be bug...
    1069. 

  1069.     assert_match(/^\ufb05{3}$/i, "\ufb05\ufb06st")
    1070. 

  1070.     assert_match(/^\u03b9\u0308\u0301$/i, "\u0390")
    1071. 

  1071.   end
    1072. 

    1073. 

  1073.   def test_unicode_age
    1074. 

  1074.     assert_match(/^\p{Age=6.0}$/u, "\u261c")
    1075. 

  1075.     assert_match(/^\p{Age=1.1}$/u, "\u261c")
    1076. 

  1076.     assert_no_match(/^\P{age=6.0}$/u, "\u261c")
    1077. 

    1078. 

  1078.     assert_match(/^\p{age=6.0}$/u, "\u31f6")
    1079. 

  1079.     assert_match(/^\p{age=3.2}$/u, "\u31f6")
    1080. 

  1080.     assert_no_match(/^\p{age=3.1}$/u, "\u31f6")
    1081. 

  1081.     assert_no_match(/^\p{age=3.0}$/u, "\u31f6")
    1082. 

  1082.     assert_no_match(/^\p{age=1.1}$/u, "\u31f6")
    1083. 

    1084. 

  1084.     assert_match(/^\p{age=6.0}$/u, "\u2754")
    1085. 

  1085.     assert_no_match(/^\p{age=5.0}$/u, "\u2754")
    1086. 

  1086.     assert_no_match(/^\p{age=4.0}$/u, "\u2754")
    1087. 

  1087.     assert_no_match(/^\p{age=3.0}$/u, "\u2754")
    1088. 

  1088.     assert_no_match(/^\p{age=2.0}$/u, "\u2754")
    1089. 

  1089.     assert_no_match(/^\p{age=1.1}$/u, "\u2754")
    1090. 

    1091. 

  1091.     assert_no_match(/^\p{age=12.0}$/u, "\u32FF")
    1092. 

  1092.     assert_match(/^\p{age=12.1}$/u, "\u32FF")
    1093. 

  1093.   end
    1094. 

    1095. 

  1095.   MatchData_A = eval("class MatchData_\u{3042} < MatchData; self; end")
    1096. 

    1097. 

  1097.   def test_matchdata
    1098. 

  1098.     a = "haystack".match(/hay/)
    1099. 

  1099.     b = "haystack".match(/hay/)
    1100. 

  1100.     assert_equal(a, b, '[ruby-core:24748]')
    1101. 

  1101.     h = {a => 42}
    1102. 

  1102.     assert_equal(42, h[b], '[ruby-core:24748]')
    1103. 

  1103. =begin
    1104. 

  1104.     assert_match(/#<TestRegexp::MatchData_\u{3042}:/, MatchData_A.allocate.inspect)
    1105. 

  1105. =end
    1106. 

    1107. 

  1107.     h = /^(?<@time>\d+): (?<body>.*)/.match("123456: hoge fuga")
    1108. 

  1108.     assert_equal("123456", h["@time"])
    1109. 

  1109.     assert_equal("hoge fuga", h["body"])
    1110. 

  1110.   end
    1111. 

    1112. 

  1112.   def test_regexp_popped
    1113. 

  1113.     assert_nothing_raised { eval("a = 1; /\#{ a }/; a") }
    1114. 

  1114.     assert_nothing_raised { eval("a = 1; /\#{ a }/o; a") }
    1115. 

  1115.   end
    1116. 

    1117. 

  1117.   def test_invalid_fragment
    1118. 

  1118.     bug2547 = '[ruby-core:27374]'
    1119. 

  1119.     assert_raise(SyntaxError, bug2547) {eval('/#{"\\\\"}y/')}
    1120. 

  1120.   end
    1121. 

    1122. 

  1122.   def test_dup_warn
    1123. 

  1123.     assert_warning(/duplicated/) { Regexp.new('[\u3042\u3043\u3042]') }
    1124. 

  1124.     assert_warning(/duplicated/) { Regexp.new('[\u3042\u3043\u3043]') }
    1125. 

  1125.     assert_warning(/\A\z/) { Regexp.new('[\u3042\u3044\u3043]') }
    1126. 

  1126.     assert_warning(/\A\z/) { Regexp.new('[\u3042\u3045\u3043]') }
    1127. 

  1127.     assert_warning(/\A\z/) { Regexp.new('[\u3042\u3045\u3044]') }
    1128. 

  1128.     assert_warning(/\A\z/) { Regexp.new('[\u3042\u3045\u3043-\u3044]') }
    1129. 

  1129.     assert_warning(/duplicated/) { Regexp.new('[\u3042\u3045\u3042-\u3043]') }
    1130. 

  1130.     assert_warning(/duplicated/) { Regexp.new('[\u3042\u3045\u3044-\u3045]') }
    1131. 

  1131.     assert_warning(/\A\z/) { Regexp.new('[\u3042\u3046\u3044]') }
    1132. 

  1132.     assert_warning(/duplicated/) { Regexp.new('[\u1000-\u2000\u3042-\u3046\u3044]') }
    1133. 

  1133.     assert_warning(/duplicated/) { Regexp.new('[\u3044\u3041-\u3047]') }
    1134. 

  1134.     assert_warning(/duplicated/) { Regexp.new('[\u3042\u3044\u3046\u3041-\u3047]') }
    1135. 

    1136. 

  1136.     bug7471 = '[ruby-core:50344]'
    1137. 

  1137.     assert_warning('', bug7471) { Regexp.new('[\D]') =~ "\u3042" }
    1138. 

    1139. 

  1139.     bug8151 = '[ruby-core:53649]'
    1140. 

  1140.     assert_warning(/\A\z/, bug8151) { Regexp.new('(?:[\u{33}])').to_s }
    1141. 

    1142. 

  1142.     assert_warning(%r[/.*/\Z]) { Regexp.new("[\n\n]") }
    1143. 

  1143.   end
    1144. 

    1145. 

  1145.   def test_property_warn
    1146. 

  1146.     assert_in_out_err('-w', 'x=/\p%s/', [], %r"warning: invalid Unicode Property \\p: /\\p%s/")
    1147. 

  1147.   end
    1148. 

    1149. 

  1149.   def test_invalid_escape_error
    1150. 

  1150.     bug3539 = '[ruby-core:31048]'
    1151. 

  1151.     error = assert_raise(SyntaxError) {eval('/\x/', nil, bug3539)}
    1152. 

  1152.     assert_match(/invalid hex escape/, error.message)
    1153. 

  1153.     assert_equal(1, error.message.scan(/.*invalid .*escape.*/i).size, bug3539)
    1154. 

  1154.   end
    1155. 

    1156. 

  1156.   def test_raw_hyphen_and_tk_char_type_after_range
    1157. 

  1157.     bug6853 = '[ruby-core:47115]'
    1158. 

  1158.     # use Regexp.new instead of literal to ignore a parser warning.
    1159. 

  1159.     check(Regexp.new('[0-1-\\s]'), [' ', '-'], ['2', 'a'], bug6853)
    1160. 

  1160.   end
    1161. 

    1162. 

  1162.   def test_error_message_on_failed_conversion
    1163. 

  1163.     bug7539 = '[ruby-core:50733]'
    1164. 

  1164.     assert_equal false, /x/=== 42
    1165. 

  1165.     assert_raise_with_message(TypeError, 'no implicit conversion of Integer into String', bug7539) {
    1166. 

  1166.       Regexp.quote(42)
    1167. 

  1167.     }
    1168. 

  1168.   end
    1169. 

    1170. 

  1170.   def test_conditional_expression
    1171. 

  1171.     bug8583 = '[ruby-dev:47480] [Bug #8583]'
    1172. 

    1173. 

  1173.     conds = {"xy"=>true, "yx"=>true, "xx"=>false, "yy"=>false}
    1174. 

  1174.     assert_match_each(/\A((x)|(y))(?(2)y|x)\z/, conds, bug8583)
    1175. 

  1175.     assert_match_each(/\A((?<x>x)|(?<y>y))(?(<x>)y|x)\z/, conds, bug8583)
    1176. 

    1177. 

  1177.     bug12418 = '[ruby-core:75694] [Bug #12418]'
    1178. 

  1178.     assert_raise(RegexpError, bug12418){ Regexp.new('(0?0|(?(5)||)|(?(5)||))?') }
    1179. 

  1179.   end
    1180. 

    1181. 

  1181.   def test_options_in_look_behind
    1182. 

  1182.     assert_nothing_raised {
    1183. 

  1183.       assert_match_at("(?<=(?i)ab)cd", "ABcd", [[2,4]])
    1184. 

  1184.       assert_match_at("(?<=(?i:ab))cd", "ABcd", [[2,4]])
    1185. 

  1185.       assert_match_at("(?<!(?i)ab)cd", "aacd", [[2,4]])
    1186. 

  1186.       assert_match_at("(?<!(?i:ab))cd", "aacd", [[2,4]])
    1187. 

    1188. 

  1188.       assert_not_match("(?<=(?i)ab)cd", "ABCD")
    1189. 

  1189.       assert_not_match("(?<=(?i:ab))cd", "ABCD")
    1190. 

  1190.       assert_not_match("(?<!(?i)ab)cd", "ABcd")
    1191. 

  1191.       assert_not_match("(?<!(?i:ab))cd", "ABcd")
    1192. 

  1192.     }
    1193. 

  1193.   end
    1194. 

    1195. 

  1195.   def test_once
    1196. 

  1196.     pr1 = proc{|i| /#{i}/o}
    1197. 

  1197.     assert_equal(/0/, pr1.call(0))
    1198. 

  1198.     assert_equal(/0/, pr1.call(1))
    1199. 

  1199.     assert_equal(/0/, pr1.call(2))
    1200. 

  1200.   end
    1201. 

    1202. 

  1202.   def test_once_recursive
    1203. 

  1203.     pr2 = proc{|i|
    1204. 

  1204.       if i > 0
    1205. 

  1205.         /#{pr2.call(i-1).to_s}#{i}/
    1206. 

  1206.       else
    1207. 

  1207.         //
    1208. 

  1208.       end
    1209. 

  1209.     }
    1210. 

  1210.     assert_equal(/(?-mix:(?-mix:(?-mix:)1)2)3/, pr2.call(3))
    1211. 

  1211.   end
    1212. 

    1213. 

  1213.   def test_once_multithread
    1214. 

  1214.     m = Thread::Mutex.new
    1215. 

  1215.     pr3 = proc{|i|
    1216. 

  1216.       /#{m.unlock; sleep 0.5; i}/o
    1217. 

  1217.     }
    1218. 

  1218.     ary = []
    1219. 

  1219.     n = 0
    1220. 

  1220.     th1 = Thread.new{m.lock; ary << pr3.call(n+=1)}
    1221. 

  1221.     th2 = Thread.new{m.lock; ary << pr3.call(n+=1)}
    1222. 

  1222.     th1.join; th2.join
    1223. 

  1223.     assert_equal([/1/, /1/], ary)
    1224. 

  1224.   end
    1225. 

    1226. 

  1226.   def test_once_escape
    1227. 

  1227.     pr4 = proc{|i|
    1228. 

  1228.       catch(:xyzzy){
    1229. 

  1229.         /#{throw :xyzzy, i}/o =~ ""
    1230. 

  1230.         :ng
    1231. 

  1231.       }
    1232. 

  1232.     }
    1233. 

  1233.     assert_equal(0, pr4.call(0))
    1234. 

  1234.     assert_equal(1, pr4.call(1))
    1235. 

  1235.   end
    1236. 

    1237. 

  1237.   def test_eq_tilde_can_be_overridden
    1238. 

  1238.     assert_separately([], <<-RUBY)
    1239. 

  1239.       class Regexp
    1240. 

  1240.         undef =~
    1241. 

  1241.         def =~(str)
    1242. 

  1242.           "foo"
    1243. 

  1243.         end
    1244. 

  1244.       end
    1245. 

    1246. 

  1246.       assert_equal("foo", // =~ "")
    1247. 

  1247.     RUBY
    1248. 

  1248.   end
    1249. 

    1250. 

  1250.   def test_invalid_free_at_parse_depth_limit_over
    1251. 

  1251.     assert_separately([], "#{<<-"begin;"}\n#{<<-"end;"}")
    1252. 

  1252.     begin;
    1253. 

  1253.       begin
    1254. 

  1254.         require '-test-/regexp'
    1255. 

  1255.       rescue LoadError
    1256. 

  1256.       else
    1257. 

  1257.         bug = '[ruby-core:79624] [Bug #13234]'
    1258. 

  1258.         Bug::Regexp.parse_depth_limit = 10
    1259. 

  1259.         src = "[" * 100
    1260. 

  1260.         3.times do
    1261. 

  1261.           assert_raise_with_message(RegexpError, /parse depth limit over/, bug) do
    1262. 

  1262.             Regexp.new(src)
    1263. 

  1263.           end
    1264. 

  1264.         end
    1265. 

  1265.       end
    1266. 

  1266.     end;
    1267. 

  1267.   end
    1268. 

    1269. 

  1269.   def test_absent
    1270. 

  1270.     assert_equal(0, /(?~(a|c)c)/ =~ "abb")
    1271. 

  1271.     assert_equal("abb", $&)
    1272. 

    1273. 

  1273.     assert_equal(0, /\/\*((?~\*\/))\*\// =~ "/*abc*def/xyz*/ /* */")
    1274. 

  1274.     assert_equal("abc*def/xyz", $1)
    1275. 

    1276. 

  1276.     assert_equal(0, /(?~(a)c)/ =~ "abb")
    1277. 

  1277.     assert_nil($1)
    1278. 

  1278.   end
    1279. 

    1280. 

  1280.   # This assertion is for porting x2() tests in testpy.py of Onigmo.
    1281. 

  1281.   def assert_match_at(re, str, positions, msg = nil)
    1282. 

  1282.     re = Regexp.new(re) unless re.is_a?(Regexp)
    1283. 

    1284. 

  1284.     match = re.match(str)
    1285. 

    1286. 

  1286.     assert_not_nil match, message(msg) {
    1287. 

  1287.       "Expected #{re.inspect} to match #{str.inspect}"
    1288. 

  1288.     }
    1289. 

    1290. 

  1290.     if match
    1291. 

  1291.       actual_positions = (0...match.size).map { |i|
    1292. 

  1292.         [match.begin(i), match.end(i)]
    1293. 

  1293.       }
    1294. 

    1295. 

  1295.       assert_equal positions, actual_positions, message(msg) {
    1296. 

  1296.         "Expected #{re.inspect} to match #{str.inspect} at: #{positions.inspect}"
    1297. 

  1297.       }
    1298. 

  1298.     end
    1299. 

  1299.   end
    1300. 

    1301. 

  1301.   def assert_match_each(re, conds, msg = nil)
    1302. 

  1302.     errs = conds.select {|str, match| match ^ (re =~ str)}
    1303. 

  1303.     msg = message(msg) {
    1304. 

  1304.       "Expected #{re.inspect} to\n" +
    1305. 

  1305.       errs.map {|str, match| "\t#{'not ' unless match}match #{str.inspect}"}.join(",\n")
    1306. 

  1306.     }
    1307. 

  1307.     assert_empty(errs, msg)
    1308. 

  1308.   end
    1309. 

  1309. end
    1310. 

    1311.