anchor.diff:      }
       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,
  
positive.code:   }
  
    /**
     * 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) {
        fail("Expected array of size $expectedSize; found null");
      }
      if (array.length != expectedSize) {
        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) {
          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) {
        fail("Expected list of size $expectedSize; found null");
      }
      if (list.length != expectedSize) {
        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) {
          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) {
        fail("Expected list of size $expectedSize; found null");
      }
      if (set.length != expectedSize) {
        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)) {
          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
  
negative.code:  * The class `EngineTestCase` defines utility methods for making assertions.
   */
  class EngineTestCase {
    void setUp() {}
  
    void tearDown() {}
  