All humans make mistakes—even web app developers, mobile app developers, and other software developers. Sometimes, the mistakes software developers make are entirely inconsequential and easy to overlook, being minor annoyances at worse. Unfortunately, some mistakes have much bigger consequences and can even put people’s lives at risk.
During the last few decades, the software testing industry has advanced by leaps and bounds to ensure that software applications run without any failures. This article explains what modern software testing involves, describing in detail each stage of the software testing life cycle (STLC).
What is software testing?
Techopedia defines software testing as “a set of processes aimed at investigating, evaluating and ascertaining the completeness and quality of computer software. Software testing ensures the compliance of a software product in relation with regulatory, business, technical, functional, and user requirements.”
In other words, software testing checks whether a software application:
- Meets all technical and business specifications
- Is free of any obvious bugs that affect its performance or functionality
- Doesn’t exhibit any usability, compatibility, security, or installation issues.
Broadly speaking, software testing can be either manual or automated. In manual software testing, test cases (more about them later in this article) are executed manually. In automated software testing, test cases are executed using various automation testing tools, which bring many benefits to software testing, such as improved reliability, faster test case execution, and great reusability. However, automated testing isn’t suited for all types of testing, especially those that require the tester’s experience, knowledge, analytical skills, intuition, and creativity.
Software testing, both manual and automated, has many benefits, some of which are more obvious than others:
- Saves money: An undetected bug in a critical system can cost the organization that relies on the system far more money than what it would cost to ensure the system didn’t contain any bugs before its deployment.
- Increases profit: Software development companies that assign software testing a high priority quickly rise through the ranks and gain access to customers who prefer quality over quantity and are willing to pay for it. What’s more, software developers enjoy producing high-quality software much more than spending their days hastily writing software they know is going to be buggy and hard to use.
- Improves customer satisfaction: Most customers understand that software development is an iterative process that goes through defined stages and sometimes many revisions. But just because customers typically don’t expect perfection on the first try doesn’t mean that it’s not worth doing everything possible to serve quality software that works according to technical and business requirements.
- Leads to better user experience: These days software needs to be both functional and usable. Only software testing can assure great user experience and remove all critical bugs, errors, and design flaws that would otherwise be a source of dissatisfaction.
- Ensures reliability: In many industries, the cost of unreliable software can be enormous. This includes healthcare, finance, or automotive, just to give three examples. With the help of software testing, it’s possible to increase the reliability of software to meet any technical and industry standard.
- Cuts maintenance costs: While software testing is an additional expense, the potential reduction in maintenance costs makes it well worth it. Generally, it’s much easier and cheaper to fix a bug before the software application has been deployed than after.
- Inspires confidence: The launch of any software application is a stressful occasion because there are many things that can go wrong. Software testing can increase everyone’s confidence in the software application by minimizing the chance the application will produce a fail state.
Now that we’ve explained the benefits of software testing and its importance, let’s take a closer look at the software testing life cycle to learn more about the six stages of testing.
What is the software testing life cycle (STLC)?
The word “life cycle” is defined as a series of stages through which something (such as an individual, culture, or manufactured product) passes during its lifetime. When we talk about software testing life cycle, or STLC for short, we mean the sequence of activities carried out by the testing team to ensure maximum results from software testing.
The stages of software testing life cycle include:
- Requirement Analysis
- Test Planning
- Test Case Development
- Test Environment Setup
- Test Execution
- Test Cycle Closure
Each of these six stages has certain entry and exit criteria, which specify the minimum set of conditions that should be met before starting the software testing and the minimum set of conditions that should be completed in order to stop the software testing, respectively. Of course, things don’t always go exactly according to plan in the real world, and it’s fairly common to move to the next stage without meeting all exit criteria for the previous stage.
Stage 1: Requirement analysis
The first stage of STLC is requirement analysis. The main objective of this stage is to understand what needs to be tested and figure out the testable requirements. The different types of requirements include business requirements, architectural and design requirements, and system and integration requirements. If the testing team struggles to understand any particular requirement, it can ask various stakeholders, such as business analysts, to clarify them. The testing team will then prepare RTM (Requirement Traceability Matrix), which is a document that maps and traces user requirements with test cases. If applicable, the testing team will also prepare an automation feasibility report.
Entry Criteria: available requirements document, defined acceptance criteria, available application architectural document
Exit Criteria: signed off RTM (Requirement Traceability Matrix), test automation feasibility report signed off by the client
Stage 2: Test planning
The second stage of software testing life cycle is test planning. During this stage, all of the testing strategy is defined, and the test manager determines the effort and cost estimates for the entire project. The effort and cost of testing largely depend on which testing types will be covered and which will be ignored. The commonly used testing types include unit testing, API testing, integration testing, system testing, sanity testing, smoke testing, install/uninstall testing, interface testing, regression testing, and agile testing. Each testing type has its distinct characteristics and applications, and testers need to be familiar with them to be able to sort them according to priority.
Entry Criteria: requirements documents, requirement traceability matrix, test automation feasibility document
Exit Criteria: approved test plan/strategy document, signed off effort estimation document
Stage 3: Test case development
The third stage of STLC is test case development. As its name suggests, the main purpose of this stage is to create detailed test cases and prepare data for testing. A test case specifies the inputs, execution conditions, testing procedure, and expected results that define a single test to be executed in order to achieve a particular software testing objective. Opinions vary on how exactly test cases should be created, but it’s always important to make them simple, transparent, and unique. All software requirements should be 100% covered, which can be ensured with the help of RTM. If automation testing is to be used, this is the time to produce automation testing scripts.
Entry Criteria: requirements documents, RTM and test plan, automation analysis report
Exit Criteria: reviewed and signed test cases/scripts, reviewed and signed test data
Stage 4: Environment setup
The fourth stage of STLC is environment setup. Even though this stage can be very time-consuming, it’s absolutely critical because it enables the testing team to efficiently execute test cases. There are many software tools and hardware devices that can be used for software testing, including Selenium, Katalon Studio, TestComplete, Appium, or Ranorex. Not all tests are executed on local machines, so it may be necessary to establish a test server that can support the tested software application. A smoke test (a preliminary test conducted to reveal simple errors of key functionalities, before passing software on to the quality assurance team for detailed inspection) is performed to confirm the readiness of the testing environment. While this stage can be done in parallel with the previous stage, it’s usually better to do them in order.
Entry Criteria: available system design and architecture documents, available environment setup plan
Exit Criteria: environment setup is working as per the plan and checklist, complete test data setup, successful smoke test
Stage 5: Test execution
The fifth stage of STLC is test execution. With the testing environment ready, it’s time to carry out the testing based on the test plans and the test cases prepared in Stage 2 and Stage 3. Test cases that execute successfully are marked as “passed”, while test cases that fail are marked as “failed” and reported to software developers for further analysis. If a test case is impossible to execute due to some defect, it should be marked as “blocked”. When the test case is unblocked, it should be marked as “not run”. After executing all test cases, the test team will produce a test execution report and possibly even detailed reports for individual test cases.
Entry Criteria: baselined RTM, test plan, test case/scripts are available, test environment is ready, completed test data setup, available unit/integration test report for the build to be tested
Exit Criteria: all tests planned are executed, defects logged and tracked to closure
Stage 6: Test cycle closure
The sixth and final stage of STLC is test cycle closure. This stage involves the testing meeting to evaluate known issues and code quality defects, discuss the completion of the software testing life cycle based on time, test coverage, cost, critical business objectives, quality, and other factors, and identify various bottlenecks that should be eliminated to increase the efficiency of future testing. Finally, a test closure report is prepared by the testing team and signed off by the client.
Entry Criteria: completed testing, available test results, available defect logs
Exit Criteria: test closure report signed off by the client
The software testing life cycle can be described as a systematic and sequential way of conducting software testing. It consists of six distinct stages: requirement analysis, test planning, test case development, test environment setup, test execution, and test cycle closure. Each of these six stages has certain entry and exit criteria, which govern when software testers can move to the next stage. When done right, software testing can save money, increase profit, improve customer satisfaction, ensure reliability, cut maintenance costs, and inspire confidence, making it a critically important part of modern software development.