1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
// A special path component meaning "this directory."
const kCurrentDirectory = '.';
// A special path component meaning "the parent directory."
const kParentDirectory = '..';
// Array of separators used to separate components in hierarchical paths.
let kPathSeparators;
if (navigator.userAgent.includes('Windows NT')) {
// Windows uses both '/' and '\' as path separators.
kPathSeparators = ['/', '\\'];
} else {
kPathSeparators = ['/'];
}
async function getFileSize(handle) {
const file = await handle.getFile();
return file.size;
}
async function getFileContents(handle) {
const file = await handle.getFile();
return new Response(file).text();
}
async function getDirectoryEntryCount(handle) {
let result = 0;
for await (let entry of handle) {
result++;
}
return result;
}
async function getSortedDirectoryEntries(handle) {
let result = [];
for await (let entry of handle.values()) {
if (entry.kind === 'directory') {
result.push(entry.name + '/');
} else {
result.push(entry.name);
}
}
result.sort();
return result;
}
async function createDirectory(test, name, parent) {
const new_dir_handle = await parent.getDirectoryHandle(name, {create: true});
cleanup(test, new_dir_handle, async () => {
try {
await parent.removeEntry(name, {recursive: true});
} catch (e) {
// Ignore any errors when removing directories, as tests might
// have already removed the directory.
}
});
return new_dir_handle;
}
async function createEmptyFile(test, name, parent) {
const handle = await parent.getFileHandle(name, {create: true});
cleanup(test, handle, async () => {
try {
await parent.removeEntry(name);
} catch (e) {
// Ignore any errors when removing files, as tests might already remove
// the file.
}
});
// Make sure the file is empty.
assert_equals(await getFileSize(handle), 0);
return handle;
}
async function createFileWithContents(test, name, contents, parent) {
const handle = await createEmptyFile(test, name, parent);
const writer = await handle.createWritable();
await writer.write(new Blob([contents]));
await writer.close();
return handle;
}
var fs_cleanups = [];
async function cleanup(test, value, cleanup_func) {
if (fs_cleanups.length === 0) {
// register to get called back once from cleanup
test.add_cleanup(async () => {
// Cleanup in LIFO order to ensure locks are released correctly relative
// to thinks like removeEntry(). Do so in a serialized form, not in parallel!
fs_cleanups.reverse();
for (let cleanup of fs_cleanups) {
try {
await cleanup();
} catch (e) {
// Ignore any errors when removing files, as tests might already remove
// the file.
}
}
fs_cleanups.length = 0;
});
}
fs_cleanups.push(cleanup_func);
return value;
}
async function cleanup_writable(test, value) {
return cleanup(test, value, async () => {
try {
return (await value).close();
} catch (e) {
// Ignore any errors when closing writables, since attempting to close
// aborted or closed writables will error.
}
});
}
|
