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

"use strict";

var {utils: Cu} = Components;

var SHARED_PATH;

var EXISTING_FILE = do_get_file("xpcshell.ini").path;

add_task(async function init() {
  do_get_profile();
  SHARED_PATH = OS.Path.join(OS.Constants.Path.profileDir, "test_osfile_read.tmp");
});


// Check that OS.File.read() is executed after the previous operation
add_test_pair(async function ordering() {
  let string1 = "Initial state " + Math.random();
  let string2 = "After writing " + Math.random();
  await OS.File.writeAtomic(SHARED_PATH, string1);
  OS.File.writeAtomic(SHARED_PATH, string2);
  let string3 = await OS.File.read(SHARED_PATH, { encoding: "utf-8" });
  Assert.equal(string3, string2);
});

add_test_pair(async function read_write_all() {
  let DEST_PATH = SHARED_PATH + Math.random();
  let TMP_PATH = DEST_PATH + ".tmp";

  let test_with_options = function(options, suffix) {
    return (async function() {
      info("Running test read_write_all with options " + JSON.stringify(options));
      let TEST = "read_write_all " + suffix;

      let optionsBackup = JSON.parse(JSON.stringify(options));

      // Check that read + writeAtomic performs a correct copy
      let currentDir = await OS.File.getCurrentDirectory();
      let pathSource = OS.Path.join(currentDir, EXISTING_FILE);
      let contents = await OS.File.read(pathSource);
      Assert.ok(!!contents); // Content is not empty
      let bytesRead = contents.byteLength;

      let bytesWritten = await OS.File.writeAtomic(DEST_PATH, contents, options);
      Assert.equal(bytesRead, bytesWritten); // Correct number of bytes written

      // Check that options are not altered
      Assert.equal(JSON.stringify(options), JSON.stringify(optionsBackup));
      await reference_compare_files(pathSource, DEST_PATH, TEST);

      // Check that temporary file was removed or never created exist
      Assert.ok(!new FileUtils.File(TMP_PATH).exists());

      // Check that writeAtomic fails if noOverwrite is true and the destination
      // file already exists!
      contents = new Uint8Array(300);
      let view = new Uint8Array(contents.buffer, 10, 200);
      try {
        let opt = JSON.parse(JSON.stringify(options));
        opt.noOverwrite = true;
        await OS.File.writeAtomic(DEST_PATH, view, opt);
        do_throw("With noOverwrite, writeAtomic should have refused to overwrite file (" + suffix + ")");
      } catch (err) {
        if (err instanceof OS.File.Error && err.becauseExists) {
          info("With noOverwrite, writeAtomic correctly failed (" + suffix + ")");
        } else {
          throw err;
        }
      }
      await reference_compare_files(pathSource, DEST_PATH, TEST);

      // Check that temporary file was removed or never created
      Assert.ok(!new FileUtils.File(TMP_PATH).exists());

      // Now write a subset
      let START = 10;
      let LENGTH = 100;
      contents = new Uint8Array(300);
      for (let i = 0; i < contents.byteLength; i++)
        contents[i] = i % 256;
      view = new Uint8Array(contents.buffer, START, LENGTH);
      bytesWritten = await OS.File.writeAtomic(DEST_PATH, view, options);
      Assert.equal(bytesWritten, LENGTH);

      let array2 = await OS.File.read(DEST_PATH);
      Assert.equal(LENGTH, array2.length);
      for (let j = 0; j < LENGTH; j++)
        Assert.equal(array2[j], (j + START) % 256);

      // Cleanup.
      await OS.File.remove(DEST_PATH);
      await OS.File.remove(TMP_PATH);
    })();
  };

  await test_with_options({tmpPath: TMP_PATH}, "Renaming, not flushing");
  await test_with_options({tmpPath: TMP_PATH, flush: true}, "Renaming, flushing");
  await test_with_options({}, "Not renaming, not flushing");
  await test_with_options({flush: true}, "Not renaming, flushing");
});
