More fixes for failures on the Windows bot

pkg/analyzer/test/generated/compile_time_error_code_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.compile_time_error_code_test;
 
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/source_io.dart';
-import 'package:unittest/unittest.dart' as _ut;
 
 import '../reflective_tests.dart';
+import '../utils.dart';
 import 'resolver_test.dart';
 
 main() {
-  _ut.groupSep = ' | ';
+  initializeTestEnvironment();
   runReflectiveTests(CompileTimeErrorCodeTest);
 }
 
 @reflectiveTest
 class CompileTimeErrorCodeTest extends ResolverTestCase {
   void fail_awaitInWrongContext_sync() {
     // This test requires better error recovery than we currently have. In
     // particular, we need to be able to distinguish between an await expression
     // in the wrong context, and the use of 'await' as an identifier.
     Source source = addSource(r'''
@@ skipping 173 matching lines @@
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.ACCESS_PRIVATE_ENUM_FIELD]);
     // Cannot verify because "_name" cannot be resolved.
   }
 
   void test_ambiguousExport() {
     Source source = addSource(r'''
 library L;
 export 'lib1.dart';
 export 'lib2.dart';''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 class N {}''');
-    addNamedSource("/lib2.dart", r'''
+    addNamedSource(
+        "/lib2.dart",
+        r'''
 library lib2;
 class N {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.AMBIGUOUS_EXPORT]);
     verify([source]);
   }
 
   void test_async_used_as_identifier_in_annotation() {
     Source source = addSource('''
 const int async = 0;
@@ skipping 240 matching lines @@
 f() async {
   return "$async";
 }
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER]);
     verify([source]);
   }
 
   void test_async_used_as_identifier_in_suffix() {
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 int async;
 ''');
     Source source = addSource('''
 import 'lib1.dart' as l;
 f() async {
   return l.async;
 }
 ''');
     computeLibrarySourceErrors(source);
@@ skipping 463 matching lines @@
 library lib1;
 class A {
   const A();
 }''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 main() {
   const a.A();
 }'''
-    ], <ErrorCode>[CompileTimeErrorCode.CONST_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      CompileTimeErrorCode.CONST_DEFERRED_CLASS
+    ]);
   }
 
   void test_constDeferredClass_namedConstructor() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {
   const A.b();
 }''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 main() {
   const a.A.b();
 }'''
-    ], <ErrorCode>[CompileTimeErrorCode.CONST_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      CompileTimeErrorCode.CONST_DEFERRED_CLASS
+    ]);
   }
 
   void test_constEval_newInstance_constConstructor() {
     Source source = addSource(r'''
 class A {
   const A();
 }
 const a = new A();''');
     computeLibrarySourceErrors(source);
     assertErrors(source,
@@ skipping 419 matching lines @@
 int A;
 f() {
   return const A();
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_WITH_NON_TYPE]);
     verify([source]);
   }
 
   void test_constWithNonType_fromLibrary() {
-    Source source1 = addNamedSource("lib.dart", "");
-    Source source2 = addNamedSource("lib2.dart", r'''
+    Source source1 = addNamedSource("/lib.dart", "");
+    Source source2 = addNamedSource(
+        "/lib2.dart",
+        r'''
 import 'lib.dart' as lib;
 void f() {
   const lib.A();
 }''');
     computeLibrarySourceErrors(source1);
     computeLibrarySourceErrors(source2);
     assertErrors(source2, [CompileTimeErrorCode.CONST_WITH_NON_TYPE]);
     verify([source1]);
   }
 
@@ skipping 115 matching lines @@
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [
       CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT,
       CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT
     ]);
     verify([source]);
   }
 
   void test_duplicateDefinition_acrossLibraries() {
-    Source librarySource = addNamedSource("/lib.dart", r'''
+    Source librarySource = addNamedSource(
+        "/lib.dart",
+        r'''
 library lib;
 
 part 'a.dart';
 part 'b.dart';''');
-    Source sourceA = addNamedSource("/a.dart", r'''
+    Source sourceA = addNamedSource(
+        "/a.dart",
+        r'''
 part of lib;
 
 class A {}''');
-    Source sourceB = addNamedSource("/b.dart", r'''
+    Source sourceB = addNamedSource(
+        "/b.dart",
+        r'''
 part of lib;
 
 class A {}''');
     computeLibrarySourceErrors(librarySource);
     assertErrors(sourceB, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([librarySource, sourceA, sourceB]);
   }
 
   void test_duplicateDefinition_catch() {
     Source source = addSource(r'''
@@ skipping 252 matching lines @@
 
   void test_extendsDeferredClass() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class B extends a.A {}'''
-    ], <ErrorCode>[CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS
+    ]);
   }
 
   void test_extendsDeferredClass_classTypeAlias() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class M {}
 class C = a.A with M;'''
-    ], <ErrorCode>[CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS
+    ]);
   }
 
   void test_extendsDisallowedClass_class_bool() {
     Source source = addSource("class A extends bool {}");
     computeLibrarySourceErrors(source);
     assertErrors(source, [
       CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
       CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT
     ]);
     verify([source]);
@@ skipping 398 matching lines @@
 
   void test_implementsDeferredClass() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class B implements a.A {}'''
-    ], <ErrorCode>[CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS
+    ]);
   }
 
   void test_implementsDeferredClass_classTypeAlias() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class B {}
 class M {}
 class C = B with M implements a.A;'''
-    ], <ErrorCode>[CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS
+    ]);
   }
 
   void test_implementsDisallowedClass_class_bool() {
     Source source = addSource("class A implements bool {}");
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
 
   void test_implementsDisallowedClass_class_double() {
@@ skipping 267 matching lines @@
   }
 
   void test_importInternalLibrary() {
     Source source = addSource("import 'dart:_interceptors';");
     computeLibrarySourceErrors(source);
     // Note, in these error cases we may generate an UNUSED_IMPORT hint, while
     // we could prevent the hint from being generated by testing the import
     // directive for the error, this is such a minor corner case that we don't
     // think we should add the additional computation time to figure out such
     // cases.
-    assertErrors(source, [
-      CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY,
-      HintCode.UNUSED_IMPORT
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY, HintCode.UNUSED_IMPORT]);
     verify([source]);
   }
 
   void test_importInternalLibrary_js_helper() {
     Source source = addSource("import 'dart:_js_helper';");
     computeLibrarySourceErrors(source);
     // Note, in these error cases we may generate an UNUSED_IMPORT hint, while
     // we could prevent the hint from being generated by testing the import
     // directive for the error, this is such a minor corner case that we don't
     // think we should add the additional computation time to figure out such
     // cases.
-    assertErrors(source, [
-      CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY,
-      HintCode.UNUSED_IMPORT
-    ]);
+    assertErrors(source,
+        [CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY, HintCode.UNUSED_IMPORT]);
     verify([source]);
   }
 
   void test_importOfNonLibrary() {
     Source source = addSource(r'''
 library lib;
 import 'part.dart';
 A a;''');
-    addNamedSource("/part.dart", r'''
+    addNamedSource(
+        "/part.dart",
+        r'''
 part of lib;
 class A{}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY]);
     verify([source]);
   }
 
   void test_inconsistentCaseExpressionTypes() {
     Source source = addSource(r'''
 f(var p) {
@@ skipping 253 matching lines @@
 get V => 0;
 @V
 main() {
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
 
   void test_invalidAnnotation_importWithPrefix_getter() {
-    addNamedSource("/lib.dart", r'''
+    addNamedSource(
+        "/lib.dart",
+        r'''
 library lib;
 get V => 0;''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 @p.V
 main() {
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
 
   void test_invalidAnnotation_importWithPrefix_notConstantVariable() {
-    addNamedSource("/lib.dart", r'''
+    addNamedSource(
+        "/lib.dart",
+        r'''
 library lib;
 final V = 0;''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 @p.V
 main() {
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
 
   void test_invalidAnnotation_importWithPrefix_notVariableOrConstructorInvocation() {
-    addNamedSource("/lib.dart", r'''
+    addNamedSource(
+        "/lib.dart",
+        r'''
 library lib;
 typedef V();''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 @p.V
 main() {
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
@@ skipping 550 matching lines @@
 
   void test_mixinDeferredClass() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class B extends Object with a.A {}'''
-    ], <ErrorCode>[CompileTimeErrorCode.MIXIN_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      CompileTimeErrorCode.MIXIN_DEFERRED_CLASS
+    ]);
   }
 
   void test_mixinDeferredClass_classTypeAlias() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class B {}
 class C = B with a.A;'''
-    ], <ErrorCode>[CompileTimeErrorCode.MIXIN_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      CompileTimeErrorCode.MIXIN_DEFERRED_CLASS
+    ]);
   }
 
   void test_mixinHasNoConstructors_mixinApp() {
     Source source = addSource(r'''
 class B {
   B({x});
 }
 class M {}
 class C = B with M;
 ''');
@@ skipping 1258 matching lines @@
   p = 1;
 }
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   void test_prefix_conditionalPropertyAccess_call() {
-    addNamedSource('/lib.dart', '''
+    addNamedSource(
+        '/lib.dart',
+        '''
 library lib;
 g() {}
 ''');
     Source source = addSource('''
 import 'lib.dart' as p;
 f() {
   p?.g();
 }
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   void test_prefix_conditionalPropertyAccess_call_loadLibrary() {
-    addNamedSource('/lib.dart', '''
+    addNamedSource(
+        '/lib.dart',
+        '''
 library lib;
 ''');
     Source source = addSource('''
 import 'lib.dart' deferred as p;
 f() {
   p?.loadLibrary();
 }
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   void test_prefix_conditionalPropertyAccess_get() {
-    addNamedSource('/lib.dart', '''
+    addNamedSource(
+        '/lib.dart',
+        '''
 library lib;
 var x;
 ''');
     Source source = addSource('''
 import 'lib.dart' as p;
 f() {
   return p?.x;
 }
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   void test_prefix_conditionalPropertyAccess_get_loadLibrary() {
-    addNamedSource('/lib.dart', '''
+    addNamedSource(
+        '/lib.dart',
+        '''
 library lib;
 ''');
     Source source = addSource('''
 import 'lib.dart' deferred as p;
 f() {
   return p?.loadLibrary;
 }
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   void test_prefix_conditionalPropertyAccess_set() {
-    addNamedSource('/lib.dart', '''
+    addNamedSource(
+        '/lib.dart',
+        '''
 library lib;
 var x;
 ''');
     Source source = addSource('''
 import 'lib.dart' as p;
 f() {
   p?.x = null;
 }
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   void test_prefix_conditionalPropertyAccess_set_loadLibrary() {
-    addNamedSource('/lib.dart', '''
+    addNamedSource(
+        '/lib.dart',
+        '''
 library lib;
 ''');
     Source source = addSource('''
 import 'lib.dart' deferred as p;
 f() {
   p?.loadLibrary = null;
 }
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(
@@ skipping 25 matching lines @@
   p();
 }
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   void test_prefixCollidesWithTopLevelMembers_functionTypeAlias() {
-    addNamedSource("/lib.dart", r'''
+    addNamedSource(
+        "/lib.dart",
+        r'''
 library lib;
 class A{}''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 typedef p();
 p.A a;''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
   }
 
   void test_prefixCollidesWithTopLevelMembers_topLevelFunction() {
-    addNamedSource("/lib.dart", r'''
+    addNamedSource(
+        "/lib.dart",
+        r'''
 library lib;
 class A{}''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 p() {}
 p.A a;''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
   }
 
   void test_prefixCollidesWithTopLevelMembers_topLevelVariable() {
-    addNamedSource("/lib.dart", r'''
+    addNamedSource(
+        "/lib.dart",
+        r'''
 library lib;
 class A{}''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 var p = null;
 p.A a;''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
   }
 
   void test_prefixCollidesWithTopLevelMembers_type() {
-    addNamedSource("/lib.dart", r'''
+    addNamedSource(
+        "/lib.dart",
+        r'''
 library lib;
 class A{}''');
     Source source = addSource(r'''
 import 'lib.dart' as p;
 class p {}
 p.A a;''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
@@ skipping 21 matching lines @@
   p += 1;
 }
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT]);
     verify([source]);
   }
 
   void test_prefixNotFollowedByDot_conditionalMethodInvocation() {
-    addNamedSource('/lib.dart', '''
+    addNamedSource(
+        '/lib.dart',
+        '''
 library lib;
 g() {}
 ''');
     Source source = addSource('''
 import 'lib.dart' as p;
 f() {
   p?.g();
 }
 ''');
     computeLibrarySourceErrors(source);
@@ skipping 557 matching lines @@
 library lib1;
 f1() {}''',
       r'''
 library lib2;
 f2() {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as lib;
 import 'lib2.dart' as lib;
 main() { lib.f1(); lib.f2(); }'''
-    ], <ErrorCode>[CompileTimeErrorCode.SHARED_DEFERRED_PREFIX]);
+    ], <ErrorCode>[
+      CompileTimeErrorCode.SHARED_DEFERRED_PREFIX
+    ]);
   }
 
   void test_superInInvalidContext_binaryExpression() {
     Source source = addSource("var v = super + 0;");
     computeLibrarySourceErrors(source);
     assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
     // no verify(), 'super.v' is not resolved
   }
 
   void test_superInInvalidContext_constructorFieldInitializer() {
@@ skipping 560 matching lines @@
         source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR]);
     verify([source]);
     reset();
   }
 
   void _check_wrongNumberOfParametersForOperator1(String name) {
     _check_wrongNumberOfParametersForOperator(name, "");
     _check_wrongNumberOfParametersForOperator(name, "a, b");
   }
 }