Get more tests passing on windows

pkg/analyzer/test/src/summary/bazel_summary_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 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/context/cache.dart';
@@ skipping 15 matching lines @@
 
 import '../context/abstract_context.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(BazelResultProviderTest);
     defineReflectiveTests(SummaryProviderTest);
   });
 }
 
-const OUT_ROOT = '$SRC_ROOT/bazel-bin';
-const SRC_ROOT = '/company/src/user/project/root';
-
 @reflectiveTest
 class BazelResultProviderTest extends _BaseTest {
   BazelResultProvider provider;
 
   @override
   void setUp() {
     super.setUp();
     provider = new BazelResultProvider(new SummaryProvider(
         resourceProvider,
         '_.temp',
         _getOutputFolder,
-        resourceProvider.getFolder('/tmp/dart/bazel/linked'),
+        resourceProvider
+            .getFolder(resourceProvider.convertPath('/tmp/dart/bazel/linked')),
         context));
   }
 
   test_failure_inconsistent_directDependency() {
     _setComponentFile('aaa', 'a.dart', 'class A {}');
     _setComponentFile(
         'bbb',
         'b.dart',
         r'''
 import 'package:components.aaa/a.dart';
@@ skipping 385 matching lines @@
       context.declaredVariables.define('dart.library.html', 'true');
       _createManager(allowLinking: true);
       List<Package> packages = manager.getLinkedPackages(source);
       expect(packages, hasLength(1));
       _assertDependencyInUser(packages.single.linked, 'foo_html.dart');
     }
   }
 }
 
 class _BaseTest extends AbstractContextTest {
+  String sourceRoot;
+  String outRoot;
+
   @override
   void setUp() {
     super.setUp();
     // Include a 'package' URI resolver.
+    sourceRoot = resourceProvider.convertPath('/company/src/user/project/root');
+    outRoot = resourceProvider.pathContext.join(sourceRoot, 'bazel-bin');
     sourceFactory = new SourceFactory(<UriResolver>[
       sdkResolver,
       resourceResolver,
-      new _TestPackageResolver(resourceProvider)
+      new _TestPackageResolver(resourceProvider, sourceRoot)
     ], null, resourceProvider);
     context.sourceFactory = sourceFactory;
   }
 
   Folder _getOutputFolder(Uri absoluteUri) {
+    var pathContext = resourceProvider.pathContext;
     if (absoluteUri.scheme == 'package') {
       List<String> segments = absoluteUri.pathSegments;
       if (segments.isNotEmpty) {
         String packageName = segments.first;
-        String path = OUT_ROOT + '/' + packageName.replaceAll('.', '/');
+        String path = pathContext.join(
+            outRoot, packageName.replaceAll('.', pathContext.separator));
         return resourceProvider.getFolder(path);
       }
     }
     return null;
   }
 
   Source _resolveUri(String uri) {
     return context.sourceFactory.resolveUri(null, uri);
   }
 
   File _setComponentFile(String componentName, String fileName, String code) {
-    String path = '$SRC_ROOT/components/$componentName/lib/$fileName';
+    String path = resourceProvider.pathContext
+        .join(sourceRoot, 'components', componentName, 'lib', fileName);
     return resourceProvider.newFile(path, code);
   }
 
   void _writeUnlinkedBundle(String packageName) {
-    String packagePath = packageName.replaceAll('.', '/');
+    var pathContext = resourceProvider.pathContext;
+    String packagePath = packageName.replaceAll('.', pathContext.separator);
     PackageBundleBuilder unlinkedBundle = _computeUnlinkedBundle(
         resourceProvider,
         packageName,
-        resourceProvider.getFolder(SRC_ROOT + '/' + packagePath + '/lib'),
+        resourceProvider
+            .getFolder(pathContext.join(sourceRoot, packagePath, 'lib')),
         true);
     String shortName = packageName.substring(packageName.lastIndexOf('.') + 1);
     resourceProvider.newFileWithBytes(
-        '$OUT_ROOT/$packagePath/$shortName.full.ds', unlinkedBundle.toBuffer());
+        pathContext.join(outRoot, packagePath, shortName) + '.full.ds',
+        unlinkedBundle.toBuffer());
   }
 
   static PackageBundleBuilder _computeUnlinkedBundle(ResourceProvider provider,
       String packageName, Folder libFolder, bool strong) {
     var pathContext = provider.pathContext;
     String libPath = libFolder.path + pathContext.separator;
     PackageBundleAssembler assembler = new PackageBundleAssembler();
 
     /**
      * Return the `package` [Uri] for the given [path] in the `lib` folder
@@ skipping 55 matching lines @@
     Parser parser = new Parser(source, errorListener);
     parser.parseGenericMethodComments = strong;
     CompilationUnit unit = parser.parseCompilationUnit(token);
     unit.lineInfo = lineInfo;
     return unit;
   }
 }
 
 class _TestPackageResolver implements UriResolver {
   final ResourceProvider resourceProvider;
+  final String sourceRoot;
 
-  _TestPackageResolver(this.resourceProvider);
+  _TestPackageResolver(this.resourceProvider, this.sourceRoot);
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) {
     if (uri.scheme == 'package') {
       List<String> segments = uri.pathSegments;
       if (segments.isNotEmpty) {
         pathos.Context pathContext = resourceProvider.pathContext;
         String packageName = segments.first;
         String folderPath = pathContext.join(
-            SRC_ROOT, packageName.replaceAll('.', pathContext.separator));
+            sourceRoot, packageName.replaceAll('.', pathContext.separator));
         String path = pathContext.join(
             folderPath, 'lib', pathContext.joinAll(segments.skip(1)));
         return resourceProvider.getFile(path).createSource(uri);
       }
     }
     return null;
   }
 
   @override
   Uri restoreAbsolute(Source source) {
     throw new UnimplementedError();
   }
 }