Format and sort analyzer and analysis_server packages.

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/source.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/scanner.dart';
+import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart' show TokenMap;
 import 'package:unittest/unittest.dart';
+
+import '../reflective_tests.dart';
 import 'test_support.dart';
-import '../reflective_tests.dart';
 
 
+main() {
+  groupSep = ' | ';
+  runReflectiveTests(CharSequenceReaderTest);
+  runReflectiveTests(IncrementalScannerTest);
+  runReflectiveTests(KeywordStateTest);
+  runReflectiveTests(ScannerTest);
+  runReflectiveTests(TokenTypeTest);
+}
+
 class CharSequenceReaderTest {
   void test_advance() {
     CharSequenceReader reader = new CharSequenceReader("x");
     expect(reader.advance(), 0x78);
     expect(reader.advance(), -1);
     expect(reader.advance(), -1);
   }
 
   void test_creation() {
     expect(new CharSequenceReader("x"), isNotNull);
@@ skipping 48 matching lines @@
   IncrementalScanner _incrementalScanner;
 
   /**
    * The first token from the token stream resulting from performing an
    * incremental scan, or `null` if [scan] has not been invoked.
    */
   Token _incrementalTokens;
 
   void fail_insert_beginning() {
     // This is currently reporting the changed range as being from 0 to 5, but
-    // that would force us to re-parse both classes, which is clearly sub-optimal.
+    // that would force us to re-parse both classes, which is clearly
+    // sub-optimal.
     //
     // "class B {}"
     // "class A {} class B {}"
     _scan("", "", "class A {} ", "class B {}");
     _assertTokens(-1, 4, ["class", "A", "{", "}", "class", "B", "{", "}"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_delete_identifier_beginning() {
     // "abs + b;"
@@ skipping 73 matching lines @@
     // "xa + b;"
     _scan("", "", "x", "a + b;");
     _assertTokens(-1, 1, ["xa", "+", "b", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_convertOneFunctionToTwo() {
     // "f() {}"
     // "f() => 0; g() {}"
     _scan("f()", "", " => 0; g()", " {}");
-    _assertTokens(2, 9, ["f", "(", ")", "=>", "0", ";", "g", "(", ")", "{", "}"]);
+    _assertTokens(
+        2,
+        9,
+        ["f", "(", ")", "=>", "0", ";", "g", "(", ")", "{", "}"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_convertOneFunctionToTwo_overlap() {
     // "f() {}"
     // "f() {} g() {}"
     _scan("f() {", "", "} g() {", "}");
     _assertTokens(4, 10, ["f", "(", ")", "{", "}", "g", "(", ")", "{", "}"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
@@ skipping 300 matching lines @@
         _originalTokens,
         replaceStart,
         removed.length,
         added.length);
     //
     // Validate that the results of the incremental scan are the same as the
     // full scan of the modified source.
     //
     Token incrementalToken = _incrementalTokens;
     expect(incrementalToken, isNotNull);
-    while (incrementalToken.type != TokenType.EOF
-        && modifiedTokens.type != TokenType.EOF) {
+    while (incrementalToken.type != TokenType.EOF &&
+        modifiedTokens.type != TokenType.EOF) {
       expect(
           incrementalToken.type,
           same(modifiedTokens.type),
           reason: "Wrong type for token");
       expect(
           incrementalToken.offset,
-              modifiedTokens.offset,
-              reason: "Wrong offset for token");
+          modifiedTokens.offset,
+          reason: "Wrong offset for token");
       expect(
           incrementalToken.length,
-              modifiedTokens.length,
-              reason: "Wrong length for token");
+          modifiedTokens.length,
+          reason: "Wrong length for token");
       expect(
           incrementalToken.lexeme,
-              modifiedTokens.lexeme,
-              reason: "Wrong lexeme for token");
+          modifiedTokens.lexeme,
+          reason: "Wrong lexeme for token");
       incrementalToken = incrementalToken.next;
       modifiedTokens = modifiedTokens.next;
     }
     expect(
         incrementalToken.type,
         same(TokenType.EOF),
         reason: "Too many tokens");
     expect(
         modifiedTokens.type,
         same(TokenType.EOF),
@@ skipping 41 matching lines @@
         // keyword.substring(0, keyword.length() - 1)
         expect(state, isNotNull);
       }
     }
   }
 }
 
 class ScannerTest {
   void fail_incomplete_string_interpolation() {
     // https://code.google.com/p/dart/issues/detail?id=18073
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 9, "\"foo \${bar", [
-        new StringToken(TokenType.STRING, "\"foo ", 0),
-        new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 5),
-        new StringToken(TokenType.IDENTIFIER, "bar", 7)]);
+    _assertErrorAndTokens(
+        ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+        9,
+        "\"foo \${bar",
+        [
+            new StringToken(TokenType.STRING, "\"foo ", 0),
+            new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 5),
+            new StringToken(TokenType.IDENTIFIER, "bar", 7)]);
   }
 
   void test_ampersand() {
     _assertToken(TokenType.AMPERSAND, "&");
   }
 
   void test_ampersand_ampersand() {
     _assertToken(TokenType.AMPERSAND_AMPERSAND, "&&");
   }
 
@@ skipping 55 matching lines @@
 
   void test_colon() {
     _assertToken(TokenType.COLON, ":");
   }
 
   void test_comma() {
     _assertToken(TokenType.COMMA, ",");
   }
 
   void test_comment_disabled_multi() {
-    Scanner scanner = new Scanner(null, new CharSequenceReader("/* comment */ "), AnalysisErrorListener.NULL_LISTENER);
+    Scanner scanner = new Scanner(
+        null,
+        new CharSequenceReader("/* comment */ "),
+        AnalysisErrorListener.NULL_LISTENER);
     scanner.preserveComments = false;
     Token token = scanner.tokenize();
     expect(token, isNotNull);
     expect(token.precedingComments, isNull);
   }
 
   void test_comment_multi() {
     _assertComment(TokenType.MULTI_LINE_COMMENT, "/* comment */");
   }
 
   void test_comment_multi_unterminated() {
     _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");
   }
 
   void test_double_both_e() {
     _assertToken(TokenType.DOUBLE, "0.123e4");
   }
 
@@ skipping 284 matching lines @@
   void test_keyword_while() {
     _assertKeywordToken("while");
   }
 
   void test_keyword_with() {
     _assertKeywordToken("with");
   }
 
   void test_lineInfo_multilineComment() {
     String source = "/*\r *\r */";
-    _assertLineInfo(source, [
-        new ScannerTest_ExpectedLocation(0, 1, 1),
-        new ScannerTest_ExpectedLocation(4, 2, 2),
-        new ScannerTest_ExpectedLocation(source.length - 1, 3, 3)]);
+    _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, [
-        new ScannerTest_ExpectedLocation(0, 1, 1),
-        new ScannerTest_ExpectedLocation(7, 2, 2),
-        new ScannerTest_ExpectedLocation(source.length - 1, 3, 4)]);
+    _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, [
-        new ScannerTest_ExpectedLocation(0, 1, 1),
-        new ScannerTest_ExpectedLocation(source.indexOf("MISSING_GETTER"), 3, 20),
-        new ScannerTest_ExpectedLocation(source.length - 1, 4, 1)]);
+    String source =
+        "class Test {\r\n    String s = '...';\r\n    int get x => s.MISSING_GETTER;\r\n}";
+    _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, [
-        new ScannerTest_ExpectedLocation(0, 1, 1),
-        new ScannerTest_ExpectedLocation(source.indexOf("}"), 2, 1)]);
+    _assertLineInfo(
+        source,
+        [
+            new ScannerTest_ExpectedLocation(0, 1, 1),
+            new ScannerTest_ExpectedLocation(source.indexOf("}"), 2, 1)]);
   }
 
   void test_lt() {
     _assertToken(TokenType.LT, "<");
   }
 
   void test_lt_eq() {
     _assertToken(TokenType.LT_EQ, "<=");
   }
 
@@ skipping 47 matching lines @@
 
   void test_period_period() {
     _assertToken(TokenType.PERIOD_PERIOD, "..");
   }
 
   void test_period_period_period() {
     _assertToken(TokenType.PERIOD_PERIOD_PERIOD, "...");
   }
 
   void test_periodAfterNumberNotIncluded_identifier() {
-    _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)]);
+    _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()", [
-        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)]);
+    _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, "+");
   }
 
   void test_plus_eq() {
     _assertToken(TokenType.PLUS_EQ, "+=");
   }
 
@@ skipping 17 matching lines @@
     _assertToken(TokenType.SCRIPT_TAG, "#! /bin/dart");
   }
 
   void test_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 scanner =
+        new Scanner(null, new SubSequenceReader("a", offsetDelta), listener);
     scanner.setSourceStart(3, 9);
     scanner.tokenize();
     List<int> lineStarts = scanner.lineStarts;
     expect(lineStarts, isNotNull);
     expect(lineStarts.length, 3);
     expect(lineStarts[2], 33);
   }
 
   void test_slash() {
     _assertToken(TokenType.SLASH, "/");
@@ skipping 27 matching lines @@
 
   void test_string_multi_embeddedQuotes() {
     _assertToken(TokenType.STRING, "\"\"\"line1\n\"\"\nline2\"\"\"");
   }
 
   void test_string_multi_embeddedQuotes_escapedChar() {
     _assertToken(TokenType.STRING, "\"\"\"a\"\"\\tb\"\"\"");
   }
 
   void test_string_multi_interpolation_block() {
-    _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)]);
+    _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!\"", [
-        new StringToken(TokenType.STRING, "\"Hello ", 0),
-        new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 7),
-        new StringToken(TokenType.IDENTIFIER, "name", 8),
-        new StringToken(TokenType.STRING, "!\"", 12)]);
+    _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'''");
   }
 
   void test_string_multi_slashEnter() {
     _assertToken(TokenType.STRING, "'''\\\n'''");
   }
 
   void test_string_multi_unterminated() {
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 8, "'''string", [new StringToken(TokenType.STRING, "'''string", 0)]);
+    _assertErrorAndTokens(
+        ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+        8,
+        "'''string",
+        [new StringToken(TokenType.STRING, "'''string", 0)]);
   }
 
   void test_string_multi_unterminated_interpolation_block() {
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 8, "'''\${name", [
-        new StringToken(TokenType.STRING, "'''", 0),
-        new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 3),
-        new StringToken(TokenType.IDENTIFIER, "name", 5),
-        new StringToken(TokenType.STRING, "", 9)]);
+    _assertErrorAndTokens(
+        ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+        8,
+        "'''\${name",
+        [
+            new StringToken(TokenType.STRING, "'''", 0),
+            new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 3),
+            new StringToken(TokenType.IDENTIFIER, "name", 5),
+            new StringToken(TokenType.STRING, "", 9)]);
   }
 
   void test_string_multi_unterminated_interpolation_identifier() {
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 7, "'''\$name", [
-        new StringToken(TokenType.STRING, "'''", 0),
-        new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 3),
-        new StringToken(TokenType.IDENTIFIER, "name", 4),
-        new StringToken(TokenType.STRING, "", 8)]);
+    _assertErrorAndTokens(
+        ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+        7,
+        "'''\$name",
+        [
+            new StringToken(TokenType.STRING, "'''", 0),
+            new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 3),
+            new StringToken(TokenType.IDENTIFIER, "name", 4),
+            new StringToken(TokenType.STRING, "", 8)]);
   }
 
   void test_string_raw_multi_double() {
     _assertToken(TokenType.STRING, "r\"\"\"line1\nline2\"\"\"");
   }
 
   void test_string_raw_multi_single() {
     _assertToken(TokenType.STRING, "r'''string'''");
   }
 
   void test_string_raw_multi_unterminated() {
     String source = "r'''string";
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 9, source, [new StringToken(TokenType.STRING, source, 0)]);
+    _assertErrorAndTokens(
+        ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+        9,
+        source,
+        [new StringToken(TokenType.STRING, source, 0)]);
   }
 
   void test_string_raw_simple_double() {
     _assertToken(TokenType.STRING, "r\"string\"");
   }
 
   void test_string_raw_simple_single() {
     _assertToken(TokenType.STRING, "r'string'");
   }
 
   void test_string_raw_simple_unterminated_eof() {
     String source = "r'string";
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 7, source, [new StringToken(TokenType.STRING, source, 0)]);
+    _assertErrorAndTokens(
+        ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+        7,
+        source,
+        [new StringToken(TokenType.STRING, source, 0)]);
   }
 
   void test_string_raw_simple_unterminated_eol() {
     String source = "r'string";
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 8, "$source\n", [new StringToken(TokenType.STRING, source, 0)]);
+    _assertErrorAndTokens(
+        ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+        8,
+        "$source\n",
+        [new StringToken(TokenType.STRING, source, 0)]);
   }
 
   void test_string_simple_double() {
     _assertToken(TokenType.STRING, "\"string\"");
   }
 
   void test_string_simple_escapedDollar() {
     _assertToken(TokenType.STRING, "'a\\\$b'");
   }
 
   void test_string_simple_interpolation_adjacentIdentifiers() {
-    _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)]);
+    _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}!'", [
-        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)]);
+    _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'", [
-        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)]);
+    _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'", [
-        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)]);
+    _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!'", [
-        new StringToken(TokenType.STRING, "'Hello ", 0),
-        new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 7),
-        new StringToken(TokenType.IDENTIFIER, "name", 8),
-        new StringToken(TokenType.STRING, "!'", 12)]);
+    _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\$'", [
-        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)]);
+    _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'", [
-        new StringToken(TokenType.STRING, "'", 0),
-        new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 1),
-        new StringToken(TokenType.STRING, "1'", 2)]);
+    _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'");
   }
 
   void test_string_simple_unterminated_eof() {
     String source = "'string";
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 6, source, [new StringToken(TokenType.STRING, source, 0)]);
+    _assertErrorAndTokens(
+        ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+        6,
+        source,
+        [new StringToken(TokenType.STRING, source, 0)]);
   }
 
   void test_string_simple_unterminated_eol() {
     String source = "'string";
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 7, "$source\r", [new StringToken(TokenType.STRING, source, 0)]);
+    _assertErrorAndTokens(
+        ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+        7,
+        "$source\r",
+        [new StringToken(TokenType.STRING, source, 0)]);
   }
 
   void test_string_simple_unterminated_interpolation_block() {
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 6, "'\${name", [
-        new StringToken(TokenType.STRING, "'", 0),
-        new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 1),
-        new StringToken(TokenType.IDENTIFIER, "name", 3),
-        new StringToken(TokenType.STRING, "", 7)]);
+    _assertErrorAndTokens(
+        ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+        6,
+        "'\${name",
+        [
+            new StringToken(TokenType.STRING, "'", 0),
+            new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 1),
+            new StringToken(TokenType.IDENTIFIER, "name", 3),
+            new StringToken(TokenType.STRING, "", 7)]);
   }
 
   void test_string_simple_unterminated_interpolation_identifier() {
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 5, "'\$name", [
-        new StringToken(TokenType.STRING, "'", 0),
-        new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 1),
-        new StringToken(TokenType.IDENTIFIER, "name", 2),
-        new StringToken(TokenType.STRING, "", 6)]);
+    _assertErrorAndTokens(
+        ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+        5,
+        "'\$name",
+        [
+            new StringToken(TokenType.STRING, "'", 0),
+            new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 1),
+            new StringToken(TokenType.IDENTIFIER, "name", 2),
+            new StringToken(TokenType.STRING, "", 6)]);
   }
 
   void test_tilde() {
     _assertToken(TokenType.TILDE, "~");
   }
 
   void test_tilde_slash() {
     _assertToken(TokenType.TILDE_SLASH, "~/");
   }
 
@@ skipping 33 matching lines @@
     expect(comment.lexeme, source);
   }
 
   /**
    * Assert that scanning the given source produces an error with the given code.
    *
    * @param expectedError the error that should be produced
    * @param expectedOffset the string offset that should be associated with the error
    * @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);
-    listener.assertErrors([new AnalysisError.con2(null, expectedOffset, 1, expectedError, [source.codeUnitAt(expectedOffset)])]);
+    listener.assertErrors(
+        [
+            new AnalysisError.con2(
+                null,
+                expectedOffset,
+                1,
+                expectedError,
+                [source.codeUnitAt(expectedOffset)])]);
   }
 
   /**
    * Assert that scanning the given source produces an error with the given code, and also produces
    * the given tokens.
    *
    * @param expectedError the error that should be produced
    * @param expectedOffset the string offset that should be associated with the error
    * @param source the source to be scanned to produce the error
    * @param expectedTokens the tokens that are expected to be in the source
    */
-  void _assertErrorAndTokens(ScannerErrorCode expectedError, int expectedOffset, String source, List<Token> expectedTokens) {
+  void _assertErrorAndTokens(ScannerErrorCode expectedError, int expectedOffset,
+      String source, List<Token> expectedTokens) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Token token = _scanWithListener(source, listener);
-    listener.assertErrors([new AnalysisError.con2(null, expectedOffset, 1, expectedError, [source.codeUnitAt(expectedOffset)])]);
+    listener.assertErrors(
+        [
+            new AnalysisError.con2(
+                null,
+                expectedOffset,
+                1,
+                expectedError,
+                [source.codeUnitAt(expectedOffset)])]);
     _checkTokens(token, expectedTokens);
   }
 
   /**
    * 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) {
@@ skipping 11 matching lines @@
     expect(token.type, TokenType.KEYWORD);
     expect(token.offset, 1);
     expect(token.length, source.length);
     expect(token.lexeme, source);
     value = token.value();
     expect(value is Keyword, isTrue);
     expect((value as Keyword).syntax, source);
     expect(token.next.type, TokenType.EOF);
   }
 
-  void _assertLineInfo(String source, List<ScannerTest_ExpectedLocation> expectedLocations) {
+  void _assertLineInfo(String source,
+      List<ScannerTest_ExpectedLocation> expectedLocations) {
     GatheringErrorListener listener = new GatheringErrorListener();
     _scanWithListener(source, listener);
     listener.assertNoErrors();
     LineInfo info = listener.getLineInfo(new TestSource());
     expect(info, isNotNull);
     for (ScannerTest_ExpectedLocation expectedLocation in expectedLocations) {
       LineInfo_Location location = info.getLocation(expectedLocation._offset);
       expect(location.lineNumber, expectedLocation._lineNumber);
       expect(location.columnNumber, expectedLocation._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);
     expect(originalToken, isNotNull);
     expect(originalToken.type, expectedType);
     expect(originalToken.offset, 0);
     expect(originalToken.length, source.length);
     expect(originalToken.lexeme, source);
     if (expectedType == TokenType.SCRIPT_TAG) {
-      // Adding space before the script tag is not allowed, and adding text at the end changes nothing.
+      // Adding space before the script tag is not allowed, and adding text at
+      // the end changes nothing.
       return originalToken;
     } else if (expectedType == TokenType.SINGLE_LINE_COMMENT) {
       // Adding space to an end-of-line comment changes the comment.
       Token tokenWithSpaces = _scan(" $source");
       expect(tokenWithSpaces, isNotNull);
       expect(tokenWithSpaces.type, expectedType);
       expect(tokenWithSpaces.offset, 1);
       expect(tokenWithSpaces.length, source.length);
       expect(tokenWithSpaces.lexeme, source);
       return originalToken;
-    } else if (expectedType == TokenType.INT || expectedType == TokenType.DOUBLE) {
+    } else if (expectedType == TokenType.INT ||
+        expectedType == TokenType.DOUBLE) {
       Token tokenWithLowerD = _scan("${source}d");
       expect(tokenWithLowerD, isNotNull);
       expect(tokenWithLowerD.type, expectedType);
       expect(tokenWithLowerD.offset, 0);
       expect(tokenWithLowerD.length, source.length);
       expect(tokenWithLowerD.lexeme, source);
       Token tokenWithUpperD = _scan("${source}D");
       expect(tokenWithUpperD, isNotNull);
       expect(tokenWithUpperD.type, expectedType);
       expect(tokenWithUpperD.offset, 0);
@@ skipping 21 matching lines @@
     Token token = _scan(source);
     _checkTokens(token, expectedTokens);
   }
 
   void _checkTokens(Token firstToken, List<Token> expectedTokens) {
     expect(firstToken, isNotNull);
     Token token = firstToken;
     for (int i = 0; i < expectedTokens.length; i++) {
       Token expectedToken = expectedTokens[i];
       expect(token.type, expectedToken.type, reason: "Wrong type for token $i");
-      expect(token.offset, expectedToken.offset, reason: "Wrong offset for token $i");
-      expect(token.length, expectedToken.length, reason: "Wrong length for token $i");
-      expect(token.lexeme, expectedToken.lexeme, reason: "Wrong lexeme for token $i");
+      expect(
+          token.offset,
+          expectedToken.offset,
+          reason: "Wrong offset for token $i");
+      expect(
+          token.length,
+          expectedToken.length,
+          reason: "Wrong length for token $i");
+      expect(
+          token.lexeme,
+          expectedToken.lexeme,
+          reason: "Wrong lexeme for token $i");
       token = token.next;
       expect(token, isNotNull);
     }
     expect(token.type, TokenType.EOF);
   }
 
   Token _scan(String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Token token = _scanWithListener(source, listener);
     listener.assertNoErrors();
     return token;
   }
 
   Token _scanWithListener(String source, GatheringErrorListener listener) {
-    Scanner scanner = new Scanner(null, new CharSequenceReader(source), listener);
+    Scanner scanner =
+        new Scanner(null, new CharSequenceReader(source), listener);
     Token result = scanner.tokenize();
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     return result;
   }
 }
 
 /**
  * Instances of the class `ExpectedLocation` encode information about the expected location
  * of a given offset in source code.
  */
 class ScannerTest_ExpectedLocation {
   final int _offset;
 
   final int _lineNumber;
 
   final int _columnNumber;
 
-  ScannerTest_ExpectedLocation(this._offset, this._lineNumber, this._columnNumber);
+  ScannerTest_ExpectedLocation(this._offset, this._lineNumber,
+      this._columnNumber);
 }
 
 /**
  * Instances of the class `TokenStreamValidator` are used to validate the correct construction
  * of a stream of tokens.
  */
 class TokenStreamValidator {
   /**
    * Validate that the stream of tokens that starts with the given token is correct.
    *
@@ skipping 10 matching lines @@
   void _validateStream(StringBuffer buffer, Token token) {
     if (token == null) {
       return;
     }
     Token previousToken = null;
     int previousEnd = -1;
     Token currentToken = token;
     while (currentToken != null && currentToken.type != TokenType.EOF) {
       _validateStream(buffer, currentToken.precedingComments);
       TokenType type = currentToken.type;
-      if (type == TokenType.OPEN_CURLY_BRACKET || type == TokenType.OPEN_PAREN || type == TokenType.OPEN_SQUARE_BRACKET || type == TokenType.STRING_INTERPOLATION_EXPRESSION) {
+      if (type == TokenType.OPEN_CURLY_BRACKET ||
+          type == TokenType.OPEN_PAREN ||
+          type == TokenType.OPEN_SQUARE_BRACKET ||
+          type == TokenType.STRING_INTERPOLATION_EXPRESSION) {
         if (currentToken is! BeginToken) {
           buffer.write("\r\nExpected BeginToken, found ");
           buffer.write(currentToken.runtimeType.toString());
           buffer.write(" ");
           _writeToken(buffer, currentToken);
         }
       }
       int currentStart = currentToken.offset;
       int currentLength = currentToken.length;
       int currentEnd = currentStart + currentLength - 1;
@@ skipping 81 matching lines @@
     expect(TokenType.LT_LT.isUserDefinableOperator, isTrue);
     expect(TokenType.MINUS.isUserDefinableOperator, isTrue);
     expect(TokenType.PERCENT.isUserDefinableOperator, isTrue);
     expect(TokenType.PLUS.isUserDefinableOperator, isTrue);
     expect(TokenType.SLASH.isUserDefinableOperator, isTrue);
     expect(TokenType.STAR.isUserDefinableOperator, isTrue);
     expect(TokenType.TILDE.isUserDefinableOperator, isTrue);
     expect(TokenType.TILDE_SLASH.isUserDefinableOperator, isTrue);
   }
 }
-
-main() {
-  groupSep = ' | ';
-  runReflectiveTests(CharSequenceReaderTest);
-  runReflectiveTests(IncrementalScannerTest);
-  runReflectiveTests(KeywordStateTest);
-  runReflectiveTests(ScannerTest);
-  runReflectiveTests(TokenTypeTest);
-}