&BaseEndpointInfo{ip: "10.0.1.4", port: 80, endpoint: "10.0.1.4:80", isLocal: false, ready: true, serving: true, terminating: false},
					&BaseEndpointInfo{ip: "10.0.1.5", port: 80, endpoint: "10.0.1.5:80", isLocal: false, ready: true, serving: true, terminating: false},

    for (Operation* op : ready) {
      if (best == nullptr || better(op, best)) {
        best = op;
      }
    }

    if (!best) {
      assert(ready.empty());
      return result;  // happens for unused results for ops in the todo list
    }

    // Consider this operation emitted, and make its results available.
    ready.erase(std::find(ready.begin(), ready.end(), best));
    previous_op = best;

			continue
		}

		var ready bool
		if c.State.Running == nil {
			ready = false
		} else if result, ok := m.readinessManager.Get(kubecontainer.ParseContainerID(c.ContainerID)); ok && result == results.Success {
			ready = true
		} else {
			// The check whether there is a probe which hasn't run yet.
			w, exists := m.getWorker(pod.UID, c.Name, readiness)
			ready = !exists // no readinessProbe -> always ready

	// ready is a synchronization mechanism that causes subtests to execute
	// round robin.
	ready := make([]chan bool, parallel)
	for i := range ready {
		ready[i] = make(chan bool, 1)
	}
	ready[0] <- true

	for i := range ready {
		i := i
		t.Run(fmt.Sprintf("sub-%d", i), func(t *testing.T) {
			t.Parallel()
			for j := 0; j < 2; j++ {
				<-ready[i]
				t.Logf("this is sub-%d", i)

	isLocal bool

	// ready indicates whether this endpoint is ready and NOT terminating, unless
	// PublishNotReadyAddresses is set on the service, in which case it will just
	// always be true.
	ready bool
	// serving indicates whether this endpoint is ready regardless of its terminating state.
	// For pods this is true if it has a ready status regardless of its deletion timestamp.
	serving bool

		return err
	}

	var notReady []string
	var debugInfo map[string]string

	// Check if we are ready immediately, to avoid the 2s delay below when we are already ready
	if ready, _, _, err := waitForResources(objects, client.Kube(), l); err == nil && ready {
		return nil
	}

var (
	ErrNotReady = fmt.Errorf("configuration is not ready")
	ErrDisabled = fmt.Errorf("disabled")
)

type getFunc func() (runtime.Object, error)

// When running, poller calls `get` every `interval`. If `get` is
// successful, `Ready()` returns ready and `configuration()` returns the
// `mergedConfiguration`; if `get` has failed more than `failureThreshold ` times,
// `Ready()` returns not ready and `configuration()` returns nil configuration.

	if !handler.WaitForReady() {
		t.Errorf("Expect ready for no readyFunc provided.")
	}

	// 2. readyFunc return ready immediately
	readyFunc := func() bool {
		return true
	}
	handler.SetReadyFunc(readyFunc)
	if !handler.WaitForReady() {
		t.Errorf("Expect ready for readyFunc returns ready immediately.")
	}

	// 3. readyFunc always return not ready. WaitForReady timeout
	readyFunc = func() bool {
		return false

				select {
				case <-timeout:
					return fmt.Errorf("timeout waiting for Envoy proxy to become ready. Last error: %v", err)
				case <-time.After(time.Duration(periodMillis) * time.Millisecond):
					err = checkIfReady(client, url)
					if err == nil {
						log.Infof("Envoy is ready!")
						return nil
					}
					log.Debugf("Not ready yet: %v", err)
				}
			}
		},
	}
)

		}
	}

	return v1.PodCondition{
		Type:   v1.ContainersReady,
		Status: v1.ConditionTrue,
	}
}

// GeneratePodReadyCondition returns "Ready" condition of a pod.
// The status of "Ready" condition is "True", if all containers in a pod are ready
// AND all matching conditions specified in the ReadinessGates have status equal to "True".