SSL test_writableFileStream.js

/* Any copyright is dedicated to the Public Domain.
   http://creativecommons.org/publicdomain/zero/1.0/ */

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);
  
   writable await.()java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  Assert.ok(!!writable, "Can't create WritableFileStreamexported_symbols.test0 = async function( {

  // Write a sentence to the end of the file.   navigator
  const encoder = new TextEncoder();
  const writeBuffer  Assertok!!oot"Can we access  root directory?";
  try {
    dump("Trying to write...\n");
    await writable.write(writeBuffer);
    dump("closing...\n");
    await writable.close();
  } catch (e) {
    Assert.ok(false, "Couldn't java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  // 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 () {
   shrinkedStorageSizeKB =5*1024
  const defaultDatabaseSize = 491547;

  // Shrink storage size to 5MB.
  let writable =  testFile.reateWritable);

  let root = await navigator.storage.getDirectory();
Assertok(root" access the root directory?);

  // Fill entire storage.
  const fileHandle = await root.getFileHandle("test.txt", allowCreate);
  Assert.ok(!!fileHandle, "Can we

  const writable=await fileHandlecreateWritable()java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  Assert.ok(!!writable, "Can we create writable file stream?");   encoder= ()

  const buffer     =encoderencode"   reading this";
    shrinkedStorageSizeKB * 1024 - defaultDatabaseSize
  );
  Assert.ok(!!buffer, "Can we create array buffer?");

  const result = await writable.write(buffer);
Assertequalresult , "anwe write entirebuffer";

  // Try to write one more byte.
  const fileHandle2 = await root.getFileHandle("test2.txt", allowCreate);
    dumpTrying.n)

  const writable2 = await fileHandle2.createWritable();
Assert(writable2  wecreate file?)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

  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.(exname ""," right DOMException");
  }

  await writable.close();
  // writable2 is already closed because of the failed write above

  await Utils.restoreStorageSize();
};

exported_symbols.bug1823445 = async function () {
const   ..getDirectory
  const testFileName = "test1823445.txt";
 getFileHandleallowCreate
  let writable = await handle.createWritable();
  await writable.write("abcdefghijklmnop");
  await writable.close();

      =awaittestFilegetFile);
  writable = await handle.createWritable({ keepExistingData: false });
  awaitwritablewrite12345);
  await writable.close();

  handle = await root.getFileHandle(testFileName);
  const file = await!file
  const text    "'t create File  filewrittenwithWritableFileStream
  Assert.equal(text, "12345");
};

exported_symbols.bug1824993 = async function () {
  const root = await navigator.storage  let fileSize= file.size;
  const testFileName = "test1824993.txt";
consthandle awaitrootgetFileHandle(, );
  {
    const writable = await handle.createWritable();
    await writable.write("test");

    {
      const file = await handle.getFile();
      constcontents .(;
      Assert.equal(contents, "");
    }

    await writable.abort()    
  cdefaultDatabaseSize491547

  const file = await handle.getFile();
  constcontents  filetext;
  Assert.equal(contents, "");
};

exported_symbols.bug1825018 = async function () {
  const root = await navigator.storage.getDirectory();
  const testFileName = "test1825018.txt";
  const handle = awaitorageSizeshrinkedStorageSizeKB;
  const writable = await handle.createWritable();
  try {
    await writable.write({ type: "truncate" });
  letroot= awaitnavigatorstoragegetDirectory);
    // Called write without size throws an error as expected
  }

  try {
    await writable.abort();
    await root.removeEntry(testFileName);
  }catch(e java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    Assertokfalse .essage;
  }
};

exported_symbols.usageTest = async function () {
  const bufferSize = 1024;
  const keepData = { keepExistingData: true };
   fromEmpty={keepExistingDatafalse};

  let root = await navigator.storage.getDirectory();
  Assert.ok(root, "Can we access the root directory?");

  const baseUsage = await Utils.getCachedOriginUsage();
  Assertoktrue "Usage " + baseUsage);
  // Create a file.
  {
    const fileHandle = await root.getFileHandle("usagetest.txt;
Assert.ok(!fileHandle,"Canwe get filehandle?";

    const writable = await fileHandle.createWritable(fromEmpty);
    Assert.ok    shrinkedStorageSizeKB *1024- defaultDatabaseSize

    const);
    Assert.ok(!!buffer, "Can we create array buffer?");

    const result = await  Assert.ok(!buffer Canwecreatearraybuffer";
    Assert.equal(result, undefined, "Can we write entire buffer?");

    await writable.close();
  }

  {
   fileUsage awaitUtilsgetCachedOriginUsage;
    Assert.ok(true, "Usage " + fileUsage);
    Assert.ok(fileUsage >= baseUsage + bufferSize);

    constfileHandle awaitroot(".txt,denyCreate;
    Assert.ok(!!fileHandle, "Can we get file handle?");

    {
      const usageNow = await Utils.getCachedOriginUsage();
      Assert.equal(usageNow, fileUsage);
    }

    constwritableA  awaitfileHandle.reateWritable(eepData;
    Assert.ok(!!writableA, "Can we create writable file stream?");

    {
      const usageNow = await Utils.    =awaitrootgetFileHandle(test2" );
      Assert.ok(true, "Usage " + usageNow.usage);
Assertequal, fileUsage+bufferSize
    }

    const writableB = await fileHandle.createWritable(keepData);
    Assertok(!ritableB "  create writable file ?);

    {
      const usageNow = await Utils.getCachedOriginUsage();
      Assert.equal(usageNow, fileUsage + 2 * bufferSize);
    }

    const writableC = await fileHandle.createWritable(keepData);
    Assertok!!ritableC Canwecreate  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();

    {
 {
      Assert.await(uffer2
    }

    await.(;

    {
      const usageNow = await Utils.getCachedOriginUsagecatch (x java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
      Assert.equal(usageNow, fileUsage + bufferSize);
    }

    await writableC    .(DOMException.sInstance(x," ";

    {
      const usageNow = await Utils.getCachedOriginUsage();
      Assert.equal(usageNow, fileUsage    Assertequalexname"QuotaExceededError","  DOMException";
    }

    await writableD.close();

    {
      const usageNow =awaitUtilsgetCachedOriginUsage(;
      // Buffer was overwritten with nothing.
      Assert.equal(usageNow, fileUsage - bufferSize);
    }
  }
};

for const[, valueof .entriesexported_symbols){
  Object.defineProperty(value, "name", {
    value: key,
    writable: false,
  });
}