How to use the fs.mkdir function in fs

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 {

console.log("The file was saved!");
                    }
                });
            }
        });
    });
};

if(deleteExistingDownloadFolder)
{
    rimraf.sync(downloadSubDir);
}

if(!fs.existsSync(__dirname+"/"+downloadSubDir))
{
    fs.mkdir(__dirname +"/"+downloadSubDir);
}

const stream = fs.createReadStream('datasets/dryad_identifiers.json', {
    encoding: 'utf8'
});

parser = JSONStream.parse(['response', 'docs', true]);

stream.pipe(parser);

//parser.on('root', function (obj) {
//    console.log(obj); // whatever you will do with each JSON object
//});
//

parser.on('data', function (obj) {

// TODO delete archive from hyperdrive
      // TODO close swarm
      const dat = archives[link]
      delete archives[link]
      cb()
      dat.listStream.destroy()
      dat.close(function (err) {
        if (err) console.error(err)
        dat.db.close(function (err) {
          if (err) console.error(err)
        })
      })
    } else {
      if (archives[link]) return
      const path = `${root}/${link}`
      fs.mkdir(path, () => {
        const dat = args.createArchive(Object.assign({ key }, data.value))
        dat.open(err => {
          if (err) throw err // TODO

          // TODO add to dat-js https://github.com/joehand/dat-js/issues/30
          dat.listStream = dat.archive.list({ live: true })
          dat.listStream.on('data', entry => {
            if (entry.name !== 'dat.json') return
            collect(dat.archive.createFileReadStream('dat.json'), (err, raw) => {
              if (err) return
              let json
              try {
                json = JSON.parse(raw.toString())
              } catch (err) {
                console.error('failed to parse dat.json', err)
                return

// check if data/routes folder exists
		try {
			fs.statSync(routes_dir);
		} 
		catch (e) {
			fs.mkdir(routes_dir);	
			logger.log("info", "creating data/routes directory");
		}

		// check if data/routes folder exists
		try {
			fs.statSync(live_dir);
		} 
		catch (e) {
			fs.mkdir(live_dir);	
			logger.log("info", "creating data/routes/live directory");
		}
	}

lab.before(function (done) {
        fs.mkdir(buildDir, function () {
            var options = {
                main: __dirname + '/../fixtures/app/app.js',
                jsFileName: 'app',
                cssFileName: 'app',
                buildDirectory: buildDir,
                stylesheets: [
                    __dirname + '/../fixtures/stylesheets/style.css'
                ],
                libraries: [
                    __dirname + '/../fixtures/libraries/iife-no-semicolon.js',
                    __dirname + '/../fixtures/libraries/lib.js'
                ]
            };
            moonboots = new Moonboots(options);
            moonboots.on('ready', done);
        });

fs.readdir(path, (err, data) => {
      if (err) {
        fs.mkdir(path, (err, data) => {
          return err ? reject(`Couldn't create folder: ${path}`) : resolve();
        });
      } else {
        return resolve();
      }
    });
  });

await new Promise ((resolve, reject) => {
		mkdir (testingDir, (err) => {
			if (err) {
				reject (err)
				return
			}
			resolve ()
		})
	})
	chdir (testingDir)

fs.exists (path, function (flExists) {
						if (flExists) {
							doLevel (levelnum + 1);
							}
						else {
							fs.mkdir (path, undefined, function () {
								doLevel (levelnum + 1);
								});
							}
						});
					}

mkpath(path.dirname(dirpath), mode, function (err) {
                    if (err) {
                        callback(err);
                    } else {
                        fs.mkdir(dirpath, mode, function (err) {
                            if (!err || err.code == 'EEXIST') {
                                callback(null);
                            } else {
                                callback(err);
                            }
                        });
                    }
                });
            } else {

exec('rm -rf '+pre, function(err){
    if (err) {
      OE(err);
      return RP('3');
    }
    fs.mkdir(pre, function(err){
      if (err) {
        OE(err);
        return RP('3');
      }
      originImg.resize(250, 250, '!')
      .autoOrient()
      .write(pre+'/1.'+imgType, function(err){
        if (err) {
          OE(err);
          return RP('3');
        }
        originImg.resize(150, 150, '!')
        .autoOrient()
        .write(pre+'/2.'+imgType, function(err){
          if (err) {
            OE(err);