Hvordan bruke kombinasjoner av settene som testdata

Question

Hvordan bruke kombinasjoner av settene som testdata

stemmer

19

Jeg ønsker å teste en funksjon med en tuppel fra et sett av natural saker og normale verdier. For eksempel, mens testing av en funksjon som returnerer truenår gitt tre lengder som danner en gyldig trekant, vil jeg har spesifikke tilfeller, negativ / små / store tall, verdier nær-til å bli oversvømmet, etc .; det er mer, er hovedmålet å generere kombinasjoner av disse verdiene, med eller uten repetisjon, for å få et sett av testdata.

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

Som et notat: Jeg faktisk vet svaret på dette, men det kan være nyttig for andre, og en utfordring for folk her! --will innlegget mitt svar senere.

unit-testing language-agnostic testing

Publisert på 02/08/2008 klokken 19:34
kilden bruker nlucaroni

På andre språk...

5 svar

stemmer

4

Interessant spørsmål!

Jeg ville gjøre dette ved å plukke kombinasjoner, noe som følgende i python. Den vanskeligste delen er trolig første pass verifikasjon, dvs. if f(1,2,3) returns true, det er et riktig resultat? Når du har bekreftet det, så er dette et godt grunnlag for regresjonstesting.

Sannsynligvis er det en god idé å lage et sett med testtilfeller som du vet vil være oppfylt (f.eks 3,4,5 for denne trekanten tilfellet), og et sett med testtilfeller som du vet vil være alt falsk (f.eks 0,1 , inf). Da kan du lettere kontrollere testene er riktige.

# xpermutations fra http://code.activestate.com/recipes/190465
fra xpermutations importere *

lengder = [- 1,0,1,5,10,0,1000, 'inf']
for c i xselections (lengder, 3): # eller xuniqueselections
    print 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);
...

Svarte 02/08/2008 kl. 22:04
kilden bruker Mark Harrison

stemmer

2

Jeg tror du kan gjøre dette med Row Test Egenskap (tilgjengelig i MbUnit og senere versjoner av NUnit) der du kan spesifisere flere sett for å fylle en enhet test.

Svarte 16/08/2008 kl. 11:31
kilden bruker Jon Limjap

stemmer

0

Selv om det er mulig å lage massevis av testdata og se hva som skjer, er det mer effektivt å prøve å minimere de data som brukes.

Fra en typisk QA perspektiv, vil du ønsker å identifisere ulike klassifiseringer av innganger. Produsere et sett av inngangsverdier for hver klassifisering og bestemme de relevante utganger.

Her er et utvalg av klasser av inngangsverdier

gyldige trekanter med små tall som (1 milliard, 2, kroner, 2 milliarder)
gyldige trekanter med store tall, slik som (0.000001, 0,00002, 0,00003)
gyldige stumpe trekanter som er 'almost'flat slik som (10, 10, 19,9999)
gyldige akutte trekanter som er 'nesten' flat slik som (10, 10, 0000001)
ugyldige trekanter med minst en negativ verdi
ugyldige trekanter der summen av to sidene er lik den tredje
ugyldige trekanter hvor summen av to sider er større enn den tredje
inngangsverdier som er ikke-numeriske

...

Når du er fornøyd med listen over inngangs klassifikasjoner for denne funksjonen, så kan du lage selve testdata. Sannsynlig, ville det være nyttig å teste alle permutasjoner av hvert element. (For eksempel (2,3,4) (2,4,3) (3,2,4) (3,4,2) (4,2,3) (4,3,2)) vanligvis vil du finne det finnes noen klassifikasjoner du gikk glipp av (for eksempel begrepet inf som inngangsparameter).

Tilfeldige data for en viss periode kan være nyttig også, som kan finne merkelige feil i koden, men er vanligvis ikke produktiv.

Mer sannsynlig er denne funksjonen blir brukt i noen bestemt sammenheng hvor ytterligere regler anvendes. (For eksempel bare heltallige verdier eller verdier må være i trinn på 0,01, etc.) Disse legge til listen over klassifiseringer av inngangsparametere.

Svarte 17/09/2008 kl. 01:15
kilden bruker not-bob

stemmer

4

Med den splitter nye Python 2.6, har du en standardløsning med itertools modul som returnerer kartesisk produkt av iterables:

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)]

Du kan gi en "gjenta" argument for å utføre produktet med en iterable og seg selv:

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)]

Du kan også justere noe med kombinasjoner også:

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

Og hvis ordre saker, er det variasjoner:

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)]

Selvfølgelig alt det kule ting ikke akkurat gjøre det samme, men du kan bruke dem på en eller annen måte å løse deg problem.

Bare husk at du kan konvertere en tuppel eller en liste til et sett, og vice versa ved hjelp av liste (), tuppel () og sette ().

Svarte 04/10/2008 kl. 06:52
kilden bruker e-satis

nlucaroni · Accepted Answer · 2008-08-03 17:06

Absolutt, spesielt arbeider med mange av disse permutasjoner / kombinasjonene jeg kan helt klart se at den første pass ville være et problem.

Interessant implementering i python, selv om jeg skrev en fin en i C og Objective Caml basert på "algoritme 515" (se nedenfor). Han skrev i Fortran som det var vanlig på den tiden for alle "Algoritme XX" papirer, vel, at montering eller c. Jeg måtte omskrive det og gjøre noen små forbedringer for å arbeide med matriser ikke serier av tall. Dette gjør random access, jeg jobber fortsatt med å få noen fine implementeringer av de som er nevnt i Knuth fjerde volumet fascikkel 2. Jeg skal en forklaring på hvordan dette fungerer for leseren. Selv om noen er nysgjerrig, jeg ville ikke motsette seg å skrive noe opp.

/** [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: Generering av en vektor fra leksikografiske Index"; Spenner, BP, og Lybanon, M. ACM Transactions on Mathematical Software, vol. 3, nr 2, juni 1977.