Software Testing Life Cycle Consists of the Following Phases

8/6/2019 Software Testing Life Cycle Consists of the Following Phases

http://slidepdf.com/reader/full/software-testing-life-cycle-consists-of-the-following-phases 1/3

Software Testing Life Cycle consists of the following phases:

1. Planning

2. Analysis

3. Design

4. Execution

5. Cycles

6. Final Testing and Implementation

7. Post Implementation

1. Test Planning (Product Definition Phase):The test plan phase mainly signifies preparation of a test plan. A test plan is a high level planning

document derived from the project plan (if one exists) and details the future course of testing.

Sometimes, a quality assurance plan - which is more broader in scope than a test plan is alsomade.

Contents of a Test Plan are as follows :

• Scope of testing

• Entry Criteria (When testing will begin?)

• Exit Criteria (When testing will stop?)

• Testing Strategies (Black Box, White Box, etc.)• Testing Levels (Integration testing, Regression testing, etc.)

• Limitation (if any)

• Planned Reviews and Code Walkthroughs

• Testing Techniques (Boundary Value Analysis, Equivalence Partitioning, etc.)

• Testing Tools and Databases (Automatic Testing Tools, Performance testing tools)

• Reporting (How would bugs be reported)

• Milestones

• Resources and Training

Contents of a SQA Plan, more broader than a test plan, are as follows :

The IEEE standard for SQA Plan Preparation contains the following outline :

• Purpose

• Reference Documents

• Management

• Documentation

• Standards, Practices and Conventions



• Reviews and Audits

• Software Configuration Management

• Problem Reporting and Corrective Action (Software Metrics to be used can be identifiedat this stage)

• Tools, Techniques and Methodologies

•

Code Control• Media Control

• Supplier Control

• Records, Collection, maintenance and Retention

2.Test Analysis (Documentation Phase)

The Analysis Phase is more an extension of the planning phase. Whereas the planning phase pertains to high level plans - the Analysis phase is where detailed plans are documented. This is

when actual test cases and scripts are planned and documented.

This phase can be further broken down into the following steps :

• Review Inputs : The requirement specification document, feature specification documentand other project planning documents are considered as inputs and the test plan is further

disintegrated into smaller level test cases.

• Formats : Generally at this phase a functional validation matrix based on BusinessRequirements is created. Then the test case format is finalized. Also Software Metrics are

designed in this stage. Using some kind of software like Microsoft project, the testing

timeline along with milestones are created.

• Test Cases : Based on the functional validation matrix and other input documents, testcases are written. Also some mapping is done between the features and test cases.

•

Plan Automation : While creating test cases, those cases that should be automated areidentified. Ideally those test cases that are relevant for Regression Testing are identifiedfor automation. Also areas for performance, load and stress testing are identified.

• Plan Regression and Correction Verification Testing : The testing cycles, i.e. number of

times that testing will be redone to verify that bugs fixed have not introduced newer errors is planned.

3. Test Design (Architecture Document and Review Phase):

One has to realize that the testing life cycle runs parallel to the software development life cycle.

So by the time, one reaches this phase - the development team would have created some code or at least some prototype or minimum a design document would be have been created.

Hence in the Test Design (Architecture Document Phase) - all the plans, test cases, etc. from the

Analysis phase are revised and finalized. In other words, looking at the work product or design -

the test cases, test cycles and other plans are finalized. Newer test cases are added. Also somekind of Risk Assessment Criteria is developed. Also writing of automated testing scripts begin.

Finally - the testing reports (especially unit testing reports) are finalized. Quality checkpoints, if

any, are included in the test cases based on the SQA Plan.

http://www.testingbrain.com/info/tutorial.php?artid=181










4. Test Execution (Unit / Functional Testing Phase):

By this time. the development team would have been completed creation of the work products.

Of Course, the work product would still contain bugs. So, in the execution phase - developerswould carry out unit testing with testers help, if required. Testers would execute the test plans.

Automatic testing Scripts would be completed. Stress and performance Testing would be

executed. White box testing, code reviews, etc. would be conducted. As and when bugs arefound - reporting would be done.

5. Test Cycle (Re-Testing Phase):

By this time, minimum one test cycle (one round of test execution) would have been completed

and bugs would have been reported. Once the development team fixes the bugs, then a secondround of testing begins. This testing could be mere correction verification testing, that is

checking only that part of the code that has been corrected. It could also be Regression Testing -

where the entire work product is tested to verify that correction to the code has not affected other parts of the code.

Hence this process of :Testing --> Bug reporting --> Bug fixing (and enhancements) --> Retesting

is carried out as planned. Here is where automation tests are extremely useful to repeat the sametest cases again and again.

During this phase - review of test cases and test plan could also be carried out.

6. Final Testing and Implementation (Code Freeze Phase):

When the exit criteria is achieved or planned test cycles are completed, then final testing is done.

Ideally, this is System or Integration testing. Also any remaining Stress and Performance testing

is carried out. Inputs for process improvements in terms of software metrics is given. Test reportsare prepared. if required, a test release note, releasing the product for roll out could be prepared.

Other remaining documentation is completed.

7. Post Implementation (Process Improvement Phase):

This phase, that looks good on paper, is seldom carried out. In this phase, the testing is evaluatedand lessons learnt are documented. Software Metrics (Bug Analysis Metrics) are analyzed

statistically and conclusions are drawn. Strategies to prevent similar problems in future projects

is identified. Process Improvement Suggestions are implemented. Cleaning up of testingenvironment and Archival of test cases, records and reports are done.