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 |
|
| 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.
|
| Assertion.SimpleAssert<T> |
|
| AssertJUnit |
A set of assert methods.
|
| Attributes |
Simple implementation of IAttributes.
|
| BannerPanel |
|
| BaseAnnotation |
|
| BaseBeforeAfter |
|
| BaseChunk |
|
| BaseClassFinder |
This class
|
| BaseInvoker |
|
| BaseMultiSuitePanel |
|
| BasePanel |
|
| BaseTestMethod |
Superclass to represent both @Test and @Configuration methods.
|
| BeforeClass |
|
| BeforeGroups |
|
| BeforeMethod |
|
| BeforeSuite |
|
| BeforeTest |
|
| Buffer |
|
| ChronologicalPanel |
|
| ClassBasedParallelWorker |
|
| 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 |
|
| CommentDisabledXmlWeaver |
This class provides String representation of both XmlSuite and XmlTest without
adding an XML comment as the test name and suite name at the end of the corresponding tags. |
| ComparisonCriteria |
Defines criteria for finding two items "equal enough".
|
| ConfigInvoker |
|
| 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 |
|
| ConstructorOrMethod |
Encapsulation of either a method or a constructor.
|
| ConversionUtils |
Helper methods used by the Eclipse plug-in when converting tests from JUnit.
|
| 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.
|
| DataProviderMethod |
|
| 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
|
| DefaultThreadPoolExecutorFactory |
|
| DefaultXmlWeaver |
This class provides String representation of both XmlSuite and XmlTest but adds
an XML comment as the test name and suite name at the end of the corresponding tags. |
| DependencyMap |
Helper class to keep track of dependencies.
|
| DirectMethodMatcher |
Checks for method argument match with or without filtering injectables.
|
| DisabledRetryAnalyzer |
|
| DomUtil |
|
| DomUtil.NodeProcessor |
|
| DomXmlParser |
|
| DotTestListener |
|
| DynamicGraph<T> |
Representation of the graph of methods.
|
| DynamicGraph.Edges<T> |
Manage edges and weights between nodes.
|
| DynamicGraphHelper |
|
| EclipseInterface |
Symbols in this class are used by the Eclipse plug-in, do not modify them without updating the
plug-in as well.
|
| EmailableReporter |
Reported designed to render self-contained HTML top down view of a testing suite.
|
| EmailableReporter.TestSorter |
Arranges methods by classname and method name
|
| 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 |
|
| ExceptionUtils |
A utility class that houses mechanisms to retrieve exception information.
|
| ExecutorAdapter |
An implementation for IExecutor based on ThreadPoolExecutor
|
| 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 |
A very simple ITestListener used by the TestNG runner to find out the exit code.
|
| 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.
|
| FutureResultAdapter |
A very reduced interface of Future.
|
| Graph<T> |
Simple graph class to implement topological sort (used to sort methods based on what groups they
depend on).
|
| Graph.Node<T> |
|
| GraphThreadPoolExecutor<T> |
An Executor that launches tasks per batches.
|
| GroupConfigMethodArguments |
|
| GroupConfigMethodArguments.Builder |
|
| GroupPanel |
|
| GroupsHelper |
|
| Guice |
This annotation specifies what Guice modules should be used to instantiate this test class.
|
| GuiceHelper |
|
| 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. |
| IAlterTestName |
Deprecated.
|
| 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.
|
| IAnnotationTransformer2 |
Deprecated.
|
| IAnnotationTransformer3 |
Deprecated.
|
| 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 |
|
| 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.
|
| IDataProvidable |
A trait shared by all the annotations that have dataProvider/dataProviderClass attributes.
|
| IDataProviderAnnotation |
Encapsulate the @DataProvider / @testng.data-provider annotation
|
| 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.
|
| IExecutor |
Reduced interface to mimic an ExecutorService.
|
| IExecutorFactory |
Represents the capabilities to be possessed by any implementation that can be plugged into TestNG
to execute nodes from a IDynamicGraph object. |
| IExpectedExceptionsHolder |
|
| IFactoryAnnotation |
Encapsulate the @Factory / @testng.factory annotation
|
| IFileParser<T> |
|
| IFutureResult |
Reduced interface to mimic Future.
|
| Ignore |
Alternative of @Test(enable=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.
|
| IInstanceInfo<T> |
This class defines a pair of instance/class.
|
| 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.
|
| IInvokedMethodListener2 |
Deprecated.
|
| IInvoker |
This class defines an invoker.
|
| IJUnitTestRunner |
An abstraction interface over JUnit test runners.
|
| 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.
|
| IModuleFactory |
This interface is used by the moduleFactory attribute of the @Guice annotation.
|
| INameFilter |
|
| INavigatorPanel |
Panels that are accessible from the navigator.
|
| InexactComparisonCriteria |
|
| InjectableParameter |
Enumeration of injectables.
|
| InjectableParameter.Assistant |
convenience means to add and remove injectables.
|
| InstanceBasedParallelParallelWorker |
|
| InstanceCreator |
Utility class for object instantiations.
|
| InstanceInfo<T> |
|
| InstanceOrderingMethodInterceptor |
A method interceptor that sorts its methods per instances (i.e.
|
| Ints |
|
| InvokedMethod |
|
| InvokedMethodListenerInvoker |
|
| InvokedMethodListenerInvoker.InvocationStrategy<LISTENER_TYPE extends IInvokedMethodListener> |
|
| InvokedMethodListenerInvoker.InvokeAfterInvocationWithContextStrategy |
|
| InvokedMethodListenerInvoker.InvokeAfterInvocationWithoutContextStrategy |
|
| InvokedMethodListenerInvoker.InvokeBeforeInvocationWithContextStrategy |
|
| InvokedMethodListenerInvoker.InvokeBeforeInvocationWithoutContextStrategy |
|
| InvokedMethodListenerMethod |
|
| InvokedMethodListenerSubtype |
|
| 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.
|
| IObjectFactory |
Factory used to create all test instances.
|
| IObjectFactory2 |
Factory used to create all test instances.
|
| IObjectFactoryAnnotation |
|
| 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.
|
| 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.
|
| ISuite |
Interface defining a Test Suite.
|
| ISuiteListener |
Listener for test suites.
|
| ISuiteParser |
|
| ISuiteResult |
This class represents the result of a suite run.
|
| ITagFactory |
|
| ITagSetter<T> |
|
| 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.
|
| 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 |
Represents the capabilities of a TestNG specific ExecutorService
|
| 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.
|
| ITestRunnerFactory2 |
Deprecated.
|
| IThreadFactory |
Reduced interface to mimic ThreadFactory.
|
| IThreadWorkerFactory<T> |
A factory that creates workers used by GraphThreadPoolExecutor
|
| IWeaveXml |
Represents the capabilities of a XML serialiser (As string)
|
| IWorker<T> |
A runnable object that is used by GraphThreadPoolExecutor to execute tasks
|
| JarFileUtils |
A Utility for extracting XmlSuite from a jar. |
| 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.
|
| JDK15TagFactory.Default<T> |
This interface is used to calculate the default value for various annotation return types.
|
| JUnit3TestClass |
|
| JUnit3TestMethod |
|
| JUnit3TestRecognizer |
|
| JUnit4ConfigurationMethod |
|
| JUnit4SpockMethod |
|
| JUnit4TestClass |
|
| JUnit4TestMethod |
|
| JUnit4TestRecognizer |
|
| JUnit4TestRunner |
A JUnit TestRunner that records/triggers all information/events necessary to TestNG.
|
| JUnitMethodFinder |
This class locates all test and configuration methods according to JUnit.
|
| JUnitReportReporter |
|
| JUnitReportReporter.TestTag |
|
| JUnitTestClass |
|
| JUnitTestFinder |
|
| JUnitTestMethod |
|
| JUnitTestRecognizer |
|
| JUnitTestRunner |
A JUnit TestRunner that records/triggers all information/events necessary to TestNG.
|
| JUnitTestRunner.TestRunInfo |
|
| JUnitXMLReporter |
A JUnit XML report generator (replacing the original JUnitXMLReporter that was based on XML
APIs).
|
| LaunchSuite |
This class is used to encapsulate a launch.
|
| LaunchSuite.ClassesAndMethodsSuite |
|
| LaunchSuite.ClassListSuite |
ClassListSuite TODO cquezel JavaDoc.
|
| LaunchSuite.CustomizedSuite |
CustomizedSuite TODO cquezel JavaDoc.
|
| LaunchSuite.ExistingSuite |
ExistingSuite is a non-temporary LaunchSuite based on an existing file.
|
| LaunchSuite.MethodsSuite |
A MethodsSuite is a suite made up of methods.
|
| 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 |
|
| Logger |
TestNG support logging via a custom logging framework similar to Log4j. |
| 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.
|
| MethodHelper.MatchResults |
|
| 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
|
| Model |
|
| Model |
|
| Model.SubModel |
|
| MultiMap<K,V,C extends java.util.Collection<V>> |
|
| Mustache |
|
| NavigatorPanel |
|
| NavigatorPanel.BaseResultProvider |
|
| NavigatorPanel.IResultProvider |
|
| NoInjection |
Turn off TestNG injection for a parameter.
|
| NoOpTestClass |
|
| 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 |
|
| Objects.ValueHolder |
|
| OnElement |
|
| OnElementList |
|
| 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> |
|
| Parameter |
This class can be replaceable by java.lang.reflect.Parameter if using jdk 1.8.
|
| ParameterHandler |
|
| ParameterHandler.ParameterBag |
This class holds a ParameterHolder or in case of an error, a non-null
TestResult containing the cause
|
| 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 |
A holder class for parameters defined just in this tag and all parameters including the ones
inherited from enclosing tags.
|
| Parameters.FilterOutInJectedTypesResult |
Store the result of parameterTypes and optionalValues after filter out injected types
|
| Parameters.MethodParameters |
A parameter passing helper class.
|
| ParametersAnnotation |
An implementation of IParameters
|
| ParentSetter |
|
| Parser |
Parser is a parser for a TestNG XML test suite file.
|
| PoolService<FutureType> |
Simple wrapper for an ExecutorCompletionService.
|
| PreserveOrderMethodInterceptor |
A method interceptor that preserves the order in which test classes were found in the
<test> tag.
|
| PropertyUtils |
Utility class for setting JavaBeans-style properties on instances.
|
| Reflect |
|
| ReflectionHelper |
|
| ReflectionRecipes |
Utility class to handle reflection.
|
| ReflectionRecipes.ListBackedImmutableQueue<T> |
|
| 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.
|
| ScriptMethodSelector |
|
| ScriptSelectorFactory |
|
| SetMultiMap<K,V> |
A container to hold sets indexed by a key.
|
| Sets |
|
| SingleTestMethodWorker |
Extends TestMethodWorker and is used to work on only a single method instance
|
| 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.
|
| StringChunk |
|
| Strings |
|
| SuiteGenerator |
Factory to create custom suites.
|
| SuiteHTMLReporter |
This class implements an HTML reporter for suites.
|
| SuitePanel |
|
| SuiteResult |
This class logs the result of an entire Test Suite (defined by a property file).
|
| SuiteResultCounts |
Class to help calculate result counts for tests run as part of a suite and its children suites
|
| SuiteRunner |
SuiteRunner is responsible for running all the tests included in one suite.
|
| SuiteRunner.DefaultTestRunnerFactory |
|
| SuiteRunner.ProxyTestRunnerFactory |
|
| 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 |
|
| Systematiser |
|
| Systematiser.Order |
|
| Tag |
|
| Tag |
|
| TagContent |
|
| 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
|
| TestClass |
This class represents a test class: - The test methods - The configuration methods (test and
method) - The class file
|
| TestException |
Exception thrown when an exception happens while running a test method.
|
| TestHTMLReporter |
This class implements an HTML reporter for individual tests.
|
| TestHTMLReporter.ConfigurationComparator |
|
| TestHTMLReporter.NameComparator |
|
| 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.
|
| TestInvoker |
|
| TestInvoker.StatusHolder |
|
| 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 |
|
| 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"
|
| TestNG |
This class is the main entry point for running tests in the TestNG framework.
|
| TestNGAntTask |
TestNG settings:
classfileset (inner)
classfilesetref (attribute)
xmlfileset (inner)
xmlfilesetref (attribute)
enableAssert (attribute)
excludedGroups (attribute)
groups (attribute)
junit (attribute)
listener (attribute)
outputdir (attribute)
parallel (attribute)
reporter (attribute)
sourcedir (attribute)
sourcedirref (attribute)
suitename (attribute)
suiterunnerclass (attribute)
target (attribute)
testjar (attribute)
testname (attribute)
threadcount (attribute)
dataproviderthreadcount (attribute)
verbose (attribute)
testrunfactory (attribute)
configFailurepolicy (attribute)
randomizeSuites (attribute)
methodselectors (attribute)
Ant settings:
classpath (inner)
classpathref (attribute)
jvm (attribute)
workingDir (attribute)
env (inner)
sysproperty (inner)
propertyset (inner)
jvmarg (inner)
timeout (attribute)
haltonfailure (attribute)
onHaltTarget (attribute)
failureProperty (attribute)
haltonFSP (attribute)
FSPproperty (attribute)
haltonskipped (attribute)
skippedProperty (attribute)
testRunnerFactory (attribute)
Debug information:
dumpCommand (boolean)
dumpEnv (boolean)
dumpSys (boolean)
|
| TestNGAntTask.Mode |
|
| TestNGAntTask.TestNGLogOS |
|
| TestNGAntTask.TestNGLogSH |
|
| TestNGClassFinder |
This class creates an ITestClass from a test class.
|
| TestNGContentHandler |
Suite definition parser utility.
|
| TestNGContentHandler.Include |
|
| TestNGContentHandler.Location |
|
| TestNGException |
The base class for all exceptions thrown by TestNG.
|
| TestNGMethod |
This class represents a test method.
|
| TestNGMethodFinder |
The default strategy for finding test methods: look up annotations @Test in front of methods.
|
| TestNGMethodFinder.MethodType |
|
| TestNgMethodUtils |
Collections of helper methods to help deal with TestNG configuration methods
|
| TestNGTagFactory |
|
| TestNGThreadFactory |
|
| TestNGUtils |
|
| TestNgXmlPanel |
|
| TestOrConfiguration |
|
| TestPanel |
Display the list of 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.
|
| ThreadUtil.ThreadFactoryImpl |
|
| 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.
|
| Utils |
Helper methods to parse annotations.
|
| Utils.StackTraceType |
|
| Value |
|
| VariableChunk |
|
| VerboseReporter |
Reporter printing out detailed messages about what TestNG is going to run and what is the status
of what has been just run.
|
| VerboseReporter.Status |
|
| 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. |
| Wrapper |
|
| XDom |
|
| XmlClass |
This class describes the tag 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 in testng.xml.
|
| XmlMethodSelectors |
|
| XmlPackage |
This class describes the tag 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.
|
| XmlWeaver |
|