Cross-Platform Mobile Testing: Strategies for Multi-Device Success

import boto3

# Initialize Device Farm client
client = boto3.client('devicefarm', region_name='us-west-2')

# Create a test run
response = client.schedule_run(
    projectArn='arn:aws:devicefarm:us-west-2:111222333:project:xxxxx',
    appArn='arn:aws:devicefarm:us-west-2:111222333:upload:xxxxx',
    devicePoolArn='arn:aws:devicefarm:us-west-2:111222333:devicepool:xxxxx',
    test={
        'type': 'APPIUM_PYTHON',
        'testPackageArn': 'arn:aws:devicefarm:us-west-2:111222333:upload:xxxxx'
    },
    configuration={
        'extraDataPackageArn': 'arn:aws:devicefarm:us-west-2:111222333:upload:xxxxx',
        'locale': 'en_US',
        'location': {
            'latitude': 37.422,
            'longitude': -122.084
        }
    }
)

print(f"Test run ARN: {response['run']['arn']}")

// BrowserStack configuration for Appium
const capabilities = {
  'browserstack.user': process.env.BROWSERSTACK_USERNAME,
  'browserstack.key': process.env.BROWSERSTACK_ACCESS_KEY,
  'app': 'bs://c700ce60cf13ae8ed97705a55b8e022f13c5827c',
  'device': 'Samsung Galaxy S23',
  'os_version': '13.0',
  'project': 'Cross-Platform Test Suite',
  'build': 'Android Build 1.0',
  'name': 'Payment Flow Test',
  'browserstack.debug': true,
  'browserstack.networkLogs': true
};

const driver = await new webdriver.Builder()
  .usingServer('http://hub-cloud.browserstack.com/wd/hub')
  .withCapabilities(capabilities)
  .build();

@Test
public void testCrossPlatformLogin() {
    DesiredCapabilities caps = new DesiredCapabilities();
    caps.setCapability("platformName", "Android");
    caps.setCapability("platformVersion", "13");
    caps.setCapability("deviceName", "Google Pixel 7");
    caps.setCapability("app", "sauce-storage:MyApp.apk");
    caps.setCapability("automationName", "UiAutomator2");
    caps.setCapability("name", "Login Test - Android 13");

    String sauceUrl = "https://ondemand.us-west-1.saucelabs.com:443/wd/hub";
    AppiumDriver driver = new AppiumDriver(new URL(sauceUrl), caps);

    // Test logic here
    driver.quit();
}

# compatibility-matrix.yml
platforms:
  ios:
    priority_devices:
      - { model: "iPhone 15 Pro", os: "17.0", priority: 1 }
      - { model: "iPhone 14", os: "16.0", priority: 1 }
      - { model: "iPhone 13", os: "15.0", priority: 2 }
      - { model: "iPad Pro 12.9", os: "17.0", priority: 2 }

    os_coverage:
      - version: "17.0"  # Latest
      - version: "16.0"  # N-1
      - version: "15.0"  # N-2

  android:
    priority_devices:
      - { model: "Samsung Galaxy S23", os: "13.0", priority: 1 }
      - { model: "Google Pixel 7", os: "13.0", priority: 1 }
      - { model: "OnePlus 11", os: "13.0", priority: 2 }
      - { model: "Samsung Galaxy A54", os: "13.0", priority: 2 }
      - { model: "Samsung Galaxy S21", os: "12.0", priority: 2 }

    os_coverage:
      - version: "13.0"  # Latest
      - version: "12.0"  # N-1
      - version: "11.0"  # N-2
      - version: "10.0"  # Long-term support

    screen_categories:
      - small: "< 5 inches"
      - medium: "5-6 inches"
      - large: "> 6 inches"
      - tablet: "> 7 inches"

test_coverage:
  p1_devices: "100% test suite"
  p2_devices: "Core flows + smoke tests"
  p3_devices: "Smoke tests only"

from appium import webdriver
from appium.options.android import UiAutomator2Options
from appium.options.ios import XCUITestOptions

class CrossPlatformTest:
    def __init__(self, platform):
        self.platform = platform
        self.driver = self._initialize_driver()

    def _initialize_driver(self):
        if self.platform == 'android':
            options = UiAutomator2Options()
            options.platform_name = 'Android'
            options.device_name = 'Android Emulator'
            options.app = '/path/to/app.apk'
            options.automation_name = 'UiAutomator2'
        else:  # iOS
            options = XCUITestOptions()
            options.platform_name = 'iOS'
            options.device_name = 'iPhone 14 Simulator'
            options.app = '/path/to/app.app'
            options.automation_name = 'XCUITest'

        return webdriver.Remote('http://localhost:4723', options=options)

    def test_login_flow(self):
        # Platform-agnostic element location
        username_field = self.driver.find_element(
            by='accessibility id',
            value='username_input'
        )
        password_field = self.driver.find_element(
            by='accessibility id',
            value='password_input'
        )
        login_button = self.driver.find_element(
            by='accessibility id',
            value='login_button'
        )

        username_field.send_keys('testuser@example.com')
        password_field.send_keys('SecurePass123!')
        login_button.click()

        # Verify successful login
        assert self.driver.find_element(
            by='accessibility id',
            value='home_screen'
        ).is_displayed()

    def teardown(self):
        self.driver.quit()

# Run on both platforms
android_test = CrossPlatformTest('android')
android_test.test_login_flow()
android_test.teardown()

ios_test = CrossPlatformTest('ios')
ios_test.test_login_flow()
ios_test.teardown()

// detox.config.js - Cross-platform Detox configuration
module.exports = {
  testRunner: 'jest',
  runnerConfig: 'e2e/config.json',
  apps: {
    'ios.debug': {
      type: 'ios.app',
      binaryPath: 'ios/build/Build/Products/Debug-iphonesimulator/MyApp.app',
      build: 'xcodebuild -workspace ios/MyApp.xcworkspace -scheme MyApp -configuration Debug -sdk iphonesimulator -derivedDataPath ios/build'
    },
    'android.debug': {
      type: 'android.apk',
      binaryPath: 'android/app/build/outputs/apk/debug/app-debug.apk',
      build: 'cd android && ./gradlew assembleDebug assembleAndroidTest -DtestBuildType=debug'
    }
  },
  devices: {
    simulator: {
      type: 'ios.simulator',
      device: { type: 'iPhone 14' }
    },
    emulator: {
      type: 'android.emulator',
      device: { avdName: 'Pixel_7_API_33' }
    }
  },
  configurations: {
    'ios.sim.debug': {
      device: 'simulator',
      app: 'ios.debug'
    },
    'android.emu.debug': {
      device: 'emulator',
      app: 'android.debug'
    }
  }
};

// integration_test/cross_platform_test.dart
import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';
import 'package:my_app/main.dart' as app;
import 'dart:io' show Platform;

void main() {
  IntegrationTestWidgetsFlutterBinding.ensureInitialized();

  group('Cross-Platform Login Test', () {
    testWidgets('should login successfully on both platforms',
      (WidgetTester tester) async {
      app.main();
      await tester.pumpAndSettle();

      // Platform-specific adjustments
      if (Platform.isIOS) {
        // iOS-specific behavior
        await tester.tap(find.text('Continue with Apple'));
      } else {
        // Android-specific behavior
        await tester.tap(find.text('Continue with Google'));
      }
      await tester.pumpAndSettle();

      // Common test steps
      await tester.enterText(
        find.byKey(Key('email_field')),
        'test@example.com'
      );
      await tester.enterText(
        find.byKey(Key('password_field')),
        'password123'
      );
      await tester.tap(find.byKey(Key('login_button')));
      await tester.pumpAndSettle();

      expect(find.text('Welcome Back'), findsOneWidget);
    });
  });
}

class PlatformHandler:
    def __init__(self, driver, platform):
        self.driver = driver
        self.platform = platform

    def handle_permissions(self, permission_type):
        if self.platform == 'iOS':
            # iOS permission dialog
            if permission_type == 'location':
                self.driver.find_element(
                    by='xpath',
                    value='//XCUIElementTypeButton[@name="Allow While Using App"]'
                ).click()
        else:  # Android
            # Android permission dialog
            if permission_type == 'location':
                self.driver.find_element(
                    by='id',
                    value='com.android.permissioncontroller:id/permission_allow_foreground_only_button'
                ).click()

    def enable_biometric(self):
        if self.platform == 'iOS':
            # Simulate Face ID
            self.driver.execute_script('mobile: enrollBiometric', {
                'isEnabled': True
            })
        else:  # Android
            # Simulate fingerprint
            self.driver.finger_print(1)

# Screen configuration test suite
SCREEN_CONFIGS = [
    {'name': 'Small Phone', 'width': 375, 'height': 667, 'dpi': 326},   # iPhone SE
    {'name': 'Medium Phone', 'width': 390, 'height': 844, 'dpi': 460},  # iPhone 14
    {'name': 'Large Phone', 'width': 430, 'height': 932, 'dpi': 460},   # iPhone 14 Pro Max
    {'name': 'Tablet', 'width': 1024, 'height': 1366, 'dpi': 264},      # iPad Pro
    {'name': 'Android Small', 'width': 360, 'height': 640, 'dpi': 320},
    {'name': 'Android Medium', 'width': 412, 'height': 915, 'dpi': 420},
    {'name': 'Android Large', 'width': 384, 'height': 854, 'dpi': 440},
]

def test_responsive_layout(driver, config):
    """Test layout adapts correctly to different screen sizes"""
    # Set screen size (emulator/simulator)
    driver.set_window_size(config['width'], config['height'])

    # Verify critical elements are visible and properly sized
    header = driver.find_element(by='id', value='header')
    assert header.is_displayed()

    # Check text doesn't overflow
    product_title = driver.find_element(by='id', value='product_title')
    assert product_title.size['width'] <= config['width']

    # Verify images scale appropriately
    product_image = driver.find_element(by='id', value='product_image')
    assert product_image.size['width'] <= config['width'] * 0.9

    # Screenshot for visual regression
    driver.save_screenshot(f"layout_{config['name']}.png")

# version-compatibility-strategy.yml
minimum_supported_versions:
  ios: "15.0"    # Support last 3 major versions
  android: "10"  # API level 29

testing_strategy:
  new_features:
    # Test new OS features on latest versions
    - ios_17_features:
        - interactive_widgets
        - contact_posters
    - android_13_features:
        - themed_icons
        - per_app_language

  deprecated_apis:
    # Test fallbacks for deprecated functionality
    - monitor_deprecation_warnings
    - implement_alternative_apis
    - gradual_migration_plan

  backward_compatibility:
    # Ensure graceful degradation
    - feature_flags_for_new_apis
    - runtime_os_version_checks
    - fallback_implementations

test_matrix:
  regression_testing:
    - current_version  # iOS 17, Android 13
    - n_minus_1        # iOS 16, Android 12
    - n_minus_2        # iOS 15, Android 11

  edge_testing:
    - minimum_supported  # iOS 15, Android 10
    - beta_versions      # iOS 18 beta, Android 14 beta

// iOS version checking
if #available(iOS 16.0, *) {
    // Use iOS 16+ features
    configureActivityKit()
} else {
    // Fallback for older versions
    configureLocalNotifications()
}

// Android version checking
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
    // Android 13+ notification permissions
    requestNotificationPermission()
} else {
    // Automatic permission on older versions
    setupNotifications()
}

# analytics_based_selection.py
import pandas as pd

# Load real user analytics
device_analytics = pd.read_csv('user_devices.csv')

# Select devices covering 90% of user base
top_devices = device_analytics.nlargest(10, 'user_percentage')

print("Priority devices (90% coverage):")
for idx, device in top_devices.iterrows():
    print(f"{device['model']} - {device['user_percentage']}% users")

// Jenkinsfile - Parallel execution configuration
pipeline {
    agent any
    stages {
        stage('Parallel Mobile Tests') {
            parallel {
                stage('iOS Suite') {
                    steps {
                        script {
                            // Run on 3 concurrent iOS devices
                            sh './run_ios_tests.sh --parallel 3'
                        }
                    }
                }
                stage('Android Suite') {
                    steps {
                        script {
                            // Run on 5 concurrent Android devices
                            sh './run_android_tests.sh --parallel 5'
                        }
                    }
                }
            }
        }
    }
}

#!/bin/bash
# Use emulators for fast feedback, real devices for critical flows

# Fast smoke tests on emulators (5 minutes)
./gradlew connectedAndroidTest -Pandroid.testInstrumentationRunnerArguments.class=com.app.SmokeTests

# Critical flows on real devices (20 minutes)
./gradlew connectedAndroidTest -Pandroid.testInstrumentationRunnerArguments.class=com.app.CriticalFlows \
  -Pandroid.device.cloud=browserstack

# pytest_parallel_config.py
import pytest
from concurrent.futures import ThreadPoolExecutor
from appium import webdriver

DEVICE_CONFIGS = [
    {'platform': 'iOS', 'device': 'iPhone 14', 'version': '16.0'},
    {'platform': 'iOS', 'device': 'iPhone 13', 'version': '15.0'},
    {'platform': 'Android', 'device': 'Pixel 7', 'version': '13.0'},
    {'platform': 'Android', 'device': 'Galaxy S23', 'version': '13.0'},
]

def run_test_on_device(config):
    """Execute test suite on a specific device configuration"""
    driver = initialize_driver(config)
    try:
        # Run test suite
        run_login_tests(driver)
        run_checkout_tests(driver)
        run_profile_tests(driver)
        return {'config': config, 'status': 'PASSED'}
    except Exception as e:
        return {'config': config, 'status': 'FAILED', 'error': str(e)}
    finally:
        driver.quit()

def parallel_test_execution():
    """Run tests in parallel across multiple devices"""
    with ThreadPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(run_test_on_device, DEVICE_CONFIGS))

    # Aggregate results
    passed = sum(1 for r in results if r['status'] == 'PASSED')
    failed = sum(1 for r in results if r['status'] == 'FAILED')

    print(f"Results: {passed} passed, {failed} failed")
    return all(r['status'] == 'PASSED' for r in results)

if __name__ == '__main__':
    success = parallel_test_execution()
    exit(0 if success else 1)

# test-execution-strategy.yml
test_stages:
  development:
    environment: "local_emulators"
    frequency: "every_commit"
    coverage: "unit_tests + smoke_tests"
    cost: "$0"

  continuous_integration:
    environment: "cloud_emulators"
    frequency: "every_pull_request"
    coverage: "regression_suite"
    cost: "$50/month"

  nightly:
    environment: "cloud_real_devices (top_5)"
    frequency: "daily"
    coverage: "full_regression"
    cost: "$200/month"

  release_candidate:
    environment: "cloud_real_devices (full_matrix)"
    frequency: "pre_release"
    coverage: "comprehensive_testing"
    cost: "$500/release"

# .github/workflows/mobile-testing.yml
name: Cross-Platform Mobile Tests

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  android_emulator_tests:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v3

      - name: Set up JDK 17
        uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'

      - name: Run Android Emulator Tests
        uses: reactivecircus/android-emulator-runner@v2
        with:
          api-level: 33
          target: google_apis
          arch: x86_64
          script: ./gradlew connectedAndroidTest

      - name: Upload Test Reports
        uses: actions/upload-artifact@v3
        if: always()
        with:
          name: android-test-reports
          path: app/build/reports/androidTests/

  ios_simulator_tests:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v3

      - name: Select Xcode
        run: sudo xcode-select -s /Applications/Xcode_15.0.app

      - name: Run iOS Tests
        run: |
          xcodebuild test \
            -workspace MyApp.xcworkspace \
            -scheme MyApp \
            -destination 'platform=iOS Simulator,name=iPhone 14,OS=17.0'

      - name: Upload Test Results
        uses: actions/upload-artifact@v3
        if: always()
        with:
          name: ios-test-results
          path: build/test-results/

  browserstack_real_devices:
    runs-on: ubuntu-latest
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v3

      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'

      - name: Install dependencies
        run: npm ci

      - name: Run BrowserStack Tests
        env:
          BROWSERSTACK_USERNAME: ${{ secrets.BROWSERSTACK_USERNAME }}
          BROWSERSTACK_ACCESS_KEY: ${{ secrets.BROWSERSTACK_ACCESS_KEY }}
        run: |
          npm run test:browserstack:parallel

      - name: Generate Test Report
        run: npm run generate-report

      - name: Upload BrowserStack Results
        uses: actions/upload-artifact@v3
        with:
          name: browserstack-results
          path: test-results/

  test_report:
    needs: [android_emulator_tests, ios_simulator_tests, browserstack_real_devices]
    runs-on: ubuntu-latest
    if: always()
    steps:
      - name: Download all artifacts
        uses: actions/download-artifact@v3

      - name: Merge and publish test results
        run: |
          # Aggregate results from all platforms
          python scripts/merge_test_results.py

      - name: Comment PR with results
        uses: actions/github-script@v6
        if: github.event_name == 'pull_request'
        with:
          script: |
            const fs = require('fs');
            const report = fs.readFileSync('test-summary.md', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: report
            });