}

    boolean excluded(FileTreeElement file) {
        !patternSet.asSpec.isSatisfiedBy(file)
    }

    private static FileTreeElement element(boolean isFile, String... elements) {
        [
            getRelativePath: { return new RelativePath(isFile, elements) },
            getFile        : { return new File(elements.join('/')) }
        ] as FileTreeElement
    }

    }

    private static boolean isLegacyVisualCpp(File candidate) {
        return new File(candidate, PATH_BIN + LEGACY_COMPILER_FILENAME).isFile();
    }

    private static boolean isVS2017VisualCpp(File candidate) {
        return new File(candidate, PATH_BIN + VS2017_COMPILER_FILENAME).isFile();
    }

		return spec.PersistentVolume.Spec.HostPath, spec.ReadOnly, nil
	}

	return nil, false, fmt.Errorf("spec does not reference an HostPath volume type")
}

type hostPathTypeChecker interface {
	Exists() bool
	IsFile() bool
	MakeFile() error
	IsDir() bool
	MakeDir() error
	IsBlock() bool
	IsChar() bool
	IsSocket() bool
	GetPath() string
}

type fileTypeChecker struct {
	path string

        when:
        fileTree.visitStructure(visitor, owner)

        then:
        1 * visitor.visitFileTree(generatedFile, _, owner) >> { d, p, t ->
            assert p.isEmpty()
            assert generatedFile.isFile()
            assert generatedFile.text == "contents!"
        }
        1 * generationListener.execute(generatedFile)
        1 * contentWriter.execute(_) >> { OutputStream outputStream ->

    public VisualCppInstallCandidate getVisualCppFromMetadataFile(File installDir) {
        File msvcVersionFile = new File(installDir, VS2017_METADATA_FILE_PATH);
        if (!msvcVersionFile.exists() || !msvcVersionFile.isFile()) {
            LOGGER.debug("The MSVC version file at {} either does not exist or is not a file.  Cannot determine the MSVC version for this installation.", msvcVersionFile.getAbsolutePath());
            return null;
        }

            }

            private void validate(File output) {
                validateOutputExists(outputDir, output);
                if (outputFiles.contains(output) && !output.isFile()) {
                    throw new InvalidUserDataException("Transform output file " + output.getPath() + " must be a file, but is not.");
                }

        if (path == null) {
            logger.warn("{} was not found.", path);
            return null;
        }
        final File osddFile = new File(path);
        if (!osddFile.isFile()) {
            logger.warn("{} was not a file.", path);
            return null;
        }
        return osddFile;
    }

    protected boolean isOsddLinkEnabled() {

            case FILE:
                if (!file.exists()) {
                    throw new InvalidUserDataException(String.format("File '%s' does not exist.", file));
                }
                if (!file.isFile()) {
                    throw new InvalidUserDataException(String.format("File '%s' is not a file.", file));
                }
                break;
            case DIRECTORY:
                if (!file.exists()) {

                    .anyMatch(absolutePath::startsWith);
            },
            dir -> !directoriesToClean.contains(dir)
        );

        try {
            for (File f : filesToDelete) {
                if (f.isFile()) {
                    outputsCleaner.cleanupOutput(f, FileType.RegularFile);
                }
            }
            outputsCleaner.cleanupDirectories();
        } catch (IOException e) {

        then: "the cache entry is reused"
        configurationCache.assertStateLoaded()

        when: "the file used in configuration is deleted and a directory is created in its place"
        assert accessedFile.isFile()
        assert accessedFile.delete()
        assert accessedFile.mkdirs()
        configurationCacheRunLenient()

        then: "the cache entry is invalidated and the change of the file system entry is reported"