// will call StartTestLog/StopTestLog multiple times.
		// Checking log.set avoids calling testlog.SetLogger multiple times
		// (which will panic) and also avoids writing the header multiple times.
		log.set = true
		testlog.SetLogger(&log)
		log.w.WriteString("# test log\n") // known to cmd/go/internal/test/test.go
	}
	log.mu.Unlock()
}

func (TestDeps) StopTestLog() error {

import java.util.ArrayList;
import java.util.List;

@ThreadSafe
@ServiceScope(Scope.Global.class)
public class SftpClientFactory implements Stoppable {
    private static final Logger LOGGER = LoggerFactory.getLogger(SftpClientFactory.class);

    private SftpClientCreator sftpClientCreator = new SftpClientCreator();
    private final Object lock = new Object();
    private final List<LockableSftpClient> allClients = new ArrayList<>();

package com.example;

import java.util.logging.Logger;

public class LumberJack {
    private static final Logger ROOT = Logger.getLogger("");
    private static final Logger OAK = Logger.getLogger("oak");
    private static final Logger ELM = Logger.getLogger("elm");
    private static final Logger ELMER = Logger.getLogger("elm.er");

    public void sing() {
        ROOT.fine("Oh, I'm a lumberjack, and I'm okay.");

    private final StandardOutputRedirector.OutputListener stdErrListener = Mock()
    private final Logger logger1 = Logger.getLogger("")
    private final Logger logger2 = Logger.getLogger("hello")
    private final Logger logger3 = Logger.getLogger("hello.world")
    private static String savedJULConfigClassProperty = null;

    public static class DummyFormatter extends Formatter {
        @Override

        if (problems.isEmpty()) {
            getLogger().info("Plugin validation finished without warnings.");
        } else {
            if (getFailOnWarning().get() || problems.stream().anyMatch(problem -> problem.getDefinition().getSeverity() == ERROR)) {
                if (getIgnoreFailures().get()) {
                    getLogger().warn("Plugin validation finished with errors. {} {}",

object LoggerCodec : Codec<Logger> {

    override suspend fun WriteContext.encode(value: Logger) {
        writeString(value.name)
    }

    override suspend fun ReadContext.decode(): Logger? =
        LoggerFactory.getLogger(readString())

import java.util.HashSet;
import java.util.Set;

public class LoggingIncubatingFeatureHandler implements FeatureHandler<IncubatingFeatureUsage> {
    private static final Logger LOGGER = LoggerFactory.getLogger(LoggingIncubatingFeatureHandler.class);

    private final Set<String> features = new HashSet<String>();

    @Override
    public void featureUsed(IncubatingFeatureUsage usage) {

        }
    }

    override suspend fun ReadContext.decode(): DefaultContextAwareTaskLogger =
        decodePreservingIdentity { id ->
            DefaultContextAwareTaskLogger(Logging.getLogger(Task::class.java)).also { logger ->
                read()?.let { rewriter ->
                    logger.messageRewriter = rewriter as MessageRewriter
                }
                isolate.identities.putInstance(id, logger)

        if (!reset) {
            LogManager.getLogManager().reset();
            try {
                LogManager.getLogManager().readConfiguration();
            } catch (IOException error) {
                Logger.getLogger("").addHandler(new ConsoleHandler());
            }
            reset = true;
        }
    }

 */

package org.gradle.internal.cc.base

import org.gradle.api.logging.Logger
import org.gradle.api.logging.Logging


/**
 * Configuration Cache logger.
 */