datasketches 0.5.2 → 0.5.3

data/vendor/datasketches-cpp/common/include/fdlibm_log.hpp

@@ -0,0 +1,101 @@
+// fdlibm __ieee754_log, used by Java's StrictMath.log (and by Math.log on most JVMs).
+// Derived from FDLIBM 5.3, Copyright (C) 1993 by Sun Microsystems, Inc.
+// "Permission to use, copy, modify, and distribute this software is freely granted,
+//  provided that this notice is preserved."
+#ifndef FDLIBM_LOG_HPP
+#define FDLIBM_LOG_HPP
+#include <cstdint>
+#include <cstring>
+#include <limits>
+
+namespace fdlibm {
+
+inline int32_t hi_word(double x){ uint64_t u; std::memcpy(&u,&x,8); return (int32_t)(uint32_t)(u>>32); }
+inline uint32_t lo_word(double x){ uint64_t u; std::memcpy(&u,&x,8); return (uint32_t)u; }
+inline void set_hi_word(double& x, uint32_t hi){ uint64_t u; std::memcpy(&u,&x,8);
+  u = (u & 0x00000000ffffffffULL) | ((uint64_t)hi<<32); std::memcpy(&x,&u,8); }
+
+// Forces a value to be rounded to a double before it is used again. fdlibm needs strict
+// IEEE-754 evaluation: a fused multiply-add anywhere in the polynomial below changes the
+// result. Pragmas are overridden by an explicit -ffp-contract=fast, so use a volatile
+// round-trip, which the standard requires the compiler to honour.
+inline double rnd(double v) { volatile double t = v; return t; }
+
+inline double log(double x) {
+// fdlibm depends on strict IEEE-754 evaluation: a fused multiply-add would change the result
+// of the polynomial evaluation below, so contraction must be off for this function.
+#if defined(__clang__)
+#pragma clang fp contract(off)
+#endif
+  static const double
+    ln2_hi = 6.93147180369123816490e-01,  /* 3fe62e42 fee00000 */
+    ln2_lo = 1.90821492927058770002e-10,  /* 3dea39ef 35793c76 */
+    two54  = 1.80143985094819840000e+16,  /* 43500000 00000000 */
+    Lg1 = 6.666666666666735130e-01,       /* 3FE55555 55555593 */
+    Lg2 = 3.999999999940941908e-01,       /* 3FD99999 9997FA04 */
+    Lg3 = 2.857142874366239149e-01,       /* 3FD24924 94229359 */
+    Lg4 = 2.222219843214978396e-01,       /* 3FCC71C5 1D8E78AF */
+    Lg5 = 1.818357216161805012e-01,       /* 3FC74664 96CB03DE */
+    Lg6 = 1.531383769920937332e-01,       /* 3FC39A09 D078C69F */
+    Lg7 = 1.479819860511658591e-01,       /* 3FC2F112 DF3E5244 */
+    zero = 0.0;
+
+  double hfsq,f,s,z,R,w,t1,t2,dk;
+  int32_t k,hx,i,j;
+  uint32_t lx;
+
+  hx = hi_word(x);
+  lx = lo_word(x);
+
+  k = 0;
+  if (hx < 0x00100000) {                       /* x < 2**-1022 */
+    // fdlibm writes these as -two54/zero and (x-x)/zero, which also raise the divide-by-zero
+    // and invalid flags. MSVC rejects a compile-time division by a zero constant (C2124), so
+    // return the same values directly. The estimators never call log() with these inputs.
+    if (((hx & 0x7fffffff) | lx) == 0) {                          /* log(+-0) = -inf */
+      return -std::numeric_limits<double>::infinity();
+    }
+    if (hx < 0) {                                                 /* log(-#) = NaN */
+      return std::numeric_limits<double>::quiet_NaN();
+    }
+    k -= 54; x *= two54;                       /* subnormal: scale up */
+    hx = hi_word(x);
+  }
+  if (hx >= 0x7ff00000) { return x+x; }
+  k += (hx>>20) - 1023;
+  hx &= 0x000fffff;
+  i = (hx + 0x95f64) & 0x100000;
+  set_hi_word(x, (uint32_t)(hx | (i ^ 0x3ff00000)));   /* normalize x or x/2 */
+  k += (i>>20);
+  f = x - 1.0;
+  if ((0x000fffff & (2+hx)) < 3) {             /* |f| < 2**-20 */
+    if (f == zero) {
+      if (k == 0) { return zero; }
+      dk = (double)k; return rnd(dk*ln2_hi) + rnd(dk*ln2_lo);
+    }
+    R = rnd(rnd(f*f)*rnd(0.5 - rnd(0.33333333333333333*f)));
+    if (k == 0) { return f-R; }
+    dk = (double)k; return rnd(dk*ln2_hi) - (rnd(R - rnd(dk*ln2_lo)) - f);
+  }
+  s = f/(2.0+f);
+  dk = (double)k;
+  z = s*s;
+  i = hx - 0x6147a;
+  w = z*z;
+  j = 0x6b851 - hx;
+  t1 = rnd(w*rnd(Lg2 + rnd(w*rnd(Lg4 + rnd(w*Lg6)))));
+  t2 = rnd(z*rnd(Lg1 + rnd(w*rnd(Lg3 + rnd(w*rnd(Lg5 + rnd(w*Lg7)))))));
+  i |= j;
+  R = t2 + t1;
+  if (i > 0) {
+    hfsq = rnd(0.5*f)*f;
+    if (k == 0) { return f - rnd(hfsq - rnd(s*(hfsq+R))); }
+    return rnd(dk*ln2_hi) - (rnd(hfsq - rnd(rnd(s*(hfsq+R)) + rnd(dk*ln2_lo))) - f);
+  } else {
+    if (k == 0) { return f - rnd(s*(f-R)); }
+    return rnd(dk*ln2_hi) - (rnd(rnd(s*(f-R)) - rnd(dk*ln2_lo)) - f);
+  }
+}
+
+} // namespace fdlibm
+#endif

data/vendor/datasketches-cpp/common/include/serde.hpp

@@ -20,6 +20,7 @@
 #ifndef DATASKETCHES_SERDE_HPP_
 #define DATASKETCHES_SERDE_HPP_
 
+#include <cstdint>
 #include <cstring>
 #include <iostream>
 #include <memory>
@@ -132,6 +133,11 @@ struct serde<T, typename std::enable_if<std::is_arithmetic<T>::value>::type> {
 /// ItemsSketch<String> with ArrayOfStringsSerDe in Java.
 /// The length of each string is stored as a 32-bit integer (historically),
 /// which may be too wasteful. Treat this as an example.
+///
+/// This implementation treats std::string as an arbitrary byte container.
+/// It does not check whether string contents are valid UTF-8.
+///
+/// Use a UTF-8-validating SerDe when cross-language portability is required.
 template<>
 struct serde<std::string> {
   /// @copydoc serde::serialize

data/vendor/datasketches-cpp/common/test/CMakeLists.txt

@@ -69,15 +69,21 @@ target_sources(common_test
   PRIVATE
     quantiles_sorted_view_test.cpp
     optional_test.cpp
+    binomial_bounds_test.cpp
 )
 
 # now the integration test part
 add_executable(integration_test)
 
-target_link_libraries(integration_test count cpc density fi hll kll req sampling theta tuple common_test_lib)
+target_link_libraries(integration_test count cpc density fi hll kll req sampling theta tuple quantiles common_test_lib)
 
+# Use CMAKE_CXX_STANDARD if defined, otherwise C++11
+set(_integration_cxx_standard 11)
+if(DEFINED CMAKE_CXX_STANDARD)
+  set(_integration_cxx_standard ${CMAKE_CXX_STANDARD})
+endif()
 set_target_properties(integration_test PROPERTIES
-  CXX_STANDARD 11
+  CXX_STANDARD ${_integration_cxx_standard}
   CXX_STANDARD_REQUIRED YES
 )
 
@@ -90,3 +96,39 @@ target_sources(integration_test
   PRIVATE
     integration_test.cpp
 )
+
+# Separate hardening test executable (header-only, no pre-compiled libs)
+# This ensures the sketch code is compiled with C++17 + hardening
+# Always build this target - it will use CMAKE_CXX_STANDARD if set (and >= 17), otherwise C++17
+
+add_executable(hardening_test)
+target_link_libraries(hardening_test common common_test_lib)
+
+# Include directories for header-only sketch implementations
+target_include_directories(hardening_test PRIVATE
+  ${CMAKE_SOURCE_DIR}/quantiles/include
+  ${CMAKE_SOURCE_DIR}/kll/include
+  ${CMAKE_SOURCE_DIR}/req/include
+  ${CMAKE_SOURCE_DIR}/common/include
+)
+
+# Use C++17 minimum for hardening tests
+set(_hardening_cxx_standard 17)
+if(DEFINED CMAKE_CXX_STANDARD AND CMAKE_CXX_STANDARD GREATER_EQUAL 17)
+  set(_hardening_cxx_standard ${CMAKE_CXX_STANDARD})
+endif()
+set_target_properties(hardening_test PROPERTIES
+  CXX_STANDARD ${_hardening_cxx_standard}
+  CXX_STANDARD_REQUIRED YES
+)
+message(STATUS "hardening_test will use C++${_hardening_cxx_standard}")
+
+add_test(
+  NAME hardening_test
+  COMMAND hardening_test "[deserialize_hardening]"
+)
+
+target_sources(hardening_test
+  PRIVATE
+    deserialize_hardening_test.cpp
+)

data/vendor/datasketches-cpp/common/test/binomial_bounds_test.cpp

@@ -0,0 +1,279 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <catch2/catch.hpp>
+
+#include "binomial_bounds.hpp"
+
+namespace datasketches {
+
+TEST_CASE("binomial_bounds: get_lower_bound", "[common]") {
+
+  SECTION("num_samples == 0") {
+    double result = binomial_bounds::get_lower_bound(0, 0.5, 1);
+    REQUIRE(result == 0.0);
+  }
+
+  SECTION("theta == 1.0") {
+    double result = binomial_bounds::get_lower_bound(100, 1.0, 1);
+    REQUIRE(result == 100.0);
+  }
+
+  SECTION("num_samples == 1") {
+    double result = binomial_bounds::get_lower_bound(1, 0.5, 1);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("num_samples == 1, stddev=2") {
+    double result = binomial_bounds::get_lower_bound(1, 0.5, 2);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("num_samples == 1, stddev=3") {
+    double result = binomial_bounds::get_lower_bound(1, 0.5, 3);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("num_samples > 120") {
+    double result = binomial_bounds::get_lower_bound(121, 0.5, 1);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("num_samples > 120, stddev=2") {
+    double result = binomial_bounds::get_lower_bound(200, 0.5, 2);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("num_samples > 120, stddev=3") {
+    double result = binomial_bounds::get_lower_bound(500, 0.5, 3);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("2 <= num_samples <= 120 AND theta > (1-1e-5)") {
+    double result = binomial_bounds::get_lower_bound(50, 1.0 - 1e-6, 1);
+    REQUIRE(std::abs(result - 50.0) < 50.0 * 0.01);
+  }
+
+  SECTION("2 <= num_samples <= 120 AND theta > (1-1e-5), stddev=2") {
+    double result = binomial_bounds::get_lower_bound(50, 1.0 - 1e-6, 2);
+    REQUIRE(std::abs(result - 50.0) < 50.0 * 0.01);
+  }
+
+  SECTION("2 <= num_samples <= 120 AND theta > (1-1e-5), stddev=3") {
+    double result = binomial_bounds::get_lower_bound(50, 1.0 - 1e-6, 3);
+    REQUIRE(std::abs(result - 50.0) < 50.0 * 0.01);
+  }
+
+  SECTION("2 <= num_samples <= 120 AND theta < num_samples/360") {
+    double result = binomial_bounds::get_lower_bound(100, 0.001, 1);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("2 <= num_samples <= 120 AND theta < num_samples/360, stddev=2") {
+    double result = binomial_bounds::get_lower_bound(100, 0.001, 2);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("2 <= num_samples <= 120 AND theta < num_samples/360, stddev=3") {
+    double result = binomial_bounds::get_lower_bound(100, 0.001, 3);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("2 <= num_samples <= 120 AND middle range theta (exact calculation)") {
+    double result = binomial_bounds::get_lower_bound(10, 0.5, 1);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("2 <= num_samples <= 120 AND middle range theta, stddev=2") {
+    double result = binomial_bounds::get_lower_bound(10, 0.5, 2);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("2 <= num_samples <= 120 AND middle range theta, stddev=3") {
+    double result = binomial_bounds::get_lower_bound(10, 0.5, 3);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("theta=0") {
+    REQUIRE_THROWS_AS(binomial_bounds::get_lower_bound(10, 0.0, 1), std::invalid_argument);
+  }
+
+  SECTION("theta very close to 0") {
+    double result = binomial_bounds::get_lower_bound(10, 1e-10, 1);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("num_samples=2 boundary") {
+    double result = binomial_bounds::get_lower_bound(2, 0.5, 1);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("num_samples=120 boundary") {
+    double result = binomial_bounds::get_lower_bound(120, 0.5, 1);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("estimate clamping case") {
+    double result = binomial_bounds::get_lower_bound(10, 0.9, 1);
+    double estimate = 10.0 / 0.9;
+    REQUIRE(result <= estimate);
+  }
+
+  SECTION("invalid theta < 0") {
+    REQUIRE_THROWS_AS(binomial_bounds::get_lower_bound(100, -0.1, 1), std::invalid_argument);
+  }
+
+  SECTION("invalid theta > 1") {
+    REQUIRE_THROWS_AS(binomial_bounds::get_lower_bound(100, 1.1, 1), std::invalid_argument);
+  }
+
+  SECTION("invalid stddev = 0") {
+    REQUIRE_THROWS_AS(binomial_bounds::get_lower_bound(100, 0.5, 0), std::invalid_argument);
+  }
+
+  SECTION("invalid stddev = 4") {
+    REQUIRE_THROWS_AS(binomial_bounds::get_lower_bound(100, 0.5, 4), std::invalid_argument);
+  }
+}
+
+TEST_CASE("binomial_bounds: get_upper_bound", "[common]") {
+
+  SECTION("theta == 1.0") {
+    double result = binomial_bounds::get_upper_bound(100, 1.0, 1);
+    REQUIRE(result == 100.0);
+  }
+
+  SECTION("num_samples == 0") {
+    double result = binomial_bounds::get_upper_bound(0, 0.5, 1);
+    REQUIRE(result > 0.0);
+  }
+
+  SECTION("num_samples == 0, stddev=2") {
+    double result = binomial_bounds::get_upper_bound(0, 0.5, 2);
+    REQUIRE(result > 0.0);
+  }
+
+  SECTION("num_samples == 0, stddev=3") {
+    double result = binomial_bounds::get_upper_bound(0, 0.5, 3);
+    REQUIRE(result > 0.0);
+  }
+
+  SECTION("num_samples > 120") {
+    double result = binomial_bounds::get_upper_bound(121, 0.5, 1);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("num_samples > 120, stddev=2") {
+    double result = binomial_bounds::get_upper_bound(200, 0.5, 2);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("num_samples > 120, stddev=3") {
+    double result = binomial_bounds::get_upper_bound(500, 0.5, 3);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("1 <= num_samples <= 120 AND theta > (1-1e-5)") {
+    double result = binomial_bounds::get_upper_bound(50, 1.0 - 1e-6, 1);
+    REQUIRE(result == 51.0);
+  }
+
+  SECTION("1 <= num_samples <= 120 AND theta > (1-1e-5), stddev=2") {
+    double result = binomial_bounds::get_upper_bound(50, 1.0 - 1e-6, 2);
+    REQUIRE(result == 51.0);
+  }
+
+  SECTION("1 <= num_samples <= 120 AND theta > (1-1e-5), stddev=3") {
+    double result = binomial_bounds::get_upper_bound(50, 1.0 - 1e-6, 3);
+    REQUIRE(result == 51.0);
+  }
+
+  SECTION("1 <= num_samples <= 120 AND theta < num_samples/360") {
+    double result = binomial_bounds::get_upper_bound(100, 0.001, 1);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("1 <= num_samples <= 120 AND theta < num_samples/360, stddev=2") {
+    double result = binomial_bounds::get_upper_bound(100, 0.001, 2);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("1 <= num_samples <= 120 AND theta < num_samples/360, stddev=3") {
+    double result = binomial_bounds::get_upper_bound(100, 0.001, 3);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("1 <= num_samples <= 120 AND middle range theta (exact calculation)") {
+    double result = binomial_bounds::get_upper_bound(10, 0.5, 1);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("1 <= num_samples <= 120 AND middle range theta, stddev=2") {
+    double result = binomial_bounds::get_upper_bound(10, 0.5, 2);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("1 <= num_samples <= 120 AND middle range theta, stddev=3") {
+    double result = binomial_bounds::get_upper_bound(10, 0.5, 3);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("theta=0") {
+    REQUIRE_THROWS_AS(binomial_bounds::get_upper_bound(10, 0.0, 1), std::invalid_argument);
+  }
+
+  SECTION("theta very close to 0") {
+    double result = binomial_bounds::get_upper_bound(10, 1e-10, 1);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("num_samples=1 boundary") {
+    double result = binomial_bounds::get_upper_bound(1, 0.5, 1);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("num_samples=120 boundary") {
+    double result = binomial_bounds::get_upper_bound(120, 0.5, 1);
+    REQUIRE(result >= 0.0);
+  }
+
+  SECTION("estimate clamping case") {
+    double result = binomial_bounds::get_upper_bound(10, 0.9, 1);
+    double estimate = 10.0 / 0.9;
+    REQUIRE(result >= estimate);
+  }
+
+  SECTION("invalid theta < 0") {
+    REQUIRE_THROWS_AS(binomial_bounds::get_upper_bound(100, -0.1, 1), std::invalid_argument);
+  }
+
+  SECTION("invalid theta > 1") {
+    REQUIRE_THROWS_AS(binomial_bounds::get_upper_bound(100, 1.1, 1), std::invalid_argument);
+  }
+
+  SECTION("invalid stddev = 0") {
+    REQUIRE_THROWS_AS(binomial_bounds::get_upper_bound(100, 0.5, 0), std::invalid_argument);
+  }
+
+  SECTION("invalid stddev = 4") {
+    REQUIRE_THROWS_AS(binomial_bounds::get_upper_bound(100, 0.5, 4), std::invalid_argument);
+  }
+}
+
+} /* namespace datasketches */

data/vendor/datasketches-cpp/common/test/deserialize_hardening_test.cpp

@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <catch2/catch.hpp>
+#include <sstream>
+#include <vector>
+
+// Include all affected sketch types
+#include <quantiles_sketch.hpp>
+#include <kll_sketch.hpp>
+#include <req_sketch.hpp>
+
+namespace datasketches {
+
+/**
+ * Test for fix of issue #477:
+ * BUG: SIGABRT in deserialize(): dereferencing empty std::optional (libc++ verbose_abort)
+ * 
+ * These tests exercise the actual deserialization code path that contained the bug.
+ * With buggy code (&*tmp on empty optional) and hardening enabled, these will SIGABRT.
+ * With fixed code (aligned_storage), these pass normally.
+ * 
+ * IMPORTANT: These tests actually call deserialize() on multi-item sketches, which
+ * exercises the buggy code path where min/max are deserialized.
+ */
+
+TEST_CASE("quantiles_sketch: deserialize multi-item sketch", "[deserialize_hardening]") {
+  // Create sketch with multiple items (so min/max are stored in serialization)
+  quantiles_sketch<double> sketch(128);
+  for (int i = 0; i < 1000; i++) {
+    sketch.update(static_cast<double>(i));
+  }
+  
+  // Serialize
+  auto bytes = sketch.serialize();
+  
+  // Deserialize - WITH BUGGY CODE AND HARDENING, THIS WILL SIGABRT HERE
+  // The bug is: sd.deserialize(is, &*tmp, 1) where tmp is empty optional
+  auto sketch2 = quantiles_sketch<double>::deserialize(bytes.data(), bytes.size());
+  
+  // Verify deserialization worked correctly
+  REQUIRE(sketch2.get_n() == sketch.get_n());
+  REQUIRE(sketch2.get_min_item() == sketch.get_min_item());
+  REQUIRE(sketch2.get_max_item() == sketch.get_max_item());
+  REQUIRE(sketch2.get_quantile(0.5) == sketch.get_quantile(0.5));
+}
+
+TEST_CASE("quantiles_sketch: deserialize from stream", "[deserialize_hardening]") {
+  quantiles_sketch<float> sketch(256);
+  for (int i = 0; i < 2000; i++) {
+    sketch.update(static_cast<float>(i) * 0.5f);
+  }
+  
+  // Serialize to stream
+  std::stringstream ss;
+  sketch.serialize(ss);
+  
+  // Deserialize from stream - exercises the buggy code path
+  auto sketch2 = quantiles_sketch<float>::deserialize(ss);
+  
+  REQUIRE(sketch2.get_n() == sketch.get_n());
+  REQUIRE(sketch2.get_min_item() == sketch.get_min_item());
+  REQUIRE(sketch2.get_max_item() == sketch.get_max_item());
+}
+
+TEST_CASE("kll_sketch: deserialize multi-item sketch", "[deserialize_hardening]") {
+  kll_sketch<float> sketch(200);
+  for (int i = 0; i < 1500; i++) {
+    sketch.update(static_cast<float>(i));
+  }
+  
+  auto bytes = sketch.serialize();
+  
+  // Deserialize - exercises buggy &*tmp code path
+  auto sketch2 = kll_sketch<float>::deserialize(bytes.data(), bytes.size());
+  
+  REQUIRE(sketch2.get_n() == sketch.get_n());
+  REQUIRE(sketch2.get_min_item() == sketch.get_min_item());
+  REQUIRE(sketch2.get_max_item() == sketch.get_max_item());
+}
+
+TEST_CASE("kll_sketch: deserialize from stream", "[deserialize_hardening]") {
+  kll_sketch<int> sketch(400);
+  for (int i = 0; i < 3000; i++) {
+    sketch.update(i);
+  }
+  
+  std::stringstream ss;
+  sketch.serialize(ss);
+  
+  // Deserialize from stream
+  auto sketch2 = kll_sketch<int>::deserialize(ss);
+  
+  REQUIRE(sketch2.get_n() == sketch.get_n());
+  REQUIRE(sketch2.get_min_item() == sketch.get_min_item());
+  REQUIRE(sketch2.get_max_item() == sketch.get_max_item());
+}
+
+TEST_CASE("req_sketch: deserialize multi-level sketch", "[deserialize_hardening]") {
+  // REQ sketch only has the bug when num_levels > 1
+  // We need to add enough items to trigger multiple levels
+  req_sketch<float> sketch(12);
+  for (int i = 0; i < 10000; i++) {
+    sketch.update(static_cast<float>(i));
+  }
+  
+  auto bytes = sketch.serialize();
+  
+  // Deserialize - exercises buggy code path when num_levels > 1
+  auto sketch2 = req_sketch<float>::deserialize(bytes.data(), bytes.size());
+  
+  REQUIRE(sketch2.get_n() == sketch.get_n());
+  REQUIRE(sketch2.get_min_item() == sketch.get_min_item());
+  REQUIRE(sketch2.get_max_item() == sketch.get_max_item());
+}
+
+TEST_CASE("req_sketch: deserialize from stream", "[deserialize_hardening]") {
+  req_sketch<double> sketch(20);
+  for (int i = 0; i < 15000; i++) {
+    sketch.update(static_cast<double>(i) * 0.1);
+  }
+  
+  std::stringstream ss;
+  sketch.serialize(ss);
+  
+  // Deserialize from stream
+  auto sketch2 = req_sketch<double>::deserialize(ss);
+  
+  REQUIRE(sketch2.get_n() == sketch.get_n());
+  REQUIRE(sketch2.get_min_item() == sketch.get_min_item());
+  REQUIRE(sketch2.get_max_item() == sketch.get_max_item());
+}
+
+TEST_CASE("multiple sketch types: stress test", "[deserialize_hardening]") {
+  SECTION("quantiles with various sizes") {
+    for (int k : {64, 128, 256}) {
+      quantiles_sketch<int> sketch(k);
+      for (int i = 0; i < 5000; i++) {
+        sketch.update(i);
+      }
+      auto bytes = sketch.serialize();
+      auto sketch2 = quantiles_sketch<int>::deserialize(bytes.data(), bytes.size());
+      REQUIRE(sketch2.get_n() == sketch.get_n());
+    }
+  }
+  
+  SECTION("kll with various sizes") {
+    for (int k : {100, 200, 400}) {
+      kll_sketch<double> sketch(k);
+      for (int i = 0; i < 4000; i++) {
+        sketch.update(static_cast<double>(i) / 10.0);
+      }
+      auto bytes = sketch.serialize();
+      auto sketch2 = kll_sketch<double>::deserialize(bytes.data(), bytes.size());
+      REQUIRE(sketch2.get_n() == sketch.get_n());
+    }
+  }
+  
+  SECTION("req with various sizes") {
+    for (int k : {12, 20}) {
+      req_sketch<float> sketch(k);
+      for (int i = 0; i < 8000; i++) {
+        sketch.update(static_cast<float>(i));
+      }
+      auto bytes = sketch.serialize();
+      auto sketch2 = req_sketch<float>::deserialize(bytes.data(), bytes.size());
+      REQUIRE(sketch2.get_n() == sketch.get_n());
+    }
+  }
+}
+
+} // namespace datasketches