How to use

getStackTrace

method

in

java.lang.Throwable

private LocationImpl(StackTraceFilter stackTraceFilter, Throwable stackTraceHolder) {
  this.stackTraceFilter = stackTraceFilter;
  this.stackTraceHolder = stackTraceHolder;
  if (stackTraceHolder.getStackTrace() == null || stackTraceHolder.getStackTrace().length == 0) {
    //there are corner cases where exception can have a null or empty stack trace
    //for example, a custom exception can override getStackTrace() method
    this.sourceFile = "<unknown source file>";
  } else {
    this.sourceFile = stackTraceFilter.findSourceFile(stackTraceHolder.getStackTrace(), "<unknown source file>");
  }
}

@Override
public boolean matches(Method method, Class<?> targetClass, Object... args) {
  this.evaluations++;
  for (StackTraceElement element : new Throwable().getStackTrace()) {
    if (element.getClassName().equals(this.clazz.getName()) &&
        (this.methodName == null || element.getMethodName().equals(this.methodName))) {
      return true;
    }
  }
  return false;
}

private void appendStackTrace(StringBuilder b, Throwable ex, String prefix) {
  b.append(prefix).append(ex).append('\n');
  for (StackTraceElement stackElement : ex.getStackTrace()) {
    b.append("\t\tat ").append(stackElement).append('\n');
  }
  if (ex.getCause() != null) {
    b.append("\tCaused by: ");
    appendStackTrace(b, ex.getCause(), "");
  }
}

private String getStackTrace (Throwable e) {
  StringBuilder sb = new StringBuilder();
  for (StackTraceElement trace : e.getStackTrace()) {
    sb.append(trace.toString() + "\n");
  }
  return sb.toString();
}

private String getStackTrace (Throwable e) {
  StringBuilder sb = new StringBuilder();
  for (StackTraceElement trace : e.getStackTrace()) {
    sb.append(trace.toString() + "\n");
  }
  return sb.toString();
}

  @Override
  public void writeObject(Object obj, AbstractHessianOutput out)
      throws IOException {
    Throwable e = (Throwable) obj;

    e.getStackTrace();

    super.writeObject(obj, out);
  }
}

private static void filter(Throwable th) {
  StackTraceElement[] stackTrace = th.getStackTrace();
  int cutIndex = -1;
  int length = stackTrace.length;
  for (int i = 0; i < length; i++) {
    StackTraceElement stackTraceElement = stackTrace[i];
    if (stackTraceElement.getClassName().startsWith(JADX_API_PACKAGE)) {
      cutIndex = i;
    } else if (cutIndex > 0) {
      cutIndex = i;
      break;
    }
  }
  if (cutIndex > 0 && cutIndex < length) {
    th.setStackTrace(Arrays.copyOfRange(stackTrace, 0, cutIndex));
  }
}

public void setExecuteErrorLast(Throwable executeErrorLast) {
  this.executeErrorLast = executeErrorLast;
  if (executeErrorLast != null) {
    this.executeErrorLastMessage = executeErrorLast.getMessage();
    this.executeErrorLastClass = executeErrorLast.getClass().getName();
    this.executeErrorLastStackTrace = Utils.toString(executeErrorLast.getStackTrace());
  }
}

public void setLastError(Throwable lastError) {
  if (lastError != null) {
    lastErrorClass = lastError.getClass().getName();
    lastErrorMessage = lastError.getMessage();
    lastErrorStackTrace = Utils.toString(lastError.getStackTrace());
  }
}

@Override
public String toString() {
  //TODO SF perhaps store the results after invocation?
  StackTraceElement[] filtered = stackTraceFilter.filter(stackTraceHolder.getStackTrace(), false);
  if (filtered.length == 0) {
    return "-> at <<unknown line>>";
  }
  return "-> at " + filtered[0].toString();
}

private static Exception throwCause(Exception e, boolean combineStackTraces) throws Exception {
 Throwable cause = e.getCause();
 if (cause == null) {
  throw e;
 }
 if (combineStackTraces) {
  StackTraceElement[] combined =
    ObjectArrays.concat(cause.getStackTrace(), e.getStackTrace(), StackTraceElement.class);
  cause.setStackTrace(combined);
 }
 if (cause instanceof Exception) {
  throw (Exception) cause;
 }
 if (cause instanceof Error) {
  throw (Error) cause;
 }
 // The cause is a weird kind of Throwable, so throw the outer exception.
 throw e;
}

  public RedissonKryoCodecException(Throwable cause) {
    super(cause.getMessage(), cause);
    setStackTrace(cause.getStackTrace());
  }
}

private void appendStackTrace(StringBuilder b, Throwable ex, String prefix) {
  b.append(prefix).append(ex).append('\n');
  for (StackTraceElement stackElement : ex.getStackTrace()) {
    b.append("\t\tat ").append(stackElement).append('\n');
  }
  if (ex.getCause() != null) {
    b.append("\tCaused by: ");
    appendStackTrace(b, ex.getCause(), "");
  }
}

/**
 * @deprecated as of 1.305 use {@link #getEnvironment(TaskListener)}
 */
@Deprecated
public EnvVars getEnvironment() throws IOException, InterruptedException {
  LOGGER.log(WARNING, "deprecated call to Run.getEnvironment\n\tat {0}", new Throwable().getStackTrace()[1]);
  return getEnvironment(new LogTaskListener(LOGGER, Level.INFO));
}

private void resolve() {
  StackTraceElement[] stack = new Throwable().getStackTrace();
  String sourceClassName = null;
  String sourceMethodName = null;
  boolean found = false;
  for (StackTraceElement element : stack) {
    String className = element.getClassName();
    if (FQCN.equals(className)) {
      found = true;
    }
    else if (found) {
      sourceClassName = className;
      sourceMethodName = element.getMethodName();
      break;
    }
  }
  setSourceClassName(sourceClassName);
  setSourceMethodName(sourceMethodName);
}

  public void filter(Throwable throwable) {
    if (!config.cleansStackTrace()) {
      return;
    }
    StackTraceElement[] filtered = filter.filter(throwable.getStackTrace(), true);
    throwable.setStackTrace(filtered);
  }
}

private static Object tryInvoke(Method origin, Object instance, Object[] arguments) throws Throwable {
  try {
    return origin.invoke(instance, arguments);
  } catch (InvocationTargetException exception) {
    Throwable cause = exception.getCause();
    new ConditionalStackTraceFilter().filter(hideRecursiveCall(cause, new Throwable().getStackTrace().length, origin.getDeclaringClass()));
    throw cause;
  }
}

private boolean contain(Throwable t, String className, String methodName) {
  for (StackTraceElement element : t.getStackTrace()) {
    if (className.equals(element.getClassName()) && methodName.equals(element.getMethodName())) {
      return true;
    }
  }
  return false;
}

public static void build(ThrowableProxy nestedTP, Throwable nestedThrowable, ThrowableProxy parentTP) {
  StackTraceElement[] nestedSTE = nestedThrowable.getStackTrace();
  int commonFramesCount = -1;
  if (parentTP != null) {
    commonFramesCount = findNumberOfCommonFrames(nestedSTE, parentTP.getStackTraceElementProxyArray());
  }
  nestedTP.commonFrames = commonFramesCount;
  nestedTP.stackTraceElementProxyArray = steArrayToStepArray(nestedSTE);
}

public void appendWarnings(Failure failure, String warnings) {
  if (isEmpty(warnings)) {
    return;
  }
  //TODO: this has to protect the use in case jUnit changes and this internal state logic fails
  Throwable throwable = (Throwable) getInternalState(failure, "fThrownException");
  String newMessage = "contains both: actual test failure *and* Mockito warnings.\n" +
      warnings + "\n *** The actual failure is because of: ***\n";
  ExceptionIncludingMockitoWarnings e = new ExceptionIncludingMockitoWarnings(newMessage, throwable);
  e.setStackTrace(throwable.getStackTrace());
  setInternalState(failure, "fThrownException", e);
}