The Tor Browser / file revision

 /*

  * Any copyright is dedicated to the Public Domain.

  * http://creativecommons.org/licenses/publicdomain/

  */

 var BUGNUMBER = 646490;

 var summary =

   "RegExp.prototype.exec doesn't get the lastIndex and ToInteger() it for " +

   "non-global regular expressions when it should";

 print(BUGNUMBER + ": " + summary);

 /**************

  * BEGIN TEST *

  **************/

 function expectThrowTypeError(fun)

 {

   try

   {

     var r = fun();

     throw new Error("didn't throw TypeError, returned " + r);

   }

   catch (e)

   {

     assertEq(e instanceof TypeError, true,

              "didn't throw TypeError, got: " + e);

   }

 }

 function checkExec(description, regex, args, obj)

 {

   var lastIndex = obj.lastIndex;

   var index = obj.index;

   var input = obj.input;

   var indexArray = obj.indexArray;

   var res = regex.exec.apply(regex, args);

   assertEq(Array.isArray(res), true, description + ": not an array");

   assertEq(regex.lastIndex, lastIndex, description + ": wrong lastIndex");

   assertEq(res.index, index, description + ": wrong index");

   assertEq(res.input, input, description + ": wrong input");

   assertEq(res.length, indexArray.length, description + ": wrong length");

   for (var i = 0, sz = indexArray.length; i < sz; i++)

     assertEq(res[i], indexArray[i], description + " " + i + ": wrong index value");

 }

 var exec = RegExp.prototype.exec;

 var r, res, called, obj;

 /* 1. Let R be this RegExp object. */

 expectThrowTypeError(function() { exec.call(null); });

 expectThrowTypeError(function() { exec.call(""); });

 expectThrowTypeError(function() { exec.call(5); });

 expectThrowTypeError(function() { exec.call({}); });

 expectThrowTypeError(function() { exec.call([]); });

 expectThrowTypeError(function() { exec.call(); });

 expectThrowTypeError(function() { exec.call(true); });

 expectThrowTypeError(function() { exec.call(Object.create(RegExp.prototype)); });

 expectThrowTypeError(function() { exec.call(Object.create(/a/)); });

 /* 2. Let S be the value of ToString(string). */

 called = false;

 r = /a/;

 assertEq(r.lastIndex, 0);

 checkExec("/a/", r, [{ toString: function() { called = true; return 'ba'; } }],

           { lastIndex: 0,

             index: 1,

             input: "ba",

             indexArray: ["a"] });

 assertEq(called, true);

 called = false;

 try

 {

   res = r.exec({ toString: null, valueOf: function() { called = true; throw 17; } });

   throw new Error("didn't throw");

 }

 catch (e)

 {

   assertEq(e, 17);

 }

 assertEq(called, true);

 called = false;

 obj = r.lastIndex = { valueOf: function() { assertEq(true, false, "shouldn't have been called"); } };

 try

 {

   res = r.exec({ toString: null, valueOf: function() { assertEq(called, false); called = true; throw 17; } });

   throw new Error("didn't throw");

 }

 catch (e)

 {

   assertEq(e, 17);

 }

 assertEq(called, true);

 assertEq(r.lastIndex, obj);

 // We don't test lack of an argument because of RegExp statics non-standard

 // behaviors overriding what really should happen for lack of an argument, sigh.

 /*

  * 3. Let length be the length of S.

  * 4. Let lastIndex be the result of calling the [[Get]] internal method of R with argument "lastIndex".

  * 5. Let i be the value of ToInteger(lastIndex).

  */

 r = /b/;

 r.lastIndex = { valueOf: {}, toString: {} };

 expectThrowTypeError(function() { r.exec("foopy"); });

 r.lastIndex = { valueOf: function() { throw new TypeError(); } };

 expectThrowTypeError(function() { r.exec("foopy"); });

 /*

  * 6. Let global be the result of calling the [[Get]] internal method of R with argument "global".

  * 7. If global is false, then let i = 0.

  */

 obj = { valueOf: function() { return 5; } };

 r = /abc/;

 r.lastIndex = obj;

 checkExec("/abc/ take one", r, ["abc-------abc"],

           { lastIndex: obj,

             index: 0,

             input: "abc-------abc",

             indexArray: ["abc"] });

 checkExec("/abc/ take two", r, ["abc-------abc"],

           { lastIndex: obj,

             index: 0,

             input: "abc-------abc",

             indexArray: ["abc"] });

 /*

  * 8. Let matchSucceeded be false.

  * 9. Repeat, while matchSucceeded is false

  *    a. If i < 0 or i > length, then

  *       i. Call the [[Put]] internal method of R with arguments "lastIndex", 0, and true.

  *       ii. Return null.

  *    b. Call the [[Match]] internal method of R with arguments S and i.

  *    c. If [[Match]] returned failure, then

  *       i. Let i = i+1.

  *    d. else

  *       i. Let r be the State result of the call to [[Match]].

  *       ii. Set matchSucceeded to true.

  *    e. Let i = i+1.

  */

 r = /abc()?/;

 r.lastIndex = -5;

 checkExec("/abc()?/ with lastIndex -5", r, ["abc-------abc"],

           { lastIndex: -5,

             index: 0,

             input: "abc-------abc",

             indexArray: ["abc", undefined] });

 r = /abc/;

 r.lastIndex = -17;

 res = r.exec("cdefg");

 assertEq(res, null);

 assertEq(r.lastIndex, 0);

 r = /abc/g;

 r.lastIndex = -42;

 res = r.exec("cdefg");

 assertEq(res, null);

 assertEq(r.lastIndex, 0);

 /*

  * 10. Let e be r's endIndex value.

  * 11. If global is true,

  *     a. Call the [[Put]] internal method of R with arguments "lastIndex", e, and true.

  */

 r = /abc/g;

 r.lastIndex = 17;

 assertEq(r.exec("sdfs"), null);

 assertEq(r.lastIndex, 0);

 r = /abc/g;

 r.lastIndex = 2;

 checkExec("/abc/g", r, ["00abc"],

           { lastIndex: 5,

             index: 2,

             input: "00abc",

             indexArray: ["abc"] });

 r = /a(b)c/g;

 r.lastIndex = 2;

 checkExec("/a(b)c/g take two", r, ["00abcd"],

           { lastIndex: 5,

             index: 2,

             input: "00abcd",

             indexArray: ["abc", "b"] });

 /*

  * 12. Let n be the length of r's captures array. (This is the same value as

  *     15.10.2.1's NCapturingParens.)

  * 13. Let A be a new array created as if by the expression new Array() where

  *     Array is the standard built-in constructor with that name.

  * 14. Let matchIndex be the position of the matched substring within the

  *     complete String S.

  * 15. Call the [[DefineOwnProperty]] internal method of A with arguments

  *     "index", Property Descriptor {[[Value]]: matchIndex, [[Writable]: true,

  *     [[Enumerable]]: true, [[Configurable]]: true}, and true.

  * 16. Call the [[DefineOwnProperty]] internal method of A with arguments

  *     "input", Property Descriptor {[[Value]]: S, [[Writable]: true,

  *     [[Enumerable]]: true, [[Configurable]]: true}, and true.

  * 17. Call the [[DefineOwnProperty]] internal method of A with arguments

  *     "length", Property Descriptor {[[Value]]: n + 1}, and true.

  * 18. Let matchedSubstr be the matched substring (i.e. the portion of S

  *     between offset i inclusive and offset e exclusive).

  * 19. Call the [[DefineOwnProperty]] internal method of A with arguments "0",

  *     Property Descriptor {[[Value]]: matchedSubstr, [[Writable]: true,

  *     [[Enumerable]]: true, [[Configurable]]: true}, and true.

  * 20. For each integer i such that I > 0 and I ≤ n

  *     a. Let captureI be i th element of r's captures array.

  *     b. Call the [[DefineOwnProperty]] internal method of A with arguments

  *        ToString(i), Property Descriptor {[[Value]]: captureI, [[Writable]:

  *        true, [[Enumerable]]: true, [[Configurable]]: true}, and true.

  * 21. Return A.

  */

 // throughout, above (and in other tests)

 /******************************************************************************/

 if (typeof reportCompare === "function")

   reportCompare(true, true);

 print("All tests passed!");