Types of Testing

Types of Testing:

1. Unit Testing:

In software development, with multiple stages of testing process, unit testing is one of the

imperative stages. In this  stage, the corresponding programmers follow program testing

techniques to verify the internal structure of every coding module like program. These program

based testing techniques are also known as white box testing or glass box testing. Since white box testing requires a deeper understanding of the software development process, software engineers with a development background are placed on white box testing assignments for the duration of a project.

The purpose of  white box testing as performed by the project team is to:

l  Initiate a strategy to build quality throughout the life cycle.

l  Provide a complementary function to next stage of testing.

l  Perform complete coverage at the unit level.

l  Improve the quality by optimizing performance.

The following are the some unit testing techniques:

Segment coverage: Ensure that each code statement is executed once.

Branch Coverage or Node Testing:Coverage of each code branch in from all possible was.

Compound Condition Coverage: For multiple condition test each condition with multiple paths and combination of different path to reach that condition.

Basis Path Testing:Each independent path in the code is taken for testing.

Data Flow Testing (DFT): In this approach you track the specific variables through each possible calculation, thus defining the set of intermediate paths through the code.DFT tends to reflect dependencies but it is mainly through sequences of data manipulation. In short each data variable is tracked and its use is verified.
This approach tends to uncover bugs like variables used but not initialize, or declared but not used, and so on.

Path Testing: Path testing is where all possible paths through the code are defined and covered. Its a time consuming task.

Loop Testing: These strategies relate to testing single loops, concatenated loops, and nested loops. Independent and dependent code loops and values are tested by this approach.

2.  Integration Testing:

Integration testing is a systematic technique for constructing the program structure while at the

same time conducting tests to uncover errors associated with interfacing. The objective is to take

unit tested components and build a program structure that has been dictated by design.

Usually, the following methods of Integration testing are followed:

1. Top-down Integration approach.

2. Bottom-up Integration approach.

3. System Integration(Big-bang Integration)

2.1 Top-down Integration:

Top-down integration testing involves testing the topmost modules interface with other bottom modules in order to cover all the modules. For example, consider a product/software application development where modules become available one after the other in the order specified in the below diagram.

     Top-down integration testing is an incremental approach to construction of program structure.

Modules are integrated by moving downward through the control hierarchy, beginning with the

main control module. Modules subordinate to the main control module are incorporated into the

structure in either a depth-first or breadth-first manner.

The Integration process is performed in a series of five steps:

l  The main control module is used as a test driver and stubs are substituted for all components directly subordinate to the main control module.

l  Depending on the integration approach selected subordinate stubs are replaced one at a time with actual components.

l  Tests are conducted as each component is integrated.

l  On completion of each set of tests, another stub is replaced with the real component.

l  Regression testing may be conducted to ensure that new errors have not been introduced.

2.2 Bottom-up Integration:

 Bottom-up integration testing begins construction and testing with atomic modules (i.e. components at the lowest levels in the program structure). Because components are integrated from the button up, processing required for components subordinate to a given level is always available and the need for stubs is eliminated.

A Bottom-up integration strategy may be implemented with the following steps:

l     Low level components are combined into clusters that perform a specific software sub               function.

l     A driver is written to coordinate test case input and output.

l     The cluster is tested.

l     Drivers are removed and clusters are combined moving upward in the program structure.

2.3 System Integration(Big-bang Integration): Instead of integrating module-by-module and testing, this approach waits till all the modules arrive and one round of integration testing is done. This approach is also called Big-bang integration. It reduces the testing effort and removes duplication in testing. Big-bang integration is ideal for a product where the interfaces are stable with less number of defects.

3. System Testing: System testing is the only phase of testing, which tests the usability, functional and other non-functional aspects of the product. System testing may be started once the unit and integration testing are complete, which ensures that the more basic program logic errors and defects have been corrected.  Including the validation of the business requirements of the product, system testing is done to make sure that the product is ready for moving to the user acceptance test level.

4. Usability Testing: Testing for 'user-friendliness'. Clearly this is subjective, and will depend on the targeted end-user or customer. Usability is a combination of factors that influence users experience with a product of a system. It is a methodical evalution of the graphical user interface to measure the quality of a user's experience when interacting with a system.

5. User Interface Testing: In user Interface testing, we have to test three factors on every screen of the application:

Ø  Ease of use

Ø  Look and feel

Ø  User should able to easily navigate through the application (Short Navigation).

6. Functional Testing: Functional Testing involves testing applications functionality and features. Functional testing helps in validating what the system is supposed to do. It has only two results as far as fulfillment is concerned – met of not met.

7. Functionality Testing: It is also known as Requirements testing. Functionality testing must verify that the software can perform its function correctly.

8. Smoke Testing: Typically an initial testing effort to determine if a new software version is performing well enough to accept it for a major testing effort. For example, if the new software is crashing systems every 5 minutes, bogging down systems to a crawl, or corrupting databases, the software may not be in a 'sane' enough condition to warrant further testing in its current state.

9. Recovery Testing: Testing how well the system recovers from crashes, hardware failures and catastrophic problems is known as Recovery Testing(also called Reliability Testing). In this testing, with the help of backup and recovery procedures application can go to abnormal to normal state.

10. Regression Testing:

Regression testing is the re-execution of some subset of tests that have already been

conducted to ensure that changes have not propagated unintended side affects.

Regression may be conducted manually, by re-executing a subset of al test cases or

using automated capture/playback tools.

The Regression test suit contains three different classes of test cases:

l  A representative sample of tests that will exercise all software functions.

l  Additional tests that focus on software functions that are likely to be affected by the change.

l  Tests that focus on the software components that have been changed.

11. Re-Testing:

Testing the already tested functionality with different sets of test data to validate the behavior of

the application.

12. Load testing:

Testing an application under heavy loads, such as testing of a web site under a range of loads to

determine at what point the system's response time degrades or fails.

13. Stress testing:

Term often used interchangeably with 'load' and 'performance' testing. Stress testing is done to

evaluate a system performance beyond the limits of specified requirements, to ensure that system does not break. It is used to evaluate the behavior of the product under extreme  conditions.

14. Performance testing:

The testing performed to evaluate the response time, throughput and utilization of the system to execute its required function in comparison with different versions of the same product or different competitive product.

15. Security Testing:

Security testing attempts to verify that protection mechanisms built into a system will, in fact,

protect it from improper penetration. During Security testing, password cracking, unauthorized

entry into the software, network security are all taken into consideration.

16. Alpha Testing: The Alpha testing is conducted at the developer sites and in a controlled environment by the end-user of the software.

17. User Acceptance Testing:

User Acceptance testing occurs just before the software is released to the customer. The end-

users along with the developers perform the User Acceptance Testing with a certain set of test

cases and typical scenarios.

18. Beta Testing:

The Beta testing is conducted at one or more customer sites by the end-user of the software. The

beta test is a live application of the software in an environment that cannot be controlled by the

developer

19. Exploratory Testing:

Often taken to mean a creative, informal software test that is not based on formal test plans or

test cases; testers may be learning the software as they test it.

20. Ad-hoc Testing:

Similar to exploratory testing, but often taken to mean that the testers have significant

understanding of the software before testing it.

21. Installation Testing:

Testing the installing and uninstalling the build in the customer site like environment.

l  In this the following factors to be tested:

l  Setup Program Execution

l  Easy Screens during installation

l  Occupied Disk space

l  Check Uninstallation