return new OutputFileValueSupplier(fileCollection) {
                @Nonnull
                @Override
                public File getValue() {
                    return root;
                }
            };
        }

        public static OutputFileValueSupplier fromSupplier(Supplier<File> root, FileCollection fileCollection) {

import org.gradle.api.file.FileCollection;

/**
 * Models a collection of native type dependencies.
 */
@Incubating
public interface NativeDependencySet {
    /**
     * Returns the header file directories to use at compile time.
     */
    FileCollection getIncludeRoots();

    /**
     * Returns the files to use at link time.
     */
    FileCollection getLinkFiles();

    /**

        private final Provider<Boolean> importAware;
        private final TaskOutputsInternal taskOutputs;
        private final FileCollection includeDirs;
        private final String taskPath;
        private final FileCollection sourceFiles;
        private final FileCollection headerFilesCollection;
        private ObjectHolder<CompilationState> compileStateCache;
        private IncrementalCompilation incrementalCompilation;

import org.gradle.api.DefaultTask;
import org.gradle.api.file.FileCollection;
import org.gradle.api.tasks.Classpath;
import org.gradle.work.DisableCachingByDefault;

/**
 * Base class for Jacoco tasks.
 */
@DisableCachingByDefault(because = "Abstract super-class, not to be instantiated directly")
public abstract class JacocoBase extends DefaultTask {

    private FileCollection jacocoClasspath;

    /**

        def targetBinary = Mock(VisualStudioTargetBinary)
        targetBinary.getSourceFiles() >> fileCollection(sources)
        targetBinary.getHeaderFiles() >> fileCollection()
        targetBinary.getResourceFiles() >> fileCollection()
        targetBinary.projectPath >> ":"
        targetBinary.componentName >> "main"
        targetBinary.visualStudioProjectName >> "mainExe"

        def binary = Mock(VisualStudioTargetBinary)
        2 * binary.sourceFiles >> fileCollection(sourceFiles)
        2 * binary.resourceFiles >> fileCollection(resourceFiles)
        2 * binary.headerFiles >> fileCollection(headerFiles)
        return binary
    }

    private FileCollection fileCollection(List<File> files) {
        return Stub(FileCollection) {
            getFiles() >> files
        }
    }

        tree2.files == [file3] as Set
    }

    def "can view relative paths as a file collection"() {
        given:
        def fileCollection = baseDirectory.files("a/b/c", "d", "e/f")
        def secondBase = tmpDir.createDir("secondBase")

        expect:
        fileCollection.files == [
            baseDir.file("a/b/c"),
            baseDir.file("d"),
            baseDir.file("e/f")
        ] as Set

    /**
     * Returns the C++ source files of this binary.
     */
    FileCollection getCppSource();

    /**
     * Returns the header directories to use to compile this binary. Includes the header directories of this binary plus those of its dependencies.
     */
    FileCollection getCompileIncludePath();

    /**

        this.binary = binary;
    }

    @Override
    public FileCollection getIncludeRoots() {
        return binary.getHeaderDirs();
    }

    @Override
    public FileCollection getLinkFiles() {
        return binary.getLinkFiles();
    }

    @Override
    public FileCollection getRuntimeFiles() {
        return binary.getRuntimeFiles();
    }

        return runTask;
    }

    @Override
    public FileCollection getCompileIncludePath() {
        // TODO: This should be modeled differently, perhaps as a dependency on the implementation configuration
        return super.getCompileIncludePath().plus(getProjectLayout().files(new Callable<FileCollection>() {
            @Override
            public FileCollection call() {
                CppComponent tested = testedComponent.getOrNull();