KaneAI - World’s First E2E Software Testing Agent.Book a Demo 
How to use getConfigurationListeners method of org.testng.TestRunner class
Best Testng code snippet using org.testng.TestRunner.getConfigurationListeners
Source:TestRunner.java 
...292 initMethods();293 }294 initListeners();295 addConfigurationListener(m_confListener);296 for (IConfigurationListener cl : m_configuration.getConfigurationListeners()) {297 addConfigurationListener(cl);298 }299 }300 private void initListeners() {301 //302 // Find all the listener factories and collect all the listeners requested in a303 // @Listeners annotation.304 //305 Set<Class<? extends ITestNGListener>> listenerClasses = Sets.newHashSet();306 Class<? extends ITestNGListenerFactory> listenerFactoryClass = null;307 for (IClass cls : getTestClasses()) {308 Class<?> realClass = cls.getRealClass();309 TestListenerHelper.ListenerHolder listenerHolder =310 TestListenerHelper.findAllListeners(realClass, m_annotationFinder);311 if (listenerFactoryClass == null) {312 listenerFactoryClass = listenerHolder.getListenerFactoryClass();313 }314 listenerClasses.addAll(listenerHolder.getListenerClasses());315 }316 if (listenerFactoryClass == null) {317 listenerFactoryClass = DefaultListenerFactory.class;318 }319 //320 // Now we have all the listeners collected from @Listeners and at most one321 // listener factory collected from a class implementing ITestNGListenerFactory.322 // Instantiate all the requested listeners.323 //324 ITestNGListenerFactory factory =325 TestListenerHelper.createListenerFactory(m_testClassFinder, listenerFactoryClass);326 // Instantiate all the listeners327 for (Class<? extends ITestNGListener> c : listenerClasses) {328 if (IClassListener.class.isAssignableFrom(c) && m_classListeners.containsKey(c)) {329 continue;330 }331 ITestNGListener listener = factory.createListener(c);332 addListener(listener);333 }334 }335 /** Initialize meta groups */336 private void initMetaGroups(XmlTest xmlTest) {337 Map<String, List<String>> metaGroups = xmlTest.getMetaGroups();338 for (Map.Entry<String, List<String>> entry : metaGroups.entrySet()) {339 addMetaGroup(entry.getKey(), entry.getValue());340 }341 }342 private void initRunInfo(final XmlTest xmlTest) {343 // Groups344 m_xmlMethodSelector.setIncludedGroups(createGroups(m_xmlTest.getIncludedGroups()));345 m_xmlMethodSelector.setExcludedGroups(createGroups(m_xmlTest.getExcludedGroups()));346 m_xmlMethodSelector.setScript(m_xmlTest.getScript());347 // Groups override348 m_xmlMethodSelector.setOverrideIncludedMethods(m_configuration.getOverrideIncludedMethods());349 // Methods350 m_xmlMethodSelector.setXmlClasses(m_xmlTest.getXmlClasses());351 m_runInfo.addMethodSelector(m_xmlMethodSelector, 10);352 // Add user-specified method selectors (only class selectors, we can ignore353 // script selectors here)354 if (null != xmlTest.getMethodSelectors()) {355 for (org.testng.xml.XmlMethodSelector selector : xmlTest.getMethodSelectors()) {356 if (selector.getClassName() != null) {357 IMethodSelector s = InstanceCreator.createSelector(selector);358 m_runInfo.addMethodSelector(s, selector.getPriority());359 }360 }361 }362 }363 private void initMethods() {364 //365 // Calculate all the methods we need to invoke366 //367 List<ITestNGMethod> beforeClassMethods = Lists.newArrayList();368 List<ITestNGMethod> testMethods = Lists.newArrayList();369 List<ITestNGMethod> afterClassMethods = Lists.newArrayList();370 List<ITestNGMethod> beforeSuiteMethods = Lists.newArrayList();371 List<ITestNGMethod> afterSuiteMethods = Lists.newArrayList();372 List<ITestNGMethod> beforeXmlTestMethods = Lists.newArrayList();373 List<ITestNGMethod> afterXmlTestMethods = Lists.newArrayList();374 ClassInfoMap classMap = new ClassInfoMap(m_testClassesFromXml);375 m_testClassFinder =376 new TestNGClassFinder(377 classMap, Maps.newHashMap(), m_configuration, this, holder);378 ITestMethodFinder testMethodFinder =379 new TestNGMethodFinder(m_runInfo, m_annotationFinder, comparator);380 m_runInfo.setTestMethods(testMethods);381 //382 // Initialize TestClasses383 //384 IClass[] classes = m_testClassFinder.findTestClasses();385 for (IClass ic : classes) {386 // Create TestClass387 ITestClass tc =388 new TestClass(389 ic,390 testMethodFinder,391 m_annotationFinder,392 m_xmlTest,393 classMap.getXmlClass(ic.getRealClass()), m_testClassFinder.getFactoryCreationFailedMessage());394 m_classMap.put(ic.getRealClass(), tc);395 }396 //397 // Calculate groups methods398 //399 Map<String, List<ITestNGMethod>> beforeGroupMethods =400 MethodGroupsHelper.findGroupsMethods(m_classMap.values(), true);401 Map<String, List<ITestNGMethod>> afterGroupMethods =402 MethodGroupsHelper.findGroupsMethods(m_classMap.values(), false);403 //404 // Walk through all the TestClasses, store their method405 // and initialize them with the correct ITestClass406 //407 for (ITestClass tc : m_classMap.values()) {408 fixMethodsWithClass(tc.getTestMethods(), tc, testMethods);409 fixMethodsWithClass(((ITestClassConfigInfo) tc).getAllBeforeClassMethods().toArray(new ITestNGMethod[0]), tc, beforeClassMethods);410 fixMethodsWithClass(tc.getBeforeTestMethods(), tc, null);411 fixMethodsWithClass(tc.getAfterTestMethods(), tc, null);412 fixMethodsWithClass(tc.getAfterClassMethods(), tc, afterClassMethods);413 fixMethodsWithClass(tc.getBeforeSuiteMethods(), tc, beforeSuiteMethods);414 fixMethodsWithClass(tc.getAfterSuiteMethods(), tc, afterSuiteMethods);415 fixMethodsWithClass(tc.getBeforeTestConfigurationMethods(), tc, beforeXmlTestMethods);416 fixMethodsWithClass(tc.getAfterTestConfigurationMethods(), tc, afterXmlTestMethods);417 fixMethodsWithClass(418 tc.getBeforeGroupsMethods(),419 tc,420 MethodHelper.uniqueMethodList(beforeGroupMethods.values()));421 fixMethodsWithClass(422 tc.getAfterGroupsMethods(),423 tc,424 MethodHelper.uniqueMethodList(afterGroupMethods.values()));425 }426 //427 // Sort the methods428 //429 m_beforeSuiteMethods =430 MethodHelper.collectAndOrderMethods(431 beforeSuiteMethods,432 false /* forTests */,433 m_runInfo,434 m_annotationFinder,435 true /* unique */,436 m_excludedMethods,437 comparator);438 m_beforeXmlTestMethods =439 MethodHelper.collectAndOrderMethods(440 beforeXmlTestMethods,441 false /* forTests */,442 m_runInfo,443 m_annotationFinder,444 true /* unique (CQ added by me)*/,445 m_excludedMethods,446 comparator);447 m_classMethodMap = new ClassMethodMap(Arrays.asList(testMethodsContainer.getItems()), m_xmlMethodSelector);448 m_groupMethods = new ConfigurationGroupMethods(testMethodsContainer, beforeGroupMethods, afterGroupMethods);449 m_afterXmlTestMethods =450 MethodHelper.collectAndOrderMethods(451 afterXmlTestMethods,452 false /* forTests */,453 m_runInfo,454 m_annotationFinder,455 true /* unique (CQ added by me)*/,456 m_excludedMethods,457 comparator);458 m_afterSuiteMethods =459 MethodHelper.collectAndOrderMethods(460 afterSuiteMethods,461 false /* forTests */,462 m_runInfo,463 m_annotationFinder,464 true /* unique */,465 m_excludedMethods,466 comparator);467 }468 private ITestNGMethod[] computeAndGetAllTestMethods() {469 List<ITestNGMethod> testMethods = Lists.newArrayList();470 for (ITestClass tc : m_classMap.values()) {471 fixMethodsWithClass(tc.getTestMethods(), tc, testMethods);472 }473 return MethodHelper.collectAndOrderMethods(474 testMethods,475 true /* forTest? */,476 m_runInfo,477 m_annotationFinder,478 false /* unique */,479 m_excludedMethods,480 comparator);481 }482 public Collection<ITestClass> getTestClasses() {483 return m_classMap.values();484 }485 public void setTestName(String name) {486 m_testName = name;487 }488 public void setOutputDirectory(String od) {489 m_outputDirectory = od;490 }491 private void addMetaGroup(String name, List<String> groupNames) {492 m_metaGroups.put(name, groupNames);493 }494 private Map<String, String> createGroups(List<String> groups) {495 return GroupsHelper.createGroups(m_metaGroups, groups);496 }497 /**498 * The main entry method for TestRunner.499 *500 * <p>This is where all the hard work is done: - Invoke configuration methods - Invoke test501 * methods - Catch exceptions - Collect results - Invoke listeners - etc...502 */503 public void run() {504 beforeRun();505 try {506 XmlTest test = getTest();507 if (test.isJUnit()) {508 privateRunJUnit();509 } else {510 privateRun(test);511 }512 } finally {513 afterRun();514 forgetHeavyReferencesIfNeeded();515 }516 }517 private void forgetHeavyReferencesIfNeeded() {518 if (RuntimeBehavior.isMemoryFriendlyMode()) {519 testMethodsContainer.clearItems();520 m_groupMethods = null;521 m_classMethodMap = null;522 }523 }524 /** Before run preparements. */525 private void beforeRun() {526 //527 // Log the start date528 //529 m_startDate = new Date(System.currentTimeMillis());530 // Log start531 logStart();532 // Invoke listeners533 fireEvent(true /*start*/);534 // invoke @BeforeTest535 ITestNGMethod[] testConfigurationMethods = getBeforeTestConfigurationMethods();536 invokeTestConfigurations(testConfigurationMethods);537 }538 private void invokeTestConfigurations(ITestNGMethod[] testConfigurationMethods) {539 if (null != testConfigurationMethods && testConfigurationMethods.length > 0) {540 ConfigMethodArguments arguments = new Builder()541 .usingConfigMethodsAs(testConfigurationMethods)542 .forSuite(m_xmlTest.getSuite())543 .usingParameters(m_xmlTest.getAllParameters())544 .build();545 m_invoker.getConfigInvoker().invokeConfigurations(arguments);546 }547 }548 private ITestNGMethod[] m_allJunitTestMethods = new ITestNGMethod[] {};549 private void privateRunJUnit() {550 final ClassInfoMap cim = new ClassInfoMap(m_testClassesFromXml, false);551 final Set<Class<?>> classes = cim.getClasses();552 final List<ITestNGMethod> runMethods = Lists.newArrayList();553 List<IWorker<ITestNGMethod>> workers = Lists.newArrayList();554 // FIXME: directly referencing JUnitTestRunner which uses JUnit classes555 // may result in an class resolution exception under different JVMs556 // The resolution process is not specified in the JVM spec with a specific implementation,557 // so it can be eager => failure558 workers.add(559 new IWorker<ITestNGMethod>() {560 /** @see TestMethodWorker#getTimeOut() */561 @Override562 public long getTimeOut() {563 return 0;564 }565 /** @see java.lang.Runnable#run() */566 @Override567 public void run() {568 for (Class<?> tc : classes) {569 List<XmlInclude> includedMethods = cim.getXmlClass(tc).getIncludedMethods();570 List<String> methods = Lists.newArrayList();571 for (XmlInclude inc : includedMethods) {572 methods.add(inc.getName());573 }574 IJUnitTestRunner tr = IJUnitTestRunner.createTestRunner(TestRunner.this);575 tr.setInvokedMethodListeners(m_invokedMethodListeners);576 try {577 tr.run(tc, methods.toArray(new String[0]));578 } catch (Exception ex) {579 LOGGER.error(ex.getMessage(), ex);580 } finally {581 runMethods.addAll(tr.getTestMethods());582 }583 }584 }585 @Override586 public List<ITestNGMethod> getTasks() {587 throw new TestNGException("JUnit not supported");588 }589 @Override590 public int getPriority() {591 if (m_allJunitTestMethods.length == 1) {592 return m_allJunitTestMethods[0].getPriority();593 } else {594 return 0;595 }596 }597 @Override598 public int compareTo(@Nonnull IWorker<ITestNGMethod> other) {599 return getPriority() - other.getPriority();600 }601 });602 runJUnitWorkers(workers);603 m_allJunitTestMethods = runMethods.toArray(new ITestNGMethod[0]);604 }605 private static Comparator<ITestNGMethod> newComparator(boolean needPrioritySort) {606 return needPrioritySort ? new TestMethodComparator() : null;607 }608 private boolean sortOnPriority(ITestNGMethod[] interceptedOrder) {609 return m_methodInterceptors.size() > 1 ||610 Arrays.stream(interceptedOrder).anyMatch(m -> m.getPriority() != 0);611 }612 // If any of the test methods specify a priority other than the default, we'll need to be able to sort them.613 private static BlockingQueue<Runnable> newQueue(boolean needPrioritySort) {614 return needPrioritySort ? new PriorityBlockingQueue<>() : new LinkedBlockingQueue<>();615 }616 /**617 * Main method that create a graph of methods and then pass it to the graph executor to run them.618 */619 private void privateRun(XmlTest xmlTest) {620 boolean parallel = xmlTest.getParallel().isParallel();621 // parallel622 int threadCount = parallel ? xmlTest.getThreadCount() : 1;623 // Make sure we create a graph based on the intercepted methods, otherwise an interceptor624 // removing methods would cause the graph never to terminate (because it would expect625 // termination from methods that never get invoked).626 ITestNGMethod[] interceptedOrder = intercept(getAllTestMethods());627 AtomicReference<IDynamicGraph<ITestNGMethod>> reference = new AtomicReference<>();628 TimeUtils.computeAndShowTime("DynamicGraphHelper.createDynamicGraph()",629 () -> {630 IDynamicGraph<ITestNGMethod> ref = DynamicGraphHelper631 .createDynamicGraph(interceptedOrder, getCurrentXmlTest());632 reference.set(ref);633 }634 );635 IDynamicGraph<ITestNGMethod> graph = reference.get();636 graph.setVisualisers(this.visualisers);637 // In some cases, additional sorting is needed to make sure tests run in the appropriate order.638 // If the user specified a method interceptor, or if we have any methods that have a non-default639 // priority on them, we need to sort.640 boolean needPrioritySort = sortOnPriority(interceptedOrder);641 Comparator<ITestNGMethod> methodComparator = newComparator(needPrioritySort);642 if (parallel) {643 if (graph.getNodeCount() <= 0) {644 return;645 }646 ITestNGThreadPoolExecutor executor =647 this.m_configuration.getExecutorFactory().newTestMethodExecutor(648 "test=" + xmlTest.getName(),649 graph,650 this,651 threadCount,652 threadCount,653 0,654 TimeUnit.MILLISECONDS,655 newQueue(needPrioritySort),656 methodComparator);657 executor.run();658 try {659 long timeOut = m_xmlTest.getTimeOut(XmlTest.DEFAULT_TIMEOUT_MS);660 Utils.log(661 "TestRunner",662 2,663 "Starting executor for test "664 + m_xmlTest.getName()665 + " with time out:"666 + timeOut667 + " milliseconds.");668 executor.awaitTermination(timeOut, TimeUnit.MILLISECONDS);669 executor.shutdownNow();670 } catch (InterruptedException handled) {671 LOGGER.error(handled.getMessage(), handled);672 Thread.currentThread().interrupt();673 }674 return;675 }676 List<ITestNGMethod> freeNodes = graph.getFreeNodes();677 if (graph.getNodeCount() > 0 && freeNodes.isEmpty()) {678 throw new TestNGException("No free nodes found in:" + graph);679 }680 while (!freeNodes.isEmpty()) {681 if (needPrioritySort) {682 freeNodes.sort(methodComparator);683 // Since this is sequential, let's run one at a time and fetch/sort freeNodes after each method.684 // Future task: To optimize this, we can only update freeNodes after running a test that another test is dependent upon.685 freeNodes = freeNodes.subList(0, 1);686 }687 createWorkers(freeNodes).forEach(Runnable::run);688 graph.setStatus(freeNodes, IDynamicGraph.Status.FINISHED);689 freeNodes = graph.getFreeNodes();690 }691 }692 /** Apply the method interceptor (if applicable) to the list of methods. */693 private ITestNGMethod[] intercept(ITestNGMethod[] methods) {694 List<IMethodInstance> methodInstances =695 MethodHelper.methodsToMethodInstances(Arrays.asList(methods));696 for (IMethodInterceptor m_methodInterceptor : m_methodInterceptors) {697 methodInstances = m_methodInterceptor.intercept(methodInstances, this);698 }699 List<ITestNGMethod> result = MethodHelper.methodInstancesToMethods(methodInstances);700 // Since an interceptor is involved, we would need to ensure that the ClassMethodMap object is701 // in sync with the702 // output of the interceptor, else @AfterClass doesn't get executed at all when interceptors are703 // involved.704 // so let's update the current classMethodMap object with the list of methods obtained from the705 // interceptor.706 this.m_classMethodMap = new ClassMethodMap(result, null);707 ITestNGMethod[] resultArray = result.toArray(new ITestNGMethod[0]);708 // Check if an interceptor had altered the effective test method count. If yes, then we need to709 // update our configurationGroupMethod object with that information.710 if (resultArray.length != testMethodsContainer.getItems().length) {711 m_groupMethods =712 new ConfigurationGroupMethods(713 new TestMethodContainer(() -> resultArray),714 m_groupMethods.getBeforeGroupsMethods(),715 m_groupMethods.getAfterGroupsMethods());716 }717 // If the user specified a method interceptor, whatever that returns is the order we're going718 // to run things in. Set the intercepted priority for that case.719 // There's a built-in interceptor, so look for more than one.720 if (m_methodInterceptors.size() > 1) {721 for (int i = 0; i < resultArray.length; ++i) {722 resultArray[i].setInterceptedPriority(i);723 }724 }725 return resultArray;726 }727 /**728 * Create a list of workers to run the methods passed in parameter. Each test method is run in its729 * own worker except in the following cases: - The method belongs to a class that730 * has @Test(sequential=true) - The parallel attribute is set to "classes" In both these cases,731 * all the methods belonging to that class will then be put in the same worker in order to run in732 * the same thread.733 */734 @Override735 public List<IWorker<ITestNGMethod>> createWorkers(List<ITestNGMethod> methods) {736 AbstractParallelWorker.Arguments args =737 new AbstractParallelWorker.Arguments.Builder()738 .classMethodMap(this.m_classMethodMap)739 .configMethods(this.m_groupMethods)740 .finder(this.m_annotationFinder)741 .invoker(this.m_invoker)742 .methods(methods)743 .testContext(this)744 .listeners(this.m_classListeners.values())745 .build();746 return AbstractParallelWorker.newWorker(m_xmlTest.getParallel(), m_xmlTest.getGroupByInstances()).createWorkers(args);747 }748 //749 // Invoke the workers750 //751 private void runJUnitWorkers(List<? extends IWorker<ITestNGMethod>> workers) {752 // Sequential run753 workers.forEach(Runnable::run);754 }755 private void afterRun() {756 // invoke @AfterTest757 ITestNGMethod[] testConfigurationMethods = getAfterTestConfigurationMethods();758 invokeTestConfigurations(testConfigurationMethods);759 //760 // Log the end date761 //762 m_endDate = new Date(System.currentTimeMillis());763 dumpInvokedMethods();764 // Invoke listeners765 fireEvent(false /*stop*/);766 }767 /** Logs the beginning of the {@link #beforeRun()} . */768 private void logStart() {769 log(770 "Running test "771 + m_testName772 + " on "773 + m_classMap.size()774 + " "775 + " classes, "776 + " included groups:["777 + Strings.valueOf(m_xmlMethodSelector.getIncludedGroups())778 + "] excluded groups:["779 + Strings.valueOf(m_xmlMethodSelector.getExcludedGroups())780 + "]");781 if (getVerbose() >= 3) {782 for (ITestClass tc : m_classMap.values()) {783 ((TestClass) tc).dump();784 }785 }786 }787 /**788 * Trigger the start/finish event.789 *790 * @param isStart <tt>true</tt> if the event is for start, <tt>false</tt> if the event is for791 * finish792 */793 private void fireEvent(boolean isStart) {794 for (ITestListener itl : m_testListeners) {795 if (isStart) {796 itl.onStart(this);797 } else {798 itl.onFinish(this);799 }800 }801 }802 /////803 // ITestContext804 //805 @Override806 public String getName() {807 return m_testName;808 }809 /** @return Returns the startDate. */810 @Override811 public Date getStartDate() {812 return m_startDate;813 }814 /** @return Returns the endDate. */815 @Override816 public Date getEndDate() {817 return m_endDate;818 }819 @Override820 public IResultMap getPassedTests() {821 return m_passedTests;822 }823 @Override824 public IResultMap getSkippedTests() {825 return m_skippedTests;826 }827 @Override828 public IResultMap getFailedTests() {829 return m_failedTests;830 }831 @Override832 public IResultMap getFailedButWithinSuccessPercentageTests() {833 return m_failedButWithinSuccessPercentageTests;834 }835 @Override836 public String[] getIncludedGroups() {837 Map<String, String> ig = m_xmlMethodSelector.getIncludedGroups();838 return ig.values().toArray(new String[0]);839 }840 @Override841 public String[] getExcludedGroups() {842 Map<String, String> eg = m_xmlMethodSelector.getExcludedGroups();843 return eg.values().toArray(new String[0]);844 }845 @Override846 public String getOutputDirectory() {847 return m_outputDirectory;848 }849 /** @return Returns the suite. */850 @Override851 public ISuite getSuite() {852 return m_suite;853 }854 @Override855 public ITestNGMethod[] getAllTestMethods() {856 if (getTest().isJUnit()) {857 //This is true only when we are running JUnit mode858 return m_allJunitTestMethods;859 }860 return testMethodsContainer.getItems();861 }862 @Override863 public String getHost() {864 return m_host;865 }866 @Override867 public Collection<ITestNGMethod> getExcludedMethods() {868 Map<ITestNGMethod, ITestNGMethod> vResult = Maps.newHashMap();869 for (ITestNGMethod m : m_excludedMethods) {870 vResult.put(m, m);871 }872 return vResult.keySet();873 }874 /** @see org.testng.ITestContext#getFailedConfigurations() */875 @Override876 public IResultMap getFailedConfigurations() {877 return m_failedConfigurations;878 }879 @Override880 public IResultMap getConfigurationsScheduledForInvocation() {881 return m_configsToBeInvoked;882 }883 /** @see org.testng.ITestContext#getPassedConfigurations() */884 @Override885 public IResultMap getPassedConfigurations() {886 return m_passedConfigurations;887 }888 /** @see org.testng.ITestContext#getSkippedConfigurations() */889 @Override890 public IResultMap getSkippedConfigurations() {891 return m_skippedConfigurations;892 }893 @Override894 public void addPassedTest(ITestNGMethod tm, ITestResult tr) {895 m_passedTests.addResult(tr);896 }897 @Override898 public Set<ITestResult> getPassedTests(ITestNGMethod tm) {899 return m_passedTests.getResults(tm);900 }901 @Override902 public Set<ITestResult> getFailedTests(ITestNGMethod tm) {903 return m_failedTests.getResults(tm);904 }905 @Override906 public Set<ITestResult> getSkippedTests(ITestNGMethod tm) {907 return m_skippedTests.getResults(tm);908 }909 @Override910 public void addSkippedTest(ITestNGMethod tm, ITestResult tr) {911 m_skippedTests.addResult(tr);912 }913 @Override914 public void addFailedTest(ITestNGMethod testMethod, ITestResult result) {915 logFailedTest(result, false /* withinSuccessPercentage */);916 }917 @Override918 public void addFailedButWithinSuccessPercentageTest(919 ITestNGMethod testMethod, ITestResult result) {920 logFailedTest(result, true /* withinSuccessPercentage */);921 }922 @Override923 public XmlTest getTest() {924 return m_xmlTest;925 }926 @Override927 public List<ITestListener> getTestListeners() {928 return m_testListeners;929 }930 @Override931 public List<IConfigurationListener> getConfigurationListeners() {932 List<IConfigurationListener> listeners = Lists.newArrayList(m_configurationListeners);933 for (IConfigurationListener each : this.m_configuration.getConfigurationListeners()) {934 boolean duplicate = false;935 for (IConfigurationListener listener : listeners) {936 if (each.getClass().equals(listener.getClass())) {937 duplicate = true;938 break;939 }940 }941 if (!duplicate) {942 listeners.add(each);943 }944 }945 return Lists.newArrayList(listeners);946 }947 private void logFailedTest(ITestResult tr, boolean withinSuccessPercentage) {...
Source:SuiteRunner.java
...450 }451 for (ITestListener itl : m_failureGenerators) {452 testRunner.addListener(itl);453 }454 for (IConfigurationListener cl : m_configuration.getConfigurationListeners()) {455 testRunner.addConfigurationListener(cl);456 }457 return testRunner;458 }459 }460 private static class ProxyTestRunnerFactory implements ITestRunnerFactory {461 private ITestListener[] m_failureGenerators;462 private ITestRunnerFactory m_target;463 public ProxyTestRunnerFactory(ITestListener[] failureListeners, ITestRunnerFactory target) {464 m_failureGenerators = failureListeners;465 m_target= target;466 }467 @Override468 public TestRunner newTestRunner(ISuite suite, XmlTest test,...
Source:JUnit4TestRunner.java
...129 tr = createTestResult(failure.getDescription());130 tr.setStatus(TestResult.FAILURE);131 tr.setEndMillis(Calendar.getInstance().getTimeInMillis());132 tr.setThrowable(failure.getException());133 for (IConfigurationListener l : m_parentRunner.getConfigurationListeners()) {134 l.onConfigurationFailure(tr);135 }136 for (Description childDesc : failure.getDescription().getChildren()) {137 testIgnored(childDesc);138 }139 } else {140 tr.setStatus(TestResult.FAILURE);141 tr.setEndMillis(Calendar.getInstance().getTimeInMillis());142 tr.setThrowable(failure.getException());143 m_parentRunner.addFailedTest(tr.getMethod(), tr);144 for (ITestListener l : m_listeners) {145 l.onTestFailure(tr);146 }147 }...
Source:RemoteTestNG6_9_10.java
...28 if (m_useDefaultListeners) {29 runner.addListener(new TestHTMLReporter());30 runner.addListener(new JUnitXMLReporter());31 }32 for (IConfigurationListener cl : getConfiguration().getConfigurationListeners()) {33 runner.addListener(cl);34 }35 return runner;36 }37 };38 }39 return m_customTestRunnerFactory;40 }41 @Override42 protected ITestRunnerFactory createDelegatingTestRunnerFactory(ITestRunnerFactory trf, MessageHub smsh) {43 return new DelegatingTestRunnerFactory(trf, smsh);44 }45 private static class DelegatingTestRunnerFactory implements ITestRunnerFactory {46 private final ITestRunnerFactory m_delegateFactory;...
Source:RemoteTestNG6_5.java
...26 if (m_useDefaultListeners) {27 runner.addListener(new TestHTMLReporter());28 runner.addListener(new JUnitXMLReporter());29 }30 for (IConfigurationListener cl : getConfiguration().getConfigurationListeners()) {31 runner.addListener(cl);32 }33 return runner;34 }35 };36 }37 return m_customTestRunnerFactory;38 }39 @Override40 protected ITestRunnerFactory createDelegatingTestRunnerFactory(ITestRunnerFactory trf, MessageHub smsh) {41 return new DelegatingTestRunnerFactory(trf, smsh);42 }43 private static class DelegatingTestRunnerFactory implements ITestRunnerFactory {44 private final ITestRunnerFactory m_delegateFactory;...
Source:RemoteTestNG6_9_7.java
...26 if (m_useDefaultListeners) {27 runner.addListener(new TestHTMLReporter());28 runner.addListener(new JUnitXMLReporter());29 }30 for (IConfigurationListener cl : getConfiguration().getConfigurationListeners()) {31 runner.addListener(cl);32 }33 return runner;34 }35 };36 }37 return m_customTestRunnerFactory;38 }39 @Override40 protected ITestRunnerFactory createDelegatingTestRunnerFactory(ITestRunnerFactory trf, MessageHub smsh) {41 return new DelegatingTestRunnerFactory(trf, smsh);42 }43 private static class DelegatingTestRunnerFactory implements ITestRunnerFactory {44 private final ITestRunnerFactory m_delegateFactory;...
Source:020fb.java
...13 transient private boolean m_skipFailedInvocationCounts;14@@ -1416,7 +1416,7 @@15 16 @Override17 public List<IConfigurationListener> getConfigurationListeners() {18- return m_configurationListeners;19+ return Lists.<IConfigurationListener>newArrayList(m_configurationListeners);20 }21 //22 // ITestResultNotifier...
Source:43b55.java
...8 for (ITestListener itl : m_failureGenerators) {9- testRunner.addListener(itl);10+ testRunner.addTestListener(itl);11 }12 for (IConfigurationListener cl : m_configuration.getConfigurationListeners()) {13 testRunner.addConfigurationListener(cl);...
getConfigurationListeners
Using AI Code Generation
1package com.automationrhapsody.testng;2import java.util.List;3import org.testng.IConfigurationListener;4import org.testng.ITestContext;5import org.testng.ITestResult;6import org.testng.TestListenerAdapter;7import org.testng.TestNG;8import org.testng.annotations.Test;9public class TestRunnerTest {10 public void testGetConfigurationListeners() {11 TestRunner testRunner = new TestRunner();12 List<IConfigurationListener> configurationListeners = testRunner.getConfigurationListeners();13 System.out.println("Configuration listeners: " + configurationListeners);14 }15 private static class TestRunner extends TestNG {16 public List<IConfigurationListener> getConfigurationListeners() {17 return super.getConfigurationListeners();18 }19 }20}21package com.automationrhapsody.testng;22import java.util.List;23import org.testng.IConfigurationListener;24import org.testng.ITestContext;25import org.testng.ITestResult;26import org.testng.TestListenerAdapter;27import org.testng.TestNG;28import org.testng.annotations.Test;29public class TestRunnerTest {30 public void testGetConfigurationListeners() {31 TestRunner testRunner = new TestRunner();32 List<IConfigurationListener> configurationListeners = testRunner.getConfigurationListeners();33 System.out.println("Configuration listeners: " + configurationListeners);34 }35 private static class TestRunner extends TestNG {36 public List<IConfigurationListener> getConfigurationListeners() {37 return super.getConfigurationListeners();38 }39 }40}41package com.automationrhapsody.testng;42import java.util.List;43import org.testng.IConfigurationListener;44import org.testng.ITestContext;45import org.testng.ITestResult;46import org.testng.TestListenerAdapter;47import org.testng.TestNG;48import org.testng.annotations.Test;49public class TestRunnerTest {50 public void testGetConfigurationListeners() {51 TestRunner testRunner = new TestRunner();52 List<IConfigurationListener> configurationListeners = testRunner.getConfigurationListeners();53 System.out.println("Configuration listeners: " + configurationListeners);54 }55 private static class TestRunner extends TestNG {56 public List<IConfigurationListener> getConfigurationListeners() {57 return super.getConfigurationListeners();58 }59 }60}61package com.automationrhapsody.testng;62import java.util.List;63import org.testng.IConfigurationListener;64import org.testng.ITestContext;65import org.testng.ITestResult;66import org.testng.TestListenerAdapter;67import org.testng.TestNG;68import org.testng.annotations.Test;
getConfigurationListeners
Using AI Code Generation
1package com.test;2import java.util.List;3import org.testng.ITestNGListener;4import org.testng.TestRunner;5public class GetConfigurationListeners {6 public static void main(String[] args) {7 TestRunner testRunner = new TestRunner();8 List<ITestNGListener> list = testRunner.getConfigurationListeners();9 System.out.println(list);10 }11}
getConfigurationListeners
Using AI Code Generation
1public void testConfigurationListeners() {2 TestRunner testRunner = new TestRunner();3 IConfigurationListener[] configurationListeners = testRunner.getConfigurationListeners();4 Assert.assertEquals(configurationListeners.length, 1);5}6public void testSetConfigurationListeners() {7 TestRunner testRunner = new TestRunner();8 IConfigurationListener[] configurationListeners = testRunner.getConfigurationListeners();9 testRunner.setConfigurationListeners(configurationListeners);10}11public void testAddConfigurationListener() {12 TestRunner testRunner = new TestRunner();13 IConfigurationListener[] configurationListeners = testRunner.getConfigurationListeners();14 testRunner.addConfigurationListener(configurationListeners[0]);15}16public void testRemoveConfigurationListener() {17 TestRunner testRunner = new TestRunner();18 IConfigurationListener[] configurationListeners = testRunner.getConfigurationListeners();19 testRunner.removeConfigurationListener(configurationListeners[0]);20}21public void testGetTestListeners() {22 TestRunner testRunner = new TestRunner();23 ITestListener[] testListeners = testRunner.getTestListeners();24 Assert.assertEquals(testListeners.length, 1);25}26public void testSetTestListeners() {27 TestRunner testRunner = new TestRunner();28 ITestListener[] testListeners = testRunner.getTestListeners();29 testRunner.setTestListeners(testListeners);30}31public void testAddTestListener() {32 TestRunner testRunner = new TestRunner();33 ITestListener[] testListeners = testRunner.getTestListeners();34 testRunner.addTestListener(testListeners[0]);35}36public void testRemoveTestListener() {37 TestRunner testRunner = new TestRunner();38 ITestListener[] testListeners = testRunner.getTestListeners();39 testRunner.removeTestListener(testListeners[0]);40}41public void testGetMethodInterceptors() {42 TestRunner testRunner = new TestRunner();
getConfigurationListeners
Using AI Code Generation
1import java.util.List;2import java.util.Map;3import java.util.Set;4import org.testng.ITestContext;5import org.testng.ITestNGMethod;6import org.testng.TestRunner;7import
TestNG tutorial
TestNG is a Java-based open-source framework for test automation that includes various test types, such as unit testing, functional testing, E2E testing, etc. TestNG is in many ways similar to JUnit and NUnit. But in contrast to its competitors, its extensive features make it a lot more reliable framework. One of the major reasons for its popularity is its ability to structure tests and improve the scripts' readability and maintainability. Another reason can be the important characteristics like the convenience of using multiple annotations, reliance, and priority that make this framework popular among developers and testers for test design. You can refer to the TestNG tutorial to learn why you should choose the TestNG framework.
Chapters
- JUnit 5 vs. TestNG: Compare and explore the core differences between JUnit 5 and TestNG from the Selenium WebDriver viewpoint.
- Installing TestNG in Eclipse: Start installing the TestNG Plugin and learn how to set up TestNG in Eclipse to begin constructing a framework for your test project.
- Create TestNG Project in Eclipse: Get started with creating a TestNG project and write your first TestNG test script.
- Automation using TestNG: Dive into how to install TestNG in this Selenium TestNG tutorial, the fundamentals of developing an automation script for Selenium automation testing.
- Parallel Test Execution in TestNG: Here are some essential elements of parallel testing with TestNG in this Selenium TestNG tutorial.
- Creating TestNG XML File: Here is a step-by-step tutorial on creating a TestNG XML file to learn why and how it is created and discover how to run the TestNG XML file being executed in parallel.
- Automation with Selenium, Cucumber & TestNG: Explore for an in-depth tutorial on automation using Selenium, Cucumber, and TestNG, as TestNG offers simpler settings and more features.
- JUnit Selenium Tests using TestNG: Start running your regular and parallel tests by looking at how to run test cases in Selenium using JUnit and TestNG without having to rewrite the tests.
- Group Test Cases in TestNG: Along with the explanation and demonstration using relevant TestNG group examples, learn how to group test cases in TestNG.
- Prioritizing Tests in TestNG: Get started with how to prioritize test cases in TestNG for Selenium automation testing.
- Assertions in TestNG: Examine what TestNG assertions are, the various types of TestNG assertions, and situations that relate to Selenium automated testing.
- DataProviders in TestNG: Deep dive into learning more about TestNG's DataProvider and how to effectively use it in our test scripts for Selenium test automation.
- Parameterization in TestNG: Here are the several parameterization strategies used in TestNG tests and how to apply them in Selenium automation scripts.
- TestNG Listeners in Selenium WebDriver: Understand the various TestNG listeners to utilize them effectively for your next plan when working with TestNG and Selenium automation.
- TestNG Annotations: Learn more about the execution order and annotation attributes, and refer to the prerequisites required to set up TestNG.
- TestNG Reporter Log in Selenium: Find out how to use the TestNG Reporter Log and learn how to eliminate the need for external software with TestNG Reporter Class to boost productivity.
- TestNG Reports in Jenkins: Discover how to generate TestNG reports in Jenkins if you want to know how to create, install, and share TestNG reports in Jenkins.
Certification
You can push your abilities to do automated testing using TestNG and advance your career by earning a TestNG certification. Check out our TestNG certification.
YouTube
Watch this complete tutorial to learn how you can leverage the capabilities of the TestNG framework for Selenium automation testing.
Run Testng automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Most used method in TestRunner
- getInvoker
- getBeforeSuiteMethods
- getAfterSuiteMethods
- getBeforeTestConfigurationMethods
- getAfterTestConfigurationMethods
- getTestClasses
- setTestName
- setOutputDirectory
- run
- createWorkers
- getName
- getStartDate
- getEndDate
- getPassedTests
- getSkippedTests
- getFailedTests
- getFailedButWithinSuccessPercentageTests
- getIncludedGroups
- getExcludedGroups
- getOutputDirectory
- getSuite
- getAllTestMethods
- getHost
- getExcludedMethods
- getFailedConfigurations
- getConfigurationsScheduledForInvocation
- getPassedConfigurations
- getSkippedConfigurations
- addPassedTest
- addSkippedTest
- addFailedTest
- addFailedButWithinSuccessPercentageTest
- getTest
- getTestListeners
- getConfigurationListeners
- getVerbose
- setVerbose
- addListener
- getCurrentXmlTest
- getAttribute
- setAttribute
- getAttributeNames
- removeAttribute
- getInjectorFactory
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
