datasketches 0.1.0

data/vendor/datasketches-cpp/hll/test/CrossCountingTest.cpp

@@ -0,0 +1,93 @@
+/*
+ * 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 <catch.hpp>
+#include <ostream>
+#include <cmath>
+#include <string>
+
+#include "hll.hpp"
+
+namespace datasketches {
+
+static hll_sketch buildSketch(const int n, const int lgK, const target_hll_type tgtHllType) {
+  hll_sketch sketch(lgK, tgtHllType);
+  for (int i = 0; i < n; ++i) {
+    sketch.update(i);
+  }
+  return sketch;
+}
+
+static void crossCountingCheck(const int lgK, const int n) {
+  hll_sketch sk4 = buildSketch(n, lgK, HLL_4);
+  const double est = sk4.get_estimate();
+  const double lb = sk4.get_lower_bound(1);
+  const double ub = sk4.get_upper_bound(1);
+
+  hll_sketch sk6 = buildSketch(n, lgK, HLL_6);
+  REQUIRE(sk6.get_estimate() == est);
+  REQUIRE(sk6.get_lower_bound(1) == lb);
+  REQUIRE(sk6.get_upper_bound(1) == ub);
+
+  hll_sketch sk8 = buildSketch(n, lgK, HLL_8);
+  REQUIRE(sk8.get_estimate() == est);
+  REQUIRE(sk8.get_lower_bound(1) == lb);
+  REQUIRE(sk8.get_upper_bound(1) == ub);
+
+  // Conversions
+  hll_sketch sk4to6(sk4, HLL_6);
+  REQUIRE(sk4to6.get_estimate() == est);
+  REQUIRE(sk4to6.get_lower_bound(1) == lb);
+  REQUIRE(sk4to6.get_upper_bound(1) == ub);
+
+  hll_sketch sk4to8(sk4, HLL_8);
+  REQUIRE(sk4to8.get_estimate() == est);
+  REQUIRE(sk4to8.get_lower_bound(1) == lb);
+  REQUIRE(sk4to8.get_upper_bound(1) == ub);
+
+  hll_sketch sk6to4(sk6, HLL_4);
+  REQUIRE(sk6to4.get_estimate() == est);
+  REQUIRE(sk6to4.get_lower_bound(1) == lb);
+  REQUIRE(sk6to4.get_upper_bound(1) == ub);
+
+  hll_sketch sk6to8(sk6, HLL_8);
+  REQUIRE(sk6to8.get_estimate() == est);
+  REQUIRE(sk6to8.get_lower_bound(1) == lb);
+  REQUIRE(sk6to8.get_upper_bound(1) == ub);
+
+  hll_sketch sk8to4(sk8, HLL_4);
+  REQUIRE(sk8to4.get_estimate() == est);
+  REQUIRE(sk8to4.get_lower_bound(1) == lb);
+  REQUIRE(sk8to4.get_upper_bound(1) == ub);
+
+  hll_sketch sk8to6(sk8, HLL_6);
+  REQUIRE(sk8to6.get_estimate() == est);
+  REQUIRE(sk8to6.get_lower_bound(1) == lb);
+  REQUIRE(sk8to6.get_upper_bound(1) == ub);
+}
+
+TEST_CASE("cross counting: cross counting checks", "[cross_counting]") {
+  crossCountingCheck(4, 100);
+  crossCountingCheck(4, 10000);
+  crossCountingCheck(12, 7);
+  crossCountingCheck(12, 384);
+  crossCountingCheck(12, 10000);
+}
+
+} /* namespace datasketches */

data/vendor/datasketches-cpp/hll/test/HllArrayTest.cpp

@@ -0,0 +1,191 @@
+/*
+ * 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 "hll.hpp"
+
+#include <exception>
+#include <sstream>
+#include <catch.hpp>
+
+namespace datasketches {
+
+static void testComposite(const int lgK, const target_hll_type tgtHllType, const int n) {
+  hll_union u(lgK);
+  hll_sketch sk(lgK, tgtHllType);
+  for (int i = 0; i < n; ++i) {
+    u.update(i);
+    sk.update(i);
+  }
+  u.update(sk); // merge
+  hll_sketch res = u.get_result(target_hll_type::HLL_8);
+  double est = res.get_composite_estimate();
+  REQUIRE(sk.get_composite_estimate() == est);
+}
+
+TEST_CASE("hll array: check composite estimate", "[hll_array]") {
+  testComposite(4, target_hll_type::HLL_8, 10000);
+  testComposite(5, target_hll_type::HLL_8, 10000);
+  testComposite(6, target_hll_type::HLL_8, 10000);
+  testComposite(13, target_hll_type::HLL_8, 10000);
+}
+
+static void serializeDeserialize(const int lgK, target_hll_type tgtHllType, const int n) {
+  hll_sketch sk1(lgK, tgtHllType);
+
+  for (int i = 0; i < n; ++i) {
+    sk1.update(i);
+  }
+  //REQUIRE(sk1.getCurrentMode() == CurMode::HLL);
+
+  double est1 = sk1.get_estimate();
+  REQUIRE(est1 == Approx(n).margin(n * 0.03));
+
+  // serialize as compact and updatable, deserialize, compare estimates are exact
+  std::stringstream ss(std::ios::in | std::ios::out | std::ios::binary);
+  sk1.serialize_compact(ss);
+  hll_sketch sk2 = hll_sketch::deserialize(ss);
+  REQUIRE(sk1.get_estimate() == sk2.get_estimate());
+
+  ss.clear();
+  sk1.serialize_updatable(ss);
+  sk2 = hll_sketch::deserialize(ss);
+  REQUIRE(sk1.get_estimate() == sk2.get_estimate());
+
+  sk1.reset();
+  REQUIRE(sk1.get_estimate() == 0.0);
+}
+
+TEST_CASE("hll array: check serialize deserialize", "[hll_array]") {
+  int lgK = 4;
+  int n = 8;
+  serializeDeserialize(lgK, HLL_4, n);
+  serializeDeserialize(lgK, HLL_6, n);
+  serializeDeserialize(lgK, HLL_8, n);
+
+  lgK = 15;
+  n = (((1 << (lgK - 3))*3)/4) + 100;
+  serializeDeserialize(lgK, HLL_4, n);
+  serializeDeserialize(lgK, HLL_6, n);
+  serializeDeserialize(lgK, HLL_8, n);
+
+  lgK = 21;
+  n = (((1 << (lgK - 3))*3)/4) + 1000;
+  serializeDeserialize(lgK, HLL_4, n);
+  serializeDeserialize(lgK, HLL_6, n);
+  serializeDeserialize(lgK, HLL_8, n);
+}
+
+TEST_CASE("hll array: check is compact", "[hll_array]") {
+  hll_sketch sk(4);
+  for (int i = 0; i < 8; ++i) {
+    sk.update(i);
+  }
+  REQUIRE_FALSE(sk.is_compact());
+}
+
+TEST_CASE("hll array: check corrupt bytearray", "[hll_array]") {
+  int lgK = 8;
+  hll_sketch sk1(lgK, HLL_8);
+  for (int i = 0; i < 50; ++i) {
+    sk1.update(i);
+  }
+  auto sketchBytes = sk1.serialize_compact();
+  uint8_t* bytes = sketchBytes.data();
+  const size_t size = sketchBytes.size();
+
+  bytes[HllUtil<>::PREAMBLE_INTS_BYTE] = 0;
+  REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
+  REQUIRE_THROWS_AS(HllArray<>::newHll(bytes, size), std::invalid_argument);
+  bytes[HllUtil<>::PREAMBLE_INTS_BYTE] = HllUtil<>::HLL_PREINTS;
+
+  bytes[HllUtil<>::SER_VER_BYTE] = 0;
+  REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
+  bytes[HllUtil<>::SER_VER_BYTE] = HllUtil<>::SER_VER;
+
+  bytes[HllUtil<>::FAMILY_BYTE] = 0;
+  REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
+  bytes[HllUtil<>::FAMILY_BYTE] = HllUtil<>::FAMILY_ID;
+
+  uint8_t tmp = bytes[HllUtil<>::MODE_BYTE];
+  bytes[HllUtil<>::MODE_BYTE] = 0x10; // HLL_6, LIST
+  REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
+  bytes[HllUtil<>::MODE_BYTE] = tmp;
+
+  tmp = bytes[HllUtil<>::LG_ARR_BYTE];
+  bytes[HllUtil<>::LG_ARR_BYTE] = 0;
+  hll_sketch::deserialize(bytes, size);
+  // should work fine despite the corruption
+  bytes[HllUtil<>::LG_ARR_BYTE] = tmp;
+
+  REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size - 1), std::out_of_range);
+  REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, 3), std::out_of_range);
+}
+
+TEST_CASE("hll array: check corrupt stream", "[hll_array]") {
+  int lgK = 6;
+  hll_sketch sk1(lgK);
+  for (int i = 0; i < 50; ++i) {
+    sk1.update(i);
+  }
+  std::stringstream ss;
+  sk1.serialize_compact(ss);
+
+  ss.seekp(HllUtil<>::PREAMBLE_INTS_BYTE);
+  ss.put(0);
+  ss.seekg(0);
+  REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
+  REQUIRE_THROWS_AS(HllArray<>::newHll(ss), std::invalid_argument);                                
+  ss.seekp(HllUtil<>::PREAMBLE_INTS_BYTE);
+  ss.put(HllUtil<>::HLL_PREINTS);
+
+  ss.seekp(HllUtil<>::SER_VER_BYTE);
+  ss.put(0);
+  ss.seekg(0);
+  REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
+  ss.seekp(HllUtil<>::SER_VER_BYTE);
+  ss.put(HllUtil<>::SER_VER);
+
+  ss.seekp(HllUtil<>::FAMILY_BYTE);
+  ss.put(0);
+  ss.seekg(0);
+  REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
+  ss.seekp(HllUtil<>::FAMILY_BYTE);
+  ss.put(HllUtil<>::FAMILY_ID);
+
+  ss.seekg(HllUtil<>::MODE_BYTE);
+  uint8_t tmp = ss.get();
+  ss.seekp(HllUtil<>::MODE_BYTE);
+  ss.put(0x11); // HLL_6, SET
+  ss.seekg(0);
+  REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
+  ss.seekp(HllUtil<>::MODE_BYTE);
+  ss.put(tmp);
+
+  ss.seekg(HllUtil<>::LG_ARR_BYTE);
+  tmp = ss.get();
+  ss.seekp(HllUtil<>::LG_ARR_BYTE);
+  ss.put(0);
+  ss.seekg(0);
+  hll_sketch::deserialize(ss);
+  // should work fine despite the corruption
+  ss.seekp(HllUtil<>::LG_ARR_BYTE);
+  ss.put(tmp);
+}
+
+} /* namespace datasketches */

data/vendor/datasketches-cpp/hll/test/HllSketchTest.cpp

@@ -0,0 +1,389 @@
+/*
+ * 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 "hll.hpp"
+
+#include <catch.hpp>
+#include <test_allocator.hpp>
+
+namespace datasketches {
+
+typedef hll_sketch_alloc<test_allocator<void>> hll_sketch_test_alloc;
+
+static void runCheckCopy(int lgConfigK, target_hll_type tgtHllType) {
+  hll_sketch_test_alloc sk(lgConfigK, tgtHllType);
+
+  for (int i = 0; i < 7; ++i) {
+    sk.update(i);
+  }
+
+  hll_sketch_test_alloc skCopy = sk;
+  REQUIRE(sk.get_estimate() == skCopy.get_estimate());
+
+  // no access to hllSketchImpl, so we'll ensure those differ by adding more
+  // data to sk and ensuring the mode and estimates differ
+  for (int i = 7; i < 24; ++i) {
+    sk.update(i);
+  }
+  REQUIRE(16.0 < (sk.get_estimate() - skCopy.get_estimate()));
+
+  skCopy = sk;
+  REQUIRE(sk.get_estimate() == skCopy.get_estimate());
+
+  int u = (sk.get_target_type() == HLL_4) ? 100000 : 25;
+  for (int i = 24; i < u; ++i) {
+    sk.update(i);
+  }
+  REQUIRE(sk.get_estimate() != skCopy.get_estimate()); // either 1 or 100k difference
+
+  skCopy = sk;
+  REQUIRE(sk.get_estimate() == skCopy.get_estimate());
+}
+
+TEST_CASE("hll sketch: check copies", "[hll_sketch]") {
+  test_allocator_total_bytes = 0;
+  runCheckCopy(14, HLL_4);
+  runCheckCopy(8, HLL_6);
+  runCheckCopy(8, HLL_8);
+  REQUIRE(test_allocator_total_bytes == 0);
+}
+
+static void copyAs(target_hll_type srcType, target_hll_type dstType) {
+  int lgK = 8;
+  int n1 = 7;
+  int n2 = 24;
+  int n3 = 1000;
+  int base = 0;
+
+  hll_sketch_test_alloc src(lgK, srcType);
+  for (int i = 0; i < n1; ++i) {
+    src.update(i + base);
+  }
+  hll_sketch_test_alloc dst(src, dstType);
+  REQUIRE(src.get_estimate() == dst.get_estimate());
+
+  for (int i = n1; i < n2; ++i) {
+    src.update(i + base);
+  }
+  dst = hll_sketch_test_alloc(src, dstType);
+  REQUIRE(src.get_estimate() == dst.get_estimate());
+
+  for (int i = n2; i < n3; ++i) {
+    src.update(i + base);
+  }
+  dst = hll_sketch_test_alloc(src, dstType);
+  REQUIRE(src.get_estimate() == dst.get_estimate());
+}
+
+TEST_CASE("hll sketch: check copy as", "[hll_sketch]") {
+  test_allocator_total_bytes = 0;
+  copyAs(HLL_4, HLL_4);
+  copyAs(HLL_4, HLL_6);
+  copyAs(HLL_4, HLL_8);
+  copyAs(HLL_6, HLL_4);
+  copyAs(HLL_6, HLL_6);
+  copyAs(HLL_6, HLL_8);
+  copyAs(HLL_8, HLL_4);
+  copyAs(HLL_8, HLL_6);
+  copyAs(HLL_8, HLL_8);
+  REQUIRE(test_allocator_total_bytes == 0);
+}
+
+TEST_CASE("hll sketch: check misc1", "[hll_sketch]") {
+  test_allocator_total_bytes = 0;
+  {
+    int lgConfigK = 8;
+    target_hll_type srcType = target_hll_type::HLL_8;
+    hll_sketch_test_alloc sk(lgConfigK, srcType);
+
+    for (int i = 0; i < 7; ++i) { sk.update(i); } // LIST
+    REQUIRE(sk.get_compact_serialization_bytes() == 36);
+    REQUIRE(sk.get_updatable_serialization_bytes() == 40);
+
+    for (int i = 7; i < 24; ++i) { sk.update(i); } // SET
+    REQUIRE(sk.get_compact_serialization_bytes() == 108);
+    REQUIRE(sk.get_updatable_serialization_bytes() == 140);
+
+    sk.update(24); // HLL
+    REQUIRE(sk.get_updatable_serialization_bytes() == 40 + 256);
+
+    const int hllBytes = HllUtil<>::HLL_BYTE_ARR_START + (1 << lgConfigK);
+    REQUIRE(sk.get_compact_serialization_bytes() == hllBytes);
+    REQUIRE(hll_sketch::get_max_updatable_serialization_bytes(lgConfigK, HLL_8) == hllBytes);
+  }
+  REQUIRE(test_allocator_total_bytes == 0);
+}
+
+TEST_CASE("hll sketch: check num std dev", "[hll_sketch]") {
+  REQUIRE_THROWS_AS(HllUtil<>::checkNumStdDev(0), std::invalid_argument);
+}
+
+void checkSerializationSizes(const int lgConfigK, target_hll_type tgtHllType) {
+  hll_sketch_test_alloc sk(lgConfigK, tgtHllType);
+  int i;
+
+  // LIST
+  for (i = 0; i < 7; ++i) { sk.update(i); }
+  int expected = HllUtil<>::LIST_INT_ARR_START + (i << 2);
+  REQUIRE(sk.get_compact_serialization_bytes() == expected);
+  expected = HllUtil<>::LIST_INT_ARR_START + (4 << HllUtil<>::LG_INIT_LIST_SIZE);
+  REQUIRE(sk.get_updatable_serialization_bytes() == expected);
+
+  // SET
+  for (i = 7; i < 24; ++i) { sk.update(i); }
+  expected = HllUtil<>::HASH_SET_INT_ARR_START + (i << 2);
+  REQUIRE(sk.get_compact_serialization_bytes() == expected);
+  expected = HllUtil<>::HASH_SET_INT_ARR_START + (4 << HllUtil<>::LG_INIT_SET_SIZE);
+  REQUIRE(sk.get_updatable_serialization_bytes() == expected);
+}
+
+TEST_CASE("hll sketch: check ser sizes", "[hll_sketch]") {
+  test_allocator_total_bytes = 0;
+  checkSerializationSizes(8, HLL_8);
+  checkSerializationSizes(8, HLL_6);
+  checkSerializationSizes(8, HLL_4);
+  REQUIRE(test_allocator_total_bytes == 0);
+}
+
+TEST_CASE("hll sketch: exercise to string", "[hll_sketch]") {
+  test_allocator_total_bytes = 0;
+  {
+    hll_sketch_test_alloc sk(15, HLL_4);
+    for (int i = 0; i < 25; ++i) { sk.update(i); }
+    std::ostringstream oss(std::ios::binary);
+    oss << sk.to_string(false, true, true, true);
+    for (int i = 25; i < (1 << 20); ++i) { sk.update(i); }
+    oss << sk.to_string(false, true, true, true);
+    oss << sk.to_string(false, true, true, false);
+
+    sk = hll_sketch_test_alloc(8, HLL_8);
+    for (int i = 0; i < 25; ++i) { sk.update(i); }
+    oss << sk.to_string(false, true, true, true);
+  }
+  REQUIRE(test_allocator_total_bytes == 0);
+}
+
+// Creates and serializes then deserializes sketch.
+// Returns true if deserialized sketch is compact.
+static bool checkCompact(const int lgK, const int n, const target_hll_type type, bool compact) {
+  hll_sketch_test_alloc sk(lgK, type);
+  for (int i = 0; i < n; ++i) { sk.update(i); }
+  
+  std::stringstream ss(std::ios::in | std::ios::out | std::ios::binary);
+  if (compact) { 
+    sk.serialize_compact(ss);
+    REQUIRE(ss.tellp() == sk.get_compact_serialization_bytes());
+  } else {
+    sk.serialize_updatable(ss);
+    REQUIRE(ss.tellp() == sk.get_updatable_serialization_bytes());
+  }
+  
+  hll_sketch_test_alloc sk2 = hll_sketch_test_alloc::deserialize(ss);
+  REQUIRE(sk2.get_estimate() == Approx(n).margin(0.01));
+  bool isCompact = sk2.is_compact();
+
+  return isCompact;
+}
+
+TEST_CASE("hll sketch: check compact flag", "[hll_sketch]") {
+  test_allocator_total_bytes = 0;
+  {
+    int lgK = 8;
+    // unless/until we create non-updatable "direct" versions,
+    // deserialized image should never be compact
+    // LIST: follows serialization request
+    REQUIRE(checkCompact(lgK, 7, HLL_8, false) == false);
+    REQUIRE(checkCompact(lgK, 7, HLL_8, true) == false);
+
+    // SET: follows serialization request
+    REQUIRE(checkCompact(lgK, 24, HLL_8, false) == false);
+    REQUIRE(checkCompact(lgK, 24, HLL_8, true) == false);
+
+    // HLL8: always updatable
+    REQUIRE(checkCompact(lgK, 25, HLL_8, false) == false);
+    REQUIRE(checkCompact(lgK, 25, HLL_8, true) == false);
+
+    // HLL6: always updatable
+    REQUIRE(checkCompact(lgK, 25, HLL_6, false) == false);
+    REQUIRE(checkCompact(lgK, 25, HLL_6, true) == false);
+
+    // HLL4: follows serialization request
+    REQUIRE(checkCompact(lgK, 25, HLL_4, false) == false);
+    REQUIRE(checkCompact(lgK, 25, HLL_4, true) == false);
+  }
+  REQUIRE(test_allocator_total_bytes == 0);
+}
+
+TEST_CASE("hll sketch: check k limits", "[hll_sketch]") {
+  test_allocator_total_bytes = 0;
+  {
+    hll_sketch_test_alloc sketch1(HllUtil<>::MIN_LOG_K, target_hll_type::HLL_8);
+    hll_sketch_test_alloc sketch2(HllUtil<>::MAX_LOG_K, target_hll_type::HLL_4);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc(HllUtil<>::MIN_LOG_K - 1), std::invalid_argument);
+
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc(HllUtil<>::MAX_LOG_K + 1), std::invalid_argument);
+  }
+  REQUIRE(test_allocator_total_bytes == 0);
+}
+
+TEST_CASE("hll sketch: check input types", "[hll_sketch]") {
+  test_allocator_total_bytes = 0;
+  {
+    hll_sketch_test_alloc sk(8, target_hll_type::HLL_8);
+
+    // inserting the same value as a variety of input types
+    sk.update((uint8_t) 102);
+    sk.update((uint16_t) 102);
+    sk.update((uint32_t) 102);
+    sk.update((uint64_t) 102);
+    sk.update((int8_t) 102);
+    sk.update((int16_t) 102);
+    sk.update((int32_t) 102);
+    sk.update((int64_t) 102);
+    REQUIRE(sk.get_estimate() == Approx(1.0).margin(0.01));
+
+    // identical binary representations
+    // no unsigned in Java, but need to sign-extend both as Java would do
+    sk.update((uint8_t) 255);
+    sk.update((int8_t) -1);
+
+    sk.update((float) -2.0);
+    sk.update((double) -2.0);
+
+    std::string str = "input string";
+    sk.update(str);
+    sk.update(str.c_str(), str.length());
+    REQUIRE(sk.get_estimate() == Approx(4.0).margin(0.01));
+
+    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_6);
+    sk.update((float) 0.0);
+    sk.update((float) -0.0);
+    sk.update((double) 0.0);
+    sk.update((double) -0.0);
+    REQUIRE(sk.get_estimate() == Approx(1.0).margin(0.01));
+
+    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_4);
+    sk.update(std::nanf("3"));
+    sk.update(std::nan("9"));
+    REQUIRE(sk.get_estimate() == Approx(1.0).margin(0.01));
+
+    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_4);
+    sk.update(nullptr, 0);
+    sk.update("");
+    REQUIRE(sk.is_empty());
+  }
+  REQUIRE(test_allocator_total_bytes == 0);
+}
+
+TEST_CASE("hll sketch: deserialize list mode buffer overrun", "[hll_sketch]") {
+  test_allocator_total_bytes = 0;
+  {
+    hll_sketch_test_alloc sketch(10);
+    sketch.update(1);
+    auto bytes = sketch.serialize_compact();
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
+
+    // ckeck for leaks on stream exceptions
+    {
+      std::stringstream ss;
+      ss.exceptions(std::ios::failbit | std::ios::badbit);
+      ss.str(std::string((char*)bytes.data(), 7));
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+    }
+    {
+      std::stringstream ss;
+      ss.exceptions(std::ios::failbit | std::ios::badbit);
+      ss.str(std::string((char*)bytes.data(), bytes.size() - 1));
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+    }
+  }
+  REQUIRE(test_allocator_total_bytes == 0);
+}
+
+TEST_CASE("hll sketch: deserialize set mode buffer overrun", "[hll_sketch]") {
+  test_allocator_total_bytes = 0;
+  {
+    hll_sketch_test_alloc sketch(10);
+    for (int i = 0; i < 10; ++i) sketch.update(i);
+    //std::cout << sketch.to_string();
+    auto bytes = sketch.serialize_updatable();
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
+
+    // ckeck for leaks on stream exceptions
+    {
+      std::stringstream ss;
+      ss.exceptions(std::ios::failbit | std::ios::badbit);
+      ss.str(std::string((char*)bytes.data(), 7));
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+    }
+    {
+      std::stringstream ss;
+      ss.exceptions(std::ios::failbit | std::ios::badbit);
+      ss.str(std::string((char*)bytes.data(), bytes.size() - 1));
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+    }
+  }
+  REQUIRE(test_allocator_total_bytes == 0);
+}
+
+TEST_CASE("hll sketch: deserialize HLL mode buffer overrun", "[hll_sketch]") {
+  test_allocator_total_bytes = 0;
+  {
+    // this sketch should have aux table
+    hll_sketch_test_alloc sketch(15);
+    for (int i = 0; i < 14444; ++i) sketch.update(i);
+    //std::cout << sketch.to_string();
+    auto bytes = sketch.serialize_compact();
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 15), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 16420), std::out_of_range); // before aux table
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
+
+    // ckeck for leaks on stream exceptions
+    {
+      std::stringstream ss;
+      ss.exceptions(std::ios::failbit | std::ios::badbit);
+      ss.str(std::string((char*)bytes.data(), 7));
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+    }
+    {
+      std::stringstream ss;
+      ss.exceptions(std::ios::failbit | std::ios::badbit);
+      ss.str(std::string((char*)bytes.data(), 15));
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+    }
+    {
+      std::stringstream ss;
+      ss.exceptions(std::ios::failbit | std::ios::badbit);
+      ss.str(std::string((char*)bytes.data(), 16420)); // before aux table
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+    }
+    {
+      std::stringstream ss;
+      ss.exceptions(std::ios::failbit | std::ios::badbit);
+      ss.str(std::string((char*)bytes.data(), bytes.size() - 1));
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+    }
+  }
+  REQUIRE(test_allocator_total_bytes == 0);
+}
+
+} /* namespace datasketches */