Rename AstFactory -> AstTestFactory.

pkg/analyzer/test/src/dart/element/element_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 analyzer.test.src.dart.element.element_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/handle.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisOptionsImpl;
 import 'package:analyzer/src/generated/source_io.dart';
-import 'package:analyzer/src/generated/testing/ast_factory.dart';
+import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/generated/testing/test_type_provider.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../../../generated/analysis_context_factory.dart'
     show AnalysisContextHelper;
 import '../../../generated/resolver_test_case.dart';
 import '../../../generated/test_support.dart';
 
@@ skipping 1294 matching lines @@
       expect(nodeB.element, same(elementB));
     }
   }
 }
 
 @reflectiveTest
 class FunctionTypeImplTest extends EngineTestCase {
   void test_creation() {
     expect(
         new FunctionTypeImpl(
-            new FunctionElementImpl.forNode(AstFactory.identifier3("f"))),
+            new FunctionElementImpl.forNode(AstTestFactory.identifier3("f"))),
         isNotNull);
   }
 
   void test_equality_recursive() {
     FunctionTypeAliasElementImpl s =
         ElementFactory.functionTypeAliasElement('s');
     FunctionTypeAliasElementImpl t =
         ElementFactory.functionTypeAliasElement('t');
     FunctionTypeAliasElementImpl u =
         ElementFactory.functionTypeAliasElement('u');
     FunctionTypeAliasElementImpl v =
         ElementFactory.functionTypeAliasElement('v');
     s.returnType = t.type;
     t.returnType = s.type;
     u.returnType = v.type;
     v.returnType = u.type;
     // We don't care whether the types compare equal or not.  We just need the
     // computation to terminate.
     expect(s.type == u.type, new isInstanceOf<bool>());
   }
 
   void test_getElement() {
     FunctionElementImpl typeElement =
-        new FunctionElementImpl.forNode(AstFactory.identifier3("f"));
+        new FunctionElementImpl.forNode(AstTestFactory.identifier3("f"));
     FunctionTypeImpl type = new FunctionTypeImpl(typeElement);
     expect(type.element, typeElement);
   }
 
   void test_getNamedParameterTypes_namedParameters() {
     TestTypeProvider typeProvider = new TestTypeProvider();
     FunctionElement element = ElementFactory
         .functionElementWithParameters('f', VoidTypeImpl.instance, [
       ElementFactory.requiredParameter2('a', typeProvider.intType),
       ElementFactory.requiredParameter('b'),
@@ skipping 91 matching lines @@
     FunctionTypeImpl type = element.type;
     List<DartType> types = type.optionalParameterTypes;
     expect(types, hasLength(2));
     expect(types[0], typeProvider.stringType);
     expect(types[1], DynamicTypeImpl.instance);
   }
 
   void test_getReturnType() {
     DartType expectedReturnType = VoidTypeImpl.instance;
     FunctionElementImpl functionElement =
-        new FunctionElementImpl.forNode(AstFactory.identifier3("f"));
+        new FunctionElementImpl.forNode(AstTestFactory.identifier3("f"));
     functionElement.returnType = expectedReturnType;
     FunctionTypeImpl type = new FunctionTypeImpl(functionElement);
     DartType returnType = type.returnType;
     expect(returnType, expectedReturnType);
   }
 
   void test_getTypeArguments() {
     FunctionTypeImpl type = new FunctionTypeImpl(
-        new FunctionElementImpl.forNode(AstFactory.identifier3("f")));
+        new FunctionElementImpl.forNode(AstTestFactory.identifier3("f")));
     List<DartType> types = type.typeArguments;
     expect(types, hasLength(0));
   }
 
   void test_hashCode_element() {
     FunctionTypeImpl type = new FunctionTypeImpl(
-        new FunctionElementImpl.forNode(AstFactory.identifier3("f")));
+        new FunctionElementImpl.forNode(AstTestFactory.identifier3("f")));
     type.hashCode;
   }
 
   void test_hashCode_noElement() {
     FunctionTypeImpl type = new FunctionTypeImpl(null);
     type.hashCode;
   }
 
   void test_hashCode_recursive() {
     FunctionTypeAliasElementImpl s =
@@ skipping 339 matching lines @@
         .functionElement2("s", ElementFactory.classElement2("B"))
         .type;
     expect(t.isSubtypeOf(s), isFalse);
   }
 
   void test_isSubtypeOf_typeParameters_matchesBounds() {
     TestTypeProvider provider = new TestTypeProvider();
     InterfaceType boolType = provider.boolType;
     InterfaceType stringType = provider.stringType;
     TypeParameterElementImpl parameterB =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("B"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("B"));
     parameterB.bound = boolType;
     TypeParameterTypeImpl typeB = new TypeParameterTypeImpl(parameterB);
     TypeParameterElementImpl parameterS =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("S"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("S"));
     parameterS.bound = stringType;
     TypeParameterTypeImpl typeS = new TypeParameterTypeImpl(parameterS);
     FunctionElementImpl functionAliasElement =
-        new FunctionElementImpl.forNode(AstFactory.identifier3("func"));
+        new FunctionElementImpl.forNode(AstTestFactory.identifier3("func"));
     functionAliasElement.parameters = <ParameterElement>[
       ElementFactory.requiredParameter2("a", typeB),
       ElementFactory.positionalParameter2("b", typeS)
     ];
     functionAliasElement.returnType = stringType;
     FunctionTypeImpl functionAliasType =
         new FunctionTypeImpl(functionAliasElement);
     functionAliasElement.type = functionAliasType;
     FunctionElementImpl functionElement =
-        new FunctionElementImpl.forNode(AstFactory.identifier3("f"));
+        new FunctionElementImpl.forNode(AstTestFactory.identifier3("f"));
     functionElement.parameters = <ParameterElement>[
       ElementFactory.requiredParameter2("c", boolType),
       ElementFactory.positionalParameter2("d", stringType)
     ];
     functionElement.returnType = provider.dynamicType;
     FunctionTypeImpl functionType = new FunctionTypeImpl(functionElement);
     functionElement.type = functionType;
     expect(functionType.isAssignableTo(functionAliasType), isTrue);
   }
 
@@ skipping 161 matching lines @@
     f.returnType = g.type;
     FunctionTypeImpl paramType = f.type.returnType;
     expect(paramType.prunedTypedefs, hasLength(1));
     expect(paramType.prunedTypedefs[0], same(f));
   }
 
   void test_substitute2_equal() {
     ClassElementImpl definingClass = ElementFactory.classElement2("C", ["E"]);
     TypeParameterType parameterType = definingClass.typeParameters[0].type;
     MethodElementImpl functionElement =
-        new MethodElementImpl.forNode(AstFactory.identifier3("m"));
+        new MethodElementImpl.forNode(AstTestFactory.identifier3("m"));
     String namedParameterName = "c";
     functionElement.parameters = <ParameterElement>[
       ElementFactory.requiredParameter2("a", parameterType),
       ElementFactory.positionalParameter2("b", parameterType),
       ElementFactory.namedParameter2(namedParameterName, parameterType)
     ];
     functionElement.returnType = parameterType;
     definingClass.methods = <MethodElement>[functionElement];
     FunctionTypeImpl functionType = new FunctionTypeImpl(functionElement);
     InterfaceTypeImpl argumentType = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("D")));
+        new ClassElementImpl.forNode(AstTestFactory.identifier3("D")));
     FunctionType result = functionType
         .substitute2(<DartType>[argumentType], <DartType>[parameterType]);
     expect(result.returnType, argumentType);
     List<DartType> normalParameters = result.normalParameterTypes;
     expect(normalParameters, hasLength(1));
     expect(normalParameters[0], argumentType);
     List<DartType> optionalParameters = result.optionalParameterTypes;
     expect(optionalParameters, hasLength(1));
     expect(optionalParameters[0], argumentType);
     Map<String, DartType> namedParameters = result.namedParameterTypes;
     expect(namedParameters, hasLength(1));
     expect(namedParameters[namedParameterName], argumentType);
   }
 
   void test_substitute2_notEqual() {
     DartType returnType = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("R")));
+        new ClassElementImpl.forNode(AstTestFactory.identifier3("R")));
     DartType normalParameterType = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("A")));
+        new ClassElementImpl.forNode(AstTestFactory.identifier3("A")));
     DartType optionalParameterType = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("B")));
+        new ClassElementImpl.forNode(AstTestFactory.identifier3("B")));
     DartType namedParameterType = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("C")));
+        new ClassElementImpl.forNode(AstTestFactory.identifier3("C")));
     FunctionElementImpl functionElement =
-        new FunctionElementImpl.forNode(AstFactory.identifier3("f"));
+        new FunctionElementImpl.forNode(AstTestFactory.identifier3("f"));
     String namedParameterName = "c";
     functionElement.parameters = <ParameterElement>[
       ElementFactory.requiredParameter2("a", normalParameterType),
       ElementFactory.positionalParameter2("b", optionalParameterType),
       ElementFactory.namedParameter2(namedParameterName, namedParameterType)
     ];
     functionElement.returnType = returnType;
     FunctionTypeImpl functionType = new FunctionTypeImpl(functionElement);
     InterfaceTypeImpl argumentType = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("D")));
+        new ClassElementImpl.forNode(AstTestFactory.identifier3("D")));
     TypeParameterTypeImpl parameterType = new TypeParameterTypeImpl(
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("E")));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("E")));
     FunctionType result = functionType
         .substitute2(<DartType>[argumentType], <DartType>[parameterType]);
     expect(result.returnType, returnType);
     List<DartType> normalParameters = result.normalParameterTypes;
     expect(normalParameters, hasLength(1));
     expect(normalParameters[0], normalParameterType);
     List<DartType> optionalParameters = result.optionalParameterTypes;
     expect(optionalParameters, hasLength(1));
     expect(optionalParameters[0], optionalParameterType);
     Map<String, DartType> namedParameters = result.namedParameterTypes;
@@ skipping 141 matching lines @@
     expect(method.type.typeArguments,
         unorderedEquals(_toTypes(classElement.typeParameters)));
     expect(method.type.typeFormals, unorderedEquals(method.typeParameters));
     expect(method.type.typeParameters,
         unorderedEquals(classElement.typeParameters));
   }
 
   void test_withTypeArguments() {
     ClassElementImpl enclosingClass = ElementFactory.classElement2("C", ["E"]);
     MethodElementImpl methodElement =
-        new MethodElementImpl.forNode(AstFactory.identifier3("m"));
+        new MethodElementImpl.forNode(AstTestFactory.identifier3("m"));
     enclosingClass.methods = <MethodElement>[methodElement];
     FunctionTypeImpl type = new FunctionTypeImpl(methodElement);
     DartType expectedType = enclosingClass.typeParameters[0].type;
     List<DartType> arguments = type.typeArguments;
     expect(arguments, hasLength(1));
     expect(arguments[0], expectedType);
   }
 
   Iterable<DartType> _toTypes(List<TypeParameterElement> typeParameters) {
     return typeParameters.map((TypeParameterElement element) => element.type);
@@ skipping 908 matching lines @@
 
   void test_isMoreSpecificThan_typeParameterType_withBound() {
     //
     // class A {}
     // class B<E extends A> {}
     //
     ClassElement classA = ElementFactory.classElement2("A");
     InterfaceType typeA = classA.type;
     ClassElementImpl classB = ElementFactory.classElement2("B");
     TypeParameterElementImpl parameterEA =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("E"));
     TypeParameterType parameterAEType = new TypeParameterTypeImpl(parameterEA);
     parameterEA.bound = typeA;
     parameterEA.type = parameterAEType;
     classB.typeParameters = <TypeParameterElementImpl>[parameterEA];
     expect(parameterAEType.isMoreSpecificThan(typeA), isTrue);
   }
 
   void test_isSubtypeOf_directSubtype() {
     ClassElement classA = ElementFactory.classElement2("A");
     ClassElement classB = ElementFactory.classElement("B", classA.type);
@@ skipping 581 matching lines @@
     } catch (e) {
       // Expected result
     }
   }
 
   void test_substitute_notEqual() {
     // The [test_substitute_equals] above has a slightly higher level
     // implementation.
     ClassElementImpl classA = ElementFactory.classElement2("A");
     TypeParameterElementImpl parameterElement =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("E"));
     InterfaceTypeImpl type = new InterfaceTypeImpl(classA);
     TypeParameterTypeImpl parameter =
         new TypeParameterTypeImpl(parameterElement);
     type.typeArguments = <DartType>[parameter];
     InterfaceType argumentType = ElementFactory.classElement2("B").type;
     TypeParameterTypeImpl parameterType = new TypeParameterTypeImpl(
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("F")));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("F")));
     InterfaceType result =
         type.substitute2(<DartType>[argumentType], <DartType>[parameterType]);
     expect(result.element, classA);
     List<DartType> resultArguments = result.typeArguments;
     expect(resultArguments, hasLength(1));
     expect(resultArguments[0], parameter);
   }
 }
 
 @reflectiveTest
 class LibraryElementImplTest extends EngineTestCase {
   void test_creation() {
     expect(
         new LibraryElementImpl.forNode(
-            createAnalysisContext(), AstFactory.libraryIdentifier2(["l"])),
+            createAnalysisContext(), AstTestFactory.libraryIdentifier2(["l"])),
         isNotNull);
   }
 
   void test_getImportedLibraries() {
     AnalysisContext context = createAnalysisContext();
     LibraryElementImpl library1 = ElementFactory.library(context, "l1");
     LibraryElementImpl library2 = ElementFactory.library(context, "l2");
     LibraryElementImpl library3 = ElementFactory.library(context, "l3");
     LibraryElementImpl library4 = ElementFactory.library(context, "l4");
     PrefixElement prefixA =
-        new PrefixElementImpl.forNode(AstFactory.identifier3("a"));
+        new PrefixElementImpl.forNode(AstTestFactory.identifier3("a"));
     PrefixElement prefixB =
-        new PrefixElementImpl.forNode(AstFactory.identifier3("b"));
+        new PrefixElementImpl.forNode(AstTestFactory.identifier3("b"));
     List<ImportElementImpl> imports = [
       ElementFactory.importFor(library2, null),
       ElementFactory.importFor(library2, prefixB),
       ElementFactory.importFor(library3, null),
       ElementFactory.importFor(library3, prefixA),
       ElementFactory.importFor(library3, prefixB),
       ElementFactory.importFor(library4, prefixA)
     ];
     library1.imports = imports;
     List<LibraryElement> libraries = library1.importedLibraries;
     expect(libraries,
         unorderedEquals(<LibraryElement>[library2, library3, library4]));
   }
 
   void test_getPrefixes() {
     AnalysisContext context = createAnalysisContext();
     LibraryElementImpl library = ElementFactory.library(context, "l1");
     PrefixElement prefixA =
-        new PrefixElementImpl.forNode(AstFactory.identifier3("a"));
+        new PrefixElementImpl.forNode(AstTestFactory.identifier3("a"));
     PrefixElement prefixB =
-        new PrefixElementImpl.forNode(AstFactory.identifier3("b"));
+        new PrefixElementImpl.forNode(AstTestFactory.identifier3("b"));
     List<ImportElementImpl> imports = [
       ElementFactory.importFor(ElementFactory.library(context, "l2"), null),
       ElementFactory.importFor(ElementFactory.library(context, "l3"), null),
       ElementFactory.importFor(ElementFactory.library(context, "l4"), prefixA),
       ElementFactory.importFor(ElementFactory.library(context, "l5"), prefixA),
       ElementFactory.importFor(ElementFactory.library(context, "l6"), prefixB)
     ];
     library.imports = imports;
     List<PrefixElement> prefixes = library.prefixes;
     expect(prefixes, hasLength(2));
@@ skipping 32 matching lines @@
         ElementFactory.importFor(importedLibraryHandle, null);
     library.imports = <ImportElement>[import];
     library.libraryCycle; // Force computation of the cycle.
 
     library.invalidateLibraryCycles();
   }
 
   void test_setImports() {
     AnalysisContext context = createAnalysisContext();
     LibraryElementImpl library = new LibraryElementImpl.forNode(
-        context, AstFactory.libraryIdentifier2(["l1"]));
+        context, AstTestFactory.libraryIdentifier2(["l1"]));
     List<ImportElementImpl> expectedImports = [
       ElementFactory.importFor(ElementFactory.library(context, "l2"), null),
       ElementFactory.importFor(ElementFactory.library(context, "l3"), null)
     ];
     library.imports = expectedImports;
     List<ImportElement> actualImports = library.imports;
     expect(actualImports, hasLength(expectedImports.length));
     for (int i = 0; i < actualImports.length; i++) {
       expect(actualImports[i], same(expectedImports[i]));
     }
@@ skipping 335 matching lines @@
     expect(value, isNotNull);
     expect(value.toIntValue(), 42);
     expect(constant.constantValue, value);
   }
 }
 
 @reflectiveTest
 class TypeParameterTypeImplTest extends EngineTestCase {
   void test_creation() {
     expect(
-        new TypeParameterTypeImpl(
-            new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"))),
+        new TypeParameterTypeImpl(new TypeParameterElementImpl.forNode(
+            AstTestFactory.identifier3("E"))),
         isNotNull);
   }
 
   void test_getElement() {
     TypeParameterElementImpl element =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("E"));
     TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);
     expect(type.element, element);
   }
 
   void test_isMoreSpecificThan_typeArguments_dynamic() {
     TypeParameterElementImpl element =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("E"));
     TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);
     // E << dynamic
     expect(type.isMoreSpecificThan(DynamicTypeImpl.instance), isTrue);
   }
 
   void test_isMoreSpecificThan_typeArguments_object() {
     TypeParameterElementImpl element =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("E"));
     TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);
     // E << Object
     expect(type.isMoreSpecificThan(ElementFactory.object.type), isTrue);
   }
 
   void test_isMoreSpecificThan_typeArguments_recursive() {
     ClassElementImpl classS = ElementFactory.classElement2("A");
     TypeParameterElementImpl typeParameterU =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("U"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("U"));
     TypeParameterTypeImpl typeParameterTypeU =
         new TypeParameterTypeImpl(typeParameterU);
     TypeParameterElementImpl typeParameterT =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("T"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("T"));
     TypeParameterTypeImpl typeParameterTypeT =
         new TypeParameterTypeImpl(typeParameterT);
     typeParameterT.bound = typeParameterTypeU;
     typeParameterU.bound = typeParameterTypeU;
     // <T extends U> and <U extends T>
     // T << S
     expect(typeParameterTypeT.isMoreSpecificThan(classS.type), isFalse);
   }
 
   void test_isMoreSpecificThan_typeArguments_self() {
     TypeParameterElementImpl element =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("E"));
     TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);
     // E << E
     expect(type.isMoreSpecificThan(type), isTrue);
   }
 
   void test_isMoreSpecificThan_typeArguments_transitivity_interfaceTypes() {
     //  class A {}
     //  class B extends A {}
     //
     ClassElement classA = ElementFactory.classElement2("A");
     ClassElement classB = ElementFactory.classElement("B", classA.type);
     InterfaceType typeA = classA.type;
     InterfaceType typeB = classB.type;
     TypeParameterElementImpl typeParameterT =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("T"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("T"));
     typeParameterT.bound = typeB;
     TypeParameterTypeImpl typeParameterTypeT =
         new TypeParameterTypeImpl(typeParameterT);
     // <T extends B>
     // T << A
     expect(typeParameterTypeT.isMoreSpecificThan(typeA), isTrue);
   }
 
   void test_isMoreSpecificThan_typeArguments_transitivity_typeParameters() {
     ClassElementImpl classS = ElementFactory.classElement2("A");
     TypeParameterElementImpl typeParameterU =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("U"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("U"));
     typeParameterU.bound = classS.type;
     TypeParameterTypeImpl typeParameterTypeU =
         new TypeParameterTypeImpl(typeParameterU);
     TypeParameterElementImpl typeParameterT =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("T"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("T"));
     typeParameterT.bound = typeParameterTypeU;
     TypeParameterTypeImpl typeParameterTypeT =
         new TypeParameterTypeImpl(typeParameterT);
     // <T extends U> and <U extends S>
     // T << S
     expect(typeParameterTypeT.isMoreSpecificThan(classS.type), isTrue);
   }
 
   void test_isMoreSpecificThan_typeArguments_upperBound() {
     ClassElementImpl classS = ElementFactory.classElement2("A");
     TypeParameterElementImpl typeParameterT =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("T"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("T"));
     typeParameterT.bound = classS.type;
     TypeParameterTypeImpl typeParameterTypeT =
         new TypeParameterTypeImpl(typeParameterT);
     // <T extends S>
     // T << S
     expect(typeParameterTypeT.isMoreSpecificThan(classS.type), isTrue);
   }
 
   void test_resolveToBound_bound() {
     ClassElementImpl classS = ElementFactory.classElement2("A");
     TypeParameterElementImpl element =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("E"));
     element.bound = classS.type;
     TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);
     expect(type.resolveToBound(null), same(classS.type));
   }
 
   void test_resolveToBound_nestedBound() {
     ClassElementImpl classS = ElementFactory.classElement2("A");
     TypeParameterElementImpl elementE =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("E"));
     elementE.bound = classS.type;
     TypeParameterTypeImpl typeE = new TypeParameterTypeImpl(elementE);
     TypeParameterElementImpl elementF =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("F"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("F"));
     elementF.bound = typeE;
     TypeParameterTypeImpl typeF = new TypeParameterTypeImpl(elementE);
     expect(typeF.resolveToBound(null), same(classS.type));
   }
 
   void test_resolveToBound_unbound() {
     TypeParameterTypeImpl type = new TypeParameterTypeImpl(
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("E")));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("E")));
     // Returns whatever type is passed to resolveToBound().
     expect(type.resolveToBound(VoidTypeImpl.instance),
         same(VoidTypeImpl.instance));
   }
 
   void test_substitute_equal() {
     TypeParameterElementImpl element =
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("E"));
     TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);
     InterfaceTypeImpl argument = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("A")));
+        new ClassElementImpl.forNode(AstTestFactory.identifier3("A")));
     TypeParameterTypeImpl parameter = new TypeParameterTypeImpl(element);
     expect(type.substitute2(<DartType>[argument], <DartType>[parameter]),
         same(argument));
   }
 
   void test_substitute_notEqual() {
     TypeParameterTypeImpl type = new TypeParameterTypeImpl(
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("E")));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("E")));
     InterfaceTypeImpl argument = new InterfaceTypeImpl(
-        new ClassElementImpl.forNode(AstFactory.identifier3("A")));
+        new ClassElementImpl.forNode(AstTestFactory.identifier3("A")));
     TypeParameterTypeImpl parameter = new TypeParameterTypeImpl(
-        new TypeParameterElementImpl.forNode(AstFactory.identifier3("F")));
+        new TypeParameterElementImpl.forNode(AstTestFactory.identifier3("F")));
     expect(type.substitute2(<DartType>[argument], <DartType>[parameter]),
         same(type));
   }
 }
 
 @reflectiveTest
 class VoidTypeImplTest extends EngineTestCase {
   /**
    * Reference {code VoidTypeImpl.getInstance()}.
    */
@@ skipping 36 matching lines @@
 }
 
 class _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction
     extends InterfaceTypeImpl {
   _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction(ClassElement arg0)
       : super(arg0);
 
   @override
   bool get isDartCoreFunction => true;
 }