Any software tester knowingly or unknowingly does it!
While testing, if a tester comes across a bug, as a general
practice, tester registers that bug with the programmer. Along with
registering the bug, tester also tries to make it sure that he/she has
understood the scenario and functionality properly and can reproduce
the bug condition. Once programmer fixes the bug, tester runs a test
case with the same scenario replication in which the bug had occurred
previously. If tester finds that the bug is fixed, he/she again tries
to find out if the fix can handle any such same type of scenario with
different inputs.
For an example, lets consider that a tester finds a bug related to
an input text field on a form, where the field is supposed to accept
any digit other than the digits from 1 to 100, which it fails to and
accepts the number 100. Tester logs this bug to the programmer and now
is waiting for the fix. Once programmer fixes the bug, it sends it
across to the tester so as to get it tested. Tester now will try to
test the bug with same input value (100: as he/she had found that this
condition causes application to fail) in the field. If application
rejects the number (100) entered by the tester, he/she can safely close
the defect.
Now, along with the above given test input value, which had
revealed the bug, tester tries to check if there is any other value
from this set (0 to 100), which can cause the application to fail.
He/she may try to enter values from 0 to 100, or may be some characters
or a combination of character and numbers in any order. All these test
cases are thought by the tester as a variation of the type of value
he/she had entered previously and represent only one test scenario.
This testing is called exploratory testing, as the tester tried to
explore and find out the possibility of revealing a bug by using any
possible way.
|