.thenReturn(UpgradeResult.empty());

                applyGoal.execute(context);

                // Verify that the Apply-specific header is logged
                verify(context.logger).info("Maven Upgrade Tool - Apply");
            } finally {
                // Clean up - delete all files in the directory first
                try {
                    Files.walk(tempDir)

import org.apache.maven.api.cli.Logger;

import static java.util.Objects.requireNonNull;

/**
 * Proto {@link Logger} that just passes to functioning {@link org.slf4j.Logger} instance.
 */
public class Slf4jLogger implements Logger {
    private final org.slf4j.Logger logger;

    public Slf4jLogger(org.slf4j.Logger logger) {
        this.logger = requireNonNull(logger, "logger");
    }

    @Override

import org.slf4j.Logger;

/**
 */
class LoggingRepositoryListener extends AbstractRepositoryListener {

    private final Logger logger;

    LoggingRepositoryListener(Logger logger) {
        this.logger = logger;
    }

    @Override
    public void artifactInstalling(RepositoryEvent event) {

                task = jobHelper.startMonitorTask(jobLog);
            }

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

          return 0;
        }
      };

  // We use a holder class to delay initialization: https://github.com/google/guava/issues/6566
  private static final class LoggerHolder {
    static final Logger logger = Logger.getLogger(CacheBuilder.class.getName());
  }

  static final int UNSET_INT = -1;

  boolean strictParsing = true;

  int initialCapacity = UNSET_INT;
  int concurrencyLevel = UNSET_INT;

        if (logger.isInfoEnabled()) {
            logger.info("Starting crawler cleanup: sessionId={}", sessionId);
        }
        try {
            // TODO transaction?
            urlQueueService.delete(sessionId);
            dataService.delete(sessionId);
            urlFilter.clear();
            if (logger.isInfoEnabled()) {

            }
        }).execute()) {
            if (logger.isDebugEnabled()) {
                logger.debug("Bulk Response:\n{}", response.getContentAsString());
            }
            systemHelper.reloadConfiguration(resetJobs.get());

            if (logger.isInfoEnabled()) {
                logger.info("Bulk data import completed successfully: fileName={}, resetJobs={}", fileName, resetJobs.get());

    @Test
    public void test_rewrite_multiple_logger_names() {
        String[] loggerNames = { "test.logger", "another.logger", "third.logger" };
        ErrorToWarnRewritePolicy policy = new ErrorToWarnRewritePolicy(loggerNames);

        LogEvent event1 = Log4jLogEvent.newBuilder()
                .setLoggerName("test.logger.sub")
                .setLevel(Level.ERROR)
                .setMessage(new SimpleMessage("test message 1"))

 * future.addListener(new Runnable() {
 *   public void run() {
 *     processedCount.incrementAndGet();
 *     inFlight.remove(name);
 *     lastProcessed.set(name);
 *     logger.info("Done with {0}", name);
 *   }
 * }, executor);
 * }
 *
 * <h3>How to get an instance</h3>
 *
 * <p>We encourage you to return {@code ListenableFuture} from your methods so that your users can

//	   os.SetTransitionState(goi)
//	}
//
// // After the overwriting object operation is complete.
//
//	if jentry, ok := os.ShouldRemoveRemoteObject(); ok {
//	    err := globalTierJournal.AddEntry(jentry)
//	    logger.LogIf(ctx, err)
//	}
type objSweeper struct {
	Object              string
	Bucket              string
	VersionID           string // version ID set by application, applies only to DeleteObject and DeleteObjects APIs