Trying NDEBUG.

Author: dkorolev

Blocks/HTTP/impl/posix_client.h

@@ -203,7 +203,7 @@ struct ImplWrapper<HTTPClientPOSIX> {
   inline static void PrepareInput(const KeepResponseInMemory&, HTTPClientPOSIX&) {}
 
   inline static void PrepareInput(const SaveResponseToFile& save_to_file_request, HTTPClientPOSIX&) {
-    assert(!save_to_file_request.file_name.empty());
+    CURRENT_ASSERT(!save_to_file_request.file_name.empty());
   }
 
   template <typename REQUEST_PARAMS, typename RESPONSE_PARAMS>

Blocks/HTTP/types.h

@@ -236,7 +236,7 @@ struct HTTPImpl {
 
   // TODO(dkorolev): Deprecate the below some time in the future. And perhaps add an `http_port_t`.
   server_impl_t& operator()(int port) {
-    assert(port > 0 && port < 65536);
+    CURRENT_ASSERT(port > 0 && port < 65536);
     return operator()(static_cast<uint16_t>(port));
   }
 

Blocks/MMQ/mmq.h

@@ -84,7 +84,7 @@ class MMQImpl {
   // Destructor waits for the consumer thread to terminate, which implies committing all the queued messages.
   ~MMQImpl() {
     if (consumer_thread_created_) {
-      assert(consumer_thread_.joinable());
+      CURRENT_ASSERT(consumer_thread_.joinable());
       {
         std::lock_guard<std::mutex> lock(mutex_);
         destructing_ = true;

Blocks/MMQ/test.cc

@@ -44,12 +44,12 @@ TEST(InMemoryMQ, SmokeTest) {
     std::atomic_size_t processed_messages_;
     ConsumerImpl() : processed_messages_(0u) {}
     EntryResponse operator()(const std::string& s, idxts_t current, idxts_t) {
-      assert(current.index >= expected_next_message_index_);
+      CURRENT_ASSERT(current.index >= expected_next_message_index_);
       dropped_messages_ += (current.index - expected_next_message_index_);
       expected_next_message_index_ = (current.index + 1);
       messages_ += s + '\n';
       ++processed_messages_;
-      assert(expected_next_message_index_ - processed_messages_ - 1 == dropped_messages_);
+      CURRENT_ASSERT(expected_next_message_index_ - processed_messages_ - 1 == dropped_messages_);
       return EntryResponse::More;
     }
   };
@@ -82,7 +82,7 @@ struct SuspendableConsumerImpl {
       ;  // Spin lock.
     }
     messages_.push_back(s);
-    assert(last.index >= total_messages_accepted_by_the_queue_);
+    CURRENT_ASSERT(last.index >= total_messages_accepted_by_the_queue_);
     total_messages_accepted_by_the_queue_ = last.index;
     if (processing_delay_ms_) {
       std::this_thread::sleep_for(std::chrono::milliseconds(processing_delay_ms_));

Blocks/Persistence/file.h

@@ -56,7 +56,7 @@ class IteratorOverFileOfPersistedEntries {
  public:
   explicit IteratorOverFileOfPersistedEntries(std::istream& fi, std::streampos offset, uint64_t index_at_offset)
       : fi_(fi), next_(index_at_offset, std::chrono::microseconds(0)) {
-    assert(!fi_.bad());
+    CURRENT_ASSERT(!fi_.bad());
     if (offset) {
       fi_.seekg(offset, std::ios_base::beg);
     }
@@ -152,8 +152,8 @@ class FilePersister {
         std::streampos current_offset(0);
         while (cit.ProcessNextEntry(
             [&fi, &offset, &timestamp, &current_offset](const idxts_t& current, const char*) {
-              assert(current.index == offset.size());
-              assert(current.index == timestamp.size());
+              CURRENT_ASSERT(current.index == offset.size());
+              CURRENT_ASSERT(current.index == timestamp.size());
               offset.push_back(current_offset);
               timestamp.push_back(current.us);
               current_offset = fi.tellg();
@@ -312,8 +312,8 @@ class FilePersister {
     const auto current = idxts_t(iterator.index, iterator.us);
     {
       std::lock_guard<std::mutex> lock(file_persister_impl_->mutex);
-      assert(file_persister_impl_->offset.size() == iterator.index);
-      assert(file_persister_impl_->timestamp.size() == iterator.index);
+      CURRENT_ASSERT(file_persister_impl_->offset.size() == iterator.index);
+      CURRENT_ASSERT(file_persister_impl_->timestamp.size() == iterator.index);
       file_persister_impl_->offset.push_back(file_persister_impl_->appender.tellp());
       file_persister_impl_->timestamp.push_back(timestamp);
     }
@@ -377,8 +377,8 @@ class FilePersister {
       CURRENT_THROW(InvalidIterableRangeException());
     }
     std::lock_guard<std::mutex> lock(file_persister_impl_->mutex);
-    assert(file_persister_impl_->offset.size() >=
-           current_size);  // "Greater" is OK, `Iterate()` is multithreaded. -- D.K.
+    CURRENT_ASSERT(file_persister_impl_->offset.size() >=
+                   current_size);  // "Greater" is OK, `Iterate()` is multithreaded. -- D.K.
     return IterableRange(
         file_persister_impl_, begin_index, end_index, file_persister_impl_->offset[begin_index]);
   }

Blocks/SS/pubsub.h

@@ -27,7 +27,6 @@ SOFTWARE.
 #define BLOCKS_SS_PUBSUB_H
 
 #include "../../port.h"
-#include <cassert>
 
 #include "idx_ts.h"
 
@@ -168,7 +167,7 @@ struct PassEntryToSubscriberIfTypeMatchesImpl {
     if (Exists<TYPE_SUBSCRIBED_TO>(entry_cref)) {
       return f(Value<TYPE_SUBSCRIBED_TO>(std::forward<E>(entry)), current, last);
     } else {
-      assert(current.index <= last.index);
+      CURRENT_ASSERT(current.index <= last.index);
       if (current.index < last.index) {
         return EntryResponse::More;
       } else {

Bricks/dot/graphviz.h

@@ -29,7 +29,6 @@ SOFTWARE.
 
 #include "../port.h"
 
-#include <cassert>
 #include <vector>
 #include <string>
 #include <sstream>
@@ -254,8 +253,9 @@ struct GenericGraph {
     const auto output_file_deleter = current::FileSystem::ScopedRmFile(output_file_name);
 
     current::FileSystem::WriteStringToFile(AsDOT(), input_file_name.c_str());
-    assert(!::system(current::strings::Printf(
-                         "dot -T svg %s -o %s\n", input_file_name.c_str(), output_file_name.c_str()).c_str()));
+    CURRENT_ASSERT(
+        !::system(current::strings::Printf(
+                      "dot -T svg %s -o %s\n", input_file_name.c_str(), output_file_name.c_str()).c_str()));
     return current::FileSystem::ReadFileAsString(output_file_name.c_str());
   }
 };

Bricks/file/file.h

@@ -29,7 +29,6 @@ SOFTWARE.
 
 #include "../port.h"
 
-#include <cassert>
 #include <cstdio>
 #include <fstream>
 #include <string>
@@ -108,12 +107,12 @@ struct FileSystem {
   static inline std::string GenTmpFileName() {
     char buffer[L_tmpnam];
 #if defined(CURRENT_WINDOWS)
-    assert(!(::tmpnam_s(buffer)));
+    CURRENT_ASSERT(!(::tmpnam_s(buffer)));
 #elif defined(CURRENT_APPLE)
     // TODO(dkorolev): Fix temporary file names generation.
     return strings::Printf("/tmp/.current-tmp-%08x", rand());
 #else
-    assert(buffer == ::tmpnam(buffer));
+    CURRENT_ASSERT(buffer == ::tmpnam(buffer));
 #endif
     return buffer;
   }

Bricks/graph/gnuplot.h

@@ -27,7 +27,6 @@ SOFTWARE.
 #ifndef BRICKS_GRAPH_GNUPLOT_H
 #define BRICKS_GRAPH_GNUPLOT_H
 
-#include <cassert>
 #include <vector>
 #include <string>
 #include <map>
@@ -204,7 +203,7 @@ struct GNUPlot {
   }
 
   operator std::string() const {
-    assert(!plots_.empty());  // TODO(dkorolev): Exception?
+    CURRENT_ASSERT(!plots_.empty());  // TODO(dkorolev): Exception?
 
     const std::string input_file_name = current::FileSystem::GenTmpFileName();
     const std::string output_file_name = current::FileSystem::GenTmpFileName();
@@ -231,8 +230,9 @@ struct GNUPlot {
       }
     }
     if (output_format_ != "gnuplot") {
-      assert(!::system(strings::Printf("gnuplot <%s >%s\n", input_file_name.c_str(), output_file_name.c_str())
-                           .c_str()));
+      CURRENT_ASSERT(
+          !::system(
+              strings::Printf("gnuplot <%s >%s\n", input_file_name.c_str(), output_file_name.c_str()).c_str()));
       return current::FileSystem::ReadFileAsString(output_file_name.c_str());
     } else {
       // For unit tests, just compare the inputs.

Bricks/net/http/headers/headers.h

@@ -28,7 +28,6 @@ SOFTWARE.
 #include "../../../port.h"
 
 #include <algorithm>
-#include <cassert>
 #include <map>
 #include <string>
 #include <vector>
@@ -228,7 +227,8 @@ struct Headers final {
     Header::ThrowIfHeaderIsCookie(header);
     const auto rhs = map.find(header);
     if (rhs != map.end()) {
-      assert(rhs->second);  // Invariant: If `header` exists in map, its `std::unique_ptr<>` value is valid.
+      CURRENT_ASSERT(
+          rhs->second);  // Invariant: If `header` exists in map, its `std::unique_ptr<>` value is valid.
       return rhs->second->value;
     } else {
       CURRENT_THROW(HeaderNotFoundException(header));
@@ -239,7 +239,8 @@ struct Headers final {
     Header::ThrowIfHeaderIsCookie(header);
     const auto rhs = map.find(header);
     if (rhs != map.end()) {
-      assert(rhs->second);  // Invariant: If `header` exists in map, its `std::unique_ptr<>` value is valid.
+      CURRENT_ASSERT(
+          rhs->second);  // Invariant: If `header` exists in map, its `std::unique_ptr<>` value is valid.
       return rhs->second->value;
     } else {
       return value_if_not_found;
@@ -253,7 +254,8 @@ struct Headers final {
     Header::ThrowIfHeaderIsCookie(header);
     const auto rhs = map.find(header);
     if (rhs != map.end()) {
-      assert(rhs->second);  // Invariant: If `header` exists in map, its `std::unique_ptr<>` value is valid.
+      CURRENT_ASSERT(
+          rhs->second);  // Invariant: If `header` exists in map, its `std::unique_ptr<>` value is valid.
       return *rhs->second;
     } else {
       CURRENT_THROW(HeaderNotFoundException(header));

Bricks/net/http/impl/server.h

@@ -156,7 +156,7 @@ class GenericHTTPRequestData : public HELPER {
       size_t chunk;
       size_t read_count;
       // Use `- offset - 1` instead of just `- offset` to leave room for the '\0'.
-      assert(buffer_.size() > offset + 1);
+      CURRENT_ASSERT(buffer_.size() > offset + 1);
       // NOTE: This `if` should not be made a `while`, as it may so happen that the boundary between two
       // consecutively received packets lays right on the final size, but instead of parsing the received body,
       // the server would wait forever for more data to arrive from the client.
@@ -218,7 +218,8 @@ class GenericHTTPRequestData : public HELPER {
                 //    during the next iteration of the outer loop.
                 // The original version of this code was only adding one to `next_offset`.
                 // This had a bug, which got revealed as the `while` loop above has been corrected into `if`.
-                // Upon changing the `while` to an `if`, the `assert (buffer_.size() > offset + 1);` check above
+                // Upon changing the `while` to an `if`, the `CURRENT_ASSERT(buffer_.size() > offset + 1);`
+                // check above
                 // would fail on a chunked HTTP body of several large chunks. Thus, `next_offset + 2` is it.
                 // Note that the actual `resize()` would always allocate more room than the extra two bytes.
                 // The `std::max()` condition is kept just in case we compile Current for a device
@@ -319,7 +320,7 @@ class GenericHTTPRequestData : public HELPER {
 
   inline size_t BodyLength() const {
     if (body_buffer_begin_) {
-      assert(body_buffer_end_);
+      CURRENT_ASSERT(body_buffer_end_);
       return body_buffer_end_ - body_buffer_begin_;
     } else {
       return 0u;

Bricks/net/http/test.cc

@@ -345,7 +345,7 @@ TEST(PosixHTTPServerTest, ChunkedBodyLargeFirstChunk) {
 struct HTTPClientImplCURL {
   static string Syscall(const string& cmdline) {
     FILE* pipe = ::popen(cmdline.c_str(), "r");
-    assert(pipe);
+    CURRENT_ASSERT(pipe);
     char s[1024];
     const auto warn_unused_result_catch_warning = ::fgets(s, sizeof(s), pipe);
     static_cast<void>(warn_unused_result_catch_warning);
@@ -404,7 +404,7 @@ class HTTPClientImplPOSIX {
       connection.BlockingWrite("\r\n", false);
     }
     HTTPRequestData http_request(connection);
-    assert(!http_request.Body().empty());
+    CURRENT_ASSERT(!http_request.Body().empty());
     const string body = http_request.Body();
     server_thread.join();
     return body;

Bricks/net/tcp/impl/posix.h

@@ -34,7 +34,6 @@ SOFTWARE.
 #include "../../../util/singleton.h"
 #include "../../../template/enable_if.h"
 
-#include <cassert>
 #include <cstring>
 #include <string>
 #include <utility>
@@ -374,7 +373,7 @@ class Connection : public SocketHandle {
 #if defined(CURRENT_APPLE) || defined(CURRENT_WINDOWS)
     static_cast<void>(more);  // Supress the 'unused parameter' warning.
 #endif
-    assert(buffer);
+    CURRENT_ASSERT(buffer);
     BRICKS_NET_LOG(
         "S%05d BlockingWrite(%d bytes) ...\n", static_cast<SOCKET>(socket), static_cast<int>(write_length));
 #if !defined(CURRENT_WINDOWS) && !defined(CURRENT_APPLE)
@@ -397,7 +396,7 @@ class Connection : public SocketHandle {
   }
 
   inline Connection& BlockingWrite(const char* s, bool more) {
-    assert(s);
+    CURRENT_ASSERT(s);
     return BlockingWrite(s, strlen(s), more);
   }
 

Bricks/strings/chunk.h

@@ -61,7 +61,6 @@ SOFTWARE.
 #include "../port.h"
 
 #include <algorithm>
-#include <cassert>
 #include <cmath>
 #include <cstring>
 #include <unordered_map>
@@ -73,13 +72,13 @@ namespace strings {
 class Chunk {
  public:
   Chunk() : S(""), N(0u) {}
-  Chunk(const char* s, size_t n) : S(s), N(n) { assert(S[N] == '\0'); }
+  Chunk(const char* s, size_t n) : S(s), N(n) { CURRENT_ASSERT(S[N] == '\0'); }
   Chunk(const char* s) : S(s), N(strlen(s)) {}
   template <int L>
   Chunk(const char s[L])
       : S(s), N(L - 1) {
     // The above line break is `clang-format`, not me. -- D.K.
-    assert(S[N] == '\0');
+    CURRENT_ASSERT(S[N] == '\0');
   }
   Chunk(const std::string& s) : S(s.data()), N(s.size()) {}
   // Copyable and assignable by design.
@@ -92,15 +91,15 @@ class Chunk {
   void assign(const char* s, size_t n) {
     S = s;
     N = n;
-    assert(S[N] == '\0');
+    CURRENT_ASSERT(S[N] == '\0');
   }
 
   void clear() {
     S = "";
     N = 0u;
   }
 
-  void CheckPrivilege(size_t i) const { assert(i <= N); }
+  void CheckPrivilege(size_t i) const { CURRENT_ASSERT(i <= N); }
 
   char operator[](size_t i) const {
     CheckPrivilege(i);  // Once is enough.

Bricks/strings/rounding.h

@@ -25,19 +25,20 @@ SOFTWARE.
 #ifndef BRICKS_STRINGS_ROUNDING_H
 #define BRICKS_STRINGS_ROUNDING_H
 
+#include "../../port.h"
+
 #include <cstring>
 #include <string>
 #include <sstream>
 #include <cmath>
-#include <cassert>
 
 namespace current {
 namespace strings {
 
 // Rounds the number to have `n_digits` significant digits.
 inline std::string RoundDoubleToString(double value, size_t n_digits) {
-  assert(n_digits >= 1);
-  assert(n_digits <= 100);
+  CURRENT_ASSERT(n_digits >= 1);
+  CURRENT_ASSERT(n_digits <= 100);
   // `value` will be between `10^dim` and `10^(dim+1)`.
   const int dim = static_cast<int>(std::floor((std::log(value) / std::log(10.0)) + 1e-6));
   const double k = std::pow(10.0, static_cast<double>(dim - static_cast<int>(n_digits) + 1));

Bricks/util/lazy_instantiation.h

@@ -134,10 +134,10 @@ class LazilyInstantiated {
   T& InstantiateAsSharedPtr(std::shared_ptr<T>& shared_instance,
                             LazyInstantiationStrategy strategy = LazyInstantiationStrategy::Flexible) const {
     if (strategy == LazyInstantiationStrategy::ShouldNotBeInitialized) {
-      assert(!shared_instance);
+      CURRENT_ASSERT(!shared_instance);
     }
     if (strategy == LazyInstantiationStrategy::ShouldAlreadyBeInitialized) {
-      assert(shared_instance);
+      CURRENT_ASSERT(shared_instance);
     }
     if (!shared_instance) {
       shared_instance = InstantiateAsSharedPtr();

Bricks/util/test.cc

@@ -122,7 +122,7 @@ TEST(Util, MakeScopeGuard) {
           story_ += "helper_end\n";
           called_ = true;
         } else {
-          assert(false);  // LCOV_EXCL_LINE
+          CURRENT_ASSERT(false);  // LCOV_EXCL_LINE
         }
       }
 

Bricks/util/waitable_terminate_signal.h

@@ -26,7 +26,6 @@ SOFTWARE.
 #define BRICKS_UTIL_WAITABLE_TERMINATE_SIGNAL_H
 
 #include <atomic>
-#include <cassert>
 #include <condition_variable>
 #include <mutex>
 #include <unordered_set>