Mobile App Testing — A Complete Guide

What is Mobile Testing?

Mobile testing is the process of evaluating the functionality, usability, performance, and compatibility of mobile applications and websites on various mobile devices — including smartphones and tablets. It covers both the software layer (apps and OS) and hardware interactions (sensors, cameras, radios).

Types of Mobile Applications

Before testing, you need to know what type of app you're testing — because each has different risk areas and tools.

Android Build Types

In Android development, a build is the compiled version of the application. There are three standard build types, each with a different purpose in the testing and release pipeline:

Variant Testing — HVT, DVT, EVT, PVT

In Android hardware product development (devices, IoT, smart TVs etc.), four types of variant testing are performed at different stages of the product lifecycle:

Mobile-Specific Test Types

Beyond standard functional testing, mobile apps require a set of specialised test types that address unique mobile risks:

Installation & Update Testing

Interruption Testing

Mobile devices are constantly interrupted. Your app must handle all these gracefully — pausing, resuming, and maintaining state correctly:

• Incoming phone call while app is running — does the app pause and resume correctly?
• SMS / notification received — does the notification overlay cause UI issues?
• Low battery warning — does the app save state before power off?
• Network disconnection — does the app show the right error and recover when connectivity returns?
• Home button press — does the app correctly background and resume from the same state?
• Orientation change (portrait ↔ landscape) — does the app handle rotation without crashing or losing data?

Power Consumption & Memory Testing

Security & Compliance Testing

• Security Testing: Validate authentication (login, token expiry), authorisation (user can only see their data), data encryption in transit (HTTPS/TLS) and at rest (local storage)
• Vulnerability Testing: Identify weaknesses in the app that could be exploited — hardcoded credentials, insecure API endpoints, exposed debug logs
• Compliance Testing: Verify the app meets defined standards — GDPR for data privacy, WCAG for accessibility, carrier certification requirements for telecom apps
• Certification Testing: Required for apps distributed through carrier channels — verifies the app meets licensing and store submission standards

Compatibility, Localisation & Globalisation

Mobile App Performance Testing

Functional correctness is the baseline — the app does what it is supposed to do. Performance is the layer that determines whether users actually keep using it. A functionally correct app that takes 8 seconds to launch, drops frames during scrolling, and drains 20% battery in an hour will generate one-star reviews and uninstalls. On mobile, performance is not an optional quality attribute — it is a core user expectation.

Why Mobile Performance Is Uniquely Challenging

Mobile devices operate under constraints that desktop and server environments simply do not have. Battery is finite and users are acutely aware of apps that drain it. Memory on mid-range and low-end Android devices can be as little as 2–3 GB, shared across the OS, background services, and all running apps — leaving your app a narrow budget. CPUs on budget devices run at a fraction of the clock speed of a Pixel 9 or iPhone 15, meaning performance that feels fine on a flagship may feel unusable to the majority of your users. Network payloads that seem small on desktop become expensive on metered 4G connections where users pay per megabyte. Performance testing must account for all of these real-world constraints, not just lab conditions on premium hardware.

Key Mobile Performance Metrics

The following metrics form the core of any mobile performance test plan. Cold start time measures how long the app takes to launch from a completely stopped state — no cached state in memory. Warm start measures the same launch when the app was recently in the background and its process is still alive. The target for cold start is under 2 seconds; warm start should be under 1 second. Frame rate targets 60 frames per second for smooth scrolling and animations — any dropped frame is visible to the user as jank. Memory usage is tracked as the heap grows over an extended session: a healthy app will plateau; a memory leak will produce a heap that grows continuously until the OS kills the process. CPU usage should return to near-zero when the app is idle. Battery drain rate is expressed as percentage per hour under a defined usage scenario. Network payload size — the total bytes transferred per user session — matters both for performance on slow connections and for mobile data costs.

Tools for Measuring Mobile Performance

Android Studio's built-in Android Profiler provides real-time graphs for CPU, memory, network, and energy usage. You can record a session, interact with the app, and then inspect frame-by-frame what caused a spike. On iOS, Xcode's Instruments tool offers equivalent profiling with specialised templates for Time Profiler, Leaks, and Energy Log. Firebase Performance Monitoring provides production-grade telemetry — cold start times, screen render times, and network request latency measured from real user devices in the field, not just from your lab. This is particularly valuable because it captures the performance your actual users experience, not the performance your test device delivers.

ADB Commands for Performance Investigation

For Android, the Android Debug Bridge provides direct access to performance data without needing a GUI profiler. The command adb shell dumpsys meminfo <package> prints a detailed memory breakdown for a specific app — total PSS, Java heap, native heap, and code memory. adb shell top shows live CPU usage per process, equivalent to a mobile task manager. adb shell dumpsys batterystats dumps the device's complete battery usage history, including which apps are holding wake locks — a common cause of unexpected background battery drain. These commands are fast to run and work without any additional tooling, making them ideal for quick triage during test execution.

Common Mobile Performance Bugs

Memory leaks manifest as a heap that never stops growing. The symptom is an app that becomes progressively slower over a 30 to 60 minute session and eventually crashes — reproducible by watching the memory profiler while performing the same actions repeatedly. ANRs (Application Not Responding) occur when the main thread is blocked for more than 5 seconds — typically caused by network calls or database queries running on the UI thread instead of a background thread. Jank is any dropped frame — visible as stutter during scrolling or animation — usually caused by expensive operations running during a frame render. Excessive wake locks prevent the CPU from entering low-power sleep states, draining battery even when the screen is off and the user is not interacting with the app.

Performance Testing Workflow

The standard workflow is: establish a baseline measurement under a defined scenario (fresh install, standard user journey, consistent device and network conditions), run a stress test (extended session, heavy data load, or constrained memory), measure again under the same conditions, then compare the two sets of metrics. Any regression — a cold start that increased by 500ms, a memory footprint that grew by 30MB, a battery drain rate that doubled — is a performance defect that should be raised and triaged just like a functional bug.

References

• Android Developer Documentation — Build Variants: developer.android.com/build
• ISTQB Mobile Application Testing Specialist Syllabus
• Appium Documentation — appium.io
• Cohn, M. — Succeeding with Agile, Addison-Wesley (mobile testing chapters)
• Google Play Developer Policy Center — play.google.com/about/developer-content-policy