Replace EngineTestCase.assertSize() with hasLength().

pkg/analyzer/test/generated/parser_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser_test;
 
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 134 matching lines @@
   void test_assignableExpression_arguments_normal_chain() {
     PropertyAccess propertyAccess1 = ParserTestCase.parseExpression("a(b)(c).d(e).f", []);
     expect(propertyAccess1.propertyName.name, "f");
     //
     // a(b)(c).d(e)
     //
     MethodInvocation invocation2 = EngineTestCase.assertInstanceOf((obj) => obj is MethodInvocation, MethodInvocation, propertyAccess1.target);
     expect(invocation2.methodName.name, "d");
     ArgumentList argumentList2 = invocation2.argumentList;
     expect(argumentList2, isNotNull);
-    EngineTestCase.assertSizeOfList(1, argumentList2.arguments);
+    expect(argumentList2.arguments, hasLength(1));
     //
     // a(b)(c)
     //
     FunctionExpressionInvocation invocation3 = EngineTestCase.assertInstanceOf((obj) => obj is FunctionExpressionInvocation, FunctionExpressionInvocation, invocation2.target);
     ArgumentList argumentList3 = invocation3.argumentList;
     expect(argumentList3, isNotNull);
-    EngineTestCase.assertSizeOfList(1, argumentList3.arguments);
+    expect(argumentList3.arguments, hasLength(1));
     //
     // a(b)
     //
     MethodInvocation invocation4 = EngineTestCase.assertInstanceOf((obj) => obj is MethodInvocation, MethodInvocation, invocation3.function);
     expect(invocation4.methodName.name, "a");
     ArgumentList argumentList4 = invocation4.argumentList;
     expect(argumentList4, isNotNull);
-    EngineTestCase.assertSizeOfList(1, argumentList4.arguments);
+    expect(argumentList4.arguments, hasLength(1));
   }
 
   void test_assignmentExpression_compound() {
     AssignmentExpression expression = ParserTestCase.parseExpression("x = y = 0", []);
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftHandSide);
     EngineTestCase.assertInstanceOf((obj) => obj is AssignmentExpression, AssignmentExpression, expression.rightHandSide);
   }
 
   void test_assignmentExpression_indexExpression() {
     AssignmentExpression expression = ParserTestCase.parseExpression("x[1] = 0", []);
@@ skipping 92 matching lines @@
   }
 
   void test_constructor_initializer_withParenthesizedExpression() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
 class C {
   C() :
     this.a = (b == null ? c : d) {
   }
 }''', []);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
-    EngineTestCase.assertSizeOfList(1, declarations);
+    expect(declarations, hasLength(1));
   }
 
   void test_equalityExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x == y != z", [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_equalityExpression_precedence_relational_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("x is y == z", []);
     EngineTestCase.assertInstanceOf((obj) => obj is IsExpression, IsExpression, expression.leftOperand);
@@ skipping 34 matching lines @@
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_logicalOrExpression_precedence_logicalAnd_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("x || y && z", []);
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_multipleLabels_statement() {
     LabeledStatement statement = ParserTestCase.parseStatement("a: b: c: return x;", []);
-    EngineTestCase.assertSizeOfList(3, statement.labels);
+    expect(statement.labels, hasLength(3));
     EngineTestCase.assertInstanceOf((obj) => obj is ReturnStatement, ReturnStatement, statement.statement);
   }
 
   void test_multiplicativeExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x * y / z", []);
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_multiplicativeExpression_precedence_unary_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("-x * y", []);
@@ skipping 985 matching lines @@
   }
 
   void test_optionalAfterNormalParameters_positional() {
     ParserTestCase.parseCompilationUnit("f([a], b) {}", [ParserErrorCode.NORMAL_BEFORE_OPTIONAL_PARAMETERS]);
   }
 
   void test_parseCascadeSection_missingIdentifier() {
     MethodInvocation methodInvocation = ParserTestCase.parse4("parseCascadeSection", "..()", [ParserErrorCode.MISSING_IDENTIFIER]);
     expect(methodInvocation.target, isNull);
     expect(methodInvocation.methodName.name, "");
-    EngineTestCase.assertSizeOfList(0, methodInvocation.argumentList.arguments);
+    expect(methodInvocation.argumentList.arguments, hasLength(0));
   }
 
   void test_positionalAfterNamedArgument() {
     ParserTestCase.parse4("parseArgumentList", "(x: 1, 2)", [ParserErrorCode.POSITIONAL_AFTER_NAMED_ARGUMENT]);
   }
 
   void test_positionalParameterOutsideGroup() {
     ParserTestCase.parse4("parseFormalParameterList", "(a, b = 0)", [ParserErrorCode.POSITIONAL_PARAMETER_OUTSIDE_GROUP]);
   }
 
@@ skipping 651 matching lines @@
    *           the expected count, if the compilation errors in the source do not match those that
    *           are expected, or if the result would have been `null`
    */
   static List<Statement> parseStatements(String source, int expectedCount, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scanner scanner = new Scanner(null, new CharSequenceReader(source), listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = createParser(listener);
     List<Statement> statements = parser.parseStatements(token);
-    EngineTestCase.assertSizeOfList(expectedCount, statements);
+    expect(statements, hasLength(expectedCount));
     listener.assertErrorsWithCodes(errorCodes);
     return statements;
   }
 
   /**
    * Invoke a method in [Parser]. The method is assumed to have the given number and type of
    * parameters and will be invoked with the given arguments.
    *
    * The given source is scanned and the parser is initialized to start with the first token in the
    * source before the method is invoked.
@@ skipping 395 matching lines @@
   void test_equalityExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super ==  ==", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_expressionList_multiple_end() {
     List<Expression> result = ParserTestCase.parse4("parseExpressionList", ", 2, 3, 4", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertSizeOfList(4, result);
+    expect(result, hasLength(4));
     Expression syntheticExpression = result[0];
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, syntheticExpression);
     expect(syntheticExpression.isSynthetic, isTrue);
   }
 
   void test_expressionList_multiple_middle() {
     List<Expression> result = ParserTestCase.parse4("parseExpressionList", "1, 2, , 4", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertSizeOfList(4, result);
+    expect(result, hasLength(4));
     Expression syntheticExpression = result[2];
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, syntheticExpression);
     expect(syntheticExpression.isSynthetic, isTrue);
   }
 
   void test_expressionList_multiple_start() {
     List<Expression> result = ParserTestCase.parse4("parseExpressionList", "1, 2, 3,", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertSizeOfList(4, result);
+    expect(result, hasLength(4));
     Expression syntheticExpression = result[3];
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, syntheticExpression);
     expect(syntheticExpression.isSynthetic, isTrue);
   }
 
   void test_functionExpression_in_ConstructorFieldInitializer() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("class A { A() : a = (){}; var v; }", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.UNEXPECTED_TOKEN]);
     // Make sure we recovered and parsed "var v" correctly
     ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
     NodeList<ClassMember> members = declaration.members;
     ClassMember fieldDecl = members[1];
     EngineTestCase.assertInstanceOf((obj) => obj is FieldDeclaration, FieldDeclaration, fieldDecl);
     NodeList<VariableDeclaration> vars = (fieldDecl as FieldDeclaration).fields.variables;
-    EngineTestCase.assertSizeOfList(1, vars);
+    expect(vars, hasLength(1));
     expect(vars[0].name.name, "v");
   }
 
   void test_incomplete_topLevelVariable() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("String", [ParserErrorCode.EXPECTED_EXECUTABLE]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
-    EngineTestCase.assertSizeOfList(1, declarations);
+    expect(declarations, hasLength(1));
     CompilationUnitMember member = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration, TopLevelVariableDeclaration, member);
     NodeList<VariableDeclaration> variables = (member as TopLevelVariableDeclaration).variables.variables;
-    EngineTestCase.assertSizeOfList(1, variables);
+    expect(variables, hasLength(1));
     SimpleIdentifier name = variables[0].name;
     expect(name.isSynthetic, isTrue);
   }
 
   void test_incomplete_topLevelVariable_const() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("const ", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.EXPECTED_TOKEN]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
-    EngineTestCase.assertSizeOfList(1, declarations);
+    expect(declarations, hasLength(1));
     CompilationUnitMember member = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration, TopLevelVariableDeclaration, member);
     NodeList<VariableDeclaration> variables = (member as TopLevelVariableDeclaration).variables.variables;
-    EngineTestCase.assertSizeOfList(1, variables);
+    expect(variables, hasLength(1));
     SimpleIdentifier name = variables[0].name;
     expect(name.isSynthetic, isTrue);
   }
 
   void test_incomplete_topLevelVariable_final() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("final ", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.EXPECTED_TOKEN]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
-    EngineTestCase.assertSizeOfList(1, declarations);
+    expect(declarations, hasLength(1));
     CompilationUnitMember member = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration, TopLevelVariableDeclaration, member);
     NodeList<VariableDeclaration> variables = (member as TopLevelVariableDeclaration).variables.variables;
-    EngineTestCase.assertSizeOfList(1, variables);
+    expect(variables, hasLength(1));
     SimpleIdentifier name = variables[0].name;
     expect(name.isSynthetic, isTrue);
   }
 
   void test_incomplete_topLevelVariable_var() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("var ", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.EXPECTED_TOKEN]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
-    EngineTestCase.assertSizeOfList(1, declarations);
+    expect(declarations, hasLength(1));
     CompilationUnitMember member = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration, TopLevelVariableDeclaration, member);
     NodeList<VariableDeclaration> variables = (member as TopLevelVariableDeclaration).variables.variables;
-    EngineTestCase.assertSizeOfList(1, variables);
+    expect(variables, hasLength(1));
     SimpleIdentifier name = variables[0].name;
     expect(name.isSynthetic, isTrue);
   }
 
   void test_incompleteField_const() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
 class C {
   const
 }''', [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.EXPECTED_TOKEN]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
-    EngineTestCase.assertSizeOfList(1, declarations);
+    expect(declarations, hasLength(1));
     CompilationUnitMember unitMember = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
-    EngineTestCase.assertSizeOfList(1, members);
+    expect(members, hasLength(1));
     ClassMember classMember = members[0];
     EngineTestCase.assertInstanceOf((obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
     VariableDeclarationList fieldList = (classMember as FieldDeclaration).fields;
     expect((fieldList.keyword as KeywordToken).keyword, Keyword.CONST);
     NodeList<VariableDeclaration> fields = fieldList.variables;
-    EngineTestCase.assertSizeOfList(1, fields);
+    expect(fields, hasLength(1));
     VariableDeclaration field = fields[0];
     expect(field.name.isSynthetic, isTrue);
   }
 
   void test_incompleteField_final() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
 class C {
   final
 }''', [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.EXPECTED_TOKEN]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
-    EngineTestCase.assertSizeOfList(1, declarations);
+    expect(declarations, hasLength(1));
     CompilationUnitMember unitMember = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
-    EngineTestCase.assertSizeOfList(1, members);
+    expect(members, hasLength(1));
     ClassMember classMember = members[0];
     EngineTestCase.assertInstanceOf((obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
     VariableDeclarationList fieldList = (classMember as FieldDeclaration).fields;
     expect((fieldList.keyword as KeywordToken).keyword, Keyword.FINAL);
     NodeList<VariableDeclaration> fields = fieldList.variables;
-    EngineTestCase.assertSizeOfList(1, fields);
+    expect(fields, hasLength(1));
     VariableDeclaration field = fields[0];
     expect(field.name.isSynthetic, isTrue);
   }
 
   void test_incompleteField_var() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
 class C {
   var
 }''', [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.EXPECTED_TOKEN]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
-    EngineTestCase.assertSizeOfList(1, declarations);
+    expect(declarations, hasLength(1));
     CompilationUnitMember unitMember = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
-    EngineTestCase.assertSizeOfList(1, members);
+    expect(members, hasLength(1));
     ClassMember classMember = members[0];
     EngineTestCase.assertInstanceOf((obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
     VariableDeclarationList fieldList = (classMember as FieldDeclaration).fields;
     expect((fieldList.keyword as KeywordToken).keyword, Keyword.VAR);
     NodeList<VariableDeclaration> fields = fieldList.variables;
-    EngineTestCase.assertSizeOfList(1, fields);
+    expect(fields, hasLength(1));
     VariableDeclaration field = fields[0];
     expect(field.name.isSynthetic, isTrue);
   }
 
   void test_isExpression_noType() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("class Bar<T extends Foo> {m(x){if (x is ) return;if (x is !)}}", [
         ParserErrorCode.EXPECTED_TYPE_NAME,
         ParserErrorCode.EXPECTED_TYPE_NAME,
         ParserErrorCode.MISSING_STATEMENT]);
     ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
@@ skipping 88 matching lines @@
 
   void test_missingGet() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
 class C {
   int length {}
   void foo() {}
 }''', [ParserErrorCode.MISSING_GET]);
     expect(unit, isNotNull);
     ClassDeclaration classDeclaration = unit.declarations[0] as ClassDeclaration;
     NodeList<ClassMember> members = classDeclaration.members;
-    EngineTestCase.assertSizeOfList(2, members);
+    expect(members, hasLength(2));
     EngineTestCase.assertInstanceOf((obj) => obj is MethodDeclaration, MethodDeclaration, members[0]);
     ClassMember member = members[1];
     EngineTestCase.assertInstanceOf((obj) => obj is MethodDeclaration, MethodDeclaration, member);
     expect((member as MethodDeclaration).name.name, "foo");
   }
 
   void test_missingIdentifier_afterAnnotation() {
     MethodDeclaration method = ParserTestCase.parse3("parseClassMember", <Object> ["C"], "@override }", [ParserErrorCode.EXPECTED_CLASS_MEMBER]);
     expect(method.documentationComment, isNull);
     NodeList<Annotation> metadata = method.metadata;
-    EngineTestCase.assertSizeOfList(1, metadata);
+    expect(metadata, hasLength(1));
     expect(metadata[0].name.name, "override");
   }
 
   void test_multiplicativeExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("* y", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     expect(expression.leftOperand.isSynthetic, isTrue);
   }
 
   void test_multiplicativeExpression_missing_LHS_RHS() {
@@ skipping 127 matching lines @@
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_typedef_eof() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("typedef n", [
         ParserErrorCode.EXPECTED_TOKEN,
         ParserErrorCode.MISSING_TYPEDEF_PARAMETERS]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
-    EngineTestCase.assertSizeOfList(1, declarations);
+    expect(declarations, hasLength(1));
     CompilationUnitMember member = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionTypeAlias, FunctionTypeAlias, member);
   }
 }
 
 class ResolutionCopierTest extends EngineTestCase {
   void test_visitAnnotation() {
     String annotationName = "proxy";
     Annotation fromNode = AstFactory.annotation(AstFactory.identifier3(annotationName));
     Element element = ElementFactory.topLevelVariableElement2(annotationName);
@@ skipping 917 matching lines @@
 
   void test_parseArgument_unnamed() {
     String lexeme = "x";
     SimpleIdentifier identifier = ParserTestCase.parse4("parseArgument", lexeme, []);
     expect(identifier.name, lexeme);
   }
 
   void test_parseArgumentList_empty() {
     ArgumentList argumentList = ParserTestCase.parse4("parseArgumentList", "()", []);
     NodeList<Expression> arguments = argumentList.arguments;
-    EngineTestCase.assertSizeOfList(0, arguments);
+    expect(arguments, hasLength(0));
   }
 
   void test_parseArgumentList_mixed() {
     ArgumentList argumentList = ParserTestCase.parse4("parseArgumentList", "(w, x, y: y, z: z)", []);
     NodeList<Expression> arguments = argumentList.arguments;
-    EngineTestCase.assertSizeOfList(4, arguments);
+    expect(arguments, hasLength(4));
   }
 
   void test_parseArgumentList_noNamed() {
     ArgumentList argumentList = ParserTestCase.parse4("parseArgumentList", "(x, y, z)", []);
     NodeList<Expression> arguments = argumentList.arguments;
-    EngineTestCase.assertSizeOfList(3, arguments);
+    expect(arguments, hasLength(3));
   }
 
   void test_parseArgumentList_onlyNamed() {
     ArgumentList argumentList = ParserTestCase.parse4("parseArgumentList", "(x: x, y: y)", []);
     NodeList<Expression> arguments = argumentList.arguments;
-    EngineTestCase.assertSizeOfList(2, arguments);
+    expect(arguments, hasLength(2));
   }
 
   void test_parseAssertStatement() {
     AssertStatement statement = ParserTestCase.parse4("parseAssertStatement", "assert (x);", []);
     expect(statement.keyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.condition, isNotNull);
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.semicolon, isNotNull);
   }
 
   void test_parseAssignableExpression_expression_args_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "(x)(y).z");
     FunctionExpressionInvocation invocation = propertyAccess.target as FunctionExpressionInvocation;
     expect(invocation.function, isNotNull);
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
-    EngineTestCase.assertSizeOfList(1, argumentList.arguments);
+    expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_expression_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "(x).y");
     expect(propertyAccess.target, isNotNull);
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
@@ skipping 10 matching lines @@
     SimpleIdentifier identifier = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "x");
     expect(identifier, isNotNull);
   }
 
   void test_parseAssignableExpression_identifier_args_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "x(y).z");
     MethodInvocation invocation = propertyAccess.target as MethodInvocation;
     expect(invocation.methodName.name, "x");
     ArgumentList argumentList = invocation.argumentList;
     expect(argumentList, isNotNull);
-    EngineTestCase.assertSizeOfList(1, argumentList.arguments);
+    expect(argumentList.arguments, hasLength(1));
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parseAssignableExpression_identifier_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "x.y");
     expect(propertyAccess.target, isNotNull);
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.propertyName, isNotNull);
   }
@@ skipping 121 matching lines @@
     BinaryExpression expression = ParserTestCase.parse4("parseBitwiseXorExpression", "super ^ y", []);
     EngineTestCase.assertInstanceOf((obj) => obj is SuperExpression, SuperExpression, expression.leftOperand);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.CARET);
     expect(expression.rightOperand, isNotNull);
   }
 
   void test_parseBlock_empty() {
     Block block = ParserTestCase.parse4("parseBlock", "{}", []);
     expect(block.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(0, block.statements);
+    expect(block.statements, hasLength(0));
     expect(block.rightBracket, isNotNull);
   }
 
   void test_parseBlock_nonEmpty() {
     Block block = ParserTestCase.parse4("parseBlock", "{;}", []);
     expect(block.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, block.statements);
+    expect(block.statements, hasLength(1));
     expect(block.rightBracket, isNotNull);
   }
 
   void test_parseBreakStatement_label() {
     BreakStatement statement = ParserTestCase.parse4("parseBreakStatement", "break foo;", []);
     expect(statement.keyword, isNotNull);
     expect(statement.label, isNotNull);
     expect(statement.semicolon, isNotNull);
   }
 
@@ skipping 17 matching lines @@
     EngineTestCase.assertInstanceOf((obj) => obj is IndexExpression, IndexExpression, section.function);
     expect(section.argumentList, isNotNull);
   }
 
   void test_parseCascadeSection_ii() {
     MethodInvocation section = ParserTestCase.parse4("parseCascadeSection", "..a(b).c(d)", []);
     EngineTestCase.assertInstanceOf((obj) => obj is MethodInvocation, MethodInvocation, section.target);
     expect(section.period, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.argumentList, isNotNull);
-    EngineTestCase.assertSizeOfList(1, section.argumentList.arguments);
+    expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_p() {
     PropertyAccess section = ParserTestCase.parse4("parseCascadeSection", "..a", []);
     expect(section.target, isNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   void test_parseCascadeSection_p_assign() {
@@ skipping 18 matching lines @@
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   void test_parseCascadeSection_pa() {
     MethodInvocation section = ParserTestCase.parse4("parseCascadeSection", "..a(b)", []);
     expect(section.target, isNull);
     expect(section.period, isNotNull);
     expect(section.methodName, isNotNull);
     expect(section.argumentList, isNotNull);
-    EngineTestCase.assertSizeOfList(1, section.argumentList.arguments);
+    expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_paa() {
     FunctionExpressionInvocation section = ParserTestCase.parse4("parseCascadeSection", "..a(b)(c)", []);
     EngineTestCase.assertInstanceOf((obj) => obj is MethodInvocation, MethodInvocation, section.function);
     expect(section.argumentList, isNotNull);
-    EngineTestCase.assertSizeOfList(1, section.argumentList.arguments);
+    expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_paapaa() {
     FunctionExpressionInvocation section = ParserTestCase.parse4("parseCascadeSection", "..a(b)(c).d(e)(f)", []);
     EngineTestCase.assertInstanceOf((obj) => obj is MethodInvocation, MethodInvocation, section.function);
     expect(section.argumentList, isNotNull);
-    EngineTestCase.assertSizeOfList(1, section.argumentList.arguments);
+    expect(section.argumentList.arguments, hasLength(1));
   }
 
   void test_parseCascadeSection_pap() {
     PropertyAccess section = ParserTestCase.parse4("parseCascadeSection", "..a(b).c", []);
     expect(section.target, isNotNull);
     expect(section.operator, isNotNull);
     expect(section.propertyName, isNotNull);
   }
 
   void test_parseClassDeclaration_abstract() {
     ClassDeclaration declaration = ParserTestCase.parse("parseClassDeclaration", <Object> [
         emptyCommentAndMetadata(),
         TokenFactory.tokenFromKeyword(Keyword.ABSTRACT)], "class A {}");
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNotNull);
     expect(declaration.extendsClause, isNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
-    EngineTestCase.assertSizeOfList(0, declaration.members);
+    expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNull);
   }
 
   void test_parseClassDeclaration_empty() {
     ClassDeclaration declaration = ParserTestCase.parse("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class A {}");
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.extendsClause, isNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
-    EngineTestCase.assertSizeOfList(0, declaration.members);
+    expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNull);
   }
 
   void test_parseClassDeclaration_extends() {
     ClassDeclaration declaration = ParserTestCase.parse("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class A extends B {}");
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.extendsClause, isNotNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
-    EngineTestCase.assertSizeOfList(0, declaration.members);
+    expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNull);
   }
 
   void test_parseClassDeclaration_extendsAndImplements() {
     ClassDeclaration declaration = ParserTestCase.parse("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class A extends B implements C {}");
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.extendsClause, isNotNull);
     expect(declaration.implementsClause, isNotNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
-    EngineTestCase.assertSizeOfList(0, declaration.members);
+    expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNull);
   }
 
   void test_parseClassDeclaration_extendsAndWith() {
     ClassDeclaration declaration = ParserTestCase.parse("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class A extends B with C {}");
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.typeParameters, isNull);
     expect(declaration.extendsClause, isNotNull);
     expect(declaration.withClause, isNotNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(0, declaration.members);
+    expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
   }
 
   void test_parseClassDeclaration_extendsAndWithAndImplements() {
     ClassDeclaration declaration = ParserTestCase.parse("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class A extends B with C implements D {}");
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.typeParameters, isNull);
     expect(declaration.extendsClause, isNotNull);
     expect(declaration.withClause, isNotNull);
     expect(declaration.implementsClause, isNotNull);
     expect(declaration.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(0, declaration.members);
+    expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
   }
 
   void test_parseClassDeclaration_implements() {
     ClassDeclaration declaration = ParserTestCase.parse("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class A implements C {}");
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.extendsClause, isNull);
     expect(declaration.implementsClause, isNotNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
-    EngineTestCase.assertSizeOfList(0, declaration.members);
+    expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNull);
   }
 
   void test_parseClassDeclaration_native() {
     ClassDeclaration declaration = ParserTestCase.parse("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class A native 'nativeValue' {}");
     NativeClause nativeClause = declaration.nativeClause;
     expect(nativeClause, isNotNull);
     expect(nativeClause.keyword, isNotNull);
     expect(nativeClause.name.stringValue, "nativeValue");
     expect(nativeClause.beginToken, same(nativeClause.keyword));
     expect(nativeClause.endToken, same(nativeClause.name.endToken));
   }
 
   void test_parseClassDeclaration_nonEmpty() {
     ClassDeclaration declaration = ParserTestCase.parse("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class A {var f;}");
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.extendsClause, isNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
-    EngineTestCase.assertSizeOfList(1, declaration.members);
+    expect(declaration.members, hasLength(1));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNull);
   }
 
   void test_parseClassDeclaration_typeAlias_implementsC() {
     ClassTypeAlias typeAlias = ParserTestCase.parse("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class A = Object with B implements C;");
     expect(typeAlias.keyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.withClause, isNotNull);
@@ skipping 17 matching lines @@
 
   void test_parseClassDeclaration_typeParameters() {
     ClassDeclaration declaration = ParserTestCase.parse("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class A<B> {}");
     expect(declaration.documentationComment, isNull);
     expect(declaration.abstractKeyword, isNull);
     expect(declaration.extendsClause, isNull);
     expect(declaration.implementsClause, isNull);
     expect(declaration.classKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
-    EngineTestCase.assertSizeOfList(0, declaration.members);
+    expect(declaration.members, hasLength(0));
     expect(declaration.rightBracket, isNotNull);
     expect(declaration.typeParameters, isNotNull);
-    EngineTestCase.assertSizeOfList(1, declaration.typeParameters.typeParameters);
+    expect(declaration.typeParameters.typeParameters, hasLength(1));
   }
 
   void test_parseClassMember_constructor_withInitializers() {
     // TODO(brianwilkerson) Test other kinds of class members: fields, getters and setters.
     ConstructorDeclaration constructor = ParserTestCase.parse("parseClassMember", <Object> ["C"], "C(_, _\$, this.__) : _a = _ + _\$ {}");
     expect(constructor.body, isNotNull);
     expect(constructor.separator, isNotNull);
     expect(constructor.externalKeyword, isNull);
     expect(constructor.constKeyword, isNull);
     expect(constructor.factoryKeyword, isNull);
     expect(constructor.name, isNull);
     expect(constructor.parameters, isNotNull);
     expect(constructor.period, isNull);
     expect(constructor.returnType, isNotNull);
-    EngineTestCase.assertSizeOfList(1, constructor.initializers);
+    expect(constructor.initializers, hasLength(1));
   }
 
   void test_parseClassMember_field_instance_prefixedType() {
     FieldDeclaration field = ParserTestCase.parse("parseClassMember", <Object> ["C"], "p.A f;");
     expect(field.documentationComment, isNull);
-    EngineTestCase.assertSizeOfList(0, field.metadata);
+    expect(field.metadata, hasLength(0));
     expect(field.staticKeyword, isNull);
     VariableDeclarationList list = field.fields;
     expect(list, isNotNull);
     NodeList<VariableDeclaration> variables = list.variables;
-    EngineTestCase.assertSizeOfList(1, variables);
+    expect(variables, hasLength(1));
     VariableDeclaration variable = variables[0];
     expect(variable.name, isNotNull);
   }
 
   void test_parseClassMember_field_namedGet() {
     FieldDeclaration field = ParserTestCase.parse("parseClassMember", <Object> ["C"], "var get;");
     expect(field.documentationComment, isNull);
-    EngineTestCase.assertSizeOfList(0, field.metadata);
+    expect(field.metadata, hasLength(0));
     expect(field.staticKeyword, isNull);
     VariableDeclarationList list = field.fields;
     expect(list, isNotNull);
     NodeList<VariableDeclaration> variables = list.variables;
-    EngineTestCase.assertSizeOfList(1, variables);
+    expect(variables, hasLength(1));
     VariableDeclaration variable = variables[0];
     expect(variable.name, isNotNull);
   }
 
   void test_parseClassMember_field_namedOperator() {
     FieldDeclaration field = ParserTestCase.parse("parseClassMember", <Object> ["C"], "var operator;");
     expect(field.documentationComment, isNull);
-    EngineTestCase.assertSizeOfList(0, field.metadata);
+    expect(field.metadata, hasLength(0));
     expect(field.staticKeyword, isNull);
     VariableDeclarationList list = field.fields;
     expect(list, isNotNull);
     NodeList<VariableDeclaration> variables = list.variables;
-    EngineTestCase.assertSizeOfList(1, variables);
+    expect(variables, hasLength(1));
     VariableDeclaration variable = variables[0];
     expect(variable.name, isNotNull);
   }
 
   void test_parseClassMember_field_namedOperator_withAssignment() {
     FieldDeclaration field = ParserTestCase.parse("parseClassMember", <Object> ["C"], "var operator = (5);");
     expect(field.documentationComment, isNull);
-    EngineTestCase.assertSizeOfList(0, field.metadata);
+    expect(field.metadata, hasLength(0));
     expect(field.staticKeyword, isNull);
     VariableDeclarationList list = field.fields;
     expect(list, isNotNull);
     NodeList<VariableDeclaration> variables = list.variables;
-    EngineTestCase.assertSizeOfList(1, variables);
+    expect(variables, hasLength(1));
     VariableDeclaration variable = variables[0];
     expect(variable.name, isNotNull);
     expect(variable.initializer, isNotNull);
   }
 
   void test_parseClassMember_field_namedSet() {
     FieldDeclaration field = ParserTestCase.parse("parseClassMember", <Object> ["C"], "var set;");
     expect(field.documentationComment, isNull);
-    EngineTestCase.assertSizeOfList(0, field.metadata);
+    expect(field.metadata, hasLength(0));
     expect(field.staticKeyword, isNull);
     VariableDeclarationList list = field.fields;
     expect(list, isNotNull);
     NodeList<VariableDeclaration> variables = list.variables;
-    EngineTestCase.assertSizeOfList(1, variables);
+    expect(variables, hasLength(1));
     VariableDeclaration variable = variables[0];
     expect(variable.name, isNotNull);
   }
 
   void test_parseClassMember_getter_void() {
     MethodDeclaration method = ParserTestCase.parse("parseClassMember", <Object> ["C"], "void get g {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNotNull);
@@ skipping 188 matching lines @@
   void test_parseClassMember_redirectingFactory_const() {
     ConstructorDeclaration constructor = ParserTestCase.parse("parseClassMember", <Object> ["C"], "const factory C() = B;");
     expect(constructor.externalKeyword, isNull);
     expect(constructor.constKeyword, isNotNull);
     expect(constructor.factoryKeyword, isNotNull);
     expect(constructor.returnType, isNotNull);
     expect(constructor.period, isNull);
     expect(constructor.name, isNull);
     expect(constructor.parameters, isNotNull);
     expect(constructor.separator, isNotNull);
-    EngineTestCase.assertSizeOfList(0, constructor.initializers);
+    expect(constructor.initializers, hasLength(0));
     expect(constructor.redirectedConstructor, isNotNull);
     expect(constructor.body, isNotNull);
   }
 
   void test_parseClassMember_redirectingFactory_nonConst() {
     ConstructorDeclaration constructor = ParserTestCase.parse("parseClassMember", <Object> ["C"], "factory C() = B;");
     expect(constructor.externalKeyword, isNull);
     expect(constructor.constKeyword, isNull);
     expect(constructor.factoryKeyword, isNotNull);
     expect(constructor.returnType, isNotNull);
     expect(constructor.period, isNull);
     expect(constructor.name, isNull);
     expect(constructor.parameters, isNotNull);
     expect(constructor.separator, isNotNull);
-    EngineTestCase.assertSizeOfList(0, constructor.initializers);
+    expect(constructor.initializers, hasLength(0));
     expect(constructor.redirectedConstructor, isNotNull);
     expect(constructor.body, isNotNull);
   }
 
   void test_parseClassTypeAlias_abstract() {
     Token classToken = TokenFactory.tokenFromKeyword(Keyword.CLASS);
     Token abstractToken = TokenFactory.tokenFromKeyword(Keyword.ABSTRACT);
     ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), abstractToken, classToken], "A = B with C;");
     expect(classTypeAlias.keyword, isNotNull);
     expect(classTypeAlias.name.name, "A");
@@ skipping 39 matching lines @@
     expect(classTypeAlias.equals, isNotNull);
     expect(classTypeAlias.abstractKeyword, isNull);
     expect(classTypeAlias.superclass.name.name, isNotNull, reason: "B");
     expect(classTypeAlias.withClause, isNotNull);
     expect(classTypeAlias.implementsClause, isNotNull);
     expect(classTypeAlias.semicolon, isNotNull);
   }
 
   void test_parseCombinators_h() {
     List<Combinator> combinators = ParserTestCase.parse4("parseCombinators", "hide a;", []);
-    EngineTestCase.assertSizeOfList(1, combinators);
+    expect(combinators, hasLength(1));
     HideCombinator combinator = combinators[0] as HideCombinator;
     expect(combinator, isNotNull);
     expect(combinator.keyword, isNotNull);
-    EngineTestCase.assertSizeOfList(1, combinator.hiddenNames);
+    expect(combinator.hiddenNames, hasLength(1));
   }
 
   void test_parseCombinators_hs() {
     List<Combinator> combinators = ParserTestCase.parse4("parseCombinators", "hide a show b;", []);
-    EngineTestCase.assertSizeOfList(2, combinators);
+    expect(combinators, hasLength(2));
     HideCombinator hideCombinator = combinators[0] as HideCombinator;
     expect(hideCombinator, isNotNull);
     expect(hideCombinator.keyword, isNotNull);
-    EngineTestCase.assertSizeOfList(1, hideCombinator.hiddenNames);
+    expect(hideCombinator.hiddenNames, hasLength(1));
     ShowCombinator showCombinator = combinators[1] as ShowCombinator;
     expect(showCombinator, isNotNull);
     expect(showCombinator.keyword, isNotNull);
-    EngineTestCase.assertSizeOfList(1, showCombinator.shownNames);
+    expect(showCombinator.shownNames, hasLength(1));
   }
 
   void test_parseCombinators_hshs() {
     List<Combinator> combinators = ParserTestCase.parse4("parseCombinators", "hide a show b hide c show d;", []);
-    EngineTestCase.assertSizeOfList(4, combinators);
+    expect(combinators, hasLength(4));
   }
 
   void test_parseCombinators_s() {
     List<Combinator> combinators = ParserTestCase.parse4("parseCombinators", "show a;", []);
-    EngineTestCase.assertSizeOfList(1, combinators);
+    expect(combinators, hasLength(1));
     ShowCombinator combinator = combinators[0] as ShowCombinator;
     expect(combinator, isNotNull);
     expect(combinator.keyword, isNotNull);
-    EngineTestCase.assertSizeOfList(1, combinator.shownNames);
+    expect(combinator.shownNames, hasLength(1));
   }
 
   void test_parseCommentAndMetadata_c() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse4("parseCommentAndMetadata", "/** 1 */ void", []);
     expect(commentAndMetadata.comment, isNotNull);
-    EngineTestCase.assertSizeOfList(0, commentAndMetadata.metadata);
+    expect(commentAndMetadata.metadata, hasLength(0));
   }
 
   void test_parseCommentAndMetadata_cmc() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse4("parseCommentAndMetadata", "/** 1 */ @A /** 2 */ void", []);
     expect(commentAndMetadata.comment, isNotNull);
-    EngineTestCase.assertSizeOfList(1, commentAndMetadata.metadata);
+    expect(commentAndMetadata.metadata, hasLength(1));
   }
 
   void test_parseCommentAndMetadata_cmcm() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse4("parseCommentAndMetadata", "/** 1 */ @A /** 2 */ @B void", []);
     expect(commentAndMetadata.comment, isNotNull);
-    EngineTestCase.assertSizeOfList(2, commentAndMetadata.metadata);
+    expect(commentAndMetadata.metadata, hasLength(2));
   }
 
   void test_parseCommentAndMetadata_cmm() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse4("parseCommentAndMetadata", "/** 1 */ @A @B void", []);
     expect(commentAndMetadata.comment, isNotNull);
-    EngineTestCase.assertSizeOfList(2, commentAndMetadata.metadata);
+    expect(commentAndMetadata.metadata, hasLength(2));
   }
 
   void test_parseCommentAndMetadata_m() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse4("parseCommentAndMetadata", "@A void", []);
     expect(commentAndMetadata.comment, isNull);
-    EngineTestCase.assertSizeOfList(1, commentAndMetadata.metadata);
+    expect(commentAndMetadata.metadata, hasLength(1));
   }
 
   void test_parseCommentAndMetadata_mcm() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse4("parseCommentAndMetadata", "@A /** 1 */ @B void", []);
     expect(commentAndMetadata.comment, isNotNull);
-    EngineTestCase.assertSizeOfList(2, commentAndMetadata.metadata);
+    expect(commentAndMetadata.metadata, hasLength(2));
   }
 
   void test_parseCommentAndMetadata_mcmc() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse4("parseCommentAndMetadata", "@A /** 1 */ @B /** 2 */ void", []);
     expect(commentAndMetadata.comment, isNotNull);
-    EngineTestCase.assertSizeOfList(2, commentAndMetadata.metadata);
+    expect(commentAndMetadata.metadata, hasLength(2));
   }
 
   void test_parseCommentAndMetadata_mm() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse4("parseCommentAndMetadata", "@A @B(x) void", []);
     expect(commentAndMetadata.comment, isNull);
-    EngineTestCase.assertSizeOfList(2, commentAndMetadata.metadata);
+    expect(commentAndMetadata.metadata, hasLength(2));
   }
 
   void test_parseCommentAndMetadata_none() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse4("parseCommentAndMetadata", "void", []);
     expect(commentAndMetadata.comment, isNull);
-    EngineTestCase.assertSizeOfList(0, commentAndMetadata.metadata);
+    expect(commentAndMetadata.metadata, hasLength(0));
   }
 
   void test_parseCommentAndMetadata_singleLine() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse4("parseCommentAndMetadata", r'''
 /// 1
 /// 2
 void''', []);
     expect(commentAndMetadata.comment, isNotNull);
-    EngineTestCase.assertSizeOfList(0, commentAndMetadata.metadata);
+    expect(commentAndMetadata.metadata, hasLength(0));
   }
 
   void test_parseCommentReference_new_prefixed() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["new a.b", 7], "");
     PrefixedIdentifier prefixedIdentifier = EngineTestCase.assertInstanceOf((obj) => obj is PrefixedIdentifier, PrefixedIdentifier, reference.identifier);
     SimpleIdentifier prefix = prefixedIdentifier.prefix;
     expect(prefix.token, isNotNull);
     expect(prefix.name, "a");
     expect(prefix.offset, 11);
     expect(prefixedIdentifier.period, isNotNull);
@@ skipping 39 matching lines @@
     expect(identifier, isNotNull);
     expect(identifier.isSynthetic, isTrue);
     expect(identifier.token, isNotNull);
     expect(identifier.name, "");
     expect(identifier.offset, 5);
   }
 
   void test_parseCommentReferences_multiLine() {
     List<Token> tokens = <Token> [new StringToken(TokenType.MULTI_LINE_COMMENT, "/** xxx [a] yyy [b] zzz */", 3)];
     List<CommentReference> references = ParserTestCase.parse("parseCommentReferences", <Object> [tokens], "");
-    EngineTestCase.assertSizeOfList(2, references);
+    expect(references, hasLength(2));
     CommentReference reference = references[0];
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.offset, 12);
     reference = references[1];
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.offset, 20);
   }
 
   void test_parseCommentReferences_notClosed_noIdentifier() {
     List<Token> tokens = <Token> [new StringToken(TokenType.MULTI_LINE_COMMENT, "/** [ some text", 5)];
     List<CommentReference> references = ParserTestCase.parse("parseCommentReferences", <Object> [tokens], "");
-    EngineTestCase.assertSizeOfList(1, references);
+    expect(references, hasLength(1));
     CommentReference reference = references[0];
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.identifier.isSynthetic, isTrue);
     expect(reference.identifier.name, "");
   }
 
   void test_parseCommentReferences_notClosed_withIdentifier() {
     List<Token> tokens = <Token> [new StringToken(TokenType.MULTI_LINE_COMMENT, "/** [namePrefix some text", 5)];
     List<CommentReference> references = ParserTestCase.parse("parseCommentReferences", <Object> [tokens], "");
-    EngineTestCase.assertSizeOfList(1, references);
+    expect(references, hasLength(1));
     CommentReference reference = references[0];
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.identifier.isSynthetic, isFalse);
     expect(reference.identifier.name, "namePrefix");
   }
 
   void test_parseCommentReferences_singleLine() {
     List<Token> tokens = <Token> [
         new StringToken(TokenType.SINGLE_LINE_COMMENT, "/// xxx [a] yyy [b] zzz", 3),
         new StringToken(TokenType.SINGLE_LINE_COMMENT, "/// x [c]", 28)];
     List<CommentReference> references = ParserTestCase.parse("parseCommentReferences", <Object> [tokens], "");
-    EngineTestCase.assertSizeOfList(3, references);
+    expect(references, hasLength(3));
     CommentReference reference = references[0];
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.offset, 12);
     reference = references[1];
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.offset, 20);
     reference = references[2];
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.offset, 35);
   }
 
   void test_parseCommentReferences_skipCodeBlock_bracketed() {
     List<Token> tokens = <Token> [new StringToken(TokenType.MULTI_LINE_COMMENT, "/** [:xxx [a] yyy:] [b] zzz */", 3)];
     List<CommentReference> references = ParserTestCase.parse("parseCommentReferences", <Object> [tokens], "");
-    EngineTestCase.assertSizeOfList(1, references);
+    expect(references, hasLength(1));
     CommentReference reference = references[0];
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.offset, 24);
   }
 
   void test_parseCommentReferences_skipCodeBlock_spaces() {
     List<Token> tokens = <Token> [new StringToken(TokenType.MULTI_LINE_COMMENT, "/**\n *     a[i]\n * xxx [i] zzz\n */", 3)];
     List<CommentReference> references = ParserTestCase.parse("parseCommentReferences", <Object> [tokens], "");
-    EngineTestCase.assertSizeOfList(1, references);
+    expect(references, hasLength(1));
     CommentReference reference = references[0];
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.offset, 27);
   }
 
   void test_parseCommentReferences_skipLinkDefinition() {
     List<Token> tokens = <Token> [new StringToken(TokenType.MULTI_LINE_COMMENT, "/** [a]: http://www.google.com (Google) [b] zzz */", 3)];
     List<CommentReference> references = ParserTestCase.parse("parseCommentReferences", <Object> [tokens], "");
-    EngineTestCase.assertSizeOfList(1, references);
+    expect(references, hasLength(1));
     CommentReference reference = references[0];
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.offset, 44);
   }
 
   void test_parseCommentReferences_skipLinked() {
     List<Token> tokens = <Token> [new StringToken(TokenType.MULTI_LINE_COMMENT, "/** [a](http://www.google.com) [b] zzz */", 3)];
     List<CommentReference> references = ParserTestCase.parse("parseCommentReferences", <Object> [tokens], "");
-    EngineTestCase.assertSizeOfList(1, references);
+    expect(references, hasLength(1));
     CommentReference reference = references[0];
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.offset, 35);
   }
 
   void test_parseCommentReferences_skipReferenceLink() {
     List<Token> tokens = <Token> [new StringToken(TokenType.MULTI_LINE_COMMENT, "/** [a][c] [b] zzz */", 3)];
     List<CommentReference> references = ParserTestCase.parse("parseCommentReferences", <Object> [tokens], "");
-    EngineTestCase.assertSizeOfList(1, references);
+    expect(references, hasLength(1));
     CommentReference reference = references[0];
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.offset, 15);
   }
 
   void test_parseCompilationUnit_abstractAsPrefix_parameterized() {
     CompilationUnit unit = ParserTestCase.parse4("parseCompilationUnit", "abstract<dynamic> _abstract = new abstract.A();", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(0, unit.directives);
-    EngineTestCase.assertSizeOfList(1, unit.declarations);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnit_builtIn_asFunctionName() {
     ParserTestCase.parse4("parseCompilationUnit", "abstract(x) => 0;", []);
     ParserTestCase.parse4("parseCompilationUnit", "as(x) => 0;", []);
     ParserTestCase.parse4("parseCompilationUnit", "dynamic(x) => 0;", []);
     ParserTestCase.parse4("parseCompilationUnit", "export(x) => 0;", []);
     ParserTestCase.parse4("parseCompilationUnit", "external(x) => 0;", []);
     ParserTestCase.parse4("parseCompilationUnit", "factory(x) => 0;", []);
     ParserTestCase.parse4("parseCompilationUnit", "get(x) => 0;", []);
     ParserTestCase.parse4("parseCompilationUnit", "implements(x) => 0;", []);
     ParserTestCase.parse4("parseCompilationUnit", "import(x) => 0;", []);
     ParserTestCase.parse4("parseCompilationUnit", "library(x) => 0;", []);
     ParserTestCase.parse4("parseCompilationUnit", "operator(x) => 0;", []);
     ParserTestCase.parse4("parseCompilationUnit", "part(x) => 0;", []);
     ParserTestCase.parse4("parseCompilationUnit", "set(x) => 0;", []);
     ParserTestCase.parse4("parseCompilationUnit", "static(x) => 0;", []);
     ParserTestCase.parse4("parseCompilationUnit", "typedef(x) => 0;", []);
   }
 
   void test_parseCompilationUnit_directives_multiple() {
     CompilationUnit unit = ParserTestCase.parse4("parseCompilationUnit", "library l;\npart 'a.dart';", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(2, unit.directives);
-    EngineTestCase.assertSizeOfList(0, unit.declarations);
+    expect(unit.directives, hasLength(2));
+    expect(unit.declarations, hasLength(0));
   }
 
   void test_parseCompilationUnit_directives_single() {
     CompilationUnit unit = ParserTestCase.parse4("parseCompilationUnit", "library l;", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(1, unit.directives);
-    EngineTestCase.assertSizeOfList(0, unit.declarations);
+    expect(unit.directives, hasLength(1));
+    expect(unit.declarations, hasLength(0));
   }
 
   void test_parseCompilationUnit_empty() {
     CompilationUnit unit = ParserTestCase.parse4("parseCompilationUnit", "", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(0, unit.directives);
-    EngineTestCase.assertSizeOfList(0, unit.declarations);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(0));
   }
 
   void test_parseCompilationUnit_exportAsPrefix() {
     CompilationUnit unit = ParserTestCase.parse4("parseCompilationUnit", "export.A _export = new export.A();", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(0, unit.directives);
-    EngineTestCase.assertSizeOfList(1, unit.declarations);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnit_exportAsPrefix_parameterized() {
     CompilationUnit unit = ParserTestCase.parse4("parseCompilationUnit", "export<dynamic> _export = new export.A();", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(0, unit.directives);
-    EngineTestCase.assertSizeOfList(1, unit.declarations);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnit_operatorAsPrefix_parameterized() {
     CompilationUnit unit = ParserTestCase.parse4("parseCompilationUnit", "operator<dynamic> _operator = new operator.A();", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(0, unit.directives);
-    EngineTestCase.assertSizeOfList(1, unit.declarations);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnit_script() {
     CompilationUnit unit = ParserTestCase.parse4("parseCompilationUnit", "#! /bin/dart", []);
     expect(unit.scriptTag, isNotNull);
-    EngineTestCase.assertSizeOfList(0, unit.directives);
-    EngineTestCase.assertSizeOfList(0, unit.declarations);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(0));
   }
 
   void test_parseCompilationUnit_skipFunctionBody_withInterpolation() {
     ParserTestCase.parseFunctionBodies = false;
     CompilationUnit unit = ParserTestCase.parse4("parseCompilationUnit", "f() { '\${n}'; }", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(1, unit.declarations);
+    expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnit_topLevelDeclaration() {
     CompilationUnit unit = ParserTestCase.parse4("parseCompilationUnit", "class A {}", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(0, unit.directives);
-    EngineTestCase.assertSizeOfList(1, unit.declarations);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnit_typedefAsPrefix() {
     CompilationUnit unit = ParserTestCase.parse4("parseCompilationUnit", "typedef.A _typedef = new typedef.A();", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(0, unit.directives);
-    EngineTestCase.assertSizeOfList(1, unit.declarations);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
   }
 
   void test_parseCompilationUnitMember_abstractAsPrefix() {
     TopLevelVariableDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "abstract.A _abstract = new abstract.A();");
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
   }
 
   void test_parseCompilationUnitMember_class() {
     ClassDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "class A {}");
     expect(declaration.name.name, "A");
-    EngineTestCase.assertSizeOfList(0, declaration.members);
+    expect(declaration.members, hasLength(0));
   }
 
   void test_parseCompilationUnitMember_classTypeAlias() {
     ClassTypeAlias alias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "abstract class A = B with C;");
     expect(alias.name.name, "A");
     expect(alias.abstractKeyword, isNotNull);
   }
 
   void test_parseCompilationUnitMember_constVariable() {
     TopLevelVariableDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "const int x = 0;");
@@ skipping 101 matching lines @@
     expect(typeAlias.superclass.name.name, "S");
     expect(typeAlias.withClause, isNotNull);
     expect(typeAlias.implementsClause, isNull);
     expect(typeAlias.semicolon, isNotNull);
   }
 
   void test_parseCompilationUnitMember_typeAlias_generic() {
     ClassTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "class C<E> = S<E> with M<E> implements I<E>;");
     expect(typeAlias.keyword, isNotNull);
     expect(typeAlias.name.name, "C");
-    EngineTestCase.assertSizeOfList(1, typeAlias.typeParameters.typeParameters);
+    expect(typeAlias.typeParameters.typeParameters, hasLength(1));
     expect(typeAlias.equals, isNotNull);
     expect(typeAlias.abstractKeyword, isNull);
     expect(typeAlias.superclass.name.name, "S");
     expect(typeAlias.withClause, isNotNull);
     expect(typeAlias.implementsClause, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
   }
 
   void test_parseCompilationUnitMember_typeAlias_implements() {
     ClassTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "class C = S with M implements I;");
@@ skipping 17 matching lines @@
     expect(typeAlias.abstractKeyword, isNull);
     expect(typeAlias.superclass.name.name, "S");
     expect(typeAlias.withClause, isNotNull);
     expect(typeAlias.implementsClause, isNull);
     expect(typeAlias.semicolon, isNotNull);
   }
 
   void test_parseCompilationUnitMember_typedef() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "typedef F();");
     expect(typeAlias.name.name, "F");
-    EngineTestCase.assertSizeOfList(0, typeAlias.parameters.parameters);
+    expect(typeAlias.parameters.parameters, hasLength(0));
   }
 
   void test_parseCompilationUnitMember_variable() {
     TopLevelVariableDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "var x = 0;");
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
   }
 
   void test_parseCompilationUnitMember_variableGet() {
     TopLevelVariableDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "String get = null;");
@@ skipping 25 matching lines @@
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
   }
 
   void test_parseConstExpression_listLiteral_typed() {
     ListLiteral literal = ParserTestCase.parse4("parseConstExpression", "const <A> []", []);
     expect(literal.constKeyword, isNotNull);
     expect(literal.typeArguments, isNotNull);
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(0, literal.elements);
+    expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseConstExpression_listLiteral_untyped() {
     ListLiteral literal = ParserTestCase.parse4("parseConstExpression", "const []", []);
     expect(literal.constKeyword, isNotNull);
     expect(literal.typeArguments, isNull);
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(0, literal.elements);
+    expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseConstExpression_mapLiteral_typed() {
     MapLiteral literal = ParserTestCase.parse4("parseConstExpression", "const <A, B> {}", []);
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(0, literal.entries);
+    expect(literal.entries, hasLength(0));
     expect(literal.rightBracket, isNotNull);
     expect(literal.typeArguments, isNotNull);
   }
 
   void test_parseConstExpression_mapLiteral_untyped() {
     MapLiteral literal = ParserTestCase.parse4("parseConstExpression", "const {}", []);
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(0, literal.entries);
+    expect(literal.entries, hasLength(0));
     expect(literal.rightBracket, isNotNull);
     expect(literal.typeArguments, isNull);
   }
 
   void test_parseConstructor() {
     // TODO(brianwilkerson) Implement tests for this method.
     //    parse("parseConstructor", new Class[] {Parser.CommentAndMetadata.class,
     //        Token.class, Token.class, SimpleIdentifier.class, Token.class,
     //        SimpleIdentifier.class, FormalParameterList.class}, new Object[] {emptyCommentAndMetadata(),
     //        null, null, null, null, null, null}, "");
   }
 
   void test_parseConstructor_with_pseudo_function_literal() {
     // "(b) {}" should not be misinterpreted as a function literal even though it looks like one.
     ClassMember classMember = ParserTestCase.parse("parseClassMember", <Object> ["C"], "C() : a = (b) {}");
     EngineTestCase.assertInstanceOf((obj) => obj is ConstructorDeclaration, ConstructorDeclaration, classMember);
     ConstructorDeclaration constructor = classMember as ConstructorDeclaration;
     NodeList<ConstructorInitializer> initializers = constructor.initializers;
-    EngineTestCase.assertSizeOfList(1, initializers);
+    expect(initializers, hasLength(1));
     ConstructorInitializer initializer = initializers[0];
     EngineTestCase.assertInstanceOf((obj) => obj is ConstructorFieldInitializer, ConstructorFieldInitializer, initializer);
     EngineTestCase.assertInstanceOf((obj) => obj is ParenthesizedExpression, ParenthesizedExpression, (initializer as ConstructorFieldInitializer).expression);
     EngineTestCase.assertInstanceOf((obj) => obj is BlockFunctionBody, BlockFunctionBody, constructor.body);
   }
 
   void test_parseConstructorFieldInitializer_qualified() {
     ConstructorFieldInitializer invocation = ParserTestCase.parse4("parseConstructorFieldInitializer", "this.a = b", []);
     expect(invocation.equals, isNotNull);
     expect(invocation.expression, isNotNull);
@@ skipping 50 matching lines @@
     ContinueStatement statement = ParserTestCase.parse4("parseContinueStatement", "continue;", [ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP]);
     expect(statement.keyword, isNotNull);
     expect(statement.label, isNull);
     expect(statement.semicolon, isNotNull);
   }
 
   void test_parseDirective_export() {
     ExportDirective directive = ParserTestCase.parse("parseDirective", <Object> [emptyCommentAndMetadata()], "export 'lib/lib.dart';");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
-    EngineTestCase.assertSizeOfList(0, directive.combinators);
+    expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseDirective_import() {
     ImportDirective directive = ParserTestCase.parse("parseDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart';");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.asToken, isNull);
     expect(directive.prefix, isNull);
-    EngineTestCase.assertSizeOfList(0, directive.combinators);
+    expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseDirective_library() {
     LibraryDirective directive = ParserTestCase.parse("parseDirective", <Object> [emptyCommentAndMetadata()], "library l;");
     expect(directive.libraryToken, isNotNull);
     expect(directive.name, isNotNull);
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseDirective_part() {
     PartDirective directive = ParserTestCase.parse("parseDirective", <Object> [emptyCommentAndMetadata()], "part 'lib/lib.dart';");
     expect(directive.partToken, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseDirective_partOf() {
     PartOfDirective directive = ParserTestCase.parse("parseDirective", <Object> [emptyCommentAndMetadata()], "part of l;");
     expect(directive.partToken, isNotNull);
     expect(directive.ofToken, isNotNull);
     expect(directive.libraryName, isNotNull);
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseDirectives_complete() {
     CompilationUnit unit = _parseDirectives("#! /bin/dart\nlibrary l;\nclass A {}", []);
     expect(unit.scriptTag, isNotNull);
-    EngineTestCase.assertSizeOfList(1, unit.directives);
+    expect(unit.directives, hasLength(1));
   }
 
   void test_parseDirectives_empty() {
     CompilationUnit unit = _parseDirectives("", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(0, unit.directives);
+    expect(unit.directives, hasLength(0));
   }
 
   void test_parseDirectives_mixed() {
     CompilationUnit unit = _parseDirectives("library l; class A {} part 'foo.dart';", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(1, unit.directives);
+    expect(unit.directives, hasLength(1));
   }
 
   void test_parseDirectives_multiple() {
     CompilationUnit unit = _parseDirectives("library l;\npart 'a.dart';", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(2, unit.directives);
+    expect(unit.directives, hasLength(2));
   }
 
   void test_parseDirectives_script() {
     CompilationUnit unit = _parseDirectives("#! /bin/dart", []);
     expect(unit.scriptTag, isNotNull);
-    EngineTestCase.assertSizeOfList(0, unit.directives);
+    expect(unit.directives, hasLength(0));
   }
 
   void test_parseDirectives_single() {
     CompilationUnit unit = _parseDirectives("library l;", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(1, unit.directives);
+    expect(unit.directives, hasLength(1));
   }
 
   void test_parseDirectives_topLevelDeclaration() {
     CompilationUnit unit = _parseDirectives("class A {}", []);
     expect(unit.scriptTag, isNull);
-    EngineTestCase.assertSizeOfList(0, unit.directives);
+    expect(unit.directives, hasLength(0));
   }
 
   void test_parseDocumentationComment_block() {
     Comment comment = ParserTestCase.parse4("parseDocumentationComment", "/** */ class", []);
     expect(comment.isBlock, isFalse);
     expect(comment.isDocumentation, isTrue);
     expect(comment.isEndOfLine, isFalse);
   }
 
   void test_parseDocumentationComment_block_withReference() {
     Comment comment = ParserTestCase.parse4("parseDocumentationComment", "/** [a] */ class", []);
     expect(comment.isBlock, isFalse);
     expect(comment.isDocumentation, isTrue);
     expect(comment.isEndOfLine, isFalse);
     NodeList<CommentReference> references = comment.references;
-    EngineTestCase.assertSizeOfList(1, references);
+    expect(references, hasLength(1));
     CommentReference reference = references[0];
     expect(reference, isNotNull);
     expect(reference.offset, 5);
   }
 
   void test_parseDocumentationComment_endOfLine() {
     Comment comment = ParserTestCase.parse4("parseDocumentationComment", "/// \n/// \n class", []);
     expect(comment.isBlock, isFalse);
     expect(comment.isDocumentation, isTrue);
     expect(comment.isEndOfLine, isFalse);
@@ skipping 14 matching lines @@
     EmptyStatement statement = ParserTestCase.parse4("parseEmptyStatement", ";", []);
     expect(statement.semicolon, isNotNull);
   }
 
   void test_parseEnumDeclaration_one() {
     EnumDeclaration declaration = ParserTestCase.parse("parseEnumDeclaration", <Object> [emptyCommentAndMetadata()], "enum E {ONE}");
     expect(declaration.documentationComment, isNull);
     expect(declaration.keyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
-    EngineTestCase.assertSizeOfList(1, declaration.constants);
+    expect(declaration.constants, hasLength(1));
     expect(declaration.rightBracket, isNotNull);
   }
 
   void test_parseEnumDeclaration_trailingComma() {
     EnumDeclaration declaration = ParserTestCase.parse("parseEnumDeclaration", <Object> [emptyCommentAndMetadata()], "enum E {ONE,}");
     expect(declaration.documentationComment, isNull);
     expect(declaration.keyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
-    EngineTestCase.assertSizeOfList(1, declaration.constants);
+    expect(declaration.constants, hasLength(1));
     expect(declaration.rightBracket, isNotNull);
   }
 
   void test_parseEnumDeclaration_two() {
     EnumDeclaration declaration = ParserTestCase.parse("parseEnumDeclaration", <Object> [emptyCommentAndMetadata()], "enum E {ONE, TWO}");
     expect(declaration.documentationComment, isNull);
     expect(declaration.keyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
-    EngineTestCase.assertSizeOfList(2, declaration.constants);
+    expect(declaration.constants, hasLength(2));
     expect(declaration.rightBracket, isNotNull);
   }
 
   void test_parseEqualityExpression_normal() {
     BinaryExpression expression = ParserTestCase.parse4("parseEqualityExpression", "x == y", []);
     expect(expression.leftOperand, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.EQ_EQ);
     expect(expression.rightOperand, isNotNull);
   }
 
   void test_parseEqualityExpression_super() {
     BinaryExpression expression = ParserTestCase.parse4("parseEqualityExpression", "super == y", []);
     EngineTestCase.assertInstanceOf((obj) => obj is SuperExpression, SuperExpression, expression.leftOperand);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.EQ_EQ);
     expect(expression.rightOperand, isNotNull);
   }
 
   void test_parseExportDirective_hide() {
     ExportDirective directive = ParserTestCase.parse("parseExportDirective", <Object> [emptyCommentAndMetadata()], "export 'lib/lib.dart' hide A, B;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
-    EngineTestCase.assertSizeOfList(1, directive.combinators);
+    expect(directive.combinators, hasLength(1));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseExportDirective_hide_show() {
     ExportDirective directive = ParserTestCase.parse("parseExportDirective", <Object> [emptyCommentAndMetadata()], "export 'lib/lib.dart' hide A show B;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
-    EngineTestCase.assertSizeOfList(2, directive.combinators);
+    expect(directive.combinators, hasLength(2));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseExportDirective_noCombinator() {
     ExportDirective directive = ParserTestCase.parse("parseExportDirective", <Object> [emptyCommentAndMetadata()], "export 'lib/lib.dart';");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
-    EngineTestCase.assertSizeOfList(0, directive.combinators);
+    expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseExportDirective_show() {
     ExportDirective directive = ParserTestCase.parse("parseExportDirective", <Object> [emptyCommentAndMetadata()], "export 'lib/lib.dart' show A, B;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
-    EngineTestCase.assertSizeOfList(1, directive.combinators);
+    expect(directive.combinators, hasLength(1));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseExportDirective_show_hide() {
     ExportDirective directive = ParserTestCase.parse("parseExportDirective", <Object> [emptyCommentAndMetadata()], "export 'lib/lib.dart' show B hide A;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
-    EngineTestCase.assertSizeOfList(2, directive.combinators);
+    expect(directive.combinators, hasLength(2));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseExpression_assign() {
     // TODO(brianwilkerson) Implement more tests for this method.
     AssignmentExpression expression = ParserTestCase.parse4("parseExpression", "x = y", []);
     expect(expression.leftHandSide, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.EQ);
     expect(expression.rightHandSide, isNotNull);
@@ skipping 40 matching lines @@
   }
 
   void test_parseExpression_invokeFunctionExpression() {
     FunctionExpressionInvocation invocation = ParserTestCase.parse4("parseExpression", "(a) {return a + a;} (3)", []);
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionExpression, FunctionExpression, invocation.function);
     FunctionExpression expression = invocation.function as FunctionExpression;
     expect(expression.parameters, isNotNull);
     expect(expression.body, isNotNull);
     ArgumentList list = invocation.argumentList;
     expect(list, isNotNull);
-    EngineTestCase.assertSizeOfList(1, list.arguments);
+    expect(list.arguments, hasLength(1));
   }
 
   void test_parseExpression_superMethodInvocation() {
     MethodInvocation invocation = ParserTestCase.parse4("parseExpression", "super.m()", []);
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
   void test_parseExpressionList_multiple() {
     List<Expression> result = ParserTestCase.parse4("parseExpressionList", "1, 2, 3", []);
-    EngineTestCase.assertSizeOfList(3, result);
+    expect(result, hasLength(3));
   }
 
   void test_parseExpressionList_single() {
     List<Expression> result = ParserTestCase.parse4("parseExpressionList", "1", []);
-    EngineTestCase.assertSizeOfList(1, result);
+    expect(result, hasLength(1));
   }
 
   void test_parseExpressionWithoutCascade_assign() {
     // TODO(brianwilkerson) Implement more tests for this method.
     AssignmentExpression expression = ParserTestCase.parse4("parseExpressionWithoutCascade", "x = y", []);
     expect(expression.leftHandSide, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.EQ);
     expect(expression.rightHandSide, isNotNull);
   }
@@ skipping 200 matching lines @@
     expect(simpleParameter.kind, kind);
     expect(parameter.separator, isNotNull);
     expect(parameter.defaultValue, isNotNull);
     expect(parameter.kind, kind);
   }
 
   void test_parseFormalParameterList_empty() {
     FormalParameterList parameterList = ParserTestCase.parse4("parseFormalParameterList", "()", []);
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNull);
-    EngineTestCase.assertSizeOfList(0, parameterList.parameters);
+    expect(parameterList.parameters, hasLength(0));
     expect(parameterList.rightDelimiter, isNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
 
   void test_parseFormalParameterList_named_multiple() {
     FormalParameterList parameterList = ParserTestCase.parse4("parseFormalParameterList", "({A a : 1, B b, C c : 3})", []);
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNotNull);
-    EngineTestCase.assertSizeOfList(3, parameterList.parameters);
+    expect(parameterList.parameters, hasLength(3));
     expect(parameterList.rightDelimiter, isNotNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
 
   void test_parseFormalParameterList_named_single() {
     FormalParameterList parameterList = ParserTestCase.parse4("parseFormalParameterList", "({A a})", []);
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNotNull);
-    EngineTestCase.assertSizeOfList(1, parameterList.parameters);
+    expect(parameterList.parameters, hasLength(1));
     expect(parameterList.rightDelimiter, isNotNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
 
   void test_parseFormalParameterList_normal_multiple() {
     FormalParameterList parameterList = ParserTestCase.parse4("parseFormalParameterList", "(A a, B b, C c)", []);
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNull);
-    EngineTestCase.assertSizeOfList(3, parameterList.parameters);
+    expect(parameterList.parameters, hasLength(3));
     expect(parameterList.rightDelimiter, isNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
 
   void test_parseFormalParameterList_normal_named() {
     FormalParameterList parameterList = ParserTestCase.parse4("parseFormalParameterList", "(A a, {B b})", []);
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNotNull);
-    EngineTestCase.assertSizeOfList(2, parameterList.parameters);
+    expect(parameterList.parameters, hasLength(2));
     expect(parameterList.rightDelimiter, isNotNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
 
   void test_parseFormalParameterList_normal_positional() {
     FormalParameterList parameterList = ParserTestCase.parse4("parseFormalParameterList", "(A a, [B b])", []);
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNotNull);
-    EngineTestCase.assertSizeOfList(2, parameterList.parameters);
+    expect(parameterList.parameters, hasLength(2));
     expect(parameterList.rightDelimiter, isNotNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
 
   void test_parseFormalParameterList_normal_single() {
     FormalParameterList parameterList = ParserTestCase.parse4("parseFormalParameterList", "(A a)", []);
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNull);
-    EngineTestCase.assertSizeOfList(1, parameterList.parameters);
+    expect(parameterList.parameters, hasLength(1));
     expect(parameterList.rightDelimiter, isNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
 
   void test_parseFormalParameterList_positional_multiple() {
     FormalParameterList parameterList = ParserTestCase.parse4("parseFormalParameterList", "([A a = null, B b, C c = null])", []);
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNotNull);
-    EngineTestCase.assertSizeOfList(3, parameterList.parameters);
+    expect(parameterList.parameters, hasLength(3));
     expect(parameterList.rightDelimiter, isNotNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
 
   void test_parseFormalParameterList_positional_single() {
     FormalParameterList parameterList = ParserTestCase.parse4("parseFormalParameterList", "([A a = null])", []);
     expect(parameterList.leftParenthesis, isNotNull);
     expect(parameterList.leftDelimiter, isNotNull);
-    EngineTestCase.assertSizeOfList(1, parameterList.parameters);
+    expect(parameterList.parameters, hasLength(1));
     expect(parameterList.rightDelimiter, isNotNull);
     expect(parameterList.rightParenthesis, isNotNull);
   }
 
   void test_parseForStatement_each_await() {
     ForEachStatement statement = ParserTestCase.parse4("parseForStatement", "await for (element in list) {}", []);
     expect(statement.awaitKeyword, isNotNull);
     expect(statement.forKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.loopVariable, isNull);
@@ skipping 16 matching lines @@
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
   void test_parseForStatement_each_noType_metadata() {
     ForEachStatement statement = ParserTestCase.parse4("parseForStatement", "for (@A var element in list) {}", []);
     expect(statement.awaitKeyword, isNull);
     expect(statement.forKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.loopVariable, isNotNull);
-    EngineTestCase.assertSizeOfList(1, statement.loopVariable.metadata);
+    expect(statement.loopVariable.metadata, hasLength(1));
     expect(statement.identifier, isNull);
     expect(statement.inKeyword, isNotNull);
     expect(statement.iterator, isNotNull);
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
   void test_parseForStatement_each_type() {
     ForEachStatement statement = ParserTestCase.parse4("parseForStatement", "for (A element in list) {}", []);
     expect(statement.awaitKeyword, isNull);
@@ skipping 22 matching lines @@
 
   void test_parseForStatement_loop_c() {
     ForStatement statement = ParserTestCase.parse4("parseForStatement", "for (; i < count;) {}", []);
     expect(statement.forKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.variables, isNull);
     expect(statement.initialization, isNull);
     expect(statement.leftSeparator, isNotNull);
     expect(statement.condition, isNotNull);
     expect(statement.rightSeparator, isNotNull);
-    EngineTestCase.assertSizeOfList(0, statement.updaters);
+    expect(statement.updaters, hasLength(0));
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
   void test_parseForStatement_loop_cu() {
     ForStatement statement = ParserTestCase.parse4("parseForStatement", "for (; i < count; i++) {}", []);
     expect(statement.forKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.variables, isNull);
     expect(statement.initialization, isNull);
     expect(statement.leftSeparator, isNotNull);
     expect(statement.condition, isNotNull);
     expect(statement.rightSeparator, isNotNull);
-    EngineTestCase.assertSizeOfList(1, statement.updaters);
+    expect(statement.updaters, hasLength(1));
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
   void test_parseForStatement_loop_ecu() {
     ForStatement statement = ParserTestCase.parse4("parseForStatement", "for (i--; i < count; i++) {}", []);
     expect(statement.forKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.variables, isNull);
     expect(statement.initialization, isNotNull);
     expect(statement.leftSeparator, isNotNull);
     expect(statement.condition, isNotNull);
     expect(statement.rightSeparator, isNotNull);
-    EngineTestCase.assertSizeOfList(1, statement.updaters);
+    expect(statement.updaters, hasLength(1));
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
   void test_parseForStatement_loop_i() {
     ForStatement statement = ParserTestCase.parse4("parseForStatement", "for (var i = 0;;) {}", []);
     expect(statement.forKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     VariableDeclarationList variables = statement.variables;
     expect(variables, isNotNull);
-    EngineTestCase.assertSizeOfList(0, variables.metadata);
-    EngineTestCase.assertSizeOfList(1, variables.variables);
+    expect(variables.metadata, hasLength(0));
+    expect(variables.variables, hasLength(1));
     expect(statement.initialization, isNull);
     expect(statement.leftSeparator, isNotNull);
     expect(statement.condition, isNull);
     expect(statement.rightSeparator, isNotNull);
-    EngineTestCase.assertSizeOfList(0, statement.updaters);
+    expect(statement.updaters, hasLength(0));
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
   void test_parseForStatement_loop_i_withMetadata() {
     ForStatement statement = ParserTestCase.parse4("parseForStatement", "for (@A var i = 0;;) {}", []);
     expect(statement.forKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     VariableDeclarationList variables = statement.variables;
     expect(variables, isNotNull);
-    EngineTestCase.assertSizeOfList(1, variables.metadata);
-    EngineTestCase.assertSizeOfList(1, variables.variables);
+    expect(variables.metadata, hasLength(1));
+    expect(variables.variables, hasLength(1));
     expect(statement.initialization, isNull);
     expect(statement.leftSeparator, isNotNull);
     expect(statement.condition, isNull);
     expect(statement.rightSeparator, isNotNull);
-    EngineTestCase.assertSizeOfList(0, statement.updaters);
+    expect(statement.updaters, hasLength(0));
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
   void test_parseForStatement_loop_ic() {
     ForStatement statement = ParserTestCase.parse4("parseForStatement", "for (var i = 0; i < count;) {}", []);
     expect(statement.forKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     VariableDeclarationList variables = statement.variables;
     expect(variables, isNotNull);
-    EngineTestCase.assertSizeOfList(1, variables.variables);
+    expect(variables.variables, hasLength(1));
     expect(statement.initialization, isNull);
     expect(statement.leftSeparator, isNotNull);
     expect(statement.condition, isNotNull);
     expect(statement.rightSeparator, isNotNull);
-    EngineTestCase.assertSizeOfList(0, statement.updaters);
+    expect(statement.updaters, hasLength(0));
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
   void test_parseForStatement_loop_icu() {
     ForStatement statement = ParserTestCase.parse4("parseForStatement", "for (var i = 0; i < count; i++) {}", []);
     expect(statement.forKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     VariableDeclarationList variables = statement.variables;
     expect(variables, isNotNull);
-    EngineTestCase.assertSizeOfList(1, variables.variables);
+    expect(variables.variables, hasLength(1));
     expect(statement.initialization, isNull);
     expect(statement.leftSeparator, isNotNull);
     expect(statement.condition, isNotNull);
     expect(statement.rightSeparator, isNotNull);
-    EngineTestCase.assertSizeOfList(1, statement.updaters);
+    expect(statement.updaters, hasLength(1));
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
   void test_parseForStatement_loop_iicuu() {
     ForStatement statement = ParserTestCase.parse4("parseForStatement", "for (int i = 0, j = count; i < j; i++, j--) {}", []);
     expect(statement.forKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     VariableDeclarationList variables = statement.variables;
     expect(variables, isNotNull);
-    EngineTestCase.assertSizeOfList(2, variables.variables);
+    expect(variables.variables, hasLength(2));
     expect(statement.initialization, isNull);
     expect(statement.leftSeparator, isNotNull);
     expect(statement.condition, isNotNull);
     expect(statement.rightSeparator, isNotNull);
-    EngineTestCase.assertSizeOfList(2, statement.updaters);
+    expect(statement.updaters, hasLength(2));
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
   void test_parseForStatement_loop_iu() {
     ForStatement statement = ParserTestCase.parse4("parseForStatement", "for (var i = 0;; i++) {}", []);
     expect(statement.forKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     VariableDeclarationList variables = statement.variables;
     expect(variables, isNotNull);
-    EngineTestCase.assertSizeOfList(1, variables.variables);
+    expect(variables.variables, hasLength(1));
     expect(statement.initialization, isNull);
     expect(statement.leftSeparator, isNotNull);
     expect(statement.condition, isNull);
     expect(statement.rightSeparator, isNotNull);
-    EngineTestCase.assertSizeOfList(1, statement.updaters);
+    expect(statement.updaters, hasLength(1));
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
   void test_parseForStatement_loop_u() {
     ForStatement statement = ParserTestCase.parse4("parseForStatement", "for (;; i++) {}", []);
     expect(statement.forKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.variables, isNull);
     expect(statement.initialization, isNull);
     expect(statement.leftSeparator, isNotNull);
     expect(statement.condition, isNull);
     expect(statement.rightSeparator, isNotNull);
-    EngineTestCase.assertSizeOfList(1, statement.updaters);
+    expect(statement.updaters, hasLength(1));
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
   void test_parseFunctionBody_block() {
     BlockFunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, null, false], "{}");
     expect(functionBody.keyword, isNull);
     expect(functionBody.star, isNull);
     expect(functionBody.block, isNotNull);
     expect(functionBody.isAsynchronous, isFalse);
@@ skipping 177 matching lines @@
     expect(method.modifierKeyword, staticKeyword);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
     expect(method.parameters, isNull);
     expect(method.propertyKeyword, isNotNull);
     expect(method.returnType, returnType);
   }
 
   void test_parseIdentifierList_multiple() {
     List<SimpleIdentifier> list = ParserTestCase.parse4("parseIdentifierList", "a, b, c", []);
-    EngineTestCase.assertSizeOfList(3, list);
+    expect(list, hasLength(3));
   }
 
   void test_parseIdentifierList_single() {
     List<SimpleIdentifier> list = ParserTestCase.parse4("parseIdentifierList", "a", []);
-    EngineTestCase.assertSizeOfList(1, list);
+    expect(list, hasLength(1));
   }
 
   void test_parseIfStatement_else_block() {
     IfStatement statement = ParserTestCase.parse4("parseIfStatement", "if (x) {} else {}", []);
     expect(statement.ifKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.condition, isNotNull);
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.thenStatement, isNotNull);
     expect(statement.elseKeyword, isNotNull);
@@ skipping 28 matching lines @@
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.condition, isNotNull);
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.thenStatement, isNotNull);
     expect(statement.elseKeyword, isNull);
     expect(statement.elseStatement, isNull);
   }
 
   void test_parseImplementsClause_multiple() {
     ImplementsClause clause = ParserTestCase.parse4("parseImplementsClause", "implements A, B, C", []);
-    EngineTestCase.assertSizeOfList(3, clause.interfaces);
+    expect(clause.interfaces, hasLength(3));
     expect(clause.keyword, isNotNull);
   }
 
   void test_parseImplementsClause_single() {
     ImplementsClause clause = ParserTestCase.parse4("parseImplementsClause", "implements A", []);
-    EngineTestCase.assertSizeOfList(1, clause.interfaces);
+    expect(clause.interfaces, hasLength(1));
     expect(clause.keyword, isNotNull);
   }
 
   void test_parseImportDirective_deferred() {
     ImportDirective directive = ParserTestCase.parse("parseImportDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart' deferred as a;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredToken, isNotNull);
     expect(directive.asToken, isNotNull);
     expect(directive.prefix, isNotNull);
-    EngineTestCase.assertSizeOfList(0, directive.combinators);
+    expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_hide() {
     ImportDirective directive = ParserTestCase.parse("parseImportDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart' hide A, B;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredToken, isNull);
     expect(directive.asToken, isNull);
     expect(directive.prefix, isNull);
-    EngineTestCase.assertSizeOfList(1, directive.combinators);
+    expect(directive.combinators, hasLength(1));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_noCombinator() {
     ImportDirective directive = ParserTestCase.parse("parseImportDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart';");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredToken, isNull);
     expect(directive.asToken, isNull);
     expect(directive.prefix, isNull);
-    EngineTestCase.assertSizeOfList(0, directive.combinators);
+    expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_prefix() {
     ImportDirective directive = ParserTestCase.parse("parseImportDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart' as a;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredToken, isNull);
     expect(directive.asToken, isNotNull);
     expect(directive.prefix, isNotNull);
-    EngineTestCase.assertSizeOfList(0, directive.combinators);
+    expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_prefix_hide_show() {
     ImportDirective directive = ParserTestCase.parse("parseImportDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart' as a hide A show B;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredToken, isNull);
     expect(directive.asToken, isNotNull);
     expect(directive.prefix, isNotNull);
-    EngineTestCase.assertSizeOfList(2, directive.combinators);
+    expect(directive.combinators, hasLength(2));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_prefix_show_hide() {
     ImportDirective directive = ParserTestCase.parse("parseImportDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart' as a show B hide A;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredToken, isNull);
     expect(directive.asToken, isNotNull);
     expect(directive.prefix, isNotNull);
-    EngineTestCase.assertSizeOfList(2, directive.combinators);
+    expect(directive.combinators, hasLength(2));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseImportDirective_show() {
     ImportDirective directive = ParserTestCase.parse("parseImportDirective", <Object> [emptyCommentAndMetadata()], "import 'lib/lib.dart' show A, B;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.deferredToken, isNull);
     expect(directive.asToken, isNull);
     expect(directive.prefix, isNull);
-    EngineTestCase.assertSizeOfList(1, directive.combinators);
+    expect(directive.combinators, hasLength(1));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseInitializedIdentifierList_type() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     Token staticKeyword = TokenFactory.tokenFromKeyword(Keyword.STATIC);
     TypeName type = new TypeName(new SimpleIdentifier(null), null);
     FieldDeclaration declaration = ParserTestCase.parse("parseInitializedIdentifierList", <Object> [
         commentAndMetadata(comment, []),
         staticKeyword,
         null,
         type], "a = 1, b, c = 3;");
     expect(declaration.documentationComment, comment);
     VariableDeclarationList fields = declaration.fields;
     expect(fields, isNotNull);
     expect(fields.keyword, isNull);
     expect(fields.type, type);
-    EngineTestCase.assertSizeOfList(3, fields.variables);
+    expect(fields.variables, hasLength(3));
     expect(declaration.staticKeyword, staticKeyword);
     expect(declaration.semicolon, isNotNull);
   }
 
   void test_parseInitializedIdentifierList_var() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     Token staticKeyword = TokenFactory.tokenFromKeyword(Keyword.STATIC);
     Token varKeyword = TokenFactory.tokenFromKeyword(Keyword.VAR);
     FieldDeclaration declaration = ParserTestCase.parse("parseInitializedIdentifierList", <Object> [
         commentAndMetadata(comment, []),
         staticKeyword,
         varKeyword,
         null], "a = 1, b, c = 3;");
     expect(declaration.documentationComment, comment);
     VariableDeclarationList fields = declaration.fields;
     expect(fields, isNotNull);
     expect(fields.keyword, varKeyword);
     expect(fields.type, isNull);
-    EngineTestCase.assertSizeOfList(3, fields.variables);
+    expect(fields.variables, hasLength(3));
     expect(declaration.staticKeyword, staticKeyword);
     expect(declaration.semicolon, isNotNull);
   }
 
   void test_parseInstanceCreationExpression_qualifiedType() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
     InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token], "A.B()");
     expect(expression.keyword, token);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
@@ skipping 58 matching lines @@
     expect(identifier.name, name);
   }
 
   void test_parseListLiteral_empty_oneToken() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.CONST);
     TypeArgumentList typeArguments = null;
     ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [token, typeArguments], "[]");
     expect(literal.constKeyword, token);
     expect(literal.typeArguments, typeArguments);
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(0, literal.elements);
+    expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseListLiteral_empty_twoTokens() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.CONST);
     TypeArgumentList typeArguments = null;
     ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [token, typeArguments], "[ ]");
     expect(literal.constKeyword, token);
     expect(literal.typeArguments, typeArguments);
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(0, literal.elements);
+    expect(literal.elements, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseListLiteral_multiple() {
     ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [null, null], "[1, 2, 3]");
     expect(literal.constKeyword, isNull);
     expect(literal.typeArguments, isNull);
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(3, literal.elements);
+    expect(literal.elements, hasLength(3));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseListLiteral_single() {
     ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [null, null], "[1]");
     expect(literal.constKeyword, isNull);
     expect(literal.typeArguments, isNull);
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, literal.elements);
+    expect(literal.elements, hasLength(1));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseListOrMapLiteral_list_noType() {
     ListLiteral literal = ParserTestCase.parse("parseListOrMapLiteral", <Object> [null], "[1]");
     expect(literal.constKeyword, isNull);
     expect(literal.typeArguments, isNull);
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, literal.elements);
+    expect(literal.elements, hasLength(1));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseListOrMapLiteral_list_type() {
     ListLiteral literal = ParserTestCase.parse("parseListOrMapLiteral", <Object> [null], "<int> [1]");
     expect(literal.constKeyword, isNull);
     expect(literal.typeArguments, isNotNull);
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, literal.elements);
+    expect(literal.elements, hasLength(1));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseListOrMapLiteral_map_noType() {
     MapLiteral literal = ParserTestCase.parse("parseListOrMapLiteral", <Object> [null], "{'1' : 1}");
     expect(literal.constKeyword, isNull);
     expect(literal.typeArguments, isNull);
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, literal.entries);
+    expect(literal.entries, hasLength(1));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseListOrMapLiteral_map_type() {
     MapLiteral literal = ParserTestCase.parse("parseListOrMapLiteral", <Object> [null], "<String, int> {'1' : 1}");
     expect(literal.constKeyword, isNull);
     expect(literal.typeArguments, isNotNull);
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, literal.entries);
+    expect(literal.entries, hasLength(1));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseLogicalAndExpression() {
     BinaryExpression expression = ParserTestCase.parse4("parseLogicalAndExpression", "x && y", []);
     expect(expression.leftOperand, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.AMPERSAND_AMPERSAND);
     expect(expression.rightOperand, isNotNull);
   }
 
   void test_parseLogicalOrExpression() {
     BinaryExpression expression = ParserTestCase.parse4("parseLogicalOrExpression", "x || y", []);
     expect(expression.leftOperand, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.BAR_BAR);
     expect(expression.rightOperand, isNotNull);
   }
 
   void test_parseMapLiteral_empty() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.CONST);
     TypeArgumentList typeArguments = AstFactory.typeArgumentList([
         AstFactory.typeName4("String", []),
         AstFactory.typeName4("int", [])]);
     MapLiteral literal = ParserTestCase.parse("parseMapLiteral", <Object> [token, typeArguments], "{}");
     expect(literal.constKeyword, token);
     expect(literal.typeArguments, typeArguments);
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(0, literal.entries);
+    expect(literal.entries, hasLength(0));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseMapLiteral_multiple() {
     MapLiteral literal = ParserTestCase.parse("parseMapLiteral", <Object> [null, null], "{'a' : b, 'x' : y}");
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(2, literal.entries);
+    expect(literal.entries, hasLength(2));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseMapLiteral_single() {
     MapLiteral literal = ParserTestCase.parse("parseMapLiteral", <Object> [null, null], "{'x' : y}");
     expect(literal.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, literal.entries);
+    expect(literal.entries, hasLength(1));
     expect(literal.rightBracket, isNotNull);
   }
 
   void test_parseMapLiteralEntry_complex() {
     MapLiteralEntry entry = ParserTestCase.parse4("parseMapLiteralEntry", "2 + 2 : y", []);
     expect(entry.key, isNotNull);
     expect(entry.separator, isNotNull);
     expect(entry.value, isNotNull);
   }
 
@@ skipping 134 matching lines @@
   void test_parseNonLabeledStatement_invokeFunctionExpression() {
     ExpressionStatement statement = ParserTestCase.parse4("parseNonLabeledStatement", "(a) {return a + a;} (3);", []);
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionExpressionInvocation, FunctionExpressionInvocation, statement.expression);
     FunctionExpressionInvocation invocation = statement.expression as FunctionExpressionInvocation;
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionExpression, FunctionExpression, invocation.function);
     FunctionExpression expression = invocation.function as FunctionExpression;
     expect(expression.parameters, isNotNull);
     expect(expression.body, isNotNull);
     ArgumentList list = invocation.argumentList;
     expect(list, isNotNull);
-    EngineTestCase.assertSizeOfList(1, list.arguments);
+    expect(list.arguments, hasLength(1));
   }
 
   void test_parseNonLabeledStatement_null() {
     ExpressionStatement statement = ParserTestCase.parse4("parseNonLabeledStatement", "null;", []);
     expect(statement.expression, isNotNull);
   }
 
   void test_parseNonLabeledStatement_startingWithBuiltInIdentifier() {
     ExpressionStatement statement = ParserTestCase.parse4("parseNonLabeledStatement", "library.getName();", []);
     expect(statement.expression, isNotNull);
@@ skipping 41 matching lines @@
     expect(parameter.parameters, isNull);
   }
 
   void test_parseNormalFormalParameter_field_function_nested() {
     FieldFormalParameter parameter = ParserTestCase.parse4("parseNormalFormalParameter", "this.a(B b))", []);
     expect(parameter.keyword, isNull);
     expect(parameter.type, isNull);
     expect(parameter.identifier, isNotNull);
     FormalParameterList parameterList = parameter.parameters;
     expect(parameterList, isNotNull);
-    EngineTestCase.assertSizeOfList(1, parameterList.parameters);
+    expect(parameterList.parameters, hasLength(1));
   }
 
   void test_parseNormalFormalParameter_field_function_noNested() {
     FieldFormalParameter parameter = ParserTestCase.parse4("parseNormalFormalParameter", "this.a())", []);
     expect(parameter.keyword, isNull);
     expect(parameter.type, isNull);
     expect(parameter.identifier, isNotNull);
     FormalParameterList parameterList = parameter.parameters;
     expect(parameterList, isNotNull);
-    EngineTestCase.assertSizeOfList(0, parameterList.parameters);
+    expect(parameterList.parameters, hasLength(0));
   }
 
   void test_parseNormalFormalParameter_field_noType() {
     FieldFormalParameter parameter = ParserTestCase.parse4("parseNormalFormalParameter", "this.a)", []);
     expect(parameter.keyword, isNull);
     expect(parameter.type, isNull);
     expect(parameter.identifier, isNotNull);
     expect(parameter.parameters, isNull);
   }
 
@@ skipping 213 matching lines @@
   }
 
   void test_parsePrimaryExpression_listLiteral_index() {
     ListLiteral literal = ParserTestCase.parse4("parsePrimaryExpression", "[]", []);
     expect(literal, isNotNull);
   }
 
   void test_parsePrimaryExpression_listLiteral_typed() {
     ListLiteral literal = ParserTestCase.parse4("parsePrimaryExpression", "<A>[ ]", []);
     expect(literal.typeArguments, isNotNull);
-    EngineTestCase.assertSizeOfList(1, literal.typeArguments.arguments);
+    expect(literal.typeArguments.arguments, hasLength(1));
   }
 
   void test_parsePrimaryExpression_mapLiteral() {
     MapLiteral literal = ParserTestCase.parse4("parsePrimaryExpression", "{}", []);
     expect(literal, isNotNull);
   }
 
   void test_parsePrimaryExpression_mapLiteral_typed() {
     MapLiteral literal = ParserTestCase.parse4("parsePrimaryExpression", "<A, B>{}", []);
     expect(literal.typeArguments, isNotNull);
-    EngineTestCase.assertSizeOfList(2, literal.typeArguments.arguments);
+    expect(literal.typeArguments.arguments, hasLength(2));
   }
 
   void test_parsePrimaryExpression_new() {
     InstanceCreationExpression expression = ParserTestCase.parse4("parsePrimaryExpression", "new A()", []);
     expect(expression, isNotNull);
   }
 
   void test_parsePrimaryExpression_null() {
     NullLiteral literal = ParserTestCase.parse4("parsePrimaryExpression", "null", []);
     expect(literal.literal, isNotNull);
@@ skipping 204 matching lines @@
   }
 
   void test_parseStatement_functionDeclaration() {
     // TODO(brianwilkerson) Implement more tests for this method.
     FunctionDeclarationStatement statement = ParserTestCase.parse4("parseStatement", "int f(a, b) {};", []);
     expect(statement.functionDeclaration, isNotNull);
   }
 
   void test_parseStatement_mulipleLabels() {
     LabeledStatement statement = ParserTestCase.parse4("parseStatement", "l: m: return x;", []);
-    EngineTestCase.assertSizeOfList(2, statement.labels);
+    expect(statement.labels, hasLength(2));
     expect(statement.statement, isNotNull);
   }
 
   void test_parseStatement_noLabels() {
     ParserTestCase.parse4("parseStatement", "return x;", []);
   }
 
   void test_parseStatement_singleLabel() {
     LabeledStatement statement = ParserTestCase.parse4("parseStatement", "l: return x;", []);
-    EngineTestCase.assertSizeOfList(1, statement.labels);
+    expect(statement.labels, hasLength(1));
     expect(statement.statement, isNotNull);
   }
 
   void test_parseStatements_multiple() {
     List<Statement> statements = ParserTestCase.parseStatements("return; return;", 2, []);
-    EngineTestCase.assertSizeOfList(2, statements);
+    expect(statements, hasLength(2));
   }
 
   void test_parseStatements_single() {
     List<Statement> statements = ParserTestCase.parseStatements("return;", 1, []);
-    EngineTestCase.assertSizeOfList(1, statements);
+    expect(statements, hasLength(1));
   }
 
   void test_parseStringLiteral_adjacent() {
     AdjacentStrings literal = ParserTestCase.parse4("parseStringLiteral", "'a' 'b'", []);
     NodeList<StringLiteral> strings = literal.strings;
-    EngineTestCase.assertSizeOfList(2, strings);
+    expect(strings, hasLength(2));
     StringLiteral firstString = strings[0];
     StringLiteral secondString = strings[1];
     expect((firstString as SimpleStringLiteral).value, "a");
     expect((secondString as SimpleStringLiteral).value, "b");
   }
 
   void test_parseStringLiteral_interpolated() {
     StringInterpolation literal = ParserTestCase.parse4("parseStringLiteral", "'a \${b} c \$this d'", []);
     NodeList<InterpolationElement> elements = literal.elements;
-    EngineTestCase.assertSizeOfList(5, elements);
+    expect(elements, hasLength(5));
     expect(elements[0] is InterpolationString, isTrue);
     expect(elements[1] is InterpolationExpression, isTrue);
     expect(elements[2] is InterpolationString, isTrue);
     expect(elements[3] is InterpolationExpression, isTrue);
     expect(elements[4] is InterpolationString, isTrue);
   }
 
   void test_parseStringLiteral_single() {
     SimpleStringLiteral literal = ParserTestCase.parse4("parseStringLiteral", "'a'", []);
     expect(literal.literal, isNotNull);
@@ skipping 16 matching lines @@
     expect(invocation.period, isNull);
   }
 
   void test_parseSwitchStatement_case() {
     SwitchStatement statement = ParserTestCase.parse4("parseSwitchStatement", "switch (a) {case 1: return 'I';}", []);
     expect(statement.keyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.expression, isNotNull);
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, statement.members);
+    expect(statement.members, hasLength(1));
     expect(statement.rightBracket, isNotNull);
   }
 
   void test_parseSwitchStatement_empty() {
     SwitchStatement statement = ParserTestCase.parse4("parseSwitchStatement", "switch (a) {}", []);
     expect(statement.keyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.expression, isNotNull);
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(0, statement.members);
+    expect(statement.members, hasLength(0));
     expect(statement.rightBracket, isNotNull);
   }
 
   void test_parseSwitchStatement_labeledCase() {
     SwitchStatement statement = ParserTestCase.parse4("parseSwitchStatement", "switch (a) {l1: l2: l3: case(1):}", []);
     expect(statement.keyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.expression, isNotNull);
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, statement.members);
-    EngineTestCase.assertSizeOfList(3, statement.members[0].labels);
+    expect(statement.members, hasLength(1));
+    expect(statement.members[0].labels, hasLength(3));
     expect(statement.rightBracket, isNotNull);
   }
 
   void test_parseSwitchStatement_labeledStatementInCase() {
     SwitchStatement statement = ParserTestCase.parse4("parseSwitchStatement", "switch (a) {case 0: f(); l1: g(); break;}", []);
     expect(statement.keyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.expression, isNotNull);
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, statement.members);
-    EngineTestCase.assertSizeOfList(3, statement.members[0].statements);
+    expect(statement.members, hasLength(1));
+    expect(statement.members[0].statements, hasLength(3));
     expect(statement.rightBracket, isNotNull);
   }
 
   void test_parseSymbolLiteral_builtInIdentifier() {
     SymbolLiteral literal = ParserTestCase.parse4("parseSymbolLiteral", "#dynamic.static.abstract", []);
     expect(literal.poundSign, isNotNull);
     List<Token> components = literal.components;
-    EngineTestCase.assertLength(3, components);
+    expect(components, hasLength(3));
     expect(components[0].lexeme, "dynamic");
     expect(components[1].lexeme, "static");
     expect(components[2].lexeme, "abstract");
   }
 
   void test_parseSymbolLiteral_multiple() {
     SymbolLiteral literal = ParserTestCase.parse4("parseSymbolLiteral", "#a.b.c", []);
     expect(literal.poundSign, isNotNull);
     List<Token> components = literal.components;
-    EngineTestCase.assertLength(3, components);
+    expect(components, hasLength(3));
     expect(components[0].lexeme, "a");
     expect(components[1].lexeme, "b");
     expect(components[2].lexeme, "c");
   }
 
   void test_parseSymbolLiteral_operator() {
     SymbolLiteral literal = ParserTestCase.parse4("parseSymbolLiteral", "#==", []);
     expect(literal.poundSign, isNotNull);
     List<Token> components = literal.components;
-    EngineTestCase.assertLength(1, components);
+    expect(components, hasLength(1));
     expect(components[0].lexeme, "==");
   }
 
   void test_parseSymbolLiteral_single() {
     SymbolLiteral literal = ParserTestCase.parse4("parseSymbolLiteral", "#a", []);
     expect(literal.poundSign, isNotNull);
     List<Token> components = literal.components;
-    EngineTestCase.assertLength(1, components);
+    expect(components, hasLength(1));
     expect(components[0].lexeme, "a");
   }
 
   void test_parseSymbolLiteral_void() {
     SymbolLiteral literal = ParserTestCase.parse4("parseSymbolLiteral", "#void", []);
     expect(literal.poundSign, isNotNull);
     List<Token> components = literal.components;
-    EngineTestCase.assertLength(1, components);
+    expect(components, hasLength(1));
     expect(components[0].lexeme, "void");
   }
 
   void test_parseThrowExpression() {
     ThrowExpression expression = ParserTestCase.parse4("parseThrowExpression", "throw x;", []);
     expect(expression.keyword, isNotNull);
     expect(expression.expression, isNotNull);
   }
 
   void test_parseThrowExpressionWithoutCascade() {
     ThrowExpression expression = ParserTestCase.parse4("parseThrowExpressionWithoutCascade", "throw x;", []);
     expect(expression.keyword, isNotNull);
     expect(expression.expression, isNotNull);
   }
 
   void test_parseTryStatement_catch() {
     TryStatement statement = ParserTestCase.parse4("parseTryStatement", "try {} catch (e) {}", []);
     expect(statement.tryKeyword, isNotNull);
     expect(statement.body, isNotNull);
     NodeList<CatchClause> catchClauses = statement.catchClauses;
-    EngineTestCase.assertSizeOfList(1, catchClauses);
+    expect(catchClauses, hasLength(1));
     CatchClause clause = catchClauses[0];
     expect(clause.onKeyword, isNull);
     expect(clause.exceptionType, isNull);
     expect(clause.catchKeyword, isNotNull);
     expect(clause.exceptionParameter, isNotNull);
     expect(clause.comma, isNull);
     expect(clause.stackTraceParameter, isNull);
     expect(clause.body, isNotNull);
     expect(statement.finallyKeyword, isNull);
     expect(statement.finallyBlock, isNull);
   }
 
   void test_parseTryStatement_catch_finally() {
     TryStatement statement = ParserTestCase.parse4("parseTryStatement", "try {} catch (e, s) {} finally {}", []);
     expect(statement.tryKeyword, isNotNull);
     expect(statement.body, isNotNull);
     NodeList<CatchClause> catchClauses = statement.catchClauses;
-    EngineTestCase.assertSizeOfList(1, catchClauses);
+    expect(catchClauses, hasLength(1));
     CatchClause clause = catchClauses[0];
     expect(clause.onKeyword, isNull);
     expect(clause.exceptionType, isNull);
     expect(clause.catchKeyword, isNotNull);
     expect(clause.exceptionParameter, isNotNull);
     expect(clause.comma, isNotNull);
     expect(clause.stackTraceParameter, isNotNull);
     expect(clause.body, isNotNull);
     expect(statement.finallyKeyword, isNotNull);
     expect(statement.finallyBlock, isNotNull);
   }
 
   void test_parseTryStatement_finally() {
     TryStatement statement = ParserTestCase.parse4("parseTryStatement", "try {} finally {}", []);
     expect(statement.tryKeyword, isNotNull);
     expect(statement.body, isNotNull);
-    EngineTestCase.assertSizeOfList(0, statement.catchClauses);
+    expect(statement.catchClauses, hasLength(0));
     expect(statement.finallyKeyword, isNotNull);
     expect(statement.finallyBlock, isNotNull);
   }
 
   void test_parseTryStatement_multiple() {
     TryStatement statement = ParserTestCase.parse4("parseTryStatement", "try {} on NPE catch (e) {} on Error {} catch (e) {}", []);
     expect(statement.tryKeyword, isNotNull);
     expect(statement.body, isNotNull);
-    EngineTestCase.assertSizeOfList(3, statement.catchClauses);
+    expect(statement.catchClauses, hasLength(3));
     expect(statement.finallyKeyword, isNull);
     expect(statement.finallyBlock, isNull);
   }
 
   void test_parseTryStatement_on() {
     TryStatement statement = ParserTestCase.parse4("parseTryStatement", "try {} on Error {}", []);
     expect(statement.tryKeyword, isNotNull);
     expect(statement.body, isNotNull);
     NodeList<CatchClause> catchClauses = statement.catchClauses;
-    EngineTestCase.assertSizeOfList(1, catchClauses);
+    expect(catchClauses, hasLength(1));
     CatchClause clause = catchClauses[0];
     expect(clause.onKeyword, isNotNull);
     expect(clause.exceptionType, isNotNull);
     expect(clause.catchKeyword, isNull);
     expect(clause.exceptionParameter, isNull);
     expect(clause.comma, isNull);
     expect(clause.stackTraceParameter, isNull);
     expect(clause.body, isNotNull);
     expect(statement.finallyKeyword, isNull);
     expect(statement.finallyBlock, isNull);
   }
 
   void test_parseTryStatement_on_catch() {
     TryStatement statement = ParserTestCase.parse4("parseTryStatement", "try {} on Error catch (e, s) {}", []);
     expect(statement.tryKeyword, isNotNull);
     expect(statement.body, isNotNull);
     NodeList<CatchClause> catchClauses = statement.catchClauses;
-    EngineTestCase.assertSizeOfList(1, catchClauses);
+    expect(catchClauses, hasLength(1));
     CatchClause clause = catchClauses[0];
     expect(clause.onKeyword, isNotNull);
     expect(clause.exceptionType, isNotNull);
     expect(clause.catchKeyword, isNotNull);
     expect(clause.exceptionParameter, isNotNull);
     expect(clause.comma, isNotNull);
     expect(clause.stackTraceParameter, isNotNull);
     expect(clause.body, isNotNull);
     expect(statement.finallyKeyword, isNull);
     expect(statement.finallyBlock, isNull);
   }
 
   void test_parseTryStatement_on_catch_finally() {
     TryStatement statement = ParserTestCase.parse4("parseTryStatement", "try {} on Error catch (e, s) {} finally {}", []);
     expect(statement.tryKeyword, isNotNull);
     expect(statement.body, isNotNull);
     NodeList<CatchClause> catchClauses = statement.catchClauses;
-    EngineTestCase.assertSizeOfList(1, catchClauses);
+    expect(catchClauses, hasLength(1));
     CatchClause clause = catchClauses[0];
     expect(clause.onKeyword, isNotNull);
     expect(clause.exceptionType, isNotNull);
     expect(clause.catchKeyword, isNotNull);
     expect(clause.exceptionParameter, isNotNull);
     expect(clause.comma, isNotNull);
     expect(clause.stackTraceParameter, isNotNull);
     expect(clause.body, isNotNull);
     expect(statement.finallyKeyword, isNotNull);
     expect(statement.finallyBlock, isNotNull);
@@ skipping 55 matching lines @@
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.parameters, isNotNull);
     expect(typeAlias.returnType, isNotNull);
     expect(typeAlias.semicolon, isNotNull);
     expect(typeAlias.typeParameters, isNull);
   }
 
   void test_parseTypeArgumentList_multiple() {
     TypeArgumentList argumentList = ParserTestCase.parse4("parseTypeArgumentList", "<int, int, int>", []);
     expect(argumentList.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(3, argumentList.arguments);
+    expect(argumentList.arguments, hasLength(3));
     expect(argumentList.rightBracket, isNotNull);
   }
 
   void test_parseTypeArgumentList_nested() {
     TypeArgumentList argumentList = ParserTestCase.parse4("parseTypeArgumentList", "<A<B>>", []);
     expect(argumentList.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, argumentList.arguments);
+    expect(argumentList.arguments, hasLength(1));
     TypeName argument = argumentList.arguments[0];
     expect(argument, isNotNull);
     TypeArgumentList innerList = argument.typeArguments;
     expect(innerList, isNotNull);
-    EngineTestCase.assertSizeOfList(1, innerList.arguments);
+    expect(innerList.arguments, hasLength(1));
     expect(argumentList.rightBracket, isNotNull);
   }
 
   void test_parseTypeArgumentList_single() {
     TypeArgumentList argumentList = ParserTestCase.parse4("parseTypeArgumentList", "<int>", []);
     expect(argumentList.leftBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, argumentList.arguments);
+    expect(argumentList.arguments, hasLength(1));
     expect(argumentList.rightBracket, isNotNull);
   }
 
   void test_parseTypeName_parameterized() {
     TypeName typeName = ParserTestCase.parse4("parseTypeName", "List<int>", []);
     expect(typeName.name, isNotNull);
     expect(typeName.typeArguments, isNotNull);
   }
 
   void test_parseTypeName_simple() {
@@ skipping 13 matching lines @@
     TypeParameter parameter = ParserTestCase.parse4("parseTypeParameter", "A", []);
     expect(parameter.bound, isNull);
     expect(parameter.keyword, isNull);
     expect(parameter.name, isNotNull);
   }
 
   void test_parseTypeParameterList_multiple() {
     TypeParameterList parameterList = ParserTestCase.parse4("parseTypeParameterList", "<A, B extends C, D>", []);
     expect(parameterList.leftBracket, isNotNull);
     expect(parameterList.rightBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(3, parameterList.typeParameters);
+    expect(parameterList.typeParameters, hasLength(3));
   }
 
   void test_parseTypeParameterList_parameterizedWithTrailingEquals() {
     TypeParameterList parameterList = ParserTestCase.parse4("parseTypeParameterList", "<A extends B<E>>=", []);
     expect(parameterList.leftBracket, isNotNull);
     expect(parameterList.rightBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, parameterList.typeParameters);
+    expect(parameterList.typeParameters, hasLength(1));
   }
 
   void test_parseTypeParameterList_single() {
     TypeParameterList parameterList = ParserTestCase.parse4("parseTypeParameterList", "<A>", []);
     expect(parameterList.leftBracket, isNotNull);
     expect(parameterList.rightBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, parameterList.typeParameters);
+    expect(parameterList.typeParameters, hasLength(1));
   }
 
   void test_parseTypeParameterList_withTrailingEquals() {
     TypeParameterList parameterList = ParserTestCase.parse4("parseTypeParameterList", "<A>=", []);
     expect(parameterList.leftBracket, isNotNull);
     expect(parameterList.rightBracket, isNotNull);
-    EngineTestCase.assertSizeOfList(1, parameterList.typeParameters);
+    expect(parameterList.typeParameters, hasLength(1));
   }
 
   void test_parseUnaryExpression_decrement_normal() {
     PrefixExpression expression = ParserTestCase.parse4("parseUnaryExpression", "--x", []);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.MINUS_MINUS);
     expect(expression.operand, isNotNull);
   }
 
   void test_parseUnaryExpression_decrement_super() {
@@ skipping 99 matching lines @@
     VariableDeclaration declaration = ParserTestCase.parse4("parseVariableDeclaration", "a", []);
     expect(declaration.name, isNotNull);
     expect(declaration.equals, isNull);
     expect(declaration.initializer, isNull);
   }
 
   void test_parseVariableDeclarationListAfterMetadata_const_noType() {
     VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "const a");
     expect(declarationList.keyword, isNotNull);
     expect(declarationList.type, isNull);
-    EngineTestCase.assertSizeOfList(1, declarationList.variables);
+    expect(declarationList.variables, hasLength(1));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_const_type() {
     VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "const A a");
     expect(declarationList.keyword, isNotNull);
     expect(declarationList.type, isNotNull);
-    EngineTestCase.assertSizeOfList(1, declarationList.variables);
+    expect(declarationList.variables, hasLength(1));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_final_noType() {
     VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "final a");
     expect(declarationList.keyword, isNotNull);
     expect(declarationList.type, isNull);
-    EngineTestCase.assertSizeOfList(1, declarationList.variables);
+    expect(declarationList.variables, hasLength(1));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_final_type() {
     VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "final A a");
     expect(declarationList.keyword, isNotNull);
     expect(declarationList.type, isNotNull);
-    EngineTestCase.assertSizeOfList(1, declarationList.variables);
+    expect(declarationList.variables, hasLength(1));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_type_multiple() {
     VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "A a, b, c");
     expect(declarationList.keyword, isNull);
     expect(declarationList.type, isNotNull);
-    EngineTestCase.assertSizeOfList(3, declarationList.variables);
+    expect(declarationList.variables, hasLength(3));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_type_single() {
     VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "A a");
     expect(declarationList.keyword, isNull);
     expect(declarationList.type, isNotNull);
-    EngineTestCase.assertSizeOfList(1, declarationList.variables);
+    expect(declarationList.variables, hasLength(1));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_var_multiple() {
     VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "var a, b, c");
     expect(declarationList.keyword, isNotNull);
     expect(declarationList.type, isNull);
-    EngineTestCase.assertSizeOfList(3, declarationList.variables);
+    expect(declarationList.variables, hasLength(3));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_var_single() {
     VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "var a");
     expect(declarationList.keyword, isNotNull);
     expect(declarationList.type, isNull);
-    EngineTestCase.assertSizeOfList(1, declarationList.variables);
+    expect(declarationList.variables, hasLength(1));
   }
 
   void test_parseVariableDeclarationListAfterType_type() {
     TypeName type = new TypeName(new SimpleIdentifier(null), null);
     VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterType", <Object> [emptyCommentAndMetadata(), null, type], "a");
     expect(declarationList.keyword, isNull);
     expect(declarationList.type, type);
-    EngineTestCase.assertSizeOfList(1, declarationList.variables);
+    expect(declarationList.variables, hasLength(1));
   }
 
   void test_parseVariableDeclarationListAfterType_var() {
     Token keyword = TokenFactory.tokenFromKeyword(Keyword.VAR);
     VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterType", <Object> [emptyCommentAndMetadata(), keyword, null], "a, b, c");
     expect(declarationList.keyword, keyword);
     expect(declarationList.type, isNull);
-    EngineTestCase.assertSizeOfList(3, declarationList.variables);
+    expect(declarationList.variables, hasLength(3));
   }
 
   void test_parseVariableDeclarationStatementAfterMetadata_multiple() {
     VariableDeclarationStatement statement = ParserTestCase.parse("parseVariableDeclarationStatementAfterMetadata", <Object> [emptyCommentAndMetadata()], "var x, y, z;");
     expect(statement.semicolon, isNotNull);
     VariableDeclarationList variableList = statement.variables;
     expect(variableList, isNotNull);
-    EngineTestCase.assertSizeOfList(3, variableList.variables);
+    expect(variableList.variables, hasLength(3));
   }
 
   void test_parseVariableDeclarationStatementAfterMetadata_single() {
     VariableDeclarationStatement statement = ParserTestCase.parse("parseVariableDeclarationStatementAfterMetadata", <Object> [emptyCommentAndMetadata()], "var x;");
     expect(statement.semicolon, isNotNull);
     VariableDeclarationList variableList = statement.variables;
     expect(variableList, isNotNull);
-    EngineTestCase.assertSizeOfList(1, variableList.variables);
+    expect(variableList.variables, hasLength(1));
   }
 
   void test_parseWhileStatement() {
     WhileStatement statement = ParserTestCase.parse4("parseWhileStatement", "while (x) {}", []);
     expect(statement.keyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.condition, isNotNull);
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
   void test_parseWithClause_multiple() {
     WithClause clause = ParserTestCase.parse4("parseWithClause", "with A, B, C", []);
     expect(clause.withKeyword, isNotNull);
-    EngineTestCase.assertSizeOfList(3, clause.mixinTypes);
+    expect(clause.mixinTypes, hasLength(3));
   }
 
   void test_parseWithClause_single() {
     WithClause clause = ParserTestCase.parse4("parseWithClause", "with M", []);
     expect(clause.withKeyword, isNotNull);
-    EngineTestCase.assertSizeOfList(1, clause.mixinTypes);
+    expect(clause.mixinTypes, hasLength(1));
   }
 
   void test_parseYieldStatement_each() {
     YieldStatement statement = ParserTestCase.parse4("parseYieldStatement", "yield* x;", []);
     expect(statement.yieldKeyword, isNotNull);
     expect(statement.star, isNotNull);
     expect(statement.expression, isNotNull);
     expect(statement.semicolon, isNotNull);
   }
 
@@ skipping 225 matching lines @@
    *           not match those that are expected, or if the result would have been `null`
    */
   CompilationUnit _parseDirectives(String source, List<ErrorCode> errorCodes) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scanner scanner = new Scanner(null, new CharSequenceReader(source), listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     CompilationUnit unit = parser.parseDirectives(token);
     expect(unit, isNotNull);
-    EngineTestCase.assertSizeOfList(0, unit.declarations);
+    expect(unit.declarations, hasLength(0));
     listener.assertErrorsWithCodes(errorCodes);
     return unit;
   }
 
   /**
    * Invoke a "skip" method in [Parser]. The method is assumed to take a token as it's
    * parameter and is given the first token in the scanned source.
    *
    * @param methodName the name of the method that should be invoked
    * @param source the source to be processed by the method
@@ skipping 19 matching lines @@
 main() {
   groupSep = ' | ';
   runReflectiveTests(ComplexParserTest);
   runReflectiveTests(ErrorParserTest);
   runReflectiveTests(IncrementalParserTest);
   runReflectiveTests(NonErrorParserTest);
   runReflectiveTests(RecoveryParserTest);
   runReflectiveTests(ResolutionCopierTest);
   runReflectiveTests(SimpleParserTest);
 }