From 0cfc57efce5ab8e59fc9a88028dbd12fa3b72085 Mon Sep 17 00:00:00 2001 From: Steve Huston Date: Thu, 22 Mar 2007 18:26:23 +0000 Subject: ChangeLogTag:Thu Mar 22 18:25:01 UTC 2007 Steve Huston --- ACE/ChangeLog | 37 ++++ ACE/ace/Log_Msg.cpp | 4 +- ACE/ace/Log_Msg.h | 2 +- ACE/ace/Log_Msg_Backend.h | 47 +++-- ACE/ace/Log_Msg_IPC.h | 8 + ACE/ace/Message_Queue_T.cpp | 5 +- ACE/ace/Message_Queue_T.h | 353 +++++++++++++++++++-------------- ACE/ace/OS_NS_Thread.inl | 22 +- ACE/tests/Auto_Event_Test.cpp | 47 +++-- ACE/tests/Bug_1890_Regression_Test.cpp | 167 ++++++++++------ ACE/tests/Makefile.am | 21 ++ ACE/tests/Message_Queue_Test_Ex.cpp | 101 ++++++++++ ACE/tests/Message_Queue_Test_Ex.h | 5 + ACE/tests/Semaphore_Test.cpp | 46 +++-- ACE/tests/run_test.lst | 1 + ACE/tests/tests.mpc | 8 + 16 files changed, 612 insertions(+), 262 deletions(-) diff --git a/ACE/ChangeLog b/ACE/ChangeLog index 839383d1d49..e34e07e960a 100644 --- a/ACE/ChangeLog +++ b/ACE/ChangeLog @@ -1,3 +1,40 @@ +Thu Mar 22 18:25:01 UTC 2007 Steve Huston + + * ace/Log_Msg.{h cpp}: Corrected comments describing the format for + %D timestamp. Thanks to Stefan Naewe for reporting this. + + * ace/OS_NS_Thread.inl (thread_mutex_init): On Windows, guard against + InitializeCriticalSection throwing an out-of-memory exception. Thanks + to Aleksandar Vukajlovic for this. + + * ace/Log_Msg_Backend.h: Doxygenized and expanded comments. + * ace/Log_Msg_IPC.h: Moved some comments re reset() from + Log_Msg_Backend to here because they discuss resetting the IPC. + + * ace/Message_Queue_T.{h cpp}: Added an optional 'priority' argument + to ACE_Message_Queue_Ex::enqueue_prio. There was previously no way + to specify a priority for queueing; now there is. The priority + defaults to 0 (lowest priority). + Also fixed up the Doxygen stuff for ACE_Message_Queue_Ex. + + * tests/Message_Queue_Test_Ex.{h cpp}: + Added a test for priority queueing. + + * tests/Log_Msg_Backend_Test.cpp: New test to illustrate how to set + up a custom logging backend and test the hooks are called properly. + + * tests/tests.mpc: + * tests/Makefile.am: + * tests/run_test.lst: Added Log_Msg_Backend_Test. + + * tests/Auto_Event_Test.cpp: + * tests/Semaphore_Test.cpp: Replace ACE_ASSERTS with if/ACE_ERROR to + 1) make sure it runs in Release mode, 2) not wipe out embedded + systems on failures, 3) record something useful in the log. Also, + changed error notices to LM_ERROR. When logging msecs (unsigned + long) cast it to int; ACE_Log_Msg doesn't have the 'l' modifier and + without it %d and long is a mismatch. + Thu Mar 22 16:29:16 UTC 2007 William R. Otte * bin/MakeProjectCreator/modules/GNUAutobuildProjectCreator.pm diff --git a/ACE/ace/Log_Msg.cpp b/ACE/ace/Log_Msg.cpp index 72cdb2ac399..ec8573de669 100644 --- a/ACE/ace/Log_Msg.cpp +++ b/ACE/ace/Log_Msg.cpp @@ -1560,8 +1560,8 @@ ACE_Log_Msg::log (const ACE_TCHAR *format_str, break; } - case 'D': // Format the timestamp in month/day/year - // hour:minute:sec:usec format. + case 'D': // Format the timestamp in format: + // Weekday Month day year hour:minute:sec.usec { ACE_TCHAR day_and_time[35]; ACE::timestamp (day_and_time, diff --git a/ACE/ace/Log_Msg.h b/ACE/ace/Log_Msg.h index 5bc62f1e097..818af15861d 100644 --- a/ACE/ace/Log_Msg.h +++ b/ACE/ace/Log_Msg.h @@ -499,7 +499,7 @@ public: * to var-argument. * - 's': print out a character string * - 'T': print timestamp in hour:minute:sec:usec format. - * - 'D': print timestamp in month/day/year hour:minute:sec:usec format. + * - 'D': print timestamp as Weekday Month day year hour:minute:sec.usec * - 't': print thread id (1 if single-threaded) * - 'u': print as unsigned int * - 'w': prints a wide character diff --git a/ACE/ace/Log_Msg_Backend.h b/ACE/ace/Log_Msg_Backend.h index 58e6089d8af..e4f50da0fc5 100644 --- a/ACE/ace/Log_Msg_Backend.h +++ b/ACE/ace/Log_Msg_Backend.h @@ -30,13 +30,13 @@ class ACE_Log_Record; /** * @class ACE_Log_Msg_Backend * - * @brief Define the interface for ACE_Log_Msg backend strategies. + * @brief Defines the interface for ACE_Log_Msg back end processing. * - * The ACE_Log_Msg class can log to multiple backend strategies, for - * example, some send messages to a remote logger, others dump to a - * file, or simply to stderr. In the future we could define - * interfaces that log to the syslog daemon (on UNIX), the Event log - * (on NT) a temporary ring buffer, etc. + * The ACE_Log_Msg class uses ACE_Log_Msg_Backend as the target interface + * for back end log record procesing. In addition to the classes ACE + * derives from this (ACE_Log_Msg_NT_Event_Log, ACE_Log_Msg_UNIX_Syslog, and + * ACE_Log_Msg_IPC) users can derive classes from ACE_Log_Msg_Backend for + * use as a custom logger back end. */ class ACE_Export ACE_Log_Msg_Backend { @@ -44,23 +44,40 @@ public: /// No-op virtual destructor. virtual ~ACE_Log_Msg_Backend (void); - /// Open a new connection + /** + * Open the back end object. Perform any actions needed to prepare + * the object for later logging operations. + * + * @param logger_key The character string passed to ACE_Log_Msg::open(). + * If the @c LOGGER logging destination is not being + * used, any string can be passed through to the back end. + * + * @retval 0 for success; -1 for failure. + */ virtual int open (const ACE_TCHAR *logger_key) = 0; - /* - * Reset the backend. When changing the logging destination the - * backend may need to properly disconnect from the remote logging - * daemon and reclaim some local resources. But we try to reduce - * the number of local allocations/deallocations. + /** + * Reset the backend. If ACE_Log_Msg is reopened during execution, this + * hook will be called. This method should perform any needed cleanup + * activity (similar to close()) because this object won't be reopened + * if the new open call does not specify use of this back end being reset. + * + * @retval Currently ignored, but to be safe, return 0 for success; + * -1 for failure. */ virtual int reset (void) = 0; /// Close the backend completely. virtual int close (void) = 0; - /// Backend routine. This is called when we want to log a message. - /// Since this routine is pure virtual, it must be implemented by the - /// subclass. + /** + * Process a log record. + * + * @param log_record The ACE_Log_Record to process. + * + * @retval -1 for failure; else it is customarily the number of bytes + * processed, but can also be 0 to signify success. + */ virtual ssize_t log (ACE_Log_Record &log_record) = 0; }; diff --git a/ACE/ace/Log_Msg_IPC.h b/ACE/ace/Log_Msg_IPC.h index 80865ccda02..8b39b9ec551 100644 --- a/ACE/ace/Log_Msg_IPC.h +++ b/ACE/ace/Log_Msg_IPC.h @@ -57,7 +57,15 @@ public: /// Open a new connection virtual int open (const ACE_TCHAR *logger_key); + + /** + * Reset the backend. When changing the logging destination the + * backend may need to properly disconnect from the remote logging + * daemon and reclaim some local resources. But we try to reduce + * the number of local allocations/deallocations. + */ virtual int reset (void); + virtual int close (void); virtual ssize_t log (ACE_Log_Record &log_record); diff --git a/ACE/ace/Message_Queue_T.cpp b/ACE/ace/Message_Queue_T.cpp index 1c083767fe9..5a367ab2fa5 100644 --- a/ACE/ace/Message_Queue_T.cpp +++ b/ACE/ace/Message_Queue_T.cpp @@ -157,7 +157,8 @@ ACE_Message_Queue_Ex::enqueue (ACE_MESSAGE_TYPE template int ACE_Message_Queue_Ex::enqueue_prio (ACE_MESSAGE_TYPE *new_item, - ACE_Time_Value *timeout) + ACE_Time_Value *timeout, + unsigned long priority) { ACE_TRACE ("ACE_Message_Queue_Ex::enqueue_prio"); @@ -166,7 +167,7 @@ ACE_Message_Queue_Ex::enqueue_prio (ACE_MESSAGE ACE_NEW_RETURN (mb, ACE_Message_Block ((char *) new_item, sizeof (*new_item), - ACE_Message_Queue_Ex::DEFAULT_PRIORITY), + priority), -1); int const result = this->queue_.enqueue_prio (mb, timeout); diff --git a/ACE/ace/Message_Queue_T.h b/ACE/ace/Message_Queue_T.h index d7973ed4dd7..0d24f8c74aa 100644 --- a/ACE/ace/Message_Queue_T.h +++ b/ACE/ace/Message_Queue_T.h @@ -62,7 +62,9 @@ public: typedef ACE_Message_Queue_Reverse_Iterator REVERSE_ITERATOR; - // = Initialization and termination methods. + /** + * @name Initialization methods + */ //@{ /** * Initialize an ACE_Message_Queue. @@ -100,19 +102,19 @@ public: /// Releases all resources from the message queue and marks it deactivated. virtual ~ACE_Message_Queue (void); - /// Releases all resources from the message queue but does not mark it - /// deactivated. - /// @sa close(). /** - * This method holds the queue lock during this operation. + * Releases all resources from the message queue but does not mark it + * deactivated. This method holds the queue lock during this operation. + * @sa close(). * * @return The number of messages flushed; -1 on error. */ virtual int flush (void); - /// Release all resources from the message queue but do not mark it - /// as deactivated. /** + * Release all resources from the message queue but do not mark it + * as deactivated. + * * @pre The caller must be holding the queue lock before calling this * method. * @@ -333,16 +335,15 @@ public: ACE_Time_Value *timeout = 0); //@} - // = Check if queue is full/empty. + /** @name Queue statistics methods + */ + //@{ + /// True if queue is full, else false. virtual int is_full (void); /// True if queue is empty, else false. virtual int is_empty (void); - /** @name Queue statistics methods - */ - //@{ - /** * Number of total bytes on the queue, i.e., sum of the message * block sizes. @@ -948,20 +949,25 @@ public: * @brief A threaded message queueing facility, modeled after the * queueing facilities in System V STREAMs. * - * An is a strongly-typed version of the - * ACE_Message_Queue. If - * is then all operations are - * thread-safe. Otherwise, if it's then there's no - * locking overhead. + * ACE_Message_Queue_Ex is a strongly-typed version of the + * ACE_Message_Queue class. Rather than queueing in terms of ACE_Message_Block + * objects, ACE_Message_Queue_Ex has a template argument to specify the + * type of objects that are queued. + * + * The second template argument parameterizes the queue's synchronization. + * The argument specifies a synchronization strategy. The two main + * strategies available for ACE_SYNCH_DECL are: + * -# ACE_MT_SYNCH: all operations are thread-safe + * -# ACE_NULL_SYNCH: no synchronization and no locking overhead */ template class ACE_Message_Queue_Ex { public: - // = Default priority value. enum { + /// Default priority value. This is the lowest priority. DEFAULT_PRIORITY = 0 }; @@ -978,141 +984,173 @@ public: REVERSE_ITERATOR; #endif /* 0 */ - // = Initialization and termination methods. - /** - * Initialize an ACE_Message_Queue. The - * determines how many bytes can be stored in a queue before it's - * considered "full." Supplier threads must block until the queue - * is no longer full. The determines how many - * bytes must be in the queue before supplier threads are allowed to - * enqueue additional ACE_Message_Blocks. By default, the - * equals the , which means that - * suppliers will be able to enqueue new messages as soon as a - * consumer removes any message from the queue. Making the - * smaller than the forces - * consumers to drain more messages from the queue before suppliers - * can enqueue new messages, which can minimize the "silly window - * syndrome." + * @name Initialization methods + */ + //@{ + /** + * Initialize an ACE_Message_Queue_Ex. + * + * @param hwm High water mark. Determines how many bytes can be stored in a + * queue before it's considered full. Supplier threads must block + * until the queue is no longer full. + * @param lwm Low water mark. Determines how many bytes must be in the queue + * before supplier threads are allowed to enqueue additional + * data. By default, the @a hwm equals @a lwm, which means + * that suppliers will be able to enqueue new messages as soon as + * a consumer removes any message from the queue. Making the low + * water mark smaller than the high water mark forces consumers to + * drain more messages from the queue before suppliers can enqueue + * new messages, which can minimize the "silly window syndrome." + * @param ns Notification strategy. Pointer to an object conforming to the + * ACE_Notification_Strategy interface. If set, the object's + * notify(void) method will be called each time data is added to + * this ACE_Message_Queue. @see ACE_Reactor_Notification_Strategy. */ ACE_Message_Queue_Ex (size_t high_water_mark = ACE_Message_Queue_Base::DEFAULT_HWM, size_t low_water_mark = ACE_Message_Queue_Base::DEFAULT_LWM, ACE_Notification_Strategy * = 0); - - /** - * Initialize an ACE_Message_Queue. The - * determines how many bytes can be stored in a queue before it's - * considered "full." Supplier threads must block until the queue - * is no longer full. The determines how many - * bytes must be in the queue before supplier threads are allowed to - * enqueue additional ACE_Message_Blocks. By default, the - * equals the , which means that - * suppliers will be able to enqueue new messages as soon as a - * consumer removes any message from the queue. Making the - * smaller than the forces - * consumers to drain more messages from the queue before suppliers - * can enqueue new messages, which can minimize the "silly window - * syndrome." - */ virtual int open (size_t hwm = ACE_Message_Queue_Base::DEFAULT_HWM, size_t lwm = ACE_Message_Queue_Base::DEFAULT_LWM, ACE_Notification_Strategy * = 0); + //@} - /// Close down the message queue and release all resources. + /// Releases all resources from the message queue and marks it deactivated. + /// @sa flush(). + /// + /// @retval The number of messages released from the queue; -1 on error. virtual int close (void); - /// Close down the message queue and release all resources. + /// Releases all resources from the message queue and marks it deactivated. virtual ~ACE_Message_Queue_Ex (void); - /// Release all resources from the message queue but do not mark it as deactivated. - /// This method holds the queue lock during this operation. Returns the number of - /// messages flushed. + /** + * Releases all resources from the message queue but does not mark it + * deactivated. This method holds the queue lock during this operation. + * @sa close(). + * + * @return The number of messages flushed; -1 on error. + */ virtual int flush (void); - /// Release all resources from the message queue but do not mark it as - /// deactivated. This method does not hold the queue lock during this - /// operation, i.e., it assume the lock is held externally. - /// Returns the number of messages flushed. + /** + * Release all resources from the message queue but do not mark it + * as deactivated. + * + * @pre The caller must be holding the queue lock before calling this + * method. + * + * @return The number of messages flushed. + */ virtual int flush_i (void); - // = Enqueue and dequeue methods. - - // For the following enqueue and dequeue methods if @a timeout == 0, - // the caller will block until action is possible, else will wait - // until the absolute time specified in *@a timeout elapses). These - // calls will return, however, when queue is closed, deactivated, - // when a signal occurs, or if the time specified in timeout - // elapses, (in which case errno = EWOULDBLOCK). - + /** @name Enqueue and dequeue methods + * + * The enqueue and dequeue methods accept a timeout value passed as + * an ACE_Time_Value *. In all cases, if the timeout pointer is 0, + * the caller will block until action is possible. If the timeout pointer + * is non-zero, the call will wait (if needed, subject to water mark + * settings) until the absolute time specified in the referenced + * ACE_Time_Value object is reached. If the time is reached before the + * desired action is possible, the method will return -1 with errno set + * to @c EWOULDBLOCK. Regardless of the timeout setting, however, + * these methods will also fail and return -1 when the queue is closed, + * deactivated, pulsed, or when a signal occurs. + * + * The time parameters are handled the same as in ACE_Message_Queue, so + * you can see C++NPv2 Section 6.2 and APG Section 12.3 for a fuller + * treatment of ACE_Message_Queue, enqueueing, dequeueing, and how these + * operations are affected by queue state transitions. + */ + //@{ /** - * Retrieve the first without removing it. Note - * that @a timeout uses <{absolute}> time rather than <{relative}> - * time. If the @a timeout elapses without receiving a message -1 is - * returned and is set to . If the queue is - * deactivated -1 is returned and is set to . - * Otherwise, returns -1 on failure, else the number of items still - * on the queue. + * Retrieve a pointer to the first item in the queue without removing it. + * + * @note Because the item whose pointer is returned is still on the queue, + * another thread may dequeue that item at any time, + * including before the calling thread examines the peeked-at item. + * Be very careful with this method in multithreaded queueing + * situations. + * + * @param first_item Reference to an ACE_MESSAGE_TYPE * that will + * point to the first item on the queue. The item + * remains on the queue until this or another thread + * dequeues it. + * @param timeout The absolute time the caller will wait until + * for an item to be queued. + * + * @retval >0 The number of items on the queue. + * @retval -1 On failure. errno holds the reason. Common errno values are: + * - EWOULDBLOCK: the timeout elapsed + * - ESHUTDOWN: the queue was deactivated or pulsed */ virtual int peek_dequeue_head (ACE_MESSAGE_TYPE *&first_item, ACE_Time_Value *timeout = 0); /** - * Enqueue an into the in - * accordance with its (0 is lowest priority). FIFO - * order is maintained when messages of the same priority are - * inserted consecutively. Note that @a timeout uses <{absolute}> - * time rather than <{relative}> time. If the @a timeout elapses - * without receiving a message -1 is returned and is set to - * . If the queue is deactivated -1 is returned and - * is set to . Otherwise, returns -1 on failure, - * else the number of items still on the queue. + * Enqueue an ACE_MESSAGE TYPE into the queue in accordance with + * the specified priority (0 is lowest priority). FIFO + * order is maintained when items of the same priority are + * inserted consecutively. + * + * @param new_item Pointer to an item that will be added to the queue. + * @param timeout The absolute time the caller will wait until + * for the block to be queued. + * @param priority The priority to use when enqueueing the item. + * + * @retval >0 The number of items on the queue after adding + * the specified item. + * @retval -1 On failure. errno holds the reason. Common errno values are: + * - EWOULDBLOCK: the timeout elapsed + * - ESHUTDOWN: the queue was deactivated or pulsed */ virtual int enqueue_prio (ACE_MESSAGE_TYPE *new_item, - ACE_Time_Value *timeout = 0); + ACE_Time_Value *timeout = 0, + unsigned long priority = DEFAULT_PRIORITY); /** - * Enqueue an into the in - * accordance with its . FIFO - * order is maintained when messages of the same deadline time are - * inserted consecutively. Note that @a timeout uses <{absolute}> - * time rather than <{relative}> time. If the @a timeout elapses - * without receiving a message -1 is returned and is set to - * . If the queue is deactivated -1 is returned and - * is set to . Otherwise, returns -1 on failure, - * else the number of items still on the queue. + * This method acts just like enqueue_tail(). There's no deadline + * time associated with items. */ virtual int enqueue_deadline (ACE_MESSAGE_TYPE *new_item, ACE_Time_Value *timeout = 0); /** - * This is an alias for . It's only here for + * @deprecated This is an alias for enqueue_prio(). It's only here for * backwards compatibility and will go away in a subsequent release. - * Please use instead. Note that @a timeout uses - * <{absolute}> time rather than <{relative}> time. + * Please use enqueue_prio() instead. */ virtual int enqueue (ACE_MESSAGE_TYPE *new_item, ACE_Time_Value *timeout = 0); /** - * Enqueue an at the end of the queue. Note - * that @a timeout uses <{absolute}> time rather than <{relative}> - * time. If the @a timeout elapses without receiving a message -1 is - * returned and is set to . If the queue is - * deactivated -1 is returned and is set to . - * Otherwise, returns -1 on failure, else the number of items still - * on the queue. + * Enqueue an item at the tail of the queue. + * + * @param new_item Pointer to an item that will be added to the queue. + * @param timeout The absolute time the caller will wait until + * for the item to be queued. + * + * @retval >0 The number of items on the queue after adding + * the specified item. + * @retval -1 On failure. errno holds the reason. Common errno values are: + * - EWOULDBLOCK: the timeout elapsed + * - ESHUTDOWN: the queue was deactivated or pulsed */ virtual int enqueue_tail (ACE_MESSAGE_TYPE *new_item, ACE_Time_Value *timeout = 0); /** - * Enqueue an at the head of the queue. Note - * that @a timeout uses <{absolute}> time rather than <{relative}> - * time. If the @a timeout elapses without receiving a message -1 is - * returned and is set to . If the queue is - * deactivated -1 is returned and is set to . - * Otherwise, returns -1 on failure, else the number of items still - * on the queue. + * Enqueue an item at the head of the queue. + * + * @param new_item Pointer to an item that will be added to the queue. + * @param timeout The absolute time the caller will wait until + * for the item to be queued. + * + * @retval >0 The number of items on the queue after adding + * the specified item. + * @retval -1 On failure. errno holds the reason. Common errno values are: + * - EWOULDBLOCK: the timeout elapsed + * - ESHUTDOWN: the queue was deactivated or pulsed */ virtual int enqueue_head (ACE_MESSAGE_TYPE *new_item, ACE_Time_Value *timeout = 0); @@ -1120,64 +1158,74 @@ public: /// This method is an alias for the following method. virtual int dequeue (ACE_MESSAGE_TYPE *&first_item, ACE_Time_Value *timeout = 0); - // This method is an alias for the following method. /** - * Dequeue and return the at the head of the - * queue. Note that @a timeout uses <{absolute}> time rather than - * <{relative}> time. If the @a timeout elapses without receiving a - * message -1 is returned and is set to . If - * the queue is deactivated -1 is returned and is set to - * . Otherwise, returns -1 on failure, else the number - * of items still on the queue. + * Dequeue the item at the head of the queue and return a pointer to it. + * + * @param first_item Reference to an ACE_MESSAGE_TYPE * that will + * be set to the address of the dequeued item. + * @param timeout The absolute time the caller will wait until + * for an item to be dequeued. + * + * @retval >=0 The number of items remaining in the queue. + * @retval -1 On failure. errno holds the reason. Common errno values are: + * - EWOULDBLOCK: the timeout elapsed + * - ESHUTDOWN: the queue was deactivated or pulsed */ virtual int dequeue_head (ACE_MESSAGE_TYPE *&first_item, ACE_Time_Value *timeout = 0); /** - * Dequeue and return the that has the lowest - * priority. Note that @a timeout uses <{absolute}> time rather than - * <{relative}> time. If the @a timeout elapses without receiving a - * message -1 is returned and is set to . If - * the queue is deactivated -1 is returned and is set to - * . Otherwise, returns -1 on failure, else the number - * of items still on the queue. + * Dequeue the item that has the lowest priority (preserves + * FIFO order for items with the same priority) and return a pointer + * to it. + * + * @param first_item Reference to an ACE_MESSAGE_TYPE * that will + * be set to the address of the dequeued item. + * @param timeout The absolute time the caller will wait until + * for an item to be dequeued. + * + * @retval >=0 The number of items remaining in the queue. + * @retval -1 On failure. errno holds the reason. Common errno values are: + * - EWOULDBLOCK: the timeout elapsed + * - ESHUTDOWN: the queue was deactivated or pulsed */ virtual int dequeue_prio (ACE_MESSAGE_TYPE *&dequeued, ACE_Time_Value *timeout = 0); /** - * Dequeue and return the at the tail of the - * queue. Note that @a timeout uses <{absolute}> time rather than - * <{relative}> time. If the @a timeout elapses without receiving a - * message -1 is returned and is set to . If - * the queue is deactivated -1 is returned and is set to - * . Otherwise, returns -1 on failure, else the number - * of items still on the queue. + * Dequeue the item at the tail of the queue and return a pointer to it. + * + * @param dequeued Reference to an ACE_MESSAGE_TYPE * that will + * be set to the address of the dequeued item. + * @param timeout The absolute time the caller will wait until + * for an item to be dequeued. + * + * @retval >=0 The number of items remaining in the queue. + * @retval -1 On failure. errno holds the reason. Common errno values are: + * - EWOULDBLOCK: the timeout elapsed + * - ESHUTDOWN: the queue was deactivated or pulsed */ virtual int dequeue_tail (ACE_MESSAGE_TYPE *&dequeued, ACE_Time_Value *timeout = 0); /** - * Dequeue and return the with the lowest - * deadline time. Note that @a timeout uses <{absolute}> time rather than - * <{relative}> time. If the @a timeout elapses without receiving a - * message -1 is returned and is set to . If - * the queue is deactivated -1 is returned and is set to - * . Otherwise, returns -1 on failure, else the number - * of items still on the queue. + * Because there's deadline associated with enqueue_deadline(), this + * method will behave just as dequeue_head(). */ virtual int dequeue_deadline (ACE_MESSAGE_TYPE *&dequeued, ACE_Time_Value *timeout = 0); + //@} + + /** @name Queue statistics methods + */ + //@{ - // = Check if queue is full/empty. /// True if queue is full, else false. virtual int is_full (void); /// True if queue is empty, else false. virtual int is_empty (void); - - // = Queue statistic methods. /** * Number of total bytes on the queue, i.e., sum of the message * block sizes. @@ -1206,7 +1254,12 @@ public: */ virtual void message_length (size_t new_length); - // = Flow control methods. + //@} + + /** @name Water mark (flow control) methods + */ + //@{ + /** * Get high watermark. */ @@ -1227,8 +1280,14 @@ public: * additional s. */ virtual void low_water_mark (size_t lwm); + //@} - // = Activation control methods. + /** @name Activation and queue state methods + * See C++NPv2 Section 6.2 and APG Section 12.3 for a fuller treatment of + * queue states and transitions and how the transitions affect message + * enqueueing and dequeueing operations. + */ + //@{ /** * Deactivate the queue and wakeup all threads waiting on the queue @@ -1262,8 +1321,11 @@ public: /// Returns true if the state of the queue is DEACTIVATED, /// but false if the queue's state is ACTIVATED or PULSED. virtual int deactivated (void); + //@} - // = Notification hook. + /** @name Notification strategy methods + */ + //@{ /** * This hook is automatically invoked by , @@ -1282,6 +1344,7 @@ public: /// Set the notification strategy for the virtual void notification_strategy (ACE_Notification_Strategy *s); + //@} /// Returns a reference to the lock used by the . virtual ACE_SYNCH_MUTEX_T &lock (void); diff --git a/ACE/ace/OS_NS_Thread.inl b/ACE/ace/OS_NS_Thread.inl index 908b7a7087a..3dc96677e56 100644 --- a/ACE/ace/OS_NS_Thread.inl +++ b/ACE/ace/OS_NS_Thread.inl @@ -3475,7 +3475,16 @@ ACE_OS::thread_mutex_init (ACE_thread_mutex_t *m, ACE_UNUSED_ARG (lock_type); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (arg); - ::InitializeCriticalSection (m); + + ACE_SEH_TRY + { + ::InitializeCriticalSection (m); + } + ACE_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + errno = ENOMEM; + return -1; + } return 0; # elif defined (ACE_HAS_STHREADS) || defined (ACE_HAS_PTHREADS) @@ -3509,7 +3518,16 @@ ACE_OS::thread_mutex_init (ACE_thread_mutex_t *m, ACE_UNUSED_ARG (lock_type); ACE_UNUSED_ARG (name); ACE_UNUSED_ARG (arg); - ::InitializeCriticalSection (m); + + ACE_SEH_TRY + { + ::InitializeCriticalSection (m); + } + ACE_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER) + { + errno = ENOMEM; + return -1; + } return 0; # elif defined (ACE_HAS_STHREADS) || defined (ACE_HAS_PTHREADS) diff --git a/ACE/tests/Auto_Event_Test.cpp b/ACE/tests/Auto_Event_Test.cpp index b7fd8c59049..e2ed56f46a8 100644 --- a/ACE/tests/Auto_Event_Test.cpp +++ b/ACE/tests/Auto_Event_Test.cpp @@ -79,8 +79,15 @@ test_timeout (void) wait.sec (wait.sec () + wait_secs); if (evt.wait (&wait) == -1) - ACE_ASSERT (errno == ETIME); - + { + if (errno != ETIME) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("%p\n"), + ACE_TEXT ("test_timeout should be ETIME but is"))); + status = -1; + } + } ACE_Time_Value wait_diff = ACE_OS::gettimeofday () - begin; msecs_waited = wait_diff.msec (); @@ -89,12 +96,13 @@ test_timeout (void) if (msecs_diff > ACE_ALLOWED_SLACK) { - ACE_DEBUG ((LM_DEBUG, + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Timed wait fails length test\n"))); - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("Value: %d ms, actual %d ms\n"), - msecs_expected, - msecs_waited)); + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("Expected %d ms, actual %d ms; %d allowed\n"), + (int)msecs_expected, + (int)msecs_waited, + (int)ACE_ALLOWED_SLACK)); status = -1; } @@ -149,19 +157,27 @@ worker (void *) if (evt.wait (&tv) == -1) { // verify that we have ETIME - ACE_ASSERT(ACE_OS::last_error() == ETIME); - ++timeouts; + if (ACE_OS::last_error() != ETIME) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("%p\n"), + ACE_TEXT ("Worker should be ETIME but is"))); + } + else + ++timeouts; ACE_Time_Value diff = ACE_OS::gettimeofday (); diff = diff - tv; // tv should have been reset to time acquired long diff_msec = diff.msec (); if (diff_msec > ACE_ALLOWED_SLACK) { - ACE_DEBUG ((LM_DEBUG, + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Acquire fails time reset test\n"))); - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("Diff btw now and returned time: %d ms\n"), - diff.msec ())); + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("Diff btw now and returned time: %d ms; ") + ACE_TEXT ("%d allowed\n"), + (int)diff_msec, + (int)ACE_ALLOWED_SLACK)); test_result = 1; } // Hold the lock for a while. @@ -212,9 +228,10 @@ int run_main (int argc, ACE_TCHAR *argv[]) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Worker threads timed out %d percent of the time\n"), - percent)); + (int)percent)); - ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Auto_Event Test successful\n"))); + if (test_result == 0) + ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Auto_Event Test successful\n"))); #else ACE_UNUSED_ARG (argc); ACE_UNUSED_ARG (argv); diff --git a/ACE/tests/Bug_1890_Regression_Test.cpp b/ACE/tests/Bug_1890_Regression_Test.cpp index 9e94a1ebb2d..a2d735f4230 100644 --- a/ACE/tests/Bug_1890_Regression_Test.cpp +++ b/ACE/tests/Bug_1890_Regression_Test.cpp @@ -95,6 +95,8 @@ run_main (int, ACE_TCHAR *[]) { ACE_START_TEST (ACE_TEXT ("Bug_1890_Regression_Test")); + bool success = true; + ACE_Reactor * reactor = ACE_Reactor::instance(); // Create the timer, this is the main driver for the test @@ -102,25 +104,26 @@ run_main (int, ACE_TCHAR *[]) // Initialize the timer and register with the reactor if (-1 == timer->open(reactor)) - { - ACE_ERROR_RETURN ((LM_ERROR, "Cannot initialize timer\n"), -1); - } + { + ACE_ERROR_RETURN ((LM_ERROR, + ACE_TEXT ("%p\n"), + ACE_TEXT ("Cannot initialize timer")), + -1); + } reactor->run_reactor_event_loop(); // Verify that the results are what we expect - if (!timer->check_expected_results()) - { - ACE_ERROR_RETURN ((LM_ERROR, "Test failed\n"), -1); - } + if (!(success = timer->check_expected_results ())) + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Test failed\n"))); // Cleanup - timer->close(); + timer->close (); delete timer; ACE_END_TEST; - return 0; + return success ? 0 : -1; } Handler::Handler() @@ -129,41 +132,45 @@ Handler::Handler() { } -int Handler:: -open(ACE_Reactor * r) +int +Handler::open (ACE_Reactor * r) { - if(-1 == the_pipe_.open(handles_)) + if (-1 == the_pipe_.open (handles_)) { return -1; } - if(-1 == r->register_handler(this, ACE_Event_Handler::READ_MASK)) + if (-1 == r->register_handler (this, ACE_Event_Handler::READ_MASK)) { return -1; } return 0; } -size_t Handler::handle_input_count() const +size_t +Handler::handle_input_count() const { - return handle_input_count_; + return handle_input_count_; } -void Handler::send_dummy_data() +void +Handler::send_dummy_data() { - char buf[] = "dummy"; - (void) the_pipe_.send(buf, sizeof(buf)); + char buf[] = "dummy"; + (void) the_pipe_.send (buf, sizeof (buf)); } -ACE_HANDLE Handler::get_handle() const +ACE_HANDLE +Handler::get_handle() const { - return the_pipe_.read_handle(); + return the_pipe_.read_handle (); } -int Handler::handle_input(ACE_HANDLE) +int +Handler::handle_input(ACE_HANDLE) { - ++handle_input_count_; - // ACE_DEBUG((LM_DEBUG, "Handler::handle_input called for %d\n", h)); - return 0; + ++handle_input_count_; + // ACE_DEBUG((LM_DEBUG, "Handler::handle_input called for %d\n", h)); + return 0; } int const initial_iterations = 5; @@ -177,109 +184,137 @@ Timer::Timer() { } -int Timer::open(ACE_Reactor * r) +int +Timer::open (ACE_Reactor * r) { - this->reactor(r); + this->reactor (r); // Initialize both handles and register them with the reactor for reading. - for(int i = 0; i != nhandlers; ++i) - { - if (-1 == handler_[i].open(r)) - { - ACE_ERROR_RETURN ((LM_ERROR, "Could not open dummy handler %d\n", i), -1); - } - } + for (int i = 0; i != nhandlers; ++i) + { + if (-1 == handler_[i].open (r)) + { + ACE_ERROR_RETURN ((LM_ERROR, + ACE_TEXT ("Could not open dummy handler %d %p\n"), + i, + ACE_TEXT ("")), + -1); + } + } ACE_Time_Value const interval(0, ACE_ONE_SECOND_IN_USECS / 10); ACE_Time_Value const startup (0, ACE_ONE_SECOND_IN_USECS / 20); - if ( -1 == r->schedule_timer( - this, 0, startup, interval)) - { - ACE_ERROR_RETURN((LM_ERROR, "Could not schedule timer\n"), -1); - } + if (-1 == r->schedule_timer (this, 0, startup, interval)) + { + ACE_ERROR_RETURN ((LM_ERROR, + ACE_TEXT ("%p\n"), + ACE_TEXT ("Could not schedule timer")), + -1); + } return 0; } -void Timer::close() +void +Timer::close() { - for(int i = 0; i != nhandlers; ++i) - { - reactor()->remove_handler(&handler_[i], ACE_Event_Handler::ALL_EVENTS_MASK); - } - reactor()->cancel_timer(this); + for (int i = 0; i != nhandlers; ++i) + { + this->reactor ()->remove_handler (&handler_[i], + ACE_Event_Handler::ALL_EVENTS_MASK | + ACE_Event_Handler::DONT_CALL); + } + this->reactor ()->cancel_timer (this); } -bool Timer::check_expected_results() const +bool +Timer::check_expected_results() const { - if(recorded_count_ < special_handler().handle_input_count()) + if (this->recorded_count_ < this->special_handler ().handle_input_count ()) { - return true; + return true; } - return false; + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("recorded_count %B, special_handler count %B\n"), + this->recorded_count_, + this->special_handler ().handle_input_count ())); + return false; } -int Timer::handle_timeout(ACE_Time_Value const &, void const *) +int +Timer::handle_timeout(ACE_Time_Value const &, void const *) { - if (iteration_ == 0) + if (iteration_ == 0) { send_data_through_handlers(); } - ++iteration_; - if (iteration_ < initial_iterations) + ++iteration_; + if (iteration_ < initial_iterations) { return 0; } - if (iteration_ == initial_iterations) + if (iteration_ == initial_iterations) { remove_some_handlers(); recorded_count_ = special_handler().handle_input_count(); return 0; } - if (iteration_ < total_iterations) + if (iteration_ < total_iterations) { return 0; } - reactor()->end_reactor_event_loop(); + reactor()->end_reactor_event_loop(); - return 0; + return 0; } -void Timer::send_data_through_handlers() +void +Timer::send_data_through_handlers() { - for(int i = 0; i != nhandlers; ++i) + for (int i = 0; i != nhandlers; ++i) { handler_[i].send_dummy_data(); } } -void Timer::remove_some_handlers() +void +Timer::remove_some_handlers() { - for(int i = 0; i != nhandlers; ++i) + // The reactor may not get around to callbacks on deletion until the test + // is over. + ACE_Reactor_Mask mask = + ACE_Event_Handler::ALL_EVENTS_MASK | ACE_Event_Handler::DONT_CALL; + for (int i = 0; i != nhandlers; ++i) { - if (-1 == reactor()->remove_handler(&handler_[i], ACE_Event_Handler::ALL_EVENTS_MASK)) + if (-1 == reactor()->remove_handler(&handler_[i], mask)) { - ACE_ERROR((LM_ERROR, "Cannot remove handler %d in timeout\n", i)); + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("Cannot remove handler %d in %p\n"), + i, + ACE_TEXT ("timeout"))); } } - if (-1 == reactor()->register_handler(&special_handler(), ACE_Event_Handler::ALL_EVENTS_MASK)) + if (-1 == reactor()->register_handler(&special_handler(), + ACE_Event_Handler::ALL_EVENTS_MASK)) { - ACE_ERROR((LM_ERROR, "Cannot add back special handler in timeout\n")); + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("Cannot add back special handler in %p\n"), + ACE_TEXT ("timeout"))); } } Handler & Timer::special_handler() { - return handler_[special_handler_index]; + return handler_[special_handler_index]; } Handler const & Timer::special_handler() const { - return handler_[special_handler_index]; + return handler_[special_handler_index]; } diff --git a/ACE/tests/Makefile.am b/ACE/tests/Makefile.am index 72f1f504760..19f469328a3 100644 --- a/ACE/tests/Makefile.am +++ b/ACE/tests/Makefile.am @@ -1244,6 +1244,27 @@ Log_Msg_Test_LDADD = \ endif !BUILD_ACE_FOR_TAO + +## Makefile.Log_Msg_Backend_Test.am + +if !BUILD_ACE_FOR_TAO + +noinst_PROGRAMS += Log_Msg_Backend_Test + +Log_Msg_Backend_Test_CPPFLAGS = \ + -I$(ACE_ROOT) \ + -I$(ACE_BUILDDIR) + +Log_Msg_Backend_Test_SOURCES = \ + $(ACE_ROOT)/tests/Main.cpp \ + Log_Msg_Backend_Test.cpp + +Log_Msg_Backend_Test_LDADD = \ + libTest_Output.la \ + $(ACE_BUILDDIR)/ace/libACE.la + +endif !BUILD_ACE_FOR_TAO + ## Makefile.Logging_Strategy_Test.am noinst_PROGRAMS += Logging_Strategy_Test diff --git a/ACE/tests/Message_Queue_Test_Ex.cpp b/ACE/tests/Message_Queue_Test_Ex.cpp index fd4f714a42b..1bd1803d23f 100644 --- a/ACE/tests/Message_Queue_Test_Ex.cpp +++ b/ACE/tests/Message_Queue_Test_Ex.cpp @@ -27,6 +27,7 @@ #include "test_config.h" #include "ace/Thread_Manager.h" +#include "ace/Auto_Ptr.h" #include "ace/Message_Queue.h" #include "ace/Synch_Traits.h" #include "ace/Null_Mutex.h" @@ -623,6 +624,100 @@ int basic_queue_test (ACE_Message_Queue_Ex& q) return status; } +int queue_priority_test (ACE_Message_Queue_Ex& q) +{ + int status = 0; + if (!q.is_empty ()) + ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Prio test queue not empty\n")), 1); + + // Set up a few objects with names for how they should come out of the queue. + auto_ptr b1, b2, b3, b4; + b1.reset (new User_Class ("first")); + b2.reset (new User_Class ("second")); + b3.reset (new User_Class ("third")); + b4.reset (new User_Class ("fourth")); + unsigned long prio = + ACE_Message_Queue_Ex::DEFAULT_PRIORITY; + + prio += 1; + if (-1 == q.enqueue_prio (b2.get (), 0, prio)) + ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("b2")), 1); + if (-1 == q.enqueue_prio (b3.get (), 0, prio)) + ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("b3")), 1); + prio -= 1; + if (-1 == q.enqueue_prio (b4.get (), 0, prio)) + ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("b4")), 1); + prio += 5; + if (-1 == q.enqueue_prio (b1.get (), 0, prio)) + ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("b1")), 1); + + User_Class *b = 0; + if (q.dequeue_head (b) == -1) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("dequeue 1"))); + ++status; + } + else + { + if (ACE_OS::strcmp (b->message (), "first") != 0) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("First dequeued was %C\n"), + b->message ())); + ++status; + } + } + if (q.dequeue_head (b) == -1) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("dequeue 2"))); + ++status; + } + else + { + if (ACE_OS::strcmp (b->message (), "second") != 0) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("Second dequeued was %C\n"), + b->message ())); + ++status; + } + } + if (q.dequeue_head (b) == -1) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("dequeue 3"))); + ++status; + } + else + { + if (ACE_OS::strcmp (b->message (), "third") != 0) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("Third dequeued was %C\n"), + b->message ())); + ++status; + } + } + if (q.dequeue_head (b) == -1) + { + ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("dequeue 4"))); + ++status; + } + else + { + if (ACE_OS::strcmp (b->message (), "fourth") != 0) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("Fourth dequeued was %C\n"), + b->message ())); + ++status; + } + } + + if (status == 0) + ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Priority queueing test: OK\n"))); + return status; +} + int run_main (int argc, ACE_TCHAR *argv[]) { @@ -647,6 +742,12 @@ run_main (int argc, ACE_TCHAR *argv[]) ++status; } + // Check priority operations. + if (0 != queue_priority_test (q1)) + { + ++status; + } + ACE_NEW_RETURN (timer, ACE_High_Res_Timer, -1); diff --git a/ACE/tests/Message_Queue_Test_Ex.h b/ACE/tests/Message_Queue_Test_Ex.h index 408d62277d2..38d076ac729 100644 --- a/ACE/tests/Message_Queue_Test_Ex.h +++ b/ACE/tests/Message_Queue_Test_Ex.h @@ -35,6 +35,11 @@ public: ~User_Class (void) { delete [] this->message_; } + const char *message (void) const + { + return this->message_; + } + // This is for checking the ACE_Message_Queue_Ex_N User_Class *next () const { diff --git a/ACE/tests/Semaphore_Test.cpp b/ACE/tests/Semaphore_Test.cpp index fb5ccc36dce..d2815b5cf57 100644 --- a/ACE/tests/Semaphore_Test.cpp +++ b/ACE/tests/Semaphore_Test.cpp @@ -83,7 +83,15 @@ test_timeout (void) wait.sec (wait.sec () + wait_secs); if (s.acquire (wait) == -1) - ACE_ASSERT (errno == ETIME); + { + if (errno != ETIME) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("%p\n"), + ACE_TEXT ("test_timeout should be ETIME but is"))); + status = -1; + } + } ACE_Time_Value wait_diff = ACE_OS::gettimeofday () - begin; @@ -93,12 +101,13 @@ test_timeout (void) if (msecs_diff > ACE_ALLOWED_SLACK) { - ACE_DEBUG ((LM_DEBUG, + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Timed wait fails length test\n"))); - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("Value: %d ms, actual %d ms\n"), - msecs_expected, - msecs_waited)); + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("Expected %d ms, actual %d ms; %d allowed\n"), + (int)msecs_expected, + (int)msecs_waited, + (int)ACE_ALLOWED_SLACK)); status = -1; } @@ -158,19 +167,27 @@ worker (void *) if (s.acquire (tv) == -1) { // verify that we have ETIME - ACE_ASSERT(ACE_OS::last_error() == ETIME); - ++timeouts; + if (ACE_OS::last_error() != ETIME) + { + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("%p\n"), + ACE_TEXT ("Worker should be ETIME but is"))); + } + else + ++timeouts; ACE_Time_Value diff = ACE_OS::gettimeofday (); diff = diff - tv; // tv should have been reset to time acquired long diff_msec = diff.msec (); if (diff_msec > ACE_ALLOWED_SLACK) { - ACE_DEBUG ((LM_DEBUG, + ACE_ERROR ((LM_ERROR, ACE_TEXT ("Acquire fails time reset test\n"))); - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("Diff btw now and returned time: %d ms\n"), - diff.msec ())); + ACE_ERROR ((LM_ERROR, + ACE_TEXT ("Diff btw now and returned time: %d ms; ") + ACE_TEXT ("%d allowed\n"), + (int)diff_msec, + (int)ACE_ALLOWED_SLACK)); test_result = 1; } // Hold the lock for a while. @@ -230,10 +247,11 @@ int run_main (int argc, ACE_TCHAR *argv[]) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Worker threads timed out %d percent of the time\n"), - percent)); + (int)percent)); # endif /* ACE_HAS_STHREADS && ACE_HAS_POSIX_SEM */ - ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Semaphore Test successful\n"))); + if (test_result == 0) + ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Semaphore Test successful\n"))); #else ACE_UNUSED_ARG (argc); ACE_UNUSED_ARG (argv); diff --git a/ACE/tests/run_test.lst b/ACE/tests/run_test.lst index a9e36f266f0..1c6e29d8b7a 100644 --- a/ACE/tests/run_test.lst +++ b/ACE/tests/run_test.lst @@ -73,6 +73,7 @@ IOStream_Test Integer_Truncate_Test Lazy_Map_Manager_Test Log_Msg_Test: !ACE_FOR_TAO +Log_Msg_Backend_Test: !ACE_FOR_TAO Logging_Strategy_Test: !DISABLE_ToFix_LynxOS_PPC !STATIC !ST Manual_Event_Test: !DISABLE_ToFix_LynxOS_PPC MEM_Stream_Test: !DISABLE_ToFix_LynxOS_PPC !DISABLE_ToFix_LynxOS_x86 !VxWorks !nsk !ACE_FOR_TAO diff --git a/ACE/tests/tests.mpc b/ACE/tests/tests.mpc index e9b4437b94a..61bd364467b 100644 --- a/ACE/tests/tests.mpc +++ b/ACE/tests/tests.mpc @@ -488,6 +488,14 @@ project(Log Msg Test) : acetest { } } +project(Log Msg Backend Test) : acetest { + avoids += ace_for_tao + exename = Log_Msg_Backend_Test + Source_Files { + Log_Msg_Backend_Test.cpp + } +} + project(Logging Strategy Test) : acetest { exename = Logging_Strategy_Test Source_Files { -- cgit v1.2.1