How do all the bugs look like?
Isn’t it true, that totally different bugs in completely different systems under test belong in some way to the same class, type or category of bugs or to several but same classes, types or categories?
Can we derive a pattern to answer this question?
First, what’s the reason why asking such questions?
In my opinion it can be a good start to dive deeper into testing. It can be a way to help working out test scenarios or charters for exploratory testing sessions. It can improve test strategies. Or it can simple help to build knowledge about software testing in general or concerning system under test in particular.
I tried to answer such questions with following mind map:
The mind map is about 3 classes of software bugs.
- class 1: ‚Something is there which should not be there‘
- class 2: ‚Something is not there which should be there‘
- class 3: ‚It’s there but not as expected‘
I think in every type of software under test we can find at least these 3 classes or types of possible bugs.
examples for class 1: ‚Something is there which should not be there‘: example system under test crashes. This can happen for banking software, smarthpone app, webside and so on and so on.
examples for class 2: ‚Something is there which should not be there‘.
For example we can have missing GUI elements like buttons, text fields and so on in a display for a medical device as well as in a smartphone app.
examples for class 3: ‚It’s there but not as expected‘:
– That something is not translated can happen for a webside but also for a CAT program
when both are delivered to world wide customers.
– We can have performance problems in general when using the internet. But in
particular this can happen when using a certain web site. But we also can have
performance problems when using a clinical information system when using an interface
of a 3rd party product.
Of course: The mind map is not complete and might not fit in realy every context.
Also for some examples bugs can fit into several classes or types.
Maybee I also forgot some classes or types of bugs. I named only 3 classes. On the other side it also doesn’t make sense to look for ‚all‘ classes or types. This would be endless work and therefore senseles.
But I think the mind maps shows one thing: When we work with totally different kind of software and hardware we can find often the same types of bugs, can’t we?
And when we recognize this, I thing we have a good start point for getting ideas of how we can build test cases or how we can ‚explore‘ our individual system under test. My target is here to provide this as a general basic thinking of software testing – not more – not less.
Maybee in some context it’s a good idea to start exploratory testing with a charter named: ‚Test, that nothing unexpected will happen. (class 1 from mind map above)‘.
In some other context this doesn’t make sense, as a tester should keep everything in mind and not only one aspect when e. g. the target is to discover the ‚unknown unknowns‘