How to use the path.join function in path

test.each(testCases)("programmatic: %j", async testCase => {
    await bestzip(
      Object.assign(
        { destination, cwd: path.join(__dirname, "../", testCase.cwd) },
        testCase
      )
    );
    await unzip(destination, tmpdir);
    const structure = getStructure(tmpdir);

    expect(structure).toMatchSnapshot();

    if (testCase.structure) {
      expect(structure).toEqual(testCase.structure);
    } else {
      // the structure is defined in the first test run, so it may not be defined when running subsets of tests
      console.log("skipping structure match");
    }
  });

_.each(dirContents, function(val) {
                var ext = path.extname(val);
                var cssPath = path.join(dir, val);
                var stat = fs.lstatSync(cssPath);

                // skip if ignored by `ignore` config option
                if (this._ignorePath(cssPath)) {
                    return;
                }

                if (stat.isDirectory()) {
                    cssFiles = cssFiles.concat(this.read(cssPath));
                    return;
                }

                // skip if not a valid css extensions
                if (_.indexOf(this.opts.styleFileExt, ext) === -1) {
                    return;
                }

let gradle = fs.readFileSync(path.join(indir, 'app', 'build.gradle'), {encoding: 'utf8'});
		gradle = gradle.replace(/{package}/g, targetOptions.package);
		fs.writeFileSync(path.join(outdir, 'app', 'build.gradle'), gradle, {encoding: 'utf8'});

		let appiml = fs.readFileSync(path.join(indir, 'app', 'app.iml'), {encoding: 'utf8'});
		appiml = appiml.replace(/{name}/g, safename);
		fs.writeFileSync(path.join(outdir, 'app', 'app.iml'), appiml, {encoding: 'utf8'});

		fs.ensureDirSync(path.join(outdir, 'app', 'src'));
		//fs.emptyDirSync(path.join(outdir, 'app', 'src'));

		// fs.copySync(path.join(indir, 'main', 'AndroidManifest.xml'), path.join(outdir, 'app', 'src', 'main', 'AndroidManifest.xml'));
		let manifest = fs.readFileSync(path.join(indir, 'main', 'AndroidManifest.xml'), {encoding: 'utf8'});
		manifest = manifest.replace(/{package}/g, targetOptions.package);
		manifest = manifest.replace(/{screenOrientation}/g, targetOptions.screenOrientation);
		fs.ensureDirSync(path.join(outdir, 'app', 'src', 'main'));
		fs.writeFileSync(path.join(outdir, 'app', 'src', 'main', 'AndroidManifest.xml'), manifest, {encoding: 'utf8'});

		fs.ensureDirSync(path.join(outdir, 'app', 'src', 'main', 'res', 'values'));
		let strings = fs.readFileSync(path.join(indir, 'main', 'res', 'values', 'strings.xml'), {encoding: 'utf8'});
		strings = strings.replace(/{name}/g, name);
		fs.writeFileSync(path.join(outdir, 'app', 'src', 'main', 'res', 'values', 'strings.xml'), strings, {encoding: 'utf8'});

		fs.ensureDirSync(path.join(outdir, 'app', 'src', 'main', 'res', 'mipmap-hdpi'));
		exportImage(this.options.kha, findIcon(from, this.options), path.join(this.options.to, this.sysdir(), safename, 'app', 'src', 'main', 'res', 'mipmap-hdpi', "ic_launcher"), {width: 72, height: 72}, 'png', false);
		fs.ensureDirSync(path.join(outdir, 'app', 'src', 'main', 'res', 'mipmap-mdpi'));
		exportImage(this.options.kha, findIcon(from, this.options), path.join(this.options.to, this.sysdir(), safename, 'app', 'src', 'main', 'res', 'mipmap-mdpi', "ic_launcher"), {width: 48, height: 48}, 'png', false);
		fs.ensureDirSync(path.join(outdir, 'app', 'src', 'main', 'res', 'mipmap-xhdpi'));
		exportImage(this.options.kha, findIcon(from, this.options), path.join(this.options.to, this.sysdir(), safename, 'app', 'src', 'main', 'res', 'mipmap-xhdpi', "ic_launcher"), {width: 96, height: 96}, 'png', false);
		fs.ensureDirSync(path.join(outdir, 'app', 'src', 'main', 'res', 'mipmap-xxhdpi'));
		exportImage(this.options.kha, findIcon(from, this.options), path.join(this.options.to, this.sysdir(), safename, 'app', 'src', 'main', 'res', 'mipmap-xxhdpi', "ic_launcher"), {width: 144, height: 144}, 'png', false);

return asyncFs.copyFile(
      path.join(k0ContractsSrcDir, filename),
      path.join(contractsDir, filename)
    )
  }))

  await Promise.all(testContracts.map(name => {
    const filename = name + '.sol'
    return asyncFs.copyFile(
      path.join(testContractsSrcDir, filename),
      path.join(contractsDir, filename)
    )
  }))

  console.log(contractsDir)
  const outputPath = path.join(contractsDir, 'output.json')
  const command = [
    `solc --combined-json abi,bin openzeppelin-solidity=${ozDir}`,
    '*.sol > output.json'
  ].join(' ')
  const options = {
    cwd: contractsDir,
    maxBuffer: 1024 * 1024
  }
  const { stderr } = await execAsync(command, options)

  if (stderr) {
    console.log(stderr)
  }
  const json = await asyncFs.readTextFile(outputPath)
  await Promise.all(contractNames.map(name => {
    return asyncFs.unlink(path.join(contractsDir, `${name}.sol`))

'use strict';

//dependencies
var path = require('path');
var _ = require('lodash');
var nock = require('nock');
var faker = require('faker');
var url = require('url-querystring');
var expect = require('chai').expect;
var Transport = require(path.join(__dirname, '..', '..'));
var receivedSMS = require(path.join(__dirname, 'fixtures', 'received_sms.json'));

//TODO test for alternative flow
//TODO assert request urls

describe('Received SMS', function () {

  it('should have /sms/1/inbox/reports as default received sms url',
    function (done) {
      var transport = new Transport();

      expect(transport.receivedUrl).to.equal('/sms/1/inbox/reports');

      done();
    });

var http = require('http');
var express = require('express');
var logger = require('morgan');
var methodOverride = require('method-override');
var bodyParser = require('body-parser');
var multer = require('multer');
var errorHandler = require('errorhandler');
var path = require('path');

var routes = require('./../demo/server_routes');
var baseDir = path.join(__dirname, '..');

var app = express();
app.set('port', process.env.PORT || 3005);
app.use(logger('dev'));
app.use(methodOverride());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended : true}));
app.use(express.static(baseDir));
routes(app, baseDir);
app.use(errorHandler());

app.listen(app.get('port'), function () {
  console.log('Express server listening on port ' + app.get('port'))
});

function getInstallerConfig () {
  console.log('creating windows installer')
  const rootPath = path.join('./')
  const outPath = path.join(rootPath, 'release-builds')

  return Promise.resolve({
    appDirectory: path.join(outPath, 'LINESimulator-win32-x64/'),
    authors: 'Kenichiro Nakamura',
    noMsi: false,
    outputDirectory: path.join(outPath, 'windows-installer'),
    exe: 'LINESimulator.exe',
    setupExe: 'LINESimulatorInstaller.exe',
    setupIcon: path.join(rootPath, 'src', 'icons','favicon.ico')
  })
}

if (fs.existsSync(createPlanetActionRicardianContractDestination)) {
		throw new Error(`universe.createplanet_rc.md already exists in ${createPlanetActionRicardianContractDestination} directory. You've probably already initialized infeos for this project.`);
	}

	if (fs.existsSync(createStarActionRicardianContractDestination)) {
		throw new Error(`universe.createstar_rc.md already exists in ${createStarActionRicardianContractDestination} directory. You've probably already initialized infeos for this project.`);
	}

	const smartContractHeaderFileSource = path.join(libraryDirectory, '/smart_contracts/universe.hpp');
	const smartContractImplementationFileSource = path.join(libraryDirectory, '/smart_contracts/universe.cpp');
	const subSmartContractPlanetImplementationFileSource = path.join(libraryDirectory, '/smart_contracts/universe.planet.cpp');
	const subSmartContractStarImplementationFileSource = path.join(libraryDirectory, '/smart_contracts/universe.star.cpp');
	const typesContractHeaderFileSource = path.join(libraryDirectory, '/smart_contracts/types.hpp');

	const universeRicardianContractFileSource = path.join(libraryDirectory, '/ricardian_contracts/universe_rc.md');
	const addPlanetRicardianContractFileSource = path.join(libraryDirectory, '/ricardian_contracts/universe.addplanet_rc.md');
	const createPlanetRicardianContractFileSource = path.join(libraryDirectory, '/ricardian_contracts/universe.createplanet_rc.md');
	const createStarRicardianContractFileSource = path.join(libraryDirectory, '/ricardian_contracts/universe.createstar_rc.md');

	fs.copyFileSync(smartContractHeaderFileSource, smartContractHeaderDestination);
	fs.copyFileSync(smartContractImplementationFileSource, smartContractImplementationDestination);
	fs.copyFileSync(subSmartContractPlanetImplementationFileSource, subSmartContractPlanetImplementationDestination);
	fs.copyFileSync(subSmartContractStarImplementationFileSource, subSmartContractStarImplementationDestination);
	fs.copyFileSync(typesContractHeaderFileSource, typesContractHeaderDestination);

	fs.copyFileSync(universeRicardianContractFileSource, universeRicardianContractDestination);
	fs.copyFileSync(addPlanetRicardianContractFileSource, addPlanetActionRicardianContractDestination);
	fs.copyFileSync(createPlanetRicardianContractFileSource, createPlanetActionRicardianContractDestination);
	fs.copyFileSync(createStarRicardianContractFileSource, createStarActionRicardianContractDestination);

	/**

}, deferred.reject);
                        } else {
                            errCleanUp('Unexpected zipball configuration');
                        }
                    } catch (e) {
                        errCleanUp(e);
                    }
                }

                try {
                    //If the baseUrl does not exist, create it.
                    file.mkdirs(baseUrl);

                    //Get the package JSON data for dependency, if it is
                    //already on disk.
                    existingPath = path.join(baseUrl, archiveInfo.finalLocalName);
                    if (!path.existsSync(existingPath)) {
                        existingPath += '.js';
                        if (!path.existsSync(existingPath)) {
                            existingPath = null;
                        }
                    }

                    pkg = (existingPath && packageJson(existingPath)) || {};

                    if (existingPath && !namedArgs.force) {
                        return deferred.reject(existingPath + ' already exists. To ' +
                                'install anyway, pass -f to the command');
                    }

                } catch (e) {
                    errCleanUp(e);

getPath(): string {
    return path.join(this.scope.getPath(), SOURCES_MAP);
  }