Initial revision

10 files changed, 1756 insertions, 0 deletions

diff --git a/examples/Reactor/Misc/Makefile b/examples/Reactor/Misc/Makefile
new file mode 100644
index 00000000000..31d49795de7
--- /dev/null
+++ b/examples/Reactor/Misc/Makefile
@@ -0,0 +1,378 @@
+#----------------------------------------------------------------------------
+#	@(#)Makefile	1.1	10/18/96
+#
+#	Makefile for a test of the miscellaneous Reactor examples
+#----------------------------------------------------------------------------
+
+#----------------------------------------------------------------------------
+#	Local macros
+#----------------------------------------------------------------------------
+
+BIN    	= pingpong \
+	  notification \
+	  signal_tester \
+	  test_event_handler_t \
+	  test_handle_set \
+	  test_reactors \
+	  test_signals \
+	  test_time_value \
+	  test_timer_queue
+
+LSRC   	= $(addsuffix .cpp,$(BIN))
+
+VLDLIBS = $(LDLIBS:%=%$(VAR))
+
+BUILD 	= $(VBIN)
+
+#----------------------------------------------------------------------------
+#	Include macros and targets
+#----------------------------------------------------------------------------
+
+include		$(WRAPPER_ROOT)/include/makeinclude/wrapper_macros.GNU
+include		$(WRAPPER_ROOT)/include/makeinclude/macros.GNU
+include		$(WRAPPER_ROOT)/include/makeinclude/rules.common.GNU
+include		$(WRAPPER_ROOT)/include/makeinclude/rules.nonested.GNU
+include		$(WRAPPER_ROOT)/include/makeinclude/rules.bin.GNU
+include		$(WRAPPER_ROOT)/include/makeinclude/rules.local.GNU
+
+#----------------------------------------------------------------------------
+#	Local targets
+#----------------------------------------------------------------------------
+
+#----------------------------------------------------------------------------
+#	Dependencies
+#----------------------------------------------------------------------------
+# DO NOT DELETE THIS LINE -- g++dep uses it.
+# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY.
+
+.obj/pingpong.o .shobj/pingpong.so: pingpong.cpp \
+ $(WRAPPER_ROOT)/ace/Log_Msg.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.h \
+ $(WRAPPER_ROOT)/ace/ACE.h \
+ $(WRAPPER_ROOT)/ace/OS.h \
+ $(WRAPPER_ROOT)/ace/Time_Value.h \
+ $(WRAPPER_ROOT)/ace/config.h \
+ $(WRAPPER_ROOT)/ace/Trace.h \
+ $(WRAPPER_ROOT)/ace/ACE.i \
+ $(WRAPPER_ROOT)/ace/Log_Priority.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.i \
+ $(WRAPPER_ROOT)/ace/Synch.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(WRAPPER_ROOT)/ace/Synch_T.h \
+ $(WRAPPER_ROOT)/ace/Synch_T.cpp \
+ $(WRAPPER_ROOT)/ace/Thread.h \
+ $(WRAPPER_ROOT)/ace/Synch_T.i \
+ $(WRAPPER_ROOT)/ace/Reactor.h \
+ $(WRAPPER_ROOT)/ace/Handle_Set.h \
+ $(WRAPPER_ROOT)/ace/Timer_Queue.h \
+ $(WRAPPER_ROOT)/ace/Event_Handler.h \
+ $(WRAPPER_ROOT)/ace/Timer_Queue.i \
+ $(WRAPPER_ROOT)/ace/Signal.h \
+ $(WRAPPER_ROOT)/ace/Set.h \
+ $(WRAPPER_ROOT)/ace/Set.cpp \
+ $(WRAPPER_ROOT)/ace/Set.i \
+ $(WRAPPER_ROOT)/ace/Token.h \
+ $(WRAPPER_ROOT)/ace/Pipe.h \
+ $(WRAPPER_ROOT)/ace/Pipe.i \
+ $(WRAPPER_ROOT)/ace/SOCK_Stream.h \
+ $(WRAPPER_ROOT)/ace/SOCK_IO.h \
+ $(WRAPPER_ROOT)/ace/SOCK.h \
+ $(WRAPPER_ROOT)/ace/Addr.h \
+ $(WRAPPER_ROOT)/ace/IPC_SAP.h \
+ $(WRAPPER_ROOT)/ace/IPC_SAP.i \
+ $(WRAPPER_ROOT)/ace/SOCK.i \
+ $(WRAPPER_ROOT)/ace/SOCK_IO.i \
+ $(WRAPPER_ROOT)/ace/INET_Addr.h \
+ $(WRAPPER_ROOT)/ace/SOCK_Stream.i \
+ $(WRAPPER_ROOT)/ace/Reactor.i
+.obj/notification.o .shobj/notification.so: notification.cpp \
+ $(WRAPPER_ROOT)/ace/Log_Msg.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.h \
+ $(WRAPPER_ROOT)/ace/ACE.h \
+ $(WRAPPER_ROOT)/ace/OS.h \
+ $(WRAPPER_ROOT)/ace/Time_Value.h \
+ $(WRAPPER_ROOT)/ace/config.h \
+ $(WRAPPER_ROOT)/ace/Trace.h \
+ $(WRAPPER_ROOT)/ace/ACE.i \
+ $(WRAPPER_ROOT)/ace/Log_Priority.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.i \
+ $(WRAPPER_ROOT)/ace/Service_Config.h \
+ $(WRAPPER_ROOT)/ace/Service_Object.h \
+ $(WRAPPER_ROOT)/ace/Shared_Object.h \
+ $(WRAPPER_ROOT)/ace/Event_Handler.h \
+ $(WRAPPER_ROOT)/ace/Thread_Manager.h \
+ $(WRAPPER_ROOT)/ace/Thread.h \
+ $(WRAPPER_ROOT)/ace/Synch.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(WRAPPER_ROOT)/ace/Synch_T.h \
+ $(WRAPPER_ROOT)/ace/Synch_T.cpp \
+ $(WRAPPER_ROOT)/ace/Synch_T.i \
+ $(WRAPPER_ROOT)/ace/Set.h \
+ $(WRAPPER_ROOT)/ace/Set.cpp \
+ $(WRAPPER_ROOT)/ace/Set.i \
+ $(WRAPPER_ROOT)/ace/Proactor.h \
+ $(WRAPPER_ROOT)/ace/Message_Block.h \
+ $(WRAPPER_ROOT)/ace/Malloc.h \
+ $(WRAPPER_ROOT)/ace/Malloc_T.h \
+ $(WRAPPER_ROOT)/ace/Malloc_T.cpp \
+ $(WRAPPER_ROOT)/ace/Malloc_T.i \
+ $(WRAPPER_ROOT)/ace/Memory_Pool.h \
+ $(WRAPPER_ROOT)/ace/Signal.h \
+ $(WRAPPER_ROOT)/ace/Mem_Map.h \
+ $(WRAPPER_ROOT)/ace/Timer_Queue.h \
+ $(WRAPPER_ROOT)/ace/Timer_Queue.i \
+ $(WRAPPER_ROOT)/ace/ReactorEx.h \
+ $(WRAPPER_ROOT)/ace/Token.h \
+ $(WRAPPER_ROOT)/ace/Reactor.h \
+ $(WRAPPER_ROOT)/ace/Handle_Set.h \
+ $(WRAPPER_ROOT)/ace/Pipe.h \
+ $(WRAPPER_ROOT)/ace/Pipe.i \
+ $(WRAPPER_ROOT)/ace/SOCK_Stream.h \
+ $(WRAPPER_ROOT)/ace/SOCK_IO.h \
+ $(WRAPPER_ROOT)/ace/SOCK.h \
+ $(WRAPPER_ROOT)/ace/Addr.h \
+ $(WRAPPER_ROOT)/ace/IPC_SAP.h \
+ $(WRAPPER_ROOT)/ace/IPC_SAP.i \
+ $(WRAPPER_ROOT)/ace/SOCK.i \
+ $(WRAPPER_ROOT)/ace/SOCK_IO.i \
+ $(WRAPPER_ROOT)/ace/INET_Addr.h \
+ $(WRAPPER_ROOT)/ace/SOCK_Stream.i \
+ $(WRAPPER_ROOT)/ace/Reactor.i \
+ $(WRAPPER_ROOT)/ace/Svc_Conf_Tokens.h
+.obj/signal_tester.o .shobj/signal_tester.so: signal_tester.cpp \
+ $(WRAPPER_ROOT)/ace/Log_Msg.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.h \
+ $(WRAPPER_ROOT)/ace/ACE.h \
+ $(WRAPPER_ROOT)/ace/OS.h \
+ $(WRAPPER_ROOT)/ace/Time_Value.h \
+ $(WRAPPER_ROOT)/ace/config.h \
+ $(WRAPPER_ROOT)/ace/Trace.h \
+ $(WRAPPER_ROOT)/ace/ACE.i \
+ $(WRAPPER_ROOT)/ace/Log_Priority.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.i \
+ $(WRAPPER_ROOT)/ace/Service_Config.h \
+ $(WRAPPER_ROOT)/ace/Service_Object.h \
+ $(WRAPPER_ROOT)/ace/Shared_Object.h \
+ $(WRAPPER_ROOT)/ace/Event_Handler.h \
+ $(WRAPPER_ROOT)/ace/Thread_Manager.h \
+ $(WRAPPER_ROOT)/ace/Thread.h \
+ $(WRAPPER_ROOT)/ace/Synch.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(WRAPPER_ROOT)/ace/Synch_T.h \
+ $(WRAPPER_ROOT)/ace/Synch_T.cpp \
+ $(WRAPPER_ROOT)/ace/Synch_T.i \
+ $(WRAPPER_ROOT)/ace/Set.h \
+ $(WRAPPER_ROOT)/ace/Set.cpp \
+ $(WRAPPER_ROOT)/ace/Set.i \
+ $(WRAPPER_ROOT)/ace/Proactor.h \
+ $(WRAPPER_ROOT)/ace/Message_Block.h \
+ $(WRAPPER_ROOT)/ace/Malloc.h \
+ $(WRAPPER_ROOT)/ace/Malloc_T.h \
+ $(WRAPPER_ROOT)/ace/Malloc_T.cpp \
+ $(WRAPPER_ROOT)/ace/Malloc_T.i \
+ $(WRAPPER_ROOT)/ace/Memory_Pool.h \
+ $(WRAPPER_ROOT)/ace/Signal.h \
+ $(WRAPPER_ROOT)/ace/Mem_Map.h \
+ $(WRAPPER_ROOT)/ace/Timer_Queue.h \
+ $(WRAPPER_ROOT)/ace/Timer_Queue.i \
+ $(WRAPPER_ROOT)/ace/ReactorEx.h \
+ $(WRAPPER_ROOT)/ace/Token.h \
+ $(WRAPPER_ROOT)/ace/Reactor.h \
+ $(WRAPPER_ROOT)/ace/Handle_Set.h \
+ $(WRAPPER_ROOT)/ace/Pipe.h \
+ $(WRAPPER_ROOT)/ace/Pipe.i \
+ $(WRAPPER_ROOT)/ace/SOCK_Stream.h \
+ $(WRAPPER_ROOT)/ace/SOCK_IO.h \
+ $(WRAPPER_ROOT)/ace/SOCK.h \
+ $(WRAPPER_ROOT)/ace/Addr.h \
+ $(WRAPPER_ROOT)/ace/IPC_SAP.h \
+ $(WRAPPER_ROOT)/ace/IPC_SAP.i \
+ $(WRAPPER_ROOT)/ace/SOCK.i \
+ $(WRAPPER_ROOT)/ace/SOCK_IO.i \
+ $(WRAPPER_ROOT)/ace/INET_Addr.h \
+ $(WRAPPER_ROOT)/ace/SOCK_Stream.i \
+ $(WRAPPER_ROOT)/ace/Reactor.i \
+ $(WRAPPER_ROOT)/ace/Svc_Conf_Tokens.h
+.obj/test_event_handler_t.o .shobj/test_event_handler_t.so: test_event_handler_t.cpp \
+ $(WRAPPER_ROOT)/ace/Log_Msg.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.h \
+ $(WRAPPER_ROOT)/ace/ACE.h \
+ $(WRAPPER_ROOT)/ace/OS.h \
+ $(WRAPPER_ROOT)/ace/Time_Value.h \
+ $(WRAPPER_ROOT)/ace/config.h \
+ $(WRAPPER_ROOT)/ace/Trace.h \
+ $(WRAPPER_ROOT)/ace/ACE.i \
+ $(WRAPPER_ROOT)/ace/Log_Priority.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.i \
+ $(WRAPPER_ROOT)/ace/Event_Handler_T.h \
+ $(WRAPPER_ROOT)/ace/Event_Handler.h
+.obj/test_handle_set.o .shobj/test_handle_set.so: test_handle_set.cpp \
+ $(WRAPPER_ROOT)/ace/Log_Msg.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.h \
+ $(WRAPPER_ROOT)/ace/ACE.h \
+ $(WRAPPER_ROOT)/ace/OS.h \
+ $(WRAPPER_ROOT)/ace/Time_Value.h \
+ $(WRAPPER_ROOT)/ace/config.h \
+ $(WRAPPER_ROOT)/ace/Trace.h \
+ $(WRAPPER_ROOT)/ace/ACE.i \
+ $(WRAPPER_ROOT)/ace/Log_Priority.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.i \
+ $(WRAPPER_ROOT)/ace/Handle_Set.h
+.obj/test_reactors.o .shobj/test_reactors.so: test_reactors.cpp \
+ $(WRAPPER_ROOT)/ace/Reactor.h \
+ $(WRAPPER_ROOT)/ace/Handle_Set.h \
+ $(WRAPPER_ROOT)/ace/ACE.h \
+ $(WRAPPER_ROOT)/ace/OS.h \
+ $(WRAPPER_ROOT)/ace/Time_Value.h \
+ $(WRAPPER_ROOT)/ace/config.h \
+ $(WRAPPER_ROOT)/ace/Trace.h \
+ $(WRAPPER_ROOT)/ace/ACE.i \
+ $(WRAPPER_ROOT)/ace/Log_Msg.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.h \
+ $(WRAPPER_ROOT)/ace/Log_Priority.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.i \
+ $(WRAPPER_ROOT)/ace/Timer_Queue.h \
+ $(WRAPPER_ROOT)/ace/Event_Handler.h \
+ $(WRAPPER_ROOT)/ace/Synch.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(WRAPPER_ROOT)/ace/Synch_T.h \
+ $(WRAPPER_ROOT)/ace/Synch_T.cpp \
+ $(WRAPPER_ROOT)/ace/Thread.h \
+ $(WRAPPER_ROOT)/ace/Synch_T.i \
+ $(WRAPPER_ROOT)/ace/Timer_Queue.i \
+ $(WRAPPER_ROOT)/ace/Signal.h \
+ $(WRAPPER_ROOT)/ace/Set.h \
+ $(WRAPPER_ROOT)/ace/Set.cpp \
+ $(WRAPPER_ROOT)/ace/Set.i \
+ $(WRAPPER_ROOT)/ace/Token.h \
+ $(WRAPPER_ROOT)/ace/Pipe.h \
+ $(WRAPPER_ROOT)/ace/Pipe.i \
+ $(WRAPPER_ROOT)/ace/SOCK_Stream.h \
+ $(WRAPPER_ROOT)/ace/SOCK_IO.h \
+ $(WRAPPER_ROOT)/ace/SOCK.h \
+ $(WRAPPER_ROOT)/ace/Addr.h \
+ $(WRAPPER_ROOT)/ace/IPC_SAP.h \
+ $(WRAPPER_ROOT)/ace/IPC_SAP.i \
+ $(WRAPPER_ROOT)/ace/SOCK.i \
+ $(WRAPPER_ROOT)/ace/SOCK_IO.i \
+ $(WRAPPER_ROOT)/ace/INET_Addr.h \
+ $(WRAPPER_ROOT)/ace/SOCK_Stream.i \
+ $(WRAPPER_ROOT)/ace/Reactor.i \
+ $(WRAPPER_ROOT)/ace/Service_Config.h \
+ $(WRAPPER_ROOT)/ace/Service_Object.h \
+ $(WRAPPER_ROOT)/ace/Shared_Object.h \
+ $(WRAPPER_ROOT)/ace/Thread_Manager.h \
+ $(WRAPPER_ROOT)/ace/Proactor.h \
+ $(WRAPPER_ROOT)/ace/Message_Block.h \
+ $(WRAPPER_ROOT)/ace/Malloc.h \
+ $(WRAPPER_ROOT)/ace/Malloc_T.h \
+ $(WRAPPER_ROOT)/ace/Malloc_T.cpp \
+ $(WRAPPER_ROOT)/ace/Malloc_T.i \
+ $(WRAPPER_ROOT)/ace/Memory_Pool.h \
+ $(WRAPPER_ROOT)/ace/Mem_Map.h \
+ $(WRAPPER_ROOT)/ace/ReactorEx.h \
+ $(WRAPPER_ROOT)/ace/Svc_Conf_Tokens.h \
+ $(WRAPPER_ROOT)/ace/Task.h \
+ $(WRAPPER_ROOT)/ace/Message_Queue.h \
+ $(WRAPPER_ROOT)/ace/IO_Cntl_Msg.h \
+ $(WRAPPER_ROOT)/ace/Message_Queue.cpp \
+ $(WRAPPER_ROOT)/ace/Message_Queue.i \
+ $(WRAPPER_ROOT)/ace/Task.cpp \
+ $(WRAPPER_ROOT)/ace/Module.h \
+ $(WRAPPER_ROOT)/ace/Module.cpp \
+ $(WRAPPER_ROOT)/ace/Stream_Modules.h \
+ $(WRAPPER_ROOT)/ace/Stream_Modules.cpp \
+ $(WRAPPER_ROOT)/ace/Stream_Modules.i \
+ $(WRAPPER_ROOT)/ace/Module.i \
+ $(WRAPPER_ROOT)/ace/Task.i
+.obj/test_signals.o .shobj/test_signals.so: test_signals.cpp \
+ $(WRAPPER_ROOT)/ace/Log_Msg.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.h \
+ $(WRAPPER_ROOT)/ace/ACE.h \
+ $(WRAPPER_ROOT)/ace/OS.h \
+ $(WRAPPER_ROOT)/ace/Time_Value.h \
+ $(WRAPPER_ROOT)/ace/config.h \
+ $(WRAPPER_ROOT)/ace/Trace.h \
+ $(WRAPPER_ROOT)/ace/ACE.i \
+ $(WRAPPER_ROOT)/ace/Log_Priority.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.i \
+ $(WRAPPER_ROOT)/ace/Reactor.h \
+ $(WRAPPER_ROOT)/ace/Handle_Set.h \
+ $(WRAPPER_ROOT)/ace/Timer_Queue.h \
+ $(WRAPPER_ROOT)/ace/Event_Handler.h \
+ $(WRAPPER_ROOT)/ace/Synch.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(WRAPPER_ROOT)/ace/Synch_T.h \
+ $(WRAPPER_ROOT)/ace/Synch_T.cpp \
+ $(WRAPPER_ROOT)/ace/Thread.h \
+ $(WRAPPER_ROOT)/ace/Synch_T.i \
+ $(WRAPPER_ROOT)/ace/Timer_Queue.i \
+ $(WRAPPER_ROOT)/ace/Signal.h \
+ $(WRAPPER_ROOT)/ace/Set.h \
+ $(WRAPPER_ROOT)/ace/Set.cpp \
+ $(WRAPPER_ROOT)/ace/Set.i \
+ $(WRAPPER_ROOT)/ace/Token.h \
+ $(WRAPPER_ROOT)/ace/Pipe.h \
+ $(WRAPPER_ROOT)/ace/Pipe.i \
+ $(WRAPPER_ROOT)/ace/SOCK_Stream.h \
+ $(WRAPPER_ROOT)/ace/SOCK_IO.h \
+ $(WRAPPER_ROOT)/ace/SOCK.h \
+ $(WRAPPER_ROOT)/ace/Addr.h \
+ $(WRAPPER_ROOT)/ace/IPC_SAP.h \
+ $(WRAPPER_ROOT)/ace/IPC_SAP.i \
+ $(WRAPPER_ROOT)/ace/SOCK.i \
+ $(WRAPPER_ROOT)/ace/SOCK_IO.i \
+ $(WRAPPER_ROOT)/ace/INET_Addr.h \
+ $(WRAPPER_ROOT)/ace/SOCK_Stream.i \
+ $(WRAPPER_ROOT)/ace/Reactor.i
+.obj/test_time_value.o .shobj/test_time_value.so: test_time_value.cpp \
+ $(WRAPPER_ROOT)/ace/ACE.h \
+ $(WRAPPER_ROOT)/ace/OS.h \
+ $(WRAPPER_ROOT)/ace/Time_Value.h \
+ $(WRAPPER_ROOT)/ace/config.h \
+ $(WRAPPER_ROOT)/ace/Trace.h \
+ $(WRAPPER_ROOT)/ace/ACE.i \
+ $(WRAPPER_ROOT)/ace/Log_Msg.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.h \
+ $(WRAPPER_ROOT)/ace/Log_Priority.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.i
+.obj/test_timer_queue.o .shobj/test_timer_queue.so: test_timer_queue.cpp \
+ $(WRAPPER_ROOT)/ace/Log_Msg.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.h \
+ $(WRAPPER_ROOT)/ace/ACE.h \
+ $(WRAPPER_ROOT)/ace/OS.h \
+ $(WRAPPER_ROOT)/ace/Time_Value.h \
+ $(WRAPPER_ROOT)/ace/config.h \
+ $(WRAPPER_ROOT)/ace/Trace.h \
+ $(WRAPPER_ROOT)/ace/ACE.i \
+ $(WRAPPER_ROOT)/ace/Log_Priority.h \
+ $(WRAPPER_ROOT)/ace/Log_Record.i \
+ $(WRAPPER_ROOT)/ace/Timer_Queue.h \
+ $(WRAPPER_ROOT)/ace/Event_Handler.h \
+ $(WRAPPER_ROOT)/ace/Synch.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(WRAPPER_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(WRAPPER_ROOT)/ace/Synch_T.h \
+ $(WRAPPER_ROOT)/ace/Synch_T.cpp \
+ $(WRAPPER_ROOT)/ace/Thread.h \
+ $(WRAPPER_ROOT)/ace/Synch_T.i \
+ $(WRAPPER_ROOT)/ace/Timer_Queue.i
+
+# IF YOU PUT ANYTHING HERE IT WILL GO AWAY
diff --git a/examples/Reactor/Misc/notification.cpp b/examples/Reactor/Misc/notification.cpp
new file mode 100644
index 00000000000..45836446b5a
--- /dev/null
+++ b/examples/Reactor/Misc/notification.cpp
@@ -0,0 +1,249 @@
+#include "ace/Log_Msg.h"
+// @(#)notification.cpp	1.1	10/18/96
+
+#include "ace/Service_Config.h"
+#include "ace/Thread.h"
+
+#if defined (ACE_HAS_THREADS)
+
+class Thread_Handler : public ACE_Event_Handler
+  // = TITLE
+  //   Illustrate how the ACE_Reactor's thread-safe event notification 
+  //   mechanism works.
+  //     
+  // = DESCRIPTION
+  //   Handle timeouts in the main thread via the ACE_Reactor and I/O
+  //   events in a separate thread.  Just before the separate I/O thread
+  //   exits it notifies the ACE_Reactor in the main thread using the
+  //   ACE_Reactor's notification mechanism. 
+{
+public:
+  Thread_Handler (int delay, int interval, int n_threads);
+  Thread_Handler (size_t id): id_ (id) {}
+
+  virtual int handle_signal (int signum, siginfo_t * = 0, ucontext_t * = 0);
+  // Handle signals.
+
+  virtual int handle_exception (ACE_HANDLE);
+  // Print data from main thread.
+
+  virtual int handle_output (ACE_HANDLE);
+  // Print data from main thread.
+
+  virtual int handle_timeout (const ACE_Time_Value &, 
+			      const void *);
+  // Handle timeout events in the main thread.
+
+  virtual int handle_input (ACE_HANDLE);
+  // General notification messages to the Reactor.
+
+  virtual int notify (void);
+  // Perform notifications.
+
+  virtual int svc (void);
+  // Handle I/O events in a separate threads.
+
+private:
+  static void *svc_run (void *);
+  // Glues C++ to C thread library functions.
+
+  size_t id_;
+  // ID passed in by Thread_Handler constructor.
+
+  // = Timing variables.
+  // Delay factor for timer-driven I/O.
+  static ACE_Time_Value delay_;
+
+  // Interval factor for Event_Handler timer.
+  static ACE_Time_Value interval_;
+};
+
+// Delay factor for timer-driven I/O.
+ACE_Time_Value Thread_Handler::delay_;
+
+// Interval factor for Event_Handler timer.
+ACE_Time_Value Thread_Handler::interval_;
+
+Thread_Handler::Thread_Handler (int delay, 
+				int interval,
+				int n_threads)
+{
+  delay_.set (delay);
+  interval_.set (interval);
+
+  ACE_Sig_Set sig_set;
+  
+  sig_set.sig_add (SIGQUIT);
+  sig_set.sig_add (SIGINT);
+
+  this->id_ = 0;
+
+  if (ACE::register_stdin_handler (this,
+				   ACE_Service_Config::reactor (),
+				   ACE_Service_Config::thr_mgr ()) == -1)
+    ACE_ERROR ((LM_ERROR, "%p\n", "register_stdin_handler"));
+
+  else if (ACE_Service_Config::reactor ()->register_handler (sig_set, this) == -1)
+    ACE_ERROR ((LM_ERROR, "(%t) %p\n", "register_handler"));
+
+  else if (ACE_Service_Config::reactor ()->schedule_timer 
+      (this, 0, Thread_Handler::delay_, Thread_Handler::interval_) == -1)
+    ACE_ERROR ((LM_ERROR, "(%t) %p\n", "schedule_timer"));
+   
+  // Set up this thread's signal mask, which is inherited by the
+  // threads it spawns.
+
+  ACE_Thread::sigsetmask (SIG_BLOCK, sig_set);
+
+  // Create N new threads of control Thread_Handlers.
+
+  for (size_t i = 0; i < n_threads; i++)
+    if (ACE_Thread::spawn (&Thread_Handler::svc_run, 
+			   new Thread_Handler (i + 1),
+			   THR_NEW_LWP | THR_DETACHED) != 0)
+      ACE_ERROR ((LM_ERROR, "%p\n", "ACE_Thread::spawn"));
+
+  // Unblock signal set so that only this thread receives them!
+  ACE_Thread::sigsetmask (SIG_UNBLOCK, sig_set);
+}
+
+// Test stdin handling (can use select to demultiplex HANDLEs)
+
+int
+Thread_Handler::handle_input (ACE_HANDLE handle)
+{
+  char buf[BUFSIZ];
+  ssize_t n = ACE_OS::read (handle, buf, sizeof buf);
+
+  if (n > 0)
+    {
+      ACE_DEBUG ((LM_DEBUG, "(%t) %*s", n, buf));
+      return this->notify ();
+    }
+  else
+    return -1;
+}
+
+int
+Thread_Handler::notify (void)
+{
+  // Just do something to test the ACE_Reactor's multi-thread
+  // capabilities...
+
+  if (ACE_Service_Config::reactor ()->notify 
+      (this, ACE_Event_Handler::EXCEPT_MASK) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "(%t) %p\n", "notify"), -1);
+
+  else if (ACE_Service_Config::reactor ()->notify 
+	   (this, ACE_Event_Handler::WRITE_MASK) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "(%t) %p\n", "notify"), -1);
+
+  return 0;
+}
+
+// Perform a task that will test the ACE_Reactor's multi-threading
+// capabilities in separate threads.
+
+int
+Thread_Handler::svc (void)
+{
+  for (;;)
+    {
+      if (Thread_Handler::delay_.sec () > 0)
+	// Block for delay_.secs () / 2, then notify the Reactor.
+	ACE_OS::sleep (Thread_Handler::delay_.sec () / 2);
+
+      this->notify ();
+    }
+  return 0;
+}
+
+// Test signal handling.
+
+int 
+Thread_Handler::handle_signal (int signum, siginfo_t *, ucontext_t *)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) received signal %S\n", signum));
+
+  switch (signum)
+    {
+    case SIGINT:
+    case SIGQUIT:
+      ACE_ERROR ((LM_ERROR, 
+		  "(%t) ******************** shutting down %n on signal %S\n", 
+		  signum));
+      ACE_Service_Config::end_reactor_event_loop ();
+    }
+  return 0;
+}
+
+int 
+Thread_Handler::handle_timeout (const ACE_Time_Value &time,
+				const void *)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) received timeout at (%u, %u)\n",
+	      time.sec (), time.usec ()));
+  return 0;
+}
+
+// Called by the ACE_Reactor when it receives a notification.
+
+int
+Thread_Handler::handle_exception (ACE_HANDLE)
+{
+  ACE_DEBUG ((LM_DEBUG, 
+	      "(%t) handle_exception received notification from id %d\n", 
+	      this->id_));
+  return 0;
+}
+
+// Called by the ACE_Reactor when it receives a notification.
+
+int
+Thread_Handler::handle_output (ACE_HANDLE)
+{
+  ACE_DEBUG ((LM_DEBUG, 
+	      "(%t) handle_output received notification from id %d\n", 
+	      this->id_));
+  return 0;
+}
+
+// "Shim" function that integrates C thread API with C++.
+
+void *
+Thread_Handler::svc_run (void *eh)
+{
+  Thread_Handler *this_handler = (Thread_Handler *) eh;
+
+  return this_handler->svc () == 0 ? 0 : (void *) -1;
+}
+
+int 
+main (int argc, char *argv[])
+{
+  // Required to initialize the Service Configurator.
+  ACE_Service_Config daemon (argv[0]);
+
+  if (argc != 4)
+    ACE_ERROR ((LM_ERROR, 
+		"usage: %s delay interval n_threads%a\n",
+		argv[0], 1));
+
+  int delay = ACE_OS::atoi (argv[1]);
+  int interval = ACE_OS::atoi (argv[2]);
+  size_t n_threads = ACE_OS::atoi (argv[3]);
+
+  Thread_Handler thr_handler (delay, interval, n_threads);
+
+  ACE_Service_Config::run_reactor_event_loop ();
+  ACE_DEBUG ((LM_DEBUG, "exiting from main%a\n", 1));
+  return 0;
+}
+#else
+int 
+main (int, char *[])
+{
+  ACE_ERROR_RETURN ((LM_ERROR, 
+		     "threads not supported on this platform\n"), -1);
+}
+#endif /* ACE_HAS_THREADS */
diff --git a/examples/Reactor/Misc/pingpong.cpp b/examples/Reactor/Misc/pingpong.cpp
new file mode 100644
index 00000000000..a44267f4e82
--- /dev/null
+++ b/examples/Reactor/Misc/pingpong.cpp
@@ -0,0 +1,241 @@
+/* Simple program that illustrates all the features of the ACE_Reactor:
+// @(#)pingpong.cpp	1.1	10/18/96
+
+
+   1. I/O event demultiplexing
+   2. Signal-based demultiplexing
+   3. Timer-based demultiplexing
+
+   To test this program, compile it and then execute it as follows:
+
+   % ./pingpong hello
+
+   You should see lots of the following output:
+   
+   writing <4> [7860]
+   writing <4> [7860]
+   writing <4> [7860]
+   writing <4> [7860]
+   reading <5> (7860) [1] = hello
+   writing <4> [7860]
+   writing <5> [7861]
+   reading <4> (7861) [2] = hello
+   reading <5> (7860) [2] = hello
+   writing <4> [7860]
+   writing <5> [7861]
+   reading <4> (7861) [3] = hello
+   reading <5> (7860) [3] = hello
+
+   After 10 seconds you'll see the following:
+
+   ./pingpong: shutting down tester (pid = 7861)
+   ./pingpong: shutting down tester (pid = 7860)
+
+   and the program will stop.  If you'd like to
+   stop it earlier, just hit the control-C sequence
+   and you'll see the same messages. */
+
+#include "ace/Log_Msg.h"
+#include "ace/Synch.h"
+#include "ace/Reactor.h"
+#include "ace/Pipe.h"
+
+class Ping_Pong : public ACE_Test_and_Set<ACE_Null_Mutex, sig_atomic_t>
+{
+public:
+  Ping_Pong (char b[], ACE_HANDLE f);
+  virtual ACE_HANDLE get_handle (void) const;
+  virtual int handle_input (ACE_HANDLE);
+  virtual int handle_output (ACE_HANDLE);
+  virtual int handle_timeout (const ACE_Time_Value &, const void *);
+
+private:
+  char buf_[BUFSIZ];
+  // Buffer to send.
+
+  size_t buflen_;
+  // Length of the buffer to send.
+
+  int pid_;
+  // Process ID.
+
+  ACE_HANDLE handle_;
+  // Open handle.
+};
+
+Ping_Pong::Ping_Pong (char b[], ACE_HANDLE f)
+  : handle_ (f),
+    buflen_ (ACE_OS::strlen (b) + 1 + (2 * sizeof (int))),
+    pid_ (ACE_OS::getpid ())
+{
+  *((int *) this->buf_) = (int) this->pid_;
+  *((int *) (this->buf_ + sizeof (int))) = 0;
+  ACE_OS::strcpy (this->buf_ + (2 * sizeof (int)), b); 
+  this->buf_[this->buflen_ - 1] = '\n';
+  this->buf_[this->buflen_] = '\0';
+}
+
+ACE_HANDLE
+Ping_Pong::get_handle (void) const
+{
+  return this->handle_;
+}
+
+int 
+Ping_Pong::handle_input (ACE_HANDLE)
+{
+#if defined (ACE_HAS_STREAM_PIPES)
+  // We can rely on record-oriented reads...
+
+  ssize_t n = ACE::recv (this->handle_, this->buf_, this->buflen_);
+
+  if (n != this->buflen_)
+    ACE_ERROR_RETURN ((LM_ERROR, "(%P|%t) reading [%d] %p\n", handle_, "read"), -1);
+
+  ACE_DEBUG ((LM_DEBUG, 
+	      "(%P|%t) reading <%d> (%d) [%d] = %s\n",
+	      this->handle_, 
+	      *(int *) this->buf_, 
+	      *(int *) (this->buf_ + sizeof (int)), 
+	      this->buf_ + (2 * sizeof (int))));
+#else
+  ssize_t n = ACE::recv (this->handle_, this->buf_, sizeof this->buf_);
+
+  if (n == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "[%d] %p\n", handle_, "read"), -1);
+
+  n -= (2 * sizeof (int));
+  char *buf = this->buf_ + (2 * sizeof (int));
+
+  ACE_DEBUG ((LM_DEBUG, "(%P|%t) reading <%d> = %*s\n",
+	      this->handle_, n, buf));
+#endif /* ACE_HAS_STREAM_PIPES */
+  return 0;
+}
+
+int 
+Ping_Pong::handle_output (ACE_HANDLE)
+{
+#if defined (ACE_HAS_STREAM_PIPES)
+  // We can rely on record-oriented reads...
+
+  (*(int *) (this->buf_)) = this->pid_;
+  (*(int *) (this->buf_ + sizeof (int)))++;
+  if (ACE::send (this->handle_, this->buf_, this->buflen_) == -1)
+    return -1;
+  else
+    {
+      ACE_DEBUG ((LM_DEBUG, 
+		  "(%P|%t) writing <%d> [%d]\n", 
+		  this->handle_, this->pid_));
+      return 0;
+    }
+#else
+  if (ACE::send (this->handle_, this->buf_, this->buflen_) == -1)
+    return -1;
+  else
+    {
+      ACE_DEBUG ((LM_DEBUG, 
+		  "(%P|%t) writing <%d>\n", this->handle_));
+      return 0;
+    }
+#endif /* ACE_HAS_STREAM_PIPES */
+}
+
+int 
+Ping_Pong::handle_timeout (const ACE_Time_Value &, 
+			   const void *)
+{
+  this->set (1);
+  return 0;
+}
+
+// Contains the string to "pingpong" back and forth...
+static char *string_name;
+
+// Wait for 10 seconds and then shut down.
+static const int SHUTDOWN_TIME = 10;
+
+#if defined (ACE_WIN32)
+static ACE_Barrier barrier (3);
+
+static void *
+worker (void *arg)
+{
+  ACE_HANDLE handle = (ACE_HANDLE) arg;
+
+  run_svc (handle);
+  barrier.wait ();
+  ACE_DEBUG ((LM_DEBUG, "(%P|%t) %n: shutting down tester\n"));
+  return 0;
+}
+#endif /* ACE_WIN32 */
+
+static void
+run_svc (ACE_HANDLE handle)
+{
+  ACE_Reactor reactor;
+
+  Ping_Pong callback (string_name, handle);
+
+  // Register the callback object for the various I/O, signal, and
+  // timer-based events.
+
+  if (reactor.register_handler (&callback,
+				ACE_Event_Handler::READ_MASK 
+				| ACE_Event_Handler::WRITE_MASK) == -1
+      || reactor.register_handler (SIGINT, &callback) == -1
+      || reactor.schedule_timer (&callback, 0, SHUTDOWN_TIME) == -1)
+    ACE_ERROR ((LM_ERROR, "%p\n%a", "reactor", 1));
+
+  // Main event loop (one per process).
+
+  while (callback.is_set () == 0)
+    reactor.handle_events ();
+}
+
+int 
+main (int argc, char *argv[])
+{
+  ACE_LOG_MSG->open (argv[0]);
+
+  if (argc != 2)
+    ACE_ERROR ((LM_ERROR, "usage: %n string\n%a", 1));
+
+  string_name = argv[1];
+
+  ACE_HANDLE handles[2];
+
+  // Create a pipe and initialize the handles.
+  ACE_Pipe pipe (handles);
+
+#if defined (ACE_WIN32)
+  if (ACE_Thread::spawn (ACE_THR_FUNC (worker), 
+			 (void *) handles[0], 
+			 THR_DETACHED) == -1
+      || ACE_Thread::spawn (ACE_THR_FUNC (worker),
+			    (void *) handles[1],
+			    THR_DETACHED) == -1)
+      ACE_ERROR ((LM_ERROR, "%p\n%a", "spawn", 1));
+
+  barrier.wait ();
+
+#else
+  pid_t pid = ACE_OS::fork ();
+
+  if (pid == -1)
+    ACE_ERROR ((LM_ERROR, "%p\n%a", "fork", 1));
+
+  // Resync the ACE_Log_Msg notion of process id and program name.
+  ACE_LOG_MSG->sync (argv[0]); 
+
+  run_svc (handles[pid == 0]);
+
+  ACE_DEBUG ((LM_DEBUG, "(%P|%t) %n: shutting down tester\n"));
+#endif /* ACE_WIN32 */
+
+  if (pipe.close () == -1)
+    ACE_ERROR ((LM_ERROR, "%p\n", "close"));
+
+  return 0;
+}
diff --git a/examples/Reactor/Misc/signal_tester.cpp b/examples/Reactor/Misc/signal_tester.cpp
new file mode 100644
index 00000000000..1631c00b2d0
--- /dev/null
+++ b/examples/Reactor/Misc/signal_tester.cpp
@@ -0,0 +1,221 @@
+// Perform an extensive test of the ACE_Reactor's event dispatching
+// @(#)signal_tester.cpp	1.1	10/18/96
+
+// mechanisms.  These mechanisms illustrate how signals, I/O, and
+// timeout events can all be handled within the same framework.  In
+// addition, this example illustrates how to use the ACE_Reactor for
+// devices that perform I/O via signals (such as SVR4 message queues).
+
+#include "ace/Log_Msg.h"
+#include "ace/Service_Config.h"
+
+// Used to shut down the event loop.
+static sig_atomic_t done = 0;
+
+// This class illustrates how to handle signal-driven I/O using the
+// ACE_Reactor framework.  Note that signals may be caught and
+// processed without requiring the use of global signal handler
+// functions or global signal handler data.
+
+class Sig_Handler : public ACE_Event_Handler
+{
+public:
+  Sig_Handler (void);
+  virtual ACE_HANDLE get_handle (void) const;
+  virtual int handle_input (ACE_HANDLE);
+  virtual int shutdown (ACE_HANDLE, ACE_Reactor_Mask);
+  virtual int handle_signal (ACE_HANDLE signum, siginfo_t * = 0, 
+			     ucontext_t * = 0);
+
+private:
+  ACE_HANDLE handle_;
+};
+
+// A dummy_handle is required to reserve a slot in the ACE_Reactor's
+// descriptor table.
+
+Sig_Handler::Sig_Handler (void)
+{
+  // Assign the Sig_Handler a dummy I/O descriptor.  Note that even
+  // though we open this file "Write Only" we still need to use the
+  // ACE_Event_Handler::NULL_MASK when registering this with the
+  // ACE_Reactor (see below).
+  this->handle_ = ACE_OS::open (ACE_DEV_NULL, O_WRONLY);
+  ACE_ASSERT (this->handle_ != -1);
+
+  // Register signal handler object.  Note that NULL_MASK is used to
+  // keep the ACE_Reactor from calling us back on the "/dev/null"
+  // descriptor.
+  if (ACE_Service_Config::reactor ()->register_handler 
+      (this, ACE_Event_Handler::NULL_MASK) == -1)
+    ACE_ERROR ((LM_ERROR, "%p\n%a", "register_handler", 1));
+
+  // Create a sigset_t corresponding to the signals we want to catch.
+  ACE_Sig_Set sig_set;
+
+  sig_set.sig_add (SIGINT);
+  sig_set.sig_add (SIGQUIT);
+  sig_set.sig_add (SIGALRM);  
+
+  // Register the signal handler object to catch the signals.
+  if (ACE_Service_Config::reactor ()->register_handler (sig_set, this) == -1)
+    ACE_ERROR ((LM_ERROR, "%p\n%a", "register_handler", 1));
+}
+
+// Called by the ACE_Reactor to extract the fd.
+
+ACE_HANDLE
+Sig_Handler::get_handle (void) const
+{
+  return this->handle_;
+}
+
+// In a real application, this method would be where the read on the
+// signal-driven I/O device would occur asynchronously.  For now we'll
+// just print a greeting to let you know that everything is working
+// properly!
+
+int 
+Sig_Handler::handle_input (ACE_HANDLE)
+{
+  ACE_DEBUG ((LM_DEBUG, "handling asynchonrous input...\n"));
+  return 0;
+}
+
+// In a real application, this method would do any cleanup activities
+// required when shutting down the I/O device.
+
+int 
+Sig_Handler::shutdown (ACE_HANDLE, ACE_Reactor_Mask)
+{
+  ACE_DEBUG ((LM_DEBUG, "closing down Sig_Handler...\n"));
+  return 0;
+}
+
+// This method handles all the signals that are being caught by this
+// object.  In our simple example, we are simply catching SIGALRM,
+// SIGINT, and SIGQUIT.  Anything else is logged and ignored.
+//
+// There are several advantages to using this approach.  First, 
+// the behavior triggered by the signal is handled in the main event
+// loop, rather than in the signal handler.  Second, the ACE_Reactor's 
+// signal handling mechanism eliminates the need to use global signal 
+// handler functions and data. 
+
+int
+Sig_Handler::handle_signal (int signum, siginfo_t *, ucontext_t *)
+{
+  ACE_DEBUG ((LM_DEBUG, "received signal %S\n", signum));
+
+  switch (signum)
+    {
+    case SIGALRM:
+      // Rearm the alarm.
+      ACE_OS::alarm (4);
+      break;
+    case SIGINT:
+      // Tell the ACE_Reactor to enable the ready bit for
+      // this->handle_.  The ACE_Reactor will subsequently call the
+      // Sig_Handler::handle_input method from within its event loop.
+      return ACE_Service_Config::reactor ()->ready_ops 
+	(this->handle_, ACE_Event_Handler::READ_MASK, ACE_Reactor::ADD_MASK);
+    case SIGQUIT:
+      ACE_DEBUG ((LM_DEBUG, "%S: shutting down signal tester\n", signum));
+      ACE_Service_Config::end_reactor_event_loop ();
+      break;
+    default: 
+      ACE_DEBUG ((LM_DEBUG, 
+		  "%S: not handled, returning to program\n", signum));
+      break;
+    }
+  return 0;
+}
+
+// This class illustrates that the ACE_Reactor can handle signals,
+// STDIO, and timeouts using the same mechanisms.
+
+class STDIN_Handler : public ACE_Event_Handler
+{
+public:
+  STDIN_Handler (void);
+  virtual int handle_input (ACE_HANDLE);
+  virtual int handle_timeout (const ACE_Time_Value &, 
+			      const void *arg);
+};
+
+STDIN_Handler::STDIN_Handler (void)
+{
+  if (ACE::register_stdin_handler (this,
+				   ACE_Service_Config::reactor (),
+				   ACE_Service_Config::thr_mgr ()) == -1)
+    ACE_ERROR ((LM_ERROR, "%p\n", "register_stdin_handler"));
+
+  // Register the STDIN_Handler to be dispatched once every second.
+  else if (ACE_Service_Config::reactor ()->schedule_timer
+	   (this, 0, ACE_Time_Value (1), ACE_Time_Value (1)) == -1)
+    ACE_ERROR ((LM_ERROR, "%p\n%a", "schedule_timer", 1));
+}
+
+int 
+STDIN_Handler::handle_timeout (const ACE_Time_Value &tv, 
+			       const void *arg)
+{
+  ACE_DEBUG ((LM_DEBUG, "timeout occurred at %d sec, %d usec\n",
+	      tv.sec (), tv.usec ()));
+  return 0;
+}
+
+// Read from input descriptor and write to stdout descriptor.
+
+int 
+STDIN_Handler::handle_input (ACE_HANDLE handle)
+{
+  ssize_t n;
+  char buf[BUFSIZ];
+
+  switch (n = ACE_OS::read (handle, buf, sizeof buf))
+    {
+    case -1:
+      if (errno == EINTR)
+	return 0;
+        /* NOTREACHED */
+      else
+	ACE_ERROR ((LM_ERROR, "%p\n", "read"));
+      /* FALLTHROUGH */
+    case 0:
+      ACE_Service_Config::end_reactor_event_loop ();
+      break;
+    default:
+      {
+	ssize_t result = ACE::write_n (ACE_STDOUT, buf, n);
+
+	if (result != n)
+	  ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "write"), 
+			    result == -1 && errno == EINTR ? 0 : -1);
+      }
+    }
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  ACE_Service_Config daemon (argv [0]);
+
+  // Signal handler.
+  Sig_Handler sh;
+
+  // Define an I/O handler object.
+  STDIN_Handler ioh;
+
+  // Optionally start the alarm.
+  if (argc > 1)
+    ACE_OS::alarm (4);
+
+  // Loop handling signals and I/O events until SIGQUIT occurs.
+
+  while (daemon.reactor_event_loop_done () == 0)
+    daemon.run_reactor_event_loop ();
+
+  return 0;
+}
diff --git a/examples/Reactor/Misc/test_event_handler_t.cpp b/examples/Reactor/Misc/test_event_handler_t.cpp
new file mode 100644
index 00000000000..a28108baf10
--- /dev/null
+++ b/examples/Reactor/Misc/test_event_handler_t.cpp
@@ -0,0 +1,45 @@
+#include "ace/Log_Msg.h"
+// @(#)test_event_handler_t.cpp	1.1	10/18/96
+
+#include "ace/Event_Handler_T.h"
+
+#if defined (ACE_HAS_TEMPLATE_TYPEDEFS)
+
+class ACE_Sig_Handler
+{
+public:
+  ACE_Sig_Handler (void) {}
+  virtual ACE_HANDLE get_handle (void) const { return 0; }
+  virtual void set_handle (ACE_HANDLE) {}
+  virtual int handle_async_io (ACE_HANDLE) { return 0; }
+  virtual int shutdown (ACE_HANDLE, ACE_Reactor_Mask) { return 0; }
+  virtual int signal_handler (ACE_HANDLE signum
+#if defined (ACE_HAS_SIGINFO_T)
+    , siginfo_t * = 0, ucontext_t * = 0
+#endif /* ACE_HAS_SIGINFO_T */
+    )
+  {
+    return 0;
+  }
+};
+
+int 
+main (void)
+{
+  typedef ACE_Event_Handler_T<ACE_Sig_Handler> EH_SH;
+
+  // Tie the ACE_Event_Handler_T together with the methods from ACE_Sig_Handler.
+  EH_SH tied_sh (new ACE_Sig_Handler, 1,
+		 &ACE_Sig_Handler::get_handle,
+		 &ACE_Sig_Handler::handle_async_io,
+		 &ACE_Sig_Handler::shutdown,
+		 &ACE_Sig_Handler::signal_handler);
+  return 0;
+}
+#else
+int
+main (void)
+{
+  ACE_ERROR_RETURN ((LM_ERROR, "your platform does not support template typedefs\n"), 1);
+}
+#endif /* ACE_HAS_TEMPLATE_TYPEDEFS */
diff --git a/examples/Reactor/Misc/test_handle_set.cpp b/examples/Reactor/Misc/test_handle_set.cpp
new file mode 100644
index 00000000000..65e7db3fc67
--- /dev/null
+++ b/examples/Reactor/Misc/test_handle_set.cpp
@@ -0,0 +1,75 @@
+#include "ace/Log_Msg.h"
+// @(#)test_handle_set.cpp	1.1	10/18/96
+
+#include "ace/Handle_Set.h"
+
+#define IS_ODD(X) (((X) & 1) != 0)
+
+void
+test1 (int count)
+{
+  int duplicates = 0;
+  int sets	 = 0;
+  int clears	 = 0;
+
+  ACE_Handle_Set handle_set;
+
+  ACE_OS::srand (ACE_OS::time (0L));
+
+  for (int i = 0; i < count; i++)
+    {
+      int i = int (ACE_OS::rand () % ACE_Handle_Set::MAXSIZE);
+
+      if (IS_ODD (i))
+	{
+	  if (handle_set.is_set (i))
+	    duplicates++;
+
+	  handle_set.set_bit (i);
+	  sets++;
+	}
+      else
+	{
+	  if (handle_set.is_set (i))
+	    duplicates--;
+
+	  handle_set.clr_bit (i);
+	  clears++;
+	}
+    }
+
+  ACE_DEBUG ((LM_DEBUG, "count = %d, set_size = %d, duplicates = %d\n",
+	      count, handle_set.num_set (), (sets - clears) == duplicates));
+}
+
+void
+test2 (void)
+{
+  ACE_Handle_Set handle_set;
+  ACE_HANDLE handle;
+
+  handle_set.set_bit (0);
+  handle_set.set_bit (1);
+  handle_set.set_bit (32);
+  handle_set.set_bit (63);
+  handle_set.set_bit (64);
+  handle_set.set_bit (65);
+  handle_set.set_bit (122);
+  handle_set.set_bit (129);
+  handle_set.set_bit (245);
+  handle_set.set_bit (255);
+
+  for (ACE_Handle_Set_Iterator fi (handle_set); 
+       (handle = fi ()) != -1; 
+       ++fi)
+    ACE_DEBUG ((LM_DEBUG, "handle = %d\n", handle));
+}
+
+int
+main (int argc, char *argv[])
+{
+  int count = argc > 1 ? ACE_OS::atoi (argv[1]) : ACE_Handle_Set::MAXSIZE;
+  test1 (count);
+  test2 ();
+}
+
diff --git a/examples/Reactor/Misc/test_reactors.cpp b/examples/Reactor/Misc/test_reactors.cpp
new file mode 100644
index 00000000000..81bc1c3a20d
--- /dev/null
+++ b/examples/Reactor/Misc/test_reactors.cpp
@@ -0,0 +1,205 @@
+// Perform a torture test of multiple ACE_Reactors and ACE_Tasks in
+// @(#)test_reactors.cpp	1.1	10/18/96
+
+// the same process...  Thanks to Detlef Becker for contributing this.
+
+#include "ace/Reactor.h"
+#include "ace/Synch.h"
+#include "ace/Service_Config.h"
+#include "ace/Task.h"
+
+#if defined (ACE_HAS_THREADS)
+
+static const int NUM_INVOCATIONS = 10;
+static const int MAX_TASKS = 20;
+
+class Test_Task : public ACE_Task<ACE_MT_SYNCH>
+{
+public:
+  Test_Task (void);
+  ~Test_Task (void);
+
+  virtual int open (void *args = 0);
+  virtual int close (u_long flags = 0);
+  virtual int put (ACE_Message_Block *, ACE_Time_Value *tv = 0);
+  virtual int svc (void);
+
+  virtual int handle_input (ACE_HANDLE handle);
+  virtual int handle_close (ACE_HANDLE fd, 
+			    ACE_Reactor_Mask close_mask);
+
+private:
+  ACE_Reactor *r_;
+  int handled_;
+
+  static int task_count_;
+};
+
+int Test_Task::task_count_ = 0;
+
+static ACE_Atomic_Op<ACE_Thread_Mutex, u_long> done_count = MAX_TASKS * 2;
+
+static ACE_Recursive_Thread_Mutex reclock_;
+
+Test_Task::Test_Task (void)
+  : handled_ (0)
+{
+  ACE_GUARD (ACE_Recursive_Thread_Mutex, ace_mon, reclock_);
+
+  Test_Task::task_count_++;
+  ACE_DEBUG ((LM_DEBUG, 
+	      "(%t) TT+ Test_Task::task_count_ = %d\n", 
+	      Test_Task::task_count_));
+}
+
+Test_Task::~Test_Task (void)
+{
+  ACE_GUARD (ACE_Recursive_Thread_Mutex, ace_mon, reclock_);
+
+  ACE_DEBUG ((LM_DEBUG, 
+	      "(%t) TT- Test_Task::task_count_ = %d\n", 
+	      Test_Task::task_count_));
+}
+
+int 
+Test_Task::open (void *args)
+{
+  r_ = (ACE_Reactor *) args;
+  return this->activate (THR_NEW_LWP);
+}
+
+int 
+Test_Task::close (u_long flags)
+{
+  ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, reclock_, -1);
+
+  Test_Task::task_count_--;
+  ACE_DEBUG ((LM_DEBUG, 
+	      "(%t) close Test_Task::task_count_ = %d\n", 
+	      Test_Task::task_count_));
+  return 0;
+}
+
+int 
+Test_Task::put (ACE_Message_Block *mb, 
+		ACE_Time_Value *tv)
+{
+  return 0;
+}
+
+int 
+Test_Task::svc (void)
+{
+  for (int i = 0; i < NUM_INVOCATIONS; i++)
+    {
+      ACE_OS::thr_yield ();
+
+      // ACE_DEBUG ((LM_DEBUG, "(%t) calling notify %d\n", i));
+
+      if (r_->notify (this, ACE_Event_Handler::READ_MASK) == -1)
+	ACE_ERROR_RETURN ((LM_ERROR, "(%t) %p\n", "notify"), -1);
+      
+      // ACE_DEBUG ((LM_DEBUG, "(%t) leaving notify %d\n", i));
+    }
+
+  return 0;
+}
+
+int 
+Test_Task::handle_close (ACE_HANDLE fd, 
+			 ACE_Reactor_Mask close_mask)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) handle_close\n"));
+  return 0;
+}
+
+int 
+Test_Task::handle_input (ACE_HANDLE fd)
+{
+  ACE_DEBUG ((LM_DEBUG, "(%t) handle_input\n"));
+
+  this->handled_++;
+
+  if (this->handled_ == NUM_INVOCATIONS)
+    {
+      done_count--;
+      ACE_DEBUG ((LM_DEBUG, 
+		  "(%t) handle_input, handled_ = %d, done_count = %d\n",
+		  this->handled_, (u_long) done_count));
+    }
+
+  ACE_OS::thr_yield ();
+  return -1;
+}
+
+static void *
+worker (void *args)
+{
+  ACE_Thread_Control tc (ACE_Service_Config::thr_mgr ());
+  ACE_Reactor *reactor = (ACE_Reactor *) args;
+
+  reactor->owner (ACE_Thread::self ());
+
+  ACE_Time_Value timeout (4);
+
+  for (;;)
+    {
+      //ACE_DEBUG ((LM_DEBUG, "(%t) calling handle_events\n"));
+
+      switch (reactor->handle_events (timeout))
+	{
+	case -1:
+	  ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "reactor"), 0);
+	  /* NOTREACHED */
+	case 0:
+	  ACE_ERROR_RETURN ((LM_ERROR, "timeout\n"), 0);
+	  /* NOTREACHED */
+	}
+
+      // ACE_DEBUG ((LM_DEBUG, "(%t) done with handle_events\n"));
+
+    }
+
+  return 0;
+}
+
+int 
+main (void)
+{
+  ACE_Reactor *react1 = ACE_Service_Config::reactor ();
+  ACE_Reactor *react2 = new ACE_Reactor ();
+  Test_Task tt1[MAX_TASKS];
+  Test_Task tt2[MAX_TASKS];
+
+  for (int i = 0; i < MAX_TASKS; i++)
+    {
+      tt1[i].open (react1);
+      tt2[i].open (react2);
+    }
+
+  if (ACE_Service_Config::thr_mgr ()->spawn 
+      (ACE_THR_FUNC (worker), (void *) react1, THR_NEW_LWP) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "spawn"), -1);
+
+  else if (ACE_Service_Config::thr_mgr ()->spawn 
+      (ACE_THR_FUNC (worker), (void *) react2, THR_NEW_LWP) == -1)
+    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "spawn"), -1);
+
+  ACE_Service_Config::thr_mgr ()->wait ();
+  ACE_DEBUG ((LM_DEBUG, "(%t) done\n"));
+
+  return 42;
+}
+
+#if defined (ACE_TEMPLATES_REQUIRE_SPECIALIZATION)
+template class ACE_Atomic_Op<ACE_Thread_Mutex, u_long>;
+#endif /* ACE_TEMPLATES_REQUIRE_SPECIALIZATION */
+
+#else
+int 
+main (int, char *[])
+{
+  ACE_ERROR ((LM_ERROR, "threads not supported on this platform\n"));
+  return 0;
+}
+#endif /* ACE_HAS_THREADS */
diff --git a/examples/Reactor/Misc/test_signals.cpp b/examples/Reactor/Misc/test_signals.cpp
new file mode 100644
index 00000000000..b3725f66c89
--- /dev/null
+++ b/examples/Reactor/Misc/test_signals.cpp
@@ -0,0 +1,226 @@
+// Test the ability of the Reactor/Signal_Handler to register multiple
+// @(#)test_signals.cpp	1.1	10/18/96
+
+// handler per-signal.
+
+/* This test works as follows:
+	
+	1. To test the "original" semantics of ACE (i.e., only one
+	   ACE_Event_Handler can be registered per signal), you don't
+	   need to do anything special.  Existing programs work the
+	   same since giving the Reactor's constructor a 0 value
+	   (which is the default argument, BTW) instructs it to behave
+	   as before.  When a 0 is given, the ACE_Reactor's
+	   constructor/open method creates an instance of
+	   ACE_Sig_Handler and assigns this to an internal pointer.
+	   This pointer is then used to dispatch all signal-related
+	   methods within the Reactor.  The default ACE_Sig_Handler
+	   only allows *one* ACE_Event_Handler to be registered
+	   per-signal.
+
+	   To run this version of the test do the following:
+  
+	   % ./test-signal
+	   ./test_signals
+	   waiting for SIGINT or SIGQUIT
+	   ^C
+	   signal Interrupt occurred in Sig_Handler_2 (fruity, 0, 0) with count = 1
+	   waiting for SIGINT or SIGQUIT
+	   ^\
+	   signal Quit occurred in Sig_Handler_2 (fruity, 0, 0) with count = 2
+	   shutting down SIGQUIT in Sig_Handler_2 (fruity, 0, 0)
+	   waiting for SIGINT or SIGQUIT
+	   ^C
+	   signal Interrupt occurred in Sig_Handler_2 (fruity, 0, 0) with count = 3
+	   waiting for SIGINT or SIGQUIT
+	   ^\Quit (core dumped)
+
+           Note that in this test only one handler (the last one --
+	   "Sig_Handler_2 (fruity)") is actually registered.  BTW, the
+	   core dump is the expected behavior since the default
+	   disposition is restored when there are no more handlers
+	   (see the code below).
+
+	2. To test the "multiple handlers per-signal semantics", you
+	   need to pass the constructor/open method of the ACE_Reactor
+	   a pointer to a an instance of ACE_Sig_Handlers (note the
+	   plural "s").  ACE_Sig_Handlers is a class that derives from
+	   ACE_Sig_Handler.  The difference between these two classes
+	   is that (1) ACE_Sig_Handlers::register_signal allows
+	   multiple ACE_Event_Handlers to be registered per-signal and
+	   (2) it enables SA_RESTART by default.  This class also
+	   implements Detlef Becker's algorithm for integrating ACE
+	   signal handling with 3rd party libraries.
+
+	   To run this version of the test do the following:
+  
+	   % ./test_signals 1
+
+	   waiting for SIGINT or SIGQUIT
+	   ^C
+	   signal Interrupt occurred in external handler!
+	   signal Interrupt occurred in Sig_Handler_1 (howdy, 3, 1) with count = 1
+	   shutting down SIGINT in Sig_Handler_1 (howdy, 3, 1)
+	   signal Interrupt occurred in Sig_Handler_1 (doody, 5, 4) with count = 1
+	   shutting down SIGINT in Sig_Handler_1 (doody, 5, 4)
+	   signal Interrupt occurred in Sig_Handler_2 (tutty, 7, 6) with count = 1
+	   signal Interrupt occurred in Sig_Handler_2 (fruity, 9, 8) with count = 1
+	   waiting for SIGINT or SIGQUIT
+	   ^\
+	   signal Quit occurred in Sig_Handler_1 (howdy, 3, 1) with count = 2
+	   shutting down SIGQUIT in Sig_Handler_1 (howdy, 3, 1)
+	   signal Quit occurred in Sig_Handler_1 (doody, 5, 4) with count = 2
+	   shutting down SIGQUIT in Sig_Handler_1 (doody, 5, 4)
+	   signal Quit occurred in Sig_Handler_2 (tutty, 7, 6) with count = 2
+	   shutting down SIGQUIT in Sig_Handler_2 (tutty, 7, 6)
+	   signal Quit occurred in Sig_Handler_2 (fruity, 9, 8) with count = 2
+	   shutting down SIGQUIT in Sig_Handler_2 (fruity, 9, 8)
+	   waiting for SIGINT or SIGQUIT
+	   ^C
+	   signal Interrupt occurred in external handler!
+	   signal Interrupt occurred in Sig_Handler_2 (tutty, 7, 6) with count = 3
+	   signal Interrupt occurred in Sig_Handler_2 (fruity, 9, 8) with count = 3
+	   waiting for SIGINT or SIGQUIT
+	   ^\Quit (core dumped)
+
+           When this test begins all four handlers are registered and
+           dispatched when a SIGINT or SIGQUIT occurs.  After the
+           first SIGINT, the handle_signal method of the Sig_Handler_1
+           objects unregister themselves.  At that point there are 4
+           SIGQUIT handlers left, but only 2 of our SIGINT handlers
+           left (and the 1 external handler).  After the first
+           SIGQUIT, there are no SIGQUIT handlers left since they all
+           deregister themselves (which restores the "SIG_DFL"
+           disposition).  On the second SIGINT there are only 3
+           handlers left (2 of ours and 1 external).  Finally, on the
+           second SIGQUIT we exit and dump core since that's what
+           happens with the default disposition for SIGQUIT. */
+
+#include "ace/Log_Msg.h"
+#include "ace/Reactor.h"
+
+class Sig_Handler_1 : public ACE_Event_Handler
+{
+public:
+  Sig_Handler_1 (ACE_Reactor &reactor, char *msg)
+    : msg_ (msg),
+      count_ (0),
+      reactor_ (reactor)
+  {
+    // Register the signal handlers.
+    this->quit_sigkey_ = reactor.register_handler (SIGQUIT, this);
+    this->int_sigkey_ = reactor.register_handler (SIGINT, this);
+
+    if (this->quit_sigkey_ == -1 || this->int_sigkey_ == -1)
+      ACE_ERROR ((LM_ERROR, "%p\n", "register_handler"));
+  }
+
+  virtual int handle_signal (int signum, siginfo_t *, ucontext_t *)
+  {
+    this->count_++;
+    ACE_DEBUG ((LM_DEBUG, 
+	       "\nsignal %S occurred in Sig_Handler_1 (%s, %d, %d) with count = %d",
+	       signum, this->msg_, this->int_sigkey_, this->quit_sigkey_, this->count_));
+    if (this->count_ != 1 && signum == SIGQUIT)
+      {
+	if (this->reactor_.remove_handler (SIGQUIT, 0, 0,
+					   this->quit_sigkey_) == -1)
+	  ACE_ERROR ((LM_ERROR, "\n%p", "remove_handler"));
+	else
+	  ACE_DEBUG ((LM_DEBUG, "\nshutting down SIGQUIT in Sig_Handler_1 (%s, %d, %d)",
+		     this->msg_, this->int_sigkey_, this->quit_sigkey_));
+      }
+    else if (this->count_ != 2 && signum == SIGINT)
+      {
+	if (this->reactor_.remove_handler (SIGINT, 0, 0,
+					   this->int_sigkey_) == -1)
+	  ACE_ERROR ((LM_ERROR, "\n%p", "remove_handler"));
+	else
+	  ACE_DEBUG ((LM_DEBUG, "\nshutting down SIGINT in Sig_Handler_1 (%s, %d, %d)",
+		     this->msg_, this->int_sigkey_, this->quit_sigkey_));
+      }
+    return 0;
+  }
+
+protected:
+  char *msg_;
+  int count_;
+  int int_sigkey_;
+  int quit_sigkey_;
+  ACE_Reactor &reactor_;
+};
+
+class Sig_Handler_2 : public Sig_Handler_1
+{
+public:
+  Sig_Handler_2 (ACE_Reactor &reactor, char *msg)
+    : Sig_Handler_1 (reactor, msg)
+  {
+  }
+
+  virtual int handle_signal (int signum, siginfo_t *, ucontext_t *)
+  {
+    this->count_++;
+    ACE_DEBUG ((LM_DEBUG, 
+	       "\nsignal %S occurred in Sig_Handler_2 (%s, %d, %d) with count = %d",
+	       signum, this->msg_, this->int_sigkey_, this->quit_sigkey_, this->count_));
+    if (this->count_ != 0 && signum == SIGQUIT)
+      {
+	if (this->reactor_.remove_handler (SIGQUIT, 0, 0,
+					   this->quit_sigkey_) == -1)
+	  ACE_ERROR ((LM_ERROR, "\n%p", "remove_handler"));
+	else
+	  ACE_DEBUG ((LM_DEBUG, "\nshutting down SIGQUIT in Sig_Handler_2 (%s, %d, %d)",
+		     this->msg_, this->int_sigkey_, this->quit_sigkey_));
+      }
+    else
+      return 0;
+  }
+};
+
+static void
+external_handler (int signum)
+{
+  ACE_DEBUG ((LM_DEBUG, "\nsignal %S occurred in external handler!", signum));
+}
+
+#if !defined (HPUX)
+int 
+main (int argc, char *argv)
+{
+  // If argc > 1 then allow multiple handlers per-signal, else just
+  // allow 1 handler per-signal.
+  ACE_Sig_Handlers multi_handlers;
+
+  ACE_Reactor reactor (argc > 1 ? &multi_handlers: 0);
+
+  if (argc > 1)
+    {
+      // Register an "external" signal handler so that the
+      // ACE_Sig_Handlers code will have something to incorporate!
+      ACE_SignalHandler eh = ACE_SignalHandler (external_handler);
+      ACE_Sig_Action sa (eh);
+
+      sa.register_action (SIGINT);
+    }
+
+  // Create a bevy of handlers.
+  Sig_Handler_1 h1 (reactor, "howdy"), h2 (reactor, "doody");
+  Sig_Handler_2 h3 (reactor, "tutty"), h4 (reactor, "fruity");
+
+  // Wait for user to type SIGINT and SIGQUIT.
+
+  for (;;)
+    {
+      ACE_DEBUG ((LM_DEBUG, "\nwaiting for SIGINT or SIGQUIT\n"));
+      reactor.handle_events ();
+    }
+  return 0;
+}
+#else
+int
+main (void)
+{
+  ACE_ERROR_RETURN ((LM_ERROR, "The HP C++ compiler is too lame to support this feature\n"), -1);
+}
+#endif /* HPUX */
diff --git a/examples/Reactor/Misc/test_time_value.cpp b/examples/Reactor/Misc/test_time_value.cpp
new file mode 100644
index 00000000000..691528eb292
--- /dev/null
+++ b/examples/Reactor/Misc/test_time_value.cpp
@@ -0,0 +1,69 @@
+#include "ace/ACE.h"
+// @(#)test_time_value.cpp	1.1	10/18/96
+
+
+inline int my_abs (int d) { return d > 0 ? d : -d; }
+
+ostream &
+operator<< (ostream &stream, const ACE_Time_Value &tv)
+{
+  if (tv.usec () < 0 || tv.sec () < 0)
+    stream << "-";
+
+  stream << dec << my_abs (int (tv.sec ())) << "."
+//	 << setw (6) << setfill ('0') 
+	 << dec << my_abs (int (tv.usec ()));
+  return stream;
+}
+
+int
+main (int argc, char *argv[])
+{
+  ACE_Time_Value tv1;
+  ACE_Time_Value tv2 (2);
+  ACE_Time_Value tv3 (100);  
+  ACE_Time_Value tv4 (1, 1000000);
+  ACE_Time_Value tv5 (2);
+  ACE_Time_Value tv6 (1, -1000000);
+
+  ACE_ASSERT (tv1 == ACE_Time_Value (0));
+  ACE_ASSERT (tv2 < tv3);
+  ACE_ASSERT (tv2 <= tv2);
+  ACE_ASSERT (tv2 >= tv4);
+  ACE_ASSERT (tv5 >= tv6);
+  ACE_ASSERT (tv2 == ACE_Time_Value (1, 1000000));
+  ACE_ASSERT (tv5 == tv4);
+  ACE_ASSERT (tv2 == tv4);
+  ACE_ASSERT (tv1 != tv2);
+  ACE_ASSERT (tv6 == tv1);
+
+  cout << "0,0 :\t\t"        << ACE_Time_Value (0,0) << endl;
+  cout << "-0,0 :\t\t"       << ACE_Time_Value (-0,0) << endl;
+  cout << "0,-0 :\t\t"       << ACE_Time_Value (0,-0) << endl;
+  cout << "-0,-0 :\t\t"      << ACE_Time_Value (-0,-0) << endl;
+  cout << endl;
+
+  cout << "0,1 :\t\t"        << ACE_Time_Value (0,1) << endl;
+  cout << "1,0 :\t\t"        << ACE_Time_Value (1,0) << endl;
+  cout << "-1,0 :\t\t"       << ACE_Time_Value (-1,0) << endl;
+  cout << "-1,-0 :\t\t"      << ACE_Time_Value (-1,-0) << endl;
+  cout << endl;
+
+  cout << "1,1 :\t\t"        << ACE_Time_Value (1,1) << endl;
+  cout << "-1,1 :\t\t"       << ACE_Time_Value (-1,1) << endl;
+  cout << "1,-1 :\t\t"       << ACE_Time_Value (1,-1) << endl;
+  cout << "-1,-1 :\t\t"      << ACE_Time_Value (-1,-1) << endl;
+  cout << endl;
+
+  cout << "1,-1111111 :\t"   << ACE_Time_Value (1,-1111111) << endl;
+  cout << "1,-100000 :\t"    << ACE_Time_Value (1,-100000) << endl;
+  cout << "1,-1000000 :\t"   << ACE_Time_Value (1,-1000000) << endl;
+  cout << "-1,1000000 :\t"   << ACE_Time_Value (-1,1000000) << endl;
+  cout << "5,-1000000 :\t"   << ACE_Time_Value (5,-1000000) << endl;
+  cout << "5,-1500000 :\t"   << ACE_Time_Value (5,-1500000) << endl;
+  cout << "2,-2500000 :\t"   << ACE_Time_Value (2,-2500000) << endl;
+  cout << "2,-4500000 :\t"   << ACE_Time_Value (2,-4500000) << endl;
+
+  return 0;
+}
+
diff --git a/examples/Reactor/Misc/test_timer_queue.cpp b/examples/Reactor/Misc/test_timer_queue.cpp
new file mode 100644
index 00000000000..4e7010d1e94
--- /dev/null
+++ b/examples/Reactor/Misc/test_timer_queue.cpp
@@ -0,0 +1,47 @@
+#include "ace/Log_Msg.h"
+// @(#)test_timer_queue.cpp	1.1	10/18/96
+
+#include "ace/Timer_Queue.h"
+
+class Example_Handler : public ACE_Event_Handler
+{
+public:
+  Example_Handler (void)
+    : count_ (0) 
+  {}
+
+  virtual int handle_timeout (const ACE_Time_Value &tv, const void *arg)
+  {
+    ACE_DEBUG ((LM_DEBUG, "yow, the time has come and gone %d times %d, Horatio!\n", 
+		this->count_++, int (arg)));
+    return 0;
+  }
+
+private:
+  int count_;
+};
+
+int
+main (int argc, char *argv[])
+{
+  ACE_Timer_Queue tq;
+  Example_Handler eh;
+
+  ACE_ASSERT (tq.is_empty ());
+  ACE_ASSERT (ACE_Time_Value::zero == ACE_Time_Value (0));
+  int timer_id; 
+  
+  timer_id = tq.schedule (&eh, (const void *) 1, ACE_OS::gettimeofday ());
+  tq.schedule (&eh, (const void *) 2, ACE_OS::gettimeofday ());
+  tq.schedule (&eh, (const void *) 3, ACE_OS::gettimeofday ());
+  tq.cancel (timer_id);
+  ACE_ASSERT (!tq.is_empty ());
+  tq.expire (ACE_OS::gettimeofday ());
+  tq.schedule (&eh, (const void *) 4, ACE_OS::gettimeofday ());
+  tq.schedule (&eh, (const void *) 5, ACE_OS::gettimeofday ());
+  tq.cancel (&eh);
+  ACE_ASSERT (tq.is_empty ());
+  tq.expire (ACE_OS::gettimeofday ());
+  return 0;
+}
+