Rename debug domain to execution

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/spec/generate_files".
 
 /**
  * Convenience methods for running integration tests
@@ skipping 1065 matching lines @@
    *   The file containing the errors for which fixes are being requested.
    *
    * offset ( int )
    *
    *   The offset used to select the errors for which fixes will be returned.
    *
    * Returns
    *
    * fixes ( List<AnalysisErrorFixes> )
    *
-   *   The fixes that are available for each of the analysis errors. There is a
-   *   one-to-one correspondence between the analysis errors in the request and
-   *   the lists of changes in the response. In particular, it is always the
-   *   case that errors.length == fixes.length and that fixes[i] is the list of
-   *   fixes for the error in errors[i]. The list of changes corresponding to
-   *   an error can be empty if there are no fixes available for that error.
+   *   The fixes that are available for the errors at the given offset.
    */
   Future sendEditGetFixes(String file, int offset, {bool checkTypes: true}) {
     Map<String, dynamic> params = {};
     params["file"] = file;
     params["offset"] = offset;
     if (checkTypes) {
       expect(params, isEditGetFixesParams);
     }
     return server.send("edit.getFixes", params)
         .then((result) {
@@ skipping 85 matching lines @@
     return server.send("edit.getRefactoring", params)
         .then((result) {
       if (checkTypes) {
         expect(result, isEditGetRefactoringResult);
       }
       return result;
     });
   }
 
   /**
-   * Create a debugging context for the executable file with the given path.
-   * The context that is created will persist until debug.deleteContext is used
-   * to delete it. Clients, therefore, are responsible for managing the
-   * lifetime of debugging contexts.
+   * Create an execution context for the executable file with the given path.
+   * The context that is created will persist until execution.deleteContext is
+   * used to delete it. Clients, therefore, are responsible for managing the
+   * lifetime of execution contexts.
    *
    * Parameters
    *
    * contextRoot ( FilePath )
    *
    *   The path of the Dart or HTML file that will be launched.
    *
    * Returns
    *
-   * id ( DebugContextId )
+   * id ( ExecutionContextId )
    *
-   *   The identifier used to refer to the debugging context that was created.
+   *   The identifier used to refer to the execution context that was created.
    */
-  Future sendDebugCreateContext(String contextRoot, {bool checkTypes: true}) {
+  Future sendExecutionCreateContext(String contextRoot, {bool checkTypes: true}) {
     Map<String, dynamic> params = {};
     params["contextRoot"] = contextRoot;
     if (checkTypes) {
-      expect(params, isDebugCreateContextParams);
+      expect(params, isExecutionCreateContextParams);
     }
-    return server.send("debug.createContext", params)
+    return server.send("execution.createContext", params)
         .then((result) {
       if (checkTypes) {
-        expect(result, isDebugCreateContextResult);
+        expect(result, isExecutionCreateContextResult);
       }
       return result;
     });
   }
 
   /**
-   * Delete the debugging context with the given identifier. The context id is
+   * Delete the execution context with the given identifier. The context id is
    * no longer valid after this command. The server is allowed to re-use ids
    * when they are no longer valid.
    *
    * Parameters
    *
-   * id ( DebugContextId )
+   * id ( ExecutionContextId )
    *
-   *   The identifier of the debugging context that is to be deleted.
+   *   The identifier of the execution context that is to be deleted.
    */
-  Future sendDebugDeleteContext(String id, {bool checkTypes: true}) {
+  Future sendExecutionDeleteContext(String id, {bool checkTypes: true}) {
     Map<String, dynamic> params = {};
     params["id"] = id;
     if (checkTypes) {
-      expect(params, isDebugDeleteContextParams);
+      expect(params, isExecutionDeleteContextParams);
     }
-    return server.send("debug.deleteContext", params)
+    return server.send("execution.deleteContext", params)
         .then((result) {
       if (checkTypes) {
-        expect(result, isDebugDeleteContextResult);
+        expect(result, isExecutionDeleteContextResult);
       }
       return result;
     });
   }
 
   /**
-   * Map a URI from the debugging context to the file that it corresponds to,
-   * or map a file to the URI that it corresponds to in the debugging context.
+   * 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.
    *
    * Parameters
    *
-   * id ( DebugContextId )
+   * id ( ExecutionContextId )
    *
-   *   The identifier of the debugging context in which the URI is to be
+   *   The identifier of the execution context in which the URI is to be
    *   mapped.
    *
    * file ( optional FilePath )
    *
    *   The path of the file to be mapped into a URI.
    *
    * uri ( optional String )
    *
    *   The URI to be mapped into a file path.
    *
    * Returns
    *
    * file ( optional FilePath )
    *
    *   The file to which the URI was mapped. This field is omitted if the uri
    *   field was not given in the request.
    *
    * uri ( optional String )
    *
    *   The URI to which the file path was mapped. This field is omitted if the
    *   file field was not given in the request.
    */
-  Future sendDebugMapUri(String id, {String file, String uri, bool checkTypes: true}) {
+  Future sendExecutionMapUri(String id, {String file, String uri, bool checkTypes: true}) {
     Map<String, dynamic> params = {};
     params["id"] = id;
     if (file != null) {
       params["file"] = file;
     }
     if (uri != null) {
       params["uri"] = uri;
     }
     if (checkTypes) {
-      expect(params, isDebugMapUriParams);
+      expect(params, isExecutionMapUriParams);
     }
-    return server.send("debug.mapUri", params)
+    return server.send("execution.mapUri", params)
         .then((result) {
       if (checkTypes) {
-        expect(result, isDebugMapUriResult);
+        expect(result, isExecutionMapUriResult);
       }
       return result;
     });
   }
 
   /**
    * 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<DebugService> )
+   * subscriptions ( List<ExecutionService> )
    *
    *   A list of the services being subscribed to.
    */
-  Future sendDebugSetSubscriptions(List<String> subscriptions, {bool checkTypes: true}) {
+  Future sendExecutionSetSubscriptions(List<String> subscriptions, {bool checkTypes: true}) {
     Map<String, dynamic> params = {};
     params["subscriptions"] = subscriptions;
     if (checkTypes) {
-      expect(params, isDebugSetSubscriptionsParams);
+      expect(params, isExecutionSetSubscriptionsParams);
     }
-    return server.send("debug.setSubscriptions", params)
+    return server.send("execution.setSubscriptions", params)
         .then((result) {
       if (checkTypes) {
-        expect(result, isDebugSetSubscriptionsResult);
+        expect(result, isExecutionSetSubscriptionsResult);
       }
       return result;
     });
   }
 
   /**
    * Reports information needed to allow applications within the given context
    * 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 a
-   * debug.setSubscriptions request.
+   * execution.setSubscriptions request.
    *
    * Parameters
    *
    * executables ( List<ExecutableFile> )
    *
    *   A list of the files that are executable in the given context. This list
    *   replaces any previous list provided for the given context.
    *
    * dartToHtml ( Map<FilePath, List<FilePath>> )
    *
    *   A mapping from the paths of Dart files that are referenced by HTML files
    *   to a list of the HTML files that reference the Dart files.
    *
    * htmlToDart ( Map<FilePath, List<FilePath>> )
    *
    *   A mapping from the paths of HTML files that reference Dart files to a
    *   list of the Dart files they reference.
    */
-  Stream onDebugLaunchData;
+  Stream onExecutionLaunchData;
 
   /**
-   * Stream controller for [onDebugLaunchData].
+   * Stream controller for [onExecutionLaunchData].
    */
-  StreamController _onDebugLaunchData;
+  StreamController _onExecutionLaunchData;
 
   /**
    * Initialize the fields in InttestMixin, and ensure that notifications will
    * be handled.
    */
   void initializeInttestMixin() {
     _onServerConnected = new StreamController(sync: true);
     onServerConnected = _onServerConnected.stream.asBroadcastStream();
     _onServerError = new StreamController(sync: true);
     onServerError = _onServerError.stream.asBroadcastStream();
@@ skipping 12 matching lines @@
     _onAnalysisOccurrences = new StreamController(sync: true);
     onAnalysisOccurrences = _onAnalysisOccurrences.stream.asBroadcastStream();
     _onAnalysisOutline = new StreamController(sync: true);
     onAnalysisOutline = _onAnalysisOutline.stream.asBroadcastStream();
     _onAnalysisOverrides = new StreamController(sync: true);
     onAnalysisOverrides = _onAnalysisOverrides.stream.asBroadcastStream();
     _onCompletionResults = new StreamController(sync: true);
     onCompletionResults = _onCompletionResults.stream.asBroadcastStream();
     _onSearchResults = new StreamController(sync: true);
     onSearchResults = _onSearchResults.stream.asBroadcastStream();
-    _onDebugLaunchData = new StreamController(sync: true);
-    onDebugLaunchData = _onDebugLaunchData.stream.asBroadcastStream();
+    _onExecutionLaunchData = new StreamController(sync: true);
+    onExecutionLaunchData = _onExecutionLaunchData.stream.asBroadcastStream();
   }
 
   /**
    * Dispatch the notification named [event], and containing parameters
    * [params], to the appropriate stream.
    */
   void dispatchNotification(String event, params) {
     switch (event) {
       case "server.connected":
         expect(params, isServerConnectedParams);
@@ skipping 40 matching lines @@
         _onAnalysisOverrides.add(params);
         break;
       case "completion.results":
         expect(params, isCompletionResultsParams);
         _onCompletionResults.add(params);
         break;
       case "search.results":
         expect(params, isSearchResultsParams);
         _onSearchResults.add(params);
         break;
-      case "debug.launchData":
-        expect(params, isDebugLaunchDataParams);
-        _onDebugLaunchData.add(params);
+      case "execution.launchData":
+        expect(params, isExecutionLaunchDataParams);
+        _onExecutionLaunchData.add(params);
         break;
       default:
         fail('Unexpected notification: $event');
         break;
     }
   }
 }