Gelijkwaardigheid partitioneren bij het testen van software is een black-box testtechniek die je helpt om efficiënte testgevallen te bouwen zonder concessies te doen aan de testdekking.

In dit artikel bekijken we wat partitioneren van equivalentieklassen is, waarom het nuttig is en verkennen we enkele processen en benaderingen die je kunt gebruiken om de voordelen van deze techniek te benutten.

 

Wat is partitionering van equivalentieklassen

in het testen van software?

Alle software heeft bepaalde invoervoorwaarden. In de context van softwaretesten beschrijven deze invoervoorwaarden de waarden of gegevens die een tester moet gebruiken om de kwaliteit en functionaliteit van hun software te verifiëren. Deze invoer kan zoiets simpels zijn als een muisklik, maar ook tekst en getallen.

Een equivalente partitie bij het testen van software onderzoekt de verschillende inputs die nodig zijn om de software te gebruiken en groepeert ze in equivalentieklassen, dat wil zeggen sets van inputs die een equivalent effect hebben op het gedrag van de software.

Als je weet hoe elke groep ingangen zich zal gedragen, dan hoef je niet elke vertegenwoordiger van de groep te testen. Als zodanig is het partitioneren van equivalentieklassen een geweldige manier om testers te helpen de frequentie van overbodige tests te verminderen. In een hyperconcurrerende wereld van softwareontwikkeling met steeds strakkere deadlines is het cruciaal om tijd en moeite te besparen in de levenscyclus van softwaretesten (STLC).

Tot slot is het goed om op te merken dat equivalentie testen een black-box testtechniek is. In het kort betekent het dat de testers geen kennis hoeven te hebben van de interne code of de interne werking van het programma. Testen zijn gebaseerd op inputs, outputs en extern gedrag. Daarom zijn deze tests sterk gericht op het gedrag van de gebruiker tijdens het gebruik van het programma.

 

1. Softwaretest gelijkwaardigheid partitioneren in een notendop

Gelijkwaardigheidsverdeling verdeelt de invoergegevens van softwaretests in twee kampen: geldige en ongeldige invoer. De waarden binnen elke partitie moeten ervoor zorgen dat de software hetzelfde gedrag vertoont. Bijvoorbeeld:

• Als de voorwaarde van één waarde in Partitie A waar is, dan moeten de andere waarden in Partitie A dat ook zijn.
• Evenzo, als de voorwaarden van een waarde in Partitie A onwaar zijn, dan moeten de andere waarden in Partitie A ook onwaar zijn.

In een testcontext moet elke partitie minstens één keer aan bod komen. Logischerwijs betekent dit dat als één ingang in Partitie A faalt, alle andere ingangen ook falen. Dit proces zou tijd moeten besparen omdat testers, in plaats van elke ingang te testen die in Partitie A zit, er slechts één kunnen testen en de uitkomst kunnen extrapoleren op basis van de overeenkomsten.

 

2. Waarom het testen van equivalentieklassen bij het testen van software belangrijk is

Voordat we ingaan op de directe voordelen van het testen van equivalentieklassen bij het testen van software, moeten we definiëren waarom de aanpak belangrijk is.

Alle testers begrijpen dat het testen van software compromissen vereist. Tijd en budgetten zijn beperkt, wat betekent dat testers het beste uit hun middelen moeten halen. Softwaretests gelijkwaardig verdelen helpt teams een balans te vinden tussen efficiëntie en betrouwbaarheid in hun tests door het aantal inputs te verminderen.

 

Voordelen van gelijkwaardigheidsverdeling

in het testen van software

Een gelijkwaardige partitie bij het testen van software wordt om verschillende redenen door testteams geprefereerd. Hier zijn een paar van de meest overtuigende.

1. Efficiëntie

Het grote voordeel van het testen van gelijkwaardigheidspartities is de efficiëntie. Als testers equivalentiepartitionering gebruiken, kunnen ze het aantal testgevallen dat ze nodig hebben verminderen zonder afbreuk te doen aan de testdekking. Door een invoersituatie uit elke equivalentieklasse te kiezen, kunnen testers erop vertrouwen dat ze begrijpen hoe hun software werkt met een verscheidenheid aan invoer.

2. Eenvoud

Een ander groot voordeel van het partitioneren van softwaretest-equivalenties is de eenvoud. Het opsplitsen van een diverse set inputs in zowel geldige als ongeldige gegevens betekent dat testplanning veel eenvoudiger is. Het testen van elke ingang afzonderlijk vereist veel documentatie en coördinatie. Door dat terug te brengen tot één representatief voorbeeld wordt het testproces gestroomlijnd.

Verbeterde dekking

Door equivalentieklassen te gebruiken bij het testen, kun je je testtijd ook efficiënter gebruiken. Het reduceren van testingangen in klassen betekent dat je elke klasse grondiger kunt testen. Deze uitgebreide aanpak zou eerlijk gezegd onmogelijk zijn als je elke ingang afzonderlijk zou testen. Met equivalentie partitionering kunnen teams grondig te werk gaan en geldige en ongeldige gegevens, edge cases, grenswaarden en meer testen.

3. Herbruikbaarheid

De initiële tijd die je investeert in het vaststellen van elke equivalentieklasse bij het testen van software betaalt zich later terug als je deze klassen hergebruikt voor toekomstige invoertests. Hoewel niet alle partities relevant zullen zijn voor toekomstige tests, zullen de partities die dat wel zijn je veel tijd besparen bij toekomstige projecten of zelfs regressietests.

 

Nadelen van gelijkwaardigheidsverdeling

in het testen van software

Hoewel partitioneren op basis van gelijkwaardigheid een aantal grote voordelen biedt, is het niet de ideale oplossing voor elk scenario. Laten we eens kijken naar enkele van de beperkingen.

1. Invoer volgorde

In bepaalde situaties is de volgorde van invoer een cruciaal onderdeel van het testen van de functionaliteit van een applicatie. Dat is niet iets dat je echt kunt verminderen door equivalentiepartitionering te gebruiken. Testers moeten rekening houden met deze situaties en alternatieve technieken gebruiken om een goede dekking te bieden.

2. Complexe invoerafhankelijkheden

Complexe software met complexe invoerafhankelijkheden is een ander gebied waar de beperkingen van equivalentiepartitionering aan het licht komen. Bijvoorbeeld software die berekeningen uitvoert op basis van verschillende inputs. In dit scenario moeten testers verschillende technieken gebruiken om de combinatorische explosie te beperken en de kans op het isoleren van defecten te vergroten.

 

Alternatieve benaderingen als aanvulling op de

beperkingen van gelijkwaardigheidstests

Hoewel het testen van gelijkwaardigheidspartities geschikt is voor veel testscenario’s, kan zeer complexe software met ingewikkelde afhankelijkheden tussen invoerwaarden aanvullende benaderingen vereisen.

Als het gaat om het schrijven van testgevallen voor complexe software, is het gebruik van een combinatie van deze benaderingen een goed idee.

1. Paargewijs testen

Pairwise testen is een softwaretesttechniek die alle mogelijke combinaties van elk paar invoerparameters test. Deze aanpak zorgt ervoor dat elk paar parameters samen minstens één keer wordt getest.

2. Beslissingstabel testen

Een beslissingstabel helpt testers bij het methodisch in kaart brengen van verschillende invoercombinaties. Het is een goede manier om systematische dekking te garanderen als er complexe afhankelijkheden bestaan.

3. Testen van toestandsovergangen

Dit testtype meet hoe de software overgaat tussen verschillende toestanden als reactie op verschillende invoercombinaties.

4. Modelgebaseerd testen

Deze aanpak vereist het maken van een model gebaseerd op de interne logica van de software en het gebruik van een automatiseringstool om testgevallen te maken op basis van dat model. Deze techniek kan goed omgaan met complexiteit en zorgt voor voldoende dekking.

 

Testvoorbeelden voor het partitioneren van equivalentieklassen

De beste manier om equivalentiepartitionering te begrijpen is om te kijken hoe en waar je een equivalentieklasse zou kunnen gebruiken bij het testen van software. Hier zijn een paar voorbeelden om je te helpen het concept verder te visualiseren.

 

1. Testvoorbeeld #1 van partitionering van equivalentieklassen

Een online bestelformulier is een goed voorbeeld van een equivalentieklasse bij het testen van software.

Stel, je bouwt een app voor een online verkoper van stationaire apparatuur. Er is een typisch bestelformulier voor bails A4-papier. Hier wordt uitgelegd hoe je equivalentieklassen kunt gebruiken om deze vorm te testen.

Gelijkwaardigheidsklassen:

Hoeveelheden A4-papier liggen binnen een specifiek bereik van bijvoorbeeld 1 tot 100. De drie klassen zijn dus:

• 1 tot 100
• Cijfers onder 1
• Getallen boven de 100.

 

Testgevallen:

Er moeten drie testcases worden uitgevoerd, met de volgende verwachte resultaten

• Elk getal tussen 1 en 100 = Bestelling verwerkt
• Cijfers onder 1 = foutmelding
• Getallen boven 100 = foutmelding

 

2. Voorbeeld #2 van testen op equivalentieverdeling

Een equivalentieklasse in softwaretesten kan met meer dan alleen getallen omgaan. In dit voorbeeld zullen we onderzoeken hoe je hetzelfde principe kunt gebruiken om een uploadportaal te verifiëren. Stel dat je moet testen voor een site waar gebruikers identiteitsdocumenten moeten uploaden, maar je kunt alleen specifieke formaten accepteren.

Gelijkwaardigheidsklassen:

• Ondersteunde documenten zijn PDF en JPEG.
• Niet-ondersteunde documenten zijn alle andere documentformaten
• Geen document

 

Testgevallen:

• Test door PDF of JPEG te uploaden = succesvolle upload
• Test door niet ondersteund formaat te uploaden = foutmelding
• Test zonder bestandsupload = foutmelding

 

Hoe een gelijkwaardigheidsverdeling implementeren

aanpak voor het testen van software

Als je equivalentieklassen wilt gebruiken bij het testen, moet je een strategische aanpak kiezen. Hier is een handige stap-voor-stap handleiding voor het implementeren van equivalentie partitionering bij het testen van software.

 

Stap #1: Ingangsvariabelen identificeren

 

Elke software reageert op verschillende invoervariabelen. Voor complexe software kunnen deze variabelen enorm zijn. Neem dus de softwarevereisten en -specificaties door en identificeer alle variabelen die van invloed zijn op het gedrag van de software.

Enkele van de meest voor de hand liggende inputs zijn formulieren voor gebruikersinvoer. Je moet echter een breder scala aan inputs voor je lijst overwegen. Je kunt ook rekening houden met omgevingsvariabelen, API-aanroepen, interne berekeningen, enzovoort.

Vervolgens moet je de verschillende soorten variabele gegevens begrijpen. Je kunt deze variabelen categoriseren als geheel getal, Booleaans, tekenreeks, enz. om de juiste partities te definiëren.

Tot slot moet je de invoerbeperkingen onderzoeken. Dat zijn dingen zoals welke tekens zijn toegestaan, gedefinieerde formaten en minimum/maximum waarden.

 

Stap #2. Geldige en ongeldige partities bepalen

Kijk naar elke invoervariabele en begin ze te verdelen in geldige en ongeldige uitkomsten. Dit zijn je equivalentieklassen bij het testen.

1. Geldige partities

Geldige partities kunnen worden opgesplitst in twee klassen.

Positieve equivalentieklassen:

Waarden waarvan je verwacht dat je software ze met succes zal verwerken. Bijvoorbeeld, voor software die percentages registreert, is alles tussen 0 en 100 geldig.

Negatieve equivalentieklassen:

Deze categorie is voor waarden die buiten de grenzen van de verwachte invoer vallen, maar die je software moet afhandelen met een foutmelding. De invoer is bijvoorbeeld 110 voor een percentage, waardoor de software een foutbericht teruggeeft met de tekst “Alle waarden moeten 0 tot 100 zijn”.

 

2. Ongeldige partities

Deze equivalentieklassen bevatten ingangen die fouten of onverwacht gedrag veroorzaken. In ons voorbeeld hierboven zou dat pogingen kunnen inhouden om A+ of B of gelijkaardige inputs in te voeren in het percentagecijfer. Hoewel deze invoer technisch correct kan zijn, valt hij buiten de numerieke verwachtingen.

 

#3. Effectieve testgevallen schrijven

Vervolgens moet je testgevallen ontwerpen die elke equivalentiepartitie minstens één keer behandelen. Zoals eerder in het artikel vermeld, zorgt dit voor de juiste testdekking.

Allereerst moet je representatieve waarden selecteren binnen elke equivalentiepartitie die zowel geldige als ongeldige gegevens kan bevatten.

Tips voor het schrijven van degelijke testgevallen

• Denk na over grenswaarden: Zorg ervoor dat je de grenzen van je partities test. Minimum, maximum, inclusief, exclusief, etc., omdat deze gebieden sterke kandidaten zijn voor bugs. Als je invoerverwachtingen bijvoorbeeld tussen 0 en 100 liggen, test dan op negatieve waarden en op getallen als 101.
• Overweeg positieve en negatieve testscenario’s voor zowel je valide als ongeldige testgevallen.
• Combinatietesten zijn een goed idee. Gebruik een paar verschillende benaderingen zoals beschreven in onze alternatieve benaderingen om de beperkingen van de gelijkwaardigheidstest hierboven aan te vullen.
• Documenteer de beweegredenen waarom de invoerwaarden in specifieke partities zijn verdeeld en beschrijf duidelijk het verwachte gedrag van elke test.
• Gebruik waar mogelijk visuele hulpmiddelen om een gevoel van duidelijkheid en objectiviteit in je testcases te brengen door diagrammen of tabellen te gebruiken om je partities in kaart te brengen.

 

#4. Je testgevallen plannen en uitvoeren

Geef prioriteit aan je taken op basis van factoren zoals:

• Welke gebieden hebben de meeste kans op defecten
• Welke scenario’s het meest waarschijnlijk ernstige scenario’s veroorzaken, zoals vastlopen of bevriezen

Voer vervolgens je tests uit en noteer de uitvoer en eventuele fouten. Voor complexe programma’s met veel invoer kun je RPA-tools gebruiken om acties van gebruikers na te bootsen.

 

#5. Analyseer de resultaten

Voeg de verzamelde testgegevens samen en analyseer de resultaten. Enkele methoden die je moet gebruiken zijn:

• Bekijk elke testcase en vergelijk de werkelijke uitvoer met de verwachte uitvoer
• Zoek afwijkingen en onderzoek en rapporteer bugs en defecten.

 

#6 Extra tips

Hoewel deze tips niet in elk scenario toepasbaar zijn, zullen ze nuttig blijken bij het testen van complexe software.

• Beslissingstabellen zijn een uitstekende manier om je equivalentiepartities en verschillende invoercombinaties die je mogelijk wilt gebruiken te visualiseren
• Je kunt gelijkwaardigheidsklassen samenvoegen als ze bijna identiek gedrag vertonen, waardoor het testproces verder wordt geoptimaliseerd.
• Grenswaardetests gebruiken om defecten beter op te sporen
• Automatiseer waar mogelijk je testgevallen voor het partitioneren van equivalenties

 

Gelijkwaardigheidsverdeling en grenswaardeanalyse

Gelijkwaardig partitioneren is gebaseerd op de aanname dat elke test binnen een partitie hetzelfde resultaat oplevert. Hoewel dat in veel situaties waar is, zal het niet altijd werken. Inputs die per ongeluk zijn toegevoegd aan een partitie kunnen bijvoorbeeld niet worden gecontroleerd, wat leidt tot verminderde dekking en mogelijke instabiliteit van de software in de toekomst.

De oplossing voor dit probleem is het testen van grenswaarden. Hiermee kunnen softwaretestteams zich richten op de gebieden die het meest waarschijnlijk risico’s bevatten en de software op die basis testen. In het kort komt het erop neer dat risico’s zich het meest waarschijnlijk voordoen aan de randen of grenzen van je invoerpartities. Daarom kunnen testers testgevallen schrijven aan de boven- en ondergrenzen van de invoer, naast de andere testgevallen van de equivalentieklasse.

 

Gelijkwaardigheidspartitionering en automatisering met ZAPTEST

Software testautomatiseringsprogramma’s, zoals ZAPTEST, kunnen teams helpen om het partitioneren van equivalenties te automatiseren, zowel tijdens het maken als tijdens het uitvoeren van tests.

Laten we eens kijken hoe ZAPTEST je kan helpen om de voordelen van deze handige black-box testaanpak te benutten.

 

1. Gereedschapsselectie

Het is belangrijk om het juiste gereedschap voor de klus te kiezen. De meeste testautomatiseringsprogramma’s zijn gespecialiseerd in web-, mobiele of desktoptests. ZAPTEST kan testen op verschillende platforms en applicaties, waardoor het een solide keuze is.

 

2. Testgevallen schrijven en uitvoeren

Met ZAPTEST 1Script kun je de gebruikersinterface scannen om testautomatisering te bouwen. Daarnaast kun je ook mock-ups van applicaties scannen als je in een vroeg stadium van ontwikkeling zit. Met de Scan GUI-functie scant ZAPTEST alle testobjecten en voegt ze toe aan de objectenlijst.

Van hieruit kun je objecten toevoegen aan het diagram en de teststappen opbouwen.

Met ZAPTEST kun je het schrijven van cases automatiseren met een eenvoudige drag-and-drop interface. Je hebt geen coderingsexpertise nodig om testcases te bouwen met ZAPTEST. Vanaf hier kun je dus de relevante bewerking selecteren uit een vervolgkeuzemenu en een testcase bouwen op basis van de invoerwaarden die nodig zijn voor je interface. Vervolgens kun je testgevallen bouwen voor elke equivalentie en je testgevallen uitvoeren. Je kunt zelfs testgevallen hergebruiken en ze bewerken in de Step editor, wat veel tijd bespaart.

 

3. Rapportage en beheer van testcases

Met ZAPTEST kun je testcases parallel uitvoeren, wat een aanzienlijke tijdsbesparing oplevert. Dit kan je helpen om een groot aantal verschillende equivalentiepartities tegelijk uit te voeren of om bepaalde groepen testen uit te voeren.

Resultaten zijn eenvoudig te verzamelen dankzij gedetailleerde rapporten over mislukte/overtroffen tests, schermafbeeldingen, uitvoeringslogs en prestatiecijfers voor elke testcase.

 

4. Onderhoud van testcases

Je kunt je testcases ook eenvoudig bijhouden en onderhouden dankzij de mogelijkheden voor kwaliteitsversiebeheer. Bovendien kunnen gebruikers van ZAPTEST tests klonen en hergebruiken om een nieuw niveau van efficiëntie te bereiken.

ZAPTEST biedt veel meer functionaliteit naast testcaseautomatisering. Met een suite van RPA-tools biedt ZAPTEST 2-in-1 functionaliteit, waarmee de kloof tussen DevOps en BizOps wordt overbrugd in een toekomst die wordt gekenmerkt door hyperautomatisering, waarbij alles wat geautomatiseerd kan worden ook geautomatiseerd zal worden.

 

Laatste gedachten

Gelijkwaardigheidsverdeling is een elegante oplossing voor situaties waarin testers een balans moeten vinden tussen efficiëntie en nauwkeurigheid. Omdat sommige software een bijna eindeloze reeks invoer toestaat, helpt het partitioneren van equivalentieklassen teams om testgegevens op te splitsen in hanteerbare, hapklare brokken die elk grondig getest kunnen worden.

Download post as PDF