From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- js/src/tests/non262/Unicode/browser.js | 0 js/src/tests/non262/Unicode/non-bmp-non-spaces.js | 60 ++++++ js/src/tests/non262/Unicode/regress-352044-01.js | 36 ++++ js/src/tests/non262/Unicode/regress-352044-02-n.js | 36 ++++ js/src/tests/non262/Unicode/shell.js | 0 js/src/tests/non262/Unicode/uc-001-n.js | 23 ++ js/src/tests/non262/Unicode/uc-002-n.js | 14 ++ js/src/tests/non262/Unicode/uc-002.js | 21 ++ js/src/tests/non262/Unicode/uc-003.js | 27 +++ js/src/tests/non262/Unicode/uc-004.js | 26 +++ js/src/tests/non262/Unicode/uc-005.js | 239 +++++++++++++++++++++ 11 files changed, 482 insertions(+) create mode 100644 js/src/tests/non262/Unicode/browser.js create mode 100644 js/src/tests/non262/Unicode/non-bmp-non-spaces.js create mode 100644 js/src/tests/non262/Unicode/regress-352044-01.js create mode 100644 js/src/tests/non262/Unicode/regress-352044-02-n.js create mode 100644 js/src/tests/non262/Unicode/shell.js create mode 100644 js/src/tests/non262/Unicode/uc-001-n.js create mode 100644 js/src/tests/non262/Unicode/uc-002-n.js create mode 100644 js/src/tests/non262/Unicode/uc-002.js create mode 100644 js/src/tests/non262/Unicode/uc-003.js create mode 100644 js/src/tests/non262/Unicode/uc-004.js create mode 100644 js/src/tests/non262/Unicode/uc-005.js (limited to 'js/src/tests/non262/Unicode') diff --git a/js/src/tests/non262/Unicode/browser.js b/js/src/tests/non262/Unicode/browser.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/js/src/tests/non262/Unicode/non-bmp-non-spaces.js b/js/src/tests/non262/Unicode/non-bmp-non-spaces.js new file mode 100644 index 0000000000..809eb81d28 --- /dev/null +++ b/js/src/tests/non262/Unicode/non-bmp-non-spaces.js @@ -0,0 +1,60 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 4 -*- + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// White space must not be determined by truncating char32_t to char16_t. + +assertThrowsInstanceOf(() => eval("\u{40008}"), SyntaxError); +assertThrowsInstanceOf(() => eval("\u{40009}"), SyntaxError); // U+0009 CHARACTER TABULATION +assertThrowsInstanceOf(() => eval("\u{4000A}"), SyntaxError); // U+000A LINE FEED +assertThrowsInstanceOf(() => eval("\u{4000B}"), SyntaxError); // U+000B LINE TABULATION +assertThrowsInstanceOf(() => eval("\u{4000C}"), SyntaxError); // U+000C FORM FEED +assertThrowsInstanceOf(() => eval("\u{4000D}"), SyntaxError); // U+000D CARRIAGE RETURN +assertThrowsInstanceOf(() => eval("\u{4000E}"), SyntaxError); + +assertThrowsInstanceOf(() => eval("\u{4001F}"), SyntaxError); +assertThrowsInstanceOf(() => eval("\u{40020}"), SyntaxError); // U+0020 SPACE +assertThrowsInstanceOf(() => eval("\u{40021}"), SyntaxError); + +assertThrowsInstanceOf(() => eval("\u{4009F}"), SyntaxError); +assertThrowsInstanceOf(() => eval("\u{400A0}"), SyntaxError); // U+00A0 NO-BREAK SPACE +assertThrowsInstanceOf(() => eval("\u{400A1}"), SyntaxError); + +assertThrowsInstanceOf(() => eval("\u{4167F}"), SyntaxError); +assertThrowsInstanceOf(() => eval("\u{41680}"), SyntaxError); // U+1680 OGHAM SPACE MARK +assertThrowsInstanceOf(() => eval("\u{41681}"), SyntaxError); + +assertThrowsInstanceOf(() => eval("\u{41FFF}"), SyntaxError); +assertThrowsInstanceOf(() => eval("\u{42000}"), SyntaxError); // U+2000 EN QUAD +assertThrowsInstanceOf(() => eval("\u{42001}"), SyntaxError); // U+2001 EM QUAD +assertThrowsInstanceOf(() => eval("\u{42002}"), SyntaxError); // U+2002 EN SPACE +assertThrowsInstanceOf(() => eval("\u{42003}"), SyntaxError); // U+2003 EM SPACE +assertThrowsInstanceOf(() => eval("\u{42004}"), SyntaxError); // U+2004 THREE-PER-EM SPACE +assertThrowsInstanceOf(() => eval("\u{42005}"), SyntaxError); // U+2005 FOUR-PER-EM SPACE +assertThrowsInstanceOf(() => eval("\u{42006}"), SyntaxError); // U+2006 SIX-PER-EM SPACE +assertThrowsInstanceOf(() => eval("\u{42007}"), SyntaxError); // U+2007 FIGURE SPACE +assertThrowsInstanceOf(() => eval("\u{42008}"), SyntaxError); // U+2008 PUNCTUATION SPACE +assertThrowsInstanceOf(() => eval("\u{42009}"), SyntaxError); // U+2009 THIN SPACE +assertThrowsInstanceOf(() => eval("\u{4200A}"), SyntaxError); // U+200A HAIR SPACE +assertThrowsInstanceOf(() => eval("\u{4200B}"), SyntaxError); + +assertThrowsInstanceOf(() => eval("\u{42027}"), SyntaxError); +assertThrowsInstanceOf(() => eval("\u{42028}"), SyntaxError); // U+2028 LINE SEPARATOR +assertThrowsInstanceOf(() => eval("\u{42029}"), SyntaxError); // U+2028 PARAGRAPH SEPARATOR +assertThrowsInstanceOf(() => eval("\u{4202A}"), SyntaxError); + +assertThrowsInstanceOf(() => eval("\u{4202E}"), SyntaxError); +assertThrowsInstanceOf(() => eval("\u{4202F}"), SyntaxError); // U+202F NARROW NO-BREAK SPACE +assertThrowsInstanceOf(() => eval("\u{42030}"), SyntaxError); + +assertThrowsInstanceOf(() => eval("\u{4205E}"), SyntaxError); +assertThrowsInstanceOf(() => eval("\u{4205F}"), SyntaxError); // U+205F MEDIUM MATHEMATICAL SPACE +assertThrowsInstanceOf(() => eval("\u{42060}"), SyntaxError); + +assertThrowsInstanceOf(() => eval("\u{42FFF}"), SyntaxError); +assertThrowsInstanceOf(() => eval("\u{43000}"), SyntaxError); // U+3000 IDEOGRAPHIC SPACE +assertThrowsInstanceOf(() => eval("\u{43001}"), SyntaxError); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Unicode/regress-352044-01.js b/js/src/tests/non262/Unicode/regress-352044-01.js new file mode 100644 index 0000000000..bdbb4371b9 --- /dev/null +++ b/js/src/tests/non262/Unicode/regress-352044-01.js @@ -0,0 +1,36 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 352044; +var summary = 'issues with Unicode escape sequences in JavaScript source code'; +var actual = ''; +var expect = ''; + + +//----------------------------------------------------------------------------- +test(); +//----------------------------------------------------------------------------- + +function test() +{ + printBugNumber(BUGNUMBER); + printStatus (summary); + + expect = 'SyntaxError'; + + try + { + var i = 1; + eval('i \\u002b= 1'); + print(i); + } + catch(ex) + { + actual = ex.constructor.name; + } + + reportCompare(expect, actual, summary); +} diff --git a/js/src/tests/non262/Unicode/regress-352044-02-n.js b/js/src/tests/non262/Unicode/regress-352044-02-n.js new file mode 100644 index 0000000000..d3f41c3e8a --- /dev/null +++ b/js/src/tests/non262/Unicode/regress-352044-02-n.js @@ -0,0 +1,36 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 352044; +var summary = 'issues with Unicode escape sequences in JavaScript source code'; +var actual = 'No Error'; +var expect = 'SyntaxError'; + + +//----------------------------------------------------------------------------- +test(); +//----------------------------------------------------------------------------- + +function test() +{ + printBugNumber(BUGNUMBER); + printStatus (summary); + + print('This test case is expected to throw an uncaught SyntaxError'); + + try + { + var i = 1; + i \u002b= 1; + print(i); + } + catch(ex) + { + actual = ex + ''; + } + + reportCompare(expect, actual, summary); +} diff --git a/js/src/tests/non262/Unicode/shell.js b/js/src/tests/non262/Unicode/shell.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/js/src/tests/non262/Unicode/uc-001-n.js b/js/src/tests/non262/Unicode/uc-001-n.js new file mode 100644 index 0000000000..4ac78b5c2c --- /dev/null +++ b/js/src/tests/non262/Unicode/uc-001-n.js @@ -0,0 +1,23 @@ +/* -*- tab-width: 8; indent-tabs-mode: nil; js-indent-level: 4 -*- + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +var BUGNUMBER = 23612; + +test(); + +function test() +{ + printStatus ("Unicode Characters 1C-1F negative test."); + printBugNumber (BUGNUMBER); + + reportCompare ("error", eval ("'no'\u001C+' error'"), + "Unicode whitespace test (1C.)"); + reportCompare ("error", eval ("'no'\u001D+' error'"), + "Unicode whitespace test (1D.)"); + reportCompare ("error", eval ("'no'\u001E+' error'"), + "Unicode whitespace test (1E.)"); + reportCompare ("error", eval ("'no'\u001F+' error'"), + "Unicode whitespace test (1F.)"); +} diff --git a/js/src/tests/non262/Unicode/uc-002-n.js b/js/src/tests/non262/Unicode/uc-002-n.js new file mode 100644 index 0000000000..5b1512a70e --- /dev/null +++ b/js/src/tests/non262/Unicode/uc-002-n.js @@ -0,0 +1,14 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 4 -*- + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +var BUGNUMBER = 23607; +DESCRIPTION = "Non-character escapes in identifiers negative test."; + +printStatus ("Non-character escapes in identifiers negative test."); +printBugNumber (BUGNUMBER); + +eval("\u0020 = 5"); +reportCompare('PASS', 'FAIL', "Previous statement should have thrown an error."); + diff --git a/js/src/tests/non262/Unicode/uc-002.js b/js/src/tests/non262/Unicode/uc-002.js new file mode 100644 index 0000000000..e96d95d377 --- /dev/null +++ b/js/src/tests/non262/Unicode/uc-002.js @@ -0,0 +1,21 @@ +/* -*- tab-width: 8; indent-tabs-mode: nil; js-indent-level: 4 -*- + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +var BUGNUMBER = 23613; + +test(); + +function test() +{ + printStatus ("Unicode non-breaking space character test."); + printBugNumber (BUGNUMBER); + + reportCompare ("no error", eval("'no'\u00A0+ ' error'"), + "Unicode non-breaking space character test."); + + var str = "\u00A0foo"; + reportCompare (0, str.search(/^\sfoo$/), + "Unicode non-breaking space character regexp test."); +} diff --git a/js/src/tests/non262/Unicode/uc-003.js b/js/src/tests/non262/Unicode/uc-003.js new file mode 100644 index 0000000000..12207809ad --- /dev/null +++ b/js/src/tests/non262/Unicode/uc-003.js @@ -0,0 +1,27 @@ +/* -*- tab-width: 8; indent-tabs-mode: nil; js-indent-level: 4 -*- + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +var BUGNUMBER = 23608; +var BUGNUMBER = 23607; + +test(); + +function test() +{ + var \u0041 = 5; + var A\u03B2 = 15; + + printStatus ("Escapes in identifiers test."); + printBugNumber (BUGNUMBER); + + reportCompare (5, eval("\u0041"), + "Escaped ASCII Identifier test."); + reportCompare (6, eval("++\u0041"), + "Escaped ASCII Identifier test"); + reportCompare (15, eval("A\u03B2"), + "Escaped non-ASCII Identifier test"); + reportCompare (16, eval("++A\u03B2"), + "Escaped non-ASCII Identifier test"); +} diff --git a/js/src/tests/non262/Unicode/uc-004.js b/js/src/tests/non262/Unicode/uc-004.js new file mode 100644 index 0000000000..4490753491 --- /dev/null +++ b/js/src/tests/non262/Unicode/uc-004.js @@ -0,0 +1,26 @@ +/* -*- tab-width: 8; indent-tabs-mode: nil; js-indent-level: 4 -*- + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +var BUGNUMBER = 23612; + +test(); + +function test() +{ + printStatus ("Unicode Characters 1C-1F with regexps test."); + printBugNumber (BUGNUMBER); + + var ary = ["\u001Cfoo", "\u001Dfoo", "\u001Efoo", "\u001Ffoo"]; + + for (var i in ary) + { + reportCompare (0, ary[Number(i)].search(/^\Sfoo$/), + "Unicode characters 1C-1F in regexps, ary[" + + i + "] did not match \\S test (it should not.)"); + reportCompare (-1, ary[Number(i)].search(/^\sfoo$/), + "Unicode characters 1C-1F in regexps, ary[" + + i + "] matched \\s test (it should not.)"); + } +} diff --git a/js/src/tests/non262/Unicode/uc-005.js b/js/src/tests/non262/Unicode/uc-005.js new file mode 100644 index 0000000000..fe28b460fc --- /dev/null +++ b/js/src/tests/non262/Unicode/uc-005.js @@ -0,0 +1,239 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* + * + * Date: 15 July 2002 + * SUMMARY: Testing identifiers with double-byte names + * See http://bugzilla.mozilla.org/show_bug.cgi?id=58274 + * + * Here is a sample of the problem: + * + * js> function f\u02B1 () {} + * + * js> f\u02B1.toSource(); + * function f¦() {} + * + * js> f\u02B1.toSource().toSource(); + * (new String("function f\xB1() {}")) + * + * + * See how the high-byte information (the 02) has been lost? + * The same thing was happening with the toString() method: + * + * js> f\u02B1.toString(); + * + * function f¦() { + * } + * + * js> f\u02B1.toString().toSource(); + * (new String("\nfunction f\xB1() {\n}\n")) + * + */ +//----------------------------------------------------------------------------- +var UBound = 0; +var BUGNUMBER = 58274; +var summary = 'Testing identifiers with double-byte names'; +var status = ''; +var statusitems = []; +var actual = ''; +var actualvalues = []; +var expect= ''; +var expectedvalues = []; + + +/* + * Define a function that uses double-byte identifiers in + * "every possible way" + * + * Then recover each double-byte identifier via f.toString(). + * To make this easier, put a 'Z' token before every one. + * + * Our eval string will be: + * + * sEval = "function Z\u02b1(Z\u02b2, b) { + * try { Z\u02b3 : var Z\u02b4 = Z\u02b1; } + * catch (Z\u02b5) { for (var Z\u02b6 in Z\u02b5) + * {for (1; 1<0; Z\u02b7++) {new Array()[Z\u02b6] = 1;} };} }"; + * + * It will be helpful to build this string in stages: + */ +var s0 = 'function Z'; +var s1 = '\u02b1(Z'; +var s2 = '\u02b2, b) {try { Z'; +var s3 = '\u02b3 : var Z'; +var s4 = '\u02b4 = Z'; +var s5 = '\u02b1; } catch (Z' + var s6 = '\u02b5) { for (var Z'; +var s7 = '\u02b6 in Z'; +var s8 = '\u02b5){for (1; 1<0; Z'; +var s9 = '\u02b7++) {new Array()[Z'; +var s10 = '\u02b6] = 1;} };} }'; + + +/* + * Concatenate these and eval() to create the function Z\u02b1 + */ +var sEval = s0 + s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10; +eval(sEval); + + +/* + * Recover all the double-byte identifiers via Z\u02b1.toString(). + * We'll recover the 1st one as arrID[1], the 2nd one as arrID[2], + * and so on ... + */ +var arrID = getIdentifiers(Z\u02b1); + + +/* + * Now check that we got back what we put in - + */ +status = inSection(1); +actual = arrID[1]; +expect = s1.charAt(0); +addThis(); + +status = inSection(2); +actual = arrID[2]; +expect = s2.charAt(0); +addThis(); + +status = inSection(3); +actual = arrID[3]; +expect = s3.charAt(0); +addThis(); + +status = inSection(4); +actual = arrID[4]; +expect = s4.charAt(0); +addThis(); + +status = inSection(5); +actual = arrID[5]; +expect = s5.charAt(0); +addThis(); + +status = inSection(6); +actual = arrID[6]; +expect = s6.charAt(0); +addThis(); + +status = inSection(7); +actual = arrID[7]; +expect = s7.charAt(0); +addThis(); + +status = inSection(8); +actual = arrID[8]; +expect = s8.charAt(0); +addThis(); + +status = inSection(9); +actual = arrID[9]; +expect = s9.charAt(0); +addThis(); + +status = inSection(10); +actual = arrID[10]; +expect = s10.charAt(0); +addThis(); + + + + +//----------------------------------------------------------------------------- +test(); +//----------------------------------------------------------------------------- + + + +/* + * Goal: recover the double-byte identifiers from f.toString() + * by getting the very next character after each 'Z' token. + * + * The return value will be an array |arr| indexed such that + * |arr[1]| is the 1st identifier, |arr[2]| the 2nd, and so on. + * + * Note, however, f.toString() is implementation-independent. + * For example, it may begin with '\nfunction' instead of 'function'. + * + * Rhino uses a Unicode representation for f.toString(); whereas + * SpiderMonkey uses an ASCII representation, putting escape sequences + * for non-ASCII characters. For example, if a function is called f\u02B1, + * then in Rhino the toString() method will present a 2-character Unicode + * string for its name, whereas SpiderMonkey will present a 7-character + * ASCII string for its name: the string literal 'f\u02B1'. + * + * So we force the lexer to condense the string before we use it. + * This will give uniform results in Rhino and SpiderMonkey. + */ +function getIdentifiers(f) +{ + var str = condenseStr(f.toString()); + var arr = str.split('Z'); + + /* + * The identifiers are the 1st char of each split substring + * EXCEPT the first one, which is just ('\n' +) 'function '. + * + * Thus note the 1st identifier will be stored in |arr[1]|, + * the 2nd one in |arr[2]|, etc., making the indexing easy - + */ + for (i in arr) + arr[i] = arr[i].charAt(0); + return arr; +} + + +/* + * This function is the opposite of a functions like escape(), which take + * Unicode characters and return escape sequences for them. Here, we force + * the lexer to turn escape sequences back into single characters. + * + * Note we can't simply do |eval(str)|, since in practice |str| will be an + * identifier somewhere in the program (e.g. a function name); thus |eval(str)| + * would return the object that the identifier represents: not what we want. + * + * So we surround |str| lexicographically with quotes to force the lexer to + * evaluate it as a string. Have to strip out any linefeeds first, however - + */ +function condenseStr(str) +{ + /* + * You won't be able to do the next step if |str| has + * any carriage returns or linefeeds in it. For example: + * + * js> eval("'" + '\nHello' + "'"); + * 1: SyntaxError: unterminated string literal: + * 1: ' + * 1: ^ + * + * So replace them with the empty string - + */ + str = str.replace(/[\r\n]/g, '') + return eval("'" + str + "'") + } + + +function addThis() +{ + statusitems[UBound] = status; + actualvalues[UBound] = actual; + expectedvalues[UBound] = expect; + UBound++; +} + + +function test() +{ + printBugNumber(BUGNUMBER); + printStatus(summary); + + for (var i=0; i