Change default format to produce output that can be passed between isolates

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';
+import 'dart:isolate';
 
 part 'test_models.dart';
 
 main() {
   var p1 = new Person();
   var a1 = new Address();
   a1.street = 'N 34th';
   a1.city = 'Seattle';
 
-  var formats = [const SimpleFlatFormat(), const SimpleMapFormat(),
+  var formats = [const InternalMapFormat(),
+                 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);
     expect(extracted['zip'], null);
     Reader reader = setUpReader(s, extracted);
     Address a2 = readBackSimple(s, a1, reader);
     expect(a2.street, 'N 34th');
     expect(a2.city, 'Seattle');
     expect(a2.state,null);
     expect(a2.zip, null);
   });
 
   test('Slightly further with a simple object', () {
     var p1 = new Person()..name = 'Alice'..address = a1;
     var s = new Serialization()
         ..addRuleFor(p1).configureForMaps()
         ..addRuleFor(a1).configureForMaps();
     // TODO(alanknight): Need a better API for getting to flat state without
     // actually writing.
-    var w = new Writer(s);
+    var w = new Writer(s, const InternalMapFormat());
     w.write(p1);
     var personRule = s.rules.firstWhere(
         (x) => x is BasicRule && x.type == reflect(p1).type);
     var flatPerson = w.states[personRule.number].first;
     var primStates = w.states.first;
     expect(primStates.isEmpty, true);
     expect(flatPerson["name"], "Alice");
     var ref = flatPerson["address"];
     expect(ref is Reference, true);
     var addressRule = s.rules.firstWhere(
@@ skipping 148 matching lines @@
     var all = trace.writer.references.keys.toSet();
     expect(all.length, 4);
     expect(all.contains(n1), isTrue);
     expect(all.contains(n2), isTrue);
     expect(all.contains(n3), isTrue);
     expect(all.contains(n1.children), isTrue);
   });
 
   test('Flatten references in a cyclical structure', () {
     var s = new Serialization();
-    var w = new Writer(s);
+    var w = new Writer(s, const InternalMapFormat());
     w.trace = new Trace(w);
     w.write(n1);
     expect(w.states.length, 6); // prims, lists, essential lists, basic, symbol
     var children = 0, name = 1, parent = 2;
     var nodeRule = s.rules.firstWhere((x) => x is BasicRule);
     List rootNode = w.states[nodeRule.number].where(
         (x) => x[name] == "1").toList();
     rootNode = rootNode.first;
     expect(rootNode[parent], isNull);
     var list = w.states[1].first;
@@ skipping 291 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, const SimpleMapFormat());
+    var output = s.write(data, const InternalMapFormat());
     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);
+    expect(map["person"] is Reference, isTrue);
   });
 
   test("MirrorRule with lookup by qualified name rather than named object", () {
     var s = new Serialization()..addRule(new MirrorRule());
     var m = reflectClass(Address);
     var output = s.write(m);
     var input = s.read(output);
     expect(input is ClassMirror, isTrue);
     expect(MirrorSystem.getName(input.simpleName), "Address");
   });
 
+  test('round-trip, default format, pass to isolate', () {
+      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 = nodeSerializerReflective(n1);
+      var output = s.write(n2);
+      var port = spawnFunction(echo);
+      port.call(output).then(expectAsync1((input) => verify(input)));
+  });
+}
+
+/**
+ * Verify serialized output that we have passed to an isolate and back.
+ */
+verify(input) {
+  var s2 = nodeSerializerReflective(new Node("a"));
+  var reader = new Reader(s2);
+  var m2 = reader.read(input);
+  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);
+  expect(m1.parent, isNull);
 }
 
 /******************************************************************************
  * The end of the tests and the beginning of various helper functions to make
  * it easier to write the repetitive sections.
  ******************************************************************************/
 
 writeAndReadBack(Serialization s, Format format, object) {
   var w = s.newWriter(format);
   var output = w.write(object);
@@ skipping 216 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;
   }
 }
+
+/**
+ * Function used in an isolate to make sure that the output passes through
+ * isolate serialization properly.
+ */
+echo() {
+  port.receive((msg, reply) {
+    reply.send(msg);
+  });
+}