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

pkg/analyzer/test/generated/all_the_rest_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.all_the_rest_test;
 
 import 'dart:collection';
@@ skipping 434 matching lines @@
         buffer.write(start);
         buffer.write(", ");
       }
       fail(buffer.toString());
     }
     return firstToken;
   }
 }
 
 
+@ReflectiveTestCase()
 class AngularCompilationUnitBuilderTest extends AngularTest {
   void test_bad_notConstructorAnnotation() {
     String mainContent = r'''
 const MY_ANNOTATION = null;
 @MY_ANNOTATION()
 class MyFilter {
 }''';
     resolveMainSource(mainContent);
     // prepare AngularFilterElement
     ClassElement classElement = mainUnitElement.getType("MyFilter");
@@ skipping 973 matching lines @@
         selector);
     expect((selector as AngularTagSelectorElementImpl).name, name);
   }
 
   static String _createAngularSource(String code) {
     return "import 'angular.dart';\n" + code;
   }
 }
 
 
+@ReflectiveTestCase()
 class AngularHtmlUnitResolverTest extends AngularTest {
   void fail_analysisContext_changeDart_invalidateApplication() {
     addMainSource(r'''
 
 import 'angular.dart';
 
 @Component(
     templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
     publishAs: 'ctrl',
     selector: 'myComponent')
@@ skipping 887 matching lines @@
     resolveIndex2(content);
     assertNoErrors();
     verify([indexSource]);
   }
 }
 
 
 /**
  * Tests for [HtmlUnitUtils] for Angular HTMLs.
  */
+@ReflectiveTestCase()
 class AngularHtmlUnitUtilsTest extends AngularTest {
   void test_getElement_forExpression() {
     addMyController();
     _resolveSimpleCtrlFieldHtml();
     // prepare expression
     int offset = indexContent.indexOf("ctrl");
     Expression expression = ht.HtmlUnitUtils.getExpression(indexUnit, offset);
     // get element
     Element element = ht.HtmlUnitUtils.getElement(expression);
     EngineTestCase.assertInstanceOf(
@@ skipping 620 matching lines @@
    *         not found.
    */
   static int findOffset(String content, String search) {
     int offset = content.indexOf(search);
     expect(offset, isNot(-1));
     return offset;
   }
 }
 
 
+@ReflectiveTestCase()
 class ConstantEvaluatorTest extends ResolverTestCase {
   void fail_constructor() {
     EvaluationResult result = _getExpressionValue("?");
     expect(result.isValid, isTrue);
     DartObject value = result.value;
     expect(value, null);
   }
 
   void fail_identifier_class() {
     EvaluationResult result = _getExpressionValue("?");
@@ skipping 364 matching lines @@
         (declaration as TopLevelVariableDeclaration).variables.variables;
     expect(variables, hasLength(1));
     ConstantEvaluator evaluator = new ConstantEvaluator(
         source,
         (analysisContext as AnalysisContextImpl).typeProvider);
     return evaluator.evaluate(variables[0].initializer);
   }
 }
 
 
+@ReflectiveTestCase()
 class ConstantFinderTest extends EngineTestCase {
   AstNode _node;
 
   /**
    * Test an annotation that consists solely of an identifier (and hence
    * represents a reference to a compile-time constant variable).
    */
   void test_visitAnnotation_constantVariable() {
     _node = AstFactory.annotation(AstFactory.identifier3('x'));
     expect(_findAnnotations(), contains(_node));
@@ skipping 115 matching lines @@
     identifier.staticElement = element;
     AstFactory.variableDeclarationList2(
         isConst ? Keyword.CONST : null,
         [variableDeclaration]);
     _node = variableDeclaration;
     return element;
   }
 }
 
 
+@ReflectiveTestCase()
 class ConstantValueComputerTest extends ResolverTestCase {
   void test_annotation_constConstructor() {
     CompilationUnit compilationUnit = resolveSource(r'''
 class A {
   final int i;
   const A(this.i);
 }
 
 class C {
   @A(5)
@@ skipping 1213 matching lines @@
     super.beforeGetEvaluationResult(node);
     // If we are getting the evaluation result for a node in the graph,
     // make sure we properly recorded the dependency.
     if (_referenceGraph.nodes.contains(node)) {
       expect(_referenceGraph.containsPath(_nodeBeingEvaluated, node), isTrue);
     }
   }
 }
 
 
+@ReflectiveTestCase()
 class ConstantVisitorTest extends ResolverTestCase {
   void test_visitConditionalExpression_false() {
     Expression thenExpression = AstFactory.integer(1);
     Expression elseExpression = AstFactory.integer(0);
     ConditionalExpression expression = AstFactory.conditionalExpression(
         AstFactory.booleanLiteral(false),
         thenExpression,
         elseExpression);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
@@ skipping 151 matching lines @@
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
     DartObjectImpl result = expression.accept(
         new ConstantVisitor.con2(typeProvider, lexicalEnvironment, errorReporter));
     errorListener.assertNoErrors();
     return result;
   }
 }
 
 
+@ReflectiveTestCase()
 class ContentCacheTest {
   void test_setContents() {
     Source source = new TestSource();
     ContentCache cache = new ContentCache();
     expect(cache.getContents(source), isNull);
     expect(cache.getModificationStamp(source), isNull);
     String contents = "library lib;";
     expect(cache.setContents(source, contents), isNull);
     expect(cache.getContents(source), contents);
     expect(cache.getModificationStamp(source), isNotNull);
     expect(cache.setContents(source, contents), contents);
     expect(cache.setContents(source, null), contents);
     expect(cache.getContents(source), isNull);
     expect(cache.getModificationStamp(source), isNull);
     expect(cache.setContents(source, null), isNull);
   }
 }
 
 
+@ReflectiveTestCase()
 class DartObjectImplTest extends EngineTestCase {
   TypeProvider _typeProvider = new TestTypeProvider();
 
   void fail_add_knownString_knownString() {
     fail("New constant semantics are not yet enabled");
     _assertAdd(_stringValue("ab"), _stringValue("a"), _stringValue("b"));
   }
 
   void fail_add_knownString_unknownString() {
     fail("New constant semantics are not yet enabled");
@@ skipping 2228 matching lines @@
           new StringState(value));
     }
   }
 
   DartObjectImpl _symbolValue(String value) {
     return new DartObjectImpl(_typeProvider.symbolType, new SymbolState(value));
   }
 }
 
 
+@ReflectiveTestCase()
 class DartUriResolverTest {
   void test_creation() {
     JavaFile sdkDirectory = DirectoryBasedDartSdk.defaultSdkDirectory;
     expect(sdkDirectory, isNotNull);
     DartSdk sdk = new DirectoryBasedDartSdk(sdkDirectory);
     expect(new DartUriResolver(sdk), isNotNull);
   }
 
   void test_isDartUri_null_scheme() {
     Uri uri = parseUriWithException("foo.dart");
@@ skipping 25 matching lines @@
     expect(sdkDirectory, isNotNull);
     DartSdk sdk = new DirectoryBasedDartSdk(sdkDirectory);
     UriResolver resolver = new DartUriResolver(sdk);
     Source result =
         resolver.resolveAbsolute(parseUriWithException("package:some/file.dart"));
     expect(result, isNull);
   }
 }
 
 
+@ReflectiveTestCase()
 class DeclaredVariablesTest extends EngineTestCase {
   void test_getBool_false() {
     TestTypeProvider typeProvider = new TestTypeProvider();
     String variableName = "var";
     DeclaredVariables variables = new DeclaredVariables();
     variables.define(variableName, "false");
     DartObject object = variables.getBool(typeProvider, variableName);
     expect(object, isNotNull);
     expect(object.boolValue, false);
   }
@@ skipping 81 matching lines @@
   }
 
   void _assertUnknownDartObject(ParameterizedType expectedType,
       DartObject result) {
     expect((result as DartObjectImpl).isUnknown, isTrue);
     expect(result.type, expectedType);
   }
 }
 
 
+@ReflectiveTestCase()
 class DirectoryBasedDartSdkTest {
   void fail_getDocFileFor() {
     DirectoryBasedDartSdk sdk = _createDartSdk();
     JavaFile docFile = sdk.getDocFileFor("html");
     expect(docFile, isNotNull);
   }
 
   void test_creation() {
     DirectoryBasedDartSdk sdk = _createDartSdk();
     expect(sdk, isNotNull);
@@ skipping 92 matching lines @@
     expect(
         sdkDirectory,
         isNotNull,
         reason:
             "No SDK configured; set the property 'com.google.dart.sdk' on the command line");
     return new DirectoryBasedDartSdk(sdkDirectory);
   }
 }
 
 
+@ReflectiveTestCase()
 class DirectoryBasedSourceContainerTest {
   void test_contains() {
     JavaFile dir = FileUtilities2.createFile("/does/not/exist");
     JavaFile file1 = FileUtilities2.createFile("/does/not/exist/some.dart");
     JavaFile file2 =
         FileUtilities2.createFile("/does/not/exist/folder/some2.dart");
     JavaFile file3 = FileUtilities2.createFile("/does/not/exist3/some3.dart");
     FileBasedSource source1 = new FileBasedSource.con1(file1);
     FileBasedSource source2 = new FileBasedSource.con1(file2);
     FileBasedSource source3 = new FileBasedSource.con1(file3);
     DirectoryBasedSourceContainer container =
         new DirectoryBasedSourceContainer.con1(dir);
     expect(container.contains(source1), isTrue);
     expect(container.contains(source2), isTrue);
     expect(container.contains(source3), isFalse);
   }
 }
 
 
+@ReflectiveTestCase()
 class ElementBuilderTest extends EngineTestCase {
   void test_visitCatchClause() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String exceptionParameterName = "e";
     String stackParameterName = "s";
     CatchClause clause =
         AstFactory.catchClause2(exceptionParameterName, stackParameterName);
     clause.accept(builder);
     List<LocalVariableElement> variables = holder.localVariables;
@@ skipping 1236 matching lines @@
         null,
         null,
         null,
         AstFactory.identifier3("main"),
         AstFactory.formalParameterList([formalParameter]),
         body);
   }
 }
 
 
+@ReflectiveTestCase()
 class ElementLocatorTest extends ResolverTestCase {
   void fail_locate_ExportDirective() {
     AstNode id = _findNodeIn("export", "export 'dart:core';");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ImportElement,
         ImportElement,
         element);
   }
 
@@ skipping 450 matching lines @@
   CompilationUnit _resolveContents(String code) {
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     return analysisContext.resolveCompilationUnit(source, library);
   }
 }
 
 
+@ReflectiveTestCase()
 class EnumMemberBuilderTest extends EngineTestCase {
   void test_visitEnumDeclaration_multiple() {
     String firstName = "ONE";
     String secondName = "TWO";
     String thirdName = "THREE";
     EnumDeclaration enumDeclaration =
         AstFactory.enumDeclaration2("E", [firstName, secondName, thirdName]);
 
     ClassElement enumElement = _buildElement(enumDeclaration);
     List<FieldElement> fields = enumElement.fields;
@@ skipping 62 matching lines @@
     EnumMemberBuilder memberBuilder =
         new EnumMemberBuilder(new TestTypeProvider());
     enumDeclaration.accept(memberBuilder);
     List<ClassElement> enums = holder.enums;
     expect(enums, hasLength(1));
     return enums[0];
   }
 }
 
 
+@ReflectiveTestCase()
 class ErrorReporterTest extends EngineTestCase {
   /**
    * Create a type with the given name in a compilation unit with the given name.
    *
    * @param fileName the name of the compilation unit containing the class
    * @param typeName the name of the type to be created
    * @return the type that was created
    */
   InterfaceType createType(String fileName, String typeName) {
     CompilationUnitElementImpl unit = ElementFactory.compilationUnit(fileName);
@@ skipping 32 matching lines @@
     reporter.reportTypeErrorForNode(
         StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE,
         AstFactory.identifier3("x"),
         [firstType, secondType]);
     AnalysisError error = listener.errors[0];
     expect(error.message.indexOf("(") >= 0, isTrue);
   }
 }
 
 
+@ReflectiveTestCase()
 class ErrorSeverityTest extends EngineTestCase {
   void test_max_error_error() {
     expect(
         ErrorSeverity.ERROR.max(ErrorSeverity.ERROR),
         same(ErrorSeverity.ERROR));
   }
 
   void test_max_error_none() {
     expect(
         ErrorSeverity.ERROR.max(ErrorSeverity.NONE),
@@ skipping 37 matching lines @@
   }
 
   void test_max_warning_warning() {
     expect(
         ErrorSeverity.WARNING.max(ErrorSeverity.WARNING),
         same(ErrorSeverity.WARNING));
   }
 }
 
 
+@ReflectiveTestCase()
 class ExitDetectorTest extends ParserTestCase {
   void fail_doStatement_continue_with_label() {
     _assertFalse("{ x: do { continue x; } while(true); }");
   }
 
   void fail_whileStatement_continue_with_label() {
     _assertFalse("{ x: while (true) { continue x; } }");
   }
 
   void fail_whileStatement_doStatement_scopeRequired() {
@@ skipping 481 matching lines @@
 
   ExpressionVisitor_AngularTest_verify(this.verifier);
 
   @override
   void visitExpression(Expression expression) {
     expression.accept(verifier);
   }
 }
 
 
+@ReflectiveTestCase()
 class FileBasedSourceTest {
   void test_equals_false_differentFiles() {
     JavaFile file1 = FileUtilities2.createFile("/does/not/exist1.dart");
     JavaFile file2 = FileUtilities2.createFile("/does/not/exist2.dart");
     FileBasedSource source1 = new FileBasedSource.con1(file1);
     FileBasedSource source2 = new FileBasedSource.con1(file2);
     expect(source1 == source2, isFalse);
   }
 
   void test_equals_false_null() {
@@ skipping 196 matching lines @@
     JavaFile file = FileUtilities2.createFile("/does/not/exist.dart");
     FileBasedSource source =
         new FileBasedSource.con2(parseUriWithException("dart:core"), file);
     expect(source, isNotNull);
     expect(source.fullName, file.getAbsolutePath());
     expect(source.isInSystemLibrary, isTrue);
   }
 }
 
 
+@ReflectiveTestCase()
 class FileUriResolverTest {
   void test_creation() {
     expect(new FileUriResolver(), isNotNull);
   }
 
   void test_resolve_file() {
     UriResolver resolver = new FileUriResolver();
     Source result =
         resolver.resolveAbsolute(parseUriWithException("file:/does/not/exist.dart"));
     expect(result, isNotNull);
     expect(
         result.fullName,
         FileUtilities2.createFile("/does/not/exist.dart").getAbsolutePath());
   }
 
   void test_resolve_nonFile() {
     UriResolver resolver = new FileUriResolver();
     Source result =
         resolver.resolveAbsolute(parseUriWithException("dart:core"));
     expect(result, isNull);
   }
 }
 
 
+@ReflectiveTestCase()
 class HtmlParserTest extends EngineTestCase {
   /**
    * The name of the 'script' tag in an HTML file.
    */
   static String _TAG_SCRIPT = "script";
   void fail_parse_scriptWithComment() {
     String scriptBody = r'''
       /**
        *     <editable-label bind-value="dartAsignableValue">
        *     </editable-label>
@@ skipping 163 matching lines @@
       new XmlValidator_Tag(tag, new XmlValidator_Attributes(), null, children);
   void _validate(ht.HtmlUnit htmlUnit, List<XmlValidator_Tag> expectedTags) {
     XmlValidator validator = new XmlValidator();
     validator.expectTags(expectedTags);
     htmlUnit.accept(validator);
     validator.assertValid();
   }
 }
 
 
+@ReflectiveTestCase()
 class HtmlTagInfoBuilderTest extends HtmlParserTest {
   void test_builder() {
     HtmlTagInfoBuilder builder = new HtmlTagInfoBuilder();
     ht.HtmlUnit unit = parse(r'''
 <html>
   <body>
     <div id="x"></div>
     <p class='c'></p>
     <div class='c'></div>
   </body>
 </html>''');
     unit.accept(builder);
     HtmlTagInfo info = builder.getTagInfo();
     expect(info, isNotNull);
     List<String> allTags = info.allTags;
     expect(allTags, hasLength(4));
     expect(info.getTagWithId("x"), "div");
     List<String> tagsWithClass = info.getTagsWithClass("c");
     expect(tagsWithClass, hasLength(2));
   }
 }
 
 
+@ReflectiveTestCase()
 class HtmlUnitBuilderTest extends EngineTestCase {
   AnalysisContextImpl _context;
   @override
   void setUp() {
     _context = AnalysisContextFactory.contextWithCore();
   }
   @override
   void tearDown() {
     _context = null;
     super.tearDown();
@@ skipping 117 matching lines @@
   void validate(int scriptIndex, TopLevelVariableElement variable) {
     expect(variable, isNotNull, reason: "script $scriptIndex");
     expect(variable.name, _expectedName, reason: "script $scriptIndex");
   }
 }
 
 
 /**
  * Instances of the class `HtmlWarningCodeTest` test the generation of HTML warning codes.
  */
+@ReflectiveTestCase()
 class HtmlWarningCodeTest extends EngineTestCase {
   /**
    * The source factory used to create the sources to be resolved.
    */
   SourceFactory _sourceFactory;
 
   /**
    * The analysis context used to resolve the HTML files.
    */
   AnalysisContextImpl _context;
@@ skipping 90 matching lines @@
   Source fromFileUri(Uri uri) => null;
 
   @override
   SdkLibrary getSdkLibrary(String dartUri) => null;
 
   @override
   Source mapDartUri(String dartUri) => null;
 }
 
 
+@ReflectiveTestCase()
 class ReferenceFinderTest extends EngineTestCase {
   DirectedGraph<AstNode> _referenceGraph;
   Map<VariableElement, VariableDeclaration> _variableDeclarationMap;
   Map<ConstructorElement, ConstructorDeclaration> _constructorDeclarationMap;
   VariableDeclaration _head;
   AstNode _tail;
   @override
   void setUp() {
     _referenceGraph = new DirectedGraph<AstNode>();
     _variableDeclarationMap =
@@ skipping 142 matching lines @@
     SimpleIdentifier identifier = AstFactory.identifier3(name);
     identifier.staticElement = variableElement;
     return identifier;
   }
   void _visitNode(AstNode node) {
     node.accept(_createReferenceFinder(_head));
   }
 }
 
 
+@ReflectiveTestCase()
 class SDKLibrariesReaderTest extends EngineTestCase {
   void test_readFrom_dart2js() {
     LibraryMap libraryMap = new SdkLibrariesReader(
         true).readFromFile(FileUtilities2.createFile("/libs.dart"), r'''
 final Map<String, LibraryInfo> LIBRARIES = const <String, LibraryInfo> {
   'first' : const LibraryInfo(
     'first/first.dart',
     category: 'First',
     documented: true,
     platforms: VM_PLATFORM,
@@ skipping 51 matching lines @@
     expect(second.path, "second/second.dart");
     expect(second.shortName, "dart:second");
     expect(second.isDart2JsLibrary, false);
     expect(second.isDocumented, false);
     expect(second.isImplementation, true);
     expect(second.isVmLibrary, false);
   }
 }
 
 
+@ReflectiveTestCase()
 class SourceFactoryTest {
   void test_creation() {
     expect(new SourceFactory([]), isNotNull);
   }
   void test_fromEncoding_invalidUri() {
     SourceFactory factory = new SourceFactory([]);
     try {
       factory.fromEncoding("<:&%>");
       fail("Expected IllegalArgumentException");
     } on IllegalArgumentException catch (exception) {
@@ skipping 47 matching lines @@
     Source source2 = new FileBasedSource.con1(file2);
     Uri expected1 = parseUriWithException("file:///my_file.dart");
     SourceFactory factory =
         new SourceFactory([new UriResolver_restoreUri(source1, expected1)]);
     expect(factory.restoreUri(source1), same(expected1));
     expect(factory.restoreUri(source2), same(null));
   }
 }
 
 
+@ReflectiveTestCase()
 class StringScannerTest extends AbstractScannerTest {
   @override
   ht.AbstractScanner newScanner(String input) {
     return new ht.StringScanner(null, input);
   }
 }
 
 
 /**
  * Instances of the class `ToSourceVisitorTest`
  */
+@ReflectiveTestCase()
 class ToSourceVisitorTest extends EngineTestCase {
   void fail_visitHtmlScriptTagNode_attributes_content() {
     _assertSource(
         "<script type='application/dart'>f() {}</script>",
         HtmlFactory.scriptTagWithContent(
             "f() {}",
             [HtmlFactory.attribute("type", "'application/dart'")]));
   }
 
   void fail_visitHtmlScriptTagNode_noAttributes_content() {
@@ skipping 34 matching lines @@
    * @param node the AST node being visited to produce the actual source
    */
   void _assertSource(String expectedSource, ht.XmlNode node) {
     PrintStringWriter writer = new PrintStringWriter();
     node.accept(new ht.ToSourceVisitor(writer));
     expect(writer.toString(), expectedSource);
   }
 }
 
 
+@ReflectiveTestCase()
 class UriKindTest {
   void test_fromEncoding() {
     expect(UriKind.fromEncoding(0x64), same(UriKind.DART_URI));
     expect(UriKind.fromEncoding(0x66), same(UriKind.FILE_URI));
     expect(UriKind.fromEncoding(0x70), same(UriKind.PACKAGE_URI));
     expect(UriKind.fromEncoding(0x58), same(null));
   }
 
   void test_getEncoding() {
     expect(UriKind.DART_URI.encoding, 0x64);
@@ skipping 423 matching lines @@
     } else {
       expect(scriptSource, isNotNull, reason: "script $scriptIndex");
       String actualExternalScriptName = scriptSource.shortName;
       expect(
           actualExternalScriptName,
           _expectedExternalScriptName,
           reason: "script $scriptIndex");
     }
   }
 }