Replace EngineTestCase.assertSize() with hasLength().

pkg/analyzer/test/generated/all_the_rest.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.all_the_rest_test;
 
 import 'dart:collection';
@@ skipping 459 matching lines @@
     ClassElement classElement = mainUnitElement.getType("MyDirective");
     AngularDecoratorElement directive =
         getAngularElement(classElement, (e) => e is AngularDecoratorElement);
     expect(directive, isNotNull);
     // verify
     expect(directive.name, null);
     expect(directive.nameOffset, -1);
     _assertHasAttributeSelector(directive.selector, "my-dir");
     // verify properties
     List<AngularPropertyElement> properties = directive.properties;
-    EngineTestCase.assertLength(3, properties);
+    expect(properties, hasLength(3));
     _assertProperty(
         properties[0],
         "my-dir",
         findMainOffset("my-dir' :"),
         AngularPropertyKind.ONE_WAY,
         "myPropA",
         findMainOffset("myPropA'"));
     _assertProperty(
         properties[1],
         ".",
@@ skipping 281 matching lines @@
              })
 class MyComponent extends MySuper {
 }'''));
     // prepare AngularComponentElement
     ClassElement classElement = mainUnitElement.getType("MyComponent");
     AngularComponentElement component =
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     expect(component, isNotNull);
     // verify
     List<AngularPropertyElement> properties = component.properties;
-    EngineTestCase.assertLength(1, properties);
+    expect(properties, hasLength(1));
     _assertProperty(
         properties[0],
         "prop-a",
         findMainOffset("prop-a' :"),
         AngularPropertyKind.ATTR,
         "myPropA",
         findMainOffset("myPropA'"));
   }
 
   void test_NgComponent_properties_fromFields() {
@@ skipping 15 matching lines @@
   @NgTwoWay('prop-e')
   var myPropE;
 }'''));
     // prepare AngularComponentElement
     ClassElement classElement = mainUnitElement.getType("MyComponent");
     AngularComponentElement component =
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     expect(component, isNotNull);
     // verify
     List<AngularPropertyElement> properties = component.properties;
-    EngineTestCase.assertLength(5, properties);
+    expect(properties, hasLength(5));
     _assertProperty(
         properties[0],
         "prop-a",
         findMainOffset("prop-a')"),
         AngularPropertyKind.ATTR,
         "myPropA",
         -1);
     _assertProperty(
         properties[1],
         "prop-b",
@@ skipping 45 matching lines @@
   var myPropD;
   var myPropE;
 }'''));
     // prepare AngularComponentElement
     ClassElement classElement = mainUnitElement.getType("MyComponent");
     AngularComponentElement component =
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     expect(component, isNotNull);
     // verify
     List<AngularPropertyElement> properties = component.properties;
-    EngineTestCase.assertLength(5, properties);
+    expect(properties, hasLength(5));
     _assertProperty(
         properties[0],
         "prop-a",
         findMainOffset("prop-a' :"),
         AngularPropertyKind.ATTR,
         "myPropA",
         findMainOffset("myPropA'"));
     _assertProperty(
         properties[1],
         "prop-b",
@@ skipping 39 matching lines @@
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     expect(component, isNotNull);
     // verify
     expect(component.name, "ctrl");
     expect(component.nameOffset, AngularTest.findOffset(mainContent, "ctrl'"));
     _assertIsTagSelector(component.selector, "myComp");
     expect(component.templateUri, "my_template.html");
     expect(component.templateUriOffset, AngularTest.findOffset(mainContent, "my_template.html'"));
     expect(component.styleUri, "my_styles.css");
     expect(component.styleUriOffset, AngularTest.findOffset(mainContent, "my_styles.css'"));
-    EngineTestCase.assertLength(0, component.properties);
+    expect(component.properties, hasLength(0));
   }
 
   void test_NgComponent_scopeProperties() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
     String mainContent = _createAngularSource(r'''
 @Component(publishAs: 'ctrl', selector: 'myComp',
              templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
 class MyComponent {
   MyComponent(Scope scope) {
@@ skipping 12 matching lines @@
 }''');
     resolveMainSourceNoErrors(mainContent);
     // prepare AngularComponentElement
     ClassElement classElement = mainUnitElement.getType("MyComponent");
     AngularComponentElement component =
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     expect(component, isNotNull);
     // verify
     List<AngularScopePropertyElement> scopeProperties =
         component.scopeProperties;
-    EngineTestCase.assertLength(3, scopeProperties);
+    expect(scopeProperties, hasLength(3));
     {
       AngularScopePropertyElement property = scopeProperties[0];
       expect(findMainElement2("boolProp"), same(property));
       expect(property.name, "boolProp");
       expect(property.nameOffset, AngularTest.findOffset(mainContent, "boolProp'"));
       expect(property.type.name, "bool");
     }
     {
       AngularScopePropertyElement property = scopeProperties[1];
       expect(findMainElement2("intProp"), same(property));
@@ skipping 365 matching lines @@
     foo('wrong.html', 'bar'); // more than one argument
     foo('wrong' + '.html');   // not literal
     foo('wrong.html');        // not ViewFactory
     view('my_templateA.html');
     view('my_templateB.html');
   }
 }''');
     resolveMainSourceNoErrors(mainContent);
     // prepare AngularViewElement(s)
     List<AngularViewElement> views = mainUnitElement.angularViews;
-    EngineTestCase.assertLength(2, views);
+    expect(views, hasLength(2));
     {
       AngularViewElement view = views[0];
       expect(view.templateUri, "my_templateA.html");
       expect(view.name, null);
       expect(view.nameOffset, -1);
       expect(view.templateUriOffset, AngularTest.findOffset(mainContent, "my_templateA.html'"));
     }
     {
       AngularViewElement view = views[1];
       expect(view.templateUri, "my_templateB.html");
@@ skipping 2000 matching lines @@
     expect(value.stringValue, expectedValue);
   }
 
   EvaluationResult _getExpressionValue(String contents) {
     Source source = addSource("var x = $contents;");
     LibraryElement library = resolve(source);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(source, library);
     expect(unit, isNotNull);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
-    EngineTestCase.assertSizeOfList(1, declarations);
+    expect(declarations, hasLength(1));
     CompilationUnitMember declaration = declarations[0];
     EngineTestCase.assertInstanceOf(
         (obj) => obj is TopLevelVariableDeclaration,
         TopLevelVariableDeclaration,
         declaration);
     NodeList<VariableDeclaration> variables =
         (declaration as TopLevelVariableDeclaration).variables.variables;
-    EngineTestCase.assertSizeOfList(1, variables);
+    expect(variables, hasLength(1));
     ConstantEvaluator evaluator = new ConstantEvaluator(
         source,
         (analysisContext as AnalysisContextImpl).typeProvider);
     return evaluator.evaluate(variables[0].initializer);
   }
 }
 
 
 class ConstantFinderTest extends EngineTestCase {
   AstNode _node;
@@ skipping 112 matching lines @@
 const int c = b;''');
     LibraryElement libraryElement = resolve(librarySource);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     analysisContext.computeErrors(librarySource);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit);
     computer.computeValues();
     NodeList<CompilationUnitMember> members = unit.declarations;
-    EngineTestCase.assertSizeOfList(3, members);
+    expect(members, hasLength(3));
     _validate(false, (members[0] as TopLevelVariableDeclaration).variables);
     _validate(false, (members[1] as TopLevelVariableDeclaration).variables);
     _validate(false, (members[2] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_dependentVariables() {
     Source librarySource = addSource(r'''
 const int b = a;
 const int a = 0;''');
     LibraryElement libraryElement = resolve(librarySource);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit);
     computer.computeValues();
     NodeList<CompilationUnitMember> members = unit.declarations;
-    EngineTestCase.assertSizeOfList(2, members);
+    expect(members, hasLength(2));
     _validate(true, (members[0] as TopLevelVariableDeclaration).variables);
     _validate(true, (members[1] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_empty() {
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.computeValues();
   }
 
   void test_computeValues_multipleSources() {
@@ skipping 15 matching lines @@
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(libraryUnit, isNotNull);
     CompilationUnit partUnit =
         analysisContext.resolveCompilationUnit(partSource, libraryElement);
     expect(partUnit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(libraryUnit);
     computer.add(partUnit);
     computer.computeValues();
     NodeList<CompilationUnitMember> libraryMembers = libraryUnit.declarations;
-    EngineTestCase.assertSizeOfList(2, libraryMembers);
+    expect(libraryMembers, hasLength(2));
     _validate(
         true,
         (libraryMembers[0] as TopLevelVariableDeclaration).variables);
     _validate(
         true,
         (libraryMembers[1] as TopLevelVariableDeclaration).variables);
     NodeList<CompilationUnitMember> partMembers = libraryUnit.declarations;
-    EngineTestCase.assertSizeOfList(2, partMembers);
+    expect(partMembers, hasLength(2));
     _validate(true, (partMembers[0] as TopLevelVariableDeclaration).variables);
     _validate(true, (partMembers[1] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_singleVariable() {
     Source librarySource = addSource("const int a = 0;");
     LibraryElement libraryElement = resolve(librarySource);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit);
     computer.computeValues();
     NodeList<CompilationUnitMember> members = unit.declarations;
-    EngineTestCase.assertSizeOfList(1, members);
+    expect(members, hasLength(1));
     _validate(true, (members[0] as TopLevelVariableDeclaration).variables);
   }
 
   void test_dependencyOnConstructor() {
     // x depends on "const A()"
     _assertProperDependencies(r'''
 class A {
   const A();
 }
 const x = const A();''',
@@ skipping 286 matching lines @@
   void test_instanceCreationExpression_computedField() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A(4, 5);
 class A {
   const A(int i, int j) : k = 2 * i + j;
   final int k;
 }''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
-    EngineTestCase.assertSizeOfMap(1, fields);
+    expect(fields, hasLength(1));
     _assertIntField(fields, "k", 13);
   }
 
   void
       test_instanceCreationExpression_computedField_namedOptionalWithDefault() {
     _checkInstanceCreationOptionalParams(false, true, true);
   }
 
   void
       test_instanceCreationExpression_computedField_namedOptionalWithoutDefault() {
@@ skipping 17 matching lines @@
   const A(int i) : b = const B(4);
   final int b;
 }
 class B {
   const B(this.k);
   final int k;
 }''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     Map<String, DartObjectImpl> fieldsOfA = _assertType(result, "A");
-    EngineTestCase.assertSizeOfMap(1, fieldsOfA);
+    expect(fieldsOfA, hasLength(1));
     Map<String, DartObjectImpl> fieldsOfB =
         _assertFieldType(fieldsOfA, "b", "B");
-    EngineTestCase.assertSizeOfMap(1, fieldsOfB);
+    expect(fieldsOfB, hasLength(1));
     _assertIntField(fieldsOfB, "k", 4);
   }
 
   void test_instanceCreationExpression_computedField_usesStaticConst() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A(3);
 class A {
   const A(int i) : k = i + B.bar;
   final int k;
 }
 class B {
   static const bar = 4;
 }''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
-    EngineTestCase.assertSizeOfMap(1, fields);
+    expect(fields, hasLength(1));
     _assertIntField(fields, "k", 7);
   }
 
   void test_instanceCreationExpression_computedField_usesToplevelConst() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A(3);
 const bar = 4;
 class A {
   const A(int i) : k = i + bar;
   final int k;
 }''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
-    EngineTestCase.assertSizeOfMap(1, fields);
+    expect(fields, hasLength(1));
     _assertIntField(fields, "k", 7);
   }
 
   void test_instanceCreationExpression_explicitSuper() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const B(4, 5);
 class A {
   const A(this.x);
   final int x;
 }
 class B extends A {
   const B(int x, this.y) : super(x * 2);
   final int y;
 }''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "B");
-    EngineTestCase.assertSizeOfMap(2, fields);
+    expect(fields, hasLength(2));
     _assertIntField(fields, "y", 5);
     Map<String, DartObjectImpl> superclassFields =
         _assertFieldType(fields, GenericState.SUPERCLASS_FIELD, "A");
-    EngineTestCase.assertSizeOfMap(1, superclassFields);
+    expect(superclassFields, hasLength(1));
     _assertIntField(superclassFields, "x", 8);
   }
 
   void test_instanceCreationExpression_fieldFormalParameter() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A(42);
 class A {
   int x;
   const A(this.x)
 }''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
-    EngineTestCase.assertSizeOfMap(1, fields);
+    expect(fields, hasLength(1));
     _assertIntField(fields, "x", 42);
   }
 
   void
       test_instanceCreationExpression_fieldFormalParameter_namedOptionalWithDefault() {
     _checkInstanceCreationOptionalParams(true, true, true);
   }
 
   void
       test_instanceCreationExpression_fieldFormalParameter_namedOptionalWithoutDefault() {
@@ skipping 17 matching lines @@
   const A() : x(3);
   final int x;
 }
 class B extends A {
   const B(this.y);
   final int y;
 }''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "B");
-    EngineTestCase.assertSizeOfMap(2, fields);
+    expect(fields, hasLength(2));
     _assertIntField(fields, "y", 4);
     Map<String, DartObjectImpl> superclassFields =
         _assertFieldType(fields, GenericState.SUPERCLASS_FIELD, "A");
-    EngineTestCase.assertSizeOfMap(1, superclassFields);
+    expect(superclassFields, hasLength(1));
     _assertIntField(superclassFields, "x", 3);
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A.a1();
 class A {
   const A.a1() : this.a2();
   const A.a2() : x = 5;
   final int x;
@@ skipping 111 matching lines @@
 
 class B<T> implements A {
   final T x;
   const B(this.x);
 }
 
 const A a = const A(10);''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "a");
     Map<String, DartObjectImpl> fields = _assertType(result, "B<int>");
-    EngineTestCase.assertSizeOfMap(1, fields);
+    expect(fields, hasLength(1));
     _assertIntField(fields, "x", 10);
   }
 
   void test_instanceCreationExpression_redirectWithTypeSubstitution() {
     // To evaluate the redirection of A<int>,
     // A's template argument (T=int) must be substituted
     // into B's template argument (B<U> where U=T) to get B<int>.
     CompilationUnit compilationUnit = resolveSource(r'''
 class A<T> {
   const factory A(var a) = B<T>;
 }
 
 class B<U> implements A {
   final U x;
   const B(this.x);
 }
 
 const A<int> a = const A<int>(10);''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "a");
     Map<String, DartObjectImpl> fields = _assertType(result, "B<int>");
-    EngineTestCase.assertSizeOfMap(1, fields);
+    expect(fields, hasLength(1));
     _assertIntField(fields, "x", 10);
   }
 
   void test_instanceCreationExpression_redirect_cycle() {
     // It is an error to have a cycle in factory redirects; however, we need
     // to make sure that even if the error occurs, attempting to evaluate the
     // constant will terminate.
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A();
 class A {
@@ skipping 188 matching lines @@
     CompilationUnit compilationUnit = resolveSource("""
 const x = const A();
 const y = const A(${isNamed ? '$paramName: ' : ''}10);
 class A {
   const A(${isNamed ? "{$formalParam}" : "[$formalParam]"})${isFieldFormal ? "" : " : $fieldName = $paramName"};
   final int $fieldName;
 }""");
     EvaluationResultImpl x =
         _evaluateInstanceCreationExpression(compilationUnit, "x");
     Map<String, DartObjectImpl> fieldsOfX = _assertType(x, "A");
-    EngineTestCase.assertSizeOfMap(1, fieldsOfX);
+    expect(fieldsOfX, hasLength(1));
     if (hasDefault) {
       _assertIntField(fieldsOfX, fieldName, 3);
     } else {
       _assertNullField(fieldsOfX, fieldName);
     }
     EvaluationResultImpl y =
         _evaluateInstanceCreationExpression(compilationUnit, "y");
     Map<String, DartObjectImpl> fieldsOfY = _assertType(y, "A");
-    EngineTestCase.assertSizeOfMap(1, fieldsOfY);
+    expect(fieldsOfY, hasLength(1));
     _assertIntField(fieldsOfY, fieldName, 10);
   }
 
   void _checkInstanceCreation_withSupertypeParams(bool isExplicit) {
     String superCall = isExplicit ? " : super()" : "";
     CompilationUnit compilationUnit = resolveSource("""
 class A<T> {
   const A();
 }
 class B<T, U> extends A<T> {
@@ skipping 672 matching lines @@
   }
 
   void test_getValue_int_unknown() {
     expect(_intValue(null).value, isNull);
   }
 
   void test_getValue_list_empty() {
     Object result = _listValue([]).value;
     _assertInstanceOfObjectArray(result);
     List<Object> array = result as List<Object>;
-    EngineTestCase.assertLength(0, array);
+    expect(array, hasLength(0));
   }
 
   void test_getValue_list_valid() {
     Object result = _listValue([_intValue(23)]).value;
     _assertInstanceOfObjectArray(result);
     List<Object> array = result as List<Object>;
-    EngineTestCase.assertLength(1, array);
+    expect(array, hasLength(1));
   }
 
   void test_getValue_map_empty() {
     Object result = _mapValue([]).value;
     EngineTestCase.assertInstanceOf((obj) => obj is Map, Map, result);
     Map map = result as Map;
-    EngineTestCase.assertSizeOfMap(0, map);
+    expect(map, hasLength(0));
   }
 
   void test_getValue_map_valid() {
     Object result =
         _mapValue([_stringValue("key"), _stringValue("value")]).value;
     EngineTestCase.assertInstanceOf((obj) => obj is Map, Map, result);
     Map map = result as Map;
-    EngineTestCase.assertSizeOfMap(1, map);
+    expect(map, hasLength(1));
   }
 
   void test_getValue_null() {
     expect(_nullValue().value, isNull);
   }
 
   void test_getValue_string_known() {
     String value = "twenty-three";
     expect(_stringValue(value).value, value);
   }
@@ skipping 1997 matching lines @@
 class ElementBuilderTest extends EngineTestCase {
   void test_visitCatchClause() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String exceptionParameterName = "e";
     String stackParameterName = "s";
     CatchClause clause =
         AstFactory.catchClause2(exceptionParameterName, stackParameterName, []);
     clause.accept(builder);
     List<LocalVariableElement> variables = holder.localVariables;
-    EngineTestCase.assertLength(2, variables);
+    expect(variables, hasLength(2));
     VariableElement exceptionVariable = variables[0];
     expect(exceptionVariable, isNotNull);
     expect(exceptionVariable.name, exceptionParameterName);
     expect(exceptionVariable.isSynthetic, isFalse);
     expect(exceptionVariable.isConst, isFalse);
     expect(exceptionVariable.isFinal, isFalse);
     expect(exceptionVariable.initializer, isNull);
     VariableElement stackVariable = variables[1];
     expect(stackVariable, isNotNull);
     expect(stackVariable.name, stackParameterName);
@@ skipping 10 matching lines @@
     ClassDeclaration classDeclaration = AstFactory.classDeclaration(
         Keyword.ABSTRACT,
         className,
         null,
         null,
         null,
         null,
         []);
     classDeclaration.accept(builder);
     List<ClassElement> types = holder.types;
-    EngineTestCase.assertLength(1, types);
+    expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type, isNotNull);
     expect(type.name, className);
     List<TypeParameterElement> typeParameters = type.typeParameters;
-    EngineTestCase.assertLength(0, typeParameters);
+    expect(typeParameters, hasLength(0));
     expect(type.isAbstract, isTrue);
     expect(type.isSynthetic, isFalse);
   }
 
   void test_visitClassDeclaration_minimal() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "C";
     ClassDeclaration classDeclaration =
         AstFactory.classDeclaration(null, className, null, null, null, null, []);
     classDeclaration.accept(builder);
     List<ClassElement> types = holder.types;
-    EngineTestCase.assertLength(1, types);
+    expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type, isNotNull);
     expect(type.name, className);
     List<TypeParameterElement> typeParameters = type.typeParameters;
-    EngineTestCase.assertLength(0, typeParameters);
+    expect(typeParameters, hasLength(0));
     expect(type.isAbstract, isFalse);
     expect(type.isSynthetic, isFalse);
   }
 
   void test_visitClassDeclaration_parameterized() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "C";
     String firstVariableName = "E";
     String secondVariableName = "F";
     ClassDeclaration classDeclaration = AstFactory.classDeclaration(
         null,
         className,
         AstFactory.typeParameterList([firstVariableName, secondVariableName]),
         null,
         null,
         null,
         []);
     classDeclaration.accept(builder);
     List<ClassElement> types = holder.types;
-    EngineTestCase.assertLength(1, types);
+    expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type, isNotNull);
     expect(type.name, className);
     List<TypeParameterElement> typeParameters = type.typeParameters;
-    EngineTestCase.assertLength(2, typeParameters);
+    expect(typeParameters, hasLength(2));
     expect(typeParameters[0].name, firstVariableName);
     expect(typeParameters[1].name, secondVariableName);
     expect(type.isAbstract, isFalse);
     expect(type.isSynthetic, isFalse);
   }
 
   void test_visitClassDeclaration_withMembers() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "C";
@@ skipping 15 matching lines @@
             AstFactory.methodDeclaration2(
                 null,
                 null,
                 null,
                 null,
                 AstFactory.identifier3(methodName),
                 AstFactory.formalParameterList([]),
                 AstFactory.blockFunctionBody2([]))]);
     classDeclaration.accept(builder);
     List<ClassElement> types = holder.types;
-    EngineTestCase.assertLength(1, types);
+    expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type, isNotNull);
     expect(type.name, className);
     expect(type.isAbstract, isFalse);
     expect(type.isSynthetic, isFalse);
     List<TypeParameterElement> typeParameters = type.typeParameters;
-    EngineTestCase.assertLength(1, typeParameters);
+    expect(typeParameters, hasLength(1));
     TypeParameterElement typeParameter = typeParameters[0];
     expect(typeParameter, isNotNull);
     expect(typeParameter.name, typeParameterName);
     List<FieldElement> fields = type.fields;
-    EngineTestCase.assertLength(1, fields);
+    expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, fieldName);
     List<MethodElement> methods = type.methods;
-    EngineTestCase.assertLength(1, methods);
+    expect(methods, hasLength(1));
     MethodElement method = methods[0];
     expect(method, isNotNull);
     expect(method.name, methodName);
   }
 
   void test_visitConstructorDeclaration_factory() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "A";
     ConstructorDeclaration constructorDeclaration =
         AstFactory.constructorDeclaration2(
             null,
             Keyword.FACTORY,
             AstFactory.identifier3(className),
             null,
             AstFactory.formalParameterList([]),
             null,
             AstFactory.blockFunctionBody2([]));
     constructorDeclaration.accept(builder);
     List<ConstructorElement> constructors = holder.constructors;
-    EngineTestCase.assertLength(1, constructors);
+    expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isFactory, isTrue);
     expect(constructor.name, "");
-    EngineTestCase.assertLength(0, constructor.functions);
-    EngineTestCase.assertLength(0, constructor.labels);
-    EngineTestCase.assertLength(0, constructor.localVariables);
-    EngineTestCase.assertLength(0, constructor.parameters);
+    expect(constructor.functions, hasLength(0));
+    expect(constructor.labels, hasLength(0));
+    expect(constructor.localVariables, hasLength(0));
+    expect(constructor.parameters, hasLength(0));
   }
 
   void test_visitConstructorDeclaration_minimal() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "A";
     ConstructorDeclaration constructorDeclaration =
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3(className),
             null,
             AstFactory.formalParameterList([]),
             null,
             AstFactory.blockFunctionBody2([]));
     constructorDeclaration.accept(builder);
     List<ConstructorElement> constructors = holder.constructors;
-    EngineTestCase.assertLength(1, constructors);
+    expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isFactory, isFalse);
     expect(constructor.name, "");
-    EngineTestCase.assertLength(0, constructor.functions);
-    EngineTestCase.assertLength(0, constructor.labels);
-    EngineTestCase.assertLength(0, constructor.localVariables);
-    EngineTestCase.assertLength(0, constructor.parameters);
+    expect(constructor.functions, hasLength(0));
+    expect(constructor.labels, hasLength(0));
+    expect(constructor.localVariables, hasLength(0));
+    expect(constructor.parameters, hasLength(0));
   }
 
   void test_visitConstructorDeclaration_named() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "A";
     String constructorName = "c";
     ConstructorDeclaration constructorDeclaration =
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3(className),
             constructorName,
             AstFactory.formalParameterList([]),
             null,
             AstFactory.blockFunctionBody2([]));
     constructorDeclaration.accept(builder);
     List<ConstructorElement> constructors = holder.constructors;
-    EngineTestCase.assertLength(1, constructors);
+    expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isFactory, isFalse);
     expect(constructor.name, constructorName);
-    EngineTestCase.assertLength(0, constructor.functions);
-    EngineTestCase.assertLength(0, constructor.labels);
-    EngineTestCase.assertLength(0, constructor.localVariables);
-    EngineTestCase.assertLength(0, constructor.parameters);
+    expect(constructor.functions, hasLength(0));
+    expect(constructor.labels, hasLength(0));
+    expect(constructor.localVariables, hasLength(0));
+    expect(constructor.parameters, hasLength(0));
     expect(constructorDeclaration.name.staticElement, same(constructor));
     expect(constructorDeclaration.element, same(constructor));
   }
 
   void test_visitConstructorDeclaration_unnamed() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "A";
     ConstructorDeclaration constructorDeclaration =
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3(className),
             null,
             AstFactory.formalParameterList([]),
             null,
             AstFactory.blockFunctionBody2([]));
     constructorDeclaration.accept(builder);
     List<ConstructorElement> constructors = holder.constructors;
-    EngineTestCase.assertLength(1, constructors);
+    expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isFactory, isFalse);
     expect(constructor.name, "");
-    EngineTestCase.assertLength(0, constructor.functions);
-    EngineTestCase.assertLength(0, constructor.labels);
-    EngineTestCase.assertLength(0, constructor.localVariables);
-    EngineTestCase.assertLength(0, constructor.parameters);
+    expect(constructor.functions, hasLength(0));
+    expect(constructor.labels, hasLength(0));
+    expect(constructor.localVariables, hasLength(0));
+    expect(constructor.parameters, hasLength(0));
     expect(constructorDeclaration.element, same(constructor));
   }
 
   void test_visitEnumDeclaration() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String enumName = "E";
     EnumDeclaration enumDeclaration =
         AstFactory.enumDeclaration2(enumName, ["ONE"]);
     enumDeclaration.accept(builder);
     List<ClassElement> enums = holder.enums;
-    EngineTestCase.assertLength(1, enums);
+    expect(enums, hasLength(1));
     ClassElement enumElement = enums[0];
     expect(enumElement, isNotNull);
     expect(enumElement.name, enumName);
   }
 
   void test_visitFieldDeclaration() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String firstFieldName = "x";
     String secondFieldName = "y";
     FieldDeclaration fieldDeclaration = AstFactory.fieldDeclaration2(
         false,
         null,
         [
             AstFactory.variableDeclaration(firstFieldName),
             AstFactory.variableDeclaration(secondFieldName)]);
     fieldDeclaration.accept(builder);
     List<FieldElement> fields = holder.fields;
-    EngineTestCase.assertLength(2, fields);
+    expect(fields, hasLength(2));
     FieldElement firstField = fields[0];
     expect(firstField, isNotNull);
     expect(firstField.name, firstFieldName);
     expect(firstField.initializer, isNull);
     expect(firstField.isConst, isFalse);
     expect(firstField.isFinal, isFalse);
     expect(firstField.isSynthetic, isFalse);
     FieldElement secondField = fields[1];
     expect(secondField, isNotNull);
     expect(secondField.name, secondFieldName);
     expect(secondField.initializer, isNull);
     expect(secondField.isConst, isFalse);
     expect(secondField.isFinal, isFalse);
     expect(secondField.isSynthetic, isFalse);
   }
 
   void test_visitFieldFormalParameter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String parameterName = "p";
     FieldFormalParameter formalParameter =
         AstFactory.fieldFormalParameter(null, null, parameterName);
     formalParameter.accept(builder);
     List<ParameterElement> parameters = holder.parameters;
-    EngineTestCase.assertLength(1, parameters);
+    expect(parameters, hasLength(1));
     ParameterElement parameter = parameters[0];
     expect(parameter, isNotNull);
     expect(parameter.name, parameterName);
     expect(parameter.initializer, isNull);
     expect(parameter.isConst, isFalse);
     expect(parameter.isFinal, isFalse);
     expect(parameter.isSynthetic, isFalse);
     expect(parameter.parameterKind, ParameterKind.REQUIRED);
-    EngineTestCase.assertLength(0, parameter.parameters);
+    expect(parameter.parameters, hasLength(0));
   }
 
   void test_visitFieldFormalParameter_funtionTyped() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String parameterName = "p";
     FieldFormalParameter formalParameter = AstFactory.fieldFormalParameter(
         null,
         null,
         parameterName,
         AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("a")]));
     formalParameter.accept(builder);
     List<ParameterElement> parameters = holder.parameters;
-    EngineTestCase.assertLength(1, parameters);
+    expect(parameters, hasLength(1));
     ParameterElement parameter = parameters[0];
     expect(parameter, isNotNull);
     expect(parameter.name, parameterName);
     expect(parameter.initializer, isNull);
     expect(parameter.isConst, isFalse);
     expect(parameter.isFinal, isFalse);
     expect(parameter.isSynthetic, isFalse);
     expect(parameter.parameterKind, ParameterKind.REQUIRED);
-    EngineTestCase.assertLength(1, parameter.parameters);
+    expect(parameter.parameters, hasLength(1));
   }
 
   void test_visitFormalParameterList() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String firstParameterName = "a";
     String secondParameterName = "b";
     FormalParameterList parameterList = AstFactory.formalParameterList(
         [
             AstFactory.simpleFormalParameter3(firstParameterName),
             AstFactory.simpleFormalParameter3(secondParameterName)]);
     parameterList.accept(builder);
     List<ParameterElement> parameters = holder.parameters;
-    EngineTestCase.assertLength(2, parameters);
+    expect(parameters, hasLength(2));
     expect(parameters[0].name, firstParameterName);
     expect(parameters[1].name, secondParameterName);
   }
 
   void test_visitFunctionDeclaration_getter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String functionName = "f";
     FunctionDeclaration declaration = AstFactory.functionDeclaration(
         null,
         Keyword.GET,
         functionName,
         AstFactory.functionExpression2(
             AstFactory.formalParameterList([]),
             AstFactory.blockFunctionBody2([])));
     declaration.accept(builder);
     List<PropertyAccessorElement> accessors = holder.accessors;
-    EngineTestCase.assertLength(1, accessors);
+    expect(accessors, hasLength(1));
     PropertyAccessorElement accessor = accessors[0];
     expect(accessor, isNotNull);
     expect(accessor.name, functionName);
     expect(declaration.element, same(accessor));
     expect(declaration.functionExpression.element, same(accessor));
     expect(accessor.isGetter, isTrue);
     expect(accessor.isSetter, isFalse);
     expect(accessor.isSynthetic, isFalse);
     PropertyInducingElement variable = accessor.variable;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is TopLevelVariableElement,
         TopLevelVariableElement,
         variable);
     expect(variable.isSynthetic, isTrue);
   }
 
   void test_visitFunctionDeclaration_plain() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String functionName = "f";
     FunctionDeclaration declaration = AstFactory.functionDeclaration(
         null,
         null,
         functionName,
         AstFactory.functionExpression2(
             AstFactory.formalParameterList([]),
             AstFactory.blockFunctionBody2([])));
     declaration.accept(builder);
     List<FunctionElement> functions = holder.functions;
-    EngineTestCase.assertLength(1, functions);
+    expect(functions, hasLength(1));
     FunctionElement function = functions[0];
     expect(function, isNotNull);
     expect(function.name, functionName);
     expect(declaration.element, same(function));
     expect(declaration.functionExpression.element, same(function));
     expect(function.isSynthetic, isFalse);
   }
 
   void test_visitFunctionDeclaration_setter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String functionName = "f";
     FunctionDeclaration declaration = AstFactory.functionDeclaration(
         null,
         Keyword.SET,
         functionName,
         AstFactory.functionExpression2(
             AstFactory.formalParameterList([]),
             AstFactory.blockFunctionBody2([])));
     declaration.accept(builder);
     List<PropertyAccessorElement> accessors = holder.accessors;
-    EngineTestCase.assertLength(1, accessors);
+    expect(accessors, hasLength(1));
     PropertyAccessorElement accessor = accessors[0];
     expect(accessor, isNotNull);
     expect(accessor.name, "$functionName=");
     expect(declaration.element, same(accessor));
     expect(declaration.functionExpression.element, same(accessor));
     expect(accessor.isGetter, isFalse);
     expect(accessor.isSetter, isTrue);
     expect(accessor.isSynthetic, isFalse);
     PropertyInducingElement variable = accessor.variable;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is TopLevelVariableElement,
         TopLevelVariableElement,
         variable);
     expect(variable.isSynthetic, isTrue);
   }
 
   void test_visitFunctionExpression() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     FunctionExpression expression = AstFactory.functionExpression2(
         AstFactory.formalParameterList([]),
         AstFactory.blockFunctionBody2([]));
     expression.accept(builder);
     List<FunctionElement> functions = holder.functions;
-    EngineTestCase.assertLength(1, functions);
+    expect(functions, hasLength(1));
     FunctionElement function = functions[0];
     expect(function, isNotNull);
     expect(expression.element, same(function));
     expect(function.isSynthetic, isFalse);
   }
 
   void test_visitFunctionTypeAlias() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String aliasName = "F";
     String parameterName = "E";
     FunctionTypeAlias aliasNode = AstFactory.typeAlias(
         null,
         aliasName,
         AstFactory.typeParameterList([parameterName]),
         null);
     aliasNode.accept(builder);
     List<FunctionTypeAliasElement> aliases = holder.typeAliases;
-    EngineTestCase.assertLength(1, aliases);
+    expect(aliases, hasLength(1));
     FunctionTypeAliasElement alias = aliases[0];
     expect(alias, isNotNull);
     expect(alias.name, aliasName);
-    EngineTestCase.assertLength(0, alias.parameters);
+    expect(alias.parameters, hasLength(0));
     List<TypeParameterElement> typeParameters = alias.typeParameters;
-    EngineTestCase.assertLength(1, typeParameters);
+    expect(typeParameters, hasLength(1));
     TypeParameterElement typeParameter = typeParameters[0];
     expect(typeParameter, isNotNull);
     expect(typeParameter.name, parameterName);
   }
 
   void test_visitFunctionTypedFormalParameter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String parameterName = "p";
     FunctionTypedFormalParameter formalParameter =
         AstFactory.functionTypedFormalParameter(null, parameterName, []);
     _useParameterInMethod(formalParameter, 100, 110);
     formalParameter.accept(builder);
     List<ParameterElement> parameters = holder.parameters;
-    EngineTestCase.assertLength(1, parameters);
+    expect(parameters, hasLength(1));
     ParameterElement parameter = parameters[0];
     expect(parameter, isNotNull);
     expect(parameter.name, parameterName);
     expect(parameter.initializer, isNull);
     expect(parameter.isConst, isFalse);
     expect(parameter.isFinal, isFalse);
     expect(parameter.isSynthetic, isFalse);
     expect(parameter.parameterKind, ParameterKind.REQUIRED);
     {
       SourceRange visibleRange = parameter.visibleRange;
       expect(100, visibleRange.offset);
       expect(110, visibleRange.end);
     }
   }
 
   void test_visitLabeledStatement() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String labelName = "l";
     LabeledStatement statement = AstFactory.labeledStatement(
         AstFactory.list([AstFactory.label2(labelName)]),
         AstFactory.breakStatement());
     statement.accept(builder);
     List<LabelElement> labels = holder.labels;
-    EngineTestCase.assertLength(1, labels);
+    expect(labels, hasLength(1));
     LabelElement label = labels[0];
     expect(label, isNotNull);
     expect(label.name, labelName);
     expect(label.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_abstract() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstFactory.identifier3(methodName),
         AstFactory.formalParameterList([]),
         AstFactory.emptyFunctionBody());
     methodDeclaration.accept(builder);
     List<MethodElement> methods = holder.methods;
-    EngineTestCase.assertLength(1, methods);
+    expect(methods, hasLength(1));
     MethodElement method = methods[0];
     expect(method, isNotNull);
     expect(method.name, methodName);
-    EngineTestCase.assertLength(0, method.functions);
-    EngineTestCase.assertLength(0, method.labels);
-    EngineTestCase.assertLength(0, method.localVariables);
-    EngineTestCase.assertLength(0, method.parameters);
+    expect(method.functions, hasLength(0));
+    expect(method.labels, hasLength(0));
+    expect(method.localVariables, hasLength(0));
+    expect(method.parameters, hasLength(0));
     expect(method.isAbstract, isTrue);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_getter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         Keyword.GET,
         null,
         AstFactory.identifier3(methodName),
         AstFactory.formalParameterList([]),
         AstFactory.blockFunctionBody2([]));
     methodDeclaration.accept(builder);
     List<FieldElement> fields = holder.fields;
-    EngineTestCase.assertLength(1, fields);
+    expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, methodName);
     expect(field.isSynthetic, isTrue);
     expect(field.setter, isNull);
     PropertyAccessorElement getter = field.getter;
     expect(getter, isNotNull);
     expect(getter.isAbstract, isFalse);
     expect(getter.isGetter, isTrue);
     expect(getter.isSynthetic, isFalse);
     expect(getter.name, methodName);
     expect(getter.variable, field);
-    EngineTestCase.assertLength(0, getter.functions);
-    EngineTestCase.assertLength(0, getter.labels);
-    EngineTestCase.assertLength(0, getter.localVariables);
-    EngineTestCase.assertLength(0, getter.parameters);
+    expect(getter.functions, hasLength(0));
+    expect(getter.labels, hasLength(0));
+    expect(getter.localVariables, hasLength(0));
+    expect(getter.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_getter_abstract() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         Keyword.GET,
         null,
         AstFactory.identifier3(methodName),
         AstFactory.formalParameterList([]),
         AstFactory.emptyFunctionBody());
     methodDeclaration.accept(builder);
     List<FieldElement> fields = holder.fields;
-    EngineTestCase.assertLength(1, fields);
+    expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, methodName);
     expect(field.isSynthetic, isTrue);
     expect(field.setter, isNull);
     PropertyAccessorElement getter = field.getter;
     expect(getter, isNotNull);
     expect(getter.isAbstract, isTrue);
     expect(getter.isGetter, isTrue);
     expect(getter.isSynthetic, isFalse);
     expect(getter.name, methodName);
     expect(getter.variable, field);
-    EngineTestCase.assertLength(0, getter.functions);
-    EngineTestCase.assertLength(0, getter.labels);
-    EngineTestCase.assertLength(0, getter.localVariables);
-    EngineTestCase.assertLength(0, getter.parameters);
+    expect(getter.functions, hasLength(0));
+    expect(getter.labels, hasLength(0));
+    expect(getter.localVariables, hasLength(0));
+    expect(getter.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_getter_external() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration(
         null,
         null,
         Keyword.GET,
         null,
         AstFactory.identifier3(methodName),
         AstFactory.formalParameterList([]));
     methodDeclaration.accept(builder);
     List<FieldElement> fields = holder.fields;
-    EngineTestCase.assertLength(1, fields);
+    expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, methodName);
     expect(field.isSynthetic, isTrue);
     expect(field.setter, isNull);
     PropertyAccessorElement getter = field.getter;
     expect(getter, isNotNull);
     expect(getter.isAbstract, isFalse);
     expect(getter.isGetter, isTrue);
     expect(getter.isSynthetic, isFalse);
     expect(getter.name, methodName);
     expect(getter.variable, field);
-    EngineTestCase.assertLength(0, getter.functions);
-    EngineTestCase.assertLength(0, getter.labels);
-    EngineTestCase.assertLength(0, getter.localVariables);
-    EngineTestCase.assertLength(0, getter.parameters);
+    expect(getter.functions, hasLength(0));
+    expect(getter.labels, hasLength(0));
+    expect(getter.localVariables, hasLength(0));
+    expect(getter.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_minimal() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstFactory.identifier3(methodName),
         AstFactory.formalParameterList([]),
         AstFactory.blockFunctionBody2([]));
     methodDeclaration.accept(builder);
     List<MethodElement> methods = holder.methods;
-    EngineTestCase.assertLength(1, methods);
+    expect(methods, hasLength(1));
     MethodElement method = methods[0];
     expect(method, isNotNull);
     expect(method.name, methodName);
-    EngineTestCase.assertLength(0, method.functions);
-    EngineTestCase.assertLength(0, method.labels);
-    EngineTestCase.assertLength(0, method.localVariables);
-    EngineTestCase.assertLength(0, method.parameters);
+    expect(method.functions, hasLength(0));
+    expect(method.labels, hasLength(0));
+    expect(method.localVariables, hasLength(0));
+    expect(method.parameters, hasLength(0));
     expect(method.isAbstract, isFalse);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_operator() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "+";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         null,
         Keyword.OPERATOR,
         AstFactory.identifier3(methodName),
         AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("addend")]),
         AstFactory.blockFunctionBody2([]));
     methodDeclaration.accept(builder);
     List<MethodElement> methods = holder.methods;
-    EngineTestCase.assertLength(1, methods);
+    expect(methods, hasLength(1));
     MethodElement method = methods[0];
     expect(method, isNotNull);
     expect(method.name, methodName);
-    EngineTestCase.assertLength(0, method.functions);
-    EngineTestCase.assertLength(0, method.labels);
-    EngineTestCase.assertLength(0, method.localVariables);
-    EngineTestCase.assertLength(1, method.parameters);
+    expect(method.functions, hasLength(0));
+    expect(method.labels, hasLength(0));
+    expect(method.localVariables, hasLength(0));
+    expect(method.parameters, hasLength(1));
     expect(method.isAbstract, isFalse);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_setter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         Keyword.SET,
         null,
         AstFactory.identifier3(methodName),
         AstFactory.formalParameterList([]),
         AstFactory.blockFunctionBody2([]));
     methodDeclaration.accept(builder);
     List<FieldElement> fields = holder.fields;
-    EngineTestCase.assertLength(1, fields);
+    expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, methodName);
     expect(field.isSynthetic, isTrue);
     expect(field.getter, isNull);
     PropertyAccessorElement setter = field.setter;
     expect(setter, isNotNull);
     expect(setter.isAbstract, isFalse);
     expect(setter.isSetter, isTrue);
     expect(setter.isSynthetic, isFalse);
     expect(setter.name, "$methodName=");
     expect(setter.displayName, methodName);
     expect(setter.variable, field);
-    EngineTestCase.assertLength(0, setter.functions);
-    EngineTestCase.assertLength(0, setter.labels);
-    EngineTestCase.assertLength(0, setter.localVariables);
-    EngineTestCase.assertLength(0, setter.parameters);
+    expect(setter.functions, hasLength(0));
+    expect(setter.labels, hasLength(0));
+    expect(setter.localVariables, hasLength(0));
+    expect(setter.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_setter_abstract() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         Keyword.SET,
         null,
         AstFactory.identifier3(methodName),
         AstFactory.formalParameterList([]),
         AstFactory.emptyFunctionBody());
     methodDeclaration.accept(builder);
     List<FieldElement> fields = holder.fields;
-    EngineTestCase.assertLength(1, fields);
+    expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, methodName);
     expect(field.isSynthetic, isTrue);
     expect(field.getter, isNull);
     PropertyAccessorElement setter = field.setter;
     expect(setter, isNotNull);
     expect(setter.isAbstract, isTrue);
     expect(setter.isSetter, isTrue);
     expect(setter.isSynthetic, isFalse);
     expect(setter.name, "$methodName=");
     expect(setter.displayName, methodName);
     expect(setter.variable, field);
-    EngineTestCase.assertLength(0, setter.functions);
-    EngineTestCase.assertLength(0, setter.labels);
-    EngineTestCase.assertLength(0, setter.localVariables);
-    EngineTestCase.assertLength(0, setter.parameters);
+    expect(setter.functions, hasLength(0));
+    expect(setter.labels, hasLength(0));
+    expect(setter.localVariables, hasLength(0));
+    expect(setter.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_setter_external() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration(
         null,
         null,
         Keyword.SET,
         null,
         AstFactory.identifier3(methodName),
         AstFactory.formalParameterList([]));
     methodDeclaration.accept(builder);
     List<FieldElement> fields = holder.fields;
-    EngineTestCase.assertLength(1, fields);
+    expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, methodName);
     expect(field.isSynthetic, isTrue);
     expect(field.getter, isNull);
     PropertyAccessorElement setter = field.setter;
     expect(setter, isNotNull);
     expect(setter.isAbstract, isFalse);
     expect(setter.isSetter, isTrue);
     expect(setter.isSynthetic, isFalse);
     expect(setter.name, "$methodName=");
     expect(setter.displayName, methodName);
     expect(setter.variable, field);
-    EngineTestCase.assertLength(0, setter.functions);
-    EngineTestCase.assertLength(0, setter.labels);
-    EngineTestCase.assertLength(0, setter.localVariables);
-    EngineTestCase.assertLength(0, setter.parameters);
+    expect(setter.functions, hasLength(0));
+    expect(setter.labels, hasLength(0));
+    expect(setter.localVariables, hasLength(0));
+    expect(setter.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_static() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         Keyword.STATIC,
         null,
         null,
         null,
         AstFactory.identifier3(methodName),
         AstFactory.formalParameterList([]),
         AstFactory.blockFunctionBody2([]));
     methodDeclaration.accept(builder);
     List<MethodElement> methods = holder.methods;
-    EngineTestCase.assertLength(1, methods);
+    expect(methods, hasLength(1));
     MethodElement method = methods[0];
     expect(method, isNotNull);
     expect(method.name, methodName);
-    EngineTestCase.assertLength(0, method.functions);
-    EngineTestCase.assertLength(0, method.labels);
-    EngineTestCase.assertLength(0, method.localVariables);
-    EngineTestCase.assertLength(0, method.parameters);
+    expect(method.functions, hasLength(0));
+    expect(method.labels, hasLength(0));
+    expect(method.localVariables, hasLength(0));
+    expect(method.parameters, hasLength(0));
     expect(method.isAbstract, isFalse);
     expect(method.isStatic, isTrue);
     expect(method.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_withMembers() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     String parameterName = "p";
@@ skipping 15 matching lines @@
                     [AstFactory.variableDeclaration(localVariableName)]),
                 AstFactory.tryStatement2(
                     AstFactory.block(
                         [
                             AstFactory.labeledStatement(
                                 AstFactory.list([AstFactory.label2(labelName)]),
                                 AstFactory.returnStatement())]),
                     [AstFactory.catchClause(exceptionParameterName, [])])]));
     methodDeclaration.accept(builder);
     List<MethodElement> methods = holder.methods;
-    EngineTestCase.assertLength(1, methods);
+    expect(methods, hasLength(1));
     MethodElement method = methods[0];
     expect(method, isNotNull);
     expect(method.name, methodName);
     expect(method.isAbstract, isFalse);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
     List<VariableElement> parameters = method.parameters;
-    EngineTestCase.assertLength(1, parameters);
+    expect(parameters, hasLength(1));
     VariableElement parameter = parameters[0];
     expect(parameter, isNotNull);
     expect(parameter.name, parameterName);
     List<VariableElement> localVariables = method.localVariables;
-    EngineTestCase.assertLength(2, localVariables);
+    expect(localVariables, hasLength(2));
     VariableElement firstVariable = localVariables[0];
     VariableElement secondVariable = localVariables[1];
     expect(firstVariable, isNotNull);
     expect(secondVariable, isNotNull);
     expect((firstVariable.name == localVariableName &&
             secondVariable.name == exceptionParameterName) ||
             (firstVariable.name == exceptionParameterName &&
                 secondVariable.name == localVariableName), isTrue);
     List<LabelElement> labels = method.labels;
-    EngineTestCase.assertLength(1, labels);
+    expect(labels, hasLength(1));
     LabelElement label = labels[0];
     expect(label, isNotNull);
     expect(label.name, labelName);
   }
 
   void test_visitNamedFormalParameter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String parameterName = "p";
     DefaultFormalParameter formalParameter = AstFactory.namedFormalParameter(
         AstFactory.simpleFormalParameter3(parameterName),
         AstFactory.identifier3("42"));
     _useParameterInMethod(formalParameter, 100, 110);
     formalParameter.accept(builder);
     List<ParameterElement> parameters = holder.parameters;
-    EngineTestCase.assertLength(1, parameters);
+    expect(parameters, hasLength(1));
     ParameterElement parameter = parameters[0];
     expect(parameter, isNotNull);
     expect(parameter.name, parameterName);
     expect(parameter.isConst, isFalse);
     expect(parameter.isFinal, isFalse);
     expect(parameter.isSynthetic, isFalse);
     expect(parameter.parameterKind, ParameterKind.NAMED);
     {
       SourceRange visibleRange = parameter.visibleRange;
       expect(100, visibleRange.offset);
       expect(110, visibleRange.end);
     }
     expect(parameter.defaultValueCode, "42");
     FunctionElement initializer = parameter.initializer;
     expect(initializer, isNotNull);
     expect(initializer.isSynthetic, isTrue);
   }
 
   void test_visitSimpleFormalParameter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String parameterName = "p";
     SimpleFormalParameter formalParameter =
         AstFactory.simpleFormalParameter3(parameterName);
     _useParameterInMethod(formalParameter, 100, 110);
     formalParameter.accept(builder);
     List<ParameterElement> parameters = holder.parameters;
-    EngineTestCase.assertLength(1, parameters);
+    expect(parameters, hasLength(1));
     ParameterElement parameter = parameters[0];
     expect(parameter, isNotNull);
     expect(parameter.name, parameterName);
     expect(parameter.initializer, isNull);
     expect(parameter.isConst, isFalse);
     expect(parameter.isFinal, isFalse);
     expect(parameter.isSynthetic, isFalse);
     expect(parameter.parameterKind, ParameterKind.REQUIRED);
     {
       SourceRange visibleRange = parameter.visibleRange;
       expect(100, visibleRange.offset);
       expect(110, visibleRange.end);
     }
   }
 
   void test_visitTypeAlias_minimal() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String aliasName = "F";
     TypeAlias typeAlias = AstFactory.typeAlias(null, aliasName, null, null);
     typeAlias.accept(builder);
     List<FunctionTypeAliasElement> aliases = holder.typeAliases;
-    EngineTestCase.assertLength(1, aliases);
+    expect(aliases, hasLength(1));
     FunctionTypeAliasElement alias = aliases[0];
     expect(alias, isNotNull);
     expect(alias.name, aliasName);
     expect(alias.type, isNotNull);
     expect(alias.isSynthetic, isFalse);
   }
 
   void test_visitTypeAlias_withFormalParameters() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String aliasName = "F";
     String firstParameterName = "x";
     String secondParameterName = "y";
     TypeAlias typeAlias = AstFactory.typeAlias(
         null,
         aliasName,
         AstFactory.typeParameterList([]),
         AstFactory.formalParameterList(
             [
                 AstFactory.simpleFormalParameter3(firstParameterName),
                 AstFactory.simpleFormalParameter3(secondParameterName)]));
     typeAlias.accept(builder);
     List<FunctionTypeAliasElement> aliases = holder.typeAliases;
-    EngineTestCase.assertLength(1, aliases);
+    expect(aliases, hasLength(1));
     FunctionTypeAliasElement alias = aliases[0];
     expect(alias, isNotNull);
     expect(alias.name, aliasName);
     expect(alias.type, isNotNull);
     expect(alias.isSynthetic, isFalse);
     List<VariableElement> parameters = alias.parameters;
-    EngineTestCase.assertLength(2, parameters);
+    expect(parameters, hasLength(2));
     expect(parameters[0].name, firstParameterName);
     expect(parameters[1].name, secondParameterName);
     List<TypeParameterElement> typeParameters = alias.typeParameters;
     expect(typeParameters, isNotNull);
-    EngineTestCase.assertLength(0, typeParameters);
+    expect(typeParameters, hasLength(0));
   }
 
   void test_visitTypeAlias_withTypeParameters() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String aliasName = "F";
     String firstTypeParameterName = "A";
     String secondTypeParameterName = "B";
     TypeAlias typeAlias = AstFactory.typeAlias(
         null,
         aliasName,
         AstFactory.typeParameterList([firstTypeParameterName, secondTypeParameterName]),
         AstFactory.formalParameterList([]));
     typeAlias.accept(builder);
     List<FunctionTypeAliasElement> aliases = holder.typeAliases;
-    EngineTestCase.assertLength(1, aliases);
+    expect(aliases, hasLength(1));
     FunctionTypeAliasElement alias = aliases[0];
     expect(alias, isNotNull);
     expect(alias.name, aliasName);
     expect(alias.type, isNotNull);
     expect(alias.isSynthetic, isFalse);
     List<VariableElement> parameters = alias.parameters;
     expect(parameters, isNotNull);
-    EngineTestCase.assertLength(0, parameters);
+    expect(parameters, hasLength(0));
     List<TypeParameterElement> typeParameters = alias.typeParameters;
-    EngineTestCase.assertLength(2, typeParameters);
+    expect(typeParameters, hasLength(2));
     expect(typeParameters[0].name, firstTypeParameterName);
     expect(typeParameters[1].name, secondTypeParameterName);
   }
 
   void test_visitTypeParameter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String parameterName = "E";
     TypeParameter typeParameter = AstFactory.typeParameter(parameterName);
     typeParameter.accept(builder);
     List<TypeParameterElement> typeParameters = holder.typeParameters;
-    EngineTestCase.assertLength(1, typeParameters);
+    expect(typeParameters, hasLength(1));
     TypeParameterElement typeParameterElement = typeParameters[0];
     expect(typeParameterElement, isNotNull);
     expect(typeParameterElement.name, parameterName);
     expect(typeParameterElement.bound, isNull);
     expect(typeParameterElement.isSynthetic, isFalse);
   }
 
   void test_visitVariableDeclaration_inConstructor() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     //
     // C() {var v;}
     //
     String variableName = "v";
     VariableDeclaration variable =
         AstFactory.variableDeclaration2(variableName, null);
     Statement statement =
         AstFactory.variableDeclarationStatement2(null, [variable]);
     ConstructorDeclaration constructor = AstFactory.constructorDeclaration2(
         null,
         null,
         AstFactory.identifier3("C"),
         "C",
         AstFactory.formalParameterList([]),
         null,
         AstFactory.blockFunctionBody2([statement]));
     constructor.accept(builder);
     List<ConstructorElement> constructors = holder.constructors;
-    EngineTestCase.assertLength(1, constructors);
+    expect(constructors, hasLength(1));
     List<LocalVariableElement> variableElements =
         constructors[0].localVariables;
-    EngineTestCase.assertLength(1, variableElements);
+    expect(variableElements, hasLength(1));
     LocalVariableElement variableElement = variableElements[0];
     expect(variableElement.name, variableName);
   }
 
   void test_visitVariableDeclaration_inMethod() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     //
     // m() {var v;}
     //
     String variableName = "v";
     VariableDeclaration variable =
         AstFactory.variableDeclaration2(variableName, null);
     Statement statement =
         AstFactory.variableDeclarationStatement2(null, [variable]);
     MethodDeclaration constructor = AstFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstFactory.identifier3("m"),
         AstFactory.formalParameterList([]),
         AstFactory.blockFunctionBody2([statement]));
     constructor.accept(builder);
     List<MethodElement> methods = holder.methods;
-    EngineTestCase.assertLength(1, methods);
+    expect(methods, hasLength(1));
     List<LocalVariableElement> variableElements = methods[0].localVariables;
-    EngineTestCase.assertLength(1, variableElements);
+    expect(variableElements, hasLength(1));
     LocalVariableElement variableElement = variableElements[0];
     expect(variableElement.name, variableName);
   }
 
   void test_visitVariableDeclaration_localNestedInField() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     //
     // var f = () {var v;}
     //
     String variableName = "v";
     VariableDeclaration variable =
         AstFactory.variableDeclaration2(variableName, null);
     Statement statement =
         AstFactory.variableDeclarationStatement2(null, [variable]);
     Expression initializer = AstFactory.functionExpression2(
         AstFactory.formalParameterList([]),
         AstFactory.blockFunctionBody2([statement]));
     String fieldName = "f";
     VariableDeclaration field =
         AstFactory.variableDeclaration2(fieldName, initializer);
     FieldDeclaration fieldDeclaration =
         AstFactory.fieldDeclaration2(false, null, [field]);
     fieldDeclaration.accept(builder);
     List<FieldElement> variables = holder.fields;
-    EngineTestCase.assertLength(1, variables);
+    expect(variables, hasLength(1));
     FieldElement fieldElement = variables[0];
     expect(fieldElement, isNotNull);
     FunctionElement initializerElement = fieldElement.initializer;
     expect(initializerElement, isNotNull);
     List<FunctionElement> functionElements = initializerElement.functions;
-    EngineTestCase.assertLength(1, functionElements);
+    expect(functionElements, hasLength(1));
     List<LocalVariableElement> variableElements =
         functionElements[0].localVariables;
-    EngineTestCase.assertLength(1, variableElements);
+    expect(variableElements, hasLength(1));
     LocalVariableElement variableElement = variableElements[0];
     expect(variableElement.name, variableName);
     expect(variableElement.isConst, isFalse);
     expect(variableElement.isFinal, isFalse);
     expect(variableElement.isSynthetic, isFalse);
   }
 
   void test_visitVariableDeclaration_noInitializer() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String variableName = "v";
     VariableDeclaration variableDeclaration =
         AstFactory.variableDeclaration2(variableName, null);
     AstFactory.variableDeclarationList2(null, [variableDeclaration]);
     variableDeclaration.accept(builder);
     List<TopLevelVariableElement> variables = holder.topLevelVariables;
-    EngineTestCase.assertLength(1, variables);
+    expect(variables, hasLength(1));
     TopLevelVariableElement variable = variables[0];
     expect(variable, isNotNull);
     expect(variable.initializer, isNull);
     expect(variable.name, variableName);
     expect(variable.isConst, isFalse);
     expect(variable.isFinal, isFalse);
     expect(variable.isSynthetic, isFalse);
     expect(variable.getter, isNotNull);
     expect(variable.setter, isNotNull);
   }
@@ skipping 511 matching lines @@
 class EnumMemberBuilderTest extends EngineTestCase {
   void test_visitEnumDeclaration_multiple() {
     String firstName = "ONE";
     String secondName = "TWO";
     String thirdName = "THREE";
     EnumDeclaration enumDeclaration =
         AstFactory.enumDeclaration2("E", [firstName, secondName, thirdName]);
 
     ClassElement enumElement = _buildElement(enumDeclaration);
     List<FieldElement> fields = enumElement.fields;
-    EngineTestCase.assertLength(5, fields);
+    expect(fields, hasLength(5));
 
     FieldElement constant = fields[2];
     expect(constant, isNotNull);
     expect(constant.name, firstName);
     expect(constant.isStatic, isTrue);
     _assertGetter(constant);
 
     constant = fields[3];
     expect(constant, isNotNull);
     expect(constant.name, secondName);
     expect(constant.isStatic, isTrue);
     _assertGetter(constant);
 
     constant = fields[4];
     expect(constant, isNotNull);
     expect(constant.name, thirdName);
     expect(constant.isStatic, isTrue);
     _assertGetter(constant);
   }
 
   void test_visitEnumDeclaration_single() {
     String firstName = "ONE";
     EnumDeclaration enumDeclaration =
         AstFactory.enumDeclaration2("E", [firstName]);
 
     ClassElement enumElement = _buildElement(enumDeclaration);
     List<FieldElement> fields = enumElement.fields;
-    EngineTestCase.assertLength(3, fields);
+    expect(fields, hasLength(3));
 
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, "index");
     expect(field.isStatic, isFalse);
     expect(field.isSynthetic, isTrue);
     _assertGetter(field);
 
     field = fields[1];
     expect(field, isNotNull);
@@ skipping 17 matching lines @@
   }
 
   ClassElement _buildElement(EnumDeclaration enumDeclaration) {
     ElementHolder holder = new ElementHolder();
     ElementBuilder elementBuilder = new ElementBuilder(holder);
     enumDeclaration.accept(elementBuilder);
     EnumMemberBuilder memberBuilder =
         new EnumMemberBuilder(new TestTypeProvider());
     enumDeclaration.accept(memberBuilder);
     List<ClassElement> enums = holder.enums;
-    EngineTestCase.assertLength(1, enums);
+    expect(enums, hasLength(1));
     return enums[0];
   }
 }
 
 
 class ErrorReporterTest extends EngineTestCase {
   /**
    * Create a type with the given name in a compilation unit with the given name.
    *
    * @param fileName the name of the compilation unit containing the class
@@ skipping 1016 matching lines @@
   <body>
     <div id="x"></div>
     <p class='c'></p>
     <div class='c'></div>
   </body>
 </html>''');
     unit.accept(builder);
     HtmlTagInfo info = builder.getTagInfo();
     expect(info, isNotNull);
     List<String> allTags = info.allTags;
-    EngineTestCase.assertLength(4, allTags);
+    expect(allTags, hasLength(4));
     expect(info.getTagWithId("x"), "div");
     List<String> tagsWithClass = info.getTagsWithClass("c");
-    EngineTestCase.assertLength(2, tagsWithClass);
+    expect(tagsWithClass, hasLength(2));
   }
 }
 
 
 class HtmlUnitBuilderTest extends EngineTestCase {
   AnalysisContextImpl _context;
   @override
   void setUp() {
     _context = AnalysisContextFactory.contextWithCore();
   }
@@ skipping 72 matching lines @@
       new _ExpectedScript.con1(expectedLibrary);
   _ExpectedScript _s2(String scriptSourcePath) =>
       new _ExpectedScript.con2(scriptSourcePath);
   HtmlUnitBuilderTest_ExpectedVariable _v(String varName) =>
       new HtmlUnitBuilderTest_ExpectedVariable(varName);
   void _validate(HtmlElementImpl element,
       List<_ExpectedScript> expectedScripts) {
     expect(element.context, same(_context));
     List<HtmlScriptElement> scripts = element.scripts;
     expect(scripts, isNotNull);
-    EngineTestCase.assertLength(expectedScripts.length, scripts);
+    expect(scripts, hasLength(expectedScripts.length));
     for (int scriptIndex = 0; scriptIndex < scripts.length; scriptIndex++) {
       expectedScripts[scriptIndex]._validate(scriptIndex, scripts[scriptIndex]);
     }
   }
 }
 
 
 class HtmlUnitBuilderTest_ExpectedLibrary {
   final HtmlUnitBuilderTest HtmlUnitBuilderTest_this;
   final List<HtmlUnitBuilderTest_ExpectedVariable> _expectedVariables;
   HtmlUnitBuilderTest_ExpectedLibrary(this.HtmlUnitBuilderTest_this,
       this._expectedVariables);
   void _validate(int scriptIndex, EmbeddedHtmlScriptElementImpl script) {
     LibraryElement library = script.scriptLibrary;
     expect(library, isNotNull, reason: "script $scriptIndex");
     expect(script.context, same(HtmlUnitBuilderTest_this._context), reason: "script $scriptIndex");
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull, reason: "script $scriptIndex");
     List<TopLevelVariableElement> variables = unit.topLevelVariables;
-    EngineTestCase.assertLength(_expectedVariables.length, variables);
+    expect(variables, hasLength(_expectedVariables.length));
     for (int index = 0; index < variables.length; index++) {
       _expectedVariables[index].validate(scriptIndex, variables[index]);
     }
     expect(library.enclosingElement, same(script), reason: "script $scriptIndex");
   }
 }
 
 
 class HtmlUnitBuilderTest_ExpectedVariable {
   final String _expectedName;
@@ skipping 188 matching lines @@
   }
   void test_visitSuperConstructorInvocation_unresolved() {
     SuperConstructorInvocation superConstructorInvocation =
         AstFactory.superConstructorInvocation([]);
     _tail = superConstructorInvocation;
     _visitNode(superConstructorInvocation);
     _assertNoArcs();
   }
   void _assertNoArcs() {
     Set<AstNode> tails = _referenceGraph.getTails(_head);
-    EngineTestCase.assertSizeOfSet(0, tails);
+    expect(tails, hasLength(0));
   }
   void _assertOneArc(AstNode tail) {
     Set<AstNode> tails = _referenceGraph.getTails(_head);
-    EngineTestCase.assertSizeOfSet(1, tails);
+    expect(tails, hasLength(1));
     expect(tails.first, same(tail));
   }
   ReferenceFinder _createReferenceFinder(AstNode source) =>
       new ReferenceFinder(
           source,
           _referenceGraph,
           _variableDeclarationMap,
           _constructorDeclarationMap);
   InstanceCreationExpression _makeTailConstructor(String name,
       bool isConstDeclaration, bool isConstUsage, bool inMap) {
@@ skipping 703 matching lines @@
     Source scriptSource = externalScript.scriptSource;
     if (_expectedExternalScriptName == null) {
       expect(scriptSource, isNull, reason: "script $scriptIndex");
     } else {
       expect(scriptSource, isNotNull, reason: "script $scriptIndex");
       String actualExternalScriptName = scriptSource.shortName;
       expect(actualExternalScriptName, _expectedExternalScriptName, reason: "script $scriptIndex");
     }
   }
 }