Low Level Testing
Low level testing involves testing individual program components, one at a time or in combination. It requires intimate knowledge of the programs internal structure and is therefore most appropriately performed by development.
Forms of low level testing are
Unit Testing
A System is developed piecemeal, as a collection of processes and modules. The distinction between incremental and big bang testing boils down to a choice between testing the product piecemeal or in one big lump.
Under an incremental testing strategy, each piece is first tested separately. The testing of individual pieces of a process or program is called module testing, unit testing, or element testing.
Module testing (or unit testing) is a process of testing the individual subprograms, subroutines, or procedures in a program. That is rather than initially testing the program as a whole, testing is first focused on the smaller building blocks of the program. The motivations for doing this are threefold.
First, module testing is a way of managing the combinatory of testing, since attention is focused initially on smaller units of the program.
Second, module testing eases the task of debugging (the process of pinpointing and correcting a discovered error), since, when an error is found, it is known to exist in a particular module.
Finally, module testing introduces parallelism into the testing process by presenting us with the opportunity to test multiple modules simultaneously
Benefits
- By Unit Testing We are checking initial Stability and functionality for the provided module
- Before integrating particular module to the daily build, Testers understand its function and its importance as a part of visual plant
- It's useful to cover more test cases by knowing its effect on other module as well as overall system
Integration Testing
Testing combinations of pieces of the product is called integration testing. The primary objective of integration testing is to discover errors in the interfaces between the components.
Integration testing can be performed on several levels. We can integrate and test the various modules of a program, the program of subsystem, the subsystem of a system, the systems of network, and so on. There are a number of alternatives in integration testing.
Non-incremental Integration
In non-incremental "big bang" integration, all components are combined at once to form the program. The integrated result is then tested. Debugging is difficult since an error can be associated with any component.
Incremental Integration
Incremental integration is where we unit test the next program component after combining it with the set of previously tested components. There are two approaches to incremental integration: bottom-up and top-down.
Benefits
- It requires less work in the sense of fewer driver or stub modules.
- Error involving mismatched component interfaces will be detected earlier.
- Debugging is easier because errors found are usually associated with most recently added component.
- More thorough testing may result, because the testing of each new component can provide further function and logic coverage of previously integrated components.
|
