Extend test coverage for JSON.stringify's slow path.

test/mjsunit/json.js

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 207 matching lines @@
 TestInvalid('null ""');
 TestInvalid('null ""');
 TestInvalid('[] ""');
 TestInvalid('[true] ""');
 TestInvalid('{} ""');
 TestInvalid('{"x":true} ""');
 TestInvalid('"Garbage""After string"');
 
 // Stringify
 
-assertEquals("true", JSON.stringify(true));
-assertEquals("false", JSON.stringify(false));
-assertEquals("null", JSON.stringify(null));
-assertEquals("false", JSON.stringify({toJSON: function () { return false; }}));
-assertEquals("4", JSON.stringify(4));
-assertEquals('"foo"', JSON.stringify("foo"));
-assertEquals("null", JSON.stringify(Infinity));
-assertEquals("null", JSON.stringify(-Infinity));
-assertEquals("null", JSON.stringify(NaN));
-assertEquals("4", JSON.stringify(new Number(4)));
-assertEquals('"bar"', JSON.stringify(new String("bar")));
+function TestStringify(expected, input) {
+  assertEquals(expected, JSON.stringify(input));
+  assertEquals(expected, JSON.stringify(input, null, 0));
+}
 
-assertEquals('"foo\\u0000bar"', JSON.stringify("foo\0bar"));
-assertEquals('"f\\"o\'o\\\\b\\ba\\fr\\nb\\ra\\tz"',
-             JSON.stringify("f\"o\'o\\b\ba\fr\nb\ra\tz"));
+TestStringify("true", true);
+TestStringify("false", false);
+TestStringify("null", null);
+TestStringify("false", {toJSON: function () { return false; }});
+TestStringify("4", 4);
+TestStringify('"foo"', "foo");
+TestStringify("null", Infinity);
+TestStringify("null", -Infinity);
+TestStringify("null", NaN);
+TestStringify("4", new Number(4));
+TestStringify('"bar"', new String("bar"));
 
-assertEquals("[1,2,3]", JSON.stringify([1, 2, 3]));
+TestStringify('"foo\\u0000bar"', "foo\0bar");
+TestStringify('"f\\"o\'o\\\\b\\ba\\fr\\nb\\ra\\tz"',
+              "f\"o\'o\\b\ba\fr\nb\ra\tz");
+
+TestStringify("[1,2,3]", [1, 2, 3]);
 assertEquals("[\n 1,\n 2,\n 3\n]", JSON.stringify([1, 2, 3], null, 1));
 assertEquals("[\n  1,\n  2,\n  3\n]", JSON.stringify([1, 2, 3], null, 2));
 assertEquals("[\n  1,\n  2,\n  3\n]",
              JSON.stringify([1, 2, 3], null, new Number(2)));
 assertEquals("[\n^1,\n^2,\n^3\n]", JSON.stringify([1, 2, 3], null, "^"));
 assertEquals("[\n^1,\n^2,\n^3\n]",
              JSON.stringify([1, 2, 3], null, new String("^")));
 assertEquals("[\n 1,\n 2,\n [\n  3,\n  [\n   4\n  ],\n  5\n ],\n 6,\n 7\n]",
              JSON.stringify([1, 2, [3, [4], 5], 6, 7], null, 1));
 assertEquals("[]", JSON.stringify([], null, 1));
 assertEquals("[1,2,[3,[4],5],6,7]",
              JSON.stringify([1, 2, [3, [4], 5], 6, 7], null));
 assertEquals("[2,4,[6,[8],10],12,14]",
              JSON.stringify([1, 2, [3, [4], 5], 6, 7], DoubleNumbers));
-assertEquals('["a","ab","abc"]', JSON.stringify(["a","ab","abc"]));
-assertEquals('{"a":1,"c":true}',
-              JSON.stringify({ a : 1,
-                               b : function() { 1 },
-                               c : true,
-                               d : function() { 2 } }));
-assertEquals('[1,null,true,null]',
-             JSON.stringify([1, function() { 1 }, true, function() { 2 }]));
-assertEquals('"toJSON 123"',
-             JSON.stringify({ toJSON : function() { return 'toJSON 123'; } }));
-assertEquals('{"a":321}',
-             JSON.stringify({ a : { toJSON : function() { return 321; } } }));
+TestStringify('["a","ab","abc"]', ["a","ab","abc"]);
+TestStringify('{"a":1,"c":true}', { a : 1,
+                                    b : function() { 1 },
+                                    c : true,
+                                    d : function() { 2 } });
+TestStringify('[1,null,true,null]',
+              [1, function() { 1 }, true, function() { 2 }]);
+TestStringify('"toJSON 123"',
+              { toJSON : function() { return 'toJSON 123'; } });
+TestStringify('{"a":321}',
+              { a : { toJSON : function() { return 321; } } });
 var counter = 0;
 assertEquals('{"getter":123}',
              JSON.stringify({ get getter() { counter++; return 123; } }));
 assertEquals(1, counter);
-assertEquals('{"a":"abc","b":"\u1234bc"}',
-             JSON.stringify({ a : "abc", b : "\u1234bc" }));
+assertEquals('{"getter":123}',
+             JSON.stringify({ get getter() { counter++; return 123; } },
+                            null,
+                            0));
+assertEquals(2, counter);
+
+TestStringify('{"a":"abc","b":"\u1234bc"}',
+              { a : "abc", b : "\u1234bc" });
 
 
 var a = { a : 1, b : 2 };
 delete a.a;
-assertEquals('{"b":2}', JSON.stringify(a));
+TestStringify('{"b":2}', a);
 
 var b = {};
 b.__proto__ = { toJSON : function() { return 321;} };
-assertEquals("321", JSON.stringify(b));
+TestStringify("321", b);
 
 var array = [""];
 var expected = '""';
 for (var i = 0; i < 10000; i++) {
   array.push("");
   expected = '"",' + expected;
 }
 expected = '[' + expected + ']';
-assertEquals(expected, JSON.stringify(array));
+TestStringify(expected, array);
 
 
 var circular = [1, 2, 3];
 circular[2] = circular;
 assertThrows(function () { JSON.stringify(circular); }, TypeError);
+assertThrows(function () { JSON.stringify(circular, null, 0); }, TypeError);
 
 var singleton = [];
 var multiOccurrence = [singleton, singleton, singleton];
-assertEquals("[[],[],[]]", JSON.stringify(multiOccurrence));
+TestStringify("[[],[],[]]", multiOccurrence);
 
-assertEquals('{"x":5,"y":6}', JSON.stringify({x:5,y:6}));
+TestStringify('{"x":5,"y":6}', {x:5,y:6});
 assertEquals('{"x":5}', JSON.stringify({x:5,y:6}, ['x']));
 assertEquals('{\n "a": "b",\n "c": "d"\n}',
              JSON.stringify({a:"b",c:"d"}, null, 1));
 assertEquals('{"y":6,"x":5}', JSON.stringify({x:5,y:6}, ['y', 'x']));
 
 // toJSON get string keys.
 var checker = {};
 var array = [checker];
 checker.toJSON = function(key) { return 1 + key; };
-assertEquals('["10"]', JSON.stringify(array));
+TestStringify('["10"]', array);
 
 // The gap is capped at ten characters if specified as string.
 assertEquals('{\n          "a": "b",\n          "c": "d"\n}',
               JSON.stringify({a:"b",c:"d"}, null,
                              "          /*characters after 10th*/"));
 
 //The gap is capped at ten characters if specified as number.
 assertEquals('{\n          "a": "b",\n          "c": "d"\n}',
               JSON.stringify({a:"b",c:"d"}, null, 15));
 
 // Replaced wrapped primitives are unwrapped.
 function newx(k, v)  { return (k == "x") ? new v(42) : v; }
 assertEquals('{"x":"42"}', JSON.stringify({x: String}, newx));
 assertEquals('{"x":42}', JSON.stringify({x: Number}, newx));
 assertEquals('{"x":true}', JSON.stringify({x: Boolean}, newx));
 
-assertEquals(undefined, JSON.stringify(undefined));
-assertEquals(undefined, JSON.stringify(function () { }));
+TestStringify(undefined, undefined);
+TestStringify(undefined, function () { });
 // Arrays with missing, undefined or function elements have those elements
 // replaced by null.
-assertEquals("[null,null,null]",
-             JSON.stringify([undefined,,function(){}]));
+TestStringify("[null,null,null]", [undefined,,function(){}]);
 
 // Objects with undefined or function properties (including replaced properties)
 // have those properties ignored.
 assertEquals('{}',
              JSON.stringify({a: undefined, b: function(){}, c: 42, d: 42},
                             function(k, v) { if (k == "c") return undefined;
                                              if (k == "d") return function(){};
                                              return v; }));
 
 TestInvalid('1); throw "foo"; (1');
@@ skipping 60 matching lines @@
 var func = function() { /* Is callable */ };
 
 var funcJSON = function() { /* Is callable */ };
 funcJSON.toJSON = function() { return "has toJSON"; };
 
 var re = /Is callable/;
 
 var reJSON = /Is callable/;
 reJSON.toJSON = function() { return "has toJSON"; };
 
-assertEquals(
-    '[37,null,1,"foo","37","true",null,"has toJSON",{},"has toJSON"]',
-    JSON.stringify([num37, numFoo, numTrue,
-                    strFoo, str37, strTrue,
-                    func, funcJSON, re, reJSON]));
+TestStringify('[37,null,1,"foo","37","true",null,"has toJSON",{},"has toJSON"]',
+              [num37, numFoo, numTrue,
+               strFoo, str37, strTrue,
+               func, funcJSON, re, reJSON]);
 
 
 var oddball = Object(42);
 oddball.__proto__ = { __proto__: null, toString: function() { return true; } };
-assertEquals('1', JSON.stringify(oddball));
+TestStringify('1', oddball);
 
 var getCount = 0;
 var callCount = 0;
 var counter = { get toJSON() { getCount++;
                                return function() { callCount++;
                                                    return 42; }; } };
 
 // RegExps are not callable, so they are stringified as objects.
-assertEquals('{}', JSON.stringify(/regexp/));
-assertEquals('42', JSON.stringify(counter));
-assertEquals(1, getCount);
-assertEquals(1, callCount);
+TestStringify('{}', /regexp/);
+TestStringify('42', counter);
+assertEquals(2, getCount);
+assertEquals(2, callCount);
 
 var oddball2 = Object(42);
 var oddball3 = Object("foo");
 oddball3.__proto__ = { __proto__: null,
                        toString: "not callable",
                        valueOf: function() { return true; } };
 oddball2.__proto__ = { __proto__: null,
                        toJSON: function () { return oddball3; } }
-assertEquals('"true"', JSON.stringify(oddball2));
+TestStringify('"true"', oddball2);
 
 
 var falseNum = Object("37");
 falseNum.__proto__ = Number.prototype;
 falseNum.toString = function() { return 42; };
-assertEquals('"42"', JSON.stringify(falseNum));
+TestStringify('"42"', falseNum);
 
 // Parse an object value as __proto__.
 var o1 = JSON.parse('{"__proto__":[]}');
 assertEquals([], o1.__proto__);
 assertEquals(["__proto__"], Object.keys(o1));
 assertEquals([], Object.getOwnPropertyDescriptor(o1, "__proto__").value);
 assertEquals(["__proto__"], Object.getOwnPropertyNames(o1));
 assertTrue(o1.hasOwnProperty("__proto__"));
 assertTrue(Object.prototype.isPrototypeOf(o1));
 
 // Parse a non-object value as __proto__.
 var o2 = JSON.parse('{"__proto__":5}');
 assertEquals(5, o2.__proto__);
 assertEquals(["__proto__"], Object.keys(o2));
 assertEquals(5, Object.getOwnPropertyDescriptor(o2, "__proto__").value);
 assertEquals(["__proto__"], Object.getOwnPropertyNames(o2));
 assertTrue(o2.hasOwnProperty("__proto__"));
 assertTrue(Object.prototype.isPrototypeOf(o2));
 
 var json = '{"stuff before slash\\\\stuff after slash":"whatever"}';
-assertEquals(json, JSON.stringify(JSON.parse(json)));
+TestStringify(json, JSON.parse(json));