Annotate analyzer tests with @ReflectiveTestCase().

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';
 
 import '../reflective_tests.dart';
 import 'test_support.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(CharSequenceReaderTest);
   runReflectiveTests(KeywordStateTest);
   runReflectiveTests(ScannerTest);
   runReflectiveTests(TokenTypeTest);
 }
 
+@ReflectiveTestCase()
 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 83 matching lines @@
   }
 
   void test_setOffset() {
     CharSequenceReader baseReader = new CharSequenceReader("xyzzy");
     CharacterRangeReader reader = new CharacterRangeReader(baseReader, 1, 4);
     reader.offset = 2;
     expect(reader.offset, 2);
   }
 }
 
+@ReflectiveTestCase()
 class KeywordStateTest {
   void test_KeywordState() {
     //
     // Generate the test data to be scanned.
     //
     List<Keyword> keywords = Keyword.values;
     int keywordCount = keywords.length;
     List<String> textToTest = new List<String>(keywordCount * 3);
     for (int i = 0; i < keywordCount; i++) {
       String syntax = keywords[i].syntax;
@@ skipping 23 matching lines @@
         // keyword + "x"
         expect(state, isNull);
       } else {
         // keyword.substring(0, keyword.length() - 1)
         expect(state, isNotNull);
       }
     }
   }
 }
 
+@ReflectiveTestCase()
 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),
@@ skipping 1152 matching lines @@
     buffer.write(", '");
     buffer.write(token.lexeme);
     buffer.write("', ");
     buffer.write(token.offset);
     buffer.write(", ");
     buffer.write(token.length);
     buffer.write("]");
   }
 }
 
+@ReflectiveTestCase()
 class TokenTypeTest extends EngineTestCase {
   void test_isOperator() {
     expect(TokenType.AMPERSAND.isOperator, isTrue);
     expect(TokenType.AMPERSAND_AMPERSAND.isOperator, isTrue);
     expect(TokenType.AMPERSAND_EQ.isOperator, isTrue);
     expect(TokenType.BANG.isOperator, isTrue);
     expect(TokenType.BANG_EQ.isOperator, isTrue);
     expect(TokenType.BAR.isOperator, isTrue);
     expect(TokenType.BAR_BAR.isOperator, isTrue);
     expect(TokenType.BAR_EQ.isOperator, isTrue);
@@ skipping 46 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);
   }
 }