* 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;
    }

import org.gradle.api.Action;
import org.gradle.api.tasks.Internal;
import org.gradle.api.tasks.util.PatternFilterable;
import org.gradle.internal.HasInternalProtocol;

/**
 * Synchronizes the contents of a destination directory with some source directories and files.
 *
 * @since 7.5
 */
@HasInternalProtocol
public interface SyncSpec extends CopySpec {

    /**

 *
 * <p>The parent directory will be created before the task is executed if it does not exist
 * already.</p>
 *
 * <p>This will cause the task to be considered out-of-date when the file path or contents
 * are different to when the task was last run.</p>
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.FIELD})
public @interface OutputFile {

    }

    def "can build a war"() {
        given:
        super.sample sample

        when:
        executer.withTasks('clean', 'build').run()

        then:
        // Check contents of War
        TestFile warContents = file('war-tmp')
        sample.dir.file("build/libs/quickstart.war").unzipTo(warContents)
        warContents.assertHasDescendants(
                'META-INF/MANIFEST.MF',