• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16/*
17 * @tc.name:regexp
18 * @tc.desc:test Regexp
19 * @tc.type: FUNC
20 * @tc.require: issueI5NO8G
21 */
22
23{
24  let reg= /ab|cd||/
25  assert_equal(JSON.stringify(reg.exec("cd")),'["cd"]')
26}
27{
28  let reg= /ab||/
29  assert_equal(JSON.stringify(reg.exec("cd")),'[""]')
30}
31{
32  let reg= /ab|cd|ef/
33  assert_equal(JSON.stringify(reg.exec("cd")),'["cd"]')
34}
35
36{
37  let str = "��";
38  let regexp = /[��]/;
39  assert_equal(JSON.stringify(str.replace(regexp,"b")),JSON.stringify("b\ude00"));
40}
41{
42  let str = "��";
43  let regexp = /[��]/g;
44  assert_equal(JSON.stringify(str.replace(regexp,"b")),JSON.stringify("bb"));
45}
46{
47  let str = "��";
48  let regexp = /[��]/u;
49  assert_equal(JSON.stringify(str.replace(regexp,"b")),JSON.stringify("b"));
50}
51{
52  let str = "��";
53  let regexp = /[\��]/;
54  assert_equal(JSON.stringify(str.replace(regexp,"b")),JSON.stringify("b\ude00"));
55}
56
57
58var reg = /[\x5d-\x7e]/i;
59var result = reg.test("a");
60assert_equal(result,true);
61
62var reg1 = new RegExp("^[-+]?([0-9]+)?(\\٫[0-9]{1,})?$");
63var result1 = reg1.test('0٫0000000000001');
64assert_equal(result1,true);
65
66var reg2 = /^[Α-ώ]+$/i
67assert_equal(reg2.test('άέήίΰϊϋόύώ'),true);
68
69assert_equal(reg2.test('ΆΈΉΊΪΫΎΏ'),true);
70
71assert_equal(reg2.test('αβγδεζηθικλμνξοπρςστυφχψω'),true);
72
73assert_equal(reg2.test('ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ'),true);
74
75let reg3 =/^[A-Z0-9_\-]*$/i
76assert_equal(reg3.test(''),true)
77
78let reg4 =   new RegExp("^(?<urlStrIndex>.*?)(?<urlStr>https?[:：]//[^/]+/svn(?:/[a-z0-9.,;?'*:+&%$#=~_ \\u4E00-\\u9FA5-]*)*).*$", "i")
79assert_equal(reg4.test('a'),false);
80
81let reg5 =   new RegExp("^(?<urlStrIndex>.*?)(?<urlStr>(?:(?:ht|f)tps?[:：]//)?(?:[a-z0-9-]+\\.)+" + "(?:com|edu|gov|mil|net|org|biz|info|name|museum|us|ca|uk|cn|cc|tw|de|au|sg|hk|ei|fr|me|im)(?![a-z])" + "(?:\\:[0-9][0-9]*)?(?:\\.?/[a-z0-9.,;?'\\|*:\\\\+&%$#=~_-]*)*).*$", "i")
82assert_equal(reg5.test('a'),false);
83
84let reg6 =   new RegExp("^(?<urlStrIndex>.*?)(?<urlStr>(?:ht|f)tps?[:：]//(?:[a-z0-9-]+\\.)*[a-z0-9-]+(?:/[a-z0-9]+)*[/a-z0-9.,;?'\\|*:\\\\+&%$#=~_-]*).*$", "i")
85assert_equal(reg6.test('a'),false);
86
87let reg7 =   new RegExp("^(?<urlStrIndex>.*?)(?<urlStr>(?:https?[:：]//)?(?:[a-z0-9-\\\\]+\\.)+" + "(?:com|edu|gov|mil|net|org|biz|info|name|museum|us|ca|uk|cn|cc|tw|de|au|sg|hk|ei|fr|me|im)(?![a-z])" + "(?:\\:\\d{4})?(?:/[a-z0-9.,;?'\\|*:\\\\+&%$#=~_-]*)*\\?(?:[a-z0-9]*=[a-z0-9.,;?'*:+%$#=~_\\u4E00-\\u9FA5-]*&?)*).*$", "i")
88assert_equal(reg7.test('a'),false);
89
90let arr = []
91let temp = true
92var quotedEmailUserUtf8 = /^([\s\x01-\x08\x0b\x0c\x0e-\x1f\x7f\x21\x23-\x5b\x5d-\x7e\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|(\\[\x01-\x09\x0b\x0c\x0d-\x7f\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))*$/i;
93arr.push(quotedEmailUserUtf8.test(" foo m端ller "))
94
95let reg8 = /^[A-ZÃÁÀÂÄÇÉÊËÍÏÕÓÔÖÚÜ]+$/i
96arr.push(reg8.test('palíndromo'))
97arr.push(reg8.test('órgão'))
98arr.push(reg8.test('qwértyúão'))
99arr.push(reg8.test('àäãcëüïÄÏÜ'))
100
101let reg9 = /^[A-ZÀÉÈÌÎÓÒÙ]+$/i
102arr.push(reg9.test('àéèìîóòù'))
103arr.push(reg9.test('metró'))
104arr.push(reg9.test('pèsca'))
105arr.push(reg9.test('genî'))
106
107let reg10 = /^[A-ZÀÁẠẢÃÂẦẤẬẨẪĂẰẮẶẲẴĐÈÉẸẺẼÊỀẾỆỂỄÌÍỊỈĨÒÓỌỎÕÔỒỐỘỔỖƠỜỚỢỞỠÙÚỤỦŨƯỪỨỰỬỮỲÝỴỶỸ]+$/i
108arr.push(reg10.test('thiến'))
109arr.push(reg10.test('nghiêng'))
110arr.push(reg10.test('chào'))
111arr.push(reg10.test('thế'))
112arr.push(reg10.test('giới'))
113
114let reg11 = /^[A-ZÅÄÖ]+$/i
115arr.push(reg11.test('äiti'))
116
117let reg12 = /^[A-ZÆØÅ]+$/i
118arr.push(reg12.test('aøå'))
119
120let reg13 = /^[A-ZĄĆĘŚŁŃÓŻŹ]+$/i
121arr.push(reg13.test('kreską'))
122arr.push(reg13.test('zamknięte'))
123arr.push(reg13.test('zwykłe'))
124arr.push(reg13.test('kropką'))
125arr.push(reg13.test('przyjęły'))
126arr.push(reg13.test('święty'))
127arr.push(reg13.test('Pozwól'))
128
129let reg14 = /^[А-ЯЂЈЉЊЋЏ]+$/i
130arr.push(reg14.test('ШћжЂљЕ'))
131
132let reg15 = /^[A-ZČĆŽŠĐ]+$/i
133arr.push(reg15.test('ŠAabčšđćž'))
134arr.push(reg15.test('ŠATROĆčđš'))
135
136let reg16 = /^[A-ZÁÉÍÑÓÚÜ]+$/i
137arr.push(reg16.test('ábcó'))
138arr.push(reg16.test('dormís'))
139arr.push(reg16.test('volvés'))
140arr.push(reg16.test('español'))
141
142let reg17 = /^[A-ZÅÄÖ]+$/i
143arr.push(reg17.test('religiös'))
144arr.push(reg17.test('stjäla'))
145arr.push(reg17.test('västgöte'))
146
147let reg18 = /^[A-ZÇĞİıÖŞÜ]+$/i
148arr.push(reg18.test('AİıÖöÇ窺ĞğÜüZ'))
149
150let reg19 = /^[Α-ώ]+$/i
151arr.push(reg19.test('άέήίΰϊϋόύώ'))
152arr.push(reg19.test('ΆΈΉΊΪΫΎΏ'))
153
154let reg20 = /^[0-9A-VXYZÇƏĞİıÖŞÜ]+$/i
155arr.push(reg20.test('Azərbaycan'))
156arr.push(reg20.test('abcç2'))
157arr.push(reg20.test('3kərə4kərə'))
158
159let reg21 = /^[0-9А-Я]+$/i
160arr.push(reg21.test('абв1'))
161arr.push(reg21.test('жаба'))
162arr.push(reg21.test('яГоДа2'))
163arr.push(reg21.test('йЮя'))
164
165let reg22 = /^[0-9A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ]+$/i
166arr.push(reg22.test('řiť123'))
167
168let reg23 = /^[0-9A-ZÁČĎÉÍŇÓŠŤÚÝŽĹŔĽÄÔ]+$/i
169arr.push(reg23.test('1môj'))
170arr.push(reg23.test('2ľúbím'))
171arr.push(reg23.test('3mäkčeň'))
172arr.push(reg23.test('5vŕba'))
173arr.push(reg23.test('6ňorimberk'))
174arr.push(reg23.test('7ťava'))
175arr.push(reg23.test('8žanéta'))
176arr.push(reg23.test('9Ďábelské'))
177arr.push(reg23.test('10ódy'))
178
179let reg24 = /^[0-9A-ZÁÉËÏÓÖÜÚ]+$/i
180arr.push(reg24.test('Kán123'))
181arr.push(reg24.test('één354'))
182
183let reg25 = /^[0-9A-ZÅÄÖ]+$/i
184arr.push(reg25.test('äiti124'))
185arr.push(reg25.test('451åå23'))
186
187let reg26 = /^[0-9A-ZÄÖÜß]+$/i
188arr.push(reg26.test('äbc123'))
189
190let reg27 = /^[0-9A-ZÁÉÍÓÖŐÚÜŰ]+$/i
191arr.push(reg27.test('0árvíztűrőtükörfúrógép123'))
192
193let reg28 = /^[0-9A-ZÃÁÀÂÄÇÉÊËÍÏÕÓÔÖÚÜ]+$/i
194arr.push(reg28.test('palíndromo'))
195arr.push(reg28.test('2órgão'))
196arr.push(reg28.test('qwértyúão9'))
197arr.push(reg28.test('àäãcë4üïÄÏÜ'))
198
199let reg29 = /^[0-9A-ZÀÉÈÌÎÓÒÙ]+$/i
200arr.push(reg29.test('123àéèìîóòù'))
201arr.push(reg29.test('met23ró'))
202arr.push(reg29.test('pès56ca'))
203arr.push(reg29.test('gen45î'))
204
205let reg30 = /^[0-9A-ZÁÉÍÑÓÚÜ]+$/i
206arr.push(reg30.test('ábcó123'))
207
208let reg31 = /^[0-9A-ZÀÁẠẢÃÂẦẤẬẨẪĂẰẮẶẲẴĐÈÉẸẺẼÊỀẾỆỂỄÌÍỊỈĨÒÓỌỎÕÔỒỐỘỔỖƠỜỚỢỞỠÙÚỤỦŨƯỪỨỰỬỮỲÝỴỶỸ]+$/i
209arr.push(reg31.test('Thầy3'))
210arr.push(reg31.test('3Gà'))
211
212let reg32 = /^[0-9A-ZĄĆĘŚŁŃÓŻŹ]+$/i
213arr.push(reg32.test('kre123ską'))
214arr.push(reg32.test('zam21knięte'))
215arr.push(reg32.test('zw23ykłe'))
216arr.push(reg32.test('prz23yjęły'))
217arr.push(reg32.test('świ23ęty'))
218arr.push(reg32.test('Poz1322wól'))
219
220let reg33 = /^[0-9А-ЯЂЈЉЊЋЏ]+$/i
221arr.push(reg33.test('ШћжЂљЕ123'))
222
223let reg34 = /^[0-9A-ZČĆŽŠĐ]+$/i
224arr.push(reg34.test('ŠAabčšđćž123'))
225arr.push(reg34.test('ŠATRO11Ćčđš'))
226
227let reg35 = /^[0-9A-ZÅÄÖ]+$/i
228arr.push(reg35.test('religiös13'))
229arr.push(reg35.test('st23jäla'))
230arr.push(reg35.test('västgöte123'))
231
232let reg36 = /^[0-9A-ZÇĞİıÖŞÜ]+$/i
233arr.push(reg36.test('AİıÖöÇ窺ĞğÜüZ123'))
234
235let reg37 = new RegExp("^[-+]?([0-9]+)?(\\٫[0-9]{1,})?$")
236arr.push(reg37.test('0٫0000000000001'))
237
238let reg38 = new RegExp("^(?:[-+])?(?:[0-9]+)?(?:\\٫[0-9]*)?(?:[eE][\\+\\-]?(?:[0-9]+))?$")
239arr.push(reg38.test('123٫'))
240arr.push(reg38.test('123٫123'))
241arr.push(reg38.test('-123٫123'))
242
243let reg39 =/^[A-Z0-9_\-]*$/i
244arr.push(reg39.test(''))
245
246let reg40 = RegExp("^(?!-? )(?=.*\\d)(\\¥)?-?(0|[1-9]\\d|[1-9]\\d{0,2}(\\,\\d{3})*)?(\\.(\\d{2}))?$")
247arr.push(reg40.test('¥6,954,231'))
248arr.push(reg40.test('¥-6,954,231'))
249
250var reg41 = /^[A-VXYZÇƏĞİıÖŞÜ]+$/i;
251arr.push(reg41.test('Azərbaycan'))
252arr.push(reg41.test('üöğıəçş'))
253arr.push(reg41.test('sizAzərbaycanlaşdırılmışlardansınızmı'))
254arr.push(reg41.test('dahaBirDüzgünString'))
255arr.push(reg41.test('abcçdeəfgğhxıijkqlmnoöprsştuüvyz'))
256
257let reg42 = /^[А-Я]+$/i
258arr.push(reg42.test('абв'))
259arr.push(reg42.test('жаба'))
260arr.push(reg42.test('яГоДа'))
261
262let reg43 = /^[A-ZÁČĎÉĚÍŇÓŘŠŤÚŮÝŽ]+$/i
263arr.push(reg43.test('žluťoučký'))
264arr.push(reg43.test('Pěl'))
265arr.push(reg43.test('Ďábelské'))
266arr.push(reg43.test('ódy'))
267
268let reg44 = /^[A-ZÁČĎÉÍŇÓŠŤÚÝŽĹŔĽÄÔ]+$/i
269arr.push(reg44.test('môj'))
270arr.push(reg44.test('ľúbím'))
271arr.push(reg44.test('mäkčeň'))
272arr.push(reg44.test('vŕba'))
273arr.push(reg44.test('ňorimberk'))
274
275let reg45 = /^[A-ZÆØÅ]+$/i
276arr.push(reg45.test('aøå'))
277
278let reg46 = /^[A-ZÁÉËÏÓÖÜÚ]+$/i
279arr.push(reg46.test('Kán'))
280arr.push(reg46.test('één'))
281arr.push(reg46.test('vóór'))
282arr.push(reg46.test('nú'))
283arr.push(reg46.test('héél'))
284
285let reg47 = /^[A-ZÄÖÜß]+$/i
286arr.push(reg47.test('äbc'))
287arr.push(reg47.test('FöÖbär'))
288
289let reg48 = /^[A-ZÁÉÍÓÖŐÚÜŰ]+$/i
290arr.push(reg48.test('árvíztűrőtükörfúrógép'))
291
292arr.forEach((item)=>{
293  if(!item){
294    temp = false
295  }
296})
297assert_equal(temp,true)
298
299let arr1 = []
300let temp1 = false
301let reg49 = /[^A-Z0-9+\/=]/i;
302arr1.push(reg49.test("Zg=="));
303arr1.push(reg49.test("Zm8="));
304arr1.push(reg49.test("Zm9v"));
305arr1.push(reg49.test("Zm9vYg=="));
306arr1.push(reg49.test("Zm9vYmE="));
307arr1.push(reg49.test("Zm9vYmFy"));
308arr1.push(reg49.test(
309  "TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2NpbmcgZWxpdC4="
310));
311arr1.push(reg49.test("Vml2YW11cyBmZXJtZW50dW0gc2VtcGVyIHBvcnRhLg=="));
312arr1.push(reg49.test("U3VzcGVuZGlzc2UgbGVjdHVzIGxlbw=="));
313arr1.forEach((item)=>{
314  if(item){
315    temp1 = true
316  }
317})
318assert_equal(temp1,false)
319let str1 = 'SC52BAHL01031234567890123456USD'
320assert_equal(str1.replace(/[^A-Z0-9]+/gi, ''),"SC52BAHL01031234567890123456USD")
321
322let reg50 = /^[ABCEGHJKLMNPRSTVXY]\d[ABCEGHJ-NPRSTV-Z][\s-]?\d[ABCEGHJ-NPRSTV-Z]\d$/i
323
324let regabc = /abc/g;
325let strabcd = "abcdabcdabcd";
326let exceptArr = [true,true,true,false,true,true,true,false,true,true]
327let resultArr = []
328for (let i = 0; i < 10; i++) {
329  // cache is used in this case
330  resultArr.push(regabc.test(strabcd))
331}
332assert_equal(exceptArr,resultArr);
333
334let str2 = "aaaabbBbcccC";
335for (let i = 0; i < 2; i++) {
336  assert_equal(str2,'aaaabbBbcccC');
337  let t1 = str2.replace(/([A-Z])/g, function(e) {
338    return "_" + e;
339  });
340  assert_equal(t1,'aaaabb_Bbccc_C');
341  let t2 = str2.replace(/([A-Z])/g, "_$1");
342  assert_equal(t2,'aaaabb_Bbccc_C');
343  assert_equal(t1.replace(/([a-z]+)/g, "_xy"),'_xy_B_xy_C');
344  assert_equal(t2.replace(/_/g, ""),'aaaabbBbcccC');
345}
346
347// regexp cache test
348let mediaReg = "\([^\)]+\)\([^\)]+\)\([^\)]+\)\([^\)]+\)\([^\)]+\)\([^\)]+\)\([^\)]+\)\([^\)]+\)\([^\)]+\)\([^\)]+\)\([^\)]+\)\([^\)]+\)\([^\)]+\)\([^\)]+\)\([^\)]+\)\([^\)]+\)";
349let string = '(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s';
350const regex1 = new RegExp(mediaReg);
351let matchArray = string.match(regex1);
352assert_equal(matchArray.toString(),'(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s,(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(,s,(,s,(,s,(,s,(,s,(,s,(,s,(,s');
353
354// Test regexp.test fastpath
355var protoExec = RegExp.prototype.exec
356RegExp.prototype.exec = function () {
357  return null
358}
359var reg = /a/
360assert_equal(reg.test("aaaaa"),false);
361
362delete RegExp.prototype.exec
363assert_equal(reg.test("aaaaa"),true);
364
365Object.prototype.exec = function () {
366  return null
367}
368assert_equal(reg.test("aaaaa"),false);
369
370delete Object.prototype.exec
371RegExp.prototype.exec = protoExec
372assert_equal(reg.test("aaaaa"),true);
373
374var protoTest = RegExp.prototype.test
375RegExp.prototype.test = function () {
376    return false
377}
378var reg2 = /foo*/
379assert_equal(reg2.test("fooooooo"),false);
380
381RegExp.prototype.test = protoTest
382assert_equal(reg2.test("fooooooo"),true);
383
384// Same hash in cached result, but different flags.
385var regexp1 = /a*/gs;
386var regexp2 = /a*/g;
387regexp2.lastIndex = 8;
388assert_equal(regexp1.exec('aaa').toString(),'aaa');
389assert_equal(regexp2.exec('aaa'),null);
390
391// Same hash in cached result, and same flags, but different lastIndex.
392var regexp3 = /a*/g;
393var regexp4 = /a*/g;
394regexp4.lastIndex = 1;
395assert_equal(regexp3.exec('aaabab').toString(),'aaa');
396assert_equal(regexp4.exec('aaabaa').toString(),'aa');
397
398const v43 = /V[\d-\d]/ys;
399const o54 = {
400    __proto__: v43,
401};
402try {
403    o54.test(Map);
404    assert_unreachable();
405} catch (error) {
406  assert_equal("Caught an error: "+ error.message, "Caught an error: this does not have [[RegExpMatcher]]");
407}
408
409// Testing regexp.prototype.replace after optimization
410{
411  const re1 = /[Cz]/;
412  const re2 = /[Cz]/g;
413  const re3 = /([Cz])/;
414  const re4 = /([Cz])/g;
415
416  let replace_str = "abCdefgzabCdefgzabCdefgz";
417  let replace_result = replace_str.replace(re1, "");
418  assert_equal(re1.lastIndex,0);
419  let cached_reuslt = replace_str.replace(re1, "");
420  assert_equal(replace_result === cached_reuslt,true);
421  assert_equal(re1.lastIndex,0);
422
423  replace_result = replace_str.replace(re2, "xyz");
424  assert_equal(re2.lastIndex,0);
425  cached_reuslt = replace_str.replace(re2, "xyz");
426  assert_equal(replace_result === cached_reuslt,true);
427  assert_equal(re2.lastIndex,0);
428
429  replace_result = replace_str.replace(re3, "x$1yz");
430  assert_equal(re3.lastIndex,0);
431  cached_reuslt = replace_str.replace(re3, "x$1yz");
432  assert_equal(replace_result === cached_reuslt,true);
433  assert_equal(re3.lastIndex,0);
434
435  replace_result = replace_str.replace(re4, String);
436  assert_equal(re4.lastIndex,0);
437  cached_reuslt = replace_str.replace(re4, String);
438  assert_equal(replace_result === cached_reuslt,true);
439  assert_equal(re4.lastIndex,0);
440}
441
442// test RegExp.prototype.xx
443assert_equal(RegExp.prototype.dotAll,undefined)
444assert_equal(RegExp.prototype.global,undefined)
445assert_equal(RegExp.prototype.hasIndices,undefined)
446assert_equal(RegExp.prototype.ignoreCase,undefined)
447assert_equal(RegExp.prototype.multiline,undefined)
448assert_equal(RegExp.prototype.sticky,undefined)
449assert_equal(RegExp.prototype.unicode,undefined)
450assert_equal(RegExp.prototype.lastIndex,undefined)
451assert_equal(RegExp.prototype.flags,"")
452assert_equal(RegExp.prototype.source,"(?:)")
453try {
454    RegExp.prototype.test("abc")
455    assert_unreachable();
456} catch (error) {
457  assert_equal(error instanceof TypeError,true)
458}
459try {
460    RegExp.prototype.exec("abc")
461    assert_unreachable();
462} catch (error) {
463  assert_equal(error instanceof TypeError,true)
464}
465assert_equal(RegExp.prototype.toString(),'/(?:)/')
466
467let inputString = "/vedio/av{avid}{cid}";
468let extractedContent = inputString.match(/\{([^{}]+)\}/g);
469let replacedString = inputString.replace(/\{([^{}]+)\}/g, '(uuu)').replace(/\//g, "\\/");
470assert_equal(replacedString,'\\/vedio\\/av(uuu)(uuu)');
471
472let str = "beep boop   afff测试样本one1";
473assert_equal(str.split(/([{}:;,]|\s+)/).toString(),'beep, ,boop,   ,afff测试样本one1');
474
475function verifyRegExp(text) {
476  text = text.replace(new RegExp('[\\s]', 'g'), ' ');
477  let emRegExp = new RegExp('<em>.*?</em>', 'ig');
478  let results = text.split(emRegExp);
479  text.match(emRegExp);
480  return results;
481}
482
483const srcTextA = '<em>a</em>bcdefghijklmnopqrstuvwxyz<em>a</em>bcdefghijklmnopqrstuvwxyz<em>a</em>bcdefghijklmnopqrstuvwxyz<em>a</em>bcdefghijklmnopqrstuvwxyz'
484const srcTextAbcd = '<em>abcd</em>efghijklmnopqrstuvwxyz<em>abcd</em>efghijklmnopqrstuvwxyz<em>abcd</em>efghijklmnopqrstuvwxyz<em>abcd</em>efghijklmnopqrstuvwxyz'
485
486var s =`verifyRegExp_1: ${verifyRegExp(srcTextA)}`
487assert_equal(s,'verifyRegExp_1: ,bcdefghijklmnopqrstuvwxyz,bcdefghijklmnopqrstuvwxyz,bcdefghijklmnopqrstuvwxyz,bcdefghijklmnopqrstuvwxyz');
488var s =`verifyRegExp_2: ${verifyRegExp(srcTextAbcd)}`
489assert_equal(s,'verifyRegExp_2: ,efghijklmnopqrstuvwxyz,efghijklmnopqrstuvwxyz,efghijklmnopqrstuvwxyz,efghijklmnopqrstuvwxyz');
490var s = `verifyRegExp_3: ${verifyRegExp(srcTextAbcd)}`
491assert_equal(s,'verifyRegExp_3: ,efghijklmnopqrstuvwxyz,efghijklmnopqrstuvwxyz,efghijklmnopqrstuvwxyz,efghijklmnopqrstuvwxyz');
492
493//regexp unicode property
494const ans1 = /\p{Alphabetic}/u.test("æ");
495const ans2 = /\p{Alpha}/u.test("2");
496const ans3 = /^[\p{Lu}\p{Ll}]+$/u.test("ASDFasdf");
497const ans4 = /^[\P{Lu}\p{Ll}]+$/u.test("ASDFasdf");
498const ans5 = /\P{Ll}/iu.test("b");
499const ans6 = /\p{Ll}/iu.test("b");
500const ans7 = /[^\P{Any}]+/u.test(456);
501const ans8 = /\p{Assigned}+/u.test("������");
502const ans9 = /[\p{P}\p{S}]/u.test("!");
503const ans10 = /\p{General_Category=Math_Symbol}/u.test("+");
504assert_equal(ans1,true);
505assert_equal(ans2,false);
506assert_equal(ans3,true);
507assert_equal(ans4,false);
508assert_equal(ans5,true);
509assert_equal(ans6,true);
510assert_equal(ans7,true);
511assert_equal(ans8,true);
512assert_equal(ans9,true);
513assert_equal(ans10,true);
514try {
515  const ans11 = RegExp("/[\\p{}]/u");
516  assert_unreachable();
517} catch(error) {
518  assert_equal(error instanceof SyntaxError, true);
519}
520const str3 = "a-b-c";
521const re = /-/y;
522assert_equal(str3.split(re).toString(),'a,b,c');
523
524re.lastIndex = 1;
525assert_equal(str3.split(re).toString(),'a,b,c');
526
527re.lastIndex = -1;
528assert_equal(str3.split(re).toString(),'a,b,c');
529
530re.lastIndex = 3;
531assert_equal(str3.split(re).toString(),'a,b,c');
532
533assert_equal(re.test(str3),true);
534
535assert_equal(str3.split(/-/g).toString(),'a,b,c');
536
537// search
538const str4 = "abc";
539let re1 = /b/;
540re1.lastIndex = 2;
541assert_equal(str4.search(re1),1);
542assert_equal(str4.search(/b/y),-1);
543assert_equal(str4.search(re1),1);
544assert_equal(re1.lastIndex,2);
545
546// check cache
547const str5 = "a-bc";
548let re2 = /-/;
549re2.lastIndex = 2;
550assert_equal(str5.split(re2).toString(),'a,bc');
551assert_equal(re2.lastIndex,2);
552assert_equal(str5.split(re2).toString(),'a,bc');
553assert_equal(re2.lastIndex,2);
554
555const str6 = "abcabc";
556let re3 = /abc/;
557re3.lastIndex = 2;
558assert_equal(str6.match(re3).toString(),'abc');
559assert_equal(re3.lastIndex,2);
560assert_equal(str6.match(re3).toString(),'abc');
561assert_equal(re3.lastIndex,2);
562
563let re4 = /abc/g;
564re4.lastIndex = 2;
565assert_equal(str6.match(re4).toString(),'abc,abc');
566assert_equal(re4.lastIndex,0);
567assert_equal(str6.match(re4).toString(),'abc,abc');
568assert_equal(re4.lastIndex,0);
569Object.defineProperty(RegExp.prototype, "global", {
570  value: true
571})
572var flags = RegExp.prototype.flags;
573Object.defineProperty(RegExp.prototype, "global", {
574  value: false
575})
576assert_equal(flags,"g");
577assert_equal(str6.match(re4).toString(),'abc');
578assert_equal(re4.lastIndex,3);
579assert_equal(str6.match(re4).toString(),'abc');
580assert_equal(re4.lastIndex,6);
581
582let myExp = new RegExp("a+b+c");
583Object.defineProperty(myExp, "sticky", {
584    value: true
585  })
586assert_equal(myExp.toString(),'/a+b+c/y');
587
588// Testing regexp.prototype.replace after optimization
589{
590  const re1 = /[Cz]/;
591  const re2 = /[Cz]/g;
592  const re3 = /([Cz])/;
593  const re4 = /([Cz])/g;
594
595  let replace_str = "abCdefgzabCdefgzabCdefgz";
596  let replace_result = replace_str.replace(re1, "");
597  assert_equal(re1.lastIndex,0);
598  let cached_reuslt = replace_str.replace(re1, "");
599  assert_equal(replace_result === cached_reuslt,true);
600  assert_equal(re1.lastIndex,0);
601
602  replace_result = replace_str.replace(re2, "xyz");
603  assert_equal(re2.lastIndex,3);
604  cached_reuslt = replace_str.replace(re2, "xyz");
605  assert_equal(replace_result === cached_reuslt,false);
606  assert_equal(re2.lastIndex,8);
607
608  replace_result = replace_str.replace(re3, "x$1yz");
609  assert_equal(re3.lastIndex,0);
610  cached_reuslt = replace_str.replace(re3, "x$1yz");
611  assert_equal(replace_result === cached_reuslt,true);
612  assert_equal(re3.lastIndex,0);
613
614  replace_result = replace_str.replace(re4, String);
615  assert_equal(re4.lastIndex,3);
616  cached_reuslt = replace_str.replace(re4, String);
617  assert_equal(replace_result === cached_reuslt,true);
618  assert_equal(re4.lastIndex,8);
619}
620
621const regex = /(?:)+/;
622const str10 = "abcabcabc";
623const matches = regex.test(str10);
624assert_equal(matches,true);
625const matches1 = regex.exec(str10);
626assert_equal(matches1.toString(),"");
627
628try {
629  let matchReg = new RegExp("@【哈哈】*^o^*|@小米（kk）",'g');
630  assert_unreachable();
631} catch (error) {
632  assert_equal("Caught an error: "+ error.message, "Caught an error: nothing to repeat");
633}
634
635let e = /./;
636e.exec = function() {
637    return [];
638}
639"".replace(e, "");
640delete e.exec;
641
642{
643  const v0 = /qeu(?<a>.)\k<a>(x)(x)(x)\1*xyz{93}/ugysd;
644  const v4 = typeof Date === "string";
645  v0[Symbol.match] = v4;
646  assert_equal(v0["exec"](),null);
647}
648
649{
650  ("65535").split(/(?!\1(a\1)\1)\1/g);
651  const o4 = {
652    ...RegExp,
653  };
654  assert_equal(o4.toString(),"[object Object]");
655}
656
657{
658  const v2 = /e\8Z(x)(x)(x)(x)(x)(x)(x)(x)(x)(x)\10*/misd;
659  v2[1073741824] = -194290175n;
660  for (let v3 = 0; v3 < 2; v3++) {
661    assert_equal(v2.test(-194290175n),false);
662  }
663}
664
665function f(...args) {
666  return {};
667}
668let reg51 = new RegExp("a");
669f.exec = f;
670let relpfun = reg51[Symbol.replace];
671relpfun.apply(f, [1, 2, 3, 4]);
672var s = "success"
673assert_equal(s,"success");
674
675{
676  let str = /^\s*([^;\s]*)/;
677  str.test("text/html");
678  assert_equal(RegExp.$1,'text/html');
679  str.test("text/plain");
680  assert_equal(RegExp.$1,'text/plain');
681  str.test("text/html");
682  assert_equal(RegExp.$1,'text/html');
683}
684
685{
686  RegExp.prototype.test = function () {
687    return false;
688  };
689  let str = /^\s*([^;\s]*)/;
690  str.test("text/html");
691  assert_equal(RegExp.$1,'text/html');
692  str.test("text/plain");
693  assert_equal(RegExp.$1,'text/html');
694  str.test("text/html");
695  assert_equal(RegExp.$1,'text/html');
696  RegExp.prototype.test = protoTest
697}
698
699{
700  let reg52 = /abc/;
701  let count = 0;
702  assert_equal(reg52.ignoreCase,false);
703  assert_equal(reg52.global,false);
704  assert_equal(reg52.flags,"");
705  Object.defineProperty(reg52, "global", {
706    get: function() { count++; return true; }
707  });
708  Object.defineProperty(reg52, "ignoreCase", {
709    get: function() { count++; return true; }
710  });
711
712  assert_equal(reg52.ignoreCase,true);
713  assert_equal(count,1);
714  assert_equal(reg52.global,true);
715  assert_equal(count,2);
716  assert_equal(reg52.flags,"gi");
717  assert_equal(count,4);
718}
719
720// test getFlags
721Object.defineProperty(RegExp.prototype, "global", {
722  value: true
723})
724const res = /abc/giymsud;
725res.lastIndex = -1;
726assert_equal(res.flags,'dgimsuy');
727const res1 = /abc/g;
728res1.lastIndex = -1;
729assert_equal(res1.flags,'g');
730const res2 = /abc/i;
731res2.lastIndex = -1;
732assert_equal(res2.flags,'gi');
733const res3 = /abc/y;
734res3.lastIndex = -1;
735assert_equal(res3.flags,'gy');
736const res4 = /abc/m;
737res4.lastIndex = -1;
738assert_equal(res4.flags,'gm');
739const res5 = /abc/s;
740res5.lastIndex = -1;
741assert_equal(res5.flags,'gs');
742const res6 = /abc/u;
743res6.lastIndex = -1;
744assert_equal(res6.flags,'gu');
745const res7 = /abc/d;
746res7.lastIndex = -1;
747assert_equal(res7.flags,'dg');
748const res8 = /abc/;
749res8.lastIndex = -1;
750assert_equal(res8.flags,'g');
751
752{
753  let str = "<style>test</style>"
754  let reg = new RegExp("/");
755  assert_equal(reg.source + ' ' + JSON.stringify(reg.exec(str)), '\\/ ["/"]');
756
757  reg = new RegExp("\/[a-z]*>");
758  assert_equal(reg.source + ' ' + JSON.stringify(reg.exec(str)),'\\/[a-z]*> ["/style>"]');
759
760  reg = new RegExp("\\/[a-z]*>");
761  assert_equal(reg.source + ' ' + JSON.stringify(reg.exec(str)),'\\/[a-z]*> ["/style>"]');
762
763  reg = new RegExp("\\\/[a-z]*>");
764  assert_equal(reg.source + ' ' + JSON.stringify(reg.exec(str)),'\\/[a-z]*> ["/style>"]');
765
766  str="<style>test<\\\\/style>"
767  reg = new RegExp("\\\\/[a-z]*>");
768  assert_equal(reg.source + ' ' + JSON.stringify(reg.exec(str)),'\\\\\\/[a-z]*> ["\\\\/style>"]');
769
770  reg = new RegExp("\\\\\/[a-z]*>");
771  assert_equal(reg.source + ' ' +  JSON.stringify(reg.exec(str)),'\\\\\\/[a-z]*> ["\\\\/style>"]');
772
773  reg = new RegExp("\\\\\\/[a-z]*>");
774  assert_equal(reg.source + ' ' +  JSON.stringify(reg.exec(str)),'\\\\\\/[a-z]*> ["\\\\/style>"]');
775
776  reg = new RegExp("\\\\\\\/[a-z]*>");
777  assert_equal(reg.source + ' ' +  JSON.stringify(reg.exec(str)),'\\\\\\/[a-z]*> ["\\\\/style>"]');
778}
779{
780  let str="\\\\\\\\[aaa"
781  try {
782    let pattern="[";
783    let reg = new RegExp(pattern);
784    assert_unreachable();
785  } catch (error) {
786    assert_equal(error instanceof SyntaxError,true);
787  }
788  try {
789    let pattern="\[";
790    let reg = new RegExp(pattern);
791    assert_unreachable();
792  } catch (error) {
793    assert_equal(error instanceof SyntaxError,true);
794  }
795  try {
796    let pattern="\\[";
797    let reg = new RegExp(pattern);
798    assert_equal(pattern+" "+JSON.stringify(reg.exec(str)),'\\[ ["["]')
799  } catch (error) {
800    assert_unreachable();
801  }
802  try {
803    let pattern="\\\[";
804    let reg = new RegExp(pattern);
805    assert_equal(pattern+" "+JSON.stringify(reg.exec(str)),'\\[ ["["]')
806  } catch (error) {
807    assert_unreachable();
808  }
809  try {
810    let pattern="\\\\[";
811    let reg = new RegExp(pattern);
812    assert_unreachable();
813  } catch (error) {
814    assert_equal(error instanceof SyntaxError,true);
815  }
816  try {
817    let pattern="\\\\\[";
818    let reg = new RegExp(pattern);
819    assert_unreachable();
820  } catch (error) {
821    assert_equal(error instanceof SyntaxError,true);
822  }
823  try {
824    let pattern="\\\\\\[";
825    let reg = new RegExp(pattern);
826    assert_equal(pattern+" "+JSON.stringify(reg.exec(str)),'\\\\\\[ ["\\\\["]')
827  } catch (error) {
828    assert_unreachable();
829  }
830  try {
831    let pattern="\\\\\\\[";
832    let reg = new RegExp(pattern);
833    assert_equal(pattern+" "+JSON.stringify(reg.exec(str)),'\\\\\\[ ["\\\\["]')
834  } catch (error) {
835    assert_unreachable();
836  }
837}
838
839{
840  Object.defineProperty(RegExp.prototype, "global", {
841    value: false
842  })
843  let str1;
844  let result;
845  const re1 = /[Cz]/;
846  const re2 = /[Cz]/g;
847  const re3 = /([Cz])/;
848  const re4 = /([Cz])/g;
849
850  function createHaystack() {
851    let s = "abCdefgz";
852    for (let i = 0; i < 3; i++) s += s;
853    return s;
854  }
855  str1 = createHaystack();
856  function String1Replace(re) {
857    result = re[Symbol.replace](str1, ".");
858  }
859  function String2Replace(re) {
860    result = re[Symbol.replace](str1, "xyz");
861  }
862  function String3Replace(re) {
863    result = re[Symbol.replace](str1, "x$1yz");
864  }
865  function Function1Replace(re) {
866    result = re[Symbol.replace](str1, String);
867  }
868  String1Replace(re1);
869  assert_equal(result,"ab.defgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgz");
870  String1Replace(re2);
871  assert_equal(result,"ab.defgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgz");
872  String2Replace(re2);
873  assert_equal(result,"abCdefgxyzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgz");
874  String2Replace(re1);
875  assert_equal(result,"abxyzdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgz");
876  String3Replace(re3);
877  assert_equal(result,"abxCyzdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgz");
878  String3Replace(re4);
879  assert_equal(result,"abxCyzdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgz");
880  Function1Replace(re3);
881  assert_equal(result,"abCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgz");
882  Function1Replace(re4);
883  assert_equal(result,"abCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgzabCdefgz");
884
885  // subStringIsUtf8 branch canbecompressed
886  str1 = 'utf83c这要替换"!';
887  let regexp = /([0-9])([a-z])/g
888  let newStr1 = str1.replace(regexp, "$1" );
889  assert_equal(newStr1,'utf83这要替换"!');
890
891  // subStringIsUtf8 branch length=0;
892  str1 = '3c这要替换"!';
893  regexp = /([0-9])([a-z])/g
894  newStr1 = str1.replace(regexp, "$1" );
895  assert_equal(newStr1,'3这要替换"!');
896
897  // subStringIsUtf8 branch src isUtf8;
898  str1 = 'abcdefg3chigk"!';
899  regexp = /([0-9])([a-z])/g
900  newStr1 = str1.replace(regexp, "$1" );
901  assert_equal(newStr1,'abcdefg3higk"!');
902}
903
904{
905  let s1 = 'abc';
906  let s2 = '\ud834\udf06';
907  let reg = new RegExp(s1.repeat(10000));
908  let str = s1.repeat(10000);
909  let res = str.replace(reg, s2);
910  assert_equal(res == s2, true);
911
912  reg = new RegExp(s2.repeat(10000));
913  str = s2.repeat(10000);
914  res = str.replace(reg, s1);
915  assert_equal(res == s1, true);
916}
917
918// This case aims to check overflow of error message while parsing regular expression
919{
920  let patternPart1 = "^(\\p{g}+)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
921  let patternPart2 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
922  let pattern = patternPart1 + patternPart2;
923  try {
924    let r = new RegExp(pattern);
925    assert_unreachable();
926  } catch (e) {
927    assert_equal(e instanceof SyntaxError, true);
928  }
929}
930
931{
932  class C3 extends Array {
933  }
934  const o7 = {
935    get(a5, a6) {
936      return 1942;
937    },
938  };
939  const v9 = new Proxy(C3, o7);
940  try {
941    RegExp(v9).toString();
942    assert_unreachable();
943  } catch (e) {
944    assert_equal(e instanceof SyntaxError, true);
945  }
946}
947try {
948  class C12 {
949  }
950  const v16 = ("symbol").constructor.fromCharCode(C12);
951  const v17 = v16.repeat(65534);
952  v17.replace(/(?<a>)/dumgs, v17);
953} catch (e) {
954  assert_equal(e.name, "RangeError");
955}
956test_end();