super.processWebInfLib();

        final WebResource[] possibleJars = listResources("/WEB-INF/plugin", false);

        for (final WebResource possibleJar : possibleJars) {
            if (possibleJar.isFile() && possibleJar.getName().endsWith(".jar")) {
                try (final JarFile jarFile = new JarFile(possibleJar.getCanonicalPath())) {
                    final Manifest manifest = jarFile.getManifest();

            Assume.assumeFalse(ExceptionUtils.getStackTrace(e).contains("Connection timed out"))
            throw e
        }

        then:
        install.home.isDirectory()
        install.mvn.isFile()
        install.version == mavenVersion
        MavenInstallation.probeVersion(install.home) == mavenVersion

        where:
        mavenVersion << ['3.3.9', '3.5.0']
    }

        }
        if (!directory.exists()) {
            throw new IllegalArgumentException("execDirectory doesn't exists!");
        }
        if (directory.isFile()) {
            throw new IllegalArgumentException("execDirectory is a file");
        }

        this.execDirectory = directory;
        return this;
    }

            def javadocFile = file("build/libs/${javaLibrary.artifactId}-${javaLibrary.version}${featurePostFix}-javadoc.jar")
            assert javadocFile.isFile()
            def javadocContents = new ZipTestFixture(javadocFile)
            javadocContents.assertContainsFile("${classNameForFeature(featureName)}.html")

    public PersistedToolchains build(File userToolchainsFile) throws MisconfiguredToolchainException {
        PersistedToolchains toolchains = null;

        if (userToolchainsFile != null && userToolchainsFile.isFile()) {
            try (InputStream in = Files.newInputStream(userToolchainsFile.toPath())) {
                toolchains = new PersistedToolchains(new MavenToolchainsStaxReader().read(in));
            } catch (Exception e) {

        if (!jarFile.exists()) {
            throw new IllegalArgumentException("jarFile doesn't exists! (" + jarFileAbsolutePath + ")");
        }
        if (!jarFile.isFile()) {
            throw new IllegalArgumentException("jarFile is not a file! (" + jarFileAbsolutePath + ")");
        }
        if (!hasExtension(jarFile, ".jar")) {

        if (!buildFile.exists()) {
            throw new InvalidUserDataException(String.format("Build file '%s' does not exist.", buildFile));
        }
        if (!buildFile.isFile()) {
            throw new InvalidUserDataException(String.format("Build file '%s' is not a file.", buildFile));
        }
    }

            cache.open()
        } finally {
            cache.close()
        }

        then:
        0 * _  // Does not call initialization action.
        dir.file("cache.properties").isFile()
        dir.file("some-file").isFile()
    }

    def "will rebuild cache if not unlocked cleanly"() {
        given:
        def dir = temporaryFolder.testDirectory.createDir("cache")
        def initialized = false

    (findProperty(KotlinDslScriptsModel.SCRIPTS_GRADLE_PROPERTY_NAME) as? String)
        ?.split("|")
        ?.asSequence()
        ?.filter { it.isNotBlank() }
        ?.map(::canonicalFile)
        ?.filter { it.isFile }
        ?.toList()


// TODO:kotlin-dsl naive implementation for now, refine
private
fun Project.collectKotlinDslScripts(): List<File> = buildList {

    addAll(discoverInitScripts())

		// This handles "" by returning defaults.
		return getDNSConfig(resolverConfig)
	}

	isFile, err := fileExists(resolverConfig)
	if err != nil {
		err = fmt.Errorf(`Unexpected error while getting os.Stat for "%s" resolver config. Error: %w`, resolverConfig, err)
		klog.ErrorS(err, "Cannot get host DNS Configuration.")
		return nil, err
	}
	if isFile {
		// Get the DNS config from a resolv.conf-like file.
		return getDNSConfig(resolverConfig)