Overview

In this tutorial, we will look at the differences between Error, Fault, and Failure. These are often misunderstood by beginners in Software Testing.

Error/Mistake

To Err is Human.

An Error is a human action or mistake when developing/using or operating a system or the software application. Human errors and mistakes introduce or inject faults into the system.

An Error is an action that produces an incorrect result. An incorrect human action resulting in faults being injected into the software program.  Examples misinterpretations, omissions , etc.

A discrepancy between a computed, observed or measured value/condition and the true specified or theoretically correct value/condition.

Fault

Fault is adjudged or hypothesized cause of System Error. An incorrect step, process, or data definition in a software application. System error is a system state that is liable to lead to failure.

Failures are caused by faults in the application. Therefore, it refers to an underlying condition within the software application that causes failures to occur.

Note: A high-level picture that doesn’t take system error into consideration.

Failure

The inability of the program to perform its required activity. As a result, the product is not able to perform the activity according to its specification. Failures refer to a behavioral deviation from the user requirement or the product specification. It is a deviation of the delivered service from compliance with the specification.

The flow

An error characterizes a particular state of a system, a failure is a particular event namely the transition from correct service delivery to incorrect service. An error may cause a fault to be injected into the application, and a fault may cause failure when the application is executed.

A single error may cause many faults. For example, a wrong algorithm is applied in multiple modules of the system and that causes multiple faults in the system. Similarly, a single fault may cause many failures in repeated executions. A faulty system would fail many times in repeated executions until the problem is fixed or patched. 

On the other hand, the same failure may be caused by several faults. For example, an interface or interaction failure involving multiple faulty modules.