Code Detective – Bug Report

You have a new case. You need to find what’s wrong, and to find it, you need to know what you’re looking for.

You might think we’re talking about a detective, but we’re talking about a tester. For the tester to recognize the bug, he must know every characteristic of the bug.

Let’s try to differentiate them.

Types of bugs

Functional Bug

The tester must uncover these bugs while examining the system’s functions and testing if everything does what it’s supposed to be doing.

If the function does something not on the requirements list, it’s a bug.

Examples:

• • • search doesn’t react to user input;
    • app crashes;
    • a button doesn’t submit a form;
    • a button opens a window it’s not supposed to open.

In the case where there are no functional requirements, this type of bug is harder to find. Previous experience with similar software can be of great help, and you could also try exploratory testing.

Localization Bug

Localization bugs can only be found in software that supports several languages or is adapted for use in different time zones.

Start by checking if different languages work equally well. Check all elements of the system to see if they are correctly translated. You should change the default language and examine all aspects. If something is not translated correctly or at all – it’s a bug.

At this stage, you can also check for UI bugs. If the text is longer in a different language, it could extend over the UI or break it.

Depending on the software, you could check if the time is displayed correctly or if the currency change is working fine.

User Interface Bug

This should be an easy job if you have all the mockups of the software screens. Just compare the software with the mockups;;;; if anything is out of place – that’s a bug. It also helps if you have design guidelines. Usually, the guidelines describe styles and elements in different states.

Example: The color of a link in the initial state, on hover, and after a click.

You should not worry if there is no documentation to help. You should find most of the UI bugs by just checking the software:

• • • overlapping elements;
    • broken layout;
    • elements that are off the place;
    • missing elements;
    • text coming out of a block.

Usability Bug

Usability bugs need special attention because if software doesn’t offer a comfortable experience, nobody will like it and use it.

Example of usability bugs:

• • • buttons with unclear functions – no clear button name or icon, no hints;
    • poorly chosen colors – when you can’t see the text clearly;
    • when the user can’t find a button.

System Update Bug

Modern software relies on system updates. Containing new functions and bug fixes, system updates can also have some bugs that are pretty hard to find. The most common ones result in a user losing all the settings or being logged off.

Rapid Fire Bugs

Heisenbug is a bug that seems to disappear or alter its behavior when one attempts to study it.

Bohrbug is a bug that appears under the same conditions each time, but it’s nearly impossible to trace back the whole set of events to find the issue’s core.

Mandelbug is a bug whose causes are so complex that that that that it defies repair or makes its behavior appear chaotic or non-deterministic.

Schrödinbug is a bug that manifests itself in running software after a programmer notices that the code should never have worked in the first place.

Hindenburg is a bug with destructive behavior.

Higgs-bugson is a bug predicted to exist based upon other observed conditions but is difficult, if not impossible, to reproduce in a development or test environment artificially.