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

pkg/analyzer/test/generated/resolver_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.
 
 library engine.resolver_test;
 
 import 'dart:collection';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
@@ skipping 318 matching lines @@
   TestSource source2 = new TestSource('/2.dart');
   TestSource source3 = new TestSource('/3.dart');
 
   void test_getAddedSources() {
     AnalysisDelta delta = new AnalysisDelta();
     delta.setAnalysisLevel(source1, AnalysisLevel.ALL);
     delta.setAnalysisLevel(source2, AnalysisLevel.ERRORS);
     delta.setAnalysisLevel(source3, AnalysisLevel.NONE);
     List<Source> addedSources = delta.addedSources;
     expect(addedSources, hasLength(2));
-    EngineTestCase.assertContains(addedSources, [source1, source2]);
+    expect(addedSources, unorderedEquals([source1, source2]));
   }
 
   void test_getAnalysisLevels() {
     AnalysisDelta delta = new AnalysisDelta();
     expect(delta.analysisLevels.length, 0);
   }
 
   void test_setAnalysisLevel() {
     AnalysisDelta delta = new AnalysisDelta();
     delta.setAnalysisLevel(source1, AnalysisLevel.ALL);
@@ skipping 3901 matching lines @@
 
   void test_lookupOverrides_overrideBaseClass() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElementImpl methodMinA = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodMinA];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     MethodElementImpl methodMinB = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classB.methods = <MethodElement> [methodMinB];
     List<ExecutableElement> overrides = _inheritanceManager.lookupOverrides(classB, methodName);
-    EngineTestCase.assertEqualsIgnoreOrder(<Object> [methodMinA], overrides);
+    expect(overrides, unorderedEquals([methodMinA]));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupOverrides_overrideInterface() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElementImpl methodMinA = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodMinA];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
     MethodElementImpl methodMinB = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classB.methods = <MethodElement> [methodMinB];
     List<ExecutableElement> overrides = _inheritanceManager.lookupOverrides(classB, methodName);
-    EngineTestCase.assertEqualsIgnoreOrder(<Object> [methodMinA], overrides);
+    expect(overrides, unorderedEquals([methodMinA]));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupOverrides_overrideTwoInterfaces() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElementImpl methodMinA = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodMinA];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     MethodElementImpl methodMinB = ElementFactory.methodElement(methodName, _typeProvider.doubleType, []);
     classB.methods = <MethodElement> [methodMinB];
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     classC.interfaces = <InterfaceType> [classA.type, classB.type];
     MethodElementImpl methodMinC = ElementFactory.methodElement(methodName, _typeProvider.numType, []);
     classC.methods = <MethodElement> [methodMinC];
     List<ExecutableElement> overrides = _inheritanceManager.lookupOverrides(classC, methodName);
-    EngineTestCase.assertEqualsIgnoreOrder(<Object> [methodMinA, methodMinB], overrides);
+    expect(overrides, unorderedEquals([methodMinA, methodMinB]));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
     _assertNoErrors(classC);
   }
 
   void _assertErrors(ClassElement classElt, List<ErrorCode> expectedErrorCodes) {
     GatheringErrorListener errorListener = new GatheringErrorListener();
     HashSet<AnalysisError> actualErrors = _inheritanceManager.getErrors(classElt);
     if (actualErrors != null) {
       for (AnalysisError error in actualErrors) {
@@ skipping 4866 matching lines @@
     // class A extends B
     // class B extends A
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     classA.supertype = classB.type;
     _definingCompilationUnit.types = <ClassElement> [classA, classB];
     HashSet<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
     expect(subtypesOfA, hasLength(2));
-    EngineTestCase.assertContains(arraySubtypesOfA, [classA, classB]);
+    expect(arraySubtypesOfA, unorderedEquals([classA, classB]));
   }
 
   void test_computeAllSubtypes_manyRecursiveSubtypes() {
     //
     // class A
     // class B extends A
     // class C extends B
     // class D extends B
     // class E extends B
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     ClassElementImpl classC = ElementFactory.classElement("C", classB.type, []);
     ClassElementImpl classD = ElementFactory.classElement("D", classB.type, []);
     ClassElementImpl classE = ElementFactory.classElement("E", classB.type, []);
     _definingCompilationUnit.types = <ClassElement> [classA, classB, classC, classD, classE];
     HashSet<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
     HashSet<ClassElement> subtypesOfB = _subtypeManager.computeAllSubtypes(classB);
     List<ClassElement> arraySubtypesOfB = new List.from(subtypesOfB);
     expect(subtypesOfA, hasLength(4));
-    EngineTestCase.assertContains(arraySubtypesOfA, [classB, classC, classD, classE]);
+    expect(arraySubtypesOfA, unorderedEquals([classB, classC, classD, classE]));
     expect(subtypesOfB, hasLength(3));
-    EngineTestCase.assertContains(arraySubtypesOfB, [classC, classD, classE]);
+    expect(arraySubtypesOfB, unorderedEquals([classC, classD, classE]));
   }
 
   void test_computeAllSubtypes_noSubtypes() {
     //
     // class A
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     _definingCompilationUnit.types = <ClassElement> [classA];
     HashSet<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     expect(subtypesOfA, hasLength(0));
   }
 
   void test_computeAllSubtypes_oneSubtype() {
     //
     // class A
     // class B extends A
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     _definingCompilationUnit.types = <ClassElement> [classA, classB];
     HashSet<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
     expect(subtypesOfA, hasLength(1));
-    EngineTestCase.assertContains(arraySubtypesOfA, [classB]);
+    expect(arraySubtypesOfA, unorderedEquals([classB]));
   }
 
   @override
   void setUp() {
     super.setUp();
     AnalysisContextImpl context = AnalysisContextFactory.contextWithCore();
     FileBasedSource source = new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
     _definingCompilationUnit = new CompilationUnitElementImpl("test.dart");
     _definingCompilationUnit.source = source;
     LibraryElementImpl definingLibrary = ElementFactory.library(context, "test");
@@ skipping 2250 matching lines @@
   runReflectiveTests(TypeResolverVisitorTest);
   runReflectiveTests(CheckedModeCompileTimeErrorCodeTest);
   runReflectiveTests(ErrorResolverTest);
   runReflectiveTests(HintCodeTest);
   runReflectiveTests(MemberMapTest);
   runReflectiveTests(NonHintCodeTest);
   runReflectiveTests(SimpleResolverTest);
   runReflectiveTests(StrictModeTest);
   runReflectiveTests(TypePropagationTest);
 }