What are Defect, Fault & Failure?

What are Defect and Failure?

A defect is an error or a bug, in the application which is created. A programmer while designing and building the software can make mistakes or error. These mistakes or errors mean that there are flaws in the software. These are called defects.

When actual result deviates from the expected result while testing a software application or product then it results into a defect. Hence, any deviation from the specification mentioned in the product functional specification document is a defect. In different organizations it’s called differently like bug, issue, incidents or problem.

When the result of the software application or product does not meet with the end user expectations or the software requirements then it results into a Bug or Defect. These defects or bugs occur because of an error in logic or in coding which results into the failure or unpredicted or unanticipated results.

Defect Report

When a tester finds a bug or defect it’s required to convey the same to the developers. Thus they report bugs with the detail steps and are called as Bug Reports, issue report, problem report.

This Defect report or Bug report can contains:

  • This Defect report or Bug report consists of the following information:
  • Defect ID – Every bug or defect has it’s unique identification number
  • Defect Description – This includes the abstract of the issue.
  • Product Version – This includes the product version of the application in which the defect is found.
  • Detail Steps – This includes the detailed steps of the issue with the screenshots attached so that developers can recreate it.
  • Date Raised – This includes the Date when the bug is reported
  • Reported By – This includes the details of the tester who reported the bug like Name and ID
  • Status – This field includes the Status of the defect like New, Assigned, Open, Retest, Verification, Closed, Failed, Deferred, etc.
  • Fixed by – This field includes the details of the developer who fixed it like Name and ID
  • Date Closed – This includes the Date when the bug is closed
  • Severity – Based on the severity (Critical, Major or Minor) it tells us about impact of the defect or bug in the software application
  • Priority – Based on the Priority set (High/Medium/Low) the order of fixing the defect can be made. (Know more about Severity and Priority)

What's the difference between Severity & Priority

1) SEVERITY:

It is the extent to which the defect can affect the software. In other words it defines the impact that a given defect has on the system. For example: If an application or web page crashes when a remote link is clicked, in this case clicking the remote link by an user is rare but the impact of application crashing is severe. So the severity is high but priority is low.

Severity can be of following types:

Critical: The defect that results in the termination of the complete system or one or more component of the system and causes extensive corruption of the data. The failed function is unusable and there is no acceptable alternative method to achieve the required results then the severity will be stated as critical.

Major: The defect that results in the termination of the complete system or one or more component of the system and causes extensive corruption of the data. The failed function is unusable but there exists an acceptable alternative method to achieve the required results then the severity will be stated as major.

Moderate: The defect that does not result in the termination, but causes the system to produce incorrect, incomplete or inconsistent results then the severity will be stated as moderate.

Minor: The defect that does not result in the termination and does not damage the usability of the system and the desired results can be easily obtained by working around the defects then the severity is stated as minor.

Cosmetic: The defect that is related to the enhancement of the system where the changes are related to the look and field of the application then the severity is stated as cosmetic.


2) PRIORITY:

Priority defines the order in which we should resolve a defect. Should we fix it now, or can it wait? This priority status is set by the tester to the developer mentioning the time frame to fix the defect. If high priority is mentioned then the developer has to fix it at the earliest. The priority status is set based on the customer requirements. For example: If the company name is misspelled in the home page of the website, then the priority is high and severity is low to fix it.

Priority can be of following types:

Low: The defect is an irritant which should be repaired, but repair can be deferred until after more serious defect have been fixed.

Medium: The defect should be resolved in the normal course of development activities. It can wait until a new build or version is created.

High: The defect must be resolved as soon as possible because the defect is affecting the application or the product severely. The system cannot be used until the repair has been done.

What is a Failure in Software Testing?

If under certain environment and situation defects in the application or product get executed then the system will produce the wrong results causing a failure.

Not all defects result in failures, some may stay inactive in the code and we may never notice them. Example: Defects in dead code will never result in failures.

It is not just defects that give rise to failure. Failures can also be caused because of the other reasons also like below.

Other reasons that could cause Failure!

  • Because of the environmental conditions as well like a radiation burst, a strong magnetic field, electronic field or pollution could cause faults in hardware or firmware. Those faults might prevent or change the execution of software.
  • Failures may also arise because of human error in interacting with the software, perhaps a wrong input value being entered or an output being misinterpreted.
  • Finally failures may also be caused by someone deliberately trying to cause a failure in the system.

Difference between Error, Defect and Failure:

  • Error: The mistakes made by programmer is known as an ‘Error’. This could happen because of the following reasons: i) Because of some confusion in understanding the functionality of the software, ii) Because of some miscalculation of the values and iii) Because of misinterpretation of any value, etc.
  • Defect: The bugs introduced by programmer inside the code are known as a defect. This can happen because of some programatical mistakes.
  • Failure: If under certain circumstances these defects get executed by the tester during the testing then it results into the failure which is known as software failure.

Few points that are important to know:

  • When tester is executing a test he/she may observe some difference in the behavior of the feature or functionality, but this not because of the failure. This may happen because of the wrong test data entered, tester may not be aware of the feature or functionality or because of the bad environment. Because of these reasons incidents are reported. They are known as incident report. The condition or situation which requires further analysis or clarification is known as incident. To deal with the incidents the programmer need to to the analysis that whether this incident has occurred because of the failure or not.
  • It’s not necessary that defects or bugs introduced in the product are only by the software. To understand it further let’s take an example. A bug or defect can also be introduced by a business analyst. Defects present in the specifications like requirements specification and design specifications can be detected during the reviews. When the defect or bug is caught during the review cannot result into failure because the software has not yet been executed.
  • These defects or bugs are reported not to blame the developers or any people but to judge the quality of the product. The quality of product is of utmost importance. To gain the confidence of the customers it’s very important to deliver the quality product on time.