executor);
    assertFinallyFailsWithException(closingFuture);
    waitUntilClosed(closingFuture);
    assertClosed(closeable1, closeable2);
  }

  public void testTransformAsync_failed() throws Exception {
    ClosingFuture<Object> closingFuture =
        ClosingFuture.from(immediateFuture("value"))
            .transformAsync(
                new AsyncClosingFunction<String, Object>() {

            String path,
            InterpolationException e,
            String locationKey) {
        problems.add(
                Severity.ERROR,
                ModelProblem.Version.BASE,
                "Failed to interpolate file location " + path + ": " + e.getMessage(),
                target.getLocation(locationKey),
                e);
    }

    private static boolean isNotEmpty(String string) {

            if (response.getHttpStatusCode() == 200) {
                return true;
            }
            logger.warn("Failed to reindex from {} to {}", fromIndex, toIndex);
        } catch (final IOException e) {
            logger.warn("Failed to reindex from {} to {}", fromIndex, toIndex, e);
        }
        return false;
    }

                                logger.warn("Failed to build parent project for " + project.getId(), e);
                            } else {
                                // Message below is checked for in the MNG-2199 core IT.
                                logger.warn("Failed to build parent project for " + project.getId());
                            }
                        }

    if (ATOMIC_HELPER.casValue(this, null, valueToSet)) {
      complete(this, /*callInterruptTask=*/ false);
      return true;
    }
    return false;
  }

  /**
   * Sets the failed result of this {@code Future} unless this {@code Future} has already been
   * cancelled or set (including {@linkplain #setFuture set asynchronously}). When a call to this

                try {
                    chainedResponse = sessionSetup(request, response);
                }
                catch ( GeneralSecurityException e ) {
                    throw new SmbException("Session setup failed", e);
                }

                if ( chainedResponse != null && chainedResponse.isReceived() ) {
                    return chainedResponse;
                }

            if (logger.isDebugEnabled()) {
                logger.debug("Failed to process a scroll request.", e);
            }
            writeJsonResponse(HttpServletResponse.SC_BAD_REQUEST, e);
        } catch (final Exception e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to process a scroll request.", e);
            }

                    logger.debug("Login failed. No permissions. {}", context);
                }
                return OptionalEntity.empty();
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Logged in. {}", context);
            }
            return OptionalEntity.of(ldapUser);
        } catch (final Exception e) {
            logger.debug("Login failed.", e);
        }

            doSend(request);
        }
        catch ( IOException ioe ) {
            log.warn("send failed", ioe);
            try {
                disconnect(true);
            }
            catch ( IOException ioe2 ) {
                ioe.addSuppressed(ioe2);
                log.error("disconnect failed", ioe2);
            }
            throw ioe;
        }
    }

   * primary input fails with the given {@code exceptionType}, from the result provided by the
   * {@code fallback}. {@link Function#apply} is not invoked until the primary input has failed, so
   * if the primary input succeeds, it is never invoked. If, during the invocation of {@code
   * fallback}, an exception is thrown, this exception is used as the result of the output {@code
   * Future}.
   *