Replace typed_mock with mockito in analyzer.

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/exception/exception.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/task/driver.dart';
 import 'package:analyzer/src/task/inputs.dart';
 import 'package:analyzer/src/task/manager.dart';
 import 'package:analyzer/task/model.dart';
+import 'package:mockito/mockito.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
-import 'package:typed_mock/typed_mock.dart';
 
 import '../../generated/test_support.dart';
 import 'test_support.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(AnalysisDriverTest);
     defineReflectiveTests(CycleAwareDependencyWalkerTest);
     defineReflectiveTests(WorkItemTest);
     defineReflectiveTests(WorkOrderTest);
   });
 }
 
 class AbstractDriverTest {
   TaskManager taskManager = new TaskManager();
   List<WorkManager> workManagers = <WorkManager>[];
   InternalAnalysisContext context = new _InternalAnalysisContextMock();
   AnalysisDriver analysisDriver;
 
   void setUp() {
     context = new _InternalAnalysisContextMock();
     analysisDriver = new AnalysisDriver(taskManager, workManagers, context);
-    when(context.aboutToComputeResult(anyObject, anyObject)).thenReturn(false);
+    when(context.aboutToComputeResult(any, any)).thenReturn(false);
   }
 }
 
 @reflectiveTest
 class AnalysisDriverTest extends AbstractDriverTest {
   WorkManager workManager1 = new _WorkManagerMock();
   WorkManager workManager2 = new _WorkManagerMock();
 
   AnalysisTarget target1 = new TestSource('/1.dart');
   AnalysisTarget target2 = new TestSource('/2.dart');
@@ skipping 79 matching lines @@
     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);
+      when(context.aboutToComputeResult(any, result)).thenReturn(true);
       WorkOrder workOrder =
           analysisDriver.createWorkOrderForResult(target, result);
       expect(workOrder, isNull);
     }
     // no result
     {
-      when(context.aboutToComputeResult(anyObject, result)).thenReturn(false);
+      when(context.aboutToComputeResult(any, 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);
@@ skipping 66 matching lines @@
   test_createWorkOrderForTarget_incomplete_priorityTarget_generalResult() {
     _createWorkOrderForTarget(false, true, false);
   }
 
   test_createWorkOrderForTarget_incomplete_priorityTarget_priorityResult() {
     _createWorkOrderForTarget(false, true, true);
   }
 
   test_performAnalysisTask() {
     _configureDescriptors12();
-    when(workManager1.getNextResultPriority()).thenReturnList(
-        <WorkOrderPriority>[WorkOrderPriority.NORMAL, WorkOrderPriority.NONE]);
     when(workManager1.getNextResult())
         .thenReturn(new TargetedResult(target1, result1));
 
+    when(workManager1.getNextResultPriority())
+        .thenReturn(WorkOrderPriority.NORMAL);
     expect(analysisDriver.performAnalysisTask(), true);
     expect(analysisDriver.performAnalysisTask(), true);
+
+    when(workManager1.getNextResultPriority())
+        .thenReturn(WorkOrderPriority.NONE);
     expect(analysisDriver.performAnalysisTask(), false);
   }
 
   test_performAnalysisTask_infiniteLoop_handled() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor<int> resultA = new ResultDescriptor<int>('resultA', -1);
     ResultDescriptor<int> resultB = new ResultDescriptor<int>('resultB', -2);
     // configure tasks
     TestAnalysisTask task1;
     TestAnalysisTask task2;
@@ skipping 13 matching lines @@
         value: 10,
         handlesDependencyCycles: true);
     task2 = new TestAnalysisTask(context, target,
         descriptor: descriptor2,
         results: [resultB],
         value: 20,
         handlesDependencyCycles: true);
     taskManager.addTaskDescriptor(descriptor1);
     taskManager.addTaskDescriptor(descriptor2);
     // configure WorkManager
-    when(workManager1.getNextResultPriority()).thenReturnList(
-        <WorkOrderPriority>[WorkOrderPriority.NORMAL, WorkOrderPriority.NONE]);
+    when(workManager1.getNextResultPriority())
+        .thenReturn(WorkOrderPriority.NORMAL);
     when(workManager1.getNextResult())
         .thenReturn(new TargetedResult(target, resultB));
     // prepare work order
-    while (analysisDriver.performAnalysisTask()) {}
+    while (analysisDriver.performAnalysisTask()) {
+      when(workManager1.getNextResultPriority())
+          .thenReturn(WorkOrderPriority.NONE);
+    }
     Set<TaskDescriptor> expectedCycle = [descriptor1, descriptor2].toSet();
     expect(task1.dependencyCycle, isNotNull);
     expect(task1.dependencyCycle.map((workItem) => workItem.descriptor).toSet(),
         expectedCycle);
     expect(task2.dependencyCycle, isNotNull);
     expect(task2.dependencyCycle.map((workItem) => workItem.descriptor).toSet(),
         expectedCycle);
     CaughtException exception = context.getCacheEntry(target).exception;
     expect(exception, isNull);
     expect(context.getCacheEntry(target).getValue(resultA), 10);
@@ skipping 15 matching lines @@
     TaskDescriptor descriptor2 = new TaskDescriptor(
         'task2',
         (context, target) => task2,
         (target) => {'inputA': new SimpleTaskInput<int>(target, resultA)},
         [resultB]);
     task1 = new TestAnalysisTask(context, target, descriptor: descriptor1);
     task2 = new TestAnalysisTask(context, target, descriptor: descriptor2);
     taskManager.addTaskDescriptor(descriptor1);
     taskManager.addTaskDescriptor(descriptor2);
     // configure WorkManager
-    when(workManager1.getNextResultPriority()).thenReturnList(
-        <WorkOrderPriority>[WorkOrderPriority.NORMAL, WorkOrderPriority.NONE]);
+    when(workManager1.getNextResultPriority())
+        .thenReturn(WorkOrderPriority.NORMAL);
     when(workManager1.getNextResult())
         .thenReturn(new TargetedResult(target, resultB));
     // prepare work order
     expect(analysisDriver.performAnalysisTask(), true);
     expect(analysisDriver.performAnalysisTask(), true);
     CaughtException exception = context.getCacheEntry(target).exception;
     expect(exception, isNotNull);
     expect(exception.exception, new isInstanceOf<InfiniteTaskLoopException>());
   }
 
@@ skipping 11 matching lines @@
         (context, target) => task2,
         (target) => {'inputA': new SimpleTaskInput<int>(target, resultA)},
         [resultB]);
     task1 = new TestAnalysisTask(context, target,
         descriptor: descriptor1, results: [resultA], value: 10);
     task2 = new TestAnalysisTask(context, target,
         descriptor: descriptor2, value: 20);
     taskManager.addTaskDescriptor(descriptor1);
     taskManager.addTaskDescriptor(descriptor2);
     // configure WorkManager
-    when(workManager1.getNextResultPriority()).thenReturnList(
-        <WorkOrderPriority>[WorkOrderPriority.NORMAL, WorkOrderPriority.NONE]);
+    when(workManager1.getNextResultPriority())
+        .thenReturn(WorkOrderPriority.NORMAL);
     when(workManager1.getNextResult())
         .thenReturn(new TargetedResult(target, resultB));
     // prepare work order
     expect(analysisDriver.performAnalysisTask(), true);
     expect(context.getCacheEntry(target).getValue(resultA), -1);
     expect(context.getCacheEntry(target).getValue(resultB), -2);
     // compute resultA
     expect(analysisDriver.performAnalysisTask(), true);
     expect(context.getCacheEntry(target).getValue(resultA), 10);
     expect(context.getCacheEntry(target).getValue(resultB), -2);
     // compute resultB
     expect(analysisDriver.performAnalysisTask(), true);
     expect(context.getCacheEntry(target).getValue(resultA), 10);
     expect(context.getCacheEntry(target).getValue(resultB), 20);
     // done
+    when(workManager1.getNextResultPriority())
+        .thenReturn(WorkOrderPriority.NONE);
     expect(analysisDriver.performAnalysisTask(), false);
   }
 
   test_performAnalysisTask_onResultComputed() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('result', null);
     TestAnalysisTask task;
     TaskDescriptor descriptor = new TaskDescriptor(
         'task', (context, target) => task, (target) => {}, [result]);
     task = new TestAnalysisTask(context, target,
@@ skipping 315 matching lines @@
         (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);
+    when(context.aboutToComputeResult(any, resultA)).thenReturn(true);
     // gather inputs
     WorkItem item = new WorkItem(context, target, task2, null, 0, null);
     WorkItem inputItem = item.gatherInputs(taskManager, []);
     expect(inputItem, isNull);
   }
 
   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(false);
+    when(context.aboutToComputeResult(any, 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_complete() {
     AnalysisTarget target = new TestSource();
@@ skipping 72 matching lines @@
     // done
     expect(order.moveNext(), isFalse);
     expect(order.current, isNull);
   }
 }
 
 /**
  * A dummy [InternalAnalysisContext] that does not use [AnalysisDriver] itself,
  * but provides enough implementation for it to function.
  */
-class _InternalAnalysisContextMock extends TypedMock
+class _InternalAnalysisContextMock extends Mock
     implements InternalAnalysisContext {
   AnalysisCache analysisCache;
 
   @override
   final AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
 
   @override
   List<AnalysisTarget> explicitTargets = <AnalysisTarget>[];
 
   @override
@@ skipping 30 matching lines @@
     for (int dependency in graph[node]) {
       if (!skipInputs.contains(dependency) &&
           !evaluatedNodes.contains(dependency)) {
         return dependency;
       }
     }
     return null;
   }
 }
 
-class _WorkManagerMock extends TypedMock implements WorkManager {}
+class _WorkManagerMock extends Mock implements WorkManager {}