• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// Copyright 2009 the V8 project authors. All rights reserved.
2// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6//     * Redistributions of source code must retain the above copyright
7//       notice, this list of conditions and the following disclaimer.
8//     * Redistributions in binary form must reproduce the above
9//       copyright notice, this list of conditions and the following
10//       disclaimer in the documentation and/or other materials provided
11//       with the distribution.
12//     * Neither the name of Google Inc. nor the names of its
13//       contributors may be used to endorse or promote products derived
14//       from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28// Date toJSON
29assertEquals("1970-01-01T00:00:00.000Z", new Date(0).toJSON());
30assertEquals("1979-01-11T08:00:00.000Z", new Date("1979-01-11 08:00 GMT").toJSON());
31assertEquals("2005-05-05T05:05:05.000Z", new Date("2005-05-05 05:05:05 GMT").toJSON());
32var n1 = new Date(10000);
33n1.toISOString = function () { return "foo"; };
34assertEquals("foo", n1.toJSON());
35var n2 = new Date(10001);
36n2.toISOString = null;
37assertThrows(function () { n2.toJSON(); }, TypeError);
38var n4 = new Date(10003);
39n4.toISOString = function () {
40  assertEquals(0, arguments.length);
41  assertEquals(this, n4);
42  return null;
43};
44assertEquals(null, n4.toJSON());
45
46assertTrue(Object.prototype === JSON.__proto__);
47assertEquals("[object JSON]", Object.prototype.toString.call(JSON));
48
49//Test Date.prototype.toJSON as generic function.
50var d1 = {toJSON: Date.prototype.toJSON,
51         toISOString: function() { return 42; }};
52assertEquals(42, d1.toJSON());
53
54var d2 = {toJSON: Date.prototype.toJSON,
55          valueOf: function() { return Infinity; },
56          toISOString: function() { return 42; }};
57assertEquals(null, d2.toJSON());
58
59var d3 = {toJSON: Date.prototype.toJSON,
60          valueOf: "not callable",
61          toString: function() { return Infinity; },
62          toISOString: function() { return 42; }};
63
64assertEquals(null, d3.toJSON());
65
66var d4 = {toJSON: Date.prototype.toJSON,
67          valueOf: "not callable",
68          toString: "not callable either",
69          toISOString: function() { return 42; }};
70assertThrows("d4.toJSON()", TypeError);  // ToPrimitive throws.
71
72var d5 = {toJSON: Date.prototype.toJSON,
73          valueOf: "not callable",
74          toString: function() { return "Infinity"; },
75          toISOString: function() { return 42; }};
76assertEquals(42, d5.toJSON());
77
78var d6 = {toJSON: Date.prototype.toJSON,
79          toISOString: function() { return ["not primitive"]; }};
80assertEquals(["not primitive"], d6.toJSON());
81
82var d7 = {toJSON: Date.prototype.toJSON,
83          ISOString: "not callable"};
84assertThrows("d7.toJSON()", TypeError);
85
86// DontEnum
87for (var p in this) {
88  assertFalse(p == "JSON");
89}
90
91// Parse
92assertEquals({}, JSON.parse("{}"));
93assertEquals({42:37}, JSON.parse('{"42":37}'));
94assertEquals(null, JSON.parse("null"));
95assertEquals(true, JSON.parse("true"));
96assertEquals(false, JSON.parse("false"));
97assertEquals("foo", JSON.parse('"foo"'));
98assertEquals("f\no", JSON.parse('"f\\no"'));
99assertEquals("\b\f\n\r\t\"\u2028\/\\",
100             JSON.parse('"\\b\\f\\n\\r\\t\\"\\u2028\\/\\\\"'));
101assertEquals([1.1], JSON.parse("[1.1]"));
102assertEquals([1], JSON.parse("[1.0]"));
103
104assertEquals(0, JSON.parse("0"));
105assertEquals(1, JSON.parse("1"));
106assertEquals(0.1, JSON.parse("0.1"));
107assertEquals(1.1, JSON.parse("1.1"));
108assertEquals(1.1, JSON.parse("1.100000"));
109assertEquals(1.111111, JSON.parse("1.111111"));
110assertEquals(-0, JSON.parse("-0"));
111assertEquals(-1, JSON.parse("-1"));
112assertEquals(-0.1, JSON.parse("-0.1"));
113assertEquals(-1.1, JSON.parse("-1.1"));
114assertEquals(-1.1, JSON.parse("-1.100000"));
115assertEquals(-1.111111, JSON.parse("-1.111111"));
116assertEquals(11, JSON.parse("1.1e1"));
117assertEquals(11, JSON.parse("1.1e+1"));
118assertEquals(0.11, JSON.parse("1.1e-1"));
119assertEquals(11, JSON.parse("1.1E1"));
120assertEquals(11, JSON.parse("1.1E+1"));
121assertEquals(0.11, JSON.parse("1.1E-1"));
122
123assertEquals([], JSON.parse("[]"));
124assertEquals([1], JSON.parse("[1]"));
125assertEquals([1, "2", true, null], JSON.parse('[1, "2", true, null]'));
126
127assertEquals("", JSON.parse('""'));
128assertEquals(["", "", -0, ""], JSON.parse('[    ""  ,    ""  ,   -0,    ""]'));
129assertEquals("", JSON.parse('""'));
130
131
132function GetFilter(name) {
133  function Filter(key, value) {
134    return (key == name) ? undefined : value;
135  }
136  return Filter;
137}
138
139var pointJson = '{"x": 1, "y": 2}';
140assertEquals({'x': 1, 'y': 2}, JSON.parse(pointJson));
141assertEquals({'x': 1}, JSON.parse(pointJson, GetFilter('y')));
142assertEquals({'y': 2}, JSON.parse(pointJson, GetFilter('x')));
143
144assertEquals([1, 2, 3], JSON.parse("[1, 2, 3]"));
145
146var array1 = JSON.parse("[1, 2, 3]", GetFilter(1));
147assertEquals([1, , 3], array1);
148assertFalse(array1.hasOwnProperty(1));  // assertEquals above is not enough
149
150var array2 = JSON.parse("[1, 2, 3]", GetFilter(2));
151assertEquals([1, 2, ,], array2);
152assertFalse(array2.hasOwnProperty(2));
153
154function DoubleNumbers(key, value) {
155  return (typeof value == 'number') ? 2 * value : value;
156}
157
158var deepObject = '{"a": {"b": 1, "c": 2}, "d": {"e": {"f": 3}}}';
159assertEquals({"a": {"b": 1, "c": 2}, "d": {"e": {"f": 3}}},
160             JSON.parse(deepObject));
161assertEquals({"a": {"b": 2, "c": 4}, "d": {"e": {"f": 6}}},
162             JSON.parse(deepObject, DoubleNumbers));
163
164function TestInvalid(str) {
165  assertThrows(function () { JSON.parse(str); }, SyntaxError);
166}
167
168TestInvalid('abcdef');
169TestInvalid('isNaN()');
170TestInvalid('{"x": [1, 2, deepObject]}');
171TestInvalid('[1, [2, [deepObject], 3], 4]');
172TestInvalid('function () { return 0; }');
173
174TestInvalid("[1, 2");
175TestInvalid('{"x": 3');
176
177// JavaScript number literals not valid in JSON.
178TestInvalid('[01]');
179TestInvalid('[.1]');
180TestInvalid('[1.]');
181TestInvalid('[1.e1]');
182TestInvalid('[-.1]');
183TestInvalid('[-1.]');
184
185// Plain invalid number literals.
186TestInvalid('-');
187TestInvalid('--1');
188TestInvalid('-1e');
189TestInvalid('1e--1]');
190TestInvalid('1e+-1');
191TestInvalid('1e-+1');
192TestInvalid('1e++1');
193
194// JavaScript string literals not valid in JSON.
195TestInvalid("'single quote'");  // Valid JavaScript
196TestInvalid('"\\a invalid escape"');
197TestInvalid('"\\v invalid escape"');  // Valid JavaScript
198TestInvalid('"\\\' invalid escape"');  // Valid JavaScript
199TestInvalid('"\\x42 invalid escape"');  // Valid JavaScript
200TestInvalid('"\\u202 invalid escape"');
201TestInvalid('"\\012 invalid escape"');
202TestInvalid('"Unterminated string');
203TestInvalid('"Unterminated string\\"');
204TestInvalid('"Unterminated string\\\\\\"');
205
206// Test bad JSON that would be good JavaScript (ES5).
207TestInvalid("{true:42}");
208TestInvalid("{false:42}");
209TestInvalid("{null:42}");
210TestInvalid("{'foo':42}");
211TestInvalid("{42:42}");
212TestInvalid("{0:42}");
213TestInvalid("{-1:42}");
214
215// Test for trailing garbage detection.
216TestInvalid('42 px');
217TestInvalid('42 .2');
218TestInvalid('42 2');
219TestInvalid('42 e1');
220TestInvalid('"42" ""');
221TestInvalid('"42" ""');
222TestInvalid('"" ""');
223TestInvalid('true ""');
224TestInvalid('false ""');
225TestInvalid('null ""');
226TestInvalid('null ""');
227TestInvalid('[] ""');
228TestInvalid('[true] ""');
229TestInvalid('{} ""');
230TestInvalid('{"x":true} ""');
231TestInvalid('"Garbage""After string"');
232
233// Stringify
234
235function TestStringify(expected, input) {
236  assertEquals(expected, JSON.stringify(input));
237  assertEquals(expected, JSON.stringify(input, (key, value) => value));
238  assertEquals(JSON.stringify(input, null, "="),
239               JSON.stringify(input, (key, value) => value, "="));
240}
241
242TestStringify("true", true);
243TestStringify("false", false);
244TestStringify("null", null);
245TestStringify("false", {toJSON: function () { return false; }});
246TestStringify("4", 4);
247TestStringify('"foo"', "foo");
248TestStringify("null", Infinity);
249TestStringify("null", -Infinity);
250TestStringify("null", NaN);
251TestStringify("4", new Number(4));
252TestStringify('"bar"', new String("bar"));
253
254TestStringify('"foo\\u0000bar"', "foo\0bar");
255TestStringify('"f\\"o\'o\\\\b\\ba\\fr\\nb\\ra\\tz"',
256              "f\"o\'o\\b\ba\fr\nb\ra\tz");
257
258TestStringify("[1,2,3]", [1, 2, 3]);
259assertEquals("[\n 1,\n 2,\n 3\n]", JSON.stringify([1, 2, 3], null, 1));
260assertEquals("[\n  1,\n  2,\n  3\n]", JSON.stringify([1, 2, 3], null, 2));
261assertEquals("[\n  1,\n  2,\n  3\n]",
262             JSON.stringify([1, 2, 3], null, new Number(2)));
263assertEquals("[\n^1,\n^2,\n^3\n]", JSON.stringify([1, 2, 3], null, "^"));
264assertEquals("[\n^1,\n^2,\n^3\n]",
265             JSON.stringify([1, 2, 3], null, new String("^")));
266assertEquals("[\n 1,\n 2,\n [\n  3,\n  [\n   4\n  ],\n  5\n ],\n 6,\n 7\n]",
267             JSON.stringify([1, 2, [3, [4], 5], 6, 7], null, 1));
268assertEquals("[]", JSON.stringify([], null, 1));
269assertEquals("[1,2,[3,[4],5],6,7]",
270             JSON.stringify([1, 2, [3, [4], 5], 6, 7], null));
271assertEquals("[2,4,[6,[8],10],12,14]",
272             JSON.stringify([1, 2, [3, [4], 5], 6, 7], DoubleNumbers));
273TestStringify('["a","ab","abc"]', ["a","ab","abc"]);
274TestStringify('{"a":1,"c":true}', { a : 1,
275                                    b : function() { 1 },
276                                    c : true,
277                                    d : function() { 2 } });
278TestStringify('[1,null,true,null]',
279              [1, function() { 1 }, true, function() { 2 }]);
280TestStringify('"toJSON 123"',
281              { toJSON : function() { return 'toJSON 123'; } });
282TestStringify('{"a":321}',
283              { a : { toJSON : function() { return 321; } } });
284var counter = 0;
285assertEquals('{"getter":123}',
286             JSON.stringify({ get getter() { counter++; return 123; } }));
287assertEquals(1, counter);
288assertEquals('{"getter":123}',
289             JSON.stringify({ get getter() { counter++; return 123; } },
290                            null,
291                            0));
292assertEquals(2, counter);
293
294TestStringify('{"a":"abc","b":"\u1234bc"}',
295              { a : "abc", b : "\u1234bc" });
296
297
298var a = { a : 1, b : 2 };
299delete a.a;
300TestStringify('{"b":2}', a);
301
302var b = {};
303b.__proto__ = { toJSON : function() { return 321;} };
304TestStringify("321", b);
305
306var array = [""];
307var expected = '""';
308for (var i = 0; i < 10000; i++) {
309  array.push("");
310  expected = '"",' + expected;
311}
312expected = '[' + expected + ']';
313TestStringify(expected, array);
314
315
316var circular = [1, 2, 3];
317circular[2] = circular;
318assertThrows(function () { JSON.stringify(circular); }, TypeError);
319assertThrows(function () { JSON.stringify(circular, null, 0); }, TypeError);
320
321var singleton = [];
322var multiOccurrence = [singleton, singleton, singleton];
323TestStringify("[[],[],[]]", multiOccurrence);
324
325TestStringify('{"x":5,"y":6}', {x:5,y:6});
326assertEquals('{"x":5}', JSON.stringify({x:5,y:6}, ['x']));
327assertEquals('{\n "a": "b",\n "c": "d"\n}',
328             JSON.stringify({a:"b",c:"d"}, null, 1));
329assertEquals('{"y":6,"x":5}', JSON.stringify({x:5,y:6}, ['y', 'x']));
330
331// toJSON get string keys.
332var checker = {};
333var array = [checker];
334checker.toJSON = function(key) { return 1 + key; };
335TestStringify('["10"]', array);
336
337// The gap is capped at ten characters if specified as string.
338assertEquals('{\n          "a": "b",\n          "c": "d"\n}',
339              JSON.stringify({a:"b",c:"d"}, null,
340                             "          /*characters after 10th*/"));
341
342//The gap is capped at ten characters if specified as number.
343assertEquals('{\n          "a": "b",\n          "c": "d"\n}',
344              JSON.stringify({a:"b",c:"d"}, null, 15));
345
346// Replaced wrapped primitives are unwrapped.
347function newx(k, v)  { return (k == "x") ? new v(42) : v; }
348assertEquals('{"x":"42"}', JSON.stringify({x: String}, newx));
349assertEquals('{"x":42}', JSON.stringify({x: Number}, newx));
350assertEquals('{"x":true}', JSON.stringify({x: Boolean}, newx));
351
352TestStringify(undefined, undefined);
353TestStringify(undefined, function () { });
354// Arrays with missing, undefined or function elements have those elements
355// replaced by null.
356TestStringify("[null,null,null]", [undefined,,function(){}]);
357
358// Objects with undefined or function properties (including replaced properties)
359// have those properties ignored.
360assertEquals('{}',
361             JSON.stringify({a: undefined, b: function(){}, c: 42, d: 42},
362                            function(k, v) { if (k == "c") return undefined;
363                                             if (k == "d") return function(){};
364                                             return v; }));
365
366TestInvalid('1); throw "foo"; (1');
367
368var x = 0;
369eval("(1); x++; (1)");
370TestInvalid('1); x++; (1');
371
372// Test string conversion of argument.
373var o = { toString: function() { return "42"; } };
374assertEquals(42, JSON.parse(o));
375
376
377for (var i = 0; i < 65536; i++) {
378  var string = String.fromCharCode(i);
379  var encoded = JSON.stringify(string);
380  var expected = "uninitialized";
381  // Following the ES5 specification of the abstraction function Quote.
382  if (string == '"' || string == '\\') {
383    // Step 2.a
384    expected = '\\' + string;
385  } else if ("\b\t\n\r\f".indexOf(string) >= 0) {
386    // Step 2.b
387    if (string == '\b') expected = '\\b';
388    else if (string == '\t') expected = '\\t';
389    else if (string == '\n') expected = '\\n';
390    else if (string == '\f') expected = '\\f';
391    else if (string == '\r') expected = '\\r';
392  } else if (i < 32) {
393    // Step 2.c
394    if (i < 16) {
395      expected = "\\u000" + i.toString(16);
396    } else {
397      expected = "\\u00" + i.toString(16);
398    }
399  } else {
400    expected = string;
401  }
402  assertEquals('"' + expected + '"', encoded, "Codepoint " + i);
403}
404
405
406// Ensure that wrappers and callables are handled correctly.
407var num37 = new Number(42);
408num37.valueOf = function() { return 37; };
409
410var numFoo = new Number(42);
411numFoo.valueOf = "not callable";
412numFoo.toString = function() { return "foo"; };
413
414var numTrue = new Number(42);
415numTrue.valueOf = function() { return true; }
416
417var strFoo = new String("bar");
418strFoo.toString = function() { return "foo"; };
419
420var str37 = new String("bar");
421str37.toString = "not callable";
422str37.valueOf = function() { return 37; };
423
424var strTrue = new String("bar");
425strTrue.toString = function() { return true; }
426
427var func = function() { /* Is callable */ };
428
429var funcJSON = function() { /* Is callable */ };
430funcJSON.toJSON = function() { return "has toJSON"; };
431
432var re = /Is callable/;
433
434var reJSON = /Is callable/;
435reJSON.toJSON = function() { return "has toJSON"; };
436
437TestStringify('[37,null,1,"foo","37","true",null,"has toJSON",{},"has toJSON"]',
438              [num37, numFoo, numTrue,
439               strFoo, str37, strTrue,
440               func, funcJSON, re, reJSON]);
441
442
443var oddball = Object(42);
444oddball.__proto__ = { __proto__: null, toString: function() { return true; } };
445TestStringify('1', oddball);
446
447var getCount = 0;
448var callCount = 0;
449var counter = { get toJSON() { getCount++;
450                               return function() { callCount++;
451                                                   return 42; }; } };
452
453// RegExps are not callable, so they are stringified as objects.
454TestStringify('{}', /regexp/);
455TestStringify('42', counter);
456assertEquals(4, getCount);
457assertEquals(4, callCount);
458
459var oddball2 = Object(42);
460var oddball3 = Object("foo");
461oddball3.__proto__ = { __proto__: null,
462                       toString: "not callable",
463                       valueOf: function() { return true; } };
464oddball2.__proto__ = { __proto__: null,
465                       toJSON: function () { return oddball3; } }
466TestStringify('"true"', oddball2);
467
468
469var falseNum = Object("37");
470falseNum.__proto__ = Number.prototype;
471falseNum.toString = function() { return 42; };
472TestStringify('"42"', falseNum);
473
474// Parse an object value as __proto__.
475var o1 = JSON.parse('{"__proto__":[]}');
476assertEquals([], o1.__proto__);
477assertEquals(["__proto__"], Object.keys(o1));
478assertEquals([], Object.getOwnPropertyDescriptor(o1, "__proto__").value);
479assertEquals(["__proto__"], Object.getOwnPropertyNames(o1));
480assertTrue(o1.hasOwnProperty("__proto__"));
481assertTrue(Object.prototype.isPrototypeOf(o1));
482
483// Parse a non-object value as __proto__.
484var o2 = JSON.parse('{"__proto__":5}');
485assertEquals(5, o2.__proto__);
486assertEquals(["__proto__"], Object.keys(o2));
487assertEquals(5, Object.getOwnPropertyDescriptor(o2, "__proto__").value);
488assertEquals(["__proto__"], Object.getOwnPropertyNames(o2));
489assertTrue(o2.hasOwnProperty("__proto__"));
490assertTrue(Object.prototype.isPrototypeOf(o2));
491
492var json = '{"stuff before slash\\\\stuff after slash":"whatever"}';
493TestStringify(json, JSON.parse(json));
494
495
496// https://bugs.chromium.org/p/v8/issues/detail?id=3139
497
498reviver = function(p, v) {
499  if (p == "a") {
500    this.b = { get x() {return null}, set x(_){throw 666} }
501  }
502  return v;
503}
504assertEquals({a: 0, b: {x: null}}, JSON.parse('{"a":0,"b":1}', reviver));
505
506
507// Make sure a failed [[Delete]] doesn't throw
508
509reviver = function(p, v) {
510  Object.freeze(this);
511  return p === "" ? v : undefined;
512}
513assertEquals({a: 0, b: 1}, JSON.parse('{"a":0,"b":1}', reviver));
514
515
516// Make sure a failed [[DefineProperty]] doesn't throw
517
518reviver = function(p, v) {
519  Object.freeze(this);
520  return p === "" ? v : 42;
521}
522assertEquals({a: 0, b: 1}, JSON.parse('{"a":0,"b":1}', reviver));
523
524reviver = (k, v) => (v === Infinity) ? "inf" : v;
525assertEquals('{"":"inf"}', JSON.stringify({"":Infinity}, reviver));
526