Разница между выражением и принятием решения

Утверждение считается, что каждый оператор в коде выполняется хотя бы один раз.
Утверждение/ответвление веток, как говорят, проверяет, что каждая ветвь/выход решений проверена, то есть все утверждения в обеих ветвях false/true будут выполнены.
Но разве это не то же самое? В охвате Statement мне нужно выполнить все заявления, поэтому я предполагаю, что это можно сделать только путем запуска всех возможных способов. Я знаю, что здесь что-то не хватает.

Ответ 1

Если тесты имеют полное покрытие ветки, то мы можем сказать, что оно также имеет полное покрытие заявления, но не наоборот.

100% покрытие ветки => 100% покрытие заявления

100% покрытие заявления не подразумевает 100% покрытие ветки

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

if(a){
   if(b){
     bool statement1 = true;
   }
}

a = true, b = true обеспечит 100% покрытие выписки, но не покрытие ветки

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

Ответ 2

Ответ Павла не совсем прав, по крайней мере, я так думаю (согласно определениям ISTQB). Там довольно значительная разница между выражением, решением/ветвью и охватом условий. Я буду использовать образец из другого ответа, но немного изменился, поэтому я могу показать все три примера тестового покрытия. Написанные здесь тесты дают 100% -ное покрытие для каждого типа.

if(a || b)) {
    test1 = true;
}
else {
    if(c) {
      test2 = true
    }
}

Здесь мы имеем два утверждения: если (a || b) и if (c), чтобы полностью объяснить эти различия покрытия:

отчет оператора должен проверять каждое утверждение хотя бы один раз, поэтому нам нужно всего два теста:
- a = true b = false - это дает нам путь, если (a || b) true → test1 = true
- a = false, b = false и c = true - это дает нам путь: if (a || b) false → else → if (c) → test2 = true.

Таким образом мы выполнили каждое утверждение.

отрасль/решение нуждается в еще одном тесте:
- a = false, b = false, c = false - это приводит нас к этой секунде, если мы выполняем ложную ветвь из этого оператора, которая не была выполнена в оболочке оператора
Таким образом, мы проверили все ветки, то есть мы прошли все пути.
охват состояния нуждается в другом тесте:
- a = false, b = true - ведет по тому же пути, что и первый тест, но выполняет другое решение в инструкции OR (a || b), чтобы пройти через него.

Таким образом, мы протестировали все условия, что означает, что мы прошли все пути (ветки) и вызвали его с каждым условием, которое мы могли бы - сначала утверждение "если" было истинным в первом тесте из-за того, что оно было вызвано = true, и в последний тест, потому что b = true вызвал его. Конечно, кто-то может утверждать, что этот случай с a = true и b = true также должен быть проверен, но когда мы проверим, как работает "или", мы можем видеть, что он не нужен, а также переменная c может иметь любое значение как в этих тестах он не оценивается.

По крайней мере, я это интерпретировал. Если кому-то все еще интересно:)

РЕДАКТОР. В большинстве источников, которые я нашел в последнее время, термины покрытия решения/ветки эквивалентны, и термин, который я описывал как покрытие для принятия решений, на самом деле является условием покрытия, следовательно, обновление ответа.

Ответ 3

У вас может быть выражение вроде:

if(a || b || (c && d && !e)) {
    test1 = true;
} else {
    test2 = false;
}

Если в вашем покрытии кода указано, что строки test1 и test2 попадают, тогда у вас есть охват операторов, но для получения полного охвата веток вам нужно будет проверить, когда true, когда a является ложным, но b истинно, когда a и b являются ложными, но c и d являются истинными, а e - ложными и т.д.

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

Ответ 4

Хороший вопрос Объяснение, которое я часто использую, состоит в том, что оператор if без ветки else по-прежнему содержит невидимый "пустой" оператор else:

Простое покрытие операторов просто настаивает на том, что все операторы, которые на самом деле существуют, действительно выполняются.
Покрытие ветки настаивает на том, что выполняются даже невидимые ветки else.

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

Пример кода:

if (passwordEnteredOK()) {
    enterSystem();
} 
/* Invisible else part 
else {
  // do nothing
}
*/

При покрытии выписки вы просто проверяете, что с правильным паролем вы можете использовать систему. В зоне покрытия ветки вы также проверяете, что с неверным паролем вы не войдете в систему.