How to use getInvokedAfterClassMethods method of org.testng.MethodMap class

We can use the below Spring annotation in our test case to make it either at class level or Method-level context close.

@DirtiesContext(classMode=ClassMode.AFTER_EACH_TEST_METHOD)

@DirtiesContext(classMode=ClassMode.AFTER_CLASS)

For your scenario you can do like this, You can use @FixMethodOrder(MethodSorters.NAME_ASCENDING) at class level,and annotate @DirtiesContext(methodMode=ClassMode.AFTER_EACH_TEST_METHOD) at each test case wherever you want to close the context. and keep the all the related test cases either first or last in class according to the Ascending order convention so that they will run consecutively so that they will be using the same context(without @DirtiesContext).

When I explain unit testing I like to describe them as a list of phases:

• Test Setup : Define and Create all the Data and Objects you need for the tests
• Expectations : Say what methods and parameters you expect to be executed during the test
• Test : The actual behavior/method call you want to test
• Assertions : Statements that make sure the outcome of the test were successful
• Test Tear down : Destroy any side effects that occurred during the test

jUnit is a Unit Testing Framework and provides all but the Expectations phase of testing. Alternatives in the Java space include:

• TestNG
• jtest
• jBehave (sort of)
• jDave (sort of)

Other Language equivalents include:

• PHP - phpUnit
• Ruby - Test::Unit
• Flash - FlexUnit

The concept of mocking is what added the new phase of Expectations, and since jUnit saw most of it's major development prior to the mocking movement, those features were not incorporated into the core, and a set of tools to fill that gap in the java space have opened up. Those libraries include

• EasyMock
• jMock
• jMockIt

All of these libraries are compliments to any of the above Unit Testing frameworks I listed, including jUnit. They add the ability to define mock objects. Mock objects get "expectations" assigned to them, which are then asserted in the Assertions phase. Each Mock library accomplishes this slightly differently, but the major models are

• Record Replay - EasyMock
• Expectations - jMock, jMockIt

I personally am a fan of the Expectations approach, which is more declarative, and less error prone, because it requires less methods to be called by the implementor, but that is a stylistic preference not a technical one.

Other Languages (since they came to the unit testing world later than java) don't have this seperation for the most part. The Unit Testing Library and Mock Library are one and the same. This is the case in phpunit, rspec. I imagine jUnit will not be incorporating this natively any time soon, since there is already such a rich set of alternative mock libraries available.

No, this isn't available in JUnit 5.

For a time in JUnit 3, you could extend the TestCase class and then all of your methods which were prefixed with test* would be run automatically, but not only was that more subject to breakage, it's actually actively deprecated and modern frameworks won't run with those older-style tests.

You can use reflections library and its MethodAnnotationsScanner:

Reflections reflections = new Reflections("my.package");
Set<Method> resources =
    reflections.getMethodsAnnotatedWith(org.testng.Test.class);

Your variable threadName is a local variable. There will exist one instance for each thread, more correctly, there will exist one instance for every function call. This means they can not affect each other.

1.Go to File->Settings-> Plugins>Verify that TestNG-J is enabled. 2.Configure the testNG xml file and provide it as an external source by going to edit configurations and selecting suite and providing the path of the testNG xml you created.

Please upgrade the TestNG with latest version.

Then, change the version of the TestNG in project's xml file:

 <dependency>
        <groupId>org.testng</groupId>
        <artifactId>testng</artifactId>
        <version>6.1.1</version>
        <scope>compile</scope>
    </dependency>

to

<dependency>
        <groupId>org.testng</groupId>
        <artifactId>testng</artifactId>
        <version><!-- Updated Version Name --></version>
        <scope>compile</scope>
    </dependency>

You can create a listener implementing IMethodInterceptor interface. Which will give you an ability to access groups list from your @Test and manage your "tests to execute list" as you need. At same time ITestContext parameter allows you to access the data from testNg xml. So, you can set groups to run in default testNg manner (suite xml file); but run them depending on algorithm you implement. Something like:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.testng.IMethodInstance;
import org.testng.IMethodInterceptor;
import org.testng.ITestContext;
import org.testng.annotations.Test;

public class Interceptor implements IMethodInterceptor
{

    @Override
    public List<IMethodInstance> intercept(List<IMethodInstance> methods, ITestContext context)
    {
        int methCount = methods.size();
        List<IMethodInstance> result = new ArrayList<IMethodInstance>();

        for (int i = 0; i < methCount; i++)
        {
            IMethodInstance instns = methods.get(i);
            List<String> grps = Arrays.asList(instns.getMethod().getConstructorOrMethod().getMethod().getAnnotation(Test.class).groups());
//get these groups from testng.xml via context method parameter                         
            if (grps.contains("A") && grps.contains("B"))
            {
                result.add(instns);
            }                       
        }                       
        return result;
    }
}

Should use .* to match them all as far as I know.