Compute TYPE_PROVIDER using BuildTypeProviderTask.

pkg/analyzer/test/src/task/dart_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 test.src.task.dart_test;
 
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 19 matching lines @@
 import '../../generated/test_support.dart';
 import '../../reflective_tests.dart';
 import '../mock_sdk.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(BuildCompilationUnitElementTaskTest);
   runReflectiveTests(BuildDirectiveElementsTaskTest);
   runReflectiveTests(BuildLibraryElementTaskTest);
   runReflectiveTests(BuildPublicNamespaceTaskTest);
+  runReflectiveTests(BuildTypeProviderTaskTest);
   runReflectiveTests(ParseDartTaskTest);
   runReflectiveTests(ScanDartTaskTest);
 }
 
 @reflectiveTest
 class BuildCompilationUnitElementTaskTest extends _AbstractDartTaskTest {
   test_buildInputs() {
     Map<String, TaskInput> inputs =
         BuildCompilationUnitElementTask.buildInputs(emptySource);
     expect(inputs, isNotNull);
@@ skipping 616 matching lines @@
     });
     _computeResult(sources.first, PUBLIC_NAMESPACE);
     expect(task, new isInstanceOf<BuildPublicNamespaceTask>());
     // validate
     Namespace namespace = outputs[PUBLIC_NAMESPACE];
     expect(namespace.definedNames.keys, unorderedEquals(['a', 'd']));
   }
 }
 
 @reflectiveTest
+class BuildTypeProviderTaskTest extends _AbstractDartTaskTest {
+  test_perform() {
+    _computeResult(AnalysisContextTarget.request, TYPE_PROVIDER);
+    expect(task, new isInstanceOf<BuildTypeProviderTask>());
+    // validate
+    TypeProvider typeProvider = outputs[TYPE_PROVIDER];
+    expect(typeProvider, isNotNull);
+    expect(typeProvider.boolType, isNotNull);
+    expect(typeProvider.intType, isNotNull);
+    expect(typeProvider.futureType, isNotNull);
+  }
+}
+
+@reflectiveTest
 class ParseDartTaskTest extends _AbstractDartTaskTest {
   test_buildInputs() {
     Map<String, TaskInput> inputs = ParseDartTask.buildInputs(emptySource);
     expect(inputs, isNotNull);
     expect(inputs.keys, unorderedEquals([
       ParseDartTask.LINE_INFO_INPUT_NAME,
       ParseDartTask.TOKEN_STREAM_INPUT_NAME
     ]));
   }
 
@@ skipping 162 matching lines @@
       new DartUriResolver(sdk),
       new ResourceUriResolver(resourceProvider)
     ]);
     // prepare TaskManager
     taskManager.addTaskDescriptor(GetContentTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(ScanDartTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(ParseDartTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(BuildCompilationUnitElementTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(BuildLibraryElementTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(BuildPublicNamespaceTask.DESCRIPTOR);
+    taskManager.addTaskDescriptor(BuildTypeProviderTask.DESCRIPTOR);
     taskManager.addTaskDescriptor(BuildDirectiveElementsTask.DESCRIPTOR);
     // prepare AnalysisDriver
     analysisDriver = new AnalysisDriver(taskManager, context);
   }
 
   void _computeResult(AnalysisTarget target, ResultDescriptor result) {
     task = analysisDriver.computeResult(target, result);
+    expect(task.caughtException, isNull);
     outputs = task.outputs;
   }
 
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
     List<AnalysisError> errors = task.outputs[result];
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
@@ skipping 12 matching lines @@
       Source source = file.createSource();
       sources.add(source);
     });
     return sources;
   }
 }
 
 class _MockContext extends TypedMock implements ExtendedAnalysisContext {
   AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
   SourceFactory sourceFactory;
+  TypeProvider typeProvider;
 
   Map<AnalysisTarget, CacheEntry> entryMap = <AnalysisTarget, CacheEntry>{};
 
   String get name => '_MockContext';
 
   bool exists(Source source) => source.exists();
 
   @override
   CacheEntry getCacheEntry(AnalysisTarget target) {
     return entryMap.putIfAbsent(target, () => new CacheEntry());
   }
 
   TimestampedData<String> getContents(Source source) => source.contents;
 
   noSuchMethod(Invocation invocation) {
     print('noSuchMethod: ${invocation.memberName}');
     return super.noSuchMethod(invocation);
   }
 }