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; }