Format all multitests

tests/lib/mirrors/invocation_fuzz_test.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.
 
 // This test reflectively enumerates all the methods in the system and tries to
 // invoke them with various basic values (nulls, ints, etc). This may result in
 // Dart exceptions or hangs, but should never result in crashes or JavaScript
 // exceptions.
 
 library test.invoke_natives;
@@ skipping 20 matching lines @@
 
   // Don't run blocking io calls.
   new RegExp(r".*Sync$"),
 
   // These prevent the test from exiting.
   'dart.io.sleep',
   'dart.io.HttpServer.HttpServer.listenOn',
 
   // These either cause the VM to segfault or throw uncatchable API errors.
   // TODO(15274): Fix them and remove from blacklist.
-  'dart.io.SystemEncoding.decode',  // Windows only
-  'dart.io.SystemEncoding.encode',  // Windows only
+  'dart.io.SystemEncoding.decode', // Windows only
+  'dart.io.SystemEncoding.encode', // Windows only
 
   // These construct an object with an uninitialized native field.
   // TODO(23869): We could make this safer, but making the failure non-fatal
   //   would we worthless aside from this test.
   'dart.io.X509Certificate.X509Certificate._',
   'dart.io._X509Impl._X509Impl',
 
   // Don't call private methods in dart.async as they may circumvent the zoned
   // error handling below.
   new RegExp(r"^dart\.async\._.*$"),
 
   'dart._internal.fatal',
 ];
 
 bool isBlacklisted(Symbol qualifiedSymbol) {
   var qualifiedString = MirrorSystem.getName(qualifiedSymbol);
   for (var pattern in blacklist) {
     if (qualifiedString.contains(pattern)) {
       print('Skipping $qualifiedString');
       return true;
     }
   }
   return false;
 }
 
 class Task {
   var name;
   var action;
 }
+
 var queue = new List();
 
 checkMethod(MethodMirror m, ObjectMirror target, [origin]) {
   if (isBlacklisted(m.qualifiedName)) return;
 
   var task = new Task();
   task.name = '${MirrorSystem.getName(m.qualifiedName)} from $origin';
 
   if (m.isRegularMethod) {
-    task.action =
-      () => target.invoke(m.simpleName,
-                          new List.filled(m.parameters.length, fuzzArgument));
+    task.action = () => target.invoke(
+        m.simpleName, new List.filled(m.parameters.length, fuzzArgument));
   } else if (m.isGetter) {
-    task.action =
-        () => target.getField(m.simpleName);
+    task.action = () => target.getField(m.simpleName);
   } else if (m.isSetter) {
-    task.action =
-        () => target.setField(m.simpleName, null);
+    task.action = () => target.setField(m.simpleName, null);
   } else if (m.isConstructor) {
     return;
   } else {
     throw "Unexpected method kind";
   }
 
   queue.add(task);
 }
 
 checkField(VariableMirror v, ObjectMirror target, [origin]) {
@@ skipping 26 matching lines @@
       .forEach((m) => checkMethod(m, classMirror));
 
   classMirror.declarations.values
       .where((d) => d is MethodMirror && d.isConstructor)
       .forEach((m) {
     if (isBlacklisted(m.qualifiedName)) return;
     var task = new Task();
     task.name = MirrorSystem.getName(m.qualifiedName);
 
     task.action = () {
-      var instance = classMirror.newInstance(
-          m.constructorName,
+      var instance = classMirror.newInstance(m.constructorName,
           new List.filled(m.parameters.length, fuzzArgument));
       checkInstance(instance, task.name);
     };
     queue.add(task);
   });
 }
 
 checkLibrary(libraryMirror) {
   print(libraryMirror.simpleName);
   if (isBlacklisted(libraryMirror.qualifiedName)) return;
@@ skipping 12 matching lines @@
 doOneTask() {
   if (queue.length == 0) {
     print('Done');
     return;
   }
 
   var task = queue.removeLast();
   print(task.name);
   try {
     task.action();
-  } catch(e) {}
+  } catch (e) {}
 
   // Register the next task in a timer callback so as to yield to async code
   // scheduled in the current task. This isn't necessary for the test itself,
   // but is helpful when trying to figure out which function is responsible for
   // a crash.
   testZone.createTimer(Duration.ZERO, doOneTask);
 }
 
 var fuzzArgument;
 
 main() {
   fuzzArgument = null;
   fuzzArgument = 1; // //# smi: ok
   fuzzArgument = false; // //# false: ok
   fuzzArgument = 'string'; // //# string: ok
   fuzzArgument = new List(0); // //# emptyarray: ok
 
   print('Fuzzing with $fuzzArgument');
 
   currentMirrorSystem().libraries.values.forEach(checkLibrary);
 
-  var valueObjects =
-    [true, false, null, [], {}, dynamic,
-     0, 0xEFFFFFF, 0xFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 3.14159, () {},
-     "foo", 'blåbærgrød', 'Îñţérñåţîöñåļîžåţîờñ', "\u{1D11E}", #symbol];
+  var valueObjects = [
+    true,
+    false,
+    null,
+    [],
+    {},
+    dynamic,
+    0,
+    0xEFFFFFF,
+    0xFFFFFFFF,
+    0xFFFFFFFFFFFFFFFF,
+    3.14159,
+    () {},
+    "foo",
+    'blåbærgrød',
+    'Îñţérñåţîöñåļîžåţîờñ',
+    "\u{1D11E}",
+    #symbol
+  ];
   valueObjects.forEach((v) => checkInstance(reflect(v), 'value object'));
 
-  uncaughtErrorHandler(self, parent, zone, error, stack) {};
+  uncaughtErrorHandler(self, parent, zone, error, stack) {}
+  ;
   var zoneSpec =
-     new ZoneSpecification(handleUncaughtError: uncaughtErrorHandler);
+      new ZoneSpecification(handleUncaughtError: uncaughtErrorHandler);
   testZone = Zone.current.fork(specification: zoneSpec);
   testZone.createTimer(Duration.ZERO, doOneTask);
 }