#include "postgres_fe.h"
#include <ctype.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <signal.h>
#include <unistd.h>
#include "common/logging.h"
#include "common/restricted_token.h"
#include "common/string.h"
#include "common/username.h"
#include "getopt_long.h"
#include "lib/stringinfo.h"
#include "libpq/pqcomm.h"
#include "pg_config_paths.h"
#include "pg_regress.h"
#include "portability/instr_time.h"

Include dependency graph for pg_regress.c:

Data Structures
struct	_resultmap

Macros
#define	MAX_PARALLEL_TESTS 100

#define	ULONGPID(x) (unsigned long) (x)

Typedefs
typedef struct _resultmap	_resultmap

Functions
static bool	directory_exists (const char *dir)

static void	make_directory (const char *dir)

static void	header (const char *fmt,...) pg_attribute_printf(1

static void static void	status (const char *fmt,...) pg_attribute_printf(1

static void static void static void	psql_command (const char database, const char query,...) pg_attribute_printf(2

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

static void	free_stringlist (_stringlist **listhead)

static void	split_to_stringlist (const char s, const char delim, _stringlist **listhead)

static void	status_end (void)

static void	stop_postmaster (void)

static bool	string_matches_pattern (const char str, const char pattern)

void	replace_string (StringInfo string, const char replace, const char replacement)

static void	convert_sourcefiles_in (const char source_subdir, const char dest_dir, const char dest_subdir, const char suffix)

static void	convert_sourcefiles (void)

static void	prepare_testtablespace_dir (void)

static void	load_resultmap (void)

static const char *	get_expectfile (const char testname, const char file)

static void	initialize_environment (void)

PID_TYPE	spawn_process (const char *cmdline)

static long	file_size (const char *file)

static int	file_line_count (const char *file)

bool	file_exists (const char *file)

static char *	get_alternative_expectfile (const char *expectfile, int i)

static int	run_diff (const char cmd, const char filename)

static bool	results_differ (const char testname, const char resultsfile, const char *default_expectfile)

static void	wait_for_tests (PID_TYPE pids, int statuses, instr_time stoptimes, char *names, int num_tests)

static void	log_child_failure (int exitstatus)

static void	run_schedule (const char *schedule, test_start_function startfunc, postprocess_result_function postfunc)

static void	run_single_test (const char *test, test_start_function startfunc, postprocess_result_function postfunc)

static void	open_result_files (void)

static void	drop_database_if_exists (const char *dbname)

static void	create_database (const char *dbname)

static void	drop_role_if_exists (const char *rolename)

static void	create_role (const char rolename, const _stringlist granted_dbs)

static void	help (void)

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

Variables
char *	host_platform = HOST_TUPLE

static char *	shellprog = SHELLPROG

const char *	basic_diff_opts = ""

const char *	pretty_diff_opts = "-U3"

_stringlist *	dblist = NULL

bool	debug = false

char *	inputdir = "."

char *	outputdir = "."

char *	bindir = PGBINDIR

char *	launcher = NULL

static _stringlist *	loadextension = NULL

static int	max_connections = 0

static int	max_concurrent_tests = 0

static char *	encoding = NULL

static _stringlist *	schedulelist = NULL

static _stringlist *	extra_tests = NULL

static char *	temp_instance = NULL

static _stringlist *	temp_configs = NULL

static bool	nolocale = false

static bool	use_existing = false

static char *	hostname = NULL

static int	port = -1

static bool	port_specified_by_user = false

static char *	dlpath = PKGLIBDIR

static char *	user = NULL

static _stringlist *	extraroles = NULL

static char *	config_auth_datadir = NULL

static const char *	progname

static char *	logfilename

static FILE *	logfile

static char *	difffilename

static const char *	sockdir

static _resultmap *	resultmap = NULL

static PID_TYPE	postmaster_pid = INVALID_PID

static bool	postmaster_running = false

static int	success_count = 0

static int	fail_count = 0

static int	fail_ignore_count = 0

Macro Definition Documentation

◆ MAX_PARALLEL_TESTS

#define MAX_PARALLEL_TESTS 100

Referenced by run_schedule().

◆ ULONGPID

#define ULONGPID ( x ) (unsigned long) (x)

Referenced by regression_main().

Typedef Documentation

◆ _resultmap

typedef struct _resultmap _resultmap

Function Documentation

◆ add_stringlist_item()

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

Definition at line 157 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;
     }
 }

◆ convert_sourcefiles()

static void convert_sourcefiles ( void )

static

Definition at line 582 of file pg_regress.c.

References convert_sourcefiles_in(), and outputdir.

Referenced by initialize_environment().

 {
     convert_sourcefiles_in("input", outputdir, "sql", "sql");
     convert_sourcefiles_in("output", outputdir, "expected", "out");
 }

◆ convert_sourcefiles_in()

static void convert_sourcefiles_in	(	const char *	source_subdir,
		const char *	dest_dir,
		const char *	dest_subdir,
		const char *	suffix
	)

static

Definition at line 476 of file pg_regress.c.

References _, StringInfoData::data, directory_exists(), dlpath, fprintf, infile(), initStringInfo(), inputdir, make_directory(), MAXPGPATH, name, outfile, outputdir, pfree(), pg_get_line_buf(), pgfnames(), pgfnames_cleanup(), progname, replace_string(), snprintf, and strerror.

Referenced by convert_sourcefiles().

 {
     char        testtablespace[MAXPGPATH];
     char        indir[MAXPGPATH];
     char        outdir_sub[MAXPGPATH];
     char      **name;
     char      **names;
     int         count = 0;
 
     snprintf(indir, MAXPGPATH, "%s/%s", inputdir, source_subdir);
 
     /* Check that indir actually exists and is a directory */
     if (!directory_exists(indir))
     {
         /*
          * No warning, to avoid noise in tests that do not have these
          * directories; for example, ecpg, contrib and src/pl.
          */
         return;
     }
 
     names = pgfnames(indir);
     if (!names)
         /* Error logged in pgfnames */
         exit(2);
 
     /* Create the "dest" subdirectory if not present */
     snprintf(outdir_sub, MAXPGPATH, "%s/%s", dest_dir, dest_subdir);
     if (!directory_exists(outdir_sub))
         make_directory(outdir_sub);
 
     /* We might need to replace @testtablespace@ */
     snprintf(testtablespace, MAXPGPATH, "%s/testtablespace", outputdir);
 
     /* finally loop on each file and do the replacement */
     for (name = names; *name; name++)
     {
         char        srcfile[MAXPGPATH];
         char        destfile[MAXPGPATH];
         char        prefix[MAXPGPATH];
         FILE       *infile,
                    *outfile;
         StringInfoData line;
 
         /* reject filenames not finishing in ".source" */
         if (strlen(*name) < 8)
             continue;
         if (strcmp(*name + strlen(*name) - 7, ".source") != 0)
             continue;
 
         count++;
 
         /* build the full actual paths to open */
         snprintf(prefix, strlen(*name) - 6, "%s", *name);
         snprintf(srcfile, MAXPGPATH, "%s/%s", indir, *name);
         snprintf(destfile, MAXPGPATH, "%s/%s/%s.%s", dest_dir, dest_subdir,
                  prefix, suffix);
 
         infile = fopen(srcfile, "r");
         if (!infile)
         {
             fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
                     progname, srcfile, strerror(errno));
             exit(2);
         }
         outfile = fopen(destfile, "w");
         if (!outfile)
         {
             fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
                     progname, destfile, strerror(errno));
             exit(2);
         }
 
         initStringInfo(&line);
 
         while (pg_get_line_buf(infile, &line))
         {
             replace_string(&line, "@abs_srcdir@", inputdir);
             replace_string(&line, "@abs_builddir@", outputdir);
             replace_string(&line, "@testtablespace@", testtablespace);
             replace_string(&line, "@libdir@", dlpath);
             replace_string(&line, "@DLSUFFIX@", DLSUFFIX);
             fputs(line.data, outfile);
         }
 
         pfree(line.data);
         fclose(infile);
         fclose(outfile);
     }
 
     /*
      * If we didn't process any files, complain because it probably means
      * somebody neglected to pass the needed --inputdir argument.
      */
     if (count <= 0)
     {
         fprintf(stderr, _("%s: no *.source files found in \"%s\"\n"),
                 progname, indir);
         exit(2);
     }
 
     pgfnames_cleanup(names);
 }

◆ create_database()

static void create_database ( const char * dbname )

static

Definition at line 2020 of file pg_regress.c.

References _, encoding, header(), _stringlist::next, nolocale, psql_command(), and _stringlist::str.

Referenced by regression_main().

 {
     _stringlist *sl;
 
     /*
      * We use template0 so that any installation-local cruft in template1 will
      * not mess up the tests.
      */
     header(_("creating database \"%s\""), dbname);
     if (encoding)
         psql_command("postgres", "CREATE DATABASE \"%s\" TEMPLATE=template0 ENCODING='%s'%s", dbname, encoding,
                      (nolocale) ? " LC_COLLATE='C' LC_CTYPE='C'" : "");
     else
         psql_command("postgres", "CREATE DATABASE \"%s\" TEMPLATE=template0%s", dbname,
                      (nolocale) ? " LC_COLLATE='C' LC_CTYPE='C'" : "");
     psql_command(dbname,
                  "ALTER DATABASE \"%s\" SET lc_messages TO 'C';"
                  "ALTER DATABASE \"%s\" SET lc_monetary TO 'C';"
                  "ALTER DATABASE \"%s\" SET lc_numeric TO 'C';"
                  "ALTER DATABASE \"%s\" SET lc_time TO 'C';"
                  "ALTER DATABASE \"%s\" SET bytea_output TO 'hex';"
                  "ALTER DATABASE \"%s\" SET timezone_abbreviations TO 'Default';",
                  dbname, dbname, dbname, dbname, dbname, dbname);
 
     /*
      * Install any requested extensions.  We use CREATE IF NOT EXISTS so that
      * this will work whether or not the extension is preinstalled.
      */
     for (sl = loadextension; sl != NULL; sl = sl->next)
     {
         header(_("installing %s"), sl->str);
         psql_command(dbname, "CREATE EXTENSION IF NOT EXISTS \"%s\"", sl->str);
     }
 }

◆ create_role()

static void create_role	(	const char *	rolename,
		const _stringlist *	granted_dbs
	)

static

Definition at line 2063 of file pg_regress.c.

References _, header(), _stringlist::next, psql_command(), and _stringlist::str.

Referenced by regression_main().

 {
     header(_("creating role \"%s\""), rolename);
     psql_command("postgres", "CREATE ROLE \"%s\" WITH LOGIN", rolename);
     for (; granted_dbs != NULL; granted_dbs = granted_dbs->next)
     {
         psql_command("postgres", "GRANT ALL ON DATABASE \"%s\" TO \"%s\"",
                      granted_dbs->str, rolename);
     }
 }

◆ directory_exists()

static bool directory_exists ( const char * dir )

static

Definition at line 1311 of file pg_regress.c.

References S_ISDIR, stat::st_mode, and stat.

Referenced by convert_sourcefiles_in(), open_result_files(), prepare_testtablespace_dir(), and regression_main().

 {
     struct stat st;
 
     if (stat(dir, &st) != 0)
         return false;
     if (S_ISDIR(st.st_mode))
         return true;
     return false;
 }

◆ drop_database_if_exists()

static void drop_database_if_exists ( const char * dbname )

static

Definition at line 2013 of file pg_regress.c.

References _, header(), and psql_command().

Referenced by regression_main().

 {
     header(_("dropping database \"%s\""), dbname);
     psql_command("postgres", "DROP DATABASE IF EXISTS \"%s\"", dbname);
 }

◆ drop_role_if_exists()

static void drop_role_if_exists ( const char * rolename )

static

Definition at line 2056 of file pg_regress.c.

References _, header(), and psql_command().

Referenced by regression_main().

 {
     header(_("dropping role \"%s\""), rolename);
     psql_command("postgres", "DROP ROLE IF EXISTS \"%s\"", rolename);
 }

◆ file_exists()

bool file_exists ( const char * file )

Definition at line 1300 of file pg_regress.c.

Referenced by results_differ().

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

◆ file_line_count()

static int file_line_count ( const char * file )

static

Definition at line 1278 of file pg_regress.c.

References _, fprintf, progname, and strerror.

Referenced by results_differ().

 {
     int         c;
     int         l = 0;
     FILE       *f = fopen(file, "r");
 
     if (!f)
     {
         fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
                 progname, file, strerror(errno));
         return -1;
     }
     while ((c = fgetc(f)) != EOF)
     {
         if (c == '\n')
             l++;
     }
     fclose(f);
     return l;
 }

◆ file_size()

static long file_size ( const char * file )

static

Definition at line 1257 of file pg_regress.c.

References _, fprintf, progname, and strerror.

Referenced by regression_main(), and run_diff().

 {
     long        r;
     FILE       *f = fopen(file, "r");
 
     if (!f)
     {
         fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
                 progname, file, strerror(errno));
         return -1;
     }
     fseek(f, 0, SEEK_END);
     r = ftell(f);
     fclose(f);
     return r;
 }

◆ free_stringlist()

static void free_stringlist ( _stringlist ** listhead )

static

Definition at line 178 of file pg_regress.c.

References free.

Referenced by regression_main(), and run_schedule().

 {
     if (listhead == NULL || *listhead == NULL)
         return;
     if ((*listhead)->next != NULL)
         free_stringlist(&((*listhead)->next));
     free((*listhead)->str);
     free(*listhead);
     *listhead = NULL;
 }

◆ get_alternative_expectfile()

static char* get_alternative_expectfile	(	const char *	expectfile,
		int	i
	)

static

Definition at line 1338 of file pg_regress.c.

References free, malloc, and snprintf.

Referenced by results_differ().

 {
     char       *last_dot;
     int         ssize = strlen(expectfile) + 2 + 1;
     char       *tmp;
     char       *s;
 
     if (!(tmp = (char *) malloc(ssize)))
         return NULL;
 
     if (!(s = (char *) malloc(ssize)))
     {
         free(tmp);
         return NULL;
     }
 
     strcpy(tmp, expectfile);
     last_dot = strrchr(tmp, '.');
     if (!last_dot)
     {
         free(tmp);
         free(s);
         return NULL;
     }
     *last_dot = '\0';
     snprintf(s, ssize, "%s_%d.%s", tmp, i, last_dot + 1);
     free(tmp);
     return s;
 }

◆ get_expectfile()

static const char* get_expectfile	(	const char *	testname,
		const char *	file
	)

static

Definition at line 710 of file pg_regress.c.

References _resultmap::next, _resultmap::resultfile, _resultmap::test, and _resultmap::type.

Referenced by results_differ().

 {
     char       *file_type;
     _resultmap *rm;
 
     /*
      * Determine the file type from the file name. This is just what is
      * following the last dot in the file name.
      */
     if (!file || !(file_type = strrchr(file, '.')))
         return NULL;
 
     file_type++;
 
     for (rm = resultmap; rm != NULL; rm = rm->next)
     {
         if (strcmp(testname, rm->test) == 0 && strcmp(file_type, rm->type) == 0)
         {
             return rm->resultfile;
         }
     }
 
     return NULL;
 }

◆ header()

static void header	(	const char *	fmt,
			...
	)

static

Definition at line 210 of file pg_regress.c.

References fprintf, generate_unaccent_rules::stdout, and vsnprintf.

Referenced by _tarPositionTo(), BTPageSetDeleted(), check_toast_tuple(), convertJsonbArray(), convertJsonbObject(), create_database(), create_role(), cube_recv(), datumRestore(), datumSerialize(), DecodeMultiInsert(), DecodeXLogTuple(), drop_database_if_exists(), drop_role_if_exists(), ExecHashJoinGetSavedTuple(), pgss_shmem_startup(), printTableAddHeader(), ReceiveTarCopyChunk(), ReceiveTarFile(), refresh_utf8format(), regression_main(), scan_file(), tar_close(), and XLogReaderValidatePageHeader().

 {
     char        tmp[64];
     va_list     ap;
 
     va_start(ap, fmt);
     vsnprintf(tmp, sizeof(tmp), fmt, ap);
     va_end(ap);
 
     fprintf(stdout, "============== %-38s ==============\n", tmp);
     fflush(stdout);
 }

◆ help()

static void help ( void )

static

Definition at line 2075 of file pg_regress.c.

References _, printf, and progname.

Referenced by regression_main().

 {
     printf(_("PostgreSQL regression test driver\n"));
     printf(_("\n"));
     printf(_("Usage:\n  %s [OPTION]... [EXTRA-TEST]...\n"), progname);
     printf(_("\n"));
     printf(_("Options:\n"));
     printf(_("      --bindir=BINPATH          use BINPATH for programs that are run;\n"));
     printf(_("                                if empty, use PATH from the environment\n"));
     printf(_("      --config-auth=DATADIR     update authentication settings for DATADIR\n"));
     printf(_("      --create-role=ROLE        create the specified role before testing\n"));
     printf(_("      --dbname=DB               use database DB (default \"regression\")\n"));
     printf(_("      --debug                   turn on debug mode in programs that are run\n"));
     printf(_("      --dlpath=DIR              look for dynamic libraries in DIR\n"));
     printf(_("      --encoding=ENCODING       use ENCODING as the encoding\n"));
     printf(_("  -h, --help                    show this help, then exit\n"));
     printf(_("      --inputdir=DIR            take input files from DIR (default \".\")\n"));
     printf(_("      --launcher=CMD            use CMD as launcher of psql\n"));
     printf(_("      --load-extension=EXT      load the named extension before running the\n"));
     printf(_("                                tests; can appear multiple times\n"));
     printf(_("      --make-testtablespace-dir create testtablespace directory\n"));
     printf(_("      --max-connections=N       maximum number of concurrent connections\n"));
     printf(_("                                (default is 0, meaning unlimited)\n"));
     printf(_("      --max-concurrent-tests=N  maximum number of concurrent tests in schedule\n"));
     printf(_("                                (default is 0, meaning unlimited)\n"));
     printf(_("      --outputdir=DIR           place output files in DIR (default \".\")\n"));
     printf(_("      --schedule=FILE           use test ordering schedule from FILE\n"));
     printf(_("                                (can be used multiple times to concatenate)\n"));
     printf(_("      --temp-instance=DIR       create a temporary instance in DIR\n"));
     printf(_("      --use-existing            use an existing installation\n"));
     printf(_("  -V, --version                 output version information, then exit\n"));
     printf(_("\n"));
     printf(_("Options for \"temp-instance\" mode:\n"));
     printf(_("      --no-locale               use C locale\n"));
     printf(_("      --port=PORT               start postmaster on PORT\n"));
     printf(_("      --temp-config=FILE        append contents of FILE to temporary config\n"));
     printf(_("\n"));
     printf(_("Options for using an existing installation:\n"));
     printf(_("      --host=HOST               use postmaster running on HOST\n"));
     printf(_("      --port=PORT               use postmaster running at PORT\n"));
     printf(_("      --user=USER               connect as USER\n"));
     printf(_("\n"));
     printf(_("The exit status is 0 if all tests passed, 1 if some tests failed, and 2\n"));
     printf(_("if the tests could not be run for some reason.\n"));
     printf(_("\n"));
     printf(_("Report bugs to <%s>.\n"), PACKAGE_BUGREPORT);
     printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
 }

◆ initialize_environment()

static void initialize_environment ( void )

static

Definition at line 739 of file pg_regress.c.

References _, addrinfo::ai_addr, addrinfo::ai_addrlen, addrinfo::ai_canonname, addrinfo::ai_family, addrinfo::ai_flags, addrinfo::ai_next, AI_NUMERICHOST, addrinfo::ai_protocol, addrinfo::ai_socktype, Assert, convert_sourcefiles(), encoding, fprintf, free, get_user_name(), getaddrinfo, hostname, load_resultmap(), MAXPGPATH, _stringlist::next, nolocale, pg_malloc(), pghost, pgport, port, printf, progname, psprintf(), realloc, setenv, snprintf, sockdir, sprintf, _stringlist::str, strerror, temp_instance, unsetenv, and user.

Referenced by regression_main().

 {
     /*
      * Set default application_name.  (The test_start_function may choose to
      * override this, but if it doesn't, we have something useful in place.)
      */
     setenv("PGAPPNAME", "pg_regress", 1);
 
     if (nolocale)
     {
         /*
          * Clear out any non-C locale settings
          */
         unsetenv("LC_COLLATE");
         unsetenv("LC_CTYPE");
         unsetenv("LC_MONETARY");
         unsetenv("LC_NUMERIC");
         unsetenv("LC_TIME");
         unsetenv("LANG");
 
         /*
          * Most platforms have adopted the POSIX locale as their
          * implementation-defined default locale.  Exceptions include native
          * Windows, macOS with --enable-nls, and Cygwin with --enable-nls.
          * (Use of --enable-nls matters because libintl replaces setlocale().)
          * Also, PostgreSQL does not support macOS with locale environment
          * variables unset; see PostmasterMain().
          */
 #if defined(WIN32) || defined(__CYGWIN__) || defined(__darwin__)
         setenv("LANG", "C", 1);
 #endif
     }
 
     /*
      * Set translation-related settings to English; otherwise psql will
      * produce translated messages and produce diffs.  (XXX If we ever support
      * translation of pg_regress, this needs to be moved elsewhere, where psql
      * is actually called.)
      */
     unsetenv("LANGUAGE");
     unsetenv("LC_ALL");
     setenv("LC_MESSAGES", "C", 1);
 
     /*
      * Set encoding as requested
      */
     if (encoding)
         setenv("PGCLIENTENCODING", encoding, 1);
     else
         unsetenv("PGCLIENTENCODING");
 
     /*
      * Set timezone and datestyle for datetime-related tests
      */
     setenv("PGTZ", "PST8PDT", 1);
     setenv("PGDATESTYLE", "Postgres, MDY", 1);
 
     /*
      * Likewise set intervalstyle to ensure consistent results.  This is a bit
      * more painful because we must use PGOPTIONS, and we want to preserve the
      * user's ability to set other variables through that.
      */
     {
         const char *my_pgoptions = "-c intervalstyle=postgres_verbose";
         const char *old_pgoptions = getenv("PGOPTIONS");
         char       *new_pgoptions;
 
         if (!old_pgoptions)
             old_pgoptions = "";
         new_pgoptions = psprintf("%s %s",
                                  old_pgoptions, my_pgoptions);
         setenv("PGOPTIONS", new_pgoptions, 1);
         free(new_pgoptions);
     }
 
     if (temp_instance)
     {
         /*
          * Clear out any environment vars that might cause psql to connect to
          * the wrong postmaster, or otherwise behave in nondefault ways. (Note
          * we also use psql's -X switch consistently, so that ~/.psqlrc files
          * won't mess things up.)  Also, set PGPORT to the temp port, and set
          * PGHOST depending on whether we are using TCP or Unix sockets.
          *
          * This list should be kept in sync with TestLib.pm.
          */
         unsetenv("PGCHANNELBINDING");
         /* PGCLIENTENCODING, see above */
         unsetenv("PGCONNECT_TIMEOUT");
         unsetenv("PGDATA");
         unsetenv("PGDATABASE");
         unsetenv("PGGSSENCMODE");
         unsetenv("PGGSSLIB");
         /* PGHOSTADDR, see below */
         unsetenv("PGKRBSRVNAME");
         unsetenv("PGPASSFILE");
         unsetenv("PGPASSWORD");
         unsetenv("PGREQUIREPEER");
         unsetenv("PGREQUIRESSL");
         unsetenv("PGSERVICE");
         unsetenv("PGSERVICEFILE");
         unsetenv("PGSSLCERT");
         unsetenv("PGSSLCRL");
         unsetenv("PGSSLCRLDIR");
         unsetenv("PGSSLKEY");
         unsetenv("PGSSLMAXPROTOCOLVERSION");
         unsetenv("PGSSLMINPROTOCOLVERSION");
         unsetenv("PGSSLMODE");
         unsetenv("PGSSLROOTCERT");
         unsetenv("PGSSLSNI");
         unsetenv("PGTARGETSESSIONATTRS");
         unsetenv("PGUSER");
         /* PGPORT, see below */
         /* PGHOST, see below */
 
 #ifdef HAVE_UNIX_SOCKETS
         if (hostname != NULL)
             setenv("PGHOST", hostname, 1);
         else
         {
             sockdir = getenv("PG_REGRESS_SOCK_DIR");
             if (!sockdir)
                 sockdir = make_temp_sockdir();
             setenv("PGHOST", sockdir, 1);
         }
 #else
         Assert(hostname != NULL);
         setenv("PGHOST", hostname, 1);
 #endif
         unsetenv("PGHOSTADDR");
         if (port != -1)
         {
             char        s[16];
 
             sprintf(s, "%d", port);
             setenv("PGPORT", s, 1);
         }
     }
     else
     {
         const char *pghost;
         const char *pgport;
 
         /*
          * When testing an existing install, we honor existing environment
          * variables, except if they're overridden by command line options.
          */
         if (hostname != NULL)
         {
             setenv("PGHOST", hostname, 1);
             unsetenv("PGHOSTADDR");
         }
         if (port != -1)
         {
             char        s[16];
 
             sprintf(s, "%d", port);
             setenv("PGPORT", s, 1);
         }
         if (user != NULL)
             setenv("PGUSER", user, 1);
 
         /*
          * However, we *don't* honor PGDATABASE, since we certainly don't wish
          * to connect to whatever database the user might like as default.
          * (Most tests override PGDATABASE anyway, but there are some ECPG
          * test cases that don't.)
          */
         unsetenv("PGDATABASE");
 
         /*
          * Report what we're connecting to
          */
         pghost = getenv("PGHOST");
         pgport = getenv("PGPORT");
 #ifndef HAVE_UNIX_SOCKETS
         if (!pghost)
             pghost = "localhost";
 #endif
 
         if (pghost && pgport)
             printf(_("(using postmaster on %s, port %s)\n"), pghost, pgport);
         if (pghost && !pgport)
             printf(_("(using postmaster on %s, default port)\n"), pghost);
         if (!pghost && pgport)
             printf(_("(using postmaster on Unix socket, port %s)\n"), pgport);
         if (!pghost && !pgport)
             printf(_("(using postmaster on Unix socket, default port)\n"));
     }
 
     convert_sourcefiles();
     load_resultmap();
 }

◆ load_resultmap()

static void load_resultmap ( void )

static

Definition at line 628 of file pg_regress.c.

References _, buf, fprintf, host_platform, i, inputdir, MAXPGPATH, _resultmap::next, pg_malloc(), pg_strdup(), progname, _resultmap::resultfile, resultmap, snprintf, strerror, string_matches_pattern(), _resultmap::test, and _resultmap::type.

Referenced by initialize_environment().

 {
     char        buf[MAXPGPATH];
     FILE       *f;
 
     /* scan the file ... */
     snprintf(buf, sizeof(buf), "%s/resultmap", inputdir);
     f = fopen(buf, "r");
     if (!f)
     {
         /* OK if it doesn't exist, else complain */
         if (errno == ENOENT)
             return;
         fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
                 progname, buf, strerror(errno));
         exit(2);
     }
 
     while (fgets(buf, sizeof(buf), f))
     {
         char       *platform;
         char       *file_type;
         char       *expected;
         int         i;
 
         /* strip trailing whitespace, especially the newline */
         i = strlen(buf);
         while (i > 0 && isspace((unsigned char) buf[i - 1]))
             buf[--i] = '\0';
 
         /* parse out the line fields */
         file_type = strchr(buf, ':');
         if (!file_type)
         {
             fprintf(stderr, _("incorrectly formatted resultmap entry: %s\n"),
                     buf);
             exit(2);
         }
         *file_type++ = '\0';
 
         platform = strchr(file_type, ':');
         if (!platform)
         {
             fprintf(stderr, _("incorrectly formatted resultmap entry: %s\n"),
                     buf);
             exit(2);
         }
         *platform++ = '\0';
         expected = strchr(platform, '=');
         if (!expected)
         {
             fprintf(stderr, _("incorrectly formatted resultmap entry: %s\n"),
                     buf);
             exit(2);
         }
         *expected++ = '\0';
 
         /*
          * if it's for current platform, save it in resultmap list. Note: by
          * adding at the front of the list, we ensure that in ambiguous cases,
          * the last match in the resultmap file is used. This mimics the
          * behavior of the old shell script.
          */
         if (string_matches_pattern(host_platform, platform))
         {
             _resultmap *entry = pg_malloc(sizeof(_resultmap));
 
             entry->test = pg_strdup(buf);
             entry->type = pg_strdup(file_type);
             entry->resultfile = pg_strdup(expected);
             entry->next = resultmap;
             resultmap = entry;
         }
     }
     fclose(f);
 }

◆ log_child_failure()

static void log_child_failure ( int exitstatus )

static

Definition at line 1627 of file pg_regress.c.

References _, pg_strsignal(), status(), WEXITSTATUS, WIFEXITED, WIFSIGNALED, and WTERMSIG.

Referenced by run_schedule(), and run_single_test().

 {
     if (WIFEXITED(exitstatus))
         status(_(" (test process exited with exit code %d)"),
                WEXITSTATUS(exitstatus));
     else if (WIFSIGNALED(exitstatus))
     {
 #if defined(WIN32)
         status(_(" (test process was terminated by exception 0x%X)"),
                WTERMSIG(exitstatus));
 #else
         status(_(" (test process was terminated by signal %d: %s)"),
                WTERMSIG(exitstatus), pg_strsignal(WTERMSIG(exitstatus)));
 #endif
     }
     else
         status(_(" (test process exited with unrecognized status %d)"),
                exitstatus);
 }

◆ make_directory()

static void make_directory ( const char * dir )

static

Definition at line 1324 of file pg_regress.c.

References _, fprintf, mkdir, progname, S_IRWXG, S_IRWXO, S_IRWXU, and strerror.

Referenced by convert_sourcefiles_in(), open_result_files(), prepare_testtablespace_dir(), and regression_main().

 {
     if (mkdir(dir, S_IRWXU | S_IRWXG | S_IRWXO) < 0)
     {
         fprintf(stderr, _("%s: could not create directory \"%s\": %s\n"),
                 progname, dir, strerror(errno));
         exit(2);
     }
 }

◆ open_result_files()

static void open_result_files ( void )

static

Definition at line 1973 of file pg_regress.c.

References _, difffilename, directory_exists(), fprintf, logfile, logfilename, make_directory(), MAXPGPATH, outputdir, pg_strdup(), progname, snprintf, and strerror.

Referenced by regression_main().

 {
     char        file[MAXPGPATH];
     FILE       *difffile;
 
     /* create outputdir directory if not present */
     if (!directory_exists(outputdir))
         make_directory(outputdir);
 
     /* create the log file (copy of running status output) */
     snprintf(file, sizeof(file), "%s/regression.out", outputdir);
     logfilename = pg_strdup(file);
     logfile = fopen(logfilename, "w");
     if (!logfile)
     {
         fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
                 progname, logfilename, strerror(errno));
         exit(2);
     }
 
     /* create the diffs file as empty */
     snprintf(file, sizeof(file), "%s/regression.diffs", outputdir);
     difffilename = pg_strdup(file);
     difffile = fopen(difffilename, "w");
     if (!difffile)
     {
         fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
                 progname, difffilename, strerror(errno));
         exit(2);
     }
     /* we don't keep the diffs file open continuously */
     fclose(difffile);
 
     /* also create the results directory if not present */
     snprintf(file, sizeof(file), "%s/results", outputdir);
     if (!directory_exists(file))
         make_directory(file);
 }

◆ prepare_testtablespace_dir()

static void prepare_testtablespace_dir ( void )

static

Definition at line 596 of file pg_regress.c.

References _, directory_exists(), fprintf, make_directory(), MAXPGPATH, outputdir, progname, rmtree(), and snprintf.

Referenced by regression_main().

 {
     char        testtablespace[MAXPGPATH];
 
     snprintf(testtablespace, MAXPGPATH, "%s/testtablespace", outputdir);
 
     if (directory_exists(testtablespace))
     {
         if (!rmtree(testtablespace, true))
         {
             fprintf(stderr, _("\n%s: could not remove test tablespace \"%s\"\n"),
                     progname, testtablespace);
             exit(2);
         }
     }
     make_directory(testtablespace);
 }

◆ psql_command()

static void psql_command	(	const char *	database,
		const char *	query,
			...
	)

static

Definition at line 1144 of file pg_regress.c.

References _, generate_unaccent_rules::args, bindir, fprintf, MAXPGPATH, PID_TYPE, snprintf, and vsnprintf.

Referenced by create_database(), create_role(), drop_database_if_exists(), and drop_role_if_exists().

 {
     char        query_formatted[1024];
     char        query_escaped[2048];
     char        psql_cmd[MAXPGPATH + 2048];
     va_list     args;
     char       *s;
     char       *d;
 
     /* Generate the query with insertion of sprintf arguments */
     va_start(args, query);
     vsnprintf(query_formatted, sizeof(query_formatted), query, args);
     va_end(args);
 
     /* Now escape any shell double-quote metacharacters */
     d = query_escaped;
     for (s = query_formatted; *s; s++)
     {
         if (strchr("\\\"$`", *s))
             *d++ = '\\';
         *d++ = *s;
     }
     *d = '\0';
 
     /* And now we can build and execute the shell command */
     snprintf(psql_cmd, sizeof(psql_cmd),
              "\"%s%spsql\" -X -c \"%s\" \"%s\"",
              bindir ? bindir : "",
              bindir ? "/" : "",
              query_escaped,
              database);
 
     if (system(psql_cmd) != 0)
     {
         /* psql probably already reported the error */
         fprintf(stderr, _("command failed: %s\n"), psql_cmd);
         exit(2);
     }
 }

◆ regression_main()

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

Definition at line 2125 of file pg_regress.c.

References _, add_stringlist_item(), bindir, buf, 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	(	StringInfo	string,
		const char *	replace,
		const char *	replacement
	)

Definition at line 447 of file pg_regress.c.

References appendStringInfoString(), StringInfoData::data, free, and pg_strdup().

Referenced by convert_sourcefiles_in(), and ecpg_start_test().

 {
     int         pos = 0;
     char       *ptr;
 
     while ((ptr = strstr(string->data + pos, replace)) != NULL)
     {
         /* Must copy the remainder of the string out of the StringInfo */
         char       *suffix = pg_strdup(ptr + strlen(replace));
 
         /* Truncate StringInfo at start of found string ... */
         string->len = ptr - string->data;
         /* ... and append the replacement (this restores the trailing '\0') */
         appendStringInfoString(string, replacement);
         /* Next search should start after the replacement */
         pos = string->len;
         /* Put back the remainder of the string */
         appendStringInfoString(string, suffix);
         free(suffix);
     }
 }

◆ results_differ()

static bool results_differ	(	const char *	testname,
		const char *	resultsfile,
		const char *	default_expectfile
	)

static

Definition at line 1405 of file pg_regress.c.

References _, basic_diff_opts, difffilename, file_exists(), file_line_count(), fprintf, free, get_alternative_expectfile(), get_expectfile(), i, MAXPGPATH, pretty_diff_opts, run_diff(), snprintf, strerror, and strlcpy().

Referenced by run_schedule(), and run_single_test().

 {
     char        expectfile[MAXPGPATH];
     char        diff[MAXPGPATH];
     char        cmd[MAXPGPATH * 3];
     char        best_expect_file[MAXPGPATH];
     FILE       *difffile;
     int         best_line_count;
     int         i;
     int         l;
     const char *platform_expectfile;
 
     /*
      * We can pass either the resultsfile or the expectfile, they should have
      * the same type (filename.type) anyway.
      */
     platform_expectfile = get_expectfile(testname, resultsfile);
 
     strlcpy(expectfile, default_expectfile, sizeof(expectfile));
     if (platform_expectfile)
     {
         /*
          * Replace everything after the last slash in expectfile with what the
          * platform_expectfile contains.
          */
         char       *p = strrchr(expectfile, '/');
 
         if (p)
             strcpy(++p, platform_expectfile);
     }
 
     /* Name to use for temporary diff file */
     snprintf(diff, sizeof(diff), "%s.diff", resultsfile);
 
     /* OK, run the diff */
     snprintf(cmd, sizeof(cmd),
              "diff %s \"%s\" \"%s\" > \"%s\"",
              basic_diff_opts, expectfile, resultsfile, diff);
 
     /* Is the diff file empty? */
     if (run_diff(cmd, diff) == 0)
     {
         unlink(diff);
         return false;
     }
 
     /* There may be secondary comparison files that match better */
     best_line_count = file_line_count(diff);
     strcpy(best_expect_file, expectfile);
 
     for (i = 0; i <= 9; i++)
     {
         char       *alt_expectfile;
 
         alt_expectfile = get_alternative_expectfile(expectfile, i);
         if (!alt_expectfile)
         {
             fprintf(stderr, _("Unable to check secondary comparison files: %s\n"),
                     strerror(errno));
             exit(2);
         }
 
         if (!file_exists(alt_expectfile))
         {
             free(alt_expectfile);
             continue;
         }
 
         snprintf(cmd, sizeof(cmd),
                  "diff %s \"%s\" \"%s\" > \"%s\"",
                  basic_diff_opts, alt_expectfile, resultsfile, diff);
 
         if (run_diff(cmd, diff) == 0)
         {
             unlink(diff);
             free(alt_expectfile);
             return false;
         }
 
         l = file_line_count(diff);
         if (l < best_line_count)
         {
             /* This diff was a better match than the last one */
             best_line_count = l;
             strlcpy(best_expect_file, alt_expectfile, sizeof(best_expect_file));
         }
         free(alt_expectfile);
     }
 
     /*
      * fall back on the canonical results file if we haven't tried it yet and
      * haven't found a complete match yet.
      */
 
     if (platform_expectfile)
     {
         snprintf(cmd, sizeof(cmd),
                  "diff %s \"%s\" \"%s\" > \"%s\"",
                  basic_diff_opts, default_expectfile, resultsfile, diff);
 
         if (run_diff(cmd, diff) == 0)
         {
             /* No diff = no changes = good */
             unlink(diff);
             return false;
         }
 
         l = file_line_count(diff);
         if (l < best_line_count)
         {
             /* This diff was a better match than the last one */
             best_line_count = l;
             strlcpy(best_expect_file, default_expectfile, sizeof(best_expect_file));
         }
     }
 
     /*
      * Use the best comparison file to generate the "pretty" diff, which we
      * append to the diffs summary file.
      */
 
     /* Write diff header */
     difffile = fopen(difffilename, "a");
     if (difffile)
     {
         fprintf(difffile,
                 "diff %s %s %s\n",
                 pretty_diff_opts, best_expect_file, resultsfile);
         fclose(difffile);
     }
 
     /* Run diff */
     snprintf(cmd, sizeof(cmd),
              "diff %s \"%s\" \"%s\" >> \"%s\"",
              pretty_diff_opts, best_expect_file, resultsfile, difffilename);
     run_diff(cmd, difffilename);
 
     unlink(diff);
     return true;
 }

◆ run_diff()

static int run_diff	(	const char *	cmd,
		const char *	filename
	)

static

Definition at line 1372 of file pg_regress.c.

References _, file_size(), fprintf, WEXITSTATUS, and WIFEXITED.

Referenced by results_differ().

 {
     int         r;
 
     r = system(cmd);
     if (!WIFEXITED(r) || WEXITSTATUS(r) > 1)
     {
         fprintf(stderr, _("diff command failed with status %d: %s\n"), r, cmd);
         exit(2);
     }
 #ifdef WIN32
 
     /*
      * On WIN32, if the 'diff' command cannot be found, system() returns 1,
      * but produces nothing to stdout, so we check for that here.
      */
     if (WEXITSTATUS(r) == 1 && file_size(filename) <= 0)
     {
         fprintf(stderr, _("diff command not found: %s\n"), cmd);
         exit(2);
     }
 #endif
 
     return WEXITSTATUS(r);
 }

◆ run_schedule()

static void run_schedule	(	const char *	schedule,
		test_start_function	startfunc,
		postprocess_result_function	postfunc
	)

static

Definition at line 1651 of file pg_regress.c.

References _, add_stringlist_item(), fail_count, fail_ignore_count, fprintf, free_stringlist(), i, INSTR_TIME_GET_MILLISEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, log_child_failure(), max_concurrent_tests, max_connections, MAX_PARALLEL_TESTS, _stringlist::next, pg_free(), pg_strdup(), PID_TYPE, printf, progname, results_differ(), status(), status_end(), _stringlist::str, strerror, success_count, _resultmap::test, and wait_for_tests().

Referenced by regression_main().

 {
 #define MAX_PARALLEL_TESTS 100
     char       *tests[MAX_PARALLEL_TESTS];
     _stringlist *resultfiles[MAX_PARALLEL_TESTS];
     _stringlist *expectfiles[MAX_PARALLEL_TESTS];
     _stringlist *tags[MAX_PARALLEL_TESTS];
     PID_TYPE    pids[MAX_PARALLEL_TESTS];
     instr_time  starttimes[MAX_PARALLEL_TESTS];
     instr_time  stoptimes[MAX_PARALLEL_TESTS];
     int         statuses[MAX_PARALLEL_TESTS];
     _stringlist *ignorelist = NULL;
     char        scbuf[1024];
     FILE       *scf;
     int         line_num = 0;
 
     memset(tests, 0, sizeof(tests));
     memset(resultfiles, 0, sizeof(resultfiles));
     memset(expectfiles, 0, sizeof(expectfiles));
     memset(tags, 0, sizeof(tags));
 
     scf = fopen(schedule, "r");
     if (!scf)
     {
         fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
                 progname, schedule, strerror(errno));
         exit(2);
     }
 
     while (fgets(scbuf, sizeof(scbuf), scf))
     {
         char       *test = NULL;
         char       *c;
         int         num_tests;
         bool        inword;
         int         i;
 
         line_num++;
 
         /* strip trailing whitespace, especially the newline */
         i = strlen(scbuf);
         while (i > 0 && isspace((unsigned char) scbuf[i - 1]))
             scbuf[--i] = '\0';
 
         if (scbuf[0] == '\0' || scbuf[0] == '#')
             continue;
         if (strncmp(scbuf, "test: ", 6) == 0)
             test = scbuf + 6;
         else if (strncmp(scbuf, "ignore: ", 8) == 0)
         {
             c = scbuf + 8;
             while (*c && isspace((unsigned char) *c))
                 c++;
             add_stringlist_item(&ignorelist, c);
 
             /*
              * Note: ignore: lines do not run the test, they just say that
              * failure of this test when run later on is to be ignored. A bit
              * odd but that's how the shell-script version did it.
              */
             continue;
         }
         else
         {
             fprintf(stderr, _("syntax error in schedule file \"%s\" line %d: %s\n"),
                     schedule, line_num, scbuf);
             exit(2);
         }
 
         num_tests = 0;
         inword = false;
         for (c = test;; c++)
         {
             if (*c == '\0' || isspace((unsigned char) *c))
             {
                 if (inword)
                 {
                     /* Reached end of a test name */
                     char        sav;
 
                     if (num_tests >= MAX_PARALLEL_TESTS)
                     {
                         fprintf(stderr, _("too many parallel tests (more than %d) in schedule file \"%s\" line %d: %s\n"),
                                 MAX_PARALLEL_TESTS, schedule, line_num, scbuf);
                         exit(2);
                     }
                     sav = *c;
                     *c = '\0';
                     tests[num_tests] = pg_strdup(test);
                     num_tests++;
                     *c = sav;
                     inword = false;
                 }
                 if (*c == '\0')
                     break;      /* loop exit is here */
             }
             else if (!inword)
             {
                 /* Start of a test name */
                 test = c;
                 inword = true;
             }
         }
 
         if (num_tests == 0)
         {
             fprintf(stderr, _("syntax error in schedule file \"%s\" line %d: %s\n"),
                     schedule, line_num, scbuf);
             exit(2);
         }
 
         if (num_tests == 1)
         {
             status(_("test %-28s ... "), tests[0]);
             pids[0] = (startfunc) (tests[0], &resultfiles[0], &expectfiles[0], &tags[0]);
             INSTR_TIME_SET_CURRENT(starttimes[0]);
             wait_for_tests(pids, statuses, stoptimes, NULL, 1);
             /* status line is finished below */
         }
         else if (max_concurrent_tests > 0 && max_concurrent_tests < num_tests)
         {
             fprintf(stderr, _("too many parallel tests (more than %d) in schedule file \"%s\" line %d: %s\n"),
                     max_concurrent_tests, schedule, line_num, scbuf);
             exit(2);
         }
         else if (max_connections > 0 && max_connections < num_tests)
         {
             int         oldest = 0;
 
             status(_("parallel group (%d tests, in groups of %d): "),
                    num_tests, max_connections);
             for (i = 0; i < num_tests; i++)
             {
                 if (i - oldest >= max_connections)
                 {
                     wait_for_tests(pids + oldest, statuses + oldest,
                                    stoptimes + oldest,
                                    tests + oldest, i - oldest);
                     oldest = i;
                 }
                 pids[i] = (startfunc) (tests[i], &resultfiles[i], &expectfiles[i], &tags[i]);
                 INSTR_TIME_SET_CURRENT(starttimes[i]);
             }
             wait_for_tests(pids + oldest, statuses + oldest,
                            stoptimes + oldest,
                            tests + oldest, i - oldest);
             status_end();
         }
         else
         {
             status(_("parallel group (%d tests): "), num_tests);
             for (i = 0; i < num_tests; i++)
             {
                 pids[i] = (startfunc) (tests[i], &resultfiles[i], &expectfiles[i], &tags[i]);
                 INSTR_TIME_SET_CURRENT(starttimes[i]);
             }
             wait_for_tests(pids, statuses, stoptimes, tests, num_tests);
             status_end();
         }
 
         /* Check results for all tests */
         for (i = 0; i < num_tests; i++)
         {
             _stringlist *rl,
                        *el,
                        *tl;
             bool        differ = false;
 
             if (num_tests > 1)
                 status(_("     %-28s ... "), tests[i]);
 
             /*
              * Advance over all three lists simultaneously.
              *
              * Compare resultfiles[j] with expectfiles[j] always. Tags are
              * optional but if there are tags, the tag list has the same
              * length as the other two lists.
              */
             for (rl = resultfiles[i], el = expectfiles[i], tl = tags[i];
                  rl != NULL;    /* rl and el have the same length */
                  rl = rl->next, el = el->next,
                  tl = tl ? tl->next : NULL)
             {
                 bool        newdiff;
 
                 if (postfunc)
                     (*postfunc) (rl->str);
                 newdiff = results_differ(tests[i], rl->str, el->str);
                 if (newdiff && tl)
                 {
                     printf("%s ", tl->str);
                 }
                 differ |= newdiff;
             }
 
             if (differ)
             {
                 bool        ignore = false;
                 _stringlist *sl;
 
                 for (sl = ignorelist; sl != NULL; sl = sl->next)
                 {
                     if (strcmp(tests[i], sl->str) == 0)
                     {
                         ignore = true;
                         break;
                     }
                 }
                 if (ignore)
                 {
                     status(_("failed (ignored)"));
                     fail_ignore_count++;
                 }
                 else
                 {
                     status(_("FAILED"));
                     fail_count++;
                 }
             }
             else
             {
                 status(_("ok    "));    /* align with FAILED */
                 success_count++;
             }
 
             if (statuses[i] != 0)
                 log_child_failure(statuses[i]);
 
             INSTR_TIME_SUBTRACT(stoptimes[i], starttimes[i]);
             status(_(" %8.0f ms"), INSTR_TIME_GET_MILLISEC(stoptimes[i]));
 
             status_end();
         }
 
         for (i = 0; i < num_tests; i++)
         {
             pg_free(tests[i]);
             tests[i] = NULL;
             free_stringlist(&resultfiles[i]);
             free_stringlist(&expectfiles[i]);
             free_stringlist(&tags[i]);
         }
     }
 
     free_stringlist(&ignorelist);
 
     fclose(scf);
 }

◆ run_single_test()

static void run_single_test	(	const char *	test,
		test_start_function	startfunc,
		postprocess_result_function	postfunc
	)

static

Definition at line 1905 of file pg_regress.c.

References _, fail_count, INSTR_TIME_GET_MILLISEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, log_child_failure(), _stringlist::next, PID_TYPE, printf, results_differ(), status(), status_end(), _stringlist::str, success_count, and wait_for_tests().

Referenced by regression_main().

 {
     PID_TYPE    pid;
     instr_time  starttime;
     instr_time  stoptime;
     int         exit_status;
     _stringlist *resultfiles = NULL;
     _stringlist *expectfiles = NULL;
     _stringlist *tags = NULL;
     _stringlist *rl,
                *el,
                *tl;
     bool        differ = false;
 
     status(_("test %-28s ... "), test);
     pid = (startfunc) (test, &resultfiles, &expectfiles, &tags);
     INSTR_TIME_SET_CURRENT(starttime);
     wait_for_tests(&pid, &exit_status, &stoptime, NULL, 1);
 
     /*
      * Advance over all three lists simultaneously.
      *
      * Compare resultfiles[j] with expectfiles[j] always. Tags are optional
      * but if there are tags, the tag list has the same length as the other
      * two lists.
      */
     for (rl = resultfiles, el = expectfiles, tl = tags;
          rl != NULL;            /* rl and el have the same length */
          rl = rl->next, el = el->next,
          tl = tl ? tl->next : NULL)
     {
         bool        newdiff;
 
         if (postfunc)
             (*postfunc) (rl->str);
         newdiff = results_differ(test, rl->str, el->str);
         if (newdiff && tl)
         {
             printf("%s ", tl->str);
         }
         differ |= newdiff;
     }
 
     if (differ)
     {
         status(_("FAILED"));
         fail_count++;
     }
     else
     {
         status(_("ok    "));    /* align with FAILED */
         success_count++;
     }
 
     if (exit_status != 0)
         log_child_failure(exit_status);
 
     INSTR_TIME_SUBTRACT(stoptime, starttime);
     status(_(" %8.0f ms"), INSTR_TIME_GET_MILLISEC(stoptime));
 
     status_end();
 }

◆ spawn_process()

PID_TYPE spawn_process ( const char * cmdline )

Definition at line 1190 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
 }

◆ split_to_stringlist()

static void split_to_stringlist	(	const char *	s,
		const char *	delim,
		_stringlist **	listhead
	)

static

Definition at line 193 of file pg_regress.c.

References add_stringlist_item(), free, and pg_strdup().

Referenced by regression_main().

 {
     char       *sc = pg_strdup(s);
     char       *token = strtok(sc, delim);
 
     while (token)
     {
         add_stringlist_item(listhead, token);
         token = strtok(NULL, delim);
     }
     free(sc);
 }

◆ status()

static void status	(	const char *	fmt,
			...
	)

static

Definition at line 227 of file pg_regress.c.

References logfile, generate_unaccent_rules::stdout, and vfprintf.

Referenced by _bt_first(), _bt_parallel_seize(), _bt_readnextpage(), _bt_steppage(), apw_start_leader_worker(), AtAbort_Portals(), AtCleanup_Portals(), AtEOSubXact_RelationCache(), AtEOXact_RelationCache(), AtPrepare_Locks(), AtSubAbort_Portals(), AtSubCleanup_Portals(), AtSubCommit_Portals(), BackendInitialize(), BaseBackup(), be_lo_lseek(), be_lo_lseek64(), bf_check_supported_key_len(), check_worker_status(), CheckForSessionAndXactLocks(), CheckMD5Auth(), ClientAuthentication(), compute_new_xmax_infomask(), dblink_get_connections(), DestroyPartitionDirectory(), do_kill(), do_lo_export(), do_lo_unlink(), DoesMultiXactIdConflict(), ecpg_process_output(), ecpg_store_result(), exec_command(), exec_command_crosstabview(), exec_command_d(), exec_command_edit(), exec_command_ef_ev(), exec_command_g(), exec_command_gdesc(), exec_command_gexec(), exec_command_gset(), exec_command_lo(), exec_command_quit(), exec_command_sf_sv(), exec_command_write(), executeQueryOrDie(), forget_invalid_pages(), forget_invalid_pages_db(), ForgetPortalSnapshots(), FreezeMultiXactId(), get_collation_actual_version(), get_xid_status(), GetLockmodeName(), GetMultiXactIdHintBits(), HandleSlashCmds(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), HoldPinnedPortals(), InvalidateAttoptCacheCallback(), InvalidateOprCacheCallBack(), InvalidateOprProofCacheCallBack(), InvalidateShippableCacheCallback(), InvalidateTableSpaceCacheCallback(), InvalidateTSCacheCallBack(), libpqrcv_connect(), ListenToWorkers(), lo_read(), lo_write(), LockReassignCurrentOwner(), LockReleaseAll(), LockReleaseCurrentOwner(), LockReleaseSession(), log_child_failure(), logicalrep_partmap_invalidate_cb(), logicalrep_relmap_invalidate_cb(), MultiXactIdCreateFromMembers(), MultiXactIdExpand(), MultiXactIdGetUpdateXid(), mxid_to_string(), parallel_restore(), parseServiceInfo(), parseWorkerResponse(), pg_collation_actual_version(), pg_cryptohash_final(), pg_cryptohash_init(), pg_cryptohash_update(), pg_hmac_final(), pg_hmac_init(), pg_hmac_update(), pg_newlocale_from_collation(), pg_prepared_xact(), pg_start_backup(), pg_stop_backup(), pg_stop_backup_v2(), pg_xact_status(), pgrowlocks(), PortalErrorCleanup(), PortalHashTableDeleteAll(), PostmasterMain(), PostPrepare_Locks(), pqFunctionCall3(), pqGetline3(), PQmakeEmptyPGresult(), PQresetPoll(), PQresStatus(), PQsetClientEncoding(), PreCommit_Portals(), RecordNewMultiXact(), rel_sync_cache_publication_cb(), RelationCacheInitializePhase3(), RelationCacheInvalidate(), RelfilenodeMapInvalidateCallback(), RememberToFreeTupleDescAtEOX(), restore_toc_entry(), run_reindex_command(), run_schedule(), run_single_test(), run_vacuum_command(), sepgsql_client_auth(), SerializeUncommittedEnums(), shm_mq_counterparty_gone(), shm_mq_wait_internal(), smgrcloseall(), StandbyReleaseAllLocks(), StandbyReleaseOldLocks(), str_numth(), test_config_settings(), test_pipelined_insert(), ThereAreNoReadyPortals(), TransactionGroupUpdateXidStatus(), TransactionIdGetStatus(), TypeCacheOpcCallback(), TypeCacheRelCallback(), TypeCacheTypCallback(), uuid_generate_internal(), varstr_abbrev_convert(), varstr_cmp(), varstrfastcmp_locale(), wait_for_postmaster(), wait_for_tests(), WaitForBackgroundWorkerShutdown(), WaitForBackgroundWorkerStartup(), WaitForCommands(), WaitForParallelWorkersToAttach(), WaitForParallelWorkersToExit(), WaitForReplicationWorkerAttach(), WaitForTerminatingWorkers(), worker_spi_launch(), write_relcache_init_file(), and XLogCheckInvalidPages().

 {
     va_list     ap;
 
     va_start(ap, fmt);
     vfprintf(stdout, fmt, ap);
     fflush(stdout);
     va_end(ap);
 
     if (logfile)
     {
         va_start(ap, fmt);
         vfprintf(logfile, fmt, ap);
         va_end(ap);
     }
 }

◆ status_end()

static void status_end ( void )

static

Definition at line 248 of file pg_regress.c.

References fprintf, logfile, and generate_unaccent_rules::stdout.

Referenced by run_schedule(), and run_single_test().

 {
     fprintf(stdout, "\n");
     fflush(stdout);
     if (logfile)
         fprintf(logfile, "\n");
 }

◆ stop_postmaster()

static void stop_postmaster ( void )

static

Definition at line 260 of file pg_regress.c.

References _, Assert, bindir, buf, fprintf, MAXPGPATH, mkdtemp(), port, postmaster_running, pqsignal(), progname, psprintf(), SIG_DFL, SIGHUP, SIGPIPE, snprintf, generate_unaccent_rules::stdout, strerror, temp_instance, and UNIXSOCK_PATH.

Referenced by regression_main().

 {
     if (postmaster_running)
     {
         /* We use pg_ctl to issue the kill and wait for stop */
         char        buf[MAXPGPATH * 2];
         int         r;
 
         /* On Windows, system() seems not to force fflush, so... */
         fflush(stdout);
         fflush(stderr);
 
         snprintf(buf, sizeof(buf),
                  "\"%s%spg_ctl\" stop -D \"%s/data\" -s",
                  bindir ? bindir : "",
                  bindir ? "/" : "",
                  temp_instance);
         r = system(buf);
         if (r != 0)
         {
             fprintf(stderr, _("\n%s: could not stop postmaster: exit code was %d\n"),
                     progname, r);
             _exit(2);           /* not exit(), that could be recursive */
         }
 
         postmaster_running = false;
     }
 }

◆ string_matches_pattern()

static bool string_matches_pattern	(	const char *	str,
		const char *	pattern
	)

static

Definition at line 379 of file pg_regress.c.

Referenced by load_resultmap().

 {
     while (*str && *pattern)
     {
         if (*pattern == '.' && pattern[1] == '*')
         {
             pattern += 2;
             /* Trailing .* matches everything. */
             if (*pattern == '\0')
                 return true;
 
             /*
              * Otherwise, scan for a text position at which we can match the
              * rest of the pattern.
              */
             while (*str)
             {
                 /*
                  * Optimization to prevent most recursion: don't recurse
                  * unless first pattern char might match this text char.
                  */
                 if (*str == *pattern || *pattern == '.')
                 {
                     if (string_matches_pattern(str, pattern))
                         return true;
                 }
 
                 str++;
             }
 
             /*
              * End of text with no match.
              */
             return false;
         }
         else if (*pattern != '.' && *str != *pattern)
         {
             /*
              * Not the single-character wildcard and no explicit match? Then
              * time to quit...
              */
             return false;
         }
 
         str++;
         pattern++;
     }
 
     if (*pattern == '\0')
         return true;            /* end of pattern, so declare match */
 
     /* End of input string.  Do we have matching pattern remaining? */
     while (*pattern == '.' && pattern[1] == '*')
         pattern += 2;
     if (*pattern == '\0')
         return true;            /* end of pattern, so declare match */
 
     return false;
 }

◆ wait_for_tests()

static void wait_for_tests	(	PID_TYPE *	pids,
		int *	statuses,
		instr_time *	stoptimes,
		char **	names,
		int	num_tests
	)

static

Definition at line 1555 of file pg_regress.c.

References _, fprintf, free, i, INSTR_TIME_SET_CURRENT, INVALID_PID, pg_malloc(), PID_TYPE, status(), and strerror.

Referenced by run_schedule(), and run_single_test().

 {
     int         tests_left;
     int         i;
 
 #ifdef WIN32
     PID_TYPE   *active_pids = pg_malloc(num_tests * sizeof(PID_TYPE));
 
     memcpy(active_pids, pids, num_tests * sizeof(PID_TYPE));
 #endif
 
     tests_left = num_tests;
     while (tests_left > 0)
     {
         PID_TYPE    p;
 
 #ifndef WIN32
         int         exit_status;
 
         p = wait(&exit_status);
 
         if (p == INVALID_PID)
         {
             fprintf(stderr, _("failed to wait for subprocesses: %s\n"),
                     strerror(errno));
             exit(2);
         }
 #else
         DWORD       exit_status;
         int         r;
 
         r = WaitForMultipleObjects(tests_left, active_pids, FALSE, INFINITE);
         if (r < WAIT_OBJECT_0 || r >= WAIT_OBJECT_0 + tests_left)
         {
             fprintf(stderr, _("failed to wait for subprocesses: error code %lu\n"),
                     GetLastError());
             exit(2);
         }
         p = active_pids[r - WAIT_OBJECT_0];
         /* compact the active_pids array */
         active_pids[r - WAIT_OBJECT_0] = active_pids[tests_left - 1];
 #endif                          /* WIN32 */
 
         for (i = 0; i < num_tests; i++)
         {
             if (p == pids[i])
             {
 #ifdef WIN32
                 GetExitCodeProcess(pids[i], &exit_status);
                 CloseHandle(pids[i]);
 #endif
                 pids[i] = INVALID_PID;
                 statuses[i] = (int) exit_status;
                 INSTR_TIME_SET_CURRENT(stoptimes[i]);
                 if (names)
                     status(" %s", names[i]);
                 tests_left--;
                 break;
             }
         }
     }
 
 #ifdef WIN32
     free(active_pids);
 #endif
 }

Variable Documentation

◆ basic_diff_opts

const char* basic_diff_opts = ""

Definition at line 67 of file pg_regress.c.

Referenced by results_differ().

◆ bindir

char* bindir = PGBINDIR

Definition at line 79 of file pg_regress.c.

Referenced by psql_command(), psql_start_test(), regression_main(), and stop_postmaster().

◆ config_auth_datadir

char* config_auth_datadir = NULL

static

Definition at line 97 of file pg_regress.c.

Referenced by regression_main().

◆ dblist

_stringlist* dblist = NULL

Definition at line 75 of file pg_regress.c.

Referenced by do_start_worker(), get_database_list(), isolation_init(), isolation_start_test(), psql_init(), psql_start_test(), and rebuild_database_list().

◆ debug

bool debug = false

Definition at line 76 of file pg_regress.c.

Referenced by regression_main().

◆ difffilename

char* difffilename

static

Definition at line 103 of file pg_regress.c.

Referenced by open_result_files(), regression_main(), and results_differ().

◆ dlpath

char* dlpath = PKGLIBDIR

static

Definition at line 94 of file pg_regress.c.

Referenced by convert_sourcefiles_in(), and regression_main().

◆ encoding

char* encoding = NULL

static

Definition at line 84 of file pg_regress.c.

Referenced by create_database(), initialize_environment(), and regression_main().

◆ extra_tests

_stringlist* extra_tests = NULL

static

Definition at line 86 of file pg_regress.c.

◆ extraroles

_stringlist* extraroles = NULL

static

Definition at line 96 of file pg_regress.c.

◆ fail_count

int fail_count = 0

static

Definition at line 117 of file pg_regress.c.

Referenced by regression_main(), run_schedule(), and run_single_test().

◆ fail_ignore_count

int fail_ignore_count = 0

static

Definition at line 118 of file pg_regress.c.

Referenced by regression_main(), and run_schedule().

◆ host_platform

char* host_platform = HOST_TUPLE

Definition at line 55 of file pg_regress.c.

Referenced by load_resultmap().

◆ hostname

char* hostname = NULL

static

Definition at line 91 of file pg_regress.c.

Referenced by initialize_environment(), pqPacketSend(), and regression_main().

◆ inputdir

char* inputdir = "."

Definition at line 77 of file pg_regress.c.

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

◆ launcher

char* launcher = NULL

Definition at line 80 of file pg_regress.c.

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

◆ loadextension

_stringlist* loadextension = NULL

static

Definition at line 81 of file pg_regress.c.

◆ logfile

FILE* logfile

static

Definition at line 102 of file pg_regress.c.

Referenced by doLog(), open_result_files(), regression_main(), spawn_process(), status(), status_end(), and write_syslogger_file().

◆ logfilename

char* logfilename

static

Definition at line 101 of file pg_regress.c.

Referenced by open_result_files(), and regression_main().

◆ max_concurrent_tests

int max_concurrent_tests = 0

static

Definition at line 83 of file pg_regress.c.

Referenced by regression_main(), and run_schedule().

◆ max_connections

int max_connections = 0

static

Definition at line 82 of file pg_regress.c.

Referenced by regression_main(), and run_schedule().

◆ nolocale

bool nolocale = false

static

Definition at line 89 of file pg_regress.c.

Referenced by create_database(), initialize_environment(), and regression_main().

◆ outputdir

char* outputdir = "."

Definition at line 78 of file pg_regress.c.

Referenced by convert_sourcefiles(), convert_sourcefiles_in(), ecpg_start_test(), isolation_start_test(), open_result_files(), prepare_testtablespace_dir(), psql_start_test(), and regression_main().

◆ port

int port = -1

static

◆ port_specified_by_user

bool port_specified_by_user = false

static

Definition at line 93 of file pg_regress.c.

Referenced by regression_main().

◆ postmaster_pid

PID_TYPE postmaster_pid = INVALID_PID

static

Definition at line 113 of file pg_regress.c.

Referenced by regression_main().

◆ postmaster_running

bool postmaster_running = false

static

Definition at line 114 of file pg_regress.c.

Referenced by regression_main(), and stop_postmaster().

◆ pretty_diff_opts

const char* pretty_diff_opts = "-U3"

Definition at line 68 of file pg_regress.c.

Referenced by regression_main(), and results_differ().

◆ progname

const char* progname

static

Definition at line 100 of file pg_regress.c.

Referenced by convert_sourcefiles_in(), file_line_count(), file_size(), help(), initialize_environment(), load_resultmap(), make_directory(), open_result_files(), prepare_testtablespace_dir(), regression_main(), run_schedule(), spawn_process(), and stop_postmaster().

◆ resultmap

_resultmap* resultmap = NULL

static

Definition at line 111 of file pg_regress.c.

Referenced by load_resultmap().

◆ schedulelist

_stringlist* schedulelist = NULL

static

Definition at line 85 of file pg_regress.c.

◆ shellprog

char* shellprog = SHELLPROG

static

Definition at line 58 of file pg_regress.c.

Referenced by spawn_process().

◆ sockdir

const char* sockdir

static

Definition at line 104 of file pg_regress.c.

Referenced by initialize_environment(), and regression_main().

◆ success_count

int success_count = 0

static

Definition at line 116 of file pg_regress.c.

Referenced by regression_main(), run_schedule(), and run_single_test().

◆ temp_configs

_stringlist* temp_configs = NULL

static

Definition at line 88 of file pg_regress.c.

◆ temp_instance

char* temp_instance = NULL

static

Definition at line 87 of file pg_regress.c.

Referenced by initialize_environment(), regression_main(), and stop_postmaster().

◆ use_existing

bool use_existing = false

static

Definition at line 90 of file pg_regress.c.

Referenced by regression_main().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ MAX_PARALLEL_TESTS

◆ ULONGPID

Typedef Documentation

◆ _resultmap

Function Documentation

◆ add_stringlist_item()

◆ convert_sourcefiles()

◆ convert_sourcefiles_in()

◆ create_database()

◆ create_role()

◆ directory_exists()

◆ drop_database_if_exists()

◆ drop_role_if_exists()

◆ file_exists()

◆ file_line_count()

◆ file_size()

◆ free_stringlist()

◆ get_alternative_expectfile()

◆ get_expectfile()

◆ header()

◆ help()

◆ initialize_environment()

◆ load_resultmap()

◆ log_child_failure()

◆ make_directory()

◆ open_result_files()

◆ prepare_testtablespace_dir()

◆ psql_command()

◆ regression_main()

◆ replace_string()

◆ results_differ()

◆ run_diff()

◆ run_schedule()

◆ run_single_test()

◆ spawn_process()

◆ split_to_stringlist()

◆ status()

◆ status_end()

◆ stop_postmaster()

◆ string_matches_pattern()

◆ wait_for_tests()

Variable Documentation

◆ basic_diff_opts

◆ bindir

◆ config_auth_datadir

◆ dblist

◆ debug

◆ difffilename

◆ dlpath

◆ encoding

◆ extra_tests

◆ extraroles

◆ fail_count

◆ fail_ignore_count

◆ host_platform

◆ hostname

◆ inputdir

◆ launcher

◆ loadextension

◆ logfile

◆ logfilename

◆ max_concurrent_tests

◆ max_connections

◆ nolocale

◆ outputdir

◆ port

◆ port_specified_by_user

◆ postmaster_pid

◆ postmaster_running

◆ pretty_diff_opts

◆ progname

◆ resultmap

◆ schedulelist

◆ shellprog