Format and sort analyzer and analysis_server packages.

pkg/analysis_server/test/protocol_server_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.
 
 library test.computer.element;
 
 import 'dart:mirrors';
 
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/protocol_server.dart';
@@ skipping 256 matching lines @@
       expect(location.offset, 20);
       expect(location.length, 'myConstructor'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 11);
     }
     expect(element.parameters, '(int a, [String b])');
     expect(element.returnType, 'A');
     expect(element.flags, Element.FLAG_CONST);
   }
 
+  void test_fromElement_dynamic() {
+    var engineElement = engine.DynamicElementImpl.instance;
+    // create notification Element
+    Element element = newElement_fromEngine(engineElement);
+    expect(element.kind, ElementKind.UNKNOWN);
+    expect(element.name, 'dynamic');
+    expect(element.location, isNull);
+    expect(element.parameters, isNull);
+    expect(element.returnType, isNull);
+    expect(element.flags, 0);
+  }
+
   void test_fromElement_FIELD() {
     engine.Source source = addSource('/test.dart', '''
 class A {
   static const myField = 42;
 }''');
     engine.CompilationUnit unit = resolveLibraryUnit(source);
     engine.FieldElement engineElement = findElementInUnit(unit, 'myField');
     // create notification Element
     Element element = newElement_fromEngine(engineElement);
     expect(element.kind, ElementKind.FIELD);
@@ skipping 107 matching lines @@
       expect(location.file, '/test.dart');
       expect(location.offset, 16);
       expect(location.length, 'mySetter'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 7);
     }
     expect(element.parameters, '(String x)');
     expect(element.returnType, isNull);
     expect(element.flags, 0);
   }
-
-  void test_fromElement_dynamic() {
-    var engineElement = engine.DynamicElementImpl.instance;
-    // create notification Element
-    Element element = newElement_fromEngine(engineElement);
-    expect(element.kind, ElementKind.UNKNOWN);
-    expect(element.name, 'dynamic');
-    expect(element.location, isNull);
-    expect(element.parameters, isNull);
-    expect(element.returnType, isNull);
-    expect(element.flags, 0);
-  }
 }
 
-/**
- * Helper class for testing the correspondence between an analysis engine enum
- * and an analysis server API enum.
- */
-class EnumTester<EngineEnum, ApiEnum extends Enum> {
-  /**
-   * Test that the function [convert] properly converts all possible values of
-   * [EngineEnum] to an [ApiEnum] with the same name, with the exceptions noted
-   * in [exceptions].  For each key in [exceptions], if the corresponding value
-   * is null, then we check that converting the given key results in an error.
-   * If the corresponding value is an [ApiEnum], then we check that converting
-   * the given key results in the given value.
-   */
-  void run(ApiEnum convert(EngineEnum value), {Map<EngineEnum,
-      ApiEnum> exceptions: const {}}) {
-    ClassMirror engineClass = reflectClass(EngineEnum);
-    engineClass.staticMembers.forEach((Symbol symbol, MethodMirror method) {
-      if (symbol == #values) {
-        return;
-      }
-      if (!method.isGetter) {
-        return;
-      }
-      String enumName = MirrorSystem.getName(symbol);
-      EngineEnum engineValue = engineClass.getField(symbol).reflectee;
-      expect(engineValue, new isInstanceOf<EngineEnum>());
-      if (exceptions.containsKey(engineValue)) {
-        ApiEnum expectedResult = exceptions[engineValue];
-        if (expectedResult == null) {
-          expect(() {
-            convert(engineValue);
-          }, throws);
-        } else {
-          ApiEnum apiValue = convert(engineValue);
-          expect(apiValue, equals(expectedResult));
-        }
-      } else {
-        ApiEnum apiValue = convert(engineValue);
-        expect(apiValue.name, equals(enumName));
-      }
-    });
-  }
-}
-
-
 @ReflectiveTestCase()
 class EnumTest {
   void test_AnalysisErrorSeverity() {
     new EnumTester<engine.ErrorSeverity, AnalysisErrorSeverity>().run(
         (engine.ErrorSeverity engineErrorSeverity) =>
             new AnalysisErrorSeverity(engineErrorSeverity.name),
         exceptions: {
       engine.ErrorSeverity.NONE: null
     });
   }
@@ skipping 31 matching lines @@
       engine.ElementKind.UNIVERSE: ElementKind.UNKNOWN
     });
   }
 
   void test_SearchResultKind() {
     // TODO(paulberry): why does the MatchKind class exist at all?  Can't we
     // use SearchResultKind inside the analysis server?
     new EnumTester<MatchKind, SearchResultKind>().run(
         newSearchResultKind_fromEngine,
         exceptions: {
-          // TODO(paulberry): do any of the exceptions below constitute bugs?
-          MatchKind.ANGULAR_REFERENCE: SearchResultKind.UNKNOWN,
-          MatchKind.ANGULAR_CLOSING_TAG_REFERENCE: SearchResultKind.UNKNOWN
-        });
+      // TODO(paulberry): do any of the exceptions below constitute bugs?
+      MatchKind.ANGULAR_REFERENCE: SearchResultKind.UNKNOWN,
+      MatchKind.ANGULAR_CLOSING_TAG_REFERENCE: SearchResultKind.UNKNOWN
+    });
   }
 }
+
+
+/**
+ * Helper class for testing the correspondence between an analysis engine enum
+ * and an analysis server API enum.
+ */
+class EnumTester<EngineEnum, ApiEnum extends Enum> {
+  /**
+   * Test that the function [convert] properly converts all possible values of
+   * [EngineEnum] to an [ApiEnum] with the same name, with the exceptions noted
+   * in [exceptions].  For each key in [exceptions], if the corresponding value
+   * is null, then we check that converting the given key results in an error.
+   * If the corresponding value is an [ApiEnum], then we check that converting
+   * the given key results in the given value.
+   */
+  void run(ApiEnum convert(EngineEnum value), {Map<EngineEnum,
+      ApiEnum> exceptions: const {}}) {
+    ClassMirror engineClass = reflectClass(EngineEnum);
+    engineClass.staticMembers.forEach((Symbol symbol, MethodMirror method) {
+      if (symbol == #values) {
+        return;
+      }
+      if (!method.isGetter) {
+        return;
+      }
+      String enumName = MirrorSystem.getName(symbol);
+      EngineEnum engineValue = engineClass.getField(symbol).reflectee;
+      expect(engineValue, new isInstanceOf<EngineEnum>());
+      if (exceptions.containsKey(engineValue)) {
+        ApiEnum expectedResult = exceptions[engineValue];
+        if (expectedResult == null) {
+          expect(() {
+            convert(engineValue);
+          }, throws);
+        } else {
+          ApiEnum apiValue = convert(engineValue);
+          expect(apiValue, equals(expectedResult));
+        }
+      } else {
+        ApiEnum apiValue = convert(engineValue);
+        expect(apiValue.name, equals(enumName));
+      }
+    });
+  }
+}