public class BiMapClearTester<K, V> extends AbstractBiMapTester<K, V> {
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testClearClearsInverse() {
    BiMap<V, K> inv = getMap().inverse();
    getMap().clear();
    assertTrue(getMap().isEmpty());
    assertTrue(inv.isEmpty());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testKeySetClearClearsInverse() {
    BiMap<V, K> inv = getMap().inverse();

public class QueuePollTester<E> extends AbstractQueueTester<E> {
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(ZERO)
  public void testPoll_empty() {
    assertNull("emptyQueue.poll() should return null", getQueue().poll());
    expectUnchanged();
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(ONE)
  public void testPoll_size1() {

 */
class RecordedResponse(
  @JvmField val request: Request,
  val response: Response?,
  val webSocket: WebSocket?,
  val body: String?,
  val failure: IOException?,
) {
  fun assertRequestUrl(url: HttpUrl) =
    apply {
      assertThat(request.url).isEqualTo(url)
    }

  fun assertRequestMethod(method: String) =
    apply {
      assertThat(request.method).isEqualTo(method)
    }

public class ListAddTester<E> extends AbstractListTester<E> {
  @CollectionFeature.Require(SUPPORTS_ADD)
  @CollectionSize.Require(absent = ZERO)
  public void testAdd_supportedPresent() {
    assertTrue("add(present) should return true", getList().add(e0()));
    expectAdded(e0());
  }

  @CollectionFeature.Require(absent = SUPPORTS_ADD)
  @CollectionSize.Require(absent = ZERO)
  /*
   * absent = ZERO isn't required, since unmodList.add() must

public class MapForEachTester<K, V> extends AbstractMapTester<K, V> {
  @CollectionFeature.Require(KNOWN_ORDER)
  public void testForEachKnownOrder() {
    List<Entry<K, V>> entries = new ArrayList<>();
    getMap().forEach((k, v) -> entries.add(entry(k, v)));
    assertEquals(getOrderedElements(), entries);
  }

  @CollectionFeature.Require(absent = KNOWN_ORDER)
  public void testForEachUnknownOrder() {

}

// Returns access credentials in the request Authorization header.
func getReqAccessCred(r *http.Request, region string) (cred auth.Credentials) {
	cred, _, _ = getReqAccessKeyV4(r, region, serviceS3)
	if cred.AccessKey == "" {
		cred, _, _ = getReqAccessKeyV2(r)
	}
	return cred
}

// Extract request params to be sent with event notification.
func extractReqParams(r *http.Request) map[string]string {
	if r == nil {

from fastapi import FastAPI, Request

app = FastAPI(
    servers=[
        {"url": "https://stag.example.com", "description": "Staging environment"},
        {"url": "https://prod.example.com", "description": "Production environment"},
    ],
    root_path="/api/v1",
)


@app.get("/app")
def read_main(request: Request):

from fastapi import FastAPI, Request
from fastapi.testclient import TestClient
from inline_snapshot import snapshot

app = FastAPI(openapi_prefix="/api/v1")


@app.get("/app")
def read_main(request: Request):
    return {"message": "Hello World", "root_path": request.scope.get("root_path")}


client = TestClient(app)


def test_main():
    response = client.get("/app")
    assert response.status_code == 200

_2023-04-22_

 *  Fix: Don't fail the call when the response code is ‘HTTP 102 Processing’ or
    ‘HTTP 103 Early Hints’.
 *  Fix: Read the response even if writing the request fails. This means you'll get a proper HTTP
    response even if the server rejects your request body.
 *  Fix: Use literal IP addresses directly rather than passing them to `DnsOverHttps`.

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class ListRetainAllTester<E> extends AbstractListTester<E> {
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testRetainAll_duplicatesKept() {
    E[] array = createSamplesArray();
    array[1] = e0();
    collection = getSubjectGenerator().create(array);
    assertFalse(