testng-data-driven

TestNG Data-Driven Testing

Master TestNG data-driven testing including DataProviders, Factory patterns, and parameterization for comprehensive test coverage. This skill covers techniques for testing with multiple data sets efficiently.

Overview

Data-driven testing separates test logic from test data, enabling a single test method to run against multiple inputs. TestNG provides powerful features for data-driven testing through DataProviders, Factory methods, and XML parameterization.

DataProvider Basics

Simple DataProvider

import org.testng.annotations.; import static org.testng.Assert.;

public class SimpleDataProviderTest {

@DataProvider(name = "numbers")
public Object[][] provideNumbers() {
    return new Object[][] {
        {1, 2, 3},
        {4, 5, 9},
        {0, 0, 0},
        {-1, 1, 0}
    };
}

@Test(dataProvider = "numbers")
public void testAddition(int a, int b, int expected) {
    assertEquals(a + b, expected);
}

}

DataProvider with Single Values

public class SingleValueDataProviderTest {

@DataProvider(name = "validEmails")
public Object[][] provideValidEmails() {
    return new Object[][] {
        {"user@example.com"},
        {"test.user@domain.org"},
        {"admin+tag@company.co.uk"},
        {"user123@test.io"}
    };
}

@Test(dataProvider = "validEmails")
public void testValidEmail(String email) {
    assertTrue(isValidEmail(email), "Email should be valid: " + email);
}

private boolean isValidEmail(String email) {
    return email != null &#x26;&#x26; email.matches("^[\\w+.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$");
}

}

Advanced DataProvider Patterns

DataProvider in Separate Class

// DataProviders class public class TestDataProviders {

@DataProvider(name = "userData")
public static Object[][] provideUserData() {
    return new Object[][] {
        {"john", "john@example.com", 25},
        {"jane", "jane@example.com", 30},
        {"bob", "bob@example.com", 22}
    };
}

@DataProvider(name = "loginCredentials")
public static Object[][] provideLoginCredentials() {
    return new Object[][] {
        {"admin", "admin123", true},
        {"user", "user456", true},
        {"invalid", "wrong", false}
    };
}

}

// Test class using external DataProvider public class UserTest {

@Test(dataProvider = "userData", dataProviderClass = TestDataProviders.class)
public void testUserCreation(String name, String email, int age) {
    User user = new User(name, email, age);
    assertNotNull(user);
    assertEquals(user.getName(), name);
    assertEquals(user.getEmail(), email);
    assertEquals(user.getAge(), age);
}

@Test(dataProvider = "loginCredentials", dataProviderClass = TestDataProviders.class)
public void testLogin(String username, String password, boolean expectedSuccess) {
    boolean result = authService.login(username, password);
    assertEquals(result, expectedSuccess);
}

}

DataProvider with Method Context

import org.testng.ITestContext; import org.testng.annotations.*; import java.lang.reflect.Method;

public class ContextAwareDataProviderTest {

@DataProvider(name = "contextAwareData")
public Object[][] provideContextAwareData(ITestContext context, Method method) {
    String testName = method.getName();
    String suiteName = context.getSuite().getName();

    System.out.println("Providing data for: " + testName + " in suite: " + suiteName);

    if (testName.contains("Admin")) {
        return new Object[][] {
            {"admin", "ADMIN_ROLE"},
            {"superadmin", "SUPER_ADMIN_ROLE"}
        };
    } else {
        return new Object[][] {
            {"user1", "USER_ROLE"},
            {"user2", "USER_ROLE"}
        };
    }
}

@Test(dataProvider = "contextAwareData")
public void testAdminAccess(String username, String role) {
    // Test admin access
}

@Test(dataProvider = "contextAwareData")
public void testUserAccess(String username, String role) {
    // Test user access
}

}

Parallel DataProvider

public class ParallelDataProviderTest {

@DataProvider(name = "parallelData", parallel = true)
public Object[][] provideParallelData() {
    return new Object[][] {
        {"Test 1"},
        {"Test 2"},
        {"Test 3"},
        {"Test 4"},
        {"Test 5"},
        {"Test 6"},
        {"Test 7"},
        {"Test 8"},
        {"Test 9"},
        {"Test 10"}
    };
}

@Test(dataProvider = "parallelData")
public void testParallel(String data) {
    System.out.println(Thread.currentThread().getName() + " - " + data);
    // Tests run in parallel threads
}

}

Iterator DataProvider

import java.util.Iterator; import java.util.Arrays;

public class IteratorDataProviderTest {

@DataProvider(name = "iteratorData")
public Iterator&#x3C;Object[]> provideIteratorData() {
    // Useful for large datasets - generates data on demand
    return Arrays.asList(
        new Object[]{"data1", 1},
        new Object[]{"data2", 2},
        new Object[]{"data3", 3}
    ).iterator();
}

@Test(dataProvider = "iteratorData")
public void testWithIterator(String name, int value) {
    assertNotNull(name);
    assertTrue(value > 0);
}

}

Lazy DataProvider for Large Datasets

import java.util.Iterator; import java.util.NoSuchElementException;

public class LazyDataProviderTest {

@DataProvider(name = "lazyData")
public Iterator&#x3C;Object[]> provideLazyData() {
    return new Iterator&#x3C;Object[]>() {
        private int current = 0;
        private final int max = 1000;

        @Override
        public boolean hasNext() {
            return current &#x3C; max;
        }

        @Override
        public Object[] next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            // Generate data on demand
            return new Object[]{
                "User_" + current,
                "user" + current + "@example.com",
                current++
            };
        }
    };
}

@Test(dataProvider = "lazyData")
public void testLargeDataset(String name, String email, int id) {
    assertNotNull(name);
    assertTrue(email.contains("@"));
}

}

Factory Pattern

Basic Factory

import org.testng.annotations.*;

public class FactoryTest { private String browser;

@Factory
public static Object[] createInstances() {
    return new Object[] {
        new FactoryTest("chrome"),
        new FactoryTest("firefox"),
        new FactoryTest("safari")
    };
}

public FactoryTest(String browser) {
    this.browser = browser;
}

@Test
public void testHomePage() {
    System.out.println("Testing home page on: " + browser);
}

@Test
public void testLoginPage() {
    System.out.println("Testing login page on: " + browser);
}

}

Factory with DataProvider

public class FactoryWithDataProviderTest { private String username; private String role;

@Factory(dataProvider = "userRoles")
public FactoryWithDataProviderTest(String username, String role) {
    this.username = username;
    this.role = role;
}

@DataProvider(name = "userRoles")
public static Object[][] provideUserRoles() {
    return new Object[][] {
        {"admin", "ADMIN"},
        {"manager", "MANAGER"},
        {"user", "USER"},
        {"guest", "GUEST"}
    };
}

@Test
public void testUserPermissions() {
    System.out.println("Testing permissions for " + username + " with role " + role);
    // Test specific permissions based on role
}

@Test
public void testUserDashboard() {
    System.out.println("Testing dashboard for " + username + " with role " + role);
    // Test dashboard features based on role
}

@Override
public String toString() {
    return username + "_" + role;
}

}

External Data Sources

CSV DataProvider

import java.io.; import java.util.;

public class CsvDataProviderTest {

@DataProvider(name = "csvData")
public Object[][] provideCsvData() throws IOException {
    List&#x3C;Object[]> data = new ArrayList&#x3C;>();

    try (BufferedReader reader = new BufferedReader(
            new FileReader("src/test/resources/testdata.csv"))) {

        String line;
        // Skip header
        reader.readLine();

        while ((line = reader.readLine()) != null) {
            String[] values = line.split(",");
            data.add(new Object[]{
                values[0].trim(),  // username
                values[1].trim(),  // email
                Integer.parseInt(values[2].trim())  // age
            });
        }
    }

    return data.toArray(new Object[0][]);
}

@Test(dataProvider = "csvData")
public void testUserFromCsv(String username, String email, int age) {
    assertNotNull(username);
    assertTrue(email.contains("@"));
    assertTrue(age > 0);
}

}

JSON DataProvider

import com.fasterxml.jackson.databind.; import java.io.; import java.util.*;

public class JsonDataProviderTest {

@DataProvider(name = "jsonData")
public Object[][] provideJsonData() throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    List&#x3C;Map&#x3C;String, Object>> testData = mapper.readValue(
        new File("src/test/resources/testdata.json"),
        new TypeReference&#x3C;List&#x3C;Map&#x3C;String, Object>>>() {}
    );

    Object[][] data = new Object[testData.size()][3];
    for (int i = 0; i &#x3C; testData.size(); i++) {
        Map&#x3C;String, Object> entry = testData.get(i);
        data[i][0] = entry.get("name");
        data[i][1] = entry.get("email");
        data[i][2] = ((Number) entry.get("age")).intValue();
    }

    return data;
}

@Test(dataProvider = "jsonData")
public void testUserFromJson(String name, String email, int age) {
    assertNotNull(name);
    assertFalse(name.isEmpty());
}

}

Excel DataProvider

import org.apache.poi.ss.usermodel.; import org.apache.poi.xssf.usermodel.XSSFWorkbook; import java.io.; import java.util.*;

public class ExcelDataProviderTest {

@DataProvider(name = "excelData")
public Object[][] provideExcelData() throws IOException {
    List&#x3C;Object[]> data = new ArrayList&#x3C;>();

    try (FileInputStream fis = new FileInputStream("src/test/resources/testdata.xlsx");
         Workbook workbook = new XSSFWorkbook(fis)) {

        Sheet sheet = workbook.getSheetAt(0);

        for (int i = 1; i &#x3C;= sheet.getLastRowNum(); i++) {
            Row row = sheet.getRow(i);
            if (row != null) {
                data.add(new Object[]{
                    getCellValue(row.getCell(0)),
                    getCellValue(row.getCell(1)),
                    (int) row.getCell(2).getNumericCellValue()
                });
            }
        }
    }

    return data.toArray(new Object[0][]);
}

private String getCellValue(Cell cell) {
    if (cell == null) return "";
    return cell.getCellType() == CellType.STRING
        ? cell.getStringCellValue()
        : String.valueOf((int) cell.getNumericCellValue());
}

@Test(dataProvider = "excelData")
public void testUserFromExcel(String name, String email, int age) {
    assertNotNull(name);
    assertTrue(age >= 0);
}

}

Advanced Parameterization

Optional Parameters

public class OptionalParameterTest {

@Parameters({"browser", "timeout"})
@BeforeClass
public void setUp(
        String browser,
        @Optional("30000") String timeout) {

    System.out.println("Browser: " + browser);
    System.out.println("Timeout: " + timeout);
}

@Test
public void testMethod() {
    // Test implementation
}

}

Combining Parameters and DataProviders

public class CombinedParametersTest {

private String environment;

@Parameters("environment")
@BeforeClass
public void setUp(String environment) {
    this.environment = environment;
}

@DataProvider(name = "users")
public Object[][] provideUsers() {
    return new Object[][] {
        {"user1", "pass1"},
        {"user2", "pass2"}
    };
}

@Test(dataProvider = "users")
public void testLogin(String username, String password) {
    System.out.println("Testing on " + environment + " with user: " + username);
    // Combine XML parameter with DataProvider data
}

}

Dynamic DataProvider Based on Parameters

public class DynamicDataProviderTest {

private static String environment;

@Parameters("environment")
@BeforeClass
public static void setUp(@Optional("staging") String env) {
    environment = env;
}

@DataProvider(name = "environmentData")
public Object[][] provideEnvironmentData() {
    switch (environment) {
        case "production":
            return new Object[][] {
                {"prod-user1", "prod-api-key-1"},
                {"prod-user2", "prod-api-key-2"}
            };
        case "staging":
            return new Object[][] {
                {"staging-user1", "staging-api-key-1"},
                {"staging-user2", "staging-api-key-2"}
            };
        default:
            return new Object[][] {
                {"dev-user", "dev-api-key"}
            };
    }
}

@Test(dataProvider = "environmentData")
public void testApiAccess(String user, String apiKey) {
    System.out.println("Testing API access for: " + user + " on " + environment);
}

}

Data Provider Naming

Named Data Provider Rows

public class NamedDataProviderTest {

@DataProvider(name = "testCases")
public Object[][] provideTestCases() {
    return new Object[][] {
        // Each row can have a name for better reporting
        {"TC001_ValidLogin", "admin", "admin123", true},
        {"TC002_InvalidPassword", "admin", "wrong", false},
        {"TC003_EmptyUsername", "", "password", false},
        {"TC004_SpecialCharacters", "user@#$", "pass@#$", false}
    };
}

@Test(dataProvider = "testCases")
public void testLogin(String testCaseId, String username, String password, boolean expected) {
    System.out.println("Executing: " + testCaseId);
    // Test implementation
}

}

Best Practices

Keep DataProviders focused - One DataProvider per data type or scenario
Use external files for large datasets - CSV, JSON, or Excel for maintainability
Make DataProviders static when shared - Required for external DataProvider classes
Include test case identifiers - First column can be test case ID for tracing
Use meaningful DataProvider names - Clear names improve test reports
Consider parallel execution - Enable parallel flag for independent tests
Handle null values explicitly - Define behavior for null/empty data
Document expected formats - Comment data structure for complex providers
Use Iterator for large datasets - Avoid memory issues with lazy loading
Separate test data from test logic - Keep tests clean and data manageable

Common Pitfalls

Type mismatches - DataProvider types must match test method parameters
Missing static modifier - External DataProvider methods must be static
Array dimension errors - Must return Object[][] not Object[]
Null pointer exceptions - Not handling null values in data
Resource leaks - Not closing file streams in DataProviders
Tight coupling - Hard-coding environment-specific data
Over-parameterization - Too many parameters make tests hard to read
Missing test case IDs - Hard to trace failures without identifiers
Ignoring execution order - DataProvider rows may run in any order
Not considering parallelism - Shared state issues with parallel DataProviders

When to Use This Skill

Testing with multiple input combinations
Implementing boundary value testing
Creating cross-browser or cross-environment tests
Loading test data from external sources
Building parameterized test suites
Creating data-driven API tests
Implementing database-driven tests
Building reusable test data frameworks

testng-data-driven

Safety Notice

Copy this and send it to your AI assistant to learn

Source Transparency

Related Skills

android-jetpack-compose

fastapi-async-patterns

storybook-story-writing