@Test fun connectExceptionsAreReturnedAsSuppressed() {
    val proxySelector = RecordingProxySelector()
    proxySelector.proxies.add(Proxy(Proxy.Type.HTTP, TestUtil.UNREACHABLE_ADDRESS_IPV4))
    proxySelector.proxies.add(Proxy.NO_PROXY)
    server.shutdown()

    client =
      client.newBuilder()
        .proxySelector(proxySelector)
        .readTimeout(Duration.ofMillis(100))
        .connectTimeout(Duration.ofMillis(100))

import okhttp3.internal.toImmutableList

/**
 * A specification for a connection to an origin server. For simple connections, this is the
 * server's hostname and port. If an explicit proxy is requested (or [no proxy][Proxy.NO_PROXY] is
 * explicitly requested), this also includes that proxy information. For secure connections the
 * address also includes the SSL socket factory, hostname verifier, and certificate pinner.
 *

    protected CurlRequest createCurlRequest(final String url) {
        final CurlRequest request = Curl.get(url);
        final Proxy proxy = ComponentUtil.getFessConfig().getHttpProxy();
        if (proxy != null && !Proxy.NO_PROXY.equals(proxy)) {
            request.proxy(proxy);
        }
        return request;
    }

    public void deleteInstalledArtifact(final Artifact artifact) {

    }
  }

  internal enum class ProxyConfig {
    NO_PROXY {
      override fun connect(
        server: MockWebServer,
        client: OkHttpClient,
      ): Call.Factory {
        return client.newBuilder()
          .proxy(Proxy.NO_PROXY)
          .build()
      }
    },
    CREATE_ARG {
      override fun connect(

    assertThat(connectStart.call).isSameAs(call)
    assertThat(connectStart.inetSocketAddress).isEqualTo(expectedAddress)
    assertThat(connectStart.proxy).isEqualTo(Proxy.NO_PROXY)
    val connectEnd = listener.removeUpToEvent<CallEvent.ConnectEnd>()
    assertThat(connectEnd.call).isSameAs(call)
    assertThat(connectEnd.inetSocketAddress).isEqualTo(expectedAddress)

    builder = builder.writeTimeout(Duration.ofSeconds(0L))
    builder = builder.pingInterval(0L, TimeUnit.SECONDS)
    builder = builder.pingInterval(Duration.ofSeconds(0L))
    builder = builder.proxy(Proxy.NO_PROXY)
    builder = builder.proxySelector(NullProxySelector)
    builder = builder.cookieJar(CookieJar.NO_COOKIES)
    builder = builder.cache(Cache(File("/cache/"), Integer.MAX_VALUE.toLong()))

     * precedence over [proxySelector], which is only honored when this proxy is null (which it is
     * by default). To disable proxy use completely, call `proxy(Proxy.NO_PROXY)`.
     */
    fun proxy(proxy: Proxy?) =
      apply {
        if (proxy != this.proxy) {
          this.routeDatabase = null
        }
        this.proxy = proxy
      }

    /**

                        }
                    });
                }
            } else {
                proxy = Proxy.NO_PROXY;
            }
            propMap.put(HTML_PROXY, proxy);
        }
        return proxy;
    }

    String getThumbnailHtmlImageExcludeExtensions();

    client =
      client.newBuilder()
        .proxySelector(
          FakeProxySelector()
            .addProxy(server2.toProxyAddress())
            .addProxy(Proxy.NO_PROXY),
        )
        .build()
    server2.shutdown()
    val request =
      Request(
        url = server.url("/"),
        body = "abc".toRequestBody("text/plain".toMediaType()),
      )

*   The httpstream/spdy calls now support CIDR notation for NO_PROXY ([#54413](https://github.com/kubernetes/kubernetes/pull/54413),[ @kad](https://github.com/kad))