Implement JSON built-in object
JerryScript-DCO-1.0-Signed-off-by: Roland Takacs rtakacs.u-szeged@partner.samsung.com JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg@inf.u-szeged.hu
This commit is contained in:
Zoltan Herczeg
@@ -0,0 +1,359 @@
|
||||
// Copyright 2015 University of Szeged
|
||||
// Copyright 2015 Samsung Electronics Co., Ltd.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// Checking primitve types
|
||||
var str;
|
||||
var result;
|
||||
var log;
|
||||
|
||||
function check_parse_error (str)
|
||||
{
|
||||
try {
|
||||
JSON.parse (str);
|
||||
// Should throw a parse error.
|
||||
assert (false);
|
||||
} catch (e) {
|
||||
}
|
||||
}
|
||||
|
||||
str = ' null ';
|
||||
assert (JSON.parse (str) === null);
|
||||
str = 'true';
|
||||
assert (JSON.parse (str) === true);
|
||||
str = 'false';
|
||||
assert (JSON.parse (str) === false);
|
||||
str = '-32.5e002';
|
||||
assert (JSON.parse (str) == -3250);
|
||||
str = '"str"';
|
||||
assert (JSON.parse (str) == "str");
|
||||
|
||||
check_parse_error ('undefined');
|
||||
check_parse_error ('falses');
|
||||
check_parse_error ('+5');
|
||||
check_parse_error ('5.');
|
||||
check_parse_error ('01');
|
||||
check_parse_error ('0x1');
|
||||
check_parse_error ('0e-');
|
||||
check_parse_error ('3e+a');
|
||||
check_parse_error ('55e4,');
|
||||
check_parse_error ('5 true');
|
||||
check_parse_error ("'str'");
|
||||
|
||||
// Checking objects
|
||||
str = ' { "x": 0, "yy": null, "zzz": { "A": 4.0, "BB": { "1": 63e-1 }, "CCC" : false } } ';
|
||||
result = JSON.parse (str);
|
||||
assert (typeof result == "object");
|
||||
assert (result.x === 0);
|
||||
assert (result.yy === null);
|
||||
assert (typeof result.zzz == "object");
|
||||
assert (result.zzz.A === 4);
|
||||
assert (typeof result.zzz.BB == "object");
|
||||
assert (result.zzz.BB["1"] === 6.3);
|
||||
assert (result.zzz.CCC === false);
|
||||
|
||||
check_parse_error ('{');
|
||||
check_parse_error ('{{{}');
|
||||
check_parse_error ('{x:5}');
|
||||
check_parse_error ('{true:4}');
|
||||
check_parse_error ('{"x":5 "y":6}');
|
||||
check_parse_error ('{"x":5,"y":6,}');
|
||||
check_parse_error ('{"x":5,,"y":6}');
|
||||
|
||||
// Checking arrays
|
||||
str = '[{"x":[]},[[]],{}, [ null ] ]';
|
||||
result = JSON.parse (str);
|
||||
assert (result.length === 4);
|
||||
assert (typeof result === "object");
|
||||
assert (typeof result[0] === "object");
|
||||
assert (typeof result[0].x === "object");
|
||||
assert (result[0].x.length === 0);
|
||||
assert (result[1].length === 1);
|
||||
assert (result[1][0].length === 0);
|
||||
assert (typeof result[2] === "object");
|
||||
assert (result[3].length === 1);
|
||||
assert (result[3][0] === null);
|
||||
|
||||
check_parse_error ('[');
|
||||
check_parse_error ('[[[]');
|
||||
check_parse_error ('[ true null ]');
|
||||
check_parse_error ('[1,,2]');
|
||||
check_parse_error ('[1,2,]');
|
||||
check_parse_error ('[1] [2]');
|
||||
|
||||
// Checking parse with different primitive types
|
||||
|
||||
assert (JSON.parse (null) == null);
|
||||
assert (JSON.parse (true) == true);
|
||||
assert (JSON.parse (3) == 3);
|
||||
|
||||
try {
|
||||
JSON.parse (undefined);
|
||||
// Should not be reached.
|
||||
assert (false);
|
||||
} catch (e) {
|
||||
assert (e instanceof SyntaxError);
|
||||
}
|
||||
|
||||
// Checking parse with different object types
|
||||
|
||||
object = { toString: function() { return false; } };
|
||||
assert (JSON.parse (object) == false);
|
||||
|
||||
object = {"a": 3, "b": "foo"};
|
||||
try {
|
||||
JSON.parse (object);
|
||||
// Should not be reached.
|
||||
assert (false);
|
||||
} catch (e) {
|
||||
assert (e instanceof SyntaxError);
|
||||
}
|
||||
|
||||
array = [3, "foo"];
|
||||
try {
|
||||
JSON.parse (array);
|
||||
// Should not be reached.
|
||||
assert (false);
|
||||
} catch (e) {
|
||||
assert (e instanceof SyntaxError);
|
||||
}
|
||||
|
||||
assert (JSON.parse (new Number (3)) == 3);
|
||||
assert (JSON.parse (new Boolean (true)) == true);
|
||||
|
||||
object = new String ('{"a": 3, "b": "foo"}');
|
||||
result = JSON.parse (object);
|
||||
|
||||
assert (result.a == 3);
|
||||
assert (result.b == "foo");
|
||||
|
||||
// Checking reviver
|
||||
|
||||
function toStringReviver(k, v)
|
||||
{
|
||||
log += "<" + k + ">:" + (typeof v == "number" ? v : "(obj)") + ", ";
|
||||
return v;
|
||||
}
|
||||
|
||||
str = '{ "a":1, "b":2, "c": { "d":4, "e": { "f":6 } } }';
|
||||
log = "";
|
||||
JSON.parse (str, toStringReviver);
|
||||
assert (log === "<a>:1, <b>:2, <d>:4, <f>:6, <e>:(obj), <c>:(obj), <>:(obj), ");
|
||||
|
||||
str = '[ 32, 47, 33 ]';
|
||||
log = "";
|
||||
JSON.parse (str, toStringReviver);
|
||||
assert (log === "<0>:32, <1>:47, <2>:33, <>:(obj), ");
|
||||
|
||||
// Defining properties multiple times
|
||||
|
||||
str = ' { "a":1, "b":2, "a":3 } ';
|
||||
log = "";
|
||||
JSON.parse (str, toStringReviver);
|
||||
assert (log === "<a>:3, <b>:2, <>:(obj), ");
|
||||
|
||||
str = ' { "a":1, "b":2, "b":3 } ';
|
||||
log = "";
|
||||
JSON.parse (str, toStringReviver);
|
||||
assert (log === "<a>:1, <b>:3, <>:(obj), ");
|
||||
|
||||
str = ' { "a":1, "b":{}, "b":[], "a":2, "b":3, "c":4 } ';
|
||||
log = "";
|
||||
JSON.parse (str, toStringReviver);
|
||||
assert (log === "<a>:2, <b>:3, <c>:4, <>:(obj), ");
|
||||
|
||||
// Changing property value
|
||||
|
||||
str = ' { "a":1, "b":2, "c":3 } ';
|
||||
result = JSON.parse (str, function (k, v) {
|
||||
if (k == "a")
|
||||
{
|
||||
return 8;
|
||||
}
|
||||
if (k == "b")
|
||||
{
|
||||
return 9;
|
||||
}
|
||||
if (k == "c")
|
||||
{
|
||||
return void 0;
|
||||
}
|
||||
return v;
|
||||
});
|
||||
|
||||
assert (result.a === 8);
|
||||
assert (result.b === 9);
|
||||
assert (result.c === void 0);
|
||||
|
||||
// Adding / deleting properties
|
||||
|
||||
str = ' { "a":1, "b":2 } ';
|
||||
log = "";
|
||||
result = JSON.parse (str, function (k, v) {
|
||||
if (k == "a")
|
||||
{
|
||||
// Deleted properties must still be enumerated.
|
||||
delete this["b"];
|
||||
// New properties must not be enumerated.
|
||||
this.c = 4;
|
||||
}
|
||||
if (k != "")
|
||||
{
|
||||
log += "<" + k + ">:" + v + " ";
|
||||
}
|
||||
return v;
|
||||
});
|
||||
|
||||
assert (log === "<a>:1 <b>:undefined ");
|
||||
assert (result.a === 1);
|
||||
assert (result.b === void 0);
|
||||
assert (result.c === 4);
|
||||
|
||||
// Changing properties to accessors
|
||||
|
||||
str = ' { "a":1, "b":2, "c":3 } ';
|
||||
log = "";
|
||||
JSON.parse (str, function (k, v) {
|
||||
if (k == "a")
|
||||
{
|
||||
Object.defineProperty(this, "b", {
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
get: function() { return 12; }
|
||||
});
|
||||
Object.defineProperty(this, "c", {
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
set: function(val) { }
|
||||
});
|
||||
}
|
||||
if (k != "")
|
||||
{
|
||||
log += "<" + k + ">:" + v + " ";
|
||||
}
|
||||
return v;
|
||||
});
|
||||
assert (log === "<a>:1 <b>:12 <c>:undefined ");
|
||||
|
||||
// Forcing extra walk steps
|
||||
|
||||
str = ' { "a":1, "b":2 } ';
|
||||
log = "";
|
||||
JSON.parse (str, function (k, v) {
|
||||
if (k == "a")
|
||||
{
|
||||
this.b = { x:3, y:4 };
|
||||
}
|
||||
if (k != "")
|
||||
{
|
||||
log += "<" + k + ">:" + v + " ";
|
||||
}
|
||||
return v;
|
||||
});
|
||||
assert (log === "<a>:1 <x>:3 <y>:4 <b>:[object Object] ");
|
||||
|
||||
// Setting a property to read-only, and change its value.
|
||||
|
||||
str = ' { "a":1, "b":2 } ';
|
||||
result = JSON.parse (str, function (k, v) {
|
||||
if (k == "a")
|
||||
{
|
||||
Object.defineProperty(this, "b", {
|
||||
enumerable: true,
|
||||
// FIXME: Should work with configurable: true.
|
||||
configurable: false,
|
||||
writable: false,
|
||||
value: 2
|
||||
});
|
||||
return 8;
|
||||
}
|
||||
if (k == "b")
|
||||
{
|
||||
return 9;
|
||||
}
|
||||
return v;
|
||||
});
|
||||
|
||||
assert (result.a === 8);
|
||||
assert (result.b === 2);
|
||||
|
||||
// Throw error in the reviver
|
||||
|
||||
try {
|
||||
str = ' { "a":1, "b":2 } ';
|
||||
result = JSON.parse (str, function (k, v) { throw new ReferenceError("error"); } );
|
||||
assert(false);
|
||||
} catch (e) {
|
||||
assert (e.message === "error");
|
||||
assert (e instanceof ReferenceError);
|
||||
}
|
||||
|
||||
// Throw error in a getter
|
||||
|
||||
try {
|
||||
str = ' { "a":1, "b":2 } ';
|
||||
JSON.parse (str, function (k, v) {
|
||||
if (k == "a")
|
||||
{
|
||||
Object.defineProperty(this, "b", {
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
get: function() { throw new ReferenceError("error"); }
|
||||
});
|
||||
}
|
||||
return v;
|
||||
});
|
||||
assert(false);
|
||||
} catch (e) {
|
||||
assert (e.message === "error");
|
||||
assert (e instanceof ReferenceError);
|
||||
}
|
||||
|
||||
// Checking reviver with different primitive types
|
||||
|
||||
str = ' { "a":1 } ';
|
||||
|
||||
result = JSON.parse (str, 4);
|
||||
assert (result.a == 1);
|
||||
|
||||
result = JSON.parse (str, null);
|
||||
assert (result.a == 1);
|
||||
|
||||
result = JSON.parse (str, undefined);
|
||||
assert (result.a == 1);
|
||||
|
||||
result = JSON.parse (str, true);
|
||||
assert (result.a == 1);
|
||||
|
||||
result = JSON.parse (str, "foo");
|
||||
assert (result.a == 1);
|
||||
|
||||
// Checking reviver with different object types
|
||||
|
||||
str = ' { "a":1 } ';
|
||||
|
||||
result = JSON.parse(str, new Boolean (true));
|
||||
assert (result.a == 1);
|
||||
|
||||
result = JSON.parse(str, new String ("foo"));
|
||||
assert (result.a == 1);
|
||||
|
||||
result = JSON.parse(str, new Number (3));
|
||||
assert (result.a == 1);
|
||||
|
||||
result = JSON.parse(str, {"a": 2});
|
||||
assert (result.a == 1);
|
||||
|
||||
result = JSON.parse(str, [1, 2, 3]);
|
||||
assert (result.a == 1);
|
||||
@@ -0,0 +1,186 @@
|
||||
// Copyright 2015 Samsung Electronics Co., Ltd.
|
||||
// Copyright 2015 University of Szeged.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// Checking quoting strings
|
||||
normal_string = "asdasd";
|
||||
assert (JSON.stringify (normal_string) == '"asdasd"');
|
||||
|
||||
format_characters = "\ba\fs\nd\ra\tsd";
|
||||
assert (JSON.stringify (format_characters) == '"\\ba\\fs\\nd\\ra\\tsd"');
|
||||
|
||||
ctl_string = "asd asd";
|
||||
assert (JSON.stringify (ctl_string) == '"asd\\u001fasd"');
|
||||
|
||||
escpad_string = "\"asda\sd";
|
||||
assert (JSON.stringify (escpad_string) == '"\\"asdasd"');
|
||||
|
||||
// Checking primitive types
|
||||
assert (JSON.stringify (1) === '1');
|
||||
assert (JSON.stringify (true) === 'true');
|
||||
assert (JSON.stringify ("foo") === '"foo"');
|
||||
assert (JSON.stringify (null) === 'null');
|
||||
assert (JSON.stringify (undefined) === undefined);
|
||||
|
||||
assert (JSON.stringify (new Number(1)) === '1');
|
||||
assert (JSON.stringify (new Boolean(true)) === 'true');
|
||||
assert (JSON.stringify (new String("foo")) === '"foo"');
|
||||
|
||||
// Checking objects
|
||||
empty_object = {}
|
||||
assert (JSON.stringify (empty_object) == '{}');
|
||||
|
||||
empty_object = {};
|
||||
empty_object.a = undefined;
|
||||
|
||||
assert (JSON.stringify (empty_object) == '{}');
|
||||
|
||||
p_object = { "a": 1, "b": true, "c": "foo", "d": null, "e": undefined };
|
||||
assert (JSON.stringify (p_object) == '{"d":null,"c":"foo","b":true,"a":1}');
|
||||
|
||||
o_object = { "a": new Number(1), "b": new Boolean(true), "c": new String("foo") };
|
||||
assert (JSON.stringify (o_object) == '{"c":"foo","b":true,"a":1}');
|
||||
|
||||
child = { "a": 1, "b": new String("\nfoo"), "c": undefined };
|
||||
parent = { "a": true, "b": child, "c": null};
|
||||
|
||||
assert (JSON.stringify (parent) == '{"c":null,"b":{"b":"\\nfoo","a":1},"a":true}');
|
||||
|
||||
recursive_object = {};
|
||||
recursive_object.a = 2;
|
||||
recursive_object.b = recursive_object;
|
||||
|
||||
try {
|
||||
JSON.stringify (recursive_object)
|
||||
// Should not be reached.
|
||||
assert (false);
|
||||
} catch (e) {
|
||||
assert (e instanceof TypeError);
|
||||
}
|
||||
|
||||
// Checking arrays
|
||||
empty_array = [];
|
||||
assert (JSON.stringify (empty_array) == '[]');
|
||||
|
||||
array = [undefined];
|
||||
assert (JSON.stringify (array) == '[null]');
|
||||
|
||||
p_array = [1, true, "foo", null, undefined];
|
||||
assert (JSON.stringify (p_array) == '[1,true,"foo",null,null]');
|
||||
|
||||
o_array = [new Number(1), new Boolean(true), new String("foo")];
|
||||
assert (JSON.stringify (o_array) == '[1,true,"foo"]');
|
||||
|
||||
child = [ 1, new String("\nfoo"), undefined ];
|
||||
parent = [ true, child, null ];
|
||||
|
||||
assert (JSON.stringify (parent) == '[true,[1,"\\nfoo",null],null]');
|
||||
|
||||
recursive_array = [];
|
||||
recursive_array[0] = 2;
|
||||
recursive_array[1] = recursive_array;
|
||||
|
||||
try {
|
||||
JSON.stringify (recursive_array)
|
||||
// Should not be reached.
|
||||
assert (false);
|
||||
} catch (e) {
|
||||
assert (e instanceof TypeError);
|
||||
}
|
||||
|
||||
object = {"a": 1, "b": [1, true, {"a": "foo"}]};
|
||||
assert (JSON.stringify (object) == '{"b":[1,true,{"a":"foo"}],"a":1}');
|
||||
|
||||
array = [1, {"a": 2, "b": true, c: [3]}];
|
||||
assert (JSON.stringify (array) == '[1,{"c":[3],"b":true,"a":2}]');
|
||||
|
||||
// Filtering / replacing
|
||||
to_json_object = {};
|
||||
to_json_object.a = 2;
|
||||
to_json_object.toJSON = function (key) { return 3; };
|
||||
|
||||
assert (JSON.stringify (to_json_object) === "3");
|
||||
|
||||
function replacer_function (key, value)
|
||||
{
|
||||
if (typeof(value) == "string")
|
||||
return "FOO";
|
||||
return value;
|
||||
}
|
||||
|
||||
object = { "a": "JSON", "b": new String("JSON"), "c": 3 };
|
||||
assert (JSON.stringify (object, replacer_function) == '{"c":3,"b":"JSON","a":"FOO"}');
|
||||
|
||||
filter = ["a", "b"];
|
||||
assert (JSON.stringify (object, filter) == '{"a":"JSON","b":"JSON"}');
|
||||
|
||||
// Throw error in the replacer function
|
||||
function replacer_thrower (key, value)
|
||||
{
|
||||
throw new ReferenceError("foo");
|
||||
return value;
|
||||
}
|
||||
|
||||
try {
|
||||
JSON.stringify (object, replacer_thrower)
|
||||
// Should not be reached.
|
||||
assert (false);
|
||||
} catch (e) {
|
||||
assert (e.message === "foo");
|
||||
assert (e instanceof ReferenceError);
|
||||
}
|
||||
|
||||
// Checking replacer with different primitive types
|
||||
object = { "a": 2 };
|
||||
assert (JSON.stringify (object, 3) == '{"a":2}');
|
||||
assert (JSON.stringify (object, true) == '{"a":2}');
|
||||
assert (JSON.stringify (object, null) == '{"a":2}');
|
||||
assert (JSON.stringify (object, undefined) == '{"a":2}');
|
||||
assert (JSON.stringify (object, "foo") == '{"a":2}');
|
||||
|
||||
// Checking replacer with different primitive types
|
||||
assert (JSON.stringify (object, new Boolean (true)) == '{"a":2}');
|
||||
assert (JSON.stringify (object, new Number (3)) == '{"a":2}');
|
||||
assert (JSON.stringify (object, new String ("foo")) == '{"a":2}');
|
||||
assert (JSON.stringify (object, { "a": 3 }) == '{"a":2}');
|
||||
|
||||
// Checking JSON formatting
|
||||
object = {"a": 2};
|
||||
assert (JSON.stringify (object, null, " ") == '{\n "a": 2\n}');
|
||||
assert (JSON.stringify (object, null, "asd") == '{\nasd"a": 2\n}');
|
||||
assert (JSON.stringify (object, null, "asd0123456789") == '{\nasd0123456"a": 2\n}');
|
||||
assert (JSON.stringify (object, null, 100) == '{\n "a": 2\n}');
|
||||
|
||||
array = [2];
|
||||
assert (JSON.stringify (array, null, " ") == '[\n 2\n]');
|
||||
assert (JSON.stringify (array, null, "asd") == '[\nasd2\n]');
|
||||
assert (JSON.stringify (array, null, "asd0123456789") == '[\nasd01234562\n]');
|
||||
assert (JSON.stringify (array, null, 100) == '[\n 2\n]');
|
||||
|
||||
nested_object = {"a": 2, "b": {"c": 1, "d": true}};
|
||||
assert (JSON.stringify (nested_object, null, 2) == '{\n "b": {\n "d": true,\n "c": 1\n },\n "a": 2\n}');
|
||||
|
||||
nested_array = [2, [1,true]];
|
||||
assert (JSON.stringify (nested_array, null, 2) == '[\n 2,\n [\n 1,\n true\n ]\n]');
|
||||
|
||||
// Checking space (formatting parameter) with different primititve types
|
||||
object = { "a": 2 };
|
||||
assert (JSON.stringify (object, null, true) == '{"a":2}');
|
||||
assert (JSON.stringify (object, null, null) == '{"a":2}');
|
||||
assert (JSON.stringify (object, null, undefined) == '{"a":2}');
|
||||
|
||||
// Checking space (formatting parameter) with different object types
|
||||
assert (JSON.stringify (object, null, new Boolean (true)) == '{"a":2}');
|
||||
assert (JSON.stringify (object, null, [1, 2, 3] ) == '{"a":2}');
|
||||
assert (JSON.stringify (object, null, { "a": 3 }) == '{"a":2}');
|
||||
Reference in New Issue
Block a user