Consistently use "superuser" instead of "super user"

[pgsql.git] / src / test / regress / pg_regress.c

/*-------------------------------------------------------------------------
 *
 * pg_regress --- regression test driver
 *
 * This is a C implementation of the previous shell script for running
 * the regression tests, and should be mostly compatible with it.
 * Initial author of C translation: Magnus Hagander
 *
 * This code is released under the terms of the PostgreSQL License.
 *
 * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * src/test/regress/pg_regress.c
 *
 *-------------------------------------------------------------------------
 */

#include "postgres_fe.h"

#include <ctype.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <signal.h>
#include <unistd.h>

#ifdef HAVE_SYS_RESOURCE_H
#include <sys/time.h>
#include <sys/resource.h>
#endif

#include "common/logging.h"
#include "common/restricted_token.h"
#include "common/string.h"
#include "common/username.h"
#include "getopt_long.h"
#include "lib/stringinfo.h"
#include "libpq/pqcomm.h"               /* needed for UNIXSOCK_PATH() */
#include "pg_config_paths.h"
#include "pg_regress.h"
#include "portability/instr_time.h"

/* for resultmap we need a list of pairs of strings */
typedef struct _resultmap
{
        char       *test;
        char       *type;
        char       *resultfile;
        struct _resultmap *next;
} _resultmap;

/*
 * Values obtained from Makefile.
 */
char       *host_platform = HOST_TUPLE;

#ifndef WIN32                                   /* not used in WIN32 case */
static char *shellprog = SHELLPROG;
#endif

/*
 * On Windows we use -w in diff switches to avoid problems with inconsistent
 * newline representation.  The actual result files will generally have
 * Windows-style newlines, but the comparison files might or might not.
 */
#ifndef WIN32
const char *basic_diff_opts = "";
const char *pretty_diff_opts = "-U3";
#else
const char *basic_diff_opts = "-w";
const char *pretty_diff_opts = "-w -U3";
#endif

/* options settable from command line */
_stringlist *dblist = NULL;
bool            debug = false;
char       *inputdir = ".";
char       *outputdir = ".";
char       *bindir = PGBINDIR;
char       *launcher = NULL;
static _stringlist *loadextension = NULL;
static int      max_connections = 0;
static int      max_concurrent_tests = 0;
static char *encoding = NULL;
static _stringlist *schedulelist = NULL;
static _stringlist *extra_tests = NULL;
static char *temp_instance = NULL;
static _stringlist *temp_configs = NULL;
static bool nolocale = false;
static bool use_existing = false;
static char *hostname = NULL;
static int      port = -1;
static bool port_specified_by_user = false;
static char *dlpath = PKGLIBDIR;
static char *user = NULL;
static _stringlist *extraroles = NULL;
static char *config_auth_datadir = NULL;

/* internal variables */
static const char *progname;
static char *logfilename;
static FILE *logfile;
static char *difffilename;
static const char *sockdir;
#ifdef HAVE_UNIX_SOCKETS
static const char *temp_sockdir;
static char sockself[MAXPGPATH];
static char socklock[MAXPGPATH];
#endif

static _resultmap *resultmap = NULL;

static PID_TYPE postmaster_pid = INVALID_PID;
static bool postmaster_running = false;

static int      success_count = 0;
static int      fail_count = 0;
static int      fail_ignore_count = 0;

static bool directory_exists(const char *dir);
static void make_directory(const char *dir);

static void header(const char *fmt,...) pg_attribute_printf(1, 2);
static void status(const char *fmt,...) pg_attribute_printf(1, 2);
static void psql_command(const char *database, const char *query,...) pg_attribute_printf(2, 3);

/*
 * allow core files if possible.
 */
#if defined(HAVE_GETRLIMIT) && defined(RLIMIT_CORE)
static void
unlimit_core_size(void)
{
        struct rlimit lim;

        getrlimit(RLIMIT_CORE, &lim);
        if (lim.rlim_max == 0)
        {
                fprintf(stderr,
                                _("%s: could not set core size: disallowed by hard limit\n"),
                                progname);
                return;
        }
        else if (lim.rlim_max == RLIM_INFINITY || lim.rlim_cur < lim.rlim_max)
        {
                lim.rlim_cur = lim.rlim_max;
                setrlimit(RLIMIT_CORE, &lim);
        }
}
#endif


/*
 * Add an item at the end of a stringlist.
 */
void
add_stringlist_item(_stringlist **listhead, const char *str)
{
        _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;
        }
}

/*
 * Free a stringlist.
 */
static void
free_stringlist(_stringlist **listhead)
{
        if (listhead == NULL || *listhead == NULL)
                return;
        if ((*listhead)->next != NULL)
                free_stringlist(&((*listhead)->next));
        free((*listhead)->str);
        free(*listhead);
        *listhead = NULL;
}

/*
 * Split a delimited string into a stringlist
 */
static void
split_to_stringlist(const char *s, const char *delim, _stringlist **listhead)
{
        char       *sc = pg_strdup(s);
        char       *token = strtok(sc, delim);

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

/*
 * Print a progress banner on stdout.
 */
static void
header(const char *fmt,...)
{
        char            tmp[64];
        va_list         ap;

        va_start(ap, fmt);
        vsnprintf(tmp, sizeof(tmp), fmt, ap);
        va_end(ap);

        fprintf(stdout, "============== %-38s ==============\n", tmp);
        fflush(stdout);
}

/*
 * Print "doing something ..." --- supplied text should not end with newline
 */
static void
status(const char *fmt,...)
{
        va_list         ap;

        va_start(ap, fmt);
        vfprintf(stdout, fmt, ap);
        fflush(stdout);
        va_end(ap);

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

/*
 * Done "doing something ..."
 */
static void
status_end(void)
{
        fprintf(stdout, "\n");
        fflush(stdout);
        if (logfile)
                fprintf(logfile, "\n");
}

/*
 * shut down temp postmaster
 */
static void
stop_postmaster(void)
{
        if (postmaster_running)
        {
                /* We use pg_ctl to issue the kill and wait for stop */
                char            buf[MAXPGPATH * 2];
                int                     r;

                /* On Windows, system() seems not to force fflush, so... */
                fflush(stdout);
                fflush(stderr);

                snprintf(buf, sizeof(buf),
                                 "\"%s%spg_ctl\" stop -D \"%s/data\" -s",
                                 bindir ? bindir : "",
                                 bindir ? "/" : "",
                                 temp_instance);
                r = system(buf);
                if (r != 0)
                {
                        fprintf(stderr, _("\n%s: could not stop postmaster: exit code was %d\n"),
                                        progname, r);
                        _exit(2);                       /* not exit(), that could be recursive */
                }

                postmaster_running = false;
        }
}

#ifdef HAVE_UNIX_SOCKETS
/*
 * Remove the socket temporary directory.  pg_regress never waits for a
 * postmaster exit, so it is indeterminate whether the postmaster has yet to
 * unlink the socket and lock file.  Unlink them here so we can proceed to
 * remove the directory.  Ignore errors; leaking a temporary directory is
 * unimportant.  This can run from a signal handler.  The code is not
 * acceptable in a Windows signal handler (see initdb.c:trapsig()), but
 * on Windows, pg_regress does not use Unix sockets by default.
 */
static void
remove_temp(void)
{
        Assert(temp_sockdir);
        unlink(sockself);
        unlink(socklock);
        rmdir(temp_sockdir);
}

/*
 * Signal handler that calls remove_temp() and reraises the signal.
 */
static void
signal_remove_temp(int signum)
{
        remove_temp();

        pqsignal(signum, SIG_DFL);
        raise(signum);
}

/*
 * Create a temporary directory suitable for the server's Unix-domain socket.
 * The directory will have mode 0700 or stricter, so no other OS user can open
 * our socket to exploit our use of trust authentication.  Most systems
 * constrain the length of socket paths well below _POSIX_PATH_MAX, so we
 * place the directory under /tmp rather than relative to the possibly-deep
 * current working directory.
 *
 * Compared to using the compiled-in DEFAULT_PGSOCKET_DIR, this also permits
 * testing to work in builds that relocate it to a directory not writable to
 * the build/test user.
 */
static const char *
make_temp_sockdir(void)
{
        char       *template = psprintf("%s/pg_regress-XXXXXX",
                                                                        getenv("TMPDIR") ? getenv("TMPDIR") : "/tmp");

        temp_sockdir = mkdtemp(template);
        if (temp_sockdir == NULL)
        {
                fprintf(stderr, _("%s: could not create directory \"%s\": %s\n"),
                                progname, template, strerror(errno));
                exit(2);
        }

        /* 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;
}
#endif                                                  /* HAVE_UNIX_SOCKETS */

/*
 * Check whether string matches pattern
 *
 * In the original shell script, this function was implemented using expr(1),
 * which provides basic regular expressions restricted to match starting at
 * the string start (in conventional regex terms, there's an implicit "^"
 * at the start of the pattern --- but no implicit "$" at the end).
 *
 * For now, we only support "." and ".*" as non-literal metacharacters,
 * because that's all that anyone has found use for in resultmap.  This
 * code could be extended if more functionality is needed.
 */
static bool
string_matches_pattern(const char *str, const char *pattern)
{
        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;
}

/*
 * Replace all occurrences of "replace" in "string" with "replacement".
 * The StringInfo will be suitably enlarged if necessary.
 *
 * Note: this is optimized on the assumption that most calls will find
 * no more than one occurrence of "replace", and quite likely none.
 */
void
replace_string(StringInfo string, const char *replace, const char *replacement)
{
        int                     pos = 0;
        char       *ptr;

        while ((ptr = strstr(string->data + pos, replace)) != NULL)
        {
                /* Must copy the remainder of the string out of the StringInfo */
                char       *suffix = pg_strdup(ptr + strlen(replace));

                /* Truncate StringInfo at start of found string ... */
                string->len = ptr - string->data;
                /* ... and append the replacement (this restores the trailing '\0') */
                appendStringInfoString(string, replacement);
                /* Next search should start after the replacement */
                pos = string->len;
                /* Put back the remainder of the string */
                appendStringInfoString(string, suffix);
                free(suffix);
        }
}

/*
 * Convert *.source found in the "source" directory, replacing certain tokens
 * in the file contents with their intended values, and put the resulting files
 * in the "dest" directory, replacing the ".source" prefix in their names with
 * the given suffix.
 */
static void
convert_sourcefiles_in(const char *source_subdir, const char *dest_dir, const char *dest_subdir, const char *suffix)
{
        char            testtablespace[MAXPGPATH];
        char            indir[MAXPGPATH];
        char            outdir_sub[MAXPGPATH];
        char      **name;
        char      **names;
        int                     count = 0;

        snprintf(indir, MAXPGPATH, "%s/%s", inputdir, source_subdir);

        /* Check that indir actually exists and is a directory */
        if (!directory_exists(indir))
        {
                /*
                 * No warning, to avoid noise in tests that do not have these
                 * directories; for example, ecpg, contrib and src/pl.
                 */
                return;
        }

        names = pgfnames(indir);
        if (!names)
                /* Error logged in pgfnames */
                exit(2);

        /* Create the "dest" subdirectory if not present */
        snprintf(outdir_sub, MAXPGPATH, "%s/%s", dest_dir, dest_subdir);
        if (!directory_exists(outdir_sub))
                make_directory(outdir_sub);

        /* We might need to replace @testtablespace@ */
        snprintf(testtablespace, MAXPGPATH, "%s/testtablespace", outputdir);

        /* finally loop on each file and do the replacement */
        for (name = names; *name; name++)
        {
                char            srcfile[MAXPGPATH];
                char            destfile[MAXPGPATH];
                char            prefix[MAXPGPATH];
                FILE       *infile,
                                   *outfile;
                StringInfoData line;

                /* reject filenames not finishing in ".source" */
                if (strlen(*name) < 8)
                        continue;
                if (strcmp(*name + strlen(*name) - 7, ".source") != 0)
                        continue;

                count++;

                /* build the full actual paths to open */
                snprintf(prefix, strlen(*name) - 6, "%s", *name);
                snprintf(srcfile, MAXPGPATH, "%s/%s", indir, *name);
                snprintf(destfile, MAXPGPATH, "%s/%s/%s.%s", dest_dir, dest_subdir,
                                 prefix, suffix);

                infile = fopen(srcfile, "r");
                if (!infile)
                {
                        fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
                                        progname, srcfile, strerror(errno));
                        exit(2);
                }
                outfile = fopen(destfile, "w");
                if (!outfile)
                {
                        fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
                                        progname, destfile, strerror(errno));
                        exit(2);
                }

                initStringInfo(&line);

                while (pg_get_line_buf(infile, &line))
                {
                        replace_string(&line, "@abs_srcdir@", inputdir);
                        replace_string(&line, "@abs_builddir@", outputdir);
                        replace_string(&line, "@testtablespace@", testtablespace);
                        replace_string(&line, "@libdir@", dlpath);
                        replace_string(&line, "@DLSUFFIX@", DLSUFFIX);
                        fputs(line.data, outfile);
                }

                pfree(line.data);
                fclose(infile);
                fclose(outfile);
        }

        /*
         * If we didn't process any files, complain because it probably means
         * somebody neglected to pass the needed --inputdir argument.
         */
        if (count <= 0)
        {
                fprintf(stderr, _("%s: no *.source files found in \"%s\"\n"),
                                progname, indir);
                exit(2);
        }

        pgfnames_cleanup(names);
}

/* Create the .sql and .out files from the .source files, if any */
static void
convert_sourcefiles(void)
{
        convert_sourcefiles_in("input", outputdir, "sql", "sql");
        convert_sourcefiles_in("output", outputdir, "expected", "out");
}

/*
 * Clean out the test tablespace dir, or create it if it doesn't exist.
 *
 * On Windows, doing this cleanup here makes it possible to run the
 * regression tests under a Windows administrative user account with the
 * restricted token obtained when starting pg_regress.
 */
static void
prepare_testtablespace_dir(void)
{
        char            testtablespace[MAXPGPATH];

        snprintf(testtablespace, MAXPGPATH, "%s/testtablespace", outputdir);

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

/*
 * Scan resultmap file to find which platform-specific expected files to use.
 *
 * The format of each line of the file is
 *                 testname/hostplatformpattern=substitutefile
 * where the hostplatformpattern is evaluated per the rules of expr(1),
 * namely, it is a standard regular expression with an implicit ^ at the start.
 * (We currently support only a very limited subset of regular expressions,
 * see string_matches_pattern() above.)  What hostplatformpattern will be
 * matched against is the config.guess output.  (In the shell-script version,
 * we also provided an indication of whether gcc or another compiler was in
 * use, but that facility isn't used anymore.)
 */
static void
load_resultmap(void)
{
        char            buf[MAXPGPATH];
        FILE       *f;

        /* scan the file ... */
        snprintf(buf, sizeof(buf), "%s/resultmap", inputdir);
        f = fopen(buf, "r");
        if (!f)
        {
                /* OK if it doesn't exist, else complain */
                if (errno == ENOENT)
                        return;
                fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
                                progname, buf, strerror(errno));
                exit(2);
        }

        while (fgets(buf, sizeof(buf), f))
        {
                char       *platform;
                char       *file_type;
                char       *expected;
                int                     i;

                /* strip trailing whitespace, especially the newline */
                i = strlen(buf);
                while (i > 0 && isspace((unsigned char) buf[i - 1]))
                        buf[--i] = '\0';

                /* parse out the line fields */
                file_type = strchr(buf, ':');
                if (!file_type)
                {
                        fprintf(stderr, _("incorrectly formatted resultmap entry: %s\n"),
                                        buf);
                        exit(2);
                }
                *file_type++ = '\0';

                platform = strchr(file_type, ':');
                if (!platform)
                {
                        fprintf(stderr, _("incorrectly formatted resultmap entry: %s\n"),
                                        buf);
                        exit(2);
                }
                *platform++ = '\0';
                expected = strchr(platform, '=');
                if (!expected)
                {
                        fprintf(stderr, _("incorrectly formatted resultmap entry: %s\n"),
                                        buf);
                        exit(2);
                }
                *expected++ = '\0';

                /*
                 * if it's for current platform, save it in resultmap list. Note: by
                 * adding at the front of the list, we ensure that in ambiguous cases,
                 * the last match in the resultmap file is used. This mimics the
                 * behavior of the old shell script.
                 */
                if (string_matches_pattern(host_platform, platform))
                {
                        _resultmap *entry = pg_malloc(sizeof(_resultmap));

                        entry->test = pg_strdup(buf);
                        entry->type = pg_strdup(file_type);
                        entry->resultfile = pg_strdup(expected);
                        entry->next = resultmap;
                        resultmap = entry;
                }
        }
        fclose(f);
}

/*
 * Check in resultmap if we should be looking at a different file
 */
static
const char *
get_expectfile(const char *testname, const char *file)
{
        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;
}

/*
 * Prepare environment variables for running regression tests
 */
static void
initialize_environment(void)
{
        /*
         * Set default application_name.  (The test_start_function may choose to
         * override this, but if it doesn't, we have something useful in place.)
         */
        setenv("PGAPPNAME", "pg_regress", 1);

        if (nolocale)
        {
                /*
                 * Clear out any non-C locale settings
                 */
                unsetenv("LC_COLLATE");
                unsetenv("LC_CTYPE");
                unsetenv("LC_MONETARY");
                unsetenv("LC_NUMERIC");
                unsetenv("LC_TIME");
                unsetenv("LANG");

                /*
                 * Most platforms have adopted the POSIX locale as their
                 * implementation-defined default locale.  Exceptions include native
                 * Windows, macOS with --enable-nls, and Cygwin with --enable-nls.
                 * (Use of --enable-nls matters because libintl replaces setlocale().)
                 * Also, PostgreSQL does not support macOS with locale environment
                 * variables unset; see PostmasterMain().
                 */
#if defined(WIN32) || defined(__CYGWIN__) || defined(__darwin__)
                setenv("LANG", "C", 1);
#endif
        }

        /*
         * Set translation-related settings to English; otherwise psql will
         * produce translated messages and produce diffs.  (XXX If we ever support
         * translation of pg_regress, this needs to be moved elsewhere, where psql
         * is actually called.)
         */
        unsetenv("LANGUAGE");
        unsetenv("LC_ALL");
        setenv("LC_MESSAGES", "C", 1);

        /*
         * Set encoding as requested
         */
        if (encoding)
                setenv("PGCLIENTENCODING", encoding, 1);
        else
                unsetenv("PGCLIENTENCODING");

        /*
         * Set timezone and datestyle for datetime-related tests
         */
        setenv("PGTZ", "PST8PDT", 1);
        setenv("PGDATESTYLE", "Postgres, MDY", 1);

        /*
         * Likewise set intervalstyle to ensure consistent results.  This is a bit
         * more painful because we must use PGOPTIONS, and we want to preserve the
         * user's ability to set other variables through that.
         */
        {
                const char *my_pgoptions = "-c intervalstyle=postgres_verbose";
                const char *old_pgoptions = getenv("PGOPTIONS");
                char       *new_pgoptions;

                if (!old_pgoptions)
                        old_pgoptions = "";
                new_pgoptions = psprintf("%s %s",
                                                                 old_pgoptions, my_pgoptions);
                setenv("PGOPTIONS", new_pgoptions, 1);
                free(new_pgoptions);
        }

        if (temp_instance)
        {
                /*
                 * Clear out any environment vars that might cause psql to connect to
                 * the wrong postmaster, or otherwise behave in nondefault ways. (Note
                 * we also use psql's -X switch consistently, so that ~/.psqlrc files
                 * won't mess things up.)  Also, set PGPORT to the temp port, and set
                 * PGHOST depending on whether we are using TCP or Unix sockets.
                 *
                 * This list should be kept in sync with TestLib.pm.
                 */
                unsetenv("PGCHANNELBINDING");
                /* PGCLIENTENCODING, see above */
                unsetenv("PGCONNECT_TIMEOUT");
                unsetenv("PGDATA");
                unsetenv("PGDATABASE");
                unsetenv("PGGSSENCMODE");
                unsetenv("PGGSSLIB");
                /* PGHOSTADDR, see below */
                unsetenv("PGKRBSRVNAME");
                unsetenv("PGPASSFILE");
                unsetenv("PGPASSWORD");
                unsetenv("PGREQUIREPEER");
                unsetenv("PGREQUIRESSL");
                unsetenv("PGSERVICE");
                unsetenv("PGSERVICEFILE");
                unsetenv("PGSSLCERT");
                unsetenv("PGSSLCRL");
                unsetenv("PGSSLCRLDIR");
                unsetenv("PGSSLKEY");
                unsetenv("PGSSLMAXPROTOCOLVERSION");
                unsetenv("PGSSLMINPROTOCOLVERSION");
                unsetenv("PGSSLMODE");
                unsetenv("PGSSLROOTCERT");
                unsetenv("PGSSLSNI");
                unsetenv("PGTARGETSESSIONATTRS");
                unsetenv("PGUSER");
                /* PGPORT, see below */
                /* PGHOST, see below */

#ifdef HAVE_UNIX_SOCKETS
                if (hostname != NULL)
                        setenv("PGHOST", hostname, 1);
                else
                {
                        sockdir = getenv("PG_REGRESS_SOCK_DIR");
                        if (!sockdir)
                                sockdir = make_temp_sockdir();
                        setenv("PGHOST", sockdir, 1);
                }
#else
                Assert(hostname != NULL);
                setenv("PGHOST", hostname, 1);
#endif
                unsetenv("PGHOSTADDR");
                if (port != -1)
                {
                        char            s[16];

                        sprintf(s, "%d", port);
                        setenv("PGPORT", s, 1);
                }
        }
        else
        {
                const char *pghost;
                const char *pgport;

                /*
                 * When testing an existing install, we honor existing environment
                 * variables, except if they're overridden by command line options.
                 */
                if (hostname != NULL)
                {
                        setenv("PGHOST", hostname, 1);
                        unsetenv("PGHOSTADDR");
                }
                if (port != -1)
                {
                        char            s[16];

                        sprintf(s, "%d", port);
                        setenv("PGPORT", s, 1);
                }
                if (user != NULL)
                        setenv("PGUSER", user, 1);

                /*
                 * However, we *don't* honor PGDATABASE, since we certainly don't wish
                 * to connect to whatever database the user might like as default.
                 * (Most tests override PGDATABASE anyway, but there are some ECPG
                 * test cases that don't.)
                 */
                unsetenv("PGDATABASE");

                /*
                 * Report what we're connecting to
                 */
                pghost = getenv("PGHOST");
                pgport = getenv("PGPORT");
#ifndef HAVE_UNIX_SOCKETS
                if (!pghost)
                        pghost = "localhost";
#endif

                if (pghost && pgport)
                        printf(_("(using postmaster on %s, port %s)\n"), pghost, pgport);
                if (pghost && !pgport)
                        printf(_("(using postmaster on %s, default port)\n"), pghost);
                if (!pghost && pgport)
                        printf(_("(using postmaster on Unix socket, port %s)\n"), pgport);
                if (!pghost && !pgport)
                        printf(_("(using postmaster on Unix socket, default port)\n"));
        }

        convert_sourcefiles();
        load_resultmap();
}

#ifdef ENABLE_SSPI

/* support for config_sspi_auth() */
static const char *
fmtHba(const char *raw)
{
        static char *ret;
        const char *rp;
        char       *wp;

        wp = ret = realloc(ret, 3 + strlen(raw) * 2);

        *wp++ = '"';
        for (rp = raw; *rp; rp++)
        {
                if (*rp == '"')
                        *wp++ = '"';
                *wp++ = *rp;
        }
        *wp++ = '"';
        *wp++ = '\0';

        return ret;
}

/*
 * Get account and domain/realm names for the current user.  This is based on
 * pg_SSPI_recvauth().  The returned strings use static storage.
 */
static void
current_windows_user(const char **acct, const char **dom)
{
        static char accountname[MAXPGPATH];
        static char domainname[MAXPGPATH];
        HANDLE          token;
        TOKEN_USER *tokenuser;
        DWORD           retlen;
        DWORD           accountnamesize = sizeof(accountname);
        DWORD           domainnamesize = sizeof(domainname);
        SID_NAME_USE accountnameuse;

        if (!OpenProcessToken(GetCurrentProcess(), TOKEN_READ, &token))
        {
                fprintf(stderr,
                                _("%s: could not open process token: error code %lu\n"),
                                progname, GetLastError());
                exit(2);
        }

        if (!GetTokenInformation(token, TokenUser, NULL, 0, &retlen) && GetLastError() != 122)
        {
                fprintf(stderr,
                                _("%s: could not get token information buffer size: error code %lu\n"),
                                progname, GetLastError());
                exit(2);
        }
        tokenuser = pg_malloc(retlen);
        if (!GetTokenInformation(token, TokenUser, tokenuser, retlen, &retlen))
        {
                fprintf(stderr,
                                _("%s: could not get token information: error code %lu\n"),
                                progname, GetLastError());
                exit(2);
        }

        if (!LookupAccountSid(NULL, tokenuser->User.Sid, accountname, &accountnamesize,
                                                  domainname, &domainnamesize, &accountnameuse))
        {
                fprintf(stderr,
                                _("%s: could not look up account SID: error code %lu\n"),
                                progname, GetLastError());
                exit(2);
        }

        free(tokenuser);

        *acct = accountname;
        *dom = domainname;
}

/*
 * Rewrite pg_hba.conf and pg_ident.conf to use SSPI authentication.  Permit
 * the current OS user to authenticate as the bootstrap superuser and as any
 * user named in a --create-role option.
 *
 * In --config-auth mode, the --user switch can be used to specify the
 * bootstrap superuser's name, otherwise we assume it is the default.
 */
static void
config_sspi_auth(const char *pgdata, const char *superuser_name)
{
        const char *accountname,
                           *domainname;
        char       *errstr;
        bool            have_ipv6;
        char            fname[MAXPGPATH];
        int                     res;
        FILE       *hba,
                           *ident;
        _stringlist *sl;

        /* Find out the name of the current OS user */
        current_windows_user(&accountname, &domainname);

        /* Determine the bootstrap superuser's name */
        if (superuser_name == NULL)
        {
                /*
                 * Compute the default superuser name the same way initdb does.
                 *
                 * It's possible that this result always matches "accountname", the
                 * value SSPI authentication discovers.  But the underlying system
                 * functions do not clearly guarantee that.
                 */
                superuser_name = get_user_name(&errstr);
                if (superuser_name == NULL)
                {
                        fprintf(stderr, "%s: %s\n", progname, errstr);
                        exit(2);
                }
        }

        /*
         * Like initdb.c:setup_config(), determine whether the platform recognizes
         * ::1 (IPv6 loopback) as a numeric host address string.
         */
        {
                struct addrinfo *gai_result;
                struct addrinfo hints;
                WSADATA         wsaData;

                hints.ai_flags = AI_NUMERICHOST;
                hints.ai_family = AF_UNSPEC;
                hints.ai_socktype = 0;
                hints.ai_protocol = 0;
                hints.ai_addrlen = 0;
                hints.ai_canonname = NULL;
                hints.ai_addr = NULL;
                hints.ai_next = NULL;

                have_ipv6 = (WSAStartup(MAKEWORD(2, 2), &wsaData) == 0 &&
                                         getaddrinfo("::1", NULL, &hints, &gai_result) == 0);
        }

        /* Check a Write outcome and report any error. */
#define CW(cond)        \
        do { \
                if (!(cond)) \
                { \
                        fprintf(stderr, _("%s: could not write to file \"%s\": %s\n"), \
                                        progname, fname, strerror(errno)); \
                        exit(2); \
                } \
        } while (0)

        res = snprintf(fname, sizeof(fname), "%s/pg_hba.conf", pgdata);
        if (res < 0 || res >= sizeof(fname))
        {
                /*
                 * Truncating this name is a fatal error, because we must not fail to
                 * overwrite an original trust-authentication pg_hba.conf.
                 */
                fprintf(stderr, _("%s: directory name too long\n"), progname);
                exit(2);
        }
        hba = fopen(fname, "w");
        if (hba == NULL)
        {
                fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
                                progname, fname, strerror(errno));
                exit(2);
        }
        CW(fputs("# Configuration written by config_sspi_auth()\n", hba) >= 0);
        CW(fputs("host all all 127.0.0.1/32  sspi include_realm=1 map=regress\n",
                         hba) >= 0);
        if (have_ipv6)
                CW(fputs("host all all ::1/128  sspi include_realm=1 map=regress\n",
                                 hba) >= 0);
        CW(fclose(hba) == 0);

        snprintf(fname, sizeof(fname), "%s/pg_ident.conf", pgdata);
        ident = fopen(fname, "w");
        if (ident == NULL)
        {
                fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
                                progname, fname, strerror(errno));
                exit(2);
        }
        CW(fputs("# Configuration written by config_sspi_auth()\n", ident) >= 0);

        /*
         * Double-quote for the benefit of account names containing whitespace or
         * '#'.  Windows forbids the double-quote character itself, so don't
         * bother escaping embedded double-quote characters.
         */
        CW(fprintf(ident, "regress  \"%s@%s\"  %s\n",
                           accountname, domainname, fmtHba(superuser_name)) >= 0);
        for (sl = extraroles; sl; sl = sl->next)
                CW(fprintf(ident, "regress  \"%s@%s\"  %s\n",
                                   accountname, domainname, fmtHba(sl->str)) >= 0);
        CW(fclose(ident) == 0);
}

#endif                                                  /* ENABLE_SSPI */

/*
 * Issue a command via psql, connecting to the specified database
 *
 * Since we use system(), this doesn't return until the operation finishes
 */
static void
psql_command(const char *database, const char *query,...)
{
        char            query_formatted[1024];
        char            query_escaped[2048];
        char            psql_cmd[MAXPGPATH + 2048];
        va_list         args;
        char       *s;
        char       *d;

        /* Generate the query with insertion of sprintf arguments */
        va_start(args, query);
        vsnprintf(query_formatted, sizeof(query_formatted), query, args);
        va_end(args);

        /* Now escape any shell double-quote metacharacters */
        d = query_escaped;
        for (s = query_formatted; *s; s++)
        {
                if (strchr("\\\"$`", *s))
                        *d++ = '\\';
                *d++ = *s;
        }
        *d = '\0';

        /* And now we can build and execute the shell command */
        snprintf(psql_cmd, sizeof(psql_cmd),
                         "\"%s%spsql\" -X -c \"%s\" \"%s\"",
                         bindir ? bindir : "",
                         bindir ? "/" : "",
                         query_escaped,
                         database);

        if (system(psql_cmd) != 0)
        {
                /* psql probably already reported the error */
                fprintf(stderr, _("command failed: %s\n"), psql_cmd);
                exit(2);
        }
}

/*
 * Spawn a process to execute the given shell command; don't wait for it
 *
 * Returns the process ID (or HANDLE) so we can wait for it later
 */
PID_TYPE
spawn_process(const char *cmdline)
{
#ifndef WIN32
        pid_t           pid;

        /*
         * Must flush I/O buffers before fork.  Ideally we'd use fflush(NULL) here
         * ... does anyone still care about systems where that doesn't work?
         */
        fflush(stdout);
        fflush(stderr);
        if (logfile)
                fflush(logfile);

        pid = fork();
        if (pid == -1)
        {
                fprintf(stderr, _("%s: could not fork: %s\n"),
                                progname, strerror(errno));
                exit(2);
        }
        if (pid == 0)
        {
                /*
                 * In child
                 *
                 * Instead of using system(), exec the shell directly, and tell it to
                 * "exec" the command too.  This saves two useless processes per
                 * parallel test case.
                 */
                char       *cmdline2;

                cmdline2 = psprintf("exec %s", cmdline);
                execl(shellprog, shellprog, "-c", cmdline2, (char *) NULL);
                fprintf(stderr, _("%s: could not exec \"%s\": %s\n"),
                                progname, shellprog, strerror(errno));
                _exit(1);                               /* not exit() here... */
        }
        /* in parent */
        return pid;
#else
        PROCESS_INFORMATION pi;
        char       *cmdline2;
        HANDLE          restrictedToken;
        const char *comspec;

        /* Find CMD.EXE location using COMSPEC, if it's set */
        comspec = getenv("COMSPEC");
        if (comspec == NULL)
                comspec = "CMD";

        memset(&pi, 0, sizeof(pi));
        cmdline2 = psprintf("\"%s\" /c \"%s\"", comspec, cmdline);

        if ((restrictedToken =
                 CreateRestrictedProcess(cmdline2, &pi)) == 0)
                exit(2);

        CloseHandle(pi.hThread);
        return pi.hProcess;
#endif
}

/*
 * Count bytes in file
 */
static long
file_size(const char *file)
{
        long            r;
        FILE       *f = fopen(file, "r");

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

/*
 * Count lines in file
 */
static int
file_line_count(const char *file)
{
        int                     c;
        int                     l = 0;
        FILE       *f = fopen(file, "r");

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

bool
file_exists(const char *file)
{
        FILE       *f = fopen(file, "r");

        if (!f)
                return false;
        fclose(f);
        return true;
}

static bool
directory_exists(const char *dir)
{
        struct stat st;

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

/* Create a directory */
static void
make_directory(const char *dir)
{
        if (mkdir(dir, S_IRWXU | S_IRWXG | S_IRWXO) < 0)
        {
                fprintf(stderr, _("%s: could not create directory \"%s\": %s\n"),
                                progname, dir, strerror(errno));
                exit(2);
        }
}

/*
 * In: filename.ext, Return: filename_i.ext, where 0 < i <= 9
 */
static char *
get_alternative_expectfile(const char *expectfile, int i)
{
        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;
}

/*
 * Run a "diff" command and also check that it didn't crash
 */
static int
run_diff(const char *cmd, const char *filename)
{
        int                     r;

        r = system(cmd);
        if (!WIFEXITED(r) || WEXITSTATUS(r) > 1)
        {
                fprintf(stderr, _("diff command failed with status %d: %s\n"), r, cmd);
                exit(2);
        }
#ifdef WIN32

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

        return WEXITSTATUS(r);
}

/*
 * Check the actual result file for the given test against expected results
 *
 * Returns true if different (failure), false if correct match found.
 * In the true case, the diff is appended to the diffs file.
 */
static bool
results_differ(const char *testname, const char *resultsfile, const char *default_expectfile)
{
        char            expectfile[MAXPGPATH];
        char            diff[MAXPGPATH];
        char            cmd[MAXPGPATH * 3];
        char            best_expect_file[MAXPGPATH];
        FILE       *difffile;
        int                     best_line_count;
        int                     i;
        int                     l;
        const char *platform_expectfile;

        /*
         * We can pass either the resultsfile or the expectfile, they should have
         * the same type (filename.type) anyway.
         */
        platform_expectfile = get_expectfile(testname, resultsfile);

        strlcpy(expectfile, default_expectfile, sizeof(expectfile));
        if (platform_expectfile)
        {
                /*
                 * Replace everything after the last slash in expectfile with what the
                 * platform_expectfile contains.
                 */
                char       *p = strrchr(expectfile, '/');

                if (p)
                        strcpy(++p, platform_expectfile);
        }

        /* Name to use for temporary diff file */
        snprintf(diff, sizeof(diff), "%s.diff", resultsfile);

        /* OK, run the diff */
        snprintf(cmd, sizeof(cmd),
                         "diff %s \"%s\" \"%s\" > \"%s\"",
                         basic_diff_opts, expectfile, resultsfile, diff);

        /* Is the diff file empty? */
        if (run_diff(cmd, diff) == 0)
        {
                unlink(diff);
                return false;
        }

        /* There may be secondary comparison files that match better */
        best_line_count = file_line_count(diff);
        strcpy(best_expect_file, expectfile);

        for (i = 0; i <= 9; i++)
        {
                char       *alt_expectfile;

                alt_expectfile = get_alternative_expectfile(expectfile, i);
                if (!alt_expectfile)
                {
                        fprintf(stderr, _("Unable to check secondary comparison files: %s\n"),
                                        strerror(errno));
                        exit(2);
                }

                if (!file_exists(alt_expectfile))
                {
                        free(alt_expectfile);
                        continue;
                }

                snprintf(cmd, sizeof(cmd),
                                 "diff %s \"%s\" \"%s\" > \"%s\"",
                                 basic_diff_opts, alt_expectfile, resultsfile, diff);

                if (run_diff(cmd, diff) == 0)
                {
                        unlink(diff);
                        free(alt_expectfile);
                        return false;
                }

                l = file_line_count(diff);
                if (l < best_line_count)
                {
                        /* This diff was a better match than the last one */
                        best_line_count = l;
                        strlcpy(best_expect_file, alt_expectfile, sizeof(best_expect_file));
                }
                free(alt_expectfile);
        }

        /*
         * fall back on the canonical results file if we haven't tried it yet and
         * haven't found a complete match yet.
         */

        if (platform_expectfile)
        {
                snprintf(cmd, sizeof(cmd),
                                 "diff %s \"%s\" \"%s\" > \"%s\"",
                                 basic_diff_opts, default_expectfile, resultsfile, diff);

                if (run_diff(cmd, diff) == 0)
                {
                        /* No diff = no changes = good */
                        unlink(diff);
                        return false;
                }

                l = file_line_count(diff);
                if (l < best_line_count)
                {
                        /* This diff was a better match than the last one */
                        best_line_count = l;
                        strlcpy(best_expect_file, default_expectfile, sizeof(best_expect_file));
                }
        }

        /*
         * Use the best comparison file to generate the "pretty" diff, which we
         * append to the diffs summary file.
         */

        /* Write diff header */
        difffile = fopen(difffilename, "a");
        if (difffile)
        {
                fprintf(difffile,
                                "diff %s %s %s\n",
                                pretty_diff_opts, best_expect_file, resultsfile);
                fclose(difffile);
        }

        /* Run diff */
        snprintf(cmd, sizeof(cmd),
                         "diff %s \"%s\" \"%s\" >> \"%s\"",
                         pretty_diff_opts, best_expect_file, resultsfile, difffilename);
        run_diff(cmd, difffilename);

        unlink(diff);
        return true;
}

/*
 * Wait for specified subprocesses to finish, and return their exit
 * statuses into statuses[] and stop times into stoptimes[]
 *
 * If names isn't NULL, print each subprocess's name as it finishes
 *
 * Note: it's OK to scribble on the pids array, but not on the names array
 */
static void
wait_for_tests(PID_TYPE * pids, int *statuses, instr_time *stoptimes,
                           char **names, int num_tests)
{
        int                     tests_left;
        int                     i;

#ifdef WIN32
        PID_TYPE   *active_pids = pg_malloc(num_tests * sizeof(PID_TYPE));

        memcpy(active_pids, pids, num_tests * sizeof(PID_TYPE));
#endif

        tests_left = num_tests;
        while (tests_left > 0)
        {
                PID_TYPE        p;

#ifndef WIN32
                int                     exit_status;

                p = wait(&exit_status);

                if (p == INVALID_PID)
                {
                        fprintf(stderr, _("failed to wait for subprocesses: %s\n"),
                                        strerror(errno));
                        exit(2);
                }
#else
                DWORD           exit_status;
                int                     r;

                r = WaitForMultipleObjects(tests_left, active_pids, FALSE, INFINITE);
                if (r < WAIT_OBJECT_0 || r >= WAIT_OBJECT_0 + tests_left)
                {
                        fprintf(stderr, _("failed to wait for subprocesses: error code %lu\n"),
                                        GetLastError());
                        exit(2);
                }
                p = active_pids[r - WAIT_OBJECT_0];
                /* compact the active_pids array */
                active_pids[r - WAIT_OBJECT_0] = active_pids[tests_left - 1];
#endif                                                  /* WIN32 */

                for (i = 0; i < num_tests; i++)
                {
                        if (p == pids[i])
                        {
#ifdef WIN32
                                GetExitCodeProcess(pids[i], &exit_status);
                                CloseHandle(pids[i]);
#endif
                                pids[i] = INVALID_PID;
                                statuses[i] = (int) exit_status;
                                INSTR_TIME_SET_CURRENT(stoptimes[i]);
                                if (names)
                                        status(" %s", names[i]);
                                tests_left--;
                                break;
                        }
                }
        }

#ifdef WIN32
        free(active_pids);
#endif
}

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

/*
 * Run all the tests specified in one schedule file
 */
static void
run_schedule(const char *schedule, test_start_function startfunc,
                         postprocess_result_function postfunc)
{
#define MAX_PARALLEL_TESTS 100
        char       *tests[MAX_PARALLEL_TESTS];
        _stringlist *resultfiles[MAX_PARALLEL_TESTS];
        _stringlist *expectfiles[MAX_PARALLEL_TESTS];
        _stringlist *tags[MAX_PARALLEL_TESTS];
        PID_TYPE        pids[MAX_PARALLEL_TESTS];
        instr_time      starttimes[MAX_PARALLEL_TESTS];
        instr_time      stoptimes[MAX_PARALLEL_TESTS];
        int                     statuses[MAX_PARALLEL_TESTS];
        _stringlist *ignorelist = NULL;
        char            scbuf[1024];
        FILE       *scf;
        int                     line_num = 0;

        memset(tests, 0, sizeof(tests));
        memset(resultfiles, 0, sizeof(resultfiles));
        memset(expectfiles, 0, sizeof(expectfiles));
        memset(tags, 0, sizeof(tags));

        scf = fopen(schedule, "r");
        if (!scf)
        {
                fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
                                progname, schedule, strerror(errno));
                exit(2);
        }

        while (fgets(scbuf, sizeof(scbuf), scf))
        {
                char       *test = NULL;
                char       *c;
                int                     num_tests;
                bool            inword;
                int                     i;

                line_num++;

                /* strip trailing whitespace, especially the newline */
                i = strlen(scbuf);
                while (i > 0 && isspace((unsigned char) scbuf[i - 1]))
                        scbuf[--i] = '\0';

                if (scbuf[0] == '\0' || scbuf[0] == '#')
                        continue;
                if (strncmp(scbuf, "test: ", 6) == 0)
                        test = scbuf + 6;
                else if (strncmp(scbuf, "ignore: ", 8) == 0)
                {
                        c = scbuf + 8;
                        while (*c && isspace((unsigned char) *c))
                                c++;
                        add_stringlist_item(&ignorelist, c);

                        /*
                         * Note: ignore: lines do not run the test, they just say that
                         * failure of this test when run later on is to be ignored. A bit
                         * odd but that's how the shell-script version did it.
                         */
                        continue;
                }
                else
                {
                        fprintf(stderr, _("syntax error in schedule file \"%s\" line %d: %s\n"),
                                        schedule, line_num, scbuf);
                        exit(2);
                }

                num_tests = 0;
                inword = false;
                for (c = test;; c++)
                {
                        if (*c == '\0' || isspace((unsigned char) *c))
                        {
                                if (inword)
                                {
                                        /* Reached end of a test name */
                                        char            sav;

                                        if (num_tests >= MAX_PARALLEL_TESTS)
                                        {
                                                fprintf(stderr, _("too many parallel tests (more than %d) in schedule file \"%s\" line %d: %s\n"),
                                                                MAX_PARALLEL_TESTS, schedule, line_num, scbuf);
                                                exit(2);
                                        }
                                        sav = *c;
                                        *c = '\0';
                                        tests[num_tests] = pg_strdup(test);
                                        num_tests++;
                                        *c = sav;
                                        inword = false;
                                }
                                if (*c == '\0')
                                        break;          /* loop exit is here */
                        }
                        else if (!inword)
                        {
                                /* Start of a test name */
                                test = c;
                                inword = true;
                        }
                }

                if (num_tests == 0)
                {
                        fprintf(stderr, _("syntax error in schedule file \"%s\" line %d: %s\n"),
                                        schedule, line_num, scbuf);
                        exit(2);
                }

                if (num_tests == 1)
                {
                        status(_("test %-28s ... "), tests[0]);
                        pids[0] = (startfunc) (tests[0], &resultfiles[0], &expectfiles[0], &tags[0]);
                        INSTR_TIME_SET_CURRENT(starttimes[0]);
                        wait_for_tests(pids, statuses, stoptimes, NULL, 1);
                        /* status line is finished below */
                }
                else if (max_concurrent_tests > 0 && max_concurrent_tests < num_tests)
                {
                        fprintf(stderr, _("too many parallel tests (more than %d) in schedule file \"%s\" line %d: %s\n"),
                                        max_concurrent_tests, schedule, line_num, scbuf);
                        exit(2);
                }
                else if (max_connections > 0 && max_connections < num_tests)
                {
                        int                     oldest = 0;

                        status(_("parallel group (%d tests, in groups of %d): "),
                                   num_tests, max_connections);
                        for (i = 0; i < num_tests; i++)
                        {
                                if (i - oldest >= max_connections)
                                {
                                        wait_for_tests(pids + oldest, statuses + oldest,
                                                                   stoptimes + oldest,
                                                                   tests + oldest, i - oldest);
                                        oldest = i;
                                }
                                pids[i] = (startfunc) (tests[i], &resultfiles[i], &expectfiles[i], &tags[i]);
                                INSTR_TIME_SET_CURRENT(starttimes[i]);
                        }
                        wait_for_tests(pids + oldest, statuses + oldest,
                                                   stoptimes + oldest,
                                                   tests + oldest, i - oldest);
                        status_end();
                }
                else
                {
                        status(_("parallel group (%d tests): "), num_tests);
                        for (i = 0; i < num_tests; i++)
                        {
                                pids[i] = (startfunc) (tests[i], &resultfiles[i], &expectfiles[i], &tags[i]);
                                INSTR_TIME_SET_CURRENT(starttimes[i]);
                        }
                        wait_for_tests(pids, statuses, stoptimes, tests, num_tests);
                        status_end();
                }

                /* Check results for all tests */
                for (i = 0; i < num_tests; i++)
                {
                        _stringlist *rl,
                                           *el,
                                           *tl;
                        bool            differ = false;

                        if (num_tests > 1)
                                status(_("     %-28s ... "), tests[i]);

                        /*
                         * Advance over all three lists simultaneously.
                         *
                         * Compare resultfiles[j] with expectfiles[j] always. Tags are
                         * optional but if there are tags, the tag list has the same
                         * length as the other two lists.
                         */
                        for (rl = resultfiles[i], el = expectfiles[i], tl = tags[i];
                                 rl != NULL;    /* rl and el have the same length */
                                 rl = rl->next, el = el->next,
                                 tl = tl ? tl->next : NULL)
                        {
                                bool            newdiff;

                                if (postfunc)
                                        (*postfunc) (rl->str);
                                newdiff = results_differ(tests[i], rl->str, el->str);
                                if (newdiff && tl)
                                {
                                        printf("%s ", tl->str);
                                }
                                differ |= newdiff;
                        }

                        if (differ)
                        {
                                bool            ignore = false;
                                _stringlist *sl;

                                for (sl = ignorelist; sl != NULL; sl = sl->next)
                                {
                                        if (strcmp(tests[i], sl->str) == 0)
                                        {
                                                ignore = true;
                                                break;
                                        }
                                }
                                if (ignore)
                                {
                                        status(_("failed (ignored)"));
                                        fail_ignore_count++;
                                }
                                else
                                {
                                        status(_("FAILED"));
                                        fail_count++;
                                }
                        }
                        else
                        {
                                status(_("ok    "));    /* align with FAILED */
                                success_count++;
                        }

                        if (statuses[i] != 0)
                                log_child_failure(statuses[i]);

                        INSTR_TIME_SUBTRACT(stoptimes[i], starttimes[i]);
                        status(_(" %8.0f ms"), INSTR_TIME_GET_MILLISEC(stoptimes[i]));

                        status_end();
                }

                for (i = 0; i < num_tests; i++)
                {
                        pg_free(tests[i]);
                        tests[i] = NULL;
                        free_stringlist(&resultfiles[i]);
                        free_stringlist(&expectfiles[i]);
                        free_stringlist(&tags[i]);
                }
        }

        free_stringlist(&ignorelist);

        fclose(scf);
}

/*
 * Run a single test
 */
static void
run_single_test(const char *test, test_start_function startfunc,
                                postprocess_result_function postfunc)
{
        PID_TYPE        pid;
        instr_time      starttime;
        instr_time      stoptime;
        int                     exit_status;
        _stringlist *resultfiles = NULL;
        _stringlist *expectfiles = NULL;
        _stringlist *tags = NULL;
        _stringlist *rl,
                           *el,
                           *tl;
        bool            differ = false;

        status(_("test %-28s ... "), test);
        pid = (startfunc) (test, &resultfiles, &expectfiles, &tags);
        INSTR_TIME_SET_CURRENT(starttime);
        wait_for_tests(&pid, &exit_status, &stoptime, NULL, 1);

        /*
         * Advance over all three lists simultaneously.
         *
         * Compare resultfiles[j] with expectfiles[j] always. Tags are optional
         * but if there are tags, the tag list has the same length as the other
         * two lists.
         */
        for (rl = resultfiles, el = expectfiles, tl = tags;
                 rl != NULL;                    /* rl and el have the same length */
                 rl = rl->next, el = el->next,
                 tl = tl ? tl->next : NULL)
        {
                bool            newdiff;

                if (postfunc)
                        (*postfunc) (rl->str);
                newdiff = results_differ(test, rl->str, el->str);
                if (newdiff && tl)
                {
                        printf("%s ", tl->str);
                }
                differ |= newdiff;
        }

        if (differ)
        {
                status(_("FAILED"));
                fail_count++;
        }
        else
        {
                status(_("ok    "));    /* align with FAILED */
                success_count++;
        }

        if (exit_status != 0)
                log_child_failure(exit_status);

        INSTR_TIME_SUBTRACT(stoptime, starttime);
        status(_(" %8.0f ms"), INSTR_TIME_GET_MILLISEC(stoptime));

        status_end();
}

/*
 * Create the summary-output files (making them empty if already existing)
 */
static void
open_result_files(void)
{
        char            file[MAXPGPATH];
        FILE       *difffile;

        /* create outputdir directory if not present */
        if (!directory_exists(outputdir))
                make_directory(outputdir);

        /* create the log file (copy of running status output) */
        snprintf(file, sizeof(file), "%s/regression.out", outputdir);
        logfilename = pg_strdup(file);
        logfile = fopen(logfilename, "w");
        if (!logfile)
        {
                fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
                                progname, logfilename, strerror(errno));
                exit(2);
        }

        /* create the diffs file as empty */
        snprintf(file, sizeof(file), "%s/regression.diffs", outputdir);
        difffilename = pg_strdup(file);
        difffile = fopen(difffilename, "w");
        if (!difffile)
        {
                fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
                                progname, difffilename, strerror(errno));
                exit(2);
        }
        /* we don't keep the diffs file open continuously */
        fclose(difffile);

        /* also create the results directory if not present */
        snprintf(file, sizeof(file), "%s/results", outputdir);
        if (!directory_exists(file))
                make_directory(file);
}

static void
drop_database_if_exists(const char *dbname)
{
        header(_("dropping database \"%s\""), dbname);
        psql_command("postgres", "DROP DATABASE IF EXISTS \"%s\"", dbname);
}

static void
create_database(const char *dbname)
{
        _stringlist *sl;

        /*
         * We use template0 so that any installation-local cruft in template1 will
         * not mess up the tests.
         */
        header(_("creating database \"%s\""), dbname);
        if (encoding)
                psql_command("postgres", "CREATE DATABASE \"%s\" TEMPLATE=template0 ENCODING='%s'%s", dbname, encoding,
                                         (nolocale) ? " LC_COLLATE='C' LC_CTYPE='C'" : "");
        else
                psql_command("postgres", "CREATE DATABASE \"%s\" TEMPLATE=template0%s", dbname,
                                         (nolocale) ? " LC_COLLATE='C' LC_CTYPE='C'" : "");
        psql_command(dbname,
                                 "ALTER DATABASE \"%s\" SET lc_messages TO 'C';"
                                 "ALTER DATABASE \"%s\" SET lc_monetary TO 'C';"
                                 "ALTER DATABASE \"%s\" SET lc_numeric TO 'C';"
                                 "ALTER DATABASE \"%s\" SET lc_time TO 'C';"
                                 "ALTER DATABASE \"%s\" SET bytea_output TO 'hex';"
                                 "ALTER DATABASE \"%s\" SET timezone_abbreviations TO 'Default';",
                                 dbname, dbname, dbname, dbname, dbname, dbname);

        /*
         * Install any requested extensions.  We use CREATE IF NOT EXISTS so that
         * this will work whether or not the extension is preinstalled.
         */
        for (sl = loadextension; sl != NULL; sl = sl->next)
        {
                header(_("installing %s"), sl->str);
                psql_command(dbname, "CREATE EXTENSION IF NOT EXISTS \"%s\"", sl->str);
        }
}

static void
drop_role_if_exists(const char *rolename)
{
        header(_("dropping role \"%s\""), rolename);
        psql_command("postgres", "DROP ROLE IF EXISTS \"%s\"", rolename);
}

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

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

int
regression_main(int argc, char *argv[],
                                init_function ifunc,
                                test_start_function startfunc,
                                postprocess_result_function postfunc)
{
        static struct option long_options[] = {
                {"help", no_argument, NULL, 'h'},
                {"version", no_argument, NULL, 'V'},
                {"dbname", required_argument, NULL, 1},
                {"debug", no_argument, NULL, 2},
                {"inputdir", required_argument, NULL, 3},
                {"max-connections", required_argument, NULL, 5},
                {"encoding", required_argument, NULL, 6},
                {"outputdir", required_argument, NULL, 7},
                {"schedule", required_argument, NULL, 8},
                {"temp-instance", required_argument, NULL, 9},
                {"no-locale", no_argument, NULL, 10},
                {"host", required_argument, NULL, 13},
                {"port", required_argument, NULL, 14},
                {"user", required_argument, NULL, 15},
                {"bindir", required_argument, NULL, 16},
                {"dlpath", required_argument, NULL, 17},
                {"create-role", required_argument, NULL, 18},
                {"temp-config", required_argument, NULL, 19},
                {"use-existing", no_argument, NULL, 20},
                {"launcher", required_argument, NULL, 21},
                {"load-extension", required_argument, NULL, 22},
                {"config-auth", required_argument, NULL, 24},
                {"max-concurrent-tests", required_argument, NULL, 25},
                {"make-testtablespace-dir", no_argument, NULL, 26},
                {NULL, 0, NULL, 0}
        };

        bool            use_unix_sockets;
        bool            make_testtablespace_dir = false;
        _stringlist *sl;
        int                     c;
        int                     i;
        int                     option_index;
        char            buf[MAXPGPATH * 4];
        char            buf2[MAXPGPATH * 4];

        pg_logging_init(argv[0]);
        progname = get_progname(argv[0]);
        set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_regress"));

        get_restricted_token();

        atexit(stop_postmaster);

#if !defined(HAVE_UNIX_SOCKETS)
        use_unix_sockets = false;
#elif defined(WIN32)

        /*
         * We don't use Unix-domain sockets on Windows by default, even if the
         * build supports them.  (See comment at remove_temp() for a reason.)
         * Override at your own risk.
         */
        use_unix_sockets = getenv("PG_TEST_USE_UNIX_SOCKETS") ? true : false;
#else
        use_unix_sockets = true;
#endif

        if (!use_unix_sockets)
                hostname = "localhost";

        /*
         * We call the initialization function here because that way we can set
         * default parameters and let them be overwritten by the commandline.
         */
        ifunc(argc, argv);

        if (getenv("PG_REGRESS_DIFF_OPTS"))
                pretty_diff_opts = getenv("PG_REGRESS_DIFF_OPTS");

        while ((c = getopt_long(argc, argv, "hV", long_options, &option_index)) != -1)
        {
                switch (c)
                {
                        case 'h':
                                help();
                                exit(0);
                        case 'V':
                                puts("pg_regress (PostgreSQL) " PG_VERSION);
                                exit(0);
                        case 1:

                                /*
                                 * If a default database was specified, we need to remove it
                                 * before we add the specified one.
                                 */
                                free_stringlist(&dblist);
                                split_to_stringlist(optarg, ",", &dblist);
                                break;
                        case 2:
                                debug = true;
                                break;
                        case 3:
                                inputdir = pg_strdup(optarg);
                                break;
                        case 5:
                                max_connections = atoi(optarg);
                                break;
                        case 6:
                                encoding = pg_strdup(optarg);
                                break;
                        case 7:
                                outputdir = pg_strdup(optarg);
                                break;
                        case 8:
                                add_stringlist_item(&schedulelist, optarg);
                                break;
                        case 9:
                                temp_instance = make_absolute_path(optarg);
                                break;
                        case 10:
                                nolocale = true;
                                break;
                        case 13:
                                hostname = pg_strdup(optarg);
                                break;
                        case 14:
                                port = atoi(optarg);
                                port_specified_by_user = true;
                                break;
                        case 15:
                                user = pg_strdup(optarg);
                                break;
                        case 16:
                                /* "--bindir=" means to use PATH */
                                if (strlen(optarg))
                                        bindir = pg_strdup(optarg);
                                else
                                        bindir = NULL;
                                break;
                        case 17:
                                dlpath = pg_strdup(optarg);
                                break;
                        case 18:
                                split_to_stringlist(optarg, ",", &extraroles);
                                break;
                        case 19:
                                add_stringlist_item(&temp_configs, optarg);
                                break;
                        case 20:
                                use_existing = true;
                                break;
                        case 21:
                                launcher = pg_strdup(optarg);
                                break;
                        case 22:
                                add_stringlist_item(&loadextension, optarg);
                                break;
                        case 24:
                                config_auth_datadir = pg_strdup(optarg);
                                break;
                        case 25:
                                max_concurrent_tests = atoi(optarg);
                                break;
                        case 26:
                                make_testtablespace_dir = true;
                                break;
                        default:
                                /* getopt_long already emitted a complaint */
                                fprintf(stderr, _("\nTry \"%s -h\" for more information.\n"),
                                                progname);
                                exit(2);
                }
        }

        /*
         * if we still have arguments, they are extra tests to run
         */
        while (argc - optind >= 1)
        {
                add_stringlist_item(&extra_tests, argv[optind]);
                optind++;
        }

        if (config_auth_datadir)
        {
#ifdef ENABLE_SSPI
                if (!use_unix_sockets)
                        config_sspi_auth(config_auth_datadir, user);
#endif
                exit(0);
        }

        if (temp_instance && !port_specified_by_user)

                /*
                 * To reduce chances of interference with parallel installations, use
                 * a port number starting in the private range (49152-65535)
                 * calculated from the version number.  This aids !HAVE_UNIX_SOCKETS
                 * systems; elsewhere, the use of a private socket directory already
                 * prevents interference.
                 */
                port = 0xC000 | (PG_VERSION_NUM & 0x3FFF);

        inputdir = make_absolute_path(inputdir);
        outputdir = make_absolute_path(outputdir);
        dlpath = make_absolute_path(dlpath);

        /*
         * Initialization
         */
        open_result_files();

        initialize_environment();

#if defined(HAVE_GETRLIMIT) && defined(RLIMIT_CORE)
        unlimit_core_size();
#endif

        if (make_testtablespace_dir)
                prepare_testtablespace_dir();

        if (temp_instance)
        {
                FILE       *pg_conf;
                const char *env_wait;
                int                     wait_seconds;

                /*
                 * Prepare the temp instance
                 */

                if (directory_exists(temp_instance))
                {
                        header(_("removing existing temp instance"));
                        if (!rmtree(temp_instance, true))
                        {
                                fprintf(stderr, _("\n%s: could not remove temp instance \"%s\"\n"),
                                                progname, temp_instance);
                                exit(2);
                        }
                }

                header(_("creating temporary instance"));

                /* make the temp instance top directory */
                make_directory(temp_instance);

                /* and a directory for log files */
                snprintf(buf, sizeof(buf), "%s/log", outputdir);
                if (!directory_exists(buf))
                        make_directory(buf);

                /* initdb */
                header(_("initializing database system"));
                snprintf(buf, sizeof(buf),
                                 "\"%s%sinitdb\" -D \"%s/data\" --no-clean --no-sync%s%s > \"%s/log/initdb.log\" 2>&1",
                                 bindir ? bindir : "",
                                 bindir ? "/" : "",
                                 temp_instance,
                                 debug ? " --debug" : "",
                                 nolocale ? " --no-locale" : "",
                                 outputdir);
                if (system(buf))
                {
                        fprintf(stderr, _("\n%s: initdb failed\nExamine %s/log/initdb.log for the reason.\nCommand was: %s\n"), progname, outputdir, buf);
                        exit(2);
                }

                /*
                 * Adjust the default postgresql.conf for regression testing. The user
                 * can specify a file to be appended; in any case we expand logging
                 * and set max_prepared_transactions to enable testing of prepared
                 * xacts.  (Note: to reduce the probability of unexpected shmmax
                 * failures, don't set max_prepared_transactions any higher than
                 * actually needed by the prepared_xacts regression test.)
                 */
                snprintf(buf, sizeof(buf), "%s/data/postgresql.conf", temp_instance);
                pg_conf = fopen(buf, "a");
                if (pg_conf == NULL)
                {
                        fprintf(stderr, _("\n%s: could not open \"%s\" for adding extra config: %s\n"), progname, buf, strerror(errno));
                        exit(2);
                }
                fputs("\n# Configuration added by pg_regress\n\n", pg_conf);
                fputs("log_autovacuum_min_duration = 0\n", pg_conf);
                fputs("log_checkpoints = on\n", pg_conf);
                fputs("log_line_prefix = '%m %b[%p] %q%a '\n", pg_conf);
                fputs("log_lock_waits = on\n", pg_conf);
                fputs("log_temp_files = 128kB\n", pg_conf);
                fputs("max_prepared_transactions = 2\n", pg_conf);

                for (sl = temp_configs; sl != NULL; sl = sl->next)
                {
                        char       *temp_config = sl->str;
                        FILE       *extra_conf;
                        char            line_buf[1024];

                        extra_conf = fopen(temp_config, "r");
                        if (extra_conf == NULL)
                        {
                                fprintf(stderr, _("\n%s: could not open \"%s\" to read extra config: %s\n"), progname, temp_config, strerror(errno));
                                exit(2);
                        }
                        while (fgets(line_buf, sizeof(line_buf), extra_conf) != NULL)
                                fputs(line_buf, pg_conf);
                        fclose(extra_conf);
                }

                fclose(pg_conf);

#ifdef ENABLE_SSPI
                if (!use_unix_sockets)
                {
                        /*
                         * Since we successfully used the same buffer for the much-longer
                         * "initdb" command, this can't truncate.
                         */
                        snprintf(buf, sizeof(buf), "%s/data", temp_instance);
                        config_sspi_auth(buf, NULL);
                }
#elif !defined(HAVE_UNIX_SOCKETS)
#error Platform has no means to secure the test installation.
#endif

                /*
                 * Check if there is a postmaster running already.
                 */
                snprintf(buf2, sizeof(buf2),
                                 "\"%s%spsql\" -X postgres <%s 2>%s",
                                 bindir ? bindir : "",
                                 bindir ? "/" : "",
                                 DEVNULL, DEVNULL);

                for (i = 0; i < 16; i++)
                {
                        if (system(buf2) == 0)
                        {
                                char            s[16];

                                if (port_specified_by_user || i == 15)
                                {
                                        fprintf(stderr, _("port %d apparently in use\n"), port);
                                        if (!port_specified_by_user)
                                                fprintf(stderr, _("%s: could not determine an available port\n"), progname);
                                        fprintf(stderr, _("Specify an unused port using the --port option or shut down any conflicting PostgreSQL servers.\n"));
                                        exit(2);
                                }

                                fprintf(stderr, _("port %d apparently in use, trying %d\n"), port, port + 1);
                                port++;
                                sprintf(s, "%d", port);
                                setenv("PGPORT", s, 1);
                        }
                        else
                                break;
                }

                /*
                 * Start the temp postmaster
                 */
                header(_("starting postmaster"));
                snprintf(buf, sizeof(buf),
                                 "\"%s%spostgres\" -D \"%s/data\" -F%s "
                                 "-c \"listen_addresses=%s\" -k \"%s\" "
                                 "> \"%s/log/postmaster.log\" 2>&1",
                                 bindir ? bindir : "",
                                 bindir ? "/" : "",
                                 temp_instance, debug ? " -d 5" : "",
                                 hostname ? hostname : "", sockdir ? sockdir : "",
                                 outputdir);
                postmaster_pid = spawn_process(buf);
                if (postmaster_pid == INVALID_PID)
                {
                        fprintf(stderr, _("\n%s: could not spawn postmaster: %s\n"),
                                        progname, strerror(errno));
                        exit(2);
                }

                /*
                 * Wait till postmaster is able to accept connections; normally this
                 * is only a second or so, but Cygwin is reportedly *much* slower, and
                 * test builds using Valgrind or similar tools might be too.  Hence,
                 * allow the default timeout of 60 seconds to be overridden from the
                 * PGCTLTIMEOUT environment variable.
                 */
                env_wait = getenv("PGCTLTIMEOUT");
                if (env_wait != NULL)
                {
                        wait_seconds = atoi(env_wait);
                        if (wait_seconds <= 0)
                                wait_seconds = 60;
                }
                else
                        wait_seconds = 60;

                for (i = 0; i < wait_seconds; i++)
                {
                        /* Done if psql succeeds */
                        if (system(buf2) == 0)
                                break;

                        /*
                         * Fail immediately if postmaster has exited
                         */
#ifndef WIN32
                        if (waitpid(postmaster_pid, NULL, WNOHANG) == postmaster_pid)
#else
                        if (WaitForSingleObject(postmaster_pid, 0) == WAIT_OBJECT_0)
#endif
                        {
                                fprintf(stderr, _("\n%s: postmaster failed\nExamine %s/log/postmaster.log for the reason\n"), progname, outputdir);
                                exit(2);
                        }

                        pg_usleep(1000000L);
                }
                if (i >= wait_seconds)
                {
                        fprintf(stderr, _("\n%s: postmaster did not respond within %d seconds\nExamine %s/log/postmaster.log for the reason\n"),
                                        progname, wait_seconds, outputdir);

                        /*
                         * If we get here, the postmaster is probably wedged somewhere in
                         * startup.  Try to kill it ungracefully rather than leaving a
                         * stuck postmaster that might interfere with subsequent test
                         * attempts.
                         */
#ifndef WIN32
                        if (kill(postmaster_pid, SIGKILL) != 0 &&
                                errno != ESRCH)
                                fprintf(stderr, _("\n%s: could not kill failed postmaster: %s\n"),
                                                progname, strerror(errno));
#else
                        if (TerminateProcess(postmaster_pid, 255) == 0)
                                fprintf(stderr, _("\n%s: could not kill failed postmaster: error code %lu\n"),
                                                progname, GetLastError());
#endif

                        exit(2);
                }

                postmaster_running = true;

#ifdef _WIN64
/* need a series of two casts to convert HANDLE without compiler warning */
#define ULONGPID(x) (unsigned long) (unsigned long long) (x)
#else
#define ULONGPID(x) (unsigned long) (x)
#endif
                printf(_("running on port %d with PID %lu\n"),
                           port, ULONGPID(postmaster_pid));
        }
        else
        {
                /*
                 * Using an existing installation, so may need to get rid of
                 * pre-existing database(s) and role(s)
                 */
                if (!use_existing)
                {
                        for (sl = dblist; sl; sl = sl->next)
                                drop_database_if_exists(sl->str);
                        for (sl = extraroles; sl; sl = sl->next)
                                drop_role_if_exists(sl->str);
                }
        }

        /*
         * Create the test database(s) and role(s)
         */
        if (!use_existing)
        {
                for (sl = dblist; sl; sl = sl->next)
                        create_database(sl->str);
                for (sl = extraroles; sl; sl = sl->next)
                        create_role(sl->str, dblist);
        }

        /*
         * Ready to run the tests
         */
        header(_("running regression test queries"));

        for (sl = schedulelist; sl != NULL; sl = sl->next)
        {
                run_schedule(sl->str, startfunc, postfunc);
        }

        for (sl = extra_tests; sl != NULL; sl = sl->next)
        {
                run_single_test(sl->str, startfunc, postfunc);
        }

        /*
         * Shut down temp installation's postmaster
         */
        if (temp_instance)
        {
                header(_("shutting down postmaster"));
                stop_postmaster();
        }

        /*
         * If there were no errors, remove the temp instance immediately to
         * conserve disk space.  (If there were errors, we leave the instance in
         * place for possible manual investigation.)
         */
        if (temp_instance && fail_count == 0 && fail_ignore_count == 0)
        {
                header(_("removing temporary instance"));
                if (!rmtree(temp_instance, true))
                        fprintf(stderr, _("\n%s: could not remove temp instance \"%s\"\n"),
                                        progname, temp_instance);
        }

        fclose(logfile);

        /*
         * Emit nice-looking summary message
         */
        if (fail_count == 0 && fail_ignore_count == 0)
                snprintf(buf, sizeof(buf),
                                 _(" All %d tests passed. "),
                                 success_count);
        else if (fail_count == 0)       /* fail_count=0, fail_ignore_count>0 */
                snprintf(buf, sizeof(buf),
                                 _(" %d of %d tests passed, %d failed test(s) ignored. "),
                                 success_count,
                                 success_count + fail_ignore_count,
                                 fail_ignore_count);
        else if (fail_ignore_count == 0)        /* fail_count>0 && fail_ignore_count=0 */
                snprintf(buf, sizeof(buf),
                                 _(" %d of %d tests failed. "),
                                 fail_count,
                                 success_count + fail_count);
        else
                /* fail_count>0 && fail_ignore_count>0 */
                snprintf(buf, sizeof(buf),
                                 _(" %d of %d tests failed, %d of these failures ignored. "),
                                 fail_count + fail_ignore_count,
                                 success_count + fail_count + fail_ignore_count,
                                 fail_ignore_count);

        putchar('\n');
        for (i = strlen(buf); i > 0; i--)
                putchar('=');
        printf("\n%s\n", buf);
        for (i = strlen(buf); i > 0; i--)
                putchar('=');
        putchar('\n');
        putchar('\n');

        if (file_size(difffilename) > 0)
        {
                printf(_("The differences that caused some tests to fail can be viewed in the\n"
                                 "file \"%s\".  A copy of the test summary that you see\n"
                                 "above is saved in the file \"%s\".\n\n"),
                           difffilename, logfilename);
        }
        else
        {
                unlink(difffilename);
                unlink(logfilename);
        }

        if (fail_count != 0)
                exit(1);

        return 0;
}