Source code
Revision control
Copy as Markdown
Other Tools
/* Any copyright is dedicated to the Public Domain.
const allowCreate = { create: true };
const denyCreate = { create: false };
exported_symbols.test0 = async function () {
let root = await navigator.storage.getDirectory();
Assert.ok(!!root, "Can we access the root directory?");
const testFile = await root.getFileHandle("test.txt", allowCreate);
Assert.ok(!!testFile, "Can't access existing file");
let writable = await testFile.createWritable();
Assert.ok(!!writable, "Can't create WritableFileStream to existing file");
// Write a sentence to the end of the file.
const encoder = new TextEncoder();
const writeBuffer = encoder.encode("Thank you for reading this.");
try {
dump("Trying to write...\n");
await writable.write(writeBuffer);
dump("closing...\n");
await writable.close();
} catch (e) {
Assert.ok(false, "Couldn't write to WritableFileStream: " + e);
}
// Read it back
// Get size of the file.
let file = await testFile.getFile();
Assert.ok(
!!file,
"Can't create File to file written with WritableFileStream"
);
let fileSize = file.size;
Assert.ok(fileSize == writeBuffer.byteLength);
};
exported_symbols.quotaTest = async function () {
const shrinkedStorageSizeKB = 5 * 1024;
const defaultDatabaseSize = 491547;
// Shrink storage size to 5MB.
await Utils.shrinkStorageSize(shrinkedStorageSizeKB);
let root = await navigator.storage.getDirectory();
Assert.ok(root, "Can we access the root directory?");
// Fill entire storage.
const fileHandle = await root.getFileHandle("test.txt", allowCreate);
Assert.ok(!!fileHandle, "Can we get file handle?");
const writable = await fileHandle.createWritable();
Assert.ok(!!writable, "Can we create writable file stream?");
const buffer = new ArrayBuffer(
shrinkedStorageSizeKB * 1024 - defaultDatabaseSize
);
Assert.ok(!!buffer, "Can we create array buffer?");
const result = await writable.write(buffer);
Assert.equal(result, undefined, "Can we write entire buffer?");
// Try to write one more byte.
const fileHandle2 = await root.getFileHandle("test2.txt", allowCreate);
Assert.ok(!!fileHandle2, "Can we get file handle?");
const writable2 = await fileHandle2.createWritable();
Assert.ok(!!writable2, "Can we create writable file stream?");
const buffer2 = new ArrayBuffer(1);
Assert.ok(!!buffer2, "Can we create array buffer?");
try {
await writable2.write(buffer2);
Assert.ok(false, "Should have thrown");
} catch (ex) {
Assert.ok(true, "Did throw");
Assert.ok(DOMException.isInstance(ex), "Threw DOMException");
Assert.equal(ex.name, "QuotaExceededError", "Threw right DOMException");
}
await writable.close();
// writable2 is already closed because of the failed write above
await Utils.restoreStorageSize();
};
exported_symbols.bug1823445 = async function () {
const root = await navigator.storage.getDirectory();
const testFileName = "test1823445.txt";
let handle = await root.getFileHandle(testFileName, allowCreate);
let writable = await handle.createWritable();
await writable.write("abcdefghijklmnop");
await writable.close();
handle = await root.getFileHandle(testFileName);
writable = await handle.createWritable({ keepExistingData: false });
await writable.write("12345");
await writable.close();
handle = await root.getFileHandle(testFileName);
const file = await handle.getFile();
const text = await file.text();
Assert.equal(text, "12345");
};
exported_symbols.bug1824993 = async function () {
const root = await navigator.storage.getDirectory();
const testFileName = "test1824993.txt";
const handle = await root.getFileHandle(testFileName, allowCreate);
{
const writable = await handle.createWritable();
await writable.write("test");
{
const file = await handle.getFile();
const contents = await file.text();
Assert.equal(contents, "");
}
await writable.abort();
}
const file = await handle.getFile();
const contents = await file.text();
Assert.equal(contents, "");
};
exported_symbols.bug1825018 = async function () {
const root = await navigator.storage.getDirectory();
const testFileName = "test1825018.txt";
const handle = await root.getFileHandle(testFileName, allowCreate);
const writable = await handle.createWritable();
try {
await writable.write({ type: "truncate" });
} catch (e) {
// Called write without size throws an error as expected
}
try {
await writable.abort();
await root.removeEntry(testFileName);
} catch (e) {
Assert.ok(false, e.message);
}
};
exported_symbols.usageTest = async function () {
const bufferSize = 1024;
const keepData = { keepExistingData: true };
const fromEmpty = { keepExistingData: false };
let root = await navigator.storage.getDirectory();
Assert.ok(root, "Can we access the root directory?");
const baseUsage = await Utils.getCachedOriginUsage();
Assert.ok(true, "Usage " + baseUsage);
// Create a file.
{
const fileHandle = await root.getFileHandle("usagetest.txt", allowCreate);
Assert.ok(!!fileHandle, "Can we get file handle?");
const writable = await fileHandle.createWritable(fromEmpty);
Assert.ok(!!writable, "Can we create writable file stream?");
const buffer = new ArrayBuffer(bufferSize);
Assert.ok(!!buffer, "Can we create array buffer?");
const result = await writable.write(buffer);
Assert.equal(result, undefined, "Can we write entire buffer?");
await writable.close();
}
{
const fileUsage = await Utils.getCachedOriginUsage();
Assert.ok(true, "Usage " + fileUsage);
Assert.ok(fileUsage >= baseUsage + bufferSize);
const fileHandle = await root.getFileHandle("usagetest.txt", denyCreate);
Assert.ok(!!fileHandle, "Can we get file handle?");
{
const usageNow = await Utils.getCachedOriginUsage();
Assert.equal(usageNow, fileUsage);
}
const writableA = await fileHandle.createWritable(keepData);
Assert.ok(!!writableA, "Can we create writable file stream?");
{
const usageNow = await Utils.getCachedOriginUsage();
Assert.ok(true, "Usage " + usageNow.usage);
Assert.equal(usageNow, fileUsage + bufferSize);
}
const writableB = await fileHandle.createWritable(keepData);
Assert.ok(!!writableB, "Can we create writable file stream?");
{
const usageNow = await Utils.getCachedOriginUsage();
Assert.equal(usageNow, fileUsage + 2 * bufferSize);
}
const writableC = await fileHandle.createWritable(keepData);
Assert.ok(!!writableC, "Can we create writable file stream?");
{
const usageNow = await Utils.getCachedOriginUsage();
Assert.equal(usageNow, fileUsage + 3 * bufferSize);
}
const writableD = await fileHandle.createWritable(fromEmpty);
Assert.ok(!!writableD, "Can we create writable file stream?");
{
const usageNow = await Utils.getCachedOriginUsage();
// We did not keep existing data for this writable
Assert.equal(usageNow, fileUsage + 3 * bufferSize);
}
await writableA.abort();
{
const usageNow = await Utils.getCachedOriginUsage();
Assert.equal(usageNow, fileUsage + 2 * bufferSize);
}
await writableB.close();
{
const usageNow = await Utils.getCachedOriginUsage();
Assert.equal(usageNow, fileUsage + bufferSize);
}
await writableC.abort();
{
const usageNow = await Utils.getCachedOriginUsage();
Assert.equal(usageNow, fileUsage);
}
await writableD.close();
{
const usageNow = await Utils.getCachedOriginUsage();
// Buffer was overwritten with nothing.
Assert.equal(usageNow, fileUsage - bufferSize);
}
}
};
for (const [key, value] of Object.entries(exported_symbols)) {
Object.defineProperty(value, "name", {
value: key,
writable: false,
});
}