Error guessing in software testing is one of the most common experienced-based techniques used across projects. In this tutorial, we will learn in detail about these topics:
- What is Error guessing technique?
- How to apply the Error guessing technique?
- When to use error guessing?
- Pitfalls of error guessing technique
What is Error guessing technique?
Error guessing is a technique that makes use of testers’ skills, intuition, and experience to anticipate the occurrence of errors, defects, and failures that may not be easily captured by formal techniques like Boundary Value Analysis and Equivalence partitioning.
This technique is unstructured, which means there is no math behind it. If multiple testers apply this technique to the same application, they might end up with different test cases. The test cases might reflect the experience of the tester with similar applications and his domain expertise.
A methodical approach to the error guessing technique is to create a list of possible errors, defects, and failures, and then design tests that will cover this list.
How to apply the Error guessing technique?
Error guessing depends on testers’ experience with the below considerations:
How the application has worked in the past?
A tester who has worked on the same application is best for the error guessing technique. He would have a good understanding of how the application has worked in previous releases. For e.g. it’s likely that a particular area of application has always been buggy, and hence additional testing is required. The tester can apply error guessing here, while stable areas call for only formal techniques.
What kind of errors tend to be made?
Every application has a history, which is based on the people that are working on it, and also the functionality or integration points that the application has. An experienced tester would know the type of errors that have occurred in the past. E.g. there is an e-commerce application where the discount logic has often failed with the application of a random discount code. In such cases, the tester will try different combinations of valid and invalid discounts and see that the logic is working fine. This insight comes only when the tester has enough experience in the application to know the historical issues.
What are the Failures that have occurred in other applications?
An experienced tester would not only rely on the current application but also make use of his experience in testing similar applications. In some cases, the requirements themselves may not be enough, or the application is new so there is no historical data available. In such cases, the tester will have to rely on the domain experience.
Let’s understand this with the help of a simple example:
Consider a scenario where you are testing the functionality of funds transfer in a banking application. There is a field where you need to enter the amount. The requirements say that you can transfer any amount between 100 and 100000
If you apply standard techniques of Boundary value analysis and Equivalence Partitioning, you may come up with the below validations:
99, 100, 101, 500000, 99999, 100000, 100001.
However, an experienced tester has seen that a few of the similar applications have not handled the cases with a negative value. He would use this experience to create error-guessing scenarios for the current application
When to use the Error guessing technique in software testing?
We should always remember that error guessing is not a substitute for formal techniques. Wherever possible, we should use it in addition to formal techniques and only when the tester has past experience on similar applications.
Error guessing will be effective when-
- Tester has got good experience with the same/similar applications.
- There is enough data on historical behavior and failure of the application in past
- The requirements are inappropriate and formal techniques are difficult to apply.
- The application or functionality is business-critical, and there is a case to put more testing efforts by applying error guessing in addition to formal techniques.
Some of the defects found in error guessing are usually a result of exhaustive testing on the application. However, the tester has seen such issues in past and he can use his experience to come up with such scenarios without running the exhaustive tests again. This would save a lot of time and still find some quality edge case defects.
Pitfalls of Error Guessing technique
Similar to any unstructured approach, the error guessing technique is dependent on the testers’ intuition and experience. Lack of experience can enforce the failure of this technique. This is especially riskier in cases where requirements are not very clear, or product knowledge is not enough. Then it’s important to make sure that the testers on the project have got enough domain knowledge and experience on similar applications. If the testers are not experienced, they would create error scenarios that may not be relevant, and this would result in poor quality of testing.
