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); }