}

		var rootCAs *x509.CertPool
		if opts != nil && opts.CADir != "" {
			rootCAs, err = certs.GetRootCAs(opts.CADir)
			if err != nil {
				return nil, err
			}
		}

		client, err := kms.NewClient(&kms.Config{
			Endpoints: endpoints,
			APIKey:    key,
			TLS: &tls.Config{
				MinVersion:         tls.VersionTLS12,
				ClientSessionCache: tls.NewLRUClientSessionCache(tlsClientSessionCacheSize),

      this.uriPort = ******@****.***t
    }

  private lateinit var call: RealCall
  private val routeDatabase = RouteDatabase()

  @BeforeEach fun setUp() {
    call =
      clientTestRule.newClient().newCall(
        Request.Builder()
          .url("https://$uriHost:$uriPort/")
          .build(),
      ) as RealCall
  }

  @AfterEach fun tearDown() {
    factory.close()
  }

	if err := sa.AddReaderKubeSource([]local.ReaderSource{{Name: "", Reader: strings.NewReader(wh)}}); err != nil {
		return err
	}
	k, err := kube.NewClient(kube.NewClientConfigForRestConfig(config), "")
	if err != nil {
		return err
	}
	sa.AddRunningKubeSourceWithRevision(k, revision, false)
	res, err := sa.Analyze(make(chan struct{}))
	if err != nil {

func WithRevision(revision string) ClientOption {
	return func(c CLIClient) CLIClient {
		client := c.(*client)
		client.revision = revision
		return client
	}
}

// NewClient creates a Kubernetes client from the given rest config.
func NewClient(clientConfig clientcmd.ClientConfig, cluster cluster.ID) (Client, error) {
	return newClientInternal(newClientFactory(clientConfig, false), WithCluster(cluster))
}

// and Start it when the Manager is Started. It also provides additional options to modify internal reconciler behavior.
func Add(mgr manager.Manager, options *Options) error {
	restConfig = mgr.GetConfig()
	kubeClient, err := kube.NewClient(kube.NewClientConfigForRestConfig(restConfig), "")
	if err != nil {
		return fmt.Errorf("create Kubernetes client: %v", err)
	}

  @RegisterExtension
  public val clientTestRule =
    OkHttpClientTestRule().apply {
      logger = Logger.getLogger(OkHttpTest::class.java.name)
    }

  private var client: OkHttpClient = clientTestRule.newClient()

  private val moshi =
    Moshi.Builder()
      .add(KotlinJsonAdapterFactory())
      .build()

  private val handshakeCertificates = localhost()

  private lateinit var server: MockWebServer

@Tag("Slow")
class InterceptorTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()
  private lateinit var server: MockWebServer
  private var client = clientTestRule.newClient()
  private val callback = RecordingCallback()

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server
  }

  @Test
  fun applicationInterceptorsCanShortCircuitResponses() {

			config.Burst = args.RegistryOptions.KubeOptions.KubernetesAPIBurst
		})
		if err != nil {
			return fmt.Errorf("failed creating kube config: %v", err)
		}

		s.kubeClient, err = kubelib.NewClient(kubelib.NewClientConfigForRestConfig(kubeRestConfig), s.clusterID)
		if err != nil {
			return fmt.Errorf("failed creating kube client: %v", err)
		}
		s.kubeClient = kubelib.EnableCrdWatcher(s.kubeClient)
	}

  private lateinit var server: MockWebServer
  private lateinit var server2: MockWebServer
  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private var client = clientTestRule.newClient()
  private var cache: Cache? = null

  @BeforeEach
  fun setUp(
    server: MockWebServer,
    @MockWebServerInstance("server2") server2: MockWebServer,
  ) {
    this.server = server

		{"DefaultRPCPath", Const, 0},
		{"DefaultServer", Var, 0},
		{"Dial", Func, 0},
		{"DialHTTP", Func, 0},
		{"DialHTTPPath", Func, 0},
		{"ErrShutdown", Var, 0},
		{"HandleHTTP", Func, 0},
		{"NewClient", Func, 0},
		{"NewClientWithCodec", Func, 0},
		{"NewServer", Func, 0},
		{"Register", Func, 0},
		{"RegisterName", Func, 0},
		{"Request", Type, 0},
		{"Request.Seq", Field, 0},