Skip to content

Instantly share code, notes, and snippets.

@anba

anba/dot_unicode.js Secret

Created December 8, 2015 13:22
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save anba/b85b5d0ca4e91dc1ebbc to your computer and use it in GitHub Desktop.
Save anba/b85b5d0ca4e91dc1ebbc to your computer and use it in GitHub Desktop.
Download ZIP
Unicode RegExp tests
Raw
dot_unicode.js
/*
* Copyright (c) 2012-2015 André Bargull
* Alle Rechte vorbehalten / All Rights Reserved. Use is subject to license terms.
*
* <https://github.com/anba/es6draft>
*/
const {
assertFalse, assertTrue
} = Assert;
assertTrue(RegExp("^.$", "u").test("\udbff\udfff"));
assertFalse(RegExp("^..$", "u").test("\udbff\udfff"));
assertFalse(RegExp("^.\\udfff$", "u").test("\udbff\udfff"));
assertFalse(RegExp("^\\udbff.$", "u").test("\udbff\udfff"));
assertTrue(RegExp("^\\udbff\\udfff$", "u").test("\udbff\udfff"));
assertFalse(RegExp("^[\\udbff][\\udfff]$", "u").test("\udbff\udfff"));
Raw
ignorecase_neg_unicode.js
/*
* Copyright (c) 2012-2015 André Bargull
* Alle Rechte vorbehalten / All Rights Reserved. Use is subject to license terms.
*
* <https://github.com/anba/es6draft>
*/
const {
assertSame
} = Assert;
function test(upperCase, lowerCase, plane, {unicode: unicode = false} = {}) {
const upperCaseText = String(upperCase);
const lowerCaseText = String(lowerCase);
const pairs = [
[upperCaseText, upperCase],
[lowerCaseText, lowerCase],
[upperCaseText, lowerCase],
[lowerCaseText, upperCase],
];
for (let flags of plane.flags) {
let ignoreCase = flags.includes("i");
let unicodeCase = flags.includes("u");
if (unicode && ignoreCase && !unicodeCase) {
continue;
}
let expected = ignoreCase ? [false, false, false, false] : [false, false, true, true];
for (let transform of plane.transformers) {
for (let [index, [text, range]] of pairs.entries()) {
let pattern = transform(range);
let re = new RegExp(`^${pattern}$`, flags);
assertSame(expected[index], re.test(text), `${re}.test("${text}")`);
}
}
}
}
// flags and transformers for Supplementary Planes
const supplementary = {
flags: ["u", "ui"],
transformers: [
Transformers.charClass.negated.identity,
Transformers.charClass.negated.toExtendedUnicodeEscape,
]
};
// flags and transformers for Basic Multilingual Plane
const basic = {
flags: [...supplementary.flags],
transformers: [
...supplementary.transformers,
// Transformers.charClass.negated.toIdentityEscape,
Transformers.charClass.negated.toUnicodeEscape,
]
};
// flags and transformers for Basic Latin and Latin-1 Supplement
const latin = {
flags: [...basic.flags],
transformers: [
...basic.transformers,
// Transformers.charClass.negated.toOctalEscape,
Transformers.charClass.negated.toHexEscape,
// Transformers.charClassRange.negated.toOctalEscape,
Transformers.charClassRange.negated.toHexEscape,
]
};
UnicodeCaseFolding(test, {latin, basic, supplementary});
Raw
ignorecase_unicode.js
/*
* Copyright (c) 2012-2015 André Bargull
* Alle Rechte vorbehalten / All Rights Reserved. Use is subject to license terms.
*
* <https://github.com/anba/es6draft>
*/
const {
assertSame
} = Assert;
function test(upperCase, lowerCase, plane, {unicode: unicode = false} = {}) {
const upperCaseText = String(upperCase);
const lowerCaseText = String(lowerCase);
const pairs = [
[upperCaseText, upperCase],
[lowerCaseText, lowerCase],
[upperCaseText, lowerCase],
[lowerCaseText, upperCase],
];
for (let flags of plane.flags) {
let ignoreCase = flags.includes("i");
let unicodeCase = flags.includes("u");
if (unicode && ignoreCase && !unicodeCase) {
continue;
}
let expected = ignoreCase ? [true, true, true, true] : [true, true, false, false];
for (let transform of plane.transformers) {
for (let [index, [text, range]] of pairs.entries()) {
let pattern = transform(range);
let re = new RegExp(`^${pattern}$`, flags);
assertSame(expected[index], re.test(text), `${re}.test("${text}")`);
}
}
}
}
// flags and transformers for Supplementary Planes
const supplementary = {
flags: ["u", "ui"],
transformers: [
Transformers.identity,
Transformers.toExtendedUnicodeEscape,
Transformers.charClass.identity,
Transformers.charClass.toExtendedUnicodeEscape,
Transformers.charClassRange.identity,
Transformers.charClassRange.toExtendedUnicodeEscape,
]
};
// flags and transformers for Basic Multilingual Plane
const basic = {
flags: [...supplementary.flags],
transformers: [
...supplementary.transformers,
// Transformers.toIdentityEscape,
Transformers.toUnicodeEscape,
// Transformers.charClass.toIdentityEscape,
Transformers.charClass.toUnicodeEscape,
// Transformers.charClassRange.toIdentityEscape,
Transformers.charClassRange.toUnicodeEscape,
]
};
// flags and transformers for Basic Latin and Latin-1 Supplement
const latin = {
flags: [...basic.flags],
transformers: [
...basic.transformers,
// Transformers.toOctalEscape,
Transformers.toHexEscape,
// Transformers.charClass.toOctalEscape,
Transformers.charClass.toHexEscape,
// Transformers.charClassRange.toOctalEscape,
Transformers.charClassRange.toHexEscape,
]
};
UnicodeCaseFolding(test, {latin, basic, supplementary});
Raw
ignorecase_unicode_iWithDot.js
/*
* Copyright (c) 2012-2015 André Bargull
* Alle Rechte vorbehalten / All Rights Reserved. Use is subject to license terms.
*
* <https://github.com/anba/es6draft>
*/
const {
assertSame
} = Assert;
// flags and transformers for Supplementary Planes
const supplementary = {
transformers: [
Transformers.identity,
Transformers.toExtendedUnicodeEscape,
Transformers.charClass.identity,
Transformers.charClass.toExtendedUnicodeEscape,
Transformers.charClassRange.identity,
Transformers.charClassRange.toExtendedUnicodeEscape,
]
};
// flags and transformers for Basic Multilingual Plane
const basic = {
transformers: [
...supplementary.transformers,
// Transformers.toIdentityEscape,
Transformers.toUnicodeEscape,
// Transformers.charClass.toIdentityEscape,
Transformers.charClass.toUnicodeEscape,
// Transformers.charClassRange.toIdentityEscape,
Transformers.charClassRange.toUnicodeEscape,
]
};
// flags and transformers for Basic Latin and Latin-1 Supplement
const latin = {
transformers: [
...basic.transformers,
// Transformers.toOctalEscape,
Transformers.toHexEscape,
// Transformers.charClass.toOctalEscape,
Transformers.charClass.toHexEscape,
// Transformers.charClassRange.toOctalEscape,
Transformers.charClassRange.toHexEscape,
]
};
let tests = [
{
char: "\u0049",
plane: latin,
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: false},
],
},
{
char: "\u0069",
plane: latin,
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: false},
]
},
{
char: "\u0130",
plane: basic,
cases: [
{compareTo: "\u0049", expected: false},
{compareTo: "\u0069", expected: false},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: false},
]
},
{
char: "\u0131",
plane: basic,
cases: [
{compareTo: "\u0049", expected: false},
{compareTo: "\u0069", expected: false},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: true},
]
},
];
for (let {char, plane, cases} of tests) {
for (let transform of plane.transformers) {
for (let {compareTo, expected} of cases) {
let pattern = transform(range(char, char));
let re = new RegExp(`${pattern}`, "ui");
assertSame(expected, re.test(compareTo), `${re}.test("${compareTo}")`);
}
}
}
Raw
ignorecase_unicode_iWithDot_backref.js
/*
* Copyright (c) 2012-2015 André Bargull
* Alle Rechte vorbehalten / All Rights Reserved. Use is subject to license terms.
*
* <https://github.com/anba/es6draft>
*/
const {
assertTrue, assertFalse
} = Assert;
let re = /(i)\1/ui;
// \u0130 and \u0131 are not matched in (i)
assertFalse(re.test("\u0130i"));
assertFalse(re.test("\u0131i"));
// \u0130 and \u0131 are not matched in backreference \1
assertFalse(re.test("i\u0130"));
assertFalse(re.test("i\u0131"));
Raw
ignorecase_unicode_iWithDot_range.js
/*
* Copyright (c) 2012-2015 André Bargull
* Alle Rechte vorbehalten / All Rights Reserved. Use is subject to license terms.
*
* <https://github.com/anba/es6draft>
*/
const {
assertSame
} = Assert;
let tests = [
{
range: "\u0049\u0069",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: false},
],
},
{
range: "\u0130\u0131",
cases: [
{compareTo: "\u0049", expected: false},
{compareTo: "\u0069", expected: false},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: true},
]
},
{
range: "\u0130-\u0131",
cases: [
{compareTo: "\u0049", expected: false},
{compareTo: "\u0069", expected: false},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: true},
]
},
{
range: "i\u0130",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: false},
]
},
{
range: "I\u0130",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: false},
]
},
{
range: "i\u0131",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: true},
]
},
{
range: "I\u0131",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: true},
]
},
{
range: "i\u0131\u0130",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: true},
]
},
{
range: "I\u0131\u0130",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: true},
]
},
{
range: "\\w",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: false},
]
},
{
range: "\\W",
cases: [
{compareTo: "\u0049", expected: false},
{compareTo: "\u0069", expected: false},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: true},
]
},
{
range: "a-z",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: false},
]
},
{
range: "A-Z",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: false},
]
},
{
range: "a-zA-Z",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: false},
]
},
{
range: "\u0080-\u{10ffff}",
cases: [
{compareTo: "\u0049", expected: false},
{compareTo: "\u0069", expected: false},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: true},
]
},
];
for (let {range, cases} of tests) {
for (let {compareTo, expected} of cases) {
let re = new RegExp(`^[${range}]$`, "ui");
assertSame(expected, re.test(compareTo), `${re}.test("${compareTo}")`);
let re_neg = new RegExp(`^[^${range}]$`, "ui");
assertSame(!expected, re_neg.test(compareTo), `${re_neg}.test("${compareTo}")`);
}
}
Raw
ignorecase_unicode_neg_iWithDot.js
/*
* Copyright (c) 2012-2015 André Bargull
* Alle Rechte vorbehalten / All Rights Reserved. Use is subject to license terms.
*
* <https://github.com/anba/es6draft>
*/
const {
assertSame
} = Assert;
// flags and transformers for Supplementary Planes
const supplementary = {
transformers: [
Transformers.charClass.negated.identity,
Transformers.charClass.negated.toExtendedUnicodeEscape,
Transformers.charClassRange.negated.identity,
Transformers.charClassRange.negated.toExtendedUnicodeEscape,
]
};
// flags and transformers for Basic Multilingual Plane
const basic = {
transformers: [
...supplementary.transformers,
// Transformers.charClass.negated.toIdentityEscape,
Transformers.charClass.negated.toUnicodeEscape,
// Transformers.charClassRange.negated.toIdentityEscape,
Transformers.charClassRange.negated.toUnicodeEscape,
]
};
// flags and transformers for Basic Latin and Latin-1 Supplement
const latin = {
transformers: [
...basic.transformers,
// Transformers.charClass.negated.toOctalEscape,
Transformers.charClass.negated.toHexEscape,
// Transformers.charClassRange.negated.toOctalEscape,
Transformers.charClassRange.negated.toHexEscape,
]
};
let tests = [
{
char: "\u0049",
plane: latin,
cases: [
{compareTo: "\u0049", expected: false},
{compareTo: "\u0069", expected: false},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: true},
],
},
{
char: "\u0069",
plane: latin,
cases: [
{compareTo: "\u0049", expected: false},
{compareTo: "\u0069", expected: false},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: true},
]
},
{
char: "\u0130",
plane: basic,
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: true},
]
},
{
char: "\u0131",
plane: basic,
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: false},
]
},
];
for (let {char, plane, cases} of tests) {
for (let transform of plane.transformers) {
for (let {compareTo, expected} of cases) {
let pattern = transform(range(char, char));
let re = new RegExp(`${pattern}`, "ui");
assertSame(expected, re.test(compareTo), `${re}.test("${compareTo}")`);
}
}
}
Raw
ignorecase_unicode_sharpS.js
/*
* Copyright (c) 2012-2015 André Bargull
* Alle Rechte vorbehalten / All Rights Reserved. Use is subject to license terms.
*
* <https://github.com/anba/es6draft>
*/
const {
assertTrue, assertFalse
} = Assert;
// Characters where ToUpper(codePoint) == CaseFold(codePoint)
// and exists codePoint2 with:
// codePoint2 != codePoint and CaseFold(codePoint) == CaseFold(codePoint2)
let map = [
["\u00df", "\u1e9e"],
];
for (let [from, to] of map) {
assertTrue(new RegExp(`^${from}$`, "iu").test(to));
assertTrue(new RegExp(`^${to}$`, "iu").test(from));
assertTrue(new RegExp(`^[${from}]$`, "iu").test(to));
assertTrue(new RegExp(`^[${to}]$`, "iu").test(from));
assertFalse(new RegExp(`^[^${from}]$`, "iu").test(to));
assertFalse(new RegExp(`^[^${to}]$`, "iu").test(from));
}
Raw
ignorecase_unicode_word.js
/*
* Copyright (c) 2012-2015 André Bargull
* Alle Rechte vorbehalten / All Rights Reserved. Use is subject to license terms.
*
* <https://github.com/anba/es6draft>
*/
const {
assertSame
} = Assert;
let tests = [
{
pattern: "\\w",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u004B", expected: true},
{compareTo: "\u006B", expected: true},
{compareTo: "\u0053", expected: true},
{compareTo: "\u0073", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: false},
{compareTo: "\u017f", expected: true},
{compareTo: "\u212a", expected: true},
],
},
{
pattern: "\\W",
cases: [
{compareTo: "\u0049", expected: false},
{compareTo: "\u0069", expected: false},
{compareTo: "\u004B", expected: true},
{compareTo: "\u006B", expected: true},
{compareTo: "\u0053", expected: true},
{compareTo: "\u0073", expected: true},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: true},
{compareTo: "\u017f", expected: true},
{compareTo: "\u212a", expected: true},
],
},
{
pattern: "[\\w]",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u004B", expected: true},
{compareTo: "\u006B", expected: true},
{compareTo: "\u0053", expected: true},
{compareTo: "\u0073", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: false},
{compareTo: "\u017f", expected: true},
{compareTo: "\u212a", expected: true},
],
},
{
pattern: "[\\W]",
cases: [
{compareTo: "\u0049", expected: false},
{compareTo: "\u0069", expected: false},
{compareTo: "\u004B", expected: true},
{compareTo: "\u006B", expected: true},
{compareTo: "\u0053", expected: true},
{compareTo: "\u0073", expected: true},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: true},
{compareTo: "\u017f", expected: true},
{compareTo: "\u212a", expected: true},
],
},
{
pattern: "[^\\w]",
cases: [
{compareTo: "\u0049", expected: false},
{compareTo: "\u0069", expected: false},
{compareTo: "\u004B", expected: false},
{compareTo: "\u006B", expected: false},
{compareTo: "\u0053", expected: false},
{compareTo: "\u0073", expected: false},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: true},
{compareTo: "\u017f", expected: false},
{compareTo: "\u212a", expected: false},
],
},
{
pattern: "[^\\W]",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u004B", expected: false},
{compareTo: "\u006B", expected: false},
{compareTo: "\u0053", expected: false},
{compareTo: "\u0073", expected: false},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: false},
{compareTo: "\u017f", expected: false},
{compareTo: "\u212a", expected: false},
],
},
{
pattern: "[a-z]",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u004B", expected: true},
{compareTo: "\u006B", expected: true},
{compareTo: "\u0053", expected: true},
{compareTo: "\u0073", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: false},
{compareTo: "\u017f", expected: true},
{compareTo: "\u212a", expected: true},
],
},
{
pattern: "[A-Z]",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u004B", expected: true},
{compareTo: "\u006B", expected: true},
{compareTo: "\u0053", expected: true},
{compareTo: "\u0073", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: false},
{compareTo: "\u017f", expected: true},
{compareTo: "\u212a", expected: true},
],
},
{
pattern: "[^a-z]",
cases: [
{compareTo: "\u0049", expected: false},
{compareTo: "\u0069", expected: false},
{compareTo: "\u004B", expected: false},
{compareTo: "\u006B", expected: false},
{compareTo: "\u0053", expected: false},
{compareTo: "\u0073", expected: false},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: true},
{compareTo: "\u017f", expected: false},
{compareTo: "\u212a", expected: false},
],
},
{
pattern: "[^A-Z]",
cases: [
{compareTo: "\u0049", expected: false},
{compareTo: "\u0069", expected: false},
{compareTo: "\u004B", expected: false},
{compareTo: "\u006B", expected: false},
{compareTo: "\u0053", expected: false},
{compareTo: "\u0073", expected: false},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: true},
{compareTo: "\u017f", expected: false},
{compareTo: "\u212a", expected: false},
],
},
{
pattern: "[a-zA-Z]",
cases: [
{compareTo: "\u0049", expected: true},
{compareTo: "\u0069", expected: true},
{compareTo: "\u004B", expected: true},
{compareTo: "\u006B", expected: true},
{compareTo: "\u0053", expected: true},
{compareTo: "\u0073", expected: true},
{compareTo: "\u0130", expected: false},
{compareTo: "\u0131", expected: false},
{compareTo: "\u017f", expected: true},
{compareTo: "\u212a", expected: true},
],
},
{
pattern: "[^a-zA-Z]",
cases: [
{compareTo: "\u0049", expected: false},
{compareTo: "\u0069", expected: false},
{compareTo: "\u004B", expected: false},
{compareTo: "\u006B", expected: false},
{compareTo: "\u0053", expected: false},
{compareTo: "\u0073", expected: false},
{compareTo: "\u0130", expected: true},
{compareTo: "\u0131", expected: true},
{compareTo: "\u017f", expected: false},
{compareTo: "\u212a", expected: false},
],
},
];
for (let {pattern, cases} of tests) {
for (let {compareTo, expected} of cases) {
let re = new RegExp(`^${pattern}$`, "ui");
assertSame(expected, re.test(compareTo), `${re}.test("${compareTo}")`);
}
}
Raw
invalid_xunicode_escape.js
/*
* Copyright (c) 2012-2015 André Bargull
* Alle Rechte vorbehalten / All Rights Reserved. Use is subject to license terms.
*
* <https://github.com/anba/es6draft>
*/
const {
assertThrows
} = Assert;
// no lenient error behaviour for invalid extended unicode escape sequences
const values = [
"\\u{",
"\\u{0",
"\\u{f",
"\\u{}",
"\\u{h}",
"\\u{ah}",
"\\u{ha}",
];
for (let v of values) {
assertThrows(SyntaxError, () => RegExp(v, "u"));
}
Raw
mixed_unicode_escape.js
/*
* Copyright (c) 2012-2015 André Bargull
* Alle Rechte vorbehalten / All Rights Reserved. Use is subject to license terms.
*
* <https://github.com/anba/es6draft>
*/
const {
assertTrue, assertFalse
} = Assert;
// surrogate detection for unescaped and escaped code units
assertTrue(RegExp("\ud801\udc00", "u").test("\u{10400}"));
assertTrue(RegExp("\\ud801\\udc00", "u").test("\u{10400}"));
// mixed code units are not treated as a single code point
assertFalse(RegExp("\\ud801\udc00", "u").test("\u{10400}"));
assertFalse(RegExp("\ud801\\udc00", "u").test("\u{10400}"));
Raw
mixed_unicode_escape_range.js
/*
* Copyright (c) 2012-2015 André Bargull
* Alle Rechte vorbehalten / All Rights Reserved. Use is subject to license terms.
*
* <https://github.com/anba/es6draft>
*/
const {
assertTrue
} = Assert;
const values = [
"\\u{10ffff}",
"\u{10ffff}",
"\\udbff\\udfff",
"\udbff\udfff",
];
for (let {start, end} of [for (start of values) for (end of values) {start, end}]) {
assertTrue(new RegExp(`[${start}-${end}]`, "u").test("\u{10ffff}"));
}
Raw
unicode_backref_unpaired_surrogate.js
/*
* Copyright (c) 2012-2015 André Bargull
* Alle Rechte vorbehalten / All Rights Reserved. Use is subject to license terms.
*
* <https://github.com/anba/es6draft>
*/
const {
assertTrue, assertFalse
} = Assert;
// https://mail.mozilla.org/pipermail/es-discuss/2015-January/041281.html
assertTrue(/foo(.+)bar\1/.test("foo\uD834bar\uD834\uDC00"));
assertTrue(/foo(.+)bar\1/i.test("foo\uD834bar\uD834\uDC00"));
assertFalse(/foo(.+)bar\1/u.test("foo\uD834bar\uD834\uDC00"));
assertFalse(/foo(.+)bar\1/ui.test("foo\uD834bar\uD834\uDC00"));
assertTrue(/^(.+)\1$/.test("\uDC00foobar\uD834\uDC00foobar\uD834"));
assertTrue(/^(.+)\1$/i.test("\uDC00foobar\uD834\uDC00foobar\uD834"));
assertFalse(/^(.+)\1$/u.test("\uDC00foobar\uD834\uDC00foobar\uD834"));
assertFalse(/^(.+)\1$/ui.test("\uDC00foobar\uD834\uDC00foobar\uD834"));
Raw
unicode_wordboundary.js
/*
* Copyright (c) 2012-2015 André Bargull
* Alle Rechte vorbehalten / All Rights Reserved. Use is subject to license terms.
*
* <https://github.com/anba/es6draft>
*/
const {
assertTrue, assertFalse
} = Assert;
// 00B5;MICRO SIGN;Ll;
// 00C0;LATIN CAPITAL LETTER A WITH GRAVE;Lu;
// 0660;ARABIC-INDIC DIGIT ZERO;Nd;
// 104A0;OSMANYA DIGIT ZERO;Nd;
// Word boundary detection works correctly in non-unicode mode
assertTrue(/A\b/.test("A\u00B5"));
assertFalse(/A\B/.test("A\u00B5"));
assertTrue(/A\b/.test("A\u00C0"));
assertFalse(/A\B/.test("A\u00C0"));
assertTrue(/A\b/.test("A\u0660"));
assertFalse(/A\B/.test("A\u0660"));
assertTrue(/A\b/.test("A\u{104A0}"));
assertFalse(/A\B/.test("A\u{104A0}"));
// Word boundary detection works correctly in unicode mode
assertTrue(/A\b/u.test("A\u00B5"));
assertFalse(/A\B/u.test("A\u00B5"));
assertTrue(/A\b/u.test("A\u00C0"));
assertFalse(/A\B/u.test("A\u00C0"));
assertTrue(/A\b/u.test("A\u0660"));
assertFalse(/A\B/u.test("A\u0660"));
assertTrue(/A\b/u.test("A\u{104A0}"));
assertFalse(/A\B/u.test("A\u{104A0}"));
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment