Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
LIFE CYCLE
(STLC)
3. Design
4. Execution
5. Cycles
7. Post Implementation
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 broader in scope than a
test plan is also made.
• 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
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
identified at this stage)
• Tools, Techniques and Methodologies
• Code Control
• Media Control
• Supplier Control
• Records, Collection, maintenance and Retention
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 :
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 some kind of Risk Assessment Criteria is developed. Also writing
of automated testing scripts begins. 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.
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 - developers would carry out unit testing with tester’s 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 are found - reporting would be done.
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 second round 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.
Testing --> Bug reporting --> Bug fixing (and enhancements) --> Retesting is carried out
as planned. Here is where automation tests are extremely useful to repeat the same test
cases again and again.
During this phase - review of test cases and test plan could also be carried out.
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 are given. Test reports are prepared. if required, a test release note, releasing the
product for roll out could be prepared. Other remaining documentation is completed.
This phase, that looks good on paper, is seldom carried out. In this phase, the testing is
evaluated and lessons learnt are documented. Software Metrics (Bug Analysis Metrics)
are analyzed statistically and conclusions are drawn. Strategies to prevent similar
problems in future projects are identified. Process Improvement Suggestions are
implemented. Cleaning up of testing environment and Archival of test cases, records and
reports are done.