exception.message.startsWith("Could not update timestamp")
        file.file
        file.lastModified() == original
        // Changes in implementation of commons-io require us to not have a stubbed Path here
        new File(file.absolutePath).text == "data"
    }

    private static class PathOverridingFile extends TestFile {
        private final java.nio.file.Path path

    TestResources resources = new TestResources(temporaryFolder)
    TestKeyStore keyStore

    def setup() {
        keyStore = TestKeyStore.init(resources.dir)
        // We need to set the SSL properties as arguments here even for non-embedded test mode
        // because we want them to be set on the wrapper client JVM, not the daemon one
        wrapperExecuter.withArguments(keyStore.getTrustStoreArguments())
        server.configure(keyStore)

        when:
        dir.deleteDir() // directory does not exist
        configurationCacheRun("report")

        then:
        fixture.assertStateStored() // TODO - it would be good to reuse a previous entry here
        outputContains("Calculating task graph as configuration cache cannot be reused because an input to build file 'build.gradle' has changed.")
        outputContains(output1)

        where:

        TypeName entryChildType = TypeUtils.typeName(entry.type);
        CodeBlock matchExpr = entry.kind == RECEIVER_AS_CLASS ?
            CodeBlock.of("$L.equals($T.class)", argExpr, entryChildType) :
            // Vararg fits here, too:
            CodeBlock.of("$1L == null || $1L instanceof $2T", argExpr, entryChildType.box());
        result.beginControlFlow("if ($L)", matchExpr);
        boolean shouldPopParameter = false;

When the action requires no parameters, you can use link:{javadocPath}/org/gradle/api/flow/FlowParameters.None.html[FlowParameters.None] as the type of parameter.

Here is an example of a dataflow action that takes a shared build service and a file path as parameters:

====
[source.multi-language-sample,java]
.SoundPlay.java
----

import com.google.common.base.Objects;
import com.google.common.collect.Ordering;
import org.gradle.internal.deprecation.DeprecationLogger;

import javax.annotation.Nullable;

/**
 * This class is only here to maintain binary compatibility with existing plugins.
 *
 * @deprecated Will be removed in Gradle 9.0.
 */
@Deprecated
public class VersionNumber implements Comparable<VersionNumber> {

----
<root>
└── config
    └── checkstyle           // <1>
        └── checkstyle.xml   // <2>
        └── suppressions.xml
----
<1> Checkstyle configuration files go here
<2> Primary Checkstyle configuration file

[[sec:checkstyle_dependency_management]]
== Dependency management

The Checkstyle plugin adds the following dependency configurations:

- `UP-TO-DATE` - tasks that used incremental build and were not re-run.

To summarize:

1. First, we used the `build` task to populate our local cache with task inputs and outputs -- we can imagine this was done a week ago.
2. Then, we used the `clean` task to mimic switching branches -- overriding previous outputs.
3. Finally, we used the `build` task -- unlike incremental builds, the previous outputs were stored in the local cache and could be reused.

import javax.annotation.Nullable;
import java.io.File;
import java.util.Arrays;
import java.util.Locale;
import java.util.regex.Pattern;

/**
 * This class is only here to maintain binary compatibility with existing plugins.
 * <p>
 * Plugins should prefer external frameworks over this class.
 *
 * @deprecated Will be removed in Gradle 9.0.
 */
@Deprecated
public class TextUtil {

If task B uses the output of task A, then task A must complete before task B begins.

- A task may declare its dependencies explicitly.
- A task may depend on other tasks implicitly.

Here is an example of explicit task dependency:
[.multi-language-sample]
=====
[source, kotlin]
----
tasks.register("hello") {
    doLast {
        println("Hello!")
    }
}