func TestRegisterWatch(t *testing.T) {
	testCases := []struct {
		name     string
		request  *http.Request
		expected *watchIdentifier
	}{
		{
			name:     "watch all objects",
			request:  httpRequest("GET", "/api/v1/pods", "watch=true"),
			expected: newWatchIdentifier("", "pods", "", ""),
		},
		{
			name:     "list all objects",
			request:  httpRequest("GET", "/api/v1/pods", ""),
			expected: nil,
		},
		{

        .addHeader("h2", "v2")
        .streamHandler(body)
        .build(),
    )
    val request =
      Request.Builder()
        .url(server.url("/"))
        .method("POST", AsyncRequestBody())
        .build()
    val call = client.newCall(request)
    call.execute().use { response ->
      val sink = (request.body as AsyncRequestBody?)!!.takeSink()
      sink.writeUtf8("hey\n")

        buf.append("12345ABCDE");
        request.setParameter("userCode", buf.toString());
        assertEquals("12345abcde12345ABCDE", userInfoHelper.getUserCodeFromRequest(request));
        request.setParameter("userCode", buf.toString() + "_");
        assertEquals("12345abcde12345ABCDE_", userInfoHelper.getUserCodeFromRequest(request));
        request.setParameter("userCode", buf.toString() + " ");

    }

    public PluginPrefixResult resolve(PluginPrefixRequest request) throws NoPluginFoundForPrefixException {
        logger.debug("Resolving plugin prefix {} from {}", request.getPrefix(), request.getPluginGroups());

        PluginPrefixResult result = resolveFromProject(request);

        if (result == null) {
            result = resolveFromRepository(request);

            if (result == null) {

	testCases := []struct {
		Request     http.Request
		ExpectedMap []metav1.ServerAddressByClientCIDR
	}{
		{
			Request:     http.Request{},
			ExpectedMap: publicAddressCIDRMap,
		},
		{
			Request: http.Request{
				Header: map[string][]string{
					"X-Real-Ip": {internalIP},
				},
			},
			ExpectedMap: internalAddressCIDRMap,
		},
		{
			Request: http.Request{
				Header: map[string][]string{

        this.executionProperties = executionProperties;
        this.request = new DefaultMavenExecutionRequest();
        this.request.setUserProperties(userProperties);
        this.request.setLocalRepository(localRepository);
        this.request.setGoals(goals);
        this.request.setBaseDirectory((executionRootDir != null) ? new File(executionRootDir) : null);
        this.request.setStartTime(startTime);
        this.result = null;

      client.newBuilder()
        .addInterceptor(Interceptor { throw IOException() })
        .build()
    val request = Request.Builder().url(server.url("/")).build()
    c.newCall(request).enqueue(callback)
    val response = callback.await(request.url)
    assertThat(response.request).isEqualTo(request)
  }

  @Test
  fun reusedSinksGetIndependentTimeoutInstances() {
    server.enqueue(MockResponse())

fun Request.Builder.commonDelete(body: RequestBody?): Request.Builder = method("DELETE", body)

fun Request.Builder.commonPut(body: RequestBody): Request.Builder = method("PUT", body)

fun Request.Builder.commonPatch(body: RequestBody): Request.Builder = method("PATCH", body)

fun Request.Builder.commonMethod(
  method: String,
  body: RequestBody?,
): Request.Builder =
  apply {

		return s.allow(request), nil
	}

	return s.deny(request), nil
}

// ServeHTTP implements the HTTP check request.
func (s *ExtAuthzServer) ServeHTTP(response http.ResponseWriter, request *http.Request) {
	body, err := io.ReadAll(request.Body)
	if err != nil {
		log.Printf("[HTTP] read body failed: %v", err)
	}

		name string
		want RoutingClaim
	}{
		{
			name: "@request.auth.claims",
			want: RoutingClaim{},
		},
		{
			name: "@request.auth.claims-",
			want: RoutingClaim{},
		},
		{
			name: "request.auth.claims.",
			want: RoutingClaim{},
		},
		{
			name: "@request.auth.claims.",
			want: RoutingClaim{},
		},
		{
			name: "@request.auth.claims-abc",
			want: RoutingClaim{},
		},
		{