Replicating CL https://chromiumcodereview.appspot.com/11553012/

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 '../../unittest/lib/unittest.dart';
 import '../lib/serialization.dart';
 import '../lib/src/serialization_helpers.dart';
 import '../lib/src/mirrors_helpers.dart';
@@ skipping 202 matching lines @@
     var list = w.states[1].first;
     expect(w.stateForReference(rootNode[children]), list);
     var parentNode = w.stateForReference(list[0])[parent];
     expect(w.stateForReference(parentNode), rootNode);
   });
 
   test('round-trip', () {
     runRoundTripTest(nodeSerializerReflective);
   });
 
-  test('round-trip hard-coded', () {
+  test('round-trip ClosureRule', () {
     runRoundTripTest(nodeSerializerNonReflective);
   });
 
   test('round-trip with essential parent', () {
     runRoundTripTest(nodeSerializerWithEssentialParent);
   });
 
   test('round-trip, flat format', () {
     runRoundTripTestFlat(nodeSerializerReflective);
   });
 
   test('round-trip using Maps', () {
     runRoundTripTest(nodeSerializerUsingMaps);
   });
 
+  test('round-trip with Node CustomRule', () {
+    runRoundTripTestFlat(nodeSerializerCustom);
+  });
+
+  test('round-trip with Node CustomRule, to maps', () {
+    runRoundTripTest(nodeSerializerCustom);
+  });
+
   test('eating your own tail', () {
     // Create a meta-serializer, that serializes serializations, then
     // use it to serialize a basic serialization, then run a test on the
     // the result.
     var s = new Serialization()
       ..addRuleFor(new Node(''), constructorFields: ['name'])
       ..selfDescribing = false;
     var meta = metaSerialization();
     var serialized = meta.write(s);
     var s2 = new Reader(meta)
-        .readOne(serialized, {"Node" : reflect(new Node('')).type});
+        .read(serialized, {"Node" : reflect(new Node('')).type});
     runRoundTripTest((x) => s2);
   });
 
   test("Verify we're not serializing lists twice if they're essential", () {
     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 = new Serialization()
       ..addRuleFor(n1, constructorFields: ["name"]).
@@ skipping 18 matching lines @@
          n2 = new NodeEqualByName("foo"),
          n3 = new NodeEqualByName("3");
     n1.children = [n2, n3];
     n2.parent = n1;
     n3.parent = n1;
     var s = new Serialization()
       ..selfDescribing = false
       ..addRuleFor(n1, constructorFields: ["name"]);
     var w = new Writer(s);
     var r = new Reader(s);
-    var m1 = r.read(w.write(n1)).first;
+    var m1 = r.read(w.write(n1));
     var m2 = m1.children.first;
     var m3 = m1.children.last;
     expect(m1, m2);
     expect(identical(m1, m2), isFalse);
     expect(m1 == m3, isFalse);
     expect(identical(m2.parent, m3.parent), isTrue);
   });
 
 }
 
 /******************************************************************************
  * The end of the tests and the beginning of various helper functions to make
  * it easier to write the repetitive sections.
  ******************************************************************************/
 
 /** Create a Serialization for serializing Serializations. */
 Serialization metaSerialization() {
   // Make some bogus rule instances so we have something to feed rule creation
   // and get their types. If only we had class literals implemented...
-  var closureRule = new ClosureToMapRule.stub([].runtimeType);
   var basicRule = new BasicRule(reflect(null).type, '', [], [], []);
 
   var meta = new Serialization()
     ..selfDescribing = false
     ..addRuleFor(new ListRule())
     ..addRuleFor(new PrimitiveRule())
-    // TODO(alanknight): Handle the ClosureToMapRule as well.
+    // TODO(alanknight): Handle CustomRule as well.
     // Note that we're passing in a constant for one of the fields.
     ..addRuleFor(basicRule,
         constructorFields: ['typeWrapped',
           'constructorName',
           'constructorFields', 'regularFields', []],
         fields: [])
      ..addRuleFor(new Serialization()).specialTreatmentFor('rules',
          (InstanceMirror s, List rules) {
              rules.forEach((x) => s.reflectee.addRule(x));
          })
-    ..addRule(new ClassMirrorRule());
+    ..addRule(new NamedObjectRule())
+    ..addRule(new MirrorRule());
   return meta;
 }
 
 /**
  * Read back a simple object, assumed to be the only one of its class in the
  * reader.
  */
 readBackSimple(Serialization s, object, Reader reader) {
-  var rule = s.rulesFor(object)[0];
+  var rule = s.rulesFor(object, null)[0];
   reader.inflateForRule(rule);
   var list2 = reader.allObjectsForRule(rule)[0];
   return list2;
 }
 
 /**
  * Set up a basic reader with some fake data. Hard-codes the assumption
  * of how many rules there are.
  */
 Reader setUpReader(aSerialization, sampleData) {
   var reader = new Reader(aSerialization);
   // We're not sure which rule needs the sample data, so put it everywhere
   // and trust that the extra will just be ignored.
   reader.data = [[sampleData], [sampleData], [sampleData], [sampleData]];
   return reader;
 }
 
 /** Return a serialization for Node objects, using a reflective rule. */
 Serialization nodeSerializerReflective(Node n) {
   return new Serialization()
     ..addRuleFor(n, constructorFields: ["name"])
-    ..externalObjects['Node'] = reflect(new Node('')).type;
+    ..namedObjects['Node'] = reflect(new Node('')).type;
 }
 
 /**
  * Return a serialization for Node objects but using Maps for the internal
  * representation rather than lists.
  */
 Serialization nodeSerializerUsingMaps(Node n) {
   return new Serialization()
     ..addRuleFor(n, constructorFields: ["name"]).configureForMaps()
-    ..externalObjects['Node'] = reflect(new Node('')).type;
+    ..namedObjects['Node'] = reflect(new Node('')).type;
 }
 
 /**
+ * Return a serialization for Node objects but using Maps for the internal
+ * representation rather than lists.
+ */
+Serialization nodeSerializerCustom(Node n) {
+  return new Serialization()
+    ..addRule(new NodeRule());
+}
+
+/**
  * Return a serialization for Node objects where the "parent" instance
  * variable is considered essential state.
  */
 Serialization nodeSerializerWithEssentialParent(Node n) {
   // Force the node rule to be first, in order to make a cycle which would
   // not cause a problem if we handled the list first, because the list
   // considers all of its state non-essential, thus breaking the cycle.
   var s = new Serialization.blank()
     ..addRuleFor(
         n,
         constructor: "parentEssential",
         constructorFields: ["parent"])
     ..addDefaultRules()
-    ..externalObjects['Node'] = reflect(new Node('')).type
+    ..namedObjects['Node'] = reflect(new Node('')).type
     ..selfDescribing = false;
   return s;
 }
 
 /** Return a serialization for Node objects using a ClosureToMapRule. */
 Serialization nodeSerializerNonReflective(Node n) {
-  var rule = new ClosureToMapRule(
+  var rule = new ClosureRule(
       n.runtimeType,
       (o) => {"name" : o.name, "children" : o.children, "parent" : o.parent},
       (map) => new Node(map["name"]),
-      (map, object) {
+      (object, map) {
         object
           ..children = map["children"]
           ..parent = map["parent"];
       });
   return new Serialization()
     ..selfDescribing = false
     ..addRule(rule);
 }
 
 /**
  * Run a round-trip test on a simple tree of nodes, using a serialization
  * that's returned by the [serializerSetup] function.
  */
 runRoundTripTest(Function 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);
   var s2 = serializerSetUp(n1);
   var reader = new Reader(s2);
-  var m2 = reader.readOne(output);
+  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);
   expect(m1.parent, isNull);
 }
 
 /**
  * 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.writeFlat(n2);
   expect(output is List, isTrue);
   var s2 = serializerSetUp(n1);
   var reader = new Reader(s2);
-  var m2 = reader.readFlat(output).first;
+  var m2 = reader.readFlat(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);
   expect(m1.parent, isNull);
 }
 
 /** Extract the state from [object] using the rules in [s] and return it. */
-states(Object object, Serialization s) {
-  var rules = s.rulesFor(object);
+states(object, Serialization s) {
+  var rules = s.rulesFor(object, null);
   return rules.map((x) => x.extractState(object, doNothing));
+}
+
+/** A hard-coded rule for serializing Node instances. */
+class NodeRule extends CustomRule {
+  bool appliesTo(instance, _) => instance is Node;
+  getState(instance) => [instance.parent, instance.name, instance.children];
+  create(state) => new Node(state[1]);
+  setState(Node node, state) {
+    node.parent = state[0];
+    node.children = state[2];
+  }
 }