How to create JUnit Test Suite? (with Examples)

As software projects scale, managing and executing tests efficiently becomes essential. JUnit Test Suites provide a powerful way to organize and execute tests in a structured manner, particularly in complex applications. By grouping related test cases, developers can streamline the testing process, saving time and resources.

This article explores the concept of a JUnit Test Suite, comparing JUnit 4 vs. JUnit 5, and discussing the objective, benefits, and categories of test suites. It covers practical JUnit Test Suite examples for both existing and new projects, including advanced techniques, rules, extensions, and best practices.

What is a JUnit Test Suite?

In large-scale projects, multiple scenarios must be tested to ensure software reliability. In order to streamline the process, related test cases are often grouped into test suites.

This approach allows testers to execute specific sets of tests based on need, which is particularly useful when some tests are time-consuming or rely on external dependencies like API calls. These selective executions help avoid unnecessary overhead and improve test efficiency.

A JUnit test suite enables the grouping and execution of test cases across multiple classes. Instead of running each class independently, a test suite allows multiple tests to run together, making the testing process more organized and efficient.

This grouping is particularly important for managing different types of tests, such as unit, integration, or slow-running tests.

JUnit 4 vs. JUnit 5

JUnit has evolved significantly between versions 4 and 5, with notable improvements in flexibility and modern language support.

JUnit 4:

• The entire framework is packaged in a single JAR file, meaning all features are imported even if only a subset is needed.
• Supports only one test runner at a time (e.g., SpringJUnit4ClassRunner or Parameterized), limiting flexibility in combining different testing strategies.
• Was designed before Java 8 and does not leverage newer language features such as lambda expressions or streams.

JUnit 5:

• Introduces a modular architecture, allowing developers to import only the necessary components.
• Supports multiple test runners (via extensions), enabling more flexible and powerful test execution strategies.
• Fully embraces Java 8 and later versions, offering cleaner syntax and more expressive test definitions.
• Represents a complete redesign of the JUnit framework, addressing many of the limitations found in JUnit 4.

Overall, JUnit test suites are essential for structured testing in complex applications, and JUnit 5 provides a more modern, flexible, and efficient approach to test suite management.

While JUnit test suites help organize and execute tests efficiently, running them across real-world environments, browsers, devices, and operating systems can still be a challenge.

Platforms like BrowserStack enable teams to run JUnit-based Selenium or Appium tests on real devices and browsers in the cloud, eliminating the need to maintain test infrastructure.

Benefits of Using a Test Suite

The primary benefits of using a test suite include:

• Organized Testing: Groups related test cases for easier planning and execution.
• Comprehensive Coverage: Combines functional and non-functional test types within a single suite.
• Clear Purpose: Documents the intent behind each test case, aiding traceability.
• Defined Criteria: Includes Test environment details such as software version, operating system, and dependencies.
• Customizable Structure: Can be tailored based on test frequency, complexity, or scope.
• Faster Execution: Allows for efficient, repeatable testing, especially during regression or continuous integration cycles.

By creating test suites tailored to different types of tests, such as functional, UI, or performance, you can streamline quality assurance and improve collaboration between QA and business teams.

Test Suite Categories

Test suites can be divided into two main categories based on their purpose and level of abstraction:

• Abstract Test Suite: A high-level set of test cases derived from a model of the system under test (SUT). It outlines testing objectives and system behavior but lacks implementation details, making it non-executable. It serves as a blueprint for creating executable tests.
• Executable Test Suite: A detailed, runnable set of test cases derived from abstract tests. It includes specific instructions that interact directly with the system under test (SUT), enabling automated or manual execution to verify functionality.

 How to run JUnit Test Suite?

To run a JUnit test suite, it’s essential to understand how to create and organize it. The following sections outline different ways to set up a test suite.

1. Creating a Test Suite for an Existing Project

Follow these steps to develop a test suite in Eclipse:

1. Navigate to the project where you want to create the test suite in Eclipse.
2. In the package explorer pane, right-click on the project and choose “New” from the context menu.
3. Select “JUnit” from the list of available options in the new window, followed by “JUnit Test Suite” from the sub-menu.
4. To move to the next step, use the “Next” button.
5. The name and location of the test suite can be specified in the following box. Make sure to choose a location.
6. To complete the test suite, click the “Finish” button.
7. After you’ve created the test suite, you can add individual test cases by right-clicking on it in the Package Explorer pane and selecting “Add New Test” from the context menu.
8. In the next window, you can give the new test case a name and a location. Make certain that you choose a location within the test suite’s package.
9. To complete the test scenario, click the “Finish” button.
10. Repeat the preceding steps to add more test cases to the test suite.
11. Once you’ve added all of the test cases to the test suite, you can run it by right-clicking on it in the Package Explorer pane and selecting “Run As” for “JUnit Test” from the context menu.
12. This will run all test cases in the test suite and show the results in the JUnit view.

2. Creating a Test Suite for a New Project

The procedures below can be used to construct a test suite in Eclipse:

1. Navigate to the project where you want to build the test suite in Eclipse.
2. Right-click the project in the package explorer pane and choose “New” from the context menu.
3. Pick “JUnit” from the drop-down menu in the new window, then pick “JUnit Test Suite” from the sub-menu.
4. To move on to the next phase, click “Next”.
5. You can specify the test suite’s name and location in the following window. Choose a site that is located in the project’s source folder.
6. To finish building the test suite, click “Finish”.
7. Individual test cases can be added to a test suite after it has been created by right-clicking the test suite in the Package Explorer pane and choosing “Add New Test” from the context menu.
8. The name and location of the new test case can be entered in the following window. Select a location from the test suite’s package carefully.
9. To finish creating the test case, click “Finish”.
10. Follow the same procedure to add more test cases to the test suite.
11. The test suite can be performed entirely when all test cases have been created by right-clicking on the test suite in the Package Explorer pane and choosing “Run As” for “JUnit Test” from the context menu.

3. Creating a Test Suite for Different Test Types

A test suite is a collection of test cases grouped together to execute and track testing progress. It plays a key role in software development by helping teams organize test cases based on testing objectives, planning needs, or analysis requirements.

For example, a test suite for a product purchasing workflow might include:

• Test Case 1: Login
• Test Case 2: Add Products to Cart
• Test Case 3: Checkout
• Test Case 4: Logout

Talk to an Expert

Creating a Basic JUnit Test Suite

A JUnit test suite example can be better understood by setting up a sample project.

• A test suite groups and runs several unit test cases at once. The suite tests in JUnit are executed using both the @RunWith and @Suite annotations. This section uses TestJunit1 and TestJunit2 as two test classes running simultaneously using the Test Suite.
• Make a test Java class under C:\>JUNIT_WORKSPACE, such as MessageUtil.java.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

private String message;

//Constructor
public MessageUtil(String message){
this.message = message; 
}

// prints the message
public String printMessage(){
System.out.println(message);
return message;
}


public String salutationMessage(){
message = "Hello!" + message;
System.out.println(message);
return message;
} 
}

Creating Test Classes

• In C:\>JUNIT_WORKSPACE, create a Java class file called TestJunit1.java.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit1 {

String message = "Robert"; 
MessageUtil messageUtil = new MessageUtil(message);

@Test
public void testPrintMessage() { 
System.out.println("Inside testPrintMessage()"); 
assertEquals(message, messageUtil.printMessage()); 
}
}

• In C:\>JUNIT_WORKSPACE, create a Java class file called TestJunit2.java.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit2 {

String message = "Robert"; 
MessageUtil messageUtil = new MessageUtil(message);

@Test
public void testSalutationMessage() {
System.out.println("Inside testSalutationMessage()");
message = "Hello!" + "Robert";
assertEquals(message,messageUtil.salutationMessage());
}
}

Creating a Test Suite 

• Construct a Java class.
• Add the annotation @RunWith(Suite.class) to the class.
• Making use of the @Suite.SuiteClasses annotation, add references to JUnit test classes.
• To run the test case(s), create a Java class file called TestSuite.java in C:\>JUNIT_WORKSPACE.

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)

@Suite.SuiteClasses({
TestJunit1.class,
TestJunit2.class
})

public class JunitTestSuite { 
}

• Create Test Runner Class
• To execute the test case(s), create a java class file named TestRunner.java in C:\>JUNIT_WORKSPACE.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;


public class TestRunner {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(JunitTestSuite.class);


      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
 
      System.out.println(result.wasSuccessful());
   }
}

Running the Test Suite 

• Compile all of the Java classes with javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit1.java 
TestJunit2.java JunitTestSuite.java TestRunner.java

Execute the Test Runner, which will execute the test case defined in the specified Test Case class.

C:\JUNIT_WORKSPACE>java TestRunner

Check the output.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hello Robert
true

Grouping Tests using JUnit Test Suite

You want your unit tests to execute as fast as possible and provide you with as much information as possible at the beginning of a well-organized build process. Having the option to organize your tests into distinct groups is a helpful instrument for this.

• This can help you tell the difference between quick-running unit tests and longer-running integration, performance, load, or acceptance tests, for instance.
• Using JUnit Categories, you can organize your tests into logical groups and run them independently of one another. For instance, you can differentiate between fast and slow tests.
• Annotations allow you to choose which classes to include or dismiss. The @Category annotation is available for labeling test cases and methods with one of these groups.

Grouping Tests using JUnit Categories

You need to establish your categories first: FastTests and SlowTests.

FastTests.java

public interface FastTests { /* category marker */ }

SlowTests.java

public interface SlowTests { /* category marker */ }

A class or an interface can both be considered categories. Method b() of class A is annotated with the @category keyword in the code below.

Indicating that method b() falls under the SlowTests category. By doing this, you were able to mark each test method separately in addition to the entire class.

import org.junit.Test;
import org.junit.experimental.categories.Category;
public class A {
@Test
public void a() {
System.out.println("a() method of class A has been run...\n");
}
@Category(SlowTests.class)
@Test
public void b() {
System.out.println("b() method of class A has been run...\n");
}
}

Class B is marked with the @Category annotation in the code below. As a result, this category includes all of the test methods for this test class.

You can see that a test class or test method can be categorized under multiple categories.

import org.junit.Test;
import org.junit.experimental.categories.Category;
@Category({SlowTests.class, FastTests.class})
public class B {
@Test
public void c() {
System.out.println("c() method of class B has been run...\n");
}
}

Running Test Groups 

• You can see that the name of your test suite is SlowTestFirstSuite in the code below.
• A test suite can also be categorized. Which categories will be executed are indicated by the annotation @IncludeCategory.
• The SlowTest category is present in the example below and will be used.
• As a result, the test methods b() of class A and c() of class B will be run.

SlowTestFirstSuite.java
import org.junit.experimental.categories.Categories;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
@RunWith(Categories.class)
@Categories.IncludeCategory(SlowTests.class)
@Suite.SuiteClasses({ A.class, B.class }) // Note that Categories is a kind of Suite
public class SlowTestsFirstSuite {
// b() method of class A has been run...
// c() method of class B has been run...
}

• The code below has an annotation called @ExcludeCategory that specifies which categories will not be executed.
• The test method b() of class A will be run in the code sample below, but methods a() and c() of class A and class B won’t be run because they are excluded from execution by the @ExcluedeCategory annotation.
• Because it is not in any category, the test method a() of class A will not be run in either scenario.

import org.junit.experimental.categories.Categories;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
@RunWith(Categories.class)
@Categories.IncludeCategory(SlowTests.class)
@Categories.ExcludeCategory(FastTests.class)
@Suite.SuiteClasses({ A.class, B.class }) // Note that Categories is a kind of Suite
public class SlowTestsSecondSuite {
//b() method of class A has been run...
}

Advanced JUnit Test Suite Techniques

In a test class, JUnit enables developers to use parameters.

• Using the annotation, the test class can be identified as a parameterized test: @RunWith(Parameterized.class)
• A static method with the @Parameters annotation that create
• s and returns a Collection of Arrays must be present in the test class. Each object in this collection is one of the test method’s parameters.
• When a parameterized test class is run, instances of the test methods and the test data components are produced for the cross-product (binary operation of two arrays).
• Each test’s values will be stored in the public constructor. The number of elements in each array that is supplied by the method with the @Parameters annotation must match the number of elements in the constructor of the class. The constructor passes each parameter’s class and test values to the class.
• In JUnit 5, the Assumptions class allows you to use static methods to set conditions for test execution. These conditions will be based on your assumptions; if one fails, the test will be aborted (rather than failing, as with assertions). They allow you to programmatically determine whether to continue running tests, saving you a significant amount of time and perhaps computing bandwidth during testing.
• It can be useful to temporarily disregard some test scenarios. You can use the @Disabled annotation to prevent those tests (individual test methods or entire test classes) from running. In the test report, any @Disabled test method will be noted as disabled. @Disabled allows you to indicate a rationale for deactivating the test as a parameter.
• Nested test classes can be used to organize tests that should be together logically.
• Using the @Timeout annotation allows you to specify a maximum time for the execution of a test method. If the test takes longer to execute than the duration you selected (which is by default defined in seconds), @timeout will simply fail the test.

Using JUnit Rules

• A rule changes how a test method or methods are conducted or reported.
• The @Rule annotation indicates that the class implements the TestRule interface.
• The @ClassRule annotation corresponds to the TestRule class.
• Rules allow you to write code to inspect a test before it is run, change how and whether it is run, and inspect and alter the test results.
• A rule implementation can intercept test method execution and change the behavior of these tests, or it can include cleaning work like @Before, @After, @BeforeClass, and @AfterClass.
• The rules notion is similar to JUnitRunners, but with the added feature of combining different rules. When combining many Runners, it is best to use rule cases.

Using JUnit Extensions

JUnit 5 extensions are associated with a specific event during test execution known as an extension point. The JUnit engine invokes registered extensions when a given life cycle phase is reached.

Five primary types of extension points can be used:

• test instance post-processing
• conditional test execution
• life-cycle callbacks
• parameter resolution
• exception handling

Best Practices for JUnit Test Suites

To ensure efficient and effective use of JUnit Test Suites, the following best practices should be followed.

1. Naming Conventions

• The test names should be insightful, and users should be able to grasp the test’s behavior and expectations simply by looking at the name.
• givenEmployeeObject_whenSaveEmployee_thenReturnSavedEmployee
• givenEmployeesList_whenFindAll_thenReturnListOfEmployees
• givenEmployeeObject_whenUpdateEmployee_thenReturnUpdatedEmployee

2. Test Organization

• Separating the test classes from the production code is recommended. This means they are created, run, and maintained independently from the code used in production.
• In addition, it eliminates the risk of having development code executed in the production environment.

3. Test Suite Maintenance

• Make sure that each test is written independently of the others.
• So, whenever you write multiple Unit tests, ensure that they are all independent of one another. This will assist you in determining the root problem and correctly testing the logic unit.
• Use the @BeforeEach and @AfterEach annotations to put up any prerequisites for all of your test cases. The @BeforeEach and @AfterEach methods in the current class execute before and after each method annotated with @Test, @RepeatedTest, @ParameterizedTest, or @TestFactory.
• JUnit conducts tests in any sequence by default. To modify the order of test execution, just annotate your test class with @FixMethodOrder and pick one of the available MethodSorters:
• @FixMethodOrder(MethodSorters.JVM): Leaves the test methods in the order returned by the JVM. This order may differ from run to run.
• @FixMethodOrder(MethodSorters.NAME_ASCENDING): Sorts the test methods in lexicographic order by the method name.

What is the use of suite in JUnit 5?

The @Suite annotation is used to create test suites in JUnit 5. Suites facilitate the execution of tests dispersed over various classes and packages. To narrow down your test cases, you can take advantage of the Include and Exclude annotations.

To specify which tests should be included or excluded from a given suite, JUnit 5 offers the following annotations.

• @SelectClasses
• @SelectPackages
• @IncludePackages
• @ExcludePackages
• @IncludeClassNamePatterns
• @ExcludeClassNamePatterns
• @IncludeTags
• @ExcludeTags

Conclusion

JUnit Test Suites play a critical role in structuring and streamlining the testing process, especially in large and complex applications. By grouping related test cases, they enable efficient execution, better organization, and improved test coverage.

With the flexibility offered by JUnit 5, teams can adopt more modular and scalable testing strategies using rules, extensions, and advanced suite configurations. Implementing best practices further enhances the reliability and maintainability of test suites, making them a valuable asset in any development workflow.

To take testing a step further, integrating test suites with a scalable and real-world execution environment is key. BrowserStack Automate empowers teams to run JUnit-based Selenium and Appium tests across 3500+ real browser and device combinations, directly from the cloud. It supports:

• Parallel test execution to drastically reduce test runtime
• Local testing for staging environments behind firewalls
• Test observability features like video recordings, screenshots, logs, and detailed debugging
• Zero maintenance of infrastructure, allowing teams to focus purely on test logic

By combining the power of JUnit Test Suites with BrowserStack Automate, development and QA teams can ensure faster feedback, higher coverage, and more reliable software, delivered at scale and speed.

Try BrowserStack Now