Adhoc Testing: A Brief Note With Examples

Ad-hoc testing, categorized under ‘Unstructured Testing,’ is a unique approach aimed at breaking the system through unconventional methods. Notably, it lacks a predefined test design technique for creating test cases.

This testing process focuses on uncovering software bugs, and its distinctive feature is the absence of formal documentation due to the spontaneous and unscripted nature of the tests. Let’s delve into the details of this intriguing testing technique.
adhoc principle

What’s Structured and Unstructured Testing?

Structured Testing

In this approach, for 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?

Adhoc test diagram
Ad-Hoc testing, falling under unstructured testing, doesn’t involve a predefined plan, requirement documentation, or test case design. Conducted by testers well-versed in the software, it relies on error guessing, randomly created test cases, and exploration without adhering to specific requirements.

Often termed Monkey Testing or Random Testing, it efficiently identifies potential software error areas, leveraging testers’ knowledge. Notably, this approach of skipping formalities, such as document creation, is time-saving, making it a valuable testing method.

It is also generally conducted after the structured testing has already been performed. This is done so as to find 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 ‘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 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 that give rise to critical loopholes in an application. Such errors are usually very difficult to uncover.
  • This testing takes comparatively less 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 documents, 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 not to be conducted in test cases that already have existing errors in them. The errors must first be properly documented before they are removed from the system. After they are fixed, the test cases must be retested to ensure their proper functioning.

What are the Advantages of Adhoc Testing?

  • Ad-hoc testing has the benefit of allowing for the discovery of many errors that would otherwise go unnoticed when using only formal testing techniques.
  • 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 find errors during this process.
  • Testers, as well as the developers of the application, can easily test the application, as no test cases need to be planned and designed. This helps the developers 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 depends on the skill and knowledge of the tester.
  • Since there are no previously created and documented test cases, the amount of time and effort 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 support the tester’s testing process, finding more errors, bugs, and inconsistencies becomes easier.

2) Find Out Error-Prone Areas

If testers 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 in the areas of the application that are most used by end-users or customers. This helps in securing the important features and reporting any bug beforehand.

4) Roughly Plan The Test Plan

Although ad hoc 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 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 testing process.

6) Error Guessing

Encourage testers to use their experience and intuition to guess potential error areas and vulnerabilities in the software

7) Random Testing

Implement random testing techniques to ensure a diverse range of scenarios are covered, mimicking real-world usage.

8) Effective Communication

Facilitate communication among the testing team to share insights, findings, and potential areas of concern.

9) Balanced Coverage:

Strive for a balance between exploring new, untested areas and revisiting previously tested functionalities to ensure comprehensive coverage.

10) Feedback Loop

Establish a feedback loop with the development team, promptly communicating discovered issues for quick resolution.

11) Regression Testing

Consider performing regression testing alongside Ad-Hoc testing to ensure that new changes don’t adversely impact existing functionalities.

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.

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

Conclusion/final thoughts

In conclusion, ad hoc testing emerges as a crucible where the tester’s creativity and expertise are rigorously tested. Throughout our exploration, we delved into the nuanced aspects of this testing paradigm, unraveling its types, distinct characteristics, illustrative examples, as well as the associated advantages, disadvantages, and best practices.

Adhoc testing, often synonymous with spontaneity, demands a profound understanding of the software under test.

While its unstructured nature may seem chaotic, it serves as a litmus test for a tester’s acumen, relying on intuition and experience to uncover unforeseen vulnerabilities.

As the software testing landscape evolves, embracing the dynamism of Adhoc testing becomes imperative, recognizing its role in fortifying the robustness of applications and ensuring a resilient user experience.

What is Monkey Testing? Features, Types With Examples

Monkey testing is a crucial testing method that is done to authenticate the functionality of the product application. Monkey testing is done to ensure that the specifications given by the client are properly addressed in the software.
Monkey testing is a kind of black box testing. This testing is done when the tester is the time deficit in order to write and execute the function.
monkey testing
There are many names given to this testing pattern as Random testing, Monkey Testing, Fuzz Testing, and the technical name is Stochastic Testing.
This testing works well in case of androids, desktops, web and other mobile applications.
In this testing, there is no predefined strategy or algorithm and hence the testing works on tester’s gut and mood. Monkey testing is more efficient while doing stress testing.


It was first used in 1983 to test the software on Mac. These programs were Macwrite and Macpaint. The original Mac had the scarcity of memory.
monkey testing
After the program was completely initiated, there was a lesser amount of memory left than required to perform the test. So Macwrite and MacPaint used buffers those were quite larger than the size of the screen of the desktop. So it became essential to create some testing method that acquired lesser memory.
So Steve Capps used Monkey program to enter random inputs to Macwrite and Macpaint. The Monkey functioned parallel to the other programs, data entry running in the system.
This would perform faster than a regular user as if a monkey was showing the swiftness in him. Hence the team decided to set up commands, window events, menu clicks so that it can target the requirements of the tester.
The term monkey testing was first seen in the book ‘The Art of Software Testing’ written by Glenford J. Myers in 1979. It is a very famous technique among software engineers.
Monkey testing is a software testing technique in which the operator provides the software with some random inputs in order to analyze the behavior of the software.

It also finds out whether the system or application will work properly under such conditions or crash. The testing is usually used by the tester at the beginner’s level.


Listening to the term Monkey Testing gives the vision of monkeys thumping on the keys of the keyboard and working as a computer expert, writing functions and other content.
All the random thrust on the keyboard may result in brilliant work as it may hit all possible combinations. It all may sound good. Going deeper into this theory, let us understand monkey testing.
Monkey testing is an automated test, which is done without any specification in mind. The main purpose of the test is to find out errors and bugs in the software to ensure the complete development of the product.

There are Some Other Features of Monkey Testing:

  • There is no specification while performing this test.
  • It focuses on crashing the system by hitting random inputs so that the security can be ensured once the product is complete.
  • The testing is done in the system where the errors are not identified at regular intervals.
  • The time and effort that is required are comparatively lesser in this kind of testing.
  • It ensures the reliability and efficiency of the system.

Example/Types of Monkey Testing

In this process of testing the tests are chosen independently from the test domain and are performed depending upon the tester’s requirement.
After the test, the team tries to replicate the error, once the issue is detected and fixed.
Monkey testing is categorized into three major kinds. Each of these focuses on different aspects of the programs and clears bugs from that particular genre.
monkey testing


Dumb monkey testing technique or ignorant monkeys, as the name specifies, inculcates a tester who has no knowledge of the application, its features, functions, working behavior or bugs.
They do not have any clue if the provided inputs are valid or invalid. It is the simplest testing which does not require the tester to know about the characteristics or qualities of the software or of the test flow.
The dumb monkey does not know the flow of work or the type of data being fed to the application or the system.
This determines fewer errors as compared to Smart monkey test. This test can catch the bugs that are harder to identify but are critically important too.


Smart Monkey testing is another variant of monkey testing in which testing is performed by testers or group of testers who has a deep understanding of the workflow of software/application
The smart monkey test is aware of the locations of test and is well aware of the page they will be redirected to.
In this type, the tester is more focused on breaking an application and when they find an error, they are aware enough to report the bug.
This is an ample example of load testing. The impressive part is that this type of test gives the tester quicker results than that of its counterpart.


The brilliant word suggests an advancement to the word smart. This is also true in case of these techniques, the brilliant monkey testing is an advancement in the smart monkey testing technique.
A tester or a team of testers is assigned for the task, ensuring that they have complete knowledge about this software domain and its functionalities.
Example: The tester who has sufficient knowledge of the banking sector may be asked to enter the banking domain’s data.

  • The tester knows well about the usage of the program and also the way other users handle it. So they carry out the testing from the user’s perspective.
  • It is an extension of the smart monkey testing technique.
  • It can also help in determining other bugs that may occur in the future span of its functioning.

Also Read: Black Box Testing – Techniques, Examples and Types 


Monkey testing caters to the needs of an organization in chasing the out-of-the-box errors. It has both advantages and disadvantages as like every other entity.
Here are a few to add up to its advantages:

  • Usually, the software testing that is performed is ad-hoc but monkey testing can also help the tester to unwind the burden under the stress testing condition. Also if the tester does not have much knowledge about the application, this testing can rescue.
  • The deep-rooted randomness can sometimes save the system from complete breakdown by identifying the major bugs.
  • Being easy to follow monkey testing caters another advantage. Smart monkeys can help find unique bugs if set up with proper and accurate state model, quickly.
  • It has a great advantage that it can be accessed by anyone, one who may have knowledge of the file or who do not. Evidently, they will not be able to understand the appropriateness of the result, but still, they will not face any problem to perform it.
  • In an unintended way, it also allows the domain tester to judge the response of the program. But as the test pattern is unplanned the software may come under stress and will affect the server.
  • The cost-effectiveness makes this software more advantageous than others.
  • In case of a time crunch, if all the other test have been performed, the tester can opt for monkey testing that will allow quick fixing of the bugs.

There are Several Disadvantages that can Overshadow its Positive Points:

  • The test input values provided in monkey testing are so random that it becomes very difficult to reproduce the bugs and errors.
  • The occurrence of unexpected bugs makes it more difficult to analyze and resolve the bugs.
  • It may run for a long time before the commencement of the test, which reproduces unnecessary bugs which may again be time consuming and irrelevant.
  • It comprises accuracy as it is not able to recreate the same environment of the test.
  • The smart monkey can be efficient when provided with the state model but it also becomes expensive in that case.

Difference Between Monkey Testing and Ad-hoc Testing

  • The main difference between ad-hoc testing and monkey testing is that the former is carried out without any documentation or planning.
  • It focuses on breaking the system into subparts and finding out the bug in that particular subpart and resolve it. So that the functionality could be maintained. This is opposite to the functioning line of Monkey testing.

Difference Between Monkey Testing and Gorilla Testing

  • The other difference can be seen in gorilla testing and monkey testing. Here the former is performed on limited features and modules to analyze their functionalities, whereas the latter focuses on breaking down of a complete system to identify the bugs.


There are many tools which make it possible to perform the automated test efficiently.
They are developed to generate random data so that all the faults and flaws can be reported in the application. The generation of monkey testing tools requires some good amount of efforts but once they are done, they perform efficiently with automation.

1. For Android- MonkeyRunner Tool:

  • MonkeyRunner android tool is designed to work aptly with androids.
  • The tester can easily install and execute an android program, send it data files and store them in the computer using the Python program.
  • The tester can also control and access to the Android device by using an application program interface(API) provided by the tool.
  • As the MonkeyRunner tool is used to perform the framework level of testing and functional test, it can also be used to random testing test suites.

2. On android – U/I Application Exerciser Monkey:

  • This application is quite different from the MonkeyRunner tool, which controls the android device from exterior to the android code while U/I Application exerciser monkey runs inside the emulator.
  • It can also be used to develop the system and user events in the quasi random stream.


Monkey testing evidently, has differences with regard to the working of a monkey as it can completely analyze the function and will not do anything improper or irrelevant with the system.

The end user who uses any application or software is not expected to have the functional knowledge of the same. So by this testing, we can ensure the fulfillment of the needs of the user and decrease the probability of the awful breakdown of the software and system.
We can say that as it is not always possible to regenerate the bugs, it becomes almost difficult and sometimes impossible for us to reproduce the same found bug. It is very time-consuming work that requires a lot of effort, therefore we cannot recommend Monkey testing in the initial stages of the testing.
Later when the other test is done it can be opted to find the other issues such as the software and hardware issues, fault lines and memory leaks which are difficult to find in normal testing.
So we can say that one could opt for this particular kind of test if they lack in time and have performed other required test. Also one needs to ensure that the application is highly stable and can be reproduced as it focuses on the crash of the entire system.