Replace EngineTestCase.assertSize() with hasLength().

pkg/analyzer/test/generated/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.
 
 // 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.element_test;
 
 import 'package:analyzer/src/generated/java_core.dart';
@@ skipping 77 matching lines @@
     expect(types.contains(typeB), isTrue);
     expect(types.contains(typeObject), isTrue);
     expect(types.contains(typeC), isFalse);
   }
 
   void test_getAllSupertypes_recursive() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     classA.supertype = classB.type;
     List<InterfaceType> supers = classB.allSupertypes;
-    EngineTestCase.assertLength(1, supers);
+    expect(supers, hasLength(1));
   }
 
   void test_getField() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String fieldName = "f";
     FieldElementImpl field = ElementFactory.fieldElement(fieldName, false, false, false, null);
     classA.fields = <FieldElement> [field];
     expect(classA.getField(fieldName), same(field));
     // no such field
     expect(classA.getField("noSuchField"), same(null));
@@ skipping 825 matching lines @@
   void test_equals_notEqual_sameLengths() {
     ElementLocationImpl first = new ElementLocationImpl.con2("a;b;c");
     ElementLocationImpl second = new ElementLocationImpl.con2("a;b;d");
     expect(first == second, isFalse);
   }
 
   void test_getComponents() {
     String encoding = "a;b;c";
     ElementLocationImpl location = new ElementLocationImpl.con2(encoding);
     List<String> components = location.components;
-    EngineTestCase.assertLength(3, components);
+    expect(components, hasLength(3));
     expect(components[0], "a");
     expect(components[1], "b");
     expect(components[2], "c");
   }
 
   void test_getEncoding() {
     String encoding = "a;b;c;;d";
     ElementLocationImpl location = new ElementLocationImpl.con2(encoding);
     expect(location.encoding, encoding);
   }
@@ skipping 13 matching lines @@
 
   void test_getElement() {
     FunctionElementImpl typeElement = new FunctionElementImpl.forNode(AstFactory.identifier3("f"));
     FunctionTypeImpl type = new FunctionTypeImpl.con1(typeElement);
     expect(type.element, typeElement);
   }
 
   void test_getNamedParameterTypes() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.forNode(AstFactory.identifier3("f")));
     Map<String, DartType> types = type.namedParameterTypes;
-    EngineTestCase.assertSizeOfMap(0, types);
+    expect(types, hasLength(0));
   }
 
   void test_getNormalParameterTypes() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.forNode(AstFactory.identifier3("f")));
     List<DartType> types = type.normalParameterTypes;
-    EngineTestCase.assertLength(0, types);
+    expect(types, hasLength(0));
   }
 
   void test_getReturnType() {
     DartType expectedReturnType = VoidTypeImpl.instance;
     FunctionElementImpl functionElement = new FunctionElementImpl.forNode(AstFactory.identifier3("f"));
     functionElement.returnType = expectedReturnType;
     FunctionTypeImpl type = new FunctionTypeImpl.con1(functionElement);
     DartType returnType = type.returnType;
     expect(returnType, expectedReturnType);
   }
 
   void test_getTypeArguments() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.forNode(AstFactory.identifier3("f")));
     List<DartType> types = type.typeArguments;
-    EngineTestCase.assertLength(0, types);
+    expect(types, hasLength(0));
   }
 
   void test_hashCode_element() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1(new FunctionElementImpl.forNode(AstFactory.identifier3("f")));
     type.hashCode;
   }
 
   void test_hashCode_noElement() {
     FunctionTypeImpl type = new FunctionTypeImpl.con1(null);
     type.hashCode;
@@ skipping 325 matching lines @@
   }
 
   void test_setTypeArguments() {
     ClassElementImpl enclosingClass = ElementFactory.classElement2("C", ["E"]);
     MethodElementImpl methodElement = new MethodElementImpl.forNode(AstFactory.identifier3("m"));
     enclosingClass.methods = <MethodElement> [methodElement];
     FunctionTypeImpl type = new FunctionTypeImpl.con1(methodElement);
     DartType expectedType = enclosingClass.typeParameters[0].type;
     type.typeArguments = <DartType> [expectedType];
     List<DartType> arguments = type.typeArguments;
-    EngineTestCase.assertLength(1, arguments);
+    expect(arguments, hasLength(1));
     expect(arguments[0], expectedType);
   }
 
   void test_substitute2_equal() {
     ClassElementImpl definingClass = ElementFactory.classElement2("C", ["E"]);
     TypeParameterType parameterType = definingClass.typeParameters[0].type;
     MethodElementImpl functionElement = new MethodElementImpl.forNode(AstFactory.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.con1(functionElement);
     functionType.typeArguments = <DartType> [parameterType];
     InterfaceTypeImpl argumentType = new InterfaceTypeImpl.con1(new ClassElementImpl.forNode(AstFactory.identifier3("D")));
     FunctionType result = functionType.substitute2(<DartType> [argumentType], <DartType> [parameterType]);
     expect(result.returnType, argumentType);
     List<DartType> normalParameters = result.normalParameterTypes;
-    EngineTestCase.assertLength(1, normalParameters);
+    expect(normalParameters, hasLength(1));
     expect(normalParameters[0], argumentType);
     List<DartType> optionalParameters = result.optionalParameterTypes;
-    EngineTestCase.assertLength(1, optionalParameters);
+    expect(optionalParameters, hasLength(1));
     expect(optionalParameters[0], argumentType);
     Map<String, DartType> namedParameters = result.namedParameterTypes;
-    EngineTestCase.assertSizeOfMap(1, namedParameters);
+    expect(namedParameters, hasLength(1));
     expect(namedParameters[namedParameterName], argumentType);
   }
 
   void test_substitute2_notEqual() {
     DartType returnType = new InterfaceTypeImpl.con1(new ClassElementImpl.forNode(AstFactory.identifier3("R")));
     DartType normalParameterType = new InterfaceTypeImpl.con1(new ClassElementImpl.forNode(AstFactory.identifier3("A")));
     DartType optionalParameterType = new InterfaceTypeImpl.con1(new ClassElementImpl.forNode(AstFactory.identifier3("B")));
     DartType namedParameterType = new InterfaceTypeImpl.con1(new ClassElementImpl.forNode(AstFactory.identifier3("C")));
     FunctionElementImpl functionElement = new FunctionElementImpl.forNode(AstFactory.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.con1(functionElement);
     InterfaceTypeImpl argumentType = new InterfaceTypeImpl.con1(new ClassElementImpl.forNode(AstFactory.identifier3("D")));
     TypeParameterTypeImpl parameterType = new TypeParameterTypeImpl(new TypeParameterElementImpl.forNode(AstFactory.identifier3("E")));
     FunctionType result = functionType.substitute2(<DartType> [argumentType], <DartType> [parameterType]);
     expect(result.returnType, returnType);
     List<DartType> normalParameters = result.normalParameterTypes;
-    EngineTestCase.assertLength(1, normalParameters);
+    expect(normalParameters, hasLength(1));
     expect(normalParameters[0], normalParameterType);
     List<DartType> optionalParameters = result.optionalParameterTypes;
-    EngineTestCase.assertLength(1, optionalParameters);
+    expect(optionalParameters, hasLength(1));
     expect(optionalParameters[0], optionalParameterType);
     Map<String, DartType> namedParameters = result.namedParameterTypes;
-    EngineTestCase.assertSizeOfMap(1, namedParameters);
+    expect(namedParameters, hasLength(1));
     expect(namedParameters[namedParameterName], namedParameterType);
   }
 }
 
 class HtmlElementImplTest extends EngineTestCase {
   void test_equals_differentSource() {
     AnalysisContextImpl context = createAnalysisContext();
     HtmlElementImpl elementA = ElementFactory.htmlUnit(context, "indexA.html");
     HtmlElementImpl elementB = ElementFactory.htmlUnit(context, "indexB.html");
     expect(elementA == elementB, isFalse);
@@ skipping 152 matching lines @@
     ClassElementImpl classC = ElementFactory.classElement2("C", ["T"]);
     ClassElement classD = ElementFactory.classElement2("D", []);
     InterfaceType typeA = classA.type;
     classB.interfaces = <InterfaceType> [typeA];
     InterfaceTypeImpl typeBT = new InterfaceTypeImpl.con1(classB);
     DartType typeT = classC.type.typeArguments[0];
     typeBT.typeArguments = <DartType> [typeT];
     classC.interfaces = <InterfaceType> [typeBT];
     // A
     Set<InterfaceType> superinterfacesOfA = InterfaceTypeImpl.computeSuperinterfaceSet(typeA);
-    EngineTestCase.assertSizeOfSet(1, superinterfacesOfA);
+    expect(superinterfacesOfA, hasLength(1));
     InterfaceType typeObject = ElementFactory.object.type;
     expect(superinterfacesOfA.contains(typeObject), isTrue);
     // B<D>
     InterfaceTypeImpl typeBD = new InterfaceTypeImpl.con1(classB);
     typeBD.typeArguments = <DartType> [classD.type];
     Set<InterfaceType> superinterfacesOfBD = InterfaceTypeImpl.computeSuperinterfaceSet(typeBD);
-    EngineTestCase.assertSizeOfSet(2, superinterfacesOfBD);
+    expect(superinterfacesOfBD, hasLength(2));
     expect(superinterfacesOfBD.contains(typeObject), isTrue);
     expect(superinterfacesOfBD.contains(typeA), isTrue);
     // C<D>
     InterfaceTypeImpl typeCD = new InterfaceTypeImpl.con1(classC);
     typeCD.typeArguments = <DartType> [classD.type];
     Set<InterfaceType> superinterfacesOfCD = InterfaceTypeImpl.computeSuperinterfaceSet(typeCD);
-    EngineTestCase.assertSizeOfSet(3, superinterfacesOfCD);
+    expect(superinterfacesOfCD, hasLength(3));
     expect(superinterfacesOfCD.contains(typeObject), isTrue);
     expect(superinterfacesOfCD.contains(typeA), isTrue);
     expect(superinterfacesOfCD.contains(typeBD), isTrue);
   }
 
   void test_computeSuperinterfaceSet_genericSuperclassPath() {
     //
     //  A
     //  |
     //  B<T>
     //  |
     //  C<T>
     //
     //  D
     //
     ClassElement classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     ClassElement classB = ElementFactory.classElement("B", typeA, ["T"]);
     ClassElementImpl classC = ElementFactory.classElement2("C", ["T"]);
     InterfaceTypeImpl typeBT = new InterfaceTypeImpl.con1(classB);
     DartType typeT = classC.type.typeArguments[0];
     typeBT.typeArguments = <DartType> [typeT];
     classC.supertype = typeBT;
     ClassElement classD = ElementFactory.classElement2("D", []);
     // A
     Set<InterfaceType> superinterfacesOfA = InterfaceTypeImpl.computeSuperinterfaceSet(typeA);
-    EngineTestCase.assertSizeOfSet(1, superinterfacesOfA);
+    expect(superinterfacesOfA, hasLength(1));
     InterfaceType typeObject = ElementFactory.object.type;
     expect(superinterfacesOfA.contains(typeObject), isTrue);
     // B<D>
     InterfaceTypeImpl typeBD = new InterfaceTypeImpl.con1(classB);
     typeBD.typeArguments = <DartType> [classD.type];
     Set<InterfaceType> superinterfacesOfBD = InterfaceTypeImpl.computeSuperinterfaceSet(typeBD);
-    EngineTestCase.assertSizeOfSet(2, superinterfacesOfBD);
+    expect(superinterfacesOfBD, hasLength(2));
     expect(superinterfacesOfBD.contains(typeObject), isTrue);
     expect(superinterfacesOfBD.contains(typeA), isTrue);
     // C<D>
     InterfaceTypeImpl typeCD = new InterfaceTypeImpl.con1(classC);
     typeCD.typeArguments = <DartType> [classD.type];
     Set<InterfaceType> superinterfacesOfCD = InterfaceTypeImpl.computeSuperinterfaceSet(typeCD);
-    EngineTestCase.assertSizeOfSet(3, superinterfacesOfCD);
+    expect(superinterfacesOfCD, hasLength(3));
     expect(superinterfacesOfCD.contains(typeObject), isTrue);
     expect(superinterfacesOfCD.contains(typeA), isTrue);
     expect(superinterfacesOfCD.contains(typeBD), isTrue);
   }
 
   void test_computeSuperinterfaceSet_multipleInterfacePaths() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     ClassElementImpl classD = ElementFactory.classElement2("D", []);
     ClassElementImpl classE = ElementFactory.classElement2("E", []);
     classB.interfaces = <InterfaceType> [classA.type];
     classC.interfaces = <InterfaceType> [classA.type];
     classD.interfaces = <InterfaceType> [classC.type];
     classE.interfaces = <InterfaceType> [classB.type, classD.type];
     // D
     Set<InterfaceType> superinterfacesOfD = InterfaceTypeImpl.computeSuperinterfaceSet(classD.type);
-    EngineTestCase.assertSizeOfSet(3, superinterfacesOfD);
+    expect(superinterfacesOfD, hasLength(3));
     expect(superinterfacesOfD.contains(ElementFactory.object.type), isTrue);
     expect(superinterfacesOfD.contains(classA.type), isTrue);
     expect(superinterfacesOfD.contains(classC.type), isTrue);
     // E
     Set<InterfaceType> superinterfacesOfE = InterfaceTypeImpl.computeSuperinterfaceSet(classE.type);
-    EngineTestCase.assertSizeOfSet(5, superinterfacesOfE);
+    expect(superinterfacesOfE, hasLength(5));
     expect(superinterfacesOfE.contains(ElementFactory.object.type), isTrue);
     expect(superinterfacesOfE.contains(classA.type), isTrue);
     expect(superinterfacesOfE.contains(classB.type), isTrue);
     expect(superinterfacesOfE.contains(classC.type), isTrue);
     expect(superinterfacesOfE.contains(classD.type), isTrue);
   }
 
   void test_computeSuperinterfaceSet_multipleSuperclassPaths() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     ClassElement classB = ElementFactory.classElement("B", classA.type, []);
     ClassElement classC = ElementFactory.classElement("C", classA.type, []);
     ClassElement classD = ElementFactory.classElement("D", classC.type, []);
     ClassElementImpl classE = ElementFactory.classElement("E", classB.type, []);
     classE.interfaces = <InterfaceType> [classD.type];
     // D
     Set<InterfaceType> superinterfacesOfD = InterfaceTypeImpl.computeSuperinterfaceSet(classD.type);
-    EngineTestCase.assertSizeOfSet(3, superinterfacesOfD);
+    expect(superinterfacesOfD, hasLength(3));
     expect(superinterfacesOfD.contains(ElementFactory.object.type), isTrue);
     expect(superinterfacesOfD.contains(classA.type), isTrue);
     expect(superinterfacesOfD.contains(classC.type), isTrue);
     // E
     Set<InterfaceType> superinterfacesOfE = InterfaceTypeImpl.computeSuperinterfaceSet(classE.type);
-    EngineTestCase.assertSizeOfSet(5, superinterfacesOfE);
+    expect(superinterfacesOfE, hasLength(5));
     expect(superinterfacesOfE.contains(ElementFactory.object.type), isTrue);
     expect(superinterfacesOfE.contains(classA.type), isTrue);
     expect(superinterfacesOfE.contains(classB.type), isTrue);
     expect(superinterfacesOfE.contains(classC.type), isTrue);
     expect(superinterfacesOfE.contains(classD.type), isTrue);
   }
 
   void test_computeSuperinterfaceSet_recursion() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     classA.supertype = classB.type;
     Set<InterfaceType> superinterfacesOfB = InterfaceTypeImpl.computeSuperinterfaceSet(classB.type);
-    EngineTestCase.assertSizeOfSet(2, superinterfacesOfB);
+    expect(superinterfacesOfB, hasLength(2));
   }
 
   void test_computeSuperinterfaceSet_singleInterfacePath() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     classB.interfaces = <InterfaceType> [classA.type];
     classC.interfaces = <InterfaceType> [classB.type];
     // A
     Set<InterfaceType> superinterfacesOfA = InterfaceTypeImpl.computeSuperinterfaceSet(classA.type);
-    EngineTestCase.assertSizeOfSet(1, superinterfacesOfA);
+    expect(superinterfacesOfA, hasLength(1));
     expect(superinterfacesOfA.contains(ElementFactory.object.type), isTrue);
     // B
     Set<InterfaceType> superinterfacesOfB = InterfaceTypeImpl.computeSuperinterfaceSet(classB.type);
-    EngineTestCase.assertSizeOfSet(2, superinterfacesOfB);
+    expect(superinterfacesOfB, hasLength(2));
     expect(superinterfacesOfB.contains(ElementFactory.object.type), isTrue);
     expect(superinterfacesOfB.contains(classA.type), isTrue);
     // C
     Set<InterfaceType> superinterfacesOfC = InterfaceTypeImpl.computeSuperinterfaceSet(classC.type);
-    EngineTestCase.assertSizeOfSet(3, superinterfacesOfC);
+    expect(superinterfacesOfC, hasLength(3));
     expect(superinterfacesOfC.contains(ElementFactory.object.type), isTrue);
     expect(superinterfacesOfC.contains(classA.type), isTrue);
     expect(superinterfacesOfC.contains(classB.type), isTrue);
   }
 
   void test_computeSuperinterfaceSet_singleSuperclassPath() {
     //
     //  A
     //  |
     //  B
     //  |
     //  C
     //
     ClassElement classA = ElementFactory.classElement2("A", []);
     ClassElement classB = ElementFactory.classElement("B", classA.type, []);
     ClassElement classC = ElementFactory.classElement("C", classB.type, []);
     // A
     Set<InterfaceType> superinterfacesOfA = InterfaceTypeImpl.computeSuperinterfaceSet(classA.type);
-    EngineTestCase.assertSizeOfSet(1, superinterfacesOfA);
+    expect(superinterfacesOfA, hasLength(1));
     expect(superinterfacesOfA.contains(ElementFactory.object.type), isTrue);
     // B
     Set<InterfaceType> superinterfacesOfB = InterfaceTypeImpl.computeSuperinterfaceSet(classB.type);
-    EngineTestCase.assertSizeOfSet(2, superinterfacesOfB);
+    expect(superinterfacesOfB, hasLength(2));
     expect(superinterfacesOfB.contains(ElementFactory.object.type), isTrue);
     expect(superinterfacesOfB.contains(classA.type), isTrue);
     // C
     Set<InterfaceType> superinterfacesOfC = InterfaceTypeImpl.computeSuperinterfaceSet(classC.type);
-    EngineTestCase.assertSizeOfSet(3, superinterfacesOfC);
+    expect(superinterfacesOfC, hasLength(3));
     expect(superinterfacesOfC.contains(ElementFactory.object.type), isTrue);
     expect(superinterfacesOfC.contains(classA.type), isTrue);
     expect(superinterfacesOfC.contains(classB.type), isTrue);
   }
 
   void test_creation() {
     expect(new InterfaceTypeImpl.con1(ElementFactory.classElement2("A", [])), isNotNull);
   }
 
   void test_getAccessors() {
@@ skipping 64 matching lines @@
     //
     // class C implements A, B
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     InterfaceType typeB = classB.type;
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     classC.interfaces = <InterfaceType> [typeA, typeB];
     List<InterfaceType> interfaces = classC.type.interfaces;
-    EngineTestCase.assertLength(2, interfaces);
+    expect(interfaces, hasLength(2));
     if (identical(interfaces[0], typeA)) {
       expect(interfaces[1], same(typeB));
     } else {
       expect(interfaces[0], same(typeB));
       expect(interfaces[1], same(typeA));
     }
   }
 
   void test_getInterfaces_parameterized() {
     //
     // class A<E>
     // class B<F> implements A<F>
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", ["E"]);
     ClassElementImpl classB = ElementFactory.classElement2("B", ["F"]);
     InterfaceType typeB = classB.type;
     InterfaceTypeImpl typeAF = new InterfaceTypeImpl.con1(classA);
     typeAF.typeArguments = <DartType> [typeB.typeArguments[0]];
     classB.interfaces = <InterfaceType> [typeAF];
     //
     // B<I>
     //
     InterfaceType typeI = ElementFactory.classElement2("I", []).type;
     InterfaceTypeImpl typeBI = new InterfaceTypeImpl.con1(classB);
     typeBI.typeArguments = <DartType> [typeI];
     List<InterfaceType> interfaces = typeBI.interfaces;
-    EngineTestCase.assertLength(1, interfaces);
+    expect(interfaces, hasLength(1));
     InterfaceType result = interfaces[0];
     expect(result.element, same(classA));
     expect(result.typeArguments[0], same(typeI));
   }
 
   void test_getLeastUpperBound_directInterfaceCase() {
     //
     // class A
     // class B implements A
     // class C implements B
@@ skipping 249 matching lines @@
     // A<I>
     //
     InterfaceType typeI = ElementFactory.classElement2("I", []).type;
     InterfaceTypeImpl typeAI = new InterfaceTypeImpl.con1(classA);
     typeAI.typeArguments = <DartType> [typeI];
     MethodElement method = typeAI.getMethod(methodName);
     expect(method, isNotNull);
     FunctionType methodType = method.type;
     expect(methodType.returnType, same(typeI));
     List<DartType> parameterTypes = methodType.normalParameterTypes;
-    EngineTestCase.assertLength(1, parameterTypes);
+    expect(parameterTypes, hasLength(1));
     expect(parameterTypes[0], same(typeI));
   }
 
   void test_getMethod_unimplemented() {
     //
     // class A {}
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     expect(typeA.getMethod("m"), isNull);
@@ skipping 18 matching lines @@
     //
     // class C extends Object with A, B
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     InterfaceType typeB = classB.type;
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     classC.mixins = <InterfaceType> [typeA, typeB];
     List<InterfaceType> interfaces = classC.type.mixins;
-    EngineTestCase.assertLength(2, interfaces);
+    expect(interfaces, hasLength(2));
     if (identical(interfaces[0], typeA)) {
       expect(interfaces[1], same(typeB));
     } else {
       expect(interfaces[0], same(typeB));
       expect(interfaces[1], same(typeA));
     }
   }
 
   void test_getMixins_parameterized() {
     //
     // class A<E>
     // class B<F> extends Object with A<F>
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", ["E"]);
     ClassElementImpl classB = ElementFactory.classElement2("B", ["F"]);
     InterfaceType typeB = classB.type;
     InterfaceTypeImpl typeAF = new InterfaceTypeImpl.con1(classA);
     typeAF.typeArguments = <DartType> [typeB.typeArguments[0]];
     classB.mixins = <InterfaceType> [typeAF];
     //
     // B<I>
     //
     InterfaceType typeI = ElementFactory.classElement2("I", []).type;
     InterfaceTypeImpl typeBI = new InterfaceTypeImpl.con1(classB);
     typeBI.typeArguments = <DartType> [typeI];
     List<InterfaceType> interfaces = typeBI.mixins;
-    EngineTestCase.assertLength(1, interfaces);
+    expect(interfaces, hasLength(1));
     InterfaceType result = interfaces[0];
     expect(result.element, same(classA));
     expect(result.typeArguments[0], same(typeI));
   }
 
   void test_getSetter_implemented() {
     //
     // class A { s() {} }
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
@@ skipping 17 matching lines @@
     //
     // A<I>
     //
     InterfaceType typeI = ElementFactory.classElement2("I", []).type;
     InterfaceTypeImpl typeAI = new InterfaceTypeImpl.con1(classA);
     typeAI.typeArguments = <DartType> [typeI];
     PropertyAccessorElement setter = typeAI.getSetter(setterName);
     expect(setter, isNotNull);
     FunctionType setterType = setter.type;
     List<DartType> parameterTypes = setterType.normalParameterTypes;
-    EngineTestCase.assertLength(1, parameterTypes);
+    expect(parameterTypes, hasLength(1));
     expect(parameterTypes[0], same(typeI));
   }
 
   void test_getSetter_unimplemented() {
     //
     // class A {}
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     expect(typeA.getSetter("s"), isNull);
@@ skipping 27 matching lines @@
     InterfaceType typeI = ElementFactory.classElement2("I", []).type;
     InterfaceTypeImpl typeBI = new InterfaceTypeImpl.con1(classB);
     typeBI.typeArguments = <DartType> [typeI];
     InterfaceType superclass = typeBI.superclass;
     expect(superclass.element, same(classA));
     expect(superclass.typeArguments[0], same(typeI));
   }
 
   void test_getTypeArguments_empty() {
     InterfaceType type = ElementFactory.classElement2("A", []).type;
-    EngineTestCase.assertLength(0, type.typeArguments);
+    expect(type.typeArguments, hasLength(0));
   }
 
   void test_hashCode() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     expect(0 == typeA.hashCode, isFalse);
   }
 
   void test_isAssignableTo_typeVariables() {
     //
@@ skipping 532 matching lines @@
     // B<I>
     //
     InterfaceType typeI = ElementFactory.classElement2("I", []).type;
     InterfaceTypeImpl typeBI = new InterfaceTypeImpl.con1(classB);
     typeBI.typeArguments = <DartType> [typeI];
     MethodElement method = typeBI.lookUpMethod(methodName, library);
     expect(method, isNotNull);
     FunctionType methodType = method.type;
     expect(methodType.returnType, same(typeI));
     List<DartType> parameterTypes = methodType.normalParameterTypes;
-    EngineTestCase.assertLength(1, parameterTypes);
+    expect(parameterTypes, hasLength(1));
     expect(parameterTypes[0], same(typeI));
   }
 
   void test_lookUpMethod_recursive() {
     //
     // class A extends B {}
     // class B extends A {}
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
@@ skipping 87 matching lines @@
 
   void test_substitute_equal() {
     ClassElement classAE = ElementFactory.classElement2("A", ["E"]);
     InterfaceType typeAE = classAE.type;
     InterfaceType argumentType = ElementFactory.classElement2("B", []).type;
     List<DartType> args = [argumentType];
     List<DartType> params = [classAE.typeParameters[0].type];
     InterfaceType typeAESubbed = typeAE.substitute2(args, params);
     expect(typeAESubbed.element, classAE);
     List<DartType> resultArguments = typeAESubbed.typeArguments;
-    EngineTestCase.assertLength(1, resultArguments);
+    expect(resultArguments, hasLength(1));
     expect(resultArguments[0], argumentType);
   }
 
   void test_substitute_exception() {
     try {
       ClassElementImpl classA = ElementFactory.classElement2("A", []);
       InterfaceTypeImpl type = new InterfaceTypeImpl.con1(classA);
       InterfaceType argumentType = ElementFactory.classElement2("B", []).type;
       type.substitute2(<DartType> [argumentType], <DartType> []);
       fail("Expected to encounter exception, argument and parameter type array lengths not equal.");
     } 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"));
     InterfaceTypeImpl type = new InterfaceTypeImpl.con1(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")));
     InterfaceType result = type.substitute2(<DartType> [argumentType], <DartType> [parameterType]);
     expect(result.element, classA);
     List<DartType> resultArguments = result.typeArguments;
-    EngineTestCase.assertLength(1, resultArguments);
+    expect(resultArguments, hasLength(1));
     expect(resultArguments[0], parameter);
   }
 }
 
 class InterfaceTypeImpl_FunctionTypeImplTest_test_isSubtypeOf_baseCase_classFunction extends InterfaceTypeImpl {
   InterfaceTypeImpl_FunctionTypeImplTest_test_isSubtypeOf_baseCase_classFunction(ClassElement arg0) : super.con1(arg0);
 
   @override
   bool get isDartCoreFunction => true;
 }
@@ skipping 29 matching lines @@
     PrefixElement prefixA = new PrefixElementImpl.forNode(AstFactory.identifier3("a"));
     PrefixElement prefixB = new PrefixElementImpl.forNode(AstFactory.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;
-    EngineTestCase.assertLength(2, prefixes);
+    expect(prefixes, hasLength(2));
     if (identical(prefixA, prefixes[0])) {
       expect(prefixes[1], same(prefixB));
     } else {
       expect(prefixes[0], same(prefixB));
       expect(prefixes[1], same(prefixA));
     }
   }
 
   void test_getUnits() {
     AnalysisContext context = createAnalysisContext();
@@ skipping 76 matching lines @@
   }
 
   void test_setImports() {
     AnalysisContext context = createAnalysisContext();
     LibraryElementImpl library = new LibraryElementImpl.forNode(context, AstFactory.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;
-    EngineTestCase.assertLength(expectedImports.length, actualImports);
+    expect(actualImports, hasLength(expectedImports.length));
     for (int i = 0; i < actualImports.length; i++) {
       expect(actualImports[i], same(expectedImports[i]));
     }
   }
 }
 
 class MultiplyDefinedElementImplTest extends EngineTestCase {
   void test_fromElements_conflicting() {
     Element firstElement = ElementFactory.localVariableElement2("xx");
     Element secondElement = ElementFactory.localVariableElement2("yy");
     Element result = MultiplyDefinedElementImpl.fromElements(null, firstElement, secondElement);
     EngineTestCase.assertInstanceOf((obj) => obj is MultiplyDefinedElement, MultiplyDefinedElement, result);
     List<Element> elements = (result as MultiplyDefinedElement).conflictingElements;
-    EngineTestCase.assertLength(2, elements);
+    expect(elements, hasLength(2));
     for (int i = 0; i < elements.length; i++) {
       EngineTestCase.assertInstanceOf((obj) => obj is LocalVariableElement, LocalVariableElement, elements[i]);
     }
   }
 
   void test_fromElements_multiple() {
     Element firstElement = ElementFactory.localVariableElement2("xx");
     Element secondElement = ElementFactory.localVariableElement2("yy");
     Element thirdElement = ElementFactory.localVariableElement2("zz");
     Element result = MultiplyDefinedElementImpl.fromElements(null, MultiplyDefinedElementImpl.fromElements(null, firstElement, secondElement), thirdElement);
     EngineTestCase.assertInstanceOf((obj) => obj is MultiplyDefinedElement, MultiplyDefinedElement, result);
     List<Element> elements = (result as MultiplyDefinedElement).conflictingElements;
-    EngineTestCase.assertLength(3, elements);
+    expect(elements, hasLength(3));
     for (int i = 0; i < elements.length; i++) {
       EngineTestCase.assertInstanceOf((obj) => obj is LocalVariableElement, LocalVariableElement, elements[i]);
     }
   }
 
   void test_fromElements_nonConflicting() {
     Element element = ElementFactory.localVariableElement2("xx");
     expect(MultiplyDefinedElementImpl.fromElements(null, element, element), same(element));
   }
 }
@@ skipping 335 matching lines @@
   runReflectiveTests(UnionTypeImplTest);
   runReflectiveTests(VoidTypeImplTest);
   runReflectiveTests(ClassElementImplTest);
   runReflectiveTests(CompilationUnitElementImplTest);
   runReflectiveTests(ElementLocationImplTest);
   runReflectiveTests(ElementImplTest);
   runReflectiveTests(HtmlElementImplTest);
   runReflectiveTests(LibraryElementImplTest);
   runReflectiveTests(MultiplyDefinedElementImplTest);
 }