Annotate analyzer tests with @ReflectiveTestCase().

pkg/analyzer/test/generated/ast_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.ast_test;
 
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 77 matching lines @@
 
   BreadthFirstVisitor_BreadthFirstVisitorTest_testIt(this.nodes) : super();
 
   @override
   Object visitNode(AstNode node) {
     nodes.add(node);
     return super.visitNode(node);
   }
 }
 
+@ReflectiveTestCase()
 class BreadthFirstVisitorTest extends ParserTestCase {
   void test_it() {
     String source = r'''
 class A {
   bool get g => true;
 }
 class B {
   int f() {
     num q() {
       return 3;
@@ skipping 31 matching lines @@
         FunctionDeclarationStatement,
         nodes[27]);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is IntegerLiteral,
         IntegerLiteral,
         nodes[58]);
     //3
   }
 }
 
+@ReflectiveTestCase()
 class ClassDeclarationTest extends ParserTestCase {
   void test_getConstructor() {
     List<ConstructorInitializer> initializers =
         new List<ConstructorInitializer>();
     ConstructorDeclaration defaultConstructor =
         AstFactory.constructorDeclaration(
             AstFactory.identifier3("Test"),
             null,
             AstFactory.formalParameterList(),
             initializers);
@@ skipping 78 matching lines @@
             Keyword.ABSTRACT,
             "B",
             null,
             null,
             null,
             null).isAbstract,
         isTrue);
   }
 }
 
+@ReflectiveTestCase()
 class ClassTypeAliasTest extends ParserTestCase {
   void test_isAbstract() {
     expect(
         AstFactory.classTypeAlias("A", null, null, null, null, null).isAbstract,
         isFalse);
     expect(
         AstFactory.classTypeAlias(
             "B",
             null,
             Keyword.ABSTRACT,
             null,
             null,
             null).isAbstract,
         isTrue);
   }
 }
 
+@ReflectiveTestCase()
 class ConstantEvaluatorTest extends ParserTestCase {
   void fail_constructor() {
     Object value = _getConstantValue("?");
     expect(value, null);
   }
 
   void fail_identifier_class() {
     Object value = _getConstantValue("?");
     expect(value, null);
   }
@@ skipping 297 matching lines @@
   void test_unary_negated_integer() {
     Object value = _getConstantValue("-42");
     EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
     expect(value as int, -42);
   }
 
   Object _getConstantValue(String source) =>
       ParserTestCase.parseExpression(source).accept(new ConstantEvaluator());
 }
 
+@ReflectiveTestCase()
 class ConstructorDeclarationTest extends EngineTestCase {
   void test_firstTokenAfterCommentAndMetadata_all_inverted() {
     Token externalKeyword = TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
     externalKeyword.offset = 14;
     ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
         Keyword.CONST,
         Keyword.FACTORY,
         AstFactory.identifier3('int'),
         null,
         null,
@@ skipping 59 matching lines @@
         null,
         null,
         null,
         null);
     expect(
         declaration.firstTokenAfterCommentAndMetadata,
         declaration.factoryKeyword);
   }
 }
 
+@ReflectiveTestCase()
 class IndexExpressionTest extends EngineTestCase {
   void test_inGetterContext_assignment_compound_left() {
     IndexExpression expression = AstFactory.indexExpression(
         AstFactory.identifier3("a"),
         AstFactory.identifier3("b"));
     // a[b] += c
     AstFactory.assignmentExpression(
         expression,
         TokenType.PLUS_EQ,
         AstFactory.identifier3("c"));
@@ skipping 114 matching lines @@
   void test_inSetterContext_prefix_plusPlus() {
     IndexExpression expression = AstFactory.indexExpression(
         AstFactory.identifier3("a"),
         AstFactory.identifier3("b"));
     // ++a[b]
     AstFactory.prefixExpression(TokenType.PLUS_PLUS, expression);
     expect(expression.inSetterContext(), isTrue);
   }
 }
 
+@ReflectiveTestCase()
 class NodeListTest extends EngineTestCase {
   void test_add() {
     AstNode parent = AstFactory.argumentList();
     AstNode firstNode = AstFactory.booleanLiteral(true);
     AstNode secondNode = AstFactory.booleanLiteral(false);
     NodeList<AstNode> list = new NodeList<AstNode>(parent);
     list.insert(0, secondNode);
     list.insert(0, firstNode);
     expect(list, hasLength(2));
     expect(list[0], same(firstNode));
@@ skipping 207 matching lines @@
     NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
     try {
       javaListSet(list, 1, node);
       fail("Expected IndexOutOfBoundsException");
     } on RangeError catch (exception) {
       // Expected
     }
   }
 }
 
+@ReflectiveTestCase()
 class NodeLocatorTest extends ParserTestCase {
   void test_range() {
     CompilationUnit unit =
         ParserTestCase.parseCompilationUnit("library myLib;");
     _assertLocate(
         unit,
         4,
         10,
         (node) => node is LibraryDirective,
         LibraryDirective);
@@ skipping 41 matching lines @@
     expect(locator.foundNode, same(node));
     expect(node.offset <= start, isTrue, reason: "Node starts after range");
     expect(
         node.offset + node.length > end,
         isTrue,
         reason: "Node ends before range");
     EngineTestCase.assertInstanceOf(predicate, expectedClass, node);
   }
 }
 
+@ReflectiveTestCase()
 class SimpleIdentifierTest extends ParserTestCase {
   void test_inDeclarationContext_catch_exception() {
     SimpleIdentifier identifier =
         AstFactory.catchClause("e").exceptionParameter;
     expect(identifier.inDeclarationContext(), isTrue);
   }
 
   void test_inDeclarationContext_catch_stack() {
     SimpleIdentifier identifier =
         AstFactory.catchClause2("e", "s").stackTraceParameter;
@@ skipping 298 matching lines @@
     AstNode child = identifier;
     AstNode parent = identifier.parent;
     while (parent != null) {
       child = parent;
       parent = parent.parent;
     }
     return child;
   }
 }
 
+@ReflectiveTestCase()
 class SimpleStringLiteralTest extends ParserTestCase {
   void test_contentsEnd() {
     expect(
         new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X").contentsEnd,
         2);
     expect(
         new SimpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X").contentsEnd,
         2);
     expect(
         new SimpleStringLiteral(
@@ skipping 193 matching lines @@
   void test_simple() {
     Token token = TokenFactory.tokenFromString("'value'");
     SimpleStringLiteral stringLiteral = new SimpleStringLiteral(token, "value");
     expect(stringLiteral.literal, same(token));
     expect(stringLiteral.beginToken, same(token));
     expect(stringLiteral.endToken, same(token));
     expect(stringLiteral.value, "value");
   }
 }
 
+@ReflectiveTestCase()
 class StringInterpolationTest extends ParserTestCase {
   void test_contentsOffsetEnd() {
     AstFactory.interpolationExpression(AstFactory.identifier3('bb'));
     // 'a${bb}ccc'
     {
       var ae = AstFactory.interpolationString("'a", "a");
       var cToken = new StringToken(TokenType.STRING, "ccc'", 10);
       var cElement = new InterpolationString(cToken, 'ccc');
       StringInterpolation node = AstFactory.string([ae, ae, cElement]);
       expect(node.contentsOffset, 1);
@@ skipping 109 matching lines @@
     // '''
     {
       var a = AstFactory.interpolationString("'''a", "a");
       var c = AstFactory.interpolationString("ccc'''", "ccc");
       StringInterpolation node = AstFactory.string([a, b, c]);
       expect(node.isSingleQuoted, isTrue);
     }
   }
 }
 
+@ReflectiveTestCase()
 class ToSourceVisitorTest extends EngineTestCase {
   void test_visitAdjacentStrings() {
     _assertSource(
         "'a' 'b'",
         AstFactory.adjacentStrings([AstFactory.string2("a"), AstFactory.string2("b")]));
   }
 
   void test_visitAnnotation_constant() {
     _assertSource("@A", AstFactory.annotation(AstFactory.identifier3("A")));
   }
@@ skipping 2273 matching lines @@
    * @param node the AST node being visited to produce the actual source
    * @throws AFE if the visitor does not produce the expected source for the given node
    */
   void _assertSource(String expectedSource, AstNode node) {
     PrintStringWriter writer = new PrintStringWriter();
     node.accept(new ToSourceVisitor(writer));
     expect(writer.toString(), expectedSource);
   }
 }
 
+@ReflectiveTestCase()
 class VariableDeclarationTest extends ParserTestCase {
   void test_getDocumentationComment_onGrandParent() {
     VariableDeclaration varDecl = AstFactory.variableDeclaration("a");
     TopLevelVariableDeclaration decl =
         AstFactory.topLevelVariableDeclaration2(Keyword.VAR, [varDecl]);
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     expect(varDecl.documentationComment, isNull);
     decl.documentationComment = comment;
     expect(varDecl.documentationComment, isNotNull);
     expect(decl.documentationComment, isNotNull);
@@ skipping 24 matching lines @@
 
   static const List<WrapperKind> values = const [
       PREFIXED_LEFT,
       PREFIXED_RIGHT,
       PROPERTY_LEFT,
       PROPERTY_RIGHT,
       NONE];
 
   const WrapperKind(String name, int ordinal) : super(name, ordinal);
 }