New analyzer snapshot. Sorted unit members.

pkg/analyzer/test/generated/test_support.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.test_support;
 
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_junit.dart';
 import 'package:analyzer/src/generated/java_engine.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';
 import 'package:unittest/unittest.dart' as _ut;
 
 /**
+ * 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 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
+   */
+  static void assertCollectionSize(int expectedSize, Iterable c) {
+    if (c == null) {
+      JUnitTestCase.fail("Expected collection of size ${expectedSize}; found null");
+    } else if (c.length != expectedSize) {
+      JUnitTestCase.fail("Expected collection of size ${expectedSize}; contained ${c.length} elements");
+    }
+  }
+
+  /**
+   * 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 `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");
+    }
+    List<bool> found = new List<bool>.filled(expectedSize, false);
+    for (int i = 0; i < expectedSize; i++) {
+      _privateAssertContains(array, found, expectedElements[i]);
+    }
+  }
+
+  /**
+   * Assert that the array of actual values contain exactly the same values as those in the array of
+   * expected value, with the exception that the order of the elements is not required to be the
+   * same.
+   *
+   * @param expectedValues the values that are expected to be found
+   * @param actualValues the actual values that are being compared against the expected values
+   */
+  static void assertEqualsIgnoreOrder(List<Object> expectedValues, List<Object> actualValues) {
+    JUnitTestCase.assertNotNull(actualValues);
+    int expectedLength = expectedValues.length;
+    JUnitTestCase.assertEquals(expectedLength, actualValues.length);
+    List<bool> found = new List<bool>.filled(expectedLength, false);
+    for (int i = 0; i < expectedLength; i++) {
+      found[i] = false;
+    }
+    for (Object actualValue in actualValues) {
+      bool wasExpected = false;
+      for (int i = 0; i < expectedLength; i++) {
+        if (!found[i] && expectedValues[i] == actualValue) {
+          found[i] = true;
+          wasExpected = true;
+          break;
+        }
+      }
+      if (!wasExpected) {
+        JUnitTestCase.fail("The actual value ${actualValue} was not expected");
+      }
+    }
+  }
+
+  /**
+   * 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 (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 - _PRINT_RANGE);
+      int diffAfter = Math.min(actual.length, diffPos + _PRINT_RANGE);
+      String diffStr = "${actual.substring(diffAhead, diffPos)}^${actual.substring(diffPos, diffAfter)}";
+      // use detailed message
+      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 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 `null` or does not have the expected
+   *           elements
+   */
+  static void assertExactElementsInArray(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-`null` and has exactly expected elements.
+   *
+   * @param list the list being tested
+   * @param expectedElements the expected elements
+   * @throws AssertionFailedError if the list is `null` or does not have the expected elements
+   */
+  static void assertExactElementsInList(List 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 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 `null` or does not have the expected elements
+   */
+  static void assertExactElementsInSet(Set 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++) {
+      Object expectedElement = expectedElements[i];
+      if (!set.contains(expectedElement)) {
+        JUnitTestCase.fail("Expected ${expectedElement} in set${set}");
+      }
+    }
+  }
+
+  /**
+   * 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(Predicate<Object> predicate, Type expectedClass, Object object) {
+    if (!predicate(object)) {
+      JUnitTestCase.fail("Expected instance of ${expectedClass.toString()}, found ${(object == null ? "null" : object.runtimeType.toString())}");
+    }
+    return object;
+  }
+
+  /**
+   * 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 `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((obj) => obj is KeywordToken, KeywordToken, actualToken);
+      JUnitTestCase.assertEquals(expectedToken.keyword, (actualToken as KeywordToken).keyword);
+    } else if (expectedToken is StringToken) {
+      assertInstanceOf((obj) => obj is StringToken, StringToken, actualToken);
+      JUnitTestCase.assertEquals(expectedToken.lexeme, (actualToken as StringToken).lexeme);
+    }
+  }
+
+  /**
+   * 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 `null` or does not have the expected number
+   *           of elements
+   */
+  static void assertSizeOfList(int expectedSize, List 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-`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 `null` or does not have the expected number of
+   *           elements
+   */
+  static void assertSizeOfMap(int expectedSize, Map 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-`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 `null` or does not have the expected number of
+   *           elements
+   */
+  static void assertSizeOfSet(int expectedSize, Set 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");
+    }
+  }
+
+  /**
+   * Convert the given array of lines into a single source string.
+   *
+   * @param lines the lines to be merged into a single source string
+   * @return the source string composed of the given lines
+   */
+  static String createSource(List<String> lines) {
+    PrintStringWriter writer = new PrintStringWriter();
+    for (String line in lines) {
+      writer.println(line);
+    }
+    return writer.toString();
+  }
+
+  /**
+   * @return the [AstNode] with requested type at offset of the "prefix".
+   */
+  static AstNode findNode(AstNode root, String code, String prefix, Predicate<AstNode> predicate) {
+    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(predicate);
+  }
+
+  /**
+   * 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.codeUnitAt(i) != str2.codeUnitAt(i)) {
+        diffPos = i;
+        break;
+      }
+    }
+    if (diffPos == -1 && str1.length != str2.length) {
+      diffPos = len1;
+    }
+    return diffPos;
+  }
+
+  static void _privateAssertContains(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;
+          }
+        }
+      }
+      JUnitTestCase.fail("Does not contain null");
+    } else {
+      for (int i = 0; i < array.length; i++) {
+        if (!found[i]) {
+          if (element == array[i]) {
+            found[i] = true;
+            return;
+          }
+        }
+      }
+      JUnitTestCase.fail("Does not contain ${element}");
+    }
+  }
+
+  AnalysisContextImpl createAnalysisContext() {
+    AnalysisContextImpl context = new AnalysisContextImpl();
+    context.sourceFactory = new SourceFactory([]);
+    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
+   * @param getterName the name of the getter to be returned
+   * @return the property accessor element representing the getter with the given name
+   */
+  PropertyAccessorElement getGetter(InterfaceType type, String getterName) {
+    for (PropertyAccessorElement accessor in type.element.accessors) {
+      if (accessor.isGetter && accessor.name == getterName) {
+        return accessor;
+      }
+    }
+    JUnitTestCase.fail("Could not find getter named ${getterName} in ${type.displayName}");
+    return null;
+  }
+
+  /**
+   * Return the method in the given type with the given name. Inherited methods are ignored.
+   *
+   * @param type the type in which the method is declared
+   * @param methodName the name of the method to be returned
+   * @return the method element representing the method with the given name
+   */
+  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', () {
+    });
+  }
+}
+
+/**
  * 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.
    */
   final String _rawSource;
 
   /**
@@ skipping 366 matching lines @@
     for (AnalysisError error in errors) {
       if (_equalErrors(error, targetError)) {
         errors.remove(error);
         return true;
       }
     }
     return false;
   }
 }
 
-/**
- * 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 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
-   */
-  static void assertCollectionSize(int expectedSize, Iterable c) {
-    if (c == null) {
-      JUnitTestCase.fail("Expected collection of size ${expectedSize}; found null");
-    } else if (c.length != expectedSize) {
-      JUnitTestCase.fail("Expected collection of size ${expectedSize}; contained ${c.length} elements");
-    }
-  }
-
-  /**
-   * 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 `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");
-    }
-    List<bool> found = new List<bool>.filled(expectedSize, false);
-    for (int i = 0; i < expectedSize; i++) {
-      _privateAssertContains(array, found, expectedElements[i]);
-    }
-  }
-
-  /**
-   * Assert that the array of actual values contain exactly the same values as those in the array of
-   * expected value, with the exception that the order of the elements is not required to be the
-   * same.
-   *
-   * @param expectedValues the values that are expected to be found
-   * @param actualValues the actual values that are being compared against the expected values
-   */
-  static void assertEqualsIgnoreOrder(List<Object> expectedValues, List<Object> actualValues) {
-    JUnitTestCase.assertNotNull(actualValues);
-    int expectedLength = expectedValues.length;
-    JUnitTestCase.assertEquals(expectedLength, actualValues.length);
-    List<bool> found = new List<bool>.filled(expectedLength, false);
-    for (int i = 0; i < expectedLength; i++) {
-      found[i] = false;
-    }
-    for (Object actualValue in actualValues) {
-      bool wasExpected = false;
-      for (int i = 0; i < expectedLength; i++) {
-        if (!found[i] && expectedValues[i] == actualValue) {
-          found[i] = true;
-          wasExpected = true;
-          break;
-        }
-      }
-      if (!wasExpected) {
-        JUnitTestCase.fail("The actual value ${actualValue} was not expected");
-      }
-    }
-  }
-
-  /**
-   * 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 (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 - _PRINT_RANGE);
-      int diffAfter = Math.min(actual.length, diffPos + _PRINT_RANGE);
-      String diffStr = "${actual.substring(diffAhead, diffPos)}^${actual.substring(diffPos, diffAfter)}";
-      // use detailed message
-      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 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 `null` or does not have the expected
-   *           elements
-   */
-  static void assertExactElementsInArray(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-`null` and has exactly expected elements.
-   *
-   * @param list the list being tested
-   * @param expectedElements the expected elements
-   * @throws AssertionFailedError if the list is `null` or does not have the expected elements
-   */
-  static void assertExactElementsInList(List 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 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 `null` or does not have the expected elements
-   */
-  static void assertExactElementsInSet(Set 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++) {
-      Object expectedElement = expectedElements[i];
-      if (!set.contains(expectedElement)) {
-        JUnitTestCase.fail("Expected ${expectedElement} in set${set}");
-      }
-    }
-  }
-
-  /**
-   * 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(Predicate<Object> predicate, Type expectedClass, Object object) {
-    if (!predicate(object)) {
-      JUnitTestCase.fail("Expected instance of ${expectedClass.toString()}, found ${(object == null ? "null" : object.runtimeType.toString())}");
-    }
-    return object;
-  }
-
-  /**
-   * 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 `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((obj) => obj is KeywordToken, KeywordToken, actualToken);
-      JUnitTestCase.assertEquals(expectedToken.keyword, (actualToken as KeywordToken).keyword);
-    } else if (expectedToken is StringToken) {
-      assertInstanceOf((obj) => obj is StringToken, StringToken, actualToken);
-      JUnitTestCase.assertEquals(expectedToken.lexeme, (actualToken as StringToken).lexeme);
-    }
-  }
-
-  /**
-   * 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 `null` or does not have the expected number
-   *           of elements
-   */
-  static void assertSizeOfList(int expectedSize, List 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-`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 `null` or does not have the expected number of
-   *           elements
-   */
-  static void assertSizeOfMap(int expectedSize, Map 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-`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 `null` or does not have the expected number of
-   *           elements
-   */
-  static void assertSizeOfSet(int expectedSize, Set 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");
-    }
-  }
-
-  /**
-   * Convert the given array of lines into a single source string.
-   *
-   * @param lines the lines to be merged into a single source string
-   * @return the source string composed of the given lines
-   */
-  static String createSource(List<String> lines) {
-    PrintStringWriter writer = new PrintStringWriter();
-    for (String line in lines) {
-      writer.println(line);
-    }
-    return writer.toString();
-  }
-
-  /**
-   * @return the [AstNode] with requested type at offset of the "prefix".
-   */
-  static AstNode findNode(AstNode root, String code, String prefix, Predicate<AstNode> predicate) {
-    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(predicate);
-  }
-
-  /**
-   * 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.codeUnitAt(i) != str2.codeUnitAt(i)) {
-        diffPos = i;
-        break;
-      }
-    }
-    if (diffPos == -1 && str1.length != str2.length) {
-      diffPos = len1;
-    }
-    return diffPos;
-  }
-
-  static void _privateAssertContains(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;
-          }
-        }
-      }
-      JUnitTestCase.fail("Does not contain null");
-    } else {
-      for (int i = 0; i < array.length; i++) {
-        if (!found[i]) {
-          if (element == array[i]) {
-            found[i] = true;
-            return;
-          }
-        }
-      }
-      JUnitTestCase.fail("Does not contain ${element}");
-    }
-  }
-
-  AnalysisContextImpl createAnalysisContext() {
-    AnalysisContextImpl context = new AnalysisContextImpl();
-    context.sourceFactory = new SourceFactory([]);
-    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
-   * @param getterName the name of the getter to be returned
-   * @return the property accessor element representing the getter with the given name
-   */
-  PropertyAccessorElement getGetter(InterfaceType type, String getterName) {
-    for (PropertyAccessorElement accessor in type.element.accessors) {
-      if (accessor.isGetter && accessor.name == getterName) {
-        return accessor;
-      }
-    }
-    JUnitTestCase.fail("Could not find getter named ${getterName} in ${type.displayName}");
-    return null;
-  }
-
-  /**
-   * Return the method in the given type with the given name. Inherited methods are ignored.
-   *
-   * @param type the type in which the method is declared
-   * @param methodName the name of the method to be returned
-   * @return the method element representing the method with the given name
-   */
-  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 {
   String _name;
   TestSource([this._name = '/test.dart']);
   int get hashCode => 0;
   bool operator ==(Object object) {
     return object is TestSource;
   }
@@ skipping 25 matching lines @@
   Source resolveRelative(Uri uri) {
     throw new UnsupportedOperationException();
   }
   UriKind get uriKind {
     throw new UnsupportedOperationException();
   }
   TimestampedData<String> get contents {
     throw new UnsupportedOperationException();
   }
 }