More fixes for failures on the Windows bot

pkg/analysis_server/test/domain_analysis_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 test.domain.analysis;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/domain_analysis.dart';
 import 'package:analysis_server/src/plugin/server_plugin.dart';
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:path/path.dart';
 import 'package:plugin/manager.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 import 'package:unittest/unittest.dart';
 
 import 'analysis_abstract.dart';
 import 'mock_sdk.dart';
 import 'mocks.dart';
+import 'utils.dart';
 
 main() {
-  groupSep = ' | ';
+  initializeTestEnvironment();
 
   defineReflectiveTests(AnalysisDomainTest);
   defineReflectiveTests(SetSubscriptionsTest);
 
   MockServerChannel serverChannel;
   MemoryResourceProvider resourceProvider;
   AnalysisServer server;
   AnalysisDomainHandler handler;
 
   setUp(() {
     serverChannel = new MockServerChannel();
     resourceProvider = new MemoryResourceProvider();
     ExtensionManager manager = new ExtensionManager();
     ServerPlugin serverPlugin = new ServerPlugin();
     manager.processPlugins([serverPlugin]);
-    server = new AnalysisServer(serverChannel, resourceProvider,
-        new MockPackageMapProvider(), null, serverPlugin,
-        new AnalysisServerOptions(), new MockSdk(),
+    server = new AnalysisServer(
+        serverChannel,
+        resourceProvider,
+        new MockPackageMapProvider(),
+        null,
+        serverPlugin,
+        new AnalysisServerOptions(),
+        new MockSdk(),
         InstrumentationService.NULL_SERVICE);
     handler = new AnalysisDomainHandler(server);
   });
 
   group('updateContent', testUpdateContent);
 
   group('AnalysisDomainHandler', () {
     group('setAnalysisRoots', () {
       Response testSetAnalysisRoots(
           List<String> included, List<String> excluded) {
@@ skipping 70 matching lines @@
         }
 
         setPriorityFiles(['/p1/a.dart', '/p2/b.dart']);
         setPriorityFiles(['/p2/b.dart', '/p2/c.dart']);
         setPriorityFiles([]);
       });
     });
 
     group('updateOptions', () {
       test('invalid', () {
-        var request = new Request(
-            '0', ANALYSIS_UPDATE_OPTIONS, {OPTIONS: {'not-an-option': true}});
+        var request = new Request('0', ANALYSIS_UPDATE_OPTIONS, {
+          OPTIONS: {'not-an-option': true}
+        });
         var response = handler.handleRequest(request);
         // Invalid options should be silently ignored.
         expect(response, isResponseSuccess('0'));
       });
 
       test('null', () {
         // null is allowed as a synonym for {}.
         var request =
             new Request('0', ANALYSIS_UPDATE_OPTIONS, {OPTIONS: null});
         var response = handler.handleRequest(request);
         expect(response, isResponseSuccess('0'));
       });
     });
   });
 }
 
 testUpdateContent() {
   test('bad type', () {
     AnalysisTestHelper helper = new AnalysisTestHelper();
     helper.createSingleFileProject('// empty');
     return helper.onAnalysisComplete.then((_) {
       Request request = new Request('0', ANALYSIS_UPDATE_CONTENT, {
-        'files': {helper.testFile: {TYPE: 'foo',}}
+        'files': {
+          helper.testFile: {TYPE: 'foo',}
+        }
       });
       Response response = helper.handler.handleRequest(request);
       expect(response, isResponseFailure('0'));
     });
   });
 
   test('full content', () {
     AnalysisTestHelper helper = new AnalysisTestHelper();
     helper.createSingleFileProject('// empty');
     return helper.onAnalysisComplete.then((_) {
@@ skipping 114 matching lines @@
     if (notification.event == ANALYSIS_ERRORS) {
       var decoded = new AnalysisErrorsParams.fromNotification(notification);
       filesErrors[decoded.file] = decoded.errors;
     }
   }
 
   test_packageMapDependencies() async {
     // Prepare a source file that has errors because it refers to an unknown
     // package.
     String pkgFile = '/packages/pkgA/libA.dart';
-    resourceProvider.newFile(pkgFile, '''
+    resourceProvider.newFile(
+        pkgFile,
+        '''
 library lib_a;
 class A {}
 ''');
     addTestFile('''
 import 'package:pkgA/libA.dart';
 f(A a) {
 }
 ''');
     String pkgDependency = posix.join(projectPath, 'package_dep');
     resourceProvider.newFile(pkgDependency, 'contents');
@@ skipping 10 matching lines @@
     // Give the server time to notice the file has changed, then let
     // analysis complete. There should now be no error.
     await pumpEventQueue();
     await waitForTasksFinished();
     expect(filesErrors[testFile], isEmpty);
   }
 
   test_setRoots_packages() {
     // prepare package
     String pkgFile = '/packages/pkgA/libA.dart';
-    resourceProvider.newFile(pkgFile, '''
+    resourceProvider.newFile(
+        pkgFile,
+        '''
 library lib_a;
 class A {}
 ''');
-    packageMapProvider.packageMap['pkgA'] =
-        [resourceProvider.getResource('/packages/pkgA')];
+    packageMapProvider.packageMap['pkgA'] = [
+      resourceProvider.getResource('/packages/pkgA')
+    ];
     addTestFile('''
 import 'package:pkgA/libA.dart';
 main(A a) {
 }
 ''');
     // create project and wait for analysis
     createProject();
     return waitForTasksFinished().then((_) {
       // if 'package:pkgA/libA.dart' was resolved, then there are no errors
       expect(filesErrors[testFile], isEmpty);
@@ skipping 20 matching lines @@
 
   String testFile = '/project/bin/test.dart';
   String testCode;
 
   AnalysisTestHelper() {
     serverChannel = new MockServerChannel();
     resourceProvider = new MemoryResourceProvider();
     ExtensionManager manager = new ExtensionManager();
     ServerPlugin serverPlugin = new ServerPlugin();
     manager.processPlugins([serverPlugin]);
-    server = new AnalysisServer(serverChannel, resourceProvider,
-        new MockPackageMapProvider(), null, serverPlugin,
-        new AnalysisServerOptions(), new MockSdk(),
+    server = new AnalysisServer(
+        serverChannel,
+        resourceProvider,
+        new MockPackageMapProvider(),
+        null,
+        serverPlugin,
+        new AnalysisServerOptions(),
+        new MockSdk(),
         InstrumentationService.NULL_SERVICE);
     handler = new AnalysisDomainHandler(server);
     // listen for notifications
     Stream<Notification> notificationStream =
         serverChannel.notificationController.stream;
     notificationStream.listen((Notification notification) {
       if (notification.event == ANALYSIS_ERRORS) {
         var decoded = new AnalysisErrorsParams.fromNotification(notification);
         filesErrors[decoded.file] = decoded.errors;
       }
@@ skipping 202 matching lines @@
     expect(filesHighlights[testFile], isNull);
     // subscribe
     addAnalysisSubscription(AnalysisService.HIGHLIGHTS, file);
     await server.onAnalysisComplete;
     // there are results
     expect(filesHighlights[file], isNull);
   }
 
   test_afterAnalysis_packageFile_external() async {
     String pkgFile = '/packages/pkgA/lib/libA.dart';
-    resourceProvider.newFile(pkgFile, '''
+    resourceProvider.newFile(
+        pkgFile,
+        '''
 library lib_a;
 class A {}
 ''');
     packageMapProvider.packageMap = {
       'pkgA': [(resourceProvider.newFolder('/packages/pkgA/lib'))]
     };
     //
     addTestFile('''
 import 'package:pkgA/libA.dart';
 main() {
   new A();
 }
 ''');
     createProject();
     // wait for analysis, no results initially
     await waitForTasksFinished();
     expect(filesHighlights[pkgFile], isNull);
     // subscribe
     addAnalysisSubscription(AnalysisService.HIGHLIGHTS, pkgFile);
     await server.onAnalysisComplete;
     // there are results
     expect(filesHighlights[pkgFile], isNotEmpty);
   }
 
   test_afterAnalysis_packageFile_inRoot() async {
     String pkgA = '/pkgA';
     String pkgB = '/pkgA';
     String pkgFileA = '$pkgA/lib/libA.dart';
     String pkgFileB = '$pkgA/lib/libB.dart';
-    resourceProvider.newFile(pkgFileA, '''
+    resourceProvider.newFile(
+        pkgFileA,
+        '''
 library lib_a;
 class A {}
 ''');
-    resourceProvider.newFile(pkgFileB, '''
+    resourceProvider.newFile(
+        pkgFileB,
+        '''
 import 'package:pkgA/libA.dart';
 main() {
   new A();
 }
 ''');
     packageMapProvider.packageMap = {
       'pkgA': [
         resourceProvider.newFolder('$pkgA/lib'),
         resourceProvider.newFolder('$pkgB/lib')
       ]
     };
     // add 'pkgA' and 'pkgB' as projects
     {
       resourceProvider.newFolder(projectPath);
       handleSuccessfulRequest(
           new AnalysisSetAnalysisRootsParams([pkgA, pkgB], []).toRequest('0'));
     }
     // wait for analysis, no results initially
     await waitForTasksFinished();
     expect(filesHighlights[pkgFileA], isNull);
     // subscribe
     addAnalysisSubscription(AnalysisService.HIGHLIGHTS, pkgFileA);
     await server.onAnalysisComplete;
     // there are results
     expect(filesHighlights[pkgFileA], isNotEmpty);
   }
 
   test_afterAnalysis_packageFile_notUsed() async {
     String pkgFile = '/packages/pkgA/lib/libA.dart';
-    resourceProvider.newFile(pkgFile, '''
+    resourceProvider.newFile(
+        pkgFile,
+        '''
 library lib_a;
 class A {}
 ''');
     packageMapProvider.packageMap = {
       'pkgA': [(resourceProvider.newFolder('/packages/pkgA/lib'))]
     };
     //
     addTestFile('// no "pkgA" reference');
     createProject();
     // wait for analysis, no results initially
@@ skipping 25 matching lines @@
   test_beforeAnalysis() async {
     addTestFile('int V = 42;');
     createProject();
     // subscribe
     addAnalysisSubscription(AnalysisService.HIGHLIGHTS, testFile);
     // wait for analysis
     await waitForTasksFinished();
     expect(filesHighlights[testFile], isNotEmpty);
   }
 }