Tue Aug 14 23:28:07 UTC 2007 Abdullah Sowayan <abdullah.sowayan@lmco.com>

20 files changed, 383 insertions, 360 deletions

diff --git a/ACE/ChangeLog b/ACE/ChangeLog
index 31d395a6665..a7107e1fe59 100644
--- a/ACE/ChangeLog
+++ b/ACE/ChangeLog
@@ -1,3 +1,26 @@
+Tue Aug 14 23:28:07 UTC 2007  Abdullah Sowayan  <abdullah.sowayan@lmco.com>
+
+        * tests/ACE_Init_Test.h:
+        * tests/ACE_Init_TestDlg.h:
+        * tests/Based_Pointer_Test.cpp:
+        * tests/Basic_Types_Test.cpp:
+        * tests/Bug_2815_Regression_Test.cpp:
+        * tests/Bug_2820_Regression_Test.cpp:
+        * tests/Config_Test.h:
+        * tests/Config_Test.cpp:
+        * tests/Max_Default_Port_Test.cpp:
+        * tests/Mem_Map_Test.cpp:
+        * tests/Notification_Queue_Unit_Test.cpp:
+        * tests/QtReactor_Test.h:
+        * tests/QtReactor_Test.cpp:
+        * tests/Reactor_Notify_Test.cpp:
+        * tests/SOCK_Dgram_Test.cpp:
+        * tests/SV_Shared_Memory_Test.cpp:
+        * tests/Signal_Test.cpp:
+        * tests/Thread_Pool_Reactor_Test.cpp:
+        * tests/Vector_Test.cpp:
+          Untabify.
+
 Tue Aug 14 22:39:56 UTC 2007  Steve Huston  <shuston@riverace.com>
 
         * configure.ac: Run the epoll_create() check; don't just link it.
diff --git a/ACE/tests/ACE_Init_Test.h b/ACE/tests/ACE_Init_Test.h
index cd4d6d386f1..d4266376485 100644
--- a/ACE/tests/ACE_Init_Test.h
+++ b/ACE/tests/ACE_Init_Test.h
@@ -25,7 +25,7 @@
 #endif // _MSC_VER >= 1000
 
 #ifndef __AFXWIN_H__
-	#error include 'stdafx.h' before including this file for PCH
+  #error include 'stdafx.h' before including this file for PCH
 #endif
 
 #include "ACE_Init_Test_Resource.h"		// main symbols
diff --git a/ACE/tests/ACE_Init_TestDlg.h b/ACE/tests/ACE_Init_TestDlg.h
index 57f8acf491c..94dbac7ecbb 100644
--- a/ACE/tests/ACE_Init_TestDlg.h
+++ b/ACE/tests/ACE_Init_TestDlg.h
@@ -14,31 +14,31 @@ class CACE_Init_TestDlg : public CDialog
 {
 // Construction
 public:
-	CACE_Init_TestDlg(CWnd* pParent = 0);	// standard constructor
+  CACE_Init_TestDlg(CWnd* pParent = 0);  // standard constructor
 
 // Dialog Data
-	//{{AFX_DATA(CACE_Init_TestDlg)
-	enum { IDD = IDD_ACE_INIT_TEST_DIALOG };
-		// NOTE: the ClassWizard will add data members here
-	//}}AFX_DATA
+  //{{AFX_DATA(CACE_Init_TestDlg)
+  enum { IDD = IDD_ACE_INIT_TEST_DIALOG };
+  // NOTE: the ClassWizard will add data members here
+  //}}AFX_DATA
 
-	// ClassWizard generated virtual function overrides
-	//{{AFX_VIRTUAL(CACE_Init_TestDlg)
-	protected:
-	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV support
-	//}}AFX_VIRTUAL
+  // ClassWizard generated virtual function overrides
+  //{{AFX_VIRTUAL(CACE_Init_TestDlg)
+  protected:
+  virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
+  //}}AFX_VIRTUAL
 
 // Implementation
 protected:
-	HICON m_hIcon;
-
-	// Generated message map functions
-	//{{AFX_MSG(CACE_Init_TestDlg)
-	virtual BOOL OnInitDialog();
-	afx_msg void OnPaint();
-	afx_msg HCURSOR OnQueryDragIcon();
-	//}}AFX_MSG
-	DECLARE_MESSAGE_MAP()
+  HICON m_hIcon;
+
+  // Generated message map functions
+  //{{AFX_MSG(CACE_Init_TestDlg)
+  virtual BOOL OnInitDialog();
+  afx_msg void OnPaint();
+  afx_msg HCURSOR OnQueryDragIcon();
+  //}}AFX_MSG
+  DECLARE_MESSAGE_MAP()
 };
 
 //{{AFX_INSERT_LOCATION}}
diff --git a/ACE/tests/Based_Pointer_Test.cpp b/ACE/tests/Based_Pointer_Test.cpp
index 9e1dd3ee7a0..41d548d2039 100644
--- a/ACE/tests/Based_Pointer_Test.cpp
+++ b/ACE/tests/Based_Pointer_Test.cpp
@@ -29,8 +29,8 @@
 #include "ace/Null_Mutex.h"
 
 ACE_RCSID (tests,
-	   Based_Pointer_Repository_Test,
-	   "$Id$")
+           Based_Pointer_Repository_Test,
+           "$Id$")
 
 #ifdef ACE_HAS_POSITION_INDEPENDENT_POINTERS
 
@@ -344,7 +344,7 @@ mmap_remap_test(void)
       {
         ACE_ERROR ((LM_ERROR,
             ACE_TEXT ("Unable to find base address after remap of segment\n")));
-  	for (i= 0; i<3; ++i)
+        for (i= 0; i<3; ++i)
           {
             alloc[ i ]->remove();
             delete alloc[ i ];
@@ -356,7 +356,7 @@ mmap_remap_test(void)
       {
         ACE_ERROR ((LM_ERROR,
               ACE_TEXT ("New base address not mapped after MMAP remap\n")));
-	for (i= 0; i<3; ++i)
+        for (i= 0; i<3; ++i)
           {
             alloc[ i ]->remove();
             delete alloc[ i ];
diff --git a/ACE/tests/Basic_Types_Test.cpp b/ACE/tests/Basic_Types_Test.cpp
index 23e63129387..7fd5afb584b 100644
--- a/ACE/tests/Basic_Types_Test.cpp
+++ b/ACE/tests/Basic_Types_Test.cpp
@@ -276,18 +276,18 @@ run_main (int, ACE_TCHAR *[])
   else
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT ("sizeof (ptrdiff_t) != sizeof (void*)\n")));
+                  ACE_TEXT ("sizeof (ptrdiff_t) != sizeof (void*)\n")));
       ++errors;
     }
 
   // ACE assumes sizeof (ptrdiff_t) >= sizeof (a_function_pointer)
   if (sizeof (ptrdiff_t) >= sizeof (a_function_pointer))
     ACE_DEBUG ((LM_DEBUG,
-		ACE_TEXT ("sizeof (ptrdiff_t) >= sizeof (a_function_pointer)\n")));
+                ACE_TEXT ("sizeof (ptrdiff_t) >= sizeof (a_function_pointer)\n")));
   else
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT ("sizeof (ptrdiff_t) < sizeof (a_function_pointer)\n")));
+                  ACE_TEXT ("sizeof (ptrdiff_t) < sizeof (a_function_pointer)\n")));
       ++errors;
     }
 
diff --git a/ACE/tests/Bug_2815_Regression_Test.cpp b/ACE/tests/Bug_2815_Regression_Test.cpp
index dc831ed6b13..d365b4f3d3a 100644
--- a/ACE/tests/Bug_2815_Regression_Test.cpp
+++ b/ACE/tests/Bug_2815_Regression_Test.cpp
@@ -46,18 +46,18 @@ class Driver
 {
 public:
   Driver(ACE_Reactor * reactor,
-	 int max_notifications,
-	 char const *test_name);
+         int max_notifications,
+         char const *test_name);
 
   /// Run the test
   void run (void);
-  
+
   /// One of the sub-handlers has received a notification
   void notification_received ();
-  
+
   /// One of the sub-handlers has decided to skip several notifications
   void notifications_skipped (int skip_count);
-	
+
   /**
    * @brief Return the reactor configured for this test
    */
@@ -76,29 +76,29 @@ private:
    * @brief Return true if the test is finished.
    */
   bool done (void) const;
-  
+
   /**
    * @brief Return true if there are more iterations to run.
    */
   bool more_iterations () const;
-  
+
   /**
    * @brief Return true if the current iteration is completed.
    */
   bool current_iteration_done () const;
-  
+
   /**
    * @brief Run one iteration of the test, each iteration doubles
    * the number of events.
    */
   int run_one_iteration (void);
-  
+
   /**
    * @brief Initialize a bunch of One_Shot_Handlers
    */
   void initialize_handlers(
     int nhandlers, One_Shot_Handler ** handlers);
-	
+
   /**
    * @brief Dispatch events to the One_Shot_Handlers
    */
@@ -176,12 +176,12 @@ class One_Shot_Handler : public ACE_Event_Handler
 public:
   One_Shot_Handler(
     Driver * master_handler,
-	char const * test_name,
-	int id);
+    char const * test_name,
+    int id);
 
   /// Increase the number of expected notifications
   void notification_queued();
-  
+
   /// Receive the notifications, but remove itself from the reactor on
   /// on the first one.
   virtual int handle_exception(ACE_HANDLE);
@@ -195,7 +195,7 @@ private:
 
   /// Identify the test and handler for debugging and better error output
   char const * test_name_;
-  int id_;  
+  int id_;
 };
 
 int
@@ -218,8 +218,8 @@ run_main (int, ACE_TCHAR *[])
         1);
 
     Driver handler(&select_reactor,
-		   max_notifications,
-		   "Select_Reactor");
+                   max_notifications,
+                   "Select_Reactor");
 
     handler.run ();
   }
@@ -228,8 +228,8 @@ run_main (int, ACE_TCHAR *[])
     ACE_Reactor tp_reactor (new ACE_TP_Reactor,
                             1);
     Driver handler(&tp_reactor,
-		   max_notifications,
-		   "TP_Reactor");
+                   max_notifications,
+                   "TP_Reactor");
     handler.run();
   }
 
@@ -260,18 +260,18 @@ Driver::run (void)
   {
     if(run_one_iteration() == -1)
       {
-	return;
+        return;
       }
 
     notifications_curr_ *= 2;
   }
 
   ACE_DEBUG ((LM_INFO,
-	      ACE_TEXT ("Test %C passed sent=%d, recv=%d, skip=%d\n"),
-	      test_name_,
-	      notifications_sent_,
-	      notifications_recv_,
-	      notifications_skipped_));
+              ACE_TEXT ("Test %C passed sent=%d, recv=%d, skip=%d\n"),
+              test_name_,
+              notifications_sent_,
+              notifications_recv_,
+              notifications_skipped_));
 }
 
 void
@@ -300,7 +300,7 @@ Driver::send_notifications (void)
   int const nhandlers = 16;
   One_Shot_Handler * handlers[nhandlers];
   initialize_handlers(nhandlers, handlers);
-  
+
   for (int i = 0; i != notifications_curr_; ++i)
   {
     notify_handlers(nhandlers, handlers);
@@ -330,8 +330,8 @@ Driver::run_one_iteration (void)
 {
   ACE_DEBUG ((LM_INFO,
               ACE_TEXT ("Running iteration with %d events for %C test\n"),
-	      notifications_curr_,
-	      test_name_));
+              notifications_curr_,
+              test_name_));
 
   send_notifications ();
 
@@ -348,14 +348,14 @@ Driver::run_one_iteration (void)
 
     if (end - start >= timeout)
       {
-	ACE_ERROR ((LM_ERROR,
-		    ACE_TEXT ("Test %C failed due to timeout ")
-		    ACE_TEXT (" sent=%d,recv=%d,skip=%d\n"),
-		    test_name_,
-		    notifications_sent_,
-		    notifications_recv_,
-		    notifications_skipped_));
-	return -1;
+        ACE_ERROR ((LM_ERROR,
+                    ACE_TEXT ("Test %C failed due to timeout ")
+                    ACE_TEXT (" sent=%d,recv=%d,skip=%d\n"),
+                    test_name_,
+                    notifications_sent_,
+                    notifications_recv_,
+                    notifications_skipped_));
+        return -1;
       }
   }
 
@@ -380,10 +380,10 @@ Driver::notify_handlers(
   {
     if(reactor()->notify (handlers[i]) == -1)
       {
-	ACE_ERROR((LM_ERROR,
-		   ACE_TEXT ("Cannot send notifications in %C test (%d/%d)\n"),
-		   test_name_, i, notifications_curr_));
-	return;
+        ACE_ERROR((LM_ERROR,
+                   ACE_TEXT ("Cannot send notifications in %C test (%d/%d)\n"),
+                   test_name_, i, notifications_curr_));
+        return;
       }
     handlers[i]->notification_queued();
 
@@ -397,55 +397,55 @@ check_notification_invariants()
   if (notifications_sent_ < 0)
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT("The number of notifications sent (%d)")
-		  ACE_TEXT(" should be positive\n"),
-		  notifications_sent_));
+                  ACE_TEXT("The number of notifications sent (%d)")
+                  ACE_TEXT(" should be positive\n"),
+                  notifications_sent_));
       invariant_failed();
     }
 
   if (notifications_recv_ < 0)
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT("The number of notifications received (%d)")
-		  ACE_TEXT(" should be positive\n"),
-		  notifications_recv_));
+                  ACE_TEXT("The number of notifications received (%d)")
+                  ACE_TEXT(" should be positive\n"),
+                  notifications_recv_));
       invariant_failed();
     }
 
   if (notifications_skipped_ < 0)
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT("The number of notifications skipped (%d)")
-		  ACE_TEXT(" should be positive\n"),
-		  notifications_skipped_));
+                  ACE_TEXT("The number of notifications skipped (%d)")
+                  ACE_TEXT(" should be positive\n"),
+                  notifications_skipped_));
       invariant_failed();
     }
-  
+
   if (notifications_sent_ < notifications_recv_)
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT("Too many notifications received (%d)")
-		  ACE_TEXT(" vs sent (%d)\n"),
-		  notifications_recv_, notifications_sent_));
+                  ACE_TEXT("Too many notifications received (%d)")
+                  ACE_TEXT(" vs sent (%d)\n"),
+                  notifications_recv_, notifications_sent_));
       invariant_failed();
     }
 
   if (notifications_sent_ < notifications_skipped_)
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT("Too many notifications skipped (%d)")
-		  ACE_TEXT(" vs sent (%d)\n"),
-		  notifications_skipped_, notifications_sent_));
+                  ACE_TEXT("Too many notifications skipped (%d)")
+                  ACE_TEXT(" vs sent (%d)\n"),
+                  notifications_skipped_, notifications_sent_));
       invariant_failed();
     }
 
   if (notifications_skipped_ + notifications_recv_ > notifications_sent_)
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT("Too many notifications skipped (%d)")
-		  ACE_TEXT(" and received (%d) vs sent (%d)\n"),
-		  notifications_skipped_, notifications_recv_,
-		  notifications_sent_));
+                  ACE_TEXT("Too many notifications skipped (%d)")
+                  ACE_TEXT(" and received (%d) vs sent (%d)\n"),
+                  notifications_skipped_, notifications_recv_,
+                  notifications_sent_));
       invariant_failed();
     }
 }
@@ -459,8 +459,8 @@ invariant_failed()
 // ============================================
 
 One_Shot_Handler::One_Shot_Handler(
-	Driver * master_handler,
-	char const * test_name, int id)
+  Driver * master_handler,
+  char const * test_name, int id)
   : ACE_Event_Handler(master_handler->reactor())
   , master_handler_(master_handler)
   , expected_notifications_(0)
@@ -474,13 +474,13 @@ notification_queued()
 {
   ++expected_notifications_;
 }
-  
+
 int One_Shot_Handler::
 handle_exception(ACE_HANDLE)
 {
   --expected_notifications_;
   master_handler_->notification_received();
-  
+
   int r = reactor()->purge_pending_notifications(this);
   if (r >= 0)
     {
@@ -488,10 +488,10 @@ handle_exception(ACE_HANDLE)
       delete this;
       return 0;
     }
-	
+
   ACE_ERROR((LM_ERROR,
-	     ACE_TEXT ("Cannot remove handler %d in %C test\n"),
-	     id_, test_name_));
+             ACE_TEXT ("Cannot remove handler %d in %C test\n"),
+             id_, test_name_));
 
   delete this;
   return 0;
diff --git a/ACE/tests/Bug_2820_Regression_Test.cpp b/ACE/tests/Bug_2820_Regression_Test.cpp
index 68828bc7d65..93a9c1bc45c 100644
--- a/ACE/tests/Bug_2820_Regression_Test.cpp
+++ b/ACE/tests/Bug_2820_Regression_Test.cpp
@@ -72,9 +72,9 @@ run_main (int, ACE_TCHAR *[])
     {
       result = -1;
       ACE_ERROR((LM_ERROR,
-		 ACE_TEXT("Reference count should increase by %d.")
-		 ACE_TEXT("  Initial count=%d, final count = %d\n"),
-		 notify_count, pre_notify_count, pos_notify_count));
+                 ACE_TEXT("Reference count should increase by %d.")
+                 ACE_TEXT("  Initial count=%d, final count = %d\n"),
+                 notify_count, pre_notify_count, pos_notify_count));
     }
 
   ACE_auto_ptr_reset(reactor, (ACE_Reactor*)0);
@@ -91,16 +91,16 @@ run_main (int, ACE_TCHAR *[])
     {
       result = -1;
       ACE_ERROR((LM_ERROR,
-		 ACE_TEXT("Reference count should have increased by 2.")
-		 ACE_TEXT("  Initial count=%d, final count = %d\n"),
-		 pre_notify_count, pos_release_count));
+                 ACE_TEXT("Reference count should have increased by 2.")
+                 ACE_TEXT("  Initial count=%d, final count = %d\n"),
+                 pre_notify_count, pos_release_count));
     }
 
   ACE_DEBUG ((LM_INFO,
-	      ACE_TEXT("Ref count results.  pre_notify refcount=%d,")
-	      ACE_TEXT(" pos_notify=%d, pos_delete=%d\n"),
-	      pre_notify_count, pos_notify_count, pos_release_count));
-  
+              ACE_TEXT("Ref count results.  pre_notify refcount=%d,")
+              ACE_TEXT(" pos_notify=%d, pos_delete=%d\n"),
+              pre_notify_count, pos_notify_count, pos_release_count));
+
   // Remove a reference for each time we explicitly increased it.
   v->remove_reference();
   v->remove_reference();
@@ -108,10 +108,10 @@ run_main (int, ACE_TCHAR *[])
       v->remove_reference();
 
   ACE_DEBUG ((LM_INFO,
-	      ACE_TEXT("Ref count results.  pre_notify refcount=%d,")
-	      ACE_TEXT(" pos_notify=%d, pos_delete=%d, pos_remove=%d\n"),
-	      pre_notify_count, pos_notify_count, pos_release_count,
-	      pos_remove_count));
+              ACE_TEXT("Ref count results.  pre_notify refcount=%d,")
+              ACE_TEXT(" pos_notify=%d, pos_delete=%d, pos_remove=%d\n"),
+              pre_notify_count, pos_notify_count, pos_release_count,
+              pos_remove_count));
 
   ACE_END_TEST;
 
diff --git a/ACE/tests/Config_Test.cpp b/ACE/tests/Config_Test.cpp
index 881b33da542..8e90205cebd 100644
--- a/ACE/tests/Config_Test.cpp
+++ b/ACE/tests/Config_Test.cpp
@@ -1091,23 +1091,23 @@ iniCompare (ACE_Configuration_Heap& fromFile, ACE_Configuration_Heap& original)
 // change a network section value
 int Config_Test::change_one (ACE_Configuration &cfg, u_int a)
 {
-	ACE_Configuration_Section_Key root = cfg.root_section ();
-	ACE_Configuration_Section_Key NetworkSection;
-	ACE_Configuration_Section_Key LoggerSection;
-	ACE_Configuration_Section_Key BinarySection;
-
-	if (cfg.open_section (root,
-		ACE_TEXT ("network"),
-		1,
-		NetworkSection))
-		return -1;
-
-	if (cfg.set_integer_value (NetworkSection,
-		ACE_TEXT ("TimeToLive"),
-		a))
-		return -2;
-
-	return 0;
+  ACE_Configuration_Section_Key root = cfg.root_section ();
+  ACE_Configuration_Section_Key NetworkSection;
+  ACE_Configuration_Section_Key LoggerSection;
+  ACE_Configuration_Section_Key BinarySection;
+
+  if (cfg.open_section (root,
+                        ACE_TEXT ("network"),
+                        1,
+                        NetworkSection))
+    return -1;
+
+  if (cfg.set_integer_value (NetworkSection,
+                             ACE_TEXT ("TimeToLive"),
+                             a))
+    return -2;
+
+  return 0;
 }
 
 // Used to test INI Import Export class
@@ -1363,25 +1363,25 @@ Config_Test::testRegFormat ()
                            rc),
                           -1);
 
-		// 7.1 Change a value and test NOT equal case
-		change_one (original, 101);
-		if (fromFile == original)
-		{
-			ACE_ERROR_RETURN ((LM_ERROR,
-				ACE_TEXT ("not pass value change test (%d)\n"),
-				rc),
-				-1);
-		}
-
-		// 7.2 change value back, they should be equal now
-		change_one (original, 100);
-		if (fromFile != original)
-		{
-			ACE_ERROR_RETURN ((LM_ERROR,
-				ACE_TEXT ("not pass value change test (%d)\n"),
-				rc),
-				-1);
-		}
+      // 7.1 Change a value and test NOT equal case
+      change_one (original, 101);
+      if (fromFile == original)
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             ACE_TEXT ("not pass value change test (%d)\n"),
+                             rc),
+                            -1);
+        }
+
+      // 7.2 change value back, they should be equal now
+      change_one (original, 100);
+        if (fromFile != original)
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             ACE_TEXT ("not pass value change test (%d)\n"),
+                             rc),
+                            -1);
+        }
 
     }// end if heap could not be opened.
   else
diff --git a/ACE/tests/Config_Test.h b/ACE/tests/Config_Test.h
index 30c75432d61..28fcdbd2d36 100644
--- a/ACE/tests/Config_Test.h
+++ b/ACE/tests/Config_Test.h
@@ -49,9 +49,9 @@ public:
 
 
 private:
-	// change a value for value change test
+  // change a value for value change test
   int change_one (ACE_Configuration &l, u_int a = 101);
-	
+
   void get_section_string (ACE_Configuration&             config,
                            ACE_Configuration_Section_Key& SectionKey,
                            const ACE_TCHAR*               pszName,
diff --git a/ACE/tests/Max_Default_Port_Test.cpp b/ACE/tests/Max_Default_Port_Test.cpp
index 5a07a0abb35..772f6e8ae21 100644
--- a/ACE/tests/Max_Default_Port_Test.cpp
+++ b/ACE/tests/Max_Default_Port_Test.cpp
@@ -129,25 +129,25 @@ client (void *arg)
                    &timeout) == -1)
     {
 #if defined (ACE_VXWORKS)
-	  if (errno == ETIME)
-	  {
-		if ( ++retry_port_<6 )
-		{
-  		  ACE_DEBUG ((LM_DEBUG,
-  		   	         ACE_TEXT ("(%P|%t) Going to retry port %d\n"),
-                     server_addr.get_port_number()));
-		}
-	  }
-	  if ( retry_port_>5 )
-	  {
-		retry_port_ = 0;
+      if (errno == ETIME)
+        {
+          if ( ++retry_port_<6 )
+          {
+            ACE_DEBUG ((LM_DEBUG,
+                        ACE_TEXT ("(%P|%t) Going to retry port %d\n"),
+                        server_addr.get_port_number()));
+          }
+        }
+      if ( retry_port_>5 )
+        {
+          retry_port_ = 0;
 #endif
-      ACE_ERROR ((LM_ERROR,
-                  ACE_TEXT ("(%P|%t) %p\n"),
-                  ACE_TEXT ("connection failed")));
+          ACE_ERROR ((LM_ERROR,
+                      ACE_TEXT ("(%P|%t) %p\n"),
+                      ACE_TEXT ("connection failed")));
 
 #if defined (ACE_VXWORKS)
-	  }
+        }
 #endif
       return 0;
     }
@@ -183,11 +183,11 @@ run_main (int argc, ACE_TCHAR *argv[])
   for (u_short idx = USHRT_MAX; idx != USHRT_MAX - 300; --idx)
     {
 #if defined (ACE_VXWORKS)
-	  if (retry_port_>0)
-	  {
-	  	++idx;
-        ACE_OS::sleep (ACE_Time_Value (2*ACE_DEFAULT_TIMEOUT));
-	  }
+      if (retry_port_>0)
+        {
+          ++idx;
+          ACE_OS::sleep (ACE_Time_Value (2*ACE_DEFAULT_TIMEOUT));
+        }
 #endif
 
       ACE_INET_Addr addr (idx);
diff --git a/ACE/tests/Mem_Map_Test.cpp b/ACE/tests/Mem_Map_Test.cpp
index cce9b55fb5d..207f5a1eb15 100644
--- a/ACE/tests/Mem_Map_Test.cpp
+++ b/ACE/tests/Mem_Map_Test.cpp
@@ -226,13 +226,13 @@ run_main (int, ACE_TCHAR *[])
                       -1);
 #if defined (__QNXNTO__) || (defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x640))
   mmap_4_open.open(temp_file2,
-	  O_RDWR | O_TRUNC | O_CREAT,
-	  ACE_DEFAULT_FILE_PERMS);
-  temp_file_handle = mmap_4_open.handle();
+                   O_RDWR | O_TRUNC | O_CREAT,
+                   ACE_DEFAULT_FILE_PERMS);
+                   temp_file_handle = mmap_4_open.handle();
 #else
   temp_file_handle = ACE_OS::open (temp_file2,
-	  O_RDWR | O_TRUNC | O_CREAT,
-	  ACE_DEFAULT_FILE_PERMS);
+                                   O_RDWR | O_TRUNC | O_CREAT,
+                                   ACE_DEFAULT_FILE_PERMS);
 #endif
   if ( temp_file_handle == ACE_INVALID_HANDLE)
 
diff --git a/ACE/tests/Notification_Queue_Unit_Test.cpp b/ACE/tests/Notification_Queue_Unit_Test.cpp
index 76ee3461e12..98d19f61fef 100644
--- a/ACE/tests/Notification_Queue_Unit_Test.cpp
+++ b/ACE/tests/Notification_Queue_Unit_Test.cpp
@@ -49,17 +49,17 @@ TEST_LIST
 // an existing framework (Boost.Test, TUT, CppTest).  But this will
 // do for our purposes
 void test_equal(int x, int y, char const * x_msg, char const * y_msg,
-		char const * error_message,
-		char const * test_name, char const * filename, int lineno);
+                char const * error_message,
+                char const * test_name, char const * filename, int lineno);
 void test_equal(void * x, void * y, char const * x_msg, char const * y_msg,
-		char const * error_message,
-		char const * test_name, char const * filename, int lineno);
+                char const * error_message,
+                char const * test_name, char const * filename, int lineno);
 void test_not_equal(int x, int y, char const * x_msg, char const * y_msg,
-		    char const * error_message,
-		    char const * test_name, char const * filename, int lineno);
+                    char const * error_message,
+                    char const * test_name, char const * filename, int lineno);
 void test_assert(bool predicate, char const * predicate_msg,
-		 char const * error_message,
-		 char const * test_name, char const * filename, int lineno);
+                 char const * error_message,
+                 char const * test_name, char const * filename, int lineno);
 
 #define TEST_EQUAL(X, Y, MSG) \
   test_equal((X), (Y), #X, #Y, MSG, test_name, __FILE__, __LINE__)
@@ -99,18 +99,18 @@ void pop_returns_element_pushed(char const * test_name)
 
   int result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh1,
-			      ACE_Event_Handler::READ_MASK));
+                              ACE_Event_Handler::READ_MASK));
   TEST_ASSERT(result == 1, "push[1] should return 1");
 
   result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh2,
-			      ACE_Event_Handler::WRITE_MASK));
+                              ACE_Event_Handler::WRITE_MASK));
   TEST_ASSERT(result == 0, "push[2] should return 0");
 
   result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh3,
-			      ACE_Event_Handler::READ_MASK
-			      |ACE_Event_Handler::WRITE_MASK));
+                              ACE_Event_Handler::READ_MASK |
+                              ACE_Event_Handler::WRITE_MASK));
   TEST_ASSERT(result == 0, "push[3] should return 0");
 
   ACE_Notification_Buffer current;
@@ -123,7 +123,7 @@ void pop_returns_element_pushed(char const * test_name)
 
   TEST_EQUAL(current.eh_, &eh1, "Wrong handler extracted");
   TEST_EQUAL(current.mask_, ACE_Event_Handler::READ_MASK,
-		     "Wrong mask extracted");
+             "Wrong mask extracted");
 
   result = queue.pop_next_notification(current, more_messages_queued, next);
   TEST_ASSERT(result == 1, "pop[1] should return 1");
@@ -131,16 +131,16 @@ void pop_returns_element_pushed(char const * test_name)
 
   TEST_EQUAL(current.eh_, &eh2, "Wrong handler extracted");
   TEST_EQUAL(current.mask_, ACE_Event_Handler::WRITE_MASK,
-		     "Wrong mask extracted");
+             "Wrong mask extracted");
 
   result = queue.pop_next_notification(current, more_messages_queued, next);
   TEST_ASSERT(result == 1, "pop[2] should return 1");
   TEST_ASSERT(!more_messages_queued, "pop[2] should not have more messages");
 
   TEST_EQUAL(current.eh_, &eh3, "Wrong handler extracted");
-  TEST_EQUAL(current.mask_, ACE_Event_Handler::READ_MASK
-		     |ACE_Event_Handler::WRITE_MASK,
-		     "Wrong mask extracted");
+  TEST_EQUAL(current.mask_, ACE_Event_Handler::READ_MASK |
+                            ACE_Event_Handler::WRITE_MASK,
+             "Wrong mask extracted");
 
   more_messages_queued = true;
   result = queue.pop_next_notification(current, more_messages_queued, next);
@@ -155,7 +155,7 @@ void purge_empty_queue(char const * test_name)
   Event_Handler eh1(1);
 
   int result = queue.purge_pending_notifications(&eh1,
-						 ACE_Event_Handler::READ_MASK);
+                                                 ACE_Event_Handler::READ_MASK);
   TEST_ASSERT(result == 0, "purge of empty queue should return 0");
 }
 
@@ -168,14 +168,14 @@ void purge_with_no_matches(char const * test_name)
 
   int result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh1,
-			      ACE_Event_Handler::READ_MASK));
+                              ACE_Event_Handler::READ_MASK));
 
   result = queue.purge_pending_notifications(&eh2,
-					     ACE_Event_Handler::READ_MASK);
+                                             ACE_Event_Handler::READ_MASK);
   TEST_ASSERT(result == 0, "purge of eh2 should return 0");
 
   result = queue.purge_pending_notifications(&eh1,
-					     ACE_Event_Handler::WRITE_MASK);
+                                             ACE_Event_Handler::WRITE_MASK);
   TEST_ASSERT(result == 0, "purge of eh1/WRITE should return 0");
 }
 
@@ -188,30 +188,30 @@ void purge_with_single_match(char const * test_name)
 
   int result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh1,
-			      ACE_Event_Handler::READ_MASK
-			      |ACE_Event_Handler::WRITE_MASK));
+                              ACE_Event_Handler::READ_MASK |
+                              ACE_Event_Handler::WRITE_MASK));
   result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh1,
-			      ACE_Event_Handler::WRITE_MASK));
+                              ACE_Event_Handler::WRITE_MASK));
   result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh2,
-			      ACE_Event_Handler::READ_MASK));
+                              ACE_Event_Handler::READ_MASK));
   result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh2,
-			      ACE_Event_Handler::WRITE_MASK));
+                              ACE_Event_Handler::WRITE_MASK));
   result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh2,
-			      ACE_Event_Handler::WRITE_MASK));
+                              ACE_Event_Handler::WRITE_MASK));
   result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh2,
-			      ACE_Event_Handler::WRITE_MASK));
+                              ACE_Event_Handler::WRITE_MASK));
 
   result = queue.purge_pending_notifications(&eh2,
-					     ACE_Event_Handler::READ_MASK);
+                                             ACE_Event_Handler::READ_MASK);
   TEST_EQUAL(result, 1, "purge of eh2/READ should return 1");
 
   result = queue.purge_pending_notifications(&eh1,
-					     ACE_Event_Handler::READ_MASK);
+                                             ACE_Event_Handler::READ_MASK);
   TEST_EQUAL(result, 0, "purge of eh1/READ should return 0");
 }
 
@@ -224,30 +224,30 @@ void purge_with_multiple_matches(char const * test_name)
 
   int result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh1,
-			      ACE_Event_Handler::READ_MASK
-			      |ACE_Event_Handler::WRITE_MASK));
+                              ACE_Event_Handler::READ_MASK |
+                              ACE_Event_Handler::WRITE_MASK));
   result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh1,
-			      ACE_Event_Handler::WRITE_MASK));
+                              ACE_Event_Handler::WRITE_MASK));
   result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh2,
-			      ACE_Event_Handler::READ_MASK));
+                              ACE_Event_Handler::READ_MASK));
   result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh2,
-			      ACE_Event_Handler::WRITE_MASK));
+                              ACE_Event_Handler::WRITE_MASK));
   result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh2,
-			      ACE_Event_Handler::WRITE_MASK));
+                              ACE_Event_Handler::WRITE_MASK));
   result = queue.push_new_notification(
       ACE_Notification_Buffer(&eh2,
-			      ACE_Event_Handler::WRITE_MASK));
+                              ACE_Event_Handler::WRITE_MASK));
 
   result = queue.purge_pending_notifications(&eh2,
-					     ACE_Event_Handler::WRITE_MASK);
+                                             ACE_Event_Handler::WRITE_MASK);
   TEST_EQUAL(result, 3, "purge of eh2/WRITE should return 3");
 
   result = queue.purge_pending_notifications(&eh1,
-					     ACE_Event_Handler::WRITE_MASK);
+                                             ACE_Event_Handler::WRITE_MASK);
   TEST_EQUAL(result, 1, "purge of eh1/WRITE should return 1");
 }
 
@@ -267,63 +267,63 @@ void reset_non_empty_queue(char const * /* test_name */)
 
   queue.push_new_notification(
       ACE_Notification_Buffer(0,
-			      ACE_Event_Handler::READ_MASK));
+                              ACE_Event_Handler::READ_MASK));
   queue.push_new_notification(
       ACE_Notification_Buffer(&eh1,
-			      ACE_Event_Handler::READ_MASK));
+                              ACE_Event_Handler::READ_MASK));
   queue.push_new_notification(
       ACE_Notification_Buffer(&eh2,
-			      ACE_Event_Handler::WRITE_MASK));
+                              ACE_Event_Handler::WRITE_MASK));
   queue.push_new_notification(
       ACE_Notification_Buffer(0,
-			      ACE_Event_Handler::WRITE_MASK));
+                              ACE_Event_Handler::WRITE_MASK));
 
   queue.reset();
 }
 
 void test_equal(int x, int y, char const * x_msg, char const * y_msg,
-		char const * error_message,
-		char const * test_name, char const * filename, int lineno)
+                char const * error_message,
+                char const * test_name, char const * filename, int lineno)
 {
   if (x == y) return;
   ACE_ERROR ((LM_ERROR,
-	      ACE_TEXT("%C in (%C %C:%d) %C (%d) != %C (%d)\n"),
-	      error_message,
-	      test_name, filename, lineno,
-	      x_msg, x, y_msg, y));
+              ACE_TEXT("%C in (%C %C:%d) %C (%d) != %C (%d)\n"),
+              error_message,
+              test_name, filename, lineno,
+              x_msg, x, y_msg, y));
 }
 
 void test_equal(void * x, void * y, char const * x_msg, char const * y_msg,
-		char const * error_message,
-		char const * test_name, char const * filename, int lineno)
+                char const * error_message,
+                char const * test_name, char const * filename, int lineno)
 {
   if (x == y) return;
   ACE_ERROR ((LM_ERROR,
-	      ACE_TEXT("%C in (%C %C:%d) %C (%@) != %C (%@)\n"),
-	      error_message,
-	      test_name, filename, lineno,
-	      x_msg, x, y_msg, y));
+              ACE_TEXT("%C in (%C %C:%d) %C (%@) != %C (%@)\n"),
+              error_message,
+              test_name, filename, lineno,
+              x_msg, x, y_msg, y));
 }
 
 void test_not_equal(int x, int y, char const * x_msg, char const * y_msg,
-		    char const * error_message,
-		    char const * test_name, char const * filename, int lineno)
+                    char const * error_message,
+                    char const * test_name, char const * filename, int lineno)
 {
   if (x != y) return;
   ACE_ERROR ((LM_ERROR,
-	      ACE_TEXT("%C in (%C %C:%d) %C (%d) != %C (%d)\n"),
-	      error_message,
-	      test_name, filename, lineno,
-	      x_msg, x, y_msg, y));
+              ACE_TEXT("%C in (%C %C:%d) %C (%d) != %C (%d)\n"),
+              error_message,
+              test_name, filename, lineno,
+              x_msg, x, y_msg, y));
 }
 
 void test_assert(bool predicate, char const * predicate_msg,
-		 char const * error_message,
-		char const * test_name, char const * filename, int lineno)
+                 char const * error_message,
+                 char const * test_name, char const * filename, int lineno)
 {
   if (predicate) return;
   ACE_ERROR ((LM_ERROR,
-	      ACE_TEXT("Assertion in (%C %C:%d) %C %C\n"),
-	      test_name, filename, lineno,
-	      predicate_msg, error_message));
+              ACE_TEXT("Assertion in (%C %C:%d) %C %C\n"),
+              test_name, filename, lineno,
+              predicate_msg, error_message));
 }
diff --git a/ACE/tests/QtReactor_Test.cpp b/ACE/tests/QtReactor_Test.cpp
index 909b74e5188..740ad7279c7 100644
--- a/ACE/tests/QtReactor_Test.cpp
+++ b/ACE/tests/QtReactor_Test.cpp
@@ -42,8 +42,8 @@
 #include "test_config.h"
 
 ACE_RCSID (tests,
-	QtReactor_Test,
-	"$Id$")
+           QtReactor_Test,
+           "$Id$")
 
 #include <assert.h>
 #include <qapplication.h>
diff --git a/ACE/tests/QtReactor_Test.h b/ACE/tests/QtReactor_Test.h
index f2be9a5331c..6996ad274b1 100644
--- a/ACE/tests/QtReactor_Test.h
+++ b/ACE/tests/QtReactor_Test.h
@@ -8,16 +8,16 @@
 
 class QTestApplication: public QApplication
 {
-	Q_OBJECT
+  Q_OBJECT
 public:
-	typedef QApplication inherited;
+  typedef QApplication inherited;
 public:
-	QTestApplication( int argc, char *argv[] );
-	virtual void exec( int msec = 0 );
+  QTestApplication( int argc, char *argv[] );
+  virtual void exec( int msec = 0 );
 public slots:
-	virtual void finishTest(); //!< slot to finish the test, connected to finishTimer_
+  virtual void finishTest(); //!< slot to finish the test, connected to finishTimer_
 private:
-	QTimer finishTimer_; //!< timer to finish the test
+  QTimer finishTimer_; //!< timer to finish the test
 };
 
 #endif /*QTREACTOR_TEST_H*/
diff --git a/ACE/tests/Reactor_Notify_Test.cpp b/ACE/tests/Reactor_Notify_Test.cpp
index b3ea04794e0..8c1af55294d 100644
--- a/ACE/tests/Reactor_Notify_Test.cpp
+++ b/ACE/tests/Reactor_Notify_Test.cpp
@@ -180,7 +180,7 @@ Supplier_Task::perform_notifications (int notifications)
     {
       iterations *= (iterations * iterations * 2);
 #if defined (ACE_VXWORKS)
-	  // scale down otherwise the test won'y finish in time
+      // scale down otherwise the test won'y finish in time
       iterations /= 4;
 #endif
     }
@@ -440,9 +440,9 @@ run_notify_purge_test (void)
     // notifications.  It is the application's responsability to do
     // so.
     r->purge_pending_notifications(n2,
-				   ACE_Event_Handler::ALL_EVENTS_MASK);
+                                   ACE_Event_Handler::ALL_EVENTS_MASK);
     r->purge_pending_notifications(&n1,
-				   ACE_Event_Handler::ALL_EVENTS_MASK);
+                                   ACE_Event_Handler::ALL_EVENTS_MASK);
   }
 
   ACE_Time_Value t (1);
diff --git a/ACE/tests/SOCK_Dgram_Test.cpp b/ACE/tests/SOCK_Dgram_Test.cpp
index e89af2c4eba..210a1be7eb5 100644
--- a/ACE/tests/SOCK_Dgram_Test.cpp
+++ b/ACE/tests/SOCK_Dgram_Test.cpp
@@ -45,93 +45,93 @@ client (void *arg)
   if (remote_addr->get_type () == AF_INET)
     {
       server_addr.set (remote_addr->get_port_number (),
-		       ACE_LOCALHOST,
-		       1,
-		       remote_addr->get_type ());
+                       ACE_LOCALHOST,
+                       1,
+                       remote_addr->get_type ());
     }
 #if defined (ACE_HAS_IPV6)
   else
     {
       server_addr.set (remote_addr->get_port_number(),
                        ACE_IPV6_LOCALHOST,
-		       1,
-		       remote_addr->get_type ());
+                       1,
+                       remote_addr->get_type ());
     }
 #endif /* ACE_HAS_IPV6 */
 
   server_addr.addr_to_string (hostname_string, 100);
   ACE_DEBUG ((LM_DEBUG,
-	      ACE_TEXT ("(%P|%t) starting client UDP send to %s\n"),
-	      hostname_string));
+              ACE_TEXT ("(%P|%t) starting client UDP send to %s\n"),
+              hostname_string));
 
   if (cli_dgram.open (ACE_Addr::sap_any, server_addr.get_type ()) == -1)
     {
       ACE_ERROR((LM_ERROR,
                  ACE_TEXT("(%P|%t) protocol %d, %p\n"),
                  server_addr.get_type (),
-		 ACE_TEXT ("SOCK_Dgram open")));
+                 ACE_TEXT ("SOCK_Dgram open")));
     }
   else if (cli_dgram.send (TEST_DATA, sizeof (TEST_DATA), server_addr) == -1)
     {
       ACE_ERROR((LM_ERROR,
-		 ACE_TEXT("(%P|%t) UDP send to %s %p\n"),
-		 hostname_string,
-		 ACE_TEXT ("failed")));
+                 ACE_TEXT("(%P|%t) UDP send to %s %p\n"),
+                 hostname_string,
+                 ACE_TEXT ("failed")));
     }
   else
     {
       ssize_t rcv_cnt = cli_dgram.recv (buf,
-					sizeof (buf),
-					peer_addr,
-					0,
-					&timeout);
+                                        sizeof (buf),
+                                        peer_addr,
+                                        0,
+                                        &timeout);
       if (rcv_cnt == -1)
-	{
-	  if (errno == ETIME)
-	    {
-	      ACE_ERROR((LM_ERROR,
-			 ACE_TEXT("(%P|%t) UDP recv on proto %d timed out\n"),
-			 server_addr.get_type ()));
-	    }
-	  else 
-	    {
-	      ACE_ERROR((LM_ERROR,
-			 ACE_TEXT("(%P|%t) UDP recv on proto %d %p\n"),
-			 server_addr.get_type (),
-			 ACE_TEXT("failed")));
-	    }
-	}
+        {
+          if (errno == ETIME)
+          {
+            ACE_ERROR((LM_ERROR,
+                       ACE_TEXT("(%P|%t) UDP recv on proto %d timed out\n"),
+                       server_addr.get_type ()));
+          }
+          else
+          {
+            ACE_ERROR((LM_ERROR,
+                       ACE_TEXT("(%P|%t) UDP recv on proto %d %p\n"),
+                       server_addr.get_type (),
+                       ACE_TEXT("failed")));
+          }
+        }
       else
-	{
-	  // recv() ok, check data and 'from' address
-	  size_t rcv_siz = static_cast<size_t> (rcv_cnt);
-	  if (rcv_siz != sizeof (TEST_DATA))
-	    {
-	      ACE_ERROR ((LM_ERROR,
-			  ACE_TEXT ("(%P|%t) recv cnt %B; should be %B\n"),
-			  rcv_siz,
-			  sizeof (TEST_DATA)));
-	    }
-	  else
-	    {
-	      buf[rcv_siz] = '\0';
-	      if (ACE_OS::strncmp (buf, TEST_DATA, ACE_OS::strlen (TEST_DATA)))
-		ACE_ERROR ((LM_ERROR,
-			    ACE_TEXT ("(%P|%t) recv string should be %s; ")
-			    ACE_TEXT (" but is %s\n"),
-			    TEST_DATA, buf));
-	    }
-	  if (peer_addr.get_type () != server_addr.get_type ())
-	    ACE_ERROR ((LM_ERROR,
-			ACE_TEXT ("(%P|%t) recv addr type %d; should be %d\n"),
-			peer_addr.get_type (),
-			server_addr.get_type ()));
-	  if (peer_addr.get_size () != server_addr.get_size ())
-	    ACE_ERROR ((LM_ERROR,
-			ACE_TEXT ("(%P|%t) recv addr size %d; should be %d\n"),
-			peer_addr.get_size (),
-			server_addr.get_size ()));
-	}
+        {
+          // recv() ok, check data and 'from' address
+          size_t rcv_siz = static_cast<size_t> (rcv_cnt);
+          if (rcv_siz != sizeof (TEST_DATA))
+            {
+              ACE_ERROR ((LM_ERROR,
+                          ACE_TEXT ("(%P|%t) recv cnt %B; should be %B\n"),
+                          rcv_siz,
+                          sizeof (TEST_DATA)));
+            }
+          else
+            {
+              buf[rcv_siz] = '\0';
+              if (ACE_OS::strncmp (buf, TEST_DATA, ACE_OS::strlen (TEST_DATA)))
+                ACE_ERROR ((LM_ERROR,
+                            ACE_TEXT ("(%P|%t) recv string should be %s; ")
+                            ACE_TEXT (" but is %s\n"),
+                            TEST_DATA, buf));
+            }
+          if (peer_addr.get_type () != server_addr.get_type ())
+            ACE_ERROR ((LM_ERROR,
+                        ACE_TEXT ("(%P|%t) recv addr type %d; should be %d\n"),
+                        peer_addr.get_type (),
+                        server_addr.get_type ()));
+          if (peer_addr.get_size () != server_addr.get_size ())
+            ACE_ERROR ((LM_ERROR,
+                        ACE_TEXT ("(%P|%t) recv addr size %d; should be %d\n"),
+                        peer_addr.get_size (),
+                        server_addr.get_size ()));
+        }
     }
 
   cli_dgram.close();
@@ -158,38 +158,38 @@ server (void *arg)
       // recv() ok, check data and 'from' address
       size_t rcv_siz = static_cast<size_t> (rcv_cnt);
       if (rcv_siz != sizeof (TEST_DATA))
-	{
-	  ACE_ERROR ((LM_ERROR,
-		      ACE_TEXT ("(%P|%t) recv cnt %B; should be %B\n"),
-		      rcv_siz,
-		      sizeof (TEST_DATA)));
-	}
+        {
+          ACE_ERROR ((LM_ERROR,
+                      ACE_TEXT ("(%P|%t) recv cnt %B; should be %B\n"),
+                      rcv_siz,
+                      sizeof (TEST_DATA)));
+        }
       else
-	{
-	  buf[rcv_siz / sizeof (ACE_TCHAR)] = '\0';
-	  if (ACE_OS::strncmp (buf, TEST_DATA, ACE_OS::strlen (TEST_DATA)))
-	    ACE_ERROR ((LM_ERROR,
-			ACE_TEXT ("(%P|%t) recv string should be %s; ")
-			ACE_TEXT (" but is %s\n"),
-			TEST_DATA, buf));
-	}
+        {
+          buf[rcv_siz / sizeof (ACE_TCHAR)] = '\0';
+          if (ACE_OS::strncmp (buf, TEST_DATA, ACE_OS::strlen (TEST_DATA)))
+            ACE_ERROR ((LM_ERROR,
+                        ACE_TEXT ("(%P|%t) recv string should be %s; ")
+                        ACE_TEXT (" but is %s\n"),
+                        TEST_DATA, buf));
+        }
 
       if (0 == peer_addr.addr_to_string (hostname_string,
-					 sizeof (hostname_string)))
-	ACE_DEBUG ((LM_DEBUG,
-		    ACE_TEXT ("(%P|%t) Echoing data to %s\n"),
-		    hostname_string));
+          sizeof (hostname_string)))
+        ACE_DEBUG ((LM_DEBUG,
+                    ACE_TEXT ("(%P|%t) Echoing data to %s\n"),
+                    hostname_string));
       else
-	ACE_ERROR ((LM_ERROR,
-		    ACE_TEXT ("(%P|%t) %p\n"),
-		    ACE_TEXT ("addr_to_string")));
-      if (server_dgram->send (TEST_DATA, sizeof (TEST_DATA), 
-			      peer_addr, 0) == -1)
-	{
-	  ACE_ERROR((LM_ERROR,
-		     ACE_TEXT("(%P|%t) %p\n"),
-		     ACE_TEXT("Server UDP send failed")));
-	}
+        ACE_ERROR ((LM_ERROR,
+                    ACE_TEXT ("(%P|%t) %p\n"),
+                    ACE_TEXT ("addr_to_string")));
+      if (server_dgram->send (TEST_DATA, sizeof (TEST_DATA),
+                              peer_addr, 0) == -1)
+        {
+          ACE_ERROR((LM_ERROR,
+                     ACE_TEXT("(%P|%t) %p\n"),
+                     ACE_TEXT("Server UDP send failed")));
+        }
     }
   server_dgram->close ();
 
@@ -216,21 +216,21 @@ spawn (int proto)
   // Bind UDP server to the appropriate port
   if (server_dgram.open (server_addr, proto) == -1)
     ACE_ERROR ((LM_ERROR,
-		ACE_TEXT ("(%P|%t) %p\n"),
-		ACE_TEXT ("server dgram open")));
+                ACE_TEXT ("(%P|%t) %p\n"),
+                ACE_TEXT ("server dgram open")));
   else
     {
       ACE_DEBUG ((LM_DEBUG,
-		  ACE_TEXT ("(%P|%t) started server at proto %d, port %d\n"),
-		  proto,
+                  ACE_TEXT ("(%P|%t) started server at proto %d, port %d\n"),
+                  proto,
                   server_addr.get_port_number ()));
 #if !defined (ACE_LACKS_FORK)
       switch (ACE_OS::fork (ACE_TEXT ("child")))
         {
         case -1:
           ACE_ERROR_BREAK ((LM_ERROR,
-			    ACE_TEXT ("(%P|%t) %p\n"),
-			    ACE_TEXT ("fork failed")));
+                            ACE_TEXT ("(%P|%t) %p\n"),
+                            ACE_TEXT ("fork failed")));
           /* NOTREACHED */
         case 0:
           client (&server_addr);
diff --git a/ACE/tests/SV_Shared_Memory_Test.cpp b/ACE/tests/SV_Shared_Memory_Test.cpp
index 305e3785c96..8fd73b158e6 100644
--- a/ACE/tests/SV_Shared_Memory_Test.cpp
+++ b/ACE/tests/SV_Shared_Memory_Test.cpp
@@ -142,11 +142,11 @@ run_main (int, ACE_TCHAR *[])
     !defined(ACE_LACKS_SYSV_SHMEM)
 
   // Check whether allocator was initialized.
-  if (myallocator ().bad ()) 
+  if (myallocator ().bad ())
     {
       ACE_ERROR_RETURN ((LM_ERROR,
-			 ACE_TEXT ("Unable to initialize allocator\n")),
-			 -1);
+                         ACE_TEXT ("Unable to initialize allocator\n")),
+                         -1);
     }
 
   char *shm = reinterpret_cast<char *> (myallocator ().malloc (SHMSZ));
diff --git a/ACE/tests/Signal_Test.cpp b/ACE/tests/Signal_Test.cpp
index 49d05835568..33e38a36420 100644
--- a/ACE/tests/Signal_Test.cpp
+++ b/ACE/tests/Signal_Test.cpp
@@ -336,7 +336,7 @@ run_test (ACE_THR_FUNC worker,
       int result;
 
       ACE_DEBUG ((LM_DEBUG,
-		  ACE_TEXT ("(%P|%t) spawning worker thread\n")));
+                  ACE_TEXT ("(%P|%t) spawning worker thread\n")));
       result = ACE_Thread_Manager::instance ()->spawn
                 (worker,
                   reinterpret_cast <void *> (handle_signals_synchronously),
@@ -405,10 +405,10 @@ parse_args (int argc, ACE_TCHAR *argv[])
     default:
       ACE_DEBUG ((LM_DEBUG,
                   ACE_TEXT ("(%P|%t) usage:\n")
-		  ACE_TEXT ("-i <iterations>\n")
-		  ACE_TEXT ("-c\n")
-		  ACE_TEXT ("-p <parent_pid>\n")
-		  ACE_TEXT ("-t <test_number>\n")));
+                  ACE_TEXT ("-i <iterations>\n")
+                  ACE_TEXT ("-c\n")
+                  ACE_TEXT ("-p <parent_pid>\n")
+                  ACE_TEXT ("-t <test_number>\n")));
       break;
   }
 }
diff --git a/ACE/tests/Thread_Pool_Reactor_Test.cpp b/ACE/tests/Thread_Pool_Reactor_Test.cpp
index 76112e167fe..b5ebe90e0fe 100644
--- a/ACE/tests/Thread_Pool_Reactor_Test.cpp
+++ b/ACE/tests/Thread_Pool_Reactor_Test.cpp
@@ -64,8 +64,8 @@ static const ACE_TCHAR *rendezvous = ACE_TEXT ("127.0.0.1:10010");
 static size_t svr_thrno = ACE_MAX_THREADS;
 
 #if defined (CHORUS) \
-	|| defined (ACE_VXWORKS) 	// default network parameters (MAX_BINDS and system buffers) are too small for full test
-		// Add platforms that can't handle too many
+  || defined (ACE_VXWORKS)  // default network parameters (MAX_BINDS and system buffers) are too small for full test
+        // Add platforms that can't handle too many
         // connection simultaneously here.
 #define ACE_LOAD_FACTOR /2
 #else
diff --git a/ACE/tests/Vector_Test.cpp b/ACE/tests/Vector_Test.cpp
index 58209680c4f..1d0933d73eb 100644
--- a/ACE/tests/Vector_Test.cpp
+++ b/ACE/tests/Vector_Test.cpp
@@ -49,8 +49,8 @@ int run_main (int, ACE_TCHAR *[])
 
   ACE_ASSERT (vector.size () == TOP);
   ACE_DEBUG ((LM_DEBUG,
-	      ACE_TEXT ("Size: %d\n"),
-	      vector.size ()));
+              ACE_TEXT ("Size: %d\n"),
+              vector.size ()));
 
   for (i = 0; i < TOP; ++i)
     ACE_ASSERT (vector[i] == i);
@@ -79,15 +79,15 @@ int run_main (int, ACE_TCHAR *[])
 
   ACE_ASSERT (vector.size () == LEFT);
   ACE_DEBUG ((LM_DEBUG,
-	      ACE_TEXT ("Size: %d\n"),
-	      vector.size ()));
+              ACE_TEXT ("Size: %d\n"),
+              vector.size ()));
 
   for (i = 0; i < LEFT; ++i)
     {
       ACE_ASSERT (vector[i] == i);
       ACE_DEBUG ((LM_DEBUG,
-            ACE_TEXT ("vector[%d]:%d\n"),
-            i, vector[i]));
+                  ACE_TEXT ("vector[%d]:%d\n"),
+                  i, vector[i]));
     }
 
   vector.resize(RESIZE, 0);
@@ -114,8 +114,8 @@ int run_main (int, ACE_TCHAR *[])
   vector.clear ();
   ACE_ASSERT (vector.size () == 0);
   ACE_DEBUG ((LM_DEBUG,
-	      ACE_TEXT ("Size: %d\n"),
-	      vector.size ()));
+              ACE_TEXT ("Size: %d\n"),
+              vector.size ()));
 
   VECTOR v1;
   VECTOR v2;