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

Go to the source code of this file.

Data Structures

struct  _resultmap
 

Macros

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

Typedefs

typedef struct _resultmap _resultmap
 

Functions

static bool directory_exists (const char *dir)
 
static void make_directory (const char *dir)
 
static void header (const char *fmt,...) pg_attribute_printf(1
 
static void static void status (const char *fmt,...) pg_attribute_printf(1
 
static void static void static void psql_command (const char *database, const char *query,...) pg_attribute_printf(2
 
static void static void static void void add_stringlist_item (_stringlist **listhead, const char *str)
 
static void free_stringlist (_stringlist **listhead)
 
static void split_to_stringlist (const char *s, const char *delim, _stringlist **listhead)
 
static void status_end (void)
 
static void stop_postmaster (void)
 
static bool string_matches_pattern (const char *str, const char *pattern)
 
void replace_string (StringInfo string, const char *replace, const char *replacement)
 
static void convert_sourcefiles_in (const char *source_subdir, const char *dest_dir, const char *dest_subdir, const char *suffix)
 
static void convert_sourcefiles (void)
 
static void 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 * 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 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 _resultmapresultmap = NULL
 
static PID_TYPE postmaster_pid = INVALID_PID
 
static bool postmaster_running = false
 
static int success_count = 0
 
static int fail_count = 0
 
static int fail_ignore_count = 0
 

Macro Definition Documentation

◆ MAX_PARALLEL_TESTS

#define MAX_PARALLEL_TESTS   100

Referenced by run_schedule().

◆ ULONGPID

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

Referenced by regression_main().

Typedef Documentation

◆ _resultmap

typedef struct _resultmap _resultmap

Function Documentation

◆ add_stringlist_item()

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

Definition at line 157 of file pg_regress.c.

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

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

158 {
159  _stringlist *newentry = pg_malloc(sizeof(_stringlist));
160  _stringlist *oldentry;
161 
162  newentry->str = pg_strdup(str);
163  newentry->next = NULL;
164  if (*listhead == NULL)
165  *listhead = newentry;
166  else
167  {
168  for (oldentry = *listhead; oldentry->next; oldentry = oldentry->next)
169  /* skip */ ;
170  oldentry->next = newentry;
171  }
172 }
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
char * str
Definition: pg_regress.h:26
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
struct _stringlist * next
Definition: pg_regress.h:27

◆ convert_sourcefiles()

static void convert_sourcefiles ( void  )
static

Definition at line 600 of file pg_regress.c.

References convert_sourcefiles_in(), and outputdir.

Referenced by initialize_environment().

601 {
602  convert_sourcefiles_in("input", outputdir, "sql", "sql");
603  convert_sourcefiles_in("output", outputdir, "expected", "out");
604 }
static void convert_sourcefiles_in(const char *source_subdir, const char *dest_dir, const char *dest_subdir, const char *suffix)
Definition: pg_regress.c:476
char * outputdir
Definition: pg_regress.c:78

◆ convert_sourcefiles_in()

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

Definition at line 476 of file pg_regress.c.

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

Referenced by convert_sourcefiles().

477 {
478  char testtablespace[MAXPGPATH];
479  char indir[MAXPGPATH];
480  char outdir_sub[MAXPGPATH];
481  char **name;
482  char **names;
483  int count = 0;
484 
485  snprintf(indir, MAXPGPATH, "%s/%s", inputdir, source_subdir);
486 
487  /* Check that indir actually exists and is a directory */
488  if (!directory_exists(indir))
489  {
490  /*
491  * No warning, to avoid noise in tests that do not have these
492  * directories; for example, ecpg, contrib and src/pl.
493  */
494  return;
495  }
496 
497  names = pgfnames(indir);
498  if (!names)
499  /* Error logged in pgfnames */
500  exit(2);
501 
502  /* Create the "dest" subdirectory if not present */
503  snprintf(outdir_sub, MAXPGPATH, "%s/%s", dest_dir, dest_subdir);
504  if (!directory_exists(outdir_sub))
505  make_directory(outdir_sub);
506 
507  snprintf(testtablespace, MAXPGPATH, "%s/testtablespace", outputdir);
508 
509 #ifdef WIN32
510 
511  /*
512  * On Windows only, clean out the test tablespace dir, or create it if it
513  * doesn't exist so as it is possible to run the regression tests as a
514  * Windows administrative user account with the restricted token obtained
515  * when starting pg_regress. On other platforms we expect the Makefile to
516  * take care of that.
517  */
518  if (directory_exists(testtablespace))
519  if (!rmtree(testtablespace, true))
520  {
521  fprintf(stderr, _("\n%s: could not remove test tablespace \"%s\"\n"),
522  progname, testtablespace);
523  exit(2);
524  }
525  make_directory(testtablespace);
526 #endif
527 
528  /* finally loop on each file and do the replacement */
529  for (name = names; *name; name++)
530  {
531  char srcfile[MAXPGPATH];
532  char destfile[MAXPGPATH];
533  char prefix[MAXPGPATH];
534  FILE *infile,
535  *outfile;
536  StringInfoData line;
537 
538  /* reject filenames not finishing in ".source" */
539  if (strlen(*name) < 8)
540  continue;
541  if (strcmp(*name + strlen(*name) - 7, ".source") != 0)
542  continue;
543 
544  count++;
545 
546  /* build the full actual paths to open */
547  snprintf(prefix, strlen(*name) - 6, "%s", *name);
548  snprintf(srcfile, MAXPGPATH, "%s/%s", indir, *name);
549  snprintf(destfile, MAXPGPATH, "%s/%s/%s.%s", dest_dir, dest_subdir,
550  prefix, suffix);
551 
552  infile = fopen(srcfile, "r");
553  if (!infile)
554  {
555  fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
556  progname, srcfile, strerror(errno));
557  exit(2);
558  }
559  outfile = fopen(destfile, "w");
560  if (!outfile)
561  {
562  fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
563  progname, destfile, strerror(errno));
564  exit(2);
565  }
566 
567  initStringInfo(&line);
568 
569  while (pg_get_line_buf(infile, &line))
570  {
571  replace_string(&line, "@abs_srcdir@", inputdir);
572  replace_string(&line, "@abs_builddir@", outputdir);
573  replace_string(&line, "@testtablespace@", testtablespace);
574  replace_string(&line, "@libdir@", dlpath);
575  replace_string(&line, "@DLSUFFIX@", DLSUFFIX);
576  fputs(line.data, outfile);
577  }
578 
579  pfree(line.data);
580  fclose(infile);
581  fclose(outfile);
582  }
583 
584  /*
585  * If we didn't process any files, complain because it probably means
586  * somebody neglected to pass the needed --inputdir argument.
587  */
588  if (count <= 0)
589  {
590  fprintf(stderr, _("%s: no *.source files found in \"%s\"\n"),
591  progname, indir);
592  exit(2);
593  }
594 
595  pgfnames_cleanup(names);
596 }
bool pg_get_line_buf(FILE *stream, StringInfo buf)
Definition: pg_get_line.c:88
static bool directory_exists(const char *dir)
Definition: pg_regress.c:1279
char ** pgfnames(const char *path)
Definition: pgfnames.c:37
static const char * progname
Definition: pg_regress.c:100
static void make_directory(const char *dir)
Definition: pg_regress.c:1292
#define fprintf
Definition: port.h:219
void pfree(void *pointer)
Definition: mcxt.c:1057
#define MAXPGPATH
static char * dlpath
Definition: pg_regress.c:94
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
bool rmtree(const char *path, bool rmtopdir)
Definition: rmtree.c:42
char * outputdir
Definition: pg_regress.c:78
char * inputdir
Definition: pg_regress.c:77
static void infile(const char *filename)
Definition: zic.c:1241
void pgfnames_cleanup(char **filenames)
Definition: pgfnames.c:86
#define strerror
Definition: port.h:228
const char * name
Definition: encode.c:515
void replace_string(StringInfo string, const char *replace, const char *replacement)
Definition: pg_regress.c:447
static char * outfile
#define snprintf
Definition: port.h:215
#define _(x)
Definition: elog.c:89

◆ create_database()

static void create_database ( const char *  dbname)
static

Definition at line 1988 of file pg_regress.c.

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

Referenced by regression_main().

1989 {
1990  _stringlist *sl;
1991 
1992  /*
1993  * We use template0 so that any installation-local cruft in template1 will
1994  * not mess up the tests.
1995  */
1996  header(_("creating database \"%s\""), dbname);
1997  if (encoding)
1998  psql_command("postgres", "CREATE DATABASE \"%s\" TEMPLATE=template0 ENCODING='%s'%s", dbname, encoding,
1999  (nolocale) ? " LC_COLLATE='C' LC_CTYPE='C'" : "");
2000  else
2001  psql_command("postgres", "CREATE DATABASE \"%s\" TEMPLATE=template0%s", dbname,
2002  (nolocale) ? " LC_COLLATE='C' LC_CTYPE='C'" : "");
2004  "ALTER DATABASE \"%s\" SET lc_messages TO 'C';"
2005  "ALTER DATABASE \"%s\" SET lc_monetary TO 'C';"
2006  "ALTER DATABASE \"%s\" SET lc_numeric TO 'C';"
2007  "ALTER DATABASE \"%s\" SET lc_time TO 'C';"
2008  "ALTER DATABASE \"%s\" SET bytea_output TO 'hex';"
2009  "ALTER DATABASE \"%s\" SET timezone_abbreviations TO 'Default';",
2011 
2012  /*
2013  * Install any requested extensions. We use CREATE IF NOT EXISTS so that
2014  * this will work whether or not the extension is preinstalled.
2015  */
2016  for (sl = loadextension; sl != NULL; sl = sl->next)
2017  {
2018  header(_("installing %s"), sl->str);
2019  psql_command(dbname, "CREATE EXTENSION IF NOT EXISTS \"%s\"", sl->str);
2020  }
2021 }
char * str
Definition: pg_regress.h:26
static char * encoding
Definition: pg_regress.c:84
static _stringlist * loadextension
Definition: pg_regress.c:81
static void static void static void psql_command(const char *database, const char *query,...) pg_attribute_printf(2
Definition: pg_regress.c:1112
char * dbname
Definition: streamutil.c:51
static void header(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:210
struct _stringlist * next
Definition: pg_regress.h:27
static bool nolocale
Definition: pg_regress.c:89
#define _(x)
Definition: elog.c:89

◆ create_role()

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

Definition at line 2031 of file pg_regress.c.

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

Referenced by regression_main().

2032 {
2033  header(_("creating role \"%s\""), rolename);
2034  psql_command("postgres", "CREATE ROLE \"%s\" WITH LOGIN", rolename);
2035  for (; granted_dbs != NULL; granted_dbs = granted_dbs->next)
2036  {
2037  psql_command("postgres", "GRANT ALL ON DATABASE \"%s\" TO \"%s\"",
2038  granted_dbs->str, rolename);
2039  }
2040 }
char * str
Definition: pg_regress.h:26
static void static void static void psql_command(const char *database, const char *query,...) pg_attribute_printf(2
Definition: pg_regress.c:1112
static void header(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:210
struct _stringlist * next
Definition: pg_regress.h:27
#define _(x)
Definition: elog.c:89

◆ directory_exists()

static bool directory_exists ( const char *  dir)
static

Definition at line 1279 of file pg_regress.c.

References S_ISDIR, stat::st_mode, and stat.

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

1280 {
1281  struct stat st;
1282 
1283  if (stat(dir, &st) != 0)
1284  return false;
1285  if (S_ISDIR(st.st_mode))
1286  return true;
1287  return false;
1288 }
#define S_ISDIR(m)
Definition: win32_port.h:316
#define stat
Definition: win32_port.h:275

◆ drop_database_if_exists()

static void drop_database_if_exists ( const char *  dbname)
static

Definition at line 1981 of file pg_regress.c.

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

Referenced by regression_main().

1982 {
1983  header(_("dropping database \"%s\""), dbname);
1984  psql_command("postgres", "DROP DATABASE IF EXISTS \"%s\"", dbname);
1985 }
static void static void static void psql_command(const char *database, const char *query,...) pg_attribute_printf(2
Definition: pg_regress.c:1112
char * dbname
Definition: streamutil.c:51
static void header(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:210
#define _(x)
Definition: elog.c:89

◆ drop_role_if_exists()

static void drop_role_if_exists ( const char *  rolename)
static

Definition at line 2024 of file pg_regress.c.

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

Referenced by regression_main().

2025 {
2026  header(_("dropping role \"%s\""), rolename);
2027  psql_command("postgres", "DROP ROLE IF EXISTS \"%s\"", rolename);
2028 }
static void static void static void psql_command(const char *database, const char *query,...) pg_attribute_printf(2
Definition: pg_regress.c:1112
static void header(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:210
#define _(x)
Definition: elog.c:89

◆ file_exists()

bool file_exists ( const char *  file)

Definition at line 1268 of file pg_regress.c.

Referenced by results_differ().

1269 {
1270  FILE *f = fopen(file, "r");
1271 
1272  if (!f)
1273  return false;
1274  fclose(f);
1275  return true;
1276 }

◆ file_line_count()

static int file_line_count ( const char *  file)
static

Definition at line 1246 of file pg_regress.c.

References _, fprintf, progname, and strerror.

Referenced by results_differ().

1247 {
1248  int c;
1249  int l = 0;
1250  FILE *f = fopen(file, "r");
1251 
1252  if (!f)
1253  {
1254  fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
1255  progname, file, strerror(errno));
1256  return -1;
1257  }
1258  while ((c = fgetc(f)) != EOF)
1259  {
1260  if (c == '\n')
1261  l++;
1262  }
1263  fclose(f);
1264  return l;
1265 }
static const char * progname
Definition: pg_regress.c:100
#define fprintf
Definition: port.h:219
char * c
#define strerror
Definition: port.h:228
#define _(x)
Definition: elog.c:89

◆ file_size()

static long file_size ( const char *  file)
static

Definition at line 1225 of file pg_regress.c.

References _, fprintf, progname, and strerror.

Referenced by regression_main(), and run_diff().

1226 {
1227  long r;
1228  FILE *f = fopen(file, "r");
1229 
1230  if (!f)
1231  {
1232  fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
1233  progname, file, strerror(errno));
1234  return -1;
1235  }
1236  fseek(f, 0, SEEK_END);
1237  r = ftell(f);
1238  fclose(f);
1239  return r;
1240 }
static const char * progname
Definition: pg_regress.c:100
#define fprintf
Definition: port.h:219
#define strerror
Definition: port.h:228
#define _(x)
Definition: elog.c:89

◆ free_stringlist()

static void free_stringlist ( _stringlist **  listhead)
static

Definition at line 178 of file pg_regress.c.

References free.

Referenced by regression_main(), and run_schedule().

179 {
180  if (listhead == NULL || *listhead == NULL)
181  return;
182  if ((*listhead)->next != NULL)
183  free_stringlist(&((*listhead)->next));
184  free((*listhead)->str);
185  free(*listhead);
186  *listhead = NULL;
187 }
static void free_stringlist(_stringlist **listhead)
Definition: pg_regress.c:178
#define free(a)
Definition: header.h:65

◆ get_alternative_expectfile()

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

Definition at line 1306 of file pg_regress.c.

References free, malloc, and snprintf.

Referenced by results_differ().

1307 {
1308  char *last_dot;
1309  int ssize = strlen(expectfile) + 2 + 1;
1310  char *tmp;
1311  char *s;
1312 
1313  if (!(tmp = (char *) malloc(ssize)))
1314  return NULL;
1315 
1316  if (!(s = (char *) malloc(ssize)))
1317  {
1318  free(tmp);
1319  return NULL;
1320  }
1321 
1322  strcpy(tmp, expectfile);
1323  last_dot = strrchr(tmp, '.');
1324  if (!last_dot)
1325  {
1326  free(tmp);
1327  free(s);
1328  return NULL;
1329  }
1330  *last_dot = '\0';
1331  snprintf(s, ssize, "%s_%d.%s", tmp, i, last_dot + 1);
1332  free(tmp);
1333  return s;
1334 }
#define malloc(a)
Definition: header.h:50
#define free(a)
Definition: header.h:65
int i
#define snprintf
Definition: port.h:215

◆ get_expectfile()

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

Definition at line 702 of file pg_regress.c.

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

Referenced by results_differ().

703 {
704  char *file_type;
705  _resultmap *rm;
706 
707  /*
708  * Determine the file type from the file name. This is just what is
709  * following the last dot in the file name.
710  */
711  if (!file || !(file_type = strrchr(file, '.')))
712  return NULL;
713 
714  file_type++;
715 
716  for (rm = resultmap; rm != NULL; rm = rm->next)
717  {
718  if (strcmp(testname, rm->test) == 0 && strcmp(file_type, rm->type) == 0)
719  {
720  return rm->resultfile;
721  }
722  }
723 
724  return NULL;
725 }
struct _resultmap * next
Definition: pg_regress.c:49
static _resultmap * resultmap
Definition: pg_regress.c:111
char * test
Definition: pg_regress.c:46
char * type
Definition: pg_regress.c:47
char * resultfile
Definition: pg_regress.c:48

◆ header()

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

◆ help()

static void help ( void  )
static

Definition at line 2043 of file pg_regress.c.

References _, printf, and progname.

Referenced by regression_main().

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

◆ initialize_environment()

static void initialize_environment ( void  )
static

Definition at line 731 of file pg_regress.c.

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

Referenced by regression_main().

732 {
733  /*
734  * Set default application_name. (The test_start_function may choose to
735  * override this, but if it doesn't, we have something useful in place.)
736  */
737  setenv("PGAPPNAME", "pg_regress", 1);
738 
739  if (nolocale)
740  {
741  /*
742  * Clear out any non-C locale settings
743  */
744  unsetenv("LC_COLLATE");
745  unsetenv("LC_CTYPE");
746  unsetenv("LC_MONETARY");
747  unsetenv("LC_NUMERIC");
748  unsetenv("LC_TIME");
749  unsetenv("LANG");
750 
751  /*
752  * Most platforms have adopted the POSIX locale as their
753  * implementation-defined default locale. Exceptions include native
754  * Windows, macOS with --enable-nls, and Cygwin with --enable-nls.
755  * (Use of --enable-nls matters because libintl replaces setlocale().)
756  * Also, PostgreSQL does not support macOS with locale environment
757  * variables unset; see PostmasterMain().
758  */
759 #if defined(WIN32) || defined(__CYGWIN__) || defined(__darwin__)
760  setenv("LANG", "C", 1);
761 #endif
762  }
763 
764  /*
765  * Set translation-related settings to English; otherwise psql will
766  * produce translated messages and produce diffs. (XXX If we ever support
767  * translation of pg_regress, this needs to be moved elsewhere, where psql
768  * is actually called.)
769  */
770  unsetenv("LANGUAGE");
771  unsetenv("LC_ALL");
772  setenv("LC_MESSAGES", "C", 1);
773 
774  /*
775  * Set encoding as requested
776  */
777  if (encoding)
778  setenv("PGCLIENTENCODING", encoding, 1);
779  else
780  unsetenv("PGCLIENTENCODING");
781 
782  /*
783  * Set timezone and datestyle for datetime-related tests
784  */
785  setenv("PGTZ", "PST8PDT", 1);
786  setenv("PGDATESTYLE", "Postgres, MDY", 1);
787 
788  /*
789  * Likewise set intervalstyle to ensure consistent results. This is a bit
790  * more painful because we must use PGOPTIONS, and we want to preserve the
791  * user's ability to set other variables through that.
792  */
793  {
794  const char *my_pgoptions = "-c intervalstyle=postgres_verbose";
795  const char *old_pgoptions = getenv("PGOPTIONS");
796  char *new_pgoptions;
797 
798  if (!old_pgoptions)
799  old_pgoptions = "";
800  new_pgoptions = psprintf("%s %s",
801  old_pgoptions, my_pgoptions);
802  setenv("PGOPTIONS", new_pgoptions, 1);
803  free(new_pgoptions);
804  }
805 
806  if (temp_instance)
807  {
808  /*
809  * Clear out any environment vars that might cause psql to connect to
810  * the wrong postmaster, or otherwise behave in nondefault ways. (Note
811  * we also use psql's -X switch consistently, so that ~/.psqlrc files
812  * won't mess things up.) Also, set PGPORT to the temp port, and set
813  * PGHOST depending on whether we are using TCP or Unix sockets.
814  */
815  unsetenv("PGDATABASE");
816  unsetenv("PGUSER");
817  unsetenv("PGSERVICE");
818  unsetenv("PGSSLMODE");
819  unsetenv("PGREQUIRESSL");
820  unsetenv("PGCONNECT_TIMEOUT");
821  unsetenv("PGDATA");
822 #ifdef HAVE_UNIX_SOCKETS
823  if (hostname != NULL)
824  setenv("PGHOST", hostname, 1);
825  else
826  {
827  sockdir = getenv("PG_REGRESS_SOCK_DIR");
828  if (!sockdir)
829  sockdir = make_temp_sockdir();
830  setenv("PGHOST", sockdir, 1);
831  }
832 #else
833  Assert(hostname != NULL);
834  setenv("PGHOST", hostname, 1);
835 #endif
836  unsetenv("PGHOSTADDR");
837  if (port != -1)
838  {
839  char s[16];
840 
841  sprintf(s, "%d", port);
842  setenv("PGPORT", s, 1);
843  }
844  }
845  else
846  {
847  const char *pghost;
848  const char *pgport;
849 
850  /*
851  * When testing an existing install, we honor existing environment
852  * variables, except if they're overridden by command line options.
853  */
854  if (hostname != NULL)
855  {
856  setenv("PGHOST", hostname, 1);
857  unsetenv("PGHOSTADDR");
858  }
859  if (port != -1)
860  {
861  char s[16];
862 
863  sprintf(s, "%d", port);
864  setenv("PGPORT", s, 1);
865  }
866  if (user != NULL)
867  setenv("PGUSER", user, 1);
868 
869  /*
870  * However, we *don't* honor PGDATABASE, since we certainly don't wish
871  * to connect to whatever database the user might like as default.
872  * (Most tests override PGDATABASE anyway, but there are some ECPG
873  * test cases that don't.)
874  */
875  unsetenv("PGDATABASE");
876 
877  /*
878  * Report what we're connecting to
879  */
880  pghost = getenv("PGHOST");
881  pgport = getenv("PGPORT");
882 #ifndef HAVE_UNIX_SOCKETS
883  if (!pghost)
884  pghost = "localhost";
885 #endif
886 
887  if (pghost && pgport)
888  printf(_("(using postmaster on %s, port %s)\n"), pghost, pgport);
889  if (pghost && !pgport)
890  printf(_("(using postmaster on %s, default port)\n"), pghost);
891  if (!pghost && pgport)
892  printf(_("(using postmaster on Unix socket, port %s)\n"), pgport);
893  if (!pghost && !pgport)
894  printf(_("(using postmaster on Unix socket, default port)\n"));
895  }
896 
898  load_resultmap();
899 }
static const char * sockdir
Definition: pg_regress.c:104
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
static char * encoding
Definition: pg_regress.c:84
#define printf(...)
Definition: port.h:221
static char * temp_instance
Definition: pg_regress.c:87
static void convert_sourcefiles(void)
Definition: pg_regress.c:600
#define sprintf
Definition: port.h:217
#define setenv(x, y, z)
Definition: win32_port.h:497
static int port
Definition: pg_regress.c:92
char * pghost
Definition: pgbench.c:243
#define free(a)
Definition: header.h:65
#define Assert(condition)
Definition: c.h:792
static void load_resultmap(void)
Definition: pg_regress.c:620
static char * user
Definition: pg_regress.c:95
static bool nolocale
Definition: pg_regress.c:89
static char * hostname
Definition: pg_regress.c:91
#define _(x)
Definition: elog.c:89
char * pgport
Definition: pgbench.c:244
#define unsetenv(x)
Definition: win32_port.h:498

◆ load_resultmap()

static void load_resultmap ( void  )
static

Definition at line 620 of file pg_regress.c.

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

Referenced by initialize_environment().

621 {
622  char buf[MAXPGPATH];
623  FILE *f;
624 
625  /* scan the file ... */
626  snprintf(buf, sizeof(buf), "%s/resultmap", inputdir);
627  f = fopen(buf, "r");
628  if (!f)
629  {
630  /* OK if it doesn't exist, else complain */
631  if (errno == ENOENT)
632  return;
633  fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
634  progname, buf, strerror(errno));
635  exit(2);
636  }
637 
638  while (fgets(buf, sizeof(buf), f))
639  {
640  char *platform;
641  char *file_type;
642  char *expected;
643  int i;
644 
645  /* strip trailing whitespace, especially the newline */
646  i = strlen(buf);
647  while (i > 0 && isspace((unsigned char) buf[i - 1]))
648  buf[--i] = '\0';
649 
650  /* parse out the line fields */
651  file_type = strchr(buf, ':');
652  if (!file_type)
653  {
654  fprintf(stderr, _("incorrectly formatted resultmap entry: %s\n"),
655  buf);
656  exit(2);
657  }
658  *file_type++ = '\0';
659 
660  platform = strchr(file_type, ':');
661  if (!platform)
662  {
663  fprintf(stderr, _("incorrectly formatted resultmap entry: %s\n"),
664  buf);
665  exit(2);
666  }
667  *platform++ = '\0';
668  expected = strchr(platform, '=');
669  if (!expected)
670  {
671  fprintf(stderr, _("incorrectly formatted resultmap entry: %s\n"),
672  buf);
673  exit(2);
674  }
675  *expected++ = '\0';
676 
677  /*
678  * if it's for current platform, save it in resultmap list. Note: by
679  * adding at the front of the list, we ensure that in ambiguous cases,
680  * the last match in the resultmap file is used. This mimics the
681  * behavior of the old shell script.
682  */
683  if (string_matches_pattern(host_platform, platform))
684  {
685  _resultmap *entry = pg_malloc(sizeof(_resultmap));
686 
687  entry->test = pg_strdup(buf);
688  entry->type = pg_strdup(file_type);
689  entry->resultfile = pg_strdup(expected);
690  entry->next = resultmap;
691  resultmap = entry;
692  }
693  }
694  fclose(f);
695 }
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
char * host_platform
Definition: pg_regress.c:55
static const char * progname
Definition: pg_regress.c:100
struct _resultmap * next
Definition: pg_regress.c:49
static bool string_matches_pattern(const char *str, const char *pattern)
Definition: pg_regress.c:379
#define fprintf
Definition: port.h:219
static _resultmap * resultmap
Definition: pg_regress.c:111
#define MAXPGPATH
static char * buf
Definition: pg_test_fsync.c:68
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
char * test
Definition: pg_regress.c:46
char * type
Definition: pg_regress.c:47
char * inputdir
Definition: pg_regress.c:77
#define strerror
Definition: port.h:228
char * resultfile
Definition: pg_regress.c:48
int i
#define snprintf
Definition: port.h:215
#define _(x)
Definition: elog.c:89

◆ log_child_failure()

static void log_child_failure ( int  exitstatus)
static

Definition at line 1595 of file pg_regress.c.

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

Referenced by run_schedule(), and run_single_test().

1596 {
1597  if (WIFEXITED(exitstatus))
1598  status(_(" (test process exited with exit code %d)"),
1599  WEXITSTATUS(exitstatus));
1600  else if (WIFSIGNALED(exitstatus))
1601  {
1602 #if defined(WIN32)
1603  status(_(" (test process was terminated by exception 0x%X)"),
1604  WTERMSIG(exitstatus));
1605 #else
1606  status(_(" (test process was terminated by signal %d: %s)"),
1607  WTERMSIG(exitstatus), pg_strsignal(WTERMSIG(exitstatus)));
1608 #endif
1609  }
1610  else
1611  status(_(" (test process exited with unrecognized status %d)"),
1612  exitstatus);
1613 }
#define WTERMSIG(w)
Definition: win32_port.h:146
#define WIFEXITED(w)
Definition: win32_port.h:143
const char * pg_strsignal(int signum)
Definition: pgstrsignal.c:42
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:227
#define WIFSIGNALED(w)
Definition: win32_port.h:144
#define _(x)
Definition: elog.c:89
#define WEXITSTATUS(w)
Definition: win32_port.h:145

◆ make_directory()

static void make_directory ( const char *  dir)
static

Definition at line 1292 of file pg_regress.c.

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

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

1293 {
1294  if (mkdir(dir, S_IRWXU | S_IRWXG | S_IRWXO) < 0)
1295  {
1296  fprintf(stderr, _("%s: could not create directory \"%s\": %s\n"),
1297  progname, dir, strerror(errno));
1298  exit(2);
1299  }
1300 }
static const char * progname
Definition: pg_regress.c:100
#define fprintf
Definition: port.h:219
#define S_IRWXG
Definition: win32_port.h:301
#define strerror
Definition: port.h:228
#define S_IRWXU
Definition: win32_port.h:289
#define mkdir(a, b)
Definition: win32_port.h:63
#define _(x)
Definition: elog.c:89
#define S_IRWXO
Definition: win32_port.h:313

◆ open_result_files()

static void open_result_files ( void  )
static

Definition at line 1941 of file pg_regress.c.

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

Referenced by regression_main().

1942 {
1943  char file[MAXPGPATH];
1944  FILE *difffile;
1945 
1946  /* create outputdir directory if not present */
1949 
1950  /* create the log file (copy of running status output) */
1951  snprintf(file, sizeof(file), "%s/regression.out", outputdir);
1952  logfilename = pg_strdup(file);
1953  logfile = fopen(logfilename, "w");
1954  if (!logfile)
1955  {
1956  fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
1957  progname, logfilename, strerror(errno));
1958  exit(2);
1959  }
1960 
1961  /* create the diffs file as empty */
1962  snprintf(file, sizeof(file), "%s/regression.diffs", outputdir);
1963  difffilename = pg_strdup(file);
1964  difffile = fopen(difffilename, "w");
1965  if (!difffile)
1966  {
1967  fprintf(stderr, _("%s: could not open file \"%s\" for writing: %s\n"),
1968  progname, difffilename, strerror(errno));
1969  exit(2);
1970  }
1971  /* we don't keep the diffs file open continuously */
1972  fclose(difffile);
1973 
1974  /* also create the results directory if not present */
1975  snprintf(file, sizeof(file), "%s/results", outputdir);
1976  if (!directory_exists(file))
1977  make_directory(file);
1978 }
static bool directory_exists(const char *dir)
Definition: pg_regress.c:1279
static const char * progname
Definition: pg_regress.c:100
static void make_directory(const char *dir)
Definition: pg_regress.c:1292
static FILE * logfile
Definition: pg_regress.c:102
#define fprintf
Definition: port.h:219
static char * difffilename
Definition: pg_regress.c:103
#define MAXPGPATH
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
char * outputdir
Definition: pg_regress.c:78
static char * logfilename
Definition: pg_regress.c:101
#define strerror
Definition: port.h:228
#define snprintf
Definition: port.h:215
#define _(x)
Definition: elog.c:89

◆ psql_command()

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

Definition at line 1112 of file pg_regress.c.

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

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

1113 {
1114  char query_formatted[1024];
1115  char query_escaped[2048];
1116  char psql_cmd[MAXPGPATH + 2048];
1117  va_list args;
1118  char *s;
1119  char *d;
1120 
1121  /* Generate the query with insertion of sprintf arguments */
1122  va_start(args, query);
1123  vsnprintf(query_formatted, sizeof(query_formatted), query, args);
1124  va_end(args);
1125 
1126  /* Now escape any shell double-quote metacharacters */
1127  d = query_escaped;
1128  for (s = query_formatted; *s; s++)
1129  {
1130  if (strchr("\\\"$`", *s))
1131  *d++ = '\\';
1132  *d++ = *s;
1133  }
1134  *d = '\0';
1135 
1136  /* And now we can build and execute the shell command */
1137  snprintf(psql_cmd, sizeof(psql_cmd),
1138  "\"%s%spsql\" -X -c \"%s\" \"%s\"",
1139  bindir ? bindir : "",
1140  bindir ? "/" : "",
1141  query_escaped,
1142  database);
1143 
1144  if (system(psql_cmd) != 0)
1145  {
1146  /* psql probably already reported the error */
1147  fprintf(stderr, _("command failed: %s\n"), psql_cmd);
1148  exit(2);
1149  }
1150 }
#define fprintf
Definition: port.h:219
#define vsnprintf
Definition: port.h:214
#define MAXPGPATH
char * bindir
Definition: pg_regress.c:79
#define snprintf
Definition: port.h:215
#define _(x)
Definition: elog.c:89

◆ regression_main()

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

Definition at line 2092 of file pg_regress.c.

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

Referenced by main().

2096 {
2097  static struct option long_options[] = {
2098  {"help", no_argument, NULL, 'h'},
2099  {"version", no_argument, NULL, 'V'},
2100  {"dbname", required_argument, NULL, 1},
2101  {"debug", no_argument, NULL, 2},
2102  {"inputdir", required_argument, NULL, 3},
2103  {"max-connections", required_argument, NULL, 5},
2104  {"encoding", required_argument, NULL, 6},
2105  {"outputdir", required_argument, NULL, 7},
2106  {"schedule", required_argument, NULL, 8},
2107  {"temp-instance", required_argument, NULL, 9},
2108  {"no-locale", no_argument, NULL, 10},
2109  {"host", required_argument, NULL, 13},
2110  {"port", required_argument, NULL, 14},
2111  {"user", required_argument, NULL, 15},
2112  {"bindir", required_argument, NULL, 16},
2113  {"dlpath", required_argument, NULL, 17},
2114  {"create-role", required_argument, NULL, 18},
2115  {"temp-config", required_argument, NULL, 19},
2116  {"use-existing", no_argument, NULL, 20},
2117  {"launcher", required_argument, NULL, 21},
2118  {"load-extension", required_argument, NULL, 22},
2119  {"config-auth", required_argument, NULL, 24},
2120  {"max-concurrent-tests", required_argument, NULL, 25},
2121  {NULL, 0, NULL, 0}
2122  };
2123 
2124  bool use_unix_sockets;
2125  _stringlist *sl;
2126  int c;
2127  int i;
2128  int option_index;
2129  char buf[MAXPGPATH * 4];
2130  char buf2[MAXPGPATH * 4];
2131 
2132  pg_logging_init(argv[0]);
2133  progname = get_progname(argv[0]);
2134  set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_regress"));
2135 
2137 
2138  atexit(stop_postmaster);
2139 
2140 #if !defined(HAVE_UNIX_SOCKETS)
2141  use_unix_sockets = false;
2142 #elif defined(WIN32)
2143 
2144  /*
2145  * We don't use Unix-domain sockets on Windows by default, even if the
2146  * build supports them. (See comment at remove_temp() for a reason.)
2147  * Override at your own risk.
2148  */
2149  use_unix_sockets = getenv("PG_TEST_USE_UNIX_SOCKETS") ? true : false;
2150 #else
2151  use_unix_sockets = true;
2152 #endif
2153 
2154  if (!use_unix_sockets)
2155  hostname = "localhost";
2156 
2157  /*
2158  * We call the initialization function here because that way we can set
2159  * default parameters and let them be overwritten by the commandline.
2160  */
2161  ifunc(argc, argv);
2162 
2163  if (getenv("PG_REGRESS_DIFF_OPTS"))
2164  pretty_diff_opts = getenv("PG_REGRESS_DIFF_OPTS");
2165 
2166  while ((c = getopt_long(argc, argv, "hV", long_options, &option_index)) != -1)
2167  {
2168  switch (c)
2169  {
2170  case 'h':
2171  help();
2172  exit(0);
2173  case 'V':
2174  puts("pg_regress (PostgreSQL) " PG_VERSION);
2175  exit(0);
2176  case 1:
2177 
2178  /*
2179  * If a default database was specified, we need to remove it
2180  * before we add the specified one.
2181  */
2184  break;
2185  case 2:
2186  debug = true;
2187  break;
2188  case 3:
2190  break;
2191  case 5:
2192  max_connections = atoi(optarg);
2193  break;
2194  case 6:
2196  break;
2197  case 7:
2199  break;
2200  case 8:
2202  break;
2203  case 9:
2205  break;
2206  case 10:
2207  nolocale = true;
2208  break;
2209  case 13:
2211  break;
2212  case 14:
2213  port = atoi(optarg);
2214  port_specified_by_user = true;
2215  break;
2216  case 15:
2217  user = pg_strdup(optarg);
2218  break;
2219  case 16:
2220  /* "--bindir=" means to use PATH */
2221  if (strlen(optarg))
2222  bindir = pg_strdup(optarg);
2223  else
2224  bindir = NULL;
2225  break;
2226  case 17:
2227  dlpath = pg_strdup(optarg);
2228  break;
2229  case 18:
2231  break;
2232  case 19:
2234  break;
2235  case 20:
2236  use_existing = true;
2237  break;
2238  case 21:
2240  break;
2241  case 22:
2243  break;
2244  case 24:
2246  break;
2247  case 25:
2248  max_concurrent_tests = atoi(optarg);
2249  break;
2250  default:
2251  /* getopt_long already emitted a complaint */
2252  fprintf(stderr, _("\nTry \"%s -h\" for more information.\n"),
2253  progname);
2254  exit(2);
2255  }
2256  }
2257 
2258  /*
2259  * if we still have arguments, they are extra tests to run
2260  */
2261  while (argc - optind >= 1)
2262  {
2264  optind++;
2265  }
2266 
2267  if (config_auth_datadir)
2268  {
2269 #ifdef ENABLE_SSPI
2270  if (!use_unix_sockets)
2271  config_sspi_auth(config_auth_datadir, user);
2272 #endif
2273  exit(0);
2274  }
2275 
2277 
2278  /*
2279  * To reduce chances of interference with parallel installations, use
2280  * a port number starting in the private range (49152-65535)
2281  * calculated from the version number. This aids !HAVE_UNIX_SOCKETS
2282  * systems; elsewhere, the use of a private socket directory already
2283  * prevents interference.
2284  */
2285  port = 0xC000 | (PG_VERSION_NUM & 0x3FFF);
2286 
2290 
2291  /*
2292  * Initialization
2293  */
2295 
2297 
2298 #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_CORE)
2299  unlimit_core_size();
2300 #endif
2301 
2302  if (temp_instance)
2303  {
2304  FILE *pg_conf;
2305  const char *env_wait;
2306  int wait_seconds;
2307 
2308  /*
2309  * Prepare the temp instance
2310  */
2311 
2313  {
2314  header(_("removing existing temp instance"));
2315  if (!rmtree(temp_instance, true))
2316  {
2317  fprintf(stderr, _("\n%s: could not remove temp instance \"%s\"\n"),
2319  exit(2);
2320  }
2321  }
2322 
2323  header(_("creating temporary instance"));
2324 
2325  /* make the temp instance top directory */
2327 
2328  /* and a directory for log files */
2329  snprintf(buf, sizeof(buf), "%s/log", outputdir);
2330  if (!directory_exists(buf))
2331  make_directory(buf);
2332 
2333  /* initdb */
2334  header(_("initializing database system"));
2335  snprintf(buf, sizeof(buf),
2336  "\"%s%sinitdb\" -D \"%s/data\" --no-clean --no-sync%s%s > \"%s/log/initdb.log\" 2>&1",
2337  bindir ? bindir : "",
2338  bindir ? "/" : "",
2339  temp_instance,
2340  debug ? " --debug" : "",
2341  nolocale ? " --no-locale" : "",
2342  outputdir);
2343  if (system(buf))
2344  {
2345  fprintf(stderr, _("\n%s: initdb failed\nExamine %s/log/initdb.log for the reason.\nCommand was: %s\n"), progname, outputdir, buf);
2346  exit(2);
2347  }
2348 
2349  /*
2350  * Adjust the default postgresql.conf for regression testing. The user
2351  * can specify a file to be appended; in any case we expand logging
2352  * and set max_prepared_transactions to enable testing of prepared
2353  * xacts. (Note: to reduce the probability of unexpected shmmax
2354  * failures, don't set max_prepared_transactions any higher than
2355  * actually needed by the prepared_xacts regression test.)
2356  */
2357  snprintf(buf, sizeof(buf), "%s/data/postgresql.conf", temp_instance);
2358  pg_conf = fopen(buf, "a");
2359  if (pg_conf == NULL)
2360  {
2361  fprintf(stderr, _("\n%s: could not open \"%s\" for adding extra config: %s\n"), progname, buf, strerror(errno));
2362  exit(2);
2363  }
2364  fputs("\n# Configuration added by pg_regress\n\n", pg_conf);
2365  fputs("log_autovacuum_min_duration = 0\n", pg_conf);
2366  fputs("log_checkpoints = on\n", pg_conf);
2367  fputs("log_line_prefix = '%m %b[%p] %q%a '\n", pg_conf);
2368  fputs("log_lock_waits = on\n", pg_conf);
2369  fputs("log_temp_files = 128kB\n", pg_conf);
2370  fputs("max_prepared_transactions = 2\n", pg_conf);
2371 
2372  for (sl = temp_configs; sl != NULL; sl = sl->next)
2373  {
2374  char *temp_config = sl->str;
2375  FILE *extra_conf;
2376  char line_buf[1024];
2377 
2378  extra_conf = fopen(temp_config, "r");
2379  if (extra_conf == NULL)
2380  {
2381  fprintf(stderr, _("\n%s: could not open \"%s\" to read extra config: %s\n"), progname, temp_config, strerror(errno));
2382  exit(2);
2383  }
2384  while (fgets(line_buf, sizeof(line_buf), extra_conf) != NULL)
2385  fputs(line_buf, pg_conf);
2386  fclose(extra_conf);
2387  }
2388 
2389  fclose(pg_conf);
2390 
2391 #ifdef ENABLE_SSPI
2392  if (!use_unix_sockets)
2393  {
2394  /*
2395  * Since we successfully used the same buffer for the much-longer
2396  * "initdb" command, this can't truncate.
2397  */
2398  snprintf(buf, sizeof(buf), "%s/data", temp_instance);
2399  config_sspi_auth(buf, NULL);
2400  }
2401 #elif !defined(HAVE_UNIX_SOCKETS)
2402 #error Platform has no means to secure the test installation.
2403 #endif
2404 
2405  /*
2406  * Check if there is a postmaster running already.
2407  */
2408  snprintf(buf2, sizeof(buf2),
2409  "\"%s%spsql\" -X postgres <%s 2>%s",
2410  bindir ? bindir : "",
2411  bindir ? "/" : "",
2412  DEVNULL, DEVNULL);
2413 
2414  for (i = 0; i < 16; i++)
2415  {
2416  if (system(buf2) == 0)
2417  {
2418  char s[16];
2419 
2420  if (port_specified_by_user || i == 15)
2421  {
2422  fprintf(stderr, _("port %d apparently in use\n"), port);
2424  fprintf(stderr, _("%s: could not determine an available port\n"), progname);
2425  fprintf(stderr, _("Specify an unused port using the --port option or shut down any conflicting PostgreSQL servers.\n"));
2426  exit(2);
2427  }
2428 
2429  fprintf(stderr, _("port %d apparently in use, trying %d\n"), port, port + 1);
2430  port++;
2431  sprintf(s, "%d", port);
2432  setenv("PGPORT", s, 1);
2433  }
2434  else
2435  break;
2436  }
2437 
2438  /*
2439  * Start the temp postmaster
2440  */
2441  header(_("starting postmaster"));
2442  snprintf(buf, sizeof(buf),
2443  "\"%s%spostgres\" -D \"%s/data\" -F%s "
2444  "-c \"listen_addresses=%s\" -k \"%s\" "
2445  "> \"%s/log/postmaster.log\" 2>&1",
2446  bindir ? bindir : "",
2447  bindir ? "/" : "",
2448  temp_instance, debug ? " -d 5" : "",
2449  hostname ? hostname : "", sockdir ? sockdir : "",
2450  outputdir);
2452  if (postmaster_pid == INVALID_PID)
2453  {
2454  fprintf(stderr, _("\n%s: could not spawn postmaster: %s\n"),
2455  progname, strerror(errno));
2456  exit(2);
2457  }
2458 
2459  /*
2460  * Wait till postmaster is able to accept connections; normally this
2461  * is only a second or so, but Cygwin is reportedly *much* slower, and
2462  * test builds using Valgrind or similar tools might be too. Hence,
2463  * allow the default timeout of 60 seconds to be overridden from the
2464  * PGCTLTIMEOUT environment variable.
2465  */
2466  env_wait = getenv("PGCTLTIMEOUT");
2467  if (env_wait != NULL)
2468  {
2469  wait_seconds = atoi(env_wait);
2470  if (wait_seconds <= 0)
2471  wait_seconds = 60;
2472  }
2473  else
2474  wait_seconds = 60;
2475 
2476  for (i = 0; i < wait_seconds; i++)
2477  {
2478  /* Done if psql succeeds */
2479  if (system(buf2) == 0)
2480  break;
2481 
2482  /*
2483  * Fail immediately if postmaster has exited
2484  */
2485 #ifndef WIN32
2486  if (waitpid(postmaster_pid, NULL, WNOHANG) == postmaster_pid)
2487 #else
2488  if (WaitForSingleObject(postmaster_pid, 0) == WAIT_OBJECT_0)
2489 #endif
2490  {
2491  fprintf(stderr, _("\n%s: postmaster failed\nExamine %s/log/postmaster.log for the reason\n"), progname, outputdir);
2492  exit(2);
2493  }
2494 
2495  pg_usleep(1000000L);
2496  }
2497  if (i >= wait_seconds)
2498  {
2499  fprintf(stderr, _("\n%s: postmaster did not respond within %d seconds\nExamine %s/log/postmaster.log for the reason\n"),
2500  progname, wait_seconds, outputdir);
2501 
2502  /*
2503  * If we get here, the postmaster is probably wedged somewhere in
2504  * startup. Try to kill it ungracefully rather than leaving a
2505  * stuck postmaster that might interfere with subsequent test
2506  * attempts.
2507  */
2508 #ifndef WIN32
2509  if (kill(postmaster_pid, SIGKILL) != 0 &&
2510  errno != ESRCH)
2511  fprintf(stderr, _("\n%s: could not kill failed postmaster: %s\n"),
2512  progname, strerror(errno));
2513 #else
2514  if (TerminateProcess(postmaster_pid, 255) == 0)
2515  fprintf(stderr, _("\n%s: could not kill failed postmaster: error code %lu\n"),
2516  progname, GetLastError());
2517 #endif
2518 
2519  exit(2);
2520  }
2521 
2522  postmaster_running = true;
2523 
2524 #ifdef _WIN64
2525 /* need a series of two casts to convert HANDLE without compiler warning */
2526 #define ULONGPID(x) (unsigned long) (unsigned long long) (x)
2527 #else
2528 #define ULONGPID(x) (unsigned long) (x)
2529 #endif
2530  printf(_("running on port %d with PID %lu\n"),
2532  }
2533  else
2534  {
2535  /*
2536  * Using an existing installation, so may need to get rid of
2537  * pre-existing database(s) and role(s)
2538  */
2539  if (!use_existing)
2540  {
2541  for (sl = dblist; sl; sl = sl->next)
2543  for (sl = extraroles; sl; sl = sl->next)
2544  drop_role_if_exists(sl->str);
2545  }
2546  }
2547 
2548  /*
2549  * Create the test database(s) and role(s)
2550  */
2551  if (!use_existing)
2552  {
2553  for (sl = dblist; sl; sl = sl->next)
2554  create_database(sl->str);
2555  for (sl = extraroles; sl; sl = sl->next)
2556  create_role(sl->str, dblist);
2557  }
2558 
2559  /*
2560  * Ready to run the tests
2561  */
2562  header(_("running regression test queries"));
2563 
2564  for (sl = schedulelist; sl != NULL; sl = sl->next)
2565  {
2566  run_schedule(sl->str, startfunc, postfunc);
2567  }
2568 
2569  for (sl = extra_tests; sl != NULL; sl = sl->next)
2570  {
2571  run_single_test(sl->str, startfunc, postfunc);
2572  }
2573 
2574  /*
2575  * Shut down temp installation's postmaster
2576  */
2577  if (temp_instance)
2578  {
2579  header(_("shutting down postmaster"));
2580  stop_postmaster();
2581  }
2582 
2583  /*
2584  * If there were no errors, remove the temp instance immediately to
2585  * conserve disk space. (If there were errors, we leave the instance in
2586  * place for possible manual investigation.)
2587  */
2588  if (temp_instance && fail_count == 0 && fail_ignore_count == 0)
2589  {
2590  header(_("removing temporary instance"));
2591  if (!rmtree(temp_instance, true))
2592  fprintf(stderr, _("\n%s: could not remove temp instance \"%s\"\n"),
2594  }
2595 
2596  fclose(logfile);
2597 
2598  /*
2599  * Emit nice-looking summary message
2600  */
2601  if (fail_count == 0 && fail_ignore_count == 0)
2602  snprintf(buf, sizeof(buf),
2603  _(" All %d tests passed. "),
2604  success_count);
2605  else if (fail_count == 0) /* fail_count=0, fail_ignore_count>0 */
2606  snprintf(buf, sizeof(buf),
2607  _(" %d of %d tests passed, %d failed test(s) ignored. "),
2608  success_count,
2611  else if (fail_ignore_count == 0) /* fail_count>0 && fail_ignore_count=0 */
2612  snprintf(buf, sizeof(buf),
2613  _(" %d of %d tests failed. "),
2614  fail_count,
2616  else
2617  /* fail_count>0 && fail_ignore_count>0 */
2618  snprintf(buf, sizeof(buf),
2619  _(" %d of %d tests failed, %d of these failures ignored. "),
2623 
2624  putchar('\n');
2625  for (i = strlen(buf); i > 0; i--)
2626  putchar('=');
2627  printf("\n%s\n", buf);
2628  for (i = strlen(buf); i > 0; i--)
2629  putchar('=');
2630  putchar('\n');
2631  putchar('\n');
2632 
2633  if (file_size(difffilename) > 0)
2634  {
2635  printf(_("The differences that caused some tests to fail can be viewed in the\n"
2636  "file \"%s\". A copy of the test summary that you see\n"
2637  "above is saved in the file \"%s\".\n\n"),
2639  }
2640  else
2641  {
2642  unlink(difffilename);
2643  unlink(logfilename);
2644  }
2645 
2646  if (fail_count != 0)
2647  exit(1);
2648 
2649  return 0;
2650 }
char * make_absolute_path(const char *path)
Definition: path.c:608
static bool directory_exists(const char *dir)
Definition: pg_regress.c:1279
static void drop_role_if_exists(const char *rolename)
Definition: pg_regress.c:2024
static void drop_database_if_exists(const char *dbname)
Definition: pg_regress.c:1981
static int max_concurrent_tests
Definition: pg_regress.c:83
static const char * sockdir
Definition: pg_regress.c:104
static int wait_seconds
Definition: pg_ctl.c:80
static _stringlist * extra_tests
Definition: pg_regress.c:86
static void help(void)
Definition: pg_regress.c:2043
char * str
Definition: pg_regress.h:26
static void initialize_environment(void)
Definition: pg_regress.c:731
bool debug
Definition: pg_regress.c:76
const char * get_progname(const char *argv0)
Definition: path.c:453
static void static void static void void add_stringlist_item(_stringlist **listhead, const char *str)
Definition: pg_regress.c:157
int getopt_long(int argc, char *const argv[], const char *optstring, const struct option *longopts, int *longindex)
Definition: getopt_long.c:57
void get_restricted_token(void)
void pg_logging_init(const char *argv0)
Definition: logging.c:81
static char * encoding
Definition: pg_regress.c:84
static const char * progname
Definition: pg_regress.c:100
static void make_directory(const char *dir)
Definition: pg_regress.c:1292
static bool use_existing
Definition: pg_regress.c:90
static bool postmaster_running
Definition: pg_regress.c:114
#define kill(pid, sig)
Definition: win32_port.h:454
#define printf(...)
Definition: port.h:221
static FILE * logfile
Definition: pg_regress.c:102
static void stop_postmaster(void)
Definition: pg_regress.c:260
#define fprintf
Definition: port.h:219
static char * temp_instance
Definition: pg_regress.c:87
char * launcher
Definition: pg_regress.c:80
static void split_to_stringlist(const char *s, const char *delim, _stringlist **listhead)
Definition: pg_regress.c:193
static void free_stringlist(_stringlist **listhead)
Definition: pg_regress.c:178
PID_TYPE spawn_process(const char *cmdline)
Definition: pg_regress.c:1158
#define SIGKILL
Definition: win32_port.h:163
#define sprintf
Definition: port.h:217
#define setenv(x, y, z)
Definition: win32_port.h:497
#define true
Definition: c.h:383
static char * difffilename
Definition: pg_regress.c:103
void pg_usleep(long microsec)
Definition: signal.c:53
#define required_argument
Definition: getopt_long.h:25
int optind
Definition: getopt.c:50
static _stringlist * loadextension
Definition: pg_regress.c:81
static void run_schedule(const char *schedule, test_start_function startfunc, postprocess_result_function postfunc)
Definition: pg_regress.c:1619
#define MAXPGPATH
_stringlist * dblist
Definition: pg_regress.c:75
static _stringlist * extraroles
Definition: pg_regress.c:96
static _stringlist * temp_configs
Definition: pg_regress.c:88
char * c
const char * pretty_diff_opts
Definition: pg_regress.c:68
static char * buf
Definition: pg_test_fsync.c:68
#define INVALID_PID
Definition: pg_regress.h:15
static void create_role(const char *rolename, const _stringlist *granted_dbs)
Definition: pg_regress.c:2031
static char * dlpath
Definition: pg_regress.c:94
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
static int success_count
Definition: pg_regress.c:116
#define DEVNULL
Definition: port.h:146
static int max_connections
Definition: pg_regress.c:82
static int port
Definition: pg_regress.c:92
static PID_TYPE postmaster_pid
Definition: pg_regress.c:113
bool rmtree(const char *path, bool rmtopdir)
Definition: rmtree.c:42
#define no_argument
Definition: getopt_long.h:24
static char * config_auth_datadir
Definition: pg_regress.c:97
#define PG_TEXTDOMAIN(domain)
Definition: c.h:1203
static int fail_ignore_count
Definition: pg_regress.c:118
static int fail_count
Definition: pg_regress.c:117
char * outputdir
Definition: pg_regress.c:78
static char * logfilename
Definition: pg_regress.c:101
char * inputdir
Definition: pg_regress.c:77
static long file_size(const char *file)
Definition: pg_regress.c:1225
static bool port_specified_by_user
Definition: pg_regress.c:93
char * bindir
Definition: pg_regress.c:79
#define strerror
Definition: port.h:228
static void header(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:210
static char * user
Definition: pg_regress.c:95
void set_pglocale_pgservice(const char *argv0, const char *app)
Definition: exec.c:434
char * optarg
Definition: getopt.c:52
static _stringlist * schedulelist
Definition: pg_regress.c:85
struct _stringlist * next
Definition: pg_regress.h:27
int i
static bool nolocale
Definition: pg_regress.c:89
static void open_result_files(void)
Definition: pg_regress.c:1941
static char * hostname
Definition: pg_regress.c:91
#define snprintf
Definition: port.h:215
#define _(x)
Definition: elog.c:89
static void run_single_test(const char *test, test_start_function startfunc, postprocess_result_function postfunc)
Definition: pg_regress.c:1873
#define ULONGPID(x)
static void create_database(const char *dbname)
Definition: pg_regress.c:1988

◆ replace_string()

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

Definition at line 447 of file pg_regress.c.

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

Referenced by convert_sourcefiles_in(), and ecpg_start_test().

448 {
449  int pos = 0;
450  char *ptr;
451 
452  while ((ptr = strstr(string->data + pos, replace)) != NULL)
453  {
454  /* Must copy the remainder of the string out of the StringInfo */
455  char *suffix = pg_strdup(ptr + strlen(replace));
456 
457  /* Truncate StringInfo at start of found string ... */
458  string->len = ptr - string->data;
459  /* ... and append the replacement (this restores the trailing '\0') */
460  appendStringInfoString(string, replacement);
461  /* Next search should start after the replacement */
462  pos = string->len;
463  /* Put back the remainder of the string */
464  appendStringInfoString(string, suffix);
465  free(suffix);
466  }
467 }
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
#define free(a)
Definition: header.h:65

◆ results_differ()

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

Definition at line 1373 of file pg_regress.c.

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

Referenced by run_schedule(), and run_single_test().

1374 {
1375  char expectfile[MAXPGPATH];
1376  char diff[MAXPGPATH];
1377  char cmd[MAXPGPATH * 3];
1378  char best_expect_file[MAXPGPATH];
1379  FILE *difffile;
1380  int best_line_count;
1381  int i;
1382  int l;
1383  const char *platform_expectfile;
1384 
1385  /*
1386  * We can pass either the resultsfile or the expectfile, they should have
1387  * the same type (filename.type) anyway.
1388  */
1389  platform_expectfile = get_expectfile(testname, resultsfile);
1390 
1391  strlcpy(expectfile, default_expectfile, sizeof(expectfile));
1392  if (platform_expectfile)
1393  {
1394  /*
1395  * Replace everything after the last slash in expectfile with what the
1396  * platform_expectfile contains.
1397  */
1398  char *p = strrchr(expectfile, '/');
1399 
1400  if (p)
1401  strcpy(++p, platform_expectfile);
1402  }
1403 
1404  /* Name to use for temporary diff file */
1405  snprintf(diff, sizeof(diff), "%s.diff", resultsfile);
1406 
1407  /* OK, run the diff */
1408  snprintf(cmd, sizeof(cmd),
1409  "diff %s \"%s\" \"%s\" > \"%s\"",
1410  basic_diff_opts, expectfile, resultsfile, diff);
1411 
1412  /* Is the diff file empty? */
1413  if (run_diff(cmd, diff) == 0)
1414  {
1415  unlink(diff);
1416  return false;
1417  }
1418 
1419  /* There may be secondary comparison files that match better */
1420  best_line_count = file_line_count(diff);
1421  strcpy(best_expect_file, expectfile);
1422 
1423  for (i = 0; i <= 9; i++)
1424  {
1425  char *alt_expectfile;
1426 
1427  alt_expectfile = get_alternative_expectfile(expectfile, i);
1428  if (!alt_expectfile)
1429  {
1430  fprintf(stderr, _("Unable to check secondary comparison files: %s\n"),
1431  strerror(errno));
1432  exit(2);
1433  }
1434 
1435  if (!file_exists(alt_expectfile))
1436  {
1437  free(alt_expectfile);
1438  continue;
1439  }
1440 
1441  snprintf(cmd, sizeof(cmd),
1442  "diff %s \"%s\" \"%s\" > \"%s\"",
1443  basic_diff_opts, alt_expectfile, resultsfile, diff);
1444 
1445  if (run_diff(cmd, diff) == 0)
1446  {
1447  unlink(diff);
1448  free(alt_expectfile);
1449  return false;
1450  }
1451 
1452  l = file_line_count(diff);
1453  if (l < best_line_count)
1454  {
1455  /* This diff was a better match than the last one */
1456  best_line_count = l;
1457  strlcpy(best_expect_file, alt_expectfile, sizeof(best_expect_file));
1458  }
1459  free(alt_expectfile);
1460  }
1461 
1462  /*
1463  * fall back on the canonical results file if we haven't tried it yet and
1464  * haven't found a complete match yet.
1465  */
1466 
1467  if (platform_expectfile)
1468  {
1469  snprintf(cmd, sizeof(cmd),
1470  "diff %s \"%s\" \"%s\" > \"%s\"",
1471  basic_diff_opts, default_expectfile, resultsfile, diff);
1472 
1473  if (run_diff(cmd, diff) == 0)
1474  {
1475  /* No diff = no changes = good */
1476  unlink(diff);
1477  return false;
1478  }
1479 
1480  l = file_line_count(diff);
1481  if (l < best_line_count)
1482  {
1483  /* This diff was a better match than the last one */
1484  best_line_count = l;
1485  strlcpy(best_expect_file, default_expectfile, sizeof(best_expect_file));
1486  }
1487  }
1488 
1489  /*
1490  * Use the best comparison file to generate the "pretty" diff, which we
1491  * append to the diffs summary file.
1492  */
1493 
1494  /* Write diff header */
1495  difffile = fopen(difffilename, "a");
1496  if (difffile)
1497  {
1498  fprintf(difffile,
1499  "diff %s %s %s\n",
1500  pretty_diff_opts, best_expect_file, resultsfile);
1501  fclose(difffile);
1502  }
1503 
1504  /* Run diff */
1505  snprintf(cmd, sizeof(cmd),
1506  "diff %s \"%s\" \"%s\" >> \"%s\"",
1507  pretty_diff_opts, best_expect_file, resultsfile, difffilename);
1508  run_diff(cmd, difffilename);
1509 
1510  unlink(diff);
1511  return true;
1512 }
static char * get_alternative_expectfile(const char *expectfile, int i)
Definition: pg_regress.c:1306
#define fprintf
Definition: port.h:219
static char * difffilename
Definition: pg_regress.c:103
#define MAXPGPATH
const char * pretty_diff_opts
Definition: pg_regress.c:68
static int run_diff(const char *cmd, const char *filename)
Definition: pg_regress.c:1340
#define free(a)
Definition: header.h:65
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
static const char * get_expectfile(const char *testname, const char *file)
Definition: pg_regress.c:702
static int file_line_count(const char *file)
Definition: pg_regress.c:1246
#define strerror
Definition: port.h:228
bool file_exists(const char *file)
Definition: pg_regress.c:1268
int i
const char * basic_diff_opts
Definition: pg_regress.c:67
#define snprintf
Definition: port.h:215
#define _(x)
Definition: elog.c:89

◆ run_diff()

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

Definition at line 1340 of file pg_regress.c.

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

Referenced by results_differ().

1341 {
1342  int r;
1343 
1344  r = system(cmd);
1345  if (!WIFEXITED(r) || WEXITSTATUS(r) > 1)
1346  {
1347  fprintf(stderr, _("diff command failed with status %d: %s\n"), r, cmd);
1348  exit(2);
1349  }
1350 #ifdef WIN32
1351 
1352  /*
1353  * On WIN32, if the 'diff' command cannot be found, system() returns 1,
1354  * but produces nothing to stdout, so we check for that here.
1355  */
1356  if (WEXITSTATUS(r) == 1 && file_size(filename) <= 0)
1357  {
1358  fprintf(stderr, _("diff command not found: %s\n"), cmd);
1359  exit(2);
1360  }
1361 #endif
1362 
1363  return WEXITSTATUS(r);
1364 }
#define fprintf
Definition: port.h:219
#define WIFEXITED(w)
Definition: win32_port.h:143
static long file_size(const char *file)
Definition: pg_regress.c:1225
static char * filename
Definition: pg_dumpall.c:91
#define _(x)
Definition: elog.c:89
#define WEXITSTATUS(w)
Definition: win32_port.h:145

◆ run_schedule()

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

Definition at line 1619 of file pg_regress.c.

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

Referenced by regression_main().

1621 {
1622 #define MAX_PARALLEL_TESTS 100
1623  char *tests[MAX_PARALLEL_TESTS];
1624  _stringlist *resultfiles[MAX_PARALLEL_TESTS];
1625  _stringlist *expectfiles[MAX_PARALLEL_TESTS];
1628  instr_time starttimes[MAX_PARALLEL_TESTS];
1629  instr_time stoptimes[MAX_PARALLEL_TESTS];
1630  int statuses[MAX_PARALLEL_TESTS];
1631  _stringlist *ignorelist = NULL;
1632  char scbuf[1024];
1633  FILE *scf;
1634  int line_num = 0;
1635 
1636  memset(tests, 0, sizeof(tests));
1637  memset(resultfiles, 0, sizeof(resultfiles));
1638  memset(expectfiles, 0, sizeof(expectfiles));
1639  memset(tags, 0, sizeof(tags));
1640 
1641  scf = fopen(schedule, "r");
1642  if (!scf)
1643  {
1644  fprintf(stderr, _("%s: could not open file \"%s\" for reading: %s\n"),
1645  progname, schedule, strerror(errno));
1646  exit(2);
1647  }
1648 
1649  while (fgets(scbuf, sizeof(scbuf), scf))
1650  {
1651  char *test = NULL;
1652  char *c;
1653  int num_tests;
1654  bool inword;
1655  int i;
1656 
1657  line_num++;
1658 
1659  /* strip trailing whitespace, especially the newline */
1660  i = strlen(scbuf);
1661  while (i > 0 && isspace((unsigned char) scbuf[i - 1]))
1662  scbuf[--i] = '\0';
1663 
1664  if (scbuf[0] == '\0' || scbuf[0] == '#')
1665  continue;
1666  if (strncmp(scbuf, "test: ", 6) == 0)
1667  test = scbuf + 6;
1668  else if (strncmp(scbuf, "ignore: ", 8) == 0)
1669  {
1670  c = scbuf + 8;
1671  while (*c && isspace((unsigned char) *c))
1672  c++;
1673  add_stringlist_item(&ignorelist, c);
1674 
1675  /*
1676  * Note: ignore: lines do not run the test, they just say that
1677  * failure of this test when run later on is to be ignored. A bit
1678  * odd but that's how the shell-script version did it.
1679  */
1680  continue;
1681  }
1682  else
1683  {
1684  fprintf(stderr, _("syntax error in schedule file \"%s\" line %d: %s\n"),
1685  schedule, line_num, scbuf);
1686  exit(2);
1687  }
1688 
1689  num_tests = 0;
1690  inword = false;
1691  for (c = test;; c++)
1692  {
1693  if (*c == '\0' || isspace((unsigned char) *c))
1694  {
1695  if (inword)
1696  {
1697  /* Reached end of a test name */
1698  char sav;
1699 
1700  if (num_tests >= MAX_PARALLEL_TESTS)
1701  {
1702  fprintf(stderr, _("too many parallel tests (more than %d) in schedule file \"%s\" line %d: %s\n"),
1703  MAX_PARALLEL_TESTS, schedule, line_num, scbuf);
1704  exit(2);
1705  }
1706  sav = *c;
1707  *c = '\0';
1708  tests[num_tests] = pg_strdup(test);
1709  num_tests++;
1710  *c = sav;
1711  inword = false;
1712  }
1713  if (*c == '\0')
1714  break; /* loop exit is here */
1715  }
1716  else if (!inword)
1717  {
1718  /* Start of a test name */
1719  test = c;
1720  inword = true;
1721  }
1722  }
1723 
1724  if (num_tests == 0)
1725  {
1726  fprintf(stderr, _("syntax error in schedule file \"%s\" line %d: %s\n"),
1727  schedule, line_num, scbuf);
1728  exit(2);
1729  }
1730 
1731  if (num_tests == 1)
1732  {
1733  status(_("test %-28s ... "), tests[0]);
1734  pids[0] = (startfunc) (tests[0], &resultfiles[0], &expectfiles[0], &tags[0]);
1735  INSTR_TIME_SET_CURRENT(starttimes[0]);
1736  wait_for_tests(pids, statuses, stoptimes, NULL, 1);
1737  /* status line is finished below */
1738  }
1739  else if (max_concurrent_tests > 0 && max_concurrent_tests < num_tests)
1740  {
1741  fprintf(stderr, _("too many parallel tests (more than %d) in schedule file \"%s\" line %d: %s\n"),
1742  max_concurrent_tests, schedule, line_num, scbuf);
1743  exit(2);
1744  }
1745  else if (max_connections > 0 && max_connections < num_tests)
1746  {
1747  int oldest = 0;
1748 
1749  status(_("parallel group (%d tests, in groups of %d): "),
1750  num_tests, max_connections);
1751  for (i = 0; i < num_tests; i++)
1752  {
1753  if (i - oldest >= max_connections)
1754  {
1755  wait_for_tests(pids + oldest, statuses + oldest,
1756  stoptimes + oldest,
1757  tests + oldest, i - oldest);
1758  oldest = i;
1759  }
1760  pids[i] = (startfunc) (tests[i], &resultfiles[i], &expectfiles[i], &tags[i]);
1761  INSTR_TIME_SET_CURRENT(starttimes[i]);
1762  }
1763  wait_for_tests(pids + oldest, statuses + oldest,
1764  stoptimes + oldest,
1765  tests + oldest, i - oldest);
1766  status_end();
1767  }
1768  else
1769  {
1770  status(_("parallel group (%d tests): "), num_tests);
1771  for (i = 0; i < num_tests; i++)
1772  {
1773  pids[i] = (startfunc) (tests[i], &resultfiles[i], &expectfiles[i], &tags[i]);
1774  INSTR_TIME_SET_CURRENT(starttimes[i]);
1775  }
1776  wait_for_tests(pids, statuses, stoptimes, tests, num_tests);
1777  status_end();
1778  }
1779 
1780  /* Check results for all tests */
1781  for (i = 0; i < num_tests; i++)
1782  {
1783  _stringlist *rl,
1784  *el,
1785  *tl;
1786  bool differ = false;
1787 
1788  if (num_tests > 1)
1789  status(_(" %-28s ... "), tests[i]);
1790 
1791  /*
1792  * Advance over all three lists simultaneously.
1793  *
1794  * Compare resultfiles[j] with expectfiles[j] always. Tags are
1795  * optional but if there are tags, the tag list has the same
1796  * length as the other two lists.
1797  */
1798  for (rl = resultfiles[i], el = expectfiles[i], tl = tags[i];
1799  rl != NULL; /* rl and el have the same length */
1800  rl = rl->next, el = el->next,
1801  tl = tl ? tl->next : NULL)
1802  {
1803  bool newdiff;
1804 
1805  if (postfunc)
1806  (*postfunc) (rl->str);
1807  newdiff = results_differ(tests[i], rl->str, el->str);
1808  if (newdiff && tl)
1809  {
1810  printf("%s ", tl->str);
1811  }
1812  differ |= newdiff;
1813  }
1814 
1815  if (differ)
1816  {
1817  bool ignore = false;
1818  _stringlist *sl;
1819 
1820  for (sl = ignorelist; sl != NULL; sl = sl->next)
1821  {
1822  if (strcmp(tests[i], sl->str) == 0)
1823  {
1824  ignore = true;
1825  break;
1826  }
1827  }
1828  if (ignore)
1829  {
1830  status(_("failed (ignored)"));
1832  }
1833  else
1834  {
1835  status(_("FAILED"));
1836  fail_count++;
1837  }
1838  }
1839  else
1840  {
1841  status(_("ok ")); /* align with FAILED */
1842  success_count++;
1843  }
1844 
1845  if (statuses[i] != 0)
1846  log_child_failure(statuses[i]);
1847 
1848  INSTR_TIME_SUBTRACT(stoptimes[i], starttimes[i]);
1849  status(_(" %8.0f ms"), INSTR_TIME_GET_MILLISEC(stoptimes[i]));
1850 
1851  status_end();
1852  }
1853 
1854  for (i = 0; i < num_tests; i++)
1855  {
1856  pg_free(tests[i]);
1857  tests[i] = NULL;
1858  free_stringlist(&resultfiles[i]);
1859  free_stringlist(&expectfiles[i]);
1860  free_stringlist(&tags[i]);
1861  }
1862  }
1863 
1864  free_stringlist(&ignorelist);
1865 
1866  fclose(scf);
1867 }
static int max_concurrent_tests
Definition: pg_regress.c:83
static void test(void)
static void log_child_failure(int exitstatus)
Definition: pg_regress.c:1595
char * str
Definition: pg_regress.h:26
static void static void static void void add_stringlist_item(_stringlist **listhead, const char *str)
Definition: pg_regress.c:157
#define INSTR_TIME_GET_MILLISEC(t)
Definition: instr_time.h:202
struct timeval instr_time
Definition: instr_time.h:150
static const char * progname
Definition: pg_regress.c:100
static void status_end(void)
Definition: pg_regress.c:248
#define PID_TYPE
Definition: pg_regress.h:14
#define printf(...)
Definition: port.h:221
#define fprintf
Definition: port.h:219
static bool results_differ(const char *testname, const char *resultsfile, const char *default_expectfile)
Definition: pg_regress.c:1373
static void free_stringlist(_stringlist **listhead)
Definition: pg_regress.c:178
#define INSTR_TIME_SUBTRACT(x, y)
Definition: instr_time.h:170
char * c
#define MAX_PARALLEL_TESTS
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
static int success_count
Definition: pg_regress.c:116
static int max_connections
Definition: pg_regress.c:82
static int fail_ignore_count
Definition: pg_regress.c:118
static int fail_count
Definition: pg_regress.c:117
#define strerror
Definition: port.h:228
void pg_free(void *ptr)
Definition: fe_memutils.c:105
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:156
struct _stringlist * next
Definition: pg_regress.h:27
int i
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:227
#define _(x)
Definition: elog.c:89
static void wait_for_tests(PID_TYPE *pids, int *statuses, instr_time *stoptimes, char **names, int num_tests)
Definition: pg_regress.c:1523

◆ run_single_test()

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

Definition at line 1873 of file pg_regress.c.

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

Referenced by regression_main().

1875 {
1876  PID_TYPE pid;
1877  instr_time starttime;
1878  instr_time stoptime;
1879  int exit_status;
1880  _stringlist *resultfiles = NULL;
1881  _stringlist *expectfiles = NULL;
1882  _stringlist *tags = NULL;
1883  _stringlist *rl,
1884  *el,
1885  *tl;
1886  bool differ = false;
1887 
1888  status(_("test %-28s ... "), test);
1889  pid = (startfunc) (test, &resultfiles, &expectfiles, &tags);
1890  INSTR_TIME_SET_CURRENT(starttime);
1891  wait_for_tests(&pid, &exit_status, &stoptime, NULL, 1);
1892 
1893  /*
1894  * Advance over all three lists simultaneously.
1895  *
1896  * Compare resultfiles[j] with expectfiles[j] always. Tags are optional
1897  * but if there are tags, the tag list has the same length as the other
1898  * two lists.
1899  */
1900  for (rl = resultfiles, el = expectfiles, tl = tags;
1901  rl != NULL; /* rl and el have the same length */
1902  rl = rl->next, el = el->next,
1903  tl = tl ? tl->next : NULL)
1904  {
1905  bool newdiff;
1906 
1907  if (postfunc)
1908  (*postfunc) (rl->str);
1909  newdiff = results_differ(test, rl->str, el->str);
1910  if (newdiff && tl)
1911  {
1912  printf("%s ", tl->str);
1913  }
1914  differ |= newdiff;
1915  }
1916 
1917  if (differ)
1918  {
1919  status(_("FAILED"));
1920  fail_count++;
1921  }
1922  else
1923  {
1924  status(_("ok ")); /* align with FAILED */
1925  success_count++;
1926  }
1927 
1928  if (exit_status != 0)
1929  log_child_failure(exit_status);
1930 
1931  INSTR_TIME_SUBTRACT(stoptime, starttime);
1932  status(_(" %8.0f ms"), INSTR_TIME_GET_MILLISEC(stoptime));
1933 
1934  status_end();
1935 }
static void test(void)
static void log_child_failure(int exitstatus)
Definition: pg_regress.c:1595
char * str
Definition: pg_regress.h:26
#define INSTR_TIME_GET_MILLISEC(t)
Definition: instr_time.h:202
struct timeval instr_time
Definition: instr_time.h:150
static void status_end(void)
Definition: pg_regress.c:248
#define PID_TYPE
Definition: pg_regress.h:14
#define printf(...)
Definition: port.h:221
static bool results_differ(const char *testname, const char *resultsfile, const char *default_expectfile)
Definition: pg_regress.c:1373
#define INSTR_TIME_SUBTRACT(x, y)
Definition: instr_time.h:170
static int success_count
Definition: pg_regress.c:116
static int fail_count
Definition: pg_regress.c:117
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:156
struct _stringlist * next
Definition: pg_regress.h:27
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:227
#define _(x)
Definition: elog.c:89
static void wait_for_tests(PID_TYPE *pids, int *statuses, instr_time *stoptimes, char **names, int num_tests)
Definition: pg_regress.c:1523

◆ spawn_process()

PID_TYPE spawn_process ( const char *  cmdline)

Definition at line 1158 of file pg_regress.c.

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

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

1159 {
1160 #ifndef WIN32
1161  pid_t pid;
1162 
1163  /*
1164  * Must flush I/O buffers before fork. Ideally we'd use fflush(NULL) here
1165  * ... does anyone still care about systems where that doesn't work?
1166  */
1167  fflush(stdout);
1168  fflush(stderr);
1169  if (logfile)
1170  fflush(logfile);
1171 
1172  pid = fork();
1173  if (pid == -1)
1174  {
1175  fprintf(stderr, _("%s: could not fork: %s\n"),
1176  progname, strerror(errno));
1177  exit(2);
1178  }
1179  if (pid == 0)
1180  {
1181  /*
1182  * In child
1183  *
1184  * Instead of using system(), exec the shell directly, and tell it to
1185  * "exec" the command too. This saves two useless processes per
1186  * parallel test case.
1187  */
1188  char *cmdline2;
1189 
1190  cmdline2 = psprintf("exec %s", cmdline);
1191  execl(shellprog, shellprog, "-c", cmdline2, (char *) NULL);
1192  fprintf(stderr, _("%s: could not exec \"%s\": %s\n"),
1193  progname, shellprog, strerror(errno));
1194  _exit(1); /* not exit() here... */
1195  }
1196  /* in parent */
1197  return pid;
1198 #else
1199  PROCESS_INFORMATION pi;
1200  char *cmdline2;
1201  HANDLE restrictedToken;
1202  const char *comspec;
1203 
1204  /* Find CMD.EXE location using COMSPEC, if it's set */
1205  comspec = getenv("COMSPEC");
1206  if (comspec == NULL)
1207  comspec = "CMD";
1208 
1209  memset(&pi, 0, sizeof(pi));
1210  cmdline2 = psprintf("\"%s\" /c \"%s\"", comspec, cmdline);
1211 
1212  if ((restrictedToken =
1213  CreateRestrictedProcess(cmdline2, &pi)) == 0)
1214  exit(2);
1215 
1216  CloseHandle(pi.hThread);
1217  return pi.hProcess;
1218 #endif
1219 }
static char * shellprog
Definition: pg_regress.c:58
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
static const char * progname
Definition: pg_regress.c:100
static FILE * logfile
Definition: pg_regress.c:102
#define fprintf
Definition: port.h:219
#define strerror
Definition: port.h:228
#define _(x)
Definition: elog.c:89

◆ split_to_stringlist()

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

Definition at line 193 of file pg_regress.c.

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

Referenced by regression_main().

194 {
195  char *sc = pg_strdup(s);
196  char *token = strtok(sc, delim);
197 
198  while (token)
199  {
200  add_stringlist_item(listhead, token);
201  token = strtok(NULL, delim);
202  }
203  free(sc);
204 }
static void static void static void void add_stringlist_item(_stringlist **listhead, const char *str)
Definition: pg_regress.c:157
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
#define free(a)
Definition: header.h:65

◆ status()

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

Definition at line 227 of file pg_regress.c.

References logfile, generate_unaccent_rules::stdout, and vfprintf.

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

228 {
229  va_list ap;
230 
231  va_start(ap, fmt);
232  vfprintf(stdout, fmt, ap);
233  fflush(stdout);
234  va_end(ap);
235 
236  if (logfile)
237  {
238  va_start(ap, fmt);
239  vfprintf(logfile, fmt, ap);
240  va_end(ap);
241  }
242 }
static FILE * logfile
Definition: pg_regress.c:102
#define vfprintf
Definition: port.h:218

◆ status_end()

static void status_end ( void  )
static

Definition at line 248 of file pg_regress.c.

References fprintf, logfile, and generate_unaccent_rules::stdout.

Referenced by run_schedule(), and run_single_test().

249 {
250  fprintf(stdout, "\n");
251  fflush(stdout);
252  if (logfile)
253  fprintf(logfile, "\n");
254 }
static FILE * logfile
Definition: pg_regress.c:102
#define fprintf
Definition: port.h:219

◆ stop_postmaster()

static void stop_postmaster ( void  )
static

Definition at line 260 of file pg_regress.c.

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

Referenced by regression_main().

261 {
262  if (postmaster_running)
263  {
264  /* We use pg_ctl to issue the kill and wait for stop */
265  char buf[MAXPGPATH * 2];
266  int r;
267 
268  /* On Windows, system() seems not to force fflush, so... */
269  fflush(stdout);
270  fflush(stderr);
271 
272  snprintf(buf, sizeof(buf),
273  "\"%s%spg_ctl\" stop -D \"%s/data\" -s",
274  bindir ? bindir : "",
275  bindir ? "/" : "",
276  temp_instance);
277  r = system(buf);
278  if (r != 0)
279  {
280  fprintf(stderr, _("\n%s: could not stop postmaster: exit code was %d\n"),
281  progname, r);
282  _exit(2); /* not exit(), that could be recursive */
283  }
284 
285  postmaster_running = false;
286  }
287 }
static const char * progname
Definition: pg_regress.c:100
static bool postmaster_running
Definition: pg_regress.c:114
#define fprintf
Definition: port.h:219
static char * temp_instance
Definition: pg_regress.c:87
#define MAXPGPATH
static char * buf
Definition: pg_test_fsync.c:68
char * bindir
Definition: pg_regress.c:79
#define snprintf
Definition: port.h:215
#define _(x)
Definition: elog.c:89

◆ string_matches_pattern()

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

Definition at line 379 of file pg_regress.c.

Referenced by load_resultmap().

380 {
381  while (*str && *pattern)
382  {
383  if (*pattern == '.' && pattern[1] == '*')
384  {
385  pattern += 2;
386  /* Trailing .* matches everything. */
387  if (*pattern == '\0')
388  return true;
389 
390  /*
391  * Otherwise, scan for a text position at which we can match the
392  * rest of the pattern.
393  */
394  while (*str)
395  {
396  /*
397  * Optimization to prevent most recursion: don't recurse
398  * unless first pattern char might match this text char.
399  */
400  if (*str == *pattern || *pattern == '.')
401  {
402  if (string_matches_pattern(str, pattern))
403  return true;
404  }
405 
406  str++;
407  }
408 
409  /*
410  * End of text with no match.
411  */
412  return false;
413  }
414  else if (*pattern != '.' && *str != *pattern)
415  {
416  /*
417  * Not the single-character wildcard and no explicit match? Then
418  * time to quit...
419  */
420  return false;
421  }
422 
423  str++;
424  pattern++;
425  }
426 
427  if (*pattern == '\0')
428  return true; /* end of pattern, so declare match */
429 
430  /* End of input string. Do we have matching pattern remaining? */
431  while (*pattern == '.' && pattern[1] == '*')
432  pattern += 2;
433  if (*pattern == '\0')
434  return true; /* end of pattern, so declare match */
435 
436  return false;
437 }
static bool string_matches_pattern(const char *str, const char *pattern)
Definition: pg_regress.c:379

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

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

Referenced by run_schedule(), and run_single_test().

1525 {
1526  int tests_left;
1527  int i;
1528 
1529 #ifdef WIN32
1530  PID_TYPE *active_pids = pg_malloc(num_tests * sizeof(PID_TYPE));
1531 
1532  memcpy(active_pids, pids, num_tests * sizeof(PID_TYPE));
1533 #endif
1534 
1535  tests_left = num_tests;
1536  while (tests_left > 0)
1537  {
1538  PID_TYPE p;
1539 
1540 #ifndef WIN32
1541  int exit_status;
1542 
1543  p = wait(&exit_status);
1544 
1545  if (p == INVALID_PID)
1546  {
1547  fprintf(stderr, _("failed to wait for subprocesses: %s\n"),
1548  strerror(errno));
1549  exit(2);
1550  }
1551 #else
1552  DWORD exit_status;
1553  int r;
1554 
1555  r = WaitForMultipleObjects(tests_left, active_pids, FALSE, INFINITE);
1556  if (r < WAIT_OBJECT_0 || r >= WAIT_OBJECT_0 + tests_left)
1557  {
1558  fprintf(stderr, _("failed to wait for subprocesses: error code %lu\n"),
1559  GetLastError());
1560  exit(2);
1561  }
1562  p = active_pids[r - WAIT_OBJECT_0];
1563  /* compact the active_pids array */
1564  active_pids[r - WAIT_OBJECT_0] = active_pids[tests_left - 1];
1565 #endif /* WIN32 */
1566 
1567  for (i = 0; i < num_tests; i++)
1568  {
1569  if (p == pids[i])
1570  {
1571 #ifdef WIN32
1572  GetExitCodeProcess(pids[i], &exit_status);
1573  CloseHandle(pids[i]);
1574 #endif
1575  pids[i] = INVALID_PID;
1576  statuses[i] = (int) exit_status;
1577  INSTR_TIME_SET_CURRENT(stoptimes[i]);
1578  if (names)
1579  status(" %s", names[i]);
1580  tests_left--;
1581  break;
1582  }
1583  }
1584  }
1585 
1586 #ifdef WIN32
1587  free(active_pids);
1588 #endif
1589 }
void * pg_malloc(size_t size)
Definition: fe_memutils.c:47
#define PID_TYPE
Definition: pg_regress.h:14
#define fprintf
Definition: port.h:219
#define INVALID_PID
Definition: pg_regress.h:15
#define free(a)
Definition: header.h:65
#define strerror
Definition: port.h:228
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:156
int i
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:227
#define _(x)
Definition: elog.c:89

Variable Documentation

◆ basic_diff_opts

const char* basic_diff_opts = ""

Definition at line 67 of file pg_regress.c.

Referenced by results_differ().

◆ bindir

char* bindir = PGBINDIR

Definition at line 79 of file pg_regress.c.

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

◆ config_auth_datadir

char* config_auth_datadir = NULL
static

Definition at line 97 of file pg_regress.c.

Referenced by regression_main().

◆ dblist

◆ debug

bool debug = false

Definition at line 76 of file pg_regress.c.

Referenced by regression_main().

◆ difffilename

char* difffilename
static

Definition at line 103 of file pg_regress.c.

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

◆ dlpath

char* dlpath = PKGLIBDIR
static

Definition at line 94 of file pg_regress.c.

Referenced by convert_sourcefiles_in(), and regression_main().

◆ encoding

char* encoding = NULL
static

Definition at line 84 of file pg_regress.c.

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

◆ extra_tests

_stringlist* extra_tests = NULL
static

Definition at line 86 of file pg_regress.c.

◆ extraroles

_stringlist* extraroles = NULL
static

Definition at line 96 of file pg_regress.c.

◆ fail_count

int fail_count = 0
static

Definition at line 117 of file pg_regress.c.

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

◆ fail_ignore_count

int fail_ignore_count = 0
static

Definition at line 118 of file pg_regress.c.

Referenced by regression_main(), and run_schedule().

◆ host_platform

char* host_platform = HOST_TUPLE

Definition at line 55 of file pg_regress.c.

Referenced by load_resultmap().

◆ hostname

char* hostname = NULL
static

Definition at line 91 of file pg_regress.c.

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

◆ inputdir

◆ launcher

char* launcher = NULL

Definition at line 80 of file pg_regress.c.

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

◆ loadextension

_stringlist* loadextension = NULL
static

Definition at line 81 of file pg_regress.c.

◆ logfile

FILE* logfile
static

◆ logfilename

char* logfilename
static

Definition at line 101 of file pg_regress.c.

Referenced by open_result_files(), and regression_main().

◆ max_concurrent_tests

int max_concurrent_tests = 0
static

Definition at line 83 of file pg_regress.c.

Referenced by regression_main(), and run_schedule().

◆ max_connections

int max_connections = 0
static

Definition at line 82 of file pg_regress.c.

Referenced by regression_main(), and run_schedule().

◆ nolocale

bool nolocale = false
static

Definition at line 89 of file pg_regress.c.

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

◆ outputdir

◆ port

◆ port_specified_by_user

bool port_specified_by_user = false
static

Definition at line 93 of file pg_regress.c.

Referenced by regression_main().

◆ postmaster_pid

PID_TYPE postmaster_pid = INVALID_PID
static

Definition at line 113 of file pg_regress.c.

Referenced by regression_main().

◆ postmaster_running

bool postmaster_running = false
static

Definition at line 114 of file pg_regress.c.

Referenced by regression_main(), and stop_postmaster().

◆ pretty_diff_opts

const char* pretty_diff_opts = "-U3"

Definition at line 68 of file pg_regress.c.

Referenced by regression_main(), and results_differ().

◆ progname

◆ resultmap

_resultmap* resultmap = NULL
static

Definition at line 111 of file pg_regress.c.

Referenced by load_resultmap().

◆ schedulelist

_stringlist* schedulelist = NULL
static

Definition at line 85 of file pg_regress.c.

◆ shellprog

char* shellprog = SHELLPROG
static

Definition at line 58 of file pg_regress.c.

Referenced by spawn_process().

◆ sockdir

const char* sockdir
static

Definition at line 104 of file pg_regress.c.

Referenced by initialize_environment(), and regression_main().

◆ success_count

int success_count = 0
static

Definition at line 116 of file pg_regress.c.

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

◆ temp_configs

_stringlist* temp_configs = NULL
static

Definition at line 88 of file pg_regress.c.

◆ temp_instance

char* temp_instance = NULL
static

Definition at line 87 of file pg_regress.c.

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

◆ use_existing

bool use_existing = false
static

Definition at line 90 of file pg_regress.c.

Referenced by regression_main().

◆ user