More fixes for failures on the Windows bot

pkg/analyzer/test/src/task/incremental_element_builder_test.dart

 // Copyright (c) 2015, 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 test.src.task.incremental_element_builder_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/task/incremental_element_builder.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../reflective_tests.dart';
+import '../../utils.dart';
 import '../context/abstract_context.dart';
 
 main() {
-  groupSep = ' | ';
+  initializeTestEnvironment();
   runReflectiveTests(IncrementalCompilationUnitElementBuilderTest);
 }
 
 @reflectiveTest
 class IncrementalCompilationUnitElementBuilderTest extends AbstractContextTest {
   Source source;
 
   String oldCode;
   CompilationUnit oldUnit;
   CompilationUnitElement unitElement;
@@ skipping 44 matching lines @@
     expect(unitDelta.hasDirectiveChange, isTrue);
   }
 
   test_directives_keepOffset_partOf() {
     String libCode = '''
 // comment to shift tokens
 library my_lib;
 part 'test.dart';
 ''';
     Source libSource = newSource('/lib.dart', libCode);
-    _buildOldUnit(r'''
+    _buildOldUnit(
+        r'''
 part of my_lib;
 class A {}
-''', libSource);
+''',
+        libSource);
     List<Directive> oldDirectives = oldUnit.directives.toList();
     _buildNewUnit(r'''
 part of my_lib;
 class A {}
 ''');
     List<Directive> newDirectives = newUnit.directives;
     {
       Directive newNode = newDirectives[0];
       expect(newNode, same(oldDirectives[0]));
       expect(getNodeText(newNode), 'part of my_lib;');
@@ skipping 227 matching lines @@
 class C {}
 /// reference [bool] type.
 class A {}
 /// reference [int] type.
 class B {}
 ''');
     List<CompilationUnitMember> newNodes = newUnit.declarations;
     {
       CompilationUnitMember newNode = newNodes[0];
       expect(newNode, same(oldNodes[2]));
-      expect(getNodeText(newNode), r'''
+      expect(
+          getNodeText(newNode),
+          r'''
 /// reference [double] and [B] types.
 class C {}''');
       ClassElement element = newNode.element;
       expect(element, isNotNull);
       expect(element.name, 'C');
       expect(element.nameOffset, newCode.indexOf('C {}'));
       // [double] and [B] are still resolved
       {
         var docReferences = newNode.documentationComment.references;
         expect(docReferences, hasLength(2));
         expect(docReferences[0].identifier.staticElement.name, 'double');
         expect(docReferences[1].identifier.staticElement,
             same(newNodes[2].element));
       }
     }
     {
       CompilationUnitMember newNode = newNodes[1];
       expect(newNode, same(oldNodes[0]));
-      expect(getNodeText(newNode), r'''
+      expect(
+          getNodeText(newNode),
+          r'''
 /// reference [bool] type.
 class A {}''');
       ClassElement element = newNode.element;
       expect(element, isNotNull);
       expect(element.name, 'A');
       expect(element.nameOffset, newCode.indexOf('A {}'));
       // [bool] is still resolved
       {
         var docReferences = newNode.documentationComment.references;
         expect(docReferences, hasLength(1));
         expect(docReferences[0].identifier.staticElement.name, 'bool');
       }
     }
     {
       CompilationUnitMember newNode = newNodes[2];
       expect(newNode, same(oldNodes[1]));
-      expect(getNodeText(newNode), r'''
+      expect(
+          getNodeText(newNode),
+          r'''
 /// reference [int] type.
 class B {}''');
       ClassElement element = newNode.element;
       expect(element, isNotNull);
       expect(element.name, 'B');
       expect(element.nameOffset, newCode.indexOf('B {}'));
       // [int] is still resolved
       {
         var docReferences = newNode.documentationComment.references;
         expect(docReferences, hasLength(1));
@@ skipping 234 matching lines @@
     expect(elementB, isNotNull);
     expect(elementC, isNotNull);
     expect(elementD, isNotNull);
     expect(elementA.name, 'a');
     expect(elementB.name, 'b');
     expect(elementC.name, 'c');
     expect(elementD.name, 'd');
     // unit.types
     expect(unitElement.topLevelVariables,
         unorderedEquals([elementA, elementB, elementC, elementD]));
-    expect(unitElement.accessors, unorderedEquals([
-      elementA.getter,
-      elementA.setter,
-      elementB.getter,
-      elementB.setter,
-      elementC.getter,
-      elementC.setter,
-      elementD.getter,
-      elementD.setter
-    ]));
+    expect(
+        unitElement.accessors,
+        unorderedEquals([
+          elementA.getter,
+          elementA.setter,
+          elementB.getter,
+          elementB.setter,
+          elementC.getter,
+          elementC.setter,
+          elementD.getter,
+          elementD.setter
+        ]));
   }
 
   test_unitMembers_topLevelVariable_final() {
     _buildOldUnit(r'''
 final int a = 1;
 ''');
     List<CompilationUnitMember> oldNodes = oldUnit.declarations.toList();
     _buildNewUnit(r'''
 final int a =  1;
 ''');
@@ skipping 30 matching lines @@
     this.oldCode = oldCode;
     source = newSource('/test.dart', oldCode);
     if (libSource == null) {
       libSource = source;
     }
     oldUnit = context.resolveCompilationUnit2(source, libSource);
     unitElement = oldUnit.element;
     expect(unitElement, isNotNull);
   }
 }