tyler.durden
/
test262
mirror of https://github.com/tc39/test262.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Make RegExp/CharacterClassEscapes tests faster across all engines

This commit is contained in:
André Bargull 2018-08-17 07:48:42 -07:00
parent 60b9467630
commit 8879820a8f
25 changed files with 199 additions and 364 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
harness/regExpUtils.js
View File

@ -7,17 +7,20 @@ description: |
function buildString({ loneCodePoints, ranges }) {
const CHUNK_SIZE = 10000;
let result = String.fromCodePoint(...loneCodePoints);
for (const [start, end] of ranges) {
let result = Reflect.apply(String.fromCodePoint, null, loneCodePoints);
for (let i = 0; i < ranges.length; i++) {
const range = ranges[i];
const start = range[0];
const end = range[1];
const codePoints = [];
for (let length = 0, codePoint = start; codePoint <= end; codePoint++) {
codePoints[length++] = codePoint;
if (length === CHUNK_SIZE) {
result += String.fromCodePoint(...codePoints);
result += Reflect.apply(String.fromCodePoint, null, codePoints);
codePoints.length = length = 0;
}
}
result += String.fromCodePoint(...codePoints);
result += Reflect.apply(String.fromCodePoint, null, codePoints);
}
return result;
}

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-digit-class-escape-flags-u.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0x10ffff / 0x10000);
for (let codePoint = 0; codePoint < 0x10FFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0x10FFFF]]});
const re = /\d/ug;
const matchingRange = /[0-9]/ug;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-digit-class-escape-plus-quantifier-flags-u.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0x10ffff / 0x10000);
for (let codePoint = 0; codePoint < 0x10FFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0x10FFFF]]});
const re = /\d+/ug;
const matchingRange = /[0-9]+/ug;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-digit-class-escape-plus-quantifier.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0xffff / 0x10000);
for (let codePoint = 0; codePoint < 0xFFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0xFFFF]]});
const re = /\d+/g;
const matchingRange = /[0-9]+/g;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-digit-class-escape.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0xffff / 0x10000);
for (let codePoint = 0; codePoint < 0xFFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0xFFFF]]});
const re = /\d/g;
const matchingRange = /[0-9]/g;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-non-digit-class-escape-flags-u.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0x10ffff / 0x10000);
for (let codePoint = 0; codePoint < 0x10FFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0x10FFFF]]});
const re = /\D/ug;
const matchingRange = /[\0-\/:-\u{10FFFF}]/ug;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-non-digit-class-escape-plus-quantifier-flags-u.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0x10ffff / 0x10000);
for (let codePoint = 0; codePoint < 0x10FFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0x10FFFF]]});
const re = /\D+/ug;
const matchingRange = /[\0-\/:-\u{10FFFF}]+/ug;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-non-digit-class-escape-plus-quantifier.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0xffff / 0x10000);
for (let codePoint = 0; codePoint < 0xFFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0xFFFF]]});
const re = /\D+/g;
const matchingRange = /[\0-\/:-\uFFFF]+/g;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-non-digit-class-escape.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0xffff / 0x10000);
for (let codePoint = 0; codePoint < 0xFFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0xFFFF]]});
const re = /\D/g;
const matchingRange = /[\0-\/:-\uFFFF]/g;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-non-whitespace-class-escape-flags-u.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0x10ffff / 0x10000);
for (let codePoint = 0; codePoint < 0x10FFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0x10FFFF]]});
const re = /\S/ug;
const matchingRange = /[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uFEFE\uFF00-\u{10FFFF}]/ug;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-non-whitespace-class-escape-plus-quantifier-flags-u.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0x10ffff / 0x10000);
for (let codePoint = 0; codePoint < 0x10FFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0x10FFFF]]});
const re = /\S+/ug;
const matchingRange = /[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uFEFE\uFF00-\u{10FFFF}]+/ug;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-non-whitespace-class-escape-plus-quantifier.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0xffff / 0x10000);
for (let codePoint = 0; codePoint < 0xFFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0xFFFF]]});
const re = /\S+/g;
const matchingRange = /[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uFEFE\uFF00-\uFFFF]+/g;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-non-whitespace-class-escape.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0xffff / 0x10000);
for (let codePoint = 0; codePoint < 0xFFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0xFFFF]]});
const re = /\S/g;
const matchingRange = /[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uFEFE\uFF00-\uFFFF]/g;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-non-word-class-escape-flags-u.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0x10ffff / 0x10000);
for (let codePoint = 0; codePoint < 0x10FFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0x10FFFF]]});
const re = /\W/ug;
const matchingRange = /[\0-\/:-@\[-\^`\{-\u{10FFFF}]/ug;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-non-word-class-escape-plus-quantifier-flags-u.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0x10ffff / 0x10000);
for (let codePoint = 0; codePoint < 0x10FFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0x10FFFF]]});
const re = /\W+/ug;
const matchingRange = /[\0-\/:-@\[-\^`\{-\u{10FFFF}]+/ug;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-non-word-class-escape-plus-quantifier.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0xffff / 0x10000);
for (let codePoint = 0; codePoint < 0xFFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0xFFFF]]});
const re = /\W+/g;
const matchingRange = /[\0-\/:-@\[-\^`\{-\uFFFF]+/g;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-non-word-class-escape.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0xffff / 0x10000);
for (let codePoint = 0; codePoint < 0xFFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0xFFFF]]});
const re = /\W/g;
const matchingRange = /[\0-\/:-@\[-\^`\{-\uFFFF]/g;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-whitespace-class-escape-flags-u.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0x10ffff / 0x10000);
for (let codePoint = 0; codePoint < 0x10FFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0x10FFFF]]});
const re = /\s/ug;
const matchingRange = /[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]/ug;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-whitespace-class-escape-plus-quantifier-flags-u.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0x10ffff / 0x10000);
for (let codePoint = 0; codePoint < 0x10FFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0x10FFFF]]});
const re = /\s+/ug;
const matchingRange = /[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+/ug;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-whitespace-class-escape-plus-quantifier.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0xffff / 0x10000);
for (let codePoint = 0; codePoint < 0xFFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0xFFFF]]});
const re = /\s+/g;
const matchingRange = /[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+/g;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-whitespace-class-escape.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0xffff / 0x10000);
for (let codePoint = 0; codePoint < 0xFFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0xFFFF]]});
const re = /\s/g;
const matchingRange = /[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]/g;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-word-class-escape-flags-u.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0x10ffff / 0x10000);
for (let codePoint = 0; codePoint < 0x10FFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0x10FFFF]]});
const re = /\w/ug;
const matchingRange = /[0-9A-Z_a-z]/ug;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-word-class-escape-plus-quantifier-flags-u.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0x10ffff / 0x10000);
for (let codePoint = 0; codePoint < 0x10FFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0x10FFFF]]});
const re = /\w+/ug;
const matchingRange = /[0-9A-Z_a-z]+/ug;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-word-class-escape-plus-quantifier.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0xffff / 0x10000);
for (let codePoint = 0; codePoint < 0xFFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0xFFFF]]});
const re = /\w+/g;
const matchingRange = /[0-9A-Z_a-z]+/g;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,

23
test/built-ins/RegExp/CharacterClassEscapes/character-class-word-class-escape.js
View File

@ -33,15 +33,10 @@ info: |
The production CharacterClassEscape :: W evaluates as follows:
Return the set of all characters not included in the set returned by CharacterClassEscape :: w.
features: [String.fromCodePoint]
includes: [regExpUtils.js]
---*/
const chunks = [];
const totalChunks = Math.ceil(0xffff / 0x10000);
for (let codePoint = 0; codePoint < 0xFFFF; codePoint++) {
// split strings to avoid a super long one;
chunks[codePoint % totalChunks] += String.fromCodePoint(codePoint);
}
const str = buildString({loneCodePoints: [], ranges: [[0, 0xFFFF]]});
const re = /\w/g;
const matchingRange = /[0-9A-Z_a-z]/g;
@ -52,16 +47,14 @@ function matching(str) {
return str.replace(re, '') === str.replace(matchingRange, '');
}
for (const str of chunks) {
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
if (!matching(str)) {
// Error, let's find out where
for (const char of str) {
if (!matching(char)) {
errors.push('0x' + char.codePointAt(0).toString(16));
}
}
};
}
assert.sameValue(
errors.length,