Revert "Format all multitests"

tests/language/switch_case_warn_test.dart

 // Copyright (c) 2016, 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.
 // Test switch statement.
 
 // Tests some switch-case statements blocks that should and should not
 // cause static warnings.
 // This test is not testing runtime behavior, only static warnings.
 
 // None of the cases blocks should cause a warning.
 void testSwitch(int x) {
   // Catch all control flow leaving the switch.
   // Run switch in catch clause to check rethrow.
-  TRY:
-  try {
+  TRY: try {
     throw x;
   } catch (x) {
     // Add loop as break/continue target.
-    LOOP:
-    do {
+    LOOP: do {
       switch (x) {
         case 0:
         case 1:
           nop(x);
-          break; // Break switch.
+          break;  // Break switch.
         case 2:
           nop(x);
           break LOOP;
         case 3:
           nop(x);
-          continue; // Continue loop.
+          continue;  // Continue loop.
         case 4:
           nop(x);
           continue LOOP;
         case 5:
           nop(x);
           continue LAST;
         // Avoid warning for "return;"" and "return e;" in same function.
         case 6: //     //# retnon: ok
           nop(x); //   //# retnon: continued
           return; //   //# retnon: continued
         case 7: //     //# retval: ok
           nop(x); //   //# retval: continued
           return x; // //# retval: continued
         case 8:
           nop(x);
           throw x;
         case 9:
           nop(x);
           rethrow;
         case 10:
-        case 11:
-          {
-            nop(x);
-            break; // Break switch.
-          }
-        case 12:
-          {
-            nop(x);
-            break LOOP;
-          }
-        case 13:
-          {
-            nop(x);
-            continue; // Continue loop.
-          }
-        case 14:
-          {
-            nop(x);
-            continue LOOP;
-          }
-        case 15:
-          {
-            nop(x);
-            continue LAST;
-          }
+        case 11: {
+          nop(x);
+          break;  // Break switch.
+        }
+        case 12: {
+          nop(x);
+          break LOOP;
+        }
+        case 13: {
+          nop(x);
+          continue;  // Continue loop.
+        }
+        case 14: {
+          nop(x);
+          continue LOOP;
+        }
+        case 15: {
+          nop(x);
+          continue LAST;
+        }
         case 16: { //  //# retnon: continued
           nop(x); //   //# retnon: continued
           return; //   //# retnon: continued
         } //           //# retnon: continued
         case 17: { //  //# retval: continued
           nop(x); //   //# retval: continued
           return x; // //# retval: continued
         } //           //# retval: continued
-        case 18:
-          {
-            nop(x);
-            throw x;
-          }
-        case 19:
-          {
-            nop(x);
-            rethrow;
-          }
+        case 18: {
+          nop(x);
+          throw x;
+        }
+        case 19: {
+          nop(x);
+          rethrow;
+        }
         LAST:
-        case 20:
-          {
-            nop(x);
-            // Fallthrough allowed on last statements.
-          }
+        case 20: {
+          nop(x);
+          // Fallthrough allowed on last statements.
+        }
       }
     } while (false);
   } finally {
     // Catch all control flow leaving the switch and ignore it.
     // Use break instead of return to avoid warning for `return` and `return e`
     // in same function.
     break TRY;
   }
 }
 
 // All these switch cases should cause warnings.
 void testSwitchWarn(x) {
   // Catch all control flow from the switch and ignore it.
-  TRY:
-  try {
+  TRY: try {
     throw 0;
   } catch (e) {
     // Wrap in loop as target for continue/break.
-    LOOP:
-    do {
+    LOOP: do {
       switch (x) {
         case 0: //                         //# 01: static type warning
         case 1: { //                       //# 01: continued
           { //                             //# 01: continued
             nop(x); //                     //# 01: continued
             break;  // Break switch. //    //# 01: continued
           } //                             //# 01: continued
         } //                               //# 01: continued
         case 2: { //                       //# 02: static type warning
           { //                             //# 02: continued
@@ skipping 54 matching lines @@
         case 14: //                        //# 14: static type warning
           if (x) break; else break; //     //# 14: continued
         case 15: //                        //# 15: static type warning
           (throw 0); //                    //# 15: continued
         case 16: //                        //# 16: static type warning
           nop(x); //      fallthrough. //  //# 16: continued
         case 17: //                        //# 17: static type warning
           L: break; //                     //# 17: continued
         LAST:
         case 99:
-        // Last case can't cause static warning.
+          // Last case can't cause static warning.
       }
     } while (false);
   } finally {
     // Catch all control flow leaving the switch and ignore it.
     // Use break instead of return to avoid warning for `return` and `return e`
     // in same function.
     break TRY;
   }
 }
 
 main() {
   // Ensure that all the cases compile and run (even if they might throw).
   for (int i = 0; i <= 20; i++) {
-    testSwitch(i); // Just make sure it runs.
+    testSwitch(i);  // Just make sure it runs.
   }
   for (int i = 0; i <= 18; i++) {
     testSwitchWarn(i);
   }
 }
 
 /// Don't make it obvious that a switch case isn't doing anything.
 void nop(x) {}