Hoe maak je combinaties van reeksen als testgegevens

stemmen
18

Ik wil graag een functie te testen met een tupel uit een set van pony gevallen en de normale waarden. Terwijl bijvoorbeeld het testen van een functie die retourneert truewanneer gegeven drie lengtes die een geldige driehoek, zou bepaalde gevallen negatieve / kleine / grote aantallen waarden dicht te zijn overgelopen, etc .; wat meer is, de belangrijkste doel is om combinaties van deze waarden te genereren, met of zonder herhaling, met het oog op een reeks van testgegevens krijgen.

(inf,0,-1), (5,10,1000), (10,5,5), (0,-1,5), (1000,inf,inf),
...

Als een opmerking: Ik weet eigenlijk het antwoord op deze, maar het kan nuttig zijn voor anderen, en een uitdaging voor de mensen hier! --will posten mijn antwoord later.

De vraag is gesteld op 02/08/2008 om 22:34
bron van user
In andere talen...                            


5 antwoorden

stemmen
4

Interessante vraag!

Ik zou dit doen door het plukken combinaties, zoiets als het volgende in python. Het moeilijkste deel is waarschijnlijk voor het eerst pas verificatie, dat wil zeggen if f(1,2,3) returns true, is dat een correct resultaat? Als je dat eenmaal hebt gecontroleerd, dan is dit een goede basis voor regressietesten.

Waarschijnlijk is het een goed idee om een ​​aantal testcases waarvan u weet dat alle ware (bijvoorbeeld 3.4.5 voor deze driehoek geval), en een set van testgevallen dat u weet zal alle valse (bijvoorbeeld 0,1 maken , inf). Dan kunt u gemakkelijker controleren de tests correct zijn.

# Xpermutations van http://code.activestate.com/recipes/190465
van xpermutations importeren *

lengte = [- 1,0,1,5,10,0,1000, 'inf']
voor C in xselections (lengtes 3): # of xuniqueselections
    afdruk c
(-1, -1, -1);
(-1, -1,0);
(-1, -1,1);
(-1, -1,5);
(-1, -1,10);
(-1, -1,0);
(-1, -1,1000);
(-1, -1, inf);
(-1,0, -1);
(-1,0,0);
...
antwoordde op 03/08/2008 om 01:04
bron van user

stemmen
14

Absoluut, vooral ter bestrijding van veel van deze permutaties / combinaties Ik kan zeker zien dat de eerste pas een probleem zou zijn.

Interessante implementatie in python, hoewel ik schreef een nice one in C en Ocaml op basis van "Algorithm 515" (zie hieronder). Hij schreef zijn in Fortran als was het gebruikelijk toen voor alle "Algorithm XX" papers, nou, dat assemblage of c. Ik moest herschrijven en een aantal kleine verbeteringen te werken met arrays niet reeksen van getallen. Deze random access doet, ben ik nog steeds bezig om een ​​aantal leuke implementaties van de in Knuth 4e volume fascicle 2 genoemde krijg ik er een uitleg over hoe dit werkt aan de lezer. Hoewel als iemand nieuwsgierig is, zou ik er geen bezwaar tegen het schrijven van iets omhoog.

/** [combination c n p x]
 * get the [x]th lexicographically ordered set of [p] elements in [n]
 * output is in [c], and should be sizeof(int)*[p] */
void combination(int* c,int n,int p, int x){
    int i,r,k = 0;
    for(i=0;i<p-1;i++){
        c[i] = (i != 0) ? c[i-1] : 0;
        do {
            c[i]++;
            r = choose(n-c[i],p-(i+1));
            k = k + r;
        } while(k < x);
        k = k - r;
    }
    c[p-1] = c[p-2] + x - k;
}

~ "Algoritme 515: Generatie van een Vector van de Lexicografische Index"; Gespen, BP, en Lybanon, M. ACM Transactions on Mathematical Software, Vol. 3, No. 2, juni 1977.

antwoordde op 03/08/2008 om 20:06
bron van user

stemmen
2

Ik denk dat je kunt dit doen met de Row Test Attribute (beschikbaar in MbUnit en latere versies van NUnit), waar je verschillende sets kon opgeven om een unit test bevolken.

antwoordde op 16/08/2008 om 14:31
bron van user

stemmen
0

Hoewel het mogelijk is om veel van de testgegevens te maken en zien wat er gebeurt, is het efficiënter om te proberen om het minimaliseren van de data wordt gebruikt.

Vanuit een normale QA perspectief, zou je willen verschillende classificaties van inputs te identificeren. Maak een verzameling invoerwaarden voor elke classificatie en de geschikte uitgangen.

Hier is een voorbeeld van de klassen van de input waarden

  • geldige driehoeken met kleine aantallen zoals (1 miljard, 2 miljard, 2 miljard)
  • geldige driehoeken met grote aantallen zoals (0.000001, 0,00002, 0,00003)
  • geldige stompe driehoeken dat almost'flat als zodanig (10, 10, 19,9999)
  • geldige acute driehoeken die 'nagenoeg' flat zoals (10, 10, 0000001)
  • ongeldige driehoeken met ten minste één negatieve waarde
  • ongeldige driehoeken waarbij de som van beide zijden gelijk aan de derde
  • ongeldige driehoeken waarbij de som van beide kanten groter is dan de derde
  • ingangswaarden die niet-numerieke

...

Bent u tevreden met de lijst van de input classificaties voor deze functie, dan kunt u de werkelijke testgegevens te creëren. Waarschijnlijk zou het nuttig zijn om alle permutaties van elk item te testen. (Bijvoorbeeld (2,3,4), (2,4,3), (3,2,4), (3,4,2), (4,2,3), (4,3,2)) typisch, vind je er een aantal classificaties je gemist (zoals het concept van de inf als input parameter).

Willekeurige gegevens voor een bepaalde periode van tijd kan nuttig zijn als goed, die vreemde bugs in de code kan vinden, maar is over het algemeen niet productief.

Meer waarschijnlijk wordt deze functie gebruikt in een speciale situatie waarin bijkomende regels worden toegepast. (Bijvoorbeeld alleen gehele getallen of -waarden in stappen van 0,01, etc.) Deze toevoegen aan de lijst classificaties van invoerparameters.

antwoordde op 17/09/2008 om 04:15
bron van user

stemmen
4

Met de gloednieuwe Python 2.6, heb je een standaard oplossing met de itertools module die de cartesiaanse product van iterables terugkeert:

import itertools

print list(itertools.product([1,2,3], [4,5,6]))
   [(1, 4), (1, 5), (1, 6),
   (2, 4), (2, 5), (2, 6),
   (3, 4), (3, 5), (3, 6)]

U kunt een "herhaling" argument bieden om het product uit te voeren met een iterable en zelf:

print list(itertools.product([1,2], repeat=3))
[(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2),
(2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]

U kunt ook iets met combinaties tweak ook:

print list(itertools.combinations('123', 2))
[('1', '2'), ('1', '3'), ('2', '3')]

En indien bestelling van zaken, zijn er permutaties:

print list(itertools.permutations([1,2,3,4], 2))
[(1, 2), (1, 3), (1, 4),
   (2, 1), (2, 3), (2, 4),
   (3, 1), (3, 2), (3, 4),
   (4, 1), (4, 2), (4, 3)]

Natuurlijk al die spullen te koelen niet precies hetzelfde doen, maar je kunt ze gebruiken in een of andere manier om je probleem op te lossen.

Vergeet niet dat je een tupel of een lijst kan converteren naar een set en vice versa met behulp van de lijst (), tuple () en stel ().

antwoordde op 04/10/2008 om 09:52
bron van user

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more