Как использовать комбинации наборов в качестве тестовых данных

Безусловно, особенно имея дело с большим количеством этих перестановок/комбинаций, я определенно вижу, что первый проход будет проблемой.

Интересная реализация в python, хотя я написал хороший вариант в C и Ocaml на основе "Algorithm 515" (см. ниже). Он написал свой в Fortran, как это было принято тогда для всех "Algorithm XX" газет, ну, это assembly или c. Мне пришлось переписать его и сделать некоторые небольшие улучшения для работы с массивами, а не диапазонами чисел. Этот делает случайный доступ, я все еще работаю над получением некоторых хороших реализаций тех, которые упоминаются в брошюре кнута 4-го тома 2. Я объясню читателю, как это работает. Хотя, если кому-то интересно, я бы не возражал написать что-нибудь.

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

~"Алгоритм 515: генерация вектора из лексикографического индекса"; Buckles, B. P., and Lybanon, M. ACM Transactions on Mathematical Software, Vol. 3, № 2, Июнь 1977 Года.

С совершенно новым Python 2.6 у вас есть стандартное решение с модулем itertools, который возвращает декартово произведение 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)]

Вы можете предоставить аргумент "repeat" для выполнения продукта с итерацией и самим собой:

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

Вы также можете настроить что-то с комбинациями, а также :

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

И если порядок имеет значение, есть перестановки :

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

Конечно, все эти крутые вещи не совсем делают одно и то же, но вы можете использовать их так или иначе, чтобы решить свою проблему.

Просто помните, что вы можете преобразовать кортеж или список в набор и наоборот, используя list(), tuple() и set().

Интересный вопрос!

Я бы сделал это, выбирая комбинации, что-то вроде следующего в python. Самое сложное, вероятно, это проверка первого прохода, т. е. if f(1,2,3) returns true, это правильный результат? После того, как вы это проверили, это хорошая основа для регрессионного тестирования.

Вероятно, это хорошая идея, чтобы сделать набор тестовых случаев, которые вы знаете, будут все истинны (например, 3,4,5 для этого случая треугольника), и набор тестовых случаев, которые вы знаете, будут все ложны (например, 0,1, inf). Тогда вам будет легче проверить правильность тестов.

# xpermutations from http://code.activestate.com/recipes/190465
from xpermutations import *

lengths=[-1,0,1,5,10,0,1000,'inf']
for c in xselections(lengths,3):        # or 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);
...

Я думаю, что вы можете сделать это с помощью атрибута Row Test (доступного в MbUnit и более поздних версиях NUnit), где вы можете указать несколько наборов для заполнения одного модульного теста.

Хотя можно создать множество тестовых данных и посмотреть, что произойдет, более эффективно попытаться свести к минимуму используемые данные.

С типичной точки зрения QA, вы бы хотели определить различные классификации входных данных. Создайте набор входных значений для каждой классификации и определите соответствующие выходные значения.

Вот пример классов входных значений

• допустимые треугольники с малыми числами, такими как (1 млрд, 2 млрд, 2 млрд)
• допустимые треугольники с большими числами, такими как (0.000001, 0.00002, 0.00003)
• допустимые тупые треугольники, которые являются "почти" плоскими, например (10, 10, 19.9999)
• допустимые острые треугольники, которые являются 'almost' плоскими, например (10, 10, 0000001)
• неверный треугольников с, по меньшей мере, одно отрицательное значение
• недопустимые треугольники, где сумма двух сторон равна третьей
• недопустимые треугольники, в которых сумма двух сторон больше третьей
• входные значения, которые не являются числовыми ...

После того, как вы удовлетворитесь списком входных классификаций для этой функции, вы можете создать фактические тестовые данные. Вероятно, было бы полезно проверить все перестановки каждого элемента. (например (2,3,4), (2,4,3), (3,2,4), (3,4,2), (4,2,3), (4,3,2)) как правило, вы обнаружите, что некоторые классификации вы пропустили (например, понятие inf в качестве входного параметра).

Случайные данные в течение некоторого периода времени также могут быть полезны, что может привести к обнаружению странных ошибок в коде, но в целом непродуктивно.

Скорее всего, эта функция используется в каком-то конкретном контексте, где применяются дополнительные правила.(например, только целочисленные значения или значения должны быть с шагом 0.01 и т. д.) Они дополняют список классификаций входных параметров.