Annotate analyzer tests with @ReflectiveTestCase().

pkg/analyzer/test/generated/utilities_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.utilities_test;
 
 import 'dart:collection';
@@ skipping 43 matching lines @@
   @override
   bool isEqualTokens(Token first, Token second) {
     if (expectTokensCopied && first != null && identical(first, second)) {
       fail('Failed to copy token: ${first.lexeme} (${first.offset})');
       return false;
     }
     return super.isEqualTokens(first, second);
   }
 }
 
+@ReflectiveTestCase()
 class AstClonerTest extends EngineTestCase {
   void test_visitAdjacentStrings() {
     _assertClone(
         AstFactory.adjacentStrings([AstFactory.string2("a"), AstFactory.string2("b")]));
   }
 
   void test_visitAnnotation_constant() {
     _assertClone(AstFactory.annotation(AstFactory.identifier3("A")));
   }
 
@@ skipping 1971 matching lines @@
     }
 
     clone = node.accept(new AstCloner(true));
     comparitor = new AstCloneComparator(true);
     if (!comparitor.isEqualNodes(node, clone)) {
       fail("Failed to clone ${node.runtimeType.toString()}");
     }
   }
 }
 
+@ReflectiveTestCase()
 class BooleanArrayTest {
   void test_get_negative() {
     try {
       BooleanArray.get(0, -1);
       fail("Expected ");
     } on RangeError catch (exception) {
       // Expected
     }
   }
 
@@ skipping 39 matching lines @@
   }
 
   void test_set_valuePreserving() {
     expect(BooleanArray.set(0, 0, false), 0);
     expect(BooleanArray.set(1, 0, true), 1);
     expect(BooleanArray.set(0, 30, false), 0);
     expect(BooleanArray.set(1 << 30, 30, true), 1 << 30);
   }
 }
 
+@ReflectiveTestCase()
 class DirectedGraphTest extends EngineTestCase {
   void test_addEdge() {
     DirectedGraph<DirectedGraphTest_Node> graph =
         new DirectedGraph<DirectedGraphTest_Node>();
     expect(graph.isEmpty, isTrue);
     graph.addEdge(new DirectedGraphTest_Node(), new DirectedGraphTest_Node());
     expect(graph.isEmpty, isFalse);
   }
 
   void test_addNode() {
@@ skipping 1117 matching lines @@
   @override
   TypeArgumentList get(TypedLiteral node) => node.typeArguments;
 }
 
 class Getter_NodeReplacerTest_testUriBasedDirective implements
     NodeReplacerTest_Getter {
   @override
   StringLiteral get(UriBasedDirective node) => node.uri;
 }
 
+@ReflectiveTestCase()
 class LineInfoTest {
   void test_creation() {
     expect(new LineInfo(<int>[0]), isNotNull);
   }
 
   void test_creation_empty() {
     try {
       new LineInfo(<int>[]);
       fail("Expected IllegalArgumentException");
     } on IllegalArgumentException catch (exception) {
@@ skipping 291 matching lines @@
 }
 
 class ListGetter_NodeReplacerTest_testSwitchMember_2 extends
     NodeReplacerTest_ListGetter<SwitchMember, Statement> {
   ListGetter_NodeReplacerTest_testSwitchMember_2(int arg0) : super(arg0);
 
   @override
   NodeList<Statement> getList(SwitchMember node) => node.statements;
 }
 
+@ReflectiveTestCase()
 class ListUtilitiesTest {
   void test_addAll_emptyToEmpty() {
     List<String> list = new List<String>();
     List<String> elements = <String>[];
     ListUtilities.addAll(list, elements);
     expect(list.length, 0);
   }
 
   void test_addAll_emptyToNonEmpty() {
     List<String> list = new List<String>();
@@ skipping 12 matching lines @@
 
   void test_addAll_nonEmptyToNonEmpty() {
     List<String> list = new List<String>();
     list.add("a");
     List<String> elements = ["b", "c"];
     ListUtilities.addAll(list, elements);
     expect(list.length, 3);
   }
 }
 
+@ReflectiveTestCase()
 class MultipleMapIteratorTest extends EngineTestCase {
   void test_multipleMaps_firstEmpty() {
     Map<String, String> map1 = new HashMap<String, String>();
     Map<String, String> map2 = new HashMap<String, String>();
     map2["k2"] = "v2";
     Map<String, String> map3 = new HashMap<String, String>();
     map3["k3"] = "v3";
     MultipleMapIterator<String, String> iterator =
         _iterator([map1, map2, map3]);
     expect(iterator.moveNext(), isTrue);
@@ skipping 97 matching lines @@
     iterator.value = newValue;
     expect(iterator.value, same(newValue));
     expect(iterator.moveNext(), isFalse);
   }
 
   MultipleMapIterator<String, String> _iterator(List<Map> maps) {
     return new MultipleMapIterator<String, String>(maps);
   }
 }
 
+@ReflectiveTestCase()
 class NodeReplacerTest extends EngineTestCase {
   /**
    * An empty list of tokens.
    */
   static const List<Token> EMPTY_TOKEN_LIST = const <Token>[];
 
   void test_adjacentStrings() {
     AdjacentStrings node =
         AstFactory.adjacentStrings([AstFactory.string2("a"), AstFactory.string2("b")]);
     _assertReplace(
@@ skipping 1029 matching lines @@
     NodeList<C> list = getList(parent);
     if (list.isEmpty) {
       return null;
     }
     return list[_index];
   }
 
   NodeList<C> getList(P parent);
 }
 
+@ReflectiveTestCase()
 class SingleMapIteratorTest extends EngineTestCase {
   void test_empty() {
     Map<String, String> map = new HashMap<String, String>();
     SingleMapIterator<String, String> iterator =
         new SingleMapIterator<String, String>(map);
     expect(iterator.moveNext(), isFalse);
     try {
       iterator.key;
       fail("Expected NoSuchElementException");
     } on NoSuchElementException catch (exception) {
@@ skipping 37 matching lines @@
     expect(iterator.moveNext(), isTrue);
     expect(iterator.key, same(key));
     expect(iterator.value, same(value));
     String newValue = "newValue";
     iterator.value = newValue;
     expect(iterator.value, same(newValue));
     expect(iterator.moveNext(), isFalse);
   }
 }
 
+@ReflectiveTestCase()
 class SourceRangeTest {
   void test_access() {
     SourceRange r = new SourceRange(10, 1);
     expect(r.offset, 10);
     expect(r.length, 1);
     expect(r.end, 10 + 1);
     // to check
     r.hashCode;
   }
 
@@ skipping 129 matching lines @@
     expect(r.startsIn(new SourceRange(5, 1)), isTrue);
     expect(r.startsIn(new SourceRange(0, 20)), isTrue);
   }
 
   void test_toString() {
     SourceRange r = new SourceRange(10, 1);
     expect(r.toString(), "[offset=10, length=1]");
   }
 }
 
+@ReflectiveTestCase()
 class StringUtilitiesTest {
   void test_EMPTY() {
     expect(StringUtilities.EMPTY, "");
     expect(StringUtilities.EMPTY.isEmpty, isTrue);
   }
 
   void test_EMPTY_ARRAY() {
     expect(StringUtilities.EMPTY_ARRAY.length, 0);
   }
 
@@ skipping 236 matching lines @@
     expect(StringUtilities.substringBeforeChar(null, 0x61), null);
     expect(StringUtilities.substringBeforeChar("", 0x61), "");
     expect(StringUtilities.substringBeforeChar("abc", 0x61), "");
     expect(StringUtilities.substringBeforeChar("abcba", 0x62), "a");
     expect(StringUtilities.substringBeforeChar("abc", 0x63), "ab");
     expect(StringUtilities.substringBeforeChar("abc", 0x64), "abc");
   }
 }
 
 
+@ReflectiveTestCase()
 class TokenMapTest {
   void test_creation() {
     expect(new TokenMap(), isNotNull);
   }
 
   void test_get_absent() {
     TokenMap tokenMap = new TokenMap();
     expect(tokenMap.get(TokenFactory.tokenFromType(TokenType.AT)), isNull);
   }
 
   void test_get_added() {
     TokenMap tokenMap = new TokenMap();
     Token key = TokenFactory.tokenFromType(TokenType.AT);
     Token value = TokenFactory.tokenFromType(TokenType.AT);
     tokenMap.put(key, value);
     expect(tokenMap.get(key), same(value));
   }
 }