assertNotNull(stats);
        assertTrue((long) stats.get("totalAllocated") >= 2);
        assertTrue((long) stats.get("totalReleased") >= 1);
        assertNotNull(stats.get("activeResources"));
        assertNotNull(stats.get("closedResources"));
    }

    @Test
    @DisplayName("Test get active resources")
    void testGetActiveResources() {

security = HTTPBearer(description="HTTP Bearer token scheme")


@app.get("/users/me")
def read_current_user(credentials: HTTPAuthorizationCredentials = Security(security)):
    return {"scheme": credentials.scheme, "credentials": credentials.credentials}


client = TestClient(app)


def test_security_http_bearer():
    response = client.get("/users/me", headers={"Authorization": "Bearer foobar"})

        testFilesCleanupService.get().addTaskReports(path, validatePluginsReports())
    }

    project.tasks.withType<FindBrokenInternalLinks>().configureEach {
        testFilesCleanupService.get().addTaskReports(path, findBrokenInternalLinksReports())
    }
    project.tasks.withType<DistributionTest>().configureEach {
        testFilesCleanupService.get().addTaskReports(path, distributionReports())
    }

def get_data_override():
    return [3, 4, 5]


@app.get("/user")
def read_user(
    user_data: tuple[str, list[str]] = Security(get_user, scopes=["foo", "bar"]),
    data: list[int] = Depends(get_data),
):
    return {"user": user_data[0], "scopes": user_data[1], "data": data}


client = TestClient(app)


def test_normal():
    response = client.get("/user")
    assert response.json() == {
        "user": "john",

]


@app.get("/items/stream", response_class=EventSourceResponse)
async def sse_items() -> AsyncIterable[Item]:
    for item in items:
        yield item


@app.get("/items/stream-no-async", response_class=EventSourceResponse)
def sse_items_no_async() -> Iterable[Item]:
    for item in items:
        yield item


@app.get("/items/stream-no-annotation", response_class=EventSourceResponse)

    assertThat(f.get()).isEqualTo(CustomRuntimeException.class);
  }

  public void testCatchingAsync() throws Exception {
    FluentFuture<?> f =
        FluentFuture.from(immediateFailedFuture(new CustomRuntimeException()))
            .catchingAsync(Throwable.class, t -> immediateFuture(t.getClass()), directExecutor());
    assertThat(f.get()).isEqualTo(CustomRuntimeException.class);
  }

    for (int i = 0; i < cellList.size(); i++) {
      Cell<R, C, V> cell = cellList.get(i);
      R rowKey = cell.getRowKey();
      C columnKey = cell.getColumnKey();
      // The requireNonNull calls are safe because we construct the indexes with indexMap.
      int rowIndex = requireNonNull(rowKeyToIndex.get(rowKey));
      int columnIndex = requireNonNull(columnKeyToIndex.get(columnKey));
      V existingValue = values[rowIndex][columnIndex];

     */
    public WitnessUnregisterRequest() {
        // Default constructor
    }

    private String registrationId;
    private byte[] contextHandle;

    /**
     * Gets the registration ID to unregister.
     *
     * @return the registration ID
     */
    public String getRegistrationId() {
        return registrationId;
    }

    /**

  TF_DeviceList* devices = TFE_ContextListDevices(ctx, status.get());
  CHECK_EQ(TF_OK, TF_GetCode(status.get())) << TF_Message(status.get());

  const int num_devices = TF_DeviceListCount(devices);
  for (int i = 0; i < num_devices; ++i) {
    const string dev_type(TF_DeviceListType(devices, i, status.get()));
    CHECK_EQ(TF_GetCode(status.get()), TF_OK) << TF_Message(status.get());

    void testGetPath() {
        // Given
        String path = "/test/path";
        when(mockReferralData.getPath()).thenReturn(path);

        // When
        String result = mockReferralData.getPath();

        // Then
        assertEquals(path, result);
        verify(mockReferralData).getPath();
    }

    @Test
    @DisplayName("Should get expiration")
    void testGetExpiration() {