dart2js: run dartfmt on tests

tests/compiler/dart2js/mock_libraries.dart

 // Copyright (c) 2014, 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 for creating mock versions of platform and internal libraries.
 
 library mock_libraries;
 
 const DEFAULT_PLATFORM_CONFIG = """
 [libraries]
 core:core/core.dart
 async:async/async.dart
 _js_helper:_internal/js_runtime/lib/js_helper.dart
 _interceptors:_internal/js_runtime/lib/interceptors.dart
 _isolate_helper:_internal/js_runtime/lib/isolate_helper.dart
 """;
 
-String buildLibrarySource(
-    Map<String, String> elementMap,
+String buildLibrarySource(Map<String, String> elementMap,
     [Map<String, String> additionalElementMap = const <String, String>{}]) {
   Map<String, String> map = new Map<String, String>.from(elementMap);
   if (additionalElementMap != null) {
     map.addAll(additionalElementMap);
   }
   StringBuffer sb = new StringBuffer();
   map.values.forEach((String element) {
     sb.write('$element\n');
   });
   return sb.toString();
 }
 
 const Map<String, String> DEFAULT_CORE_LIBRARY = const <String, String>{
   'bool': 'class bool {}',
   'Comparator': 'abstract class Comparator<T> {}',
   'DateTime': r'''
       class DateTime {
         DateTime(year);
         DateTime.utc(year);
       }''',
-      'Deprecated': r'''
+  'Deprecated': r'''
       class Deprecated extends Object {
         final String expires;
         const Deprecated(this.expires);
       }''',
   'deprecated': 'const Object deprecated = const Deprecated("next release");',
   'double': r'''
       abstract class double extends num {
         static var NAN = 0;
         static parse(s) {}
       }''',
@@ skipping 80 matching lines @@
   'boolConversionCheck': 'boolConversionCheck(x) {}',
   'boolTypeCast': 'boolTypeCast(value) {}',
   'boolTypeCheck': 'boolTypeCheck(value) {}',
   'checkSubtype': 'checkSubtype(object, isField, checks, asField) {}',
   'checkSubtypeOfRuntimeType': 'checkSubtypeOfRuntimeType(o, t) {}',
   'BoundClosure': r'''abstract class BoundClosure extends Closure {
     var self;
     var target;
     var receiver;
   }''',
-  'buildFunctionType':
-      r'''buildFunctionType(returnType, parameterTypes,
+  'buildFunctionType': r'''buildFunctionType(returnType, parameterTypes,
                             optionalParameterTypes) {
             return new RuntimeFunctionType();
           }''',
   'buildInterfaceType': '''buildInterfaceType(rti, typeArguments) {
                              if (rti == null) return new RuntimeTypePlain();
                              return new RuntimeTypeGeneric();
                            }''',
   'buildNamedFunctionType':
       r'''buildNamedFunctionType(returnType, parameterTypes,
                                  namedParameters) {
@@ skipping 104 matching lines @@
     final Type owner;
     final String name;
     final int bound;
     const TypeVariable(this.owner, this.name, this.bound);
   }''',
   'unwrapException': 'unwrapException(e) {}',
   'voidTypeCheck': 'voidTypeCheck(value) {}',
   'wrapException': 'wrapException(x) { return x; }',
   'badMain': 'badMain() { throw "bad main"; }',
   'missingMain': 'missingMain() { throw "missing main"; }',
-  'mainHasTooManyParameters':
-      'mainHasTooManyParameters() '
+  'mainHasTooManyParameters': 'mainHasTooManyParameters() '
       '{ throw "main has too many parameters"; }',
 };
 
-const Map<String, String> DEFAULT_FOREIGN_HELPER_LIBRARY
-    = const <String, String>{
+const Map<String, String> DEFAULT_FOREIGN_HELPER_LIBRARY =
+    const <String, String>{
   'JS': r'''
       dynamic JS(String typeDescription, String codeTemplate,
         [var arg0, var arg1, var arg2, var arg3, var arg4, var arg5, var arg6,
          var arg7, var arg8, var arg9, var arg10, var arg11]) {}''',
 };
 
 const Map<String, String> DEFAULT_INTERCEPTORS_LIBRARY = const <String, String>{
-  'findIndexForNativeSubclassType':
-      'findIndexForNativeSubclassType(type) {}',
+  'findIndexForNativeSubclassType': 'findIndexForNativeSubclassType(type) {}',
   'getDispatchProperty': 'getDispatchProperty(o) {}',
   'getInterceptor': 'getInterceptor(x) {}',
   'getNativeInterceptor': 'getNativeInterceptor(x) {}',
   'initializeDispatchProperty': 'initializeDispatchProperty(f,p,i) {}',
   'initializeDispatchPropertyCSP': 'initializeDispatchPropertyCSP(f,p,i) {}',
   'Interceptor': r'''
       class Interceptor {
         toString() {}
         bool operator==(other) => identical(this, other);
         get hashCode => throw "Interceptor.hashCode not implemented.";
@@ skipping 27 matching lines @@
       abstract class JSIndexable {
         get length;
         operator[](index);
       }''',
   'JSInt': r'''
        class JSInt extends JSNumber implements int {
          operator~() => this;
        }''',
   'JSMutableArray':
       'class JSMutableArray extends JSArray implements JSMutableIndexable {}',
-  'JSUnmodifiableArray':
-      'class JSUnmodifiableArray extends JSArray {}',
+  'JSUnmodifiableArray': 'class JSUnmodifiableArray extends JSArray {}',
   'JSMutableIndexable':
       'abstract class JSMutableIndexable extends JSIndexable {}',
-      'JSPositiveInt': 'class JSPositiveInt extends JSInt {}',
+  'JSPositiveInt': 'class JSPositiveInt extends JSInt {}',
   'JSNull': r'''
       class JSNull extends Interceptor {
         bool operator==(other) => identical(null, other);
         get hashCode => throw "JSNull.hashCode not implemented.";
         String toString() => 'Null';
         Type get runtimeType => null;
         noSuchMethod(x) => super.noSuchMethod(x);
       }''',
   'JSNumber': r'''
       class JSNumber extends Interceptor implements num {
@@ skipping 57 matching lines @@
 const Map<String, String> DEFAULT_ISOLATE_HELPER_LIBRARY =
     const <String, String>{
   'startRootIsolate': 'void startRootIsolate(entry, args) {}',
   '_currentIsolate': 'var _currentIsolate;',
   '_callInIsolate': 'var _callInIsolate;',
   '_WorkerBase': 'class _WorkerBase {}',
 };
 
 const Map<String, String> DEFAULT_ASYNC_LIBRARY = const <String, String>{
   'DeferredLibrary': 'class DeferredLibrary {}',
-  'Future':
-      '''
+  'Future': '''
       class Future<T> {
         Future.value([value]);
       }
       ''',
   'Stream': 'class Stream<T> {}',
   'Completer': 'class Completer<T> {}',
   'StreamIterator': 'class StreamIterator<T> {}',
 };
 
 /// These members are only needed when async/await is used.
@@ skipping 35 matching lines @@
 
     const LookupMap(this._entries, [this._nestedMaps = const []])
         : _key = null, _value = null;
 
     const LookupMap.pair(this._key, this._value)
         : _entries = const [], _nestedMaps = const [];
     V operator[](K k) => null;
   }''',
   '_version': 'const _version = "0.0.1+1";',
 };