kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/testProcess.c

756 lines
23 KiB
C
Raw Blame History

/*============================================================================
KWSys - Kitware System Library
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#include "kwsysPrivate.h"
#include KWSYS_HEADER(Process.h)
#include KWSYS_HEADER(Encoding.h)
/* Work-around CMake dependency scanning limitation. This must
duplicate the above list of headers. */
#if 0
# include "Process.h.in"
# include "Encoding.h.in"
#endif
#include <assert.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if defined(_WIN32)
# include <windows.h>
#else
# include <unistd.h>
# include <signal.h>
#endif
#if defined(__BORLANDC__)
# pragma warn -8060 /* possibly incorrect assignment */
#endif
/* Platform-specific sleep functions. */
#if defined(__BEOS__) && !defined(__ZETA__)
/* BeOS 5 doesn't have usleep(), but it has snooze(), which is identical. */
# include <be/kernel/OS.h>
static inline void testProcess_usleep(unsigned int usec)
{
snooze(usec);
}
#elif defined(_WIN32)
/* Windows can only sleep in millisecond intervals. */
static void testProcess_usleep(unsigned int usec)
{
Sleep(usec / 1000);
}
#else
# define testProcess_usleep usleep
#endif
#if defined(_WIN32)
static void testProcess_sleep(unsigned int sec)
{
Sleep(sec*1000);
}
#else
static void testProcess_sleep(unsigned int sec)
{
sleep(sec);
}
#endif
int runChild(const char* cmd[], int state, int exception, int value,
int share, int output, int delay, double timeout, int poll,
int repeat, int disown, int createNewGroup,
unsigned int interruptDelay);
static int test1(int argc, const char* argv[])
{
/* This is a very basic functional test of kwsysProcess. It is repeated
numerous times to verify that there are no resource leaks in kwsysProcess
that eventually lead to an error. Many versions of OS X will fail after
256 leaked file handles, so 257 iterations seems to be a good test. On
the other hand, too many iterations will cause the test to time out -
especially if the test is instrumented with e.g. valgrind.
If you have problems with this test timing out on your system, or want to
run more than 257 iterations, you can change the number of iterations by
setting the KWSYS_TEST_PROCESS_1_COUNT environment variable. */
(void)argc; (void)argv;
fprintf(stdout, "Output on stdout from test returning 0.\n");
fprintf(stderr, "Output on stderr from test returning 0.\n");
return 0;
}
static int test2(int argc, const char* argv[])
{
(void)argc; (void)argv;
fprintf(stdout, "Output on stdout from test returning 123.\n");
fprintf(stderr, "Output on stderr from test returning 123.\n");
return 123;
}
static int test3(int argc, const char* argv[])
{
(void)argc; (void)argv;
fprintf(stdout, "Output before sleep on stdout from timeout test.\n");
fprintf(stderr, "Output before sleep on stderr from timeout test.\n");
fflush(stdout);
fflush(stderr);
testProcess_sleep(15);
fprintf(stdout, "Output after sleep on stdout from timeout test.\n");
fprintf(stderr, "Output after sleep on stderr from timeout test.\n");
return 0;
}
static int test4(int argc, const char* argv[])
{
/* Prepare a pointer to an invalid address. Don't use null, because
dereferencing null is undefined behaviour and compilers are free to
do whatever they want. ex: Clang will warn at compile time, or even
optimize away the write. We hope to 'outsmart' them by using
'volatile' and a slightly larger address, based on a runtime value. */
volatile int* invalidAddress = 0;
invalidAddress += argc?1:2;
#if defined(_WIN32)
/* Avoid error diagnostic popups since we are crashing on purpose. */
SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
#elif defined(__BEOS__) || defined(__HAIKU__)
/* Avoid error diagnostic popups since we are crashing on purpose. */
disable_debugger(1);
#endif
(void)argc; (void)argv;
fprintf(stdout, "Output before crash on stdout from crash test.\n");
fprintf(stderr, "Output before crash on stderr from crash test.\n");
fflush(stdout);
fflush(stderr);
assert(invalidAddress); /* Quiet Clang scan-build. */
/* Provoke deliberate crash by writing to the invalid address. */
*invalidAddress = 0;
fprintf(stdout, "Output after crash on stdout from crash test.\n");
fprintf(stderr, "Output after crash on stderr from crash test.\n");
return 0;
}
static int test5(int argc, const char* argv[])
{
int r;
const char* cmd[4];
(void)argc;
cmd[0] = argv[0];
cmd[1] = "run";
cmd[2] = "4";
cmd[3] = 0;
fprintf(stdout, "Output on stdout before recursive test.\n");
fprintf(stderr, "Output on stderr before recursive test.\n");
fflush(stdout);
fflush(stderr);
r = runChild(cmd, kwsysProcess_State_Exception,
kwsysProcess_Exception_Fault, 1, 1, 1, 0, 15, 0, 1, 0, 0, 0);
fprintf(stdout, "Output on stdout after recursive test.\n");
fprintf(stderr, "Output on stderr after recursive test.\n");
fflush(stdout);
fflush(stderr);
return r;
}
#define TEST6_SIZE (4096*2)
static void test6(int argc, const char* argv[])
{
int i;
char runaway[TEST6_SIZE+1];
(void)argc; (void)argv;
for(i=0;i < TEST6_SIZE;++i)
{
runaway[i] = '.';
}
runaway[TEST6_SIZE] = '\n';
/* Generate huge amounts of output to test killing. */
for(;;)
{
fwrite(runaway, 1, TEST6_SIZE+1, stdout);
fflush(stdout);
}
}
/* Define MINPOLL to be one more than the number of times output is
written. Define MAXPOLL to be the largest number of times a loop
delaying 1/10th of a second should ever have to poll. */
#define MINPOLL 5
#define MAXPOLL 20
static int test7(int argc, const char* argv[])
{
(void)argc; (void)argv;
fprintf(stdout, "Output on stdout before sleep.\n");
fprintf(stderr, "Output on stderr before sleep.\n");
fflush(stdout);
fflush(stderr);
/* Sleep for 1 second. */
testProcess_sleep(1);
fprintf(stdout, "Output on stdout after sleep.\n");
fprintf(stderr, "Output on stderr after sleep.\n");
fflush(stdout);
fflush(stderr);
return 0;
}
static int test8(int argc, const char* argv[])
{
/* Create a disowned grandchild to test handling of processes
that exit before their children. */
int r;
const char* cmd[4];
(void)argc;
cmd[0] = argv[0];
cmd[1] = "run";
cmd[2] = "108";
cmd[3] = 0;
fprintf(stdout, "Output on stdout before grandchild test.\n");
fprintf(stderr, "Output on stderr before grandchild test.\n");
fflush(stdout);
fflush(stderr);
r = runChild(cmd, kwsysProcess_State_Disowned, kwsysProcess_Exception_None,
1, 1, 1, 0, 10, 0, 1, 1, 0, 0);
fprintf(stdout, "Output on stdout after grandchild test.\n");
fprintf(stderr, "Output on stderr after grandchild test.\n");
fflush(stdout);
fflush(stderr);
return r;
}
static int test8_grandchild(int argc, const char* argv[])
{
(void)argc; (void)argv;
fprintf(stdout, "Output on stdout from grandchild before sleep.\n");
fprintf(stderr, "Output on stderr from grandchild before sleep.\n");
fflush(stdout);
fflush(stderr);
/* TODO: Instead of closing pipes here leave them open to make sure
the grandparent can stop listening when the parent exits. This
part of the test cannot be enabled until the feature is
implemented. */
fclose(stdout);
fclose(stderr);
testProcess_sleep(15);
return 0;
}
static int test9(int argc, const char* argv[])
{
/* Test Ctrl+C behavior: the root test program will send a Ctrl+C to this
process. Here, we start a child process that sleeps for a long time
while ignoring signals. The test is successful if this process waits
for the child to return before exiting from the Ctrl+C handler.
WARNING: This test will falsely pass if the share parameter of runChild
was set to 0 when invoking the test9 process. */
int r;
const char* cmd[4];
(void)argc;
cmd[0] = argv[0];
cmd[1] = "run";
cmd[2] = "109";
cmd[3] = 0;
fprintf(stdout, "Output on stdout before grandchild test.\n");
fprintf(stderr, "Output on stderr before grandchild test.\n");
fflush(stdout);
fflush(stderr);
r = runChild(cmd, kwsysProcess_State_Exited,
kwsysProcess_Exception_None,
0, 1, 1, 0, 30, 0, 1, 0, 0, 0);
/* This sleep will avoid a race condition between this function exiting
normally and our Ctrl+C handler exiting abnormally after the process
exits. */
testProcess_sleep(1);
fprintf(stdout, "Output on stdout after grandchild test.\n");
fprintf(stderr, "Output on stderr after grandchild test.\n");
fflush(stdout);
fflush(stderr);
return r;
}
#if defined(_WIN32)
static BOOL WINAPI test9_grandchild_handler(DWORD dwCtrlType)
{
/* Ignore all Ctrl+C/Break signals. We must use an actual handler function
instead of using SetConsoleCtrlHandler(NULL, TRUE) so that we can also
ignore Ctrl+Break in addition to Ctrl+C. */
(void)dwCtrlType;
return TRUE;
}
#endif
static int test9_grandchild(int argc, const char* argv[])
{
/* The grandchild just sleeps for a few seconds while ignoring signals. */
(void)argc; (void)argv;
#if defined(_WIN32)
if(!SetConsoleCtrlHandler(test9_grandchild_handler, TRUE))
{
return 1;
}
#else
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_IGN;
sigemptyset(&sa.sa_mask);
if(sigaction(SIGINT, &sa, 0) < 0)
{
return 1;
}
#endif
fprintf(stdout, "Output on stdout from grandchild before sleep.\n");
fprintf(stderr, "Output on stderr from grandchild before sleep.\n");
fflush(stdout);
fflush(stderr);
/* Sleep for 9 seconds. */
testProcess_sleep(9);
fprintf(stdout, "Output on stdout from grandchild after sleep.\n");
fprintf(stderr, "Output on stderr from grandchild after sleep.\n");
fflush(stdout);
fflush(stderr);
return 0;
}
static int test10(int argc, const char* argv[])
{
/* Test Ctrl+C behavior: the root test program will send a Ctrl+C to this
process. Here, we start a child process that sleeps for a long time and
processes signals normally. However, this grandchild is created in a new
process group - ensuring that Ctrl+C we receive is sent to our process
groups. We make sure it exits anyway. */
int r;
const char* cmd[4];
(void)argc;
cmd[0] = argv[0];
cmd[1] = "run";
cmd[2] = "110";
cmd[3] = 0;
fprintf(stdout, "Output on stdout before grandchild test.\n");
fprintf(stderr, "Output on stderr before grandchild test.\n");
fflush(stdout);
fflush(stderr);
r = runChild(cmd, kwsysProcess_State_Exception,
kwsysProcess_Exception_Interrupt,
0, 1, 1, 0, 30, 0, 1, 0, 1, 0);
fprintf(stdout, "Output on stdout after grandchild test.\n");
fprintf(stderr, "Output on stderr after grandchild test.\n");
fflush(stdout);
fflush(stderr);
return r;
}
static int test10_grandchild(int argc, const char* argv[])
{
/* The grandchild just sleeps for a few seconds and handles signals. */
(void)argc; (void)argv;
fprintf(stdout, "Output on stdout from grandchild before sleep.\n");
fprintf(stderr, "Output on stderr from grandchild before sleep.\n");
fflush(stdout);
fflush(stderr);
/* Sleep for 6 seconds. */
testProcess_sleep(6);
fprintf(stdout, "Output on stdout from grandchild after sleep.\n");
fprintf(stderr, "Output on stderr from grandchild after sleep.\n");
fflush(stdout);
fflush(stderr);
return 0;
}
static int runChild2(kwsysProcess* kp,
const char* cmd[], int state, int exception, int value,
int share, int output, int delay, double timeout,
int poll, int disown, int createNewGroup,
unsigned int interruptDelay)
{
int result = 0;
char* data = 0;
int length = 0;
double userTimeout = 0;
double* pUserTimeout = 0;
kwsysProcess_SetCommand(kp, cmd);
if(timeout >= 0)
{
kwsysProcess_SetTimeout(kp, timeout);
}
if(share)
{
kwsysProcess_SetPipeShared(kp, kwsysProcess_Pipe_STDOUT, 1);
kwsysProcess_SetPipeShared(kp, kwsysProcess_Pipe_STDERR, 1);
}
if(disown)
{
kwsysProcess_SetOption(kp, kwsysProcess_Option_Detach, 1);
}
if(createNewGroup)
{
kwsysProcess_SetOption(kp, kwsysProcess_Option_CreateProcessGroup, 1);
}
kwsysProcess_Execute(kp);
if(poll)
{
pUserTimeout = &userTimeout;
}
if(interruptDelay)
{
testProcess_sleep(interruptDelay);
kwsysProcess_Interrupt(kp);
}
if(!share && !disown)
{
int p;
while((p = kwsysProcess_WaitForData(kp, &data, &length, pUserTimeout)))
{
if(output)
{
if(poll && p == kwsysProcess_Pipe_Timeout)
{
fprintf(stdout, "WaitForData timeout reached.\n");
fflush(stdout);
/* Count the number of times we polled without getting data.
If it is excessive then kill the child and fail. */
if(++poll >= MAXPOLL)
{
fprintf(stdout, "Poll count reached limit %d.\n",
MAXPOLL);
kwsysProcess_Kill(kp);
}
}
else
{
fwrite(data, 1, (size_t) length, stdout);
fflush(stdout);
}
}
if(poll)
{
/* Delay to avoid busy loop during polling. */
testProcess_usleep(100000);
}
if(delay)
{
/* Purposely sleeping only on Win32 to let pipe fill up. */
#if defined(_WIN32)
testProcess_usleep(100000);
#endif
}
}
}
if(disown)
{
kwsysProcess_Disown(kp);
}
else
{
kwsysProcess_WaitForExit(kp, 0);
}
switch (kwsysProcess_GetState(kp))
{
case kwsysProcess_State_Starting:
printf("No process has been executed.\n"); break;
case kwsysProcess_State_Executing:
printf("The process is still executing.\n"); break;
case kwsysProcess_State_Expired:
printf("Child was killed when timeout expired.\n"); break;
case kwsysProcess_State_Exited:
printf("Child exited with value = %d\n",
kwsysProcess_GetExitValue(kp));
result = ((exception != kwsysProcess_GetExitException(kp)) ||
(value != kwsysProcess_GetExitValue(kp))); break;
case kwsysProcess_State_Killed:
printf("Child was killed by parent.\n"); break;
case kwsysProcess_State_Exception:
printf("Child terminated abnormally: %s\n",
kwsysProcess_GetExceptionString(kp));
result = ((exception != kwsysProcess_GetExitException(kp)) ||
(value != kwsysProcess_GetExitValue(kp))); break;
case kwsysProcess_State_Disowned:
printf("Child was disowned.\n"); break;
case kwsysProcess_State_Error:
printf("Error in administrating child process: [%s]\n",
kwsysProcess_GetErrorString(kp)); break;
};
if(result)
{
if(exception != kwsysProcess_GetExitException(kp))
{
fprintf(stderr, "Mismatch in exit exception. "
"Should have been %d, was %d.\n",
exception, kwsysProcess_GetExitException(kp));
}
if(value != kwsysProcess_GetExitValue(kp))
{
fprintf(stderr, "Mismatch in exit value. "
"Should have been %d, was %d.\n",
value, kwsysProcess_GetExitValue(kp));
}
}
if(kwsysProcess_GetState(kp) != state)
{
fprintf(stderr, "Mismatch in state. "
"Should have been %d, was %d.\n",
state, kwsysProcess_GetState(kp));
result = 1;
}
/* We should have polled more times than there were data if polling
was enabled. */
if(poll && poll < MINPOLL)
{
fprintf(stderr, "Poll count is %d, which is less than %d.\n",
poll, MINPOLL);
result = 1;
}
return result;
}
/**
* Runs a child process and blocks until it returns. Arguments as follows:
*
* cmd = Command line to run.
* state = Expected return value of kwsysProcess_GetState after exit.
* exception = Expected return value of kwsysProcess_GetExitException.
* value = Expected return value of kwsysProcess_GetExitValue.
* share = Whether to share stdout/stderr child pipes with our pipes
* by way of kwsysProcess_SetPipeShared. If false, new pipes
* are created.
* output = If !share && !disown, whether to write the child's stdout
* and stderr output to our stdout.
* delay = If !share && !disown, adds an additional short delay to
* the pipe loop to allow the pipes to fill up; Windows only.
* timeout = Non-zero to sets a timeout in seconds via
* kwsysProcess_SetTimeout.
* poll = If !share && !disown, we count the number of 0.1 second
* intervals where the child pipes had no new data. We fail
* if not in the bounds of MINPOLL/MAXPOLL.
* repeat = Number of times to run the process.
* disown = If set, the process is disowned.
* createNewGroup = If set, the process is created in a new process group.
* interruptDelay = If non-zero, number of seconds to delay before
* interrupting the process. Note that this delay will occur
* BEFORE any reading/polling of pipes occurs and before any
* detachment occurs.
*/
int runChild(const char* cmd[], int state, int exception, int value,
int share, int output, int delay, double timeout,
int poll, int repeat, int disown, int createNewGroup,
unsigned int interruptDelay)
{
int result = 1;
kwsysProcess* kp = kwsysProcess_New();
if(!kp)
{
fprintf(stderr, "kwsysProcess_New returned NULL!\n");
return 1;
}
while(repeat-- > 0)
{
result = runChild2(kp, cmd, state, exception, value, share,
output, delay, timeout, poll, disown, createNewGroup,
interruptDelay);
if(result)
{
break;
}
}
kwsysProcess_Delete(kp);
return result;
}
int main(int argc, const char* argv[])
{
int n = 0;
#ifdef _WIN32
int i;
char new_args[10][_MAX_PATH];
LPWSTR* w_av = CommandLineToArgvW(GetCommandLineW(), &argc);
for(i=0; i<argc; i++)
{
kwsysEncoding_wcstombs(new_args[i], w_av[i], _MAX_PATH);
argv[i] = new_args[i];
}
LocalFree(w_av);
#endif
#if 0
{
HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
DuplicateHandle(GetCurrentProcess(), out,
GetCurrentProcess(), &out, 0, FALSE,
DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);
SetStdHandle(STD_OUTPUT_HANDLE, out);
}
{
HANDLE out = GetStdHandle(STD_ERROR_HANDLE);
DuplicateHandle(GetCurrentProcess(), out,
GetCurrentProcess(), &out, 0, FALSE,
DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);
SetStdHandle(STD_ERROR_HANDLE, out);
}
#endif
if(argc == 2)
{
n = atoi(argv[1]);
}
else if(argc == 3 && strcmp(argv[1], "run") == 0)
{
n = atoi(argv[2]);
}
/* Check arguments. */
if(((n >= 1 && n <= 10) || n == 108 || n == 109 || n == 110) && argc == 3)
{
/* This is the child process for a requested test number. */
switch (n)
{
case 1: return test1(argc, argv);
case 2: return test2(argc, argv);
case 3: return test3(argc, argv);
case 4: return test4(argc, argv);
case 5: return test5(argc, argv);
case 6: test6(argc, argv); return 0;
case 7: return test7(argc, argv);
case 8: return test8(argc, argv);
case 9: return test9(argc, argv);
case 10: return test10(argc, argv);
case 108: return test8_grandchild(argc, argv);
case 109: return test9_grandchild(argc, argv);
case 110: return test10_grandchild(argc, argv);
}
fprintf(stderr, "Invalid test number %d.\n", n);
return 1;
}
else if(n >= 1 && n <= 10)
{
/* This is the parent process for a requested test number. */
int states[10] =
{
kwsysProcess_State_Exited,
kwsysProcess_State_Exited,
kwsysProcess_State_Expired,
kwsysProcess_State_Exception,
kwsysProcess_State_Exited,
kwsysProcess_State_Expired,
kwsysProcess_State_Exited,
kwsysProcess_State_Exited,
kwsysProcess_State_Expired, /* Ctrl+C handler test */
kwsysProcess_State_Exception /* Process group test */
};
int exceptions[10] =
{
kwsysProcess_Exception_None,
kwsysProcess_Exception_None,
kwsysProcess_Exception_None,
kwsysProcess_Exception_Fault,
kwsysProcess_Exception_None,
kwsysProcess_Exception_None,
kwsysProcess_Exception_None,
kwsysProcess_Exception_None,
kwsysProcess_Exception_None,
kwsysProcess_Exception_Interrupt
};
int values[10] = {0, 123, 1, 1, 0, 0, 0, 0, 1, 1};
int shares[10] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1};
int outputs[10] = {1, 1, 1, 1, 1, 0, 1, 1, 1, 1};
int delays[10] = {0, 0, 0, 0, 0, 1, 0, 0, 0, 0};
double timeouts[10] = {10, 10, 10, 30, 30, 10, -1, 10, 6, 4};
int polls[10] = {0, 0, 0, 0, 0, 0, 1, 0, 0, 0};
int repeat[10] = {257, 1, 1, 1, 1, 1, 1, 1, 1, 1};
int createNewGroups[10] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1};
unsigned int interruptDelays[10] = {0, 0, 0, 0, 0, 0, 0, 0, 3, 2};
int r;
const char* cmd[4];
#ifdef _WIN32
char* argv0 = 0;
#endif
char* test1IterationsStr = getenv("KWSYS_TEST_PROCESS_1_COUNT");
if(test1IterationsStr)
{
long int test1Iterations = strtol(test1IterationsStr, 0, 10);
if(test1Iterations > 10 && test1Iterations != LONG_MAX)
{
repeat[0] = (int)test1Iterations;
}
}
#ifdef _WIN32
if(n == 0 && (argv0 = strdup(argv[0])))
{
/* Try converting to forward slashes to see if it works. */
char* c;
for(c=argv0; *c; ++c)
{
if(*c == '\\')
{
*c = '/';
}
}
cmd[0] = argv0;
}
else
{
cmd[0] = argv[0];
}
#else
cmd[0] = argv[0];
#endif
cmd[1] = "run";
cmd[2] = argv[1];
cmd[3] = 0;
fprintf(stdout, "Output on stdout before test %d.\n", n);
fprintf(stderr, "Output on stderr before test %d.\n", n);
fflush(stdout);
fflush(stderr);
r = runChild(cmd, states[n-1], exceptions[n-1], values[n-1], shares[n-1],
outputs[n-1], delays[n-1], timeouts[n-1],
polls[n-1], repeat[n-1], 0, createNewGroups[n-1],
interruptDelays[n-1]);
fprintf(stdout, "Output on stdout after test %d.\n", n);
fprintf(stderr, "Output on stderr after test %d.\n", n);
fflush(stdout);
fflush(stderr);
#if defined(_WIN32)
if(argv0) { free(argv0); }
#endif
return r;
}
else if(argc > 2 && strcmp(argv[1], "0") == 0)
{
/* This is the special debugging test to run a given command
line. */
const char** cmd = argv+2;
int state = kwsysProcess_State_Exited;
int exception = kwsysProcess_Exception_None;
int value = 0;
double timeout = 0;
int r = runChild(cmd, state, exception, value, 0, 1, 0, timeout,
0, 1, 0, 0, 0);
return r;
}
else
{
/* Improper usage. */
fprintf(stdout, "Usage: %s <test number>\n", argv[0]);
return 1;
}
}
Reference in New Issue View Git Blame Copy Permalink