Source code
Revision control
Copy as Markdown
Other Tools
/**
* Any copyright is dedicated to the Public Domain.
*/
exported_symbols.smokeTest = async function smokeTest() {
const storage = navigator.storage;
const subdirectoryNames = new Set(["Documents", "Downloads", "Music"]);
const allowCreate = { create: true };
{
let root = await storage.getDirectory();
Assert.ok(root, "Can we access the root directory?");
let it = await root.values();
Assert.ok(!!it, "Does root have values iterator?");
let elem = await it.next();
Assert.ok(elem.done, "Is root directory empty?");
for (let dirName of subdirectoryNames) {
await root.getDirectoryHandle(dirName, allowCreate);
Assert.ok(true, "Was it possible to add subdirectory " + dirName + "?");
}
}
{
let root = await storage.getDirectory();
Assert.ok(root, "Can we refresh the root directory?");
let it = await root.values();
Assert.ok(!!it, "Does root have values iterator?");
let hasElements = false;
let hangGuard = 0;
for await (let [key, elem] of root.entries()) {
Assert.ok(elem, "Is element not non-empty?");
Assert.equal("directory", elem.kind, "Is found item a directory?");
Assert.ok(
elem.name.length >= 1 && elem.name.match("^[A-Za-z]{1,64}"),
"Are names of the elements strings?"
);
Assert.equal(key, elem.name);
Assert.ok(subdirectoryNames.has(elem.name), "Is name among known names?");
hasElements = true;
++hangGuard;
if (hangGuard == 10) {
break; // Exit if there is a hang
}
}
Assert.ok(hasElements, "Is values container now non-empty?");
Assert.equal(3, hangGuard, "Do we only have three elements?");
{
it = await root.values();
Assert.ok(!!it, "Does root have values iterator?");
let elem = await it.next();
await elem.value.getDirectoryHandle("Trash", allowCreate);
let subit = elem.value.values();
Assert.ok(!!elem, "Is element not non-empty?");
let subdirResult = await subit.next();
let subdir = subdirResult.value;
Assert.ok(!!subdir, "Is element not non-empty?");
Assert.equal("directory", subdir.kind, "Is found item a directory?");
Assert.equal("Trash", subdir.name, "Is found item a directory?");
}
const wipeEverything = { recursive: true };
for (let dirName of subdirectoryNames) {
await root.removeEntry(dirName, wipeEverything);
Assert.ok(
true,
"Was it possible to remove subdirectory " + dirName + "?"
);
}
}
{
let root = await storage.getDirectory();
Assert.ok(root, "Can we refresh the root directory?");
let it = root.values();
Assert.ok(!!it, "Does root have values iterator?");
let elem = await it.next();
Assert.ok(elem.done, "Is root directory empty?");
}
};
exported_symbols.quotaTest = async function () {
const storage = navigator.storage;
const allowCreate = { create: true };
{
let root = await storage.getDirectory();
Assert.ok(root, "Can we access the root directory?");
const fileHandle = await root.getFileHandle("test.txt", allowCreate);
Assert.ok(!!fileHandle, "Can we get file handle?");
const usageAtStart = await Utils.getCachedOriginUsage();
Assert.ok(true, "usageAtStart: " + usageAtStart);
const writable = await fileHandle.createWritable();
Assert.ok(!!writable, "Can we create writable file stream?");
const usageAtWritableCreated = await Utils.getCachedOriginUsage();
Assert.equal(
usageAtWritableCreated - usageAtStart,
0,
"Did usage increase when writable was created?"
);
const buffer = new ArrayBuffer(42);
Assert.ok(!!buffer, "Can we create array buffer?");
const result = await writable.write(buffer);
Assert.equal(result, undefined, "Can we write entire buffer?");
const usageAtWriteDone = await Utils.getCachedOriginUsage();
// Note: Usage should change only on close after 1824305
Assert.equal(
usageAtWriteDone - usageAtWritableCreated,
buffer.byteLength,
"Is write immediately reflected in usage?"
);
await writable.close();
const usageAtWritableClosed = await Utils.getCachedOriginUsage();
Assert.equal(
usageAtWritableClosed - usageAtWritableCreated,
buffer.byteLength,
"Did usage increase by the amount of bytes written?"
);
await root.removeEntry("test.txt");
const usageAtFileDeleted = await Utils.getCachedOriginUsage();
Assert.equal(
usageAtFileDeleted,
usageAtWritableCreated,
"Is usage back to the value before any writing when the file is removed?"
);
}
};
exported_symbols.pagedIterationTest = async function () {
const root = await navigator.storage.getDirectory();
for await (let contentItem of root.keys()) {
await root.removeEntry(contentItem, { recursive: true });
}
const allowCreate = { create: true };
// When half of the buffer is iterated, a request for the second half is sent.
// We test that the this boundary is crossed smoothly.
// After the buffer is filled, a request for more items is sent. The
// items are placed in the first half of the buffer.
// This boundary should also be crossed without problems.
// Currently, the buffer is half-filled at 1024.
const itemBatch = 3 + 2 * 1024;
for (let i = 0; i <= itemBatch; ++i) {
await root.getDirectoryHandle("" + i, allowCreate);
}
let result = 0;
let sum = 0;
const handles = new Set();
let isUnique = true;
for await (let [key, elem] of root.entries()) {
result += key.length;
sum += parseInt(elem.name);
if (handles.has(key)) {
// Asserting here is slow and verbose
isUnique = false;
break;
}
handles.add(key);
}
Assert.ok(isUnique);
Assert.equal(result, 7098);
Assert.equal(sum, (itemBatch * (itemBatch + 1)) / 2);
};
for (const [key, value] of Object.entries(exported_symbols)) {
Object.defineProperty(value, "name", {
value: key,
writable: false,
});
}