checkNotNull(throwable);
    if (throwable instanceof RuntimeException) {
      throw (RuntimeException) throwable;
    }
    if (throwable instanceof Error) {
      throw (Error) throwable;
    }
  }

  /**
   * Propagates {@code throwable} exactly as-is, if and only if it is an instance of {@link
   * RuntimeException} or {@link Error}.
   *

    }

    @Test
    public void testExceptionChaining() {
        IOException rootCause = new IOException("Root cause");
        RuntimeException intermediateCause = new RuntimeException("Intermediate", rootCause);
        CurlException exception = new CurlException("Final message", intermediateCause);

        assertEquals("Final message", exception.getMessage());

        SuggestWriterResult result = new SuggestWriterResult();

        result.addFailure(new Exception("Exception"));
        result.addFailure(new RuntimeException("RuntimeException"));
        result.addFailure(new IllegalStateException("IllegalStateException"));
        result.addFailure(new NullPointerException("NullPointerException"));

        when(supplier.get()).thenThrow(new RuntimeException(new SmbUnsupportedOperationException("boom")));

        // Act & Assert: the exception is propagated and interaction recorded once
        RuntimeException thrown = assertThrows(RuntimeException.class, supplier::get);
        assertInstanceOf(SmbUnsupportedOperationException.class, thrown.getCause());
        assertEquals("boom", thrown.getCause().getMessage());

    try {
      CountDownLatch latch = new CountDownLatch(1);
      RuntimeException expected =
          assertThrows(RuntimeException.class, () -> GcFinalization.await(latch));
      assertWrapsInterruptedException(expected);
    } finally {
      interruptenator.shutdown();
      Thread.interrupted();
    }
  }

            byte[] actualFileId = (byte[]) fileIdField.get(request);
            assertArrayEquals(expectedFileId, actualFileId);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Test
    @DisplayName("Test constructor with Configuration and FileId")
    void testConstructorWithConfigAndFileId() {
        request = new Smb2SetInfoRequest(mockConfig, testFileId);

  public static <V> ListenableFuture<V> throwingRuntimeException(RuntimeException e) {
    UncheckedThrowingFuture<V> future = new UncheckedThrowingFuture<V>();
    future.complete(checkNotNull(e));
    return future;
  }

  public static <V> UncheckedThrowingFuture<V> incomplete() {
    return new UncheckedThrowingFuture<V>();
  }

  public void complete(RuntimeException e) {

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

        // Should be runtime exception (unchecked), not an Error
        // CommandExecutionException extends RuntimeException, not Error
        assertTrue(exception instanceof RuntimeException);
    }

    @Test

          protected void startUp() throws Exception {
            super.startUp();
            throw exception;
          }
        };
    assertEquals(0, service.startUpCalled);
    RuntimeException e =
        assertThrows(RuntimeException.class, () -> service.startAsync().awaitRunning());
    assertThat(e).hasCauseThat().isSameInstanceAs(exception);
    assertEquals(1, service.startUpCalled);

    @Override
    public void finalizeReferent() {
      references.remove(this);
      latch.countDown();
    }
  }

  @FormatMethod
  private static RuntimeException formatRuntimeException(String format, Object... args) {
    return new RuntimeException(String.format(Locale.ROOT, format, args));
  }