| /** |
| * Copyright (c) 2014 Codetrails GmbH. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Daniel Haftstein - initial tests. |
| */ |
| package org.eclipse.epp.logging.aeri.core.util; |
| |
| import static org.eclipse.emf.ecore.util.EcoreUtil.getAllContents; |
| import static org.eclipse.epp.logging.aeri.core.util.Reports.newStatus; |
| import static org.eclipse.epp.logging.aeri.tests.util.TestReports.*; |
| import static org.hamcrest.Matchers.*; |
| import static org.junit.Assert.assertThat; |
| |
| import java.lang.reflect.Field; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.concurrent.atomic.AtomicInteger; |
| import java.util.regex.Pattern; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.MultiStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.emf.common.util.TreeIterator; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.epp.logging.aeri.core.IModelFactory; |
| import org.eclipse.epp.logging.aeri.core.IReport; |
| import org.eclipse.epp.logging.aeri.core.IStackTraceElement; |
| import org.eclipse.epp.logging.aeri.core.ISystemSettings; |
| import org.eclipse.epp.logging.aeri.core.IThrowable; |
| import org.eclipse.epp.logging.aeri.tests.util.TestReports; |
| import org.junit.Assert; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| public class ReportsTest { |
| IModelFactory eFac = IModelFactory.eINSTANCE; |
| private static final List<Pattern> PREFIX_WHITELIST = WildcardPatterns |
| .convert(Arrays.asList("sun.*", "java.*", "javax.*", "org.eclipse.*")); |
| |
| private static final String WHITELISTED_CLASSNAME = "java.lang.RuntimeException"; |
| private static final String NOT_WHITELISTED_CLASSNAME = "foo.bar.FooBarException"; |
| |
| private static final String WHITELISTED_CLASSNAME_2 = "java.lang.String"; |
| private static final String WHITELISTED_METHODNAME_2 = "trim"; |
| |
| private static final String NOT_WHITELISTED_CLASSNAME_2 = "foo.bar.AnyClass"; |
| private static final String NOT_WHITELISTED_METHODNAME_2 = "foo"; |
| |
| private static String ANONYMIZED_TAG = "HIDDEN"; |
| |
| private ISystemSettings settings; |
| |
| @Before |
| public void before() { |
| settings = eFac.createSystemSettings(); |
| exCounter = 1; |
| stCounter = 1; |
| } |
| |
| @Test |
| public void testClearEventMessage() { |
| IReport report = createTestReport(); |
| Reports.anonymizeMessages(report); |
| assertThat(report.getStatus().getMessage(), is(ANONYMIZED_TAG)); |
| } |
| |
| @Test |
| public void testDeclaringClassToNull() |
| throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { |
| java.lang.Throwable some = new java.lang.Throwable("contains null"); |
| java.lang.StackTraceElement ste = new java.lang.StackTraceElement("class", "method", null, 1); |
| Field field = java.lang.StackTraceElement.class.getDeclaredField("declaringClass"); |
| field.setAccessible(true); |
| field.set(ste, null); |
| some.setStackTrace(new java.lang.StackTraceElement[] { ste }); |
| IThrowable sut = Reports.newThrowable(some); |
| Assert.assertEquals("MISSING", sut.getStackTrace().get(0).getClassName()); |
| } |
| |
| @Test |
| public void testClearThrowableMessage() { |
| IReport event = createTestReport(); |
| Reports.anonymizeMessages(event); |
| assertThat(event.getStatus().getException().getMessage(), is(ANONYMIZED_TAG)); |
| } |
| |
| @Test |
| public void testAnonymizeThrowableDtoClassname() { |
| IThrowable throwable = createThrowable(NOT_WHITELISTED_CLASSNAME); |
| Reports.anonymizeStackTraces(throwable, PREFIX_WHITELIST); |
| assertThat(throwable.getClassName(), is(ANONYMIZED_TAG)); |
| } |
| |
| @Test |
| public void testAnonymizeThrowableDtoWhitelistedClassname() { |
| IThrowable throwable = createThrowable(WHITELISTED_CLASSNAME); |
| Reports.anonymizeStackTraces(throwable, PREFIX_WHITELIST); |
| assertThat(throwable.getClassName(), is(WHITELISTED_CLASSNAME)); |
| } |
| |
| @Test |
| public void testAnonymizeIStackTraceElementDtoClassnames() { |
| IStackTraceElement element = createStackTraceElement(NOT_WHITELISTED_CLASSNAME_2, NOT_WHITELISTED_METHODNAME_2); |
| Reports.anonymizeStackTraceElements(element, PREFIX_WHITELIST); |
| assertThat(element.getClassName(), is(ANONYMIZED_TAG)); |
| } |
| |
| @Test |
| public void testAnonymizeIStackTraceElementDtoWhitelistedClassnames() { |
| IStackTraceElement element = createStackTraceElement(WHITELISTED_CLASSNAME, ""); |
| Reports.anonymizeStackTraceElements(element, PREFIX_WHITELIST); |
| assertThat(element.getClassName(), is(WHITELISTED_CLASSNAME)); |
| } |
| |
| @Test |
| public void testAnonymizeIStackTraceElementMethodname() { |
| IStackTraceElement element = createStackTraceElement(NOT_WHITELISTED_CLASSNAME_2, NOT_WHITELISTED_METHODNAME_2); |
| Reports.anonymizeStackTraceElements(element, PREFIX_WHITELIST); |
| assertThat(element.getMethodName(), is(ANONYMIZED_TAG)); |
| } |
| |
| @Test |
| public void testAnonymizeIStackTraceElementWhitelistedMethodname() { |
| IStackTraceElement element = createStackTraceElement(WHITELISTED_CLASSNAME_2, WHITELISTED_METHODNAME_2); |
| Reports.anonymizeStackTraceElements(element, PREFIX_WHITELIST); |
| assertThat(element.getMethodName(), is(WHITELISTED_METHODNAME_2)); |
| } |
| |
| @Test |
| public void testFingerprint() { |
| |
| Exception cause = new RuntimeException("cause"); |
| Exception r1 = new RuntimeException("exception message"); |
| |
| r1.fillInStackTrace(); |
| Exception r2 = new RuntimeException("exception message", cause); |
| r2.fillInStackTrace(); |
| |
| IStatus s1 = new Status(IStatus.ERROR, "org.eclipse.epp.logging.aeri", "some error message", r1); |
| IStatus s2 = new Status(IStatus.ERROR, "org.eclipse.epp.logging.aeri", "some error message", r2); |
| |
| org.eclipse.epp.logging.aeri.core.IStatus noCause = Reports.newStatus(s1); |
| org.eclipse.epp.logging.aeri.core.IStatus withCause = Reports.newStatus(s2); |
| |
| Assert.assertNotEquals(noCause.getFingerprint(), withCause.getFingerprint()); |
| } |
| |
| @Test |
| public void testFingerprintNested() { |
| Exception root = new RuntimeException("root"); |
| IStatus s1 = new Status(IStatus.ERROR, "org.eclipse.epp.logging.aeri", "some error message", root); |
| IStatus s2 = new MultiStatus("org.eclipse.epp.logging.aeri", 0, new IStatus[] { s1 }, "some error message", root); |
| |
| org.eclipse.epp.logging.aeri.core.IStatus normal = Reports.newStatus(s1); |
| org.eclipse.epp.logging.aeri.core.IStatus multi = Reports.newStatus(s2); |
| |
| Assert.assertNotEquals(normal.getFingerprint(), multi.getFingerprint()); |
| } |
| |
| @Test |
| public void testCoreExceptionHandling() { |
| IStatus causingStatus = new Status(IStatus.ERROR, "the.causing.plugin", "first message"); |
| java.lang.Throwable causingException = new CoreException(causingStatus); |
| IStatus causedStatus = new Status(IStatus.WARNING, "some.calling.plugin", "any other message", causingException); |
| java.lang.Throwable rootException = new CoreException(causedStatus); |
| IStatus rootEvent = new Status(IStatus.ERROR, "org.eclipse.epp.logging.aeri", "someErrorMessage", rootException); |
| |
| org.eclipse.epp.logging.aeri.core.IStatus rootStatus = Reports.newStatus(rootEvent); |
| |
| org.eclipse.epp.logging.aeri.core.IStatus child = rootStatus.getChildren().get(0); |
| org.eclipse.epp.logging.aeri.core.IStatus leaf = child.getChildren().get(0); |
| assertThat(child.getPluginId(), is("some.calling.plugin")); |
| assertThat(leaf.getPluginId(), is("the.causing.plugin")); |
| } |
| |
| @Test |
| public void testMultistatusDuplicateChildFiltering() { |
| |
| Exception e1 = new Exception("Stack Trace"); |
| e1.setStackTrace(createStacktraceForClasses("java.lang.Object", "org.eclipse.core.internal.jobs.WorkerPool", |
| "org.eclipse.core.internal.jobs.WorkerPool", "org.eclipse.core.internal.jobs.Worker")); |
| IStatus s1 = new Status(IStatus.ERROR, "org.eclipse.ui.monitoring", |
| "Thread 'Worker-3' tid=39 (TIMED_WAITING)\n" + "Waiting for: org.eclipse.core.internal.jobs.WorkerPool@416dc7fc", e1); |
| |
| Exception e2 = new Exception("Stack Trace"); |
| e2.setStackTrace(TestReports.createStacktraceForClasses("java.lang.Object", "org.eclipse.core.internal.jobs.WorkerPool", |
| "org.eclipse.core.internal.jobs.WorkerPool", "org.eclipse.core.internal.jobs.Worker")); |
| IStatus s2 = new Status(IStatus.ERROR, "org.eclipse.ui.monitoring", |
| "Thread 'Worker-2' tid=36 (TIMED_WAITING)\n" + "Waiting for: org.eclipse.core.internal.jobs.WorkerPool@416dc7fc", e2); |
| |
| IStatus multi = new MultiStatus("org.eclipse.ui.monitoring", 0, new IStatus[] { s1, s2 }, "UI freeze of 10s at 08:09:02.936", |
| new RuntimeException("stand-in-stacktrace")); |
| org.eclipse.epp.logging.aeri.core.IStatus newStatus = Reports.newStatus(multi); |
| assertThat(newStatus.getChildren().size(), is(1)); |
| assertThat(newStatus.getMessage(), is("UI freeze of 10s at 08:09:02.936 [1 child-status duplicates removed by Error Reporting]")); |
| } |
| |
| @Test |
| public void testMultistatusChildFilteringHandlesEmptyStacktrace() { |
| |
| Exception e1 = new Exception("Stack Trace 1"); |
| e1.setStackTrace(new java.lang.StackTraceElement[0]); |
| IStatus s1 = new Status(IStatus.ERROR, "org.eclipse.ui.monitoring", "Thread 'Signal Dispatcher' tid=4 (RUNNABLE)", e1); |
| |
| IStatus multi = new MultiStatus("org.eclipse.ui.monitoring", 0, new IStatus[] { s1 }, "UI freeze of 10s at 08:09:02.936", |
| new RuntimeException("stand-in-stacktrace")); |
| org.eclipse.epp.logging.aeri.core.IStatus newStatus = Reports.newStatus(multi); |
| assertThat(newStatus.getChildren().size(), is(0)); |
| } |
| |
| @Test |
| public void testMultistatus() { |
| MultiStatus mst = mst(ex(), st(ex()), st(ex()), st(ex()), st(ex()), st(ex())); |
| org.eclipse.epp.logging.aeri.core.IStatus res = Reports.newStatus(mst); |
| assertThat(numberOfStatusObjects(res), is(6)); |
| } |
| |
| @Test |
| public void testCausedByContainsCoreExceptionWithStatus() { |
| Status st = st(ex(cex(st(ex())))); |
| org.eclipse.epp.logging.aeri.core.IStatus res = newStatus(st); |
| assertThat(numberOfStatusObjects(res), is(2)); |
| } |
| |
| @Test |
| public void testCausedByContainsCoreExceptionWithMultistatus() { |
| MultiStatus mst = mst(ex(), st(ex()), st(ex()), st(ex()), st(ex()), st(ex())); |
| Status st = st(ex(cex(mst))); |
| org.eclipse.epp.logging.aeri.core.IStatus res = Reports.newStatus(st); |
| assertThat(numberOfStatusObjects(res), is(7)); |
| } |
| |
| @Test |
| public void testDetachMultistatusFromCoreException() { |
| // #input |
| // st4 |
| // -ex4 |
| // --cex |
| // ---mst3 |
| // ----ex1 |
| // ----st1 |
| // -----ex2 |
| // ----st2 |
| // -----ex3 |
| Status st = st(ex(cex(mst(ex(), st(ex()), st(ex()))))); |
| // #expected output |
| // st4 |
| // -ex4 |
| // --cex(mst3) |
| // ---ex1 |
| // -mst3 (moved from cex to st4.children) |
| // --ex1 |
| // --st1 |
| // ---ex2 |
| // --st2 |
| // ---ex3 |
| org.eclipse.epp.logging.aeri.core.IStatus st4 = Reports.newStatus(st); |
| IThrowable ex4 = st4.getException(); |
| IThrowable cex = ex4.getCause(); |
| IThrowable ex1 = cex.getCause(); |
| org.eclipse.epp.logging.aeri.core.IStatus mst3 = st4.getChildren().get(0); |
| IThrowable ex1b = mst3.getException(); |
| org.eclipse.epp.logging.aeri.core.IStatus st1 = mst3.getChildren().get(0); |
| IThrowable ex2 = st1.getException(); |
| org.eclipse.epp.logging.aeri.core.IStatus st2 = mst3.getChildren().get(1); |
| IThrowable ex3 = st2.getException(); |
| |
| assertThat(st4.getMessage(), is("st4")); |
| assertThat(ex4.getMessage(), is("ex4")); |
| assertThat(cex.getMessage(), is("mst3")); |
| assertThat(ex1.getMessage(), is("ex1")); |
| assertThat(mst3.getMessage(), is("mst3 [detached from CoreException of Status 'st4' by Error Reporting]")); |
| assertThat(ex1b.getMessage(), is("ex1")); |
| assertThat(st1.getMessage(), is("st1")); |
| assertThat(ex2.getMessage(), is("ex2")); |
| assertThat(st2.getMessage(), is("st2")); |
| assertThat(ex3.getMessage(), is("ex3")); |
| } |
| |
| @Test |
| public void testDetachMultipleMultistatusFromCoreException() { |
| // #input |
| // st9 |
| // -ex6 |
| // --cex |
| // ---st8 |
| // ----cex |
| // -----mst7 |
| // ------ex1 |
| // ------st4 |
| // -------cex |
| // --------mst3 |
| // ---------ex2 |
| // ---------st1 |
| // ----------ex3 |
| // ---------st2 |
| // ----------ex4 |
| // ------st6 |
| // -------cex |
| // --------st5 |
| // ---------ex5 |
| Status st = st(ex(cex(st(cex(mst(ex(), st(cex(mst(ex(), st(ex()), st(ex())))), st(cex(st(ex()))))))))); |
| // #expected output |
| // st9 |
| // -st8 |
| // --mst7 |
| // ---ex1 |
| // ---st4 |
| // ----mst3 |
| // -----ex2 |
| // ----st1 |
| // -----ex3 |
| // ----st2 |
| // -----ex4 |
| // ---st6 |
| // ----st5 |
| // -----ex5 |
| org.eclipse.epp.logging.aeri.core.IStatus st9 = Reports.newStatus(st); |
| IThrowable ex6 = st9.getException(); |
| org.eclipse.epp.logging.aeri.core.IStatus st8 = st9.getChildren().get(0); |
| org.eclipse.epp.logging.aeri.core.IStatus mst7 = st8.getChildren().get(0); |
| org.eclipse.epp.logging.aeri.core.IStatus st4 = mst7.getChildren().get(0); |
| org.eclipse.epp.logging.aeri.core.IStatus mst3 = st4.getChildren().get(0); |
| org.eclipse.epp.logging.aeri.core.IStatus st2 = mst3.getChildren().get(1); |
| IThrowable ex4 = st2.getException(); |
| org.eclipse.epp.logging.aeri.core.IStatus st6 = mst7.getChildren().get(1); |
| org.eclipse.epp.logging.aeri.core.IStatus st5 = st6.getChildren().get(0); |
| IThrowable ex5 = st5.getException(); |
| |
| assertThat(st9.getMessage(), is("st9")); |
| assertThat(ex6.getMessage(), is("ex6")); |
| assertThat(st8.getMessage(), is("st8 [detached from CoreException of Status 'st9' by Error Reporting]")); |
| assertThat(mst7.getMessage(), is("mst7 [detached from CoreException of Status 'st8' by Error Reporting]")); |
| assertThat(st4.getMessage(), is("st4")); |
| assertThat(mst3.getMessage(), is("mst3 [detached from CoreException of Status 'st4' by Error Reporting]")); |
| assertThat(st2.getMessage(), is("st2")); |
| assertThat(ex4.getMessage(), is("ex4")); |
| assertThat(st6.getMessage(), is("st6")); |
| assertThat(st5.getMessage(), is("st5 [detached from CoreException of Status 'st6' by Error Reporting]")); |
| assertThat(ex5.getMessage(), is("ex5")); |
| } |
| |
| @Test |
| public void testPrettyPrintNullSafe1() { |
| IReport report = eFac.createReport(); |
| Reports.toPrettyString(report); |
| } |
| |
| @Test |
| public void testPrettyPrintNullSafe2() { |
| IReport report = eFac.createReport(); |
| report.setStatus(eFac.createStatus()); |
| Reports.toPrettyString(report); |
| } |
| |
| @Test |
| public void testPrettyPrintNullSafe3() { |
| IReport report = eFac.createReport(); |
| report.setStatus(eFac.createStatus()); |
| IThrowable t = eFac.createThrowable(); |
| t.setClassName("org.test"); |
| report.getStatus().setException(t); |
| Reports.toPrettyString(report); |
| } |
| |
| @Test |
| public void testPrettyPrintSkipsNullException() { |
| IReport report = eFac.createReport(); |
| report.setStatus(eFac.createStatus()); |
| String prettyPrint = Reports.toPrettyString(report); |
| assertThat(prettyPrint, not(containsString("Exception"))); |
| } |
| |
| @Test |
| public void testMultistatusMainStacktracesNotFiltered() { |
| |
| Exception e1 = new Exception("Stack Trace"); |
| java.lang.StackTraceElement[] stackTrace = createStacktraceForClasses("java.lang.Thread", |
| "org.eclipse.epp.logging.aeri.ui.actions.UiFreezeAction", "org.eclipse.ui.internal.PluginAction", |
| "org.eclipse.ui.internal.WWinPluginAction", "org.eclipse.jface.action.ActionContributionItem", |
| "org.eclipse.jface.action.ActionContributionItem", "org.eclipse.jface.action.ActionContributionItem", |
| "org.eclipse.swt.widgets.EventTable", "org.eclipse.swt.widgets.Display", "org.eclipse.swt.widgets.Widget", |
| "org.eclipse.swt.widgets.Display", "org.eclipse.swt.widgets.Display", |
| "org.eclipse.e4.ui.internal.workbench.swt.PartRenderingEngine", "org.eclipse.core.databinding.observable.Realm", |
| "org.eclipse.e4.ui.internal.workbench.swt.PartRenderingEngine", "org.eclipse.e4.ui.internal.workbench.E4Workbench", |
| "org.eclipse.ui.internal.Workbench", "org.eclipse.core.databinding.observable.Realm", "org.eclipse.ui.internal.Workbench", |
| "org.eclipse.ui.PlatformUI", "org.eclipse.ui.internal.ide.application.IDEApplication", |
| "org.eclipse.equinox.internal.app.EclipseAppHandle", "org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher", |
| "org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher", "org.eclipse.core.runtime.adaptor.EclipseStarter", |
| "org.eclipse.core.runtime.adaptor.EclipseStarter", "sun.reflect.NativeMethodAccessorImpl", |
| "sun.reflect.NativeMethodAccessorImpl", "sun.reflect.DelegatingMethodAccessorImpl", "java.lang.reflect.Method", |
| "org.eclipse.equinox.launcher.Main", "org.eclipse.equinox.launcher.Main", "org.eclipse.equinox.launcher.Main", |
| "org.eclipse.equinox.launcher.Main", "org.eclipse.equinox.launcher.Main"); |
| e1.setStackTrace(stackTrace); |
| IStatus s1 = new Status(IStatus.ERROR, "org.eclipse.ui.monitoring", |
| "Sample at 11:25:04.447 (+1,331s)\n" + "Thread 'main' tid=1 (TIMED_WAITING)", e1); |
| |
| IStatus multi = new MultiStatus("org.eclipse.ui.monitoring", 0, new IStatus[] { s1 }, "UI freeze of 6,0s at 11:24:59.108", |
| new RuntimeException("stand-in-stacktrace")); |
| org.eclipse.epp.logging.aeri.core.IStatus newStatus = Reports.newStatus(multi); |
| assertThat(newStatus.getChildren().size(), is(1)); |
| assertThat(newStatus.getChildren().get(0).getException().getStackTrace().size(), is(stackTrace.length)); |
| } |
| |
| private static int numberOfStatusObjects(org.eclipse.epp.logging.aeri.core.IStatus status) { |
| final AtomicInteger counter = new AtomicInteger(); |
| ModelSwitch<AtomicInteger> visitor = new ModelSwitch<AtomicInteger>() { |
| |
| @Override |
| public AtomicInteger caseStatus(org.eclipse.epp.logging.aeri.core.IStatus object) { |
| counter.incrementAndGet(); |
| return counter; |
| } |
| |
| @Override |
| public AtomicInteger caseThrowable(IThrowable object) { |
| return counter; |
| } |
| }; |
| |
| visitor.doSwitch(status); |
| for (TreeIterator<EObject> it = getAllContents(status, true); it.hasNext();) { |
| visitor.doSwitch(it.next()); |
| } |
| return counter.get(); |
| } |
| |
| private static int exCounter = 1; |
| |
| private static Exception ex() { |
| return ex(null); |
| } |
| |
| private static Exception cex(IStatus st) { |
| return new CoreException(st); |
| } |
| |
| private static Exception ex(Exception cause) { |
| return new Exception("ex" + exCounter++, cause); |
| } |
| |
| private static int stCounter = 1; |
| |
| private static Status st(Exception ex) { |
| return new Status(IStatus.ERROR, "org.eclipse", "st" + stCounter++, ex); |
| } |
| |
| private static MultiStatus mst(Exception ex, Status... status) { |
| return new MultiStatus("org.eclipse", IStatus.ERROR, status, "mst" + stCounter++, ex); |
| } |
| |
| } |
