Refine search
private void generateSuiteResult(String suiteName, ISuiteResult sr, String cssClass, StringBuilder tableOfContents) { ITestContext tc = sr.getTestContext(); int passed = tc.getPassedTests().size(); int failed = tc.getFailedTests().size(); int skipped = tc.getSkippedTests().size(); String baseFile = tc.getName(); tableOfContents .append("\n<table width='100%' class='test-").append(cssClass).append("'>\n") .append("<tr><td>\n") .append("<table style='width: 100%'><tr>") .append("<td valign='top'>") .append(suiteName).append(" (").append(passed).append("/").append(failed).append("/").append(skipped).append(")") .append(CLOSE_TD) .append("<td valign='top' align='right'>\n") .append(" <a href='").append(baseFile).append(".html' target='mainFrame'>Results</a>\n") .append(CLOSE_TD) .append("</tr></table>\n") .append("</td></tr><p/>\n") ; tableOfContents.append("</table>\n"); }
/** Creates a section showing known results for each method */ protected void generateMethodDetailReport(List<ISuite> suites) { m_methodIndex = 0; for (ISuite suite : suites) { Map<String, ISuiteResult> r = suite.getResults(); for (ISuiteResult r2 : r.values()) { ITestContext testContext = r2.getTestContext(); if (r.values().size() > 0) { m_out.println("<h1>" + testContext.getName() + "</h1>"); } resultDetail(testContext.getFailedConfigurations()); resultDetail(testContext.getFailedTests()); resultDetail(testContext.getSkippedConfigurations()); resultDetail(testContext.getSkippedTests()); resultDetail(testContext.getPassedTests()); } } }
public List<ITestResult> getAllTestResults(ISuite suite, boolean testsOnly) { List<ITestResult> result = Lists.newArrayList(); for (ISuiteResult sr : suite.getResults().values()) { result.addAll(sr.getTestContext().getPassedTests().getAllResults()); result.addAll(sr.getTestContext().getFailedTests().getAllResults()); result.addAll(sr.getTestContext().getSkippedTests().getAllResults()); if (! testsOnly) { result.addAll(sr.getTestContext().getPassedConfigurations().getAllResults()); result.addAll(sr.getTestContext().getFailedConfigurations().getAllResults()); result.addAll(sr.getTestContext().getSkippedConfigurations().getAllResults()); } } return result; } }
Map<String, ISuiteResult> suiteResults = suite.getResults(); int groupCount = suite.getMethodsByGroups().size(); int methodCount = 0; for (ISuiteResult sr : suiteResults.values()) { ITestNGMethod[] methods = sr.getTestContext().getAllTestMethods(); methodCount += Utils.calculateInvokedMethodCount(methods); String name = "Results for " + suite.getName(); tableOfContents .append("<html>\n") String suiteName = entry.getKey(); ISuiteResult sr = entry.getValue(); ITestContext tc = sr.getTestContext(); int failed = tc.getFailedTests().size(); int skipped = tc.getSkippedTests().size(); int passed = tc.getPassedTests().size(); ISuiteResult[] r = results[i]; for (ISuiteResult sr: r) { String suiteName = sr.getTestContext().getName(); generateSuiteResult(suiteName, sr, colors[i], tableOfContents);
public void calculateResultCounts(XmlSuite xmlSuite, SuiteRunnerMap suiteRunnerMap) { ISuite iSuite = suiteRunnerMap.get(xmlSuite); if (iSuite != null) { Map<String, ISuiteResult> results = iSuite.getResults(); if (results != null) { Collection<ISuiteResult> tempSuiteResult = results.values(); for (ISuiteResult isr : tempSuiteResult) { ITestContext ctx = isr.getTestContext(); int skipped = ctx.getSkippedTests().size(); int failed = ctx.getFailedTests().size() + ctx.getFailedButWithinSuccessPercentageTests().size(); m_skipped += skipped; m_failed += failed; m_confFailures += ctx.getFailedConfigurations().size(); m_confSkips += ctx.getSkippedConfigurations().size(); m_total += ctx.getPassedTests().size() + failed + skipped; } for (XmlSuite childSuite : xmlSuite.getChildSuites()) { calculateResultCounts(childSuite, suiteRunnerMap); } } } } }
int ignored = 0; for (ISuite s : suites) { Map<String, ISuiteResult> suiteResults = s.getResults(); for (ISuiteResult sr : suiteResults.values()) { ITestContext testContext = sr.getTestContext(); passed += testContext.getPassedTests().size(); failed += testContext.getFailedTests().size(); skipped += testContext.getSkippedTests().size(); ignored += testContext.getExcludedMethods().size();
private void writeAllToBuffer(XMLStringBuffer xmlBuffer, ISuiteResult suiteResult) { xmlBuffer.push(XMLReporterConfig.TAG_TEST, getSuiteResultAttributes(suiteResult)); Set<ITestResult> testResults = Sets.newHashSet(); ITestContext testContext = suiteResult.getTestContext(); addAllTestResults(testResults, testContext.getPassedTests()); addAllTestResults(testResults, testContext.getFailedTests()); addAllTestResults(testResults, testContext.getSkippedTests()); addAllTestResults(testResults, testContext.getPassedConfigurations()); addAllTestResults(testResults, testContext.getSkippedConfigurations()); addAllTestResults(testResults, testContext.getFailedConfigurations()); addAllTestResults(testResults, testContext.getFailedButWithinSuccessPercentageTests()); addTestResults(xmlBuffer, testResults); xmlBuffer.pop(); }
protected void generateFailureSuite(XmlSuite xmlSuite, ISuite suite, String outputDir) { XmlSuite failedSuite = xmlSuite.shallowCopy(); failedSuite.setName("Failed suite [" + xmlSuite.getName() + "]"); m_xmlSuite= failedSuite; Map<String, ISuiteResult> results = suite.getResults(); for(Map.Entry<String, ISuiteResult> entry : results.entrySet()) { ISuiteResult suiteResult = entry.getValue(); ITestContext testContext = suiteResult.getTestContext(); generateXmlTest(testContext.getCurrentXmlTest(), testContext, testContext.getFailedTests().getAllResults(), testContext.getSkippedTests().getAllResults()); } if(null != failedSuite.getTests() && failedSuite.getTests().size() > 0) { Utils.writeUtf8File(outputDir, TESTNG_FAILED_XML, failedSuite.toXml()); Utils.writeUtf8File(suite.getOutputDirectory(), TESTNG_FAILED_XML, failedSuite.toXml()); } }
@Override public void generateReport( List<XmlSuite> xmlSuites, List<ISuite> suites, String outputDirectory) { for (ISuite suite : suites) { for (Map.Entry<String, ISuiteResult> testResult : suite.getResults().entrySet()) { Set<ITestResult> results = testResult.getValue().getTestContext().getFailedTests().getAllResults(); if (results.isEmpty()) { continue; } System.out.println( "Failures in <suite> :" + suite.getName() + ", <test> :" + testResult.getKey()); for (ITestResult result : results) { String c = result.getMethod().getRealClass().getName(); String m = result.getMethod().getMethodName() + "()"; System.out.println(c + "." + m); if (result.getThrowable() != null) { StringWriter sw = new StringWriter(); PrintWriter writer = new PrintWriter(sw); result.getThrowable().printStackTrace(writer); System.out.println( String.format("StackTrace:\n %s \n", Utils.filterTrace(sw.toString()))); } } } } } }
final Map<String, ISuiteResult> tests = suite.getResults(); for (final ISuiteResult r : tests.values()) { final ITestContext overview = r.getTestContext(); final ShortTestResult mini = new ShortTestResult(overview.getName()); q = overview.getAllTestMethods().length; qty_method += q; mini.setTotalMethod(q); q = overview.getPassedTests().size(); qty_pass_s += q; mini.setInstancesPassed(q); q = skippedTests.get(overview.getName()).size(); qty_skip += q; mini.setInstancesSkipped(q); if (isRetryHandleNeeded.get(overview.getName())) { q = failedTests.get(overview.getName()).size(); } else { q = failedTests.get(overview.getName()).size()
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); } } } }
private Properties getSuiteResultAttributes(ISuiteResult suiteResult) { Properties attributes = new Properties(); ITestContext tc = suiteResult.getTestContext(); attributes.setProperty(XMLReporterConfig.ATTR_NAME, tc.getName()); XMLReporter.addDurationAttributes(config, attributes, tc.getStartDate(), tc.getEndDate()); return attributes; }
/** * Reads the test results and extracts summary information. Each entry in * the results corresponds to a test set (conformance class). * * @param results * The results for all test sets that were executed. */ void summarizeResults(Map<String, ISuiteResult> results) { Date earliestStartDate = new Date(); Date latestEndDate = new Date(); for (Map.Entry<String, ISuiteResult> entry : results.entrySet()) { ITestContext testContext = entry.getValue().getTestContext(); this.totalPassed += testContext.getPassedTests().size(); this.totalFailed += testContext.getFailedTests().size(); this.totalSkipped += testContext.getSkippedTests().size(); Date startDate = testContext.getStartDate(); if (earliestStartDate.after(startDate)) { earliestStartDate = startDate; } Date endDate = testContext.getEndDate(); if (latestEndDate.before(endDate)) { latestEndDate = (endDate != null) ? endDate : startDate; } } this.totalDuration = Duration.between(earliestStartDate.toInstant(), latestEndDate.toInstant()); }
private static void generateReport(String name, ISuiteResult suiteResult) { ITestContext ctx = suiteResult.getTestContext(); IResultMap failedConfigs = ctx.getFailedConfigurations(); boolean hasFailedConfigs = !failedConfigs.getAllMethods().isEmpty(); IResultMap failedTests = ctx.getFailedTests(); boolean hasFailedTests = !failedTests.getAllResults().isEmpty(); if (!hasFailedConfigs && !hasFailedTests) { return; } if (hasFailedConfigs) { System.err.println(Strings.repeat("=", 100)); System.err.println("::::::Failed Configurations for Suite ::: [" + name + "] ::: Test name [" + ctx.getName() + "]::::::"); System.err.println(Strings.repeat("=", 100)); failedConfigs.getAllResults().forEach(FailedInformationOnConsoleReporter::generateReport); System.err.println(Strings.repeat("=", 100)); System.err.println("\n\n"); } if (hasFailedTests) { System.err.println(Strings.repeat("=", 100)); System.err.println("::::::Failed Tests for Suite ::: [" + name + "] ::: Test name [" + ctx.getName() + "]::::::"); System.err.println(Strings.repeat("=", 100)); failedTests.getAllResults().forEach(FailedInformationOnConsoleReporter::generateReport); System.err.println(Strings.repeat("=", 100)); System.err.println("\n\n"); } }
private Properties getSuiteAttributes(ISuite suite) { Properties props = new Properties(); props.setProperty(XMLReporterConfig.ATTR_NAME, suite.getName()); // Calculate the duration Map<String, ISuiteResult> results = suite.getResults(); Date minStartDate = new Date(); Date maxEndDate = null; // TODO: We could probably optimize this in order not to traverse this twice for (Map.Entry<String, ISuiteResult> result : results.entrySet()) { ITestContext testContext = result.getValue().getTestContext(); Date startDate = testContext.getStartDate(); Date endDate = testContext.getEndDate(); if (minStartDate.after(startDate)) { minStartDate = startDate; } if (maxEndDate == null || maxEndDate.before(endDate)) { maxEndDate = endDate != null ? endDate : startDate; } } // The suite could be completely empty if (maxEndDate == null) { maxEndDate = minStartDate; } addDurationAttributes(config, props, minStartDate, maxEndDate); return props; }
public SuiteResult(ISuite suite) { suiteName = suite.getName(); mode = suite.getXmlSuite().getParallel(); for (ISuiteResult suiteResult : suite.getResults().values()) { testResults.add(new TestResult(suiteResult.getTestContext())); } }
/** * Writes the specified ISuiteResult in the given XMLStringBuffer. Please consider that depending on the settings in * the <code>config</code> property it might generate an additional XML file with the actual content and only * reference the file with an <code>url</code> attribute in the passed XMLStringBuffer. * * @param xmlBuffer The XML buffer where to write or reference the suite result * @param suiteResult The <code>ISuiteResult</code> to serialize */ public void writeSuiteResult(XMLStringBuffer xmlBuffer, ISuiteResult suiteResult) { if (XMLReporterConfig.FF_LEVEL_SUITE_RESULT != config.getFileFragmentationLevel()) { writeAllToBuffer(xmlBuffer, suiteResult); } else { String parentDir = config.getOutputDirectory() + File.separatorChar + suiteResult.getTestContext().getSuite().getName(); File file = referenceSuiteResult(xmlBuffer, parentDir, suiteResult); XMLStringBuffer suiteXmlBuffer = new XMLStringBuffer(); writeAllToBuffer(suiteXmlBuffer, suiteResult); Utils.writeUtf8File(file.getAbsoluteFile().getParent(), file.getName(), suiteXmlBuffer.toXML()); } }
private void createMethodContent(List<ISuite> suites, String outdir) { logger.entering(new Object[] { suites, outdir }); for (ISuite suite : suites) { Map<String, ISuiteResult> r = suite.getResults(); for (ISuiteResult r2 : r.values()) { ITestContext ctx = r2.getTestContext(); ITestNGMethod[] methods = ctx.getAllTestMethods(); for (int i = 0; i < methods.length; i++) { createMethod(ctx, methods[i], outdir); } } } logger.exiting(); }
protected void generateReportsSection(final List<ISuite> suites) { m_out.println("<div id='reports'>"); for (final ISuite suite : suites) { final Map<String, ISuiteResult> r = suite.getResults(); for (final ISuiteResult r2 : r.values()) { final ITestContext tc = r2.getTestContext(); final int envtp = getNbInstanceForGroup(true, tc.getPassedTests()); int envtf = getNbInstanceForGroup(true, failedTests.get(tc.getName())); int envts = getNbInstanceForGroup(true, skippedTests.get(tc.getName())); envtf += getNbInstanceForGroup(true, tc.getFailedConfigurations()); envts += getNbInstanceForGroup(true, tc.getSkippedConfigurations()); final int testp = getNbInstanceForGroup(false, tc.getPassedTests()); final int testf = getNbInstanceForGroup(false, failedTests.get(tc.getName())); final int tests = getNbInstanceForGroup(false, skippedTests.get(tc.getName())); final String envthtml = generateHTML(tc, true, suite, tc); final String testhtml = generateHTML(tc, false, suite, tc); final StringBuffer globalErrorTabs = new StringBuffer(); final StringBuffer globalErrorHtmls = new StringBuffer(); generateGlobalErrorHTML(tc, globalErrorTabs, globalErrorHtmls); generateReportDetailsContainer(tc.getName(), envtp, envtf, envts, testp, testf, tests, envthtml, testhtml, globalErrorTabs.toString(), globalErrorHtmls.toString()); } } m_out.println("</div>"); }
@Override public void generateReport(List<XmlSuite> xmlSuites, List<ISuite> suites, String outputDirectory) { for (ISuite s : suites) { for (ISuiteResult sr : s.getResults().values()) { ITestContext ctx = sr.getTestContext(); Assert.assertEquals(2, ctx.getSkippedTests().size()); } } } };