Code coverage tests

This page documents the degree to which the PARI/GP source code is tested by our public test suite, distributed with the source distribution in directory src/test/. This is measured by the gcov utility; we then process gcov output using the lcov frond-end.

We test a few variants depending on Configure flags on the pari.math.u-bordeaux1.fr machine (x86_64 architecture), and agregate them in the final report:

The target is 90% coverage for all mathematical modules (given that branches depending on DEBUGLEVEL or DEBUGMEM are not covered). This script is run to produce the results below.

LCOV - code coverage report
Current view: top level - language - parse.y (source / functions) Hit Total Coverage
Test: PARI/GP v2.8.0 lcov report (development 17097-9391e68) Lines: 125 129 96.9 %
Date: 2014-11-21 Functions: 0 0 -
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 2 2 100.0 %

           Branch data     Line data    Source code
       1                 :            : %{
       2                 :            : /* Copyright (C) 2006  The PARI group.
       3                 :            : 
       4                 :            : This file is part of the PARI package.
       5                 :            : 
       6                 :            : PARI/GP is free software; you can redistribute it and/or modify it under the
       7                 :            : terms of the GNU General Public License as published by the Free Software
       8                 :            : Foundation. It is distributed in the hope that it will be useful, but WITHOUT
       9                 :            : ANY WARRANTY WHATSOEVER.
      10                 :            : 
      11                 :            : Check the License for details. You should have received a copy of it, along
      12                 :            : with the package; see the file 'COPYING'. If not, write to the Free Software
      13                 :            : Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
      14                 :            : 
      15                 :            : #define YYSIZE_T size_t
      16                 :            : #define YYSTYPE union token_value
      17                 :            : #define YYLTYPE struct node_loc
      18                 :            : #define YYLLOC_DEFAULT(Current, Rhs, N)     \
      19                 :            :         ((Current).start  = ((N)?(Rhs)[1].start:(Rhs)[0].end),  \
      20                 :            :          (Current).end    = (Rhs)[N].end)
      21                 :            : #include "parsec.h"
      22                 :            : #define NOARG(x) newnode(Fnoarg,-1,-1,&(x))
      23                 :            : %}
      24                 :            : %error-verbose
      25                 :            : %name-prefix "pari_"
      26                 :            : %pure-parser
      27                 :            : %parse-param {char **lex}
      28                 :            : %lex-param {char **lex}
      29                 :      38420 : %initial-action{ @$.start=@$.end=*lex; }
      30                 :            : %token KPARROW ")->"
      31                 :            : %token KARROW "->"
      32                 :            : %token KDOTDOT ".."
      33                 :            : %token KPE   "+="
      34                 :            : %token KSE   "-="
      35                 :            : %token KME   "*="
      36                 :            : %token KDE   "/="
      37                 :            : %token KDRE  "\\/="
      38                 :            : %token KEUCE "\\="
      39                 :            : %token KMODE "%="
      40                 :            : %token KAND  "&&"
      41                 :            : %token KOR   "||"
      42                 :            : %token KID   "==="
      43                 :            : %token KEQ   "=="
      44                 :            : %token KNE   "!="
      45                 :            : %token KGE   ">="
      46                 :            : %token KLE   "<="
      47                 :            : %token KSRE  ">>="
      48                 :            : %token KSLE  "<<="
      49                 :            : %token KSR   ">>"
      50                 :            : %token KSL   "<<"
      51                 :            : %token KDR   "\\/"
      52                 :            : %token KPP   "++"
      53                 :            : %token KSS   "--"
      54                 :            : %token <gen> KINTEGER "integer"
      55                 :            : %token <gen> KREAL "real number"
      56                 :            : %token KENTRY "variable name"
      57                 :            : %token KSTRING "character string"
      58                 :            : %left SEQ DEFFUNC
      59                 :            : %left INT LVAL
      60                 :            : %right ")->" "->"
      61                 :            : %left ';' ',' ".."
      62                 :            : %right '=' "+=" "-=" "*=" "/=" "\\/=" "\\=" "%=" ">>=" "<<="
      63                 :            : %left '&' "&&" "||"
      64                 :            : %left "===" "==" "!=" '>' ">=" '<' "<="
      65                 :            : %left '+' '-'
      66                 :            : %left '%' "\\/" '\\' '/' '*' ">>" "<<"
      67                 :            : %left SIGN
      68                 :            : %right '^'
      69                 :            : %left '#'
      70                 :            : %left '!' '~' '[' '\''
      71                 :            : %left '.'
      72                 :            : %left "++" "--"
      73                 :            : %left '('
      74                 :            : %left ':'
      75                 :            : %type <val> seq sequence
      76                 :            : %type <val> range matrix matrix_index expr
      77                 :            : %type <val> lvalue
      78                 :            : %type <val> matrixelts matrixlines arg listarg definition
      79                 :            : %type <val> funcid memberid
      80                 :            : %type <val> backticks history
      81                 :            : %type <val> compr in inseq
      82                 :          0 : %destructor { pari_discarded++; } seq matrix range matrix_index expr lvalue matrixelts matrixlines arg listarg definition funcid memberid backticks history compr in inseq
      83                 :            : %%
      84                 :            : 
      85                 :      38420 : sequence: seq        {$$=$1;} /* skip the destructor */
      86                 :      38420 : ;
      87                 :            : 
      88                 :       3712 : seq: /**/ %prec SEQ  {$$=NOARG(@$);}
      89                 :       3712 :    | expr %prec SEQ  {$$=$1;}
      90                 :     116422 :    | seq ';'         {$$=$1; @$=@1;}
      91                 :      16256 :    | seq ';' expr    {$$=newnode(Fseq,$1,$3,&@$);}
      92                 :       7027 : ;
      93                 :            : 
      94                 :        170 : range: /* */          { $$=newnode(Frange,NOARG(@$),NOARG(@$),&@$); }
      95                 :       2471 :      | expr           { $$=newnode(Frange,$1,NOARG(@$),&@$); }
      96                 :       2461 :      | expr ".." expr { $$=newnode(Frange,$1,$3,&@$); }
      97                 :        205 :      | '^' expr       { $$=newnode(Frange,NOARG(@$),$2,&@$); }
      98                 :         45 : ;
      99                 :            : 
     100                 :        265 : matrix_index: '[' range ',' range ']' {$$=newnode(Fmatrix,$2,$4,&@$);}
     101                 :       2411 :             | '[' range ']'           {$$=newnode(Fmatrix,$2,-1,&@$);}
     102                 :       2146 : ;
     103                 :            : 
     104                 :         25 : backticks: '`' {$$=1;}
     105                 :         25 :          | backticks '`' {$$=$1+1;}
     106                 :         60 : ;
     107                 :            : 
     108                 :         35 : history: '%'           {$$=newopcall(OPhist,-1,-1,&@$);}
     109                 :         45 :        | '%' KINTEGER  {$$=newopcall(OPhist,newintnode(&@2),-1,&@$);}
     110                 :         30 :        | '%' backticks {$$=newopcall(OPhist,newnode(Fsmall,-$2,-1,&@$),-1,&@$);}
     111                 :         25 :        | '%' '#'          {$$=newopcall(OPhisttime,-1,-1,&@$);}
     112                 :         10 :        | '%' '#' KINTEGER {$$=newopcall(OPhisttime,newintnode(&@3),-1,&@$);}
     113                 :         10 :        | '%' '#' backticks{$$=newopcall(OPhisttime,newnode(Fsmall,-$3,-1,&@$),-1,&@$);}
     114                 :          5 : ;
     115                 :            : 
     116                 :    4783796 : expr: KINTEGER %prec INT  {$$=newintnode(&@1);}
     117                 :    4785176 :     | KREAL               {$$=newconst(CSTreal,&@$);}
     118                 :       1380 :     | '.'                 {$$=newconst(CSTreal,&@$);}
     119                 :          0 :     | KINTEGER '.' KENTRY {$$=newnode(Ffunction,newconst(CSTmember,&@3),
     120                 :            :                                                 newintnode(&@1),&@$);}
     121                 :     734085 :     | KSTRING       {$$=newconst(CSTstr,&@$);}
     122                 :     735155 :     | '\'' KENTRY   {$$=newconst(CSTquote,&@$);}
     123                 :       1070 :     | history           {$$=$1;}
     124                 :        210 :     | expr '(' listarg ')'  {$$=newnode(Fcall,$1,$3,&@$);}
     125                 :        130 :     | funcid            {$$=$1;}
     126                 :      43545 :     | lvalue %prec LVAL {$$=$1;}
     127                 :      69400 :     | matrix            {$$=$1;}
     128                 :    2502029 :     | compr             {$$=$1;}
     129                 :        175 :     | definition        {$$=$1;}
     130                 :       1350 :     | matrix '=' expr {$$=newnode(Fassign,$1,$3,&@$);}
     131                 :      11188 :     | lvalue '=' expr {$$=newnode(Fassign,$1,$3,&@$);}
     132                 :      11083 :     | lvalue "++"     {$$=newopcall(OPpp,$1,-1,&@$);}
     133                 :         25 :     | lvalue "--"     {$$=newopcall(OPss,$1,-1,&@$);}
     134                 :         60 :     | lvalue "*="   expr {$$=newopcall(OPme,$1,$3,&@$);}
     135                 :         65 :     | lvalue "/="   expr {$$=newopcall(OPde,$1,$3,&@$);}
     136                 :         10 :     | lvalue "\\/=" expr {$$=newopcall(OPdre,$1,$3,&@$);}
     137                 :         10 :     | lvalue "\\="  expr {$$=newopcall(OPeuce,$1,$3,&@$);}
     138                 :         10 :     | lvalue "%="   expr {$$=newopcall(OPmode,$1,$3,&@$);}
     139                 :         10 :     | lvalue "<<="  expr {$$=newopcall(OPsle,$1,$3,&@$);}
     140                 :         10 :     | lvalue ">>="  expr {$$=newopcall(OPsre,$1,$3,&@$);}
     141                 :         25 :     | lvalue "+="   expr {$$=newopcall(OPpe,$1,$3,&@$);}
     142                 :         40 :     | lvalue "-="   expr {$$=newopcall(OPse,$1,$3,&@$);}
     143                 :        225 :     | '!' expr         {$$=newopcall(OPnb,$2,-1,&@$);}
     144                 :       1065 :     | '#' expr         {$$=newopcall(OPlength,$2,-1,&@$);}
     145                 :       1010 :     | expr "||"  expr  {$$=newopcall(OPor,$1,$3,&@$);}
     146                 :        245 :     | expr "&&"  expr  {$$=newopcall(OPand,$1,$3,&@$);}
     147                 :         95 :     | expr '&'   expr  {$$=newopcall(OPand,$1,$3,&@$);}
     148                 :        195 :     | expr "===" expr  {$$=newopcall(OPid,$1,$3,&@$);}
     149                 :        835 :     | expr "=="  expr  {$$=newopcall(OPeq,$1,$3,&@$);}
     150                 :       1155 :     | expr "!="  expr  {$$=newopcall(OPne,$1,$3,&@$);}
     151                 :        555 :     | expr ">="  expr  {$$=newopcall(OPge,$1,$3,&@$);}
     152                 :        140 :     | expr '>'   expr  {$$=newopcall(OPg,$1,$3,&@$);}
     153                 :        140 :     | expr "<="  expr  {$$=newopcall(OPle,$1,$3,&@$);}
     154                 :        161 :     | expr '<'   expr  {$$=newopcall(OPl,$1,$3,&@$);}
     155                 :       7988 :     | expr '-'   expr  {$$=newopcall(OPs,$1,$3,&@$);}
     156                 :      25757 :     | expr '+'   expr  {$$=newopcall(OPp,$1,$3,&@$);}
     157                 :      17955 :     | expr "<<"  expr  {$$=newopcall(OPsl,$1,$3,&@$);}
     158                 :         80 :     | expr ">>"  expr  {$$=newopcall(OPsr,$1,$3,&@$);}
     159                 :        120 :     | expr '%'   expr  {$$=newopcall(OPmod,$1,$3,&@$);}
     160                 :        125 :     | expr "\\/" expr  {$$=newopcall(OPdr,$1,$3,&@$);}
     161                 :         60 :     | expr '\\'  expr  {$$=newopcall(OPeuc,$1,$3,&@$);}
     162                 :      77992 :     | expr '/'   expr  {$$=newopcall(OPd,$1,$3,&@$);}
     163                 :      94677 :     | expr '*'   expr  {$$=newopcall(OPm,$1,$3,&@$);}
     164                 :      16725 :     | '+' expr %prec SIGN {$$=$2;}
     165                 :    1464627 :     | '-' expr %prec SIGN {$$=newopcall(OPn,$2,-1,&@$);}
     166                 :    1488057 :     | expr '^' expr {$$=newopcall(OPpow,$1,$3,&@$);}
     167                 :      23850 :     | expr '~' {$$=newopcall(OPtrans,$1,-1,&@$);}
     168                 :        425 :     | expr '\'' {$$=newopcall(OPderiv,$1,-1,&@$);}
     169                 :        130 :     | expr '!'  {$$=newopcall(OPfact,$1,-1,&@$);}
     170                 :        610 :     | expr matrix_index {$$=newnode(Fmatcoeff,$1,$2,&@$);}
     171                 :        510 :     | memberid {$$=$1;}
     172                 :       6655 :     | expr ':' KENTRY   {$$=newnode(Ftag,$1,0,&@$);}
     173                 :          0 :     | '(' expr ')' {$$=$2;}
     174                 :       4434 : ;
     175                 :            : 
     176                 :      81463 : lvalue: KENTRY %prec LVAL   {$$=newnode(Fentry,newconst(CSTentry,&@1),-1,&@$);}
     177                 :      83364 :       | lvalue matrix_index {$$=newnode(Fmatcoeff,$1,$2,&@$);}
     178                 :       1901 :       | lvalue ':' KENTRY   {$$=newnode(Ftag,$1,newconst(CSTentry,&@2),&@$);}
     179                 :          0 : ;
     180                 :            : 
     181                 :    2165084 : matrixelts: expr {$$=$1;}
     182                 :    7863855 :           | matrixelts ',' expr {$$=newnode(Fmatrixelts,$1,$3,&@$);}
     183                 :    5698771 : ;
     184                 :            : 
     185                 :       3785 : matrixlines: matrixelts  ';' matrixelts {$$=newnode(Fmatrixlines,$1,$3,&@$);}
     186                 :      15260 :            | matrixlines ';' matrixelts {$$=newnode(Fmatrixlines,$1,$3,&@$);}
     187                 :      11475 : ;
     188                 :            : 
     189                 :     351965 : matrix: '[' ']'             {$$=newnode(Fvec,-1,-1,&@$);}
     190                 :     352090 :       | '[' expr ".." expr ']' {$$=newopcall(OPrange,$2,$4,&@$);}
     191                 :        370 :       | '[' ';' ']'         {$$=newnode(Fmat,-1,-1,&@$);}
     192                 :    2146284 :       | '[' matrixelts ']'  {$$=newnode(Fvec,$2,-1,&@$);}
     193                 :    2149824 :       | '[' matrixlines ']' {$$=newnode(Fmat,$2,-1,&@$);}
     194                 :       3785 :       | '[' error ']'       {$$=-1; YYABORT;}
     195                 :            : ;
     196                 :            : 
     197                 :        225 : in: lvalue '<' '-' expr {$$=newnode(Flistarg,$4,$1,&@$);}
     198                 :        225 : ;
     199                 :            : 
     200                 :        115 : inseq: in                    {$$=newopcall(OPcompr,$1,-2,&@$);}
     201                 :        175 :      | in ',' expr           {$$=newopcall3(OPcompr,$1,-2,$3,&@$);}
     202                 :        100 :      | in ';' inseq          {$$=newopcall(OPcomprc,$1,$3,&@$);}
     203                 :         50 :      | in ',' expr ';' inseq {$$=newopcall3(OPcomprc,$1,$5,$3,&@$);}
     204                 :         10 : ;
     205                 :            : 
     206                 :        175 : compr: '[' expr '|' inseq ']' {$$=addcurrexpr($4,$2,&@$);}
     207                 :        175 : ;
     208                 :            : 
     209                 :      80494 : arg: seq        {$$=$1;}
     210                 :      80504 :    | lvalue '[' ".." ']' {$$=newnode(Fvararg,$1,-1,&@$);}
     211                 :        375 :    | '&' lvalue {$$=newnode(Frefarg,$2,-1,&@$);}
     212         [ +  + ]:        445 :    | arg error  {if (!pari_once) { yyerrok; } pari_once=1;}  expr
     213                 :        160 :                      {pari_once=0; $$=newopcall(OPcat,$1,$4,&@$);}
     214                 :         80 : ;
     215                 :            : 
     216                 :      44640 : listarg: arg {$$=$1;}
     217                 :      80869 :        | listarg ',' arg {$$=newnode(Flistarg,$1,$3,&@$);}
     218                 :      36229 : ;
     219                 :            : 
     220                 :      43545 : funcid: KENTRY '(' listarg ')' {$$=newnode(Ffunction,newconst(CSTentry,&@1),$3,&@$);}
     221                 :      43545 : ;
     222                 :            : 
     223                 :       6655 : memberid: expr '.' KENTRY {$$=newnode(Ffunction,newconst(CSTmember,&@3),$1,&@$);}
     224                 :       6655 : ;
     225                 :            : 
     226                 :            : definition: KENTRY '(' listarg ')' '=' seq %prec DEFFUNC
     227                 :        935 :                                    {$$=newfunc(CSTentry,&@1,$3,$6,&@$);}
     228                 :        935 :           | expr '.' KENTRY '=' seq %prec DEFFUNC
     229                 :          5 :                                    {$$=newfunc(CSTmember,&@3,$1,$5,&@$);}
     230                 :        255 :           | lvalue "->" seq              {$$=newnode(Flambda, $1,$3,&@$);}
     231                 :        280 :           | '(' listarg ")->" seq        {$$=newnode(Flambda, $2,$4,&@$);}
     232                 :         30 : ;
     233                 :            : 
     234                 :            : %%

Generated by: LCOV version 1.9