}

    private void loadInsideLock(HashCode key, Consumer<? super File> reader) {
        File file = getCacheEntryFile(key);
        if (!file.exists()) {
            return;
        }

        fileAccessTracker.markAccessed(file);

        try {
            reader.accept(file);
        } catch (Exception e) {
            // Try to move the file out of the way in case its permanently corrupt

    private final RandomAccessFile file;

    public RandomAccessFileInputStream(RandomAccessFile file) {
        this.file = file;
    }

    @Override
    public long skip(long n) throws IOException {
        file.seek(file.getFilePointer() + n);
        return n;
    }

    @Override
    public int read(byte[] bytes) throws IOException {
        return file.read(bytes);
    }

    @Override

            urls.add(file.toURI());
        }
        return urls;
    }

    public Collection<File> getAsFiles() {
        return files;
    }

    public URL[] getAsURLArray() {
        Collection<URL> result = getAsURLs();
        return result.toArray(new URL[0]);
    }

    public Collection<URL> getAsURLs() {
        List<URL> urls = new ArrayList<URL>();
        for (File file : files) {

        then:
        subprojectDir.file("src/main/cpp").assertHasDescendants(SAMPLE_LIB_CLASS)
        subprojectDir.file("src/main/public").assertHasDescendants("some-thing.h")
        subprojectDir.file("src/test/cpp").assertHasDescendants(SAMPLE_LIB_TEST_CLASS)

        and:
        subprojectDir.file("src/main/public/some-thing.h").text.contains("namespace some_thing {")

import net.rubygrapefruit.platform.file.FileInfo;
import net.rubygrapefruit.platform.file.Files;
import org.gradle.api.UncheckedIOException;
import org.gradle.internal.file.FileMetadata;
import org.gradle.internal.file.FileMetadata.AccessType;
import org.gradle.internal.file.FileMetadataAccessor;
import org.gradle.internal.file.impl.DefaultFileMetadata;

import java.io.File;

 */

package org.gradle.internal.file;

import java.io.File;

public interface FileMetadataAccessor {
    /**
     * Gets the file metadata of a {@link File}.
     * <p>
     * If the type of the file cannot be determined, or is
     * neither {@link org.gradle.internal.file.FileType#RegularFile}
     * nor {@link org.gradle.internal.file.FileType#Directory},
     * then the file type of the file metadata is of type

            [fromString(), "command.execute(['FOOBAR=foobar'], file('$pwd'))", pwd, "foobar"],
            [fromGroovyString(), "command.execute(['FOOBAR=foobar'], file('$pwd'))", pwd, "foobar"],
            [fromStringArray(), "command.execute(['FOOBAR=foobar'], file('$pwd'))", pwd, "foobar"],
            [fromStringList(), "command.execute(['FOOBAR=foobar'], file('$pwd'))", pwd, "foobar"],

    private static final String[] EMPTY = new String[0];

    public static String createManifestClasspath(File jarFile, Collection<File> classpath) {
        List<String> paths = new ArrayList<String>(classpath.size());
        for (File file : classpath) {
            String path = constructRelativeClasspathUri(jarFile, file);
            paths.add(path);
        }

        return CollectionUtils.join(" ", paths);
    }

        def store3 = f.createStoreSet().nextBinaryStore()

        then:
        store.file != store2.file //rolled
        [store.file, store2.file, store3.file].each { it.exists() }

        when:
        new CompositeStoppable().add(store, store2, store3)

        then:
        [store.file, store2.file, store3.file].each { !it.exists() }
    }

    def "provides stores"() {
        def set1 = f.createStoreSet()

                inFile = file("in.txt")
                outFile = layout.buildDirectory.file("out.txt")
            }
            task transformer(type: InputTask) {
                inValue = producer.outFile.map { f -> f.asFile.text as Integer }.map { i -> i + 2 }
                outFile = file("out.txt")
            }
        """
        def input = file("in.txt")
        def output = file("out.txt")