Основные понятия тестирования

Организация тестирования

Тестирование осуществляется на заданном заранее множестве входных данных X и множестве предполагаемых результатов Y – (X,Y), которые задают график желаемой функции. Кроме того, зафиксирована процедура Оракул (oracle), которая определяет, соответствуют ли выходные данные – Yв (вычисленные по входным данным – X) желаемым результатам – Y, т.е. принадлежит ли каждая вычисленная точка (X,Yв) графику желаемой функции (X,Y).

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

Пример сравнения словесного описания пункта спецификации с результатом выполнения фрагмента кода

Пункт спецификации: "Метод Power должен принимать входные параметры: x – целое число, возводимое в степень, и n – неотрицательный порядок степени. Метод должен возвращать вычисленное значение xn ".

Выполняем метод со следующими параметрами: Power(2,2)

Проверка результата выполнения возможна, когда результат вычисления заранее известен – 4. Если результат выполнения 22 = 4, то он соответствует спецификации.

В процессе тестирования Оракул последовательно получает элементы множества (X,Y) и соответствующие им результаты вычислений (X,Yв) для идентификации фактов несовпадений (test incident).

При выявлении $$(X,Yв)\notin (X,Y)$$ запускается процедура исправления ошибки, которая заключается во внимательном анализе (просмотре) протокола промежуточных вычислений, приведших к (X,Yв), с помощью следующих методов:

Пример вставки операторов протоколирования промежуточных результатов

Можно выводить промежуточные значения переменных при выполнении программы. Код, осуществляющий вывод, расположен ниже (Пример 2.3). Этот метод относится к наиболее популярным средствам автоматизации отладки программистов прошлых десятилетий. В настоящее время он известен как метод внедрения "агентов" в текст отлаживаемой программы.

//  Метод вычисляет неотрицательную
//  степень n числа x
static public double Power(double x, int n)
{
  double z=1; 
  
  for (int i=1;n>=i;i++)
  {
    z = z*x;
    Console.WriteLine("i = {0} z = {1}",
                      i, z);
  }
  return z;
}

double Power(double x, int n)
{
  double z=1; 
  int i;
  for (i=1;n>=i;i++)
  {
    z = z*x;
    printf("i = %d z = %f\n",i,z);
  }
  return z;
}

Пример пошагового выполнения программы

При пошаговом выполнении программы код выполняется строчка за строчкой. В среде Microsoft Visual Studio.NET возможны следующие команды пошагового выполнения:

Пошаговое выполнение до сих пор является мощным методом автономного тестирования и отладки небольших программ.

Пример выполнения программы с заказанными контрольными точками и анализом трасс и дампов

Контрольная точка (breakpoint) – точка программы, которая при ее достижении посылает отладчику сигнал. По этому сигналу либо временно приостанавливается выполнение отлаживаемой программы, либо запускается программа "агент", фиксирующая состояние заранее определенных переменных или областей в данный момент.

Когда выполнение в контрольной точке приостанавливается, отлаживаемая программа переходит в режим останова (break mode). Вход в режим останова не прерывает и не заканчивает выполнение программы и позволяет анализировать состояние отдельных переменных или структур данных. Возврат из режима break mode в режим выполнения может произойти в любой момент по желанию пользователя.

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

Трасса - это "сохраненный путь " на управляющем графе программы, т.е. зафиксированные в журнале записи о состояниях переменных в заданных точках в ходе выполнения программы.

Например: на Рис. 2.1 условно изображен управляющий граф некоторой программы. Трасса, проходящая через вершины 0-1-3-4-5 зафиксирована в Табл. 2.1. Строки таблицы отображают вершины управляющего графа программы, или breakpoints, в которых фиксировались текущие значения заказанных пользователем переменных.

(рис 2.1) Управляющий граф программы(рис 2.1) Управляющий граф программы

Трасса, проходящая через вершины 0-1-3-4-5

№ вершины-оператора	Значение переменной x	Значение переменной z	Значение переменной n	Значение переменной i
0	3	1	2	не зафиксировано
1	3	1	2	не зафиксировано
3	3	1	2	1
4	3	3	2	2
5	3	3	2	не зафиксировано

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

Обратное выполнение программы возможно при условии сохранения на каждом шаге программы всех значений переменных или состояний программы для соответствующей трассы. Тогда поднимаясь от конечной точки трассы к любой другой, можно по шагам произвести вычисления состояний, двигаясь от следствия к причине, от состояний на выходе преобразователя данных к состояниям на его входе. Естественно, такие возможности мы получаем в режиме off-line анализа при фиксации в Log – файле всей истории выполнения трассы.

Пример обратного выполнения для программы вычисления степени числа x

В программе на Пример 2.4 фиксируются значения всех переменных после выполнения каждого оператора.

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

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

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

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

Тестирование заканчивается, когда выполнилось или "прошло" (pass) успешно достаточное количество тестов в соответствии с выбранным критерием тестирования.

Тестирование – это:

Сквозной пример тестирования

Возьмем несколько отличающуюся от Пример 2.4 программу:

//  Метод вычисляет степень n числа x
static public double Power(int x, int n)
{
  int z=1; 
  for (int i=1;n>=i;i++)
  {
    z = z*x;
  }
  return z;
}

[STAThread]
static void Main(string[] args)
{
  int x;
  int n;
  try
  {
    Console.WriteLine("Enter x:");
    x=Convert.ToInt32(Console.ReadLine());
    if ((x>=0)  (x<=999))
    {
      Console.WriteLine("Enter n:");
      n=Convert.ToInt32(Console.ReadLine());
      if ((n>=1)  (n<=100))
      {
        Console.WriteLine("The power n" + " of x is {0}", Power(x,n));
        Console.ReadLine();
      }
      else
      {
        Console.WriteLine("Error : n " + "must be in [1..100]");
        Console.ReadLine();
      }
    }
    else
    {
      Console.WriteLine("Error : x " + "must be in [0..999]");
      Console.ReadLine();
    }
  }
  catch (Exception e)
  {
    Console.WriteLine("Error : Please enter " + "a numeric argument.");
    Console.ReadLine();
  }
}

#include <stdio.h>

double Power(int x, int n)
{
  int z=1;
  int i; 
  for (i=1;n>=i;i++)
  {
    z = z*x;
  }
  return z;
}

void main(void)
{
  int x;
  int n;
  
  printf("Enter x:");
  if(scanf("%d",x))
  {
    if ((x>=0)  (x<=999))
    {
      printf("Enter n:");
      if(scanf("%d",n)) {
        if ((n>=1)  (n<=100))
        {
          printf("The power n of x is %f\n", Power(x,n));
        }
        else
        {
          printf("Error : n must be in [1..100]\n");
        }
      }
      else
      {
        printf("Error : Please enter a numeric argument\n");
      }
    }
    else
    {
      printf("Error : x must be in [0..999]\n");
    }
  }
  else
  {
    printf("Error : Please enter a numeric argument\n");
  }
}

Для приведенной программы, вычисляющей степень числа (Пример 2.5), воспроизведем последовательность действий, необходимых для тестирования.

Спецификация программы

На вход программа принимает два параметра: x - число, n – степень. Результат вычисления выводится на консоль.

Значения числа и степени должны быть целыми.

Значения числа, возводимого в степень, должны лежать в диапазоне – [0..999].

Значения степени должны лежать в диапазоне – [1..100].

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

Разработка тестов

Определим области эквивалентности входных параметров.

Для x – числа, возводимого в степень, определим классы возможных значений:

Анализ тестовых случаев

Выполнение тестовых случаев

Запустим программу с заданными значениями аргументов.

Оценка результатов выполнения программы на тестах

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

Три фазы тестирования

Реализация тестирования разделяется на три этапа:

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

Простой пример

Рассмотрим вопросы тестирования на примере простой программы (Пример 2.6) на языке С#. Текст этой программы и некоторых других несколько видоизменен с целью сделать иллюстрацию описываемых фактов более прозрачной.

/* Функция вычисляет неотрицательную
   степень n числа x */
1  double Power(double x, int n){
2  double z=1; int i;
3  for (i=1;
4  n>=i;
5  i++)
6  {z = z*x;} /* Возврат в п.4 */
7  return z;}

/* Функция вычисляет неотрицательную
   степень n числа x */
1  double Power(double x, int n){
2  double z=1; int i;
3  for (i=1;
4  n>=i;
5  i++)
6  {z = z*x;} /* Возврат в п.4 */
7  return z;}

Управляющий граф программы (УГП) на Рис. 2.2 отображает поток управления программы. Нумерация узлов графа совпадает с нумерацией строк программы. Узлы 1 и 2 не включаются в УГП, поскольку отображают строки описаний, т.е. не содержат управляющих операторов.

Управляющий граф программы

Управляющий граф программы (УГП) – граф G(V,A), где V(V1,… Vm) – множество вершин (операторов), A(A1,… An) – множество дуг (управлений), соединяющих операторы-вершины.

Путь – последовательность вершин и дуг УГП, в которой любая дуга выходит из вершины Vi и приходит в вершину Vj, например: (3,4,7), (3,4,5,6,4,5,6), (3,4), (3,4,5,6)

Ветвь – путь (V1, V2, … Vk), где V1 - либо первый, либо условный оператор программы, Vk - либо условный оператор, либо оператор выхода из программы, а все остальные операторы – безусловные, например: (3,4) (4,5,6,4) (4,7). Пути, различающиеся хотя бы числом прохождений цикла – разные пути, поэтому число путей в программе может быть не ограничено. Ветви - линейные участки программы, их конечноe число.

Существуют реализуемые и нереализуемые пути в программе, в нереализуемые пути в обычных условиях попасть нельзя.

float H(float x,float y)
  {
  float H;
1  if (x*x+y*y+2<=0)
2  H = 17;
3  else H = 64;
4  return H*H+x*x;
  }

float H(float x,float y)
  {
  float H;
1  if (x*x+y*y+2<=0)
2  H = 17;
3  else H = 64;
4  return H*H+x*x;
  }

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

Основные проблемы тестирования

Рассмотрим два примера тестирования:

// Прочитать значения датчика
static public bool ReadSensor(bool Sensor)
{
  //...чтение значения датчика
  Console.WriteLine("...reading sensor value");
  return Sensor;
}

// Открыть схват
static public void OpenHand()
{
  //...открываем схват
  Console.WriteLine("...opening hand");
}

//  Закрыть схват
static public void CloseHand()
{
  //...закрываем схват
  Console.WriteLine("...closing hand");
}

[STAThread]
static void Main(string[] args)
{
  while (true)
  {
    Console.WriteLine("Enter Sensor value (true/false)");
    if (ReadSensor(Convert.ToBoolean(Console.ReadLine())))
    {
      OpenHand();
      CloseHand();
    }
  }
}

#include <stdio.h>

/* Прочитать значения датчика */
int ReadSensor(int Sensor)
{
  /* ...чтение значения датчика */
  printf("...reading sensor value\n");
  return Sensor;
}

/* Открыть схват */
void OpenHand()
{
  /* ...открываем схват */
  printf("...opening hand\n");
}

/* Закрыть схват */
void CloseHand()
{
  /* ...закрываем схват */
  printf("...closing hand\n");
}

void main(void)
{
  int s;
  while (1)
  {
    printf("Enter Sensor value (0/1)");
    scanf("%d",s);
    if (ReadSensor(s))
    {
      OpenHand();
      CloseHand();
    }
  }
}

Отсюда вывод:

Задача о выборе конечного набора тестов (X,Y) для проверки программы в общем случае неразрешима.

Поэтому для решения практических задач остается искать частные случаи решения этой задачи.