method.setAccessible(true);
            return (ClassificationMeta) method.invoke(obj, param);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

        },
        directExecutor());
    assertThat(called[0]).isTrue();
  }

  // Avoid trouble with automatic mapping between JRE and Kotlin runtime classes.
  static class CustomRuntimeException extends RuntimeException {}

  public void testCatching() throws Exception {
    FluentFuture<?> f =
        FluentFuture.from(immediateFailedFuture(new CustomRuntimeException()))
            .catching(
                Throwable.class,

        InvalidAccessTokenException exception = new InvalidAccessTokenException(type, message);

        assertTrue(exception instanceof FessSystemException);
        assertTrue(exception instanceof RuntimeException);
        assertTrue(exception instanceof Exception);
        assertTrue(exception instanceof Throwable);
    }

    public void test_throwAndCatch() {
        // Test throwing and catching the exception

        try {
            Field f = findField(target.getClass(), name);
            f.setAccessible(true);
            f.set(target, value);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    // Utility: reflectively get a private/protected field (searches up the hierarchy)
    private static Object getField(Object target, String name) {
        try {

                    try {
                        return File.createTempFile(prefix, suffix);
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }
            };
            ComponentUtil.register(mockSystemHelper, "systemHelper");

            // Register mock FessConfig

        //     int accessFlags = convertAccessFlags(access);
        //     memoryRegister = endpoint.registerMemory(buffer, accessFlags).execute().free();
        // } catch (Exception e) {
        //     throw new RuntimeException("Failed to register memory region", e);
        // }

        this.memoryRegister = new Object(); // Placeholder

        log.debug("DiSNI memory region registered, size: {}", buffer.remaining());
    }

            java.lang.reflect.Field f = target.getClass().getDeclaredField(name);
            f.setAccessible(true);
            return f.get(target);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

      throws InterruptedException {

    int count = 10;
    AtomicInteger callCount = new AtomicInteger();
    CountDownLatch startSignal = new CountDownLatch(count + 1);
    RuntimeException e = new RuntimeException();

    LoadingCache<String, String> cache =
        builder.build(
            new CacheLoader<String, String>() {
              @Override

        }
    }

    public void test_setError_withException_noRequest() {
        // Test setError with exception when no HTTP request is available
        try {
            WebApiUtil.setError(500, new RuntimeException("Test error"));
        } catch (Exception e) {
            fail("setError should handle missing request gracefully: " + e.getMessage());
        }
    }

    public void test_setError_withNullMessage() {

            @Override
            public int getRid() {
                return 0;
            }

            @Override
            public String toDisplayString() {
                throw new RuntimeException("Test exception");
            }

            @Override
            public String getAccountName() {
                return "TestUser";
            }

            @Override