How to perform Integration Testing:

This integration testing is performed mainly in two ways

· Non-Incremental method and

· Incremental method

In Non-incremental method, we integrate all the modules at a time. This method is basically a "big-bang" approach. This method, while common, is not recommended because it makes it almost impossible to determine the cause of any errors or problems.

In Incremental method, we integrate small segments of the system slowly in order to easily isolate the problems. This method is preferred and is highly encouraged because it enforces a more systematic approach to software development and will improve reliability.

This incremental method can be done in three ways.

1. Top-down

2. Bottom-up

3. Critical Section.

2.Bottom-up

Steps to perform Integration Testing using Bottom-up approach

· First the lower level modules are combined to form builds or clusters.

· A special, simple and short program is written to test the cluster is called as Driver.

· Replace the driver with module higher in hierarchy.

· Use regression testing (conducting all or some of the previous tests) to ensure new errors are not introduced.

Advantages:

· Easier to create test cases and observe output.

· No stubs are required.

· Errors in critical modules are found early

· It supports reuse of low-level units

· Interface faults can be more easily found: when the developers substitute a test driver by a higher level component, they have a clear model of how the lower level component works and of the assumptions embedded in its interface.

Disadvantages:

· Major drawback is absence of working system until integration complete.

· Test drivers are must.

· High-level errors may cause changes in lower modules.

· It tests the most important subsystems lastly.

Prerequisites for Bottom-up Approach

· Test Plan

· HLDD-High Level Design Document

· LLDD-Low Level Design Document

Identify the Exact Procedure for writing Drivers for Bottom-up approach:

1. Identify the methods, which are to be called by a method in higher level module.

2. Identify the parameters to be passed from the lower level module or same level.

3. Identify the domain values of each parameter passed from the lower level module or same level.

4. Identify the order in which the parameters passed between the components/modules from the lower level module or same level.

5. By considering the above parameters a driver is written

Where and why drivers are required Bottom-up testing requires the writing of drivers. Drivers simulate both its environment (how it is called) in the system we are building, and all other environments in which it may be called according to its specification. A driver is required in order to perform complete testing.

Driver:

Driver is a simple and short program written to test a function. The driver should be simple enough that we can confirm its correctness by inspection.

The Developing Stub-Driver Vs Test Execution and Regression testing analysis:

Well Designed Drivers/Stubs gives the following output

· High Effort in Development

· Low effort in test execution and regression testing

Poorly Designed Drivers/Stubs gives the following output

· Low Effort in development

· High effort in test execution and regression testing

How to Design Test Cases from Sequence DiagramsBefore writing the testcases we have to identify the following things.

1. Study the sequence diagram that shows the integration of different components/modules.

2. Verify the object lifetime as per the sequence diagram.

3. Identify the components/modules to be integrated from the sequence diagrams

4. Identify the main (start) method name, which calls a method in other module.

5. Identify the parameters passed

6. Identify the domain values of each parameter passed

7. Identify the order in which the parameters passed between the components/modules

From these parameters derive the test cases by

i. Divide the input domain into equivalent classes, such that all valid, invalid values which falls under classes

ii. Identify boundary values of each equivalent class as input data

iii. Identify some random values from the class as input data