What is the use of @Test(invocationCount=x)?

When automating tests using, developers may front scenario where they need to execute a test method multiple multiplication.

TestNG & # 8217; s@ Test (invocationCount=x)annotation is a knock-down tool for such situation. The annotating allows you to delimitate how often a particular tryout method should be execute within the trial suite.

This is particularly useful for,, and still when a particular operation needs to be validated under different weather multiple times.

What is @ Test (invocationCount=x)?

The @ Test (invocationCount=x) is an annotation in TestNGused to limit the number of times a test method should be executed. Instead of duplicating code and creating multiple instances of the same test method, you can just use this annotation to delineate the repetition enumeration.

For illustration,

If you take to run a method five clip, habituate@ Test (invocationCount=5)will insure that the test method is executed just five times during the tryout execution.

This simplifies code upkeep and reduces redundance, making it an efficient solution for developer dealing with or requirements.

What is the use of @ Test (invocationCount=x)? With Example

One of the primary uses of the@ Test (invocationCount=x)annotation is to increase the reliability of tests.

Imagine you have a function that passes in one tryout run but fails intermittently. By scarper the trial method multiple time, you can disclose such hidden or transient that might be overleap with a single test run.

The annotation is likewise essential in performance essay scenarios.

For illustration, if you require to measure your system & # 8217; s performance or robustness when performing a peculiar operation multiple multiplication, this annotation guarantee the method is called repeatedly under the same conditions.

It is also useful for simulating repeated actions by end user, making it an idealistic tool for.

Pro tip: Tools like SUSA can handle this autonomously — upload your app and get results without writing a single test script.

Example of @ Test (invocationCount=x)

Here & # 8217; s a basic example demonstrating how the@ Test (invocationCount=x) works:

significance org.testng.Assert; import org.testng.annotations.Test; public class InvocationCountExample {@ Test (invocationCount = 5) public null testAddition () {Calculator estimator = new Calculator (); int result = calculator.add (2, 3); Assert.assertEquals (result, 5, `` Addition result is incorrect. ``);}}

Explanation of @ Test (invocationCount=x)

In the above example, thetestAddition ()method is executed five time. Each time, theadd()method of theCalculatorfamily adds two numbers (2 and 3), and the event is compared against the expected upshot (5) usingAssert.assertEquals ().

Output of @ Test (invocationCount=x)

This repetitive execution ensures that the addition part is tested multiple clip for consistency. TestNG will swag the test as a failure if any of the five invocation fail, helping identify intermittent bug that might only occur in specific situations.

Selenium Example: Website Testing

Let ’ s see how@ Test (invocationCount=x)can be used with to.

importee org.openqa.selenium.WebDriver; import org.openqa.selenium.chrome.ChromeDriver; import org.testng.annotations.AfterClass; import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; public class SeleniumInvocationExample {WebDriver driver; @ BeforeClass world void setup () {System.setProperty (`` webdriver.chrome.driver '', `` /path/to/chromedriver ''); driver = new ChromeDriver ();} @ Test (invocationCount = 3) public void testWebsiteTitle () {driver.get (`` https: //example.com ''); String rubric = driver.getTitle (); Assert.assertEquals (title, `` Example Domain '', `` Title mismatch! ``);} @ AfterClass public void teardown () {driver.quit ();}}

Explanation:

• This illustration tests a website & # 8217; s title three multiplication. ThetestWebsiteTitle ()method navigates toexample.comand verifies the page rubric.
• The repetitive executing ensures body in title substantiation across multiple runs.

Appium Example: Wandering Testing

Here ’ s how the@ Test (invocationCount=x)annotation can be apply with to prove a peregrine application.

import io.appium.java_client.AppiumDriver; import io.appium.java_client.MobileElement; import io.appium.java_client.android.AndroidDriver; import org.openqa.selenium.remote.DesiredCapabilities; import org.testng.Assert; import org.testng.annotations.BeforeClass; meaning org.testng.annotations.Test; import java.net.URL; public class AppiumInvocationExample {AppiumDriver & lt; MobileElement & gt; driver; @ BeforeClass public void apparatus () throws Exception {DesiredCapabilities caps = new DesiredCapabilities (); caps.setCapability (`` deviceName '', `` Android Emulator ''); caps.setCapability (`` platformName '', `` Android ''); caps.setCapability (`` app '', `` /path/to/app.apk ''); driver = new AndroidDriver & lt; & gt; (new URL (`` http: //localhost:4723/wd/hub ''), cap);} @ Test (invocationCount = 4) public void testAppLaunch () {MobileElement el = driver.findElementById (`` com.example.app: id/welcome_text ''); Assert.assertEquals (el.getText (), `` Welcome '', `` Text mismatch on launch! ``);}}

Explanation:

• The testAppLaunch ()method runs four times, validating that the app & # 8217; s welcome blind exhibit the correct text each clip it launches.
• Repeating the test ensures the mobile app launches correctly and consistently across multiple runs.

Use Cases of @ Test (invocationCount=x)

• Reliability Testing: By running a tryout multiple clip, you can validate whether your application consistently produces the like upshot across different invocations, facilitate to notice any transient bugs.
• Performance Validation: You can emphasize test your application by invoking the like test repeatedly and measuring the clip or resource consumption, which can highlight execution bottleneck.
• : When updating or modifying code, utilise@ Test (invocationCount=x)allows regression tests to be performed multiple times to ensure no new issue are present.

Conclusion

The @ Test (invocationCount=x)annotation is a highly effective feature in TestNG that render a uncomplicated mechanism to fulfill trial methods multiple times without repeat code.

If you are a tester or a developer, you can perform across multiple device, browsers, and their versions with BrowserStack.

BrowserStack offers a platform where you can access over 3500+ different gimmick, browsers, and OS combinations apply this platform, and it supports.

Talk to an Expert

Related Guides