pkg/serialization types cleanup

pkg/serialization/test/serialization_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 serialization_test;
 
 import 'dart:json' as json;
 import 'package:unittest/unittest.dart';
 import 'package:serialization/serialization.dart';
 import 'package:serialization/src/serialization_helpers.dart';
 import 'package:serialization/src/mirrors_helpers.dart';
 
 part 'test_models.dart';
 
 main() {
   var p1 = new Person();
   var a1 = new Address();
   a1.street = 'N 34th';
   a1.city = 'Seattle';
 
-  var formats = [new SimpleFlatFormat(), new SimpleMapFormat(),
-                 new SimpleJsonFormat(storeRoundTripInfo: true)];
+  var formats = [const SimpleFlatFormat(), const SimpleMapFormat(),
+                 const SimpleJsonFormat(storeRoundTripInfo: true)];
 
   test('Basic extraction of a simple object', () {
     // TODO(alanknight): Switch these to use literal types. Issue
     var s = new Serialization()
         ..addRuleFor(a1).configureForMaps();
     Map extracted = states(a1, s).first;
     expect(extracted.length, 4);
     expect(extracted['street'], 'N 34th');
     expect(extracted['city'], 'Seattle');
     expect(extracted['state'], null);
@@ skipping 307 matching lines @@
     var out = s.write(a1);
     var newAddress = s.read(out);
     expect(newAddress.street, a1.street);
     expect(newAddress.city, "Kirkland");
     expect(newAddress.state, "WA");
     expect(newAddress.zip, "98103");
   });
 
   test("Straight JSON format", () {
     var s = new Serialization();
-    var writer = s.newWriter(new SimpleJsonFormat());
+    var writer = s.newWriter(const SimpleJsonFormat());
     var out = json.stringify(writer.write(a1));
     var reconstituted = json.parse(out);
     expect(reconstituted.length, 4);
     expect(reconstituted[0], "Seattle");
   });
 
   test("Straight JSON format, nested objects", () {
     var p1 = new Person()..name = 'Alice'..address = a1;
     var s = new Serialization()..selfDescribing = false;
     var addressRule = s.addRuleFor(a1)..configureForMaps();
     var personRule = s.addRuleFor(p1)..configureForMaps();
-    var writer = s.newWriter(new SimpleJsonFormat(storeRoundTripInfo: true));
+    var writer = s.newWriter(const SimpleJsonFormat(storeRoundTripInfo: true));
     var out = json.stringify(writer.write(p1));
     var reconstituted = json.parse(out);
     var expected = {
       "name" : "Alice",
       "rank" : null,
       "serialNumber" : null,
       "_rule" : personRule.number,
       "address" : {
         "street" : "N 34th",
         "city" : "Seattle",
         "state" : null,
         "zip" : null,
         "_rule" : addressRule.number
       }
     };
     expect(expected, reconstituted);
   });
 
   test("Straight JSON format, round-trip", () {
     // Note that we can't use the usual round-trip test because it has cycles.
     var p1 = new Person()..name = 'Alice'..address = a1;
     // Use maps for one rule, lists for the other.
     var s = new Serialization()
       ..addRuleFor(a1)
       ..addRuleFor(p1).configureForMaps();
     var p2 = writeAndReadBack(s,
-        new SimpleJsonFormat(storeRoundTripInfo: true), p1);
+        const SimpleJsonFormat(storeRoundTripInfo: true), p1);
     expect(p2.name, "Alice");
     var a2 = p2.address;
     expect(a2.street, "N 34th");
     expect(a2.city, "Seattle");
   });
 
   test("Straight JSON format, non-string key", () {
     // This tests what happens if we have a key that's not a string. That's
     // not allowed by json, so we don't actually turn it into a json string,
     // but someone might reasonably convert to a json-able structure without
     // going through the string representation.
     var p1 = new Person()..name = 'Alice'..address = a1;
     var s = new Serialization()
         ..addRule(new PersonRuleReturningMapWithNonStringKey());
     var p2 = writeAndReadBack(s,
-        new SimpleJsonFormat(storeRoundTripInfo: true), p1);
+        const SimpleJsonFormat(storeRoundTripInfo: true), p1);
     expect(p2.name, "Alice");
     expect(p2.address.street, "N 34th");
   });
 
   test("Root is a Map", () {
     // Note that we can't use the usual round-trip test because it has cycles.
     var p1 = new Person()..name = 'Alice'..address = a1;
     // Use maps for one rule, lists for the other.
     var s = new Serialization()
       ..addRuleFor(a1)
@@ skipping 39 matching lines @@
   test("Simple JSON format, round-trip with named objects", () {
     // Note that we can't use the usual round-trip test because it has cycles.
     var p1 = new Person()..name = 'Alice'..address = a1;
     // Use maps for one rule, lists for the other.
     var s = new Serialization()
       ..selfDescribing = false
       ..addRule(new NamedObjectRule())
       ..addRuleFor(a1)
       ..addRuleFor(p1).configureForMaps()
       ..namedObjects["foo"] = a1;
-    var writer = s.newWriter(new SimpleJsonFormat(storeRoundTripInfo: true));
+    var writer = s.newWriter(const SimpleJsonFormat(storeRoundTripInfo: true));
     var out = writer.write(p1);
-    var reader = s.newReader(new SimpleJsonFormat(storeRoundTripInfo: true));
+    var reader = s.newReader(const SimpleJsonFormat(storeRoundTripInfo: true));
     var p2 = reader.read(out, {"foo" : 12});
     expect(p2.name, "Alice");
     var a2 = p2.address;
     expect(a2, 12);
   });
 
   test("More complicated Maps", () {
     var s = new Serialization()..selfDescribing = false;
     var p1 = new Person()..name = 'Alice'..address = a1;
     var data = new Map();
@@ skipping 23 matching lines @@
         expect(input[p2], same(a2));
         expect(input[a2], same(p2));
       }
     }
   });
 
   test("Map with string keys stays that way", () {
     var s = new Serialization()..addRuleFor(new Person());
     var data = {"abc" : 1, "def" : "ghi"};
     data["person"] = new Person()..name = "Foo";
-    var output = s.write(data, new SimpleMapFormat());
+    var output = s.write(data, const SimpleMapFormat());
     var mapRule = s.rules.firstWhere((x) => x is MapRule);
     var map = output["data"][mapRule.number][0];
     expect(map is Map, isTrue);
     expect(map["abc"], 1);
     expect(map["def"], "ghi");
     expect(new Reader(s).asReference(map["person"]) is Reference, isTrue);
   });
 
   test("MirrorRule with lookup by qualified name rather than named object", () {
     var s = new Serialization()..addRule(new MirrorRule());
@@ skipping 172 matching lines @@
 /**
  * Run a round-trip test on a simple of nodes, but using the flat format
  * rather than the maps.
  */
 runRoundTripTestFlat(serializerSetUp) {
   Node n1 = new Node("1"), n2 = new Node("2"), n3 = new Node("3");
   n1.children = [n2, n3];
   n2.parent = n1;
   n3.parent = n1;
   var s = serializerSetUp(n1);
-  var output = s.write(n2, new SimpleFlatFormat());
+  var output = s.write(n2, const SimpleFlatFormat());
   expect(output is List, isTrue);
   var s2 = serializerSetUp(n1);
-  var reader = new Reader(s2, new SimpleFlatFormat());
+  var reader = new Reader(s2, const SimpleFlatFormat());
   var m2 = reader.read(output);
   var m1 = m2.parent;
   expect(m1 is Node, isTrue);
   var children = m1.children;
   expect(m1.name,"1");
   var m3 = m1.children.last;
   expect(m2.name, "2");
   expect(m3.name, "3");
   expect(m2.parent, m1);
   expect(m3.parent, m1);
@@ skipping 37 matching lines @@
   }
   findValue(String key, Map state) {
     var answer;
     for (var each in state.keys) {
       var value = state[each];
       if (value == key) return each;
     }
     return null;
   }
 }