Replace EngineTestCase.assertSize() with hasLength().

pkg/analyzer/test/generated/resolver_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.resolver_test;
 
 import 'dart:collection';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
@@ skipping 317 matching lines @@
   TestSource source1 = new TestSource('/1.dart');
   TestSource source2 = new TestSource('/2.dart');
   TestSource source3 = new TestSource('/3.dart');
 
   void test_getAddedSources() {
     AnalysisDelta delta = new AnalysisDelta();
     delta.setAnalysisLevel(source1, AnalysisLevel.ALL);
     delta.setAnalysisLevel(source2, AnalysisLevel.ERRORS);
     delta.setAnalysisLevel(source3, AnalysisLevel.NONE);
     List<Source> addedSources = delta.addedSources;
-    EngineTestCase.assertLength(2, addedSources);
+    expect(addedSources, hasLength(2));
     EngineTestCase.assertContains(addedSources, [source1, source2]);
   }
 
   void test_getAnalysisLevels() {
     AnalysisDelta delta = new AnalysisDelta();
     expect(delta.analysisLevels.length, 0);
   }
 
   void test_setAnalysisLevel() {
     AnalysisDelta delta = new AnalysisDelta();
@@ skipping 13 matching lines @@
     expect(result.length > 0, isTrue);
   }
 }
 
 class ChangeSetTest extends EngineTestCase {
   void test_changedContent() {
     TestSource source = new TestSource();
     String content = "";
     ChangeSet changeSet = new ChangeSet();
     changeSet.changedContent(source, content);
-    EngineTestCase.assertSizeOfList(0, changeSet.addedSources);
-    EngineTestCase.assertSizeOfList(0, changeSet.changedSources);
+    expect(changeSet.addedSources, hasLength(0));
+    expect(changeSet.changedSources, hasLength(0));
     Map<Source, String> map = changeSet.changedContents;
-    EngineTestCase.assertSizeOfMap(1, map);
+    expect(map, hasLength(1));
     expect(map[source], same(content));
-    EngineTestCase.assertSizeOfMap(0, changeSet.changedRanges);
-    EngineTestCase.assertSizeOfList(0, changeSet.deletedSources);
-    EngineTestCase.assertSizeOfList(0, changeSet.removedSources);
-    EngineTestCase.assertSizeOfList(0, changeSet.removedContainers);
+    expect(changeSet.changedRanges, hasLength(0));
+    expect(changeSet.deletedSources, hasLength(0));
+    expect(changeSet.removedSources, hasLength(0));
+    expect(changeSet.removedContainers, hasLength(0));
   }
 
   void test_changedRange() {
     TestSource source = new TestSource();
     String content = "";
     ChangeSet changeSet = new ChangeSet();
     changeSet.changedRange(source, content, 1, 2, 3);
-    EngineTestCase.assertSizeOfList(0, changeSet.addedSources);
-    EngineTestCase.assertSizeOfList(0, changeSet.changedSources);
-    EngineTestCase.assertSizeOfMap(0, changeSet.changedContents);
+    expect(changeSet.addedSources, hasLength(0));
+    expect(changeSet.changedSources, hasLength(0));
+    expect(changeSet.changedContents, hasLength(0));
     Map<Source, ChangeSet_ContentChange> map = changeSet.changedRanges;
-    EngineTestCase.assertSizeOfMap(1, map);
+    expect(map, hasLength(1));
     ChangeSet_ContentChange change = map[source];
     expect(change, isNotNull);
     expect(change.contents, content);
     expect(change.offset, 1);
     expect(change.oldLength, 2);
     expect(change.newLength, 3);
-    EngineTestCase.assertSizeOfList(0, changeSet.deletedSources);
-    EngineTestCase.assertSizeOfList(0, changeSet.removedSources);
-    EngineTestCase.assertSizeOfList(0, changeSet.removedContainers);
+    expect(changeSet.deletedSources, hasLength(0));
+    expect(changeSet.removedSources, hasLength(0));
+    expect(changeSet.removedContainers, hasLength(0));
   }
 
   void test_toString() {
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(new TestSource());
     changeSet.changedSource(new TestSource());
     changeSet.changedContent(new TestSource(), "");
     changeSet.changedRange(new TestSource(), "", 0, 0, 0);
     changeSet.deletedSource(new TestSource());
     changeSet.removedSource(new TestSource());
@@ skipping 1508 matching lines @@
   C() {
     int get x => 0;
   }
 }''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     var unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     var types = unit.types;
     expect(types, isNotNull);
-    EngineTestCase.assertSizeOfList(1, types);
+    expect(types, hasLength(1));
     var type = types[0];
     expect(type, isNotNull);
     var constructors = type.constructors;
     expect(constructors, isNotNull);
-    EngineTestCase.assertSizeOfList(1, constructors);
+    expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     List<FunctionElement> functions = constructor.functions;
     expect(functions, isNotNull);
-    EngineTestCase.assertSizeOfList(1, functions);
+    expect(functions, hasLength(1));
     expect(functions[0].enclosingElement, constructor);
     assertErrors(source, [ParserErrorCode.GETTER_IN_FUNCTION]);
   }
 }
 
 class HintCodeTest extends ResolverTestCase {
   void fail_deadCode_statementAfterRehrow() {
     Source source = addSource(r'''
 f() {
   try {
@@ skipping 2287 matching lines @@
     classA.accessors = <PropertyAccessorElement> [setterS];
     expect(_inheritanceManager.lookupMember(classA, setterName), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupOverrides_noParentClasses() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElementImpl methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
-    EngineTestCase.assertSizeOfList(0, _inheritanceManager.lookupOverrides(classA, methodName));
+    expect(_inheritanceManager.lookupOverrides(classA, methodName), hasLength(0));
     _assertNoErrors(classA);
   }
 
   void test_lookupOverrides_overrideBaseClass() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElementImpl methodMinA = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodMinA];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     MethodElementImpl methodMinB = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
@@ skipping 91 matching lines @@
 part 'second.dart';''');
     addSource("/first.dart", r'''
 part of lib;
 int get V => 0;''');
     addSource("/second.dart", r'''
 part of lib;
 void set V(int v) {}''');
     LibraryElement element = _buildLibrary(librarySource, []);
     expect(element, isNotNull);
     List<CompilationUnitElement> sourcedUnits = element.parts;
-    EngineTestCase.assertLength(2, sourcedUnits);
+    expect(sourcedUnits, hasLength(2));
     List<PropertyAccessorElement> firstAccessors = sourcedUnits[0].accessors;
-    EngineTestCase.assertLength(1, firstAccessors);
+    expect(firstAccessors, hasLength(1));
     List<PropertyAccessorElement> secondAccessors = sourcedUnits[1].accessors;
-    EngineTestCase.assertLength(1, secondAccessors);
+    expect(secondAccessors, hasLength(1));
     expect(secondAccessors[0].variable, same(firstAccessors[0].variable));
   }
 
   void test_empty() {
     Source librarySource = addSource("/lib.dart", "library lib;");
     LibraryElement element = _buildLibrary(librarySource, []);
     expect(element, isNotNull);
     expect(element.name, "lib");
     expect(element.entryPoint, isNull);
-    EngineTestCase.assertLength(0, element.importedLibraries);
-    EngineTestCase.assertLength(0, element.imports);
+    expect(element.importedLibraries, hasLength(0));
+    expect(element.imports, hasLength(0));
     expect(element.library, same(element));
-    EngineTestCase.assertLength(0, element.prefixes);
-    EngineTestCase.assertLength(0, element.parts);
+    expect(element.prefixes, hasLength(0));
+    expect(element.parts, hasLength(0));
     CompilationUnitElement unit = element.definingCompilationUnit;
     expect(unit, isNotNull);
     expect(unit.name, "lib.dart");
     expect(unit.library, element);
-    EngineTestCase.assertLength(0, unit.accessors);
-    EngineTestCase.assertLength(0, unit.functions);
-    EngineTestCase.assertLength(0, unit.functionTypeAliases);
-    EngineTestCase.assertLength(0, unit.types);
-    EngineTestCase.assertLength(0, unit.topLevelVariables);
+    expect(unit.accessors, hasLength(0));
+    expect(unit.functions, hasLength(0));
+    expect(unit.functionTypeAliases, hasLength(0));
+    expect(unit.types, hasLength(0));
+    expect(unit.topLevelVariables, hasLength(0));
   }
 
   void test_missingLibraryDirectiveWithPart() {
     addSource("/a.dart", "part of lib;");
     Source librarySource = addSource("/lib.dart", "part 'a.dart';");
     LibraryElement element = _buildLibrary(librarySource, [ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART]);
     expect(element, isNotNull);
   }
 
   void test_missingPartOfDirective() {
@@ skipping 15 matching lines @@
 class A {}''');
     addSource("/first.dart", r'''
 part of lib;
 class B {}''');
     addSource("/second.dart", r'''
 part of lib;
 class C {}''');
     LibraryElement element = _buildLibrary(librarySource, []);
     expect(element, isNotNull);
     List<CompilationUnitElement> sourcedUnits = element.parts;
-    EngineTestCase.assertLength(2, sourcedUnits);
+    expect(sourcedUnits, hasLength(2));
     _assertTypes(element.definingCompilationUnit, ["A"]);
     if (sourcedUnits[0].name == "first.dart") {
       _assertTypes(sourcedUnits[0], ["B"]);
       _assertTypes(sourcedUnits[1], ["C"]);
     } else {
       _assertTypes(sourcedUnits[0], ["C"]);
       _assertTypes(sourcedUnits[1], ["B"]);
     }
   }
 
@@ skipping 28 matching lines @@
 
   /**
    * Ensure that there are elements representing all of the types in the given array of type names.
    *
    * @param unit the compilation unit containing the types
    * @param typeNames the names of the types that should be found
    */
   void _assertTypes(CompilationUnitElement unit, List<String> typeNames) {
     expect(unit, isNotNull);
     List<ClassElement> types = unit.types;
-    EngineTestCase.assertLength(typeNames.length, types);
+    expect(types, hasLength(typeNames.length));
     for (ClassElement type in types) {
       expect(type, isNotNull);
       String actualTypeName = type.displayName;
       bool wasExpected = false;
       for (String expectedTypeName in typeNames) {
         if (expectedTypeName == actualTypeName) {
           wasExpected = true;
         }
       }
       if (!wasExpected) {
@@ skipping 46 matching lines @@
       GatheringErrorListener errorListener = new GatheringErrorListener();
       Scope scope = new LibraryImportScope(importingLibrary, errorListener);
       expect(scope.lookup(AstFactory.identifier3(typeNameA), importingLibrary), typeA);
       errorListener.assertNoErrors();
       expect(scope.lookup(AstFactory.identifier3(typeNameC), importingLibrary), typeC);
       errorListener.assertNoErrors();
       Element element = scope.lookup(AstFactory.identifier3(typeNameB), importingLibrary);
       errorListener.assertErrorsWithCodes([StaticWarningCode.AMBIGUOUS_IMPORT]);
       EngineTestCase.assertInstanceOf((obj) => obj is MultiplyDefinedElement, MultiplyDefinedElement, element);
       List<Element> conflictingElements = (element as MultiplyDefinedElement).conflictingElements;
-      EngineTestCase.assertLength(2, conflictingElements);
+      expect(conflictingElements, hasLength(2));
       if (identical(conflictingElements[0], typeB1)) {
         expect(conflictingElements[1], same(typeB2));
       } else if (identical(conflictingElements[0], typeB2)) {
         expect(conflictingElements[1], same(typeB1));
       } else {
         expect(conflictingElements[0], same(typeB1));
       }
     }
     {
       GatheringErrorListener errorListener = new GatheringErrorListener();
@@ skipping 243 matching lines @@
     _errorListener = new GatheringErrorListener();
     _library = _createLibrary("/lib.dart");
   }
 
   void test_getExplicitlyImportsCore() {
     expect(_library.explicitlyImportsCore, isFalse);
     _errorListener.assertNoErrors();
   }
 
   void test_getExports() {
-    EngineTestCase.assertLength(0, _library.exports);
+    expect(_library.exports, hasLength(0));
     _errorListener.assertNoErrors();
   }
 
   void test_getImports() {
-    EngineTestCase.assertLength(0, _library.imports);
+    expect(_library.imports, hasLength(0));
     _errorListener.assertNoErrors();
   }
 
   void test_getImportsAndExports() {
     _library.importedLibraries = <Library> [_createLibrary("/imported.dart")];
     _library.exportedLibraries = <Library> [_createLibrary("/exported.dart")];
-    EngineTestCase.assertLength(2, _library.importsAndExports);
+    expect(_library.importsAndExports, hasLength(2));
     _errorListener.assertNoErrors();
   }
 
   void test_getLibraryScope() {
     LibraryElementImpl element = new LibraryElementImpl.forNode(_analysisContext, AstFactory.libraryIdentifier2(["lib"]));
     element.definingCompilationUnit = new CompilationUnitElementImpl("lib.dart");
     _library.libraryElement = element;
     expect(_library.libraryScope, isNotNull);
     _errorListener.assertNoErrors();
   }
 
   void test_getLibrarySource() {
     expect(_library.librarySource, isNotNull);
   }
 
   void test_setExplicitlyImportsCore() {
     _library.explicitlyImportsCore = true;
     expect(_library.explicitlyImportsCore, isTrue);
     _errorListener.assertNoErrors();
   }
 
   void test_setExportedLibraries() {
     Library exportLibrary = _createLibrary("/exported.dart");
     _library.exportedLibraries = <Library> [exportLibrary];
     List<Library> exports = _library.exports;
-    EngineTestCase.assertLength(1, exports);
+    expect(exports, hasLength(1));
     expect(exports[0], same(exportLibrary));
     _errorListener.assertNoErrors();
   }
 
   void test_setImportedLibraries() {
     Library importLibrary = _createLibrary("/imported.dart");
     _library.importedLibraries = <Library> [importLibrary];
     List<Library> imports = _library.imports;
-    EngineTestCase.assertLength(1, imports);
+    expect(imports, hasLength(1));
     expect(imports[0], same(importLibrary));
     _errorListener.assertNoErrors();
   }
 
   void test_setLibraryElement() {
     LibraryElementImpl element = new LibraryElementImpl.forNode(_analysisContext, AstFactory.libraryIdentifier2(["lib"]));
     _library.libraryElement = element;
     expect(_library.libraryElement, same(element));
   }
 
@@ skipping 2282 matching lines @@
 
   void test_hasReferenceToSuper() {
     Source source = addSource(r'''
 class A {}
 class B {toString() => super.toString();}''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
-    EngineTestCase.assertLength(2, classes);
+    expect(classes, hasLength(2));
     expect(classes[0].hasReferenceToSuper, isFalse);
     expect(classes[1].hasReferenceToSuper, isTrue);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_import_hide() {
     addNamedSource("lib1.dart", r'''
 library lib1;
 set foo(value) {}
@@ skipping 109 matching lines @@
 
   void test_isValidMixin_badSuperclass() {
     Source source = addSource(r'''
 class A extends B {}
 class B {}''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
-    EngineTestCase.assertLength(2, classes);
+    expect(classes, hasLength(2));
     expect(classes[0].isValidMixin, isFalse);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_constructor() {
     Source source = addSource(r'''
 class A {
   A() {}
 }''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
-    EngineTestCase.assertLength(1, classes);
+    expect(classes, hasLength(1));
     expect(classes[0].isValidMixin, isFalse);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_super() {
     Source source = addSource(r'''
 class A {
   toString() {
     return super.toString();
   }
 }''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
-    EngineTestCase.assertLength(1, classes);
+    expect(classes, hasLength(1));
     expect(classes[0].isValidMixin, isFalse);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_valid() {
     Source source = addSource("class A {}");
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
-    EngineTestCase.assertLength(1, classes);
+    expect(classes, hasLength(1));
     expect(classes[0].isValidMixin, isTrue);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_labels_switch() {
     Source source = addSource(r'''
 void doSwitch(int target) {
   switch (target) {
     l0: case 0:
@@ skipping 32 matching lines @@
 
   void test_metadata_class() {
     Source source = addSource(r'''
 const A = null;
 @A class C<A> {}''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unitElement = library.definingCompilationUnit;
     expect(unitElement, isNotNull);
     List<ClassElement> classes = unitElement.types;
-    EngineTestCase.assertLength(1, classes);
+    expect(classes, hasLength(1));
     List<ElementAnnotation> annotations = classes[0].metadata;
-    EngineTestCase.assertLength(1, annotations);
+    expect(annotations, hasLength(1));
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
-    EngineTestCase.assertSizeOfList(2, declarations);
+    expect(declarations, hasLength(2));
     Element expectedElement = (declarations[0] as TopLevelVariableDeclaration).variables.variables[0].name.staticElement;
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyInducingElement, PropertyInducingElement, expectedElement);
     expectedElement = (expectedElement as PropertyInducingElement).getter;
     Element actualElement = (declarations[1] as ClassDeclaration).metadata[0].name.staticElement;
     expect(actualElement, same(expectedElement));
   }
 
   void test_metadata_field() {
     Source source = addSource(r'''
 const A = null;
 class C {
   @A int f;
 }''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
-    EngineTestCase.assertLength(1, classes);
+    expect(classes, hasLength(1));
     FieldElement field = classes[0].fields[0];
     List<ElementAnnotation> annotations = field.metadata;
-    EngineTestCase.assertLength(1, annotations);
+    expect(annotations, hasLength(1));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_fieldFormalParameter() {
     Source source = addSource(r'''
 const A = null;
 class C {
   int f;
   C(@A this.f);
 }''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
-    EngineTestCase.assertLength(1, classes);
+    expect(classes, hasLength(1));
     List<ConstructorElement> constructors = classes[0].constructors;
-    EngineTestCase.assertLength(1, constructors);
+    expect(constructors, hasLength(1));
     List<ParameterElement> parameters = constructors[0].parameters;
-    EngineTestCase.assertLength(1, parameters);
+    expect(parameters, hasLength(1));
     List<ElementAnnotation> annotations = parameters[0].metadata;
-    EngineTestCase.assertLength(1, annotations);
+    expect(annotations, hasLength(1));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_function() {
     Source source = addSource(r'''
 const A = null;
 @A f() {}''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
-    EngineTestCase.assertLength(1, functions);
+    expect(functions, hasLength(1));
     List<ElementAnnotation> annotations = functions[0].metadata;
-    EngineTestCase.assertLength(1, annotations);
+    expect(annotations, hasLength(1));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_functionTypedParameter() {
     Source source = addSource(r'''
 const A = null;
 f(@A int p(int x)) {}''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
-    EngineTestCase.assertLength(1, functions);
+    expect(functions, hasLength(1));
     List<ParameterElement> parameters = functions[0].parameters;
-    EngineTestCase.assertLength(1, parameters);
+    expect(parameters, hasLength(1));
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
-    EngineTestCase.assertLength(1, annotations1);
+    expect(annotations1, hasLength(1));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_libraryDirective() {
     Source source = addSource(r'''
 @A library lib;
 const A = null;''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     List<ElementAnnotation> annotations = library.metadata;
-    EngineTestCase.assertLength(1, annotations);
+    expect(annotations, hasLength(1));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_method() {
     Source source = addSource(r'''
 const A = null;
 class C {
   @A void m() {}
 }''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
-    EngineTestCase.assertLength(1, classes);
+    expect(classes, hasLength(1));
     MethodElement method = classes[0].methods[0];
     List<ElementAnnotation> annotations = method.metadata;
-    EngineTestCase.assertLength(1, annotations);
+    expect(annotations, hasLength(1));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_namedParameter() {
     Source source = addSource(r'''
 const A = null;
 f({@A int p : 0}) {}''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
-    EngineTestCase.assertLength(1, functions);
+    expect(functions, hasLength(1));
     List<ParameterElement> parameters = functions[0].parameters;
-    EngineTestCase.assertLength(1, parameters);
+    expect(parameters, hasLength(1));
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
-    EngineTestCase.assertLength(1, annotations1);
+    expect(annotations1, hasLength(1));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_positionalParameter() {
     Source source = addSource(r'''
 const A = null;
 f([@A int p = 0]) {}''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
-    EngineTestCase.assertLength(1, functions);
+    expect(functions, hasLength(1));
     List<ParameterElement> parameters = functions[0].parameters;
-    EngineTestCase.assertLength(1, parameters);
+    expect(parameters, hasLength(1));
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
-    EngineTestCase.assertLength(1, annotations1);
+    expect(annotations1, hasLength(1));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_simpleParameter() {
     Source source = addSource(r'''
 const A = null;
 f(@A p1, @A int p2) {}''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
-    EngineTestCase.assertLength(1, functions);
+    expect(functions, hasLength(1));
     List<ParameterElement> parameters = functions[0].parameters;
-    EngineTestCase.assertLength(2, parameters);
+    expect(parameters, hasLength(2));
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
-    EngineTestCase.assertLength(1, annotations1);
+    expect(annotations1, hasLength(1));
     List<ElementAnnotation> annotations2 = parameters[1].metadata;
-    EngineTestCase.assertLength(1, annotations2);
+    expect(annotations2, hasLength(1));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_typedef() {
     Source source = addSource(r'''
 const A = null;
 @A typedef F<A>();''');
     LibraryElement library = resolve(source);
     expect(library, isNotNull);
     CompilationUnitElement unitElement = library.definingCompilationUnit;
     expect(unitElement, isNotNull);
     List<FunctionTypeAliasElement> aliases = unitElement.functionTypeAliases;
-    EngineTestCase.assertLength(1, aliases);
+    expect(aliases, hasLength(1));
     List<ElementAnnotation> annotations = aliases[0].metadata;
-    EngineTestCase.assertLength(1, annotations);
+    expect(annotations, hasLength(1));
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
-    EngineTestCase.assertSizeOfList(2, declarations);
+    expect(declarations, hasLength(2));
     Element expectedElement = (declarations[0] as TopLevelVariableDeclaration).variables.variables[0].name.staticElement;
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyInducingElement, PropertyInducingElement, expectedElement);
     expectedElement = (expectedElement as PropertyInducingElement).getter;
     Element actualElement = (declarations[1] as FunctionTypeAlias).metadata[0].name.staticElement;
     expect(actualElement, same(expectedElement));
   }
 
   void test_method_fromMixin() {
     Source source = addSource(r'''
 class B {
@@ skipping 952 matching lines @@
    * @param expectedNormalTypes the expected types of the normal parameters
    * @param expectedOptionalTypes the expected types of the optional parameters
    * @param expectedNamedTypes the expected types of the named parameters
    * @param actualType the type being tested
    */
   void _assertFunctionType(DartType expectedReturnType, List<DartType> expectedNormalTypes, List<DartType> expectedOptionalTypes, Map<String, DartType> expectedNamedTypes, DartType actualType) {
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionType, FunctionType, actualType);
     FunctionType functionType = actualType as FunctionType;
     List<DartType> normalTypes = functionType.normalParameterTypes;
     if (expectedNormalTypes == null) {
-      EngineTestCase.assertLength(0, normalTypes);
+      expect(normalTypes, hasLength(0));
     } else {
       int expectedCount = expectedNormalTypes.length;
-      EngineTestCase.assertLength(expectedCount, normalTypes);
+      expect(normalTypes, hasLength(expectedCount));
       for (int i = 0; i < expectedCount; i++) {
         expect(normalTypes[i], same(expectedNormalTypes[i]));
       }
     }
     List<DartType> optionalTypes = functionType.optionalParameterTypes;
     if (expectedOptionalTypes == null) {
-      EngineTestCase.assertLength(0, optionalTypes);
+      expect(optionalTypes, hasLength(0));
     } else {
       int expectedCount = expectedOptionalTypes.length;
-      EngineTestCase.assertLength(expectedCount, optionalTypes);
+      expect(optionalTypes, hasLength(expectedCount));
       for (int i = 0; i < expectedCount; i++) {
         expect(optionalTypes[i], same(expectedOptionalTypes[i]));
       }
     }
     Map<String, DartType> namedTypes = functionType.namedParameterTypes;
     if (expectedNamedTypes == null) {
-      EngineTestCase.assertSizeOfMap(0, namedTypes);
+      expect(namedTypes, hasLength(0));
     } else {
-      EngineTestCase.assertSizeOfMap(expectedNamedTypes.length, namedTypes);
+      expect(namedTypes, hasLength(expectedNamedTypes.length));
       expectedNamedTypes.forEach((String name, DartType type) {
         expect(namedTypes[name], same(type));
       });
     }
     expect(functionType.returnType, same(expectedReturnType));
   }
 
   void _assertType(InterfaceTypeImpl expectedType, InterfaceTypeImpl actualType) {
     expect(actualType.displayName, expectedType.displayName);
     expect(actualType.element, expectedType.element);
     List<DartType> expectedArguments = expectedType.typeArguments;
     int length = expectedArguments.length;
     List<DartType> actualArguments = actualType.typeArguments;
-    EngineTestCase.assertLength(length, actualArguments);
+    expect(actualArguments, hasLength(length));
     for (int i = 0; i < length; i++) {
       _assertType2(expectedArguments[i], actualArguments[i]);
     }
   }
 
   void _assertType2(DartType expectedType, DartType actualType) {
     if (expectedType is InterfaceTypeImpl) {
       EngineTestCase.assertInstanceOf((obj) => obj is InterfaceTypeImpl, InterfaceTypeImpl, actualType);
       _assertType(expectedType, actualType as InterfaceTypeImpl);
     }
@@ skipping 573 matching lines @@
     //
     // class A extends B
     // class B extends A
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     classA.supertype = classB.type;
     _definingCompilationUnit.types = <ClassElement> [classA, classB];
     HashSet<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
-    EngineTestCase.assertSizeOfSet(2, subtypesOfA);
+    expect(subtypesOfA, hasLength(2));
     EngineTestCase.assertContains(arraySubtypesOfA, [classA, classB]);
   }
 
   void test_computeAllSubtypes_manyRecursiveSubtypes() {
     //
     // class A
     // class B extends A
     // class C extends B
     // class D extends B
     // class E extends B
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     ClassElementImpl classC = ElementFactory.classElement("C", classB.type, []);
     ClassElementImpl classD = ElementFactory.classElement("D", classB.type, []);
     ClassElementImpl classE = ElementFactory.classElement("E", classB.type, []);
     _definingCompilationUnit.types = <ClassElement> [classA, classB, classC, classD, classE];
     HashSet<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
     HashSet<ClassElement> subtypesOfB = _subtypeManager.computeAllSubtypes(classB);
     List<ClassElement> arraySubtypesOfB = new List.from(subtypesOfB);
-    EngineTestCase.assertSizeOfSet(4, subtypesOfA);
+    expect(subtypesOfA, hasLength(4));
     EngineTestCase.assertContains(arraySubtypesOfA, [classB, classC, classD, classE]);
-    EngineTestCase.assertSizeOfSet(3, subtypesOfB);
+    expect(subtypesOfB, hasLength(3));
     EngineTestCase.assertContains(arraySubtypesOfB, [classC, classD, classE]);
   }
 
   void test_computeAllSubtypes_noSubtypes() {
     //
     // class A
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     _definingCompilationUnit.types = <ClassElement> [classA];
     HashSet<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
-    EngineTestCase.assertSizeOfSet(0, subtypesOfA);
+    expect(subtypesOfA, hasLength(0));
   }
 
   void test_computeAllSubtypes_oneSubtype() {
     //
     // class A
     // class B extends A
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     _definingCompilationUnit.types = <ClassElement> [classA, classB];
     HashSet<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
-    EngineTestCase.assertSizeOfSet(1, subtypesOfA);
+    expect(subtypesOfA, hasLength(1));
     EngineTestCase.assertContains(arraySubtypesOfA, [classB]);
   }
 
   @override
   void setUp() {
     super.setUp();
     AnalysisContextImpl context = AnalysisContextFactory.contextWithCore();
     FileBasedSource source = new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
     _definingCompilationUnit = new CompilationUnitElementImpl("test.dart");
     _definingCompilationUnit.source = source;
@@ skipping 1508 matching lines @@
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     IndexExpression indexExpression = statement.expression as IndexExpression;
     expect(indexExpression.propagatedType, isNull);
     Expression v = indexExpression.target;
     InterfaceType propagatedType = v.propagatedType as InterfaceType;
     expect(propagatedType.element, same(typeProvider.listType.element));
     List<DartType> typeArguments = propagatedType.typeArguments;
-    EngineTestCase.assertLength(1, typeArguments);
+    expect(typeArguments, hasLength(1));
     expect(typeArguments[0], same(typeProvider.dynamicType));
   }
 
   void test_mapLiteral_different() {
     Source source = addSource(r'''
 f() {
   var v = {'0' : 0, 1 : '1', '2' : 2};
   return v;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier identifier = statement.expression as SimpleIdentifier;
     InterfaceType propagatedType = identifier.propagatedType as InterfaceType;
     expect(propagatedType.element, same(typeProvider.mapType.element));
     List<DartType> typeArguments = propagatedType.typeArguments;
-    EngineTestCase.assertLength(2, typeArguments);
+    expect(typeArguments, hasLength(2));
     expect(typeArguments[0], same(typeProvider.dynamicType));
     expect(typeArguments[1], same(typeProvider.dynamicType));
   }
 
   void test_mapLiteral_same() {
     Source source = addSource(r'''
 f() {
   var v = {'a' : 0, 'b' : 1, 'c' : 2};
   return v;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier identifier = statement.expression as SimpleIdentifier;
     InterfaceType propagatedType = identifier.propagatedType as InterfaceType;
     expect(propagatedType.element, same(typeProvider.mapType.element));
     List<DartType> typeArguments = propagatedType.typeArguments;
-    EngineTestCase.assertLength(2, typeArguments);
+    expect(typeArguments, hasLength(2));
     expect(typeArguments[0], same(typeProvider.dynamicType));
     expect(typeArguments[1], same(typeProvider.dynamicType));
   }
 
   void test_mergePropagatedTypesAtJoinPoint_4() {
     // https://code.google.com/p/dart/issues/detail?id=19929
     _assertTypeOfMarkedExpression(r'''
 f5(x) {
   var y = [];
   if (x) {
@@ skipping 448 matching lines @@
     ClassElement elementC = ElementFactory.classElement2("C", []);
     ClassElement elementD = ElementFactory.classElement2("D", []);
     ExtendsClause extendsClause = AstFactory.extendsClause(AstFactory.typeName(elementB, []));
     WithClause withClause = AstFactory.withClause([AstFactory.typeName(elementC, [])]);
     ImplementsClause implementsClause = AstFactory.implementsClause([AstFactory.typeName(elementD, [])]);
     ClassDeclaration declaration = AstFactory.classDeclaration(null, "A", null, extendsClause, withClause, implementsClause, []);
     declaration.name.staticElement = elementA;
     _resolveNode(declaration, [elementA, elementB, elementC, elementD]);
     expect(elementA.supertype, same(elementB.type));
     List<InterfaceType> mixins = elementA.mixins;
-    EngineTestCase.assertLength(1, mixins);
+    expect(mixins, hasLength(1));
     expect(mixins[0], same(elementC.type));
     List<InterfaceType> interfaces = elementA.interfaces;
-    EngineTestCase.assertLength(1, interfaces);
+    expect(interfaces, hasLength(1));
     expect(interfaces[0], same(elementD.type));
     _listener.assertNoErrors();
   }
 
   void test_visitClassDeclaration_instanceMemberCollidesWithClass() {
     // class A {}
     // class B extends A {
     //   void A() {}
     // }
     ClassElementImpl elementA = ElementFactory.classElement2("A", []);
@@ skipping 13 matching lines @@
     ClassElement elementB = ElementFactory.classElement2("B", []);
     ClassElement elementC = ElementFactory.classElement2("C", []);
     ClassElement elementD = ElementFactory.classElement2("D", []);
     WithClause withClause = AstFactory.withClause([AstFactory.typeName(elementC, [])]);
     ImplementsClause implementsClause = AstFactory.implementsClause([AstFactory.typeName(elementD, [])]);
     ClassTypeAlias alias = AstFactory.classTypeAlias("A", null, null, AstFactory.typeName(elementB, []), withClause, implementsClause);
     alias.name.staticElement = elementA;
     _resolveNode(alias, [elementA, elementB, elementC, elementD]);
     expect(elementA.supertype, same(elementB.type));
     List<InterfaceType> mixins = elementA.mixins;
-    EngineTestCase.assertLength(1, mixins);
+    expect(mixins, hasLength(1));
     expect(mixins[0], same(elementC.type));
     List<InterfaceType> interfaces = elementA.interfaces;
-    EngineTestCase.assertLength(1, interfaces);
+    expect(interfaces, hasLength(1));
     expect(interfaces[0], same(elementD.type));
     _listener.assertNoErrors();
   }
 
   void test_visitFieldFormalParameter_functionType() {
     InterfaceType intType = _typeProvider.intType;
     TypeName intTypeName = AstFactory.typeName4("int", []);
     String innerParameterName = "a";
     SimpleFormalParameter parameter = AstFactory.simpleFormalParameter3(innerParameterName);
     parameter.identifier.staticElement = ElementFactory.requiredParameter(innerParameterName);
     String outerParameterName = "p";
     FormalParameter node = AstFactory.fieldFormalParameter(null, intTypeName, outerParameterName, AstFactory.formalParameterList([parameter]));
     node.identifier.staticElement = ElementFactory.requiredParameter(outerParameterName);
     DartType parameterType = _resolveFormalParameter(node, [intType.element]);
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionType, FunctionType, parameterType);
     FunctionType functionType = parameterType as FunctionType;
     expect(functionType.returnType, same(intType));
-    EngineTestCase.assertLength(1, functionType.parameters);
+    expect(functionType.parameters, hasLength(1));
     _listener.assertNoErrors();
   }
 
   void test_visitFieldFormalParameter_noType() {
     String parameterName = "p";
     FormalParameter node = AstFactory.fieldFormalParameter(Keyword.VAR, null, parameterName);
     node.identifier.staticElement = ElementFactory.requiredParameter(parameterName);
     expect(_resolveFormalParameter(node, []), same(_typeProvider.dynamicType));
     _listener.assertNoErrors();
   }
@@ skipping 39 matching lines @@
 
   void test_visitTypeName_parameters_arguments() {
     ClassElement classA = ElementFactory.classElement2("A", ["E"]);
     ClassElement classB = ElementFactory.classElement2("B", []);
     TypeName typeName = AstFactory.typeName(classA, [AstFactory.typeName(classB, [])]);
     typeName.type = null;
     _resolveNode(typeName, [classA, classB]);
     InterfaceType resultType = typeName.type as InterfaceType;
     expect(resultType.element, same(classA));
     List<DartType> resultArguments = resultType.typeArguments;
-    EngineTestCase.assertLength(1, resultArguments);
+    expect(resultArguments, hasLength(1));
     expect(resultArguments[0], same(classB.type));
     _listener.assertNoErrors();
   }
 
   void test_visitTypeName_parameters_noArguments() {
     ClassElement classA = ElementFactory.classElement2("A", ["E"]);
     TypeName typeName = AstFactory.typeName(classA, []);
     typeName.type = null;
     _resolveNode(typeName, [classA]);
     InterfaceType resultType = typeName.type as InterfaceType;
     expect(resultType.element, same(classA));
     List<DartType> resultArguments = resultType.typeArguments;
-    EngineTestCase.assertLength(1, resultArguments);
+    expect(resultArguments, hasLength(1));
     expect(resultArguments[0], same(DynamicTypeImpl.instance));
     _listener.assertNoErrors();
   }
 
   void test_visitTypeName_void() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     TypeName typeName = AstFactory.typeName4("void", []);
     _resolveNode(typeName, [classA]);
     expect(typeName.type, same(VoidTypeImpl.instance));
     _listener.assertNoErrors();
@@ skipping 79 matching lines @@
   runReflectiveTests(TypeResolverVisitorTest);
   runReflectiveTests(CheckedModeCompileTimeErrorCodeTest);
   runReflectiveTests(ErrorResolverTest);
   runReflectiveTests(HintCodeTest);
   runReflectiveTests(MemberMapTest);
   runReflectiveTests(NonHintCodeTest);
   runReflectiveTests(SimpleResolverTest);
   runReflectiveTests(StrictModeTest);
   runReflectiveTests(TypePropagationTest);
 }