int run_main (int, ACE_TCHAR *[]) { ACE_START_TEST (ACE_TEXT ("Recursive_Condition_Test")); #if defined (ACE_HAS_THREADS) int status = 0; /* Test 1 - Simple test */ ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Test 1...\n"))); if (test_1 () != 0) ++status; /* Test #2 - Sleep 2 seconds before releasing mutex */ ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Test 2...\n"))); if (test_2 () != 0) ++status; /* Test #3 - One main thread - 4 subthreads */ ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Test 3...\n"))); if (test_3 () != 0) ++status; /* Test #4 - Multiple calls to mutex_.acquire and mutex_.release */ ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Test 4...\n"))); if (test_4 () != 0) ++status; // Timer queue usage. Thread_Timer_Queue timer_queue; Test_Handler handler; if (0 != timer_queue.activate ()) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%t) %p\n"), ACE_TEXT ("activate"))); ++status; } ACE_Time_Value timeout = ACE_OS::gettimeofday() + ACE_Time_Value (1, 0); if (-1 == timer_queue.schedule (&handler, &timer_queue, timeout)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%t) %p\n"), ACE_TEXT ("schedule"))); ++status; } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting to sleep\n"))); ACE_OS::sleep (10); timer_queue.deactivate (); timer_queue.wait (); // Scheduling every second, waiting 10 seconds, should get at least 9 int expirations = handler.nr_expirations (); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Caught %d timer expirations\n"), expirations)); if (expirations < 9) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Should have caught at least 9\n"))); #else ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE doesn't support recursive condition variables on this platform\n"))); #endif /* ACE_HAS_THREADS */ ACE_END_TEST; return 0; }
int run_main (int argc, ACE_TCHAR *argv[]) { u_short port = 0; if (argc == 1) { // This is the "master" process. ACE_START_TEST (ACE_TEXT ("MEM_Stream_Test")); create_reactor (); ACE_MEM_Addr server_addr (port); reset_handler (NUMBER_OF_REACTIVE_CONNECTIONS); test_reactive (argc > 0 ? argv[0] : ACE_TEXT ("MEM_Stream_Test"), server_addr); ACE_Reactor::instance ()->reset_reactor_event_loop (); #if !defined (ACE_WIN32) && defined (_ACE_USE_SV_SEM) ACE_ERROR ((LM_DEBUG, ACE_TEXT ("\n *** Platform only supports non-scalable SysV semaphores ***\n\n"))); #endif /* !ACE_WIN32 && _ACE_USE_SV_SEM */ reset_handler (NUMBER_OF_MT_CONNECTIONS); test_concurrent (argc > 0 ? argv[0] : ACE_TEXT ("MEM_Stream_Test"), server_addr); ACE_END_TEST; return 0; } else { // We end up here if this is a child process spawned for one of // the test passes. command line is: -p <port> -r (reactive) | // -m (multithreaded) ACE_TCHAR lognm[MAXPATHLEN]; int mypid (ACE_OS::getpid ()); ACE_OS::sprintf(lognm, ACE_TEXT ("MEM_Stream_Test-%d"), mypid); ACE_START_TEST (lognm); ACE_Get_Opt opts (argc, argv, ACE_TEXT ("p:rm")); int opt, iport, status; ACE_MEM_IO::Signal_Strategy model = ACE_MEM_IO::Reactive; while ((opt = opts()) != -1) { switch (opt) { case 'p': iport = ACE_OS::atoi (opts.opt_arg ()); port = static_cast <u_short> (iport); break; case 'r': model = ACE_MEM_IO::Reactive; break; case 'm': model = ACE_MEM_IO::MT; break; default: ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Invalid option (-p <port> -r | -m)\n")), 1); } } status = run_client (port, model); ACE_END_TEST; return status; } }
int run_main (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("XtMotifReactor_Test")); XtAppContext app_context; Widget topLevel, goodbye, PressMe, lbl, digits_rc; Widget children[5]; #if defined (HummingBird_X) HCLXmInit (); #endif /* HummingBird_X */ topLevel = XtVaAppInitialize (&app_context, "XTReactor_Test", 0, 0, &argc, argv, 0, static_cast<void *>(0)); digits_rc = create_box(topLevel, "digits_rc"); //"Stop Test" button. goodbye = XtCreateWidget ( (char *) "goodbye", BUTTON_WIDGET, digits_rc, 0, 0); set_label(goodbye, "Stop Test"); //"Press Me" button PressMe = XtCreateWidget ((char *) "PressMe", BUTTON_WIDGET, digits_rc, 0, 0); //Display for event counter lbl = XtCreateWidget ((char *) "label_for_event_one", LABEL_WIDGET, digits_rc, 0, 0); set_label(lbl, "label_for_all_events"); int ac = 0; children[ac++] = goodbye; children[ac++] = PressMe; children[ac++] = lbl; XtManageChildren (children, ac); XtManageChild (digits_rc); //Register callback for "Stop Test" button XtAddCallback (goodbye, PRESS_ME_CALLBACK, Quit, 0); //Register callback for "Press Me" button XtAddCallback (PressMe, PRESS_ME_CALLBACK, inc_count, (XtPointer) lbl); // Register callback for X Timer (void) XtAppAddTimeOut (app_context, 1000, inc_tmo, (XtPointer) lbl); XtRealizeWidget (topLevel); // It will perform X Main Loop ACE_XtReactor reactor (app_context); ACE_Reactor r (&reactor); //Event Handler for ACE Timer. EV_handler evh; ACE_Acceptor <Connection_Handler, ACE_SOCK_ACCEPTOR> acceptor; if (acceptor.open (ACE_INET_Addr ((u_short) SERV_TCP_PORT), &r) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "open"), -1); if (reactor.schedule_timer (&evh, (const void *) lbl, ACE_Time_Value (2), ACE_Time_Value (2))==-1) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) can't register with reactor\n"), -1); ACE_Thread_Manager::instance ()->spawn ((ACE_THR_FUNC) client, 0, THR_NEW_LWP | THR_DETACHED); XtAppMainLoop (XtWidgetToApplicationContext (topLevel)); ACE_END_TEST; return 0; }
int run_main (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("TP_Reactor_Test")); #if defined(ACE_HAS_THREADS) if (::parse_args (argc, argv) == -1) return -1; disable_signal (SIGPIPE, SIGPIPE); MyTask task1; Acceptor acceptor; Connector connector; if (task1.start (threads) == 0) { int rc = 0; ACE_INET_Addr addr (port); if (both != 0 || host == 0) // Acceptor rc += acceptor.start (addr); if (both != 0 || host != 0) { if (host == 0) host = ACE_LOCALHOST; if (addr.set (port, host, 1, addr.get_type ()) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), host)); rc += connector.start (addr, senders); } if (rc > 0) ACE_OS::sleep (seconds); } task1.stop (); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nNumber of Receivers objects = %d\n") ACE_TEXT ("\nNumber of Sender objects = %d\n"), acceptor.get_number_sessions (), connector.get_number_sessions ())); // As Reactor event loop now is inactive it is safe to destroy all // senders connector.stop (); acceptor.stop (); //Print statistic ACE_TCHAR bufs [256]; ACE_TCHAR bufr [256]; ACE_OS::sprintf ( bufs , ACE_TEXT ("%ld(%ld)"), connector.get_total_snd(), connector.get_total_w() ); ACE_OS::sprintf ( bufr , ACE_TEXT ("%ld(%ld)"), connector.get_total_rcv(), connector.get_total_r() ); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Connector/Senders total bytes: snd=%s rcv=%s\n"), bufs, bufr )); ACE_OS::sprintf ( bufs , ACE_TEXT ("%ld(%ld)"), acceptor.get_total_snd(), acceptor.get_total_w() ); ACE_OS::sprintf ( bufr , ACE_TEXT ("%ld(%ld)"), acceptor.get_total_rcv(), acceptor.get_total_r() ); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Acceptor/Receivers total bytes: snd=%s rcv=%s\n"), bufs, bufr )); #else /* ACE_HAS_THREADS */ ACE_UNUSED_ARG( argc ); ACE_UNUSED_ARG( argv ); #endif /* ACE_HAS_THREADS */ 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; }
int run_main (int, ACE_TCHAR *[]) { ACE_START_TEST (ACE_TEXT ("Mem_Map_Test")); #if !defined (ACE_LACKS_MMAP) #if defined (__QNXNTO__) || (defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x670)) ACE_ERROR ((LM_INFO, ACE_TEXT ("mmap on QNX Neutrino/VxWorks can map only shared memory files\n"))); #endif // = Initialize the temporary variable names ACE_TCHAR test_file[MAXPATHLEN + 1]; ACE_TCHAR temp_file1[MAXPATHLEN + 1]; ACE_TCHAR temp_file2[MAXPATHLEN + 1]; // Get the temporary directory // - 18 is for the filenames, ace_mem_map_temp_1 is the longest if (ACE::get_temp_dir (test_file, MAXPATHLEN - 18) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Temporary path too long\n")), -1); // Copy the temp directory to the other variables ACE_OS::strcpy (temp_file1, test_file); ACE_OS::strcpy (temp_file2, test_file); // Add the filenames to the end ACE_OS::strcat (test_file, ACE_TEXT ("ace_mem_map_test")); ACE_OS::strcat (temp_file1, ACE_TEXT ("ace_mem_map_temp_1")); ACE_OS::strcat (temp_file2, ACE_TEXT ("ace_mem_map_temp_2")); // First create a test file to work on if (create_test_file (test_file, LINE_LENGTH, NUM_LINES) != 0) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Create test file failed\n")), -1); ACE_Mem_Map mmap; // First memory map the test file if (mmap.map (test_file) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%n: %p %s\n%a"), ACE_TEXT ("mmap"), test_file), -1); // Now create a temporary file for intermediate processing #if defined (__QNXNTO__) || (defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x670)) ACE_Mem_Map mmap_4_open; mmap_4_open.open(temp_file1, O_RDWR | O_TRUNC | O_CREAT, ACE_DEFAULT_FILE_PERMS); ACE_HANDLE temp_file_handle = mmap_4_open.handle(); #else ACE_HANDLE temp_file_handle = ACE_OS::open (temp_file1, O_RDWR | O_TRUNC | O_CREAT, ACE_DEFAULT_FILE_PERMS); #endif if (temp_file_handle == ACE_INVALID_HANDLE) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Open failed\n")), -1); // Reverse the original file and write the output to the temporary // file. reverse_file (temp_file_handle, (char *) mmap.addr (), mmap.size ()); #if defined (__QNXNTO__) || (defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x670)) mmap_4_open.close(); #else ACE_OS::close (temp_file_handle); #endif ACE_Mem_Map temp_mmap; // Now memory map the temporary file if (temp_mmap.map (temp_file1) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%n: %p %s\n%a"), ACE_TEXT ("mmap"), temp_file1), -1); #if defined (__QNXNTO__) || (defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x670)) mmap_4_open.open(temp_file2, O_RDWR | O_TRUNC | O_CREAT, ACE_DEFAULT_FILE_PERMS); temp_file_handle = mmap_4_open.handle(); #else temp_file_handle = ACE_OS::open (temp_file2, O_RDWR | O_TRUNC | O_CREAT, ACE_DEFAULT_FILE_PERMS); #endif if ( temp_file_handle == ACE_INVALID_HANDLE) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Open failed\n")), -1); // Now reverse the temporary file and write everything to the second // temporary file. reverse_file (temp_file_handle, (char *) temp_mmap.addr (), temp_mmap.size ()); #if defined (__QNXNTO__) || (defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x670)) mmap_4_open.close(); #else ACE_OS::close (temp_file_handle); #endif // Memory map the second temporary file ACE_Mem_Map temp_mmap2; if (temp_mmap2.map (temp_file2) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%n: %p %s\n%a"), ACE_TEXT ("mmap"), temp_file2), -1); // Now do a memcmp -- the orig file and the second temporary file // should be identical. ACE_TEST_ASSERT (ACE_OS::memcmp (temp_mmap2.addr (), mmap.addr (), mmap.size ()) == 0); // Delete the test file mmap.remove (); // Delete ACE_TEMP_TEST_FILE temp_mmap.remove (); // Delete ACE_TEMP_TEST_FILE_2 temp_mmap2.remove (); #else /* !ACE_LACKS_MMAP */ ACE_ERROR ((LM_INFO, ACE_TEXT ("mmap is not supported on this platform\n"))); #endif /* !ACE_LACKS_MMAP */ ACE_END_TEST; return 0; }
int run_main (int , ACE_TCHAR *[]) { ACE_START_TEST (ACE_TEXT ("Monotonic_Task_Test")); int status = 0; # if defined (ACE_HAS_THREADS) MyTask my_task; if (my_task.start () == 0) { // shift back in time 4 sec; this would mess up timeouts if // monotonic timer was not used ACE_Time_Value tv_shift (4, 0); set_system_time (ACE_OS::gettimeofday () - tv_shift); if (my_task.put_message () == 0) { // task should now have finished dequeueing and started waiting for stop signal // wait (2sec) on thread manager should timeout // use the time policy aware gettimeofday() // method of the task to get current time ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tv (my_task.gettimeofday ()); tv += ACE_Time_Value (2, 0); // shift another 3 sec back in time; without monotonic timer support in // thread manager this would mess up the timed wait tv_shift += ACE_Time_Value (3, 0); set_system_time (ACE_OS::gettimeofday () - ACE_Time_Value (3,0)); if (my_task.thr_mgr ()->wait (&tv) == 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Thread manager did not time out\n"))); status = 1; } else { ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tv_now (my_task.gettimeofday ()); ACE_DEBUG ((LM_INFO, ACE_TEXT ("Thread manager timed out at %#T\n"), &tv_now)); } } else status = 1; // ok, now stop task if (my_task.stop () != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to stop task\n"))); status = 1; } // restore time set_system_time (ACE_OS::gettimeofday () + tv_shift); } else status = 1; # endif /* ACE_HAS_THREADS */ ACE_END_TEST; return status; }
int run_main (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("Priority_Task_Test")); if (argc <= 1) // Disable LM_DEBUG messages. ACE_Log_Msg::instance ()->priority_mask (ACE_Log_Msg::instance ()->priority_mask () &~ LM_DEBUG); else if (argc == 2) { if (ACE_OS::strcmp (argv[1], ACE_TEXT ("-d")) != 0) ACE_ERROR_RETURN ((LM_ERROR, usage, argv [0]), -1); // else -d option: don't disable LM_DEBUG messages } else ACE_ERROR_RETURN ((LM_ERROR, usage, argv [0]), -1); int status = 0; #if defined (ACE_HAS_THREADS) Priority_Task tasks[ACE_MAX_ITERATIONS]; size_t i; // Spawn off ACE_MAX_ITERATIONS of tasks, passing each one their // iteration number as their priority. // NOTE: on Solaris, for example, this requests the min FIFO // priority. But, this test doesn't use the Realtime scheduling // class. The FIFO priorities are used because they're all // nonnegative. ACE_Sched_Priority_Iterator priority (ACE_SCHED_FIFO, ACE_SCOPE_THREAD); for (i = 0; i < ACE_MAX_ITERATIONS; i++) { int p = priority.priority (); if (tasks[i].open ((void *) &p) == -1) break; // Out of enclosing loop. // If there are more priorities get the next one... if (priority.more ()) priority.next (); } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) %d tasks spawned, wait for them to exit . . .\n"), ACE_MAX_ITERATIONS)); // Wait for all tasks to exit. ACE_Thread_Manager::instance ()->wait (); for (i = 0; i < ACE_MAX_ITERATIONS; i++) if (!tasks[i].succeeded ()) { ++status; break; } #else ACE_ERROR ((LM_DEBUG, ACE_TEXT ("threads not supported on this platform\n"))); #endif /* ACE_HAS_THREADS */ // Re-enable LM_DEBUG messages. ACE_Log_Msg::instance ()->priority_mask (ACE_Log_Msg::instance ()->priority_mask () | LM_DEBUG); ACE_END_TEST; return status; }
int // This has been unconditionally turned on for the time being since I can't // figure out an easy way to enable it and still keep ACE_TMAIN in a seperate // cpp. #if 1 || defined (ACE_HAS_NONSTATIC_OBJECT_MANAGER) || defined (ACE_LACKS_FORK) // ACE_HAS_NONSTATIC_OBJECT_MANAGER only allows main to have two // arguments. And on platforms that lack fork (), we can't use spawn. run_main (int, ACE_TCHAR* []) { // Only Win32 can set wide-char environment strings. So, for all // others, use char string literals regardless of ACE_USES_WCHAR. # if defined (ACE_WIN32) ACE_OS::putenv (ACE_TEXT ("TEST_VALUE_POSITIVE=10.2")); ACE_OS::putenv (ACE_TEXT ("TEST_VALUE_NEGATIVE=-10.2")); # else ACE_OS::putenv ("TEST_VALUE_POSITIVE=10.2"); ACE_OS::putenv ("TEST_VALUE_NEGATIVE=-10.2"); # endif /* ACE_WIN32 */ #else /* ! ACE_HAS_NONSTATIC_OBJECT_MANAGER && ! ACE_LACKS_FORK */ run_main (int argc, ACE_TCHAR * [], ACE_TCHAR *envp[]) { if (argc == 1) { int status; // No arguments means we're the initial test. ACE_Process_Options options (1); status = options.setenv (envp); if (status != 0) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("setenv(envp)"))); options.command_line (ACE_TEXT (".") ACE_DIRECTORY_SEPARATOR_STR ACE_TEXT ("Env_Value_Test run_as_test")); status = options.setenv (ACE_TEXT ("TEST_VALUE_POSITIVE"), ACE_TEXT ("%s"), ACE_TEXT ("10.2")); if (status != 0) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("setenv(TEST_VALUE_POSITIVE)"))); status = options.setenv (ACE_TEXT ("TEST_VALUE_NEGATIVE"), ACE_TEXT ("%s"), ACE_TEXT ("-10.2")); if (status != 0) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("setenv(TEST_VALUE_NEGATIVE)"))); ACE_Process p; pid_t result = p.spawn (options); if (result == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("spawn"))); else p.wait (); } else #endif /* ! ACE_HAS_NONSTATIC_OBJECT_MANAGER && ! ACE_LACKS_FORK */ { // In this case we're the child ACE_START_TEST (ACE_TEXT ("Env_Value_Test")); TEST_THIS (int, ACE_TEXT ("TEST_VALUE_POSITIVE"), 4, 10); TEST_THIS (double, ACE_TEXT ("TEST_VALUE_POSITIVE"), -1.0, 10.2); TEST_THIS (long, ACE_TEXT ("TEST_VALUE_POSITIVE"), 0, 10); TEST_THIS (unsigned long, ACE_TEXT ("TEST_VALUE_POSITIVE"), 0, 10); TEST_THIS (short, ACE_TEXT ("TEST_VALUE_POSITIVE"), 0, 10); TEST_THIS (unsigned short, ACE_TEXT ("TEST_VALUE_POSITIVE"), 0, 10); TEST_THIS (int, ACE_TEXT ("TEST_VALUE_NEGATIVE"), 4, -10); TEST_THIS (double, ACE_TEXT ("TEST_VALUE_NEGATIVE"), -1.0, -10.2); TEST_THIS (long, ACE_TEXT ("TEST_VALUE_NEGATIVE"), 0, -10L); TEST_THIS (unsigned long, ACE_TEXT ("TEST_VALUE_NEGATIVE"), 0, (unsigned long) -10); TEST_THIS (short, ACE_TEXT ("TEST_VALUE_NEGATIVE"), 0, -10); TEST_THIS (unsigned short, ACE_TEXT ("TEST_VALUE_NEGATIVE"), 0, (unsigned short) -10); const ACE_TCHAR *defstr = ACE_TEXT ("Sarah Cleeland is Two!"); ACE_Env_Value<const ACE_TCHAR *> sval (ACE_TEXT ("This_Shouldnt_Be_Set_Hopefully"), defstr); if (ACE_OS::strcmp (sval, defstr) != 0) ACE_ERROR ((LM_ERROR, ACE_TEXT ("Mismatch: %s should be %s\n"), (const ACE_TCHAR *)sval, defstr)); ACE_END_TEST; } return 0; }
int run_main (int, ACE_TCHAR *[]) { ACE_START_TEST (ACE_TEXT ("Bug_2912_Regression_Test")); // SSL_CTX_set_cipher_list, etc. init_ssl (); // Keep RT signals on POSIX from killing us. disable_signal (ACE_SIGRTMIN, ACE_SIGRTMAX); int ret = 0; Client_Service_Handler client_handler; Server_Service_Handler server_handler; ACE_Time_Value wait_time (10, 0); // Client and Server will utilize different proactors since this test // depends on SSL thread error state behavior. CLIENT_PROACTOR_TASK->activate (); SERVER_PROACTOR_TASK->activate (); // Open server acceptor and client connector if (0 == ret) { ret = ACCEPTOR->open ( ACE_INET_Addr (ACE_DEFAULT_SERVER_PORT), 0, 0, ACE_DEFAULT_ASYNCH_BACKLOG, 1, SERVER_PROACTOR, 1); if (-1 == ret) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ( "ACE_Asynch_Acceptor::open failed, %d\n"), (int)errno)); } } if (0 == ret) { ret = CONNECTOR->open (0, CLIENT_PROACTOR, 1); if (-1 == ret) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ( "ACE_Asynch_Connector::open failed, %d\n"), (int)errno)); } } // Supply server_handler and client_handler to acceptor and connector and // connect client to the server. if (0 == ret) { ACCEPTOR->prepare_for_connection (&server_handler); CONNECTOR->prepare_for_connection (&client_handler); ret = CONNECTOR->connect ( ACE_INET_Addr (ACE_DEFAULT_SERVER_PORT, ACE_LOCALHOST)); if (-1 == ret) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ( "ACE_Asynch_Connector::connect failed, %d\n"), (int)errno)); } } if (0 == ret) { ret = client_handler.wait_for_external_write_queue (&wait_time); if (-1 == ret) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ( "Timed out waiting for client's write readiness\n"))); } } // Client sends data to server if (0 == ret) { ret = client_handler.write_data (); } // Client waits for echo reply from server if (0 == ret) { ret = client_handler.wait_for_read_completed (&wait_time); if (-1 == ret) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ( "Timed out waiting for client's read to complete\n"))); } } if (0 == ret) { if (client_handler.read_successful () == 1) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Success\n"))); ret = 0; } else { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Client's read failed\n"))); ret = -1; } } // Cleanup and shutdown ACCEPTOR->cancel (); while (!ACCEPTOR->safe_to_delete ()) ACE_OS::sleep (ACE_Time_Value (0, 500000)); CONNECTOR->cancel (); while (!CONNECTOR->safe_to_delete ()) ACE_OS::sleep (ACE_Time_Value (0, 500000)); client_handler.cancel_and_close (); while (!client_handler.safe_to_delete ()) ACE_OS::sleep (ACE_Time_Value (0, 500000)); server_handler.cancel_and_close (); while (!server_handler.safe_to_delete ()) ACE_OS::sleep (ACE_Time_Value (0, 500000)); CLIENT_PROACTOR->proactor_end_event_loop (); CLIENT_PROACTOR_TASK->wait (); SERVER_PROACTOR->proactor_end_event_loop (); SERVER_PROACTOR_TASK->wait (); ACE_END_TEST; return 0; }
int run_main (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("Max_Default_Port_Test_IPV6")); ACE_UNUSED_ARG (argc); ACE_UNUSED_ARG (argv); #if defined (ACE_HAS_IPV6) u_short max_listened_port = 0; //Ports beyond 65279 were said to bad on NT sp 3. for (u_short idx = USHRT_MAX; idx != USHRT_MAX - 300; --idx) { ACE_INET_Addr addr (idx, "::"); My_Accept_Handler *eh = new My_Accept_Handler (addr); if ( ACE_Reactor::instance()->register_handler ( eh, ACE_Event_Handler::ACCEPT_MASK) == -1) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("Failed to register event handler")), 1); } ACE_DEBUG ((LM_DEBUG, "Registered event handler at %d\n", idx)); ACE_Time_Value tv (1); #if defined (ACE_HAS_THREADS) if (ACE_Thread_Manager::instance ()->spawn_n (1, ACE_THR_FUNC (client), reinterpret_cast<void *> (&addr), THR_NEW_LWP | THR_DETACHED) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("(%P|%t) %p\n"), ACE_TEXT ("thread create failed")), 1); ACE_Thread_Manager::instance ()->wait (); #else ACE_UNUSED_ARG (client); ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) only one thread may be run in a process on this platform\n%a"), 1)); #endif //ACE_HAS_THREADS if (ACE_Reactor::instance()->handle_events (tv) == -1 ) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("Reactor::handle_events")), 1); } // see if I can register a reactor at this port. if (eh->port () == idx) { if (idx > max_listened_port) max_listened_port = idx; } else { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Test Fail, listening port %d\n"), eh->port()), 1); } ACE_Reactor::instance()->remove_handler ( eh, ACE_Event_Handler::ACCEPT_MASK | ACE_Event_Handler::DONT_CALL); delete eh; } ACE_DEBUG ((LM_DEBUG, "Value of ACE_MAX_DEFAULT_PORT %d\n", ACE_MAX_DEFAULT_PORT)); ACE_DEBUG ((LM_DEBUG, "Highest port value I can listen at %d\n", max_listened_port)); ACE_DEBUG ((LM_DEBUG, "Highest port value I can connect to %d\n", max_connected_port)); if ((max_listened_port == ACE_MAX_DEFAULT_PORT) && (max_connected_port == ACE_MAX_DEFAULT_PORT)) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Valid ACE_MAX_DEFAULT_PORT value: %d\n"), max_listened_port)); } else { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Invalid ACE_MAX_DEFAULT_PORT ") ACE_TEXT ("or %d port may be busy; got to %d\n"), ACE_MAX_DEFAULT_PORT, max_listened_port)); } #endif /* ACE_HAS_IPV6 */ ACE_END_TEST; return 0; }
int run_main (int, ACE_TCHAR *[]) { ACE_START_TEST (ACE_TEXT ("INET_Addr_Test")); int status = 0; // Innocent until proven guilty // Try to set up known IP and port. u_short port (80); ACE_UINT32 const ia_any = INADDR_ANY; ACE_INET_Addr local_addr(port, ia_any); status |= check_type_consistency (local_addr); if (local_addr.get_port_number () != 80) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Got port %d, expecting 80\n"), (int)(local_addr.get_port_number ()))); status = 1; } if (local_addr.get_ip_address () != ia_any) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Mismatch on local IP addr\n"))); status = 1; } // Assignment constructor ACE_INET_Addr local_addr2 (local_addr); status |= check_type_consistency (local_addr2); if (local_addr2.get_port_number () != 80) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Copy got port %d, expecting 80\n"), (int)(local_addr2.get_port_number ()))); status = 1; } if (local_addr2.get_ip_address () != ia_any) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Mismatch on copy local IP addr\n"))); status = 1; } if (local_addr != local_addr2) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Copy local addr mismatch\n"))); status = 1; } // Try to parse out a simple address:port string. Intentionally reuse // the ACE_INET_Addr to ensure resetting an address works. const char *addr_ports[] = { "127.0.0.1:80", "www.dre.vanderbilt.edu:80", 0 }; ACE_INET_Addr addr_port; for (int i = 0; addr_ports[i] != 0; ++i) { if (addr_port.set (addr_ports[i]) == 0) { status |= check_type_consistency (addr_port); if (addr_port.get_port_number () != 80) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Got port %d from %s\n"), (int)(addr_port.get_port_number ()), addr_ports[i])); status = 1; } ACE_INET_Addr check (addr_ports[i]); if (addr_port != check) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Reset on iter %d failed\n"), i)); status = 1; } } else { // Sometimes this fails because the run-time host lacks the capability to // resolve a name. But it shouldn't fail on the first one, 127.0.0.1. if (i == 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%C: %p\n"), addr_ports[i], ACE_TEXT ("lookup"))); status = 1; } else { ACE_ERROR ((LM_WARNING, ACE_TEXT ("%C: %p\n"), addr_ports[i], ACE_TEXT ("lookup"))); } } } const char *ipv4_addresses[] = { "127.0.0.1", "138.38.180.251", "64.219.54.121", "192.0.0.1", "10.0.0.1", 0 }; ACE_INET_Addr addr; status |= check_type_consistency (addr); char hostaddr[1024]; for (int i=0; ipv4_addresses[i] != 0; i++) { struct in_addr addrv4; ACE_OS::memset ((void *) &addrv4, 0, sizeof addrv4); ACE_UINT32 addr32; ACE_OS::inet_pton (AF_INET, ipv4_addresses[i], &addrv4); ACE_OS::memcpy (&addr32, &addrv4, sizeof (addr32)); status |= !(addr.set (80, ipv4_addresses[i]) == 0); status |= check_type_consistency (addr); /* ** Now check to make sure get_ip_address matches and get_host_addr ** matches. */ if (addr.get_ip_address () != ACE_HTONL (addr32)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error: %C failed get_ip_address() check\n") ACE_TEXT ("0x%x != 0x%x\n"), ipv4_addresses[i], addr.get_ip_address (), ACE_HTONL (addr32))); status = 1; } if (addr.get_host_addr () != 0 && ACE_OS::strcmp (addr.get_host_addr(), ipv4_addresses[i]) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%C failed get_host_addr() check\n") ACE_TEXT ("%C != %C\n"), ipv4_addresses[i], addr.get_host_addr (), ipv4_addresses[i])); status = 1; } // Now we check the operation of get_host_addr(char*,int) const char* haddr = addr.get_host_addr (&hostaddr[0], sizeof(hostaddr)); if (haddr != 0 && ACE_OS::strcmp (&hostaddr[0], haddr) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%C failed get_host_addr(char* buf,int) check\n") ACE_TEXT ("buf ['%C'] != return value ['%C']\n"), ipv4_addresses[i], &hostaddr[0], haddr)); status = 1; } if (ACE_OS::strcmp (&hostaddr[0], ipv4_addresses[i]) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%C failed get_host_addr(char*,int) check\n") ACE_TEXT ("buf ['%C'] != expected value ['%C']\n"), ipv4_addresses[i], &hostaddr[0], ipv4_addresses[i])); status = 1; } // Clear out the address by setting it to 1 and check addr.set (0, ACE_UINT32 (1), 1); status |= check_type_consistency (addr); if (addr.get_ip_address () != 1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to set address to 1\n"))); status = 1; } // Now set the address using a 32 bit number and check that we get // the right string out of get_host_addr(). addr.set (80, addr32, 0); // addr32 is already in network byte order status |= check_type_consistency(addr); if (addr.get_host_addr () != 0 && ACE_OS::strcmp (addr.get_host_addr (), ipv4_addresses[i]) != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("%C failed second get_host_addr() check\n") ACE_TEXT ("return value ['%C'] != expected value ['%C']\n"), ipv4_addresses[i], addr.get_host_addr (), ipv4_addresses[i])); status = 1; } // Test for ACE_INET_Addr::set_addr(). struct sockaddr_in sa4; sa4.sin_family = AF_INET; sa4.sin_addr = addrv4; sa4.sin_port = ACE_HTONS (8080); addr.set (0, ACE_UINT32 (1), 1); addr.set_addr (&sa4, sizeof(sa4)); status |= check_type_consistency (addr); if (addr.get_port_number () != 8080) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::set_addr() ") ACE_TEXT ("failed to update port number.\n"))); status = 1; } if (addr.get_ip_address () != ACE_HTONL (addr32)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::set_addr() ") ACE_TEXT ("failed to update address.\n"))); status = 1; } } #if defined (ACE_HAS_IPV6) if (ACE::ipv6_enabled ()) { const char *ipv6_addresses[] = { "1080::8:800:200c:417a", // unicast address "ff01::101", // multicast address "::1", // loopback address "::", // unspecified addresses 0 }; for (int i=0; ipv6_addresses[i] != 0; i++) { ACE_INET_Addr addr (80, ipv6_addresses[i]); status |= check_type_consistency (addr); if (0 != ACE_OS::strcmp (addr.get_host_addr (), ipv6_addresses[i])) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("IPv6 get_host_addr failed: %C != %C\n"), addr.get_host_addr (), ipv6_addresses[i])); status = 1; } } const char *ipv6_names[] = { "naboo.dre.vanderbilt.edu", "v6.ipv6-test.com", 0 }; for (int i=0; ipv6_names[i] != 0; i++) { ACE_INET_Addr addr (80, ipv6_names[i]); status |= check_type_consistency (addr); if (0 != ACE_OS::strcmp (addr.get_host_name (), ipv6_names[i])) { // Alias? Check lookup on the reverse. ACE_INET_Addr alias_check; if (alias_check.set (80, addr.get_host_name ()) == 0) { if (addr != alias_check) ACE_ERROR ((LM_WARNING, ACE_TEXT ("IPv6 name mismatch: %s (%s) != %s\n"), addr.get_host_name (), addr.get_host_addr (), ipv6_names[i])); } else { ACE_ERROR ((LM_WARNING, ACE_TEXT ("IPv6 reverse lookup mismatch: %s (%s) != %s\n"), addr.get_host_name (), addr.get_host_addr (), ipv6_names[i])); } } } } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("IPv6 tests done\n"))); #else ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_HAS_IPV6 not set; no IPv6 tests run\n"))); #endif struct Address loopback_addresses[] = { {"127.0.0.1", true}, {"127.1.2.3", true} , {"127.0.0.0", true}, {"127.255.255.255", true} , {"126.255.255.255", false}, {"128.0.0.0", false}, {0, true} }; for (int i=0; loopback_addresses[i].name != 0; i++) { struct in_addr addrv4; ACE_UINT32 addr32 = 0; ACE_OS::inet_pton (AF_INET, loopback_addresses[i].name, &addrv4); ACE_OS::memcpy (&addr32, &addrv4, sizeof (addr32)); addr.set (80, loopback_addresses[i].name); if (addr.is_loopback() != loopback_addresses[i].loopback) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::is_loopback() ") ACE_TEXT ("failed to distinguish loopback address. %C\n") , loopback_addresses[i].name)); status = 1; } } if (addr.string_to_addr ("127.0.0.1:72000", AF_INET) != -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_INET_Addr::string_to_addr() ") ACE_TEXT ("failed to detect port number overflow\n"))); status = 1; } if (!test_tao_use ()) status = 1; if (!test_multiple ()) status = 1; if (!test_port_assignment ()) status = 1; ACE_INET_Addr a1 (80, "127.0.0.1"); ACE_INET_Addr a2 = a1; if (a1 != a2) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Address equality check failed after assignment\n"))); status = 1; } ACE_END_TEST; return status; }
int run_main (int argc, ACE_TCHAR *argv[]) { int retval = 0; MCT_Config config; retval = config.open (argc, argv); if (retval != 0) return 1; const ACE_TCHAR *temp = ACE_TEXT ("Multicast_Test"); ACE_TString test = temp; u_long role = config.role (); if (ACE_BIT_DISABLED (role, MCT_Config::PRODUCER) || ACE_BIT_DISABLED (role, MCT_Config::CONSUMER)) { if (ACE_BIT_ENABLED (role, MCT_Config::PRODUCER)) test += ACE_TEXT ("-PRODUCER"); else test += ACE_TEXT ("-CONSUMER"); } // Start test only if options are valid. ACE_START_TEST (test.c_str ()); // Register a signal handler to close down application gracefully. ACE_Sig_Action sa ((ACE_SignalHandler) handler, SIGINT); // Dump the configuration info to the log if caller passed debug option. if (config.debug ()) config.dump (); ACE_Reactor *reactor = ACE_Reactor::instance (); MCT_Task *task = new MCT_Task (config, reactor); if (ACE_BIT_ENABLED (role, MCT_Config::CONSUMER)) { ACE_DEBUG ((LM_INFO, ACE_TEXT ("Starting consumer...\n"))); // Open makes it an active object. retval += task->open (); } // now produce the datagrams... if (ACE_BIT_ENABLED (role, MCT_Config::PRODUCER)) retval += producer (config); if (ACE_BIT_ENABLED (role, MCT_Config::CONSUMER)) { // and wait for everything to finish ACE_DEBUG ((LM_INFO, ACE_TEXT ("start waiting for consumer to finish...\n"))); // Wait for the threads to exit. // But, wait for a limited time since we could hang if the last udp // message isn't received. ACE_Time_Value max_wait ( config.wait ()/* seconds */); ACE_Time_Value wait_time (ACE_OS::gettimeofday () + max_wait); ACE_Time_Value *ptime = ACE_BIT_ENABLED (role, MCT_Config::PRODUCER) ? &wait_time : 0; if (ACE_Thread_Manager::instance ()->wait (ptime) == -1) { // We will no longer wait for this thread, so we must // force it to exit otherwise the thread will be referencing // deleted memory. finished = 1; reactor->end_reactor_event_loop (); if (errno == ETIME) ACE_ERROR ((LM_ERROR, ACE_TEXT ("maximum wait time of %d msec exceeded\n"), max_wait.msec ())); else ACE_OS::perror (ACE_TEXT ("wait")); ++error; // This should exit now that we ended the reactor loop. task->wait (); } } delete task; ACE_END_TEST; return (retval == 0 && error == 0) ? 0 : 1; }
int run_main (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("Svc_Handler_Test")); { size_t max_buffer_size = BUFSIZ; size_t iterations = 10; if (argc > 1) max_buffer_size = ACE_OS::atoi (argv[1]); if (argc > 2) iterations = ACE_OS::atoi (argv[2]); ACE_FILE_Connector connector; ACE_FILE_IO file_io; // Create a temporary filename. ACE_FILE_Addr file (ACE_sap_any_cast (ACE_FILE_Addr &)); // Open up the temp file. if (connector.connect (file_io, file) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("connect failed for %p\n"), file.get_path_name ()), 1); #if (!defined (ACE_WIN32) \ || (defined (ACE_HAS_WINNT4) && ACE_HAS_WINNT4 == 1)) && \ !defined (VXWORKS) # define TEST_CAN_UNLINK_IN_ADVANCE #endif // Create the service handler and assign it <file_io> as its data // sink. SVC_HANDLER svc_handler (0, 0, 0, max_buffer_size, 0); svc_handler.peer () = file_io; // Run the test. run_test (svc_handler, iterations); file_io.close (); // Open up the temp file. if (connector.connect (file_io, file) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("connect failed for %p\n"), file.get_path_name ()), 1); char buf[ACE_MAXLOGMSGLEN + 1]; ACE_LOG_MSG->clr_flags (ACE_Log_Msg::VERBOSE_LITE); ACE_FILE_Info info; file_io.get_info (info); ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT("file size = %d\n"), info.size_)); for (ssize_t n_bytes; (n_bytes = file_io.recv (buf, ACE_MAXLOGMSGLEN)) > 0; ) { buf[n_bytes] = '\0'; ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT("%s"), ACE_TEXT_CHAR_TO_TCHAR(buf))); } ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT("\n"))); file_io.close (); if (file_io.unlink () == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("unlink failed for %p\n"), file.get_path_name ()), 1); } ACE_END_TEST; return 0; }
int run_main (int, ACE_TCHAR *[]) { ACE_START_TEST (ACE_TEXT ("Bug_3541_Regression_Test")); int ret = 0; #if defined(ACE_WIN32) && !defined (ACE_USES_WINCE_SEMA_SIMULATION) int lastError; // ACE_OS::event_init() const ACE_TCHAR *eventName = ACE_TEXT ("Bug3541_Event"); ACE_Event event0(0, // int manual_reset = 0 0, // int initial_state = 0 USYNC_PROCESS, // int type = USYNC_THREAD eventName); // const ACE_TCHAR *name = 0 lastError = ACE_OS::last_error(); ACE_event_t eventHandle = event0.handle(); if ((eventHandle == ACE_INVALID_HANDLE) || (lastError != 0)) { ret = -1; ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_Event(%s) failed - handle %d lastError %d\n"), eventName, eventHandle, lastError)); } else { ACE_Event event1(0, // int manual_reset = 0 0, // int initial_state = 0 USYNC_PROCESS, // int type = USYNC_THREAD eventName); // const ACE_TCHAR *name = 0 lastError = ACE_OS::last_error(); eventHandle = event1.handle(); if ((eventHandle == ACE_INVALID_HANDLE) || (lastError != ERROR_ALREADY_EXISTS)) { ret = -1; ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_Event(%s) failed - handle %d lastError %d\n"), eventName, eventHandle, lastError)); } } // ACE_OS::sema_init const ACE_TCHAR *semaphoreName = ACE_TEXT ("Bug3541_Semaphore"); ACE_Semaphore semaphore0(1, // int count = 1 USYNC_PROCESS, // int type = USYNC_THREAD semaphoreName); // const ACE_TCHAR *name = 0 lastError = ACE_OS::last_error(); const ACE_sema_t &semaphoreLock = semaphore0.lock(); if ((semaphoreLock == ACE_INVALID_HANDLE) || (lastError != 0)) { ret = -1; ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_Semaphore(%s) failed - lock %d lastError %d\n"), semaphoreName, semaphoreLock, lastError)); } else { ACE_Semaphore semaphore1(1, // int count = 1 USYNC_PROCESS, // int type = USYNC_THREAD semaphoreName); // const ACE_TCHAR *name = 0 lastError = ACE_OS::last_error(); const ACE_sema_t &semaphoreLock = semaphore1.lock(); if ((semaphoreLock == ACE_INVALID_HANDLE) || (lastError != ERROR_ALREADY_EXISTS)) { ret = -1; ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_Semaphore(%s) failed - lock %d lastError %d\n"), semaphoreName, semaphoreLock, lastError)); } } // ACE_OS::mutex_init() const ACE_TCHAR *mutexName = ACE_TEXT ("Bug3541_Mutex"); ACE_Mutex mutex0(USYNC_PROCESS, // int type = USYNC_THREAD mutexName); // const ACE_TCHAR *name = 0 lastError = ACE_OS::last_error(); const ACE_mutex_t &mutexLock = mutex0.lock(); if ((mutexLock.proc_mutex_ == ACE_INVALID_HANDLE) || (lastError != 0)) { ret = -1; ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_Mutex(%s) failed - lock %d lastError %d\n"), mutexName, mutexLock, lastError)); } else { ACE_Mutex mutex1(USYNC_PROCESS, // int type = USYNC_THREAD mutexName); // const ACE_TCHAR *name = 0 lastError = ACE_OS::last_error(); const ACE_mutex_t &mutexLock = mutex1.lock(); if ((mutexLock.proc_mutex_ == ACE_INVALID_HANDLE) || (lastError != ERROR_ALREADY_EXISTS)) { ret = -1; ACE_ERROR ((LM_ERROR, ACE_TEXT ("ACE_Mutex(%s) failed - lock %d lastError %d\n"), mutexName, mutexLock, lastError)); } } #endif ACE_END_TEST; return ret; }
int run_main (int argc, ACE_TCHAR *argv[]) { int c = 0; int handle_inherit = 0; /* Disable inheritance by default */ bool ischild = false; ACE_TString temp_file_name; ACE_Get_Opt getopt (argc, argv, ACE_TEXT ("ch:f:")); while ((c = getopt ()) != -1) switch ((char) c) { case 'c': ischild = true; break; case 'h': handle_inherit = ACE_OS::atoi (getopt.opt_arg ()); break; case 'f': temp_file_name = getopt.opt_arg (); break; default: // Don't forgive bad options ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Bad option\n")), -1); break; } if (ischild) { ACE_TCHAR lognm[MAXPATHLEN]; int const mypid (ACE_OS::getpid ()); ACE_OS::sprintf(lognm, ACE_TEXT ("Process_Test-child-%d"), mypid); ACE_START_TEST (lognm); int result = check_temp_file (temp_file_name); // Check descriptor inheritance if (result == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Could not retrieve open files\n")), -1); else if (result == handle_inherit) result = 0; else ACE_ERROR ((LM_ERROR, ACE_TEXT ("Handle inheritance test failed with ") ACE_TEXT ("%d, expected %d\n"), result, handle_inherit)); ACE_END_LOG; return result; } else { ACE_START_TEST (ACE_TEXT ("Process_Test")); int status = test_setenv (); // The rest of this test relies on the ability to get a list of open // files for a process and examine each file descriptor to see which // file is open, matching against an expected opened file name. // Although most systems provide some mechanism to do this, the code // in this test uses Linux-specific techniques. Thus, although it // is possible to add the code for the checks on, for example, // HP-UX (pstat_getproc, pstat_getpathname) and // AIX (/proc is available, but there's no self and the fds are not links // to the opened file names), the code isn't here at present. #if defined (ACE_LACKS_FORK) || defined (ACE_LACKS_READLINK) || !defined(ACE_LINUX) ACE_ERROR ((LM_INFO, ACE_TEXT ("The remainder of this test is not supported on this platform\n"))); #else // Test handle inheritance set to true if (!status) status = run_parent (true); // ... and set to false if (!status) run_parent (false); #endif /* ! ACE_LACKS_FORK */ ACE_END_TEST; return status; } }
int run_main (int argc, ACE_TCHAR *argv[]) { // Validate options. int result = parse_args (argc, argv); if (result != 0) return result; // Start the test only if options are valid. ACE_START_TEST (ACE_TEXT ("Cache_Map_Manager_Test")); // Remove the extra debugging attributes from Log_Msg output. ACE_LOG_MSG->clr_flags (ACE_Log_Msg::VERBOSE_LITE); // Providing random a unique seed. ACE_OS::srand (static_cast<u_int> (ACE_OS::time (0))); // Create the lookup array. ACE_NEW_RETURN (lookup_array, KEY[no_of_lookups], -1); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nLookup sequence: "))); // Initialize the lookup array. for (size_t k = 0; k < no_of_lookups; ++k) { if (randomize_lookups != 0) lookup_array[k] = ACE_OS::rand () % iterations; else lookup_array[k] = k % iterations; ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%d "), lookup_array[k])); } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n\n"))); // Do we need to test all the strategies. if (caching_strategy_type == ACE_ALL) { caching_strategy_type = ACE_NULL; test_caching_strategy_type (); caching_strategy_type = ACE_LRU; test_caching_strategy_type (); caching_strategy_type = ACE_LFU; test_caching_strategy_type (); caching_strategy_type = ACE_FIFO; test_caching_strategy_type (); } else { test_caching_strategy_type (); } delete[] lookup_array; ACE_LOG_MSG->set_flags (ACE_Log_Msg::VERBOSE_LITE); ACE_END_TEST; return 0; }