Format generated files.

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/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/protocol/protocol_internal.dart';
 import 'package:test/test.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
@@ skipping 187 matching lines @@
    * 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<AnalysisGetHoverResult> sendAnalysisGetHover(String file, int offset) async {
+  Future<AnalysisGetHoverResult> sendAnalysisGetHover(
+      String file, int offset) async {
     var params = new AnalysisGetHoverParams(file, offset).toJson();
     var result = await server.send("analysis.getHover", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
     return new AnalysisGetHoverResult.fromJson(decoder, 'result', result);
   }
 
   /**
    * Return the transitive closure of reachable sources for a given file.
    *
    * If a request is made for a file which does not exist, or which is not
@@ skipping 12 matching lines @@
    * sources (Map<String, List<String>>)
    *
    *   A mapping from source URIs to directly reachable source URIs. For
    *   example, a file "foo.dart" that imports "bar.dart" would have the
    *   corresponding mapping { "file:///foo.dart" : ["file:///bar.dart"] }. If
    *   "bar.dart" has further imports (or exports) there will be a mapping from
    *   the URI "file:///bar.dart" to them. To check if a specific URI is
    *   reachable from a given file, clients can check for its presence in the
    *   resulting key set.
    */
-  Future<AnalysisGetReachableSourcesResult> sendAnalysisGetReachableSources(String file) async {
+  Future<AnalysisGetReachableSourcesResult> sendAnalysisGetReachableSources(
+      String file) async {
     var params = new AnalysisGetReachableSourcesParams(file).toJson();
     var result = await server.send("analysis.getReachableSources", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
-    return new AnalysisGetReachableSourcesResult.fromJson(decoder, 'result', result);
+    return new AnalysisGetReachableSourcesResult.fromJson(
+        decoder, 'result', result);
   }
 
   /**
    * Return library dependency information for use in client-side indexing and
    * package URI resolution.
    *
    * Clients that are only using the libraries field should consider using the
    * analyzedFiles notification instead.
    *
    * Returns
    *
    * libraries (List<FilePath>)
    *
    *   A list of the paths of library elements referenced by files in existing
    *   analysis roots.
    *
    * packageMap (Map<String, Map<String, List<FilePath>>>)
    *
    *   A mapping from context source roots to package maps which map package
    *   names to source directories for use in client-side package URI
    *   resolution.
    */
-  Future<AnalysisGetLibraryDependenciesResult> sendAnalysisGetLibraryDependencies() async {
+  Future<AnalysisGetLibraryDependenciesResult>
+      sendAnalysisGetLibraryDependencies() async {
     var result = await server.send("analysis.getLibraryDependencies", null);
     ResponseDecoder decoder = new ResponseDecoder(null);
-    return new AnalysisGetLibraryDependenciesResult.fromJson(decoder, 'result', result);
+    return new AnalysisGetLibraryDependenciesResult.fromJson(
+        decoder, 'result', result);
   }
 
   /**
    * Return the navigation information associated with the given region of the
    * given file. If the navigation information for the given file has not yet
    * been computed, or the most recently computed navigation information for
    * the given file is out of date, then the response for this request will be
    * delayed until it has been computed. If the content of the file changes
    * after this request was received but before a response could be sent, then
    * an error of type CONTENT_MODIFIED will be generated.
@@ skipping 36 matching lines @@
    * targets (List<NavigationTarget>)
    *
    *   A list of the navigation targets that are referenced by the navigation
    *   regions.
    *
    * regions (List<NavigationRegion>)
    *
    *   A list of the navigation regions within the requested region of the
    *   file.
    */
-  Future<AnalysisGetNavigationResult> sendAnalysisGetNavigation(String file, int offset, int length) async {
+  Future<AnalysisGetNavigationResult> sendAnalysisGetNavigation(
+      String file, int offset, int length) async {
     var params = new AnalysisGetNavigationParams(file, offset, length).toJson();
     var result = await server.send("analysis.getNavigation", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
     return new AnalysisGetNavigationResult.fromJson(decoder, 'result', result);
   }
 
   /**
    * Force the re-analysis of everything contained in the specified analysis
    * roots. This will cause all previously computed analysis results to be
    * discarded and recomputed, and will cause all subscribed notifications to
@@ skipping 70 matching lines @@
    *   If a package root is a file, then the analyzer will behave as though
    *   that file is a ".packages" file in the source directory. The effect is
    *   the same as specifying the file as a "--packages" parameter to the Dart
    *   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();
+  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);
     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();
+  Future sendAnalysisSetGeneralSubscriptions(
+      List<GeneralAnalysisService> subscriptions) async {
+    var params =
+        new AnalysisSetGeneralSubscriptionsParams(subscriptions).toJson();
     var result = await server.send("analysis.setGeneralSubscriptions", params);
     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
@@ skipping 49 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<AnalysisService, List<String>> subscriptions) async {
+  Future sendAnalysisSetSubscriptions(
+      Map<AnalysisService, List<String>> subscriptions) async {
     var params = new AnalysisSetSubscriptionsParams(subscriptions).toJson();
     var result = await server.send("analysis.setSubscriptions", params);
     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.
    *
    * Parameters
    *
    * files (Map<FilePath, AddContentOverlay | ChangeContentOverlay |
    * RemoveContentOverlay>)
    *
    *   A table mapping the files whose content has changed to a description of
    *   the content change.
    *
    * Returns
    */
-  Future<AnalysisUpdateContentResult> sendAnalysisUpdateContent(Map<String, dynamic> files) async {
+  Future<AnalysisUpdateContentResult> sendAnalysisUpdateContent(
+      Map<String, dynamic> files) async {
     var params = new AnalysisUpdateContentParams(files).toJson();
     var result = await server.send("analysis.updateContent", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
     return new AnalysisUpdateContentResult.fromJson(decoder, 'result', result);
   }
 
   /**
    * Deprecated: all of the options can be set by users in an analysis options
    * file.
    *
@@ skipping 339 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<CompletionGetSuggestionsResult> sendCompletionGetSuggestions(String file, int offset) async {
+  Future<CompletionGetSuggestionsResult> sendCompletionGetSuggestions(
+      String file, int offset) async {
     var params = new CompletionGetSuggestionsParams(file, offset).toJson();
     var result = await server.send("completion.getSuggestions", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
-    return new CompletionGetSuggestionsResult.fromJson(decoder, 'result', result);
+    return new CompletionGetSuggestionsResult.fromJson(
+        decoder, 'result', 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
    *
    * id (CompletionId)
@@ skipping 68 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<SearchFindElementReferencesResult> sendSearchFindElementReferences(String file, int offset, bool includePotential) async {
-    var params = new SearchFindElementReferencesParams(file, offset, includePotential).toJson();
+  Future<SearchFindElementReferencesResult> sendSearchFindElementReferences(
+      String file, int offset, bool includePotential) async {
+    var params =
+        new SearchFindElementReferencesParams(file, offset, includePotential)
+            .toJson();
     var result = await server.send("search.findElementReferences", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
-    return new SearchFindElementReferencesResult.fromJson(decoder, 'result', result);
+    return new SearchFindElementReferencesResult.fromJson(
+        decoder, 'result', 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<SearchFindMemberDeclarationsResult> sendSearchFindMemberDeclarations(String name) async {
+  Future<SearchFindMemberDeclarationsResult> sendSearchFindMemberDeclarations(
+      String name) async {
     var params = new SearchFindMemberDeclarationsParams(name).toJson();
     var result = await server.send("search.findMemberDeclarations", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
-    return new SearchFindMemberDeclarationsResult.fromJson(decoder, 'result', result);
+    return new SearchFindMemberDeclarationsResult.fromJson(
+        decoder, 'result', 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<SearchFindMemberReferencesResult> sendSearchFindMemberReferences(String name) async {
+  Future<SearchFindMemberReferencesResult> sendSearchFindMemberReferences(
+      String name) async {
     var params = new SearchFindMemberReferencesParams(name).toJson();
     var result = await server.send("search.findMemberReferences", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
-    return new SearchFindMemberReferencesResult.fromJson(decoder, 'result', result);
+    return new SearchFindMemberReferencesResult.fromJson(
+        decoder, 'result', 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<SearchFindTopLevelDeclarationsResult> sendSearchFindTopLevelDeclarations(String pattern) async {
+  Future<SearchFindTopLevelDeclarationsResult>
+      sendSearchFindTopLevelDeclarations(String pattern) async {
     var params = new SearchFindTopLevelDeclarationsParams(pattern).toJson();
     var result = await server.send("search.findTopLevelDeclarations", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
-    return new SearchFindTopLevelDeclarationsResult.fromJson(decoder, 'result', result);
+    return new SearchFindTopLevelDeclarationsResult.fromJson(
+        decoder, 'result', result);
   }
 
   /**
    * Return the type hierarchy of the class declared or referenced at the given
    * location.
    *
    * Parameters
    *
    * file (FilePath)
    *
@@ skipping 16 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<SearchGetTypeHierarchyResult> sendSearchGetTypeHierarchy(String file, int offset, {bool superOnly}) async {
-    var params = new SearchGetTypeHierarchyParams(file, offset, superOnly: superOnly).toJson();
+  Future<SearchGetTypeHierarchyResult> sendSearchGetTypeHierarchy(
+      String file, int offset,
+      {bool superOnly}) async {
+    var params =
+        new SearchGetTypeHierarchyParams(file, offset, superOnly: superOnly)
+            .toJson();
     var result = await server.send("search.getTypeHierarchy", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
     return new SearchGetTypeHierarchyResult.fromJson(decoder, 'result', 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 61 matching lines @@
    *   empty if the code was already formatted (there are no changes).
    *
    * selectionOffset (int)
    *
    *   The offset of the selection after formatting the code.
    *
    * selectionLength (int)
    *
    *   The length of the selection after formatting the code.
    */
-  Future<EditFormatResult> sendEditFormat(String file, int selectionOffset, int selectionLength, {int lineLength}) async {
-    var params = new EditFormatParams(file, selectionOffset, selectionLength, lineLength: lineLength).toJson();
+  Future<EditFormatResult> sendEditFormat(
+      String file, int selectionOffset, int selectionLength,
+      {int lineLength}) async {
+    var params = new EditFormatParams(file, selectionOffset, selectionLength,
+            lineLength: lineLength)
+        .toJson();
     var result = await server.send("edit.format", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
     return new EditFormatResult.fromJson(decoder, 'result', result);
   }
 
   /**
    * 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.
@@ skipping 11 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<EditGetAssistsResult> sendEditGetAssists(String file, int offset, int length) async {
+  Future<EditGetAssistsResult> sendEditGetAssists(
+      String file, int offset, int length) async {
     var params = new EditGetAssistsParams(file, offset, length).toJson();
     var result = await server.send("edit.getAssists", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
     return new EditGetAssistsResult.fromJson(decoder, 'result', result);
   }
 
   /**
    * Get a list of the kinds of refactorings that are valid for the given
    * selection in the given file.
    *
@@ skipping 10 matching lines @@
    * 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<EditGetAvailableRefactoringsResult> sendEditGetAvailableRefactorings(String file, int offset, int length) async {
-    var params = new EditGetAvailableRefactoringsParams(file, offset, length).toJson();
+  Future<EditGetAvailableRefactoringsResult> sendEditGetAvailableRefactorings(
+      String file, int offset, int length) async {
+    var params =
+        new EditGetAvailableRefactoringsParams(file, offset, length).toJson();
     var result = await server.send("edit.getAvailableRefactorings", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
-    return new EditGetAvailableRefactoringsResult.fromJson(decoder, 'result', result);
+    return new EditGetAvailableRefactoringsResult.fromJson(
+        decoder, 'result', result);
   }
 
   /**
    * Return the set of fixes that are available for the errors at a given
    * offset in a given file.
    *
    * Parameters
    *
    * file (FilePath)
    *
@@ skipping 90 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<EditGetRefactoringResult> sendEditGetRefactoring(RefactoringKind kind, String file, int offset, int length, bool validateOnly, {RefactoringOptions options}) async {
-    var params = new EditGetRefactoringParams(kind, file, offset, length, validateOnly, options: options).toJson();
+  Future<EditGetRefactoringResult> sendEditGetRefactoring(RefactoringKind kind,
+      String file, int offset, int length, bool validateOnly,
+      {RefactoringOptions options}) async {
+    var params = new EditGetRefactoringParams(
+            kind, file, offset, length, validateOnly,
+            options: options)
+        .toJson();
     var result = await server.send("edit.getRefactoring", params);
     ResponseDecoder decoder = new ResponseDecoder(kind);
     return new EditGetRefactoringResult.fromJson(decoder, 'result', 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
@@ skipping 39 matching lines @@
    *
    *   The Dart file to organize directives in.
    *
    * Returns
    *
    * edit (SourceFileEdit)
    *
    *   The file edit that is to be applied to the given file to effect the
    *   organizing.
    */
-  Future<EditOrganizeDirectivesResult> sendEditOrganizeDirectives(String file) async {
+  Future<EditOrganizeDirectivesResult> sendEditOrganizeDirectives(
+      String file) async {
     var params = new EditOrganizeDirectivesParams(file).toJson();
     var result = await server.send("edit.organizeDirectives", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
     return new EditOrganizeDirectivesResult.fromJson(decoder, 'result', 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, or the path of
    *   the directory containing the file.
    *
    * Returns
    *
    * id (ExecutionContextId)
    *
    *   The identifier used to refer to the execution context that was created.
    */
-  Future<ExecutionCreateContextResult> sendExecutionCreateContext(String contextRoot) async {
+  Future<ExecutionCreateContextResult> sendExecutionCreateContext(
+      String contextRoot) async {
     var params = new ExecutionCreateContextParams(contextRoot).toJson();
     var result = await server.send("execution.createContext", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
     return new ExecutionCreateContextResult.fromJson(decoder, 'result', 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.
@@ skipping 52 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<ExecutionMapUriResult> sendExecutionMapUri(String id, {String file, String uri}) async {
+  Future<ExecutionMapUriResult> sendExecutionMapUri(String id,
+      {String file, String uri}) async {
     var params = new ExecutionMapUriParams(id, file: file, uri: uri).toJson();
     var result = await server.send("execution.mapUri", params);
     ResponseDecoder decoder = new ResponseDecoder(null);
     return new ExecutionMapUriResult.fromJson(decoder, 'result', result);
   }
 
   /**
    * Deprecated: the analysis server no longer fires LAUNCH_DATA events.
    *
    * 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<ExecutionService> subscriptions) async {
+  Future sendExecutionSetSubscriptions(
+      List<ExecutionService> subscriptions) async {
     var params = new ExecutionSetSubscriptionsParams(subscriptions).toJson();
     var result = await server.send("execution.setSubscriptions", params);
     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
@@ skipping 29 matching lines @@
    *
    * Returns
    *
    * contexts (List<ContextData>)
    *
    *   The list of analysis contexts.
    */
   Future<DiagnosticGetDiagnosticsResult> sendDiagnosticGetDiagnostics() async {
     var result = await server.send("diagnostic.getDiagnostics", null);
     ResponseDecoder decoder = new ResponseDecoder(null);
-    return new DiagnosticGetDiagnosticsResult.fromJson(decoder, 'result', result);
+    return new DiagnosticGetDiagnosticsResult.fromJson(
+        decoder, 'result', result);
   }
 
   /**
    * Return the port of the diagnostic web server. If the server is not running
    * this call will start the server. If unable to start the diagnostic web
    * server, this call will return an error of DEBUG_PORT_COULD_NOT_BE_OPENED.
    *
    * Returns
    *
    * port (int)
    *
    *   The diagnostic server port.
    */
   Future<DiagnosticGetServerPortResult> sendDiagnosticGetServerPort() async {
     var result = await server.send("diagnostic.getServerPort", null);
     ResponseDecoder decoder = new ResponseDecoder(null);
-    return new DiagnosticGetServerPortResult.fromJson(decoder, 'result', result);
+    return new DiagnosticGetServerPortResult.fromJson(
+        decoder, 'result', result);
   }
 
   /**
    * Initialize the fields in InttestMixin, and ensure that notifications will
    * be handled.
    */
   void initializeInttestMixin() {
-    _onServerConnected = new StreamController<ServerConnectedParams>(sync: true);
+    _onServerConnected =
+        new StreamController<ServerConnectedParams>(sync: true);
     onServerConnected = _onServerConnected.stream.asBroadcastStream();
     _onServerError = new StreamController<ServerErrorParams>(sync: true);
     onServerError = _onServerError.stream.asBroadcastStream();
     _onServerStatus = new StreamController<ServerStatusParams>(sync: true);
     onServerStatus = _onServerStatus.stream.asBroadcastStream();
-    _onAnalysisAnalyzedFiles = new StreamController<AnalysisAnalyzedFilesParams>(sync: true);
-    onAnalysisAnalyzedFiles = _onAnalysisAnalyzedFiles.stream.asBroadcastStream();
+    _onAnalysisAnalyzedFiles =
+        new StreamController<AnalysisAnalyzedFilesParams>(sync: true);
+    onAnalysisAnalyzedFiles =
+        _onAnalysisAnalyzedFiles.stream.asBroadcastStream();
     _onAnalysisErrors = new StreamController<AnalysisErrorsParams>(sync: true);
     onAnalysisErrors = _onAnalysisErrors.stream.asBroadcastStream();
-    _onAnalysisFlushResults = new StreamController<AnalysisFlushResultsParams>(sync: true);
+    _onAnalysisFlushResults =
+        new StreamController<AnalysisFlushResultsParams>(sync: true);
     onAnalysisFlushResults = _onAnalysisFlushResults.stream.asBroadcastStream();
-    _onAnalysisFolding = new StreamController<AnalysisFoldingParams>(sync: true);
+    _onAnalysisFolding =
+        new StreamController<AnalysisFoldingParams>(sync: true);
     onAnalysisFolding = _onAnalysisFolding.stream.asBroadcastStream();
-    _onAnalysisHighlights = new StreamController<AnalysisHighlightsParams>(sync: true);
+    _onAnalysisHighlights =
+        new StreamController<AnalysisHighlightsParams>(sync: true);
     onAnalysisHighlights = _onAnalysisHighlights.stream.asBroadcastStream();
-    _onAnalysisImplemented = new StreamController<AnalysisImplementedParams>(sync: true);
+    _onAnalysisImplemented =
+        new StreamController<AnalysisImplementedParams>(sync: true);
     onAnalysisImplemented = _onAnalysisImplemented.stream.asBroadcastStream();
-    _onAnalysisInvalidate = new StreamController<AnalysisInvalidateParams>(sync: true);
+    _onAnalysisInvalidate =
+        new StreamController<AnalysisInvalidateParams>(sync: true);
     onAnalysisInvalidate = _onAnalysisInvalidate.stream.asBroadcastStream();
-    _onAnalysisNavigation = new StreamController<AnalysisNavigationParams>(sync: true);
+    _onAnalysisNavigation =
+        new StreamController<AnalysisNavigationParams>(sync: true);
     onAnalysisNavigation = _onAnalysisNavigation.stream.asBroadcastStream();
-    _onAnalysisOccurrences = new StreamController<AnalysisOccurrencesParams>(sync: true);
+    _onAnalysisOccurrences =
+        new StreamController<AnalysisOccurrencesParams>(sync: true);
     onAnalysisOccurrences = _onAnalysisOccurrences.stream.asBroadcastStream();
-    _onAnalysisOutline = new StreamController<AnalysisOutlineParams>(sync: true);
+    _onAnalysisOutline =
+        new StreamController<AnalysisOutlineParams>(sync: true);
     onAnalysisOutline = _onAnalysisOutline.stream.asBroadcastStream();
-    _onAnalysisOverrides = new StreamController<AnalysisOverridesParams>(sync: true);
+    _onAnalysisOverrides =
+        new StreamController<AnalysisOverridesParams>(sync: true);
     onAnalysisOverrides = _onAnalysisOverrides.stream.asBroadcastStream();
-    _onCompletionResults = new StreamController<CompletionResultsParams>(sync: true);
+    _onCompletionResults =
+        new StreamController<CompletionResultsParams>(sync: true);
     onCompletionResults = _onCompletionResults.stream.asBroadcastStream();
     _onSearchResults = new StreamController<SearchResultsParams>(sync: true);
     onSearchResults = _onSearchResults.stream.asBroadcastStream();
-    _onExecutionLaunchData = new StreamController<ExecutionLaunchDataParams>(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":
         outOfTestExpect(params, isServerConnectedParams);
-        _onServerConnected.add(new ServerConnectedParams.fromJson(decoder, 'params', params));
+        _onServerConnected
+            .add(new ServerConnectedParams.fromJson(decoder, 'params', params));
         break;
       case "server.error":
         outOfTestExpect(params, isServerErrorParams);
-        _onServerError.add(new ServerErrorParams.fromJson(decoder, 'params', params));
+        _onServerError
+            .add(new ServerErrorParams.fromJson(decoder, 'params', params));
         break;
       case "server.status":
         outOfTestExpect(params, isServerStatusParams);
-        _onServerStatus.add(new ServerStatusParams.fromJson(decoder, 'params', params));
+        _onServerStatus
+            .add(new ServerStatusParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.analyzedFiles":
         outOfTestExpect(params, isAnalysisAnalyzedFilesParams);
-        _onAnalysisAnalyzedFiles.add(new AnalysisAnalyzedFilesParams.fromJson(decoder, 'params', params));
+        _onAnalysisAnalyzedFiles.add(new AnalysisAnalyzedFilesParams.fromJson(
+            decoder, 'params', params));
         break;
       case "analysis.errors":
         outOfTestExpect(params, isAnalysisErrorsParams);
-        _onAnalysisErrors.add(new AnalysisErrorsParams.fromJson(decoder, 'params', params));
+        _onAnalysisErrors
+            .add(new AnalysisErrorsParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.flushResults":
         outOfTestExpect(params, isAnalysisFlushResultsParams);
-        _onAnalysisFlushResults.add(new AnalysisFlushResultsParams.fromJson(decoder, 'params', params));
+        _onAnalysisFlushResults.add(
+            new AnalysisFlushResultsParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.folding":
         outOfTestExpect(params, isAnalysisFoldingParams);
-        _onAnalysisFolding.add(new AnalysisFoldingParams.fromJson(decoder, 'params', params));
+        _onAnalysisFolding
+            .add(new AnalysisFoldingParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.highlights":
         outOfTestExpect(params, isAnalysisHighlightsParams);
-        _onAnalysisHighlights.add(new AnalysisHighlightsParams.fromJson(decoder, 'params', params));
+        _onAnalysisHighlights.add(
+            new AnalysisHighlightsParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.implemented":
         outOfTestExpect(params, isAnalysisImplementedParams);
-        _onAnalysisImplemented.add(new AnalysisImplementedParams.fromJson(decoder, 'params', params));
+        _onAnalysisImplemented.add(
+            new AnalysisImplementedParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.invalidate":
         outOfTestExpect(params, isAnalysisInvalidateParams);
-        _onAnalysisInvalidate.add(new AnalysisInvalidateParams.fromJson(decoder, 'params', params));
+        _onAnalysisInvalidate.add(
+            new AnalysisInvalidateParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.navigation":
         outOfTestExpect(params, isAnalysisNavigationParams);
-        _onAnalysisNavigation.add(new AnalysisNavigationParams.fromJson(decoder, 'params', params));
+        _onAnalysisNavigation.add(
+            new AnalysisNavigationParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.occurrences":
         outOfTestExpect(params, isAnalysisOccurrencesParams);
-        _onAnalysisOccurrences.add(new AnalysisOccurrencesParams.fromJson(decoder, 'params', params));
+        _onAnalysisOccurrences.add(
+            new AnalysisOccurrencesParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.outline":
         outOfTestExpect(params, isAnalysisOutlineParams);
-        _onAnalysisOutline.add(new AnalysisOutlineParams.fromJson(decoder, 'params', params));
+        _onAnalysisOutline
+            .add(new AnalysisOutlineParams.fromJson(decoder, 'params', params));
         break;
       case "analysis.overrides":
         outOfTestExpect(params, isAnalysisOverridesParams);
-        _onAnalysisOverrides.add(new AnalysisOverridesParams.fromJson(decoder, 'params', params));
+        _onAnalysisOverrides.add(
+            new AnalysisOverridesParams.fromJson(decoder, 'params', params));
         break;
       case "completion.results":
         outOfTestExpect(params, isCompletionResultsParams);
-        _onCompletionResults.add(new CompletionResultsParams.fromJson(decoder, 'params', params));
+        _onCompletionResults.add(
+            new CompletionResultsParams.fromJson(decoder, 'params', params));
         break;
       case "search.results":
         outOfTestExpect(params, isSearchResultsParams);
-        _onSearchResults.add(new SearchResultsParams.fromJson(decoder, 'params', params));
+        _onSearchResults
+            .add(new SearchResultsParams.fromJson(decoder, 'params', params));
         break;
       case "execution.launchData":
         outOfTestExpect(params, isExecutionLaunchDataParams);
-        _onExecutionLaunchData.add(new ExecutionLaunchDataParams.fromJson(decoder, 'params', params));
+        _onExecutionLaunchData.add(
+            new ExecutionLaunchDataParams.fromJson(decoder, 'params', params));
         break;
       default:
         fail('Unexpected notification: $event');
         break;
     }
   }
 }