Adhoc Testing: A Brief Note With Examples

Adhoc testing is usually performed to break the system and using unconventional ways. The most astounding feature of Adhoc testing is that it does not have any test design technique to create test cases.
The process is usually performed to find loopholes of a software. Since Adhoc testing does not have test cases it is often performed without any documentation.
Have a look at the process in detail
Ad-Hoc testing is a technique that falls under the ‘Unstructured Testing’ category.

What’s Structured and Unstructured Testing?

Structured Testing

In this approach, every activity that occurs during the testing procedure, from the creation of test cases to their sequential execution, everything is scripted. The testers follow this script to conduct tests according to it.

Unstructured Testing

In this approach, testing is commonly done through error guessing, where the testers create the test cases, during the testing process itself.

What is Adhoc Testing?

As discussed above, it is a type of unstructured testing approach, where no organized plan is created before starting the testing process.
Therefore, prior to testing, no requirement documentation or test case planning and designing are done.
Ad-Hoc testing is usually conducted by a tester who has a strong knowledge of the software under test, regarding what it does and how it works.
This testing is done by randomly creating test cases through error guessing and executing them, without following any requirements for the test.
A major part of this testing is to find out the potential areas of the software, where errors could be present.
This is why it is also sometimes known as Monkey Testing or Random Testing. This is why it is important for only those testers who have good knowledge of the software to conduct this test.
An advantage of Ad-Hoc testing is that it saves quite a lot of time, which otherwise goes into the creation of documents like test requirements, test case planning, designing, etc.

It is also generally conducted after the structured testing has already been performed. This is done, so as to find out uncommon flaws in the software that could not be detected by following the prior written test cases.

Types of Adhoc Testing

1) Buddy Testing

In this type of Ad-Hoc testing, tests are conducted with the team effort of at least two people. This team is usually made up of at least one software tester and one software developer.
This type of testing takes place after the conduction of unit testing of a module is completed.
The team of the two ‘buddies’ works together on that module to create valid test cases.
This is done so that the tester does not end up reporting errors generated through invalid test cases. This type of testing can also be considered as the combination of both unit and system testing.

2) Monkey Testing

The randomness of the approach used in this testing is why it is termed as ‘monkey testing’.
Here, the software under test is provided by random inputs, for which their corresponding outputs are observed.
On the basis of the obtained outputs, any occurrence of errors, inconsistencies, or system crashes is determined.

3) Pair Testing

This testing is much like buddy testing. However, here, a pair of only the testers work together on the modules for testing.
They work together to share ideas, opinions, and knowledge over the same machine to identify errors and defects.
Testers are paired according to their knowledge levels and expertise, to get a different insight into any problem.

Characteristics of Adhoc Testing

• This testing is done after formal testing techniques have already been conducted on the software. The reason for this is that ad-hoc tests are done to find out the anomalies in the application, which cannot be predicted prior to testing.
• This testing can only be conducted by those testers who have a good and thorough knowledge of the working of the application. This is because effective ‘error guessing’ can only be done when the tester knows what the application does and how it works.
• The Ad-hoc testing technique is most suited for finding bugs and inconsistencies which give rise to critical loopholes in an application. Such errors are usually very difficult to uncover.
• This testing takes comparatively lesser time than other testing techniques. This is because it is done without prior planning, designing, and structuring.
• Ad-Hoc testing is conducted only once, as any errors that are found require to be retested.

Examples of Adhoc Tests

• Testing for the proper working of an application when the browser settings are different. For example, identifying errors that occur when the option for JavaScript is disabled in different browsers, etc.
• Testing the application across platforms. It is essential to check whether the developed application can run fluently in different operating systems or browsers.
• Providing inputs to the system that are outside the valid-inputs range, to check whether the resulting action taken by the application is appropriate or not.
• Copying the application’s URL and manipulating it to run on a different browser. This is done to ascertain that any unauthorized users is not able to get unauthenticated access to the system.
• Going through a series of random steps or navigating randomly through the application so as to check the results obtained by going through a certain combination of unusual inputs.

When to Conduct Adhoc Testing

Usually, ad-hoc testing is conducted when there isn’t enough time to perform exhaustive and thorough testing which includes preparing test requirements document, test cases, and test case designs.

The perfect time to conduct this type of testing is after the completion of formal testing techniques.
However, ad-hoc tests can also be conducted in the middle of the development of the software.
It can be performed after the complete development of the software, or even after a few modules have been developed.
It can also be conducted during the process of formal testing methods as well.
There are a few situations where this testing, however, must not be conducted. Therefore, every tester must know when to avoid this testing.
Given below are a few conditions when ad-hoc testing must not be conducted:

• Ad-Hoc testing must not be conducted when Beta testing is being carried out. This is because Beta testing involves the clients, who test the developed software to provide suggestions for new features that need to be added or to change the requirements for it.
• This testing is also advised to not be conducted in the test cases which already have existing errors in them. The errors must be first properly documented before they are removed from the system. After they are fixed, the test cases must be retested, to ensure their proper working.

What are the Advantages of Adhoc Testing?

• One advantage of ad-hoc testing is that many errors, that usually go undetected when only formal testing methods are used, can be found by randomly testing the application.
• The testers get to explore the application freely, according to their intuition and understanding of the application. They can then execute the tests as they go, helping them in finding out errors during this process.
• Testers a well as the developers of the application can easily test the application, as no test cases are needed to be planned and designed. This helps the developers to generate more effective and error-free codes easily.
• This testing can also help in the creation of unique test cases that can ineffectively detect errors. Therefore, such test cases can be added to formal testing with other planned test cases.
• Ad-Hoc testing can be conducted at any point in time during the software development lifecycle because it does not follow any formal process.
• It can be combined with other testing techniques and executed to produce more informative and effective results.

What are the Disadvantages of Adhoc Testing?

• Since the testing process is not documented and no particular test case is followed, it becomes very difficult for the tester to regenerate an error. This is because the tester needs to remember the exact steps that he followed to get that error, which is not possible every time.
• Sometimes, due to the execution of invalid test cases randomly developed by the tester, invalid errors are reported, which becomes an issue in the subsequent error fixing processes.
• If the testers do not have prior knowledge about the working of the application under test, then performing ad-hoc tests will not be able to uncover many errors. This is because the testers need to work through error guessing and intuitively create and execute test cases on the spot.
• Ad-Hoc testing does not provide assurance that errors will be found. Proactive error guessing for testing totally depend on the skill and knowledge of the tester.
• Since there are no previously created and documented test cases, the amount of time and efforts that go into this testing remains uncertain. Sometimes, finding even one error could take a huge amount of time.

Best Practices to Conduct Adhoc Testing

For effectively conducting the Ad-Hoc testing technique, it is important to know the most effective and efficient ways to do so.
This is because if tests are not conducted in a proper manner, then the effort and time put into the tests will be wasted.
Therefore, to conduct this type of testing, one must know the best practices that can help in a more comprehensive approach to testing:

1) Good Software Knowledge

Make sure that the tester assigned for the testing of the application through the ad-hoc approach has a good hold on the application.
The tester must be familiar with all the features of the application so as to facilitate better ‘error guessing’ on the application.
With sufficient knowledge to back the tester’s testing process, finding more errors, bugs, and inconsistencies become easier.

2) Find Out Error-Prone Areas

If testers, how are not familiar with the application, then the best practice for them to start their testing process is to check for the part of the application where the majority of the errors lie.
Picking such sensitive areas to perform ad-hoc tests can help them find errors more easily.

3) Prioritize Test Areas

It is always better to start testing from the areas of the application that is the most used by the end-users or customers. This helps in securing the important features and reporting any bug beforehand.

4) Roughly Plan The Test Plan

Although Adhoc testing requires no prior planning or documentation, it proves to be very useful and efficient if a rough plan is created beforehand.
Just noting down the main pointers and areas that require testing can help the testers to cover the maximum part of the application in a short amount of time.

5) Tools

It is essential to make use of the right kind of tools like debuggers, task monitors and profilers to ease the process of testing.

This is because there are times when specific bugs and exceptions cannot be seen and are not caught while testing.
However, using the right tools can help isolate the error in just a short time.
Adhoc testing vs Exploratory testing

Adhoc Testing	Exploratory Testing
Testers must have a clear idea about the workflow of the application	Testers learn about the application on the go
More about the perfecting the testing process	It’s a learning method to know about the application
A form of positive testing	A form of negative system
There is no plan	A charter based plan will be put to use
There is no proposed time limit	Time boxed/character vector
Can be executed by the software test engineer	Have to be done by the expert
Focus is on the application process	Data entry areas will be the prime focus
Complexities of tests will not bother much this process	Challenges involved

 
Conclusion/final thoughts
AdHoc testing is, therefore, one, where the tester’s creativity and knowledge are put to test.
We have discussed every aspect of this type of testing including its types, characteristics, examples, advantages, disadvantages and best practices!