Optimize VM JSON parser for memory use.

tests/lib/convert/json_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library json_test;
 
 import "package:expect/expect.dart";
 import "dart:convert";
 
 bool badFormat(e) => e is FormatException;
@@ skipping 248 matching lines @@
     testThrows('[$i"s"]');
     testThrows('["s"$i]');
     testThrows('$i{"k":"v"}');
     testThrows('{$i"k":"v"}');
     testThrows('{"k"$i:"v"}');
     testThrows('{"k":$i"v"}');
     testThrows('{"k":"v"$i}');
   }
 }
 
+void testOutput() {
+  var nonJsonValue = new Object();
+  // Test that results are integers or doubles as appropriate.
+  var res = JSON.decode("0");
+  Expect.equals(0, res);
+  Expect.isTrue(res is int);
+  res = JSON.decode("999999999");
+  Expect.equals(999999999, res);
+  Expect.isTrue(res is int);
+  res = JSON.decode("0.5");
+  Expect.equals(0.5, res);
+  Expect.isTrue(res is double);
+  res = JSON.decode("5e5");
+  Expect.equals(500000, res);
+  Expect.isTrue(res is double);
+
+  // Test that lists are extensible and untyped.
+  res = JSON.decode("[42]");
+  Expect.isTrue(res is List);
+  Expect.listEquals([42], res);
+  res.add(37);
+  Expect.listEquals([42, 37], res);
+  res.add(nonJsonValue);
+  Expect.listEquals([42, 37, nonJsonValue], res);
+  // List handles concurrent modification correctly.
+  res = JSON.decode("[1, 2, 3]");
+  res.forEach((v) { res[0] = 42; });  // Not a modification, does not throw.
+  Expect.throws(() { res.forEach((v) { res.add(37); }); },
+                (e) => e is ConcurrentModificationError);
+
+  // Test that maps are untyped, modifiable and ordered.
+  res = JSON.decode('{"x": 42}');
+  Expect.isTrue(res is Map);
+  Expect.equals(1, res.length);
+  Expect.equals(42, res["x"]);
+  res["y"] = nonJsonValue;
+  Expect.equals(2, res.length);
+  Expect.equals(nonJsonValue, res["y"]);
+  // TODO(lrn): Can we avoid this? It would be great for optimizations
+  // if maps must be string keyed.
+  res[nonJsonValue] = 37;
+  Expect.equals(3, res.length);
+  Expect.equals(37, res[nonJsonValue]);
+  // Concurrent modifications.
+  res = JSON.decode('{"x": 42, "y": 37}');
+  res.forEach((k, v) { res["x"] = 99; });  // Not a modification, doesn't throw.
+
+  res = JSON.decode('{"x": 42, "y": 37}');
+  Expect.throws(() { res.forEach((k, v) { res["z"] = 12; }); },
+                (e) => e is ConcurrentModificationError);
+  res = JSON.decode('{"x": 42, "y": 37}');
+  Expect.throws(() { res.keys.forEach((k) { res["z"] = 12; }); },
+                (e) => e is ConcurrentModificationError);
+
+  res = JSON.decode('{"x": 42, "y": 37}');
+  res.forEach((k, v) { res.remove("z"); });
+
+  res = JSON.decode('{"x": 42, "y": 37}');
+  Expect.throws(() { res.forEach((k, v) { res.remove("x"); }); },
+                (e) => e is ConcurrentModificationError);
+  res = JSON.decode('{"x": 42, "y": 37}');
+  Expect.throws(() { res.keys.forEach((k) { res.remove("x"); }); },
+                (e) => e is ConcurrentModificationError);
+
+  res = JSON.decode('{"x": 42, "y": 37}');
+  Expect.throws(() { res.forEach((k, v) { res.clear(); }); },
+                (e) => e is ConcurrentModificationError);
+
+  res = JSON.decode('{"x": 42, "y": 37}');
+  Expect.throws(() { res.keys.forEach((k) { res.clear(); }); },
+                (e) => e is ConcurrentModificationError);
+
+  res = JSON.decode('{"x": 42, "y": 37}');
+  Expect.throws(() { res.forEach((k, v) { res.putIfAbsent("z", () => 99); }); },
+                (e) => e is ConcurrentModificationError);
+
+  res = JSON.decode('{"x": 42, "y": 37}');
+  Expect.throws(() {
+                  res.keys.forEach((k) { res.putIfAbsent("z", () => 99); });
+                },
+                (e) => e is ConcurrentModificationError);
+}
+
+
 main() {
   testNumbers();
   testStrings();
   testWords();
   testObjects();
   testArrays();
   testWhitespace();
+  testOutput();
 }