are here: Freetutes.com
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
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.
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.
Fig 9.3 Sequence of Tests
Page | Contents
| Next Page >>