Task: Build Public Namespace.

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 14 matching lines @@
 import 'package:unittest/unittest.dart';
 
 import '../../generated/resolver_test.dart';
 import '../../generated/test_support.dart';
 import '../../reflective_tests.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(BuildCompilationUnitElementTaskTest);
   runReflectiveTests(BuildLibraryElementTaskTest);
+  runReflectiveTests(BuildPublicNamespaceTaskTest);
   runReflectiveTests(ParseDartTaskTest);
   runReflectiveTests(ScanDartTaskTest);
 }
 
 @reflectiveTest
 class BuildCompilationUnitElementTaskTest extends EngineTestCase {
   test_buildInputs() {
     AnalysisTarget target = new TestSource();
     Map<String, TaskInput> inputs =
         BuildCompilationUnitElementTask.buildInputs(target);
-    expect(inputs, isNotNull);
-    expect(inputs, hasLength(1));
-    expect(inputs[BuildCompilationUnitElementTask.PARSED_UNIT_INPUT_NAME],
-        isNotNull);
+    expect(inputs.keys, unorderedEquals(
+        [BuildCompilationUnitElementTask.PARSED_UNIT_INPUT_NAME]));
   }
 
   test_constructor() {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     AnalysisTarget target = new TestSource();
     BuildCompilationUnitElementTask task =
         new BuildCompilationUnitElementTask(context, target);
     expect(task, isNotNull);
     expect(task.context, context);
     expect(task.target, target);
@@ skipping 59 matching lines @@
       BuildCompilationUnitElementTask.PARSED_UNIT_INPUT_NAME:
           parseOutputs[PARSED_UNIT]
     };
     buildTask.perform();
 
     return buildTask;
   }
 }
 
 @reflectiveTest
-class BuildLibraryElementTaskTest extends EngineTestCase {
-  MemoryResourceProvider resourceProvider = new MemoryResourceProvider();
-  InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
-
+class BuildLibraryElementTaskTest extends _AbstractDartTaskTest {
   Source librarySource;
   CompilationUnit libraryUnit;
   CompilationUnitElement libraryUnitElement;
   List<CompilationUnit> partUnits;
 
-  BuildLibraryElementTask task;
-  Map<ResultDescriptor<dynamic>, dynamic> outputs;
   LibraryElement libraryElement;
 
-  void setUp() {
-    DartSdk sdk = context.sourceFactory.dartSdk;
-    context.sourceFactory = new SourceFactory(<UriResolver>[
-      new DartUriResolver(sdk),
-      new ResourceUriResolver(resourceProvider)
-    ]);
-  }
-
   test_buildInputs() {
     ExtendedAnalysisContext context = new _MockContext();
     // prepare sources
     File libraryFile = resourceProvider.newFile('/lib.dart', '');
     File partFile1 = resourceProvider.newFile('/part1.dart', '');
     File partFile2 = resourceProvider.newFile('/part2.dart', '');
     Source librarySource = libraryFile.createSource();
     Source partSource1 = partFile1.createSource();
     Source partSource2 = partFile2.createSource();
     // set INCLUDED_PARTS
@@ skipping 207 matching lines @@
     expect(unitElement2.topLevelVariables, [variable]);
   }
 
   void _assertErrorsWithCodes(List<ErrorCode> expectedErrorCodes) {
     List<AnalysisError> errors = outputs[BUILD_LIBRARY_ERRORS];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
     errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
-  CompilationUnit _buildCompilationUnit(
-      InternalAnalysisContext context, String path, String content) {
-    File file = resourceProvider.newFile(path, content);
-    Source source = file.createSource();
-
-    ScanDartTask scanTask = new ScanDartTask(context, source);
-    scanTask.inputs = {ScanDartTask.CONTENT_INPUT_NAME: content};
-    scanTask.perform();
-    Map<ResultDescriptor, dynamic> scanOutputs = scanTask.outputs;
-
-    ParseDartTask parseTask = new ParseDartTask(context, source);
-    parseTask.inputs = {
-      ParseDartTask.LINE_INFO_INPUT_NAME: scanOutputs[LINE_INFO],
-      ParseDartTask.TOKEN_STREAM_INPUT_NAME: scanOutputs[TOKEN_STREAM]
-    };
-    parseTask.perform();
-    Map<ResultDescriptor, dynamic> parseOutputs = parseTask.outputs;
-
-    BuildCompilationUnitElementTask buildTask =
-        new BuildCompilationUnitElementTask(context, source);
-    buildTask.inputs = {
-      BuildCompilationUnitElementTask.PARSED_UNIT_INPUT_NAME:
-          parseOutputs[PARSED_UNIT]
-    };
-    buildTask.perform();
-    return buildTask.outputs[BUILT_UNIT];
-  }
-
   void _performBuildTask(Map<String, String> sourceMap) {
+    _BuildLibraryElementTaskResult result = _buildLibraryElement(sourceMap);
     Map<String, CompilationUnit> unitMap = <String, CompilationUnit>{};
     sourceMap.forEach((String path, String content) {
-      CompilationUnit unit = _buildCompilationUnit(context, path, content);
+      CompilationUnit unit = _buildCompilationUnit(path, content);
       unitMap[path] = unit;
     });
 
-    libraryUnit = unitMap.values.first;
-    libraryUnitElement = libraryUnit.element;
-    librarySource = libraryUnitElement.source;
-    partUnits = unitMap.values.skip(1).toList();
+    libraryUnit = result.libraryUnit;
+    libraryUnitElement = result.libraryUnitElement;
+    librarySource = result.librarySource;
+    partUnits = result.partUnits;
 
-    task = new BuildLibraryElementTask(context, librarySource);
-    task.inputs = {
-      BuildLibraryElementTask.DEFINING_BUILT_UNIT_INPUT_NAME: libraryUnit,
-      BuildLibraryElementTask.PART_BUILT_UNITS_INPUT_NAME: partUnits
-    };
-    task.perform();
-    outputs = task.outputs;
-    libraryElement = outputs[BUILT_LIBRARY_ELEMENT];
+    task = result.task;
+    outputs = result.outputs;
+    libraryElement = result.libraryElement;
   }
 }
 
+@reflectiveTest
+class BuildPublicNamespaceTaskTest extends _AbstractDartTaskTest {
+  test_buildInputs() {
+    AnalysisTarget target = new TestSource();
+    Map<String, TaskInput> inputs =
+        BuildPublicNamespaceTask.buildInputs(target);
+    expect(inputs.keys, unorderedEquals(
+        [BuildPublicNamespaceTask.BUILT_LIBRARY_ELEMENT_INPUT_NAME]));
+  }
+
+  test_constructor() {
+    AnalysisContext context = AnalysisContextFactory.contextWithCore();
+    AnalysisTarget target = new TestSource();
+    BuildPublicNamespaceTask task =
+        new BuildPublicNamespaceTask(context, target);
+    expect(task, isNotNull);
+    expect(task.context, context);
+    expect(task.target, target);
+  }
+
+  test_createTask() {
+    AnalysisContext context = AnalysisContextFactory.contextWithCore();
+    AnalysisTarget target = new TestSource();
+    BuildPublicNamespaceTask task =
+        BuildPublicNamespaceTask.createTask(context, target);
+    expect(task, isNotNull);
+    expect(task.context, context);
+    expect(task.target, target);
+  }
+
+  test_description() {
+    AnalysisTarget target = new TestSource();
+    BuildPublicNamespaceTask task = new BuildPublicNamespaceTask(null, target);
+    expect(task.description, isNotNull);
+  }
+
+  test_descriptor() {
+    TaskDescriptor descriptor = BuildPublicNamespaceTask.DESCRIPTOR;
+    expect(descriptor, isNotNull);
+  }
+
+  test_perform() {
+    var buildLibraryElementResult = _buildLibraryElement({
+      '/lib.dart': '''
+library lib;
+part 'part.dart';
+a() {}
+_b() {}
+''',
+      '/part.dart': '''
+part of lib;
+_c() {}
+d() {}
+'''
+    });
+    Source librarySource = buildLibraryElementResult.librarySource;
+    LibraryElement libraryElement = buildLibraryElementResult.libraryElement;
+    // perform task
+    BuildPublicNamespaceTask task =
+        new BuildPublicNamespaceTask(context, librarySource);
+    task.inputs = {
+      BuildPublicNamespaceTask.BUILT_LIBRARY_ELEMENT_INPUT_NAME: libraryElement
+    };
+    Map<ResultDescriptor, dynamic> outputs = _performTask(task);
+    // validate
+    Namespace namespace = outputs[PUBLIC_NAMESPACE];
+    expect(namespace.definedNames.keys, unorderedEquals(['a', 'd']));
+  }
+}
+
 @reflectiveTest
 class ParseDartTaskTest extends EngineTestCase {
   test_buildInputs() {
     AnalysisTarget target = new TestSource();
     Map<String, TaskInput> inputs = ParseDartTask.buildInputs(target);
-    expect(inputs, isNotNull);
-    expect(inputs, hasLength(2));
-    expect(inputs[ParseDartTask.LINE_INFO_INPUT_NAME], isNotNull);
-    expect(inputs[ParseDartTask.TOKEN_STREAM_INPUT_NAME], isNotNull);
+    expect(inputs.keys, unorderedEquals([

[Brian Wilkerson, 2015/03/11 20:55:25]

I'd rather have the explicit test that 'inputs' isn't null than for the test to
fail with an NPE, but maybe that's foolish.

+      ParseDartTask.LINE_INFO_INPUT_NAME,
+      ParseDartTask.TOKEN_STREAM_INPUT_NAME
+    ]));
   }
 
   test_constructor() {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     AnalysisTarget target = new TestSource();
     ParseDartTask task = new ParseDartTask(context, target);
     expect(task, isNotNull);
     expect(task.context, context);
     expect(task.target, target);
   }
@@ skipping 90 matching lines @@
     parseTask.perform();
     return parseTask;
   }
 }
 
 @reflectiveTest
 class ScanDartTaskTest extends EngineTestCase {
   test_buildInputs() {
     AnalysisTarget target = new TestSource();
     Map<String, TaskInput> inputs = ScanDartTask.buildInputs(target);
-    expect(inputs, isNotNull);
-    expect(inputs, hasLength(1));
-    expect(inputs[ScanDartTask.CONTENT_INPUT_NAME], isNotNull);
+    expect(inputs.keys, unorderedEquals([ScanDartTask.CONTENT_INPUT_NAME]));
   }
 
   test_constructor() {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     AnalysisTarget target = new TestSource();
     ScanDartTask task = new ScanDartTask(context, target);
     expect(task, isNotNull);
     expect(task.context, context);
     expect(task.target, target);
   }
@@ skipping 44 matching lines @@
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     AnalysisTarget target = new TestSource();
 
     ScanDartTask scanTask = new ScanDartTask(context, target);
     scanTask.inputs = {ScanDartTask.CONTENT_INPUT_NAME: content};
     scanTask.perform();
     return scanTask;
   }
 }
 
+class _AbstractDartTaskTest extends EngineTestCase {
+  MemoryResourceProvider resourceProvider = new MemoryResourceProvider();
+
+  InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
+  Map<AnalysisTarget, CacheEntry> entryMap = <AnalysisTarget, CacheEntry>{};
+
+  AnalysisTask task;
+  Map<ResultDescriptor<dynamic>, dynamic> outputs;
+
+  CacheEntry getCacheEntry(AnalysisTarget target) {
+    return entryMap.putIfAbsent(target, () => new CacheEntry());
+  }
+
+  void setUp() {
+    DartSdk sdk = context.sourceFactory.dartSdk;
+    context.sourceFactory = new SourceFactory(<UriResolver>[
+      new DartUriResolver(sdk),
+      new ResourceUriResolver(resourceProvider)
+    ]);
+  }
+
+  CompilationUnit _buildCompilationUnit(String path, String content) {
+    File file = resourceProvider.newFile(path, content);
+    Source source = file.createSource();
+    // scan
+    ScanDartTask scanTask = new ScanDartTask(context, source);
+    scanTask.inputs = {ScanDartTask.CONTENT_INPUT_NAME: content};
+    var scanOutputs = _performTask(scanTask);
+    // parse
+    ParseDartTask parseTask = new ParseDartTask(context, source);
+    parseTask.inputs = {
+      ParseDartTask.LINE_INFO_INPUT_NAME: scanOutputs[LINE_INFO],
+      ParseDartTask.TOKEN_STREAM_INPUT_NAME: scanOutputs[TOKEN_STREAM]
+    };
+    var parseOutputs = _performTask(parseTask);
+    // build CompilationUnit
+    BuildCompilationUnitElementTask buildTask =
+        new BuildCompilationUnitElementTask(context, source);
+    buildTask.inputs = {
+      BuildCompilationUnitElementTask.PARSED_UNIT_INPUT_NAME:
+          parseOutputs[PARSED_UNIT]
+    };
+    var buildUnitOutputs = _performTask(buildTask);
+    // done
+    return buildUnitOutputs[BUILT_UNIT];
+  }
+
+  _BuildLibraryElementTaskResult _buildLibraryElement(
+      Map<String, String> sourceMap) {
+    Map<String, CompilationUnit> unitMap = <String, CompilationUnit>{};
+    sourceMap.forEach((String path, String content) {
+      CompilationUnit unit = _buildCompilationUnit(path, content);
+      unitMap[path] = unit;
+    });
+
+    CompilationUnit libraryUnit = unitMap.values.first;
+    CompilationUnitElement libraryUnitElement = libraryUnit.element;
+    Source librarySource = libraryUnitElement.source;
+    List<CompilationUnit> partUnits = unitMap.values.skip(1).toList();
+
+    BuildLibraryElementTask task =
+        new BuildLibraryElementTask(context, librarySource);
+    task.inputs = {
+      BuildLibraryElementTask.DEFINING_BUILT_UNIT_INPUT_NAME: libraryUnit,
+      BuildLibraryElementTask.PART_BUILT_UNITS_INPUT_NAME: partUnits
+    };
+    Map<ResultDescriptor, dynamic> outputs = _performTask(task);
+
+    LibraryElement libraryElement = outputs[BUILT_LIBRARY_ELEMENT];
+    return new _BuildLibraryElementTaskResult(librarySource, libraryUnit,
+        libraryUnitElement, partUnits, task, outputs, libraryElement);
+  }
+
+  /**
+   * Perform the given [task], record and return its outputs.
+   */
+  Map<ResultDescriptor, dynamic> _performTask(AnalysisTask task) {
+    AnalysisTarget target = task.target;
+    // perform the task
+    task.perform();
+    Map<ResultDescriptor, dynamic> outputs = task.outputs;
+    // file the cache entry
+    CacheEntry cacheEntry = getCacheEntry(target);
+    outputs.forEach((result, value) {
+      cacheEntry.setValue(result, value);
+    });
+    return outputs;
+  }
+}
+
+class _BuildLibraryElementTaskResult {
+  final Source librarySource;
+  final CompilationUnit libraryUnit;
+  final CompilationUnitElement libraryUnitElement;
+  final List<CompilationUnit> partUnits;
+  final BuildLibraryElementTask task;
+  final Map<ResultDescriptor, dynamic> outputs;
+  final LibraryElement libraryElement;
+  _BuildLibraryElementTaskResult(this.librarySource, this.libraryUnit,
+      this.libraryUnitElement, this.partUnits, this.task, this.outputs,
+      this.libraryElement);
+}
+
 class _MockContext extends TypedMock implements ExtendedAnalysisContext {
   Map<AnalysisTarget, CacheEntry> entryMap = <AnalysisTarget, CacheEntry>{};
 
   @override
   CacheEntry getCacheEntry(AnalysisTarget target) {
     return entryMap.putIfAbsent(target, () => new CacheEntry());
   }
 
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }