Reformat

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.
 
 library engine.scanner_test;
 
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:unittest/unittest.dart';
@@ skipping 154 matching lines @@
         expect(state, isNotNull);
       }
     }
   }
 }
 
 @reflectiveTest
 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,
+    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 */");
+        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)]);
+    _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 39 matching lines @@
 
   void test_percent_eq() {
     _assertToken(TokenType.PERCENT_EQ, "%=");
   }
 
   void test_period() {
     _assertToken(TokenType.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_period_period() {
     _assertToken(TokenType.PERIOD_PERIOD, "..");
   }
 
   void test_period_period_period() {
     _assertToken(TokenType.PERIOD_PERIOD_PERIOD, "...");
   }
 
@@ skipping 74 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 34 matching lines @@
   }
 
   /**
    * Assert that scanning the given [source] produces an error with the given
    * code.
    *
    * [expectedError] the error that should be produced
    * [expectedOffset] the string offset that should be associated with the error
    * [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.
    *
    * [expectedError] the error that should be produced
    * [expectedOffset] the string offset that should be associated with the error
    * [source] the source to be scanned to produce the error
    * [expectedTokens] the tokens that are expected to be in the source
    */
   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.
    */
   void _assertKeywordToken(String source) {
     Token token = _scan(source);
     expect(token, isNotNull);
     expect(token.type, TokenType.KEYWORD);
     expect(token.offset, 0);
     expect(token.length, source.length);
     expect(token.lexeme, source);
     Object value = token.value();
     expect(value is Keyword, isTrue);
     expect((value as Keyword).syntax, source);
     token = _scan(" $source ");
     expect(token, isNotNull);
     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);
     }
@@ skipping 56 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,
+      expect(token.offset, expectedToken.offset,
           reason: "Wrong offset for token $i");
-      expect(
-          token.length,
-          expectedToken.length,
+      expect(token.length, expectedToken.length,
           reason: "Wrong length for token $i");
-      expect(
-          token.lexeme,
-          expectedToken.lexeme,
+      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);
@@ skipping 14 matching lines @@
  * An `ExpectedLocation` encodes 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);
 }
 
 /**
  * A `TokenStreamValidator` is 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 115 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);
   }
 }