Use AnalysisDriver to run task tests.

pkg/analyzer/lib/src/task/driver.dart

 // Copyright (c) 2015, 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.
 
 library analyzer.src.task.driver;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/context/cache.dart';
@@ skipping 48 matching lines @@
    */
   Stream<AnalysisTask> get onTaskCompleted => _onTaskCompletedController.stream;
 
   /**
    * The stream that is notified when a task is started.
    */
   Stream<AnalysisTask> get onTaskStarted => _onTaskStartedController.stream;
 
   /**
    * Perform work until the given [result] has been computed for the given
-   * [target].
+   * [target]. Return the last [AnalysisTask] that was performed.
    */
-  void computeResult(AnalysisTarget target, ResultDescriptor result) {
+  AnalysisTask computeResult(AnalysisTarget target, ResultDescriptor result) {
+    AnalysisTask task;
     WorkOrder workOrder = createWorkOrderForResult(target, result);
     if (workOrder != null) {
       while (workOrder.moveNext()) {
-        performWorkItem(workOrder.current);
+        task = performWorkItem(workOrder.current);
       }
     }
+    return task;
   }
 
   /**
    * Return the work order describing the work that should be getting worked on,
    * or `null` if there is currently no work to be done.
    */
   WorkOrder createNextWorkOrder() {
     //
     // TODO(brianwilkerson) This is an inefficient implementation. We need to
     // port over the concept of the WorkManager to manage the list of sources
@@ skipping 90 matching lines @@
     } else if (currentWorkOrder.moveNext()) {
       performWorkItem(currentWorkOrder.current);
     } else {
       currentWorkOrder = createNextWorkOrder();
     }
     return currentWorkOrder != null;
   }
 
   /**
    * Perform the given work item.
+   * Return the performed [AnalysisTask].
    */
-  void performWorkItem(WorkItem item) {
+  AnalysisTask performWorkItem(WorkItem item) {
     if (item.exception != null) {
       // Mark all of the results that the task would have computed as being in
       // ERROR with the exception recorded on the work item.
       CacheEntry targetEntry = context.getCacheEntry(item.target);
       targetEntry.setErrorState(item.exception, item.descriptor.results);
-      return;
+      return null;
     }
     // Otherwise, perform the task.
     AnalysisTask task = item.buildTask();
     _onTaskStartedController.add(task);
     task.perform();
     CacheEntry entry = context.getCacheEntry(task.target);
     if (task.caughtException == null) {
       Map<ResultDescriptor, dynamic> outputs = task.outputs;
       for (ResultDescriptor result in task.descriptor.results) {
         // TODO(brianwilkerson) We could check here that a value was produced
         // and throw an exception if not (unless we want to allow null values).
         entry.setValue(result, outputs[result]);
       }
     } else {
       entry.setErrorState(task.caughtException, item.descriptor.results);
     }
     _onTaskCompletedController.add(task);
+    return task;
   }
 
   /**
    * Reset the state of the driver in response to a change in the state of one
    * or more analysis targets. This will cause any analysis that was currently
    * in process to be stopped and for analysis to resume based on the new state.
    */
   void reset() {
     currentWorkOrder = null;
   }
@@ skipping 178 matching lines @@
     currentItem = pendingItems.removeLast();
     WorkItem childItem = currentItem.gatherInputs(taskManager);
     while (childItem != null) {
       pendingItems.add(currentItem);
       currentItem = childItem;
       childItem = currentItem.gatherInputs(taskManager);
     }
     return true;
   }
 }