private Throwable getTestResultException(ITestResult testResult) { Throwable testResultException = testResult.getThrowable(); if (testResultException instanceof InvocationTargetException) { testResultException = ((InvocationTargetException) testResultException).getCause(); } return testResultException; }
private TestTag createTestTagFor(ITestResult tr, Class<?> cls) { TestTag testTag = new TestTag(); Properties p2 = new Properties(); p2.setProperty(XMLConstants.ATTR_CLASSNAME, cls.getName()); p2.setProperty(XMLConstants.ATTR_NAME, getTestName(tr)); int status = tr.getStatus(); if (status == ITestResult.SKIP || status == ITestResult.SUCCESS_PERCENTAGE_FAILURE) { testTag.childTag = XMLConstants.SKIPPED; } else if (status == ITestResult.FAILURE) { handleFailure(testTag, tr.getThrowable()); } testTag.properties = p2; return testTag; }
@Override public void onTestFailure(ITestResult result) { System.out.format("!!!!!!!!! FAILURE-- %s.%s(%s)-------\n", result.getTestClass(), result.getTestName(), Arrays.toString(result.getParameters())); if (result.getThrowable() instanceof ThreadTimeoutException) { System.out.println("====== THREAD DUMPS ======"); System.out.println(ThreadDumpUtil.buildThreadDiagnosticString()); } }
private void logExceptions(String status, List<ITestResult> results) { results.forEach( tr -> { Throwable throwable = tr.getThrowable(); logResult(status, tr, throwable != null ? Utils.shortStackTrace(throwable, false) : null); }); }
@Override public void onConfigurationFailure(ITestResult itr) { this.errorMessage = itr.getThrowable().getMessage(); } }
private void createFailureElement(XMLStringBuffer doc, ITestResult tr) { Properties attrs= new Properties(); Throwable t= tr.getThrowable(); if(t != null) { attrs.setProperty(XMLConstants.ATTR_TYPE, t.getClass().getName()); String message= t.getMessage(); if((message != null) && (message.length() > 0)) { attrs.setProperty(XMLConstants.ATTR_MESSAGE, encodeAttr(message)); // ENCODE } doc.push(XMLConstants.FAILURE, attrs); doc.addCDATA(Utils.shortStackTrace(t, false)); doc.pop(); } else { doc.addEmptyElement(XMLConstants.FAILURE); // THIS IS AN ERROR } }
static Throwable getExceptionDetails(ITestContext context, Object instance) { Set<ITestResult> configResults = context.getFailedConfigurations().getAllResults(); if (configResults.isEmpty()) { configResults = context.getSkippedConfigurations().getAllResults(); } if (configResults.isEmpty()) { //if we are here it means we have a test method skip due to a @BeforeSuite failure in a different <test> maybe //So we will have to find out that first failure/skip and get its throwable and pack that information into our //current test method's test result. return getConfigFailureException(context); } for (ITestResult configResult : configResults) { if (sameInstance(configResult, instance)) { return configResult.getThrowable(); } } //If we are here it perhaps means that the test method is being skipped because there was a configuration //failure in a different class due to @BeforeGroups being used. //So lets just find the first exception information and then just pack it in. return configResults.iterator().next().getThrowable(); }
private TestTag createTestTagFor(ITestResult tr, Class<?> cls) { TestTag testTag = new TestTag(); Properties p2 = new Properties(); p2.setProperty(XMLConstants.ATTR_CLASSNAME, cls.getName()); p2.setProperty(XMLConstants.ATTR_NAME, getTestName(tr)); int status = tr.getStatus(); if (status == ITestResult.SKIP || status == ITestResult.SUCCESS_PERCENTAGE_FAILURE) { testTag.childTag = XMLConstants.SKIPPED; } else if (status == ITestResult.FAILURE) { handleFailure(testTag, tr.getThrowable()); } testTag.properties = p2; return testTag; }
protected static void invokeMethodConsideringTimeout(ITestNGMethod tm, ConstructorOrMethod method, Object targetInstance, Object[] params, ITestResult testResult) throws Throwable { if (MethodHelper.calculateTimeOut(tm) <= 0) { MethodInvocationHelper.invokeMethod(method.getMethod(), targetInstance, params); } else { MethodInvocationHelper.invokeWithTimeout(tm, targetInstance, params, testResult); if (!testResult.isSuccess()) { // A time out happened Throwable ex = testResult.getThrowable(); testResult.setStatus(ITestResult.FAILURE); testResult.setThrowable(ex.getCause() == null ? ex : ex.getCause()); throw testResult.getThrowable(); } } }
@Test public void testWithOnlyOneThread() { addClass(TestClassSample.class); run(); Collection<List<ITestResult>> failed = getFailedTests().values(); Assert.assertEquals(failed.size(), 1); ITestResult failedResult = failed.iterator().next().get(0); Assert.assertTrue(failedResult.getThrowable() instanceof ThreadTimeoutException); Assert.assertEquals(failedResult.getThrowable().getMessage(), String.format("Method %s.testMethod() didn't finish within the time-out 1000", TestClassSample.class.getName())); }
@Override public void onTestFailure(ITestResult testResult) { String methodName = testResult.getMethod().getMethodName(); String raw = testResult.getThrowable().getMessage(); String actual = raw.split("\n")[1]; failures.put(methodName, actual); }
@Test public void testExceptions() { InvokedMethodNameListener listener = run(DataProviderIntegrationSample.class); Throwable exception = listener.getResult("theTest").getThrowable(); assertThat(exception).isInstanceOf(MethodMatcherException.class); }
/** * An exception was thrown by the test, determine if this method * should be marked as a failure or as failure_but_within_successPercentage */ private void handleException(Throwable throwable, ITestNGMethod testMethod, ITestResult testResult, int failureCount) { if (throwable != null && testResult.getThrowable() == null) { testResult.setThrowable(throwable); } int successPercentage= testMethod.getSuccessPercentage(); int invocationCount= testMethod.getInvocationCount(); float numberOfTestsThatCanFail= ((100 - successPercentage) * invocationCount) / 100f; if(failureCount < numberOfTestsThatCanFail) { testResult.setStatus(ITestResult.SUCCESS_PERCENTAGE_FAILURE); } else { testResult.setStatus(ITestResult.FAILURE); } }
private static Throwable getConfigFailureException(ITestContext context) { for (IInvokedMethod method : context.getSuite().getAllInvokedMethods()) { ITestNGMethod m = method.getTestMethod(); if (m.isBeforeSuiteConfiguration() && (!method.getTestResult().isSuccess())) { return method.getTestResult().getThrowable(); } } return null; }
public void generateReport(List<XmlSuite> list, List<ISuite> suites, String s) { for (ISuite suite : suites) { for (ISuiteResult suiteResult : suite.getResults().values()) { ITestContext ctx = suiteResult.getTestContext(); Set<ITestResult> results = ctx.getSkippedTests().getAllResults(); for (ITestResult result : results) { Throwable throwable = result.getThrowable(); errors.add(throwable); } } } }
@Test(description = "GITHUB1509") public void testDataProvidersThatReturnNull() { TestListenerAdapter tla = new TestListenerAdapter(); TestNG tng = create(Github1509TestClassSample.class); tng.addListener(tla); tng.run(); assertThat(tla.getFailedTests()).size().isEqualTo(1); ITestResult result = tla.getFailedTests().get(0); String className = Github1509TestClassSample.class.getName() + ".getData()"; String msg = "Data Provider public java.lang.Object[][] " + className + " returned a null value"; assertThat(result.getThrowable().getMessage()).contains(msg); }
@Test public void testCreateParametersUsingDataProviderNegativeCase() { XmlTest xmlTest = createXmlTest("suite", "test"); Class<?> clazz = ExceptionThrowingDataDrivenSampleTestClass.class; ITestNGMethod testNGMethod = new FakeTestNGMethod(clazz, "testMethod", xmlTest); ParameterHandler.ParameterBag params = invokeParameterCreation(testNGMethod); assertThat(params.parameterHolder).isNull(); assertThat(params.errorResult).isNotNull(); assertThat(params.errorResult.getThrowable()) .hasCauseInstanceOf(UnsupportedOperationException.class); }
@Override public void run(final IHookCallBack callBack, final ITestResult testResult) { // Make sure we start with a clean state assertListenerStatus(); // Run the actual test callBack.runTestMethod(testResult); if (testResult.getThrowable() == null) { // Make sure we finish in a clean state (if the test didn't fail) assertListenerStatus(); } }
@Override public void afterInvocation(IInvokedMethod method, ITestResult testResult) { m_afterCount++; if (method.getTestMethod().isAfterSuiteConfiguration()) { suiteStatus = testResult.getStatus(); suiteThrowable = testResult.getThrowable(); } if (method.getTestMethod().isTest()) { methodStatus = testResult.getStatus(); methodThrowable = testResult.getThrowable(); } }
private static Throwable getConfigFailureException(ITestContext context) { for (IInvokedMethod method : context.getSuite().getAllInvokedMethods()) { ITestNGMethod m = method.getTestMethod(); if (m.isBeforeSuiteConfiguration() && (!method.getTestResult().isSuccess())) { return method.getTestResult().getThrowable(); } } return null; } }