Translate private Java members to private Dart members.

pkg/analyzer/test/generated/scanner_test.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.scanner_test;
 
 import 'package:analyzer/src/generated/java_core.dart';
@@ skipping 231 matching lines @@
  * of a stream of tokens.
  */
 class TokenStreamValidator {
   /**
    * Validate that the stream of tokens that starts with the given token is correct.
    *
    * @param token the first token in the stream of tokens to be validated
    */
   void validate(Token token) {
     JavaStringBuilder builder = new JavaStringBuilder();
-    validateStream(builder, token);
+    _validateStream(builder, token);
     if (builder.length > 0) {
       JUnitTestCase.fail(builder.toString());
     }
   }
 
-  void validateStream(JavaStringBuilder builder, Token token) {
+  void _validateStream(JavaStringBuilder builder, Token token) {
     if (token == null) {
       return;
     }
     Token previousToken = null;
     int previousEnd = -1;
     Token currentToken = token;
     while (currentToken != null && currentToken.type != TokenType.EOF) {
-      validateStream(builder, currentToken.precedingComments);
+      _validateStream(builder, currentToken.precedingComments);
       TokenType type = currentToken.type;
       if (identical(type, TokenType.OPEN_CURLY_BRACKET) || identical(type, TokenType.OPEN_PAREN) || identical(type, TokenType.OPEN_SQUARE_BRACKET) || identical(type, TokenType.STRING_INTERPOLATION_EXPRESSION)) {
         if (currentToken is! BeginToken) {
           builder.append("\r\nExpected BeginToken, found ");
           builder.append(currentToken.runtimeType.toString());
           builder.append(" ");
-          writeToken(builder, currentToken);
+          _writeToken(builder, currentToken);
         }
       }
       int currentStart = currentToken.offset;
       int currentLength = currentToken.length;
       int currentEnd = currentStart + currentLength - 1;
       if (currentStart <= previousEnd) {
         builder.append("\r\nInvalid token sequence: ");
-        writeToken(builder, previousToken);
+        _writeToken(builder, previousToken);
         builder.append(" followed by ");
-        writeToken(builder, currentToken);
+        _writeToken(builder, currentToken);
       }
       previousEnd = currentEnd;
       previousToken = currentToken;
       currentToken = currentToken.next;
     }
   }
 
-  void writeToken(JavaStringBuilder builder, Token token) {
+  void _writeToken(JavaStringBuilder builder, Token token) {
     builder.append("[");
     builder.append(token.type);
     builder.append(", '");
     builder.append(token.lexeme);
     builder.append("', ");
     builder.append(token.offset);
     builder.append(", ");
     builder.append(token.length);
     builder.append("]");
   }
 }
 
 class ScannerTest extends JUnitTestCase {
   void test_ampersand() {
-    assertToken(TokenType.AMPERSAND, "&");
+    _assertToken(TokenType.AMPERSAND, "&");
   }
 
   void test_ampersand_ampersand() {
-    assertToken(TokenType.AMPERSAND_AMPERSAND, "&&");
+    _assertToken(TokenType.AMPERSAND_AMPERSAND, "&&");
   }
 
   void test_ampersand_eq() {
-    assertToken(TokenType.AMPERSAND_EQ, "&=");
+    _assertToken(TokenType.AMPERSAND_EQ, "&=");
   }
 
   void test_at() {
-    assertToken(TokenType.AT, "@");
+    _assertToken(TokenType.AT, "@");
   }
 
   void test_backping() {
-    assertToken(TokenType.BACKPING, "`");
+    _assertToken(TokenType.BACKPING, "`");
   }
 
   void test_backslash() {
-    assertToken(TokenType.BACKSLASH, "\\");
+    _assertToken(TokenType.BACKSLASH, "\\");
   }
 
   void test_bang() {
-    assertToken(TokenType.BANG, "!");
+    _assertToken(TokenType.BANG, "!");
   }
 
   void test_bang_eq() {
-    assertToken(TokenType.BANG_EQ, "!=");
+    _assertToken(TokenType.BANG_EQ, "!=");
   }
 
   void test_bar() {
-    assertToken(TokenType.BAR, "|");
+    _assertToken(TokenType.BAR, "|");
   }
 
   void test_bar_bar() {
-    assertToken(TokenType.BAR_BAR, "||");
+    _assertToken(TokenType.BAR_BAR, "||");
   }
 
   void test_bar_eq() {
-    assertToken(TokenType.BAR_EQ, "|=");
+    _assertToken(TokenType.BAR_EQ, "|=");
   }
 
   void test_caret() {
-    assertToken(TokenType.CARET, "^");
+    _assertToken(TokenType.CARET, "^");
   }
 
   void test_caret_eq() {
-    assertToken(TokenType.CARET_EQ, "^=");
+    _assertToken(TokenType.CARET_EQ, "^=");
   }
 
   void test_close_curly_bracket() {
-    assertToken(TokenType.CLOSE_CURLY_BRACKET, "}");
+    _assertToken(TokenType.CLOSE_CURLY_BRACKET, "}");
   }
 
   void test_close_paren() {
-    assertToken(TokenType.CLOSE_PAREN, ")");
+    _assertToken(TokenType.CLOSE_PAREN, ")");
   }
 
   void test_close_quare_bracket() {
-    assertToken(TokenType.CLOSE_SQUARE_BRACKET, "]");
+    _assertToken(TokenType.CLOSE_SQUARE_BRACKET, "]");
   }
 
   void test_colon() {
-    assertToken(TokenType.COLON, ":");
+    _assertToken(TokenType.COLON, ":");
   }
 
   void test_comma() {
-    assertToken(TokenType.COMMA, ",");
+    _assertToken(TokenType.COMMA, ",");
   }
 
   void test_comment_disabled_multi() {
     Scanner scanner = new Scanner(null, new CharSequenceReader("/* comment */ "), AnalysisErrorListener.NULL_LISTENER);
     scanner.preserveComments = false;
     Token token = scanner.tokenize();
     JUnitTestCase.assertNotNull(token);
     JUnitTestCase.assertNull(token.precedingComments);
   }
 
   void test_comment_multi() {
-    assertComment(TokenType.MULTI_LINE_COMMENT, "/* comment */");
+    _assertComment(TokenType.MULTI_LINE_COMMENT, "/* comment */");
   }
 
   void test_comment_multi_unterminated() {
-    assertError(ScannerErrorCode.UNTERMINATED_MULTI_LINE_COMMENT, 3, "/* x");
+    _assertError(ScannerErrorCode.UNTERMINATED_MULTI_LINE_COMMENT, 3, "/* x");
   }
 
   void test_comment_nested() {
-    assertComment(TokenType.MULTI_LINE_COMMENT, "/* comment /* within a */ comment */");
+    _assertComment(TokenType.MULTI_LINE_COMMENT, "/* comment /* within a */ comment */");
   }
 
   void test_comment_single() {
-    assertComment(TokenType.SINGLE_LINE_COMMENT, "// comment");
+    _assertComment(TokenType.SINGLE_LINE_COMMENT, "// comment");
   }
 
   void test_double_both_e() {
-    assertToken(TokenType.DOUBLE, "0.123e4");
+    _assertToken(TokenType.DOUBLE, "0.123e4");
   }
 
   void test_double_both_E() {
-    assertToken(TokenType.DOUBLE, "0.123E4");
+    _assertToken(TokenType.DOUBLE, "0.123E4");
   }
 
   void test_double_fraction() {
-    assertToken(TokenType.DOUBLE, ".123");
+    _assertToken(TokenType.DOUBLE, ".123");
   }
 
   void test_double_fraction_e() {
-    assertToken(TokenType.DOUBLE, ".123e4");
+    _assertToken(TokenType.DOUBLE, ".123e4");
   }
 
   void test_double_fraction_E() {
-    assertToken(TokenType.DOUBLE, ".123E4");
+    _assertToken(TokenType.DOUBLE, ".123E4");
   }
 
   void test_double_missingDigitInExponent() {
-    assertError(ScannerErrorCode.MISSING_DIGIT, 1, "1e");
+    _assertError(ScannerErrorCode.MISSING_DIGIT, 1, "1e");
   }
 
   void test_double_whole_e() {
-    assertToken(TokenType.DOUBLE, "12e4");
+    _assertToken(TokenType.DOUBLE, "12e4");
   }
 
   void test_double_whole_E() {
-    assertToken(TokenType.DOUBLE, "12E4");
+    _assertToken(TokenType.DOUBLE, "12E4");
   }
 
   void test_eq() {
-    assertToken(TokenType.EQ, "=");
+    _assertToken(TokenType.EQ, "=");
   }
 
   void test_eq_eq() {
-    assertToken(TokenType.EQ_EQ, "==");
+    _assertToken(TokenType.EQ_EQ, "==");
   }
 
   void test_gt() {
-    assertToken(TokenType.GT, ">");
+    _assertToken(TokenType.GT, ">");
   }
 
   void test_gt_eq() {
-    assertToken(TokenType.GT_EQ, ">=");
+    _assertToken(TokenType.GT_EQ, ">=");
   }
 
   void test_gt_gt() {
-    assertToken(TokenType.GT_GT, ">>");
+    _assertToken(TokenType.GT_GT, ">>");
   }
 
   void test_gt_gt_eq() {
-    assertToken(TokenType.GT_GT_EQ, ">>=");
+    _assertToken(TokenType.GT_GT_EQ, ">>=");
   }
 
   void test_hash() {
-    assertToken(TokenType.HASH, "#");
+    _assertToken(TokenType.HASH, "#");
   }
 
   void test_hexidecimal() {
-    assertToken(TokenType.HEXADECIMAL, "0x1A2B3C");
+    _assertToken(TokenType.HEXADECIMAL, "0x1A2B3C");
   }
 
   void test_hexidecimal_missingDigit() {
-    assertError(ScannerErrorCode.MISSING_HEX_DIGIT, 1, "0x");
+    _assertError(ScannerErrorCode.MISSING_HEX_DIGIT, 1, "0x");
   }
 
   void test_identifier() {
-    assertToken(TokenType.IDENTIFIER, "result");
+    _assertToken(TokenType.IDENTIFIER, "result");
   }
 
   void test_illegalChar_cyrillicLetter_middle() {
-    assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "Shche\u0433lov");
+    _assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "Shche\u0433lov");
   }
 
   void test_illegalChar_cyrillicLetter_start() {
-    assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "\u0429");
+    _assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "\u0429");
   }
 
   void test_illegalChar_nbsp() {
-    assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "\u00A0");
+    _assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "\u00A0");
   }
 
   void test_illegalChar_notLetter() {
-    assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "\u0312");
+    _assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "\u0312");
   }
 
   void test_index() {
-    assertToken(TokenType.INDEX, "[]");
+    _assertToken(TokenType.INDEX, "[]");
   }
 
   void test_index_eq() {
-    assertToken(TokenType.INDEX_EQ, "[]=");
+    _assertToken(TokenType.INDEX_EQ, "[]=");
   }
 
   void test_int() {
-    assertToken(TokenType.INT, "123");
+    _assertToken(TokenType.INT, "123");
   }
 
   void test_int_initialZero() {
-    assertToken(TokenType.INT, "0123");
+    _assertToken(TokenType.INT, "0123");
   }
 
   void test_keyword_abstract() {
-    assertKeywordToken("abstract");
+    _assertKeywordToken("abstract");
   }
 
   void test_keyword_as() {
-    assertKeywordToken("as");
+    _assertKeywordToken("as");
   }
 
   void test_keyword_assert() {
-    assertKeywordToken("assert");
+    _assertKeywordToken("assert");
   }
 
   void test_keyword_break() {
-    assertKeywordToken("break");
+    _assertKeywordToken("break");
   }
 
   void test_keyword_case() {
-    assertKeywordToken("case");
+    _assertKeywordToken("case");
   }
 
   void test_keyword_catch() {
-    assertKeywordToken("catch");
+    _assertKeywordToken("catch");
   }
 
   void test_keyword_class() {
-    assertKeywordToken("class");
+    _assertKeywordToken("class");
   }
 
   void test_keyword_const() {
-    assertKeywordToken("const");
+    _assertKeywordToken("const");
   }
 
   void test_keyword_continue() {
-    assertKeywordToken("continue");
+    _assertKeywordToken("continue");
   }
 
   void test_keyword_default() {
-    assertKeywordToken("default");
+    _assertKeywordToken("default");
   }
 
   void test_keyword_do() {
-    assertKeywordToken("do");
+    _assertKeywordToken("do");
   }
 
   void test_keyword_dynamic() {
-    assertKeywordToken("dynamic");
+    _assertKeywordToken("dynamic");
   }
 
   void test_keyword_else() {
-    assertKeywordToken("else");
+    _assertKeywordToken("else");
   }
 
   void test_keyword_enum() {
-    assertKeywordToken("enum");
+    _assertKeywordToken("enum");
   }
 
   void test_keyword_export() {
-    assertKeywordToken("export");
+    _assertKeywordToken("export");
   }
 
   void test_keyword_extends() {
-    assertKeywordToken("extends");
+    _assertKeywordToken("extends");
   }
 
   void test_keyword_factory() {
-    assertKeywordToken("factory");
+    _assertKeywordToken("factory");
   }
 
   void test_keyword_false() {
-    assertKeywordToken("false");
+    _assertKeywordToken("false");
   }
 
   void test_keyword_final() {
-    assertKeywordToken("final");
+    _assertKeywordToken("final");
   }
 
   void test_keyword_finally() {
-    assertKeywordToken("finally");
+    _assertKeywordToken("finally");
   }
 
   void test_keyword_for() {
-    assertKeywordToken("for");
+    _assertKeywordToken("for");
   }
 
   void test_keyword_get() {
-    assertKeywordToken("get");
+    _assertKeywordToken("get");
   }
 
   void test_keyword_if() {
-    assertKeywordToken("if");
+    _assertKeywordToken("if");
   }
 
   void test_keyword_implements() {
-    assertKeywordToken("implements");
+    _assertKeywordToken("implements");
   }
 
   void test_keyword_import() {
-    assertKeywordToken("import");
+    _assertKeywordToken("import");
   }
 
   void test_keyword_in() {
-    assertKeywordToken("in");
+    _assertKeywordToken("in");
   }
 
   void test_keyword_is() {
-    assertKeywordToken("is");
+    _assertKeywordToken("is");
   }
 
   void test_keyword_library() {
-    assertKeywordToken("library");
+    _assertKeywordToken("library");
   }
 
   void test_keyword_new() {
-    assertKeywordToken("new");
+    _assertKeywordToken("new");
   }
 
   void test_keyword_null() {
-    assertKeywordToken("null");
+    _assertKeywordToken("null");
   }
 
   void test_keyword_operator() {
-    assertKeywordToken("operator");
+    _assertKeywordToken("operator");
   }
 
   void test_keyword_part() {
-    assertKeywordToken("part");
+    _assertKeywordToken("part");
   }
 
   void test_keyword_rethrow() {
-    assertKeywordToken("rethrow");
+    _assertKeywordToken("rethrow");
   }
 
   void test_keyword_return() {
-    assertKeywordToken("return");
+    _assertKeywordToken("return");
   }
 
   void test_keyword_set() {
-    assertKeywordToken("set");
+    _assertKeywordToken("set");
   }
 
   void test_keyword_static() {
-    assertKeywordToken("static");
+    _assertKeywordToken("static");
   }
 
   void test_keyword_super() {
-    assertKeywordToken("super");
+    _assertKeywordToken("super");
   }
 
   void test_keyword_switch() {
-    assertKeywordToken("switch");
+    _assertKeywordToken("switch");
   }
 
   void test_keyword_this() {
-    assertKeywordToken("this");
+    _assertKeywordToken("this");
   }
 
   void test_keyword_throw() {
-    assertKeywordToken("throw");
+    _assertKeywordToken("throw");
   }
 
   void test_keyword_true() {
-    assertKeywordToken("true");
+    _assertKeywordToken("true");
   }
 
   void test_keyword_try() {
-    assertKeywordToken("try");
+    _assertKeywordToken("try");
   }
 
   void test_keyword_typedef() {
-    assertKeywordToken("typedef");
+    _assertKeywordToken("typedef");
   }
 
   void test_keyword_var() {
-    assertKeywordToken("var");
+    _assertKeywordToken("var");
   }
 
   void test_keyword_void() {
-    assertKeywordToken("void");
+    _assertKeywordToken("void");
   }
 
   void test_keyword_while() {
-    assertKeywordToken("while");
+    _assertKeywordToken("while");
   }
 
   void test_keyword_with() {
-    assertKeywordToken("with");
+    _assertKeywordToken("with");
   }
 
   void test_lineInfo_multilineComment() {
     String source = "/*\r *\r */";
-    assertLineInfo(source, [
+    _assertLineInfo(source, [
         new ScannerTest_ExpectedLocation(0, 1, 1),
         new ScannerTest_ExpectedLocation(4, 2, 2),
         new ScannerTest_ExpectedLocation(source.length - 1, 3, 3)]);
   }
 
   void test_lineInfo_multilineString() {
     String source = "'''a\r\nbc\r\nd'''";
-    assertLineInfo(source, [
+    _assertLineInfo(source, [
         new ScannerTest_ExpectedLocation(0, 1, 1),
         new ScannerTest_ExpectedLocation(7, 2, 2),
         new ScannerTest_ExpectedLocation(source.length - 1, 3, 4)]);
   }
 
   void test_lineInfo_simpleClass() {
     String source = "class Test {\r\n    String s = '...';\r\n    int get x => s.MISSING_GETTER;\r\n}";
-    assertLineInfo(source, [
+    _assertLineInfo(source, [
         new ScannerTest_ExpectedLocation(0, 1, 1),
         new ScannerTest_ExpectedLocation(source.indexOf("MISSING_GETTER"), 3, 20),
         new ScannerTest_ExpectedLocation(source.length - 1, 4, 1)]);
   }
 
   void test_lineInfo_slashN() {
     String source = "class Test {\n}";
-    assertLineInfo(source, [
+    _assertLineInfo(source, [
         new ScannerTest_ExpectedLocation(0, 1, 1),
         new ScannerTest_ExpectedLocation(source.indexOf("}"), 2, 1)]);
   }
 
   void test_lt() {
-    assertToken(TokenType.LT, "<");
+    _assertToken(TokenType.LT, "<");
   }
 
   void test_lt_eq() {
-    assertToken(TokenType.LT_EQ, "<=");
+    _assertToken(TokenType.LT_EQ, "<=");
   }
 
   void test_lt_lt() {
-    assertToken(TokenType.LT_LT, "<<");
+    _assertToken(TokenType.LT_LT, "<<");
   }
 
   void test_lt_lt_eq() {
-    assertToken(TokenType.LT_LT_EQ, "<<=");
+    _assertToken(TokenType.LT_LT_EQ, "<<=");
   }
 
   void test_minus() {
-    assertToken(TokenType.MINUS, "-");
+    _assertToken(TokenType.MINUS, "-");
   }
 
   void test_minus_eq() {
-    assertToken(TokenType.MINUS_EQ, "-=");
+    _assertToken(TokenType.MINUS_EQ, "-=");
   }
 
   void test_minus_minus() {
-    assertToken(TokenType.MINUS_MINUS, "--");
+    _assertToken(TokenType.MINUS_MINUS, "--");
   }
 
   void test_open_curly_bracket() {
-    assertToken(TokenType.OPEN_CURLY_BRACKET, "{");
+    _assertToken(TokenType.OPEN_CURLY_BRACKET, "{");
   }
 
   void test_open_paren() {
-    assertToken(TokenType.OPEN_PAREN, "(");
+    _assertToken(TokenType.OPEN_PAREN, "(");
   }
 
   void test_open_square_bracket() {
-    assertToken(TokenType.OPEN_SQUARE_BRACKET, "[");
+    _assertToken(TokenType.OPEN_SQUARE_BRACKET, "[");
   }
 
   void test_openSquareBracket() {
-    assertToken(TokenType.OPEN_SQUARE_BRACKET, "[");
+    _assertToken(TokenType.OPEN_SQUARE_BRACKET, "[");
   }
 
   void test_percent() {
-    assertToken(TokenType.PERCENT, "%");
+    _assertToken(TokenType.PERCENT, "%");
   }
 
   void test_percent_eq() {
-    assertToken(TokenType.PERCENT_EQ, "%=");
+    _assertToken(TokenType.PERCENT_EQ, "%=");
   }
 
   void test_period() {
-    assertToken(TokenType.PERIOD, ".");
+    _assertToken(TokenType.PERIOD, ".");
   }
 
   void test_period_period() {
-    assertToken(TokenType.PERIOD_PERIOD, "..");
+    _assertToken(TokenType.PERIOD_PERIOD, "..");
   }
 
   void test_period_period_period() {
-    assertToken(TokenType.PERIOD_PERIOD_PERIOD, "...");
+    _assertToken(TokenType.PERIOD_PERIOD_PERIOD, "...");
   }
 
   void test_periodAfterNumberNotIncluded_identifier() {
-    assertTokens("42.isEven()", [
+    _assertTokens("42.isEven()", [
         new StringToken(TokenType.INT, "42", 0),
         new Token(TokenType.PERIOD, 2),
         new StringToken(TokenType.IDENTIFIER, "isEven", 3),
         new Token(TokenType.OPEN_PAREN, 9),
         new Token(TokenType.CLOSE_PAREN, 10)]);
   }
 
   void test_periodAfterNumberNotIncluded_period() {
-    assertTokens("42..isEven()", [
+    _assertTokens("42..isEven()", [
         new StringToken(TokenType.INT, "42", 0),
         new Token(TokenType.PERIOD_PERIOD, 2),
         new StringToken(TokenType.IDENTIFIER, "isEven", 4),
         new Token(TokenType.OPEN_PAREN, 10),
         new Token(TokenType.CLOSE_PAREN, 11)]);
   }
 
   void test_plus() {
-    assertToken(TokenType.PLUS, "+");
+    _assertToken(TokenType.PLUS, "+");
   }
 
   void test_plus_eq() {
-    assertToken(TokenType.PLUS_EQ, "+=");
+    _assertToken(TokenType.PLUS_EQ, "+=");
   }
 
   void test_plus_plus() {
-    assertToken(TokenType.PLUS_PLUS, "++");
+    _assertToken(TokenType.PLUS_PLUS, "++");
   }
 
   void test_question() {
-    assertToken(TokenType.QUESTION, "?");
+    _assertToken(TokenType.QUESTION, "?");
   }
 
   void test_scriptTag_withArgs() {
-    assertToken(TokenType.SCRIPT_TAG, "#!/bin/dart -debug");
+    _assertToken(TokenType.SCRIPT_TAG, "#!/bin/dart -debug");
   }
 
   void test_scriptTag_withoutSpace() {
-    assertToken(TokenType.SCRIPT_TAG, "#!/bin/dart");
+    _assertToken(TokenType.SCRIPT_TAG, "#!/bin/dart");
   }
 
   void test_scriptTag_withSpace() {
-    assertToken(TokenType.SCRIPT_TAG, "#! /bin/dart");
+    _assertToken(TokenType.SCRIPT_TAG, "#! /bin/dart");
   }
 
   void test_semicolon() {
-    assertToken(TokenType.SEMICOLON, ";");
+    _assertToken(TokenType.SEMICOLON, ";");
   }
 
   void test_setSourceStart() {
     int offsetDelta = 42;
     GatheringErrorListener listener = new GatheringErrorListener();
     Scanner scanner = new Scanner(null, new SubSequenceReader("a", offsetDelta), listener);
     scanner.setSourceStart(3, 9);
     scanner.tokenize();
     List<int> lineStarts = scanner.lineStarts;
     JUnitTestCase.assertNotNull(lineStarts);
     JUnitTestCase.assertEquals(3, lineStarts.length);
     JUnitTestCase.assertEquals(33, lineStarts[2]);
   }
 
   void test_slash() {
-    assertToken(TokenType.SLASH, "/");
+    _assertToken(TokenType.SLASH, "/");
   }
 
   void test_slash_eq() {
-    assertToken(TokenType.SLASH_EQ, "/=");
+    _assertToken(TokenType.SLASH_EQ, "/=");
   }
 
   void test_star() {
-    assertToken(TokenType.STAR, "*");
+    _assertToken(TokenType.STAR, "*");
   }
 
   void test_star_eq() {
-    assertToken(TokenType.STAR_EQ, "*=");
+    _assertToken(TokenType.STAR_EQ, "*=");
   }
 
   void test_startAndEnd() {
-    Token token = scan("a");
+    Token token = _scan("a");
     Token previous = token.previous;
     JUnitTestCase.assertEquals(token, previous.next);
     JUnitTestCase.assertEquals(previous, previous.previous);
     Token next = token.next;
     JUnitTestCase.assertEquals(next, next.next);
     JUnitTestCase.assertEquals(token, next.previous);
   }
 
   void test_string_multi_double() {
-    assertToken(TokenType.STRING, "\"\"\"line1\nline2\"\"\"");
+    _assertToken(TokenType.STRING, "\"\"\"line1\nline2\"\"\"");
   }
 
   void test_string_multi_embeddedQuotes() {
-    assertToken(TokenType.STRING, "\"\"\"line1\n\"\"\nline2\"\"\"");
+    _assertToken(TokenType.STRING, "\"\"\"line1\n\"\"\nline2\"\"\"");
   }
 
   void test_string_multi_embeddedQuotes_escapedChar() {
-    assertToken(TokenType.STRING, "\"\"\"a\"\"\\tb\"\"\"");
+    _assertToken(TokenType.STRING, "\"\"\"a\"\"\\tb\"\"\"");
   }
 
   void test_string_multi_interpolation_block() {
-    assertTokens("\"Hello \${name}!\"", [
+    _assertTokens("\"Hello \${name}!\"", [
         new StringToken(TokenType.STRING, "\"Hello ", 0),
         new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 7),
         new StringToken(TokenType.IDENTIFIER, "name", 9),
         new Token(TokenType.CLOSE_CURLY_BRACKET, 13),
         new StringToken(TokenType.STRING, "!\"", 14)]);
   }
 
   void test_string_multi_interpolation_identifier() {
-    assertTokens("\"Hello \$name!\"", [
+    _assertTokens("\"Hello \$name!\"", [
         new StringToken(TokenType.STRING, "\"Hello ", 0),
         new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 7),
         new StringToken(TokenType.IDENTIFIER, "name", 8),
         new StringToken(TokenType.STRING, "!\"", 12)]);
   }
 
   void test_string_multi_single() {
-    assertToken(TokenType.STRING, "'''string'''");
+    _assertToken(TokenType.STRING, "'''string'''");
   }
 
   void test_string_multi_slashEnter() {
-    assertToken(TokenType.STRING, "'''\\\n'''");
+    _assertToken(TokenType.STRING, "'''\\\n'''");
   }
 
   void test_string_multi_unterminated() {
-    assertError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 8, "'''string");
+    _assertError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 8, "'''string");
   }
 
   void test_string_raw_multi_double() {
-    assertToken(TokenType.STRING, "r\"\"\"line1\nline2\"\"\"");
+    _assertToken(TokenType.STRING, "r\"\"\"line1\nline2\"\"\"");
   }
 
   void test_string_raw_multi_single() {
-    assertToken(TokenType.STRING, "r'''string'''");
+    _assertToken(TokenType.STRING, "r'''string'''");
   }
 
   void test_string_raw_multi_unterminated() {
-    assertError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 9, "r'''string");
+    _assertError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 9, "r'''string");
   }
 
   void test_string_raw_simple_double() {
-    assertToken(TokenType.STRING, "r\"string\"");
+    _assertToken(TokenType.STRING, "r\"string\"");
   }
 
   void test_string_raw_simple_single() {
-    assertToken(TokenType.STRING, "r'string'");
+    _assertToken(TokenType.STRING, "r'string'");
   }
 
   void test_string_raw_simple_unterminated_eof() {
-    assertError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 7, "r'string");
+    _assertError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 7, "r'string");
   }
 
   void test_string_raw_simple_unterminated_eol() {
-    assertError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 8, "r'string\n");
+    _assertError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 8, "r'string\n");
   }
 
   void test_string_simple_double() {
-    assertToken(TokenType.STRING, "\"string\"");
+    _assertToken(TokenType.STRING, "\"string\"");
   }
 
   void test_string_simple_escapedDollar() {
-    assertToken(TokenType.STRING, "'a\\\$b'");
+    _assertToken(TokenType.STRING, "'a\\\$b'");
   }
 
   void test_string_simple_interpolation_adjacentIdentifiers() {
-    assertTokens("'\$a\$b'", [
+    _assertTokens("'\$a\$b'", [
         new StringToken(TokenType.STRING, "'", 0),
         new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 1),
         new StringToken(TokenType.IDENTIFIER, "a", 2),
         new StringToken(TokenType.STRING, "", 3),
         new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 3),
         new StringToken(TokenType.IDENTIFIER, "b", 4),
         new StringToken(TokenType.STRING, "'", 5)]);
   }
 
   void test_string_simple_interpolation_block() {
-    assertTokens("'Hello \${name}!'", [
+    _assertTokens("'Hello \${name}!'", [
         new StringToken(TokenType.STRING, "'Hello ", 0),
         new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 7),
         new StringToken(TokenType.IDENTIFIER, "name", 9),
         new Token(TokenType.CLOSE_CURLY_BRACKET, 13),
         new StringToken(TokenType.STRING, "!'", 14)]);
   }
 
   void test_string_simple_interpolation_blockWithNestedMap() {
-    assertTokens("'a \${f({'b' : 'c'})} d'", [
+    _assertTokens("'a \${f({'b' : 'c'})} d'", [
         new StringToken(TokenType.STRING, "'a ", 0),
         new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 3),
         new StringToken(TokenType.IDENTIFIER, "f", 5),
         new Token(TokenType.OPEN_PAREN, 6),
         new Token(TokenType.OPEN_CURLY_BRACKET, 7),
         new StringToken(TokenType.STRING, "'b'", 8),
         new Token(TokenType.COLON, 12),
         new StringToken(TokenType.STRING, "'c'", 14),
         new Token(TokenType.CLOSE_CURLY_BRACKET, 17),
         new Token(TokenType.CLOSE_PAREN, 18),
         new Token(TokenType.CLOSE_CURLY_BRACKET, 19),
         new StringToken(TokenType.STRING, " d'", 20)]);
   }
 
   void test_string_simple_interpolation_firstAndLast() {
-    assertTokens("'\$greeting \$name'", [
+    _assertTokens("'\$greeting \$name'", [
         new StringToken(TokenType.STRING, "'", 0),
         new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 1),
         new StringToken(TokenType.IDENTIFIER, "greeting", 2),
         new StringToken(TokenType.STRING, " ", 10),
         new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 11),
         new StringToken(TokenType.IDENTIFIER, "name", 12),
         new StringToken(TokenType.STRING, "'", 16)]);
   }
 
   void test_string_simple_interpolation_identifier() {
-    assertTokens("'Hello \$name!'", [
+    _assertTokens("'Hello \$name!'", [
         new StringToken(TokenType.STRING, "'Hello ", 0),
         new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 7),
         new StringToken(TokenType.IDENTIFIER, "name", 8),
         new StringToken(TokenType.STRING, "!'", 12)]);
   }
 
   void test_string_simple_interpolation_missingIdentifier() {
-    assertTokens("'\$x\$'", [
+    _assertTokens("'\$x\$'", [
         new StringToken(TokenType.STRING, "'", 0),
         new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 1),
         new StringToken(TokenType.IDENTIFIER, "x", 2),
         new StringToken(TokenType.STRING, "", 3),
         new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 3),
         new StringToken(TokenType.STRING, "'", 4)]);
   }
 
   void test_string_simple_interpolation_nonIdentifier() {
-    assertTokens("'\$1'", [
+    _assertTokens("'\$1'", [
         new StringToken(TokenType.STRING, "'", 0),
         new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 1),
         new StringToken(TokenType.STRING, "1'", 2)]);
   }
 
   void test_string_simple_single() {
-    assertToken(TokenType.STRING, "'string'");
+    _assertToken(TokenType.STRING, "'string'");
   }
 
   void test_string_simple_unterminated_eof() {
-    assertError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 6, "'string");
+    _assertError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 6, "'string");
   }
 
   void test_string_simple_unterminated_eol() {
-    assertError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 7, "'string\r");
+    _assertError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 7, "'string\r");
   }
 
   void test_tilde() {
-    assertToken(TokenType.TILDE, "~");
+    _assertToken(TokenType.TILDE, "~");
   }
 
   void test_tilde_slash() {
-    assertToken(TokenType.TILDE_SLASH, "~/");
+    _assertToken(TokenType.TILDE_SLASH, "~/");
   }
 
   void test_tilde_slash_eq() {
-    assertToken(TokenType.TILDE_SLASH_EQ, "~/=");
+    _assertToken(TokenType.TILDE_SLASH_EQ, "~/=");
   }
 
   void test_unclosedPairInInterpolation() {
     GatheringErrorListener listener = new GatheringErrorListener();
-    scanWithListener("'\${(}'", listener);
+    _scanWithListener("'\${(}'", listener);
   }
 
-  void assertComment(TokenType commentType, String source) {
+  void _assertComment(TokenType commentType, String source) {
     //
     // Test without a trailing end-of-line marker
     //
-    Token token = scan(source);
+    Token token = _scan(source);
     JUnitTestCase.assertNotNull(token);
     JUnitTestCase.assertEquals(TokenType.EOF, token.type);
     Token comment = token.precedingComments;
     JUnitTestCase.assertNotNull(comment);
     JUnitTestCase.assertEquals(commentType, comment.type);
     JUnitTestCase.assertEquals(0, comment.offset);
     JUnitTestCase.assertEquals(source.length, comment.length);
     JUnitTestCase.assertEquals(source, comment.lexeme);
     //
     // Test with a trailing end-of-line marker
     //
-    token = scan("${source}\n");
+    token = _scan("${source}\n");
     JUnitTestCase.assertNotNull(token);
     JUnitTestCase.assertEquals(TokenType.EOF, token.type);
     comment = token.precedingComments;
     JUnitTestCase.assertNotNull(comment);
     JUnitTestCase.assertEquals(commentType, comment.type);
     JUnitTestCase.assertEquals(0, comment.offset);
     JUnitTestCase.assertEquals(source.length, comment.length);
     JUnitTestCase.assertEquals(source, comment.lexeme);
   }
 
   /**
    * Assert that scanning the given source produces an error with the given code.
    *
    * @param illegalCharacter
    * @param i
    * @param source the source to be scanned to produce the error
    */
-  void assertError(ScannerErrorCode expectedError, int expectedOffset, String source) {
+  void _assertError(ScannerErrorCode expectedError, int expectedOffset, String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
-    scanWithListener(source, listener);
+    _scanWithListener(source, listener);
     listener.assertErrors([new AnalysisError.con2(null, expectedOffset, 1, expectedError, [source.codeUnitAt(expectedOffset)])]);
   }
 
   /**
    * Assert that when scanned the given source contains a single keyword token with the same lexeme
    * as the original source.
    *
    * @param source the source to be scanned
    */
-  void assertKeywordToken(String source) {
-    Token token = scan(source);
+  void _assertKeywordToken(String source) {
+    Token token = _scan(source);
     JUnitTestCase.assertNotNull(token);
     JUnitTestCase.assertEquals(TokenType.KEYWORD, token.type);
     JUnitTestCase.assertEquals(0, token.offset);
     JUnitTestCase.assertEquals(source.length, token.length);
     JUnitTestCase.assertEquals(source, token.lexeme);
     Object value = token.value();
     JUnitTestCase.assertTrue(value is Keyword);
     JUnitTestCase.assertEquals(source, (value as Keyword).syntax);
-    token = scan(" ${source} ");
+    token = _scan(" ${source} ");
     JUnitTestCase.assertNotNull(token);
     JUnitTestCase.assertEquals(TokenType.KEYWORD, token.type);
     JUnitTestCase.assertEquals(1, token.offset);
     JUnitTestCase.assertEquals(source.length, token.length);
     JUnitTestCase.assertEquals(source, token.lexeme);
     value = token.value();
     JUnitTestCase.assertTrue(value is Keyword);
     JUnitTestCase.assertEquals(source, (value as Keyword).syntax);
     JUnitTestCase.assertEquals(TokenType.EOF, token.next.type);
   }
 
-  void assertLineInfo(String source, List<ScannerTest_ExpectedLocation> expectedLocations) {
+  void _assertLineInfo(String source, List<ScannerTest_ExpectedLocation> expectedLocations) {
     GatheringErrorListener listener = new GatheringErrorListener();
-    scanWithListener(source, listener);
+    _scanWithListener(source, listener);
     listener.assertNoErrors();
     LineInfo info = listener.getLineInfo(new TestSource());
     JUnitTestCase.assertNotNull(info);
     for (ScannerTest_ExpectedLocation expectedLocation in expectedLocations) {
       LineInfo_Location location = info.getLocation(expectedLocation._offset);
       JUnitTestCase.assertEquals(expectedLocation._lineNumber, location.lineNumber);
       JUnitTestCase.assertEquals(expectedLocation._columnNumber, location.columnNumber);
     }
   }
 
   /**
    * Assert that the token scanned from the given source has the expected type.
    *
    * @param expectedType the expected type of the token
    * @param source the source to be scanned to produce the actual token
    */
-  Token assertToken(TokenType expectedType, String source) {
-    Token originalToken = scan(source);
+  Token _assertToken(TokenType expectedType, String source) {
+    Token originalToken = _scan(source);
     JUnitTestCase.assertNotNull(originalToken);
     JUnitTestCase.assertEquals(expectedType, originalToken.type);
     JUnitTestCase.assertEquals(0, originalToken.offset);
     JUnitTestCase.assertEquals(source.length, originalToken.length);
     JUnitTestCase.assertEquals(source, originalToken.lexeme);
     if (identical(expectedType, TokenType.SCRIPT_TAG)) {
       // Adding space before the script tag is not allowed, and adding text at the end changes nothing.
       return originalToken;
     } else if (identical(expectedType, TokenType.SINGLE_LINE_COMMENT)) {
       // Adding space to an end-of-line comment changes the comment.
-      Token tokenWithSpaces = scan(" ${source}");
+      Token tokenWithSpaces = _scan(" ${source}");
       JUnitTestCase.assertNotNull(tokenWithSpaces);
       JUnitTestCase.assertEquals(expectedType, tokenWithSpaces.type);
       JUnitTestCase.assertEquals(1, tokenWithSpaces.offset);
       JUnitTestCase.assertEquals(source.length, tokenWithSpaces.length);
       JUnitTestCase.assertEquals(source, tokenWithSpaces.lexeme);
       return originalToken;
     } else if (identical(expectedType, TokenType.INT) || identical(expectedType, TokenType.DOUBLE)) {
-      Token tokenWithLowerD = scan("${source}d");
+      Token tokenWithLowerD = _scan("${source}d");
       JUnitTestCase.assertNotNull(tokenWithLowerD);
       JUnitTestCase.assertEquals(expectedType, tokenWithLowerD.type);
       JUnitTestCase.assertEquals(0, tokenWithLowerD.offset);
       JUnitTestCase.assertEquals(source.length, tokenWithLowerD.length);
       JUnitTestCase.assertEquals(source, tokenWithLowerD.lexeme);
-      Token tokenWithUpperD = scan("${source}D");
+      Token tokenWithUpperD = _scan("${source}D");
       JUnitTestCase.assertNotNull(tokenWithUpperD);
       JUnitTestCase.assertEquals(expectedType, tokenWithUpperD.type);
       JUnitTestCase.assertEquals(0, tokenWithUpperD.offset);
       JUnitTestCase.assertEquals(source.length, tokenWithUpperD.length);
       JUnitTestCase.assertEquals(source, tokenWithUpperD.lexeme);
     }
-    Token tokenWithSpaces = scan(" ${source} ");
+    Token tokenWithSpaces = _scan(" ${source} ");
     JUnitTestCase.assertNotNull(tokenWithSpaces);
     JUnitTestCase.assertEquals(expectedType, tokenWithSpaces.type);
     JUnitTestCase.assertEquals(1, tokenWithSpaces.offset);
     JUnitTestCase.assertEquals(source.length, tokenWithSpaces.length);
     JUnitTestCase.assertEquals(source, tokenWithSpaces.lexeme);
     JUnitTestCase.assertEquals(TokenType.EOF, originalToken.next.type);
     return originalToken;
   }
 
   /**
    * Assert that when scanned the given source contains a sequence of tokens identical to the given
    * tokens.
    *
    * @param source the source to be scanned
    * @param expectedTokens the tokens that are expected to be in the source
    */
-  void assertTokens(String source, List<Token> expectedTokens) {
-    Token token = scan(source);
+  void _assertTokens(String source, List<Token> expectedTokens) {
+    Token token = _scan(source);
     JUnitTestCase.assertNotNull(token);
     for (int i = 0; i < expectedTokens.length; i++) {
       Token expectedToken = expectedTokens[i];
       JUnitTestCase.assertEqualsMsg("Wrong type for token ${i}", expectedToken.type, token.type);
       JUnitTestCase.assertEqualsMsg("Wrong offset for token ${i}", expectedToken.offset, token.offset);
       JUnitTestCase.assertEqualsMsg("Wrong length for token ${i}", expectedToken.length, token.length);
       JUnitTestCase.assertEqualsMsg("Wrong lexeme for token ${i}", expectedToken.lexeme, token.lexeme);
       token = token.next;
       JUnitTestCase.assertNotNull(token);
     }
     JUnitTestCase.assertEquals(TokenType.EOF, token.type);
   }
 
-  Token scan(String source) {
+  Token _scan(String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
-    Token token = scanWithListener(source, listener);
+    Token token = _scanWithListener(source, listener);
     listener.assertNoErrors();
     return token;
   }
 
-  Token scanWithListener(String source, GatheringErrorListener listener) {
+  Token _scanWithListener(String source, GatheringErrorListener listener) {
     Scanner scanner = new Scanner(null, new CharSequenceReader(source), listener);
     Token result = scanner.tokenize();
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     return result;
   }
 
   static dartSuite() {
     _ut.group('ScannerTest', () {
       _ut.test('test_ampersand', () {
         final __test = new ScannerTest();
@@ skipping 684 matching lines @@
 
   /**
    * The first token from the token stream resulting from performing an incremental scan, or
    * `null` if [scan] has not been invoked.
    */
   Token _incrementalTokens;
 
   void test_delete_identifier_beginning() {
     // "abs + b;"
     // "s + b;")
-    scan("", "ab", "", "s + b;");
-    assertTokens(-1, 1, ["s", "+", "b", ";"]);
+    _scan("", "ab", "", "s + b;");
+    _assertTokens(-1, 1, ["s", "+", "b", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_delete_identifier_end() {
     // "abs + b;"
     // "a + b;")
-    scan("a", "bs", "", " + b;");
-    assertTokens(-1, 1, ["a", "+", "b", ";"]);
+    _scan("a", "bs", "", " + b;");
+    _assertTokens(-1, 1, ["a", "+", "b", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_delete_identifier_middle() {
     // "abs + b;"
     // "as + b;")
-    scan("a", "b", "", "s + b;");
-    assertTokens(-1, 1, ["as", "+", "b", ";"]);
+    _scan("a", "b", "", "s + b;");
+    _assertTokens(-1, 1, ["as", "+", "b", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_delete_mergeTokens() {
     // "a + b + c;"
     // "ac;")
-    scan("a", " + b + ", "", "c;");
-    assertTokens(-1, 1, ["ac", ";"]);
+    _scan("a", " + b + ", "", "c;");
+    _assertTokens(-1, 1, ["ac", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_afterIdentifier1() {
     // "a + b;"
     // "abs + b;"
-    scan("a", "", "bs", " + b;");
-    assertTokens(-1, 1, ["abs", "+", "b", ";"]);
-    assertReplaced(1, "+");
+    _scan("a", "", "bs", " + b;");
+    _assertTokens(-1, 1, ["abs", "+", "b", ";"]);
+    _assertReplaced(1, "+");
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_afterIdentifier2() {
     // "a + b;"
     // "a + by;"
-    scan("a + b", "", "y", ";");
-    assertTokens(1, 3, ["a", "+", "by", ";"]);
+    _scan("a + b", "", "y", ";");
+    _assertTokens(1, 3, ["a", "+", "by", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_beforeIdentifier() {
     // "a + b;"
     // "a + xb;")
-    scan("a + ", "", "x", "b;");
-    assertTokens(1, 3, ["a", "+", "xb", ";"]);
+    _scan("a + ", "", "x", "b;");
+    _assertTokens(1, 3, ["a", "+", "xb", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_beforeIdentifier_firstToken() {
     // "a + b;"
     // "xa + b;"
-    scan("", "", "x", "a + b;");
-    assertTokens(-1, 1, ["xa", "+", "b", ";"]);
+    _scan("", "", "x", "a + b;");
+    _assertTokens(-1, 1, ["xa", "+", "b", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_convertOneFunctionToTwo() {
     // "f() {}"
     // "f() => 0; g() {}"
-    scan("f()", "", " => 0; g()", " {}");
-    assertTokens(2, 9, ["f", "(", ")", "=>", "0", ";", "g", "(", ")", "{", "}"]);
+    _scan("f()", "", " => 0; g()", " {}");
+    _assertTokens(2, 9, ["f", "(", ")", "=>", "0", ";", "g", "(", ")", "{", "}"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_end() {
     // "class A {}"
     // "class A {} class B {}"
-    scan("class A {}", "", " class B {}", "");
-    assertTokens(3, 8, ["class", "A", "{", "}", "class", "B", "{", "}"]);
+    _scan("class A {}", "", " class B {}", "");
+    _assertTokens(3, 8, ["class", "A", "{", "}", "class", "B", "{", "}"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_insideIdentifier() {
     // "cob;"
     // "cow.b;"
-    scan("co", "", "w.", "b;");
-    assertTokens(-1, 3, ["cow", ".", "b", ";"]);
+    _scan("co", "", "w.", "b;");
+    _assertTokens(-1, 3, ["cow", ".", "b", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_newIdentifier1() {
     // "a;  c;"
     // "a; b c;"
-    scan("a; ", "", "b", " c;");
-    assertTokens(1, 3, ["a", ";", "b", "c", ";"]);
+    _scan("a; ", "", "b", " c;");
+    _assertTokens(1, 3, ["a", ";", "b", "c", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_newIdentifier2() {
     // "a;  c;"
     // "a;b  c;"
-    scan("a;", "", "b", "  c;");
-    assertTokens(1, 3, ["a", ";", "b", "c", ";"]);
-    assertReplaced(1, ";");
+    _scan("a;", "", "b", "  c;");
+    _assertTokens(1, 3, ["a", ";", "b", "c", ";"]);
+    _assertReplaced(1, ";");
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_period() {
     // "a + b;"
     // "a + b.;"
-    scan("a + b", "", ".", ";");
-    assertTokens(2, 4, ["a", "+", "b", ".", ";"]);
+    _scan("a + b", "", ".", ";");
+    _assertTokens(2, 4, ["a", "+", "b", ".", ";"]);
   }
 
   void test_insert_period_betweenIdentifiers1() {
     // "a b;"
     // "a. b;"
-    scan("a", "", ".", " b;");
-    assertTokens(0, 2, ["a", ".", "b", ";"]);
+    _scan("a", "", ".", " b;");
+    _assertTokens(0, 2, ["a", ".", "b", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_period_betweenIdentifiers2() {
     // "a b;"
     // "a .b;"
-    scan("a ", "", ".", "b;");
-    assertTokens(0, 2, ["a", ".", "b", ";"]);
+    _scan("a ", "", ".", "b;");
+    _assertTokens(0, 2, ["a", ".", "b", ";"]);
   }
 
   void test_insert_period_betweenIdentifiers3() {
     // "a  b;"
     // "a . b;"
-    scan("a ", "", ".", " b;");
-    assertTokens(0, 2, ["a", ".", "b", ";"]);
+    _scan("a ", "", ".", " b;");
+    _assertTokens(0, 2, ["a", ".", "b", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_period_insideExistingIdentifier() {
     // "ab;"
     // "a.b;"
-    scan("a", "", ".", "b;");
-    assertTokens(-1, 3, ["a", ".", "b", ";"]);
+    _scan("a", "", ".", "b;");
+    _assertTokens(-1, 3, ["a", ".", "b", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_periodAndIdentifier() {
     // "a + b;"
     // "a + b.x;"
-    scan("a + b", "", ".x", ";");
-    assertTokens(2, 5, ["a", "+", "b", ".", "x", ";"]);
+    _scan("a + b", "", ".x", ";");
+    _assertTokens(2, 5, ["a", "+", "b", ".", "x", ";"]);
   }
 
   void test_insert_whitespace_beginning_beforeToken() {
     // "a + b;"
     // " a + b;"
-    scan("", "", " ", "a + b;");
-    assertTokens(0, 1, ["a", "+", "b", ";"]);
+    _scan("", "", " ", "a + b;");
+    _assertTokens(0, 1, ["a", "+", "b", ";"]);
     JUnitTestCase.assertFalse(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_whitespace_betweenTokens() {
     // "a + b;"
     // "a  + b;"
-    scan("a ", "", " ", "+ b;");
-    assertTokens(1, 2, ["a", "+", "b", ";"]);
+    _scan("a ", "", " ", "+ b;");
+    _assertTokens(1, 2, ["a", "+", "b", ";"]);
     JUnitTestCase.assertFalse(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_whitespace_end_afterToken() {
     // "a + b;"
     // "a + b; "
-    scan("a + b;", "", " ", "");
-    assertTokens(3, 4, ["a", "+", "b", ";"]);
+    _scan("a + b;", "", " ", "");
+    _assertTokens(3, 4, ["a", "+", "b", ";"]);
     JUnitTestCase.assertFalse(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_whitespace_end_afterWhitespace() {
     // "a + b; "
     // "a + b;  "
-    scan("a + b; ", "", " ", "");
-    assertTokens(3, 4, ["a", "+", "b", ";"]);
+    _scan("a + b; ", "", " ", "");
+    _assertTokens(3, 4, ["a", "+", "b", ";"]);
     JUnitTestCase.assertFalse(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_insert_whitespace_withMultipleComments() {
     // "//comment", "//comment2", "a + b;"
     // "//comment", "//comment2", "a  + b;"
-    scan(EngineTestCase.createSource(["//comment", "//comment2", "a"]), "", " ", " + b;");
-    assertTokens(1, 2, ["a", "+", "b", ";"]);
+    _scan(EngineTestCase.createSource(["//comment", "//comment2", "a"]), "", " ", " + b;");
+    _assertTokens(1, 2, ["a", "+", "b", ";"]);
     JUnitTestCase.assertFalse(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_replace_identifier_beginning() {
     // "bell + b;"
     // "fell + b;")
-    scan("", "b", "f", "ell + b;");
-    assertTokens(-1, 1, ["fell", "+", "b", ";"]);
+    _scan("", "b", "f", "ell + b;");
+    _assertTokens(-1, 1, ["fell", "+", "b", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_replace_identifier_end() {
     // "bell + b;"
     // "belt + b;")
-    scan("bel", "l", "t", " + b;");
-    assertTokens(-1, 1, ["belt", "+", "b", ";"]);
+    _scan("bel", "l", "t", " + b;");
+    _assertTokens(-1, 1, ["belt", "+", "b", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_replace_identifier_middle() {
     // "first + b;"
     // "frost + b;")
-    scan("f", "ir", "ro", "st + b;");
-    assertTokens(-1, 1, ["frost", "+", "b", ";"]);
+    _scan("f", "ir", "ro", "st + b;");
+    _assertTokens(-1, 1, ["frost", "+", "b", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_replace_multiple_partialFirstAndLast() {
     // "aa + bb;"
     // "ab * ab;")
-    scan("a", "a + b", "b * a", "b;");
-    assertTokens(-1, 3, ["ab", "*", "ab", ";"]);
+    _scan("a", "a + b", "b * a", "b;");
+    _assertTokens(-1, 3, ["ab", "*", "ab", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_replace_operator_oneForMany() {
     // "a + b;"
     // "a * c - b;")
-    scan("a ", "+", "* c -", " b;");
-    assertTokens(0, 4, ["a", "*", "c", "-", "b", ";"]);
+    _scan("a ", "+", "* c -", " b;");
+    _assertTokens(0, 4, ["a", "*", "c", "-", "b", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_replace_operator_oneForOne() {
     // "a + b;"
     // "a * b;")
-    scan("a ", "+", "*", " b;");
-    assertTokens(0, 2, ["a", "*", "b", ";"]);
+    _scan("a ", "+", "*", " b;");
+    _assertTokens(0, 2, ["a", "*", "b", ";"]);
     JUnitTestCase.assertTrue(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   void test_tokenMap() {
     // "main() {a + b;}"
     // "main() { a + b;}"
-    scan("main() {", "", " ", "a + b;}");
+    _scan("main() {", "", " ", "a + b;}");
     TokenMap tokenMap = _incrementalScanner.tokenMap;
     Token oldToken = _originalTokens;
     while (oldToken.type != TokenType.EOF) {
       Token newToken = tokenMap.get(oldToken);
       JUnitTestCase.assertNotSame(oldToken, newToken);
       JUnitTestCase.assertSame(oldToken.type, newToken.type);
       JUnitTestCase.assertEquals(oldToken.lexeme, newToken.lexeme);
       oldToken = oldToken.next;
     }
     JUnitTestCase.assertFalse(_incrementalScanner.hasNonWhitespaceChange);
   }
 
   /**
    * Assert that the token at the given offset was replaced with a new token having the given
    * lexeme.
    *
    * @param tokenOffset the offset of the token being tested
    * @param lexeme the expected lexeme of the new token
    */
-  void assertReplaced(int tokenOffset, String lexeme) {
+  void _assertReplaced(int tokenOffset, String lexeme) {
     Token oldToken = _originalTokens;
     for (int i = 0; i < tokenOffset; i++) {
       oldToken = oldToken.next;
     }
     JUnitTestCase.assertEquals(lexeme, oldToken.lexeme);
     Token newToken = _incrementalScanner.tokenMap.get(oldToken);
     JUnitTestCase.assertNotNull(newToken);
     JUnitTestCase.assertEquals(lexeme, newToken.lexeme);
     JUnitTestCase.assertNotSame(oldToken, newToken);
   }
 
   /**
    * Assert that the result of the incremental scan matches the given list of lexemes and that the
    * left and right tokens correspond to the tokens at the given indices.
    *
    * @param leftIndex the expected index of the left token
    * @param rightIndex the expected index of the right token
    * @param lexemes the expected lexemes of the resulting tokens
    */
-  void assertTokens(int leftIndex, int rightIndex, List<String> lexemes) {
+  void _assertTokens(int leftIndex, int rightIndex, List<String> lexemes) {
     int count = lexemes.length;
     JUnitTestCase.assertTrueMsg("Invalid left index", leftIndex >= -1 && leftIndex < count);
     JUnitTestCase.assertTrueMsg("Invalid right index", rightIndex >= 0 && rightIndex <= count);
     Token leftToken = null;
     Token rightToken = null;
     Token token = _incrementalTokens;
     if (leftIndex < 0) {
       leftToken = token.previous;
     }
     for (int i = 0; i < count; i++) {
@@ skipping 23 matching lines @@
   /**
    * Given a description of the original and modified contents, perform an incremental scan of the
    * two pieces of text. Verify that the incremental scan produced the same tokens as those that
    * would be produced by a full scan of the new contents.
    *
    * @param prefix the unchanged text before the edit region
    * @param removed the text that was removed from the original contents
    * @param added the text that was added to the modified contents
    * @param suffix the unchanged text after the edit region
    */
-  void scan(String prefix, String removed, String added, String suffix) {
+  void _scan(String prefix, String removed, String added, String suffix) {
     //
     // Compute the information needed to perform the test.
     //
     String originalContents = "${prefix}${removed}${suffix}";
     String modifiedContents = "${prefix}${added}${suffix}";
     int replaceStart = prefix.length;
     Source source = new TestSource();
     //
     // Scan the original contents.
     //
@@ skipping 162 matching lines @@
   }
 }
 
 main() {
   CharSequenceReaderTest.dartSuite();
   IncrementalScannerTest.dartSuite();
   KeywordStateTest.dartSuite();
   ScannerTest.dartSuite();
   TokenTypeTest.dartSuite();
 }