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-bordeaux.fr machine (x86_64 architecture), and agregate them in the final report:

The target is to exceed 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 - modules - forsubset.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.18.0 lcov report (development 29644-f1a46412a2) Lines: 53 53 100.0 %
Date: 2024-10-12 09:06:38 Functions: 7 7 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* Copyright (C) 2017  The PARI group.
       2             : 
       3             : This file is part of the PARI/GP package.
       4             : 
       5             : PARI/GP is free software; you can redistribute it and/or modify it under the
       6             : terms of the GNU General Public License as published by the Free Software
       7             : Foundation; either version 2 of the License, or (at your option) any later
       8             : version. 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             : #include "pari.h"
      16             : #include "paripriv.h"
      17             : 
      18             : void
      19         168 : forksubset_init(forsubset_t *T, long n, long k)
      20             : {
      21         168 :   T->all = 0;
      22         168 :   T->first = 1;
      23         168 :   T->n = n;
      24         168 :   T->k = k;
      25         168 :   T->v = identity_perm(k);
      26         168 : }
      27             : 
      28             : void
      29          70 : forallsubset_init(forsubset_t *T, long n)
      30             : {
      31          70 :   T->all = 1;
      32          70 :   T->first = 1;
      33          70 :   T->n = n;
      34          70 :   T->k = 0;
      35          70 :   T->v = vecsmalltrunc_init(n + 1);
      36          70 : }
      37             : 
      38             : static GEN
      39        1470 : forksubset_next(forsubset_t *T)
      40             : {
      41        1470 :   GEN v = T->v;
      42        1470 :   long i, n = T->n, k = T->k;
      43             : 
      44        1470 :   if (T->first) { T->first = 0; return (k >= 0 && k <= n) ? v: NULL; }
      45        1232 :   if (k <= 0 || k >= n) return NULL;
      46             : 
      47        1036 :   if (v[k] < n) { v[k]++; return v; }
      48         847 :   for (i = k - 1; i >= 1 && v[i+1] == v[i] + 1; i--);
      49         518 :   if (i == 0) return NULL;
      50             : 
      51         329 :   v[i]++;
      52         784 :   for (; i < k; i++) v[i+1] = v[i] + 1;
      53         329 :   return v;
      54             : }
      55             : static GEN
      56         854 : forallsubset_next(forsubset_t *T)
      57             : {
      58             :   long i;
      59             : 
      60         854 :   if (forksubset_next(T)) return T->v;
      61         238 :   else if (T->k < T->n)
      62             :   {
      63         168 :     (T->k)++;
      64         168 :     setlg(T->v, T->k+1);
      65         588 :     for (i = 1; i <= T->k; i++) (T->v)[i] = i;
      66         168 :     return T->v;
      67             :   }
      68          70 :   return NULL;
      69             : }
      70             : GEN
      71        1470 : forsubset_next(forsubset_t *T)
      72        1470 : { return T->all? forallsubset_next(T): forksubset_next(T); }
      73             : void
      74         245 : forsubset_init(forsubset_t *T, GEN nk)
      75             : {
      76         245 :   switch(typ(nk))
      77             :   {
      78          70 :     case t_INT: forallsubset_init(T, itos(nk)); return;
      79         168 :     case t_VEC:
      80         168 :       if (lg(nk) == 3)
      81             :       {
      82         168 :         GEN n = gel(nk,1), k = gel(nk,2);
      83         168 :         if (typ(n) == t_INT && typ(k) == t_INT)
      84         168 :           return forksubset_init(T, itos(n),itos(k));
      85             :       }
      86             :     default:
      87           7 :       pari_err_TYPE("forsubset", nk);
      88             :   }
      89             : }
      90             : void
      91         245 : forsubset0(GEN nk, GEN code)
      92             : {
      93         245 :   pari_sp av = avma;
      94             :   forsubset_t T;
      95         245 :   void *E = (void*)code;
      96             :   GEN v;
      97         245 :   push_lex(gen_0, code);
      98         245 :   forsubset_init(&T, nk);
      99        1470 :   while ((v = forsubset_next(&T)))
     100        1232 :     if (gp_evalvoid(E, v)) break;
     101         238 :   pop_lex(1); set_avma(av);
     102         238 : }

Generated by: LCOV version 1.16