def stream2 = new PrintStream(new ByteArrayOutputStream())

        given:
        loggingSystem.restore(loggingSystem.startCapture())
        stream = stream2

        when:
        def snapshot = loggingSystem.startCapture()

        then:
        stream != stream2

        when:
        loggingSystem.restore(snapshot)

        then:
        stream == stream2
    }

        when:
        configurer.startCapture()

        then:
        Logger.getLogger("").getLevel() == null
    }

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

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

        when:
        loggingSystem.startCapture()

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

    def canSetLogLevelBeforeAndAfterEnabled() {
        when:
        loggingSystem.setLevel(LogLevel.DEBUG)

        then:
        0 * loggingConfigurer._

        when:
        loggingSystem.startCapture()

        then:

     * Logging systems that have no intrinsic levels should generate events at the specified logging level.
     *
     * <p>This method should not have any effect when capture is not enabled for this logging system using {@link #startCapture()}.</p>
     *
     * @param logLevel The minimum log level.
     * @return the state of this logging system immediately before the changes are applied.
     */
    Snapshot setLevel(LogLevel logLevel);

    /**

    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) {}

    private Snapshot dummy() {
        return new Snapshot() {};
    }

        then:
        1 * stdOutLoggingSystem.snapshot() >> stdOutSnapshot
        1 * stdErrLoggingSystem.snapshot() >> stdErrSnapshot
        1 * stdOutLoggingSystem.startCapture()
        1 * stdErrLoggingSystem.startCapture()
        0 * stdOutLoggingSystem._
        0 * stdErrLoggingSystem._

        when:
        loggingManager.stop()

        then:

            if (installed) {
                logger.setLevel(LOG_LEVEL_MAPPING.get(logLevel));
            }
        }
        return snapshot;
    }

    @Override
    public Snapshot startCapture() {
        Snapshot snapshot = snapshot();
        install(LOG_LEVEL_MAPPING.get(requestedLevel));
        return snapshot;
    }

    @Override
    public void restore(Snapshot state) {

            this.logLevel = logLevel;
            if (enabled) {
                configurer.configure(logLevel);
            }
        }
        return snapshot;
    }

    @Override
    public Snapshot startCapture() {
        Snapshot snapshot = snapshot();
        if (!enabled) {
            enabled = true;
            configurer.configure(logLevel);
        }
        return snapshot;
    }

    @Override

            originalState = loggingSystem.snapshot();
            if (level != null) {
                loggingSystem.setLevel(level);
            }
            if (enabled) {
                loggingSystem.startCapture();
            }
        }

        /**
         * Start capturing events from this logging system. Does not take effect until started.
         */
        public void enableCapture() {

                outstr.flush();
                outputEventListener.onOutput(new LogLevelChangeEvent(logLevel));
            }
        }
        return snapshot;
    }

    @Override
    public Snapshot startCapture() {
        Snapshot snapshot = snapshot();
        if (!enabled) {
            install();
        }
        return snapshot;
    }

    private void uninstall() {
        if (original != null) {