The Tor Browser: js/src/tests/ecma_3/RegExp/perlstress-002.js@129ffea94266

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 /* This Source Code Form is subject to the terms of the Mozilla Public

     3  * License, v. 2.0. If a copy of the MPL was not distributed with this

     4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     6 /*

     7  *

     8  * Date:    2002-07-07

     9  * SUMMARY: Testing JS RegExp engine against Perl 5 RegExp engine.

    10  * Adjust cnLBOUND, cnUBOUND below to restrict which sections are tested.

    11  *

    12  * This test was created by running various patterns and strings through the

    13  * Perl 5 RegExp engine. We saved the results below to test the JS engine.

    14  *

    15  * Each of the examples below is a negative test; that is, each produces a

    16  * null match in Perl. Thus we set |expectedmatch| = |null| in each section.

    17  *

    18  * NOTE: ECMA/JS and Perl do differ on certain points. We have either commented

    19  * out such sections altogether, or modified them to fit what we expect from JS.

    20  *

    21  * EXAMPLES:

    22  *

    23  * - ECMA does support (?: (?= and (?! operators, but doesn't support (?<  etc.

    24  *

    25  * - ECMA doesn't support (?(condition)

    26  *

    27  */

    28 //-----------------------------------------------------------------------------

    29 var i = 0;

    30 var BUGNUMBER = 85721;

    31 var summary = 'Testing regular expression edge cases';

    32 var cnSingleSpace = ' ';

    33 var status = '';

    34 var statusmessages = new Array();

    35 var pattern = '';

    36 var patterns = new Array();

    37 var string = '';

    38 var strings = new Array();

    39 var actualmatch = '';

    40 var actualmatches = new Array();

    41 var expectedmatch = '';

    42 var expectedmatches = new Array();

    43 var cnLBOUND = 0;

    44 var cnUBOUND = 1000;

    47 status = inSection(1);

    48 pattern = /abc/;

    49 string = 'xbc';

    50 actualmatch = string.match(pattern);

    51 expectedmatch = null;

    52 addThis();

    54 status = inSection(2);

    55 pattern = /abc/;

    56 string = 'axc';

    57 actualmatch = string.match(pattern);

    58 expectedmatch = null;

    59 addThis();

    61 status = inSection(3);

    62 pattern = /abc/;

    63 string = 'abx';

    64 actualmatch = string.match(pattern);

    65 expectedmatch = null;

    66 addThis();

    68 status = inSection(4);

    69 pattern = /ab+bc/;

    70 string = 'abc';

    71 actualmatch = string.match(pattern);

    72 expectedmatch = null;

    73 addThis();

    75 status = inSection(5);

    76 pattern = /ab+bc/;

    77 string = 'abq';

    78 actualmatch = string.match(pattern);

    79 expectedmatch = null;

    80 addThis();

    82 status = inSection(6);

    83 pattern = /ab{1,}bc/;

    84 string = 'abq';

    85 actualmatch = string.match(pattern);

    86 expectedmatch = null;

    87 addThis();

    89 status = inSection(7);

    90 pattern = /ab{4,5}bc/;

    91 string = 'abbbbc';

    92 actualmatch = string.match(pattern);

    93 expectedmatch = null;

    94 addThis();

    96 status = inSection(8);

    97 pattern = /ab?bc/;

    98 string = 'abbbbc';

    99 actualmatch = string.match(pattern);

   100 expectedmatch = null;

   101 addThis();

   103 status = inSection(9);

   104 pattern = /^abc$/;

   105 string = 'abcc';

   106 actualmatch = string.match(pattern);

   107 expectedmatch = null;

   108 addThis();

   110 status = inSection(10);

   111 pattern = /^abc$/;

   112 string = 'aabc';

   113 actualmatch = string.match(pattern);

   114 expectedmatch = null;

   115 addThis();

   117 status = inSection(11);

   118 pattern = /abc$/;

   119 string = 'aabcd';

   120 actualmatch = string.match(pattern);

   121 expectedmatch = null;

   122 addThis();

   124 status = inSection(12);

   125 pattern = /a.*c/;

   126 string = 'axyzd';

   127 actualmatch = string.match(pattern);

   128 expectedmatch = null;

   129 addThis();

   131 status = inSection(13);

   132 pattern = /a[bc]d/;

   133 string = 'abc';

   134 actualmatch = string.match(pattern);

   135 expectedmatch = null;

   136 addThis();

   138 status = inSection(14);

   139 pattern = /a[b-d]e/;

   140 string = 'abd';

   141 actualmatch = string.match(pattern);

   142 expectedmatch = null;

   143 addThis();

   145 status = inSection(15);

   146 pattern = /a[^bc]d/;

   147 string = 'abd';

   148 actualmatch = string.match(pattern);

   149 expectedmatch = null;

   150 addThis();

   152 status = inSection(16);

   153 pattern = /a[^-b]c/;

   154 string = 'a-c';

   155 actualmatch = string.match(pattern);

   156 expectedmatch = null;

   157 addThis();

   159 status = inSection(17);

   160 pattern = /a[^]b]c/;

   161 string = 'a]c';

   162 actualmatch = string.match(pattern);

   163 expectedmatch = null;

   164 addThis();

   166 status = inSection(18);

   167 pattern = /\by\b/;

   168 string = 'xy';

   169 actualmatch = string.match(pattern);

   170 expectedmatch = null;

   171 addThis();

   173 status = inSection(19);

   174 pattern = /\by\b/;

   175 string = 'yz';

   176 actualmatch = string.match(pattern);

   177 expectedmatch = null;

   178 addThis();

   180 status = inSection(20);

   181 pattern = /\by\b/;

   182 string = 'xyz';

   183 actualmatch = string.match(pattern);

   184 expectedmatch = null;

   185 addThis();

   187 status = inSection(21);

   188 pattern = /\Ba\B/;

   189 string = 'a-';

   190 actualmatch = string.match(pattern);

   191 expectedmatch = null;

   192 addThis();

   194 status = inSection(22);

   195 pattern = /\Ba\B/;

   196 string = '-a';

   197 actualmatch = string.match(pattern);

   198 expectedmatch = null;

   199 addThis();

   201 status = inSection(23);

   202 pattern = /\Ba\B/;

   203 string = '-a-';

   204 actualmatch = string.match(pattern);

   205 expectedmatch = null;

   206 addThis();

   208 status = inSection(24);

   209 pattern = /\w/;

   210 string = '-';

   211 actualmatch = string.match(pattern);

   212 expectedmatch = null;

   213 addThis();

   215 status = inSection(25);

   216 pattern = /\W/;

   217 string = 'a';

   218 actualmatch = string.match(pattern);

   219 expectedmatch = null;

   220 addThis();

   222 status = inSection(26);

   223 pattern = /a\sb/;

   224 string = 'a-b';

   225 actualmatch = string.match(pattern);

   226 expectedmatch = null;

   227 addThis();

   229 status = inSection(27);

   230 pattern = /\d/;

   231 string = '-';

   232 actualmatch = string.match(pattern);

   233 expectedmatch = null;

   234 addThis();

   236 status = inSection(28);

   237 pattern = /\D/;

   238 string = '1';

   239 actualmatch = string.match(pattern);

   240 expectedmatch = null;

   241 addThis();

   243 status = inSection(29);

   244 pattern = /[\w]/;

   245 string = '-';

   246 actualmatch = string.match(pattern);

   247 expectedmatch = null;

   248 addThis();

   250 status = inSection(30);

   251 pattern = /[\W]/;

   252 string = 'a';

   253 actualmatch = string.match(pattern);

   254 expectedmatch = null;

   255 addThis();

   257 status = inSection(31);

   258 pattern = /a[\s]b/;

   259 string = 'a-b';

   260 actualmatch = string.match(pattern);

   261 expectedmatch = null;

   262 addThis();

   264 status = inSection(32);

   265 pattern = /[\d]/;

   266 string = '-';

   267 actualmatch = string.match(pattern);

   268 expectedmatch = null;

   269 addThis();

   271 status = inSection(33);

   272 pattern = /[\D]/;

   273 string = '1';

   274 actualmatch = string.match(pattern);

   275 expectedmatch = null;

   276 addThis();

   278 status = inSection(34);

   279 pattern = /$b/;

   280 string = 'b';

   281 actualmatch = string.match(pattern);

   282 expectedmatch = null;

   283 addThis();

   285 status = inSection(35);

   286 pattern = /^(ab|cd)e/;

   287 string = 'abcde';

   288 actualmatch = string.match(pattern);

   289 expectedmatch = null;

   290 addThis();

   292 status = inSection(36);

   293 pattern = /a[bcd]+dcdcde/;

   294 string = 'adcdcde';

   295 actualmatch = string.match(pattern);

   296 expectedmatch = null;

   297 addThis();

   299 status = inSection(37);

   300 pattern = /(bc+d$|ef*g.|h?i(j|k))/;

   301 string = 'effg';

   302 actualmatch = string.match(pattern);

   303 expectedmatch = null;

   304 addThis();

   306 status = inSection(38);

   307 pattern = /(bc+d$|ef*g.|h?i(j|k))/;

   308 string = 'bcdd';

   309 actualmatch = string.match(pattern);

   310 expectedmatch = null;

   311 addThis();

   313 status = inSection(39);

   314 pattern = /[k]/;

   315 string = 'ab';

   316 actualmatch = string.match(pattern);

   317 expectedmatch = null;

   318 addThis();

   320 // MODIFIED - ECMA has different rules for paren contents.

   321 status = inSection(40);

   322 pattern = /(a)|\1/;

   323 string = 'x';

   324 actualmatch = string.match(pattern);

   325 //expectedmatch = null;

   326 expectedmatch = Array("", undefined);

   327 addThis();

   329 // MODIFIED - ECMA has different rules for paren contents.

   330 status = inSection(41);

   331 pattern = /((\3|b)\2(a)x)+/;

   332 string = 'aaxabxbaxbbx';

   333 actualmatch = string.match(pattern);

   334 //expectedmatch = null;

   335 expectedmatch = Array("ax", "ax", "", "a");

   336 addThis();

   338 status = inSection(42);

   339 pattern = /abc/i;

   340 string = 'XBC';

   341 actualmatch = string.match(pattern);

   342 expectedmatch = null;

   343 addThis();

   345 status = inSection(43);

   346 pattern = /abc/i;

   347 string = 'AXC';

   348 actualmatch = string.match(pattern);

   349 expectedmatch = null;

   350 addThis();

   352 status = inSection(44);

   353 pattern = /abc/i;

   354 string = 'ABX';

   355 actualmatch = string.match(pattern);

   356 expectedmatch = null;

   357 addThis();

   359 status = inSection(45);

   360 pattern = /ab+bc/i;

   361 string = 'ABC';

   362 actualmatch = string.match(pattern);

   363 expectedmatch = null;

   364 addThis();

   366 status = inSection(46);

   367 pattern = /ab+bc/i;

   368 string = 'ABQ';

   369 actualmatch = string.match(pattern);

   370 expectedmatch = null;

   371 addThis();

   373 status = inSection(47);

   374 pattern = /ab{1,}bc/i;

   375 string = 'ABQ';

   376 actualmatch = string.match(pattern);

   377 expectedmatch = null;

   378 addThis();

   380 status = inSection(48);

   381 pattern = /ab{4,5}?bc/i;

   382 string = 'ABBBBC';

   383 actualmatch = string.match(pattern);

   384 expectedmatch = null;

   385 addThis();

   387 status = inSection(49);

   388 pattern = /ab??bc/i;

   389 string = 'ABBBBC';

   390 actualmatch = string.match(pattern);

   391 expectedmatch = null;

   392 addThis();

   394 status = inSection(50);

   395 pattern = /^abc$/i;

   396 string = 'ABCC';

   397 actualmatch = string.match(pattern);

   398 expectedmatch = null;

   399 addThis();

   401 status = inSection(51);

   402 pattern = /^abc$/i;

   403 string = 'AABC';

   404 actualmatch = string.match(pattern);

   405 expectedmatch = null;

   406 addThis();

   408 status = inSection(52);

   409 pattern = /a.*c/i;

   410 string = 'AXYZD';

   411 actualmatch = string.match(pattern);

   412 expectedmatch = null;

   413 addThis();

   415 status = inSection(53);

   416 pattern = /a[bc]d/i;

   417 string = 'ABC';

   418 actualmatch = string.match(pattern);

   419 expectedmatch = null;

   420 addThis();

   422 status = inSection(54);

   423 pattern = /a[b-d]e/i;

   424 string = 'ABD';

   425 actualmatch = string.match(pattern);

   426 expectedmatch = null;

   427 addThis();

   429 status = inSection(55);

   430 pattern = /a[^bc]d/i;

   431 string = 'ABD';

   432 actualmatch = string.match(pattern);

   433 expectedmatch = null;

   434 addThis();

   436 status = inSection(56);

   437 pattern = /a[^-b]c/i;

   438 string = 'A-C';

   439 actualmatch = string.match(pattern);

   440 expectedmatch = null;

   441 addThis();

   443 status = inSection(57);

   444 pattern = /a[^]b]c/i;

   445 string = 'A]C';

   446 actualmatch = string.match(pattern);

   447 expectedmatch = null;

   448 addThis();

   450 status = inSection(58);

   451 pattern = /$b/i;

   452 string = 'B';

   453 actualmatch = string.match(pattern);

   454 expectedmatch = null;

   455 addThis();

   457 status = inSection(59);

   458 pattern = /^(ab|cd)e/i;

   459 string = 'ABCDE';

   460 actualmatch = string.match(pattern);

   461 expectedmatch = null;

   462 addThis();

   464 status = inSection(60);

   465 pattern = /a[bcd]+dcdcde/i;

   466 string = 'ADCDCDE';

   467 actualmatch = string.match(pattern);

   468 expectedmatch = null;

   469 addThis();

   471 status = inSection(61);

   472 pattern = /(bc+d$|ef*g.|h?i(j|k))/i;

   473 string = 'EFFG';

   474 actualmatch = string.match(pattern);

   475 expectedmatch = null;

   476 addThis();

   478 status = inSection(62);

   479 pattern = /(bc+d$|ef*g.|h?i(j|k))/i;

   480 string = 'BCDD';

   481 actualmatch = string.match(pattern);

   482 expectedmatch = null;

   483 addThis();

   485 status = inSection(63);

   486 pattern = /[k]/i;

   487 string = 'AB';

   488 actualmatch = string.match(pattern);

   489 expectedmatch = null;

   490 addThis();

   492 status = inSection(64);

   493 pattern = /^(a\1?){4}$/;

   494 string = 'aaaaaaaaa';

   495 actualmatch = string.match(pattern);

   496 expectedmatch = null;

   497 addThis();

   499 status = inSection(65);

   500 pattern = /^(a\1?){4}$/;

   501 string = 'aaaaaaaaaaa';

   502 actualmatch = string.match(pattern);

   503 expectedmatch = null;

   504 addThis();

   506 /* ECMA doesn't support (?(

   507    status = inSection(66);

   508    pattern = /^(a(?(1)\1)){4}$/;

   509    string = 'aaaaaaaaa';

   510    actualmatch = string.match(pattern);

   511    expectedmatch = null;

   512    addThis();

   514    status = inSection(67);

   515    pattern = /^(a(?(1)\1)){4}$/;

   516    string = 'aaaaaaaaaaa';

   517    actualmatch = string.match(pattern);

   518    expectedmatch = null;

   519    addThis();

   520 */

   522 /* ECMA doesn't support (?<

   523    status = inSection(68);

   524    pattern = /(?<=a)b/;

   525    string = 'cb';

   526    actualmatch = string.match(pattern);

   527    expectedmatch = null;

   528    addThis();

   530    status = inSection(69);

   531    pattern = /(?<=a)b/;

   532    string = 'b';

   533    actualmatch = string.match(pattern);

   534    expectedmatch = null;

   535    addThis();

   537    status = inSection(70);

   538    pattern = /(?<!c)b/;

   539    string = 'cb';

   540    actualmatch = string.match(pattern);

   541    expectedmatch = null;

   542    addThis();

   543 */

   545 /* ECMA doesn't support (?(condition)

   546    status = inSection(71);

   547    pattern = /(?:(?i)a)b/;

   548    string = 'aB';

   549    actualmatch = string.match(pattern);

   550    expectedmatch = null;

   551    addThis();

   553    status = inSection(72);

   554    pattern = /((?i)a)b/;

   555    string = 'aB';

   556    actualmatch = string.match(pattern);

   557    expectedmatch = null;

   558    addThis();

   560    status = inSection(73);

   561    pattern = /(?i:a)b/;

   562    string = 'aB';

   563    actualmatch = string.match(pattern);

   564    expectedmatch = null;

   565    addThis();

   567    status = inSection(74);

   568    pattern = /((?i:a))b/;

   569    string = 'aB';

   570    actualmatch = string.match(pattern);

   571    expectedmatch = null;

   572    addThis();

   574    status = inSection(75);

   575    pattern = /(?:(?-i)a)b/i;

   576    string = 'Ab';

   577    actualmatch = string.match(pattern);

   578    expectedmatch = null;

   579    addThis();

   581    status = inSection(76);

   582    pattern = /((?-i)a)b/i;

   583    string = 'Ab';

   584    actualmatch = string.match(pattern);

   585    expectedmatch = null;

   586    addThis();

   588    status = inSection(77);

   589    pattern = /(?:(?-i)a)b/i;

   590    string = 'AB';

   591    actualmatch = string.match(pattern);

   592    expectedmatch = null;

   593    addThis();

   595    status = inSection(78);

   596    pattern = /((?-i)a)b/i;

   597    string = 'AB';

   598    actualmatch = string.match(pattern);

   599    expectedmatch = null;

   600    addThis();

   602    status = inSection(79);

   603    pattern = /(?-i:a)b/i;

   604    string = 'Ab';

   605    actualmatch = string.match(pattern);

   606    expectedmatch = null;

   607    addThis();

   609    status = inSection(80);

   610    pattern = /((?-i:a))b/i;

   611    string = 'Ab';

   612    actualmatch = string.match(pattern);

   613    expectedmatch = null;

   614    addThis();

   616    status = inSection(81);

   617    pattern = /(?-i:a)b/i;

   618    string = 'AB';

   619    actualmatch = string.match(pattern);

   620    expectedmatch = null;

   621    addThis();

   623    status = inSection(82);

   624    pattern = /((?-i:a))b/i;

   625    string = 'AB';

   626    actualmatch = string.match(pattern);

   627    expectedmatch = null;

   628    addThis();

   630    status = inSection(83);

   631    pattern = /((?-i:a.))b/i;

   632    string = 'a\nB';

   633    actualmatch = string.match(pattern);

   634    expectedmatch = null;

   635    addThis();

   637    status = inSection(84);

   638    pattern = /((?s-i:a.))b/i;

   639    string = 'B\nB';

   640    actualmatch = string.match(pattern);

   641    expectedmatch = null;

   642    addThis();

   643 */

   645 /* ECMA doesn't support (?<

   646    status = inSection(85);

   647    pattern = /(?<![cd])b/;

   648    string = 'dbcb';

   649    actualmatch = string.match(pattern);

   650    expectedmatch = null;

   651    addThis();

   653    status = inSection(86);

   654    pattern = /(?<!(c|d))b/;

   655    string = 'dbcb';

   656    actualmatch = string.match(pattern);

   657    expectedmatch = null;

   658    addThis();

   659 */

   661 status = inSection(87);

   662 pattern = /^(?:a?b?)*$/;

   663 string = 'a--';

   664 actualmatch = string.match(pattern);

   665 expectedmatch = null;

   666 addThis();

   668 status = inSection(88);

   669 pattern = /^b/;

   670 string = 'a\nb\nc\n';

   671 actualmatch = string.match(pattern);

   672 expectedmatch = null;

   673 addThis();

   675 status = inSection(89);

   676 pattern = /()^b/;

   677 string = 'a\nb\nc\n';

   678 actualmatch = string.match(pattern);

   679 expectedmatch = null;

   680 addThis();

   682 /* ECMA doesn't support (?(

   683    status = inSection(90);

   684    pattern = /(?(1)a|b)/;

   685    string = 'a';

   686    actualmatch = string.match(pattern);

   687    expectedmatch = null;

   688    addThis();

   690    status = inSection(91);

   691    pattern = /(x)?(?(1)a|b)/;

   692    string = 'a';

   693    actualmatch = string.match(pattern);

   694    expectedmatch = null;

   695    addThis();

   697    status = inSection(92);

   698    pattern = /()(?(1)b|a)/;

   699    string = 'a';

   700    actualmatch = string.match(pattern);

   701    expectedmatch = null;

   702    addThis();

   704    status = inSection(93);

   705    pattern = /^(\()?blah(?(1)(\)))$/;

   706    string = 'blah)';

   707    actualmatch = string.match(pattern);

   708    expectedmatch = null;

   709    addThis();

   711    status = inSection(94);

   712    pattern = /^(\()?blah(?(1)(\)))$/;

   713    string = '(blah';

   714    actualmatch = string.match(pattern);

   715    expectedmatch = null;

   716    addThis();

   718    status = inSection(95);

   719    pattern = /^(\(+)?blah(?(1)(\)))$/;

   720    string = 'blah)';

   721    actualmatch = string.match(pattern);

   722    expectedmatch = null;

   723    addThis();

   725    status = inSection(96);

   726    pattern = /^(\(+)?blah(?(1)(\)))$/;

   727    string = '(blah';

   728    actualmatch = string.match(pattern);

   729    expectedmatch = null;

   730    addThis();

   732    status = inSection(97);

   733    pattern = /(?(?{0})a|b)/;

   734    string = 'a';

   735    actualmatch = string.match(pattern);

   736    expectedmatch = null;

   737    addThis();

   739    status = inSection(98);

   740    pattern = /(?(?{1})b|a)/;

   741    string = 'a';

   742    actualmatch = string.match(pattern);

   743    expectedmatch = null;

   744    addThis();

   746    status = inSection(99);

   747    pattern = /(?(?!a)a|b)/;

   748    string = 'a';

   749    actualmatch = string.match(pattern);

   750    expectedmatch = null;

   751    addThis();

   753    status = inSection(100);

   754    pattern = /(?(?=a)b|a)/;

   755    string = 'a';

   756    actualmatch = string.match(pattern);

   757    expectedmatch = null;

   758    addThis();

   759 */

   761 status = inSection(101);

   762 pattern = /^(?=(a+?))\1ab/;

   763 string = 'aaab';

   764 actualmatch = string.match(pattern);

   765 expectedmatch = null;

   766 addThis();

   768 status = inSection(102);

   769 pattern = /^(?=(a+?))\1ab/;

   770 string = 'aaab';

   771 actualmatch = string.match(pattern);

   772 expectedmatch = null;

   773 addThis();

   775 status = inSection(103);

   776 pattern = /([\w:]+::)?(\w+)$/;

   777 string = 'abcd:';

   778 actualmatch = string.match(pattern);

   779 expectedmatch = null;

   780 addThis();

   782 status = inSection(104);

   783 pattern = /([\w:]+::)?(\w+)$/;

   784 string = 'abcd:';

   785 actualmatch = string.match(pattern);

   786 expectedmatch = null;

   787 addThis();

   789 status = inSection(105);

   790 pattern = /(>a+)ab/;

   791 string = 'aaab';

   792 actualmatch = string.match(pattern);

   793 expectedmatch = null;

   794 addThis();

   796 status = inSection(106);

   797 pattern = /a\Z/;

   798 string = 'a\nb\n';

   799 actualmatch = string.match(pattern);

   800 expectedmatch = null;

   801 addThis();

   803 status = inSection(107);

   804 pattern = /a\z/;

   805 string = 'a\nb\n';

   806 actualmatch = string.match(pattern);

   807 expectedmatch = null;

   808 addThis();

   810 status = inSection(108);

   811 pattern = /a$/;

   812 string = 'a\nb\n';

   813 actualmatch = string.match(pattern);

   814 expectedmatch = null;

   815 addThis();

   817 status = inSection(109);

   818 pattern = /a\z/;

   819 string = 'b\na\n';

   820 actualmatch = string.match(pattern);

   821 expectedmatch = null;

   822 addThis();

   824 status = inSection(110);

   825 pattern = /a\z/m;

   826 string = 'a\nb\n';

   827 actualmatch = string.match(pattern);

   828 expectedmatch = null;

   829 addThis();

   831 status = inSection(111);

   832 pattern = /a\z/m;

   833 string = 'b\na\n';

   834 actualmatch = string.match(pattern);

   835 expectedmatch = null;

   836 addThis();

   838 status = inSection(112);

   839 pattern = /aa\Z/;

   840 string = 'aa\nb\n';

   841 actualmatch = string.match(pattern);

   842 expectedmatch = null;

   843 addThis();

   845 status = inSection(113);

   846 pattern = /aa\z/;

   847 string = 'aa\nb\n';

   848 actualmatch = string.match(pattern);

   849 expectedmatch = null;

   850 addThis();

   852 status = inSection(114);

   853 pattern = /aa$/;

   854 string = 'aa\nb\n';

   855 actualmatch = string.match(pattern);

   856 expectedmatch = null;

   857 addThis();

   859 status = inSection(115);

   860 pattern = /aa\z/;

   861 string = 'b\naa\n';

   862 actualmatch = string.match(pattern);

   863 expectedmatch = null;

   864 addThis();

   866 status = inSection(116);

   867 pattern = /aa\z/m;

   868 string = 'aa\nb\n';

   869 actualmatch = string.match(pattern);

   870 expectedmatch = null;

   871 addThis();

   873 status = inSection(117);

   874 pattern = /aa\z/m;

   875 string = 'b\naa\n';

   876 actualmatch = string.match(pattern);

   877 expectedmatch = null;

   878 addThis();

   880 status = inSection(118);

   881 pattern = /aa\Z/;

   882 string = 'ac\nb\n';

   883 actualmatch = string.match(pattern);

   884 expectedmatch = null;

   885 addThis();

   887 status = inSection(119);

   888 pattern = /aa\z/;

   889 string = 'ac\nb\n';

   890 actualmatch = string.match(pattern);

   891 expectedmatch = null;

   892 addThis();

   894 status = inSection(120);

   895 pattern = /aa$/;

   896 string = 'ac\nb\n';

   897 actualmatch = string.match(pattern);

   898 expectedmatch = null;

   899 addThis();

   901 status = inSection(121);

   902 pattern = /aa\Z/;

   903 string = 'b\nac\n';

   904 actualmatch = string.match(pattern);

   905 expectedmatch = null;

   906 addThis();

   908 status = inSection(122);

   909 pattern = /aa\z/;

   910 string = 'b\nac\n';

   911 actualmatch = string.match(pattern);

   912 expectedmatch = null;

   913 addThis();

   915 status = inSection(123);

   916 pattern = /aa$/;

   917 string = 'b\nac\n';

   918 actualmatch = string.match(pattern);

   919 expectedmatch = null;

   920 addThis();

   922 status = inSection(124);

   923 pattern = /aa\Z/;

   924 string = 'b\nac';

   925 actualmatch = string.match(pattern);

   926 expectedmatch = null;

   927 addThis();

   929 status = inSection(125);

   930 pattern = /aa\z/;

   931 string = 'b\nac';

   932 actualmatch = string.match(pattern);

   933 expectedmatch = null;

   934 addThis();

   936 status = inSection(126);

   937 pattern = /aa$/;

   938 string = 'b\nac';

   939 actualmatch = string.match(pattern);

   940 expectedmatch = null;

   941 addThis();

   943 status = inSection(127);

   944 pattern = /aa\Z/m;

   945 string = 'ac\nb\n';

   946 actualmatch = string.match(pattern);

   947 expectedmatch = null;

   948 addThis();

   950 status = inSection(128);

   951 pattern = /aa\z/m;

   952 string = 'ac\nb\n';

   953 actualmatch = string.match(pattern);

   954 expectedmatch = null;

   955 addThis();

   957 status = inSection(129);

   958 pattern = /aa$/m;

   959 string = 'ac\nb\n';

   960 actualmatch = string.match(pattern);

   961 expectedmatch = null;

   962 addThis();

   964 status = inSection(130);

   965 pattern = /aa\Z/m;

   966 string = 'b\nac\n';

   967 actualmatch = string.match(pattern);

   968 expectedmatch = null;

   969 addThis();

   971 status = inSection(131);

   972 pattern = /aa\z/m;

   973 string = 'b\nac\n';

   974 actualmatch = string.match(pattern);

   975 expectedmatch = null;

   976 addThis();

   978 status = inSection(132);

   979 pattern = /aa$/m;

   980 string = 'b\nac\n';

   981 actualmatch = string.match(pattern);

   982 expectedmatch = null;

   983 addThis();

   985 status = inSection(133);

   986 pattern = /aa\Z/m;

   987 string = 'b\nac';

   988 actualmatch = string.match(pattern);

   989 expectedmatch = null;

   990 addThis();

   992 status = inSection(134);

   993 pattern = /aa\z/m;

   994 string = 'b\nac';

   995 actualmatch = string.match(pattern);

   996 expectedmatch = null;

   997 addThis();

   999 status = inSection(135);

  1000 pattern = /aa$/m;

  1001 string = 'b\nac';

  1002 actualmatch = string.match(pattern);

  1003 expectedmatch = null;

  1004 addThis();

  1006 status = inSection(136);

  1007 pattern = /aa\Z/;

  1008 string = 'ca\nb\n';

  1009 actualmatch = string.match(pattern);

  1010 expectedmatch = null;

  1011 addThis();

  1013 status = inSection(137);

  1014 pattern = /aa\z/;

  1015 string = 'ca\nb\n';

  1016 actualmatch = string.match(pattern);

  1017 expectedmatch = null;

  1018 addThis();

  1020 status = inSection(138);

  1021 pattern = /aa$/;

  1022 string = 'ca\nb\n';

  1023 actualmatch = string.match(pattern);

  1024 expectedmatch = null;

  1025 addThis();

  1027 status = inSection(139);

  1028 pattern = /aa\Z/;

  1029 string = 'b\nca\n';

  1030 actualmatch = string.match(pattern);

  1031 expectedmatch = null;

  1032 addThis();

  1034 status = inSection(140);

  1035 pattern = /aa\z/;

  1036 string = 'b\nca\n';

  1037 actualmatch = string.match(pattern);

  1038 expectedmatch = null;

  1039 addThis();

  1041 status = inSection(141);

  1042 pattern = /aa$/;

  1043 string = 'b\nca\n';

  1044 actualmatch = string.match(pattern);

  1045 expectedmatch = null;

  1046 addThis();

  1048 status = inSection(142);

  1049 pattern = /aa\Z/;

  1050 string = 'b\nca';

  1051 actualmatch = string.match(pattern);

  1052 expectedmatch = null;

  1053 addThis();

  1055 status = inSection(143);

  1056 pattern = /aa\z/;

  1057 string = 'b\nca';

  1058 actualmatch = string.match(pattern);

  1059 expectedmatch = null;

  1060 addThis();

  1062 status = inSection(144);

  1063 pattern = /aa$/;

  1064 string = 'b\nca';

  1065 actualmatch = string.match(pattern);

  1066 expectedmatch = null;

  1067 addThis();

  1069 status = inSection(145);

  1070 pattern = /aa\Z/m;

  1071 string = 'ca\nb\n';

  1072 actualmatch = string.match(pattern);

  1073 expectedmatch = null;

  1074 addThis();

  1076 status = inSection(146);

  1077 pattern = /aa\z/m;

  1078 string = 'ca\nb\n';

  1079 actualmatch = string.match(pattern);

  1080 expectedmatch = null;

  1081 addThis();

  1083 status = inSection(147);

  1084 pattern = /aa$/m;

  1085 string = 'ca\nb\n';

  1086 actualmatch = string.match(pattern);

  1087 expectedmatch = null;

  1088 addThis();

  1090 status = inSection(148);

  1091 pattern = /aa\Z/m;

  1092 string = 'b\nca\n';

  1093 actualmatch = string.match(pattern);

  1094 expectedmatch = null;

  1095 addThis();

  1097 status = inSection(149);

  1098 pattern = /aa\z/m;

  1099 string = 'b\nca\n';

  1100 actualmatch = string.match(pattern);

  1101 expectedmatch = null;

  1102 addThis();

  1104 status = inSection(150);

  1105 pattern = /aa$/m;

  1106 string = 'b\nca\n';

  1107 actualmatch = string.match(pattern);

  1108 expectedmatch = null;

  1109 addThis();

  1111 status = inSection(151);

  1112 pattern = /aa\Z/m;

  1113 string = 'b\nca';

  1114 actualmatch = string.match(pattern);

  1115 expectedmatch = null;

  1116 addThis();

  1118 status = inSection(152);

  1119 pattern = /aa\z/m;

  1120 string = 'b\nca';

  1121 actualmatch = string.match(pattern);

  1122 expectedmatch = null;

  1123 addThis();

  1125 status = inSection(153);

  1126 pattern = /aa$/m;

  1127 string = 'b\nca';

  1128 actualmatch = string.match(pattern);

  1129 expectedmatch = null;

  1130 addThis();

  1132 status = inSection(154);

  1133 pattern = /ab\Z/;

  1134 string = 'ab\nb\n';

  1135 actualmatch = string.match(pattern);

  1136 expectedmatch = null;

  1137 addThis();

  1139 status = inSection(155);

  1140 pattern = /ab\z/;

  1141 string = 'ab\nb\n';

  1142 actualmatch = string.match(pattern);

  1143 expectedmatch = null;

  1144 addThis();

  1146 status = inSection(156);

  1147 pattern = /ab$/;

  1148 string = 'ab\nb\n';

  1149 actualmatch = string.match(pattern);

  1150 expectedmatch = null;

  1151 addThis();

  1153 status = inSection(157);

  1154 pattern = /ab\z/;

  1155 string = 'b\nab\n';

  1156 actualmatch = string.match(pattern);

  1157 expectedmatch = null;

  1158 addThis();

  1160 status = inSection(158);

  1161 pattern = /ab\z/m;

  1162 string = 'ab\nb\n';

  1163 actualmatch = string.match(pattern);

  1164 expectedmatch = null;

  1165 addThis();

  1167 status = inSection(159);

  1168 pattern = /ab\z/m;

  1169 string = 'b\nab\n';

  1170 actualmatch = string.match(pattern);

  1171 expectedmatch = null;

  1172 addThis();

  1174 status = inSection(160);

  1175 pattern = /ab\Z/;

  1176 string = 'ac\nb\n';

  1177 actualmatch = string.match(pattern);

  1178 expectedmatch = null;

  1179 addThis();

  1181 status = inSection(161);

  1182 pattern = /ab\z/;

  1183 string = 'ac\nb\n';

  1184 actualmatch = string.match(pattern);

  1185 expectedmatch = null;

  1186 addThis();

  1188 status = inSection(162);

  1189 pattern = /ab$/;

  1190 string = 'ac\nb\n';

  1191 actualmatch = string.match(pattern);

  1192 expectedmatch = null;

  1193 addThis();

  1195 status = inSection(163);

  1196 pattern = /ab\Z/;

  1197 string = 'b\nac\n';

  1198 actualmatch = string.match(pattern);

  1199 expectedmatch = null;

  1200 addThis();

  1202 status = inSection(164);

  1203 pattern = /ab\z/;

  1204 string = 'b\nac\n';

  1205 actualmatch = string.match(pattern);

  1206 expectedmatch = null;

  1207 addThis();

  1209 status = inSection(165);

  1210 pattern = /ab$/;

  1211 string = 'b\nac\n';

  1212 actualmatch = string.match(pattern);

  1213 expectedmatch = null;

  1214 addThis();

  1216 status = inSection(166);

  1217 pattern = /ab\Z/;

  1218 string = 'b\nac';

  1219 actualmatch = string.match(pattern);

  1220 expectedmatch = null;

  1221 addThis();

  1223 status = inSection(167);

  1224 pattern = /ab\z/;

  1225 string = 'b\nac';

  1226 actualmatch = string.match(pattern);

  1227 expectedmatch = null;

  1228 addThis();

  1230 status = inSection(168);

  1231 pattern = /ab$/;

  1232 string = 'b\nac';

  1233 actualmatch = string.match(pattern);

  1234 expectedmatch = null;

  1235 addThis();

  1237 status = inSection(169);

  1238 pattern = /ab\Z/m;

  1239 string = 'ac\nb\n';

  1240 actualmatch = string.match(pattern);

  1241 expectedmatch = null;

  1242 addThis();

  1244 status = inSection(170);

  1245 pattern = /ab\z/m;

  1246 string = 'ac\nb\n';

  1247 actualmatch = string.match(pattern);

  1248 expectedmatch = null;

  1249 addThis();

  1251 status = inSection(171);

  1252 pattern = /ab$/m;

  1253 string = 'ac\nb\n';

  1254 actualmatch = string.match(pattern);

  1255 expectedmatch = null;

  1256 addThis();

  1258 status = inSection(172);

  1259 pattern = /ab\Z/m;

  1260 string = 'b\nac\n';

  1261 actualmatch = string.match(pattern);

  1262 expectedmatch = null;

  1263 addThis();

  1265 status = inSection(173);

  1266 pattern = /ab\z/m;

  1267 string = 'b\nac\n';

  1268 actualmatch = string.match(pattern);

  1269 expectedmatch = null;

  1270 addThis();

  1272 status = inSection(174);

  1273 pattern = /ab$/m;

  1274 string = 'b\nac\n';

  1275 actualmatch = string.match(pattern);

  1276 expectedmatch = null;

  1277 addThis();

  1279 status = inSection(175);

  1280 pattern = /ab\Z/m;

  1281 string = 'b\nac';

  1282 actualmatch = string.match(pattern);

  1283 expectedmatch = null;

  1284 addThis();

  1286 status = inSection(176);

  1287 pattern = /ab\z/m;

  1288 string = 'b\nac';

  1289 actualmatch = string.match(pattern);

  1290 expectedmatch = null;

  1291 addThis();

  1293 status = inSection(177);

  1294 pattern = /ab$/m;

  1295 string = 'b\nac';

  1296 actualmatch = string.match(pattern);

  1297 expectedmatch = null;

  1298 addThis();

  1300 status = inSection(178);

  1301 pattern = /ab\Z/;

  1302 string = 'ca\nb\n';

  1303 actualmatch = string.match(pattern);

  1304 expectedmatch = null;

  1305 addThis();

  1307 status = inSection(179);

  1308 pattern = /ab\z/;

  1309 string = 'ca\nb\n';

  1310 actualmatch = string.match(pattern);

  1311 expectedmatch = null;

  1312 addThis();

  1314 status = inSection(180);

  1315 pattern = /ab$/;

  1316 string = 'ca\nb\n';

  1317 actualmatch = string.match(pattern);

  1318 expectedmatch = null;

  1319 addThis();

  1321 status = inSection(181);

  1322 pattern = /ab\Z/;

  1323 string = 'b\nca\n';

  1324 actualmatch = string.match(pattern);

  1325 expectedmatch = null;

  1326 addThis();

  1328 status = inSection(182);

  1329 pattern = /ab\z/;

  1330 string = 'b\nca\n';

  1331 actualmatch = string.match(pattern);

  1332 expectedmatch = null;

  1333 addThis();

  1335 status = inSection(183);

  1336 pattern = /ab$/;

  1337 string = 'b\nca\n';

  1338 actualmatch = string.match(pattern);

  1339 expectedmatch = null;

  1340 addThis();

  1342 status = inSection(184);

  1343 pattern = /ab\Z/;

  1344 string = 'b\nca';

  1345 actualmatch = string.match(pattern);

  1346 expectedmatch = null;

  1347 addThis();

  1349 status = inSection(185);

  1350 pattern = /ab\z/;

  1351 string = 'b\nca';

  1352 actualmatch = string.match(pattern);

  1353 expectedmatch = null;

  1354 addThis();

  1356 status = inSection(186);

  1357 pattern = /ab$/;

  1358 string = 'b\nca';

  1359 actualmatch = string.match(pattern);

  1360 expectedmatch = null;

  1361 addThis();

  1363 status = inSection(187);

  1364 pattern = /ab\Z/m;

  1365 string = 'ca\nb\n';

  1366 actualmatch = string.match(pattern);

  1367 expectedmatch = null;

  1368 addThis();

  1370 status = inSection(188);

  1371 pattern = /ab\z/m;

  1372 string = 'ca\nb\n';

  1373 actualmatch = string.match(pattern);

  1374 expectedmatch = null;

  1375 addThis();

  1377 status = inSection(189);

  1378 pattern = /ab$/m;

  1379 string = 'ca\nb\n';

  1380 actualmatch = string.match(pattern);

  1381 expectedmatch = null;

  1382 addThis();

  1384 status = inSection(190);

  1385 pattern = /ab\Z/m;

  1386 string = 'b\nca\n';

  1387 actualmatch = string.match(pattern);

  1388 expectedmatch = null;

  1389 addThis();

  1391 status = inSection(191);

  1392 pattern = /ab\z/m;

  1393 string = 'b\nca\n';

  1394 actualmatch = string.match(pattern);

  1395 expectedmatch = null;

  1396 addThis();

  1398 status = inSection(192);

  1399 pattern = /ab$/m;

  1400 string = 'b\nca\n';

  1401 actualmatch = string.match(pattern);

  1402 expectedmatch = null;

  1403 addThis();

  1405 status = inSection(193);

  1406 pattern = /ab\Z/m;

  1407 string = 'b\nca';

  1408 actualmatch = string.match(pattern);

  1409 expectedmatch = null;

  1410 addThis();

  1412 status = inSection(194);

  1413 pattern = /ab\z/m;

  1414 string = 'b\nca';

  1415 actualmatch = string.match(pattern);

  1416 expectedmatch = null;

  1417 addThis();

  1419 status = inSection(195);

  1420 pattern = /ab$/m;

  1421 string = 'b\nca';

  1422 actualmatch = string.match(pattern);

  1423 expectedmatch = null;

  1424 addThis();

  1426 status = inSection(196);

  1427 pattern = /abb\Z/;

  1428 string = 'abb\nb\n';

  1429 actualmatch = string.match(pattern);

  1430 expectedmatch = null;

  1431 addThis();

  1433 status = inSection(197);

  1434 pattern = /abb\z/;

  1435 string = 'abb\nb\n';

  1436 actualmatch = string.match(pattern);

  1437 expectedmatch = null;

  1438 addThis();

  1440 status = inSection(198);

  1441 pattern = /abb$/;

  1442 string = 'abb\nb\n';

  1443 actualmatch = string.match(pattern);

  1444 expectedmatch = null;

  1445 addThis();

  1447 status = inSection(199);

  1448 pattern = /abb\z/;

  1449 string = 'b\nabb\n';

  1450 actualmatch = string.match(pattern);

  1451 expectedmatch = null;

  1452 addThis();

  1454 status = inSection(200);

  1455 pattern = /abb\z/m;

  1456 string = 'abb\nb\n';

  1457 actualmatch = string.match(pattern);

  1458 expectedmatch = null;

  1459 addThis();

  1461 status = inSection(201);

  1462 pattern = /abb\z/m;

  1463 string = 'b\nabb\n';

  1464 actualmatch = string.match(pattern);

  1465 expectedmatch = null;

  1466 addThis();

  1468 status = inSection(202);

  1469 pattern = /abb\Z/;

  1470 string = 'ac\nb\n';

  1471 actualmatch = string.match(pattern);

  1472 expectedmatch = null;

  1473 addThis();

  1475 status = inSection(203);

  1476 pattern = /abb\z/;

  1477 string = 'ac\nb\n';

  1478 actualmatch = string.match(pattern);

  1479 expectedmatch = null;

  1480 addThis();

  1482 status = inSection(204);

  1483 pattern = /abb$/;

  1484 string = 'ac\nb\n';

  1485 actualmatch = string.match(pattern);

  1486 expectedmatch = null;

  1487 addThis();

  1489 status = inSection(205);

  1490 pattern = /abb\Z/;

  1491 string = 'b\nac\n';

  1492 actualmatch = string.match(pattern);

  1493 expectedmatch = null;

  1494 addThis();

  1496 status = inSection(206);

  1497 pattern = /abb\z/;

  1498 string = 'b\nac\n';

  1499 actualmatch = string.match(pattern);

  1500 expectedmatch = null;

  1501 addThis();

  1503 status = inSection(207);

  1504 pattern = /abb$/;

  1505 string = 'b\nac\n';

  1506 actualmatch = string.match(pattern);

  1507 expectedmatch = null;

  1508 addThis();

  1510 status = inSection(208);

  1511 pattern = /abb\Z/;

  1512 string = 'b\nac';

  1513 actualmatch = string.match(pattern);

  1514 expectedmatch = null;

  1515 addThis();

  1517 status = inSection(209);

  1518 pattern = /abb\z/;

  1519 string = 'b\nac';

  1520 actualmatch = string.match(pattern);

  1521 expectedmatch = null;

  1522 addThis();

  1524 status = inSection(210);

  1525 pattern = /abb$/;

  1526 string = 'b\nac';

  1527 actualmatch = string.match(pattern);

  1528 expectedmatch = null;

  1529 addThis();

  1531 status = inSection(211);

  1532 pattern = /abb\Z/m;

  1533 string = 'ac\nb\n';

  1534 actualmatch = string.match(pattern);

  1535 expectedmatch = null;

  1536 addThis();

  1538 status = inSection(212);

  1539 pattern = /abb\z/m;

  1540 string = 'ac\nb\n';

  1541 actualmatch = string.match(pattern);

  1542 expectedmatch = null;

  1543 addThis();

  1545 status = inSection(213);

  1546 pattern = /abb$/m;

  1547 string = 'ac\nb\n';

  1548 actualmatch = string.match(pattern);

  1549 expectedmatch = null;

  1550 addThis();

  1552 status = inSection(214);

  1553 pattern = /abb\Z/m;

  1554 string = 'b\nac\n';

  1555 actualmatch = string.match(pattern);

  1556 expectedmatch = null;

  1557 addThis();

  1559 status = inSection(215);

  1560 pattern = /abb\z/m;

  1561 string = 'b\nac\n';

  1562 actualmatch = string.match(pattern);

  1563 expectedmatch = null;

  1564 addThis();

  1566 status = inSection(216);

  1567 pattern = /abb$/m;

  1568 string = 'b\nac\n';

  1569 actualmatch = string.match(pattern);

  1570 expectedmatch = null;

  1571 addThis();

  1573 status = inSection(217);

  1574 pattern = /abb\Z/m;

  1575 string = 'b\nac';

  1576 actualmatch = string.match(pattern);

  1577 expectedmatch = null;

  1578 addThis();

  1580 status = inSection(218);

  1581 pattern = /abb\z/m;

  1582 string = 'b\nac';

  1583 actualmatch = string.match(pattern);

  1584 expectedmatch = null;

  1585 addThis();

  1587 status = inSection(219);

  1588 pattern = /abb$/m;

  1589 string = 'b\nac';

  1590 actualmatch = string.match(pattern);

  1591 expectedmatch = null;

  1592 addThis();

  1594 status = inSection(220);

  1595 pattern = /abb\Z/;

  1596 string = 'ca\nb\n';

  1597 actualmatch = string.match(pattern);

  1598 expectedmatch = null;

  1599 addThis();

  1601 status = inSection(221);

  1602 pattern = /abb\z/;

  1603 string = 'ca\nb\n';

  1604 actualmatch = string.match(pattern);

  1605 expectedmatch = null;

  1606 addThis();

  1608 status = inSection(222);

  1609 pattern = /abb$/;

  1610 string = 'ca\nb\n';

  1611 actualmatch = string.match(pattern);

  1612 expectedmatch = null;

  1613 addThis();

  1615 status = inSection(223);

  1616 pattern = /abb\Z/;

  1617 string = 'b\nca\n';

  1618 actualmatch = string.match(pattern);

  1619 expectedmatch = null;

  1620 addThis();

  1622 status = inSection(224);

  1623 pattern = /abb\z/;

  1624 string = 'b\nca\n';

  1625 actualmatch = string.match(pattern);

  1626 expectedmatch = null;

  1627 addThis();

  1629 status = inSection(225);

  1630 pattern = /abb$/;

  1631 string = 'b\nca\n';

  1632 actualmatch = string.match(pattern);

  1633 expectedmatch = null;

  1634 addThis();

  1636 status = inSection(226);

  1637 pattern = /abb\Z/;

  1638 string = 'b\nca';

  1639 actualmatch = string.match(pattern);

  1640 expectedmatch = null;

  1641 addThis();

  1643 status = inSection(227);

  1644 pattern = /abb\z/;

  1645 string = 'b\nca';

  1646 actualmatch = string.match(pattern);

  1647 expectedmatch = null;

  1648 addThis();

  1650 status = inSection(228);

  1651 pattern = /abb$/;

  1652 string = 'b\nca';

  1653 actualmatch = string.match(pattern);

  1654 expectedmatch = null;

  1655 addThis();

  1657 status = inSection(229);

  1658 pattern = /abb\Z/m;

  1659 string = 'ca\nb\n';

  1660 actualmatch = string.match(pattern);

  1661 expectedmatch = null;

  1662 addThis();

  1664 status = inSection(230);

  1665 pattern = /abb\z/m;

  1666 string = 'ca\nb\n';

  1667 actualmatch = string.match(pattern);

  1668 expectedmatch = null;

  1669 addThis();

  1671 status = inSection(231);

  1672 pattern = /abb$/m;

  1673 string = 'ca\nb\n';

  1674 actualmatch = string.match(pattern);

  1675 expectedmatch = null;

  1676 addThis();

  1678 status = inSection(232);

  1679 pattern = /abb\Z/m;

  1680 string = 'b\nca\n';

  1681 actualmatch = string.match(pattern);

  1682 expectedmatch = null;

  1683 addThis();

  1685 status = inSection(233);

  1686 pattern = /abb\z/m;

  1687 string = 'b\nca\n';

  1688 actualmatch = string.match(pattern);

  1689 expectedmatch = null;

  1690 addThis();

  1692 status = inSection(234);

  1693 pattern = /abb$/m;

  1694 string = 'b\nca\n';

  1695 actualmatch = string.match(pattern);

  1696 expectedmatch = null;

  1697 addThis();

  1699 status = inSection(235);

  1700 pattern = /abb\Z/m;

  1701 string = 'b\nca';

  1702 actualmatch = string.match(pattern);

  1703 expectedmatch = null;

  1704 addThis();

  1706 status = inSection(236);

  1707 pattern = /abb\z/m;

  1708 string = 'b\nca';

  1709 actualmatch = string.match(pattern);

  1710 expectedmatch = null;

  1711 addThis();

  1713 status = inSection(237);

  1714 pattern = /abb$/m;

  1715 string = 'b\nca';

  1716 actualmatch = string.match(pattern);

  1717 expectedmatch = null;

  1718 addThis();

  1720 status = inSection(238);

  1721 pattern = /a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz/;

  1722 string = 'x';

  1723 actualmatch = string.match(pattern);

  1724 expectedmatch = null;

  1725 addThis();

  1727 status = inSection(239);

  1728 pattern = /\GX.*X/;

  1729 string = 'aaaXbX';

  1730 actualmatch = string.match(pattern);

  1731 expectedmatch = null;

  1732 addThis();

  1734 status = inSection(240);

  1735 pattern = /\.c(pp|xx|c)?$/i;

  1736 string = 'Changes';

  1737 actualmatch = string.match(pattern);

  1738 expectedmatch = null;

  1739 addThis();

  1741 status = inSection(241);

  1742 pattern = /^([a-z]:)/;

  1743 string = 'C:/';

  1744 actualmatch = string.match(pattern);

  1745 expectedmatch = null;

  1746 addThis();

  1748 status = inSection(242);

  1749 pattern = /(\w)?(abc)\1b/;

  1750 string = 'abcab';

  1751 actualmatch = string.match(pattern);

  1752 expectedmatch = null;

  1753 addThis();

  1755 /* ECMA doesn't support (?(

  1756    status = inSection(243);

  1757    pattern = /^(a)?(?(1)a|b)+$/;

  1758    string = 'a';

  1759    actualmatch = string.match(pattern);

  1760    expectedmatch = null;

  1761    addThis();

  1762 */

  1766 //-----------------------------------------------------------------------------

  1767 test();

  1768 //-----------------------------------------------------------------------------

  1772 function addThis()

  1773 {

  1774   if(omitCurrentSection())

  1775     return;

  1777   statusmessages[i] = status;

  1778   patterns[i] = pattern;

  1779   strings[i] = string;

  1780   actualmatches[i] = actualmatch;

  1781   expectedmatches[i] = expectedmatch;

  1782   i++;

  1783 }

  1786 function omitCurrentSection()

  1787 {

  1788   try

  1789   {

  1790     // current section number is in global status variable

  1791     var n = status.match(/(\d+)/)[1];

  1792     return ((n < cnLBOUND) || (n > cnUBOUND));

  1793   }

  1794   catch(e)

  1795   {

  1796     return false;

  1797   }

  1798 }

  1801 function test()

  1802 {

  1803   enterFunc ('test');

  1804   printBugNumber(BUGNUMBER);

  1805   printStatus (summary);

  1806   testRegExp(statusmessages, patterns, strings, actualmatches, expectedmatches);

  1807   exitFunc ('test');

  1808 }

The Tor Browser / file revision

js/src/tests/ecma_3/RegExp/perlstress-002.js@129ffea94266

js/src/tests/ecma_3/RegExp/perlstress-002.js