Code clean-up

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/error.dart';
@@ skipping 55 matching lines @@
     expect(reader.peek(), -1);
   }
 
   void test_setOffset() {
     CharSequenceReader reader = new CharSequenceReader("xyz");
     reader.offset = 2;
     expect(reader.offset, 2);
   }
 }
 
+class CharacterRangeReaderTest extends EngineTestCase {
+  void test_advance() {
+    CharSequenceReader baseReader = new CharSequenceReader("xyzzy");
+    CharacterRangeReader reader = new CharacterRangeReader(baseReader, 1, 4);
+    expect(reader.advance(), 0x79);
+    expect(reader.advance(), 0x80);
+    expect(reader.advance(), 0x80);
+    expect(reader.advance(), -1);
+    expect(reader.advance(), -1);
+  }
+
+  void test_creation() {
+    CharSequenceReader baseReader = new CharSequenceReader("xyzzy");
+    CharacterRangeReader reader = new CharacterRangeReader(baseReader, 1, 4);
+    expect(reader, isNotNull);
+  }
+
+  void test_getOffset() {
+    CharSequenceReader baseReader = new CharSequenceReader("xyzzy");
+    CharacterRangeReader reader = new CharacterRangeReader(baseReader, 1, 2);
+    expect(reader.offset, 1);
+    reader.advance();
+    expect(reader.offset, 2);
+    reader.advance();
+    expect(reader.offset, 2);
+  }
+
+  void test_getString() {
+    CharSequenceReader baseReader = new CharSequenceReader("__xyzzy__");
+    CharacterRangeReader reader = new CharacterRangeReader(baseReader, 2, 7);
+    reader.offset = 5;
+    expect(reader.getString(3, 0), "yzz");
+    expect(reader.getString(4, 1), "zzy");
+  }
+
+  void test_peek() {
+    CharSequenceReader baseReader = new CharSequenceReader("xyzzy");
+    CharacterRangeReader reader = new CharacterRangeReader(baseReader, 1, 3);
+    expect(reader.peek(), 0x79);
+    expect(reader.peek(), 0x79);
+    reader.advance();
+    expect(reader.peek(), 0x80);
+    expect(reader.peek(), 0x80);
+    reader.advance();
+    expect(reader.peek(), -1);
+    expect(reader.peek(), -1);
+  }
+
+  void test_setOffset() {
+    CharSequenceReader baseReader = new CharSequenceReader("xyzzy");
+    CharacterRangeReader reader = new CharacterRangeReader(baseReader, 1, 4);
+    reader.offset = 2;
+    expect(reader.offset, 2);
+  }
+}
+
 class IncrementalScannerTest extends EngineTestCase {
   /**
    * The first token from the token stream resulting from parsing the original
    * source, or `null` if [scan] has not been invoked.
    */
   Token _originalTokens;
 
   /**
    * The scanner used to perform incremental scanning, or `null` if [scan] has
    * not been invoked.
@@ skipping 11 matching lines @@
     // 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 fail_insert_comment_afterIdentifier() {
+    // "a + b"
+    // "a /* TODO */ + b"
+    _scan("a", "", " /* TODO */", " + b");
+    _assertTokens(0, 1, ["a", "+", "b"]);
+    _assertComments(1, ["/* TODO */"]);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isFalse);
+  }
+
+  void fail_insert_comment_beforeIdentifier() {
+    // "a + b"
+    // "a + /* TODO */ b"
+    _scan("a + ", "", "/* TODO */ ", "b");
+    _assertTokens(1, 2, ["a", "+", "b"]);
+    _assertComments(2, ["/* TODO */"]);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isFalse);
+  }
+
+  void fail_insert_inComment() {
+    // "a /* TO */ b"
+    // "a /* TODO */ b"
+    _scan("a /* TO", "", "DO", " */ b");
+    _assertTokens(0, 1, ["a", "b"]);
+    _assertComments(1, ["/* TODO */"]);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isFalse);
+  }
+
   void test_delete_identifier_beginning() {
     // "abs + b;"
-    // "s + b;")
+    // "s + b;"
     _scan("", "ab", "", "s + b;");
     _assertTokens(-1, 1, ["s", "+", "b", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_delete_identifier_end() {
     // "abs + b;"
-    // "a + b;")
+    // "a + b;"
     _scan("a", "bs", "", " + b;");
     _assertTokens(-1, 1, ["a", "+", "b", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_delete_identifier_middle() {
     // "abs + b;"
-    // "as + b;")
+    // "as + b;"
     _scan("a", "b", "", "s + b;");
     _assertTokens(-1, 1, ["as", "+", "b", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_delete_mergeTokens() {
     // "a + b + c;"
-    // "ac;")
+    // "ac;"
     _scan("a", " + b + ", "", "c;");
     _assertTokens(-1, 1, ["ac", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_delete_whitespace() {
     // "a + b + c;"
-    // "a+ b + c;")
+    // "a+ b + c;"
     _scan("a", " ", "", "+ b + c;");
     _assertTokens(1, 2, ["a", "+", "b", "+", "c", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isFalse);
   }
 
-  void test_insert_afterIdentifier_firstToken() {
-    // "a + b;"
-    // "abs + b;"
-    _scan("a", "", "bs", " + b;");
-    _assertTokens(-1, 1, ["abs", "+", "b", ";"]);
-    _assertReplaced(1, "+");
+  void test_insert_convertOneFunctionToTwo_noOverlap() {
+    // "f() {}"
+    // "f() => 0; g() {}"
+    _scan("f()", "", " => 0; g()", " {}");
+    _assertTokens(
+        2,
+        9,
+        ["f", "(", ")", "=>", "0", ";", "g", "(", ")", "{", "}"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
-  void test_insert_afterIdentifier_lastToken() {
-    // "a + b"
-    // "a + bc")
-    _scan("a + b", "", "c", "");
-    _assertTokens(1, 3, ["a", "+", "bc"]);
+  void test_insert_convertOneFunctionToTwo_overlap() {
+    // "f() {}"
+    // "f() {} g() {}"
+    _scan("f() {", "", "} g() {", "}");
+    _assertTokens(4, 10, ["f", "(", ")", "{", "}", "g", "(", ")", "{", "}"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
-  void test_insert_afterIdentifier_middleToken() {
-    // "a + b;"
-    // "a + by;"
-    _scan("a + b", "", "y", ";");
-    _assertTokens(1, 3, ["a", "+", "by", ";"]);
+  void test_insert_end() {
+    // "class A {}"
+    // "class A {} class B {}"
+    _scan("class A {}", "", " class B {}", "");
+    _assertTokens(3, 8, ["class", "A", "{", "}", "class", "B", "{", "}"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
-  void test_insert_beforeIdentifier() {
+  void test_insert_identifierAndPeriod() {
     // "a + b;"
-    // "a + xb;")
-    _scan("a + ", "", "x", "b;");
-    _assertTokens(1, 3, ["a", "+", "xb", ";"]);
-    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
+    // "a + x.b;"
+    _scan("a + ", "", "x.", "b;");
+    _assertTokens(1, 4, ["a", "+", "x", ".", "b", ";"]);
   }
 
-  void test_insert_beforeIdentifier_firstToken() {
+  void test_insert_inIdentifier_left_firstToken() {
     // "a + b;"
     // "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", "(", ")", "{", "}"]);
+  void test_insert_inIdentifier_left_lastToken() {
+    // "a + b"
+    // "a + xb"
+    _scan("a + ", "", "x", "b");
+    _assertTokens(1, 3, ["a", "+", "xb"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
-  void test_insert_convertOneFunctionToTwo_overlap() {
-    // "f() {}"
-    // "f() {} g() {}"
-    _scan("f() {", "", "} g() {", "}");
-    _assertTokens(4, 10, ["f", "(", ")", "{", "}", "g", "(", ")", "{", "}"]);
+  void test_insert_inIdentifier_left_middleToken() {
+    // "a + b;"
+    // "a + xb;"
+    _scan("a + ", "", "x", "b;");
+    _assertTokens(1, 3, ["a", "+", "xb", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
-  void test_insert_end() {
-    // "class A {}"
-    // "class A {} class B {}"
-    _scan("class A {}", "", " class B {}", "");
-    _assertTokens(3, 8, ["class", "A", "{", "}", "class", "B", "{", "}"]);
+  void test_insert_inIdentifier_middle() {
+    // "cat;"
+    // "cart;"
+    _scan("ca", "", "r", "t;");
+    _assertTokens(-1, 1, ["cart", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
-  void test_insert_insideIdentifier() {
-    // "cob;"
-    // "cow.b;"
-    _scan("co", "", "w.", "b;");
-    _assertTokens(-1, 3, ["cow", ".", "b", ";"]);
+  void test_insert_inIdentifier_right_firstToken() {
+    // "a + b;"
+    // "abs + b;"
+    _scan("a", "", "bs", " + b;");
+    _assertTokens(-1, 1, ["abs", "+", "b", ";"]);
+    _assertReplaced(1, "+");
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
+  void test_insert_inIdentifier_right_lastToken() {
+    // "a + b"
+    // "a + bc"
+    _scan("a + b", "", "c", "");
+    _assertTokens(1, 3, ["a", "+", "bc"]);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
+  }
+
+  void test_insert_inIdentifier_right_middleToken() {
+    // "a + b;"
+    // "a + by;"
+    _scan("a + b", "", "y", ";");
+    _assertTokens(1, 3, ["a", "+", "by", ";"]);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
+  }
+
   void test_insert_newIdentifier_noSpaceBefore() {
     // "a; c;"
     // "a;b c;"
     _scan("a;", "", "b", " c;");
     _assertTokens(1, 3, ["a", ";", "b", "c", ";"]);
     _assertReplaced(1, ";");
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_newIdentifier_spaceBefore() {
     // "a; c;"
     // "a; b c;"
     _scan("a; ", "", "b ", "c;");
     _assertTokens(1, 3, ["a", ";", "b", "c", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
-  void test_insert_period() {
+  void test_insert_periodAndIdentifier() {
+    // "a + b;"
+    // "a + b.x;"
+    _scan("a + b", "", ".x", ";");
+    _assertTokens(2, 5, ["a", "+", "b", ".", "x", ";"]);
+  }
+
+  void test_insert_period_afterIdentifier() {
     // "a + b;"
     // "a + b.;"
     _scan("a + b", "", ".", ";");
     _assertTokens(2, 4, ["a", "+", "b", ".", ";"]);
   }
 
   void test_insert_period_betweenIdentifiers_left() {
     // "a b;"
     // "a. b;"
     _scan("a", "", ".", " b;");
@@ skipping 17 matching lines @@
   }
 
   void test_insert_period_insideExistingIdentifier() {
     // "ab;"
     // "a.b;"
     _scan("a", "", ".", "b;");
     _assertTokens(-1, 3, ["a", ".", "b", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
-  void test_insert_periodAndIdentifier() {
-    // "a + b;"
-    // "a + b.x;"
-    _scan("a + b", "", ".x", ";");
-    _assertTokens(2, 5, ["a", "+", "b", ".", "x", ";"]);
+  void test_insert_splitIdentifier() {
+    // "cob;"
+    // "cow.b;"
+    _scan("co", "", "w.", "b;");
+    _assertTokens(-1, 3, ["cow", ".", "b", ";"]);
+    expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_insert_whitespace_beginning_beforeToken() {
     // "a + b;"
     // " a + b;"
     _scan("", "", " ", "a + b;");
     _assertTokens(0, 1, ["a", "+", "b", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isFalse);
   }
 
@@ skipping 27 matching lines @@
     _scan(r'''
 //comment
 //comment2
 a''', "", " ", " + b;");
     _assertTokens(1, 2, ["a", "+", "b", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isFalse);
   }
 
   void test_replace_identifier_beginning() {
     // "bell + b;"
-    // "fell + b;")
+    // "fell + b;"
     _scan("", "b", "f", "ell + b;");
     _assertTokens(-1, 1, ["fell", "+", "b", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_replace_identifier_end() {
     // "bell + b;"
-    // "belt + b;")
+    // "belt + b;"
     _scan("bel", "l", "t", " + b;");
     _assertTokens(-1, 1, ["belt", "+", "b", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_replace_identifier_middle() {
     // "first + b;"
-    // "frost + b;")
+    // "frost + b;"
     _scan("f", "ir", "ro", "st + b;");
     _assertTokens(-1, 1, ["frost", "+", "b", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_replace_multiple_partialFirstAndLast() {
     // "aa + bb;"
-    // "ab * ab;")
+    // "ab * ab;"
     _scan("a", "a + b", "b * a", "b;");
     _assertTokens(-1, 3, ["ab", "*", "ab", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_replace_operator_oneForMany() {
     // "a + b;"
-    // "a * c - b;")
+    // "a * c - b;"
     _scan("a ", "+", "* c -", " b;");
     _assertTokens(0, 4, ["a", "*", "c", "-", "b", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
   void test_replace_operator_oneForOne() {
     // "a + b;"
-    // "a * b;")
+    // "a * b;"
     _scan("a ", "+", "*", " b;");
     _assertTokens(0, 2, ["a", "*", "b", ";"]);
     expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
   }
 
-  void test_tokenMap() {
-    // "main() {a + b;}"
-    // "main() { a + b;}"
-    _scan("main() {", "", " ", "a + b;}");
-    TokenMap tokenMap = _incrementalScanner.tokenMap;
-    Token oldToken = _originalTokens;
-    while (oldToken.type != TokenType.EOF) {
-      Token newToken = tokenMap.get(oldToken);
-      expect(newToken, isNot(same(oldToken)));
-      expect(newToken.type, same(oldToken.type));
-      expect(newToken.lexeme, oldToken.lexeme);
-      oldToken = oldToken.next;
+  /**
+   * Assert that the comments associated with the token at the given [index]
+   * have lexemes that match the given list of lexemes, both in number and in
+   * content.
+   */
+  void _assertComments(int index, List<String> lexemes) {
+    Token token = _incrementalTokens;
+    for (int i = 0; i < index; i++) {
+      token = token.next;
     }
-    expect(_incrementalScanner.hasNonWhitespaceChange, isFalse);
+    Token comment = token.precedingComments;
+    if (lexemes.isEmpty) {
+      expect(
+          comment,
+          isNull,
+          reason: "No comments expected but comments found");
+    }
+    int count = 0;
+    for (String lexeme in lexemes) {
+      if (comment == null) {
+        fail("Expected ${lexemes.length} comments but found $count");
+      }
+      expect(comment.lexeme, lexeme);
+      count++;
+      comment = comment.next;
+    }
+    if (comment != null) {
+      while (comment != null) {
+        count++;
+        comment = comment.next;
+      }
+      fail("Expected ${lexemes.length} comments but found $count");
+    }
   }
 
   /**
    * Assert that the token at the given [offset] was replaced with a new token
    * having the given [lexeme].
    */
   void _assertReplaced(int offset, String lexeme) {
     Token oldToken = _originalTokens;
     for (int i = 0; i < offset; i++) {
       oldToken = oldToken.next;
@@ skipping 115 matching lines @@
     expect(incrementalToken, isNotNull);
     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");
+          reason:
+              "Wrong offset for token (${incrementalToken.lexeme} != ${modifiedTokens.lexeme})");
       expect(
           incrementalToken.length,
           modifiedTokens.length,
-          reason: "Wrong length for token");
+          reason:
+              "Wrong length for token (${incrementalToken.lexeme} != ${modifiedTokens.lexeme})");
       expect(
           incrementalToken.lexeme,
           modifiedTokens.lexeme,
           reason: "Wrong lexeme for token");
       incrementalToken = incrementalToken.next;
       modifiedTokens = modifiedTokens.next;
     }
     expect(
         incrementalToken.type,
         same(TokenType.EOF),
@@ skipping 156 matching lines @@
   void test_comment_nested() {
     _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");
+  }
+
   void test_double_both_e() {
     _assertToken(TokenType.DOUBLE, "0.123e4");
   }
 
-  void test_double_both_E() {
-    _assertToken(TokenType.DOUBLE, "0.123E4");
+  void test_double_fraction() {
+    _assertToken(TokenType.DOUBLE, ".123");
   }
 
-  void test_double_fraction() {
-    _assertToken(TokenType.DOUBLE, ".123");
+  void test_double_fraction_E() {
+    _assertToken(TokenType.DOUBLE, ".123E4");
   }
 
   void test_double_fraction_e() {
     _assertToken(TokenType.DOUBLE, ".123e4");
   }
 
-  void test_double_fraction_E() {
-    _assertToken(TokenType.DOUBLE, ".123E4");
+  void test_double_missingDigitInExponent() {
+    _assertError(ScannerErrorCode.MISSING_DIGIT, 1, "1e");
   }
 
-  void test_double_missingDigitInExponent() {
-    _assertError(ScannerErrorCode.MISSING_DIGIT, 1, "1e");
+  void test_double_whole_E() {
+    _assertToken(TokenType.DOUBLE, "12E4");
   }
 
   void test_double_whole_e() {
     _assertToken(TokenType.DOUBLE, "12e4");
   }
 
-  void test_double_whole_E() {
-    _assertToken(TokenType.DOUBLE, "12E4");
-  }
-
   void test_eq() {
     _assertToken(TokenType.EQ, "=");
   }
 
   void test_eq_eq() {
     _assertToken(TokenType.EQ_EQ, "==");
   }
 
   void test_gt() {
     _assertToken(TokenType.GT, ">");
@@ skipping 312 matching lines @@
   }
 
   void test_minus_eq() {
     _assertToken(TokenType.MINUS_EQ, "-=");
   }
 
   void test_minus_minus() {
     _assertToken(TokenType.MINUS_MINUS, "--");
   }
 
+  void test_openSquareBracket() {
+    _assertToken(TokenType.OPEN_SQUARE_BRACKET, "[");
+  }
+
   void test_open_curly_bracket() {
     _assertToken(TokenType.OPEN_CURLY_BRACKET, "{");
   }
 
   void test_open_paren() {
     _assertToken(TokenType.OPEN_PAREN, "(");
   }
 
   void test_open_square_bracket() {
     _assertToken(TokenType.OPEN_SQUARE_BRACKET, "[");
   }
 
-  void test_openSquareBracket() {
-    _assertToken(TokenType.OPEN_SQUARE_BRACKET, "[");
-  }
-
   void test_percent() {
     _assertToken(TokenType.PERCENT, "%");
   }
 
   void test_percent_eq() {
     _assertToken(TokenType.PERCENT_EQ, "%=");
   }
 
   void test_period() {
     _assertToken(TokenType.PERIOD, ".");
   }
 
-  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)]);
   }
 
   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)]);
   }
 
+  void test_period_period() {
+    _assertToken(TokenType.PERIOD_PERIOD, "..");
+  }
+
+  void test_period_period_period() {
+    _assertToken(TokenType.PERIOD_PERIOD_PERIOD, "...");
+  }
+
   void test_plus() {
     _assertToken(TokenType.PLUS, "+");
   }
 
   void test_plus_eq() {
     _assertToken(TokenType.PLUS_EQ, "+=");
   }
 
   void test_plus_plus() {
     _assertToken(TokenType.PLUS_PLUS, "++");
   }
 
   void test_question() {
     _assertToken(TokenType.QUESTION, "?");
   }
 
   void test_scriptTag_withArgs() {
     _assertToken(TokenType.SCRIPT_TAG, "#!/bin/dart -debug");
   }
 
+  void test_scriptTag_withSpace() {
+    _assertToken(TokenType.SCRIPT_TAG, "#! /bin/dart");
+  }
+
   void test_scriptTag_withoutSpace() {
     _assertToken(TokenType.SCRIPT_TAG, "#!/bin/dart");
   }
 
-  void test_scriptTag_withSpace() {
-    _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.setSourceStart(3, 9);
@@ skipping 661 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);
   }
 }