New analyzer snapshot.

pkg/analyzer/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 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_junit.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/ast.dart' show ASTNode, NodeLocator;
 import 'package:analyzer/src/generated/element.dart' show InterfaceType, MethodElement, PropertyAccessorElement;
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext, AnalysisContextImpl, RecordingErrorListener;
 import 'package:unittest/unittest.dart' as _ut;
+
 /**
  * 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;
 
   /**
    * The source being parsed after inserting a marker at the beginning and end of the range of the
    * most recent error.
    */
   String _markedSource;
@@ skipping 211 matching lines @@
     }
     return false;
   }
 
   /**
    * 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 117 matching lines @@
   bool foundAndRemoved(List<AnalysisError> errors, AnalysisError targetError) {
     for (AnalysisError error in errors) {
       if (equals4(error, targetError)) {
         errors.remove(error);
         return true;
       }
     }
     return true;
   }
 }
+
 /**
  * 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).
@@ skipping 201 matching lines @@
    * 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 collection is non-`null` and has the expected number of elements.
    *
    * @param expectedSize the expected number of elements
    * @param c the collection being tested
    * @throws AssertionFailedError if the list is `null` or does not have the expected number
    *           of elements
@@ skipping 72 matching lines @@
    * @return the [ASTNode] with requested type at offset of the "prefix".
    */
   static ASTNode findNode(ASTNode root, String code, String prefix, Type clazz) {
     int offset = code.indexOf(prefix);
     if (offset == -1) {
       throw new IllegalArgumentException("Not found '${prefix}'.");
     }
     ASTNode node = new NodeLocator.con1(offset).searchWithin(root);
     return node.getAncestor(clazz);
   }
+
   static void assertContains2(List<Object> array, List<bool> found, Object element) {
     if (element == null) {
       for (int i = 0; i < array.length; i++) {
         if (!found[i]) {
           if (array[i] == null) {
             found[i] = true;
             return;
           }
         }
       }
@@ skipping 25 matching lines @@
       if (str1.codeUnitAt(i) != str2.codeUnitAt(i)) {
         diffPos = i;
         break;
       }
     }
     if (diffPos == -1 && str1.length != str2.length) {
       diffPos = len1;
     }
     return diffPos;
   }
+
   AnalysisContextImpl createAnalysisContext() {
     AnalysisContextImpl context = new AnalysisContextImpl();
     context.sourceFactory = new SourceFactory.con2([]);
     return context;
   }
 
   /**
    * Return the getter in the given type with the given name. Inherited getters are ignored.
    *
    * @param type the type in which the getter is declared
@@ skipping 19 matching lines @@
    */
   MethodElement getMethod(InterfaceType type, String methodName) {
     for (MethodElement method in type.element.methods) {
       if (method.name == methodName) {
         return method;
       }
     }
     JUnitTestCase.fail("Could not find method named ${methodName} in ${type.displayName}");
     return null;
   }
+
   static dartSuite() {
     _ut.group('EngineTestCase', () {
     });
   }
 }
+
 main() {
 }
 
 class TestSource implements Source {
   int get hashCode => 0;
   bool operator ==(Object object) {
     return object is TestSource;
   }
   AnalysisContext get context {
     throw new UnsupportedOperationException();
@@ skipping 48 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");
     }
   }
 }