LCOV - differential code coverage report
Current view: top level - src/test/isolation - specparse.y (source / functions) Coverage Total Hit UBC CBC
Current: Differential Code Coverage 16@8cea358b128 vs 17@8cea358b128 Lines: 95.9 % 98 94 4 94
Current Date: 2024-04-14 14:21:10 Functions: - 0 0
Baseline: 16@8cea358b128 Branches: - 0 0
Baseline Date: 2024-04-14 14:21:09 Line coverage date bins:
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed (240..) days: 95.9 % 98 94 4 94

 Age         Owner                    Branch data    TLA  Line data    Source code
                                  1                 :                : %{
                                  2                 :                : /*-------------------------------------------------------------------------
                                  3                 :                :  *
                                  4                 :                :  * specparse.y
                                  5                 :                :  *    bison grammar for the isolation test file format
                                  6                 :                :  *
                                  7                 :                :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
                                  8                 :                :  * Portions Copyright (c) 1994, Regents of the University of California
                                  9                 :                :  *
                                 10                 :                :  *-------------------------------------------------------------------------
                                 11                 :                :  */
                                 12                 :                : 
                                 13                 :                : #include "postgres_fe.h"
                                 14                 :                : 
                                 15                 :                : #include "isolationtester.h"
                                 16                 :                : 
                                 17                 :                : 
                                 18                 :                : TestSpec        parseresult;            /* result of parsing is left here */
                                 19                 :                : 
                                 20                 :                : %}
                                 21                 :                : 
                                 22                 :                : %expect 0
                                 23                 :                : %name-prefix="spec_yy"
                                 24                 :                : 
                                 25                 :                : %union
                                 26                 :                : {
                                 27                 :                :     char       *str;
                                 28                 :                :     int         integer;
                                 29                 :                :     Session    *session;
                                 30                 :                :     Step       *step;
                                 31                 :                :     Permutation *permutation;
                                 32                 :                :     PermutationStep *permutationstep;
                                 33                 :                :     PermutationStepBlocker *blocker;
                                 34                 :                :     struct
                                 35                 :                :     {
                                 36                 :                :         void  **elements;
                                 37                 :                :         int     nelements;
                                 38                 :                :     }           ptr_list;
                                 39                 :                : }
                                 40                 :                : 
                                 41                 :                : %type <ptr_list> setup_list
                                 42                 :                : %type <str>  opt_setup opt_teardown
                                 43                 :                : %type <str> setup
                                 44                 :                : %type <ptr_list> step_list session_list permutation_list opt_permutation_list
                                 45                 :                : %type <ptr_list> permutation_step_list blocker_list
                                 46                 :                : %type <session> session
                                 47                 :                : %type <step> step
                                 48                 :                : %type <permutation> permutation
                                 49                 :                : %type <permutationstep> permutation_step
                                 50                 :                : %type <blocker> blocker
                                 51                 :                : 
                                 52                 :                : %token <str> sqlblock identifier
                                 53                 :                : %token <integer> INTEGER
                                 54                 :                : %token NOTICES PERMUTATION SESSION SETUP STEP TEARDOWN TEST
                                 55                 :                : 
                                 56                 :                : %%
                                 57                 :                : 
                                 58                 :                : TestSpec:
                                 59                 :                :             setup_list
                                 60                 :                :             opt_teardown
                                 61                 :                :             session_list
                                 62                 :                :             opt_permutation_list
                                 63                 :                :             {
 4240 kgrittn@postgresql.o       64                 :CBC         132 :                 parseresult.setupsqls = (char **) $1.elements;
                                 65                 :            132 :                 parseresult.nsetupsqls = $1.nelements;
 4815 heikki.linnakangas@i       66                 :            132 :                 parseresult.teardownsql = $2;
                                 67                 :            132 :                 parseresult.sessions = (Session **) $3.elements;
                                 68                 :            132 :                 parseresult.nsessions = $3.nelements;
                                 69                 :            132 :                 parseresult.permutations = (Permutation **) $4.elements;
                                 70                 :            132 :                 parseresult.npermutations = $4.nelements;
                                 71                 :                :             }
                                 72                 :                :         ;
                                 73                 :                : 
                                 74                 :                : setup_list:
                                 75                 :                :             /* EMPTY */
                                 76                 :                :             {
 4240 kgrittn@postgresql.o       77                 :            132 :                 $$.elements = NULL;
                                 78                 :            132 :                 $$.nelements = 0;
                                 79                 :                :             }
                                 80                 :                :             | setup_list setup
                                 81                 :                :             {
 2784 tgl@sss.pgh.pa.us          82                 :            266 :                 $$.elements = pg_realloc($1.elements,
                                 83                 :            133 :                                          ($1.nelements + 1) * sizeof(void *));
 4240 kgrittn@postgresql.o       84                 :            133 :                 $$.elements[$1.nelements] = $2;
                                 85                 :            133 :                 $$.nelements = $1.nelements + 1;
                                 86                 :                :             }
                                 87                 :                :         ;
                                 88                 :                : 
                                 89                 :                : opt_setup:
 4815 heikki.linnakangas@i       90                 :            127 :             /* EMPTY */         { $$ = NULL; }
 4240 kgrittn@postgresql.o       91                 :            195 :             | setup             { $$ = $1; }
                                 92                 :                :         ;
                                 93                 :                : 
                                 94                 :                : setup:
                                 95                 :            328 :             SETUP sqlblock      { $$ = $2; }
                                 96                 :                :         ;
                                 97                 :                : 
                                 98                 :                : opt_teardown:
 4815 heikki.linnakangas@i       99                 :            311 :             /* EMPTY */         { $$ = NULL; }
                                100                 :            143 :             | TEARDOWN sqlblock { $$ = $2; }
                                101                 :                :         ;
                                102                 :                : 
                                103                 :                : session_list:
                                104                 :                :             session_list session
                                105                 :                :             {
 2784 tgl@sss.pgh.pa.us         106                 :            380 :                 $$.elements = pg_realloc($1.elements,
                                107                 :            190 :                                          ($1.nelements + 1) * sizeof(void *));
 4815 heikki.linnakangas@i      108                 :            190 :                 $$.elements[$1.nelements] = $2;
                                109                 :            190 :                 $$.nelements = $1.nelements + 1;
                                110                 :                :             }
                                111                 :                :             | session
                                112                 :                :             {
                                113                 :            132 :                 $$.nelements = 1;
 2784 tgl@sss.pgh.pa.us         114                 :            132 :                 $$.elements = pg_malloc(sizeof(void *));
 4815 heikki.linnakangas@i      115                 :            132 :                 $$.elements[0] = $1;
                                116                 :                :             }
                                117                 :                :         ;
                                118                 :                : 
                                119                 :                : session:
                                120                 :                :             SESSION identifier opt_setup step_list opt_teardown
                                121                 :                :             {
 2784 tgl@sss.pgh.pa.us         122                 :            322 :                 $$ = pg_malloc(sizeof(Session));
 4815 heikki.linnakangas@i      123                 :            322 :                 $$->name = $2;
                                124                 :            322 :                 $$->setupsql = $3;
                                125                 :            322 :                 $$->steps = (Step **) $4.elements;
                                126                 :            322 :                 $$->nsteps = $4.nelements;
                                127                 :            322 :                 $$->teardownsql = $5;
                                128                 :                :             }
                                129                 :                :         ;
                                130                 :                : 
                                131                 :                : step_list:
                                132                 :                :             step_list step
                                133                 :                :             {
 2784 tgl@sss.pgh.pa.us         134                 :           2068 :                 $$.elements = pg_realloc($1.elements,
                                135                 :           1034 :                                          ($1.nelements + 1) * sizeof(void *));
 4815 heikki.linnakangas@i      136                 :           1034 :                 $$.elements[$1.nelements] = $2;
                                137                 :           1034 :                 $$.nelements = $1.nelements + 1;
                                138                 :                :             }
                                139                 :                :             | step
                                140                 :                :             {
                                141                 :            322 :                 $$.nelements = 1;
 2784 tgl@sss.pgh.pa.us         142                 :            322 :                 $$.elements = pg_malloc(sizeof(void *));
 4815 heikki.linnakangas@i      143                 :            322 :                 $$.elements[0] = $1;
                                144                 :                :             }
                                145                 :                :         ;
                                146                 :                : 
                                147                 :                : 
                                148                 :                : step:
                                149                 :                :             STEP identifier sqlblock
                                150                 :                :             {
 2784 tgl@sss.pgh.pa.us         151                 :           1356 :                 $$ = pg_malloc(sizeof(Step));
 4815 heikki.linnakangas@i      152                 :           1356 :                 $$->name = $2;
                                153                 :           1356 :                 $$->sql = $3;
 1027 tgl@sss.pgh.pa.us         154                 :           1356 :                 $$->session = -1; /* until filled */
 1695 michael@paquier.xyz       155                 :           1356 :                 $$->used = false;
                                156                 :                :             }
                                157                 :                :         ;
                                158                 :                : 
                                159                 :                : 
                                160                 :                : opt_permutation_list:
                                161                 :                :             permutation_list
                                162                 :                :             {
 4815 heikki.linnakangas@i      163                 :            118 :                 $$ = $1;
                                164                 :                :             }
                                165                 :                :             | /* EMPTY */
                                166                 :                :             {
                                167                 :             14 :                 $$.elements = NULL;
                                168                 :             14 :                 $$.nelements = 0;
                                169                 :                :             }
                                170                 :                : 
                                171                 :                : permutation_list:
                                172                 :                :             permutation_list permutation
                                173                 :                :             {
 2784 tgl@sss.pgh.pa.us         174                 :           2138 :                 $$.elements = pg_realloc($1.elements,
                                175                 :           1069 :                                          ($1.nelements + 1) * sizeof(void *));
 4815 heikki.linnakangas@i      176                 :           1069 :                 $$.elements[$1.nelements] = $2;
                                177                 :           1069 :                 $$.nelements = $1.nelements + 1;
                                178                 :                :             }
                                179                 :                :             | permutation
                                180                 :                :             {
                                181                 :            118 :                 $$.nelements = 1;
 2784 tgl@sss.pgh.pa.us         182                 :            118 :                 $$.elements = pg_malloc(sizeof(void *));
 4815 heikki.linnakangas@i      183                 :            118 :                 $$.elements[0] = $1;
                                184                 :                :             }
                                185                 :                :         ;
                                186                 :                : 
                                187                 :                : 
                                188                 :                : permutation:
                                189                 :                :             PERMUTATION permutation_step_list
                                190                 :                :             {
 2784 tgl@sss.pgh.pa.us         191                 :           1187 :                 $$ = pg_malloc(sizeof(Permutation));
 4815 heikki.linnakangas@i      192                 :           1187 :                 $$->nsteps = $2.nelements;
 1027 tgl@sss.pgh.pa.us         193                 :           1187 :                 $$->steps = (PermutationStep **) $2.elements;
                                194                 :                :             }
                                195                 :                :         ;
                                196                 :                : 
                                197                 :                : permutation_step_list:
                                198                 :                :             permutation_step_list permutation_step
                                199                 :                :             {
 2784                           200                 :          15338 :                 $$.elements = pg_realloc($1.elements,
                                201                 :           7669 :                                          ($1.nelements + 1) * sizeof(void *));
 4815 heikki.linnakangas@i      202                 :           7669 :                 $$.elements[$1.nelements] = $2;
                                203                 :           7669 :                 $$.nelements = $1.nelements + 1;
                                204                 :                :             }
                                205                 :                :             | permutation_step
                                206                 :                :             {
                                207                 :           1187 :                 $$.nelements = 1;
 2784 tgl@sss.pgh.pa.us         208                 :           1187 :                 $$.elements = pg_malloc(sizeof(void *));
 4815 heikki.linnakangas@i      209                 :           1187 :                 $$.elements[0] = $1;
                                210                 :                :             }
                                211                 :                :         ;
                                212                 :                : 
                                213                 :                : permutation_step:
                                214                 :                :             identifier
                                215                 :                :             {
 1027 tgl@sss.pgh.pa.us         216                 :           8808 :                 $$ = pg_malloc(sizeof(PermutationStep));
                                217                 :           8808 :                 $$->name = $1;
                                218                 :           8808 :                 $$->blockers = NULL;
                                219                 :           8808 :                 $$->nblockers = 0;
                                220                 :           8808 :                 $$->step = NULL;
                                221                 :                :             }
                                222                 :                :             | identifier '(' blocker_list ')'
                                223                 :                :             {
                                224                 :             48 :                 $$ = pg_malloc(sizeof(PermutationStep));
                                225                 :             48 :                 $$->name = $1;
                                226                 :             48 :                 $$->blockers = (PermutationStepBlocker **) $3.elements;
                                227                 :             48 :                 $$->nblockers = $3.nelements;
                                228                 :             48 :                 $$->step = NULL;
                                229                 :                :             }
                                230                 :                :         ;
                                231                 :                : 
                                232                 :                : blocker_list:
                                233                 :                :             blocker_list ',' blocker
                                234                 :                :             {
 1027 tgl@sss.pgh.pa.us         235                 :UBC           0 :                 $$.elements = pg_realloc($1.elements,
                                236                 :              0 :                                          ($1.nelements + 1) * sizeof(void *));
                                237                 :              0 :                 $$.elements[$1.nelements] = $3;
                                238                 :              0 :                 $$.nelements = $1.nelements + 1;
                                239                 :                :             }
                                240                 :                :             | blocker
                                241                 :                :             {
 1027 tgl@sss.pgh.pa.us         242                 :CBC          48 :                 $$.nelements = 1;
                                243                 :             48 :                 $$.elements = pg_malloc(sizeof(void *));
                                244                 :             48 :                 $$.elements[0] = $1;
                                245                 :                :             }
                                246                 :                :         ;
                                247                 :                : 
                                248                 :                : blocker:
                                249                 :                :             identifier
                                250                 :                :             {
                                251                 :             36 :                 $$ = pg_malloc(sizeof(PermutationStepBlocker));
                                252                 :             36 :                 $$->stepname = $1;
                                253                 :             36 :                 $$->blocktype = PSB_OTHER_STEP;
                                254                 :             36 :                 $$->num_notices = -1;
                                255                 :             36 :                 $$->step = NULL;
                                256                 :             36 :                 $$->target_notices = -1;
                                257                 :                :             }
                                258                 :                :             | identifier NOTICES INTEGER
                                259                 :                :             {
                                260                 :              1 :                 $$ = pg_malloc(sizeof(PermutationStepBlocker));
                                261                 :              1 :                 $$->stepname = $1;
                                262                 :              1 :                 $$->blocktype = PSB_NUM_NOTICES;
                                263                 :              1 :                 $$->num_notices = $3;
                                264                 :              1 :                 $$->step = NULL;
                                265                 :              1 :                 $$->target_notices = -1;
                                266                 :                :             }
                                267                 :                :             | '*'
                                268                 :                :             {
                                269                 :             11 :                 $$ = pg_malloc(sizeof(PermutationStepBlocker));
                                270                 :             11 :                 $$->stepname = NULL;
                                271                 :             11 :                 $$->blocktype = PSB_ONCE;
                                272                 :             11 :                 $$->num_notices = -1;
                                273                 :             11 :                 $$->step = NULL;
                                274                 :             11 :                 $$->target_notices = -1;
                                275                 :                :             }
                                276                 :                :         ;
                                277                 :                : 
                                278                 :                : %%
        

Generated by: LCOV version 2.1-beta2-3-g6141622