Format and sort analyzer and analysis_server packages.

pkg/analyzer/test/generated/test_support.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 code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.test_support;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/ast.dart' show AstNode, NodeLocator;
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:unittest/unittest.dart';
 
 
 /**
  * The class `EngineTestCase` defines utility methods for making assertions.
  */
 class EngineTestCase {
-  void setUp() {}
-
-  void tearDown() {}
-
   /**
    * Assert that the given collection has the same number of elements as the number of specified
    * names, and that for each specified name, a corresponding element can be found in the given
    * collection with that name.
    *
    * @param elements the elements
    * @param names the names
    */
   void assertNamedElements(List<Element> elements, List<String> names) {
     for (String elemName in names) {
@@ skipping 52 matching lines @@
   MethodElement getMethod(InterfaceType type, String methodName) {
     for (MethodElement method in type.element.methods) {
       if (method.name == methodName) {
         return method;
       }
     }
     fail("Could not find method named $methodName in ${type.displayName}");
     return null;
   }
 
+  void setUp() {}
+
+  void tearDown() {}
+
   /**
    * Assert that the given object is an instance of the expected class.
    *
    * @param expectedClass the class that the object is expected to be an instance of
    * @param object the object being tested
    * @return the object that was being tested
    * @throws Exception if the object is not an instance of the expected class
    */
   static Object assertInstanceOf(Predicate<Object> predicate,
       Type expectedClass, Object object) {
     if (!predicate(object)) {
-      fail("Expected instance of $expectedClass, found ${object == null ? "null" : object.runtimeType}");
+      fail(
+          "Expected instance of $expectedClass, found ${object == null ? "null" : object.runtimeType}");
     }
     return object;
   }
 
   /**
    * @return the [AstNode] with requested type at offset of the "prefix".
    */
   static AstNode findNode(AstNode root, String code, String prefix,
       Predicate<AstNode> predicate) {
     int offset = code.indexOf(prefix);
@@ skipping 90 matching lines @@
 
   /**
    * Assert that the number of errors that have been gathered matches the number of errors that are
    * given and that they have the expected error codes. The order in which the errors were gathered
    * is ignored.
    *
    * @param expectedErrorCodes the error codes of the errors that should have been gathered
    * @throws AssertionFailedError if a different number of errors have been gathered than were
    *           expected
    */
-  void assertErrorsWithCodes([List<ErrorCode> expectedErrorCodes = ErrorCode.EMPTY_LIST]) {
+  void assertErrorsWithCodes([List<ErrorCode> expectedErrorCodes =
+      ErrorCode.EMPTY_LIST]) {
     StringBuffer buffer = new StringBuffer();
     //
     // Verify that the expected error codes have a non-empty message.
     //
     for (ErrorCode errorCode in expectedErrorCodes) {
-      expect(errorCode.message.isEmpty, isFalse, reason: "Empty error code message");
+      expect(
+          errorCode.message.isEmpty,
+          isFalse,
+          reason: "Empty error code message");
     }
     //
     // Compute the expected number of each type of error.
     //
     HashMap<ErrorCode, int> expectedCounts = new HashMap<ErrorCode, int>();
     for (ErrorCode code in expectedErrorCodes) {
       int count = expectedCounts[code];
       if (count == null) {
         count = 1;
       } else {
@@ skipping 92 matching lines @@
     int actualWarningCount = 0;
     for (AnalysisError error in _errors) {
       if (error.errorCode.errorSeverity == ErrorSeverity.ERROR) {
         actualErrorCount++;
       } else {
         actualWarningCount++;
       }
     }
     if (expectedErrorCount != actualErrorCount ||
         expectedWarningCount != actualWarningCount) {
-      fail("Expected $expectedErrorCount errors and $expectedWarningCount warnings, found $actualErrorCount errors and $actualWarningCount warnings");
+      fail(
+          "Expected $expectedErrorCount errors and $expectedWarningCount warnings, found $actualErrorCount errors and $actualWarningCount warnings");
     }
   }
 
   /**
    * Assert that no errors have been gathered.
    *
    * @throws AssertionFailedError if any errors have been gathered
    */
   void assertNoErrors() {
     assertErrors(_NO_ERRORS);
@@ skipping 220 matching lines @@
   TestSource([this._name = '/test.dart', this._contents]);
 
   TimestampedData<String> get contents {
     readCount++;
     if (generateExceptionOnRead) {
       String msg = "I/O Exception while getting the contents of " + _name;
       throw new Exception(msg);
     }
     return new TimestampedData<String>(0, _contents);
   }
-  void setContents(String value) {
-    modificationStamp = new DateTime.now().millisecondsSinceEpoch;
-    _contents = value;
-  }
   String get encoding {
     throw new UnsupportedOperationException();
   }
   String get fullName {
     return _name;
   }
   int get hashCode => 0;
   bool get isInSystemLibrary {
     return false;
   }
@@ skipping 15 matching lines @@
   bool exists() => exists2;
   void getContentsToReceiver(Source_ContentReceiver receiver) {
     throw new UnsupportedOperationException();
   }
   Source resolve(String uri) {
     throw new UnsupportedOperationException();
   }
   Uri resolveRelativeUri(Uri uri) {
     return new Uri(scheme: 'file', path: _name).resolveUri(uri);
   }
+  void setContents(String value) {
+    modificationStamp = new DateTime.now().millisecondsSinceEpoch;
+    _contents = value;
+  }
 }