Revert "Fix observatory tests broken by running dartfmt."

runtime/tests/vm/dart/random_walk_fuzzer.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.
 
 // Random-walk fuzzer for the Dart VM.
 //
 // Start with all the classes and libraries and various interesting values.
 // Repeatedly choose one as a receiver, construct a message it is likely to
 // understand, send the message, and add the result.
 //
@@ skipping 29 matching lines @@
     // When running on many machines in parallel, the current time alone
     // is a poor choice of seed.
     seed = 0;
     try {
       var f = new File("/dev/urandom").openSync();
       seed = (seed << 8) | f.readByteSync();
       seed = (seed << 8) | f.readByteSync();
       seed = (seed << 8) | f.readByteSync();
       seed = (seed << 8) | f.readByteSync();
       f.close();
-    } catch (e) {
+    } catch(e) {
       print("Failed to read from /dev/urandom: $e");
     }
 
     seed ^= new DateTime.now().millisecondsSinceEpoch;
     seed &= 0xFFFFFFFF;
   }
   random = new Random(seed);
 
   // Information needed to reproduce this run.
   print("Dart VM fuzzer");
@@ skipping 40 matching lines @@
 List<Candidate<ObjectMirror>> candidateReceivers =
     new List<Candidate<ObjectMirror>>();
 List<Candidate<InstanceMirror>> candidateArguments =
     new List<Candidate<InstanceMirror>>();
 
 void addInstance(var instance) {
   addInstanceMirror(reflect(instance));
 }
 
 void addInstanceMirror(InstanceMirror mirror,
-    [Candidate origin, String message]) {
+                       [Candidate origin, String message]) {
   var c = new Candidate<InstanceMirror>();
   c.mirror = mirror;
   c.origin = origin;
   c.message = message;
 
   candidateReceivers.add(c);
   candidateArguments.add(c);
 }
 
 void addObjectMirror(ObjectMirror mirror) {
@@ skipping 41 matching lines @@
   addInstance(-1.0);
   addInstance(0.0);
   addInstance(1.0);
   addInstance(2.0);
   addInstance(double.NAN);
   addInstance(double.INFINITY);
   addInstance(double.NEGATIVE_INFINITY);
   addInstance(double.MIN_POSITIVE);
   addInstance(double.MAX_FINITE);
 
-  addInstance("foo"); // ASCII string
-  addInstance("blåbærgrød"); // Latin1 string
-  addInstance("Îñţérñåţîöñåļîžåţîờñ"); // Unicode string
-  addInstance("𝄞"); // Surrogate pairs
-  addInstance("𝄞"[0]); // Surrogate pairs
-  addInstance("𝄞"[1]); // Surrogate pairs
-  addInstance("\u{0}"); // Non-printing charater
-  addInstance("\u{1}"); // Non-printing charater
-  addInstance("f\u{0}oo"); // Internal NUL
-  addInstance("blåbæ\u{0}rgrød"); // Internal NUL
-  addInstance("Îñţérñåţîö\u{0}ñåļîžåţîờñ"); // Internal NUL
-  addInstance("\u{0}𝄞"); // Internal NUL
+  addInstance("foo");  // ASCII string
+  addInstance("blåbærgrød");  // Latin1 string
+  addInstance("Îñţérñåţîöñåļîžåţîờñ");  // Unicode string
+  addInstance("𝄞");  // Surrogate pairs
+  addInstance("𝄞"[0]);  // Surrogate pairs
+  addInstance("𝄞"[1]);  // Surrogate pairs
+  addInstance("\u{0}");  // Non-printing charater
+  addInstance("\u{1}");  // Non-printing charater
+  addInstance("f\u{0}oo");  // Internal NUL
+  addInstance("blåbæ\u{0}rgrød");  // Internal NUL
+  addInstance("Îñţérñåţîö\u{0}ñåļîžåţîờñ");  // Internal NUL
+  addInstance("\u{0}𝄞");  // Internal NUL
 
   for (int len = 0; len < 8; len++) {
     addInstance(fillInt(new Int8List(len)));
     addInstance(fillInt(new Int16List(len)));
     addInstance(fillInt(new Int32List(len)));
     addInstance(fillInt(new Int64List(len)));
     addInstance(fillInt(new Uint8List(len)));
     addInstance(fillInt(new Uint16List(len)));
     addInstance(fillInt(new Uint32List(len)));
     addInstance(fillInt(new Uint64List(len)));
     addInstance(fillFloat(new Float32List(len)));
     addInstance(fillFloat(new Float64List(len)));
   }
 
   randomInstance(ignore) {
     return randomElementOf(candidateArguments).mirror.reflectee;
   }
-
   for (int len = 0; len < 8; len++) {
     addInstance(new List.generate(len, randomInstance));
   }
 }
 
 void fillInt(TypedData d) {
   for (var i = 0; i < d.length; i++) {
     d[i] = random.nextInt(0xFFFFFFFF);
   }
 }
 
 void fillFloat(TypedData d) {
   for (var i = 0; i < d.length; i++) {
     d[i] = random.nextDouble();
   }
 }
 
 void setupClasses() {
   currentMirrorSystem().libraries.values.forEach((lib) {
-    if (lib.simpleName == #fuzzer) return; // Don't recurse.
+    if (lib.simpleName == #fuzzer) return;  // Don't recurse.
     addObjectMirror(lib);
     lib.declarations.values.forEach((decl) {
       if (decl is ClassMirror) {
         addObjectMirror(decl);
       }
     });
   });
 }
 
 MethodMirror randomMethodOf(receiver) {
   if (receiver is ClassMirror) {
-    return randomElementOf(receiver.declarations.values
-        .where((d) => d is MethodMirror && d.isStatic)
-        .toList());
+    return randomElementOf(receiver.declarations.values.where(
+        (d) => d is MethodMirror && d.isStatic).toList());
   } else if (receiver is LibraryMirror) {
-    return randomElementOf(
-        receiver.declarations.values.where((d) => d is MethodMirror).toList());
+    return randomElementOf(receiver.declarations.values.where(
+        (d) => d is MethodMirror).toList());
   } else if (receiver is InstanceMirror) {
     var methods = [];
     var cls = receiver.type;
     while (cls != reflectClass(Object)) {
       cls.declarations.values.forEach((d) {
         if (d is MethodMirror && !d.isStatic) methods.add(d);
       });
       cls = cls.superclass;
     }
     return randomElementOf(methods);
@@ skipping 28 matching lines @@
 
   String message = prettyMessageName(receiver, method);
   if (trace) {
     c.trace();
     print(message);
   }
 
   if (method.isConstructor) {
     try {
       result = receiver.newInstance(method.simpleName, positional, named);
-    } catch (e) {}
+    } catch(e) {}
   } else if (method.isRegularMethod) {
     try {
       result = receiver.invoke(method.simpleName, positional, named);
-    } catch (e) {}
+    } catch(e) {}
   } else if (method.isGetter) {
     try {
       result = receiver.getField(method.simpleName);
-    } catch (e) {}
+    } catch(e) {}
   } else if (method.isSetter) {
     try {
       result = receiver.setField(method.simpleName, positional[0]);
-    } catch (e) {}
+    } catch(e) {}
   }
 
   if (result != null) {
     addInstanceMirror(result, c, message);
   }
 }
 
 InstanceMirror randomArgumentWithBias(TypeMirror bias) {
   if (maybe(0.75)) {
     for (var candidate in candidateArguments) {
@@ skipping 23 matching lines @@
     if (p.isNamed && maybe(0.5)) {
       result[p.simpleName] = randomArgumentWithBias(p.type);
     }
   }
 
   return result;
 }
 
 void garbageCollect() {
   // Chain a bunch of moderately sized arrays, then let go of them. Using a
-  // moderate size avoids our allocations going directly to a large object
+  // moderate size avoids our allocations going directly to a large object 
   // page in old space.
   var n;
   for (int i = 0; i < 2048; i++) {
     var m = new List(512);
     m[0] = n;
     n = m;
   }
 }