AnalysisDriver.createWorkOrderForResult() should check AnalysisContext.aboutToComputeResult() first.

pkg/analyzer/test/src/task/driver_test.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.test.src.task.driver_test;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/task/driver.dart';
@@ skipping 106 matching lines @@
 
   test_createNextWorkOrder_none() {
     _configureDescriptors12();
     when(workManager1.getNextResultPriority())
         .thenReturn(WorkOrderPriority.NONE);
     when(workManager2.getNextResultPriority())
         .thenReturn(WorkOrderPriority.NONE);
     expect(analysisDriver.createNextWorkOrder(), isNull);
   }
 
+  test_createWorkOrderForResult_aboutToComputeResult() {
+    AnalysisTarget target = new TestSource();
+    ResultDescriptor result = new ResultDescriptor('result', null);
+    TaskDescriptor descriptor = new TaskDescriptor(
+        'task',
+        (context, target) => new TestAnalysisTask(context, target),
+        (target) => {},
+        [result]);
+    taskManager.addTaskDescriptor(descriptor);
+    context.getCacheEntry(target).setState(result, CacheState.INVALID);
+    // has result
+    {
+      when(context.aboutToComputeResult(anyObject, result)).thenReturn(true);
+      WorkOrder workOrder =
+          analysisDriver.createWorkOrderForResult(target, result);
+      expect(workOrder, isNull);
+    }
+    // no result
+    {
+      when(context.aboutToComputeResult(anyObject, result)).thenReturn(false);
+      WorkOrder workOrder =
+          analysisDriver.createWorkOrderForResult(target, result);
+      expect(workOrder, isNotNull);
+    }
+  }
+
   test_createWorkOrderForResult_error() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('result', null);
     CaughtException exception = new CaughtException(null, null);
     context
         .getCacheEntry(target)
         .setErrorState(exception, <ResultDescriptor>[result]);
 
     expect(analysisDriver.createWorkOrderForResult(target, result), isNull);
   }
@@ skipping 505 matching lines @@
     AnalysisTarget target = new TestSource();
     TaskDescriptor descriptor = new TaskDescriptor(
         'task', null, (target) => {}, [new ResultDescriptor('result', null)]);
     WorkItem item = new WorkItem(context, target, descriptor, null, 0, null);
     expect(item, isNotNull);
     expect(item.context, context);
     expect(item.descriptor, descriptor);
     expect(item.target, target);
   }
 
-  test_gatherInputs_complete() {
-    AnalysisTarget target = new TestSource();
-    TaskDescriptor descriptor = new TaskDescriptor(
-        'task',
-        (context, target) => new TestAnalysisTask(context, target),
-        (target) => {},
-        [new ResultDescriptor('output', null)]);
-    WorkItem item = new WorkItem(context, target, descriptor, null, 0, null);
-    WorkItem result = item.gatherInputs(taskManager, []);
-    expect(result, isNull);
-    expect(item.exception, isNull);
-  }
-
-  test_gatherInputs_incomplete() {
+  test_gatherInputs_aboutToComputeResult_hasResult() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor resultA = new ResultDescriptor('resultA', null);
     ResultDescriptor resultB = new ResultDescriptor('resultB', null);
     // prepare tasks
     TaskDescriptor task1 = new TaskDescriptor(
         'task',
         (context, target) =>
             new TestAnalysisTask(context, target, results: [resultA]),
         (target) => {},
         [resultA]);
     TaskDescriptor task2 = new TaskDescriptor(
         'task',
         (context, target) => new TestAnalysisTask(context, target),
         (target) => {'one': resultA.of(target)},
         [resultB]);
     taskManager.addTaskDescriptor(task1);
     taskManager.addTaskDescriptor(task2);
+    // configure mocks
+    when(context.aboutToComputeResult(anyObject, resultA)).thenReturn(true);
     // gather inputs
     WorkItem item = new WorkItem(context, target, task2, null, 0, null);
     WorkItem inputItem = item.gatherInputs(taskManager, []);
-    expect(inputItem, isNotNull);
+    expect(inputItem, isNull);
   }
 
-  test_gatherInputs_invalid() {
-    AnalysisTarget target = new TestSource();
-    ResultDescriptor inputResult = new ResultDescriptor('input', null);
-    TaskDescriptor descriptor = new TaskDescriptor(
-        'task',
-        (context, target) => new TestAnalysisTask(context, target),
-        (target) => {'one': inputResult.of(target)},
-        [new ResultDescriptor('output', null)]);
-    WorkItem item = new WorkItem(context, target, descriptor, null, 0, null);
-    WorkItem result = item.gatherInputs(taskManager, []);
-    expect(result, isNull);
-    expect(item.exception, isNotNull);
-  }
-
-  test_gatherInputs_aboutToComputeResult_hasResult() {
+  test_gatherInputs_aboutToComputeResult_noResult() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor resultA = new ResultDescriptor('resultA', null);
     ResultDescriptor resultB = new ResultDescriptor('resultB', null);
     // prepare tasks
     TaskDescriptor task1 = new TaskDescriptor(
         'task',
         (context, target) =>
             new TestAnalysisTask(context, target, results: [resultA]),
         (target) => {},
         [resultA]);
     TaskDescriptor task2 = new TaskDescriptor(
         'task',
         (context, target) => new TestAnalysisTask(context, target),
         (target) => {'one': resultA.of(target)},
         [resultB]);
     taskManager.addTaskDescriptor(task1);
     taskManager.addTaskDescriptor(task2);
+    // configure ResultProvider
     // configure mocks
-    when(context.aboutToComputeResult(anyObject, resultA)).thenReturn(true);
+    when(context.aboutToComputeResult(anyObject, resultA)).thenReturn(false);
     // gather inputs
     WorkItem item = new WorkItem(context, target, task2, null, 0, null);
     WorkItem inputItem = item.gatherInputs(taskManager, []);
-    expect(inputItem, isNull);
+    expect(inputItem, isNotNull);
+    expect(inputItem.target, target);
+    expect(inputItem.descriptor, task1);
   }
 
-  test_gatherInputs_aboutToComputeResult_noResult() {
+  test_gatherInputs_complete() {
+    AnalysisTarget target = new TestSource();
+    TaskDescriptor descriptor = new TaskDescriptor(
+        'task',
+        (context, target) => new TestAnalysisTask(context, target),
+        (target) => {},
+        [new ResultDescriptor('output', null)]);
+    WorkItem item = new WorkItem(context, target, descriptor, null, 0, null);
+    WorkItem result = item.gatherInputs(taskManager, []);
+    expect(result, isNull);
+    expect(item.exception, isNull);
+  }
+
+  test_gatherInputs_incomplete() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor resultA = new ResultDescriptor('resultA', null);
     ResultDescriptor resultB = new ResultDescriptor('resultB', null);
     // prepare tasks
     TaskDescriptor task1 = new TaskDescriptor(
         'task',
         (context, target) =>
             new TestAnalysisTask(context, target, results: [resultA]),
         (target) => {},
         [resultA]);
     TaskDescriptor task2 = new TaskDescriptor(
         'task',
         (context, target) => new TestAnalysisTask(context, target),
         (target) => {'one': resultA.of(target)},
         [resultB]);
     taskManager.addTaskDescriptor(task1);
     taskManager.addTaskDescriptor(task2);
-    // configure ResultProvider
-    // configure mocks
-    when(context.aboutToComputeResult(anyObject, resultA)).thenReturn(false);
     // gather inputs
     WorkItem item = new WorkItem(context, target, task2, null, 0, null);
     WorkItem inputItem = item.gatherInputs(taskManager, []);
     expect(inputItem, isNotNull);
-    expect(inputItem.target, target);
-    expect(inputItem.descriptor, task1);
+  }
+
+  test_gatherInputs_invalid() {
+    AnalysisTarget target = new TestSource();
+    ResultDescriptor inputResult = new ResultDescriptor('input', null);
+    TaskDescriptor descriptor = new TaskDescriptor(
+        'task',
+        (context, target) => new TestAnalysisTask(context, target),
+        (target) => {'one': inputResult.of(target)},
+        [new ResultDescriptor('output', null)]);
+    WorkItem item = new WorkItem(context, target, descriptor, null, 0, null);
+    WorkItem result = item.gatherInputs(taskManager, []);
+    expect(result, isNull);
+    expect(item.exception, isNotNull);
   }
 }
 
 @reflectiveTest
 class WorkOrderTest extends EngineTestCase {
   test_create() {
     TaskManager manager = new TaskManager();
     TaskDescriptor descriptor = new TaskDescriptor(
         'task', null, (_) => {}, [new ResultDescriptor('result', null)]);
     WorkOrder order = new WorkOrder(
@@ skipping 64 matching lines @@
       if (!skipInputs.contains(dependency) &&
           !evaluatedNodes.contains(dependency)) {
         return dependency;
       }
     }
     return null;
   }
 }
 
 class _WorkManagerMock extends TypedMock implements WorkManager {}