Мутационное тестирование

«Анализ мутаций» перенаправляется сюда. Чтобы узнать о биологическом термине, см. Анализ мутаций генов .

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

Введение

Большая часть этой статьи посвящена «мутации программы», при которой программа модифицируется. Более общее определение анализа мутаций заключается в использовании четко определенных правил, определенных в синтаксических структурах, для внесения систематических изменений в программные артефакты. Мутационный анализ применялся и к другим проблемам, но обычно его применяют к тестированию. Таким образом, мутационное тестирование определяется как использование мутационного анализа для разработки новых тестов программного обеспечения или оценки существующих тестов программного обеспечения. Таким образом, анализ и тестирование мутаций можно применять к моделям проектирования, спецификациям, базам данных, тестам, XML и другим типам программных артефактов, хотя мутация программ является наиболее распространенной.

Обзор

Тесты могут создаваться для проверки правильности реализации данной программной системы, но создание тестов по-прежнему ставит вопрос, являются ли тесты корректными и в достаточной ли степени покрывают требования, породившие реализацию. (Эта технологическая проблема сама по себе является примером более глубокой философской проблемы, называемой « Quis custodiet ipsos custodes? » [«Кто будет охранять охрану?»].) Идея тестирования мутаций заключается в том, что если вводится мутант, это обычно вызывает ошибка в функционале программы, которую должны найти тесты. Таким образом тесты проверяются. Если мутант не обнаруживается набором тестов, это обычно означает, что набор тестов не может обнаружить недостатки, представленные мутантом, но это также может указывать на то, что мутация не вызывает ошибок, то есть мутация является действительным изменением. это не влияет на функциональность. Один (распространенный) способ, которым мутант может быть действительным, заключается в том, что измененный код является «мертвым кодом», который никогда не выполняется.

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

Цели

Целей мутационного тестирования несколько:

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

История

Мутационное тестирование было первоначально предложено Ричардом Липтоном, будучи студентом, в 1971 году. и впервые разработан и опубликован ДеМилло, Липтоном и Сэйвордом. Первую реализацию инструмента тестирования мутаций осуществил Тимоти Бадд в рамках своей докторской работы (под названием « Анализ мутаций ») в 1980 году в Йельском университете .

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

В 2004 году компания Certess Inc. (ныне часть Synopsys ) распространила многие принципы на область проверки оборудования. В то время как анализ мутаций предполагает обнаружить только разницу в полученных выходных данных, Certess расширяет его, проверяя, что программа проверки на тестовом стенде действительно обнаружит разницу. Это расширение означает, что оцениваются все три этапа проверки, а именно: активация, распространение и обнаружение. Они назвали это функциональной квалификацией.

Фаззинг можно рассматривать как частный случай мутационного тестирования. При фаззинге сообщения или данные, которыми обмениваются внутри коммуникационных интерфейсов (как внутри, так и между экземплярами программного обеспечения), изменяются, чтобы выявить сбои или различия в обработке данных. Кодомикон (2001) и Mu Dynamics (2005) развили концепции фаззинга до платформы тестирования мутаций с полным сохранением состояния, оснащенной мониторами для тщательной проверки реализации протоколов.

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

Тестирование мутаций основано на двух гипотезах. Первая — это гипотеза компетентного программиста . Эта гипотеза утверждает, что компетентные программисты пишут программы, близкие к правильным. «Закрыть» должно основываться на поведении, а не на синтаксисе. Вторая гипотеза называется эффектом связи . Эффект связи утверждает, что простые неисправности могут каскадно или объединяться , образуя другие возникающие неисправности.

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

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

Например, рассмотрим следующий фрагмент кода C++:

if (a && b) {
    c = 1;
} else {
    c = 0;
}

Оператор мутации условия заменит && с || и произвести следующий мутант:

if (a || b) {
    c = 1;
} else {
    c = 0;
}

Теперь, чтобы тест убил этого мутанта, должны быть выполнены следующие три условия:

1. Тест должен достичь измененного утверждения.
2. Входные данные теста должны влиять на состояние программы, вызывая разные состояния программы для мутанта и исходной программы. Например, тест с a = 1 и b = 0 сделал бы это.
3. Неправильное состояние программы (значение «c») должно распространиться на выход программы и быть проверено тестом.

Эти условия в совокупности называются моделью RIP .

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

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

Обнаружение эквивалентных мутантов является одним из самых больших препятствий для практического использования мутационного тестирования. Усилия, необходимые для проверки эквивалентности мутантов, могут быть очень высокими даже для небольших программ. Систематический обзор литературы 2014 года, посвященный широкому спектру подходов к решению проблемы эквивалентных мутантов. определил 17 соответствующих методов (в 22 статьях) и три категории методов: обнаружение (DEM); внушение (СЭМ); и избежание генерации эквивалентных мутантов (AEMG). Эксперимент показал, что мутации высшего порядка в целом и стратегия JudyDiffOp в частности обеспечивают многообещающий подход к проблеме эквивалентных мутантов.

В дополнение к эквивалентным мутантам существуют отнесенные к категории мутанты , которые представляют собой мутанты, которые существуют в том же месте исходного кода, что и другой мутант, и, как говорят, «отнесены» к другому мутанту. Включенные мутанты невидимы для инструмента тестирования мутаций и не влияют на показатели покрытия. Например, предположим, что у вас есть два мутанта, A и B, которые одинаково меняют строку кода. Мутант А тестируется первым, и в результате код работает неправильно. Затем тестируется мутант B, и результат тот же, что и в случае с мутантом A. В этом случае считается, что мутант B относится к мутанту A, поскольку результат тестирования мутанта B такой же, как и результат тестирования мутанта A. Поэтому Мутанта Б не нужно тестировать, так как результат будет таким же, как и Мутанта А.

Операторы мутации

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

Многие операторы мутаций были исследованы исследователями. Вот несколько примеров операторов мутации для императивных языков:

• Удаление заявления
• Дублирование или вставка оператора, например goto fail;
• Замена логических подвыражений на true и false
• Замена одних арифметических операций другими, например + с *, - с /
• Замена некоторых логических отношений другими, например > с >=, == и <=
• Замена переменных другими из той же области действия (типы переменных должны быть совместимыми)
• Удалить тело метода.

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

Типы операторов мутации

Операторы для контейнеров называются операторами мутации на уровне класса . Операторы на уровне класса изменяют структуру программы, добавляя, удаляя или изменяя проверяемые выражения. Для каждой категории изменений установлены конкретные операторы. Например, инструмент muJava предлагает различные операторы мутации на уровне класса, такие как изменение модификатора доступа, вставка оператора приведения типа и удаление оператора приведения типа. Операторы мутации также были разработаны для тестирования уязвимостей безопасности программ.

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

Виды мутационного тестирования

Существует три типа мутационного тестирования;

Мутация заявления

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

Например, в приведенном ниже фрагменте кода удален весь раздел else:

function checkCredentials(username, password) {
  if (username === "admin" && password === "password") {
    return true;
  } 
}

Мутация значения

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

Во-первых, происходит преобразование маленького значения в большее. Это влечет за собой замену маленького значения в коде на большее. Цель этого изменения — оценить, как код реагирует на более крупные входные данные. Это помогает гарантировать, что код сможет точно и эффективно обрабатывать эти большие значения, не встречая ошибок или неожиданных проблем.

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

Например:

// Original code
function multiplyByTwo(value) {
  return value * 2;
}

// Value mutation: Small value to higher value
function multiplyByTwoMutation1(value) {
  return value * 10;
}

// Value mutation: Higher value to small value
function multiplyByTwoMutation2(value) {
  return value / 10;
}

Мутация решения

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

Например:

// Original code
function isPositive(number) {
  return number > 0;
}

// Decision mutation: Changing the comparison operator
function isPositiveMutation1(number) {
  return number >= 0;
}

// Decision mutation: Negating the result
function isPositiveMutation2(number) {
  return !(number > 0);
}

См. также

• Создание ошибок (или посев ошибок)
• Тестирование на вменяемость
• Внесение неисправностей