Java Programming Tutorial for QA Test Automation Engineers

public class TestConfig {
  static final String BASE_URL   = "https://thetechworldlabs.com";
  static final int    TIMEOUT    = 10;
  static final String BROWSER    = "chrome";
  static boolean      headless   = false;
}

// 1D Array - single row of test data
int[] testScores = {95, 87, 92, 88, 90};

// Access element by index
System.out.println(testScores[0]); // Output: 95

// Loop through array
for (int i = 0; i < testScores.length; i++) {
  System.out.println("Score: " + testScores[i]);
}

// 2D Array - table of login credentials
String[][] loginData = {
  {"admin@test.com", "admin123", "Admin"},
  {"user@test.com",  "user123",  "User"},
  {"guest@test.com", "guest123", "Guest"}
};

// Access 2D array element
System.out.println(loginData[0][0]); // Output: admin@test.com

// Loop through 2D array
for (int i = 0; i < loginData.length; i++) {
  for (int j = 0; j < loginData[i].length; j++) {
    System.out.print(loginData[i][j] + " | ");
  }
  System.out.println();
}

// Verify page title
String title = driver.getTitle();
if (title.contains("Login")) {
  System.out.println("✓ Correct page loaded");
}

// Extract data from API response
String response = "{\"status\":\"success\",\"user\":\"john\"}";
if (response.contains("success")) {
  System.out.println("✓ API call successful");
}

// Parse CSV line
String line = "username,password,role";
String[] fields = line.split(",");

// Trim and validate input
String userInput = "  admin123  ";
String cleaned = userInput.trim();
if (cleaned.equals("admin123")) {
  System.out.println("✓ Input matches expected value");
}

// Build test URLs
String baseURL = "https://example.com";
String loginURL = baseURL + "/login";
String dashboardURL = baseURL + "/dashboard";

// if-else
if (score >= 50) {
  System.out.println("Pass");
} else if (score >= 40) {
  System.out.println("Borderline");
} else {
  System.out.println("Fail");
}

// for loop — iterate test data rows
for (int i = 0; i < testData.length; i++) {
  System.out.println("Running case: " + testData[i]);
}

// enhanced for — loop through elements
for (WebElement el : driver.findElements(By.tagName("li"))) {
  System.out.println(el.getText());
}

// while loop — wait for condition
int retries = 0;
while (!isLoaded && retries < 5) { retries++; }

public class TestCase {
  // Fields (attributes)
  private String name;
  private String status;

  // Constructor
  public TestCase(String name) {
    this.name   = name;
    this.status = "NOT_RUN";
  }

  // Method
  public void markPassed() { status = "PASSED"; }
  public void markFailed() { status = "FAILED"; }

  // Getters
  public String getName()   { return name; }
  public String getStatus() { return status; }
}

// Usage
TestCase tc = new TestCase("Login Test");
tc.markPassed();
System.out.println(tc.getName() + ": " + tc.getStatus());

// Method with no parameters, no return
public void launchBrowser() {
  driver = new ChromeDriver();
  driver.get("https://example.com");
}

// Method with parameters, returns boolean
public boolean loginUser(String username, String password) {
  driver.findElement(By.id("username")).sendKeys(username);
  driver.findElement(By.id("password")).sendKeys(password);
  driver.findElement(By.xpath("//button[@type='submit']")).click();
  return true;
}

// Method with return type
public String getPageTitle() {
  return driver.getTitle();
}

// Usage in test
@Test
public void testLoginFlow() {
  launchBrowser();
  loginUser("admin", "password123");
  String title = getPageTitle();
  System.out.println("Title: " + title);
}

// BaseTest.java — shared setup for ALL tests
public class BaseTest {
  protected WebDriver driver;

  @BeforeClass
  public void setup() {
    driver = new ChromeDriver();
    driver.manage().window().maximize();
    driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
  }

  @AfterClass
  public void teardown() { driver.quit(); }
}

// LoginTest.java — extends BaseTest, inherits driver
public class LoginTest extends BaseTest {
  @Test
  public void testLogin() {
    driver.get(BASE_URL + "/login");
    // test steps...
  }
}

// Parent class - BaseTest with setup/teardown
public class BaseTest {
  protected WebDriver driver;

  @BeforeMethod
  public void setup() {
    System.out.println("Generic setup");
    driver = new ChromeDriver();
  }
}

// Child class - ChromeTest OVERRIDES parent method
public class ChromeTest extends BaseTest {
  @Override
  public void setup() {
    System.out.println("Chrome-specific setup");
    super.setup(); // Call parent method first
    driver.manage().window().maximize();
  }
}

// Method Overloading - click() with different parameters
public void click(By locator) {
  driver.findElement(locator).click();
}

public void click(WebElement element) {
  element.click();
}

public void click(String xpath, String waitTime) {
  WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(Long.parseLong(waitTime)));
  wait.until(ExpectedConditions.elementToBeClickable(By.xpath(xpath))).click();
}

// Define interface - contract for browser automation
public interface BrowserActions {
  void openBrowser();
  void navigateTo(String url);
  void closeBrowser();
  String getPageTitle();
}

// Implement interface - Chrome automation
public class ChromeAutomation implements BrowserActions {
  WebDriver driver;

  @Override
  public void openBrowser() {
    driver = new ChromeDriver();
  }

  @Override
  public void navigateTo(String url) {
    driver.get(url);
  }

  @Override
  public void closeBrowser() {
    driver.quit();
  }

  @Override
  public String getPageTitle() {
    return driver.getTitle();
  }
}

// Usage - interface type can hold any implementation
BrowserActions browser = new ChromeAutomation();
browser.openBrowser();
browser.navigateTo("https://example.com");

public class TestConfig {
  // Private - only accessible within this class
  private String apiKey = "secret123";
  private String dbPassword;

  // Public - accessible everywhere
  public static final String BASE_URL = "https://api.example.com";

  // Protected - accessible by subclasses and same package
  protected String browserType = "chrome";

  // Getters - controlled read access
  public String getApiKey() {
    return apiKey;
  }

  // Setters - controlled write access with validation
  public void setDbPassword(String password) {
    if (password != null && !password.isEmpty()) {
      this.dbPassword = password;
    } else {
      System.out.println("Invalid password");
    }
  }
}

// Usage
TestConfig config = new TestConfig();
System.out.println(config.getApiKey()); // OK - use getter
config.setDbPassword("newPassword"); // OK - use setter
// config.apiKey = "fake"; // COMPILE ERROR - private

// Store test credentials
Map<String, String> users = new HashMap<>();
users.put("admin", "adminPass");
users.put("user",  "userPass");

// Iterate all test cases
List<String> testCases = new ArrayList<>();
testCases.add("Login Test");
testCases.add("Checkout Test");

for (String tc : testCases) {
  System.out.println("Running: " + tc);
}

try {
  WebElement el = driver.findElement(By.id("missingElement"));
  el.click();
} catch (NoSuchElementException e) {
  System.out.println("Element not found: " + e.getMessage());
  // Take screenshot for debugging
  File shot = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
  FileUtils.copyFile(shot, new File("screenshots/failure.png"));
} catch (TimeoutException e) {
  System.out.println("Timeout waiting for element");
} finally {
  // Always runs — ideal for cleanup
  driver.quit();
}

import java.nio.file.*;
import java.util.*;

List<String> lines = Files.readAllLines(Paths.get("src/test/resources/testdata.csv"));

for (String line : lines) {
  String[] parts    = line.split(",");
  String username   = parts[0];
  String password   = parts[1];
  String expected   = parts[2];
  // use in your Selenium test...
}

admin@example.com,admin123,dashboard
user@example.com,user123,home
invalid@test.com,wrongpass,error

// WITHOUT Generics - requires casting, error-prone
List testData = new ArrayList();
testData.add("admin");
testData.add("user");
String username = (String) testData.get(0); // Casting needed

// WITH Generics - type-safe, clean
List<String> credentials = new ArrayList<>();
credentials.add("admin@example.com");
credentials.add("user@example.com");
String email = credentials.get(0); // No casting needed

// Generic method - reusable for any type
public <T> void printList(List<T> list) {
  for (T item : list) {
    System.out.println(item);
  }
}

// Generic class - useful for test data holders
public class TestData<T> {
  private T value;
  private boolean passed;

  public TestData(T value) {
    this.value = value;
    this.passed = false;
  }

  public T getValue() { return value; }
  public void markPassed() { this.passed = true; }
}

// Usage with different types
TestData<String> strData = new TestData<>("Login Test");
TestData<Integer> intData = new TestData<>(200); // HTTP status code

// Lambda expression syntax: (parameters) -> { body }
List<Integer> scores = new ArrayList<>(Arrays.asList(45, 78, 92, 38, 85));

// Filter passed tests (score >= 50)
List<Integer> passed = scores.stream()
  .filter(score -> score >= 50)
  .collect(Collectors.toList());

// Map and transform - get percentage
List<Double> percentages = scores.stream()
  .map(score -> (score / 100.0) * 100)
  .collect(Collectors.toList());

// Find first score >= 80
Integer topScore = scores.stream()
  .filter(score -> score >= 80)
  .findFirst()
  .orElse(0);

// Count passed tests
long passCount = scores.stream()
  .filter(score -> score >= 50)
  .count();

// forEach with lambda - print results
scores.stream()
  .forEach(score -> System.out.println("Score: " + score));

public class LoginTests {
  WebDriver driver;

  @BeforeSuite
  public void setupSuite() {
    System.out.println("Suite Setup: Initialize logger, DB connection");
  }

  @BeforeClass
  public void setupBrowser() {
    driver = new ChromeDriver();
    driver.get("https://example.com");
  }

  @BeforeMethod
  public void beforeEachTest() {
    System.out.println("Navigating to login page");
    driver.navigate().to("https://example.com/login");
  }

  @Test(description = "Verify login with valid credentials")
  public void testValidLogin() {
    // Test implementation
  }

  @Test(dataProvider = "loginData")
  public void testLoginMultipleUsers(String username, String password) {
    driver.findElement(By.id("username")).sendKeys(username);
    driver.findElement(By.id("password")).sendKeys(password);
  }

  @DataProvider(name = "loginData")
  public Object[][] provideLoginData() {
    return new Object[][] {
      {"admin@example.com", "admin123"},
      {"user@example.com", "user123"},
      {"guest@example.com", "guest123"}
    };
  }

  @AfterMethod
  public void afterEachTest() {
    System.out.println("Test completed. Taking screenshot if failed.");
  }

  @AfterClass
  public void closeBrowser() {
    driver.quit();
  }
}

// Method 1: Extend Thread class
public class TestRunner extends Thread {
  private String testName;

  public TestRunner(String testName) {
    this.testName = testName;
  }

  @Override
  public void run() {
    System.out.println("Running: " + testName + " on " + Thread.currentThread().getName());
  }
}

// Method 2: Implement Runnable (preferred)
public class SeleniumTest implements Runnable {
  private WebDriver driver;

  @Override
  public void run() {
    // Each thread gets its own driver
    driver = new ChromeDriver();
    driver.get("https://example.com");
    System.out.println("Test executed by " + Thread.currentThread().getName());
    driver.quit();
  }
}

// Usage: Create and start threads
public static void main(String[] args) {
  // Using Thread extension
  TestRunner test1 = new TestRunner("LoginTest");
  TestRunner test2 = new TestRunner("CheckoutTest");
  test1.start();
  test2.start();

  // Using Runnable (better for Selenium)
  Thread t1 = new Thread(new SeleniumTest());
  Thread t2 = new Thread(new SeleniumTest());
  t1.start();
  t2.start();
}

// TestNG Parallel Execution (in testng.xml)
// <suite parallel="tests" thread-count="4">
// <test name="LoginTests">
// <test name="CheckoutTests">