/* Test capturing output from a subprocess. Copyright (C) 2017-2018 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ #include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <support/capture_subprocess.h> #include <support/check.h> #include <support/support.h> #include <sys/wait.h> #include <unistd.h> /* Write one byte at *P to FD and advance *P. Do nothing if *P is '\0'. */ static void transfer (const unsigned char **p, int fd) { if (**p != '\0') { TEST_VERIFY (write (fd, *p, 1) == 1); ++*p; } } /* Determine the order in which stdout and stderr are written. */ enum write_mode { out_first, err_first, interleave, write_mode_last = interleave }; /* Describe what to write in the subprocess. */ struct test { char *out; char *err; enum write_mode write_mode; int signal; int status; }; /* For use with support_capture_subprocess. */ static void callback (void *closure) { const struct test *test = closure; bool mode_ok = false; switch (test->write_mode) { case out_first: TEST_VERIFY (fputs (test->out, stdout) >= 0); TEST_VERIFY (fflush (stdout) == 0); TEST_VERIFY (fputs (test->err, stderr) >= 0); TEST_VERIFY (fflush (stderr) == 0); mode_ok = true; break; case err_first: TEST_VERIFY (fputs (test->err, stderr) >= 0); TEST_VERIFY (fflush (stderr) == 0); TEST_VERIFY (fputs (test->out, stdout) >= 0); TEST_VERIFY (fflush (stdout) == 0); mode_ok = true; break; case interleave: { const unsigned char *pout = (const unsigned char *) test->out; const unsigned char *perr = (const unsigned char *) test->err; do { transfer (&pout, STDOUT_FILENO); transfer (&perr, STDERR_FILENO); } while (*pout != '\0' || *perr != '\0'); } mode_ok = true; break; } TEST_VERIFY (mode_ok); if (test->signal != 0) raise (test->signal); exit (test->status); } /* Create a heap-allocated random string of letters. */ static char * random_string (size_t length) { char *result = xmalloc (length + 1); for (size_t i = 0; i < length; ++i) result[i] = 'a' + (rand () % 26); result[length] = '\0'; return result; } /* Check that the specific stream from the captured subprocess matches expectations. */ static void check_stream (const char *what, const struct xmemstream *stream, const char *expected) { if (strcmp (stream->buffer, expected) != 0) { support_record_failure (); printf ("error: captured %s data incorrect\n" " expected: %s\n" " actual: %s\n", what, expected, stream->buffer); } if (stream->length != strlen (expected)) { support_record_failure (); printf ("error: captured %s data length incorrect\n" " expected: %zu\n" " actual: %zu\n", what, strlen (expected), stream->length); } } static int do_test (void) { const int lengths[] = {0, 1, 17, 512, 20000, -1}; /* Test multiple combinations of support_capture_subprocess. length_idx_stdout: Index into the lengths array above, controls how many bytes are written by the subprocess to standard output. length_idx_stderr: Same for standard error. write_mode: How standard output and standard error writes are ordered. signal: Exit with no signal if zero, with SIGTERM if one. status: Process exit status: 0 if zero, 3 if one. */ for (int length_idx_stdout = 0; lengths[length_idx_stdout] >= 0; ++length_idx_stdout) for (int length_idx_stderr = 0; lengths[length_idx_stderr] >= 0; ++length_idx_stderr) for (int write_mode = 0; write_mode < write_mode_last; ++write_mode) for (int signal = 0; signal < 2; ++signal) for (int status = 0; status < 2; ++status) { struct test test = { .out = random_string (lengths[length_idx_stdout]), .err = random_string (lengths[length_idx_stderr]), .write_mode = write_mode, .signal = signal * SIGTERM, /* 0 or SIGTERM. */ .status = status * 3, /* 0 or 3. */ }; TEST_VERIFY (strlen (test.out) == lengths[length_idx_stdout]); TEST_VERIFY (strlen (test.err) == lengths[length_idx_stderr]); struct support_capture_subprocess result = support_capture_subprocess (callback, &test); check_stream ("stdout", &result.out, test.out); check_stream ("stderr", &result.err, test.err); if (test.signal != 0) { TEST_VERIFY (WIFSIGNALED (result.status)); TEST_VERIFY (WTERMSIG (result.status) == test.signal); } else { TEST_VERIFY (WIFEXITED (result.status)); TEST_VERIFY (WEXITSTATUS (result.status) == test.status); } support_capture_subprocess_free (&result); free (test.out); free (test.err); } return 0; } #include <support/test-driver.c>