How to use exec method in Appium Android Driver

Best JavaScript code snippet using appium-android-driver

regexp-pcre.js

Source:regexp-pcre.js Github

copy

Full Screen

...1638res[1563] = /[^a]/m;1639res[1564] = /[^\xaa]/m;1640res[1565] = /[^\xaa]/m;1641res[1566] = / End of testinput10 /;1642assertToStringEquals("abc", res[1].exec("abc"), 0);1643assertToStringEquals("abc", res[1].exec("defabc"), 1);1644assertToStringEquals("abc", res[1].exec("Aabc"), 2);1645assertNull(res[1].exec("*** Failers", 3));1646assertToStringEquals("abc", res[1].exec("Adefabc"), 4);1647assertToStringEquals("ABC", res[1].exec("ABC"), 5);1648assertToStringEquals("abc", res[2].exec("abc"), 6);1649assertNull(res[2].exec("Aabc", 7));1650assertNull(res[2].exec("*** Failers", 8));1651assertNull(res[2].exec("defabc", 9));1652assertNull(res[2].exec("Adefabc", 10));1653assertToStringEquals("abc", res[7].exec("abc"), 11);1654assertNull(res[7].exec("*** Failers", 12));1655assertNull(res[7].exec("def\nabc", 13));1656assertThrows("var re = /x{5,4}/;");1657assertThrows("var re = /[abcd/;");1658assertThrows("var re = /[z-a]/;");1659assertThrows("var re = /^*/;");1660assertThrows("var re = /(abc/;");1661assertThrows("var re = /(?# abc/;");1662assertToStringEquals("cat", res[11].exec("this sentence eventually mentions a cat"), 20);1663assertToStringEquals("elephant", res[11].exec("this sentences rambles on and on for a while and then reaches elephant"), 21);1664assertToStringEquals("cat", res[12].exec("this sentence eventually mentions a cat"), 22);1665assertToStringEquals("elephant", res[12].exec("this sentences rambles on and on for a while and then reaches elephant"), 23);1666assertToStringEquals("CAT", res[13].exec("this sentence eventually mentions a CAT cat"), 24);1667assertToStringEquals("elephant", res[13].exec("this sentences rambles on and on for a while to elephant ElePhant"), 25);1668assertThrows("var re = /{4,5}abc/;");1669assertToStringEquals("abcb,a,b,c", res[18].exec("abcb"), 27);1670assertToStringEquals("abcb,a,b,c", res[18].exec("O0abcb"), 28);1671assertToStringEquals("abcb,a,b,c", res[18].exec("O3abcb"), 29);1672assertToStringEquals("abcb,a,b,c", res[18].exec("O6abcb"), 30);1673assertToStringEquals("abcb,a,b,c", res[18].exec("O9abcb"), 31);1674assertToStringEquals("abcb,a,b,c", res[18].exec("O12abcb"), 32);1675assertToStringEquals("abc,a,,", res[19].exec("abc"), 33);1676assertToStringEquals("abc,a,,", res[19].exec("O0abc"), 34);1677assertToStringEquals("abc,a,,", res[19].exec("O3abc"), 35);1678assertToStringEquals("abc,a,,", res[19].exec("O6abc"), 36);1679assertToStringEquals("aba,,a,b", res[19].exec("aba"), 37);1680assertToStringEquals("aba,,a,b", res[19].exec("O0aba"), 38);1681assertToStringEquals("aba,,a,b", res[19].exec("O3aba"), 39);1682assertToStringEquals("aba,,a,b", res[19].exec("O6aba"), 40);1683assertToStringEquals("aba,,a,b", res[19].exec("O9aba"), 41);1684assertToStringEquals("aba,,a,b", res[19].exec("O12aba"), 42);1685assertToStringEquals("abc", res[20].exec("abc"), 43);1686assertNull(res[20].exec("*** Failers", 44));1687assertNull(res[20].exec("abc\n", 45));1688assertNull(res[20].exec("abc\ndef", 46));1689assertToStringEquals("the quick brown fox", res[22].exec("the quick brown fox"), 47);1690assertToStringEquals("the quick brown fox", res[22].exec("this is a line with the quick brown fox"), 48);1691assertToStringEquals("abc", res[23].exec("abcdef"), 49);1692assertToStringEquals("abc", res[23].exec("abcdefB"), 50);1693assertToStringEquals("defabc,abc,abc,", res[24].exec("defabc"), 51);1694assertToStringEquals("Zdefabc,abc,abc,", res[24].exec("Zdefabc"), 52);1695assertToStringEquals("abc", res[25].exec("abc"), 53);1696assertNull(res[25].exec("*** Failers", 54));1697assertToStringEquals("abc", res[26].exec("abcdef"), 55);1698assertToStringEquals("abc", res[26].exec("abcdefB"), 56);1699assertToStringEquals("defabc,abc,abc,", res[27].exec("defabc"), 57);1700assertToStringEquals("Zdefabc,abc,abc,", res[27].exec("Zdefabc"), 58);1701assertToStringEquals("the quick brown fox", res[28].exec("the quick brown fox"), 59);1702assertNull(res[28].exec("*** Failers", 60));1703assertToStringEquals("The Quick Brown Fox", res[28].exec("The Quick Brown Fox"), 61);1704assertToStringEquals("the quick brown fox", res[29].exec("the quick brown fox"), 62);1705assertToStringEquals("The Quick Brown Fox", res[29].exec("The Quick Brown Fox"), 63);1706assertNull(res[30].exec("*** Failers", 64));1707assertNull(res[30].exec("abc\ndef", 65));1708assertToStringEquals("abc", res[31].exec("abc"), 66);1709assertNull(res[31].exec("abc\n", 67));1710assertToStringEquals("abc,abc", res[33].exec("abc"), 68);1711assertThrows("var re = /)/;");1712assertToStringEquals("-pr", res[35].exec("co-processors, and for"), 70);1713assertToStringEquals("<def>ghi<klm>", res[36].exec("abc<def>ghi<klm>nop"), 71);1714assertToStringEquals("<def>", res[37].exec("abc<def>ghi<klm>nop"), 72);1715assertToStringEquals("<def>", res[37].exec("abc<def>ghi<klm>nop"), 73);1716assertNull(res[37].exec("abc========def", 74));1717assertNull(res[37].exec("foo", 75));1718assertNull(res[37].exec("catfoo", 76));1719assertNull(res[37].exec("*** Failers", 77));1720assertNull(res[37].exec("the barfoo", 78));1721assertNull(res[37].exec("and cattlefoo", 79));1722assertToStringEquals("a", res[40].exec("a"), 80);1723assertNull(res[40].exec("a\n", 81));1724assertNull(res[40].exec("*** Failers", 82));1725assertToStringEquals("a", res[40].exec("Za"), 83);1726assertNull(res[40].exec("Za\n", 84));1727assertToStringEquals("a", res[41].exec("a"), 85);1728assertToStringEquals("a", res[41].exec("a\n"), 86);1729assertToStringEquals("a", res[41].exec("Za\n"), 87);1730assertNull(res[41].exec("*** Failers", 88));1731assertToStringEquals("a", res[41].exec("Za"), 89);1732assertToStringEquals("b", res[44].exec("foo\nbarbar"), 90);1733assertToStringEquals("a", res[44].exec("***Failers"), 91);1734assertToStringEquals("b", res[44].exec("rhubarb"), 92);1735assertToStringEquals("b", res[44].exec("barbell"), 93);1736assertToStringEquals("a", res[44].exec("abc\nbarton"), 94);1737assertToStringEquals("b", res[44].exec("foo\nbarbar"), 95);1738assertToStringEquals("a", res[44].exec("***Failers"), 96);1739assertToStringEquals("b", res[44].exec("rhubarb"), 97);1740assertToStringEquals("b", res[44].exec("barbell"), 98);1741assertToStringEquals("a", res[44].exec("abc\nbarton"), 99);1742assertToStringEquals("a", res[44].exec("abc"), 100);1743assertToStringEquals("a", res[44].exec("def\nabc"), 101);1744assertToStringEquals("a", res[44].exec("*** Failers"), 102);1745assertToStringEquals("a", res[44].exec("defabc"), 103);1746assertNull(res[45].exec("the bullock-cart", 104));1747assertNull(res[45].exec("a donkey-cart race", 105));1748assertNull(res[45].exec("*** Failers", 106));1749assertNull(res[45].exec("cart", 107));1750assertNull(res[45].exec("horse-and-cart", 108));1751assertNull(res[45].exec("alphabetabcd", 109));1752assertNull(res[45].exec("endingxyz", 110));1753assertNull(res[45].exec("abxyZZ", 111));1754assertNull(res[45].exec("abXyZZ", 112));1755assertNull(res[45].exec("ZZZ", 113));1756assertNull(res[45].exec("zZZ", 114));1757assertNull(res[45].exec("bZZ", 115));1758assertNull(res[45].exec("BZZ", 116));1759assertNull(res[45].exec("*** Failers", 117));1760assertNull(res[45].exec("ZZ", 118));1761assertNull(res[45].exec("abXYZZ", 119));1762assertNull(res[45].exec("zzz", 120));1763assertNull(res[45].exec("bzz", 121));1764assertNull(res[45].exec("bar", 122));1765assertNull(res[45].exec("foobbar", 123));1766assertNull(res[45].exec("*** Failers", 124));1767assertNull(res[45].exec("fooabar", 125));1768assertNull(res[46].exec("*** Failers", 126));1769assertNull(res[46].exec("a", 127));1770assertNull(res[48].exec("aaaaaa", 128));1771assertThrows("var re = /a[b-a]/;");1772assertThrows("var re = /a[/;");1773assertThrows("var re = /*a/;");1774assertThrows("var re = /abc)/;");1775assertThrows("var re = /(abc/;");1776assertThrows("var re = /a**/;");1777assertThrows("var re = /)(/;");1778assertThrows("var re = /a[b-a]/;");1779assertThrows("var re = /a[/;");1780assertThrows("var re = /*a/;");1781assertThrows("var re = /abc)/;");1782assertThrows("var re = /(abc/;");1783assertThrows("var re = /a**/;");1784assertThrows("var re = /)(/;");1785assertThrows("var re = /:(?:/;");1786assertThrows("var re = /a(?{)b/;");1787assertThrows("var re = /a(?{{})b/;");1788assertThrows("var re = /a(?{}})b/;");1789assertThrows("var re = /a(?{\"{\"})b/;");1790assertThrows("var re = /a(?{\"{\"}})b/;");1791assertThrows("var re = /[a[:xyz:/;");1792assertThrows("var re = /a{37,17}/;");1793assertToStringEquals("abcd,a,d", res[58].exec("abcd"), 151);1794assertToStringEquals("abcd,a,d", res[58].exec("abcdC2"), 152);1795assertToStringEquals("abcd,a,d", res[58].exec("abcdC5"), 153);1796assertToStringEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyz"), 154);1797assertToStringEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyzC1"), 155);1798assertToStringEquals("abcdefghijklmnopqrst,abcdefghijklmnopqrst", res[59].exec("abcdefghijklmnopqrstuvwxyzG1"), 156);1799assertToStringEquals("abcdefghijklmno,abcdefghijklmno", res[60].exec("abcdefghijklmnopqrstuvwxyz"), 157);1800assertToStringEquals("abcdefghijklmno,abcdefghijklmno", res[60].exec("abcdefghijklmnopqrstuvwxyzC1G1"), 158);1801assertToStringEquals("abcdefghijklmnop,abcdefghijklmnop", res[61].exec("abcdefghijklmnopqrstuvwxyz"), 159);1802assertToStringEquals("abcdefghijklmnop,abcdefghijklmnop", res[61].exec("abcdefghijklmnopqrstuvwxyzC1G1L"), 160);1803assertToStringEquals("adef,a,,f", res[62].exec("adefG1G2G3G4L"), 161);1804assertToStringEquals("bcdef,bc,bc,f", res[62].exec("bcdefG1G2G3G4L"), 162);1805assertToStringEquals("adef,a,,f", res[62].exec("adefghijkC0"), 163);1806assertToStringEquals("abc\x00def", res[63].exec("abc\x00defLC0"), 164);1807assertToStringEquals("iss", res[69].exec("Mississippi"), 165);1808assertToStringEquals("iss", res[70].exec("Mississippi"), 166);1809assertToStringEquals("iss", res[71].exec("Mississippi"), 167);1810assertToStringEquals("iss", res[72].exec("Mississippi"), 168);1811assertToStringEquals("iss", res[73].exec("Mississippi"), 169);1812assertNull(res[73].exec("*** Failers", 170));1813assertToStringEquals("iss", res[73].exec("MississippiA"), 171);1814assertToStringEquals("iss", res[73].exec("Mississippi"), 172);1815assertNull(res[73].exec("Mississippi", 173));1816assertToStringEquals("iss", res[74].exec("ississippi"), 174);1817assertToStringEquals("abciss", res[75].exec("abciss\nxyzisspqr"), 175);1818assertToStringEquals("Mis", res[76].exec("Mississippi"), 176);1819assertToStringEquals("sis", res[76].exec("MississippiA"), 177);1820assertToStringEquals("ri ", res[76].exec("Missouri river"), 178);1821assertToStringEquals("riv", res[76].exec("Missouri riverA"), 179);1822assertToStringEquals("Mis", res[77].exec("Mississippi"), 180);1823assertToStringEquals("ab\n", res[78].exec("ab\nab\ncd"), 181);1824assertToStringEquals("ab\n", res[79].exec("ab\nab\ncd"), 182);1825assertToStringEquals("a", res[115].exec("a"), 183);1826assertToStringEquals("b", res[115].exec("b"), 184);1827assertToStringEquals("ab", res[115].exec("ab"), 185);1828assertToStringEquals("", res[115].exec("\\"), 186);1829assertToStringEquals("", res[115].exec("*** Failers"), 187);1830assertToStringEquals("", res[115].exec("N"), 188);1831assertToStringEquals("", res[116].exec("abcd"), 189);1832assertToStringEquals("", res[116].exec("-abc"), 190);1833assertToStringEquals("", res[116].exec("Nab-c"), 191);1834assertToStringEquals("", res[116].exec("*** Failers"), 192);1835assertToStringEquals("", res[116].exec("Nabc"), 193);1836assertToStringEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzz"), 194);1837assertToStringEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO0"), 195);1838assertToStringEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO1"), 196);1839assertToStringEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO2"), 197);1840assertToStringEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO3"), 198);1841assertToStringEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO4"), 199);1842assertToStringEquals("aaaabbbbzz,bbbb,z,z", res[117].exec("aaaabbbbzzzzO5"), 200);1843assertToStringEquals("(abcd", res[118].exec("(abcd)"), 201);1844assertToStringEquals("(abcd", res[118].exec("(abcd)xyz"), 202);1845assertNull(res[118].exec("xyz(abcd)", 203));1846assertNull(res[118].exec("(ab(xy)cd)pqr", 204));1847assertNull(res[118].exec("(ab(xycd)pqr", 205));1848assertNull(res[118].exec("() abc ()", 206));1849assertNull(res[118].exec("12(abcde(fsh)xyz(foo(bar))lmno)89", 207));1850assertNull(res[118].exec("*** Failers", 208));1851assertToStringEquals("abcd", res[118].exec("abcd"), 209);1852assertToStringEquals("abcd", res[118].exec("abcd)"), 210);1853assertToStringEquals("(abcd", res[118].exec("(abcd"), 211);1854assertNull(res[118].exec("(ab(xy)cd)pqr", 212));1855assertNull(res[118].exec("1(abcd)(x(y)z)pqr", 213));1856assertToStringEquals("(abcd", res[118].exec("(abcd)"), 214);1857assertNull(res[118].exec("(ab(xy)cd)", 215));1858assertNull(res[118].exec("(a(b(c)d)e)", 216));1859assertNull(res[118].exec("((ab))", 217));1860assertNull(res[118].exec("*** Failers", 218));1861assertNull(res[118].exec("()", 219));1862assertNull(res[118].exec("()", 220));1863assertNull(res[118].exec("12(abcde(fsh)xyz(foo(bar))lmno)89", 221));1864assertNull(res[118].exec("(ab(xy)cd)", 222));1865assertNull(res[118].exec("(ab(xy)cd)", 223));1866assertNull(res[118].exec("(ab(xy)cd)", 224));1867assertNull(res[118].exec("(123ab(xy)cd)", 225));1868assertNull(res[118].exec("(ab(xy)cd)", 226));1869assertNull(res[118].exec("(123ab(xy)cd)", 227));1870assertNull(res[118].exec("(ab(xy)cd)", 228));1871assertToStringEquals("(abcd", res[118].exec("(abcd(xyz<p>qrs)123)"), 229);1872assertNull(res[118].exec("(ab(cd)ef)", 230));1873assertNull(res[118].exec("(ab(cd(ef)gh)ij)", 231));1874assertNull(res[146].exec("A", 232));1875assertNull(res[146].exec("a", 233));1876assertNull(res[147].exec("A", 234));1877assertNull(res[147].exec("a", 235));1878assertNull(res[147].exec("ab", 236));1879assertNull(res[147].exec("aB", 237));1880assertNull(res[147].exec("*** Failers", 238));1881assertNull(res[147].exec("Ab", 239));1882assertNull(res[147].exec("AB", 240));1883assertThrows("var re = /[\\200-\\110]/;");1884assertToStringEquals("1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 ABC ABC,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 ,11 ,12 ,13 ,14 ,15 ,16 ,17 ,18 ,19 ,20 ,21 ,22 ,23 ,24 ,25 ,26 ,27 ,28 ,29 ,30 ,31 ,32 ,33 ,34 ,35 ,36 ,37 ,38 ,39 ,40 ,41 ,42 ,43 ,44 ,45 ,46 ,47 ,48 ,49 ,50 ,51 ,52 ,53 ,54 ,55 ,56 ,57 ,58 ,59 ,60 ,61 ,62 ,63 ,64 ,65 ,66 ,67 ,68 ,69 ,70 ,71 ,72 ,73 ,74 ,75 ,76 ,77 ,78 ,79 ,80 ,81 ,82 ,83 ,84 ,85 ,86 ,87 ,88 ,89 ,90 ,91 ,92 ,93 ,94 ,95 ,96 ,97 ,98 ,99 ,100 ,101 ,102 ,103 ,104 ,105 ,106 ,107 ,108 ,109 ,110 ,111 ,112 ,113 ,114 ,115 ,116 ,117 ,118 ,119 ,120 ,121 ,122 ,123 ,124 ,125 ,126 ,127 ,128 ,129 ,130 ,131 ,132 ,133 ,134 ,135 ,136 ,137 ,138 ,139 ,140 ,141 ,142 ,143 ,144 ,145 ,146 ,147 ,148 ,149 ,150 ,151 ,152 ,153 ,154 ,155 ,156 ,157 ,158 ,159 ,160 ,161 ,162 ,163 ,164 ,165 ,166 ,167 ,168 ,169 ,170 ,171 ,172 ,173 ,174 ,175 ,176 ,177 ,178 ,179 ,180 ,181 ,182 ,183 ,184 ,185 ,186 ,187 ,188 ,189 ,190 ,191 ,192 ,193 ,194 ,195 ,196 ,197 ,198 ,199 ,200 ,201 ,202 ,203 ,204 ,205 ,206 ,207 ,208 ,209 ,210 ,211 ,212 ,213 ,214 ,215 ,216 ,217 ,218 ,219 ,220 ,221 ,222 ,223 ,224 ,225 ,226 ,227 ,228 ,229 ,230 ,231 ,232 ,233 ,234 ,235 ,236 ,237 ,238 ,239 ,240 ,241 ,242 ,243 ,244 ,245 ,246 ,247 ,248 ,249 ,250 ,251 ,252 ,253 ,254 ,255 ,256 ,257 ,258 ,259 ,260 ,261 ,262 ,263 ,264 ,265 ,266 ,267 ,268 ,269 ,ABC,ABC", res[149].exec("O900 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 ABC ABC"), 242);1885assertToStringEquals("mainmain,main,", res[151].exec("mainmain"), 243);1886assertToStringEquals("mainOmain,main,", res[151].exec("mainOmain"), 244);1887assertToStringEquals("aba,a,", res[153].exec("aba"), 245);1888assertToStringEquals("aabbaa,aa,", res[154].exec("aabbaa"), 246);1889assertToStringEquals("aabbaa,aa,", res[155].exec("aabbaa"), 247);1890assertToStringEquals("aabbaa,aa,", res[156].exec("aabbaa"), 248);1891assertToStringEquals("aabbaa,", res[157].exec("aabbaa"), 249);1892assertToStringEquals("aabbaa,aa,,", res[158].exec("aabbaa"), 250);1893assertToStringEquals("aabbaa,,", res[159].exec("aabbaa"), 251);1894assertToStringEquals("aabbaa,", res[160].exec("aabbaa"), 252);1895assertToStringEquals("aabbbaa,", res[161].exec("aabbbaa"), 253);1896assertToStringEquals("aabbbaa,", res[162].exec("aabbbaa"), 254);1897assertToStringEquals("aabbaa,", res[163].exec("aabbaa"), 255);1898assertToStringEquals("aabbbaa,", res[164].exec("aabbbaa"), 256);1899assertToStringEquals("aabbbaa,aa,,", res[165].exec("aabbbaa"), 257);1900assertToStringEquals("aabbbbaa,aa,,", res[166].exec("aabbbbaa"), 258);1901assertThrows("var re = //;");1902assertToStringEquals("a", res[169].exec("ab"), 260);1903assertToStringEquals("a", res[169].exec("aB"), 261);1904assertToStringEquals("*", res[169].exec("*** Failers"), 262);1905assertToStringEquals("A", res[169].exec("AB"), 263);1906assertToStringEquals("a", res[169].exec("ab"), 264);1907assertToStringEquals("a", res[169].exec("aB"), 265);1908assertToStringEquals("*", res[169].exec("*** Failers"), 266);1909assertToStringEquals("A", res[169].exec("AB"), 267);1910assertNull(res[172].exec("\\", 268));1911assertNull(res[177].exec("*** Failers", 269));1912assertNull(res[177].exec("xxxxx", 270));1913assertNull(res[177].exec("now is the time for all good men to come to the aid of the party", 271));1914assertNull(res[177].exec("*** Failers", 272));1915assertNull(res[177].exec("this is not a line with only words and spaces!", 273));1916assertNull(res[177].exec("12345a", 274));1917assertNull(res[177].exec("*** Failers", 275));1918assertNull(res[177].exec("12345+", 276));1919assertNull(res[177].exec("aaab", 277));1920assertNull(res[177].exec("aaab", 278));1921assertNull(res[177].exec("aaab", 279));1922assertNull(res[177].exec("((abc(ade)ufh()()x", 280));1923assertNull(res[177].exec("(abc)", 281));1924assertNull(res[177].exec("(abc(def)xyz)", 282));1925assertNull(res[177].exec("*** Failers", 283));1926assertNull(res[177].exec("((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 284));1927assertNull(res[177].exec("xaaaab", 285));1928assertNull(res[177].exec("xaaaab", 286));1929assertThrows("var re = /[/;");1930assertThrows("var re = /[a-/;");1931assertNull(res[189].exec("<>", 289));1932assertNull(res[189].exec("<abcd>", 290));1933assertNull(res[189].exec("<abc <123> hij>", 291));1934assertNull(res[189].exec("<abc <def> hij>", 292));1935assertNull(res[189].exec("<abc<>def>", 293));1936assertNull(res[189].exec("<abc<>", 294));1937assertNull(res[189].exec("*** Failers", 295));1938assertNull(res[189].exec("<abc", 296));1939assertToStringEquals("bc123bc,bc,bc", res[195].exec("abc123bc"), 297);1940assertToStringEquals("abc", res[215].exec("abcdef"), 298);1941assertToStringEquals("abc", res[215].exec("1234abcdef"), 299);1942assertNull(res[215].exec("*** Failers", 300));1943assertToStringEquals("abc", res[215].exec("abcxyz"), 301);1944assertToStringEquals("abc", res[215].exec("abcxyzf"), 302);1945assertToStringEquals("abc", res[215].exec("123abcdef"), 303);1946assertToStringEquals("abc", res[215].exec("1234abcdef"), 304);1947assertNull(res[215].exec("*** Failers", 305));1948assertToStringEquals("abc", res[215].exec("abcdef"), 306);1949assertNull(res[215].exec("*** Failers", 307));1950assertToStringEquals("abc", res[215].exec("\x83x0abcdef"), 308);1951assertToStringEquals("abc", res[215].exec("123abcdef"), 309);1952assertToStringEquals("abc", res[215].exec("123abcdefC+"), 310);1953assertToStringEquals("abc", res[215].exec("123abcdefC-"), 311);1954assertNull(res[215].exec("*** Failers", 312));1955assertToStringEquals("abc", res[215].exec("123abcdefC!1"), 313);1956assertToStringEquals("abc", res[215].exec("abcabcabc"), 314);1957assertToStringEquals("abc", res[215].exec("abcabcC!1!3"), 315);1958assertNull(res[215].exec("*** Failers", 316));1959assertToStringEquals("abc", res[215].exec("abcabcabcC!1!3"), 317);1960assertToStringEquals("C", res[215].exec("123C+"), 318);1961assertToStringEquals("C", res[215].exec("123456C+"), 319);1962assertToStringEquals("C", res[215].exec("123456789C+"), 320);1963assertToStringEquals("abc", res[215].exec("xyzabcC+"), 321);1964assertToStringEquals("abc", res[215].exec("XxyzabcC+"), 322);1965assertToStringEquals("abc", res[215].exec("abcdefC+"), 323);1966assertToStringEquals("abc", res[215].exec("abcxyzC+"), 324);1967assertToStringEquals("c", res[215].exec("abbbbbcccC*1"), 325);1968assertToStringEquals("c", res[215].exec("abbbbbcccC*1"), 326);1969assertNull(res[215].exec("xab", 327));1970assertToStringEquals("c", res[215].exec("xbc"), 328);1971assertNull(res[215].exec("xde", 329));1972assertNull(res[215].exec("xxab", 330));1973assertNull(res[215].exec("xxxab", 331));1974assertNull(res[215].exec("*** Failers", 332));1975assertNull(res[215].exec("xyab", 333));1976assertToStringEquals("abc", res[215].exec("abc"), 334);1977assertToStringEquals("c", res[215].exec("a(b)c"), 335);1978assertToStringEquals("c", res[215].exec("a(b(c))d"), 336);1979assertNull(res[215].exec("*** Failers)", 337));1980assertToStringEquals("c", res[215].exec("a(b(c)d"), 338);1981assertNull(res[215].exec("1221", 339));1982assertToStringEquals("c", res[215].exec("Satan, oscillate my metallic sonatas!"), 340);1983assertToStringEquals("c", res[215].exec("A man, a plan, a canal: Panama!"), 341);1984assertNull(res[215].exec("Able was I ere I saw Elba.", 342));1985assertNull(res[215].exec("*** Failers", 343));1986assertToStringEquals("c", res[215].exec("The quick brown fox"), 344);1987assertNull(res[215].exec("12", 345));1988assertNull(res[215].exec("(((2+2)*-3)-7)", 346));1989assertNull(res[215].exec("-12", 347));1990assertNull(res[215].exec("*** Failers", 348));1991assertNull(res[215].exec("((2+2)*-3)-7)", 349));1992assertNull(res[215].exec("xyz", 350));1993assertNull(res[215].exec("xxyzxyzz", 351));1994assertNull(res[215].exec("*** Failers", 352));1995assertNull(res[215].exec("xxyzz", 353));1996assertNull(res[215].exec("xxyzxyzxyzz", 354));1997assertNull(res[215].exec("<>", 355));1998assertToStringEquals("abc", res[215].exec("<abcd>"), 356);1999assertToStringEquals("abc", res[215].exec("<abc <123> hij>"), 357);2000assertToStringEquals("abc", res[215].exec("<abc <def> hij>"), 358);2001assertToStringEquals("abc", res[215].exec("<abc<>def>"), 359);2002assertToStringEquals("abc", res[215].exec("<abc<>"), 360);2003assertNull(res[215].exec("*** Failers", 361));2004assertToStringEquals("abc", res[215].exec("<abc"), 362);2005assertToStringEquals("abc", res[215].exec("abcdefabc"), 363);2006assertNull(res[215].exec("a=a", 364));2007assertNull(res[215].exec("a=b", 365));2008assertToStringEquals("c", res[215].exec("a=bc"), 366);2009assertNull(res[215].exec("a=a", 367));2010assertNull(res[215].exec("a=b", 368));2011assertToStringEquals("c", res[215].exec("a=bc"), 369);2012assertNull(res[215].exec("abde", 370));2013assertToStringEquals("c", res[215].exec("acde"), 371);2014assertNull(res[215].exec("1221", 372));2015assertToStringEquals("c", res[215].exec("Satan, oscillate my metallic sonatas!"), 373);2016assertToStringEquals("c", res[215].exec("A man, a plan, a canal: Panama!"), 374);2017assertNull(res[215].exec("Able was I ere I saw Elba.", 375));2018assertNull(res[215].exec("*** Failers", 376));2019assertToStringEquals("c", res[215].exec("The quick brown fox"), 377);2020assertNull(res[228].exec("abcdefgh", 378));2021assertNull(res[228].exec("abcdefghC1Gtwo", 379));2022assertNull(res[228].exec("abcdefghConeCtwo", 380));2023assertNull(res[228].exec("abcdefghCthree", 381));2024assertToStringEquals("zz,", res[228].exec("zzaaCZ"), 382);2025assertToStringEquals("zz,", res[228].exec("zzaaCA"), 383);2026assertNull(res[228].exec("[10,20,30,5,5,4,4,2,43,23,4234]", 384));2027assertNull(res[228].exec("*** Failers", 385));2028assertNull(res[228].exec("[]", 386));2029assertNull(res[228].exec("[10,20,30,5,5,4,4,2,43,23,4234]", 387));2030assertNull(res[228].exec("[]", 388));2031assertToStringEquals(" Baby Bjorn Active Carrier - With free SHIPPING!!, Baby Bjorn Active Carrier - With free SHIPPING!!,,", res[229].exec(" Baby Bjorn Active Carrier - With free SHIPPING!!"), 389);2032assertToStringEquals(" Baby Bjorn Active Carrier - With free SHIPPING!!, Baby Bjorn Active Carrier - With free SHIPPING!!,,", res[230].exec(" Baby Bjorn Active Carrier - With free SHIPPING!!"), 390);2033assertNull(res[238].exec("Note: that { does NOT introduce a quantifier", 391));2034assertToStringEquals("aacaacaacaacaac123,aac", res[239].exec("aacaacaacaacaac123"), 392);2035assertNull(res[243].exec("abP", 393));2036assertNull(res[243].exec("abcP", 394));2037assertNull(res[243].exec("abcdP", 395));2038assertToStringEquals("abcde", res[243].exec("abcdeP"), 396);2039assertNull(res[243].exec("the quick brown abcP", 397));2040assertNull(res[243].exec("** FailersP", 398));2041assertNull(res[243].exec("the quick brown abxyz foxP", 399));2042assertNull(res[243].exec("13/05/04P", 400));2043assertNull(res[243].exec("13/5/2004P", 401));2044assertNull(res[243].exec("02/05/09P", 402));2045assertNull(res[243].exec("1P", 403));2046assertNull(res[243].exec("1/2P", 404));2047assertNull(res[243].exec("1/2/0P", 405));2048assertNull(res[243].exec("1/2/04P", 406));2049assertNull(res[243].exec("0P", 407));2050assertNull(res[243].exec("02/P", 408));2051assertNull(res[243].exec("02/0P", 409));2052assertNull(res[243].exec("02/1P", 410));2053assertNull(res[243].exec("** FailersP", 411));2054assertNull(res[243].exec("P", 412));2055assertNull(res[243].exec("123P", 413));2056assertNull(res[243].exec("33/4/04P", 414));2057assertNull(res[243].exec("3/13/04P", 415));2058assertNull(res[243].exec("0/1/2003P", 416));2059assertNull(res[243].exec("0/P", 417));2060assertNull(res[243].exec("02/0/P", 418));2061assertNull(res[243].exec("02/13P", 419));2062assertToStringEquals("123", res[248].exec("123P"), 420);2063assertNull(res[248].exec("aP", 421));2064assertNull(res[248].exec("bP", 422));2065assertNull(res[248].exec("cP", 423));2066assertNull(res[248].exec("c12P", 424));2067assertToStringEquals("c123", res[248].exec("c123P"), 425);2068assertNull(res[249].exec("1P", 426));2069assertNull(res[249].exec("123P", 427));2070assertToStringEquals("123X", res[249].exec("123X"), 428);2071assertNull(res[249].exec("1234P", 429));2072assertToStringEquals("1234X", res[249].exec("1234X"), 430);2073assertNull(res[249].exec("12345P", 431));2074assertToStringEquals("12345X", res[249].exec("12345X"), 432);2075assertNull(res[249].exec("*** Failers", 433));2076assertNull(res[249].exec("1X", 434));2077assertNull(res[249].exec("123456P", 435));2078assertNull(res[249].exec("abc", 436));2079assertNull(res[249].exec("** Failers", 437));2080assertNull(res[249].exec("bca", 438));2081assertNull(res[249].exec("abc", 439));2082assertNull(res[249].exec("** Failers", 440));2083assertNull(res[249].exec("bca", 441));2084assertNull(res[249].exec("abc", 442));2085assertNull(res[249].exec("** Failers", 443));2086assertNull(res[249].exec("def", 444));2087assertNull(res[249].exec("abc", 445));2088assertNull(res[249].exec("** Failers", 446));2089assertNull(res[249].exec("def", 447));2090assertNull(res[249].exec("<!DOCTYPE seite SYSTEM \"http://www.lco.lineas.de/xmlCms.dtd\">\n<seite>\n<dokumenteninformation>\n<seitentitel>Partner der LCO</seitentitel>\n<sprache>de</sprache>\n<seitenbeschreibung>Partner der LINEAS Consulting\nGmbH</seitenbeschreibung>\n<schluesselworte>LINEAS Consulting GmbH Hamburg\nPartnerfirmen</schluesselworte>\n<revisit>30 days</revisit>\n<robots>index,follow</robots>\n<menueinformation>\n<aktiv>ja</aktiv>\n<menueposition>3</menueposition>\n<menuetext>Partner</menuetext>\n</menueinformation>\n<lastedited>\n<autor>LCO</autor>\n<firma>LINEAS Consulting</firma>\n<datum>15.10.2003</datum>\n</lastedited>\n</dokumenteninformation>\n<inhalt>\n\n<absatzueberschrift>Die Partnerfirmen der LINEAS Consulting\nGmbH</absatzueberschrift>\n\n<absatz><link ziel=\"http://www.ca.com/\" zielfenster=\"_blank\">\n<bild name=\"logo_ca.gif\" rahmen=\"no\"/></link> <link\nziel=\"http://www.ey.com/\" zielfenster=\"_blank\"><bild\nname=\"logo_euy.gif\" rahmen=\"no\"/></link>\n</absatz>\n\n<absatz><link ziel=\"http://www.cisco.de/\" zielfenster=\"_blank\">\n<bild name=\"logo_cisco.gif\" rahmen=\"ja\"/></link></absatz>\n\n<absatz><link ziel=\"http://www.atelion.de/\"\nzielfenster=\"_blank\"><bild\nname=\"logo_atelion.gif\" rahmen=\"no\"/></link>\n</absatz>\n\n<absatz><link ziel=\"http://www.line-information.de/\"\nzielfenster=\"_blank\">\n<bild name=\"logo_line_information.gif\" rahmen=\"no\"/></link>\n</absatz>\n\n<absatz><bild name=\"logo_aw.gif\" rahmen=\"no\"/></absatz>\n\n<absatz><link ziel=\"http://www.incognis.de/\"\nzielfenster=\"_blank\"><bild\nname=\"logo_incognis.gif\" rahmen=\"no\"/></link></absatz>\n\n<absatz><link ziel=\"http://www.addcraft.com/\"\nzielfenster=\"_blank\"><bild\nname=\"logo_addcraft.gif\" rahmen=\"no\"/></link></absatz>\n\n<absatz><link ziel=\"http://www.comendo.com/\"\nzielfenster=\"_blank\"><bild\nname=\"logo_comendo.gif\" rahmen=\"no\"/></link></absatz>\n\n</inhalt>\n</seite>", 448));2091assertToStringEquals("line\nbreak", res[251].exec("this is a line\nbreak"), 449);2092assertToStringEquals("line\nbreak", res[251].exec("line one\nthis is a line\nbreak in the second line"), 450);2093assertToStringEquals("line\nbreak", res[252].exec("this is a line\nbreak"), 451);2094assertNull(res[252].exec("** Failers", 452));2095assertToStringEquals("line\nbreak", res[252].exec("line one\nthis is a line\nbreak in the second line"), 453);2096assertToStringEquals("line\nbreak", res[253].exec("this is a line\nbreak"), 454);2097assertNull(res[253].exec("** Failers", 455));2098assertToStringEquals("line\nbreak", res[253].exec("line one\nthis is a line\nbreak in the second line"), 456);2099assertToStringEquals("ab-cd", res[254].exec("ab-cd"), 457);2100assertToStringEquals("ab=cd", res[254].exec("ab=cd"), 458);2101assertNull(res[254].exec("** Failers", 459));2102assertNull(res[254].exec("ab\ncd", 460));2103assertToStringEquals("ab-cd", res[255].exec("ab-cd"), 461);2104assertToStringEquals("ab=cd", res[255].exec("ab=cd"), 462);2105assertNull(res[255].exec("ab\ncd", 463));2106assertNull(res[255].exec("AbCd", 464));2107assertNull(res[255].exec("** Failers", 465));2108assertNull(res[255].exec("abcd", 466));2109// We are compatible with JSC, and don't throw an exception in this case.2110// assertThrows("var re = /(){2,4294967295}/;");2111assertNull(res[255].exec("abcdefghijklAkB", 468));2112assertNull(res[255].exec("abcdefghijklAkB", 469));2113assertNull(res[255].exec("abcdefghijklAkB", 470));2114assertNull(res[255].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 471));2115assertNull(res[255].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 472));2116assertNull(res[255].exec("(this(and)that", 473));2117assertNull(res[255].exec("(this(and)that)", 474));2118assertNull(res[255].exec("(this(and)that)stuff", 475));2119assertNull(res[255].exec("(this(and)that", 476));2120assertNull(res[255].exec("(this(and)that)", 477));2121assertNull(res[255].exec("(this(and)that", 478));2122assertNull(res[255].exec("(this(and)that)", 479));2123assertNull(res[255].exec("(this(and)that", 480));2124assertNull(res[255].exec("(this(and)that)", 481));2125assertNull(res[255].exec("((this))", 482));2126assertNull(res[255].exec("(this(and)that", 483));2127assertNull(res[255].exec("(this(and)that)", 484));2128assertNull(res[255].exec("(this)", 485));2129assertNull(res[255].exec("((this))", 486));2130assertToStringEquals("abc,b", res[256].exec("abc"), 487);2131assertToStringEquals("abc,b", res[256].exec("abc"), 488);2132assertNull(res[256].exec("a1bCA", 489));2133assertNull(res[256].exec("a2bCA", 490));2134assertNull(res[257].exec("a bc dCACBCC", 491));2135assertNull(res[257].exec("aabc", 492));2136assertNull(res[257].exec("bc", 493));2137assertNull(res[257].exec("** Failers", 494));2138assertNull(res[257].exec("abc", 495));2139assertNull(res[257].exec("bXaX", 496));2140assertNull(res[257].exec("bbXaaX", 497));2141assertNull(res[257].exec("(b)\\Xa\\X", 498));2142assertNull(res[257].exec("bXXaYYaY", 499));2143assertNull(res[257].exec("bXYaXXaX", 500));2144assertNull(res[257].exec("bXXaYYaY", 501));2145assertToStringEquals("\x0b,\x0b", res[259].exec("\x0b,\x0b"), 502);2146assertToStringEquals("\x0c,\x0d", res[259].exec("\x0c,\x0d"), 503);2147assertToStringEquals("abc", res[260].exec("xyz\nabc"), 504);2148assertToStringEquals("abc", res[260].exec("xyz\nabc<lf>"), 505);2149assertToStringEquals("abc", res[260].exec("xyz\x0d\nabc<lf>"), 506);2150assertToStringEquals("abc", res[260].exec("xyz\x0dabc<cr>"), 507);2151assertToStringEquals("abc", res[260].exec("xyz\x0d\nabc<crlf>"), 508);2152assertNull(res[260].exec("** Failers", 509));2153assertToStringEquals("abc", res[260].exec("xyz\nabc<cr>"), 510);2154assertToStringEquals("abc", res[260].exec("xyz\x0d\nabc<cr>"), 511);2155assertToStringEquals("abc", res[260].exec("xyz\nabc<crlf>"), 512);2156assertToStringEquals("abc", res[260].exec("xyz\x0dabc<crlf>"), 513);2157assertToStringEquals("abc", res[260].exec("xyz\x0dabc<lf>"), 514);2158assertToStringEquals("abc", res[261].exec("xyzabc"), 515);2159assertToStringEquals("abc", res[261].exec("xyzabc\n"), 516);2160assertToStringEquals("abc", res[261].exec("xyzabc\npqr"), 517);2161assertToStringEquals("abc", res[261].exec("xyzabc\x0d<cr>"), 518);2162assertToStringEquals("abc", res[261].exec("xyzabc\x0dpqr<cr>"), 519);2163assertToStringEquals("abc", res[261].exec("xyzabc\x0d\n<crlf>"), 520);2164assertToStringEquals("abc", res[261].exec("xyzabc\x0d\npqr<crlf>"), 521);2165assertNull(res[261].exec("** Failers", 522));2166assertToStringEquals("abc", res[261].exec("xyzabc\x0d"), 523);2167assertToStringEquals("abc", res[261].exec("xyzabc\x0dpqr"), 524);2168assertToStringEquals("abc", res[261].exec("xyzabc\x0d\n"), 525);2169assertToStringEquals("abc", res[261].exec("xyzabc\x0d\npqr"), 526);2170assertToStringEquals("abc", res[262].exec("xyz\x0dabcdef"), 527);2171assertToStringEquals("abc", res[262].exec("xyz\nabcdef<lf>"), 528);2172assertNull(res[262].exec("** Failers", 529));2173assertToStringEquals("abc", res[262].exec("xyz\nabcdef"), 530);2174assertToStringEquals("abc", res[263].exec("xyz\nabcdef"), 531);2175assertToStringEquals("abc", res[263].exec("xyz\x0dabcdef<cr>"), 532);2176assertNull(res[263].exec("** Failers", 533));2177assertToStringEquals("abc", res[263].exec("xyz\x0dabcdef"), 534);2178assertToStringEquals("abc", res[264].exec("xyz\x0d\nabcdef"), 535);2179assertToStringEquals("abc", res[264].exec("xyz\x0dabcdef<cr>"), 536);2180assertNull(res[264].exec("** Failers", 537));2181assertToStringEquals("abc", res[264].exec("xyz\x0dabcdef"), 538);2182assertToStringEquals("abc", res[266].exec("xyz\x0dabc<bad>"), 539);2183assertToStringEquals("abc", res[266].exec("abc"), 540);2184assertToStringEquals("abc", res[267].exec("abc\ndef"), 541);2185assertToStringEquals("abc", res[267].exec("abc\x0ddef"), 542);2186assertToStringEquals("abc", res[267].exec("abc\x0d\ndef"), 543);2187assertToStringEquals("<cr>abc", res[267].exec("<cr>abc\ndef"), 544);2188assertToStringEquals("<cr>abc", res[267].exec("<cr>abc\x0ddef"), 545);2189assertToStringEquals("<cr>abc", res[267].exec("<cr>abc\x0d\ndef"), 546);2190assertToStringEquals("<crlf>abc", res[267].exec("<crlf>abc\ndef"), 547);2191assertToStringEquals("<crlf>abc", res[267].exec("<crlf>abc\x0ddef"), 548);2192assertToStringEquals("<crlf>abc", res[267].exec("<crlf>abc\x0d\ndef"), 549);2193assertNull(res[268].exec("abc\ndef", 550));2194assertNull(res[268].exec("abc\x0ddef", 551));2195assertNull(res[268].exec("abc\x0d\ndef", 552));2196assertToStringEquals("XY,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,XY,Y", res[269].exec("XYO400"), 553);2197assertToStringEquals("aaaA5", res[278].exec("aaaA5"), 554);2198assertNull(res[278].exec("** Failers", 555));2199assertNull(res[278].exec("aaaa5", 556));2200assertToStringEquals("aaaA5", res[279].exec("aaaA5"), 557);2201assertToStringEquals("aaaa5", res[279].exec("aaaa5"), 558);2202assertToStringEquals("x", res[350].exec("xyCabcCxyz"), 559);2203assertToStringEquals("x", res[350].exec("xyCabcCxyz"), 560);2204assertToStringEquals("b", res[350].exec("bXaX"), 561);2205assertToStringEquals("b", res[350].exec("bXbX"), 562);2206assertToStringEquals("*", res[350].exec("** Failers"), 563);2207assertToStringEquals("aX", res[350].exec("aXaX"), 564);2208assertToStringEquals("aX", res[350].exec("aXbX"), 565);2209assertToStringEquals("x", res[350].exec("xx"), 566);2210assertToStringEquals("x", res[350].exec("xy"), 567);2211assertToStringEquals("y", res[350].exec("yy"), 568);2212assertToStringEquals("y", res[350].exec("yx"), 569);2213assertToStringEquals("x", res[350].exec("xx"), 570);2214assertToStringEquals("x", res[350].exec("xy"), 571);2215assertToStringEquals("y", res[350].exec("yy"), 572);2216assertToStringEquals("y", res[350].exec("yx"), 573);2217assertToStringEquals("b", res[350].exec("bxay"), 574);2218assertToStringEquals("b", res[350].exec("bxby"), 575);2219assertToStringEquals("*", res[350].exec("** Failers"), 576);2220assertToStringEquals("ax", res[350].exec("axby"), 577);2221assertToStringEquals("X", res[350].exec("XxXxxx"), 578);2222assertToStringEquals("X", res[350].exec("XxXyyx"), 579);2223assertToStringEquals("X", res[350].exec("XxXyxx"), 580);2224assertToStringEquals("*", res[350].exec("** Failers"), 581);2225assertToStringEquals("x", res[350].exec("x"), 582);2226assertToStringEquals("ab", res[350].exec("abcabc"), 583);2227assertToStringEquals("Xaaa,a", res[351].exec("Xaaa"), 584);2228assertToStringEquals("Xaba,a", res[351].exec("Xaba"), 585);2229assertThrows("var re = /^[a-\\Q\\E]/;");2230assertNull(res[353].exec("(xy)x", 587));2231assertNull(res[353].exec("1221", 588));2232assertNull(res[353].exec("Satan, oscillate my metallic sonatas!", 589));2233assertNull(res[353].exec("A man, a plan, a canal: Panama!", 590));2234assertNull(res[353].exec("Able was I ere I saw Elba.", 591));2235assertNull(res[353].exec("*** Failers", 592));2236assertNull(res[353].exec("The quick brown fox", 593));2237assertToStringEquals("abcd:,abcd", res[354].exec("abcd:"), 594);2238assertToStringEquals("abcd:,abcd", res[354].exec("abcd:"), 595);2239assertToStringEquals("a:,a", res[354].exec("a:aaxyz"), 596);2240assertToStringEquals("ab:,ab", res[354].exec("ab:ababxyz"), 597);2241assertNull(res[354].exec("** Failers", 598));2242assertToStringEquals("a:,a", res[354].exec("a:axyz"), 599);2243assertToStringEquals("ab:,ab", res[354].exec("ab:abxyz"), 600);2244assertNull(res[354].exec("abd", 601));2245assertNull(res[354].exec("ce", 602));2246assertNull(res[354].exec("abcabc1Xabc2XabcXabcabc", 603));2247assertNull(res[354].exec("abcabc1Xabc2XabcXabcabc", 604));2248assertNull(res[354].exec("abcabc1Xabc2XabcXabcabc", 605));2249assertNull(res[354].exec("abcd", 606));2250assertNull(res[354].exec("metcalfe 33", 607));2251assertNull(res[356].exec("a\x0db", 608));2252assertNull(res[356].exec("a\nb<cr>", 609));2253assertToStringEquals("a\x85b", res[356].exec("a\x85b<anycrlf> "), 610);2254assertNull(res[356].exec("** Failers", 611));2255assertNull(res[356].exec("a\nb", 612));2256assertNull(res[356].exec("a\nb<any>", 613));2257assertNull(res[356].exec("a\x0db<cr>", 614));2258assertNull(res[356].exec("a\x0db<any>", 615));2259assertToStringEquals("a\x85b", res[356].exec("a\x85b<any> "), 616);2260assertNull(res[356].exec("a\x0db<anycrlf>", 617));2261assertToStringEquals("abc1", res[357].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 \x85abc7 JUNK"), 618);2262assertToStringEquals("abc1", res[358].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6\x85 abc7 abc9"), 619);2263assertNull(res[361].exec("a\nb", 620));2264assertNull(res[361].exec("a\x0db", 621));2265assertNull(res[361].exec("a\x0d\nb", 622));2266assertNull(res[361].exec("a\x0bb", 623));2267assertNull(res[361].exec("a\x0cb", 624));2268assertNull(res[361].exec("a\x85b", 625));2269assertNull(res[361].exec("** Failers", 626));2270assertNull(res[361].exec("a\n\x0db", 627));2271assertToStringEquals("ab", res[362].exec("ab"), 628);2272assertNull(res[362].exec("a\nb", 629));2273assertNull(res[362].exec("a\x0db", 630));2274assertNull(res[362].exec("a\x0d\nb", 631));2275assertNull(res[362].exec("a\x0bb", 632));2276assertNull(res[362].exec("a\x0cb", 633));2277assertNull(res[362].exec("a\x85b", 634));2278assertNull(res[362].exec("a\n\x0db", 635));2279assertNull(res[362].exec("a\n\x0d\x85\x0cb", 636));2280assertNull(res[363].exec("a\nb", 637));2281assertNull(res[363].exec("a\x0db", 638));2282assertNull(res[363].exec("a\x0d\nb", 639));2283assertNull(res[363].exec("a\x0bb", 640));2284assertNull(res[363].exec("a\x0cb", 641));2285assertNull(res[363].exec("a\x85b", 642));2286assertNull(res[363].exec("a\n\x0db", 643));2287assertNull(res[363].exec("a\n\x0d\x85\x0cb", 644));2288assertNull(res[363].exec("** Failers", 645));2289assertNull(res[363].exec("ab", 646));2290assertNull(res[364].exec("a\nb", 647));2291assertNull(res[364].exec("a\n\x0db", 648));2292assertNull(res[364].exec("a\n\x0d\x85b", 649));2293assertNull(res[364].exec("a\x0d\n\x0d\nb", 650));2294assertNull(res[364].exec("a\x0d\n\x0d\n\x0d\nb", 651));2295assertNull(res[364].exec("a\n\x0d\n\x0db", 652));2296assertNull(res[364].exec("a\n\n\x0d\nb", 653));2297assertNull(res[364].exec("** Failers", 654));2298assertNull(res[364].exec("a\n\n\n\x0db", 655));2299assertNull(res[364].exec("a\x0d", 656));2300assertToStringEquals("aRb", res[365].exec("aRb"), 657);2301assertNull(res[365].exec("** Failers", 658));2302assertNull(res[365].exec("a\nb", 659));2303assertNull(res[365].exec("abcPXP123", 660));2304assertNull(res[365].exec("abcPXP123", 661));2305assertNull(res[365].exec("1.2.3.4", 662));2306assertNull(res[365].exec("131.111.10.206", 663));2307assertNull(res[365].exec("10.0.0.0", 664));2308assertNull(res[365].exec("** Failers", 665));2309assertNull(res[365].exec("10.6", 666));2310assertNull(res[365].exec("455.3.4.5", 667));2311assertNull(res[365].exec("1.2.3.4", 668));2312assertNull(res[365].exec("131.111.10.206", 669));2313assertNull(res[365].exec("10.0.0.0", 670));2314assertNull(res[365].exec("** Failers", 671));2315assertNull(res[365].exec("10.6", 672));2316assertNull(res[365].exec("455.3.4.5", 673));2317assertNull(res[365].exec("123axbaxbaxbx456", 674));2318assertNull(res[365].exec("123axbaxbaxb456", 675));2319assertNull(res[365].exec("123axbaxbaxbx456", 676));2320assertNull(res[365].exec("123axbaxbaxbx456", 677));2321assertNull(res[365].exec("123axbaxbaxbx456", 678));2322assertNull(res[366].exec("ababababbbabZXXXX", 679));2323assertNull(res[372].exec("a\x0db", 680));2324assertNull(res[372].exec("*** Failers", 681));2325assertNull(res[372].exec("a\nb", 682));2326assertToStringEquals("afoo", res[373].exec("afoo"), 683);2327assertNull(res[373].exec("** Failers", 684));2328assertNull(res[373].exec("\x0d\nfoo", 685));2329assertNull(res[373].exec("\nfoo", 686));2330assertToStringEquals("afoo", res[374].exec("afoo"), 687);2331assertNull(res[374].exec("\nfoo", 688));2332assertNull(res[374].exec("** Failers", 689));2333assertNull(res[374].exec("\x0d\nfoo", 690));2334assertToStringEquals("afoo", res[375].exec("afoo"), 691);2335assertNull(res[375].exec("** Failers", 692));2336assertNull(res[375].exec("\nfoo", 693));2337assertNull(res[375].exec("\x0d\nfoo", 694));2338assertToStringEquals("afoo", res[376].exec("afoo"), 695);2339assertNull(res[376].exec("\x0d\nfoo", 696));2340assertNull(res[376].exec("\nfoo", 697));2341assertToStringEquals("", res[377].exec("abc\x0d\x0dxyz"), 698);2342assertToStringEquals("", res[377].exec("abc\n\x0dxyz "), 699);2343assertNull(res[377].exec("** Failers ", 700));2344assertToStringEquals("", res[377].exec("abc\x0d\nxyz"), 701);2345assertToStringEquals("", res[377].exec("abc\x0d\n\x0d\n"), 702);2346assertToStringEquals("", res[377].exec("abc\x0d\n\x0d\n"), 703);2347assertToStringEquals("", res[377].exec("abc\x0d\n\x0d\n"), 704);2348assertToStringEquals("abc1", res[378].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6\x85 abc9"), 705);2349assertToStringEquals("X", res[379].exec("XABC"), 706);2350assertNull(res[379].exec("** Failers ", 707));2351assertToStringEquals("X", res[379].exec("XABCB"), 708);2352assertThrows("var re = /(ab|c)(?-1)/;");2353assertNull(res[379].exec("abc", 710));2354assertNull(res[379].exec("xyabcabc", 711));2355assertNull(res[379].exec("** Failers", 712));2356assertNull(res[379].exec("xyabc ", 713));2357assertThrows("var re = /x(?-0)y/;");2358assertThrows("var re = /x(?-1)y/;");2359assertNull(res[379].exec("abcX", 716));2360assertNull(res[379].exec("Y", 717));2361assertNull(res[379].exec("** Failers", 718));2362assertNull(res[379].exec("abcY ", 719));2363assertNull(res[379].exec("YabcXabc", 720));2364assertNull(res[379].exec("YabcXabcXabc", 721));2365assertNull(res[379].exec("** Failers", 722));2366assertToStringEquals("X", res[379].exec("XabcXabc "), 723);2367assertNull(res[379].exec("Y!", 724));2368assertNull(res[380].exec("foobar", 725));2369assertNull(res[381].exec("foobar", 726));2370assertToStringEquals("foobaz,foo,baz", res[381].exec("foobaz "), 727);2371assertNull(res[382].exec("foobarbaz", 728));2372assertNull(res[382].exec("tom-tom", 729));2373assertNull(res[382].exec("bon-bon ", 730));2374assertNull(res[382].exec("** Failers", 731));2375assertNull(res[382].exec("tom-bon ", 732));2376assertNull(res[382].exec("tom-tom", 733));2377assertNull(res[382].exec("bon-bon ", 734));2378assertThrows("var re = /(?|(abc)|(xyz))/;");2379assertThrows("var re = /(x)(?|(abc)|(xyz))(x)/;");2380assertNull(res[383].exec("xabcx", 737));2381assertNull(res[383].exec("xxyzx ", 738));2382assertThrows("var re = /(x)(?|(abc)(pqr)|(xyz))(x)/;");2383assertNull(res[383].exec("xabcpqrx", 740));2384assertNull(res[383].exec("xxyzx ", 741));2385assertThrows("var re = /(?|(abc)|(xyz))\\1/;");2386assertNull(res[383].exec("abcabc", 743));2387assertNull(res[383].exec("xyzxyz ", 744));2388assertNull(res[383].exec("** Failers", 745));2389assertNull(res[383].exec("abcxyz", 746));2390assertNull(res[383].exec("xyzabc ", 747));2391assertNull(res[383].exec("abcabc", 748));2392assertNull(res[383].exec("xyzabc ", 749));2393assertNull(res[383].exec("** Failers ", 750));2394assertNull(res[383].exec("xyzxyz ", 751));2395assertNull(res[384].exec("X X\n", 752));2396assertNull(res[384].exec("X\x09X\x0b", 753));2397assertNull(res[384].exec("** Failers", 754));2398assertNull(res[384].exec("\xa0 X\n ", 755));2399assertNull(res[385].exec("\x09 \xa0X\n\x0b\x0c\x0d\n", 756));2400assertNull(res[385].exec("\x09 \xa0\n\x0b\x0c\x0d\n", 757));2401assertNull(res[385].exec("\x09 \xa0\n\x0b\x0c", 758));2402assertNull(res[385].exec("** Failers ", 759));2403assertNull(res[385].exec("\x09 \xa0\n\x0b", 760));2404assertNull(res[385].exec(" ", 761));2405assertNull(res[386].exec("XY ABCDE", 762));2406assertNull(res[386].exec("XY PQR ST ", 763));2407assertNull(res[387].exec("XY AB PQRS", 764));2408assertNull(res[388].exec(">XNNNYZ", 765));2409assertNull(res[388].exec("> X NYQZ", 766));2410assertNull(res[388].exec("** Failers", 767));2411assertNull(res[388].exec(">XYZ ", 768));2412assertNull(res[388].exec("> X NY Z", 769));2413assertNull(res[389].exec(">XY\nZ\nA\x0bNN\x0c", 770));2414assertNull(res[389].exec(">\n\x0dX\nY\n\x0bZZZ\nAAA\x0bNNN\x0c", 771));2415assertNull(res[390].exec(">\x09<", 772));2416assertNull(res[391].exec(">\x09 \xa0<", 773));2417assertNull(res[396].exec("** Failers", 774));2418assertNull(res[396].exec("XXXX", 775));2419assertNull(res[397].exec("XXXX Y ", 776));2420assertNull(res[419].exec("aaaaaa", 777));2421assertNull(res[419].exec("aaabccc", 778));2422assertNull(res[419].exec("aaabccc", 779));2423assertNull(res[419].exec("aaabccc", 780));2424assertNull(res[419].exec("aaabcccaaabccc", 781));2425assertNull(res[419].exec("aaaxxxxxx", 782));2426assertNull(res[419].exec("aaa++++++ ", 783));2427assertNull(res[419].exec("bbbxxxxx", 784));2428assertNull(res[419].exec("bbb+++++ ", 785));2429assertNull(res[419].exec("cccxxxx", 786));2430assertNull(res[419].exec("ccc++++ ", 787));2431assertNull(res[419].exec("dddddddd ", 788));2432assertNull(res[419].exec("aaaxxxxxx", 789));2433assertNull(res[419].exec("aaa++++++ ", 790));2434assertNull(res[419].exec("bbbxxxxx", 791));2435assertNull(res[419].exec("bbb+++++ ", 792));2436assertNull(res[419].exec("cccxxxx", 793));2437assertNull(res[419].exec("ccc++++ ", 794));2438assertNull(res[419].exec("dddddddd ", 795));2439assertNull(res[419].exec("aaabccc", 796));2440assertNull(res[419].exec("ABX", 797));2441assertNull(res[419].exec("AADE", 798));2442assertNull(res[419].exec("ACDE", 799));2443assertNull(res[419].exec("** Failers", 800));2444assertNull(res[419].exec("AD ", 801));2445assertNull(res[419].exec(" ", 802));2446assertNull(res[419].exec("aaaaaa", 803));2447assertNull(res[419].exec("aaabccc", 804));2448assertNull(res[419].exec("aaabccc", 805));2449assertNull(res[419].exec("aaabccc", 806));2450assertNull(res[419].exec("aaabcccaaabccc", 807));2451assertNull(res[419].exec("aaabccc", 808));2452assertNull(res[422].exec("\x0d\nA", 809));2453assertToStringEquals("\nA", res[423].exec("\x0d\nA "), 810);2454assertToStringEquals("\nA", res[424].exec("\x0d\nA "), 811);2455assertToStringEquals("\nA,\n", res[425].exec("\x0d\nA "), 812);2456assertNull(res[425].exec("a\nb", 813));2457assertNull(res[425].exec("** Failers", 814));2458assertNull(res[425].exec("a\x0db ", 815));2459assertNull(res[425].exec("a\nb", 816));2460assertNull(res[425].exec("** Failers", 817));2461assertNull(res[425].exec("a\x0db ", 818));2462assertNull(res[425].exec("a\x0db", 819));2463assertNull(res[425].exec("** Failers", 820));2464assertNull(res[425].exec("a\nb ", 821));2465assertNull(res[425].exec("a\x0db", 822));2466assertNull(res[425].exec("a\nb ", 823));2467assertNull(res[425].exec("** Failers", 824));2468assertNull(res[425].exec("a\x0d\nb ", 825));2469assertNull(res[425].exec("** Failers", 826));2470assertNull(res[425].exec("a\x0db", 827));2471assertNull(res[425].exec("a\nb ", 828));2472assertNull(res[425].exec("a\x0d\nb ", 829));2473assertNull(res[425].exec("** Failers", 830));2474assertNull(res[425].exec("a\x0db", 831));2475assertNull(res[425].exec("a\nb ", 832));2476assertNull(res[425].exec("a\x0d\nb ", 833));2477assertNull(res[425].exec("a\x85b ", 834));2478assertNull(res[426].exec("a\x0db", 835));2479assertNull(res[426].exec("a\nb", 836));2480assertNull(res[426].exec("a\x0d\nb", 837));2481assertNull(res[426].exec("** Failers", 838));2482assertNull(res[426].exec("a\x85b", 839));2483assertNull(res[426].exec("a\x0bb ", 840));2484assertNull(res[427].exec("a\x0db", 841));2485assertNull(res[427].exec("a\nb", 842));2486assertNull(res[427].exec("a\x0d\nb", 843));2487assertNull(res[427].exec("a\x85b", 844));2488assertNull(res[427].exec("a\x0bb ", 845));2489assertNull(res[427].exec("** Failers ", 846));2490assertNull(res[427].exec("a\x85b<bsr_anycrlf>", 847));2491assertNull(res[427].exec("a\x0bb<bsr_anycrlf>", 848));2492assertNull(res[428].exec("a\x0db", 849));2493assertNull(res[428].exec("a\nb", 850));2494assertNull(res[428].exec("a\x0d\nb", 851));2495assertNull(res[428].exec("** Failers", 852));2496assertNull(res[428].exec("a\x85b", 853));2497assertNull(res[428].exec("a\x0bb ", 854));2498assertNull(res[429].exec("a\x0db", 855));2499assertNull(res[429].exec("a\nb", 856));2500assertNull(res[429].exec("a\x0d\nb", 857));2501assertNull(res[429].exec("a\x85b", 858));2502assertNull(res[429].exec("a\x0bb ", 859));2503assertNull(res[429].exec("** Failers ", 860));2504assertNull(res[429].exec("a\x85b<bsr_anycrlf>", 861));2505assertNull(res[429].exec("a\x0bb<bsr_anycrlf>", 862));2506assertNull(res[430].exec("a\x0d\n\nb", 863));2507assertNull(res[430].exec("a\n\x0d\x0db", 864));2508assertNull(res[430].exec("a\x0d\n\x0d\n\x0d\n\x0d\nb", 865));2509assertNull(res[430].exec("** Failers", 866));2510assertNull(res[430].exec("a\x8585b", 867));2511assertNull(res[430].exec("a\x0b\x00bb ", 868));2512assertNull(res[431].exec("a\x0d\x0db", 869));2513assertNull(res[431].exec("a\n\n\nb", 870));2514assertNull(res[431].exec("a\x0d\n\n\x0d\x0db", 871));2515assertNull(res[431].exec("a\x8585b", 872));2516assertNull(res[431].exec("a\x0b\x00bb ", 873));2517assertNull(res[431].exec("** Failers ", 874));2518assertNull(res[431].exec("a\x0d\x0d\x0d\x0d\x0db ", 875));2519assertNull(res[431].exec("a\x8585b<bsr_anycrlf>", 876));2520assertNull(res[431].exec("a\x0b\x00bb<bsr_anycrlf>", 877));2521assertNull(res[431].exec("a\nb", 878));2522assertNull(res[431].exec("a\x0db ", 879));2523assertNull(res[431].exec("a\x85b", 880));2524assertNull(res[431].exec("a\nb", 881));2525assertNull(res[431].exec("a\x0db ", 882));2526assertNull(res[431].exec("a\x85b", 883));2527assertThrows("var re = /(?-+a)/;");2528assertNull(res[443].exec("aaaa", 885));2529assertNull(res[443].exec("bacxxx", 886));2530assertNull(res[443].exec("bbaccxxx ", 887));2531assertNull(res[443].exec("bbbacccxx", 888));2532assertNull(res[443].exec("aaaa", 889));2533assertNull(res[443].exec("bacxxx", 890));2534assertNull(res[443].exec("bbaccxxx ", 891));2535assertNull(res[443].exec("bbbacccxx", 892));2536assertToStringEquals("a,a", res[444].exec("aaaa"), 893);2537assertNull(res[444].exec("bacxxx", 894));2538assertNull(res[444].exec("bbaccxxx ", 895));2539assertNull(res[444].exec("bbbacccxx", 896));2540assertToStringEquals("a,a", res[445].exec("aaaa"), 897);2541assertNull(res[445].exec("bacxxx", 898));2542assertNull(res[445].exec("bbaccxxx ", 899));2543assertNull(res[445].exec("bbbacccxx", 900));2544assertToStringEquals("a,a", res[446].exec("aaaa"), 901);2545assertNull(res[446].exec("bacxxx", 902));2546assertNull(res[446].exec("bbaccxxx ", 903));2547assertNull(res[446].exec("bbbacccxx", 904));2548assertToStringEquals("a,a,a", res[447].exec("aaaa"), 905);2549assertNull(res[447].exec("bacxxx", 906));2550assertNull(res[447].exec("bbaccxxx ", 907));2551assertNull(res[447].exec("bbbacccxx", 908));2552assertNull(res[449].exec("bacxxx", 909));2553assertNull(res[449].exec("XaaX", 910));2554assertNull(res[449].exec("XAAX ", 911));2555assertNull(res[449].exec("XaaX", 912));2556assertNull(res[449].exec("** Failers ", 913));2557assertNull(res[449].exec("XAAX ", 914));2558assertNull(res[449].exec("XaaX", 915));2559assertNull(res[449].exec("XAAX ", 916));2560assertNull(res[449].exec("xzxx", 917));2561assertNull(res[449].exec("yzyy ", 918));2562assertNull(res[449].exec("** Failers", 919));2563assertNull(res[449].exec("xxz ", 920));2564assertToStringEquals("a,,,a", res[450].exec("cat"), 921);2565assertToStringEquals("a,,,a", res[451].exec("cat"), 922);2566assertToStringEquals("TA]", res[452].exec("The ACTA] comes "), 923);2567assertToStringEquals("TA]", res[453].exec("The ACTA] comes "), 924);2568assertNull(res[453].exec("abcbabc", 925));2569assertNull(res[453].exec("abcbabc", 926));2570assertNull(res[453].exec("abcbabc", 927));2571assertNull(res[453].exec("** Failers ", 928));2572assertNull(res[453].exec("abcXabc", 929));2573assertNull(res[453].exec("abcXabc", 930));2574assertNull(res[453].exec("** Failers ", 931));2575assertNull(res[453].exec("abcbabc", 932));2576assertNull(res[453].exec("xyzbabcxyz", 933));2577assertNull(res[456].exec("** Failers", 934));2578assertNull(res[456].exec("ab", 935));2579assertNull(res[457].exec("** Failers", 936));2580assertNull(res[457].exec("ab ", 937));2581assertNull(res[457].exec("** Failers", 938));2582assertNull(res[457].exec("ab ", 939));2583assertToStringEquals("aXb", res[458].exec("aXb"), 940);2584assertToStringEquals("a\nb", res[458].exec("a\nb "), 941);2585assertNull(res[458].exec("** Failers", 942));2586assertNull(res[458].exec("ab ", 943));2587assertToStringEquals("aXb", res[459].exec("aXb"), 944);2588assertToStringEquals("a\nX\nXb", res[459].exec("a\nX\nXb "), 945);2589assertNull(res[459].exec("** Failers", 946));2590assertNull(res[459].exec("ab ", 947));2591assertToStringEquals("acb", res[463].exec("acb"), 948);2592assertToStringEquals("ab", res[463].exec("ab"), 949);2593assertNull(res[463].exec("ax{100}b ", 950));2594assertNull(res[463].exec("*** Failers", 951));2595assertNull(res[463].exec("a\nb ", 952));2596assertNull(res[464].exec("ax{4000}xyb ", 953));2597assertNull(res[464].exec("ax{4000}yb ", 954));2598assertNull(res[464].exec("ax{4000}x{100}yb ", 955));2599assertNull(res[464].exec("*** Failers", 956));2600assertNull(res[464].exec("ax{4000}b ", 957));2601assertNull(res[464].exec("ac\ncb ", 958));2602assertToStringEquals("a\xc0,,\xc0", res[465].exec("a\xc0\x88b"), 959);2603assertToStringEquals("ax,,x", res[466].exec("ax{100}b"), 960);2604assertToStringEquals("a\xc0\x88b,\xc0\x88,b", res[467].exec("a\xc0\x88b"), 961);2605assertToStringEquals("ax{100}b,x{100},b", res[468].exec("ax{100}b"), 962);2606assertToStringEquals("a\xc0\x92,\xc0,\x92", res[469].exec("a\xc0\x92bcd"), 963);2607assertToStringEquals("ax{,x,{", res[470].exec("ax{240}bcd"), 964);2608assertToStringEquals("a\xc0\x92,\xc0,\x92", res[471].exec("a\xc0\x92bcd"), 965);2609assertToStringEquals("ax{,x,{", res[472].exec("ax{240}bcd"), 966);2610assertToStringEquals("a\xc0,,\xc0", res[473].exec("a\xc0\x92bcd"), 967);2611assertToStringEquals("ax,,x", res[474].exec("ax{240}bcd"), 968);2612assertNull(res[475].exec("ax{1234}xyb ", 969));2613assertNull(res[475].exec("ax{1234}x{4321}yb ", 970));2614assertNull(res[475].exec("ax{1234}x{4321}x{3412}b ", 971));2615assertNull(res[475].exec("*** Failers", 972));2616assertNull(res[475].exec("ax{1234}b ", 973));2617assertNull(res[475].exec("ac\ncb ", 974));2618assertToStringEquals("ax{1234}xyb,x{1234}xy", res[476].exec("ax{1234}xyb "), 975);2619assertToStringEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[476].exec("ax{1234}x{4321}yb "), 976);2620assertToStringEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[476].exec("ax{1234}x{4321}x{3412}b "), 977);2621assertToStringEquals("axxxxbcdefghijb,xxxxbcdefghij", res[476].exec("axxxxbcdefghijb "), 978);2622assertToStringEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[476].exec("ax{1234}x{4321}x{3412}x{3421}b "), 979);2623assertNull(res[476].exec("*** Failers", 980));2624assertToStringEquals("ax{1234}b,x{1234}", res[476].exec("ax{1234}b "), 981);2625assertToStringEquals("ax{1234}xyb,x{1234}xy", res[477].exec("ax{1234}xyb "), 982);2626assertToStringEquals("ax{1234}x{4321}yb,x{1234}x{4321}y", res[477].exec("ax{1234}x{4321}yb "), 983);2627assertToStringEquals("ax{1234}x{4321}x{3412}b,x{1234}x{4321}x{3412}", res[477].exec("ax{1234}x{4321}x{3412}b "), 984);2628assertToStringEquals("axxxxb,xxxx", res[477].exec("axxxxbcdefghijb "), 985);2629assertToStringEquals("ax{1234}x{4321}x{3412}x{3421}b,x{1234}x{4321}x{3412}x{3421}", res[477].exec("ax{1234}x{4321}x{3412}x{3421}b "), 986);2630assertNull(res[477].exec("*** Failers", 987));2631assertToStringEquals("ax{1234}b,x{1234}", res[477].exec("ax{1234}b "), 988);2632assertNull(res[478].exec("ax{1234}xyb ", 989));2633assertNull(res[478].exec("ax{1234}x{4321}yb ", 990));2634assertNull(res[478].exec("ax{1234}x{4321}x{3412}b ", 991));2635assertToStringEquals("axxxxb,xxxx", res[478].exec("axxxxbcdefghijb "), 992);2636assertNull(res[478].exec("ax{1234}x{4321}x{3412}x{3421}b ", 993));2637assertToStringEquals("axbxxb,xbxx", res[478].exec("axbxxbcdefghijb "), 994);2638assertToStringEquals("axxxxxb,xxxxx", res[478].exec("axxxxxbcdefghijb "), 995);2639assertNull(res[478].exec("*** Failers", 996));2640assertNull(res[478].exec("ax{1234}b ", 997));2641assertNull(res[478].exec("axxxxxxbcdefghijb ", 998));2642assertNull(res[479].exec("ax{1234}xyb ", 999));2643assertNull(res[479].exec("ax{1234}x{4321}yb ", 1000));2644assertNull(res[479].exec("ax{1234}x{4321}x{3412}b ", 1001));2645assertToStringEquals("axxxxb,xxxx", res[479].exec("axxxxbcdefghijb "), 1002);2646assertNull(res[479].exec("ax{1234}x{4321}x{3412}x{3421}b ", 1003));2647assertToStringEquals("axbxxb,xbxx", res[479].exec("axbxxbcdefghijb "), 1004);2648assertToStringEquals("axxxxxb,xxxxx", res[479].exec("axxxxxbcdefghijb "), 1005);2649assertNull(res[479].exec("*** Failers", 1006));2650assertNull(res[479].exec("ax{1234}b ", 1007));2651assertNull(res[479].exec("axxxxxxbcdefghijb ", 1008));2652assertNull(res[479].exec("*** Failers", 1009));2653assertNull(res[479].exec("x{100}", 1010));2654assertNull(res[479].exec("aXbcd", 1011));2655assertNull(res[479].exec("ax{100}bcd", 1012));2656assertNull(res[479].exec("ax{100000}bcd", 1013));2657assertNull(res[479].exec("x{100}x{100}x{100}b", 1014));2658assertNull(res[479].exec("*** Failers ", 1015));2659assertNull(res[479].exec("x{100}x{100}b", 1016));2660assertNull(res[479].exec("x{ab} ", 1017));2661assertNull(res[479].exec("\xc2\xab", 1018));2662assertNull(res[479].exec("*** Failers ", 1019));2663assertNull(res[479].exec("\x00{ab}", 1020));2664assertNull(res[479].exec("WXYZ", 1021));2665assertNull(res[479].exec("x{256}XYZ ", 1022));2666assertNull(res[479].exec("*** Failers", 1023));2667assertNull(res[479].exec("XYZ ", 1024));2668assertNull(res[480].exec("Xx{1234}", 1025));2669assertNull(res[481].exec("Xx{1234}YZ", 1026));2670assertToStringEquals("X", res[482].exec("XYZabcdce"), 1027);2671assertToStringEquals("X", res[483].exec("XYZabcde"), 1028);2672assertNull(res[484].exec("Xabcdefg ", 1029));2673assertNull(res[484].exec("Xx{1234} ", 1030));2674assertNull(res[484].exec("Xx{1234}YZ", 1031));2675assertNull(res[484].exec("Xx{1234}x{512} ", 1032));2676assertNull(res[484].exec("Xx{1234}x{512}YZ", 1033));2677assertNull(res[485].exec("Xabcdefg ", 1034));2678assertNull(res[485].exec("Xx{1234} ", 1035));2679assertNull(res[485].exec("Xx{1234}YZ", 1036));2680assertNull(res[485].exec("Xx{1234}x{512} ", 1037));2681assertToStringEquals("bcd", res[486].exec("bcd"), 1038);2682assertToStringEquals("00}", res[486].exec("x{100}aYx{256}Z "), 1039);2683assertToStringEquals("x{", res[487].exec("x{100}bc"), 1040);2684assertToStringEquals("x{100}bcA", res[488].exec("x{100}bcAa"), 1041);2685assertToStringEquals("x{", res[489].exec("x{100}bca"), 1042);2686assertToStringEquals("bcd", res[490].exec("bcd"), 1043);2687assertToStringEquals("00}", res[490].exec("x{100}aYx{256}Z "), 1044);2688assertToStringEquals("x{", res[491].exec("x{100}bc"), 1045);2689assertToStringEquals("x{100}bc", res[492].exec("x{100}bcAa"), 1046);2690assertToStringEquals("x{", res[493].exec("x{100}bca"), 1047);2691assertNull(res[493].exec("abcd", 1048));2692assertNull(res[493].exec("abcd", 1049));2693assertToStringEquals("x{", res[493].exec("x{100}x{100} "), 1050);2694assertToStringEquals("x{", res[493].exec("x{100}x{100} "), 1051);2695assertToStringEquals("x{", res[493].exec("x{100}x{100}x{100}x{100} "), 1052);2696assertNull(res[493].exec("abce", 1053));2697assertToStringEquals("x{", res[493].exec("x{100}x{100}x{100}x{100} "), 1054);2698assertNull(res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1055));2699assertNull(res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1056));2700assertNull(res[493].exec("abcdx{100}x{100}x{100}x{100} ", 1057));2701assertNull(res[493].exec("abcdx{100}x{100}x{100}XX", 1058));2702assertNull(res[493].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 1059));2703assertNull(res[493].exec("abcdx{100}x{100}x{100}x{100}x{100}x{100}x{100}XX", 1060));2704assertToStringEquals("Xy", res[493].exec("Xyyyax{100}x{100}bXzzz"), 1061);2705assertToStringEquals("X", res[496].exec("1X2"), 1062);2706assertToStringEquals("x", res[496].exec("1x{100}2 "), 1063);2707assertToStringEquals(">X", res[497].exec("> >X Y"), 1064);2708assertToStringEquals(">x", res[497].exec("> >x{100} Y"), 1065);2709assertToStringEquals("1", res[498].exec("x{100}3"), 1066);2710assertToStringEquals(" ", res[499].exec("x{100} X"), 1067);2711assertToStringEquals("abcd", res[500].exec("12abcd34"), 1068);2712assertToStringEquals("*** Failers", res[500].exec("*** Failers"), 1069);2713assertToStringEquals(" ", res[500].exec("1234 "), 1070);2714assertToStringEquals("abc", res[501].exec("12abcd34"), 1071);2715assertToStringEquals("ab", res[501].exec("12ab34"), 1072);2716assertToStringEquals("***", res[501].exec("*** Failers "), 1073);2717assertNull(res[501].exec("1234", 1074));2718assertToStringEquals(" ", res[501].exec("12a34 "), 1075);2719assertToStringEquals("ab", res[502].exec("12abcd34"), 1076);2720assertToStringEquals("ab", res[502].exec("12ab34"), 1077);2721assertToStringEquals("**", res[502].exec("*** Failers "), 1078);2722assertNull(res[502].exec("1234", 1079));2723assertToStringEquals(" ", res[502].exec("12a34 "), 1080);2724assertToStringEquals("12", res[503].exec("12abcd34"), 1081);2725assertNull(res[503].exec("*** Failers", 1082));2726assertToStringEquals("12", res[504].exec("12abcd34"), 1083);2727assertToStringEquals("123", res[504].exec("1234abcd"), 1084);2728assertNull(res[504].exec("*** Failers ", 1085));2729assertNull(res[504].exec("1.4 ", 1086));2730assertToStringEquals("12", res[505].exec("12abcd34"), 1087);2731assertToStringEquals("12", res[505].exec("1234abcd"), 1088);2732assertNull(res[505].exec("*** Failers ", 1089));2733assertNull(res[505].exec("1.4 ", 1090));2734assertToStringEquals("12abcd34", res[506].exec("12abcd34"), 1091);2735assertToStringEquals("***", res[506].exec("*** Failers"), 1092);2736assertNull(res[506].exec(" ", 1093));2737assertToStringEquals("12a", res[507].exec("12abcd34"), 1094);2738assertToStringEquals("123", res[507].exec("1234abcd"), 1095);2739assertToStringEquals("***", res[507].exec("*** Failers"), 1096);2740assertNull(res[507].exec(" ", 1097));2741assertToStringEquals("12", res[508].exec("12abcd34"), 1098);2742assertToStringEquals("12", res[508].exec("1234abcd"), 1099);2743assertToStringEquals("**", res[508].exec("*** Failers"), 1100);2744assertNull(res[508].exec(" ", 1101));2745assertToStringEquals("> <", res[509].exec("12> <34"), 1102);2746assertNull(res[509].exec("*** Failers", 1103));2747assertToStringEquals("> <", res[510].exec("ab> <cd"), 1104);2748assertToStringEquals("> <", res[510].exec("ab> <ce"), 1105);2749assertNull(res[510].exec("*** Failers", 1106));2750assertNull(res[510].exec("ab> <cd ", 1107));2751assertToStringEquals("> <", res[511].exec("ab> <cd"), 1108);2752assertToStringEquals("> <", res[511].exec("ab> <ce"), 1109);2753assertNull(res[511].exec("*** Failers", 1110));2754assertNull(res[511].exec("ab> <cd ", 1111));2755assertToStringEquals("12", res[512].exec("12 34"), 1112);2756assertToStringEquals("Failers", res[512].exec("*** Failers"), 1113);2757assertNull(res[512].exec("+++=*! ", 1114));2758assertToStringEquals("ab", res[513].exec("ab cd"), 1115);2759assertToStringEquals("abc", res[513].exec("abcd ce"), 1116);2760assertToStringEquals("Fai", res[513].exec("*** Failers"), 1117);2761assertNull(res[513].exec("a.b.c", 1118));2762assertToStringEquals("ab", res[514].exec("ab cd"), 1119);2763assertToStringEquals("ab", res[514].exec("abcd ce"), 1120);2764assertToStringEquals("Fa", res[514].exec("*** Failers"), 1121);2765assertNull(res[514].exec("a.b.c", 1122));2766assertToStringEquals("====", res[515].exec("12====34"), 1123);2767assertToStringEquals("*** ", res[515].exec("*** Failers"), 1124);2768assertToStringEquals(" ", res[515].exec("abcd "), 1125);2769assertToStringEquals("===", res[516].exec("ab====cd"), 1126);2770assertToStringEquals("==", res[516].exec("ab==cd"), 1127);2771assertToStringEquals("***", res[516].exec("*** Failers"), 1128);2772assertNull(res[516].exec("a.b.c", 1129));2773assertToStringEquals("==", res[517].exec("ab====cd"), 1130);2774assertToStringEquals("==", res[517].exec("ab==cd"), 1131);2775assertToStringEquals("**", res[517].exec("*** Failers"), 1132);2776assertNull(res[517].exec("a.b.c", 1133));2777assertNull(res[517].exec("x{100}", 1134));2778assertNull(res[517].exec("Zx{100}", 1135));2779assertNull(res[517].exec("x{100}Z", 1136));2780assertToStringEquals("**", res[517].exec("*** Failers "), 1137);2781assertNull(res[517].exec("Zx{100}", 1138));2782assertNull(res[517].exec("x{100}", 1139));2783assertNull(res[517].exec("x{100}Z", 1140));2784assertToStringEquals("**", res[517].exec("*** Failers "), 1141);2785assertNull(res[517].exec("abcx{200}X", 1142));2786assertNull(res[517].exec("abcx{100}X ", 1143));2787assertToStringEquals("**", res[517].exec("*** Failers"), 1144);2788assertToStringEquals(" ", res[517].exec("X "), 1145);2789assertNull(res[517].exec("abcx{200}X", 1146));2790assertNull(res[517].exec("abcx{100}X ", 1147));2791assertNull(res[517].exec("abQX ", 1148));2792assertToStringEquals("**", res[517].exec("*** Failers"), 1149);2793assertToStringEquals(" ", res[517].exec("X "), 1150);2794assertNull(res[517].exec("abcx{100}x{200}x{100}X", 1151));2795assertToStringEquals("**", res[517].exec("*** Failers"), 1152);2796assertNull(res[517].exec("abcx{200}X", 1153));2797assertToStringEquals(" ", res[517].exec("X "), 1154);2798assertNull(res[517].exec("AX", 1155));2799assertNull(res[517].exec("x{150}X", 1156));2800assertNull(res[517].exec("x{500}X ", 1157));2801assertToStringEquals("**", res[517].exec("*** Failers"), 1158);2802assertNull(res[517].exec("x{100}X", 1159));2803assertToStringEquals(" ", res[517].exec("x{200}X "), 1160);2804assertNull(res[517].exec("AX", 1161));2805assertNull(res[517].exec("x{150}X", 1162));2806assertNull(res[517].exec("x{500}X ", 1163));2807assertToStringEquals("**", res[517].exec("*** Failers"), 1164);2808assertNull(res[517].exec("x{100}X", 1165));2809assertToStringEquals(" ", res[517].exec("x{200}X "), 1166);2810assertNull(res[517].exec("QX ", 1167));2811assertNull(res[517].exec("AX", 1168));2812assertNull(res[517].exec("x{500}X ", 1169));2813assertToStringEquals("**", res[517].exec("*** Failers"), 1170);2814assertNull(res[517].exec("x{100}X", 1171));2815assertNull(res[517].exec("x{150}X", 1172));2816assertToStringEquals(" ", res[517].exec("x{200}X "), 1173);2817assertNull(res[518].exec("aXb", 1174));2818assertNull(res[518].exec("a\nb", 1175));2819assertNull(res[519].exec("aXb", 1176));2820assertNull(res[519].exec("a\nb", 1177));2821assertNull(res[519].exec("*** Failers ", 1178));2822assertNull(res[519].exec("ax{100}b ", 1179));2823assertNull(res[519].exec("z", 1180));2824assertNull(res[519].exec("Z ", 1181));2825assertNull(res[519].exec("x{100}", 1182));2826assertNull(res[519].exec("*** Failers", 1183));2827assertNull(res[519].exec("x{102}", 1184));2828assertNull(res[519].exec("y ", 1185));2829assertToStringEquals("\xff", res[520].exec(">\xff<"), 1186);2830assertNull(res[521].exec(">x{ff}<", 1187));2831assertToStringEquals("X", res[522].exec("XYZ"), 1188);2832assertToStringEquals("X", res[523].exec("XYZ"), 1189);2833assertToStringEquals("x", res[523].exec("x{123} "), 1190);2834assertToStringEquals(",", res[528].exec("catac"), 1191);2835assertToStringEquals(",", res[528].exec("ax{256}a "), 1192);2836assertToStringEquals(",", res[528].exec("x{85}"), 1193);2837assertToStringEquals(",", res[528].exec("\u1234 "), 1194);2838assertToStringEquals(",", res[528].exec("\u1234 "), 1195);2839assertToStringEquals(",", res[528].exec("abcdefg"), 1196);2840assertToStringEquals(",", res[528].exec("ab"), 1197);2841assertToStringEquals(",", res[528].exec("a "), 1198);2842assertToStringEquals("Ax", res[529].exec("Ax{a3}BC"), 1199);2843assertToStringEquals("Ax", res[530].exec("Ax{a3}BC"), 1200);2844assertToStringEquals("}=", res[531].exec("+x{a3}== "), 1201);2845assertToStringEquals("}=", res[532].exec("+x{a3}== "), 1202);2846assertToStringEquals("x", res[533].exec("x{442}x{435}x{441}x{442}"), 1203);2847assertToStringEquals("x", res[534].exec("x{442}x{435}x{441}x{442}"), 1204);2848assertToStringEquals("x", res[535].exec("x{442}x{435}x{441}x{442}"), 1205);2849assertToStringEquals("x", res[536].exec("x{442}x{435}x{441}x{442}"), 1206);2850assertToStringEquals("{", res[537].exec("x{2442}x{2435}x{2441}x{2442}"), 1207);2851assertToStringEquals("{", res[538].exec("x{2442}x{2435}x{2441}x{2442}"), 1208);2852assertToStringEquals("abc\n\x0dx{442}x{435}x{441}x{442}xyz ", res[539].exec("abc\n\x0dx{442}x{435}x{441}x{442}xyz "), 1209);2853assertToStringEquals("x{442}x{435}x{441}x{442}", res[539].exec("x{442}x{435}x{441}x{442}"), 1210);2854assertToStringEquals("c d", res[540].exec("abc defx{442}x{443}xyz\npqr"), 1211);2855assertToStringEquals("c d", res[541].exec("abc defx{442}x{443}xyz\npqr"), 1212);2856assertNull(res[542].exec("+x{2442}", 1213));2857assertNull(res[543].exec("+x{2442}", 1214));2858assertNull(res[544].exec("Ax{442}", 1215));2859assertNull(res[545].exec("Ax{442}", 1216));2860assertNull(res[546].exec("Ax{442}", 1217));2861assertNull(res[547].exec("Ax{442}", 1218));2862assertNull(res[548].exec("\x19x{e01ff}", 1219));2863assertNull(res[549].exec("Ax{422}", 1220));2864assertNull(res[550].exec("x{19}x{e01ff}", 1221));2865assertNull(res[551].exec("Ax{442}", 1222));2866assertNull(res[552].exec("Ax{442}", 1223));2867assertNull(res[553].exec("ax{442}", 1224));2868assertNull(res[554].exec("+x{2442}", 1225));2869assertNull(res[555].exec("Mx{442}", 1226));2870assertToStringEquals("abc", res[556].exec("abc"), 1227);2871assertToStringEquals("abc", res[557].exec("abc"), 1228);2872assertToStringEquals("abc", res[558].exec("abc"), 1229);2873assertToStringEquals("abc", res[559].exec("abc"), 1230);2874assertNull(res[560].exec("x{100}ax{1234}bcd", 1231));2875assertNull(res[562].exec("x{0041}x{2262}x{0391}x{002e}", 1232));2876assertNull(res[562].exec("x{D55c}x{ad6d}x{C5B4} ", 1233));2877assertNull(res[562].exec("x{65e5}x{672c}x{8a9e}", 1234));2878assertToStringEquals("{861}X", res[563].exec("x{212ab}x{212ab}x{212ab}x{861}X"), 1235);2879assertToStringEquals("x{2", res[564].exec("x{212ab}x{212ab}x{212ab}x{861}"), 1236);2880assertToStringEquals("x{c", res[564].exec("x{c0}b"), 1237);2881assertToStringEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1238);2882assertToStringEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1239);2883assertToStringEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1240);2884assertToStringEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1241);2885assertToStringEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1242);2886assertToStringEquals("ax{", res[564].exec("ax{c0}aaaa/ "), 1243);2887assertToStringEquals("ax{", res[564].exec("ax{c0}ax{c0}aaa/ "), 1244);2888assertToStringEquals("Sho", res[564].exec("Should produce an error diagnostic"), 1245);2889assertNull(res[565].exec("Xx{1234}", 1246));2890assertNull(res[565].exec("X\nabc ", 1247));2891assertToStringEquals("b", res[566].exec("bar"), 1248);2892assertNull(res[566].exec("*** Failers", 1249));2893assertNull(res[566].exec("c", 1250));2894assertNull(res[566].exec("x{ff}", 1251));2895assertNull(res[566].exec("x{100} ", 1252));2896assertToStringEquals("c", res[567].exec("c"), 1253);2897assertToStringEquals("x", res[567].exec("x{ff}"), 1254);2898assertToStringEquals("x", res[567].exec("x{100} "), 1255);2899assertToStringEquals("*", res[567].exec("*** Failers "), 1256);2900assertNull(res[567].exec("aaa", 1257));2901assertToStringEquals("x", res[568].exec("x{f1}"), 1258);2902assertToStringEquals("x", res[568].exec("x{bf}"), 1259);2903assertToStringEquals("x", res[568].exec("x{100}"), 1260);2904assertToStringEquals("x", res[568].exec("x{1000} "), 1261);2905assertToStringEquals("*", res[568].exec("*** Failers"), 1262);2906assertToStringEquals("x", res[568].exec("x{c0} "), 1263);2907assertToStringEquals("x", res[568].exec("x{f0} "), 1264);2908assertToStringEquals("1", res[568].exec("1234"), 1265);2909assertToStringEquals("\"", res[568].exec("\"1234\" "), 1266);2910assertToStringEquals("x", res[568].exec("x{100}1234"), 1267);2911assertToStringEquals("\"", res[568].exec("\"x{100}1234\" "), 1268);2912assertToStringEquals("x", res[568].exec("x{100}x{100}12ab "), 1269);2913assertToStringEquals("x", res[568].exec("x{100}x{100}\"12\" "), 1270);2914assertToStringEquals("*", res[568].exec("*** Failers "), 1271);2915assertToStringEquals("x", res[568].exec("x{100}x{100}abcd"), 1272);2916assertToStringEquals("A", res[568].exec("A"), 1273);2917assertToStringEquals("x", res[568].exec("x{100}"), 1274);2918assertToStringEquals("Z", res[568].exec("Zx{100}"), 1275);2919assertToStringEquals("x", res[568].exec("x{100}Z"), 1276);2920assertToStringEquals("*", res[568].exec("*** Failers "), 1277);2921assertToStringEquals("Z", res[568].exec("Zx{100}"), 1278);2922assertToStringEquals("x", res[568].exec("x{100}"), 1279);2923assertToStringEquals("x", res[568].exec("x{100}Z"), 1280);2924assertToStringEquals("*", res[568].exec("*** Failers "), 1281);2925assertToStringEquals("x", res[568].exec("x{100}"), 1282);2926assertToStringEquals("x", res[568].exec("x{104}"), 1283);2927assertToStringEquals("*", res[568].exec("*** Failers"), 1284);2928assertToStringEquals("x", res[568].exec("x{105}"), 1285);2929assertToStringEquals("x", res[568].exec("x{ff} "), 1286);2930assertToStringEquals("x", res[568].exec("x{100}"), 1287);2931assertToStringEquals("\u0100", res[568].exec("\u0100 "), 1288);2932assertToStringEquals("\xff", res[569].exec(">\xff<"), 1289);2933assertNull(res[570].exec(">x{ff}<", 1290));2934assertToStringEquals("\xd6", res[572].exec("\xd6 # Matches without Study"), 1291);2935assertToStringEquals("x", res[572].exec("x{d6}"), 1292);2936assertToStringEquals("\xd6", res[572].exec("\xd6 <-- Same with Study"), 1293);2937assertToStringEquals("x", res[572].exec("x{d6}"), 1294);2938assertToStringEquals("\xd6", res[572].exec("\xd6 # Matches without Study"), 1295);2939assertToStringEquals("x", res[572].exec("x{d6} "), 1296);2940assertToStringEquals("\xd6", res[572].exec("\xd6 <-- Same with Study"), 1297);2941assertToStringEquals("x", res[572].exec("x{d6} "), 1298);2942assertToStringEquals("\ufffd", res[572].exec("\ufffd]"), 1299);2943assertToStringEquals("\ufffd", res[572].exec("\ufffd"), 1300);2944assertToStringEquals("\ufffd", res[572].exec("\ufffd\ufffd\ufffd"), 1301);2945assertToStringEquals("\ufffd", res[572].exec("\ufffd\ufffd\ufffd?"), 1302);2946assertNull(res[573].exec("\xc0\x80", 1303));2947assertNull(res[573].exec("\xc1\x8f ", 1304));2948assertNull(res[573].exec("\xe0\x9f\x80", 1305));2949assertNull(res[573].exec("\xf0\x8f\x80\x80 ", 1306));2950assertNull(res[573].exec("\xf8\x87\x80\x80\x80 ", 1307));2951assertNull(res[573].exec("\xfc\x83\x80\x80\x80\x80", 1308));2952assertNull(res[573].exec("\xfe\x80\x80\x80\x80\x80 ", 1309));2953assertNull(res[573].exec("\xff\x80\x80\x80\x80\x80 ", 1310));2954assertNull(res[573].exec("\xc3\x8f", 1311));2955assertNull(res[573].exec("\xe0\xaf\x80", 1312));2956assertNull(res[573].exec("\xe1\x80\x80", 1313));2957assertNull(res[573].exec("\xf0\x9f\x80\x80 ", 1314));2958assertNull(res[573].exec("\xf1\x8f\x80\x80 ", 1315));2959assertNull(res[573].exec("\xf8\x88\x80\x80\x80 ", 1316));2960assertNull(res[573].exec("\xf9\x87\x80\x80\x80 ", 1317));2961assertNull(res[573].exec("\xfc\x84\x80\x80\x80\x80", 1318));2962assertNull(res[573].exec("\xfd\x83\x80\x80\x80\x80", 1319));2963assertNull(res[573].exec("?\xf8\x88\x80\x80\x80 ", 1320));2964assertNull(res[573].exec("?\xf9\x87\x80\x80\x80 ", 1321));2965assertNull(res[573].exec("?\xfc\x84\x80\x80\x80\x80", 1322));2966assertNull(res[573].exec("?\xfd\x83\x80\x80\x80\x80", 1323));2967assertToStringEquals(".", res[574].exec("A.B"), 1324);2968assertToStringEquals("{", res[574].exec("Ax{100}B "), 1325);2969assertToStringEquals("x", res[575].exec("x{100}X "), 1326);2970assertToStringEquals("a", res[575].exec("ax{1234}b"), 1327);2971assertNull(res[577].exec("AxxB ", 1328));2972assertToStringEquals("abc1", res[578].exec("abc1 \nabc2 \x0babc3xx \x0cabc4 \x0dabc5xx \x0d\nabc6 x{0085}abc7 x{2028}abc8 x{2029}abc9 JUNK"), 1329);2973assertToStringEquals("abc1", res[579].exec("abc1\n abc2\x0b abc3\x0c abc4\x0d abc5\x0d\n abc6x{0085} abc7x{2028} abc8x{2029} abc9"), 1330);2974assertNull(res[580].exec("a\nb", 1331));2975assertNull(res[580].exec("a\x0db", 1332));2976assertNull(res[580].exec("a\x0d\nb", 1333));2977assertNull(res[580].exec("a\x0bb", 1334));2978assertNull(res[580].exec("a\x0cb", 1335));2979assertNull(res[580].exec("ax{85}b ", 1336));2980assertNull(res[580].exec("ax{2028}b ", 1337));2981assertNull(res[580].exec("ax{2029}b ", 1338));2982assertNull(res[580].exec("** Failers", 1339));2983assertNull(res[580].exec("a\n\x0db ", 1340));2984assertToStringEquals("ab", res[581].exec("ab"), 1341);2985assertNull(res[581].exec("a\nb", 1342));2986assertNull(res[581].exec("a\x0db", 1343));2987assertNull(res[581].exec("a\x0d\nb", 1344));2988assertNull(res[581].exec("a\x0bb", 1345));2989assertNull(res[581].exec("a\x0cx{2028}x{2029}b", 1346));2990assertNull(res[581].exec("ax{85}b ", 1347));2991assertNull(res[581].exec("a\n\x0db ", 1348));2992assertNull(res[581].exec("a\n\x0dx{85}\x0cb ", 1349));2993assertNull(res[582].exec("a\nb", 1350));2994assertNull(res[582].exec("a\x0db", 1351));2995assertNull(res[582].exec("a\x0d\nb", 1352));2996assertNull(res[582].exec("a\x0bb", 1353));2997assertNull(res[582].exec("a\x0cx{2028}x{2029}b", 1354));2998assertNull(res[582].exec("ax{85}b ", 1355));2999assertNull(res[582].exec("a\n\x0db ", 1356));3000assertNull(res[582].exec("a\n\x0dx{85}\x0cb ", 1357));3001assertNull(res[582].exec("** Failers", 1358));3002assertNull(res[582].exec("ab ", 1359));3003assertNull(res[583].exec("a\nb", 1360));3004assertNull(res[583].exec("a\n\x0db", 1361));3005assertNull(res[583].exec("a\n\x0dx{85}b", 1362));3006assertNull(res[583].exec("a\x0d\n\x0d\nb ", 1363));3007assertNull(res[583].exec("a\x0d\n\x0d\n\x0d\nb ", 1364));3008assertNull(res[583].exec("a\n\x0d\n\x0db", 1365));3009assertNull(res[583].exec("a\n\n\x0d\nb ", 1366));3010assertNull(res[583].exec("** Failers", 1367));3011assertNull(res[583].exec("a\n\n\n\x0db", 1368));3012assertNull(res[583].exec("a\x0d", 1369));3013assertNull(res[584].exec("X X\n", 1370));3014assertNull(res[584].exec("X\x09X\x0b", 1371));3015assertNull(res[584].exec("** Failers", 1372));3016assertNull(res[584].exec("x{a0} X\n ", 1373));3017assertNull(res[585].exec("\x09 x{a0}X\n\x0b\x0c\x0d\n", 1374));3018assertNull(res[585].exec("\x09 x{a0}\n\x0b\x0c\x0d\n", 1375));3019assertNull(res[585].exec("\x09 x{a0}\n\x0b\x0c", 1376));3020assertNull(res[585].exec("** Failers ", 1377));3021assertNull(res[585].exec("\x09 x{a0}\n\x0b", 1378));3022assertNull(res[585].exec(" ", 1379));3023assertNull(res[586].exec("x{3001}x{3000}x{2030}x{2028}", 1380));3024assertNull(res[586].exec("Xx{180e}Xx{85}", 1381));3025assertNull(res[586].exec("** Failers", 1382));3026assertNull(res[586].exec("x{2009} X\n ", 1383));3027assertNull(res[587].exec("x{1680}x{180e}x{2007}Xx{2028}x{2029}\x0c\x0d\n", 1384));3028assertNull(res[587].exec("\x09x{205f}x{a0}\nx{2029}\x0cx{2028}\n", 1385));3029assertNull(res[587].exec("\x09 x{202f}\n\x0b\x0c", 1386));3030assertNull(res[587].exec("** Failers ", 1387));3031assertNull(res[587].exec("\x09x{200a}x{a0}x{2028}\x0b", 1388));3032assertNull(res[587].exec(" ", 1389));3033assertNull(res[588].exec(">x{1680}", 1390));3034assertNull(res[589].exec(">x{1680}x{180e}x{2000}x{2003}x{200a}x{202f}x{205f}x{3000}<", 1391));3035assertToStringEquals("x{1ec5} ", res[593].exec("x{1ec5} "), 1392);3036assertNull(res[594].exec("x{0}x{d7ff}x{e000}x{10ffff}", 1393));3037assertNull(res[594].exec("x{d800}", 1394));3038assertNull(res[594].exec("x{d800}?", 1395));3039assertNull(res[594].exec("x{da00}", 1396));3040assertNull(res[594].exec("x{da00}?", 1397));3041assertNull(res[594].exec("x{dfff}", 1398));3042assertNull(res[594].exec("x{dfff}?", 1399));3043assertNull(res[594].exec("x{110000} ", 1400));3044assertNull(res[594].exec("x{110000}? ", 1401));3045assertNull(res[594].exec("x{2000000} ", 1402));3046assertNull(res[594].exec("x{2000000}? ", 1403));3047assertNull(res[594].exec("x{7fffffff} ", 1404));3048assertNull(res[594].exec("x{7fffffff}? ", 1405));3049assertNull(res[595].exec("a\x0db", 1406));3050assertNull(res[595].exec("a\nb", 1407));3051assertNull(res[595].exec("a\x0d\nb", 1408));3052assertNull(res[595].exec("** Failers", 1409));3053assertNull(res[595].exec("ax{85}b", 1410));3054assertNull(res[595].exec("a\x0bb ", 1411));3055assertNull(res[596].exec("a\x0db", 1412));3056assertNull(res[596].exec("a\nb", 1413));3057assertNull(res[596].exec("a\x0d\nb", 1414));3058assertNull(res[596].exec("ax{85}b", 1415));3059assertNull(res[596].exec("a\x0bb ", 1416));3060assertNull(res[596].exec("** Failers ", 1417));3061assertNull(res[596].exec("ax{85}b<bsr_anycrlf>", 1418));3062assertNull(res[596].exec("a\x0bb<bsr_anycrlf>", 1419));3063assertNull(res[597].exec("a\x0db", 1420));3064assertNull(res[597].exec("a\nb", 1421));3065assertNull(res[597].exec("a\x0d\nb", 1422));3066assertNull(res[597].exec("** Failers", 1423));3067assertNull(res[597].exec("ax{85}b", 1424));3068assertNull(res[597].exec("a\x0bb ", 1425));3069assertNull(res[598].exec("a\x0db", 1426));3070assertNull(res[598].exec("a\nb", 1427));3071assertNull(res[598].exec("a\x0d\nb", 1428));3072assertNull(res[598].exec("ax{85}b", 1429));3073assertNull(res[598].exec("a\x0bb ", 1430));3074assertNull(res[598].exec("** Failers ", 1431));3075assertNull(res[598].exec("ax{85}b<bsr_anycrlf>", 1432));3076assertNull(res[598].exec("a\x0bb<bsr_anycrlf>", 1433));3077assertToStringEquals("QQQx{2029}ABCaXYZ=!bPQR", res[599].exec("QQQx{2029}ABCaXYZ=!bPQR"), 1434);3078assertNull(res[599].exec("** Failers", 1435));3079assertNull(res[599].exec("ax{2029}b", 1436));3080assertNull(res[599].exec("a\xe2\x80\xa9b ", 1437));3081assertNull(res[600].exec("ax{1234}b", 1438));3082assertToStringEquals("a\nb", res[600].exec("a\nb "), 1439);3083assertNull(res[600].exec("** Failers", 1440));3084assertNull(res[600].exec("ab ", 1441));3085assertToStringEquals("aXb", res[601].exec("aXb"), 1442);3086assertToStringEquals("a\nX\nXx{1234}b", res[601].exec("a\nX\nXx{1234}b "), 1443);3087assertNull(res[601].exec("** Failers", 1444));3088assertNull(res[601].exec("ab ", 1445));3089assertNull(res[601].exec("x{de}x{de}", 1446));3090assertNull(res[601].exec("x{123} ", 1447));3091assertToStringEquals("X", res[602].exec("Ax{1ec5}ABCXYZ"), 1448);3092assertNull(res[604].exec("x{c0}x{30f}x{660}x{66c}x{f01}x{1680}<", 1449));3093assertNull(res[604].exec("\npx{300}9!$ < ", 1450));3094assertNull(res[604].exec("** Failers ", 1451));3095assertNull(res[604].exec("apx{300}9!$ < ", 1452));3096assertNull(res[605].exec("X", 1453));3097assertNull(res[605].exec("** Failers ", 1454));3098assertNull(res[605].exec("", 1455));3099assertNull(res[606].exec("9", 1456));3100assertNull(res[606].exec("** Failers ", 1457));3101assertNull(res[606].exec("x{c0}", 1458));3102assertNull(res[607].exec("X", 1459));3103assertNull(res[607].exec("** Failers ", 1460));3104assertNull(res[607].exec("x{30f}", 1461));3105assertNull(res[608].exec("X", 1462));3106assertNull(res[608].exec("** Failers ", 1463));3107assertNull(res[608].exec("x{660}", 1464));3108assertNull(res[609].exec("X", 1465));3109assertNull(res[609].exec("** Failers ", 1466));3110assertNull(res[609].exec("x{66c}", 1467));3111assertNull(res[610].exec("X", 1468));3112assertNull(res[610].exec("** Failers ", 1469));3113assertNull(res[610].exec("x{f01}", 1470));3114assertNull(res[611].exec("X", 1471));3115assertNull(res[611].exec("** Failers ", 1472));3116assertNull(res[611].exec("x{1680}", 1473));3117assertNull(res[612].exec("x{017}", 1474));3118assertNull(res[612].exec("x{09f} ", 1475));3119assertNull(res[612].exec("** Failers", 1476));3120assertNull(res[612].exec("x{0600} ", 1477));3121assertNull(res[613].exec("x{601}", 1478));3122assertNull(res[613].exec("** Failers", 1479));3123assertNull(res[613].exec("x{09f} ", 1480));3124assertNull(res[614].exec("x{e0000}", 1481));3125assertNull(res[614].exec("** Failers", 1482));3126assertNull(res[614].exec("x{09f} ", 1483));3127assertNull(res[615].exec("x{f8ff}", 1484));3128assertNull(res[615].exec("** Failers", 1485));3129assertNull(res[615].exec("x{09f} ", 1486));3130assertNull(res[616].exec("?x{dfff}", 1487));3131assertNull(res[616].exec("** Failers", 1488));3132assertNull(res[616].exec("x{09f} ", 1489));3133assertNull(res[617].exec("a", 1490));3134assertNull(res[617].exec("** Failers ", 1491));3135assertNull(res[617].exec("Z", 1492));3136assertNull(res[617].exec("x{e000} ", 1493));3137assertNull(res[618].exec("x{2b0}", 1494));3138assertNull(res[618].exec("** Failers", 1495));3139assertNull(res[618].exec("a ", 1496));3140assertNull(res[619].exec("x{1bb}", 1497));3141assertNull(res[619].exec("x{3400}", 1498));3142assertNull(res[619].exec("x{3401}", 1499));3143assertNull(res[619].exec("x{4d00}", 1500));3144assertNull(res[619].exec("x{4db4}", 1501));3145assertNull(res[619].exec("x{4db5} ", 1502));3146assertNull(res[619].exec("** Failers", 1503));3147assertNull(res[619].exec("a ", 1504));3148assertNull(res[619].exec("x{2b0}", 1505));3149assertNull(res[619].exec("x{4db6} ", 1506));3150assertNull(res[620].exec("x{1c5}", 1507));3151assertNull(res[620].exec("** Failers", 1508));3152assertNull(res[620].exec("a ", 1509));3153assertNull(res[620].exec("x{2b0}", 1510));3154assertNull(res[621].exec("A", 1511));3155assertNull(res[621].exec("** Failers", 1512));3156assertNull(res[621].exec("x{2b0}", 1513));3157assertNull(res[622].exec("x{903}", 1514));3158assertNull(res[622].exec("** Failers", 1515));3159assertNull(res[622].exec("X", 1516));3160assertNull(res[622].exec("x{300}", 1517));3161assertNull(res[622].exec(" ", 1518));3162assertNull(res[623].exec("x{488}", 1519));3163assertNull(res[623].exec("** Failers", 1520));3164assertNull(res[623].exec("X", 1521));3165assertNull(res[623].exec("x{903}", 1522));3166assertNull(res[623].exec("x{300}", 1523));3167assertNull(res[624].exec("x{300}", 1524));3168assertNull(res[624].exec("** Failers", 1525));3169assertNull(res[624].exec("X", 1526));3170assertNull(res[624].exec("x{903}", 1527));3171assertNull(res[624].exec("0123456789x{660}x{661}x{662}x{663}x{664}x{665}x{666}x{667}x{668}x{669}x{66a}", 1528));3172assertNull(res[624].exec("x{6f0}x{6f1}x{6f2}x{6f3}x{6f4}x{6f5}x{6f6}x{6f7}x{6f8}x{6f9}x{6fa}", 1529));3173assertNull(res[624].exec("x{966}x{967}x{968}x{969}x{96a}x{96b}x{96c}x{96d}x{96e}x{96f}x{970}", 1530));3174assertNull(res[624].exec("** Failers", 1531));3175assertNull(res[624].exec("X", 1532));3176assertNull(res[625].exec("x{16ee}", 1533));3177assertNull(res[625].exec("** Failers", 1534));3178assertNull(res[625].exec("X", 1535));3179assertNull(res[625].exec("x{966}", 1536));3180assertNull(res[626].exec("x{b2}", 1537));3181assertNull(res[626].exec("x{b3}", 1538));3182assertNull(res[626].exec("** Failers", 1539));3183assertNull(res[626].exec("X", 1540));3184assertNull(res[626].exec("x{16ee}", 1541));3185assertNull(res[627].exec("_", 1542));3186assertNull(res[627].exec("x{203f}", 1543));3187assertNull(res[627].exec("** Failers", 1544));3188assertNull(res[627].exec("X", 1545));3189assertNull(res[627].exec("-", 1546));3190assertNull(res[627].exec("x{58a}", 1547));3191assertNull(res[628].exec("-", 1548));3192assertNull(res[628].exec("x{58a}", 1549));3193assertNull(res[628].exec("** Failers", 1550));3194assertNull(res[628].exec("X", 1551));3195assertNull(res[628].exec("x{203f}", 1552));3196assertNull(res[629].exec(")", 1553));3197assertNull(res[629].exec("]", 1554));3198assertNull(res[629].exec("}", 1555));3199assertNull(res[629].exec("x{f3b}", 1556));3200assertNull(res[629].exec("** Failers", 1557));3201assertNull(res[629].exec("X", 1558));3202assertNull(res[629].exec("x{203f}", 1559));3203assertNull(res[629].exec("(", 1560));3204assertNull(res[629].exec("[", 1561));3205assertNull(res[629].exec("{", 1562));3206assertNull(res[629].exec("x{f3c}", 1563));3207assertNull(res[630].exec("x{bb}", 1564));3208assertNull(res[630].exec("x{2019}", 1565));3209assertNull(res[630].exec("** Failers", 1566));3210assertNull(res[630].exec("X", 1567));3211assertNull(res[630].exec("x{203f}", 1568));3212assertNull(res[631].exec("x{ab}", 1569));3213assertNull(res[631].exec("x{2018}", 1570));3214assertNull(res[631].exec("** Failers", 1571));3215assertNull(res[631].exec("X", 1572));3216assertNull(res[631].exec("x{203f}", 1573));3217assertNull(res[632].exec("!", 1574));3218assertNull(res[632].exec("x{37e}", 1575));3219assertNull(res[632].exec("** Failers", 1576));3220assertNull(res[632].exec("X", 1577));3221assertNull(res[632].exec("x{203f}", 1578));3222assertNull(res[633].exec("(", 1579));3223assertNull(res[633].exec("[", 1580));3224assertNull(res[633].exec("{", 1581));3225assertNull(res[633].exec("x{f3c}", 1582));3226assertNull(res[633].exec("** Failers", 1583));3227assertNull(res[633].exec("X", 1584));3228assertNull(res[633].exec(")", 1585));3229assertNull(res[633].exec("]", 1586));3230assertNull(res[633].exec("}", 1587));3231assertNull(res[633].exec("x{f3b}", 1588));3232assertNull(res[633].exec("$x{a2}x{a3}x{a4}x{a5}x{a6}", 1589));3233assertNull(res[633].exec("x{9f2}", 1590));3234assertNull(res[633].exec("** Failers", 1591));3235assertNull(res[633].exec("X", 1592));3236assertNull(res[633].exec("x{2c2}", 1593));3237assertNull(res[634].exec("x{2c2}", 1594));3238assertNull(res[634].exec("** Failers", 1595));3239assertNull(res[634].exec("X", 1596));3240assertNull(res[634].exec("x{9f2}", 1597));3241assertNull(res[634].exec("+<|~x{ac}x{2044}", 1598));3242assertNull(res[634].exec("** Failers", 1599));3243assertNull(res[634].exec("X", 1600));3244assertNull(res[634].exec("x{9f2}", 1601));3245assertNull(res[635].exec("x{a6}", 1602));3246assertNull(res[635].exec("x{482} ", 1603));3247assertNull(res[635].exec("** Failers", 1604));3248assertNull(res[635].exec("X", 1605));3249assertNull(res[635].exec("x{9f2}", 1606));3250assertNull(res[636].exec("x{2028}", 1607));3251assertNull(res[636].exec("** Failers", 1608));3252assertNull(res[636].exec("X", 1609));3253assertNull(res[636].exec("x{2029}", 1610));3254assertNull(res[637].exec("x{2029}", 1611));3255assertNull(res[637].exec("** Failers", 1612));3256assertNull(res[637].exec("X", 1613));3257assertNull(res[637].exec("x{2028}", 1614));3258assertNull(res[638].exec("\\ \\", 1615));3259assertNull(res[638].exec("x{a0}", 1616));3260assertNull(res[638].exec("x{1680}", 1617));3261assertNull(res[638].exec("x{180e}", 1618));3262assertNull(res[638].exec("x{2000}", 1619));3263assertNull(res[638].exec("x{2001} ", 1620));3264assertNull(res[638].exec("** Failers", 1621));3265assertNull(res[638].exec("x{2028}", 1622));3266assertNull(res[638].exec("x{200d} ", 1623));3267assertNull(res[638].exec(" x{660}x{661}x{662}ABC", 1624));3268assertNull(res[638].exec(" x{660}x{661}x{662}ABC", 1625));3269assertNull(res[639].exec(" x{660}x{661}x{662}ABC", 1626));3270assertNull(res[640].exec(" x{660}x{661}x{662}ABC", 1627));3271assertNull(res[641].exec(" x{660}x{661}x{662}ABC", 1628));3272assertNull(res[642].exec(" x{660}x{661}x{662}ABC", 1629));3273assertNull(res[643].exec(" x{660}x{661}x{662}ABC", 1630));3274assertNull(res[644].exec(" x{660}x{661}x{662}ABC", 1631));3275assertNull(res[645].exec(" x{660}x{661}x{662}ABC", 1632));3276assertNull(res[646].exec(" x{660}x{661}x{662}ABC", 1633));3277assertNull(res[647].exec(" x{660}x{661}x{662}ABC", 1634));3278assertNull(res[647].exec(" x{660}x{661}x{662}ABC", 1635));3279assertNull(res[647].exec(" x{660}x{661}x{662}ABC", 1636));3280assertNull(res[647].exec(" ** Failers", 1637));3281assertNull(res[647].exec(" x{660}x{661}x{662}ABC", 1638));3282assertNull(res[648].exec("A", 1639));3283assertNull(res[648].exec("ax{10a0}B ", 1640));3284assertNull(res[648].exec("** Failers ", 1641));3285assertNull(res[648].exec("a", 1642));3286assertNull(res[648].exec("x{1d00} ", 1643));3287assertNull(res[649].exec("1234", 1644));3288assertNull(res[649].exec("** Failers", 1645));3289assertNull(res[649].exec("ABC ", 1646));3290assertNull(res[650].exec("1234", 1647));3291assertNull(res[650].exec("** Failers", 1648));3292assertNull(res[650].exec("ABC ", 1649));3293assertNull(res[650].exec("A2XYZ", 1650));3294assertNull(res[650].exec("123A5XYZPQR", 1651));3295assertNull(res[650].exec("ABAx{660}XYZpqr", 1652));3296assertNull(res[650].exec("** Failers", 1653));3297assertNull(res[650].exec("AXYZ", 1654));3298assertNull(res[650].exec("XYZ ", 1655));3299assertNull(res[650].exec("1XYZ", 1656));3300assertNull(res[650].exec("AB=XYZ.. ", 1657));3301assertNull(res[650].exec("XYZ ", 1658));3302assertNull(res[650].exec("** Failers", 1659));3303assertNull(res[650].exec("WXYZ ", 1660));3304assertNull(res[655].exec("1234", 1661));3305assertNull(res[655].exec("1234", 1662));3306assertNull(res[655].exec("12-34", 1663));3307assertToStringEquals("{", res[655].exec("12+x{661}-34 "), 1664);3308assertNull(res[655].exec("** Failers", 1665));3309assertToStringEquals("d", res[655].exec("abcd "), 1666);3310assertToStringEquals("d", res[656].exec("abcd"), 1667);3311assertNull(res[656].exec("** Failers", 1668));3312assertNull(res[656].exec("1234", 1669));3313assertNull(res[657].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1670));3314assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[657].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1671);3315assertToStringEquals(" ", res[657].exec(" "), 1672);3316assertNull(res[657].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1673));3317assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[657].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1674);3318assertNull(res[658].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1675));3319assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[658].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1676);3320assertNull(res[659].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1677));3321assertNull(res[659].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 1678));3322assertNull(res[660].exec("11111111111111111111111111111111111111111111111111111111111111111111111", 1679));3323assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[660].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), 1680);3324assertNull(res[661].exec("a", 1681));3325assertNull(res[661].exec("A ", 1682));3326assertNull(res[662].exec("a", 1683));3327assertNull(res[662].exec("A ", 1684));3328assertNull(res[663].exec("A", 1685));3329assertNull(res[663].exec("aZ", 1686));3330assertNull(res[663].exec("** Failers", 1687));3331assertNull(res[663].exec("abc ", 1688));3332assertNull(res[664].exec("A", 1689));3333assertNull(res[664].exec("aZ", 1690));3334assertNull(res[664].exec("** Failers", 1691));3335assertNull(res[664].exec("abc ", 1692));3336assertNull(res[665].exec("a", 1693));3337assertNull(res[665].exec("Az", 1694));3338assertNull(res[665].exec("** Failers", 1695));3339assertNull(res[665].exec("ABC ", 1696));3340assertNull(res[666].exec("a", 1697));3341assertNull(res[666].exec("Az", 1698));3342assertNull(res[666].exec("** Failers", 1699));3343assertNull(res[666].exec("ABC ", 1700));3344assertNull(res[666].exec("x{c0}", 1701));3345assertNull(res[666].exec("x{e0} ", 1702));3346assertNull(res[666].exec("x{c0}", 1703));3347assertNull(res[666].exec("x{e0} ", 1704));3348assertNull(res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 1705));3349assertNull(res[666].exec("** Failers", 1706));3350assertNull(res[666].exec("ax{391}x{10427}x{ff3a}x{1fb0} ", 1707));3351assertNull(res[666].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 1708));3352assertNull(res[666].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 1709));3353assertNull(res[666].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 1710));3354assertNull(res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 1711));3355assertNull(res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb0}", 1712));3356assertNull(res[666].exec("ax{391}x{10427}x{ff3a}x{1fb0} ", 1713));3357assertNull(res[666].exec("Ax{3b1}x{10427}x{ff3a}x{1fb0}", 1714));3358assertNull(res[666].exec("Ax{391}x{1044F}x{ff3a}x{1fb0}", 1715));3359assertNull(res[666].exec("Ax{391}x{10427}x{ff5a}x{1fb0}", 1716));3360assertNull(res[666].exec("Ax{391}x{10427}x{ff3a}x{1fb8}", 1717));3361assertNull(res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}", 1718));3362assertNull(res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 1719));3363assertNull(res[666].exec("x{391}x{3b1}x{3b1}x{3b1}x{391}X", 1720));3364assertNull(res[666].exec("x{391}", 1721));3365assertNull(res[666].exec("x{ff3a}", 1722));3366assertNull(res[666].exec("x{3b1}", 1723));3367assertNull(res[666].exec("x{ff5a} ", 1724));3368assertNull(res[666].exec("x{c0}", 1725));3369assertNull(res[666].exec("x{e0} ", 1726));3370assertNull(res[666].exec("x{104}", 1727));3371assertNull(res[666].exec("x{105}", 1728));3372assertNull(res[666].exec("x{109} ", 1729));3373assertNull(res[666].exec("** Failers", 1730));3374assertNull(res[666].exec("x{100}", 1731));3375assertNull(res[666].exec("x{10a} ", 1732));3376assertNull(res[666].exec("Z", 1733));3377assertNull(res[666].exec("z", 1734));3378assertNull(res[666].exec("x{39c}", 1735));3379assertNull(res[666].exec("x{178}", 1736));3380assertNull(res[666].exec("|", 1737));3381assertNull(res[666].exec("x{80}", 1738));3382assertNull(res[666].exec("x{ff}", 1739));3383assertNull(res[666].exec("x{100}", 1740));3384assertNull(res[666].exec("x{101} ", 1741));3385assertNull(res[666].exec("** Failers", 1742));3386assertNull(res[666].exec("x{102}", 1743));3387assertNull(res[666].exec("Y", 1744));3388assertNull(res[666].exec("y ", 1745));3389assertNull(res[667].exec("A", 1746));3390assertNull(res[667].exec("Ax{300}BC ", 1747));3391assertNull(res[667].exec("Ax{300}x{301}x{302}BC ", 1748));3392assertNull(res[667].exec("*** Failers", 1749));3393assertNull(res[667].exec("x{300} ", 1750));3394assertToStringEquals("X", res[668].exec("X123"), 1751);3395assertNull(res[668].exec("*** Failers", 1752));3396assertNull(res[668].exec("AXYZ", 1753));3397assertNull(res[669].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 1754));3398assertNull(res[669].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 1755));3399assertNull(res[670].exec("Ax{300}x{301}x{302}BCAx{300}x{301} ", 1756));3400assertNull(res[670].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C ", 1757));3401assertToStringEquals("A,,A", res[671].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 1758);3402assertToStringEquals("A,,A", res[671].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 1759);3403assertToStringEquals("A,,A", res[672].exec("Ax{300}x{301}x{302}BCAx{300}x{301} "), 1760);3404assertToStringEquals("A,,A", res[672].exec("Ax{300}x{301}x{302}BCAx{300}x{301}C "), 1761);3405assertNull(res[673].exec("*** Failers", 1762));3406assertNull(res[673].exec("Ax{300}x{301}x{302}", 1763));3407assertNull(res[674].exec("Ax{300}x{301}Bx{300}X", 1764));3408assertNull(res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 1765));3409assertNull(res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 1766));3410assertNull(res[674].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 1767));3411assertNull(res[675].exec("Ax{300}x{301}Bx{300}X", 1768));3412assertNull(res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}", 1769));3413assertNull(res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}X", 1770));3414assertNull(res[675].exec("Ax{300}x{301}Bx{300}Cx{300}x{301}DAx{300}X", 1771));3415assertNull(res[675].exec("x{2e81}x{3007}x{2f804}x{31a0}", 1772));3416assertNull(res[675].exec("** Failers", 1773));3417assertNull(res[675].exec("x{2e7f} ", 1774));3418assertNull(res[675].exec("x{3105}", 1775));3419assertNull(res[675].exec("** Failers", 1776));3420assertNull(res[675].exec("x{30ff} ", 1777));3421assertNull(res[676].exec("x{06e9}", 1778));3422assertNull(res[676].exec("x{060b}", 1779));3423assertNull(res[676].exec("** Failers", 1780));3424assertNull(res[676].exec("Xx{06e9} ", 1781));3425assertNull(res[677].exec("x{2f800}", 1782));3426assertNull(res[677].exec("** Failers", 1783));3427assertNull(res[677].exec("x{a014}", 1784));3428assertNull(res[677].exec("x{a4c6} ", 1785));3429assertNull(res[678].exec("AXYZ", 1786));3430assertNull(res[678].exec("x{1234}XYZ ", 1787));3431assertNull(res[678].exec("** Failers", 1788));3432assertNull(res[678].exec("X ", 1789));3433assertNull(res[679].exec("** Failers", 1790));3434assertNull(res[679].exec("AX", 1791));3435assertNull(res[680].exec("XYZ", 1792));3436assertNull(res[680].exec("AXYZ", 1793));3437assertNull(res[680].exec("x{1234}XYZ ", 1794));3438assertNull(res[680].exec("** Failers", 1795));3439assertNull(res[680].exec("ABXYZ ", 1796));3440assertNull(res[681].exec("XYZ", 1797));3441assertNull(res[681].exec("** Failers", 1798));3442assertNull(res[681].exec("AXYZ", 1799));3443assertNull(res[681].exec("x{1234}XYZ ", 1800));3444assertNull(res[681].exec("ABXYZ ", 1801));3445assertNull(res[681].exec("AXYZ", 1802));3446assertNull(res[681].exec("x{1234}XYZ", 1803));3447assertNull(res[681].exec("Ax{1234}XYZ", 1804));3448assertNull(res[681].exec("** Failers", 1805));3449assertNull(res[681].exec("XYZ", 1806));3450assertNull(res[681].exec("** Failers", 1807));3451assertNull(res[681].exec("AXYZ", 1808));3452assertNull(res[681].exec("x{1234}XYZ", 1809));3453assertNull(res[681].exec("Ax{1234}XYZ", 1810));3454assertNull(res[681].exec("XYZ", 1811));3455assertNull(res[682].exec("XYZ", 1812));3456assertNull(res[682].exec("AXYZ", 1813));3457assertNull(res[682].exec("x{1234}XYZ", 1814));3458assertNull(res[682].exec("Ax{1234}XYZ", 1815));3459assertNull(res[682].exec("** Failers", 1816));3460assertNull(res[683].exec("XYZ", 1817));3461assertNull(res[683].exec("** Failers", 1818));3462assertNull(res[683].exec("AXYZ", 1819));3463assertNull(res[683].exec("x{1234}XYZ", 1820));3464assertNull(res[683].exec("Ax{1234}XYZ", 1821));3465assertToStringEquals("AX", res[684].exec("AXYZ"), 1822);3466assertNull(res[684].exec("x{1234}XYZ ", 1823));3467assertNull(res[684].exec("** Failers", 1824));3468assertNull(res[684].exec("X ", 1825));3469assertNull(res[685].exec("** Failers", 1826));3470assertToStringEquals("AX", res[685].exec("AX"), 1827);3471assertToStringEquals("X", res[686].exec("XYZ"), 1828);3472assertToStringEquals("AX", res[686].exec("AXYZ"), 1829);3473assertNull(res[686].exec("x{1234}XYZ ", 1830));3474assertNull(res[686].exec("** Failers", 1831));3475assertNull(res[686].exec("ABXYZ ", 1832));3476assertToStringEquals("X", res[687].exec("XYZ"), 1833);3477assertNull(res[687].exec("** Failers", 1834));3478assertToStringEquals("AX", res[687].exec("AXYZ"), 1835);3479assertNull(res[687].exec("x{1234}XYZ ", 1836));3480assertNull(res[687].exec("ABXYZ ", 1837));3481assertToStringEquals("AX", res[688].exec("AXYZ"), 1838);3482assertNull(res[688].exec("x{1234}XYZ", 1839));3483assertNull(res[688].exec("Ax{1234}XYZ", 1840));3484assertNull(res[688].exec("** Failers", 1841));3485assertNull(res[688].exec("XYZ", 1842));3486assertNull(res[689].exec("** Failers", 1843));3487assertToStringEquals("AX", res[689].exec("AXYZ"), 1844);3488assertNull(res[689].exec("x{1234}XYZ", 1845));3489assertNull(res[689].exec("Ax{1234}XYZ", 1846));3490assertNull(res[689].exec("XYZ", 1847));3491assertToStringEquals("X", res[690].exec("XYZ"), 1848);3492assertToStringEquals("AX", res[690].exec("AXYZ"), 1849);3493assertNull(res[690].exec("x{1234}XYZ", 1850));3494assertNull(res[690].exec("Ax{1234}XYZ", 1851));3495assertNull(res[690].exec("** Failers", 1852));3496assertToStringEquals("X", res[691].exec("XYZ"), 1853);3497assertNull(res[691].exec("** Failers", 1854));3498assertToStringEquals("AX", res[691].exec("AXYZ"), 1855);3499assertNull(res[691].exec("x{1234}XYZ", 1856));3500assertNull(res[691].exec("Ax{1234}XYZ", 1857));3501assertNull(res[692].exec("abcdefgh", 1858));3502assertNull(res[692].exec("x{1234}\n\x0dx{3456}xyz ", 1859));3503assertNull(res[693].exec("abcdefgh", 1860));3504assertNull(res[693].exec("x{1234}\n\x0dx{3456}xyz ", 1861));3505assertNull(res[694].exec("** Failers", 1862));3506assertNull(res[694].exec("abcdefgh", 1863));3507assertNull(res[694].exec("x{1234}\n\x0dx{3456}xyz ", 1864));3508assertNull(res[695].exec(" AXY", 1865));3509assertNull(res[695].exec(" aXY", 1866));3510assertNull(res[695].exec(" x{1c5}XY", 1867));3511assertNull(res[695].exec(" ** Failers", 1868));3512assertNull(res[695].exec(" x{1bb}XY", 1869));3513assertNull(res[695].exec(" x{2b0}XY", 1870));3514assertNull(res[695].exec(" !XY ", 1871));3515assertNull(res[696].exec(" AXY", 1872));3516assertNull(res[696].exec(" aXY", 1873));3517assertNull(res[696].exec(" x{1c5}XY", 1874));3518assertNull(res[696].exec(" ** Failers", 1875));3519assertNull(res[696].exec(" x{1bb}XY", 1876));3520assertNull(res[696].exec(" x{2b0}XY", 1877));3521assertNull(res[696].exec(" !XY ", 1878));3522assertNull(res[696].exec(" AXY", 1879));3523assertNull(res[696].exec(" aXY", 1880));3524assertNull(res[696].exec(" AbcdeXyz ", 1881));3525assertNull(res[696].exec(" x{1c5}AbXY", 1882));3526assertNull(res[696].exec(" abcDEXypqreXlmn ", 1883));3527assertNull(res[696].exec(" ** Failers", 1884));3528assertNull(res[696].exec(" x{1bb}XY", 1885));3529assertNull(res[696].exec(" x{2b0}XY", 1886));3530assertNull(res[696].exec(" !XY ", 1887));3531assertNull(res[697].exec(" AXY", 1888));3532assertNull(res[697].exec(" aXY", 1889));3533assertNull(res[697].exec(" AbcdeXyz ", 1890));3534assertNull(res[697].exec(" x{1c5}AbXY", 1891));3535assertNull(res[697].exec(" abcDEXypqreXlmn ", 1892));3536assertNull(res[697].exec(" ** Failers", 1893));3537assertNull(res[697].exec(" x{1bb}XY", 1894));3538assertNull(res[697].exec(" x{2b0}XY", 1895));3539assertNull(res[697].exec(" !XY ", 1896));3540assertNull(res[697].exec(" AXY", 1897));3541assertNull(res[697].exec(" aXY", 1898));3542assertNull(res[697].exec(" AbcdeXyz ", 1899));3543assertNull(res[697].exec(" x{1c5}AbXY", 1900));3544assertNull(res[697].exec(" abcDEXypqreXlmn ", 1901));3545assertNull(res[697].exec(" ** Failers", 1902));3546assertNull(res[697].exec(" x{1bb}XY", 1903));3547assertNull(res[697].exec(" x{2b0}XY", 1904));3548assertNull(res[697].exec(" !XY ", 1905));3549assertNull(res[698].exec(" AXY", 1906));3550assertNull(res[698].exec(" aXY", 1907));3551assertNull(res[698].exec(" AbcdeXyz ", 1908));3552assertNull(res[698].exec(" x{1c5}AbXY", 1909));3553assertNull(res[698].exec(" abcDEXypqreXlmn ", 1910));3554assertNull(res[698].exec(" ** Failers", 1911));3555assertNull(res[698].exec(" x{1bb}XY", 1912));3556assertNull(res[698].exec(" x{2b0}XY", 1913));3557assertNull(res[698].exec(" !XY ", 1914));3558assertNull(res[699].exec(" !XY", 1915));3559assertNull(res[699].exec(" x{1bb}XY", 1916));3560assertNull(res[699].exec(" x{2b0}XY", 1917));3561assertNull(res[699].exec(" ** Failers", 1918));3562assertNull(res[699].exec(" x{1c5}XY", 1919));3563assertNull(res[699].exec(" AXY ", 1920));3564assertNull(res[700].exec(" !XY", 1921));3565assertNull(res[700].exec(" x{1bb}XY", 1922));3566assertNull(res[700].exec(" x{2b0}XY", 1923));3567assertNull(res[700].exec(" ** Failers", 1924));3568assertNull(res[700].exec(" x{1c5}XY", 1925));3569assertNull(res[700].exec(" AXY ", 1926));3570assertNull(res[701].exec("\xa0!", 1927));3571assertNull(res[701].exec("AabcabcYZ ", 1928));3572assertToStringEquals("L=abcX,L=abc,abc", res[702].exec("L=abcX"), 1929);3573assertNull(res[702].exec("x{c0}", 1930));3574assertNull(res[702].exec("x{e0} ", 1931));3575assertNull(res[702].exec("x{c0}", 1932));3576assertNull(res[702].exec("x{e0} ", 1933));3577assertNull(res[703].exec("x{1b00}x{12000}x{7c0}x{a840}x{10900}", 1934));3578assertNull(res[706].exec("123abcdefg", 1935));3579assertNull(res[706].exec("123abc\xc4\xc5zz", 1936));3580assertNull(res[710].exec("A\x80", 1937));3581assertNull(res[725].exec("x{60e} ", 1938));3582assertNull(res[725].exec("x{656} ", 1939));3583assertNull(res[725].exec("x{657} ", 1940));3584assertNull(res[725].exec("x{658} ", 1941));3585assertNull(res[725].exec("x{659} ", 1942));3586assertNull(res[725].exec("x{65a} ", 1943));3587assertNull(res[725].exec("x{65b} ", 1944));3588assertNull(res[725].exec("x{65c} ", 1945));3589assertNull(res[725].exec("x{65d} ", 1946));3590assertNull(res[725].exec("x{65e} ", 1947));3591assertNull(res[725].exec("x{66a} ", 1948));3592assertNull(res[725].exec("x{6e9} ", 1949));3593assertNull(res[725].exec("x{6ef}", 1950));3594assertNull(res[725].exec("x{6fa} ", 1951));3595assertNull(res[725].exec("** Failers", 1952));3596assertNull(res[725].exec("x{600}", 1953));3597assertNull(res[725].exec("x{650}", 1954));3598assertNull(res[725].exec("x{651} ", 1955));3599assertNull(res[725].exec("x{652} ", 1956));3600assertNull(res[725].exec("x{653} ", 1957));3601assertNull(res[725].exec("x{654} ", 1958));3602assertNull(res[725].exec("x{655} ", 1959));3603assertNull(res[725].exec("x{65f} ", 1960));3604assertNull(res[726].exec("x{1d2b} ", 1961));3605assertNull(res[727].exec("x{589}", 1962));3606assertNull(res[727].exec("x{60c}", 1963));3607assertNull(res[727].exec("x{61f} ", 1964));3608assertNull(res[727].exec("x{964}", 1965));3609assertNull(res[727].exec("x{965} ", 1966));3610assertNull(res[727].exec("x{970} ", 1967));3611assertNull(res[728].exec("x{64b}", 1968));3612assertNull(res[728].exec("x{654}", 1969));3613assertNull(res[728].exec("x{655}", 1970));3614assertNull(res[728].exec("x{200c} ", 1971));3615assertNull(res[728].exec("** Failers", 1972));3616assertNull(res[728].exec("x{64a}", 1973));3617assertNull(res[728].exec("x{656} ", 1974));3618assertNull(res[729].exec("x{10450}", 1975));3619assertNull(res[729].exec("x{1047f}", 1976));3620assertNull(res[730].exec("x{10400}", 1977));3621assertNull(res[730].exec("x{1044f}", 1978));3622assertNull(res[731].exec("x{10480}", 1979));3623assertNull(res[731].exec("x{1049d}", 1980));3624assertNull(res[731].exec("x{104a0}", 1981));3625assertNull(res[731].exec("x{104a9}", 1982));3626assertNull(res[731].exec("** Failers", 1983));3627assertNull(res[731].exec("x{1049e}", 1984));3628assertNull(res[731].exec("x{1049f}", 1985));3629assertNull(res[731].exec("x{104aa} ", 1986));3630assertNull(res[731].exec("\xe2\x80\xa8\xe2\x80\xa8", 1987));3631assertNull(res[731].exec("x{2028}x{2028}x{2028}", 1988));3632assertNull(res[732].exec("x{c0}x{e0}x{116}x{117}", 1989));3633assertNull(res[732].exec("x{c0}x{e0}x{116}x{117}", 1990));3634assertNull(res[733].exec("x{102A4}x{AA52}x{A91D}x{1C46}x{10283}x{1092E}x{1C6B}x{A93B}x{A8BF}x{1BA0}x{A50A}====", 1991));3635assertNull(res[733].exec("x{a77d}x{1d79}", 1992));3636assertNull(res[733].exec("x{1d79}x{a77d} ", 1993));3637assertNull(res[733].exec("x{a77d}x{1d79}", 1994));3638assertNull(res[733].exec("** Failers ", 1995));3639assertNull(res[733].exec("x{1d79}x{a77d} ", 1996));3640assertToStringEquals("AA,A", res[734].exec("AA"), 1997);3641assertToStringEquals("Aa,A", res[734].exec("Aa"), 1998);3642assertToStringEquals("aa,a", res[734].exec("aa"), 1999);3643assertToStringEquals("aA,a", res[734].exec("aA"), 2000);3644assertNull(res[734].exec("x{de}x{de}", 2001));3645assertNull(res[734].exec("x{de}x{fe}", 2002));3646assertNull(res[734].exec("x{fe}x{fe}", 2003));3647assertNull(res[734].exec("x{fe}x{de}", 2004));3648assertNull(res[734].exec("x{10a}x{10a}", 2005));3649assertNull(res[734].exec("x{10a}x{10b}", 2006));3650assertNull(res[734].exec("x{10b}x{10b}", 2007));3651assertNull(res[734].exec("x{10b}x{10a}", 2008));3652assertToStringEquals("abc", res[736].exec("abc"), 2009);3653assertToStringEquals("abc", res[737].exec("abc"), 2010);3654assertToStringEquals("abbbbc", res[737].exec("abbbbc"), 2011);3655assertToStringEquals("ac", res[737].exec("ac"), 2012);3656assertToStringEquals("abc", res[738].exec("abc"), 2013);3657assertToStringEquals("abbbbbbc", res[738].exec("abbbbbbc"), 2014);3658assertNull(res[738].exec("*** Failers ", 2015));3659assertNull(res[738].exec("ac", 2016));3660assertNull(res[738].exec("ab", 2017));3661assertToStringEquals("a", res[739].exec("a"), 2018);3662assertToStringEquals("aaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaa"), 2019);3663assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "), 2020);3664assertToStringEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", res[739].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaF "), 2021);3665assertToStringEquals("a,a", res[740].exec("a"), 2022);3666assertToStringEquals("a,a", res[740].exec("abcd"), 2023);3667assertToStringEquals("a,a", res[740].exec("african"), 2024);3668assertToStringEquals("abc", res[741].exec("abcdef"), 2025);3669assertNull(res[741].exec("*** Failers", 2026));3670assertNull(res[741].exec("xyzabc", 2027));3671assertNull(res[741].exec("xyz\nabc ", 2028));3672assertToStringEquals("abc", res[742].exec("abcdef"), 2029);3673assertToStringEquals("abc", res[742].exec("xyz\nabc "), 2030);3674assertNull(res[742].exec("*** Failers", 2031));3675assertNull(res[742].exec("xyzabc", 2032));3676assertNull(res[743].exec("abcdef", 2033));3677assertNull(res[743].exec("*** Failers", 2034));3678assertNull(res[743].exec("xyzabc", 2035));3679assertNull(res[743].exec("xyz\nabc ", 2036));3680assertNull(res[744].exec("abcdef", 2037));3681assertNull(res[744].exec("*** Failers", 2038));3682assertNull(res[744].exec("xyzabc", 2039));3683assertNull(res[744].exec("xyz\nabc ", 2040));3684assertNull(res[745].exec("abcdef", 2041));3685assertNull(res[745].exec("xyzabc>3", 2042));3686assertNull(res[745].exec("*** Failers", 2043));3687assertNull(res[745].exec("xyzabc ", 2044));3688assertNull(res[745].exec("xyzabc>2 ", 2045));3689assertToStringEquals("x9yzz", res[746].exec("x9yzz"), 2046);3690assertToStringEquals("x0y+z", res[746].exec("x0y+z"), 2047);3691assertNull(res[746].exec("*** Failers", 2048));3692assertNull(res[746].exec("xyz", 2049));3693assertNull(res[746].exec("xxy0z ", 2050));3694assertToStringEquals("x yzz", res[747].exec("x yzz"), 2051);3695assertToStringEquals("x y+z", res[747].exec("x y+z"), 2052);3696assertNull(res[747].exec("*** Failers", 2053));3697assertNull(res[747].exec("xyz", 2054));3698assertNull(res[747].exec("xxyyz", 2055));3699assertToStringEquals("xxy+z", res[748].exec("xxy+z"), 2056);3700assertNull(res[748].exec("*** Failers", 2057));3701assertNull(res[748].exec("xxy0z", 2058));3702assertNull(res[748].exec("x+y+z ", 2059));3703assertToStringEquals("x+y", res[749].exec("x+y"), 2060);3704assertToStringEquals("x-y", res[749].exec("x-y"), 2061);3705assertNull(res[749].exec("*** Failers", 2062));3706assertNull(res[749].exec("x\ny", 2063));3707assertToStringEquals("x+y", res[750].exec("x+y"), 2064);3708assertToStringEquals("x-y", res[750].exec("x-y"), 2065);3709assertNull(res[750].exec("x\ny", 2066));3710assertNull(res[750].exec("a+bc+dp+q", 2067));3711assertNull(res[750].exec("a+bc\ndp+q", 2068));3712assertNull(res[750].exec("x\nyp+q ", 2069));3713assertNull(res[750].exec("*** Failers ", 2070));3714assertNull(res[750].exec("a\nbc\ndp+q", 2071));3715assertNull(res[750].exec("a+bc\ndp\nq", 2072));3716assertNull(res[750].exec("x\nyp\nq ", 2073));3717assertNull(res[751].exec("ba0", 2074));3718assertNull(res[751].exec("*** Failers", 2075));3719assertNull(res[751].exec("ba0\n", 2076));3720assertNull(res[751].exec("ba0\ncd ", 2077));3721assertNull(res[752].exec("ba0", 2078));3722assertNull(res[752].exec("*** Failers", 2079));3723assertNull(res[752].exec("ba0\n", 2080));3724assertNull(res[752].exec("ba0\ncd ", 2081));3725assertNull(res[753].exec("ba0", 2082));3726assertNull(res[753].exec("ba0\n", 2083));3727assertNull(res[753].exec("*** Failers", 2084));3728assertNull(res[753].exec("ba0\ncd ", 2085));3729assertNull(res[754].exec("ba0", 2086));3730assertNull(res[754].exec("ba0\n", 2087));3731assertNull(res[754].exec("*** Failers", 2088));3732assertNull(res[754].exec("ba0\ncd ", 2089));3733assertToStringEquals("a0", res[755].exec("ba0"), 2090);3734assertNull(res[755].exec("ba0\n", 2091));3735assertNull(res[755].exec("*** Failers", 2092));3736assertNull(res[755].exec("ba0\ncd ", 2093));3737assertToStringEquals("a0", res[756].exec("ba0"), 2094);3738assertToStringEquals("a0", res[756].exec("ba0\n"), 2095);3739assertToStringEquals("a0", res[756].exec("ba0\ncd "), 2096);3740assertNull(res[756].exec("*** Failers", 2097));3741assertToStringEquals("abc", res[757].exec("abc"), 2098);3742assertToStringEquals("aBc", res[757].exec("aBc"), 2099);3743assertToStringEquals("ABC", res[757].exec("ABC"), 2100);3744assertToStringEquals("b", res[758].exec("abcd"), 2101);3745assertToStringEquals("abz", res[759].exec("abz"), 2102);3746assertToStringEquals("abb", res[759].exec("abbz"), 2103);3747assertToStringEquals("az", res[759].exec("azz "), 2104);3748assertToStringEquals("yz", res[760].exec("ayzq"), 2105);3749assertToStringEquals("xyz", res[760].exec("axyzq"), 2106);3750assertToStringEquals("xxyz", res[760].exec("axxyz"), 2107);3751assertToStringEquals("xxxyz", res[760].exec("axxxyzq"), 2108);3752assertToStringEquals("xxxyz", res[760].exec("axxxxyzq"), 2109);3753assertNull(res[760].exec("*** Failers", 2110));3754assertNull(res[760].exec("ax", 2111));3755assertNull(res[760].exec("axx ", 2112));3756assertNull(res[760].exec(" ", 2113));3757assertToStringEquals("xxxyz", res[761].exec("axxxyzq"), 2114);3758assertToStringEquals("xxxyz", res[761].exec("axxxxyzq"), 2115);3759assertNull(res[761].exec("*** Failers", 2116));3760assertNull(res[761].exec("ax", 2117));3761assertNull(res[761].exec("axx ", 2118));3762assertNull(res[761].exec("ayzq", 2119));3763assertNull(res[761].exec("axyzq", 2120));3764assertNull(res[761].exec("axxyz", 2121));3765assertNull(res[761].exec(" ", 2122));3766assertToStringEquals("xxyz", res[762].exec("axxyz"), 2123);3767assertToStringEquals("xxxyz", res[762].exec("axxxyzq"), 2124);3768assertToStringEquals("xxxyz", res[762].exec("axxxxyzq"), 2125);3769assertNull(res[762].exec("*** Failers", 2126));3770assertNull(res[762].exec("ax", 2127));3771assertNull(res[762].exec("axx ", 2128));3772assertNull(res[762].exec("ayzq", 2129));3773assertNull(res[762].exec("axyzq", 2130));3774assertNull(res[762].exec(" ", 2131));3775assertToStringEquals("b", res[763].exec("bac"), 2132);3776assertToStringEquals("bcdef", res[763].exec("bcdefax"), 2133);3777assertToStringEquals("*** F", res[763].exec("*** Failers"), 2134);3778assertToStringEquals(" ", res[763].exec("aaaaa "), 2135);3779assertToStringEquals("b", res[764].exec("bac"), 2136);3780assertToStringEquals("bcdef", res[764].exec("bcdefax"), 2137);3781assertToStringEquals("*** F", res[764].exec("*** Failers"), 2138);3782assertToStringEquals("", res[764].exec("aaaaa "), 2139);3783assertToStringEquals("xyz", res[765].exec("xyz"), 2140);3784assertToStringEquals("wxyz", res[765].exec("awxyza"), 2141);3785assertToStringEquals("bcdef", res[765].exec("abcdefa"), 2142);3786assertToStringEquals("bcdef", res[765].exec("abcdefghijk"), 2143);3787assertToStringEquals("*** F", res[765].exec("*** Failers"), 2144);3788assertNull(res[765].exec("axya", 2145));3789assertNull(res[765].exec("axa", 2146));3790assertToStringEquals(" ", res[765].exec("aaaaa "), 2147);3791assertToStringEquals("1234", res[766].exec("1234b567"), 2148);3792assertToStringEquals("", res[766].exec("xyz"), 2149);3793assertToStringEquals("a", res[767].exec("a1234b567"), 2150);3794assertToStringEquals("xyz", res[767].exec("xyz"), 2151);3795assertToStringEquals(" ", res[767].exec(" "), 2152);3796assertToStringEquals("1234", res[768].exec("ab1234c56"), 2153);3797assertNull(res[768].exec("*** Failers", 2154));3798assertNull(res[768].exec("xyz", 2155));3799assertToStringEquals("ab", res[769].exec("ab123c56"), 2156);3800assertToStringEquals("*** Failers", res[769].exec("*** Failers"), 2157);3801assertNull(res[769].exec("789", 2158));3802assertToStringEquals("5A", res[770].exec("045ABC"), 2159);3803assertToStringEquals("A", res[770].exec("ABC"), 2160);3804assertNull(res[770].exec("*** Failers", 2161));3805assertNull(res[770].exec("XYZ", 2162));3806assertToStringEquals("A", res[771].exec("ABC"), 2163);3807assertToStringEquals("BA", res[771].exec("BAC"), 2164);3808assertToStringEquals("A", res[771].exec("9ABC "), 2165);3809assertNull(res[771].exec("*** Failers", 2166));3810assertToStringEquals("aaaa", res[772].exec("aaaa"), 2167);3811assertToStringEquals("xyz", res[773].exec("xyz"), 2168);3812assertToStringEquals("ggggggggxyz", res[773].exec("ggggggggxyz"), 2169);3813assertToStringEquals("abcdxyz", res[774].exec("abcdxyz"), 2170);3814assertToStringEquals("axyz", res[774].exec("axyz"), 2171);3815assertNull(res[774].exec("*** Failers", 2172));3816assertNull(res[774].exec("xyz", 2173));3817assertToStringEquals("xyz", res[775].exec("xyz"), 2174);3818assertToStringEquals("cxyz", res[775].exec("cxyz "), 2175);3819assertToStringEquals("12X", res[776].exec("12X"), 2176);3820assertToStringEquals("123X", res[776].exec("123X"), 2177);3821assertNull(res[776].exec("*** Failers", 2178));3822assertNull(res[776].exec("X", 2179));3823assertNull(res[776].exec("1X", 2180));3824assertNull(res[776].exec("1234X ", 2181));3825assertToStringEquals("a4", res[777].exec("a45"), 2182);3826assertToStringEquals("b9", res[777].exec("b93"), 2183);3827assertToStringEquals("c9", res[777].exec("c99z"), 2184);3828assertToStringEquals("d0", res[777].exec("d04"), 2185);3829assertNull(res[777].exec("*** Failers", 2186));3830assertNull(res[777].exec("e45", 2187));3831assertNull(res[777].exec("abcd ", 2188));3832assertNull(res[777].exec("abcd1234", 2189));3833assertNull(res[777].exec("1234 ", 2190));3834assertToStringEquals("a4", res[778].exec("a45"), 2191);3835assertToStringEquals("b9", res[778].exec("b93"), 2192);3836assertToStringEquals("c9", res[778].exec("c99z"), 2193);3837assertToStringEquals("d0", res[778].exec("d04"), 2194);3838assertToStringEquals("abcd1", res[778].exec("abcd1234"), 2195);3839assertToStringEquals("1", res[778].exec("1234 "), 2196);3840assertNull(res[778].exec("*** Failers", 2197));3841assertNull(res[778].exec("e45", 2198));3842assertNull(res[778].exec("abcd ", 2199));3843assertToStringEquals("a4", res[779].exec("a45"), 2200);3844assertToStringEquals("b9", res[779].exec("b93"), 2201);3845assertToStringEquals("c9", res[779].exec("c99z"), 2202);3846assertToStringEquals("d0", res[779].exec("d04"), 2203);3847assertToStringEquals("abcd1", res[779].exec("abcd1234"), 2204);3848assertNull(res[779].exec("*** Failers", 2205));3849assertNull(res[779].exec("1234 ", 2206));3850assertNull(res[779].exec("e45", 2207));3851assertNull(res[779].exec("abcd ", 2208));3852assertToStringEquals("aX", res[780].exec("aX"), 2209);3853assertToStringEquals("aaX", res[780].exec("aaX "), 2210);3854assertToStringEquals("a4", res[781].exec("a45"), 2211);3855assertToStringEquals("b9", res[781].exec("b93"), 2212);3856assertToStringEquals("c9", res[781].exec("c99z"), 2213);3857assertToStringEquals("d0", res[781].exec("d04"), 2214);3858assertToStringEquals("1", res[781].exec("1234 "), 2215);3859assertNull(res[781].exec("*** Failers", 2216));3860assertNull(res[781].exec("abcd1234", 2217));3861assertNull(res[781].exec("e45", 2218));3862assertToStringEquals("ab4", res[782].exec("ab45"), 2219);3863assertToStringEquals("bcd9", res[782].exec("bcd93"), 2220);3864assertNull(res[782].exec("*** Failers", 2221));3865assertNull(res[782].exec("1234 ", 2222));3866assertNull(res[782].exec("a36 ", 2223));3867assertNull(res[782].exec("abcd1234", 2224));3868assertNull(res[782].exec("ee45", 2225));3869assertToStringEquals("abc4,abc", res[783].exec("abc45"), 2226);3870assertToStringEquals("abcabcabc4,abc", res[783].exec("abcabcabc45"), 2227);3871assertToStringEquals("4,", res[783].exec("42xyz "), 2228);3872assertNull(res[783].exec("*** Failers", 2229));3873assertToStringEquals("abc4,abc", res[784].exec("abc45"), 2230);3874assertToStringEquals("abcabcabc4,abc", res[784].exec("abcabcabc45"), 2231);3875assertNull(res[784].exec("*** Failers", 2232));3876assertNull(res[784].exec("42xyz ", 2233));3877assertToStringEquals("abc4,abc", res[785].exec("abc45"), 2234);3878assertToStringEquals("4,", res[785].exec("42xyz "), 2235);3879assertNull(res[785].exec("*** Failers", 2236));3880assertNull(res[785].exec("abcabcabc45", 2237));3881assertToStringEquals("abcabc4,abc", res[786].exec("abcabc45"), 2238);3882assertToStringEquals("abcabcabc4,abc", res[786].exec("abcabcabc45"), 2239);3883assertNull(res[786].exec("*** Failers", 2240));3884assertNull(res[786].exec("abcabcabcabc45", 2241));3885assertNull(res[786].exec("abc45", 2242));3886assertNull(res[786].exec("42xyz ", 2243));3887assertNull(res[786].exec("1abc2abc3456", 2244));3888assertNull(res[786].exec("1abc2xyz3456 ", 2245));3889assertToStringEquals("ab=ab,ab,ab", res[787].exec("ab=ab"), 2246);3890assertToStringEquals("ab=ab,ab,ab", res[787].exec("ab=ab"), 2247);3891assertNull(res[787].exec("abc", 2248));3892assertNull(res[787].exec("a(b)c", 2249));3893assertNull(res[787].exec("a(b(c))d ", 2250));3894assertNull(res[787].exec("*** Failers)", 2251));3895assertNull(res[787].exec("a(b(c)d ", 2252));3896assertNull(res[787].exec(">abc>123<xyz<", 2253));3897assertNull(res[787].exec(">abc>1(2)3<xyz<", 2254));3898assertNull(res[787].exec(">abc>(1(2)3)<xyz<", 2255));3899assertNull(res[787].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa9876", 2256));3900assertNull(res[787].exec("*** Failers ", 2257));3901assertNull(res[787].exec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 2258));3902assertNull(res[787].exec("<>", 2259));3903assertNull(res[787].exec("<abcd>", 2260));3904assertNull(res[787].exec("<abc <123> hij>", 2261));3905assertNull(res[787].exec("<abc <def> hij>", 2262));3906assertNull(res[787].exec("<abc<>def> ", 2263));3907assertNull(res[787].exec("<abc<> ", 2264));3908assertNull(res[787].exec("*** Failers", 2265));3909assertNull(res[787].exec("<abc", 2266));3910assertNull(res[787].exec("abc: ", 2267));3911assertNull(res[787].exec("12 ", 2268));3912assertNull(res[787].exec("*** Failers ", 2269));3913assertNull(res[787].exec("123 ", 2270));3914assertNull(res[787].exec("xyz ", 2271));3915assertNull(res[787].exec(" ", 2272));3916assertNull(res[787].exec("abc: ", 2273));3917assertNull(res[787].exec("12 ", 2274));3918assertNull(res[787].exec("*** Failers", 2275));3919assertNull(res[787].exec("123", 2276));3920assertNull(res[787].exec("xyz ", 2277));3921assertNull(res[788].exec("abcde: ", 2278));3922assertNull(res[788].exec("*** Failers ", 2279));3923assertNull(res[788].exec("abc.. ", 2280));3924assertNull(res[788].exec("123 ", 2281));3925assertNull(res[788].exec("vwxyz ", 2282));3926assertNull(res[788].exec(" ", 2283));3927assertNull(res[789].exec("12 ", 2284));3928assertNull(res[789].exec("*** Failers", 2285));3929assertNull(res[789].exec("abcde:", 2286));3930assertNull(res[789].exec("abc.. ", 2287));3931assertNull(res[789].exec("123", 2288));3932assertNull(res[789].exec("vwxyz ", 2289));3933assertNull(res[789].exec("abc12345", 2290));3934assertNull(res[789].exec("wxy123z", 2291));3935assertNull(res[789].exec("*** Failers", 2292));3936assertNull(res[789].exec("123abc", 2293));3937assertNull(res[789].exec("123abc", 2294));3938assertNull(res[789].exec("mno123456 ", 2295));3939assertNull(res[789].exec("*** Failers", 2296));3940assertNull(res[789].exec("abc12345", 2297));3941assertNull(res[789].exec("wxy123z", 2298));3942assertNull(res[789].exec("abcxyz", 2299));3943assertNull(res[789].exec("123abcxyz999 ", 2300));3944assertToStringEquals("abc", res[791].exec("abcdef"), 2301);3945assertNull(res[791].exec("*** Failers", 2302));3946assertToStringEquals("abc", res[791].exec("abcdefB "), 2303);3947assertToStringEquals(",", res[792].exec("bcd"), 2304);3948assertToStringEquals("aaa,aaa", res[792].exec("aaabcd"), 2305);3949assertToStringEquals(",", res[792].exec("xyz"), 2306);3950assertToStringEquals(",", res[792].exec("xyzN "), 2307);3951assertToStringEquals(",", res[792].exec("*** Failers"), 2308);3952assertToStringEquals(",", res[792].exec("bcdN "), 2309);3953assertToStringEquals("xyz", res[793].exec("xyz"), 2310);3954assertNull(res[793].exec("xyz\n", 2311));3955assertNull(res[793].exec("*** Failers", 2312));3956assertNull(res[793].exec("xyzZ", 2313));3957assertNull(res[793].exec("xyz\nZ ", 2314));3958assertToStringEquals("xyz", res[794].exec("xyz"), 2315);3959assertToStringEquals("xyz", res[794].exec("xyz\n "), 2316);3960assertToStringEquals("xyz", res[794].exec("abcxyz\npqr "), 2317);3961assertToStringEquals("xyz", res[794].exec("abcxyz\npqrZ "), 2318);3962assertToStringEquals("xyz", res[794].exec("xyz\nZ "), 2319);3963assertNull(res[794].exec("*** Failers", 2320));3964assertNull(res[794].exec("xyzZ", 2321));3965assertNull(res[795].exec("abcdef", 2322));3966assertNull(res[795].exec("defabcxyz>3 ", 2323));3967assertNull(res[795].exec("*** Failers ", 2324));3968assertNull(res[795].exec("defabcxyz", 2325));3969assertNull(res[796].exec("abP", 2326));3970assertNull(res[796].exec("abcdeP", 2327));3971assertToStringEquals("abcdef", res[796].exec("abcdefP"), 2328);3972assertNull(res[796].exec("*** Failers", 2329));3973assertNull(res[796].exec("abxP ", 2330));3974assertNull(res[797].exec("aP", 2331));3975assertNull(res[797].exec("aaP", 2332));3976assertNull(res[797].exec("aa2P ", 2333));3977assertNull(res[797].exec("aaaP", 2334));3978assertNull(res[797].exec("aaa23P ", 2335));3979assertNull(res[797].exec("aaaa12345P", 2336));3980assertToStringEquals("aa0z", res[797].exec("aa0zP"), 2337);3981assertToStringEquals("aaaa4444444444444z", res[797].exec("aaaa4444444444444zP "), 2338);3982assertNull(res[797].exec("*** Failers", 2339));3983assertNull(res[797].exec("azP ", 2340));3984assertNull(res[797].exec("aaaaaP ", 2341));3985assertNull(res[797].exec("a56P ", 2342));3986assertNull(res[799].exec("adfadadaklhlkalkajhlkjahdfasdfasdfladsfjkjPZ", 2343));3987assertNull(res[799].exec("lkjhlkjhlkjhlkjhabbbbbbcdaefabbbbbbbefaPBZ", 2344));3988assertNull(res[799].exec("cdabbbbbbbbPRBZ", 2345));3989assertNull(res[799].exec("efabbbbbbbbbbbbbbbbPRBZ", 2346));3990assertNull(res[799].exec("bbbbbbbbbbbbcdXyasdfadfPRBZ ", 2347));3991assertNull(res[799].exec("abc", 2348));3992assertNull(res[799].exec("** Failers", 2349));3993assertNull(res[799].exec("def ", 2350));3994assertToStringEquals("the quick brown fox", res[800].exec("the quick brown fox"), 2351);3995assertNull(res[800].exec("The quick brown FOX", 2352));3996assertToStringEquals("the quick brown fox", res[800].exec("What do you know about the quick brown fox?"), 2353);3997assertNull(res[800].exec("What do you know about THE QUICK BROWN FOX?", 2354));3998assertToStringEquals("the quick brown fox", res[801].exec("the quick brown fox"), 2355);3999assertToStringEquals("The quick brown FOX", res[801].exec("The quick brown FOX"), 2356);4000assertToStringEquals("the quick brown fox", res[801].exec("What do you know about the quick brown fox?"), 2357);4001assertToStringEquals("THE QUICK BROWN FOX", res[801].exec("What do you know about THE QUICK BROWN FOX?"), 2358);4002assertToStringEquals("abcd\x09\n\x0d\x0cae9;$\\?caxyz", res[802].exec("abcd\x09\n\x0d\x0cae9;$\\?caxyz"), 2359);4003assertToStringEquals("abxyzpqrrrabbxyyyypqAzz", res[803].exec("abxyzpqrrrabbxyyyypqAzz"), 2360);4004assertToStringEquals("abxyzpqrrrabbxyyyypqAzz", res[803].exec("abxyzpqrrrabbxyyyypqAzz"), 2361);4005assertToStringEquals("aabxyzpqrrrabbxyyyypqAzz", res[803].exec("aabxyzpqrrrabbxyyyypqAzz"), 2362);4006assertToStringEquals("aaabxyzpqrrrabbxyyyypqAzz", res[803].exec("aaabxyzpqrrrabbxyyyypqAzz"), 2363);4007assertToStringEquals("aaaabxyzpqrrrabbxyyyypqAzz", res[803].exec("aaaabxyzpqrrrabbxyyyypqAzz"), 2364);4008assertToStringEquals("abcxyzpqrrrabbxyyyypqAzz", res[803].exec("abcxyzpqrrrabbxyyyypqAzz"), 2365);4009assertToStringEquals("aabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aabcxyzpqrrrabbxyyyypqAzz"), 2366);4010assertToStringEquals("aaabcxyzpqrrrabbxyyyypAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypAzz"), 2367);4011assertToStringEquals("aaabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqAzz"), 2368);4012assertToStringEquals("aaabcxyzpqrrrabbxyyyypqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqAzz"), 2369);4013assertToStringEquals("aaabcxyzpqrrrabbxyyyypqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqAzz"), 2370);4014assertToStringEquals("aaabcxyzpqrrrabbxyyyypqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqAzz"), 2371);4015assertToStringEquals("aaabcxyzpqrrrabbxyyyypqqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqAzz"), 2372);4016assertToStringEquals("aaabcxyzpqrrrabbxyyyypqqqqqqAzz", res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqqAzz"), 2373);4017assertToStringEquals("aaaabcxyzpqrrrabbxyyyypqAzz", res[803].exec("aaaabcxyzpqrrrabbxyyyypqAzz"), 2374);4018assertToStringEquals("abxyzzpqrrrabbxyyyypqAzz", res[803].exec("abxyzzpqrrrabbxyyyypqAzz"), 2375);4019assertToStringEquals("aabxyzzzpqrrrabbxyyyypqAzz", res[803].exec("aabxyzzzpqrrrabbxyyyypqAzz"), 2376);4020assertToStringEquals("aaabxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaabxyzzzzpqrrrabbxyyyypqAzz"), 2377);4021assertToStringEquals("aaaabxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaaabxyzzzzpqrrrabbxyyyypqAzz"), 2378);4022assertToStringEquals("abcxyzzpqrrrabbxyyyypqAzz", res[803].exec("abcxyzzpqrrrabbxyyyypqAzz"), 2379);4023assertToStringEquals("aabcxyzzzpqrrrabbxyyyypqAzz", res[803].exec("aabcxyzzzpqrrrabbxyyyypqAzz"), 2380);4024assertToStringEquals("aaabcxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaabcxyzzzzpqrrrabbxyyyypqAzz"), 2381);4025assertToStringEquals("aaaabcxyzzzzpqrrrabbxyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbxyyyypqAzz"), 2382);4026assertToStringEquals("aaaabcxyzzzzpqrrrabbbxyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyypqAzz"), 2383);4027assertToStringEquals("aaaabcxyzzzzpqrrrabbbxyyyyypqAzz", res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyyypqAzz"), 2384);4028assertToStringEquals("aaabcxyzpqrrrabbxyyyypABzz", res[803].exec("aaabcxyzpqrrrabbxyyyypABzz"), 2385);4029assertToStringEquals("aaabcxyzpqrrrabbxyyyypABBzz", res[803].exec("aaabcxyzpqrrrabbxyyyypABBzz"), 2386);4030assertToStringEquals("aaabxyzpqrrrabbxyyyypqAzz", res[803].exec(">>>aaabxyzpqrrrabbxyyyypqAzz"), 2387);4031assertToStringEquals("aaaabxyzpqrrrabbxyyyypqAzz", res[803].exec(">aaaabxyzpqrrrabbxyyyypqAzz"), 2388);4032assertToStringEquals("abcxyzpqrrrabbxyyyypqAzz", res[803].exec(">>>>abcxyzpqrrrabbxyyyypqAzz"), 2389);4033assertNull(res[803].exec("*** Failers", 2390));4034assertNull(res[803].exec("abxyzpqrrabbxyyyypqAzz", 2391));4035assertNull(res[803].exec("abxyzpqrrrrabbxyyyypqAzz", 2392));4036assertNull(res[803].exec("abxyzpqrrrabxyyyypqAzz", 2393));4037assertNull(res[803].exec("aaaabcxyzzzzpqrrrabbbxyyyyyypqAzz", 2394));4038assertNull(res[803].exec("aaaabcxyzzzzpqrrrabbbxyyypqAzz", 2395));4039assertNull(res[803].exec("aaabcxyzpqrrrabbxyyyypqqqqqqqAzz", 2396));4040assertToStringEquals("abczz,abc", res[804].exec("abczz"), 2397);4041assertToStringEquals("abcabczz,abc", res[804].exec("abcabczz"), 2398);4042assertNull(res[804].exec("*** Failers", 2399));4043assertNull(res[804].exec("zz", 2400));4044assertNull(res[804].exec("abcabcabczz", 2401));4045assertNull(res[804].exec(">>abczz", 2402));4046assertToStringEquals("bc,b", res[805].exec("bc"), 2403);4047assertToStringEquals("bbc,b", res[805].exec("bbc"), 2404);4048assertToStringEquals("bbbc,bb", res[805].exec("bbbc"), 2405);4049assertToStringEquals("bac,a", res[805].exec("bac"), 2406);4050assertToStringEquals("bbac,a", res[805].exec("bbac"), 2407);4051assertToStringEquals("aac,a", res[805].exec("aac"), 2408);4052assertToStringEquals("abbbbbbbbbbbc,bbbbbbbbbbb", res[805].exec("abbbbbbbbbbbc"), 2409);4053assertToStringEquals("bbbbbbbbbbbac,a", res[805].exec("bbbbbbbbbbbac"), 2410);4054assertNull(res[805].exec("*** Failers", 2411));4055assertNull(res[805].exec("aaac", 2412));4056assertNull(res[805].exec("abbbbbbbbbbbac", 2413));4057assertToStringEquals("bc,b", res[806].exec("bc"), 2414);4058assertToStringEquals("bbc,bb", res[806].exec("bbc"), 2415);4059assertToStringEquals("bbbc,bbb", res[806].exec("bbbc"), 2416);4060assertToStringEquals("bac,a", res[806].exec("bac"), 2417);4061assertToStringEquals("bbac,a", res[806].exec("bbac"), 2418);4062assertToStringEquals("aac,a", res[806].exec("aac"), 2419);4063assertToStringEquals("abbbbbbbbbbbc,bbbbbbbbbbb", res[806].exec("abbbbbbbbbbbc"), 2420);4064assertToStringEquals("bbbbbbbbbbbac,a", res[806].exec("bbbbbbbbbbbac"), 2421);4065assertNull(res[806].exec("*** Failers", 2422));4066assertNull(res[806].exec("aaac", 2423));4067assertNull(res[806].exec("abbbbbbbbbbbac", 2424));4068assertToStringEquals("bbc,bb", res[806].exec("bbc"), 2425);4069assertToStringEquals("babc,ba", res[807].exec("babc"), 2426);4070assertToStringEquals("bbabc,ba", res[807].exec("bbabc"), 2427);4071assertToStringEquals("bababc,ba", res[807].exec("bababc"), 2428);4072assertNull(res[807].exec("*** Failers", 2429));4073assertNull(res[807].exec("bababbc", 2430));4074assertNull(res[807].exec("babababc", 2431));4075assertToStringEquals("babc,ba", res[808].exec("babc"), 2432);4076assertToStringEquals("bbabc,ba", res[808].exec("bbabc"), 2433);4077assertToStringEquals("bababc,ba", res[808].exec("bababc"), 2434);4078assertNull(res[808].exec("*** Failers", 2435));4079assertNull(res[808].exec("bababbc", 2436));4080assertNull(res[808].exec("babababc", 2437));4081assertThrows("var re = /^\\ca\\cA\\c[\\c{\\c:/;");4082assertNull(res[808].exec("\x01\x01e;z", 2439));4083assertToStringEquals("a", res[809].exec("athing"), 2440);4084assertToStringEquals("b", res[809].exec("bthing"), 2441);4085assertToStringEquals("]", res[809].exec("]thing"), 2442);4086assertToStringEquals("c", res[809].exec("cthing"), 2443);4087assertToStringEquals("d", res[809].exec("dthing"), 2444);4088assertToStringEquals("e", res[809].exec("ething"), 2445);4089assertNull(res[809].exec("*** Failers", 2446));4090assertNull(res[809].exec("fthing", 2447));4091assertNull(res[809].exec("[thing", 2448));4092assertNull(res[809].exec("\\thing", 2449));4093assertNull(res[810].exec("]thing", 2450));4094assertNull(res[810].exec("cthing", 2451));4095assertNull(res[810].exec("dthing", 2452));4096assertNull(res[810].exec("ething", 2453));4097assertNull(res[810].exec("*** Failers", 2454));4098assertNull(res[810].exec("athing", 2455));4099assertNull(res[810].exec("fthing", 2456));4100assertToStringEquals("f", res[811].exec("fthing"), 2457);4101assertToStringEquals("[", res[811].exec("[thing"), 2458);4102assertToStringEquals("\\", res[811].exec("\\thing"), 2459);4103assertToStringEquals("*", res[811].exec("*** Failers"), 2460);4104assertNull(res[811].exec("athing", 2461));4105assertNull(res[811].exec("bthing", 2462));4106assertNull(res[811].exec("]thing", 2463));4107assertNull(res[811].exec("cthing", 2464));4108assertNull(res[811].exec("dthing", 2465));4109assertNull(res[811].exec("ething", 2466));4110assertNull(res[812].exec("athing", 2467));4111assertNull(res[812].exec("fthing", 2468));4112assertNull(res[812].exec("*** Failers", 2469));4113assertNull(res[812].exec("]thing", 2470));4114assertNull(res[812].exec("cthing", 2471));4115assertNull(res[812].exec("dthing", 2472));4116assertNull(res[812].exec("ething", 2473));4117assertNull(res[812].exec("\ufffd", 2474));4118assertNull(res[812].exec("\ufffd", 2475));4119assertToStringEquals("0", res[813].exec("0"), 2476);4120assertToStringEquals("1", res[813].exec("1"), 2477);4121assertToStringEquals("2", res[813].exec("2"), 2478);4122assertToStringEquals("3", res[813].exec("3"), 2479);4123assertToStringEquals("4", res[813].exec("4"), 2480);4124assertToStringEquals("5", res[813].exec("5"), 2481);4125assertToStringEquals("6", res[813].exec("6"), 2482);4126assertToStringEquals("7", res[813].exec("7"), 2483);4127assertToStringEquals("8", res[813].exec("8"), 2484);4128assertToStringEquals("9", res[813].exec("9"), 2485);4129assertToStringEquals("10", res[813].exec("10"), 2486);4130assertToStringEquals("100", res[813].exec("100"), 2487);4131assertNull(res[813].exec("*** Failers", 2488));4132assertNull(res[813].exec("abc", 2489));4133assertToStringEquals("enter", res[814].exec("enter"), 2490);4134assertToStringEquals("inter", res[814].exec("inter"), 2491);4135assertToStringEquals("uponter", res[814].exec("uponter"), 2492);4136assertToStringEquals("xxx0", res[815].exec("xxx0"), 2493);4137assertToStringEquals("xxx1234", res[815].exec("xxx1234"), 2494);4138assertNull(res[815].exec("*** Failers", 2495));4139assertNull(res[815].exec("xxx", 2496));4140assertToStringEquals("x123", res[816].exec("x123"), 2497);4141assertToStringEquals("xx123", res[816].exec("xx123"), 2498);4142assertToStringEquals("123456", res[816].exec("123456"), 2499);4143assertNull(res[816].exec("*** Failers", 2500));4144assertNull(res[816].exec("123", 2501));4145assertToStringEquals("x1234", res[816].exec("x1234"), 2502);4146assertToStringEquals("x123", res[817].exec("x123"), 2503);4147assertToStringEquals("xx123", res[817].exec("xx123"), 2504);4148assertToStringEquals("123456", res[817].exec("123456"), 2505);4149assertNull(res[817].exec("*** Failers", 2506));4150assertNull(res[817].exec("123", 2507));4151assertToStringEquals("x1234", res[817].exec("x1234"), 2508);4152assertToStringEquals("abc!pqr=apquxz.ixr.zzz.ac.uk,abc,pqr", res[818].exec("abc!pqr=apquxz.ixr.zzz.ac.uk"), 2509);4153assertNull(res[818].exec("*** Failers", 2510));4154assertNull(res[818].exec("!pqr=apquxz.ixr.zzz.ac.uk", 2511));4155assertNull(res[818].exec("abc!=apquxz.ixr.zzz.ac.uk", 2512));4156assertNull(res[818].exec("abc!pqr=apquxz:ixr.zzz.ac.uk", 2513));4157assertNull(res[818].exec("abc!pqr=apquxz.ixr.zzz.ac.ukk", 2514));4158assertToStringEquals(":", res[819].exec("Well, we need a colon: somewhere"), 2515);4159assertNull(res[819].exec("*** Fail if we don't", 2516));4160assertToStringEquals("0abc,0abc", res[820].exec("0abc"), 2517);4161assertToStringEquals("abc,abc", res[820].exec("abc"), 2518);4162assertToStringEquals("fed,fed", res[820].exec("fed"), 2519);4163assertToStringEquals("E,E", res[820].exec("E"), 2520);4164assertToStringEquals("::,::", res[820].exec("::"), 2521);4165assertToStringEquals("5f03:12C0::932e,5f03:12C0::932e", res[820].exec("5f03:12C0::932e"), 2522);4166assertToStringEquals("def,def", res[820].exec("fed def"), 2523);4167assertToStringEquals("ff,ff", res[820].exec("Any old stuff"), 2524);4168assertNull(res[820].exec("*** Failers", 2525));4169assertNull(res[820].exec("0zzz", 2526));4170assertNull(res[820].exec("gzzz", 2527));4171assertNull(res[820].exec("fed ", 2528));4172assertNull(res[820].exec("Any old rubbish", 2529));4173assertToStringEquals(".1.2.3,1,2,3", res[821].exec(".1.2.3"), 2530);4174assertToStringEquals("A.12.123.0,12,123,0", res[821].exec("A.12.123.0"), 2531);4175assertNull(res[821].exec("*** Failers", 2532));4176assertNull(res[821].exec(".1.2.3333", 2533));4177assertNull(res[821].exec("1.2.3", 2534));4178assertNull(res[821].exec("1234.2.3", 2535));4179assertToStringEquals("1 IN SOA non-sp1 non-sp2(,1,non-sp1,non-sp2", res[822].exec("1 IN SOA non-sp1 non-sp2("), 2536);4180assertToStringEquals("1 IN SOA non-sp1 non-sp2 (,1,non-sp1,non-sp2", res[822].exec("1 IN SOA non-sp1 non-sp2 ("), 2537);4181assertNull(res[822].exec("*** Failers", 2538));4182assertNull(res[822].exec("1IN SOA non-sp1 non-sp2(", 2539));4183assertToStringEquals("a.,", res[823].exec("a."), 2540);4184assertToStringEquals("Z.,", res[823].exec("Z."), 2541);4185assertToStringEquals("2.,", res[823].exec("2."), 2542);4186assertToStringEquals("ab-c.pq-r.,.pq-r", res[823].exec("ab-c.pq-r."), 2543);4187assertToStringEquals("sxk.zzz.ac.uk.,.uk", res[823].exec("sxk.zzz.ac.uk."), 2544);4188assertToStringEquals("x-.y-.,.y-", res[823].exec("x-.y-."), 2545);4189assertNull(res[823].exec("*** Failers", 2546));4190assertNull(res[823].exec("-abc.peq.", 2547));4191assertToStringEquals("*.a,,,", res[824].exec("*.a"), 2548);4192assertToStringEquals("*.b0-a,0-a,,", res[824].exec("*.b0-a"), 2549);4193assertToStringEquals("*.c3-b.c,3-b,.c,", res[824].exec("*.c3-b.c"), 2550);4194assertToStringEquals("*.c-a.b-c,-a,.b-c,-c", res[824].exec("*.c-a.b-c"), 2551);4195assertNull(res[824].exec("*** Failers", 2552));4196assertNull(res[824].exec("*.0", 2553));4197assertNull(res[824].exec("*.a-", 2554));4198assertNull(res[824].exec("*.a-b.c-", 2555));4199assertNull(res[824].exec("*.c-a.0-c", 2556));4200assertToStringEquals("abde,de,abd,e", res[825].exec("abde"), 2557);4201assertToStringEquals("abdf,,abd,f", res[826].exec("abdf"), 2558);4202assertToStringEquals("ab,abcd,cd,ab", res[827].exec("abcd"), 2559);4203assertToStringEquals("a.b.c.d,.d", res[828].exec("a.b.c.d"), 2560);4204assertToStringEquals("A.B.C.D,.D", res[828].exec("A.B.C.D"), 2561);4205assertToStringEquals("a.b.c.1.2.3.C,.C", res[828].exec("a.b.c.1.2.3.C"), 2562);4206assertToStringEquals("\"1234\",", res[829].exec("\"1234\""), 2563);4207assertToStringEquals("\"abcd\" ;,;", res[829].exec("\"abcd\" ;"), 2564);4208assertToStringEquals("\"\" ; rhubarb,; rhubarb", res[829].exec("\"\" ; rhubarb"), 2565);4209assertNull(res[829].exec("*** Failers", 2566));4210assertNull(res[829].exec("\"1234\" : things", 2567));4211assertNull(res[830].exec("\\", 2568));4212assertNull(res[830].exec("*** Failers", 2569));4213assertToStringEquals("ab c", res[831].exec("ab c"), 2570);4214assertNull(res[831].exec("*** Failers", 2571));4215assertNull(res[831].exec("abc", 2572));4216assertNull(res[831].exec("ab cde", 2573));4217assertToStringEquals("ab c", res[831].exec("ab c"), 2574);4218assertNull(res[831].exec("*** Failers", 2575));4219assertNull(res[831].exec("abc", 2576));4220assertNull(res[831].exec("ab cde", 2577));4221assertToStringEquals("a bcd", res[832].exec("a bcd"), 2578);4222assertNull(res[832].exec("a b d", 2579));4223assertNull(res[832].exec("*** Failers", 2580));4224assertNull(res[832].exec("abcd", 2581));4225assertNull(res[832].exec("ab d", 2582));4226assertToStringEquals("abcdefhijklm,abc,bc,c,def,ef,f,hij,ij,j,klm,lm,m", res[833].exec("abcdefhijklm"), 2583);4227assertToStringEquals("abcdefhijklm,bc,c,ef,f,ij,j,lm,m", res[834].exec("abcdefhijklm"), 2584);4228assertNull(res[835].exec("a+ Z0+\x08\n\x1d\x12", 2585));4229assertNull(res[835].exec(".^$(*+)|{?,?}", 2586));4230assertToStringEquals("z", res[836].exec("z"), 2587);4231assertToStringEquals("az", res[836].exec("az"), 2588);4232assertToStringEquals("aaaz", res[836].exec("aaaz"), 2589);4233assertToStringEquals("a", res[836].exec("a"), 2590);4234assertToStringEquals("aa", res[836].exec("aa"), 2591);4235assertToStringEquals("aaaa", res[836].exec("aaaa"), 2592);4236assertToStringEquals("a", res[836].exec("a+"), 2593);4237assertToStringEquals("aa", res[836].exec("aa+"), 2594);4238assertToStringEquals("z", res[837].exec("z"), 2595);4239assertToStringEquals("a", res[837].exec("az"), 2596);4240assertToStringEquals("a", res[837].exec("aaaz"), 2597);4241assertToStringEquals("a", res[837].exec("a"), 2598);4242assertToStringEquals("a", res[837].exec("aa"), 2599);4243assertToStringEquals("a", res[837].exec("aaaa"), 2600);4244assertToStringEquals("a", res[837].exec("a+"), 2601);4245assertToStringEquals("a", res[837].exec("aa+"), 2602);4246assertToStringEquals("az", res[838].exec("az"), 2603);4247assertToStringEquals("aaaz", res[838].exec("aaaz"), 2604);4248assertToStringEquals("aa", res[838].exec("aa"), 2605);4249assertToStringEquals("aaaa", res[838].exec("aaaa"), 2606);4250assertToStringEquals("aa", res[838].exec("aa+"), 2607);4251assertToStringEquals("az", res[839].exec("az"), 2608);4252assertToStringEquals("aa", res[839].exec("aaaz"), 2609);4253assertToStringEquals("aa", res[839].exec("aa"), 2610);4254assertToStringEquals("aa", res[839].exec("aaaa"), 2611);4255assertToStringEquals("aa", res[839].exec("aa+"), 2612);4256assertToStringEquals("1234567890", res[840].exec("1234567890"), 2613);4257assertToStringEquals("12345678ab", res[840].exec("12345678ab"), 2614);4258assertToStringEquals("12345678__", res[840].exec("12345678__"), 2615);4259assertNull(res[840].exec("*** Failers", 2616));4260assertNull(res[840].exec("1234567", 2617));4261assertToStringEquals("uoie", res[841].exec("uoie"), 2618);4262assertToStringEquals("1234", res[841].exec("1234"), 2619);4263assertToStringEquals("12345", res[841].exec("12345"), 2620);4264assertToStringEquals("aaaaa", res[841].exec("aaaaa"), 2621);4265assertNull(res[841].exec("*** Failers", 2622));4266assertNull(res[841].exec("123456", 2623));4267assertToStringEquals("uoie", res[842].exec("uoie"), 2624);4268assertToStringEquals("1234", res[842].exec("1234"), 2625);4269assertToStringEquals("1234", res[842].exec("12345"), 2626);4270assertToStringEquals("aaaa", res[842].exec("aaaaa"), 2627);4271assertToStringEquals("1234", res[842].exec("123456"), 2628);4272assertToStringEquals("From abcd Mon Sep 01 12:33,abcd", res[843].exec("From abcd Mon Sep 01 12:33:02 1997"), 2629);4273assertToStringEquals("From abcd Mon Sep 01 12:33,Sep ", res[844].exec("From abcd Mon Sep 01 12:33:02 1997"), 2630);4274assertToStringEquals("From abcd Mon Sep 1 12:33,Sep ", res[844].exec("From abcd Mon Sep 1 12:33:02 1997"), 2631);4275assertNull(res[844].exec("*** Failers", 2632));4276assertNull(res[844].exec("From abcd Sep 01 12:33:02 1997", 2633));4277assertNull(res[845].exec("12\n34", 2634));4278assertNull(res[845].exec("12\x0d34", 2635));4279assertToStringEquals("brown", res[846].exec("the quick brown\x09 fox"), 2636);4280assertToStringEquals("foolish see?,lish see?", res[847].exec("foobar is foolish see?"), 2637);4281assertToStringEquals("rowbar etc, etc", res[848].exec("foobar crowbar etc"), 2638);4282assertToStringEquals("barrel,rel", res[848].exec("barrel"), 2639);4283assertToStringEquals("2barrel,rel", res[848].exec("2barrel"), 2640);4284assertToStringEquals("A barrel,rel", res[848].exec("A barrel"), 2641);4285assertToStringEquals("abc,abc", res[849].exec("abc456"), 2642);4286assertNull(res[849].exec("*** Failers", 2643));4287assertNull(res[849].exec("abc123", 2644));4288assertToStringEquals("1234", res[850].exec("1234"), 2645);4289assertToStringEquals("1234", res[851].exec("1234"), 2646);4290assertToStringEquals("abcd", res[852].exec("abcd"), 2647);4291assertToStringEquals("abcd", res[853].exec("abcd"), 2648);4292assertToStringEquals("abc", res[854].exec("the abc"), 2649);4293assertNull(res[854].exec("*** Failers", 2650));4294assertNull(res[854].exec("abc", 2651));4295assertToStringEquals("abc", res[855].exec("abc"), 2652);4296assertNull(res[855].exec("*** Failers", 2653));4297assertNull(res[855].exec("the abc", 2654));4298assertToStringEquals("aabb,b", res[856].exec("aabbbbb"), 2655);4299assertToStringEquals("aabbbbb,abbbbb", res[857].exec("aabbbbb"), 2656);4300assertToStringEquals("aa,a", res[858].exec("aabbbbb"), 2657);4301assertToStringEquals("aabb,b", res[859].exec("aabbbbb"), 2658);4302assertToStringEquals("Alan Other <user@dom.ain>", res[860].exec("Alan Other <user@dom.ain>"), 2659);4303assertToStringEquals("user@dom.ain", res[860].exec("<user@dom.ain>"), 2660);4304assertToStringEquals("user@dom.ain", res[860].exec("user@dom.ain"), 2661);4305assertToStringEquals("\"A. Other\" <user.1234@dom.ain> (a comment)", res[860].exec("\"A. Other\" <user.1234@dom.ain> (a comment)"), 2662);4306assertToStringEquals(" Other <user.1234@dom.ain> (a comment)", res[860].exec("A. Other <user.1234@dom.ain> (a comment)"), 2663);4307assertToStringEquals("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay", res[860].exec("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay"), 2664);4308assertToStringEquals("user@some.where", res[860].exec("A missing angle <user@some.where"), 2665);4309assertNull(res[860].exec("*** Failers", 2666));4310assertNull(res[860].exec("The quick brown fox", 2667));4311assertToStringEquals("Alan Other <user@dom.ain>", res[861].exec("Alan Other <user@dom.ain>"), 2668);4312assertToStringEquals("user@dom.ain", res[861].exec("<user@dom.ain>"), 2669);4313assertToStringEquals("user@dom.ain", res[861].exec("user@dom.ain"), 2670);4314assertToStringEquals("\"A. Other\" <user.1234@dom.ain>", res[861].exec("\"A. Other\" <user.1234@dom.ain> (a comment)"), 2671);4315assertToStringEquals(" Other <user.1234@dom.ain>", res[861].exec("A. Other <user.1234@dom.ain> (a comment)"), 2672);4316assertToStringEquals("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay", res[861].exec("\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay"), 2673);4317assertToStringEquals("user@some.where", res[861].exec("A missing angle <user@some.where"), 2674);4318assertNull(res[861].exec("*** Failers", 2675));4319assertNull(res[861].exec("The quick brown fox", 2676));4320assertNull(res[861].exec("abc\x00def\x00pqr\x00xyz\x000AB", 2677));4321assertNull(res[861].exec("abc456 abc\x00def\x00pqr\x00xyz\x000ABCDE", 2678));4322assertToStringEquals("abc\x0def\x00pqr\x000xyz\x0000AB", res[862].exec("abc\x0def\x00pqr\x000xyz\x0000AB"), 2679);4323assertToStringEquals("abc\x0def\x00pqr\x000xyz\x0000AB", res[862].exec("abc456 abc\x0def\x00pqr\x000xyz\x0000ABCDE"), 2680);4324assertToStringEquals("\x00", res[863].exec("\x00A"), 2681);4325assertToStringEquals("\x01", res[863].exec("\x01B"), 2682);4326assertToStringEquals("\x1f", res[863].exec("\x1fC"), 2683);4327assertToStringEquals("\x00\x00\x00\x00", res[864].exec("\x00\x00\x00\x00"), 2684);4328assertNull(res[865].exec("The Ax0x0Z", 2685));4329assertNull(res[865].exec("An A\x00x0\x00Z", 2686));4330assertNull(res[865].exec("*** Failers", 2687));4331assertNull(res[865].exec("A\x00Z", 2688));4332assertNull(res[865].exec("A\x00x0\x00x0Z", 2689));4333assertToStringEquals(" ", res[866].exec(" abc"), 2690);4334assertToStringEquals("\x0c", res[866].exec("\x0cabc"), 2691);4335assertToStringEquals("\n", res[866].exec("\nabc"), 2692);4336assertToStringEquals("\x0d", res[866].exec("\x0dabc"), 2693);4337assertToStringEquals("\x09", res[866].exec("\x09abc"), 2694);4338assertNull(res[866].exec("*** Failers", 2695));4339assertNull(res[866].exec("abc", 2696));4340assertToStringEquals("abc", res[867].exec("abc"), 2697);4341assertToStringEquals("abbbbc", res[868].exec("abbbbc"), 2698);4342assertToStringEquals("abbbc", res[868].exec("abbbc"), 2699);4343assertToStringEquals("abbc", res[868].exec("abbc"), 2700);4344assertNull(res[868].exec("*** Failers", 2701));4345assertNull(res[868].exec("abc", 2702));4346assertNull(res[868].exec("abbbbbc", 2703));4347assertToStringEquals("track1.title:TBlah blah blah,track1,title,Blah blah blah", res[869].exec("track1.title:TBlah blah blah"), 2704);4348assertToStringEquals("track1.title:TBlah blah blah,track1,title,Blah blah blah", res[870].exec("track1.title:TBlah blah blah"), 2705);4349assertToStringEquals("track1.title:TBlah blah blah,track1,title,Blah blah blah", res[871].exec("track1.title:TBlah blah blah"), 2706);4350assertToStringEquals("WXY_^abc", res[872].exec("WXY_^abc"), 2707);4351assertNull(res[872].exec("*** Failers", 2708));4352assertNull(res[872].exec("wxy", 2709));4353assertToStringEquals("WXY_^abc", res[873].exec("WXY_^abc"), 2710);4354assertToStringEquals("wxy_^ABC", res[873].exec("wxy_^ABC"), 2711);4355assertToStringEquals("WXY_^abc", res[874].exec("WXY_^abc"), 2712);4356assertToStringEquals("wxy_^ABC", res[874].exec("wxy_^ABC"), 2713);4357assertToStringEquals("abc", res[875].exec("abc"), 2714);4358assertToStringEquals("abc", res[875].exec("qqq\nabc"), 2715);4359assertToStringEquals("abc", res[875].exec("abc\nzzz"), 2716);4360assertToStringEquals("abc", res[875].exec("qqq\nabc\nzzz"), 2717);4361assertToStringEquals("abc", res[876].exec("abc"), 2718);4362assertNull(res[876].exec("*** Failers", 2719));4363assertNull(res[876].exec("qqq\nabc", 2720));4364assertNull(res[876].exec("abc\nzzz", 2721));4365assertNull(res[876].exec("qqq\nabc\nzzz", 2722));4366assertNull(res[877].exec("abc", 2723));4367assertNull(res[877].exec("abc\n ", 2724));4368assertNull(res[877].exec("*** Failers", 2725));4369assertNull(res[877].exec("qqq\nabc", 2726));4370assertNull(res[877].exec("abc\nzzz", 2727));4371assertNull(res[877].exec("qqq\nabc\nzzz", 2728));4372assertNull(res[878].exec("abc\ndef", 2729));4373assertNull(res[879].exec("*** Failers", 2730));4374assertNull(res[879].exec("abc\ndef", 2731));4375assertToStringEquals("b", res[880].exec("b::c"), 2732);4376assertToStringEquals("::", res[880].exec("c::b"), 2733);4377assertToStringEquals("az-", res[881].exec("az-"), 2734);4378assertToStringEquals("a", res[881].exec("*** Failers"), 2735);4379assertNull(res[881].exec("b", 2736));4380assertToStringEquals("za-", res[882].exec("za-"), 2737);4381assertToStringEquals("a", res[882].exec("*** Failers"), 2738);4382assertNull(res[882].exec("b", 2739));4383assertToStringEquals("a-z", res[883].exec("a-z"), 2740);4384assertToStringEquals("a", res[883].exec("*** Failers"), 2741);4385assertNull(res[883].exec("b", 2742));4386assertToStringEquals("abcdxyz", res[884].exec("abcdxyz"), 2743);4387assertToStringEquals("12-34", res[885].exec("12-34"), 2744);4388assertNull(res[885].exec("*** Failers", 2745));4389assertNull(res[885].exec("aaa", 2746));4390assertToStringEquals("12-34z", res[886].exec("12-34z"), 2747);4391assertNull(res[886].exec("*** Failers", 2748));4392assertNull(res[886].exec("aaa", 2749));4393assertToStringEquals("\\", res[887].exec("\\\\"), 2750);4394assertToStringEquals(" Z", res[888].exec("the Zoo"), 2751);4395assertNull(res[888].exec("*** Failers", 2752));4396assertNull(res[888].exec("Zulu", 2753));4397assertToStringEquals("ab{3cd", res[889].exec("ab{3cd"), 2754);4398assertToStringEquals("ab{3,cd", res[890].exec("ab{3,cd"), 2755);4399assertToStringEquals("ab{3,4a}cd", res[891].exec("ab{3,4a}cd"), 2756);4400assertToStringEquals("{4,5a}bc", res[892].exec("{4,5a}bc"), 2757);4401assertNull(res[893].exec("a\x0db", 2758));4402assertNull(res[893].exec("*** Failers", 2759));4403assertNull(res[893].exec("a\nb", 2760));4404assertToStringEquals("abc", res[894].exec("abc"), 2761);4405assertNull(res[894].exec("abc\n", 2762));4406assertNull(res[894].exec("*** Failers", 2763));4407assertNull(res[894].exec("abc\ndef", 2764));4408assertToStringEquals("abcS,abc", res[895].exec("abcS"), 2765);4409assertToStringEquals("abc\x93,abc", res[896].exec("abc\x93"), 2766);4410assertToStringEquals("abc\xd3,abc", res[897].exec("abc\xd3"), 2767);4411assertToStringEquals("abc@,abc", res[898].exec("abc@"), 2768);4412assertToStringEquals("abc@,abc", res[898].exec("abc@"), 2769);4413assertToStringEquals("abc@,abc", res[898].exec("abc@0"), 2770);4414assertToStringEquals("abc@,abc", res[898].exec("abc@0"), 2771);4415assertToStringEquals("abc@,abc", res[898].exec("abc@0"), 2772);4416assertToStringEquals("abc@,abc", res[898].exec("abc@0"), 2773);4417assertToStringEquals("abc@,abc", res[898].exec("abc@0"), 2774);4418assertToStringEquals("abc@,abc", res[898].exec("abc@0"), 2775);4419assertNull(res[899].exec("abc\x0081", 2776));4420assertNull(res[899].exec("abc\x0081", 2777));4421assertNull(res[900].exec("abc\x0091", 2778));4422assertNull(res[900].exec("abc\x0091", 2779));4423assertToStringEquals("abcdefghijk\nS,a,b,c,d,e,f,g,h,i,j,k", res[901].exec("abcdefghijk\nS"), 2780);4424assertToStringEquals("abidef", res[902].exec("abidef"), 2781);4425assertToStringEquals("bc", res[903].exec("bc"), 2782);4426assertToStringEquals("xyz,,", res[904].exec("xyz"), 2783);4427assertToStringEquals("abc\x08de", res[905].exec("abc\x08de"), 2784);4428assertToStringEquals("abc\x01de", res[906].exec("abc\x01de"), 2785);4429assertToStringEquals("abc\x01de,abc", res[907].exec("abc\x01de"), 2786);4430assertNull(res[907].exec("a\nb", 2787));4431assertToStringEquals("baNOTcccc,b,a,NOT,cccc", res[908].exec("baNOTccccd"), 2788);4432assertToStringEquals("baNOTccc,b,a,NOT,ccc", res[908].exec("baNOTcccd"), 2789);4433assertToStringEquals("baNOTcc,b,a,NO,Tcc", res[908].exec("baNOTccd"), 2790);4434assertToStringEquals("baccc,b,a,,ccc", res[908].exec("bacccd"), 2791);4435assertToStringEquals("*** Failers,*,*,* Fail,ers", res[908].exec("*** Failers"), 2792);4436assertNull(res[908].exec("anything", 2793));4437assertNull(res[908].exec("b\x08c ", 2794));4438assertNull(res[908].exec("baccd", 2795));4439assertToStringEquals("A", res[909].exec("Abc"), 2796);4440assertToStringEquals("b", res[910].exec("Abc "), 2797);4441assertToStringEquals("AAA", res[911].exec("AAAaAbc"), 2798);4442assertToStringEquals("bc ", res[912].exec("AAAaAbc "), 2799);4443assertToStringEquals("bbb\nccc", res[913].exec("bbb\nccc"), 2800);4444assertToStringEquals("c", res[914].exec("abc"), 2801);4445assertToStringEquals("s", res[914].exec("*** Failers"), 2802);4446assertToStringEquals(" ", res[914].exec("abk "), 2803);4447assertToStringEquals("abc", res[915].exec("abc"), 2804);4448assertToStringEquals("bc", res[915].exec("kbc"), 2805);4449assertToStringEquals("bc ", res[915].exec("kabc "), 2806);4450assertToStringEquals("ers", res[915].exec("*** Failers"), 2807);4451assertNull(res[915].exec("abk", 2808));4452assertNull(res[915].exec("akb", 2809));4453assertNull(res[915].exec("akk ", 2810));4454assertToStringEquals("12345678@a.b.c.d", res[916].exec("12345678@a.b.c.d"), 2811);4455assertToStringEquals("123456789@x.y.z", res[916].exec("123456789@x.y.z"), 2812);4456assertNull(res[916].exec("*** Failers", 2813));4457assertNull(res[916].exec("12345678@x.y.uk", 2814));4458assertNull(res[916].exec("1234567@a.b.c.d ", 2815));4459assertToStringEquals("b", res[917].exec("aaaabcd"), 2816);4460assertToStringEquals("A", res[917].exec("aaAabcd "), 2817);4461assertToStringEquals("b", res[918].exec("aaaabcd"), 2818);4462assertToStringEquals("b", res[918].exec("aaAabcd "), 2819);4463assertToStringEquals("b", res[919].exec("aaaabcd"), 2820);4464assertToStringEquals("A", res[919].exec("aaAabcd "), 2821);4465assertToStringEquals("b", res[920].exec("aaaabcd"), 2822);4466assertToStringEquals("b", res[920].exec("aaAabcd "), 2823);4467assertToStringEquals("PSTAIREISLL", res[922].exec("xxxxxxxxxxxPSTAIREISLLxxxxxxxxx"), 2824);4468assertToStringEquals("PSTAIREISLL", res[923].exec("xxxxxxxxxxxPSTAIREISLLxxxxxxxxx"), 2825);4469assertToStringEquals(".230003938,.23", res[924].exec("1.230003938"), 2826);4470assertToStringEquals(".875000282,.875", res[924].exec("1.875000282 "), 2827);4471assertToStringEquals(".235,.23", res[924].exec("1.235 "), 2828);4472assertNull(res[924].exec(" ", 2829));4473assertToStringEquals(".23,.23,", res[925].exec("1.230003938 "), 2830);4474assertToStringEquals(".875,.875,5", res[925].exec("1.875000282"), 2831);4475assertNull(res[925].exec("*** Failers ", 2832));4476assertNull(res[925].exec("1.235 ", 2833));4477assertThrows("var re = /a(?)b/;");4478assertNull(res[925].exec("ab ", 2835));4479assertToStringEquals("foo table,foo,table", res[926].exec("Food is on the foo table"), 2836);4480assertToStringEquals("food is under the bar in the bar,d is under the bar in the ", res[927].exec("The food is under the bar in the barn."), 2837);4481assertToStringEquals("food is under the bar,d is under the ", res[928].exec("The food is under the bar in the barn."), 2838);4482assertToStringEquals("I have 2 numbers: 53147,I have 2 numbers: 53147,", res[929].exec("I have 2 numbers: 53147"), 2839);4483assertToStringEquals("I have 2 numbers: 53147,I have 2 numbers: 5314,7", res[930].exec("I have 2 numbers: 53147"), 2840);4484assertToStringEquals(",,", res[931].exec("I have 2 numbers: 53147"), 2841);4485assertToStringEquals("I have 2,I have ,2", res[932].exec("I have 2 numbers: 53147"), 2842);4486assertToStringEquals("I have 2 numbers: 53147,I have 2 numbers: 5314,7", res[933].exec("I have 2 numbers: 53147"), 2843);4487assertToStringEquals("I have 2 numbers: 53147,I have 2 numbers: ,53147", res[934].exec("I have 2 numbers: 53147"), 2844);4488assertToStringEquals("I have 2 numbers: 53147,I have 2 numbers: ,53147", res[935].exec("I have 2 numbers: 53147"), 2845);4489assertToStringEquals("I have 2 numbers: 53147,I have 2 numbers: ,53147", res[936].exec("I have 2 numbers: 53147"), 2846);4490assertToStringEquals("AB", res[937].exec("ABC123"), 2847);4491assertToStringEquals(" ", res[937].exec(" "), 2848);4492assertToStringEquals("ABC,ABC", res[938].exec("ABC445"), 2849);4493assertNull(res[938].exec("*** Failers", 2850));4494assertNull(res[938].exec("ABC123", 2851));4495assertToStringEquals("W46]", res[939].exec("W46]789 "), 2852);4496assertToStringEquals("-46]", res[939].exec("-46]789"), 2853);4497assertNull(res[939].exec("*** Failers", 2854));4498assertNull(res[939].exec("Wall", 2855));4499assertNull(res[939].exec("Zebra", 2856));4500assertNull(res[939].exec("42", 2857));4501assertNull(res[939].exec("[abcd] ", 2858));4502assertNull(res[939].exec("]abcd[", 2859));4503assertNull(res[939].exec(" ", 2860));4504assertToStringEquals("W", res[940].exec("W46]789 "), 2861);4505assertToStringEquals("W", res[940].exec("Wall"), 2862);4506assertToStringEquals("Z", res[940].exec("Zebra"), 2863);4507assertToStringEquals("X", res[940].exec("Xylophone "), 2864);4508assertToStringEquals("4", res[940].exec("42"), 2865);4509assertToStringEquals("[", res[940].exec("[abcd] "), 2866);4510assertToStringEquals("]", res[940].exec("]abcd["), 2867);4511assertToStringEquals("\\", res[940].exec("\\backslash "), 2868);4512assertNull(res[940].exec("*** Failers", 2869));4513assertNull(res[940].exec("-46]789", 2870));4514assertNull(res[940].exec("well", 2871));4515assertToStringEquals("01/01/2000", res[941].exec("01/01/2000"), 2872);4516assertToStringEquals(",", res[944].exec("bcd"), 2873);4517assertToStringEquals(",", res[944].exec("abc"), 2874);4518assertToStringEquals(",", res[944].exec("aab "), 2875);4519assertToStringEquals(",", res[945].exec("bcd"), 2876);4520assertToStringEquals("a,a", res[945].exec("abc"), 2877);4521assertToStringEquals("a,a", res[945].exec("aab "), 2878);4522assertToStringEquals(",", res[946].exec("bcd"), 2879);4523assertToStringEquals("a,a", res[946].exec("abc"), 2880);4524assertToStringEquals("aa,a", res[946].exec("aab "), 2881);4525assertToStringEquals(",", res[947].exec("bcd"), 2882);4526assertToStringEquals("a,a", res[947].exec("abc"), 2883);4527assertToStringEquals("aa,a", res[947].exec("aab"), 2884);4528assertToStringEquals("aaa,a", res[947].exec("aaa "), 2885);4529assertToStringEquals(",", res[948].exec("bcd"), 2886);4530assertToStringEquals("a,a", res[948].exec("abc"), 2887);4531assertToStringEquals("aa,a", res[948].exec("aab"), 2888);4532assertToStringEquals("aaa,a", res[948].exec("aaa"), 2889);4533assertToStringEquals("aaaaaaaa,a", res[948].exec("aaaaaaaa "), 2890);4534assertNull(res[949].exec("bcd", 2891));4535assertToStringEquals("a,a", res[949].exec("abc"), 2892);4536assertToStringEquals("a,a", res[949].exec("aab "), 2893);4537assertNull(res[950].exec("bcd", 2894));4538assertToStringEquals("a,a", res[950].exec("abc"), 2895);4539assertToStringEquals("aa,a", res[950].exec("aab "), 2896);4540assertNull(res[951].exec("bcd", 2897));4541assertToStringEquals("a,a", res[951].exec("abc"), 2898);4542assertToStringEquals("aa,a", res[951].exec("aab"), 2899);4543assertToStringEquals("aaa,a", res[951].exec("aaa "), 2900);4544assertNull(res[952].exec("bcd", 2901));4545assertToStringEquals("a,a", res[952].exec("abc"), 2902);4546assertToStringEquals("aa,a", res[952].exec("aab"), 2903);4547assertToStringEquals("aaa,a", res[952].exec("aaa"), 2904);4548assertToStringEquals("aaaaaaaa,a", res[952].exec("aaaaaaaa "), 2905);4549assertToStringEquals("bib.gif", res[953].exec("borfle\nbib.gif\nno"), 2906);4550assertToStringEquals("bib.gif", res[954].exec("borfle\nbib.gif\nno"), 2907);4551assertToStringEquals("bib.gif", res[955].exec("borfle\nbib.gif\nno"), 2908);4552assertToStringEquals("bib.gif", res[956].exec("borfle\nbib.gif\nno"), 2909);4553assertToStringEquals("bib.gif", res[957].exec("borfle\nbib.gif\nno"), 2910);4554assertToStringEquals("no", res[958].exec("borfle\nbib.gif\nno"), 2911);4555assertToStringEquals("borfle", res[959].exec("borfle\nbib.gif\nno"), 2912);4556assertToStringEquals("no", res[960].exec("borfle\nbib.gif\nno"), 2913);4557assertToStringEquals("borfle", res[961].exec("borfle\nbib.gif\nno"), 2914);4558assertToStringEquals("", res[962].exec("borfle\nbib.gif\nno\n"), 2915);4559assertToStringEquals("borfle", res[963].exec("borfle\nbib.gif\nno\n"), 2916);4560assertToStringEquals("", res[964].exec("borfle\nbib.gif\nno\n"), 2917);4561assertToStringEquals("borfle", res[965].exec("borfle\nbib.gif\nno\n"), 2918);4562assertToStringEquals("1234X,1234X", res[966].exec("abcde\n1234Xyz"), 2919);4563assertToStringEquals("B,B", res[966].exec("BarFoo "), 2920);4564assertNull(res[966].exec("*** Failers", 2921));4565assertNull(res[966].exec("abcde\nBar ", 2922));4566assertToStringEquals("1234X,1234X", res[967].exec("abcde\n1234Xyz"), 2923);4567assertToStringEquals("B,B", res[967].exec("BarFoo "), 2924);4568assertToStringEquals("B,B", res[967].exec("abcde\nBar "), 2925);4569assertToStringEquals("1234X,1234X", res[968].exec("abcde\n1234Xyz"), 2926);4570assertToStringEquals("B,B", res[968].exec("BarFoo "), 2927);4571assertNull(res[968].exec("*** Failers", 2928));4572assertNull(res[968].exec("abcde\nBar ", 2929));4573assertToStringEquals("1234X,1234X", res[969].exec("abcde\n1234Xyz"), 2930);4574assertToStringEquals("B,B", res[969].exec("BarFoo "), 2931);4575assertToStringEquals("B,B", res[969].exec("abcde\nBar "), 2932);4576assertToStringEquals("1234X,1234X", res[969].exec("abcde\n1234Xyz"), 2933);4577assertToStringEquals("B,B", res[969].exec("BarFoo "), 2934);4578assertNull(res[969].exec("*** Failers ", 2935));4579assertToStringEquals("B,B", res[969].exec("abcde\nBar "), 2936);4580assertToStringEquals("1234X,1234X", res[969].exec("abcde\n1234Xyz"), 2937);4581assertToStringEquals("B,B", res[969].exec("BarFoo "), 2938);4582assertNull(res[969].exec("*** Failers ", 2939));4583assertToStringEquals("B,B", res[969].exec("abcde\nBar "), 2940);4584assertNull(res[970].exec("**** Failers", 2941));4585assertNull(res[970].exec("abc\nB", 2942));4586assertNull(res[970].exec(" ", 2943));4587assertNull(res[970].exec("abc\nB", 2944));4588assertNull(res[970].exec("abc\nB", 2945));4589assertNull(res[970].exec(" ", 2946));4590assertNull(res[970].exec("abc\nB", 2947));4591assertNull(res[970].exec("abc\nB", 2948));4592assertToStringEquals("B", res[970].exec("B\n"), 2949);4593assertToStringEquals("123456654321", res[971].exec("123456654321"), 2950);4594assertToStringEquals("123456654321", res[972].exec("123456654321 "), 2951);4595assertToStringEquals("123456654321", res[973].exec("123456654321"), 2952);4596assertToStringEquals("abcabcabcabc", res[974].exec("abcabcabcabc"), 2953);4597assertToStringEquals("abcabcabcabc", res[975].exec("abcabcabcabc"), 2954);4598assertToStringEquals("abcabcabcabc,c", res[976].exec("abcabcabcabc "), 2955);4599assertToStringEquals("n", res[977].exec("n"), 2956);4600assertNull(res[977].exec("*** Failers ", 2957));4601assertNull(res[977].exec("z ", 2958));4602assertToStringEquals("abcd", res[978].exec("abcd"), 2959);4603assertNull(res[978].exec("*** Failers", 2960));4604assertNull(res[978].exec("abce ", 2961));4605assertToStringEquals("abe", res[979].exec("abe"), 2962);4606assertNull(res[979].exec("*** Failers", 2963));4607assertNull(res[979].exec("abcde ", 2964));4608assertToStringEquals("abd,", res[980].exec("abd"), 2965);4609assertNull(res[980].exec("*** Failers", 2966));4610assertNull(res[980].exec("abcd ", 2967));4611assertToStringEquals("a,", res[981].exec("a"), 2968);4612assertToStringEquals("ab,b", res[981].exec("ab"), 2969);4613assertToStringEquals("abbbb,bbbb", res[981].exec("abbbb"), 2970);4614assertToStringEquals("a,", res[981].exec("*** Failers"), 2971);4615assertNull(res[981].exec("bbbbb ", 2972));4616assertToStringEquals("abe", res[982].exec("abe"), 2973);4617assertNull(res[982].exec("*** Failers", 2974));4618assertNull(res[982].exec("ab1e ", 2975));4619assertToStringEquals("\"quick\",quick", res[983].exec("the \"quick\" brown fox"), 2976);4620assertToStringEquals("\"the \\\"quick\\\" brown fox\", brown fox", res[983].exec("\"the \\\"quick\\\" brown fox\" "), 2977);4621assertToStringEquals("", res[984].exec("abc"), 2978);4622assertToStringEquals("", res[985].exec("abc "), 2979);4623assertToStringEquals("", res[986].exec("abc "), 2980);4624assertThrows("var re = //;");4625assertToStringEquals("", res[986].exec("abc"), 2982);4626assertToStringEquals("acb", res[988].exec("acb"), 2983);4627assertToStringEquals("a\nb", res[988].exec("a\nb"), 2984);4628assertToStringEquals("acb", res[989].exec("acb"), 2985);4629assertNull(res[989].exec("*** Failers ", 2986));4630assertNull(res[989].exec("a\nb ", 2987));4631assertToStringEquals("acb", res[990].exec("acb"), 2988);4632assertToStringEquals("a\nb", res[990].exec("a\nb "), 2989);4633assertToStringEquals("acb", res[991].exec("acb"), 2990);4634assertNull(res[991].exec("a\nb ", 2991));4635assertToStringEquals("bac,a", res[992].exec("bac"), 2992);4636assertToStringEquals("bbac,a", res[992].exec("bbac"), 2993);4637assertToStringEquals("bbbac,a", res[992].exec("bbbac"), 2994);4638assertToStringEquals("bbbbac,a", res[992].exec("bbbbac"), 2995);4639assertToStringEquals("bbbbbac,a", res[992].exec("bbbbbac "), 2996);4640assertToStringEquals("bac,a", res[993].exec("bac"), 2997);4641assertToStringEquals("bbac,a", res[993].exec("bbac"), 2998);4642assertToStringEquals("bbbac,a", res[993].exec("bbbac"), 2999);4643assertToStringEquals("bbbbac,a", res[993].exec("bbbbac"), 3000);4644assertToStringEquals("bbbbbac,a", res[993].exec("bbbbbac "), 3001);4645assertToStringEquals("x", res[994].exec("x\nb\n"), 3002);4646assertToStringEquals("x", res[994].exec("a\x08x\n "), 3003);4647assertNull(res[995].exec("\x00{ab} ", 3004));4648assertToStringEquals("CD,", res[996].exec("CD "), 3005);4649assertToStringEquals("CD,", res[997].exec("CD "), 3006);4650assertNull(res[997].exec("foo", 3007));4651assertNull(res[997].exec("catfood", 3008));4652assertNull(res[997].exec("arfootle", 3009));4653assertNull(res[997].exec("rfoosh", 3010));4654assertNull(res[997].exec("*** Failers", 3011));4655assertNull(res[997].exec("barfoo", 3012));4656assertNull(res[997].exec("towbarfoo", 3013));4657assertNull(res[997].exec("catfood", 3014));4658assertNull(res[997].exec("*** Failers", 3015));4659assertNull(res[997].exec("foo", 3016));4660assertNull(res[997].exec("barfoo", 3017));4661assertNull(res[997].exec("towbarfoo", 3018));4662assertNull(res[997].exec("fooabar", 3019));4663assertNull(res[997].exec("*** Failers", 3020));4664assertNull(res[997].exec("bar", 3021));4665assertNull(res[997].exec("foobbar", 3022));4666assertNull(res[997].exec(" ", 3023));4667assertNull(res[998].exec("abc", 3024));4668assertNull(res[998].exec("*** Failers", 3025));4669assertNull(res[998].exec("abc\n ", 3026));4670assertNull(res[998].exec("qqq\nabc", 3027));4671assertNull(res[998].exec("abc\nzzz", 3028));4672assertNull(res[998].exec("qqq\nabc\nzzz", 3029));4673assertNull(res[998].exec("/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/it/you/see/", 3030));4674assertNull(res[998].exec("/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo", 3031));4675assertNull(res[998].exec("1.230003938", 3032));4676assertNull(res[998].exec("1.875000282", 3033));4677assertNull(res[998].exec("*** Failers ", 3034));4678assertNull(res[998].exec("1.235 ", 3035));4679assertNull(res[998].exec("now is the time for all good men to come to the aid of the party", 3036));4680assertNull(res[998].exec("*** Failers", 3037));4681assertNull(res[998].exec("this is not a line with only words and spaces!", 3038));4682assertToStringEquals("12345a,12345,a", res[999].exec("12345a"), 3039);4683assertToStringEquals("12345,1234,5", res[999].exec("12345+ "), 3040);4684assertToStringEquals("12345a,12345,a", res[999].exec("12345a"), 3041);4685assertNull(res[999].exec("*** Failers", 3042));4686assertToStringEquals("12345,1234,5", res[999].exec("12345+ "), 3043);4687assertNull(res[999].exec("aaab", 3044));4688assertNull(res[999].exec("aaab", 3045));4689assertNull(res[999].exec("aaab", 3046));4690assertNull(res[999].exec("aaabbbccc", 3047));4691assertNull(res[999].exec("aaabbbbccccd", 3048));4692assertToStringEquals("aaabbbbcccc,ccc", res[1000].exec("aaabbbbccccd"), 3049);4693assertToStringEquals("abc,b", res[1000].exec("((abc(ade)ufh()()x"), 3050);4694assertNull(res[1000].exec("", 3051));4695assertToStringEquals("abc,b", res[1000].exec("(abc)"), 3052);4696assertToStringEquals("abc,b", res[1000].exec("(abc(def)xyz)"), 3053);4697assertNull(res[1000].exec("*** Failers", 3054));4698assertNull(res[1000].exec("ab", 3055));4699assertNull(res[1000].exec("Ab", 3056));4700assertNull(res[1000].exec("*** Failers ", 3057));4701assertNull(res[1000].exec("aB", 3058));4702assertNull(res[1000].exec("AB", 3059));4703assertNull(res[1000].exec(" ", 3060));4704assertToStringEquals("bc,b", res[1000].exec("a bcd e"), 3061);4705assertNull(res[1000].exec("*** Failers", 3062));4706assertToStringEquals("c,", res[1000].exec("a b cd e"), 3063);4707assertToStringEquals("abc,b", res[1000].exec("abcd e "), 3064);4708assertToStringEquals("bc,b", res[1000].exec("a bcde "), 3065);4709assertToStringEquals("bc,b", res[1000].exec("a bcde f"), 3066);4710assertNull(res[1000].exec("*** Failers", 3067));4711assertToStringEquals("abc,b", res[1000].exec("abcdef "), 3068);4712assertToStringEquals("abc,b", res[1000].exec("abc"), 3069);4713assertToStringEquals("c,", res[1000].exec("aBc"), 3070);4714assertNull(res[1000].exec("*** Failers", 3071));4715assertNull(res[1000].exec("abC", 3072));4716assertNull(res[1000].exec("aBC ", 3073));4717assertToStringEquals("bc,b", res[1000].exec("Abc"), 3074);4718assertToStringEquals("c,", res[1000].exec("ABc"), 3075);4719assertNull(res[1000].exec("ABC", 3076));4720assertNull(res[1000].exec("AbC", 3077));4721assertNull(res[1000].exec("", 3078));4722assertToStringEquals("abc,b", res[1000].exec("abc"), 3079);4723assertToStringEquals("c,", res[1000].exec("aBc"), 3080);4724assertNull(res[1000].exec("*** Failers ", 3081));4725assertNull(res[1000].exec("ABC", 3082));4726assertNull(res[1000].exec("abC", 3083));4727assertNull(res[1000].exec("aBC", 3084));4728assertNull(res[1000].exec("", 3085));4729assertToStringEquals("c,", res[1000].exec("aBc"), 3086);4730assertToStringEquals("c,", res[1000].exec("aBBc"), 3087);4731assertNull(res[1000].exec("*** Failers ", 3088));4732assertNull(res[1000].exec("aBC", 3089));4733assertNull(res[1000].exec("aBBC", 3090));4734assertNull(res[1000].exec("", 3091));4735assertToStringEquals("abc,b", res[1000].exec("abcd"), 3092);4736assertNull(res[1000].exec("abCd", 3093));4737assertNull(res[1000].exec("*** Failers", 3094));4738assertNull(res[1000].exec("aBCd", 3095));4739assertToStringEquals("abc,b", res[1000].exec("abcD "), 3096);4740assertNull(res[1000].exec("", 3097));4741assertNull(res[1000].exec("more than million", 3098));4742assertNull(res[1000].exec("more than MILLION", 3099));4743assertNull(res[1000].exec("more \n than Million ", 3100));4744assertNull(res[1000].exec("*** Failers", 3101));4745assertNull(res[1000].exec("MORE THAN MILLION ", 3102));4746assertNull(res[1000].exec("more \n than \n million ", 3103));4747assertNull(res[1000].exec("more than million", 3104));4748assertNull(res[1000].exec("more than MILLION", 3105));4749assertNull(res[1000].exec("more \n than Million ", 3106));4750assertNull(res[1000].exec("*** Failers", 3107));4751assertNull(res[1000].exec("MORE THAN MILLION ", 3108));4752assertNull(res[1000].exec("more \n than \n million ", 3109));4753assertNull(res[1000].exec("", 3110));4754assertToStringEquals("abc,b", res[1000].exec("abc"), 3111);4755assertToStringEquals("bc,b", res[1000].exec("aBbc"), 3112);4756assertToStringEquals("c,", res[1000].exec("aBBc "), 3113);4757assertNull(res[1000].exec("*** Failers", 3114));4758assertToStringEquals("bc,b", res[1000].exec("Abc"), 3115);4759assertNull(res[1000].exec("abAb ", 3116));4760assertNull(res[1000].exec("abbC ", 3117));4761assertNull(res[1000].exec("", 3118));4762assertToStringEquals("abc,b", res[1000].exec("abc"), 3119);4763assertToStringEquals("c,", res[1000].exec("aBc"), 3120);4764assertNull(res[1000].exec("*** Failers", 3121));4765assertNull(res[1000].exec("Ab ", 3122));4766assertNull(res[1000].exec("abC", 3123));4767assertNull(res[1000].exec("aBC ", 3124));4768assertNull(res[1000].exec("", 3125));4769assertToStringEquals("c,", res[1000].exec("abxxc"), 3126);4770assertToStringEquals("c,", res[1000].exec("aBxxc"), 3127);4771assertNull(res[1000].exec("*** Failers", 3128));4772assertToStringEquals("c,", res[1000].exec("Abxxc"), 3129);4773assertToStringEquals("c,", res[1000].exec("ABxxc"), 3130);4774assertNull(res[1000].exec("abxxC ", 3131));4775assertToStringEquals("abc,b", res[1000].exec("abc:"), 3132);4776assertNull(res[1000].exec("12", 3133));4777assertNull(res[1000].exec("*** Failers", 3134));4778assertNull(res[1000].exec("123", 3135));4779assertNull(res[1000].exec("xyz ", 3136));4780assertToStringEquals("abc,b", res[1000].exec("abc:"), 3137);4781assertNull(res[1000].exec("12", 3138));4782assertNull(res[1000].exec("*** Failers", 3139));4783assertNull(res[1000].exec("123", 3140));4784assertNull(res[1000].exec("xyz ", 3141));4785assertNull(res[1000].exec("", 3142));4786assertNull(res[1000].exec("foobar", 3143));4787assertToStringEquals("c,", res[1000].exec("cat"), 3144);4788assertToStringEquals("c,", res[1000].exec("fcat"), 3145);4789assertToStringEquals("c,", res[1000].exec("focat "), 3146);4790assertNull(res[1000].exec("*** Failers", 3147));4791assertToStringEquals("c,", res[1000].exec("foocat "), 3148);4792assertNull(res[1000].exec("foobar", 3149));4793assertToStringEquals("c,", res[1000].exec("cat"), 3150);4794assertToStringEquals("c,", res[1000].exec("fcat"), 3151);4795assertToStringEquals("c,", res[1000].exec("focat "), 3152);4796assertNull(res[1000].exec("*** Failers", 3153));4797assertToStringEquals("c,", res[1000].exec("foocat "), 3154);4798assertNull(res[1000].exec("a", 3155));4799assertNull(res[1000].exec("aa", 3156));4800assertNull(res[1000].exec("aaaa", 3157));4801assertNull(res[1000].exec("", 3158));4802assertToStringEquals("abc,abc", res[1001].exec("abc"), 3159);4803assertToStringEquals("abcabc,abc", res[1001].exec("abcabc"), 3160);4804assertToStringEquals("abcabcabc,abc", res[1001].exec("abcabcabc"), 3161);4805assertToStringEquals(",", res[1001].exec("xyz "), 3162);4806assertToStringEquals("a,a", res[1002].exec("a"), 3163);4807assertToStringEquals("aaaaa,aaaaa", res[1002].exec("aaaaa "), 3164);4808assertToStringEquals("a,a", res[1003].exec("a"), 3165);4809assertToStringEquals("b,b", res[1003].exec("b"), 3166);4810assertToStringEquals("ababab,ababab", res[1003].exec("ababab"), 3167);4811assertToStringEquals("aaaab,aaaab", res[1003].exec("aaaabcde"), 3168);4812assertToStringEquals("bbbb,bbbb", res[1003].exec("bbbb "), 3169);4813assertToStringEquals("b,b", res[1004].exec("b"), 3170);4814assertToStringEquals("bbbb,bbbb", res[1004].exec("bbbb"), 3171);4815assertToStringEquals(",", res[1004].exec("aaa "), 3172);4816assertToStringEquals("cccc,cccc", res[1005].exec("cccc"), 3173);4817assertToStringEquals(",", res[1005].exec("abab "), 3174);4818assertToStringEquals("a,a", res[1006].exec("a"), 3175);4819assertToStringEquals("aaaa,a", res[1006].exec("aaaa "), 3176);4820assertToStringEquals("a,a", res[1007].exec("a"), 3177);4821assertToStringEquals("b,b", res[1007].exec("b"), 3178);4822assertToStringEquals("abab,b", res[1007].exec("abab"), 3179);4823assertToStringEquals("baba,a", res[1007].exec("baba "), 3180);4824assertToStringEquals("b,b", res[1008].exec("b"), 3181);4825assertToStringEquals("bbbb,b", res[1008].exec("bbbb"), 3182);4826assertToStringEquals(",", res[1008].exec("aaa "), 3183);4827assertToStringEquals("c,c", res[1009].exec("c"), 3184);4828assertToStringEquals("cccc,c", res[1009].exec("cccc"), 3185);4829assertToStringEquals(",", res[1009].exec("baba "), 3186);4830assertToStringEquals(",", res[1009].exec("a"), 3187);4831assertToStringEquals(",", res[1009].exec("aaabcde "), 3188);4832assertToStringEquals(",", res[1009].exec("aaaaa"), 3189);4833assertToStringEquals(",", res[1009].exec("aabbaa "), 3190);4834assertToStringEquals(",", res[1009].exec("aaaaa"), 3191);4835assertToStringEquals(",", res[1009].exec("aabbaa "), 3192);4836assertToStringEquals("12-sep-98,8", res[1009].exec("12-sep-98"), 3193);4837assertToStringEquals("12-09-98,8", res[1009].exec("12-09-98"), 3194);4838assertToStringEquals("*** F,F", res[1009].exec("*** Failers"), 3195);4839assertToStringEquals("sep-12-98,8", res[1009].exec("sep-12-98"), 3196);4840assertToStringEquals(" , ", res[1009].exec(" "), 3197);4841assertToStringEquals("s,s", res[1009].exec("saturday"), 3198);4842assertToStringEquals("sund,d", res[1009].exec("sunday"), 3199);4843assertToStringEquals("S,S", res[1009].exec("Saturday"), 3200);4844assertToStringEquals("Sund,d", res[1009].exec("Sunday"), 3201);4845assertToStringEquals("SATURDAY,Y", res[1009].exec("SATURDAY"), 3202);4846assertToStringEquals("SUNDAY,Y", res[1009].exec("SUNDAY"), 3203);4847assertToStringEquals("SunD,D", res[1009].exec("SunDay"), 3204);4848assertToStringEquals(",", res[1009].exec("abcx"), 3205);4849assertToStringEquals(",", res[1009].exec("aBCx"), 3206);4850assertToStringEquals(",", res[1009].exec("bbx"), 3207);4851assertToStringEquals("BBx,x", res[1009].exec("BBx"), 3208);4852assertToStringEquals("*** F,F", res[1009].exec("*** Failers"), 3209);4853assertToStringEquals(",", res[1009].exec("abcX"), 3210);4854assertToStringEquals(",", res[1009].exec("aBCX"), 3211);4855assertToStringEquals(",", res[1009].exec("bbX"), 3212);4856assertToStringEquals("BBX , ", res[1009].exec("BBX "), 3213);4857assertToStringEquals(",", res[1009].exec("ac"), 3214);4858assertToStringEquals(",", res[1009].exec("aC"), 3215);4859assertToStringEquals(",", res[1009].exec("bD"), 3216);4860assertToStringEquals("eleph,h", res[1009].exec("elephant"), 3217);4861assertToStringEquals("Europe , ", res[1009].exec("Europe "), 3218);4862assertToStringEquals("frog,g", res[1009].exec("frog"), 3219);4863assertToStringEquals("Fr,r", res[1009].exec("France"), 3220);4864assertToStringEquals("*** F,F", res[1009].exec("*** Failers"), 3221);4865assertToStringEquals("Afric,c", res[1009].exec("Africa "), 3222);4866assertToStringEquals(",", res[1009].exec("ab"), 3223);4867assertToStringEquals(",", res[1009].exec("aBd"), 3224);4868assertToStringEquals("xy,y", res[1009].exec("xy"), 3225);4869assertToStringEquals("xY,Y", res[1009].exec("xY"), 3226);4870assertToStringEquals("ze,e", res[1009].exec("zebra"), 3227);4871assertToStringEquals("Z,Z", res[1009].exec("Zambesi"), 3228);4872assertToStringEquals("*** F,F", res[1009].exec("*** Failers"), 3229);4873assertToStringEquals(",", res[1009].exec("aCD "), 3230);4874assertToStringEquals("XY , ", res[1009].exec("XY "), 3231);4875assertToStringEquals("foo\n,\n", res[1009].exec("foo\nbar"), 3232);4876assertToStringEquals("*** F,F", res[1009].exec("*** Failers"), 3233);4877assertToStringEquals(",", res[1009].exec("bar"), 3234);4878assertToStringEquals(",", res[1009].exec("baz\nbar "), 3235);4879assertToStringEquals(",", res[1009].exec("barbaz"), 3236);4880assertToStringEquals(",", res[1009].exec("barbarbaz "), 3237);4881assertToStringEquals("koo,o", res[1009].exec("koobarbaz "), 3238);4882assertToStringEquals("*** F,F", res[1009].exec("*** Failers"), 3239);4883assertToStringEquals(",", res[1009].exec("baz"), 3240);4884assertToStringEquals("foo,o", res[1009].exec("foobarbaz "), 3241);4885assertToStringEquals("abc", res[1012].exec("abc"), 3242);4886assertToStringEquals("abc", res[1012].exec("xabcy"), 3243);4887assertToStringEquals("abc", res[1012].exec("ababc"), 3244);4888assertNull(res[1012].exec("*** Failers", 3245));4889assertNull(res[1012].exec("xbc", 3246));4890assertNull(res[1012].exec("axc", 3247));4891assertNull(res[1012].exec("abx", 3248));4892assertToStringEquals("abc", res[1013].exec("abc"), 3249);4893assertToStringEquals("abc", res[1014].exec("abc"), 3250);4894assertToStringEquals("abbc", res[1014].exec("abbc"), 3251);4895assertToStringEquals("abbbbc", res[1014].exec("abbbbc"), 3252);4896assertToStringEquals("a", res[1015].exec("abbbbc"), 3253);4897assertToStringEquals("abbb", res[1016].exec("abbbbc"), 3254);4898assertToStringEquals("abbbbc", res[1017].exec("abbbbc"), 3255);4899assertToStringEquals("abbc", res[1018].exec("abbc"), 3256);4900assertNull(res[1018].exec("*** Failers", 3257));4901assertNull(res[1018].exec("abc", 3258));4902assertNull(res[1018].exec("abq", 3259));4903assertToStringEquals("abbbbc", res[1020].exec("abbbbc"), 3260);4904assertToStringEquals("abbbbc", res[1021].exec("abbbbc"), 3261);4905assertToStringEquals("abbbbc", res[1022].exec("abbbbc"), 3262);4906assertToStringEquals("abbbbc", res[1023].exec("abbbbc"), 3263);4907assertNull(res[1024].exec("*** Failers", 3264));4908assertNull(res[1024].exec("abq", 3265));4909assertNull(res[1024].exec("abbbbc", 3266));4910assertToStringEquals("abbc", res[1025].exec("abbc"), 3267);4911assertToStringEquals("abc", res[1025].exec("abc"), 3268);4912assertToStringEquals("abc", res[1026].exec("abc"), 3269);4913assertToStringEquals("abc", res[1028].exec("abc"), 3270);4914assertToStringEquals("abc", res[1029].exec("abc"), 3271);4915assertToStringEquals("abc", res[1030].exec("abc"), 3272);4916assertNull(res[1030].exec("*** Failers", 3273));4917assertNull(res[1030].exec("abbbbc", 3274));4918assertNull(res[1030].exec("abcc", 3275));4919assertToStringEquals("abc", res[1031].exec("abcc"), 3276);4920assertToStringEquals("abc", res[1033].exec("aabc"), 3277);4921assertNull(res[1033].exec("*** Failers", 3278));4922assertToStringEquals("abc", res[1033].exec("aabc"), 3279);4923assertNull(res[1033].exec("aabcd", 3280));4924assertToStringEquals("", res[1034].exec("abc"), 3281);4925assertToStringEquals("", res[1035].exec("abc"), 3282);4926assertToStringEquals("abc", res[1036].exec("abc"), 3283);4927assertToStringEquals("axc", res[1036].exec("axc"), 3284);4928assertToStringEquals("axyzc", res[1037].exec("axyzc"), 3285);4929assertToStringEquals("abd", res[1038].exec("abd"), 3286);4930assertNull(res[1038].exec("*** Failers", 3287));4931assertNull(res[1038].exec("axyzd", 3288));4932assertNull(res[1038].exec("abc", 3289));4933assertToStringEquals("ace", res[1039].exec("ace"), 3290);4934assertToStringEquals("ac", res[1040].exec("aac"), 3291);4935assertToStringEquals("a-", res[1041].exec("a-"), 3292);4936assertToStringEquals("a-", res[1042].exec("a-"), 3293);4937assertToStringEquals("a]", res[1043].exec("a]"), 3294);4938assertNull(res[1044].exec("a]b", 3295));4939assertToStringEquals("aed", res[1045].exec("aed"), 3296);4940assertNull(res[1045].exec("*** Failers", 3297));4941assertNull(res[1045].exec("abd", 3298));4942assertNull(res[1045].exec("abd", 3299));4943assertToStringEquals("adc", res[1046].exec("adc"), 3300);4944assertNull(res[1047].exec("adc", 3301));4945assertNull(res[1047].exec("*** Failers", 3302));4946assertNull(res[1047].exec("a-c", 3303));4947assertNull(res[1047].exec("a]c", 3304));4948assertToStringEquals("a", res[1048].exec("a-"), 3305);4949assertToStringEquals("a", res[1048].exec("-a"), 3306);4950assertToStringEquals("a", res[1048].exec("-a-"), 3307);4951assertNull(res[1049].exec("*** Failers", 3308));4952assertNull(res[1049].exec("xy", 3309));4953assertNull(res[1049].exec("yz", 3310));4954assertNull(res[1049].exec("xyz", 3311));4955assertToStringEquals("a", res[1050].exec("*** Failers"), 3312);4956assertNull(res[1050].exec("a-", 3313));4957assertNull(res[1050].exec("-a", 3314));4958assertNull(res[1050].exec("-a-", 3315));4959assertToStringEquals("y", res[1051].exec("xy"), 3316);4960assertToStringEquals("y", res[1052].exec("yz"), 3317);4961assertToStringEquals("y", res[1053].exec("xyz"), 3318);4962assertToStringEquals("a", res[1054].exec("a"), 3319);4963assertToStringEquals("-", res[1055].exec("-"), 3320);4964assertToStringEquals("*", res[1055].exec("*** Failers"), 3321);4965assertToStringEquals("-", res[1055].exec("-"), 3322);4966assertNull(res[1055].exec("a", 3323));4967assertToStringEquals("a b", res[1056].exec("a b"), 3324);4968assertToStringEquals("a-b", res[1057].exec("a-b"), 3325);4969assertNull(res[1057].exec("*** Failers", 3326));4970assertToStringEquals("a-b", res[1057].exec("a-b"), 3327);4971assertNull(res[1057].exec("a b", 3328));4972assertToStringEquals("1", res[1058].exec("1"), 3329);4973assertToStringEquals("-", res[1059].exec("-"), 3330);4974assertToStringEquals("*", res[1059].exec("*** Failers"), 3331);4975assertToStringEquals("-", res[1059].exec("-"), 3332);4976assertNull(res[1059].exec("1", 3333));4977assertToStringEquals("a", res[1060].exec("a"), 3334);4978assertToStringEquals("-", res[1061].exec("-"), 3335);4979assertToStringEquals("*", res[1061].exec("*** Failers"), 3336);4980assertToStringEquals("-", res[1061].exec("-"), 3337);4981assertNull(res[1061].exec("a", 3338));4982assertToStringEquals("a b", res[1062].exec("a b"), 3339);4983assertToStringEquals("a-b", res[1063].exec("a-b"), 3340);4984assertNull(res[1063].exec("*** Failers", 3341));4985assertToStringEquals("a-b", res[1063].exec("a-b"), 3342);4986assertNull(res[1063].exec("a b", 3343));4987assertToStringEquals("1", res[1064].exec("1"), 3344);4988assertToStringEquals("-", res[1065].exec("-"), 3345);4989assertToStringEquals("*", res[1065].exec("*** Failers"), 3346);4990assertToStringEquals("-", res[1065].exec("-"), 3347);4991assertNull(res[1065].exec("1", 3348));4992assertToStringEquals("ab", res[1066].exec("abc"), 3349);4993assertToStringEquals("ab", res[1066].exec("abcd"), 3350);4994assertToStringEquals("ef,", res[1067].exec("def"), 3351);4995assertToStringEquals("a(b", res[1069].exec("a(b"), 3352);4996assertNull(res[1069].exec("ab", 3353));4997assertNull(res[1069].exec("a((b", 3354));4998assertNull(res[1070].exec("a\x08", 3355));4999assertToStringEquals("a,a,a", res[1071].exec("abc"), 3356);5000assertToStringEquals("abc,a,c", res[1072].exec("abc"), 3357);5001assertToStringEquals("abc", res[1073].exec("aabbabc"), 3358);5002assertToStringEquals("abc", res[1074].exec("aabbabc"), 3359);5003assertToStringEquals("abc", res[1075].exec("abcabc"), 3360);5004assertToStringEquals("ab,b", res[1076].exec("ab"), 3361);5005assertToStringEquals("ab,b", res[1077].exec("ab"), 3362);5006assertToStringEquals("ab,b", res[1078].exec("ab"), 3363);5007assertToStringEquals("ab,b", res[1079].exec("ab"), 3364);5008assertToStringEquals("a,a", res[1080].exec("ab"), 3365);5009assertToStringEquals("a,a", res[1081].exec("ab"), 3366);5010assertToStringEquals("cde", res[1082].exec("cde"), 3367);5011assertNull(res[1083].exec("*** Failers", 3368));5012assertNull(res[1083].exec("b", 3369));5013assertToStringEquals("abbbcd,c", res[1085].exec("abbbcd"), 3370);5014assertToStringEquals("abcd,a", res[1086].exec("abcd"), 3371);5015assertToStringEquals("e", res[1087].exec("e"), 3372);5016assertToStringEquals("ef,e", res[1088].exec("ef"), 3373);5017assertToStringEquals("abcdefg", res[1089].exec("abcdefg"), 3374);5018assertToStringEquals("ab", res[1090].exec("xabyabbbz"), 3375);5019assertToStringEquals("a", res[1090].exec("xayabbbz"), 3376);5020assertToStringEquals("cde,cd", res[1091].exec("abcde"), 3377);5021assertToStringEquals("hij", res[1092].exec("hij"), 3378);5022assertToStringEquals("ef,", res[1094].exec("abcdef"), 3379);5023assertToStringEquals("bcd,b", res[1095].exec("abcd"), 3380);5024assertToStringEquals("abc,a", res[1096].exec("abc"), 3381);5025assertToStringEquals("abc,bc", res[1097].exec("abc"), 3382);5026assertToStringEquals("abcd,bc,d", res[1098].exec("abcd"), 3383);5027assertToStringEquals("abcd,bc,d", res[1099].exec("abcd"), 3384);5028assertToStringEquals("abcd,b,cd", res[1100].exec("abcd"), 3385);5029assertToStringEquals("adcdcde", res[1101].exec("adcdcde"), 3386);5030assertNull(res[1102].exec("*** Failers", 3387));5031assertNull(res[1102].exec("abcde", 3388));5032assertNull(res[1102].exec("adcdcde", 3389));5033assertToStringEquals("abc,ab", res[1103].exec("abc"), 3390);5034assertToStringEquals("abcd,abc,a,b,d", res[1104].exec("abcd"), 3391);5035assertToStringEquals("alpha", res[1105].exec("alpha"), 3392);5036assertToStringEquals("bh,", res[1106].exec("abh"), 3393);5037assertToStringEquals("effgz,effgz,", res[1107].exec("effgz"), 3394);5038assertToStringEquals("ij,ij,j", res[1107].exec("ij"), 3395);5039assertToStringEquals("effgz,effgz,", res[1107].exec("reffgz"), 3396);5040assertNull(res[1107].exec("*** Failers", 3397));5041assertNull(res[1107].exec("effg", 3398));5042assertNull(res[1107].exec("bcdd", 3399));5043assertToStringEquals("a,a,a,a,a,a,a,a,a,a,a", res[1108].exec("a"), 3400);5044assertToStringEquals("a,a,a,a,a,a,a,a,a,a", res[1109].exec("a"), 3401);5045assertNull(res[1110].exec("*** Failers", 3402));5046assertNull(res[1110].exec("aa", 3403));5047assertNull(res[1110].exec("uh-uh", 3404));5048assertToStringEquals("multiple words", res[1111].exec("multiple words, yeah"), 3405);5049assertToStringEquals("abcde,ab,de", res[1112].exec("abcde"), 3406);5050assertToStringEquals("(a, b),a,b", res[1113].exec("(a, b)"), 3407);5051assertToStringEquals("abcd", res[1115].exec("abcd"), 3408);5052assertToStringEquals("abcd,bc", res[1116].exec("abcd"), 3409);5053assertToStringEquals("ac", res[1117].exec("ac"), 3410);5054assertToStringEquals("ABC", res[1118].exec("ABC"), 3411);5055assertToStringEquals("ABC", res[1118].exec("XABCY"), 3412);5056assertToStringEquals("ABC", res[1118].exec("ABABC"), 3413);5057assertNull(res[1118].exec("*** Failers", 3414));5058assertNull(res[1118].exec("aaxabxbaxbbx", 3415));5059assertNull(res[1118].exec("XBC", 3416));5060assertNull(res[1118].exec("AXC", 3417));5061assertNull(res[1118].exec("ABX", 3418));5062assertToStringEquals("ABC", res[1119].exec("ABC"), 3419);5063assertToStringEquals("ABC", res[1120].exec("ABC"), 3420);5064assertToStringEquals("ABBC", res[1120].exec("ABBC"), 3421);5065assertToStringEquals("ABBBBC", res[1121].exec("ABBBBC"), 3422);5066assertToStringEquals("ABBBBC", res[1122].exec("ABBBBC"), 3423);5067assertToStringEquals("ABBC", res[1123].exec("ABBC"), 3424);5068assertNull(res[1124].exec("*** Failers", 3425));5069assertNull(res[1124].exec("ABC", 3426));5070assertNull(res[1124].exec("ABQ", 3427));5071assertToStringEquals("ABBBBC", res[1126].exec("ABBBBC"), 3428);5072assertToStringEquals("ABBBBC", res[1127].exec("ABBBBC"), 3429);5073assertToStringEquals("ABBBBC", res[1128].exec("ABBBBC"), 3430);5074assertToStringEquals("ABBBBC", res[1129].exec("ABBBBC"), 3431);5075assertNull(res[1130].exec("*** Failers", 3432));5076assertNull(res[1130].exec("ABQ", 3433));5077assertNull(res[1130].exec("ABBBBC", 3434));5078assertToStringEquals("ABBC", res[1131].exec("ABBC"), 3435);5079assertToStringEquals("ABC", res[1131].exec("ABC"), 3436);5080assertToStringEquals("ABC", res[1132].exec("ABC"), 3437);5081assertToStringEquals("ABC", res[1134].exec("ABC"), 3438);5082assertToStringEquals("ABC", res[1135].exec("ABC"), 3439);5083assertToStringEquals("ABC", res[1136].exec("ABC"), 3440);5084assertNull(res[1136].exec("*** Failers", 3441));5085assertNull(res[1136].exec("ABBBBC", 3442));5086assertNull(res[1136].exec("ABCC", 3443));5087assertToStringEquals("ABC", res[1137].exec("ABCC"), 3444);5088assertToStringEquals("ABC", res[1139].exec("AABC"), 3445);5089assertToStringEquals("", res[1140].exec("ABC"), 3446);5090assertToStringEquals("", res[1141].exec("ABC"), 3447);5091assertToStringEquals("ABC", res[1142].exec("ABC"), 3448);5092assertToStringEquals("AXC", res[1142].exec("AXC"), 3449);5093assertToStringEquals("AXYZC", res[1143].exec("AXYZC"), 3450);5094assertNull(res[1144].exec("*** Failers", 3451));5095assertToStringEquals("AABC", res[1144].exec("AABC"), 3452);5096assertNull(res[1144].exec("AXYZD", 3453));5097assertToStringEquals("ABD", res[1145].exec("ABD"), 3454);5098assertToStringEquals("ACE", res[1146].exec("ACE"), 3455);5099assertNull(res[1146].exec("*** Failers", 3456));5100assertNull(res[1146].exec("ABC", 3457));5101assertNull(res[1146].exec("ABD", 3458));5102assertToStringEquals("AC", res[1147].exec("AAC"), 3459);5103assertToStringEquals("A-", res[1148].exec("A-"), 3460);5104assertToStringEquals("A-", res[1149].exec("A-"), 3461);5105assertToStringEquals("A]", res[1150].exec("A]"), 3462);5106assertNull(res[1151].exec("A]B", 3463));5107assertToStringEquals("AED", res[1152].exec("AED"), 3464);5108assertToStringEquals("ADC", res[1153].exec("ADC"), 3465);5109assertNull(res[1153].exec("*** Failers", 3466));5110assertNull(res[1153].exec("ABD", 3467));5111assertNull(res[1153].exec("A-C", 3468));5112assertNull(res[1154].exec("ADC", 3469));5113assertToStringEquals("AB", res[1155].exec("ABC"), 3470);5114assertToStringEquals("AB", res[1155].exec("ABCD"), 3471);5115assertToStringEquals("EF,", res[1156].exec("DEF"), 3472);5116assertNull(res[1157].exec("*** Failers", 3473));5117assertNull(res[1157].exec("A]C", 3474));5118assertNull(res[1157].exec("B", 3475));5119assertToStringEquals("A(B", res[1158].exec("A(B"), 3476);5120assertNull(res[1158].exec("AB", 3477));5121assertNull(res[1158].exec("A((B", 3478));5122assertNull(res[1159].exec("AB", 3479));5123assertToStringEquals("A,A,A", res[1160].exec("ABC"), 3480);5124assertToStringEquals("ABC,A,C", res[1161].exec("ABC"), 3481);5125assertToStringEquals("ABC", res[1162].exec("AABBABC"), 3482);5126assertToStringEquals("ABC", res[1163].exec("AABBABC"), 3483);5127assertToStringEquals("ABC", res[1164].exec("ABCABC"), 3484);5128assertToStringEquals("ABC", res[1165].exec("ABCABC"), 3485);5129assertToStringEquals("ABC", res[1166].exec("ABCABC"), 3486);5130assertToStringEquals("AB,B", res[1167].exec("AB"), 3487);5131assertToStringEquals("AB,B", res[1168].exec("AB"), 3488);5132assertToStringEquals("AB,B", res[1169].exec("AB"), 3489);5133assertToStringEquals("AB,B", res[1170].exec("AB"), 3490);5134assertToStringEquals("A,A", res[1171].exec("AB"), 3491);5135assertToStringEquals("A,A", res[1172].exec("AB"), 3492);5136assertToStringEquals(",", res[1173].exec("AB"), 3493);5137assertToStringEquals("CDE", res[1174].exec("CDE"), 3494);5138assertToStringEquals("ABBBCD,C", res[1177].exec("ABBBCD"), 3495);5139assertToStringEquals("ABCD,A", res[1178].exec("ABCD"), 3496);5140assertToStringEquals("E", res[1179].exec("E"), 3497);5141assertToStringEquals("EF,E", res[1180].exec("EF"), 3498);5142assertToStringEquals("ABCDEFG", res[1181].exec("ABCDEFG"), 3499);5143assertToStringEquals("AB", res[1182].exec("XABYABBBZ"), 3500);5144assertToStringEquals("A", res[1182].exec("XAYABBBZ"), 3501);5145assertToStringEquals("CDE,CD", res[1183].exec("ABCDE"), 3502);5146assertToStringEquals("HIJ", res[1184].exec("HIJ"), 3503);5147assertNull(res[1185].exec("ABCDE", 3504));5148assertToStringEquals("EF,", res[1186].exec("ABCDEF"), 3505);5149assertToStringEquals("BCD,B", res[1187].exec("ABCD"), 3506);5150assertToStringEquals("ABC,A", res[1188].exec("ABC"), 3507);5151assertToStringEquals("ABC,BC", res[1189].exec("ABC"), 3508);5152assertToStringEquals("ABCD,BC,D", res[1190].exec("ABCD"), 3509);5153assertToStringEquals("ABCD,BC,D", res[1191].exec("ABCD"), 3510);5154assertToStringEquals("ABCD,B,CD", res[1192].exec("ABCD"), 3511);5155assertToStringEquals("ADCDCDE", res[1193].exec("ADCDCDE"), 3512);5156assertToStringEquals("ABC,AB", res[1195].exec("ABC"), 3513);5157assertToStringEquals("ABCD,ABC,A,B,D", res[1196].exec("ABCD"), 3514);5158assertToStringEquals("ALPHA", res[1197].exec("ALPHA"), 3515);5159assertToStringEquals("BH,", res[1198].exec("ABH"), 3516);5160assertToStringEquals("EFFGZ,EFFGZ,", res[1199].exec("EFFGZ"), 3517);5161assertToStringEquals("IJ,IJ,J", res[1199].exec("IJ"), 3518);5162assertToStringEquals("EFFGZ,EFFGZ,", res[1199].exec("REFFGZ"), 3519);5163assertNull(res[1199].exec("*** Failers", 3520));5164assertNull(res[1199].exec("ADCDCDE", 3521));5165assertNull(res[1199].exec("EFFG", 3522));5166assertNull(res[1199].exec("BCDD", 3523));5167assertToStringEquals("A,A,A,A,A,A,A,A,A,A,A", res[1200].exec("A"), 3524);5168assertToStringEquals("A,A,A,A,A,A,A,A,A,A", res[1201].exec("A"), 3525);5169assertToStringEquals("A,A", res[1202].exec("A"), 3526);5170assertToStringEquals("C,C", res[1203].exec("C"), 3527);5171assertNull(res[1204].exec("*** Failers", 3528));5172assertNull(res[1204].exec("AA", 3529));5173assertNull(res[1204].exec("UH-UH", 3530));5174assertToStringEquals("MULTIPLE WORDS", res[1205].exec("MULTIPLE WORDS, YEAH"), 3531);5175assertToStringEquals("ABCDE,AB,DE", res[1206].exec("ABCDE"), 3532);5176assertToStringEquals("(A, B),A,B", res[1207].exec("(A, B)"), 3533);5177assertToStringEquals("ABCD", res[1209].exec("ABCD"), 3534);5178assertToStringEquals("ABCD,BC", res[1210].exec("ABCD"), 3535);5179assertToStringEquals("AC", res[1211].exec("AC"), 3536);5180assertToStringEquals("ad", res[1212].exec("abad"), 3537);5181assertToStringEquals("ad", res[1213].exec("abad"), 3538);5182assertToStringEquals("ad", res[1214].exec("abad"), 3539);5183assertToStringEquals("ace,e", res[1215].exec("ace"), 3540);5184assertToStringEquals("ace,e", res[1216].exec("ace"), 3541);5185assertToStringEquals("ace,e", res[1217].exec("ace"), 3542);5186assertToStringEquals("acd,d", res[1217].exec("acdbcdbe"), 3543);5187assertToStringEquals("acdbcdbe,e", res[1218].exec("acdbcdbe"), 3544);5188assertToStringEquals("acdb,b", res[1219].exec("acdbcdbe"), 3545);5189assertToStringEquals("acdbcdb,b", res[1220].exec("acdbcdbe"), 3546);5190assertToStringEquals("acdbcd,d", res[1221].exec("acdbcdbe"), 3547);5191assertToStringEquals("foobar,bar,,bar", res[1222].exec("foobar"), 3548);5192assertToStringEquals("acdbcdbe,e", res[1223].exec("acdbcdbe"), 3549);5193assertToStringEquals("acdbcdbe,e", res[1224].exec("acdbcdbe"), 3550);5194assertToStringEquals("acdbcdbe,e", res[1225].exec("acdbcdbe"), 3551);5195assertToStringEquals("acdbcdb,b", res[1226].exec("acdbcdbe"), 3552);5196assertToStringEquals("acdbcdbe,e", res[1227].exec("acdbcdbe"), 3553);5197assertToStringEquals("acdbcdb,b", res[1228].exec("acdbcdbe"), 3554);5198assertToStringEquals("ace,c,e", res[1229].exec("ace"), 3555);5199assertToStringEquals("AB,A", res[1230].exec("AB"), 3556);5200assertToStringEquals(".,.,", res[1231].exec("."), 3557);5201assertToStringEquals("<&", res[1232].exec("<&OUT"), 3558);5202assertToStringEquals("foobar,,,,b,a,r", res[1233].exec("foobar"), 3559);5203assertToStringEquals(",,,,,,", res[1233].exec("ab"), 3560);5204assertToStringEquals(",,,,,,", res[1233].exec("*** Failers"), 3561);5205assertToStringEquals(",,,,,,", res[1233].exec("cb"), 3562);5206assertToStringEquals(",,,,,,", res[1233].exec("b"), 3563);5207assertToStringEquals(",,,,,,", res[1233].exec("ab"), 3564);5208assertToStringEquals(",,,,,,", res[1233].exec("b"), 3565);5209assertToStringEquals(",,,,,,", res[1233].exec("b"), 3566);5210assertToStringEquals("aba", res[1234].exec("aba"), 3567);5211assertToStringEquals("a", res[1235].exec("aba"), 3568);5212assertToStringEquals(",", res[1236].exec("abc"), 3569);5213assertToStringEquals("aax,a", res[1237].exec("aax"), 3570);5214assertToStringEquals("aax,a,a", res[1238].exec("aax"), 3571);5215assertToStringEquals("aax,a,a", res[1239].exec("aax"), 3572);5216assertToStringEquals("ab,", res[1240].exec("cab"), 3573);5217assertToStringEquals("ab,", res[1241].exec("cab"), 3574);5218assertToStringEquals("ab,", res[1241].exec("ab"), 3575);5219assertToStringEquals("ab,", res[1241].exec("ab"), 3576);5220assertNull(res[1241].exec("Ab", 3577));5221assertNull(res[1241].exec("Ab", 3578));5222assertNull(res[1241].exec("*** Failers", 3579));5223assertNull(res[1241].exec("cb", 3580));5224assertNull(res[1241].exec("aB", 3581));5225assertToStringEquals("ab,", res[1241].exec("ab"), 3582);5226assertToStringEquals("ab,", res[1241].exec("ab"), 3583);5227assertNull(res[1241].exec("Ab", 3584));5228assertNull(res[1241].exec("Ab", 3585));5229assertNull(res[1241].exec("*** Failers", 3586));5230assertNull(res[1241].exec("aB", 3587));5231assertNull(res[1241].exec("aB", 3588));5232assertToStringEquals("ab,", res[1241].exec("ab"), 3589);5233assertToStringEquals("ab,", res[1241].exec("ab"), 3590);5234assertNull(res[1241].exec("aB", 3591));5235assertNull(res[1241].exec("aB", 3592));5236assertNull(res[1241].exec("*** Failers", 3593));5237assertNull(res[1241].exec("aB", 3594));5238assertNull(res[1241].exec("Ab", 3595));5239assertNull(res[1241].exec("aB", 3596));5240assertNull(res[1241].exec("aB", 3597));5241assertNull(res[1241].exec("*** Failers", 3598));5242assertNull(res[1241].exec("Ab", 3599));5243assertNull(res[1241].exec("AB", 3600));5244assertToStringEquals("ab,", res[1241].exec("ab"), 3601);5245assertToStringEquals("ab,", res[1241].exec("ab"), 3602);5246assertNull(res[1241].exec("aB", 3603));5247assertNull(res[1241].exec("aB", 3604));5248assertNull(res[1241].exec("*** Failers", 3605));5249assertNull(res[1241].exec("AB", 3606));5250assertNull(res[1241].exec("Ab", 3607));5251assertNull(res[1241].exec("aB", 3608));5252assertNull(res[1241].exec("aB", 3609));5253assertNull(res[1241].exec("*** Failers", 3610));5254assertNull(res[1241].exec("Ab", 3611));5255assertNull(res[1241].exec("AB", 3612));5256assertNull(res[1241].exec("*** Failers", 3613));5257assertNull(res[1241].exec("AB", 3614));5258assertNull(res[1241].exec("a\nB", 3615));5259assertNull(res[1241].exec("a\nB", 3616));5260assertToStringEquals("cabbbb", res[1242].exec("cabbbb"), 3617);5261assertToStringEquals("caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", res[1243].exec("caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"), 3618);5262assertToStringEquals("foobar1234baz", res[1244].exec("foobar1234baz"), 3619);5263assertToStringEquals("x~~,~~", res[1245].exec("x~~"), 3620);5264assertToStringEquals("aaac", res[1246].exec("aaac"), 3621);5265assertToStringEquals("aaac", res[1247].exec("aaac"), 3622);5266assertNull(res[1247].exec("*** Failers", 3623));5267assertNull(res[1247].exec("B\nB", 3624));5268assertNull(res[1247].exec("dbcb", 3625));5269assertNull(res[1247].exec("dbaacb", 3626));5270assertNull(res[1247].exec("dbaacb", 3627));5271assertNull(res[1247].exec("cdaccb", 3628));5272assertNull(res[1248].exec("*** Failers", 3629));5273assertNull(res[1248].exec("dbcb", 3630));5274assertNull(res[1248].exec("a--", 3631));5275assertNull(res[1248].exec("a\nb\nc\n", 3632));5276assertNull(res[1248].exec("a\nb\nc\n", 3633));5277assertNull(res[1248].exec("a\nb\n", 3634));5278assertNull(res[1248].exec("a\nb\n", 3635));5279assertNull(res[1248].exec("a\nb\n", 3636));5280assertNull(res[1248].exec("a\nb\n", 3637));5281assertNull(res[1248].exec("a\nb\nc\n", 3638));5282assertNull(res[1248].exec("a\nb\nc\n", 3639));5283assertNull(res[1248].exec("a\nb\nc\n", 3640));5284assertNull(res[1248].exec("a\nb\nc\n", 3641));5285assertNull(res[1250].exec("*** Failers", 3642));5286assertNull(res[1250].exec("a\nb\nc\n", 3643));5287assertNull(res[1250].exec("a\nb\nc\n", 3644));5288assertNull(res[1250].exec("a\nb\nc\n", 3645));5289assertNull(res[1250].exec("a", 3646));5290assertNull(res[1250].exec("*** Failers", 3647));5291assertNull(res[1250].exec("a", 3648));5292assertNull(res[1250].exec("a", 3649));5293assertNull(res[1250].exec("a", 3650));5294assertToStringEquals("one:,one:", res[1251].exec("one:"), 3651);5295assertNull(res[1251].exec("a", 3652));5296assertToStringEquals("abcd,,abcd", res[1252].exec("abcd"), 3653);5297assertToStringEquals("xy:z:::abcd,xy:z:::,abcd", res[1252].exec("xy:z:::abcd"), 3654);5298assertToStringEquals("aexyc,c", res[1253].exec("aexycd"), 3655);5299assertToStringEquals("aab,aa", res[1254].exec("caab"), 3656);5300assertToStringEquals("abcd,,abcd", res[1255].exec("abcd"), 3657);5301assertToStringEquals("xy:z:::abcd,xy:z:::,abcd", res[1255].exec("xy:z:::abcd"), 3658);5302assertToStringEquals("Failers,,Failers", res[1255].exec("*** Failers"), 3659);5303assertNull(res[1255].exec("abcd:", 3660));5304assertNull(res[1255].exec("abcd:", 3661));5305assertToStringEquals("aexyc,c", res[1256].exec("aexycd"), 3662);5306assertNull(res[1257].exec("aaab", 3663));5307assertToStringEquals(":[,:[", res[1258].exec("a:[b]:"), 3664);5308assertToStringEquals("=[,=[", res[1259].exec("a=[b]="), 3665);5309assertToStringEquals(".[,.[", res[1260].exec("a.[b]."), 3666);5310assertNull(res[1260].exec("aaab", 3667));5311assertNull(res[1260].exec("aaab", 3668));5312assertNull(res[1260].exec("((abc(ade)ufh()()x", 3669));5313assertNull(res[1261].exec("*** Failers", 3670));5314assertNull(res[1261].exec("aaab", 3671));5315assertNull(res[1261].exec("a\nb\n", 3672));5316assertNull(res[1262].exec("a\nb\n", 3673));5317assertNull(res[1264].exec("a\nb", 3674));5318assertNull(res[1265].exec("a\nb", 3675));5319assertNull(res[1265].exec("*** Failers", 3676));5320assertNull(res[1265].exec("alphabetabcd", 3677));5321assertNull(res[1265].exec("endingwxyz", 3678));5322assertNull(res[1265].exec("*** Failers", 3679));5323assertNull(res[1265].exec("a rather long string that doesn't end with one of them", 3680));5324assertNull(res[1265].exec("word cat dog elephant mussel cow horse canary baboon snake shark otherword", 3681));5325assertNull(res[1265].exec("word cat dog elephant mussel cow horse canary baboon snake shark", 3682));5326assertNull(res[1265].exec("word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope", 3683));5327assertNull(res[1265].exec("999foo", 3684));5328assertNull(res[1265].exec("123999foo ", 3685));5329assertNull(res[1265].exec("*** Failers", 3686));5330assertNull(res[1265].exec("123abcfoo", 3687));5331assertNull(res[1265].exec("999foo", 3688));5332assertNull(res[1265].exec("123999foo ", 3689));5333assertNull(res[1265].exec("*** Failers", 3690));5334assertNull(res[1265].exec("123abcfoo", 3691));5335assertNull(res[1265].exec("123abcfoo", 3692));5336assertNull(res[1265].exec("123456foo ", 3693));5337assertNull(res[1265].exec("*** Failers", 3694));5338assertNull(res[1265].exec("123999foo ", 3695));5339assertNull(res[1265].exec("123abcfoo ", 3696));5340assertNull(res[1265].exec("123456foo ", 3697));5341assertNull(res[1265].exec("*** Failers", 3698));5342assertNull(res[1265].exec("123999foo ", 3699));5343assertToStringEquals("ZA,A,", res[1266].exec("ZABCDEFG"), 3700);5344assertToStringEquals("ZA,A,", res[1267].exec("ZABCDEFG"), 3701);5345assertToStringEquals("ZA,A,,", res[1268].exec("ZABCDEFG"), 3702);5346assertToStringEquals("ZA,A,,", res[1268].exec("ZABCDEFG"), 3703);5347assertToStringEquals("ZA,A,,", res[1268].exec("ZABCDEFG"), 3704);5348assertToStringEquals("a", res[1269].exec("abbab"), 3705);5349assertToStringEquals("", res[1269].exec("abcde"), 3706);5350assertToStringEquals("", res[1269].exec("-things"), 3707);5351assertToStringEquals("", res[1269].exec("0digit"), 3708);5352assertToStringEquals("", res[1269].exec("*** Failers"), 3709);5353assertToStringEquals("", res[1269].exec("bcdef "), 3710);5354assertToStringEquals("a", res[1270].exec("abcde"), 3711);5355assertToStringEquals("-", res[1270].exec("-things"), 3712);5356assertToStringEquals("0", res[1270].exec("0digit"), 3713);5357assertNull(res[1270].exec("*** Failers", 3714));5358assertNull(res[1270].exec("bcdef ", 3715));5359assertNull(res[1271].exec("> \x09\n\x0c\x0d\x0b<", 3716));5360assertNull(res[1271].exec(" ", 3717));5361assertNull(res[1272].exec("> \x09\n\x0c\x0d\x0b<", 3718));5362assertNull(res[1272].exec(" ", 3719));5363assertToStringEquals(" \x09\n\x0c\x0d\x0b", res[1273].exec("> \x09\n\x0c\x0d\x0b<"), 3720);5364assertToStringEquals(" ", res[1273].exec(" "), 3721);5365assertToStringEquals(" \x09\n\x0c\x0d\x0b", res[1274].exec("> \x09\n\x0c\x0d\x0b<"), 3722);5366assertToStringEquals(" ", res[1274].exec(" "), 3723);5367assertNull(res[1275].exec("ab", 3724));5368assertNull(res[1278].exec("abcabcabc", 3725));5369assertNull(res[1278].exec("abc(*+|abc ", 3726));5370assertNull(res[1279].exec("abc abcabc", 3727));5371assertNull(res[1279].exec("*** Failers", 3728));5372assertNull(res[1279].exec("abcabcabc ", 3729));5373assertNull(res[1280].exec("abc#not comment\n literal ", 3730));5374assertNull(res[1281].exec("abc#not comment\n literal ", 3731));5375assertNull(res[1282].exec("abc#not comment\n literal ", 3732));5376assertNull(res[1283].exec("abc#not comment\n literal ", 3733));5377assertNull(res[1284].exec("abc\\$xyz", 3734));5378assertNull(res[1285].exec("abc$xyz", 3735));5379assertNull(res[1286].exec("abc", 3736));5380assertNull(res[1286].exec("*** Failers", 3737));5381assertNull(res[1286].exec("xyzabc ", 3738));5382assertNull(res[1287].exec("abc1abc2xyzabc3", 3739));5383assertToStringEquals("abc1", res[1288].exec("abc1abc2xyzabc3 "), 3740);5384assertNull(res[1288].exec("XabcdY", 3741));5385assertNull(res[1288].exec("*** Failers ", 3742));5386assertNull(res[1288].exec("Xa b c d Y ", 3743));5387assertToStringEquals("abcY", res[1288].exec("XabcY"), 3744);5388assertNull(res[1288].exec("AxyzB ", 3745));5389assertNull(res[1288].exec("XabCY", 3746));5390assertNull(res[1288].exec("*** Failers", 3747));5391assertToStringEquals("abcY", res[1288].exec("XabcY "), 3748);5392assertNull(res[1288].exec("abCE", 3749));5393assertNull(res[1288].exec("DE", 3750));5394assertNull(res[1288].exec("*** Failers", 3751));5395assertToStringEquals("abcE", res[1288].exec("abcE"), 3752);5396assertNull(res[1288].exec("abCe ", 3753));5397assertNull(res[1288].exec("dE", 3754));5398assertNull(res[1288].exec("De ", 3755));5399assertNull(res[1289].exec("z", 3756));5400assertNull(res[1289].exec("a", 3757));5401assertNull(res[1289].exec("-", 3758));5402assertNull(res[1289].exec("d", 3759));5403assertNull(res[1289].exec("] ", 3760));5404assertNull(res[1289].exec("*** Failers", 3761));5405assertNull(res[1289].exec("b ", 3762));5406assertToStringEquals("z", res[1290].exec("z"), 3763);5407assertToStringEquals("C", res[1290].exec("C "), 3764);5408assertToStringEquals("M", res[1291].exec("M "), 3765);5409assertNull(res[1292].exec("", 3766));5410assertNull(res[1292].exec("REGular", 3767));5411assertNull(res[1292].exec("regulaer", 3768));5412assertNull(res[1292].exec("Regex ", 3769));5413assertNull(res[1292].exec("regul\ufffdr ", 3770));5414assertNull(res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3771));5415assertNull(res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3772));5416assertNull(res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3773));5417assertNull(res[1292].exec("\ufffd\ufffd\ufffd\ufffd\ufffd", 3774));5418assertNull(res[1292].exec("\x84XAZXB", 3775));5419assertNull(res[1292].exec("123a", 3776));5420assertNull(res[1292].exec("ac", 3777));5421assertToStringEquals("b,", res[1292].exec("bbbbc"), 3778);5422assertToStringEquals("ab,a", res[1292].exec("abc"), 3779);5423assertNull(res[1292].exec("*** Failers", 3780));5424assertToStringEquals("b,", res[1292].exec("bca"), 3781);5425assertNull(res[1292].exec("", 3782));5426assertToStringEquals("ab,a", res[1292].exec("abc"), 3783);5427assertNull(res[1292].exec("*** Failers", 3784));5428assertToStringEquals("b,", res[1292].exec("bca"), 3785);5429assertToStringEquals("ab,a", res[1292].exec("abc"), 3786);5430assertNull(res[1292].exec("*** Failers", 3787));5431assertNull(res[1292].exec("def ", 3788));5432assertNull(res[1292].exec("", 3789));5433assertToStringEquals("ab,a", res[1292].exec("abc"), 3790);5434assertNull(res[1292].exec("*** Failers", 3791));5435assertNull(res[1292].exec("def ", 3792));5436assertNull(res[1292].exec("", 3793));5437assertToStringEquals("line\nbreak", res[1293].exec("this is a line\nbreak"), 3794);5438assertToStringEquals("line\nbreak", res[1293].exec("line one\nthis is a line\nbreak in the second line "), 3795);5439assertToStringEquals("line\nbreak", res[1294].exec("this is a line\nbreak"), 3796);5440assertNull(res[1294].exec("** Failers ", 3797));5441assertToStringEquals("line\nbreak", res[1294].exec("line one\nthis is a line\nbreak in the second line "), 3798);5442assertToStringEquals("line\nbreak", res[1295].exec("this is a line\nbreak"), 3799);5443assertNull(res[1295].exec("** Failers ", 3800));5444assertToStringEquals("line\nbreak", res[1295].exec("line one\nthis is a line\nbreak in the second line "), 3801);5445assertNull(res[1296].exec("123P", 3802));5446assertNull(res[1296].exec("a4PR", 3803));5447assertNull(res[1297].exec("123P", 3804));5448assertNull(res[1297].exec("4PR", 3805));5449assertToStringEquals("", res[1298].exec("a\nb\nc\n"), 3806);5450assertToStringEquals("", res[1298].exec(" "), 3807);5451assertToStringEquals("", res[1298].exec("A\nC\nC\n "), 3808);5452assertToStringEquals("", res[1298].exec("AB"), 3809);5453assertToStringEquals("", res[1298].exec("aB "), 3810);5454assertToStringEquals("", res[1298].exec("AB"), 3811);5455assertToStringEquals("", res[1298].exec("aB "), 3812);5456assertToStringEquals("", res[1298].exec("AB"), 3813);5457assertToStringEquals("", res[1298].exec("aB "), 3814);5458assertToStringEquals("", res[1298].exec("AB"), 3815);5459assertToStringEquals("", res[1298].exec("aB "), 3816);5460assertToStringEquals("Content-Type:xxxxxyyy ", res[1299].exec("Content-Type:xxxxxyyy "), 3817);5461assertToStringEquals("Content-Type:xxxxxyyyz", res[1300].exec("Content-Type:xxxxxyyyz"), 3818);5462assertToStringEquals("Content-Type:xxxyyy ", res[1301].exec("Content-Type:xxxyyy "), 3819);5463assertToStringEquals("Content-Type:xxxyyyz", res[1302].exec("Content-Type:xxxyyyz"), 3820);5464assertToStringEquals("abc", res[1303].exec("xyz\nabc"), 3821);5465assertToStringEquals("abc", res[1303].exec("xyz\nabc<lf>"), 3822);5466assertToStringEquals("abc", res[1303].exec("xyz\x0d\nabc<lf>"), 3823);5467assertToStringEquals("abc", res[1303].exec("xyz\x0dabc<cr>"), 3824);5468assertToStringEquals("abc", res[1303].exec("xyz\x0d\nabc<crlf>"), 3825);5469assertNull(res[1303].exec("** Failers ", 3826));5470assertToStringEquals("abc", res[1303].exec("xyz\nabc<cr>"), 3827);5471assertToStringEquals("abc", res[1303].exec("xyz\x0d\nabc<cr>"), 3828);5472assertToStringEquals("abc", res[1303].exec("xyz\nabc<crlf>"), 3829);5473assertToStringEquals("abc", res[1303].exec("xyz\x0dabc<crlf>"), 3830);5474assertToStringEquals("abc", res[1303].exec("xyz\x0dabc<lf>"), 3831);5475assertToStringEquals("abc", res[1304].exec("xyzabc"), 3832);5476assertToStringEquals("abc", res[1304].exec("xyzabc\n "), 3833);5477assertToStringEquals("abc", res[1304].exec("xyzabc\npqr "), 3834);5478assertToStringEquals("abc", res[1304].exec("xyzabc\x0d<cr> "), 3835);5479assertToStringEquals("abc", res[1304].exec("xyzabc\x0dpqr<cr> "), 3836);5480assertToStringEquals("abc", res[1304].exec("xyzabc\x0d\n<crlf> "), 3837);5481assertToStringEquals("abc", res[1304].exec("xyzabc\x0d\npqr<crlf> "), 3838);5482assertNull(res[1304].exec("** Failers", 3839));5483assertToStringEquals("abc", res[1304].exec("xyzabc\x0d "), 3840);5484assertToStringEquals("abc", res[1304].exec("xyzabc\x0dpqr "), 3841);5485assertToStringEquals("abc", res[1304].exec("xyzabc\x0d\n "), 3842);5486assertToStringEquals("abc", res[1304].exec("xyzabc\x0d\npqr "), 3843);5487assertToStringEquals("abc", res[1305].exec("xyz\x0dabcdef"), 3844);5488assertToStringEquals("abc", res[1305].exec("xyz\nabcdef<lf>"), 3845);5489assertNull(res[1305].exec("** Failers ", 3846));5490assertToStringEquals("abc", res[1305].exec("xyz\nabcdef"), 3847);5491assertNull(res[1305].exec(" ", 3848));5492assertToStringEquals("abc", res[1306].exec("xyz\nabcdef"), 3849);5493assertToStringEquals("abc", res[1306].exec("xyz\x0dabcdef<cr>"), 3850);5494assertNull(res[1306].exec("** Failers ", 3851));5495assertToStringEquals("abc", res[1306].exec("xyz\x0dabcdef"), 3852);5496assertNull(res[1306].exec(" ", 3853));5497assertToStringEquals("abc", res[1307].exec("xyz\x0d\nabcdef"), 3854);5498assertToStringEquals("abc", res[1307].exec("xyz\x0dabcdef<cr>"), 3855);5499assertNull(res[1307].exec("** Failers ", 3856));5500assertToStringEquals("abc", res[1307].exec("xyz\x0