Human beings are prone to mistakes because of in-attention, incorrect assumptions, carelessness, or inadequate system knowledge. This very nature of humans makes software vulnerable to bugs, defects, and errors (we will get to know these terms in detail in later posts). To prevent and correct these issues, we need testing.
Traditionally software testing was done in a single phase, and that too only once the implementation or coding used to get completed. But the increasing complexity of software applications led to the evolution of testing.
So testing techniques have evolved over time, and testing activities are not confined to a single phase. Instead, these were integrated with the different phases of the software development life cycle.
In this blog post, we will walk you through the nitty-gritty of software testing.
What is Software Testing?
Software testing is the process of evaluating a system with the intent of finding bugs. It is performed to check if the system satisfies its specified requirements and quality standards. It evaluates the system to validate its functionality.
Testing measures the system’s overall quality in terms of correctness, completeness, usability, performance, and other functional and non-functional attributes.
Software testing is not associated with uncovering potential bugs or defects. It also involves finding measures to improve the system’s efficiency and accuracy.
Basically, software testing is an amalgamation of verification and validation.
- Verification is a static process that does not involve code execution. It validates the documents, design, and code against specified requirements and answers the question – “Are we building the product right?”.
- Validation is a dynamic process that involves code execution. It checks software for its reliability, usability, and functionality. It answers the question – “Are we building the right product?”.
Why is Software Testing Important?
Software Testing is an indispensable activity in SDLC because it uncovers any bugs or errors early that can be addressed before releasing the system to the market.
The following are some significant reasons stating the importance of software testing:
- It provides assurance to the stakeholders that the product works as intended.
- Delivering an untested product with avoidable defects to the end-user/customer leaves a bad reputation for the development company.
- The separate testing phase adds a confidence factor to the stakeholders regarding the quality of the software under development.
- Defects detected in the earlier phase of SDLC result in lesser cost and resource utilization for defect resolution.
- The testing team adds another dimension to software development by providing a different viewpoint to the product development process.
- An untested software not only makes software error-prone but also costs the customer business failure, like in the case of Microsoft’s MP3 player – Zune’s crash.
- Software issues can cost lives. E.g., in the case of Therac 25, many people died due to concurrent programming errors wherein patients were given radiation doses that were hundreds of times greater than normal, resulting in death or serious injury.
The following are some real-world examples stating the importance of software testing where bugs or errors proved expensive and life-threatening.
- Starbucks’ POS system had glitches. Hence, 60% of stores in the United States and Canada were closed. For some time, the store even served coffee for free, as customers were not able to perform transactions.
- In 2015, a fighter plane F-35 had bugs that made it unable to detect targets correctly.
- Due to a small software bug, China Airlines Airbus A300 crashed, in which 264 innocents lost their lives.
- The costliest accident in history was a software bug in a military satellite launch. It cost $1.2 billion.
- A software bug at a major US bank resulted in the credit of 920 million US dollars to 823 customers.
Who Conducts Software Testing?
Testing is/can be done by all technical and non-technical people associated with software development. As testing is not a single process and a series of phases, the following are people associated with it in different phases:
- Developer – Developers perform unit testing of the software and ensure that the individual modules or components work correctly.
- Testers – Testers are the face of software testing. A tester verifies the application’s functionality as a functional tester, checks its performance as a performance tester, automates the functional test cases, and creates test scripts as an automation tester.
- Test Managers/Lead/Architects – They develop and define the test strategy and test plan documents.
End Users – A group of end-users does the User Acceptance Testing (UAT) to ensure the software is ready to release to the real world.
How is Software Testing done?
Testing can be done both manually as well as using automation tools.
- Manual Testing – When performed manually, it is called Manual Testing. It includes requirements verification, development of test strategy and plan, test case preparation, test case execution, defect creation, defect retesting, and finally, test report sharing with all the relevant stakeholders.
Testers do all these, put their legs into end-users shoes, and test the application to detect its unusual behavior. Manual testing involves unit, integration, system, and acceptance testing.
- Automation Testing – When automated tools are used, it is called Automation testing. It includes test script preparation and test report generation using different tools like – Selenium, Katalon Studio, QTP, etc.
In this type of testing, rerunning test scenarios is quick and easy. It increases test coverage, improves accuracy, and significantly saves time and money compared to manual testing.
Some other types of software testing include functional and non-functional.
|Functional Testing||Unit testing|
|Non-Functional Testing||Performance testing|
Levels of Software Testing
There are four levels of software testing, as follows-
- Unit Testing: It is the first level of testing that involves validating every individual component or module of a software product for its correctness and functionality. Each module is tested in isolation.
- Integration Testing: This level involves combining unit-tested components and testing them as a group. It uncovers any inconsistencies between the integration of components.
- System Testing: This testing level tests the system as a whole to ensure it meets quality standards and specified requirements.
- Acceptance Testing: It involves validating the system for its acceptability.
When do we start Software Testing?
Based on the software project and the selection of a specific SDLC model, the testing activities can be performed in the different phases of the software life cycle.
There is a misconception that testing is done only when some part of the software is built. However, testing can (should) be started even before a single line of code is written. It can be done in parallel with the development phase, e.g., in the case of the V Model, development and testing activities are integrated.
|Development Phase||Testing Activity|
|Requirement Design||Acceptance test creation|
|Functional Specification||Functional test case creation|
|Implementation||Unit test case creation|
|Code Complete||Test case execution|
When to Stop Testing?
This question – “When to stop testing” or “How much testing is enough” is very tricky to answer as we can never be sure the system is 100% bug-free. But still, some markers help us in determining the closure of the testing phase of the software development life cycle.
- Sufficient pass percentage – Depending on the system, testing can be stopped when an agreed-upon test case pass percentage is reached.
- After a successful test case execution – The testing phase can be stopped when one complete cycle of test cases is executed after the last known bug fix.
- On meeting deadlines – Testing can be stopped after deadlines get met with no high-priority issues left in the system.
- Mean Time Between Failure (MTBF) – MTBF is the time interval between two inherent failures. Based on the different stakeholder’s decisions, if the MTBF is large, one can stop the testing.
So, this was all about an introduction to software testing. It is an integral phase in software development, which ensures the delivery of defect-free and high-quality software. Its major goal is to uncover all possible errors and bugs in the software and address them immediately. In addition, it takes care of validating the software’s efficiency, functionality, and usability. Hence, putting a software product under rigorous testing is essential to ensure its quality and correct functioning.