Unity-game-testen: een praktische, engine-specifieke handleiding

Unity vormt de basis voor enkele van de grootste titels ter wereld en brengt deze uit voor telefoons, consoles, browsers en desktops vanuit één enkel project. Dat bereik is precies wat het testen van een Unity-game lastig maakt: één build moet werken op iPhone, Android, consoles en desktop, waarbij elk platform zijn eigen specifieke problemen kent.

Code die perfect werkt op uw build-machine kan haperen op een smartphone uit het middensegment, en een functie die moeiteloos door elke controle in de editor kwam, kan instorten zodra een echte speler ermee aan de slag gaat. Spelers haken snel af bij een game die traag is of vastloopt, dus de zwakke plekken die u mist, leiden tot de reviews waar u spijt van krijgt.

De echte vraag voor iedereen die met Unity bouwt, is dus niet of er getest moet worden, maar hoe u de specifieke foutpunten van de engine ontdekt zonder een fortuin uit te geven. Dat is waar ervaren game testing services hun waarde bewijzen. Deze gids laat u de essentiële zaken zien:

• Wat het Test Framework doet
• Twee soorten checks die het uitvoert
• Hoe automatisering in een echt releaseschema past
• Valkuilen die een lancering geruisloos kunnen verpesten

Lees verder en ontdek alles wat essentieel is voor Unity game testing!

Hoe test u een Unity-game?

Het testen van een Unity-game werkt op drie niveaus:

• Geautomatiseerde checks die in de engine zijn geschreven, vangen codeproblemen vroegtijdig op, terwijl een build nog goedkoop te repareren is.
• Hands-on speelsessies op echte apparaten ontdekken de rommelige, menselijke problemen die automatisering nooit ziet, zoals een tutorial die spelers in verwarring brengt of een menu dat niet intuïtief aanvoelt.
• Compliance-checks, waarbij u bevestigt dat de game voldoet aan de regels die platformen zoals de App Store en PlayStation voor de lancering stellen.

Deze niveaus corresponderen met de bredere soorten game testing waar elke studio mee te maken heeft, van functionele en compatibiliteitschecks tot prestaties en stabiliteit.

De meeste teams focussen te veel op één niveau en verwaarlozen de andere. Een studio vol engineers heeft bijvoorbeeld de neiging alles te automatiseren en praktijktests over te slaan, om zich vervolgens af te vragen waarom recensenten klagen over het gevoel van de game. Ondertussen speelt een kleiner indie-team de game vaak tot in den treure handmatig door, slaat automatisering over en breekt vervolgens bij elke nieuwe toevoeging oude functies. Een gezond project moet alle drie de niveaus gebruiken; goede Unity game testing draait om het weten hoeveel van elk een titel nodig heeft.

Wat is het Unity Test Framework?

Het Unity Test Framework is een gratis tool die in de editor is ingebouwd. Hiermee kunnen uw programmeurs kleine geautomatiseerde checks schrijven en deze uitvoeren tegen de code van de game, zonder het programma te verlaten. Onder de motorkap gebruikt het NUnit, een algemeen vertrouwde open-source bibliotheek voor de C#-programmeertaal, waardoor de checks een standaard volgen die de meeste ontwikkelaars al herkennen. U kunt het volledige overzicht lezen in de officiële documentatie van Unity.

Zie het als een automatische inspecteur voor de regels van uw game. Als een gezondheidsbalk bijvoorbeeld met tien punten moet dalen wanneer een personage schade oploopt, kan het framework dit elke keer binnen een fractie van een seconde bevestigen. Wat het niet kan, is beoordelen of die klap bevredigend aanvoelde of dat de animatie er goed uitzag. Het controleert de machine, niet de magie, en dat onderscheid bepaalt alles wat verder komt kijken bij Unity game testing.

Edit Mode versus Play Mode, en waarom het verschil ertoe doet

Het framework voert twee soorten checks uit, en het verschil daartussen is waar veel studio’s de mist in gaan:

• Edit mode-checks worden uitgevoerd terwijl de game is uitgeschakeld, alsof u een bouwtekening bestudeert in plaats van in de auto rijdt. Ze zijn snel en goedkoop en geschikt voor alles waarvoor de game niet daadwerkelijk hoeft te draaien, zoals scoreberekeningen, voorraadregels of de logica van opslagbestanden.
• Play mode-checks worden uitgevoerd terwijl de game actief is, dus ze kunnen helpen bij het beoordelen van de manier waarop iemand de game daadwerkelijk ervaart. Ze zijn trager en lastiger in te stellen, maar ze vangen de problemen op die pas in beweging zichtbaar worden, zoals haperende physics, afwijkingen in timing of objecten die niet verschijnen wanneer dat wel zou moeten. Unity doorloopt de techniek van beide in hun gids voor geautomatiseerde tests.

Het verkeerd gebruik van deze modi is een veelgemaakte en kostbare fout. Een team dat veel edit mode-checks schrijft omdat deze snel zijn, ziet een muur van geruststellende groene vinkjes en gaat ervan uit dat de game solide is. Spelers stuiten vervolgens echter op bugs die alleen in play mode verschijnen en nooit zijn gecontroleerd. Die ‘groene vinkjes’ zijn slechts zo betrouwbaar als de tests die erachter zitten.

Instelwerk dat geruisloos een sprint opslokt

Voordat er Unity game testing kan plaatsvinden, moet uw project worden ingedeeld in gelabelde secties. Dat is hoe de checks weten naar welke delen van de code ze moeten kijken. Dit netjes doen is eenvoudig aan het begin van een project, maar enorm pijnlijk om achteraf nog toe te voegen. Teams die testen als een bijzaak zien, verliezen daarom dagen aan het rechtbreien van deze structuur.

Er is een tweede valkuil om rekening mee te houden. Unity kan laten zien welk deel van uw code door checks is bereikt. Een hoog dekkingspercentage vertelt u echter alleen welke regels code zijn uitgevoerd, niet of elk pad daardoor ook daadwerkelijk goed is getest. De game kan dus een indrukwekkend cijfer rapporteren en alsnog een bug verbergen op een route waar niemand aan heeft gedacht.

Hoe automatiseert u het testen in Unity?

Automatisering in Unity begint in de engine, waar uw programmeurs tests schrijven met het Unity Test Framework. Zij sturen deze checks door de ingebouwde Test Runner en koppelen deze aan continuous integration. Het geautomatiseerde systeem herbouwt en valideert uw game bij elke codewijziging, waardoor een defecte functie binnen enkele minuten wordt gemarkeerd in plaats van dat deze pas weken later in een review naar voren komt. Onze automated testing services zijn precies op dat ritme gebouwd.

Het addertje onder het gras is dat automatisering niet gratis is nadat het is geschreven. Elke test heeft onderhoud nodig naarmate de game verandert, en een verwaarloosde set tests ontaardt in een stapel valse alarmen die iedereen op den duur negeert. Automatisering bewijst pas echt zijn nut als iemand er eigenaarschap over neemt.

Unity game testing op iPhone en Android

De allerbelangrijkste gewoonte bij het testen van Unity-games is het draaien van uw titel op de hardware die spelers daadwerkelijk gaan gebruiken, in plaats van alleen in de editor op een snelle computer. De editor is op een manier vergevingsgezind zoals een telefoon in iemands broekzak dat nooit is.

Een Unity-game testen op Android betekent dat u een breed scala aan apparaten met sterk uiteenlopende chips, schermformaten en geheugencapaciteit moet dekken. Een build die soepel draait op een vlaggenschip-telefoon kan haperen op een budgetmodel dat door miljoenen mensen wordt gebruikt. Het testen van een Unity-game op iPhone is beperkter wat hardware betreft, maar strenger in de regels, omdat het beoordelingsproces van Apple builds kan afwijzen om redenen die nooit op de machine van de ontwikkelaar zichtbaar zijn. Een titel die in de editor af lijkt, kan op beide platforms alsnog vastlopen door totaal verschillende redenen. Daarom bouwen en testen serieuze teams al lang voor de lancering op echte iOS- en Android-apparaten. Onze checklist voor het testen van mobiele games zet uiteen wat u op elk apparaat moet controleren voordat u de app indient.

Unity-gametesttools voorbij het testframework

Het Unity Test Framework is uitstekend op codeniveau, maar het is nooit ontworpen om door menu’s te klikken, een level uit te spelen of zich te gedragen als een persoon met een controller in de hand. Voor dat soort end-to-end-testen, en voor het op grote schaal aansturen van builds op echte telefoons, heeft u aanvullende Unity-gametesttools nodig naast de standaardfuncties. We vergelijken de tools die studio’s daadwerkelijk gebruiken in onze gids over automatiseringstools voor gametesten, dus dit artikel focust zich op de engine zelf.

De eigenaardigheden bij het testen van Unity-games die QA-teams over het hoofd zien

Elke engine heeft zijn eigen persoonlijkheid, en die van Unity komt op een paar punten naar voren waar teams zich op verkijken:

• Fysica kan zich anders gedragen afhankelijk van de snelheid waarmee een apparaat de game draait. Een sprong die perfect landt op een snelle pc kan een personage op een tragere telefoon door een muur laten schieten. Alleen testen op high-end hardware verbergt deze categorie bugs volledig.
• Unity stopt af en toe om ongebruikt geheugen op te ruimen, en die pauze kan zich op het slechtst mogelijke moment uiten als een zichtbare hapering, zoals midden in een eindbaasgevecht. Deze haperingen komen zelden voor op een krachtige ontwikkelmachine, waardoor ze de eindgebruiker bereiken. Het tijdig opsporen van framedrops en geheugenpieken voordat de spelers ze ervaren, is de kern van game-performancetesten, vooral op apparaten met minder rekenkracht.
• Dezelfde scène kan er merkbaar anders uitzien via de verschillende rendering-opties van Unity, waardoor artwork dat bij de ene instelling door de keuring kwam, bij de andere te donker of kapot kan lijken. Een team dat visuals op slechts één configuratie controleert, test slechts een fractie van wat spelers te zien krijgen.
• Het lezen van foutmeldingen is eenvoudig in de editor, maar lastig zodra de game op een echt apparaat draait. Testers zonder de juiste configuratie sturen uiteindelijk bugrapporten in als een screenshot zonder uitleg, waarna een ontwikkelaar uren kwijt is aan het reproduceren van een probleem dat nooit goed is vastgelegd.

Geen van deze problemen is exotisch; het zijn de normale consequenties van hoe Unity werkt, en precies de zaken waar een tester die de engine kent als eerste op let.

In-house, geautomatiseerd of uitbesteed: kies uw model voor het testen van Unity-games

Er is geen enkelvoudig goed antwoord, alleen de keuze die past bij uw game en uw team. QA in-house opbouwen levert mensen op die het project door en door kennen, wat enorm waardevol is, hoewel het langzaam is om personeel te werven en duur om ze tussen releases door bezig te houden. Als u voor die route kiest, helpt onze gids over het bouwen van een gametestteam u bij het bepalen wie u wanneer moet inhuren. Inzetten op automatisering levert snelheid en consistentie op, zolang iemand de checks onderhoudt en accepteert dat machines alles missen wat met gevoel en spelplezier te maken heeft.

Het inschakelen van een extern team is in een paar situaties logisch:

• U nadert een lancering en heeft snel brede dekking op veel apparaten nodig.
• Uw engineers zijn sterk, maar hebben nog nooit de play mode-checks of een CI/CD-pipeline van Unity opgezet, en u wilt geen sprint verliezen aan het leerproces.
• Uw eigen team staat simpelweg te dicht op de game om de ruwe randjes te zien die een frisse blik in een middag ontdekt.

De pragmatische keuze voor de meeste studio’s is een combinatie: automatisering voor de repetitieve checks die het beste zonder menselijke tussenkomst verlopen, en bekwame handmatige testers voor de inschattingen die een script niet kan maken. Die mix goed krijgen voor een specifieke game is het belangrijkste werk, en dat is waar een ervaren partner zijn meerwaarde bewijst.

Unity biedt een buitengewoon bereik, en die schaal brengt testkosten met zich mee die niet worden gedekt door algemeen advies. Studio’s die een schone lancering maken, zijn de studio’s die de zwakke plekken van de engine vroegtijdig controleren op echte apparaten, samen met mensen die die bugs al eerder hebben gezien.

Dat is precies wat wij doen, dus vertel ons over uw titel en wij laten u zien waar de risico’s schuilen.

Veelgestelde vragen

Is het Unity Test Framework gratis?

Ja, het Unity Test Framework zit zonder extra kosten ingebouwd in de editor, dus elk team kan direct beginnen met het schrijven van geautomatiseerde checks zonder iets aan te hoeven schaffen.

Kunt u user interface-testen automatiseren in Unity?

Ja, dat kan, maar niet met alleen het Test Framework. Het aansturen van menu’s en knoppen zoals een speler dat zou doen, vereist extra tooling boven op de ingebouwde checks van Unity.

Moet u een Unity-game testen op echte iPhone- en Android-apparaten?

Ja, de editor verbergt platformspecifieke fouten, dus de enige betrouwbare manier om te zien wat spelers te zien krijgen, is door de game op fysieke iOS- en Android-apparaten te draaien.

Is handmatig testen nog nodig als u automatiseert?

Ja, automatisering is onovertroffen voor repetitieve checks, maar het kan niet beoordelen of een game leuk is, of een level eerlijk voelt, of dat een animatie er goed uitziet – en die beslissingen bepalen de recensies.

Wanneer moet een Unity-studio externe testers inschakelen?

De gebruikelijke aanleidingen zijn een naderende lancering die brede apparaatdekking vereist, een team zonder specifieke testervaring met de engine, of een game die de eigen makers te goed kennen om nog objectief te kunnen beoordelen.