diff options
Diffstat (limited to 'js/src/tests/ecma_6/RegExp')
67 files changed, 6346 insertions, 0 deletions
diff --git a/js/src/tests/ecma_6/RegExp/RegExpExec-exec.js b/js/src/tests/ecma_6/RegExp/RegExpExec-exec.js new file mode 100644 index 000000000..e92792fcf --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/RegExpExec-exec.js @@ -0,0 +1,18 @@ +var BUGNUMBER = 887016; +var summary = "RegExpExec should throw if exec property of non-RegExp is not callable"; + +print(BUGNUMBER + ": " + summary); + +for (var exec of [null, 0, false, undefined, ""]) { + // RegExp with non-callable exec + var re = /a/; + re.exec = exec; + RegExp.prototype[Symbol.match].call(re, "foo"); + + // non-RegExp with non-callable exec + assertThrowsInstanceOf(() => RegExp.prototype[Symbol.match].call({ exec }, "foo"), + TypeError); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/RegExpExec-return.js b/js/src/tests/ecma_6/RegExp/RegExpExec-return.js new file mode 100644 index 000000000..1148aac07 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/RegExpExec-return.js @@ -0,0 +1,31 @@ +var BUGNUMBER = 887016; +var summary = "RegExpExec should throw if returned value is not an object nor null."; + +print(BUGNUMBER + ": " + summary); + +for (var ret of [null, {}, [], /a/]) { + assertEq(RegExp.prototype[Symbol.match].call({ + get global() { + return false; + }, + exec(S) { + return ret; + } + }, "foo"), ret); +} + +for (ret of [undefined, 1, true, false, Symbol.iterator]) { + assertThrowsInstanceOf(() => { + RegExp.prototype[Symbol.match].call({ + get global() { + return false; + }, + exec(S) { + return ret; + } + }, "foo"); + }, TypeError); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/browser.js b/js/src/tests/ecma_6/RegExp/browser.js new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/browser.js diff --git a/js/src/tests/ecma_6/RegExp/class-null.js b/js/src/tests/ecma_6/RegExp/class-null.js new file mode 100644 index 000000000..c95e5a4d7 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/class-null.js @@ -0,0 +1,15 @@ +var BUGNUMBER = 1279467; +var summary = "Null in character class in RegExp with unicode flag."; + +print(BUGNUMBER + ": " + summary); + +var m = /([\0]+)/u.exec("\u0000"); +assertEq(m.length, 2); +assertEq(m[0], '\u0000'); +assertEq(m[1], '\u0000'); + +var m = /([\0]+)/u.exec("0"); +assertEq(m, null); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/compile-lastIndex.js b/js/src/tests/ecma_6/RegExp/compile-lastIndex.js new file mode 100644 index 000000000..80c820f43 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/compile-lastIndex.js @@ -0,0 +1,88 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +var BUGNUMBER = 1253099; +var summary = + "RegExp.prototype.compile must perform all its steps *except* setting " + + ".lastIndex, then throw, when provided a RegExp whose .lastIndex has been " + + "made non-writable"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +var regex = /foo/i; + +// Aside from making .lastIndex non-writable, this has two incidental effects +// ubiquitously tested through the remainder of this test: +// +// * RegExp.prototype.compile will do everything it ordinarily does, BUT it +// will throw a TypeError when attempting to zero .lastIndex immediately +// before succeeding overall. +// * RegExp.prototype.test for a non-global and non-sticky regular expression, +// in case of a match, will return true (as normal). BUT if no match is +// found, it will throw a TypeError when attempting to modify .lastIndex. +// +// Ain't it great? +Object.defineProperty(regex, "lastIndex", { value: 42, writable: false }); + +assertEq(regex.global, false); +assertEq(regex.ignoreCase, true); +assertEq(regex.multiline, false); +assertEq(regex.unicode, false); +assertEq(regex.sticky, false); +assertEq(Object.getOwnPropertyDescriptor(regex, "lastIndex").writable, false); +assertEq(regex.lastIndex, 42); + +assertEq(regex.test("foo"), true); +assertEq(regex.test("FOO"), true); +assertThrowsInstanceOf(() => regex.test("bar"), TypeError); +assertThrowsInstanceOf(() => regex.test("BAR"), TypeError); + +assertThrowsInstanceOf(() => regex.compile("bar"), TypeError); + +assertEq(regex.global, false); +assertEq(regex.ignoreCase, false); +assertEq(regex.multiline, false); +assertEq(regex.unicode, false); +assertEq(regex.sticky, false); +assertEq(Object.getOwnPropertyDescriptor(regex, "lastIndex").writable, false); +assertEq(regex.lastIndex, 42); +assertThrowsInstanceOf(() => regex.test("foo"), TypeError); +assertThrowsInstanceOf(() => regex.test("FOO"), TypeError); +assertEq(regex.test("bar"), true); +assertThrowsInstanceOf(() => regex.test("BAR"), TypeError); + +assertThrowsInstanceOf(() => regex.compile("^baz", "m"), TypeError); + +assertEq(regex.global, false); +assertEq(regex.ignoreCase, false); +assertEq(regex.multiline, true); +assertEq(regex.unicode, false); +assertEq(regex.sticky, false); +assertEq(Object.getOwnPropertyDescriptor(regex, "lastIndex").writable, false); +assertEq(regex.lastIndex, 42); +assertThrowsInstanceOf(() => regex.test("foo"), TypeError); +assertThrowsInstanceOf(() => regex.test("FOO"), TypeError); +assertThrowsInstanceOf(() => regex.test("bar"), TypeError); +assertThrowsInstanceOf(() => regex.test("BAR"), TypeError); +assertEq(regex.test("baz"), true); +assertThrowsInstanceOf(() => regex.test("BAZ"), TypeError); +assertThrowsInstanceOf(() => regex.test("012345678901234567890123456789012345678901baz"), + TypeError); +assertEq(regex.test("012345678901234567890123456789012345678901\nbaz"), true); +assertThrowsInstanceOf(() => regex.test("012345678901234567890123456789012345678901BAZ"), + TypeError); +assertThrowsInstanceOf(() => regex.test("012345678901234567890123456789012345678901\nBAZ"), + TypeError); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/ecma_6/RegExp/constructor-IsRegExp.js b/js/src/tests/ecma_6/RegExp/constructor-IsRegExp.js new file mode 100644 index 000000000..8c735e4b9 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/constructor-IsRegExp.js @@ -0,0 +1,86 @@ +var BUGNUMBER = 1147817; +var summary = "RegExp constructor with pattern with @@match."; + +print(BUGNUMBER + ": " + summary); + +var matchValue; +var constructorValue; + +var matchGet; +var constructorGet; +var sourceGet; +var flagsGet; +function reset() { + matchGet = false; + constructorGet = false; + sourceGet = false; + flagsGet = false; +} +var obj = { + get [Symbol.match]() { + matchGet = true; + return matchValue; + }, + get constructor() { + constructorGet = true; + return constructorValue; + }, + get source() { + sourceGet = true; + return "foo"; + }, + get flags() { + flagsGet = true; + return "i"; + }, + toString() { + return "bar"; + } +}; + +matchValue = true; +constructorValue = function() {}; + +reset(); +assertEq(RegExp(obj).toString(), "/foo/i"); +assertEq(matchGet, true); +assertEq(constructorGet, true); +assertEq(sourceGet, true); +assertEq(flagsGet, true); + +reset(); +assertEq(RegExp(obj, "g").toString(), "/foo/g"); +assertEq(matchGet, true); +assertEq(constructorGet, false); +assertEq(sourceGet, true); +assertEq(flagsGet, false); + +matchValue = false; +constructorValue = function() {}; + +reset(); +assertEq(RegExp(obj).toString(), "/bar/"); +assertEq(matchGet, true); +assertEq(constructorGet, false); +assertEq(sourceGet, false); +assertEq(flagsGet, false); + +reset(); +assertEq(RegExp(obj, "g").toString(), "/bar/g"); +assertEq(matchGet, true); +assertEq(constructorGet, false); +assertEq(sourceGet, false); +assertEq(flagsGet, false); + +matchValue = true; +constructorValue = RegExp; + +reset(); +assertEq(RegExp(obj), obj); +assertEq(matchGet, true); +assertEq(constructorGet, true); +assertEq(sourceGet, false); +assertEq(flagsGet, false); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/constructor-constructor.js b/js/src/tests/ecma_6/RegExp/constructor-constructor.js new file mode 100644 index 000000000..528f4978c --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/constructor-constructor.js @@ -0,0 +1,78 @@ +var BUGNUMBER = 1147817; +var summary = "RegExp constructor should check pattern.constructor."; + +print(BUGNUMBER + ": " + summary); + +var g = newGlobal(); + +var re = /foo/; +assertEq(RegExp(re), re); +re.constructor = 10; +assertEq(RegExp(re) === re, false); +assertEq(RegExp(re).toString(), re.toString()); + +// If pattern comes from different global, RegExp shouldn't return it. +re = g.eval(`var re = /foo/; re;`); +assertEq(RegExp(re) === re, false); +assertEq(RegExp(re).toString(), re.toString()); +g.eval(`re.constructor = 10;`); +assertEq(RegExp(re) === re, false); +assertEq(RegExp(re).toString(), re.toString()); + + +re = new Proxy(/a/, { + get(that, name) { + return that[name]; + } +}); +assertEq(RegExp(re), re); +re = new Proxy(/a/, { + get(that, name) { + if (name == "constructor") { + return function() {}; + } + return that[name]; + } +}); +assertEq(RegExp(re) === re, false); +re = new Proxy(/a/, { + get(that, name) { + if (name == Symbol.match) { + return undefined; + } + return that[name]; + } +}); +assertEq(RegExp(re) === re, false); + +re = new Proxy(g.eval(`/a/`), { + get(that, name) { + return that[name]; + } +}); +assertEq(RegExp(re) === re, false); + +re = g.eval(`new Proxy(/a/, { + get(that, name) { + return that[name]; + } +});`); +assertEq(RegExp(re) === re, false); + + +var obj = { [Symbol.match]: true, source: "foo", flags: "gi" }; +assertEq(RegExp(obj) === obj, false); +assertEq(RegExp(obj).toString(), "/foo/gi"); +obj.constructor = RegExp; +assertEq(RegExp(obj), obj); + +obj = g.eval(`var obj = { [Symbol.match]: true, source: "foo", flags: "gi" }; obj;`); +assertEq(RegExp(obj) === obj, false); +assertEq(RegExp(obj).toString(), "/foo/gi"); +g.eval(`obj.constructor = RegExp`); +assertEq(RegExp(obj) === obj, false); +obj.constructor = RegExp; +assertEq(RegExp(obj), obj); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/constructor-ordering-2.js b/js/src/tests/ecma_6/RegExp/constructor-ordering-2.js new file mode 100644 index 000000000..21a6bbeca --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/constructor-ordering-2.js @@ -0,0 +1,21 @@ +// Make sure that we don't ToString the second argument until /after/ doing +// the appropriate subclassing lookups + +var didLookup = false; + +var re = /a/; +var flags = { toString() { assertEq(didLookup, true); return "g"; } }; +var newRe = Reflect.construct(RegExp, [re, flags], + Object.defineProperty(function(){}.bind(null), "prototype", { + get() { + didLookup = true; + return RegExp.prototype; + } +})); + +assertEq(Object.getPrototypeOf(newRe), RegExp.prototype); +assertEq(didLookup, true); + + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/ecma_6/RegExp/constructor-ordering.js b/js/src/tests/ecma_6/RegExp/constructor-ordering.js new file mode 100644 index 000000000..3e3a9b695 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/constructor-ordering.js @@ -0,0 +1,16 @@ +// Make sure that we don't misorder subclassing accesses with respect to +// accessing regex arg internal slots +// +// Test credit André Bargull. + +var re = /a/; +var newRe = Reflect.construct(RegExp, [re], Object.defineProperty(function(){}.bind(null), "prototype", { + get() { + re.compile("b"); + return RegExp.prototype; + } +})); +assertEq(newRe.source, "a"); + +if (typeof reportCompare === 'function') + reportCompare(0,0,"OK"); diff --git a/js/src/tests/ecma_6/RegExp/constructor-regexp-unicode.js b/js/src/tests/ecma_6/RegExp/constructor-regexp-unicode.js new file mode 100644 index 000000000..b348c34a0 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/constructor-regexp-unicode.js @@ -0,0 +1,9 @@ +var BUGNUMBER = 1274393; +var summary = "RegExp constructor should check the pattern syntax again when adding unicode flag."; + +print(BUGNUMBER + ": " + summary); + +assertThrowsInstanceOf(() => RegExp(/\-/, "u"), SyntaxError); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/constructor-regexp.js b/js/src/tests/ecma_6/RegExp/constructor-regexp.js new file mode 100644 index 000000000..419b02713 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/constructor-regexp.js @@ -0,0 +1,61 @@ +var BUGNUMBER = 1130860; +var summary = "RegExp constructor shouldn't invoke source/flags getters on argument RegExp instance."; + +print(BUGNUMBER + ": " + summary); + +// same-compartment +var a = /foo/; +var flagsCalled = false; +var sourceCalled = false; +Object.defineProperty(a, "source", { get: () => { + sourceCalled = true; + return "bar"; +}}); +Object.defineProperty(a, "flags", { get: () => { + flagsCalled = true; + return "i"; +}}); + +assertEq(a.source, "bar"); +assertEq(a.flags, "i"); +assertEq(sourceCalled, true); +assertEq(flagsCalled, true); + +sourceCalled = false; +flagsCalled = false; +assertEq(new RegExp(a).source, "foo"); +assertEq(sourceCalled, false); +assertEq(flagsCalled, false); + +// cross-compartment +var g = newGlobal(); +var b = g.eval(` +var b = /foo2/; +var flagsCalled = false; +var sourceCalled = false; +Object.defineProperty(b, "source", { get: () => { + sourceCalled = true; + return "bar2"; +}}); +Object.defineProperty(b, "flags", { get: () => { + flagsCalled = true; + return "i"; +}}); +b; +`); + +assertEq(b.source, "bar2"); +assertEq(b.flags, "i"); +assertEq(g.eval("sourceCalled;"), true); +assertEq(g.eval("flagsCalled;"), true); + +g.eval(` +sourceCalled = false; +flagsCalled = false; +`); +assertEq(new RegExp(b).source, "foo2"); +assertEq(g.eval("sourceCalled;"), false); +assertEq(g.eval("flagsCalled;"), false); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/descriptor.js b/js/src/tests/ecma_6/RegExp/descriptor.js new file mode 100644 index 000000000..cc545b3a6 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/descriptor.js @@ -0,0 +1,25 @@ +var BUGNUMBER = 1120169; +var summary = "Implement RegExp.prototype.{global, ignoreCase, multiline, sticky, unicode} - property descriptor"; + +print(BUGNUMBER + ": " + summary); + +var getters = [ + "flags", + "global", + "ignoreCase", + "multiline", + "source", + "sticky", + "unicode", +]; + +for (var name of getters) { + var desc = Object.getOwnPropertyDescriptor(RegExp.prototype, name); + assertEq(desc.configurable, true); + assertEq(desc.enumerable, false); + assertEq("writable" in desc, false); + assertEq("get" in desc, true); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/escape.js b/js/src/tests/ecma_6/RegExp/escape.js new file mode 100644 index 000000000..bb59b797d --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/escape.js @@ -0,0 +1,70 @@ +var BUGNUMBER = 1130860; +var summary = 'Slash and LineTerminator should be escaped correctly.'; + +print(BUGNUMBER + ": " + summary); + +function test(re, source) { + assertEq(re.source, source); + assertEq(eval("/" + re.source + "/").source, source); + assertEq(re.toString(), "/" + source + "/"); +} + +test(/\\n/, "\\\\n"); +test(/\\\n/, "\\\\\\n"); +test(/\\\\n/, "\\\\\\\\n"); +test(RegExp("\\n"), "\\n"); +test(RegExp("\\\n"), "\\n"); +test(RegExp("\\\\n"), "\\\\n"); + +test(/\\r/, "\\\\r"); +test(/\\\r/, "\\\\\\r"); +test(/\\\\r/, "\\\\\\\\r"); +test(RegExp("\\r"), "\\r"); +test(RegExp("\\\r"), "\\r"); +test(RegExp("\\\\r"), "\\\\r"); + +test(/\\u2028/, "\\\\u2028"); +test(/\\\u2028/, "\\\\\\u2028"); +test(/\\\\u2028/, "\\\\\\\\u2028"); +test(RegExp("\\u2028"), "\\u2028"); +test(RegExp("\\\u2028"), "\\u2028"); +test(RegExp("\\\\u2028"), "\\\\u2028"); + +test(/\\u2029/, "\\\\u2029"); +test(/\\\u2029/, "\\\\\\u2029"); +test(/\\\\u2029/, "\\\\\\\\u2029"); +test(RegExp("\\u2029"), "\\u2029"); +test(RegExp("\\\u2029"), "\\u2029"); +test(RegExp("\\\\u2029"), "\\\\u2029"); + +test(/\//, "\\/"); +test(/\\\//, "\\\\\\/"); +test(RegExp("/"), "\\/"); +test(RegExp("\/"), "\\/"); +test(RegExp("\\/"), "\\/"); +test(RegExp("\\\/"), "\\/"); +test(RegExp("\\\\/"), "\\\\\\/"); + +test(/[/]/, "[/]"); +test(/[\/]/, "[\\/]"); +test(/[\\/]/, "[\\\\/]"); +test(/[\\\/]/, "[\\\\\\/]"); +test(RegExp("[/]"), "[/]"); +test(RegExp("[\/]"), "[/]"); +test(RegExp("[\\/]"), "[\\/]"); +test(RegExp("[\\\/]"), "[\\/]"); +test(RegExp("[\\\\/]"), "[\\\\/]"); + +test(RegExp("\[/\]"), "[/]"); +test(RegExp("\[\\/\]"), "[\\/]"); + +test(/\[\/\]/, "\\[\\/\\]"); +test(/\[\\\/\]/, "\\[\\\\\\/\\]"); +test(RegExp("\\[/\\]"), "\\[\\/\\]"); +test(RegExp("\\[\/\\]"), "\\[\\/\\]"); +test(RegExp("\\[\\/\\]"), "\\[\\/\\]"); +test(RegExp("\\[\\\/\\]"), "\\[\\/\\]"); +test(RegExp("\\[\\\\/\\]"), "\\[\\\\\\/\\]"); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/exec-lastIndex-negative.js b/js/src/tests/ecma_6/RegExp/exec-lastIndex-negative.js new file mode 100644 index 000000000..18eb2ab9d --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/exec-lastIndex-negative.js @@ -0,0 +1,27 @@ +var BUGNUMBER = 1207922; +var summary = "negative lastIndex should be treated as 0."; + +print(BUGNUMBER + ": " + summary); + +var pattern = /abc/gi; +var string = 'AbcaBcabC'; + +var indices = [ + -1, + -Math.pow(2,32), + -(Math.pow(2,32) + 1), + -Math.pow(2,32) * 2, + -Math.pow(2,40), + -Number.MAX_VALUE, +]; +for (var index of indices) { + pattern.lastIndex = index; + var result = pattern.exec(string); + assertEq(result.index, 0); + assertEq(result.length, 1); + assertEq(result[0], "Abc"); + assertEq(pattern.lastIndex, 3); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/flag-accessors.js b/js/src/tests/ecma_6/RegExp/flag-accessors.js new file mode 100644 index 000000000..848b916c5 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/flag-accessors.js @@ -0,0 +1,49 @@ +var BUGNUMBER = 1120169; +var summary = "Implement RegExp.prototype.{global, ignoreCase, multiline, sticky, unicode}"; + +print(BUGNUMBER + ": " + summary); + +var props = [ + "global", + "ignoreCase", + "multiline", + "sticky", + "unicode", +]; + +testThrows(RegExp.prototype); +test(/foo/iymg, [true, true, true, true, false]); +test(RegExp(""), [false, false, false, false, false]); +test(RegExp("", "mygi"), [true, true, true, true, false]); +test(RegExp("", "mygiu"), [true, true, true, true, true]); + +testThrowsGeneric(); +testThrowsGeneric(1); +testThrowsGeneric(""); +testThrowsGeneric({}); +testThrowsGeneric(new Proxy({}, {get(){ return true; }})); + +function test(obj, expects) { + for (var i = 0; i < props.length; i++) { + assertEq(obj[props[i]], expects[i]); + } +} + +function testThrows(obj) { + for (var prop of props) { + assertThrowsInstanceOf(obj[prop], TypeError); + } +} + +function testThrowsGeneric(obj) { + for (var prop of props) { + assertThrowsInstanceOf(() => genericGet(obj, prop), TypeError); + } +} + +function genericGet(obj, prop) { + return Object.getOwnPropertyDescriptor(RegExp.prototype, prop).get.call(obj); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/flags-param-handling.js b/js/src/tests/ecma_6/RegExp/flags-param-handling.js new file mode 100644 index 000000000..e47799601 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/flags-param-handling.js @@ -0,0 +1,18 @@ +assertEq(RegExp(/foo/my).flags, "my"); +assertEq(RegExp(/foo/, "gi").flags, "gi"); +assertEq(RegExp(/foo/my, "gi").flags, "gi"); +assertEq(RegExp(/foo/my, "").flags, ""); +assertEq(RegExp(/foo/my, undefined).flags, "my"); +assertThrowsInstanceOf(() => RegExp(/foo/my, null), SyntaxError); +assertThrowsInstanceOf(() => RegExp(/foo/my, "foo"), SyntaxError); + +assertEq(/a/.compile("b", "gi").flags, "gi"); +assertEq(/a/.compile(/b/my).flags, "my"); +assertEq(/a/.compile(/b/my, undefined).flags, "my"); +assertThrowsInstanceOf(() => /a/.compile(/b/my, "gi"), TypeError); +assertThrowsInstanceOf(() => /a/.compile(/b/my, ""), TypeError); +assertThrowsInstanceOf(() => /a/.compile(/b/my, null), TypeError); +assertThrowsInstanceOf(() => /a/.compile(/b/my, "foo"), TypeError); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/flags.js b/js/src/tests/ecma_6/RegExp/flags.js new file mode 100644 index 000000000..292fa4f3f --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/flags.js @@ -0,0 +1,26 @@ +var BUGNUMBER = 1108467; +var summary = "Implement RegExp.prototype.flags"; + +print(BUGNUMBER + ": " + summary); + +assertEq(RegExp.prototype.flags, ""); +assertEq(/foo/iymg.flags, "gimy"); +assertEq(RegExp("").flags, ""); +assertEq(RegExp("", "mygi").flags, "gimy"); +assertEq(RegExp("", "mygui").flags, "gimuy"); +assertEq(genericFlags({}), ""); +assertEq(genericFlags({ignoreCase: true}), "i"); +assertEq(genericFlags({sticky:1, unicode:1, global: 0}), "uy"); +assertEq(genericFlags({__proto__: {multiline: true}}), "m"); +assertEq(genericFlags(new Proxy({}, {get(){return true}})), "gimuy"); + +assertThrowsInstanceOf(() => genericFlags(), TypeError); +assertThrowsInstanceOf(() => genericFlags(1), TypeError); +assertThrowsInstanceOf(() => genericFlags(""), TypeError); + +function genericFlags(obj) { + return Object.getOwnPropertyDescriptor(RegExp.prototype,"flags").get.call(obj); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/getter-name.js b/js/src/tests/ecma_6/RegExp/getter-name.js new file mode 100644 index 000000000..d0a413dbc --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/getter-name.js @@ -0,0 +1,16 @@ +var BUGNUMBER = 1180290; +var summary = 'RegExp getters should have get prefix'; + +print(BUGNUMBER + ": " + summary); + +assertEq(Object.getOwnPropertyDescriptor(RegExp, Symbol.species).get.name, "get [Symbol.species]"); +assertEq(Object.getOwnPropertyDescriptor(RegExp.prototype, "flags").get.name, "get flags"); +assertEq(Object.getOwnPropertyDescriptor(RegExp.prototype, "global").get.name, "get global"); +assertEq(Object.getOwnPropertyDescriptor(RegExp.prototype, "ignoreCase").get.name, "get ignoreCase"); +assertEq(Object.getOwnPropertyDescriptor(RegExp.prototype, "multiline").get.name, "get multiline"); +assertEq(Object.getOwnPropertyDescriptor(RegExp.prototype, "source").get.name, "get source"); +assertEq(Object.getOwnPropertyDescriptor(RegExp.prototype, "sticky").get.name, "get sticky"); +assertEq(Object.getOwnPropertyDescriptor(RegExp.prototype, "unicode").get.name, "get unicode"); + +if (typeof reportCompare === 'function') + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/ignoreCase-multiple.js b/js/src/tests/ecma_6/RegExp/ignoreCase-multiple.js new file mode 100644 index 000000000..e52cf499b --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/ignoreCase-multiple.js @@ -0,0 +1,71 @@ +var BUGNUMBER = 1280046; +var summary = "ignoreCase match should perform Canonicalize both on input and pattern."; + +print(BUGNUMBER + ": " + summary); + +// Each element [code1, upper, code2] satisfies the following condition: +// ToUpperCase(code1) == upper +// ToUpperCase(code2) == upper +var pairs = + [ + // U+00B5: MICRO SIGN + // U+039C: GREEK CAPITAL LETTER MU + // U+03BC: GREEK SMALL LETTER MU + ["\u00B5", "\u039C", "\u03BC"], + // U+0345: COMBINING GREEK YPOGEGRAMMENI + // U+0399: GREEK CAPITAL LETTER IOTA + // U+03B9: GREEK SMALL LETTER IOTA + ["\u0345", "\u0399", "\u03B9"], + // U+03C2: GREEK SMALL LETTER FINAL SIGMA + // U+03A3: GREEK CAPITAL LETTER SIGMA + // U+03C3: GREEK SMALL LETTER SIGMA + ["\u03C2", "\u03A3", "\u03C3"], + // U+03D0: GREEK BETA SYMBOL + // U+0392: GREEK CAPITAL LETTER BETA + // U+03B2: GREEK SMALL LETTER BETA + ["\u03D0", "\u0392", "\u03B2"], + // U+03D1: GREEK THETA SYMBOL + // U+0398: GREEK CAPITAL LETTER THETA + // U+03B8: GREEK SMALL LETTER THETA + ["\u03D1", "\u0398", "\u03B8"], + // U+03D5: GREEK PHI SYMBOL + // U+03A6: GREEK CAPITAL LETTER PHI + // U+03C6: GREEK SMALL LETTER PHI + ["\u03D5", "\u03A6", "\u03C6"], + // U+03D6: GREEK PI SYMBOL + // U+03A0: GREEK CAPITAL LETTER PI + // U+03C0: GREEK SMALL LETTER PI + ["\u03D6", "\u03A0", "\u03C0"], + // U+03F0: GREEK KAPPA SYMBOL + // U+039A: GREEK CAPITAL LETTER KAPPA + // U+03BA: GREEK SMALL LETTER KAPPA + ["\u03F0", "\u039A", "\u03BA"], + // U+03F1: GREEK RHO SYMBOL + // U+03A1: GREEK CAPITAL LETTER RHO + // U+03C1: GREEK SMALL LETTER RHO + ["\u03F1", "\u03A1", "\u03C1"], + // U+03F5: GREEK LUNATE EPSILON SYMBOL + // U+0395: GREEK CAPITAL LETTER EPSILON + // U+03B5: GREEK SMALL LETTER EPSILON + ["\u03F5", "\u0395", "\u03B5"], + // U+1E9B: LATIN SMALL LETTER LONG S WITH DOT ABOVE + // U+1E60: LATIN CAPITAL LETTER S WITH DOT ABOVE + // U+1E61: LATIN SMALL LETTER S WITH DOT ABOVE + ["\u1E9B", "\u1E60", "\u1E61"], + // U+1FBE: GREEK PROSGEGRAMMENI + // U+0399: GREEK CAPITAL LETTER IOTA + // U+03B9: GREEK SMALL LETTER IOTA + ["\u1FBE", "\u0399", "\u03B9"], + ]; + +for (var [code1, upper, code2] of pairs) { + assertEq(new RegExp(code1, "i").test(code2), true); + assertEq(new RegExp(code1, "i").test(upper), true); + assertEq(new RegExp(upper, "i").test(code1), true); + assertEq(new RegExp(upper, "i").test(code2), true); + assertEq(new RegExp(code2, "i").test(code1), true); + assertEq(new RegExp(code2, "i").test(upper), true); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/lastIndex-nonwritable.js b/js/src/tests/ecma_6/RegExp/lastIndex-nonwritable.js new file mode 100644 index 000000000..3c867f953 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/lastIndex-nonwritable.js @@ -0,0 +1,27 @@ +var BUGNUMBER = 1168416; +var summary = "Regexp.prototype.test/exec shouldn't change lastIndex if not writable."; + +print(BUGNUMBER + ": " + summary); + +var regex = /0/g; +Object.freeze(regex); +var str = "abc000"; + +var desc = Object.getOwnPropertyDescriptor(regex, "lastIndex"); +assertEq(desc.writable, false); +assertEq(desc.value, 0); + +assertThrowsInstanceOf(() => regex.test(str), TypeError); + +desc = Object.getOwnPropertyDescriptor(regex, "lastIndex"); +assertEq(desc.writable, false); +assertEq(desc.value, 0); + +assertThrowsInstanceOf(() => regex.exec(str), TypeError); + +desc = Object.getOwnPropertyDescriptor(regex, "lastIndex"); +assertEq(desc.writable, false); +assertEq(desc.value, 0); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/match-this.js b/js/src/tests/ecma_6/RegExp/match-this.js new file mode 100644 index 000000000..ee05462f2 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/match-this.js @@ -0,0 +1,12 @@ +var BUGNUMBER = 887016; +var summary = "RegExp.prototype[@@match] should check this value."; + +print(BUGNUMBER + ": " + summary); + +for (var v of [null, 1, true, undefined, "", Symbol.iterator]) { + assertThrowsInstanceOf(() => RegExp.prototype[Symbol.match].call(v), + TypeError); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/match-trace.js b/js/src/tests/ecma_6/RegExp/match-trace.js new file mode 100644 index 000000000..3216db641 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/match-trace.js @@ -0,0 +1,147 @@ +var BUGNUMBER = 887016; +var summary = "Trace RegExp.prototype[@@match] behavior."; + +print(BUGNUMBER + ": " + summary); + +var n; +var log; +var target; +var global; +var unicode; +var logProxy; + +var execResult; +var lastIndexResult; +var lastIndexExpected; + +function P(A) { + return new Proxy(A, { + get(that, name) { + if (logProxy) + log += "get:result[" + name + "],"; + return that[name]; + } + }); +} + +var myRegExp = { + get global() { + log += "get:global,"; + return global; + }, + get lastIndex() { + log += "get:lastIndex,"; + return lastIndexResult[n]; + }, + set lastIndex(v) { + log += "set:lastIndex,"; + assertEq(v, lastIndexExpected[n]); + }, + get unicode() { + log += "get:unicode,"; + return unicode; + }, + get exec() { + log += "get:exec,"; + return function(S) { + log += "call:exec,"; + assertEq(S, target); + return execResult[n++]; + }; + }, +}; + +function reset() { + n = 0; + log = ""; + target = "abcAbcABC"; + global = true; + unicode = false; + logProxy = true; +} + +// Trace global with non-empty match. +reset(); +execResult = [ P(["abc"]), P(["ABC"]), null ]; +lastIndexResult = [ , , , ]; +lastIndexExpected = [ 0, , , ]; +var ret = RegExp.prototype[Symbol.match].call(myRegExp, target); +assertEq(JSON.stringify(ret), `["abc","ABC"]`); +assertEq(log, + "get:global," + + "get:unicode," + + "set:lastIndex," + + "get:exec,call:exec,get:result[0]," + + "get:exec,call:exec,get:result[0]," + + "get:exec,call:exec,"); + +// Trace global with empty match. +reset(); +execResult = [ P([""]), P([""]), null ]; +lastIndexResult = [ , 4, 20, ]; +lastIndexExpected = [ 0, 5, 21, ]; +ret = RegExp.prototype[Symbol.match].call(myRegExp, target); +assertEq(JSON.stringify(ret), `["",""]`); +assertEq(log, + "get:global," + + "get:unicode," + + "set:lastIndex," + + "get:exec,call:exec,get:result[0],get:lastIndex,set:lastIndex," + + "get:exec,call:exec,get:result[0],get:lastIndex,set:lastIndex," + + "get:exec,call:exec,"); + +// Trace global and unicode with empty match. +// 1. not surrogate pair +// 2. lead surrogate pair +// 3. trail surrogate pair +// 4. lead surrogate pair without trail surrogate pair +// 5. index overflow +reset(); +unicode = true; +// 0123 4 5678 +target = "___\uD83D\uDC38___\uD83D"; +execResult = [ P([""]), P([""]), P([""]), P([""]), P([""]), null ]; +lastIndexResult = [ , 2, 3, 4, 8, 9, ]; +lastIndexExpected = [ 0, 3, 5, 5, 9, 10, ]; +ret = RegExp.prototype[Symbol.match].call(myRegExp, target); +assertEq(JSON.stringify(ret), `["","","","",""]`); +assertEq(log, + "get:global," + + "get:unicode," + + "set:lastIndex," + + "get:exec,call:exec,get:result[0],get:lastIndex,set:lastIndex," + + "get:exec,call:exec,get:result[0],get:lastIndex,set:lastIndex," + + "get:exec,call:exec,get:result[0],get:lastIndex,set:lastIndex," + + "get:exec,call:exec,get:result[0],get:lastIndex,set:lastIndex," + + "get:exec,call:exec,get:result[0],get:lastIndex,set:lastIndex," + + "get:exec,call:exec,"); + +// Trace global with no match. +reset(); +execResult = [ null ]; +lastIndexResult = [ , ]; +lastIndexExpected = [ 0, ]; +ret = RegExp.prototype[Symbol.match].call(myRegExp, target); +assertEq(ret, null); +assertEq(log, + "get:global," + + "get:unicode," + + "set:lastIndex," + + "get:exec,call:exec,"); + +// Trace non-global. +reset(); +global = false; +execResult = [ P(["abc"]) ]; +lastIndexResult = []; +lastIndexExpected = []; +ret = RegExp.prototype[Symbol.match].call(myRegExp, target); +// ret is the Proxy on non-global case, disable logging. +logProxy = false; +assertEq(JSON.stringify(ret), `["abc"]`); +assertEq(log, + "get:global," + + "get:exec,call:exec,"); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/match.js b/js/src/tests/ecma_6/RegExp/match.js new file mode 100644 index 000000000..06308b2d6 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/match.js @@ -0,0 +1,36 @@ +var BUGNUMBER = 887016; +var summary = "Implement RegExp.prototype[@@match]."; + +print(BUGNUMBER + ": " + summary); + +assertEq(RegExp.prototype[Symbol.match].name, "[Symbol.match]"); +assertEq(RegExp.prototype[Symbol.match].length, 1); +var desc = Object.getOwnPropertyDescriptor(RegExp.prototype, Symbol.match); +assertEq(desc.configurable, true); +assertEq(desc.enumerable, false); +assertEq(desc.writable, true); + +var re = /a/; +var v = re[Symbol.match]("abcAbcABC"); +assertEq(Array.isArray(v), true); +assertEq(v.length, 1); +assertEq(v[0], "a"); + +re = /d/; +v = re[Symbol.match]("abcAbcABC"); +assertEq(v, null); + +re = /a/ig; +v = re[Symbol.match]("abcAbcABC"); +assertEq(Array.isArray(v), true); +assertEq(v.length, 3); +assertEq(v[0], "a"); +assertEq(v[1], "A"); +assertEq(v[2], "A"); + +re = /d/g; +v = re[Symbol.match]("abcAbcABC"); +assertEq(v, null); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/replace-compile.js b/js/src/tests/ecma_6/RegExp/replace-compile.js new file mode 100644 index 000000000..45359037a --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/replace-compile.js @@ -0,0 +1,21 @@ +var BUGNUMBER = 1287524; +var summary = 'RegExp.prototype[@@replace] should call replacer function after collecting all matches.'; + +print(BUGNUMBER + ": " + summary); + +var rx = RegExp("a", "g"); +var r = rx[Symbol.replace]("abba", function() { + rx.compile("b", "g"); + return "?"; +}); +assertEq(r, "?bb?"); + +rx = RegExp("a", "g"); +r = "abba".replace(rx, function() { + rx.compile("b", "g"); + return "?"; +}); +assertEq(r, "?bb?"); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/replace-global-unicode.js b/js/src/tests/ecma_6/RegExp/replace-global-unicode.js new file mode 100644 index 000000000..80b3ea199 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/replace-global-unicode.js @@ -0,0 +1,18 @@ +var BUGNUMBER = 1287524; +var summary = 'RegExp.prototype[@@replace] should not use optimized path if RegExp.prototype.unicode is modified.'; + +print(BUGNUMBER + ": " + summary); + +Object.defineProperty(RegExp.prototype, "unicode", { + get() { + RegExp.prototype.exec = () => null; + } +}); + +var rx = RegExp("a", "g"); +var s = "abba"; +var r = rx[Symbol.replace](s, "c"); +assertEq(r, "abba"); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/replace-sticky-lastIndex.js b/js/src/tests/ecma_6/RegExp/replace-sticky-lastIndex.js new file mode 100644 index 000000000..2500b2c42 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/replace-sticky-lastIndex.js @@ -0,0 +1,23 @@ +var BUGNUMBER = 887016; +var summary = "String.prototype.replace should do nothing if lastIndex is invalid for sticky RegExp"; + +print(BUGNUMBER + ": " + summary); + +var re = /a/y; +re.lastIndex = -1; +assertEq("a".replace(re, "b"), "b"); +re.lastIndex = 0; +assertEq("a".replace(re, "b"), "b"); +re.lastIndex = 1; +assertEq("a".replace(re, "b"), "a"); +re.lastIndex = 2; +assertEq("a".replace(re, "b"), "a"); +re.lastIndex = "foo"; +assertEq("a".replace(re, "b"), "b"); +re.lastIndex = "1"; +assertEq("a".replace(re, "b"), "a"); +re.lastIndex = {}; +assertEq("a".replace(re, "b"), "b"); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/replace-sticky.js b/js/src/tests/ecma_6/RegExp/replace-sticky.js new file mode 100644 index 000000000..32a6e2aee --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/replace-sticky.js @@ -0,0 +1,21 @@ +var BUGNUMBER = 887016; +var summary = "String.prototype.replace should use and update lastIndex if sticky flag is set"; + +print(BUGNUMBER + ": " + summary); + +var input = "abcdeabcdeabcdefghij"; +var re = new RegExp("abcde", "y"); +re.test(input); +assertEq(re.lastIndex, 5); +var ret = input.replace(re, "ABCDE"); +assertEq(ret, "abcdeABCDEabcdefghij"); +assertEq(re.lastIndex, 10); +ret = input.replace(re, "ABCDE"); +assertEq(ret, "abcdeabcdeABCDEfghij"); +assertEq(re.lastIndex, 15); +ret = input.replace(re, "ABCDE"); +assertEq(ret, "abcdeabcdeabcdefghij"); +assertEq(re.lastIndex, 0); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/replace-this.js b/js/src/tests/ecma_6/RegExp/replace-this.js new file mode 100644 index 000000000..499304f9c --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/replace-this.js @@ -0,0 +1,12 @@ +var BUGNUMBER = 887016; +var summary = "RegExp.prototype[@@replace] should check |this| value."; + +print(BUGNUMBER + ": " + summary); + +for (var v of [null, 1, true, undefined, "", Symbol.iterator]) { + assertThrowsInstanceOf(() => RegExp.prototype[Symbol.replace].call(v), + TypeError); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/replace-trace.js b/js/src/tests/ecma_6/RegExp/replace-trace.js new file mode 100644 index 000000000..73e623563 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/replace-trace.js @@ -0,0 +1,309 @@ +var BUGNUMBER = 887016; +var summary = "Trace RegExp.prototype[@@replace] behavior."; + +print(BUGNUMBER + ": " + summary); + +var n; +var log; +var target; +var global; +var unicode; + +var execResult; +var lastIndexResult; +var lastIndexExpected; + +var arraySetterObserved = false; +function startObserve() { + for (var i = 0; i < 10; i++) { + Object.defineProperty(Array.prototype, i, { + set: function(v) { + arraySetterObserved = true; + }, + configurable: true, + }); + } +} +function stopObserve() { + for (var i = 0; i < 10; i++) + delete Array.prototype[i] +} + +startObserve(); + +function P(A, index, matched2) { + var i = 0; + A.index = index; + return new Proxy(A, { + get(that, name) { + log += "get:result[" + name + "],"; + + // Return a different value for 2nd access to result[0]. + if (matched2 !== undefined && name == 0) { + if (i == 1) { + return matched2; + } + i++; + } + + return that[name]; + } + }); +} + +var myRegExp = { + get global() { + log += "get:global,"; + return global; + }, + get lastIndex() { + log += "get:lastIndex,"; + return lastIndexResult[n]; + }, + set lastIndex(v) { + log += "set:lastIndex,"; + assertEq(v, lastIndexExpected[n]); + }, + get unicode() { + log += "get:unicode,"; + return unicode; + }, + get exec() { + log += "get:exec,"; + return function(S) { + log += "call:exec,"; + assertEq(S, target); + return execResult[n++]; + }; + }, +}; + +function reset() { + n = 0; + log = ""; + target = "abcAbcABC"; + global = true; + unicode = false; + arraySetterObserved = false; +} + +// Trace global with non-empty match. +reset(); +execResult = [ P(["bc"], 1), null ]; +lastIndexResult = [ , , ]; +lastIndexExpected = [ 0, , ]; +var ret = RegExp.prototype[Symbol.replace].call(myRegExp, target, "_XYZ_"); +assertEq(arraySetterObserved, false); +assertEq(ret, "a_XYZ_AbcABC"); +assertEq(log, + "get:global," + + "get:unicode," + + "set:lastIndex," + + "get:exec,call:exec," + + "get:result[0]," + + "get:exec,call:exec," + + "get:result[length],get:result[0],get:result[index],"); + +// Trace global with empty match. +reset(); +execResult = [ P([""], 1), null ]; +lastIndexResult = [ , 5, ]; +lastIndexExpected = [ 0, 6, ]; +ret = RegExp.prototype[Symbol.replace].call(myRegExp, target, "_XYZ_"); +assertEq(arraySetterObserved, false); +assertEq(ret, "a_XYZ_bcAbcABC"); +assertEq(log, + "get:global," + + "get:unicode," + + "set:lastIndex," + + "get:exec,call:exec," + + "get:result[0]," + + "get:lastIndex,set:lastIndex," + + "get:exec,call:exec," + + "get:result[length],get:result[0],get:result[index],"); + +// Trace global and unicode with empty match. +// 1. not surrogate pair +// 2. lead surrogate pair +// 3. trail surrogate pair +// 4. lead surrogate pair without trail surrogate pair +// 5. index overflow +reset(); +unicode = true; +// 0123 4 5678 +target = "---\uD83D\uDC38---\uD83D"; +execResult = [ P([""], 1), P([""], 2), P([""], 3), P([""], 4), P([""], 5), null ]; +lastIndexResult = [ , 2, 3, 4, 8, 9, ]; +lastIndexExpected = [ 0, 3, 5, 5, 9, 10, ]; +ret = RegExp.prototype[Symbol.replace].call(myRegExp, target, "_XYZ_"); +assertEq(arraySetterObserved, false); +assertEq(ret, "-_XYZ_-_XYZ_-_XYZ_\uD83D_XYZ_\uDC38_XYZ_---\uD83D"); +assertEq(log, + "get:global," + + "get:unicode," + + "set:lastIndex," + + "get:exec,call:exec," + + "get:result[0]," + + "get:lastIndex,set:lastIndex," + + "get:exec,call:exec," + + "get:result[0]," + + "get:lastIndex,set:lastIndex," + + "get:exec,call:exec," + + "get:result[0]," + + "get:lastIndex,set:lastIndex," + + "get:exec,call:exec," + + "get:result[0]," + + "get:lastIndex,set:lastIndex," + + "get:exec,call:exec," + + "get:result[0]," + + "get:lastIndex,set:lastIndex," + + "get:exec,call:exec," + + "get:result[length],get:result[0],get:result[index]," + + "get:result[length],get:result[0],get:result[index]," + + "get:result[length],get:result[0],get:result[index]," + + "get:result[length],get:result[0],get:result[index]," + + "get:result[length],get:result[0],get:result[index],"); + +// Trace global with captures and substitutions. +reset(); +execResult = [ P(["bc", "b", "c"], 1), null ]; +lastIndexResult = [ , , ]; +lastIndexExpected = [ 0, , ]; +ret = RegExp.prototype[Symbol.replace].call(myRegExp, target, "[$&,$`,$',$1,$2,$3,$]"); +assertEq(arraySetterObserved, false); +assertEq(ret, "a[bc,a,AbcABC,b,c,$3,$]AbcABC"); +assertEq(log, + "get:global," + + "get:unicode," + + "set:lastIndex," + + "get:exec,call:exec," + + "get:result[0]," + + "get:exec,call:exec," + + "get:result[length],get:result[0],get:result[index]," + + "get:result[1],get:result[2],"); + +// Trace global with empty match and captures and substitutions, +// with different matched. +reset(); +execResult = [ P(["", "b", "c"], 1, "BC"), null ]; +lastIndexResult = [ , 5, ]; +lastIndexExpected = [ 0, 6, ]; +ret = RegExp.prototype[Symbol.replace].call(myRegExp, target, "[$&,$`,$',$1,$2,$3,$]"); +assertEq(arraySetterObserved, false); +assertEq(ret, "a[BC,a,AbcABC,b,c,$3,$]AbcABC"); +assertEq(log, + "get:global," + + "get:unicode," + + "set:lastIndex," + + "get:exec,call:exec," + + "get:result[0]," + + "get:lastIndex,set:lastIndex," + + "get:exec,call:exec," + + "get:result[length],get:result[0],get:result[index]," + + "get:result[1],get:result[2],"); + +// Trace global with empty match and captures and function, +// with different matched. +reset(); +execResult = [ P(["", "b", "c"], 1, "BC"), null ]; +lastIndexResult = [ , 5, ]; +lastIndexExpected = [ 0, 6, ]; +function replaceFunc(...args) { + log += "call:replaceFunc,"; + assertEq(args.length, 5); + assertEq(args[0], "BC"); + assertEq(args[1], "b"); + assertEq(args[2], "c"); + assertEq(args[3], 1); + assertEq(args[4], target); + return "_ret_"; +} +// This also tests RegExpStatics save/restore with no match. +ret = RegExp.prototype[Symbol.replace].call(myRegExp, target, replaceFunc); +assertEq(arraySetterObserved, false); +assertEq(ret, "a_ret_AbcABC"); +assertEq(log, + "get:global," + + "get:unicode," + + "set:lastIndex," + + "get:exec,call:exec," + + "get:result[0]," + + "get:lastIndex,set:lastIndex," + + "get:exec,call:exec," + + "get:result[length],get:result[0],get:result[index]," + + "get:result[1],get:result[2]," + + "call:replaceFunc,"); + +// Trace global with non-empty match, move backwards. +// 2nd match shouldn't be replaced. +reset(); +execResult = [ P(["X"], 5), P(["YZ"], 1), null ]; +lastIndexResult = [ , , , ]; +lastIndexExpected = [ 0, , , ]; +ret = RegExp.prototype[Symbol.replace].call(myRegExp, target, "_XYZ_"); +assertEq(arraySetterObserved, false); +assertEq(ret, "abcAb_XYZ_ABC"); +assertEq(log, + "get:global," + + "get:unicode," + + "set:lastIndex," + + "get:exec,call:exec," + + "get:result[0]," + + "get:exec,call:exec," + + "get:result[0]," + + "get:exec,call:exec," + + "get:result[length],get:result[0],get:result[index]," + + "get:result[length],get:result[0],get:result[index],"); + +// Trace global with non-empty match, position + matchLength overflows. +reset(); +execResult = [ P(["fooooooo"], 7), null ]; +lastIndexResult = [ , , ]; +lastIndexExpected = [ 0, , ]; +ret = RegExp.prototype[Symbol.replace].call(myRegExp, target, "_XYZ_"); +assertEq(arraySetterObserved, false); +assertEq(ret, "abcAbcA_XYZ_"); +assertEq(log, + "get:global," + + "get:unicode," + + "set:lastIndex," + + "get:exec,call:exec," + + "get:result[0]," + + "get:exec,call:exec," + + "get:result[length],get:result[0],get:result[index],"); + +// Trace global with non-empty match, position overflows. +reset(); +execResult = [ P(["fooooooo"], 12), null ]; +lastIndexResult = [ , , ]; +lastIndexExpected = [ 0, , ]; +ret = RegExp.prototype[Symbol.replace].call(myRegExp, target, "_XYZ_"); +assertEq(arraySetterObserved, false); +assertEq(ret, "abcAbcABC_XYZ_"); +assertEq(log, + "get:global," + + "get:unicode," + + "set:lastIndex," + + "get:exec,call:exec," + + "get:result[0]," + + "get:exec,call:exec," + + "get:result[length],get:result[0],get:result[index],"); + +// Trace non-global. +reset(); +global = false; +execResult = [ P(["bc"], 1) ]; +lastIndexResult = [ , , ]; +lastIndexExpected = [ 0, , ]; +ret = RegExp.prototype[Symbol.replace].call(myRegExp, target, "_XYZ_"); +assertEq(arraySetterObserved, false); +assertEq(ret, "a_XYZ_AbcABC"); +assertEq(log, + "get:global," + + "get:exec,call:exec," + + "get:result[length],get:result[0],get:result[index],"); + +stopObserve(); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/replace-twoBytes.js b/js/src/tests/ecma_6/RegExp/replace-twoBytes.js new file mode 100644 index 000000000..660677c9f --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/replace-twoBytes.js @@ -0,0 +1,44 @@ +var BUGNUMBER = 1269719; +var summary = "RegExp.prototype[@@replace] should check latin1/twoBytes for all strings used in relate operation."; + +print(BUGNUMBER + ": " + summary); + +var ans = [ + "[AB$2$3$]", + "[AB$2$3$]\u3048", + "[AB$2$3$]", + "[AB$2$3$]\u3048", + "[A\u3044$2$3$]", + "[A\u3044$2$3$]\u3048", + "[A\u3044$2$3$]", + "[A\u3044$2$3$]\u3048", + "[\u3042B$2$3$]", + "[\u3042B$2$3$]\u3048", + "[\u3042B$2$3$]", + "[\u3042B$2$3$]\u3048", + "[\u3042\u3044$2$3$]", + "[\u3042\u3044$2$3$]\u3048", + "[\u3042\u3044$2$3$]", + "[\u3042\u3044$2$3$]\u3048", +]; +var i = 0; +for (var matched of ["A", "\u3042"]) { + for (var group1 of ["B", "\u3044"]) { + for (var string of ["C", "\u3046"]) { + for (var replacement of ["[$&$`$'$1$2$3$]", "[$&$`$'$1$2$3$]\u3048"]) { + var myRegExp = { + get exec() { + return function() { + return [matched, group1]; + }; + } + }; + assertEq(RegExp.prototype[Symbol.replace].call(myRegExp, string, replacement), ans[i]); + i++; + } + } + } +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/replace.js b/js/src/tests/ecma_6/RegExp/replace.js new file mode 100644 index 000000000..43522ab55 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/replace.js @@ -0,0 +1,34 @@ +var BUGNUMBER = 887016; +var summary = "Implement RegExp.prototype[@@replace]."; + +print(BUGNUMBER + ": " + summary); + +assertEq(RegExp.prototype[Symbol.replace].name, "[Symbol.replace]"); +assertEq(RegExp.prototype[Symbol.replace].length, 2); +var desc = Object.getOwnPropertyDescriptor(RegExp.prototype, Symbol.replace); +assertEq(desc.configurable, true); +assertEq(desc.enumerable, false); +assertEq(desc.writable, true); + +var re = /a/; +var v = re[Symbol.replace]("abcAbcABC", "X"); +assertEq(v, "XbcAbcABC"); + +re = /d/; +v = re[Symbol.replace]("abcAbcABC", "X"); +assertEq(v, "abcAbcABC"); + +re = /a/ig; +v = re[Symbol.replace]("abcAbcABC", "X"); +assertEq(v, "XbcXbcXBC"); + +re = /(a)(b)(cd)/; +v = re[Symbol.replace]("012abcd345", "_$$_$&_$`_$'_$0_$1_$2_$3_$4_$+_$"); +assertEq(v, "012_$_abcd_012_345_$0_a_b_cd_$4_cd_$345"); + +re = /(a)(b)(cd)/; +v = re[Symbol.replace]("012abcd345", "_\u3042_$$_$&_$`_$'_$0_$1_$2_$3_$4_$+_$"); +assertEq(v, "012_\u3042_$_abcd_012_345_$0_a_b_cd_$4_cd_$345"); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/search-this.js b/js/src/tests/ecma_6/RegExp/search-this.js new file mode 100644 index 000000000..731f5480f --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/search-this.js @@ -0,0 +1,12 @@ +var BUGNUMBER = 887016; +var summary = "RegExp.prototype[@@search] should check this value."; + +print(BUGNUMBER + ": " + summary); + +for (var v of [null, 1, true, undefined, "", Symbol.iterator]) { + assertThrowsInstanceOf(() => RegExp.prototype[Symbol.search].call(v), + TypeError); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/search-trace.js b/js/src/tests/ecma_6/RegExp/search-trace.js new file mode 100644 index 000000000..ef14514c6 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/search-trace.js @@ -0,0 +1,76 @@ +var BUGNUMBER = 887016; +var summary = "Trace RegExp.prototype[@@search] behavior."; + +print(BUGNUMBER + ": " + summary); + +var n; +var log; +var target; + +var execResult; +var lastIndexResult; +var lastIndexExpected; + +function P(index) { + return new Proxy({ index }, { + get(that, name) { + log += "get:result[" + name + "],"; + return that[name]; + } + }); +} + +var myRegExp = { + get lastIndex() { + log += "get:lastIndex,"; + return lastIndexResult[n]; + }, + set lastIndex(v) { + log += "set:lastIndex,"; + assertEq(v, lastIndexExpected[n]); + }, + get exec() { + log += "get:exec,"; + return function(S) { + log += "call:exec,"; + assertEq(S, target); + return execResult[n++]; + }; + }, +}; + +function reset() { + n = 0; + log = ""; + target = "abcAbcABC"; +} + +// Trace hit. +reset(); +execResult = [ P(16) ]; +lastIndexResult = [ 10, , ]; +lastIndexExpected = [ 0, 10 ]; +var ret = RegExp.prototype[Symbol.search].call(myRegExp, target); +assertEq(ret, 16); +assertEq(log, + "get:lastIndex," + + "set:lastIndex," + + "get:exec,call:exec," + + "set:lastIndex," + + "get:result[index],"); + +// Trace not hit. +reset(); +execResult = [ null ]; +lastIndexResult = [ 10, , ]; +lastIndexExpected = [ 0, 10 ]; +ret = RegExp.prototype[Symbol.search].call(myRegExp, target); +assertEq(ret, -1); +assertEq(log, + "get:lastIndex," + + "set:lastIndex," + + "get:exec,call:exec," + + "set:lastIndex,"); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/search.js b/js/src/tests/ecma_6/RegExp/search.js new file mode 100644 index 000000000..0875ee47e --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/search.js @@ -0,0 +1,26 @@ +var BUGNUMBER = 887016; +var summary = "Implement RegExp.prototype[@@search]."; + +print(BUGNUMBER + ": " + summary); + +assertEq(RegExp.prototype[Symbol.search].name, "[Symbol.search]"); +assertEq(RegExp.prototype[Symbol.search].length, 1); +var desc = Object.getOwnPropertyDescriptor(RegExp.prototype, Symbol.search); +assertEq(desc.configurable, true); +assertEq(desc.enumerable, false); +assertEq(desc.writable, true); + +var re = /B/; +var v = re[Symbol.search]("abcAbcABC"); +assertEq(v, 7); + +re = /B/i; +v = re[Symbol.search]("abcAbcABCD"); +assertEq(v, 1); + +re = /d/; +v = re[Symbol.search]("abcAbcABCD"); +assertEq(v, -1); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/shell.js b/js/src/tests/ecma_6/RegExp/shell.js new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/shell.js diff --git a/js/src/tests/ecma_6/RegExp/source.js b/js/src/tests/ecma_6/RegExp/source.js new file mode 100644 index 000000000..354a9d19d --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/source.js @@ -0,0 +1,29 @@ +var BUGNUMBER = 1120169; +var summary = "Implement RegExp.prototype.source"; + +print(BUGNUMBER + ": " + summary); + +assertEq(RegExp.prototype.source, "(?:)"); +assertEq(/foo/.source, "foo"); +assertEq(/foo/iymg.source, "foo"); +assertEq(/\//.source, "\\/"); +assertEq(/\n\r/.source, "\\n\\r"); +assertEq(/\u2028\u2029/.source, "\\u2028\\u2029"); +assertEq(RegExp("").source, "(?:)"); +assertEq(RegExp("", "mygi").source, "(?:)"); +assertEq(RegExp("/").source, "\\/"); +assertEq(RegExp("\n\r").source, "\\n\\r"); +assertEq(RegExp("\u2028\u2029").source, "\\u2028\\u2029"); + +assertThrowsInstanceOf(() => genericSource(), TypeError); +assertThrowsInstanceOf(() => genericSource(1), TypeError); +assertThrowsInstanceOf(() => genericSource(""), TypeError); +assertThrowsInstanceOf(() => genericSource({}), TypeError); +assertThrowsInstanceOf(() => genericSource(new Proxy(/foo/, {get(){ return true; }})), TypeError); + +function genericSource(obj) { + return Object.getOwnPropertyDescriptor(RegExp.prototype, "source").get.call(obj); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/split-deleted-flags.js b/js/src/tests/ecma_6/RegExp/split-deleted-flags.js new file mode 100644 index 000000000..d2ccc852d --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/split-deleted-flags.js @@ -0,0 +1,11 @@ +var BUGNUMBER = 1322319; +var summary = "RegExp.prototype.split should throw if RegRxp.prototype.flags is deleted." + +print(BUGNUMBER + ": " + summary); + +delete RegExp.prototype.flags; + +assertThrowsInstanceOf(() => "aaaaa".split(/a/), SyntaxError); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/split-flags-on-obj.js b/js/src/tests/ecma_6/RegExp/split-flags-on-obj.js new file mode 100644 index 000000000..8c68efed5 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/split-flags-on-obj.js @@ -0,0 +1,21 @@ +var BUGNUMBER = 0; +var summary = "RegExp.prototype.split should reflect the change to Object.prototype.flags."; + +print(BUGNUMBER + ": " + summary); + +Object.defineProperty(Object.prototype, "flags", Object.getOwnPropertyDescriptor(RegExp.prototype, "flags")); +delete RegExp.prototype.flags; + +let re = /a/i; +let a = re[Symbol.split]("1a2A3a4A5"); +assertDeepEq(a, ["1", "2", "3", "4", "5"]); + +delete Object.prototype.flags; + +Object.prototype.flags = ""; + +a = re[Symbol.split]("1a2A3a4A5"); +assertDeepEq(a, ["1", "2A3", "4A5"]); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/split-invalid-lastIndex.js b/js/src/tests/ecma_6/RegExp/split-invalid-lastIndex.js new file mode 100644 index 000000000..3def559ad --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/split-invalid-lastIndex.js @@ -0,0 +1,31 @@ +var BUGNUMBER = 1263851; +var summary = "RegExp.prototype[@@split] should handle if lastIndex is out of bound."; + +print(BUGNUMBER + ": " + summary); + +var myRegExp = { + get constructor() { + return { + get [Symbol.species]() { + return function() { + return { + get lastIndex() { + return 9; + }, + set lastIndex(v) {}, + exec() { + return []; + } + }; + }; + } + }; + } +}; +var result = RegExp.prototype[Symbol.split].call(myRegExp, "abcde");; +assertEq(result.length, 2); +assertEq(result[0], ""); +assertEq(result[1], ""); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/split-limit.js b/js/src/tests/ecma_6/RegExp/split-limit.js new file mode 100644 index 000000000..5fa194b90 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/split-limit.js @@ -0,0 +1,14 @@ +var BUGNUMBER = 1287525; +var summary = "RegExp.prototype[@@split] shouldn't use optimized path if limit is not number."; + +print(BUGNUMBER + ": " + summary); + +var rx = /a/; +var r = rx[Symbol.split]("abba", {valueOf() { + RegExp.prototype.exec = () => null; + return 100; +}}); +assertEq(r.length, 1); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/split-obj.js b/js/src/tests/ecma_6/RegExp/split-obj.js new file mode 100644 index 000000000..75c09f38d --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/split-obj.js @@ -0,0 +1,12 @@ +var BUGNUMBER = 887016; +var summary = "RegExp.prototype[@@split] should check if this value is RegExp."; + +print(BUGNUMBER + ": " + summary); + +var obj = { flags: "", toString: () => "-" }; +assertDeepEq(RegExp.prototype[Symbol.split].call(obj, "a-b-c"), + ["a", "b", "c"]); + +if (typeof reportCompare === "function") + reportCompare(true, true); + diff --git a/js/src/tests/ecma_6/RegExp/split-prop-access.js b/js/src/tests/ecma_6/RegExp/split-prop-access.js new file mode 100644 index 000000000..73c5bebb3 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/split-prop-access.js @@ -0,0 +1,19 @@ +var BUGNUMBER = 1287525; +var summary = 'String.prototype.split should call ToUint32(limit) before ToString(separator).'; + +print(BUGNUMBER + ": " + summary); + +var accessed = false; + +var rx = /a/; +Object.defineProperty(rx, Symbol.match, { + get() { + accessed = true; + } +}); +rx[Symbol.split]("abba"); + +assertEq(accessed, true); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/split-this.js b/js/src/tests/ecma_6/RegExp/split-this.js new file mode 100644 index 000000000..ece29fe8a --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/split-this.js @@ -0,0 +1,12 @@ +var BUGNUMBER = 887016; +var summary = "RegExp.prototype[@@split] should check this value."; + +print(BUGNUMBER + ": " + summary); + +for (var v of [null, 1, true, undefined, "", Symbol.iterator]) { + assertThrowsInstanceOf(() => RegExp.prototype[Symbol.split].call(v), + TypeError); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/split-trace.js b/js/src/tests/ecma_6/RegExp/split-trace.js new file mode 100644 index 000000000..ce6e410d9 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/split-trace.js @@ -0,0 +1,229 @@ +var BUGNUMBER = 887016; +var summary = "Trace RegExp.prototype[@@split] behavior."; + +print(BUGNUMBER + ": " + summary); + +var n; +var log; +var target; +var flags; +var expectedFlags; + +var execResult; +var lastIndexResult; +var lastIndexExpected; + +var arraySetterObserved = false; +function startObserve() { + for (var i = 0; i < 10; i++) { + Object.defineProperty(Array.prototype, i, { + set: function(v) { + arraySetterObserved = true; + }, + configurable: true, + }); + } +} +function stopObserve() { + for (var i = 0; i < 10; i++) + delete Array.prototype[i] +} + +startObserve(); + +function P(A) { + return new Proxy(A, { + get(that, name) { + log += "get:result[" + name + "],"; + return that[name]; + } + }); +} + +var myRegExp = { + get constructor() { + log += "get:constructor,"; + return { + get [Symbol.species]() { + log += "get:species,"; + return function(pattern, flags) { + assertEq(pattern, myRegExp); + assertEq(flags, expectedFlags); + log += "call:constructor,"; + return { + get lastIndex() { + log += "get:lastIndex,"; + return lastIndexResult[n]; + }, + set lastIndex(v) { + log += "set:lastIndex,"; + assertEq(v, lastIndexExpected[n]); + }, + get flags() { + log += "get:flags,"; + return flags; + }, + get exec() { + log += "get:exec,"; + return function(S) { + log += "call:exec,"; + assertEq(S, target); + return execResult[n++]; + }; + }, + }; + }; + } + }; + }, + get flags() { + log += "get:flags,"; + return flags; + }, +}; + +function reset() { + n = 0; + log = ""; + target = "abcde"; + flags = ""; + expectedFlags = "y"; + arraySetterObserved = false; +} + +// Trace match and no match. +reset(); +execResult = [ null, P(["b"]), null, P(["d"]), null ]; +lastIndexResult = [ , , 2, , 4, , ]; +lastIndexExpected = [ 0, 1, 2, 3, 4, ]; +var ret = RegExp.prototype[Symbol.split].call(myRegExp, target); +assertEq(arraySetterObserved, false); +assertEq(JSON.stringify(ret), `["a","c","e"]`); +assertEq(log, + "get:constructor," + + "get:species," + + "get:flags," + + "call:constructor," + + "set:lastIndex,get:exec,call:exec," + + "set:lastIndex,get:exec,call:exec,get:lastIndex," + + "get:result[length]," + + "set:lastIndex,get:exec,call:exec," + + "set:lastIndex,get:exec,call:exec,get:lastIndex," + + "get:result[length]," + + "set:lastIndex,get:exec,call:exec,"); + +// Trace non-empty flags, empty target, no match. +reset(); +flags = "iy"; +expectedFlags = "iy"; +target = ""; +execResult = [ null ]; +lastIndexResult = []; +lastIndexExpected = []; +ret = RegExp.prototype[Symbol.split].call(myRegExp, target); +assertEq(arraySetterObserved, false); +assertEq(JSON.stringify(ret), `[""]`); +assertEq(log, + "get:constructor," + + "get:species," + + "get:flags," + + "call:constructor," + + "get:exec,call:exec,"); + +// Trace empty target, match. +reset(); +target = ""; +execResult = [ P([""]) ]; +lastIndexResult = []; +lastIndexExpected = []; +ret = RegExp.prototype[Symbol.split].call(myRegExp, target); +assertEq(arraySetterObserved, false); +assertEq(JSON.stringify(ret), `[]`); +assertEq(log, + "get:constructor," + + "get:species," + + "get:flags," + + "call:constructor," + + "get:exec,call:exec,"); + +// Trace captures. +reset(); +target = "abc"; +execResult = [ null, P(["b", "X", "YZ"]), null ]; +lastIndexResult = [ , , 2, , ]; +lastIndexExpected = [ 0, 1, 2, ]; +ret = RegExp.prototype[Symbol.split].call(myRegExp, target); +assertEq(arraySetterObserved, false); +assertEq(JSON.stringify(ret), `["a","X","YZ","c"]`); +assertEq(log, + "get:constructor," + + "get:species," + + "get:flags," + + "call:constructor," + + "set:lastIndex,get:exec,call:exec," + + "set:lastIndex,get:exec,call:exec,get:lastIndex," + + "get:result[length]," + + "get:result[1],get:result[2]," + + "set:lastIndex,get:exec,call:exec,"); + +// Trace unicode. +// 1. not surrogate pair +// 2. lead surrogate pair +// 3. trail surrogate pair +// 4. lead surrogate pair without trail surrogate pair +// 5. index overflow +reset(); +flags = "u"; +expectedFlags = "uy"; +target = "-\uD83D\uDC38\uDC38\uD83D"; +execResult = [ null, null, null, null ]; +lastIndexResult = [ , , , , , ]; +lastIndexExpected = [ 0, 1, 3, 4, ]; +ret = RegExp.prototype[Symbol.split].call(myRegExp, target); +assertEq(arraySetterObserved, false); +assertEq(JSON.stringify(ret), `["-\uD83D\uDC38\uDC38\uD83D"]`); +assertEq(log, + "get:constructor," + + "get:species," + + "get:flags," + + "call:constructor," + + "set:lastIndex,get:exec,call:exec," + + "set:lastIndex,get:exec,call:exec," + + "set:lastIndex,get:exec,call:exec," + + "set:lastIndex,get:exec,call:exec,"); + +// Trace unicode, match, same position and different position. +reset(); +flags = "u"; +expectedFlags = "uy"; +target = "-\uD83D\uDC38\uDC38\uD83D"; +var E = P(["", "X"]); +execResult = [ E, E, E, E, E, E, E ]; +lastIndexResult = [ , 0, 1, 1, 3, 3, 4, 4 ]; +lastIndexExpected = [ 0, 1, 1, 3, 3, 4, 4, ]; +ret = RegExp.prototype[Symbol.split].call(myRegExp, target); +assertEq(arraySetterObserved, false); +assertEq(JSON.stringify(ret), `["-","X","\uD83D\uDC38","X","\uDC38","X","\uD83D"]`); +assertEq(log, + "get:constructor," + + "get:species," + + "get:flags," + + "call:constructor," + + "set:lastIndex,get:exec,call:exec,get:lastIndex," + + "set:lastIndex,get:exec,call:exec,get:lastIndex," + + "get:result[length]," + + "get:result[1]," + + "set:lastIndex,get:exec,call:exec,get:lastIndex," + + "set:lastIndex,get:exec,call:exec,get:lastIndex," + + "get:result[length]," + + "get:result[1]," + + "set:lastIndex,get:exec,call:exec,get:lastIndex," + + "set:lastIndex,get:exec,call:exec,get:lastIndex," + + "get:result[length]," + + "get:result[1]," + + "set:lastIndex,get:exec,call:exec,get:lastIndex,"); + +stopObserve(); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/split.js b/js/src/tests/ecma_6/RegExp/split.js new file mode 100644 index 000000000..d7e28d791 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/split.js @@ -0,0 +1,30 @@ +var BUGNUMBER = 887016; +var summary = "Implement RegExp.prototype[@@split]."; + +print(BUGNUMBER + ": " + summary); + +assertEq(RegExp.prototype[Symbol.split].name, "[Symbol.split]"); +assertEq(RegExp.prototype[Symbol.split].length, 2); +var desc = Object.getOwnPropertyDescriptor(RegExp.prototype, Symbol.split); +assertEq(desc.configurable, true); +assertEq(desc.enumerable, false); +assertEq(desc.writable, true); + +var re = /b/; +var v = re[Symbol.split]("abcAbcABC"); +assertEq(JSON.stringify(v), `["a","cA","cABC"]`); + +re = /d/; +v = re[Symbol.split]("abcAbcABC"); +assertEq(JSON.stringify(v), `["abcAbcABC"]`); + +re = /b/ig; +v = re[Symbol.split]("abcAbcABC"); +assertEq(JSON.stringify(v), `["a","cA","cA","C"]`); + +re = /b/ig; +v = re[Symbol.split]("abcAbcABC", 2); +assertEq(JSON.stringify(v), `["a","cA"]`); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/sticky.js b/js/src/tests/ecma_6/RegExp/sticky.js new file mode 100644 index 000000000..13a6debe9 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/sticky.js @@ -0,0 +1,126 @@ +var BUGNUMBER = 773687; +var summary = 'sticky flag should not break assertion behavior.'; + +print(BUGNUMBER + ": " + summary); + +function test(re, text, expectations) { + // Sanity check for test data itself. + assertEq(expectations.length, text.length + 1); + + for (var i = 0; i < expectations.length; i++) { + var result = expectations[i]; + + re.lastIndex = i; + var match = re.exec(text); + if (result === null) { + assertEq(re.lastIndex, 0); + assertEq(match, null); + } else { + assertEq(re.lastIndex, result.lastIndex); + assertEq(match !== null, true); + assertEq(match.length, result.matches.length); + for (var j = 0; j < result.matches.length; j++) + assertEq(match[j], result.matches[j]); + assertEq(match.index, result.index); + } + } +} + +// simple text +test(/bc/y, "abcabd", [ + null, + { lastIndex: 3, matches: ["bc"], index: 1 }, + null, + null, + null, + null, + null, +]); + +// complex pattern +test(/bc|c|d/y, "abcabd", [ + null, + { lastIndex: 3, matches: ["bc"], index: 1 }, + { lastIndex: 3, matches: ["c"], index: 2 }, + null, + null, + { lastIndex: 6, matches: ["d"], index: 5 }, + null, +]); + +test(/.*(bc|c|d)/y, "abcabd", [ + { lastIndex: 6, matches: ["abcabd", "d"], index: 0 }, + { lastIndex: 6, matches: ["bcabd", "d"], index: 1 }, + { lastIndex: 6, matches: ["cabd", "d"], index: 2 }, + { lastIndex: 6, matches: ["abd", "d"], index: 3 }, + { lastIndex: 6, matches: ["bd", "d"], index: 4 }, + { lastIndex: 6, matches: ["d", "d"], index: 5 }, + null, +]); + +test(/.*?(bc|c|d)/y, "abcabd", [ + { lastIndex: 3, matches: ["abc", "bc"], index: 0 }, + { lastIndex: 3, matches: ["bc", "bc"], index: 1 }, + { lastIndex: 3, matches: ["c", "c"], index: 2 }, + { lastIndex: 6, matches: ["abd", "d"], index: 3 }, + { lastIndex: 6, matches: ["bd", "d"], index: 4 }, + { lastIndex: 6, matches: ["d", "d"], index: 5 }, + null, +]); + +test(/(bc|.*c|d)/y, "abcabd", [ + { lastIndex: 3, matches: ["abc", "abc"], index: 0 }, + { lastIndex: 3, matches: ["bc", "bc"], index: 1 }, + { lastIndex: 3, matches: ["c", "c"], index: 2 }, + null, + null, + { lastIndex: 6, matches: ["d", "d"], index: 5 }, + null, +]); + +// ^ assertions +test(/^/y, "abcabc", [ + { lastIndex: 0, matches: [""], index: 0 }, + null, + null, + null, + null, + null, + null, +]); + +test(/^a/my, "abc\nabc", [ + { lastIndex: 1, matches: ["a"], index: 0 }, + null, + null, + null, + { lastIndex: 5, matches: ["a"], index: 4 }, + null, + null, + null, +]); + +// \b assertions +test(/\b/y, "abc bc", [ + { lastIndex: 0, matches: [""], index: 0 }, + null, + null, + { lastIndex: 3, matches: [""], index: 3 }, + { lastIndex: 4, matches: [""], index: 4 }, + null, + { lastIndex: 6, matches: [""], index: 6 }, +]); + +// \B assertions +test(/\B/y, "abc bc", [ + null, + { lastIndex: 1, matches: [""], index: 1 }, + { lastIndex: 2, matches: [""], index: 2 }, + null, + null, + { lastIndex: 5, matches: [""], index: 5 }, + null, +]); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/test-trailing.js b/js/src/tests/ecma_6/RegExp/test-trailing.js new file mode 100644 index 000000000..7cb910ee6 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/test-trailing.js @@ -0,0 +1,31 @@ +var BUGNUMBER = 1304737; +var summary = "Trailing .* should not be ignored on matchOnly match."; + +print(BUGNUMBER + ": " + summary); + +function test(r, lastIndexIsZero) { + r.lastIndex = 0; + r.test("foo"); + assertEq(r.lastIndex, lastIndexIsZero ? 0 : 3); + + r.lastIndex = 0; + r.test("foo\nbar"); + assertEq(r.lastIndex, lastIndexIsZero ? 0 : 3); + + var input = "foo" + ".bar".repeat(20000); + r.lastIndex = 0; + r.test(input); + assertEq(r.lastIndex, lastIndexIsZero ? 0 : input.length); + + r.lastIndex = 0; + r.test(input + "\nbaz"); + assertEq(r.lastIndex, lastIndexIsZero ? 0 : input.length); +} + +test(/f.*/, true); +test(/f.*/g, false); +test(/f.*/y, false); +test(/f.*/gy, false); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/toString.js b/js/src/tests/ecma_6/RegExp/toString.js new file mode 100644 index 000000000..5ffbeed33 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/toString.js @@ -0,0 +1,42 @@ +var BUGNUMBER = 1079919; +var summary = "Make RegExp.prototype.toString to be a generic function."; + +print(BUGNUMBER + ": " + summary); + +assertEq(RegExp.prototype.toString(), "/(?:)/"); +assertEq(/foo/.toString(), "/foo/"); +assertEq(/foo/i.toString(), "/foo/i"); +assertEq(/foo/gimy.toString(), "/foo/gimy"); +assertEq(/foo/igym.toString(), "/foo/gimy"); +assertEq(/\n\r/.toString(), "/\\n\\r/"); +assertEq(/\u2028\u2029/.toString(), "/\\u2028\\u2029/"); +assertEq(/\//.toString(), "/\\//"); +assertEq(RegExp().toString(), "/(?:)/"); +assertEq(RegExp("", "gimy").toString(), "/(?:)/gimy"); +assertEq(RegExp("\n\r").toString(), "/\\n\\r/"); +assertEq(RegExp("\u2028\u2029").toString(), "/\\u2028\\u2029/"); +assertEq(RegExp("/").toString(), "/\\//"); + +assertThrowsInstanceOf(() => RegExp.prototype.toString.call(), TypeError); +assertThrowsInstanceOf(() => RegExp.prototype.toString.call(1), TypeError); +assertThrowsInstanceOf(() => RegExp.prototype.toString.call(""), TypeError); +assertEq(RegExp.prototype.toString.call({}), "/undefined/undefined"); +assertEq(RegExp.prototype.toString.call({ source:"foo", flags:"bar" }), "/foo/bar"); + +var a = []; +var p = new Proxy({}, { + get(that, name) { + a.push(name); + return { + toString() { + a.push(name + "-tostring"); + return name; + } + }; + } +}); +assertEq(RegExp.prototype.toString.call(p), "/source/flags"); +assertEq(a.join(","), "source,source-tostring,flags,flags-tostring"); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-back-reference.js b/js/src/tests/ecma_6/RegExp/unicode-back-reference.js new file mode 100644 index 000000000..2a65432a1 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-back-reference.js @@ -0,0 +1,39 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- back reference should not match lead surrogate that has corresponding trail surrogate."; + +print(BUGNUMBER + ": " + summary); + +// The last character of back reference is not a surrogate. +assertEqArray(/foo(.+)bar\1/u.exec("fooAbarA\uDC00"), + ["fooAbarA", "A"]); +assertEqArray(/foo(.+)bar\1/u.exec("fooAbarA\uD834"), + ["fooAbarA", "A"]); +assertEqArray(/foo(.+)bar\1/u.exec("fooAbarAA"), + ["fooAbarA", "A"]); +assertEqArray(/foo(.+)bar\1/u.exec("fooAbarA"), + ["fooAbarA", "A"]); + +// The last character of back reference is a lead surrogate. +assertEq(/foo(.+)bar\1/u.exec("foo\uD834bar\uD834\uDC00"), null); +assertEqArray(/foo(.+)bar\1/u.exec("foo\uD834bar\uD834\uD834"), + ["foo\uD834bar\uD834", "\uD834"]); +assertEqArray(/foo(.+)bar\1/u.exec("foo\uD834bar\uD834A"), + ["foo\uD834bar\uD834", "\uD834"]); +assertEqArray(/foo(.+)bar\1/u.exec("foo\uD834bar\uD834"), + ["foo\uD834bar\uD834", "\uD834"]); + +// The last character of back reference is a trail surrogate. +assertEqArray(/foo(.+)bar\1/u.exec("foo\uDC00bar\uDC00\uDC00"), + ["foo\uDC00bar\uDC00", "\uDC00"]); +assertEqArray(/foo(.+)bar\1/u.exec("foo\uDC00bar\uDC00\uD834"), + ["foo\uDC00bar\uDC00", "\uDC00"]); +assertEqArray(/foo(.+)bar\1/u.exec("foo\uDC00bar\uDC00A"), + ["foo\uDC00bar\uDC00", "\uDC00"]); +assertEqArray(/foo(.+)bar\1/u.exec("foo\uDC00bar\uDC00"), + ["foo\uDC00bar\uDC00", "\uDC00"]); + +// Pattern should not match to surrogate pair partially. +assertEq(/^(.+)\1$/u.exec("\uDC00foobar\uD834\uDC00foobar\uD834"), null); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-braced.js b/js/src/tests/ecma_6/RegExp/unicode-braced.js new file mode 100644 index 000000000..97df7acab --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-braced.js @@ -0,0 +1,166 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- braced pattern in RegExpUnicodeEscapeSequence."; + +print(BUGNUMBER + ": " + summary); + +// ==== standalone ==== + +assertEqArray(/\u{41}/u.exec("ABC"), + ["A"]); +assertEqArray(/\u{41}/.exec("ABC" + "u".repeat(41)), + ["u".repeat(41)]); + +assertEqArray(/\u{4A}/u.exec("JKL"), + ["J"]); +assertEqArray(/\u{4A}/.exec("JKLu{4A}"), + ["u{4A}"]); + +assertEqArray(/\u{1F438}/u.exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/\u{1F438}/.exec("u{1F438}"), + ["u{1F438}"]); + +assertEqArray(/\u{0}/u.exec("\u{0}"), + ["\u{0}"]); +assertEqArray(/\u{10FFFF}/u.exec("\u{10FFFF}"), + ["\u{10FFFF}"]); +assertEqArray(/\u{10ffff}/u.exec("\u{10FFFF}"), + ["\u{10FFFF}"]); + +// leading 0 +assertEqArray(/\u{0000000000000000000000}/u.exec("\u{0}"), + ["\u{0}"]); +assertEqArray(/\u{000000000000000010FFFF}/u.exec("\u{10FFFF}"), + ["\u{10FFFF}"]); + +// RegExp constructor +assertEqArray(new RegExp("\\u{0}", "u").exec("\u{0}"), + ["\u{0}"]); +assertEqArray(new RegExp("\\u{41}", "u").exec("ABC"), + ["A"]); +assertEqArray(new RegExp("\\u{1F438}", "u").exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(new RegExp("\\u{10FFFF}", "u").exec("\u{10FFFF}"), + ["\u{10FFFF}"]); + +assertEqArray(new RegExp("\\u{0000000000000000}", "u").exec("\u{0}"), + ["\u{0}"]); + +assertEqArray(eval(`/\\u{${"0".repeat(Math.pow(2, 24)) + "1234"}}/u`).exec("\u{1234}"), + ["\u{1234}"]); +assertEqArray(new RegExp(`\\u{${"0".repeat(Math.pow(2, 24)) + "1234"}}`, "u").exec("\u{1234}"), + ["\u{1234}"]); + +// ==== ? ==== + +assertEqArray(/\u{1F438}?/u.exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/\u{1F438}?/u.exec(""), + [""]); + +// lead-only target +assertEqArray(/\u{1F438}?/u.exec("\uD83D"), + [""]); + +// RegExp constructor +assertEqArray(new RegExp("\\u{1F438}?", "u").exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(new RegExp("\\u{1F438}?", "u").exec(""), + [""]); +assertEqArray(new RegExp("\\u{1F438}?", "u").exec("\uD83D"), + [""]); + +// ==== + ==== + +assertEqArray(/\u{1F438}+/u.exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/\u{1F438}+/u.exec("\u{1F438}\u{1F438}"), + ["\u{1F438}\u{1F438}"]); +assertEq(/\u{1F438}+/u.exec(""), + null); + +// lead-only target +assertEq(/\u{1F438}+/u.exec("\uD83D"), + null); +assertEqArray(/\u{1F438}+/u.exec("\uD83D\uDC38\uDC38"), + ["\uD83D\uDC38"]); + +// ==== * ==== + +assertEqArray(/\u{1F438}*/u.exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/\u{1F438}*/u.exec("\u{1F438}\u{1F438}"), + ["\u{1F438}\u{1F438}"]); +assertEqArray(/\u{1F438}*/u.exec(""), + [""]); + +// lead-only target +assertEqArray(/\u{1F438}*/u.exec("\uD83D"), + [""]); +assertEqArray(/\u{1F438}*/u.exec("\uD83D\uDC38\uDC38"), + ["\uD83D\uDC38"]); + +// ==== lead-only ==== + +// match only non-surrogate pair +assertEqArray(/\u{D83D}/u.exec("\uD83D\uDBFF"), + ["\uD83D"]); +assertEq(/\u{D83D}/u.exec("\uD83D\uDC00"), + null); +assertEq(/\u{D83D}/u.exec("\uD83D\uDFFF"), + null); +assertEqArray(/\u{D83D}/u.exec("\uD83D\uE000"), + ["\uD83D"]); + +// match before non-tail char +assertEqArray(/\u{D83D}/u.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/\u{D83D}/u.exec("\uD83DA"), + ["\uD83D"]); + +// ==== trail-only ==== + +// match only non-surrogate pair +assertEqArray(/\u{DC38}/u.exec("\uD7FF\uDC38"), + ["\uDC38"]); +assertEq(/\u{DC38}/u.exec("\uD800\uDC38"), + null); +assertEq(/\u{DC38}/u.exec("\uDBFF\uDC38"), + null); +assertEqArray(/\u{DC38}/u.exec("\uDC00\uDC38"), + ["\uDC38"]); + +// match after non-lead char +assertEqArray(/\u{DC38}/u.exec("\uDC38"), + ["\uDC38"]); +assertEqArray(/\u{DC38}/u.exec("A\uDC38"), + ["\uDC38"]); + +// ==== wrong patterns ==== + +assertThrowsInstanceOf(() => eval(`/\\u{-1}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u{0.0}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u{G}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u{}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u{{/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u{/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u{110000}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u{00110000}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u{100000000000000000000000000000}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u{FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u{ FFFF}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u{FFFF }/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u{FF FF}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u{F F F F}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u{100000001}/u`), SyntaxError); + +// surrogate pair with braced +assertEq(/\u{D83D}\u{DC38}+/u.exec("\uD83D\uDC38\uDC38"), + null); +assertEq(/\uD83D\u{DC38}+/u.exec("\uD83D\uDC38\uDC38"), + null); +assertEq(/\u{D83D}\uDC38+/u.exec("\uD83D\uDC38\uDC38"), + null); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-character-class-escape.js b/js/src/tests/ecma_6/RegExp/unicode-character-class-escape.js new file mode 100644 index 000000000..175207d5a --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-character-class-escape.js @@ -0,0 +1,75 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- CharacterClassEscape."; + +print(BUGNUMBER + ": " + summary); + +// BMP + +assertEqArray(/\d+/u.exec("abcxyzABCXYZ0123456789_\t\r\n\v\x0c\xa0\uFEFF*"), + ["0123456789"]); +assertEqArray(/\D+/u.exec("abcxyzABCXYZ0123456789_\t\r\n\v\x0c\xa0\uFEFF*"), + ["abcxyzABCXYZ"]); + +assertEqArray(/\s+/u.exec("abcxyzABCXYZ0123456789_\t\r\n\v\x0c\xa0\uFEFF*"), + ["\t\r\n\v\x0c\xa0\uFEFF"]); +assertEqArray(/\S+/u.exec("abcxyzABCXYZ0123456789_\t\r\n\v\x0c\xa0\uFEFF*"), + ["abcxyzABCXYZ0123456789_"]); + +assertEqArray(/\w+/u.exec("abcxyzABCXYZ0123456789_\t\r\n\v\x0c\xa0\uFEFF*"), + ["abcxyzABCXYZ0123456789_"]); +assertEqArray(/\W+/u.exec("abcxyzABCXYZ0123456789_\t\r\n\v\x0c\xa0\uFEFF*"), + ["\t\r\n\v\x0c\xa0\uFEFF*"]); + +assertEqArray(/\n+/u.exec("abcxyzABCXYZ0123456789_\t\r\n\v\x0c\xa0\uFEFF*"), + ["\n"]); + +assertEqArray(/[\d]+/u.exec("abcxyzABCXYZ0123456789_\t\r\n\v\x0c\xa0\uFEFF*"), + ["0123456789"]); +assertEqArray(/[\D]+/u.exec("abcxyzABCXYZ0123456789_\t\r\n\v\x0c\xa0\uFEFF*"), + ["abcxyzABCXYZ"]); + +assertEqArray(/[\s]+/u.exec("abcxyzABCXYZ0123456789_\t\r\n\v\x0c\xa0\uFEFF*"), + ["\t\r\n\v\x0c\xa0\uFEFF"]); +assertEqArray(/[\S]+/u.exec("abcxyzABCXYZ0123456789_\t\r\n\v\x0c\xa0\uFEFF*"), + ["abcxyzABCXYZ0123456789_"]); + +assertEqArray(/[\w]+/u.exec("abcxyzABCXYZ0123456789_\t\r\n\v\x0c\xa0\uFEFF*"), + ["abcxyzABCXYZ0123456789_"]); +assertEqArray(/[\W]+/u.exec("abcxyzABCXYZ0123456789_\t\r\n\v\x0c\xa0\uFEFF*"), + ["\t\r\n\v\x0c\xa0\uFEFF*"]); + +assertEqArray(/[\n]+/u.exec("abcxyzABCXYZ0123456789_\t\r\n\v\x0c\xa0\uFEFF*"), + ["\n"]); + +// non-BMP + +function testNonBMP(re) { + assertEqArray(re.exec("\uD83D\uDBFF"), + ["\uD83D"]); + assertEqArray(re.exec("\uD83D\uDC00"), + ["\uD83D\uDC00"]); + assertEqArray(re.exec("\uD83D\uDFFF"), + ["\uD83D\uDFFF"]); + assertEqArray(re.exec("\uD83D\uE000"), + ["\uD83D"]); + + assertEqArray(re.exec("\uD7FF\uDC38"), + ["\uD7FF"]); + assertEqArray(re.exec("\uD800\uDC38"), + ["\uD800\uDC38"]); + assertEqArray(re.exec("\uDBFF\uDC38"), + ["\uDBFF\uDC38"]); + assertEqArray(re.exec("\uDC00\uDC38"), + ["\uDC00"]); +} + +testNonBMP(/\D/u); +testNonBMP(/\S/u); +testNonBMP(/\W/u); + +testNonBMP(/[\D]/u); +testNonBMP(/[\S]/u); +testNonBMP(/[\W]/u); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-class-braced.js b/js/src/tests/ecma_6/RegExp/unicode-class-braced.js new file mode 100644 index 000000000..4b5954012 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-class-braced.js @@ -0,0 +1,236 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- braced pattern in RegExpUnicodeEscapeSequence in CharacterClass."; + +print(BUGNUMBER + ": " + summary); + +// ==== standalone ==== + +assertEqArray(/[\u{41}]/u.exec("ABC"), + ["A"]); + +assertEqArray(/[\u{1F438}]/u.exec("\u{1F438}"), + ["\u{1F438}"]); +assertEq(/[\u{1F438}]/u.exec("\uD83D"), + null); +assertEq(/[\u{1F438}]/u.exec("\uDC38"), + null); + +assertEqArray(/[\u{0}]/u.exec("\u{0}"), + ["\u{0}"]); +assertEqArray(/[\u{10FFFF}]/u.exec("\u{10FFFF}"), + ["\u{10FFFF}"]); +assertEqArray(/[\u{10ffff}]/u.exec("\u{10FFFF}"), + ["\u{10FFFF}"]); + +// leading 0 +assertEqArray(/[\u{0000000000000000000000}]/u.exec("\u{0}"), + ["\u{0}"]); +assertEqArray(/[\u{000000000000000010FFFF}]/u.exec("\u{10FFFF}"), + ["\u{10FFFF}"]); + +// RegExp constructor +assertEqArray(new RegExp("[\\u{0}]", "u").exec("\u{0}"), + ["\u{0}"]); +assertEqArray(new RegExp("[\\u{41}]", "u").exec("ABC"), + ["A"]); +assertEqArray(new RegExp("[\\u{1F438}]", "u").exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(new RegExp("[\\u{10FFFF}]", "u").exec("\u{10FFFF}"), + ["\u{10FFFF}"]); + +assertEqArray(new RegExp("[\\u{0000000000000000}]", "u").exec("\u{0}"), + ["\u{0}"]); + +assertEqArray(eval(`/[\\u{${"0".repeat(Math.pow(2, 24)) + "1234"}}]/u`).exec("\u{1234}"), + ["\u{1234}"]); +assertEqArray(new RegExp(`[\\u{${"0".repeat(Math.pow(2, 24)) + "1234"}}]`, "u").exec("\u{1234}"), + ["\u{1234}"]); + +// ==== BMP + non-BMP ==== + +assertEqArray(/[A\u{1F438}]/u.exec("A\u{1F438}"), + ["A"]); +assertEqArray(/[A\u{1F438}]/u.exec("\u{1F438}A"), + ["\u{1F438}"]); + +// lead-only target +assertEqArray(/[A\u{1F438}]/u.exec("\uD83DA"), + ["A"]); +assertEq(/[A\u{1F438}]/u.exec("\uD83D"), + null); + +// + +assertEqArray(/[A\u{1F438}]+/u.exec("\u{1F438}A\u{1F438}A"), + ["\u{1F438}A\u{1F438}A"]); + +// trail surrogate + lead surrogate +assertEqArray(/[A\u{1F438}]+/u.exec("\uD83D\uDC38A\uDC38\uD83DA"), + ["\uD83D\uDC38A"]); + +// ==== non-BMP + non-BMP ==== + +assertEqArray(/[\u{1F418}\u{1F438}]/u.exec("\u{1F418}\u{1F438}"), + ["\u{1F418}"]); + +assertEqArray(/[\u{1F418}\u{1F438}]+/u.exec("\u{1F418}\u{1F438}"), + ["\u{1F418}\u{1F438}"]); +assertEqArray(/[\u{1F418}\u{1F438}]+/u.exec("\u{1F418}\uDC38\uD83D"), + ["\u{1F418}"]); +assertEqArray(/[\u{1F418}\u{1F438}]+/u.exec("\uDC18\uD83D\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/[\u{1F418}\u{1F438}]+/u.exec("\uDC18\u{1F438}\uD83D"), + ["\u{1F438}"]); + +// trail surrogate + lead surrogate +assertEq(/[\u{1F418}\u{1F438}]+/u.exec("\uDC18\uDC38\uD83D\uD83D"), + null); + +// ==== non-BMP + non-BMP range (from_lead == to_lead) ==== + +assertEqArray(/[\u{1F418}-\u{1F438}]/u.exec("\u{1F418}"), + ["\u{1F418}"]); +assertEqArray(/[\u{1F418}-\u{1F438}]/u.exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/[\u{1F418}-\u{1F438}]/u.exec("\u{1F427}"), + ["\u{1F427}"]); + +assertEq(/[\u{1F418}-\u{1F438}]/u.exec("\u{1F417}"), + null); +assertEq(/[\u{1F418}-\u{1F438}]/u.exec("\u{1F439}"), + null); + +// ==== non-BMP + non-BMP range (from_lead + 1 == to_lead) ==== + +assertEqArray(/[\u{1F17C}-\u{1F438}]/u.exec("\uD83C\uDD7C"), + ["\uD83C\uDD7C"]); +assertEqArray(/[\u{1F17C}-\u{1F438}]/u.exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/[\u{1F17C}-\u{1F438}]/u.exec("\uD83C\uDF99"), + ["\uD83C\uDF99"]); +assertEqArray(/[\u{1F17C}-\u{1F438}]/u.exec("\uD83D\uDC00"), + ["\uD83D\uDC00"]); + +assertEq(/[\u{1F17C}-\u{1F438}]/u.exec("\uD83C\uDD7B"), + null); +assertEq(/[\u{1F17C}-\u{1F438}]/u.exec("\uD83C\uE000"), + null); +assertEq(/[\u{1F17C}-\u{1F438}]/u.exec("\uD83D\uDB99"), + null); +assertEq(/[\u{1F17C}-\u{1F438}]/u.exec("\uD83D\uDC39"), + null); + +// ==== non-BMP + non-BMP range (from_lead + 2 == to_lead) ==== + +assertEqArray(/[\u{1F17C}-\u{1F829}]/u.exec("\uD83C\uDD7C"), + ["\uD83C\uDD7C"]); +assertEqArray(/[\u{1F17C}-\u{1F829}]/u.exec("\uD83E\uDC29"), + ["\uD83E\uDC29"]); + +assertEqArray(/[\u{1F17C}-\u{1F829}]/u.exec("\uD83C\uDF99"), + ["\uD83C\uDF99"]); +assertEqArray(/[\u{1F17C}-\u{1F829}]/u.exec("\uD83D\uDC00"), + ["\uD83D\uDC00"]); +assertEqArray(/[\u{1F17C}-\u{1F829}]/u.exec("\uD83D\uDF99"), + ["\uD83D\uDF99"]); +assertEqArray(/[\u{1F17C}-\u{1F829}]/u.exec("\uD83E\uDC00"), + ["\uD83E\uDC00"]); + +assertEq(/[\u{1F17C}-\u{1F829}]/u.exec("\uD83C\uDD7B"), + null); +assertEq(/[\u{1F17C}-\u{1F829}]/u.exec("\uD83C\uE000"), + null); +assertEq(/[\u{1F17C}-\u{1F829}]/u.exec("\uD83D\uDB99"), + null); +assertEq(/[\u{1F17C}-\u{1F829}]/u.exec("\uD83D\uE000"), + null); +assertEq(/[\u{1F17C}-\u{1F829}]/u.exec("\uD83E\uDB99"), + null); +assertEq(/[\u{1F17C}-\u{1F829}]/u.exec("\uD83E\uDC30"), + null); + +// ==== non-BMP + non-BMP range (other) ==== + +assertEqArray(/[\u{1D164}-\u{1F438}]/u.exec("\uD834\uDD64"), + ["\uD834\uDD64"]); +assertEqArray(/[\u{1D164}-\u{1F438}]/u.exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/[\u{1D164}-\u{1F438}]/u.exec("\uD836\uDF99"), + ["\uD836\uDF99"]); +assertEqArray(/[\u{1D164}-\u{1F438}]/u.exec("\uD838\uDC00"), + ["\uD838\uDC00"]); + +assertEq(/[\u{1D164}-\u{1F438}]/u.exec("\uD834\uDD63"), + null); +assertEq(/[\u{1D164}-\u{1F438}]/u.exec("\uD83D\uDC39"), + null); + +assertEq(/[\u{1D164}-\u{1F438}]/u.exec("\uD834\uE000"), + null); +assertEq(/[\u{1D164}-\u{1F438}]/u.exec("\uD835\uDB99"), + null); +assertEq(/[\u{1D164}-\u{1F438}]/u.exec("\uD83C\uE000"), + null); +assertEq(/[\u{1D164}-\u{1F438}]/u.exec("\uD83D\uDB99"), + null); + +// ==== BMP + non-BMP range ==== + +assertEqArray(/[\u{42}-\u{1F438}]/u.exec("B"), + ["B"]); +assertEqArray(/[\u{42}-\u{1F438}]/u.exec("C"), + ["C"]); +assertEqArray(/[\u{42}-\u{1F438}]/u.exec("\uFFFF"), + ["\uFFFF"]); +assertEqArray(/[\u{42}-\u{1F438}]/u.exec("\uD800\uDC00"), + ["\uD800\uDC00"]); + +assertEqArray(/[\u{42}-\u{1F438}]/u.exec("\uD800"), + ["\uD800"]); +assertEqArray(/[\u{42}-\u{1F438}]/u.exec("\uDBFF"), + ["\uDBFF"]); +assertEqArray(/[\u{42}-\u{1F438}]/u.exec("\uDC00"), + ["\uDC00"]); +assertEqArray(/[\u{42}-\u{1F438}]/u.exec("\uDFFF"), + ["\uDFFF"]); + +assertEqArray(/[\u{42}-\u{1F438}]/u.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/[\u{42}-\u{1F438}]/u.exec("\uDC38"), + ["\uDC38"]); + +assertEqArray(/[\u{42}-\u{1F438}]/u.exec("\uD83D\uDBFF"), + ["\uD83D"]); +assertEqArray(/[\u{42}-\u{1F438}]/u.exec("\uD83D\uDC00"), + ["\uD83D\uDC00"]); +assertEqArray(/[\u{42}-\u{1F438}]/u.exec("\uD83D\uDC38"), + ["\uD83D\uDC38"]); +assertEq(/[\u{42}-\u{1F438}]/u.exec("\uD83D\uDC39"), + null); +assertEq(/[\u{42}-\u{1F438}]/u.exec("\uD83D\uDFFF"), + null); +assertEqArray(/[\u{42}-\u{1F438}]/u.exec("\uD83D\uE000"), + ["\uD83D"]); + +assertEq(/[\u{42}-\u{1F438}]/u.exec("A"), + null); + +// ==== wrong patterns ==== + +assertThrowsInstanceOf(() => eval(`/[\\u{-1}]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u{0.0}]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u{G}]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u{}]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u{{]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u{]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u{110000}]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u{00110000}]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u{100000000000000000000000000000}]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u{FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF}]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u{ FFFF}]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u{FFFF }]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u{FF FF}]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u{F F F F}]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u{100000001}]/u`), SyntaxError); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-class-empty.js b/js/src/tests/ecma_6/RegExp/unicode-class-empty.js new file mode 100644 index 000000000..4d187551f --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-class-empty.js @@ -0,0 +1,25 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- empty class should not match anything."; + +print(BUGNUMBER + ": " + summary); + +assertEq(/[]/u.exec("A"), + null); +assertEq(/[]/u.exec("\uD83D"), + null); +assertEq(/[]/u.exec("\uDC38"), + null); +assertEq(/[]/u.exec("\uD83D\uDC38"), + null); + +assertEqArray(/[^]/u.exec("A"), + ["A"]); +assertEqArray(/[^]/u.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/[^]/u.exec("\uDC38"), + ["\uDC38"]); +assertEqArray(/[^]/u.exec("\uD83D\uDC38"), + ["\uD83D\uDC38"]); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-class-ignoreCase.js b/js/src/tests/ecma_6/RegExp/unicode-class-ignoreCase.js new file mode 100644 index 000000000..afa7705c7 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-class-ignoreCase.js @@ -0,0 +1,28 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- ignoreCase flag for CharacterClass."; + +print(BUGNUMBER + ": " + summary); + +assertEqArray(/[ABC]+/iu.exec("DCBAabcd"), + ["CBAabc"]); + +assertEqArray(/[A\u{10401}]+/iu.exec("A\u{10401}a\u{10429}"), + ["A\u{10401}a\u{10429}"]); + +assertEqArray(/[\u{10401}-\u{10404}\u{10408}-\u{1040B}]+/iu.exec("\u{10400}\u{10401}\u{10402}\u{10403}\u{10404}\u{10408}\u{10409}\u{1040A}\u{1040B}\u{1040C}"), + ["\u{10401}\u{10402}\u{10403}\u{10404}\u{10408}\u{10409}\u{1040A}\u{1040B}"]); +assertEqArray(/[\u{10401}-\u{10404}\u{10408}-\u{1040B}]+/iu.exec("\u{10428}\u{10429}\u{1042A}\u{1042B}\u{1042C}\u{10430}\u{10431}\u{10432}\u{10433}\u{10434}"), + ["\u{10429}\u{1042A}\u{1042B}\u{1042C}\u{10430}\u{10431}\u{10432}\u{10433}"]); + +assertEqArray(/[\u{10429}-\u{1042C}\u{10430}-\u{10433}]+/iu.exec("\u{10400}\u{10401}\u{10402}\u{10403}\u{10404}\u{10408}\u{10409}\u{1040A}\u{1040B}\u{1040C}"), + ["\u{10401}\u{10402}\u{10403}\u{10404}\u{10408}\u{10409}\u{1040A}\u{1040B}"]); +assertEqArray(/[\u{10429}-\u{1042C}\u{10430}-\u{10433}]+/iu.exec("\u{10428}\u{10429}\u{1042A}\u{1042B}\u{1042C}\u{10430}\u{10431}\u{10432}\u{10433}\u{10434}"), + ["\u{10429}\u{1042A}\u{1042B}\u{1042C}\u{10430}\u{10431}\u{10432}\u{10433}"]); + +assertEqArray(/[\u{10401}-\u{10404}\u{10430}-\u{10433}]+/iu.exec("\u{10400}\u{10401}\u{10402}\u{10403}\u{10404}\u{10408}\u{10409}\u{1040A}\u{1040B}\u{1040C}"), + ["\u{10401}\u{10402}\u{10403}\u{10404}\u{10408}\u{10409}\u{1040A}\u{1040B}"]); +assertEqArray(/[\u{10401}-\u{10404}\u{10430}-\u{10433}]+/iu.exec("\u{10428}\u{10429}\u{1042A}\u{1042B}\u{1042C}\u{10430}\u{10431}\u{10432}\u{10433}\u{10434}"), + ["\u{10429}\u{1042A}\u{1042B}\u{1042C}\u{10430}\u{10431}\u{10432}\u{10433}"]); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-class-lead-trail.js b/js/src/tests/ecma_6/RegExp/unicode-class-lead-trail.js new file mode 100644 index 000000000..c83bf937d --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-class-lead-trail.js @@ -0,0 +1,142 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- lead and trail pattern in RegExpUnicodeEscapeSequence in CharacterClass."; + +print(BUGNUMBER + ": " + summary); + +// ==== standalone ==== + +assertEqArray(/[\uD83D\uDC38]/u.exec("\uD83D\uDC38"), + ["\uD83D\uDC38"]); +assertEq(/[\uD83D\uDC38]/u.exec("\uD83D"), + null); +assertEq(/[\uD83D\uDC38]/u.exec("\uDC38"), + null); + +// no unicode flag +assertEqArray(/[\uD83D\uDC38]/.exec("\uD83D\uDC38"), + ["\uD83D"]); +assertEqArray(/[\uD83D\uDC38]/.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/[\uD83D\uDC38]/.exec("\uDC38"), + ["\uDC38"]); + +// RegExp constructor +assertEqArray(new RegExp("[\uD83D\uDC38]", "u").exec("\uD83D\uDC38"), + ["\uD83D\uDC38"]); +assertEq(new RegExp("[\uD83D\uDC38]", "u").exec("\uD83D"), + null); +assertEq(new RegExp("[\uD83D\uDC38]", "u").exec("\uDC38"), + null); + +// RegExp constructor, no unicode flag +assertEqArray(new RegExp("[\uD83D\uDC38]", "").exec("\uD83D\uDC38"), + ["\uD83D"]); +assertEqArray(new RegExp("[\uD83D\uDC38]", "").exec("\uD83D"), + ["\uD83D"]); +assertEqArray(new RegExp("[\uD83D\uDC38]", "").exec("\uDC38"), + ["\uDC38"]); + +// ==== lead-only ==== + +// match only non-surrogate pair +assertEqArray(/[\uD83D]/u.exec("\uD83D\uDBFF"), + ["\uD83D"]); +assertEq(/[\uD83D]/u.exec("\uD83D\uDC00"), + null); +assertEq(/[\uD83D]/u.exec("\uD83D\uDFFF"), + null); +assertEqArray(/[\uD83D]/u.exec("\uD83D\uE000"), + ["\uD83D"]); + +// match before non-tail char +assertEqArray(/[\uD83D]/u.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/[\uD83D]/u.exec("\uD83DA"), + ["\uD83D"]); + +// no unicode flag +assertEqArray(/[\uD83D]/.exec("\uD83D\uDBFF"), + ["\uD83D"]); +assertEqArray(/[\uD83D]/.exec("\uD83D\uDC00"), + ["\uD83D"]); +assertEqArray(/[\uD83D]/.exec("\uD83D\uDFFF"), + ["\uD83D"]); +assertEqArray(/[\uD83D]/.exec("\uD83D\uE000"), + ["\uD83D"]); +assertEqArray(/[\uD83D]/.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/[\uD83D]/.exec("\uD83DA"), + ["\uD83D"]); + +// ==== trail-only ==== + +// match only non-surrogate pair +assertEqArray(/[\uDC38]/u.exec("\uD7FF\uDC38"), + ["\uDC38"]); +assertEq(/[\uDC38]/u.exec("\uD800\uDC38"), + null); +assertEq(/[\uDC38]/u.exec("\uDBFF\uDC38"), + null); +assertEqArray(/[\uDC38]/u.exec("\uDC00\uDC38"), + ["\uDC38"]); + +// match after non-lead char +assertEqArray(/[\uDC38]/u.exec("\uDC38"), + ["\uDC38"]); +assertEqArray(/[\uDC38]/u.exec("A\uDC38"), + ["\uDC38"]); + +// no unicode flag +assertEqArray(/[\uDC38]/.exec("\uD7FF\uDC38"), + ["\uDC38"]); +assertEqArray(/[\uDC38]/.exec("\uD800\uDC38"), + ["\uDC38"]); +assertEqArray(/[\uDC38]/.exec("\uDBFF\uDC38"), + ["\uDC38"]); +assertEqArray(/[\uDC38]/.exec("\uDC00\uDC38"), + ["\uDC38"]); +assertEqArray(/[\uDC38]/.exec("\uDC38"), + ["\uDC38"]); +assertEqArray(/[\uDC38]/.exec("A\uDC38"), + ["\uDC38"]); + +// ==== invalid trail ==== + +assertEqArray(/[\uD83D\u3042]*/u.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/[\uD83D\u3042]*/u.exec("\uD83D\u3042"), + ["\uD83D\u3042"]); +assertEqArray(/[\uD83D\u3042]*/u.exec("\uD83D\u3042\u3042\uD83D"), + ["\uD83D\u3042\u3042\uD83D"]); + +assertEqArray(/[\uD83D\u{3042}]*/u.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/[\uD83D\u{3042}]*/u.exec("\uD83D\u3042"), + ["\uD83D\u3042"]); +assertEqArray(/[\uD83D\u{3042}]*/u.exec("\uD83D\u3042\u3042\uD83D"), + ["\uD83D\u3042\u3042\uD83D"]); + +assertEqArray(/[\uD83DA]*/u.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/[\uD83DA]*/u.exec("\uD83DA"), + ["\uD83DA"]); +assertEqArray(/[\uD83DA]*/u.exec("\uD83DAA\uD83D"), + ["\uD83DAA\uD83D"]); + +// ==== wrong patterns ==== + +assertThrowsInstanceOf(() => eval(`/[\\u]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u0]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u00]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u000]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u000G]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\u0.00]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\uD83D\\u]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\uD83D\\u0]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\uD83D\\u00]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\uD83D\\u000]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\uD83D\\u000G]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\uD83D\\u0.00]/u`), SyntaxError); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-class-negated.js b/js/src/tests/ecma_6/RegExp/unicode-class-negated.js new file mode 100644 index 000000000..0b573f6dc --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-class-negated.js @@ -0,0 +1,64 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- negated CharacterClass."; + +print(BUGNUMBER + ": " + summary); + +// ==== BMP ==== + +assertEqArray(/[^A]/u.exec("ABC"), + ["B"]); +assertEqArray(/[^A]/u.exec("A\u{1F438}C"), + ["\u{1F438}"]); +assertEqArray(/[^A]/u.exec("A\uD83DC"), + ["\uD83D"]); +assertEqArray(/[^A]/u.exec("A\uDC38C"), + ["\uDC38"]); + +assertEqArray(/[^\uE000]/u.exec("\uE000\uE001"), + ["\uE001"]); +assertEqArray(/[^\uE000]/u.exec("\uE000\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/[^\uE000]/u.exec("\uE000\uD83D"), + ["\uD83D"]); +assertEqArray(/[^\uE000]/u.exec("\uE000\uDC38"), + ["\uDC38"]); + +// ==== non-BMP ==== + +assertEqArray(/[^\u{1F438}]/u.exec("\u{1F438}A"), + ["A"]); +assertEqArray(/[^\u{1F438}]/u.exec("\u{1F438}\u{1F439}"), + ["\u{1F439}"]); +assertEqArray(/[^\u{1F438}]/u.exec("\u{1F438}\uD83D"), + ["\uD83D"]); +assertEqArray(/[^\u{1F438}]/u.exec("\u{1F438}\uDC38"), + ["\uDC38"]); + +// ==== lead-only ==== + +assertEqArray(/[^\uD83D]/u.exec("\u{1F438}A"), + ["\u{1F438}"]); +assertEqArray(/[^\uD83D]/u.exec("\uD83D\uDBFF"), + ["\uDBFF"]); +assertEqArray(/[^\uD83D]/u.exec("\uD83D\uDC00"), + ["\uD83D\uDC00"]); +assertEqArray(/[^\uD83D]/u.exec("\uD83D\uDFFF"), + ["\uD83D\uDFFF"]); +assertEqArray(/[^\uD83D]/u.exec("\uD83D\uE000"), + ["\uE000"]); + +// ==== trail-only ==== + +assertEqArray(/[^\uDC38]/u.exec("\u{1F438}A"), + ["\u{1F438}"]); +assertEqArray(/[^\uDC38]/u.exec("\uD7FF\uDC38"), + ["\uD7FF"]); +assertEqArray(/[^\uDC38]/u.exec("\uD800\uDC38"), + ["\uD800\uDC38"]); +assertEqArray(/[^\uDC38]/u.exec("\uDBFF\uDC38"), + ["\uDBFF\uDC38"]); +assertEqArray(/[^\uDC38]/u.exec("\uDC00\uDC38"), + ["\uDC00"]); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-class-range.js b/js/src/tests/ecma_6/RegExp/unicode-class-range.js new file mode 100644 index 000000000..5bb757560 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-class-range.js @@ -0,0 +1,28 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- disallow range with CharacterClassEscape."; + +print(BUGNUMBER + ": " + summary); + +assertThrowsInstanceOf(() => eval(`/[\\w-\\uFFFF]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\W-\\uFFFF]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\d-\\uFFFF]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\D-\\uFFFF]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\s-\\uFFFF]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\S-\\uFFFF]/u`), SyntaxError); + +assertThrowsInstanceOf(() => eval(`/[\\uFFFF-\\w]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\uFFFF-\\W]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\uFFFF-\\d]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\uFFFF-\\D]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\uFFFF-\\s]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\uFFFF-\\S]/u`), SyntaxError); + +assertThrowsInstanceOf(() => eval(`/[\\w-\\w]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\W-\\W]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\d-\\d]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\D-\\D]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\s-\\s]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\S-\\S]/u`), SyntaxError); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-class-raw.js b/js/src/tests/ecma_6/RegExp/unicode-class-raw.js new file mode 100644 index 000000000..742fec2b4 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-class-raw.js @@ -0,0 +1,65 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- raw unicode."; + +print(BUGNUMBER + ": " + summary); + +// ==== standalone ==== + +assertEqArray(eval(`/[\uD83D\uDC38]/u`).exec("\u{1F438}"), + ["\u{1F438}"]); + +// no unicode flag +assertEqArray(eval(`/[\uD83D\uDC38]/`).exec("\u{1F438}"), + ["\uD83D"]); + +// escaped (lead) +assertEq(eval(`/[\\uD83D\uDC38]/u`).exec("\u{1F438}"), + null); +assertEq(eval(`/[\\u{D83D}\uDC38]/u`).exec("\u{1F438}"), + null); + +// escaped (trail) +assertEq(eval(`/[\uD83D\\uDC38]/u`).exec("\u{1F438}"), + null); +assertEq(eval(`/[\uD83D\\u{DC38}]/u`).exec("\u{1F438}"), + null); + +// escaped (lead), no unicode flag +assertEqArray(eval(`/[\\uD83D\uDC38]/`).exec("\u{1F438}"), + ["\uD83D"]); + +// escaped (trail), no unicode flag +assertEqArray(eval(`/[\uD83D\\uDC38]/`).exec("\u{1F438}"), + ["\uD83D"]); + +// ==== RegExp constructor ==== + +assertEqArray(new RegExp("[\uD83D\uDC38]", "u").exec("\u{1F438}"), + ["\u{1F438}"]); + +// no unicode flag +assertEqArray(new RegExp("[\uD83D\uDC38]", "").exec("\u{1F438}"), + ["\uD83D"]); + +// escaped(lead) +assertEq(new RegExp("[\\uD83D\uDC38]", "u").exec("\u{1F438}"), + null); +assertEq(new RegExp("[\\u{D83D}\uDC38]", "u").exec("\u{1F438}"), + null); + +// escaped(trail) +assertEq(new RegExp("[\uD83D\\uDC38]", "u").exec("\u{1F438}"), + null); +assertEq(new RegExp("[\uD83D\\u{DC38}]", "u").exec("\u{1F438}"), + null); + +// escaped(lead), no unicode flag +assertEqArray(new RegExp("[\\uD83D\uDC38]", "").exec("\u{1F438}"), + ["\uD83D"]); + +// escaped(trail), no unicode flag +assertEqArray(new RegExp("[\uD83D\\uDC38]", "").exec("\u{1F438}"), + ["\uD83D"]); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-disallow-extended.js b/js/src/tests/ecma_6/RegExp/unicode-disallow-extended.js new file mode 100644 index 000000000..d1f775fac --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-disallow-extended.js @@ -0,0 +1,117 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- disallow extended patterns."; + +print(BUGNUMBER + ": " + summary); + +// IdentityEscape + +assertEqArray(/\^\$\\\.\*\+\?\(\)\[\]\{\}\|/u.exec("^$\\.*+?()[]{}|"), + ["^$\\.*+?()[]{}|"]); +assertThrowsInstanceOf(() => eval(`/\\A/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\-/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\U{10}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\U0000/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\uD83D\\U0000/u`), SyntaxError); + +assertEqArray(/[\^\$\\\.\*\+\?\(\)\[\]\{\}\|]+/u.exec("^$\\.*+?()[]{}|"), + ["^$\\.*+?()[]{}|"]); +assertThrowsInstanceOf(() => eval(`/[\\A]/u`), SyntaxError); +assertEqArray(/[A\-Z]+/u.exec("a-zABC"), + ["-"]); +assertThrowsInstanceOf(() => eval(`/[\\U{10}]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\U0000]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\uD83D\\U0000]/u`), SyntaxError); + +// PatternCharacter +assertThrowsInstanceOf(() => eval(`/{}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/{/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/{0}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/{1,}/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/{1,2}/u`), SyntaxError); + +// QuantifiableAssertion +assertEqArray(/.B(?=A)/u.exec("cBaCBA"), + ["CB"]); +assertEqArray(/.B(?!A)/u.exec("CBAcBa"), + ["cB"]); +assertEqArray(/.B(?:A)/u.exec("cBaCBA"), + ["CBA"]); +assertEqArray(/.B(A)/u.exec("cBaCBA"), + ["CBA", "A"]); + +assertThrowsInstanceOf(() => eval(`/.B(?=A)+/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/.B(?!A)+/u`), SyntaxError); +assertEqArray(/.B(?:A)+/u.exec("cBaCBA"), + ["CBA"]); +assertEqArray(/.B(A)+/u.exec("cBaCBA"), + ["CBA", "A"]); + +// ControlLetter +assertEqArray(/\cA/u.exec("\u0001"), + ["\u0001"]); +assertEqArray(/\cZ/u.exec("\u001a"), + ["\u001a"]); +assertEqArray(/\ca/u.exec("\u0001"), + ["\u0001"]); +assertEqArray(/\cz/u.exec("\u001a"), + ["\u001a"]); + +assertEqArray(/[\cA]/u.exec("\u0001"), + ["\u0001"]); +assertEqArray(/[\cZ]/u.exec("\u001a"), + ["\u001a"]); +assertEqArray(/[\ca]/u.exec("\u0001"), + ["\u0001"]); +assertEqArray(/[\cz]/u.exec("\u001a"), + ["\u001a"]); + +assertThrowsInstanceOf(() => eval(`/\\c/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\c1/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\c_/u`), SyntaxError); + +assertThrowsInstanceOf(() => eval(`/[\\c]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\c1]/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/[\\c_]/u`), SyntaxError); + +// HexEscapeSequence +assertThrowsInstanceOf(() => eval(`/\\x/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\x0/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\x1/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\x1G/u`), SyntaxError); + +// LegacyOctalEscapeSequence +assertThrowsInstanceOf(() => eval(`/\\52/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\052/u`), SyntaxError); + +// DecimalEscape +assertEqArray(/\0/u.exec("\0"), + ["\0"]); +assertEqArray(/[\0]/u.exec("\0"), + ["\0"]); +assertEqArray(/\0A/u.exec("\0A"), + ["\0A"]); +assertEqArray(/\0G/u.exec("\0G"), + ["\0G"]); +assertEqArray(/(A.)\1/u.exec("ABACABAB"), + ["ABAB", "AB"]); +assertEqArray(/(A.)(B.)(C.)(D.)(E.)(F.)(G.)(H.)(I.)(J.)(K.)\10/u.exec("A1B2C3D4E5F6G7H8I9JaKbJa"), + ["A1B2C3D4E5F6G7H8I9JaKbJa", "A1", "B2", "C3", "D4", "E5", "F6", "G7", "H8", "I9", "Ja", "Kb"]); + +assertThrowsInstanceOf(() => eval(`/\\00/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\01/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\09/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\1/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\2/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\3/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\4/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\5/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\6/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\7/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\8/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\9/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\10/u`), SyntaxError); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-everything.js b/js/src/tests/ecma_6/RegExp/unicode-everything.js new file mode 100644 index 000000000..a18ac2867 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-everything.js @@ -0,0 +1,59 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- everything Atom."; + +print(BUGNUMBER + ": " + summary); + +// ==== standalone ==== + +assertEqArray(/./u.exec("ABC"), + ["A"]); +assertEqArray(/./u.exec("\u{1F438}BC"), + ["\u{1F438}"]); + +assertEqArray(/./u.exec("\uD83D\uDBFF"), + ["\uD83D"]); +assertEqArray(/./u.exec("\uD83D\uDC00"), + ["\uD83D\uDC00"]); +assertEqArray(/./u.exec("\uD83D\uDFFF"), + ["\uD83D\uDFFF"]); +assertEqArray(/./u.exec("\uD83D\uE000"), + ["\uD83D"]); +assertEqArray(/./u.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/./u.exec("\uD83DA"), + ["\uD83D"]); + +assertEqArray(/./u.exec("\uD7FF\uDC38"), + ["\uD7FF"]); +assertEqArray(/./u.exec("\uD800\uDC38"), + ["\uD800\uDC38"]); +assertEqArray(/./u.exec("\uDBFF\uDC38"), + ["\uDBFF\uDC38"]); +assertEqArray(/./u.exec("\uDC00\uDC38"), + ["\uDC00"]); +assertEqArray(/./u.exec("\uDC38"), + ["\uDC38"]); +assertEqArray(/./u.exec("A\uDC38"), + ["A"]); + +assertEqArray(/.A/u.exec("\uD7FF\uDC38A"), + ["\uDC38A"]); +assertEqArray(/.A/u.exec("\uD800\uDC38A"), + ["\uD800\uDC38A"]); +assertEqArray(/.A/u.exec("\uDBFF\uDC38A"), + ["\uDBFF\uDC38A"]); +assertEqArray(/.A/u.exec("\uDC00\uDC38A"), + ["\uDC38A"]); + +// ==== leading multiple ==== + +assertEqArray(/.*A/u.exec("\u{1F438}\u{1F438}\u{1F438}A"), + ["\u{1F438}\u{1F438}\u{1F438}A"]); + +// ==== trailing multiple ==== + +assertEqArray(/A.*/u.exec("A\u{1F438}\u{1F438}\u{1F438}"), + ["A\u{1F438}\u{1F438}\u{1F438}"]); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-ignoreCase-ascii.js b/js/src/tests/ecma_6/RegExp/unicode-ignoreCase-ascii.js new file mode 100644 index 000000000..6d453290e --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-ignoreCase-ascii.js @@ -0,0 +1,45 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- ignoreCase flag with non-ascii to ascii map."; + +print(BUGNUMBER + ": " + summary); + +// LATIN CAPITAL LETTER Y WITH DIAERESIS +assertEqArray(/\u0178/iu.exec("\u00FF"), + ["\u00FF"]); +assertEqArray(/\u00FF/iu.exec("\u0178"), + ["\u0178"]); + +// LATIN SMALL LETTER LONG S +assertEqArray(/\u017F/iu.exec("S"), + ["S"]); +assertEqArray(/\u017F/iu.exec("s"), + ["s"]); +assertEqArray(/S/iu.exec("\u017F"), + ["\u017F"]); +assertEqArray(/s/iu.exec("\u017F"), + ["\u017F"]); + +// LATIN CAPITAL LETTER SHARP S +assertEqArray(/\u1E9E/iu.exec("\u00DF"), + ["\u00DF"]); +assertEqArray(/\u00DF/iu.exec("\u1E9E"), + ["\u1E9E"]); + +// KELVIN SIGN +assertEqArray(/\u212A/iu.exec("K"), + ["K"]); +assertEqArray(/\u212A/iu.exec("k"), + ["k"]); +assertEqArray(/K/iu.exec("\u212A"), + ["\u212A"]); +assertEqArray(/k/iu.exec("\u212A"), + ["\u212A"]); + +// ANGSTROM SIGN +assertEqArray(/\u212B/iu.exec("\u00E5"), + ["\u00E5"]); +assertEqArray(/\u00E5/iu.exec("\u212B"), + ["\u212B"]); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-ignoreCase-escape.js b/js/src/tests/ecma_6/RegExp/unicode-ignoreCase-escape.js new file mode 100644 index 000000000..d731fb6bb --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-ignoreCase-escape.js @@ -0,0 +1,71 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- ignoreCase flag with character class escape."; + +// \W doesn't match S or K from the change in +// https://github.com/tc39/ecma262/pull/525 +// (bug 1281739) + +print(BUGNUMBER + ": " + summary); + +// LATIN SMALL LETTER LONG S + +assertEqArray(/\w/iu.exec("S"), + ["S"]); +assertEqArray(/\w/iu.exec("s"), + ["s"]); +assertEqArray(/\w/iu.exec("\u017F"), + ["\u017F"]); + +assertEqArray(/[^\W]/iu.exec("S"), + ["S"]); +assertEqArray(/[^\W]/iu.exec("s"), + ["s"]); +assertEqArray(/[^\W]/iu.exec("\u017F"), + ["\u017F"]); + +assertEq(/\W/iu.exec("S"), + null); +assertEq(/\W/iu.exec("s"), + null); +assertEq(/\W/iu.exec("\u017F"), + null); + +assertEq(/[^\w]/iu.exec("S"), + null); +assertEq(/[^\w]/iu.exec("s"), + null); +assertEq(/[^\w]/iu.exec("\u017F"), + null); + +// KELVIN SIGN + +assertEqArray(/\w/iu.exec("k"), + ["k"]); +assertEqArray(/\w/iu.exec("k"), + ["k"]); +assertEqArray(/\w/iu.exec("\u212A"), + ["\u212A"]); + +assertEqArray(/[^\W]/iu.exec("k"), + ["k"]); +assertEqArray(/[^\W]/iu.exec("k"), + ["k"]); +assertEqArray(/[^\W]/iu.exec("\u212A"), + ["\u212A"]); + +assertEq(/\W/iu.exec("k"), + null); +assertEq(/\W/iu.exec("k"), + null); +assertEq(/\W/iu.exec("\u212A"), + null); + +assertEq(/[^\w]/iu.exec("k"), + null); +assertEq(/[^\w]/iu.exec("k"), + null); +assertEq(/[^\w]/iu.exec("\u212A"), + null); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-ignoreCase-negated.js b/js/src/tests/ecma_6/RegExp/unicode-ignoreCase-negated.js new file mode 100644 index 000000000..30909a515 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-ignoreCase-negated.js @@ -0,0 +1,19 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- ignoreCase flag with negated character class."; + +print(BUGNUMBER + ": " + summary); + +assertEq(/[^A]/iu.exec("A"), + null); +assertEq(/[^a]/iu.exec("A"), + null); +assertEq(/[^A]/iu.exec("a"), + null); +assertEq(/[^a]/iu.exec("a"), + null); + +assertEqArray(/[^A]/iu.exec("b"), + ["b"]); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-ignoreCase.js b/js/src/tests/ecma_6/RegExp/unicode-ignoreCase.js new file mode 100644 index 000000000..28b2e77dc --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-ignoreCase.js @@ -0,0 +1,2643 @@ +/* Generated by make_unicode.py DO NOT MODIFY */ +/* Unicode version: 9.0.0 */ + +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- ignoreCase flag."; + +print(BUGNUMBER + ": " + summary); + +function test(code, ...equivs) { + var codeRe = new RegExp(String.fromCodePoint(code) + "+", "iu"); + var ans = String.fromCodePoint(code) + equivs.map(c => String.fromCodePoint(c)).join(""); + assertEqArray(codeRe.exec("<" + ans + ">"), [ans]); + codeRe = new RegExp("[" + String.fromCodePoint(code) + "]+", "iu"); + assertEqArray(codeRe.exec("<" + ans + ">"), [ans]); +} +test(0x41,0x61); +test(0x42,0x62); +test(0x43,0x63); +test(0x44,0x64); +test(0x45,0x65); +test(0x46,0x66); +test(0x47,0x67); +test(0x48,0x68); +test(0x49,0x69); +test(0x4a,0x6a); +test(0x4b,0x6b,0x212a); +test(0x4c,0x6c); +test(0x4d,0x6d); +test(0x4e,0x6e); +test(0x4f,0x6f); +test(0x50,0x70); +test(0x51,0x71); +test(0x52,0x72); +test(0x53,0x73,0x17f); +test(0x54,0x74); +test(0x55,0x75); +test(0x56,0x76); +test(0x57,0x77); +test(0x58,0x78); +test(0x59,0x79); +test(0x5a,0x7a); +test(0x61,0x41); +test(0x62,0x42); +test(0x63,0x43); +test(0x64,0x44); +test(0x65,0x45); +test(0x66,0x46); +test(0x67,0x47); +test(0x68,0x48); +test(0x69,0x49); +test(0x6a,0x4a); +test(0x6b,0x4b,0x212a); +test(0x6c,0x4c); +test(0x6d,0x4d); +test(0x6e,0x4e); +test(0x6f,0x4f); +test(0x70,0x50); +test(0x71,0x51); +test(0x72,0x52); +test(0x73,0x53,0x17f); +test(0x74,0x54); +test(0x75,0x55); +test(0x76,0x56); +test(0x77,0x57); +test(0x78,0x58); +test(0x79,0x59); +test(0x7a,0x5a); +test(0xb5,0x3bc,0x39c); +test(0xc0,0xe0); +test(0xc1,0xe1); +test(0xc2,0xe2); +test(0xc3,0xe3); +test(0xc4,0xe4); +test(0xc5,0xe5,0x212b); +test(0xc6,0xe6); +test(0xc7,0xe7); +test(0xc8,0xe8); +test(0xc9,0xe9); +test(0xca,0xea); +test(0xcb,0xeb); +test(0xcc,0xec); +test(0xcd,0xed); +test(0xce,0xee); +test(0xcf,0xef); +test(0xd0,0xf0); +test(0xd1,0xf1); +test(0xd2,0xf2); +test(0xd3,0xf3); +test(0xd4,0xf4); +test(0xd5,0xf5); +test(0xd6,0xf6); +test(0xd8,0xf8); +test(0xd9,0xf9); +test(0xda,0xfa); +test(0xdb,0xfb); +test(0xdc,0xfc); +test(0xdd,0xfd); +test(0xde,0xfe); +test(0xdf,0x1e9e); +test(0xe0,0xc0); +test(0xe1,0xc1); +test(0xe2,0xc2); +test(0xe3,0xc3); +test(0xe4,0xc4); +test(0xe5,0xc5,0x212b); +test(0xe6,0xc6); +test(0xe7,0xc7); +test(0xe8,0xc8); +test(0xe9,0xc9); +test(0xea,0xca); +test(0xeb,0xcb); +test(0xec,0xcc); +test(0xed,0xcd); +test(0xee,0xce); +test(0xef,0xcf); +test(0xf0,0xd0); +test(0xf1,0xd1); +test(0xf2,0xd2); +test(0xf3,0xd3); +test(0xf4,0xd4); +test(0xf5,0xd5); +test(0xf6,0xd6); +test(0xf8,0xd8); +test(0xf9,0xd9); +test(0xfa,0xda); +test(0xfb,0xdb); +test(0xfc,0xdc); +test(0xfd,0xdd); +test(0xfe,0xde); +test(0xff,0x178); +test(0x100,0x101); +test(0x101,0x100); +test(0x102,0x103); +test(0x103,0x102); +test(0x104,0x105); +test(0x105,0x104); +test(0x106,0x107); +test(0x107,0x106); +test(0x108,0x109); +test(0x109,0x108); +test(0x10a,0x10b); +test(0x10b,0x10a); +test(0x10c,0x10d); +test(0x10d,0x10c); +test(0x10e,0x10f); +test(0x10f,0x10e); +test(0x110,0x111); +test(0x111,0x110); +test(0x112,0x113); +test(0x113,0x112); +test(0x114,0x115); +test(0x115,0x114); +test(0x116,0x117); +test(0x117,0x116); +test(0x118,0x119); +test(0x119,0x118); +test(0x11a,0x11b); +test(0x11b,0x11a); +test(0x11c,0x11d); +test(0x11d,0x11c); +test(0x11e,0x11f); +test(0x11f,0x11e); +test(0x120,0x121); +test(0x121,0x120); +test(0x122,0x123); +test(0x123,0x122); +test(0x124,0x125); +test(0x125,0x124); +test(0x126,0x127); +test(0x127,0x126); +test(0x128,0x129); +test(0x129,0x128); +test(0x12a,0x12b); +test(0x12b,0x12a); +test(0x12c,0x12d); +test(0x12d,0x12c); +test(0x12e,0x12f); +test(0x12f,0x12e); +test(0x132,0x133); +test(0x133,0x132); +test(0x134,0x135); +test(0x135,0x134); +test(0x136,0x137); +test(0x137,0x136); +test(0x139,0x13a); +test(0x13a,0x139); +test(0x13b,0x13c); +test(0x13c,0x13b); +test(0x13d,0x13e); +test(0x13e,0x13d); +test(0x13f,0x140); +test(0x140,0x13f); +test(0x141,0x142); +test(0x142,0x141); +test(0x143,0x144); +test(0x144,0x143); +test(0x145,0x146); +test(0x146,0x145); +test(0x147,0x148); +test(0x148,0x147); +test(0x14a,0x14b); +test(0x14b,0x14a); +test(0x14c,0x14d); +test(0x14d,0x14c); +test(0x14e,0x14f); +test(0x14f,0x14e); +test(0x150,0x151); +test(0x151,0x150); +test(0x152,0x153); +test(0x153,0x152); +test(0x154,0x155); +test(0x155,0x154); +test(0x156,0x157); +test(0x157,0x156); +test(0x158,0x159); +test(0x159,0x158); +test(0x15a,0x15b); +test(0x15b,0x15a); +test(0x15c,0x15d); +test(0x15d,0x15c); +test(0x15e,0x15f); +test(0x15f,0x15e); +test(0x160,0x161); +test(0x161,0x160); +test(0x162,0x163); +test(0x163,0x162); +test(0x164,0x165); +test(0x165,0x164); +test(0x166,0x167); +test(0x167,0x166); +test(0x168,0x169); +test(0x169,0x168); +test(0x16a,0x16b); +test(0x16b,0x16a); +test(0x16c,0x16d); +test(0x16d,0x16c); +test(0x16e,0x16f); +test(0x16f,0x16e); +test(0x170,0x171); +test(0x171,0x170); +test(0x172,0x173); +test(0x173,0x172); +test(0x174,0x175); +test(0x175,0x174); +test(0x176,0x177); +test(0x177,0x176); +test(0x178,0xff); +test(0x179,0x17a); +test(0x17a,0x179); +test(0x17b,0x17c); +test(0x17c,0x17b); +test(0x17d,0x17e); +test(0x17e,0x17d); +test(0x17f,0x73,0x53); +test(0x180,0x243); +test(0x181,0x253); +test(0x182,0x183); +test(0x183,0x182); +test(0x184,0x185); +test(0x185,0x184); +test(0x186,0x254); +test(0x187,0x188); +test(0x188,0x187); +test(0x189,0x256); +test(0x18a,0x257); +test(0x18b,0x18c); +test(0x18c,0x18b); +test(0x18e,0x1dd); +test(0x18f,0x259); +test(0x190,0x25b); +test(0x191,0x192); +test(0x192,0x191); +test(0x193,0x260); +test(0x194,0x263); +test(0x195,0x1f6); +test(0x196,0x269); +test(0x197,0x268); +test(0x198,0x199); +test(0x199,0x198); +test(0x19a,0x23d); +test(0x19c,0x26f); +test(0x19d,0x272); +test(0x19e,0x220); +test(0x19f,0x275); +test(0x1a0,0x1a1); +test(0x1a1,0x1a0); +test(0x1a2,0x1a3); +test(0x1a3,0x1a2); +test(0x1a4,0x1a5); +test(0x1a5,0x1a4); +test(0x1a6,0x280); +test(0x1a7,0x1a8); +test(0x1a8,0x1a7); +test(0x1a9,0x283); +test(0x1ac,0x1ad); +test(0x1ad,0x1ac); +test(0x1ae,0x288); +test(0x1af,0x1b0); +test(0x1b0,0x1af); +test(0x1b1,0x28a); +test(0x1b2,0x28b); +test(0x1b3,0x1b4); +test(0x1b4,0x1b3); +test(0x1b5,0x1b6); +test(0x1b6,0x1b5); +test(0x1b7,0x292); +test(0x1b8,0x1b9); +test(0x1b9,0x1b8); +test(0x1bc,0x1bd); +test(0x1bd,0x1bc); +test(0x1bf,0x1f7); +test(0x1c4,0x1c6,0x1c5); +test(0x1c5,0x1c6,0x1c4); +test(0x1c6,0x1c4,0x1c5); +test(0x1c7,0x1c9,0x1c8); +test(0x1c8,0x1c9,0x1c7); +test(0x1c9,0x1c7,0x1c8); +test(0x1ca,0x1cc,0x1cb); +test(0x1cb,0x1cc,0x1ca); +test(0x1cc,0x1ca,0x1cb); +test(0x1cd,0x1ce); +test(0x1ce,0x1cd); +test(0x1cf,0x1d0); +test(0x1d0,0x1cf); +test(0x1d1,0x1d2); +test(0x1d2,0x1d1); +test(0x1d3,0x1d4); +test(0x1d4,0x1d3); +test(0x1d5,0x1d6); +test(0x1d6,0x1d5); +test(0x1d7,0x1d8); +test(0x1d8,0x1d7); +test(0x1d9,0x1da); +test(0x1da,0x1d9); +test(0x1db,0x1dc); +test(0x1dc,0x1db); +test(0x1dd,0x18e); +test(0x1de,0x1df); +test(0x1df,0x1de); +test(0x1e0,0x1e1); +test(0x1e1,0x1e0); +test(0x1e2,0x1e3); +test(0x1e3,0x1e2); +test(0x1e4,0x1e5); +test(0x1e5,0x1e4); +test(0x1e6,0x1e7); +test(0x1e7,0x1e6); +test(0x1e8,0x1e9); +test(0x1e9,0x1e8); +test(0x1ea,0x1eb); +test(0x1eb,0x1ea); +test(0x1ec,0x1ed); +test(0x1ed,0x1ec); +test(0x1ee,0x1ef); +test(0x1ef,0x1ee); +test(0x1f1,0x1f3,0x1f2); +test(0x1f2,0x1f3,0x1f1); +test(0x1f3,0x1f1,0x1f2); +test(0x1f4,0x1f5); +test(0x1f5,0x1f4); +test(0x1f6,0x195); +test(0x1f7,0x1bf); +test(0x1f8,0x1f9); +test(0x1f9,0x1f8); +test(0x1fa,0x1fb); +test(0x1fb,0x1fa); +test(0x1fc,0x1fd); +test(0x1fd,0x1fc); +test(0x1fe,0x1ff); +test(0x1ff,0x1fe); +test(0x200,0x201); +test(0x201,0x200); +test(0x202,0x203); +test(0x203,0x202); +test(0x204,0x205); +test(0x205,0x204); +test(0x206,0x207); +test(0x207,0x206); +test(0x208,0x209); +test(0x209,0x208); +test(0x20a,0x20b); +test(0x20b,0x20a); +test(0x20c,0x20d); +test(0x20d,0x20c); +test(0x20e,0x20f); +test(0x20f,0x20e); +test(0x210,0x211); +test(0x211,0x210); +test(0x212,0x213); +test(0x213,0x212); +test(0x214,0x215); +test(0x215,0x214); +test(0x216,0x217); +test(0x217,0x216); +test(0x218,0x219); +test(0x219,0x218); +test(0x21a,0x21b); +test(0x21b,0x21a); +test(0x21c,0x21d); +test(0x21d,0x21c); +test(0x21e,0x21f); +test(0x21f,0x21e); +test(0x220,0x19e); +test(0x222,0x223); +test(0x223,0x222); +test(0x224,0x225); +test(0x225,0x224); +test(0x226,0x227); +test(0x227,0x226); +test(0x228,0x229); +test(0x229,0x228); +test(0x22a,0x22b); +test(0x22b,0x22a); +test(0x22c,0x22d); +test(0x22d,0x22c); +test(0x22e,0x22f); +test(0x22f,0x22e); +test(0x230,0x231); +test(0x231,0x230); +test(0x232,0x233); +test(0x233,0x232); +test(0x23a,0x2c65); +test(0x23b,0x23c); +test(0x23c,0x23b); +test(0x23d,0x19a); +test(0x23e,0x2c66); +test(0x23f,0x2c7e); +test(0x240,0x2c7f); +test(0x241,0x242); +test(0x242,0x241); +test(0x243,0x180); +test(0x244,0x289); +test(0x245,0x28c); +test(0x246,0x247); +test(0x247,0x246); +test(0x248,0x249); +test(0x249,0x248); +test(0x24a,0x24b); +test(0x24b,0x24a); +test(0x24c,0x24d); +test(0x24d,0x24c); +test(0x24e,0x24f); +test(0x24f,0x24e); +test(0x250,0x2c6f); +test(0x251,0x2c6d); +test(0x252,0x2c70); +test(0x253,0x181); +test(0x254,0x186); +test(0x256,0x189); +test(0x257,0x18a); +test(0x259,0x18f); +test(0x25b,0x190); +test(0x25c,0xa7ab); +test(0x260,0x193); +test(0x261,0xa7ac); +test(0x263,0x194); +test(0x265,0xa78d); +test(0x266,0xa7aa); +test(0x268,0x197); +test(0x269,0x196); +test(0x26a,0xa7ae); +test(0x26b,0x2c62); +test(0x26c,0xa7ad); +test(0x26f,0x19c); +test(0x271,0x2c6e); +test(0x272,0x19d); +test(0x275,0x19f); +test(0x27d,0x2c64); +test(0x280,0x1a6); +test(0x283,0x1a9); +test(0x287,0xa7b1); +test(0x288,0x1ae); +test(0x289,0x244); +test(0x28a,0x1b1); +test(0x28b,0x1b2); +test(0x28c,0x245); +test(0x292,0x1b7); +test(0x29d,0xa7b2); +test(0x29e,0xa7b0); +test(0x345,0x3b9,0x399,0x1fbe); +test(0x370,0x371); +test(0x371,0x370); +test(0x372,0x373); +test(0x373,0x372); +test(0x376,0x377); +test(0x377,0x376); +test(0x37b,0x3fd); +test(0x37c,0x3fe); +test(0x37d,0x3ff); +test(0x37f,0x3f3); +test(0x386,0x3ac); +test(0x388,0x3ad); +test(0x389,0x3ae); +test(0x38a,0x3af); +test(0x38c,0x3cc); +test(0x38e,0x3cd); +test(0x38f,0x3ce); +test(0x391,0x3b1); +test(0x392,0x3b2,0x3d0); +test(0x393,0x3b3); +test(0x394,0x3b4); +test(0x395,0x3b5,0x3f5); +test(0x396,0x3b6); +test(0x397,0x3b7); +test(0x398,0x3b8,0x3d1,0x3f4); +test(0x399,0x3b9,0x345,0x1fbe); +test(0x39a,0x3ba,0x3f0); +test(0x39b,0x3bb); +test(0x39c,0x3bc,0xb5); +test(0x39d,0x3bd); +test(0x39e,0x3be); +test(0x39f,0x3bf); +test(0x3a0,0x3c0,0x3d6); +test(0x3a1,0x3c1,0x3f1); +test(0x3a3,0x3c3,0x3c2); +test(0x3a4,0x3c4); +test(0x3a5,0x3c5); +test(0x3a6,0x3c6,0x3d5); +test(0x3a7,0x3c7); +test(0x3a8,0x3c8); +test(0x3a9,0x3c9,0x2126); +test(0x3aa,0x3ca); +test(0x3ab,0x3cb); +test(0x3ac,0x386); +test(0x3ad,0x388); +test(0x3ae,0x389); +test(0x3af,0x38a); +test(0x3b1,0x391); +test(0x3b2,0x392,0x3d0); +test(0x3b3,0x393); +test(0x3b4,0x394); +test(0x3b5,0x395,0x3f5); +test(0x3b6,0x396); +test(0x3b7,0x397); +test(0x3b8,0x398,0x3d1,0x3f4); +test(0x3b9,0x345,0x399,0x1fbe); +test(0x3ba,0x39a,0x3f0); +test(0x3bb,0x39b); +test(0x3bc,0xb5,0x39c); +test(0x3bd,0x39d); +test(0x3be,0x39e); +test(0x3bf,0x39f); +test(0x3c0,0x3a0,0x3d6); +test(0x3c1,0x3a1,0x3f1); +test(0x3c2,0x3c3,0x3a3); +test(0x3c3,0x3a3,0x3c2); +test(0x3c4,0x3a4); +test(0x3c5,0x3a5); +test(0x3c6,0x3a6,0x3d5); +test(0x3c7,0x3a7); +test(0x3c8,0x3a8); +test(0x3c9,0x3a9,0x2126); +test(0x3ca,0x3aa); +test(0x3cb,0x3ab); +test(0x3cc,0x38c); +test(0x3cd,0x38e); +test(0x3ce,0x38f); +test(0x3cf,0x3d7); +test(0x3d0,0x3b2,0x392); +test(0x3d1,0x3b8,0x398,0x3f4); +test(0x3d5,0x3c6,0x3a6); +test(0x3d6,0x3c0,0x3a0); +test(0x3d7,0x3cf); +test(0x3d8,0x3d9); +test(0x3d9,0x3d8); +test(0x3da,0x3db); +test(0x3db,0x3da); +test(0x3dc,0x3dd); +test(0x3dd,0x3dc); +test(0x3de,0x3df); +test(0x3df,0x3de); +test(0x3e0,0x3e1); +test(0x3e1,0x3e0); +test(0x3e2,0x3e3); +test(0x3e3,0x3e2); +test(0x3e4,0x3e5); +test(0x3e5,0x3e4); +test(0x3e6,0x3e7); +test(0x3e7,0x3e6); +test(0x3e8,0x3e9); +test(0x3e9,0x3e8); +test(0x3ea,0x3eb); +test(0x3eb,0x3ea); +test(0x3ec,0x3ed); +test(0x3ed,0x3ec); +test(0x3ee,0x3ef); +test(0x3ef,0x3ee); +test(0x3f0,0x3ba,0x39a); +test(0x3f1,0x3c1,0x3a1); +test(0x3f2,0x3f9); +test(0x3f3,0x37f); +test(0x3f4,0x3b8,0x398,0x3d1); +test(0x3f5,0x3b5,0x395); +test(0x3f7,0x3f8); +test(0x3f8,0x3f7); +test(0x3f9,0x3f2); +test(0x3fa,0x3fb); +test(0x3fb,0x3fa); +test(0x3fd,0x37b); +test(0x3fe,0x37c); +test(0x3ff,0x37d); +test(0x400,0x450); +test(0x401,0x451); +test(0x402,0x452); +test(0x403,0x453); +test(0x404,0x454); +test(0x405,0x455); +test(0x406,0x456); +test(0x407,0x457); +test(0x408,0x458); +test(0x409,0x459); +test(0x40a,0x45a); +test(0x40b,0x45b); +test(0x40c,0x45c); +test(0x40d,0x45d); +test(0x40e,0x45e); +test(0x40f,0x45f); +test(0x410,0x430); +test(0x411,0x431); +test(0x412,0x432,0x1c80); +test(0x413,0x433); +test(0x414,0x434,0x1c81); +test(0x415,0x435); +test(0x416,0x436); +test(0x417,0x437); +test(0x418,0x438); +test(0x419,0x439); +test(0x41a,0x43a); +test(0x41b,0x43b); +test(0x41c,0x43c); +test(0x41d,0x43d); +test(0x41e,0x43e,0x1c82); +test(0x41f,0x43f); +test(0x420,0x440); +test(0x421,0x441,0x1c83); +test(0x422,0x442,0x1c84,0x1c85); +test(0x423,0x443); +test(0x424,0x444); +test(0x425,0x445); +test(0x426,0x446); +test(0x427,0x447); +test(0x428,0x448); +test(0x429,0x449); +test(0x42a,0x44a,0x1c86); +test(0x42b,0x44b); +test(0x42c,0x44c); +test(0x42d,0x44d); +test(0x42e,0x44e); +test(0x42f,0x44f); +test(0x430,0x410); +test(0x431,0x411); +test(0x432,0x412,0x1c80); +test(0x433,0x413); +test(0x434,0x414,0x1c81); +test(0x435,0x415); +test(0x436,0x416); +test(0x437,0x417); +test(0x438,0x418); +test(0x439,0x419); +test(0x43a,0x41a); +test(0x43b,0x41b); +test(0x43c,0x41c); +test(0x43d,0x41d); +test(0x43e,0x41e,0x1c82); +test(0x43f,0x41f); +test(0x440,0x420); +test(0x441,0x421,0x1c83); +test(0x442,0x422,0x1c84,0x1c85); +test(0x443,0x423); +test(0x444,0x424); +test(0x445,0x425); +test(0x446,0x426); +test(0x447,0x427); +test(0x448,0x428); +test(0x449,0x429); +test(0x44a,0x42a,0x1c86); +test(0x44b,0x42b); +test(0x44c,0x42c); +test(0x44d,0x42d); +test(0x44e,0x42e); +test(0x44f,0x42f); +test(0x450,0x400); +test(0x451,0x401); +test(0x452,0x402); +test(0x453,0x403); +test(0x454,0x404); +test(0x455,0x405); +test(0x456,0x406); +test(0x457,0x407); +test(0x458,0x408); +test(0x459,0x409); +test(0x45a,0x40a); +test(0x45b,0x40b); +test(0x45c,0x40c); +test(0x45d,0x40d); +test(0x45e,0x40e); +test(0x45f,0x40f); +test(0x460,0x461); +test(0x461,0x460); +test(0x462,0x463,0x1c87); +test(0x463,0x462,0x1c87); +test(0x464,0x465); +test(0x465,0x464); +test(0x466,0x467); +test(0x467,0x466); +test(0x468,0x469); +test(0x469,0x468); +test(0x46a,0x46b); +test(0x46b,0x46a); +test(0x46c,0x46d); +test(0x46d,0x46c); +test(0x46e,0x46f); +test(0x46f,0x46e); +test(0x470,0x471); +test(0x471,0x470); +test(0x472,0x473); +test(0x473,0x472); +test(0x474,0x475); +test(0x475,0x474); +test(0x476,0x477); +test(0x477,0x476); +test(0x478,0x479); +test(0x479,0x478); +test(0x47a,0x47b); +test(0x47b,0x47a); +test(0x47c,0x47d); +test(0x47d,0x47c); +test(0x47e,0x47f); +test(0x47f,0x47e); +test(0x480,0x481); +test(0x481,0x480); +test(0x48a,0x48b); +test(0x48b,0x48a); +test(0x48c,0x48d); +test(0x48d,0x48c); +test(0x48e,0x48f); +test(0x48f,0x48e); +test(0x490,0x491); +test(0x491,0x490); +test(0x492,0x493); +test(0x493,0x492); +test(0x494,0x495); +test(0x495,0x494); +test(0x496,0x497); +test(0x497,0x496); +test(0x498,0x499); +test(0x499,0x498); +test(0x49a,0x49b); +test(0x49b,0x49a); +test(0x49c,0x49d); +test(0x49d,0x49c); +test(0x49e,0x49f); +test(0x49f,0x49e); +test(0x4a0,0x4a1); +test(0x4a1,0x4a0); +test(0x4a2,0x4a3); +test(0x4a3,0x4a2); +test(0x4a4,0x4a5); +test(0x4a5,0x4a4); +test(0x4a6,0x4a7); +test(0x4a7,0x4a6); +test(0x4a8,0x4a9); +test(0x4a9,0x4a8); +test(0x4aa,0x4ab); +test(0x4ab,0x4aa); +test(0x4ac,0x4ad); +test(0x4ad,0x4ac); +test(0x4ae,0x4af); +test(0x4af,0x4ae); +test(0x4b0,0x4b1); +test(0x4b1,0x4b0); +test(0x4b2,0x4b3); +test(0x4b3,0x4b2); +test(0x4b4,0x4b5); +test(0x4b5,0x4b4); +test(0x4b6,0x4b7); +test(0x4b7,0x4b6); +test(0x4b8,0x4b9); +test(0x4b9,0x4b8); +test(0x4ba,0x4bb); +test(0x4bb,0x4ba); +test(0x4bc,0x4bd); +test(0x4bd,0x4bc); +test(0x4be,0x4bf); +test(0x4bf,0x4be); +test(0x4c0,0x4cf); +test(0x4c1,0x4c2); +test(0x4c2,0x4c1); +test(0x4c3,0x4c4); +test(0x4c4,0x4c3); +test(0x4c5,0x4c6); +test(0x4c6,0x4c5); +test(0x4c7,0x4c8); +test(0x4c8,0x4c7); +test(0x4c9,0x4ca); +test(0x4ca,0x4c9); +test(0x4cb,0x4cc); +test(0x4cc,0x4cb); +test(0x4cd,0x4ce); +test(0x4ce,0x4cd); +test(0x4cf,0x4c0); +test(0x4d0,0x4d1); +test(0x4d1,0x4d0); +test(0x4d2,0x4d3); +test(0x4d3,0x4d2); +test(0x4d4,0x4d5); +test(0x4d5,0x4d4); +test(0x4d6,0x4d7); +test(0x4d7,0x4d6); +test(0x4d8,0x4d9); +test(0x4d9,0x4d8); +test(0x4da,0x4db); +test(0x4db,0x4da); +test(0x4dc,0x4dd); +test(0x4dd,0x4dc); +test(0x4de,0x4df); +test(0x4df,0x4de); +test(0x4e0,0x4e1); +test(0x4e1,0x4e0); +test(0x4e2,0x4e3); +test(0x4e3,0x4e2); +test(0x4e4,0x4e5); +test(0x4e5,0x4e4); +test(0x4e6,0x4e7); +test(0x4e7,0x4e6); +test(0x4e8,0x4e9); +test(0x4e9,0x4e8); +test(0x4ea,0x4eb); +test(0x4eb,0x4ea); +test(0x4ec,0x4ed); +test(0x4ed,0x4ec); +test(0x4ee,0x4ef); +test(0x4ef,0x4ee); +test(0x4f0,0x4f1); +test(0x4f1,0x4f0); +test(0x4f2,0x4f3); +test(0x4f3,0x4f2); +test(0x4f4,0x4f5); +test(0x4f5,0x4f4); +test(0x4f6,0x4f7); +test(0x4f7,0x4f6); +test(0x4f8,0x4f9); +test(0x4f9,0x4f8); +test(0x4fa,0x4fb); +test(0x4fb,0x4fa); +test(0x4fc,0x4fd); +test(0x4fd,0x4fc); +test(0x4fe,0x4ff); +test(0x4ff,0x4fe); +test(0x500,0x501); +test(0x501,0x500); +test(0x502,0x503); +test(0x503,0x502); +test(0x504,0x505); +test(0x505,0x504); +test(0x506,0x507); +test(0x507,0x506); +test(0x508,0x509); +test(0x509,0x508); +test(0x50a,0x50b); +test(0x50b,0x50a); +test(0x50c,0x50d); +test(0x50d,0x50c); +test(0x50e,0x50f); +test(0x50f,0x50e); +test(0x510,0x511); +test(0x511,0x510); +test(0x512,0x513); +test(0x513,0x512); +test(0x514,0x515); +test(0x515,0x514); +test(0x516,0x517); +test(0x517,0x516); +test(0x518,0x519); +test(0x519,0x518); +test(0x51a,0x51b); +test(0x51b,0x51a); +test(0x51c,0x51d); +test(0x51d,0x51c); +test(0x51e,0x51f); +test(0x51f,0x51e); +test(0x520,0x521); +test(0x521,0x520); +test(0x522,0x523); +test(0x523,0x522); +test(0x524,0x525); +test(0x525,0x524); +test(0x526,0x527); +test(0x527,0x526); +test(0x528,0x529); +test(0x529,0x528); +test(0x52a,0x52b); +test(0x52b,0x52a); +test(0x52c,0x52d); +test(0x52d,0x52c); +test(0x52e,0x52f); +test(0x52f,0x52e); +test(0x531,0x561); +test(0x532,0x562); +test(0x533,0x563); +test(0x534,0x564); +test(0x535,0x565); +test(0x536,0x566); +test(0x537,0x567); +test(0x538,0x568); +test(0x539,0x569); +test(0x53a,0x56a); +test(0x53b,0x56b); +test(0x53c,0x56c); +test(0x53d,0x56d); +test(0x53e,0x56e); +test(0x53f,0x56f); +test(0x540,0x570); +test(0x541,0x571); +test(0x542,0x572); +test(0x543,0x573); +test(0x544,0x574); +test(0x545,0x575); +test(0x546,0x576); +test(0x547,0x577); +test(0x548,0x578); +test(0x549,0x579); +test(0x54a,0x57a); +test(0x54b,0x57b); +test(0x54c,0x57c); +test(0x54d,0x57d); +test(0x54e,0x57e); +test(0x54f,0x57f); +test(0x550,0x580); +test(0x551,0x581); +test(0x552,0x582); +test(0x553,0x583); +test(0x554,0x584); +test(0x555,0x585); +test(0x556,0x586); +test(0x561,0x531); +test(0x562,0x532); +test(0x563,0x533); +test(0x564,0x534); +test(0x565,0x535); +test(0x566,0x536); +test(0x567,0x537); +test(0x568,0x538); +test(0x569,0x539); +test(0x56a,0x53a); +test(0x56b,0x53b); +test(0x56c,0x53c); +test(0x56d,0x53d); +test(0x56e,0x53e); +test(0x56f,0x53f); +test(0x570,0x540); +test(0x571,0x541); +test(0x572,0x542); +test(0x573,0x543); +test(0x574,0x544); +test(0x575,0x545); +test(0x576,0x546); +test(0x577,0x547); +test(0x578,0x548); +test(0x579,0x549); +test(0x57a,0x54a); +test(0x57b,0x54b); +test(0x57c,0x54c); +test(0x57d,0x54d); +test(0x57e,0x54e); +test(0x57f,0x54f); +test(0x580,0x550); +test(0x581,0x551); +test(0x582,0x552); +test(0x583,0x553); +test(0x584,0x554); +test(0x585,0x555); +test(0x586,0x556); +test(0x10a0,0x2d00); +test(0x10a1,0x2d01); +test(0x10a2,0x2d02); +test(0x10a3,0x2d03); +test(0x10a4,0x2d04); +test(0x10a5,0x2d05); +test(0x10a6,0x2d06); +test(0x10a7,0x2d07); +test(0x10a8,0x2d08); +test(0x10a9,0x2d09); +test(0x10aa,0x2d0a); +test(0x10ab,0x2d0b); +test(0x10ac,0x2d0c); +test(0x10ad,0x2d0d); +test(0x10ae,0x2d0e); +test(0x10af,0x2d0f); +test(0x10b0,0x2d10); +test(0x10b1,0x2d11); +test(0x10b2,0x2d12); +test(0x10b3,0x2d13); +test(0x10b4,0x2d14); +test(0x10b5,0x2d15); +test(0x10b6,0x2d16); +test(0x10b7,0x2d17); +test(0x10b8,0x2d18); +test(0x10b9,0x2d19); +test(0x10ba,0x2d1a); +test(0x10bb,0x2d1b); +test(0x10bc,0x2d1c); +test(0x10bd,0x2d1d); +test(0x10be,0x2d1e); +test(0x10bf,0x2d1f); +test(0x10c0,0x2d20); +test(0x10c1,0x2d21); +test(0x10c2,0x2d22); +test(0x10c3,0x2d23); +test(0x10c4,0x2d24); +test(0x10c5,0x2d25); +test(0x10c7,0x2d27); +test(0x10cd,0x2d2d); +test(0x13a0,0xab70); +test(0x13a1,0xab71); +test(0x13a2,0xab72); +test(0x13a3,0xab73); +test(0x13a4,0xab74); +test(0x13a5,0xab75); +test(0x13a6,0xab76); +test(0x13a7,0xab77); +test(0x13a8,0xab78); +test(0x13a9,0xab79); +test(0x13aa,0xab7a); +test(0x13ab,0xab7b); +test(0x13ac,0xab7c); +test(0x13ad,0xab7d); +test(0x13ae,0xab7e); +test(0x13af,0xab7f); +test(0x13b0,0xab80); +test(0x13b1,0xab81); +test(0x13b2,0xab82); +test(0x13b3,0xab83); +test(0x13b4,0xab84); +test(0x13b5,0xab85); +test(0x13b6,0xab86); +test(0x13b7,0xab87); +test(0x13b8,0xab88); +test(0x13b9,0xab89); +test(0x13ba,0xab8a); +test(0x13bb,0xab8b); +test(0x13bc,0xab8c); +test(0x13bd,0xab8d); +test(0x13be,0xab8e); +test(0x13bf,0xab8f); +test(0x13c0,0xab90); +test(0x13c1,0xab91); +test(0x13c2,0xab92); +test(0x13c3,0xab93); +test(0x13c4,0xab94); +test(0x13c5,0xab95); +test(0x13c6,0xab96); +test(0x13c7,0xab97); +test(0x13c8,0xab98); +test(0x13c9,0xab99); +test(0x13ca,0xab9a); +test(0x13cb,0xab9b); +test(0x13cc,0xab9c); +test(0x13cd,0xab9d); +test(0x13ce,0xab9e); +test(0x13cf,0xab9f); +test(0x13d0,0xaba0); +test(0x13d1,0xaba1); +test(0x13d2,0xaba2); +test(0x13d3,0xaba3); +test(0x13d4,0xaba4); +test(0x13d5,0xaba5); +test(0x13d6,0xaba6); +test(0x13d7,0xaba7); +test(0x13d8,0xaba8); +test(0x13d9,0xaba9); +test(0x13da,0xabaa); +test(0x13db,0xabab); +test(0x13dc,0xabac); +test(0x13dd,0xabad); +test(0x13de,0xabae); +test(0x13df,0xabaf); +test(0x13e0,0xabb0); +test(0x13e1,0xabb1); +test(0x13e2,0xabb2); +test(0x13e3,0xabb3); +test(0x13e4,0xabb4); +test(0x13e5,0xabb5); +test(0x13e6,0xabb6); +test(0x13e7,0xabb7); +test(0x13e8,0xabb8); +test(0x13e9,0xabb9); +test(0x13ea,0xabba); +test(0x13eb,0xabbb); +test(0x13ec,0xabbc); +test(0x13ed,0xabbd); +test(0x13ee,0xabbe); +test(0x13ef,0xabbf); +test(0x13f0,0x13f8); +test(0x13f1,0x13f9); +test(0x13f2,0x13fa); +test(0x13f3,0x13fb); +test(0x13f4,0x13fc); +test(0x13f5,0x13fd); +test(0x13f8,0x13f0); +test(0x13f9,0x13f1); +test(0x13fa,0x13f2); +test(0x13fb,0x13f3); +test(0x13fc,0x13f4); +test(0x13fd,0x13f5); +test(0x1c80,0x432,0x412); +test(0x1c81,0x434,0x414); +test(0x1c82,0x43e,0x41e); +test(0x1c83,0x441,0x421); +test(0x1c84,0x442,0x422,0x1c85); +test(0x1c85,0x442,0x422,0x1c84); +test(0x1c86,0x44a,0x42a); +test(0x1c87,0x463,0x462); +test(0x1c88,0xa64b,0xa64a); +test(0x1d79,0xa77d); +test(0x1d7d,0x2c63); +test(0x1e00,0x1e01); +test(0x1e01,0x1e00); +test(0x1e02,0x1e03); +test(0x1e03,0x1e02); +test(0x1e04,0x1e05); +test(0x1e05,0x1e04); +test(0x1e06,0x1e07); +test(0x1e07,0x1e06); +test(0x1e08,0x1e09); +test(0x1e09,0x1e08); +test(0x1e0a,0x1e0b); +test(0x1e0b,0x1e0a); +test(0x1e0c,0x1e0d); +test(0x1e0d,0x1e0c); +test(0x1e0e,0x1e0f); +test(0x1e0f,0x1e0e); +test(0x1e10,0x1e11); +test(0x1e11,0x1e10); +test(0x1e12,0x1e13); +test(0x1e13,0x1e12); +test(0x1e14,0x1e15); +test(0x1e15,0x1e14); +test(0x1e16,0x1e17); +test(0x1e17,0x1e16); +test(0x1e18,0x1e19); +test(0x1e19,0x1e18); +test(0x1e1a,0x1e1b); +test(0x1e1b,0x1e1a); +test(0x1e1c,0x1e1d); +test(0x1e1d,0x1e1c); +test(0x1e1e,0x1e1f); +test(0x1e1f,0x1e1e); +test(0x1e20,0x1e21); +test(0x1e21,0x1e20); +test(0x1e22,0x1e23); +test(0x1e23,0x1e22); +test(0x1e24,0x1e25); +test(0x1e25,0x1e24); +test(0x1e26,0x1e27); +test(0x1e27,0x1e26); +test(0x1e28,0x1e29); +test(0x1e29,0x1e28); +test(0x1e2a,0x1e2b); +test(0x1e2b,0x1e2a); +test(0x1e2c,0x1e2d); +test(0x1e2d,0x1e2c); +test(0x1e2e,0x1e2f); +test(0x1e2f,0x1e2e); +test(0x1e30,0x1e31); +test(0x1e31,0x1e30); +test(0x1e32,0x1e33); +test(0x1e33,0x1e32); +test(0x1e34,0x1e35); +test(0x1e35,0x1e34); +test(0x1e36,0x1e37); +test(0x1e37,0x1e36); +test(0x1e38,0x1e39); +test(0x1e39,0x1e38); +test(0x1e3a,0x1e3b); +test(0x1e3b,0x1e3a); +test(0x1e3c,0x1e3d); +test(0x1e3d,0x1e3c); +test(0x1e3e,0x1e3f); +test(0x1e3f,0x1e3e); +test(0x1e40,0x1e41); +test(0x1e41,0x1e40); +test(0x1e42,0x1e43); +test(0x1e43,0x1e42); +test(0x1e44,0x1e45); +test(0x1e45,0x1e44); +test(0x1e46,0x1e47); +test(0x1e47,0x1e46); +test(0x1e48,0x1e49); +test(0x1e49,0x1e48); +test(0x1e4a,0x1e4b); +test(0x1e4b,0x1e4a); +test(0x1e4c,0x1e4d); +test(0x1e4d,0x1e4c); +test(0x1e4e,0x1e4f); +test(0x1e4f,0x1e4e); +test(0x1e50,0x1e51); +test(0x1e51,0x1e50); +test(0x1e52,0x1e53); +test(0x1e53,0x1e52); +test(0x1e54,0x1e55); +test(0x1e55,0x1e54); +test(0x1e56,0x1e57); +test(0x1e57,0x1e56); +test(0x1e58,0x1e59); +test(0x1e59,0x1e58); +test(0x1e5a,0x1e5b); +test(0x1e5b,0x1e5a); +test(0x1e5c,0x1e5d); +test(0x1e5d,0x1e5c); +test(0x1e5e,0x1e5f); +test(0x1e5f,0x1e5e); +test(0x1e60,0x1e61,0x1e9b); +test(0x1e61,0x1e60,0x1e9b); +test(0x1e62,0x1e63); +test(0x1e63,0x1e62); +test(0x1e64,0x1e65); +test(0x1e65,0x1e64); +test(0x1e66,0x1e67); +test(0x1e67,0x1e66); +test(0x1e68,0x1e69); +test(0x1e69,0x1e68); +test(0x1e6a,0x1e6b); +test(0x1e6b,0x1e6a); +test(0x1e6c,0x1e6d); +test(0x1e6d,0x1e6c); +test(0x1e6e,0x1e6f); +test(0x1e6f,0x1e6e); +test(0x1e70,0x1e71); +test(0x1e71,0x1e70); +test(0x1e72,0x1e73); +test(0x1e73,0x1e72); +test(0x1e74,0x1e75); +test(0x1e75,0x1e74); +test(0x1e76,0x1e77); +test(0x1e77,0x1e76); +test(0x1e78,0x1e79); +test(0x1e79,0x1e78); +test(0x1e7a,0x1e7b); +test(0x1e7b,0x1e7a); +test(0x1e7c,0x1e7d); +test(0x1e7d,0x1e7c); +test(0x1e7e,0x1e7f); +test(0x1e7f,0x1e7e); +test(0x1e80,0x1e81); +test(0x1e81,0x1e80); +test(0x1e82,0x1e83); +test(0x1e83,0x1e82); +test(0x1e84,0x1e85); +test(0x1e85,0x1e84); +test(0x1e86,0x1e87); +test(0x1e87,0x1e86); +test(0x1e88,0x1e89); +test(0x1e89,0x1e88); +test(0x1e8a,0x1e8b); +test(0x1e8b,0x1e8a); +test(0x1e8c,0x1e8d); +test(0x1e8d,0x1e8c); +test(0x1e8e,0x1e8f); +test(0x1e8f,0x1e8e); +test(0x1e90,0x1e91); +test(0x1e91,0x1e90); +test(0x1e92,0x1e93); +test(0x1e93,0x1e92); +test(0x1e94,0x1e95); +test(0x1e95,0x1e94); +test(0x1e9b,0x1e61,0x1e60); +test(0x1e9e,0xdf); +test(0x1ea0,0x1ea1); +test(0x1ea1,0x1ea0); +test(0x1ea2,0x1ea3); +test(0x1ea3,0x1ea2); +test(0x1ea4,0x1ea5); +test(0x1ea5,0x1ea4); +test(0x1ea6,0x1ea7); +test(0x1ea7,0x1ea6); +test(0x1ea8,0x1ea9); +test(0x1ea9,0x1ea8); +test(0x1eaa,0x1eab); +test(0x1eab,0x1eaa); +test(0x1eac,0x1ead); +test(0x1ead,0x1eac); +test(0x1eae,0x1eaf); +test(0x1eaf,0x1eae); +test(0x1eb0,0x1eb1); +test(0x1eb1,0x1eb0); +test(0x1eb2,0x1eb3); +test(0x1eb3,0x1eb2); +test(0x1eb4,0x1eb5); +test(0x1eb5,0x1eb4); +test(0x1eb6,0x1eb7); +test(0x1eb7,0x1eb6); +test(0x1eb8,0x1eb9); +test(0x1eb9,0x1eb8); +test(0x1eba,0x1ebb); +test(0x1ebb,0x1eba); +test(0x1ebc,0x1ebd); +test(0x1ebd,0x1ebc); +test(0x1ebe,0x1ebf); +test(0x1ebf,0x1ebe); +test(0x1ec0,0x1ec1); +test(0x1ec1,0x1ec0); +test(0x1ec2,0x1ec3); +test(0x1ec3,0x1ec2); +test(0x1ec4,0x1ec5); +test(0x1ec5,0x1ec4); +test(0x1ec6,0x1ec7); +test(0x1ec7,0x1ec6); +test(0x1ec8,0x1ec9); +test(0x1ec9,0x1ec8); +test(0x1eca,0x1ecb); +test(0x1ecb,0x1eca); +test(0x1ecc,0x1ecd); +test(0x1ecd,0x1ecc); +test(0x1ece,0x1ecf); +test(0x1ecf,0x1ece); +test(0x1ed0,0x1ed1); +test(0x1ed1,0x1ed0); +test(0x1ed2,0x1ed3); +test(0x1ed3,0x1ed2); +test(0x1ed4,0x1ed5); +test(0x1ed5,0x1ed4); +test(0x1ed6,0x1ed7); +test(0x1ed7,0x1ed6); +test(0x1ed8,0x1ed9); +test(0x1ed9,0x1ed8); +test(0x1eda,0x1edb); +test(0x1edb,0x1eda); +test(0x1edc,0x1edd); +test(0x1edd,0x1edc); +test(0x1ede,0x1edf); +test(0x1edf,0x1ede); +test(0x1ee0,0x1ee1); +test(0x1ee1,0x1ee0); +test(0x1ee2,0x1ee3); +test(0x1ee3,0x1ee2); +test(0x1ee4,0x1ee5); +test(0x1ee5,0x1ee4); +test(0x1ee6,0x1ee7); +test(0x1ee7,0x1ee6); +test(0x1ee8,0x1ee9); +test(0x1ee9,0x1ee8); +test(0x1eea,0x1eeb); +test(0x1eeb,0x1eea); +test(0x1eec,0x1eed); +test(0x1eed,0x1eec); +test(0x1eee,0x1eef); +test(0x1eef,0x1eee); +test(0x1ef0,0x1ef1); +test(0x1ef1,0x1ef0); +test(0x1ef2,0x1ef3); +test(0x1ef3,0x1ef2); +test(0x1ef4,0x1ef5); +test(0x1ef5,0x1ef4); +test(0x1ef6,0x1ef7); +test(0x1ef7,0x1ef6); +test(0x1ef8,0x1ef9); +test(0x1ef9,0x1ef8); +test(0x1efa,0x1efb); +test(0x1efb,0x1efa); +test(0x1efc,0x1efd); +test(0x1efd,0x1efc); +test(0x1efe,0x1eff); +test(0x1eff,0x1efe); +test(0x1f00,0x1f08); +test(0x1f01,0x1f09); +test(0x1f02,0x1f0a); +test(0x1f03,0x1f0b); +test(0x1f04,0x1f0c); +test(0x1f05,0x1f0d); +test(0x1f06,0x1f0e); +test(0x1f07,0x1f0f); +test(0x1f08,0x1f00); +test(0x1f09,0x1f01); +test(0x1f0a,0x1f02); +test(0x1f0b,0x1f03); +test(0x1f0c,0x1f04); +test(0x1f0d,0x1f05); +test(0x1f0e,0x1f06); +test(0x1f0f,0x1f07); +test(0x1f10,0x1f18); +test(0x1f11,0x1f19); +test(0x1f12,0x1f1a); +test(0x1f13,0x1f1b); +test(0x1f14,0x1f1c); +test(0x1f15,0x1f1d); +test(0x1f18,0x1f10); +test(0x1f19,0x1f11); +test(0x1f1a,0x1f12); +test(0x1f1b,0x1f13); +test(0x1f1c,0x1f14); +test(0x1f1d,0x1f15); +test(0x1f20,0x1f28); +test(0x1f21,0x1f29); +test(0x1f22,0x1f2a); +test(0x1f23,0x1f2b); +test(0x1f24,0x1f2c); +test(0x1f25,0x1f2d); +test(0x1f26,0x1f2e); +test(0x1f27,0x1f2f); +test(0x1f28,0x1f20); +test(0x1f29,0x1f21); +test(0x1f2a,0x1f22); +test(0x1f2b,0x1f23); +test(0x1f2c,0x1f24); +test(0x1f2d,0x1f25); +test(0x1f2e,0x1f26); +test(0x1f2f,0x1f27); +test(0x1f30,0x1f38); +test(0x1f31,0x1f39); +test(0x1f32,0x1f3a); +test(0x1f33,0x1f3b); +test(0x1f34,0x1f3c); +test(0x1f35,0x1f3d); +test(0x1f36,0x1f3e); +test(0x1f37,0x1f3f); +test(0x1f38,0x1f30); +test(0x1f39,0x1f31); +test(0x1f3a,0x1f32); +test(0x1f3b,0x1f33); +test(0x1f3c,0x1f34); +test(0x1f3d,0x1f35); +test(0x1f3e,0x1f36); +test(0x1f3f,0x1f37); +test(0x1f40,0x1f48); +test(0x1f41,0x1f49); +test(0x1f42,0x1f4a); +test(0x1f43,0x1f4b); +test(0x1f44,0x1f4c); +test(0x1f45,0x1f4d); +test(0x1f48,0x1f40); +test(0x1f49,0x1f41); +test(0x1f4a,0x1f42); +test(0x1f4b,0x1f43); +test(0x1f4c,0x1f44); +test(0x1f4d,0x1f45); +test(0x1f51,0x1f59); +test(0x1f53,0x1f5b); +test(0x1f55,0x1f5d); +test(0x1f57,0x1f5f); +test(0x1f59,0x1f51); +test(0x1f5b,0x1f53); +test(0x1f5d,0x1f55); +test(0x1f5f,0x1f57); +test(0x1f60,0x1f68); +test(0x1f61,0x1f69); +test(0x1f62,0x1f6a); +test(0x1f63,0x1f6b); +test(0x1f64,0x1f6c); +test(0x1f65,0x1f6d); +test(0x1f66,0x1f6e); +test(0x1f67,0x1f6f); +test(0x1f68,0x1f60); +test(0x1f69,0x1f61); +test(0x1f6a,0x1f62); +test(0x1f6b,0x1f63); +test(0x1f6c,0x1f64); +test(0x1f6d,0x1f65); +test(0x1f6e,0x1f66); +test(0x1f6f,0x1f67); +test(0x1f70,0x1fba); +test(0x1f71,0x1fbb); +test(0x1f72,0x1fc8); +test(0x1f73,0x1fc9); +test(0x1f74,0x1fca); +test(0x1f75,0x1fcb); +test(0x1f76,0x1fda); +test(0x1f77,0x1fdb); +test(0x1f78,0x1ff8); +test(0x1f79,0x1ff9); +test(0x1f7a,0x1fea); +test(0x1f7b,0x1feb); +test(0x1f7c,0x1ffa); +test(0x1f7d,0x1ffb); +test(0x1f80,0x1f88); +test(0x1f81,0x1f89); +test(0x1f82,0x1f8a); +test(0x1f83,0x1f8b); +test(0x1f84,0x1f8c); +test(0x1f85,0x1f8d); +test(0x1f86,0x1f8e); +test(0x1f87,0x1f8f); +test(0x1f88,0x1f80); +test(0x1f89,0x1f81); +test(0x1f8a,0x1f82); +test(0x1f8b,0x1f83); +test(0x1f8c,0x1f84); +test(0x1f8d,0x1f85); +test(0x1f8e,0x1f86); +test(0x1f8f,0x1f87); +test(0x1f90,0x1f98); +test(0x1f91,0x1f99); +test(0x1f92,0x1f9a); +test(0x1f93,0x1f9b); +test(0x1f94,0x1f9c); +test(0x1f95,0x1f9d); +test(0x1f96,0x1f9e); +test(0x1f97,0x1f9f); +test(0x1f98,0x1f90); +test(0x1f99,0x1f91); +test(0x1f9a,0x1f92); +test(0x1f9b,0x1f93); +test(0x1f9c,0x1f94); +test(0x1f9d,0x1f95); +test(0x1f9e,0x1f96); +test(0x1f9f,0x1f97); +test(0x1fa0,0x1fa8); +test(0x1fa1,0x1fa9); +test(0x1fa2,0x1faa); +test(0x1fa3,0x1fab); +test(0x1fa4,0x1fac); +test(0x1fa5,0x1fad); +test(0x1fa6,0x1fae); +test(0x1fa7,0x1faf); +test(0x1fa8,0x1fa0); +test(0x1fa9,0x1fa1); +test(0x1faa,0x1fa2); +test(0x1fab,0x1fa3); +test(0x1fac,0x1fa4); +test(0x1fad,0x1fa5); +test(0x1fae,0x1fa6); +test(0x1faf,0x1fa7); +test(0x1fb0,0x1fb8); +test(0x1fb1,0x1fb9); +test(0x1fb3,0x1fbc); +test(0x1fb8,0x1fb0); +test(0x1fb9,0x1fb1); +test(0x1fba,0x1f70); +test(0x1fbb,0x1f71); +test(0x1fbc,0x1fb3); +test(0x1fbe,0x3b9,0x345,0x399); +test(0x1fc3,0x1fcc); +test(0x1fc8,0x1f72); +test(0x1fc9,0x1f73); +test(0x1fca,0x1f74); +test(0x1fcb,0x1f75); +test(0x1fcc,0x1fc3); +test(0x1fd0,0x1fd8); +test(0x1fd1,0x1fd9); +test(0x1fd8,0x1fd0); +test(0x1fd9,0x1fd1); +test(0x1fda,0x1f76); +test(0x1fdb,0x1f77); +test(0x1fe0,0x1fe8); +test(0x1fe1,0x1fe9); +test(0x1fe5,0x1fec); +test(0x1fe8,0x1fe0); +test(0x1fe9,0x1fe1); +test(0x1fea,0x1f7a); +test(0x1feb,0x1f7b); +test(0x1fec,0x1fe5); +test(0x1ff3,0x1ffc); +test(0x1ff8,0x1f78); +test(0x1ff9,0x1f79); +test(0x1ffa,0x1f7c); +test(0x1ffb,0x1f7d); +test(0x1ffc,0x1ff3); +test(0x2126,0x3c9,0x3a9); +test(0x212a,0x6b,0x4b); +test(0x212b,0xe5,0xc5); +test(0x2132,0x214e); +test(0x214e,0x2132); +test(0x2160,0x2170); +test(0x2161,0x2171); +test(0x2162,0x2172); +test(0x2163,0x2173); +test(0x2164,0x2174); +test(0x2165,0x2175); +test(0x2166,0x2176); +test(0x2167,0x2177); +test(0x2168,0x2178); +test(0x2169,0x2179); +test(0x216a,0x217a); +test(0x216b,0x217b); +test(0x216c,0x217c); +test(0x216d,0x217d); +test(0x216e,0x217e); +test(0x216f,0x217f); +test(0x2170,0x2160); +test(0x2171,0x2161); +test(0x2172,0x2162); +test(0x2173,0x2163); +test(0x2174,0x2164); +test(0x2175,0x2165); +test(0x2176,0x2166); +test(0x2177,0x2167); +test(0x2178,0x2168); +test(0x2179,0x2169); +test(0x217a,0x216a); +test(0x217b,0x216b); +test(0x217c,0x216c); +test(0x217d,0x216d); +test(0x217e,0x216e); +test(0x217f,0x216f); +test(0x2183,0x2184); +test(0x2184,0x2183); +test(0x24b6,0x24d0); +test(0x24b7,0x24d1); +test(0x24b8,0x24d2); +test(0x24b9,0x24d3); +test(0x24ba,0x24d4); +test(0x24bb,0x24d5); +test(0x24bc,0x24d6); +test(0x24bd,0x24d7); +test(0x24be,0x24d8); +test(0x24bf,0x24d9); +test(0x24c0,0x24da); +test(0x24c1,0x24db); +test(0x24c2,0x24dc); +test(0x24c3,0x24dd); +test(0x24c4,0x24de); +test(0x24c5,0x24df); +test(0x24c6,0x24e0); +test(0x24c7,0x24e1); +test(0x24c8,0x24e2); +test(0x24c9,0x24e3); +test(0x24ca,0x24e4); +test(0x24cb,0x24e5); +test(0x24cc,0x24e6); +test(0x24cd,0x24e7); +test(0x24ce,0x24e8); +test(0x24cf,0x24e9); +test(0x24d0,0x24b6); +test(0x24d1,0x24b7); +test(0x24d2,0x24b8); +test(0x24d3,0x24b9); +test(0x24d4,0x24ba); +test(0x24d5,0x24bb); +test(0x24d6,0x24bc); +test(0x24d7,0x24bd); +test(0x24d8,0x24be); +test(0x24d9,0x24bf); +test(0x24da,0x24c0); +test(0x24db,0x24c1); +test(0x24dc,0x24c2); +test(0x24dd,0x24c3); +test(0x24de,0x24c4); +test(0x24df,0x24c5); +test(0x24e0,0x24c6); +test(0x24e1,0x24c7); +test(0x24e2,0x24c8); +test(0x24e3,0x24c9); +test(0x24e4,0x24ca); +test(0x24e5,0x24cb); +test(0x24e6,0x24cc); +test(0x24e7,0x24cd); +test(0x24e8,0x24ce); +test(0x24e9,0x24cf); +test(0x2c00,0x2c30); +test(0x2c01,0x2c31); +test(0x2c02,0x2c32); +test(0x2c03,0x2c33); +test(0x2c04,0x2c34); +test(0x2c05,0x2c35); +test(0x2c06,0x2c36); +test(0x2c07,0x2c37); +test(0x2c08,0x2c38); +test(0x2c09,0x2c39); +test(0x2c0a,0x2c3a); +test(0x2c0b,0x2c3b); +test(0x2c0c,0x2c3c); +test(0x2c0d,0x2c3d); +test(0x2c0e,0x2c3e); +test(0x2c0f,0x2c3f); +test(0x2c10,0x2c40); +test(0x2c11,0x2c41); +test(0x2c12,0x2c42); +test(0x2c13,0x2c43); +test(0x2c14,0x2c44); +test(0x2c15,0x2c45); +test(0x2c16,0x2c46); +test(0x2c17,0x2c47); +test(0x2c18,0x2c48); +test(0x2c19,0x2c49); +test(0x2c1a,0x2c4a); +test(0x2c1b,0x2c4b); +test(0x2c1c,0x2c4c); +test(0x2c1d,0x2c4d); +test(0x2c1e,0x2c4e); +test(0x2c1f,0x2c4f); +test(0x2c20,0x2c50); +test(0x2c21,0x2c51); +test(0x2c22,0x2c52); +test(0x2c23,0x2c53); +test(0x2c24,0x2c54); +test(0x2c25,0x2c55); +test(0x2c26,0x2c56); +test(0x2c27,0x2c57); +test(0x2c28,0x2c58); +test(0x2c29,0x2c59); +test(0x2c2a,0x2c5a); +test(0x2c2b,0x2c5b); +test(0x2c2c,0x2c5c); +test(0x2c2d,0x2c5d); +test(0x2c2e,0x2c5e); +test(0x2c30,0x2c00); +test(0x2c31,0x2c01); +test(0x2c32,0x2c02); +test(0x2c33,0x2c03); +test(0x2c34,0x2c04); +test(0x2c35,0x2c05); +test(0x2c36,0x2c06); +test(0x2c37,0x2c07); +test(0x2c38,0x2c08); +test(0x2c39,0x2c09); +test(0x2c3a,0x2c0a); +test(0x2c3b,0x2c0b); +test(0x2c3c,0x2c0c); +test(0x2c3d,0x2c0d); +test(0x2c3e,0x2c0e); +test(0x2c3f,0x2c0f); +test(0x2c40,0x2c10); +test(0x2c41,0x2c11); +test(0x2c42,0x2c12); +test(0x2c43,0x2c13); +test(0x2c44,0x2c14); +test(0x2c45,0x2c15); +test(0x2c46,0x2c16); +test(0x2c47,0x2c17); +test(0x2c48,0x2c18); +test(0x2c49,0x2c19); +test(0x2c4a,0x2c1a); +test(0x2c4b,0x2c1b); +test(0x2c4c,0x2c1c); +test(0x2c4d,0x2c1d); +test(0x2c4e,0x2c1e); +test(0x2c4f,0x2c1f); +test(0x2c50,0x2c20); +test(0x2c51,0x2c21); +test(0x2c52,0x2c22); +test(0x2c53,0x2c23); +test(0x2c54,0x2c24); +test(0x2c55,0x2c25); +test(0x2c56,0x2c26); +test(0x2c57,0x2c27); +test(0x2c58,0x2c28); +test(0x2c59,0x2c29); +test(0x2c5a,0x2c2a); +test(0x2c5b,0x2c2b); +test(0x2c5c,0x2c2c); +test(0x2c5d,0x2c2d); +test(0x2c5e,0x2c2e); +test(0x2c60,0x2c61); +test(0x2c61,0x2c60); +test(0x2c62,0x26b); +test(0x2c63,0x1d7d); +test(0x2c64,0x27d); +test(0x2c65,0x23a); +test(0x2c66,0x23e); +test(0x2c67,0x2c68); +test(0x2c68,0x2c67); +test(0x2c69,0x2c6a); +test(0x2c6a,0x2c69); +test(0x2c6b,0x2c6c); +test(0x2c6c,0x2c6b); +test(0x2c6d,0x251); +test(0x2c6e,0x271); +test(0x2c6f,0x250); +test(0x2c70,0x252); +test(0x2c72,0x2c73); +test(0x2c73,0x2c72); +test(0x2c75,0x2c76); +test(0x2c76,0x2c75); +test(0x2c7e,0x23f); +test(0x2c7f,0x240); +test(0x2c80,0x2c81); +test(0x2c81,0x2c80); +test(0x2c82,0x2c83); +test(0x2c83,0x2c82); +test(0x2c84,0x2c85); +test(0x2c85,0x2c84); +test(0x2c86,0x2c87); +test(0x2c87,0x2c86); +test(0x2c88,0x2c89); +test(0x2c89,0x2c88); +test(0x2c8a,0x2c8b); +test(0x2c8b,0x2c8a); +test(0x2c8c,0x2c8d); +test(0x2c8d,0x2c8c); +test(0x2c8e,0x2c8f); +test(0x2c8f,0x2c8e); +test(0x2c90,0x2c91); +test(0x2c91,0x2c90); +test(0x2c92,0x2c93); +test(0x2c93,0x2c92); +test(0x2c94,0x2c95); +test(0x2c95,0x2c94); +test(0x2c96,0x2c97); +test(0x2c97,0x2c96); +test(0x2c98,0x2c99); +test(0x2c99,0x2c98); +test(0x2c9a,0x2c9b); +test(0x2c9b,0x2c9a); +test(0x2c9c,0x2c9d); +test(0x2c9d,0x2c9c); +test(0x2c9e,0x2c9f); +test(0x2c9f,0x2c9e); +test(0x2ca0,0x2ca1); +test(0x2ca1,0x2ca0); +test(0x2ca2,0x2ca3); +test(0x2ca3,0x2ca2); +test(0x2ca4,0x2ca5); +test(0x2ca5,0x2ca4); +test(0x2ca6,0x2ca7); +test(0x2ca7,0x2ca6); +test(0x2ca8,0x2ca9); +test(0x2ca9,0x2ca8); +test(0x2caa,0x2cab); +test(0x2cab,0x2caa); +test(0x2cac,0x2cad); +test(0x2cad,0x2cac); +test(0x2cae,0x2caf); +test(0x2caf,0x2cae); +test(0x2cb0,0x2cb1); +test(0x2cb1,0x2cb0); +test(0x2cb2,0x2cb3); +test(0x2cb3,0x2cb2); +test(0x2cb4,0x2cb5); +test(0x2cb5,0x2cb4); +test(0x2cb6,0x2cb7); +test(0x2cb7,0x2cb6); +test(0x2cb8,0x2cb9); +test(0x2cb9,0x2cb8); +test(0x2cba,0x2cbb); +test(0x2cbb,0x2cba); +test(0x2cbc,0x2cbd); +test(0x2cbd,0x2cbc); +test(0x2cbe,0x2cbf); +test(0x2cbf,0x2cbe); +test(0x2cc0,0x2cc1); +test(0x2cc1,0x2cc0); +test(0x2cc2,0x2cc3); +test(0x2cc3,0x2cc2); +test(0x2cc4,0x2cc5); +test(0x2cc5,0x2cc4); +test(0x2cc6,0x2cc7); +test(0x2cc7,0x2cc6); +test(0x2cc8,0x2cc9); +test(0x2cc9,0x2cc8); +test(0x2cca,0x2ccb); +test(0x2ccb,0x2cca); +test(0x2ccc,0x2ccd); +test(0x2ccd,0x2ccc); +test(0x2cce,0x2ccf); +test(0x2ccf,0x2cce); +test(0x2cd0,0x2cd1); +test(0x2cd1,0x2cd0); +test(0x2cd2,0x2cd3); +test(0x2cd3,0x2cd2); +test(0x2cd4,0x2cd5); +test(0x2cd5,0x2cd4); +test(0x2cd6,0x2cd7); +test(0x2cd7,0x2cd6); +test(0x2cd8,0x2cd9); +test(0x2cd9,0x2cd8); +test(0x2cda,0x2cdb); +test(0x2cdb,0x2cda); +test(0x2cdc,0x2cdd); +test(0x2cdd,0x2cdc); +test(0x2cde,0x2cdf); +test(0x2cdf,0x2cde); +test(0x2ce0,0x2ce1); +test(0x2ce1,0x2ce0); +test(0x2ce2,0x2ce3); +test(0x2ce3,0x2ce2); +test(0x2ceb,0x2cec); +test(0x2cec,0x2ceb); +test(0x2ced,0x2cee); +test(0x2cee,0x2ced); +test(0x2cf2,0x2cf3); +test(0x2cf3,0x2cf2); +test(0x2d00,0x10a0); +test(0x2d01,0x10a1); +test(0x2d02,0x10a2); +test(0x2d03,0x10a3); +test(0x2d04,0x10a4); +test(0x2d05,0x10a5); +test(0x2d06,0x10a6); +test(0x2d07,0x10a7); +test(0x2d08,0x10a8); +test(0x2d09,0x10a9); +test(0x2d0a,0x10aa); +test(0x2d0b,0x10ab); +test(0x2d0c,0x10ac); +test(0x2d0d,0x10ad); +test(0x2d0e,0x10ae); +test(0x2d0f,0x10af); +test(0x2d10,0x10b0); +test(0x2d11,0x10b1); +test(0x2d12,0x10b2); +test(0x2d13,0x10b3); +test(0x2d14,0x10b4); +test(0x2d15,0x10b5); +test(0x2d16,0x10b6); +test(0x2d17,0x10b7); +test(0x2d18,0x10b8); +test(0x2d19,0x10b9); +test(0x2d1a,0x10ba); +test(0x2d1b,0x10bb); +test(0x2d1c,0x10bc); +test(0x2d1d,0x10bd); +test(0x2d1e,0x10be); +test(0x2d1f,0x10bf); +test(0x2d20,0x10c0); +test(0x2d21,0x10c1); +test(0x2d22,0x10c2); +test(0x2d23,0x10c3); +test(0x2d24,0x10c4); +test(0x2d25,0x10c5); +test(0x2d27,0x10c7); +test(0x2d2d,0x10cd); +test(0xa640,0xa641); +test(0xa641,0xa640); +test(0xa642,0xa643); +test(0xa643,0xa642); +test(0xa644,0xa645); +test(0xa645,0xa644); +test(0xa646,0xa647); +test(0xa647,0xa646); +test(0xa648,0xa649); +test(0xa649,0xa648); +test(0xa64a,0xa64b,0x1c88); +test(0xa64b,0x1c88,0xa64a); +test(0xa64c,0xa64d); +test(0xa64d,0xa64c); +test(0xa64e,0xa64f); +test(0xa64f,0xa64e); +test(0xa650,0xa651); +test(0xa651,0xa650); +test(0xa652,0xa653); +test(0xa653,0xa652); +test(0xa654,0xa655); +test(0xa655,0xa654); +test(0xa656,0xa657); +test(0xa657,0xa656); +test(0xa658,0xa659); +test(0xa659,0xa658); +test(0xa65a,0xa65b); +test(0xa65b,0xa65a); +test(0xa65c,0xa65d); +test(0xa65d,0xa65c); +test(0xa65e,0xa65f); +test(0xa65f,0xa65e); +test(0xa660,0xa661); +test(0xa661,0xa660); +test(0xa662,0xa663); +test(0xa663,0xa662); +test(0xa664,0xa665); +test(0xa665,0xa664); +test(0xa666,0xa667); +test(0xa667,0xa666); +test(0xa668,0xa669); +test(0xa669,0xa668); +test(0xa66a,0xa66b); +test(0xa66b,0xa66a); +test(0xa66c,0xa66d); +test(0xa66d,0xa66c); +test(0xa680,0xa681); +test(0xa681,0xa680); +test(0xa682,0xa683); +test(0xa683,0xa682); +test(0xa684,0xa685); +test(0xa685,0xa684); +test(0xa686,0xa687); +test(0xa687,0xa686); +test(0xa688,0xa689); +test(0xa689,0xa688); +test(0xa68a,0xa68b); +test(0xa68b,0xa68a); +test(0xa68c,0xa68d); +test(0xa68d,0xa68c); +test(0xa68e,0xa68f); +test(0xa68f,0xa68e); +test(0xa690,0xa691); +test(0xa691,0xa690); +test(0xa692,0xa693); +test(0xa693,0xa692); +test(0xa694,0xa695); +test(0xa695,0xa694); +test(0xa696,0xa697); +test(0xa697,0xa696); +test(0xa698,0xa699); +test(0xa699,0xa698); +test(0xa69a,0xa69b); +test(0xa69b,0xa69a); +test(0xa722,0xa723); +test(0xa723,0xa722); +test(0xa724,0xa725); +test(0xa725,0xa724); +test(0xa726,0xa727); +test(0xa727,0xa726); +test(0xa728,0xa729); +test(0xa729,0xa728); +test(0xa72a,0xa72b); +test(0xa72b,0xa72a); +test(0xa72c,0xa72d); +test(0xa72d,0xa72c); +test(0xa72e,0xa72f); +test(0xa72f,0xa72e); +test(0xa732,0xa733); +test(0xa733,0xa732); +test(0xa734,0xa735); +test(0xa735,0xa734); +test(0xa736,0xa737); +test(0xa737,0xa736); +test(0xa738,0xa739); +test(0xa739,0xa738); +test(0xa73a,0xa73b); +test(0xa73b,0xa73a); +test(0xa73c,0xa73d); +test(0xa73d,0xa73c); +test(0xa73e,0xa73f); +test(0xa73f,0xa73e); +test(0xa740,0xa741); +test(0xa741,0xa740); +test(0xa742,0xa743); +test(0xa743,0xa742); +test(0xa744,0xa745); +test(0xa745,0xa744); +test(0xa746,0xa747); +test(0xa747,0xa746); +test(0xa748,0xa749); +test(0xa749,0xa748); +test(0xa74a,0xa74b); +test(0xa74b,0xa74a); +test(0xa74c,0xa74d); +test(0xa74d,0xa74c); +test(0xa74e,0xa74f); +test(0xa74f,0xa74e); +test(0xa750,0xa751); +test(0xa751,0xa750); +test(0xa752,0xa753); +test(0xa753,0xa752); +test(0xa754,0xa755); +test(0xa755,0xa754); +test(0xa756,0xa757); +test(0xa757,0xa756); +test(0xa758,0xa759); +test(0xa759,0xa758); +test(0xa75a,0xa75b); +test(0xa75b,0xa75a); +test(0xa75c,0xa75d); +test(0xa75d,0xa75c); +test(0xa75e,0xa75f); +test(0xa75f,0xa75e); +test(0xa760,0xa761); +test(0xa761,0xa760); +test(0xa762,0xa763); +test(0xa763,0xa762); +test(0xa764,0xa765); +test(0xa765,0xa764); +test(0xa766,0xa767); +test(0xa767,0xa766); +test(0xa768,0xa769); +test(0xa769,0xa768); +test(0xa76a,0xa76b); +test(0xa76b,0xa76a); +test(0xa76c,0xa76d); +test(0xa76d,0xa76c); +test(0xa76e,0xa76f); +test(0xa76f,0xa76e); +test(0xa779,0xa77a); +test(0xa77a,0xa779); +test(0xa77b,0xa77c); +test(0xa77c,0xa77b); +test(0xa77d,0x1d79); +test(0xa77e,0xa77f); +test(0xa77f,0xa77e); +test(0xa780,0xa781); +test(0xa781,0xa780); +test(0xa782,0xa783); +test(0xa783,0xa782); +test(0xa784,0xa785); +test(0xa785,0xa784); +test(0xa786,0xa787); +test(0xa787,0xa786); +test(0xa78b,0xa78c); +test(0xa78c,0xa78b); +test(0xa78d,0x265); +test(0xa790,0xa791); +test(0xa791,0xa790); +test(0xa792,0xa793); +test(0xa793,0xa792); +test(0xa796,0xa797); +test(0xa797,0xa796); +test(0xa798,0xa799); +test(0xa799,0xa798); +test(0xa79a,0xa79b); +test(0xa79b,0xa79a); +test(0xa79c,0xa79d); +test(0xa79d,0xa79c); +test(0xa79e,0xa79f); +test(0xa79f,0xa79e); +test(0xa7a0,0xa7a1); +test(0xa7a1,0xa7a0); +test(0xa7a2,0xa7a3); +test(0xa7a3,0xa7a2); +test(0xa7a4,0xa7a5); +test(0xa7a5,0xa7a4); +test(0xa7a6,0xa7a7); +test(0xa7a7,0xa7a6); +test(0xa7a8,0xa7a9); +test(0xa7a9,0xa7a8); +test(0xa7aa,0x266); +test(0xa7ab,0x25c); +test(0xa7ac,0x261); +test(0xa7ad,0x26c); +test(0xa7ae,0x26a); +test(0xa7b0,0x29e); +test(0xa7b1,0x287); +test(0xa7b2,0x29d); +test(0xa7b3,0xab53); +test(0xa7b4,0xa7b5); +test(0xa7b5,0xa7b4); +test(0xa7b6,0xa7b7); +test(0xa7b7,0xa7b6); +test(0xab53,0xa7b3); +test(0xab70,0x13a0); +test(0xab71,0x13a1); +test(0xab72,0x13a2); +test(0xab73,0x13a3); +test(0xab74,0x13a4); +test(0xab75,0x13a5); +test(0xab76,0x13a6); +test(0xab77,0x13a7); +test(0xab78,0x13a8); +test(0xab79,0x13a9); +test(0xab7a,0x13aa); +test(0xab7b,0x13ab); +test(0xab7c,0x13ac); +test(0xab7d,0x13ad); +test(0xab7e,0x13ae); +test(0xab7f,0x13af); +test(0xab80,0x13b0); +test(0xab81,0x13b1); +test(0xab82,0x13b2); +test(0xab83,0x13b3); +test(0xab84,0x13b4); +test(0xab85,0x13b5); +test(0xab86,0x13b6); +test(0xab87,0x13b7); +test(0xab88,0x13b8); +test(0xab89,0x13b9); +test(0xab8a,0x13ba); +test(0xab8b,0x13bb); +test(0xab8c,0x13bc); +test(0xab8d,0x13bd); +test(0xab8e,0x13be); +test(0xab8f,0x13bf); +test(0xab90,0x13c0); +test(0xab91,0x13c1); +test(0xab92,0x13c2); +test(0xab93,0x13c3); +test(0xab94,0x13c4); +test(0xab95,0x13c5); +test(0xab96,0x13c6); +test(0xab97,0x13c7); +test(0xab98,0x13c8); +test(0xab99,0x13c9); +test(0xab9a,0x13ca); +test(0xab9b,0x13cb); +test(0xab9c,0x13cc); +test(0xab9d,0x13cd); +test(0xab9e,0x13ce); +test(0xab9f,0x13cf); +test(0xaba0,0x13d0); +test(0xaba1,0x13d1); +test(0xaba2,0x13d2); +test(0xaba3,0x13d3); +test(0xaba4,0x13d4); +test(0xaba5,0x13d5); +test(0xaba6,0x13d6); +test(0xaba7,0x13d7); +test(0xaba8,0x13d8); +test(0xaba9,0x13d9); +test(0xabaa,0x13da); +test(0xabab,0x13db); +test(0xabac,0x13dc); +test(0xabad,0x13dd); +test(0xabae,0x13de); +test(0xabaf,0x13df); +test(0xabb0,0x13e0); +test(0xabb1,0x13e1); +test(0xabb2,0x13e2); +test(0xabb3,0x13e3); +test(0xabb4,0x13e4); +test(0xabb5,0x13e5); +test(0xabb6,0x13e6); +test(0xabb7,0x13e7); +test(0xabb8,0x13e8); +test(0xabb9,0x13e9); +test(0xabba,0x13ea); +test(0xabbb,0x13eb); +test(0xabbc,0x13ec); +test(0xabbd,0x13ed); +test(0xabbe,0x13ee); +test(0xabbf,0x13ef); +test(0xff21,0xff41); +test(0xff22,0xff42); +test(0xff23,0xff43); +test(0xff24,0xff44); +test(0xff25,0xff45); +test(0xff26,0xff46); +test(0xff27,0xff47); +test(0xff28,0xff48); +test(0xff29,0xff49); +test(0xff2a,0xff4a); +test(0xff2b,0xff4b); +test(0xff2c,0xff4c); +test(0xff2d,0xff4d); +test(0xff2e,0xff4e); +test(0xff2f,0xff4f); +test(0xff30,0xff50); +test(0xff31,0xff51); +test(0xff32,0xff52); +test(0xff33,0xff53); +test(0xff34,0xff54); +test(0xff35,0xff55); +test(0xff36,0xff56); +test(0xff37,0xff57); +test(0xff38,0xff58); +test(0xff39,0xff59); +test(0xff3a,0xff5a); +test(0xff41,0xff21); +test(0xff42,0xff22); +test(0xff43,0xff23); +test(0xff44,0xff24); +test(0xff45,0xff25); +test(0xff46,0xff26); +test(0xff47,0xff27); +test(0xff48,0xff28); +test(0xff49,0xff29); +test(0xff4a,0xff2a); +test(0xff4b,0xff2b); +test(0xff4c,0xff2c); +test(0xff4d,0xff2d); +test(0xff4e,0xff2e); +test(0xff4f,0xff2f); +test(0xff50,0xff30); +test(0xff51,0xff31); +test(0xff52,0xff32); +test(0xff53,0xff33); +test(0xff54,0xff34); +test(0xff55,0xff35); +test(0xff56,0xff36); +test(0xff57,0xff37); +test(0xff58,0xff38); +test(0xff59,0xff39); +test(0xff5a,0xff3a); +test(0x10400,0x10428); +test(0x10401,0x10429); +test(0x10402,0x1042a); +test(0x10403,0x1042b); +test(0x10404,0x1042c); +test(0x10405,0x1042d); +test(0x10406,0x1042e); +test(0x10407,0x1042f); +test(0x10408,0x10430); +test(0x10409,0x10431); +test(0x1040a,0x10432); +test(0x1040b,0x10433); +test(0x1040c,0x10434); +test(0x1040d,0x10435); +test(0x1040e,0x10436); +test(0x1040f,0x10437); +test(0x10410,0x10438); +test(0x10411,0x10439); +test(0x10412,0x1043a); +test(0x10413,0x1043b); +test(0x10414,0x1043c); +test(0x10415,0x1043d); +test(0x10416,0x1043e); +test(0x10417,0x1043f); +test(0x10418,0x10440); +test(0x10419,0x10441); +test(0x1041a,0x10442); +test(0x1041b,0x10443); +test(0x1041c,0x10444); +test(0x1041d,0x10445); +test(0x1041e,0x10446); +test(0x1041f,0x10447); +test(0x10420,0x10448); +test(0x10421,0x10449); +test(0x10422,0x1044a); +test(0x10423,0x1044b); +test(0x10424,0x1044c); +test(0x10425,0x1044d); +test(0x10426,0x1044e); +test(0x10427,0x1044f); +test(0x10428,0x10400); +test(0x10429,0x10401); +test(0x1042a,0x10402); +test(0x1042b,0x10403); +test(0x1042c,0x10404); +test(0x1042d,0x10405); +test(0x1042e,0x10406); +test(0x1042f,0x10407); +test(0x10430,0x10408); +test(0x10431,0x10409); +test(0x10432,0x1040a); +test(0x10433,0x1040b); +test(0x10434,0x1040c); +test(0x10435,0x1040d); +test(0x10436,0x1040e); +test(0x10437,0x1040f); +test(0x10438,0x10410); +test(0x10439,0x10411); +test(0x1043a,0x10412); +test(0x1043b,0x10413); +test(0x1043c,0x10414); +test(0x1043d,0x10415); +test(0x1043e,0x10416); +test(0x1043f,0x10417); +test(0x10440,0x10418); +test(0x10441,0x10419); +test(0x10442,0x1041a); +test(0x10443,0x1041b); +test(0x10444,0x1041c); +test(0x10445,0x1041d); +test(0x10446,0x1041e); +test(0x10447,0x1041f); +test(0x10448,0x10420); +test(0x10449,0x10421); +test(0x1044a,0x10422); +test(0x1044b,0x10423); +test(0x1044c,0x10424); +test(0x1044d,0x10425); +test(0x1044e,0x10426); +test(0x1044f,0x10427); +test(0x104b0,0x104d8); +test(0x104b1,0x104d9); +test(0x104b2,0x104da); +test(0x104b3,0x104db); +test(0x104b4,0x104dc); +test(0x104b5,0x104dd); +test(0x104b6,0x104de); +test(0x104b7,0x104df); +test(0x104b8,0x104e0); +test(0x104b9,0x104e1); +test(0x104ba,0x104e2); +test(0x104bb,0x104e3); +test(0x104bc,0x104e4); +test(0x104bd,0x104e5); +test(0x104be,0x104e6); +test(0x104bf,0x104e7); +test(0x104c0,0x104e8); +test(0x104c1,0x104e9); +test(0x104c2,0x104ea); +test(0x104c3,0x104eb); +test(0x104c4,0x104ec); +test(0x104c5,0x104ed); +test(0x104c6,0x104ee); +test(0x104c7,0x104ef); +test(0x104c8,0x104f0); +test(0x104c9,0x104f1); +test(0x104ca,0x104f2); +test(0x104cb,0x104f3); +test(0x104cc,0x104f4); +test(0x104cd,0x104f5); +test(0x104ce,0x104f6); +test(0x104cf,0x104f7); +test(0x104d0,0x104f8); +test(0x104d1,0x104f9); +test(0x104d2,0x104fa); +test(0x104d3,0x104fb); +test(0x104d8,0x104b0); +test(0x104d9,0x104b1); +test(0x104da,0x104b2); +test(0x104db,0x104b3); +test(0x104dc,0x104b4); +test(0x104dd,0x104b5); +test(0x104de,0x104b6); +test(0x104df,0x104b7); +test(0x104e0,0x104b8); +test(0x104e1,0x104b9); +test(0x104e2,0x104ba); +test(0x104e3,0x104bb); +test(0x104e4,0x104bc); +test(0x104e5,0x104bd); +test(0x104e6,0x104be); +test(0x104e7,0x104bf); +test(0x104e8,0x104c0); +test(0x104e9,0x104c1); +test(0x104ea,0x104c2); +test(0x104eb,0x104c3); +test(0x104ec,0x104c4); +test(0x104ed,0x104c5); +test(0x104ee,0x104c6); +test(0x104ef,0x104c7); +test(0x104f0,0x104c8); +test(0x104f1,0x104c9); +test(0x104f2,0x104ca); +test(0x104f3,0x104cb); +test(0x104f4,0x104cc); +test(0x104f5,0x104cd); +test(0x104f6,0x104ce); +test(0x104f7,0x104cf); +test(0x104f8,0x104d0); +test(0x104f9,0x104d1); +test(0x104fa,0x104d2); +test(0x104fb,0x104d3); +test(0x10c80,0x10cc0); +test(0x10c81,0x10cc1); +test(0x10c82,0x10cc2); +test(0x10c83,0x10cc3); +test(0x10c84,0x10cc4); +test(0x10c85,0x10cc5); +test(0x10c86,0x10cc6); +test(0x10c87,0x10cc7); +test(0x10c88,0x10cc8); +test(0x10c89,0x10cc9); +test(0x10c8a,0x10cca); +test(0x10c8b,0x10ccb); +test(0x10c8c,0x10ccc); +test(0x10c8d,0x10ccd); +test(0x10c8e,0x10cce); +test(0x10c8f,0x10ccf); +test(0x10c90,0x10cd0); +test(0x10c91,0x10cd1); +test(0x10c92,0x10cd2); +test(0x10c93,0x10cd3); +test(0x10c94,0x10cd4); +test(0x10c95,0x10cd5); +test(0x10c96,0x10cd6); +test(0x10c97,0x10cd7); +test(0x10c98,0x10cd8); +test(0x10c99,0x10cd9); +test(0x10c9a,0x10cda); +test(0x10c9b,0x10cdb); +test(0x10c9c,0x10cdc); +test(0x10c9d,0x10cdd); +test(0x10c9e,0x10cde); +test(0x10c9f,0x10cdf); +test(0x10ca0,0x10ce0); +test(0x10ca1,0x10ce1); +test(0x10ca2,0x10ce2); +test(0x10ca3,0x10ce3); +test(0x10ca4,0x10ce4); +test(0x10ca5,0x10ce5); +test(0x10ca6,0x10ce6); +test(0x10ca7,0x10ce7); +test(0x10ca8,0x10ce8); +test(0x10ca9,0x10ce9); +test(0x10caa,0x10cea); +test(0x10cab,0x10ceb); +test(0x10cac,0x10cec); +test(0x10cad,0x10ced); +test(0x10cae,0x10cee); +test(0x10caf,0x10cef); +test(0x10cb0,0x10cf0); +test(0x10cb1,0x10cf1); +test(0x10cb2,0x10cf2); +test(0x10cc0,0x10c80); +test(0x10cc1,0x10c81); +test(0x10cc2,0x10c82); +test(0x10cc3,0x10c83); +test(0x10cc4,0x10c84); +test(0x10cc5,0x10c85); +test(0x10cc6,0x10c86); +test(0x10cc7,0x10c87); +test(0x10cc8,0x10c88); +test(0x10cc9,0x10c89); +test(0x10cca,0x10c8a); +test(0x10ccb,0x10c8b); +test(0x10ccc,0x10c8c); +test(0x10ccd,0x10c8d); +test(0x10cce,0x10c8e); +test(0x10ccf,0x10c8f); +test(0x10cd0,0x10c90); +test(0x10cd1,0x10c91); +test(0x10cd2,0x10c92); +test(0x10cd3,0x10c93); +test(0x10cd4,0x10c94); +test(0x10cd5,0x10c95); +test(0x10cd6,0x10c96); +test(0x10cd7,0x10c97); +test(0x10cd8,0x10c98); +test(0x10cd9,0x10c99); +test(0x10cda,0x10c9a); +test(0x10cdb,0x10c9b); +test(0x10cdc,0x10c9c); +test(0x10cdd,0x10c9d); +test(0x10cde,0x10c9e); +test(0x10cdf,0x10c9f); +test(0x10ce0,0x10ca0); +test(0x10ce1,0x10ca1); +test(0x10ce2,0x10ca2); +test(0x10ce3,0x10ca3); +test(0x10ce4,0x10ca4); +test(0x10ce5,0x10ca5); +test(0x10ce6,0x10ca6); +test(0x10ce7,0x10ca7); +test(0x10ce8,0x10ca8); +test(0x10ce9,0x10ca9); +test(0x10cea,0x10caa); +test(0x10ceb,0x10cab); +test(0x10cec,0x10cac); +test(0x10ced,0x10cad); +test(0x10cee,0x10cae); +test(0x10cef,0x10caf); +test(0x10cf0,0x10cb0); +test(0x10cf1,0x10cb1); +test(0x10cf2,0x10cb2); +test(0x118a0,0x118c0); +test(0x118a1,0x118c1); +test(0x118a2,0x118c2); +test(0x118a3,0x118c3); +test(0x118a4,0x118c4); +test(0x118a5,0x118c5); +test(0x118a6,0x118c6); +test(0x118a7,0x118c7); +test(0x118a8,0x118c8); +test(0x118a9,0x118c9); +test(0x118aa,0x118ca); +test(0x118ab,0x118cb); +test(0x118ac,0x118cc); +test(0x118ad,0x118cd); +test(0x118ae,0x118ce); +test(0x118af,0x118cf); +test(0x118b0,0x118d0); +test(0x118b1,0x118d1); +test(0x118b2,0x118d2); +test(0x118b3,0x118d3); +test(0x118b4,0x118d4); +test(0x118b5,0x118d5); +test(0x118b6,0x118d6); +test(0x118b7,0x118d7); +test(0x118b8,0x118d8); +test(0x118b9,0x118d9); +test(0x118ba,0x118da); +test(0x118bb,0x118db); +test(0x118bc,0x118dc); +test(0x118bd,0x118dd); +test(0x118be,0x118de); +test(0x118bf,0x118df); +test(0x118c0,0x118a0); +test(0x118c1,0x118a1); +test(0x118c2,0x118a2); +test(0x118c3,0x118a3); +test(0x118c4,0x118a4); +test(0x118c5,0x118a5); +test(0x118c6,0x118a6); +test(0x118c7,0x118a7); +test(0x118c8,0x118a8); +test(0x118c9,0x118a9); +test(0x118ca,0x118aa); +test(0x118cb,0x118ab); +test(0x118cc,0x118ac); +test(0x118cd,0x118ad); +test(0x118ce,0x118ae); +test(0x118cf,0x118af); +test(0x118d0,0x118b0); +test(0x118d1,0x118b1); +test(0x118d2,0x118b2); +test(0x118d3,0x118b3); +test(0x118d4,0x118b4); +test(0x118d5,0x118b5); +test(0x118d6,0x118b6); +test(0x118d7,0x118b7); +test(0x118d8,0x118b8); +test(0x118d9,0x118b9); +test(0x118da,0x118ba); +test(0x118db,0x118bb); +test(0x118dc,0x118bc); +test(0x118dd,0x118bd); +test(0x118de,0x118be); +test(0x118df,0x118bf); +test(0x1e900,0x1e922); +test(0x1e901,0x1e923); +test(0x1e902,0x1e924); +test(0x1e903,0x1e925); +test(0x1e904,0x1e926); +test(0x1e905,0x1e927); +test(0x1e906,0x1e928); +test(0x1e907,0x1e929); +test(0x1e908,0x1e92a); +test(0x1e909,0x1e92b); +test(0x1e90a,0x1e92c); +test(0x1e90b,0x1e92d); +test(0x1e90c,0x1e92e); +test(0x1e90d,0x1e92f); +test(0x1e90e,0x1e930); +test(0x1e90f,0x1e931); +test(0x1e910,0x1e932); +test(0x1e911,0x1e933); +test(0x1e912,0x1e934); +test(0x1e913,0x1e935); +test(0x1e914,0x1e936); +test(0x1e915,0x1e937); +test(0x1e916,0x1e938); +test(0x1e917,0x1e939); +test(0x1e918,0x1e93a); +test(0x1e919,0x1e93b); +test(0x1e91a,0x1e93c); +test(0x1e91b,0x1e93d); +test(0x1e91c,0x1e93e); +test(0x1e91d,0x1e93f); +test(0x1e91e,0x1e940); +test(0x1e91f,0x1e941); +test(0x1e920,0x1e942); +test(0x1e921,0x1e943); +test(0x1e922,0x1e900); +test(0x1e923,0x1e901); +test(0x1e924,0x1e902); +test(0x1e925,0x1e903); +test(0x1e926,0x1e904); +test(0x1e927,0x1e905); +test(0x1e928,0x1e906); +test(0x1e929,0x1e907); +test(0x1e92a,0x1e908); +test(0x1e92b,0x1e909); +test(0x1e92c,0x1e90a); +test(0x1e92d,0x1e90b); +test(0x1e92e,0x1e90c); +test(0x1e92f,0x1e90d); +test(0x1e930,0x1e90e); +test(0x1e931,0x1e90f); +test(0x1e932,0x1e910); +test(0x1e933,0x1e911); +test(0x1e934,0x1e912); +test(0x1e935,0x1e913); +test(0x1e936,0x1e914); +test(0x1e937,0x1e915); +test(0x1e938,0x1e916); +test(0x1e939,0x1e917); +test(0x1e93a,0x1e918); +test(0x1e93b,0x1e919); +test(0x1e93c,0x1e91a); +test(0x1e93d,0x1e91b); +test(0x1e93e,0x1e91c); +test(0x1e93f,0x1e91d); +test(0x1e940,0x1e91e); +test(0x1e941,0x1e91f); +test(0x1e942,0x1e920); +test(0x1e943,0x1e921); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-index.js b/js/src/tests/ecma_6/RegExp/unicode-index.js new file mode 100644 index 000000000..a4b2eb203 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-index.js @@ -0,0 +1,17 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- Pattern match should start from lead surrogate when lastIndex points corresponding trail surrogate."; + +print(BUGNUMBER + ": " + summary); + +var r = /\uD83D\uDC38/ug; +r.lastIndex = 1; +var str = "\uD83D\uDC38"; +var result = r.exec(str); +assertEq(result.length, 1); +assertEq(result[0], "\uD83D\uDC38"); + +// This does not match to ES6 spec, but the spec will be changed. +assertEq(result.index, 0); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-lead-trail.js b/js/src/tests/ecma_6/RegExp/unicode-lead-trail.js new file mode 100644 index 000000000..7ecdb9ace --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-lead-trail.js @@ -0,0 +1,218 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- lead and trail patterns in RegExpUnicodeEscapeSequence."; + +print(BUGNUMBER + ": " + summary); + +// ==== standalone ==== + +assertEqArray(/\uD83D\uDC38/u.exec("\u{1F438}"), + ["\u{1F438}"]); + +// no unicode flag +assertEqArray(/\uD83D\uDC38/.exec("\u{1F438}"), + ["\u{1F438}"]); + +// RegExp constructor +assertEqArray(new RegExp("\\uD83D\\uDC38", "u").exec("\u{1F438}"), + ["\u{1F438}"]); + +// RegExp constructor, no unicode flag +assertEqArray(new RegExp("\\uD83D\\uDC38", "").exec("\u{1F438}"), + ["\u{1F438}"]); + +// ==== ? ==== + +assertEqArray(/\uD83D\uDC38?/u.exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/\uD83D\uDC38?/u.exec(""), + [""]); + +// lead-only target +assertEqArray(/\uD83D\uDC38?/u.exec("\uD83D"), + [""]); + +// no unicode flag +assertEqArray(/\uD83D\uDC38?/.exec("\u{1F438}"), + ["\u{1F438}"]); +assertEq(/\uD83D\uDC38?/.exec(""), + null); + +assertEqArray(/\uD83D\uDC38?/.exec("\uD83D"), + ["\uD83D"]); + +// RegExp constructor +assertEqArray(new RegExp("\\uD83D\\uDC38?", "u").exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(new RegExp("\\uD83D\\uDC38?", "u").exec(""), + [""]); + +assertEqArray(new RegExp("\\uD83D\\uDC38?", "u").exec("\uD83D"), + [""]); + +// RegExp constructor, no unicode flag +assertEqArray(new RegExp("\\uD83D\\uDC38?", "").exec("\u{1F438}"), + ["\u{1F438}"]); +assertEq(new RegExp("\\uD83D\\uDC38?", "").exec(""), + null); + +assertEqArray(new RegExp("\\uD83D\\uDC38?", "").exec("\uD83D"), + ["\uD83D"]); + +// ==== + ==== + +assertEqArray(/\uD83D\uDC38+/u.exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/\uD83D\uDC38+/u.exec("\u{1F438}\u{1F438}"), + ["\u{1F438}\u{1F438}"]); +assertEq(/\uD83D\uDC38+/u.exec(""), + null); + +// lead-only target +assertEq(/\uD83D\uDC38+/u.exec("\uD83D"), + null); +assertEqArray(/\uD83D\uDC38+/u.exec("\uD83D\uDC38\uDC38"), + ["\uD83D\uDC38"]); + +// no unicode flag +assertEqArray(/\uD83D\uDC38+/.exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/\uD83D\uDC38+/.exec("\u{1F438}\u{1F438}"), + ["\u{1F438}"]); +assertEq(/\uD83D\uDC38+/.exec("\uD83D"), + null); +assertEqArray(/\uD83D\uDC38+/.exec("\uD83D\uDC38\uDC38"), + ["\uD83D\uDC38\uDC38"]); +assertEq(/\uD83D\uDC38+/.exec(""), + null); + +// ==== * ==== + +assertEqArray(/\uD83D\uDC38*/u.exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/\uD83D\uDC38*/u.exec("\u{1F438}\u{1F438}"), + ["\u{1F438}\u{1F438}"]); +assertEqArray(/\uD83D\uDC38*/u.exec(""), + [""]); + +// lead-only target +assertEqArray(/\uD83D\uDC38*/u.exec("\uD83D"), + [""]); +assertEqArray(/\uD83D\uDC38*/u.exec("\uD83D\uDC38\uDC38"), + ["\uD83D\uDC38"]); + +// no unicode flag +assertEqArray(/\uD83D\uDC38*/.exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/\uD83D\uDC38*/.exec("\u{1F438}\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(/\uD83D\uDC38*/.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/\uD83D\uDC38*/.exec("\uD83D\uDC38\uDC38"), + ["\uD83D\uDC38\uDC38"]); +assertEq(/\uD83D\uDC38*/.exec(""), + null); + +// ==== lead-only ==== + +// match only non-surrogate pair +assertEqArray(/\uD83D/u.exec("\uD83D\uDBFF"), + ["\uD83D"]); +assertEq(/\uD83D/u.exec("\uD83D\uDC00"), + null); +assertEq(/\uD83D/u.exec("\uD83D\uDFFF"), + null); +assertEqArray(/\uD83D/u.exec("\uD83D\uE000"), + ["\uD83D"]); + +// match before non-tail char +assertEqArray(/\uD83D/u.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/\uD83D/u.exec("\uD83DA"), + ["\uD83D"]); + +// no unicode flag +assertEqArray(/\uD83D/.exec("\uD83D\uDBFF"), + ["\uD83D"]); +assertEqArray(/\uD83D/.exec("\uD83D\uDC00"), + ["\uD83D"]); +assertEqArray(/\uD83D/.exec("\uD83D\uDFFF"), + ["\uD83D"]); +assertEqArray(/\uD83D/.exec("\uD83D\uE000"), + ["\uD83D"]); +assertEqArray(/\uD83D/.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/\uD83D/.exec("\uD83DA"), + ["\uD83D"]); + +// ==== trail-only ==== + +// match only non-surrogate pair +assertEqArray(/\uDC38/u.exec("\uD7FF\uDC38"), + ["\uDC38"]); +assertEq(/\uDC38/u.exec("\uD800\uDC38"), + null); +assertEq(/\uDC38/u.exec("\uDBFF\uDC38"), + null); +assertEqArray(/\uDC38/u.exec("\uDC00\uDC38"), + ["\uDC38"]); + +// match after non-lead char +assertEqArray(/\uDC38/u.exec("\uDC38"), + ["\uDC38"]); +assertEqArray(/\uDC38/u.exec("A\uDC38"), + ["\uDC38"]); + +// no unicode flag +assertEqArray(/\uDC38/.exec("\uD7FF\uDC38"), + ["\uDC38"]); +assertEqArray(/\uDC38/.exec("\uD800\uDC38"), + ["\uDC38"]); +assertEqArray(/\uDC38/.exec("\uDBFF\uDC38"), + ["\uDC38"]); +assertEqArray(/\uDC38/.exec("\uDC00\uDC38"), + ["\uDC38"]); +assertEqArray(/\uDC38/.exec("\uDC38"), + ["\uDC38"]); +assertEqArray(/\uDC38/.exec("A\uDC38"), + ["\uDC38"]); + +// ==== invalid trail ==== + +assertEqArray(/\uD83D\u3042*/u.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/\uD83D\u3042*/u.exec("\uD83D\u3042"), + ["\uD83D\u3042"]); +assertEqArray(/\uD83D\u3042*/u.exec("\uD83D\u3042\u3042"), + ["\uD83D\u3042\u3042"]); + +assertEqArray(/\uD83D\u{3042}*/u.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/\uD83D\u{3042}*/u.exec("\uD83D\u3042"), + ["\uD83D\u3042"]); +assertEqArray(/\uD83D\u{3042}*/u.exec("\uD83D\u3042\u3042"), + ["\uD83D\u3042\u3042"]); + +assertEqArray(/\uD83DA*/u.exec("\uD83D"), + ["\uD83D"]); +assertEqArray(/\uD83DA*/u.exec("\uD83DA"), + ["\uD83DA"]); +assertEqArray(/\uD83DA*/u.exec("\uD83DAA"), + ["\uD83DAA"]); + +// ==== wrong patterns ==== + +assertThrowsInstanceOf(() => eval(`/\\u/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u0/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u00/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u000/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u000G/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\u0.00/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\uD83D\\u/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\uD83D\\u0/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\uD83D\\u00/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\uD83D\\u000/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\uD83D\\u000G/u`), SyntaxError); +assertThrowsInstanceOf(() => eval(`/\\uD83D\\u0.00/u`), SyntaxError); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/ecma_6/RegExp/unicode-raw.js b/js/src/tests/ecma_6/RegExp/unicode-raw.js new file mode 100644 index 000000000..37b572cd8 --- /dev/null +++ b/js/src/tests/ecma_6/RegExp/unicode-raw.js @@ -0,0 +1,139 @@ +var BUGNUMBER = 1135377; +var summary = "Implement RegExp unicode flag -- raw unicode."; + +print(BUGNUMBER + ": " + summary); + +// ==== standalone ==== + +assertEqArray(eval(`/\uD83D\uDC38/u`).exec("\u{1F438}"), + ["\u{1F438}"]); + +// no unicode flag +assertEqArray(eval(`/\uD83D\uDC38/`).exec("\u{1F438}"), + ["\u{1F438}"]); + +// escaped (lead) +assertEq(eval(`/\\uD83D\uDC38/u`).exec("\u{1F438}"), + null); +assertEq(eval(`/\\u{D83D}\uDC38/u`).exec("\u{1F438}"), + null); + +// escaped (trail) +assertEq(eval(`/\uD83D\\uDC38/u`).exec("\u{1F438}"), + null); +assertEq(eval(`/\uD83D\\u{DC38}/u`).exec("\u{1F438}"), + null); + +// escaped (lead), no unicode flag +assertEqArray(eval(`/\\uD83D\uDC38/`).exec("\u{1F438}"), + ["\u{1F438}"]); + +// escaped (trail), no unicode flag +assertEqArray(eval(`/\uD83D\\uDC38/`).exec("\u{1F438}"), + ["\u{1F438}"]); + +// ==== RegExp constructor ==== + +assertEqArray(new RegExp("\uD83D\uDC38", "u").exec("\u{1F438}"), + ["\u{1F438}"]); + +// no unicode flag +assertEqArray(new RegExp("\uD83D\uDC38", "").exec("\u{1F438}"), + ["\u{1F438}"]); + +// escaped(lead) +assertEq(new RegExp("\\uD83D\uDC38", "u").exec("\u{1F438}"), + null); +assertEq(new RegExp("\\u{D83D}\uDC38", "u").exec("\u{1F438}"), + null); + +// escaped(trail) +assertEq(new RegExp("\uD83D\\uDC38", "u").exec("\u{1F438}"), + null); +assertEq(new RegExp("\uD83D\\u{DC38}", "u").exec("\u{1F438}"), + null); + +// escaped(lead), no unicode flag +assertEqArray(new RegExp("\\uD83D\uDC38", "").exec("\u{1F438}"), + ["\u{1F438}"]); + +// escaped(trail), no unicode flag +assertEqArray(new RegExp("\uD83D\\uDC38", "").exec("\u{1F438}"), + ["\u{1F438}"]); + +// ==== ? ==== + +assertEqArray(eval(`/\uD83D\uDC38?/u`).exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(eval(`/\uD83D\uDC38?/u`).exec(""), + [""]); + +assertEqArray(eval(`/\uD83D\uDC38?/u`).exec("\uD83D"), + [""]); + +// no unicode flag +assertEqArray(eval(`/\uD83D\uDC38?/`).exec("\u{1F438}"), + ["\u{1F438}"]); +assertEq(eval(`/\uD83D\uDC38?/`).exec(""), + null); + +assertEqArray(eval(`/\uD83D\uDC38?/`).exec("\uD83D"), + ["\uD83D"]); + +// escaped (lead) +assertEq(eval(`/\\uD83D\uDC38?/u`).exec("\u{1F438}"), + null); +assertEq(eval(`/\\uD83D\uDC38?/u`).exec(""), + null); + +assertEqArray(eval(`/\\uD83D\uDC38?/u`).exec("\uD83D"), + ["\uD83D"]); + +// escaped (trail) +assertEq(eval(`/\uD83D\\uDC38?/u`).exec("\u{1F438}"), + null); +assertEq(eval(`/\uD83D\\uDC38?/u`).exec(""), + null); + +assertEqArray(eval(`/\uD83D\\uDC38?/u`).exec("\uD83D"), + ["\uD83D"]); + +// escaped (lead), no unicode flag +assertEqArray(eval(`/\\uD83D\uDC38?/`).exec("\u{1F438}"), + ["\u{1F438}"]); +assertEq(eval(`/\\uD83D\uDC38?/`).exec(""), + null); + +assertEqArray(eval(`/\\uD83D\uDC38?/`).exec("\uD83D"), + ["\uD83D"]); + +// escaped (trail), no unicode flag +assertEqArray(eval(`/\uD83D\\uDC38?/`).exec("\u{1F438}"), + ["\u{1F438}"]); +assertEq(eval(`/\uD83D\\uDC38?/`).exec(""), + null); + +assertEqArray(eval(`/\uD83D\\uDC38?/`).exec("\uD83D"), + ["\uD83D"]); + +// ==== RegExp constructor, ? ==== + +assertEqArray(new RegExp("\uD83D\uDC38?", "u").exec("\u{1F438}"), + ["\u{1F438}"]); +assertEqArray(new RegExp("\uD83D\uDC38?", "u").exec(""), + [""]); + +assertEqArray(new RegExp("\uD83D\uDC38?", "u").exec("\uD83D"), + [""]); + +// no unicode flag +assertEqArray(new RegExp("\uD83D\uDC38?", "").exec("\u{1F438}"), + ["\u{1F438}"]); +assertEq(new RegExp("\uD83D\uDC38?", "").exec(""), + null); + +assertEqArray(new RegExp("\uD83D\uDC38?", "").exec("\uD83D"), + ["\uD83D"]); + +if (typeof reportCompare === "function") + reportCompare(true, true); |