laag-libzmq 4.2.3.0

data/vendor/github.com/zeromq/libzmq/tests/CMakeLists.txt

@@ -0,0 +1,218 @@
+# CMake build script for ZeroMQ tests
+cmake_minimum_required(VERSION "2.8.1")
+
+# On Windows: solution file will be called tests.sln
+PROJECT(tests)
+
+set(tests
+        test_ancillaries
+        test_system
+        test_pair_inproc
+        test_pair_tcp
+        test_reqrep_inproc
+        test_reqrep_tcp
+        test_hwm
+        test_hwm_pubsub
+        test_reqrep_device
+        test_sub_forward
+        test_invalid_rep
+        test_msg_flags
+        test_msg_ffn
+        test_connect_resolve
+        test_immediate
+        test_last_endpoint
+        test_term_endpoint
+        test_router_mandatory
+        test_probe_router
+        test_stream
+        test_stream_empty
+        test_stream_disconnect
+        test_disconnect_inproc
+        test_unbind_inproc
+        test_unbind_wildcard
+        test_ctx_options
+        test_ctx_destroy
+        test_security_null
+        test_security_plain
+        test_security_zap
+        test_iov
+        test_spec_req
+        test_spec_rep
+        test_spec_dealer
+        test_spec_router
+        test_spec_pushpull
+        test_req_correlate
+        test_req_relaxed
+        test_conflate
+        test_inproc_connect
+        test_issue_566
+        test_shutdown_stress
+        test_timeo
+        test_many_sockets
+        test_diffserv
+        test_connect_rid
+        test_xpub_nodrop
+        test_pub_invert_matching
+        test_setsockopt
+        test_sockopt_hwm
+        test_heartbeats
+        test_atomics
+        test_bind_src_address
+        test_capabilities
+        test_metadata
+        test_router_handover
+        test_srcfd
+        test_stream_timeout
+        test_xpub_manual
+        test_xpub_welcome_msg
+        test_base85
+        test_bind_after_connect_tcp
+        test_sodium
+        test_monitor
+		test_socket_null
+	test_reconnect_ivl
+)
+if(ZMQ_HAVE_CURVE)
+  list(APPEND tests 
+          test_security_curve)
+endif()
+if(NOT WIN32)
+  list(APPEND tests
+          test_ipc_wildcard
+          test_pair_ipc
+          test_rebind_ipc
+          test_reqrep_ipc
+          test_proxy
+          test_proxy_single_socket
+          test_proxy_terminate
+          test_getsockopt_memset
+          test_filter_ipc
+          test_stream_exceeds_buffer
+          test_router_mandatory_hwm
+          test_use_fd_ipc
+          test_use_fd_tcp
+          test_zmq_poll_fd
+  )
+  if(HAVE_FORK)
+    list(APPEND tests test_fork)
+  endif()
+  if(CMAKE_SYSTEM_NAME MATCHES "Linux")
+    list(APPEND tests
+          test_abstract_ipc
+    )
+    if(ZMQ_HAVE_TIPC)
+      list(APPEND tests
+            test_pair_tipc
+            test_reqrep_device_tipc
+            test_reqrep_tipc
+            test_router_mandatory_tipc
+            test_sub_forward_tipc
+            test_connect_delay_tipc
+            test_shutdown_stress_tipc
+            test_term_endpoint_tipc
+      )
+    endif()
+  endif()
+endif()
+
+if(WITH_VMCI)
+  list(APPEND tests
+          test_pair_vmci
+          test_reqrep_vmci
+  )
+endif()
+
+
+IF (ENABLE_DRAFTS)
+    list(APPEND tests
+        test_poller
+        test_thread_safe
+        test_client_server
+        test_timers
+        test_radio_dish
+        test_udp
+        test_scatter_gather
+        test_dgram
+    )
+ENDIF (ENABLE_DRAFTS)
+
+# add location of platform.hpp for Windows builds
+if(WIN32)
+    add_definitions(-DZMQ_CUSTOM_PLATFORM_HPP)
+    add_definitions(-D_WINSOCK_DEPRECATED_NO_WARNINGS)
+    # Same name on 64bit systems
+    link_libraries(ws2_32.lib)
+endif()
+
+# add library and include dirs for all targets
+if (BUILD_SHARED)
+link_libraries(libzmq ${OPTIONAL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+else ()
+link_libraries(libzmq-static ${OPTIONAL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+endif ()
+include_directories("${CMAKE_SOURCE_DIR}/../include" "${CMAKE_BINARY_DIR}")
+
+foreach(test ${tests})
+  # target_sources not supported before CMake 3.1
+  if (ZMQ_HAVE_CURVE AND ${test} MATCHES test_security_curve)
+    add_executable(${test} ${test}.cpp
+        "../src/tweetnacl.c"
+        "../src/err.cpp"
+        "../src/random.cpp"
+        "../src/clock.cpp"
+        "testutil_security.hpp")
+  elseif (${test} MATCHES test_security_zap)
+    add_executable(${test} ${test}.cpp
+        "testutil_security.hpp")
+  else ()
+    add_executable(${test} ${test}.cpp)
+  endif ()
+  if(WIN32)
+    # This is the output for Debug dynamic builds on Visual Studio 6.0
+    # You should provide the correct directory, don't know how to do it automatically
+    find_path(LIBZMQ_PATH "libzmq.lib" PATHS "../bin/Win32/Debug/v120/dynamic")
+    if(NOT ${LIBZMQ_PATH} STREQUAL "LIBZMQ_PATH-NOTFOUND")
+        SET_TARGET_PROPERTIES( ${test} PROPERTIES LINK_FLAGS "/LIBPATH:${LIBZMQ_PATH}" )
+    endif()
+  else()
+    # per-test directories not generated on OS X / Darwin
+    if (NOT ${CMAKE_CXX_COMPILER_ID} MATCHES "Clang.*")
+        link_directories(${test} PRIVATE "${CMAKE_SOURCE_DIR}/../lib")
+    endif()
+  endif()
+
+
+  if(RT_LIBRARY)
+    target_link_libraries(${test} ${RT_LIBRARY} )
+  endif()
+  if(WIN32)
+    add_test(NAME ${test} WORKING_DIRECTORY ${LIBRARY_OUTPUT_PATH} COMMAND ${test})
+  else()
+    add_test(NAME ${test} COMMAND ${test})
+  endif()
+  set_tests_properties(${test} PROPERTIES TIMEOUT 10)
+endforeach()
+
+#override timeout for these tests
+if(ZMQ_HAVE_CURVE)
+  set_tests_properties(test_security_curve PROPERTIES TIMEOUT 60)
+endif()
+
+#add additional required flags
+#ZMQ_USE_TWEETNACL will already be defined when not using sodium
+if(ZMQ_HAVE_CURVE AND NOT ZMQ_USE_TWEETNACL)
+  target_compile_definitions(test_security_curve PRIVATE "-DZMQ_USE_TWEETNACL")
+endif()
+
+set_tests_properties(test_security_zap PROPERTIES TIMEOUT 60)
+
+#Check whether all tests in the current folder are present
+file(READ "${CMAKE_CURRENT_LIST_FILE}" CURRENT_LIST_FILE_CONTENT)
+file(GLOB ALL_TEST_SOURCES "test_*.cpp")
+foreach(TEST_SOURCE ${ALL_TEST_SOURCES})
+  get_filename_component(TESTNAME "${TEST_SOURCE}" NAME_WE)
+  string(REGEX MATCH "${TESTNAME}" MATCH_TESTNAME "${CURRENT_LIST_FILE_CONTENT}")
+  if (NOT MATCH_TESTNAME)
+    message(AUTHOR_WARNING "Test '${TESTNAME}' is not known to CTest.")
+  endif()
+endforeach()

data/vendor/github.com/zeromq/libzmq/tests/README.md

@@ -0,0 +1,28 @@
+#   Guidelines for tests
+
+Write your test case as if you were writing clean application code. It should be safe to compile on all platforms.
+
+The only include file you should use is `testutil.hpp`. Do not include files from src. Do not use the internal libzmq API or your test case is fair game to be deleted.
+
+If you must write non-portable code, wrap it in #ifdefs to ensure it will compile and run on all systems.
+
+Note that testutil.hpp includes platform.h. Do not include it yourself as it changes location depending on the build system and OS.
+
+All sources must contain the correct header. Please copy from test_system.cpp if you're not certain.
+
+Please use only ANSI C99 in test cases, no C++. This is to make the code more reusable.
+
+On many slower environments, like embedded systems, VMs or CI systems, test might
+fail because it takes time for sockets to settle after a connect. If you need
+to add a sleep, please be consistent with all the other tests and use:
+  msleep (SETTLE_TIME);
+
+# Building tests in Windows
+
+According to the version of your compiler, you should adapt the path `libzmq.lib` in the file `tests/CMakeLists.txt`.
+
+Install CMAKE
+CMD> CMAKE libzmq/tests
+CMD> tests.sln
+CMD> # build all projects in the solution
+

data/vendor/github.com/zeromq/libzmq/tests/test_abstract_ipc.cpp

@@ -0,0 +1,67 @@
+/*
+    Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
+
+    This file is part of libzmq, the ZeroMQ core engine in C++.
+
+    libzmq is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License (LGPL) as published
+    by the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    As a special exception, the Contributors give you permission to link
+    this library with independent modules to produce an executable,
+    regardless of the license terms of these independent modules, and to
+    copy and distribute the resulting executable under terms of your choice,
+    provided that you also meet, for each linked independent module, the
+    terms and conditions of the license of that module. An independent
+    module is a module which is not derived from or based on this library.
+    If you modify this library, you must extend this exception to your
+    version of the library.
+
+    libzmq is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+    License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "testutil.hpp"
+
+int main (void)
+{
+    setup_test_environment();
+    void *ctx = zmq_ctx_new ();
+    assert (ctx);
+
+    void *sb = zmq_socket (ctx, ZMQ_DEALER);
+    assert (sb);
+    int rc = zmq_bind (sb, "ipc://@tmp-tester");
+    assert (rc == 0);
+
+    char endpoint[200];
+    size_t size = sizeof(endpoint);
+    rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, endpoint, &size);
+    assert (rc == 0);
+    rc = strncmp(endpoint, "ipc://@tmp-tester", size);
+    assert (rc == 0);
+
+    void *sc = zmq_socket (ctx, ZMQ_DEALER);
+    assert (sc);
+    rc = zmq_connect (sc, "ipc://@tmp-tester");
+    assert (rc == 0);
+    
+    bounce (sb, sc);
+
+    rc = zmq_close (sc);
+    assert (rc == 0);
+
+    rc = zmq_close (sb);
+    assert (rc == 0);
+
+    rc = zmq_ctx_term (ctx);
+    assert (rc == 0);
+
+    return 0 ;
+}

data/vendor/github.com/zeromq/libzmq/tests/test_ancillaries.cpp

@@ -0,0 +1,51 @@
+/*
+    Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
+
+    This file is part of libzmq, the ZeroMQ core engine in C++.
+
+    libzmq is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License (LGPL) as published
+    by the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    As a special exception, the Contributors give you permission to link
+    this library with independent modules to produce an executable,
+    regardless of the license terms of these independent modules, and to
+    copy and distribute the resulting executable under terms of your choice,
+    provided that you also meet, for each linked independent module, the
+    terms and conditions of the license of that module. An independent
+    module is a module which is not derived from or based on this library.
+    If you modify this library, you must extend this exception to your
+    version of the library.
+
+    libzmq is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+    License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*
+ * File for adding tests for ancillary API methods and other miscellaenous
+ * API internals. Please ensure that when adding such tests into this file,
+ * that they are short-lived so they do not trigger timeouts in the
+ * CI build environments.
+ */
+
+#include "testutil.hpp"
+
+int main (void)
+{
+    int major, minor, patch;
+
+    zmq_version (&major, &minor, &patch);
+    assert (major == ZMQ_VERSION_MAJOR &&
+            minor == ZMQ_VERSION_MINOR &&
+            patch == ZMQ_VERSION_PATCH);
+
+    assert (zmq_strerror (EINVAL));
+
+    return 0;
+}

data/vendor/github.com/zeromq/libzmq/tests/test_atomics.cpp

@@ -0,0 +1,48 @@
+/*
+    Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
+
+    This file is part of libzmq, the ZeroMQ core engine in C++.
+
+    libzmq is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License (LGPL) as published
+    by the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    As a special exception, the Contributors give you permission to link
+    this library with independent modules to produce an executable,
+    regardless of the license terms of these independent modules, and to
+    copy and distribute the resulting executable under terms of your choice,
+    provided that you also meet, for each linked independent module, the
+    terms and conditions of the license of that module. An independent
+    module is a module which is not derived from or based on this library.
+    If you modify this library, you must extend this exception to your
+    version of the library.
+
+    libzmq is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+    License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "testutil.hpp"
+
+int main (void)
+{
+    void *counter = zmq_atomic_counter_new ();
+    assert (zmq_atomic_counter_value (counter) == 0);
+    assert (zmq_atomic_counter_inc (counter) == 0);
+    assert (zmq_atomic_counter_inc (counter) == 1);
+    assert (zmq_atomic_counter_inc (counter) == 2);
+    assert (zmq_atomic_counter_value (counter) == 3);
+    assert (zmq_atomic_counter_dec (counter) == 1);
+    assert (zmq_atomic_counter_dec (counter) == 1);
+    assert (zmq_atomic_counter_dec (counter) == 0);
+    zmq_atomic_counter_set (counter, 2);
+    assert (zmq_atomic_counter_dec (counter) == 1);
+    assert (zmq_atomic_counter_dec (counter) == 0);
+    zmq_atomic_counter_destroy (&counter);
+    return 0;
+}

data/vendor/github.com/zeromq/libzmq/tests/test_base85.cpp

@@ -0,0 +1,162 @@
+/*
+    Copyright (c) 2016 Contributors as noted in the AUTHORS file
+
+    This file is part of libzmq, the ZeroMQ core engine in C++.
+
+    libzmq is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License (LGPL) as published
+    by the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    As a special exception, the Contributors give you permission to link
+    this library with independent modules to produce an executable,
+    regardless of the license terms of these independent modules, and to
+    copy and distribute the resulting executable under terms of your choice,
+    provided that you also meet, for each linked independent module, the
+    terms and conditions of the license of that module. An independent
+    module is a module which is not derived from or based on this library.
+    If you modify this library, you must extend this exception to your
+    version of the library.
+
+    libzmq is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+    License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "testutil.hpp"
+
+// Test vector: rfc.zeromq.org/spec:32/Z85
+void test__zmq_z85_encode__valid__success ()
+{
+    static const size_t size = 8;
+    static const size_t length = size * 5 / 4;
+    static const uint8_t decoded[size] = {
+        0x86, 0x4F, 0xD2, 0x6F, 0xB5, 0x59, 0xF7, 0x5B
+    };
+    static const char expected[length + 1] = "HelloWorld";
+    char out_encoded[length + 1] = { 0 };
+
+    errno = 0;
+    assert (zmq_z85_encode(out_encoded, decoded, size) != NULL);
+    assert (streq (out_encoded, expected));
+    assert (zmq_errno () == 0);
+}
+
+// Buffer length must be evenly divisible by 4 or must fail with EINVAL.
+void test__zmq_z85_encode__invalid__failure (size_t size)
+{
+    errno = 0;
+    assert (zmq_z85_encode(NULL, NULL, size) == NULL);
+    assert (zmq_errno () == EINVAL);
+}
+
+// Test vector: rfc.zeromq.org/spec:32/Z85
+void test__zmq_z85_decode__valid__success ()
+{
+    static const size_t size = 10 * 4 / 5;
+    static const uint8_t expected[size] = {
+        0x86, 0x4F, 0xD2, 0x6F, 0xB5, 0x59, 0xF7, 0x5B
+    };
+    static const char* encoded = "HelloWorld";
+    uint8_t out_decoded[size] = { 0 };
+
+    errno = 0;
+    assert (zmq_z85_decode(out_decoded, encoded) != NULL);
+    assert (zmq_errno () == 0);
+    assert (memcmp (out_decoded, expected, size) == 0);
+}
+
+// Invalid input data must fail with EINVAL.
+template<size_t SIZE>
+void test__zmq_z85_decode__invalid__failure (const char (&encoded)[SIZE])
+{
+    uint8_t decoded[SIZE * 4 / 5 + 1];
+    errno = 0;
+    assert (zmq_z85_decode(decoded, encoded) == NULL);
+    assert (zmq_errno () == EINVAL);
+}
+
+
+// call zmq_z85_encode, then zmq_z85_decode, and compare the results with the original
+template<size_t SIZE>
+void test__zmq_z85_encode__zmq_z85_decode__roundtrip(const uint8_t (&test_data)[SIZE])
+{
+    char test_data_z85[SIZE * 5 / 4 + 1];
+    char *res1 = zmq_z85_encode(test_data_z85, test_data, SIZE);
+    assert(res1 != NULL);
+
+    uint8_t test_data_decoded[SIZE];
+    uint8_t *res2 = zmq_z85_decode(test_data_decoded, test_data_z85);
+    assert(res2 != NULL);
+
+    int res3 = memcmp(test_data, test_data_decoded, SIZE);
+    assert(res3 == 0);
+}
+
+// call zmq_z85_encode, then zmq_z85_decode, and compare the results with the original
+template<size_t SIZE>
+void test__zmq_z85_decode__zmq_z85_encode__roundtrip(const char (&test_data)[SIZE])
+{
+    const size_t decoded_size = (SIZE - 1) * 4 / 5;
+    uint8_t test_data_decoded[decoded_size];
+    uint8_t *res1 = zmq_z85_decode(test_data_decoded, test_data);
+    assert(res1 != NULL);
+
+    char test_data_z85[SIZE];
+    char *res2 = zmq_z85_encode(test_data_z85, test_data_decoded, decoded_size);
+    assert(res2 != NULL);
+
+    int res3 = memcmp(test_data, test_data_z85, SIZE);
+    assert(res3 == 0);
+}
+
+
+int main (void)
+{
+    test__zmq_z85_encode__valid__success ();
+    test__zmq_z85_encode__invalid__failure (1);
+    test__zmq_z85_encode__invalid__failure (42);
+
+    test__zmq_z85_decode__valid__success ();
+    // String length must be evenly divisible by 5 or must fail with EINVAL.
+    test__zmq_z85_decode__invalid__failure ("01234567");
+    test__zmq_z85_decode__invalid__failure ("0");
+
+    // decode invalid data with the maximum representable value
+    test__zmq_z85_decode__invalid__failure ("#####");
+
+    // decode invalid data with the minimum value beyond the limit
+    // "%nSc0" is 0xffffffff
+    test__zmq_z85_decode__invalid__failure ("%nSc1");
+
+    // decode invalid data with an invalid character in the range of valid
+    // characters
+    test__zmq_z85_decode__invalid__failure ("####\0047");
+
+    // decode invalid data with an invalid character just below the range of valid
+    // characters
+    test__zmq_z85_decode__invalid__failure ("####\0200");
+
+    // decode invalid data with an invalid character just above the range of valid
+    // characters
+    test__zmq_z85_decode__invalid__failure ("####\0037");
+
+    // round-trip encoding and decoding with minimum value
+    {
+      const uint8_t test_data[] = {0x00, 0x00, 0x00, 0x00};
+      test__zmq_z85_encode__zmq_z85_decode__roundtrip(test_data);
+    }
+    // round-trip encoding and decoding with maximum value
+    {
+      const uint8_t test_data[] = {0xff, 0xff, 0xff, 0xff};
+      test__zmq_z85_encode__zmq_z85_decode__roundtrip(test_data);
+    }
+
+    test__zmq_z85_decode__zmq_z85_encode__roundtrip("r^/rM9M=rMToK)63O8dCvd9D<PY<7iGlC+{BiSnG");
+
+    return 0;
+}