Replace typed_mock with mockito in analyzer.

pkg/analyzer/test/src/task/html_work_manager_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.html_work_manager_test;
 
 import 'package:analyzer/error/error.dart' show AnalysisError;
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/context/context.dart';
 import 'package:analyzer/src/error/codes.dart' show HtmlErrorCode;
 import 'package:analyzer/src/generated/engine.dart'
     show
         AnalysisEngine,
         AnalysisErrorInfo,
         AnalysisErrorInfoImpl,
         CacheState,
         ChangeNoticeImpl,
         InternalAnalysisContext;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/task/html.dart';
 import 'package:analyzer/src/task/html_work_manager.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/html.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';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(HtmlWorkManagerTest);
     defineReflectiveTests(HtmlWorkManagerIntegrationTest);
   });
 }
 
@@ skipping 237 matching lines @@
   void test_getNextResultPriority_hasSource() {
     manager.sourceQueue.addAll([source1]);
     expect(manager.getNextResultPriority(), WorkOrderPriority.NORMAL);
   }
 
   void test_getNextResultPriority_nothingToDo() {
     expect(manager.getNextResultPriority(), WorkOrderPriority.NONE);
   }
 
   void test_onAnalysisOptionsChanged() {
-    when(context.exists(anyObject)).thenReturn(true);
+    when(context.exists(any)).thenReturn(true);
     // set cache values
     entry1.setValue(DART_SCRIPTS, [], []);
     entry1.setValue(HTML_DOCUMENT, null, []);
     entry1.setValue(HTML_DOCUMENT_ERRORS, [], []);
     entry1.setValue(HTML_ERRORS, [], []);
     entry1.setValue(REFERENCED_LIBRARIES, [], []);
     // notify
     manager.onAnalysisOptionsChanged();
     // Only resolution-based values are invalidated.
     expect(entry1.getState(DART_SCRIPTS), CacheState.VALID);
     expect(entry1.getState(HTML_DOCUMENT), CacheState.VALID);
     expect(entry1.getState(HTML_DOCUMENT_ERRORS), CacheState.VALID);
     expect(entry1.getState(HTML_ERRORS), CacheState.INVALID);
     expect(entry1.getState(REFERENCED_LIBRARIES), CacheState.VALID);
   }
 
   void test_onResultInvalidated_scheduleInvalidatedLibraries() {
     // set HTML_ERRORS for source1 and source3
     entry1.setValue(HTML_ERRORS, [], []);
     entry3.setValue(HTML_ERRORS, [], []);
     // invalidate HTML_ERRORS for source1, schedule it
     entry1.setState(HTML_ERRORS, CacheState.INVALID);
     expect_sourceQueue([source1]);
     // invalidate HTML_ERRORS for source3, schedule it
     entry3.setState(HTML_ERRORS, CacheState.INVALID);
     expect_sourceQueue([source1, source3]);
   }
 
   void test_onSourceFactoryChanged() {
-    when(context.exists(anyObject)).thenReturn(true);
+    when(context.exists(any)).thenReturn(true);
     // set cache values
     entry1.setValue(DART_SCRIPTS, [], []);
     entry1.setValue(HTML_DOCUMENT, null, []);
     entry1.setValue(HTML_DOCUMENT_ERRORS, [], []);
     entry1.setValue(HTML_ERRORS, [], []);
     entry1.setValue(REFERENCED_LIBRARIES, [], []);
     // notify
     manager.onSourceFactoryChanged();
     // Only resolution-based values are invalidated.
     expect(entry1.getState(DART_SCRIPTS), CacheState.VALID);
@@ skipping 13 matching lines @@
     entry1.setValue(HTML_ERRORS, <AnalysisError>[error1, error2], []);
     // RESOLVED_UNIT is ready, set errors
     manager.resultsComputed(source1, {HTML_ERRORS: null});
     // all of the errors are included
     ChangeNoticeImpl notice = context.getNotice(source1);
     expect(notice.errors, unorderedEquals([error1, error2]));
     expect(notice.lineInfo, lineInfo);
   }
 }
 
-class _InternalAnalysisContextMock extends TypedMock
+class _InternalAnalysisContextMock extends Mock
     implements InternalAnalysisContext {
   @override
   CachePartition privateAnalysisCachePartition;
 
   @override
   AnalysisCache analysisCache;
 
   // The production version is a stream that carries messages from the cache
   // since the cache changes. Here, we can just pass the inner stream because
   // it doesn't change.
@@ skipping 30 matching lines @@
         errors, getCacheEntry(source).getValue(LINE_INFO));
   }
 
   @override
   ChangeNoticeImpl getNotice(Source source) {
     return _pendingNotices.putIfAbsent(
         source, () => new ChangeNoticeImpl(source));
   }
 }
 
-class _SourceFactoryMock extends TypedMock implements SourceFactory {}
+class _SourceFactoryMock extends Mock implements SourceFactory {}