What Is The Difference Between Assert And Verify Methods In Selenium

In automated testing with Selenium, Assert and Verify methods play a crucial role in checking whether the application behaves as expected. Simply put, these methods help validate the result of a test. By understanding the difference between Assert and Verify methods and learning how to use these methods, automation testers can ensure more reliable and accurate testing outcomes.

Assertions in selenium are of two types namely Hard Assertions and Soft Assertions (Verify Method).

Must read: Test Automation vs Automation Testing

What are Assertions (aka Asserts) in selenium

An Assert in Selenium is used to validate that certain conditions are met during a test run. It checks whether the expected outcome of an action matches the actual result. If the condition specified in the assert statement is true, the test will continue to run. However, if the assert command fails, the test will immediately stop, and an error will be logged. So when the Assertion fails, all the test steps after that line of code are skipped. This helps testers identify bugs early in the process by ensuring that the application behaves as expected at various checkpoints during the test.

For example, if you assert that a page title is “Home” and it’s not, the test will stop right there. This is useful for critical checks where it doesn’t make sense to proceed if a fundamental condition isn’t met.

The solution to overcoming this issue is to use a try-catch block.

We use the Assertion in the try catch block. Mostly, the assert command is used when the end result of the check value should pass to continue to the next step.

In simple words, if the assert condition is true then the program control will execute the next test step but if the condition is false, the execution will stop and further test step will not be executed.

To overcome this we use Soft Assert in TestNG.

Methods under Hard Assertions in Selenium

• assertEquals(expected, actual): This one compares the expected value with the actual value. If they do not match, the test will fail.
• assertTrue(condition): Verifies whether the specified condition holds true. If the condition is false, the test will fail.
• assertFalse(condition): Verifies whether the specified condition is false. If the condition is true, the test fails.
• assertNull(object): Verifies whether the specified object is null; if it isn’t, the test fails.
• assertNotNull(object): Verifies that the specified object is not null. If the object is null, the test will fail.
• assertSame(expected, actual): Verifies whether the expected and actual objects reference the same instance. If they do not, the test fails.
• assertNotSame(expected, actual): Verifies that the expected and actual objects are not the same instance. If they are, the test fails.
• fail(message): Explicitly fails the test with the given failure message.

What is a Verify in Selenium?

A Verify in Selenium is used to check if certain conditions are met without stopping the test execution. Unlike Assert, even if the condition specified in the Verify statement is false, the test will continue to run to the end. This is useful when you want to log errors and gather all the results from a test run without interrupting the process. Verify helps in identifying multiple issues in a single test cycle by allowing the test to proceed past failures.

For example, if you verify that a button is visible and it’s not, the test will log this failure but move on to the next steps. This allows you to collect multiple points of failure in a single test execution, which can be helpful for a comprehensive diagnostic of the application’s issues.

When a “verify” command fails, the test will continue executing and logging the failure. Mostly, the Verify command is used to check non-critical things. In such cases where we move forward even though the end result of the check value is failed.

In simple words, there wont be any halt in the test execution even though the verify condition is true or false.

Must Read: Soft Assert in Selenium

Note: In TestNG, we use only Assert Statements. We can use Verify statement in terms of if-else and try-catch.

if(isElementPresent(By.linkText("login"))){
System.out.println("Login link is present");
} else{
System.out.println("Login link is not present");
}

Or

try {
assertTrue(isElementPresent(By.xpath("assert-and-verify")));
} catch (Error e) {
verificationErrors.append(e.toString());
}

Methods under Soft Assertions in Selenium

• assertEquals(expected, actual): This one compares the expected value with the actual value. If they do not match, the test will fail and the failure is recorded.
• assertTrue(condition): Verifies whether the specified condition holds true. If the condition is false, the test will fail and the failure is recorded.
• assertFalse(condition): Verifies whether the specified condition is false. If the condition is true, the test fails and the failure is recorded.
• assertNull(object): Verifies whether the specified object is null; if it isn’t, the test fails and the failure is recorded.
• assertNotNull(object): Verifies that the specified object is not null. If the object is null, the test will fail and the failure is recorded.
• assertSame(expected, actual): Verifies whether the expected and actual objects reference the same instance. If they do not, the test fails and the failure is recorded. .
• assertNotSame(expected, actual): Verifies that the expected and actual objects are not the same instance. If they are, the test fails and the failure is recorded.

These methods work like hard assertions, but with soft asserts, failures are accumulated instead of stopping the test right away. To trigger the soft assert and log all the failures, just call the assertAll() method at the end of the test case.

Please be patient. The video will load in some time.

Must Read: How To Capture Full Page Screenshot in Selenium

Difference between Assert and Verify in Selenium

Assert vs Verify in Selenium can be summarized as follow:

Examples of Assertion in TestNG

Let’s see a basic example on Assertion in TestNG:

The below program is written using TestNG. Don’t miss TestNG Tutorial

package stmTutorial;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.Test;

public class AssertionExample {
	@Test
	public void assertion(){
		//Instantiation of driver object. To launch Firefox browser
		WebDriver driver = new FirefoxDriver();
		//To open the URL
		driver.get("https://www.softwaretestingmaterial.com");
		//Actual title is "Software Testing Material - A site for Software Testers" 
		//We took title as "Software Testing Material" to make the test fail
		String Title = "Software Testing Material";
		String GetTitle = driver.getTitle();
		System.out.println("Assertion starts here...");
		Assert.assertEquals(Title, GetTitle);
		System.out.println("A blog for Software Testers");
                driver.quit();		
	}
}

After executing the above program, we see only “Assertion starts here…” in the console. We made the assertion fail deliberately. So, in the console we couldn’t see “A blog for Software Testers”. Here the assertion failed, so the next step to print “A blog for Software Testers” is skipped.

To over come this we use try-catch block. See the below program.

package stmTutorial;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.Test;

public class AssertionExample {
	
	@Test
	public void assertion(){
		//Instantiation of driver object. To launch Firefox browser
		WebDriver driver = new FirefoxDriver();
		//To open the URL
		driver.get("https://www.softwaretestingmaterial.com");
		//Actual title is "Software Testing Material - A site for Software Testers" 
		//We took title as "Software Testing Material" to make the test fail
		String Title = "Software Testing Material";
		String GetTitle = driver.getTitle();
		System.out.println("Assertion starts here...");
		try{
			Assert.assertEquals(Title, GetTitle);
		}catch (Throwable t){
			System.out.println("A blog for Software Testers");
		}
		driver.quit();
	}

}

Must Read: TestNG Complete Tutorial

Conclusion: Assertion vs Verification

Assertions are used when critical conditions must be met for the test to proceed; if they fail, the test stops immediately. Verifications, on the other hand, are used to log any failure but allow the test to continue running. This distinction helps testers decide when a failure is critical enough to halt the test or when to simply record the failure and move on. Balancing the use of assert and verify helps create robust and reliable test scripts.

Related posts:

• Selenium Tutorial
• TestNG Tutorial
• Java for Testers Tutorial
• SQL for Testers Tutorial
• Automation Testing Tutorial
• Manual Testing Tutorial
• Selenium Interview Questions & Answers
• Manual Testing Interview Questions & Answers