public WebApiManager get(HttpServletRequest req) {
                assertSame(request, req);
                return null;
            }
        };
        ComponentUtil.register(factory, "webApiManagerFactory");

        // Execute
        webApiFilter.doFilter(request, response, chain);

        // Verify chain was called
        assertTrue(chainCalled.get());
    }

    )
    return Token(access_token=access_token, token_type="bearer")


@app.get("/users/me/")
async def read_users_me(current_user: User = Depends(get_current_active_user)) -> User:
    return current_user


@app.get("/users/me/items/")
async def read_own_items(current_user: User = Depends(get_current_active_user)):

        job.process(runtime);

        // Verify the JobLog was stored with the pre-generated ID
        assertNotNull(storedJobLog.get());
        assertEquals("pregenerated-abc123", storedJobLog.get().getId());
        assertEquals(Constants.OK, storedJobLog.get().getJobStatus());
    }

    @Test
    public void test_process_withoutJobLogId_idRemainsNull() {

  }

  /**
   * @since 33.4.0 (but since 28.1 in the JRE flavor)
   */
  public static SpliteratorTester<Long> ofLong(Supplier<Spliterator.OfLong> spliteratorSupplier) {
    return new SpliteratorTester<>(
        ImmutableSet.of(
            () -> new GeneralSpliteratorOfObject<>(spliteratorSupplier.get()),
            () -> new GeneralSpliteratorOfPrimitive<>(spliteratorSupplier.get(), c -> c::accept)));

  }

  /**
   * @since 28.1 (but only since 33.4.0 in the Android flavor)
   */
  public static SpliteratorTester<Long> ofLong(Supplier<Spliterator.OfLong> spliteratorSupplier) {
    return new SpliteratorTester<>(
        ImmutableSet.of(
            () -> new GeneralSpliteratorOfObject<>(spliteratorSupplier.get()),

      assertThat(mapCache.get(key)).isEqualTo(key + "_value");
    }
  }

  @Test
  public void testPutNewValue() {
    assertThat(mapCache.put("key", "value")).isNull();
    assertThat(mapCache.get("key")).isEqualTo("value"); // ensure key/value is cached
    assertThat(mapCache.put("key", "new value")).isEqualTo("value");
    assertThat(mapCache.get("key")).isEqualTo("new value");
  }

  @Test

            return str(v)

    @app.get("/get_custom_class")
    def return_some_user():
        # Test that the fix also works for custom pydantic classes
        return SomeCustomClass(a_uuid=MyUuid("b8799909-f914-42de-91bc-95c819218d01"))

    client = TestClient(app)

    with client:
        response_simple = client.get("/fast_uuid")
        response_pydantic = client.get("/get_custom_class")

        AssertionError,
        match="Query parameter 'q' must be one of the supported types",
    ):
        app = FastAPI()

        class Item(BaseModel):
            title: str

        @app.get("/items/")
        def read_items(q: list[Item] = Query(default=None)):
            pass  # pragma: no cover


def test_invalid_tuple():
    with pytest.raises(
        AssertionError,

): Cache = Cache(fileSystem, file, maxSize)

internal var RealConnection.idleAtNsAccessor: Long
  get() = idleAtNs
  set(value) {
    idleAtNs = value
  }

internal val Response.exchangeAccessor: Exchange?
  get() = this.exchange

internal val Exchange.connectionAccessor: RealConnection
  get() = this.connection

    public void test() throws Exception {
        final Map<String, Integer> map = map("a", 1).$("b", 2).$("c", 3).$();
        assertThat(map.size(), is(3));
        assertThat(map.get("a"), is(1));
        assertThat(map.get("b"), is(2));
        assertThat(map.get("c"), is(3));
    }