Beef up analysis server integration test messages.

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 156 matching lines @@
    * If [skipShutdown] is not set, shut down the server.
    */
   Future shutdownIfNeeded() {
     if (skipShutdown) {
       return new Future.value();
     }
     // Give the server a short time to comply with the shutdown request; if it
     // doesn't exit, then forcibly terminate it.
     sendServerShutdown();
     return server.exitCode.timeout(SHUTDOWN_TIMEOUT, onTimeout: () {
-      return server.kill();
+      return server.kill('server failed to exit');
     });
   }
 
   /**
    * 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));
@@ skipping 296 matching lines @@
    * Return a future that will complete when all commands that have been sent
    * to the server so far have been flushed to the OS buffer.
    */
   Future flushCommands() {
     return _process.stdin.flush();
   }
 
   /**
    * Stop the server.
    */
-  Future kill() {
+  Future kill(String reason) {
     debugStdio();
-    _recordStdio('PROCESS FORCIBLY TERMINATED');
+    _recordStdio('FORCIBLY TERMINATING PROCESS: $reason');
     _process.kill();
     return _process.exitCode;
   }
 
   /**
    * Start listening to output from the server, and deliver notifications to
    * [notificationProcessor].
    */
   void listenToOutput(NotificationProcessor notificationProcessor) {
     _process.stdout
         .transform((new Utf8Codec()).decoder)
         .transform(new LineSplitter())
         .listen((String line) {
       lastCommunicationTime = currentElapseTime;
       String trimmedLine = line.trim();
       _recordStdio('RECV: $trimmedLine');
       var message;
       try {
         message = JSON.decoder.convert(trimmedLine);
       } catch (exception) {
-        _badDataFromServer();
+        _badDataFromServer('JSON decode failure: $exception');
         return;
       }
       expect(message, isMap);
       Map messageAsMap = message;
       if (messageAsMap.containsKey('id')) {
         expect(messageAsMap['id'], isString);
         String id = message['id'];
         Completer completer = _pendingCommands[id];
         if (completer == null) {
           fail('Unexpected response from server: id=$id');
@@ skipping 22 matching lines @@
         // event of an error.
         expect(message, isNotification);
       }
     });
     _process.stderr
         .transform((new Utf8Codec()).decoder)
         .transform(new LineSplitter())
         .listen((String line) {
       String trimmedLine = line.trim();
       _recordStdio('ERR:  $trimmedLine');
-      _badDataFromServer();
+      _badDataFromServer('Message received on stderr', silent: true);
     });
   }
 
   /**
    * Send a command to the server.  An 'id' will be automatically assigned.
    * The returned [Future] will be completed when the server acknowledges the
    * command with a response.  If the server acknowledges the command with a
    * normal (non-error) response, the future will be completed with the 'result'
    * field from the response.  If the server acknowledges the command with an
    * error response, the future will be completed with an error.
@@ skipping 52 matching lines @@
       arguments.add(diagnosticPort.toString());
     }
     if (useAnalysisHighlight2) {
       arguments.add('--useAnalysisHighlight2');
     }
 //    print('Launching $serverPath');
 //    print('$dartBinary ${arguments.join(' ')}');
     return Process.start(dartBinary, arguments).then((Process process) {
       _process = process;
       process.exitCode.then((int code) {
-        _recordStdio('TERMINATED WITH EXIT CODE $code');
         if (code != 0) {
-          _badDataFromServer();
+          _badDataFromServer('server terminated with exit code $code');
         }
       });
     });
   }
 
   /**
    * Deal with bad data received from the server.
    */
-  void _badDataFromServer() {
+  void _badDataFromServer(String details, {bool silent: false}) {
+    if (!silent) {
+      _recordStdio('BAD DATA FROM SERVER: $details');
+    }
     if (_receivedBadDataFromServer) {
       // We're already dealing with it.
       return;
     }
     _receivedBadDataFromServer = true;
     debugStdio();
     // Give the server 1 second to continue outputting bad data before we kill
     // the test.  This is helpful if the server has had an unhandled exception
     // and is outputting a stacktrace, because it ensures that we see the
     // entire stacktrace.  Use expectAsync() to prevent the test from
     // ending during this 1 second.
     new Future.delayed(new Duration(seconds: 1), expectAsync(() {
-      fail('Bad data received from server');
+      fail('Bad data received from server: $details');
     }));
   }
 
   /**
    * Record a message that was exchanged with the server, and print it out if
    * [debugStdio] has been called.
    */
   void _recordStdio(String line) {
     double elapsedTime = currentElapseTime;
     line = "$elapsedTime: $line";
@@ skipping 215 matching lines @@
   void populateMismatches(item, List<MismatchDescriber> mismatches);
 
   /**
    * Create a [MismatchDescriber] describing a mismatch with a simple string.
    */
   MismatchDescriber simpleDescription(String description) =>
       (Description mismatchDescription) {
         mismatchDescription.add(description);
       };
 }