private final byte[] markerBody;

        MarkerResource(byte[] markerBody) {
            this.markerBody = markerBody;
        }

        /**
         * Reads the contents of the MarkerResource and returns the appropriate constant.
         *
         * @param in the stream to read from
         * @return the corresponding marker resource
         * @throws IOException if reading fails

It synchronizes the contents of a directory with its source.

This can be useful for doing things such as installing your application, creating an exploded copy of your archives, or maintaining a copy of the project's dependencies.

        when:
        run 'copy'

        then:
        result.assertTasksSkipped(":copy")
    }

    def "handles gzip compressed tars"() {
        given:
        TestFile tar = file('tar-contents')
        tar.create {
            someDir {
                file '1.txt'
                file '2.txt'
            }
        }
        tar.tgzTo(file('test.tgz'))
        and:

     * }
     * </pre>
     * <p>The returned file collection is lazy, so that the paths are evaluated only when the contents of the file
     * collection are queried. The file collection is also live, so that it evaluates the above each time the contents
     * of the collection is queried.</p>
     *
     * @param paths The contents of the file collection. Evaluated as per {@link #files(Object...)}.

  if (::testing::internal::AlwaysTrue()) { \
     GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
  } else \
    ::testing::Message()

// A class representing the parsed contents of the
// --gtest_internal_run_death_test flag, as it existed when
// RUN_ALL_TESTS was called.
class InternalRunDeathTestFlag {
 public:
  InternalRunDeathTestFlag(const std::string& a_file,

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

The method call returns the Ant data type, which you can use directly in your build script.
In the following example, we create an Ant `path` object, then iterate over the contents of it:

====
include::sample[dir="snippets/ant/useAntType/kotlin",files="build.gradle.kts"]
include::sample[dir="snippets/ant/useAntType/groovy",files="build.gradle"]
====

[[sec:using_custom_ant_tasks]]

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:

    }

    private void reportAccess(Object key, @Nullable Object value) {
        listener.onAccess(key, value);
    }

    private void reportAggregatingAccess() {
        // Mark all map contents as inputs if some aggregating access is used.
        delegate.forEach(this::reportAccess);
    }

    private void reportChange(Object key, Object value) {
        listener.onChange(key, value);
    }

    val stateType: StateType
    val stateFile: ConfigurationCacheStateStore.StateFile
    fun outputStream(): OutputStream
    fun inputStream(): InputStream
    fun delete()

    // Replace the contents of this state file, by moving the given file to the location of this state file
    fun moveFrom(file: File)
    fun stateFileForIncludedBuild(build: BuildDefinition): ConfigurationCacheStateFile
}


internal