Kurs2011

(true) либо по убыванию (false) и формируемый процедурой Обработка массива в результате анализа значения sum. Подпрограмма Сортировка возвращает в вызывающую процедуру Обработка массива отсортированный массив B.

Процедура Сортировка вызывает Сортировку по убыванию либо Сортировку по возрастанию в зависимости от полученного флага Inc.

Подпрограмма Возврат отсортированных элементов должна расставить отсортированный элементы B на места положительных либо отрицательных элементов в массиве A (в зависимости от флага Pos).

Алгоритмизация. Далее, с целью уточнения описаний структурных компонентов, осуществляем следующий этап проектирования – разработку алгоритмов. Напомним, что в случае сложных систем, проектирование, реализация и тестирование осуществляются совместно, в порядке, определяемом иерархическим, операционным или комбинированным методами (см. выше). В виду ограниченного объема издания, приведем примеры лишь трех алгоритмов: основной программы, процедуры Обработка массива и процедуры Выбор элементов для сортировки, см. приложение 3.

Тестирование программных продуктов. Тестирование – этап разработки ПО,

предназначенный для выявления ошибок, допущенных в ходе разработки. Существует несколько видов контроля качества разрабатываемого ПО; в том числе:

ручной контроль ПО (путем просмотра программ); структурное тестирование; функциональное тестирование.

Структурное тестирование (структурный подход) базируется на том, что нам известна структура тестируемого ПО и в том числе его алгоритмы («стеклянный ящик»). При этом формируют тестовые наборы данных и контролируют правильность прохождения маршрутов (последовательность операторов программы), предусмотренных алгоритмом. Формирование тестовых наборов может осуществляться по нескольким критериям. В данной лабораторной работе мы остановимся на одном из них: покрытие решений (переходов). Для реализации этого критерия необходимо такое количество и состав тестов, чтобы результат проверки каждого условия (т. е. решения) принимал значения «истина» или «ложь», по крайней мере, один раз.

Пример 11.3. Составить тестовые наборы для тестирования процедуры Обработка массива (рисунок 5).

Решение. Для схемы алгоритма ОБРАБ(А, N), см. приложение 3, составляем соответствующий граф передачи управления, см. приложение 4.

Алгоритм предусматривает три пути: 1–2–3–4–5–7–8–9–10, 1–2–3–4–6–7–8–9–10 и 1–2–3–10, покрывающих решения. Для прохождения указанных маршрутов формируем следующие тестовые значения переменной Sum:

sum = 3 – путь 1–2–3–4–6–7–8–9–10; sum = 7 – путь 1–2–3–4–5–7–8–9–10; sum = 5 – путь 1–2–3–10.

Функциональное тестирование (функциональный подход) основывается на том, что структура ПО неизвестна («черный ящик»). В этом случае тесты строят на основе функциональных спецификаций. Данный подход предусматривает несколько

12

методов формирования тестовых наборов, один из которых – эквивалентное разбиение – мы и рассмотрим в данной лабораторной работе. Метод эквивалентного разбиения заключается в следующем. Область всех возможных наборов входных данных программы по каждому параметру разбивают на конечное число групп – классов эквивалентности. Наборы данных объединяют по принципу обнаружения одних и тех же ошибок: если набор какого-либо класса обнаруживает некоторую ошибку, то предполагается, что все другие тесты этого класса эквивалентности тоже обнаружат эту ошибку и наоборот. Классы эквивалентности выделяют, перебирая ограничения, установленные для каждого входного значения. Каждое ограничение разбивают на две или более групп. При этом используют специальные бланки – таблицы классов эквивалентности. Разработку тестов осуществляют в два этапа: на первом выделяют классы эквивалентности, а на втором – формируют тесты.

Пример 11.4. Разработать тесты для программы из примера 2.1 (лабораторной работы № 2). Напомним, что в примере 2.1 требовалось вычислить следующую функцию.

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

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

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

13

Рисунок 6. Тестирование программного обеспечения при восходящем подходе:

а - автономное тестирование модулей нижнего уровня; б - тестирование следующего уровня

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

Основной

модуль

а)

Основной

модуль

б)

Рисунок 7. Начальные этапы тестирования:

а - основного модуля; б - двух модулей

14

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

Пример 11.5. Произвести кодирование алгоритмов рассмотренной программы сортировки массива и выполнить структурное тестирование.

Решение. В качестве примера приведем начальные этапы реализации проекта. Первый этап. Программа Level_0 предназначена для тестирования алгоритма

основной программы, см. приложение 3.

Program Level_0;

Const Nmax=10;

Type Mas=array[1..Nmax] of Shortint; var n: Byte;

a: Mas;

Procedure PRINT(Mp: Mas; Np:Byte); {Technological} var i: Byte;

Begin

For i:=1 to Np do Write(Mp[i]:4);

End;

{--------INPUT-------}

Procedure Input(var Mi: Mas; var Ni: Byte);

Const M: Mas =(-4, -3, -2, -1, 0, 1, 2, 3, 4, 5); Begin { of Input }

Mi:=M; Ni:=Nmax;

Write('INPUT '); Print(Mi,Ni); WriteLn(' Ni=', Ni);

End; { of Input }

{--------TRANSFORM-------}

Procedure Transform(var Mt: Mas; Nt: Byte);

Const M: Mas =(0, 1, 2, 3, 4, 5, -4, -3, -2, -1);

Begin { of Transform }

Write('TRANSF 1 ');

Print(Mt,Nt);

WriteLn(' Nt=', Nt);

Mt:=M;

Write('TRANSF 2 ');

Print(Mt,Nt);

WriteLn;

End; { of Transform }

15

{--------OUTPUT-------}

Procedure Output(Mo: Mas; No: Byte);

Begin { of Output }

Write('OUTPUT ');

Print(Mo,No);

WriteLn(' No=', No);

End; { of Output }

begin { of Program } Input(a, n); Transform(a, n); Output(a, n);

end. { of Program }

К о м м е н т а р и и к программе Level_0.

Программа имеет всего две глобальных переменных: A (для хранения исходного и полученного массива), n (число элементов исходного массива), что и требуется, исходя из схемы алгоритма или карты Константайна (рисунок 5). Глобальная константа Nmax определяет максимальное число элементов входного массива.

Программа содержит заглушки трех процедур: Input (Ввод массива), Transform (Обработка массива), Output (Вывод массива), а также технологическую процедуру Print, предназначенную для вывода на экран содержимого массива. Заглушки можно было сделать гораздо проще, имеющими в своем теле лишь один оператор WriteLn() с именем процедуры в аргументе. Однако было решено проконтролировать, как массив, сформированный типовой константой M внутри процедуры Input, получает через свои аргументы процедура Transform, а затем «преобразованный» массив принимает процедура Output. В результате выполнения программы мы получим следующее сообщение, свидетельствующее о правильной работе основного модуля.

Завершая комментарии, обратим внимание на связи основного модуля с тремя вызываемыми, рисунок 5. На карте видно, чтó процедуры возвращают в основную программу: процедура Ввод массива – массив и число его элементов, процедура Обработка массива – только массив, а процедура Вывод массива – ничего. Поэтому, например, в процедуре Input все параметры определены как параметры-переменные, а у процедуры Output – как параметры-значения.

Второй этап. Программа Level_1_T предназначена для тестирования алгоритма процедуры ОБРАБ(A, N), см. приложение 3. (Здесь мы отступили от операционного метода разработки ПО, чтобы продемонстрировать тестирование нетривиального алгоритма).

16

Program Level_1_T; Const Nmax=10;

Type Mas=array[1..Nmax] of Shortint; var n: Byte;

a: Mas;

{--------INPUT-------}

Procedure Input(var Mi: Mas; var Ni: Byte); Begin { of Input }

WriteLn;

WriteLn('INPUT (Level 0) '); End; { of Input }

{--------TRANSFORM-------}

Procedure Transform(var Mt: Mas; Nt: Byte); Type SumType=0..9;

var IncreaseFlag, PositiveFlag: Boolean; b: Mas;

n1: Byte; Sum: SumType;

Procedure Analysis(Ar:Mas; N:Byte; var Sum: SumType; var PositiveFlag: Boolean);

Begin { of Analysis } Sum:=3;

WriteLn('Analysis. Sum=',Sum); End; { of Analysis }

Procedure Choice(ArA:Mas; var ArB:Mas; N:Byte; var N1:Byte; PositiveFlag: Boolean);

Procedure Ret(var ArA:Mas; ArB:Mas; N, N1:Byte;

PositiveFlag: Boolean);

Begin { of Ret }

WriteLn('Ret');

17

End; { of Ret }

Begin { of Transform }

Analysis(Mt, Nt, Sum, IncreaseFlag); If (Sum<>5) Then

begin

If (Sum>5) Then

begin

IncreaseFlag:= True; WriteLn('Inc=',IncreaseFlag,'

(increase)')

end Else

begin

IncreaseFlag:= False; WriteLn('Inc=',IncreaseFlag,'

(decrease)')

end;

Choice(Mt, b, Nt, n1, PositiveFlag); Sort(b, n1, IncreaseFlag);

Ret(Mt, b, Nt, n1, PositiveFlag); end;

End; { of Transform }

begin { of Program } Input(a, n); Transform(a, n); Output(a, n);

end. { of Program }

К о м м е н т а р и и к программе Level_1_T.

Тестирование процедуры осуществляется в соответствии со схемой на рисунке 7 б. На первом иерархическом уровне находятся тестируемая процедура Transform и заглушки Input, Output. Второй уровень составляют вызываемые процедурой Transform заглушки: Analysis (Анализ), Choice (Выбор элементов для сортировки), Sort (Сортировка) и Ret (Возврат отсортированных элементов).

18

Внутри процедуры Transform определены: флаги IncreaseFlag, PositiveFlag (Inc, Pos на рисунке 5 и в алгоритме), B (массив элементов, требующих сортировки); n1 (количество этих элементов) и процедуры: Analysis, Choice, Sort, Ret.

Из текста программы видно, что заглушка Analysis задает константой значение суммы цифр числа элементов (Sum:=3;), что соответствует первому пути, указанному в примере 11.3. Запуская программу на выполнение, получаем следующий вывод на экран:

INPUT (Level 0)

Analysis. Sum=3 Inc=FALSE (decrease) Choice

Sort

Ret

OUTPUT (Level 0)

Это свидетельствует о том, что при данном значении арифметического корня процедура работает в соответствии с алгоритмом.

Заменив константу в процедуре Analysis на 7, получаем следующий вывод, свидетельствующий о правильности прохождения второго маршрута:

INPUT (Level 0)

Analysis. Sum=7 Inc=TRUE (increase) Choice

Sort

Ret

OUTPUT (Level 0)

Заменив константу на 5, убеждаемся в правильности прохождения и третьего пу-

ти:

INPUT (Level 0)

Analysis. Sum=5

OUTPUT (Level 0)

Таким образом, мы делаем вывод, что процедура Transform работает в соответствии с алгоритмом ОБРАБ(A, N).

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

Затем осуществляем функциональное тестирование программного продукта. Тестовые наборы составляем с учетом того, что программа составлялась без защиты от неверных входных значений. Ниже приведена таблица правильных классов эквивалентности для параметров: Sum (сумма цифр числа элементов массива), m – число элементов массива, имеющих нечетные значения; n – число элементов массива.

19

Минимальное число тестов, покрывающее все функции программы, равно трем: тест 1 объединяет классы 1 и 4, тест 2 – классы 3 и 5, тест 3 – класс 2 и любой из классов: 4 или 5.

* – любое значение.

Тест 1. n=13 Sum=4; m=6 (n–m)=7. В результате должна выполниться сортировка неотрицательных элементов по убыванию.

Исходный файл:

2 -5 0 11 2 3 -4 5 6 8 9 13 -70

Выходной файл:

13 -5 11 9 8 6 -4 5 3 2 2 0 -70

Тест 2. n=15 Sum=6; m=8 (n–m)=7. В результате должна выполниться сортировка отрицательных элементов по возрастанию.

Исходный файл:

2 -5 0 11 2 3 -4 5 6 8 9 13 -70 -11 15

Выходной файл:

2 -70 0 11 2 3 -11 5 6 8 9 13 -5 -4 15

Тест 3. n=14 Sum=5. Сортировка осуществляться не должна. Исходный файл:

2 -5 0 11 2 3 -4 5 6 8 9 13 -70 -11

Выходной файл:

2 -5 0 11 2 3 -4 5 6 8 9 13 -70 -11

Результаты тестирования свидетельствуют о том, что программа функционирует в соответствии со спецификацией.

ЗАДАНИЕ

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

20