New analyzer_experimental snapshot.

pkg/analyzer_experimental/test/generated/scanner_test.dart

 // 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 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
@@ skipping 321 matching lines @@
         runJUnitTest(__test, __test.test_hexidecimal);
       });
       _ut.test('test_hexidecimal_missingDigit', () {
         final __test = new CharBufferScannerTest();
         runJUnitTest(__test, __test.test_hexidecimal_missingDigit);
       });
       _ut.test('test_identifier', () {
         final __test = new CharBufferScannerTest();
         runJUnitTest(__test, __test.test_identifier);
       });
-      _ut.test('test_illegalChar', () {
+      _ut.test('test_illegalChar_cyrillicLetter_middle', () {
         final __test = new CharBufferScannerTest();
-        runJUnitTest(__test, __test.test_illegalChar);
+        runJUnitTest(__test, __test.test_illegalChar_cyrillicLetter_middle);
+      });
+      _ut.test('test_illegalChar_cyrillicLetter_start', () {
+        final __test = new CharBufferScannerTest();
+        runJUnitTest(__test, __test.test_illegalChar_cyrillicLetter_start);
+      });
+      _ut.test('test_illegalChar_notLetter', () {
+        final __test = new CharBufferScannerTest();
+        runJUnitTest(__test, __test.test_illegalChar_notLetter);
       });
       _ut.test('test_index', () {
         final __test = new CharBufferScannerTest();
         runJUnitTest(__test, __test.test_index);
       });
       _ut.test('test_index_eq', () {
         final __test = new CharBufferScannerTest();
         runJUnitTest(__test, __test.test_index_eq);
       });
       _ut.test('test_int', () {
@@ skipping 648 matching lines @@
         runJUnitTest(__test, __test.test_hexidecimal);
       });
       _ut.test('test_hexidecimal_missingDigit', () {
         final __test = new StringScannerTest();
         runJUnitTest(__test, __test.test_hexidecimal_missingDigit);
       });
       _ut.test('test_identifier', () {
         final __test = new StringScannerTest();
         runJUnitTest(__test, __test.test_identifier);
       });
-      _ut.test('test_illegalChar', () {
+      _ut.test('test_illegalChar_cyrillicLetter_middle', () {
         final __test = new StringScannerTest();
-        runJUnitTest(__test, __test.test_illegalChar);
+        runJUnitTest(__test, __test.test_illegalChar_cyrillicLetter_middle);
+      });
+      _ut.test('test_illegalChar_cyrillicLetter_start', () {
+        final __test = new StringScannerTest();
+        runJUnitTest(__test, __test.test_illegalChar_cyrillicLetter_start);
+      });
+      _ut.test('test_illegalChar_notLetter', () {
+        final __test = new StringScannerTest();
+        runJUnitTest(__test, __test.test_illegalChar_notLetter);
       });
       _ut.test('test_index', () {
         final __test = new StringScannerTest();
         runJUnitTest(__test, __test.test_index);
       });
       _ut.test('test_index_eq', () {
         final __test = new StringScannerTest();
         runJUnitTest(__test, __test.test_index_eq);
       });
       _ut.test('test_int', () {
@@ skipping 448 matching lines @@
   }
 }
 /**
  * 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.
+   *
    * @param token the first token in the stream of tokens to be validated
    */
   void validate(Token token) {
     JavaStringBuilder builder = new JavaStringBuilder();
     validateStream(builder, token);
     if (builder.length > 0) {
       JUnitTestCase.fail(builder.toString());
     }
   }
   void validateStream(JavaStringBuilder builder, Token token) {
@@ skipping 178 matching lines @@
   }
   void test_hexidecimal() {
     assertToken(TokenType.HEXADECIMAL, "0x1A2B3C");
   }
   void test_hexidecimal_missingDigit() {
     assertError(ScannerErrorCode.MISSING_HEX_DIGIT, 1, "0x");
   }
   void test_identifier() {
     assertToken(TokenType.IDENTIFIER, "result");
   }
-  void test_illegalChar() {
+  void test_illegalChar_cyrillicLetter_middle() {
+    assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "Shche\u0433lov");
+  }
+  void test_illegalChar_cyrillicLetter_start() {
+    assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "\u0429");
+  }
+  void test_illegalChar_notLetter() {
     assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "\u0312");
   }
   void test_index() {
     assertToken(TokenType.INDEX, "[]");
   }
   void test_index_eq() {
     assertToken(TokenType.INDEX_EQ, "[]=");
   }
   void test_int() {
     assertToken(TokenType.INT, "123");
@@ skipping 346 matching lines @@
     Token comment = token.precedingComments;
     JUnitTestCase.assertNotNull(comment);
     JUnitTestCase.assertEquals(commentType, comment.type);
     JUnitTestCase.assertEquals(0, comment.offset);
     JUnitTestCase.assertEquals(source.length, comment.length);
     JUnitTestCase.assertEquals(source, comment.lexeme);
   }
 
   /**
    * Assert that scanning the given source produces an error with the given code.
+   *
    * @param illegalCharacter
    * @param i
    * @param source the source to be scanned to produce the error
    */
   void assertError(ScannerErrorCode expectedError, int expectedOffset, String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
     scan(source, listener);
     listener.assertErrors([new AnalysisError.con2(null, expectedOffset, 1, expectedError, [(source.codeUnitAt(expectedOffset) as int)])]);
   }
 
   /**
    * 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 = scan2(source);
     JUnitTestCase.assertNotNull(token);
     JUnitTestCase.assertEquals(TokenType.KEYWORD, token.type);
     JUnitTestCase.assertEquals(0, token.offset);
     JUnitTestCase.assertEquals(source.length, token.length);
     JUnitTestCase.assertEquals(source, token.lexeme);
     Object value = token.value();
@@ skipping 18 matching lines @@
     JUnitTestCase.assertNotNull(info);
     for (AbstractScannerTest_ExpectedLocation expectedLocation in expectedLocations) {
       LineInfo_Location location = info.getLocation(expectedLocation._offset);
       JUnitTestCase.assertEquals(expectedLocation._lineNumber, location.lineNumber);
       JUnitTestCase.assertEquals(expectedLocation._columnNumber, location.columnNumber);
     }
   }
 
   /**
    * Assert that the token scanned from the given source has the expected type.
+   *
    * @param expectedType the expected type of the token
    * @param source the source to be scanned to produce the actual token
    */
   Token assertToken(TokenType expectedType, String source) {
     Token originalToken = scan2(source);
     JUnitTestCase.assertNotNull(originalToken);
     JUnitTestCase.assertEquals(expectedType, originalToken.type);
     JUnitTestCase.assertEquals(0, originalToken.offset);
     JUnitTestCase.assertEquals(source.length, originalToken.length);
     JUnitTestCase.assertEquals(source, originalToken.lexeme);
@@ skipping 14 matching lines @@
     JUnitTestCase.assertEquals(1, tokenWithSpaces.offset);
     JUnitTestCase.assertEquals(source.length, tokenWithSpaces.length);
     JUnitTestCase.assertEquals(source, tokenWithSpaces.lexeme);
     JUnitTestCase.assertEquals(TokenType.EOF, originalToken.next.type);
     return originalToken;
   }
 
   /**
    * Assert that when scanned the given source contains a sequence of tokens identical to the given
    * tokens.
+   *
    * @param source the source to be scanned
    * @param expectedTokens the tokens that are expected to be in the source
    */
   void assertTokens(String source, List<Token> expectedTokens) {
     Token token = scan2(source);
     JUnitTestCase.assertNotNull(token);
     for (int i = 0; i < expectedTokens.length; i++) {
       Token expectedToken = expectedTokens[i];
       JUnitTestCase.assertEqualsMsg("Wrong type for token ${i}", expectedToken.type, token.type);
       JUnitTestCase.assertEqualsMsg("Wrong offset for token ${i}", expectedToken.offset, token.offset);
@@ skipping 24 matching lines @@
     this._lineNumber = lineNumber;
     this._columnNumber = columnNumber;
   }
 }
 main() {
   CharBufferScannerTest.dartSuite();
   KeywordStateTest.dartSuite();
   StringScannerTest.dartSuite();
   TokenTypeTest.dartSuite();
 }