During the execution of the software program in certain situations, if the system produces wrong results then it is known as a failure. This failure is generally the effect of defect present in that certain part of the software which was executed in that situation.

However, it is not necessary that all defects result in failures. Some of these defects are present in the code, but due to never being activated, we may never notice them. For example, the defects present in the dead code will never result in failures.

Moreover, defects are not the only cause of failures. There are other reasons too due to which failures in the software product can appear. Some of these reasons are

  • Sometimes, failures can be caused by unfavourable environmental conditions like radiation burst, presence of a strong magnetic field, even electronic fields and pollution can give rise to faults in hardware and firmware which might prevent or change the execution of software causing failures
  • Failures can also arise due to human errors while interacting with the software. For example, a wrong input value entered in the software can cause a failure and sometimes even an output can be misinterpreted as a failure
  • Also, in some cases someone deliberately tries to cause a failure in the system which can lead to an actual failure

To understand failure in software better, it is important to know how to differentiate between an Error, Defect and Failure in software testing. The difference between these are given below

Error: A mistake done by the programmer while programming the software is an error. An error in the system can occur due to the following reasons

  • Not properly understanding the requirement and functional criteria of the software leading to mistakes in programming software
  • Due to some unexpected miscalculation and misinterpretation of values in the software
  • Is generally caused by Human Error i.e. mistakes done unintentionally due to lack of skill, experience and knowledge

Defect: The bugs that are detected within the code written by the programmer are known as defects. Defects in the system occur due to lack of knowledge, skill, experience, due to misinterpretation of requirements or faulty requirements provided and can also occur due to Human Error.

Failure: During certain conditions, if the defects in the software are executed by the tester during the process of testing, then it is known as a failure which is commonly known as a software failure.

Some important points related to failure in software testing are given below

  • During the testing process, if the tester is not sure whether the situation occurred is a failure or not, it is known as an incident. Incidents require a further analysis to confirm whether the failure is caused by a defect or is caused by due to some other reasons like unfavourable environment, invalid input, lack of knowledge about the feature or functionality, etc. These incidents are documented and are sent to the programmer in the form of Incident Reports. The programmer then analyses and confirms whether the incident has occurred because of the failure or not.
  • Sometimes, a few external factors too can introduce defects or bugs within the system. For example, the client requesting a software development may provide requirements and specifications design with errors in it. These faulty requirements and design specifications are then followed by the developer causing bugs and defects. However, these types of bugs can be identified during the software review and do not result in failure because they have not been executed yet
  • The defects or bugs being identified within the software are not done to blame the developers or other people responsible for them, but only to judge the quality of the software. The quality of the software holds the utmost important as it increases the confidence in customers and in turn increases business. Hence, delivering the quality product is the ultimate goal of software testing

Failures occur in the software during testing only when the defected part of the software is executed. If the defect is present in the software and has not been executed at all, then it does not cause failure.