Compare error names in strong_mode_test ignoring order.

pkg/analyzer/test/generated/strong_mode_test.dart

 // Copyright (c) 2016, 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 analyzer.test.generated.strong_mode_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 1777 matching lines @@
   String f/*<S>*/(/*=S*/ x) => null;
 }''');
     // TODO(jmesserly): we can't use assertErrors because STRONG_MODE_* errors
     // from CodeChecker don't have working equality.
     List<AnalysisError> errors = analysisContext2.computeErrors(source);
 
     // Sort errors by name.
     errors.sort((AnalysisError e1, AnalysisError e2) =>
         e1.errorCode.name.compareTo(e2.errorCode.name));
 
-    expect(errors.map((e) => e.errorCode.name), [
-      'INVALID_METHOD_OVERRIDE_RETURN_TYPE',
-      'STRONG_MODE_INVALID_METHOD_OVERRIDE'
-    ]);
+    expect(
+        errors.map((e) => e.errorCode.name),
+        unorderedEquals([
+          'INVALID_METHOD_OVERRIDE_RETURN_TYPE',
+          'STRONG_MODE_INVALID_METHOD_OVERRIDE'
+        ]));
     expect(errors[0].message, contains('Iterable<S>'),
         reason: 'errors should be in terms of the type parameters '
             'at the error location');
     verify([source]);
   }
 
   void test_genericMethod_override_invalidTypeParamBounds() {
     Source source = addSource(r'''
 class A {}
 class B extends A {}
 class C {
   /*=T*/ f/*<T extends A>*/(/*=T*/ x) => null;
 }
 class D extends C {
   /*=T*/ f/*<T extends B>*/(/*=T*/ x) => null;
 }''');
     // TODO(jmesserly): this is modified code from assertErrors, which we can't
     // use directly because STRONG_MODE_* errors don't have working equality.
     List<AnalysisError> errors = analysisContext2.computeErrors(source);
-    List errorNames = errors.map((e) => e.errorCode.name).toList();
-    expect(errorNames, hasLength(2));
-    expect(errorNames, contains('STRONG_MODE_INVALID_METHOD_OVERRIDE'));
     expect(
-        errorNames, contains('INVALID_METHOD_OVERRIDE_TYPE_PARAMETER_BOUND'));
+        errors.map((e) => e.errorCode.name),
+        unorderedEquals([
+          'INVALID_METHOD_OVERRIDE_TYPE_PARAMETER_BOUND',
+          'STRONG_MODE_INVALID_METHOD_OVERRIDE'
+        ]));
     verify([source]);
   }
 
   void test_genericMethod_override_invalidTypeParamCount() {
     Source source = addSource(r'''
 class C {
   /*=T*/ f/*<T>*/(/*=T*/ x) => null;
 }
 class D extends C {
   /*=S*/ f/*<T, S>*/(/*=T*/ x) => null;
 }''');
     // TODO(jmesserly): we can't use assertErrors because STRONG_MODE_* errors
     // from CodeChecker don't have working equality.
     List<AnalysisError> errors = analysisContext2.computeErrors(source);
-    expect(errors.map((e) => e.errorCode.name), [
-      'STRONG_MODE_INVALID_METHOD_OVERRIDE',
-      'INVALID_METHOD_OVERRIDE_TYPE_PARAMETERS'
-    ]);
+    expect(
+        errors.map((e) => e.errorCode.name),
+        unorderedEquals([
+          'STRONG_MODE_INVALID_METHOD_OVERRIDE',
+          'INVALID_METHOD_OVERRIDE_TYPE_PARAMETERS'
+        ]));
     verify([source]);
   }
 
   void test_genericMethod_propagatedType_promotion() {
     // Regression test for:
     // https://github.com/dart-lang/sdk/issues/25340
 
     // Note, after https://github.com/dart-lang/sdk/issues/25486 the original
     // example won't work, as we now compute a static type and therefore discard
     // the propagated type. So a new test was created that doesn't run under
@@ skipping 449 matching lines @@
 main() {
   var v = x;
   v; // marker
 }
 int x = 3;
 ''';
     assertPropagatedAssignedType(code, typeProvider.intType, null);
     assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 }