All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary Annotation Types Summary
| Class |
Description |
| AbstractMethodMatcher |
|
| AbstractNodeMethodMatcher |
|
| AbstractParallelWorker |
|
| AbstractParallelWorker.Arguments |
|
| AbstractParallelWorker.Arguments.Builder |
|
| AbstractXmlReporter |
|
| AbstractXmlReporter.Count |
|
| AbstractXmlReporter.Count.Builder |
|
| AfterClass |
|
| AfterGroups |
|
| AfterMethod |
|
| AfterSuite |
|
| AfterTest |
|
| AnnotationHelper |
Helper methods to find @Test and @Configuration tags.
|
| Arguments |
|
| ArrayAsserts |
|
| ArrayComparisonFailure |
Thrown when two array elements differ
|
| ArrayEndingMethodMatcher |
Checks for array ending method argument match with or without filtering injectables.
|
| ArrayIterator |
Custom iterator class over a 2D array
|
| Assert |
Assertion tool class.
|
| Assert.ThrowingRunnable |
|
| Assertion |
An assert class with various hooks allowing its behavior to be modified by subclasses.
|
| AssertJUnit |
A set of assert methods.
|
| Async |
|
| Attributes |
Simple implementation of IAttributes.
|
| AutoCloseableLock |
A simple abstraction over ReentrantLock that can be used in conjunction with
try..resources constructs.
|
| BannerPanel |
|
| BaseAnnotation |
|
| BaseBeforeAfter |
|
| BaseClassFinder |
This class
|
| BaseMultiSuitePanel |
|
| BasePanel |
|
| BaseTestMethod |
Superclass to represent both @Test and @Configuration methods.
|
| BasicAttributes |
Represents the basic attributes associated with object creation.
|
| BeforeClass |
|
| BeforeGroups |
|
| BeforeMethod |
|
| BeforeSuite |
|
| BeforeTest |
|
| Buffer |
|
| ChronologicalPanel |
|
| ClassBasedWrapper<T> |
|
| ClassHelper |
Utility class for different class manipulations.
|
| ClassImpl |
Implementation of an IClass.
|
| ClassInfoMap |
|
| ClassMethodMap |
This class maintains a map of <Class, List<ITestNGMethod>>.
|
| ClonedMethod |
|
| CollectionUtils |
|
| CommandLineArgs |
|
| ComparisonCriteria |
Defines criteria for finding two items "equal enough".
|
| ConfigMethodArguments |
|
| ConfigMethodArguments.Builder |
|
| Configuration |
|
| ConfigurationAnnotation |
An implementation of IConfiguration
|
| ConfigurationGroupMethods |
This class wraps access to beforeGroups and afterGroups methods, since they are passed around the
various invokers and potentially modified in different threads.
|
| ConfigurationMethod |
|
| ConfigurationNotInvokedException |
Represents an exception that is thrown when a configuration method is not invoked.
|
| ConstructorOrMethod |
Encapsulation of either a method or a constructor.
|
| ConversionUtils |
Deprecated. |
| Converter |
Convert XML files to YAML and vice versa.
|
| CreationAttributes |
Represents the parameters that are associated with object creation.
|
| CustomAttribute |
Represents a means to add in custom attributes to @ Test annotated tests. |
| DataProvider |
Mark a method as supplying data for a test method.
|
| DataProviderAnnotation |
An implementation of IDataProvider.
|
| DataProviderHolder |
A holder class that is aimed at acting as a container for holding various different aspects of a
data provider such as listeners/interceptors etc.,
|
| DataProviderLoader |
|
| DataProviderMethodMatcher |
Checks the conformance as per data-provide specifications.
|
| DefaultAnnotationTransformer |
|
| DefaultListenerFactory |
When no ITestNGListenerFactory implementations are available, TestNG defaults to this
implementation for instantiating listeners. |
| DefaultMethodSelectorContext |
Simple implementation of IMethodSelectorContext
|
| DefaultTestObjectFactory |
Intended to be the default way of instantiating objects within TestNG.
|
| DependencyMap |
Helper class to keep track of dependencies.
|
| DetailedAttributes |
Represents the elaborate set of attributes required for object creation.
|
| DirectMethodMatcher |
Checks for method argument match with or without filtering injectables.
|
| DisabledRetryAnalyzer |
|
| Dispenser |
Supports Object instantiation taking into account Dependency Injection.
|
| DotTestListener |
|
| DynamicGraph<T> |
Representation of the graph of methods.
|
| DynamicGraphHelper |
|
| EclipseInterface |
Symbols in this class are used by the Eclipse plug-in, do not modify them without updating the
plug-in as well.
|
| EmailableReporter2 |
Reporter that generates a single-page HTML report of the test results.
|
| EmailableReporter2.ClassResult |
|
| EmailableReporter2.MethodResult |
Groups test results by method.
|
| EmailableReporter2.SuiteResult |
|
| EmailableReporter2.TestResult |
|
| ExactComparisonCriteria |
|
| ExitCode |
|--------------------|---------|-------|------------|------------------------------------------|
| FailedWithinSuccess| Skipped | Failed| Status Code| Remarks |
|--------------------|---------|-------|------------|------------------------------------------|
| 0 | 0 | 0 | 0 | Passed tests | | 0 | 0 | 1 | 1 | Failed tests | | 0 | 1 | 0 | 2 | Skipped tests
| | 0 | 1 | 1 | 3 | Skipped/Failed tests | | 1 | 0 | 0 | 4 | FailedWithinSuccess tests | | 1 | 0
| 1 | 5 | FailedWithinSuccess/Failed tests | | 1 | 1 | 0 | 6 | FailedWithinSuccess/Skipped tests
| | 1 | 1 | 1 | 7 | FailedWithinSuccess/Skipped/Failed tests |
|--------------------|---------|-------|------------|------------------------------------------|
|
| ExitCodeListener |
|
| ExitCodeListener |
Deprecated.
|
| ExpectedExceptionsHolder |
|
| Factory |
Marks a method as a factory that returns objects that will be used by TestNG as Test classes.
|
| FactoryAnnotation |
An implementation of IFactory
|
| FactoryMethod |
This class represents a method annotated with @Factory
|
| FailedReporter |
This reporter is responsible for creating testng-failed.xml
|
| FileAssert |
Assertion tool for File centric assertions.
|
| Files |
|
| FileStringBuffer |
A string buffer that flushes its content to a temporary file whenever the internal string buffer
becomes larger than MAX.
|
| Graph<T> |
Simple graph class to implement topological sort (used to sort methods based on what groups they
depend on).
|
| Graph.Node<T> |
|
| GraphOrchestrator<T> |
An orchestrator that works with a IDynamicGraph graph to execute nodes from the DAG in an
concurrent fashion by using a ThreadPoolExecutor |
| GroupConfigMethodArguments |
|
| GroupConfigMethodArguments.Builder |
|
| GroupPanel |
|
| GroupsHelper |
|
| Guice |
This annotation specifies what Guice modules should be used to instantiate this test class.
|
| GuiceBackedInjectorFactory |
|
| GuiceContext |
|
| HtmlHelper |
|
| IAfterClass |
|
| IAfterGroups |
|
| IAfterMethod |
|
| IAfterSuite |
|
| IAfterTest |
|
| IAlterSuiteListener |
Implementations of this interface will gain access to the XmlSuite object and thus let
users be able to alter a suite or a test based on their own needs. |
| IAnnotation |
The parent interface for all the annotations.
|
| IAnnotationFinder |
This interface defines how annotations are found on classes, methods and constructors.
|
| IAnnotationTransformer |
|
| IAnnotationTransformer |
For backward compatibility.
|
| IAssert<T> |
|
| IAssertLifecycle |
Life cycle methods for the assertion class.
|
| IAttributes |
A trait that is used by all interfaces that lets the user add or remove their own attributes.
|
| IBaseBeforeAfter |
Base interface for IBeforeSuite, IAfterSuite, etc...
|
| IBaseBeforeAfterMethod |
|
| IBeforeClass |
|
| IBeforeGroups |
|
| IBeforeMethod |
|
| IBeforeSuite |
|
| IBeforeTest |
|
| IBuffer |
|
| IClass |
IClass represents a test class and a collection of its instances.
|
| IClassListener |
|
| IConfigEavesdropper |
|
| IConfigInvoker |
|
| IConfigurable |
If a test class implements this interface, its run() method will be invoked instead of each
configuration method found.
|
| IConfiguration |
|
| IConfigurationAnnotation |
Encapsulate the @Configuration / @testng.configuration annotation
|
| IConfigurationListener |
Listener interface for events related to configuration methods.
|
| IConfigurationListener2 |
Deprecated.
|
| IConfigureCallBack |
A parameter of this type will be passed to the run() method of a IConfigurable.
|
| IContainer<M> |
Represents the capabilities of a simple container to hold data
|
| ICustomizeXmlReport |
An interface that helps add custom xml tags to the TestNG generated xml report.
|
| IDataProvidable |
A trait shared by all the annotations that have dataProvider/dataProviderClass attributes.
|
| IDataProviderAnnotation |
Encapsulate the @DataProvider / @testng.data-provider annotation
|
| IDataProviderInterceptor |
This interface helps define an interceptor for data providers.
|
| IDataProviderListener |
A listener that gets invoked before and after a data provider is invoked by TestNG.
|
| IDataProviderMethod |
Represents the attributes of a DataProvider annotated method. |
| IDynamicGraph<T> |
Represents the graphical representative capabilities of an entity.
|
| IDynamicGraph.Status |
|
| IExecutionListener |
A listener used to monitor when a TestNG run starts and ends.
|
| IExecutionVisualiser |
A TestNG listener that can be used to build graph representations of TestNG methods as and when
they are being executed on a real-time basis.
|
| IExecutorServiceFactory |
Represents the capability to create a custom ExecutorService by downstream consumers.
|
| IExpectedExceptionsHolder |
|
| IFactoryAnnotation |
Encapsulate the @Factory / @testng.factory annotation
|
| IFileParser<T> |
|
| Ignore |
Alternative of @Test(enabled=false)
|
| IgnoredMethodsPanel |
|
| IgnoreListener |
|
| IHookable |
If a test class implements this interface, its run() method will be invoked instead of each @Test
method found.
|
| IHookCallBack |
A parameter of this type will be passed to the run() method of a IHookable.
|
| IIgnoreAnnotation |
Encapsulate the @ Ignore annotation |
| IInjectorFactory |
Allows customization of the Injector creation when working with dependency injection.
|
| IInstanceIdentity |
|
| IInstanceInfo<T> |
This class defines a pair of instance/class.
|
| IInvocationStatus |
Helps keep track of when a method was invoked
|
| IInvokedMethod |
An interface representing a method that has been invoked by TestNG.
|
| IInvokedMethodListener |
A listener that gets invoked before and after a method is invoked by TestNG.
|
| IInvoker |
This class defines an invoker.
|
| IListeners |
|
| IListenersAnnotation |
|
| IMethodInstance |
This interface captures a test method along with all the instances it should be run on.
|
| IMethodInterceptor |
This class is used to alter the list of test methods that TestNG is about to run.
|
| IMethodRunner |
|
| IMethodSelector |
This interface is used to augment or replace TestNG's algorithm to decide whether a test method
should be included in a test run.
|
| IMethodSelectorContext |
An implementation of this interface is passed to all the Method Selectors when their
includeMethod() is invoked.
|
| IModule |
This interface provides Module to implicitly add to the Guice context.
|
| IModuleFactory |
This interface is used by the moduleFactory attribute of the @Guice annotation.
|
| INavigatorPanel |
Panels that are accessible from the navigator.
|
| InexactComparisonCriteria |
|
| InjectableParameter |
Enumeration of injectables.
|
| InjectableParameter.Assistant |
convenience means to add and remove injectables.
|
| Input |
|
| Input.Builder |
|
| InstanceCreator |
Utility class for object instantiations.
|
| InstanceInfo<T> |
|
| Ints |
|
| InvokedMethod |
|
| InvokedMethodListenerInvoker |
|
| InvokedMethodListenerMethod |
|
| InvokeMethodRunnable |
A Runnable Method invoker.
|
| InvokeMethodRunnable.TestNGRuntimeException |
|
| Invoker |
This class is responsible for invoking methods: - test methods - configuration methods - possibly
in a separate thread and then for notifying the result listeners.
|
| IObject |
Represents the associations of a class with one or more instances.
|
| IObject.IdentifiableArrayObject |
A wrapper class that wraps around an array and associates a unique Id that can be used as a key
for the array.
|
| IObject.IdentifiableObject |
A wrapper object that associates a unique id to every unique test class object.
|
| IObjectDispenser |
Represents the capabilities of an implementation that is capable of dispensing new Objects for
TestNG
|
| IObjectFactoryAnnotation |
|
| IOrderMethods |
Helps produce a Comparator that can be used to determine order of execution for a bunch
of ITestNGMethod methods. |
| IPanel |
|
| IParameterInfo |
Represents the ability to retrieve the parameters associated with a factory method.
|
| IParameterizable |
Parent interface for annotations that can receive parameters.
|
| IParametersAnnotation |
Encapsulate the @Parameters / @testng.parameters annotation
|
| IPostProcessor |
Used by Parser to perform changes on an XML suite after it's been parsed.
|
| IReporter |
This interface can be implemented by clients to generate a report.
|
| IReporterConfig |
|
| IResultListener |
A convenient interface to use when implementing listeners.
|
| IResultListener2 |
|
| IResultMap |
|
| IRetryAnalyzer |
Interface to implement to be able to have a chance to retry a failed test.
|
| IRetryDataProvider |
Represents the ability to retry a data provider.
|
| IRetryDataProvider.DisableDataProviderRetries |
A dummy implementation which disables retrying of a failed data provider.
|
| ISuite |
Interface defining a Test Suite.
|
| ISuiteListener |
Listener for test suites.
|
| ISuiteParser |
|
| ISuiteResult |
This class represents the result of a suite run.
|
| ISuiteRunnerListener |
|
| ITest |
|
| ITest |
If a test class implements this interface, it will receive a special treatment, such as having
the test name displayed in the HTML reports.
|
| ITestAnnotation |
Encapsulate the @Test / @testng.test annotation.
|
| ITestClass |
This class represents a test class:
The test methods
The configuration methods (test and method)
The class file
Note that the methods returned by instances of this class are expected to be correct at runtime.
|
| ITestClassConfigInfo |
|
| ITestClassFinder |
This class is used by TestNG to locate the test classes.
|
| ITestContext |
This class defines a test context which contains all the information for a given test run.
|
| ITestInvoker |
|
| ITestInvoker.FailureContext |
|
| ITestListener |
A listener for test running.
|
| ITestMethodFinder |
This interface allows to modify the strategy used by TestRunner to find its test methods.
|
| ITestNGListener |
This is a marker interface for all objects that can be passed as a -listener argument.
|
| ITestNGListenerFactory |
A factory used to create instances of ITestNGListener.
|
| ITestNGMethod |
Describes a TestNG annotated method and the instance on which it will be invoked.
|
| ITestNGThreadPoolExecutor |
Deprecated.
|
| ITestObjectFactory |
Parent interface of all the object factories.
|
| ITestOrConfiguration |
This interface captures methods common to @Test and @Configuration
|
| ITestResult |
This class describes the result of a test.
|
| ITestResultNotifier |
An interface defining the notification for @Test results and also @Configuration
results.
|
| ITestRunnerFactory |
A factory for TestRunners to be used by SuiteRunners.
|
| IThreadWorkerFactory<T> |
A factory that creates workers used by GraphThreadPoolExecutor
|
| IWeaveXml |
Represents the capabilities of a XML serializer (As string)
|
| IWorker<T> |
A runnable object that is used by GraphThreadPoolExecutor to execute tasks
|
| JDK15AnnotationFinder |
This class implements IAnnotationFinder with JDK5 annotations
|
| JDK15TagFactory |
This class creates implementations of IAnnotations based on the JDK5 annotation that was found on
the Java element.
|
| JUnitReportReporter |
|
| JUnitXMLReporter |
A JUnit XML report generator (replacing the original JUnitXMLReporter that was based on XML
APIs).
|
| KeyAwareAutoCloseableLock |
A simple abstraction over ReentrantLock that can be used when
we need to be dealing with a dictionary of lockable objects wherein we traditionally would have
used the synchronized keyword.
|
| KeyAwareAutoCloseableLock.AutoReleasable |
|
| ListenerComparator |
Listener interface that can be used to determine listener execution order.
|
| ListenerOrderDeterminer |
A Utility that helps us differentiate between a user's listener and preferential Listener.
|
| Listeners |
This annotation lets you define listeners directly on a test class instead of doing so in your
testng.xml.
|
| ListenersAnnotation |
|
| ListMultiMap<K,V> |
A container to hold lists indexed by a key.
|
| Lists |
|
| LiteWeightTestNGMethod |
|
| Logger |
TestNG logging now uses slf4j logging facade to satisfy the logging needs.
|
| LoggingAssert |
Log the messages of all the assertions that get run.
|
| Main |
|
| Maps |
|
| MethodArguments |
|
| MethodGroupsHelper |
Collections of helper methods to help deal with test methods
|
| MethodHelper |
Collection of helper methods to help sort and arrange methods.
|
| MethodInheritance |
|
| MethodInstance |
|
| MethodInvocationHelper |
Collections of helper methods to help deal with invocation of TestNG methods
|
| MethodMatcher |
An interface to validate conformance of input arguments to its target method.
|
| MethodMatcherContext |
Input context for MethodMatchers.
|
| MethodMatcherException |
Thrown from MethodMatcher.
|
| MethodRunner |
|
| MethodSelectorDescriptor |
This class describes a method selector: - The class that implements it - Its priority
|
| MethodSorting |
|
| Model |
|
| MultiMap<K,V,C extends java.util.Collection<V>> |
|
| NavigatorPanel |
|
| NoInjection |
Turn off TestNG injection for a parameter.
|
| NoOpTestClass |
|
| ObjectBag |
A simple bean bag that is intended to help share objects during the lifetime of TestNG without
needing it to be a singleton.
|
| ObjectFactory |
Marks a method as the object factory to use for creating all test instances.
|
| ObjectFactoryAnnotation |
The internal representation of @ObjectFactory
|
| ObjectFactoryImpl |
Default factory for test creation.
|
| Objects |
|
| Objects.ToStringHelper |
|
| OneToTwoDimArrayIterator |
|
| OneToTwoDimIterator |
|
| Optional |
Specifies that the current parameter is optional.
|
| OverrideProcessor |
Override the groups included in the XML file with groups specified on the command line.
|
| PackageUtils |
Utility class that finds all the classes in a given package.
|
| Pair<A,B> |
|
| ParameterHolder |
A simple holder for parameters that contains the parameters and where these came from (data
provider or testng.xml)
|
| ParameterHolder.ParameterOrigin |
Origin of the parameters.
|
| ParameterInfo |
|
| Parameters |
Describes how to pass parameters to a @Test method.
|
| Parameters |
Methods that bind parameters declared in testng.xml to actual values used to invoke methods.
|
| Parameters.MethodParameters |
A parameter passing helper class.
|
| ParametersAnnotation |
An implementation of IParameters
|
| Parser |
Parser is a parser for a TestNG XML test suite file.
|
| PerformanceUtils |
|
| PerSuiteXMLReporter |
The main entry for the XML generation operation
|
| PojoReporterConfig |
|
| Processor |
|
| PropertyUtils |
Utility class for setting JavaBeans-style properties on instances.
|
| ReflectionHelper |
|
| ReflectionRecipes |
Utility class to handle reflection.
|
| RegexpExpectedExceptionsHolder |
A class that contains the expected exceptions and the message regular expression.
|
| Reporter |
This class is used for test methods to log messages that will be included in the HTML reports
generated by TestNG.
|
| ReporterConfig |
Stores the information regarding the configuration of a pluggable report listener.
|
| ReporterConfig.Property |
|
| ReporterPanel |
Display the reporter output for each test result.
|
| ResultMap |
|
| ResultsByClass |
|
| RetryAnalyzerCount |
An implementation of IRetryAnalyzer that allows you to specify the maximum number of times you
want your test to be retried.
|
| RunInfo |
This class contains all the information needed to determine what methods should be run.
|
| RuntimeBehavior |
This class houses handling all JVM arguments by TestNG
|
| RuntimeBehavior |
This class houses handling all JVM arguments related to TestNG's default reports.
|
| ScriptSelectorFactory |
|
| SetMultiMap<K,V> |
A container to hold sets indexed by a key.
|
| Sets |
|
| SkipException |
The root exception for special skip handling.
|
| SoftAssert |
When an assertion fails, don't throw an exception but record the failure.
|
| StackTraceTools |
Functionality to allow tools to analyse and subdivide stack traces.
|
| Strings |
|
| SuiteHTMLReporter |
Deprecated.
|
| SuitePanel |
|
| SuiteRunner |
SuiteRunner is responsible for running all the tests included in one suite.
|
| SuiteRunnerMap |
|
| SuiteRunnerWorker |
An IWorker that is used to encapsulate and run Suite Runners
|
| SuiteRunState |
A state object that records the status of the suite run.
|
| SuiteWorkerFactory |
An IThreadWorkerFactory for SuiteRunners
|
| SuiteXmlParser |
|
| Tarjan<T> |
Implementation of the Tarjan algorithm to find and display a cycle in a graph.
|
| Test |
Mark a class or a method as part of the test.
|
| TestAnnotation |
An implementation of ITest
|
| TestException |
Exception thrown when an exception happens while running a test method.
|
| TestHTMLReporter |
This class implements an HTML reporter for individual tests.
|
| TestInstance |
If this annotation is used on a parameter of a data provider, that parameter is the instance of
the test method which is going to be fed by this data provider.
|
| TestListenerAdapter |
A simple ITestListener adapter that stores all the tests that were run.
|
| TestListenerHelper |
A helper class that internally houses some of the listener related actions support.
|
| TestListenerHelper.ListenerHolder |
|
| TestMethodArguments |
|
| TestMethodArguments.Builder |
|
| TestMethodComparator |
|
| TestMethodContainer |
This implementation leverages a supplier to lazily load the test methods (data) for the very
first time and "remembers it" for later invocations.
|
| TestMethodWithDataProviderMethodWorker |
|
| TestMethodWorker |
FIXME: reduce contention when this class is used through parallel invocation due to
invocationCount and threadPoolSize by not invoking the @BeforeClass and @AfterClass which are
already invoked on the original method.
|
| TestNamesMatcher |
The class to work with "-testnames", "-ignoreMissedTestNames", and VM argument
"-Dtestng.ignore.missed.testnames".
|
| TestNG |
This class is the main entry point for running tests in the TestNG framework.
|
| TestNGClassFinder |
This class creates an ITestClass from a test class.
|
| TestNGContentHandler |
Suite definition parser utility.
|
| TestNGException |
The base class for all exceptions thrown by TestNG.
|
| TestNGFutureTask<T> |
|
| TestNGMethod |
This class represents a test method.
|
| TestNGMethodFinder |
The default strategy for finding test methods: look up annotations @Test in front of methods.
|
| TestNGThreadFactory |
|
| TestNGUtils |
|
| TestNgXmlPanel |
|
| TestNotInvokedException |
Represents an exception that is thrown when a test method is not invoked.
|
| TestOrConfiguration |
|
| TestPanel |
Display the list of <test> tags.
|
| TestResult |
This class represents the result of a test.
|
| TestRunner |
This class takes care of running one Test.
|
| TestRunner.PriorityWeight |
|
| TextFormatter |
This class implements a simple TextFormatter because the brainded default formatter of
java.util.logging outputs everything on two lines and it's ugly as butt.
|
| TextReporter |
A simple reporter that collects the results and prints them on standard out.
|
| ThreadExecutionException |
Wrapper exception for ExecutionExceptions.
|
| ThreadTimeoutException |
Exception used to signal a thread timeout.
|
| ThreadUtil |
A helper class to interface TestNG concurrency usage.
|
| TimeBombSkipException |
A SkipException extension that transforms a skipped method into a failed method based on
a time trigger. |
| TimesPanel |
|
| TimeUtils |
A Utility class that deals with time.
|
| TimeUtils.Task |
A sample task to be executed.
|
| UnhandledIOException |
|
| Utils |
Helper methods to parse annotations.
|
| VerboseReporter |
Reporter printing out detailed messages about what TestNG is going to run and what is the status
of what has been just run.
|
| Version |
|
| WrappedTestNGMethod |
Represents a proxy for an actual instance of ITestNGMethod but with the exception that it
generates a unique hashcode that is different from the original ITestNGMethod instance
that it wraps. |
| XmlClass |
This class describes the tag <class> in testng.xml.
|
| XMLConstants |
interface groups the XML constants tries to emulate what's in
org.apache.tools.ant.taskdefs.optional.junit.XMLConstants to be compatible with junitreport
|
| XmlDefine |
|
| XmlDependencies |
|
| XmlGroups |
|
| XmlInclude |
|
| XmlMethodSelector |
This class is the default method selector used by TestNG to determine which methods need to be
included and excluded based on the specification given in testng.xml.
|
| XmlMethodSelector |
This class describes the tag <method-selector> in testng.xml.
|
| XmlMethodSelectors |
|
| XmlPackage |
This class describes the tag <package> in testng.xml.
|
| XMLParser<T> |
|
| XMLReporter |
The main entry for the XML generation operation
|
| XMLReporterConfig |
|
| XMLReporterConfig.StackTraceLevels |
|
| XmlRun |
|
| XmlScript |
|
| XMLStringBuffer |
This class allows you to generate an XML text document by pushing and popping tags from a stack
maintained internally.
|
| XmlSuite |
This class describes the tag <suite> in testng.xml.
|
| XmlSuite.FailurePolicy |
Configuration failure policy options.
|
| XmlSuite.ParallelMode |
Parallel modes.
|
| XMLSuiteResultWriter |
Utility writing an ISuiteResult to an XMLStringBuffer.
|
| XmlSuiteUtils |
|
| XmlTest |
This class describes the tag <test> in testng.xml.
|
| XmlUtils |
|
| XMLUtils |
Static helpers for XML.
|
| Yaml |
YAML support for TestNG.
|
| YamlParser |
|