To help you navigate this article better, we’ve included a table of contents, so you can skip to the sections most relevant to you.
- What is Ad Hoc Testing
- Types of Ad Hoc Tests
- Monkey Testing
- Pair Testing
- Buddy Testing
- Characteristics of an Ad Hoc Test
- Difference Between Ad Hoc Testing and Exploratory Testing explained
- What is exploratory testing?
- When Should You Use Ad Hoc Testing
- When should Ad Hoc testing be avoided?
- Why Should You Use Ad Hoc Testing
- Benefits of Ad Hoc Testing
- Disadvantages of Ad Hoc testing
- How to Perform Ad Hoc Testing
- Tips and Best Practices for Ad Hoc Testing
You’re spent months working on an application, and you’re just about ready to roll it out to your audience. After all, you’ve run your formal tests and nothing looks out of the ordinary - no bugs, no errors, no faults.
Or so you think.
It’s easy to get caught up in the excitement of it all, but formal testing doesn’t always uncover all the defects. Give your application a once-over with ad hoc testing. The great thing about it? It doesn’t need any prep and can be run at any time during your application’s lifecycle. Think of it as a spur of the moment test; it’s run to uncover defects at various stages, so you don’t have to keep fixing bugs later down the line.
Curious about what else ad hoc testing can be used for? Read on for an in-depth tutorial into its functions, types, benefits and how you can run an ad hoc test for your application.
What is Ad Hoc Testing?
Ad hoc testing is one of the least formal types of tests run on applications, since it requires no preparation or planning. Essentially ‘breaking’ the testing process, ad hoc testing is aimed at uncovering errors and bugs at various stages throughout your software development. Since it doesn’t follow any sort of test plan, it doesn’t require documentation or specific techniques to create test cases.
Performed at any point during the application’s development, ad hoc testing doesn’t follow a particular structure. However, it’s not quite as chaotic as that might sound. It requires the testers to have a deep understanding of the application they’re building and to be confident with ‘error guessing’ (spotting potential defects based on prior testing experiences).
One of the great things about ad hoc testing is that it takes less time than more formal testing methods. Since you’re not following a set method, taking thorough notes or documenting everything, you’ll be saving a lot of time. One downside to this is that you won’t always be able to map defects to test cases. This might make it more difficult to reproduce defects.
Despite this, ad hoc testing is still a great way of unearthing defects during the early stages of your application, ensuring that your software is only released to the end-user once it’s in tip-top shape.
Types of Ad Hoc Tests
Ready to run your own test? Take a look at three of the most popular types of ad hoc testing below:
This is a type of ad hoc testing that involves testing the application with random inputs without any test cases. Imagine a monkey typing on a keyboard, and you’ve got the right idea! The main goal of monkey testing is to break the application in some way, thus uncovering defects.
What does ‘breaking the system’ mean anyway?
Part of your QA team’s job is to check a piece of software for any bugs, and one of the best ways of doing this is ‘breaking the system.’ This essentially means testing an application on extreme ends of the spectrum and acting as though it’s already buggy - this will force bugs and defects to come to the surface quicker. Think of it this way; you’re testing the application to see which areas could possibly break under pressure.
Another type of software testing, buddy testing involves two members; one from the development team and one from the testing team. Both individuals will work together on the same module sharing ideas and uncovering defects and bugs in the application. Not only does buddy testing help testers create better test cases and improve their test strategy, it also ensures that developers can fix errors as soon as they’ve been spotted. It’s important to note that this type of testing can only be done once unit testing is completed.
A type of testing that involves two testers working together, pair testing requires the testing team to work together on the same application and share ideas. While one person takes on test execution, the other records and takes notes on the findings. Ideally, they should have different levels of knowledge.
Buddy Testing Vs. Pair Testing
Buddy testing and pair testing are pretty similar (both require at least two individuals to take on the test), but their main difference lies in the people involved; buddy testing requires an individual from the development team and testing team, while pair testing requires two QA individuals from different knowledge levels.
So, which is more effective? It all depends on what your testing goal is and the kinds of things you’re looking to gain. If you want to find bugs and resolve them ASAP, then buddy testing is the more suitable option - this is because the development team is on-hand to make changes as soon as bugs are found. If, however, you’re looking to run a simple ad hoc test but don’t have the luxury of a full blown QA team, pair testing will be your best bet as testers from two different backgrounds can still run the test together.
Characteristics of an Ad Hoc Test
What other characteristics distinguish ad hoc testing from other types of testing?
- Random testing, done on any part of the application
- Manual testing executed without pre-planning or documentation
- Uncovers bugs and loopholes that may be missed during automated QA testing
- Does not follow any test design techniques, meaning no test cases are created
- Relies on error guessing from the testers
- Performed with the aim to break the system in order to to find defaults and errors
- Requires a software tester with in-depth knowledge of the testing system
- Helps determine effectiveness of the test bucket
- It’s a black box testing technique
- Performed when there is limited time to do formal, in-depth testing
The Difference Between Ad Hoc Testing and Exploratory Testing
Some of what we’ve discussed might sound similar to exploratory testing, but there are key differences.
What is exploratory testing?
Simply put, exploratory testing is an approach where test cases are created on the go by testers. Often seen as a simultaneous learning, test case design and execution technique, exploratory testing enables the tester to think more creatively during the testing process and nurtures further investigation, discovery and learning.
The great thing about exploratory testing is that nearly everything is done on the fly. This might sound a little reckless but in fact, it helps testers come up with use cases that might otherwise have been missed in a more formal test case.
Now, you might be wondering; what’s the difference between ad hoc testing and exploratory testing? Aren't they two titles for the same kind of testing? Not quite. They might both offer more flexibility and freedom in testing, but that doesn’t mean they’re the same. The key difference lies in their purpose and makeup.
As we’ve discussed, ad hoc testing is a type of software testing done with no formal testing techniques, requiring no planning or documentation. It’s unstructured and random, enabling testers to unearth critical bugs they would have otherwise missed with automated or regression testing.
What separates it from exploratory testing is the random and unstructured approach. While exploratory testing offers more flexibility in testing, it still follows formal, structured testing methods, enabling testers to set goals and boundaries. Ad hoc testing, on the other hand, requires no documentation and doesn’t have any rules, goals or boundaries. Though exploratory testing might take a slightly more formal approach, it still allows the tester to think creatively and critically about during its execution.
Exploratory testing also requires thorough documentation of each of the test steps, making it easier to reproduce bags found in previous tests. Overall, this makes it a lot more scalable and easier to manage than ad hoc testing.
Top tip: Accelerate your testing strategy by combining multiple types of testing. At GlobalAppTesting, we provide QA teams with a wide range of testing options including exploratory testing. Give your application the once over and make sure it’s fully functional before it goes to market.
When Should You Use Ad Hoc Testing
Ad hoc testing is unstructured, random and requires no documentation - so, when is the best time to execute this test? Since it’s one of the quicker processes, ad hoc testing is usually done when there’s limited time and resources available within the testing team. Perhaps they’re overburdened with other tests and tasks, or there’s no time for elaborative, formal testing to be done. In these cases, ad hoc testing is a quick and effective solution to uncovering defects with very little prep time.
Ad hoc tests are also usually only executed once formal tests have been run, as they’re great for unearthing errors you might have missed with other types of testing. Since ad hoc testing is unstructured and random, it can be done at any time during your application’s development. One thing you absolutely can’t slack on with ad hoc testing is the team you bring on to execute tests. These testers need to have an in-depth knowledge of the system being tested, so be sure to pick a team that’s clued up on your application.
When Should Ad Hoc Testing be Avoided
While ad hoc testing can be extremely useful, particularly at times when time and resources are low, it’s important to know when it should be avoided. Here are some times when you should probably steer clear of ad hoc testing:
- If the testers don’t have in-depth knowledge about the testing system or application, avoid this type of testing. One of the disadvantages of ad hoc testing is that it requires a testing team with thorough knowledge on the application and system you’re running. You can’t run an ad hoc test if your testers aren’t 100% clued up on the system, so if you can’t find these ‘experts,’ it’s best to give it a pass.
- If clients are asked to take part in beta testing of your application, it’s best to avoid ad hoc testing. This is because beta testing involves real, live users (people who might actually be using your application one day); so it’s best to give ad hoc testing a miss if you’re at this stage, as you’re probably close to your release date. Ideally, your beta testers should be providing helpful feedback at this stage anyway.
- If a UI (user interface) screen is added to an application, it’s advised you stick with negative testing to bring out as many defects as possible. While ad hoc testing is beneficial, you’ll want to note down all the user related defects you’ll be encountering so you can fix them ASAP. For tests that require an in-depth look at the user’s navigation and usability of your application, you’ll want to document and take notes as much as possible (which is quite far removed from ad-hoc testing).
Why Should You Use Ad Hoc Testing?
The best thing about ad hoc testing comes from its unstructured, informal approach: your QA department can be creative. With little to no prep or documentation required, testers can work more flexibly and look at the application from a new angle. This provides more chances for discovery, enabling users to find bugs and errors they might have missed with more formal testing methods.
Advantages of Ad Hoc Testing
- Uncovers errors and bugs that would otherwise have been missed with more formal testing methods such as non-functional testing, stress testing, automation testing and regression testing.
- Gives testers the chance to explore the application more freely, opening up the chance for more creative and critical thinking when executing tests.
- Enables testers and developers to work together (buddy testing) as no written test cases are required. Not only does this help break down silos in organizations, it also means that developers can make changes to the application as soon as defaults or problem prone areas are spotted.
- Can be easily executed since no planning or documentation is required.
- Can be conducted at any point during an application’s development, giving testers the chance to explore when they see fit rather than running to a set schedule.
- It can be combined with other, more formal methods of testing to get maximum results, leading to better test case designs and an overall better application.
- Provides optimum test coverage and quality when time or resources are low.
- Since no documentation is required, it frees up time for the tester to focus all of their energy on the test execution and possible solutions
- It can help ensure bugs are discovered pre-release, dramatically reducing the cost of fixing them (as shown below).
Disadvantages of Ad Hoc Testing
- Difficulty reproducing bugs and loopholes in later development. Since no documentation is required, it becomes more difficult to map defects to test cases because testers can’t keep track of STR’s (steps to reproduce an error).
- Requires experienced testers who have in-depth knowledge about the application and system being used.
- Little to no accountability - since ad hoc testing doesn’t have any required documentation, it can be challenging to map how much has been invested into a test. It also means unearthing bugs could take much longer than expected.
How to Perform Ad Hoc Testing
Since ad hoc testing is unstructured and doesn’t follow a specific plan, there’s no real right or wrong way to execute it. There’s no ‘steps’ or guide that testers must absolutely follow when performing an ad hoc test - but it does help to keep a few things in mind:
- Make sure you’ve got knowledgeable testers in place.
- Ensure the conditions are a right fit for an ad hoc test.
- Have a checklist in place when you’re combing through an application - again, you don’t need official documentation but it can be useful to note what you’ve done in case the process takes a few days.
Aside from that, there’s not much else a testing team can do to control ad hoc testing. The whole premise of the test is that it affords more flexibility and freedom to testers, giving them the chance to improvise and identify complex scenarios and loopholes that would otherwise have been missed.
Tips and Best Practices for Ad Hoc Testing
Though ad hoc testing doesn’t have a strict step-by-step guide, there are a few things you can do to maximize your chances of success and supercharge your testing approach:
Identify defect and bug prone areas
Save time and expose the most serious defects and bugs first by doing a bit of digging into your current application and system. Ad hoc testing might be unstructured, but putting in a little bit of prep isn’t a crime! Analyze your system and where defects seem to crop up most, so you can focus your ad hoc testing on that particular part of your application. The more often you do this, the better you’ll understand your system and the places where issues pop up the most.
Use smart tools
Uncover even more problems, and increase efficiency by using extra tools during your ad hoc testing. These could include profilers, debuggers and monitoring applications.
Top tip: Make testing easier by using a remote on-demand QA testing platform like Global App Testing. Complete with a range of testing options tailored for CIOS, engineering and QA teams, there’s something for everyone.
Upskill and build knowledge
It’s true that only experienced testers can take on ad hoc testing, but that doesn’t mean it’s completely inaccessible. Upskill and build knowledge within your entire testing team, so everyone can gain the skills and knowledge to perform an ad hoc test. Get existing ad hoc testers to share their expertise with other testers, whether in-person or via video tutorials.
Draft a rough plan to optimize results
This might come as a bit of surprise - isn’t the whole point of ad hoc testing to be unstructured and undocumented? While that may be the general basis, it’s a good idea to draft a rough outline of which features you’re focusing on. Not only will this improve efficiency, it will also save you time and ensure you execute the tests as well as possible.
Document your steps
Again, it might seem a little counter-intuitive, but documenting your steps is a great way of tracing back your steps and can come in handy when you need to reference a particular test or action performed (this could include things like: scenarios covered and features tested). It doesn’t need to be particularly in-depth, but it’s definitely worth having an idea of where you’re up to! Not only will this help you and your testing team improve the test bucket, it will also help you better improve on other existing test cases.
Consider session testing
Instead of testing features all at once, take it easy and test all your features one at a time. This is called session testing, and it’s a great way of helping you and your testing focus and understand problems better.
Make a note of all the defects you encounter
Whenever you encounter a problem or error, be sure to jot it down so you can come back to it and remedy it as soon as possible. Since ad hoc testing isn’t planned for, it’s easy to sometimes forget what you’ve encountered; so, making a note of it ensures you have a point of reference and will help you write better bug reports.
Turn your attention to unexplored areas of your application
Instead of always focusing on areas that you know a lot about, try turning your focus to some of the more unexplored areas (in other words, the areas not covered by test cases). Venture into the uncharted territory and try zoning in on these areas to reduce the possibility of redundant scenarios and cover more ground in these unexplored areas.
There are so many different types of software testing methodologies out there that it’s sometimes easy to forget about ad hoc testing. You can run through your application and think you’ve spotted all the bugs and errors when in actual fact, there’s still a few hiding under the radar!
It may seem a little different to the formal methods you’re used to, but this is what makes it so unique and beneficial to developers and QA engineering teams. It’s a chance to give your testing team the flexibility and freedom to execute tests on their own terms, increasing their creative and critical thinking skills as they navigate the testing system without a formal plan.
As we’ve gone over, however, there are a few best practices and top tips that testing teams can put into place before running an ad hoc test to ensure maximum efficiency. Ad hoc testing might be different (and it’s certainly not a great fit in every situation) but it’s a great way for QA teams to ensure they have a high quality app at the time of release.