Fix analysis server to only send SERVER_STATUS when subscribed to.

pkg/analysis_server/test/integration/integration_tests.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.integration.analysis;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
@@ skipping 38 matching lines @@
    */
   bool skipShutdown = false;
 
   /**
    * Data associated with the "server.connected" notification that was received
    * when the server started up.
    */
   var serverConnectedParams;
 
   /**
+   * True if we are currently subscribed to [SERVER_STATUS] updates.
+   */
+  bool _subscribedToServerStatus = false;
+
+  /**
    * Write a source file with the given absolute [pathname] and [contents].
    *
    * If the file didn't previously exist, it is created.  If it did, it is
    * overwritten.
    *
    * Parent directories are created as necessary.
    */
   void writeFile(String pathname, String contents) {
     new Directory(dirname(pathname)).createSync(recursive: true);
     new File(pathname).writeAsStringSync(contents);
   }
 
   /**
    * Convert the given [relativePath] to an absolute path, by interpreting it
    * relative to [sourceDirectory].  On Windows any forward slashes in
    * [relativePath] are converted to backslashes.
    */
   String sourcePath(String relativePath) {
     return join(sourceDirectory.path, relativePath.replaceAll('/', separator));
   }
 
   /**
    * Send the server an 'analysis.setAnalysisRoots' command directing it to
-   * analyze [sourceDirectory].
+   * analyze [sourceDirectory].  If [subscribeStatus] is true (the default),
+   * then also enable [SERVER_STATUS] notifications so that [analysisFinished]
+   * can be used.
    */
-  Future standardAnalysisRoot() {
-    return sendAnalysisSetAnalysisRoots([sourceDirectory.path], []);
+  Future standardAnalysisSetup({bool subscribeStatus: true}) {
+    List<Future> futures = <Future>[];
+    if (subscribeStatus) {
+      futures.add(sendServerSetSubscriptions(['STATUS']));
+    }
+    futures.add(sendAnalysisSetAnalysisRoots([sourceDirectory.path], []));
+    return Future.wait(futures);

[Brian Wilkerson, 2014/08/09 15:33:16]

Out of curiosity, is there any performance penalty for waiting on a list with a
single item rather than returning the single item?

[Paul Berry, 2014/08/09 15:42:46]

Looking at the implementation in sdk/lib/async/future.dart, there is some minor
additional bookkeeping (a list, a completer, and a few local variables are
used), but IMHO it should never be a large enough penalty to worry about.

   }
 
   /**
    * Return a future which will complete when a 'server.status' notification is
    * received from the server with 'analyzing' set to false.
    *
    * The future will only be completed by 'server.status' notifications that are
    * received after this function call.  So it is safe to use this getter
    * multiple times in one test; each time it is used it will wait afresh for
    * analysis to finish.
    */
   Future get analysisFinished {
     Completer completer = new Completer();
     StreamSubscription subscription;
+    // This will only work if the caller has already subscribed to
+    // SERVER_STATUS (e.g. using sendServerSetSubscriptions(['STATUS']))
+    expect(_subscribedToServerStatus, isTrue);
     subscription = server.onNotification(SERVER_STATUS).listen((params) {
       bool analysisComplete = false;
       try {
         analysisComplete = !params['analysis']['analyzing'];
       } catch (_) {
         // Status message was mal-formed or missing optional parameters.  That's
         // fine, since we'll detect a mal-formed status message below.
       }
       if (analysisComplete) {
         completer.complete(params);
         subscription.cancel();
       }
       expect(params, isServerStatusParams);
     });
     return completer.future;
   }
 
   /**
    * Print out any messages exchanged with the server.  If some messages have
    * already been exchanged with the server, they are printed out immediately.
    */
   void debugStdio() {
     server.debugStdio();
   }
 
+  @override
+  Future sendServerSetSubscriptions(List<String> subscriptions, {bool
+      checkTypes: true}) {
+    _subscribedToServerStatus = subscriptions.contains('STATUS');
+    return super.sendServerSetSubscriptions(subscriptions, checkTypes:
+        checkTypes);
+  }
+
   /**
    * The server is automatically started before every test, and a temporary
    * [sourceDirectory] is created.
    */
   Future setUp() {
     sourceDirectory = Directory.systemTemp.createTempSync('analysisServer');
 
     server.onNotification(ANALYSIS_ERRORS).listen((params) {
       expect(params, isMap);
       expect(params['file'], isString);
@@ skipping 555 matching lines @@
    */
   void _recordStdio(String line) {
     double elapsedTime = _time.elapsedTicks / _time.frequency;
     line = "$elapsedTime: $line";
     if (_debuggingStdio) {
       print(line);
     }
     _recordedStdio.add(line);
   }
 }