}
        final SearchResponse response = client.prepareSearch(index)
                .setQuery(QueryBuilders.termQuery(fessConfig.getIndexFieldUrl(), url))
                .setFetchSource(false)
                .setSize(fessConfig.getPageScoreBoosterMaxFetchSizeAsInteger())
                .execute()
                .actionGet(requestTimeout);

    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {
    checkNotNull(expectedThrowable);
    checkNotNull(supplier);

    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {
    checkNotNull(expectedThrowable);
    checkNotNull(supplier);

    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {
    checkNotNull(expectedThrowable);
    checkNotNull(supplier);

  }

  public void testIteratesOnce() {
    Map<AnEnum, AnEnum> map =
        Maps.asMap(
            ImmutableSet.of(AnEnum.A),
            new Function<AnEnum, AnEnum>() {
              boolean used = false;

              @Override
              public AnEnum apply(AnEnum ae) {
                checkState(!used, "should not be applied more than once");
                used = true;
                return ae;

    private static class ServerDataStub extends ServerData {
        public ServerDataStub() {
            this.security = SmbConstants.SECURITY_USER;
            this.encryptedPasswords = false;
            this.encryptionKey = new byte[0];
        }
    }

    @Test
    void anonymousGuestCredentials() throws Exception {
        setupNegotiateStubs();

        boolean groupName;
        int ownerNodeType;
        boolean isBeingDeleted;
        boolean isInConflict;
        boolean isActive;
        boolean isPermanent;
        int j;
        boolean addrFound = false;

        try {
            for (int i = 0; i < numberOfNames; srcIndex += 18, i++) {
                for (j = srcIndex + 14; src[j] == 0x20; j--) {
                    ;
                }

En ese caso, puedes desactivar esta funcionalidad en **FastAPI**, con el parámetro `separate_input_output_schemas=False`.

/// info | Información

El soporte para `separate_input_output_schemas` fue agregado en FastAPI `0.102.0`. 🤓

///

{* ../../docs_src/separate_openapi_schemas/tutorial002_py310.py hl[10] *}

   *
   * @param key key to store in the multimap
   * @param value value to store in the multimap
   * @return {@code true} if the method increased the size of the multimap, or {@code false} if the
   *     multimap already contained the key-value pair
   */
  @CanIgnoreReturnValue
  @Override
  public boolean put(@ParametricNullness K key, @ParametricNullness V value) {

        HandleGuid guid = manager.requestDurableHandle("/test/file.txt", HandleType.DURABLE_V2, 120000, null);

        manager.getHandleForReconnect("/test/file.txt");
        manager.completeReconnect("/test/file.txt", false);

        HandleInfo info = manager.getHandleByGuid(guid);
        assertNull(info);
        assertEquals(0, manager.getHandleCount());
    }

    @Test
    public void testReleaseHandle() {