} catch (Exception e) { // sneaky checked exception
      // ListenableFuture's contract is that it will not throw unchecked exceptions, so log the bad
      // runnable and/or executor and swallow it.
      log.get()
          .log(
              Level.SEVERE,
              "RuntimeException while executing runnable "
                  + listener
                  + " with executor "
                  + executor,
              e);

    }

    /**
     * Test that runtime exceptions in scripts return null
     */
    @Test
    public void test_evaluate_runtimeExceptionReturnsNull() {
        final Map<String, Object> params = new HashMap<>();
        // Division by zero
        assertNull(groovyEngine.evaluate("return 1 / 0", params));
    }

    // ===== Script Execution Tests =====

    /**

            auth1.equals(auth2);
        }
    }

    /**
     * Test that password comparison is constant-time by comparing execution times
     * for passwords that differ at different positions.
     */
    @Test
    public void testConstantTimePasswordComparison() throws Exception {

   * fails.
   */
  final void awaitTermination(Thread t) {
    awaitTermination(t, LONG_DELAY_MS);
  }

  // Some convenient Runnable classes

  // These classes don't merely allow checked exceptions but also store any exceptions that occur
  // so that we can then report them during tearDown.

  abstract class CheckedRunnable implements Runnable {
    abstract void realRun() throws Throwable;

    @Override

        createRequiredDirectories();

        // Setup failed process execution
        mockProcessHelper.setExitValue(1);
        mockProcessHelper.setOutput("Suggest creation failed");

        String result = suggestJob.execute();

        assertNotNull(result);
        assertTrue(result.contains("Session Id:"));
        // The actual execution catches exceptions so we can't guarantee Exit Code in output
    }

          log.log(
              Level.SEVERE,
              "RuntimeException while executing runnable "
                  + runnable
                  + " with executor "
                  + executor,
              e);
        }
      }
    }
  }

  // A version of the execution list that doesn't reverse the stack in execute().
  private static final class NewExecutionListWithoutReverse {

        assertNull(exception.getCause());
    }

    @Test
    public void test_constructor_withMessageAndCause() {
        // Test constructor with message and cause
        String message = "Script execution failed";
        Exception cause = new RuntimeException("Underlying error");
        ScriptEngineException exception = new ScriptEngineException(message, cause);

        assertEquals(message, exception.getMessage());

          log.log(
              Level.SEVERE,
              "RuntimeException while executing runnable "
                  + runnable
                  + " with executor "
                  + executor,
              e);
        }
      }
    }
  }

  // A version of the execution list that doesn't reverse the stack in execute().
  private static final class NewExecutionListWithoutReverse {

        boolean log = !(service instanceof NoOpService);
        /*
         * We have already exposed startup exceptions to the user in the form of suppressed
         * exceptions. We don't need to log those exceptions again.
         */
        log &= from != State.STARTING;
        if (log) {
          logger
              .get()
              .log(

                assertTrue(true, "Sign operation after close should either throw exception or handle gracefully");
            } catch (RuntimeException e) {
                // Accept runtime exceptions that might be thrown due to closed state
                assertTrue(e.getMessage() != null, "Exception should have a message: " + e.getClass().getSimpleName());
            }

            try {