couchbase 3.4.1 → 3.4.2

data/ext/couchbase/test/test_unit_config_profiles.cxx

@@ -52,14 +52,17 @@ TEST_CASE("unit: can apply wan_development profile", "[unit]")
     // for details and latest info on expectations.
     couchbase::core::cluster_options opts{};
     opts.apply_profile("wan_development");
-    CHECK(opts.key_value_timeout.count() == 20000);
-    CHECK(opts.key_value_durable_timeout.count() == 20000);
-    CHECK(opts.connect_timeout.count() == 20000);
-    CHECK(opts.view_timeout.count() == 120000);
-    CHECK(opts.query_timeout.count() == 120000);
-    CHECK(opts.analytics_timeout.count() == 120000);
-    CHECK(opts.search_timeout.count() == 120000);
-    CHECK(opts.management_timeout.count() == 120000);
+    CHECK(opts.key_value_timeout.count() == 20'000);
+    CHECK(opts.key_value_durable_timeout.count() == 20'000);
+    CHECK(opts.connect_timeout.count() == 20'000);
+    CHECK(opts.view_timeout.count() == 120'000);
+    CHECK(opts.query_timeout.count() == 120'000);
+    CHECK(opts.analytics_timeout.count() == 120'000);
+    CHECK(opts.search_timeout.count() == 120'000);
+    CHECK(opts.management_timeout.count() == 120'000);
+    CHECK(opts.bootstrap_timeout.count() == 120'000);
+    CHECK(opts.resolve_timeout.count() == 20'000);
+    CHECK(opts.dns_config.timeout().count() == 20'000);
 }
 
 TEST_CASE("unit: all other options remain unchanged", "[unit]")
@@ -71,11 +74,9 @@ TEST_CASE("unit: all other options remain unchanged", "[unit]")
     // we'd expect default_opts to be equal to opts:
     CHECK(opts.tracer == default_opts.tracer);
     CHECK(opts.meter == default_opts.meter);
-    CHECK(opts.bootstrap_timeout == default_opts.bootstrap_timeout);
     CHECK(opts.config_idle_redial_timeout == default_opts.config_idle_redial_timeout);
     CHECK(opts.config_poll_floor == default_opts.config_poll_floor);
     CHECK(opts.config_poll_interval == default_opts.config_poll_interval);
-    CHECK(opts.dns_srv_timeout == default_opts.dns_srv_timeout);
     CHECK(opts.enable_clustermap_notification == opts.enable_clustermap_notification);
     CHECK(opts.enable_compression == default_opts.enable_compression);
     CHECK(opts.enable_dns_srv == default_opts.enable_dns_srv);
@@ -88,7 +89,6 @@ TEST_CASE("unit: all other options remain unchanged", "[unit]")
     CHECK(opts.idle_http_connection_timeout == default_opts.idle_http_connection_timeout);
     CHECK(opts.max_http_connections == default_opts.max_http_connections);
     CHECK(opts.network == default_opts.network);
-    CHECK(opts.resolve_timeout == default_opts.resolve_timeout);
     CHECK(opts.show_queries == default_opts.show_queries);
     CHECK(opts.tcp_keep_alive_interval == default_opts.tcp_keep_alive_interval);
     CHECK(opts.tls_verify == default_opts.tls_verify);
@@ -129,4 +129,4 @@ TEST_CASE("unit: can have profile with constructor args", "[unit]")
                                                                                std::string("something_extra"));
     opts.apply_profile("test_with_args");
     CHECK(opts.user_agent_extra == "something_extra");
-}
+}

data/ext/couchbase/test/test_unit_connection_string.cxx

@@ -52,6 +52,8 @@ TEST_CASE("unit: connection string", "[unit]")
         CHECK(couchbase::core::utils::parse_connection_string("http://127.0.0.1").scheme == "http");
         CHECK(couchbase::core::utils::parse_connection_string("couchbase://").scheme == "couchbase");
         CHECK(couchbase::core::utils::parse_connection_string("my+scheme://").scheme == "my+scheme");
+        CHECK(couchbase::core::utils::parse_connection_string("127.0.0.1").scheme == "couchbase");
+        CHECK(couchbase::core::utils::parse_connection_string("127.0.0.1:8091").scheme == "couchbase");
 
         SECTION("default bootstrap mode")
         {
@@ -155,6 +157,13 @@ TEST_CASE("unit: connection string", "[unit]")
                       couchbase::core::utils::connection_string::address_type::dns,
                       couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
                   });
+            CHECK(couchbase::core::utils::parse_connection_string("1.2.3.4").bootstrap_nodes ==
+                  std::vector<couchbase::core::utils::connection_string::node>{
+                    { "1.2.3.4",
+                      0,
+                      couchbase::core::utils::connection_string::address_type::ipv4,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                  });
         }
 
         SECTION("multiple nodes")
@@ -207,6 +216,17 @@ TEST_CASE("unit: connection string", "[unit]")
                       couchbase::core::utils::connection_string::address_type::ipv4,
                       couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
                   });
+            CHECK(couchbase::core::utils::parse_connection_string("1.2.3.4,4.3.2.1").bootstrap_nodes ==
+                  std::vector<couchbase::core::utils::connection_string::node>{
+                    { "1.2.3.4",
+                      0,
+                      couchbase::core::utils::connection_string::address_type::ipv4,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                    { "4.3.2.1",
+                      0,
+                      couchbase::core::utils::connection_string::address_type::ipv4,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                  });
         }
 
         SECTION("custom ports")
@@ -259,6 +279,21 @@ TEST_CASE("unit: connection string", "[unit]")
                       couchbase::core::utils::connection_string::address_type::ipv4,
                       couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
                   });
+            CHECK(couchbase::core::utils::parse_connection_string("example.com:123,[::1]:456;127.0.0.1:789").bootstrap_nodes ==
+                  std::vector<couchbase::core::utils::connection_string::node>{
+                    { "example.com",
+                      123,
+                      couchbase::core::utils::connection_string::address_type::dns,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                    { "::1",
+                      456,
+                      couchbase::core::utils::connection_string::address_type::ipv6,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                    { "127.0.0.1",
+                      789,
+                      couchbase::core::utils::connection_string::address_type::ipv4,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                  });
         }
 
         SECTION("custom bootstrap mode")

data/ext/couchbase/third_party/snappy/CMakeLists.txt

@@ -27,7 +27,7 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 cmake_minimum_required(VERSION 3.1)
-project(Snappy VERSION 1.1.8 LANGUAGES C CXX)
+project(Snappy VERSION 1.1.10 LANGUAGES C CXX)
 
 # C++ standard can be overridden when this is used as a sub-project.
 if(NOT CMAKE_CXX_STANDARD)
@@ -37,12 +37,59 @@ if(NOT CMAKE_CXX_STANDARD)
   set(CMAKE_CXX_EXTENSIONS OFF)
 endif(NOT CMAKE_CXX_STANDARD)
 
+# https://github.com/izenecloud/cmake/blob/master/SetCompilerWarningAll.cmake
+if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+  # Use the highest warning level for Visual Studio.
+  set(CMAKE_CXX_WARNING_LEVEL 4)
+  if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+    string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+  else(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
+  endif(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+
+  # Disable C++ exceptions.
+  string(REGEX REPLACE "/EH[a-z]+" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHs-c-")
+  add_definitions(-D_HAS_EXCEPTIONS=0)
+
+  # Disable RTTI.
+  string(REGEX REPLACE "/GR" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GR-")
+else(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+  # Use -Wall for clang and gcc.
+  if(NOT CMAKE_CXX_FLAGS MATCHES "-Wall")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+  endif(NOT CMAKE_CXX_FLAGS MATCHES "-Wall")
+
+  # Use -Wextra for clang and gcc.
+  if(NOT CMAKE_CXX_FLAGS MATCHES "-Wextra")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra")
+  endif(NOT CMAKE_CXX_FLAGS MATCHES "-Wextra")
+
+  # Use -Werror for clang only.
+  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    if(NOT CMAKE_CXX_FLAGS MATCHES "-Werror")
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+    endif(NOT CMAKE_CXX_FLAGS MATCHES "-Werror")
+  endif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+
+  # Disable C++ exceptions.
+  string(REGEX REPLACE "-fexceptions" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
+
+  # Disable RTTI.
+  string(REGEX REPLACE "-frtti" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
+endif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+
 # BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to make
 # it prominent in the GUI.
 option(BUILD_SHARED_LIBS "Build shared libraries(DLLs)." OFF)
 
 option(SNAPPY_BUILD_TESTS "Build Snappy's own tests." ON)
 
+option(SNAPPY_BUILD_BENCHMARKS "Build Snappy's benchmarks" ON)
+
 option(SNAPPY_FUZZING_BUILD "Build Snappy for fuzzing." OFF)
 
 option(SNAPPY_REQUIRE_AVX "Target processors with AVX support." OFF)
@@ -55,8 +102,6 @@ include(TestBigEndian)
 test_big_endian(SNAPPY_IS_BIG_ENDIAN)
 
 include(CheckIncludeFile)
-check_include_file("byteswap.h" HAVE_BYTESWAP_H)
-check_include_file("sys/endian.h" HAVE_SYS_ENDIAN_H)
 check_include_file("sys/mman.h" HAVE_SYS_MMAN_H)
 check_include_file("sys/resource.h" HAVE_SYS_RESOURCE_H)
 check_include_file("sys/time.h" HAVE_SYS_TIME_H)
@@ -67,6 +112,7 @@ check_include_file("windows.h" HAVE_WINDOWS_H)
 include(CheckLibraryExists)
 check_library_exists(z zlibVersion "" HAVE_LIBZ)
 check_library_exists(lzo2 lzo1x_1_15_compress "" HAVE_LIBLZO2)
+check_library_exists(lz4 LZ4_compress_default "" HAVE_LIBLZ4)
 
 include(CheckCXXCompilerFlag)
 CHECK_CXX_COMPILER_FLAG("/arch:AVX" HAVE_VISUAL_STUDIO_ARCH_AVX)
@@ -92,6 +138,10 @@ elseif (SNAPPY_REQUIRE_AVX)
   endif(HAVE_CLANG_MAVX)
 endif(SNAPPY_REQUIRE_AVX2)
 
+# Used by googletest.
+check_cxx_compiler_flag(-Wno-missing-field-initializers
+                        SNAPPY_HAVE_NO_MISSING_FIELD_INITIALIZERS)
+
 include(CheckCXXSourceCompiles)
 check_cxx_source_compiles("
 int main() {
@@ -103,6 +153,13 @@ int main() {
   return __builtin_ctzll(0);
 }" HAVE_BUILTIN_CTZ)
 
+check_cxx_source_compiles("
+__attribute__((always_inline)) int zero() { return 0; }
+
+int main() {
+  return zero();
+}" HAVE_ATTRIBUTE_ALWAYS_INLINE)
+
 check_cxx_source_compiles("
 #include <tmmintrin.h>
 
@@ -115,26 +172,38 @@ int main() {
   return 0;
 }" SNAPPY_HAVE_SSSE3)
 
+check_cxx_source_compiles("
+#include <immintrin.h>
+int main() {
+  return _mm_crc32_u32(0, 1);
+}" SNAPPY_HAVE_X86_CRC32)
+
+check_cxx_source_compiles("
+#include <arm_neon.h>
+#include <arm_acle.h>
+int main() {
+  return __crc32cw(0, 1);
+}" SNAPPY_HAVE_NEON_CRC32)
+
 check_cxx_source_compiles("
 #include <immintrin.h>
 int main() {
   return _bzhi_u32(0, 1);
 }" SNAPPY_HAVE_BMI2)
 
+check_cxx_source_compiles("
+#include <arm_neon.h>
+int main() {
+  uint8_t val = 3, dup[8];
+  uint8x16_t v = vld1q_dup_u8(&val);
+  vst1q_u8(dup, v);
+  return 0;
+}" SNAPPY_HAVE_NEON)
+
 include(CheckSymbolExists)
 check_symbol_exists("mmap" "sys/mman.h" HAVE_FUNC_MMAP)
 check_symbol_exists("sysconf" "unistd.h" HAVE_FUNC_SYSCONF)
 
-find_package(GTest QUIET)
-if(GTEST_FOUND)
-  set(HAVE_GTEST 1)
-endif(GTEST_FOUND)
-
-find_package(Gflags QUIET)
-if(GFLAGS_FOUND)
-  set(HAVE_GFLAGS 1)
-endif(GFLAGS_FOUND)
-
 configure_file(
   "cmake/config.h.in"
   "${PROJECT_BINARY_DIR}/config.h"
@@ -202,38 +271,92 @@ if(BUILD_SHARED_LIBS)
   set_target_properties(snappy PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
 endif(BUILD_SHARED_LIBS)
 
-if(SNAPPY_BUILD_TESTS)
-  enable_testing()
-
-  add_executable(snappy_unittest "")
-  target_sources(snappy_unittest
+if(SNAPPY_BUILD_TESTS OR SNAPPY_BUILD_BENCHMARKS)
+  add_library(snappy_test_support "")
+  target_sources(snappy_test_support
     PRIVATE
-      "snappy_unittest.cc"
       "snappy-test.cc"
+      "snappy-test.h"
+      "snappy_test_data.cc"
+      "snappy_test_data.h"
+      "${PROJECT_BINARY_DIR}/config.h"
   )
-  target_compile_definitions(snappy_unittest PRIVATE -DHAVE_CONFIG_H)
-  target_link_libraries(snappy_unittest snappy ${GFLAGS_LIBRARIES})
+
+  # Test files include snappy-test.h, HAVE_CONFIG_H must be defined.
+  target_compile_definitions(snappy_test_support PUBLIC -DHAVE_CONFIG_H)
+
+  target_link_libraries(snappy_test_support snappy)
 
   if(HAVE_LIBZ)
-    target_link_libraries(snappy_unittest z)
+    target_link_libraries(snappy_test_support z)
   endif(HAVE_LIBZ)
   if(HAVE_LIBLZO2)
-    target_link_libraries(snappy_unittest lzo2)
+    target_link_libraries(snappy_test_support lzo2)
   endif(HAVE_LIBLZO2)
+  if(HAVE_LIBLZ4)
+    target_link_libraries(snappy_test_support lz4)
+  endif(HAVE_LIBLZ4)
 
-  target_include_directories(snappy_unittest
-    BEFORE PRIVATE
+  target_include_directories(snappy_test_support
+    BEFORE PUBLIC
       "${PROJECT_SOURCE_DIR}"
-      "${GTEST_INCLUDE_DIRS}"
-      "${GFLAGS_INCLUDE_DIRS}"
   )
+endif(SNAPPY_BUILD_TESTS OR SNAPPY_BUILD_BENCHMARKS)
+
+if(SNAPPY_BUILD_TESTS)
+  enable_testing()
+
+  # Prevent overriding the parent project's compiler/linker settings on Windows.
+  set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+  set(install_gtest OFF)
+  set(install_gmock OFF)
+  set(build_gmock ON)
+
+  # This project is tested using GoogleTest.
+  add_subdirectory("third_party/googletest")
+
+  # GoogleTest triggers a missing field initializers warning.
+  if(SNAPPY_HAVE_NO_MISSING_FIELD_INITIALIZERS)
+    set_property(TARGET gtest
+        APPEND PROPERTY COMPILE_OPTIONS -Wno-missing-field-initializers)
+    set_property(TARGET gmock
+        APPEND PROPERTY COMPILE_OPTIONS -Wno-missing-field-initializers)
+  endif(SNAPPY_HAVE_NO_MISSING_FIELD_INITIALIZERS)
+
+  add_executable(snappy_unittest "")
+  target_sources(snappy_unittest
+    PRIVATE
+      "snappy_unittest.cc"
+  )
+  target_link_libraries(snappy_unittest snappy_test_support gmock_main gtest)
 
   add_test(
     NAME snappy_unittest
     WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
     COMMAND "${PROJECT_BINARY_DIR}/snappy_unittest")
+
+  add_executable(snappy_test_tool "")
+  target_sources(snappy_test_tool
+    PRIVATE
+      "snappy_test_tool.cc"
+  )
+  target_link_libraries(snappy_test_tool snappy_test_support)
 endif(SNAPPY_BUILD_TESTS)
 
+if(SNAPPY_BUILD_BENCHMARKS)
+  add_executable(snappy_benchmark "")
+  target_sources(snappy_benchmark
+    PRIVATE
+      "snappy_benchmark.cc"
+  )
+  target_link_libraries(snappy_benchmark snappy_test_support benchmark_main)
+
+  # This project uses Google benchmark for benchmarking.
+  set(BENCHMARK_ENABLE_TESTING OFF CACHE BOOL "" FORCE)
+  set(BENCHMARK_ENABLE_EXCEPTIONS OFF CACHE BOOL "" FORCE)
+  add_subdirectory("third_party/benchmark")
+endif(SNAPPY_BUILD_BENCHMARKS)
+
 if(SNAPPY_FUZZING_BUILD)
   add_executable(snappy_compress_fuzzer "")
   target_sources(snappy_compress_fuzzer

data/ext/couchbase/third_party/snappy/cmake/config.h.in

@@ -1,62 +1,66 @@
 #ifndef THIRD_PARTY_SNAPPY_OPENSOURCE_CMAKE_CONFIG_H_
 #define THIRD_PARTY_SNAPPY_OPENSOURCE_CMAKE_CONFIG_H_
 
+/* Define to 1 if the compiler supports __attribute__((always_inline)). */
+#cmakedefine01 HAVE_ATTRIBUTE_ALWAYS_INLINE
+
 /* Define to 1 if the compiler supports __builtin_ctz and friends. */
-#cmakedefine HAVE_BUILTIN_CTZ 1
+#cmakedefine01 HAVE_BUILTIN_CTZ
 
 /* Define to 1 if the compiler supports __builtin_expect. */
-#cmakedefine HAVE_BUILTIN_EXPECT 1
-
-/* Define to 1 if you have the <byteswap.h> header file. */
-#cmakedefine HAVE_BYTESWAP_H 1
+#cmakedefine01 HAVE_BUILTIN_EXPECT
 
 /* Define to 1 if you have a definition for mmap() in <sys/mman.h>. */
-#cmakedefine HAVE_FUNC_MMAP 1
+#cmakedefine01 HAVE_FUNC_MMAP
 
 /* Define to 1 if you have a definition for sysconf() in <unistd.h>. */
-#cmakedefine HAVE_FUNC_SYSCONF 1
-
-/* Define to 1 to use the gflags package for command-line parsing. */
-#cmakedefine HAVE_GFLAGS 1
-
-/* Define to 1 if you have Google Test. */
-#cmakedefine HAVE_GTEST 1
+#cmakedefine01 HAVE_FUNC_SYSCONF
 
 /* Define to 1 if you have the `lzo2' library (-llzo2). */
-#cmakedefine HAVE_LIBLZO2 1
+#cmakedefine01 HAVE_LIBLZO2
 
 /* Define to 1 if you have the `z' library (-lz). */
-#cmakedefine HAVE_LIBZ 1
+#cmakedefine01 HAVE_LIBZ
 
-/* Define to 1 if you have the <sys/endian.h> header file. */
-#cmakedefine HAVE_SYS_ENDIAN_H 1
+/* Define to 1 if you have the `lz4' library (-llz4). */
+#cmakedefine01 HAVE_LIBLZ4
 
 /* Define to 1 if you have the <sys/mman.h> header file. */
-#cmakedefine HAVE_SYS_MMAN_H 1
+#cmakedefine01 HAVE_SYS_MMAN_H
 
 /* Define to 1 if you have the <sys/resource.h> header file. */
-#cmakedefine HAVE_SYS_RESOURCE_H 1
+#cmakedefine01 HAVE_SYS_RESOURCE_H
 
 /* Define to 1 if you have the <sys/time.h> header file. */
-#cmakedefine HAVE_SYS_TIME_H 1
+#cmakedefine01 HAVE_SYS_TIME_H
 
 /* Define to 1 if you have the <sys/uio.h> header file. */
-#cmakedefine HAVE_SYS_UIO_H 1
+#cmakedefine01 HAVE_SYS_UIO_H
 
 /* Define to 1 if you have the <unistd.h> header file. */
-#cmakedefine HAVE_UNISTD_H 1
+#cmakedefine01 HAVE_UNISTD_H
 
 /* Define to 1 if you have the <windows.h> header file. */
-#cmakedefine HAVE_WINDOWS_H 1
+#cmakedefine01 HAVE_WINDOWS_H
 
 /* Define to 1 if you target processors with SSSE3+ and have <tmmintrin.h>. */
 #cmakedefine01 SNAPPY_HAVE_SSSE3
 
+/* Define to 1 if you target processors with SSE4.2 and have <crc32intrin.h>. */
+#cmakedefine01 SNAPPY_HAVE_X86_CRC32
+
 /* Define to 1 if you target processors with BMI2+ and have <bmi2intrin.h>. */
 #cmakedefine01 SNAPPY_HAVE_BMI2
 
+/* Define to 1 if you target processors with NEON and have <arm_neon.h>. */
+#cmakedefine01 SNAPPY_HAVE_NEON
+
+/* Define to 1 if you have <arm_neon.h> and <arm_acle.h> and want to optimize
+   compression speed by using __crc32cw from <arm_acle.h>. */
+#cmakedefine01 SNAPPY_HAVE_NEON_CRC32
+
 /* Define to 1 if your processor stores words with the most significant byte
    first (like Motorola and SPARC, unlike Intel and VAX). */
-#cmakedefine SNAPPY_IS_BIG_ENDIAN 1
+#cmakedefine01 SNAPPY_IS_BIG_ENDIAN
 
 #endif  // THIRD_PARTY_SNAPPY_OPENSOURCE_CMAKE_CONFIG_H_