Comment utiliser des combinaisons d'ensembles comme données de test

voix
18

Je voudrais tester une fonction avec un tuple d'un ensemble de cas sociaux et des valeurs normales. Par exemple, tout en testant une fonction qui retourne truechaque fois donné trois longueurs qui forment un triangle valide, j'aurais des cas particuliers, des nombres négatifs / petits / grands, des valeurs proches-à être débordée, etc .; ce qui est plus, objectif principal est de générer des combinaisons de ces valeurs, avec ou sans répétition, afin d'obtenir un ensemble de données de test.

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

Comme une note: je connais la réponse à cela, mais il pourrait être utile pour les autres, et un défi pour les gens d'ici! --will poster ma réponse plus tard.

Créé 02/08/2008 à 22:34
source utilisateur
Dans d'autres langues...                            


5 réponses

voix
14

Absolument, surtout face à un bon nombre de ces permutations / combinaisons je peux certainement voir que le premier passage serait un problème.

la mise en œuvre intéressante en python, bien que je l'ai écrit une belle et un en C Ocaml basé sur « l'algorithme 515 » (voir ci-dessous). Il a écrit son Fortran comme il était courant à l'époque pour tous les papiers « algorithme XX », eh bien, cette assemblée ou c. Je devais réécrire et faire quelques petites améliorations à travailler avec des tableaux non gammes de nombres. Celui-ci fait un accès aléatoire, je travaille toujours sur l'obtention de belles mises en œuvre de celles mentionnées dans le volume 4 fascicle Knuth 2. Je vais expliquer comment cela fonctionne au lecteur. Bien que si quelqu'un est curieux, je ne m'y opposerais pas à rédiger quelque chose.

/** [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;
}

~ « Algorithme 515: Génération d'un vecteur de l'indice lexicographique »; Buckles, BP et Lybanon, M. ACM Transactions sur Mathematical Software, Vol. 3, n ° 2, Juin de 1977.

Créé 03/08/2008 à 20:06
source utilisateur

voix
4

Avec la toute nouvelle Python 2.6, vous avez une solution standard avec le module itertools qui renvoie le produit cartésien de 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)]

Vous pouvez fournir un argument « répéter » pour exécuter le produit avec un itérables et lui-même:

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

Vous pouvez également modifier quelque chose avec des combinaisons aussi bien:

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

Et si les questions d'ordre, il y a des permutations:

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

Bien sûr, tout ce que des choses ne font refroidir pas exactement la même chose, mais vous pouvez les utiliser d'une manière ou d'une autre pour vous résoudre le problème.

Rappelez-vous que vous pouvez convertir un tuple ou une liste à un ensemble et liste à l'aide vice versa (), tuple () et set ().

Créé 04/10/2008 à 09:52
source utilisateur

voix
4

Question interessante!

Je le faire en choisissant des combinaisons, quelque chose comme ce qui suit en python. La partie la plus difficile est probablement la première vérification passe, à savoir if f(1,2,3) returns true, est qu'un résultat correct? Une fois que vous avez vérifié que, alors c'est une bonne base pour les tests de régression.

C'est probablement une bonne idée de faire un ensemble de cas de test que vous savez être vrai (par exemple 3,4,5 pour ce cas de triangle), et un ensemble de cas de test que vous savez être tout faux (par exemple 0,1 , inf). Ensuite, vous pouvez vérifier plus facilement les tests sont corrects.

# xpermutations de http://code.activestate.com/recipes/190465
de xpermutations importer *

longueurs = [- 1,0,1,5,10,0,1000, 'inf']
C en xselections (longueurs, 3): # ou xuniqueselections
    Imprimer 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);
...
Créé 03/08/2008 à 01:04
source utilisateur

voix
2

Je pense que vous pouvez le faire avec l' attribut de test de ligne (disponible dans les versions ultérieures de MbUnit et NUnit) où vous pouvez spécifier plusieurs ensembles pour remplir un test unitaire.

Créé 16/08/2008 à 14:31
source utilisateur

voix
0

Bien qu'il soit possible de créer beaucoup de données de test et de voir ce qui se passe, il est plus efficace d'essayer de minimiser les données utilisées.

Du point de vue de l'assurance qualité typique, vous voulez identifier les différentes catégories d'intrants. Produire un ensemble de valeurs d'entrée pour chaque classification et déterminer les sorties appropriées.

Voici un échantillon de classes de valeurs d'entrée

  • triangles valides avec de petits nombres tels que (1 milliard, 2, G, G 2)
  • triangles valides avec un grand nombre tels que (0.000001, 0,00002, 0,00003)
  • triangles obtus valides qui sont « almost'flat tels que (10, 10, 19,9999)
  • triangles aigus valides qui sont « presque » plat tel que (10, 10, 0000001)
  • triangles non valides avec au moins une valeur négative
  • triangles non valides où la somme de deux côtés est égale à la troisième
  • triangles invalides lorsque la somme des deux parties est supérieure à la troisième
  • les valeurs d'entrée qui sont non-numérique

...

Une fois que vous êtes satisfait de la liste des classifications d'entrée pour cette fonction, vous pouvez créer les données d'essais. Probablement, il serait utile de tester toutes les permutations de chaque élément. (Par exemple (2,3,4), (2,4,3), (3,2,4), (3,4,2), (4,2,3), (4,3,2)) en règle générale, vous trouverez il y a des classifications que vous avez manqués (comme le concept de .inf comme paramètre d'entrée).

données aléatoires pendant un certain laps de temps peut être utile aussi bien, qui peut trouver des bugs étranges dans le code, mais il est généralement pas productif.

Plus probablement, cette fonction est utilisée dans un contexte particulier où les règles supplémentaires sont appliquées. (Par exemple, que des valeurs entières ou les valeurs doivent être par incréments de 0,01, etc.) Ceux-ci ajoutent à la liste des classifications des paramètres d'entrée.

Créé 17/09/2008 à 04:15
source utilisateur

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