Introduction to Error Guessing Technique
Error guessing technique is a well-known software technique where test engineer guesses and try to break the software code.
As this is advanced thinking(proactive), it needs lots of prior experience either on code or domain. To simulate the error path tester needs to have skills also.
Error guessing technique is very popular under the black-box technique as there is no straight forward process defined, it is also considered as an unstructured approach to testing an application.
Error Guessing is not in itself a testing technique but rather a skill that can be applied to all of the other testing techniques to produce more effective tests (i. e, tests that find defects).
Error guessing technique is a black-box testing technique. The bug, defect and failure test can be further used to create an input for a systematic approach of testing. This is otherwise known as fault attack.
Error Guessing is the ability to find errors or defects in the AUT by what appears to be intuition. In fact, testers who are effective at error guessing actually use a range of techniques, including:
- Knowledge about the AUT, such as the design method or implementation technology
- Knowledge of the results of any earlier testing phases (particularly important in Regression Testing)
- Experience of testing similar or related systems (and knowing where defects have arisen previously in those systems)
- Knowledge of typical implementation errors (such as division by zero errors)
- General testing rules of thumb of heuristics.
Error guessing is a skill that is well worth cultivating since it can make testing much more effective and efficient – two extremely important goals in the testing process. Typically, the skill of Error Guessing comes with experience with the technology and the project.
Error Guessing is the art of guessing where errors can be hidden. There are no specific tools and techniques for this, but you can write test cases depending on the situation: Either when reading the functional documents or when you are testing and find an error that you have not documented.
As I said the success of finding defects can greatly vary with the skills and experience of the test engineers.
How to write test cases for error guessing technique?
There are two different ways to perform error guessing.
- First, try & then write the steps.
- First think, write the steps & finally try.
But for both the approaches, it requires lots of skills and prior experience.
The main ideas behind the error guessing technique are-
- test the assumption that is made during the creation.
- Test the error-prone areas of the application by a list of likely defects or error-prone situations.
Scenarios where error guess of technique works best?
Error guessing technique is also experience-based testing. Error guessing technique is more of an art of testing than depending on document-based testing. As a result, it stresses more a logical and analytical of the testing and free from any dependency.
Make sure the following points whole uptaking error guessing technique:
- You must have a test model and strategies.
- You are well aware of the proceeding, underlying techniques.
- Consistent test strategies apart from error guessing technique.
- Possible to change the testing strategies awing execution of the testing activity.
Error guessing is actually is a strategy to attach the faults. Error guessing is different from random testing. Random testing is also another black box testing strategy when testers select the test cases in random order. pseudo-random test case picking algorithm can be used. But mostly this technique is used for non-functional testing of attributes(covers reliability and performed).
- Guess and test the behaviour of the application when we enter/submit button without providing the details.
- Check the file upload functionality by providing greater sized file than the allowed one.
- Check the null pointer exception.
- Check application functionality with providing invalid parameters.
- Check the functionality of the code by providing blank values in text files.
- Check the divide by zero functionality.
- In case the specifications or proper requirements are not available.
- In case the specifications or requirements are not enough.
- In case testers are short of time.
Error-prone situation testing by error guessing
- Initialization of data to test the sanity of the test data.
- Data mismatch/wrong type of data insertion.
- Handling of unexpected data.
- Test how error management occurs in an application.
- Test if proper calculation happens in an application with several data inputs.
- Test if proper recovery happens in an application.
- Test if the application can handle the concurrent process.
- test if the application can support proper events in case of an event driver application.
Purpose of error guessing technique
- The primary purpose of this type of testing is to try out luck in a certain area by proper guessing about the technologies and its loopholes. The mainstream testing can not detect these errors.
- By applying this technique, test engineers can test the corner cases of the application. hence no areas of the code are skipped.
- By this technique, test coverage of the application becomes higher without creating redundant tests.
- This testing technique compliments the boundary value testing and equivalence partitioning technique.
The factors that influence to create better error guessing technique-
There is no common documented way or test design for this type of testing. This is why termed as error guessing. However, almost every tester follow a checklist. Error guessing technique can be applied during the specification phase and during the test execution phase.
During error guessing technique, testers try to break the finite state machine and try to decode the encoded and hidden errors. Testers also check the intersections of the internal boundaries.
- Knowledge about the application in depth.
- Knowing the test coverage by traditional testing.
- Knowing the test rules.
- Excellent insight in managing test data.
- Availability of risk factors and risk reports.
- Understanding of historical test report.
- Understanding of application UI.
- Has adequate knowledge about production tickets/production bugs.
- Knowledge about historical bug related information.
- Learning curve from historical releases and applying those learning.
- Tester’s skill, intuition, the sixth sense.
- Through the understanding of the review checklist.
- Upgrade the memory of test engineer-like -existing buy list and Interesting error types from prior experience.
- Upgrades technical ability- Upgrade testers understanding QS, DB, WEB SERVER along with the coding application.
- Check out other things not only application-
- Broken requirements
- Broken design
- Broken code
- Broken build
- Broken testing
- Broken usage
When we should perform error guessing?
Error guessing can be performed by expert and senior tester s in parallel to functional and automation testing. As it is an Adhoc process, it is not well structured and there is no well-defined procedure to this process.it is always better to perform on the error-prone of areas of the application. Tests need to be creative.
Assume that are have a login, the formal testing will cover using some positive and negative scenarios. The error guessing technique can be applied to figure out-
- What happens if the user tries with SQL injection code?
- What happens if the user does not provide the password incorrect format.
- What happens if the user gives something(like x/0) which may cause null pointer exception.
In case of mobile testing, the mobile dial pad accepts 10 digits to dial a number.
The error guessing technique can be applied to figure out-
- What if the users insert characters into dial pad?
- What if the user inputs less than or greater than 10 digits?
- What if the user does not insert any value and try to dial?
The steps of error guessing technique are
Identification of test scenarios:
During this phase test specialist finds out the error or weak part of the application.
Things to take care:
- rare situations like –exceptional conditions and scenarios .graphical user interface processing, business or domain processing.
- Fault handling mechanism of the application-interrupting a process unexpectedly or test any chain interruption process.
- Bad input- like empty fields, very large value, exceeding condition, negative amount, long use of zeros.
- Combinations- untested date condition like insert 31 value of a month which ends on 30th day, leap year checking.
- The sequence of the transaction – change-cancel,change-cancel for an infinite number in a sequential way.
- Do something that is resource-intensive.
Create a logical test set:
In this step, testers create a logical test set to cover the complex part of the application.
Create a physical test case:
In this step, testers create a physical test case test document of the outcome of testing.
Execute the test:
In this phase, the testers determine the starting point and execute the physical test cases.
Major tests creation process:
- Decision table test
- Data combination test
- Data cycle test
- Elementary comparison test
- Proper error guessing
- Exploratory test
- Process cycle test
- Real-life test
- Semantic test
- Syntactic test
- Use case test
Difference between error guessing & exploratory testing:
|Error Gussing Technique||Exploratory Testing|
|It employs basic and advanced testing technique.||It employees only basic technique.|
|Suitable for experienced testers, users or admins.||Suitable for normal testers with basic testing skills.|
|No prior test case design process, test cases are written during the specification phase or during test case execution.||Test cases are written only during test execution.|
|Mainly targets assumptions, exceptions and difficult situations.||Mainly target overall testing, like GUI, web service etc.|
|Not at all systematic, not coverage oriented.||Somewhat systematic.|
Advantages of error guessing technique
- Very effective to find an error in the application in conjunction with the formal test process.
- Can detect errors which otherwise impossible to uncover by using formal tests.
- It can complement formal test design techniques.
- very helpful to uncover defects in error-prone areas the application.
Disadvantages of error guessing technique:
- Only experienced and skilled tests can perform.
- This technique does not guarantee the quality benchmark of the application.
- Focal short come of the technique-it is controlled by a knowledgeable person only.
- Error detection rate is very low- with respect to the efforts spent hence the ROI is significantly low.
A fully(100%) error-free software can not be made and at the same time, we can not test the system exhaustively. By using the Error guessing technique, testers experience can quickly identify and uncover some critical bugs. Practising and understanding the domain, application,
programme uncover more defects. An experienced and professional can smell the effect a critical piece of application. Some experts argue that error guessing is not a valid testing technique as it always depends on expert testers.
As per Cem Kaner “for reasons that you can’t logically describe you may support that a certain class of tests will crash the program, trust your judgement and include the test.”
Error guessing technique is no doubt one of the key technique is of testing that can potentially uncover many defects. for great results, we must include this technique with our regular testing techniques. In short, in this technique tester does not skip any problematic areas of the application. This is the main purpose of the Error Guessing technique. And finally, Error guessing technique should be used as a ‘mopping-up’ way to complement traditional way testing.