Покритие на кода

Накратко: Покритието на операторите пита дали всеки ред код е изпълнен. Покритието на разклоненията пита дали всяко решение е минало и по двата си пътя. За функцията за доставката първото иска 2 теста, второто 3. 100 % разклонения включва 100 % оператори, но не и обратното. И никое покритие не казва, че резултатът е проверен или че границата е на мястото си.

Проблем

100 % покритие, грешна такса

Програмистът пуска тестовете на доставката с инструмент, който брои кои редове са изпълнени. Тестовете са два: 0 € и 60 €. Отчетът казва: 100 % от редовете.

На следващия ден клиентите с количка за 30 € плащат 4,99 € доставка, вместо 4,90 €. Редът с таксата беше изпълнен. Никой тест не видя какво пише в него.

Идеята

Бялата кутия

Досега тестовете идваха от правилото: това е черната кутия. Техниките на бялата кутия (white-box) взимат тестовете от кода: кои редове има и по кои пътища може да мине програмата.

Не трябва да можеш да пишеш код за този урок. Трябва да можеш да прочетеш функцията за доставката. Езикът е по избор, в табовете:

Java

static String delivery(double total) {
    if (total <= 0) {
        return "отказана";
    }
    double fee = 4.90;
    if (total >= 50) {
        fee = 0;
    }
    return String.format("%.2f €", fee);
}

C#

static string Delivery(double total)
{
    if (total <= 0)
    {
        return "отказана";
    }
    double fee = 4.90;
    if (total >= 50)
    {
        fee = 0;
    }
    return $"{fee:F2} €";
}

Python

def delivery(total):
    if total <= 0:
        return "отказана"
    fee = 4.90
    if total >= 50:
        fee = 0
    return f"{fee:.2f} €"

JavaScript

function delivery(total) {
  if (total <= 0) {
    return "отказана";
  }
  let fee = 4.9;
  if (total >= 50) {
    fee = 0;
  }
  return `${fee.toFixed(2)} €`;
}

Функцията има две решения (места, където програмата избира път): „сумата е 0 или по-малко“ и „сумата е от 50 нагоре“. Второто е „ако“ без „иначе“: ако е невярно, програмата просто прескача реда, който нулира таксата.

Идеята

Покритие на операторите

Покритието на операторите (statement coverage) пита: колко от редовете, които правят нещо, е изпълнил поне един тест?

Ето двата теста от началото, като извиквания на функцията, с изхода им:

Java

System.out.println("0 € → " + delivery(0));
System.out.println("60 € → " + delivery(60));

Изход

0 € → отказана
60 € → 0.00 €

C#

Console.WriteLine("0 € → " + Delivery(0));
Console.WriteLine("60 € → " + Delivery(60));

Изход

0 € → отказана
60 € → 0.00 €

Python

print("0 € →", delivery(0))
print("60 € →", delivery(60))

Изход

0 € → отказана
60 € → 0.00 €

JavaScript

console.log("0 € → " + delivery(0));
console.log("60 € → " + delivery(60));

Изход

0 € → отказана
60 € → 0.00 €

• 0 € минава през първата проверка и връща „отказана“.
• 60 € минава през всичко останало: таксата става 4,90, после проверката „от 50“ я прави 0, после връщането.

Всеки ред е изпълнен. Покритието на операторите е 100 %, с два теста.

Идеята

Покритие на разклоненията

Покритието на разклоненията (branch coverage) пита друго: всяко решение минало ли е и по двата си пътя?

Разклоненията тук са четири: първата проверка вярна и невярна, втората вярна и невярна. 0 € минава първата като вярна. 60 € минава първата като невярна и втората като вярна. Втората като невярна не я минава никой: това е празният път на „ако“ без „иначе“. Покритието е 3 от 4, тоест 75 %.

Трети тест, с платена доставка, затваря дупката:

Java

System.out.println("0 € → " + delivery(0));
System.out.println("30 € → " + delivery(30));
System.out.println("60 € → " + delivery(60));

Изход

0 € → отказана
30 € → 4.90 €
60 € → 0.00 €

C#

Console.WriteLine("0 € → " + Delivery(0));
Console.WriteLine("30 € → " + Delivery(30));
Console.WriteLine("60 € → " + Delivery(60));

Изход

0 € → отказана
30 € → 4.90 €
60 € → 0.00 €

Python

print("0 € →", delivery(0))
print("30 € →", delivery(30))
print("60 € →", delivery(60))

Изход

0 € → отказана
30 € → 4.90 €
60 € → 0.00 €

JavaScript

console.log("0 € → " + delivery(0));
console.log("30 € → " + delivery(30));
console.log("60 € → " + delivery(60));

Изход

0 € → отказана
30 € → 4.90 €
60 € → 0.00 €

Три теста, 100 % от разклоненията. И отговорът на въпроса на урока: за 100 % покритие на разклоненията на функцията за доставката трябват 3 теста.

По-точно, за любопитните

ISTQB CTFL v4.0.1 описва двете мерила в раздел 4.3: statement testing и branch testing. Покритието е брой изпълнени оператори (или минати разклонения) върху всички, в проценти. Програмата казва и връзката им: 100 % покритие на разклоненията включва 100 % покритие на операторите, но не и обратното.

Има и по-строги мерила: покритие на условията (всяко условие вътре в решението е видяно и вярно, и невярно) и MC/DC (всяко условие е показало, че само то може да смени решението). MC/DC се иска за най-критичния софтуер в авиацията. Те не са в CTFL v4.0.

Покритието се мери с инструмент: JaCoCo за Java, coverlet за C#, coverage.py за Python, c8 или вграденото в Node за JavaScript. Тестовете се пускат, а инструментът отбелязва кои редове и разклонения са минати.

Пробвай

Колко теста?

1. Тест с количка за 0 €. Кои части на функцията изпълнява?

Всички редовеНищо: сумата е 0Само първата проверка и връщането на „отказана“

2. Тестовете са 0 € и 60 €. Какво е покритието на разклоненията?

100 %50 %3 от 4 (75 %): проверката „от 50“ никога не е била невярна

3. Кой тест довежда разклоненията до 100 %?

Втори тест с 0 €Количка за 100 €Количка между 0,01 и 49,99 €, например 30 €

Провери

Идеята

Защо 100 % оператори пропусна таксата

Ето функцията от началото, с таксата 4,99:

Java

static String delivery(double total) {
    if (total <= 0) {
        return "отказана";
    }
    double fee = 4.99;
    if (total >= 50) {
        fee = 0;
    }
    return String.format("%.2f €", fee);
}

C#

static string Delivery(double total)
{
    if (total <= 0)
    {
        return "отказана";
    }
    double fee = 4.99;
    if (total >= 50)
    {
        fee = 0;
    }
    return $"{fee:F2} €";
}

Python

def delivery(total):
    if total <= 0:
        return "отказана"
    fee = 4.99
    if total >= 50:
        fee = 0
    return f"{fee:.2f} €"

JavaScript

function delivery(total) {
  if (total <= 0) {
    return "отказана";
  }
  let fee = 4.99;
  if (total >= 50) {
    fee = 0;
  }
  return `${fee.toFixed(2)} €`;
}

С двата теста за операторите изходът е същият като на правилната функция:

Java

System.out.println("0 € → " + delivery(0));
System.out.println("60 € → " + delivery(60));

Изход

0 € → отказана
60 € → 0.00 €

C#

Console.WriteLine("0 € → " + Delivery(0));
Console.WriteLine("60 € → " + Delivery(60));

Изход

0 € → отказана
60 € → 0.00 €

Python

print("0 € →", delivery(0))
print("60 € →", delivery(60))

Изход

0 € → отказана
60 € → 0.00 €

JavaScript

console.log("0 € → " + delivery(0));
console.log("60 € → " + delivery(60));

Изход

0 € → отказана
60 € → 0.00 €

При 60 € редът с таксата се изпълнява, но веднага след него таксата става 0. Грешната стойност никога не стига до изхода. Изпълнен не значи проверен.

Третият тест, този за пълните разклонения, минава по празния път и показва таксата:

Java

System.out.println("0 € → " + delivery(0));
System.out.println("30 € → " + delivery(30));
System.out.println("60 € → " + delivery(60));

Изход

0 € → отказана
30 € → 4.99 €
60 € → 0.00 €

C#

Console.WriteLine("0 € → " + Delivery(0));
Console.WriteLine("30 € → " + Delivery(30));
Console.WriteLine("60 € → " + Delivery(60));

Изход

0 € → отказана
30 € → 4.99 €
60 € → 0.00 €

Python

print("0 € →", delivery(0))
print("30 € →", delivery(30))
print("60 € →", delivery(60))

Изход

0 € → отказана
30 € → 4.99 €
60 € → 0.00 €

JavaScript

console.log("0 € → " + delivery(0));
console.log("30 € → " + delivery(30));
console.log("60 € → " + delivery(60));

Изход

0 € → отказана
30 € → 4.99 €
60 € → 0.00 €

Затова покритието на разклоненията е по-силно. Празният път на „ако“ е точно мястото, където стойност от горния ред стига до клиента.

Идеята

Какво покритието не казва

Ето проверката на лимита в количката: добавянето се отказва, ако е по-малко от 1 бройка или ако в количката ще станат повече от 10.

Java

static boolean canAdd(int inCart, int add) {
    if (add < 1 || inCart + add > 10) {
        return false;
    }
    return true;
}

C#

static bool CanAdd(int inCart, int add)
{
    if (add < 1 || inCart + add > 10)
    {
        return false;
    }
    return true;
}

Python

def can_add(in_cart, add):
    if add < 1 or in_cart + add > 10:
        return False
    return True

JavaScript

function canAdd(inCart, add) {
  if (add < 1 || inCart + add > 10) {
    return false;
  }
  return true;
}

Две извиквания дават 100 % от разклоненията: (5, 0) минава през „отказ“, (2, 3) през „прието“.

Java

System.out.println(canAdd(5, 0));
System.out.println(canAdd(2, 3));

Изход

false
true

C#

Console.WriteLine(CanAdd(5, 0));
Console.WriteLine(CanAdd(2, 3));

Изход

False
True

Python

print(can_add(5, 0))
print(can_add(2, 3))

Изход

False
True

JavaScript

console.log(canAdd(5, 0));
console.log(canAdd(2, 3));

Изход

false
true

Сега смени „> 10“ на „> 11“. Същите два теста минават, покритието е пак 100 %, а 11-ата бройка влиза в количката. Покритието мери какво е изпълнено, не колко близо до границата. Тестът (10, 1) от урока за граничните стойности хваща грешката.

И нещо, което никое покритие не може да види: липсващ код. Ако проверката за празна количка изобщо не е написана, няма ред, който да не е покрит. 100 % покритие на код, който не прави нужното, е пак 100 %. Затова бялата кутия не заменя черната. Покритието казва къде няма тестове, а не че тестовете са добри.

Упражнение

Покритието на лимита

1. Две условия, едно решение. Въпросите са за проверката на лимита по-горе.

1. Колко теста трябват за 100 % покритие на разклоненията на проверката за лимита?

4: по един на всяка комбинация от двете условия2: един, при който условието е вярно, и един, при който е невярно1

2. В кода „> 10“ е сменено на „> 11“. Тестовете (5, 0) и (2, 3) дават ли 100 % разклонения?

Не: покритието падаДа, и падатДа, и пак минават: грешката е на границата, до която никой тест не стига

3. При тестовете (5, 0) и (2, 3) частта „в количката плюс добавяното е над 10“ изобщо изпълнена ли е?

Само при (2, 3), и там е невярна; никой тест не я прави вярнаИ при двата е вярнаНе, никога

Провери

Тест

Провери се

1. Откъде идват тестовете при техниките на бялата кутия?

От опита на тестераОт структурата на кодаОт изискванията

2. Кое е вярно?

100 % покритие на разклоненията дава и 100 % покритие на операторитеДвете са едно и също100 % оператори дава 100 % разклонения

3. Тестовете дават 100 % покритие на операторите, а такса 4,99 € вместо 4,90 € минава незабелязана. Защо?

Покритието е сметнато грешноРедът с таксата се изпълнява, но стойността му се сменя, преди някой да я видиЗащото кодът е на Java

4. Какво не може да каже никое покритие на кода?

Кои редове са изпълнениЧе кодът прави каквото трябва и че нещо, което липсва в кода, не трябваКои разклонения са минати

Провери

Започни урока отначало

Свързани уроци

• Нужно отпреди: Защо рано · Класове на еквивалентност · Гранични стойности · Таблица на решения
• Продължава в: Тестване по опит
• Задачи по темата: Техники за тестов дизайн