Fix computation of errors to not run extra tasks

pkg/analyzer/test/src/task/inputs_test.dart

Index: pkg/analyzer/test/src/task/inputs_test.dart
diff --git a/pkg/analyzer/test/src/task/inputs_test.dart b/pkg/analyzer/test/src/task/inputs_test.dart
index 35e466079c961a4979a68c86bc7edb7c2295b94f..3943a9955e9ec9ae738141926a71e284761727d6 100644
--- a/pkg/analyzer/test/src/task/inputs_test.dart
+++ b/pkg/analyzer/test/src/task/inputs_test.dart
@@ -15,6 +15,8 @@ import '../../utils.dart';
 
 main() {
   initializeTestEnvironment();
+  runReflectiveTests(ConstantTaskInputBuilderTest);
+  runReflectiveTests(ConstantTaskInputTest);
   runReflectiveTests(ListTaskInputImplTest);
   runReflectiveTests(ListToListTaskInputTest);
   runReflectiveTests(ListToListTaskInputBuilderTest);
@@ -28,6 +30,96 @@ main() {
 }
 
 @reflectiveTest
+class ConstantTaskInputBuilderTest extends EngineTestCase {
+  static final int value = 7;
+  static final ConstantTaskInput<int> input = new ConstantTaskInput<int>(value);
+
+  ConstantTaskInputBuilder builder;
+
+  void setUp() {
+    builder = new ConstantTaskInputBuilder(input);
+  }
+
+  test_create() {
+    expect(builder, isNotNull);
+    expect(builder.input, input);
+  }
+
+  test_currentResult_afterOneMoveNext() {
+    builder.moveNext();
+    expect(builder.currentResult, null);
+  }
+
+  test_currentResult_beforeMoveNext() {
+    expect(builder.currentResult, null);
+  }
+
+  test_currentTarget_afterOneMoveNext() {
+    builder.moveNext();
+    expect(builder.currentTarget, null);
+  }
+
+  test_currentTarget_beforeMoveNext() {
+    expect(builder.currentTarget, null);
+  }
+
+  test_currentValue_afterOneMoveNext() {
+    builder.moveNext();
+    expect(() {
+      builder.currentValue = 'value';
+    }, throwsStateError);
+  }
+
+  test_currentValue_beforeMoveNext() {
+    expect(() {
+      builder.currentValue = 'value';
+    }, throwsStateError);
+  }
+
+  test_currentValueNotAvailable_afterOneMoveNext() {
+    builder.moveNext();
+    expect(() {
+      builder.currentValueNotAvailable();
+    }, throwsStateError);
+  }
+
+  test_currentValueNotAvailable_beforeMoveNext() {
+    expect(() {
+      builder.currentValueNotAvailable();
+    }, throwsStateError);
+  }
+
+  test_inputValue_afterOneMoveNext() {
+    builder.moveNext();
+    expect(builder.inputValue, value);
+  }
+
+  test_inputValue_beforeMoveNext() {
+    expect(builder.inputValue, value);
+  }
+
+  test_moveNext() {
+    expect(builder.moveNext(), false);
+    expect(builder.moveNext(), false);
+  }
+}
+
+@reflectiveTest
+class ConstantTaskInputTest extends EngineTestCase {
+  test_create() {
+    int value = 3;
+    ConstantTaskInput<int> input = new ConstantTaskInput<int>(value);
+    expect(input, isNotNull);
+    expect(input.value, value);
+  }
+
+  test_createBuilder() {
+    ConstantTaskInput<int> input = new ConstantTaskInput<int>(5);
+    expect(input.createBuilder(), new isInstanceOf<ConstantTaskInputBuilder>());
+  }
+}
+
+@reflectiveTest
 class ListTaskInputImplTest extends EngineTestCase {
   static final AnalysisTarget target = new TestSource();
   static final result1 =
@@ -800,6 +892,21 @@ class TopLevelTaskInputBuilderTest extends EngineTestCase {
     expect(builder.currentResult, result1);
   }
 
+  test_currentResult_afterTwoMoveNext_withConstantInput() {
+    ConstantTaskInput<int> constantInput = new ConstantTaskInput<int>(11);
+    Map<String, TaskInput> inputDescriptors = {
+      'one': input1,
+      'constant': constantInput,
+      'two': input2
+    };
+    TopLevelTaskInputBuilder builder =
+        new TopLevelTaskInputBuilder(inputDescriptors);
+    builder.moveNext();
+    builder.currentValue = 'value1';
+    builder.moveNext();
+    expect(builder.currentResult, result2);
+  }
+
   test_currentResult_beforeMoveNext() {
     Map<String, TaskInput> inputDescriptors = {};
     TopLevelTaskInputBuilder builder =
@@ -835,6 +942,21 @@ class TopLevelTaskInputBuilderTest extends EngineTestCase {
     expect(builder.currentTarget, target);
   }
 
+  test_currentTarget_afterTwoMoveNext_withConstantInput() {
+    ConstantTaskInput<int> constantInput = new ConstantTaskInput<int>(11);
+    Map<String, TaskInput> inputDescriptors = {
+      'one': input1,
+      'constant': constantInput,
+      'two': input2
+    };
+    TopLevelTaskInputBuilder builder =
+        new TopLevelTaskInputBuilder(inputDescriptors);
+    builder.moveNext();
+    builder.currentValue = 'value1';
+    builder.moveNext();
+    expect(builder.currentTarget, target);
+  }
+
   test_currentTarget_beforeMoveNext() {
     Map<String, TaskInput> inputDescriptors = {};
     TopLevelTaskInputBuilder builder =