LCOV - code coverage report
Current view: top level - src/test/isolation - isolation_main.c (source / functions) Coverage Total Hit
Test: Code coverage Lines: 0.0 % 57 0
Test Date: 2026-01-26 10:56:24 Functions: 0.0 % 3 0
Legend: Lines:     hit not hit

            Line data    Source code
       1              : /*-------------------------------------------------------------------------
       2              :  *
       3              :  * isolation_main --- pg_regress test launcher for isolation tests
       4              :  *
       5              :  * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
       6              :  * Portions Copyright (c) 1994, Regents of the University of California
       7              :  *
       8              :  * src/test/isolation/isolation_main.c
       9              :  *
      10              :  *-------------------------------------------------------------------------
      11              :  */
      12              : 
      13              : #include "postgres_fe.h"
      14              : 
      15              : #include "lib/stringinfo.h"
      16              : #include "pg_regress.h"
      17              : 
      18              : static char saved_argv0[MAXPGPATH];
      19              : static char isolation_exec[MAXPGPATH];
      20              : static bool looked_up_isolation_exec = false;
      21              : 
      22              : #define PG_ISOLATION_VERSIONSTR "isolationtester (PostgreSQL) " PG_VERSION "\n"
      23              : 
      24              : /*
      25              :  * start an isolation tester process for specified file (including
      26              :  * redirection), and return process ID
      27              :  */
      28              : static PID_TYPE
      29            0 : isolation_start_test(const char *testname,
      30              :                                          _stringlist **resultfiles,
      31              :                                          _stringlist **expectfiles,
      32              :                                          _stringlist **tags)
      33              : {
      34            0 :         PID_TYPE        pid;
      35            0 :         char            infile[MAXPGPATH];
      36            0 :         char            outfile[MAXPGPATH];
      37            0 :         char            expectfile[MAXPGPATH];
      38            0 :         StringInfoData psql_cmd;
      39            0 :         char       *appnameenv;
      40              : 
      41              :         /* need to do the path lookup here, check isolation_init() for details */
      42            0 :         if (!looked_up_isolation_exec)
      43              :         {
      44              :                 /* look for isolationtester binary */
      45            0 :                 if (find_other_exec(saved_argv0, "isolationtester",
      46            0 :                                                         PG_ISOLATION_VERSIONSTR, isolation_exec) != 0)
      47              :                 {
      48            0 :                         fprintf(stderr, _("could not find proper isolationtester binary\n"));
      49            0 :                         exit(2);
      50              :                 }
      51            0 :                 looked_up_isolation_exec = true;
      52            0 :         }
      53              : 
      54              :         /*
      55              :          * Look for files in the output dir first, consistent with a vpath search.
      56              :          * This is mainly to create more reasonable error messages if the file is
      57              :          * not found.  It also allows local test overrides when running pg_regress
      58              :          * outside of the source tree.
      59              :          */
      60            0 :         snprintf(infile, sizeof(infile), "%s/specs/%s.spec",
      61            0 :                          outputdir, testname);
      62            0 :         if (!file_exists(infile))
      63            0 :                 snprintf(infile, sizeof(infile), "%s/specs/%s.spec",
      64            0 :                                  inputdir, testname);
      65              : 
      66            0 :         snprintf(outfile, sizeof(outfile), "%s/results/%s.out",
      67            0 :                          outputdir, testname);
      68              : 
      69            0 :         snprintf(expectfile, sizeof(expectfile), "%s/expected/%s.out",
      70            0 :                          outputdir, testname);
      71            0 :         if (!file_exists(expectfile))
      72            0 :                 snprintf(expectfile, sizeof(expectfile), "%s/expected/%s.out",
      73            0 :                                  inputdir, testname);
      74              : 
      75            0 :         add_stringlist_item(resultfiles, outfile);
      76            0 :         add_stringlist_item(expectfiles, expectfile);
      77              : 
      78            0 :         initStringInfo(&psql_cmd);
      79              : 
      80            0 :         if (launcher)
      81            0 :                 appendStringInfo(&psql_cmd, "%s ", launcher);
      82              : 
      83            0 :         appendStringInfo(&psql_cmd,
      84              :                                          "\"%s\" \"dbname=%s\" < \"%s\" > \"%s\" 2>&1",
      85              :                                          isolation_exec,
      86            0 :                                          dblist->str,
      87            0 :                                          infile,
      88            0 :                                          outfile);
      89              : 
      90            0 :         appnameenv = psprintf("isolation/%s", testname);
      91            0 :         setenv("PGAPPNAME", appnameenv, 1);
      92            0 :         free(appnameenv);
      93              : 
      94            0 :         pid = spawn_process(psql_cmd.data);
      95              : 
      96            0 :         if (pid == INVALID_PID)
      97              :         {
      98            0 :                 fprintf(stderr, _("could not start process for test %s\n"),
      99            0 :                                 testname);
     100            0 :                 exit(2);
     101              :         }
     102              : 
     103            0 :         unsetenv("PGAPPNAME");
     104              : 
     105            0 :         pfree(psql_cmd.data);
     106              : 
     107            0 :         return pid;
     108            0 : }
     109              : 
     110              : static void
     111            0 : isolation_init(int argc, char **argv)
     112              : {
     113            0 :         size_t          argv0_len;
     114              : 
     115              :         /*
     116              :          * We unfortunately cannot do the find_other_exec() lookup to find the
     117              :          * "isolationtester" binary here.  regression_main() calls the
     118              :          * initialization functions before parsing the commandline arguments and
     119              :          * thus hasn't changed the library search path at this point which in turn
     120              :          * can cause the "isolationtester -V" invocation that find_other_exec()
     121              :          * does to fail since it's linked to libpq.  So we instead copy argv[0]
     122              :          * and do the lookup the first time through isolation_start_test().
     123              :          */
     124            0 :         argv0_len = strlcpy(saved_argv0, argv[0], MAXPGPATH);
     125            0 :         if (argv0_len >= MAXPGPATH)
     126              :         {
     127            0 :                 fprintf(stderr, _("path for isolationtester executable is longer than %d bytes\n"),
     128              :                                 (int) (MAXPGPATH - 1));
     129            0 :                 exit(2);
     130              :         }
     131              : 
     132              :         /* set default regression database name */
     133            0 :         add_stringlist_item(&dblist, "isolation_regression");
     134            0 : }
     135              : 
     136              : int
     137            0 : main(int argc, char *argv[])
     138              : {
     139            0 :         return regression_main(argc, argv,
     140              :                                                    isolation_init,
     141              :                                                    isolation_start_test,
     142              :                                                    NULL /* no postfunc needed */ );
     143              : }
        

Generated by: LCOV version 2.3.2-1