return {"foo": foo}


@app.get("/multiple")
async def multiple(foo: Annotated[str, object(), Query(min_length=1)]):
    return {"foo": foo}


@app.get("/unrelated")
async def unrelated(foo: Annotated[str, object()]):
    return {"foo": foo}


client = TestClient(app)

foo_is_missing = {
    "detail": [
        {
            "loc": ["query", "foo"],

              chain!!.proceed(
                chain.request(),
              )
            responsesNotClosed.add(response)
            response
              .newBuilder()
              .body("unrelated response body!".toResponseBody(null))
              .build()
          },
        ).build()
    server.enqueue(
      MockResponse(
        code = 301,
        headers = headersOf("Location", "/b"),

	DB.Model(&blog).Association("Tags").Delete(tag3)
	var tags4 []Tag
	DB.Model(&blog).Association("Tags").Find(&tags4)
	if !compareTags(tags4, []string{"tag6"}) {
		t.Fatalf("Tag should not be deleted when Delete with a unrelated tag")
	}

	// Clear
	DB.Model(&blog).Association("Tags").Clear()
	if DB.Model(&blog).Association("Tags").Count() != 0 {
		t.Fatalf("All tags should be cleared")
	}
}

        }

        else -> {
          throw expected
        }
      }
    }
  }

  /**
   * Attack the CA intermediates check by presenting unrelated chains to the handshake vs.
   * certificate pinner.
   *
   * This chain is valid but not pinned:
   *
   * ```
   *   attackerCa
   *    -> phonyVictim
   * ```
   *
   *

   * a view of the multiset whose elements are of this class. A multiset implementation may return
   * Entry instances that are either live "read-through" views to the Multiset, or immutable
   * snapshots. Note that this type is unrelated to the similarly-named type {@code Map.Entry}.
   *
   * @since 2.0
   */
  interface Entry<E extends @Nullable Object> {

    /**

   * a view of the multiset whose elements are of this class. A multiset implementation may return
   * Entry instances that are either live "read-through" views to the Multiset, or immutable
   * snapshots. Note that this type is unrelated to the similarly-named type {@code Map.Entry}.
   *
   * @since 2.0
   */
  interface Entry<E extends @Nullable Object> {

    /**

   * recommended that users of this method override {@link CacheLoader#reload} with an asynchronous
   * implementation; otherwise refreshes will be performed during unrelated cache read and write
   * operations.
   *
   * <p>Currently automatic refreshes are performed when the first stale request for an entry
   * occurs. The request triggering refresh will make a synchronous call to {@link

    assertThat(recordedRequest2.requestLine).isEqualTo("GET /bar HTTP/1.1")
    assertThat(recordedRequest2.connectionIndex).isEqualTo(0)
    assertThat(recordedRequest2.exchangeIndex).isEqualTo(1)

    // an unrelated request should reuse the pooled connection
    val request3 = Request.Builder().url(server.url("/baz")).build()
    val response3 = client.newCall(request3).execute()
    assertThat(response3.body.string()).isEqualTo("DEF")

    }
  }

  /**
   * Confirm that we don't send the Proxy-Authorization header from the request to the proxy server.
   * We used to have that behavior but it is problematic because unrelated requests end up sharing
   * credentials. Worse, that approach leaks proxy credentials to the origin server.
   */
  @Test
  fun noPreemptiveProxyAuthorization() {

behavior to limit requests from node API clients, so that each Node can only get / list / watch its own Node API object, and can also only get / list / watch Pod API objects bound to that node. Clients using kubelet credentials to read other nodes or unrelated pods must change their authentication credentials (recommended), adjust their usage, or obtain broader read access independent of the node authorizer. ([#125571](https://github.com/kubernetes/kubernetes/pull/125571), [@liggitt](https://github.com/liggitt))...