Software Testing

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.10.1</version>
    <scope>test</scope>
</dependency>

// Calculator.java - The class we want to test
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    public int subtract(int a, int b) {
        return a - b;
    }
    public int multiply(int a, int b) {
        return a * b;
    }
    public int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Cannot divide by zero!");
        }
        return a / b;
    }
}

import org.junit.jupiter.api.*;
class LifecycleTest {
    @BeforeAll  // Runs ONCE before all tests
    static void setupAll() {
        System.out.println("Setting up test class...");
    }
    @BeforeEach  // Runs BEFORE each test
    void setupEach() {
        System.out.println("Starting a test...");
    }
    @Test
    void test1() {
        System.out.println("Running test 1");
    }
    @Test
    void test2() {
        System.out.println("Running test 2");
    }
    @AfterEach  // Runs AFTER each test
    void cleanupEach() {
        System.out.println("Finished a test...");
    }
    @AfterAll  // Runs ONCE after all tests
    static void cleanupAll() {
        System.out.println("Cleaning up test class...");
    }
    @Disabled("Not ready yet")  // Skip this test
    @Test
    void testNotReady() {
        // This won't run
    }
}

import static org.junit.jupiter.api.Assertions.*;
class AssertionsExampleTest {
    @Test
    void testAssertions() {
        // Check if values are equal
        assertEquals(4, 2 + 2);
        assertEquals("Hello", "Hel" + "lo");
        // Check if values are NOT equal
        assertNotEquals(5, 2 + 2);
        // Check if something is true/false
        assertTrue(5 > 3);
        assertFalse(5 < 3);
        // Check if something is null/not null
        String text = null;
        assertNull(text);
        text = "Hello";
        assertNotNull(text);
        // Check if same object
        String a = "test";
        String b = a;
        assertSame(a, b);
        // Check arrays
        int[] expected = {1, 2, 3};
        int[] actual = {1, 2, 3};
        assertArrayEquals(expected, actual);
        // Group multiple assertions
        assertAll("Person tests",
            () -> assertEquals("John", person.getFirstName()),
            () -> assertEquals("Doe", person.getLastName()),
            () -> assertEquals(30, person.getAge())
        );
    }
}

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.*;
class ParameterizedTestExample {
    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3, 4, 5})
    void testIsPositive(int number) {
        assertTrue(number > 0);
    }
    @ParameterizedTest
    @CsvSource({
        "1, 1, 2",
        "2, 3, 5",
        "5, 5, 10",
        "10, 20, 30"
    })
    void testAddition(int a, int b, int expected) {
        Calculator calc = new Calculator();
        assertEquals(expected, calc.add(a, b));
    }
    @ParameterizedTest
    @MethodSource("provideStrings")
    void testStringLength(String str, int expectedLength) {
        assertEquals(expectedLength, str.length());
    }
    static Stream<Arguments> provideStrings() {
        return Stream.of(
            Arguments.of("Hello", 5),
            Arguments.of("Test", 4),
            Arguments.of("JUnit", 5)
        );
    }
}

// UserService.java
public class UserService {
    private List<User> users = new ArrayList<>();
    public void addUser(User user) {
        if (user == null) {
            throw new IllegalArgumentException("User cannot be null");
        }
        if (user.getEmail() == null || !user.getEmail().contains("@")) {
            throw new IllegalArgumentException("Invalid email");
        }
        users.add(user);
    }
    public User findByEmail(String email) {
        return users.stream()
            .filter(u -> u.getEmail().equals(email))
            .findFirst()
            .orElse(null);
    }
    public int getUserCount() {
        return users.size();
    }
    public List<User> getActiveUsers() {
        return users.stream()
            .filter(User::isActive)
            .collect(Collectors.toList());
    }
}
// UserServiceTest.java
class UserServiceTest {
    private UserService userService;
    @BeforeEach
    void setUp() {
        userService = new UserService();
    }
    @Test
    void whenAddingValidUser_thenUserIsAdded() {
        User user = new User("john@example.com", "John", true);
        userService.addUser(user);
        assertEquals(1, userService.getUserCount());
        assertNotNull(userService.findByEmail("john@example.com"));
    }
    @Test
    void whenAddingNullUser_thenThrowsException() {
        assertThrows(IllegalArgumentException.class, () -> {
            userService.addUser(null);
        });
    }
    @Test
    void whenAddingUserWithInvalidEmail_thenThrowsException() {
        User user = new User("invalid-email", "John", true);
        Exception exception = assertThrows(
            IllegalArgumentException.class,
            () -> userService.addUser(user)
        );
        assertTrue(exception.getMessage().contains("Invalid email"));
    }
    @Test
    void whenGettingActiveUsers_thenReturnsOnlyActive() {
        userService.addUser(new User("active@test.com", "Active", true));
        userService.addUser(new User("inactive@test.com", "Inactive", false));
        userService.addUser(new User("active2@test.com", "Active2", true));
        List<User> activeUsers = userService.getActiveUsers();
        assertEquals(2, activeUsers.size());
        assertTrue(activeUsers.stream().allMatch(User::isActive));
    }
    @ParameterizedTest
    @CsvSource({
        "test@example.com, true",
        "invalid-email, false",
        "missing-at-symbol.com, false",
        "user@domain.com, true"
    })
    void testEmailValidation(String email, boolean shouldBeValid) {
        User user = new User(email, "Test User", true);
        if (shouldBeValid) {
            assertDoesNotThrow(() -> userService.addUser(user));
        } else {
            assertThrows(IllegalArgumentException.class,
                () -> userService.addUser(user));
        }
    }
}