pkg/serialization: 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';
 import 'dart:isolate';
 
 part 'test_models.dart';
 
-main() {
+void main() {

[Alan Knight, 2013/06/21 22:47:46]

You really like those type signatures, don't you :-)

I'm skeptical that these are providing a lot of value, but I don't think it
hurts, so fine.

[kevmoo-old, 2013/06/21 22:57:32]

Mostly about readability. Being explicit about what a method returns (even if
it's nothing) I find really nice.

[Alan Knight, 2013/06/21 23:15:20]

I, on the other hand, find that it adds noise and makes it less readable. But
it's not a big deal either way.

   var p1 = new Person();
   var a1 = new Address();
   a1.street = 'N 34th';
   a1.city = 'Seattle';
 
   var formats = [const InternalMapFormat(),
                  const SimpleFlatFormat(), const SimpleMapFormat(),
                  const SimpleJsonFormat(storeRoundTripInfo: true)];
 
   test('Basic extraction of a simple object', () {
@@ skipping 520 matching lines @@
   });
 
   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)));
+      return port.call(output).then(verify);

[Alan Knight, 2013/06/21 22:47:46]

Does that actually work? Don't you need some level of expectAsync in there
somewhere to make sure that verify is called before the test framework considers
everything done?

[kevmoo-old, 2013/06/21 22:57:32]

If a test returns a future, then the test system waits for the future to
complete (or error out).

Passing verify in to evaluate the result ends up super clean.

[Alan Knight, 2013/06/21 23:15:20]

OK, I'll take your word for it.

   });
 }
 
 /**
  * Verify serialized output that we have passed to an isolate and back.
  */
-verify(input) {
+void 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");
@@ skipping 136 matching lines @@
       });
   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) {
+void 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.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) {
+void 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, const SimpleFlatFormat());
   expect(output is List, isTrue);
   var s2 = serializerSetUp(n1);
   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);
   expect(m1.parent, isNull);
 }
 
 /** Extract the state from [object] using the rules in [s] and return it. */
-states(object, Serialization s) {
+List states(object, Serialization s) {
   var rules = s.rulesFor(object, null);
   return rules.map((x) => x.extractState(object, doNothing, null)).toList();
 }
 
 /** A hard-coded rule for serializing Node instances. */
 class NodeRule extends CustomRule {
   bool appliesTo(instance, _) => instance.runtimeType == Node;
   getState(instance) => [instance.parent, instance.name, instance.children];
   create(state) => new Node(state[1]);
   void setState(Node node, state) {
@@ skipping 27 matching lines @@
       if (value == key) return each;
     }
     return null;
   }
 }
 
 /**
  * Function used in an isolate to make sure that the output passes through
  * isolate serialization properly.
  */
-echo() {
+void echo() {
   port.receive((msg, reply) {
     reply.send(msg);
   });
 }