this.connectTimeoutSeconds = connectTimeoutSeconds;
    }

    @Override
    public WorkerProcessBuilder setBaseName(String baseName) {
        this.baseName = baseName;
        return this;
    }

    @Override
    public String getBaseName() {
        return baseName;
    }

    @Override
    public WorkerProcessBuilder applicationClasspath(Iterable<File> files) {
        for (File file : files) {

        if (parameters.externalClasspath.contains(primaryInputFile)) {       // <6>
            outputs.file(primaryInput)
        } else {
            val baseName = primaryInputFile.name.substring(0, primaryInputFile.name.length - 4)
            relocateJar(outputs.file("$baseName-relocated.jar"))
        }
    }

    private fun relocateJar(output: File) {
        // implementation...

				FileName:           cert.BaseName,
				CAName:             ca.Name,
				CABaseName:         ca.BaseName, // Nb. this is a path for etcd certs (they are stored in a subfolder)
				readwriter:         pkiReadWriter,
				certConfigMutators: certConfigMutators,
			}
		}

		pkiReadWriter := newPKICertificateReadWriter(rm.cfg.CertificatesDir, ca.BaseName)
		rm.cas[ca.Name] = &CAExpirationHandler{

    public DefaultScriptFileResolver() {
        this.scriptFileResolvedListener = null;
    }

    @Override
    public File resolveScriptFile(File dir, String basename) {
        for (String extension : EXTENSIONS) {
            File candidate = new File(dir, basename + extension);
            if (isCandidateFile(candidate)) {
                return candidate;
            }
        }
        return null;
    }

     *
     * @param dir the directory in which to search
     * @param basename the base name of the script file, i.e. its file name excluding the extension
     * @return the resolved script file present on disk, or {@literal null} if none were found
     */
    @Nullable
    File resolveScriptFile(File dir, String basename);

    /**
     * Searches for script files in the given directory, that is, any file with a known

  std::string pass_name = pass->getName().str();
  std::string filename =
      get_filename_(pass_prefix_ + "before_" + pass_name, op);

  if (ShouldPrint(pass, op)) DumpMlir(filename, print_callback);
}

void DataDumperLoggerConfig::printAfterIfEnabled(
    mlir::Pass *pass, mlir::Operation *op, PrintCallbackFn print_callback) {
  std::string pass_name = pass->getName().str();

        // Classes with $ may be inner classes
        int innerClassIdx = className.indexOf("$");
        if (innerClassIdx > 0) {
            String baseName = className.substring(0, innerClassIdx);
            fileExtensions.stream()
                .map(fileExtension -> classNameToRelativePath(baseName, fileExtension))
                .forEach(paths::add);
        }

        return paths;
    }

    @Override

def get_full_name(first_name: str, last_name: str):
    full_name = first_name.title() + " " + last_name.title()
    return full_name

        }

        if (name.contains(".")) {
            return name;
        }

        for (String importedClass : classMetaData.getImports()) {
            String baseName = StringUtils.substringAfterLast(importedClass, ".");
            if (baseName.equals("*")) {
                candidateClassName = StringUtils.substringBeforeLast(importedClass, ".") + "." + name;
                if (metaDataRepository.find(candidateClassName) != null) {

        singleProjectBuild(name) {
            pluginProjectBuild(delegate)
        }
    }

    def pluginProjectBuild(BuildTestFile testFile) {
        def baseName = testFile.name.capitalize()
        def className = baseName + "Impl"
        testFile.with {
            it.buildFile << """
apply plugin: 'java-gradle-plugin'

gradlePlugin {
    plugins {
        ${it.name} {