json2.js 6.76 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
// Copyright 2012 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
//       with the distribution.
//     * Neither the name of Google Inc. nor the names of its
//       contributors may be used to endorse or promote products derived
//       from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

28
// Flags: --allow-natives-syntax --expose-externalize-string
29

30 31 32
// Test JSON.stringify on the global object.
var a = 12345;
assertTrue(JSON.stringify(this).indexOf('"a":12345') > 0);
33
assertTrue(JSON.stringify(this, null, 0).indexOf('"a":12345') > 0);
34 35

// Test JSON.stringify of array in dictionary mode.
36 37
function TestStringify(expected, input) {
  assertEquals(expected, JSON.stringify(input));
38 39 40
  assertEquals(expected, JSON.stringify(input, (key, value) => value));
  assertEquals(JSON.stringify(input, null, "="),
               JSON.stringify(input, (key, value) => value, "="));
41 42
}

43 44
var array_1 = [];
var array_2 = [];
45 46 47 48 49
array_1[1<<17] = 1;
array_2[1<<17] = function() { return 1; };
var nulls = "null,";
for (var i = 0; i < 17; i++) {
  nulls += nulls;
50
}
51

52 53
expected_1 = '[' + nulls + '1]';
expected_2 = '[' + nulls + 'null]';
54 55
TestStringify(expected_1, array_1);
TestStringify(expected_2, array_2);
56 57 58 59 60

// Test JSValue with custom prototype.
var num_wrapper = Object(42);
num_wrapper.__proto__ = { __proto__: null,
                          toString: function() { return true; } };
61
TestStringify('1', num_wrapper);
62 63 64 65

var str_wrapper = Object('2');
str_wrapper.__proto__ = { __proto__: null,
                          toString: function() { return true; } };
66
TestStringify('"true"', str_wrapper);
67 68 69 70 71

var bool_wrapper = Object(false);
bool_wrapper.__proto__ = { __proto__: null,
                           toString: function() { return true; } };
// Note that toString function is not evaluated here!
72
TestStringify('false', bool_wrapper);
73 74 75 76 77 78 79

// Test getters.
var counter = 0;
var getter_obj = { get getter() {
                         counter++;
                         return 123;
                       } };
80
TestStringify('{"getter":123}', getter_obj);
81
assertEquals(4, counter);
82 83 84 85 86 87 88

// Test toJSON function.
var tojson_obj = { toJSON: function() {
                             counter++;
                             return [1, 2];
                           },
                   a: 1};
89
TestStringify('[1,2]', tojson_obj);
90
assertEquals(8, counter);
91 92 93 94 95 96 97

// Test that we don't recursively look for the toJSON function.
var tojson_proto_obj = { a: 'fail' };
tojson_proto_obj.__proto__ = { toJSON: function() {
                                         counter++;
                                         return tojson_obj;
                                       } };
98
TestStringify('{"a":1}', tojson_proto_obj);
99 100 101 102 103 104 105 106 107

// Test toJSON produced by a getter.
var tojson_via_getter = { get toJSON() {
                                return function(x) {
                                         counter++;
                                         return 321;
                                       };
                              },
                          a: 1 };
108
TestStringify('321', tojson_via_getter);
109

110 111 112 113
assertThrows(function() {
  JSON.stringify({ get toJSON() { throw "error"; } });
});

114 115 116
// Test toJSON with key.
tojson_obj = { toJSON: function(key) { return key + key; } };
var tojson_with_key_1 = { a: tojson_obj, b: tojson_obj };
117
TestStringify('{"a":"aa","b":"bb"}', tojson_with_key_1);
118
var tojson_with_key_2 = [ tojson_obj, tojson_obj ];
119
TestStringify('["00","11"]', tojson_with_key_2);
120 121 122 123

// Test toJSON with exception.
var tojson_ex = { toJSON: function(key) { throw "123" } };
assertThrows(function() { JSON.stringify(tojson_ex); });
124
assertThrows(function() { JSON.stringify(tojson_ex, null, 0); });
125

126 127
// Test toJSON with access to this.
var obj = { toJSON: function(key) { return this.a + key; }, a: "x" };
128
TestStringify('{"y":"xy"}', {y: obj});
129

130
// Test holes in arrays.
131 132 133 134
var fast_smi = [1, 2, 3, 4];
fast_smi.__proto__ = [7, 7, 7, 7];
delete fast_smi[2];
assertTrue(%HasFastSmiElements(fast_smi));
135
TestStringify("[1,2,7,4]", fast_smi);
136 137 138 139 140 141

var fast_double = [1.1, 2, 3, 4];
fast_double.__proto__ = [7, 7, 7, 7];

delete fast_double[2];
assertTrue(%HasFastDoubleElements(fast_double));
142
TestStringify("[1.1,2,7,4]", fast_double);
143 144 145 146 147 148

var fast_obj = [1, 2, {}, {}];
fast_obj.__proto__ = [7, 7, 7, 7];

delete fast_obj[2];
assertTrue(%HasFastObjectElements(fast_obj));
149
TestStringify("[1,2,7,{}]", fast_obj);
150 151 152 153 154 155 156 157 158 159 160 161 162

var getter_side_effect = { a: 1,
                           get b() {
                             delete this.a;
                             delete this.c;
                             this.e = 5;
                             return 2;
                           },
                           c: 3,
                           d: 4 };
assertEquals('{"a":1,"b":2,"d":4}', JSON.stringify(getter_side_effect));
assertEquals('{"b":2,"d":4,"e":5}', JSON.stringify(getter_side_effect));

163 164 165 166 167 168 169 170 171 172 173 174 175 176
getter_side_effect = { a: 1,
    get b() {
      delete this.a;
      delete this.c;
      this.e = 5;
      return 2;
    },
    c: 3,
    d: 4 };
assertEquals('{"a":1,"b":2,"d":4}',
             JSON.stringify(getter_side_effect, null, 0));
assertEquals('{"b":2,"d":4,"e":5}',
             JSON.stringify(getter_side_effect, null, 0));

177 178 179 180
var non_enum = {};
non_enum.a = 1;
Object.defineProperty(non_enum, "b", { value: 2, enumerable: false });
non_enum.c = 3;
181
TestStringify('{"a":1,"c":3}', non_enum);
182 183 184 185 186 187

var str = "external";
try {
  externalizeString(str, true);
} catch (e) { }
TestStringify("\"external\"", str, null, 0);
188 189 190 191 192

var o = {};
o.somespecialproperty = 10;
o["\x19"] = 10;
assertThrows("JSON.parse('{\"somespecialproperty\":100, \"\x19\":10}')");