Testing is a fundamental part of any production process. No matter what the product is, it is always tested for quality and defects before it reaches the customers so that they receive a fully-functioning quality product. The same applies to software products as well. In the world of software, the testing process is formally called Software Testing Life Cycle (STLC)!
For example, in a car manufacturing facility the production process consists of numerous steps including engineering, assembly, paint job, interior installations, etc. But before a car is shipped to a showroom to be sold to customers, it always passes through a rigorous testing procedure. This ensures that the final product meets the required quality and safety standards.
Now think if the business is a software development firm and the product being produced is a customised piece of software. The same concept of quality assurance applies here as well! A software product is always tested and goes through a software testing life cycle before it is deployed to be used by the clients or end users.
So if you are wondering how exactly is a software product tested, you need to understand what a software testing life cycle is and what steps are part of a successful software testing process.
What is Software Testing Life Cycle?
Software testing life cycle is a multi-step testing procedure that is carried out to certify a software product. It defines a series of phases that are performed by software engineers to test that the software is free of bugs and faults.
You might already know that when developing a software, it goes through phases of a software development life cycle (SDLC). So how is software development life cycle (SDLC) different from software testing life cycle (STLC)?
STLC vs. SDLC: How do they differ?
The distinction between SDLC and STLC is actually very simple! SDLC outlines the steps of the overall software development process, all the way from gathering requirements to deployment and maintenance of the software. Testing is a step in SDLC that is performed before deployment. It is also commonly referred to as Quality Assurance.
STLC on the other hand, is a series of steps performed within the testing phase. It outlines sequential phases and activities that are performed while testing a software product.
Now that you are clear about what is STLC and how it differs from SDLC, let’s understand what are the different phases in STLC.
With the advancement of software technology, the testing process has also become more complex. Today a software product goes through multiple STLC phases before it is deployed and used. Various types of tests are conducted to identify not just the bugs but any minor glitches so that the clients are completely satisfied with the performance and quality of your products.
STLC models usually consists of 6 phases of testing beginning from requirement analysis to test cycle closure. The phases of STLC take place in the following order:
- Requirement Analysis
- Test Planning
- Test case development
- Test Environment setup
- Test Execution
- Test Cycle closure
All software testing phases are important because they make sure that testing is carried out in a systematic manner and is documented to avoid any gaps. All STLC phases basically include a list of activities that need to be performed, and has a set entry and exit criteria.
What is Entry and Exit Criteria?
Entry Criteria: These are all the prerequisites that need to be completed before the phase of the testing life cycle can be initiated.
Exit Criteria: These are the requirements that need to be met before the phase of testing cycle can be concluded.
In the sections that follow we will take a closer look at what the entry and exit criteria for each phase of STLC testing are, and what activities are performed within it.
As the name suggests, a requirement analysis phase involves gathering information about the software requirements, and the purpose why the software is being built. It is very important to be familiar with the requirements of the software product in terms of its functionalities, specifications, and design. Reviewing these requirements allows the Quality Assurance (QA) team to know exactly what needs to be tested.
This is the first step of a Software Development Life Cycle as well. The documents prepared at that stage, such as Functional Specification Document, Software Requirement Specification Document, and Application Design Document usually serve as a requisite for this phase.
Using these documents, QA team reviews all the requirements and they consult project managers, clients, subject matter experts and other relevant people regarding any questions and queries they might have. This step ensures that they have a sound knowledge about the product that needs to be tested.
Using the information gathered they should define the focus and priorities of the testing process. The test environment details should also be evaluated at this stage. Moreover, it should also be defined if automated testing will be required or not. Automated testing is a process where a software product is tested using automation tools that run predefined test cases. It needs to be decided in this phase whether testing will be carried out manually or using such automation.
|To begin requirement analysis, you need to have the following documents available:|
– Functional Specification Document
|The following activities are carried out at this stage:|
– Review the software requirements mentioned in the documents.
|List of all the testable requirements|
If automation testing is required then an automation feasibility report will also be prepared in this software testing phase.
After the requirement analysis is completed the QA team proceeds to the test planning phase. It is a fundamental stage of a testing development life cycle. A test plan document is made during this stage that outlines the test strategy. You can think of this document as a blueprint of the entire testing process, the steps involved within it, the tools required and every other detail that will be important for testing of the software product. You can think of a test plan document as a business plan.
A key step performed at this stage is that the risks and costs of the testing process are estimated. A team effort estimation document is prepared that measures the testing process in terms of hours required to complete it. Using this, a timeline for the process is created which becomes a part of the test plan document
The table below summarizes the requirements, activities and deliverables of the test planning phase.
|To begin the test planning stage, the following documents should be available:|
– Requirement Specifications Document
– Automation feasibility report (if applicable)
– List of testable requirements
|Following activities will be performed in this phase:|
– QA team will determine the objectives and coverage of the test project.
– Prepare a list of the types of testing that will be carried out. There are multiple types of testing that are performed including:
● Unit Testing
● System Testing
● Integration Testing
● User Acceptance Testing (UAT)
– Select testing tools that are required to conduct software testing. For example, every software testing life cycle requires at least one of the following tools:
● A bug reporting tool
● Test management tool
● Test automation tool (if required)
– Break down the testing process into steps and describe each step.
– Define the test environment required.
– Prepare a test schedule highlighting the timeline for the entire testing process and each step.
– If the testing process involves automation testing then the steps, requirements and details of automation testing will also be compiled at this stage.
– Define control procedures and the risks of the STLC methodology
|A detailed test plan document. You can find the test plan template here.|
Test effort estimation document – this document highlights the software testing life cycle in terms of hours required to complete it.
Test case development
Test case are detailed test scenarios that are executed to check every functionality of the software product. Imagine if you have to test an email app developed for mobile phones – for every functionality of the app, there will be a different test scenario. For example, to test that the login function of the app performs perfectly, emails are being transmitted from the sender to the recipient, formatting is proper, and hundreds of other test cases will be written in order to ensure that all aspects of the application are tested. Let’s take a closer look at this example.
When a user tries to login to the app, they will perform the following steps:
- Launch the email app on their phone
- Enter their Email address
- Enter their Password
- Click the login/submit button.
This scenario can result in a number of test cases, for example:
Test Case # 1: Test result when correct email address and password is entered
Test Case # 2: Test result when incorrect email address and password is entered
Test Case # 3: Test result when correct email address and incorrect password is entered
Test Case # 4: Test result when incorrect email address and correct password is entered
Test Case # 5: Test result when email and password are left blank
For a thorough testing process, multiple detailed test cases will be written for each functionality so any error or bug can be identified and fixed.
In the test case development case, a different kind of test cases known as ‘Smoke cases’ are also prepared which I will explain in a bit more detail in the next section. Along with this, at this stage you also identify the data you require to execute all the test cases.
|– Automation Feasibility and Requirement documents are required to start the test case development phase.|
|– Define the test scenarios and write test cases for each scenario|
– If automation testing is applicable, prepare test automation scripts
– Acquire test data needed to execute test cases.
|– A list of all the possible test cases including smoke test cases|
– Test data
– Test automation scripts
When test cases are developed, the software testing stages proceeds to the step of Test Environment setup.
Test Environment setup
Out of all the STLC phases, this is a particularly important phase of the entire software testing life cycle. It is important to ensure that the environment in which the software is being tested closely matches the environment in which the application will be used after deployment. For example, a banking application which will run on client’s server is to be tested, then for a successful testing process it is important to test the application in an environment which replicates the environment in which it will be used.
Environment consists of software and hardware that are required for the application to function. Environment usually comprises of servers, systems, database, operating systems etc.
A key step of this phase is what is referred to as “smoke” testing. Smoke test cases are positive test cases that are run to see if the software meets the build acceptance criteria. This basically means that they are executed to check that the software product is built stable enough to be tested. Since it is a non-exhaustive test, it only tests the main functionalities of a software product. For example, a smoke test for an online banking application would check if the login function of the app is working, if the interface is loading, if each clickable option on the homepage is working etc. Once it is established that the basic features are working only then a more exhaustive testing of the entire product can be completed in the next phase.
|Before beginning this phase the following should be available:|
– Test Data
– Test Plan
– Smoke Test cases
|Following are the steps that need to be performed at this stage:|
– Prepare a list of software required for the testing process.
– Prepare a list of hardware required for the testing process.
– Setup test environment.
– Once it is set up, execute the smoke test cases to ensure the built product and environment is stable enough to proceed with the test execution phase.
|– A fully-prepared test environment to proceed with the next phase|
– Result of smoke test cases
This step is the main crux of the entire STLC process. This is the stage where all the test cases that were developed are executed. There are two ways to of execution: manual and automatic.
In manual testing, a Q/A engineer manually performs the test cases and records the results. While for automated testing, test scripts are developed that are automatically run in an automated testing tool to check the results of each test case.
There are 3 possible results of test case execution: Passed, Failed, or Blocked.
Passed: A test case is passed when it is executed and the result is as per the required output. For example, in our login functionality example, when a correct email address and password is entered and the user is successfully logged in, it shows that the test case is passed. Or in other words, no bug is identified.
Failed: If an incorrect email and password was entered and the user was still able to log in, instead of being shown an error, it shows that the test case failed.
Blocked: A blocked test case is when a case execution fails due to some internal or external defects in the application.
For any test cases that are failed or blocked, they are reported back to the development team who fix the bug. Once it is fixed, it is retested to ensure that the functionality performs perfectly.
|For the Test Execution stage of a software testing life cycle, you require the following:|
– Test Plan
– List of test cases
– Test data
|– Execute the test cases as planned and record the result status.|
– For every bug reported in the testing process assign a bug ID
– Communicate the identified failed or blocked cases and retest once the defects are fixed.
– Prepare a detailed test execution report summarizing the results of test cases.
|– Test case execution report document|
Test Cycle closure
Test Cycle closure, as the name indicates, is the concluding stage of the software testing cycles. When the test execution stage is completed, as defined earlier, a closure report is prepared.
Closure report is a document which evaluates the entire process and all the phases of software testing. It evaluates the process on the basis of objectives, time, cost, coverage, and number of defects and bugs identified.
Testing is a process that can go on for multiple cycles, but to make sure that it is concluded an exit criteria is decided between the clients and the software engineers. Usually, this criteria can be something like when the 90% of the testing is bug free, or when there are less than 10% bugs reported, etc.
When a STLC process meets the exit criteria, it is concluded by preparing a closure report. Often after this, the product is sent for User Acceptance Testing (UAT) where the software is tested by the actual users who will be using the product in the long run. If any errors or bugs are overlooked by the engineers and are identified by the users they can be communicated to them to have it fixed.
|Following documents from the preceding documents will be required to begin this stage of the software testing life cycle:|
– A completed test case execution report
– A report on defected test cases
|Following activities will be performed at this stage:|
– Evaluate the testing cycle based on the predetermined exit criteria
– Prepare a document evaluating the Scope, Cost, Time, Quality, Critical defects of the testing cycle
– Prepare a list of improvements for future projects
|– Test Closure report|
Now That You Know What the Software Testing Life Cycle Is – Let’s Understand at What Stage of SDLC It Is Performed
As discussed previously, testing is an essential part of the software development process. But at what stage of the development cycle is testing performed? Well, the answer to this lies in differentiation between the kinds of testing.
Testing can be for two kinds, one which is for the purpose of verification and one for validation. This can also be understood as the concepts of Quality Assurance and Quality Control, respectively.
Validation or Quality Control of the software product is done only after it is developed. It is conducted on a completed or near-completed product to ensure that it performs flawlessly. In other words, the Test Execution phase of the STLC is a phase where the product is tested for Validation or Quality Control.
While, verification or Quality Assurance of the software product is performed throughout the development process, even before the product reaches a completed form. It is a process of evaluating work products at every step to make sure that they are bug-free and meet the software specification. It is performed parallel to the development life cycle phases.
Let’s recap everything discussed about what is STLC and its different phases of testing. Software testing life cycle is similar to how any other products are tested for quality before they reach end customers. As discussed previously this process involves 6 stages beginning from requirement analysis to closure.
In a world where we as users constantly demand applications and software for our needs, we remain connected to them 24/7 and some of our most important tasks are performed by them. We as users demand software products that perform perfectly, because let’s be honest, nobody likes an app full of bugs and glitches. Hence, all software products should pass through a rigorous STLC testing to make sure we as customers are satisfied with the performance quality.
Rate this article!
Average rating 5 / 5. Vote count: 2