// pom.xml dependency
<dependency>
  <groupId>com.opencsv</groupId>
  <artifactId>opencsv</artifactId>
  <version>5.8</version>
</dependency>

import com.opencsv.CSVReader;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;

public class CsvDataReader {

    public static List<String[]> readCsv(String filePath) throws IOException {
        List<String[]> rows = new ArrayList<>();
        try (CSVReader reader = new CSVReader(new FileReader(filePath))) {
            rows = reader.readAll();
        }
        return rows;
    }
}

// pom.xml dependency
<dependency>
  <groupId>org.apache.poi</groupId>
  <artifactId>poi-ooxml</artifactId>
  <version>5.2.3</version>
</dependency>

import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ExcelDataReader {

    public static List<Map<String, String>> readExcel(String filePath, String sheetName) throws IOException {
        List<Map<String, String>> data = new ArrayList<>();

        try (FileInputStream fis = new FileInputStream(filePath);
             Workbook workbook = new XSSFWorkbook(fis)) {
            Sheet sheet = workbook.getSheet(sheetName);
            Iterator<Row> rowIterator = sheet.iterator();

            // first row is header
            Row headerRow = rowIterator.next();
            List<String> headers = new ArrayList<>();
            headerRow.forEach(cell -> headers.add(cell.getStringCellValue()));

            while (rowIterator.hasNext()) {
                Row row = rowIterator.next();
                Map<String, String> rowMap = new HashMap<>();
                for (int i = 0; i < headers.size(); i++) {
                    Cell cell = row.getCell(i);
                    String value = cell.getCellType() == CellType.STRING
                                   ? cell.getStringCellValue()
                                   : String.valueOf(cell.getNumericCellValue());
                    rowMap.put(headers.get(i), value);
                }
                data.add(rowMap);
            }
        }
        return data;
    }
}

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class ApiTest {

    @DataProvider(name = "csvData")
    public static Object[][] csvDataProvider() throws IOException {
        List<String[]> rows = CsvDataReader.readCsv("src/test/resources/testdata.csv");
        return rows.stream().map(r -> new Object[]{r[0], r[1], r[2]}).toArray(Object[][]::new);
    }

    @Test(dataProvider = "csvData")
    public void testCreateUser(String userId, String name, String email) {
        // Build request body from parameters
        String payload = String.format("{\"userId\":\"%s\",\"name\":\"%s\",\"email\":\"%s\"}", userId, name, email);
        RestAssured
            .given()
                .header("Content-Type", "application/json")
                .body(payload)
            .when()
                .post("/users")
            .then()
                .statusCode(201)
                .body("userId", equalTo(userId));
    }
}

@ParameterizedTest(name = "Create user {index}")
@MethodSource("userProvider")
void testCreateUser(String userId, String name, String email) {
    // same as above
}

import io.restassured.RestAssured;
import io.restassured.response.Response;

RestAssured.baseURI = "https://api.example.com";
RestAssured.basePath = "/v1";

Response response = RestAssured
    .given()
        .pathParam("userId", 12345)
        .queryParam("includeDetails", true)
    .when()
        .get("/users/{userId}")
    .then()
        .statusCode(200)
        .extract()
        .response();

String payload = "{\"title\":\"API Test\",\"body\":\"Testing integration\"}";

Response resp = RestAssured
    .given()
        .auth().preemptive().basic("user", "pass")
        .header("Content-Type", "application/json")
        .body(payload)
    .when()
        .post("/posts")
    .then()
        .statusCode(201)
        .extract()
        .response();

RestAssured.filters(new RequestLoggingFilter(), new ResponseLoggingFilter());

resp.then()
    .statusCode(200)
    .body("data.id", equalTo(12345))
    .body("data.name", equalTo("John Doe"));

import io.restassured.module.jsonschema.JsonSchemaValidator;

resp.then()
    .assertThat()
    .body(JsonSchemaValidator.matchesJsonSchemaInClasspath("post_schema.json"));

resp.then()
    .time(lessThan(2000L)); // 2 seconds

// pom.xml
<dependency>
  <groupId>com.zaxxer</groupId>
  <artifactId>HikariCP</artifactId>
  <version>5.0.1</version>
</dependency>

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class ResultPersistor {

    private static HikariDataSource ds;

    static {
        HikariConfig cfg = new HikariConfig();
        cfg.setJdbcUrl("jdbc:mysql://localhost:3306/testdb");
        cfg.setUsername("root");
        cfg.setPassword("root");
        ds = new HikariDataSource(cfg);
    }

    public static void saveTestResult(String testName, boolean passed, long durationMs) throws SQLException {
        String sql = "INSERT INTO test_results (test_name, passed, duration_ms, run_at) VALUES (?,?,?,NOW())";
        try (Connection conn = ds.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql)) {
            ps.setString(1, testName);
            ps.setBoolean(2, passed);
            ps.setLong(3, durationMs);
            ps.executeUpdate();
        }
    }
}

@Entity
@Table(name = "test_results")
public class TestResult {
    @Id @GeneratedValue
    private Long id;
    private String testName;
    private Boolean passed;
    private Long durationMs;
    private LocalDateTime runAt;
}