Kode-værkstedet 2: GCC og kode-dækning

Som tidligere lovet vil jeg sætte mere fokus på nogle af de værktøjer på Linux (eller andre UNIX-varianter såsom FreeBSD/OpenBSD), som jeg har fået øjnene op for det sidste halve år. Et af de mere ukendte er C/C++ kode-dækning, som kan analyseres med GCC selv. Ideen er at oversætte al koden med nogle ekstra parametre, og ved kørsel skrives automatisk hvilke linier af koden, som eksekveres. Det har især relevant, hvis man har mange (f.eks. 100) test-scenarier, hvor man ikke kan overkomme f.eks. at debugge sig igennem dem alle. En god start er "man gcov", som indeholder en let læselig gennemgang af "code coverage" analyse med GCC.

Til eksempel har jeg lavet følgende kode "v2.c". Bemærk at jeg har indsat linienumre som bedre at kunne skrive om hvad der sker i koden. I kan selv hente koden fra Pastebin, hvis I vil have den rå kode.

1:#include
2: 3:int main(int argc, char **argv) 4:{ 5:
6: if (argc<2) 7: printf("ingen argumenter\n");
8: else
9: if (argc%2==1) 10: printf("et lige antal argumenter\n");
11: else 12: printf("et ulige antal argumenter\n");
13: 14: if (argc<=3) 15: printf("Højst to argumenter\n");
16: else 17: printf("Mere end to argumenter\n");
18:
19: return 0;
20:}

Normalt vil man oversætte koden med $ gcc -o v2 v2.c som giver den binære fil "v2" ud fra kildekoden "v2.c". Jeg laver med vilje ikke optimering af koden (-O2 eller -O3) for jeg vil netop ikke miste dele af koden.

Koden oversættes i stedet nu med $ gcc -o v2*** -fprofile-arcs -ftest-coverage*** v2.c

Eksempel er i den lette ende og det er let at se at programmet hopper ned i de forskellige løkker, alt efter antallet af argumenter til "v2" programmet. Første kørsel - uden argumenter. $ ./v2 ingen argumenter Højst to argumenter Som forventet kommer vi ned i linie 7 og linie 15 - vi kan se det på udskriften ovenfor.

Bemærk at allerede ved oversættelsen af programmet dannes en ny fil "v2.gcno", og når koden udføres skrives den egentlige database-fil "v2.gcda" med oversigt over hvad der har været udført.

Fordi koden blev oversat med "-fprofile-arcs -ftest-coverage", kan vi nu analysere kodedækningen (ud fra den ene kørsel af programmet). $ gcov v2.c File 'v2.c' Lines executed:60.00% of 10 v2.c:creating 'v2.c.gcov'

Ud kom "v2.c.gcov" - hvor 60% af de 10 effektive kodelinier har været udført. Lad os se på denne fil:

    -:    0:Source:v2.c
    -:    0:Graph:v2.gcno
    -:    0:Data:v2.gcda
    -:    0:Runs:1
    -:    0:Programs:1
    -:    1:#include        
    -:    2:
    -:    3:int main(int argc, char **argv)
    1:    4:{
    -:    5:                         
    1:    6:  if (argc<2) 
    1:    7:    printf("ingen argumenter\n");     
    -:    8:  else           
#####:    9:    if (argc%2==1)
#####:   10:      printf("et lige antal argumenter\n");   
    -:   11:    else 
#####:   12:      printf("et ulige antal argumenter\n");    
    -:   13:
    1:   14:  if (argc<=3)
    1:   15:    printf("Højst to argumenter\n");   
    -:   16:  else 
#####:   17:    printf("Mere end to argumenter\n");    
    -:   18:  
    1:   19:  return 0;              
    -:   20:}  

Det interessante er især linierne med hash-tegn foran - dvs. linie 10, 12 og 17 som endnu ikke er blevet udført. Vi kan med 1-tallerne foran bla. linie 7 se at de øvrige linier har været udført en gang. Det ser meget fint ud.

Lad os lige køre programmet et par gange mere (her dræber jeg lige tekst-output). $ v2 1 > /dev/null $ v2 1 1 > /dev/null Og igen køres gcov: $ gcov v2.c

    -:    0:Source:v2.c
    -:    0:Graph:v2.gcno
    -:    0:Data:v2.gcda
    -:    0:Runs:3
    -:    0:Programs:1
    -:    1:#include        
    -:    2:
    -:    3:int main(int argc, char **argv)
    3:    4:{
    -:    5:                         
    3:    6:  if (argc<2) 
    1:    7:    printf("ingen argumenter\n");     
    -:    8:  else           
    2:    9:    if (argc%2==1)
    1:   10:      printf("et lige antal argumenter\n");   
    -:   11:    else 
    1:   12:      printf("et ulige antal argumenter\n");    
    -:   13:
    3:   14:  if (argc<=3)
    3:   15:    printf("Højst to argumenter\n");   
    -:   16:  else 
#####:   17:    printf("Mere end to argumenter\n");    
    -:   18:  
    3:   19:  return 0;              
    -:   20:}  

Nu er det kun linie 17 som ikke udført endnu. Det er vigtigt at forstå at den resulterende kode-dækning er en sum af alle gennemløb af koden. Vil man slette historikken så skal "v2.gcda" filen slettes (har man mange C/C++ filer skal alle .gcda filer sletttes).

Jeg har rigtig mange test-gennemløb af min "rigtige kode" og har haft glæde af at se mønstre i koden som ikke eksekveres - netop med de hash-tegn foran de enkelte linier i ".gcov" filerne. Man kan udvide "gcov" kaldet med f.eks. "gcov -b", hvor man ydermere får udvidet fokus på alle branches (især if-else konstruktionerne). En anden rar udvidelse er at anvende programmet "ggcov", som læser output-filerne af "gcov" og præsenterer dette (lidt) grafisk. Et par eksempler kan findes her.

Faren i det her er nemt vises ved at slette "v2.gcda" og lave tre gennemløb.

$ v2 > /dev/null $ v2 1 > /dev/null $ v2 a b c d > /dev/null

Og igen køres gcov:

$ gcov v2.c File 'v2.c' Lines executed:100.00% of 10 v2.c:creating 'v2.c.gcov'

Jubi - alt er udført.... NEJ! Alle kombinationer er ikke udført - men alle linier er mindst udført én gang. Derfor er dette ikke en mirakelkur - men nærmere et værktøj, der kan give nogen hjælp, især med massivt gennemløb af koden.

Er der nogen af jer som anvender dette og har andre tips?

/pto