ai/ai_old
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
767d87ac3e
ai_old/goja/regexp_test.go

961 lines
29 KiB
Go
Raw Normal View History

add http
2024-09-20 16:50:35 +08:00
package goja
import (
"testing"
)
func TestRegexp1(t *testing.T) {
const SCRIPT = `
var r = new RegExp("(['\"])(.*?)\\1");
var m = r.exec("'test'");
m !== null && m.length == 3 && m[2] === "test";
`
testScript(SCRIPT, valueTrue, t)
}
func TestRegexp2(t *testing.T) {
const SCRIPT = `
var r = new RegExp("(['\"])(.*?)['\"]");
var m = r.exec("'test'");
m !== null && m.length == 3 && m[2] === "test";
`
testScript(SCRIPT, valueTrue, t)
}
func TestRegexpLiteral(t *testing.T) {
const SCRIPT = `
var r = /(['\"])(.*?)\1/;
var m = r.exec("'test'");
m !== null && m.length == 3 && m[2] === "test";
`
testScript(SCRIPT, valueTrue, t)
}
func TestRegexpRe2Unicode(t *testing.T) {
const SCRIPT = `
var r = /(тест)/i;
var m = r.exec("'Тест'");
m !== null && m.length == 2 && m[1] === "Тест";
`
testScript(SCRIPT, valueTrue, t)
}
func TestRegexpRe2UnicodeTarget(t *testing.T) {
const SCRIPT = `
var r = /(['\"])(.*?)['\"]/i;
var m = r.exec("'Тест'");
m !== null && m.length == 3 && m[2] === "Тест";
`
testScript(SCRIPT, valueTrue, t)
}
func TestRegexpRegexp2Unicode(t *testing.T) {
const SCRIPT = `
var r = /(['\"])(тест)\1/i;
var m = r.exec("'Тест'");
m !== null && m.length == 3 && m[2] === "Тест";
`
testScript(SCRIPT, valueTrue, t)
}
func TestRegexpRegexp2UnicodeTarget(t *testing.T) {
const SCRIPT = `
var r = /(['\"])(.*?)\1/;
var m = r.exec("'Тест'");
m !== null && m.length == 3 && m[2] === "Тест";
`
testScript(SCRIPT, valueTrue, t)
}
func TestRegexpRe2Whitespace(t *testing.T) {
const SCRIPT = `
"\u2000\u2001\u2002\u200b".replace(/\s+/g, "") === "\u200b";
`
testScript(SCRIPT, valueTrue, t)
}
func TestRegexpRegexp2Whitespace(t *testing.T) {
const SCRIPT = `
"A\u2000\u2001\u2002A\u200b".replace(/(A)\s+\1/g, "") === "\u200b"
`
testScript(SCRIPT, valueTrue, t)
}
func TestEmptyCharClassRe2(t *testing.T) {
const SCRIPT = `
/[]/.test("\u0000");
`
testScript(SCRIPT, valueFalse, t)
}
func TestNegatedEmptyCharClassRe2(t *testing.T) {
const SCRIPT = `
/[^]/.test("\u0000");
`
testScript(SCRIPT, valueTrue, t)
}
func TestEmptyCharClassRegexp2(t *testing.T) {
const SCRIPT = `
/([])\1/.test("\u0000\u0000");
`
testScript(SCRIPT, valueFalse, t)
}
func TestRegexp2Negate(t *testing.T) {
const SCRIPT = `
/([\D1])\1/.test("aa");
`
testScript(SCRIPT, valueTrue, t)
}
func TestAlternativeRe2(t *testing.T) {
const SCRIPT = `
/()|/.exec("") !== null;
`
testScript(SCRIPT, valueTrue, t)
}
func TestRegexpReplaceGlobal(t *testing.T) {
const SCRIPT = `
"QBZPbage\ny_cynprubyqre".replace(/^\s*|\s*$/g, '')
`
testScript(SCRIPT, asciiString("QBZPbage\ny_cynprubyqre"), t)
}
func TestRegexpNumCaptures(t *testing.T) {
const SCRIPT = `
"Fubpxjnir Synfu 9.0 e115".replace(/([a-zA-Z]|\s)+/, '')
`
testScript(SCRIPT, asciiString("9.0 e115"), t)
}
func TestRegexpNumCaptures1(t *testing.T) {
const SCRIPT = `
"Fubpxjnir Sy\tfu 9.0 e115".replace(/^.*\s+(\S+\s+\S+$)/, '')
`
testScript(SCRIPT, asciiString(""), t)
}
func TestRegexpSInClass(t *testing.T) {
const SCRIPT = `
/[\S]/.test("\u2028");
`
testScript(SCRIPT, valueFalse, t)
}
func TestRegexpDotMatchCR(t *testing.T) {
const SCRIPT = `
/./.test("\r");
`
testScript(SCRIPT, valueFalse, t)
}
func TestRegexpDotMatchCRInGroup(t *testing.T) {
const SCRIPT = `
/(.)/.test("\r");
`
testScript(SCRIPT, valueFalse, t)
}
func TestRegexpDotMatchLF(t *testing.T) {
const SCRIPT = `
/./.test("\n");
`
testScript(SCRIPT, valueFalse, t)
}
func TestRegexpSplitWithBackRef(t *testing.T) {
const SCRIPT = `
"a++b+-c".split(/([+-])\1/).join(" $$ ")
`
testScript(SCRIPT, asciiString("a $$ + $$ b+-c"), t)
}
func TestEscapeNonASCII(t *testing.T) {
const SCRIPT = `
/\⩓/.test("⩓")
`
testScript(SCRIPT, valueTrue, t)
}
func TestRegexpUTF16(t *testing.T) {
const SCRIPT = `
var str = "\uD800\uDC00";
assert(/\uD800/g.test(str), "#1");
assert(/\uD800/.test(str), "#2");
assert(/𐀀/.test(str), "#3");
var re = /\uD800/;
assert(compareArray(str.replace(re, "X"), ["X", "\uDC00"]), "#4");
assert(compareArray(str.split(re), ["", "\uDC00"]), "#5");
assert(compareArray("a\uD800\uDC00b".split(/\uD800/g), ["a", "\uDC00b"]), "#6");
assert(compareArray("a\uD800\uDC00b".split(/(?:)/g), ["a", "\uD800", "\uDC00", "b"]), "#7");
assert(compareArray("0\x80".split(/(0){0}/g), ["0", undefined, "\x80"]), "#7+");
re = /(?=)a/; // a hack to use regexp2
assert.sameValue(re.exec('\ud83d\ude02a').index, 2, "#8");
assert.sameValue(/./.exec('\ud83d\ude02')[0], '\ud83d', "#9");
assert(RegExp("\uD800").test("\uD800"), "#10");
var cu = 0xD800;
var xx = "a\\" + String.fromCharCode(cu);
var pattern = eval("/" + xx + "/");
assert.sameValue(pattern.source, "a\\\\\\ud800", "Code unit: " + cu.toString(16), "#11");
assert(pattern.test("a\\\uD800"), "#12");
`
testScriptWithTestLib(SCRIPT, _undefined, t)
}
func TestRegexpUnicode(t *testing.T) {
const SCRIPT = `
assert(!/\uD800/u.test("\uD800\uDC00"), "#1");
assert(!/\uFFFD/u.test("\uD800\uDC00"), "#2");
assert(/\uD800\uDC00/u.test("\uD800\uDC00"), "#3");
assert(/\uD800/u.test("\uD800"), "#4");
assert(compareArray("a\uD800\uDC00b".split(/\uD800/gu), ["a\uD800\uDC00b"]), "#5");
assert(compareArray("a\uD800\uDC00b".split(/(?:)/gu), ["a", "𐀀", "b"]), "#6");
assert(compareArray("0\x80".split(/(0){0}/gu), ["0", undefined, "\x80"]), "#7");
var re = eval('/' + /\ud834\udf06/u.source + '/u');
assert(re.test('\ud834\udf06'), "#9");
/*re = RegExp("\\p{L}", "u");
if (!re.test("A")) {
throw new Error("Test 9 failed");
}*/
`
testScriptWithTestLib(SCRIPT, _undefined, t)
}
func TestConvertRegexpToUnicode(t *testing.T) {
if s := convertRegexpToUnicode(`test\uD800\u0C00passed`); s != `test\uD800\u0C00passed` {
t.Fatal(s)
}
if s := convertRegexpToUnicode(`test\uD800\uDC00passed`); s != `test𐀀passed` {
t.Fatal(s)
}
if s := convertRegexpToUnicode(`test\u0023passed`); s != `test\u0023passed` {
t.Fatal(s)
}
if s := convertRegexpToUnicode(`test\u0passed`); s != `test\u0passed` {
t.Fatal(s)
}
if s := convertRegexpToUnicode(`test\uD800passed`); s != `test\uD800passed` {
t.Fatal(s)
}
if s := convertRegexpToUnicode(`test\uD800`); s != `test\uD800` {
t.Fatal(s)
}
if s := convertRegexpToUnicode(`test\uD80`); s != `test\uD80` {
t.Fatal(s)
}
if s := convertRegexpToUnicode(`\\uD800\uDC00passed`); s != `\\uD800\uDC00passed` {
t.Fatal(s)
}
if s := convertRegexpToUnicode(`testpassed`); s != `testpassed` {
t.Fatal(s)
}
}
func TestConvertRegexpToUtf16(t *testing.T) {
if s := convertRegexpToUtf16(`𐀀`); s != `\ud800\udc00` {
t.Fatal(s)
}
if s := convertRegexpToUtf16(`\𐀀`); s != `\\\ud800\udc00` {
t.Fatal(s)
}
}
func TestEscapeInvalidUtf16(t *testing.T) {
if s := escapeInvalidUtf16(asciiString("test")); s != "test" {
t.Fatal(s)
}
if s := escapeInvalidUtf16(newStringValue("test\U00010000")); s != "test\U00010000" {
t.Fatal(s)
}
if s := escapeInvalidUtf16(unicodeStringFromRunes([]rune{'t', 0xD800})); s != "t\\ud800" {
t.Fatal(s)
}
if s := escapeInvalidUtf16(unicodeStringFromRunes([]rune{'t', 0xD800, 'p'})); s != "t\\ud800p" {
t.Fatal(s)
}
if s := escapeInvalidUtf16(unicodeStringFromRunes([]rune{0xD800, 'p'})); s != "\\ud800p" {
t.Fatal(s)
}
if s := escapeInvalidUtf16(unicodeStringFromRunes([]rune{'t', '\\', 0xD800, 'p'})); s != `t\\\ud800p` {
t.Fatal(s)
}
}
func TestRegexpAssertion(t *testing.T) {
const SCRIPT = `
var res = 'aaa'.match(/^a/g);
res.length === 1 || res[0] === 'a';
`
testScript(SCRIPT, valueTrue, t)
}
func TestRegexpUnicodeAdvanceStringIndex(t *testing.T) {
const SCRIPT = `
// deoptimise RegExp
var origExec = RegExp.prototype.exec;
RegExp.prototype.exec = function(s) {
return origExec.call(this, s);
};
var re = /(?:)/gu;
var str = "a\uD800\uDC00b";
assert(compareArray(str.split(re), ["a", "𐀀", "b"]), "#1");
re.lastIndex = 3;
assert.sameValue(re.exec(str).index, 3, "#2");
re.lastIndex = 2;
assert.sameValue(re.exec(str).index, 1, "#3");
re.lastIndex = 4;
assert.sameValue(re.exec(str).index, 4, "#4");
re.lastIndex = 5;
assert.sameValue(re.exec(str), null, "#5");
var iterator = str.matchAll(re); // regexp is copied by matchAll, but resets lastIndex
var matches = [];
for (var v of iterator) {matches.push(v);}
assert.sameValue(matches.length, 4, "#6");
assert.sameValue(matches[0].index, 0, "#7 index");
assert.sameValue(matches[0][0], "", "#7 value");
assert.sameValue(matches[1].index, 1, "#8 index");
assert.sameValue(matches[1][0], "", "#8 value");
assert.sameValue(matches[2].index, 3, "#9 index");
assert.sameValue(matches[2][0], "", "#9 value");
assert.sameValue(matches[3].index, 4, "#10 index");
assert.sameValue(matches[3][0], "", "#10 value");
`
testScriptWithTestLib(SCRIPT, _undefined, t)
}
func TestRegexpInit(t *testing.T) {
const SCRIPT = `
RegExp(".").lastIndex;
`
testScript(SCRIPT, intToValue(0), t)
}
func TestRegexpToString(t *testing.T) {
const SCRIPT = `
RegExp.prototype.toString.call({
source: 'foo',
flags: 'bar'});
`
testScript(SCRIPT, asciiString("/foo/bar"), t)
}
func TestRegexpEscapeSource(t *testing.T) {
const SCRIPT = `
/href="(.+?)(\/.*\/\S+?)\/"/.source;
`
testScript(SCRIPT, asciiString(`href="(.+?)(\/.*\/\S+?)\/"`), t)
}
func TestRegexpConsecutiveMatchCache(t *testing.T) {
const SCRIPT = `
(function test(unicode) {
var regex = new RegExp('t(e)(st(\\d?))', unicode?'gu':'g');
var string = 'test1test2';
var match;
var matches = [];
while (match = regex.exec(string)) {
matches.push(match);
}
var expectedMatches = [
[
'test1',
'e',
'st1',
'1'
],
[
'test2',
'e',
'st2',
'2'
]
];
expectedMatches[0].index = 0;
expectedMatches[0].input = 'test1test2';
expectedMatches[1].index = 5;
expectedMatches[1].input = 'test1test2';
assert(deepEqual(matches, expectedMatches), "#1");
// try the same regexp with a different string
regex.lastIndex = 0;
match = regex.exec(' test5');
var expectedMatch = [
'test5',
'e',
'st5',
'5'
];
expectedMatch.index = 1;
expectedMatch.input = ' test5';
assert(deepEqual(match, expectedMatch), "#2");
assert.sameValue(regex.lastIndex, 6, "#3");
// continue matching with a different string
match = regex.exec(' test5test6');
expectedMatch = [
'test6',
'e',
'st6',
'6'
];
expectedMatch.index = 6;
expectedMatch.input = ' test5test6';
assert(deepEqual(match, expectedMatch), "#4");
assert.sameValue(regex.lastIndex, 11, "#5");
match = regex.exec(' test5test6');
assert.sameValue(match, null, "#6");
return regex;
});
`
vm := New()
_, _ = vm.RunProgram(testLib())
_, _ = vm.RunProgram(testLibX())
v, err := vm.RunString(SCRIPT)
if err != nil {
t.Fatal(err)
}
var f func(bool) (*Object, error)
err = vm.ExportTo(v, &f)
if err != nil {
t.Fatal(err)
}
regex, err := f(false)
if err != nil {
t.Fatal(err)
}
if regex.self.(*regexpObject).pattern.regexp2Wrapper.cache != nil {
t.Fatal("Cache is not nil (non-unicode)")
}
regex, err = f(true)
if err != nil {
t.Fatal(err)
}
if regex.self.(*regexpObject).pattern.regexp2Wrapper.cache != nil {
t.Fatal("Cache is not nil (unicode)")
}
}
func TestRegexpMatchAll(t *testing.T) {
const SCRIPT = `
(function test(unicode) {
var regex = new RegExp('t(e)(st(\\d?))', unicode?'gu':'g');
var string = 'test1test2';
var matches = [];
for (var match of string.matchAll(regex)) {
matches.push(match);
}
var expectedMatches = [
[
'test1',
'e',
'st1',
'1'
],
[
'test2',
'e',
'st2',
'2'
]
];
expectedMatches[0].index = 0;
expectedMatches[0].input = 'test1test2';
expectedMatches[1].index = 5;
expectedMatches[1].input = 'test1test2';
assert(deepEqual(matches, expectedMatches), "#1");
assert.sameValue(regex.lastIndex, 0, "#1 lastIndex");
// try the same regexp with a different string
string = ' test5';
matches = [];
for (var match of string.matchAll(regex)) {
matches.push(match);
}
expectedMatches = [
[
'test5',
'e',
'st5',
'5'
]
];
expectedMatches[0].index = 1;
expectedMatches[0].input = ' test5';
assert(deepEqual(matches, expectedMatches), "#2");
assert.sameValue(regex.lastIndex, 0, "#2 lastIndex");
// continue matching with a different string
string = ' test5test6';
matches = [];
for (var match of string.matchAll(regex)) {
matches.push(match);
}
var expectedMatches = [
[
'test5',
'e',
'st5',
'5'
],
[
'test6',
'e',
'st6',
'6'
]
];
expectedMatches[0].index = 1;
expectedMatches[0].input = ' test5test6';
expectedMatches[1].index = 6;
expectedMatches[1].input = ' test5test6';
assert(deepEqual(matches, expectedMatches), "#3");
assert.sameValue(regex.lastIndex, 0, "#3 lastindex");
});
`
vm := New()
_, _ = vm.RunProgram(testLib())
_, _ = vm.RunProgram(testLibX())
v, err := vm.RunString(SCRIPT)
if err != nil {
t.Fatal(err)
}
var f func(bool) (*Object, error)
err = vm.ExportTo(v, &f)
if err != nil {
t.Fatal(err)
}
_, err = f(false)
if err != nil {
t.Fatal(err)
}
_, err = f(true)
if err != nil {
t.Fatal(err)
}
}
func TestRegexpOverrideSpecies(t *testing.T) {
const SCRIPT = `
Object.defineProperty(RegExp, Symbol.species, {
configurable: true,
value: function() {
throw "passed";
}
});
try {
"ab".split(/a/);
throw new Error("Expected error");
} catch(e) {
if (e !== "passed") {
throw e;
}
}
`
testScript(SCRIPT, _undefined, t)
}
func TestRegexpSymbolMatchAllCallsIsRegexp(t *testing.T) {
// This is tc39's test/built-ins/RegExp/prototype/Symbol.matchAll/isregexp-this-throws.js
const SCRIPT = `
var a = new Object();
Object.defineProperty(a, Symbol.match, {
get: function() {
throw "passed";
}
});
try {
RegExp.prototype[Symbol.matchAll].call(a, '');
throw new Error("Expected error");
} catch(e) {
if (e !== "passed") {
throw e;
}
}
`
testScript(SCRIPT, _undefined, t)
}
func TestRegexpMatchAllConstructor(t *testing.T) {
// This is tc39's test/built-ins/RegExp/prototype/Symbol.matchAll/species-constuctor.js
const SCRIPT = `
var callCount = 0;
var callArgs;
var regexp = /\d/u;
var obj = {}
Object.defineProperty(obj, Symbol.species, {
value: function() {
callCount++;
callArgs = arguments;
return /\w/g;
}
});
regexp.constructor = obj;
var str = 'a*b';
var iter = regexp[Symbol.matchAll](str);
assert.sameValue(callCount, 1);
assert.sameValue(callArgs.length, 2);
assert.sameValue(callArgs[0], regexp);
assert.sameValue(callArgs[1], 'u');
var first = iter.next()
assert.sameValue(first.done, false);
assert.sameValue(first.value.length, 1);
assert.sameValue(first.value[0], "a");
var second = iter.next()
assert.sameValue(second.done, true);
`
testScriptWithTestLib(SCRIPT, _undefined, t)
}
func TestRegexp2InvalidEscape(t *testing.T) {
testScript(`/(?=)\x0/.test("x0")`, valueTrue, t)
}
func TestRegexpUnicodeEmptyMatch(t *testing.T) {
testScript(`/(0)0|/gu.exec("0\xef").length === 2`, valueTrue, t)
}
func TestRegexpInvalidGroup(t *testing.T) {
const SCRIPT = `
["?", "(?)"].forEach(function(s) {
assert.throws(SyntaxError, function() {new RegExp(s)}, s);
});
`
testScriptWithTestLib(SCRIPT, _undefined, t)
}
func TestRegexpLookbehindAssertion(t *testing.T) {
const SCRIPT = `
var re = /(?<=Jack|Tom)Sprat/;
assert(re.test("JackSprat"), "#1");
assert(!re.test("JohnSprat"), "#2");
re = /(?<!-)\d+/;
assert(re.test("3"), "#3");
assert(!re.test("-3"), "#4");
`
testScriptWithTestLib(SCRIPT, _undefined, t)
}
func TestRegexpInvalidUTF8(t *testing.T) {
vm := New()
// Note that normally vm.ToValue() would replace invalid UTF-8 sequences with RuneError
_, err := vm.New(vm.Get("RegExp"), asciiString([]byte{0xAD}))
if err == nil {
t.Fatal("Expected error")
}
}
// this should not cause data races when run with -race
func TestRegexpConcurrentLiterals(t *testing.T) {
prg := MustCompile("test.js", `var r = /(?<!-)\d+/; r.test("");`, false)
go func() {
vm := New()
_, err := vm.RunProgram(prg)
if err != nil {
panic(err)
}
}()
vm := New()
_, _ = vm.RunProgram(prg)
}
func TestRegexpDotAll(t *testing.T) {
const SCRIPT = `
var re = /./s;
re.test("\r") && re.test("\n")
`
testScript(SCRIPT, valueTrue, t)
}
func TestRegexpDotAllInGroup(t *testing.T) {
const SCRIPT = `
var re = /(.)/s;
re.test("\r") && re.test("\n")
`
testScript(SCRIPT, valueTrue, t)
}
func TestRegexpNumSeparators(t *testing.T) {
const SCRIPT = `
const re = /(?<=a)\u{65}_/u;
assert(re.test("ae_") && !re.test("e_"));
assert.throws(SyntaxError, () => {
new RegExp("(?<=a)\\u{6_5}", "u");
});
assert.throws(SyntaxError, () => {
new RegExp("a\\u{6_5}", "u");
});
`
testScriptWithTestLib(SCRIPT, _undefined, t)
}
func TestRegexpUnicodeEscape(t *testing.T) {
const SCRIPT = `
assert.sameValue("u{0_2}".match(/\u{0_2}/)[0], "u{0_2}");
assert.sameValue("uu\x02".match(/\u{2}/u)[0], '\x02');
assert.sameValue("uu\x02".match(/\u{2}/)[0], "uu");
`
testScriptWithTestLib(SCRIPT, _undefined, t)
}
func BenchmarkRegexpSplitWithBackRef(b *testing.B) {
const SCRIPT = `
"aaaaaaaaaaaaaaaaaaaaaaaaa++bbbbbbbbbbbbbbbbbbbbbb+-ccccccccccccccccccccccc".split(/([+-])\1/)
`
b.StopTimer()
prg, err := Compile("test.js", SCRIPT, false)
if err != nil {
b.Fatal(err)
}
vm := New()
b.StartTimer()
for i := 0; i < b.N; i++ {
vm.RunProgram(prg)
}
}
func BenchmarkRegexpMatch(b *testing.B) {
const SCRIPT = `
"a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
".match(/[^\r\n]+/g)
`
b.StopTimer()
prg, err := Compile("test.js", SCRIPT, false)
if err != nil {
b.Fatal(err)
}
vm := New()
b.StartTimer()
for i := 0; i < b.N; i++ {
vm.RunProgram(prg)
}
}
func BenchmarkRegexpMatchCache(b *testing.B) {
const SCRIPT = `
(function() {
var s = "a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
"
var r = /[^\r\n]+/g
while(r.exec(s)) {};
});
`
vm := New()
v, err := vm.RunString(SCRIPT)
if err != nil {
b.Fatal(err)
}
if fn, ok := AssertFunction(v); ok {
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
fn(_undefined)
}
} else {
b.Fatal("not a function")
}
}
func BenchmarkRegexpMatchAll(b *testing.B) {
const SCRIPT = `
(function() {
var s = "a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
a\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\ra\nb\r\c\nd\r\e\n\f\rg\nh\r\
"
var r = /[^\r\n]+/g
for (var v of s.matchAll(r)) {}
});
`
vm := New()
v, err := vm.RunString(SCRIPT)
if err != nil {
b.Fatal(err)
}
if fn, ok := AssertFunction(v); ok {
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
fn(_undefined)
}
} else {
b.Fatal("not a function")
}
}
func BenchmarkRegexpSingleExec(b *testing.B) {
vm := New()
regexp := vm.Get("RegExp")
f := func(reStr, str string, b *testing.B) {
r, err := vm.New(regexp, vm.ToValue(reStr))
if err != nil {
b.Fatal(err)
}
exec, ok := AssertFunction(r.Get("exec"))
if !ok {
b.Fatal("RegExp.exec is not a function")
}
arg := vm.ToValue(str)
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
_, err := exec(r, arg)
if err != nil {
b.Fatal(err)
}
}
}
b.Run("Re-ASCII", func(b *testing.B) {
f("test", "aaaaaaaaaaaaaaaaaaaaaaaaa testing", b)
})
b.Run("Re2-ASCII", func(b *testing.B) {
f("(?=)test", "aaaaaaaaaaaaaaaaaaaaaaaaa testing", b)
})
b.Run("Re-Unicode", func(b *testing.B) {
f("test", "aaaaaaaaaaaaaaaaaaaaaaaaa testing 😀", b)
})
b.Run("Re2-Unicode", func(b *testing.B) {
f("(?=)test", "aaaaaaaaaaaaaaaaaaaaaaaaa testing 😀", b)
})
}
Reference in New Issue Copy Permalink