Format all tests.

tests/language/async_star_test.dart

 // Copyright (c) 2015, 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 async_star_test;
 
 import "package:unittest/unittest.dart";
 import "dart:async";
 
 main() {
   group("basic", () {
     test("empty", () {
       f() async* {}
       return f().toList().then((v) {
         expect(v, equals([]));
       });
     });
 
     test("single", () {
-      f() async* { yield 42; }
+      f() async* {
+        yield 42;
+      }
+
       return f().toList().then((v) {
         expect(v, equals([42]));
       });
     });
 
     test("call delays", () {
       var list = [];
-      f() async* { list.add(1); yield 2; }
+      f() async* {
+        list.add(1);
+        yield 2;
+      }
+
       var res = f().forEach(list.add);
       list.add(0);
       return res.whenComplete(() {
         expect(list, equals([0, 1, 2]));
       });
     });
 
     test("throws", () {
-      f() async* { yield 1; throw 2; }
+      f() async* {
+        yield 1;
+        throw 2;
+      }
+
       var completer = new Completer();
       var list = [];
       f().listen(list.add,
-                 onError: (v) => list.add("$v"),
-                 onDone: completer.complete);
+          onError: (v) => list.add("$v"), onDone: completer.complete);
       return completer.future.whenComplete(() {
         expect(list, equals([1, "2"]));
       });
     });
 
     test("multiple", () {
       f() async* {
         for (int i = 0; i < 10; i++) {
           yield i;
         }
       }
+
       return expectList(f(), new List.generate(10, id));
     });
 
     test("allows await", () {
       f() async* {
         var x = await new Future.value(42);
         yield x;
         x = await new Future.value(42);
       }
+
       return expectList(f(), [42]);
     });
 
     test("allows await in loop", () {
       f() async* {
         for (int i = 0; i < 10; i++) {
           yield await i;
         }
       }
+
       return expectList(f(), new List.generate(10, id));
     });
 
     test("allows yield*", () {
       f() async* {
         yield* new Stream.fromIterable([1, 2, 3]);
       }
+
       return expectList(f(), [1, 2, 3]);
     });
 
     test("allows yield* of async*", () {
       f(n) async* {
         yield n;
         if (n == 0) return;
         yield* f(n - 1);
         yield n;
       }
+
       return expectList(f(3), [3, 2, 1, 0, 1, 2, 3]);
     });
 
     test("Cannot yield* non-stream", () {
       f(s) async* {
         yield* s;
       }
+
       return f(42).transform(getErrors).single.then((v) {
         // Not implementing Stream.
         expect(v is Error, isTrue);
       });
     });
 
-   test("Cannot yield* non-stream", () {
+    test("Cannot yield* non-stream", () {
       f(s) async* {
         yield* s;
       }
+
       return f(new NotAStream()).transform(getErrors).single.then((v) {
         // Not implementing Stream.
         expect(v is Error, isTrue);
       });
     });
   });
 
   group("yield statement context", () {
     test("plain", () {
       f() async* {
         yield 0;
       }
+
       return expectList(f(), [0]);
     });
 
     test("if-then-else", () {
       f(b) async* {
-        if (b) yield 0; else yield 1;
+        if (b)
+          yield 0;
+        else
+          yield 1;
       }
+
       return expectList(f(true), [0]).whenComplete(() {
         expectList(f(false), [1]);
       });
     });
 
     test("block", () {
       f() async* {
         yield 0;
-        { yield 1; }
+        {
+          yield 1;
+        }
         yield 2;
       }
+
       return expectList(f(), [0, 1, 2]);
     });
 
     test("labeled", () {
       f() async* {
-        label1: yield 0;
+        label1:
+        yield 0;
       }
+
       return expectList(f(), [0]);
     });
 
     test("for-loop", () {
       f() async* {
         for (int i = 0; i < 3; i++) yield i;
       }
+
       return expectList(f(), [0, 1, 2]);
     });
 
     test("for-in-loop", () {
       f() async* {
         for (var i in [0, 1, 2]) yield i;
       }
+
       return expectList(f(), [0, 1, 2]);
     });
 
     test("await for-in-loop", () {
       f() async* {
         await for (var i in new Stream.fromIterable([0, 1, 2])) yield i;
       }
+
       return expectList(f(), [0, 1, 2]);
     });
 
     test("while-loop", () {
       f() async* {
         int i = 0;
         while (i < 3) yield i++;
       }
+
       return expectList(f(), [0, 1, 2]);
     });
 
     test("do-while-loop", () {
       f() async* {
         int i = 0;
         do yield i++; while (i < 3);
       }
+
       return expectList(f(), [0, 1, 2]);
     });
 
     test("try-catch-finally", () {
       f() async* {
-        try { yield 0; } catch (e) { yield 1; } finally { yield 2; }
+        try {
+          yield 0;
+        } catch (e) {
+          yield 1;
+        } finally {
+          yield 2;
+        }
       }
+
       return expectList(f(), [0, 2]);
     });
 
     test("try-catch-finally 2", () {
       f() async* {
-        try { yield throw 0; } catch (e) { yield 1; } finally { yield 2; }
+        try {
+          yield throw 0;
+        } catch (e) {
+          yield 1;
+        } finally {
+          yield 2;
+        }
       }
+
       return expectList(f(), [1, 2]);
     });
 
     test("switch-case", () {
       f(v) async* {
         switch (v) {
           case 0:
             yield 0;
             continue label1;
           label1:
           case 1:
             yield 1;
             break;
           default:
             yield 2;
         }
       }
+
       return expectList(f(0), [0, 1]).whenComplete(() {
         return expectList(f(1), [1]);
       }).whenComplete(() {
         return expectList(f(2), [2]);
       });
     });
 
     test("dead-code return", () {
       f() async* {
         return;
         yield 1;
       }
+
       return expectList(f(), []);
     });
 
     test("dead-code throw", () {
       f() async* {
         try {
           throw 0;
           yield 1;
         } catch (_) {}
       }
+
       return expectList(f(), []);
     });
 
     test("dead-code break", () {
       f() async* {
         while (true) {
           break;
           yield 1;
         }
       }
+
       return expectList(f(), []);
     });
 
     test("dead-code break 2", () {
       f() async* {
-        label: {
+        label:
+        {
           break label;
           yield 1;
         }
       }
+
       return expectList(f(), []);
     });
 
     test("dead-code continue", () {
       f() async* {
         do {
           continue;
           yield 1;
         } while (false);
       }
+
       return expectList(f(), []);
     });
   });
 
   group("yield expressions", () {
     test("local variable", () {
       f() async* {
         var x = 42;
         yield x;
       }
+
       return expectList(f(), [42]);
     });
 
     test("constant variable", () {
       f() async* {
         const x = 42;
         yield x;
       }
+
       return expectList(f(), [42]);
     });
 
     test("function call", () {
       g() => 42;
       f() async* {
         yield g();
       }
+
       return expectList(f(), [42]);
     });
 
     test("unary operator", () {
       f() async* {
         var x = -42;
         yield -x;
       }
+
       return expectList(f(), [42]);
     });
 
     test("binary operator", () {
       f() async* {
         var x = 21;
         yield x + x;
       }
+
       return expectList(f(), [42]);
     });
 
     test("ternary operator", () {
       f() async* {
         var x = 21;
         yield x == 21 ? x + x : x;
       }
+
       return expectList(f(), [42]);
     });
 
     test("suffix post-increment", () {
       f() async* {
         var x = 42;
         yield x++;
       }
+
       return expectList(f(), [42]);
     });
 
     test("suffix pre-increment", () {
       f() async* {
         var x = 41;
         yield ++x;
       }
+
       return expectList(f(), [42]);
     });
 
     test("assignment", () {
       f() async* {
         var x = 37;
         yield x = 42;
       }
+
       return expectList(f(), [42]);
     });
 
     test("assignment op", () {
       f() async* {
         var x = 41;
         yield x += 1;
       }
+
       return expectList(f(), [42]);
     });
 
     test("await", () {
       f() async* {
         yield await new Future.value(42);
       }
+
       return expectList(f(), [42]);
     });
 
     test("index operator", () {
       f() async* {
         var x = [42];
         yield x[0];
       }
+
       return expectList(f(), [42]);
     });
 
     test("function expression block", () {
       var o = new Object();
       f() async* {
-        yield () { return o; };
+        yield () {
+          return o;
+        };
       }
+
       return f().first.then((v) {
         expect(v(), same(o));
       });
     });
 
     test("function expression arrow", () {
       var o = new Object();
       f() async* {
         yield () => o;
       }
+
       return f().first.then((v) {
         expect(v(), same(o));
       });
     });
 
     test("function expression block async", () {
       var o = new Object();
       f() async* {
-        yield () async { return o; };
+        yield () async {
+          return o;
+        };
       }
+
       return f().first.then((v) => v()).then((v) {
         expect(v, same(o));
       });
     });
 
     test("function expression arrow async", () {
       var o = new Object();
       f() async* {
         yield () async => o;
       }
+
       return f().first.then((v) => v()).then((v) {
         expect(v, same(o));
       });
     });
 
     test("function expression block async*", () {
       var o = new Object();
       f() async* {
-        yield () async* { yield o; };
+        yield () async* {
+          yield o;
+        };
       }
+
       return f().first.then((v) => v().first).then((v) {
         expect(v, same(o));
       });
     });
   });
 
   group("loops", () {
     test("simple yield", () {
       f() async* {
         for (int i = 0; i < 3; i++) {
           yield i;
         }
       }
+
       return expectList(f(), [0, 1, 2]);
     });
 
     test("yield in double loop", () {
       f() async* {
         for (int i = 0; i < 3; i++) {
           for (int j = 0; j < 2; j++) {
             yield i * 2 + j;
           }
         }
       }
+
       return expectList(f(), [0, 1, 2, 3, 4, 5]);
     });
 
     test("yield in try body", () {
       var list = [];
       f() async* {
         for (int i = 0; i < 3; i++) {
           try {
             yield i;
           } finally {
             list.add("$i");
           }
         }
       }
+
       return expectList(f(), [0, 1, 2]).whenComplete(() {
         expect(list, equals(["0", "1", "2"]));
       });
     });
 
     test("yield in catch", () {
       var list = [];
       f() async* {
         for (int i = 0; i < 3; i++) {
           try {
             throw i;
           } catch (e) {
             yield e;
           } finally {
             list.add("$i");
           }
         }
       }
+
       return expectList(f(), [0, 1, 2]).whenComplete(() {
         expect(list, equals(["0", "1", "2"]));
       });
     });
 
     test("yield in finally", () {
       var list = [];
       f() async* {
         for (int i = 0; i < 3; i++) {
           try {
             throw i;
           } finally {
             yield i;
             list.add("$i");
             continue;
           }
         }
       }
+
       return expectList(f(), [0, 1, 2]).whenComplete(() {
         expect(list, equals(["0", "1", "2"]));
       });
     });
 
     test("keep yielding after cancel", () {
       f() async* {
         for (int i = 0; i < 10; i++) {
           try {
             yield i;
           } finally {
             continue;
           }
         }
       }
+
       return expectList(f().take(3), [0, 1, 2]);
     });
   });
 
   group("canceling", () {
     // Stream.take(n) automatically cancels after seeing the n'th value.
 
     test("cancels at yield", () {
       Completer exits = new Completer();
       var list = [];
       f() async* {
         try {
           list.add(0);
           yield list.add(1);
           list.add(2);
         } finally {
           exits.complete(3);
         }
       }
+
       // No events must be fired synchronously in response to a listen.
-      var subscription = f().listen((v) { fail("Received event $v"); },
-                                   onDone: () { fail("Received done"); });
+      var subscription = f().listen((v) {
+        fail("Received event $v");
+      }, onDone: () {
+        fail("Received done");
+      });
       // No events must be delivered after a cancel.
       subscription.cancel();
       return exits.future.then((v) {
         expect(v, equals(3));
         expect(list, equals([0, 1]));
       });
     });
 
     test("does cancel eventually", () {
       var exits = new Completer();
       var list = [];
       f() async* {
         int i = 0;
         try {
           while (true) yield i++;
         } finally {
           list.add("a");
           exits.complete(i);
         }
       }
+
       return expectList(f().take(5), [0, 1, 2, 3, 4])
           .then((_) => exits.future)
           .then((v) {
-            expect(v, greaterThan(4));
-            expect(list, ["a"]);
-          });
+        expect(v, greaterThan(4));
+        expect(list, ["a"]);
+      });
     });
 
     group("at index", () {
       f() async* {
         try {
           yield await new Future.microtask(() => 1);
         } finally {
           try {
             yield await new Future.microtask(() => 2);
           } finally {
             yield await new Future.microtask(() => 3);
           }
         }
       }
+
       test("- all, sanity check", () {
         return expectList(f(), [1, 2, 3]);
       });
       test("after end", () {
         return expectList(f().take(4), [1, 2, 3]);
       });
       test("at end", () {
         return expectList(f().take(3), [1, 2, 3]);
       });
       test("before end", () {
@@ skipping 11 matching lines @@
   group("pausing", () {
     test("pauses execution at yield for at least a microtask", () {
       var list = [];
       f() async* {
         list.add(1);
         yield 2;
         list.add(3);
         yield 4;
         list.add(5);
       }
+
       var done = new Completer();
       var sub = f().listen((v) {
         if (v == 2) {
           expect(list, equals([1]));
         } else if (v == 4) {
           expect(list, equals([1, 3]));
         } else {
           fail("Unexpected value $v");
         }
       }, onDone: () {
         expect(list, equals([1, 3, 5]));
         done.complete();
       });
       return done.future;
     });
 
     test("pause stops execution at yield", () {
       var list = [];
       f() async* {
         list.add(1);
         yield 2;
         list.add(3);
         yield 4;
         list.add(5);
       }
+
       var done = new Completer();
       var sub;
       sub = f().listen((v) {
         if (v == 2) {
           expect(list, equals([1]));
           sub.pause();
           new Timer(MS * 300, () {
             expect(list.length, lessThan(3));
             sub.resume();
           });
@@ skipping 12 matching lines @@
     test("pause stops execution at yield 2", () {
       var list = [];
       f() async* {
         int i = 0;
         while (true) {
           yield i;
           list.add(i);
           i++;
         }
       }
+
       int expected = 0;
       var done = new Completer();
       var sub;
       sub = f().listen((v) {
         expect(v, equals(expected++));
         if (v % 5 == 0) {
           sub.pause(new Future.delayed(MS * 300));
         } else if (v == 17) {
           sub.cancel();
           done.complete();
         }
       }, onDone: () {
         fail("Unexpected done!");
       });
       return done.future.whenComplete(() {
         expect(list.length == 18 || list.length == 19, isTrue);
       });
     });
   });
 
   group("await for", () {
     mkStream(int n) async* {
       for (int i = 0; i < n; i++) yield i;
     }
 
     test("simple stream", () {
       f(s) async {
         var r = 0;
-        await for(var v in s) r += v;
+        await for (var v in s) r += v;
         return r;
       }
+
       return f(mkStream(5)).then((v) {
         expect(v, equals(10));
       });
     });
 
     test("simple stream, await", () {
       f(s) async {
         var r = 0;
-        await for(var v in s) r += await new Future.microtask(() => v);
+        await for (var v in s) r += await new Future.microtask(() => v);
         return r;
       }
+
       return f(mkStream(5)).then((v) {
         expect(v, equals(10));
       });
     });
 
     test("simple stream reyield", () {
       f(s) async* {
         var r = 0;
-        await for(var v in s) yield r += v;
+        await for (var v in s) yield r += v;
       }
+
       return expectList(f(mkStream(5)), [0, 1, 3, 6, 10]);
     });
 
     test("simple stream, await, reyield", () {
       f(s) async* {
         var r = 0;
-        await for(var v in s) yield r += await new Future.microtask(() => v);
+        await for (var v in s) yield r += await new Future.microtask(() => v);
       }
+
       return expectList(f(mkStream(5)), [0, 1, 3, 6, 10]);
     });
 
     test("nested", () {
       f() async {
         var r = 0;
         await for (var i in mkStream(5)) {
           await for (var j in mkStream(3)) {
             r += i * j;
           }
         }
         return r;
       }
+
       return f().then((v) {
         expect(v, equals((1 + 2 + 3 + 4) * (1 + 2)));
       });
     });
 
     test("nested, await", () {
       f() async {
         var r = 0;
         await for (var i in mkStream(5)) {
           await for (var j in mkStream(3)) {
             r += await new Future.microtask(() => i * j);
           }
         }
         return r;
       }
+
       return f().then((v) {
         expect(v, equals((1 + 2 + 3 + 4) * (1 + 2)));
       });
     });
 
     test("nested, await * 2", () {
       f() async {
         var r = 0;
         await for (var i in mkStream(5)) {
           var ai = await new Future.microtask(() => i);
           await for (var j in mkStream(3)) {
             r += await new Future.microtask(() => ai * j);
           }
         }
         return r;
       }
+
       return f().then((v) {
         expect(v, equals((1 + 2 + 3 + 4) * (1 + 2)));
       });
     });
   });
 }
 
 // Obscuring identity function.
 id(x) {
   try {
     if (x != null) throw x;
   } catch (e) {
     return e;
   }
   return null;
 }
 
 expectList(stream, list) {
   return stream.toList().then((v) {
     expect(v, equals(list));
   });
 }
 
 const MS = const Duration(milliseconds: 1);
 
-var getErrors = new StreamTransformer.fromHandlers(
-  handleData:(data, sink) { fail("Unexpected value"); },
-  handleError: (e, s, sink) { sink.add(e); },
-  handleDone: (sink) { sink.close(); });
+var getErrors = new StreamTransformer.fromHandlers(handleData: (data, sink) {
+  fail("Unexpected value");
+}, handleError: (e, s, sink) {
+  sink.add(e);
+}, handleDone: (sink) {
+  sink.close();
+});
 
 class NotAStream {
   listen(oData, {onError, onDone, cancelOnError}) {
     fail("Not implementing Stream.");
   }
 }