when:
        configurer.startCapture()
        configurer.setLevel(LogLevel.LIFECYCLE)
        configurer.setLevel(LogLevel.DEBUG)

        then:
        Logger.getLogger("").getLevel() == Level.FINE
    }

    def "Log level can be changed before starting"() {
        when:
        configurer.setLevel(LogLevel.LIFECYCLE)
        configurer.setLevel(LogLevel.DEBUG)
        configurer.startCapture()

        })

        cleanup:
        currentBuildOperationRef.clear()
    }

    def onChangesLogLevelsWhenAlreadyCapturing() {
        loggingSystem.setLevel(LogLevel.INFO)
        loggingSystem.startCapture()

        when:
        loggingSystem.setLevel(LogLevel.DEBUG)
        stream.println('info')

        then:

        when:
        loggingSystem.setLevel(LogLevel.DEBUG)

        then:
        0 * loggingConfigurer._

        when:
        loggingSystem.startCapture()

        then:
        1 * loggingConfigurer.configure(LogLevel.DEBUG)
        0 * loggingConfigurer._

        when:
        loggingSystem.setLevel(LogLevel.INFO)

        then:

        logger = Logger.getLogger("");
    }

    @Override
    public Snapshot setLevel(LogLevel logLevel) {
        Snapshot snapshot = snapshot();
        if (logLevel != requestedLevel) {
            requestedLevel = logLevel;
            if (installed) {
                logger.setLevel(LOG_LEVEL_MAPPING.get(logLevel));
            }
        }
        return snapshot;
    }

    @Override

```java
HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
logging.setLevel(Level.BASIC);
OkHttpClient client = new OkHttpClient.Builder()
  .addInterceptor(logging)
  .build();
```

You can change the log level at any time by calling `setLevel()`.

To log to a custom location, pass a `Logger` instance to the constructor.
```java

     * @return the state of this logging system immediately before the changes are applied.
     */
    Snapshot setLevel(LogLevel logLevel);

    /**
     * Enables generation of logging events from this logging system. This method is always called after {@link #setLevel(LogLevel)}.
     *
     * @return the state of this logging system immediately before the changes are applied.
     */
    Snapshot startCapture();

  override fun beforeEach(context: ExtensionContext?) {
    previousLevel = logger.level
    logger.addHandler(handler)
    logger.setLevel(Level.FINEST)
  }

  override fun afterEach(context: ExtensionContext?) {
    logger.setLevel(previousLevel)
    logger.removeHandler(handler)
  }

  override fun apply(
    base: Statement,
    description: Description,
  ): Statement {

public class NoOpLoggingSystem implements StdOutLoggingSystem, StdErrLoggingSystem, LoggingSourceSystem {
    @Override
    public Snapshot snapshot() {
        return dummy();
    }

    @Override
    public Snapshot setLevel(LogLevel logLevel) {
        return dummy();
    }

    @Override
    public Snapshot startCapture() {
        return dummy();
    }

    @Override
    public void restore(Snapshot state) {}

        //(SF) checking if the logger level was not overridden.
        //this gives some confidence that the LogManager was not reset
        given:
        LogManager.getLogManager().getLogger("").setLevel(OFF);
        buildFile << "task hey"

        when:
        assertJavaUtilLoggingNotModified()

        Logger rootLogger = Logger.getLogger("");
        rootLogger.setLevel(Level.ALL);
        ConsoleHandler handler = new ConsoleHandler();
        handler.setFormatter(new SimpleFormatter());
        handler.setLevel(Level.ALL);
        rootLogger.addHandler(handler);
    }

    @Override
    public void tearDown() throws Exception {