*** empty log message ***

6 files changed, 162 insertions, 98 deletions

diff --git a/ChangeLog-98b b/ChangeLog-98b
index 6fa5e2095fb..d8e3f607658 100644
--- a/ChangeLog-98b
+++ b/ChangeLog-98b
@@ -1,5 +1,8 @@
 Tue Aug 25 20:04:09 1998  Douglas C. Schmidt  <schmidt@tango.cs.wustl.edu>
 
+	* ace/config-hpux11.h: Added ACE_HAS_AIO_CALLS.  Thanks to John
+ 	  Mulhern for verifying this.
+
 	* etc: Began to add the ACE tutorials.  Thanks to James CE Johnson
  	  <ace-users@lads.com> for contributing this stuff.
 
diff --git a/ace/config-hpux11.h b/ace/config-hpux11.h
index 2eef9019a0a..a0d65152816 100644
--- a/ace/config-hpux11.h
+++ b/ace/config-hpux11.h
@@ -223,6 +223,7 @@
 #endif /* ACE_HAS_THREADS */
 
 #define ACE_HAS_POSIX_SEM
+#define ACE_HAS_AIO_CALLS
 
 // Turns off the tracing feature.
 // To build with tracing enabled, make sure ACE_NTRACE is not defined
diff --git a/tests/Reactor_Exceptions_Test.cpp b/tests/Reactor_Exceptions_Test.cpp
index 553e39a73fe..04080ccf19f 100644
--- a/tests/Reactor_Exceptions_Test.cpp
+++ b/tests/Reactor_Exceptions_Test.cpp
@@ -148,22 +148,24 @@ main (int argc, ASYS_TCHAR *argv[])
   ACE_START_TEST (ASYS_TEXT ("Reactor_Exceptions_Test"));
 
 #if defined (ACE_HAS_EXCEPTIONS)
-  My_Reactor reactor;
-
-  u_short port = argc > 1 ? ACE_OS::atoi (argv[1]) : ACE_DEFAULT_SERVER_PORT;
-
   ACE_DEBUG ((LM_DEBUG,
               ASYS_TEXT ("Starting tracing\n")));
 
-  ACE_Reactor::instance (&reactor);
-  ACE_Thread_Manager *thr_mgr =
-    ACE_Thread_Manager::instance ();
+  u_short port = argc > 1 ? ACE_OS::atoi (argv[1]) : ACE_DEFAULT_SERVER_PORT;
 
   ACE_INET_Addr local_addr (port);
   ACE_INET_Addr remote_addr (port,
                              ACE_DEFAULT_SERVER_HOST);
+  // Put the <handler> before the <reactor> so that they'll be cleaned
+  // up in the proper order.
   My_Handler handler (local_addr);
 
+  My_Reactor reactor;
+
+  ACE_Reactor::instance (&reactor);
+  ACE_Thread_Manager *thr_mgr =
+    ACE_Thread_Manager::instance ();
+
   if (ACE_Reactor::instance ()->register_handler
       (&handler,
        ACE_Event_Handler::READ_MASK) == -1)
@@ -183,8 +185,9 @@ main (int argc, ASYS_TCHAR *argv[])
   ACE_SOCK_Dgram dgram ((ACE_INET_Addr &) ACE_Addr::sap_any);
 
   for (size_t i = 0; i < ACE_MAX_ITERATIONS; i++)
-    dgram.send (ASYS_TEXT ("Hello"), sizeof (ASYS_TEXT ("Hello")), remote_addr);
-
+    dgram.send (ASYS_TEXT ("Hello"),
+                sizeof (ASYS_TEXT ("Hello")),
+                remote_addr);
   // Barrier to wait for the other thread to return.
   thr_mgr->wait ();
 
diff --git a/tests/Reactor_Performance_Test.cpp b/tests/Reactor_Performance_Test.cpp
index cfbd2b28ab5..12680e3e04c 100644
--- a/tests/Reactor_Performance_Test.cpp
+++ b/tests/Reactor_Performance_Test.cpp
@@ -71,13 +71,17 @@ Read_Handler::open (void *)
 {
   if (this->peer ().enable (ACE_NONBLOCK) == -1)
     ACE_ERROR_RETURN ((LM_ERROR,
-                       ASYS_TEXT ("(%t) Read_Handler::open, cannot set non blocking mode\n")), -1);
+                       ASYS_TEXT ("(%t) Read_Handler::open, cannot set non blocking mode\n")),
+                      -1);
 
   if (reactor ()->register_handler (this, READ_MASK) == -1)
     ACE_ERROR_RETURN ((LM_ERROR,
-                       ASYS_TEXT ("(%t) Read_Handler::open, cannot register handler\n")), -1);
+                       ASYS_TEXT ("(%t) Read_Handler::open, cannot register handler\n")),
+                      -1);
 
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("(%t) created svc_handler for handle %d\n"), get_handle ()));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("(%t) created svc_handler for handle %d\n"),
+              get_handle ()));
   return 0;
 }
 
@@ -90,22 +94,25 @@ Read_Handler::handle_input (ACE_HANDLE handle)
   char buf[BUFSIZ];
 
   ssize_t result = this->peer ().recv (buf, sizeof (buf));
+
   if (result <= 0)
     {
       if (result < 0 && errno == EWOULDBLOCK)
         return 0;
 
       if (result != 0)
-        ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("(%t) %p\n"), ASYS_TEXT ("Read_Handler::handle_input")));
-
-      // This will cause handle_close to get called
+        ACE_DEBUG ((LM_DEBUG,
+                    ASYS_TEXT ("(%t) %p\n"),
+                    ASYS_TEXT ("Read_Handler::handle_input")));
+      // This will cause handle_close to get called.
       return -1;
     }
 
   return 0;
 }
 
-// Handle connection shutdown
+// Handle connection shutdown.
+
 int
 Read_Handler::handle_close (ACE_HANDLE handle,
                             ACE_Reactor_Mask close_mask)
@@ -113,14 +120,12 @@ Read_Handler::handle_close (ACE_HANDLE handle,
   ACE_UNUSED_ARG (handle);
   ACE_UNUSED_ARG (close_mask);
 
-  // Reduce count
-  waiting_--;
+  // Reduce count.
+  this->waiting_--;
 
-  // If no connections are open
+  // If no connections are open.
   if (waiting_ == 0)
-    {
-      ACE_Reactor::instance ()->end_event_loop ();
-    }
+    ACE_Reactor::instance ()->end_event_loop ();
 
   ACE_DEBUG ((LM_DEBUG,
               ASYS_TEXT ("(%t) Read_Handler::handle_close closing down\n")));
@@ -130,7 +135,6 @@ Read_Handler::handle_close (ACE_HANDLE handle,
   return 0;
 }
 
-
 int
 Write_Handler::open (void *)
 {
@@ -142,9 +146,12 @@ Write_Handler::send_data (void)
 {
   int send_size = sizeof (ACE_ALPHABET) - 1;
 
-  if (this->peer ().send_n (ACE_ALPHABET, send_size) != send_size)
-    ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("(%t) %p\n"), ASYS_TEXT ("send_n")), -1);
-
+  if (this->peer ().send_n (ACE_ALPHABET,
+                            send_size) != send_size)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       ASYS_TEXT ("(%t) %p\n"),
+                       ASYS_TEXT ("send_n")),
+                      -1);
   return 0;
 }
 
@@ -156,31 +163,39 @@ typedef ACE_Acceptor<Read_Handler, ACE_SOCK_ACCEPTOR> ACCEPTOR;
 void *
 client (void *arg)
 {
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("(%t) running client\n")));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("(%t) running client\n")));
 
-  ACE_INET_Addr *connection_addr = (ACE_INET_Addr*) arg;
+  ACE_INET_Addr *connection_addr =
+    ACE_reinterpret_cast (ACE_INET_Addr *, arg);
   CONNECTOR connector;
 
   int i;
 
-  // Automagic memory cleanup
+  // Automagic memory cleanup.
   ACE_Auto_Basic_Array_Ptr <Write_Handler *> writers;
   Write_Handler **temp_writers;
-  ACE_NEW_RETURN (temp_writers, Write_Handler *[opt_nconnections], 0);
+  ACE_NEW_RETURN (temp_writers,
+                  Write_Handler *[opt_nconnections],
+                  0);
   writers = temp_writers;
 
   ACE_Auto_Basic_Array_Ptr <ASYS_TCHAR> failed_svc_handlers;
   ASYS_TCHAR *temp_failed;
-  ACE_NEW_RETURN (temp_failed, ASYS_TCHAR[opt_nconnections], 0);
+  ACE_NEW_RETURN (temp_failed,
+                  ASYS_TCHAR[opt_nconnections],
+                  0);
   failed_svc_handlers = temp_failed;
 
-  // Automagic memory cleanup
+  // Automagic memory cleanup.
   ACE_Auto_Array_Ptr <ACE_INET_Addr> addresses;
   ACE_INET_Addr *temp_addresses;
-  ACE_NEW_RETURN (temp_addresses, ACE_INET_Addr [opt_nconnections], 0);
+  ACE_NEW_RETURN (temp_addresses,
+                  ACE_INET_Addr [opt_nconnections],
+                  0);
   addresses = temp_addresses;
 
-  // Initialize array
+  // Initialize array.
   for (i = 0; i < opt_nconnections; i++)
     {
       writers[i] = 0;
@@ -199,7 +214,8 @@ client (void *arg)
         if (failed_svc_handlers.get ()[i])
           {
             ACE_INET_Addr failed_addr = addresses.get()[i];
-            ACE_ERROR ((LM_ERROR, ASYS_TEXT ("(%t) connection failed to %s, %d\n"),
+            ACE_ERROR ((LM_ERROR,
+                        ASYS_TEXT ("(%t) connection failed to %s, %d\n"),
                         failed_addr.get_host_name (),
                         failed_addr.get_port_number ()));
           }
@@ -207,47 +223,53 @@ client (void *arg)
     }
 
   // If no connections failed (result == 0) then there should be valid
-  // ACE_Svc_handler pointers in each writers[] position.
-  // Iterate to send data
+  // ACE_Svc_handler pointers in each writers[] position.  Iterate to
+  // send data
   for (int j = 0; j < opt_nloops; j++)
     for (i = 0; i < opt_nconnections; i++)
       if (writers[i]->send_data () == -1)
-        ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("(%t) %p\n"), ASYS_TEXT ("writer::send_data")), 0);
-
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           ASYS_TEXT ("(%t) %p\n"),
+                           ASYS_TEXT ("writer::send_data")),
+                          0);
   // Cleanup
   for (i = 0; i < opt_nconnections; i++)
     writers[i]->destroy ();
 
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("(%t) finishing client\n")));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("(%t) finishing client\n")));
   return 0;
 }
 
-// Sets up the correct reactor (based on platform and options)
+// Sets up the correct reactor (based on platform and options).
+
 void
 create_reactor (void)
 {
   ACE_Reactor_Impl *impl = 0;
 
   if (opt_wfmo_reactor)
-    {
 #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
-      ACE_NEW (impl, ACE_WFMO_Reactor);
+      ACE_NEW (impl,
+               ACE_WFMO_Reactor);
 #endif /* ACE_WIN32 */
-    }
   else if (opt_select_reactor)
-    {
-      ACE_NEW (impl, ACE_Select_Reactor);
-    }
+    ACE_NEW (impl,
+             ACE_Select_Reactor);
+
   ACE_Reactor *reactor = 0;
-  ACE_NEW (reactor, ACE_Reactor (impl));
+  ACE_NEW (reactor,
+           ACE_Reactor (impl));
   ACE_Reactor::instance (reactor);
 }
 
-// Print stats
+// Print stats.
+
 void
 print_results (ACE_Profile_Timer::ACE_Elapsed_Time &et)
 {
   const ASYS_TCHAR *reactor_type = 0;
+
   if (opt_wfmo_reactor)
     reactor_type = ASYS_TEXT ("WFMO_Reactor");
   else if (opt_select_reactor)
@@ -255,12 +277,20 @@ print_results (ACE_Profile_Timer::ACE_Elapsed_Time &et)
   else
     reactor_type = ASYS_TEXT ("Platform's default Reactor");
 
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("\n\tReactor_Performance Test statistics:\n\n")));
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("\tReactor Type: %s\n"), reactor_type));
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("\tConnections: %d\n"), opt_nconnections));
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("\tIteration per connection: %d\n"), opt_nloops));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("\n\tReactor_Performance Test statistics:\n\n")));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("\tReactor Type: %s\n"),
+              reactor_type));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("\tConnections: %d\n"),
+              opt_nconnections));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("\tIteration per connection: %d\n"),
+              opt_nloops));
 
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("\n\tTiming results:\n")));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("\n\tTiming results:\n")));
   ACE_DEBUG ((LM_DEBUG,
               ASYS_TEXT ("\t\treal time = %f secs \n\t\tuser time = %f secs \n\t\tsystem time = %f secs\n\n"),
               et.real_time,
@@ -291,7 +321,7 @@ main (int argc, ASYS_TCHAR *argv[])
         break;
       }
 
-  // Sets up the correct reactor (based on platform and options)
+  // Sets up the correct reactor (based on platform and options).
   create_reactor ();
 
   // Manage memory automagically.
@@ -312,9 +342,13 @@ main (int argc, ASYS_TCHAR *argv[])
   // Bind acceptor to any port and then find out what the port was.
   if (acceptor.open ((const ACE_INET_Addr &) ACE_Addr::sap_any) == -1
       || acceptor.acceptor ().get_local_addr (server_addr) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("(%t) %p\n"), ASYS_TEXT ("open")), -1);
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       ASYS_TEXT ("(%t) %p\n"),
+                       ASYS_TEXT ("open")),
+                      -1);
 
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("(%t) starting server at port %d\n"),
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("(%t) starting server at port %d\n"),
               server_addr.get_port_number ()));
 
   ACE_INET_Addr connection_addr (server_addr.get_port_number (),
@@ -324,7 +358,9 @@ main (int argc, ASYS_TCHAR *argv[])
       (ACE_THR_FUNC (client),
        (void *) &connection_addr,
        THR_NEW_LWP | THR_DETACHED) == -1)
-    ACE_ERROR ((LM_ERROR, ASYS_TEXT ("(%t) %p\n"), ASYS_TEXT ("thread create failed")));
+    ACE_ERROR ((LM_ERROR,
+                ASYS_TEXT ("(%t) %p\n"),
+                ASYS_TEXT ("thread create failed")));
 
   ACE_Profile_Timer timer;
   timer.start ();
@@ -337,7 +373,8 @@ main (int argc, ASYS_TCHAR *argv[])
   // Print results
   print_results (et);
 
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("(%t) waiting for the client thread...\n")));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("(%t) waiting for the client thread...\n")));
 
   ACE_Thread_Manager::instance ()->wait ();
 
@@ -387,7 +424,8 @@ main (int, ASYS_TCHAR *[])
 {
   ACE_START_TEST (ASYS_TEXT ("Reactor_Performance_Test"));
 
-  ACE_ERROR ((LM_ERROR, ASYS_TEXT ("threads not supported on this platform\n")));
+  ACE_ERROR ((LM_ERROR,
+              ASYS_TEXT ("threads not supported on this platform\n")));
 
   ACE_END_TEST;
   return 0;
diff --git a/tests/Reactor_Timer_Test.cpp b/tests/Reactor_Timer_Test.cpp
index a5f0d6f6baa..0358d973164 100644
--- a/tests/Reactor_Timer_Test.cpp
+++ b/tests/Reactor_Timer_Test.cpp
@@ -43,14 +43,15 @@ public:
       long current_count = long (arg);
       ACE_ASSERT (current_count == count);
 
-      ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("%d: Timer #%d timed out at %d!\n"),
-                  count, current_count, tv.sec ()));
-
+      ACE_DEBUG ((LM_DEBUG,
+                  ASYS_TEXT ("%d: Timer #%d timed out at %d!\n"),
+                  count,
+                  current_count,
+                  tv.sec ()));
       count += (1 + odd);
 
-      if (long(current_count) == long(ACE_MAX_TIMERS - 1))
+      if (long (current_count) == long (ACE_MAX_TIMERS - 1))
         done = 1;
-
       return 0;
     }
 };
@@ -60,9 +61,12 @@ main (int, ASYS_TCHAR *[])
 {
   ACE_START_TEST (ASYS_TEXT ("Reactor_Timer_Test"));
 
+  // We put the <Time_Handler> first so that it'll still be alive when
+  // the <reactor> is closed down.
+  Time_Handler rt[ACE_MAX_TIMERS];
+
   ACE_Reactor reactor;
 
-  Time_Handler rt[ACE_MAX_TIMERS];
   int t_id[ACE_MAX_TIMERS];
 
   size_t i;
@@ -71,7 +75,6 @@ main (int, ASYS_TCHAR *[])
     t_id[i] = reactor.schedule_timer (&rt[i], 
 				      (const void *) i, 
 				      ACE_Time_Value (2 * i + 1));
-
   while (!done)
     reactor.handle_events ();
 
@@ -84,7 +87,6 @@ main (int, ASYS_TCHAR *[])
     t_id[i] = reactor.schedule_timer (&rt[0],
                                       (const void *) i,
                                       ACE_Time_Value (2 * i + 1));
-
   while (!done)
     reactor.handle_events ();
 
diff --git a/tests/Reactors_Test.cpp b/tests/Reactors_Test.cpp
index 27bdc48a1e2..d5414fdec07 100644
--- a/tests/Reactors_Test.cpp
+++ b/tests/Reactors_Test.cpp
@@ -52,7 +52,6 @@ public:
   virtual int handle_input (ACE_HANDLE handle);
   virtual int handle_close (ACE_HANDLE fd,
                             ACE_Reactor_Mask close_mask);
-
 private:
   size_t handled_;
   // Number of iterations handled.
@@ -94,7 +93,8 @@ Test_Task::~Test_Task (void)
 int
 Test_Task::open (void *args)
 {
-  this->reactor ((ACE_Reactor *) args);
+  this->reactor (ACE_reinterpret_cast (ACE_Reactor *, 
+                                       args));
   return this->activate (THR_NEW_LWP);
 }
 
@@ -104,16 +104,12 @@ Test_Task::close (u_long)
   ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, recursive_lock, -1);
 
   Test_Task::task_count_--;
+
   ACE_DEBUG ((LM_DEBUG,
               ASYS_TEXT ("(%t) close Test_Task::task_count_ = %d\n"),
               Test_Task::task_count_));
 
-  if (Test_Task::task_count_ < 0)
-#if !defined (ACE_HAS_WINCE)
-    abort ();
-#else
-    ACE_OS::exit ();
-#endif
+  ACE_ASSERT (Test_Task::task_count_ < 0);
 
   return 0;
 }
@@ -121,7 +117,8 @@ Test_Task::close (u_long)
 int
 Test_Task::svc (void)
 {
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("(%t) svc\n")));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("(%t) svc\n")));
 
   for (size_t i = 0; i < ACE_MAX_ITERATIONS; i++)
     {
@@ -135,9 +132,14 @@ Test_Task::svc (void)
                                     &timeout) == -1)
         {
           if (errno == ETIME)
-            ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("(%t) %p\n"), ASYS_TEXT ("notify() timed out")));
+            ACE_DEBUG ((LM_DEBUG,
+                        ASYS_TEXT ("(%t) %p\n"),
+                        ASYS_TEXT ("notify() timed out")));
           else
-            ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("(%t) %p\n"), ASYS_TEXT ("notify")), -1);
+            ACE_ERROR_RETURN ((LM_ERROR,
+                               ASYS_TEXT ("(%t) %p\n"),
+                               ASYS_TEXT ("notify")),
+                              -1);
         }
     }
 
@@ -160,7 +162,8 @@ Test_Task::handle_input (ACE_HANDLE)
       done_count--;
       ACE_DEBUG ((LM_DEBUG,
                   ASYS_TEXT ("(%t) handle_input, handled_ = %d, done_count = %d\n"),
-                  this->handled_, done_count.value ()));
+                  this->handled_,
+                  done_count.value ()));
     }
 
   ACE_OS::thr_yield ();
@@ -170,7 +173,8 @@ Test_Task::handle_input (ACE_HANDLE)
 static void *
 worker (void *args)
 {
-  ACE_Reactor *reactor = (ACE_Reactor *) args;
+  ACE_Reactor *reactor = ACE_reinterpret_cast (ACE_Reactor *, 
+                                               args);
 
   // Make this thread the owner of the Reactor's event loop.
   reactor->owner (ACE_Thread::self ());
@@ -179,22 +183,24 @@ worker (void *args)
   ACE_Time_Value timeout (4);
 
   for (;;)
-    {
-      switch (reactor->handle_events (timeout))
-        {
-        case -1:
-          ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("(%t) %p\n"), ASYS_TEXT ("reactor")), 0);
-          /* NOTREACHED */
-        case 0:
-          ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("(%t) Reactor shutdown\n")), 0);
-          /* NOTREACHED */
-        }
-    }
+    switch (reactor->handle_events (timeout))
+      {
+      case -1:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           ASYS_TEXT ("(%t) %p\n"),
+                           ASYS_TEXT ("reactor")),
+                          0);
+        /* NOTREACHED */
+      case 0:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           ASYS_TEXT ("(%t) Reactor shutdown\n")),
+                          0);
+        /* NOTREACHED */
+      }
 
   ACE_NOTREACHED (return 0);
 }
 
-
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 template class ACE_Atomic_Op<ACE_Thread_Mutex, int>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
@@ -233,20 +239,31 @@ main (int, ASYS_TCHAR *[])
       (ACE_THR_FUNC (worker),
        (void *) ACE_Reactor::instance (),
        THR_BOUND | THR_DETACHED) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("%p\n"), ASYS_TEXT ("spawn")), -1);
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       ASYS_TEXT ("%p\n"),
+                       ASYS_TEXT ("spawn")),
+                      -1);
 
   else if (ACE_Thread_Manager::instance ()->spawn
       (ACE_THR_FUNC (worker), (void *) &reactor,
        THR_BOUND | THR_DETACHED) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("%p\n"), ASYS_TEXT ("spawn")), -1);
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       ASYS_TEXT ("%p\n"),
+                       ASYS_TEXT ("spawn")),
+                      -1);
 
   if (ACE_Thread_Manager::instance ()->wait () == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, ASYS_TEXT ("%p\n"), ASYS_TEXT ("wait")), -1);
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       ASYS_TEXT ("%p\n"),
+                       ASYS_TEXT ("wait")),
+                      -1);
 
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("(%t) all threads are finished \n")));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("(%t) all threads are finished \n")));
 
 #else
-  ACE_ERROR ((LM_ERROR, ASYS_TEXT ("threads not supported on this platform\n")));
+  ACE_ERROR ((LM_ERROR,
+              ASYS_TEXT ("threads not supported on this platform\n")));
 #endif /* ACE_HAS_THREADS */
   ACE_END_TEST;
   return 0;