Decoding the Goal of Software Testing
In today’s world of digital solutions, the importance of software testing is really high.
At its core, software testing is not just a phase in the development process. It’s a vital strategy that determines the success and reliability of any software.
But what makes this activity so important, and why do we need it in software development?
Why testing is needed and what do software testers do?
Let’s start by considering why testing is needed.
Testing is necessary because we all make mistakes. Some of those mistakes can be less important, but some of them are expensive or even dangerous.
So,
The goal of a software tester is to find bugs.
Moreover, the tester should think about how to find them sooner in the development process, thus making them cheaper to fix.
The goal of a software tester is to find bugs AND find them as early as possible.
But, finding bugs, even finding them early, is not enough. Software testers should strive for software perfection.
The goal of a software tester is to find bugs, find them as early as possible, AND make sure they get fixed.
Testers are looking for bugs in order to make them fixed.
Eventually, the majority of bugs will be fixed, and the software quality gets improved.
This is the real purpose of software testing.
Let’s discuss key aspects of testing definition that affect its effectiveness.
Testing definition
One of the reasons for poor testing is a false understanding of its idea, something like: “Testing is …”
“…making sure that there are no bugs” or
“… establishing confidence that software does what it is supposed to do” or
“…showing that software performs its functions correctly”
And we may run across product teams who just want their testers to confirm that the software works.
This is the wrong approach.
Although this may sound like a subtle semantics, it’s really an important distinction.
If our goal is to demonstrate that software has no bugs, then we will subconsciously head to this goal. So we tend to select test data that have a lower probability of causing issues.
On the other hand, if our goal is to demonstrate that software has bugs, our test data will have a higher probability of catching issues. And this approach is adding more value to the software.
Thus, we shouldn’t test software to show that it works, we should start with an assumption that software contains bugs (and this is a valid assumption for almost any program) and then test software to find as many bugs as possible.
Thus, a more appropriate definition is this:
Testing is a process of executing software with the intent to find bugs.
“Successful” and “unsuccessful” testing
There is a false understanding of “successful” and “unsuccessful” in terms of testing: a passed test is called a “successful” and a failed test that found a new bug is commonly called “unsuccessful”.
This is an upside-down understanding.
Test case is “successful” when it catches a bug and when it establishes that no more bugs are to be found.
Test case that found no bugs can be considered “unsuccessful” since the bug-free software concept is basically unrealistic.
This concept is well-described by Meyers:
Consider the analogy of a person visiting a doctor because of feeling unwell.
If the doctor runs some laboratory tests that do not locate the problem, we do not call the laboratory tests “successful”. They were unsuccessful, because they cost expensive laboratory fees, and the patient is still ill, and the patient may question the doctor’s expertise.
However, if a laboratory test determines the issue, the test is successful because the doctor can now begin the appropriate treatment.
Hence, the medical profession seems to use these words in the proper sense. The analogy, of course, is that we should think of the program we start testing, as the sick patient.
Conclusions
To summarise, testing is a destructive process of trying to find bugs (whose presence is assumed) in a program.
Testing is necessary during the software development process to identify defects, fix them, and increase the overall software quality.
