task = jobHelper.startMonitorTask(jobLog);
            }

            if (logger.isDebugEnabled()) {
                logger.debug("Starting Job {}. scriptType: {}, script: {}", id, scriptType, script);
            } else if (scheduledJob.isLoggingEnabled() && logger.isInfoEnabled()) {
                logger.info("Starting Job {}.", id);
            }

import org.junit.jupiter.api.Test;
import org.slf4j.Logger;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;

/**
 */
class BuilderCommonTest {
    private Logger logger = mock(Logger.class);

    @Test
    void testResolveBuildPlan() throws Exception {

import org.codelibs.core.collection.SLinkedList;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.core.log.Logger;

/**
 * Timerを扱うクラスです。
 *
 * @author higa
 *
 */
public class TimeoutManager implements Runnable {

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

    /**
     * シングルトンのためのインスタンスです。
     */

    }

    @Test
    void testDebugEnabled() throws PlexusContainerException {
        Logger logger = mock(Logger.class);
        when(logger.isDebugEnabled()).thenReturn(true);

        DefaultClassRealmManager classRealmManager;
        ClassRealm classRealm;

        InOrder verifier = inOrder(logger);

        PlexusContainer container = new DefaultPlexusContainer();

#
# ebean.default="models.*"

# Logger
# ~~~~~
# You can also configure logback (http://logback.qos.ch/),
# by providing an application-logger.xml file in the conf directory.

# Root logger:
logger.root=ERROR

# Logger used by the framework:
logger.play=INFO

# Logger provided to your application:

val slf4jLogger = LoggerFactory.getLogger("some-logger")
slf4jLogger.info("An info log message logged using SLF4j")
// end::use-slf4j[]

// tag::use-logger[]
logger.quiet("An info log message which is always logged.")
logger.error("An error log message.")
logger.warn("A warning log message.")
logger.lifecycle("A lifecycle info log message.")
logger.info("An info log message.")
logger.debug("A debug log message.")

import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.internal.time.Time;
import org.gradle.internal.time.Timer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class BuildScriptProcessor implements ProjectConfigureAction {
    private static final Logger LOGGER = LoggerFactory.getLogger(BuildScriptProcessor.class);
    private final ScriptPluginFactory configurerFactory;

 * limitations under the License.
 */
package org.gradle.internal.dispatch

import org.slf4j.Logger
import spock.lang.Specification

class ExceptionTrackingFailureHandlerTest extends Specification {
    private final Logger logger = Mock()
    private final ExceptionTrackingFailureHandler dispatch = new ExceptionTrackingFailureHandler(logger)

    def stopRethrowsFailure() {
        RuntimeException failure = new RuntimeException()

	defaultPlugins.PreFilter = mergePluginSet(logger, defaultPlugins.PreFilter, customPlugins.PreFilter)
	defaultPlugins.Filter = mergePluginSet(logger, defaultPlugins.Filter, customPlugins.Filter)
	defaultPlugins.PostFilter = mergePluginSet(logger, defaultPlugins.PostFilter, customPlugins.PostFilter)
	defaultPlugins.PreScore = mergePluginSet(logger, defaultPlugins.PreScore, customPlugins.PreScore)

        LOG_LEVEL_MAPPING.put(LogLevel.QUIET, Level.SEVERE);
        LOG_LEVEL_MAPPING.put(LogLevel.ERROR, Level.SEVERE);
    }

    private final Logger logger;
    private LogLevel requestedLevel;
    private boolean installed;

    public JavaUtilLoggingSystem() {
        logger = Logger.getLogger("");
    }

    @Override
    public Snapshot setLevel(LogLevel logLevel) {
        Snapshot snapshot = snapshot();