Loading

Bebugging


Introduction :

When it comes to testing a software product, software engineers adopt a range of effective and advantageous techniques and methods, which enhance its accuracy and functionality. From indulging in peer reviews to conducting isolation testing, testers go to great heights to validate the quality, effectiveness, reliability, security, etc. of these products. Another important software testing technique that is implemented by software testers, to ensure that the quality of the software as well as to guarantee that it performs uniformly under various conditions and situations, is bebugging.

Therefore, to elaborate the importance and advantages of bebugging, here is a detailed discussion on the same.

What is Bebugging?

Bebugging, which is also known as errors guessing and fault injection, is an important testing methodology used by software testers to improve the quality and functionality of the software under test. While testing the software product, with the assistance of bebugging, the team of testers intentionally infuse known bugs, defects, and faults in the system and monitor its rate of detection and rectification.

Initially used by software programmers to measure test coverage, bebugging has since gained rapid popularity among software testers, as it allows them to estimate the number of bugs and faults remaining in a software product. The process involves random infusion of bugs in the program’s source code, which are then tested or detected by the programmers or testers. The percentage of the known bugs not found by the team, offers an indication of the real bugs remaining in the software that are yet to be detected by the concerned testers.

Reason for Bebugging:

As mentioned above, the process of bebugging helps software testers as well as other members related to the project monumentally. It not only assists them in finding defects in the software product, but also enables them to improve its quality and effectiveness. Other reasons for implementing bebugging are:

  • It helps determine the reliability of the executed test sets and test suites.
  • Improves the quality and effectiveness of the product.
  • Helps find undetected defects, bugs, and faults in the system, which can hinder its expected performance and functionality.
  • Allows the team to monitor the rate of defect detection and removal.

Techniques for Bebugging:

The process of bebugging can be termed as a type of fault injection, which helps determine the number of defects still present in the software by adding new and known bugs into it. Moreover, this can be implemented with the assistance of two important techniques, which are:

  • Compile Injection: This technique of bebugging is used to inject stimulated faults in source code of the system, which helps the team to determine the various faults or defects left in the system.
  • Runtime Injection: Another important technique for bebugging, runtime injection uses software triggers to inject defects and faults into a running software system. With the help of runtime injection, faults can be implemented in a number of ways, which are:
    • Time based triggers.
    • Interrupt based triggers.
    • Corruption of memory space.
    • Syscall interposition techniques.
    • Network level fault injection.

Prerequisites of Bebugging:

Before implementing the process of bebugging, it is vital for software testers to accumulate various necessary documents and components, which are useful in executing the process of bebugging. Therefore, to help you with the task of collecting these components, here is a list of all the prerequisites needed before the execution of bebugging:

  • Important lessons learnt from past releases and testing activities.
  • History of previous defects.
  • Application’s risk reports.
  • Variety of data used for other types of testing.
  • Previous test results.
  • Review checklist.
  • Production tickets.
  • Application UI.
  • Other important reports and documents prepared by software developers and testers.

Prominent Bebugging Tools:

Bebugging is a process that can be executed by software testers manually or with the assistance of various automated tools that simplify the process and make sure that they get accurate results. Hence, following are some of the most prominent bebugging tools used by software testers around the world.

  • Bstorm: It is a software security testing tool, a product by Beyond Security, is used as a framework for dynamic security testing of products. QA professionals and network administrators can perform testing. It allows network administrators to ensure security of networked applications before they are ready to be deployed. It is popular due to its robust and easy to use interface. Business organisations, be it any size can integrate beStorm into their software QA process. It is considered as a black box testing tool known to be used commercially, does not use source code and simply performs checks beginning with common failure issues and gradually moving onto the next.
  • Holodeck: It is a testing tool by Security Innovation. It uses fault simulation techniques to duplicate real-world application and system errors. Testers and developers can work in a controlled environment to analyse and debug error handling code. It thus helps to monitor the reliability of an application. It creates real-world scenarios like memory leaking, bad registry data, corrupt files or corrupted network packets. Holodeck logs and monitors the system calls. This in turn helps to introspect into even low level machine interactions, which allows one to track bug- generating events.
  • Xception: This project emphasises on the advanced debugging and performance monitoring features that are present in modern processors, to check how the system reacts to fault injections. This tool is widely used in various platforms - Online Transaction Processing System(OLTP), COTS(Commercial - off-the-shelf) system. Xception supports processors ranging from PowerPC, Intel Pentium, and SPARC(scalable processor architecture) based platforms that run on Windows/NT 2000, Linux OS, and a collection of real-time systems- LynxOS, SMX, RTLinux, ORK. There are many breakpoint registers in a processor. When a fault is injected, the processor executes the fault trigger related to manipulation of data. The processor runs at its own pace even at the injection of the fault, that is, the fault injection is treated as a small exception routine. By performance monitoring we intend to check the behaviour of the system in terms of number of clock and memory read and write cycles, and the instructions executed. This process continues until an error is caught.
  • The Mu Service Analyser: Mu Security is a tool intended to track the network traffic and attack patterns. The Internet world is prone to attacks, hence Mu-4000 offers a range of testing options like mutated traffic, published vulnerabilities, Dos attacks. It has the option to choose any protocols from - TCP, UDP, ICMP to launch Dos attacks. It has the facility to record the system's progress and records the response time during an attack. When a fault is traced, the Mu analyser facilitates tracking the traffic and the packets to determine what caused the issue.
  • Exhaustif: It is a SWIFI injection tool that checks for fault occurrence by injecting faults into the system, in a distributed environment. It is a fault tolerance verification and validation tool for embedded software systems. Exhaustif has two parts : EEM (Exhaustif Executive Manager) and FIK (Fault Injector Kernels).
  • EEM: It helps to perform data analysis, post fault injection. It is a GUI based Java application that uses a SQL database to record the test results thus obtained from the System Under Test. It basically performs memory corruptions using temporary triggers and uses optimized routine interceptions, with minimum time.
  • FIK: This comes under EEM and checks fault injections in applications that run on different operating systems.

Benefits & Drawbacks of Bebugging/Error Guessing/Fault Injection:

The process of bebugging, which is also referred as error guessing and fault injection is garnering attention of software engineers around the world because of the various advantages offered by it. However, no testing technique can be perfect, and likewise, bebugging also has few drawbacks that needs to be considered before implementing it on the software product. Following are the multifarious benefits of bebugging and the few drawbacks it offers.

Benefits:

  • It does not impact the software under test.
  • It saves time and efforts of testing.
  • Does not require any expensive hardware.
  • Can be used to test applications as well as operating systems.
  • Has higher observability and controllability of the system’s behaviour in the presence of faults.
  • Allows testers and developers to easily identify the weakest points of the software product.
  • It is a flexible testing approach.
  • Increases the probability of finding defects in the system.

Drawbacks:

  • Requires large development efforts.
  • The fidelity of this testing technique is highly dependent on the accuracy of the models used.
  • Intentional infusion of bugs and defects can impact or damage the performance or quality of the software.

Summary:

Bebugging primarily aims to refine the quality of an application by deliberately introducing new defects into it. The reason for performing such an activity is to enhance the robustness of the application and to also ensure that our system performs efficiently under stressful conditions. The entire concept of fault injection or bebugging can be classified under a common term SWIFI, which is an abbreviated term for Software Implemented Fault Injection.