What is Incremental Testing: Detailed Explanation With Examples

With the help of this article, I am going to cover one of the important Integration Approach – Incremental Testing.

By the end of this section, the audience will have a fair knowledge of following:

What You Will Learn:

What is Incremental Testing

Incremental Testing, also known as Incremental Integration Testing, is one of the approaches of Integration Testing and incorporates its fundamental concepts.

It is like a test which combines Module and Integration testing strategy.

In this testing, we test each module individually in unit testing phase, and then modules are integrated incrementally and tested to ensure smooth interface and interaction between modules.

In this approach, every module is combined incrementally, i.e., one by one till all modules or components are added logically to make the required application, instead of integrating the whole system at once and then performing testing on the end product. Integrated modules are tested as a group to ensure successful integration and data flow between modules.

As in integration testing, the primary focus of doing this testing is to check interface, integrated links, and flow of information between modules. This process is repeated till the modules are combined and tested successfully.


Let’s understand this concept with an example:

System or software application consists of following Modules:

Incremental Integration testing approach




Objective of Incremental Test

Incremental Integration Testing Methodologies

Before we start with this topic, I will like to give a brief intro about Stubs and drivers since we will be using these terms often.

Stubs and drivers are pseudo code or dummy code used in Integration or component testing when one or more modules are not developed but are required to test some other module.

Stubs are used in Top-down testing approach and are known as “called programs”. Stubs help simulate the interface between lower lever modules which are not available or developed.

Drivers are used in Bottom-up testing approach and are known as “calling programs”. Drivers help simulate the interface between top level modules which are not developed or available.

A question that might occur to some of us is why not wait till all the application modules are developed instead of using stub/driver before starting testing?

The simple answer is that it increases the project execution time since testers will be sitting idle till all the modules are developed. Also, this makes the root analysis of defect difficult. This type of testing approach is known as Big-Bang Integration testing.

Now that we have covered Stubs and drivers, let’s move on to different methodologies of Incremental Testing:

#1) Top Down

As the name suggests, testing takes place from top to bottom, i.e., from the central module to sub module. Modules framing the top layer of application are tested first.

This approach follows the structural flow of the application under testing. Unavailable or not developed modules or components are substituted by stubs.

Let’s understand this with an example:

Top down Incremental Integration Testing Approach

Following test cases will be derived:

Test Case1: Module L and Module O will be integrated and tested

Test Case2: Module L, O and P will be integrated and tested

Test Case3: Module L, O, P and R will be integrated and tested.

And so on other test cases are derived.

This type of testing where all modules at a layer are first integrated and tested is known as “breadth-first”. Another category is “depth-first”.

Following test cases will be derived for “depth-first”:

Test Case1: Module L and Module O will be integrated and tested

Test Case2: Module L, O and OS will be integrated and tested

Test Case3: Module L, O, OS, P will be integrated and tested

Test Case4: Module L, O, OS, P, CP will be integrated and tested

And so on other test cases are derived.

Merits of Top-down Methodology

De-Merits of Top-down Methodology

#2) Bottom-up

In this approach, testing takes place from bottom to top, i.e., modules at bottom layer are integrated and tested first and then sequentially other modules are integrated as we move up. Unavailable or not developed modules are replaced by drivers.

Let’s look at a below-mentioned example for better understanding:

Modules Rank, Marks, Percentage and Sports Grade are not yet developed so they will be substituted with related Driver:

Bottom up Incremental Integration testing approach

Following test cases will be derived:

Test Case1: Unit testing of module Practical and Theory

Test Case2: Integration and testing of Modules Marks-Practical-theory

Test Case3: Integration and testing of Modules Percentage-Marks-Practical-Theory

Test Case4: Unit testing of Module Sports Grade

Test Case5: Integration and testing of Modules Rank-Sports Grade-Percentage-Marks-Practical-Theory

Merits of Bottom-up Methodology

De-merits of Bottom-up Methodology

#3) Sandwich Testing

This approach is a hybrid of top-down and bottom-up methodology. Stub and drivers are used for incomplete or not developed modules.

Testing Approach


Following test cases can be derived with Sandwich Testing Strategy:

Test Case1: Test A, X, Y, and Z individually – where Test A comes under Top layer test and Test X, Y and Z comes under Bottom layer tests

Test Case2: Test A, G, H and I

Test Case3: Test G, X, and Y

Test Case4: Test Hand Z

Test Case5: Test A, G, H, I, X, Y, and Z

Merits of Sandwich Testing Methodology

De-merits of Sandwich Testing Methodology


Incremental Testing comes under the blanket of Integration testing. In this approach of testing, integration testing is done on the individual module as a part of unit testing and in next phase, modules or components of the application are integrated incrementally and testing is performed on combined modules as a group.

Out of three methodologies of Incremental Integration Testing, the choice of which methodology to choose depends on the structure of the application and also on the position of high-risk modules.

All three methodologies of incremental testing come under Horizontal category because of following behavioral aspects:


With this testing approach, it is easier to identify defects early, and it also helps the developer determine the cause of the issue. Since it uses the basics of structured testing, this testing approach is very effective and accurate.


This type of testing approach is time-consuming because of use of stubs and drivers. It is also repetitive.

About the author: This helpful tutorial is written by Neha B. She is ISTQB certified Lead Quality Analyst with 8+ years of experience.

Let us know if you have any questions/suggestions.