given throwable.
168456
private static String __getStackTrace(Throwable throwable) {
        StringWriter stringWriter = new StringWriter();
        throwable.printStackTrace(new PrintWriter(stringWriter));

        return stringWriter.toString();
    }
1187785
@Override
    public void onFailure(Throwable t) {
        if (cancelled) {
            return;
        }

        t = adjustThrowable(t);
        if (handleInternalException(t)) {
            next();
        } else {
            cancel();
        }
    }
828036
public static RuntimeException propagate(Throwable t) {
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new RuntimeException(t);
        }
    }
1085218
public static <T> T convert(Callable<T> callable,
                                Function<Throwable, RuntimeException> function) {
        try {
            return callable.call();
        } catch (Throwable e) {
            throw function.apply(e);
        }
    }
768637
private Throwable getCause(Throwable t) {
        Throwable cause = t.getCause();
        if (t.getCause() != null) {
            return cause;
        } else {
            return t;
        }
    }
44287
def throw(self, type, value=None, traceback=None):  # pylint: disable=redefined-builtin
        """"""
        return self.__wrapped__.throw(type, value, traceback)
864277
public void printThrowable(Throwable t) {
        final PrintContext context = new PrintContext();

        Throwable prevThrowable = null;
        Throwable currentThrowable = t;
        while (true) {
            printThrowable0(context, currentThrowable, prevThrowable);
            final Throwable nextThrowable = currentThrowable.getCause();
            if (currentThrowable != nextThrowable && nextThrowable != null) {
                prevThrowable = currentThrowable;
                currentThrowable = nextThrowable;
                context.append("Caused by: ");
            } else {
                break;
            }
        }
    }
388733
public T take() throws Throwable {
    dataLock.lock();      
    try {
      while(data == null && error == null) {
        try {
          availableCondition.await();
        } catch(InterruptedException e) {
          // ignore and re-loop in case of spurious wake-ups
        }
      }
      
      // should only get to here if data or error is non-null
      return getAndClearUnderLock();
    } finally {
      dataLock.unlock();
    }
  }
1103074
private Throwable extractThrowable(Throwable exception, Class<?> causeClass) {
        if (exception == null) {
            return null;
        } else if (causeClass.isInstance(exception)) {
            return exception;
        } else {
            return extractThrowable(exception.getCause(), causeClass);
        }
    }
940612
@Override
    public void throwing(String sourceClass, String sourceMethod, Throwable thrown) {
        if (isLoggable(Level.FINER)) {
            LogRecord logRecord = createLogRecord(Level.FINER, "THROW", null, sourceClass, sourceMethod, null, thrown);
            log(logRecord);
        }
    }
1340583
public static RuntimeException propagate(Throwable throwable) {
    final Throwable t = Preconditions.checkNotNull(throwable, "throwable");
    if (t instanceof Error) {
      throw (Error) t;
    }
    if (t instanceof RuntimeException) {
      throw (RuntimeException) t;
    }

    throw new RuntimeException(t);
  }
1151962
public static void throwIfUnchecked(Throwable t) {
    Preconditions.checkNotNull(t);
    if (t instanceof RuntimeException) {
      throw (RuntimeException) t;
    }
    if (t instanceof Error) {
      throw (Error) t;
    }
  }
899776
public Binder catchException(Class<? extends Throwable> throwable, MethodHandle function) {
        return new Binder(this, new Catch(throwable, function));
    }
263157
static Throwable cause(Throwable e)
  {
    while (e.getCause() != null
        && (e instanceof InstantiationException
            || e instanceof InvocationTargetException
            || e.getClass().equals(RuntimeExceptionConfig.class))) {
      e = e.getCause();
    }
    
    return e;
  }
26034
public static <T extends Throwable, A> Try<T, A> failure(T t) {
        return new Failure<>(t);
    }
1366904
function _throw (code, customMessage, original, data) {
    immutableError.throw(this, code, customMessage, original, data)
}
500740
public static Exception rethrow(Throwable throwable) throws Error {
        try {
            throw throwable;
        } catch (Error error) {
            throw error;
        } catch (Exception exception) {
            return exception;
        } catch (Throwable throwable2) {
            return msg.undeclaredThrowable(throwable2);
        }
    }