Introducing Test Nexus: Your All-in-One Android Testing Companion

New to testing? Start with our Beginner’s Guide to Android Testing — a no-jargon introduction to testing your app like a professional.

You’re three hours into testing a payment flow. Your browser has four tabs open — one with a Luhn-validated Visa number you generated from some random website, one with an Australian address you copied from Google Maps, one with a fake phone number you’re not even sure is in the right format for Melbourne. On your phone, you’ve got Fake GPS running to spoof your coordinates to Sydney, but it keeps resetting every time you switch apps. And then the app crashes. You tap over to Logcat, scroll through 10,000 lines of log noise, find the stack trace, screenshot it, paste it into a Slack message to yourself, then open it on your laptop to actually read it.

That’s one country. You have three more to test today.

This is what Android testing looks like when your toolkit is six disconnected apps, a browser, and a lot of patience. Test Nexus was built because this workflow is broken, and the people doing the actual testing — you — shouldn’t have to be the glue holding it together.

Test Nexus is a single Android application that puts test data generation, AI-powered custom forms with autofill, GPS simulation, crash monitoring, and a full SSH terminal on the same device you’re already testing on. No laptop. No browser tabs. No copy-paste chains. You generate a test identity, autofill it into your app, set a mock location, start monitoring for crashes, and begin testing — all without leaving the app.

This post walks through every module, explains exactly what each one does, and shows you how they connect so you can run a complete multi-country QA session from one device.

Six Tools, Six Friction Points

Before we get into what Test Nexus does, let’s be honest about what the current workflow actually looks like. If you’re testing location-sensitive features across multiple countries, here’s the reality:

1. 📊 Test Data Website → “Card numbers only. No matching addresses. Wrong phone format. No batch export.”
2. 📋 Copy-Paste Into Your App → “Generate data in one app. Switch to your app. Type it in field by field. Repeat 50 times.”
3. 📍 GPS Spoofer App → “Resets on app switch. No route simulation. No speed profiles.”
4. 💥 Logcat / ADB → “10,000 lines of noise. Find the stack trace yourself. Need a laptop and USB cable.”
5. 🖥️ Terminal App → “Separate app. No saved connections. No testing context.”

The actual pain isn’t that these tools are bad. Most of them work fine individually. The problem is that every time you switch between them, you lose context. You copy a card number wrong. You forget which country’s address format you need. You miss a crash because you were in another app when it happened. The friction is in the transitions, not the tools themselves.

One App, Same Device

Test Nexus replaces each of those pain points with a dedicated module — all sharing the same data layer, same device, same session.

All six modules share the same local database and the same AI engine. When DataHub generates a test profile with an Australian address, Mock Location can use those coordinates directly. When you create a custom form and generate data with AI, the Autofill system can inject that data into whatever app you’re testing. The modules aren’t just colocated — they’re connected. And that shared database is AES-256 encrypted on your device, protected by Android’s hardware-backed Keystore — your test data never leaves the phone and is unreadable without the encryption keys.

IDs & Cards: Individual Validation and Generation

Replaces: Looking up ID format rules manually, using separate sites for credit card vs. national ID generation.

While DataHub is built for batch profile generation, IDs & Cards is your standalone toolkit for individual data validation and generation. It supports 56 distinct data types with real-time feedback and animated interactions.

Validate or Generate

Enter any ID or card number to see instant validation. Test Nexus doesn’t just tell you if it’s “invalid” ΓÇö it provides specific error messages explaining why (e.g., “Invalid area number” or “Check digit does not match”). This is an essential tool for learning the internal logic of the IDs you’re testing.

Need a valid one? Tap generate to produce test data that satisfies even the strictest validation algorithms.

8 Card Brands and 34 National IDs

Unlike the DataHub subset, the standalone generator supports 8 payment card brands, including Discover, Diners Club, and Maestro. It also covers 34 national identification systems, from Italy’s complex Codice Fiscale to India’s Aadhaar (using the Verhoeff algorithm).

• Animated Card Flip: View payment card details on a virtual card that flips to show the CVV.
• Favorites: Save your most-used test IDs with custom labels for instant access.
• History: Browse your recent generations and copy all details (Number + Expiry + CVV) in one tap.
• Banking Identifiers: Generate or validate IBANs, SWIFT/BIC codes, ABA Routing numbers, and more.

IDs & Cards shares its validation engine with DataHub. For the full deep dive into format rules, batch generation, and country-specific algorithms, see Post #02 and Post #07.

DataHub: Stop Copy-Pasting Test Card Numbers

Replaces: Test data websites, manual spreadsheets, random generators with no export option.

You know the drill. You need a Visa number for testing, so you Google “test credit card number generator,” find some website, copy a number, manually type it into your app, then realize you also need a matching expiry date and CVV that the website didn’t give you. Then you need a Brazilian CPF number, but now you’re on a different website with a different format. Then you need 50 of them for batch testing, and there’s no export option.

DataHub generates all of this in one place.

What It Generates

Every piece of data follows the real format rules. Card numbers pass Luhn validation. Brazilian CPFs use the correct check digit algorithm. Phone numbers match the country’s actual format.

The supported categories include:

Payment cards — 5 card brands: Visa, Mastercard, Amex, JCB, and UnionPay. Each generated with valid prefix (BIN range), correct length, Luhn-valid check digit, matching expiry date, and CVV.

National IDs — Country-specific identification numbers with valid check digits where applicable. When you select Brazil as your target country, DataHub generates CPF numbers using the actual CPF algorithm. Select India and you get properly formatted Aadhaar numbers. Country-specific IDs are supported for 38 countries.

Country-specific profiles — When you select a country, DataHub pre-populates culturally appropriate names, addresses in the correct local format, and phone numbers matching that country’s numbering plan. A Brazilian profile gives you a Brazilian name, an address in the correct Brazilian format with CEP postal code, and a +55 phone number with the right area code and digit count.

Batch Generation

When you need more than one profile, DataHub supports batch creation. Specify the country and the quantity. DataHub generates them in a single operation and lets you export the entire set as JSON, CSV, XML, or TSV — ready to pipe into your automated test scripts, seed a database, or import into Postman.

The full deep dive into country-specific format rules, batch generation, and export options is in Post #02.

AI Custom Forms + Autofill: Define Any Schema, Generate Data, Inject It

Replaces: Copy-pasting generated data field by field into the app you’re testing.

This is the feature that no other test data tool offers, and it solves a friction point that most developers don’t even realize they’ve accepted: the physical act of getting test data from a generator into the app under test.

Here’s the typical workflow without this feature: you generate a test profile somewhere, switch to your app, tap the first name field, switch back, copy the name, switch to your app, paste, tap the email field, switch back, copy the email, switch to your app, paste. Repeat for every field, for every test iteration. For a 12-field registration form tested 10 times, that’s 120 copy-paste operations.

How It Works

Step 1: Define your form schema. In Test Nexus, describe the form you’re testing. This isn’t limited to predefined types like “credit card” or “address.” You can define any structure:

• A recipe form: name, description, origin country, prep time, ingredients, instructions
• A patient intake form: name, DOB, insurance ID, allergies, medications, emergency contact
• An e-commerce product listing: title, description, price, SKU, weight, category, shipping class
• A social media profile: display name, bio, location, website, interests

Step 2: AI generates realistic data. Tap generate, and Gemini AI fills every field with contextually appropriate sample data. Not “test123” and “lorem ipsum” — actual realistic content that matches the field type and makes sense together.

Step 3: Autofill injects it into your app. Switch to the app you’re testing, tap on the form, and Test Nexus uses Android’s Autofill Framework to fill the matching fields automatically. The data flows from Test Nexus into your app’s form without a single copy-paste.

Step 4: Repeat. Need another iteration with different data? Generate a new set and autofill again. Each generation produces unique data.

Why This Matters for QA

The autofill integration transforms test data generation from a separate tool into an integrated part of your testing flow. You’re not context-switching between a generator and your app — the generator pushes data directly into your app. This matters most during repetitive manual testing, where the data entry overhead can exceed the actual testing time.

The complete guide to setting up custom forms and autofill is in Post #05: AI Custom Forms + Autofill — Define Any Test Schema and Inject It.

Mock Location: Fake Your GPS Without Root or ADB

Replaces: Standalone GPS spoofer apps that reset on app switch and only support single-point teleportation.

If you’ve used Android’s mock location feature before, you know the setup: enable Developer Options, select a mock location provider app, install a GPS spoofer, and hope it doesn’t reset every time you switch to the app you’re testing. Most GPS spoofing apps do one thing — teleport you to a point. If you need to simulate movement (driving a delivery route, walking through a geo-fenced zone), you’re out of luck or fighting with clunky UIs.

Test Nexus Mock Location works through the same Android developer API — you enable it once in Developer Options, select Test Nexus as the provider, grant location access, and you’re done. But instead of dropping a pin and hoping for the best, it simulates realistic movement that location SDKs treat as genuine.

Intelligent Route Mode

Define a route with multiple waypoints. Test Nexus interpolates between them using a dedicated physics engine with realistic speed profiles:

• Walking — ~3 mph with natural gait variation
• Bicycling — ~10 mph with terrain-aware jitter
• Driving — Configurable (default 35 mph) with realistic braking and acceleration curves

The simulation generates GPS updates at realistic intervals, so location SDKs see natural-looking movement data instead of the teleporting artifacts that break geo-fence logic.

Road-Snapped Routing

Plan routes visually using the built-in map view. For city-level and inter-city routes, Test Nexus snaps your path to actual road geometry — the GPS stream follows real roads with turns, intersections, and realistic movement patterns instead of cutting straight lines through buildings.

ℹ️ A Note on Road Snapping Range
Road snapping works best for routes within a city or between nearby cities. For very long cross-country routes, the simulation may occasionally deviate from road geometry. For long-distance testing, break the route into shorter city-to-city segments for the most realistic results.

The full setup guide, including route configuration and speed profile details, is in Post #03: Mock Location Guide.

Deep Inspector: Crash Capture Without ADB

Replaces: Manually connecting ADB, filtering Logcat, and losing stack traces when you’re not watching.

Here’s what happens when an app crashes during your testing session without any monitoring: the app closes, you wonder what happened, and the stack trace is already gone from the Logcat buffer by the time you connect a USB cable. Even if you had Logcat running, you’d be scrolling through 10,000 lines of system noise to find the FATAL EXCEPTION line.

Deep Inspector runs as a background service on your device. It captures logs from all apps, and actively monitors your selected apps for crashes, ANRs, and performance issues — capturing the full stack trace, context logs (50 lines before and 20 after), device state (memory, battery, network), and app context — automatically, without ADB, without a USB cable, without a laptop. The crash data is displayed directly in Test Nexus and ready for you to review.

What You Can Do With Captured Crashes

• Read the full stack trace on your device — no laptop needed to find the exception chain
• See the context — review the logs leading up to the issue to identify the trigger
• Copy to clipboard — paste directly into a Jira ticket, Slack message, or GitHub issue
• Export — download reports in Plain Text, JSON, CSV, or HTML for sharing with your team
• Review history — see all issues from the current testing session in chronological order

💡 Pro Tip: AI Analysis
While Deep Inspector doesn’t automatically analyze crashes with AI, you can copy the stack trace and paste it into any AI assistant (including Gemini, which powers other Test Nexus features) for root cause analysis and fix suggestions. We’re exploring in-app AI crash analysis for a future update.

The complete Deep Inspector walkthrough, including how to use crash data for effective bug reports, is in Post #04: Crash Monitoring Without ADB — Capture Every Stack Trace Automatically.

Terminal: SSH Into Your Server Without Picking Up Your Laptop

Replaces: Separate terminal apps with no saved connections and no integration with your QA workflow.

You’re testing a payment flow on your phone. The transaction went through in the app, but did it actually hit the database? The normal workflow: put the phone down, open your laptop, SSH into the staging server, run a SQL query, check the result, pick the phone back up, continue testing.

With Test Nexus Terminal on the same device: swipe to Terminal, SSH into the server (your key is already saved), run the query, see the result, swipe back to testing. Zero context switch. Zero laptop.

Capabilities

• SSH — Full client with password and key-based authentication
• SFTP — Browse remote file systems, upload/download files
• Port Forwarding — Local and remote forwarding to access internal services through the SSH tunnel directly from your phone
• Script Execution — Run shell scripts on the remote server for test setup, data seeding, or environment cleanup

Connection profiles are saved locally, so reconnecting to your staging server takes a single tap.

The full Terminal feature guide, including SSH key management and port forwarding examples, is in Post #06: Test Nexus Terminal — Full SSH and SFTP From Your Android Device.

The Complete Workflow: One Device, Four Countries

Here’s the workflow that used to take six separate tools, a laptop, and a spreadsheet — now running entirely on one phone:

1. Generate Test Identity → DataHub → Select “Australia” → Generate full profile (name, Sydney address, AU phone number, Visa card)

2. Set Mock Location → Mock Location → Coordinates: -33.8688, 151.2093 (Sydney CBD) → All apps now think you’re in Sydney

3. Enable Crash Monitoring → Deep Inspector → Background service starts → Monitoring all apps

4. Fill Your App Automatically → AI Custom Forms + Autofill → Define your app’s form structure → Generate AI data → Autofill injects it into your app’s registration/payment form

5. Run Your Tests → Complete the transaction flow → If it crashes, Deep Inspector already captured the stack trace

6. Verify Server-Side → Terminal → SSH into staging → SELECT * FROM transactions WHERE card_prefix = '4' ORDER BY created_at DESC LIMIT 1; → Confirm the record exists

7. Review Crashes → If Deep Inspector caught anything → Read the stack trace → Copy and export for your bug report

8. Next Country → Switch DataHub to “Brazil” → Change Mock Location to São Paulo → Repeat steps 1–7

The difference isn’t just speed. It’s that the data flows between modules. The test identity generated in step 1 can be autofilled in step 4. The mock location set in step 2 is the context for the tests in step 5. You have a connected workflow instead of six disconnected tools.

Quick Comparison

Token System: Free to Start, Ads to Extend

Test Nexus uses a token system for AI-powered features. Here’s how it works:

• 20,000 free tokens on signup — enough to explore every AI feature extensively
• Earn more tokens by watching short rewarded video ads — each ad earns you 200 tokens
• No subscription, no credit card — you’re never asked to pay money. All data stays on your device, encrypted at rest.

Standard DataHub generation (algorithmic card numbers, CPFs, addresses, names, phone numbers) is free and doesn’t use tokens. AI-powered features — like Custom Form data generation and other Gemini-powered capabilities — consume tokens. You always see the token cost before confirming, so there are no surprises.

ℹ️ You control the ad experience. Ads are opt-in only. You watch a rewarded ad when you want more tokens. There are no forced ads interrupting your testing workflow.

The full breakdown of what uses tokens and what’s free is in Post #09: Token System — How Rewarded Ads Power AI Features.

Get Started in Two Minutes

1. Install Test Nexus from Google Play
2. Sign in with your Google account — you’ll receive 20,000 free tokens immediately
3. Enable Developer Options (one-time): Settings → About Phone → Tap “Build Number” 7 times
4. Select mock location provider (one-time): Developer Options → Select Mock Location App → Test Nexus
5. Grant location access: Allow Test Nexus to access your device’s location when prompted
6. Start testing — open any module and go

🚀 Ready to stop juggling six separate tools?
Download Test Nexus from the Play Store and run your first multi-country test session today.
Download Test Nexus →

What’s Next

This was the overview. The next posts in this series go deep into each module:

• #02 — How DataHub generates country-specific test data with format validation
• #03 — Complete Mock Location guide: setup, multi-waypoint routes, speed profiles, Maps integration
• #04 — Deep Inspector: automatic crash capture without ADB, and how to write effective bug reports from the data
• #05 — AI Custom Forms + Autofill: define any test schema and inject it into your app
• #06 — Terminal: SSH setup, SFTP transfers, port forwarding, script automation
• #07 — DataHub Advanced: country-specific formats, batch generation, export to JSON/CSV/XML/TSV
• #09 — Token system: what’s free, what uses tokens, and how rewarded ads work
• #10 — Building your complete multi-country testing workflow with all six modules
• #11 — Wireless ADB: debug your Android device without a cable using SPAKE2 pairing
• #12 — Deep Inspector beyond crashes: health dashboard, ANR detection, and real-time notifications

Each post is written for the same audience — the person doing the testing. Practical, specific, and directly applicable to your daily work.