def snapshot = loggingSystem.snapshot()
        loggingSystem.setLevel(LogLevel.ERROR)
        loggingSystem.startCapture()
        def capturing = stream

        when:
        loggingSystem.restore(snapshot)
        capturing.println("info-1")
        stream.println('info-2')

        then:
        stream == originalStream

 * inputs provided by injected services. For this to be possible, a capturing
 * instantiator "session" must be created before the instance is created. This
 * must be done by calling the {@link #capturing(ImplicitInputRecorder)} method
 * which provides a registrar which will record implicit inputs.
 *
 * Not all services have to be capturing. Only services implementing the

Grouping:

	(re)           numbered capturing group (submatch)
	(?P<name>re)   named & numbered capturing group (submatch)
	(?<name>re)    named & numbered capturing group (submatch)
	(?:re)         non-capturing group
	(?flags)       set flags within current group; non-capturing
	(?flags:re)    set flags during re; non-capturing

     * unique test sources (e.g. JUnit4 vs JUnit5).
     */
    interface TestSourceGenerator {
        void writeAllSources(TestSourceFixture fixture)
    }

    /**
     * Fixture for capturing test source requirements.  This will be provided to a {@link TestSourceGenerator} to generate the test sources.
     */
    class TestSourceFixture {
        List<TestClass> testClasses = []

     * Gets and clears the context of the build operation designed to measure the time taken
     * by capturing input snapshotting and cache key calculation.
     */
    Optional<BuildOperationContext> removeSnapshotTaskInputsBuildOperationContext();

    /**
     * Sets the context for the build operation designed to measure the time taken
     * by capturing input snapshotting and cache key calculation.
     */

    TestResultProcessor target = Mock()
    TestOutputRedirector redirector = Mock()
    @Subject processor = new CaptureTestOutputTestResultProcessor(target, redirector)

    def "starts capturing output"() {
        def suite = new DefaultTestSuiteDescriptor("1", "Foo")
        def event = new TestStartEvent(1)

        when:
        processor.started(suite, event)

        // This is a performance hack. We could use the regular fingerprint of the input artifact, but that takes longer than
        // capturing the normalized path and the snapshot of the raw contents, so we are using these to determine the identity.

        'method reference'       | { -> createLambdaSnapshot(TestLambdas.createMethodRefLambda()) }
        'static field capturing' | { -> createLambdaSnapshot(TestLambdas.createClassCapturingLambda()) }
        'instance capturing'     | { -> createLambdaSnapshot(TestLambdas.createInstanceCapturingLambda()) }
    }

	Rune     []rune     // matched runes, for OpLiteral, OpCharClass
	Rune0    [2]rune    // storage for short Rune
	Min, Max int        // min, max for OpRepeat
	Cap      int        // capturing index, for OpCapture
	Name     string     // capturing name, for OpCapture
}

//go:generate stringer -type Op -trimprefix Op

// An Op is a single regular expression operator.
type Op uint8

	// regexp has capturing groups for the domain and name part omitting
	// the separating forward slash from either.
	NameRegexp = expression(
		optional(DomainRegexp, literal(`/`)),
		nameComponentRegexp,
		optional(repeated(literal(`/`), nameComponentRegexp)))

	// ReferenceRegexp is the full supported format of a reference. The regexp
	// is anchored and has capturing groups for name, tag, and digest
	// components.