CMake/Source/kwsys/testProcess.c

306 lines
8.3 KiB
C
Raw Normal View History

2003-12-16 00:30:46 +03:00
/*=========================================================================
Program: KWSys - Kitware System Library
Module: $RCSfile$
Copyright (c) Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#include <kwsys/Process.h>
#include <stdio.h>
#include <stdlib.h>
2004-10-01 19:36:38 +04:00
#include <string.h>
#if defined(_WIN32)
# include <windows.h>
#else
# include <unistd.h>
#endif
int runChild(const char* cmd[], int state, int exception, int value,
int share, int output, int delay, double timeout);
int test1(int argc, const char* argv[])
{
(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;
}
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;
}
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);
#if defined(_WIN32)
Sleep(5000);
#else
sleep(5);
#endif
fprintf(stdout, "Output after sleep on stdout from timeout test.\n");
fprintf(stderr, "Output after sleep on stderr from timeout test.\n");
return 0;
}
int test4(int argc, const char* argv[])
{
(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);
*(int*)0 = 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;
}
int test5(int argc, const char* argv[])
{
int r;
const char* cmd[4];
2004-01-19 17:30:44 +03:00
(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, 2);
fprintf(stdout, "Output on stdout after recursive test.\n");
fprintf(stderr, "Output on stderr after recursive test.\n");
fflush(stdout);
fflush(stderr);
return r;
}
2004-07-14 01:27:58 +04:00
#define TEST6_SIZE (4096*2)
int test6(int argc, const char* argv[])
{
int i;
char runaway[TEST6_SIZE+1];
2004-07-14 01:27:58 +04:00
(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);
2004-07-14 01:27:58 +04:00
fflush(stdout);
}
return 0;
}
int runChild(const char* cmd[], int state, int exception, int value,
int share, int output, int delay, double timeout)
{
int result = 0;
char* data = 0;
int length = 0;
kwsysProcess* kp = kwsysProcess_New();
if(!kp)
{
fprintf(stderr, "kwsysProcess_New returned NULL!\n");
return 1;
}
kwsysProcess_SetCommand(kp, cmd);
kwsysProcess_SetTimeout(kp, timeout);
if(share)
{
kwsysProcess_SetPipeShared(kp, kwsysProcess_Pipe_STDOUT, 1);
kwsysProcess_SetPipeShared(kp, kwsysProcess_Pipe_STDERR, 1);
}
kwsysProcess_Execute(kp);
if(!share)
{
while(kwsysProcess_WaitForData(kp, &data, &length, 0))
{
if(output)
{
fwrite(data, 1, length, stdout);
fflush(stdout);
}
2004-07-14 01:27:58 +04:00
if(delay)
{
/* Purposely sleeping only on Win32 to let pipe fill up. */
2004-07-14 01:27:58 +04:00
#if defined(_WIN32)
Sleep(100);
#endif
}
}
}
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_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.\n",
exception);
}
if(value != kwsysProcess_GetExitValue(kp))
{
fprintf(stderr, "Mismatch in exit value. Should have been %d.\n",
value);
}
}
if(kwsysProcess_GetState(kp) != state)
{
fprintf(stderr, "Mismatch in state. Should have been %d.\n", state);
result = 1;
}
kwsysProcess_Delete(kp);
return result;
}
int main(int argc, const char* argv[])
{
int n = 0;
#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)
{
n = atoi(argv[2]);
}
/* Check arguments. */
2004-07-14 01:27:58 +04:00
if(n < 1 || n > 6 || (argc == 3 && strcmp(argv[1], "run") != 0))
{
fprintf(stdout, "Usage: %s <test number>\n", argv[0]);
return 1;
}
if(argc == 3)
{
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);
2004-07-14 01:27:58 +04:00
case 6: return test6(argc, argv);
}
fprintf(stderr, "Invalid test number %d.\n", n);
return 1;
}
2004-07-14 01:27:58 +04:00
if(n >= 0 && n <= 6)
{
2004-07-14 01:27:58 +04:00
int states[6] =
{
kwsysProcess_State_Exited,
kwsysProcess_State_Exited,
kwsysProcess_State_Expired,
kwsysProcess_State_Exception,
2004-07-14 01:27:58 +04:00
kwsysProcess_State_Exited,
kwsysProcess_State_Expired
};
2004-07-14 01:27:58 +04:00
int exceptions[6] =
{
kwsysProcess_Exception_None,
kwsysProcess_Exception_None,
kwsysProcess_Exception_None,
kwsysProcess_Exception_Fault,
2004-07-14 01:27:58 +04:00
kwsysProcess_Exception_None,
kwsysProcess_Exception_None
};
2004-07-14 01:27:58 +04:00
int values[6] = {0, 123, 1, 1, 0, 0};
int outputs[6] = {1, 1, 1, 1, 1, 0};
2004-07-14 01:27:58 +04:00
int delays[6] = {0, 0, 0, 0, 0, 1};
double timeouts[6] = {3, 3, 3, 3, 3, 0.1};
int r;
const char* cmd[4];
cmd[0] = argv[0];
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);
2004-07-14 01:27:58 +04:00
r = runChild(cmd, states[n-1], exceptions[n-1], values[n-1], 0,
outputs[n-1], delays[n-1], timeouts[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);
return r;
}
else
{
fprintf(stderr, "Test number out of range\n");
return 1;
}
}