CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-testng--testng

Comprehensive testing framework for Java with annotations, data-driven testing, and parallel execution capabilities

Overview
Eval results
Files

assertions.mddocs/

Assertions

TestNG's assertion framework provides comprehensive static methods for test verification through the Assert class, plus advanced assertion collection capabilities with SoftAssert for scenarios requiring multiple assertion validations.

Capabilities

Assert Class

The main assertion class providing static methods for test verification. All assertion methods throw AssertionError on failure with detailed error messages.

/**
 * Main assertion class with static methods for test verification
 */
public class Assert {
    
    // Basic boolean assertions
    public static void assertTrue(boolean condition);
    public static void assertTrue(boolean condition, String message);
    public static void assertFalse(boolean condition);
    public static void assertFalse(boolean condition, String message);
    
    // Null/not-null assertions
    public static void assertNull(Object object);
    public static void assertNull(Object object, String message);
    public static void assertNotNull(Object object);
    public static void assertNotNull(Object object, String message);
    
    // Equality assertions
    public static void assertEquals(Object actual, Object expected);
    public static void assertEquals(Object actual, Object expected, String message);
    public static void assertEquals(String actual, String expected);
    public static void assertEquals(String actual, String expected, String message);
    public static void assertEquals(double actual, double expected, double delta);
    public static void assertEquals(double actual, double expected, double delta, String message);
    public static void assertEquals(float actual, float expected, float delta);
    public static void assertEquals(float actual, float expected, float delta, String message);
    
    // Inequality assertions
    public static void assertNotEquals(Object actual, Object expected);
    public static void assertNotEquals(Object actual, Object expected, String message);
    public static void assertNotEquals(String actual, String expected);
    public static void assertNotEquals(String actual, String expected, String message);
    public static void assertNotEquals(double actual, double expected, double delta);
    public static void assertNotEquals(double actual, double expected, double delta, String message);
    public static void assertNotEquals(float actual, float expected, float delta);
    public static void assertNotEquals(float actual, float expected, float delta, String message);
    
    // Object identity assertions
    public static void assertSame(Object actual, Object expected);
    public static void assertSame(Object actual, Object expected, String message);
    public static void assertNotSame(Object actual, Object expected);
    public static void assertNotSame(Object actual, Object expected, String message);
    
    // Array assertions
    public static void assertEquals(Object[] actual, Object[] expected);
    public static void assertEquals(Object[] actual, Object[] expected, String message);
    public static void assertEquals(byte[] actual, byte[] expected);
    public static void assertEquals(byte[] actual, byte[] expected, String message);
    public static void assertEquals(short[] actual, short[] expected);
    public static void assertEquals(short[] actual, short[] expected, String message);
    public static void assertEquals(int[] actual, int[] expected);
    public static void assertEquals(int[] actual, int[] expected, String message);
    public static void assertEquals(long[] actual, long[] expected);
    public static void assertEquals(long[] actual, long[] expected, String message);
    public static void assertEquals(char[] actual, char[] expected);
    public static void assertEquals(char[] actual, char[] expected, String message);
    public static void assertEquals(float[] actual, float[] expected, float delta);
    public static void assertEquals(float[] actual, float[] expected, float delta, String message);
    public static void assertEquals(double[] actual, double[] expected, double delta);
    public static void assertEquals(double[] actual, double[] expected, double delta, String message);
    
    // Collection assertions
    public static void assertEquals(Set<?> actual, Set<?> expected);
    public static void assertEquals(Set<?> actual, Set<?> expected, String message);
    public static void assertEquals(Map<?, ?> actual, Map<?, ?> expected);
    public static void assertEquals(Map<?, ?> actual, Map<?, ?> expected, String message);
    
    // Exception assertions
    public static <T extends Throwable> T expectThrows(Class<T> expectedType, Executable executable);
    public static <T extends Throwable> T expectThrows(Class<T> expectedType, Executable executable, String message);
    
    // Failure methods
    public static void fail();
    public static void fail(String message);
    public static void fail(String message, Throwable realCause);
}

Usage Examples:

import org.testng.Assert;
import org.testng.annotations.Test;

public class AssertionExamples {
    
    @Test
    public void testBasicAssertions() {
        // Boolean assertions
        Assert.assertTrue(5 > 3, "5 should be greater than 3");
        Assert.assertFalse(2 > 5, "2 should not be greater than 5");
        
        // Null assertions
        Object nullObject = null;
        Object nonNullObject = new Object();
        Assert.assertNull(nullObject);
        Assert.assertNotNull(nonNullObject);
    }
    
    @Test
    public void testEqualityAssertions() {
        // Object equality
        String expected = "Hello TestNG";
        String actual = "Hello TestNG";
        Assert.assertEquals(actual, expected);
        
        // Numeric equality
        int expectedInt = 42;
        int actualInt = 42;
        Assert.assertEquals(actualInt, expectedInt);
        
        // Floating point with delta
        double expectedDouble = 3.14159;
        double actualDouble = 3.14160;
        Assert.assertEquals(actualDouble, expectedDouble, 0.001);
        
        // String inequality
        Assert.assertNotEquals("hello", "world");
    }
    
    @Test
    public void testObjectIdentity() {
        String str1 = new String("test");
        String str2 = new String("test");
        String str3 = str1;
        
        // Same content but different objects
        Assert.assertEquals(str1, str2);
        Assert.assertNotSame(str1, str2);
        
        // Same object reference
        Assert.assertSame(str1, str3);
    }
    
    @Test
    public void testArrayAssertions() {
        int[] expected = {1, 2, 3, 4, 5};
        int[] actual = {1, 2, 3, 4, 5};
        Assert.assertEquals(actual, expected);
        
        String[] expectedStrings = {"a", "b", "c"};
        String[] actualStrings = {"a", "b", "c"};
        Assert.assertEquals(actualStrings, expectedStrings);
        
        double[] expectedDoubles = {1.1, 2.2, 3.3};
        double[] actualDoubles = {1.11, 2.21, 3.31};
        Assert.assertEquals(actualDoubles, expectedDoubles, 0.1);
    }
    
    @Test
    public void testCollectionAssertions() {
        Set<String> expectedSet = Set.of("a", "b", "c");
        Set<String> actualSet = Set.of("c", "b", "a"); // Order doesn't matter
        Assert.assertEquals(actualSet, expectedSet);
        
        Map<String, Integer> expectedMap = Map.of("one", 1, "two", 2);
        Map<String, Integer> actualMap = Map.of("two", 2, "one", 1);
        Assert.assertEquals(actualMap, expectedMap);
    }
    
    @Test
    public void testExceptionAssertions() {
        // Test that specific exception is thrown
        IllegalArgumentException exception = Assert.expectThrows(
            IllegalArgumentException.class,
            () -> { throw new IllegalArgumentException("Invalid argument"); }
        );
        
        Assert.assertEquals(exception.getMessage(), "Invalid argument");
        
        // Test with custom message
        RuntimeException runtimeException = Assert.expectThrows(
            RuntimeException.class,
            () -> { throw new RuntimeException("Runtime error"); },
            "Should throw RuntimeException"
        );
    }
    
    @Test
    public void testFailureMethods() {
        boolean condition = false;
        if (!condition) {
            Assert.fail("Test failed due to condition");
        }
        
        try {
            riskyOperation();
        } catch (Exception e) {
            Assert.fail("Unexpected exception", e);
        }
    }
    
    private void riskyOperation() throws Exception {
        // Some operation that might throw
    }
}

SoftAssert Class

Collects multiple assertion failures and reports them all at once. Useful for validating multiple conditions without stopping at the first failure.

/**
 * Assertion class that collects failures and reports them together
 */
public class SoftAssert {
    
    // Constructor
    public SoftAssert();
    
    // All assertion methods mirror Assert class but don't throw immediately
    public void assertTrue(boolean condition);
    public void assertTrue(boolean condition, String message);
    public void assertFalse(boolean condition);
    public void assertFalse(boolean condition, String message);
    
    public void assertNull(Object object);
    public void assertNull(Object object, String message);
    public void assertNotNull(Object object);
    public void assertNotNull(Object object, String message);
    
    public void assertEquals(Object actual, Object expected);
    public void assertEquals(Object actual, Object expected, String message);
    public void assertEquals(String actual, String expected);
    public void assertEquals(String actual, String expected, String message);
    public void assertEquals(double actual, double expected, double delta);
    public void assertEquals(double actual, double expected, double delta, String message);
    public void assertEquals(float actual, float expected, float delta);
    public void assertEquals(float actual, float expected, float delta, String message);
    
    public void assertNotEquals(Object actual, Object expected);
    public void assertNotEquals(Object actual, Object expected, String message);
    
    public void assertSame(Object actual, Object expected);
    public void assertSame(Object actual, Object expected, String message);
    public void assertNotSame(Object actual, Object expected);
    public void assertNotSame(Object actual, Object expected, String message);
    
    public void assertEquals(Object[] actual, Object[] expected);
    public void assertEquals(Object[] actual, Object[] expected, String message);
    
    // Report all collected failures (throws if any failures occurred)
    public void assertAll();
    public void assertAll(String message);
}

Usage Examples:

import org.testng.asserts.SoftAssert;
import org.testng.annotations.Test;

public class SoftAssertExamples {
    
    @Test
    public void testMultipleValidations() {
        SoftAssert softAssert = new SoftAssert();
        
        // Validate multiple fields of an object
        User user = getUserFromService();
        
        softAssert.assertNotNull(user, "User should not be null");
        softAssert.assertEquals(user.getName(), "John Doe", "User name mismatch");
        softAssert.assertEquals(user.getAge(), 30, "User age mismatch");
        softAssert.assertTrue(user.isActive(), "User should be active");
        softAssert.assertNotNull(user.getEmail(), "Email should not be null");
        softAssert.assertTrue(user.getEmail().contains("@"), "Email should contain @");
        
        // All assertions are collected and reported together
        softAssert.assertAll();
    }
    
    @Test
    public void testFormValidation() {
        SoftAssert softAssert = new SoftAssert();
        
        // Validate multiple form fields
        FormData form = getFormData();
        
        softAssert.assertNotNull(form.getFirstName(), "First name is required");
        softAssert.assertNotNull(form.getLastName(), "Last name is required");
        softAssert.assertTrue(form.getFirstName().length() >= 2, "First name too short");
        softAssert.assertTrue(form.getLastName().length() >= 2, "Last name too short");
        softAssert.assertTrue(form.getAge() >= 18, "Must be at least 18 years old");
        softAssert.assertTrue(form.getAge() <= 120, "Invalid age");
        softAssert.assertTrue(isValidEmail(form.getEmail()), "Invalid email format");
        
        // Report all validation failures at once
        softAssert.assertAll("Form validation failed");
    }
    
    @Test
    public void testApiResponse() {
        SoftAssert softAssert = new SoftAssert();
        
        ApiResponse response = callApi();
        
        // Validate response structure
        softAssert.assertEquals(response.getStatus(), 200, "Wrong status code");
        softAssert.assertNotNull(response.getData(), "Response data is null");
        softAssert.assertTrue(response.getData().size() > 0, "No data returned");
        
        // Validate each item in response
        for (int i = 0; i < response.getData().size(); i++) {
            DataItem item = response.getData().get(i);
            softAssert.assertNotNull(item.getId(), "Item " + i + " has null ID");
            softAssert.assertNotNull(item.getName(), "Item " + i + " has null name");
            softAssert.assertTrue(item.getId() > 0, "Item " + i + " has invalid ID");
        }
        
        softAssert.assertAll();
    }
    
    // Helper methods
    private User getUserFromService() {
        return new User("John Doe", 30, true, "john@example.com");
    }
    
    private FormData getFormData() {
        return new FormData("John", "Doe", 25, "john@example.com");
    }
    
    private ApiResponse callApi() {
        // Mock API call
        return new ApiResponse(200, Arrays.asList(
            new DataItem(1, "Item 1"),
            new DataItem(2, "Item 2")
        ));
    }
    
    private boolean isValidEmail(String email) {
        return email != null && email.contains("@") && email.contains(".");
    }
}

FileAssert Class

File-specific assertions for validating file operations and file system states.

/**
 * File-specific assertion utilities
 */
public class FileAssert {
    
    // File existence assertions
    public static void assertFileExists(String filePath);
    public static void assertFileExists(String filePath, String message);
    public static void assertFileExists(File file);
    public static void assertFileExists(File file, String message);
    
    public static void assertFileNotExists(String filePath);
    public static void assertFileNotExists(String filePath, String message);
    public static void assertFileNotExists(File file);
    public static void assertFileNotExists(File file, String message);
    
    // File content assertions
    public static void assertFileEquals(String expectedFilePath, String actualFilePath);
    public static void assertFileEquals(String expectedFilePath, String actualFilePath, String message);
    public static void assertFileEquals(File expectedFile, File actualFile);
    public static void assertFileEquals(File expectedFile, File actualFile, String message);
    
    // File size assertions
    public static void assertFileSize(String filePath, long expectedSize);
    public static void assertFileSize(String filePath, long expectedSize, String message);
    public static void assertFileSize(File file, long expectedSize);
    public static void assertFileSize(File file, long expectedSize, String message);
}

Assertion Framework Classes

Internal assertion framework classes that can be extended for custom assertion behavior.

/**
 * Base class for assertion implementations
 */
public class Assertion {
    public Assertion();
    protected void doAssert(IAssert<?> assertCommand);
    protected void onAssertSuccess(IAssert<?> assertCommand);
    protected void onAssertFailure(IAssert<?> assertCommand, AssertionError ex);
    protected void onBeforeAssert(IAssert<?> assertCommand);
    protected void onAfterAssert(IAssert<?> assertCommand);
}

/**
 * Interface for assertion commands
 */
public interface IAssert<T> {
    void doAssert();
    Object getActual();
    Object getExpected();
    String getMessage();
}

/**
 * Interface for assertion lifecycle hooks
 */
public interface IAssertLifecycle {
    void onAssertSuccess(IAssert<?> assertCommand);
    void onAssertFailure(IAssert<?> assertCommand, AssertionError ex);
    void onBeforeAssert(IAssert<?> assertCommand);
    void onAfterAssert(IAssert<?> assertCommand);
}

/**
 * Assertion class with logging capabilities
 */
public class LoggingAssert extends Assertion {
    public LoggingAssert();
    
    @Override
    protected void onBeforeAssert(IAssert<?> assertCommand);
    
    @Override
    protected void onAssertSuccess(IAssert<?> assertCommand);
    
    @Override
    protected void onAssertFailure(IAssert<?> assertCommand, AssertionError ex);
}

Types

// Functional interface for exception testing  
@FunctionalInterface
public interface Executable {
    void execute() throws Throwable;
}

// Common data classes used in examples
public class User {
    private String name;
    private int age;
    private boolean active;
    private String email;
    
    public User(String name, int age, boolean active, String email) {
        this.name = name;
        this.age = age;
        this.active = active;
        this.email = email;
    }
    
    // Getters
    public String getName() { return name; }
    public int getAge() { return age; }
    public boolean isActive() { return active; }
    public String getEmail() { return email; }
}

public class FormData {
    private String firstName;
    private String lastName;
    private int age;
    private String email;
    
    public FormData(String firstName, String lastName, int age, String email) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        this.email = email;
    }
    
    // Getters
    public String getFirstName() { return firstName; }
    public String getLastName() { return lastName; }
    public int getAge() { return age; }
    public String getEmail() { return email; }
}

Install with Tessl CLI

npx tessl i tessl/maven-org-testng--testng

docs

annotations.md

assertions.md

collections-utilities.md

index.md

listeners-hooks.md

test-execution.md

xml-configuration.md

tile.json