#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)

void	replace_string (struct StringInfoData string, const char replace, const char *replacement)

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 *	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.

Referenced by ecpg_start_test(), isolation_start_test(), psql_start_test(), regression_main(), and wait_for_tests().

◆ PID_TYPE

#define PID_TYPE pid_t

Definition at line 14 of file pg_regress.h.

Referenced by ecpg_filter_stderr(), ecpg_start_test(), isolation_start_test(), psql_start_test(), run_schedule(), run_single_test(), and wait_for_tests().

Typedef Documentation

◆ _stringlist

typedef struct _stringlist _stringlist

◆ init_function

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

Definition at line 35 of file pg_regress.h.

◆ postprocess_result_function

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

Definition at line 44 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 38 of file pg_regress.h.

Function Documentation

◆ add_stringlist_item()

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

Definition at line 159 of file pg_regress.c.

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

Referenced by ecpg_start_test(), isolation_init(), isolation_start_test(), psql_init(), psql_start_test(), regression_main(), run_schedule(), and split_to_stringlist().

 {
     _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;
     }
 }

◆ file_exists()

bool file_exists ( const char * file )

Definition at line 1345 of file pg_regress.c.

Referenced by results_differ().

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

◆ regression_main()

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

Definition at line 2185 of file pg_regress.c.

References _, add_stringlist_item(), bindir, config_auth_datadir, create_database(), create_role(), debug, DEVNULL, difffilename, directory_exists(), dlpath, drop_database_if_exists(), drop_role_if_exists(), encoding, fail_count, fail_ignore_count, file_size(), fprintf, free_stringlist(), get_progname(), get_restricted_token(), getopt_long(), header(), help(), hostname, i, initialize_environment(), inputdir, INVALID_PID, kill, launcher, logfile, logfilename, make_absolute_path(), make_directory(), max_concurrent_tests, max_connections, MAXPGPATH, _stringlist::next, no_argument, nolocale, open_result_files(), optarg, optind, outputdir, pg_logging_init(), pg_strdup(), PG_TEXTDOMAIN, pg_usleep(), port, port_specified_by_user, postmaster_pid, postmaster_running, prepare_testtablespace_dir(), pretty_diff_opts, printf, progname, required_argument, rmtree(), run_schedule(), run_single_test(), set_pglocale_pgservice(), setenv, SIGKILL, snprintf, sockdir, spawn_process(), split_to_stringlist(), sprintf, stop_postmaster(), _stringlist::str, strerror, success_count, temp_instance, true, ULONGPID, use_existing, user, and wait_seconds.

Referenced by main().

 {
     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},
         {"make-testtablespace-dir", no_argument, NULL, 26},
         {NULL, 0, NULL, 0}
     };
 
     bool        use_unix_sockets;
     bool        make_testtablespace_dir = false;
     _stringlist *sl;
     int         c;
     int         i;
     int         option_index;
     char        buf[MAXPGPATH * 4];
     char        buf2[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(HAVE_UNIX_SOCKETS)
     use_unix_sockets = false;
 #elif defined(WIN32)
 
     /*
      * We don't use Unix-domain sockets on Windows by default, even if the
      * build supports them.  (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:
                 make_testtablespace_dir = true;
                 break;
             default:
                 /* getopt_long already emitted a complaint */
                 fprintf(stderr, _("\nTry \"%s -h\" for more information.\n"),
                         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++;
     }
 
     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 !HAVE_UNIX_SOCKETS
          * 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);
     dlpath = make_absolute_path(dlpath);
 
     /*
      * Initialization
      */
     open_result_files();
 
     initialize_environment();
 
 #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_CORE)
     unlimit_core_size();
 #endif
 
     if (make_testtablespace_dir)
         prepare_testtablespace_dir();
 
     if (temp_instance)
     {
         FILE       *pg_conf;
         const char *env_wait;
         int         wait_seconds;
 
         /*
          * Prepare the temp instance
          */
 
         if (directory_exists(temp_instance))
         {
             header(_("removing existing temp instance"));
             if (!rmtree(temp_instance, true))
             {
                 fprintf(stderr, _("\n%s: could not remove temp instance \"%s\"\n"),
                         progname, temp_instance);
                 exit(2);
             }
         }
 
         header(_("creating temporary 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 */
         header(_("initializing database system"));
         snprintf(buf, sizeof(buf),
                  "\"%s%sinitdb\" -D \"%s/data\" --no-clean --no-sync%s%s > \"%s/log/initdb.log\" 2>&1",
                  bindir ? bindir : "",
                  bindir ? "/" : "",
                  temp_instance,
                  debug ? " --debug" : "",
                  nolocale ? " --no-locale" : "",
                  outputdir);
         if (system(buf))
         {
             fprintf(stderr, _("\n%s: initdb failed\nExamine %s/log/initdb.log for the reason.\nCommand was: %s\n"), progname, outputdir, buf);
             exit(2);
         }
 
         /*
          * 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)
         {
             fprintf(stderr, _("\n%s: could not open \"%s\" for adding extra config: %s\n"), progname, buf, strerror(errno));
             exit(2);
         }
         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)
             {
                 fprintf(stderr, _("\n%s: could not open \"%s\" to read extra config: %s\n"), progname, temp_config, strerror(errno));
                 exit(2);
             }
             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);
         }
 #elif !defined(HAVE_UNIX_SOCKETS)
 #error Platform has no means to secure the test installation.
 #endif
 
         /*
          * Check if there is a postmaster running already.
          */
         snprintf(buf2, sizeof(buf2),
                  "\"%s%spsql\" -X postgres <%s 2>%s",
                  bindir ? bindir : "",
                  bindir ? "/" : "",
                  DEVNULL, DEVNULL);
 
         for (i = 0; i < 16; i++)
         {
             if (system(buf2) == 0)
             {
                 char        s[16];
 
                 if (port_specified_by_user || i == 15)
                 {
                     fprintf(stderr, _("port %d apparently in use\n"), port);
                     if (!port_specified_by_user)
                         fprintf(stderr, _("%s: could not determine an available port\n"), progname);
                     fprintf(stderr, _("Specify an unused port using the --port option or shut down any conflicting PostgreSQL servers.\n"));
                     exit(2);
                 }
 
                 fprintf(stderr, _("port %d apparently in use, trying %d\n"), port, port + 1);
                 port++;
                 sprintf(s, "%d", port);
                 setenv("PGPORT", s, 1);
             }
             else
                 break;
         }
 
         /*
          * Start the temp postmaster
          */
         header(_("starting 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)
         {
             fprintf(stderr, _("\n%s: could not spawn postmaster: %s\n"),
                     progname, strerror(errno));
             exit(2);
         }
 
         /*
          * Wait till postmaster is able to accept connections; normally this
          * is only 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; i++)
         {
             /* Done if psql succeeds */
             if (system(buf2) == 0)
                 break;
 
             /*
              * 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
             {
                 fprintf(stderr, _("\n%s: postmaster failed\nExamine %s/log/postmaster.log for the reason\n"), progname, outputdir);
                 exit(2);
             }
 
             pg_usleep(1000000L);
         }
         if (i >= wait_seconds)
         {
             fprintf(stderr, _("\n%s: postmaster did not respond within %d seconds\nExamine %s/log/postmaster.log for the reason\n"),
                     progname, 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)
                 fprintf(stderr, _("\n%s: could not kill failed postmaster: %s\n"),
                         progname, strerror(errno));
 #else
             if (TerminateProcess(postmaster_pid, 255) == 0)
                 fprintf(stderr, _("\n%s: could not kill failed postmaster: error code %lu\n"),
                         progname, GetLastError());
 #endif
 
             exit(2);
         }
 
         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
         printf(_("running on port %d with PID %lu\n"),
                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
      */
     header(_("running regression test queries"));
 
     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)
     {
         header(_("shutting down postmaster"));
         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 && fail_ignore_count == 0)
     {
         header(_("removing temporary instance"));
         if (!rmtree(temp_instance, true))
             fprintf(stderr, _("\n%s: could not remove temp instance \"%s\"\n"),
                     progname, temp_instance);
     }
 
     fclose(logfile);
 
     /*
      * Emit nice-looking summary message
      */
     if (fail_count == 0 && fail_ignore_count == 0)
         snprintf(buf, sizeof(buf),
                  _(" All %d tests passed. "),
                  success_count);
     else if (fail_count == 0)   /* fail_count=0, fail_ignore_count>0 */
         snprintf(buf, sizeof(buf),
                  _(" %d of %d tests passed, %d failed test(s) ignored. "),
                  success_count,
                  success_count + fail_ignore_count,
                  fail_ignore_count);
     else if (fail_ignore_count == 0)    /* fail_count>0 && fail_ignore_count=0 */
         snprintf(buf, sizeof(buf),
                  _(" %d of %d tests failed. "),
                  fail_count,
                  success_count + fail_count);
     else
         /* fail_count>0 && fail_ignore_count>0 */
         snprintf(buf, sizeof(buf),
                  _(" %d of %d tests failed, %d of these failures ignored. "),
                  fail_count + fail_ignore_count,
                  success_count + fail_count + fail_ignore_count,
                  fail_ignore_count);
 
     putchar('\n');
     for (i = strlen(buf); i > 0; i--)
         putchar('=');
     printf("\n%s\n", buf);
     for (i = strlen(buf); i > 0; i--)
         putchar('=');
     putchar('\n');
     putchar('\n');
 
     if (file_size(difffilename) > 0)
     {
         printf(_("The differences that caused some tests to fail can be viewed in the\n"
                  "file \"%s\".  A copy of the test summary that you see\n"
                  "above is saved in the file \"%s\".\n\n"),
                difffilename, logfilename);
     }
     else
     {
         unlink(difffilename);
         unlink(logfilename);
     }
 
     if (fail_count != 0)
         exit(1);
 
     return 0;
 }

◆ replace_string()

void replace_string	(	struct StringInfoData *	string,
		const char *	replace,
		const char *	replacement
	)

◆ spawn_process()

PID_TYPE spawn_process ( const char * cmdline )

Definition at line 1235 of file pg_regress.c.

References _, fprintf, logfile, progname, psprintf(), shellprog, generate_unaccent_rules::stdout, and strerror.

Referenced by ecpg_start_test(), isolation_start_test(), psql_start_test(), and regression_main().

 {
 #ifndef WIN32
     pid_t       pid;
 
     /*
      * Must flush I/O buffers before fork.  Ideally we'd use fflush(NULL) here
      * ... does anyone still care about systems where that doesn't work?
      */
     fflush(stdout);
     fflush(stderr);
     if (logfile)
         fflush(logfile);
 
     pid = fork();
     if (pid == -1)
     {
         fprintf(stderr, _("%s: could not fork: %s\n"),
                 progname, strerror(errno));
         exit(2);
     }
     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);
         fprintf(stderr, _("%s: could not exec \"%s\": %s\n"),
                 progname, shellprog, strerror(errno));
         _exit(1);               /* not exit() here... */
     }
     /* in parent */
     return pid;
 #else
     PROCESS_INFORMATION pi;
     char       *cmdline2;
     HANDLE      restrictedToken;
     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 ((restrictedToken =
          CreateRestrictedProcess(cmdline2, &pi)) == 0)
         exit(2);
 
     CloseHandle(pi.hThread);
     return pi.hProcess;
 #endif
 }