Fresh drop of analyzer-experimental.

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';
@@ skipping 24 matching lines @@
    */
   Map<Source, LineInfo> _lineInfoMap = new Map<Source, LineInfo>();
   /**
    * An empty array of errors used when no errors are expected.
    */
   static List<AnalysisError> _NO_ERRORS = new List<AnalysisError>.fixedLength(0);
   /**
    * Initialize a newly created error listener to collect errors.
    */
   GatheringErrorListener() : super() {
-    _jtd_constructor_234_impl();
+    _jtd_constructor_258_impl();
   }
-  _jtd_constructor_234_impl() {
+  _jtd_constructor_258_impl() {
   }
   /**
    * Initialize a newly created error listener to collect errors.
    */
-  GatheringErrorListener.con1(String rawSource) {
-    _jtd_constructor_235_impl(rawSource);
+  GatheringErrorListener.con1(String rawSource2) {
+    _jtd_constructor_259_impl(rawSource2);
   }
-  _jtd_constructor_235_impl(String rawSource) {
-    this._rawSource = rawSource;
-    this._markedSource = rawSource;
+  _jtd_constructor_259_impl(String rawSource2) {
+    this._rawSource = rawSource2;
+    this._markedSource = rawSource2;
   }
   /**
    * Assert that the number of errors that have been gathered matches the number of errors that are
    * given and that they have the expected error codes and locations. The order in which the errors
    * were gathered is ignored.
    * @param errorCodes the errors that should have been gathered
    * @throws AssertionFailedError if a different number of errors have been gathered than were
    * expected or if they do not have the same codes and locations
    */
   void assertErrors(List<AnalysisError> expectedErrors) {
@@ skipping 95 matching lines @@
    * are given and that there are the same number of errors and warnings as specified by the
    * argument. The order in which the errors were gathered is ignored.
    * @param expectedSeverities the severities of the errors that should have been gathered
    * @throws AssertionFailedError if a different number of errors have been gathered than were
    * expected
    */
   void assertErrors3(List<ErrorSeverity> expectedSeverities) {
     int expectedErrorCount = 0;
     int expectedWarningCount = 0;
     for (ErrorSeverity severity in expectedSeverities) {
-      if (severity == ErrorSeverity.ERROR) {
+      if (identical(severity, ErrorSeverity.ERROR)) {
         expectedErrorCount++;
       } else {
         expectedWarningCount++;
       }
     }
     int actualErrorCount = 0;
     int actualWarningCount = 0;
     for (AnalysisError error in _errors) {
-      if (error.errorCode.errorSeverity == ErrorSeverity.ERROR) {
+      if (identical(error.errorCode.errorSeverity, ErrorSeverity.ERROR)) {
         actualErrorCount++;
       } else {
         actualWarningCount++;
       }
     }
     if (expectedErrorCount != actualErrorCount || expectedWarningCount != actualWarningCount) {
       JUnitTestCase.fail("Expected ${expectedErrorCount} errors and ${expectedWarningCount} warnings, found ${actualErrorCount} errors and ${actualWarningCount} warnings");
     }
   }
   /**
    * Assert that no errors have been gathered.
    * @throws AssertionFailedError if any errors have been gathered
    */
   void assertNoErrors() {
-    assertErrors(GatheringErrorListener._NO_ERRORS);
+    assertErrors(_NO_ERRORS);
   }
   /**
    * Return the errors that were collected.
    * @return the errors that were collected
    */
   List<AnalysisError> get errors => _errors;
   /**
    * Return {@code 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
    */
-  bool hasError(ErrorCode errorCode) {
+  bool hasError(ErrorCode errorCode4) {
     for (AnalysisError error in _errors) {
-      if (error.errorCode == errorCode) {
+      if (identical(error.errorCode, errorCode4)) {
         return true;
       }
     }
     return false;
   }
   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)}";
@@ skipping 15 matching lines @@
    */
   void setLineInfo2(Source source, LineInfo lineInfo) {
     _lineInfoMap[source] = lineInfo;
   }
   /**
    * Return {@code 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
    */
-  bool equals(AnalysisError firstError, AnalysisError secondError) => firstError.errorCode == secondError.errorCode && firstError.offset == secondError.offset && firstError.length == secondError.length && equals3(firstError.source, secondError.source);
+  bool equals(AnalysisError firstError, AnalysisError secondError) => identical(firstError.errorCode, secondError.errorCode) && firstError.offset == secondError.offset && firstError.length == secondError.length && equals3(firstError.source, secondError.source);
   /**
    * Return {@code 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
    */
   bool equals3(Source firstSource, Source secondSource) {
     if (firstSource == null) {
       return secondSource == null;
     } else if (secondSource == null) {
       return false;
     }
     return firstSource == secondSource;
   }
   /**
    * Assert that the number of errors that have been gathered 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 errorCodes the errors that should have been gathered
    * @throws AssertionFailedError with
    */
   void fail(List<AnalysisError> expectedErrors) {
     PrintStringWriter writer = new PrintStringWriter();
     writer.print("Expected ");
     writer.print(expectedErrors.length);
     writer.print(" errors:");
     for (AnalysisError error in expectedErrors) {
-      Source source5 = error.source;
-      LineInfo lineInfo = _lineInfoMap[source5];
+      Source source9 = error.source;
+      LineInfo lineInfo = _lineInfoMap[source9];
       writer.println();
       if (lineInfo == null) {
-        int offset8 = error.offset;
-        writer.printf("  %s %s (%d..%d)", [source5 == null ? "" : source5.shortName, error.errorCode, offset8, offset8 + error.length]);
+        int offset9 = error.offset;
+        writer.printf("  %s %s (%d..%d)", [source9 == null ? "" : source9.shortName, error.errorCode, offset9, offset9 + error.length]);
       } else {
         LineInfo_Location location = lineInfo.getLocation(error.offset);
-        writer.printf("  %s %s (%d, %d/%d)", [source5 == null ? "" : source5.shortName, error.errorCode, location.lineNumber, location.columnNumber, error.length]);
+        writer.printf("  %s %s (%d, %d/%d)", [source9 == null ? "" : source9.shortName, error.errorCode, location.lineNumber, location.columnNumber, error.length]);
       }
     }
     writer.println();
     writer.print("found ");
     writer.print(_errors.length);
     writer.print(" errors:");
     for (AnalysisError error in _errors) {
-      Source source6 = error.source;
-      LineInfo lineInfo = _lineInfoMap[source6];
+      Source source10 = error.source;
+      LineInfo lineInfo = _lineInfoMap[source10];
       writer.println();
       if (lineInfo == null) {
-        int offset9 = error.offset;
-        writer.printf("  %s %s (%d..%d): %s", [source6 == null ? "" : source6.shortName, error.errorCode, offset9, offset9 + error.length, error.message]);
+        int offset10 = error.offset;
+        writer.printf("  %s %s (%d..%d): %s", [source10 == null ? "" : source10.shortName, error.errorCode, offset10, offset10 + error.length, error.message]);
       } else {
         LineInfo_Location location = lineInfo.getLocation(error.offset);
-        writer.printf("  %s %s (%d, %d/%d): %s", [source6 == null ? "" : source6.shortName, error.errorCode, location.lineNumber, location.columnNumber, error.length, error.message]);
+        writer.printf("  %s %s (%d, %d/%d): %s", [source10 == null ? "" : source10.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.
    * @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
@@ skipping 59 matching lines @@
       }
     }
   }
   /**
    * Assert that a given String is equal to an expected value.
    * @param expected the expected String value
    * @param actual the actual String value
    */
   static void assertEqualString(String expected, String actual) {
     if (actual == null || expected == null) {
-      if (actual == expected) {
+      if (identical(actual, expected)) {
         return;
       }
       if (actual == null) {
         JUnitTestCase.assertTrueMsg("Content not as expected: is 'null' expected: ${expected}", false);
       } else {
         JUnitTestCase.assertTrueMsg("Content not as expected: expected 'null' is: ${actual}", false);
       }
     }
     int diffPos = getDiffPos(expected, actual);
     if (diffPos != -1) {
-      int diffAhead = Math.max(0, diffPos - EngineTestCase._PRINT_RANGE);
-      int diffAfter = Math.min(actual.length, diffPos + EngineTestCase._PRINT_RANGE);
+      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.
    * @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
@@ skipping 62 matching lines @@
    * Assert that the given object is an instance of the expected class.
    * @param expectedClass the class that the object is expected to be an instance of
    * @param object the object being tested
    * @return the object that was being tested
    * @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;
+    return (object as Object);
   }
   /**
    * Assert that the given array is non-{@code 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
    * 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);
+      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);
+      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.
    * @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
    * of elements
    */
   static void assertSize(int expectedSize, List<Object> list) {
@@ skipping 32 matching lines @@
   /**
    * Calculate the offset where the given strings differ.
    * @param str1 the first String to compare
    * @param str2 the second String to compare
    * @return the offset at which the strings differ (or <code>-1</code> if they do not)
    */
   static int getDiffPos(String str1, String str2) {
     int len1 = Math.min(str1.length, str2.length);
     int diffPos = -1;
     for (int i = 0; i < len1; i++) {
-      if (str1.charCodeAt(i) != str2.charCodeAt(i)) {
+      if (str1.codeUnitAt(i) != str2.codeUnitAt(i)) {
         diffPos = i;
         break;
       }
     }
     if (diffPos == -1 && str1.length != str2.length) {
       diffPos = len1;
     }
     return diffPos;
   }
   static dartSuite() {
@@ skipping 45 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");
     }
   }
 }