Hubbry Logo
Monkey testingMonkey testingMain
Open search
Monkey testing
Community hub
Monkey testing
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Monkey testing
Monkey testing
Monkey testing
View on Wikipedia
from Wikipedia

In software testing, monkey testing is a technique where the user tests the application or system by providing random inputs and checking the behavior, or seeing whether the application or system will crash. Monkey testing is usually implemented as random, automated unit tests.

While the source of the name "monkey" is uncertain, it is believed by some that the name has to do with the infinite monkey theorem,[1] which states that a monkey hitting keys at random on a typewriter keyboard for an infinite amount of time will almost surely type a given text, such as the complete works of William Shakespeare. Some others believe that the name comes from the classic Mac OS application "The Monkey" developed by Steve Capps prior to 1983. It used journaling hooks to feed random events into Mac programs, and was used to test for bugs in MacPaint.[2]

Monkey Testing is also included in Android Studio as part of the standard testing tools for stress testing.[3]

Types of monkey testing

[edit]

Monkey testing can be categorized into smart monkey tests or dumb monkey tests.

Smart monkey tests

[edit]

Smart monkeys are usually identified by the following characteristics:[4]

  • Have a brief idea about the application or system
  • Know its own location, where it can go and where it has been
  • Know its own capability and the system's capability
  • Focus to break the system
  • Report bugs they found

Some smart monkeys are also referred to as brilliant monkeys,[citation needed] which perform testing as per user's behavior and can estimate the probability of certain bugs.

Dumb monkey tests

[edit]

Dumb monkeys, also known as "ignorant monkeys", are usually identified by the following characteristics:[citation needed]

  • Have no knowledge about the application or system
  • Don't know if their input or behavior is valid or invalid
  • Don't know their or the system's capabilities, nor the flow of the application
  • Can find fewer bugs than smart monkeys, but can also find important bugs that are hard to catch by smart monkeys

Advantages and disadvantages

[edit]

Advantages

[edit]

Monkey testing is an effective way to identify some out-of-the-box errors. Since the scenarios tested are usually ad-hoc, monkey testing can also be a good way to perform load and stress testing. The intrinsic randomness of monkey testing also makes it a good way to find major bugs that can break the entire system. The setup of monkey testing is easy, therefore good for any application. Smart monkeys, if properly set up with an accurate state model, can be really good at finding various kinds of bugs.

Disadvantages

[edit]

The randomness of monkey testing often makes the bugs found difficult or impossible to reproduce. Unexpected bugs found by monkey testing can also be challenging and time consuming to analyze. In some systems, monkey testing can go on for a long time before finding a bug. For smart monkeys, the ability highly depends on the state model provided, and developing a good state model can be expensive.[1]

Similar techniques and distinctions

[edit]

While monkey testing is sometimes treated the same as fuzz testing[5] and the two terms are usually used together,[6] some believe they are different by arguing that monkey testing is more about random actions while fuzz testing is more about random data input.[7] Monkey testing is also different from ad-hoc testing in that ad-hoc testing is performed without planning and documentation and the objective of ad-hoc testing is to divide the system randomly into subparts and check their functionality, which is not the case in monkey testing.

See also

[edit]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Monkey testing

View on Grokipedia
from Grokipedia
Monkey testing is an unstructured software testing technique in which random and unpredictable inputs are fed into a software application or system to evaluate its stability, robustness, and ability to handle unexpected scenarios, often revealing crashes, defects, or edge-case behaviors that structured testing might miss. This black-box method simulates erratic user interactions, such as random clicks, keystrokes, or data entries, drawing inspiration from the chaotic behavior of a monkey at a typewriter, as per the Infinite Monkey Theorem, which posits that random actions could eventually produce meaningful output. The origins of monkey testing trace back to 1983 at Apple, where engineer Steve Capps developed a desk accessory program called "" to stress-test early Macintosh applications like and under low-memory conditions by generating rapid, random events such as keystrokes and mouse movements. This approach gained wider prominence in the late 2000s with Google's release of the UI/Application Exerciser tool in 2008, designed specifically for automated random testing of Android applications to ensure reliability across diverse devices and user behaviors. Monkey testing is categorized into three primary types based on the level of tester knowledge and input sophistication: dumb monkey testing, which involves completely random actions without any understanding of the application, making it simple but less targeted; smart monkey testing, where inputs are randomized but guided by basic knowledge of the system's structure to focus on potential weak points; and brilliant monkey testing, which applies domain expertise to simulate realistic user errors in high-risk areas for more insightful results. These variants allow for varying degrees of chaos while aligning with testing goals, distinguishing monkey testing from more deliberate methods like ad-hoc testing (which relies on unstructured but informed exploration) or gorilla testing (intense, repetitive focus on specific modules). Among its key advantages, monkey testing excels at uncovering hidden bugs and improving system resilience with minimal planning and low cost, as it requires no predefined test cases and can be automated for efficiency in resource-constrained environments. However, it has notable drawbacks, including difficulty in reproducing defects due to the randomness, incomplete test coverage, and potential inefficiency without complementary structured testing, making it best suited as a supplementary technique in agile or regression phases rather than a standalone method. Common tools for implementing monkey testing include Android's built-in UI/Application Exerciser Monkey for generating pseudo-random streams of user events on devices or emulators, and MonkeyRunner, a Python-scriptable framework for more customized automation across multiple scenarios. These tools have evolved to support modern platforms, enabling QA teams to integrate monkey testing into pipelines for proactive defect detection in mobile and web applications.

Overview

Definition and Purpose

Monkey testing is an unstructured, randomized approach to in which automated scripts or tools generate unpredictable inputs to simulate erratic user interactions with an application or , aiming to expose defects that structured testing might overlook. This black-box technique involves randomly selecting from a wide array of inputs and actions, such as button presses or gestures, without any predetermined patterns or knowledge of the 's intended functionality. The primary purpose of monkey testing is to uncover hidden bugs, crashes, and anomalous behaviors by mimicking chaotic real-world usage scenarios that deviate from expected norms, thereby assessing the software's stability and resilience without relying on formal test cases. By introducing , it stresses the system to reveal vulnerabilities in edge cases or under unforeseen conditions, particularly in graphical user interfaces (GUIs) where user interactions are unpredictable. This method is especially valuable for exploratory purposes, allowing testers to probe for issues that scripted tests may not anticipate. Central to monkey testing are the principles of chaos and stochastic input generation, which prioritize system robustness over controlled validation, often applied in early development stages to identify foundational flaws before more systematic testing occurs. The technique's random nature helps simulate the variability of or misuse, providing insights into how software handles stress without requiring deep . The term "monkey testing" originates from the metaphorical image of a monkey randomly striking keys on a , symbolizing the haphazard and unintelligent input generation that characterizes the practice.

Historical Development

The concept of monkey testing traces its roots to the late 1970s, when the term was first introduced in Glenford J. Myers' seminal book The Art of Software Testing, describing a method of providing random inputs to software to uncover unexpected behaviors. This idea emerged amid early efforts in software reliability and during the 1980s, where ad-hoc random input simulation began to gain traction as a way to stress-test graphical user interfaces. A pivotal early occurred in 1983, when Apple developer Steve Capps created "," a desk accessory program for the Macintosh that generated pseudo-random keystrokes to rigorously test applications like and , ensuring robustness under chaotic user interactions. In the late 2000s, with the rise of mobile computing, the practice evolved from these manual and semi-automated origins into more structured tools. A key milestone came in 2008, when Google introduced the Android Monkey tool as a built-in utility within the Android SDK, designed to simulate random user events such as touches and gestures on mobile applications to identify crashes and stability issues. This marked a shift toward automated random testing in industry-standard development environments, building on the foundational principles from earlier decades. In the , monkey testing transitioned further from manual ad-hoc approaches to fully automated frameworks, influenced by the adoption of agile methodologies and practices that emphasized and rapid iteration. By the 2020s, integration into / () pipelines became widespread, allowing random input testing to run routinely as part of automated workflows to enhance software resilience. Open-source communities contributed significantly to this evolution, extending tools like to implement monkey-like random actions for testing. In the 2020s, monkey testing has further advanced with the integration of , enabling 'smart' random testing that combines chaos with targeted exploration to achieve higher coverage in complex applications. As of 2025, tools like AI-enhanced Monkey testers are increasingly used in mobile app and QA.

Types

Dumb Monkey Testing

Dumb monkey testing represents the most rudimentary variant of monkey testing, where inputs are generated entirely at random without any consideration for the application's , elements, or expected behaviors. In this approach, the tester or automated process operates in complete ignorance of the software's functionality, producing actions such as arbitrary key presses, mouse clicks, swipes, or data entries at fixed or variable intervals, solely to simulate chaotic user interactions. This unintelligent method ignores the current state of the application, making no distinction between valid or invalid inputs, which aligns with the core purpose of monkey testing to uncover defects through unpredictable chaos. The mechanism of dumb monkey testing relies on simple automated scripts or tools that continuously inject random events into the system without requiring preconditions or logical sequencing. These scripts typically run for prolonged durations, such as several hours or days, to stress the application and reveal issues like crashes, memory leaks, or unhandled exceptions that might not surface under controlled conditions. For instance, on a desktop application, the process might involve simulating rapid, haphazard keyboard inputs akin to "mashing" keys, while on mobile devices, it could generate erratic touch events across the screen without targeting specific buttons or fields. This testing subtype is particularly suited for preliminary sanity checks on newly developed builds, where comprehensive test suites are not yet available, or for legacy systems lacking up-to-date documentation and structured testing frameworks. It proves valuable in environments where the goal is to quickly identify gross stability flaws before investing in more sophisticated verification methods.

Smart Monkey Testing

Smart monkey testing enhances traditional monkey testing by integrating algorithmic intelligence to produce semi-random inputs that are informed by application models, user interface exploration, or prior crash data, thereby focusing efforts on more relevant interactions rather than unfettered randomness. This approach leverages partial knowledge of the system's structure or behavior to generate test sequences that are both unpredictable and purposeful, improving fault detection efficiency in graphical user interfaces (GUIs). Characteristics include adaptive action selection, state awareness to avoid infeasible paths, and prioritization of exploratory behaviors that mimic informed user actions while retaining an element of chaos. The mechanism of smart monkey testing involves techniques such as finite state machines (FSMs) to model application states and navigate screens through logical transitions, ensuring inputs align with valid workflows. Computer vision methods analyze screenshots for operable regions using saliency detection algorithms based on color, intensity, and texture features to identify clickable or interactive elements, confirming them via simulated events like taps or clicks. approaches, including with deep Q-networks, enable agents to learn from interactions by assigning rewards for novel states or penalties for repetitions, thus prioritizing high-risk actions that could lead to crashes. Hybrid strategies further blend these with random elements, appending unpredictable steps to model-driven sequences to uncover edge cases beyond scripted paths. Smart monkey testing finds application in targeted validation of complex software, particularly web and mobile applications featuring dynamic UIs where random inputs alone produce high noise and low . It excels in scenarios requiring efficient exploration of state spaces in resource-constrained environments, such as automated regression for consumer GUIs in appliances or games, reducing manual effort while increasing the likelihood of revealing latent defects. Examples include frameworks that infer state models from runtime observations to replay crash-inducing sequences learned across sessions, systematically covering untested branches via meta-heuristics like ant colony optimization. In mobile game testing, smart monkeys apply visual analysis to detect interactive zones in rendered scenes—such as buttons in selection menus or tappable tiles in rhythm games—generating coherent event chains that expose rendering or logic faults more effectively than blind randomness.

Brilliant Monkey Testing

Brilliant monkey testing is the most sophisticated variant of monkey testing, where testers with comprehensive and understanding of the application deliberately generate random inputs targeted at critical areas, simulating realistic user errors and complex interactions to uncover subtle defects and potential future issues. This approach goes beyond by leveraging human expertise to focus on high-risk functionalities, such as input validation in sensitive workflows or edge cases in user paths, ensuring higher test coverage and relevance. The mechanism involves informed , where the tester identifies key system components and introduces unpredictable but purposeful actions, like invalid data entries in critical sequences or erratic behaviors in high-traffic modules, to stress-test for hidden bugs that structured methods might miss. It is particularly effective for mature applications with intricate workflows, where nuanced testing can reveal issues arising from real-world usage patterns. For example, in a banking app, a brilliant monkey might simulate a user entering conflicting transaction details in a multi-step process to expose concurrency flaws. This subtype is best suited for final validation phases or security audits, complementing other testing strategies with its insightful, expertise-driven chaos.

Implementation

Tools and Automation

The primary tool for executing monkey testing on Android applications is the UI/Application Exerciser Monkey, a command-line utility that generates pseudo-random streams of user events such as clicks, touches, gestures, and system-level actions to stress-test apps for crashes, exceptions, and ANR errors. This tool operates directly on Android devices or emulators via the (ADB). For more advanced UI interactions that can be adapted to support smart monkey testing through custom scripting, the UI Automator framework provides APIs for external app testing, enabling scripted element interactions across Android versions. Cross-platform automation is facilitated by extensions in tools like , an open-source framework that simulates random user actions—such as taps, swipes, and text inputs—on both Android and apps, allowing monkey testing without platform-specific rewrites. Open-source alternatives include the legacy MonkeyRunner, a deprecated Python-based once used for that controls devices or emulators to send custom event sequences mimicking monkey behavior; modern alternatives like UI Automator are recommended instead. Automation in monkey testing often integrates with scripting languages like Python, where UI Automator's APIs allow developers to write custom scripts for event injection, app installation, and screenshot capture, extending basic random generation to reproducible sequences. Configuration options enhance control and repeatability, including event counts to limit the number of generated actions (e.g., 500 events), throttling to insert between events (e.g., 100ms intervals), and seed values to produce identical pseudo-random sequences for debugging. Setup typically involves ADB commands on connected hardware; for instance, the basic invocation adb shell monkey -p com.example.app 500 targets a specific package and generates 500 random events in verbose mode. The tool runs on both emulators, which simulate hardware for cost-effective local testing, and real devices, which provide accurate performance insights but require physical setup and battery management. As of 2025, cloud-based platforms enable scalable monkey testing across diverse device configurations. AWS Device Farm supports Android Monkey execution through custom test environments, allowing ADB-based runs on hundreds of real devices in parallel for comprehensive coverage. Similarly, Firebase Test Lab integrates monkey-like testing via its Robo tool, which performs intelligent UI exploration with random actions, and accommodates custom scripts on virtual and physical devices for automated, distributed runs.

Procedures and Best Practices

Monkey testing follows a structured to ensure systematic randomness while maximizing detection. The process begins with , where testers select a stable application build or version suitable for and configure the tool to target specific components, such as user interfaces or APIs, to focus the random inputs effectively. This step includes setting up the testing environment, such as emulators or physical devices, to simulate real-world conditions without interfering with production systems. During execution, the test session is initiated by defining parameters like the duration or number of events—typically ranging from hundreds to thousands—to generate random user interactions, such as taps, swipes, or data inputs. For instance, leveraging tools like the Android Monkey can automate this phase by injecting pseudo-random events into the application while running on a device or . Testers monitor the session in real-time through logs to capture responses, ensuring the application remains responsive under erratic inputs. Sessions should be throttled to allow of behaviors, preventing overwhelming the too quickly. Analysis occurs post-execution, involving a thorough review of crash reports, error logs, and performance metrics to identify failures like unhandled exceptions or memory leaks. Issues are reproduced manually where possible to verify legitimacy and prioritize based on severity, such as those causing application termination. This phase emphasizes documenting anomalies with screenshots or traces to facilitate by developers. Best practices enhance the reliability and traceability of monkey testing. Combining it with comprehensive logging captures event sequences and system states, aiding in post-test investigations. Using seeds for random number generation ensures repeatable test runs, allowing teams to recreate specific failure scenarios for deeper analysis. Limiting the scope to defined modules or workflows prevents infinite loops or resource exhaustion, while integrating monkey sessions into regression testing suites maintains ongoing quality checks without disrupting structured tests. For monitoring and termination, establish criteria such as event thresholds (e.g., 1,000 interactions) or stability metrics like absence of crashes over a set period to decide when to end a session. Real-time oversight helps detect patterns, and handling potential false positives—such as non-reproducible glitches—requires manual verification to avoid unnecessary efforts. Scaling monkey testing involves running parallel sessions across multiple devices or environments to cover diverse configurations, such as different operating system versions or screen sizes, thereby increasing coverage efficiency. Automating report generation, for example, using frameworks like , streamlines the aggregation of results from concurrent runs, enabling quicker insights into application robustness.

Evaluation

Advantages

Monkey testing stands out for its low-cost implementation and rapid setup, as it bypasses the need for designing detailed test cases or scripts, enabling testers to deploy random input generation tools with minimal preparation. This approach leverages built-in utilities like the Android UI/Application Exerciser , which can be initiated via simple command-line instructions without extensive configuration, making it accessible even for preliminary evaluations. One of its primary strengths lies in detecting edge-case defects that scripted tests often miss, such as race conditions triggered by concurrent random events or UI glitches arising from unexpected user interactions. By generating pseudo-random streams of touches, gestures, and key presses, monkey testing stresses the application in ways that mimic erratic real-world usage, exposing stability issues like unhandled exceptions and navigation errors that conventional methods overlook. In terms of efficiency, monkey testing achieves broad coverage of user-like interactions in a short timeframe, often crashing applications within an average of 85 seconds while attaining levels (at class, method, block, and line granularity) that rival or exceed manual exploration by just 2-3%. This makes it ideal for smoke testing newly developed features or validating stability after code modifications, as it quickly identifies crashes and responsiveness faults without prolonged execution. Empirical evaluations confirm its high effectiveness, with studies reporting detection of robustness errors in vulnerable Android applications at rates that strongly recommend its routine use. As a complementary technique, monkey testing enhances human-led testing by introducing unpredictable behaviors that simulate diverse user scenarios, thereby promoting earlier identification of latent bugs in agile development cycles. comparing it to shows that monkey tools generate comparable event coverage while triggering a higher proportion of system-level events (up to 99% in some apps), which aids in uncovering issues beyond structured paths. This integration fosters more robust without replacing targeted verification.

Disadvantages

Monkey testing's random nature often leads to unpredictable outcomes, making it difficult to reproduce bugs consistently. Studies on Android GUI testing have shown that Monkey's replay functionality succeeds in reproducing crash bugs only about 36.6% of the time, primarily due to issues like event injection failures, ambiguity in targeting UI elements, delays in data or widget loading, and variations from dynamic content. This lack of complicates , as testers cannot reliably recreate the exact sequence of random events that triggered a failure. Additionally, the approach generates significant noise through irrelevant crashes and false positives, which demands substantial time for and analysis to distinguish actionable defects from benign anomalies. The technique also exhibits notable coverage gaps, failing to detect logical errors, security vulnerabilities, or other issues that require structured or domain-specific inputs. For instance, Monkey struggles with event dependencies, deep navigation in complex applications, and user-specific interactions, often achieving less than 50% in analyzed apps. It is particularly unsuitable for data-intensive systems or applications with intricate workflows, where random inputs rarely exercise critical paths or validate effectively. Monkey testing imposes high resource demands, including intensive computational loads for extended runs, which can exceed 18 hours per session with inefficient exploration patterns. Interpreting the resulting outputs poses further challenges, as the absence of structured logs or patterns requires specialized expertise to sift through voluminous, erratic data without clear insights. Due to these limitations, pure monkey testing typically uncovers only 10-20% of potential defects, as reported in industry analyses of random input strategies, necessitating its combination with systematic testing methods for comprehensive validation. Empirical evaluations confirm low overall effectiveness, with average line coverage around 19.5% and activity coverage at 10.3% across tested applications.

Comparisons

Fuzzing is an automated technique that supplies invalid, unexpected, or random data to a program's inputs to identify defects, crashes, or vulnerabilities. While often targets APIs or backend components with malformed data, it shares the core objective of monkey testing in employing randomness to uncover unexpected behaviors, though monkey testing typically emphasizes interactions and actions rather than purely data inputs. Exploratory testing involves human testers conducting unscripted sessions to investigate software functionality, learning about the system while simultaneously designing and executing tests based on observations. This approach resembles manual variants of monkey testing in its ad-hoc, unstructured nature, but relies on the tester's expertise and intuition for guidance, making it less purely random and more adaptive than automated monkey testing. Stress testing evaluates a system's stability and by subjecting it to extreme workloads, such as high volumes of inputs or resource demands, to observe behavior under pressure. It overlaps with monkey testing in generating chaotic conditions to reveal robustness issues, yet employs more controlled and measurable overload scenarios compared to the unguided randomness of monkey inputs. Other related variants include grey-box testing, which incorporates partial knowledge of internal structures to generate semi-random inputs with some intentional structure, bridging black-box randomness and white-box precision. Property-based testing, as implemented in tools like QuickCheck for languages such as , automates the generation of diverse random inputs to verify high-level properties of code, providing a structured form of randomness that aligns with monkey testing's exploratory spirit but focuses on formal specifications.

Key Distinctions

Monkey testing fundamentally differs from scripted testing in its lack of predefined test cases and sequences, instead relying on automated generation of random user events to explore the () without manual scripting. Scripted testing, by contrast, involves effort-intensive creation and maintenance of explicit test scripts to verify specific functionalities, often struggling to adapt to GUI changes or uncover unforeseen defects. This serendipitous approach in monkey testing complements scripted methods by revealing unscripted issues, such as unexpected crashes from erratic interactions, that structured verification might overlook. In comparison to , monkey testing emphasizes random end-user interface actions—like clicks, touches, and gestures—targeted at GUI elements to stress application stability, whereas primarily corrupts input data streams (e.g., files or network payloads) to probe backend robustness against malformed inputs. For instance, tools like the Android Monkey generate pseudo-random UI events to simulate user behavior, achieving low crash rates in UI mutations (0.05%) but differing from intent-based that targets deeper system calls. This UI-centric randomness in monkey testing makes it particularly suited for detecting interface-specific failures, while excels in exposing data-handling vulnerabilities. Monkey testing contrasts with by applying broad, system-level chaos across the entire application rather than isolating individual code components for targeted, white-box examinations. focuses on verifying specific functions or modules in controlled environments to catch logic errors early, often requiring developer knowledge of internals. In monkey testing, the emphasis on random GUI exploration uncovers integration defects and emergent behaviors at the application level, such as unhandled exceptions from event sequences, that unit tests cannot replicate due to their narrow scope. Monkey testing holds a unique niche in stressing UI/UX components of consumer applications, where simulating unpredictable user interactions reveals stability issues in real-world scenarios like mobile apps. It thrives in environments with rich, clickable interfaces but is less effective for backend logic validation, where formal methods like unit or provide more precise coverage. This positions monkey testing as an exploratory complement to structured techniques, ideal for early detection of UX-related crashes in dynamic, user-facing systems.

References

  1. https://www.browserstack.com/guide/what-is-monkey-testing
  2. https://www.geeksforgeeks.org/software-testing/monkey-software-testing/
  3. https://tryqa.com/what-is-monkey-testing-advantages-and-disadvantages/
  4. https://hackaday.com/2025/04/05/a-look-inside-macpaint/
  5. https://www.testrail.com/blog/monkey-test/
  6. https://www.astqb.org/documents/Glossary-of-Software-Testing-Terms-v3.pdf
  7. https://ieeexplore.ieee.org/document/8364659/
  8. https://dl.acm.org/doi/10.1145/3387905.3388609
  9. https://onlinelibrary.wiley.com/doi/full/10.1002/stvr.1771
  10. https://www.testbytes.net/blog/monkey-testing/
  11. https://www.solespire.com/articles/exploring-monkey-testing-meaning-and-importance/
  12. https://www.lambdatest.com/learning-hub/monkey-testing
  13. https://www.browserstack.com/guide/monkey-testing-with-webdriverio
  14. https://blog.ostorlab.co/dast-ai-monkeytester-prompt-based.html
  15. https://www.qatouch.com/blog/monkey-testing/
  16. https://testsigma.com/blog/monkey-testing/
  17. https://muuktest.com/blog/monkey-testing
  18. https://ieeexplore.ieee.org/document/5069051
  19. https://dl.acm.org/doi/10.1145/3121245.3121247
  20. https://www.cs.cityu.edu.hk/~wkchan/papers/qrs2016-sun+zhang+jiang+wkchan.pdf
  21. https://developer.android.com/studio/test/other-testing-tools/monkey
  22. https://developer.android.com/training/testing/ui-automator
  23. https://developer.android.com/studio/test/monkeyrunner
  24. https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types-android-tests.html
  25. https://firebase.google.com/docs/test-lab/android/robo-ux-test
  26. https://dl.acm.org/doi/10.1145/3194733.3194742
  27. https://www.researchgate.net/publication/335996671_An_Empirical_Study_on_the_Effectiveness_of_Monkey_Testing_for_Android_Applications
  28. https://chapering.github.io/pubs/lctes19.pdf
  29. https://dl.acm.org/doi/10.1007/978-981-99-8664-4_8
  30. https://ieeexplore.ieee.org/document/9286135/
  31. http://taoxie.cs.illinois.edu/publications/ishcs16-getreal-taoxie.pdf
  32. https://pdfs.semanticscholar.org/bb4d/2d2513fb27b6d164b433a917fe8c86ebe937.pdf
  33. https://stackoverflow.com/questions/10241957/difference-between-fuzz-testing-and-monkey-test
  34. https://www.satisfice.com/exploratory-testing
  35. https://sqa.stackexchange.com/questions/14490/difference-between-exploratory-testing-monkey-testing-and-ad-hoc-testing
  36. https://sre.google/sre-book/testing-reliability/
  37. https://www.browserstack.com/guide/types-of-testing
  38. https://testar.org/wp-content/uploads/2021/09/stvr.1771.pdf
  39. https://engineering.purdue.edu/dcsl/publications/papers/2018/final_android-wear-robustness_dsn18_cameraready.pdf
  40. https://ieeexplore.ieee.org/document/7515500
  41. https://dl.acm.org/doi/10.1145/3316482.3326342
Add your contribution
Related Hubs
User Avatar
No comments yet.