Java TestNG :: How are Arguments Suppled to my Test Method?

Question

I'm struggling to understand the flow of execution of some Java TestNG code that my boss assigned to me. Unfortunately, the original author is no longer with my company, so I'm on my own. I've read through a few TestNG tutorials (especially this one) but still have questions.

Here is the code's test class, which learns about the tests it is to run from an external file, runs the tests, then closes everything up:

public class MyTestDriver {

    public Object[][] data = null;

    @BeforeSuite
    public void beforeSuite() {
        // open external info file
    }

    @DataProvider(name = "GetConfigData")
    public Object[][] GetSyncConfigData() throws IOException {
        try {
            // Using external file, gather info about individual tests
            // load that info into Object[][] data, I think
        } catch (Exception e) {
            // log errors
        }
        return data;
    }
}

A test may be either an async'ed test or a sync'ed test, so those cases are handled by a subclass each. Here's the async'ed subclass:

public class AsyncAPITest extends MyTestDriver {

    @Test(dataProvider = "GetConfigData")
    public void asyncTestExecution(String RUN, String TYPE, String ENVIRONMENT, String TESTNAME) throws Exception {
        try {
            // run tests
        } catch (Exception e) {
            // log errors
        }
    }
}

Coders familiar with Java TestNG will spot the annotations.

Now, let's say I run the code and the external file specifies only one Async test should be run. In that event, I'm certain the code's order of execution would be:

@BeforeSuite
MyTestDriver.beforeSuite()

@DataProvider(name = "GetConfigData")
MyTestDriver.GetSyncConfigData()

@Test(dataProvider = "GetConfigData")
AsyncAPITest.asyncTestExecution()

But here's what I don't understand: How is information passed from MyTestDriver.GetSyncConfigData() to AsyncAPITest.asyncTestExecution()? If you look at method asyncTestExecution(), that method actually takes in quite a few arguments:

public void asyncTestExecution(String RUN, String TYPE, String ENVIRONMENT, String TESTNAME) throws Exception

What is supplying those arguments? If I look through the code of MyTestDriver.GetSyncConfigData(), shouldn't I see something like this somewhere:

// data initialized as Object[][]
// data = AsyncAPITest.asyncTestExecution(RUN, TYPE, ENVIRONMENT, TESTNAME);
return data;

I just don't understand how AsyncAPITest.asyncTestExecution() is called, or what is supplying those arguments. I'm largely asking because I want to send in more arguments for later modifications. Thank you in advance for any suggestions or observations.

The `data` is a class variable which is not reset by TestNG and that field can be seen by all test methods. Does it behave the same if you make it scoped to the method? If not, then something else (like your before suite) is influencing the results. The 2d array is for multiple test executions, e.g. `{ /* run1 */ { param1, param2 }, /* run2 */ { ... } }`. — Ben Manes, Dec 16 '21 at 21:22
@BenManes Interesting! I didn't know that data would be globally visible. I don't believe that the BeforeSuite is influencing it, so if I wanted to add more arguments to the testing method, I'd append them into data. Hmmm.... Thanks! — Pete, Dec 16 '21 at 21:39

score 1 · Accepted Answer · answered Dec 17 '21 at 02:54

data has no significance. The arguments to your @Test method are being provided by @DataProvider. The return type of Dataprovider is Object[x][y]. x means sets of arguments. y means the arguments.

In your case, the dataprovider must be returning multiple values for a set of {String RUN, String TYPE, String ENVIRONMENT, String TESTNAME}. TestNG reads these sets and provides @Test, which would be run x times with each set of arguments.

How? If you are interested, you should read the implementation in testng code, but simply said, TestNG searches for annotations using the reflections API, creates multiple methods at runtime x times with y arguments and invokes them.

If you have to add an argument, then you need to add something to y - so you would need to make your dataprovider return it and your Test method accept it.

score 1 · Answer 2 · answered Dec 17 '21 at 03:05

Since you have mentioned the name of the data provider in the annotation of your test method, testNG would scan for any matching data provider methods. Thus the GetSyncConfigData data provider method is invoked. Now, each 1d array within the 2d array returned by the data provider represents a test case. So if your data is of size Object[3][4], then there are 3 test cases and each test case provides 4 arguments to your test method.

In case if a matching data provider is not found or in case of any mismatch in the number/type of arguments, an exception would be thrown.

More info

Java TestNG :: How are Arguments Suppled to my Test Method?

2 Answers2