Rename specialTreatmentFor, improve handling of constants as constructor parameters.

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 247 matching lines @@
     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"]).
-          specialTreatmentFor("children", (parent, child) =>
+          setFieldWith("children", (parent, child) =>
               parent.reflectee.children = child);
     var w = new Writer(s);
     w.write(n1);
     expect(w.rules[2] is ListRuleEssential, isTrue);
     expect(w.rules[1] is ListRule, isTrue);
     expect(w.states[1].length, 0);
     expect(w.states[2].length, 1);
     s = new Serialization()
       ..addRuleFor(n1, constructorFields: ["name"]);
     w = new Writer(s);
@@ skipping 16 matching lines @@
     var r = new Reader(s);
     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);
   });
 
+  test("Constant values as fields", () {
+    var s = new Serialization()
+      ..selfDescribing = false
+      ..addRuleFor(a1,
+          constructor: 'with',
+          constructorFields: ["street", "Kirkland", "WA", "98103"],
+          fields: []);
+    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");
+  });
+
 }
 
 /******************************************************************************
  * 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 basicRule = new BasicRule(reflect(null).type, '', [], [], []);
 
   var meta = new Serialization()
     ..selfDescribing = false
     ..addRuleFor(new ListRule())
     ..addRuleFor(new PrimitiveRule())
     // TODO(alanknight): Handle CustomRule as well.
     // Note that we're passing in a constant for one of the fields.
     ..addRuleFor(basicRule,
         constructorFields: ['type',
           'constructorName',
           'constructorFields', 'regularFields', []],
         fields: [])
-     ..addRuleFor(new Serialization()).specialTreatmentFor('rules',
+     ..addRuleFor(new Serialization()).setFieldWith('rules',
          (InstanceMirror s, List rules) {
              rules.forEach((x) => s.reflectee.addRule(x));
          })
     ..addRule(new NamedObjectRule())
     ..addRule(new MirrorRule());
   return meta;
 }
 
 /**
  * Read back a simple object, assumed to be the only one of its class in the
@@ skipping 141 matching lines @@
 /** 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];
   }
 }