Replace EngineTestCase.assertSize() with hasLength().

pkg/analyzer/test/generated/utilities_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.utilities_test;
 
 import 'dart:collection';
@@ skipping 2211 matching lines @@
     DirectedGraphTest_Node node5 = new DirectedGraphTest_Node();
     DirectedGraph<DirectedGraphTest_Node> graph =
         new DirectedGraph<DirectedGraphTest_Node>();
     graph.addEdge(node1, node2);
     graph.addEdge(node2, node3);
     graph.addEdge(node3, node1);
     graph.addEdge(node3, node4);
     graph.addEdge(node4, node5);
     graph.addEdge(node5, node3);
     List<DirectedGraphTest_Node> cycle = graph.findCycleContaining(node1);
-    EngineTestCase.assertSizeOfList(5, cycle);
+    expect(cycle, hasLength(5));
     expect(cycle.contains(node1), isTrue);
     expect(cycle.contains(node2), isTrue);
     expect(cycle.contains(node3), isTrue);
     expect(cycle.contains(node4), isTrue);
     expect(cycle.contains(node5), isTrue);
   }
 
   void test_findCycleContaining_cycle() {
     DirectedGraphTest_Node node1 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node2 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node3 = new DirectedGraphTest_Node();
     DirectedGraph<DirectedGraphTest_Node> graph =
         new DirectedGraph<DirectedGraphTest_Node>();
     graph.addEdge(node1, node2);
     graph.addEdge(node2, node3);
     graph.addEdge(node2, new DirectedGraphTest_Node());
     graph.addEdge(node3, node1);
     graph.addEdge(node3, new DirectedGraphTest_Node());
     List<DirectedGraphTest_Node> cycle = graph.findCycleContaining(node1);
-    EngineTestCase.assertSizeOfList(3, cycle);
+    expect(cycle, hasLength(3));
     expect(cycle.contains(node1), isTrue);
     expect(cycle.contains(node2), isTrue);
     expect(cycle.contains(node3), isTrue);
   }
 
   void test_findCycleContaining_notInGraph() {
     DirectedGraphTest_Node node = new DirectedGraphTest_Node();
     DirectedGraph<DirectedGraphTest_Node> graph =
         new DirectedGraph<DirectedGraphTest_Node>();
     List<DirectedGraphTest_Node> cycle = graph.findCycleContaining(node);
-    EngineTestCase.assertSizeOfList(1, cycle);
+    expect(cycle, hasLength(1));
     expect(cycle[0], node);
   }
 
   void test_findCycleContaining_null() {
     DirectedGraph<DirectedGraphTest_Node> graph =
         new DirectedGraph<DirectedGraphTest_Node>();
     try {
       graph.findCycleContaining(null);
       fail("Expected IllegalArgumentException");
     } on IllegalArgumentException catch (exception) {
       // Expected
     }
   }
 
   void test_findCycleContaining_singleton() {
     DirectedGraphTest_Node node1 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node2 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node3 = new DirectedGraphTest_Node();
     DirectedGraph<DirectedGraphTest_Node> graph =
         new DirectedGraph<DirectedGraphTest_Node>();
     graph.addEdge(node1, node2);
     graph.addEdge(node2, node3);
     List<DirectedGraphTest_Node> cycle = graph.findCycleContaining(node1);
-    EngineTestCase.assertSizeOfList(1, cycle);
+    expect(cycle, hasLength(1));
     expect(cycle[0], node1);
   }
 
   void test_getNodeCount() {
     DirectedGraphTest_Node node1 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node2 = new DirectedGraphTest_Node();
     DirectedGraph<DirectedGraphTest_Node> graph =
         new DirectedGraph<DirectedGraphTest_Node>();
     expect(graph.nodeCount, 0);
     graph.addNode(node1);
     expect(graph.nodeCount, 1);
     graph.addNode(node2);
     expect(graph.nodeCount, 2);
     graph.removeNode(node1);
     expect(graph.nodeCount, 1);
   }
 
   void test_getTails() {
     DirectedGraphTest_Node node1 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node2 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node3 = new DirectedGraphTest_Node();
     DirectedGraph<DirectedGraphTest_Node> graph =
         new DirectedGraph<DirectedGraphTest_Node>();
-    EngineTestCase.assertSizeOfSet(0, graph.getTails(node1));
+    expect(graph.getTails(node1), hasLength(0));
     graph.addEdge(node1, node2);
-    EngineTestCase.assertSizeOfSet(1, graph.getTails(node1));
+    expect(graph.getTails(node1), hasLength(1));
     graph.addEdge(node1, node3);
-    EngineTestCase.assertSizeOfSet(2, graph.getTails(node1));
+    expect(graph.getTails(node1), hasLength(2));
   }
 
   void test_removeAllNodes() {
     DirectedGraphTest_Node node1 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node2 = new DirectedGraphTest_Node();
     List<DirectedGraphTest_Node> nodes = new List<DirectedGraphTest_Node>();
     nodes.add(node1);
     nodes.add(node2);
     DirectedGraph<DirectedGraphTest_Node> graph =
         new DirectedGraph<DirectedGraphTest_Node>();
     graph.addEdge(node1, node2);
     graph.addEdge(node2, node1);
     expect(graph.isEmpty, isFalse);
     graph.removeAllNodes(nodes);
     expect(graph.isEmpty, isTrue);
   }
 
   void test_removeEdge() {
     DirectedGraphTest_Node node1 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node2 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node3 = new DirectedGraphTest_Node();
     DirectedGraph<DirectedGraphTest_Node> graph =
         new DirectedGraph<DirectedGraphTest_Node>();
     graph.addEdge(node1, node2);
     graph.addEdge(node1, node3);
-    EngineTestCase.assertSizeOfSet(2, graph.getTails(node1));
+    expect(graph.getTails(node1), hasLength(2));
     graph.removeEdge(node1, node2);
-    EngineTestCase.assertSizeOfSet(1, graph.getTails(node1));
+    expect(graph.getTails(node1), hasLength(1));
   }
 
   void test_removeNode() {
     DirectedGraphTest_Node node1 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node2 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node3 = new DirectedGraphTest_Node();
     DirectedGraph<DirectedGraphTest_Node> graph =
         new DirectedGraph<DirectedGraphTest_Node>();
     graph.addEdge(node1, node2);
     graph.addEdge(node1, node3);
-    EngineTestCase.assertSizeOfSet(2, graph.getTails(node1));
+    expect(graph.getTails(node1), hasLength(2));
     graph.removeNode(node2);
-    EngineTestCase.assertSizeOfSet(1, graph.getTails(node1));
+    expect(graph.getTails(node1), hasLength(1));
   }
 
   void test_removeSink() {
     DirectedGraphTest_Node node1 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node2 = new DirectedGraphTest_Node();
     DirectedGraph<DirectedGraphTest_Node> graph =
         new DirectedGraph<DirectedGraphTest_Node>();
     graph.addEdge(node1, node2);
     expect(graph.removeSink(), same(node2));
     expect(graph.removeSink(), same(node1));
     expect(graph.isEmpty, isTrue);
   }
 
   void test_topologicalSort_noCycles() {
     DirectedGraphTest_Node node1 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node2 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node3 = new DirectedGraphTest_Node();
     DirectedGraph<DirectedGraphTest_Node> graph =
         new DirectedGraph<DirectedGraphTest_Node>();
     graph.addEdge(node1, node2);
     graph.addEdge(node1, node3);
     graph.addEdge(node2, node3);
     List<List<DirectedGraphTest_Node>> topologicalSort =
         graph.computeTopologicalSort();
-    EngineTestCase.assertSizeOfList(3, topologicalSort);
-    EngineTestCase.assertSizeOfList(1, topologicalSort[0]);
+    expect(topologicalSort, hasLength(3));
+    expect(topologicalSort[0], hasLength(1));
     expect(topologicalSort[0][0], node3);
-    EngineTestCase.assertSizeOfList(1, topologicalSort[1]);
+    expect(topologicalSort[1], hasLength(1));
     expect(topologicalSort[1][0], node2);
-    EngineTestCase.assertSizeOfList(1, topologicalSort[2]);
+    expect(topologicalSort[2], hasLength(1));
     expect(topologicalSort[2][0], node1);
   }
 
   void test_topologicalSort_withCycles() {
     DirectedGraphTest_Node node1 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node2 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node3 = new DirectedGraphTest_Node();
     DirectedGraphTest_Node node4 = new DirectedGraphTest_Node();
     DirectedGraph<DirectedGraphTest_Node> graph =
         new DirectedGraph<DirectedGraphTest_Node>();
     graph.addEdge(node1, node2);
     graph.addEdge(node2, node1);
     graph.addEdge(node1, node3);
     graph.addEdge(node3, node4);
     graph.addEdge(node4, node3);
     List<List<DirectedGraphTest_Node>> topologicalSort =
         graph.computeTopologicalSort();
-    EngineTestCase.assertSizeOfList(2, topologicalSort);
+    expect(topologicalSort, hasLength(2));
     EngineTestCase.assertContains(topologicalSort[0], [node3, node4]);
     EngineTestCase.assertContains(topologicalSort[1], [node1, node2]);
   }
 }
 
 /**
  * Instances of the class `Node` represent simple nodes used for testing purposes.
  */
 class DirectedGraphTest_Node {
 }
@@ skipping 2884 matching lines @@
   }
 
   void test_get_added() {
     TokenMap tokenMap = new TokenMap();
     Token key = TokenFactory.tokenFromType(TokenType.AT);
     Token value = TokenFactory.tokenFromType(TokenType.AT);
     tokenMap.put(key, value);
     expect(tokenMap.get(key), same(value));
   }
 }