async generate(): Promise<ClimeCLITestCase[]> {
    let caseNames = await v.call(glob, '*/case-*/', {
      cwd: __dirname,
    });

    return caseNames
      .map(caseName => {
        if (!/-\d+\/$/.test(caseName)) {
          throw new Error(
            `Expecting numeric suffix for case name "${caseName}"`,
          );
        }

        let caseDir = Path.join(__dirname, caseName);
        let subcases = require(Path.join(caseDir, 'subcases'))
          .default as SubcaseDefinition[];

        return subcases.map(subcase => {
          return new ClimeCLITestCase(
            `${caseName}${subcase.name}`,
            [Path.join(caseDir, 'cli.js')].concat(subcase.args),
          );
        });
      })
      .reduce((result, cases) => result.concat(cases), []);
  }

  async exists(extensions?: string[]): Promise<boolean | string | undefined> {
    let extensionsSpecified = !!extensions;

    for (let extension of extensions || ['']) {
      let path = this.fullName + extension;
      let stats = await v.call(FS.stat, path).catch(v.bear);

      if (stats && stats.isFile()) {
        return extensionsSpecified ? path : true;
      }
    }

    return extensionsSpecified ? undefined : false;
  }

  async assert(exists = true): Promise<void> {
    let stats = await v.call(FS.stat, this.fullName).catch(v.bear);

    if (exists) {
      if (!stats) {
        throw new ExpectedError(`File "${this.source}" does not exist`);
      }

      if (!stats.isFile()) {
        throw new ExpectedError(
          `Object "${this.source}" is expected to be a file`,
        );
      }
    } else if (stats) {
      throw new ExpectedError(`Object "${this.source}" already exists`);
    }
  }

    async generate(): Promise<void> {
        let project = this.project;

        let { name, version } = project;

        let artifacts: ArtifactMetadataItem[] = [];

        let metadata: ArtifactMetadata = {
            name,
            version,
            artifacts
        };

        let defaultIdPlugin: Plugin | undefined;

        for (let plugin of project.plugins) {
            if (plugin.processArtifactMetadata) {
                await plugin.processArtifactMetadata(metadata);
            }

            if (plugin.getDefaultArtifactId) {
                defaultIdPlugin = plugin;
            }
        }

        for (let platform of project.platforms) {
            console.log();
            console.log(
                project.platformSpecified ?
                    `Generating artifact of project ${Style.id(name)} ${Style.dim(`(${platform.name})`)}...` :
                    `Generating artifact of project ${Style.id(name)}...`
            );
            console.log();

            let idTemplate = this.config.id || (
                defaultIdPlugin ?
                    await defaultIdPlugin.getDefaultArtifactId!(project.platformSpecified ? platform : undefined) :
                    (project.platformSpecified ? '{name}-{platform}' : '{name}')
            );

            let id = project.renderTemplate(idTemplate, {
                platform: project.platformSpecified ? platform.name : undefined
            });

            let archiver = Archiver.create('zip', {});

            let mappings = this
                .mappings
                .filter(mapping => !mapping.platformSet || mapping.platformSet.has(platform.name));

            await this.walk(mappings, platform, archiver);

            archiver.finalize();

            let path = Path.join(project.distDir, `${id}.zip`);

            let writeStream = FS.createWriteStream(path);

            archiver.pipe(writeStream);

            await awaitable(writeStream, 'close', [archiver]);

            console.log();
            console.log(`Artifact generated at path ${Style.path(path)}.`);

            artifacts.push({
                id,
                platform: project.platformSpecified ? platform.name : undefined,
                path: Path.relative(project.distDir, path)
            });
        }

        let metadataFilePath = Path.join(project.distDir, `${name}.json`);
        let metadataJSON = JSON.stringify(metadata, undefined, 4);

        await acall<void>(FS.writeFile, metadataFilePath, metadataJSON);

        console.log();
        console.log(`Artifact metadata generated at path ${Style.path(metadataFilePath)}.`);
    }

export async function safeStat(path: string): Promise<FS.Stats | undefined> {
  return v.call(FS.stat, path).catch(v.bear);
}

 async text(encoding = 'utf-8'): Promise<string> {
   await this.assert();
   return v.call<string>(FS.readFile, this.fullName, encoding);
 }

 async buffer(): Promise<Buffer> {
   await this.assert();
   return v.call<Buffer>(FS.readFile, this.fullName);
 }