Como usar combinações de conjuntos como dados de teste

votos
18

Eu gostaria de testar uma função com uma tupla de um conjunto de casos de franja e valores normais. Por exemplo, ao testar uma função que retorna truesempre dadas três comprimentos que formam um triângulo válido, teria casos específicos, / pequenas / grandes números negativos, valores próximos do afogado, etc .; o que é mais, o objetivo principal é gerar combinações desses valores, com ou sem repetição, a fim de obter um conjunto de dados de teste.

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

Como uma nota: Na verdade, eu sei a resposta para isso, mas pode ser útil para os outros, e um desafio para as pessoas aqui! CD Japan postar minha resposta mais tarde.

Publicado 02/08/2008 em 22:34
fonte usuário
Em outras línguas...                            


5 respostas

votos
14

Absolutamente, especialmente lidar com muitas dessas permutações / combinações eu posso definitivamente ver que o primeiro passo seria um problema.

implementação interessante em python, embora eu escrevi um bom um em C e Ocaml baseado em "Algoritmo 515" (veja abaixo). Ele escreveu seu em Fortran como era comum na época para todos os papéis "Algoritmo XX", bem, isso montagem ou c. Eu tive que reescrevê-lo e fazer algumas pequenas melhorias para trabalhar com não matrizes intervalos de números. Este faz de acesso aleatório, eu ainda estou trabalhando para conseguir alguns bons implementações das mencionadas no Knuth fascículo quarto do volume 2. Eu vou uma explicação de como isso funciona para o leitor. Embora se alguém está curioso, eu não se oporia a escrever alguma coisa.

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

~ "Algoritmo 515: Geração de um vetor a partir do Índice de lexicográfica"; Fivelas, BP, e Lybanon, Transações M. ACM no software matemático, Vol. 3, No. 2, junho 1977.

Respondeu 03/08/2008 em 20:06
fonte usuário

votos
4

Com o novo Python 2.6, você tem uma solução padrão com o módulo itertools que retorna o produto cartesiano 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)]

Você pode fornecer um argumento de "repetir" para executar o produto com um iterable ea própria:

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

Você também pode ajustar algo com combinações bem:

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

E se as questões de ordem, há permutações:

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

É claro que tudo o que coisas legais não exatamente fazer a mesma coisa, mas você pode usá-los de uma forma ou de outra para resolver o seu problema.

Basta lembrar que você pode converter uma tupla ou uma lista para um conjunto e vice-versa usando list (), tuple () e set ().

Respondeu 04/10/2008 em 09:52
fonte usuário

votos
4

Pergunta interessante!

Eu faria isso por escolher combinações, algo como o seguinte em python. A parte mais difícil é provavelmente a verificação primeira passagem, ou seja if f(1,2,3) returns true, é que um resultado correto? Depois de ter verificado que, então esta é uma boa base para testes de regressão.

Provavelmente é uma boa idéia para fazer um conjunto de casos de teste que você sabe que vai ser tudo verdade (por exemplo 3,4,5 para este caso triângulo), e um conjunto de casos de teste que você sabe que vai ser tudo falso (por exemplo, 0,1 , inf). Depois, você pode mais facilmente verificar os testes estão corretas.

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

comprimentos = [- 1,0,1,5,10,0,1000, 'inf']
para c em xselections (comprimentos, 3): # ou xuniqueselections
    impressão 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);
...
Respondeu 03/08/2008 em 01:04
fonte usuário

votos
2

Eu acho que você pode fazer isso com o atributo de teste Row (disponível em MbUnit e versões posteriores do NUnit), onde você pode especificar vários conjuntos para preencher um teste de unidade.

Respondeu 16/08/2008 em 14:31
fonte usuário

votos
0

Embora seja possível criar lotes de dados de teste e ver o que acontece, é mais eficiente para tentar minimizar os dados a ser utilizado.

De uma perspectiva típica QA, você gostaria de identificar diferentes classificações de entradas. Produzir um conjunto de valores de entrada para cada uma das classes e determinar as saídas apropriadas.

Aqui está um exemplo de classes de valores de entrada

  • triângulos válidos com pequenas quantidades tais como (1000000000, 2, bilhões, dois bilhões)
  • triângulos válidos com grandes números, tais como (0.000001, 0,00002, 0,00003)
  • triângulos obtusos válidos que são 'almost'flat tais como (10, 10, 19,9999)
  • triângulos agudas válidos que são 'quase' plana, como (10, 10, 0000001)
  • triângulos inválidos com pelo menos um valor negativo
  • triângulos inválidos onde a soma de dois lados é igual ao terceiro
  • triângulos inválidos onde a soma de dois lados é maior do que o terceiro
  • valores de entrada que são não-numérico

...

Quando estiver satisfeito com a lista de classificações de entrada para esta função, então você pode criar os dados de testes reais. Provavelmente, seria útil para testar todas as permutações de cada item. (Por exemplo, (2,3,4), (2,4,3), (3,2,4), (3,4,2), (4,2,3), (4,3,2)) normalmente, você verá que existem algumas classificações que você perdeu (como o conceito de inf como parâmetro de entrada).

dados aleatórios para algum período de tempo pode ser útil também, que pode encontrar bugs estranhos no código, mas geralmente não é produtivo.

Mais provavelmente, esta função está a ser utilizada em alguns contexto específico onde regras adicionais são aplicados. (Por exemplo, apenas valores ou valores inteiros deve ser em incrementos de 0,01, etc.) Estas adicionar à lista de classificações de parâmetros de entrada.

Respondeu 17/09/2008 em 04:15
fonte usuário

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