Change integration test send...() methods 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
  */
 library test.integration.methods;
 
 import 'dart:async';
 
+import 'package:analysis_server/src/protocol.dart';
 import 'package:unittest/unittest.dart';
 
 import 'integration_tests.dart';
 import 'protocol_matchers.dart';
 
 
 /**
  * Convenience methods for running integration tests
  */
 abstract class IntegrationTestMixin {
   Server get server;
 
   /**
    * Return the version number of the analysis server.
    *
    * Returns
    *
    * version ( String )
    *
    *   The version number of the analysis server.
    */
-  Future sendServerGetVersion({bool checkTypes: true}) {
+  Future sendServerGetVersion() {
     return server.send("server.getVersion", null)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isServerGetVersionResult);
-      }
+      expect(result, isServerGetVersionResult);
       return result;
     });
   }
 
   /**
    * 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({bool checkTypes: true}) {
+  Future sendServerShutdown() {
     return server.send("server.shutdown", null)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isServerShutdownResult);
-      }
+      expect(result, isServerShutdownResult);
       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<ServerService> )
    *
    *   A list of the services being subscribed to.
    */
-  Future sendServerSetSubscriptions(List<String> subscriptions, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["subscriptions"] = subscriptions;
-    if (checkTypes) {
-      expect(params, isServerSetSubscriptionsParams);
-    }
+  Future sendServerSetSubscriptions(List<ServerService> subscriptions) {
+    var params = new ServerSetSubscriptionsParams(subscriptions).toJson();
     return server.send("server.setSubscriptions", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isServerSetSubscriptionsResult);
-      }
+      expect(result, isServerSetSubscriptionsResult);
       return result;
     });
   }
 
   /**
    * 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 83 matching lines @@
    * file ( FilePath )
    *
    *   The file for which errors are being requested.
    *
    * Returns
    *
    * errors ( List<AnalysisError> )
    *
    *   The errors associated with the file.
    */
-  Future sendAnalysisGetErrors(String file, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["file"] = file;
-    if (checkTypes) {
-      expect(params, isAnalysisGetErrorsParams);
-    }
+  Future sendAnalysisGetErrors(String file) {
+    var params = new AnalysisGetErrorsParams(file).toJson();
     return server.send("analysis.getErrors", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isAnalysisGetErrorsResult);
-      }
+      expect(result, isAnalysisGetErrorsResult);
       return result;
     });
   }
 
   /**
    * Return the hover information associate with the given location. If some or
    * all of the hover information is not available at the time this request is
    * processed the information will be omitted from the response.
    *
    * Parameters
    *
    * file ( FilePath )
    *
    *   The file in which hover information is being requested.
    *
    * offset ( int )
    *
    *   The offset for which hover information is being requested.
    *
    * Returns
    *
    * hovers ( List<HoverInformation> )
    *
    *   The hover information associated with the location. The list will be
    *   empty if no information could be determined for the location. The list
    *   can contain multiple items if the file is being analyzed in multiple
    *   contexts in conflicting ways (such as a part that is included in
    *   multiple libraries).
    */
-  Future sendAnalysisGetHover(String file, int offset, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["file"] = file;
-    params["offset"] = offset;
-    if (checkTypes) {
-      expect(params, isAnalysisGetHoverParams);
-    }
+  Future sendAnalysisGetHover(String file, int offset) {
+    var params = new AnalysisGetHoverParams(file, offset).toJson();
     return server.send("analysis.getHover", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isAnalysisGetHoverResult);
-      }
+      expect(result, isAnalysisGetHoverResult);
       return result;
     });
   }
 
   /**
    * Force the re-analysis of everything contained in the existing analysis
    * roots. This will cause all previously computed analysis results to be
    * discarded and recomputed, and will cause all subscribed notifications to
    * be re-sent.
    */
-  Future sendAnalysisReanalyze({bool checkTypes: true}) {
+  Future sendAnalysisReanalyze() {
     return server.send("analysis.reanalyze", null)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isAnalysisReanalyzeResult);
-      }
+      expect(result, isAnalysisReanalyzeResult);
       return result;
     });
   }
 
   /**
    * 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 also in one of the excluded paths.
    *
    * Note that this request determines the set of requested analysis roots. The
@@ skipping 17 matching lines @@
    *
    * included ( List<FilePath> )
    *
    *   A list of the files and directories that should be analyzed.
    *
    * excluded ( List<FilePath> )
    *
    *   A list of the files and directories within the included directories that
    *   should not be analyzed.
    */
-  Future sendAnalysisSetAnalysisRoots(List<String> included, List<String> excluded, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["included"] = included;
-    params["excluded"] = excluded;
-    if (checkTypes) {
-      expect(params, isAnalysisSetAnalysisRootsParams);
-    }
+  Future sendAnalysisSetAnalysisRoots(List<String> included, List<String> excluded) {
+    var params = new AnalysisSetAnalysisRootsParams(included, excluded).toJson();
     return server.send("analysis.setAnalysisRoots", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isAnalysisSetAnalysisRootsResult);
-      }
+      expect(result, isAnalysisSetAnalysisRootsResult);
       return result;
     });
   }
 
   /**
    * 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,
    * the second higher priority than the third, and so on.
    *
    * Note that this request determines the set of requested priority files. The
    * actual set of priority files is the intersection of the requested set of
    * priority files with the set of files currently subject to analysis. (See
    * analysis.setSubscriptions for a description of files that are subject to
    * analysis.)
    *
    * If a requested priority file is a directory it is ignored, but remains in
    * the set of requested priority files so that if it later becomes a file it
    * can be included in the set of actual priority files.
    *
    * Parameters
    *
    * files ( List<FilePath> )
    *
    *   The files that are to be a priority for analysis.
    */
-  Future sendAnalysisSetPriorityFiles(List<String> files, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["files"] = files;
-    if (checkTypes) {
-      expect(params, isAnalysisSetPriorityFilesParams);
-    }
+  Future sendAnalysisSetPriorityFiles(List<String> files) {
+    var params = new AnalysisSetPriorityFilesParams(files).toJson();
     return server.send("analysis.setPriorityFiles", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isAnalysisSetPriorityFilesResult);
-      }
+      expect(result, isAnalysisSetPriorityFilesResult);
       return result;
     });
   }
 
   /**
    * Subscribe for services. 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 16 matching lines @@
    * It is an error if any of the keys in the map are not valid services. If
    * there is an error, then the existing subscriptions will remain unchanged.
    *
    * Parameters
    *
    * subscriptions ( Map<AnalysisService, List<FilePath>> )
    *
    *   A table mapping services to a list of the files being subscribed to the
    *   service.
    */
-  Future sendAnalysisSetSubscriptions(Map<String, List<String>> subscriptions, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["subscriptions"] = subscriptions;
-    if (checkTypes) {
-      expect(params, isAnalysisSetSubscriptionsParams);
-    }
+  Future sendAnalysisSetSubscriptions(Map<AnalysisService, List<String>> subscriptions) {
+    var params = new AnalysisSetSubscriptionsParams(subscriptions).toJson();
     return server.send("analysis.setSubscriptions", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isAnalysisSetSubscriptionsResult);
-      }
+      expect(result, isAnalysisSetSubscriptionsResult);
       return result;
     });
   }
 
   /**
    * 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.
    *
    * Parameters
    *
    * files ( Map<FilePath, AddContentOverlay | ChangeContentOverlay |
    * RemoveContentOverlay> )
    *
    *   A table mapping the files whose content has changed to a description of
    *   the content change.
    */
-  Future sendAnalysisUpdateContent(Map<String, Object> files, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["files"] = files;
-    if (checkTypes) {
-      expect(params, isAnalysisUpdateContentParams);
-    }
+  Future sendAnalysisUpdateContent(Map<String, dynamic> files) {
+    var params = new AnalysisUpdateContentParams(files).toJson();
     return server.send("analysis.updateContent", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isAnalysisUpdateContentResult);
-      }
+      expect(result, isAnalysisUpdateContentResult);
       return result;
     });
   }
 
   /**
    * Update the options controlling analysis based on the given set of options.
    * Any options that are not included in the analysis options will not be
    * changed. If there are options in the analysis options that are not valid,
    * they will be silently ignored.
    *
    * Parameters
    *
    * options ( AnalysisOptions )
    *
    *   The options that are to be used to control analysis.
    */
-  Future sendAnalysisUpdateOptions(Map<String, dynamic> options, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["options"] = options;
-    if (checkTypes) {
-      expect(params, isAnalysisUpdateOptionsParams);
-    }
+  Future sendAnalysisUpdateOptions(AnalysisOptions options) {
+    var params = new AnalysisUpdateOptionsParams(options).toJson();
     return server.send("analysis.updateOptions", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isAnalysisUpdateOptionsResult);
-      }
+      expect(result, isAnalysisUpdateOptionsResult);
       return result;
     });
   }
 
   /**
    * Reports the errors associated with a given file. The set of errors
    * included in the notification is always a complete list that supersedes any
    * previously reported errors.
    *
    * It is only possible to unsubscribe from this notification by using the
@@ skipping 212 matching lines @@
    * offset ( int )
    *
    *   The offset within the file at which suggestions are to be made.
    *
    * Returns
    *
    * id ( CompletionId )
    *
    *   The identifier used to associate results with this completion request.
    */
-  Future sendCompletionGetSuggestions(String file, int offset, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["file"] = file;
-    params["offset"] = offset;
-    if (checkTypes) {
-      expect(params, isCompletionGetSuggestionsParams);
-    }
+  Future sendCompletionGetSuggestions(String file, int offset) {
+    var params = new CompletionGetSuggestionsParams(file, offset).toJson();
     return server.send("completion.getSuggestions", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isCompletionGetSuggestionsResult);
-      }
+      expect(result, isCompletionGetSuggestionsResult);
       return result;
     });
   }
 
   /**
    * Reports the completion suggestions that should be presented to the user.
    * The set of suggestions included in the notification is always a complete
    * list that supersedes any previously reported suggestions.
    *
    * Parameters
@@ skipping 70 matching lines @@
    *   notification.
    *
    * element ( optional Element )
    *
    *   The element referenced or defined at the given offset and whose
    *   references will be returned in the search results.
    *
    *   If no element was found at the given location, this field will be
    *   absent.
    */
-  Future sendSearchFindElementReferences(String file, int offset, bool includePotential, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["file"] = file;
-    params["offset"] = offset;
-    params["includePotential"] = includePotential;
-    if (checkTypes) {
-      expect(params, isSearchFindElementReferencesParams);
-    }
+  Future sendSearchFindElementReferences(String file, int offset, bool includePotential) {
+    var params = new SearchFindElementReferencesParams(file, offset, includePotential).toJson();
     return server.send("search.findElementReferences", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isSearchFindElementReferencesResult);
-      }
+      expect(result, isSearchFindElementReferencesResult);
       return result;
     });
   }
 
   /**
    * Perform a search for declarations of members whose name is equal to the
    * given name.
    *
    * An identifier is returned immediately, and individual results will be
    * returned via the search.results notification as they become available.
    *
    * Parameters
    *
    * name ( String )
    *
    *   The name of the declarations to be found.
    *
    * Returns
    *
    * id ( SearchId )
    *
    *   The identifier used to associate results with this search request.
    */
-  Future sendSearchFindMemberDeclarations(String name, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["name"] = name;
-    if (checkTypes) {
-      expect(params, isSearchFindMemberDeclarationsParams);
-    }
+  Future sendSearchFindMemberDeclarations(String name) {
+    var params = new SearchFindMemberDeclarationsParams(name).toJson();
     return server.send("search.findMemberDeclarations", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isSearchFindMemberDeclarationsResult);
-      }
+      expect(result, isSearchFindMemberDeclarationsResult);
       return result;
     });
   }
 
   /**
    * Perform a search for references to members whose name is equal to the
    * given name. This search does not check to see that there is a member
    * defined with the given name, so it is able to find references to undefined
    * members as well.
    *
    * An identifier is returned immediately, and individual results will be
    * returned via the search.results notification as they become available.
    *
    * Parameters
    *
    * name ( String )
    *
    *   The name of the references to be found.
    *
    * Returns
    *
    * id ( SearchId )
    *
    *   The identifier used to associate results with this search request.
    */
-  Future sendSearchFindMemberReferences(String name, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["name"] = name;
-    if (checkTypes) {
-      expect(params, isSearchFindMemberReferencesParams);
-    }
+  Future sendSearchFindMemberReferences(String name) {
+    var params = new SearchFindMemberReferencesParams(name).toJson();
     return server.send("search.findMemberReferences", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isSearchFindMemberReferencesResult);
-      }
+      expect(result, isSearchFindMemberReferencesResult);
       return result;
     });
   }
 
   /**
    * Perform a search for declarations of top-level elements (classes,
    * typedefs, getters, setters, functions and fields) whose name matches the
    * given pattern.
    *
    * An identifier is returned immediately, and individual results will be
    * returned via the search.results notification as they become available.
    *
    * Parameters
    *
    * pattern ( String )
    *
    *   The regular expression used to match the names of the declarations to be
    *   found.
    *
    * Returns
    *
    * id ( SearchId )
    *
    *   The identifier used to associate results with this search request.
    */
-  Future sendSearchFindTopLevelDeclarations(String pattern, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["pattern"] = pattern;
-    if (checkTypes) {
-      expect(params, isSearchFindTopLevelDeclarationsParams);
-    }
+  Future sendSearchFindTopLevelDeclarations(String pattern) {
+    var params = new SearchFindTopLevelDeclarationsParams(pattern).toJson();
     return server.send("search.findTopLevelDeclarations", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isSearchFindTopLevelDeclarationsResult);
-      }
+      expect(result, isSearchFindTopLevelDeclarationsResult);
       return result;
     });
   }
 
   /**
    * Return the type hierarchy of the class declared or referenced at the given
    * location.
    *
    * Parameters
    *
@@ skipping 13 matching lines @@
    *   A list of the types in the requested hierarchy. The first element of the
    *   list is the item representing the type for which the hierarchy was
    *   requested. The index of other elements of the list is unspecified, but
    *   correspond to the integers used to reference supertype and subtype items
    *   within the items.
    *
    *   This field will be absent if the code at the given file and offset does
    *   not represent a type, or if the file has not been sufficiently analyzed
    *   to allow a type hierarchy to be produced.
    */
-  Future sendSearchGetTypeHierarchy(String file, int offset, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["file"] = file;
-    params["offset"] = offset;
-    if (checkTypes) {
-      expect(params, isSearchGetTypeHierarchyParams);
-    }
+  Future sendSearchGetTypeHierarchy(String file, int offset) {
+    var params = new SearchGetTypeHierarchyParams(file, offset).toJson();
     return server.send("search.getTypeHierarchy", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isSearchGetTypeHierarchyResult);
-      }
+      expect(result, isSearchGetTypeHierarchyResult);
       return result;
     });
   }
 
   /**
    * Reports some or all of the results of performing a requested search.
    * Unlike other notifications, this notification contains search results that
    * should be added to any previously received search results associated with
    * the same search id.
    *
@@ skipping 38 matching lines @@
    * length ( int )
    *
    *   The length of the code for which assists are being requested.
    *
    * Returns
    *
    * assists ( List<SourceChange> )
    *
    *   The assists that are available at the given location.
    */
-  Future sendEditGetAssists(String file, int offset, int length, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["file"] = file;
-    params["offset"] = offset;
-    params["length"] = length;
-    if (checkTypes) {
-      expect(params, isEditGetAssistsParams);
-    }
+  Future sendEditGetAssists(String file, int offset, int length) {
+    var params = new EditGetAssistsParams(file, offset, length).toJson();
     return server.send("edit.getAssists", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isEditGetAssistsResult);
-      }
+      expect(result, isEditGetAssistsResult);
       return result;
     });
   }
 
   /**
    * Get a list of the kinds of refactorings that are valid for the given
    * selection in the given file.
    *
    * Parameters
    *
    * file ( FilePath )
    *
    *   The file containing the code on which the refactoring would be based.
    *
    * offset ( int )
    *
    *   The offset of the code on which the refactoring would be based.
    *
    * length ( int )
    *
    *   The length of the code on which the refactoring would be based.
    *
    * Returns
    *
    * kinds ( List<RefactoringKind> )
    *
    *   The kinds of refactorings that are valid for the given selection.
    */
-  Future sendEditGetAvailableRefactorings(String file, int offset, int length, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["file"] = file;
-    params["offset"] = offset;
-    params["length"] = length;
-    if (checkTypes) {
-      expect(params, isEditGetAvailableRefactoringsParams);
-    }
+  Future sendEditGetAvailableRefactorings(String file, int offset, int length) {
+    var params = new EditGetAvailableRefactoringsParams(file, offset, length).toJson();
     return server.send("edit.getAvailableRefactorings", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isEditGetAvailableRefactoringsResult);
-      }
+      expect(result, isEditGetAvailableRefactoringsResult);
       return result;
     });
   }
 
   /**
    * Return the set of fixes that are available for the errors at a given
    * offset in a given file.
    *
    * Parameters
    *
    * file ( FilePath )
    *
    *   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 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);
-    }
+  Future sendEditGetFixes(String file, int offset) {
+    var params = new EditGetFixesParams(file, offset).toJson();
     return server.send("edit.getFixes", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isEditGetFixesResult);
-      }
+      expect(result, isEditGetFixesResult);
       return result;
     });
   }
 
   /**
    * Get the changes required to perform a refactoring.
    *
    * Parameters
    *
    * kind ( RefactoringKind )
@@ skipping 62 matching lines @@
    * potentialEdits ( optional List<String> )
    *
    *   The ids of source edits that are not known to be valid. An edit is not
    *   known to be valid if there was insufficient type information for the
    *   server to be able to determine whether or not the code needs to be
    *   modified, such as when a member is being renamed and there is a
    *   reference to a member from an unknown type. This field will be omitted
    *   if the change field is omitted or if there are no potential edits for
    *   the refactoring.
    */
-  Future sendEditGetRefactoring(String kind, String file, int offset, int length, bool validateOnly, {Map<String, dynamic> options, bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["kind"] = kind;
-    params["file"] = file;
-    params["offset"] = offset;
-    params["length"] = length;
-    params["validateOnly"] = validateOnly;
-    if (options != null) {
-      params["options"] = options;
-    }
-    if (checkTypes) {
-      expect(params, isEditGetRefactoringParams);
-    }
+  Future sendEditGetRefactoring(RefactoringKind kind, String file, int offset, int length, bool validateOnly, {RefactoringOptions options}) {
+    var params = new EditGetRefactoringParams(kind, file, offset, length, validateOnly, options: options).toJson();
     return server.send("edit.getRefactoring", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isEditGetRefactoringResult);
-      }
+      expect(result, isEditGetRefactoringResult);
       return result;
     });
   }
 
   /**
    * Sort all of the directives, unit and class members of the given Dart file.
    *
    * If a request is made for a file that does not exist, does not belong to an
    * analysis root or is not a Dart file, SORT_MEMBERS_INVALID_FILE will be
    * generated.
    *
    * If the Dart file has scan or parse errors, SORT_MEMBERS_PARSE_ERRORS will
    * be generated.
    *
    * Parameters
    *
    * file ( FilePath )
    *
    *   The Dart file to sort.
    *
    * Returns
    *
    * edit ( SourceFileEdit )
    *
    *   The file edit that is to be applied to the given file to effect the
    *   sorting.
    */
-  Future sendEditSortMembers(String file, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["file"] = file;
-    if (checkTypes) {
-      expect(params, isEditSortMembersParams);
-    }
+  Future sendEditSortMembers(String file) {
+    var params = new EditSortMembersParams(file).toJson();
     return server.send("edit.sortMembers", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isEditSortMembersResult);
-      }
+      expect(result, isEditSortMembersResult);
       return result;
     });
   }
 
   /**
    * 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 ( ExecutionContextId )
    *
    *   The identifier used to refer to the execution context that was created.
    */
-  Future sendExecutionCreateContext(String contextRoot, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["contextRoot"] = contextRoot;
-    if (checkTypes) {
-      expect(params, isExecutionCreateContextParams);
-    }
+  Future sendExecutionCreateContext(String contextRoot) {
+    var params = new ExecutionCreateContextParams(contextRoot).toJson();
     return server.send("execution.createContext", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isExecutionCreateContextResult);
-      }
+      expect(result, isExecutionCreateContextResult);
       return result;
     });
   }
 
   /**
    * 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 ( ExecutionContextId )
    *
    *   The identifier of the execution context that is to be deleted.
    */
-  Future sendExecutionDeleteContext(String id, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["id"] = id;
-    if (checkTypes) {
-      expect(params, isExecutionDeleteContextParams);
-    }
+  Future sendExecutionDeleteContext(String id) {
+    var params = new ExecutionDeleteContextParams(id).toJson();
     return server.send("execution.deleteContext", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isExecutionDeleteContextResult);
-      }
+      expect(result, isExecutionDeleteContextResult);
       return result;
     });
   }
 
   /**
    * 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.
    *
@@ skipping 17 matching lines @@
    * 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 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, isExecutionMapUriParams);
-    }
+  Future sendExecutionMapUri(String id, {String file, String uri}) {
+    var params = new ExecutionMapUriParams(id, file: file, uri: uri).toJson();
     return server.send("execution.mapUri", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isExecutionMapUriResult);
-      }
+      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<ExecutionService> )
    *
    *   A list of the services being subscribed to.
    */
-  Future sendExecutionSetSubscriptions(List<String> subscriptions, {bool checkTypes: true}) {
-    Map<String, dynamic> params = {};
-    params["subscriptions"] = subscriptions;
-    if (checkTypes) {
-      expect(params, isExecutionSetSubscriptionsParams);
-    }
+  Future sendExecutionSetSubscriptions(List<ExecutionService> subscriptions) {
+    var params = new ExecutionSetSubscriptionsParams(subscriptions).toJson();
     return server.send("execution.setSubscriptions", params)
         .then((result) {
-      if (checkTypes) {
-        expect(result, isExecutionSetSubscriptionsResult);
-      }
+      expect(result, isExecutionSetSubscriptionsResult);
       return result;
     });
   }
 
   /**
    * 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 118 matching lines @@
       case "execution.launchData":
         expect(params, isExecutionLaunchDataParams);
         _onExecutionLaunchData.add(params);
         break;
       default:
         fail('Unexpected notification: $event');
         break;
     }
   }
 }