pg_regress.c File Reference

#include "postgres_fe.h"
#include <ctype.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/time.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-fe.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:

Go to the source code of this file.

Data Structures
struct	_resultmap

Macros
#define	TESTNAME_WIDTH   36
#define	WAIT_TICKS_PER_SECOND   20
#define	plan(x)   emit_tap_output(PLAN, "1..%i", (x))
#define	note(...)   emit_tap_output(NOTE, __VA_ARGS__)
#define	note_detail(...)   emit_tap_output(NOTE_DETAIL, __VA_ARGS__)
#define	diag(...)   emit_tap_output(DIAG, __VA_ARGS__)
#define	note_end()   emit_tap_output(NOTE_END, "\n");
#define	bail_noatexit(...)   bail_out(true, __VA_ARGS__)
#define	bail(...)   bail_out(false, __VA_ARGS__)
#define	psql_command(database, ...)
#define	MAX_PARALLEL_TESTS   100
#define	ULONGPID(x)   (unsigned long) (x)

Typedefs
typedef struct _resultmap	_resultmap
typedef enum TAPtype	TAPtype

Enumerations
enum	TAPtype {   DIAG = 0 , BAIL , NOTE , NOTE_DETAIL ,   NOTE_END , TEST_STATUS , PLAN , NONE }

Functions
static bool	directory_exists (const char *dir)
static void	make_directory (const char *dir)
static void	test_status_print (bool ok, const char *testname, double runtime, bool parallel)
static void	test_status_ok (const char *testname, double runtime, bool parallel)
static void	test_status_failed (const char *testname, double runtime, bool parallel)
static void	bail_out (bool noatexit, const char *fmt,...) pg_attribute_printf(2
static void static void	emit_tap_output (TAPtype type, const char *fmt,...) pg_attribute_printf(2
static void static void static void	emit_tap_output_v (TAPtype type, const char *fmt, va_list argp) pg_attribute_printf(2
static void static void static void static StringInfo	psql_start_command (void)
static void	psql_add_command (StringInfo buf, const char *query,...) pg_attribute_printf(2
static void static void	psql_end_command (StringInfo buf, const char *database)
static void	unlimit_core_size (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	stop_postmaster (void)
static void	remove_temp (void)
static void	signal_remove_temp (SIGNAL_ARGS)
static const char *	make_temp_sockdir (void)
static bool	string_matches_pattern (const char *str, const char *pattern)
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 *	expecteddir = "."
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 char	portstr [16]
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 const char *	temp_sockdir
static char	sockself [MAXPGPATH]
static char	socklock [MAXPGPATH]
static StringInfo	failed_tests = NULL
static bool	in_note = false
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

Macro Definition Documentation

bail

#define bail

(

...

)

bail_out(false, __VA_ARGS__)

Definition at line 168 of file pg_regress.c.

bail_noatexit

#define bail_noatexit

(

...

)

bail_out(true, __VA_ARGS__)

Definition at line 167 of file pg_regress.c.

diag

#define diag

(

...

)

emit_tap_output(DIAG, __VA_ARGS__)

Definition at line 165 of file pg_regress.c.

MAX_PARALLEL_TESTS

#define MAX_PARALLEL_TESTS   100

note

#define note

(

...

)

emit_tap_output(NOTE, __VA_ARGS__)

Definition at line 163 of file pg_regress.c.

note_detail

#define note_detail

(

...

)

emit_tap_output(NOTE_DETAIL, __VA_ARGS__)

Definition at line 164 of file pg_regress.c.

note_end

#define note_end

(

)

emit_tap_output(NOTE_END, "\n");

Definition at line 166 of file pg_regress.c.

plan

#define plan

(

x

)

emit_tap_output(PLAN, "1..%i", (x))

Definition at line 162 of file pg_regress.c.

psql_command

#define psql_command	(		database,
			...
	)

Value:

    do { \
        StringInfo cmdbuf = psql_start_command(); \
        psql_add_command(cmdbuf, __VA_ARGS__); \
        psql_end_command(cmdbuf, database); \
    } while (0)

Definition at line 1184 of file pg_regress.c.

TESTNAME_WIDTH

#define TESTNAME_WIDTH   36

Definition at line 77 of file pg_regress.c.

ULONGPID

#define ULONGPID

(

x

)

(unsigned long) (x)

WAIT_TICKS_PER_SECOND

#define WAIT_TICKS_PER_SECOND   20

Definition at line 83 of file pg_regress.c.

Typedef Documentation

_resultmap

typedef struct _resultmap _resultmap

TAPtype

typedef enum TAPtype TAPtype

Enumeration Type Documentation

TAPtype

enum TAPtype

Enumerator
DIAG
BAIL
NOTE
NOTE_DETAIL
NOTE_END
TEST_STATUS
PLAN
NONE

Definition at line 85 of file pg_regress.c.

{
    DIAG = 0,
    BAIL,
    NOTE,
    NOTE_DETAIL,
    NOTE_END,
    TEST_STATUS,
    PLAN,
    NONE,
} TAPtype;

Function Documentation

add_stringlist_item()

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

Definition at line 198 of file pg_regress.c.

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

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

Referenced by regression_main(), and split_to_stringlist().

bail_out()

static void bail_out ( bool  noatexit, const char *  fmt,   ...  )

static

Definition at line 254 of file pg_regress.c.

{
    va_list     ap;
 
    va_start(ap, fmt);
    emit_tap_output_v(BAIL, fmt, ap);
    va_end(ap);
 
    if (noatexit)
        _exit(2);
 
    exit(2);
}

References BAIL, emit_tap_output_v(), exit(), fmt, va_end(), and va_start().

Referenced by ProcessConfigFileInternal().

create_database()

static void create_database ( const char *  dbname )

static

Definition at line 1970 of file pg_regress.c.

{
    StringInfo  buf = psql_start_command();
    _stringlist *sl;
 
    /*
     * We use template0 so that any installation-local cruft in template1 will
     * not mess up the tests.
     */
    if (encoding)
        psql_add_command(buf, "CREATE DATABASE \"%s\" TEMPLATE=template0 ENCODING='%s'%s", dbname, encoding,
                         (nolocale) ? " LOCALE='C'" : "");
    else
        psql_add_command(buf, "CREATE DATABASE \"%s\" TEMPLATE=template0%s", dbname,
                         (nolocale) ? " LOCALE='C'" : "");
    psql_add_command(buf,
                     "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);
    psql_end_command(buf, "postgres");
 
    /*
     * 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)
        psql_command(dbname, "CREATE EXTENSION IF NOT EXISTS \"%s\"", sl->str);
}

References buf, dbname, encoding, loadextension, _stringlist::next, nolocale, psql_add_command(), psql_command, psql_end_command(), psql_start_command(), and _stringlist::str.

Referenced by regression_main().

create_role()

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

static

Definition at line 2015 of file pg_regress.c.

{
    StringInfo  buf = psql_start_command();
 
    psql_add_command(buf, "CREATE ROLE \"%s\" WITH LOGIN", rolename);
    for (; granted_dbs != NULL; granted_dbs = granted_dbs->next)
    {
        psql_add_command(buf, "GRANT ALL ON DATABASE \"%s\" TO \"%s\"",
                         granted_dbs->str, rolename);
    }
    psql_end_command(buf, "postgres");
}

References buf, _stringlist::next, psql_add_command(), psql_end_command(), psql_start_command(), and _stringlist::str.

Referenced by regression_main().

directory_exists()

static bool directory_exists ( const char *  dir )

static

Definition at line 1313 of file pg_regress.c.

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

References S_ISDIR, stat::st_mode, and stat.

Referenced by open_result_files(), and regression_main().

drop_database_if_exists()

static void drop_database_if_exists ( const char *  dbname )

static

Definition at line 1959 of file pg_regress.c.

{
    StringInfo  buf = psql_start_command();
 
    /* Set warning level so we don't see chatter about nonexistent DB */
    psql_add_command(buf, "SET client_min_messages = warning");
    psql_add_command(buf, "DROP DATABASE IF EXISTS \"%s\"", dbname);
    psql_end_command(buf, "postgres");
}

References buf, dbname, psql_add_command(), psql_end_command(), and psql_start_command().

Referenced by regression_main().

drop_role_if_exists()

static void drop_role_if_exists ( const char *  rolename )

static

Definition at line 2004 of file pg_regress.c.

{
    StringInfo  buf = psql_start_command();
 
    /* Set warning level so we don't see chatter about nonexistent role */
    psql_add_command(buf, "SET client_min_messages = warning");
    psql_add_command(buf, "DROP ROLE IF EXISTS \"%s\"", rolename);
    psql_end_command(buf, "postgres");
}

References buf, psql_add_command(), psql_end_command(), and psql_start_command().

Referenced by regression_main().

emit_tap_output()

static void emit_tap_output ( TAPtype  type, const char *  fmt,   ...  )

static

Definition at line 330 of file pg_regress.c.

{
    va_list     argp;
 
    va_start(argp, fmt);
    emit_tap_output_v(type, fmt, argp);
    va_end(argp);
}

References emit_tap_output_v(), fmt, type, va_end(), and va_start().

Referenced by test_status_print().

emit_tap_output_v()

static void emit_tap_output_v ( TAPtype  type, const char *  fmt, va_list  argp  )

static

Definition at line 340 of file pg_regress.c.

{
    va_list     argp_logfile;
    FILE       *fp;
 
    /*
     * Diagnostic output will be hidden by prove unless printed to stderr. The
     * Bail message is also printed to stderr to aid debugging under a harness
     * which might otherwise not emit such an important message.
     */
    if (type == DIAG || type == BAIL)
        fp = stderr;
    else
        fp = stdout;
 
    /*
     * If we are ending a note_detail line we can avoid further processing and
     * immediately return following a newline.
     */
    if (type == NOTE_END)
    {
        in_note = false;
        fprintf(fp, "\n");
        if (logfile)
            fprintf(logfile, "\n");
        return;
    }
 
    /* Make a copy of the va args for printing to the logfile */
    va_copy(argp_logfile, argp);
 
    /*
     * Non-protocol output such as diagnostics or notes must be prefixed by a
     * '#' character. We print the Bail message like this too.
     */
    if ((type == NOTE || type == DIAG || type == BAIL)
        || (type == NOTE_DETAIL && !in_note))
    {
        fprintf(fp, "# ");
        if (logfile)
            fprintf(logfile, "# ");
    }
    vfprintf(fp, fmt, argp);
    if (logfile)
        vfprintf(logfile, fmt, argp_logfile);
 
    /*
     * If we are entering into a note with more details to follow, register
     * that the leading '#' has been printed such that subsequent details
     * aren't prefixed as well.
     */
    if (type == NOTE_DETAIL)
        in_note = true;
 
    /*
     * If this was a Bail message, the bail protocol message must go to stdout
     * separately.
     */
    if (type == BAIL)
    {
        fprintf(stdout, "Bail out!");
        if (logfile)
            fprintf(logfile, "Bail out!");
    }
 
    va_end(argp_logfile);
 
    if (type != NOTE_DETAIL)
    {
        fprintf(fp, "\n");
        if (logfile)
            fprintf(logfile, "\n");
    }
    fflush(NULL);
}

References BAIL, DIAG, fflush(), fmt, fprintf, in_note, logfile, NOTE, NOTE_DETAIL, NOTE_END, generate_unaccent_rules::stdout, type, va_end(), and vfprintf().

Referenced by bail_out(), and emit_tap_output().

file_exists()

bool file_exists

(

const char *

file

)

Definition at line 1302 of file pg_regress.c.

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

Referenced by results_differ().

file_line_count()

static int file_line_count ( const char *  file )

static

Definition at line 1280 of file pg_regress.c.

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

References diag, and strerror.

Referenced by results_differ().

file_size()

static long file_size ( const char *  file )

static

Definition at line 1259 of file pg_regress.c.

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

References diag, and strerror.

Referenced by regression_main(), and run_diff().

free_stringlist()

static void free_stringlist ( _stringlist **  listhead )

static

Definition at line 219 of file pg_regress.c.

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

References free.

Referenced by regression_main(), and run_schedule().

get_alternative_expectfile()

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

static

Definition at line 1338 of file pg_regress.c.

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

References free, i, malloc, and snprintf.

Referenced by results_differ().

get_expectfile()

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

static

Definition at line 681 of file pg_regress.c.

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

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

Referenced by results_differ().

help()

static void help ( void  )

static

Definition at line 2029 of file pg_regress.c.

{
    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(_("      --expecteddir=DIR         take expected files from DIR (default \".\")\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(_("      --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);
}

References _, printf, and progname.

Referenced by regression_main().

initialize_environment()

static void initialize_environment ( void  )

static

Definition at line 710 of file pg_regress.c.

{
    /*
     * 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);
 
    /*
     * Set variables that the test scripts may need to refer to.
     */
    setenv("PG_ABS_SRCDIR", inputdir, 1);
    setenv("PG_ABS_BUILDDIR", outputdir, 1);
    setenv("PG_LIBDIR", dlpath, 1);
    setenv("PG_DLSUFFIX", DLSUFFIX, 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 PostgreSQL/Test/Utils.pm.
         */
        unsetenv("PGCHANNELBINDING");
        /* PGCLIENTENCODING, see above */
        unsetenv("PGCONNECT_TIMEOUT");
        unsetenv("PGDATA");
        unsetenv("PGDATABASE");
        unsetenv("PGGSSDELEGATION");
        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 */
 
        if (hostname != NULL)
            setenv("PGHOST", hostname, 1);
        else
        {
            sockdir = getenv("PG_REGRESS_SOCK_DIR");
            if (!sockdir)
                sockdir = make_temp_sockdir();
            setenv("PGHOST", sockdir, 1);
        }
        unsetenv("PGHOSTADDR");
        if (port != -1)
        {
            char        s[16];
 
            snprintf(s, sizeof(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];
 
            snprintf(s, sizeof(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");
        if (!pghost)
        {
            /* Keep this bit in sync with libpq's default host location: */
            if (DEFAULT_PGSOCKET_DIR[0])
                 /* do nothing, we'll print "Unix socket" below */ ;
            else
                pghost = "localhost";   /* DefaultHost in fe-connect.c */
        }
 
        if (pghost && pgport)
            note("using postmaster on %s, port %s", pghost, pgport);
        if (pghost && !pgport)
            note("using postmaster on %s, default port", pghost);
        if (!pghost && pgport)
            note("using postmaster on Unix socket, port %s", pgport);
        if (!pghost && !pgport)
            note("using postmaster on Unix socket, default port");
    }
 
    load_resultmap();
}

References DEFAULT_PGSOCKET_DIR, dlpath, encoding, free, hostname, inputdir, load_resultmap(), make_temp_sockdir(), nolocale, note, outputdir, pghost, pgport, port, psprintf(), setenv, snprintf, sockdir, temp_instance, unsetenv, and user.

Referenced by regression_main().

load_resultmap()

static void load_resultmap ( void  )

static

Definition at line 606 of file pg_regress.c.

{
    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;
        bail("could not open file \"%s\" for reading: %s",
             buf, strerror(errno));
    }
 
    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)
        {
            bail("incorrectly formatted resultmap entry: %s", buf);
        }
        *file_type++ = '\0';
 
        platform = strchr(file_type, ':');
        if (!platform)
        {
            bail("incorrectly formatted resultmap entry: %s", buf);
        }
        *platform++ = '\0';
        expected = strchr(platform, '=');
        if (!expected)
        {
            bail("incorrectly formatted resultmap entry: %s", buf);
        }
        *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);
}

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

Referenced by initialize_environment().

log_child_failure()

static void log_child_failure ( int  exitstatus )

static

Definition at line 1622 of file pg_regress.c.

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

References diag, pg_strsignal(), WEXITSTATUS, WIFEXITED, WIFSIGNALED, and WTERMSIG.

Referenced by run_schedule(), and run_single_test().

make_directory()

static void make_directory ( const char *  dir )

static

Definition at line 1326 of file pg_regress.c.

{
    if (mkdir(dir, S_IRWXU | S_IRWXG | S_IRWXO) < 0)
    {
        bail("could not create directory \"%s\": %s", dir, strerror(errno));
    }
}

References bail, mkdir, S_IRWXG, S_IRWXO, S_IRWXU, and strerror.

Referenced by open_result_files(), and regression_main().

make_temp_sockdir()

static const char* make_temp_sockdir ( void  )

static

Definition at line 488 of file pg_regress.c.

{
    char       *template = psprintf("%s/pg_regress-XXXXXX",
                                    getenv("TMPDIR") ? getenv("TMPDIR") : "/tmp");
 
    temp_sockdir = mkdtemp(template);
    if (temp_sockdir == NULL)
    {
        bail("could not create directory \"%s\": %s",
             template, strerror(errno));
    }
 
    /* Stage file names for remove_temp().  Unsafe in a signal handler. */
    UNIXSOCK_PATH(sockself, port, temp_sockdir);
    snprintf(socklock, sizeof(socklock), "%s.lock", sockself);
 
    /* Remove the directory during clean exit. */
    atexit(remove_temp);
 
    /*
     * Remove the directory before dying to the usual signals.  Omit SIGQUIT,
     * preserving it as a quick, untidy exit.
     */
    pqsignal(SIGHUP, signal_remove_temp);
    pqsignal(SIGINT, signal_remove_temp);
    pqsignal(SIGPIPE, signal_remove_temp);
    pqsignal(SIGTERM, signal_remove_temp);
 
    return temp_sockdir;
}

References bail, mkdtemp(), port, pqsignal(), psprintf(), remove_temp(), SIGHUP, signal_remove_temp(), SIGPIPE, snprintf, socklock, sockself, strerror, temp_sockdir, and UNIXSOCK_PATH.

Referenced by initialize_environment().

open_result_files()

static void open_result_files ( void  )

static

Definition at line 1921 of file pg_regress.c.

{
    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)
    {
        bail("could not open file \"%s\" for writing: %s",
             logfilename, strerror(errno));
    }
 
    /* create the diffs file as empty */
    snprintf(file, sizeof(file), "%s/regression.diffs", outputdir);
    difffilename = pg_strdup(file);
    difffile = fopen(difffilename, "w");
    if (!difffile)
    {
        bail("could not open file \"%s\" for writing: %s",
             difffilename, strerror(errno));
    }
    /* 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);
}

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

Referenced by regression_main().

psql_add_command()

static void psql_add_command ( StringInfo  buf, const char *  query,   ...  )

static

Definition at line 1124 of file pg_regress.c.

{
    StringInfoData cmdbuf;
    const char *cmdptr;
 
    /* Add each command as a -c argument in the psql call */
    appendStringInfoString(buf, " -c \"");
 
    /* Generate the query with insertion of sprintf arguments */
    initStringInfo(&cmdbuf);
    for (;;)
    {
        va_list     args;
        int         needed;
 
        va_start(args, query);
        needed = appendStringInfoVA(&cmdbuf, query, args);
        va_end(args);
        if (needed == 0)
            break;              /* success */
        enlargeStringInfo(&cmdbuf, needed);
    }
 
    /* Now escape any shell double-quote metacharacters */
    for (cmdptr = cmdbuf.data; *cmdptr; cmdptr++)
    {
        if (strchr("\\\"$`", *cmdptr))
            appendStringInfoChar(buf, '\\');
        appendStringInfoChar(buf, *cmdptr);
    }
 
    appendStringInfoChar(buf, '"');
 
    pfree(cmdbuf.data);
}

References appendStringInfoChar(), appendStringInfoString(), appendStringInfoVA(), generate_unaccent_rules::args, buf, StringInfoData::data, enlargeStringInfo(), initStringInfo(), pfree(), va_end(), and va_start().

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

psql_end_command()

static void psql_end_command ( StringInfo  buf, const char *  database  )

static

Definition at line 1161 of file pg_regress.c.

{
    /* Add the database name --- assume it needs no extra escaping */
    appendStringInfo(buf,
                     " \"%s\"",
                     database);
 
    /* And now we can execute the shell command */
    fflush(NULL);
    if (system(buf->data) != 0)
    {
        /* psql probably already reported the error */
        bail("command failed: %s", buf->data);
    }
 
    /* Clean up */
    pfree(buf->data);
    pfree(buf);
}

References appendStringInfo(), bail, buf, fflush(), and pfree().

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

psql_start_command()

static StringInfo psql_start_command ( void  )

static

Definition at line 1112 of file pg_regress.c.

{
    StringInfo  buf = makeStringInfo();
 
    appendStringInfo(buf,
                     "\"%s%spsql\" -X -q",
                     bindir ? bindir : "",
                     bindir ? "/" : "");
    return buf;
}

References appendStringInfo(), bindir, buf, and makeStringInfo().

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

regression_main()

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

Definition at line 2079 of file pg_regress.c.

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

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

Referenced by main().

remove_temp()

static void remove_temp ( void  )

static

Definition at line 455 of file pg_regress.c.

{
    Assert(temp_sockdir);
    unlink(sockself);
    unlink(socklock);
    rmdir(temp_sockdir);
}

References Assert(), socklock, sockself, and temp_sockdir.

Referenced by make_temp_sockdir(), and signal_remove_temp().

results_differ()

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

static

Definition at line 1404 of file pg_regress.c.

{
    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)
        {
            bail("Unable to check secondary comparison files: %s",
                 strerror(errno));
        }
 
        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;
}

References bail, 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().

run_diff()

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

static

Definition at line 1372 of file pg_regress.c.

{
    int         r;
 
    fflush(NULL);
    r = system(cmd);
    if (!WIFEXITED(r) || WEXITSTATUS(r) > 1)
    {
        bail("diff command failed with status %d: %s", r, cmd);
    }
#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)
    {
        bail("diff command not found: %s", cmd);
    }
#endif
 
    return WEXITSTATUS(r);
}

References bail, fflush(), file_size(), filename, WEXITSTATUS, and WIFEXITED.

Referenced by results_differ().

run_schedule()

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

static

Definition at line 1645 of file pg_regress.c.

{
#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];
    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)
    {
        bail("could not open file \"%s\" for reading: %s",
             schedule, strerror(errno));
    }
 
    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
        {
            bail("syntax error in schedule file \"%s\" line %d: %s",
                 schedule, line_num, scbuf);
        }
 
        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)
                    {
                        bail("too many parallel tests (more than %d) in schedule file \"%s\" line %d: %s",
                             MAX_PARALLEL_TESTS, schedule, line_num, scbuf);
                    }
                    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)
        {
            bail("syntax error in schedule file \"%s\" line %d: %s",
                 schedule, line_num, scbuf);
        }
 
        if (num_tests == 1)
        {
            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)
        {
            bail("too many parallel tests (more than %d) in schedule file \"%s\" line %d: %s",
                 max_concurrent_tests, schedule, line_num, scbuf);
        }
        else if (max_connections > 0 && max_connections < num_tests)
        {
            int         oldest = 0;
 
            note_detail("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);
            note_end();
        }
        else
        {
            note_detail("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);
            note_end();
        }
 
        /* Check results for all tests */
        for (i = 0; i < num_tests; i++)
        {
            _stringlist *rl,
                       *el,
                       *tl;
            bool        differ = false;
 
            INSTR_TIME_SUBTRACT(stoptimes[i], starttimes[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)
                {
                    diag("tag: %s", tl->str);
                }
                differ |= newdiff;
            }
 
            if (statuses[i] != 0)
            {
                test_status_failed(tests[i], INSTR_TIME_GET_MILLISEC(stoptimes[i]), (num_tests > 1));
                log_child_failure(statuses[i]);
            }
            else
            {
                if (differ)
                {
                    test_status_failed(tests[i], INSTR_TIME_GET_MILLISEC(stoptimes[i]), (num_tests > 1));
                }
                else
                {
                    test_status_ok(tests[i], INSTR_TIME_GET_MILLISEC(stoptimes[i]), (num_tests > 1));
                }
            }
        }
 
        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]);
        }
    }
 
    fclose(scf);
}

References bail, diag, 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, note_detail, note_end, pg_free(), pg_strdup(), PID_TYPE, results_differ(), _stringlist::str, strerror, test(), test_status_failed(), test_status_ok(), and wait_for_tests().

Referenced by regression_main().

run_single_test()

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

static

Definition at line 1854 of file pg_regress.c.

{
    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;
 
    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)
        {
            diag("tag: %s", tl->str);
        }
        differ |= newdiff;
    }
 
    INSTR_TIME_SUBTRACT(stoptime, starttime);
 
    if (exit_status != 0)
    {
        test_status_failed(test, INSTR_TIME_GET_MILLISEC(stoptime), false);
        log_child_failure(exit_status);
    }
    else
    {
        if (differ)
        {
            test_status_failed(test, INSTR_TIME_GET_MILLISEC(stoptime), false);
        }
        else
        {
            test_status_ok(test, INSTR_TIME_GET_MILLISEC(stoptime), false);
        }
    }
}

References diag, INSTR_TIME_GET_MILLISEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, log_child_failure(), _stringlist::next, PID_TYPE, results_differ(), _stringlist::str, test(), test_status_failed(), test_status_ok(), and wait_for_tests().

Referenced by regression_main().

signal_remove_temp()

static void signal_remove_temp ( SIGNAL_ARGS  )

static

Definition at line 467 of file pg_regress.c.

{
    remove_temp();
 
    pqsignal(postgres_signal_arg, SIG_DFL);
    raise(postgres_signal_arg);
}

References pqsignal(), remove_temp(), and SIG_DFL.

Referenced by make_temp_sockdir().

spawn_process()

PID_TYPE spawn_process

(

const char *

cmdline

)

Definition at line 1197 of file pg_regress.c.

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

References bail, bail_noatexit, exit(), fflush(), psprintf(), shellprog, and strerror.

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

split_to_stringlist()

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

static

Definition at line 234 of file pg_regress.c.

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

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

Referenced by regression_main().

stop_postmaster()

static void stop_postmaster ( void  )

static

Definition at line 420 of file pg_regress.c.

{
    if (postmaster_running)
    {
        /* We use pg_ctl to issue the kill and wait for stop */
        char        buf[MAXPGPATH * 2];
        int         r;
 
        snprintf(buf, sizeof(buf),
                 "\"%s%spg_ctl\" stop -D \"%s/data\" -s",
                 bindir ? bindir : "",
                 bindir ? "/" : "",
                 temp_instance);
        fflush(NULL);
        r = system(buf);
        if (r != 0)
        {
            /* Not using the normal bail() as we want _exit */
            bail_noatexit(_("could not stop postmaster: exit code was %d"), r);
        }
 
        postmaster_running = false;
    }
}

References _, bail_noatexit, bindir, buf, fflush(), MAXPGPATH, postmaster_running, snprintf, and temp_instance.

Referenced by regression_main().

string_matches_pattern()

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

static

Definition at line 532 of file pg_regress.c.

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

References generate_unaccent_rules::str.

Referenced by load_resultmap().

test_status_failed()

static void test_status_failed ( const char *  testname, double  runtime, bool  parallel  )

static

Definition at line 310 of file pg_regress.c.

{
    /*
     * Save failed tests in a buffer such that we can print a summary at the
     * end with diag() to ensure it's shown even under test harnesses.
     */
    if (!failed_tests)
        failed_tests = makeStringInfo();
    else
        appendStringInfoChar(failed_tests, ',');
 
    appendStringInfo(failed_tests, " %s", testname);
 
    fail_count++;
 
    test_status_print(false, testname, runtime, parallel);
}

References appendStringInfo(), appendStringInfoChar(), fail_count, failed_tests, makeStringInfo(), and test_status_print().

Referenced by run_schedule(), and run_single_test().

test_status_ok()

static void test_status_ok ( const char *  testname, double  runtime, bool  parallel  )

static

Definition at line 302 of file pg_regress.c.

{
    success_count++;
 
    test_status_print(true, testname, runtime, parallel);
}

References success_count, and test_status_print().

Referenced by run_schedule(), and run_single_test().

test_status_print()

static void test_status_print ( bool  ok, const char *  testname, double  runtime, bool  parallel  )

static

Definition at line 279 of file pg_regress.c.

{
    int         testnumber = fail_count + success_count;
 
    /*
     * Testnumbers are padded to 5 characters to ensure that testnames align
     * vertically (assuming at most 9999 tests).  Testnames are prefixed with
     * a leading character to indicate being run in parallel or not. A leading
     * '+' indicates a parallel test, '-' indicates a single test.
     */
    emit_tap_output(TEST_STATUS, "%sok %-5i%*s %c %-*s %8.0f ms",
                    (ok ? "" : "not "),
                    testnumber,
    /* If ok, indent with four spaces matching "not " */
                    (ok ? (int) strlen("not ") : 0), "",
    /* Prefix a parallel test '+' and a single test with '-' */
                    (parallel ? '+' : '-'),
    /* Testnames are padded to align runtimes */
                    TESTNAME_WIDTH, testname,
                    runtime);
}

References emit_tap_output(), fail_count, success_count, TEST_STATUS, and TESTNAME_WIDTH.

Referenced by test_status_failed(), and test_status_ok().

unlimit_core_size()

static void unlimit_core_size ( void  )

static

Definition at line 175 of file pg_regress.c.

{
    struct rlimit lim;
 
    getrlimit(RLIMIT_CORE, &lim);
    if (lim.rlim_max == 0)
    {
        diag("could not set core size: disallowed by hard limit");
        return;
    }
    else if (lim.rlim_max == RLIM_INFINITY || lim.rlim_cur < lim.rlim_max)
    {
        lim.rlim_cur = lim.rlim_max;
        setrlimit(RLIMIT_CORE, &lim);
    }
}

References diag.

Referenced by regression_main().

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 1553 of file pg_regress.c.

{
    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)
        {
            bail("failed to wait for subprocesses: %s", strerror(errno));
        }
#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)
        {
            bail("failed to wait for subprocesses: error code %lu",
                 GetLastError());
        }
        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)
                    note_detail(" %s", names[i]);
                tests_left--;
                break;
            }
        }
    }
 
#ifdef WIN32
    free(active_pids);
#endif
}

References bail, free, i, INSTR_TIME_SET_CURRENT, INVALID_PID, note_detail, pg_malloc(), PID_TYPE, and strerror.

Referenced by run_schedule(), and run_single_test().

Variable Documentation

basic_diff_opts

const char* basic_diff_opts = ""

Definition at line 65 of file pg_regress.c.

Referenced by results_differ().

bindir

char* bindir = PGBINDIR

Definition at line 103 of file pg_regress.c.

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

config_auth_datadir

char* config_auth_datadir = NULL

static

Definition at line 122 of file pg_regress.c.

Referenced by regression_main().

dblist

_stringlist* dblist = NULL

Definition at line 98 of file pg_regress.c.

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

debug

bool debug = false

Definition at line 99 of file pg_regress.c.

Referenced by regression_main().

difffilename

char* difffilename

static

Definition at line 128 of file pg_regress.c.

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

dlpath

char* dlpath = PKGLIBDIR

static

Definition at line 119 of file pg_regress.c.

Referenced by initialize_environment(), and regression_main().

encoding

char* encoding = NULL

static

Definition at line 108 of file pg_regress.c.

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

expecteddir

char* expecteddir = "."

Definition at line 102 of file pg_regress.c.

Referenced by ecpg_start_test(), and regression_main().

extra_tests

_stringlist* extra_tests = NULL

static

Definition at line 110 of file pg_regress.c.

Referenced by regression_main().

extraroles

_stringlist* extraroles = NULL

static

Definition at line 121 of file pg_regress.c.

Referenced by regression_main().

fail_count

int fail_count = 0

static

Definition at line 142 of file pg_regress.c.

Referenced by regression_main(), test_status_failed(), and test_status_print().

failed_tests

StringInfo failed_tests = NULL

static

Definition at line 133 of file pg_regress.c.

Referenced by test_status_failed().

host_platform

char* host_platform = HOST_TUPLE

Definition at line 53 of file pg_regress.c.

Referenced by load_resultmap().

hostname

char* hostname = NULL

static

Definition at line 115 of file pg_regress.c.

Referenced by check_hostname(), initialize_environment(), passwordFromFile(), pg_getaddrinfo_all(), and regression_main().

in_note

bool in_note = false

static

Definition at line 134 of file pg_regress.c.

Referenced by emit_tap_output_v().

inputdir

char* inputdir = "."

Definition at line 100 of file pg_regress.c.

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

launcher

char* launcher = NULL

Definition at line 104 of file pg_regress.c.

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

loadextension

_stringlist* loadextension = NULL

static

Definition at line 105 of file pg_regress.c.

Referenced by create_database(), and regression_main().

logfile

FILE* logfile

static

Definition at line 127 of file pg_regress.c.

Referenced by doLog(), emit_tap_output_v(), open_result_files(), regression_main(), and write_syslogger_file().

logfilename

char* logfilename

static

Definition at line 126 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 107 of file pg_regress.c.

Referenced by regression_main(), and run_schedule().

max_connections

int max_connections = 0

static

Definition at line 106 of file pg_regress.c.

Referenced by regression_main(), and run_schedule().

nolocale

bool nolocale = false

static

Definition at line 113 of file pg_regress.c.

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

outputdir

char* outputdir = "."

Definition at line 101 of file pg_regress.c.

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

port

int port = -1

static

Definition at line 116 of file pg_regress.c.

Referenced by auth_delay_checks(), auth_failed(), auth_peer(), BackendInitialize(), BackendRun(), BackendStartup(), be_gssapi_get_auth(), be_gssapi_get_delegation(), be_gssapi_get_enc(), be_gssapi_get_princ(), be_gssapi_read(), be_gssapi_write(), be_tls_close(), be_tls_get_certificate_hash(), be_tls_get_cipher(), be_tls_get_cipher_bits(), be_tls_get_peer_issuer_name(), be_tls_get_peer_serial(), be_tls_get_peer_subject_name(), be_tls_get_version(), be_tls_open_server(), be_tls_read(), be_tls_write(), check_hba(), check_hostname(), CheckMD5Auth(), CheckPasswordAuth(), CheckPWChallengeAuth(), CheckRADIUSAuth(), CheckSASLAuth(), ClientAuthentication(), ConnCreate(), ConnFree(), conninfo_uri_parse_options(), do_connect(), ECPGconnect(), hba_getauthmethod(), ident_inet(), inet_client_addr(), inet_client_port(), inet_server_addr(), inet_server_port(), initialize_environment(), log_disconnections(), main(), make_temp_sockdir(), my_SSL_set_fd(), passwordFromFile(), PerformAuthentication(), PerformRadiusTransaction(), pq_getkeepalivescount(), pq_getkeepalivesidle(), pq_getkeepalivesinterval(), pq_gettcpusertimeout(), pq_setkeepalivescount(), pq_setkeepalivesidle(), pq_setkeepalivesinterval(), pq_settcpusertimeout(), process_startup_options(), ProcessStartupPacket(), read_or_wait(), regression_main(), report_fork_failure_to_client(), scram_get_mechanisms(), scram_init(), secure_close(), secure_open_gssapi(), secure_open_server(), secure_raw_read(), secure_raw_write(), secure_read(), secure_write(), sepgsql_client_auth(), ServerLoop(), set_authn_id(), and StreamConnection().

port_specified_by_user

bool port_specified_by_user = false

static

Definition at line 118 of file pg_regress.c.

Referenced by regression_main().

portstr

char portstr[16]

static

Definition at line 117 of file pg_regress.c.

Referenced by PerformRadiusTransaction(), PQconnectPoll(), and regression_main().

postmaster_pid

PID_TYPE postmaster_pid = INVALID_PID

static

Definition at line 138 of file pg_regress.c.

Referenced by regression_main().

postmaster_running

bool postmaster_running = false

static

Definition at line 139 of file pg_regress.c.

Referenced by regression_main(), and stop_postmaster().

pretty_diff_opts

const char* pretty_diff_opts = "-U3"

Definition at line 66 of file pg_regress.c.

Referenced by regression_main(), and results_differ().

progname

const char* progname

static

Definition at line 125 of file pg_regress.c.

Referenced by help(), and regression_main().

resultmap

_resultmap* resultmap = NULL

static

Definition at line 136 of file pg_regress.c.

Referenced by get_expectfile(), and load_resultmap().

schedulelist

_stringlist* schedulelist = NULL

static

Definition at line 109 of file pg_regress.c.

Referenced by regression_main().

shellprog

char* shellprog = SHELLPROG

static

Definition at line 56 of file pg_regress.c.

Referenced by spawn_process().

sockdir

const char* sockdir

static

Definition at line 129 of file pg_regress.c.

Referenced by initialize_environment(), and regression_main().

socklock

char socklock[MAXPGPATH]

static

Definition at line 132 of file pg_regress.c.

Referenced by make_temp_sockdir(), and remove_temp().

sockself

char sockself[MAXPGPATH]

static

Definition at line 131 of file pg_regress.c.

Referenced by make_temp_sockdir(), and remove_temp().

success_count

int success_count = 0

static

Definition at line 141 of file pg_regress.c.

Referenced by regression_main(), test_status_ok(), and test_status_print().

temp_configs

_stringlist* temp_configs = NULL

static

Definition at line 112 of file pg_regress.c.

Referenced by regression_main().

temp_instance

char* temp_instance = NULL

static

Definition at line 111 of file pg_regress.c.

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

temp_sockdir

const char* temp_sockdir

static

Definition at line 130 of file pg_regress.c.

Referenced by make_temp_sockdir(), and remove_temp().

use_existing

bool use_existing = false

static

Definition at line 114 of file pg_regress.c.

Referenced by regression_main().

user

char* user = NULL

static

Definition at line 120 of file pg_regress.c.

Referenced by _becomeUser(), _doSetSessionAuth(), check_conn_params(), connect_pg_server(), conninfo_uri_parse_options(), create_foreign_modify(), do_connect(), ECPGconnect(), exec_command_password(), GetConnection(), initialize_environment(), LockGXact(), main(), make_new_connection(), pgfdw_security_check(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresBeginDirectModify(), postgresBeginForeignScan(), postgresExecForeignTruncate(), postgresGetAnalyzeInfoForForeignTable(), PQencryptPassword(), PQencryptPasswordConn(), regression_main(), ShowUsage(), and UserMappingPasswordRequired().