thread.blockUntil.requested2
            stream.received(bytes2)
        }

        then:
        1 * dispatch.onOutput({ it instanceof ReadStdInEvent }) >> { instant.requested1 }
        1 * dispatch.onOutput({ it instanceof ReadStdInEvent }) >> { instant.requested2 }
    }

    def "read bytes returns when stream is closed"() {
        def dispatch = Mock(OutputEventListener)
        def stream = new StdInStream(dispatch)

import org.gradle.performance.measure.DataSeries

import java.time.Instant

/**
 * Each instance represents a performance execution, i.e. a row in performance execution database
 */
class PerformanceReportScenarioHistoryExecution {
    private static final int ENOUGH_REGRESSION_CONFIDENCE_THRESHOLD = 90
    Instant time
    String teamCityBuildId
    String commitId
    String shortCommitId

            notifier.run();
            changeOrCancellationArrived.await();
            while (!cancellationToken.isCancellationRequested()) {
                Instant now = nowFromMonotonicClock();
                Instant endOfQuietPeriod = lastChangeAt.plus(quietPeriod);
                if (!endOfQuietPeriod.isAfter(now)) {
                    break;
                }

    @Override
    protected LocalDateTime toLocalDateTime(final Object value) {
        if (value != null) {
            try {
                final Instant instant = Instant.from(DateTimeFormatter.ISO_INSTANT.parse(value.toString()));
                return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
            } catch (final DateTimeParseException e) {
                logger.debug("Invalid date format: {}", value, e);
            }

            connection.run(action, handler)
            instant.dispatched
        }

        then:
        1 * actionExecuter.run(action) >> {
            thread.blockUntil.dispatched
            instant.actionStarted
            return "result"
        }
        1 * handler.onComplete("result") >> {
            instant.resultReceived
        }

        and:
        instant.actionStarted < instant.resultReceived
    }

    @Override
    protected LocalDateTime toLocalDateTime(final Object value) {
        if (value != null) {
            try {
                final Instant instant = Instant.from(DateTimeFormatter.ISO_INSTANT.parse(value.toString()));
                return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
            } catch (final DateTimeParseException e) {
                logger.debug("Invalid date format: {}", value, e);
            }

    @Override
    protected LocalDateTime toLocalDateTime(final Object value) {
        if (value != null) {
            try {
                final Instant instant = Instant.from(DateTimeFormatter.ISO_INSTANT.parse(value.toString()));
                return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
            } catch (final DateTimeParseException e) {
                logger.debug("Invalid date format: {}", value, e);
            }

            instant.idle
            assert result == DaemonStopState.Clean
        }

        then:
        stopped
        instant.idle > instant.actionFinished

        and:
        1 * onStartCommand.run()
        1 * command.run() >> {
            instant.actionStarted
            thread.block()
            instant.actionFinished
        }
        0 * _._
    }

/**
 * A target for blocking. Exposes each named instant as a property, and accessing that property will block until the
 * instant has been reached.
 */
class BlockTarget {
    private final Instants instants

    BlockTarget(Instants instants) {
        this.instants = instants
    }

    def getProperty(String name) {
        instants.waitFor(name)
        true
    }

limitations under the License.
*/

package debug

import (
	"time"

	"k8s.io/apiserver/pkg/endpoints/request"
	flowcontrolrequest "k8s.io/apiserver/pkg/util/flowcontrol/request"
)

// QueueSetDump is an instant dump of queue-set.
type QueueSetDump struct {
	Queues                     []QueueDump
	QueuelessExecutingRequests []RequestDump
	Waiting                    int
	Executing                  int