Replace EngineTestCase.assertSize() with hasLength().

pkg/analyzer/test/generated/ast_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.ast_test;
 
 import 'package:analyzer/src/generated/java_core.dart';
@@ skipping 64 matching lines @@
   if ((p as A).g) {
     return p;
   } else {
     return null;
   }
 }''';
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(source, []);
     List<AstNode> nodes = new List<AstNode>();
     BreadthFirstVisitor<Object> visitor = new BreadthFirstVisitor_BreadthFirstVisitorTest_testIt(nodes);
     visitor.visitAllNodes(unit);
-    EngineTestCase.assertSizeOfList(59, nodes);
+    expect(nodes, hasLength(59));
     EngineTestCase.assertInstanceOf((obj) => obj is CompilationUnit, CompilationUnit, nodes[0]);
     EngineTestCase.assertInstanceOf((obj) => obj is ClassDeclaration, ClassDeclaration, nodes[2]);
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionDeclaration, FunctionDeclaration, nodes[3]);
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionDeclarationStatement, FunctionDeclarationStatement, nodes[27]);
     EngineTestCase.assertInstanceOf((obj) => obj is IntegerLiteral, IntegerLiteral, nodes[58]);
     //3
   }
 }
 
 class BreadthFirstVisitor_BreadthFirstVisitorTest_testIt extends BreadthFirstVisitor<Object> {
@@ skipping 459 matching lines @@
 }
 
 class NodeListTest extends EngineTestCase {
   void test_add() {
     AstNode parent = AstFactory.argumentList([]);
     AstNode firstNode = AstFactory.booleanLiteral(true);
     AstNode secondNode = AstFactory.booleanLiteral(false);
     NodeList<AstNode> list = new NodeList<AstNode>(parent);
     list.insert(0, secondNode);
     list.insert(0, firstNode);
-    EngineTestCase.assertSizeOfList(2, list);
+    expect(list, hasLength(2));
     expect(list[0], same(firstNode));
     expect(list[1], same(secondNode));
     expect(firstNode.parent, same(parent));
     expect(secondNode.parent, same(parent));
     AstNode thirdNode = AstFactory.booleanLiteral(false);
     list.insert(1, thirdNode);
-    EngineTestCase.assertSizeOfList(3, list);
+    expect(list, hasLength(3));
     expect(list[0], same(firstNode));
     expect(list[1], same(thirdNode));
     expect(list[2], same(secondNode));
     expect(firstNode.parent, same(parent));
     expect(secondNode.parent, same(parent));
     expect(thirdNode.parent, same(parent));
   }
 
   void test_add_negative() {
     NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList([]));
@@ skipping 17 matching lines @@
 
   void test_addAll() {
     AstNode parent = AstFactory.argumentList([]);
     List<AstNode> firstNodes = new List<AstNode>();
     AstNode firstNode = AstFactory.booleanLiteral(true);
     AstNode secondNode = AstFactory.booleanLiteral(false);
     firstNodes.add(firstNode);
     firstNodes.add(secondNode);
     NodeList<AstNode> list = new NodeList<AstNode>(parent);
     list.addAll(firstNodes);
-    EngineTestCase.assertSizeOfList(2, list);
+    expect(list, hasLength(2));
     expect(list[0], same(firstNode));
     expect(list[1], same(secondNode));
     expect(firstNode.parent, same(parent));
     expect(secondNode.parent, same(parent));
     List<AstNode> secondNodes = new List<AstNode>();
     AstNode thirdNode = AstFactory.booleanLiteral(true);
     AstNode fourthNode = AstFactory.booleanLiteral(false);
     secondNodes.add(thirdNode);
     secondNodes.add(fourthNode);
     list.addAll(secondNodes);
-    EngineTestCase.assertSizeOfList(4, list);
+    expect(list, hasLength(4));
     expect(list[0], same(firstNode));
     expect(list[1], same(secondNode));
     expect(list[2], same(thirdNode));
     expect(list[3], same(fourthNode));
     expect(firstNode.parent, same(parent));
     expect(secondNode.parent, same(parent));
     expect(thirdNode.parent, same(parent));
     expect(fourthNode.parent, same(parent));
   }
 
   void test_create() {
     AstNode owner = AstFactory.argumentList([]);
     NodeList<AstNode> list = NodeList.create(owner);
     expect(list, isNotNull);
-    EngineTestCase.assertSizeOfList(0, list);
+    expect(list, hasLength(0));
     expect(list.owner, same(owner));
   }
 
   void test_creation() {
     AstNode owner = AstFactory.argumentList([]);
     NodeList<AstNode> list = new NodeList<AstNode>(owner);
     expect(list, isNotNull);
-    EngineTestCase.assertSizeOfList(0, list);
+    expect(list, hasLength(0));
     expect(list.owner, same(owner));
   }
 
   void test_get_negative() {
     NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList([]));
     try {
       list[-1];
       fail("Expected IndexOutOfBoundsException");
     } on RangeError catch (exception) {
       // Expected
@@ skipping 38 matching lines @@
     List<AstNode> nodes = new List<AstNode>();
     AstNode firstNode = AstFactory.booleanLiteral(true);
     AstNode secondNode = AstFactory.booleanLiteral(false);
     AstNode thirdNode = AstFactory.booleanLiteral(true);
     AstNode fourthNode = AstFactory.booleanLiteral(false);
     nodes.add(firstNode);
     nodes.add(secondNode);
     nodes.add(thirdNode);
     NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList([]));
     list.addAll(nodes);
-    EngineTestCase.assertSizeOfList(3, list);
+    expect(list, hasLength(3));
     expect(list.indexOf(firstNode), 0);
     expect(list.indexOf(secondNode), 1);
     expect(list.indexOf(thirdNode), 2);
     expect(list.indexOf(fourthNode), -1);
     expect(list.indexOf(null), -1);
   }
 
   void test_remove() {
     List<AstNode> nodes = new List<AstNode>();
     AstNode firstNode = AstFactory.booleanLiteral(true);
     AstNode secondNode = AstFactory.booleanLiteral(false);
     AstNode thirdNode = AstFactory.booleanLiteral(true);
     nodes.add(firstNode);
     nodes.add(secondNode);
     nodes.add(thirdNode);
     NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList([]));
     list.addAll(nodes);
-    EngineTestCase.assertSizeOfList(3, list);
+    expect(list, hasLength(3));
     expect(list.removeAt(1), same(secondNode));
-    EngineTestCase.assertSizeOfList(2, list);
+    expect(list, hasLength(2));
     expect(list[0], same(firstNode));
     expect(list[1], same(thirdNode));
   }
 
   void test_remove_negative() {
     NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList([]));
     try {
       list.removeAt(-1);
       fail("Expected IndexOutOfBoundsException");
     } on RangeError catch (exception) {
@@ skipping 14 matching lines @@
   void test_set() {
     List<AstNode> nodes = new List<AstNode>();
     AstNode firstNode = AstFactory.booleanLiteral(true);
     AstNode secondNode = AstFactory.booleanLiteral(false);
     AstNode thirdNode = AstFactory.booleanLiteral(true);
     nodes.add(firstNode);
     nodes.add(secondNode);
     nodes.add(thirdNode);
     NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList([]));
     list.addAll(nodes);
-    EngineTestCase.assertSizeOfList(3, list);
+    expect(list, hasLength(3));
     AstNode fourthNode = AstFactory.integer(0);
     expect(javaListSet(list, 1, fourthNode), same(secondNode));
-    EngineTestCase.assertSizeOfList(3, list);
+    expect(list, hasLength(3));
     expect(list[0], same(firstNode));
     expect(list[1], same(fourthNode));
     expect(list[2], same(thirdNode));
   }
 
   void test_set_negative() {
     AstNode node = AstFactory.booleanLiteral(true);
     NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList([]));
     try {
       javaListSet(list, -1, node);
@@ skipping 1838 matching lines @@
   runReflectiveTests(BreadthFirstVisitorTest);
   runReflectiveTests(ClassDeclarationTest);
   runReflectiveTests(ClassTypeAliasTest);
   runReflectiveTests(IndexExpressionTest);
   runReflectiveTests(NodeListTest);
   runReflectiveTests(SimpleIdentifierTest);
   runReflectiveTests(SimpleStringLiteralTest);
   runReflectiveTests(StringInterpolationTest);
   runReflectiveTests(VariableDeclarationTest);
 }