Modules are individually tested, which is commonly known as unit testing, by their respective programmers using white-box testing techniques.

The next major task is to put the modules, that is, pieces, together to construct the complete system.

The path from tested components to constructing a deliverable system contains two major testing phases, namely, system integration testing(SIT) and system testing.

The primary objective of integration testing is to assemble a reasonably stable system in a laboratory environment such that the integrated system can withstand the rigor of a full-blown system testing in the actual environment of the system.

Thus, SIT is the testing of more than modules combined together, the modules being individually tested. Some common approaches to performing system integration are as follows:

Incremental Integration Testing

In this approach, integration testing is conducted in an incremental manner as a series of test cycles.

In each test cycle, a few more modules are integrated with an existing and tested build to generate a larger build.

The idea is to complete one cycle of testing, let the developers fix all the errors found, and continue the next cycle of testing.

The complete system is built incrementally, cycle by cycle, until the whole system is operational and ready for system-level testing.

The system is built as a succession of layers, beginning with some core modules. In each cycle, a new layer is added to the core and tested to form a new core.

The new core is intended to be self-contained and stable.

Top down Integration Testing

In a hierarchical system, there is a first, top-level module which is decomposed into a few second-level modules. Some of the second-level modules may be further decomposed into third-level modules, and so on. Some or all the modules at any level may be terminal modules, where a terminal module is one that is no more decomposed.

Integrate Module A and B using the stubs C’ and D’. Make corrections and perform regression testing. By the time testing is done. D will be ready. Integrate A, B and D using stub C’. Perform the same step as above. Now, include A, B, C and D using stubs E’, F’, and G, And follow the same process whilst going deeper in the hierarchy.

Advantages:

Fault Localization is easier.

Possibility to obtain an early prototype.

Critical Modules are tested on priority; major design flaws could be found and fixed first.

Disadvantages:

Needs many Stubs.

Modules at lower level are tested inadequately.

Bottom up Integration Testing

Opposite of top-down approach.

Perform Testing on E, F, G using the driver C’

Make corrections and perform regression testing. By the time testing is done. C will be ready.

Integrate E, F, G, C using A’ as driver. Perform the same step as above.

Now, integrate B, C, D, E, F, G using the driver A’. And follow the same process whilst rising up in the hierarchy

Advantages:

Fault localization is easier.

No time is wasted waiting for all modules to be developed unlike Big-bang approach

Disadvantages:

Critical modules (at the top level of software architecture) which control the flow of application are tested last and may be prone to defects.

Early prototype is not possible

Sandwich

In the sandwich approach, a system is integrated by using a mix of the top-down and bottom-up approaches. A hierarchical system is viewed as consisting of three layers. The bottom layer contains all the modules that are often invoked. The bottom-up approach is applied to integrate the modules in the bottom layer. The top layer contains modules implementing major design decisions. These modules are integrated by using the top-down approach. The rest of the modules are put in the middle layer. We have the advantages of the top-down approach where writing stubs for the low-level module is not required.

Big bang

In the big-bang approach, first all the modules are individually tested. Next, all those modules are put together to construct the entire system which is tested as a whole. Sometimes developers use the big-bang approach to integrate small systems. However, for large systems, this approach is not recommended.

Advantages:

Convenient for small systems.

Disadvantages:

Fault Localization is difficult.

Given the sheer number of interfaces that need to be tested in this approach, some interfaces links to be tested could be missed easily.

Since the integration testing can commence only after "all" the modules are designed, testing team will have less time for execution in the testing phase.

Since all modules are tested at once, high risk critical modules are not isolated and tested on priority. Peripheral modules which deal with user interfaces are also not isolated and tested on priority.