More fixes for failures on the Windows bot

pkg/analyzer/test/generated/static_warning_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.static_warning_code_test;
 
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:unittest/unittest.dart';
 
 import '../reflective_tests.dart';
+import '../utils.dart';
 import 'resolver_test.dart';
 
 main() {
-  groupSep = ' | ';
+  initializeTestEnvironment();
   runReflectiveTests(StaticWarningCodeTest);
 }
 
 @reflectiveTest
 class StaticWarningCodeTest extends ResolverTestCase {
   void fail_undefinedGetter() {
     Source source = addSource(r'''
 ''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_GETTER]);
@@ skipping 21 matching lines @@
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_SETTER]);
     verify([source]);
   }
 
   void test_ambiguousImport_as() {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 f(p) {p as N;}''');
-    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, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   void test_ambiguousImport_extends() {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 class A extends N {}''');
-    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, [
       StaticWarningCode.AMBIGUOUS_IMPORT,
       CompileTimeErrorCode.EXTENDS_NON_CLASS
     ]);
   }
 
   void test_ambiguousImport_implements() {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 class A implements N {}''');
-    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, [
       StaticWarningCode.AMBIGUOUS_IMPORT,
       CompileTimeErrorCode.IMPLEMENTS_NON_CLASS
     ]);
   }
 
   void test_ambiguousImport_inPart() {
     Source source = addSource(r'''
 library lib;
 import 'lib1.dart';
 import 'lib2.dart';
 part 'part.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 {}''');
-    Source partSource = addNamedSource("/part.dart", r'''
+    Source partSource = addNamedSource(
+        "/part.dart",
+        r'''
 part of lib;
 class A extends N {}''');
     computeLibrarySourceErrors(source);
     assertErrors(partSource, [
       StaticWarningCode.AMBIGUOUS_IMPORT,
       CompileTimeErrorCode.EXTENDS_NON_CLASS
     ]);
   }
 
   void test_ambiguousImport_instanceCreation() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib2.dart';
 f() {new N();}''');
-    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, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   void test_ambiguousImport_is() {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 f(p) {p is N;}''');
-    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, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   void test_ambiguousImport_qualifier() {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 g() { N.FOO; }''');
-    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, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   void test_ambiguousImport_typeAnnotation() {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 typedef N FT(N p);
 N f(N p) {
   N v;
   return null;
 }
 class A {
   N m() { return null; }
 }
 class B<T extends N> {}''');
-    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, [
       StaticWarningCode.AMBIGUOUS_IMPORT,
       StaticWarningCode.AMBIGUOUS_IMPORT,
       StaticWarningCode.AMBIGUOUS_IMPORT,
       StaticWarningCode.AMBIGUOUS_IMPORT,
       StaticWarningCode.AMBIGUOUS_IMPORT,
       StaticWarningCode.AMBIGUOUS_IMPORT,
       StaticWarningCode.AMBIGUOUS_IMPORT
     ]);
   }
 
   void test_ambiguousImport_typeArgument_annotation() {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 class A<T> {}
 A<N> f() { return null; }''');
-    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, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   void test_ambiguousImport_typeArgument_instanceCreation() {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 class A<T> {}
 f() {new A<N>();}''');
-    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, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   void test_ambiguousImport_varRead() {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 f() { g(v); }
 g(p) {}''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 var v;''');
-    addNamedSource("/lib2.dart", r'''
+    addNamedSource(
+        "/lib2.dart",
+        r'''
 library lib2;
 var v;''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   void test_ambiguousImport_varWrite() {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 f() { v = 0; }''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 var v;''');
-    addNamedSource("/lib2.dart", r'''
+    addNamedSource(
+        "/lib2.dart",
+        r'''
 library lib2;
 var v;''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   void test_ambiguousImport_withPrefix() {
     Source source = addSource(r'''
 library test;
 import 'lib1.dart' as p;
 import 'lib2.dart' as p;
 main() {
   p.f();
 }''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 f() {}''');
-    addNamedSource("/lib2.dart", r'''
+    addNamedSource(
+        "/lib2.dart",
+        r'''
 library lib2;
 f() {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   void test_argumentTypeNotAssignable_ambiguousClassName() {
     // See dartbug.com/19624
-    Source source = addNamedSource("/lib1.dart", r'''
+    Source source = addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 import 'lib2.dart';
 class _A {}
 f() {
   g((_A a) {});
 }''');
-    addNamedSource("/lib2.dart", r'''
+    addNamedSource(
+        "/lib2.dart",
+        r'''
 library lib2;
 class _A {}
 g(h(_A a)) {}''');
     computeLibrarySourceErrors(source);
     // The name _A is private to the library it's defined in, so this is a type
     // mismatch. Furthermore, the error message should mention both _A and the
     // filenames so the user can figure out what's going on.
     List<AnalysisError> errors = analysisContext2.computeErrors(source);
     expect(errors, hasLength(1));
     AnalysisError error = errors[0];
@@ skipping 601 matching lines @@
         source, [StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER]);
     verify([source]);
   }
 
   void test_conflictingDartImport() {
     Source source = addSource(r'''
 import 'lib.dart';
 import 'dart:async';
 Future f = null;
 Stream s;''');
-    addNamedSource("/lib.dart", r'''
+    addNamedSource(
+        "/lib.dart",
+        r'''
 library lib;
 class Future {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.CONFLICTING_DART_IMPORT]);
   }
 
   void test_conflictingInstanceGetterAndSuperclassMember_declField_direct_setter() {
     Source source = addSource(r'''
 class A {
   static set v(x) {}
@@ skipping 520 matching lines @@
 
   void test_importOfNonLibrary() {
     resolveWithErrors(<String>[
       r'''
 part of lib;
 class A {}''',
       r'''
 library lib;
 import 'lib1.dart' deferred as p;
 var a = new p.A();'''
-    ], <ErrorCode>[StaticWarningCode.IMPORT_OF_NON_LIBRARY]);
+    ], <ErrorCode>[
+      StaticWarningCode.IMPORT_OF_NON_LIBRARY
+    ]);
   }
 
   void test_inconsistentMethodInheritanceGetterAndMethod() {
     Source source = addSource(r'''
 abstract class A {
   int x();
 }
 abstract class B {
   int get x;
 }
@@ skipping 907 matching lines @@
 var A = 0;
 void f() {
   var a = new A();
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.NEW_WITH_NON_TYPE]);
     verify([source]);
   }
 
   void test_newWithNonType_fromLibrary() {
-    Source source1 = addNamedSource("lib.dart", "class B {}");
-    Source source2 = addNamedSource("lib2.dart", r'''
+    Source source1 = addNamedSource("/lib.dart", "class B {}");
+    Source source2 = addNamedSource(
+        "/lib2.dart",
+        r'''
 import 'lib.dart' as lib;
 void f() {
   var a = new lib.A();
 }
 lib.B b;''');
     computeLibrarySourceErrors(source1);
     computeLibrarySourceErrors(source2);
     assertErrors(source2, [StaticWarningCode.NEW_WITH_NON_TYPE]);
     verify([source1]);
   }
@@ skipping 665 matching lines @@
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 f(var v) {
   v as a.A;
 }'''
-    ], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS
+    ]);
   }
 
   void test_typeAnnotationDeferredClass_catchClause() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 f(var v) {
   try {
   } on a.A {
   }
 }'''
-    ], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS
+    ]);
   }
 
   void test_typeAnnotationDeferredClass_fieldFormalParameter() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class C {
   var v;
   C(a.A this.v);
 }'''
-    ], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS
+    ]);
   }
 
   void test_typeAnnotationDeferredClass_functionDeclaration_returnType() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 a.A f() { return null; }'''
-    ], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS
+    ]);
   }
 
   void test_typeAnnotationDeferredClass_functionTypedFormalParameter_returnType() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 f(a.A g()) {}'''
-    ], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS
+    ]);
   }
 
   void test_typeAnnotationDeferredClass_isExpression() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 f(var v) {
   bool b = v is a.A;
 }'''
-    ], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS
+    ]);
   }
 
   void test_typeAnnotationDeferredClass_methodDeclaration_returnType() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class C {
   a.A m() { return null; }
 }'''
-    ], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS
+    ]);
   }
 
   void test_typeAnnotationDeferredClass_simpleFormalParameter() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 f(a.A v) {}'''
-    ], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS
+    ]);
   }
 
   void test_typeAnnotationDeferredClass_typeArgumentList() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class C<E> {}
 C<a.A> c;'''
-    ], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS
+    ]);
   }
 
   void test_typeAnnotationDeferredClass_typeArgumentList2() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class C<E, F> {}
 C<a.A, a.A> c;'''
     ], <ErrorCode>[
       StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS,
       StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS
     ]);
   }
 
   void test_typeAnnotationDeferredClass_typeParameter_bound() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 class C<E extends a.A> {}'''
-    ], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS
+    ]);
   }
 
   void test_typeAnnotationDeferredClass_variableDeclarationList() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 class A {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as a;
 a.A v;'''
-    ], <ErrorCode>[StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS]);
+    ], <ErrorCode>[
+      StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS
+    ]);
   }
 
   void test_typeParameterReferencedByStatic_field() {
     Source source = addSource(r'''
 class A<K> {
   static K k;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
@@ skipping 107 matching lines @@
     assertErrors(source, [StaticWarningCode.UNDEFINED_CLASS]);
   }
 
   void test_undefinedClassBoolean_variableDeclaration() {
     Source source = addSource("f() { boolean v; }");
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_CLASS_BOOLEAN]);
   }
 
   void test_undefinedGetter_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() {
   var g = lib.gg;
 }''');
     computeLibrarySourceErrors(source1);
     computeLibrarySourceErrors(source2);
     assertErrors(source2, [StaticWarningCode.UNDEFINED_GETTER]);
     verify([source1]);
   }
 
@@ skipping 30 matching lines @@
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
 
   void test_undefinedIdentifier_methodInvocation() {
     Source source = addSource("f() { C.m(); }");
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
 
   void test_undefinedIdentifier_private_getter() {
-    addNamedSource("/lib.dart", r'''
+    addNamedSource(
+        "/lib.dart",
+        r'''
 library lib;
 class A {
   var _foo;
 }''');
     Source source = addSource(r'''
 import 'lib.dart';
 class B extends A {
   test() {
     var v = _foo;
   }
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
 
   void test_undefinedIdentifier_private_setter() {
-    addNamedSource("/lib.dart", r'''
+    addNamedSource(
+        "/lib.dart",
+        r'''
 library lib;
 class A {
   var _foo;
 }''');
     Source source = addSource(r'''
 import 'lib.dart';
 class B extends A {
   test() {
     _foo = 42;
   }
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
 
   void test_undefinedNamedParameter() {
     Source source = addSource(r'''
 f({a, b}) {}
 main() {
   f(c: 1);
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_NAMED_PARAMETER]);
     // no verify(), 'c' is not resolved
   }
 
   void test_undefinedSetter() {
-    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() {
   lib.gg = null;
 }''');
     computeLibrarySourceErrors(source1);
     computeLibrarySourceErrors(source2);
     assertErrors(source2, [StaticWarningCode.UNDEFINED_SETTER]);
   }
 
   void test_undefinedStaticMethodOrGetter_getter() {
@@ skipping 57 matching lines @@
 
   void test_voidReturnForGetter() {
     Source source = addSource(r'''
 class S {
   void get value {}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.VOID_RETURN_FOR_GETTER]);
   }
 }