PostgreSQL Source Code  git master
pg_regress.h File Reference
#include <unistd.h>
Include dependency graph for pg_regress.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  _stringlist
 

Macros

#define PID_TYPE   pid_t
 
#define INVALID_PID   (-1)
 

Typedefs

typedef struct _stringlist _stringlist
 
typedef PID_TYPE(* test_function) (const char *, _stringlist **, _stringlist **, _stringlist **)
 
typedef void(* init_function) (int argc, char **argv)
 

Functions

int regression_main (int argc, char *argv[], init_function ifunc, test_function tfunc)
 
void add_stringlist_item (_stringlist **listhead, const char *str)
 
PID_TYPE spawn_process (const char *cmdline)
 
void replace_string (char *string, const char *replace, const char *replacement)
 
bool file_exists (const char *file)
 

Variables

char * bindir
 
char * libdir
 
char * datadir
 
char * host_platform
 
_stringlistdblist
 
bool debug
 
char * inputdir
 
char * outputdir
 
char * launcher
 
const char * basic_diff_opts
 
const char * pretty_diff_opts
 

Macro Definition Documentation

◆ INVALID_PID

#define INVALID_PID   (-1)

◆ PID_TYPE

Typedef Documentation

◆ _stringlist

typedef struct _stringlist _stringlist

◆ init_function

typedef void(* init_function) (int argc, char **argv)

Definition at line 32 of file pg_regress.h.

◆ test_function

typedef PID_TYPE(* test_function) (const char *, _stringlist **, _stringlist **, _stringlist **)

Definition at line 28 of file pg_regress.h.

Function Documentation

◆ add_stringlist_item()

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

Definition at line 156 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().

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

◆ file_exists()

bool file_exists ( const char *  file)

Definition at line 1262 of file pg_regress.c.

Referenced by results_differ().

1263 {
1264  FILE *f = fopen(file, "r");
1265 
1266  if (!f)
1267  return false;
1268  fclose(f);
1269  return true;
1270 }

◆ regression_main()

int regression_main ( int  argc,
char *  argv[],
init_function  ifunc,
test_function  tfunc 
)

Definition at line 2091 of file pg_regress.c.

References _, add_stringlist_item(), bindir, buf, config_auth_datadir, create_database(), create_role(), debug, DEVNULL, difffilename, directory_exists(), dlpath, doputenv(), 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(), SIGKILL, snprintf, sockdir, spawn_process(), split_to_stringlist(), sprintf, stop_postmaster(), _stringlist::str, strerror, success_count, temp_instance, ULONGPID, use_existing, user, and wait_seconds.

Referenced by main().

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

◆ replace_string()

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

Definition at line 442 of file pg_regress.c.

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

Referenced by convert_sourcefiles_in(), ecpg_filter(), and ecpg_start_test().

443 {
444  char *ptr;
445 
446  while ((ptr = strstr(string, replace)) != NULL)
447  {
448  char *dup = pg_strdup(string);
449 
450  strlcpy(string, dup, ptr - string + 1);
451  strcat(string, replacement);
452  strcat(string, dup + (ptr - string) + strlen(replace));
453  free(dup);
454  }
455 }
char * pg_strdup(const char *in)
Definition: fe_memutils.c:85
#define free(a)
Definition: header.h:65
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45

◆ spawn_process()

PID_TYPE spawn_process ( const char *  cmdline)

Definition at line 1152 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().

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

Variable Documentation

◆ basic_diff_opts

const char* basic_diff_opts

Definition at line 65 of file pg_regress.c.

Referenced by results_differ().

◆ bindir

char* bindir

Definition at line 77 of file pg_regress.c.

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

◆ datadir

char* datadir

◆ dblist

◆ debug

◆ host_platform

char* host_platform

Definition at line 53 of file pg_regress.c.

Referenced by load_resultmap().

◆ inputdir

◆ launcher

char* launcher

Definition at line 78 of file pg_regress.c.

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

◆ libdir

char* libdir

◆ outputdir

◆ pretty_diff_opts

const char* pretty_diff_opts

Definition at line 66 of file pg_regress.c.

Referenced by regression_main(), and results_differ().