given:
        long now = System.currentTimeMillis()
        def cacheEntries = [
            createCacheEntry(now),
            createCacheEntry(now - TimeUnit.MINUTES.toMillis(15)),
            createCacheEntry(now - TimeUnit.HOURS.toMillis(5)),
        ]

        when:
        cleanupAction.clean(cleanableStore, progressMonitor)

        then:

            ByteArrayOutputStream stderr = connectStream(process.getErrorStream(), latch);

            process.waitFor(1, TimeUnit.MINUTES);
            latch.await(1, TimeUnit.MINUTES);
            return new ExecResult(args, process.exitValue(), stdout.toString(), stderr.toString());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

                    dayOfWeek = ScheduleTrigger.DAY.Saturday
                    hour = 1
                }
            } else {
                schedulingPolicy = daily {
                    hour = 0
                    minute = 30
                }
            }
            triggerBuild = always()
            withPendingChangesOnly = true
            param("revisionRule", "lastFinished")
            branchFilter = model.branch.branchFilter()

        <!--</module>-->

        <!-- Coding -->

                @TaskAction def exec() {
                    output.text = duration.toString()
                }
            }

            task myTask(type: MyTask) {
                duration = Duration.ofMinutes(1)
                output = project.file("build/output.txt")
            }
        """

        when:
        run ':myTask'

        then:
        executedAndNotSkipped ':myTask'

}

fun determineTimeoutMillis() = when {
    isRequestedTask(compileAllBuild) || isRequestedTask(sanityCheck) || isRequestedTask(quickTest) -> Duration.ofMinutes(30).toMillis()
    isRequestedTask(smokeTest) -> Duration.ofHours(1).plusMinutes(30).toMillis()
    isRequestedTask(docsTest) -> Duration.ofMinutes(45).toMillis()
    else -> Duration.ofHours(2).plusMinutes(45).toMillis()
}

fun setupGlobalState() {
    if (needsToUseTestVersionsPartial()) {

    companion object {
        const val IO_ACTION_TIMEOUT_SYSTEM_PROPERTY = "org.gradle.kotlin.dsl.internal.io.timeout"
        val DEFAULT_IO_ACTION_TIMEOUT = Duration.ofMinutes(1).toMillis()
    }

    override val ioActionTimeoutMs: Long by lazy {
        System.getProperty(IO_ACTION_TIMEOUT_SYSTEM_PROPERTY)
            .takeIf { !it.isNullOrBlank() }
            ?.let { property ->

        given:
        file('files/one.txt').createFile()
        file('files/a/two.txt').createFile()
        file('files/b/ignore.txt').createFile()
        buildFile """
            def files = fileTree(dir: 'files').minus(fileTree(dir: 'files/b'))
            task copy(type: Copy) {
                from files
                into 'dest'
            }
        """

        when:
        run 'copy'

        then:

        }

        String[] parentComponents = new String[components.length - 1];
        arraycopy(components, 0, parentComponents, 0, components.length - 1);

        // Same as the length of this, minus the last element, minus the dot between them
        int parentPathLength = path.length() - components[components.length - 1].length() - 1;

        return path(path.substring(0, parentPathLength), parentComponents);
    }

        TestFileCollection collection1 = new TestFileCollection(file1, file2)
        TestFileCollection collection2 = new TestFileCollection(file2, file3)

        when:
        FileCollection difference = collection1.minus(collection2)

        then:
        difference.files == toLinkedSet(file1)
    }

    def "can subtract a collections using - operator"() {
        File file1 = new File("f1")