private static final String LOGGER_FACTORY_CLASS_STR = OutputEventListenerBackedLoggerContext.class.getName();

    private final OutputEventListenerBackedLoggerContext factory = new OutputEventListenerBackedLoggerContext(Time.clock());

    public static StaticLoggerBinder getSingleton() {
        return SINGLETON;
    }

    /**
     * Declare the version of the SLF4J API this implementation is compiled against.

                return element.getName().equals(gcStrategy.getGarbageCollectorName());
            }
        });
        ScheduledFuture<?> ignored = pollingExecutor.scheduleAtFixedRate(new GarbageCollectionCheck(Time.clock(), garbageCollectorMXBean, gcStrategy.getHeapPoolName(), heapEvents, gcStrategy.getNonHeapPoolName(), nonHeapEvents), POLL_DELAY_SECONDS, POLL_INTERVAL_SECONDS, TimeUnit.SECONDS);
    }

    @Override

            versionUnderTest: GradleVersion.current().getVersion(),
            vcsBranch: Git.current().branchName,
            vcsCommits: [Git.current().commitId],
            startTime: clock.getCurrentTime(),
            channel: determineChannel(),
            teamCityBuildId: determineTeamCityBuildId()
        )
    }

            versionUnderTest: GradleVersion.current().getVersion(),
            vcsBranch: Git.current().branchName,
            vcsCommits: [Git.current().commitId, pluginCommitSha],
            startTime: clock.getCurrentTime(),
            channel: determineChannel(),
            teamCityBuildId: determineTeamCityBuildId()
        )
    }

import static org.slf4j.Logger.ROOT_LOGGER_NAME

class OutputEventListenerBackedLoggerContextTest extends Specification {
    OutputEventListenerBackedLoggerContext context = new OutputEventListenerBackedLoggerContext(Time.clock())

    private OutputEventListenerBackedLogger logger(String name) {
        context.getLogger(name)
    }

    def "can retrieve logger named #name"() {
        expect:
        logger(name).name == name

    }

    private TransientConfigurationResults deserialize(Decoder decoder, ResolvedGraphResults graphResults, SelectedArtifactResults artifactResults, BuildOperationExecutor buildOperationProcessor) {
        Timer clock = Time.startTimer();
        Map<Long, DefaultResolvedDependency> allDependencies = new HashMap<>();
        Map<Dependency, DependencyGraphNodeResult> firstLevelDependencies = new LinkedHashMap<>();

    }

    String getErr() {
        outputs.stdErr
    }

    def context

    Logger logger() {
        if (context == null) {
            context = new OutputEventListenerBackedLoggerContext(Time.clock())
        }
        context.getLogger("foo")
    }

    def "messages logged below LIFECYCLE level are ignored"() {
        when:
        logger().trace("debug")
        logger().debug("debug")

    }

    public static Result success(Duration duration, Execution outcome) {
        return new Result(duration, Try.successful(outcome));
    }

    /**
     * The elapsed wall clock time of executing the actual work, i.e. the time it took to execute the
     * {@link UnitOfWork#execute(UnitOfWork.ExecutionRequest)} method.
     *

package aes

import (
	"bytes"
	"context"
	"crypto/aes"
	"crypto/sha256"
	"errors"
	"fmt"
	"io"
	"time"

	"golang.org/x/crypto/hkdf"

	"k8s.io/apiserver/pkg/storage/value"
	"k8s.io/utils/clock"
)

const (
	// cacheTTL is the TTL of KDF cache entries.  We assume that the value.Context.AuthenticatedData
	// for every call is the etcd storage path of the associated resource, and use that as the primary

		return "", msg, ErrImageNeverPull
	}

	backOffKey := fmt.Sprintf("%s_%s", pod.UID, container.Image)
	if m.backOff.IsInBackOffSinceUpdate(backOffKey, m.backOff.Clock.Now()) {
		msg := fmt.Sprintf("Back-off pulling image %q", container.Image)
		m.logIt(ref, v1.EventTypeNormal, events.BackOffPullImage, logPrefix, msg, klog.Info)
		return "", msg, ErrImagePullBackOff
	}