Replace EngineTestCase.assertSize() with hasLength().

pkg/analyzer/test/generated/test_support.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.test_support;
 
 import 'dart:collection';
@@ skipping 42 matching lines @@
         buffer.write("Expected element named: ");
         buffer.write(elemName);
         buffer.write("\n  but found: ");
         for (Element elem in elements) {
           buffer.write(elem.name);
           buffer.write(", ");
         }
         fail(buffer.toString());
       }
     }
-    assertLength(names.length, elements);
+    expect(elements, hasLength(names.length));
   }
 
   AnalysisContextImpl createAnalysisContext() {
     AnalysisContextImpl context = new AnalysisContextImpl();
     context.sourceFactory = new SourceFactory([]);
     return context;
   }
 
   /**
    * Return the getter in the given type with the given name. Inherited getters are ignored.
@@ skipping 42 matching lines @@
     Token left = expectedStream;
     Token right = actualStream;
     while (left.type != TokenType.EOF && right.type != TokenType.EOF) {
       assertMatches(left, right);
       left = left.next;
       right = right.next;
     }
   }
 
   /**
-   * Assert that the given collection is non-`null` and has the expected number of elements.
-   *
-   * @param expectedSize the expected number of elements
-   * @param c the collection being tested
-   * @throws AssertionFailedError if the list is `null` or does not have the expected number
-   *           of elements
-   */
-  static void assertCollectionSize(int expectedSize, Iterable c) {
-    if (c == null) {
-      fail("Expected collection of size $expectedSize; found null");
-    } else if (c.length != expectedSize) {
-      fail("Expected collection of size $expectedSize; contained ${c.length} elements");
-    }
-  }
-
-  /**
    * Assert that the given array is non-`null` and contains the expected elements. The
    * elements can appear in any order.
    *
    * @param array the array being tested
    * @param expectedElements the expected elements
    * @throws AssertionFailedError if the array is `null` or does not contain the expected
    *           elements
    */
   static void assertContains(List<Object> array,
       List<Object> expectedElements) {
@@ skipping 156 matching lines @@
    */
   static Object assertInstanceOf(Predicate<Object> predicate,
       Type expectedClass, Object object) {
     if (!predicate(object)) {
       fail("Expected instance of $expectedClass, found ${object == null ? "null" : object.runtimeType}");
     }
     return object;
   }
 
   /**
-   * Assert that the given array is non-`null` and has the expected number of elements.
-   *
-   * @param expectedLength the expected number of elements
-   * @param array the array being tested
-   * @throws AssertionFailedError if the array is `null` or does not have the expected number
-   *           of elements
-   */
-  static void assertLength(int expectedLength, List<Object> array) {
-    if (array == null) {
-      fail("Expected array of length $expectedLength; found null");
-    } else if (array.length != expectedLength) {
-      fail("Expected array of length $expectedLength; contained ${array.length} elements");
-    }
-  }
-
-  /**
    * Assert that the actual token has the same type and lexeme as the expected token. Note that this
    * does not assert anything about the offsets of the tokens (although the lengths will be equal).
    *
    * @param expectedToken the token that was expected
    * @param actualToken the token that was found
    * @throws AssertionFailedError if the two tokens are not the same
    */
   static void assertMatches(Token expectedToken, Token actualToken) {
     expect(actualToken.type, expectedToken.type);
     if (expectedToken is KeywordToken) {
       assertInstanceOf((obj) => obj is KeywordToken, KeywordToken, actualToken);
       expect((actualToken as KeywordToken).keyword, expectedToken.keyword);
     } else if (expectedToken is StringToken) {
       assertInstanceOf((obj) => obj is StringToken, StringToken, actualToken);
       expect((actualToken as StringToken).lexeme, expectedToken.lexeme);
     }
   }
 
-  /**
-   * Assert that the given list is non-`null` and has the expected number of elements.
-   *
-   * @param expectedSize the expected number of elements
-   * @param list the list being tested
-   * @throws AssertionFailedError if the list is `null` or does not have the expected number
-   *           of elements
-   */
-  static void assertSizeOfList(int expectedSize, List list) {
-    if (list == null) {
-      fail("Expected list of size $expectedSize; found null");
-    } else if (list.length != expectedSize) {
-      fail("Expected list of size $expectedSize; contained ${list.length} elements");
-    }
-  }
-
-  /**
-   * Assert that the given map is non-`null` and has the expected number of elements.
-   *
-   * @param expectedSize the expected number of elements
-   * @param map the map being tested
-   * @throws AssertionFailedError if the map is `null` or does not have the expected number of
-   *           elements
-   */
-  static void assertSizeOfMap(int expectedSize, Map map) {
-    if (map == null) {
-      fail("Expected map of size $expectedSize; found null");
-    } else if (map.length != expectedSize) {
-      fail("Expected map of size $expectedSize; contained ${map.length} elements");
-    }
-  }
-
-  /**
-   * Assert that the given set is non-`null` and has the expected number of elements.
-   *
-   * @param expectedSize the expected number of elements
-   * @param set the set being tested
-   * @throws AssertionFailedError if the set is `null` or does not have the expected number of
-   *           elements
-   */
-  static void assertSizeOfSet(int expectedSize, Set set) {
-    if (set == null) {
-      fail("Expected set of size $expectedSize; found null");
-    } else if (set.length != expectedSize) {
-      fail("Expected set of size $expectedSize; contained ${set.length} elements");
-    }
-  }
 
   /**
    * @return the [AstNode] with requested type at offset of the "prefix".
    */
   static AstNode findNode(AstNode root, String code, String prefix,
       Predicate<AstNode> predicate) {
     int offset = code.indexOf(prefix);
     if (offset == -1) {
       throw new IllegalArgumentException("Not found '$prefix'.");
     }
@@ skipping 558 matching lines @@
   void getContentsToReceiver(Source_ContentReceiver receiver) {
     throw new UnsupportedOperationException();
   }
   Source resolve(String uri) {
     throw new UnsupportedOperationException();
   }
   Uri resolveRelativeUri(Uri uri) {
     return new Uri(scheme: 'file', path: _name).resolveUri(uri);
   }
 }