Replace expect() with outOfTestExpect() in Analysis Server performance benchmark.

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 33 matching lines @@
 
   /**
    * Cleanly shutdown the analysis server. Requests that are received after
    * this request will not be processed. Requests that were received before
    * this request, but for which a response has not yet been sent, will not be
    * responded to. No further responses or notifications will be sent after the
    * response to this request has been sent.
    */
   Future sendServerShutdown() async {
     var result = await server.send("server.shutdown", null);
-    expect(result, isNull);
+    outOfTestExpect(result, isNull);
     return null;
   }
 
   /**
    * Subscribe for services. All previous subscriptions are replaced by the
    * given set of services.
    *
    * It is an error if any of the elements in the list are not valid services.
    * If there is an error, then the current subscriptions will remain
    * unchanged.
    *
    * Parameters
    *
    * subscriptions (List<ServerService>)
    *
    *   A list of the services being subscribed to.
    */
   Future sendServerSetSubscriptions(List<ServerService> subscriptions) async {
     var params = new ServerSetSubscriptionsParams(subscriptions).toJson();
     var result = await server.send("server.setSubscriptions", params);
-    expect(result, isNull);
+    outOfTestExpect(result, isNull);
     return null;
   }
 
   /**
    * 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.
    *
@@ skipping 283 matching lines @@
    *
    * Parameters
    *
    * roots (optional List<FilePath>)
    *
    *   A list of the analysis roots that are to be re-analyzed.
    */
   Future sendAnalysisReanalyze({List<String> roots}) async {
     var params = new AnalysisReanalyzeParams(roots: roots).toJson();
     var result = await server.send("analysis.reanalyze", params);
-    expect(result, isNull);
+    outOfTestExpect(result, isNull);
     return null;
   }
 
   /**
    * Sets the root paths used to determine which files to analyze. The set of
    * files to be analyzed are all of the files in one of the root paths that
    * are not either explicitly or implicitly excluded. A file is explicitly
    * excluded if it is in one of the excluded paths. A file is implicitly
    * excluded if it is in a subdirectory of one of the root paths where the
    * name of the subdirectory starts with a period (that is, a hidden
@@ skipping 45 matching lines @@
    *   VM when executing any Dart file inside the source directory.
    *
    *   Files in any directories that are not overridden by this mapping have
    *   their package: URI's resolved using the normal pubspec.yaml mechanism.
    *   If this field is absent, or the empty map is specified, that indicates
    *   that the normal pubspec.yaml mechanism should always be used.
    */
   Future sendAnalysisSetAnalysisRoots(List<String> included, List<String> excluded, {Map<String, String> packageRoots}) async {
     var params = new AnalysisSetAnalysisRootsParams(included, excluded, packageRoots: packageRoots).toJson();
     var result = await server.send("analysis.setAnalysisRoots", params);
-    expect(result, isNull);
+    outOfTestExpect(result, isNull);
     return null;
   }
 
   /**
    * Subscribe for general services (that is, services that are not specific to
    * individual files). All previous subscriptions are replaced by the given
    * set of services.
    *
    * It is an error if any of the elements in the list are not valid services.
    * If there is an error, then the current subscriptions will remain
    * unchanged.
    *
    * Parameters
    *
    * subscriptions (List<GeneralAnalysisService>)
    *
    *   A list of the services being subscribed to.
    */
   Future sendAnalysisSetGeneralSubscriptions(List<GeneralAnalysisService> subscriptions) async {
     var params = new AnalysisSetGeneralSubscriptionsParams(subscriptions).toJson();
     var result = await server.send("analysis.setGeneralSubscriptions", params);
-    expect(result, isNull);
+    outOfTestExpect(result, isNull);
     return null;
   }
 
   /**
    * Set the priority files to the files in the given list. A priority file is
    * a file that is given priority when scheduling which analysis work to do
    * first. The list typically contains those files that are visible to the
    * user and those for which analysis results will have the biggest impact on
    * the user experience. The order of the files within the list is
    * significant: the first file will be given higher priority than the second,
@@ skipping 11 matching lines @@
    *
    * Parameters
    *
    * files (List<FilePath>)
    *
    *   The files that are to be a priority for analysis.
    */
   Future sendAnalysisSetPriorityFiles(List<String> files) async {
     var params = new AnalysisSetPriorityFilesParams(files).toJson();
     var result = await server.send("analysis.setPriorityFiles", params);
-    expect(result, isNull);
+    outOfTestExpect(result, isNull);
     return null;
   }
 
   /**
    * Subscribe for services that are specific to individual files. All previous
    * subscriptions are replaced by the current set of subscriptions. If a given
    * service is not included as a key in the map then no files will be
    * subscribed to the service, exactly as if the service had been included in
    * the map with an explicit empty list of files.
    *
@@ skipping 18 matching lines @@
    * Parameters
    *
    * subscriptions (Map<AnalysisService, List<FilePath>>)
    *
    *   A table mapping services to a list of the files being subscribed to the
    *   service.
    */
   Future sendAnalysisSetSubscriptions(Map<AnalysisService, List<String>> subscriptions) async {
     var params = new AnalysisSetSubscriptionsParams(subscriptions).toJson();
     var result = await server.send("analysis.setSubscriptions", params);
-    expect(result, isNull);
+    outOfTestExpect(result, isNull);
     return null;
   }
 
   /**
    * Update the content of one or more files. Files that were previously
    * updated but not included in this update remain unchanged. This effectively
    * represents an overlay of the filesystem. The files whose content is
    * overridden are therefore seen by server as being files with the given
    * content, even if the files do not exist on the filesystem or if the file
    * path represents the path to a directory on the filesystem.
@@ skipping 23 matching lines @@
    *
    * Parameters
    *
    * options (AnalysisOptions)
    *
    *   The options that are to be used to control analysis.
    */
   Future sendAnalysisUpdateOptions(AnalysisOptions options) async {
     var params = new AnalysisUpdateOptionsParams(options).toJson();
     var result = await server.send("analysis.updateOptions", params);
-    expect(result, isNull);
+    outOfTestExpect(result, isNull);
     return null;
   }
 
   /**
    * Reports the paths of the files that are being analyzed.
    *
    * This notification is not subscribed to by default. Clients can subscribe
    * by including the value "ANALYZED_FILES" in the list of services passed in
    * an analysis.setGeneralSubscriptions request.
    *
@@ skipping 903 matching lines @@
    *
    * Parameters
    *
    * id (ExecutionContextId)
    *
    *   The identifier of the execution context that is to be deleted.
    */
   Future sendExecutionDeleteContext(String id) async {
     var params = new ExecutionDeleteContextParams(id).toJson();
     var result = await server.send("execution.deleteContext", params);
-    expect(result, isNull);
+    outOfTestExpect(result, isNull);
     return null;
   }
 
   /**
    * Map a URI from the execution context to the file that it corresponds to,
    * or map a file to the URI that it corresponds to in the execution context.
    *
    * Exactly one of the file and uri fields must be provided. If both fields
    * are provided, then an error of type INVALID_PARAMETER will be generated.
    * Similarly, if neither field is provided, then an error of type
@@ skipping 55 matching lines @@
    *
    * Parameters
    *
    * subscriptions (List<ExecutionService>)
    *
    *   A list of the services being subscribed to.
    */
   Future sendExecutionSetSubscriptions(List<ExecutionService> subscriptions) async {
     var params = new ExecutionSetSubscriptionsParams(subscriptions).toJson();
     var result = await server.send("execution.setSubscriptions", params);
-    expect(result, isNull);
+    outOfTestExpect(result, isNull);
     return null;
   }
 
   /**
    * Reports information needed to allow a single file to be launched.
    *
    * This notification is not subscribed to by default. Clients can subscribe
    * by including the value "LAUNCH_DATA" in the list of services passed in an
    * execution.setSubscriptions request.
    *
@@ skipping 78 matching lines @@
   }
 
   /**
    * 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);
+        outOfTestExpect(params, isServerConnectedParams);
         _onServerConnected.add(new ServerConnectedParams.fromJson(decoder, 'params', params));
         break;
       case "server.error":
-        expect(params, isServerErrorParams);
+        outOfTestExpect(params, isServerErrorParams);
         _onServerError.add(new ServerErrorParams.fromJson(decoder, 'params', params));
         break;
       case "server.status":
-        expect(params, isServerStatusParams);
+        outOfTestExpect(params, isServerStatusParams);
         _onServerStatus.add(new ServerStatusParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.analyzedFiles":
-        expect(params, isAnalysisAnalyzedFilesParams);
+        outOfTestExpect(params, isAnalysisAnalyzedFilesParams);
         _onAnalysisAnalyzedFiles.add(new AnalysisAnalyzedFilesParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.errors":
-        expect(params, isAnalysisErrorsParams);
+        outOfTestExpect(params, isAnalysisErrorsParams);
         _onAnalysisErrors.add(new AnalysisErrorsParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.flushResults":
-        expect(params, isAnalysisFlushResultsParams);
+        outOfTestExpect(params, isAnalysisFlushResultsParams);
         _onAnalysisFlushResults.add(new AnalysisFlushResultsParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.folding":
-        expect(params, isAnalysisFoldingParams);
+        outOfTestExpect(params, isAnalysisFoldingParams);
         _onAnalysisFolding.add(new AnalysisFoldingParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.highlights":
-        expect(params, isAnalysisHighlightsParams);
+        outOfTestExpect(params, isAnalysisHighlightsParams);
         _onAnalysisHighlights.add(new AnalysisHighlightsParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.implemented":
-        expect(params, isAnalysisImplementedParams);
+        outOfTestExpect(params, isAnalysisImplementedParams);
         _onAnalysisImplemented.add(new AnalysisImplementedParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.invalidate":
-        expect(params, isAnalysisInvalidateParams);
+        outOfTestExpect(params, isAnalysisInvalidateParams);
         _onAnalysisInvalidate.add(new AnalysisInvalidateParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.navigation":
-        expect(params, isAnalysisNavigationParams);
+        outOfTestExpect(params, isAnalysisNavigationParams);
         _onAnalysisNavigation.add(new AnalysisNavigationParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.occurrences":
-        expect(params, isAnalysisOccurrencesParams);
+        outOfTestExpect(params, isAnalysisOccurrencesParams);
         _onAnalysisOccurrences.add(new AnalysisOccurrencesParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.outline":
-        expect(params, isAnalysisOutlineParams);
+        outOfTestExpect(params, isAnalysisOutlineParams);
         _onAnalysisOutline.add(new AnalysisOutlineParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.overrides":
-        expect(params, isAnalysisOverridesParams);
+        outOfTestExpect(params, isAnalysisOverridesParams);
         _onAnalysisOverrides.add(new AnalysisOverridesParams.fromJson(decoder, 'params', params));
         break;
       case "completion.results":
-        expect(params, isCompletionResultsParams);
+        outOfTestExpect(params, isCompletionResultsParams);
         _onCompletionResults.add(new CompletionResultsParams.fromJson(decoder, 'params', params));
         break;
       case "search.results":
-        expect(params, isSearchResultsParams);
+        outOfTestExpect(params, isSearchResultsParams);
         _onSearchResults.add(new SearchResultsParams.fromJson(decoder, 'params', params));
         break;
       case "execution.launchData":
-        expect(params, isExecutionLaunchDataParams);
+        outOfTestExpect(params, isExecutionLaunchDataParams);
         _onExecutionLaunchData.add(new ExecutionLaunchDataParams.fromJson(decoder, 'params', params));
         break;
       default:
         fail('Unexpected notification: $event');
         break;
     }
   }
 }