class LocalFileStandInExternalResourceTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    def "can apply ContentAndMetadataAction to file contents"() {
        def file = tmpDir.createFile("content")
        file.text = "1234"

        expect:
        def resource = new LocalFileStandInExternalResource(file, TestFiles.fileSystem())

import org.gradle.api.Transformer;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

/**
 * <p>A mapping provider that uses a transform that:</p>
 *
 * <ul>
 *     <li>1. does not use the value contents</li>
 *     <li>2. always produces a non-null value.</li>
 * </ul>
 *
 * <p>This implementation is used only for internal transforms where these constraints are known to be true.

     * Not all resources are available as a file.
     * Note that this method may return null when {@link ResourceLocation#getFile()} returns non-null, when the contents are different.
     *
     * @return A file containing this resource. Returns null if this resource is not available as a file.
     */
    @Nullable
    File getFile();

    /**

 * limitations under the License.
 */

package org.gradle.cache;

public interface CacheDecorator {
    /**
     * @param cacheId Unique id for this cache instance.
     * @param cacheName Name for the type of contents stored in this cache instance.
     */

                    throw new GradleException(String.format("Could not list contents of directory '%s' as it is not readable.", file));
                }
                // else, might be a link which points to nothing, or has been removed while we're visiting, or ...
                throw new GradleException(String.format("Could not list contents of '%s'.", file));
            }
            for (File child : children) {

            try {
                visitEntries(builder);
            } catch (FileException e) {
                // Badly formed archive, so discard the contents and produce an empty JAR
                LOGGER.debug("Malformed archive '{}'. Discarding contents.", source.getName(), e);
            }
        });
    }

    private BiConsumer<File, ClasspathBuilder.Action> resultBuilder() {
        if (source.isDirectory()) {

        if (shouldRemoveContentsOf(file, handling)) {
            File[] contents = file.listFiles();

            // Something else may have removed it
            if (contents == null) {
                return false;
            }

            boolean attemptedToDeleteAnything = false;
            for (File item : contents) {

}
// end::custom-artifact[]

tasks.register('rpm') {
    outputs.file rpmFile
    def rpmFileLocation = rpmFile
    doLast {
        // produce real RPM here
        rpmFileLocation.get().asFile << "file contents"
    }
}

// tag::custom-artifact[]
publishing {
    publications {
        ivy(IvyPublication) {
            artifact rpmArtifact
        }
    }
// end::custom-artifact[]
    repositories {

package org.gradle.internal.cc.impl

import spock.lang.Issue

class ConfigurationCacheFileCollectionIntegrationTest extends AbstractConfigurationCacheIntegrationTest {
    def "directory tree is treated as build input when its contents are queried during configuration"() {
        buildFile << """
            task report {
                def tree = fileTree("src")
                def file1 = file("src/file1")
                def result = $expression

     * flushed to the filesystem on completion of this method.
     */
    BlockAddress write(T value);

    /**
     * Reads the contents of the given block.
     * The current thread performs the decoding.
     */
    T read(BlockAddress blockAddress);

    interface Writer<T> {
        void write(Encoder encoder, T value) throws Exception;
    }