format with dart_style 0.2.0-rc.3

test/checker/checker_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.
 
 /// General type checking tests
 library dev_compiler.test.checker_test;
 
 import 'package:test/test.dart';
 
 import '../testing.dart';
@@ skipping 33 matching lines @@
 
           // Check the boolean conversion of the condition.
           print((/*severe:StaticTypeError*/i) ? false : true);
           print((/*warning:DownCastImplicit*/obj) ? false : true);
           print((/*info:DynamicCast*/dyn) ? false : true);
         }
       '''
     });
   });
 
-  test('if/for/do/while statements use boolean conversion', () => testChecker({
-    '/main.dart': '''
+  test(
+      'if/for/do/while statements use boolean conversion',
+      () => testChecker({
+            '/main.dart': '''
       main() {
         dynamic d = 42;
         Object obj = 42;
         int i = 42;
         bool b = false;
 
         if (b) {}
         if (/*info:DynamicCast*/dyn) {}
         if (/*warning:DownCastImplicit*/obj) {}
         if (/*severe:StaticTypeError*/i) {}
 
         while (b) {}
         while (/*info:DynamicCast*/dyn) {}
         while (/*warning:DownCastImplicit*/obj) {}
         while (/*severe:StaticTypeError*/i) {}
 
         do {} while (b);
         do {} while (/*info:DynamicCast*/dyn);
         do {} while (/*warning:DownCastImplicit*/obj);
         do {} while (/*severe:StaticTypeError*/i);
 
         for (;b;) {}
         for (;/*info:DynamicCast*/dyn;) {}
         for (;/*warning:DownCastImplicit*/obj;) {}
         for (;/*severe:StaticTypeError*/i;) {}
       }
     '''
-  }));
+          }));
 
   test('dynamic invocation', () {
     testChecker({
       '/main.dart': '''
 
       class A {
         dynamic call(dynamic x) => x;
       }
       class B extends A {
         int call(int x) => x;
@@ skipping 162 matching lines @@
           // num is nullable
           z = null;
           z = x;
           z = y;
 
           // bool is nullable
           b = null;
           b = true;
         }
       '''
-    }, nonnullableTypes: <String>['int', 'double']);
+    }, nonnullableTypes: <String>[
+      'int',
+      'double'
+    ]);
   });
 
   test('Primitives and generics', () {
     testChecker({
       '/main.dart': '''
         class A<T> {
           // TODO(vsm): This needs a static info indicating a runtime
           // check at construction.
           T x;
 
@@ skipping 21 matching lines @@
 
         class C<T extends num> {
           // TODO(vsm): This needs a static info indicating a runtime
           // check at construction.
           T x;
 
           // TODO(vsm): Should this be a different type of DownCast?
           T foo() => /*warning:DownCastImplicit*/null;
         }
       '''
-    }, nonnullableTypes: <String>['int', 'double']);
+    }, nonnullableTypes: <String>[
+      'int',
+      'double'
+    ]);
   });
 
   test('Constructors', () {
     testChecker({
       '/main.dart': '''
       const num z = 25;
       Object obj = "world";
 
       class A {
         int x;
@@ skipping 1269 matching lines @@
             /*severe:InvalidMethodOverride*/C m2(C value) {}
             /*severe:InvalidMethodOverride*/A m3(C value) {}
             C m4(A value) {}
             /*severe:InvalidMethodOverride*/m5(value) {}
             /*severe:InvalidMethodOverride*/dynamic m6(dynamic value) {}
           }
        '''
     }, inferFromOverrides: true);
   });
 
-  test('unary operators', () => testChecker({
-    '/main.dart': '''
+  test(
+      'unary operators',
+      () => testChecker({
+            '/main.dart': '''
       class A {
         A operator ~() {}
         A operator +(int x) {}
         A operator -(int x) {}
         A operator -() {}
       }
 
       foo() => new A();
 
       test() {
@@ skipping 12 matching lines @@
         ++a;
         --a;
         (/*info:DynamicInvoke*/++d);
         (/*info:DynamicInvoke*/--d);
 
         a++;
         a--;
         (/*info:DynamicInvoke*/d++);
         (/*info:DynamicInvoke*/d--);
       }'''
-  }));
+          }));
 
   test('binary and index operators', () {
     testChecker({
       '/main.dart': '''
           class A {
             A operator *(B b) {}
             A operator /(B b) {}
             A operator ~/(B b) {}
             A operator %(B b) {}
             A operator +(B b) {}
@@ skipping 1010 matching lines @@
             f = bar as II2D;
             f = bar as DD2I;
             f = bar as DI2D;
             f = bar as ID2D;
             f = bar as DD2D;
           }
       '''
     });
   });
 
-  test('custom URL mappings', () => testChecker({
-    '/main.dart': '''
+  test(
+      'custom URL mappings',
+      () => testChecker({
+            '/main.dart': '''
       import 'dart:foobar' show Baz;
       main() {
         print(Baz.quux);
       }'''
-  },
-      customUrlMappings: {
-    'dart:foobar': '$testDirectory/checker/dart_foobar.dart'
-  }));
+          }, customUrlMappings: {
+            'dart:foobar': '$testDirectory/checker/dart_foobar.dart'
+          }));
 
   group('function modifiers', () {
-    test('async', () => testChecker({
-      '/main.dart': '''
+    test(
+        'async',
+        () => testChecker({
+              '/main.dart': '''
         import 'dart:async';
         import 'dart:math' show Random;
 
         dynamic x;
 
         foo1() async => x;
         Future foo2() async => x;
         Future<int> foo3() async => (/*info:DynamicCast*/x);
         Future<int> foo4() async => (/*severe:StaticTypeError*/new Future<int>.value(/*info:DynamicCast*/x));
 
@@ skipping 14 matching lines @@
 
         Future<bool> get issue_264 async {
           await 42;
           if (new Random().nextBool()) {
             return true;
           } else {
             return /*severe:StaticTypeError*/new Future<bool>.value(false);
           }
         }
     '''
-    }));
+            }));
 
-    test('async*', () => testChecker({
-      '/main.dart': '''
+    test(
+        'async*',
+        () => testChecker({
+              '/main.dart': '''
         import 'dart:async';
 
         dynamic x;
 
         bar1() async* { yield x; }
         Stream bar2() async* { yield x; }
         Stream<int> bar3() async* { yield (/*info:DynamicCast*/x); }
         Stream<int> bar4() async* { yield (/*severe:StaticTypeError*/new Stream<int>()); }
 
         baz1() async* { yield* (/*info:DynamicCast*/x); }
         Stream baz2() async* { yield* (/*info:DynamicCast*/x); }
         Stream<int> baz3() async* { yield* (/*warning:DownCastComposite*/x); }
         Stream<int> baz4() async* { yield* new Stream<int>(); }
         Stream<int> baz5() async* { yield* (/*info:InferredTypeAllocation*/new Stream()); }
     '''
-    }));
+            }));
 
-    test('sync*', () => testChecker({
-      '/main.dart': '''
+    test(
+        'sync*',
+        () => testChecker({
+              '/main.dart': '''
         import 'dart:async';
 
         dynamic x;
 
         bar1() sync* { yield x; }
         Iterable bar2() sync* { yield x; }
         Iterable<int> bar3() sync* { yield (/*info:DynamicCast*/x); }
         Iterable<int> bar4() sync* { yield (/*severe:StaticTypeError*/new Iterable<int>()); }
 
         baz1() sync* { yield* (/*info:DynamicCast*/x); }
         Iterable baz2() sync* { yield* (/*info:DynamicCast*/x); }
         Iterable<int> baz3() sync* { yield* (/*warning:DownCastComposite*/x); }
         Iterable<int> baz4() sync* { yield* new Iterable<int>(); }
         Iterable<int> baz5() sync* { yield* (/*info:InferredTypeAllocation*/new Iterable()); }
     '''
-    }));
+            }));
   });
 }