Replace custom EngineTestCase.assertEquals() with 'unorderedEquals'.

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';
-import "dart:math" as math;
 
 import 'package:analyzer/src/generated/ast.dart' show AstNode, NodeLocator;
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
-import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:unittest/unittest.dart';
 
 
 /**
  * The class `EngineTestCase` defines utility methods for making assertions.
  */
 class EngineTestCase {
   void setUp() {}
 
@@ skipping 65 matching lines @@
     for (MethodElement method in type.element.methods) {
       if (method.name == methodName) {
         return method;
       }
     }
     fail("Could not find method named $methodName in ${type.displayName}");
     return null;
   }
 
   /**
-   * 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) {
-    int expectedSize = expectedElements.length;
-    if (array == null) {
-      fail("Expected array of length $expectedSize; found null");
-    }
-    if (array.length != expectedSize) {
-      fail("Expected array of length $expectedSize; contained ${array.length} elements");
-    }
-    List<bool> found = new List<bool>.filled(expectedSize, false);
-    for (int i = 0; i < expectedSize; i++) {
-      _privateAssertContains(array, found, expectedElements[i]);
-    }
-  }
-
-  /**
-   * Assert that the array of actual values contain exactly the same values as those in the array of
-   * expected value, with the exception that the order of the elements is not required to be the
-   * same.
-   *
-   * @param expectedValues the values that are expected to be found
-   * @param actualValues the actual values that are being compared against the expected values
-   */
-  static void assertEqualsIgnoreOrder(List<Object> expectedValues,
-      List<Object> actualValues) {
-    expect(actualValues, isNotNull);
-    int expectedLength = expectedValues.length;
-    expect(actualValues.length, expectedLength);
-    List<bool> found = new List<bool>.filled(expectedLength, false);
-    for (int i = 0; i < expectedLength; i++) {
-      found[i] = false;
-    }
-    for (Object actualValue in actualValues) {
-      bool wasExpected = false;
-      for (int i = 0; i < expectedLength; i++) {
-        if (!found[i] && expectedValues[i] == actualValue) {
-          found[i] = true;
-          wasExpected = true;
-          break;
-        }
-      }
-      if (!wasExpected) {
-        fail("The actual value $actualValue was not expected");
-      }
-    }
-  }
-
-  /**
    * Assert that the given object is an instance of the expected class.
    *
    * @param expectedClass the class that the object is expected to be an instance of
    * @param object the object being tested
    * @return the object that was being tested
    * @throws Exception if the object is not an instance of the expected class
    */
   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;
   }
 
   /**
    * @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'.");
     }
     AstNode node = new NodeLocator.con1(offset).searchWithin(root);
     return node.getAncestor(predicate);
   }
-
-  static void _privateAssertContains(List<Object> array, List<bool> found,
-      Object element) {
-    if (element == null) {
-      for (int i = 0; i < array.length; i++) {
-        if (!found[i]) {
-          if (array[i] == null) {
-            found[i] = true;
-            return;
-          }
-        }
-      }
-      fail("Does not contain null");
-    } else {
-      for (int i = 0; i < array.length; i++) {
-        if (!found[i]) {
-          if (element == array[i]) {
-            found[i] = true;
-            return;
-          }
-        }
-      }
-      fail("Does not contain $element");
-    }
-  }
 }
 
 /**
  * Instances of the class `GatheringErrorListener` implement an error listener that collects
  * all of the errors passed to it for later examination.
  */
 class GatheringErrorListener implements AnalysisErrorListener {
   /**
    * An empty array of errors used when no errors are expected.
    */
@@ skipping 498 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);
   }
 }