public void serialize(final DataOutput output) { try { output.writeDouble(maxError); output.writeDouble(alpha); output.writeLong(landmarkInSeconds); output.writeLong(min); output.writeLong(max); output.writeInt(totalNodeCount); postOrderTraversal( root, new Callback() { @Override public boolean process(Node node) { try { serializeNode(output, node); } catch (IOException e) { Throwables.propagate(e); } return true; } }); } catch (IOException e) { Throwables.propagate(e); } }
@Test public void should_return_stacktrace_as_String() { final Throwable throwable = new Throwable("some message"); assertThat(Throwables.getStackTrace(throwable)) .isInstanceOf(String.class) .contains("java.lang.Throwable: some message") .containsPattern("\tat .*\\(Throwables_getStackTrace_Test.java:\\d"); }
/** * Naive implementation of execution with retry logic. a callable will be executed and retry * attempted in current thread if the result and exception predicates. before retry, a callable * can be executed that can abort the retry and finish the function with the previous result. */ @SuppressFBWarnings("BC_UNCONFIRMED_CAST_OF_RETURN_VALUE") public static <T, EX extends Exception> T executeWithRetry( final RetryCallable<T, EX> what, final RetryPredicate<? super T> retryOnReturnVal, final RetryPredicate<Exception> retryOnException) throws InterruptedException, EX { T result = null; Exception lastEx = null; // last exception try { result = what.call(); } catch (InterruptedException ex1) { throw what.lastException(ex1); } catch (Exception e) { // only EX and RuntimeException lastEx = e; } Exception lastExChain = lastEx; // last exception chained with all previous exceptions while ((lastEx != null && retryOnException.apply(lastEx) == Action.RETRY) || retryOnReturnVal.apply(result) == Action.RETRY) { if (Thread.interrupted()) { Thread.currentThread().interrupt(); throw what.lastException(new InterruptedException()); } result = null; lastEx = null; try { result = what.call(); } catch (InterruptedException ex1) { throw what.lastException(ex1); } catch (Exception e) { // only EX and RuntimeException lastEx = e; if (lastExChain != null) { lastExChain = Throwables.suppress(e, lastExChain); } else { lastExChain = e; } } } if (lastEx != null) { if (lastExChain instanceof RuntimeException) { throw what.lastException((RuntimeException) lastExChain); } else { throw what.lastException((EX) lastExChain); } } return what.lastReturn(result); }
public static QuantileDigest deserialize(DataInput input) { try { double maxError = input.readDouble(); double alpha = input.readDouble(); QuantileDigest result = new QuantileDigest(maxError, alpha); result.landmarkInSeconds = input.readLong(); result.min = input.readLong(); result.max = input.readLong(); result.totalNodeCount = input.readInt(); Deque<Node> stack = new ArrayDeque<>(); for (int i = 0; i < result.totalNodeCount; i++) { int flags = input.readByte(); Node node = deserializeNode(input); if ((flags & Flags.HAS_RIGHT) != 0) { node.right = stack.pop(); } if ((flags & Flags.HAS_LEFT) != 0) { node.left = stack.pop(); } stack.push(node); result.weightedCount += node.weightedCount; if (node.weightedCount >= ZERO_WEIGHT_THRESHOLD) { result.nonZeroNodeCount++; } } if (!stack.isEmpty()) { Preconditions.checkArgument( stack.size() == 1, "Tree is corrupted. Expected a single root node"); result.root = stack.pop(); } return result; } catch (IOException e) { throw Throwables.propagate(e); } }
/** * Finds directories and files within a given directory and its subdirectories. * * @param classLoader * @param rootPath the root directory, for example org/sonar/sqale, or a file in this root * directory, for example org/sonar/sqale/index.txt * @param * @return a list of relative paths, for example {"org/sonar/sqale", "org/sonar/sqale/foo", * "org/sonar/sqale/foo/bar.txt}. Never null. */ public static Collection<String> listResources( ClassLoader classLoader, String rootPath, Predicate<String> predicate) { String jarPath = null; JarFile jar = null; try { Collection<String> paths = Lists.newArrayList(); rootPath = StringUtils.removeStart(rootPath, "/"); URL root = classLoader.getResource(rootPath); if (root != null) { checkJarFile(root); // Path of the root directory // Examples : // org/sonar/sqale/index.txt -> rootDirectory is org/sonar/sqale // org/sonar/sqale/ -> rootDirectory is org/sonar/sqale // org/sonar/sqale -> rootDirectory is org/sonar/sqale String rootDirectory = rootPath; if (StringUtils.substringAfterLast(rootPath, "/").indexOf('.') >= 0) { rootDirectory = StringUtils.substringBeforeLast(rootPath, "/"); } jarPath = root.getPath().substring(5, root.getPath().indexOf("!")); // strip out only the JAR file jar = new JarFile(URLDecoder.decode(jarPath, CharEncoding.UTF_8)); Enumeration<JarEntry> entries = jar.entries(); while (entries.hasMoreElements()) { String name = entries.nextElement().getName(); if (name.startsWith(rootDirectory) && predicate.apply(name)) { paths.add(name); } } } return paths; } catch (Exception e) { throw Throwables.propagate(e); } finally { closeJar(jar, jarPath); } }
@Test public void calls_printStackTrace_with_temp_PrintWriter() { final Throwable mock = mock(Throwable.class); Throwables.getStackTrace(mock); verify(mock, times(1)).printStackTrace(isA(PrintWriter.class)); }