#include <unistd.h>

Include dependency graph for pg_regress.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	_stringlist

Macros
#define	PID_TYPE pid_t

#define	INVALID_PID (-1)

Typedefs
typedef struct _stringlist	_stringlist

typedef void(*	init_function) (int argc, char **argv)

typedef PID_TYPE(*	test_start_function) (const char testname, _stringlist resultfiles, _stringlist expectfiles, _stringlist *tags)

typedef void(*	postprocess_result_function) (const char *filename)

Functions
int	regression_main (int argc, char *argv[], init_function ifunc, test_start_function startfunc, postprocess_result_function postfunc)

void	add_stringlist_item (_stringlist *listhead, const char str)

PID_TYPE	spawn_process (const char *cmdline)

bool	file_exists (const char *file)

Variables
char *	bindir

char *	libdir

char *	datadir

char *	host_platform

_stringlist *	dblist

bool	debug

char *	inputdir

char *	outputdir

char *	expecteddir

char *	launcher

const char *	basic_diff_opts

const char *	pretty_diff_opts

Macro Definition Documentation

◆ INVALID_PID

#define INVALID_PID (-1)

Definition at line 15 of file pg_regress.h.

◆ PID_TYPE

#define PID_TYPE pid_t

Definition at line 14 of file pg_regress.h.

Typedef Documentation

◆ _stringlist

typedef struct _stringlist _stringlist

◆ init_function

typedef void(* init_function) (int argc, char **argv)

Definition at line 33 of file pg_regress.h.

◆ postprocess_result_function

typedef void(* postprocess_result_function) (const char *filename)

Definition at line 42 of file pg_regress.h.

◆ test_start_function

typedef PID_TYPE(* test_start_function) (const char *testname, _stringlist **resultfiles, _stringlist **expectfiles, _stringlist **tags)

Definition at line 36 of file pg_regress.h.

Function Documentation

◆ add_stringlist_item()

void add_stringlist_item	(	_stringlist **	listhead,
		const char *	str
	)

Definition at line 198 of file pg_regress.c.

 {
     _stringlist *newentry = pg_malloc(sizeof(_stringlist));
     _stringlist *oldentry;
  
     newentry->str = pg_strdup(str);
     newentry->next = NULL;
     if (*listhead == NULL)
         *listhead = newentry;
     else
     {
         for (oldentry = *listhead; oldentry->next; oldentry = oldentry->next)
              /* skip */ ;
         oldentry->next = newentry;
     }
 }

References _stringlist::next, pg_malloc(), pg_strdup(), _stringlist::str, and str.

Referenced by regression_main(), and split_to_stringlist().

◆ file_exists()

bool file_exists ( const char * file )

Definition at line 1304 of file pg_regress.c.

 {
     FILE       *f = fopen(file, "r");
  
     if (!f)
         return false;
     fclose(f);
     return true;
 }

Referenced by isolation_start_test(), psql_start_test(), and results_differ().

◆ regression_main()

int regression_main	(	int	argc,
		char *	argv[],
		init_function	ifunc,
		test_start_function	startfunc,
		postprocess_result_function	postfunc
	)

Definition at line 2066 of file pg_regress.c.

 {
     static struct option long_options[] = {
         {"help", no_argument, NULL, 'h'},
         {"version", no_argument, NULL, 'V'},
         {"dbname", required_argument, NULL, 1},
         {"debug", no_argument, NULL, 2},
         {"inputdir", required_argument, NULL, 3},
         {"max-connections", required_argument, NULL, 5},
         {"encoding", required_argument, NULL, 6},
         {"outputdir", required_argument, NULL, 7},
         {"schedule", required_argument, NULL, 8},
         {"temp-instance", required_argument, NULL, 9},
         {"no-locale", no_argument, NULL, 10},
         {"host", required_argument, NULL, 13},
         {"port", required_argument, NULL, 14},
         {"user", required_argument, NULL, 15},
         {"bindir", required_argument, NULL, 16},
         {"dlpath", required_argument, NULL, 17},
         {"create-role", required_argument, NULL, 18},
         {"temp-config", required_argument, NULL, 19},
         {"use-existing", no_argument, NULL, 20},
         {"launcher", required_argument, NULL, 21},
         {"load-extension", required_argument, NULL, 22},
         {"config-auth", required_argument, NULL, 24},
         {"max-concurrent-tests", required_argument, NULL, 25},
         {"expecteddir", required_argument, NULL, 26},
         {NULL, 0, NULL, 0}
     };
  
     bool        use_unix_sockets;
     _stringlist *sl;
     int         c;
     int         i;
     int         option_index;
     char        buf[MAXPGPATH * 4];
  
     pg_logging_init(argv[0]);
     progname = get_progname(argv[0]);
     set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_regress"));
  
     get_restricted_token();
  
     atexit(stop_postmaster);
  
 #if defined(WIN32)
  
     /*
      * We don't use Unix-domain sockets on Windows by default (see comment at
      * remove_temp() for a reason).  Override at your own risk.
      */
     use_unix_sockets = getenv("PG_TEST_USE_UNIX_SOCKETS") ? true : false;
 #else
     use_unix_sockets = true;
 #endif
  
     if (!use_unix_sockets)
         hostname = "localhost";
  
     /*
      * We call the initialization function here because that way we can set
      * default parameters and let them be overwritten by the commandline.
      */
     ifunc(argc, argv);
  
     if (getenv("PG_REGRESS_DIFF_OPTS"))
         pretty_diff_opts = getenv("PG_REGRESS_DIFF_OPTS");
  
     while ((c = getopt_long(argc, argv, "hV", long_options, &option_index)) != -1)
     {
         switch (c)
         {
             case 'h':
                 help();
                 exit(0);
             case 'V':
                 puts("pg_regress (PostgreSQL) " PG_VERSION);
                 exit(0);
             case 1:
  
                 /*
                  * If a default database was specified, we need to remove it
                  * before we add the specified one.
                  */
                 free_stringlist(&dblist);
                 split_to_stringlist(optarg, ",", &dblist);
                 break;
             case 2:
                 debug = true;
                 break;
             case 3:
                 inputdir = pg_strdup(optarg);
                 break;
             case 5:
                 max_connections = atoi(optarg);
                 break;
             case 6:
                 encoding = pg_strdup(optarg);
                 break;
             case 7:
                 outputdir = pg_strdup(optarg);
                 break;
             case 8:
                 add_stringlist_item(&schedulelist, optarg);
                 break;
             case 9:
                 temp_instance = make_absolute_path(optarg);
                 break;
             case 10:
                 nolocale = true;
                 break;
             case 13:
                 hostname = pg_strdup(optarg);
                 break;
             case 14:
                 port = atoi(optarg);
                 port_specified_by_user = true;
                 break;
             case 15:
                 user = pg_strdup(optarg);
                 break;
             case 16:
                 /* "--bindir=" means to use PATH */
                 if (strlen(optarg))
                     bindir = pg_strdup(optarg);
                 else
                     bindir = NULL;
                 break;
             case 17:
                 dlpath = pg_strdup(optarg);
                 break;
             case 18:
                 split_to_stringlist(optarg, ",", &extraroles);
                 break;
             case 19:
                 add_stringlist_item(&temp_configs, optarg);
                 break;
             case 20:
                 use_existing = true;
                 break;
             case 21:
                 launcher = pg_strdup(optarg);
                 break;
             case 22:
                 add_stringlist_item(&loadextension, optarg);
                 break;
             case 24:
                 config_auth_datadir = pg_strdup(optarg);
                 break;
             case 25:
                 max_concurrent_tests = atoi(optarg);
                 break;
             case 26:
                 expecteddir = pg_strdup(optarg);
                 break;
             default:
                 /* getopt_long already emitted a complaint */
                 pg_log_error_hint("Try \"%s --help\" for more information.",
                                   progname);
                 exit(2);
         }
     }
  
     /*
      * if we still have arguments, they are extra tests to run
      */
     while (argc - optind >= 1)
     {
         add_stringlist_item(&extra_tests, argv[optind]);
         optind++;
     }
  
     /*
      * We must have a database to run the tests in; either a default name, or
      * one supplied by the --dbname switch.
      */
     if (!(dblist && dblist->str && dblist->str[0]))
     {
         bail("no database name was specified");
     }
  
     if (config_auth_datadir)
     {
 #ifdef ENABLE_SSPI
         if (!use_unix_sockets)
             config_sspi_auth(config_auth_datadir, user);
 #endif
         exit(0);
     }
  
     if (temp_instance && !port_specified_by_user)
  
         /*
          * To reduce chances of interference with parallel installations, use
          * a port number starting in the private range (49152-65535)
          * calculated from the version number.  This aids non-Unix socket mode
          * systems; elsewhere, the use of a private socket directory already
          * prevents interference.
          */
         port = 0xC000 | (PG_VERSION_NUM & 0x3FFF);
  
     inputdir = make_absolute_path(inputdir);
     outputdir = make_absolute_path(outputdir);
     expecteddir = make_absolute_path(expecteddir);
     dlpath = make_absolute_path(dlpath);
  
     /*
      * Initialization
      */
     open_result_files();
  
     initialize_environment();
  
 #if defined(HAVE_GETRLIMIT)
     unlimit_core_size();
 #endif
  
     if (temp_instance)
     {
         StringInfoData cmd;
         FILE       *pg_conf;
         const char *env_wait;
         int         wait_seconds;
         const char *initdb_template_dir;
         const char *keywords[4];
         const char *values[4];
         PGPing      rv;
         const char *initdb_extra_opts_env;
  
         /*
          * Prepare the temp instance
          */
  
         if (directory_exists(temp_instance))
         {
             if (!rmtree(temp_instance, true))
             {
                 bail("could not remove temp instance \"%s\"", temp_instance);
             }
         }
  
         /* make the temp instance top directory */
         make_directory(temp_instance);
  
         /* and a directory for log files */
         snprintf(buf, sizeof(buf), "%s/log", outputdir);
         if (!directory_exists(buf))
             make_directory(buf);
  
         initdb_extra_opts_env = getenv("PG_TEST_INITDB_EXTRA_OPTS");
  
         initStringInfo(&cmd);
  
         /*
          * Create data directory.
          *
          * If available, use a previously initdb'd cluster as a template by
          * copying it. For a lot of tests, that's substantially cheaper.
          *
          * There's very similar code in Cluster.pm, but we can't easily de
          * duplicate it until we require perl at build time.
          */
         initdb_template_dir = getenv("INITDB_TEMPLATE");
         if (initdb_template_dir == NULL || nolocale || debug || initdb_extra_opts_env)
         {
             note("initializing database system by running initdb");
  
             appendStringInfo(&cmd,
                              "\"%s%sinitdb\" -D \"%s/data\" --no-clean --no-sync",
                              bindir ? bindir : "",
                              bindir ? "/" : "",
                              temp_instance);
             if (debug)
                 appendStringInfoString(&cmd, " --debug");
             if (nolocale)
                 appendStringInfoString(&cmd, " --no-locale");
             if (initdb_extra_opts_env)
                 appendStringInfo(&cmd, " %s", initdb_extra_opts_env);
             appendStringInfo(&cmd, " > \"%s/log/initdb.log\" 2>&1", outputdir);
             fflush(NULL);
             if (system(cmd.data))
             {
                 bail("initdb failed\n"
                      "# Examine \"%s/log/initdb.log\" for the reason.\n"
                      "# Command was: %s",
                      outputdir, cmd.data);
             }
         }
         else
         {
 #ifndef WIN32
             const char *copycmd = "cp -RPp \"%s\" \"%s/data\"";
             int         expected_exitcode = 0;
 #else
             const char *copycmd = "robocopy /E /NJS /NJH /NFL /NDL /NP \"%s\" \"%s/data\"";
             int         expected_exitcode = 1;  /* 1 denotes files were copied */
 #endif
  
             note("initializing database system by copying initdb template");
  
             appendStringInfo(&cmd,
                              copycmd,
                              initdb_template_dir,
                              temp_instance);
             appendStringInfo(&cmd, " > \"%s/log/initdb.log\" 2>&1", outputdir);
             fflush(NULL);
             if (system(cmd.data) != expected_exitcode)
             {
                 bail("copying of initdb template failed\n"
                      "# Examine \"%s/log/initdb.log\" for the reason.\n"
                      "# Command was: %s",
                      outputdir, cmd.data);
             }
         }
  
         pfree(cmd.data);
  
         /*
          * Adjust the default postgresql.conf for regression testing. The user
          * can specify a file to be appended; in any case we expand logging
          * and set max_prepared_transactions to enable testing of prepared
          * xacts.  (Note: to reduce the probability of unexpected shmmax
          * failures, don't set max_prepared_transactions any higher than
          * actually needed by the prepared_xacts regression test.)
          */
         snprintf(buf, sizeof(buf), "%s/data/postgresql.conf", temp_instance);
         pg_conf = fopen(buf, "a");
         if (pg_conf == NULL)
             bail("could not open \"%s\" for adding extra config: %m", buf);
  
         fputs("\n# Configuration added by pg_regress\n\n", pg_conf);
         fputs("log_autovacuum_min_duration = 0\n", pg_conf);
         fputs("log_checkpoints = on\n", pg_conf);
         fputs("log_line_prefix = '%m %b[%p] %q%a '\n", pg_conf);
         fputs("log_lock_waits = on\n", pg_conf);
         fputs("log_temp_files = 128kB\n", pg_conf);
         fputs("max_prepared_transactions = 2\n", pg_conf);
  
         for (sl = temp_configs; sl != NULL; sl = sl->next)
         {
             char       *temp_config = sl->str;
             FILE       *extra_conf;
             char        line_buf[1024];
  
             extra_conf = fopen(temp_config, "r");
             if (extra_conf == NULL)
             {
                 bail("could not open \"%s\" to read extra config: %m",
                      temp_config);
             }
             while (fgets(line_buf, sizeof(line_buf), extra_conf) != NULL)
                 fputs(line_buf, pg_conf);
             fclose(extra_conf);
         }
  
         fclose(pg_conf);
  
 #ifdef ENABLE_SSPI
         if (!use_unix_sockets)
         {
             /*
              * Since we successfully used the same buffer for the much-longer
              * "initdb" command, this can't truncate.
              */
             snprintf(buf, sizeof(buf), "%s/data", temp_instance);
             config_sspi_auth(buf, NULL);
         }
 #endif
  
         /*
          * Prepare the connection params for checking the state of the server
          * before starting the tests.
          */
         sprintf(portstr, "%d", port);
         keywords[0] = "dbname";
         values[0] = "postgres";
         keywords[1] = "port";
         values[1] = portstr;
         keywords[2] = "host";
         values[2] = hostname ? hostname : sockdir;
         keywords[3] = NULL;
         values[3] = NULL;
  
         /*
          * Check if there is a postmaster running already.
          */
         for (i = 0; i < 16; i++)
         {
             rv = PQpingParams(keywords, values, 1);
  
             if (rv == PQPING_OK)
             {
                 if (port_specified_by_user || i == 15)
                 {
                     note("port %d apparently in use", port);
                     if (!port_specified_by_user)
                         note("could not determine an available port");
                     bail("Specify an unused port using the --port option or shut down any conflicting PostgreSQL servers.");
                 }
  
                 note("port %d apparently in use, trying %d", port, port + 1);
                 port++;
                 sprintf(portstr, "%d", port);
                 setenv("PGPORT", portstr, 1);
             }
             else
                 break;
         }
  
         /*
          * Start the temp postmaster
          */
         snprintf(buf, sizeof(buf),
                  "\"%s%spostgres\" -D \"%s/data\" -F%s "
                  "-c \"listen_addresses=%s\" -k \"%s\" "
                  "> \"%s/log/postmaster.log\" 2>&1",
                  bindir ? bindir : "",
                  bindir ? "/" : "",
                  temp_instance, debug ? " -d 5" : "",
                  hostname ? hostname : "", sockdir ? sockdir : "",
                  outputdir);
         postmaster_pid = spawn_process(buf);
         if (postmaster_pid == INVALID_PID)
             bail("could not spawn postmaster: %m");
  
         /*
          * Wait till postmaster is able to accept connections; normally takes
          * only a fraction of a second or so, but Cygwin is reportedly *much*
          * slower, and test builds using Valgrind or similar tools might be
          * too.  Hence, allow the default timeout of 60 seconds to be
          * overridden from the PGCTLTIMEOUT environment variable.
          */
         env_wait = getenv("PGCTLTIMEOUT");
         if (env_wait != NULL)
         {
             wait_seconds = atoi(env_wait);
             if (wait_seconds <= 0)
                 wait_seconds = 60;
         }
         else
             wait_seconds = 60;
  
         for (i = 0; i < wait_seconds * WAIT_TICKS_PER_SECOND; i++)
         {
             /*
              * It's fairly unlikely that the server is responding immediately
              * so we start with sleeping before checking instead of the other
              * way around.
              */
             pg_usleep(1000000L / WAIT_TICKS_PER_SECOND);
  
             rv = PQpingParams(keywords, values, 1);
  
             /* Done if the server is running and accepts connections */
             if (rv == PQPING_OK)
                 break;
  
             if (rv == PQPING_NO_ATTEMPT)
                 bail("attempting to connect to postmaster failed");
  
             /*
              * Fail immediately if postmaster has exited
              */
 #ifndef WIN32
             if (waitpid(postmaster_pid, NULL, WNOHANG) == postmaster_pid)
 #else
             if (WaitForSingleObject(postmaster_pid, 0) == WAIT_OBJECT_0)
 #endif
             {
                 bail("postmaster failed, examine \"%s/log/postmaster.log\" for the reason",
                      outputdir);
             }
         }
         if (i >= wait_seconds * WAIT_TICKS_PER_SECOND)
         {
             diag("postmaster did not respond within %d seconds, examine \"%s/log/postmaster.log\" for the reason",
                  wait_seconds, outputdir);
  
             /*
              * If we get here, the postmaster is probably wedged somewhere in
              * startup.  Try to kill it ungracefully rather than leaving a
              * stuck postmaster that might interfere with subsequent test
              * attempts.
              */
 #ifndef WIN32
             if (kill(postmaster_pid, SIGKILL) != 0 && errno != ESRCH)
                 bail("could not kill failed postmaster: %m");
 #else
             if (TerminateProcess(postmaster_pid, 255) == 0)
                 bail("could not kill failed postmaster: error code %lu",
                      GetLastError());
 #endif
             bail("postmaster failed");
         }
  
         postmaster_running = true;
  
 #ifdef _WIN64
 /* need a series of two casts to convert HANDLE without compiler warning */
 #define ULONGPID(x) (unsigned long) (unsigned long long) (x)
 #else
 #define ULONGPID(x) (unsigned long) (x)
 #endif
         note("using temp instance on port %d with PID %lu",
              port, ULONGPID(postmaster_pid));
     }
     else
     {
         /*
          * Using an existing installation, so may need to get rid of
          * pre-existing database(s) and role(s)
          */
         if (!use_existing)
         {
             for (sl = dblist; sl; sl = sl->next)
                 drop_database_if_exists(sl->str);
             for (sl = extraroles; sl; sl = sl->next)
                 drop_role_if_exists(sl->str);
         }
     }
  
     /*
      * Create the test database(s) and role(s)
      */
     if (!use_existing)
     {
         for (sl = dblist; sl; sl = sl->next)
             create_database(sl->str);
         for (sl = extraroles; sl; sl = sl->next)
             create_role(sl->str, dblist);
     }
  
     /*
      * Ready to run the tests
      */
     for (sl = schedulelist; sl != NULL; sl = sl->next)
     {
         run_schedule(sl->str, startfunc, postfunc);
     }
  
     for (sl = extra_tests; sl != NULL; sl = sl->next)
     {
         run_single_test(sl->str, startfunc, postfunc);
     }
  
     /*
      * Shut down temp installation's postmaster
      */
     if (temp_instance)
     {
         stop_postmaster();
     }
  
     /*
      * If there were no errors, remove the temp instance immediately to
      * conserve disk space.  (If there were errors, we leave the instance in
      * place for possible manual investigation.)
      */
     if (temp_instance && fail_count == 0)
     {
         if (!rmtree(temp_instance, true))
             diag("could not remove temp instance \"%s\"",
                  temp_instance);
     }
  
     /*
      * Emit a TAP compliant Plan
      */
     plan(fail_count + success_count);
  
     /*
      * Emit nice-looking summary message
      */
     if (fail_count == 0)
         note("All %d tests passed.", success_count);
     else
         diag("%d of %d tests failed.", fail_count, success_count + fail_count);
  
     if (file_size(difffilename) > 0)
     {
         diag("The differences that caused some tests to fail can be viewed in the file \"%s\".",
              difffilename);
         diag("A copy of the test summary that you see above is saved in the file \"%s\".",
              logfilename);
     }
     else
     {
         unlink(difffilename);
         unlink(logfilename);
     }
  
     fclose(logfile);
     logfile = NULL;
  
     if (fail_count != 0)
         exit(1);
  
     return 0;
 }

References add_stringlist_item(), appendStringInfo(), appendStringInfoString(), bail, bindir, buf, config_auth_datadir, create_database(), create_role(), StringInfoData::data, dblist, debug, diag, difffilename, directory_exists(), dlpath, drop_database_if_exists(), drop_role_if_exists(), encoding, exit(), expecteddir, extra_tests, extraroles, fail_count, fflush(), file_size(), free_stringlist(), get_progname(), get_restricted_token(), getopt_long(), help(), hostname, i, initialize_environment(), initStringInfo(), inputdir, INVALID_PID, kill, launcher, loadextension, logfile, logfilename, make_absolute_path(), make_directory(), max_concurrent_tests, max_connections, MAXPGPATH, _stringlist::next, no_argument, nolocale, note, open_result_files(), optarg, optind, outputdir, pfree(), pg_log_error_hint, pg_logging_init(), pg_strdup(), PG_TEXTDOMAIN, pg_usleep(), plan, port, port_specified_by_user, portstr, postmaster_pid, postmaster_running, PQPING_NO_ATTEMPT, PQPING_OK, PQpingParams(), pretty_diff_opts, progname, required_argument, rmtree(), run_schedule(), run_single_test(), schedulelist, set_pglocale_pgservice(), setenv, SIGKILL, snprintf, sockdir, spawn_process(), split_to_stringlist(), sprintf, stop_postmaster(), _stringlist::str, success_count, temp_configs, temp_instance, true, ULONGPID, unlimit_core_size(), use_existing, user, values, wait_seconds, and WAIT_TICKS_PER_SECOND.

Referenced by main().

◆ spawn_process()

PID_TYPE spawn_process ( const char * cmdline )

Definition at line 1201 of file pg_regress.c.

 {
 #ifndef WIN32
     pid_t       pid;
  
     /*
      * Must flush I/O buffers before fork.
      */
     fflush(NULL);
  
 #ifdef EXEC_BACKEND
     pg_disable_aslr();
 #endif
  
     pid = fork();
     if (pid == -1)
     {
         bail("could not fork: %m");
     }
     if (pid == 0)
     {
         /*
          * In child
          *
          * Instead of using system(), exec the shell directly, and tell it to
          * "exec" the command too.  This saves two useless processes per
          * parallel test case.
          */
         char       *cmdline2;
  
         cmdline2 = psprintf("exec %s", cmdline);
         execl(shellprog, shellprog, "-c", cmdline2, (char *) NULL);
         /* Not using the normal bail() here as we want _exit */
         bail_noatexit("could not exec \"%s\": %m", shellprog);
     }
     /* in parent */
     return pid;
 #else
     PROCESS_INFORMATION pi;
     char       *cmdline2;
     const char *comspec;
  
     /* Find CMD.EXE location using COMSPEC, if it's set */
     comspec = getenv("COMSPEC");
     if (comspec == NULL)
         comspec = "CMD";
  
     memset(&pi, 0, sizeof(pi));
     cmdline2 = psprintf("\"%s\" /c \"%s\"", comspec, cmdline);
  
     if (!CreateRestrictedProcess(cmdline2, &pi))
         exit(2);
  
     CloseHandle(pi.hThread);
     return pi.hProcess;
 #endif
 }