Fix current_isolate_info_test.

test/current_isolate_info_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.
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 import 'dart:isolate';
 
 import 'package:path/path.dart' as p;
 import 'package:stack_trace/stack_trace.dart';
 import 'package:test/test.dart';
 
 import 'package:package_resolver/package_resolver.dart';
+import 'package:package_resolver/src/utils.dart';
 
 void main() {
   // It's important to test these, because they use PackageConfig.current and
   // they're used to verify the output of the inner isolate's
   // PackageConfig.current.
   test("_packageResolverLibUri is correct", () async {
     var libPath = p.fromUri(await _packageResolverLibUri);
     expect(new File(p.join(libPath, 'package_resolver.dart')).exists(),
         completion(isTrue));
   });
 
   test("_pathLibUri is correct", () async {
     var libPath = p.fromUri(await _pathLibUri);
     expect(new File(p.join(libPath, 'path.dart')).exists(), completion(isTrue));
   });
 
   group("with a package config", () {
     var resolver;
     setUp(() async {
       var map;
       var currentIsolateMap = await PackageResolver.current.packageConfigMap;
       if (currentIsolateMap != null) {
         map = new Map.from(currentIsolateMap);
       } else {
         // If the isolate running this test isn't using package config, create
         // one from scratch with the same resolution semantics.
-        var map = {};
+        map = {};
         var root = p.fromUri(await PackageResolver.current.packageRoot);
         await for (var link in new Directory(root).list(followLinks: false)) {
           assert(link is Link);
           map[p.basename(link.path)] =
-              p.toUri(await link.resolveSymbolicLinks());
+              ensureTrailingSlash(p.toUri((await link.resolveSymbolicLinks())));
         }
       }
 
       // Ensure that we have at least one URI that ends with "/" and one that
       // doesn't. Both of these cases need to be tested.
       expect(map["package_resolver"].path, endsWith("/"));
       map["path"] = Uri.parse(p.url.normalize(map["path"].toString()));
       expect(map["path"].path, isNot(endsWith("/")));
 
       resolver = new PackageResolver.config(map);
@@ skipping 124 matching lines @@
             return false;
           } on FormatException catch (_) {
             return true;
           }
         }()""", resolver), isTrue);
       });
     });
   });
 }
 
-Future<String> get _packageResolverLibUri async =>
-    (await PackageResolver.current.urlFor("package_resolver")).toString();
+Future<String> get _packageResolverLibUri => _urlForPackage('package_resolver');
 
-Future<String> get _pathLibUri async =>
-    (await PackageResolver.current.urlFor("path")).toString();
+Future<String> get _pathLibUri => _urlForPackage('path');
+
+Future<String> _urlForPackage(String package) async {
+  var uri = await PackageResolver.current.urlFor(package);
+  if (await PackageResolver.current.packageConfigMap != null) {
+    return uri.toString();
+  }
+
+  // If we're using a package root, we resolve the symlinks in the test code so
+  // we need to resolve them here as well to ensure we're testing against the
+  // same values.
+  var resolved = new Directory(p.fromUri(uri)).resolveSymbolicLinksSync();
+  return ensureTrailingSlash(p.toUri(resolved)).toString();
+}
 
 Future _spawn(String expression, PackageResolver packageResolver) async {
   var data = new UriData.fromString("""
     import 'dart:convert';
     import 'dart:isolate';
 
     import 'package:package_resolver/package_resolver.dart';
 
     main(_, SendPort message) async {
       message.send(await ($expression));
@@ skipping 18 matching lines @@
     isolate.resume(isolate.pauseCapability);
 
     var value = await receivePort.first;
     isolate.kill();
     return value;
   } finally {
     errorPort.close();
     receivePort.close();
   }
 }