public String load(String key) throws InterruptedException {
            int behavior = random.nextInt(4);
            if (behavior == 0) { // throw an exception
              exceptionCount.incrementAndGet();
              throw new RuntimeException("fake exception for test");
            } else if (behavior == 1) { // return null
              computeNullCount.incrementAndGet();
              return null;

        try {
            userService.changePassword(username, form.newPassword);
            saveInfo(messages -> messages.addSuccessChangedPassword(GLOBAL));
        } catch (final Exception e) {
            logger.warn("Failed to change password for {}", username, e);
            throwValidationError(messages -> messages.addErrorsFailedToChangePassword(GLOBAL), toIndexPage);
        }

    } finally {
      logger.removeHandler(logHandler);
    }

    assertEquals(1, logHandler.getStoredLogRecords().size());
    assertThat(logHandler.getStoredLogRecords().get(0).getMessage())
        .isEqualTo("Exception while executing callback: MyListener custom-label");
  }

  public void testEnqueueAndDispatch_multithreaded() throws InterruptedException {
    Object listener = new Object();

    } finally {
      logger.removeHandler(logHandler);
    }

    assertEquals(1, logHandler.getStoredLogRecords().size());
    assertThat(logHandler.getStoredLogRecords().get(0).getMessage())
        .isEqualTo("Exception while executing callback: MyListener custom-label");
  }

  public void testEnqueueAndDispatch_multithreaded() throws InterruptedException {
    Object listener = new Object();

                        rr.getPolicy(true).isEnabled(),
                        rr.getPolicy(true).getUpdatePolicy(),
                        rr.getPolicy(false).getChecksumPolicy());

            } catch (Exception e) {
                throw new RuntimeException("Unable to create repository", e);
            }
        } else {
            // TODO
            throw new UnsupportedOperationException("Not yet implemented");

                if (reactorContext.getReactorBuildStatus().isHalted()) {
                    break;
                }
            } catch (Exception e) {
                session.getResult().addException(e);
                break;
            }
        }

        executor.shutdown();
        executor.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);

     * @return The result from the supplier (either fresh or cached)
     * @throws RuntimeException Any exception thrown by the supplier will be cached and re-thrown on subsequent calls
     */
    <REQ extends Request<?>, REP extends Result<REQ>> REP request(REQ req, Function<REQ, REP> supplier);

    /**
     * Executes and optionally caches a batch of requests using the provided supplier function.

   * function that also supports reverse conversion.
   *
   * <p>If you are okay with {@code null} being returned for an unrecognized key (instead of an
   * exception being thrown), you can use the method reference {@code map::get} instead. Note that
   * it is not serializable unless you explicitly make it {@link Serializable}, typically by writing

                fos = null; // Successfully wrapped, no need to close explicitly
            } catch (final Exception e) {
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (final IOException ioe) {
                        // Ignore close exception
                    }
                }
                if (newFile != null) {

    private RelatedQueryHelper relatedQueryHelper;
    private MockRelatedQueryBhv mockBhv;
    private VirtualHostHelper virtualHostHelper;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);

        // Setup system properties for DI container
        File file = File.createTempFile("test", ".properties");
        file.deleteOnExit();