Metoda cea mai simpla de testare a codului

Sa presupunem ca avem următoarele funcții:

#include "stdio.h"
#include "time.h"

#define  TRUE  1U
#define  FALSE  0U

#define  SUCCES TRUE
#define  GRESEALA FALSE


char add(char a, char b)
{
  return (a+b);
}
char sub(char a, char b)
{
  return (a-b);
}

Metoda cea mai simpla de testare este pur și simplu sa apelezi funcțiile. Suna un pic trivial dar după părerea mea aceasta este cea mai eficienta metoda sa testezi o funcție. Aceasta metoda de testare nu implica doar apelul, ci și considerarea tuturor situațiilor și scenariilor relevante pentru programator. De exemplu apelul funcției cu niște valori de parametrii din interiorul intervalului și de la limitele intervalului. Aceasta metoda de testare se numește testarea limitelor. Cu cat se aleg mai multe valori cu atat funcția e mai bine testata și foarte sigura de folosit. O alta metoda de testare mai elaborata ar fi apelul de funcții într-o anumita ordine și după seria de apeluri utilizatorul se așteaptă la un anumit efect. Practic un scenariu din "real life" se testează în acest fel și cu cat mai realiste sunt scenariile cu atat mai bine e testata o funcționalitate.

char test_adunare_1()
{
  char x,y;
  char rezultat;
  x = 1;
  y = 5;

  /* Apeleaza functia pe care vrei sa o testezi*/
  rezultat = add(x,y);

  /* Testezi ce ar trebui sa rezulte */
  if(rezultat == 6)
  {
    printf("\nTestul a trecut! rezultatul corect este : %d", rezultat);
    return SUCCES;
  }
  else
  {
    printf("\nTestul nu a trecut! rezultatul este : %d", rezultat);
    return GRESEALA;
  }
}

/* In acest test consideram limita de sus a intervalului [-128 to 127],
adica 127, datorita faptului ca tipul char este cu semn pe 1 byte.
Practic in acest test se verifica overflow-ul pentru ca se aduna 1 la 127 
ceea ce duce la un rezultat neasteptat daca nu se cunoaste exact ce face de 
fapt functia testata */
char test_adunare_2()
{
  char x,y;
  char rezultat;
  x = 127;
  y = 1;

  /* Apeleaza functia pe care vrei sa o testezi*/
  rezultat = add(x,y);

  /* Ce ar trebui sa rezulte aici ? */
  if(rezultat == (-128))
  {
    printf("\nTestul a trecut! Rezultatul corect este : %d", rezultat);
    return SUCCES;
  }
  else
  {
    printf("\nTestul nu a trecut! Rezultatul este : %d", rezultat);
    return GRESEALA;
  }
}

/* In acest test consideram limita de jos a intervalului [-128 to 127],
adica 127. La fel ca si la testul de mai sus se ajunge la un overflow  */
char test_adunare_3()
{
  char x,y;
  char rezultat;
  x = (-128);
  y = (-1);

  /* Apeleaza functia pe care vrei sa o testezi*/
  rezultat = add(x,y);

  /* Ce ar trebui sa rezulte aici ? */
  if(rezultat == 127)
  {
    printf("\nTestul a trecut! rezultatul corect este : %d", rezultat);
    return SUCCES;
  }
  else
  {
    printf("\nTestul nu a trecut! rezultatul este : %d", rezultat);
    return GRESEALA;
  }
}
int main()
{
  char rez1;
  char rez2;
  char rez3;

  rez1 = test_adunare_1();
  rez2 = test_adunare_2();
  rez3 = test_adunare_3();

  return 0;
}

Rezultatul rulării programului de mai sus este acesta:

$ test_adunare.exe
Testul a trecut! rezultatul corect este : 6
Testul a trecut! rezultatul corect este : -128
Testul a trecut! rezultatul corect este : 127

Mai departe rezultatele se pot afișa într-un raport care e de fapt o dovada către departamentul de calitate. Daca de exemplu funcția care este testata se modifica atunci eventualele greșeli de funcționalitate se regăsesc în testele picate. E simplu și foarte eficient. Ideea de baza este sa se cunoască încă din faza de testare "limitele" software-ului pe care tocmai l-am creeat. Testarea în nici un caz nu trebuie sa cada pe umerii utilizatorului final.
O zi buna tuturor!