New analyzer snapshot with MapIterator.

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 284 matching lines @@
     builder.append(token.lexeme);
     builder.append("', ");
     builder.append(token.offset);
     builder.append(", ");
     builder.append(token.length);
     builder.append("]");
   }
 }
 
 class ScannerTest extends JUnitTestCase {
+  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)]);
+  }
+
   void test_ampersand() {
     _assertToken(TokenType.AMPERSAND, "&");
   }
 
   void test_ampersand_ampersand() {
     _assertToken(TokenType.AMPERSAND_AMPERSAND, "&&");
   }
 
   void test_ampersand_eq() {
     _assertToken(TokenType.AMPERSAND_EQ, "&=");
@@ skipping 149 matching lines @@
 
   void test_hexidecimal_missingDigit() {
     _assertError(ScannerErrorCode.MISSING_HEX_DIGIT, 1, "0x");
   }
 
   void test_identifier() {
     _assertToken(TokenType.IDENTIFIER, "result");
   }
 
   void test_illegalChar_cyrillicLetter_middle() {
-    _assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "Shche\u0433lov");
+    _assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 5, "Shche\u0433lov");
   }
 
   void test_illegalChar_cyrillicLetter_start() {
     _assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "\u0429");
   }
 
   void test_illegalChar_nbsp() {
     _assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "\u00A0");
   }
 
@@ skipping 50 matching lines @@
   }
 
   void test_keyword_continue() {
     _assertKeywordToken("continue");
   }
 
   void test_keyword_default() {
     _assertKeywordToken("default");
   }
 
+  void test_keyword_deferred() {
+    _assertKeywordToken("deferred");
+  }
+
   void test_keyword_do() {
     _assertKeywordToken("do");
   }
 
   void test_keyword_dynamic() {
     _assertKeywordToken("dynamic");
   }
 
   void test_keyword_else() {
     _assertKeywordToken("else");
@@ skipping 530 matching lines @@
    * @param i
    * @param source the source to be scanned to produce the error
    */
   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)])]);
   }
 
   /**
+   * 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) {
+    GatheringErrorListener listener = new GatheringErrorListener();
+    Token token = _scanWithListener(source, listener);
+    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) {
     Token token = _scan(source);
     JUnitTestCase.assertNotNull(token);
     JUnitTestCase.assertEquals(TokenType.KEYWORD, token.type);
     JUnitTestCase.assertEquals(0, token.offset);
@@ skipping 78 matching lines @@
 
   /**
    * 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);
-    JUnitTestCase.assertNotNull(token);
+    _checkTokens(token, expectedTokens);
+  }
+
+  void _checkTokens(Token firstToken, List<Token> expectedTokens) {
+    JUnitTestCase.assertNotNull(firstToken);
+    Token token = firstToken;
     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);
@@ skipping 244 matching lines @@
         runJUnitTest(__test, __test.test_keyword_const);
       });
       _ut.test('test_keyword_continue', () {
         final __test = new ScannerTest();
         runJUnitTest(__test, __test.test_keyword_continue);
       });
       _ut.test('test_keyword_default', () {
         final __test = new ScannerTest();
         runJUnitTest(__test, __test.test_keyword_default);
       });
+      _ut.test('test_keyword_deferred', () {
+        final __test = new ScannerTest();
+        runJUnitTest(__test, __test.test_keyword_deferred);
+      });
       _ut.test('test_keyword_do', () {
         final __test = new ScannerTest();
         runJUnitTest(__test, __test.test_keyword_do);
       });
       _ut.test('test_keyword_dynamic', () {
         final __test = new ScannerTest();
         runJUnitTest(__test, __test.test_keyword_dynamic);
       });
       _ut.test('test_keyword_else', () {
         final __test = new ScannerTest();
@@ skipping 942 matching lines @@
   }
 }
 
 main() {
   CharSequenceReaderTest.dartSuite();
   IncrementalScannerTest.dartSuite();
   KeywordStateTest.dartSuite();
   ScannerTest.dartSuite();
   TokenTypeTest.dartSuite();
 }