tests themselves and not the code being tested that needs that access, though there's no
    obvious way to ensure that.

    We could consider arranging things so that only the tests we know need this would get
    the add-opens. Right now that doesn't seem worth the effort, though.
    -->
    <test.add.opens>
      --add-opens java.base/java.lang=ALL-UNNAMED

    public void test_serialization() {
        // Test that the serialVersionUID is properly defined
        // This test verifies that the class can be instantiated and has the serial version UID
        ServletException servletException = new ServletException("Serialization test");
        ServletRuntimeException runtimeException = new ServletRuntimeException(servletException);

 * take advantage of the {@linkplain Futures utilities built atop the class}. The way that you will
 * create {@code ListenableFuture} instances depends on how you currently create {@code Future}
 * instances:
 *
 * <ul>
 *   <li>If you receive them from an {@code java.util.concurrent.ExecutorService}, convert that

 * take advantage of the {@linkplain Futures utilities built atop the class}. The way that you will
 * create {@code ListenableFuture} instances depends on how you currently create {@code Future}
 * instances:
 *
 * <ul>
 *   <li>If you receive them from an {@code java.util.concurrent.ExecutorService}, convert that

        // if removeAll returns true, all we really know is that at least one subscriber was
        // removed... however, barring something very strange we can assume that if at least one
        // subscriber was removed, all subscribers on listener for that event type were... after
        // all, the definition of subscribers on a particular class is totally static

    }

    public void test_oneWayCryptography() {
        // Test that one-way cryptographer is available
        OneWayCryptographer cryptographer = securityResourceProvider.providePrimaryOneWayCryptographer();
        assertNotNull(cryptographer);
    }

    public void test_oneWayCryptography_consistency() {
        // Test that same cryptographer instance is returned

  }

  /**
   * Returns a synchronized (thread-safe) table backed by the specified table. In order to guarantee
   * serial access, it is critical that <b>all</b> access to the backing table is accomplished
   * through the returned table.
   *
   * <p>It is imperative that the user manually synchronize on the returned table when accessing any
   * of its collection views:
   *
   * {@snippet :

**Standalone code to reproduce the issue**
Provide a reproducible test case that is the bare minimum necessary to generate
the problem. If possible, please share a link to or attach code demonstrating
the problem.

**Any other info / logs**
Include any logs or source code that would be helpful to diagnose the problem.
If including tracebacks, please include the full traceback. Large logs and files

type string string

// int is a signed integer type that is at least 32 bits in size. It is a
// distinct type, however, and not an alias for, say, int32.
type int int

// uint is an unsigned integer type that is at least 32 bits in size. It is a
// distinct type, however, and not an alias for, say, uint32.
type uint uint

// uintptr is an integer type that is large enough to hold the bit pattern of
// any pointer.

        this.retryDelay = retryDelay;
    }

    /**
     * Attempt to reconnect a handle
     * @param path the file path
     * @param cause the original exception that triggered reconnection
     * @return a future that completes with the reconnected handle info or fails
     */
    public CompletableFuture<HandleInfo> reconnectHandle(String path, Exception cause) {