Refine search
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); ITestClass tc = tm.getTestClass(); m_classes.put(tc.getRealClass().getName(), tc); String name = "Results for " + suite.getName(); tableOfContents .append("<html>\n") .append(" <a target='mainFrame' href='").append(METHODS_CHRONOLOGICAL).append("'>").append("chronological</a><br/>\n") .append(" <a target='mainFrame' href='").append(METHODS_ALPHABETICAL).append("\'>").append("alphabetical</a><br/>\n") .append(" <a target='mainFrame' href='").append(METHODS_NOT_RUN).append("'>not run (").append(suite.getExcludedMethods().size()).append(")</a>") .append("</td>\n") .append("</tr>\n") ISuiteResult[] r = results[i]; for (ISuiteResult sr: r) { String suiteName = sr.getTestContext().getName(); generateSuiteResult(suiteName, sr, colors[i], tableOfContents);
@Override public void onStart(ITestContext ctx) { suiteName = ctx.getName(); log("RUNNING: Suite: \"" + suiteName + "\" containing \"" + ctx.getAllTestMethods().length + "\" Tests (config: " + ctx.getSuite().getXmlSuite().getFileName() + ")"); }
@Override public TestRunner newTestRunner(ISuite suite, XmlTest test, List<IInvokedMethodListener> listeners) { IConfiguration configuration = TestNG.getDefault().getConfiguration(); String outputDirectory = suite.getOutputDirectory(); IAnnotationFinder annotationFinder = configuration.getAnnotationFinder(); Boolean skipFailedInvocationCounts = suite.getXmlSuite().skipFailedInvocationCounts(); return new DruidTestRunner( configuration, suite, test, outputDirectory, annotationFinder, skipFailedInvocationCounts, listeners ); }
public TestRunner(IConfiguration configuration, ISuite suite, XmlTest test, boolean skipFailedInvocationCounts, Collection<IInvokedMethodListener> invokedMethodListeners, List<IClassListener> classListeners, Comparator<ITestNGMethod> comparator) { this.comparator = comparator; this.m_dataProviderListeners = Collections.emptyMap(); init(configuration, suite, test, suite.getOutputDirectory(), suite.getAnnotationFinder(), skipFailedInvocationCounts, invokedMethodListeners, classListeners); }
public SuiteResult(ISuite suite) { suiteName = suite.getName(); for (ISuiteResult suiteResult : suite.getResults().values()) { testResults.add(new TestResult(suiteResult.getTestContext())); } }
public SuiteResult(ISuite suite) { suiteName = suite.getName(); mode = suite.getXmlSuite().getParallel(); for (ISuiteResult suiteResult : suite.getResults().values()) { testResults.add(new TestResult(suiteResult.getTestContext())); } }
/** 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()); } } }
SetMultiMap<Class<?>, ITestNGMethod> mapping = new SetMultiMap(false); for (ISuite suite : suites) { Map<String, ISuiteResult> suiteResults = suite.getResults(); addMapping(mapping, suite.getExcludedMethods()); for (ISuiteResult sr : suiteResults.values()) { ITestContext tc = sr.getTestContext(); addResults(tc.getPassedTests().getAllResults(), results); addResults(tc.getFailedTests().getAllResults(), results); addResults(tc.getSkippedTests().getAllResults(), results); addResults(tc.getFailedConfigurations().getAllResults(), results); for (ITestResult tr : tc.getPassedConfigurations().getAllResults()) { if (tr.getMethod().isBeforeMethodConfiguration()) { befores.put(tr.getInstance(), tr); if (tr.getMethod().isAfterMethodConfiguration()) { afters.put(tr.getInstance(), tr);
bw.append("<br/><em>").append(suite.getName()).append("</em><p/>"); bw.append("<small><i>(Hover the method name to see the test class name)</i></small><p/>\n"); Collection<IInvokedMethod> invokedMethods = suite.getAllInvokedMethods(); if (alphabetical) { @SuppressWarnings({"unchecked"}) boolean bc = tm.isBeforeClassConfiguration(); boolean ac = tm.isAfterClassConfiguration(); boolean bt = tm.isBeforeTestConfiguration(); boolean at = tm.isAfterTestConfiguration(); boolean bs = tm.isBeforeSuiteConfiguration();
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; } }
@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()))); } } } } } }
@Override public void onStart(ITestContext context) { Logger logger = getLogger(); logger.debug("Starting tests"); if (logger.isDebugEnabled()) { logger.trace("host: " + context.getHost()); logger.trace("suite name: " + context.getSuite().getName()); logger.trace("parallel: " + context.getSuite().getParallel()); logger.trace("included groups: " + StringUtils.join(context.getIncludedGroups(), ", ")); logger.trace("excluded groups: " + StringUtils.join(context.getExcludedGroups(), ", ")); } if (logger.isTraceEnabled()) { ISuite suite = context.getSuite(); XmlSuite xmlSuite = suite.getXmlSuite(); logger.trace("thread count: " + xmlSuite.getThreadCount()); logger.trace("data provider thread count: " + xmlSuite.getDataProviderThreadCount()); logger.trace("methods: " + StringUtils.join(suite.getAllMethods(), ", ")); logger.trace("excluded methods: " + StringUtils.join(suite.getExcludedMethods(), ", ")); Set<Entry<String, String>> allParameters = xmlSuite.getAllParameters().entrySet(); for (Entry<String, String> entry : allParameters) { logger.trace(entry.getKey() + "='" + entry.getValue() + "'"); } } }
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()); } }
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); } } } } }
private void getTestMehodSummary(List<ISuite> suites) { suites.forEach(iSuite -> iSuite.getResults().values().forEach(each -> { ITestContext testObj = each.getTestContext(); getTestMethodReport(testObj.getFailedTests()); getTestMethodReport(testObj.getSkippedTests()); getTestMethodReport(testObj.getPassedTests()); })); }
+ "0, " + index + ")\n") .append("data.setCell(" + index + ", " + "1, '" + m.getMethodName() + "')\n") .append("data.setCell(" + index + ", " + "2, '" + m.getTestClass().getName() + "')\n") .append("data.setCell(" + index + ", " + "3, " + time + ");\n"); Long total = m_totalTime.get(suite.getName()); if (total == null) { total = 0L; m_totalTime.put(suite.getName(), total + time); index++;
private void updateGroups(ISuite suite, ITestResult tr) { String[] groups = tr.getMethod().getGroups(); m_groupsBySuiteName.putAll(suite.getName(), Arrays.asList(groups)); for (String group : groups) { m_methodsByGroup.put(group, tr.getMethod().getMethodName()); } }
@Override public void beforeInvocation(IInvokedMethod method, ITestResult testResult, ITestContext context) { if (!method.isTestMethod()) { return; } // Note that TCK is processing test classes sequentially in one thread - see also SingleTestClassMethodInterceptor if (totalCountOfMethods == null) { totalCountOfMethods = context.getSuite().getAllMethods().size(); } String testClassName = method.getTestMethod().getTestClass().getName(); if (!testClassName.equals(lastTestClassName)) { processedTestClasses.incrementAndGet(); lastTestClassName = testClassName; } logger.log(Level.INFO, "Invoke {0}.{1}: {2}/{3} Failed tests: {4} ({5})", new Object[] { method.getTestMethod().getTestClass().getRealClass().getSimpleName(), method.getTestMethod().getMethodName(), testMethodInvocations.incrementAndGet(), totalCountOfMethods, context.getFailedTests().size(), processedTestClasses.get() }); }
@Override public void generateReport(List<XmlSuite> xmlSuites, List<ISuite> suites, String outDir) { suites.stream() .flatMap(suite -> suite.getResults().values().stream()) .flatMap(suiteResult -> suiteResult.getTestContext().getSkippedTests().getAllResults().stream()) .forEach(this::generateReport); suites.stream() .flatMap(iSuite -> iSuite.getAllInvokedMethods().stream()) .collect(Collectors.toList()) .forEach(im -> { results.put(im.getTestMethod().getMethodName(), im.getTestResult().getStatus()); }); }
public static String getSuiteOwner(ITestContext context) { String owner = context.getSuite().getParameter("suiteOwner"); if (owner == null) { owner = ""; } return owner; } }