Change integration test notifications to use structured objects.

pkg/analysis_server/test/integration/integration_test_methods.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.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script
 // "pkg/analysis_server/tool/spec/generate_files".
 
 /**
  * Convenience methods for running integration tests
@@ skipping 70 matching lines @@
     });
   }
 
   /**
    * Reports that the server is running. This notification is issued once after
    * the server has started running but before any requests are processed to
    * let the client know that it started correctly.
    *
    * It is not possible to subscribe to or unsubscribe from this notification.
    */
-  Stream onServerConnected;
+  Stream<ServerConnectedParams> onServerConnected;
 
   /**
    * Stream controller for [onServerConnected].
    */
-  StreamController _onServerConnected;
+  StreamController<ServerConnectedParams> _onServerConnected;
 
   /**
    * Reports that an unexpected error has occurred while executing the server.
    * This notification is not used for problems with specific requests (which
    * are returned as part of the response) but is used for exceptions that
    * occur while performing other tasks, such as analysis or preparing
    * notifications.
    *
    * It is not possible to subscribe to or unsubscribe from this notification.
    *
    * Parameters
    *
    * isFatal ( bool )
    *
    *   True if the error is a fatal error, meaning that the server will
    *   shutdown automatically after sending this notification.
    *
    * message ( String )
    *
    *   The error message indicating what kind of error was encountered.
    *
    * stackTrace ( String )
    *
    *   The stack trace associated with the generation of the error, used for
    *   debugging the server.
    */
-  Stream onServerError;
+  Stream<ServerErrorParams> onServerError;
 
   /**
    * Stream controller for [onServerError].
    */
-  StreamController _onServerError;
+  StreamController<ServerErrorParams> _onServerError;
 
   /**
    * Reports the current status of the server. Parameters are omitted if there
    * has been no change in the status represented by that parameter.
    *
    * This notification is not subscribed to by default. Clients can subscribe
    * by including the value "STATUS" in the list of services passed in a
    * server.setSubscriptions request.
    *
    * Parameters
    *
    * analysis ( optional AnalysisStatus )
    *
    *   The current status of analysis, including whether analysis is being
    *   performed and if so what is being analyzed.
    */
-  Stream onServerStatus;
+  Stream<ServerStatusParams> onServerStatus;
 
   /**
    * Stream controller for [onServerStatus].
    */
-  StreamController _onServerStatus;
+  StreamController<ServerStatusParams> _onServerStatus;
 
   /**
    * Return the errors associated with the given file. If the errors for the
    * given file have not yet been computed, or the most recently computed
    * errors for the given file are out of date, then the response for this
    * request will be delayed until they have been computed. If some or all of
    * the errors for the file cannot be computed, then the subset of the errors
    * that can be computed will be returned and the response will contain an
    * error to indicate why the errors could not be computed.
    *
@@ skipping 250 matching lines @@
    * Parameters
    *
    * file ( FilePath )
    *
    *   The file containing the errors.
    *
    * errors ( List<AnalysisError> )
    *
    *   The errors contained in the file.
    */
-  Stream onAnalysisErrors;
+  Stream<AnalysisErrorsParams> onAnalysisErrors;
 
   /**
    * Stream controller for [onAnalysisErrors].
    */
-  StreamController _onAnalysisErrors;
+  StreamController<AnalysisErrorsParams> _onAnalysisErrors;
 
   /**
    * Reports that any analysis results that were previously associated with the
    * given files should be considered to be invalid because those files are no
    * longer being analyzed, either because the analysis root that contained it
    * is no longer being analyzed or because the file no longer exists.
    *
    * If a file is included in this notification and at some later time a
    * notification with results for the file is received, clients should assume
    * that the file is once again being analyzed and the information should be
    * processed.
    *
    * It is not possible to subscribe to or unsubscribe from this notification.
    *
    * Parameters
    *
    * files ( List<FilePath> )
    *
    *   The files that are no longer being analyzed.
    */
-  Stream onAnalysisFlushResults;
+  Stream<AnalysisFlushResultsParams> onAnalysisFlushResults;
 
   /**
    * Stream controller for [onAnalysisFlushResults].
    */
-  StreamController _onAnalysisFlushResults;
+  StreamController<AnalysisFlushResultsParams> _onAnalysisFlushResults;
 
   /**
    * Reports the folding regions associated with a given file. Folding regions
    * can be nested, but will not be overlapping. Nesting occurs when a foldable
    * element, such as a method, is nested inside another foldable element such
    * as a class.
    *
    * This notification is not subscribed to by default. Clients can subscribe
    * by including the value "FOLDING" in the list of services passed in an
    * analysis.setSubscriptions request.
    *
    * Parameters
    *
    * file ( FilePath )
    *
    *   The file containing the folding regions.
    *
    * regions ( List<FoldingRegion> )
    *
    *   The folding regions contained in the file.
    */
-  Stream onAnalysisFolding;
+  Stream<AnalysisFoldingParams> onAnalysisFolding;
 
   /**
    * Stream controller for [onAnalysisFolding].
    */
-  StreamController _onAnalysisFolding;
+  StreamController<AnalysisFoldingParams> _onAnalysisFolding;
 
   /**
    * Reports the highlight regions associated with a given file.
    *
    * This notification is not subscribed to by default. Clients can subscribe
    * by including the value "HIGHLIGHTS" in the list of services passed in an
    * analysis.setSubscriptions request.
    *
    * Parameters
    *
    * file ( FilePath )
    *
    *   The file containing the highlight regions.
    *
    * regions ( List<HighlightRegion> )
    *
    *   The highlight regions contained in the file. Each highlight region
    *   represents a particular syntactic or semantic meaning associated with
    *   some range. Note that the highlight regions that are returned can
    *   overlap other highlight regions if there is more than one meaning
    *   associated with a particular region.
    */
-  Stream onAnalysisHighlights;
+  Stream<AnalysisHighlightsParams> onAnalysisHighlights;
 
   /**
    * Stream controller for [onAnalysisHighlights].
    */
-  StreamController _onAnalysisHighlights;
+  StreamController<AnalysisHighlightsParams> _onAnalysisHighlights;
 
   /**
    * Reports the navigation targets associated with a given file.
    *
    * This notification is not subscribed to by default. Clients can subscribe
    * by including the value "NAVIGATION" in the list of services passed in an
    * analysis.setSubscriptions request.
    *
    * Parameters
    *
    * file ( FilePath )
    *
    *   The file containing the navigation regions.
    *
    * regions ( List<NavigationRegion> )
    *
    *   The navigation regions contained in the file. Each navigation region
    *   represents a list of targets associated with some range. The lists will
    *   usually contain a single target, but can contain more in the case of a
    *   part that is included in multiple libraries or in Dart code that is
    *   compiled against multiple versions of a package. Note that the
    *   navigation regions that are returned do not overlap other navigation
    *   regions.
    */
-  Stream onAnalysisNavigation;
+  Stream<AnalysisNavigationParams> onAnalysisNavigation;
 
   /**
    * Stream controller for [onAnalysisNavigation].
    */
-  StreamController _onAnalysisNavigation;
+  StreamController<AnalysisNavigationParams> _onAnalysisNavigation;
 
   /**
    * Reports the occurrences of references to elements within a single file.
    *
    * This notification is not subscribed to by default. Clients can subscribe
    * by including the value "OCCURRENCES" in the list of services passed in an
    * analysis.setSubscriptions request.
    *
    * Parameters
    *
    * file ( FilePath )
    *
    *   The file in which the references occur.
    *
    * occurrences ( List<Occurrences> )
    *
    *   The occurrences of references to elements within the file.
    */
-  Stream onAnalysisOccurrences;
+  Stream<AnalysisOccurrencesParams> onAnalysisOccurrences;
 
   /**
    * Stream controller for [onAnalysisOccurrences].
    */
-  StreamController _onAnalysisOccurrences;
+  StreamController<AnalysisOccurrencesParams> _onAnalysisOccurrences;
 
   /**
    * Reports the outline associated with a single file.
    *
    * This notification is not subscribed to by default. Clients can subscribe
    * by including the value "OUTLINE" in the list of services passed in an
    * analysis.setSubscriptions request.
    *
    * Parameters
    *
    * file ( FilePath )
    *
    *   The file with which the outline is associated.
    *
    * outline ( Outline )
    *
    *   The outline associated with the file.
    */
-  Stream onAnalysisOutline;
+  Stream<AnalysisOutlineParams> onAnalysisOutline;
 
   /**
    * Stream controller for [onAnalysisOutline].
    */
-  StreamController _onAnalysisOutline;
+  StreamController<AnalysisOutlineParams> _onAnalysisOutline;
 
   /**
    * Reports the overridding members in a file.
    *
    * This notification is not subscribed to by default. Clients can subscribe
    * by including the value "OVERRIDES" in the list of services passed in an
    * analysis.setSubscriptions request.
    *
    * Parameters
    *
    * file ( FilePath )
    *
    *   The file with which the overrides are associated.
    *
    * overrides ( List<Override> )
    *
    *   The overrides associated with the file.
    */
-  Stream onAnalysisOverrides;
+  Stream<AnalysisOverridesParams> onAnalysisOverrides;
 
   /**
    * Stream controller for [onAnalysisOverrides].
    */
-  StreamController _onAnalysisOverrides;
+  StreamController<AnalysisOverridesParams> _onAnalysisOverrides;
 
   /**
    * Request that completion suggestions for the given offset in the given file
    * be returned.
    *
    * Parameters
    *
    * file ( FilePath )
    *
    *   The file containing the point at which suggestions are to be made.
@@ skipping 48 matching lines @@
    *   possible completions at the requested cursor position, even those that
    *   do not match the characters the user has already typed. This allows the
    *   client to respond to further keystrokes from the user without having to
    *   make additional requests.
    *
    * isLast ( bool )
    *
    *   True if this is that last set of results that will be returned for the
    *   indicated completion.
    */
-  Stream onCompletionResults;
+  Stream<CompletionResultsParams> onCompletionResults;
 
   /**
    * Stream controller for [onCompletionResults].
    */
-  StreamController _onCompletionResults;
+  StreamController<CompletionResultsParams> _onCompletionResults;
 
   /**
    * Perform a search for references to the element defined or referenced at
    * the given offset in the given file.
    *
    * An identifier is returned immediately, and individual results will be
    * returned via the search.results notification as they become available.
    *
    * Parameters
    *
@@ skipping 178 matching lines @@
    *
    * results ( List<SearchResult> )
    *
    *   The search results being reported.
    *
    * isLast ( bool )
    *
    *   True if this is that last set of results that will be returned for the
    *   indicated search.
    */
-  Stream onSearchResults;
+  Stream<SearchResultsParams> onSearchResults;
 
   /**
    * Stream controller for [onSearchResults].
    */
-  StreamController _onSearchResults;
+  StreamController<SearchResultsParams> _onSearchResults;
 
   /**
    * Return the set of assists that are available at the given location. An
    * assist is distinguished from a refactoring primarily by the fact that it
    * affects a single file and does not require user input in order to be
    * performed.
    *
    * Parameters
    *
    * file ( FilePath )
@@ skipping 333 matching lines @@
    * kind ( optional ExecutableKind )
    *
    *   The kind of the executable file. This field is omitted if the file is
    *   not a Dart file.
    *
    * referencedFiles ( optional List<FilePath> )
    *
    *   A list of the Dart files that are referenced by the file. This field is
    *   omitted if the file is not an HTML file.
    */
-  Stream onExecutionLaunchData;
+  Stream<ExecutionLaunchDataParams> onExecutionLaunchData;
 
   /**
    * Stream controller for [onExecutionLaunchData].
    */
-  StreamController _onExecutionLaunchData;
+  StreamController<ExecutionLaunchDataParams> _onExecutionLaunchData;
 
   /**
    * Initialize the fields in InttestMixin, and ensure that notifications will
    * be handled.
    */
   void initializeInttestMixin() {
-    _onServerConnected = new StreamController(sync: true);
+    _onServerConnected = new StreamController<ServerConnectedParams>(sync: true);
     onServerConnected = _onServerConnected.stream.asBroadcastStream();
-    _onServerError = new StreamController(sync: true);
+    _onServerError = new StreamController<ServerErrorParams>(sync: true);
     onServerError = _onServerError.stream.asBroadcastStream();
-    _onServerStatus = new StreamController(sync: true);
+    _onServerStatus = new StreamController<ServerStatusParams>(sync: true);
     onServerStatus = _onServerStatus.stream.asBroadcastStream();
-    _onAnalysisErrors = new StreamController(sync: true);
+    _onAnalysisErrors = new StreamController<AnalysisErrorsParams>(sync: true);
     onAnalysisErrors = _onAnalysisErrors.stream.asBroadcastStream();
-    _onAnalysisFlushResults = new StreamController(sync: true);
+    _onAnalysisFlushResults = new StreamController<AnalysisFlushResultsParams>(sync: true);
     onAnalysisFlushResults = _onAnalysisFlushResults.stream.asBroadcastStream();
-    _onAnalysisFolding = new StreamController(sync: true);
+    _onAnalysisFolding = new StreamController<AnalysisFoldingParams>(sync: true);
     onAnalysisFolding = _onAnalysisFolding.stream.asBroadcastStream();
-    _onAnalysisHighlights = new StreamController(sync: true);
+    _onAnalysisHighlights = new StreamController<AnalysisHighlightsParams>(sync: true);
     onAnalysisHighlights = _onAnalysisHighlights.stream.asBroadcastStream();
-    _onAnalysisNavigation = new StreamController(sync: true);
+    _onAnalysisNavigation = new StreamController<AnalysisNavigationParams>(sync: true);
     onAnalysisNavigation = _onAnalysisNavigation.stream.asBroadcastStream();
-    _onAnalysisOccurrences = new StreamController(sync: true);
+    _onAnalysisOccurrences = new StreamController<AnalysisOccurrencesParams>(sync: true);
     onAnalysisOccurrences = _onAnalysisOccurrences.stream.asBroadcastStream();
-    _onAnalysisOutline = new StreamController(sync: true);
+    _onAnalysisOutline = new StreamController<AnalysisOutlineParams>(sync: true);
     onAnalysisOutline = _onAnalysisOutline.stream.asBroadcastStream();
-    _onAnalysisOverrides = new StreamController(sync: true);
+    _onAnalysisOverrides = new StreamController<AnalysisOverridesParams>(sync: true);
     onAnalysisOverrides = _onAnalysisOverrides.stream.asBroadcastStream();
-    _onCompletionResults = new StreamController(sync: true);
+    _onCompletionResults = new StreamController<CompletionResultsParams>(sync: true);
     onCompletionResults = _onCompletionResults.stream.asBroadcastStream();
-    _onSearchResults = new StreamController(sync: true);
+    _onSearchResults = new StreamController<SearchResultsParams>(sync: true);
     onSearchResults = _onSearchResults.stream.asBroadcastStream();
-    _onExecutionLaunchData = new StreamController(sync: true);
+    _onExecutionLaunchData = new StreamController<ExecutionLaunchDataParams>(sync: true);
     onExecutionLaunchData = _onExecutionLaunchData.stream.asBroadcastStream();
   }
 
   /**
    * Dispatch the notification named [event], and containing parameters
    * [params], to the appropriate stream.
    */
   void dispatchNotification(String event, params) {
+    ResponseDecoder decoder = new ResponseDecoder(null);
     switch (event) {
       case "server.connected":
         expect(params, isServerConnectedParams);
-        _onServerConnected.add(params);
+        _onServerConnected.add(new ServerConnectedParams());
         break;
       case "server.error":
         expect(params, isServerErrorParams);
-        _onServerError.add(params);
+        _onServerError.add(new ServerErrorParams.fromJson(decoder, 'params', params));
         break;
       case "server.status":
         expect(params, isServerStatusParams);
-        _onServerStatus.add(params);
+        _onServerStatus.add(new ServerStatusParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.errors":
         expect(params, isAnalysisErrorsParams);
-        _onAnalysisErrors.add(params);
+        _onAnalysisErrors.add(new AnalysisErrorsParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.flushResults":
         expect(params, isAnalysisFlushResultsParams);
-        _onAnalysisFlushResults.add(params);
+        _onAnalysisFlushResults.add(new AnalysisFlushResultsParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.folding":
         expect(params, isAnalysisFoldingParams);
-        _onAnalysisFolding.add(params);
+        _onAnalysisFolding.add(new AnalysisFoldingParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.highlights":
         expect(params, isAnalysisHighlightsParams);
-        _onAnalysisHighlights.add(params);
+        _onAnalysisHighlights.add(new AnalysisHighlightsParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.navigation":
         expect(params, isAnalysisNavigationParams);
-        _onAnalysisNavigation.add(params);
+        _onAnalysisNavigation.add(new AnalysisNavigationParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.occurrences":
         expect(params, isAnalysisOccurrencesParams);
-        _onAnalysisOccurrences.add(params);
+        _onAnalysisOccurrences.add(new AnalysisOccurrencesParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.outline":
         expect(params, isAnalysisOutlineParams);
-        _onAnalysisOutline.add(params);
+        _onAnalysisOutline.add(new AnalysisOutlineParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.overrides":
         expect(params, isAnalysisOverridesParams);
-        _onAnalysisOverrides.add(params);
+        _onAnalysisOverrides.add(new AnalysisOverridesParams.fromJson(decoder, 'params', params));
         break;
       case "completion.results":
         expect(params, isCompletionResultsParams);
-        _onCompletionResults.add(params);
+        _onCompletionResults.add(new CompletionResultsParams.fromJson(decoder, 'params', params));
         break;
       case "search.results":
         expect(params, isSearchResultsParams);
-        _onSearchResults.add(params);
+        _onSearchResults.add(new SearchResultsParams.fromJson(decoder, 'params', params));
         break;
       case "execution.launchData":
         expect(params, isExecutionLaunchDataParams);
-        _onExecutionLaunchData.add(params);
+        _onExecutionLaunchData.add(new ExecutionLaunchDataParams.fromJson(decoder, 'params', params));
         break;
       default:
         fail('Unexpected notification: $event');
         break;
     }
   }
 }