Format all tests.

tests/lib_strong/async/slow_consumer_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.
 
 // VMOptions=--old_gen_heap_size=64
 
 library slow_consumer_test;
 
 import 'package:async_helper/async_helper.dart';
 import "package:expect/expect.dart";
@@ skipping 11 matching lines @@
   SlowConsumer(int this.bytesPerSecond);
 
   Future consume(Stream stream) {
     return addStream(stream).then((_) => close());
   }
 
   Future addStream(Stream stream) {
     bool done = false;
     Completer completer = new Completer();
     var subscription;
-    subscription = stream.listen(
-      (List<int> data) {
-        current = current
-          .then((count) {
-            // Simulated amount of time it takes to handle the data.
-            int ms = data.length * 1000 ~/ bytesPerSecond;
-            Duration duration = new Duration(milliseconds: ms);
-            if (!done) subscription.pause();
-            return new Future.delayed(duration, () {
-              if (!done) subscription.resume();
-              // Make sure we use data here to keep tracking it.
-              return count + data.length;
-            });
-          });
-        },
-      onDone: () {
-        done = true;
-        current.then((count) {
-          finalCount = count;
-          completer.complete(count);
+    subscription = stream.listen((List<int> data) {
+      current = current.then((count) {
+        // Simulated amount of time it takes to handle the data.
+        int ms = data.length * 1000 ~/ bytesPerSecond;
+        Duration duration = new Duration(milliseconds: ms);
+        if (!done) subscription.pause();
+        return new Future.delayed(duration, () {
+          if (!done) subscription.resume();
+          // Make sure we use data here to keep tracking it.
+          return count + data.length;
         });
       });
+    }, onDone: () {
+      done = true;
+      current.then((count) {
+        finalCount = count;
+        completer.complete(count);
+      });
+    });
     return completer.future;
   }
 
   Future close() {
     return new Future.value(finalCount);
   }
 }
 
 class DataProvider {
   final int chunkSize;
   final int bytesPerSecond;
   int sentCount = 0;
   int targetCount;
   StreamController controller;
   Timer pendingSend;
 
   DataProvider(int this.bytesPerSecond, int this.targetCount, this.chunkSize) {
     controller = new StreamController(
-      sync: true,
-      onPause: onPauseStateChange,
-      onResume: onPauseStateChange);
+        sync: true, onPause: onPauseStateChange, onResume: onPauseStateChange);
     Timer.run(send);
   }
 
   Stream get stream => controller.stream;
 
   send() {
     if (pendingSend != null) {
       pendingSend.cancel();
       pendingSend = null;
     }
@@ skipping 26 matching lines @@
 main() {
   asyncStart();
   // The data provider can deliver 800MB/s of data. It sends 100MB of data to
   // the slower consumer who can only read 200MB/s. The data is sent in 1MB
   // chunks.
   //
   // This test is limited to 64MB of heap-space (see VMOptions on top of the
   // file). If the consumer doesn't pause the data-provider it will run out of
   // heap-space.
 
-  new DataProvider(800 * MB, 100 * MB, 1 * MB).stream
-    .pipe(new SlowConsumer(200 * MB))
-    .then((count) {
-      Expect.equals(100 * MB, count);
-      asyncEnd();
-    });
+  new DataProvider(800 * MB, 100 * MB, 1 * MB)
+      .stream
+      .pipe(new SlowConsumer(200 * MB))
+      .then((count) {
+    Expect.equals(100 * MB, count);
+    asyncEnd();
+  });
 }