Annotate remaining analyzer/analysis server tests with "@ReflectiveTestCase()"

pkg/analyzer/test/generated/element_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.
 
 // 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.element_test;
 
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 22 matching lines @@
   runReflectiveTests(VoidTypeImplTest);
   runReflectiveTests(ClassElementImplTest);
   runReflectiveTests(CompilationUnitElementImplTest);
   runReflectiveTests(ElementLocationImplTest);
   runReflectiveTests(ElementImplTest);
   runReflectiveTests(HtmlElementImplTest);
   runReflectiveTests(LibraryElementImplTest);
   runReflectiveTests(MultiplyDefinedElementImplTest);
 }
 
+@ReflectiveTestCase()
 class AngularPropertyKindTest extends EngineTestCase {
   void test_ATTR() {
     AngularPropertyKind kind = AngularPropertyKind.ATTR;
     expect(kind.callsGetter(), isFalse);
     expect(kind.callsSetter(), isTrue);
   }
 
   void test_CALLBACK() {
     AngularPropertyKind kind = AngularPropertyKind.CALLBACK;
     expect(kind.callsGetter(), isFalse);
@@ skipping 12 matching lines @@
     expect(kind.callsSetter(), isTrue);
   }
 
   void test_TWO_WAY() {
     AngularPropertyKind kind = AngularPropertyKind.TWO_WAY;
     expect(kind.callsGetter(), isTrue);
     expect(kind.callsSetter(), isTrue);
   }
 }
 
+@ReflectiveTestCase()
 class ClassElementImplTest extends EngineTestCase {
   void test_getAllSupertypes_interface() {
     ClassElement classA = ElementFactory.classElement2("A");
     ClassElement classB = ElementFactory.classElement("B", classA.type);
     ClassElementImpl elementC = ElementFactory.classElement2("C");
     InterfaceType typeObject = classA.supertype;
     InterfaceType typeA = classA.type;
     InterfaceType typeB = classB.type;
     InterfaceType typeC = elementC.type;
     elementC.interfaces = <InterfaceType>[typeB];
@@ skipping 817 matching lines @@
         ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classA = ElementFactory.classElement2("A");
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     classA.supertype = classB.type;
     (library.definingCompilationUnit as CompilationUnitElementImpl).types =
         <ClassElement>[classA, classB];
     expect(classA.lookUpSetter("s", library), isNull);
   }
 }
 
+@ReflectiveTestCase()
 class CompilationUnitElementImplTest extends EngineTestCase {
   void test_getEnum_declared() {
     TestTypeProvider typeProvider = new TestTypeProvider();
     CompilationUnitElementImpl unit =
         ElementFactory.compilationUnit("/lib.dart");
     String enumName = "E";
     ClassElement enumElement =
         ElementFactory.enumElement(typeProvider, enumName);
     unit.enums = <ClassElement>[enumElement];
     expect(unit.getEnum(enumName), same(enumElement));
@@ skipping 22 matching lines @@
   void test_getType_undeclared() {
     CompilationUnitElementImpl unit =
         ElementFactory.compilationUnit("/lib.dart");
     String className = "C";
     ClassElement classElement = ElementFactory.classElement2(className);
     unit.types = <ClassElement>[classElement];
     expect(unit.getType("${className}x"), isNull);
   }
 }
 
+@ReflectiveTestCase()
 class ElementImplTest extends EngineTestCase {
   void test_equals() {
     LibraryElementImpl library =
         ElementFactory.library(createAnalysisContext(), "lib");
     ClassElementImpl classElement = ElementFactory.classElement2("C");
     (library.definingCompilationUnit as CompilationUnitElementImpl).types =
         <ClassElement>[classElement];
     FieldElement field =
         ElementFactory.fieldElement("next", false, false, false, classElement.type);
     classElement.fields = <FieldElement>[field];
@@ skipping 75 matching lines @@
     ClassElementImpl classElementA = ElementFactory.classElement2("A");
     classElementA.nameOffset = 1;
     ClassElementImpl classElementB = ElementFactory.classElement2("B");
     classElementB.nameOffset = 2;
     expect(Element.SORT_BY_OFFSET(classElementA, classElementA), 0);
     expect(Element.SORT_BY_OFFSET(classElementA, classElementB) < 0, isTrue);
     expect(Element.SORT_BY_OFFSET(classElementB, classElementA) > 0, isTrue);
   }
 }
 
+@ReflectiveTestCase()
 class ElementKindTest extends EngineTestCase {
   void test_of_nonNull() {
     expect(
         ElementKind.of(ElementFactory.classElement2("A")),
         same(ElementKind.CLASS));
   }
 
   void test_of_null() {
     expect(ElementKind.of(null), same(ElementKind.ERROR));
   }
 }
 
+@ReflectiveTestCase()
 class ElementLocationImplTest extends EngineTestCase {
   void test_create_encoding() {
     String encoding = "a;b;c";
     ElementLocationImpl location = new ElementLocationImpl.con2(encoding);
     expect(location.encoding, encoding);
   }
 
   /**
    * For example unnamed constructor.
    */
@@ skipping 44 matching lines @@
   }
 
   void test_hashCode_equal() {
     String encoding = "a;b;c";
     ElementLocationImpl first = new ElementLocationImpl.con2(encoding);
     ElementLocationImpl second = new ElementLocationImpl.con2(encoding);
     expect(first.hashCode == second.hashCode, isTrue);
   }
 }
 
+@ReflectiveTestCase()
 class FunctionTypeImplTest extends EngineTestCase {
   void test_creation() {
     expect(
         new FunctionTypeImpl.con1(
             new FunctionElementImpl.forNode(AstFactory.identifier3("f"))),
         isNotNull);
   }
 
   void test_getElement() {
     FunctionElementImpl typeElement =
@@ skipping 578 matching lines @@
     expect(normalParameters[0], normalParameterType);
     List<DartType> optionalParameters = result.optionalParameterTypes;
     expect(optionalParameters, hasLength(1));
     expect(optionalParameters[0], optionalParameterType);
     Map<String, DartType> namedParameters = result.namedParameterTypes;
     expect(namedParameters, hasLength(1));
     expect(namedParameters[namedParameterName], namedParameterType);
   }
 }
 
+@ReflectiveTestCase()
 class HtmlElementImplTest extends EngineTestCase {
   void test_equals_differentSource() {
     AnalysisContextImpl context = createAnalysisContext();
     HtmlElementImpl elementA = ElementFactory.htmlUnit(context, "indexA.html");
     HtmlElementImpl elementB = ElementFactory.htmlUnit(context, "indexB.html");
     expect(elementA == elementB, isFalse);
   }
 
   void test_equals_null() {
     AnalysisContextImpl context = createAnalysisContext();
     HtmlElementImpl element = ElementFactory.htmlUnit(context, "index.html");
     expect(element == null, isFalse);
   }
 
   void test_equals_sameSource() {
     AnalysisContextImpl context = createAnalysisContext();
     HtmlElementImpl elementA = ElementFactory.htmlUnit(context, "index.html");
     HtmlElementImpl elementB = ElementFactory.htmlUnit(context, "index.html");
     expect(elementA == elementB, isTrue);
   }
 
   void test_equals_self() {
     AnalysisContextImpl context = createAnalysisContext();
     HtmlElementImpl element = ElementFactory.htmlUnit(context, "index.html");
     expect(element == element, isTrue);
   }
 }
 
+@ReflectiveTestCase()
 class InterfaceTypeImplTest extends EngineTestCase {
   /**
    * The type provider used to access the types.
    */
   TestTypeProvider _typeProvider;
 
   @override
   void setUp() {
     _typeProvider = new TestTypeProvider();
   }
@@ skipping 1601 matching lines @@
         new TypeParameterElementImpl.forNode(AstFactory.identifier3("F")));
     InterfaceType result =
         type.substitute2(<DartType>[argumentType], <DartType>[parameterType]);
     expect(result.element, classA);
     List<DartType> resultArguments = result.typeArguments;
     expect(resultArguments, hasLength(1));
     expect(resultArguments[0], parameter);
   }
 }
 
+@ReflectiveTestCase()
 class LibraryElementImplTest extends EngineTestCase {
   void test_creation() {
     expect(
         new LibraryElementImpl.forNode(
             createAnalysisContext(),
             AstFactory.libraryIdentifier2(["l"])),
         isNotNull);
   }
 
   void test_getImportedLibraries() {
@@ skipping 149 matching lines @@
         ElementFactory.importFor(ElementFactory.library(context, "l3"), null)];
     library.imports = expectedImports;
     List<ImportElement> actualImports = library.imports;
     expect(actualImports, hasLength(expectedImports.length));
     for (int i = 0; i < actualImports.length; i++) {
       expect(actualImports[i], same(expectedImports[i]));
     }
   }
 }
 
+@ReflectiveTestCase()
 class MultiplyDefinedElementImplTest extends EngineTestCase {
   void test_fromElements_conflicting() {
     Element firstElement = ElementFactory.localVariableElement2("xx");
     Element secondElement = ElementFactory.localVariableElement2("yy");
     Element result =
         MultiplyDefinedElementImpl.fromElements(null, firstElement, secondElement);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MultiplyDefinedElement,
         MultiplyDefinedElement,
         result);
@@ skipping 32 matching lines @@
   }
 
   void test_fromElements_nonConflicting() {
     Element element = ElementFactory.localVariableElement2("xx");
     expect(
         MultiplyDefinedElementImpl.fromElements(null, element, element),
         same(element));
   }
 }
 
+@ReflectiveTestCase()
 class TypeParameterTypeImplTest extends EngineTestCase {
   void test_creation() {
     expect(
         new TypeParameterTypeImpl(
             new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"))),
         isNotNull);
   }
 
   void test_getElement() {
     TypeParameterElementImpl element =
@@ skipping 108 matching lines @@
     InterfaceTypeImpl argument = new InterfaceTypeImpl.con1(
         new ClassElementImpl.forNode(AstFactory.identifier3("A")));
     TypeParameterTypeImpl parameter = new TypeParameterTypeImpl(
         new TypeParameterElementImpl.forNode(AstFactory.identifier3("F")));
     expect(
         type.substitute2(<DartType>[argument], <DartType>[parameter]),
         same(type));
   }
 }
 
+@ReflectiveTestCase()
 class UnionTypeImplTest extends EngineTestCase {
   ClassElement _classA;
 
   InterfaceType _typeA;
 
   ClassElement _classB;
 
   InterfaceType _typeB;
 
   DartType _uA;
@@ skipping 178 matching lines @@
     // [FunctionTypeImplTest.test_isAssignableTo_normalAndPositionalArgs].
     ClassElement a = ElementFactory.classElement2("A");
     FunctionType t =
         ElementFactory.functionElement6("t", null, <ClassElement>[a]).type;
     DartType uAT = UnionTypeImpl.union([_uA, t]);
     expect(t.isSubtypeOf(uAT), isTrue);
     expect(t.isSubtypeOf(_uAB), isFalse);
   }
 }
 
+@ReflectiveTestCase()
 class VoidTypeImplTest extends EngineTestCase {
   /**
    * Reference {code VoidTypeImpl.getInstance()}.
    */
   DartType _voidType = VoidTypeImpl.instance;
 
   void test_isMoreSpecificThan_void_A() {
     ClassElement classA = ElementFactory.classElement2("A");
     expect(_voidType.isMoreSpecificThan(classA.type), isFalse);
   }
@@ skipping 26 matching lines @@
 
 class _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction extends
     InterfaceTypeImpl {
 
   _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction(ClassElement arg0)
       : super.con1(arg0);
 
   @override
   bool get isDartCoreFunction => true;
 }