How to use fs - 10 common examples

var stat;
  var pid = process.pid;
  var mapFile = '/tmp/perf-' + pid + '.map';

  t.ok(fs.existsSync(mapFile), 'map file exists')

  stat = fs.statSync(mapFile);

  var firstSize = stat.size;
  // Linux flushes too aggressively 
  if (os.platform() === 'darwin') 
    t.equal(firstSize, 0, 'and on darwin its size is 0 since it has not been flushed yet')

  flushAll();

  stat = fs.statSync(mapFile);
  // The below by itself is not really a proof since just calling 'flushAll' causes more JIT code to be generated which by 
  // itself would increase the map file size.
  // However since Linux flushes more aggressively this is as good as we can do there.
  // On darwin, we can show that before flushAll nothing got flushed and afterwards it did which is the 
  // actual proof that this works.
  t.ok(stat.size > firstSize, 'after I flush all, the map file size is larger than before and non-zero since has been flushed')

  console.log('size before flushAll()', firstSize);
  console.log('size after  flushAll()', stat.size);
  t.end()
})

function verifyPkg (t) {
    const pkgFile = path.join(workdir, 'package.json')

    readFile(pkgFile, function (err, data) {
      t.error(err)
      const pkg = JSON.parse(data)
      t.equal(pkg.name, 'workdir')
      t.equal(pkg.version, '1.0.0')
      t.equal(pkg.description, '')
      t.equal(pkg.author, '')
      // by default this will be ISC but since we have a MIT licensed pkg file in upper dir, npm will set the license to MIT in this case
      // so for local tests we need to accept MIT as well
      t.ok(pkg.license === 'ISC' || pkg.license === 'MIT')
      t.equal(pkg.scripts.test, 'tap test/**/*.test.js')
      t.equal(pkg.scripts.start, 'fastify start -l info app.js')
      t.equal(pkg.scripts.dev, 'fastify start -l info -P app.js')
      t.equal(pkg.dependencies['fastify-cli'], '^' + cliPkg.version)
      t.equal(pkg.dependencies['fastify'], cliPkg.dependencies.fastify)
      t.equal(pkg.dependencies['fastify-plugin'], cliPkg.devDependencies['fastify-plugin'] || cliPkg.dependencies['fastify-plugin'])
      t.equal(pkg.dependencies['fastify-autoload'], cliPkg.devDependencies['fastify-autoload'])

fs.readdirSync(path).forEach(function(first) { // database

        var database = path + first;
        assert.equal(fs.statSync(database).isDirectory(), true);
        var metadata = '';
        var collections = fs.readdirSync(database);
        if (fs.existsSync(database + '/.metadata') === true) {
          metadata = database + '/.metadata/';
          delete collections[collections.indexOf('.metadata')]; // undefined is not a dir
        }
        collections.forEach(function(second) { // collection

          var collection = database + '/' + second;
          if (fs.statSync(collection).isDirectory() === false) {
            return;
          }
          fs.readdirSync(collection).forEach(function(third) { // document

            var document = collection + '/' + third;
            if (next !== undefined) {

return (async () => {

      const deleteAction = Mebo.Action.create('file.delete');
      deleteAction.input('file').setValue(filePath);

      await deleteAction.run();

      // in case the file delete has worked, the stats will throw an exception when
      // querying it from a file that does not exist
      try{
        fs.lstatSync(filePath);
      }
      catch(err){
        return true;
      }

      return false;

    })();
  });

function assertEncryptedFile(path, callback) {
  try {
    // Openssl encrypted files start with Salted
    const expectedBytes = Buffer.from('Salted');
    const buffer = Buffer.alloc(6);
    const fd = fs.openSync(path, 'r');
    // Read the first six bytes
    fs.readSync(fd, buffer, 0, 6, 0);
    fs.closeSync(fd);
    // Assert first 6 characters of the file are "Salted"
    assert.deepStrictEqual(buffer, expectedBytes, 'The backup file should be encrypted.');
    callback();
  } catch (err) {
    callback(err);
  }
}

assert.equal(fs.existsSync(root), true);
    assert.equal(fs.mkdirSync(sub1), undefined);
    assert.equal(fs.mkdirSync(sub2), undefined);
    assert.equal(fs.existsSync(sub1), true);
    assert.equal(fs.existsSync(sub2), true);

    unlink(sub1);
    unlink(sub2);

    fs.rmdir(root, function() {
      assert.equal(fs.existsSync(root), false);
    });

    var root2 = testRoot + '/test_dir2';

    fs.mkdir(root2, 777, function(err) {
      assert.equal(err, null);
      assert.equal(fs.existsSync(root2), true);

      fs.rmdir(root2, function() {
        assert.equal(fs.existsSync(root2), false);
      });

      // Run read-only directory test only on linux
      // NuttX does not support read-only attribute.
      if (process.platform === 'linux') {
        // Try to create a folder in a read-only directory.
        fs.mkdir(root, '0444', function(err) {
          assert.equal(fs.existsSync(root), true);

          var dirname = root + '/permission_test';
          try {

if (dev) {
    minor = String(parseInt(minor) + 1);
}

// Generate the version file contents.
var contents =
    "# DO NOT EDIT!  NPM AUTOMATICALLY WRITES THIS FILE!\nversion_info = (" +
    major + ", " +
    minor + ", " +
    patch +
    (dev ? ", 'dev'" : "") +
    ")\n__version__ = '.'.join(map(str, version_info))\n";

// Write the contents to the file.
var fs = require("fs");
fs.writeFile("_version.py", contents, function(err) {
    if(err) {
        console.error("Could not write the Python version file", err);
        process.exit(1);
    } else {
        console.log("Python version " + major + "." + minor + "." + patch + (dev ? "dev" : "") + " written");
    }
});

/* eslint-disable no-console */

const base64Img = require('base64-img');
const fs = require('fs');
const path = require('path');
const mkdirp = require('mkdirp');

const iconsSrcDir = path.join(__dirname, 'src', 'icons');
const iconsLibDir = path.join(__dirname, 'lib', 'icons');

mkdirp.sync(iconsLibDir);

fs.readdir(path.join(__dirname, 'src', 'icons'), (err, files) => {
  if (err) {
    console.error(err);
    process.exit(1);
  }
  for (const file of files) {
    base64Img.base64(path.join(iconsSrcDir, file), (err, data) => {
      if (err) {
        console.error(err);
        process.exit(1);
      }
      fs.writeFile(
        path.join(iconsLibDir, file + '.js'),
        `module.exports='${data}'`,
        err => {
          if (err) {
            console.error(err);

exports.initialize = function(app, id, options) {
  var certificate = null;

  // Read SAML certificate if it exists
  if (options.certificate) {
    if (FS.existsSync(options.certificate))
      certificate = FS.readFileSync(options.certificate).toString('ascii');
    else
      console.log('WARN Certificate ' + options.certificate + ' does not exist!');
  }

  var params = Util._extend({}, options.params);
  options.login = Path.join('/provider', id, 'login');
  options.callback = params.path = Path.join('/provider', id, 'callback');
  params.cert = certificate;
  params.passReqToCallback = true;

  Passport.use(id, new SAML(params, function(req, profile, done) {
    if (!profile.nameID)
      return done(new Error('No identity found in SAML callback payload!'), false);

    Model.Provider.findOrCreate({

isSymlink = fileStat.isSymbolicLink(),
                        isDir = fileStat.isDirectory()

                    if (isDir || (isSymlink && drillDownSymlinks)) {
                        await reco.replaceWwwRootDir(filePath)
                    } else {
                        await unlinkAsync(filePath)
                    }
                }
            }

            if (!removeContentOnly)
                await rmdirAsync(dirPath);


            if (!fs.existsSync('cordova/www')) {
                var ncp = require('ncp').ncp;

                ncp.limit = 9999999999999;

                ncp("./react/build", "./cordova/www", function (err) {
                    if (err) {
                        return console.error(err);
                    }
                    reco.state.callBack_replaceWwwRootDir(); // callBack();
                });
            }

        },