Remove more references to FileBasedSource

pkg/analyzer/test/generated/source_factory_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 analyzer.test.generated.test.generated.source_factory;
 
 import 'dart:convert';
 
 import 'package:analyzer/file_system/file_system.dart';
-import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisEngine, Logger;
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
-import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart' as utils;
+import 'package:analyzer/src/source/source_resource.dart';
 import 'package:package_config/packages.dart';
 import 'package:package_config/packages_file.dart' as pkgfile show parse;
 import 'package:package_config/src/packages_impl.dart';
 import 'package:path/path.dart';
 import 'package:unittest/unittest.dart';
 
 import '../reflective_tests.dart';
 import '../utils.dart';
 import 'test_support.dart';
 
 main() {
   initializeTestEnvironment();
   runReflectiveTests(SourceFactoryTest);
   runPackageMapTests();
 }
 
 Source createSource({String path, String uri}) =>
     //TODO(pquitslund): find some way to pass an actual URI into source creation
     new MemoryResourceProvider()
         .getFile(path)
         .createSource(uri != null ? Uri.parse(uri) : null);
 
 void runPackageMapTests() {
+  MemoryResourceProvider resourceProvider = new MemoryResourceProvider();
   final Uri baseUri = new Uri.file('test/base');
   final List<UriResolver> testResolvers = [
-    new ResourceUriResolver(PhysicalResourceProvider.INSTANCE)
+    new ResourceUriResolver(resourceProvider)
   ];
 
   Packages createPackageMap(Uri base, String configFileContents) {
     List<int> bytes = UTF8.encode(configFileContents);
     Map<String, Uri> map = pkgfile.parse(bytes, base);
     return new MapPackages(map);
   }
 
   Map<String, List<Folder>> getPackageMap(String config) {
     Packages packages = createPackageMap(baseUri, config);
@@ skipping 109 matching lines @@
         });
       });
       group('restoreUri', () {
         test('URI in mapping', () {
           Uri uri = restorePackageUri(
               config: '''
 unittest:/home/somebody/.pub/cache/unittest-0.9.9/lib/
 async:/home/somebody/.pub/cache/async-1.1.0/lib/
 quiver:/home/somebody/.pub/cache/quiver-1.2.1/lib
 ''',
-              source: new FileBasedSource(FileUtilities2.createFile(
+              source: new FileSource(resourceProvider.getFile(
                   '/home/somebody/.pub/cache/unittest-0.9.9/lib/unittest.dart')));
           expect(uri, isNotNull);
           expect(uri.toString(), equals('package:unittest/unittest.dart'));
         });
       });
       group('packageMap', () {
         test('non-file URIs filtered', () {
           Map<String, List<Folder>> map = getPackageMap('''
 quiver:/home/somebody/.pub/cache/quiver-1.2.1/lib
 foo:http://www.google.com
@@ skipping 14 matching lines @@
         expect(utils.startsWith(Uri.parse('/foo/bar'), Uri.parse('/foo/b')),
             isFalse);
         // Handle odd URIs (https://github.com/dart-lang/sdk/issues/24126)
         expect(utils.startsWith(Uri.parse('/foo/bar'), Uri.parse('')), isFalse);
         expect(utils.startsWith(Uri.parse(''), Uri.parse('/foo/bar')), isFalse);
       });
     });
   });
 }
 
+class AbsoluteUriResolver extends UriResolver {
+  final MemoryResourceProvider resourceProvider;
+
+  AbsoluteUriResolver(this.resourceProvider);
+
+  @override
+  Source resolveAbsolute(Uri uri, [Uri actualUri]) {
+    return new FileSource(
+        resourceProvider.getFile(resourceProvider.pathContext.fromUri(uri)),
+        actualUri);
+  }
+}
+
 class CustomUriResolver extends UriResolver {
   String uriPath;
   CustomUriResolver({this.uriPath});
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) =>
       createSource(path: uriPath);
 }
 
 @reflectiveTest
 class SourceFactoryTest {
+  MemoryResourceProvider resourceProvider = new MemoryResourceProvider();
+
   void test_creation() {
     expect(new SourceFactory([]), isNotNull);
   }
 
   void test_fromEncoding_invalidUri() {
     SourceFactory factory = new SourceFactory([]);
     expect(() => factory.fromEncoding("<:&%>"),
         throwsA(new isInstanceOf<IllegalArgumentException>()));
   }
 
@@ skipping 12 matching lines @@
 
   void test_resolveUri_absolute() {
     UriResolver_absolute resolver = new UriResolver_absolute();
     SourceFactory factory = new SourceFactory([resolver]);
     factory.resolveUri(null, "dart:core");
     expect(resolver.invoked, isTrue);
   }
 
   void test_resolveUri_nonAbsolute_absolute() {
     SourceFactory factory =
-        new SourceFactory([new UriResolver_nonAbsolute_absolute()]);
+        new SourceFactory([new AbsoluteUriResolver(resourceProvider)]);
     String absolutePath = "/does/not/matter.dart";
     Source containingSource =
-        new FileBasedSource(FileUtilities2.createFile("/does/not/exist.dart"));
+        new FileSource(resourceProvider.getFile("/does/not/exist.dart"));
     Source result = factory.resolveUri(containingSource, absolutePath);
     expect(result.fullName,
         FileUtilities2.createFile(absolutePath).getAbsolutePath());
   }
 
   void test_resolveUri_nonAbsolute_relative() {
     SourceFactory factory =
-        new SourceFactory([new UriResolver_nonAbsolute_relative()]);
+        new SourceFactory([new AbsoluteUriResolver(resourceProvider)]);
     Source containingSource =
-        new FileBasedSource(FileUtilities2.createFile("/does/not/have.dart"));
+        new FileSource(resourceProvider.getFile("/does/not/have.dart"));
     Source result = factory.resolveUri(containingSource, "exist.dart");
     expect(result.fullName,
         FileUtilities2.createFile("/does/not/exist.dart").getAbsolutePath());
   }
 
   void test_resolveUri_nonAbsolute_relative_package() {
     MemoryResourceProvider provider = new MemoryResourceProvider();
     Context context = provider.pathContext;
     String packagePath =
         context.joinAll([context.separator, 'path', 'to', 'package']);
@@ skipping 15 matching lines @@
     Source librarySource =
         firstFile.createSource(Uri.parse('package:package/dir/first.dart'));
 
     Source result = factory.resolveUri(librarySource, 'second.dart');
     expect(result, isNotNull);
     expect(result.fullName, secondPath);
     expect(result.uri.toString(), 'package:package/dir/second.dart');
   }
 
   void test_restoreUri() {
-    JavaFile file1 = FileUtilities2.createFile("/some/file1.dart");
-    JavaFile file2 = FileUtilities2.createFile("/some/file2.dart");
-    Source source1 = new FileBasedSource(file1);
-    Source source2 = new FileBasedSource(file2);
+    File file1 = resourceProvider.getFile("/some/file1.dart");
+    File file2 = resourceProvider.getFile("/some/file2.dart");
+    Source source1 = new FileSource(file1);
+    Source source2 = new FileSource(file2);
     Uri expected1 = parseUriWithException("file:///my_file.dart");
     SourceFactory factory =
         new SourceFactory([new UriResolver_restoreUri(source1, expected1)]);
     expect(factory.restoreUri(source1), same(expected1));
     expect(factory.restoreUri(source2), same(null));
   }
 }
 
 class UriResolver_absolute extends UriResolver {
   bool invoked = false;
 
   UriResolver_absolute();
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) {
     invoked = true;
     return null;
   }
 }
 
-class UriResolver_nonAbsolute_absolute extends UriResolver {
-  @override
-  Source resolveAbsolute(Uri uri, [Uri actualUri]) {
-    return new FileBasedSource(new JavaFile.fromUri(uri), actualUri);
-  }
-}
-
-class UriResolver_nonAbsolute_relative extends UriResolver {
-  @override
-  Source resolveAbsolute(Uri uri, [Uri actualUri]) {
-    return new FileBasedSource(new JavaFile.fromUri(uri), actualUri);
-  }
-}
-
 class UriResolver_restoreUri extends UriResolver {
   Source source1;
   Uri expected1;
   UriResolver_restoreUri(this.source1, this.expected1);
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) => null;
 
   @override
   Uri restoreAbsolute(Source source) {
@@ skipping 10 matching lines @@
   UriResolver_SourceFactoryTest_test_fromEncoding_valid(this.encoding);
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) {
     if (uri.toString() == encoding) {
       return new TestSource();
     }
     return null;
   }
 }