anchor.diff:      List<bool> found = new List<bool>.filled(expectedSize, false);
       for (int i = 0; i < expectedSize; i++) {
         _privateAssertContains(array, found, expectedElements[i]);
  -    }
  -  }
  -
  -  /**
  -   * 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) {
  -        fail("Content not as expected: is 'null' expected: $expected");
  -      } else {
  -        fail("Content not as expected: expected 'null' is: $actual");
  -      }
  -    }
  -    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";
  -      expect(actual, expected, reason: message);
       }
     }
   
  
positive.code:     }
      return object;
    }
  
    /**
     * 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) {
      expect(actualToken.type, expectedToken.type);
      if (expectedToken is KeywordToken) {
        assertInstanceOf((obj) => obj is KeywordToken, KeywordToken, actualToken);
        expect((actualToken as KeywordToken).keyword, expectedToken.keyword);
      } else if (expectedToken is StringToken) {
        assertInstanceOf((obj) => obj is StringToken, StringToken, actualToken);
        expect((actualToken as StringToken).lexeme, expectedToken.lexeme);
      }
    }
  
  
    /**
     * @return the [AstNode] with requested type at offset of the "prefix".
  
negative.code:     }
      AstNode node = new NodeLocator.con1(offset).searchWithin(root);
      return node.getAncestor(predicate);
    }
  
    static void _privateAssertContains(List<Object> array, List<bool> found,
  