Make error producing tests ansynchronous.

pkg/analyzer/test/generated/resolver_test_case.dart

 // Copyright (c) 2016, 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 analyzer.test.generated.resolver_test_case;
 
+import 'dart:async';
+
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/error/codes.dart';
@@ skipping 338 matching lines @@
   }
 
   /**
    * Add a source file named 'test.dart' in the root of the file system. The
    * file will have the given [contents] set in the content provider. Return the
    * source representing the added file.
    */
   Source addSource(String contents) => addNamedSource("/test.dart", contents);
 
   /**
-   * Assert that the number of errors reported against the given source matches the number of errors
-   * that are given and that they have the expected error codes. The order in which the errors were
-   * gathered is ignored.
-   *
-   * @param source the source against which the errors should have been reported
-   * @param expectedErrorCodes the error codes of the errors that should have been reported
-   * @throws AnalysisException if the reported errors could not be computed
-   * @throws AssertionFailedError if a different number of errors have been reported than were
-   *           expected
+   * Assert that the number of errors reported against the given
+   * [source] matches the number of errors that are given and that they have
+   * the expected error codes. The order in which the errors were gathered is
+   * ignored.
    */
-  void assertErrors(Source source,
-      [List<ErrorCode> expectedErrorCodes = const <ErrorCode>[]]) {
+  Future<Null> assertErrors(Source source,
+      [List<ErrorCode> expectedErrorCodes = const <ErrorCode>[]]) async {
     GatheringErrorListener errorListener = new GatheringErrorListener();
     for (AnalysisError error in analysisContext2.computeErrors(source)) {
       expect(error.source, source);
       ErrorCode errorCode = error.errorCode;
       if (!enableUnusedElement &&
           (errorCode == HintCode.UNUSED_ELEMENT ||
               errorCode == HintCode.UNUSED_FIELD)) {
         continue;
       }
       if (!enableUnusedLocalVariable &&
           (errorCode == HintCode.UNUSED_CATCH_CLAUSE ||
               errorCode == HintCode.UNUSED_CATCH_STACK ||
               errorCode == HintCode.UNUSED_LOCAL_VARIABLE)) {
         continue;
       }
       errorListener.onError(error);
     }
     errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
   /**
    * Asserts that [code] verifies, but has errors with the given error codes.
    *
    * Like [assertErrors], but takes a string of source code.
    */
   // TODO(rnystrom): Use this in more tests that have the same structure.
-  void assertErrorsInCode(String code, List<ErrorCode> errors) {
+  Future<Null> assertErrorsInCode(String code, List<ErrorCode> errors) async {
     Source source = addSource(code);
-    assertErrors(source, errors);
+    await assertErrors(source, errors);
     verify([source]);
   }
 
   /**
    * Asserts that [code] has errors with the given error codes.
    *
    * Like [assertErrors], but takes a string of source code.
    */
-  void assertErrorsInUnverifiedCode(String code, List<ErrorCode> errors) {
+  Future<Null> assertErrorsInUnverifiedCode(
+      String code, List<ErrorCode> errors) async {
     Source source = addSource(code);
-    assertErrors(source, errors);
+    await assertErrors(source, errors);
   }
 
   /**
    * Assert that no errors have been reported against the given source.
    *
    * @param source the source against which no errors should have been reported
    * @throws AnalysisException if the reported errors could not be computed
    * @throws AssertionFailedError if any errors have been reported
    */
-  void assertNoErrors(Source source) {
-    assertErrors(source);
+  Future<Null> assertNoErrors(Source source) async {
+    await assertErrors(source);
   }
 
   /**
    * Asserts that [code] has no errors or warnings.
    */
   // TODO(rnystrom): Use this in more tests that have the same structure.
-  void assertNoErrorsInCode(String code) {
+  Future<Null> assertNoErrorsInCode(String code) async {
     Source source = addSource(code);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
   }
 
   /**
    * @param code the code that assigns the value to the variable "v", no matter how. We check that
    *          "v" has expected static and propagated type.
    */
-  void assertPropagatedAssignedType(String code, DartType expectedStaticType,
-      DartType expectedPropagatedType) {
-    SimpleIdentifier identifier = findMarkedIdentifier(code, "v = ");
+  Future<Null> assertPropagatedAssignedType(String code,
+      DartType expectedStaticType, DartType expectedPropagatedType) async {
+    SimpleIdentifier identifier = await findMarkedIdentifier(code, "v = ");
     expect(identifier.staticType, same(expectedStaticType));
     expect(identifier.propagatedType, same(expectedPropagatedType));
   }
 
   /**
    * @param code the code that iterates using variable "v". We check that
    *          "v" has expected static and propagated type.
    */
-  void assertPropagatedIterationType(String code, DartType expectedStaticType,
-      DartType expectedPropagatedType) {
-    SimpleIdentifier identifier = findMarkedIdentifier(code, "v in ");
+  Future<Null> assertPropagatedIterationType(String code,
+      DartType expectedStaticType, DartType expectedPropagatedType) async {
+    SimpleIdentifier identifier = await findMarkedIdentifier(code, "v in ");
     expect(identifier.staticType, same(expectedStaticType));
     expect(identifier.propagatedType, same(expectedPropagatedType));
   }
 
   /**
    * Check the static and propagated types of the expression marked with "; // marker" comment.
    *
    * @param code source code to analyze, with the expression to check marked with "// marker".
    * @param expectedStaticType if non-null, check actual static type is equal to this.
    * @param expectedPropagatedType if non-null, check actual static type is equal to this.
    * @throws Exception
    */
-  void assertTypeOfMarkedExpression(String code, DartType expectedStaticType,
-      DartType expectedPropagatedType) {
-    SimpleIdentifier identifier = findMarkedIdentifier(code, "; // marker");
+  Future<Null> assertTypeOfMarkedExpression(String code,
+      DartType expectedStaticType, DartType expectedPropagatedType) async {
+    SimpleIdentifier identifier =
+        await findMarkedIdentifier(code, "; // marker");
     if (expectedStaticType != null) {
       expect(identifier.staticType, expectedStaticType);
     }
     expect(identifier.propagatedType, expectedPropagatedType);
   }
 
   /**
    * Cache the [contents] for the file at the given [filePath] but don't add the
    * source to the analysis context. The file path must be absolute.
    */
@@ skipping 76 matching lines @@
 
   /**
    * Return the `SimpleIdentifier` marked by `marker`. The source code must have no
    * errors and be verifiable.
    *
    * @param code source code to analyze.
    * @param marker marker identifying sought after expression in source code.
    * @return expression marked by the marker.
    * @throws Exception
    */
-  SimpleIdentifier findMarkedIdentifier(String code, String marker) {
+  Future<SimpleIdentifier> findMarkedIdentifier(
+      String code, String marker) async {
     try {
       Source source = addSource(code);
       LibraryElement library = resolve2(source);
-      assertNoErrors(source);
+      await assertNoErrors(source);
       verify([source]);
       CompilationUnit unit = resolveCompilationUnit(source, library);
       // Could generalize this further by making [SimpleIdentifier.class] a
       // parameter.
       return EngineTestCase.findNode(
           unit, code, marker, (node) => node is SimpleIdentifier);
     } catch (exception) {
       // Is there a better exception to throw here? The point is that an
       // assertion failure here should be a failure, in both "test_*" and
       // "fail_*" tests. However, an assertion failure is success for the
@@ skipping 77 matching lines @@
       CompilationUnit unit =
           resolveSource2("/lib${i + 1}.dart", sourceTexts[i]);
       // reference the source if this is the last source
       if (i + 1 == sourceTexts.length) {
         return resolutionMap.elementDeclaredByCompilationUnit(unit).source;
       }
     }
     return null;
   }
 
-  void resolveWithAndWithoutExperimental(
+  Future<Null> resolveWithAndWithoutExperimental(
       List<String> strSources,
       List<ErrorCode> codesWithoutExperimental,
-      List<ErrorCode> codesWithExperimental) {
+      List<ErrorCode> codesWithExperimental) async {
     // Setup analysis context as non-experimental
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
 //    options.enableDeferredLoading = false;
     resetWithOptions(options);
     // Analysis and assertions
     Source source = resolveSources(strSources);
-    assertErrors(source, codesWithoutExperimental);
+    await assertErrors(source, codesWithoutExperimental);
     verify([source]);
     // Setup analysis context as experimental
     reset();
     // Analysis and assertions
     source = resolveSources(strSources);
-    assertErrors(source, codesWithExperimental);
+    await assertErrors(source, codesWithExperimental);
     verify([source]);
   }
 
-  void resolveWithErrors(List<String> strSources, List<ErrorCode> codes) {
+  Future<Null> resolveWithErrors(
+      List<String> strSources, List<ErrorCode> codes) async {
     // Analysis and assertions
     Source source = resolveSources(strSources);
-    assertErrors(source, codes);
+    await assertErrors(source, codes);
     verify([source]);
   }
 
   @override
   void setUp() {
     ElementFactory.flushStaticState();
     super.setUp();
     reset();
   }
 
@@ skipping 104 matching lines @@
       _expectType(initializer.propagatedType, propagatedType);
     }
   }
 
   SimpleIdentifier findIdentifier(String search) {
     SimpleIdentifier identifier = EngineTestCase.findNode(
         testUnit, testCode, search, (node) => node is SimpleIdentifier);
     return identifier;
   }
 
-  void resolveTestUnit(String code) {
+  Future<Null> resolveTestUnit(String code) async {
     testCode = code;
     testSource = addSource(testCode);
     LibraryElement library = resolve2(testSource);
-    assertNoErrors(testSource);
+    await assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 
   /**
    * Validates that [type] matches [expected].
    *
    * If [expected] is a string, validates that the type stringifies to that
    * text. Otherwise, [expected] is used directly a [Matcher] to match the type.
    */
   _expectType(DartType type, expected) {
     if (expected is String) {
       expect(type.toString(), expected);
     } else {
       expect(type, expected);
     }
   }
 }