}

            } catch (Exception e) {
                log.error("Failed to register for witness notifications", e);
                throw new RuntimeException(e);
            }
        });
    }

    /**
     * Unregisters from witness notifications.
     *
     * @param registration the registration to remove

            if (copy.locations != null) {
                copy.locations = new java.util.LinkedHashMap(copy.locations);
            }

            return copy;
        } catch (Exception ex) {
            throw (RuntimeException)
                    new UnsupportedOperationException(getClass().getName() + " does not support clone()").initCause(ex);
        }
    } // -- InputLocation clone()

    /**

    try {
      return generator.invoke(this, args);
    } catch (InvocationTargetException e) {
      throwIfUnchecked(e.getCause());
      throw new RuntimeException(e.getCause());
    } catch (Exception e) {
      throwIfUnchecked(e);
      throw new RuntimeException(e);
    }
  }

  private final class FreshInvocationHandler extends AbstractInvocationHandler {
    private final int identity = generateInt();

        assertNotNull(errorHandler, "Error handler should not be null");

        // Test error classification for different exception types
        Exception hardwareError = new RuntimeException("RDMA hardware not supported");
        Exception networkError = new java.io.IOException("Network connection failed");
        Exception timeoutError = new java.net.SocketTimeoutException("Operation timed out");

                                roleSet.addAll(fessConfig.getSearchGuestRoleList());
                            }
                        });
            } catch (final RuntimeException e) {
                try {
                    requestManager.findLoginManager(FessUserBean.class).ifPresent(LoginManager::logout);
                } catch (final Exception e1) {
                    // ignore

   * </ul>
   */
  public void testNulls(Class<?> cls) {
    try {
      doTestNulls(cls, Visibility.PACKAGE);
    } catch (Exception e) {
      throwIfUnchecked(e);
      throw new RuntimeException(e);
    }
  }

  void doTestNulls(Class<?> cls, Visibility visibility)
      throws ParameterNotInstantiableException,
          IllegalAccessException,
          InvocationTargetException,

              }
              throw new NoSuchFieldError("the Unsafe");
            }
          });
    } catch (PrivilegedActionException e) {
      throw new RuntimeException("Could not initialize intrinsics", e.getCause());
    }
  }

            clone.currentProject = ThreadLocal.withInitial(() -> current);
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException("Bug", e);
        }
    }

    @Deprecated
    public Date getStartTime() {
        return request.getStartTime();
    }

    public Instant getStartInstant() {

            if (t instanceof Exception exception && !(t instanceof RuntimeException)) {
                eventCatapult.fire(ExecutionEvent.Type.ProjectFailed, session, null, exception);
            }

            // reactor failure modes
            if (t instanceof RuntimeException || !(t instanceof Exception)) {
                // fail fast on RuntimeExceptions, Errors and "other" Throwables

                false,
                isolatedClassLoader
            );
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("Failed to load class " + name + ". Incorrect test runtime classpath?", e);
        }
    }

    private URL fileToUrl(File file) {
        try {
            return file.toURI().toURL();