Test that analysis server and analysis engine enums properly match.

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';
+import 'package:analysis_server/src/services/search/search_engine.dart';
 import 'package:analyzer/src/generated/ast.dart' as engine;
 import 'package:analyzer/src/generated/element.dart' as engine;
 import 'package:analyzer/src/generated/error.dart' as engine;
 import 'package:analyzer/src/generated/source.dart' as engine;
 import 'package:typed_mock/typed_mock.dart';
 import 'package:unittest/unittest.dart';
 
 import 'abstract_context.dart';
 import 'mocks.dart';
 import 'reflective_tests.dart';
 
 
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(AnalysisErrorTest);
   runReflectiveTests(ElementTest);
   runReflectiveTests(ElementKindTest);
+  runReflectiveTests(EnumTest);
 }
 
 
 class AnalysisErrorMock extends TypedMock implements engine.AnalysisError {
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 
 @ReflectiveTestCase()
 class AnalysisErrorTest {
@@ skipping 365 matching lines @@
     // 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
+    });
+  }
+
+  void test_AnalysisErrorType() {
+    new EnumTester<engine.ErrorType, AnalysisErrorType>().run(
+        (engine.ErrorType engineErrorType) =>
+            new AnalysisErrorType(engineErrorType.name));
+  }
+
+  void test_ElementKind() {
+    new EnumTester<engine.ElementKind, ElementKind>().run(
+        newElementKind_fromEngine,
+        exceptions: {
+      // TODO(paulberry): do any of the exceptions below constitute bugs?

[Brian Wilkerson, 2014/10/09 21:41:22]

Yes. Some of these can almost certainly get passed to the client. The angular
and polymer specific ones, for example. Those were excluded from the list in the
specification because we intend to eventually have those be generated by
plugins. (I won't go into what plugin support means in this case.) I'm not sure
what we want to do short-term in those cases.

Others exist on the server side but currently cannot be passed to the client,
such as "IMPORT", "EXPORT", and UNIVERSE.

Some of them I'm not even sure what they're used for on the server side, such as
"ERROR" or "NAME" (although I have a guess about the latter).

[scheglov, 2014/10/09 21:44:16]

All these ElementKind values represent features that are not supported for the
server because we wait for plugins, or are used internally.

+      engine.ElementKind.ANGULAR_FORMATTER: ElementKind.UNKNOWN,
+      engine.ElementKind.ANGULAR_COMPONENT: ElementKind.UNKNOWN,
+      engine.ElementKind.ANGULAR_CONTROLLER: ElementKind.UNKNOWN,
+      engine.ElementKind.ANGULAR_DIRECTIVE: ElementKind.UNKNOWN,
+      engine.ElementKind.ANGULAR_PROPERTY: ElementKind.UNKNOWN,
+      engine.ElementKind.ANGULAR_SCOPE_PROPERTY: ElementKind.UNKNOWN,
+      engine.ElementKind.ANGULAR_SELECTOR: ElementKind.UNKNOWN,
+      engine.ElementKind.ANGULAR_VIEW: ElementKind.UNKNOWN,
+      engine.ElementKind.DYNAMIC: ElementKind.UNKNOWN,
+      engine.ElementKind.EMBEDDED_HTML_SCRIPT: ElementKind.UNKNOWN,
+      engine.ElementKind.ERROR: ElementKind.UNKNOWN,
+      engine.ElementKind.EXPORT: ElementKind.UNKNOWN,
+      engine.ElementKind.EXTERNAL_HTML_SCRIPT: ElementKind.UNKNOWN,
+      engine.ElementKind.HTML: ElementKind.UNKNOWN,
+      engine.ElementKind.IMPORT: ElementKind.UNKNOWN,
+      engine.ElementKind.NAME: ElementKind.UNKNOWN,
+      engine.ElementKind.POLYMER_ATTRIBUTE: ElementKind.UNKNOWN,
+      engine.ElementKind.POLYMER_TAG_DART: ElementKind.UNKNOWN,
+      engine.ElementKind.POLYMER_TAG_HTML: ElementKind.UNKNOWN,
+      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?

[scheglov, 2014/10/09 21:44:16]

We could, but it is kind of mixing layers here.
SearchEngine is an internal mechanism, one part of which is exposed as
SearchResult, but it provides information for other, internal, layers of the
server, such as refactoring.

+    new EnumTester<MatchKind, SearchResultKind>().run(
+        newSearchResultKind_fromEngine,
+        exceptions: {
+          // TODO(paulberry): do any of the exceptions below constitute bugs?

[Brian Wilkerson, 2014/10/09 21:41:22]

I think these also fall into the "they should be defined by a plugin" case.

+          MatchKind.ANGULAR_REFERENCE: SearchResultKind.UNKNOWN,
+          MatchKind.ANGULAR_CLOSING_TAG_REFERENCE: SearchResultKind.UNKNOWN
+        });
+  }
+}