break;
                case TRIGGERED:
                    LOGGER.debug("Watch probe has already been triggered for hierarchy: {}", watchableHierarchy);
                    break;
            }
        }

        public synchronized void trigger() {
            if (state != State.TRIGGERED) {
                LOGGER.debug("Watch probe in state {} has been triggered for hierarchy: {}", state, watchableHierarchy);

                    // We want it to be triggered only when there're pending changes in the specific vcs root, i.e. GradleMaster/GradleRelease
                    triggerRules = "+:root=${VersionedSettingsBranch.fromDslContext().vcsRootId()}:."
                    // The promotion itself will be triggered on gradle-promote's master branch

                    // We want it to be triggered only when there're pending changes in the specific vcs root, i.e. GradleMaster/GradleRelease
                    triggerRules = "+:root=${VersionedSettingsBranch.fromDslContext().vcsRootId()}:."
                    // The promotion itself will be triggered on gradle-promote's master branch

    /**
     * Whether the <a href="https://www.jetbrains.com/help/teamcity/configuring-vcs-triggers.html">VCS trigger</a>
     * should be enabled, i.e. when new commits are pushed to this branch, should a ReadyForNightly job
     * be triggered automatically?
     *
     * Currently, we only enable VCS trigger for `master`/`release`/`releaseNx` branches.
     */

package org.gradle.cache;

import javax.annotation.Nullable;
import java.time.Duration;
import java.time.Instant;

/**
 * Represents when cache cleanup should be triggered.
 *
 * @since 8.0
 */
public interface CleanupFrequency {
    /**
     * Trigger cleanup once every 24 hours.
     */
    CleanupFrequency DAILY = new CleanupFrequency() {
        @Override

 */
public interface InstanceFactory<T> {
    /**
     * Is the given service required to be injected by type?
     */
    boolean requiresService(Class<?> serviceType);

    /**
     * Is any service injection triggered by the given annotation?
     */
    boolean serviceInjectionTriggeredByAnnotation(Class<? extends Annotation> injectAnnotation);

    /**
     * Creates a new instance from the given services and parameters.
     */

 * We listen to those events specifically in {@link FileWatcherRegistry}.
 * Once the event arrives, {@link #triggerWatchProbe(String)} is called with the path,
 * and the probe becomes triggered (or proven).
 *
 * The {@link #unprovenHierarchies()} stream returns any hierarchies that were armed, but never received
 * a file system event.

        //
        // So, as a workaround, locate and make visible XML parser classes from the system classloader in our isolated ClassLoader.
        //
        // Note that in practise, this is only triggered when running in our tests

        if (needJaxpImpl()) {
            classPath = addToClassPath(classPath, getClasspathForResource(getSystemClassLoader(), "META-INF/services/javax.xml.parsers.SAXParserFactory"));

        where:
        days << [-1, 0]
    }

    def "cleanup is triggered after max number of hours expires"() {
        def originalCheckTime = initializeHome()

        // One hour isn't enough to trigger
        when:
        // Set the time back 1 hour
        def lastCleanupCheck = markCacheLastCleaned(originalCheckTime - TimeUnit.HOURS.toMillis(1))

    /**
     * Stores the results of the given work in the build cache, unless storing was disabled for this execution or work was untracked.
     * <p>
     * The former is currently used only for tasks and can be triggered via {@code org.gradle.api.internal.TaskOutputsEnterpriseInternal}.
     */
    private void storeInCacheUnlessDisabled(CacheableWork cacheableWork, BuildCacheKey cacheKey, AfterExecutionResult result, Execution executionResult) {