Критерии выбора тестов

Стохастические критерии (класс III)

Стохастическое тестирование применяется при тестировании сложных программных комплексов - когда набор детерминированных тестов (X,Y) имеет громадную мощность. В случаях, когда подобный набор невозможно разработать и исполнить на фазе тестирования, можно применить следующую методику.

Разработать программы - имитаторы случайных последовательностей входных сигналов {x}.

Вычислить независимым способом значения {y} для соответствующих входных сигналов {x} и получить тестовый набор (X,Y).

Протестировать приложение на тестовом наборе (X,Y), используя два способа контроля результатов:

Детерминированный контроль - проверка соответствия вычисленного значения $$yв\in \{ y\}$$ значению y, полученному в результате прогона теста на наборе {x} - случайной последовательности входных сигналов, сгенерированной имитатором.

Стохастический контроль - проверка соответствия множества значений {yв}, полученного в результате прогона тестов на наборе входных значений {x}, заранее известному распределению результатов F(Y).

В этом случае множество Y неизвестно (его вычисление невозможно), но известен закон распределения данного множества.

Критерии стохастического тестирования

Cтатистические методы окончания тестирования - стохастические методы принятия решений о совпадении гипотез о распределении случайных величин. К ним принадлежат широко известные: метод Стьюдента ( St ), метод Хи-квадрат ( $$\chi ^{2}$$ ) и т.п.

Метод оценки скорости выявления ошибок - основан на модели скорости выявления ошибок , согласно которой тестирование прекращается, если оцененный интервал времени между текущей ошибкой и следующей слишком велик для фазы тестирования приложения.

(рис 3.1) Зависимость скорости выявления ошибок от времени выявления

При формализации модели скорости выявления ошибок (рис 3.1) использовались следующие обозначения:

N - исходное число ошибок в программном комплексе перед тестированием,

C - константа снижения скорости выявления ошибок за счет нахождения очередной ошибки,

t1, t2,… tn - кортеж возрастающих интервалов обнаружения последовательности из n ошибок,

T - время выявления n ошибок.

Если допустить, что за время T выявлено n ошибок, то справедливо соотношение (1), утверждающее, что произведение скорости выявления i ошибки и времени выявления i ошибки есть 1 по определению:

(1) (N-i+1)*C*ti = 1

В этом предположении справедливо соотношение (2) для n ошибок:

Если из (1) определить ti и просуммировать от 1 до n, то придем к соотношению (3) для времени T выявления n ошибок

Если из (2) выразить C, приходим к соотношению (4):

Наконец, подставляя C в (3), получаем окончательное соотношение (5), удобное для оценок:

Если оценить величину , или данные о плотности ошибок для проектов рассматриваемого класса из исторической базы данных проектов, и, кроме того, использовать текущие данные об интервалах между ошибками t1, t2 … tn, полученные на фазе тестирования, то, подставляя эти данные в (5), можно получить оценку tn+1 -временного интервала необходимого для нахождения и исправления очередной ошибки (будущей ошибки).

Если tn+1>Td - допустимого времени тестирования проекта, то тестирование заканчиваем, в противном случае продолжаем поиск ошибок.

Наблюдая последовательность интервалов ошибок t1, t2 … tn, и время, потраченное на выявление n ошибок $$T=\Sigma t_{i}$$, можно прогнозировать интервал времени до следующей ошибки и уточнять в соответствии с (4) величину C.

Критерий Moranda очень практичен, так как опирается на информацию, традиционно собираемую в процессе тестирования.

Мутационный критерий (класс IV).

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

Подход базируется на следующих понятиях:

Мутации - мелкие ошибки в программе.

Мутанты - программы, отличающиеся друг от друга мутациями .

Метод мутационного тестирования - в разрабатываемую программу P вносят мутации, т.е. искусственно создают программы-мутанты P1, P2... Затем программа P и ее мутанты тестируются на одном и том же наборе тестов (X,Y).

Если на наборе (X,Y) подтверждается правильность программы P и, кроме того, выявляются все внесенные в программы-мутанты ошибки, то набор тестов (X,Y) соответствует мутационному критерию, а тестируемая программа объявляется правильной.

Если некоторые мутанты не выявили всех мутаций, то надо расширять набор тестов (X,Y) и продолжать тестирование.

Пример применения мутационного критерия

Тестируемая программа . Для нее создается две программы-мутанта P1 и P2.

В ).

В ).

При запуске тестов (X,Y) = {(x=2,n=3,y=8),(x=999,n=1,y=999), (x=0,n=100,y=0 } выявляются все ошибки в программах-мутантах и ошибка в основной программе, где в условии цикла вместо n стоит n-1:

//  Метод вычисляет неотрицательную 
//  степень n числа x
static public double PowerNonNeg(
                         double x, int n)
{
double z=1; 
    if (n>0)
    {
        for (int i=1;n-1>=i;i++)
        {
            z = z*x;
        }
    }
    else Console.WriteLine(
       "Ошибка ! Степень числа n должна 
        быть больше 0.");
    return z;
}

double PowerNonNeg(double x, int n)
{
    double z=1;
    int i;
    if (n>0)
    {
        for (i=1;n-1>=i;i++)
        {
            z = z*x;
        }
    }
    else printf(
      "Ошибка ! Степень числа n должна 
      быть больше 0.\n");
    return z;
}

Измененное начальное значение переменной z в мутанте Р1 ( z=2 ):

//  Метод вычисляет неотрицательную 
//  степень n числа x
static public double PowerMutant1(
                         double x, int n)
{
double z=2; 
    if (n>0)
    {
        for (int i=1;n>=i;i++)
        {
            z = z*x;
        }
    }
    else Console.WriteLine(
      "Ошибка ! Степень числа n должна 
       быть больше 0.");
    return z;
}

double PowerMutant1(double x, int n)
{
    double z=2;
    int i;
    if (n>0)
    {
        for (i=1;n>=i;i++)
        {
            z = z*x;
        }
    }
    else printf(
      "Ошибка ! Степень числа n должна 
       быть больше 0.\n");
    return z;
}

Измененное начальное значение переменной i и границы цикла в мутанте P2 ( i=0;n-1 ):

//  Метод вычисляет неотрицательную
//  степень n числа x
static public double PowerMutant2(
                         double x, int n)
{
double z=1; 
    if (n>0)
    {
        for (int i=0;n-1>=i;i++)
        {
            z = z*x;
        }
    }
    else Console.WriteLine(
      "Ошибка ! Степень числа n должна 
       быть больше 0");
    return z;
}

double PowerMutant2(double x, int n)
{
    double z=1;
    int i;
    if (n>0)
    {
        for (i=0;n-1>=i;i++)
        {
            z = z*x;
        }
    }
    else printf(
     "Ошибка ! Степень числа n должна 
      быть больше 0.\n");
    return z;
}