return proxiesOrNull.toImmutableList()
    }

    connectionUser.proxySelectStart(url)
    proxies = selectProxies()
    nextProxyIndex = 0
    connectionUser.proxySelectEnd(url, proxies)
  }

  /** Returns true if there's another proxy to try. */
  private fun hasNextProxy(): Boolean = nextProxyIndex < proxies.size

  /** Returns the next proxy to try. May be PROXY.NO_PROXY but never null. */

  curves to `P-256`. These restrictions apply on the following data paths:

  * mTLS communication between Envoy proxies;
  * regular TLS on the downstream and the upstream of Envoy proxies (e.g. gateway);
  * Google gRPC side requests from Envoy proxies (e.g. Stackdriver extensions);
  * Istiod xDS server;
  * Istiod injection and validation webhook servers.

class FakeProxySelector : ProxySelector() {
  val proxies: MutableList<Proxy> = mutableListOf()

  fun addProxy(proxy: Proxy): FakeProxySelector {
    proxies.add(proxy)
    return this
  }

  override fun select(uri: URI): List<Proxy> {
    // Don't handle 'socket' schemes, which the RI's Socket class may request (for SOCKS).
    return if (uri.scheme == "http" || uri.scheme == "https") proxies else listOf(Proxy.NO_PROXY)
  }

var (
	// peerProxiedRequestsTotal counts the number of requests that were proxied to a peer kube-apiserver.
	peerProxiedRequestsTotal = metrics.NewCounterVec(
		&metrics.CounterOpts{
			Subsystem:      subsystem,
			Name:           "rerouted_request_total",
			Help:           "Total number of requests that were proxied to a peer kube apiserver because the local apiserver was not capable of serving it",

    assertThat(routeSelector.hasNext()).isFalse()
  }

  @Test fun proxyDnsFailureContinuesToNextProxy() {
    val address = factory.newAddress()
    proxySelector.proxies.add(proxyA)
    proxySelector.proxies.add(proxyB)
    proxySelector.proxies.add(proxyA)
    val routeSelector = newRouteSelector(address)
    proxySelector.assertRequests(address.url.toUri())
    assertThat(routeSelector.hasNext()).isTrue()

            }
        }

        List<Proxy> proxies = settings.getProxies();

        if (proxies != null) {
            Set<String> proxyIds = new HashSet<>();

            for (Proxy proxy : proxies) {
                if (!proxyIds.add(proxy.getId())) {
                    addViolation(
                            problems,

        provider.getOrElse(someOtherValue()) == someValue()
    }

    def "cannot query value when it has none"() {
        given:
        def provider = providerWithNoValue()

        expect:
        !provider.present
        provider.getOrNull() == null
        provider.getOrElse(someValue()) == someValue()

        when:
        provider.get()

        then:

     *
     * @param <T> the provider value type
     */
    static abstract class CircularChainEvaluationSpec<T> extends CircularEvaluationSpec<T> {
        /**
         * Returns a provider-under-test that uses baseProvider for its computation
         * @param baseProvider the provider to wrap
         * @return the provider-under-test

	Conditions: []*v1alpha1.IstioCondition{
		{
			Type:    "PassedValidation",
			Status:  "True",
			Message: "just a test, here",
		},
		{
			Type:    "Reconciled",
			Status:  "False",
			Message: "1/2 proxies up to date.",
		},
	},
	ValidationMessages: nil,
}

func TestReconcileStatuses(t *testing.T) {
	type args struct {
		current *config.Config
		desired Progress
	}
	tests := []struct {
		name  string

Guillaume Nodet <******@****.***> 1664700085 +0200