Revert "Fix observatory tests broken by running dartfmt."

runtime/vm/snapshot_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.
 
 import 'dart:isolate';
 import 'dart:async';
 
 class Expect {
   static void equals(x, y) {
     if (x != y) throw new ArgumentError('not equal');
   }
 }
 
 class Fields {
-  Fields(int i, int j)
-      : fld1 = i,
-        fld2 = j,
-        fld5 = true {}
+  Fields(int i, int j) : fld1 = i, fld2 = j, fld5 = true {}
   int fld1;
   final int fld2;
   static int fld3;
   static const int fld4 = 10;
   bool fld5;
 }
-
 class FieldsTest {
   static Fields testMain() {
     Fields obj = new Fields(10, 20);
     Expect.equals(10, obj.fld1);
     Expect.equals(20, obj.fld2);
     Expect.equals(10, Fields.fld4);
     Expect.equals(true, obj.fld5);
     return obj;
   }
 }
@@ skipping 51 matching lines @@
   const LoopBenchmark() : super("Loop");
 
   void warmup() {
     Loop.loop(10);
   }
 
   void exercise() {
     // This value has been copied from benchpress.js, so that we can compare
     // performance.
     var result = Loop.loop(200);
-    if (result != 20000) Error.error("Wrong result: $result. Should be: 20000");
+    if (result != 20000)
+      Error.error("Wrong result: $result. Should be: 20000");
   }
 
   static void main() {
     new LoopBenchmark().report();
   }
 }
 
 // T o w e r s
 class TowersDisk {
   final int size;
   TowersDisk next;
 
-  TowersDisk(size)
-      : this.size = size,
-        next = null {}
+  TowersDisk(size) : this.size = size, next = null {}
 }
 
 class Towers {
   List<TowersDisk> piles;
   int movesDone;
   Towers(int disks)
-      : piles = new List<TowersDisk>(3),
-        movesDone = 0 {
+      : piles = new List<TowersDisk>(3), movesDone = 0 {
     build(0, disks);
   }
 
   void build(int pile, int disks) {
     for (var i = disks - 1; i >= 0; i--) {
       push(pile, new TowersDisk(i));
     }
   }
 
   void push(int pile, TowersDisk disk) {
@@ skipping 57 matching lines @@
 class SieveBenchmark extends BenchmarkBase {
   const SieveBenchmark() : super("Sieve");
 
   static int sieve(int size) {
     int primeCount = 0;
     List<bool> flags = new List<bool>(size + 1);
     for (int i = 1; i < size; i++) flags[i] = true;
     for (int i = 2; i < size; i++) {
       if (flags[i]) {
         primeCount++;
-        for (int k = i + 1; k <= size; k += i) flags[k - 1] = false;
+        for (int k = i + 1; k <= size; k += i)
+          flags[k - 1] = false;
       }
     }
     return primeCount;
   }
 
+
   void warmup() {
     sieve(100);
   }
 
   void exercise() {
     // This value has been copied from benchpress.js, so that we can compare
     // performance.
     int result = sieve(1000);
-    if (result != 168) Error.error("Wrong result: $result should be: 168");
+    if (result != 168)
+      Error.error("Wrong result: $result should be: 168");
   }
 
   static void main() {
     new SieveBenchmark().report();
   }
 }
 
 // P e r m u t e
 // The original benchmark uses one-based indexing. Even though arrays in JS and
 // lists in dart are zero-based, we stay with one-based indexing
@@ skipping 33 matching lines @@
   const PermuteBenchmark() : super("Permute");
 
   void warmup() {
     new Permute().permute(4);
   }
 
   void exercise() {
     // This value has been copied from benchpress.js, so that we can compare
     // performance.
     int result = new Permute().permute(8);
-    if (result != 8660) Error.error("Wrong result: $result should be: 8660");
+    if (result != 8660)
+      Error.error("Wrong result: $result should be: 8660");
   }
 
   static void main() {
     new PermuteBenchmark().report();
   }
 }
 
 // Q u e e n s
 // The original benchmark uses one-based indexing. Even though arrays in JS and
 // lists in dart are zero-based, we stay with one-based indexing
 // (wasting one element).
 class Queens {
-  static bool tryQueens(
-      int i, List<bool> a, List<bool> b, List<bool> c, List<int> x) {
+  static bool tryQueens(int i,
+                        List<bool> a,
+                        List<bool> b,
+                        List<bool> c,
+                        List<int> x) {
     int j = 0;
     bool q = false;
     while ((!q) && (j != 8)) {
       j++;
       q = false;
       if (b[j] && a[i + j] && c[i - j + 7]) {
         x[i] = j;
         b[j] = false;
         a[i + j] = false;
         c[i - j + 7] = false;
@@ skipping 17 matching lines @@
     List<bool> b = new List<bool>(17);
     List<bool> c = new List<bool>(15);
     List<int> x = new List<int>(9);
     b[1] = false;
     for (int i = -7; i <= 16; i++) {
       if ((i >= 1) && (i <= 8)) a[i] = true;
       if (i >= 2) b[i] = true;
       if (i <= 7) c[i + 7] = true;
     }
 
-    if (!tryQueens(1, b, a, c, x)) Error.error("Error in queens");
+    if (!tryQueens(1, b, a, c, x))
+      Error.error("Error in queens");
   }
 }
 
 class QueensBenchmark extends BenchmarkBase {
   const QueensBenchmark() : super("Queens");
 
   void warmup() {
     Queens.queens();
   }
 
   void exercise() {
     Queens.queens();
   }
 
   static void main() {
     new QueensBenchmark().report();
   }
 }
 
+
 // R e c u r s e
 class Recurse {
   static int recurse(int n) {
     if (n <= 0) return 1;
     recurse(n - 1);
     return recurse(n - 1);
   }
 }
 
 class RecurseBenchmark extends BenchmarkBase {
   const RecurseBenchmark() : super("Recurse");
 
   void warmup() {
     Recurse.recurse(7);
   }
 
   void exercise() {
     // This value has been copied from benchpress.js, so that we can compare
     // performance.
     Recurse.recurse(13);
   }
 
   static void main() {
     new RecurseBenchmark().report();
   }
 }
 
+
 // S u m
 class SumBenchmark extends BenchmarkBase {
   const SumBenchmark() : super("Sum");
 
   static int sum(int start, int end) {
     var sum = 0;
     for (var i = start; i <= end; i++) sum += i;
     return sum;
   }
 
   void warmup() {
     sum(1, 1000);
   }
 
   void exercise() {
     // This value has been copied from benchpress.js, so that we can compare
     // performance.
     int result = sum(1, 10000);
     if (result != 50005000)
       Error.error("Wrong result: $result should be 50005000");
   }
 
   static void main() {
     new SumBenchmark().report();
   }
 }
 
+
 // H e l p e r   f u n c t i o n s   f o r   s o r t s
 class Random {
   static const int INITIAL_SEED = 74755;
   int seed;
   Random() : seed = INITIAL_SEED {}
 
   int random() {
     seed = ((seed * 1309) + 13849) % 65536;
     return seed;
   }
@@ skipping 18 matching lines @@
       if (e < min) min = e;
     }
 
     this.min = min;
     this.max = max;
   }
 
   void check() {
     List<int> a = list;
     int len = a.length;
-    if ((a[0] != min) || a[len - 1] != max) Error.error("List is not sorted");
+    if ((a[0] != min) || a[len - 1] != max)
+      Error.error("List is not sorted");
     for (var i = 1; i < len; i++) {
       if (a[i - 1] > a[i]) Error.error("List is not sorted");
     }
   }
 }
 
+
 // B u b b l e S o r t
 class BubbleSort {
   static void sort(List<int> a) {
     int len = a.length;
     for (int i = len - 2; i >= 0; i--) {
       for (int j = 0; j <= i; j++) {
         int c = a[j];
         int n = a[j + 1];
         if (c > n) {
           a[j] = n;
@@ skipping 62 matching lines @@
     SortData data = new SortData(800);
     QuickSort.sort(data.list, 0, data.list.length - 1);
     data.check();
   }
 
   static void main() {
     new QuickSortBenchmark().report();
   }
 }
 
+
 // T r e e S o r t
 class TreeNodePress {
   int value;
   TreeNodePress left;
   TreeNodePress right;
 
   TreeNodePress(int n) : value = n {}
 
   void insert(int n) {
     if (n < value) {
-      if (left == null)
-        left = new TreeNodePress(n);
-      else
-        left.insert(n);
+      if (left == null) left = new TreeNodePress(n);
+      else left.insert(n);
     } else {
-      if (right == null)
-        right = new TreeNodePress(n);
-      else
-        right.insert(n);
+      if (right == null) right = new TreeNodePress(n);
+      else right.insert(n);
     }
   }
 
   void check() {
     TreeNodePress left = this.left;
     TreeNodePress right = this.right;
     int value = this.value;
 
     return ((left == null) || ((left.value < value) && left.check())) &&
-        ((right == null) || ((right.value >= value) && right.check()));
+           ((right == null) || ((right.value >= value) && right.check()));
   }
 }
 
 class TreeSort {
   static void sort(List<int> a) {
     int len = a.length;
     TreeNodePress tree = new TreeNodePress(a[0]);
     for (var i = 1; i < len; i++) tree.insert(a[i]);
     if (!tree.check()) Error.error("Invalid result, tree not sorted");
   }
 }
 
 class TreeSortBenchmark extends BenchmarkBase {
   const TreeSortBenchmark() : super("TreeSort");
 
   void warmup() {
     TreeSort.sort(new SortData(100).list);
   }
 
   void exercise() {
     // This value has been copied from benchpress.js, so that we can compare
     // performance.
     TreeSort.sort(new SortData(1000).list);
   }
 }
 
+
 // T a k
 class TakBenchmark extends BenchmarkBase {
   const TakBenchmark() : super("Tak");
 
   static void tak(int x, int y, int z) {
     if (y >= x) return z;
     return tak(tak(x - 1, y, z), tak(y - 1, z, x), tak(z - 1, x, y));
   }
 
   void warmup() {
     tak(9, 6, 3);
   }
 
   void exercise() {
     // This value has been copied from benchpress.js, so that we can compare
     // performance.
     tak(18, 12, 6);
   }
 
   static void main() {
     new TakBenchmark().report();
   }
 }
 
+
 // T a k l
 class ListElement {
   final int length;
   final ListElement next;
 
   const ListElement(int length, ListElement next)
-      : this.length = length,
-        this.next = next;
+  : this.length = length,
+    this.next = next;
 
   static ListElement makeList(int length) {
     if (length == 0) return null;
     return new ListElement(length, makeList(length - 1));
   }
 
   static bool isShorter(ListElement x, ListElement y) {
     ListElement xTail = x;
     ListElement yTail = y;
     while (yTail != null) {
       if (xTail == null) return true;
       xTail = xTail.next;
       yTail = yTail.next;
     }
     return false;
   }
 }
 
 class Takl {
   static ListElement takl(ListElement x, ListElement y, ListElement z) {
     if (ListElement.isShorter(y, x)) {
-      return takl(takl(x.next, y, z), takl(y.next, z, x), takl(z.next, x, y));
+      return takl(takl(x.next, y, z),
+                  takl(y.next, z, x),
+                  takl(z.next, x, y));
     } else {
       return z;
     }
   }
 }
 
 class TaklBenchmark extends BenchmarkBase {
   const TaklBenchmark() : super("Takl");
 
   void warmup() {
-    Takl.takl(ListElement.makeList(8), ListElement.makeList(4),
-        ListElement.makeList(3));
+    Takl.takl(ListElement.makeList(8),
+              ListElement.makeList(4),
+              ListElement.makeList(3));
   }
 
   void exercise() {
     // This value has been copied from benchpress.js, so that we can compare
     // performance.
     ListElement result = Takl.takl(ListElement.makeList(15),
-        ListElement.makeList(10), ListElement.makeList(6));
+                                   ListElement.makeList(10),
+                                   ListElement.makeList(6));
     if (result.length != 10) {
       int len = result.length;
       Error.error("Wrong result: $len should be: 10");
     }
   }
 
   static void main() {
     new TaklBenchmark().report();
   }
 }
 
 // M a i n
 
 class BenchPress {
   static void mainWithArgs(List<String> args) {
     List<BenchmarkBase> benchmarks = [
-      new BubbleSortBenchmark(),
-      new FibBenchmark(),
-      new LoopBenchmark(),
-      new PermuteBenchmark(),
-      new QueensBenchmark(),
-      new QuickSortBenchmark(),
-      new RecurseBenchmark(),
-      new SieveBenchmark(),
-      new SumBenchmark(),
-      new TakBenchmark(),
-      new TaklBenchmark(),
-      new TowersBenchmark(),
-      new TreeSortBenchmark(),
+        new BubbleSortBenchmark(),
+        new FibBenchmark(),
+        new LoopBenchmark(),
+        new PermuteBenchmark(),
+        new QueensBenchmark(),
+        new QuickSortBenchmark(),
+        new RecurseBenchmark(),
+        new SieveBenchmark(),
+        new SumBenchmark(),
+        new TakBenchmark(),
+        new TaklBenchmark(),
+        new TowersBenchmark(),
+        new TreeSortBenchmark(),
     ];
     if (args.length > 0) {
       String benchName = args[0];
       bool foundBenchmark = false;
       benchmarks.forEach((bench) {
         if (bench.name == benchName) {
           foundBenchmark = true;
           bench.report();
         }
       });
@@ skipping 21 matching lines @@
 }
 
 class BenchmarkBase {
   final String name;
 
   // Empty constructor.
   const BenchmarkBase(String name) : this.name = name;
 
   // The benchmark code.
   // This function is not used, if both [warmup] and [exercise] are overwritten.
-  void run() {}
+  void run() { }
 
   // Runs a short version of the benchmark. By default invokes [run] once.
   void warmup() {
     run();
   }
 
   // Exercices the benchmark. By default invokes [run] 10 times.
   void exercise() {
     for (int i = 0; i < 10; i++) {
       run();
     }
   }
 
   // Not measured setup code executed prior to the benchmark runs.
-  void setup() {}
+  void setup() { }
 
   // Not measures teardown code executed after the benchark runs.
-  void teardown() {}
+  void teardown() { }
 
   // Measures the score for this benchmark by executing it repeately until
   // time minimum has been reached.
   static double measureFor(Function f, int timeMinimum) {
     int time = 0;
     int iter = 0;
     DateTime start = new DateTime.now();
     while (time < timeMinimum) {
       f();
       time = (new DateTime.now().difference(start)).inMilliseconds;
       iter++;
     }
     // Force double result by using a double constant.
     return (1000.0 * iter) / time;
   }
 
   // Measures the score for the benchmark and returns it.
   double measure() {
     setup();
     // Warmup for at least 100ms. Discard result.
-    measureFor(() {
-      this.warmup();
-    }, -100);
+    measureFor(() { this.warmup(); }, -100);
     // Run the benchmark for at least 2000ms.
-    double result = measureFor(() {
-      this.exercise();
-    }, -2000);
+    double result = measureFor(() { this.exercise(); }, -2000);
     teardown();
     return result;
   }
 
   void report() {
     double score = measure();
     print("name: $score");
   }
+
 }
-
 class Logger {
   static print(object) {
     printobject(object);
   }
+  static printobject(obj) { }
+}
 
-  static printobject(obj) {}
-}
 
 //
 // Dromaeo ObjectString
 // Adapted from Mozilla JavaScript performance test suite.
 // Microtests of strings (concatenation, methods).
 
+
 class ObjectString extends BenchmarkBase {
+
   const ObjectString() : super("Dromaeo.ObjectString");
 
   static void main() {
     new ObjectString().report();
   }
 
   static void print(String str) {
     print(str);
   }
 
   String getRandomString(int characters) {
     var result = "";
     for (var i = 0; i < characters; i++) {
-      result +=
-          Strings.createFromCodePoints([(25 * Math.random()).toInt() + 97]);
+      result += Strings.
+          createFromCodePoints([(25 * Math.random()).toInt() + 97]);
     }
     result += result;
     result += result;
     return result;
   }
 
   void run() {
     //JS Dromeaeo uses 16384
     final ITERATE1 = 384;
     //JS Dromeaeo uses 80000
@@ skipping 96 matching lines @@
       str = input[0];
       str = input[input.length - 1];
       str = input[150]; //set it to 15000
       str = input[100]; //set it to 10000
       str = input[50]; //set it to 5000
     }
     return str;
   }
 }
 
+
 class CodeUnitAtBenchmark {
   CodeUnitAtBenchmark() {}
 
   static String test(String input, var iterations) {
     var str;
     for (var j = 0; j < iterations; j++) {
       str = input.codeUnitAt(0);
       str = input.codeUnitAt(input.length - 1);
       str = input.codeUnitAt(150); //set it to 15000
       str = input.codeUnitAt(100); //set it to 10000
@@ skipping 37 matching lines @@
   SliceBenchmark() {}
 
   static String test(String input, var iterations) {
     var str;
     for (var j = 0; j < iterations; j++) {
       str = input.substring(0, input.length - 1);
       str = input.substring(0, 5);
       str = input.substring(input.length - 1, input.length - 1);
       str = input.substring(input.length - 6, input.length - 1);
       str = input.substring(150, 155); //set to 15000 and 15005
-      str = input.substring(120, input.length - 1); //set to 12000
+      str = input.substring(120, input.length-1); //set to 12000
     }
     return str;
   }
 }
 
 class SubstrBenchmark {
   SubstrBenchmark() {}
 
   static String test(String input, var iterations) {
     var str;
     for (var j = 0; j < iterations; j++) {
-      str = input.substring(0, input.length - 1);
+      str = input.substring(0, input.length-1);
       str = input.substring(0, 4);
       str = input.substring(input.length - 1, input.length - 1);
       str = input.substring(input.length - 6, input.length - 6);
       str = input.substring(150, 154); //set to 15000 and 15005
       str = input.substring(120, 124); //set to 12000
     }
     return str;
   }
 }
 
 class SubstringBenchmark {
   SubstringBenchmark() {}
 
   static String test(String input, var iterations) {
     var str;
     for (var j = 0; j < iterations; j++) {
       str = input.substring(0, input.length - 1);
       str = input.substring(0, 4);
       str = input.substring(input.length - 1, input.length - 1);
       str = input.substring(input.length - 6, input.length - 2);
       str = input.substring(150, 154); //set to 15000 and 15005
       str = input.substring(120, input.length - 2); //set to 12000
     }
     return str;
+
   }
 }
 
 class ToLowerCaseBenchmark {
   ToLowerCaseBenchmark() {}
 
   static String test(String input, var iterations) {
     var str;
     for (var j = 0; j < (iterations / 1000); j++) {
       str = Ascii.toLowerCase(input);
@@ skipping 26 matching lines @@
       res = (tmp.compareTo(tmp2) < 0);
       res = (tmp.compareTo(tmp2) > 0);
     }
     return res;
   }
 }
 
 // Benchmarks basic message communication between two isolates.
 
 class Benchmark1 {
+
   static const MESSAGES = 10000;
   static const INIT_MESSAGE = 0;
   static const TERMINATION_MESSAGE = -1;
   static const WARMUP_TIME = 1000;
   static const RUN_TIME = 1000;
   static const RUNS = 5;
 
+
   static int run() {
     return _run;
   }
 
   static void add_result(var opsms) {
     _run++;
     _opsms += opsms;
   }
 
   static void get_result() {
     return _opsms / _run;
   }
 
   static void init() {
     _run = 0;
     _opsms = 0.0;
   }
 
   static void main() {
     init();
     PingPongGame pingPongGame = new PingPongGame();
   }
 
   static var _run;
   static var _opsms;
 }
 
 class PingPongGame {
+
   PingPongGame()
       : _ping = new ReceivePort(),
         _pingPort = _ping.toSendPort(),
         _pong = null,
         _warmedup = false,
         _iterations = 0 {
     SendPort _pong = spawnFunction(pong);
     play();
   }
 
@@ skipping 54 matching lines @@
     if (message == Benchmark1.INIT_MESSAGE) {
       replyTo.send(message, null);
     } else if (message == Benchmark1.TERMINATION_MESSAGE) {
       port.close();
     } else {
       replyTo.send(message, null);
     }
   });
 }
 
+
 class ManyGenericInstanceofTest {
   static testMain() {
     for (int i = 0; i < 5000; i++) {
       GenericInstanceof.testMain();
     }
   }
 }
 
 // ---------------------------------------------------------------------------
 // THE REST OF THIS FILE COULD BE AUTOGENERATED
@@ skipping 27 matching lines @@
 void isolate_negative_entry() {
   port.receive((ignored, replyTo) {
     replyTo.send("foo", null);
   });
 }
 
 isolate_negative_test_main() {
   test("ensure isolate code is executed", () {
     SendPort port = spawnFunction(isolate_negative_entry);
     port.call("foo").then(expectAsync1((message) {
-      Expect.equals(true, "Expected fail"); // <=-------- Should fail here.
+      Expect.equals(true, "Expected fail");   // <=-------- Should fail here.
     }));
   });
 }
 
 // ---------------------------------------------------------------------------
 // tests/isolate/message_test.dart
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // Message passing test.
 // ---------------------------------------------------------------------------
 
 class MessageTest {
   static const List list1 = const ["Hello", "World", "Hello", 0xfffffffffff];
   static const List list2 = const [null, list1, list1, list1, list1];
   static const List list3 = const [list2, 2.0, true, false, 0xfffffffffff];
   static const Map map1 = const {
-    "a=1": 1,
-    "b=2": 2,
-    "c=3": 3,
+    "a=1" : 1, "b=2" : 2, "c=3" : 3,
   };
   static const Map map2 = const {
-    "list1": list1,
-    "list2": list2,
-    "list3": list3,
+    "list1" : list1, "list2" : list2, "list3" : list3,
   };
   static const List list4 = const [map1, map2];
   static const List elms = const [
-    list1,
-    list2,
-    list3,
-    list4,
+      list1, list2, list3, list4,
   ];
 
   static void VerifyMap(Map expected, Map actual) {
     Expect.equals(true, expected is Map);
     Expect.equals(true, actual is Map);
     Expect.equals(expected.length, actual.length);
     testForEachMap(key, value) {
       if (value is List) {
         VerifyList(value, actual[key]);
       } else {
         Expect.equals(value, actual[key]);
       }
     }
-
     expected.forEach(testForEachMap);
   }
 
   static void VerifyList(List expected, List actual) {
     for (int i = 0; i < expected.length; i++) {
       if (expected[i] is List) {
         VerifyList(expected[i], actual[i]);
       } else if (expected[i] is Map) {
         VerifyMap(expected[i], actual[i]);
       } else {
@@ skipping 36 matching lines @@
     // Send objects and receive them back.
     for (int i = 0; i < MessageTest.elms.length; i++) {
       var sentObject = MessageTest.elms[i];
       remote.call(sentObject).then(expectAsync1((var receivedObject) {
         MessageTest.VerifyObject(i, receivedObject);
       }));
     }
 
     // Send recursive objects and receive them back.
     List local_list1 = ["Hello", "World", "Hello", 0xffffffffff];
-    List local_list2 = [null, local_list1, local_list1];
+    List local_list2 = [null, local_list1, local_list1 ];
     List local_list3 = [local_list2, 2.0, true, false, 0xffffffffff];
     List sendObject = new List(5);
     sendObject[0] = local_list1;
     sendObject[1] = sendObject;
     sendObject[2] = local_list2;
     sendObject[3] = sendObject;
     sendObject[4] = local_list3;
     remote.call(sendObject).then((var replyObject) {
       Expect.equals(true, sendObject is List);
       Expect.equals(true, replyObject is List);
       Expect.equals(sendObject.length, replyObject.length);
       Expect.equals(true, identical(replyObject[1], replyObject));
       Expect.equals(true, identical(replyObject[3], replyObject));
       Expect.equals(true, identical(replyObject[0], replyObject[2][1]));
       Expect.equals(true, identical(replyObject[0], replyObject[2][2]));
       Expect.equals(true, identical(replyObject[2], replyObject[4][0]));
       Expect.equals(true, identical(replyObject[0][0], replyObject[0][2]));
       // Bigint literals are not canonicalized so do a == check.
       Expect.equals(true, replyObject[0][3] == replyObject[4][4]);
     });
 
     // Shutdown the MessageServer.
     remote.call(-1).then(expectAsync1((int message) {
-      Expect.equals(MessageTest.elms.length + 1, message);
-    }));
+        Expect.equals(MessageTest.elms.length + 1, message);
+      }));
   });
 }
 
 // ---------------------------------------------------------------------------
 // tests/isolate/request_reply_test.dart
 // ---------------------------------------------------------------------------
 
 void request_reply_entry() {
   port.receive((message, SendPort replyTo) {
     replyTo.send(message + 87);
@@ skipping 56 matching lines @@
       Expect.equals((count - 1) * 2, message);
       remote.send(count++, reply);
       if (count == 10) {
         remote.send(-1, reply);
       }
     }, 11));
     remote.send(count++, reply);
   });
 }
 
+
 // ---------------------------------------------------------------------------
 // tests/isolate/mandel_isolate_test.dart
 // ---------------------------------------------------------------------------
 
 const TERMINATION_MESSAGE = -1;
 const N = 100;
 const ISOLATES = 20;
 
 mandel_main() {
   test("Render Mandelbrot in parallel", () {
     final state = new MandelbrotState();
     state._validated.future.then(expectAsync1((result) {
       expect(result, isTrue);
     }));
     for (int i = 0; i < Math.min(ISOLATES, N); i++) state.startClient(i);
   });
 }
 
+
 class MandelbrotState {
+
   MandelbrotState() {
     _result = new List<List<int>>(N);
     _lineProcessedBy = new List<LineProcessorClient>(N);
     _sent = 0;
     _missing = N;
     _validated = new Completer<bool>();
   }
 
   void startClient(int id) {
     assert(_sent < N);
@@ skipping 37 matching lines @@
     // print(output);
   }
 
   List<List<int>> _result;
   List<LineProcessorClient> _lineProcessedBy;
   int _sent;
   int _missing;
   Completer<bool> _validated;
 }
 
+
 class LineProcessorClient {
+
   LineProcessorClient(MandelbrotState this._state, int this._id) {
     _port = spawnFunction(processLines);
   }
 
   void processLine(int y) {
     _port.call(y).then((List<int> message) {
       _state.notifyProcessedLine(this, y, message);
     });
   }
 
@@ skipping 36 matching lines @@
 void processLines() {
   port.receive((message, SendPort replyTo) {
     if (message == TERMINATION_MESSAGE) {
       assert(replyTo == null);
       port.close();
     } else {
       replyTo.send(processLine(message), null);
     }
   });
 }