import org.gradle.internal.operations.notify.BuildOperationNotificationListenerRegistrar;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.Collection;

/**
 * Captures the state to recreate the {@link GradleEnterprisePluginService} instance.
 * <p>
 * The adapter is created on check-in in {@link DefaultGradleEnterprisePluginCheckInService} via {@link DefaultGradleEnterprisePluginAdapterFactory}.

  // items is the list of CSIStorageCapacity objects.
  // +listType=map
  // +listMapKey=name
  repeated CSIStorageCapacity items = 2;
}

// VolumeAttachment captures the intent to attach or detach the specified volume
// to/from the specified node.
//
// VolumeAttachment objects are non-namespaced.
message VolumeAttachment {
  // Standard object metadata.

        task.descendant('Clean stale outputs')
    }

    //This is the current behavior. Snapshotting might become not-a-task-action in the future.
    // NOTE: This operation captures more than just snapshotting, and will be removed in a later release in favor of separate snapshotting operations
    def "snapshot task inputs action has an informative name"() {
        given:

//
// The execution trace captures a wide range of execution events such as
// goroutine creation/blocking/unblocking, syscall enter/exit/block,
// GC-related events, changes of heap size, processor start/stop, etc.
// When CPU profiling is active, the execution tracer makes an effort to
// include those samples as well.
// A precise nanosecond-precision timestamp and a stack trace is

        then:
        1 * workerProcess.stopNow()
        _ * workerProcess.waitForStop() >> { throw new ExecException("waitForStop can throw") }
        notThrown(ExecException)
    }

    def "captures and rethrows unrecoverable exceptions thrown by the connection"() {
        def handler
        def processor = newProcessor()

        when:
        processor.processTestClass(Mock(TestClassRunInfo))

            }
        """

        when:
        succeeds 'help'

        then:
        output =~ /> Outer\s+< Outer\s+Inner/
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)
    def "captures lifecycle operations"() {
        given:
        file('buildSrc/buildSrcWhenReady.gradle') << ""
        file('buildSrc/build.gradle') << """
            gradle.taskGraph.whenReady {

import org.junit.Assume

import static org.hamcrest.CoreMatchers.is

abstract class AbstractJUnit4LoggingOutputCaptureIntegrationTest extends AbstractJUnitLoggingOutputCaptureIntegrationTest {
    def "captures logging output events"() {
        // This test checks behavior introduced in JUnit 4.13
        Assume.assumeTrue(VersionNumber.parse(version) >= VersionNumber.parse("4.13"))

        file("src/test/java/OkTest.java") << """

        state.didWork
        state.outcome == TaskExecutionOutcome.EXECUTED
        !state.executing
        !state.failure
        state.actionable

        noMoreInteractions()
    }

    def "captures exceptions from async work"() {
        given:
        task.getTaskActions() >> [action1, action2]
        task.hasTaskActions() >> true

        when:
        executer.execute(task, state, executionContext)

}

func (CSIStorageCapacityList) SwaggerDoc() map[string]string {
	return map_CSIStorageCapacityList
}

var map_VolumeAttachment = map[string]string{
	"":         "VolumeAttachment captures the intent to attach or detach the specified volume to/from the specified node.\n\nVolumeAttachment objects are non-namespaced.",

        expect:
        Try.ofFailable { throw failure } == Try.failure(failure)
        Try.ofFailable { throw runtimeFailure } == Try.failure(runtimeFailure)
    }

    def "captures result"() {
        expect:
        Try.ofFailable { result } == Try.successful(result)

        where:
        result << [['a', 'b', 'c'], "Some string", 5]
    }

    def "successful (flat) map"() {