dart2js: run dartfmt on tests

tests/compiler/dart2js_extra/js_array_index_error_test.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.
 
 // Test that optimized JSArray indexers enerate the same error as dyncamically
 // dispatched calls.
 
-
 import 'package:expect/expect.dart';
 
-@NoInline() @AssumeDynamic()
+@NoInline()
+@AssumeDynamic()
 confuse(x) => x;
 
-
 Error getError(action(), name, part) {
   try {
     action();
   } catch (e) {
     return e;
   }
   Expect.fail('must throw: $name: $part');
 }
 
 indexErrorContainsIndex() {
   makeFault(i) => () => confuse([])[i];
 
   var name = 'index error contains index';
   var e1 = getError(makeFault(1234), name, 'small');
   var e2 = getError(makeFault(1234000), name, 'medium');
   var e3 = getError(makeFault(1234000000000), name, 'large');
 
   Expect.equals('$e1', '$e2'.replaceAll('000', ''));
   Expect.equals('$e1', '$e3'.replaceAll('000', ''));
   Expect.equals('$e1'.length + 3, '$e2'.length);
   Expect.equals('$e1'.length + 9, '$e3'.length);
 }
 
-
 compare(name, fault1(), fault2(), fault3()) {
   var e1 = getError(fault1, name, 'fault1');
   var e2 = getError(fault2, name, 'fault2');
   var e3 = getError(fault3, name, 'fault3');
 
   Expect.equals('$e1', '$e2', '$name: fault1 vs fault2');
   Expect.equals('$e1', '$e3', '$name: fault1 vs fault3');
 }
 
 // These tests are a bit tedious and avoid common helpers with higher order
@@ skipping 38 matching lines @@
     var a = [];
     while (confuse(false)) a.add(1);
     return a[HUGE];
   }
 
   fault3() {
     var a = confuse([]);
     return [a[HUGE], a[1], a[2]];
   }
 
-  compare('constant index on empty list with huge index',
-      fault1, fault2, fault3);
+  compare(
+      'constant index on empty list with huge index', fault1, fault2, fault3);
 }
 
 constantIndexNonempty() {
   // Single dynamic receiver indexing might go via one-shot interceptor that
   // might have an accelerated path.
   fault1() => confuse([1])[1];
 
   fault2() {
     var a = [1];
     while (confuse(false)) a.add(1);
@@ skipping 21 matching lines @@
     // Easily inferred type and open coded indexer.
     return a[HUGE];
   }
 
   fault3() {
     var a = confuse([1]);
     // Multiple indexing might go via shared interceptor.
     return [a[HUGE], a[1], a[2]];
   }
 
-  compare('constant index on non-empty list with huge index',
-      fault1, fault2, fault3);
+  compare('constant index on non-empty list with huge index', fault1, fault2,
+      fault3);
 }
 
 constantIndexSetEmpty() {
   fault1() {
     // Single dynamic receiver indexing might go via one-shot interceptor that
     // might have an accelerated path.
     confuse([])[0] = 0;
   }
 
   fault2() {
@@ skipping 36 matching lines @@
     // Multiple indexing might go via shared interceptor.
     a[0] = 0;
     a[1] = 0;
     a[2] = 0;
     return a;
   }
 
   compare('constant index-set on non-empty list', fault1, fault2, fault3);
 }
 
-
 variableIndexEmpty(index, qualifier) {
   // Single dynamic receiver indexing might go via one-shot interceptor that
   // might have an accelerated path.
   fault1() => confuse([])[index];
 
   fault2() {
     var a = [];
     while (confuse(false)) a.add(1);
     // Easily inferred type and open coded indexer.
     return a[index];
@@ skipping 19 matching lines @@
     // Easily inferred type and open coded indexer.
     return a[index];
   }
 
   fault3() {
     var a = confuse([1]);
     // Multiple indexing might go via shared interceptor.
     return [a[index], a[1], a[2]];
   }
 
-  compare('variable index on non-empty list $qualifier',
-      fault1, fault2, fault3);
+  compare(
+      'variable index on non-empty list $qualifier', fault1, fault2, fault3);
 }
 
 variableIndexSetEmpty(index, qualifier) {
   fault1() {
     var a = confuse([]);
     // Single dynamic receiver indexing might go via one-shot interceptor that
     // might have an accelerated path.
     a[index] = 1;
     return a;
   }
 
   fault2() {
     var a = [];
     while (confuse(false)) a.add(1);
     // Easily inferred type and open coded indexer.
     a[index] = 1;
     return a;
   }
 
   fault3() {
     var a = confuse([]);
     // Multiple indexing might go via shared interceptor.
     a[index] = 1;
     a[2] = 2;
     a[3] = 3;
     return a;
   }
 
-  compare('variable index-set on empty list $qualifier',
-      fault1, fault2, fault3);
+  compare(
+      'variable index-set on empty list $qualifier', fault1, fault2, fault3);
 }
 
 variableIndexSetNonempty(index, qualifier) {
   fault1() {
     var a = confuse([1]);
     // Single dynamic receiver indexing might go via one-shot interceptor that
     // might have an accelerated path.
     a[index] = 1;
     return a;
   }
 
   fault2() {
     var a = [1];
     while (confuse(false)) a.add(1);
     // Easily inferred type and open coded indexer.
     a[index] = 1;
     return a;
   }
 
   fault3() {
     var a = confuse([1]);
     // Multiple indexing might go via shared interceptor.
     a[index] = 1;
     a[2] = 2;
     a[3] = 3;
     return a;
   }
 
-  compare('variable index-set on non-empty list $qualifier',
-      fault1, fault2, fault3);
+  compare('variable index-set on non-empty list $qualifier', fault1, fault2,
+      fault3);
 }
 
-
 main() {
   indexErrorContainsIndex();
 
   constantIndexEmpty();
   constantIndexHugeEmpty();
   constantIndexNonempty();
   constantIndexHugeNonempty();
   constantIndexSetEmpty();
   constantIndexSetNonempty();
 
   variableIndexEmpty(0, 'zero index');
   variableIndexEmpty(10, 'small index');
   variableIndexEmpty(-1, 'negative index');
   variableIndexEmpty(HUGE, 'huge index');
 
   variableIndexNonempty(10, 'small index');
   variableIndexNonempty(-1, 'negative index');
   variableIndexNonempty(HUGE, 'huge index');
 
   variableIndexSetEmpty(0, 'zero index');
   variableIndexSetEmpty(10, 'small index');
   variableIndexSetEmpty(-1, 'negative index');
   variableIndexSetEmpty(HUGE, 'huge index');
 
   variableIndexSetNonempty(10, 'small index');
   variableIndexSetNonempty(-1, 'negative index');
   variableIndexSetNonempty(HUGE, 'huge index');
 }