CurrieTesting. in engineering field relevant

Editor's Notes

• #3: Software testing is defined as the execution of a program to find its faults. While more time typically is spent on testing than in any other phase of software development, there is considerable confusion about its purpose. Many software professionals, for example, believe that tests are run to show that the program works rather than to learn about its faults. Myers has provided some useful testing definitions: Testing The process of executing a program (or part of a program) with the intention of finding errors. Verification An attempt to find errors by executing a program in a test or simulated environment (it is now preferable to view verification as the process of proving the program’s correctness) Validation An attempt to find errors by executing a program in a real environment. Debugging Diagnosing the precise nature of a known error and then correcting it (debugging is a correction and not a testing activity) Verification and validation are sometimes confused. They are, in fact, different activities. The difference between them is succinctly summarized by Boehm: ‘Validation: Are we building the right product?’ ‘Verification: Are we building the product right?’
• #4: A common view of testing is that all untested code has a roughly equal probability of containing defects. DeMarco asserts that the incidence of defects in untested codes varies widely and that no amount of testing can remove more than 50 percent of them. However, there is data that shows that properly run unit tests are potentially capable of detecting as many as 70 percent of the defects in a program. The objective should therefore be to remove as many as defects as possible before test since the quality improvement potential of testing is limited. An examination of even relatively simple programs demonstrates that exhaustive testing is generally impossible. If a program were to analyze a string of only ten alphabetic characters, there would be 2610 possible combinations. Testing one condition every microsecond would take four and a half million years. Thus test design reduces to a small subset of conditions that will reveal the characteristics of the program.
• #6: When unit tests are done on a white box basis, they are essentially path test. The idea is to focus on a relatively small segment of code and aim to exercise a high percentage of the internal paths. The simplest approach is to ensure that every statement is exercised at least once. A more stringent criterion is to require coverage of every path within a program. One disadvantage of white box testing is that the tester may be biased by previous experience. The tests are often designed by the programmers who produced the code since they may be the only ones who understand it. Unfortunately, those who created the programs’ faults are least likely to recognize them. Even though all the paths and variable of the program have gone through by the testing program, it could not guarantee all possible values of the variables have been tested. While its disadvantages are significant, white box testing generally has the highest error yield of all testing techniques.
• #7: This phase involves testing of modules which have been integrated in sub-system. A module is a collection of dependent components such as object class, and abstract data type of some looser collection of procedures and functions. On very large system it is often wise to do integration testing in several steps. Such systems generally have several relatively large components that can be built and integrated separately before combination into a full system. Integration Testing is divided into Top-down Integration Test and Bottom-up Integration Test.
• #8: Top-down Integration Test starts with the most abstract components and works downwards. It tests the high levels of a system before testing its detailed components. The program is represented as a single abstract component with sub-components represented by stubs. Top-down Integration Test is essentially a prototyping philosophy. The initial tests establish a basic system skeleton from the top and each new module adds capability. The problem is that functions of the lower-level modules that are not initially present must by simulated by program stubs. While producing such stubs may at first seem easy, it would be more difficult as more stub add on it. It may be difficult or impossible to test certain logical conditions such as error handling.
• #9: Test T1, T2, T3 are first run on a system composed of module A and module B. Module C is integrated and test T1 and T2 are repeated to ensure that there have not been unexpected interactions with A and B. Test T4 is also run on the system.
• #11: Bottom-up testing is the converse of top-down testing. It involves testing the modules at the lower levels in the hierarchy, and then working up the hierarchy of modules until the final module is tested.
• #12: Since exhaustive black box testing is generally impossible, these test should be viewed as statistical sampling; when errors are found, a closer examination is required. Functional testing stars by examining the functions the program is to perform and devising a sequence of inputs to test them.
• #13: The progressive phase introduces and tests new functions, uncovering problems in the newly added or modified modules and in their interfaces with the previously integrated modules. The regressive phase concerns the effect of the newly introduced changes on all the previously integrated code. Problems arise when errors made in incorporating new functions affect previously tested functions. The basic regression testing approach is to incorporate selected test cases into a regression test bucket that is run periodically in an attempt to detect regression problems. Usually the full bucket is run only occasionally, but the subset is run against every spin. The spin subset should include all the test cases for any recently integrated functions and a selected sample from the full regression bucket.
• #14: Generally speaking, it is too late to begin test planning when testing actually begins. A test planning can uncover at least as many problems as the actual tests themselves. Test planning starts with an overall development plan that defines the functions, roles and methods for all test phases. Some items needed for a good test plan must come from the requirement phase and they must be tracked throughout development. So, it would be better to conduct an early requirements inspection or walkthrough and to hold a re-review after every major changes.
• #15: Everything test should be treated like an experiment toe be carefully controlled and recorded so that it can be reproduced. The experimental approach also requires meticulous care in defining and recording the test environment., the procedures,and the test cases. Many organizations have found it valuable to keep a special test library with all copies of such material, together with test reports, incident forms, test analyses, and test plans.
• #16: Real-time testing can be particularly difficult because the development work is done on a host system and then compiled for execution on a target system.Typically a reasonable set of test and debug facilities is available for the host environment but the target system is generally much more sparsely equipped.