[Paper] FuncDroid: Towards Inter-Functional Flows for Comprehensive Mobile App GUI Testing

Source: arXiv - 2602.12834v1

Overview

Mobile apps are getting richer and are updated faster than ever, which makes thorough GUI testing a moving target. The paper FuncDroid: Towards Inter‑Functional Flows for Comprehensive Mobile App GUI Testing tackles a blind spot in existing tools: they test individual screens or features in isolation and miss bugs that arise when one functional component triggers another. By modeling and exercising inter‑functional flows, the authors deliver a testing approach that finds deeper, harder‑to‑detect defects while keeping the testing effort manageable.

Key Contributions

• Functional Flow Graph (FFG) – a novel behavioral model that explicitly represents each functional unit (e.g., login, payment) and the directed interactions between them.
• Long‑Short‑Term‑View‑Guided Testing – a dual‑view test‑generation strategy that alternates between a long‑term view (exploring high‑level functional sequences) and a short‑term view (fine‑grained widget interactions) to refine functional boundaries on the fly.
• FuncDroid Tool – an end‑to‑end prototype that automatically builds the FFG from an app’s UI hierarchy and executes inter‑functional test cases without manual scripting.
• Empirical Evaluation – experiments on 50 open‑source crash bugs and 52 popular commercial apps show a 28 % boost in coverage and a 107 % increase in detected bugs versus state‑of‑the‑art baselines, plus 18 previously unknown functional bugs uncovered in real‑world apps.

Methodology

1. Static & Dynamic Analysis to Identify Functional Units

   • The system first parses the app’s layout files and bytecode to locate entry points (e.g., activities, fragments) that correspond to distinct functionalities.
   • Runtime traces are collected during an initial “exploratory crawl” to confirm these units and discover how they transition (e.g., a “Share” button launching a new activity).

2. Constructing the Functional Flow Graph (FFG)

   • Nodes = functional units.
   • Directed edges = observed transitions (user actions, intents, callbacks).
   • Edge weights capture the frequency and context (e.g., “only after successful login”).

3. Long‑Short‑Term View‑Guided Test Generation

   • Long‑Term View: treats each node as a macro‑action, generating sequences that traverse multiple nodes to exercise inter‑functional paths (e.g., Login → Browse → Add‑to‑Cart → Checkout).
   • Short‑Term View: within a node, performs fine‑grained widget interaction (clicks, swipes, text entry) to ensure the functional unit itself is robust.
   • The two views feed each other: failures or low coverage in the short‑term view trigger the long‑term view to revisit or reorder functional sequences, and vice‑versa.

4. Adaptive Refinement

   • As tests run, FuncDroid monitors UI state changes and automatically splits or merges nodes when it detects that a previously single functional unit actually contains distinct sub‑behaviors.

5. Bug Detection & Reporting

   • Crashes are captured via Android’s logcat.
   • Non‑crash functional bugs (e.g., incorrect data propagation across screens) are flagged by invariant checks (state consistency, expected UI text, API response validation).

Results & Findings

• Depth matters: 70 % of the newly found bugs only manifested after traversing three or more functional units, confirming the importance of inter‑functional flow testing.
• Adaptive refinement reduced false positives by 23 % compared with a static‑graph approach, because the FFG evolved to match the app’s real runtime behavior.
• The tool’s overhead remained modest (average test suite execution time grew by only 1.4× over a pure short‑term tester) thanks to the targeted long‑term exploration.

Practical Implications

• For QA Teams: FuncDroid can be integrated into CI pipelines to automatically generate high‑level functional scenarios, catching bugs that would otherwise slip through manual regression suites.
• For Developers: The generated FFG offers a visual map of how app features interact, helping spot unintended coupling early in the design phase.
• For Test Automation Engineers: The dual‑view strategy can be adopted in existing frameworks (e.g., Espresso, Appium) to augment script‑based tests with systematic inter‑functional coverage without writing extra code.
• For Product Managers: The ability to surface hidden functional bugs before release reduces post‑launch hot‑fixes, improving user satisfaction and lowering support costs.

Limitations & Future Work

• Static UI Extraction: FuncDroid relies on the availability of layout resources; heavily obfuscated or dynamically generated UI (e.g., via WebView‑based hybrid apps) may lead to incomplete FFGs.
• Scalability to Very Large Apps: While the adaptive refinement mitigates state explosion, apps with thousands of functional units could still cause combinatorial blow‑up in long‑term path generation.
• Bug Oracle Scope: Current non‑crash bug detection uses generic invariants; domain‑specific checks (e.g., financial transaction correctness) would need custom plugins.

Future research directions include extending the approach to cross‑app interactions (e.g., deep links between separate apps), incorporating machine‑learning‑guided path prioritization, and building language‑agnostic adapters for non‑Android mobile platforms.

FuncDroid demonstrates that looking beyond isolated screens and embracing the full functional choreography of a mobile app can dramatically improve testing effectiveness—an insight that’s likely to shape the next generation of automated GUI testing tools.

Authors

• Jinlong He
• Changwei Xia
• Binru Huang
• Jiwei Yan
• Jun Yan
• Jian Zhang

Paper Information

• arXiv ID: 2602.12834v1
• Categories: cs.SE
• Published: February 13, 2026
• PDF: Download PDF