| // 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.source.embedder_test; |
| |
| import 'dart:core' hide Resource; |
| |
| import 'package:analyzer/file_system/file_system.dart'; |
| import 'package:analyzer/file_system/memory_file_system.dart'; |
| import 'package:analyzer/source/embedder.dart'; |
| import 'package:analyzer/src/generated/source.dart'; |
| import 'package:analyzer/src/util/absolute_path.dart'; |
| import 'package:path/path.dart' as path; |
| import 'package:unittest/unittest.dart'; |
| |
| import '../utils.dart'; |
| |
| main() { |
| group('EmbedderUriResolverTest', () { |
| setUp(() { |
| initializeTestEnvironment(path.context); |
| buildResourceProvider(); |
| }); |
| tearDown(() { |
| initializeTestEnvironment(); |
| clearResourceProvider(); |
| }); |
| test('test_NullEmbedderYamls', () { |
| var resolver = new EmbedderUriResolver(null); |
| expect(resolver.length, equals(0)); |
| }); |
| test('test_NoEmbedderYamls', () { |
| var locator = new EmbedderYamlLocator({ |
| 'fox': [pathTranslator.getResource('/empty')] |
| }); |
| expect(locator.embedderYamls.length, equals(0)); |
| }); |
| test('test_EmbedderYaml', () { |
| var locator = new EmbedderYamlLocator({ |
| 'fox': [pathTranslator.getResource('/tmp')] |
| }); |
| var resolver = new EmbedderUriResolver(locator.embedderYamls); |
| |
| expectResolved(dartUri, posixPath) { |
| Source source = resolver.resolveAbsolute(Uri.parse(dartUri)); |
| expect(source, isNotNull, reason: dartUri); |
| expect(source.fullName, posixToOSPath(posixPath)); |
| } |
| |
| // We have four mappings. |
| expect(resolver.length, equals(4)); |
| // Check that they map to the correct paths. |
| expectResolved('dart:fox', '/tmp/slippy.dart'); |
| expectResolved('dart:bear', '/tmp/grizzly.dart'); |
| expectResolved('dart:relative', '/relative.dart'); |
| expectResolved('dart:deep', '/tmp/deep/directory/file.dart'); |
| }); |
| test('test_BadYAML', () { |
| var locator = new EmbedderYamlLocator(null); |
| locator.addEmbedderYaml(null, r'''{{{,{{}}},}}'''); |
| expect(locator.embedderYamls.length, equals(0)); |
| }); |
| test('test_restoreAbsolute', () { |
| var locator = new EmbedderYamlLocator({ |
| 'fox': [pathTranslator.getResource('/tmp')] |
| }); |
| var resolver = new EmbedderUriResolver(locator.embedderYamls); |
| |
| expectRestore(String dartUri, [String expected]) { |
| var parsedUri = Uri.parse(dartUri); |
| var source = resolver.resolveAbsolute(parsedUri); |
| expect(source, isNotNull); |
| // Restore source's uri. |
| var restoreUri = resolver.restoreAbsolute(source); |
| expect(restoreUri, isNotNull, reason: dartUri); |
| // Verify that it is 'dart:fox'. |
| expect(restoreUri.toString(), equals(expected ?? dartUri)); |
| List<String> split = (expected ?? dartUri).split(':'); |
| expect(restoreUri.scheme, equals(split[0])); |
| expect(restoreUri.path, equals(split[1])); |
| } |
| |
| expectRestore('dart:deep'); |
| expectRestore('dart:deep/file.dart', 'dart:deep'); |
| expectRestore('dart:deep/part.dart'); |
| expectRestore('dart:deep/deep/file.dart'); |
| }); |
| |
| test('test_EmbedderSdk_fromFileUri', () { |
| var locator = new EmbedderYamlLocator({ |
| 'fox': [pathTranslator.getResource('/tmp')] |
| }); |
| var resolver = new EmbedderUriResolver(locator.embedderYamls); |
| var sdk = resolver.dartSdk; |
| |
| expectSource(String posixPath, String dartUri) { |
| var uri = Uri.parse(posixToOSFileUri(posixPath)); |
| var source = sdk.fromFileUri(uri); |
| expect(source, isNotNull, reason: posixPath); |
| expect(source.uri.toString(), dartUri); |
| expect(source.fullName, posixToOSPath(posixPath)); |
| } |
| |
| expectSource('/tmp/slippy.dart', 'dart:fox'); |
| expectSource('/tmp/deep/directory/file.dart', 'dart:deep'); |
| expectSource('/tmp/deep/directory/part.dart', 'dart:deep/part.dart'); |
| }); |
| test('test_EmbedderSdk_getSdkLibrary', () { |
| var locator = new EmbedderYamlLocator({ |
| 'fox': [pathTranslator.getResource('/tmp')] |
| }); |
| var resolver = new EmbedderUriResolver(locator.embedderYamls); |
| var sdk = resolver.dartSdk; |
| var lib = sdk.getSdkLibrary('dart:fox'); |
| expect(lib, isNotNull); |
| expect(lib.path, posixToOSPath('/tmp/slippy.dart')); |
| expect(lib.shortName, 'fox'); |
| }); |
| test('test_EmbedderSdk_mapDartUri', () { |
| var locator = new EmbedderYamlLocator({ |
| 'fox': [pathTranslator.getResource('/tmp')] |
| }); |
| var resolver = new EmbedderUriResolver(locator.embedderYamls); |
| var sdk = resolver.dartSdk; |
| |
| expectSource(String dartUri, String posixPath) { |
| var source = sdk.mapDartUri(dartUri); |
| expect(source, isNotNull, reason: posixPath); |
| expect(source.uri.toString(), dartUri); |
| expect(source.fullName, posixToOSPath(posixPath)); |
| } |
| |
| expectSource('dart:fox', '/tmp/slippy.dart'); |
| expectSource('dart:deep', '/tmp/deep/directory/file.dart'); |
| expectSource('dart:deep/part.dart', '/tmp/deep/directory/part.dart'); |
| }); |
| }); |
| } |
| |
| ResourceProvider resourceProvider; |
| TestPathTranslator pathTranslator; |
| |
| buildResourceProvider() { |
| var rawProvider = new MemoryResourceProvider(isWindows: isWindows); |
| resourceProvider = new TestResourceProvider(rawProvider); |
| pathTranslator = new TestPathTranslator(rawProvider) |
| ..newFolder('/empty') |
| ..newFolder('/tmp') |
| ..newFile( |
| '/tmp/_embedder.yaml', |
| r''' |
| embedded_libs: |
| "dart:fox": "slippy.dart" |
| "dart:bear": "grizzly.dart" |
| "dart:relative": "../relative.dart" |
| "dart:deep": "deep/directory/file.dart" |
| "fart:loudly": "nomatter.dart" |
| '''); |
| } |
| |
| clearResourceProvider() { |
| resourceProvider = null; |
| pathTranslator = null; |
| } |
| |
| // TODO(danrubel) if this approach works well for running tests |
| // in a platform specific way, then move all of the following functionality |
| // into a separate test utility library. |
| |
| bool get isWindows => path.Style.platform == path.Style.windows; |
| |
| /** |
| * Assert that the given path is posix. |
| */ |
| void expectAbsolutePosixPath(String posixPath) { |
| expect(posixPath, startsWith('/'), |
| reason: 'Expected absolute posix path, but found $posixPath'); |
| } |
| |
| /** |
| * Translate the given posixPath to a path appropriate for the |
| * platform on which the tests are executing. |
| */ |
| String posixToOSPath(String posixPath) { |
| expectAbsolutePosixPath(posixPath); |
| if (isWindows) { |
| String windowsPath = posixPath.replaceAll('/', '\\'); |
| if (posixPath.startsWith('/')) { |
| return 'C:$windowsPath'; |
| } |
| return windowsPath; |
| } |
| return posixPath; |
| } |
| |
| /** |
| * Translate the given posixPath to a file URI appropriate for the |
| * platform on which the tests are executing. |
| */ |
| String posixToOSFileUri(String posixPath) { |
| expectAbsolutePosixPath(posixPath); |
| return isWindows ? 'file:///C:$posixPath' : 'file://$posixPath'; |
| } |
| |
| /** |
| * A convenience utility for setting up a test [MemoryResourceProvider]. |
| * All supplied paths are assumed to be in [path.posix] format |
| * and are automatically translated to [path.context]. |
| * |
| * This class intentionally does not implement [ResourceProvider] |
| * directly or indirectly so that it cannot be used as a resource provider. |
| * We do not want functionality under test to interact with a resource provider |
| * that automatically translates paths. |
| */ |
| class TestPathTranslator { |
| final MemoryResourceProvider _provider; |
| |
| TestPathTranslator(this._provider); |
| |
| Resource getResource(String posixPath) => |
| _provider.getResource(posixToOSPath(posixPath)); |
| |
| File newFile(String posixPath, String content) => |
| _provider.newFile(posixToOSPath(posixPath), content); |
| |
| Folder newFolder(String posixPath) => |
| _provider.newFolder(posixToOSPath(posixPath)); |
| } |
| |
| /** |
| * A resource provider for testing that asserts that any supplied paths |
| * are appropriate for the OS platform on which the tests are running. |
| */ |
| class TestResourceProvider implements ResourceProvider { |
| final ResourceProvider _provider; |
| |
| TestResourceProvider(this._provider) { |
| expect(_provider.absolutePathContext.separator, isWindows ? '\\' : '/'); |
| } |
| |
| @override |
| AbsolutePathContext get absolutePathContext => _provider.absolutePathContext; |
| |
| @override |
| File getFile(String path) => _provider.getFile(_assertPath(path)); |
| |
| @override |
| Folder getFolder(String path) => _provider.getFolder(_assertPath(path)); |
| |
| @override |
| Resource getResource(String path) => _provider.getResource(_assertPath(path)); |
| |
| @override |
| Folder getStateLocation(String pluginId) => |
| _provider.getStateLocation(pluginId); |
| |
| @override |
| path.Context get pathContext => _provider.pathContext; |
| |
| /** |
| * Assert that the given path is valid for the OS platform on which the |
| * tests are running. |
| */ |
| String _assertPath(String path) { |
| if (isWindows) { |
| if (path.contains('/')) { |
| fail('Expected windows path, but found: $path'); |
| } |
| } else { |
| if (path.contains('\\')) { |
| fail('Expected posix path, but found: $path'); |
| } |
| } |
| return path; |
| } |
| } |