throw new RuntimeException("Script evaluation failed");
            }
        });

        // Execute and verify exception is propagated
        try {
            scriptExecutor.execute("errorEngine", "test");
            fail("Expected RuntimeException");
        } catch (RuntimeException e) {

          executionThread.start();
        }
      };

  @Override
  protected final void tearDown() {
    tearDownStack.runTearDown();
    assertWithMessage("exceptions should not be propagated to uncaught exception handlers")
        .that(thrownByExecutionThread)
        .isNull();
  }

  public void testServiceStartStop() throws Exception {
    WaitOnRunService service = new WaitOnRunService();

          executionThread.start();
        }
      };

  @Override
  protected final void tearDown() {
    tearDownStack.runTearDown();
    assertWithMessage("exceptions should not be propagated to uncaught exception handlers")
        .that(thrownByExecutionThread)
        .isNull();
  }

  public void testServiceStartStop() throws Exception {
    WaitOnRunService service = new WaitOnRunService();

                List.class);
        method.setAccessible(true);

        // Should not throw - errors should be logged but not propagated
        try {
            method.invoke(authenticator, null, groups, roles, groupIds);
            Thread.sleep(200); // Wait for async execution
        } catch (Exception e) {

   *
   * <p>If the call {@code setFuture(delegate)} is accepted and this {@code Future} is later
   * cancelled, cancellation will be propagated to {@code delegate}. Additionally, any call to
   * {@code setFuture} after any cancellation will propagate cancellation to the supplied {@code
   * Future}.
   *
   * <p>Note that, even if the supplied future is cancelled and it causes this future to complete,

        assertNotNull(groovyEngine.evaluate("return container", null));
    }

    // ===== Exception Handling Tests =====

    /**
     * Test that JobProcessingException is propagated
     */
    @Test
    public void test_evaluate_jobProcessingExceptionPropagates() {
        final Map<String, Object> params = new HashMap<>();
        try {

        });
        try {
            systemHelper.destroy();
            assertTrue(true);
        } catch (Exception e) {
            fail("Exception should be caught and not propagated");
        }
    }

    @Test
    public void test_getHelpUrl() {
        getMockRequest().setLocale(Locale.ENGLISH);

   *     href="https://github.com/google/guava/wiki/Why-we-deprecated-Throwables.propagate">Why we
   *     deprecated {@code Throwables.propagate}</a>.
   */
  @CanIgnoreReturnValue
  @J2ktIncompatible
  @GwtIncompatible
  @Deprecated
  public static RuntimeException propagate(Throwable throwable) {
    throwIfUnchecked(throwable);
    throw new RuntimeException(throwable);
  }

   *     href="https://github.com/google/guava/wiki/Why-we-deprecated-Throwables.propagate">Why we
   *     deprecated {@code Throwables.propagate}</a>.
   */
  @CanIgnoreReturnValue
  @J2ktIncompatible
  @GwtIncompatible
  @Deprecated
  public static RuntimeException propagate(Throwable throwable) {
    throwIfUnchecked(throwable);
    throw new RuntimeException(throwable);
  }

 *
 * <ul>
 *   <li>While calls to {@code submit} and {@code submitAsync} return a {@code Future} that can be
 *       cancelled, cancellation never propagates to a task that has started to run -- neither to
 *       the callable itself nor to any {@code Future} returned by an {@code AsyncCallable}.