clock.cpp:    errno_assert (rc == 0);
connect_session.cpp:    zmq_assert (io_thread);
connect_session.cpp:        alloc_assert (connecter);
connect_session.cpp:            alloc_assert (pgm_sender);
connect_session.cpp:            zmq_assert (rc == 0);
connect_session.cpp:            alloc_assert (pgm_receiver);
connect_session.cpp:            zmq_assert (rc == 0);
connect_session.cpp:            zmq_assert (false);
connect_session.cpp:    zmq_assert (false);
ctx.cpp:    alloc_assert (slots);
ctx.cpp:    alloc_assert (reaper);
ctx.cpp:        alloc_assert (io_thread);
ctx.cpp:    zmq_assert (log_socket);
ctx.cpp:    zmq_assert (rc == 0);
ctx.cpp:    zmq_assert (sockets.empty ());
ctx.cpp:        zmq_assert (rc == 0);
ctx.cpp:    zmq_assert (rc == 0);
ctx.cpp:    zmq_assert (cmd.type == command_t::done);
ctx.cpp:    zmq_assert (sockets.empty ());
ctx.cpp:    zmq_assert (min_load != -1);
ctx.cpp:    zmq_assert (rc == 0);
decoder.cpp:            errno_assert (rc == 0);
decoder.cpp:        errno_assert (rc == 0);
decoder.cpp:        errno_assert (rc == 0);
decoder.cpp:    errno_assert (rc == 0);
decoder.hpp:            alloc_assert (buf);
devpoll.cpp:    errno_assert (devpoll_fd != -1);
devpoll.cpp:    zmq_assert (rc == sizeof pfd);
devpoll.cpp:    assert (!fd_table [fd_].valid);
devpoll.cpp:    assert (fd_table [handle_].valid);
devpoll.cpp:        errno_assert (n != -1);
dist.cpp:    zmq_assert (pipes.empty ());
dist.cpp:    zmq_assert (!terminating);
dist.cpp:        zmq_assert (rc == 0);
dist.cpp:        zmq_assert (rc == 0);
dist.cpp:        zmq_assert (rc == 0);
dist.cpp:            zmq_assert (rc == 0);
dist.cpp:        zmq_assert (rc == 0);
dist.cpp:    zmq_assert (rc == 0);
encoder.hpp:            alloc_assert (buf);
epoll.cpp:    errno_assert (epoll_fd != -1);
epoll.cpp:    alloc_assert (pe);
epoll.cpp:    errno_assert (rc != -1);
epoll.cpp:    errno_assert (rc != -1);
epoll.cpp:    errno_assert (rc != -1);
epoll.cpp:    errno_assert (rc != -1);
epoll.cpp:    errno_assert (rc != -1);
epoll.cpp:    errno_assert (rc != -1);
epoll.cpp:        errno_assert (n != -1);
err.cpp:    zmq_assert (rc);
err.cpp:        wsa_assert (false);
err.hpp:#include <assert.h>
err.hpp:#define wsa_assert(x) \
err.hpp://  Provides convenient way to assert on WSA-style errors on Windows.
err.hpp:#define wsa_assert_no(no) \
err.hpp:#define win_assert(x) \
err.hpp://  This macro works in exactly the same way as the normal assert. It is used
err.hpp://  in its stead because standard assert on Win32 in broken - it prints nothing
err.hpp:#define zmq_assert(x) \
err.hpp:#define errno_assert(x) \
err.hpp:#define posix_assert(x) \
err.hpp:#define gai_assert(x) \
err.hpp:#define alloc_assert(x) \
fq.cpp:    zmq_assert (pipes.empty ());
fq.cpp:    zmq_assert (terminating || (!more || pipes [current] != pipe_));
fq.cpp:    zmq_assert (!terminating);
fq.cpp:        zmq_assert (!(more && !fetched));
io_object.cpp:    zmq_assert (io_thread_);
io_object.cpp:    zmq_assert (!poller);
io_object.cpp:    zmq_assert (poller);
io_object.cpp:    zmq_assert (false);
io_object.cpp:    zmq_assert (false);
io_object.cpp:    zmq_assert (false);
io_thread.cpp:    alloc_assert (poller);
io_thread.cpp:        errno_assert (rc == 0);
io_thread.cpp:    zmq_assert (false);
io_thread.cpp:    zmq_assert (false);
io_thread.cpp:    zmq_assert (poller);
ip.cpp:    zmq_assert (fd != -1);
ip.cpp:    zmq_assert (rc != -1);
ip.cpp:    alloc_assert (ifr);
ip.cpp:    zmq_assert (rc != -1);
ip.cpp:            zmq_assert (rc != -1);
ip.cpp:    zmq_assert (sd != -1);
ip.cpp:    zmq_assert (rc == 0);
ip.cpp:    zmq_assert (ifa != NULL);
ip.cpp:        zmq_assert (out_addrlen <= sizeof (*addr_));
ip.cpp:        zmq_assert (out_addrlen <= sizeof (*addr_));
ip.cpp:    zmq_assert ((size_t) (res->ai_addrlen) <= sizeof (*addr_));
ip.cpp:    zmq_assert ((size_t) (res->ai_addrlen) <= sizeof (*addr_));
kqueue.cpp:    errno_assert (kqueue_fd != -1);
kqueue.cpp:    errno_assert (rc != -1);
kqueue.cpp:    errno_assert (rc != -1);
kqueue.cpp:    alloc_assert (pe);
kqueue.cpp:        errno_assert (n != -1);
lb.cpp:    zmq_assert (pipes.empty ());
lb.cpp:    zmq_assert (!terminating);
lb.cpp:        errno_assert (rc == 0);
lb.cpp:        zmq_assert (rc == 0);
lb.cpp:        zmq_assert (!more);
lb.cpp:    zmq_assert (rc == 0);
mailbox.cpp:    zmq_assert (!ok);
mailbox.cpp:    errno_assert (rc == 0);
mailbox.cpp:    zmq_assert (ok);
mutex.hpp:                posix_assert (rc);
mutex.hpp:                posix_assert (rc);
mutex.hpp:                posix_assert (rc);
mutex.hpp:                posix_assert (rc);
named_session.cpp:    zmq_assert (!peer_identity.empty ());
named_session.cpp:    zmq_assert (peer_identity [0] != 0);
named_session.cpp:    zmq_assert (ok);
named_session.cpp:    zmq_assert (peer_identity == peer_identity_);
object.cpp:        zmq_assert (false);
object.cpp:        zmq_assert (peer_identity_.size () <= 0xff);
object.cpp:        alloc_assert (cmd.args.attach.peer_identity_size);
object.cpp:        zmq_assert (peer_identity_.size () <= 0xff);
object.cpp:        alloc_assert (cmd.args.bind.peer_identity_size);
object.cpp:    zmq_assert (false);
object.cpp:    zmq_assert (false);
object.cpp:    zmq_assert (false);
object.cpp:    zmq_assert (false);
object.cpp:    zmq_assert (false);
object.cpp:    zmq_assert (false);
object.cpp:    zmq_assert (false);
object.cpp:    zmq_assert (false);
object.cpp:    zmq_assert (false);
object.cpp:    zmq_assert (false);
object.cpp:    zmq_assert (false);
object.cpp:    zmq_assert (false);
object.cpp:    zmq_assert (false);
object.cpp:    zmq_assert (false);
object.cpp:    zmq_assert (false);
own.cpp:    zmq_assert (!owner);
own.cpp:    zmq_assert (!terminating);
own.cpp:    zmq_assert (term_acks > 0);
own.cpp:        zmq_assert (owned.empty ());
pair.cpp:    zmq_assert (!inpipe);
pair.cpp:    zmq_assert (!outpipe);
pair.cpp:    zmq_assert (!inpipe && !outpipe);
pair.cpp:    zmq_assert (pipe_ == inpipe);
pair.cpp:    zmq_assert (pipe_ == outpipe);
pair.cpp:    zmq_assert (!inpipe_alive);
pair.cpp:    zmq_assert (!outpipe_alive);
pair.cpp:    zmq_assert (rc == 0);
pgm_receiver.cpp:    zmq_assert (peers.empty ());
pgm_receiver.cpp:    zmq_assert (false);
pgm_receiver.cpp:    zmq_assert (mru_decoder != NULL);
pgm_receiver.cpp:    zmq_assert (pending_ptr != NULL);
pgm_receiver.cpp:    zmq_assert (pending_bytes == 0);
pgm_receiver.cpp:        zmq_assert ((size_t) received >= sizeof (uint16_t));
pgm_receiver.cpp:            zmq_assert (offset <= received);
pgm_receiver.cpp:            zmq_assert (it->second.decoder == NULL);
pgm_receiver.cpp:            alloc_assert (it->second.decoder);
pgm_receiver.cpp:    zmq_assert (token == rx_timer_id);
pgm_sender.cpp:    alloc_assert (out_buffer);
pgm_sender.cpp:    zmq_assert (false);
pgm_sender.cpp:        zmq_assert (nbytes == 0);
pgm_sender.cpp:            zmq_assert (errno == EBUSY);
pgm_sender.cpp:        zmq_assert (false);
pgm_socket.cpp:    zmq_assert (sock == NULL);
pgm_socket.cpp:        zmq_assert (pgm_error != NULL);
pgm_socket.cpp:        zmq_assert (false);
pgm_socket.cpp:    zmq_assert (res != NULL);
pgm_socket.cpp:            zmq_assert (pgm_error != NULL);
pgm_socket.cpp:            zmq_assert (false);
pgm_socket.cpp:            zmq_assert (pgm_error != NULL);
pgm_socket.cpp:            zmq_assert (false);
pgm_socket.cpp:        zmq_assert (pgm_error != NULL);
pgm_socket.cpp:        zmq_assert (false);
pgm_socket.cpp:        zmq_assert (pgm_error != NULL);
pgm_socket.cpp:        zmq_assert (in_batch_size > 0);
pgm_socket.cpp:        zmq_assert (pgm_msgv_len);
pgm_socket.cpp:        alloc_assert (pgm_msgv);
pgm_socket.cpp:    zmq_assert (receive_fd_);
pgm_socket.cpp:    zmq_assert (waiting_pipe_fd_);
pgm_socket.cpp:    zmq_assert (rc);
pgm_socket.cpp:    zmq_assert (socklen == sizeof (*receive_fd_));
pgm_socket.cpp:    zmq_assert (rc);
pgm_socket.cpp:    zmq_assert (socklen == sizeof (*waiting_pipe_fd_));
pgm_socket.cpp:    zmq_assert (send_fd_);
pgm_socket.cpp:    zmq_assert (receive_fd_);
pgm_socket.cpp:    zmq_assert (rdata_notify_fd_);
pgm_socket.cpp:    zmq_assert (pending_notify_fd_);
pgm_socket.cpp:    zmq_assert (rc);
pgm_socket.cpp:    zmq_assert (socklen == sizeof (*receive_fd_));
pgm_socket.cpp:    zmq_assert (rc);
pgm_socket.cpp:    zmq_assert (socklen == sizeof (*receive_fd_));
pgm_socket.cpp:    zmq_assert (rc);
pgm_socket.cpp:    zmq_assert (socklen == sizeof (*rdata_notify_fd_));
pgm_socket.cpp:    zmq_assert (rc);
pgm_socket.cpp:    zmq_assert (socklen == sizeof (*pending_notify_fd_));
pgm_socket.cpp:        zmq_assert (status == PGM_IO_STATUS_NORMAL);
pgm_socket.cpp:        zmq_assert ((ssize_t) nbytes == (ssize_t) data_len_);
pgm_socket.cpp:        zmq_assert (status == PGM_IO_STATUS_RATE_LIMITED ||
pgm_socket.cpp:    zmq_assert (rc);
pgm_socket.cpp:    zmq_assert (rc);
pgm_socket.cpp:    zmq_assert (rc);
pgm_socket.cpp:    zmq_assert (optlen == sizeof (max_tsdu));
pgm_socket.cpp:        zmq_assert (pgm_msgv_processed == 0);
pgm_socket.cpp:        zmq_assert (nbytes_processed == 0);
pgm_socket.cpp:        zmq_assert (nbytes_rec == 0);
pgm_socket.cpp:        zmq_assert (status != PGM_IO_STATUS_ERROR);
pgm_socket.cpp:            zmq_assert (nbytes_rec == 0);
pgm_socket.cpp:            zmq_assert (nbytes_rec == 0);
pgm_socket.cpp:            zmq_assert (nbytes_rec == 0);
pgm_socket.cpp:        zmq_assert (status == PGM_IO_STATUS_NORMAL);
pgm_socket.cpp:        zmq_assert (pgm_msgv_processed <= pgm_msgv_len);
pgm_socket.cpp:    zmq_assert (nbytes_rec > 0);
pgm_socket.cpp:    zmq_assert (pgm_msgv [pgm_msgv_processed].msgv_len == 1);
pgm_socket.cpp:    zmq_assert (pgm_msgv_processed <= pgm_msgv_len);
pgm_socket.cpp:    zmq_assert (status != PGM_IO_STATUS_ERROR);
pgm_socket.cpp:    zmq_assert (dummy_bytes == 0 && (status == PGM_IO_STATUS_TIMER_PENDING || 
pipe.cpp:    zmq_assert (!writer);
pipe.cpp:    zmq_assert (pipe);
pipe.cpp:    zmq_assert (!sink);
pipe.cpp:        zmq_assert (ok);
pipe.cpp:    zmq_assert (sink);
pipe.cpp:        alloc_assert (swap);
pipe.cpp:        zmq_assert (rc == 0);
pipe.cpp:    zmq_assert (!sink);
pipe.cpp:        zmq_assert (stored);
pipe.cpp:        zmq_assert (msg.flags & ZMQ_MSG_MORE);
pipe.cpp:        zmq_assert (sink);
pipe.cpp:    zmq_assert (sink);
pipe.cpp:    alloc_assert (pipe);
pipe.cpp:    alloc_assert (*reader_);
pipe.cpp:    alloc_assert (*writer_);
poll.cpp:    assert (fd_table [fd_].index == retired_fd);
poll.cpp:    assert (index != retired_fd);
poll.cpp:        errno_assert (rc != -1);
poll.cpp:            zmq_assert (!(pollset [i].revents & POLLNVAL));
poller_base.cpp:    zmq_assert (get_load () == 0);
poller_base.cpp:    zmq_assert (false);
pull.cpp:    zmq_assert (inpipe_ && !outpipe_);
push.cpp:    zmq_assert (!inpipe_ && outpipe_);
reaper.cpp:    alloc_assert (poller);
reaper.cpp:        errno_assert (rc == 0);
reaper.cpp:    zmq_assert (false);
reaper.cpp:    zmq_assert (false);
rep.cpp:                errno_assert (rc == 0);
rep.cpp:                zmq_assert (rc == 0);
req.cpp:        zmq_assert (rc == 0);
req.cpp:        zmq_assert (msg_->flags & ZMQ_MSG_MORE);
req.cpp:        zmq_assert (zmq_msg_size (msg_) == 0);
select.cpp:    zmq_assert (fds.size () <= FD_SETSIZE);
select.cpp:    zmq_assert (it != fds.end ());
select.cpp:        wsa_assert (rc != SOCKET_ERROR);
select.cpp:        errno_assert (rc != -1);
semaphore.hpp:            win_assert (ev != NULL);
semaphore.hpp:            win_assert (rc != 0);    
semaphore.hpp:            win_assert (rc != WAIT_FAILED);
semaphore.hpp:            win_assert (rc != 0);
semaphore.hpp:            posix_assert (rc);
semaphore.hpp:            posix_assert (rc);
semaphore.hpp:            posix_assert (rc);
semaphore.hpp:            posix_assert (rc);
semaphore.hpp:             posix_assert (rc);
semaphore.hpp:            posix_assert (rc);
semaphore.hpp:             errno_assert (rc != -1);
semaphore.hpp:             errno_assert (rc != -1);
semaphore.hpp:             errno_assert (rc != -1);
semaphore.hpp:            errno_assert (rc != -1);
session.cpp:    zmq_assert (!in_pipe);
session.cpp:    zmq_assert (!out_pipe);
session.cpp:    zmq_assert (state == pending);
session.cpp:                zmq_assert (!incomplete_in);
session.cpp:    zmq_assert (!pipes_attached);
session.cpp:        zmq_assert (!in_pipe);
session.cpp:        zmq_assert (!out_pipe);
session.cpp:    zmq_assert (in_pipe == pipe_);
session.cpp:    zmq_assert (!delimiter_processed);
session.cpp:    zmq_assert (in_pipe == pipe_);
session.cpp:    zmq_assert (out_pipe == pipe_);
session.cpp:    zmq_assert (in_pipe == pipe_);
session.cpp:    zmq_assert (out_pipe == pipe_);
session.cpp:        zmq_assert (!engine);
session.cpp:        zmq_assert (!in_pipe && !out_pipe);
session.cpp:    zmq_assert (!engine);
session.cpp:    zmq_assert (state == active);
session.cpp:       zmq_assert (!has_linger_timer);
session.cpp:    zmq_assert (id_ == linger_timer_id);
signaler.cpp:    errno_assert (rc == 0);
signaler.cpp:    wsa_assert (rc != SOCKET_ERROR);
signaler.cpp:    wsa_assert (rc != SOCKET_ERROR);
signaler.cpp:    errno_assert (flags >= 0);
signaler.cpp:    errno_assert (rc == 0);
signaler.cpp:    errno_assert (flags >= 0);
signaler.cpp:    errno_assert (rc == 0);
signaler.cpp:    wsa_assert (rc != SOCKET_ERROR);
signaler.cpp:    wsa_assert (rc != SOCKET_ERROR);
signaler.cpp:    wsa_assert (nbytes != SOCKET_ERROR);
signaler.cpp:    zmq_assert (nbytes == sizeof (dummy));
signaler.cpp:        zmq_assert (nbytes == sizeof (dummy));
signaler.cpp:        zmq_assert (errno == EINTR);
signaler.cpp:    zmq_assert (rc == 1);
signaler.cpp:    zmq_assert (pfd.revents & POLLIN);
signaler.cpp:    wsa_assert (rc != SOCKET_ERROR);
signaler.cpp:        zmq_assert (errno == EINTR);
signaler.cpp:    zmq_assert (rc == 1);
signaler.cpp:    wsa_assert (nbytes != SOCKET_ERROR);
signaler.cpp:    errno_assert (nbytes >= 0);
signaler.cpp:    zmq_assert (nbytes == sizeof (dummy));
signaler.cpp:    zmq_assert (dummy == 0);
signaler.cpp:    wsa_assert (listener != INVALID_SOCKET);
signaler.cpp:    wsa_assert (rc != SOCKET_ERROR);
signaler.cpp:    wsa_assert (rc != SOCKET_ERROR);
signaler.cpp:    wsa_assert (rc != SOCKET_ERROR);
signaler.cpp:    wsa_assert (rc != SOCKET_ERROR);
signaler.cpp:    wsa_assert (rc != SOCKET_ERROR);
signaler.cpp:    wsa_assert (*w_ != INVALID_SOCKET);
signaler.cpp:    wsa_assert (rc != SOCKET_ERROR);
signaler.cpp:    wsa_assert (rc != SOCKET_ERROR);
signaler.cpp:    wsa_assert (*r_ != INVALID_SOCKET);
signaler.cpp:    wsa_assert (rc != SOCKET_ERROR);
signaler.cpp:    errno_assert (listener != -1);
signaler.cpp:    errno_assert (rc != -1);
signaler.cpp:    errno_assert (rc != -1);
signaler.cpp:    errno_assert (rc != -1);
signaler.cpp:    errno_assert (rc != -1);
signaler.cpp:    errno_assert (rc != -1);
signaler.cpp:    errno_assert (*w_ != -1);
signaler.cpp:    errno_assert (rc != -1);
signaler.cpp:    errno_assert (rc != -1);
signaler.cpp:    errno_assert (rc != -1);
signaler.cpp:    errno_assert (*r_ != -1);
signaler.cpp:    errno_assert (rc == 0);
socket_base.cpp:    alloc_assert (s);
socket_base.cpp:    zmq_assert (destroyed);
socket_base.cpp:    zmq_assert (sessions.empty ());
socket_base.cpp:    zmq_assert (uri_ != NULL);
socket_base.cpp:        errno_assert (rc == 0);
socket_base.cpp:        alloc_assert (listener);
socket_base.cpp:    zmq_assert (false);
socket_base.cpp:    alloc_assert (session);
socket_base.cpp:    zmq_assert (it != sessions.end ());
socket_base.cpp:        errno_assert (rc == 0);
socket_base.cpp:    zmq_assert (false);
socket_base.cpp:    zmq_assert (false);
swap.cpp:    zmq_assert (filesize > 0);
swap.cpp:    zmq_assert (block_size > 0);
swap.cpp:    alloc_assert (buf1);
swap.cpp:    alloc_assert (buf2);
swap.cpp:    errno_assert (rc == 0);
swap.cpp:    errno_assert (rc == 0);
swap.cpp:    zmq_assert (read_pos != write_pos);
swap.cpp:        zmq_assert (read_pos <= commit_pos && commit_pos <= write_pos);
swap.cpp:        zmq_assert (read_pos <= commit_pos || commit_pos <= write_pos);
swap.cpp:        errno_assert (offset == pos);
swap.cpp:        errno_assert (rc > 0);
swap.cpp:        errno_assert (offset == write_buf_start_addr);
swap.cpp:        errno_assert (rc > 0);
tcp_connecter.cpp:    zmq_assert (s == retired_fd);
tcp_connecter.cpp:    wsa_assert (rc != SOCKET_ERROR);
tcp_connecter.cpp:    wsa_assert (rc != SOCKET_ERROR);
tcp_connecter.cpp:    zmq_assert (s != retired_fd);
tcp_connecter.cpp:    wsa_assert (rc != SOCKET_ERROR);
tcp_connecter.cpp:    zmq_assert (rc == 0);
tcp_connecter.cpp:        wsa_assert_no (err);
tcp_connecter.cpp:    zmq_assert (s == retired_fd);
tcp_connecter.cpp:        errno_assert (rc != -1);
tcp_connecter.cpp:        errno_assert (rc != -1);
tcp_connecter.cpp:        errno_assert (rc == 0);
tcp_connecter.cpp:        errno_assert (rc != SOCKET_ERROR);
tcp_connecter.cpp:        zmq_assert (AF_UNIX == sa->sa_family);
tcp_connecter.cpp:        errno_assert (rc != -1);
tcp_connecter.cpp:    zmq_assert (false);
tcp_connecter.cpp:    zmq_assert (s != retired_fd);
tcp_connecter.cpp:        //  Networking problems are OK. No need to assert.
tcp_connecter.cpp:        errno_assert (errno == ECONNREFUSED || errno == ECONNRESET ||
tcp_listener.cpp:    wsa_assert (rc != SOCKET_ERROR);
tcp_listener.cpp:    wsa_assert (rc != SOCKET_ERROR);
tcp_listener.cpp:    zmq_assert (s != retired_fd);
tcp_listener.cpp:    wsa_assert (rc != SOCKET_ERROR);
tcp_listener.cpp:    zmq_assert (s != retired_fd);
tcp_listener.cpp:    zmq_assert (sock != INVALID_SOCKET);
tcp_listener.cpp:    wsa_assert (rc != SOCKET_ERROR);
tcp_listener.cpp:    wsa_assert (rc != SOCKET_ERROR);
tcp_listener.cpp:        errno_assert (rc == 0);
tcp_listener.cpp:        errno_assert (rc != -1);
tcp_listener.cpp:        errno_assert (rc != -1);
tcp_listener.cpp:        errno_assert (rc != -1);
tcp_listener.cpp:    zmq_assert (s != retired_fd);
tcp_listener.cpp:    zmq_assert (s != retired_fd);
tcp_listener.cpp:    errno_assert (sock != -1); 
tcp_listener.cpp:    errno_assert (rc != -1);
tcp_listener.cpp:    errno_assert (rc != -1);
tcp_listener.cpp:        errno_assert (rc == 0);
tcp_listener.cpp:        errno_assert (rc != SOCKET_ERROR);
tcp_socket.cpp:    zmq_assert (s == retired_fd);
tcp_socket.cpp:        errno_assert (rc == 0);
tcp_socket.cpp:        errno_assert (rc == 0);
tcp_socket.cpp:    zmq_assert (s != retired_fd);
tcp_socket.cpp:    wsa_assert (rc != SOCKET_ERROR);
tcp_socket.cpp:    wsa_assert (nbytes != SOCKET_ERROR);
tcp_socket.cpp:    wsa_assert (nbytes != SOCKET_ERROR);
tcp_socket.cpp:    assert (s == retired_fd);
tcp_socket.cpp:        errno_assert (rc == 0);
tcp_socket.cpp:        errno_assert (rc == 0);
tcp_socket.cpp:    errno_assert (rc == 0);
tcp_socket.cpp:    zmq_assert (s != retired_fd);
tcp_socket.cpp:    errno_assert (nbytes != -1);
tcp_socket.cpp:    errno_assert (nbytes != -1);
thread.cpp:    win_assert (descriptor != NULL);
thread.cpp:    win_assert (rc != WAIT_FAILED);
thread.cpp:    win_assert (rc2 != 0);
thread.cpp:        errno_assert (rc == 0);
thread.cpp:        posix_assert (rc);
thread.cpp:    posix_assert (rc);
thread.cpp:    posix_assert (rc);
trie.cpp:            alloc_assert (next.table);
trie.cpp:            zmq_assert (next.table);
trie.cpp:            zmq_assert (next.table);
trie.cpp:            alloc_assert (next.node);
trie.cpp:            alloc_assert (next.table [c - min]);
uuid.cpp:    zmq_assert (ret == RPC_S_OK);
uuid.cpp:    zmq_assert (ret == RPC_S_OK);
uuid.cpp:    zmq_assert (status == uuid_s_ok);
uuid.cpp:    zmq_assert (status == uuid_s_ok);
uuid.cpp:    zmq_assert (ret == 1);
uuid.cpp:        zmq_assert (false);
uuid.cpp:        zmq_assert (false);  
xpub.cpp:    zmq_assert (!inpipe_ && outpipe_);
xrep.cpp:    zmq_assert (inpipes.empty ());
xrep.cpp:    zmq_assert (outpipes.empty ());
xrep.cpp:        zmq_assert (ok);
xrep.cpp:    zmq_assert (false);
xrep.cpp:    zmq_assert (false);
xrep.cpp:            zmq_assert (!it->active);
xrep.cpp:    zmq_assert (false);
xrep.cpp:            zmq_assert (!it->second.active);
xrep.cpp:    zmq_assert (false);
xrep.cpp:        zmq_assert (!current_out);
xrep.cpp:                zmq_assert (rc == 0);
xrep.cpp:                zmq_assert (rc == 0);
xrep.cpp:        zmq_assert (rc == 0);
xrep.cpp:        zmq_assert (rc == 0);
xrep.cpp:        zmq_assert (ok);
xrep.cpp:        zmq_assert (rc == 0);
xrep.cpp:    zmq_assert (rc == 0);
xrep.cpp:        zmq_assert (inpipes [current_in].active);
xrep.cpp:        zmq_assert (fetched);
xrep.cpp:            zmq_assert (rc == 0);
xreq.cpp:    zmq_assert (inpipe_ && outpipe_);
xsub.cpp:    zmq_assert (inpipe_ && !outpipe_);
xsub.cpp:    zmq_assert (rc == 0);
xsub.cpp:    zmq_assert (rc == 0);
xsub.cpp:            zmq_assert (rc == 0);
xsub.cpp:            zmq_assert (errno == EAGAIN);
xsub.cpp:            zmq_assert (rc == 0);
ypipe.hpp:                zmq_assert (rc);
yqueue.hpp:             alloc_assert (begin_chunk);
yqueue.hpp:                alloc_assert (end_chunk->next);
zmq_connecter.cpp:    zmq_assert (rc == 0);
zmq_connecter.cpp:    zmq_assert (io_thread);
zmq_connecter.cpp:    alloc_assert (init);
zmq_connecter.cpp:    zmq_assert (id_ == reconnect_timer_id);
zmq.cpp:    alloc_assert (msg_->content);
zmq.cpp:    zmq_assert ((msg_->flags | ZMQ_MSG_MASK) == 0xff);
zmq.cpp:    zmq_assert ((msg_->flags | ZMQ_MSG_MASK) == 0xff);
zmq.cpp:        zmq_assert (pgm_error != NULL);
zmq.cpp:        zmq_assert (false);
zmq.cpp:    zmq_assert (rc == 0);
zmq.cpp:    zmq_assert (LOBYTE (wsa_data.wVersion) == 2 &&
zmq.cpp:    alloc_assert (ctx);
zmq.cpp:    wsa_assert (rc != SOCKET_ERROR);
zmq.cpp:        zmq_assert (false);
zmq.cpp:    alloc_assert (pollfds);
zmq.cpp:            errno_assert (rc >= 0);
zmq.cpp:    zmq_assert (nitems_ <= FD_SETSIZE);
zmq.cpp:                wsa_assert (false);
zmq.cpp:                errno_assert (false);
zmq.cpp:    alloc_assert (watch);
zmq_engine.cpp:    zmq_assert (rc == 0);
zmq_engine.cpp:    zmq_assert (!plugged);
zmq_engine.cpp:    zmq_assert (!plugged);
zmq_engine.cpp:    zmq_assert (!inout);
zmq_engine.cpp:    zmq_assert (inout_);
zmq_engine.cpp:    zmq_assert (plugged);
zmq_engine.cpp:        zmq_assert (ephemeral_inout);
zmq_engine.cpp:            zmq_assert (ephemeral_inout);
zmq_engine.cpp:    zmq_assert (inout);
zmq_init.cpp:    alloc_assert (engine);
zmq_init.cpp:    zmq_assert (rc == 0);
zmq_init.cpp:    zmq_assert (rc == 0);
zmq_init.cpp:    zmq_assert (engine);
zmq_init.cpp:        zmq_assert (!engine);
zmq_init.cpp:        zmq_assert (ephemeral_engine);
zmq_init.cpp:        zmq_assert (socket);
zmq_init.cpp:            alloc_assert (session);
zmq_init.cpp:        alloc_assert (session);
zmq_listener.cpp:    zmq_assert (io_thread);
zmq_listener.cpp:    alloc_assert (init);