Merge lp:~stewart/percona-playback/cassert-header into lp:~percona-dev/percona-playback/light

[Stewart Smith]

correctly include the cassert header for assert() and also use standard assert() instead of custom ASSERT(). If people really want to not run the asserts, they can change this via compile option (which, IMNSHO is silly to do)

=== modified file 'src/common.h'
--- src/common.h	2011-06-23 06:11:17 +0000
+++ src/common.h	2011-07-11 07:37:28 +0000
@@ -25,6 +25,7 @@
 #include <map>
 #include <set>
 #include <deque>
+#include <cassert>
 #include <boost/shared_ptr.hpp>
 #include <pthread.h>
 
@@ -35,22 +36,21 @@
 
 #include <cassert>
 #define MAX_C_STRING_LENGTH (1024*1024)
-#define ASSERT(condition) assert(condition)
 #define CHECK_C_STRING(value) do					\
     {									\
-      ASSERT(value != NULL && "NULL is not string" && __FILE__ && __LINE__); \
-      ASSERT(value != 0 && "0 is not string" && __FILE__ && __LINE__);	\
-      ASSERT((memchr(value, 0, MAX_C_STRING_LENGTH) != NULL)		\
+      assert(value != NULL && "NULL is not string" && __FILE__ && __LINE__); \
+      assert(value != 0 && "0 is not string" && __FILE__ && __LINE__);	\
+      assert((memchr(value, 0, MAX_C_STRING_LENGTH) != NULL)		\
              && "too long C string" && __FILE__ && __LINE__);		\
     }									\
   while(false)
 #define CHECK_C_STRING_LENGTH(value,length) do				\
     {									\
-      ASSERT(value != NULL && "NULL is not string" && __FILE__ && __LINE__); \
-      ASSERT(value != 0 && "0 is not string" && __FILE__ && __LINE__);	\
-      ASSERT(((length == 0) || (memchr(value, 0, length) == NULL))      \
+      assert(value != NULL && "NULL is not string" && __FILE__ && __LINE__); \
+      assert(value != 0 && "0 is not string" && __FILE__ && __LINE__);	\
+      assert(((length == 0) || (memchr(value, 0, length) == NULL))      \
              && "incorrect C string length" && __FILE__ && __LINE__);	\
-      ASSERT(value[length] == 0						\
+      assert(value[length] == 0						\
              && "incorrect C string length" && __FILE__ && __LINE__);	\
     }									\
   while(false)
@@ -72,8 +72,6 @@
 
 #else // DEBUG
 
-#define ASSERT(condition) /* removed ASSERT(condition) */
-
 #define CHECK_C_STRING(value)			\
   /* removed CHECK_C_STRING(value) */
 #define CHECK_C_STRING_LENGTH(value,length)		\
@@ -159,12 +157,12 @@
   }
   void add(T *a_item)
   {
-    ASSERT(!has(a_item));
+    assert(!has(a_item));
     m_set.insert(a_item);
   }
   void del(T *a_item)
   {
-    ASSERT(has(a_item));
+    assert(has(a_item));
     if (m_free_count > 0 && m_free_count > m_queue.size())
     {
       m_queue.push_back(a_item);

=== modified file 'src/long_string.cc'
--- src/long_string.cc	2011-07-11 07:37:28 +0000
+++ src/long_string.cc	2011-07-11 07:37:28 +0000
@@ -18,6 +18,7 @@
 
 #include <strings.h>
 #include <iostream>
+#include <cassert>
 #include "common.h"
 #include "long_string.h"
 
@@ -205,7 +206,7 @@
   if (from >= m_length)
     return m_length;
   CHECK_C_STRING_LENGTH(m_data, m_length);
-  ASSERT(from < m_length);
+  assert(from < m_length);
   const char* result=
     (const char*)memchr(m_data + from, c, m_length - from);
   if (NULL == result)
@@ -352,7 +353,7 @@
 {
   if (m_null)
     {
-      ASSERT(false && "Impossible call method length when Nullable_String is null");
+      assert(false && "Impossible call method length when Nullable_String is null");
       throw String_Null_Error("length");
     }
   else
@@ -362,7 +363,7 @@
 {
   if (m_null)
     {
-      ASSERT(false && "Impossible call method length when Nullable_String is null");
+      assert(false && "Impossible call method length when Nullable_String is null");
       throw String_Null_Error("length");
     }
   else

=== modified file 'src/long_string.h'
--- src/long_string.h	2011-06-23 06:11:17 +0000
+++ src/long_string.h	2011-07-11 07:37:28 +0000
@@ -21,6 +21,7 @@
 
 #include <strings.h>
 #include <string>
+#include <cassert>
 #include <boost/utility.hpp>
 #include "introspection.h"
 #include "queue.h"
@@ -107,7 +108,7 @@
     CHECK_C_STRING_LENGTH(value.m_data, value.m_length);
     action.begin_compound(value);
     action.member("m_length", value.m_length);
-    ASSERT(value.m_max >= value.m_length);
+    assert(value.m_max >= value.m_length);
     action.read((void*)value.m_data, value.m_length + 1);
     action.end_compound(value);
     CHECK_C_STRING_LENGTH(value.m_data, value.m_length);

=== modified file 'src/mysql_client.cc'
--- src/mysql_client.cc	2011-06-23 06:11:17 +0000
+++ src/mysql_client.cc	2011-07-11 07:37:28 +0000
@@ -17,6 +17,7 @@
  */
 
 #include <iomanip>
+#include <cassert>
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include "query.h"
 #include "mysql_client.h"
@@ -124,7 +125,7 @@
     if (previous != current)
       {
 	int result= snprintf(m_set.data(), m_set.max(), "set %s=%lld;", name, current);
-	ASSERT(result > 0);
+	assert(result > 0);
 	m_set.length(result);
 	previous= current;
 	execute(r, m_set, eQuery_Type_Write);
@@ -172,13 +173,13 @@
     if (type == eQuery_Type_Unknown)
       {
 	Query_Parse_State state= query_parse(eQuery_Detect_Type, sql.data(), sql.length());
-	ASSERT(end_of_query(state));
+	assert(end_of_query(state));
 	type= query_type(state);
-	ASSERT(type != eQuery_Type_Unknown);
+	assert(type != eQuery_Type_Unknown);
       }
     else
       {
-	ASSERT(end_of_query(query_parse(eQuery_Detect_Correct, sql.data(), sql.length())));
+	assert(end_of_query(query_parse(eQuery_Detect_Correct, sql.data(), sql.length())));
       }
     start_timer(r);
     CHECK_C_STRING_LENGTH(sql.data(), sql.length());
@@ -226,7 +227,7 @@
 			       , (old_length == 0 ? "" : "\n")
 			       , mysql_errno(handle())
 			       , mysql_error(handle()));
-      ASSERT(new_length > 0);
+      assert(new_length > 0);
       error.length(old_length + new_length);
     }
   }

=== modified file 'src/options.cc'
--- src/options.cc	2011-06-23 06:11:17 +0000
+++ src/options.cc	2011-07-11 07:37:28 +0000
@@ -18,6 +18,7 @@
 
 #include <iostream>
 #include <fstream>
+#include <cassert>
 #include <boost/program_options.hpp>
 #include <boost/program_options/parsers.hpp>
 #include <boost/lexical_cast.hpp>
@@ -287,7 +288,7 @@
           custom_verbose_callback_vector.push_back(Verbose_Callback_Pointer(new Verbose_Callback_Fill()));
           fill= custom_verbose_callback_vector.back().get()->fill();
         }
-        ASSERT(fill);
+        assert(fill);
         fill->add(*mask);
       }
     }

=== modified file 'src/query.cc'
--- src/query.cc	2011-06-23 06:11:17 +0000
+++ src/query.cc	2011-07-11 07:37:28 +0000
@@ -18,6 +18,7 @@
 
 #include <strings.h>
 #include <iostream>
+#include <cassert>
 #include "query.h"
 #include "options.h"
 
@@ -49,7 +50,7 @@
     case (eQuery_Type_Unknown): return "unknown";
     case (eQuery_Type_Read):    return "read";
     case (eQuery_Type_Write):   return "write";
-    default: ASSERT(false && "make gcc happy"); return "const char* to_c_str(Enum_Query_Type type) FAILED";
+    default: assert(false && "make gcc happy"); return "const char* to_c_str(Enum_Query_Type type) FAILED";
     };
 }
 std::ostream& operator<<(std::ostream&s , Enum_Query_Type type)
@@ -236,7 +237,7 @@
 }
 std::size_t query_parse_stupid(Query_Parse_State &state, const char* data, std::size_t length)
 {
-  ASSERT(eQuery_Detect_Stupid == query_detect(state));
+  assert(eQuery_Detect_Stupid == query_detect(state));
   const char* result= (const char*)memchr(data, ';', length);
   if (result == NULL)
     return length;
@@ -418,7 +419,7 @@
 #define LETTER_END(state)        STATE_JUMP(state, ZERO);
 #define QUERY_TYPE(state, new_type)		\
   STATE_LABEL(state);				\
-  ASSERT(type == eQuery_Type_Unknown);		\
+  assert(type == eQuery_Type_Unknown);		\
   type= new_type;				\
   JUMP(ZERO)
   
@@ -521,13 +522,10 @@
 Query_Parse_State query_parse(Enum_Query_Detect detect, const char* data, std::size_t length)
 {
   Query_Parse_State state= query_parse_state_begin(detect);
-#ifdef DEBUG
-  std::size_t result=
-#endif //DEBUG
-    query_parse(state, data, length);
+  std::size_t result= query_parse(state, data, length);
   //if (!end_of_query(state))
   //  std::cout << *reinterpret_cast<int*>(0);
-  ASSERT(end_of_query(state));
-  ASSERT(result == length);
+  assert(end_of_query(state));
+  assert(result == length);
   return state;
 }

=== modified file 'src/queue.h'
--- src/queue.h	2011-06-23 06:11:17 +0000
+++ src/queue.h	2011-07-11 07:37:28 +0000
@@ -23,6 +23,7 @@
 #include <string.h>
 #include <queue>
 #include <sstream>
+#include <cassert>
 #include "common.h"
 #include "introspection.h"
 
@@ -205,14 +206,14 @@
     if(m_read_offset == m_write_offset) // queue is (empty or full).
     {
       // invariant
-      ASSERT((m_read_pass == m_write_pass) || (m_read_pass + 1 == m_write_pass));
+      assert((m_read_pass == m_write_pass) || (m_read_pass + 1 == m_write_pass));
       if(m_read_pass < m_write_pass)
       {
         // queue full
         return false;
       }
       // queue empty
-      ASSERT(m_read_pass == m_write_pass);
+      assert(m_read_pass == m_write_pass);
       // move to begin
       m_write_offset= m_read_offset= 0;
       m_padd_offset= m_buffer_size;
@@ -233,7 +234,7 @@
 public:
   void unsafety_push(T const &value)
   {
-    ASSERT(can_push(value));
+    assert(can_push(value));
     Writer action(*this);
     ::apply(action, value);
     if(m_write_offset == m_buffer_size)
@@ -245,7 +246,7 @@
 public:
   void unsafety_pop(T &value)
   {
-    ASSERT(!empty());
+    assert(!empty());
     Reader action(*this);
     ::apply(action, value);
     if(m_read_offset == m_padd_offset)
@@ -258,11 +259,11 @@
 private:
   queue_item_length free_size() const
   {
-    ASSERT(m_write_offset < m_buffer_size);
-    ASSERT(m_read_offset < m_buffer_size);
+    assert(m_write_offset < m_buffer_size);
+    assert(m_read_offset < m_buffer_size);
     if(m_read_offset == m_write_offset) // queue is empty or full.
     {
-      ASSERT((m_read_pass == m_write_pass) || (m_read_pass + 1 == m_write_pass));
+      assert((m_read_pass == m_write_pass) || (m_read_pass + 1 == m_write_pass));
       if(m_read_pass == m_write_pass)
         return m_buffer_size - m_write_offset; // queue is empty
       else
@@ -278,18 +279,18 @@
   void write_check(queue_item_length size) const
   {
     // check for enough space
-    ASSERT(free_size() >= size);
-    ASSERT(m_write_offset + size <= m_buffer_size);
+    assert(free_size() >= size);
+    assert(m_write_offset + size <= m_buffer_size);
     // check what we stay on free block
-    ASSERT((state(m_write_offset) == eFree) || (state(m_write_offset) == ePad));
+    assert((state(m_write_offset) == eFree) || (state(m_write_offset) == ePad));
   }
   void read_check(queue_item_length size) const
   {
     // check what we stay on data block
-    ASSERT(state(m_read_offset) == eData);
+    assert(state(m_read_offset) == eData);
     // check what data place on buffer
-    ASSERT(m_padd_offset <= m_buffer_size);
-    ASSERT(m_read_offset + size <= m_padd_offset);
+    assert(m_padd_offset <= m_buffer_size);
+    assert(m_read_offset + size <= m_padd_offset);
   }
 #else // DEBUG
   void write_check(queue_item_length) const {}
@@ -326,13 +327,13 @@
 private:
   State state(queue_item_length offset) const
   {
-    ASSERT(offset <= m_buffer_size);
+    assert(offset <= m_buffer_size);
     if(m_write_offset == m_read_offset)
     {
       if(m_read_pass < m_write_pass)
       {
         // queue is full
-        ASSERT(m_read_pass + 1 == m_write_pass);
+        assert(m_read_pass + 1 == m_write_pass);
         if(offset >= m_padd_offset)
           return ePad;
         else
@@ -341,8 +342,8 @@
       else
       {
         // queue is empty
-        ASSERT(m_read_pass == m_write_pass);
-        ASSERT(m_padd_offset == m_buffer_size);
+        assert(m_read_pass == m_write_pass);
+        assert(m_padd_offset == m_buffer_size);
         return eFree;
       }
     }
@@ -402,7 +403,7 @@
     /*std::ostringstream s;
     s << *this << " : " << this << " ctor " << m_max_count << "\n";
     std::cout << s.str() << std::flush;*/
-    ASSERT(m_max_count > 0);
+    assert(m_max_count > 0);
   }
   void reset()
   {
@@ -435,7 +436,7 @@
     s << m_queue.size();
     s << " AND MAX_COUNT " << m_max_count << "\n";
     std::cout << s.str() << std::flush;*/
-    ASSERT(m_queue.size() < m_max_count);
+    assert(m_queue.size() < m_max_count);
     m_queue.push_back(a_item);
   }
   bool unsafety_pop(T*& a_item)
@@ -444,7 +445,7 @@
     s << *this << " : " << this << " UNSAFETY_POP: QUEUE SIZE IS ";
     s << m_queue.size();
     s << " AND MAX_COUNT " << m_max_count << "\n";*/
-    ASSERT(false == m_queue.empty());
+    assert(false == m_queue.empty());
     a_item= m_queue.front();
     m_queue.pop_front();
     return true;
@@ -545,8 +546,8 @@
       }
       while(false);*/
   }
-  ASSERT(m_run);
-  ASSERT(!m_container.empty());
+  assert(m_run);
+  assert(!m_container.empty());
   /*do
     {
     std::ostringstream s;
@@ -608,7 +609,7 @@
       }
       while(false);*/
   }
-  ASSERT(m_container.can_push(value));
+  assert(m_container.can_push(value));
   /*do
     {
     std::ostringstream s;
@@ -657,7 +658,7 @@
   }
   else
   {
-    ASSERT(m_flush || m_run);
+    assert(m_flush || m_run);
   }
   s << "\n";
   do
@@ -667,7 +668,7 @@
     std::cout << s.str() << std::flush;
     }
     while(false);*/
-  ASSERT(m_flush || !m_run);
+  assert(m_flush || !m_run);
   m_not_full.notify_all();
   m_not_empty.notify_all();
   return false;

=== modified file 'src/reader.cc'
--- src/reader.cc	2011-06-23 06:11:17 +0000
+++ src/reader.cc	2011-07-11 07:37:28 +0000
@@ -17,6 +17,7 @@
  */
 
 #include <iostream>
+#include <cassert>
 #include "reader.h"
 
 Reader_Source::Reader_Source(std::size_t a_page_size, std::size_t a_page_count) :
@@ -66,7 +67,7 @@
       int length= m_source->read(string.data(), string.max());
       if (length > 0)
 	{
-	  ASSERT(static_cast<std::size_t>(length) <= string.max());
+	  assert(static_cast<std::size_t>(length) <= string.max());
 	  string.length(length);
 	  if (static_cast<std::size_t>(length) < string.max())
 	    bzero(string.data() + length, string.max() - length + 1);

=== modified file 'src/sheduler.cc'
--- src/sheduler.cc	2011-06-23 06:11:17 +0000
+++ src/sheduler.cc	2011-07-11 07:37:28 +0000
@@ -20,6 +20,7 @@
 #include <map>
 #include <queue>
 #include <memory>
+#include <cassert>
 #include "sheduler.h"
 #include "worker.h"
 #include "query.h"
@@ -53,7 +54,7 @@
 Task_Manager(std::size_t a_buffer_size) :
   Base(::max_idle_thread_count()), m_buffer_size(a_buffer_size)
   {
-    ASSERT(m_buffer_size);
+    assert(m_buffer_size);
     /*do
     {
       std::ostringstream s;
@@ -193,7 +194,7 @@
     std::pair< Map::iterator, bool > task_result;
 
     task_result= m_task.insert(task_insert);
-    ASSERT(true == task_result.second);
+    assert(true == task_result.second);
 
     Task* task= task_result.first->second;
     typedef std::auto_ptr<Connection_Worker> Pointer;
@@ -218,7 +219,7 @@
 
     if (is_stop() || is_flush())
     {
-      ASSERT(false == is_flush());
+      assert(false == is_flush());
       return false;
     }
 
@@ -245,7 +246,7 @@
       {
         i= create(thread_id);
       }
-      ASSERT(active(i));
+      assert(active(i));
       //static std::size_t count= 0;
       //std::cout << "PUSH QUERY " << ++count << "\n" << std::flush;
       task(i)->push(a_query);
@@ -285,7 +286,7 @@
   }
   Task* complete(Map::iterator a_task)
   {
-    ASSERT(active(a_task));
+    assert(active(a_task));
     Task *result= task(a_task);
     result->flush();
     m_map.erase(a_task);
@@ -293,7 +294,7 @@
   }
   Task* begin(const Query &a_query)
   {
-    ASSERT(false == active(task(a_query)));
+    assert(false == active(task(a_query)));
     std::pair< Thread_Id, Task* >    insert;
     std::pair< Map::iterator, bool > result;
 
@@ -303,7 +304,7 @@
     insert.second->push(a_query);
 
     result= m_map.insert(insert);
-    ASSERT(result.second);
+    assert(result.second);
 
     return 0;
   }

=== modified file 'src/slow_query_log_parser.h'
--- src/slow_query_log_parser.h	2011-06-23 06:11:17 +0000
+++ src/slow_query_log_parser.h	2011-07-11 07:37:28 +0000
@@ -23,6 +23,7 @@
 #include <sstream>
 #include <set>
 #include <vector>
+#include <cassert>
 #include "common.h"
 #include "options.h"
 #include "queue.h"
@@ -326,7 +327,7 @@
 				   || (('A' <= current()) && (current() <= 'Z'))))
 bool do_skip(std::size_t count)
 {
-  ASSERT(has_count(count));
+  assert(has_count(count));
   m_current += count;
   return true;
 }

=== modified file 'src/supervisor.cc'
--- src/supervisor.cc	2011-06-23 06:11:17 +0000
+++ src/supervisor.cc	2011-07-11 07:37:28 +0000
@@ -17,6 +17,7 @@
  */
 
 #include <deque>
+#include <cassert>
 #include "supervisor.h"
 #include "options.h"
 #include "worker.h"
@@ -61,7 +62,7 @@
 public:
   void start()
   {
-    ASSERT(false == m_gc.run());
+    assert(false == m_gc.run());
     m_active= 0;
     m_join.reset();
     m_flush=  false;
@@ -70,18 +71,18 @@
   }
   void join()
   {
-    ASSERT(m_flush || m_stop);
-    ASSERT(true == m_gc.run());
+    assert(m_flush || m_stop);
+    assert(true == m_gc.run());
     m_gc.join();
   }
   void flush()
   {
-    ASSERT(m_gc.run());
+    assert(m_gc.run());
     m_flush= true;
   }
   void stop()
   {
-    ASSERT(m_gc.run());
+    assert(m_gc.run());
     m_stop= true;
   }
   bool start(Worker *a_worker)

=== modified file 'src/worker.cc'
--- src/worker.cc	2011-06-23 06:11:17 +0000
+++ src/worker.cc	2011-07-11 07:37:28 +0000
@@ -19,6 +19,7 @@
 #include <vector>
 #include <sstream>
 #include <map>
+#include <cassert>
 #include <boost/shared_ptr.hpp>
 #include "options.h"
 #include "worker.h"
@@ -55,9 +56,9 @@
       Query_Parse_State state= query_parse(eQuery_Detect_Type
                                            , a_query.sql.data()
                                            , a_query.sql.length());
-      ASSERT(end_of_query(state));
+      assert(end_of_query(state));
       a_query.type= query_type(state);
-      ASSERT(a_query.type != eQuery_Type_Unknown);
+      assert(a_query.type != eQuery_Type_Unknown);
     }
     a_result.thread_id= a_worker_thread_id;
     a_client.run(a_result, a_query);
@@ -87,12 +88,12 @@
 }
 void Worker::start()
 {
-  ASSERT(false == m_thread.run());
+  assert(false == m_thread.run());
   m_thread.start();
 }
 void Worker::join()
 {
-  ASSERT(true == m_thread.run());
+  assert(true == m_thread.run());
   m_thread.join();
 }
 Task* Worker::first()