Software testing in increasingly being recognized as an area of expertise which requires specialized set of skills. In the entire scope of software project management, verification and validation of the work undertaken by a development team is of paramount importance. In this article, we explore the different approaches for software testing, which may be undertaken by the professionals working in the domain.
A good test case is one that has a high probability of detecting an undiscovered defect, not one that shows that the program works correctly. It is impossible to test your own program, Assign your best people to testing. A necessary part of every test case is a description of the expected result. Avoid non-reproducible or on-the-fly testing, ensure that testability is a key objective in your software design. Write test cases for valid as well as invalid input conditions. Thoroughly inspect the results of each test, Testing, like almost every other activity, must start with objectives. As the number of detected defects increases, the probability of the existence of more undetected defects also increases.
Types of Testing
Unit testing is a software verification method in which the smallest testable parts of an application’s program or codes, technically referred to as units, are individually and independently evaluated for proper output producing capability when some known input is provided. Unit testing is mostly automated in ITeS industries but it can also be done manually.
It is the approach in which individual software modules are combined and tested as a group. It occurs after unit testing and before validation testing. This is required to develop a better understanding on how one module can have an adverse effect on another, understand subfunctions, when combined, may not produce the desired major function, if individually acceptable imprecision in calculations may be magnified to unacceptable levels, if interfacing errors not detected in unit testing may appear, if timing problems (in real-time systems) are not detectable by unit testing and if resource contention problems are not detectable by unit testing. The approach may be handled by top down or bottom up mechanism.
Top down integration testing:
- The main control module is used as a driver, and stubs are substituted for all modules directly subordinate to the main module.
- Depending on the integration approach selected (depth or breadth first), subordinate stubs are replaced by modules one at a time.
- Tests are run as each individual module is integrated.
- On the successful completion of a set of tests, another stub is replaced with a real module
- Regression testing is performed to ensure that errors have not developed as result of integrating new modules
Bottom up integration testing:
- Integration begins with the lowest-level modules, which are combined into clusters, or builds, that perform a specific software subfunction
- Drivers (control programs developed as stubs) are written to coordinate test case input and output
- The cluster is tested
- Drivers are removed and clusters are combined moving upward in the program structure
Validation testing consists of the following steps:
- Determine if the software meets all of the requirements defined in the SRS
- Having written requirements is essential
- Regression testing is performed to determine if the software still meets all of its requirements in light of changes and modifications to the software
- Regression testing involves selectively repeating existing validation tests, not developing new tests
Alpha testing consists of the following steps
- Alpha testing is a type of acceptance testing; performed to identify all possible issues/bugs before releasing the product to everyday users or public.
- The focus of this testing is to simulate real users by using blackbox and whitebox techniques.
- The aim is to carry out the tasks that a typical user might perform.
- Alpha testing is carried out in a lab environment and usually the testers are internal employees of the organization.
- it is done early on, near the end of the development of the software, and before beta testing.
Beta testing consists of the following approaches
- Beta Testing of a product is performed by “real users” of the software application in a “real environment”
- Beta version of the software is released to a limited number of end-users of the product to obtain feedback on the product quality.
- Beta testing reduces product failure risks and provides increased quality of the product through customer validation.
- It is the final test before shipping a product to the customers.
- Direct feedback from customers is a major advantage of Beta Testing.
- This testing helps to tests the product in real time environment.
Besides these: other important software testing approaches include Object Oriented Testing
- Begins by evaluating the correctness and consistency of the OOAnalysis and OODesign models
- Testing strategy changes when the concept of the ‘unit’ broadens due to encapsulation
- Integration focuses on classes and their execution across a ‘thread’ or in the context of a usage scenario
- Validation uses conventional black box methods
- Test case design draws on conventional methods, but also encompasses special features
- class testing is the equivalent of unit testing when only the operations within the class are tested and the state behavior of the class is examined
- Integration concepts are applied three different strategies through thread-based testing—integrates the set of classes required to respond to one input or event; use-based testing—integrates the set of classes required to respond to one use case; and cluster testing—integrates the set of classes required to demonstrate one collaboration
- Random testing facilitates to identify operations applicable to a class, define constraints on their use, identify a minimum test sequence, an operation sequence that defines the minimum life history of the class (object), generate a variety of random (but valid) test sequences, exercise other (more complex) class instance life histories
- Partition testing reduces the number of test cases required to test a class same way as equivalence partitioning for conventional software. State-based partitioning categorize and test operations based on their ability to change the state of a class. Attribute-based partitioning categorize and test operations based on the attributes that they use. Category-based partitioning categorize and test operations based on the generic function each performs
- Inter-class testing ensures that for each client class, use the list of class operators to generate a series of random test sequences. The operators will send messages to other server classes. For each message that is generated, determine the collaborator class and the corresponding operator in the server object. For each operator in the server object (that has been invoked by messages sent from the client object), determine the messages that it transmits. For each of the messages, determine the next level of operators that are invoked and incorporate these into the test sequence