Skip to content
Tutorials Center
My learning

Topics

Lesson 40 of 60 ยท Manual Testing in Practice

Mobile App Testing Basics

Learn what makes mobile testing different: interruptions, permissions, flaky networks, gestures, battery, store rules, and real devices versus emulators.

A phone is not a small computer on a desk. It rings in the middle of a payment, loses signal in a lift, runs out of battery at 5%, gets rotated, locked, unlocked, and pushed into the background twenty times a day. People use mobile apps with one thumb, on the move, with an unreliable network. A product that works perfectly on a developer's laptop can fall apart under those everyday conditions.

Mobile testing is the discipline of checking an app (native, hybrid or a mobile website) under those real conditions. Most of what you already know still applies: test design, bug reports, regression. What changes is the environment, and the list of things that can go wrong. This lesson covers the mobile-specific areas and shows two stand-ins for planning them. It builds on the ideas in Compatibility and Localization Testing and Web UI, Usability and Accessibility Checks.

What is different on mobile

Interruptions Calls, alerts and app switching.
Networks Weak, slow, offline, changing.
Resources Battery, memory, storage, heat.
Touch Gestures, rotation, small screens.
1 / 2

Real devices, emulators and simulators

You will hear three words, and the differences matter.

  • An emulator (the usual term for Android) imitates a phone's hardware in software, and a simulator (the usual term for iOS) imitates only the software environment on your computer. Both are quick to start, free, and good for screen sizes, many OS versions and early development.
  • A real device is a physical phone or tablet. It is the only way to see true performance, battery use, sensors, camera quality, real mobile networks, manufacturer customizations and the feel of touch.
  • A device farm is a cloud service that rents you access to many real devices remotely.

A sensible plan uses both: emulators and simulators for breadth and daily work, real devices for the final confidence, for performance and for anything that touches hardware. Choose your real devices from your users' data: the most popular models, the oldest supported OS version, and one low-end phone, because slow hardware reveals performance defects early.

Interruptions

An app rarely owns the screen alone. Things that interrupt it, and that you must try while the app is in the middle of something important:

  • Incoming phone call, text message or notification, and answering or declining them.
  • Switching to another app and coming back after seconds, minutes or hours (the system may have closed your app in the meantime).
  • Screen lock and unlock, rotation, and the system dialog for a low battery.
  • Alarms, calendar reminders, a change of volume and plugging in headphones.
  • Losing or regaining the network, and switching between Wi-Fi and mobile data.
  • A system update or an app update arriving while the app is open.

The test question is always the same: does the app recover with the user's data intact? A half-completed checkout form should still be filled in; an upload should resume or fail gracefully; a video should pause.

The first stand-in builds an interruption matrix, the cross product of the situations a user can be in and the interruptions that can happen, and picks the risky cells. It demonstrates the planning idea; real testing then performs these checks on devices.

JS Build an interruption matrix

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Two states and six interruptions already give twelve high-risk checks, and the list grows fast. This is exactly the combinatorial explosion that risk-based testing and pairwise testing help you tame: weight the states by the cost of losing data, run the heavy ones every release and sample the rest.

Permissions

Mobile operating systems ask the user before an app uses the camera, location, contacts, microphone, notifications or photos. Each permission has several states, and each must be tested:

  • Granted: the feature works.
  • Denied once: the app explains why it needs the permission and lets the user try again, without nagging.
  • Denied permanently: the app does not crash or show a blank screen, and points to the system settings if it truly needs the permission.
  • Revoked later: the user switches it off in the settings while the app is closed. The next launch must cope.
  • Partial: some systems allow "approximate" location or "selected photos only".
  • Never asked: the app should request a permission at the moment it is needed, with a short reason, and not on first launch.

The exact options and wording differ between Android and iOS and between OS versions, so test them on the versions you support.

Networks

Mobile networks are the opposite of a stable office connection. Check:

  • Offline: what is available? Does the app show a clear message, queue the action or crash?
  • Slow and lossy networks: spinners that never end, timeouts, duplicate submits after a retry.
  • Switching from Wi-Fi to mobile data in the middle of a request.
  • Roaming and data saver modes, and large downloads on a metered connection.
  • Airplane mode toggled during a payment or upload.

Network conditioners, developer settings and emulator controls can throttle speed and drop connections on purpose. The second stand-in is a simple model of what you want to see: a retry loop meeting changing network conditions, and a table of expected permission behavior. It is not a mobile app, but it shows the style of expected-result thinking you should write down before testing. The retry logic itself is covered in more depth in Reliability, Recovery and Disaster Testing.

JS Retries and permission expectations

Press Run (or Ctrl + Enter) to see the console output here.

No output.

A good manual test on a real device repeats the same idea: start an upload, turn on airplane mode, turn it off, and observe whether the user sees a clear message, whether the data is uploaded exactly once and whether the app stays usable throughout.

Gestures, screens and orientation

Touch brings its own checks:

  • Taps, double taps, long presses, swipes, pinch-to-zoom and pull-to-refresh behave as users expect, and conflicting gestures (a swipe inside a scrolling list) do not trigger the wrong action.
  • Buttons are large enough to tap and far enough apart to avoid mistakes.
  • Rotation keeps state, and the layout adapts to portrait and landscape.
  • Different screen sizes and densities, foldable phones, notches and rounded corners, and the on-screen keyboard that covers input fields.
  • Text size and display zoom set in the system settings.
  • Dark mode, and accessibility features such as the screen reader and larger text, as covered in Web UI, Usability and Accessibility Checks.

Battery, memory, storage and performance

Users blame the app when their phone gets hot or flat. Watch for:

  • Heavy battery drain in the background, for example constant location or polling.
  • Memory growth after repeated use, leading to the system killing the app.
  • Slow start-up, janky scrolling and dropped frames on low-end phones.
  • Behavior with full storage: does saving fail with a message or crash?
  • App size and data usage on a limited mobile plan.

Developer tools on each platform measure battery, memory and frame rate, and testers can also compare "before and after" for the same flow.

Installation, updates and store rules

The life of a mobile app includes steps a website never has:

  • Install and first launch: the first-run experience and permission prompts.
  • Upgrade: installing the new version over an old one keeps user data and settings. Test upgrades from several older versions, not only the previous one.
  • Uninstall and reinstall: leftover data, or sign-in states that behave oddly.
  • Store review: app stores check apps against their guidelines before publishing, covering privacy disclosures, permissions, in-app purchases and content. Rules change, so read the current guidelines of each store and treat review as a release step with its own delay. Rejections are a risk to schedule.
  • Staged rollouts: releasing to a small percentage of users first, and being able to stop it.
  • Deep links, push notifications and in-app purchases, which depend on the platform and on backends that testers should check end to end.

Keep a short "mobile smoke test" you can run on every device in ten minutes: install, launch, sign in, one key flow, background and foreground, rotate, kill the app and reopen it. Run it first, and you will find the worst problems before deeper testing begins.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. Why is a real device still needed even if emulators work well?

    Emulators are great for breadth and speed, but hardware-related and performance issues often appear only on real devices.
  2. 2. A user fills in a long checkout form and takes a phone call. What should be true afterwards?

    Interruption tests check that the app resumes with the user's work preserved.
  3. 3. A user denies the camera permission permanently. What is the best expected behavior?

    Apps must handle a refused permission gracefully, explaining the impact and guiding users to change their choice if needed.
  4. 4. Which test is specific to installed mobile apps?

    Upgrade paths, store distribution and installation are part of the mobile app lifecycle. The others apply to web or API testing as well.
  5. 5. How should you choose which real devices to buy for testing?

    Real-world usage data and risk decide coverage. Low-end and older devices expose performance and compatibility problems early.

Summary

  • Mobile testing adds interruptions, unreliable networks, permissions, touch and limited resources to ordinary testing.
  • Emulators and simulators give breadth and speed; real devices (or a device farm) give truth about hardware and performance.
  • Test whether the app recovers with data intact after calls, app switches, locks and lost connections.
  • Test every permission state, including denied, permanently denied and revoked later.
  • Check gestures, rotation, screen sizes, battery, memory, storage and start-up speed.
  • Plan for installs, upgrades, store review and staged rollouts, and keep a ten-minute mobile smoke test.

Next up: Performance, Load and Stress Testing.