Other Tutorials by

Visual Basic - Visual Basic tutorials

VB6 beginners tutorial - Learn VB6

Advanced VB6 tutorial - Learn Advanced VB6

You are here: > Systems Analysis and Design

Strategic Approach towards Software Testing

Developers are under great pressure to deliver more complex software on increasingly aggressive schedules and with limited resources. Testers are expected to verify the quality of such software in less time and with even fewer resources. In such an environment, solid, repeatable, and practical testing methods and automation are a must.

In a software development life cycle, bug can be injected at any stage. Earlier the bugs are identified, more cost saving it has. There are different techniques for detecting and eliminating bugs that originate in respective phase.

Software testing strategy integrates software test case design techniques into a wellplanned series of steps that result in the successful construction of software. Any test strategy incorporate test planning, test case design, test execution, and the resultant data collection and evaluation.

Testing is a set of activities. These activities so planned and conducted systematically that it leaves no scope for rework or bugs.

Various software-testing strategies have been proposed so far. All provide a template for testing. Things that are common and important in these strategies are

Testing begins at the module level and works “outward” : tests which are carried out, are done at the module level where major functionality is tested and then it works toward the integration of the entire system.

Different testing techniques are appropriate at different points in time: Under different circumstances, different testing methodologies are to be used which will be the decisive factor for software robustness and scalability. Circumstance essentially means the level at which the testing is being done (Unit testing, system testing, Integration testing etc.) and the purpose of testing.

The developer of the software conducts testing and if the project is big then there is a testing team: All programmers should test and verify that their results are according to the specification given to them while coding. In cases where programs are big enough or collective effort is involved for coding, responsibilities for testing lies with the team as a whole.

Debugging and testing are altogether different processes. Testing aims to finds the errors whereas debugging is the process of fixing those errors. But debugging should be incorporated in testing strategies.

A software strategy must have low-level tests to test the source code and high-level tests that validate system functions against customer requirements.

Verification and Validation in Software Testing

Verification is a process to check the deviation of actual results from the required ones. This activity is carried out in a simulated environment so that actual results could be obtained without taking any risks.

Validation refers by the process of using software in a live environment in order to find errors. The feedback from the validation phase generally produces changes in the software to deal with bugs and failures that are uncovered. Validation may continue for several months. During the course of validating the system, failure may occur and the software will be changed. Continued use may produce additional failures and the need for still more changes.

Planning for Testing

One of the major problem before testing is while planning. Because of natural reasons a developer would like to declare his program as bug free. But this does not esantially mean that the pragrammer himself should not test his program. He is the most knowledgable person with context his own program. Therefore, he is always responsible for testing the individual units (modules) of the program, ensuring that each module performs the function for which it was designed. In many cases, the developer also conducts integration testing- a testing step that leads to the construction(and testing) of thecomplete program structure.

Only after the software architecture is complete does an independent test group(ITG) become involoved. ITG test the product very thoroughly. Both the developer and ITGs should be made responsible for testing. First developer should test the product after that ITG can do it. In this case since the developer knew that there are other people who will again test their product they'll conduct tests thoroughly. When developer and ITG work together, the product is tested thoroughly and unbiased.

Testing Strategies

Once it is decided who'll do testing then the main issue is how to go about testing. That is in which manner testing should be performed. As shown in fig. 9.3 first unit testing is performed. Unit testing focuses on the individual modules of the product. After that integration testing is performed. When modules are integrated into bigger program structure then new errors arise often. Integration testing uncovers those errors. After integration testing, other high order tests like system tests are performed. These tests focus on the overall system. Here system is treated as one entity and tested as a whole. Now we'll take up these different types of tests and try to understand their basic concepts.

Sequence of Tests
Fig 9.3 Sequence of Tests


<< Previous Page | Contents | Next Page >>


Home | About Us | Privacy Policy | Contact Us

Copyright © | All Rights Reserved