PostgreSQL Source Code  git master
pg_regress.c File Reference
#include "postgres_fe.h"
#include <ctype.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <signal.h>
#include <unistd.h>
#include "common/logging.h"
#include "common/restricted_token.h"
#include "common/string.h"
#include "common/username.h"
#include "getopt_long.h"
#include "lib/stringinfo.h"
#include "libpq-fe.h"
#include "libpq/pqcomm.h"
#include "pg_config_paths.h"
#include "pg_regress.h"
#include "portability/instr_time.h"
Include dependency graph for pg_regress.c:

Go to the source code of this file.

Data Structures

struct  _resultmap
 

Macros

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

Typedefs

typedef struct _resultmap _resultmap
 
typedef enum TAPtype TAPtype
 

Enumerations

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

Functions

static bool directory_exists (const char *dir)
 
static void make_directory (const char *dir)
 
static void test_status_print (bool ok, const char *testname, double runtime, bool parallel)
 
static void test_status_ok (const char *testname, double runtime, bool parallel)
 
static void test_status_failed (const char *testname, double runtime, bool parallel)
 
static void bail_out (bool noatexit, const char *fmt,...) pg_attribute_printf(2
 
static void static void emit_tap_output (TAPtype type, const char *fmt,...) pg_attribute_printf(2
 
static void static void static void emit_tap_output_v (TAPtype type, const char *fmt, va_list argp) pg_attribute_printf(2
 
static void static void static void static StringInfo psql_start_command (void)
 
static void psql_add_command (StringInfo buf, const char *query,...) pg_attribute_printf(2
 
static void static void psql_end_command (StringInfo buf, const char *database)
 
static void unlimit_core_size (void)
 
void add_stringlist_item (_stringlist **listhead, const char *str)
 
static void free_stringlist (_stringlist **listhead)
 
static void split_to_stringlist (const char *s, const char *delim, _stringlist **listhead)
 
static void stop_postmaster (void)
 
static void remove_temp (void)
 
static void signal_remove_temp (SIGNAL_ARGS)
 
static const char * make_temp_sockdir (void)
 
static bool string_matches_pattern (const char *str, const char *pattern)
 
static void load_resultmap (void)
 
static const char * get_expectfile (const char *testname, const char *file)
 
static void initialize_environment (void)
 
PID_TYPE spawn_process (const char *cmdline)
 
static long file_size (const char *file)
 
static int file_line_count (const char *file)
 
bool file_exists (const char *file)
 
static char * get_alternative_expectfile (const char *expectfile, int i)
 
static int run_diff (const char *cmd, const char *filename)
 
static bool results_differ (const char *testname, const char *resultsfile, const char *default_expectfile)
 
static void wait_for_tests (PID_TYPE *pids, int *statuses, instr_time *stoptimes, char **names, int num_tests)
 
static void log_child_failure (int exitstatus)
 
static void run_schedule (const char *schedule, test_start_function startfunc, postprocess_result_function postfunc)
 
static void run_single_test (const char *test, test_start_function startfunc, postprocess_result_function postfunc)
 
static void open_result_files (void)
 
static void drop_database_if_exists (const char *dbname)
 
static void create_database (const char *dbname)
 
static void drop_role_if_exists (const char *rolename)
 
static void create_role (const char *rolename, const _stringlist *granted_dbs)
 
static void help (void)
 
int regression_main (int argc, char *argv[], init_function ifunc, test_start_function startfunc, postprocess_result_function postfunc)
 

Variables

char * host_platform = HOST_TUPLE
 
static char * shellprog = SHELLPROG
 
const char * basic_diff_opts = ""
 
const char * pretty_diff_opts = "-U3"
 
_stringlistdblist = NULL
 
bool debug = false
 
char * inputdir = "."
 
char * outputdir = "."
 
char * expecteddir = "."
 
char * bindir = PGBINDIR
 
char * launcher = NULL
 
static _stringlistloadextension = NULL
 
static int max_connections = 0
 
static int max_concurrent_tests = 0
 
static char * encoding = NULL
 
static _stringlistschedulelist = NULL
 
static _stringlistextra_tests = NULL
 
static char * temp_instance = NULL
 
static _stringlisttemp_configs = NULL
 
static bool nolocale = false
 
static bool use_existing = false
 
static char * hostname = NULL
 
static int port = -1
 
static char portstr [16]
 
static bool port_specified_by_user = false
 
static char * dlpath = PKGLIBDIR
 
static char * user = NULL
 
static _stringlistextraroles = NULL
 
static char * config_auth_datadir = NULL
 
static const char * progname
 
static char * logfilename
 
static FILE * logfile
 
static char * difffilename
 
static const char * sockdir
 
static const char * temp_sockdir
 
static char sockself [MAXPGPATH]
 
static char socklock [MAXPGPATH]
 
static StringInfo failed_tests = NULL
 
static bool in_note = false
 
static _resultmapresultmap = NULL
 
static PID_TYPE postmaster_pid = INVALID_PID
 
static bool postmaster_running = false
 
static int success_count = 0
 
static int fail_count = 0
 

Macro Definition Documentation

◆ bail

#define bail (   ...)    bail_out(false, __VA_ARGS__)

Definition at line 168 of file pg_regress.c.

◆ bail_noatexit

#define bail_noatexit (   ...)    bail_out(true, __VA_ARGS__)

Definition at line 167 of file pg_regress.c.

◆ diag

#define diag (   ...)    emit_tap_output(DIAG, __VA_ARGS__)

Definition at line 165 of file pg_regress.c.

◆ MAX_PARALLEL_TESTS

#define MAX_PARALLEL_TESTS   100

◆ note

#define note (   ...)    emit_tap_output(NOTE, __VA_ARGS__)

Definition at line 163 of file pg_regress.c.

◆ note_detail

#define note_detail (   ...)    emit_tap_output(NOTE_DETAIL, __VA_ARGS__)

Definition at line 164 of file pg_regress.c.

◆ note_end

#define note_end ( )    emit_tap_output(NOTE_END, "\n");

Definition at line 166 of file pg_regress.c.

◆ plan

#define plan (   x)    emit_tap_output(PLAN, "1..%i", (x))

Definition at line 162 of file pg_regress.c.

◆ psql_command

#define psql_command (   database,
  ... 
)
Value:
do { \
StringInfo cmdbuf = psql_start_command(); \
psql_add_command(cmdbuf, __VA_ARGS__); \
psql_end_command(cmdbuf, database); \
} while (0)
static void static void static void static StringInfo psql_start_command(void)
Definition: pg_regress.c:1112

Definition at line 1184 of file pg_regress.c.

◆ TESTNAME_WIDTH

#define TESTNAME_WIDTH   36

Definition at line 77 of file pg_regress.c.

◆ ULONGPID

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

◆ WAIT_TICKS_PER_SECOND

#define WAIT_TICKS_PER_SECOND   20

Definition at line 83 of file pg_regress.c.

Typedef Documentation

◆ _resultmap

typedef struct _resultmap _resultmap

◆ TAPtype

typedef enum TAPtype TAPtype

Enumeration Type Documentation

◆ TAPtype

enum TAPtype
Enumerator
DIAG 
BAIL 
NOTE 
NOTE_DETAIL 
NOTE_END 
TEST_STATUS 
PLAN 
NONE 

Definition at line 85 of file pg_regress.c.

86 {
87  DIAG = 0,
88  BAIL,
89  NOTE,
91  NOTE_END,
93  PLAN,
94  NONE,
95 } TAPtype;
TAPtype
Definition: pg_regress.c:86
@ PLAN
Definition: pg_regress.c:93
@ NOTE
Definition: pg_regress.c:89
@ DIAG
Definition: pg_regress.c:87
@ NOTE_DETAIL
Definition: pg_regress.c:90
@ NONE
Definition: pg_regress.c:94
@ TEST_STATUS
Definition: pg_regress.c:92
@ BAIL
Definition: pg_regress.c:88
@ NOTE_END
Definition: pg_regress.c:91

Function Documentation

◆ add_stringlist_item()

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

Definition at line 198 of file pg_regress.c.

199 {
200  _stringlist *newentry = pg_malloc(sizeof(_stringlist));
201  _stringlist *oldentry;
202 
203  newentry->str = pg_strdup(str);
204  newentry->next = NULL;
205  if (*listhead == NULL)
206  *listhead = newentry;
207  else
208  {
209  for (oldentry = *listhead; oldentry->next; oldentry = oldentry->next)
210  /* skip */ ;
211  oldentry->next = newentry;
212  }
213 }
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
char * str
Definition: initdb.c:92
struct _stringlist * next
Definition: initdb.c:93

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

Referenced by regression_main(), and split_to_stringlist().

◆ bail_out()

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

Definition at line 254 of file pg_regress.c.

255 {
256  va_list ap;
257 
258  va_start(ap, fmt);
259  emit_tap_output_v(BAIL, fmt, ap);
260  va_end(ap);
261 
262  if (noatexit)
263  _exit(2);
264 
265  exit(2);
266 }
static void const char * fmt
va_end(args)
exit(1)
va_start(args, fmt)
static void static void static void emit_tap_output_v(TAPtype type, const char *fmt, va_list argp) pg_attribute_printf(2
Definition: pg_regress.c:340

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

Referenced by ProcessConfigFileInternal().

◆ create_database()

static void create_database ( const char *  dbname)
static

Definition at line 1970 of file pg_regress.c.

1971 {
1973  _stringlist *sl;
1974 
1975  /*
1976  * We use template0 so that any installation-local cruft in template1 will
1977  * not mess up the tests.
1978  */
1979  if (encoding)
1980  psql_add_command(buf, "CREATE DATABASE \"%s\" TEMPLATE=template0 ENCODING='%s'%s", dbname, encoding,
1981  (nolocale) ? " LOCALE='C'" : "");
1982  else
1983  psql_add_command(buf, "CREATE DATABASE \"%s\" TEMPLATE=template0%s", dbname,
1984  (nolocale) ? " LOCALE='C'" : "");
1986  "ALTER DATABASE \"%s\" SET lc_messages TO 'C';"
1987  "ALTER DATABASE \"%s\" SET lc_monetary TO 'C';"
1988  "ALTER DATABASE \"%s\" SET lc_numeric TO 'C';"
1989  "ALTER DATABASE \"%s\" SET lc_time TO 'C';"
1990  "ALTER DATABASE \"%s\" SET bytea_output TO 'hex';"
1991  "ALTER DATABASE \"%s\" SET timezone_abbreviations TO 'Default';",
1993  psql_end_command(buf, "postgres");
1994 
1995  /*
1996  * Install any requested extensions. We use CREATE IF NOT EXISTS so that
1997  * this will work whether or not the extension is preinstalled.
1998  */
1999  for (sl = loadextension; sl != NULL; sl = sl->next)
2000  psql_command(dbname, "CREATE EXTENSION IF NOT EXISTS \"%s\"", sl->str);
2001 }
static bool nolocale
Definition: pg_regress.c:113
static void psql_add_command(StringInfo buf, const char *query,...) pg_attribute_printf(2
Definition: pg_regress.c:1124
static void static void psql_end_command(StringInfo buf, const char *database)
Definition: pg_regress.c:1161
static _stringlist * loadextension
Definition: pg_regress.c:105
static char * encoding
Definition: pg_regress.c:108
#define psql_command(database,...)
Definition: pg_regress.c:1184
static char * buf
Definition: pg_test_fsync.c:73
char * dbname
Definition: streamutil.c:51

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

Referenced by regression_main().

◆ create_role()

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

Definition at line 2015 of file pg_regress.c.

2016 {
2018 
2019  psql_add_command(buf, "CREATE ROLE \"%s\" WITH LOGIN", rolename);
2020  for (; granted_dbs != NULL; granted_dbs = granted_dbs->next)
2021  {
2022  psql_add_command(buf, "GRANT ALL ON DATABASE \"%s\" TO \"%s\"",
2023  granted_dbs->str, rolename);
2024  }
2025  psql_end_command(buf, "postgres");
2026 }

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

Referenced by regression_main().

◆ directory_exists()

static bool directory_exists ( const char *  dir)
static

Definition at line 1313 of file pg_regress.c.

1314 {
1315  struct stat st;
1316 
1317  if (stat(dir, &st) != 0)
1318  return false;
1319  if (S_ISDIR(st.st_mode))
1320  return true;
1321  return false;
1322 }
#define stat
Definition: win32_port.h:284
#define S_ISDIR(m)
Definition: win32_port.h:325

References S_ISDIR, stat::st_mode, and stat.

Referenced by open_result_files(), and regression_main().

◆ drop_database_if_exists()

static void drop_database_if_exists ( const char *  dbname)
static

Definition at line 1959 of file pg_regress.c.

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

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

Referenced by regression_main().

◆ drop_role_if_exists()

static void drop_role_if_exists ( const char *  rolename)
static

Definition at line 2004 of file pg_regress.c.

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

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

Referenced by regression_main().

◆ emit_tap_output()

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

Definition at line 330 of file pg_regress.c.

331 {
332  va_list argp;
333 
334  va_start(argp, fmt);
335  emit_tap_output_v(type, fmt, argp);
336  va_end(argp);
337 }
const char * type

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

Referenced by test_status_print().

◆ emit_tap_output_v()

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

Definition at line 340 of file pg_regress.c.

341 {
342  va_list argp_logfile;
343  FILE *fp;
344 
345  /*
346  * Diagnostic output will be hidden by prove unless printed to stderr. The
347  * Bail message is also printed to stderr to aid debugging under a harness
348  * which might otherwise not emit such an important message.
349  */
350  if (type == DIAG || type == BAIL)
351  fp = stderr;
352  else
353  fp = stdout;
354 
355  /*
356  * If we are ending a note_detail line we can avoid further processing and
357  * immediately return following a newline.
358  */
359  if (type == NOTE_END)
360  {
361  in_note = false;
362  fprintf(fp, "\n");
363  if (logfile)
364  fprintf(logfile, "\n");
365  return;
366  }
367 
368  /* Make a copy of the va args for printing to the logfile */
369  va_copy(argp_logfile, argp);
370 
371  /*
372  * Non-protocol output such as diagnostics or notes must be prefixed by a
373  * '#' character. We print the Bail message like this too.
374  */
375  if ((type == NOTE || type == DIAG || type == BAIL)
376  || (type == NOTE_DETAIL && !in_note))
377  {
378  fprintf(fp, "# ");
379  if (logfile)
380  fprintf(logfile, "# ");
381  }
382  vfprintf(fp, fmt, argp);
383  if (logfile)
384  vfprintf(logfile, fmt, argp_logfile);
385 
386  /*
387  * If we are entering into a note with more details to follow, register
388  * that the leading '#' has been printed such that subsequent details
389  * aren't prefixed as well.
390  */
391  if (type == NOTE_DETAIL)
392  in_note = true;
393 
394  /*
395  * If this was a Bail message, the bail protocol message must go to stdout
396  * separately.
397  */
398  if (type == BAIL)
399  {
400  fprintf(stdout, "Bail out!");
401  if (logfile)
402  fprintf(logfile, "Bail out!");
403  }
404 
405  va_end(argp_logfile);
406 
407  if (type != NOTE_DETAIL)
408  {
409  fprintf(fp, "\n");
410  if (logfile)
411  fprintf(logfile, "\n");
412  }
413  fflush(NULL);
414 }
static void const char fflush(stdout)
vfprintf(stderr, fmt, args)
static bool in_note
Definition: pg_regress.c:134
static FILE * logfile
Definition: pg_regress.c:127
#define fprintf
Definition: port.h:242

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

Referenced by bail_out(), and emit_tap_output().

◆ file_exists()

bool file_exists ( const char *  file)

Definition at line 1302 of file pg_regress.c.

1303 {
1304  FILE *f = fopen(file, "r");
1305 
1306  if (!f)
1307  return false;
1308  fclose(f);
1309  return true;
1310 }

Referenced by results_differ().

◆ file_line_count()

static int file_line_count ( const char *  file)
static

Definition at line 1280 of file pg_regress.c.

1281 {
1282  int c;
1283  int l = 0;
1284  FILE *f = fopen(file, "r");
1285 
1286  if (!f)
1287  {
1288  diag("could not open file \"%s\" for reading: %s",
1289  file, strerror(errno));
1290  return -1;
1291  }
1292  while ((c = fgetc(f)) != EOF)
1293  {
1294  if (c == '\n')
1295  l++;
1296  }
1297  fclose(f);
1298  return l;
1299 }
#define diag(...)
Definition: pg_regress.c:165
#define strerror
Definition: port.h:251
char * c

References diag, and strerror.

Referenced by results_differ().

◆ file_size()

static long file_size ( const char *  file)
static

Definition at line 1259 of file pg_regress.c.

1260 {
1261  long r;
1262  FILE *f = fopen(file, "r");
1263 
1264  if (!f)
1265  {
1266  diag("could not open file \"%s\" for reading: %s",
1267  file, strerror(errno));
1268  return -1;
1269  }
1270  fseek(f, 0, SEEK_END);
1271  r = ftell(f);
1272  fclose(f);
1273  return r;
1274 }

References diag, and strerror.

Referenced by regression_main(), and run_diff().

◆ free_stringlist()

static void free_stringlist ( _stringlist **  listhead)
static

Definition at line 219 of file pg_regress.c.

220 {
221  if (listhead == NULL || *listhead == NULL)
222  return;
223  if ((*listhead)->next != NULL)
224  free_stringlist(&((*listhead)->next));
225  free((*listhead)->str);
226  free(*listhead);
227  *listhead = NULL;
228 }
#define free(a)
Definition: header.h:65
static void free_stringlist(_stringlist **listhead)
Definition: pg_regress.c:219

References free.

Referenced by regression_main(), and run_schedule().

◆ get_alternative_expectfile()

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

Definition at line 1338 of file pg_regress.c.

1339 {
1340  char *last_dot;
1341  int ssize = strlen(expectfile) + 2 + 1;
1342  char *tmp;
1343  char *s;
1344 
1345  if (!(tmp = (char *) malloc(ssize)))
1346  return NULL;
1347 
1348  if (!(s = (char *) malloc(ssize)))
1349  {
1350  free(tmp);
1351  return NULL;
1352  }
1353 
1354  strcpy(tmp, expectfile);
1355  last_dot = strrchr(tmp, '.');
1356  if (!last_dot)
1357  {
1358  free(tmp);
1359  free(s);
1360  return NULL;
1361  }
1362  *last_dot = '\0';
1363  snprintf(s, ssize, "%s_%d.%s", tmp, i, last_dot + 1);
1364  free(tmp);
1365  return s;
1366 }
#define malloc(a)
Definition: header.h:50
int i
Definition: isn.c:73
#define snprintf
Definition: port.h:238

References free, i, malloc, and snprintf.

Referenced by results_differ().

◆ get_expectfile()

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

Definition at line 681 of file pg_regress.c.

682 {
683  char *file_type;
684  _resultmap *rm;
685 
686  /*
687  * Determine the file type from the file name. This is just what is
688  * following the last dot in the file name.
689  */
690  if (!file || !(file_type = strrchr(file, '.')))
691  return NULL;
692 
693  file_type++;
694 
695  for (rm = resultmap; rm != NULL; rm = rm->next)
696  {
697  if (strcmp(testname, rm->test) == 0 && strcmp(file_type, rm->type) == 0)
698  {
699  return rm->resultfile;
700  }
701  }
702 
703  return NULL;
704 }
static _resultmap * resultmap
Definition: pg_regress.c:136
char * resultfile
Definition: pg_regress.c:46
struct _resultmap * next
Definition: pg_regress.c:47
char * test
Definition: pg_regress.c:44
char * type
Definition: pg_regress.c:45

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

Referenced by results_differ().

◆ help()

static void help ( void  )
static

Definition at line 2029 of file pg_regress.c.

2030 {
2031  printf(_("PostgreSQL regression test driver\n"));
2032  printf(_("\n"));
2033  printf(_("Usage:\n %s [OPTION]... [EXTRA-TEST]...\n"), progname);
2034  printf(_("\n"));
2035  printf(_("Options:\n"));
2036  printf(_(" --bindir=BINPATH use BINPATH for programs that are run;\n"));
2037  printf(_(" if empty, use PATH from the environment\n"));
2038  printf(_(" --config-auth=DATADIR update authentication settings for DATADIR\n"));
2039  printf(_(" --create-role=ROLE create the specified role before testing\n"));
2040  printf(_(" --dbname=DB use database DB (default \"regression\")\n"));
2041  printf(_(" --debug turn on debug mode in programs that are run\n"));
2042  printf(_(" --dlpath=DIR look for dynamic libraries in DIR\n"));
2043  printf(_(" --encoding=ENCODING use ENCODING as the encoding\n"));
2044  printf(_(" --expecteddir=DIR take expected files from DIR (default \".\")\n"));
2045  printf(_(" -h, --help show this help, then exit\n"));
2046  printf(_(" --inputdir=DIR take input files from DIR (default \".\")\n"));
2047  printf(_(" --launcher=CMD use CMD as launcher of psql\n"));
2048  printf(_(" --load-extension=EXT load the named extension before running the\n"));
2049  printf(_(" tests; can appear multiple times\n"));
2050  printf(_(" --max-connections=N maximum number of concurrent connections\n"));
2051  printf(_(" (default is 0, meaning unlimited)\n"));
2052  printf(_(" --max-concurrent-tests=N maximum number of concurrent tests in schedule\n"));
2053  printf(_(" (default is 0, meaning unlimited)\n"));
2054  printf(_(" --outputdir=DIR place output files in DIR (default \".\")\n"));
2055  printf(_(" --schedule=FILE use test ordering schedule from FILE\n"));
2056  printf(_(" (can be used multiple times to concatenate)\n"));
2057  printf(_(" --temp-instance=DIR create a temporary instance in DIR\n"));
2058  printf(_(" --use-existing use an existing installation\n"));
2059  printf(_(" -V, --version output version information, then exit\n"));
2060  printf(_("\n"));
2061  printf(_("Options for \"temp-instance\" mode:\n"));
2062  printf(_(" --no-locale use C locale\n"));
2063  printf(_(" --port=PORT start postmaster on PORT\n"));
2064  printf(_(" --temp-config=FILE append contents of FILE to temporary config\n"));
2065  printf(_("\n"));
2066  printf(_("Options for using an existing installation:\n"));
2067  printf(_(" --host=HOST use postmaster running on HOST\n"));
2068  printf(_(" --port=PORT use postmaster running at PORT\n"));
2069  printf(_(" --user=USER connect as USER\n"));
2070  printf(_("\n"));
2071  printf(_("The exit status is 0 if all tests passed, 1 if some tests failed, and 2\n"));
2072  printf(_("if the tests could not be run for some reason.\n"));
2073  printf(_("\n"));
2074  printf(_("Report bugs to <%s>.\n"), PACKAGE_BUGREPORT);
2075  printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
2076 }
#define _(x)
Definition: elog.c:91
static const char * progname
Definition: pg_regress.c:125
#define printf(...)
Definition: port.h:244

References _, printf, and progname.

Referenced by regression_main().

◆ initialize_environment()

static void initialize_environment ( void  )
static

Definition at line 710 of file pg_regress.c.

711 {
712  /*
713  * Set default application_name. (The test_start_function may choose to
714  * override this, but if it doesn't, we have something useful in place.)
715  */
716  setenv("PGAPPNAME", "pg_regress", 1);
717 
718  /*
719  * Set variables that the test scripts may need to refer to.
720  */
721  setenv("PG_ABS_SRCDIR", inputdir, 1);
722  setenv("PG_ABS_BUILDDIR", outputdir, 1);
723  setenv("PG_LIBDIR", dlpath, 1);
724  setenv("PG_DLSUFFIX", DLSUFFIX, 1);
725 
726  if (nolocale)
727  {
728  /*
729  * Clear out any non-C locale settings
730  */
731  unsetenv("LC_COLLATE");
732  unsetenv("LC_CTYPE");
733  unsetenv("LC_MONETARY");
734  unsetenv("LC_NUMERIC");
735  unsetenv("LC_TIME");
736  unsetenv("LANG");
737 
738  /*
739  * Most platforms have adopted the POSIX locale as their
740  * implementation-defined default locale. Exceptions include native
741  * Windows, macOS with --enable-nls, and Cygwin with --enable-nls.
742  * (Use of --enable-nls matters because libintl replaces setlocale().)
743  * Also, PostgreSQL does not support macOS with locale environment
744  * variables unset; see PostmasterMain().
745  */
746 #if defined(WIN32) || defined(__CYGWIN__) || defined(__darwin__)
747  setenv("LANG", "C", 1);
748 #endif
749  }
750 
751  /*
752  * Set translation-related settings to English; otherwise psql will
753  * produce translated messages and produce diffs. (XXX If we ever support
754  * translation of pg_regress, this needs to be moved elsewhere, where psql
755  * is actually called.)
756  */
757  unsetenv("LANGUAGE");
758  unsetenv("LC_ALL");
759  setenv("LC_MESSAGES", "C", 1);
760 
761  /*
762  * Set encoding as requested
763  */
764  if (encoding)
765  setenv("PGCLIENTENCODING", encoding, 1);
766  else
767  unsetenv("PGCLIENTENCODING");
768 
769  /*
770  * Set timezone and datestyle for datetime-related tests
771  */
772  setenv("PGTZ", "PST8PDT", 1);
773  setenv("PGDATESTYLE", "Postgres, MDY", 1);
774 
775  /*
776  * Likewise set intervalstyle to ensure consistent results. This is a bit
777  * more painful because we must use PGOPTIONS, and we want to preserve the
778  * user's ability to set other variables through that.
779  */
780  {
781  const char *my_pgoptions = "-c intervalstyle=postgres_verbose";
782  const char *old_pgoptions = getenv("PGOPTIONS");
783  char *new_pgoptions;
784 
785  if (!old_pgoptions)
786  old_pgoptions = "";
787  new_pgoptions = psprintf("%s %s",
788  old_pgoptions, my_pgoptions);
789  setenv("PGOPTIONS", new_pgoptions, 1);
790  free(new_pgoptions);
791  }
792 
793  if (temp_instance)
794  {
795  /*
796  * Clear out any environment vars that might cause psql to connect to
797  * the wrong postmaster, or otherwise behave in nondefault ways. (Note
798  * we also use psql's -X switch consistently, so that ~/.psqlrc files
799  * won't mess things up.) Also, set PGPORT to the temp port, and set
800  * PGHOST depending on whether we are using TCP or Unix sockets.
801  *
802  * This list should be kept in sync with PostgreSQL/Test/Utils.pm.
803  */
804  unsetenv("PGCHANNELBINDING");
805  /* PGCLIENTENCODING, see above */
806  unsetenv("PGCONNECT_TIMEOUT");
807  unsetenv("PGDATA");
808  unsetenv("PGDATABASE");
809  unsetenv("PGGSSDELEGATION");
810  unsetenv("PGGSSENCMODE");
811  unsetenv("PGGSSLIB");
812  /* PGHOSTADDR, see below */
813  unsetenv("PGKRBSRVNAME");
814  unsetenv("PGPASSFILE");
815  unsetenv("PGPASSWORD");
816  unsetenv("PGREQUIREPEER");
817  unsetenv("PGREQUIRESSL");
818  unsetenv("PGSERVICE");
819  unsetenv("PGSERVICEFILE");
820  unsetenv("PGSSLCERT");
821  unsetenv("PGSSLCRL");
822  unsetenv("PGSSLCRLDIR");
823  unsetenv("PGSSLKEY");
824  unsetenv("PGSSLMAXPROTOCOLVERSION");
825  unsetenv("PGSSLMINPROTOCOLVERSION");
826  unsetenv("PGSSLMODE");
827  unsetenv("PGSSLROOTCERT");
828  unsetenv("PGSSLSNI");
829  unsetenv("PGTARGETSESSIONATTRS");
830  unsetenv("PGUSER");
831  /* PGPORT, see below */
832  /* PGHOST, see below */
833 
834  if (hostname != NULL)
835  setenv("PGHOST", hostname, 1);
836  else
837  {
838  sockdir = getenv("PG_REGRESS_SOCK_DIR");
839  if (!sockdir)
841  setenv("PGHOST", sockdir, 1);
842  }
843  unsetenv("PGHOSTADDR");
844  if (port != -1)
845  {
846  char s[16];
847 
848  snprintf(s, sizeof(s), "%d", port);
849  setenv("PGPORT", s, 1);
850  }
851  }
852  else
853  {
854  const char *pghost;
855  const char *pgport;
856 
857  /*
858  * When testing an existing install, we honor existing environment
859  * variables, except if they're overridden by command line options.
860  */
861  if (hostname != NULL)
862  {
863  setenv("PGHOST", hostname, 1);
864  unsetenv("PGHOSTADDR");
865  }
866  if (port != -1)
867  {
868  char s[16];
869 
870  snprintf(s, sizeof(s), "%d", port);
871  setenv("PGPORT", s, 1);
872  }
873  if (user != NULL)
874  setenv("PGUSER", user, 1);
875 
876  /*
877  * However, we *don't* honor PGDATABASE, since we certainly don't wish
878  * to connect to whatever database the user might like as default.
879  * (Most tests override PGDATABASE anyway, but there are some ECPG
880  * test cases that don't.)
881  */
882  unsetenv("PGDATABASE");
883 
884  /*
885  * Report what we're connecting to
886  */
887  pghost = getenv("PGHOST");
888  pgport = getenv("PGPORT");
889  if (!pghost)
890  {
891  /* Keep this bit in sync with libpq's default host location: */
892  if (DEFAULT_PGSOCKET_DIR[0])
893  /* do nothing, we'll print "Unix socket" below */ ;
894  else
895  pghost = "localhost"; /* DefaultHost in fe-connect.c */
896  }
897 
898  if (pghost && pgport)
899  note("using postmaster on %s, port %s", pghost, pgport);
900  if (pghost && !pgport)
901  note("using postmaster on %s, default port", pghost);
902  if (!pghost && pgport)
903  note("using postmaster on Unix socket, port %s", pgport);
904  if (!pghost && !pgport)
905  note("using postmaster on Unix socket, default port");
906  }
907 
908  load_resultmap();
909 }
#define DEFAULT_PGSOCKET_DIR
static char * user
Definition: pg_regress.c:120
static void load_resultmap(void)
Definition: pg_regress.c:606
static int port
Definition: pg_regress.c:116
char * outputdir
Definition: pg_regress.c:101
#define note(...)
Definition: pg_regress.c:163
char * inputdir
Definition: pg_regress.c:100
static char * temp_instance
Definition: pg_regress.c:111
static const char * sockdir
Definition: pg_regress.c:129
static char * dlpath
Definition: pg_regress.c:119
static const char * make_temp_sockdir(void)
Definition: pg_regress.c:488
static char * hostname
Definition: pg_regress.c:115
const char * pghost
Definition: pgbench.c:294
const char * pgport
Definition: pgbench.c:295
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
#define unsetenv(x)
Definition: win32_port.h:538
#define setenv(x, y, z)
Definition: win32_port.h:537

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

Referenced by regression_main().

◆ load_resultmap()

static void load_resultmap ( void  )
static

Definition at line 606 of file pg_regress.c.

607 {
608  char buf[MAXPGPATH];
609  FILE *f;
610 
611  /* scan the file ... */
612  snprintf(buf, sizeof(buf), "%s/resultmap", inputdir);
613  f = fopen(buf, "r");
614  if (!f)
615  {
616  /* OK if it doesn't exist, else complain */
617  if (errno == ENOENT)
618  return;
619  bail("could not open file \"%s\" for reading: %s",
620  buf, strerror(errno));
621  }
622 
623  while (fgets(buf, sizeof(buf), f))
624  {
625  char *platform;
626  char *file_type;
627  char *expected;
628  int i;
629 
630  /* strip trailing whitespace, especially the newline */
631  i = strlen(buf);
632  while (i > 0 && isspace((unsigned char) buf[i - 1]))
633  buf[--i] = '\0';
634 
635  /* parse out the line fields */
636  file_type = strchr(buf, ':');
637  if (!file_type)
638  {
639  bail("incorrectly formatted resultmap entry: %s", buf);
640  }
641  *file_type++ = '\0';
642 
643  platform = strchr(file_type, ':');
644  if (!platform)
645  {
646  bail("incorrectly formatted resultmap entry: %s", buf);
647  }
648  *platform++ = '\0';
649  expected = strchr(platform, '=');
650  if (!expected)
651  {
652  bail("incorrectly formatted resultmap entry: %s", buf);
653  }
654  *expected++ = '\0';
655 
656  /*
657  * if it's for current platform, save it in resultmap list. Note: by
658  * adding at the front of the list, we ensure that in ambiguous cases,
659  * the last match in the resultmap file is used. This mimics the
660  * behavior of the old shell script.
661  */
662  if (string_matches_pattern(host_platform, platform))
663  {
664  _resultmap *entry = pg_malloc(sizeof(_resultmap));
665 
666  entry->test = pg_strdup(buf);
667  entry->type = pg_strdup(file_type);
668  entry->resultfile = pg_strdup(expected);
669  entry->next = resultmap;
670  resultmap = entry;
671  }
672  }
673  fclose(f);
674 }
#define MAXPGPATH
char * host_platform
Definition: pg_regress.c:53
#define bail(...)
Definition: pg_regress.c:168
static bool string_matches_pattern(const char *str, const char *pattern)
Definition: pg_regress.c:532

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

Referenced by initialize_environment().

◆ log_child_failure()

static void log_child_failure ( int  exitstatus)
static

Definition at line 1622 of file pg_regress.c.

1623 {
1624  if (WIFEXITED(exitstatus))
1625  diag("(test process exited with exit code %d)",
1626  WEXITSTATUS(exitstatus));
1627  else if (WIFSIGNALED(exitstatus))
1628  {
1629 #if defined(WIN32)
1630  diag("(test process was terminated by exception 0x%X)",
1631  WTERMSIG(exitstatus));
1632 #else
1633  diag("(test process was terminated by signal %d: %s)",
1634  WTERMSIG(exitstatus), pg_strsignal(WTERMSIG(exitstatus)));
1635 #endif
1636  }
1637  else
1638  diag("(test process exited with unrecognized status %d)", exitstatus);
1639 }
const char * pg_strsignal(int signum)
Definition: pgstrsignal.c:42
#define WIFEXITED(w)
Definition: win32_port.h:152
#define WIFSIGNALED(w)
Definition: win32_port.h:153
#define WTERMSIG(w)
Definition: win32_port.h:155
#define WEXITSTATUS(w)
Definition: win32_port.h:154

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

Referenced by run_schedule(), and run_single_test().

◆ make_directory()

static void make_directory ( const char *  dir)
static

Definition at line 1326 of file pg_regress.c.

1327 {
1328  if (mkdir(dir, S_IRWXU | S_IRWXG | S_IRWXO) < 0)
1329  {
1330  bail("could not create directory \"%s\": %s", dir, strerror(errno));
1331  }
1332 }
#define S_IRWXG
Definition: win32_port.h:310
#define S_IRWXO
Definition: win32_port.h:322
#define mkdir(a, b)
Definition: win32_port.h:80
#define S_IRWXU
Definition: win32_port.h:298

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

Referenced by open_result_files(), and regression_main().

◆ make_temp_sockdir()

static const char* make_temp_sockdir ( void  )
static

Definition at line 488 of file pg_regress.c.

489 {
490  char *template = psprintf("%s/pg_regress-XXXXXX",
491  getenv("TMPDIR") ? getenv("TMPDIR") : "/tmp");
492 
493  temp_sockdir = mkdtemp(template);
494  if (temp_sockdir == NULL)
495  {
496  bail("could not create directory \"%s\": %s",
497  template, strerror(errno));
498  }
499 
500  /* Stage file names for remove_temp(). Unsafe in a signal handler. */
502  snprintf(socklock, sizeof(socklock), "%s.lock", sockself);
503 
504  /* Remove the directory during clean exit. */
505  atexit(remove_temp);
506 
507  /*
508  * Remove the directory before dying to the usual signals. Omit SIGQUIT,
509  * preserving it as a quick, untidy exit.
510  */
512  pqsignal(SIGINT, signal_remove_temp);
514  pqsignal(SIGTERM, signal_remove_temp);
515 
516  return temp_sockdir;
517 }
static void signal_remove_temp(SIGNAL_ARGS)
Definition: pg_regress.c:467
static void remove_temp(void)
Definition: pg_regress.c:455
static const char * temp_sockdir
Definition: pg_regress.c:130
static char sockself[MAXPGPATH]
Definition: pg_regress.c:131
static char socklock[MAXPGPATH]
Definition: pg_regress.c:132
pqsigfunc pqsignal(int signo, pqsigfunc func)
char * mkdtemp(char *path)
Definition: mkdtemp.c:286
#define UNIXSOCK_PATH(path, port, sockdir)
Definition: pqcomm.h:44
#define SIGHUP
Definition: win32_port.h:168
#define SIGPIPE
Definition: win32_port.h:173

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

Referenced by initialize_environment().

◆ open_result_files()

static void open_result_files ( void  )
static

Definition at line 1921 of file pg_regress.c.

1922 {
1923  char file[MAXPGPATH];
1924  FILE *difffile;
1925 
1926  /* create outputdir directory if not present */
1929 
1930  /* create the log file (copy of running status output) */
1931  snprintf(file, sizeof(file), "%s/regression.out", outputdir);
1932  logfilename = pg_strdup(file);
1933  logfile = fopen(logfilename, "w");
1934  if (!logfile)
1935  {
1936  bail("could not open file \"%s\" for writing: %s",
1937  logfilename, strerror(errno));
1938  }
1939 
1940  /* create the diffs file as empty */
1941  snprintf(file, sizeof(file), "%s/regression.diffs", outputdir);
1942  difffilename = pg_strdup(file);
1943  difffile = fopen(difffilename, "w");
1944  if (!difffile)
1945  {
1946  bail("could not open file \"%s\" for writing: %s",
1947  difffilename, strerror(errno));
1948  }
1949  /* we don't keep the diffs file open continuously */
1950  fclose(difffile);
1951 
1952  /* also create the results directory if not present */
1953  snprintf(file, sizeof(file), "%s/results", outputdir);
1954  if (!directory_exists(file))
1955  make_directory(file);
1956 }
static bool directory_exists(const char *dir)
Definition: pg_regress.c:1313
static char * logfilename
Definition: pg_regress.c:126
static void make_directory(const char *dir)
Definition: pg_regress.c:1326
static char * difffilename
Definition: pg_regress.c:128

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

Referenced by regression_main().

◆ psql_add_command()

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

Definition at line 1124 of file pg_regress.c.

1125 {
1126  StringInfoData cmdbuf;
1127  const char *cmdptr;
1128 
1129  /* Add each command as a -c argument in the psql call */
1130  appendStringInfoString(buf, " -c \"");
1131 
1132  /* Generate the query with insertion of sprintf arguments */
1133  initStringInfo(&cmdbuf);
1134  for (;;)
1135  {
1136  va_list args;
1137  int needed;
1138 
1139  va_start(args, query);
1140  needed = appendStringInfoVA(&cmdbuf, query, args);
1141  va_end(args);
1142  if (needed == 0)
1143  break; /* success */
1144  enlargeStringInfo(&cmdbuf, needed);
1145  }
1146 
1147  /* Now escape any shell double-quote metacharacters */
1148  for (cmdptr = cmdbuf.data; *cmdptr; cmdptr++)
1149  {
1150  if (strchr("\\\"$`", *cmdptr))
1151  appendStringInfoChar(buf, '\\');
1152  appendStringInfoChar(buf, *cmdptr);
1153  }
1154 
1155  appendStringInfoChar(buf, '"');
1156 
1157  pfree(cmdbuf.data);
1158 }
void pfree(void *pointer)
Definition: mcxt.c:1456
int appendStringInfoVA(StringInfo str, const char *fmt, va_list args)
Definition: stringinfo.c:139
void enlargeStringInfo(StringInfo str, int needed)
Definition: stringinfo.c:289
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:182
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:194
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59

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

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

◆ psql_end_command()

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

Definition at line 1161 of file pg_regress.c.

1162 {
1163  /* Add the database name --- assume it needs no extra escaping */
1165  " \"%s\"",
1166  database);
1167 
1168  /* And now we can execute the shell command */
1169  fflush(NULL);
1170  if (system(buf->data) != 0)
1171  {
1172  /* psql probably already reported the error */
1173  bail("command failed: %s", buf->data);
1174  }
1175 
1176  /* Clean up */
1177  pfree(buf->data);
1178  pfree(buf);
1179 }
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:97

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

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

◆ psql_start_command()

static StringInfo psql_start_command ( void  )
static

Definition at line 1112 of file pg_regress.c.

1113 {
1115 
1117  "\"%s%spsql\" -X -q",
1118  bindir ? bindir : "",
1119  bindir ? "/" : "");
1120  return buf;
1121 }
char * bindir
Definition: pg_regress.c:103
StringInfo makeStringInfo(void)
Definition: stringinfo.c:41

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

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

◆ regression_main()

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

Definition at line 2079 of file pg_regress.c.

2083 {
2084  static struct option long_options[] = {
2085  {"help", no_argument, NULL, 'h'},
2086  {"version", no_argument, NULL, 'V'},
2087  {"dbname", required_argument, NULL, 1},
2088  {"debug", no_argument, NULL, 2},
2089  {"inputdir", required_argument, NULL, 3},
2090  {"max-connections", required_argument, NULL, 5},
2091  {"encoding", required_argument, NULL, 6},
2092  {"outputdir", required_argument, NULL, 7},
2093  {"schedule", required_argument, NULL, 8},
2094  {"temp-instance", required_argument, NULL, 9},
2095  {"no-locale", no_argument, NULL, 10},
2096  {"host", required_argument, NULL, 13},
2097  {"port", required_argument, NULL, 14},
2098  {"user", required_argument, NULL, 15},
2099  {"bindir", required_argument, NULL, 16},
2100  {"dlpath", required_argument, NULL, 17},
2101  {"create-role", required_argument, NULL, 18},
2102  {"temp-config", required_argument, NULL, 19},
2103  {"use-existing", no_argument, NULL, 20},
2104  {"launcher", required_argument, NULL, 21},
2105  {"load-extension", required_argument, NULL, 22},
2106  {"config-auth", required_argument, NULL, 24},
2107  {"max-concurrent-tests", required_argument, NULL, 25},
2108  {"expecteddir", required_argument, NULL, 26},
2109  {NULL, 0, NULL, 0}
2110  };
2111 
2112  bool use_unix_sockets;
2113  _stringlist *sl;
2114  int c;
2115  int i;
2116  int option_index;
2117  char buf[MAXPGPATH * 4];
2118 
2119  pg_logging_init(argv[0]);
2120  progname = get_progname(argv[0]);
2121  set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_regress"));
2122 
2124 
2125  atexit(stop_postmaster);
2126 
2127 #if defined(WIN32)
2128 
2129  /*
2130  * We don't use Unix-domain sockets on Windows by default (see comment at
2131  * remove_temp() for a reason). Override at your own risk.
2132  */
2133  use_unix_sockets = getenv("PG_TEST_USE_UNIX_SOCKETS") ? true : false;
2134 #else
2135  use_unix_sockets = true;
2136 #endif
2137 
2138  if (!use_unix_sockets)
2139  hostname = "localhost";
2140 
2141  /*
2142  * We call the initialization function here because that way we can set
2143  * default parameters and let them be overwritten by the commandline.
2144  */
2145  ifunc(argc, argv);
2146 
2147  if (getenv("PG_REGRESS_DIFF_OPTS"))
2148  pretty_diff_opts = getenv("PG_REGRESS_DIFF_OPTS");
2149 
2150  while ((c = getopt_long(argc, argv, "hV", long_options, &option_index)) != -1)
2151  {
2152  switch (c)
2153  {
2154  case 'h':
2155  help();
2156  exit(0);
2157  case 'V':
2158  puts("pg_regress (PostgreSQL) " PG_VERSION);
2159  exit(0);
2160  case 1:
2161 
2162  /*
2163  * If a default database was specified, we need to remove it
2164  * before we add the specified one.
2165  */
2168  break;
2169  case 2:
2170  debug = true;
2171  break;
2172  case 3:
2174  break;
2175  case 5:
2176  max_connections = atoi(optarg);
2177  break;
2178  case 6:
2180  break;
2181  case 7:
2183  break;
2184  case 8:
2186  break;
2187  case 9:
2189  break;
2190  case 10:
2191  nolocale = true;
2192  break;
2193  case 13:
2195  break;
2196  case 14:
2197  port = atoi(optarg);
2198  port_specified_by_user = true;
2199  break;
2200  case 15:
2201  user = pg_strdup(optarg);
2202  break;
2203  case 16:
2204  /* "--bindir=" means to use PATH */
2205  if (strlen(optarg))
2206  bindir = pg_strdup(optarg);
2207  else
2208  bindir = NULL;
2209  break;
2210  case 17:
2211  dlpath = pg_strdup(optarg);
2212  break;
2213  case 18:
2215  break;
2216  case 19:
2218  break;
2219  case 20:
2220  use_existing = true;
2221  break;
2222  case 21:
2224  break;
2225  case 22:
2227  break;
2228  case 24:
2230  break;
2231  case 25:
2232  max_concurrent_tests = atoi(optarg);
2233  break;
2234  case 26:
2236  break;
2237  default:
2238  /* getopt_long already emitted a complaint */
2239  pg_log_error_hint("Try \"%s --help\" for more information.",
2240  progname);
2241  exit(2);
2242  }
2243  }
2244 
2245  /*
2246  * if we still have arguments, they are extra tests to run
2247  */
2248  while (argc - optind >= 1)
2249  {
2251  optind++;
2252  }
2253 
2254  /*
2255  * We must have a database to run the tests in; either a default name, or
2256  * one supplied by the --dbname switch.
2257  */
2258  if (!(dblist && dblist->str && dblist->str[0]))
2259  {
2260  bail("no database name was specified");
2261  }
2262 
2263  if (config_auth_datadir)
2264  {
2265 #ifdef ENABLE_SSPI
2266  if (!use_unix_sockets)
2267  config_sspi_auth(config_auth_datadir, user);
2268 #endif
2269  exit(0);
2270  }
2271 
2273 
2274  /*
2275  * To reduce chances of interference with parallel installations, use
2276  * a port number starting in the private range (49152-65535)
2277  * calculated from the version number. This aids non-Unix socket mode
2278  * systems; elsewhere, the use of a private socket directory already
2279  * prevents interference.
2280  */
2281  port = 0xC000 | (PG_VERSION_NUM & 0x3FFF);
2282 
2287 
2288  /*
2289  * Initialization
2290  */
2292 
2294 
2295 #if defined(HAVE_GETRLIMIT)
2297 #endif
2298 
2299  if (temp_instance)
2300  {
2301  StringInfoData cmd;
2302  FILE *pg_conf;
2303  const char *env_wait;
2304  int wait_seconds;
2305  const char *initdb_template_dir;
2306  const char *keywords[4];
2307  const char *values[4];
2308  PGPing rv;
2309 
2310  /*
2311  * Prepare the temp instance
2312  */
2313 
2315  {
2316  if (!rmtree(temp_instance, true))
2317  {
2318  bail("could not remove temp instance \"%s\"", temp_instance);
2319  }
2320  }
2321 
2322  /* make the temp instance top directory */
2324 
2325  /* and a directory for log files */
2326  snprintf(buf, sizeof(buf), "%s/log", outputdir);
2327  if (!directory_exists(buf))
2329 
2330  initStringInfo(&cmd);
2331 
2332  /*
2333  * Create data directory.
2334  *
2335  * If available, use a previously initdb'd cluster as a template by
2336  * copying it. For a lot of tests, that's substantially cheaper.
2337  *
2338  * There's very similar code in Cluster.pm, but we can't easily de
2339  * duplicate it until we require perl at build time.
2340  */
2341  initdb_template_dir = getenv("INITDB_TEMPLATE");
2342  if (initdb_template_dir == NULL || nolocale || debug)
2343  {
2344  note("initializing database system by running initdb");
2345 
2346  appendStringInfo(&cmd,
2347  "\"%s%sinitdb\" -D \"%s/data\" --no-clean --no-sync",
2348  bindir ? bindir : "",
2349  bindir ? "/" : "",
2350  temp_instance);
2351  if (debug)
2352  appendStringInfoString(&cmd, " --debug");
2353  if (nolocale)
2354  appendStringInfoString(&cmd, " --no-locale");
2355  appendStringInfo(&cmd, " > \"%s/log/initdb.log\" 2>&1", outputdir);
2356  fflush(NULL);
2357  if (system(cmd.data))
2358  {
2359  bail("initdb failed\n"
2360  "# Examine \"%s/log/initdb.log\" for the reason.\n"
2361  "# Command was: %s",
2362  outputdir, cmd.data);
2363  }
2364  }
2365  else
2366  {
2367 #ifndef WIN32
2368  const char *copycmd = "cp -RPp \"%s\" \"%s/data\"";
2369  int expected_exitcode = 0;
2370 #else
2371  const char *copycmd = "robocopy /E /NJS /NJH /NFL /NDL /NP \"%s\" \"%s/data\"";
2372  int expected_exitcode = 1; /* 1 denotes files were copied */
2373 #endif
2374 
2375  note("initializing database system by copying initdb template");
2376 
2377  appendStringInfo(&cmd,
2378  copycmd,
2379  initdb_template_dir,
2380  temp_instance);
2381  appendStringInfo(&cmd, " > \"%s/log/initdb.log\" 2>&1", outputdir);
2382  fflush(NULL);
2383  if (system(cmd.data) != expected_exitcode)
2384  {
2385  bail("copying of initdb template failed\n"
2386  "# Examine \"%s/log/initdb.log\" for the reason.\n"
2387  "# Command was: %s",
2388  outputdir, cmd.data);
2389  }
2390  }
2391 
2392  pfree(cmd.data);
2393 
2394  /*
2395  * Adjust the default postgresql.conf for regression testing. The user
2396  * can specify a file to be appended; in any case we expand logging
2397  * and set max_prepared_transactions to enable testing of prepared
2398  * xacts. (Note: to reduce the probability of unexpected shmmax
2399  * failures, don't set max_prepared_transactions any higher than
2400  * actually needed by the prepared_xacts regression test.)
2401  */
2402  snprintf(buf, sizeof(buf), "%s/data/postgresql.conf", temp_instance);
2403  pg_conf = fopen(buf, "a");
2404  if (pg_conf == NULL)
2405  {
2406  bail("could not open \"%s\" for adding extra config: %s",
2407  buf, strerror(errno));
2408  }
2409  fputs("\n# Configuration added by pg_regress\n\n", pg_conf);
2410  fputs("log_autovacuum_min_duration = 0\n", pg_conf);
2411  fputs("log_checkpoints = on\n", pg_conf);
2412  fputs("log_line_prefix = '%m %b[%p] %q%a '\n", pg_conf);
2413  fputs("log_lock_waits = on\n", pg_conf);
2414  fputs("log_temp_files = 128kB\n", pg_conf);
2415  fputs("max_prepared_transactions = 2\n", pg_conf);
2416 
2417  for (sl = temp_configs; sl != NULL; sl = sl->next)
2418  {
2419  char *temp_config = sl->str;
2420  FILE *extra_conf;
2421  char line_buf[1024];
2422 
2423  extra_conf = fopen(temp_config, "r");
2424  if (extra_conf == NULL)
2425  {
2426  bail("could not open \"%s\" to read extra config: %s",
2427  temp_config, strerror(errno));
2428  }
2429  while (fgets(line_buf, sizeof(line_buf), extra_conf) != NULL)
2430  fputs(line_buf, pg_conf);
2431  fclose(extra_conf);
2432  }
2433 
2434  fclose(pg_conf);
2435 
2436 #ifdef ENABLE_SSPI
2437  if (!use_unix_sockets)
2438  {
2439  /*
2440  * Since we successfully used the same buffer for the much-longer
2441  * "initdb" command, this can't truncate.
2442  */
2443  snprintf(buf, sizeof(buf), "%s/data", temp_instance);
2444  config_sspi_auth(buf, NULL);
2445  }
2446 #endif
2447 
2448  /*
2449  * Prepare the connection params for checking the state of the server
2450  * before starting the tests.
2451  */
2452  sprintf(portstr, "%d", port);
2453  keywords[0] = "dbname";
2454  values[0] = "postgres";
2455  keywords[1] = "port";
2456  values[1] = portstr;
2457  keywords[2] = "host";
2458  values[2] = hostname ? hostname : sockdir;
2459  keywords[3] = NULL;
2460  values[3] = NULL;
2461 
2462  /*
2463  * Check if there is a postmaster running already.
2464  */
2465  for (i = 0; i < 16; i++)
2466  {
2467  rv = PQpingParams(keywords, values, 1);
2468 
2469  if (rv == PQPING_OK)
2470  {
2471  if (port_specified_by_user || i == 15)
2472  {
2473  note("port %d apparently in use", port);
2475  note("could not determine an available port");
2476  bail("Specify an unused port using the --port option or shut down any conflicting PostgreSQL servers.");
2477  }
2478 
2479  note("port %d apparently in use, trying %d", port, port + 1);
2480  port++;
2481  sprintf(portstr, "%d", port);
2482  setenv("PGPORT", portstr, 1);
2483  }
2484  else
2485  break;
2486  }
2487 
2488  /*
2489  * Start the temp postmaster
2490  */
2491  snprintf(buf, sizeof(buf),
2492  "\"%s%spostgres\" -D \"%s/data\" -F%s "
2493  "-c \"listen_addresses=%s\" -k \"%s\" "
2494  "> \"%s/log/postmaster.log\" 2>&1",
2495  bindir ? bindir : "",
2496  bindir ? "/" : "",
2497  temp_instance, debug ? " -d 5" : "",
2498  hostname ? hostname : "", sockdir ? sockdir : "",
2499  outputdir);
2501  if (postmaster_pid == INVALID_PID)
2502  bail("could not spawn postmaster: %s", strerror(errno));
2503 
2504  /*
2505  * Wait till postmaster is able to accept connections; normally takes
2506  * only a fraction of a second or so, but Cygwin is reportedly *much*
2507  * slower, and test builds using Valgrind or similar tools might be
2508  * too. Hence, allow the default timeout of 60 seconds to be
2509  * overridden from the PGCTLTIMEOUT environment variable.
2510  */
2511  env_wait = getenv("PGCTLTIMEOUT");
2512  if (env_wait != NULL)
2513  {
2514  wait_seconds = atoi(env_wait);
2515  if (wait_seconds <= 0)
2516  wait_seconds = 60;
2517  }
2518  else
2519  wait_seconds = 60;
2520 
2521  for (i = 0; i < wait_seconds * WAIT_TICKS_PER_SECOND; i++)
2522  {
2523  /*
2524  * It's fairly unlikely that the server is responding immediately
2525  * so we start with sleeping before checking instead of the other
2526  * way around.
2527  */
2528  pg_usleep(1000000L / WAIT_TICKS_PER_SECOND);
2529 
2530  rv = PQpingParams(keywords, values, 1);
2531 
2532  /* Done if the server is running and accepts connections */
2533  if (rv == PQPING_OK)
2534  break;
2535 
2536  if (rv == PQPING_NO_ATTEMPT)
2537  bail("attempting to connect to postmaster failed");
2538 
2539  /*
2540  * Fail immediately if postmaster has exited
2541  */
2542 #ifndef WIN32
2543  if (waitpid(postmaster_pid, NULL, WNOHANG) == postmaster_pid)
2544 #else
2545  if (WaitForSingleObject(postmaster_pid, 0) == WAIT_OBJECT_0)
2546 #endif
2547  {
2548  bail("postmaster failed, examine \"%s/log/postmaster.log\" for the reason",
2549  outputdir);
2550  }
2551  }
2553  {
2554  diag("postmaster did not respond within %d seconds, examine \"%s/log/postmaster.log\" for the reason",
2556 
2557  /*
2558  * If we get here, the postmaster is probably wedged somewhere in
2559  * startup. Try to kill it ungracefully rather than leaving a
2560  * stuck postmaster that might interfere with subsequent test
2561  * attempts.
2562  */
2563 #ifndef WIN32
2564  if (kill(postmaster_pid, SIGKILL) != 0 && errno != ESRCH)
2565  bail("could not kill failed postmaster: %s", strerror(errno));
2566 #else
2567  if (TerminateProcess(postmaster_pid, 255) == 0)
2568  bail("could not kill failed postmaster: error code %lu",
2569  GetLastError());
2570 #endif
2571  bail("postmaster failed");
2572  }
2573 
2574  postmaster_running = true;
2575 
2576 #ifdef _WIN64
2577 /* need a series of two casts to convert HANDLE without compiler warning */
2578 #define ULONGPID(x) (unsigned long) (unsigned long long) (x)
2579 #else
2580 #define ULONGPID(x) (unsigned long) (x)
2581 #endif
2582  note("using temp instance on port %d with PID %lu",
2584  }
2585  else
2586  {
2587  /*
2588  * Using an existing installation, so may need to get rid of
2589  * pre-existing database(s) and role(s)
2590  */
2591  if (!use_existing)
2592  {
2593  for (sl = dblist; sl; sl = sl->next)
2595  for (sl = extraroles; sl; sl = sl->next)
2596  drop_role_if_exists(sl->str);
2597  }
2598  }
2599 
2600  /*
2601  * Create the test database(s) and role(s)
2602  */
2603  if (!use_existing)
2604  {
2605  for (sl = dblist; sl; sl = sl->next)
2606  create_database(sl->str);
2607  for (sl = extraroles; sl; sl = sl->next)
2608  create_role(sl->str, dblist);
2609  }
2610 
2611  /*
2612  * Ready to run the tests
2613  */
2614  for (sl = schedulelist; sl != NULL; sl = sl->next)
2615  {
2616  run_schedule(sl->str, startfunc, postfunc);
2617  }
2618 
2619  for (sl = extra_tests; sl != NULL; sl = sl->next)
2620  {
2621  run_single_test(sl->str, startfunc, postfunc);
2622  }
2623 
2624  /*
2625  * Shut down temp installation's postmaster
2626  */
2627  if (temp_instance)
2628  {
2629  stop_postmaster();
2630  }
2631 
2632  /*
2633  * If there were no errors, remove the temp instance immediately to
2634  * conserve disk space. (If there were errors, we leave the instance in
2635  * place for possible manual investigation.)
2636  */
2637  if (temp_instance && fail_count == 0)
2638  {
2639  if (!rmtree(temp_instance, true))
2640  diag("could not remove temp instance \"%s\"",
2641  temp_instance);
2642  }
2643 
2644  /*
2645  * Emit a TAP compliant Plan
2646  */
2648 
2649  /*
2650  * Emit nice-looking summary message
2651  */
2652  if (fail_count == 0)
2653  note("All %d tests passed.", success_count);
2654  else
2655  diag("%d of %d tests failed.", fail_count, success_count + fail_count);
2656 
2657  if (file_size(difffilename) > 0)
2658  {
2659  diag("The differences that caused some tests to fail can be viewed in the file \"%s\".",
2660  difffilename);
2661  diag("A copy of the test summary that you see above is saved in the file \"%s\".",
2662  logfilename);
2663  }
2664  else
2665  {
2666  unlink(difffilename);
2667  unlink(logfilename);
2668  }
2669 
2670  fclose(logfile);
2671  logfile = NULL;
2672 
2673  if (fail_count != 0)
2674  exit(1);
2675 
2676  return 0;
2677 }
static Datum values[MAXATTR]
Definition: bootstrap.c:156
#define PG_TEXTDOMAIN(domain)
Definition: c.h:1227
void set_pglocale_pgservice(const char *argv0, const char *app)
Definition: exec.c:436
PGPing PQpingParams(const char *const *keywords, const char *const *values, int expand_dbname)
Definition: fe-connect.c:694
int getopt_long(int argc, char *const argv[], const char *optstring, const struct option *longopts, int *longindex)
Definition: getopt_long.c:60
#define no_argument
Definition: getopt_long.h:24
#define required_argument
Definition: getopt_long.h:25
return true
Definition: isn.c:126
PGPing
Definition: libpq-fe.h:146
@ PQPING_OK
Definition: libpq-fe.h:147
@ PQPING_NO_ATTEMPT
Definition: libpq-fe.h:150
void pg_logging_init(const char *argv0)
Definition: logging.c:83
#define pg_log_error_hint(...)
Definition: logging.h:112
static int wait_seconds
Definition: pg_ctl.c:75
PGDLLIMPORT int optind
Definition: getopt.c:50
PGDLLIMPORT char * optarg
Definition: getopt.c:52
#define plan(x)
Definition: pg_regress.c:162
static bool use_existing
Definition: pg_regress.c:114
static void open_result_files(void)
Definition: pg_regress.c:1921
static int max_connections
Definition: pg_regress.c:106
static bool port_specified_by_user
Definition: pg_regress.c:118
static void stop_postmaster(void)
Definition: pg_regress.c:420
static int max_concurrent_tests
Definition: pg_regress.c:107
static void create_database(const char *dbname)
Definition: pg_regress.c:1970
static void drop_role_if_exists(const char *rolename)
Definition: pg_regress.c:2004
bool debug
Definition: pg_regress.c:99
static void unlimit_core_size(void)
Definition: pg_regress.c:175
static _stringlist * schedulelist
Definition: pg_regress.c:109
#define WAIT_TICKS_PER_SECOND
Definition: pg_regress.c:83
static _stringlist * temp_configs
Definition: pg_regress.c:112
static _stringlist * extra_tests
Definition: pg_regress.c:110
static void split_to_stringlist(const char *s, const char *delim, _stringlist **listhead)
Definition: pg_regress.c:234
static void run_single_test(const char *test, test_start_function startfunc, postprocess_result_function postfunc)
Definition: pg_regress.c:1854
char * launcher
Definition: pg_regress.c:104
const char * pretty_diff_opts
Definition: pg_regress.c:66
char * expecteddir
Definition: pg_regress.c:102
static char * config_auth_datadir
Definition: pg_regress.c:122
static void drop_database_if_exists(const char *dbname)
Definition: pg_regress.c:1959
static char portstr[16]
Definition: pg_regress.c:117
static void initialize_environment(void)
Definition: pg_regress.c:710
static void help(void)
Definition: pg_regress.c:2029
static long file_size(const char *file)
Definition: pg_regress.c:1259
static bool postmaster_running
Definition: pg_regress.c:139
_stringlist * dblist
Definition: pg_regress.c:98
static _stringlist * extraroles
Definition: pg_regress.c:121
PID_TYPE spawn_process(const char *cmdline)
Definition: pg_regress.c:1197
static void create_role(const char *rolename, const _stringlist *granted_dbs)
Definition: pg_regress.c:2015
static void run_schedule(const char *schedule, test_start_function startfunc, postprocess_result_function postfunc)
Definition: pg_regress.c:1645
void add_stringlist_item(_stringlist **listhead, const char *str)
Definition: pg_regress.c:198
static int success_count
Definition: pg_regress.c:141
#define ULONGPID(x)
static int fail_count
Definition: pg_regress.c:142
static PID_TYPE postmaster_pid
Definition: pg_regress.c:138
#define INVALID_PID
Definition: pg_regress.h:15
char * make_absolute_path(const char *path)
Definition: path.c:729
#define sprintf
Definition: port.h:240
const char * get_progname(const char *argv0)
Definition: path.c:574
void get_restricted_token(void)
bool rmtree(const char *path, bool rmtopdir)
Definition: rmtree.c:50
void pg_usleep(long microsec)
Definition: signal.c:53
#define kill(pid, sig)
Definition: win32_port.h:485
#define SIGKILL
Definition: win32_port.h:172

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

Referenced by main().

◆ remove_temp()

static void remove_temp ( void  )
static

Definition at line 455 of file pg_regress.c.

456 {
458  unlink(sockself);
459  unlink(socklock);
460  rmdir(temp_sockdir);
461 }
Assert(fmt[strlen(fmt) - 1] !='\n')

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

Referenced by make_temp_sockdir(), and signal_remove_temp().

◆ results_differ()

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

Definition at line 1404 of file pg_regress.c.

1405 {
1406  char expectfile[MAXPGPATH];
1407  char diff[MAXPGPATH];
1408  char cmd[MAXPGPATH * 3];
1409  char best_expect_file[MAXPGPATH];
1410  FILE *difffile;
1411  int best_line_count;
1412  int i;
1413  int l;
1414  const char *platform_expectfile;
1415 
1416  /*
1417  * We can pass either the resultsfile or the expectfile, they should have
1418  * the same type (filename.type) anyway.
1419  */
1420  platform_expectfile = get_expectfile(testname, resultsfile);
1421 
1422  strlcpy(expectfile, default_expectfile, sizeof(expectfile));
1423  if (platform_expectfile)
1424  {
1425  /*
1426  * Replace everything after the last slash in expectfile with what the
1427  * platform_expectfile contains.
1428  */
1429  char *p = strrchr(expectfile, '/');
1430 
1431  if (p)
1432  strcpy(++p, platform_expectfile);
1433  }
1434 
1435  /* Name to use for temporary diff file */
1436  snprintf(diff, sizeof(diff), "%s.diff", resultsfile);
1437 
1438  /* OK, run the diff */
1439  snprintf(cmd, sizeof(cmd),
1440  "diff %s \"%s\" \"%s\" > \"%s\"",
1441  basic_diff_opts, expectfile, resultsfile, diff);
1442 
1443  /* Is the diff file empty? */
1444  if (run_diff(cmd, diff) == 0)
1445  {
1446  unlink(diff);
1447  return false;
1448  }
1449 
1450  /* There may be secondary comparison files that match better */
1451  best_line_count = file_line_count(diff);
1452  strcpy(best_expect_file, expectfile);
1453 
1454  for (i = 0; i <= 9; i++)
1455  {
1456  char *alt_expectfile;
1457 
1458  alt_expectfile = get_alternative_expectfile(expectfile, i);
1459  if (!alt_expectfile)
1460  {
1461  bail("Unable to check secondary comparison files: %s",
1462  strerror(errno));
1463  }
1464 
1465  if (!file_exists(alt_expectfile))
1466  {
1467  free(alt_expectfile);
1468  continue;
1469  }
1470 
1471  snprintf(cmd, sizeof(cmd),
1472  "diff %s \"%s\" \"%s\" > \"%s\"",
1473  basic_diff_opts, alt_expectfile, resultsfile, diff);
1474 
1475  if (run_diff(cmd, diff) == 0)
1476  {
1477  unlink(diff);
1478  free(alt_expectfile);
1479  return false;
1480  }
1481 
1482  l = file_line_count(diff);
1483  if (l < best_line_count)
1484  {
1485  /* This diff was a better match than the last one */
1486  best_line_count = l;
1487  strlcpy(best_expect_file, alt_expectfile, sizeof(best_expect_file));
1488  }
1489  free(alt_expectfile);
1490  }
1491 
1492  /*
1493  * fall back on the canonical results file if we haven't tried it yet and
1494  * haven't found a complete match yet.
1495  */
1496 
1497  if (platform_expectfile)
1498  {
1499  snprintf(cmd, sizeof(cmd),
1500  "diff %s \"%s\" \"%s\" > \"%s\"",
1501  basic_diff_opts, default_expectfile, resultsfile, diff);
1502 
1503  if (run_diff(cmd, diff) == 0)
1504  {
1505  /* No diff = no changes = good */
1506  unlink(diff);
1507  return false;
1508  }
1509 
1510  l = file_line_count(diff);
1511  if (l < best_line_count)
1512  {
1513  /* This diff was a better match than the last one */
1514  best_line_count = l;
1515  strlcpy(best_expect_file, default_expectfile, sizeof(best_expect_file));
1516  }
1517  }
1518 
1519  /*
1520  * Use the best comparison file to generate the "pretty" diff, which we
1521  * append to the diffs summary file.
1522  */
1523 
1524  /* Write diff header */
1525  difffile = fopen(difffilename, "a");
1526  if (difffile)
1527  {
1528  fprintf(difffile,
1529  "diff %s %s %s\n",
1530  pretty_diff_opts, best_expect_file, resultsfile);
1531  fclose(difffile);
1532  }
1533 
1534  /* Run diff */
1535  snprintf(cmd, sizeof(cmd),
1536  "diff %s \"%s\" \"%s\" >> \"%s\"",
1537  pretty_diff_opts, best_expect_file, resultsfile, difffilename);
1538  run_diff(cmd, difffilename);
1539 
1540  unlink(diff);
1541  return true;
1542 }
static int file_line_count(const char *file)
Definition: pg_regress.c:1280
bool file_exists(const char *file)
Definition: pg_regress.c:1302
static int run_diff(const char *cmd, const char *filename)
Definition: pg_regress.c:1372
static const char * get_expectfile(const char *testname, const char *file)
Definition: pg_regress.c:681
const char * basic_diff_opts
Definition: pg_regress.c:65
static char * get_alternative_expectfile(const char *expectfile, int i)
Definition: pg_regress.c:1338
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45

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

Referenced by run_schedule(), and run_single_test().

◆ run_diff()

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

Definition at line 1372 of file pg_regress.c.

1373 {
1374  int r;
1375 
1376  fflush(NULL);
1377  r = system(cmd);
1378  if (!WIFEXITED(r) || WEXITSTATUS(r) > 1)
1379  {
1380  bail("diff command failed with status %d: %s", r, cmd);
1381  }
1382 #ifdef WIN32
1383 
1384  /*
1385  * On WIN32, if the 'diff' command cannot be found, system() returns 1,
1386  * but produces nothing to stdout, so we check for that here.
1387  */
1388  if (WEXITSTATUS(r) == 1 && file_size(filename) <= 0)
1389  {
1390  bail("diff command not found: %s", cmd);
1391  }
1392 #endif
1393 
1394  return WEXITSTATUS(r);
1395 }
static char * filename
Definition: pg_dumpall.c:121

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

Referenced by results_differ().

◆ run_schedule()

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

Definition at line 1645 of file pg_regress.c.

1647 {
1648 #define MAX_PARALLEL_TESTS 100
1649  char *tests[MAX_PARALLEL_TESTS];
1650  _stringlist *resultfiles[MAX_PARALLEL_TESTS];
1651  _stringlist *expectfiles[MAX_PARALLEL_TESTS];
1654  instr_time starttimes[MAX_PARALLEL_TESTS];
1655  instr_time stoptimes[MAX_PARALLEL_TESTS];
1656  int statuses[MAX_PARALLEL_TESTS];
1657  char scbuf[1024];
1658  FILE *scf;
1659  int line_num = 0;
1660 
1661  memset(tests, 0, sizeof(tests));
1662  memset(resultfiles, 0, sizeof(resultfiles));
1663  memset(expectfiles, 0, sizeof(expectfiles));
1664  memset(tags, 0, sizeof(tags));
1665 
1666  scf = fopen(schedule, "r");
1667  if (!scf)
1668  {
1669  bail("could not open file \"%s\" for reading: %s",
1670  schedule, strerror(errno));
1671  }
1672 
1673  while (fgets(scbuf, sizeof(scbuf), scf))
1674  {
1675  char *test = NULL;
1676  char *c;
1677  int num_tests;
1678  bool inword;
1679  int i;
1680 
1681  line_num++;
1682 
1683  /* strip trailing whitespace, especially the newline */
1684  i = strlen(scbuf);
1685  while (i > 0 && isspace((unsigned char) scbuf[i - 1]))
1686  scbuf[--i] = '\0';
1687 
1688  if (scbuf[0] == '\0' || scbuf[0] == '#')
1689  continue;
1690  if (strncmp(scbuf, "test: ", 6) == 0)
1691  test = scbuf + 6;
1692  else
1693  {
1694  bail("syntax error in schedule file \"%s\" line %d: %s",
1695  schedule, line_num, scbuf);
1696  }
1697 
1698  num_tests = 0;
1699  inword = false;
1700  for (c = test;; c++)
1701  {
1702  if (*c == '\0' || isspace((unsigned char) *c))
1703  {
1704  if (inword)
1705  {
1706  /* Reached end of a test name */
1707  char sav;
1708 
1709  if (num_tests >= MAX_PARALLEL_TESTS)
1710  {
1711  bail("too many parallel tests (more than %d) in schedule file \"%s\" line %d: %s",
1712  MAX_PARALLEL_TESTS, schedule, line_num, scbuf);
1713  }
1714  sav = *c;
1715  *c = '\0';
1716  tests[num_tests] = pg_strdup(test);
1717  num_tests++;
1718  *c = sav;
1719  inword = false;
1720  }
1721  if (*c == '\0')
1722  break; /* loop exit is here */
1723  }
1724  else if (!inword)
1725  {
1726  /* Start of a test name */
1727  test = c;
1728  inword = true;
1729  }
1730  }
1731 
1732  if (num_tests == 0)
1733  {
1734  bail("syntax error in schedule file \"%s\" line %d: %s",
1735  schedule, line_num, scbuf);
1736  }
1737 
1738  if (num_tests == 1)
1739  {
1740  pids[0] = (startfunc) (tests[0], &resultfiles[0], &expectfiles[0], &tags[0]);
1741  INSTR_TIME_SET_CURRENT(starttimes[0]);
1742  wait_for_tests(pids, statuses, stoptimes, NULL, 1);
1743  /* status line is finished below */
1744  }
1745  else if (max_concurrent_tests > 0 && max_concurrent_tests < num_tests)
1746  {
1747  bail("too many parallel tests (more than %d) in schedule file \"%s\" line %d: %s",
1748  max_concurrent_tests, schedule, line_num, scbuf);
1749  }
1750  else if (max_connections > 0 && max_connections < num_tests)
1751  {
1752  int oldest = 0;
1753 
1754  note_detail("parallel group (%d tests, in groups of %d): ",
1755  num_tests, max_connections);
1756  for (i = 0; i < num_tests; i++)
1757  {
1758  if (i - oldest >= max_connections)
1759  {
1760  wait_for_tests(pids + oldest, statuses + oldest,
1761  stoptimes + oldest,
1762  tests + oldest, i - oldest);
1763  oldest = i;
1764  }
1765  pids[i] = (startfunc) (tests[i], &resultfiles[i], &expectfiles[i], &tags[i]);
1766  INSTR_TIME_SET_CURRENT(starttimes[i]);
1767  }
1768  wait_for_tests(pids + oldest, statuses + oldest,
1769  stoptimes + oldest,
1770  tests + oldest, i - oldest);
1771  note_end();
1772  }
1773  else
1774  {
1775  note_detail("parallel group (%d tests): ", num_tests);
1776  for (i = 0; i < num_tests; i++)
1777  {
1778  pids[i] = (startfunc) (tests[i], &resultfiles[i], &expectfiles[i], &tags[i]);
1779  INSTR_TIME_SET_CURRENT(starttimes[i]);
1780  }
1781  wait_for_tests(pids, statuses, stoptimes, tests, num_tests);
1782  note_end();
1783  }
1784 
1785  /* Check results for all tests */
1786  for (i = 0; i < num_tests; i++)
1787  {
1788  _stringlist *rl,
1789  *el,
1790  *tl;
1791  bool differ = false;
1792 
1793  INSTR_TIME_SUBTRACT(stoptimes[i], starttimes[i]);
1794 
1795  /*
1796  * Advance over all three lists simultaneously.
1797  *
1798  * Compare resultfiles[j] with expectfiles[j] always. Tags are
1799  * optional but if there are tags, the tag list has the same
1800  * length as the other two lists.
1801  */
1802  for (rl = resultfiles[i], el = expectfiles[i], tl = tags[i];
1803  rl != NULL; /* rl and el have the same length */
1804  rl = rl->next, el = el->next,
1805  tl = tl ? tl->next : NULL)
1806  {
1807  bool newdiff;
1808 
1809  if (postfunc)
1810  (*postfunc) (rl->str);
1811  newdiff = results_differ(tests[i], rl->str, el->str);
1812  if (newdiff && tl)
1813  {
1814  diag("tag: %s", tl->str);
1815  }
1816  differ |= newdiff;
1817  }
1818 
1819  if (statuses[i] != 0)
1820  {
1821  test_status_failed(tests[i], INSTR_TIME_GET_MILLISEC(stoptimes[i]), (num_tests > 1));
1822  log_child_failure(statuses[i]);
1823  }
1824  else
1825  {
1826  if (differ)
1827  {
1828  test_status_failed(tests[i], INSTR_TIME_GET_MILLISEC(stoptimes[i]), (num_tests > 1));
1829  }
1830  else
1831  {
1832  test_status_ok(tests[i], INSTR_TIME_GET_MILLISEC(stoptimes[i]), (num_tests > 1));
1833  }
1834  }
1835  }
1836 
1837  for (i = 0; i < num_tests; i++)
1838  {
1839  pg_free(tests[i]);
1840  tests[i] = NULL;
1841  free_stringlist(&resultfiles[i]);
1842  free_stringlist(&expectfiles[i]);
1843  free_stringlist(&tags[i]);
1844  }
1845  }
1846 
1847  fclose(scf);
1848 }
void pg_free(void *ptr)
Definition: fe_memutils.c:105
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:122
#define INSTR_TIME_SUBTRACT(x, y)
Definition: instr_time.h:181
#define INSTR_TIME_GET_MILLISEC(t)
Definition: instr_time.h:191
#define note_detail(...)
Definition: pg_regress.c:164
#define MAX_PARALLEL_TESTS
static void test_status_ok(const char *testname, double runtime, bool parallel)
Definition: pg_regress.c:302
static void log_child_failure(int exitstatus)
Definition: pg_regress.c:1622
static void test_status_failed(const char *testname, double runtime, bool parallel)
Definition: pg_regress.c:310
static void wait_for_tests(PID_TYPE *pids, int *statuses, instr_time *stoptimes, char **names, int num_tests)
Definition: pg_regress.c:1553
static bool results_differ(const char *testname, const char *resultsfile, const char *default_expectfile)
Definition: pg_regress.c:1404
#define note_end()
Definition: pg_regress.c:166
#define PID_TYPE
Definition: pg_regress.h:14
static void test(void)

References bail, diag, free_stringlist(), i, INSTR_TIME_GET_MILLISEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, log_child_failure(), max_concurrent_tests, max_connections, MAX_PARALLEL_TESTS, _stringlist::next, note_detail, note_end, pg_free(), pg_strdup(), PID_TYPE, results_differ(), _stringlist::str, strerror, test(), test_status_failed(), test_status_ok(), and wait_for_tests().

Referenced by regression_main().

◆ run_single_test()

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

Definition at line 1854 of file pg_regress.c.

1856 {
1857  PID_TYPE pid;
1858  instr_time starttime;
1859  instr_time stoptime;
1860  int exit_status;
1861  _stringlist *resultfiles = NULL;
1862  _stringlist *expectfiles = NULL;
1863  _stringlist *tags = NULL;
1864  _stringlist *rl,
1865  *el,
1866  *tl;
1867  bool differ = false;
1868 
1869  pid = (startfunc) (test, &resultfiles, &expectfiles, &tags);
1870  INSTR_TIME_SET_CURRENT(starttime);
1871  wait_for_tests(&pid, &exit_status, &stoptime, NULL, 1);
1872 
1873  /*
1874  * Advance over all three lists simultaneously.
1875  *
1876  * Compare resultfiles[j] with expectfiles[j] always. Tags are optional
1877  * but if there are tags, the tag list has the same length as the other
1878  * two lists.
1879  */
1880  for (rl = resultfiles, el = expectfiles, tl = tags;
1881  rl != NULL; /* rl and el have the same length */
1882  rl = rl->next, el = el->next,
1883  tl = tl ? tl->next : NULL)
1884  {
1885  bool newdiff;
1886 
1887  if (postfunc)
1888  (*postfunc) (rl->str);
1889  newdiff = results_differ(test, rl->str, el->str);
1890  if (newdiff && tl)
1891  {
1892  diag("tag: %s", tl->str);
1893  }
1894  differ |= newdiff;
1895  }
1896 
1897  INSTR_TIME_SUBTRACT(stoptime, starttime);
1898 
1899  if (exit_status != 0)
1900  {
1901  test_status_failed(test, INSTR_TIME_GET_MILLISEC(stoptime), false);
1902  log_child_failure(exit_status);
1903  }
1904  else
1905  {
1906  if (differ)
1907  {
1908  test_status_failed(test, INSTR_TIME_GET_MILLISEC(stoptime), false);
1909  }
1910  else
1911  {
1912  test_status_ok(test, INSTR_TIME_GET_MILLISEC(stoptime), false);
1913  }
1914  }
1915 }

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

Referenced by regression_main().

◆ signal_remove_temp()

static void signal_remove_temp ( SIGNAL_ARGS  )
static

Definition at line 467 of file pg_regress.c.

468 {
469  remove_temp();
470 
471  pqsignal(postgres_signal_arg, SIG_DFL);
472  raise(postgres_signal_arg);
473 }
#define SIG_DFL
Definition: win32_port.h:163

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

Referenced by make_temp_sockdir().

◆ spawn_process()

PID_TYPE spawn_process ( const char *  cmdline)

Definition at line 1197 of file pg_regress.c.

1198 {
1199 #ifndef WIN32
1200  pid_t pid;
1201 
1202  /*
1203  * Must flush I/O buffers before fork.
1204  */
1205  fflush(NULL);
1206 
1207 #ifdef EXEC_BACKEND
1208  pg_disable_aslr();
1209 #endif
1210 
1211  pid = fork();
1212  if (pid == -1)
1213  {
1214  bail("could not fork: %s", strerror(errno));
1215  }
1216  if (pid == 0)
1217  {
1218  /*
1219  * In child
1220  *
1221  * Instead of using system(), exec the shell directly, and tell it to
1222  * "exec" the command too. This saves two useless processes per
1223  * parallel test case.
1224  */
1225  char *cmdline2;
1226 
1227  cmdline2 = psprintf("exec %s", cmdline);
1228  execl(shellprog, shellprog, "-c", cmdline2, (char *) NULL);
1229  /* Not using the normal bail() here as we want _exit */
1230  bail_noatexit("could not exec \"%s\": %s", shellprog, strerror(errno));
1231  }
1232  /* in parent */
1233  return pid;
1234 #else
1235  PROCESS_INFORMATION pi;
1236  char *cmdline2;
1237  const char *comspec;
1238 
1239  /* Find CMD.EXE location using COMSPEC, if it's set */
1240  comspec = getenv("COMSPEC");
1241  if (comspec == NULL)
1242  comspec = "CMD";
1243 
1244  memset(&pi, 0, sizeof(pi));
1245  cmdline2 = psprintf("\"%s\" /c \"%s\"", comspec, cmdline);
1246 
1247  if (!CreateRestrictedProcess(cmdline2, &pi))
1248  exit(2);
1249 
1250  CloseHandle(pi.hThread);
1251  return pi.hProcess;
1252 #endif
1253 }
static char * shellprog
Definition: pg_regress.c:56
#define bail_noatexit(...)
Definition: pg_regress.c:167

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

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

◆ split_to_stringlist()

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

Definition at line 234 of file pg_regress.c.

235 {
236  char *sc = pg_strdup(s);
237  char *token = strtok(sc, delim);
238 
239  while (token)
240  {
241  add_stringlist_item(listhead, token);
242  token = strtok(NULL, delim);
243  }
244  free(sc);
245 }
#define token
Definition: indent_globs.h:126

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

Referenced by regression_main().

◆ stop_postmaster()

static void stop_postmaster ( void  )
static

Definition at line 420 of file pg_regress.c.

421 {
422  if (postmaster_running)
423  {
424  /* We use pg_ctl to issue the kill and wait for stop */
425  char buf[MAXPGPATH * 2];
426  int r;
427 
428  snprintf(buf, sizeof(buf),
429  "\"%s%spg_ctl\" stop -D \"%s/data\" -s",
430  bindir ? bindir : "",
431  bindir ? "/" : "",
432  temp_instance);
433  fflush(NULL);
434  r = system(buf);
435  if (r != 0)
436  {
437  /* Not using the normal bail() as we want _exit */
438  bail_noatexit(_("could not stop postmaster: exit code was %d"), r);
439  }
440 
441  postmaster_running = false;
442  }
443 }

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

Referenced by regression_main().

◆ string_matches_pattern()

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

Definition at line 532 of file pg_regress.c.

533 {
534  while (*str && *pattern)
535  {
536  if (*pattern == '.' && pattern[1] == '*')
537  {
538  pattern += 2;
539  /* Trailing .* matches everything. */
540  if (*pattern == '\0')
541  return true;
542 
543  /*
544  * Otherwise, scan for a text position at which we can match the
545  * rest of the pattern.
546  */
547  while (*str)
548  {
549  /*
550  * Optimization to prevent most recursion: don't recurse
551  * unless first pattern char might match this text char.
552  */
553  if (*str == *pattern || *pattern == '.')
554  {
555  if (string_matches_pattern(str, pattern))
556  return true;
557  }
558 
559  str++;
560  }
561 
562  /*
563  * End of text with no match.
564  */
565  return false;
566  }
567  else if (*pattern != '.' && *str != *pattern)
568  {
569  /*
570  * Not the single-character wildcard and no explicit match? Then
571  * time to quit...
572  */
573  return false;
574  }
575 
576  str++;
577  pattern++;
578  }
579 
580  if (*pattern == '\0')
581  return true; /* end of pattern, so declare match */
582 
583  /* End of input string. Do we have matching pattern remaining? */
584  while (*pattern == '.' && pattern[1] == '*')
585  pattern += 2;
586  if (*pattern == '\0')
587  return true; /* end of pattern, so declare match */
588 
589  return false;
590 }

References generate_unaccent_rules::str.

Referenced by load_resultmap().

◆ test_status_failed()

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

Definition at line 310 of file pg_regress.c.

311 {
312  /*
313  * Save failed tests in a buffer such that we can print a summary at the
314  * end with diag() to ensure it's shown even under test harnesses.
315  */
316  if (!failed_tests)
318  else
320 
321  appendStringInfo(failed_tests, " %s", testname);
322 
323  fail_count++;
324 
325  test_status_print(false, testname, runtime, parallel);
326 }
static StringInfo failed_tests
Definition: pg_regress.c:133
static void test_status_print(bool ok, const char *testname, double runtime, bool parallel)
Definition: pg_regress.c:279

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

Referenced by run_schedule(), and run_single_test().

◆ test_status_ok()

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

Definition at line 302 of file pg_regress.c.

303 {
304  success_count++;
305 
306  test_status_print(true, testname, runtime, parallel);
307 }

References success_count, and test_status_print().

Referenced by run_schedule(), and run_single_test().

◆ test_status_print()

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

Definition at line 279 of file pg_regress.c.

280 {
281  int testnumber = fail_count + success_count;
282 
283  /*
284  * Testnumbers are padded to 5 characters to ensure that testnames align
285  * vertically (assuming at most 9999 tests). Testnames are prefixed with
286  * a leading character to indicate being run in parallel or not. A leading
287  * '+' indicates a parallel test, '-' indicates a single test.
288  */
289  emit_tap_output(TEST_STATUS, "%sok %-5i%*s %c %-*s %8.0f ms",
290  (ok ? "" : "not "),
291  testnumber,
292  /* If ok, indent with four spaces matching "not " */
293  (ok ? (int) strlen("not ") : 0), "",
294  /* Prefix a parallel test '+' and a single test with '-' */
295  (parallel ? '+' : '-'),
296  /* Testnames are padded to align runtimes */
297  TESTNAME_WIDTH, testname,
298  runtime);
299 }
static void static void emit_tap_output(TAPtype type, const char *fmt,...) pg_attribute_printf(2
Definition: pg_regress.c:330
#define TESTNAME_WIDTH
Definition: pg_regress.c:77

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

Referenced by test_status_failed(), and test_status_ok().

◆ unlimit_core_size()

static void unlimit_core_size ( void  )
static

Definition at line 175 of file pg_regress.c.

176 {
177  struct rlimit lim;
178 
179  getrlimit(RLIMIT_CORE, &lim);
180  if (lim.rlim_max == 0)
181  {
182  diag("could not set core size: disallowed by hard limit");
183  return;
184  }
185  else if (lim.rlim_max == RLIM_INFINITY || lim.rlim_cur < lim.rlim_max)
186  {
187  lim.rlim_cur = lim.rlim_max;
188  setrlimit(RLIMIT_CORE, &lim);
189  }
190 }

References diag.

Referenced by regression_main().

◆ wait_for_tests()

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

Definition at line 1553 of file pg_regress.c.

1555 {
1556  int tests_left;
1557  int i;
1558 
1559 #ifdef WIN32
1560  PID_TYPE *active_pids = pg_malloc(num_tests * sizeof(PID_TYPE));
1561 
1562  memcpy(active_pids, pids, num_tests * sizeof(PID_TYPE));
1563 #endif
1564 
1565  tests_left = num_tests;
1566  while (tests_left > 0)
1567  {
1568  PID_TYPE p;
1569 
1570 #ifndef WIN32
1571  int exit_status;
1572 
1573  p = wait(&exit_status);
1574 
1575  if (p == INVALID_PID)
1576  {
1577  bail("failed to wait for subprocesses: %s", strerror(errno));
1578  }
1579 #else
1580  DWORD exit_status;
1581  int r;
1582 
1583  r = WaitForMultipleObjects(tests_left, active_pids, FALSE, INFINITE);
1584  if (r < WAIT_OBJECT_0 || r >= WAIT_OBJECT_0 + tests_left)
1585  {
1586  bail("failed to wait for subprocesses: error code %lu",
1587  GetLastError());
1588  }
1589  p = active_pids[r - WAIT_OBJECT_0];
1590  /* compact the active_pids array */
1591  active_pids[r - WAIT_OBJECT_0] = active_pids[tests_left - 1];
1592 #endif /* WIN32 */
1593 
1594  for (i = 0; i < num_tests; i++)
1595  {
1596  if (p == pids[i])
1597  {
1598 #ifdef WIN32
1599  GetExitCodeProcess(pids[i], &exit_status);
1600  CloseHandle(pids[i]);
1601 #endif
1602  pids[i] = INVALID_PID;
1603  statuses[i] = (int) exit_status;
1604  INSTR_TIME_SET_CURRENT(stoptimes[i]);
1605  if (names)
1606  note_detail(" %s", names[i]);
1607  tests_left--;
1608  break;
1609  }
1610  }
1611  }
1612 
1613 #ifdef WIN32
1614  free(active_pids);
1615 #endif
1616 }

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

Referenced by run_schedule(), and run_single_test().

Variable Documentation

◆ basic_diff_opts

const char* basic_diff_opts = ""

Definition at line 65 of file pg_regress.c.

Referenced by results_differ().

◆ bindir

char* bindir = PGBINDIR

◆ config_auth_datadir

char* config_auth_datadir = NULL
static

Definition at line 122 of file pg_regress.c.

Referenced by regression_main().

◆ dblist

◆ debug

bool debug = false

Definition at line 99 of file pg_regress.c.

Referenced by regression_main().

◆ difffilename

char* difffilename
static

Definition at line 128 of file pg_regress.c.

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

◆ dlpath

char* dlpath = PKGLIBDIR
static

Definition at line 119 of file pg_regress.c.

Referenced by initialize_environment(), and regression_main().

◆ encoding

char* encoding = NULL
static

Definition at line 108 of file pg_regress.c.

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

◆ expecteddir

char* expecteddir = "."

Definition at line 102 of file pg_regress.c.

Referenced by ecpg_start_test(), and regression_main().

◆ extra_tests

_stringlist* extra_tests = NULL
static

Definition at line 110 of file pg_regress.c.

Referenced by regression_main().

◆ extraroles

_stringlist* extraroles = NULL
static

Definition at line 121 of file pg_regress.c.

Referenced by regression_main().

◆ fail_count

int fail_count = 0
static

Definition at line 142 of file pg_regress.c.

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

◆ failed_tests

StringInfo failed_tests = NULL
static

Definition at line 133 of file pg_regress.c.

Referenced by test_status_failed().

◆ host_platform

char* host_platform = HOST_TUPLE

Definition at line 53 of file pg_regress.c.

Referenced by load_resultmap().

◆ hostname

char* hostname = NULL
static

◆ in_note

bool in_note = false
static

Definition at line 134 of file pg_regress.c.

Referenced by emit_tap_output_v().

◆ inputdir

◆ launcher

char* launcher = NULL

Definition at line 104 of file pg_regress.c.

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

◆ loadextension

_stringlist* loadextension = NULL
static

Definition at line 105 of file pg_regress.c.

Referenced by create_database(), and regression_main().

◆ logfile

FILE* logfile
static

◆ logfilename

char* logfilename
static

Definition at line 126 of file pg_regress.c.

Referenced by open_result_files(), and regression_main().

◆ max_concurrent_tests

int max_concurrent_tests = 0
static

Definition at line 107 of file pg_regress.c.

Referenced by regression_main(), and run_schedule().

◆ max_connections

int max_connections = 0
static

Definition at line 106 of file pg_regress.c.

Referenced by regression_main(), and run_schedule().

◆ nolocale

bool nolocale = false
static

Definition at line 113 of file pg_regress.c.

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

◆ outputdir

◆ port

int port = -1
static

Definition at line 116 of file pg_regress.c.

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

◆ port_specified_by_user

bool port_specified_by_user = false
static

Definition at line 118 of file pg_regress.c.

Referenced by regression_main().

◆ portstr

char portstr[16]
static

Definition at line 117 of file pg_regress.c.

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

◆ postmaster_pid

PID_TYPE postmaster_pid = INVALID_PID
static

Definition at line 138 of file pg_regress.c.

Referenced by regression_main().

◆ postmaster_running

bool postmaster_running = false
static

Definition at line 139 of file pg_regress.c.

Referenced by regression_main(), and stop_postmaster().

◆ pretty_diff_opts

const char* pretty_diff_opts = "-U3"

Definition at line 66 of file pg_regress.c.

Referenced by regression_main(), and results_differ().

◆ progname

const char* progname
static

Definition at line 125 of file pg_regress.c.

Referenced by help(), and regression_main().

◆ resultmap

_resultmap* resultmap = NULL
static

Definition at line 136 of file pg_regress.c.

Referenced by get_expectfile(), and load_resultmap().

◆ schedulelist

_stringlist* schedulelist = NULL
static

Definition at line 109 of file pg_regress.c.

Referenced by regression_main().

◆ shellprog

char* shellprog = SHELLPROG
static

Definition at line 56 of file pg_regress.c.

Referenced by spawn_process().

◆ sockdir

const char* sockdir
static

Definition at line 129 of file pg_regress.c.

Referenced by initialize_environment(), and regression_main().

◆ socklock

char socklock[MAXPGPATH]
static

Definition at line 132 of file pg_regress.c.

Referenced by make_temp_sockdir(), and remove_temp().

◆ sockself

char sockself[MAXPGPATH]
static

Definition at line 131 of file pg_regress.c.

Referenced by make_temp_sockdir(), and remove_temp().

◆ success_count

int success_count = 0
static

Definition at line 141 of file pg_regress.c.

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

◆ temp_configs

_stringlist* temp_configs = NULL
static

Definition at line 112 of file pg_regress.c.

Referenced by regression_main().

◆ temp_instance

char* temp_instance = NULL
static

Definition at line 111 of file pg_regress.c.

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

◆ temp_sockdir

const char* temp_sockdir
static

Definition at line 130 of file pg_regress.c.

Referenced by make_temp_sockdir(), and remove_temp().

◆ use_existing

bool use_existing = false
static

Definition at line 114 of file pg_regress.c.

Referenced by regression_main().

◆ user