manual software testing process
Manual Software Testing Process
In order to make the software free of defects or bugs, it has to go through a rigorous automated or manual testing process. In most organizations, the software goes through both manual testing process and automated testing process. Manual testing is important for areas, where the defect may not be detected by an automated software test plan.
- Planning and Control
- Analysis and Design
- Implementation and Execution
- Evaluating Exit Criteria and Reporting
- Closure Activities
- The aim of this stage is to identify the scope and risk of the process and determine the aim of the testing process.
- It is in this stage that the approach to be utilized for testing process is determined. The test approach includes deciding the techniques, test items, coverage, etc., to be used for the testing process.
- The testing team to be assigned to the project is decided upon as well. Along with the team, the other resources necessary for the testing process are also determined.
- Test analysis and design tasks are scheduled along with test implementation, execution and evaluation.
- An important part of this stage is determining the exit criteria. It is the exit criteria, which helps in determining the tasks and checks that have to be completed for a particular stage, before it can be declared that the testing activity is finished.
- There is constant monitoring during the testing phase to ensure that the project does not deviate from its original plan. In case of variance in planned and the actual results, measures are taken to control damage.
- The reviews and testing process is measured and the results analysis is a part of this stage.
- The testing activity and the document writing process for the same are monitored, along with the test coverage and exit criteria.
- The stakeholders along with the senior managers are intimated about the progress of the testing process.
- In case of variance or any other problem, measures are taken to put the things right.
- The decisions about under what circumstances, continue further with the testing process, stop the testing process, deliver the software or postpone the delivery till the defects in the software are fixed, are made.
- The test basis, which include product risk analysis, requirements, software architecture, design specifications, interfaces, etc., are reviewed during this activity.
- Tests are designed and written and readied even before the actual piece of software has been developed. Different software testing methodologies are used for designing the tests.
- Along with writing the test cases, the different test conditions for each of the test items are identified. This also ensures that the module behavior and structure is well understood by the testing team.
- When the test cases are being designed, it is here that the testability of the requirements are accessed.
- The aim of the implementation activity is to develop the tests from the design.
- It is at this stage that the tests are prioritized according to their importance to the end user and for the particular release. In some cases, certain test cases although important may be prioritized for a later stage, due to paucity of time for the current release.
- Once the test cases have been prioritized, a test suite is created. In a test suite, all the prioritized test cases that logically form a single group are put together.
- Before the tests can be carried out, the environment on which the tests have to be carried out is implemented. In other words, the software has to be installed for the testers to carry out the tests.
- The test cases and/or test suites are executed and the results of the tests are recorded.
- The actual and the expected results are compared and the variance is reported, along with the test data used.
- After the defect has been fixed, retests are carried out to ensure that the defects in the software are indeed fixed. Along withe the retests, regression tests are carried out to ensure no new defects were introduced into the software, due to the changes made to the software.