if (originalListener != null) {
            context.outputEventListener = originalListener
        }
        if (originalLevel != null) {
            context.level = originalLevel
        }
    }

    void setLevel(LogLevel level) {
        context.level = level
    }

    void createJar(MavenModule mavenModule, File artifactFile) {
        try {
            artifactFile.withOutputStream { stream ->
                ZipOutputStream out = new ZipOutputStream(stream)
                out.setLevel(Deflater.NO_COMPRESSION)
                try {
                    addZipEntry(out, artifactFile.name + ".properties", "testcontent")
                    if (minimumSizeKB > 0) {
                        int sizeInBytes

                final Level sourceLevel = event.getLevel();
                if (sourceLevel != Level.ERROR) {
                    return event;
                }
                return new Log4jLogEvent.Builder(event).setLevel(Level.WARN).build();
            }
        }
        return event;
    }

    @PluginFactory
    public static ErrorToWarnRewritePolicy createPolicy(@PluginAttribute("loggers") final String loggerNamePrefix) {

        LoggingSourceSystem stdout = new DefaultStdOutLoggingSystem(getStdoutListener(), get(Clock.class));
        stdout.setLevel(LogLevel.QUIET);
        LoggingSourceSystem stderr = new DefaultStdErrLoggingSystem(new TextStreamOutputEventListener(outputEventBroadcaster), get(Clock.class));
        stderr.setLevel(LogLevel.ERROR);
        return new DefaultLoggingManagerFactory(
            renderer,

        when:
        logger.trace("trace")

        then:
        0 * _._
    }

    def delegatesLevelIsEnabledToSlf4j() {

        when:
        logging.setLevel(LogLevel.WARN)

        then:
        Logger logger = Logging.getLogger(LoggingTest.class)
        logger.errorEnabled
        logger.quietEnabled
        logger.warnEnabled
        !logger.lifecycleEnabled

        }

        logger = loggers.putIfAbsent(name, new OutputEventListenerBackedLogger(name, this, clock));
        return logger != null ? logger : loggers.get(name);
    }

    public void reset() {
        setLevel(DEFAULT_LOG_LEVEL);
        DefaultUserInputReceiver userInputReceiver = new DefaultUserInputReceiver();
        OutputEventRenderer renderer = new OutputEventRenderer(clock, userInputReceiver);

            .setSleeper(sleeper));
    }

    private static void disableHttpTransportLogging() {
        java.util.logging.Logger.getLogger(HttpTransport.class.getName()).setLevel(java.util.logging.Level.OFF);
    }

        logLevel = snapshot.logLevel;
        if (enabled) {
            install();
        } else {
            uninstall();
        }
    }

    @Override
    public Snapshot setLevel(LogLevel logLevel) {
        Snapshot snapshot = snapshot();
        if (logLevel != this.logLevel) {
            this.logLevel = logLevel;
            if (enabled) {
                outstr.flush();

	public final fun level (Lokhttp3/logging/HttpLoggingInterceptor$Level;)V
	public final fun redactHeader (Ljava/lang/String;)V
	public final fun redactQueryParams ([Ljava/lang/String;)V
	public final fun setLevel (Lokhttp3/logging/HttpLoggingInterceptor$Level;)Lokhttp3/logging/HttpLoggingInterceptor;
}

public final class okhttp3/logging/HttpLoggingInterceptor$Companion {
}

	if p.options.defaultDirection == RightToLeft {
		lvl = 1
	}
	para, err := newParagraph(p.types, p.pairTypes, p.pairValues, lvl)
	if err != nil {
		return Ordering{}, err
	}

	levels := para.getLevels([]int{len(p.types)})

	p.o = calculateOrdering(levels, p.runes)
	return p.o, nil
}

// Line computes the visual ordering of runs for a single line starting and