format with dart_style 0.2.0-rc.3

test/testing.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 dev_compiler.src.testing;
 
 import 'dart:mirrors';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 10 matching lines @@
 import 'package:dev_compiler/strong_mode.dart';
 import 'package:dev_compiler/src/analysis_context.dart';
 
 import 'package:dev_compiler/src/server/dependency_graph.dart'
     show runtimeFilesForServerMode;
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart';
 import 'package:dev_compiler/src/utils.dart';
 
 /// Shared analysis context used for compilation.
-final realSdkContext = createAnalysisContextWithSources(new StrongModeOptions(),
+final realSdkContext = createAnalysisContextWithSources(
+    new StrongModeOptions(),
     new SourceResolverOptions(
         dartSdkPath: getSdkDir().path,
         customUrlMappings: {
-  'package:expect/expect.dart': _testCodegenPath('expect.dart'),
-  'package:async_helper/async_helper.dart':
-      _testCodegenPath('async_helper.dart'),
-  'package:unittest/unittest.dart': _testCodegenPath('unittest.dart'),
-  'package:dom/dom.dart': _testCodegenPath('sunflower', 'dom.dart')
-}))..analysisOptions = (new AnalysisOptionsImpl()..cacheSize = 512);
+          'package:expect/expect.dart': _testCodegenPath('expect.dart'),
+          'package:async_helper/async_helper.dart':
+              _testCodegenPath('async_helper.dart'),
+          'package:unittest/unittest.dart': _testCodegenPath('unittest.dart'),
+          'package:dom/dom.dart': _testCodegenPath('sunflower', 'dom.dart')
+        }))..analysisOptions = (new AnalysisOptionsImpl()..cacheSize = 512);
 
 String _testCodegenPath(String p1, [String p2]) =>
     path.join(testDirectory, 'codegen', p1, p2);
 
 final String testDirectory =
     path.dirname((reflectClass(_TestUtils).owner as LibraryMirror).uri.path);
 
 class _TestUtils {}
 
 /// Run the checker on a program with files contents as indicated in
@@ skipping 13 matching lines @@
 /// conversion, you can describe the test as follows:
 ///
 ///     testChecker({
 ///       '/main.dart': '''
 ///           testMethod() {
 ///             dynamic x = /*warning:Box*/3;
 ///           }
 ///       '''
 ///     });
 ///
-void testChecker(Map<String, String> testFiles, {String sdkDir,
-    customUrlMappings: const {}, relaxedCasts: true,
+void testChecker(Map<String, String> testFiles,
+    {String sdkDir,
+    customUrlMappings: const {},
+    relaxedCasts: true,
     inferDownwards: StrongModeOptions.inferDownwardsDefault,
     inferFromOverrides: StrongModeOptions.inferFromOverridesDefault,
     inferTransitively: StrongModeOptions.inferTransitivelyDefault,
     nonnullableTypes: StrongModeOptions.NONNULLABLE_TYPES}) {
   expect(testFiles.containsKey('/main.dart'), isTrue,
       reason: '`/main.dart` is missing in testFiles');
 
   var provider = createTestResourceProvider(testFiles);
   var uriResolver = new TestUriResolver(provider);
   var context = AnalysisEngine.instance.createAnalysisContext();
   context.sourceFactory = createSourceFactory(new SourceResolverOptions(
       customUrlMappings: customUrlMappings,
       useMockSdk: sdkDir == null,
       dartSdkPath: sdkDir), fileResolvers: [uriResolver]);
 
-  var checker = new StrongChecker(context, new StrongModeOptions(
-      relaxedCasts: relaxedCasts,
-      inferDownwards: inferDownwards,
-      inferFromOverrides: inferFromOverrides,
-      inferTransitively: inferTransitively,
-      nonnullableTypes: nonnullableTypes,
-      hints: true));
+  var checker = new StrongChecker(
+      context,
+      new StrongModeOptions(
+          relaxedCasts: relaxedCasts,
+          inferDownwards: inferDownwards,
+          inferFromOverrides: inferFromOverrides,
+          inferTransitively: inferTransitively,
+          nonnullableTypes: nonnullableTypes,
+          hints: true));
 
   // Run the checker on /main.dart.
   var mainSource = uriResolver.resolveAbsolute(new Uri.file('/main.dart'));
   var initialLibrary = context.resolveCompilationUnit2(mainSource, mainSource);
 
   // Extract expectations from the comments in the test files, and
   // check that all errors we emit are included in the expected map.
   var allLibraries = reachableLibraries(initialLibrary.element.library);
   for (var lib in allLibraries) {
     for (var unit in lib.units) {
@@ skipping 81 matching lines @@
               errors.map(_ErrorExpectation.parse).where((x) => x != null);
 
           for (var e in expectations) _expectError(node, e);
         }
       }
     }
     return super.visitNode(node);
   }
 
   void _expectError(AstNode node, _ErrorExpectation expected) {
-
     // See if we can find the expected error in our actual errors
     for (var actual in _actualErrors) {
       if (actual.offset == node.offset && actual.length == node.length) {
         var actualMsg = _formatActualError(actual);
         expect(_actualErrorLevel(actual), expected.level,
             reason: 'expected different error code at:\n\n$actualMsg');
         expect(errorCodeName(actual.errorCode), expected.typeName,
             reason: 'expected different error type at:\n\n$actualMsg');
 
         // We found it. Stop the search.
@@ skipping 58 matching lines @@
     expect(tokens[1], "should", reason: 'invalid error descriptor');
     expect(tokens[2], "be", reason: 'invalid error descriptor');
     if (tokens[0] == "pass") return null;
     // TODO(leafp) For now, we just use whatever the current expectation is,
     // eventually we could do more automated reporting here.
     return _parse(tokens[0]);
   }
 
   String toString() => '$level $typeName';
 }