Fix more tests on windows bots

pkg/analyzer/test/src/context/builder_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.src.context.context_builder_test;
 
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/plugin/options.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
@@ skipping 47 matching lines @@
    * The context builder to be used in the test.
    */
   ContextBuilder builder;
 
   /**
    * The path to the default SDK, or `null` if the test has not explicitly
    * invoked [createDefaultSdk].
    */
   String defaultSdkPath = null;
 
+  Uri convertedUri(String directoryPath) {

[scheglov, 2016/10/06 16:55:38]

The method name does not say anything about directory :-(

[Brian Wilkerson, 2016/10/06 17:14:55]

renamed

+//    return pathContext.toUri(resourceProvider.convertPath(directoryPath));

[scheglov, 2016/10/06 16:55:38]

Remove this line?

[Brian Wilkerson, 2016/10/06 17:14:55]

Done

+    return new Uri.directory(resourceProvider.convertPath(directoryPath),
+        windows: pathContext.style == path.windows.style);
+  }
+
   void createDefaultSdk(Folder sdkDir) {
     defaultSdkPath = pathContext.join(sdkDir.path, 'default', 'sdk');
     String librariesFilePath = pathContext.join(defaultSdkPath, 'lib',
         '_internal', 'sdk_library_metadata', 'lib', 'libraries.dart');
     resourceProvider.newFile(
         librariesFilePath,
         r'''
 const Map<String, LibraryInfo> libraries = const {
   "async": const LibraryInfo("async/async.dart"),
   "core": const LibraryInfo("core/core.dart"),
@@ skipping 28 matching lines @@
   void test_convertPackagesToMap_noPackages() {
     expect(builder.convertPackagesToMap(Packages.noPackages), isEmpty);
   }
 
   void test_convertPackagesToMap_null() {
     expect(builder.convertPackagesToMap(null), isEmpty);
   }
 
   void test_convertPackagesToMap_packages() {
     String fooName = 'foo';
-    String fooPath = '/pkg/foo';
-    Uri fooUri = new Uri.directory(fooPath);
+    String fooPath = resourceProvider.convertPath('/pkg/foo');
+    Uri fooUri = pathContext.toUri(fooPath);
     String barName = 'bar';
-    String barPath = '/pkg/bar';
-    Uri barUri = new Uri.directory(barPath);
+    String barPath = resourceProvider.convertPath('/pkg/bar');
+    Uri barUri = pathContext.toUri(barPath);
 
     MapPackages packages = new MapPackages({fooName: fooUri, barName: barUri});
     Map<String, List<Folder>> result = builder.convertPackagesToMap(packages);
     expect(result, isNotNull);
     expect(result, hasLength(2));
     expect(result[fooName], hasLength(1));
     expect(result[fooName][0].path, fooPath);
     expect(result[barName], hasLength(1));
     expect(result[barName][0].path, barPath);
   }
@@ skipping 13 matching lines @@
     _expectEqualOptions(options, defaultOptions);
   }
 
   void test_createDefaultOptions_noDefault() {
     AnalysisOptions options = builder.createDefaultOptions();
     _expectEqualOptions(options, new AnalysisOptionsImpl());
   }
 
   void test_createPackageMap_fromPackageDirectory_explicit() {
     // Use a package directory that is outside the project directory.
-    String rootPath = '/root';
+    String rootPath = resourceProvider.convertPath('/root');
     String projectPath = pathContext.join(rootPath, 'project');
     String packageDirPath = pathContext.join(rootPath, 'packages');
     String fooName = 'foo';
     String fooPath = pathContext.join(packageDirPath, fooName);
     String barName = 'bar';
     String barPath = pathContext.join(packageDirPath, barName);
     resourceProvider.newFolder(projectPath);
     resourceProvider.newFolder(fooPath);
     resourceProvider.newFolder(barPath);
 
     builder.defaultPackagesDirectoryPath = packageDirPath;
 
     Packages packages = builder.createPackageMap(projectPath);
     expect(packages, isNotNull);
     Map<String, Uri> map = packages.asMap();
     expect(map, hasLength(2));
-    expect(map[fooName], new Uri.directory(fooPath));
-    expect(map[barName], new Uri.directory(barPath));
+    expect(map[fooName], convertedUri(fooPath));
+    expect(map[barName], convertedUri(barPath));
   }
 
   void test_createPackageMap_fromPackageDirectory_inRoot() {
     // Use a package directory that is inside the project directory.
-    String projectPath = '/root/project';
+    String projectPath = resourceProvider.convertPath('/root/project');
     String packageDirPath = pathContext.join(projectPath, 'packages');
     String fooName = 'foo';
     String fooPath = pathContext.join(packageDirPath, fooName);
     String barName = 'bar';
     String barPath = pathContext.join(packageDirPath, barName);
     resourceProvider.newFolder(fooPath);
     resourceProvider.newFolder(barPath);
 
     Packages packages = builder.createPackageMap(projectPath);
     expect(packages, isNotNull);
     Map<String, Uri> map = packages.asMap();
     expect(map, hasLength(2));
-    expect(map[fooName], new Uri.directory(fooPath));
-    expect(map[barName], new Uri.directory(barPath));
+    expect(map[fooName], convertedUri(fooPath));
+    expect(map[barName], convertedUri(barPath));
   }
 
   void test_createPackageMap_fromPackageFile_explicit() {
     // Use a package file that is outside the project directory's hierarchy.
-    String rootPath = '/root';
+    String rootPath = resourceProvider.convertPath('/root');
     String projectPath = pathContext.join(rootPath, 'project');
     String packageFilePath = pathContext.join(rootPath, 'child', '.packages');
     resourceProvider.newFolder(projectPath);
+    Uri fooUri = convertedUri('/pkg/foo');
+    Uri barUri = convertedUri('/pkg/bar');
     createFile(
         packageFilePath,
-        r'''
-foo:/pkg/foo
-bar:/pkg/bar
+        '''
+foo:$fooUri
+bar:$barUri
 ''');
 
     builder.defaultPackageFilePath = packageFilePath;
     Packages packages = builder.createPackageMap(projectPath);
     expect(packages, isNotNull);
     Map<String, Uri> map = packages.asMap();
     expect(map, hasLength(2));
-    expect(map['foo'], new Uri.directory('/pkg/foo'));
-    expect(map['bar'], new Uri.directory('/pkg/bar'));
+    expect(map['foo'], fooUri);
+    expect(map['bar'], barUri);
   }
 
   void test_createPackageMap_fromPackageFile_inParentOfRoot() {
     // Use a package file that is inside the parent of the project directory.
-    String rootPath = '/root';
+    String rootPath = resourceProvider.convertPath('/root');
     String projectPath = pathContext.join(rootPath, 'project');
     String packageFilePath = pathContext.join(rootPath, '.packages');
     resourceProvider.newFolder(projectPath);
+    Uri fooUri = convertedUri('/pkg/foo');
+    Uri barUri = convertedUri('/pkg/bar');
     createFile(
         packageFilePath,
-        r'''
-foo:/pkg/foo
-bar:/pkg/bar
+        '''
+foo:$fooUri
+bar:$barUri
 ''');
 
     Packages packages = builder.createPackageMap(projectPath);
     expect(packages, isNotNull);
     Map<String, Uri> map = packages.asMap();
     expect(map, hasLength(2));
-    expect(map['foo'], new Uri.directory('/pkg/foo'));
-    expect(map['bar'], new Uri.directory('/pkg/bar'));
+    expect(map['foo'], fooUri);
+    expect(map['bar'], barUri);
   }
 
   void test_createPackageMap_fromPackageFile_inRoot() {
     // Use a package file that is inside the project directory.
-    String rootPath = '/root';
+    String rootPath = resourceProvider.convertPath('/root');
     String projectPath = pathContext.join(rootPath, 'project');
     String packageFilePath = pathContext.join(projectPath, '.packages');
     resourceProvider.newFolder(projectPath);
+    Uri fooUri = convertedUri('/pkg/foo');
+    Uri barUri = convertedUri('/pkg/bar');
     createFile(
         packageFilePath,
-        r'''
-foo:/pkg/foo
-bar:/pkg/bar
+        '''
+foo:$fooUri
+bar:$barUri
 ''');
 
     Packages packages = builder.createPackageMap(projectPath);
     expect(packages, isNotNull);
     Map<String, Uri> map = packages.asMap();
     expect(map, hasLength(2));
-    expect(map['foo'], new Uri.directory('/pkg/foo'));
-    expect(map['bar'], new Uri.directory('/pkg/bar'));
+    expect(map['foo'], fooUri);
+    expect(map['bar'], barUri);
   }
 
   void test_createPackageMap_none() {
-    String rootPath = '/root';
+    String rootPath = resourceProvider.convertPath('/root');
     Packages packages = builder.createPackageMap(rootPath);
     expect(packages, same(Packages.noPackages));
   }
 
   void test_createSourceFactory_fileProvider() {
-    String rootPath = '/root';
+    String rootPath = resourceProvider.convertPath('/root');
     Folder rootFolder = resourceProvider.getFolder(rootPath);
     createDefaultSdk(rootFolder);
     String projectPath = pathContext.join(rootPath, 'project');
     String packageFilePath = pathContext.join(projectPath, '.packages');
     String packageA = pathContext.join(rootPath, 'pkgs', 'a');
     String packageB = pathContext.join(rootPath, 'pkgs', 'b');
     createFile(
         packageFilePath,
         '''
 a:${pathContext.toUri(packageA)}
 b:${pathContext.toUri(packageB)}
 ''');
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     UriResolver resolver = new ResourceUriResolver(resourceProvider);
     builder.fileResolverProvider = (folder) => resolver;
     SourceFactoryImpl factory =
         builder.createSourceFactory(projectPath, options);
     expect(factory.resolvers, contains(same(resolver)));
   }
 
   void test_createSourceFactory_noProvider_packages_embedder_extensions() {
-    String rootPath = '/root';
+    String rootPath = resourceProvider.convertPath('/root');
     Folder rootFolder = resourceProvider.getFolder(rootPath);
     createDefaultSdk(rootFolder);
     String projectPath = pathContext.join(rootPath, 'project');
     String packageFilePath = pathContext.join(projectPath, '.packages');
     String packageA = pathContext.join(rootPath, 'pkgs', 'a');
     String embedderPath = pathContext.join(packageA, '_embedder.yaml');
     String packageB = pathContext.join(rootPath, 'pkgs', 'b');
     String extensionPath = pathContext.join(packageB, '_sdkext');
     createFile(
         packageFilePath,
@@ skipping 27 matching lines @@
     Source fooSource = factory.forUri('dart:foo');
     expect(fooSource, isNotNull);
     expect(fooSource.fullName, fooPath);
 
     Source packageSource = factory.forUri('package:b/b.dart');
     expect(packageSource, isNotNull);
     expect(packageSource.fullName, pathContext.join(packageB, 'b.dart'));
   }
 
   void test_createSourceFactory_noProvider_packages_embedder_noExtensions() {
-    String rootPath = '/root';
+    String rootPath = resourceProvider.convertPath('/root');
     Folder rootFolder = resourceProvider.getFolder(rootPath);
     createDefaultSdk(rootFolder);
     String projectPath = pathContext.join(rootPath, 'project');
     String packageFilePath = pathContext.join(projectPath, '.packages');
     String packageA = pathContext.join(rootPath, 'pkgs', 'a');
     String embedderPath = pathContext.join(packageA, '_embedder.yaml');
     String packageB = pathContext.join(rootPath, 'pkgs', 'b');
     createFile(
         packageFilePath,
         '''
@@ skipping 21 matching lines @@
     expect(packageSource, isNotNull);
     expect(packageSource.fullName, pathContext.join(packageB, 'b.dart'));
   }
 
   @failingTest
   void test_createSourceFactory_noProvider_packages_noEmbedder_extensions() {
     fail('Incomplete test');
   }
 
   void test_createSourceFactory_noProvider_packages_noEmbedder_noExtensions() {
-    String rootPath = '/root';
+    String rootPath = resourceProvider.convertPath('/root');
     Folder rootFolder = resourceProvider.getFolder(rootPath);
     createDefaultSdk(rootFolder);
     String projectPath = pathContext.join(rootPath, 'project');
     String packageFilePath = pathContext.join(projectPath, '.packages');
     String packageA = pathContext.join(rootPath, 'pkgs', 'a');
     String packageB = pathContext.join(rootPath, 'pkgs', 'b');
     createFile(
         packageFilePath,
         '''
 a:${pathContext.toUri(packageA)}
 b:${pathContext.toUri(packageB)}
 ''');
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
 
     SourceFactory factory = builder.createSourceFactory(projectPath, options);
 
     Source dartSource = factory.forUri('dart:core');
     expect(dartSource, isNotNull);
-    expect(dartSource.fullName, '$defaultSdkPath/lib/core/core.dart');
+    expect(dartSource.fullName,
+        pathContext.join(defaultSdkPath, 'lib', 'core', 'core.dart'));
 
     Source packageSource = factory.forUri('package:a/a.dart');
     expect(packageSource, isNotNull);
     expect(packageSource.fullName, pathContext.join(packageA, 'a.dart'));
   }
 
   void test_createSourceFactory_packageProvider() {
-    String rootPath = '/root';
+    String rootPath = resourceProvider.convertPath('/root');
     Folder rootFolder = resourceProvider.getFolder(rootPath);
     createDefaultSdk(rootFolder);
     String projectPath = pathContext.join(rootPath, 'project');
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     UriResolver resolver = new PackageMapUriResolver(resourceProvider, {});
     builder.packageResolverProvider = (folder) => resolver;
     SourceFactoryImpl factory =
         builder.createSourceFactory(projectPath, options);
     expect(factory.resolvers, contains(same(resolver)));
   }
@@ skipping 55 matching lines @@
     DartSdk sdk = builder.findSdk(null, new AnalysisOptionsImpl());
     expect(sdk, isNotNull);
   }
 
   void test_getAnalysisOptions_default_noOverrides() {
     AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
     defaultOptions.enableGenericMethods = true;
     builder.defaultOptions = defaultOptions;
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.enableGenericMethods = true;
-    String path = '/some/directory/path';
-    String filePath = '$path/${AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE}';
+    String path = resourceProvider.convertPath('/some/directory/path');
+    String filePath =
+        pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(
         filePath,
         '''
 linter:
   rules:
     - empty_constructor_bodies
 ''');
 
     AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
     AnalysisOptions options = builder.getAnalysisOptions(context, path);
     _expectEqualOptions(options, expected);
   }
 
   void test_getAnalysisOptions_default_overrides() {
     AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
     defaultOptions.enableGenericMethods = true;
     builder.defaultOptions = defaultOptions;
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.enableSuperMixins = true;
     expected.enableGenericMethods = true;
-    String path = '/some/directory/path';
-    String filePath = '$path/${AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE}';
+    String path = resourceProvider.convertPath('/some/directory/path');
+    String filePath =
+        pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(
         filePath,
         '''
 analyzer:
   language:
     enableSuperMixins : true
 ''');
 
     AnalysisEngine engine = AnalysisEngine.instance;
     OptionsPlugin plugin = engine.optionsPlugin;
     plugin.registerExtensionPoints((_) {});
     try {
       _TestOptionsProcessor processor = new _TestOptionsProcessor();
       processor.expectedOptions = <String, Object>{
         'analyzer': {
           'language': {'enableSuperMixins': true}
         }
       };
       (plugin.optionsProcessorExtensionPoint as ExtensionPointImpl)
           .add(processor);
       AnalysisContext context = engine.createAnalysisContext();
       AnalysisOptions options = builder.getAnalysisOptions(context, path);
       _expectEqualOptions(options, expected);
     } finally {
       plugin.registerExtensionPoints((_) {});
     }
   }
 
   void test_getAnalysisOptions_invalid() {
-    String path = '/some/directory/path';
-    String filePath = '$path/${AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE}';
+    String path = resourceProvider.convertPath('/some/directory/path');
+    String filePath =
+        pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(filePath, ';');
 
     AnalysisEngine engine = AnalysisEngine.instance;
     OptionsPlugin plugin = engine.optionsPlugin;
     plugin.registerExtensionPoints((_) {});
     try {
       _TestOptionsProcessor processor = new _TestOptionsProcessor();
       (plugin.optionsProcessorExtensionPoint as ExtensionPointImpl)
           .add(processor);
       AnalysisContext context = engine.createAnalysisContext();
       AnalysisOptions options = builder.getAnalysisOptions(context, path);
       expect(options, isNotNull);
       expect(processor.errorCount, 1);
     } finally {
       plugin.registerExtensionPoints((_) {});
     }
   }
 
   void test_getAnalysisOptions_noDefault_noOverrides() {
-    String path = '/some/directory/path';
-    String filePath = '$path/${AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE}';
+    String path = resourceProvider.convertPath('/some/directory/path');
+    String filePath =
+        pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(
         filePath,
         '''
 linter:
   rules:
     - empty_constructor_bodies
 ''');
 
     AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
     AnalysisOptions options = builder.getAnalysisOptions(context, path);
     _expectEqualOptions(options, new AnalysisOptionsImpl());
   }
 
   void test_getAnalysisOptions_noDefault_overrides() {
     AnalysisOptionsImpl expected = new AnalysisOptionsImpl();
     expected.enableSuperMixins = true;
-    String path = '/some/directory/path';
-    String filePath = '$path/${AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE}';
+    String path = resourceProvider.convertPath('/some/directory/path');
+    String filePath =
+        pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(
         filePath,
         '''
 analyzer:
   language:
     enableSuperMixins : true
 ''');
 
     AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
     AnalysisOptions options = builder.getAnalysisOptions(context, path);
     _expectEqualOptions(options, expected);
   }
 
   void test_getOptionsFile_explicit() {
-    String path = '/some/directory/path';
-    String filePath = '/options/analysis.yaml';
+    String path = resourceProvider.convertPath('/some/directory/path');
+    String filePath = resourceProvider.convertPath('/options/analysis.yaml');
     resourceProvider.newFile(filePath, '');
 
     builder.defaultAnalysisOptionsFilePath = filePath;
     File result = builder.getOptionsFile(path);
     expect(result, isNotNull);
     expect(result.path, filePath);
   }
 
   void test_getOptionsFile_inParentOfRoot_new() {
-    String parentPath = '/some/directory';
-    String path = '$parentPath/path';
+    String parentPath = resourceProvider.convertPath('/some/directory');
+    String path = pathContext.join(parentPath, 'path');
     String filePath =
-        '$parentPath/${AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE}';
+        pathContext.join(parentPath, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(filePath, '');
 
     File result = builder.getOptionsFile(path);
     expect(result, isNotNull);
     expect(result.path, filePath);
   }
 
   void test_getOptionsFile_inParentOfRoot_old() {
-    String parentPath = '/some/directory';
-    String path = '$parentPath/path';
-    String filePath = '$parentPath/${AnalysisEngine.ANALYSIS_OPTIONS_FILE}';
+    String parentPath = resourceProvider.convertPath('/some/directory');
+    String path = pathContext.join(parentPath, 'path');
+    String filePath =
+        pathContext.join(parentPath, AnalysisEngine.ANALYSIS_OPTIONS_FILE);
     resourceProvider.newFile(filePath, '');
 
     File result = builder.getOptionsFile(path);
     expect(result, isNotNull);
     expect(result.path, filePath);
   }
 
   void test_getOptionsFile_inRoot_new() {
-    String path = '/some/directory/path';
-    String filePath = '$path/${AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE}';
+    String path = resourceProvider.convertPath('/some/directory/path');
+    String filePath =
+        pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
     resourceProvider.newFile(filePath, '');
 
     File result = builder.getOptionsFile(path);
     expect(result, isNotNull);
     expect(result.path, filePath);
   }
 
   void test_getOptionsFile_inRoot_old() {
-    String path = '/some/directory/path';
-    String filePath = '$path/${AnalysisEngine.ANALYSIS_OPTIONS_FILE}';
+    String path = resourceProvider.convertPath('/some/directory/path');
+    String filePath =
+        pathContext.join(path, AnalysisEngine.ANALYSIS_OPTIONS_FILE);
     resourceProvider.newFile(filePath, '');
 
     File result = builder.getOptionsFile(path);
     expect(result, isNotNull);
     expect(result.path, filePath);
   }
 
   void _expectEqualOptions(
       AnalysisOptionsImpl actual, AnalysisOptionsImpl expected) {
     // TODO(brianwilkerson) Consider moving this to AnalysisOptionsImpl.==.
     expect(actual.analyzeFunctionBodiesPredicate,
         same(expected.analyzeFunctionBodiesPredicate));
-    expect(actual.cacheSize, expected.cacheSize);
     expect(actual.dart2jsHint, expected.dart2jsHint);
     expect(actual.enableAssertMessage, expected.enableAssertMessage);
     expect(actual.enableStrictCallChecks, expected.enableStrictCallChecks);
     expect(actual.enableGenericMethods, expected.enableGenericMethods);
     expect(actual.enableSuperMixins, expected.enableSuperMixins);
     expect(actual.enableTiming, expected.enableTiming);
     expect(actual.generateImplicitErrors, expected.generateImplicitErrors);
     expect(actual.generateSdkErrors, expected.generateSdkErrors);
     expect(actual.hint, expected.hint);
     expect(actual.incremental, expected.incremental);
@@ skipping 55 matching lines @@
       fail('Unexpected invocation of optionsProcessed');
     }
     expect(options, hasLength(expectedOptions.length));
     for (String key in expectedOptions.keys) {
       expect(options.containsKey(key), isTrue, reason: 'missing key $key');
       expect(options[key], expectedOptions[key],
           reason: 'values for key $key do not match');
     }
   }
 }