}
// 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',

    /**
     * A single cache instance shared by all Gradle versions. It is the caller's responsibility to make sure that this is shared only with
     * those versions of Gradle that are compatible with the cache implementation and contents.
     */
    SharedCache

import org.gradle.api.internal.tasks.DefaultTaskDependencyFactory;
import org.gradle.api.internal.tasks.TaskDependencyFactory;

import java.util.function.Consumer;

/**
 * A {@link FileCollection} whose contents is created lazily.
 */
public abstract class LazilyInitializedFileCollection extends CompositeFileCollection {

    // Used in a third-party plugin Freefair AspectJ:

    }

    @Override
    public boolean getHasEmptyContent() {
        return true;
    }

    @Override
    public File getFile() {
        // Returns null as there is no file that contains this resource's contents,
        // however {@link ResourceLocation#getFile()} would still return the given `sourceFile`
        return null;
    }

    @Override
    public Charset getCharset() {
        return null;
    }

    private final List<Action<StyledTextOutput>> events = new ArrayList<Action<StyledTextOutput>>();
    private boolean hasContent;

    /**
     * Writes the buffered contents of this output to the given target, and clears the buffer.
     */
    public void writeTo(StyledTextOutput output) {
        for (Action<StyledTextOutput> event : events) {
            event.execute(output);
        }