fail("Expected CurlException");
        } catch (CurlException e) {
            assertTrue(e.getMessage().contains("Failed to access the content"));
            assertSame(exception, e.getCause());
        }
    }

    @Test
    public void testGetContentAsStreamWithCache() throws IOException {
        CurlResponse response = new CurlResponse();
        byte[] data = "test content".getBytes();

    public void testGetCause() throws Exception {
        final Throwable t = new NullPointerException("test");
        final ClRuntimeException ex = new ClRuntimeException("ECL0017", asArray(t), t);
        assertThat(ex.getCause(), is(t));
        ex.printStackTrace();
    }

                throw responseManager.new400("Unsupported request type.");
            }
            return actionResponse;
        } catch (final SsoMessageException e) {
            if (e.getCause() == null) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Metadata response.", e);
                }
                saveInfo(e.getMessageCode());
            } else {

    waitingThread.start();
    waitingThread.interrupt();
    ExecutionException expected = assertThrows(ExecutionException.class, wasInterrupted::get);
    assertTrue(expected.getCause().toString(), expected.getCause() instanceof InterruptedException);
  }

  public void testMakeUninterruptible_timedGetZeroTimeoutAttempted()
      throws TimeoutException, ExecutionException {

    try {
      method.invoke(wrapper, getParameterValues(method));
      fail(method + " failed to throw exception as is.");
    } catch (InvocationTargetException e) {
      if (exception != e.getCause()) {
        throw new RuntimeException(e);
      }
    } catch (IllegalAccessException e) {
      throw new AssertionError(e);
    }
  }

  private static <T> void testEquals(

      return future.get();
    } catch (InterruptedException e) {
      currentThread().interrupt();
      throw newWithCause(exceptionClass, e);
    } catch (ExecutionException e) {
      wrapAndThrowExceptionOrError(e.getCause(), exceptionClass);
      throw new AssertionError();
    }
  }

  /** Implementation of {@link Futures#getChecked(Future, Class, long, TimeUnit)}. */
  @CanIgnoreReturnValue
  @ParametricNullness

        // Then
        assertEquals(original.getErrorCode(), retry.getErrorCode());
        assertEquals(original.getMessage(), retry.getMessage());
        assertEquals(original.getCause(), retry.getCause());
        assertNotNull(retry.getContext());
    }

    @Test
    @DisplayName("Should format message correctly")
    void testMessageFormatting() {
        // With custom message

                        }
                        return value;
                    });
                } catch (final ExecutionException e) {
                    if (e.getCause() instanceof KeyNotFoundException) {
                        return null;
                    }
                    return super.get(propertyKey);
                }
            }
        };
    }

          try {
            String result = Uninterruptibles.getUninterruptibly(currentFuture.get());
            finalResults.add(result);
          } catch (ExecutionException e) {
            finalResults.add(e.getCause());
          } catch (CancellationException e) {
            finalResults.add(CancellationException.class);
          } finally {
            awaitUnchecked(barrier);
          }
        };

    waitingThread.start();
    waitingThread.interrupt();
    ExecutionException expected = assertThrows(ExecutionException.class, wasInterrupted::get);
    assertTrue(expected.getCause().toString(), expected.getCause() instanceof InterruptedException);
  }

  public void testMakeUninterruptible_timedGetZeroTimeoutAttempted()
      throws TimeoutException, ExecutionException {