Control-Flow Based Testing (тестирование управляющей логики программы):
Шаг 1: строим граф, описывающий логику, реализованную в коде
Шаг 2: создаем тест-кейсы для покрытия всех узлов графа, ребер графа (ветки, пути)
Statement coverage (покрытие операторов = Line coverage)
· каждый оператор должен быть выполнен хотя бы один раз
§ слабый критерий – необходимое, но недостаточное условие
«-» затруднен анализ покрытия некоторых управляющих структур (не проверяется условные операторы при значении false, достаточно проверить только для значения true, чтобы выполнить оператор)
>> слабый критерий – обычно не используют
Пример:
If (a>0)
c:=25;
- > один тест для критерия statement coverage для a>0
- > пропускает проверку того, что будет, если a<0
Вranch\Decision coverage (ветки операторов)
· каждое решение должно принять значения истина и ложь по крайней мере один раз и для каждой точки входа должно быть выдано управление хотя бы один раз (IF, CASE, Loop)
§ Более сильный критерий, чем покрытие операторов
· «-» не учитываются условия с вызовами функций внутри условных операторов
§ Необходимый минимум
· Определяем набор путей start-to-end, которые покрывают все ветки графа и пишем для них тесты
Циклы (loops)
Простой цикл
• Пропустить цикл
• Пройти один раз
• Пройти дважды
• Если мах=n, тогда проходим n-1, n и n+1 раз
Вложенный цикл
• Устанавливаем счетчик в min для наружных (внешних) циклов и проверяем внутренние
• Тестируем значения, выходящие за границы
• Все внешние циклы в min
• Пока не протестируем все циклы
Condition coverage (покрытие условий)
· Все возможные результаты каждого решения в условии выполнялись хотя бы один раз (каждая компонента логического условия в результате выполнения тестовых примеров должна принимать все возможные значения) и каждой точке входа в программу или подпрограмму должно быть передано управление хотя бы один раз
|
|
· Более сильный критерий, чем покрытие решений
Data-Flow testing (тестирование потоков данных)
· Анализируем все переменные в коде: их определение (“definitions”\”write”) и использование (“uses”\”read”)
Определяем все DU пары (Def-Use pairs) и пишем тесты, покрывающие все DU пары для всех переменных:
Приложение 1
Конфигурационное управление – построение «билдов».(https://window.edu.ru/window_catalog/pdf2txt?p_id=31136&p_page=4) Рассмотрим проект по разработке программного обеспечения. Что в нем является аналогом материальных активов на обычном производстве? Определенно, не столы и стулья, которыми пользуются разработчики. И даже не компьютеры, запчасти к ним и прочее оборудование. Учета и контроля, сродни складскому, требуют файлыпроекта. В программном проекте их очень много – сотни и тысячи даже для относительно небольших проектов. Ведь создать новый файл очень легко. Многие технологии программирования поддерживают стиль, когда, например, для каждого класса создается свой отдельный файл. Файл – это виртуальная информационная единица. В чем главное отличие файла от материальных единиц учета? В том, что у файла может быть версия, и не одна, и породить эти версии очень легко – достаточно скопировать данный файл в другое место на диске. В то время как материальные предметы существуют на складе сами по себе, и для них нет понятия версии. Да, может быть несколько однотипных предметов, разных заготовок изделия различной степени готовности. Но все это не то….. А версия файла – это очень не простой объект. Чем одна версия отличается от другой? Несколькими строчками текста или полностью обновленным содержанием? И какая из двух и более версий главнее, лучше? К этому добавляется еще и то, что многие рабочие продукты могут состоять из набора файлов, и каждый из них может иметь по несколько версий. Как собрать корректную версию продукта? В итоге в программном проекте начинают происходить мистические и загадочные события. Тщательно про тестированная программа на показательных испытаниях не работает. Функциональность, о которой долго просил заказчик и которая была, наконец, добавлена в продукт, а новая версия торжественно отослана заказчику, таинственным образом исчезла из продукта. На компьютере разработчика программа работает, а у заказчика – нет…. Разгадка проста – все дело в версиях файлов. Там, где все хорошо, присутствуют файлы одной версии, а там, где все плохо – другой. Но беда в том, что «версия всего продукта» – это абстрактное понятие. На деле есть версии отдельных файлов. Один или несколько файлов в поставке продукта имеют не ту версию – все, дело плохо. Необходимоуправлять версиями файлов, а то подобная мистика может стать огромной проблемой. Она серьезно тормозит внутреннюю работу. То разработчики и тестеры работают с разными версиями системы, то итоговая сборка системы требует специальных напряжения усилий всего коллектива. Более того, возможны неприятности на уровне управления. Различные курьезные ситуации, когда заявленная функциональность отсутствует или не работает (опять не те файлы послали!), могут сильно портитьотношения с заказчиком. Недовольный заказчик может потребовать даже денежной компенсации за то, что возникающие ошибки слишком по долгу исправляются. А будет тут не долго, когда разработчики не могут воспроизвести и исправить ошибку, так как немогут точно определить, из каких же исходных текстов была собрана данная версия! Итак, становится понятно, что в программных проектах необходима специальная деятельность по поддержанию файловых активов проекта в порядке. Она и называется конфигурационным управлением. Выделим две основные задачи в конфигурационном управлении – управление версиями и управление сборками. Первое отвечает за управление версиями файлов и выполняется в проекте на основе специальных программных пакетов – средств версионного контроля. Существует большое количество таких средств – Microsoft Visual SourceSafe, IBM ClearCase, cvn, subversion и др. Управление сборками – это автоматизированный процесс трансформации исходных текстов ПО в пакет исполняемых модулей, учитывающий многочисленные настройки проекта, настройки компиляции, и интегрируемый с процессом автоматического тестирования. Эта процедура является мощным средством интеграции проекта, основой итеративной разработки. Единицы конфигурационного управления Так чем же мы управляем в рамках этой деятельности? Любыми ли файлами, которые имеются в проекте? Нет, не любыми, а только теми, которые изменяются. Например, файлы с используемым в проекте покупным ПО должны покоиться на CD-дисках или в локальной сети. Книги, документы с внешними стандартами, используемыми в проекте (например, в телекоммуникациях очень много разных стандартов на сетевые интерфейсы) и пр. также должны просто храниться там, где каждый желающий их может взять. Как правило, такой информации в проекте немного, но, разумеется, она должна быть в порядке. Однако ради этого специальный вид деятельности в проекте не нужен. Итак, конфигурационное управление имеет дело с меняющимися в процессе продуктами, состоящими из наборов файлов. Такие продукты принято называть единицами конфигурационного управления (configuration management items). Вот примеры: 1. пользовательская документация; 2. проектная документация; 3. исходные тексты ПО; 4. пакеты тестов; 5. инсталляционные пакеты ПО; 6. тестовые отчеты. У каждой единицы конфигурационного управления должно быть следующее. 1. Структура – набор файлов. Например, пользовательская документация в html должна включать индекс-файл и набор html-файлов, а также набор вынесенных картинок (gif или jpeg-файлы). Эта структура должна быть хорошо определена и отслеживаться при конфигурационном управлении – что все файлы не потеряны и присутствуют, имеют одинаковую версию, корректные ссылки друг на друга и т.д. 2. Ответственное лицо и, возможно, группу тех, кто их разрабатывает, а также более широкую и менее ответственную группу тех, кто пользуется этой информацией. Например, определенной программной компонентой могут в проекте пользоваться многие разработчики, но отвечать за ее разработку, исправление ошибок и пр. должен кто-то один. 3. Практика конфигурационного управления – кто и в каком режиме, а также в какое место выкладывает новую версию элемента конфигурационного управления в средство управления версиями, правила именования и комментирования элемента в этой версии, дальнейшие манипуляции с ним там и пр. Более высокоуровневые правила, связанные, например, с правилами изменения тестов и тестовых пакетов при изменении кода. Однако, где-то здесь лежит водораздел между конфигурационным управлением и иными видами деятельности в проекте 4. Автоматическая процедура контроля целостности элемента – например, сборка для исходных текстов программ. Есть не у всех элементов, например, может не быть у документации, тестовых пакетов. Элементы конфигурационного управления могут образовывать иерархию. Управление версиями Управление версиями файлов. Поскольку программисты имеют дело с огромным количеством файлов, многие файлы в один момент могут быть необходимы нескольким людям и важно, чтобы все они постоянно составляли единую, как минимум, компилирующуюся версию продукта, необходимо, чтобы была налажена работа с файлами с исходным кодом. Также может быть налажена работа и с другими типами файлов. В этой ситуации файлы оказываются самыми младшими (по иерархии включения) элементами конфигурационного управления. Управление версиями составных конфигурационных объектов. Понятие «ветки» проекта. Одновременно может существовать несколько версий системы – и в смысле для разных заказчиков и пр. (так сказать, в большом, настоящем смысле), и в смысле одного проекта, одного заказчика, но как разный набор исходных текстов. И в том и в другом случае в средстве управления версиями образуются разные ветки. Остановимся чуть подробнее на втором случае. Каждая ветка содержит полный образ исходного кода и других артефактов, находящихся в системе контроля версий. Каждая ветвь может развиваться независимо, а может в определенных точках интегрироваться с другими ветвями. В процессе интеграции изменения, произведенные в одной из ветвей, полуавтоматически переносятся в другую. В качестве примера можно рассмотреть следующую структуру разделения проекта на ветки. • V1.0 – ветвь, соответствующая выпущенному релизу. Внесение изменений в такие ветви запрещены и они хранят образ кода системы на момент выпуска релиза. • Fix V1.0.1 – ветвь, соответствующая выпущенному пакету исправлений к определенной версии. Подобные ветви ответвляются от исходной версии, а не от основной ветви и замораживаются сразу после выхода пакета исправлений. • Upcoming (V1.1) – ветвь, соответствующая релизу, готовящемуся к выпуску и находящемуся в стадии стабилизации. Для таких ветвей, как правило, действуют более строгие правила и работа в них ведется более формально. • Mainline – ветвь, соответствующая основному направлению развития проекта. По мере созревания именно от этой ветви отходят ветви готовящихся релизов. • WCF Experiment – ветвь, созданная для проверки некоторого технического решения, перехода на новую технологию, или внесения большого пакета изменений, потенциально нарушающих работоспособность кода на длительное время. Такие ветви, как правило, делаются доступными только для определенного круга разработчиков и убиваются по завершению работ после интеграции сосновной веткой. Управление сборками Итак, почему же процедура компиляции и создания exe dll файлов по исходникам проекта – такая важная процедура? Потому что она многократно в день выполняется каждым разработчиком на его собственном компьютере, с его собственной версией проекта. При этом отличается: - набор подпроектов, собираемых разработчиком; - он может собирать не весь проект, а только какую-то его часть; - другая часть либо им не используется вовсе, либо не пересобирается очень давно, а по факту она давно изменилась; - отличаются параметры компиляции. При этом если не собирать регулярно итоговую версию проекта, то общая интеграция может выявить много разных проблем: - несоответствие друг другу различных частей проекта; - наличие специфических ошибок, возникших из-за того, что отдельные проекты разрабатывались без учета параметров компиляции (в частности, переход в Visual Studio c debug на release версию часто сопровождается появлением многочисленных проблем). В связи с этим процедуру сборки проекта часто автоматизируют, то есть выполняют не из среды разработки, а из специального скирпта – build-скрипта. Этот скрипт используется тогда, когда разработчику требуется полная сборка всего проекта. А также он используется в процедуре непрерывной интеграции (continues integration) – то есть регулярной сборке всего проекта (как правило – каждую ночь). Как правило, процедура непрерывной интеграции включает в себя и регрессионное тестирование, и часто – создание инсталляционных пакетов. Общая схема автоматизированной сборки: Взять исходники из средства контроля версиями -> используя стандартные настройки сборки вызвать компилятор -> прогон регрессионных тестов -> если тесты прошли, то рассылаем отчет Тестировщики должны тестировать по возможности итоговую и целостную версию продукта, так что результаты регулярной сборки оказываются очень востребованы. Кроме того, наличие базовой, актуальной, целостной версии продукта позволяет организовать разработку в итеративно-инкрементальном стиле, то есть на основе внесения изменений. Такой стиль разработки называется baseline -метод. Baseline – это базовая, последняя целостная версия некоторого продукта разработки, например, документации, программного кода и т.д. Подразумевается, что разработка идет не сплошным потоком, а с фиксацией промежуточных результатов в виде текущей официальной версии разрабатываемого актива. Принятие такой версии сопровождается дополнительными действиями по оформлению, сглаживанию, тестированию, включению только законченных фрагментов и т.д. Это результат можно посмотреть, отдать тестеровщикам, передать заказчику и т.д. Baseline служит хорошимсредством синхронизации групповой работы. Baseline может быть совсем простой – веткой в средстве управления версиями, где разработчики хранят текущую версию своих исходных кодов. Единственным требованием в этом случае может быть лишь общая компилируемость проекта. Но поддержка baseline может быть сложной формальной процедурой. Baseline может также поддерживаться непрерывной интеграцией. Важно, что Baseline (особенно в случае в программными активами) не должна устанавливаться слишком рано. Сначала нужно написать какое-то количество кода, чтобы было что интегрировать. Кроме того, вначале много внимания уделяется разработке основных архитектурных решений, и целостная версия оказывается не востребованной. Но начиная с какого-то момента она просто необходима. Какой этот момент – решать членам команды. Наконец, существую проекты, где автоматическая сборка не нужна вовсе – это простые проекты, разрабатываемые небольшим количеством участников, где нет большого количество исходных текстов программ, проектов, сложных параметров
|
|
|
|
Приложение 2
Рациональный унифицированный процесс (Rational Unified Process - RUP), Лилия Хаф
Рациональный унифицированный процесс (Rational Unified Process, RUP) — одна из спиральных методологий разработки программного обеспечения. Методология поддерживается компанией Rational Software, обновление продукта происходит примерно дважды в год. В качестве языка моделирования в общей базе знаний используется язык Unified Modelling Language (UML).
Итерационная разработка программного обеспечения в RUP предполагает разделение проекта на несколько мелких проектов, которые выполняются последовательно, и каждая итерация разработки четко определена набором целей, которые должны быть достигнуты в конце итерации. Конечная итерация предполагает, что набор целей итерации должен в точности совпадать с набором целей, указанных заказчиком продукта, то есть все требования должны быть выполнены.
RUP достаточно хорошо формализован, и наибольшее внимание уделяется начальным стадиям разработки проекта — анализу и моделированию. Таким образом, эта методология направлена на снижение коммерческих рисков (risk mitigating) посредством обнаружения ошибок на ранних стадиях разработки. Технические риски (assesses) оцениваются и «расставляются» согласно приоритетам на ранних стадиях цикла разработки, а затем пересматриваются с течением времени и с развитием проекта в течение последующих итераций. Новые цели появляются в зависимости от приоритетов данных рисков. Релизы версий распределяются таким образом, что наиболее приоритетные риски устраняются первыми.
Процесс предполагает эволюционирование моделей; итерация цикла разработки однозначно соответствует определенной версии модели программного обеспечения. Каждая из итераций (workflow) содержит элементы управления жизненным циклом программного обеспечения: анализ и дизайн (моделирование), реализация, интегрирование, тестирование, внедрение. В этом смысле RUP является реализацией спиральной модели, хотя довольно часто изображается в виде графика-таблицы. Ниже мы приведем основные компоненты процесса.
Для успешного процесса разработки необходимы три составляющие (Рис. 15):
- процесс (process),
- нотация (notation)
- набор утилит (tools).
Процесс описывает, что мы делаем, в каком порядке и каким образом.
Нотация является средством коммуникации.
Набор утилит автоматизирует и управляет процессом.
Рис. 17. Треугольник успеха
В RUP представлены все три компонента. Сначала рассмотрим функции нотации, которые производят следующие действия:
• осуществляет «склеивание» процесса в единое целое;
• является языковым средством принятия решений, которые не очевидны из исходного кода;
• предоставляет семантику для отображения важных стратегических и тактических решений;
• предлагает форму, достаточную для того, чтобы размышлять, а потом принимать решения и средства автоматизации процесса для того, чтобы манипулировать формализованными данными.
Фактически нотация охватывает разработку программного обеспечения, начиная с анализа и заканчивая внедрением продукта. Нотация в случае RUP–UML — формальное языковое средство описания процесса (об UML речь пойдет ниже). Далее рассмотрим структуру процесса, а также приведем набор утилит, используемых в процессе управления разработкой проекта согласно RUP.
Структура RUP
RUP предоставляет структурированный подход к итерационной разработке программного обеспечения, подразделяя процесс на четыре основные фазы во времени (milestones): Inception (исследование, начало), Elaboration (уточнение плана), Construction (конструирование, построение) и Transition (переход, развертывание). К сожалению, в русском языке нет установившейся терминологии, поэтому в дальнейшем мы будем использовать английские термины, сопровождая их переводом на русский язык. На рис. 2 представлено широко распространенное изображение фаз RUP. Целями каждой из данных фаз являются:
• Inception — понимание, что мы создаем. Фаза сбора информации и анализа требований, определение образа проекта в целом;
• Elaboration — понимание, как мы это создаем. Фаза анализа требований и проектирования системы, планирование необходимых действий и ресурсов, спецификация функций и особенностей дизайна;
• Construction — создание бета-версии продукта. Основная фаза разработки и кодирования, построение продукта как восходящей последовательности итераций (версий кода);
• Transition — создание конечной версии продукта. Фаза внедрения продукта, поставка продукта конкретному пользователю.
Рис. 18. Фазы RUP
Это фазы управления эволюцией продукта — итерациями жизненного цикла. RUP предполагает приближение к конечной цели, но, в отличие от классического стандарта ISO (методология «водопад»), где transition является конечной фазой, каждая из фаз может повторяться несколько раз, отражая изменение требований заказчика продукта.
Методология RUP основана на девяти основных потоках (workflow), являющихся элементами итерации жизненного цикла ПО:
• Business modeling (бизнес-анализ) — предполагает анализ требований на данной итерации жизненного цикла, определение желаемых параметров системы и нужд пользователей;
• Requirements (требования) — формализация образа системы. Предполагает сбор требований и управление требованиями, перевод требований в функциональные спецификации. Здесь начинается анализ прецедентов и построение use cases (пользовательских историй) — формальное отображение требований пользователя в UML. Результатом являются документы уровня менеджмента;
• Analysis and design (анализ и моделирование) — предполагает перевод собранных требований в формализованную программную модель. Результатом является описание системы на фазе реализации (технический проект) — это документы уровня разработчиков системы. Язык формализации — Unified Modelling Language (UML), о котором речь пойдет ниже. В процессе итеративной разработки эволюционировать будет продукт именно этого потока — модель проекта.
Все изменения привязываются в RUP непосредственно к моделям, а средства автоматизации и довольно гибкий язык моделирования позволяют управлять данным процессом более или менее безболезненно в плане затрат времени и ресурсов. Здесь имеется в виду тот факт, что результатом разработки является не модель, а исполняемый код. Поэтому заказчик обычно не очень любит платить за моделирование, так как модели не являются продуктом, который ему нужен;
• Implementation (реализация, кодирование) — предполагает собственно написание кода. Элементы кода в RUP уже созданы на этапе анализа и дизайна, так как средство реализации UML — Rational Rose — позволяет создавать элементы кода на нескольких языках программирования. Методология — объектно-ориентированное программирование;
• Test (тестирование) — предполагает тестирование продукта на данной итерации. Стоит специально отметить, что regression testing (возвратное тестирование, тестирование «неухудшения» продукта) в данном случае должно содержать все актуальные тесты от предыдущей итерации и приемосдаточные тесты от предыдущей transition-фазы;
• Deployment (внедрение) — предполагает установку продукта на полигоне заказчика, подготовку персонала, запуск системы плюс приемо-сдаточные испытания, подготовка стандартов упаковки и распространения продукта, передача материалов отделу продаж (действия опциональны в зависимости от специфики продукта).
Приведенные выше элементы не являются новыми в плане жизненного цикла разработки ПО, поскольку имеют место практически в любой методологии — возможно, за исключением XP (где они, тем не менее, представлены в весьма оригинальном виде).
Особенностью реализации RUP являются временные акценты, а именно — на каких итерациях будут доминировать те или иные потоки, а также наличие универсального языка и набора утилит, позволяющего описывать процесс разработки.
Как мы видим на рис. 2, на начальных этапах эволюции продукта основное внимание уделяется формализации проекта (анализ, моделирование), что направлено на сокращение коммерческих рисков и снижение стоимости ошибок дизайна. Когда картина более или менее ясна, начинаются собственно разработка, тестирование и, наконец, внедрение продукта.
Preliminary interna — это фактически документы, выпускаемые техническим советом для менеджеров предприятия. Основная цель начальных этапов — заключение контракта или соглашения о намерениях. Дальнейшие итерации — собственно начало работы коллектива разработчиков, который имеет время и ресурсы для построения формальных моделей.
UML в данном случае имеет средства, позволяющие отображать модель на элементы кода. Например, дерево объектов отображается непосредственно, вариации зависят от мощности реализации выбранного разработчиками языка программирования, а также от совпадения взглядов Г.Буча и разработчиков данного языка на объектную модель. То же самое относится к методам.
Рассмотрим элементы, касающиеся поддержки продукта — core supporting workflows:
• Configuration management (управление конфигурацией и изменениями) — мощный слой административных действий, направленных на управление версиями продукта, что предполагает контроль исходного кода (модели, исполняемых модулей, тестов, документации), контроль версий продукта, корпоративные стандарты разработки кода и документации, отслеживание изменений и ошибок (bug tracking); тесно связан с тестированием и поддержкой пользователей (customers support);
• Management (управление проектом) — предполагает набор административных действий управления проектом согласно идеологии RUP, используются средства управления проектом (см. ниже список продуктов Rational);
• Environment (окружение) — предполагает создание и поддержку средств анализа, проектирования, разработки, тестирования (как программное, так и аппаратное обеспечение).
В RUP рекомендовано следовать шести практикам, позволяющим успешно разрабатывать проект:
• итеративная разработка;
• управление требованиями;
• использование модульных архитектур;
• визуальное моделирование;
• проверка качества;
• отслеживание изменений.
Практики не являются непосредственно частью процесса RUP, но настоятельно рекомендованы к использованию. Часть практик прямо вытекает из идеологии RUP. Так, итеративная разработка заложена в структуру RUP, поскольку этот процесс является одной из реализаций «спирали». Управление требованиями в RUP появляется на самых ранних стадиях анализа.
Теоретически модульная архитектура позволяет повторно использовать код, и система получается более гибкой. В силу того что UML является объектным языком, игнорировать модульность можно, но… несколько затруднительно.
Визуальное моделирование позволяет эффективно бороться с возрастающей сложностью систем. Кроме того, модели являются средствами коммуникации между разработчиками, но для этого разработчики должны говорить на UML, что предполагает определенный тренинг.
Визуальное моделирование часто осуществляется с помощью инструмента Rational Rose, что позволяет получать набор весьма полезных документов для менеджеров, системных администраторов, разработчиков, тестировщиков, а так же генерировать элементы кода. Данное средство не является единственной реализацией UML — доступны как коммерческие альтернативы (например, Microsoft Visio), так и некоммерческие. Следует отметить, что диалекты UML, реализованные в средствах моделирования, не всегда совпадают: диалект Rational имеет некоторые серьезные различия, описанные как в документации, так и в книгах по UML.