Add BazelPackageUriResolver with resolveAbsolute().

pkg/analyzer/test/generated/bazel_test.dart

 // Copyright (c) 2016, 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.generated.bazel_test;
 
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/generated/bazel.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 main() {
   defineReflectiveSuite(() {
+    defineReflectiveTests(BazelFileUriResolverTest);
+    defineReflectiveTests(BazelPackageUriResolverTest);
     defineReflectiveTests(BazelWorkspaceTest);
-    defineReflectiveTests(BazelFileUriResolverTest);
   });
 }
 
 @reflectiveTest
 class BazelFileUriResolverTest extends _BaseTest {
   BazelWorkspace workspace;
   BazelFileUriResolver resolver;
 
   void setUp() {
     provider.newFile(_p('/workspace/WORKSPACE'), '');
@@ skipping 63 matching lines @@
   }
 
   Source _resolvePath(String absolutePosixPath) {
     String absolutePath = provider.convertPath(absolutePosixPath);
     Uri uri = provider.pathContext.toUri(absolutePath);
     return resolver.resolveAbsolute(uri);
   }
 }
 
 @reflectiveTest
+class BazelPackageUriResolverTest extends _BaseTest {
+  BazelWorkspace workspace;
+  BazelPackageUriResolver resolver;
+
+  void setUp() {
+    provider.newFile(_p('/workspace/WORKSPACE'), '');
+    workspace = new BazelWorkspace(provider, _p('/workspace'));
+    resolver = new BazelPackageUriResolver(workspace);
+    provider.newFile(_p('/workspace/my/foo/lib/foo1.dart'), '');
+    provider.newFile(_p('/workspace/my/foo/lib/gen1.dart'), '');
+    provider.newFile(_p('/workspace/my/foo/lib/gen2.dart'), '');
+    provider.newFile(_p('/workspace/my/foo/lib/src/foo4.dart'), '');
+    provider.newFile(_p('/workspace/third_party/dart/bar/lib/bar1.dart'), '');
+    provider.newFile(
+        _p('/workspace/third_party/dart/bar/lib/src/bar2.dart'), '');
+    provider.newFile(_p('/workspace/bazel-bin/my/foo/lib/gen1.dart'), '');
+    provider.newFile(_p('/workspace/bazel-genfiles/my/foo/lib/gen2.dart'), '');
+    provider.newFile(_p('/workspace/bazel-genfiles/my/foo/lib/gen3.dart'), '');
+  }
+
+  void test_resolveAbsolute_inBazelBin() {
+    _assertResolve(
+        'package:my.foo/gen1.dart', '/workspace/bazel-bin/my/foo/lib/gen1.dart',
+        exists: true);
+  }
+
+  void test_resolveAbsolute_inBazelGenfiles() {
+    _assertResolve('package:my.foo/gen2.dart',
+        '/workspace/bazel-genfiles/my/foo/lib/gen2.dart',
+        exists: true);
+  }
+
+  void test_resolveAbsolute_inBazelGenfiles_notInWorkspace() {
+    _assertResolve('package:my.foo/gen3.dart',
+        '/workspace/bazel-genfiles/my/foo/lib/gen3.dart',
+        exists: true);
+  }
+
+  void test_resolveAbsolute_inWorkspace_doesNotExist() {
+    _assertResolve('package:my.foo/doesNotExist.dart',
+        '/workspace/my/foo/lib/doesNotExist.dart',
+        exists: false);
+  }
+
+  void test_resolveAbsolute_inWorkspace_exists() {
+    _assertResolve(
+        'package:my.foo/foo1.dart', '/workspace/my/foo/lib/foo1.dart',
+        exists: true);
+  }
+
+  void test_resolveAbsolute_null_notPackage() {
+    Source source = resolver.resolveAbsolute(Uri.parse('dart:async'));
+    expect(source, isNull);
+  }
+
+  void test_resolveAbsolute_thirdParty() {
+    _assertResolve('package:bar/bar1.dart',
+        '/workspace/third_party/dart/bar/lib/bar1.dart',
+        exists: true);
+    _assertResolve('package:bar/src/bar2.dart',
+        '/workspace/third_party/dart/bar/lib/src/bar2.dart',
+        exists: true);
+  }
+
+  void _assertResolve(String uriStr, String posixPath, {bool exists: true}) {
+    Uri uri = Uri.parse(uriStr);
+    Source source = resolver.resolveAbsolute(uri);
+    expect(source, isNotNull);
+    expect(source.fullName, _p(posixPath));
+    expect(source.uri, uri);
+    expect(source.exists(), exists);
+  }
+}
+
+@reflectiveTest
 class BazelWorkspaceTest extends _BaseTest {
   void test_factory_fail_notAbsolute() {
     expect(() => new BazelWorkspace(provider, _p('not_absolute')),
         throwsArgumentError);
   }
 
   void test_factory_hasReadonlyFolder() {
     provider.newFolder(_p('/Users/user/test/READONLY/prime'));
     provider.newFolder(_p('/Users/user/test/prime'));
     BazelWorkspace workspace = new BazelWorkspace(
@@ skipping 110 matching lines @@
 }
 
 class _BaseTest {
   final MemoryResourceProvider provider = new MemoryResourceProvider();
 
   /**
    * Return the [provider] specific path for the given Posix [path].
    */
   String _p(String path) => provider.convertPath(path);
 }