package v1

// ContainerStateApplyConfiguration represents an declarative configuration of the ContainerState type for use
// with apply.
type ContainerStateApplyConfiguration struct {
	Waiting    *ContainerStateWaitingApplyConfiguration    `json:"waiting,omitempty"`
	Running    *ContainerStateRunningApplyConfiguration    `json:"running,omitempty"`
	Terminated *ContainerStateTerminatedApplyConfiguration `json:"terminated,omitempty"`
}

        when:
        def waiting = server.expectConcurrentAndBlock("a-waiting", "b-waiting")
        def done = server.expectAndBlock("b-done")
        def build = executer.withArguments("--parallel").withTasks("run").start()

        waiting.waitForAllPendingCalls()
        waiting.release("b-waiting")
        done.waitForAllPendingCalls()
        done.releaseAll()
        waiting.releaseAll()

// and all the runners are waiting for work.
// (Then all the runners return.)
func (w *Work[T]) runner() {
	for {
		// Wait for something to do.
		w.mu.Lock()
		for len(w.todo) == 0 {
			w.waiting++
			if w.waiting == w.running {
				// All done.
				w.wait.Broadcast()
				w.mu.Unlock()
				return
			}
			w.wait.Wait()
			w.waiting--
		}

		// Pick something to do at random,

		plugin, waitTime := k, v
		wp.pendingPlugins[plugin] = time.AfterFunc(waitTime, func() {
			msg := fmt.Sprintf("rejected due to timeout after waiting %v at plugin %v",
				waitTime, plugin)
			wp.Reject(plugin, msg)
		})
	}

	return wp
}

// GetPod returns a reference to the waiting pod.
func (w *waitingPod) GetPod() *v1.Pod {
	return w.pod
}

// GetPendingPlugins returns a list of pending permit plugin's name.

                // Closed
                return -1;
            }
        }
    }

    private void waitForContent() {
        if (readPos == buffer.length && !waiting && !closed) {
            eventDispatch.onOutput(new ReadStdInEvent());
            waiting = true;
        }
        while (readPos == buffer.length && !closed) {
            try {
                lock.wait();
            } catch (InterruptedException e) {

func (fakeServerShutdownSignal) ShuttingDown() <-chan struct{} { return nil }

type fakeRequestWaitGroup struct {
	waiting           bool
	invoked, inflight int
}

func (f *fakeRequestWaitGroup) Add(delta int) error {
	f.invoked++
	if f.waiting {
		return fmt.Errorf("waitgroup is in waiting mode")
	}
	f.inflight += delta
	return nil
}
func (f *fakeRequestWaitGroup) Done() { f.inflight-- }

// progress into a single line. For example "Waiting for x, y, z". Once a component completes, we want
// a new line created so the information is not lost. To do this, we spin up a new bar with the remaining components
// on a new line, and create a new bar. For example, this becomes "x succeeded", "waiting for y, z".
func (p *Log) reportProgress(component string) func() {
	return func() {

    "podIPs": [
      {
        "ip": "ipValue"
      }
    ],
    "startTime": "2007-01-01T01:01:01Z",
    "initContainerStatuses": [
      {
        "name": "nameValue",
        "state": {
          "waiting": {
            "reason": "reasonValue",
            "message": "messageValue"
          },
          "running": {
            "startedAt": "2001-01-01T01:01:01Z"
          },
          "terminated": {

    @Override
    public void registerWork(BuildOperationRef operation, AsyncWorkCompletion workCompletion) {
        lock.lock();
        try {
            if (waiting.contains(operation)) {
                throw new IllegalStateException("Another thread is currently waiting on the completion of work for the provided operation");
            }
            items.put(operation, workCompletion);
        } finally {
            lock.unlock();

	runtime_notifyListWait(&c.notify, t)
	c.L.Lock()
}

// Signal wakes one goroutine waiting on c, if there is any.
//
// It is allowed but not required for the caller to hold c.L
// during the call.
//
// Signal() does not affect goroutine scheduling priority; if other goroutines
// are attempting to lock c.L, they may be awoken before a "waiting" goroutine.
func (c *Cond) Signal() {
	c.checker.check()