New analyzer_experimental snapshot.

pkg/analyzer_experimental/test/generated/test_support.dart

 // 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.test_support;
 import 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
 import 'package:analyzer_experimental/src/generated/element.dart' show InterfaceType, MethodElement, PropertyAccessorElement;
 import 'package:analyzer_experimental/src/generated/engine.dart' show AnalysisContext, AnalysisContextImpl, RecordingErrorListener;
 import 'package:unittest/unittest.dart' as _ut;
 /**
- * Instances of the class {@code GatheringErrorListener} implement an error listener that collects
+ * Instances of the class `GatheringErrorListener` implement an error listener that collects
  * all of the errors passed to it for later examination.
  */
 class GatheringErrorListener implements AnalysisErrorListener {
 
   /**
    * The source being parsed.
    */
   String _rawSource;
 
   /**
@@ skipping 194 matching lines @@
     assertErrors(_NO_ERRORS);
   }
 
   /**
    * Return the errors that were collected.
    * @return the errors that were collected
    */
   List<AnalysisError> get errors => _errors;
 
   /**
-   * Return the line information associated with the given source, or {@code null} if no line
+   * Return the line information associated with the given source, or `null` if no line
    * information has been associated with the source.
    * @param source the source with which the line information is associated
    * @return the line information associated with the source
    */
   LineInfo getLineInfo(Source source) => _lineInfoMap[source];
 
   /**
-   * Return {@code true} if an error with the given error code has been gathered.
+   * Return `true` if an error with the given error code has been gathered.
    * @param errorCode the error code being searched for
-   * @return {@code true} if an error with the given error code has been gathered
+   * @return `true` if an error with the given error code has been gathered
    */
   bool hasError(ErrorCode errorCode2) {
     for (AnalysisError error in _errors) {
       if (identical(error.errorCode, errorCode2)) {
         return true;
       }
     }
     return false;
   }
 
   /**
-   * Return {@code true} if at least one error has been gathered.
-   * @return {@code true} if at least one error has been gathered
+   * Return `true` if at least one error has been gathered.
+   * @return `true` if at least one error has been gathered
    */
   bool hasErrors() => _errors.length > 0;
   void onError(AnalysisError error) {
     if (_rawSource != null) {
       int left = error.offset;
       int right = left + error.length - 1;
       _markedSource = "${_rawSource.substring(0, left)}^${_rawSource.substring(left, right)}^${_rawSource.substring(right)}";
     }
     _errors.add(error);
   }
@@ skipping 10 matching lines @@
   /**
    * Set the line information associated with the given source to the given information.
    * @param source the source with which the line information is associated
    * @param lineInfo the line information to be associated with the source
    */
   void setLineInfo2(Source source, LineInfo lineInfo) {
     _lineInfoMap[source] = lineInfo;
   }
 
   /**
-   * Return {@code true} if the two errors are equivalent.
+   * Return `true` if the two errors are equivalent.
    * @param firstError the first error being compared
    * @param secondError the second error being compared
-   * @return {@code true} if the two errors are equivalent
+   * @return `true` if the two errors are equivalent
    */
   bool equals3(AnalysisError firstError, AnalysisError secondError) => identical(firstError.errorCode, secondError.errorCode) && firstError.offset == secondError.offset && firstError.length == secondError.length && equals4(firstError.source, secondError.source);
 
   /**
-   * Return {@code true} if the two sources are equivalent.
+   * Return `true` if the two sources are equivalent.
    * @param firstSource the first source being compared
    * @param secondSource the second source being compared
-   * @return {@code true} if the two sources are equivalent
+   * @return `true` if the two sources are equivalent
    */
   bool equals4(Source firstSource, Source secondSource) {
     if (firstSource == null) {
       return secondSource == null;
     } else if (secondSource == null) {
       return false;
     }
     return firstSource == secondSource;
   }
 
@@ skipping 35 matching lines @@
       } else {
         LineInfo_Location location = lineInfo.getLocation(error.offset);
         writer.printf("  %s %s (%d, %d/%d): %s", [source == null ? "" : source.shortName, error.errorCode, location.lineNumber, location.columnNumber, error.length, error.message]);
       }
     }
     JUnitTestCase.fail(writer.toString());
   }
 
   /**
    * Search through the given list of errors for an error that is equal to the target error. If one
-   * is found, remove it from the list and return {@code true}, otherwise return {@code false}without modifying the list.
+   * is found, remove it from the list and return `true`, otherwise return `false`without modifying the list.
    * @param errors the errors through which we are searching
    * @param targetError the error being searched for
-   * @return {@code true} if the error is found and removed from the list
+   * @return `true` if the error is found and removed from the list
    */
   bool foundAndRemoved(List<AnalysisError> errors, AnalysisError targetError) {
     for (AnalysisError error in errors) {
       if (equals3(error, targetError)) {
         errors.remove(error);
         return true;
       }
     }
     return true;
   }
 }
 /**
- * The class {@code EngineTestCase} defines utility methods for making assertions.
+ * The class `EngineTestCase` defines utility methods for making assertions.
  */
 class EngineTestCase extends JUnitTestCase {
   static int _PRINT_RANGE = 6;
 
   /**
    * Assert that the tokens in the actual stream of tokens have the same types and lexemes as the
    * tokens in the expected stream of tokens. Note that this does not assert anything about the
    * offsets of the tokens (although the lengths will be equal).
    * @param expectedStream the head of the stream of tokens that were expected
    * @param actualStream the head of the stream of tokens that were actually found
    * @throws AssertionFailedError if the two streams of tokens are not the same
    */
   static void assertAllMatch(Token expectedStream, Token actualStream) {
     Token left = expectedStream;
     Token right = actualStream;
     while (left.type != TokenType.EOF && right.type != TokenType.EOF) {
       assertMatches(left, right);
       left = left.next;
       right = right.next;
     }
   }
 
   /**
-   * Assert that the given array is non-{@code null} and contains the expected elements. The
+   * Assert that the given array is non-`null` and contains the expected elements. The
    * elements can appear in any order.
    * @param array the array being tested
    * @param expectedElements the expected elements
-   * @throws AssertionFailedError if the array is {@code null} or does not contain the expected
+   * @throws AssertionFailedError if the array is `null` or does not contain the expected
    * elements
    */
   static void assertContains(List<Object> array, List<Object> expectedElements) {
     int expectedSize = expectedElements.length;
     if (array == null) {
       JUnitTestCase.fail("Expected array of length ${expectedSize}; found null");
     }
     if (array.length != expectedSize) {
       JUnitTestCase.fail("Expected array of length ${expectedSize}; contained ${array.length} elements");
     }
@@ skipping 53 matching lines @@
     if (diffPos != -1) {
       int diffAhead = Math.max(0, diffPos - _PRINT_RANGE);
       int diffAfter = Math.min(actual.length, diffPos + _PRINT_RANGE);
       String diffStr = "${actual.substring(diffAhead, diffPos)}^${actual.substring(diffPos, diffAfter)}";
       String message = "Content not as expected: is\n${actual}\nDiffers at pos ${diffPos}: ${diffStr}\nexpected:\n${expected}";
       JUnitTestCase.assertEqualsMsg(message, expected, actual);
     }
   }
 
   /**
-   * Assert that the given list is non-{@code null} and has exactly expected elements.
+   * Assert that the given list is non-`null` and has exactly expected elements.
    * @param list the list being tested
    * @param expectedElements the expected elements
-   * @throws AssertionFailedError if the list is {@code null} or does not have the expected elements
+   * @throws AssertionFailedError if the list is `null` or does not have the expected elements
    */
   static void assertExactElements(List<Object> list, List<Object> expectedElements) {
     int expectedSize = expectedElements.length;
     if (list == null) {
       JUnitTestCase.fail("Expected list of size ${expectedSize}; found null");
     }
     if (list.length != expectedSize) {
       JUnitTestCase.fail("Expected list of size ${expectedSize}; contained ${list.length} elements");
     }
     for (int i = 0; i < expectedSize; i++) {
       Object element = list[i];
       Object expectedElement = expectedElements[i];
       if (!element == expectedElement) {
         JUnitTestCase.fail("Expected ${expectedElement} at [${i}]; found ${element}");
       }
     }
   }
 
   /**
-   * Assert that the given array is non-{@code null} and has exactly expected elements.
+   * Assert that the given array is non-`null` and has exactly expected elements.
    * @param array the array being tested
    * @param expectedElements the expected elements
-   * @throws AssertionFailedError if the array is {@code null} or does not have the expected
+   * @throws AssertionFailedError if the array is `null` or does not have the expected
    * elements
    */
   static void assertExactElements2(List<Object> array, List<Object> expectedElements) {
     int expectedSize = expectedElements.length;
     if (array == null) {
       JUnitTestCase.fail("Expected array of size ${expectedSize}; found null");
     }
     if (array.length != expectedSize) {
       JUnitTestCase.fail("Expected array of size ${expectedSize}; contained ${array.length} elements");
     }
     for (int i = 0; i < expectedSize; i++) {
       Object element = array[i];
       Object expectedElement = expectedElements[i];
       if (!element == expectedElement) {
         JUnitTestCase.fail("Expected ${expectedElement} at [${i}]; found ${element}");
       }
     }
   }
 
   /**
-   * Assert that the given list is non-{@code null} and has exactly expected elements.
+   * Assert that the given list is non-`null` and has exactly expected elements.
    * @param set the list being tested
    * @param expectedElements the expected elements
-   * @throws AssertionFailedError if the list is {@code null} or does not have the expected elements
+   * @throws AssertionFailedError if the list is `null` or does not have the expected elements
    */
   static void assertExactElements3(Set<Object> set, List<Object> expectedElements) {
     int expectedSize = expectedElements.length;
     if (set == null) {
       JUnitTestCase.fail("Expected list of size ${expectedSize}; found null");
     }
     if (set.length != expectedSize) {
       JUnitTestCase.fail("Expected list of size ${expectedSize}; contained ${set.length} elements");
     }
     for (int i = 0; i < expectedSize; i++) {
@@ skipping 12 matching lines @@
    * @throws Exception if the object is not an instance of the expected class
    */
   static Object assertInstanceOf(Type expectedClass, Object object) {
     if (!isInstanceOf(object, expectedClass)) {
       JUnitTestCase.fail("Expected instance of ${expectedClass.toString()}, found ${(object == null ? "null" : object.runtimeType.toString())}");
     }
     return object as Object;
   }
 
   /**
-   * Assert that the given array is non-{@code null} and has the expected number of elements.
+   * Assert that the given array is non-`null` and has the expected number of elements.
    * @param expectedLength the expected number of elements
    * @param array the array being tested
-   * @throws AssertionFailedError if the array is {@code null} or does not have the expected number
+   * @throws AssertionFailedError if the array is `null` or does not have the expected number
    * of elements
    */
   static void assertLength(int expectedLength, List<Object> array) {
     if (array == null) {
       JUnitTestCase.fail("Expected array of length ${expectedLength}; found null");
     } else if (array.length != expectedLength) {
       JUnitTestCase.fail("Expected array of length ${expectedLength}; contained ${array.length} elements");
     }
   }
 
   /**
    * Assert that the actual token has the same type and lexeme as the expected token. Note that this
    * does not assert anything about the offsets of the tokens (although the lengths will be equal).
    * @param expectedToken the token that was expected
    * @param actualToken the token that was found
    * @throws AssertionFailedError if the two tokens are not the same
    */
   static void assertMatches(Token expectedToken, Token actualToken) {
     JUnitTestCase.assertEquals(expectedToken.type, actualToken.type);
     if (expectedToken is KeywordToken) {
       assertInstanceOf(KeywordToken, actualToken);
       JUnitTestCase.assertEquals(((expectedToken as KeywordToken)).keyword, ((actualToken as KeywordToken)).keyword);
     } else if (expectedToken is StringToken) {
       assertInstanceOf(StringToken, actualToken);
       JUnitTestCase.assertEquals(((expectedToken as StringToken)).lexeme, ((actualToken as StringToken)).lexeme);
     }
   }
 
   /**
-   * Assert that the given list is non-{@code null} and has the expected number of elements.
+   * Assert that the given list is non-`null` and has the expected number of elements.
    * @param expectedSize the expected number of elements
    * @param list the list being tested
-   * @throws AssertionFailedError if the list is {@code null} or does not have the expected number
+   * @throws AssertionFailedError if the list is `null` or does not have the expected number
    * of elements
    */
   static void assertSize(int expectedSize, List<Object> list) {
     if (list == null) {
       JUnitTestCase.fail("Expected list of size ${expectedSize}; found null");
     } else if (list.length != expectedSize) {
       JUnitTestCase.fail("Expected list of size ${expectedSize}; contained ${list.length} elements");
     }
   }
 
   /**
-   * Assert that the given map is non-{@code null} and has the expected number of elements.
+   * Assert that the given map is non-`null` and has the expected number of elements.
    * @param expectedSize the expected number of elements
    * @param map the map being tested
-   * @throws AssertionFailedError if the map is {@code null} or does not have the expected number of
+   * @throws AssertionFailedError if the map is `null` or does not have the expected number of
    * elements
    */
   static void assertSize2(int expectedSize, Map<Object, Object> map) {
     if (map == null) {
       JUnitTestCase.fail("Expected map of size ${expectedSize}; found null");
     } else if (map.length != expectedSize) {
       JUnitTestCase.fail("Expected map of size ${expectedSize}; contained ${map.length} elements");
     }
   }
 
   /**
-   * Assert that the given set is non-{@code null} and has the expected number of elements.
+   * Assert that the given set is non-`null` and has the expected number of elements.
    * @param expectedSize the expected number of elements
    * @param set the set being tested
-   * @throws AssertionFailedError if the set is {@code null} or does not have the expected number of
+   * @throws AssertionFailedError if the set is `null` or does not have the expected number of
    * elements
    */
   static void assertSize3(int expectedSize, Set<Object> set) {
     if (set == null) {
       JUnitTestCase.fail("Expected set of size ${expectedSize}; found null");
     } else if (set.length != expectedSize) {
       JUnitTestCase.fail("Expected set of size ${expectedSize}; contained ${set.length} elements");
     }
   }
 
@@ skipping 156 matching lines @@
         return trampoline(target, arguments[0], arguments[1]);
       case 3:
         return trampoline(target, arguments[0], arguments[1], arguments[2]);
       case 4:
         return trampoline(target, arguments[0], arguments[1], arguments[2], arguments[3]);
       default:
         throw new IllegalArgumentException("Not implemented for > 4 arguments");
     }
   }
 }