server.shutdown()
    } catch (e: IOException) {
      logger.log(Level.WARNING, "MockWebServer shutdown failed", e)
    }
  }

  @ExperimentalOkHttpApi
  companion object {
    private val logger = Logger.getLogger(MockWebServerRule::class.java.name)
  }

    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

        where:
        name << [ROOT_LOGGER_NAME, "foo", "foo.bar"]
    }

import org.codelibs.fess.exception.InvalidAccessTokenException;

public abstract class FessApiAdminAction extends FessApiAction {

    private static final Logger logger = LogManager.getLogger(FessApiAdminAction.class);

    @Override
    protected boolean isAccessAllowed() {
        try {

import java.util.Arrays;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class IngestFactory {
    private static final Logger logger = LogManager.getLogger(IngestFactory.class);

    private Ingester[] ingesters = {};

    public synchronized void add(final Ingester ingester) {
        if (logger.isDebugEnabled()) {

/**
 * Terminates the external running 'sub' process when the Gradle process is being cancelled.
 */
public class ExecHandleShutdownHookAction implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(ExecHandleShutdownHookAction.class);
    private final ExecHandle execHandle;

    public ExecHandleShutdownHookAction(ExecHandle execHandle) {
        if (execHandle == null) {

import org.codelibs.core.log.Logger;

/**
 * Utility class for Thread class
 *
 * @author shinsuke
 *
 */
public abstract class ThreadUtil {

    private static final Logger logger = Logger.getLogger(ThreadUtil.class);

    public static void sleep(final long millis) {
        if (millis < 1L) {
            return;
        }
        try {
            Thread.sleep(millis);

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.fess.util.ComponentUtil;

public class PurgeThumbnailJob {
    private static final Logger logger = LogManager.getLogger(PurgeThumbnailJob.class);

    private long expiry = 30 * 24 * 60 * 60 * 1000L;

    public String execute() {
        try {
            final long count = ComponentUtil.getThumbnailManager().purge(getExpiry());

 *
 * <p>It is instantiated and called from {@link SystemApplicationClassLoaderWorker}.<p>
 */
public class ActionExecutionWorker implements Action<WorkerProcessContext> {
    private static final Logger LOGGER = LoggerFactory.getLogger(ActionExecutionWorker.class);
    private final Action<? super WorkerProcessContext> action;

    public ActionExecutionWorker(Action<? super WorkerProcessContext> action) {
        this.action = action;
    }

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DefaultToolchainJavaCompiler implements JavaCompiler {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultToolchainJavaCompiler.class);

    private final JavaToolchain javaToolchain;
    private final JavaCompilerFactory compilerFactory;

            this.failure = failure
        }
    }

    abstract protected List<? extends ServerExpectation> getExpectations()

    abstract protected void stop()

    abstract protected Logger getLogger()