Mobile Game Testing: Complete Guide to QA for Gaming Apps

using UnityEngine;
using UnityEngine.Profiling;

public class FPSMonitor : MonoBehaviour
{
    private float deltaTime = 0.0f;
    private int frameCount = 0;
    private float fpsSum = 0.0f;

    void Update()
    {
        deltaTime += (Time.unscaledDeltaTime - deltaTime) * 0.1f;
        float fps = 1.0f / deltaTime;

        frameCount++;
        fpsSum += fps;

        // Log metrics every 60 frames
        if (frameCount >= 60)
        {
            float avgFPS = fpsSum / frameCount;
            LogPerformanceMetric("AvgFPS", avgFPS);
            LogPerformanceMetric("MemoryUsage", Profiler.GetTotalAllocatedMemoryLong() / 1048576f);

            frameCount = 0;
            fpsSum = 0.0f;
        }
    }

    void LogPerformanceMetric(string metricName, float value)
    {
        Debug.Log($"[Performance] {metricName}: {value:F2}");
        // Send to analytics service
    }
}

# Monitor real-time FPS on Android device
adb shell dumpsys gfxinfo com.yourgame.package framestats

# Extract frame timing data
adb shell dumpsys gfxinfo com.yourgame.package | grep "50th\|90th\|95th\|99th"

# Continuous FPS monitoring with timestamp
while true; do
  echo "$(date +%H:%M:%S) - $(adb shell dumpsys gfxinfo com.yourgame.package | grep 'Total frames rendered')"
  sleep 5
done

using UnityEngine;
using System;

public class MemoryTracker : MonoBehaviour
{
    private long lastMemoryUsage = 0;

    public void TrackMemoryUsage(string sceneName)
    {
        // Force garbage collection for accurate measurement
        GC.Collect();
        System.Threading.Thread.Sleep(100);

        long totalMemory = GC.GetTotalMemory(false);
        long nativeMemory = UnityEngine.Profiling.Profiler.GetTotalAllocatedMemoryLong();

        Debug.Log($"[Memory] Scene: {sceneName}");
        Debug.Log($"  Managed Heap: {totalMemory / 1048576f:F2} MB");
        Debug.Log($"  Native Memory: {nativeMemory / 1048576f:F2} MB");
        Debug.Log($"  Delta: {(nativeMemory - lastMemoryUsage) / 1048576f:F2} MB");

        lastMemoryUsage = nativeMemory;

        // Alert if memory exceeds thresholds
        if (nativeMemory > 1024 * 1048576) // 1GB
        {
            Debug.LogWarning("Memory usage exceeds 1GB - potential crash risk on low-end devices");
        }
    }
}

# Reset battery statistics
adb shell dumpsys batterystats --reset

# Play game for test duration (e.g., 30 minutes)

# Extract battery consumption data
adb shell dumpsys batterystats com.yourgame.package

# Get specific app battery usage
adb shell dumpsys batterystats | grep -A 20 "com.yourgame.package"

using UnityEngine;
using System.Net.NetworkInformation;
using System.Diagnostics;

public class NetworkMonitor : MonoBehaviour
{
    private Ping ping;
    private Stopwatch stopwatch;

    public void MeasureLatency(string serverAddress)
    {
        ping = new Ping();
        stopwatch = Stopwatch.StartNew();

        ping.SendAsync(serverAddress, 1000, null);
        ping.PingCompleted += PingCompletedCallback;
    }

    private void PingCompletedCallback(object sender, PingCompletedEventArgs e)
    {
        if (e.Reply != null && e.Reply.Status == IPStatus.Success)
        {
            long latency = e.Reply.RoundtripTime;
            LogLatencyMetric(latency);

            if (latency > 150)
                UnityEngine.Debug.LogWarning($"High latency detected: {latency}ms");
        }
    }

    private void LogLatencyMetric(long latency)
    {
        UnityEngine.Debug.Log($"[Network] Latency: {latency}ms");
        // Categorize experience
        string quality = latency < 50 ? "Excellent" :
                        latency < 100 ? "Good" :
                        latency < 150 ? "Fair" : "Poor";
        UnityEngine.Debug.Log($"[Network] Connection Quality: {quality}");
    }
}

using UnityEngine;
using UnityEngine.TestTools;
using NUnit.Framework;
using System.Collections;

public class GameplayTests
{
    [UnityTest]
    public IEnumerator PlayerTakesDamageCorrectly()
    {
        // Arrange: Load game scene
        UnityEngine.SceneManagement.SceneManager.LoadScene("GameScene");
        yield return null; // Wait one frame for scene load

        var player = GameObject.FindObjectOfType<PlayerController>();
        int initialHealth = player.Health;

        // Act: Apply damage
        player.TakeDamage(25);
        yield return new WaitForSeconds(0.1f);

        // Assert: Verify health decreased
        Assert.AreEqual(initialHealth - 25, player.Health);
        Assert.IsTrue(player.IsAlive);
    }

    [UnityTest]
    public IEnumerator GameMaintains60FPSUnderLoad()
    {
        // Arrange: Spawn 100 enemies
        var enemyPrefab = Resources.Load<GameObject>("Enemy");
        for (int i = 0; i < 100; i++)
        {
            GameObject.Instantiate(enemyPrefab, Random.insideUnitSphere * 50, Quaternion.identity);
        }

        yield return null;

        // Act: Monitor FPS for 5 seconds
        float testDuration = 5.0f;
        float elapsed = 0;
        int frameCount = 0;
        float totalFPS = 0;

        while (elapsed < testDuration)
        {
            totalFPS += 1.0f / Time.unscaledDeltaTime;
            frameCount++;
            elapsed += Time.unscaledDeltaTime;
            yield return null;
        }

        float avgFPS = totalFPS / frameCount;

        // Assert: Average FPS should be above 55 (allowing 5 FPS margin)
        Assert.Greater(avgFPS, 55f, $"Average FPS was {avgFPS:F1}, expected >55");
    }
}

using NUnit.Framework;

public class InventorySystemTests
{
    private InventorySystem inventory;

    [SetUp]
    public void Setup()
    {
        inventory = new InventorySystem(maxSlots: 20);
    }

    [Test]
    public void AddItem_IncreasesItemCount()
    {
        // Arrange
        var item = new Item("Health Potion", ItemType.Consumable);

        // Act
        bool added = inventory.AddItem(item);

        // Assert
        Assert.IsTrue(added);
        Assert.AreEqual(1, inventory.ItemCount);
    }

    [Test]
    public void AddItem_ExceedingMaxSlots_ReturnsFalse()
    {
        // Arrange
        for (int i = 0; i < 20; i++)
        {
            inventory.AddItem(new Item($"Item{i}", ItemType.Material));
        }

        // Act
        bool added = inventory.AddItem(new Item("ExtraItem", ItemType.Material));

        // Assert
        Assert.IsFalse(added);
        Assert.AreEqual(20, inventory.ItemCount);
    }
}

#include "Tests/AutomationCommon.h"
#include "Misc/AutomationTest.h"

IMPLEMENT_SIMPLE_AUTOMATION_TEST(
    FPlayerMovementTest,
    "Game.Player.Movement",
    EAutomationTestFlags::ApplicationContextMask | EAutomationTestFlags::ProductFilter
)

bool FPlayerMovementTest::RunTest(const FString& Parameters)
{
    // Arrange: Get player character
    APlayerCharacter* Player = GetWorld()->SpawnActor<APlayerCharacter>();
    FVector InitialLocation = Player->GetActorLocation();

    // Act: Simulate forward movement for 1 second
    Player->MoveForward(1.0f);
    GetWorld()->Tick(LEVELTICK_All, 1.0f);

    // Assert: Player should have moved forward
    FVector FinalLocation = Player->GetActorLocation();
    TestTrue("Player moved forward", FinalLocation.X > InitialLocation.X);

    // Cleanup
    Player->Destroy();

    return true;
}

class FGamePerformanceTest : public FAutomationTestBase
{
public:
    bool RunPerfTest()
    {
        // Launch game with specific map
        LaunchGame("TestMap_Combat");

        // Wait for game initialization
        WaitForGameReady();

        // Spawn test scenario (100 AI enemies)
        SpawnEnemies(100);

        // Monitor performance for 60 seconds
        bool PassedFPSTest = MonitorFPS(60.0f, MinFPS: 30.0f);
        bool PassedMemoryTest = MonitorMemory(60.0f, MaxMB: 2048);

        return PassedFPSTest && PassedMemoryTest;
    }
};

# test_matrix.yaml
platforms:
  - name: Android
    devices:
      - model: flame  # Pixel 4
        version: 29
        orientation: portrait
      - model: starqlteue  # Galaxy S9+
        version: 28
        orientation: landscape
      - model: OnePlus7
        version: 30
        orientation: portrait

test-targets:
  - game-launch-test
  - tutorial-completion-test
  - 30min-gameplay-test

using UnityEngine;
using UnityEngine.Purchasing;

public class IAPTestValidator
{
    public void ValidatePurchaseFlow(Product product)
    {
        // Test scenarios:
        // 1. Successful purchase
        Assert.True(ProcessPurchase(product.transactionID));
        Assert.True(VerifyReceipt(product.receipt));
        Assert.True(GrantVirtualGoods(product.definition.id));

        // 2. Purchase cancellation
        CancelPurchase(product);
        Assert.False(WasVirtualGoodsGranted(product.definition.id));

        // 3. Purchase restoration
        RestorePurchases();
        Assert.True(NonConsumablesRestored());

        // 4. Network failure during purchase
        SimulateNetworkFailure();
        Assert.True(PurchaseQueuedForRetry(product));
    }
}

using UnityEngine;

public class ProgressionAnalytics
{
    public void TrackLevelCompletion(int levelID, float completionTime, int attempts)
    {
        // Calculate difficulty metrics
        float avgCompletionTime = GetAverageCompletionTime(levelID);
        float completionRate = GetCompletionRate(levelID);

        // Flag balance issues
        if (completionRate < 0.4f)
        {
            Debug.LogWarning($"Level {levelID} has low completion rate: {completionRate:P0}");
        }

        if (completionTime > avgCompletionTime * 2)
        {
            Debug.Log($"Player struggled with level {levelID} - took {completionTime:F1}s vs avg {avgCompletionTime:F1}s");
        }

        // Track progression pacing
        LogMetric("level_completion", new {
            level = levelID,
            duration = completionTime,
            attempts = attempts,
            player_level = GetPlayerLevel(),
            equipment_power = GetEquipmentPower()
        });
    }
}

import asyncio
import aiohttp
import time

class GameServerLoadTest:
    def __init__(self, server_url, concurrent_users):
        self.server_url = server_url
        self.concurrent_users = concurrent_users
        self.results = []

    async def simulate_player(self, player_id):
        async with aiohttp.ClientSession() as session:
            # Connect to server
            start_time = time.time()

            async with session.ws_connect(f"{self.server_url}/game") as ws:
                # Authenticate
                await ws.send_json({
                    "action": "authenticate",
                    "player_id": player_id
                })

                # Join matchmaking
                await ws.send_json({
                    "action": "join_matchmaking",
                    "game_mode": "ranked"
                })

                # Wait for match
                match_found = False
                while not match_found:
                    msg = await ws.receive_json()
                    if msg["type"] == "match_found":
                        match_time = time.time() - start_time
                        self.results.append({
                            "player_id": player_id,
                            "match_time": match_time
                        })
                        match_found = True

    async def run_test(self):
        tasks = [
            self.simulate_player(f"player_{i}")
            for i in range(self.concurrent_users)
        ]
        await asyncio.gather(*tasks)

        # Analyze results
        avg_match_time = sum(r["match_time"] for r in self.results) / len(self.results)
        print(f"Average matchmaking time: {avg_match_time:.2f}s")
        print(f"Successful matches: {len(self.results)}/{self.concurrent_users}")

# Run test with 1000 concurrent players
test = GameServerLoadTest("wss://game-server.example.com", 1000)
asyncio.run(test.run_test())

using UnityEngine;

public class QualityPresetTester : MonoBehaviour
{
    [System.Serializable]
    public class QualityBenchmark
    {
        public string qualityLevel;
        public float minFPS;
        public float maxMemoryMB;
        public float testDuration;
    }

    public QualityBenchmark[] benchmarks = new QualityBenchmark[]
    {
        new QualityBenchmark { qualityLevel = "Low", minFPS = 30, maxMemoryMB = 512, testDuration = 60 },
        new QualityBenchmark { qualityLevel = "Medium", minFPS = 45, maxMemoryMB = 768, testDuration = 60 },
        new QualityBenchmark { qualityLevel = "High", minFPS = 60, maxMemoryMB = 1024, testDuration = 60 }
    };

    public void RunQualityTests()
    {
        foreach (var benchmark in benchmarks)
        {
            QualitySettings.SetQualityLevel(GetQualityLevelIndex(benchmark.qualityLevel));

            float avgFPS = MeasureAverageFPS(benchmark.testDuration);
            float peakMemory = MeasurePeakMemory(benchmark.testDuration);

            bool fpsPass = avgFPS >= benchmark.minFPS;
            bool memoryPass = peakMemory <= benchmark.maxMemoryMB;

            Debug.Log($"Quality: {benchmark.qualityLevel} - FPS: {avgFPS:F1} (target: {benchmark.minFPS}) - Memory: {peakMemory:F0}MB (max: {benchmark.maxMemoryMB}MB)");
            Debug.Log($"Result: {(fpsPass && memoryPass ? "PASS" : "FAIL")}");
        }
    }
}

using UnityEngine;

public class HapticsValidator : MonoBehaviour
{
    public void TestHapticFeedback()
    {
        // Test light haptic
        Handheld.Vibrate();  // iOS light impact

        // Validate haptic triggers:
        // - Button press: Light haptic
        // - Item collection: Medium haptic
        // - Player damage: Heavy haptic
        // - Game over: Pattern vibration

        // Verify haptic respects:
        // - Device silent mode (iOS)
        // - User preference setting
        // - Battery saver mode
    }
}

# unity-cloud-build.yaml
targets:
  android-production:
    platform: android
    scriptingBackend: il2cpp
    buildSettings:
      development: false
      compressionMethod: lz4
    pre-build-script: Scripts/PreBuild.sh
    post-build-script: Scripts/PostBuild.sh

  ios-production:
    platform: ios
    scriptingBackend: il2cpp
    xcodeVersion: latest
    buildSettings:
      development: false

test-suites:
  unit-tests:
    platform: editmode
    testCategories: [Unit, Integration]

  playmode-tests:
    platform: playmode
    testCategories: [Functional, Performance]
    minPassRate: 95%

name: Game Build and Test

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

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - uses: game-ci/unity-test-runner@v2
        env:
          UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
        with:
          testMode: all
          artifactsPath: test-results

      - name: Upload test results
        uses: actions/upload-artifact@v3
        with:
          name: Test results
          path: test-results

  build:
    needs: test
    runs-on: ubuntu-latest
    strategy:
      matrix:
        platform: [Android, iOS]
    steps:
      - uses: game-ci/unity-builder@v2
        env:
          UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
        with:
          targetPlatform: ${{ matrix.platform }}

      - name: Deploy to TestFlight/Play Console
        run: ./deploy-scripts/${{ matrix.platform }}.sh