@Test
    @DisplayName("Should create CIFSException with message and cause")
    void testCIFSExceptionWithCause() {
        // Given
        String message = "CIFS operation failed";
        Exception cause = new RuntimeException("Root cause");

        // When
        CIFSException exception = new CIFSException(message, cause);

        // Then
        assertNotNull(exception);
        assertEquals(message, exception.getMessage());

        try {
            return makeAccessible(type.getDeclaredMethod(methodName, paramTypes));
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }

    private static Method makeAccessible(Method method) {
        method.setAccessible(true);
        return method;
    }

    spy.verifyCallCount(2);
  }

  @J2ktIncompatible
  @GwtIncompatible // lazyTransform
  public void testLazyTransform_exception() throws Exception {
    RuntimeException exception = new RuntimeException("deliberate");
    Function<Integer, String> function =
        unused -> {
          throw exception;
        };
    Future<String> transformed = lazyTransform(immediateFuture(1), function);

    spy.verifyCallCount(2);
  }

  @J2ktIncompatible
  @GwtIncompatible // lazyTransform
  public void testLazyTransform_exception() throws Exception {
    RuntimeException exception = new RuntimeException("deliberate");
    Function<Integer, String> function =
        unused -> {
          throw exception;
        };
    Future<String> transformed = lazyTransform(immediateFuture(1), function);

            mockContext = new BaseContext(config);
            response = new SmbComNegotiateResponse(mockContext);
        } catch (Exception e) {
            throw new RuntimeException("Failed to set up test", e);
        }
    }

    @Test
    public void testConstructor() {
        assertNotNull(response);
        assertEquals(DialectVersion.SMB1, response.getSelectedDialect());
    }

  public void testRuntimeExceptionFromGet() {
    RuntimeException e = new IllegalArgumentException("foo not found");
    ListenableFuture<String> f = UncheckedThrowingFuture.throwingRuntimeException(e);
    MockCallback callback = new MockCallback(e);
    addCallback(f, callback, directExecutor());
  }

  public void testOnSuccessThrowsRuntimeException() throws Exception {
    RuntimeException exception = new RuntimeException();

        String username = "testuser";
        FessUserNotFoundException originalException = new FessUserNotFoundException(username);

        try {
            throw new RuntimeException("Wrapper exception", originalException);
        } catch (RuntimeException e) {
            assertEquals("Wrapper exception", e.getMessage());
            assertNotNull(e.getCause());
            assertTrue(e.getCause() instanceof FessUserNotFoundException);

    }

    @Test
    public void test_getErrors() throws Exception {
        List<Throwable> errors = new ArrayList<>();
        errors.add(new Exception("Error 1"));
        errors.add(new RuntimeException("Error 2"));

        SuggestDeleteResponse response = new SuggestDeleteResponse(errors, 100);

        assertNotNull(response.getErrors());
        assertEquals(2, response.getErrors().size());
    }

            taskResult.setException(error);
          }
        };
    Thread runner = new Thread(task);
    runner.start();
    isInterruptibleRegistered.await();
    RuntimeException expected = assertThrows(RuntimeException.class, task::interruptTask);
    assertThat(expected)
        .hasMessageThat()
        .isEqualTo("I bet you didn't think Thread.interrupt could throw");
    /*

            taskResult.setException(error);
          }
        };
    Thread runner = new Thread(task);
    runner.start();
    isInterruptibleRegistered.await();
    RuntimeException expected = assertThrows(RuntimeException.class, task::interruptTask);
    assertThat(expected)
        .hasMessageThat()
        .isEqualTo("I bet you didn't think Thread.interrupt could throw");
    /*