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()

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",

	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

            }
        }

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

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

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

      The expected impacts of this change is improved performance of configuration distribution.
      This may result in reduced CPU and memory utilization in Istiod and proxies, as well as less network traffic between the two.
      Note that while this release changes the *protocol* to be incremental, Istio does not yet send perfect minimal incremental updates.

import okhttp3.internal.format

class RecordingProxySelector : ProxySelector() {
  @JvmField val proxies = mutableListOf<Proxy>()

  private val requestedUris = mutableListOf<URI>()
  private val failures = mutableListOf<String>()

  override fun select(uri: URI): List<Proxy> {
    requestedUris.add(uri)
    return proxies
  }

  fun assertRequests(vararg expectedUris: URI?) {

                        "proxy: " + proxy.getId(),
                        -1,
                        -1,
                        e));
            }

            proxies.add(proxy);
        }

        return new DefaultSettingsDecryptionResult(servers, proxies, problems);
    }

    private String decrypt(String str) throws SecDispatcherException {
        return (str == null) ? null : securityDispatcher.decrypt(str);
    }

| `minio_cluster_replication_proxied_head_requests_total` | (_Site Replication Only_)Number of HEAD requests proxied to replication target                          |
| `minio_cluster_replication_proxied_delete_tagging_requests_total` | (_Site Replication Only_)Number of DELETE tagging requests proxied to replication target                          |

            MavenExecutionRequest request = session.getRequest();

            if (request != null) {
                List<Proxy> proxies = request.getProxies();

                if (proxies != null) {
                    for (Proxy proxy : proxies) {
                        if (proxy.isActive() && protocol.equalsIgnoreCase(proxy.getProtocol())) {
                            SettingsDecryptionResult result =