Thu Jul 19 03:00:57 UTC 2007 Abdullah Sowayan <abdullah.sowayan@lmco.com>

57 files changed, 454 insertions, 228 deletions

diff --git a/ACE/tests/Auto_Event_Test.cpp b/ACE/tests/Auto_Event_Test.cpp
index e2ed56f46a8..bc1f895746a 100644
--- a/ACE/tests/Auto_Event_Test.cpp
+++ b/ACE/tests/Auto_Event_Test.cpp
@@ -151,8 +151,11 @@ worker (void *)
        iterations <= n_iterations;
        iterations++)
     {
+      //FUZZ: disable check_for_lack_ACE_OS
       ACE_Time_Value wait (0,
                            iterations * 1000 * 100);  // Wait 'iter' msec
+      //FUZZ: enable check_for_lack_ACE_OS
+
       ACE_Time_Value tv = ACE_OS::gettimeofday () + wait;
       if (evt.wait (&tv) == -1)
       {
diff --git a/ACE/tests/Buffer_Stream_Test.cpp b/ACE/tests/Buffer_Stream_Test.cpp
index dde6d876f4c..ce4dc033801 100644
--- a/ACE/tests/Buffer_Stream_Test.cpp
+++ b/ACE/tests/Buffer_Stream_Test.cpp
@@ -45,9 +45,11 @@ class Common_Task : public MT_Task
 public:
   Common_Task (void) {}
 
+  //FUZZ: disable check_for_lack_ACE_OS
   // = ACE_Task hooks.
   virtual int open (void * = 0);
   virtual int close (u_long = 0);
+  //FUZZ: enable check_for_lack_ACE_OS
 };
 
 class Supplier : public Common_Task
diff --git a/ACE/tests/Bug_1890_Regression_Test.cpp b/ACE/tests/Bug_1890_Regression_Test.cpp
index b506197fdb0..3f489c5bad2 100644
--- a/ACE/tests/Bug_1890_Regression_Test.cpp
+++ b/ACE/tests/Bug_1890_Regression_Test.cpp
@@ -37,8 +37,10 @@ class Handler : public ACE_Event_Handler
 public:
     Handler();
 
+    //FUZZ: disable check_for_lack_ACE_OS
     /// Initialize the pipe and register with the reactor
     int open(ACE_Reactor * reactor);
+    //FUZZ: enable check_for_lack_ACE_OS
 
     /// Return the current count
     size_t handle_input_count() const;
@@ -71,8 +73,11 @@ class Timer : public ACE_Event_Handler
 public:
     Timer();
 
+    //FUZZ: disable check_for_lack_ACE_OS
     int open(ACE_Reactor * reactor);
     void close();
+    //FUZZ: enable check_for_lack_ACE_OS
+
     bool check_expected_results() const;
 
     virtual int handle_timeout(ACE_Time_Value const &, void const*);
@@ -296,12 +301,12 @@ Timer::remove_some_handlers()
   for (int i = 0; i != nhandlers; ++i)
     {
       if (-1 == reactor()->remove_handler(&handler_[i], mask))
-	{
+        {
           ACE_ERROR ((LM_ERROR,
                       ACE_TEXT ("Cannot remove handler %d in %p\n"),
                       i,
                       ACE_TEXT ("timeout")));
-	}
+        }
     }
 
   if (-1 == reactor()->register_handler(&special_handler(),
diff --git a/ACE/tests/Bug_2540_Regression_Test.cpp b/ACE/tests/Bug_2540_Regression_Test.cpp
index 694504b7e4a..66f1f4f4ddb 100644
--- a/ACE/tests/Bug_2540_Regression_Test.cpp
+++ b/ACE/tests/Bug_2540_Regression_Test.cpp
@@ -37,8 +37,10 @@ class Handler : public ACE_Event_Handler
 public:
     Handler();
 
+    //FUZZ: disable check_for_lack_ACE_OS
     /// Initialize the pipe and register with the reactor
     int open(ACE_Reactor * reactor);
+    //FUZZ: enable check_for_lack_ACE_OS
 
     /// Return the current count
     size_t handle_input_count() const;
@@ -75,8 +77,11 @@ class Timer : public ACE_Event_Handler
 public:
     Timer();
 
+    //FUZZ: disable check_for_lack_ACE_OS
     int open(ACE_Reactor * reactor);
     void close();
+    //FUZZ: enable check_for_lack_ACE_OS
+
     bool check_expected_results() const;
 
     virtual int handle_timeout(ACE_Time_Value const &, void const*);
@@ -140,16 +145,15 @@ Handler::Handler()
 {
 }
 
-int Handler::
-open(ACE_Reactor * r)
+int Handler::open(ACE_Reactor * r)
 {
     if(-1 == the_pipe_.open(handles_))
     {
-	return -1;
+      return -1;
     }
     if(-1 == r->register_handler(this, ACE_Event_Handler::READ_MASK))
     {
-	return -1;
+      return -1;
     }
     return 0;
 }
@@ -183,8 +187,8 @@ int Handler::handle_input(ACE_HANDLE /* h */)
 
     if(auto_remove_flag_)
     {
-	auto_remove_flag_ = false;
-	return -1;
+      auto_remove_flag_ = false;
+      return -1;
     }
 
     return 0;
@@ -210,15 +214,14 @@ int Timer::open(ACE_Reactor * r)
   {
       if (-1 == handler_[i].open(r))
       {
-	  ACE_ERROR_RETURN ((LM_ERROR, "Could not open dummy handler %d\n", i), -1);
+        ACE_ERROR_RETURN ((LM_ERROR, "Could not open dummy handler %d\n", i), -1);
       }
   }
 
   ACE_Time_Value const interval(0, ACE_ONE_SECOND_IN_USECS / 10);
   ACE_Time_Value const startup (0, ACE_ONE_SECOND_IN_USECS / 20);
 
-  if ( -1 == r->schedule_timer(
-	   this, 0, startup, interval))
+  if ( -1 == r->schedule_timer(this, 0, startup, interval))
   {
       ACE_ERROR_RETURN((LM_ERROR, "Could not schedule timer\n"), -1);
   }
@@ -240,7 +243,7 @@ bool Timer::check_expected_results() const
     // We expect at least one more call after the other handlers are removed.
     if(recorded_count_ + 1 < special_handler().handle_input_count() )
     {
-	return true;
+      return true;
     }
     return false;
 }
@@ -249,41 +252,41 @@ int Timer::handle_timeout(ACE_Time_Value const &, void const *)
 {
     if (iteration_ == 0)
     {
-	// Sending data on the first iteration makes the handles always
-	// "ready" for reading because the Handler::handle_input() function
-	// never consumes the data.
-	send_data_through_handlers();
+      // Sending data on the first iteration makes the handles always
+      // "ready" for reading because the Handler::handle_input() function
+      // never consumes the data.
+      send_data_through_handlers();
     }
 
     ++iteration_;
     if (iteration_ < initial_iterations)
     {
-	// The first iterations are there just to prime things.
-	return 0;
+      // The first iterations are there just to prime things.
+      return 0;
     }
     
     if (iteration_ == initial_iterations)
     {
-	// We expect the special_handler() to work normally after this
-	// iteration, i.e., more calls to handle_input() should be delivered
-	// to it.
-	recorded_count_  = special_handler().handle_input_count();
+      // We expect the special_handler() to work normally after this
+      // iteration, i.e., more calls to handle_input() should be delivered
+      // to it.
+      recorded_count_  = special_handler().handle_input_count();
 
-	// Remove the handlers the next time the loop runs
-	remove_some_handlers();
+      // Remove the handlers the next time the loop runs
+      remove_some_handlers();
 
-	// Run the event loop, this causes the handlers to be removed from the
-	// reactor, except for special_handler()
-	ACE_Time_Value interval(0, ACE_ONE_SECOND_IN_USECS / 50);
-	reactor()->handle_events(&interval);
+      // Run the event loop, this causes the handlers to be removed from the
+      // reactor, except for special_handler()
+      ACE_Time_Value interval(0, ACE_ONE_SECOND_IN_USECS / 50);
+      reactor()->handle_events(&interval);
 
-	return 0;
+      return 0;
     }
 
     if (iteration_ < total_iterations)
     {
-	// Run a while more to make sure the special_handler() is used.
-	return 0;
+      // Run a while more to make sure the special_handler() is used.
+      return 0;
     }
 
     reactor()->end_reactor_event_loop();
@@ -295,7 +298,7 @@ void Timer::send_data_through_handlers()
 {
     for(int i = 0; i != nhandlers; ++i)
     {
-	handler_[i].send_dummy_data();
+      handler_[i].send_dummy_data();
     }
 }
 
@@ -303,7 +306,7 @@ void Timer::remove_some_handlers()
 {
     for(int i = 0; i != nhandlers - 1; ++i)
     {
-	handler_[i].simulate_socket_closure();
+      handler_[i].simulate_socket_closure();
     }
 }
 
diff --git a/ACE/tests/Bug_2609_Regression_Test.cpp b/ACE/tests/Bug_2609_Regression_Test.cpp
index ef30c77a70f..b8c42b5a441 100644
--- a/ACE/tests/Bug_2609_Regression_Test.cpp
+++ b/ACE/tests/Bug_2609_Regression_Test.cpp
@@ -51,12 +51,14 @@ public:
     g_handler_deleted = true;
   }
 
+  //FUZZ: disable check_for_lack_ACE_OS
   int open (void* pv)
   {
     TEST_TRACE ("open");
     g_semaphore.release(); // signal open completed
     return super::open (pv);
   }
+  //FUZZ: enable check_for_lack_ACE_OS
 
   int handle_close (ACE_HANDLE fd, ACE_Reactor_Mask mask)
   {
diff --git a/ACE/tests/Bug_2659_Regression_Test.cpp b/ACE/tests/Bug_2659_Regression_Test.cpp
index 2dd48ea3bce..84f1fb74382 100644
--- a/ACE/tests/Bug_2659_Regression_Test.cpp
+++ b/ACE/tests/Bug_2659_Regression_Test.cpp
@@ -147,7 +147,7 @@ run_main (int, ACE_TCHAR *[])
   }
 
   while (!reactor_task_ready) {
-    ACE_OS:: sleep (1);
+    ACE_OS::sleep (1);
   }
 
   if (thread_manager->kill_all (SIGUSR1) == -1) {
diff --git a/ACE/tests/Bug_2912_Regression_Test.cpp b/ACE/tests/Bug_2912_Regression_Test.cpp
index b2b262e8cc2..bdc1bde3af4 100644
--- a/ACE/tests/Bug_2912_Regression_Test.cpp
+++ b/ACE/tests/Bug_2912_Regression_Test.cpp
@@ -196,13 +196,13 @@ disable_signal (int sigmin, int sigmax)
 #ifndef ACE_WIN32
 
   sigset_t signal_set;
-  if (sigemptyset (&signal_set) == - 1)
+  if (ACE_OS::sigemptyset (&signal_set) == - 1)
     ACE_ERROR ((LM_ERROR,
                 ACE_TEXT ("Error: (%P|%t):%p\n"),
                 ACE_TEXT ("sigemptyset failed")));
 
   for (int i = sigmin; i <= sigmax; i++)
-    sigaddset (&signal_set, i);
+    ACE_OS::sigaddset (&signal_set, i);
 
   //  Put the <signal_set>.
   if (ACE_OS::pthread_sigmask (SIG_BLOCK, &signal_set, 0) != 0)
@@ -228,7 +228,9 @@ public:
 
   virtual ~Server_Service_Handler (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual void open (ACE_HANDLE h, ACE_Message_Block&);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   virtual void handle_read_stream (
     const ACE_Asynch_Read_Stream::Result &result);
@@ -244,10 +246,12 @@ public:
 
   int write_data (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   int read (ACE_Message_Block &mb, size_t bytes_to_read);
 
   int write (ACE_Message_Block &mb, size_t bytes_to_write);
-
+  //FUZZ: enable check_for_lack_ACE_OS
+  
   int safe_to_delete (void) const;
 
 private:
@@ -286,10 +290,13 @@ Server_Service_Handler::open (ACE_HANDLE h, ACE_Message_Block&)
 
   if (this->ssl_stream_.open (*this, h, 0, this->proactor ()) != 0)
   {
+    //FUZZ: disable check_for_lack_ACE_OS
     ACE_DEBUG ((LM_DEBUG,
                 ACE_TEXT("Server_Service_Handler::open: ")
                 ACE_TEXT("ACE_SSL_Asynch_Stream::open failed, %d\n"),
                 (int)errno));
+    //FUZZ: enable check_for_lack_ACE_OS
+
     this->cancel_and_close ();
   }
   else
@@ -531,7 +538,9 @@ public:
 
   virtual Server_Service_Handler *make_handler (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int accept (size_t bytes_to_read = 0, const void *act = 0);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   virtual void handle_accept (const ACE_Asynch_Accept::Result &result);
 
@@ -658,7 +667,9 @@ public:
 
   virtual ~Client_Service_Handler (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual void open (ACE_HANDLE h, ACE_Message_Block&);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   virtual void handle_read_stream (
     const ACE_Asynch_Read_Stream::Result &result);
@@ -674,9 +685,11 @@ public:
 
   int write_data (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   int read (ACE_Message_Block &mb, size_t bytes_to_read);
 
   int write (ACE_Message_Block &mb, size_t bytes_to_write);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   int safe_to_delete (void) const;
 
@@ -997,12 +1010,14 @@ public:
 
   virtual ~Connector (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int connect (
     const ACE_INET_Addr &remote_sap,
     const ACE_INET_Addr &local_sap =
       (const ACE_INET_Addr &)ACE_Addr::sap_any,
     int reuse_addr = 1,
     const void *act = 0);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   virtual int validate_connection (
     const ACE_Asynch_Connect::Result& result,
diff --git a/ACE/tests/CE_fostream.cpp b/ACE/tests/CE_fostream.cpp
index a57c9d7199e..c8c3c606a5f 100644
--- a/ACE/tests/CE_fostream.cpp
+++ b/ACE/tests/CE_fostream.cpp
@@ -41,13 +41,13 @@ ACE_CE_fostream::ACE_CE_fostream()
 
 ACE_CE_fostream::~ACE_CE_fostream()
 {
-    fclose(ostream_);
+    ACE_OS::fclose(ostream_);
 }
 
 
 FILE* ACE_CE_fostream::open(const ACE_TCHAR *prog_name)
 {
-    ostream_ = _wfopen(prog_name, ACE_TEXT("a+"));
+    ostream_ = ACE_OS::fopen(prog_name, ACE_TEXT("a+"));
 
     return ostream_;
 }
@@ -62,14 +62,14 @@ ACE_CE_fostream& ACE_CE_fostream::operator << (NUM_TYPE num_type)
 
 ACE_CE_fostream& ACE_CE_fostream::operator << (const ACE_ANTI_TCHAR* c)
 {
-    fprintf(ostream_, "%s", c);
+    ACE_OS::fprintf(ostream_, "%s", c);
     return *this;
 }
 
 
 ACE_CE_fostream& ACE_CE_fostream::operator << (ACE_ANTI_TCHAR c)
 {
-    fprintf(ostream_, "%c", c);
+    ACE_OS::fprintf(ostream_, "%c", c);
     return *this;
 }
 
diff --git a/ACE/tests/Conn_Test.cpp b/ACE/tests/Conn_Test.cpp
index 2e808d4497b..a48aa715980 100644
--- a/ACE/tests/Conn_Test.cpp
+++ b/ACE/tests/Conn_Test.cpp
@@ -726,8 +726,10 @@ run_main (int argc, ACE_TCHAR *argv[])
   ACE_START_TEST (ACE_TEXT ("Conn_Test"));
   int status = 0;
 
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_Get_Opt getopt (argc, argv, ACE_TEXT ("c:i:s:"));
   for (int c; (c = getopt ()) != -1; )
+    //FUZZ: enable check_for_lack_ACE_OS
     switch (c)
       {
       case 'c':
diff --git a/ACE/tests/Dev_Poll_Reactor_Test.cpp b/ACE/tests/Dev_Poll_Reactor_Test.cpp
index 450eb0a5588..81dbd1f49f4 100644
--- a/ACE/tests/Dev_Poll_Reactor_Test.cpp
+++ b/ACE/tests/Dev_Poll_Reactor_Test.cpp
@@ -53,7 +53,9 @@ public:
 
   Client (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int open (void * = 0);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   virtual int handle_output (ACE_HANDLE handle);
 
diff --git a/ACE/tests/Dynamic_Test.cpp b/ACE/tests/Dynamic_Test.cpp
index f6d2cb723da..9cadc9be433 100644
--- a/ACE/tests/Dynamic_Test.cpp
+++ b/ACE/tests/Dynamic_Test.cpp
@@ -132,20 +132,24 @@ run_main (int, ACE_TCHAR *[])
     ACE_NEW_RETURN (heap, A, 1);
     if (from_stack.dynamic_)
       {
-        printf ("ERROR1\n");
+        ACE_OS::printf ("ERROR1\n");
         ACE_ERROR_RETURN ((LM_ERROR,
                            ACE_TEXT ("dynamic_ is true for an object on the stack\n")),
                           1);
       }
-      else printf ("OK1\n");
+    else 
+      ACE_OS::printf ("OK1\n");
+
     if (!heap->dynamic_)
       {
-        printf ("ERROR2\n");
+        ACE_OS::printf ("ERROR2\n");
         ACE_ERROR_RETURN ((LM_ERROR,
                            ACE_TEXT ("dynamic_ is false for an object from the heap\n")),
                           1);
       }
-      else printf ("OK2\n");
+    else 
+      ACE_OS::printf ("OK2\n");
+
     delete heap;
   }
   ACE_END_TEST;
diff --git a/ACE/tests/FlReactor_Test.cpp b/ACE/tests/FlReactor_Test.cpp
index 7e476287853..9532b6e0a85 100644
--- a/ACE/tests/FlReactor_Test.cpp
+++ b/ACE/tests/FlReactor_Test.cpp
@@ -135,7 +135,10 @@ public:
   Connection_Handler (Test_Window *w = 0,
                       Fl_Box* box = 0);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int open (void *);
+  //FUZZ: enble check_for_lack_ACE_OS
+
   virtual int handle_input (ACE_HANDLE);
 
 private:
diff --git a/ACE/tests/Future_Set_Test.cpp b/ACE/tests/Future_Set_Test.cpp
index 1cbadc1e087..8f2eb9306ef 100644
--- a/ACE/tests/Future_Set_Test.cpp
+++ b/ACE/tests/Future_Set_Test.cpp
@@ -64,11 +64,13 @@ public:
                    Prime_Scheduler * = 0);
   // Constructor.
 
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int open (void *args = 0);
   // Initializer.
 
   virtual int shutdown (void);
   // Terminator.
+  //FUZZ: enable check_for_lack_ACE_OS
 
   virtual ~Prime_Scheduler (void);
   // Destructor.
diff --git a/ACE/tests/Future_Test.cpp b/ACE/tests/Future_Test.cpp
index 8c0090e374d..0470d15c166 100644
--- a/ACE/tests/Future_Test.cpp
+++ b/ACE/tests/Future_Test.cpp
@@ -73,11 +73,13 @@ public:
                    Prime_Scheduler * = 0);
   // Constructor.
 
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int open (void *args = 0);
   // Initializer.
 
   virtual int shutdown (void);
   // Terminator.
+  //FUZZ: enable check_for_lack_ACE_OS
 
   virtual ~Prime_Scheduler (void);
   // Destructor.
diff --git a/ACE/tests/High_Res_Timer_Test.cpp b/ACE/tests/High_Res_Timer_Test.cpp
index c537790691b..5bfcb7ca573 100644
--- a/ACE/tests/High_Res_Timer_Test.cpp
+++ b/ACE/tests/High_Res_Timer_Test.cpp
@@ -113,14 +113,19 @@ run_main (int argc, ACE_TCHAR *argv[])
 
   u_int iterations = 1;
 
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_Get_Opt getopt (argc, argv, ACE_TEXT ("i:"));
   for (int c; (c = getopt ()) != -1; )
-    switch (c)
-      {
-      case 'i':
-        iterations = ACE_OS::atoi (getopt.opt_arg ());
-        break;
-      }
+    {
+      //FUZZ: enable check_for_lack_ACE_OS
+
+      switch (c)
+        {
+        case 'i':
+          iterations = ACE_OS::atoi (getopt.opt_arg ());
+          break;
+        }
+    }
 
   // We don't check for errors if the interval is shorter than this
   // value because the OS has a finite resolution anyway.
diff --git a/ACE/tests/IOStream_Test.cpp b/ACE/tests/IOStream_Test.cpp
index cd3c42a46a0..efa6e8de7d2 100644
--- a/ACE/tests/IOStream_Test.cpp
+++ b/ACE/tests/IOStream_Test.cpp
@@ -109,9 +109,9 @@ operator>> (ACE_SOCK_IOStream & stream, qchar *buf)
   if (c != '"')
     for (*buf++ = c;
 #ifdef CHORUS
-         stream.get (c) && !isspace (c);
+         stream.get (c) && !ACE_OS::ace_isspace (c);
 #else
- (void *) stream.get (c) && !isspace (c);
+         (void *) stream.get (c) && !ACE_OS::ace_isspace (c);
 #endif /* CHORUS */
          *buf++ = c)
       continue;
diff --git a/ACE/tests/Log_Msg_Backend_Test.cpp b/ACE/tests/Log_Msg_Backend_Test.cpp
index 69707ae208d..709978e8ef9 100644
--- a/ACE/tests/Log_Msg_Backend_Test.cpp
+++ b/ACE/tests/Log_Msg_Backend_Test.cpp
@@ -32,9 +32,16 @@ public:
   Backend ()
     : reset_ (false), open_ (false), close_ (false), log_count_ (0) {}
 
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int open (const ACE_TCHAR *logger_key);
+  //FUZZ: enable check_for_lack_ACE_OS
+
   virtual int reset (void);
+  
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int close (void);
+  //FUZZ: enable check_for_lack_ACE_OS
+
   virtual ssize_t log (ACE_Log_Record &log_record);
 
   // Test probes to see if things worked as specified.
diff --git a/ACE/tests/Logging_Strategy_Test.cpp b/ACE/tests/Logging_Strategy_Test.cpp
index 2a53c83606f..6e3739020dd 100644
--- a/ACE/tests/Logging_Strategy_Test.cpp
+++ b/ACE/tests/Logging_Strategy_Test.cpp
@@ -352,9 +352,12 @@ parse_args (int argc, ACE_TCHAR *argv[])
           break;
         case 'i':
           interval_time = ACE_OS::atoi (get_opt.opt_arg ());
+
+          //FUZZ: disable check_for_lack_ACE_OS
           ACE_DEBUG ((LM_DEBUG,
                       ACE_TEXT ("Interval time (s): %d\n"),
                       interval_time));
+          //FUZZ: enable check_for_lack_ACE_OS
           break;
         case 'm':
           max_size_files = ACE_OS::atoi (get_opt.opt_arg ());
diff --git a/ACE/tests/MT_Reference_Counted_Event_Handler_Test.cpp b/ACE/tests/MT_Reference_Counted_Event_Handler_Test.cpp
index f2e52a5c24f..ae9ba5a16c6 100644
--- a/ACE/tests/MT_Reference_Counted_Event_Handler_Test.cpp
+++ b/ACE/tests/MT_Reference_Counted_Event_Handler_Test.cpp
@@ -118,7 +118,9 @@ public:
 
   Pipe (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   int open (void);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   ACE_HANDLE read_handle (void) const;
 
@@ -204,7 +206,9 @@ public:
 
   ssize_t send_message (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   void close (void);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   ACE_HANDLE handle_;
 
@@ -345,7 +349,9 @@ public:
 
   int svc (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   int close (u_long flags);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   int handle_input (ACE_HANDLE);
 
@@ -490,9 +496,11 @@ public:
              ACE_Reactor &reactor,
              int nested_upcalls);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   int connect (ACE_HANDLE &client_handle,
                ACE_HANDLE &server_handle,
                int run_receiver_thread);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   ACE_Thread_Manager &thread_manager_;
 
diff --git a/ACE/tests/Malloc_Test.cpp b/ACE/tests/Malloc_Test.cpp
index 0d6d491a268..50f3378f690 100644
--- a/ACE/tests/Malloc_Test.cpp
+++ b/ACE/tests/Malloc_Test.cpp
@@ -132,7 +132,9 @@ init_test (const void *base_addr = 0)
 #else
   ACE_MMAP_Memory_Pool_Options options (base_addr);
 #endif /* ACE_HAS_WINCE */
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_MMAP_Memory_Pool mmap (MMAP_FILENAME, &options);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   size_t rbyte = 0;
   int ft = 0;
diff --git a/ACE/tests/Manual_Event_Test.cpp b/ACE/tests/Manual_Event_Test.cpp
index 3c914698d56..d4ab9076cd7 100644
--- a/ACE/tests/Manual_Event_Test.cpp
+++ b/ACE/tests/Manual_Event_Test.cpp
@@ -105,7 +105,10 @@ worker (void *)
 
   if (++n_awoken < n_workers)
   {
+    //FUZZ: disable check_for_lack_ACE_OS
     ACE_Time_Value wait (1, 0);   // Wait 10 sec
+    //FUZZ: enable check_for_lack_ACE_OS
+
     ACE_Time_Value tv = ACE_OS::gettimeofday () + wait;
 
     if (evt.wait (&tv) == -1)
@@ -136,8 +139,10 @@ worker (void *)
 
   if (evt.wait() == -1)
   {
+    //FUZZ: disable check_for_lack_ACE_OS
     ACE_DEBUG ((LM_ERROR,
                 ACE_TEXT ("(%P|%t) Failed waiting for signal()\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
   }
 
   ACE_DEBUG ((LM_DEBUG,
@@ -179,8 +184,10 @@ int run_main (int argc, ACE_TCHAR *argv[])
   // Wait 2 sec
   ACE_OS::sleep (2);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_DEBUG ((LM_DEBUG,
               ACE_TEXT ("sending signal()\n")));
+  //FUZZ: enable check_for_lack_ACE_OS
 
   // Signal
   evt.signal();
diff --git a/ACE/tests/Message_Block_Test.cpp b/ACE/tests/Message_Block_Test.cpp
index a4ca3df0e65..fa14d46ab2f 100644
--- a/ACE/tests/Message_Block_Test.cpp
+++ b/ACE/tests/Message_Block_Test.cpp
@@ -27,8 +27,8 @@
 #include "ace/Free_List.h"
 
 ACE_RCSID (tests,
-	   Message_Block_Test,
-	   "$Id$")
+           Message_Block_Test,
+           "$Id$")
 
 // Number of memory allocation strategies used in this test.
 static const int ACE_ALLOC_STRATEGY_NO = 2;
@@ -65,8 +65,10 @@ public:
   // Allows the producer to pass messages to the <Message_Block>.
 
 private:
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int close (u_long);
   // Close hook.
+  //FUZZ: enable check_for_lack_ACE_OS
 };
 
 int
@@ -104,9 +106,9 @@ Worker_Task::svc (void)
       ACE_Message_Block *mb = 0;
 
       if (-1 == this->msg_queue ()->dequeue_head (mb))
-	ACE_ERROR_BREAK ((LM_ERROR,
-			  ACE_TEXT ("(%t) %p\n"),
-			  ACE_TEXT ("Worker_Task dequeue_head")));
+        ACE_ERROR_BREAK ((LM_ERROR,
+                          ACE_TEXT ("(%t) %p\n"),
+                          ACE_TEXT ("Worker_Task dequeue_head")));
 
       size_t length = mb->length ();
 
@@ -118,9 +120,9 @@ Worker_Task::svc (void)
       if (this->next () != 0)
         {
           if (-1 == this->put_next (mb->duplicate ()))
-	    ACE_ERROR_BREAK ((LM_ERROR,
-			      ACE_TEXT ("(%t) %p\n"),
-			      ACE_TEXT ("Worker_Task put_next")));
+            ACE_ERROR_BREAK ((LM_ERROR,
+                              ACE_TEXT ("(%t) %p\n"),
+                              ACE_TEXT ("Worker_Task put_next")));
         }
 
       // If there's no next() Task to send to, then we'll consume the
@@ -131,10 +133,10 @@ Worker_Task::svc (void)
           int i;
 
           if (count != current_count)
-	    ACE_ERROR_BREAK ((LM_ERROR,
-			      ACE_TEXT ("(%t) count from block should be %d ")
-			      ACE_TEXT ("but is %d\n"),
-			      count, current_count));
+            ACE_ERROR_BREAK ((LM_ERROR,
+                              ACE_TEXT ("(%t) count from block should be %d ")
+                              ACE_TEXT ("but is %d\n"),
+                              count, current_count));
 
           ACE_DEBUG ((LM_DEBUG,
                       ACE_TEXT ("(%t) enqueueing %d duplicates\n"),
@@ -162,10 +164,10 @@ Worker_Task::svc (void)
                            (ACE_Time_Value *) &ACE_Time_Value::zero);
 
               if (enqueue_prio_result == -1)
-		ACE_ERROR_BREAK ((LM_ERROR,
-				  ACE_TEXT ("(%t) Pass %d %p\n"),
-				  i,
-				  ACE_TEXT ("Worker_Task enqueue_prio")));
+                ACE_ERROR_BREAK ((LM_ERROR,
+                                  ACE_TEXT ("(%t) Pass %d %p\n"),
+                                  i,
+                                  ACE_TEXT ("Worker_Task enqueue_prio")));
             }
 
           ACE_DEBUG ((LM_DEBUG,
@@ -176,32 +178,32 @@ Worker_Task::svc (void)
           for (i = current_count; i > 0; i--)
             {
               if (-1 == this->msg_queue ()->dequeue_head (dup))
-		ACE_ERROR_BREAK ((LM_ERROR,
-				  ACE_TEXT ("(%t) Dup %d, %p\n"),
-				  i,
-				  ACE_TEXT ("Worker_Task dequeue dups")));
-	      if (count != ACE_OS::atoi ((ACE_TCHAR *)(dup->rd_ptr ())))
-		ACE_ERROR ((LM_ERROR,
-			    ACE_TEXT ("(%t) line %l, Dup %d, block's count ")
-			    ACE_TEXT ("is %d but should be %d\n"),
-			    i,
-			    ACE_OS::atoi ((ACE_TCHAR *)(dup->rd_ptr ())),
-			    count));
-	      if (0 != ACE_OS::strcmp ((ACE_TCHAR *)mb->rd_ptr (),
-				       (ACE_TCHAR *)dup->rd_ptr ()))
-		ACE_ERROR ((LM_ERROR,
-			    ACE_TEXT ("(%t) Dup %d text is %s; ")
-			    ACE_TEXT ("should be %s\n"),
-			    i,
-			    dup->rd_ptr (),
-			    mb->rd_ptr ()));
-	      if (dup->msg_priority () != ACE_DEFAULT_MESSAGE_BLOCK_PRIORITY + 1)
-		ACE_ERROR ((LM_ERROR,
-			    ACE_TEXT ("(%t) Dup %d block priority is %u; ")
-			    ACE_TEXT ("should be %u\n"),
-			    i,
-			    (unsigned int)dup->msg_priority (),
-			    (unsigned int)(ACE_DEFAULT_MESSAGE_BLOCK_PRIORITY + 1)));
+                ACE_ERROR_BREAK ((LM_ERROR,
+                                  ACE_TEXT ("(%t) Dup %d, %p\n"),
+                                  i,
+                                  ACE_TEXT ("Worker_Task dequeue dups")));
+              if (count != ACE_OS::atoi ((ACE_TCHAR *)(dup->rd_ptr ())))
+                ACE_ERROR ((LM_ERROR,
+                            ACE_TEXT ("(%t) line %l, Dup %d, block's count ")
+                            ACE_TEXT ("is %d but should be %d\n"),
+                            i,
+                            ACE_OS::atoi ((ACE_TCHAR *)(dup->rd_ptr ())),
+                            count));
+              if (0 != ACE_OS::strcmp ((ACE_TCHAR *)mb->rd_ptr (),
+                                       (ACE_TCHAR *)dup->rd_ptr ()))
+                ACE_ERROR ((LM_ERROR,
+                            ACE_TEXT ("(%t) Dup %d text is %s; ")
+                            ACE_TEXT ("should be %s\n"),
+                            i,
+                            dup->rd_ptr (),
+                            mb->rd_ptr ()));
+              if (dup->msg_priority () != ACE_DEFAULT_MESSAGE_BLOCK_PRIORITY + 1)
+                ACE_ERROR ((LM_ERROR,
+                            ACE_TEXT ("(%t) Dup %d block priority is %u; ")
+                            ACE_TEXT ("should be %u\n"),
+                            i,
+                            (unsigned int)dup->msg_priority (),
+                            (unsigned int)(ACE_DEFAULT_MESSAGE_BLOCK_PRIORITY + 1)));
               dup->release ();
             }
 
diff --git a/ACE/tests/Multicast_Test.cpp b/ACE/tests/Multicast_Test.cpp
index 8613c1a498b..a1686dc5701 100644
--- a/ACE/tests/Multicast_Test.cpp
+++ b/ACE/tests/Multicast_Test.cpp
@@ -110,7 +110,10 @@ public:
   ~MCT_Config (void)
     {}
 
+  //FUZZ: disable check_for_lack_ACE_OS
   int open (int argc, ACE_TCHAR *argv[]);
+  //FUZZ: enable check_for_lack_ACE_OS
+
   int debug (void) const { return this->debug_;}
   void dump (void) const;
   int groups (void) const { return this->groups_;}
@@ -118,7 +121,11 @@ public:
   u_long role (void) const { return this->role_;}
   int iterations (void) const { return this->iterations_;}
   int ttl (void) const { return this->ttl_;}
+
+  //FUZZ: disable check_for_lack_ACE_OS
   int wait (void) const { return this->wait_;}
+  //FUZZ: enable check_for_lack_ACE_OS
+
   ACE_SOCK_Dgram_Mcast::options options (void) const
   {
     return static_cast<ACE_SOCK_Dgram_Mcast::options> (this->sdm_opts_);
@@ -156,7 +163,9 @@ MCT_Config::open (int argc, ACE_TCHAR *argv[])
   int retval = 0;
   int help = 0;
 
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_Get_Opt getopt (argc, argv, ACE_TEXT (":?"), 1, 1);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   if (getopt.long_option (ACE_TEXT ("GroupStart"),
                           'g',
@@ -218,10 +227,12 @@ MCT_Config::open (int argc, ACE_TCHAR *argv[])
                        ACE_TEXT (" Unable to add help option.\n")),
                       1);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   // Now, let's parse it...
   int c = 0;
   while ((c = getopt ()) != EOF)
     {
+      //FUZZ: enable check_for_lack_ACE_OS
       switch (c)
         {
         case 0:
@@ -633,8 +644,11 @@ public:
             ACE_Reactor *reactor = ACE_Reactor::instance ());
   ~MCT_Task (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   // = Task hooks.
   virtual int open (void *args = 0);
+  //FUZZ: enable check_for_lack_ACE_OS
+
   virtual int svc (void);
 
 private:
@@ -757,8 +771,10 @@ int producer (MCT_Config &config)
 {
   int retval = 0;
 
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_DEBUG ((LM_INFO, ACE_TEXT ("Starting producer...\n")));
   ACE_SOCK_Dgram socket (ACE_sap_any_cast (ACE_INET_Addr &), PF_INET);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   // Note that is is IPv4 specific and needs to be changed once
   //
diff --git a/ACE/tests/Multicast_Test_IPV6.cpp b/ACE/tests/Multicast_Test_IPV6.cpp
index 354066c9975..9a2b29a5572 100644
--- a/ACE/tests/Multicast_Test_IPV6.cpp
+++ b/ACE/tests/Multicast_Test_IPV6.cpp
@@ -112,7 +112,10 @@ public:
   ~MCT_Config (void)
     {}
 
+  //FUZZ: disable check_for_lack_ACE_OS
   int open (int argc, ACE_TCHAR *argv[]);
+  //FUZZ: enable check_for_lack_ACE_OS
+
   int debug (void) const { return this->debug_;}
   void dump (void) const;
   int groups (void) const { return this->groups_;}
@@ -120,7 +123,11 @@ public:
   u_long role (void) const { return this->role_;}
   int iterations (void) const { return this->iterations_;}
   int ttl (void) const { return this->ttl_;}
+
+  //FUZZ: disable check_for_lack_ACE_OS
   int wait (void) const { return this->wait_;}
+  //FUZZ: enable check_for_lack_ACE_OS
+
   ACE_SOCK_Dgram_Mcast::options options (void) const
   {
     return static_cast<ACE_SOCK_Dgram_Mcast::options> (this->sdm_opts_);
@@ -160,7 +167,9 @@ MCT_Config::open (int argc, ACE_TCHAR *argv[])
   int retval = 0;
   int help = 0;
 
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_Get_Opt getopt (argc, argv, ACE_TEXT (":?"), 1, 1);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   if (getopt.long_option (ACE_TEXT ("GroupStart"),
                           'g',
@@ -224,8 +233,11 @@ MCT_Config::open (int argc, ACE_TCHAR *argv[])
 
   // Now, let's parse it...
   int c = 0;
+
+  //FUZZ: disable check_for_lack_ACE_OS
   while ((c = getopt ()) != EOF)
     {
+  //FUZZ: enable check_for_lack_ACE_OS
       switch (c)
         {
         case 0:
@@ -642,9 +654,11 @@ public:
             ACE_Reactor *reactor = ACE_Reactor::instance ());
   ~MCT_Task (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   // = Task hooks.
   virtual int open (void *args = 0);
   virtual int svc (void);
+  //FUZZ: enable check_for_lack_ACE_OS
 
 private:
   const MCT_Config &config_;
@@ -766,8 +780,10 @@ int producer (MCT_Config &config)
 {
   int retval = 0;
 
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_DEBUG ((LM_INFO, ACE_TEXT ("Starting producer...\n")));
   ACE_SOCK_Dgram socket (ACE_sap_any_cast (ACE_INET_Addr &));
+  //FUZZ: enable check_for_lack_ACE_OS
 
   // set the TTL or hop count based on the config.ttl () value
   if (config.ttl () > 1 && config.group_start().get_type() == AF_INET)
diff --git a/ACE/tests/Notify_Performance_Test.cpp b/ACE/tests/Notify_Performance_Test.cpp
index b812630a065..9f7d71d9207 100644
--- a/ACE/tests/Notify_Performance_Test.cpp
+++ b/ACE/tests/Notify_Performance_Test.cpp
@@ -166,11 +166,13 @@ run_main (int argc, ACE_TCHAR *argv[])
 {
   ACE_START_TEST (ACE_TEXT ("Notify_Performance_Test"));
 
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_Get_Opt getopt (argc, argv, ACE_TEXT ("pswdc:l:"));
-
+  
   for (int c; (c = getopt ()) != -1; )
     switch (c)
       {
+  //FUZZ: enable check_for_lack_ACE_OS
       case 'p':
         opt_dev_poll_reactor = 1;
         break;
diff --git a/ACE/tests/OS_Test.cpp b/ACE/tests/OS_Test.cpp
index a0c3681ecad..8c55318ba2c 100644
--- a/ACE/tests/OS_Test.cpp
+++ b/ACE/tests/OS_Test.cpp
@@ -287,9 +287,11 @@ string_emulation_test (void)
 
 #if defined (ACE_HAS_WCHAR)
   {
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test itoa (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing itoa (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     wchar_t itow1[33];
 
@@ -303,9 +305,11 @@ string_emulation_test (void)
                                 ACE_TEXT_WIDE ("2a")) == 0);
 
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strcmp (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strcmp (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     const wchar_t *strcmp1 = ACE_TEXT_WIDE ("stringf");
     const wchar_t *strcmp2 = ACE_TEXT_WIDE ("stringfe");
@@ -319,9 +323,11 @@ string_emulation_test (void)
     ACE_ASSERT (ACE_OS::strcmp (strcmp1, strcmp4) != 0);
     ACE_ASSERT (ACE_OS::strcmp (strcmp1, strcmp5) > 0);
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strcpy (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strcpy (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     const wchar_t *strcpy1 = ACE_TEXT_WIDE ("abcdefghijklmnopqrstuvwxyz");
     wchar_t strcpy2[27];
@@ -331,9 +337,11 @@ string_emulation_test (void)
                        strcpy1) == 0);
     ACE_ASSERT (ACE_OS::strcmp (strcpy2, strcpy1) == 0);
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strcat (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strcat (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     const wchar_t *strcat1 = ACE_TEXT_WIDE ("abcdefghijklmnopqrstuvwxyz");
     wchar_t strcat2[27] = ACE_TEXT_WIDE ("abcdefghijkl");
@@ -344,9 +352,11 @@ string_emulation_test (void)
                        strcat1) == 0);
     ACE_ASSERT (ACE_OS::strcmp (strcat2, strcat1) == 0);
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strncat (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strncat (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     const wchar_t *strncat1 = ACE_TEXT_WIDE ("abcdefghijklmnopqrstuvwxyz");
     wchar_t strncat2[27] = ACE_TEXT_WIDE ("abcdefghijkl");
@@ -357,9 +367,11 @@ string_emulation_test (void)
                        strncat1) == 0);
     ACE_ASSERT (ACE_OS::strcmp (strncat2, strncat1) == 0);
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strspn (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strspn (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     const wchar_t *strspn1 = ACE_TEXT_WIDE ("abcdefghijkabcdefghijk");
 
@@ -368,9 +380,11 @@ string_emulation_test (void)
     ACE_ASSERT (ACE_OS::strspn (strspn1,
                                 ACE_TEXT_WIDE ("mno")) == 0);
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strchr (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strchr (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     const wchar_t *strchr1 = ACE_TEXT_WIDE ("abcdefghijkabcdefghijk");
 
@@ -380,9 +394,11 @@ string_emulation_test (void)
                 == strchr1 + 7);
     ACE_ASSERT (ACE_OS::strchr (strchr1, ACE_TEXT_WIDE ('1')) == 0);
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strstr (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strstr (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     const wchar_t *strstr1 = ACE_TEXT_WIDE ("abcdefghijkabcdefghijk");
 
@@ -394,9 +410,11 @@ string_emulation_test (void)
     ACE_ASSERT (ACE_OS::strstr (strstr1,
                                 ACE_TEXT_WIDE ("mno")) == 0);
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strlen (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strlen (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     const wchar_t *strlen1 = ACE_TEXT_WIDE ("");
     const wchar_t *strlen2 = ACE_TEXT_WIDE ("12345");
@@ -404,9 +422,11 @@ string_emulation_test (void)
     ACE_ASSERT (ACE_OS::strlen (strlen1) == 0);
     ACE_ASSERT (ACE_OS::strlen (strlen2) == 5);
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strpbrk (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strpbrk (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     const wchar_t *strpbrk1 = ACE_TEXT_WIDE ("abcdefghijkabcdefghijk");
 
@@ -415,9 +435,11 @@ string_emulation_test (void)
     ACE_ASSERT (ACE_OS::strpbrk (strpbrk1,
                                         ACE_TEXT_WIDE ("mno")) == 0);
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strrchr (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strrchr (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     const wchar_t *strrchr1 = ACE_TEXT_WIDE ("abcdefghijkabcdefghijk");
 
@@ -428,9 +450,11 @@ string_emulation_test (void)
     ACE_ASSERT (ACE_OS::strrchr (strrchr1, ACE_TEXT_WIDE ('1'))
                   == 0);
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strcasecmp (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strcasecmp (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     const wchar_t *strcasecmp1 = ACE_TEXT_WIDE ("stringf");
     const wchar_t *strcasecmp2 = ACE_TEXT_WIDE ("stringfe");
@@ -444,9 +468,11 @@ string_emulation_test (void)
     ACE_ASSERT (ACE_OS::strcasecmp (strcasecmp1, strcasecmp4) == 0);
     ACE_ASSERT (ACE_OS::strcasecmp (strcasecmp1, strcasecmp5) > 0);
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strncasecmp (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strncasecmp (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     const wchar_t *strncasecmp1 = ACE_TEXT_WIDE ("stringf");
     const wchar_t *strncasecmp2 = ACE_TEXT_WIDE ("stringfe");
@@ -465,9 +491,11 @@ string_emulation_test (void)
     ACE_ASSERT
       (ACE_OS::strncasecmp (strncasecmp1, strncasecmp5, 7) > 0);
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strncmp (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strncmp (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     const wchar_t *strncmp1 = ACE_TEXT_WIDE ("stringf");
     const wchar_t *strncmp2 = ACE_TEXT_WIDE ("stringfe");
@@ -481,9 +509,11 @@ string_emulation_test (void)
     ACE_ASSERT (ACE_OS::strncmp (strncmp1, strncmp4, 7) != 0);
     ACE_ASSERT (ACE_OS::strncmp (strncmp1, strncmp5, 7) > 0);
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strncpy (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strncpy (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     wchar_t strncpy1[] = ACE_TEXT_WIDE ("abcdefghijklmnopqrstuvwxyzabc");
     wchar_t strncpy2[27];
@@ -499,9 +529,12 @@ string_emulation_test (void)
     strncpy2[26] = 0;
     ACE_ASSERT (ACE_OS::strcmp (strncpy2, strncpy1) == 0);
 
+    //FUZZ: disable check_for_lack_ACE_OS
     // ========================================================================
     // Test strtok (wchar_t version)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing strtok (wchar_t version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
+
     wchar_t strtok_r1[] = ACE_TEXT_WIDE ("A string of tokens");
 
     ACE_ASSERT (ACE_OS::strcmp (ACE_OS::strtok (strtok_r1,
@@ -541,7 +574,7 @@ snprintf_test (void)
   if (retval != 3)
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT ("[1] ACE_OS::snprintf() returns %d, should be 3\n"),
+                  ACE_TEXT ("[1] ACE_OS::snprintf() returns %d, should be 3\n"),
                   retval));
       ++error_count;
     }
@@ -554,7 +587,7 @@ snprintf_test (void)
   if (retval != 4)
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT ("[2] ACE_OS::snprintf() returns %d, should be 4\n"),
+                  ACE_TEXT ("[2] ACE_OS::snprintf() returns %d, should be 4\n"),
                   retval));
       ++error_count;
     }
@@ -563,13 +596,13 @@ snprintf_test (void)
   if (buf[3] != 0)
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT ("[3] ACE_OS::snprintf() doesn't terminate string correctly\n")));
+                  ACE_TEXT ("[3] ACE_OS::snprintf() doesn't terminate string correctly\n")));
       ++error_count;
     }
   else if (ACE_OS::strcmp(buf, "123") != 0)
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT ("[4] ACE_OS::snprintf() incorrect output\n")));
+                  ACE_TEXT ("[4] ACE_OS::snprintf() incorrect output\n")));
       ++error_count;
     }
 
@@ -578,20 +611,20 @@ snprintf_test (void)
   if (retval != 5)
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT ("[5] ACE_OS::snprintf() returns %d, should be 5\n"),
+                  ACE_TEXT ("[5] ACE_OS::snprintf() returns %d, should be 5\n"),
                   retval));
       ++error_count;
     }
   else if (buf[3] != 0)
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT ("[6] ACE_OS::snprintf() doesn't terminate string correctly\n")));
+                  ACE_TEXT ("[6] ACE_OS::snprintf() doesn't terminate string correctly\n")));
       ++error_count;
     }
   else if (ACE_OS::strcmp(buf, "123") != 0)
     {
       ACE_ERROR ((LM_ERROR,
-		  ACE_TEXT ("[6] ACE_OS::snprintf() incorrect output\n")));
+                  ACE_TEXT ("[6] ACE_OS::snprintf() incorrect output\n")));
       ++error_count;
     }
 
@@ -668,9 +701,11 @@ int
 string_strsncpy_test (void)
 {
   {
+    //FUZZ: disable check_for_lack_ACE_OS
     // Test strsncpy (char version)
     ACE_DEBUG ((LM_DEBUG,
                 ACE_TEXT ("Testing strsncpy (char version)\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
 
     char strsncpy1[] =  "abcdefghijklmnopqrstuvwxyzabc";
     char strsncpy2[36];
@@ -736,9 +771,11 @@ string_strsncpy_test (void)
 
 #if defined (ACE_HAS_WCHAR)
   {
+    //FUZZ: disable check_for_lack_ACE_OS
     // Test strsncpy (wchar_t version)
      ACE_DEBUG ((LM_DEBUG,
                 ACE_TEXT ("Testing strsncpy (wchar_t version)\n")));
+     //FUZZ: enable check_for_lack_ACE_OS
 
     wchar_t strsncpy1[] = ACE_TEXT_WIDE ("abcdefghijklmnopqrstuvwxyzabc");
     wchar_t strsncpy2[36];
diff --git a/ACE/tests/Pipe_Test.cpp b/ACE/tests/Pipe_Test.cpp
index 883f1db5126..ad7bb728646 100644
--- a/ACE/tests/Pipe_Test.cpp
+++ b/ACE/tests/Pipe_Test.cpp
@@ -75,10 +75,13 @@ parse_args (int argc, ACE_TCHAR *argv[])
 
 // Consolidate the ACE_Pipe initializations.
 
+//FUZZ: disable check_for_lack_ACE_OS
 static void
 open (ACE_Pipe &pipe,
       const char *name)
 {
+//FUZZ: enable check_for_lack_ACE_OS
+
   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("opening %C\n"), name));
   int result = pipe.open ();
 
@@ -101,11 +104,13 @@ run_main (int argc, ACE_TCHAR *argv[])
       ACE_APPEND_LOG (ACE_TEXT("Pipe_Test-children"));
       ACE_Pipe a, b, c, d, e;
 
+      //FUZZ: disable check_for_lack_ACE_OS
       open (a, "a");
       open (b, "b");
       open (c, "c");
       open (d, "d");
       open (e, "e");
+      //FUZZ: enable check_for_lack_ACE_OS
 
       ACE_END_LOG;
     }
diff --git a/ACE/tests/Priority_Reactor_Test.cpp b/ACE/tests/Priority_Reactor_Test.cpp
index 9d581b2d44c..463b43a22e7 100644
--- a/ACE/tests/Priority_Reactor_Test.cpp
+++ b/ACE/tests/Priority_Reactor_Test.cpp
@@ -238,11 +238,13 @@ run_main (int argc, ACE_TCHAR *argv[])
 {
   ACE_START_TEST (ACE_TEXT ("Priority_Reactor_Test"));
 
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_Get_Opt getopt (argc, argv, ACE_TEXT ("dc:l:m:t:"));
 
   for (int c; (c = getopt ()) != -1; )
     switch (c)
       {
+  //FUZZ: enable check_for_lack_ACE_OS
       case 'd':
         opt_priority_reactor = 0;
         break;
diff --git a/ACE/tests/Priority_Task_Test.cpp b/ACE/tests/Priority_Task_Test.cpp
index 3c4cf5c7bd6..3ae0144dcd7 100644
--- a/ACE/tests/Priority_Task_Test.cpp
+++ b/ACE/tests/Priority_Task_Test.cpp
@@ -43,9 +43,11 @@ public:
   Priority_Task (void);
   // The constructor
 
+  //FUZZ: disable check_for_lack_ACE_OS
   int open (void *);
   // Receives the priority and run svc() on a separate thread at that
   // priority.
+  //FUZZ: enable check_for_lack_ACE_OS
 
   int svc (void);
   // Runs on a separate thread an checks the priority.
diff --git a/ACE/tests/Proactor_Scatter_Gather_Test.cpp b/ACE/tests/Proactor_Scatter_Gather_Test.cpp
index acc7e11c5b7..baa08f9d9ad 100644
--- a/ACE/tests/Proactor_Scatter_Gather_Test.cpp
+++ b/ACE/tests/Proactor_Scatter_Gather_Test.cpp
@@ -279,9 +279,12 @@ public:
   Receiver  (Acceptor *acceptor = 0, int index = -1);
   virtual ~Receiver (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   /// This is called after the new connection has been accepted.
   virtual void open (ACE_HANDLE handle,
                      ACE_Message_Block &message_block);
+  //FUZZ: enable check_for_lack_ACE_OS
+
 protected:
   /// This is called by the framework when asynchronous <read> operation from the
   /// socket completes.
@@ -319,7 +322,9 @@ public:
   Writer (void);
   virtual ~Writer (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   void open (void);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   // this is *not* a callback from the framework
   int handle_read_chunks_chain (ACE_Message_Block *mb,
@@ -918,9 +923,11 @@ public:
 
   virtual ~Sender (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   /// This is called after the new connection has been established.
   virtual void open (ACE_HANDLE handle,
                      ACE_Message_Block &message_block);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   // This is called by the framework when asynchronous reads from the
   // file complete.
diff --git a/ACE/tests/Proactor_Test.cpp b/ACE/tests/Proactor_Test.cpp
index 3ac7f7f620b..1b42afb8c7c 100644
--- a/ACE/tests/Proactor_Test.cpp
+++ b/ACE/tests/Proactor_Test.cpp
@@ -125,13 +125,13 @@ disable_signal (int sigmin, int sigmax)
 #ifndef ACE_WIN32
 
   sigset_t signal_set;
-  if (sigemptyset (&signal_set) == - 1)
+  if (ACE_OS::sigemptyset (&signal_set) == - 1)
     ACE_ERROR ((LM_ERROR,
                 ACE_TEXT ("Error: (%P|%t):%p\n"),
                 ACE_TEXT ("sigemptyset failed")));
 
   for (int i = sigmin; i <= sigmax; i++)
-    sigaddset (&signal_set, i);
+    ACE_OS::sigaddset (&signal_set, i);
 
   //  Put the <signal_set>.
   if (ACE_OS::pthread_sigmask (SIG_BLOCK, &signal_set, 0) != 0)
diff --git a/ACE/tests/Proactor_Test_IPV6.cpp b/ACE/tests/Proactor_Test_IPV6.cpp
index 9958d41e8d0..0ac98651378 100644
--- a/ACE/tests/Proactor_Test_IPV6.cpp
+++ b/ACE/tests/Proactor_Test_IPV6.cpp
@@ -125,13 +125,13 @@ disable_signal (int sigmin, int sigmax)
 #ifndef ACE_WIN32
 
   sigset_t signal_set;
-  if (sigemptyset (&signal_set) == - 1)
+  if (ACE_OS::sigemptyset (&signal_set) == - 1)
     ACE_ERROR ((LM_ERROR,
                 ACE_TEXT ("Error: (%P|%t):%p\n"),
                 ACE_TEXT ("sigemptyset failed")));
 
   for (int i = sigmin; i <= sigmax; i++)
-    sigaddset (&signal_set, i);
+    ACE_OS::sigaddset (&signal_set, i);
 
   //  Put the <signal_set>.
   if (ACE_OS::pthread_sigmask (SIG_BLOCK, &signal_set, 0) != 0)
diff --git a/ACE/tests/QtReactor_Test.cpp b/ACE/tests/QtReactor_Test.cpp
index 1bbb2d43c74..909b74e5188 100644
--- a/ACE/tests/QtReactor_Test.cpp
+++ b/ACE/tests/QtReactor_Test.cpp
@@ -68,13 +68,15 @@ ACE_RCSID (tests,
 
 QTestApplication::QTestApplication (int argc, char *argv[]):
   QApplication (argc, argv, FALSE) /* do not enable GUI */
- {
-	connect (&finishTimer_, SIGNAL (timeout ()), this, SLOT (finishTest ()));
+{
+  //FUZZ: disable check_for_lack_ACE_OS
+  connect (&finishTimer_, SIGNAL (timeout ()), this, SLOT (finishTest ()));
+  //FUZZ: enable check_for_lack_ACE_OS
 }
 
 void QTestApplication::finishTest ()
 {
-  exit ();
+  ACE_OS::exit ();
 }
 
 void QTestApplication::exec (int msec)
@@ -116,9 +118,9 @@ const int TCPClientPings = 16;
 const int TCPTotalBytesToSend = TCPClientPings * TCPBytesToSend;
 
 /**
-	\class DgramHandler
-	\brief Simple event handler that receives and counts datagrams
-	as well as sends dgrams using timeouts.
+  \class DgramHandler
+  \brief Simple event handler that receives and counts datagrams
+  as well as sends dgrams using timeouts.
 */
 class DgramHandler: public ACE_Event_Handler
 {
@@ -126,10 +128,13 @@ public:
   DgramHandler (ACE_Reactor *p_reactor = 0);
   virtual ~DgramHandler ();
 
+  //FUZZ: disable check_for_lack_ACE_OS
   int  open (const ACE_INET_Addr &local,
              int protocol_family=ACE_PROTOCOL_FAMILY_INET,
              int protocol=0,
              int reuse_addr=0);
+  //FUZZ: enable check_for_lack_ACE_OS
+
   virtual ACE_HANDLE get_handle () const;
   virtual int handle_input (ACE_HANDLE handle);
   virtual int handle_close (ACE_HANDLE handle,ACE_Reactor_Mask close_mask);
@@ -148,8 +153,8 @@ private:
 };
 
 /**
-	\class TCPConnectionHandler
-	\brief TCP stream handler for both sides of connection.
+  \class TCPConnectionHandler
+  \brief TCP stream handler for both sides of connection.
 */
 class TCPConnectionHandler : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>
 {
@@ -162,7 +167,10 @@ public:
   virtual int handle_output (ACE_HANDLE handle);
   virtual int handle_input (ACE_HANDLE handle);
   virtual int handle_close (ACE_HANDLE handle,ACE_Reactor_Mask close_mask);
+
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int open (void * = 0);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   int scheduleSend (ACE_Message_Block *);
   int sendBuffers ();
@@ -225,11 +233,11 @@ private:
 */
 
 DgramHandler::DgramHandler (ACE_Reactor *p_reactor):
-	ACE_Event_Handler (p_reactor),
-	dgramsSent_ (0),
-	dgramsReceived_ (0),
-	timeoutsTriggered_ (0),
-	expectedTriggers_ (0)
+  ACE_Event_Handler (p_reactor),
+  dgramsSent_ (0),
+  dgramsReceived_ (0),
+  timeoutsTriggered_ (0),
+  expectedTriggers_ (0)
 {
   reference_counting_policy ().value (Reference_Counting_Policy::ENABLED);
 }
@@ -240,9 +248,9 @@ DgramHandler::~DgramHandler ()
 }
 
 int  DgramHandler::open (const ACE_INET_Addr &local,
-	int protocol_family,
-	int protocol,
-	int reuse_addr)
+  int protocol_family,
+  int protocol,
+  int reuse_addr)
 {
   if (0 > peer_.open (local,
                       protocol_family,
@@ -291,10 +299,9 @@ int DgramHandler::handle_timeout (const ACE_Time_Value &current_time, const void
     reactor ()->cancel_timer (this, 1);
 
   ACE_SOCK_Dgram socket;
-  if (-1 == socket.open (
-			 ACE_INET_Addr (static_cast< u_short > (0),
+  if (-1 == socket.open (ACE_INET_Addr (static_cast< u_short > (0),
                                         static_cast< ACE_UINT32 > (INADDR_ANY)),
-			 ACE_PROTOCOL_FAMILY_INET, 0, 1))
+                                        ACE_PROTOCOL_FAMILY_INET, 0, 1))
     ACE_ERROR ((LM_ERROR,
                 ACE_TEXT (" (%P) %p \n"),
                 ACE_TEXT ("Cannot open socket for sending Qt dgrams")));
@@ -360,11 +367,11 @@ int DgramHandler::expectedTriggers () const
 */
 
 TCPConnectionHandler::TCPConnectionHandler (bool p_serverSide):
-	buffers_ (0),
-	totalReceived_ (0),
-	totalSent_ (0),
-	serverSide_ (p_serverSide),
-	pingsNo_ (TCPClientPings)
+  buffers_ (0),
+  totalReceived_ (0),
+  totalSent_ (0),
+  serverSide_ (p_serverSide),
+  pingsNo_ (TCPClientPings)
 {
   reference_counting_policy ().value (Reference_Counting_Policy::ENABLED);
 }
@@ -531,8 +538,8 @@ int TCPConnectionHandler::totalSent () const
 */
 
 HandlersRegister::HandlersRegister (ACE_Reactor *p_reactor):
-	reactor_ (p_reactor),
-	TCPServersNo_ (0)
+  reactor_ (p_reactor),
+  TCPServersNo_ (0)
 {
   int i;
 
@@ -814,7 +821,7 @@ int HandlersRegister::analyzeTCP () const
 */
 
 TCPAcceptorHandler::TCPAcceptorHandler (HandlersRegister *p_handlersRegister):
-	handlersRegister_ (p_handlersRegister)
+  handlersRegister_ (p_handlersRegister)
 {
   reference_counting_policy ().value (Reference_Counting_Policy::ENABLED);
 }
diff --git a/ACE/tests/Reactor_Notify_Test.cpp b/ACE/tests/Reactor_Notify_Test.cpp
index e36b01d1d05..b3ea04794e0 100644
--- a/ACE/tests/Reactor_Notify_Test.cpp
+++ b/ACE/tests/Reactor_Notify_Test.cpp
@@ -48,11 +48,13 @@ public:
   ~Supplier_Task (void);
   // Destructor.
 
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int open (void * = 0);
   // Make this an Active Object.
 
   virtual int close (u_long);
   // Close down the supplier.
+  //FUZZ: enable check_for_lack_ACE_OS
 
   virtual int svc (void);
   // Generates events and sends them to the <Reactor>'s <notify>
diff --git a/ACE/tests/Reactor_Performance_Test.cpp b/ACE/tests/Reactor_Performance_Test.cpp
index 7d5aacc6456..d20b4199528 100644
--- a/ACE/tests/Reactor_Performance_Test.cpp
+++ b/ACE/tests/Reactor_Performance_Test.cpp
@@ -315,8 +315,10 @@ run_main (int argc, ACE_TCHAR *argv[])
 {
   ACE_START_TEST (ACE_TEXT ("Reactor_Performance_Test"));
 
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_Get_Opt getopt (argc, argv, ACE_TEXT ("dswc:l:"), 1);
   for (int c; (c = getopt ()) != -1; )
+  //FUZZ: enble check_for_lack_ACE_OS
     switch (c)
       {
       case 's':
diff --git a/ACE/tests/Reactors_Test.cpp b/ACE/tests/Reactors_Test.cpp
index f1daf382a18..0354483105d 100644
--- a/ACE/tests/Reactors_Test.cpp
+++ b/ACE/tests/Reactors_Test.cpp
@@ -42,10 +42,12 @@ public:
   Test_Task (void);
   ~Test_Task (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   // = Task hooks.
   virtual int open (void *args = 0);
   virtual int close (u_long flags = 0);
   virtual int svc (void);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   // = Event Handler hooks.
   virtual int handle_input (ACE_HANDLE handle);
diff --git a/ACE/tests/Recursive_Condition_Bug_Test.cpp b/ACE/tests/Recursive_Condition_Bug_Test.cpp
index f74e9ac94e0..26478456bd4 100644
--- a/ACE/tests/Recursive_Condition_Bug_Test.cpp
+++ b/ACE/tests/Recursive_Condition_Bug_Test.cpp
@@ -83,8 +83,10 @@ public:
     return 0;
   }
 
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int open (void * = 0)
   {
+  //FUZZ: enable check_for_lack_ACE_OS
     if (ACE_Task<ACE_MT_SYNCH>::activate (THR_NEW_LWP, 1) != 0)
       ACE_ERROR_RETURN ((LM_ERROR,
                          ACE_TEXT ("(%t) %p\n"),
diff --git a/ACE/tests/Refcounted_Auto_Ptr_Test.cpp b/ACE/tests/Refcounted_Auto_Ptr_Test.cpp
index fd6552a89b1..8331908d150 100644
--- a/ACE/tests/Refcounted_Auto_Ptr_Test.cpp
+++ b/ACE/tests/Refcounted_Auto_Ptr_Test.cpp
@@ -85,11 +85,13 @@ public:
   /// Constructor.
   Scheduler (Scheduler * = 0);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   /// Initializer.
   virtual int open (void *args = 0);
 
   /// Terminator.
   virtual int close (u_long flags = 0);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   /// Destructor.
   virtual ~Scheduler (void);
diff --git a/ACE/tests/SOCK_Dgram_Bcast_Test.cpp b/ACE/tests/SOCK_Dgram_Bcast_Test.cpp
index dc1c9ffe71f..dbd74587d26 100644
--- a/ACE/tests/SOCK_Dgram_Bcast_Test.cpp
+++ b/ACE/tests/SOCK_Dgram_Bcast_Test.cpp
@@ -200,14 +200,14 @@ int run_auto_test (const ACE_TCHAR *prog_name)
 
 void print_usage (void)
 {
-    printf("Usage:SOCK_Dgram_Bast_Test [-p port] [-n dgrams_no] [-t timeout_ms] [-s] [-r]\n"
-        "\tp broadcast port [14521]\n"
-        "\tn number of datagrams to broadcast [30] (<0 infinite)\n"
-        "\tt timeout in seconds for receive [5] (<=0 infinite)\n"
-        "\ts send datagrams and exit\n"
-        "\tr receive one datagram and exit\n\n"
-        "\t  run auto-test when no r and s option is passed\n"
-        "\t  test failures are minifested by -1 exit value, otherwise 0\n");
+  ACE_OS::printf("Usage:SOCK_Dgram_Bast_Test [-p port] [-n dgrams_no] [-t timeout_ms] [-s] [-r]\n"
+                 "\tp broadcast port [14521]\n"
+                 "\tn number of datagrams to broadcast [30] (<0 infinite)\n"
+                 "\tt timeout in seconds for receive [5] (<=0 infinite)\n"
+                 "\ts send datagrams and exit\n"
+                 "\tr receive one datagram and exit\n\n"
+                 "\t  run auto-test when no r and s option is passed\n"
+                 "\t  test failures are minifested by -1 exit value, otherwise 0\n");
 }
 
 int run_main (int argc, ACE_TCHAR *argv[])
diff --git a/ACE/tests/SOCK_Netlink_Test.cpp b/ACE/tests/SOCK_Netlink_Test.cpp
index 65ffdf697cb..0acd75637d6 100644
--- a/ACE/tests/SOCK_Netlink_Test.cpp
+++ b/ACE/tests/SOCK_Netlink_Test.cpp
@@ -210,11 +210,13 @@ public:
   // Destructor
   virtual ~Secondary_Ipaddr_Handler (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   // Initialization. Schedules a timer to run start the business.
   //
   int open (ACE_Reactor *const reactor,
             char* const ip_slash_mask,
             const char *const if_name);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   // Returns reference to netlink socket. Necessary for reactor.
   virtual ACE_HANDLE get_handle (void) const;
@@ -264,11 +266,13 @@ public:
 
 protected:
 
+  //FUZZ: disable check_for_lack_ACE_OS
   // De-registers the handler from the reactor,
   // other cleanup jobs
   virtual int close ();
 
   ACE_SOCK_Netlink& socket ();
+  //FUZZ: enable check_for_lack_ACE_OS
 
 private:
 
@@ -382,10 +386,12 @@ Secondary_Ipaddr_Handler::open (ACE_Reactor *const reactor,
   if (this->socket ().open (this->address_,
                             ACE_PROTOCOL_FAMILY_NETLINK,
                             NETLINK_ROUTE) == -1)
+    //FUZZ: disable check_for_lack_ACE_OS
     ACE_ERROR_RETURN ((LM_ERROR,
                        ACE_TEXT("(%P|%t) Secondary_Ipaddr_Handler::open: - failed \n")
                        ACE_TEXT("to initialize netlink socket bu open (). \n")),
                       -1);
+    //FUZZ: enable check_for_lack_ACE_OS
 
   // register with the reactor for input
   if (this->reactor ()->register_handler (this,
@@ -403,7 +409,7 @@ Secondary_Ipaddr_Handler::open (ACE_Reactor *const reactor,
                        ACE_TEXT("can't schedule timer with reactor.\n")),
                       -1);
 
-  this->seq_ = time (0);
+  this->seq_ = ACE_OS::time (0);
 
   ACE_OS::strncpy (this->ip_buff_,
                    ip_slash_mask,
@@ -499,7 +505,7 @@ Secondary_Ipaddr_Handler::handle_input (ACE_HANDLE)
                       ACE_TEXT("(%P) Secondary_Ipaddr_Handler::handle_input -  command informs about error \n")));
 
           // some error message
-          perror("rtnetlink error message: ");
+          ACE_OS::perror("rtnetlink error message: ");
 
           return 0;
         }
@@ -661,7 +667,7 @@ Secondary_Ipaddr_Handler::fill_inet_prefix (
           else
             *dot = '\0';
         }
-      int num = atoi (to_search);
+      int num = ACE_OS::atoi (to_search);
       if (num < 0 || num > 255)
         return -1;
       else
@@ -789,7 +795,7 @@ Secondary_Ipaddr_Handler::init_netlink_request (
   if (get_if_index (if_name,
                     interface_index) == -1 || interface_index < 0)
     {
-      fprintf (stderr, "get_if_index () - failed\n");
+      ACE_OS::fprintf (stderr, "get_if_index () - failed\n");
       return -1;
     }
   net_req.ifa_.ifa_index = interface_index;
@@ -799,7 +805,7 @@ Secondary_Ipaddr_Handler::init_netlink_request (
   if (fill_inet_prefix (local_prefix,
                         ip_slash_netmask) == -1)
     {
-      fprintf (stderr, "fill_inet_prefix () - failed\n");
+      ACE_OS::fprintf (stderr, "fill_inet_prefix () - failed\n");
       return -1;
     }
 
@@ -914,7 +920,7 @@ run_main (int argc, ACE_TCHAR *argv[])
 {
   ACE_START_TEST (ACE_TEXT ("SOCK_Netlink_Test"));
 
-  if (::geteuid ())
+  if (ACE_OS::geteuid ())
     {
       ACE_DEBUG ((LM_INFO,
                   ACE_TEXT ("Process has no superuser priveleges. ")
diff --git a/ACE/tests/SOCK_SEQPACK_SCTP_Test.cpp b/ACE/tests/SOCK_SEQPACK_SCTP_Test.cpp
index cdbf5ebc66b..154524191f7 100644
--- a/ACE/tests/SOCK_SEQPACK_SCTP_Test.cpp
+++ b/ACE/tests/SOCK_SEQPACK_SCTP_Test.cpp
@@ -162,9 +162,11 @@ Server (void *arg)
     //
     if (-1 != Stream.send_n (&byte, 1))
     {
+      //FUZZ: disable check_for_lack_ACE_OS
       ACE_ERROR ((LM_ERROR,
                   ACE_TEXT ("(%P|%t) Negative test fail: Association")
                   ACE_TEXT(".send_n succeeded after abort()\n")));
+      //FUZZ: enable check_for_lack_ACE_OS
     }
 
   }
@@ -238,9 +240,11 @@ Client(void *arg)
 
   if (-1 != Stream.recv_n (&b, 1, &tv, &bytes))
   {
+    //FUZZ: disable check_for_lack_ACE_OS
     ACE_ERROR ((LM_ERROR,
                 ACE_TEXT ("(%P|%t) Negative test failed Association")
                 ACE_TEXT (".recv_n succeeded after abort()\n")));
+    //FUZZ: enable check_for_lack_ACE_OS
   }
 
   return 0;
diff --git a/ACE/tests/SPIPE_Test.cpp b/ACE/tests/SPIPE_Test.cpp
index 31e0ae86653..c3b1ae2dd8f 100644
--- a/ACE/tests/SPIPE_Test.cpp
+++ b/ACE/tests/SPIPE_Test.cpp
@@ -170,7 +170,7 @@ server (void *)
   if (new_stream.recv (buf, sizeof(buf)) != (ssize_t) ACE_OS::strlen (ACE_ALPHABET))
     ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n%a"), ACE_TEXT ("recv"), 1));
   else
-    ACE_ASSERT(memcmp(ACE_ALPHABET, buf, ACE_OS::strlen (ACE_ALPHABET)) == 0);
+    ACE_ASSERT(ACE_OS::memcmp(ACE_ALPHABET, buf, ACE_OS::strlen (ACE_ALPHABET)) == 0);
 
   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("End of connection. Closing handle\n")));
   new_stream.close ();
diff --git a/ACE/tests/SSL/SSL_Asynch_Stream_Test.cpp b/ACE/tests/SSL/SSL_Asynch_Stream_Test.cpp
index 58556a44f0b..dc07b703530 100644
--- a/ACE/tests/SSL/SSL_Asynch_Stream_Test.cpp
+++ b/ACE/tests/SSL/SSL_Asynch_Stream_Test.cpp
@@ -58,7 +58,9 @@ public:
       block_ (1024) {}
   ~Client_Handler ();
 
+  //FUZZ: disable check_for_lack_ACE_OS
   int open (ACE_HANDLE);
+  //FUZZ: enable check_for_lack_ACE_OS
 
 private:
   virtual void handle_write_stream (const ACE_SSL_Asynch_Write_Stream_Result &result);
@@ -78,7 +80,9 @@ public:
       block_ (1024) {}
   ~Server_Handler ();
 
+  //FUZZ: disable check_for_lack_ACE_OS
   int open (ACE_HANDLE);
+  //FUZZ: enable check_for_lack_ACE_OS
 
 private:
   virtual void handle_read_stream (const ACE_SSL_Asynch_Read_Stream_Result &result);
@@ -92,7 +96,9 @@ private:
 class Server_Acceptor : public ACE_Event_Handler
 {
 public:
+  //FUZZ: disable check_for_lack_ACE_OS
   int open (const ACE_INET_Addr &listen_addr);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   // Called when a new connection is ready to accept.
   virtual int handle_input (ACE_HANDLE fd = ACE_INVALID_HANDLE);
@@ -135,12 +141,14 @@ static const char *test_string = "SSL_Asynch_Stream_Test!";
 static void
 parse_args (int argc, ACE_TCHAR *argv[])
 {
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_Get_Opt getopt (argc, argv, ACE_TEXT ("r:t:d:i:n:"));
 
   int c;
 
   while ((c = getopt ()) != -1)
     {
+  //FUZZ: enable check_for_lack_ACE_OS
       switch (c)
         {
         case 'r':                   // hostname:port
diff --git a/ACE/tests/SSL/Thread_Pool_Reactor_SSL_Test.cpp b/ACE/tests/SSL/Thread_Pool_Reactor_SSL_Test.cpp
index 290bf83592f..7f9bbd6c168 100644
--- a/ACE/tests/SSL/Thread_Pool_Reactor_SSL_Test.cpp
+++ b/ACE/tests/SSL/Thread_Pool_Reactor_SSL_Test.cpp
@@ -88,12 +88,14 @@ static int req_delay = 50;
 static void
 parse_arg (int argc, ACE_TCHAR *argv[])
 {
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_Get_Opt getopt (argc, argv, ACE_TEXT ("r:s:c:d:i:n:"));
 
   int c;
 
   while ((c = getopt ()) != -1)
     {
+  //FUZZ: enable check_for_lack_ACE_OS
       switch (c)
         {
         case 'r':                   // hostname:port
diff --git a/ACE/tests/Semaphore_Test.cpp b/ACE/tests/Semaphore_Test.cpp
index 0da7ba8b822..75fe98f848e 100644
--- a/ACE/tests/Semaphore_Test.cpp
+++ b/ACE/tests/Semaphore_Test.cpp
@@ -158,8 +158,11 @@ worker (void *)
        iterations <= n_iterations;
        iterations++)
     {
+      //FUZZ: disable check_for_lack_ACE_OS
       ACE_Time_Value wait (0,
                            iterations * 1000 * 100);  // Wait 'iter' msec
+      //FUZZ: enable check_for_lack_ACE_OS
+
       ACE_Time_Value tv = ACE_OS::gettimeofday () + wait;
       if (s.acquire (tv) == -1)
       {
diff --git a/ACE/tests/TP_Reactor_Test.cpp b/ACE/tests/TP_Reactor_Test.cpp
index 91d2b43812f..b6e4884c890 100644
--- a/ACE/tests/TP_Reactor_Test.cpp
+++ b/ACE/tests/TP_Reactor_Test.cpp
@@ -344,10 +344,9 @@ Acceptor::on_delete_receiver (Receiver &rcvr)
 int
 Acceptor::start (const ACE_INET_Addr &addr)
 {
-  if (ACE_Acceptor<Receiver,ACE_SOCK_ACCEPTOR>
-      ::open (addr,
-              ACE_Reactor::instance (),
-              ACE_NONBLOCK) < 0)
+  if (ACE_Acceptor<Receiver,ACE_SOCK_ACCEPTOR>::open (addr,
+                                                      ACE_Reactor::instance (),
+                                                      ACE_NONBLOCK) < 0)
     ACE_ERROR_RETURN ((LM_ERROR,
                        "%p\n",
                        "Acceptor::start () - open failed"),
@@ -706,9 +705,8 @@ int
 Connector::start (const ACE_INET_Addr & addr, int num)
 {
 
-  if (ACE_Connector<Sender,ACE_SOCK_CONNECTOR>
-      ::open (ACE_Reactor::instance (),
-              ACE_NONBLOCK) < 0)
+  if (ACE_Connector<Sender,ACE_SOCK_CONNECTOR>::open (ACE_Reactor::instance (),
+                                                      ACE_NONBLOCK) < 0)
     ACE_ERROR_RETURN
       ((LM_ERROR,
         "%p\n",
@@ -721,8 +719,7 @@ Connector::start (const ACE_INET_Addr & addr, int num)
     {
       Sender * sender = 0;
 
-      if (ACE_Connector<Sender,ACE_SOCK_CONNECTOR>
-          ::connect (sender, addr) < 0)
+      if (ACE_Connector<Sender,ACE_SOCK_CONNECTOR>::connect (sender, addr) < 0)
         ACE_ERROR_RETURN
           ((LM_ERROR,
             "%p\n",
@@ -1123,13 +1120,13 @@ disable_signal (int sigmin, int sigmax)
 {
 #if defined (ACE_HAS_PTHREADS_STD)  &&  !defined (ACE_LACKS_PTHREAD_SIGMASK)
   sigset_t signal_set;
-  if (sigemptyset (&signal_set) == - 1)
+  if (ACE_OS::sigemptyset (&signal_set) == - 1)
     ACE_ERROR ((LM_ERROR,
                 "Error: (%P | %t):%p\n",
                 "sigemptyset failed"));
 
   for (int i = sigmin; i <= sigmax; i++)
-    sigaddset (&signal_set, i);
+    ACE_OS::sigaddset (&signal_set, i);
 
   //  Put the <signal_set>.
   if (ACE_OS::pthread_sigmask (SIG_BLOCK, &signal_set, 0) != 0)
diff --git a/ACE/tests/Task_Ex_Test.cpp b/ACE/tests/Task_Ex_Test.cpp
index 98cc6926cf7..232e9b23c4e 100644
--- a/ACE/tests/Task_Ex_Test.cpp
+++ b/ACE/tests/Task_Ex_Test.cpp
@@ -44,8 +44,10 @@ const ACE_INT32 NUMBER_OF_MSGS=2000;
 class Consumer : public ACE_Task_Ex<ACE_MT_SYNCH, User_Defined_Msg>
 {
 public:
+  //FUZZ: disable check_for_lack_ACE_OS
   /// activate/spawn the threads.
   int open (void*);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   /// svc thread entry point
   virtual int svc (void);
diff --git a/ACE/tests/Task_Test.cpp b/ACE/tests/Task_Test.cpp
index 7359861fd9f..24bb021e1bd 100644
--- a/ACE/tests/Task_Test.cpp
+++ b/ACE/tests/Task_Test.cpp
@@ -48,7 +48,9 @@ public:
                 int n_threads,
                 int n_iterations);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int close (u_long flags = 0);
+  //FUZZ: enable check_for_lack_ACE_OS
 
   virtual int svc (void);
   // Iterate <n_iterations> time printing off a message and "waiting"
diff --git a/ACE/tests/Thread_Creation_Threshold_Test.cpp b/ACE/tests/Thread_Creation_Threshold_Test.cpp
index 2fc6fd8a0f1..008b366c966 100644
--- a/ACE/tests/Thread_Creation_Threshold_Test.cpp
+++ b/ACE/tests/Thread_Creation_Threshold_Test.cpp
@@ -74,11 +74,13 @@ public:
   // Returns true iff failed_ == false.
 
 private:
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int open (void * = 0);
   // Spawn the threads in the pool.
 
   virtual int close (u_long);
   // Close hook.
+  //FUZZ: enable check_for_lack_ACE_OS
 
   ACE_Atomic_Op<ACE_Thread_Mutex, unsigned long> total_activated_threads_;
   // Total number of threads activated through this thread pool ever.
@@ -125,9 +127,9 @@ Thread_Pool::start ()
   if (this->open () == -1)
     {
       ACE_DEBUG ((LM_DEBUG,
-		  ACE_TEXT ("(%P|%t) thread activation ")
-		  ACE_TEXT ("failed after %u threads\n"),
-		  this->total_threads()));
+                  ACE_TEXT ("(%P|%t) thread activation ")
+                  ACE_TEXT ("failed after %u threads\n"),
+                  this->total_threads()));
       this->failed_ = true;
     }
 }
@@ -156,8 +158,8 @@ Thread_Pool::open (void *)
 {
   if (PRINT_DEBUG_MSGS)
     ACE_DEBUG ((LM_DEBUG,
-    ACE_TEXT ("(%P|%t) pool start %d threads...\n"),
-		this->n_threads_));
+                ACE_TEXT ("(%P|%t) pool start %d threads...\n"),
+                this->n_threads_));
 
   if (this->total_activated_threads_ >= (65534 - this->n_threads_))
     no_op ();
@@ -183,9 +185,9 @@ run_main (int, ACE_TCHAR *[])
 
 #if defined (ACE_HAS_THREADS)
   ACE_DEBUG ((LM_DEBUG,
-	      ACE_TEXT ("(%P|%t) will try to start and kill up")
-	      ACE_TEXT (" to %u threads sequentially\n"),
-	      MAX_THREAD));
+              ACE_TEXT ("(%P|%t) will try to start and kill up")
+              ACE_TEXT (" to %u threads sequentially\n"),
+              MAX_THREAD));
   int initial_pool_size = 50;
 
   // Create the worker tasks.
@@ -206,9 +208,9 @@ run_main (int, ACE_TCHAR *[])
         return 1;
 
       if (PRINT_DEBUG_MSGS)
-	ACE_DEBUG ((LM_DEBUG,
-		    ACE_TEXT ("%u total threads\n"),
-		    thread_pool.total_threads()));
+        ACE_DEBUG ((LM_DEBUG,
+                    ACE_TEXT ("%u total threads\n"),
+                    thread_pool.total_threads()));
 
       int& n_threads = thread_pool.n_threads_;
       const unsigned long THREAD_THRESHOLD = 63336;
@@ -217,10 +219,10 @@ run_main (int, ACE_TCHAR *[])
     }
   
   ACE_DEBUG ((LM_DEBUG,
-	      ACE_TEXT ("%u total threads successfully started and died;")
-	      ACE_TEXT (" expected %u.\n"),
-	      thread_pool.total_threads (),
-	      MAX_THREAD));
+              ACE_TEXT ("%u total threads successfully started and died;")
+              ACE_TEXT (" expected %u.\n"),
+              thread_pool.total_threads (),
+              MAX_THREAD));
 #else
   ACE_ERROR ((LM_INFO,
               ACE_TEXT ("threads not supported on this platform\n")));
diff --git a/ACE/tests/Thread_Pool_Reactor_Resume_Test.cpp b/ACE/tests/Thread_Pool_Reactor_Resume_Test.cpp
index 327ef0bc917..1d05ae1a56f 100644
--- a/ACE/tests/Thread_Pool_Reactor_Resume_Test.cpp
+++ b/ACE/tests/Thread_Pool_Reactor_Resume_Test.cpp
@@ -61,8 +61,8 @@ 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
@@ -84,12 +84,14 @@ static int req_delay = 50;
 static void
 parse_arg (int argc, ACE_TCHAR *argv[])
 {
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_Get_Opt getopt (argc, argv, ACE_TEXT ("r:s:c:d:i:n:"));
 
   int c;
 
   while ((c = getopt ()) != -1)
     {
+  //FUZZ: enable check_for_lack_ACE_OS
       switch (c)
         {
         case 'r':                   // hostname:port
diff --git a/ACE/tests/Thread_Pool_Reactor_Test.cpp b/ACE/tests/Thread_Pool_Reactor_Test.cpp
index ff0c3098e80..76112e167fe 100644
--- a/ACE/tests/Thread_Pool_Reactor_Test.cpp
+++ b/ACE/tests/Thread_Pool_Reactor_Test.cpp
@@ -87,12 +87,14 @@ static int req_delay = 50;
 static void
 parse_arg (int argc, ACE_TCHAR *argv[])
 {
+  //FUZZ: disable check_for_lack_ACE_OS
   ACE_Get_Opt getopt (argc, argv, ACE_TEXT ("r:s:c:d:i:n:"));
 
   int c;
 
   while ((c = getopt ()) != -1)
     {
+  //FUZZ: enable check_for_lack_ACE_OS
       switch (c)
         {
         case 'r':                   // hostname:port
diff --git a/ACE/tests/Thread_Pool_Test.cpp b/ACE/tests/Thread_Pool_Test.cpp
index 498404273ac..6c124e494cd 100644
--- a/ACE/tests/Thread_Pool_Test.cpp
+++ b/ACE/tests/Thread_Pool_Test.cpp
@@ -72,11 +72,13 @@ public:
   // Allows the producer to pass messages to the <Thread_Pool>.
 
 private:
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int open (void * = 0);
   // Spawn the threads in the pool.
 
   virtual int close (u_long);
   // Close hook.
+  //FUZZ: enable check_for_lack_ACE_OS
 
   ACE_Lock_Adapter<ACE_Thread_Mutex> lock_adapter_;
   // Serialize access to <ACE_Message_Block> reference count, which
diff --git a/ACE/tests/TkReactor_Test.cpp b/ACE/tests/TkReactor_Test.cpp
index 3d421d77182..2b7a7634ae8 100644
--- a/ACE/tests/TkReactor_Test.cpp
+++ b/ACE/tests/TkReactor_Test.cpp
@@ -44,13 +44,13 @@ Tcl_Interp* tcl_interp;
 void eval (const char *s)
 {
   char buf[BUFSIZ];
-  strcpy (buf,s);
+  ACE_OS::strcpy (buf,s);
   int st = Tcl_GlobalEval(tcl_interp,buf);
   if (st != TCL_OK)
     {
-      int n =  strlen(s);
+      int n =  ACE_OS::strlen(s);
       char* wrk = new char[n + 80];
-      sprintf(wrk, "tkerror \"%s\"", s);
+      ACE_OS::sprintf(wrk, "tkerror \"%s\"", s);
       Tcl_GlobalEval(tcl_interp, wrk);
       delete wrk;
       //exit(1);
@@ -90,7 +90,7 @@ client (void *)
 
   ACE_SOCK_Stream stream;
   ACE_SOCK_Connector connector;
-  sprintf (buf, "Client: the life was good!");
+  ACE_OS::sprintf (buf, "Client: the life was good!");
 
   mes_len = (int) htonl (ACE_OS::strlen (buf) + 1);
 
@@ -133,11 +133,11 @@ inc_count (ClientData client_data, Tcl_Interp *interp,int, char **)
   ACE_DEBUG ((LM_DEBUG,"inc_count "));
   char new_string[80];
 
-  sprintf (new_string,
-           "Events: [%d] [%d] [%d]",
-           count1++,
-           count2,
-           count3);
+  ACE_OS::sprintf (new_string,
+                   "Events: [%d] [%d] [%d]",
+                   count1++,
+                   count2,
+                   count3);
 
   //  sprintf (command,"set %s %s",(char *)client_data,new_string);
   // eval (command);
@@ -156,11 +156,11 @@ inc_tmo (ClientData client_data)
 
   if (count2 > 10)
     ACE_OS::exit (0);
-  sprintf (new_string,
-           "Events: [%d] [%d] [%d]",
-           count1,
-           count2++,
-           count3);
+  ACE_OS::sprintf (new_string,
+                   "Events: [%d] [%d] [%d]",
+                   count1,
+                   count2++,
+                   count3);
 
   //  sprintf (command,"set %s %s",(char *)client_data,new_string);
   //  eval (command);
@@ -180,11 +180,11 @@ public:
                               const void *arg)
   {
     char new_string[80];
-    sprintf (new_string,
-             "Events: [%d] [%d] [%d]",
-             count1,
-             count2,
-             count3++);
+    ACE_OS::sprintf (new_string,
+                     "Events: [%d] [%d] [%d]",
+                     count1,
+                     count2,
+                     count3++);
 
     //    sprintf (command,"set %s %s",(char *)arg,new_string);
     //    eval (command);
@@ -199,8 +199,10 @@ public:
 class Connection_Handler : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>
 {
 public:
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int open (void *)
   {
+  //FUZZ: enable check_for_lack_ACE_OS
     char buf[100];
     int head;
     ssize_t ret = this->peer ().recv_n ((char *) &head,
diff --git a/ACE/tests/Token_Strategy_Test.cpp b/ACE/tests/Token_Strategy_Test.cpp
index c2d9367b913..5bfb46364cc 100644
--- a/ACE/tests/Token_Strategy_Test.cpp
+++ b/ACE/tests/Token_Strategy_Test.cpp
@@ -37,7 +37,10 @@ public:
                        int threads = 5, int invocations = 10);
   ~Token_Strategy_Test (void);
 
+  //FUZZ: disable check_for_lack_ACE_OS
   int open (void *a = 0);
+  //FUZZ: enable check_for_lack_ACE_OS
+
   int svc (void);
 
 private:
diff --git a/ACE/tests/Unload_libACE.cpp b/ACE/tests/Unload_libACE.cpp
index 829149d444c..f89d6d21f76 100644
--- a/ACE/tests/Unload_libACE.cpp
+++ b/ACE/tests/Unload_libACE.cpp
@@ -19,6 +19,8 @@
 //
 // ============================================================================
 
+//FUZZ: disable check_for_lack_ACE_OS
+
 #include <stdio.h>
 
 #undef UNLOAD_LIBACE_TEST
diff --git a/ACE/tests/XtAthenaReactor_Test.cpp b/ACE/tests/XtAthenaReactor_Test.cpp
index cf0530ee552..3bba4a52a6c 100644
--- a/ACE/tests/XtAthenaReactor_Test.cpp
+++ b/ACE/tests/XtAthenaReactor_Test.cpp
@@ -94,7 +94,7 @@ client (void *)
 
   ACE_SOCK_Stream stream;
   ACE_SOCK_Connector connector;
-  sprintf (buf, "Client: the life was good!");
+  ACE_OS::sprintf (buf, "Client: the life was good!");
 
   mes_len = (int) htonl (ACE_OS::strlen (buf) + 1);
 
@@ -132,11 +132,11 @@ inc_count (Widget, XtPointer client_data, XtPointer)
 {
   char new_string[80];
 
-  sprintf (new_string,
-           "Events: [%d] [%d] [%d]",
-           count1++,
-           count2,
-           count3);
+  ACE_OS::sprintf (new_string,
+                   "Events: [%d] [%d] [%d]",
+                   count1++,
+                   count2,
+                   count3);
   set_label((Widget) client_data, new_string);
 }
 
@@ -149,11 +149,11 @@ inc_tmo (void *w,XtIntervalId *)
 
   if (count2 > 10)
     ACE_OS::exit (0);
-  sprintf (new_string,
-           "Events: [%d] [%d] [%d]",
-           count1,
-           count2++,
-           count3);
+  ACE_OS::sprintf (new_string,
+                   "Events: [%d] [%d] [%d]",
+                   count1,
+                   count2++,
+                   count3);
 
   set_label((Widget) w, new_string);
 
@@ -170,11 +170,11 @@ public:
                               const void *arg)
   {
     char new_string[80];
-    sprintf (new_string,
-             "Events: [%d] [%d] [%d]",
-             count1,
-             count2,
-             count3++);
+    ACE_OS::sprintf (new_string,
+                     "Events: [%d] [%d] [%d]",
+                     count1,
+                     count2,
+                     count3++);
     set_label((Widget) arg, new_string);
     return 0;
   }
@@ -183,8 +183,10 @@ public:
 class Connection_Handler : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>
 {
 public:
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int open (void *)
   {
+  //FUZZ: enable check_for_lack_ACE_OS
     char buf[100];
     int head;
     ssize_t ret = this->peer ().recv_n ((char *) &head,
diff --git a/ACE/tests/XtMotifReactor_Test.cpp b/ACE/tests/XtMotifReactor_Test.cpp
index 7aabc230fbb..bbfeecfe998 100644
--- a/ACE/tests/XtMotifReactor_Test.cpp
+++ b/ACE/tests/XtMotifReactor_Test.cpp
@@ -101,7 +101,7 @@ client (void *)
 
   ACE_SOCK_Stream stream;
   ACE_SOCK_Connector connector;
-  sprintf (buf, "Client: the life was good!");
+  ACE_OS::sprintf (buf, "Client: the life was good!");
 
   mes_len = (int) htonl (ACE_OS::strlen (buf) + 1);
 
@@ -139,11 +139,11 @@ inc_count (Widget, XtPointer client_data, XtPointer)
 {
   char new_string[80];
 
-  sprintf (new_string,
-           "Events: [%d] [%d] [%d]",
-           count1++,
-           count2,
-           count3);
+  ACE_OS::sprintf (new_string,
+                   "Events: [%d] [%d] [%d]",
+                   count1++,
+                   count2,
+                   count3);
   set_label((Widget) client_data, new_string);
 }
 
@@ -156,11 +156,11 @@ inc_tmo (void *w,XtIntervalId *)
 
   if (count2 > 10)
     ACE_OS::exit (0);
-  sprintf (new_string,
-           "Events: [%d] [%d] [%d]",
-           count1,
-           count2++,
-           count3);
+  ACE_OS::sprintf (new_string,
+                   "Events: [%d] [%d] [%d]",
+                   count1,
+                   count2++,
+                   count3);
 
   set_label((Widget) w, new_string);
 
@@ -177,11 +177,11 @@ public:
                               const void *arg)
   {
     char new_string[80];
-    sprintf (new_string,
-             "Events: [%d] [%d] [%d]",
-             count1,
-             count2,
-             count3++);
+    ACE_OS::sprintf (new_string,
+                     "Events: [%d] [%d] [%d]",
+                     count1,
+                     count2,
+                     count3++);
     set_label((Widget) arg, new_string);
     return 0;
   }
@@ -190,8 +190,10 @@ public:
 class Connection_Handler : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>
 {
 public:
+  //FUZZ: disable check_for_lack_ACE_OS
   virtual int open (void *)
   {
+  //FUZZ: enable check_for_lack_ACE_OS
     char buf[100];
     int head;
     ssize_t ret = this->peer ().recv_n ((char *) &head,