formatter.format(testDescriptor, [new RuntimeException("oops"), new Exception("ouch")]) == """\
    java.lang.RuntimeException: oops

    java.lang.Exception: ouch
"""
    }

    def "optionally shows causes"() {
        testLogging.getShowCauses() >> true
        def cause = new RuntimeException("oops")
        def exception = new Exception("ouch", cause)

        expect:

            }
        """
    }

    def "Error message due to unwritable build scope cache directory is not scary"() {
        given:
        def localGradleCache = file('.gradle')
        localGradleCache.touch()

        when:
        fails 'hello'

        then:
        localGradleCache.isFile()
        assertHasStartupFailure(failure, "Cache directory '${localGradleCache}' exists and is not a directory.")
    }

        readFileQuietly(temp.createDir("dir")).startsWith "Unable to read file"
    }

    def "touch creates new empty file"() {
        def foo = temp.file("foo.txt")

        when:
        touch(foo)
        then:
        foo.exists()
        foo.length() == 0
        foo.file
    }

    def "touch touches existing file"() {
        def foo = temp.file("foo.txt") << "data"

        touchFile.delete();

        assertTrue(updateCheckManager.isUpdateRequired(a, remoteRepository));

        file.getParentFile().mkdirs();
        file.createNewFile();
        updateCheckManager.touch(a, remoteRepository, null);

        assertFalse(updateCheckManager.isUpdateRequired(a, remoteRepository));

        assertNull(

import org.junit.Rule
import spock.lang.Specification

import java.util.concurrent.CountDownLatch
import java.util.concurrent.atomic.AtomicInteger

import static org.apache.commons.io.FileUtils.touch

class DefaultGeneratedGradleJarCacheIntegrationTest extends Specification {
    private final static String CACHE_IDENTIFIER = 'test'
    private final static long JAR_GENERATION_TIME_MS = 2000L

    @Rule

                Timer timer = Time.startTimer();
                try {
                    cacheCleanupStrategy.getCleanupAction().clean(cleanableStore, progressMonitor);
                    FileUtils.touch(gcFile);
                    LOGGER.info("{} cleaned up in {}.", cleanableStore.getDisplayName(), timer.getElapsed());
                    context.setResult(new CacheCleanupResult(progressMonitor.getDeleted(), lastCleanupTime));

    }

    def "prompts to overwrite files if any exist and defaults to no"() {
        given: "a file exists in the build directory"
        targetDir.file(defaultFileName).touch()

        when:
        def handle = startInteractiveExecutorWithTasks(
            "init",
            "--incubating",
            "--dsl", "groovy",
            "--type", "basic",

        then:
        with(taskSuccessResult(':incrementalTask')) {
            !incremental
            executionReasons[0].contains("No history")
        }

        when:
        file('src/a').touch()
        file('src/b').touch()

        and:
        runBuild('incrementalTask')

        then:
        with(taskSuccessResult(':incrementalTask')) {
            incremental

import org.gradle.integtests.tooling.fixture.ToolingApiSpecification

class DaemonJvmCompatibilityCrossVersionSpec extends ToolingApiSpecification {
    def setup() {
        buildFile.touch()
        settingsFile << """
            rootProject.name = "root"
        """
    }

    @TargetGradleVersion(">=8.8")
    def "can run a build with Java 21 followed by another build with a different version"() {

    private DaemonContext candidate = Mock(DaemonContext)

    private TestFile javaHome = tmp.createDir("jdk")

    def setup() {
        javaHome.file("bin", OperatingSystem.current().getExecutableName("java")).touch()
    }

    DaemonRequestContext clientWants(Map args) {
        clientWants(args.requestedJvm,
            args.daemonOpts ?: [],
            args.applyInstrumentationAgent ?: false,