response.getReport().entrySet()) {
            Consumer<String> consumer = s ->
                    context.logger.info(messageBuilderFactory.builder().info(s).build());
            if (entry.getKey() == SecDispatcher.ValidationResponse.Level.ERROR) {
                consumer = s -> context.logger.error(
                        messageBuilderFactory.builder().error(s).build());

 * by using appropriate extractors for each contained file type.
 *
 * @author shinsuke
 */
public class LhaExtractor extends AbstractExtractor {
    /** Logger for this class. */
    private static final Logger logger = LogManager.getLogger(LhaExtractor.class);

    /** Maximum content size for extraction. -1 means no limit. */
    protected long maxContentSize = -1;

    /**

        B extends PerCollectionSizeTestSuiteBuilder<B, G, T, E>,
        G extends TestContainerGenerator<T, E>,
        T,
        E>
    extends FeatureSpecificTestSuiteBuilder<B, G> {
  private static final Logger logger =
      Logger.getLogger(PerCollectionSizeTestSuiteBuilder.class.getName());

  /** Creates a runnable JUnit test suite based on the criteria already given. */
  @Override
  public TestSuite createTestSuite() {

package console

import (
	"encoding/json"
	"fmt"
	"io"
	"strconv"
	"strings"

	"github.com/minio/madmin-go/v3/logger/log"
	"github.com/minio/minio/internal/color"
	"github.com/minio/minio/internal/logger"
)

// Target implements loggerTarget to send log
// in plain or json format to the standard output.
type Target struct {
	output io.Writer
}

    //                                                                            Constant
    //

    /** Logger for this class. */
    private static final Logger logger = LogManager.getLogger(SearchHelper.class);

    // ===================================================================================

    }

  fun enable(
    loggerClass: String,
    handler: Handler = logHandler(),
  ): Closeable {
    val logger = Logger.getLogger(loggerClass)
    if (configuredLoggers.add(logger)) {
      logger.addHandler(handler)
      logger.level = Level.FINEST
    }
    return Closeable {
      logger.removeHandler(handler)
    }
  }

  fun enable(loggerClass: KClass<*>) = enable(loggerClass.java.name)

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class DefaultToolchainManagerTest {
    // Mocks to inject into toolchainManager
    @Mock
    private Logger logger;

    private ToolchainManagerFactory.DefaultToolchainManagerV3 toolchainManager;

    @Mock
    private ToolchainFactory toolchainFactoryBasicType;

    @Mock

import org.dbflute.utflute.core.PlainTestCase;

/**
 * @author shinsuke
 *
 */
public class TextExtractorTest extends PlainTestCase {
    private static final Logger logger = LogManager.getLogger(TextExtractorTest.class);

    public TextExtractor textExtractor;

    @Override
    protected void setUp() throws Exception {
        super.setUp();

public class FessResponseProcessor extends DefaultResponseProcessor {
    /**
     * Default constructor.
     */
    public FessResponseProcessor() {
        super();
    }

    /** Logger instance for this class */
    private static final Logger logger = LogManager.getLogger(FessResponseProcessor.class);

    /** Factory for creating and managing ingesters */
    private IngestFactory ingestFactory = null;

    /**

    queue.enqueue(THROWING_EVENT, "custom-label");

    Logger logger = Logger.getLogger(ListenerCallQueue.class.getName());
    logger.setLevel(Level.SEVERE);
    TestLogHandler logHandler = new TestLogHandler();
    logger.addHandler(logHandler);
    try {
      queue.dispatch();
    } finally {
      logger.removeHandler(logHandler);
    }