mirror of
https://github.com/dart-lang/sdk
synced 2024-10-03 09:10:10 +00:00
c8595fdee2
Change-Id: I47741cb3dc5714f765d9b45698c2ae05dbf5349a Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/220322 Reviewed-by: Jens Johansen <jensj@google.com> Commit-Queue: Johnni Winther <johnniwinther@google.com>
275 lines
8.2 KiB
Dart
275 lines
8.2 KiB
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.
|
|
// SharedOptions=--supermixin
|
|
|
|
library front_end.test.standard_file_system_test;
|
|
|
|
import 'dart:convert';
|
|
import 'dart:io' as io;
|
|
import 'dart:math' show Random;
|
|
|
|
import 'package:front_end/src/api_prototype/file_system.dart';
|
|
import 'package:front_end/src/api_prototype/standard_file_system.dart';
|
|
import 'package:path/path.dart' as p;
|
|
import 'package:test/test.dart';
|
|
import 'package:test_reflective_loader/test_reflective_loader.dart';
|
|
|
|
void main() {
|
|
defineReflectiveSuite(() {
|
|
defineReflectiveTests(StandardFileSystemTest);
|
|
defineReflectiveTests(FileTest);
|
|
defineReflectiveTests(DirectoryTest);
|
|
defineReflectiveTests(DataTest);
|
|
});
|
|
}
|
|
|
|
final Matcher _throwsFileSystemException =
|
|
throwsA(const TypeMatcher<FileSystemException>());
|
|
|
|
@reflectiveTest
|
|
class DirectoryTest extends _BaseTest {
|
|
late String path;
|
|
late FileSystemEntity dir;
|
|
|
|
@override
|
|
void setUp() {
|
|
super.setUp();
|
|
path = p.join(tempPath, 'dir');
|
|
dir = StandardFileSystem.instance.entityForUri(p.toUri(path));
|
|
}
|
|
|
|
void test_equals_differentPaths() {
|
|
expect(dir == entityForPath(p.join(tempPath, 'dir2')), isFalse);
|
|
}
|
|
|
|
void test_equals_samePath() {
|
|
expect(dir == entityForPath(p.join(tempPath, 'dir')), isTrue);
|
|
}
|
|
|
|
Future<void> test_exists_directoryExists() async {
|
|
await new io.Directory(path).create();
|
|
expect(await dir.exists(), isTrue);
|
|
}
|
|
|
|
Future<void> test_exists_doesNotExist() async {
|
|
expect(await dir.exists(), isFalse);
|
|
}
|
|
|
|
Future<void> test_readAsBytes() async {
|
|
await new io.Directory(path).create();
|
|
await expectLater(dir.readAsBytes, _throwsFileSystemException);
|
|
}
|
|
|
|
void test_uri() {
|
|
expect(dir.uri, p.toUri(path));
|
|
}
|
|
}
|
|
|
|
@reflectiveTest
|
|
class FileTest extends _BaseTest {
|
|
late String path;
|
|
late FileSystemEntity file;
|
|
|
|
@override
|
|
void setUp() {
|
|
super.setUp();
|
|
path = p.join(tempPath, 'file.txt');
|
|
file = StandardFileSystem.instance.entityForUri(p.toUri(path));
|
|
}
|
|
|
|
void test_equals_differentPaths() {
|
|
expect(file == entityForPath(p.join(tempPath, 'file2.txt')), isFalse);
|
|
}
|
|
|
|
void test_equals_samePath() {
|
|
expect(file == entityForPath(p.join(tempPath, 'file.txt')), isTrue);
|
|
}
|
|
|
|
Future<void> test_exists_doesNotExist() async {
|
|
expect(await file.exists(), isFalse);
|
|
}
|
|
|
|
Future<void> test_exists_fileExists() async {
|
|
new io.File(path).writeAsStringSync('contents');
|
|
expect(await file.exists(), isTrue);
|
|
}
|
|
|
|
void test_hashCode_samePath() {
|
|
expect(file.hashCode, entityForPath(p.join(tempPath, 'file.txt')).hashCode);
|
|
}
|
|
|
|
Future<void> test_readAsBytes_badUtf8() async {
|
|
// A file containing invalid UTF-8 can still be read as raw bytes.
|
|
List<int> bytes = [0xc0, 0x40]; // Invalid UTF-8
|
|
new io.File(path).writeAsBytesSync(bytes);
|
|
expect(await file.readAsBytes(), bytes);
|
|
}
|
|
|
|
Future<void> test_readAsBytes_doesNotExist() async {
|
|
await expectLater(file.readAsBytes, _throwsFileSystemException);
|
|
}
|
|
|
|
Future<void> test_readAsBytes_exists() async {
|
|
var s = 'contents';
|
|
new io.File(path).writeAsStringSync(s);
|
|
expect(await file.readAsBytes(), utf8.encode(s));
|
|
}
|
|
|
|
Future<void> test_readAsString_badUtf8() async {
|
|
new io.File(path).writeAsBytesSync([0xc0, 0x40]); // Invalid UTF-8
|
|
await expectLater(file.readAsString, _throwsFileSystemException);
|
|
}
|
|
|
|
Future<void> test_readAsString_doesNotExist() async {
|
|
await expectLater(file.readAsString, _throwsFileSystemException);
|
|
}
|
|
|
|
Future<void> test_readAsString_exists() async {
|
|
var s = 'contents';
|
|
new io.File(path).writeAsStringSync(s);
|
|
expect(await file.readAsString(), s);
|
|
}
|
|
|
|
Future<void> test_readAsString_utf8() async {
|
|
var bytes = [0xe2, 0x82, 0xac]; // Unicode € symbol (in UTF-8)
|
|
new io.File(path).writeAsBytesSync(bytes);
|
|
expect(await file.readAsString(), '\u20ac');
|
|
}
|
|
|
|
void test_uri() {
|
|
expect(file.uri, p.toUri(path));
|
|
}
|
|
}
|
|
|
|
@reflectiveTest
|
|
class StandardFileSystemTest extends _BaseTest {
|
|
late Uri tempUri;
|
|
|
|
@override
|
|
void setUp() {
|
|
super.setUp();
|
|
tempUri = new Uri.directory(tempPath);
|
|
}
|
|
|
|
void test_entityForPath() {
|
|
var path = p.join(tempPath, 'file.txt');
|
|
expect(entityForPath(path).uri, p.toUri(path));
|
|
}
|
|
|
|
void test_entityForPath_absolutize() {
|
|
expect(entityForPath('file.txt').uri,
|
|
p.toUri(new io.File('file.txt').absolute.path));
|
|
}
|
|
|
|
void test_entityForPath_normalize_dot() {
|
|
expect(entityForPath(p.join(tempPath, '.', 'file.txt')).uri,
|
|
p.toUri(p.join(tempPath, 'file.txt')));
|
|
}
|
|
|
|
void test_entityForPath_normalize_dotDot() {
|
|
expect(entityForPath(p.join(tempPath, 'foo', '..', 'file.txt')).uri,
|
|
p.toUri(p.join(tempPath, 'file.txt')));
|
|
}
|
|
|
|
void test_entityForUri() {
|
|
expect(
|
|
StandardFileSystem.instance
|
|
.entityForUri(Uri.parse('${tempUri}file.txt'))
|
|
.uri,
|
|
p.toUri(p.join(tempPath, 'file.txt')));
|
|
}
|
|
|
|
void test_entityForUri_bareUri_absolute() {
|
|
expect(StandardFileSystem.instance.entityForUri(Uri.parse('/file.txt')).uri,
|
|
Uri.parse('file:///file.txt'));
|
|
}
|
|
|
|
void test_entityForUri_fileUri_relative() {
|
|
// A weird quirk of the Uri class is that it doesn't seem possible to create
|
|
// a `file:` uri with a relative path, no matter how many slashes you use or
|
|
// if you populate the fields directly. But just to be certain, try to do
|
|
// so, and make that `file:` uris with relative paths are rejected.
|
|
for (var uri in <Uri>[
|
|
new Uri(scheme: 'file', path: 'file.txt'),
|
|
Uri.parse('file:file.txt'),
|
|
Uri.parse('file:/file.txt'),
|
|
Uri.parse('file://file.txt'),
|
|
Uri.parse('file:///file.txt')
|
|
]) {
|
|
if (!uri.path.startsWith('/')) {
|
|
expect(() => StandardFileSystem.instance.entityForUri(uri),
|
|
throwsA(const TypeMatcher<Error>()));
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> test_entityForUri_nonFileUri() async {
|
|
await expectLater(
|
|
() => StandardFileSystem.instance
|
|
.entityForUri(Uri.parse('package:foo/bar.dart')),
|
|
_throwsFileSystemException);
|
|
}
|
|
|
|
void test_entityForUri_normalize_dot() {
|
|
expect(
|
|
StandardFileSystem.instance
|
|
.entityForUri(Uri.parse('${tempUri}./file.txt'))
|
|
.uri,
|
|
p.toUri(p.join(tempPath, 'file.txt')));
|
|
}
|
|
|
|
void test_entityForUri_normalize_dotDot() {
|
|
expect(
|
|
StandardFileSystem.instance
|
|
.entityForUri(Uri.parse('${tempUri}foo/../file.txt'))
|
|
.uri,
|
|
p.toUri(p.join(tempPath, 'file.txt')));
|
|
}
|
|
}
|
|
|
|
class _BaseTest {
|
|
late io.Directory tempDirectory;
|
|
late String tempPath;
|
|
|
|
FileSystemEntity entityForPath(String path) =>
|
|
StandardFileSystem.instance.entityForUri(p.toUri(path));
|
|
|
|
void setUp() {
|
|
tempDirectory = io.Directory.systemTemp.createTempSync('test_file_system');
|
|
tempPath = tempDirectory.absolute.path;
|
|
}
|
|
|
|
Future<void> tearDown() async {
|
|
try {
|
|
tempDirectory.deleteSync(recursive: true);
|
|
} on io.FileSystemException {
|
|
// Sometimes on Windows the delete fails with errno 32
|
|
// (ERROR_SHARING_VIOLATION: The process cannot access the file because it
|
|
// is being used by another process). Wait 1 second and try again.
|
|
await new Future.delayed(new Duration(seconds: 1));
|
|
tempDirectory.deleteSync(recursive: true);
|
|
}
|
|
}
|
|
}
|
|
|
|
@reflectiveTest
|
|
class DataTest {
|
|
Future<void> test_Data_URIs() async {
|
|
String string = "<{[DART]}>";
|
|
Uri string_uri = new Uri.dataFromString(string, base64: false);
|
|
Uri string_uri_base64 = new Uri.dataFromString(string, base64: true);
|
|
|
|
Random random = new Random(123);
|
|
List<int> bytes = new List.generate(1000, (index) => random.nextInt(256));
|
|
Uri bytes_uri = new Uri.dataFromBytes(bytes, percentEncoded: true);
|
|
Uri bytes_uri_base64 = new Uri.dataFromBytes(bytes, percentEncoded: false);
|
|
|
|
StandardFileSystem fs = StandardFileSystem.instance;
|
|
expect(string, await fs.entityForUri(string_uri).readAsString());
|
|
expect(string, await fs.entityForUri(string_uri_base64).readAsString());
|
|
expect(bytes, await fs.entityForUri(bytes_uri).readAsBytes());
|
|
expect(bytes, await fs.entityForUri(bytes_uri_base64).readAsBytes());
|
|
}
|
|
}
|