int
run_main (int argc, ACE_TCHAR *argv[])
{
ACE_OS::signal(SIGHUP, SIG_DFL);
if (argc > 1)
{
ACE_APPEND_LOG (ACE_TEXT ("Signal_Test-child"));
parse_args (argc, argv);
if (test_number == 1)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) **** test 1: handle signals synchronously in separate thread\n")));
// First, handle signals synchronously in separate thread.
run_test (worker_child, 1, 1);
}
else if (test_number == 2)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) **** test 2: handle signals synchronously in this thread\n")));
// Next, handle signals synchronously in this thread.
run_test (worker_child, 0, 1);
}
else if (test_number == 3)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) **** test 3: handle signals asynchronously in this thread\n")));
// Finally, handle signals asynchronously in this thread.
run_test (worker_child, 0, 0);
}
ACE_END_LOG;
}
else
{
ACE_START_TEST (ACE_TEXT ("Signal_Test"));
ACE_INIT_LOG (ACE_TEXT ("Signal_Test-child"));
// We need to get the process id here to work around "features"
// of Linux threads...
parent_pid = ACE_OS::getpid ();
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) **** test 1: handle signals synchronously in a separate thread\n")));
#ifdef ACE_HAS_THREADS
++test_number;
// Run the parent logic for the signal test, first by handling
// signals synchronously in a separate thread.
run_test (worker_parent, 1L, 1L);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) **** test 2: handle signals synchronously in this thread\n")));
++test_number;
// And next by handling synchronously signals in this thread.
run_test (worker_parent, 0L, 1L);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) **** test 3: handle signals asynchronously in this thread\n")));
#else
test_number += 2;
#endif /* ACE_HAS_THREADS */
++test_number;
// And finally by handling asynchronously signals in this thread.
run_test (worker_parent, 0L, 0L);
ACE_END_TEST;
}
return 0;
}
int
run_main (int argc, ACE_TCHAR *argv[])
{
#if defined (ACE_WIN32)
get_base_addrs();
#endif
if (argc == 1)
{
ACE_START_TEST (ACE_TEXT ("Malloc_Test"));
ACE_INIT_LOG (ACE_TEXT ("Malloc_Test-child"));
init_test (PARENT_BASE_ADDR);
ACE_Control_Block::print_alignment_info ();
# if (ACE_HAS_POSITION_INDEPENDENT_POINTERS == 1)
ACE_PI_Control_Block::print_alignment_info ();
# endif /* ACE_HAS_POSITION_INDEPENDENT_POINTERS == 1 */
// No arguments means we're the parent process.
ACE_Process_Options options (1);
#if !defined (ACE_WIN32) && defined (ACE_USES_WCHAR)
static const ACE_TCHAR* format = ACE_TEXT ("%ls%ls%ls");
#else
static const ACE_TCHAR* format = ACE_TEXT ("%s%s%s");
#endif /* !ACE_WIN32 && ACE_USES_WCHAR */
options.command_line (format, EXE_LOCATION,
argc > 0 ? argv[0] : ACE_TEXT ("Malloc_Test"),
ACE_TEXT (" run_as_test"));
MALLOC *myalloc = myallocator (PARENT_BASE_ADDR);
Test_Data *data = initialize (myalloc);
ACE_TEST_ASSERT (data != 0);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P) PARENT allocator at = %@, ")
ACE_TEXT ("data allocated at %@\n"),
myalloc,
data));
myalloc->dump ();
int result = myalloc->bind ("foo", data);
ACE_TEST_ASSERT (result != -1);
ACE_Process p;
pid_t pid = p.spawn (options);
if (pid == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("spawn")), 1);
parent (data);
// Synchronize on the exit of the child.
result = p.wait ();
if (result == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("wait")), 1);
ACE_TEST_ASSERT (myalloc->ref_counter () == 1);
myalloc->remove ();
ACE_END_TEST;
return 0;
}
else
{
// In this case we're the child process.
ACE_APPEND_LOG (ACE_TEXT ("Malloc_Test-child"));
void *data = 0;
MALLOC *myalloc = myallocator (CHILD_BASE_ADDR);
int result = myalloc->find ("foo", data);
ACE_TEST_ASSERT (result != -1);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P) CHILD allocator at = %@, ")
ACE_TEXT ("data allocated at %@\n"),
myalloc,
data));
myalloc->dump ();
child ();
myalloc->release ();
ACE_END_LOG;
return 0;
}
}
int
run_main (int argc, ACE_TCHAR *argv[])
{
parse_args (argc, argv);
if (child_process)
{
ACE_APPEND_LOG (ACE_TEXT("Pipe_Test-children"));
ACE_Pipe a, b, c, d, e;
open_pipe (a, "a");
open_pipe (b, "b");
open_pipe (c, "c");
open_pipe (d, "d");
open_pipe (e, "e");
ACE_END_LOG;
}
else
{
ACE_START_TEST (ACE_TEXT("Pipe_Test"));
ACE_INIT_LOG (ACE_TEXT("Pipe_Test-children"));
# if defined (ACE_WIN32) || !defined (ACE_USES_WCHAR)
const ACE_TCHAR *cmdline_fmt = ACE_TEXT ("%s -c%s");
# else
const ACE_TCHAR *cmdline_fmt = ACE_TEXT ("%ls -c%ls");
# endif /* ACE_WIN32 || !ACE_USES_WCHAR */
ACE_Process_Options options;
options.command_line (cmdline_fmt,
argc > 0 ? argv[0] : ACE_TEXT ("Pipe_Test"),
close_pipe == 0 ? ACE_TEXT (" -d") : ACE_TEXT (""));
ACE_exitcode status = 0;
for (int i = 0; i < ::iterations; i++)
{
ACE_Process server;
if (server.spawn (options) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("spawn failed")),
-1);
}
else
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Server forked with pid = %d.\n"),
server.getpid ()));
}
// Wait for the process we just created to exit.
server.wait (&status);
// Check if child exited without error.
if (WIFEXITED (status) != 0
&& WEXITSTATUS (status) != 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Child of server %d finished with error ")
ACE_TEXT ("exit status %d\n"),
server.getpid (),
WEXITSTATUS (status)));
ACE_END_TEST;
ACE_OS::exit (WEXITSTATUS (status));
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Server %d finished\n"),
server.getpid ()));
}
ACE_END_TEST;
}
return 0;
}
int
run_main (int argc, ACE_TCHAR *argv[])
{
#if defined (ACE_LACKS_FORK)
ACE_UNUSED_ARG (argc);
ACE_UNUSED_ARG (argv);
ACE_START_TEST (ACE_TEXT ("Process_Mutex_Test"));
ACE_ERROR ((LM_INFO,
ACE_TEXT ("fork is not supported on this platform\n")));
ACE_END_TEST;
#else /* ! ACE_LACKS_FORK */
parse_args (argc, argv);
// Child process code.
if (child_process)
{
ACE_APPEND_LOG ("Process_Mutex_Test-children");
acquire_release ();
ACE_END_LOG;
}
else
{
ACE_START_TEST (ACE_TEXT ("Process_Mutex_Test"));
ACE_INIT_LOG ("Process_Mutex_Test-children");
ACE_Process_Options options;
if (release_mutex == 0)
options.command_line (ACE_TEXT (".") ACE_DIRECTORY_SEPARATOR_STR
ACE_TEXT ("Process_Mutex_Test")
ACE_PLATFORM_EXE_SUFFIX
ACE_TEXT (" -c -n %s -d"),
ACE_TEXT_CHAR_TO_TCHAR (mutex_name));
else
options.command_line (ACE_TEXT (".") ACE_DIRECTORY_SEPARATOR_STR
ACE_TEXT ("Process_Mutex_Test")
ACE_PLATFORM_EXE_SUFFIX
ACE_TEXT (" -c -n %s"),
ACE_TEXT_CHAR_TO_TCHAR (mutex_name));
// Spawn <n_processes> child processes that will contend for the
// lock.
ACE_Process children[n_processes];
size_t i;
for (i = 0;
i < n_processes;
i++)
{
// Spawn the child process.
int result = children[i].spawn (options);
ACE_ASSERT (result != -1);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Parent spawned child process with pid = %d.\n"),
children[i].getpid ()));
// Give the newly spawned child process a chance to start...
// David Levine thinks this sleep() is required because
// calling ::waitpid () before a fork'ed child has actually
// been created may be a problem on some platforms. It's
// not enough for fork() to have returned to the parent.
ACE_OS::sleep (1);
}
for (i = 0; i < n_processes; i++)
{
ACE_exitcode child_status;
// Wait for the child processes we created to exit.
ACE_ASSERT (children[i].wait (&child_status) != -1);
if (child_status == 0)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Child %d finished ok\n"),
children[i].getpid ()));
else
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Child %d finished with status %d\n"),
children[i].getpid (), child_status));
}
ACE_END_TEST;
}
#endif /* ! ACE_LACKS_FORK */
return 0;
}
