Тестирование Мобильных Игр: Полное Руководство по QA Игровых Приложений

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;

        // Логировать метрики каждые 60 кадров
        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}");
        // Отправить в сервис аналитики
    }
}

# Мониторинг FPS в реальном времени на Android устройстве
adb shell dumpsys gfxinfo com.yourgame.package framestats

# Извлечение данных о времени кадров
adb shell dumpsys gfxinfo com.yourgame.package | grep "50th\|90th\|95th\|99th"

# Непрерывный мониторинг FPS с временной меткой
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)
    {
        // Принудительная сборка мусора для точного измерения
        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;

        // Предупредить, если память превышает пороги
        if (nativeMemory > 1024 * 1048576) // 1GB
        {
            Debug.LogWarning("Использование памяти превышает 1GB - потенциальный риск краша на устройствах низкого уровня");
        }
    }
}

# Сброс статистики батареи
adb shell dumpsys batterystats --reset

# Игра в течение времени теста (например, 30 минут)

# Извлечение данных о потреблении батареи
adb shell dumpsys batterystats com.yourgame.package

# Получить конкретное использование батареи приложением
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($"Обнаружена высокая задержка: {latency}ms");
        }
    }

    private void LogLatencyMetric(long latency)
    {
        UnityEngine.Debug.Log($"[Network] Latency: {latency}ms");
        // Категоризация опыта
        string quality = latency < 50 ? "Отличное" :
                        latency < 100 ? "Хорошее" :
                        latency < 150 ? "Удовлетворительное" : "Плохое";
        UnityEngine.Debug.Log($"[Network] Качество Соединения: {quality}");
    }
}

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

public class GameplayTests
{
    [UnityTest]
    public IEnumerator PlayerTakesDamageCorrectly()
    {
        // Arrange: Загрузить игровую сцену
        UnityEngine.SceneManagement.SceneManager.LoadScene("GameScene");
        yield return null; // Подождать один кадр для загрузки сцены

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

        // Act: Применить урон
        player.TakeDamage(25);
        yield return new WaitForSeconds(0.1f);

        // Assert: Проверить, что здоровье уменьшилось
        Assert.AreEqual(initialHealth - 25, player.Health);
        Assert.IsTrue(player.IsAlive);
    }

    [UnityTest]
    public IEnumerator GameMaintains60FPSUnderLoad()
    {
        // Arrange: Заспавнить 100 врагов
        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: Мониторить FPS в течение 5 секунд
        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: Средний FPS должен быть выше 55 (допуская запас в 5 FPS)
        Assert.Greater(avgFPS, 55f, $"Средний FPS был {avgFPS:F1}, ожидалось >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: Получить персонажа игрока
    APlayerCharacter* Player = GetWorld()->SpawnActor<APlayerCharacter>();
    FVector InitialLocation = Player->GetActorLocation();

    // Act: Симулировать движение вперед в течение 1 секунды
    Player->MoveForward(1.0f);
    GetWorld()->Tick(LEVELTICK_All, 1.0f);

    // Assert: Игрок должен был переместиться вперед
    FVector FinalLocation = Player->GetActorLocation();
    TestTrue("Player moved forward", FinalLocation.X > InitialLocation.X);

    // Cleanup
    Player->Destroy();

    return true;
}

class FGamePerformanceTest : public FAutomationTestBase
{
public:
    bool RunPerfTest()
    {
        // Запустить игру с конкретной картой
        LaunchGame("TestMap_Combat");

        // Подождать инициализации игры
        WaitForGameReady();

        // Заспавнить тестовый сценарий (100 AI врагов)
        SpawnEnemies(100);

        // Мониторить производительность в течение 60 секунд
        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)
    {
        // Тестовые сценарии:
        // 1. Успешная покупка
        Assert.True(ProcessPurchase(product.transactionID));
        Assert.True(VerifyReceipt(product.receipt));
        Assert.True(GrantVirtualGoods(product.definition.id));

        // 2. Отмена покупки
        CancelPurchase(product);
        Assert.False(WasVirtualGoodsGranted(product.definition.id));

        // 3. Восстановление покупок
        RestorePurchases();
        Assert.True(NonConsumablesRestored());

        // 4. Сбой сети во время покупки
        SimulateNetworkFailure();
        Assert.True(PurchaseQueuedForRetry(product));
    }
}

using UnityEngine;

public class ProgressionAnalytics
{
    public void TrackLevelCompletion(int levelID, float completionTime, int attempts)
    {
        // Рассчитать метрики сложности
        float avgCompletionTime = GetAverageCompletionTime(levelID);
        float completionRate = GetCompletionRate(levelID);

        // Отметить проблемы баланса
        if (completionRate < 0.4f)
        {
            Debug.LogWarning($"Уровень {levelID} имеет низкий показатель завершения: {completionRate:P0}");
        }

        if (completionTime > avgCompletionTime * 2)
        {
            Debug.Log($"Игрок испытывал трудности с уровнем {levelID} - затратил {completionTime:F1}с против среднего {avgCompletionTime:F1}с");
        }

        // Отслеживать темп прогрессии
        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:
            # Подключиться к серверу
            start_time = time.time()

            async with session.ws_connect(f"{self.server_url}/game") as ws:
                # Аутентификация
                await ws.send_json({
                    "action": "authenticate",
                    "player_id": player_id
                })

                # Присоединиться к матчмейкингу
                await ws.send_json({
                    "action": "join_matchmaking",
                    "game_mode": "ranked"
                })

                # Ждать матч
                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)

        # Анализировать результаты
        avg_match_time = sum(r["match_time"] for r in self.results) / len(self.results)
        print(f"Среднее время матчмейкинга: {avg_match_time:.2f}с")
        print(f"Успешные матчи: {len(self.results)}/{self.concurrent_users}")

# Запустить тест с 1000 одновременных игроков
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($"Качество: {benchmark.qualityLevel} - FPS: {avgFPS:F1} (цель: {benchmark.minFPS}) - Память: {peakMemory:F0}МБ (макс: {benchmark.maxMemoryMB}МБ)");
            Debug.Log($"Результат: {(fpsPass && memoryPass ? "PASS" : "FAIL")}");
        }
    }
}

using UnityEngine;

public class HapticsValidator : MonoBehaviour
{
    public void TestHapticFeedback()
    {
        // Тест легкой тактильной обратной связи
        Handheld.Vibrate();  // Легкое воздействие iOS

        // Проверить триггеры тактильной обратной связи:
        // - Нажатие кнопки: Легкая тактильная обратная связь
        // - Сбор предмета: Средняя тактильная обратная связь
        // - Урон игрока: Сильная тактильная обратная связь
        // - Конец игры: Паттерн вибрации

        // Проверить, что тактильная обратная связь учитывает:
        // - Режим беззвучности устройства (iOS)
        // - Настройки предпочтений пользователя
        // - Режим энергосбережения
    }
}

# unity-cloud-build.yaml
targets:
  android-production (как обсуждается в [Cross-Platform Mobile Testing: Strategies for Multi-Device Success](/blog/cross-platform-mobile-testing)):
    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