Change integration test notifications to use structured objects.

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 24 matching lines @@
 
   /**
    * Temporary directory in which source files can be stored.
    */
   Directory sourceDirectory;
 
   /**
    * Map from file path to the list of analysis errors which have most recently
    * been received for the file.
    */
-  HashMap<String, dynamic> currentAnalysisErrors = new HashMap<String, dynamic>(
-      );
+  HashMap<String, List<AnalysisError>> currentAnalysisErrors =
+      new HashMap<String, List<AnalysisError>>();
 
   /**
    * True if the teardown process should skip sending a "server.shutdown"
    * request (e.g. because the server is known to have already shutdown).
    */
   bool skipShutdown = false;
 
   /**
    * Data associated with the "server.connected" notification that was received
    * when the server started up.
@@ skipping 54 matching lines @@
    * 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 = onServerStatus.listen((params) {
-      bool analysisComplete = false;
-      try {
-        analysisComplete = !params['analysis']['isAnalyzing'];
-      } 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) {
+    subscription = onServerStatus.listen((ServerStatusParams params) {
+      if (!params.analysis.isAnalyzing) {
         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<ServerService> subscriptions) {
     _subscribedToServerStatus = subscriptions.contains(ServerService.STATUS);
     return super.sendServerSetSubscriptions(subscriptions);
   }
 
   /**
    * The server is automatically started before every test, and a temporary
    * [sourceDirectory] is created.
    */
   Future setUp() {
     sourceDirectory = Directory.systemTemp.createTempSync('analysisServer');
 
-    onAnalysisErrors.listen((params) {
-      currentAnalysisErrors[params['file']] = params['errors'];
+    onAnalysisErrors.listen((AnalysisErrorsParams params) {
+      currentAnalysisErrors[params.file] = params.errors;
     });
     Completer serverConnected = new Completer();
     onServerConnected.listen((_) {
       expect(serverConnected.isCompleted, isFalse);
       serverConnected.complete();
     });
     return server.start(dispatchNotification).then((params) {
       serverConnectedParams = params;
       server.exitCode.then((_) {
         skipShutdown = true;
@@ skipping 69 matching lines @@
       return true;
     } else {
       addStateInfo(matchState, {
         'mismatches': mismatches
       });
       return false;
     }
   }
 
   @override
-  Description describeMismatch(item, Description mismatchDescription, Map
-      matchState, bool verbose) {
+  Description describeMismatch(item, Description mismatchDescription,
+      Map matchState, bool verbose) {
     List<MismatchDescriber> mismatches = matchState['mismatches'];
     if (mismatches != null) {
       for (int i = 0; i < mismatches.length; i++) {
         MismatchDescriber mismatch = mismatches[i];
         if (i > 0) {
           if (mismatches.length == 2) {
             mismatchDescription = mismatchDescription.add(' and ');
           } else if (i == mismatches.length - 1) {
             mismatchDescription = mismatchDescription.add(', and ');
           } else {
             mismatchDescription = mismatchDescription.add(', ');
           }
         }
         mismatchDescription = mismatch(mismatchDescription);
       }
       return mismatchDescription;
     } else {
-      return super.describeMismatch(item, mismatchDescription, matchState,
+      return super.describeMismatch(
+          item,
+          mismatchDescription,
+          matchState,
           verbose);
     }
   }
 
   /**
    * Populate [mismatches] with descriptions of all the ways in which [item]
    * does not match.
    */
   void populateMismatches(item, List<MismatchDescriber> mismatches);
 
   /**
    * Create a [MismatchDescriber] describing a mismatch with a simple string.
    */
-  MismatchDescriber simpleDescription(String description) => (Description
-      mismatchDescription) {
+  MismatchDescriber simpleDescription(String description) =>
+      (Description mismatchDescription) {
     mismatchDescription.add(description);
   };
 
   /**
    * Check the type of a substructure whose value is [item], using [matcher].
    * If it doesn't match, record a closure in [mismatches] which can describe
    * the mismatch.  [describeSubstructure] is used to describe which
    * substructure did not match.
    */
-  checkSubstructure(item, Matcher matcher, List<MismatchDescriber>
-      mismatches, Description describeSubstructure(Description)) {
+  checkSubstructure(item, Matcher matcher, List<MismatchDescriber> mismatches,
+      Description describeSubstructure(Description)) {
     Map subState = {};
     if (!matcher.matches(item, subState)) {
       mismatches.add((Description mismatchDescription) {
         mismatchDescription = mismatchDescription.add('contains malformed ');
         mismatchDescription = describeSubstructure(mismatchDescription);
-        mismatchDescription = mismatchDescription.add(' (should be '
-            ).addDescriptionOf(matcher);
-        String subDescription = matcher.describeMismatch(item,
-            new StringDescription(), subState, false).toString();
+        mismatchDescription =
+            mismatchDescription.add(' (should be ').addDescriptionOf(matcher);
+        String subDescription = matcher.describeMismatch(
+            item,
+            new StringDescription(),
+            subState,
+            false).toString();
         if (subDescription.isNotEmpty) {
-          mismatchDescription = mismatchDescription.add('; ').add(subDescription
-              );
+          mismatchDescription =
+              mismatchDescription.add('; ').add(subDescription);
         }
         return mismatchDescription.add(')');
       });
     }
   }
 }
 
 /**
  * Matcher that matches a String drawn from a limited set.
  */
 class MatchesEnum extends Matcher {
   /**
    * Short description of the expected type.
    */
   final String description;
 
   /**
    * The set of enum values that are allowed.
    */
   final List<String> allowedValues;
 
   const MatchesEnum(this.description, this.allowedValues);
 
   @override
   bool matches(item, Map matchState) {
     return allowedValues.contains(item);
   }
 
   @override
-  Description describe(Description description) => description.add(
-      this.description);
+  Description describe(Description description) =>
+      description.add(this.description);
 }
 
 /**
  * Matcher that matches a JSON object, with a given set of required and
  * optional fields, and their associated types (expressed as [Matcher]s).
  */
 class MatchesJsonObject extends _RecursiveMatcher {
   /**
    * Short description of the expected type.
    */
   final String description;
 
   /**
    * Fields that are required to be in the JSON object, and [Matcher]s describing
    * their expected types.
    */
   final Map<String, Matcher> requiredFields;
 
   /**
    * Fields that are optional in the JSON object, and [Matcher]s describing
    * their expected types.
    */
   final Map<String, Matcher> optionalFields;
 
-  const
-      MatchesJsonObject(this.description, this.requiredFields, {this.optionalFields});
+  const MatchesJsonObject(this.description, this.requiredFields,
+      {this.optionalFields});
 
   @override
   void populateMismatches(item, List<MismatchDescriber> mismatches) {
     if (item is! Map) {
       mismatches.add(simpleDescription('is not a map'));
       return;
     }
     if (requiredFields != null) {
       requiredFields.forEach((String key, Matcher valueMatcher) {
         if (!item.containsKey(key)) {
-          mismatches.add((Description mismatchDescription) =>
-              mismatchDescription.add('is missing field ').addDescriptionOf(key).add(' ('
-              ).addDescriptionOf(valueMatcher).add(')'));
+          mismatches.add(
+              (Description mismatchDescription) =>
+                  mismatchDescription.add(
+                      'is missing field ').addDescriptionOf(
+                          key).add(' (').addDescriptionOf(valueMatcher).add(')'));
         } else {
           _checkField(key, item[key], valueMatcher, mismatches);
         }
       });
     }
     item.forEach((key, value) {
       if (requiredFields != null && requiredFields.containsKey(key)) {
         // Already checked this field
       } else if (optionalFields != null && optionalFields.containsKey(key)) {
         _checkField(key, value, optionalFields[key], mismatches);
       } else {
-        mismatches.add((Description mismatchDescription) =>
-            mismatchDescription.add('has unexpected field ').addDescriptionOf(key));
+        mismatches.add(
+            (Description mismatchDescription) =>
+                mismatchDescription.add('has unexpected field ').addDescriptionOf(key));
       }
     });
   }
 
   @override
-  Description describe(Description description) => description.add(
-      this.description);
+  Description describe(Description description) =>
+      description.add(this.description);
 
   /**
    * Check the type of a field called [key], having value [value], using
    * [valueMatcher].  If it doesn't match, record a closure in [mismatches]
    * which can describe the mismatch.
    */
-  void _checkField(String key, value, Matcher
-      valueMatcher, List<MismatchDescriber> mismatches) {
-    checkSubstructure(value, valueMatcher, mismatches, (Description description)
-        => description.add('field ').addDescriptionOf(key));
+  void _checkField(String key, value, Matcher valueMatcher,
+      List<MismatchDescriber> mismatches) {
+    checkSubstructure(
+        value,
+        valueMatcher,
+        mismatches,
+        (Description description) => description.add('field ').addDescriptionOf(key));
   }
 }
 
 /**
  * Matcher that matches a list of objects, each of which satisfies the given
  * matcher.
  */
 class _ListOf extends Matcher {
   /**
    * Matcher which every element of the list must satisfy.
@@ skipping 11 matching lines @@
 
   @override
   bool matches(item, Map matchState) {
     if (item is! List) {
       return false;
     }
     return iterableMatcher.matches(item, matchState);
   }
 
   @override
-  Description describe(Description description) => description.add('List of '
-      ).addDescriptionOf(elementMatcher);
+  Description describe(Description description) =>
+      description.add('List of ').addDescriptionOf(elementMatcher);
 
   @override
-  Description describeMismatch(item, Description mismatchDescription, Map
-      matchState, bool verbose) {
+  Description describeMismatch(item, Description mismatchDescription,
+      Map matchState, bool verbose) {
     if (item is! List) {
-      return super.describeMismatch(item, mismatchDescription, matchState,
+      return super.describeMismatch(
+          item,
+          mismatchDescription,
+          matchState,
           verbose);
     } else {
-      return iterableMatcher.describeMismatch(item, mismatchDescription,
-          matchState, verbose);
+      return iterableMatcher.describeMismatch(
+          item,
+          mismatchDescription,
+          matchState,
+          verbose);
     }
   }
 }
 
 Matcher isListOf(Matcher elementMatcher) => new _ListOf(elementMatcher);
 
 /**
  * Type of closures used by LazyMatcher.
  */
 typedef Matcher MatcherCreator();
@@ skipping 18 matching lines @@
 
   LazyMatcher(this._creator);
 
   @override
   Description describe(Description description) {
     _createMatcher();
     return _wrappedMatcher.describe(description);
   }
 
   @override
-  Description describeMismatch(item, Description mismatchDescription, Map matchState, bool verbose) {
+  Description describeMismatch(item, Description mismatchDescription,
+      Map matchState, bool verbose) {
     _createMatcher();
-    return _wrappedMatcher.describeMismatch(item, mismatchDescription, matchState, verbose);
+    return _wrappedMatcher.describeMismatch(
+        item,
+        mismatchDescription,
+        matchState,
+        verbose);
   }
 
   @override
   bool matches(item, Map matchState) {
     _createMatcher();
     return _wrappedMatcher.matches(item, matchState);
   }
 
   /**
    * Create the wrapped matcher object, if it hasn't been created already.
@@ skipping 66 matching lines @@
 
   _MapOf(this.keyMatcher, this.valueMatcher);
 
   @override
   void populateMismatches(item, List<MismatchDescriber> mismatches) {
     if (item is! Map) {
       mismatches.add(simpleDescription('is not a map'));
       return;
     }
     item.forEach((key, value) {
-      checkSubstructure(key, keyMatcher, mismatches, (Description description)
-          => description.add('key ').addDescriptionOf(key));
-      checkSubstructure(value, valueMatcher, mismatches, (Description
-          description) => description.add('field ').addDescriptionOf(key));
+      checkSubstructure(
+          key,
+          keyMatcher,
+          mismatches,
+          (Description description) => description.add('key ').addDescriptionOf(key));
+      checkSubstructure(
+          value,
+          valueMatcher,
+          mismatches,
+          (Description description) => description.add('field ').addDescriptionOf(key));
     });
   }
 
   @override
-  Description describe(Description description) => description.add('Map from '
-      ).addDescriptionOf(keyMatcher).add(' to ').addDescriptionOf(valueMatcher);
+  Description describe(Description description) =>
+      description.add(
+          'Map from ').addDescriptionOf(
+              keyMatcher).add(' to ').addDescriptionOf(valueMatcher);
 }
 
-Matcher isMapOf(Matcher keyMatcher, Matcher valueMatcher) => new _MapOf(
-    keyMatcher, valueMatcher);
+Matcher isMapOf(Matcher keyMatcher, Matcher valueMatcher) =>
+    new _MapOf(keyMatcher, valueMatcher);
 
 /**
  * Type of callbacks used to process notifications.
  */
 typedef void NotificationProcessor(String event, params);
 
 /**
  * Instances of the class [Server] manage a connection to a server process, and
  * facilitate communication to and from the server.
  */
 class Server {
   /**
    * Server process object, or null if server hasn't been started yet.
    */
   Process _process = null;
 
   /**
    * Commands that have been sent to the server but not yet acknowledged, and
    * the [Completer] objects which should be completed when acknowledgement is
    * received.
    */
-  final HashMap<String, Completer> _pendingCommands = <String, Completer> {};
+  final HashMap<String, Completer> _pendingCommands = <String, Completer>{};
 
   /**
    * Number which should be used to compute the 'id' to send in the next command
    * sent to the server.
    */
   int _nextId = 0;
 
   /**
    * [StreamController] to which notifications will be sent.
    */
@@ skipping 43 matching lines @@
    */
   Future start(NotificationProcessor notificationProcessor, {bool debugServer:
       false}) {
     if (_process != null) {
       throw new Exception('Process already started');
     }
     _time.start();
     // TODO(paulberry): move the logic for finding the script, the dart
     // executable, and the package root into a shell script.
     String dartBinary = Platform.executable;
-    String rootDir = findRoot(Platform.script.toFilePath(windows:
-        Platform.isWindows));
+    String rootDir =
+        findRoot(Platform.script.toFilePath(windows: Platform.isWindows));
     String serverPath = normalize(join(rootDir, 'bin', 'server.dart'));
     List<String> arguments = [];
     if (debugServer) {
       arguments.add('--debug');
     }
     if (Platform.packageRoot.isNotEmpty) {
       arguments.add('--package-root=${Platform.packageRoot}');
     }
     arguments.add('--checked');
     arguments.add(serverPath);
     return Process.start(dartBinary, arguments).then((Process process) {
       _process = process;
-      process.stdout.transform((new Utf8Codec()).decoder).transform(
-          new LineSplitter()).listen((String line) {
+      process.stdout.transform(
+          (new Utf8Codec()).decoder).transform(new LineSplitter()).listen((String line) {
         String trimmedLine = line.trim();
         _recordStdio('RECV: $trimmedLine');
         var message;
         try {
           message = JSON.decoder.convert(trimmedLine);
         } catch (exception) {
           _badDataFromServer();
           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');
           } else {
             _pendingCommands.remove(id);
           }
           if (messageAsMap.containsKey('error')) {
             // TODO(paulberry): propagate the error info to the completer.
-            completer.completeError(new UnimplementedError(
-                'Server responded with an error: ${JSON.encode(message)}'));
+            completer.completeError(
+                new UnimplementedError(
+                    'Server responded with an error: ${JSON.encode(message)}'));
           } else {
             completer.complete(messageAsMap['result']);
           }
           // Check that the message is well-formed.  We do this after calling
           // completer.complete() or completer.completeError() so that we don't
           // stall the test in the event of an error.
           expect(message, isResponse);
         } else {
           // Message is a notification.  It should have an event and possibly
           // params.
           expect(messageAsMap, contains('event'));
           expect(messageAsMap['event'], isString);
           notificationProcessor(messageAsMap['event'], messageAsMap['params']);
           // Check that the message is well-formed.  We do this after calling
           // notificationController.add() so that we don't stall the test in the
           // event of an error.
           expect(message, isNotification);
         }
       });
-      process.stderr.transform((new Utf8Codec()).decoder).transform(
-          new LineSplitter()).listen((String line) {
+      process.stderr.transform(
+          (new Utf8Codec()).decoder).transform(new LineSplitter()).listen((String line) {
         String trimmedLine = line.trim();
         _recordStdio('ERR:  $trimmedLine');
         _badDataFromServer();
       });
       process.exitCode.then((int code) {
         _recordStdio('TERMINATED WITH EXIT CODE $code');
         if (code != 0) {
           _badDataFromServer();
         }
       });
@@ skipping 18 matching lines @@
   /**
    * 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.
    */
   Future send(String method, Map<String, dynamic> params) {
     String id = '${_nextId++}';
-    Map<String, dynamic> command = <String, dynamic> {
+    Map<String, dynamic> command = <String, dynamic>{
       'id': id,
       'method': method
     };
     if (params != null) {
       command['params'] = params;
     }
     Completer completer = new Completer();
     _pendingCommands[id] = completer;
     String line = JSON.encode(command);
     _recordStdio('SEND: $line');
@@ skipping 41 matching lines @@
    */
   void _recordStdio(String line) {
     double elapsedTime = _time.elapsedTicks / _time.frequency;
     line = "$elapsedTime: $line";
     if (_debuggingStdio) {
       print(line);
     }
     _recordedStdio.add(line);
   }
 }