This is an automated email from the ASF dual-hosted git repository.

tisonkun pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/datasketches-rust.git


The following commit(s) were added to refs/heads/main by this push:
     new 446a7c2  refactor!: align decay and KLL merge error contracts and 
harden frequency deserialization (#376)
446a7c2 is described below

commit 446a7c24549de7405955796012868bd98d5a6edd
Author: tison <[email protected]>
AuthorDate: Sun Nov 15 23:56:04 2026 +0800

    refactor!: align decay and KLL merge error contracts and harden frequency 
deserialization (#376)
---
 CHANGELOG.md                                       |  3 ++
 benchmarks/countmin/decay.rs                       |  2 +-
 benchmarks/kll/merge.rs                            |  2 +-
 datasketches/src/countmin/sketch.rs                | 20 +++++---
 datasketches/src/frequencies/sketch.rs             |  8 ++++
 datasketches/src/kll/capacity.rs                   | 31 ++++++------
 datasketches/src/kll/mod.rs                        |  2 +-
 datasketches/src/kll/sketch.rs                     | 56 ++++++++--------------
 tests-integration/tests/countmin_test/sketch.rs    | 40 +++++++++++++---
 tests-integration/tests/kll_test/core.rs           |  8 ++--
 tests-integration/tests/kll_test/merge.rs          |  8 ++--
 tests-integration/tests/kll_test/query.rs          |  2 +-
 tests-integration/tests/serde_tests/frequencies.rs | 31 ++++++++++++
 13 files changed, 134 insertions(+), 79 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 79ecd9b..254a3d4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,8 @@ All significant changes to this project will be documented in 
this file.
 * `CpcSketch::max_serialized_bytes` and `ReqSketch::serialized_size_bytes` are 
removed; serialize the sketch and inspect `len()` on the returned byte buffer 
when the encoded size is needed.
 * `ThetaJaccardSimilarity::compute` and `TupleJaccardSimilarity::compute` now 
return `datasketches::common::JaccardSimilarity` instead of 
`datasketches::thetacommon::JaccardSimilarity`, and `datasketches::thetacommon` 
is no longer part of the public API.
 * `FrequentItemsSketch::update_with_count` and 
`FrequentItemsSketch::update_with_count_ref` are renamed to 
`update_with_weight` and `update_with_weight_ref` to match weighted update 
naming across the crate.
+* `CountMinSketch::decay` now returns `Result<(), Error>`, returning 
`InvalidArgument` without modifying the sketch when `decay` is NaN or outside 
`(0.0, 1.0]`.
+* `KllSketch::merge` now returns `()` instead of `Result<(), Error>` and 
panics without modifying the sketch if the combined stream weight exceeds 
`u64::MAX`.
 * `ReqSketch::num_retained` now returns `usize` instead of `u32`, matching 
`KllSketch`, `ThetaSketch`, and `TupleSketch`.
 * `ReqSketch::rank_lower_bound` and `ReqSketch::rank_upper_bound` now return 
`Result<f64, Error>`, returning `InvalidArgument` when `rank` is NaN or outside 
`[0.0, 1.0]` even on empty or exact-mode sketches.
 * `SketchSlice::advance` now takes `n: usize` instead of `u64` and panics if 
`n > self.remaining().len()`.
@@ -50,6 +52,7 @@ All significant changes to this project will be documented in 
this file.
 
 * `ReqSketch::merge` now cascades compaction across newly grown levels when a 
merged sketch overflows the top compactor's nominal capacity.
 * `ReqSketch::deserialize` now returns `InvalidData` for out-of-range or 
non-finite compactor `section_size_raw` values instead of overflowing 
section-size rounding.
+* `FrequentItemsSketch::deserialize` now returns `InvalidData` when an active 
item weight is zero or when the sum of active item weights and maximum error 
exceeds the declared stream weight.
 * `ThetaJaccardSimilarity` and `TupleJaccardSimilarity` now return 
`InvalidArgument` instead of `InvalidData` when a non-empty input sketch's seed 
hash does not match the configured seed.
 * `ThetaANotB::compute` and `TupleANotB::compute` now stamp empty results with 
the operator's seed hash instead of copying an unchecked seed hash from an 
empty left input.
 
diff --git a/benchmarks/countmin/decay.rs b/benchmarks/countmin/decay.rs
index 4fa0ed9..a6736bd 100644
--- a/benchmarks/countmin/decay.rs
+++ b/benchmarks/countmin/decay.rs
@@ -29,7 +29,7 @@ fn u64(bencher: Bencher, factor: f64) {
 
     bencher.bench_local(|| {
         let mut sketch = sketch.clone();
-        black_box(&mut sketch).decay(black_box(factor))
+        black_box(&mut sketch).decay(black_box(factor)).unwrap()
     });
 }
 
diff --git a/benchmarks/kll/merge.rs b/benchmarks/kll/merge.rs
index 829b731..f65fadf 100644
--- a/benchmarks/kll/merge.rs
+++ b/benchmarks/kll/merge.rs
@@ -30,7 +30,7 @@ fn merge(bencher: Bencher) {
 
     bencher.bench_local(|| {
         let mut left = left.clone();
-        left.merge(black_box(&right)).unwrap();
+        left.merge(black_box(&right));
         black_box(left)
     });
 }
diff --git a/datasketches/src/countmin/sketch.rs 
b/datasketches/src/countmin/sketch.rs
index d3a3532..5b0f2f3 100644
--- a/datasketches/src/countmin/sketch.rs
+++ b/datasketches/src/countmin/sketch.rs
@@ -719,9 +719,10 @@ impl<T: UnsignedCountMinValue> CountMinSketch<T> {
     ///
     /// A factor of `1.0` leaves the sketch unchanged; `0.5` is equivalent to 
[`Self::halve`].
     ///
-    /// # Panics
+    /// # Errors
     ///
-    /// Panics if `decay` is not finite or is outside `(0, 1]`.
+    /// Returns `InvalidArgument` without modifying the sketch if `decay` is 
NaN or outside
+    /// `(0.0, 1.0]`.
     ///
     /// # Examples
     ///
@@ -730,22 +731,27 @@ impl<T: UnsignedCountMinValue> CountMinSketch<T> {
     ///
     /// let mut sketch = CountMinSketch::<u64>::new(4, 128).unwrap();
     /// sketch.update_with_weight(1i64, 3);
-    /// sketch.decay(0.5);
+    /// sketch.decay(0.5).unwrap();
     /// assert!(sketch.estimate(1i64) >= 1);
     /// ```
-    pub fn decay(&mut self, decay: f64) {
-        assert!(decay > 0.0 && decay <= 1.0, "decay must be within (0, 1]");
+    pub fn decay(&mut self, decay: f64) -> Result<(), Error> {
+        if !(decay > 0.0 && decay <= 1.0) {
+            return Err(Error::invalid_argument(format!(
+                "decay must be in (0, 1], got {decay}"
+            )));
+        }
         if decay == 1.0 {
-            return;
+            return Ok(());
         }
         if decay == 0.5 {
             self.halve();
-            return;
+            return Ok(());
         }
         for c in &mut self.counts {
             *c = c.scale_nonnegative(decay)
         }
         self.total_weight = self.total_weight.scale_nonnegative(decay);
+        Ok(())
     }
 }
 
diff --git a/datasketches/src/frequencies/sketch.rs 
b/datasketches/src/frequencies/sketch.rs
index a5b63f2..644f941 100644
--- a/datasketches/src/frequencies/sketch.rs
+++ b/datasketches/src/frequencies/sketch.rs
@@ -742,12 +742,20 @@ impl<T: Eq + Hash> FrequentItemsSketch<T> {
             let value = cursor.read_u64_le().map_err(|error| {
                 Error::insufficient_data_of("frequent item weight", 
error).with_context("index", i)
             })?;
+            if value == 0 {
+                return Err(Error::deserial("frequent item weight must be 
positive"));
+            }
             // Reconstructing the map must not overflow or exceed the declared 
stream weight.
             remaining_weight = remaining_weight
                 .checked_sub(value)
                 .ok_or_else(|| Error::deserial("item weights exceed total 
stream weight"))?;
             values.push(value);
         }
+        if offset_val > remaining_weight {
+            return Err(Error::deserial(
+                "item weights and maximum error exceed total stream weight",
+            ));
+        }
 
         let items = deserialize_items(cursor, active_items)?;
         if items.len() != active_items {
diff --git a/datasketches/src/kll/capacity.rs b/datasketches/src/kll/capacity.rs
index 1f979cb..fd80d05 100644
--- a/datasketches/src/kll/capacity.rs
+++ b/datasketches/src/kll/capacity.rs
@@ -15,6 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use super::DEFAULT_M;
+
 const POWERS_OF_THREE: [u64; 31] = [
     1,
     3,
@@ -52,46 +54,41 @@ const POWERS_OF_THREE: [u64; 31] = [
 const MAX_DEPTH: usize = 60;
 const MAX_SHALLOW_DEPTH: usize = POWERS_OF_THREE.len() - 1;
 
-pub fn total_capacity(k: u16, minimum_capacity: u8, num_levels: usize) -> u32 {
-    validate_inputs(k, minimum_capacity, num_levels);
+pub fn total_capacity(k: u16, num_levels: usize) -> u32 {
+    validate_inputs(k, num_levels);
     let mut total: u32 = 0;
     for level in 0..num_levels {
-        total += level_capacity_unchecked(k, num_levels, level, 
minimum_capacity);
+        total += level_capacity_unchecked(k, num_levels, level);
     }
     total
 }
 
-pub fn level_capacity(k: u16, num_levels: usize, level: usize, 
minimum_capacity: u8) -> u32 {
-    validate_inputs(k, minimum_capacity, num_levels);
+pub fn level_capacity(k: u16, num_levels: usize, level: usize) -> u32 {
+    validate_inputs(k, num_levels);
     assert!(
         level < num_levels,
         "KLL level index must be in [0, {num_levels}), got {level}"
     );
-    level_capacity_unchecked(k, num_levels, level, minimum_capacity)
+    level_capacity_unchecked(k, num_levels, level)
 }
 
-fn validate_inputs(k: u16, minimum_capacity: u8, num_levels: usize) {
+fn validate_inputs(k: u16, num_levels: usize) {
     assert!(
         (1..=MAX_DEPTH + 1).contains(&num_levels),
         "KLL number of levels must be in [1, {}], got {num_levels}",
         MAX_DEPTH + 1
     );
     assert!(
-        minimum_capacity as u16 <= k,
-        "KLL minimum level capacity must not exceed k: minimum capacity 
{minimum_capacity}, k {k}"
+        DEFAULT_M as u16 <= k,
+        "KLL minimum level capacity must not exceed k: minimum capacity 
{DEFAULT_M}, k {k}"
     );
 }
 
-const fn level_capacity_unchecked(
-    k: u16,
-    num_levels: usize,
-    level: usize,
-    minimum_capacity: u8,
-) -> u32 {
+const fn level_capacity_unchecked(k: u16, num_levels: usize, level: usize) -> 
u32 {
     let depth = num_levels - level - 1;
     let capacity = capacity_at_depth(k, depth) as u32;
-    if capacity < minimum_capacity as u32 {
-        minimum_capacity as u32
+    if capacity < DEFAULT_M as u32 {
+        DEFAULT_M as u32
     } else {
         capacity
     }
diff --git a/datasketches/src/kll/mod.rs b/datasketches/src/kll/mod.rs
index e6cf6cf..39368e3 100644
--- a/datasketches/src/kll/mod.rs
+++ b/datasketches/src/kll/mod.rs
@@ -55,7 +55,7 @@ pub use self::value::KllFloat;
 pub use self::value::KllValue;
 /// Default value of parameter k.
 const DEFAULT_K: u16 = 200;
-/// Default value of parameter m.
+/// Fixed minimum level capacity encoded in the KLL wire format.
 const DEFAULT_M: u8 = 8;
 /// Minimum value of parameter k.
 const MIN_K: u16 = DEFAULT_M as u16;
diff --git a/datasketches/src/kll/sketch.rs b/datasketches/src/kll/sketch.rs
index ea836a4..950e1c2 100644
--- a/datasketches/src/kll/sketch.rs
+++ b/datasketches/src/kll/sketch.rs
@@ -53,7 +53,6 @@ use crate::error::Error;
 #[derive(Clone)]
 pub struct KllSketch<T> {
     k: u16,
-    m: u8,
     min_k: u16,
     n: u64,
     num_retained: usize,
@@ -170,7 +169,7 @@ impl<T: Clone + Ord> KllSketch<T> {
         self.min_k = self.k;
         self.n = 0;
         self.num_retained = 0;
-        self.capacity = total_capacity(self.k, self.m, 1) as usize;
+        self.capacity = total_capacity(self.k, 1) as usize;
         self.is_level_zero_sorted = false;
         self.levels.clear();
         self.levels.push(Vec::new());
@@ -180,29 +179,17 @@ impl<T: Clone + Ord> KllSketch<T> {
 
     /// Merges another sketch into this one.
     ///
-    /// # Errors
+    /// # Panics
     ///
-    /// Returns an error without modifying the sketch if the combined stream 
weight exceeds
-    /// [`u64::MAX`].
-    pub fn merge(&mut self, other: &KllSketch<T>) -> Result<(), Error> {
-        if self.m != other.m {
-            return Err(Error::invalid_argument(format!(
-                "cannot merge KLL sketches with different m values: expected 
{}, got {}",
-                self.m, other.m
-            )));
-        }
-
+    /// Panics without modifying the sketch if the combined stream weight 
would exceed [`u64::MAX`].
+    pub fn merge(&mut self, other: &KllSketch<T>) {
         if other.is_empty() {
-            return Ok(());
+            return;
         }
-        let final_n = self.n.checked_add(other.n).ok_or_else(|| {
-            Error::invalid_argument(format!(
-                "combined stream weight exceeds {}: left {}, right {}",
-                u64::MAX,
-                self.n,
-                other.n
-            ))
-        })?;
+        let final_n = self
+            .n
+            .checked_add(other.n)
+            .expect("total stream weight overflow");
 
         self.update_min_max_from_other(other);
 
@@ -224,7 +211,6 @@ impl<T: Clone + Ord> KllSketch<T> {
             self.n,
             "total weight does not match n"
         );
-        Ok(())
     }
 
     /// Returns the normalized rank of the given item.
@@ -423,7 +409,7 @@ fn serialize_with_serde<T: KllValue + Ord>(sketch: 
&KllSketch<T>) -> Vec<u8> {
     bytes.write_u8(Family::KLL.id);
     bytes.write_u8(flags);
     bytes.write_u16_le(sketch.k);
-    bytes.write_u8(sketch.m);
+    bytes.write_u8(DEFAULT_M);
     bytes.write_u8(0);
 
     if is_empty {
@@ -563,7 +549,7 @@ fn deserialize_with_serde<T: KllValue + Ord>(bytes: &[u8]) 
-> Result<KllSketch<T
         )));
     }
 
-    let capacity = total_capacity(k, m, num_levels);
+    let capacity = total_capacity(k, num_levels);
     let mut level_offsets = Vec::with_capacity(num_levels + 1);
     if !is_single_item {
         for _ in 0..num_levels {
@@ -705,10 +691,9 @@ impl<T: Clone + Ord> KllSketch<T> {
         is_level_zero_sorted: bool,
     ) -> Self {
         let num_retained = levels.iter().map(Vec::len).sum();
-        let capacity = total_capacity(k, DEFAULT_M, levels.len()) as usize;
+        let capacity = total_capacity(k, levels.len()) as usize;
         Self {
             k,
-            m: DEFAULT_M,
             min_k,
             n,
             num_retained,
@@ -828,14 +813,14 @@ impl<T: Clone + Ord> KllSketch<T> {
         let num_levels = self.levels.len();
         for level in 0..num_levels {
             let pop = self.levels[level].len() as u32;
-            let cap = level_capacity(self.k, num_levels, level, self.m);
+            let cap = level_capacity(self.k, num_levels, level);
             if pop >= cap {
                 return level;
             }
         }
         panic!(
-            "KLL sketch has {}/{} retained items but no level reached its 
compaction capacity (k {}, m {}, levels {num_levels})",
-            self.num_retained, self.capacity, self.k, self.m
+            "KLL sketch has {}/{} retained items but no level reached its 
compaction capacity (k {}, levels {num_levels})",
+            self.num_retained, self.capacity, self.k
         );
     }
 
@@ -862,13 +847,13 @@ impl<T: Clone + Ord> KllSketch<T> {
             };
         }
 
-        self.levels = general_compress(work_levels, self.k, self.m, 
self.is_level_zero_sorted);
+        self.levels = general_compress(work_levels, self.k, 
self.is_level_zero_sorted);
         self.refresh_capacity_state();
     }
 
     fn refresh_capacity_state(&mut self) {
         self.num_retained = self.levels.iter().map(Vec::len).sum();
-        self.capacity = total_capacity(self.k, self.m, self.levels.len()) as 
usize;
+        self.capacity = total_capacity(self.k, self.levels.len()) as usize;
     }
 
     fn levels_weight(&self) -> u64 {
@@ -1049,12 +1034,11 @@ fn merge_sorted_vec<T: Clone + Ord>(left: Vec<T>, 
right: Vec<T>) -> Vec<T> {
 fn general_compress<T: Clone + Ord>(
     mut levels_in: Vec<Vec<T>>,
     k: u16,
-    m: u8,
     is_level_zero_sorted: bool,
 ) -> Vec<Vec<T>> {
     let mut current_num_levels = levels_in.len();
     let mut current_item_count: usize = levels_in.iter().map(|level| 
level.len()).sum();
-    let mut target_item_count = total_capacity(k, m, current_num_levels) as 
usize;
+    let mut target_item_count = total_capacity(k, current_num_levels) as usize;
     let mut levels_out = Vec::with_capacity(current_num_levels + 1);
 
     let mut current_level = 0usize;
@@ -1064,7 +1048,7 @@ fn general_compress<T: Clone + Ord>(
         }
 
         let raw_pop = levels_in[current_level].len();
-        let cap = level_capacity(k, current_num_levels, current_level, m) as 
usize;
+        let cap = level_capacity(k, current_num_levels, current_level) as 
usize;
 
         if current_item_count < target_item_count || raw_pop < cap {
             levels_out.push(std::mem::take(&mut levels_in[current_level]));
@@ -1097,7 +1081,7 @@ fn general_compress<T: Clone + Ord>(
 
             if current_level == current_num_levels - 1 {
                 current_num_levels += 1;
-                target_item_count += level_capacity(k, current_num_levels, 0, 
m) as usize;
+                target_item_count += level_capacity(k, current_num_levels, 0) 
as usize;
                 if levels_in.len() < current_num_levels + 1 {
                     levels_in.resize_with(current_num_levels + 1, Vec::new);
                 }
diff --git a/tests-integration/tests/countmin_test/sketch.rs 
b/tests-integration/tests/countmin_test/sketch.rs
index 86326c2..b908904 100644
--- a/tests-integration/tests/countmin_test/sketch.rs
+++ b/tests-integration/tests/countmin_test/sketch.rs
@@ -225,7 +225,7 @@ fn test_update_and_bounds_with_scaling() {
         estimate + (eps * sketch.total_weight() as f64) as u64
     );
 
-    sketch.decay(0.5);
+    sketch.decay(0.5).unwrap();
     let estimate = sketch.estimate("x");
     let upper = sketch.upper_bound("x");
     let lower = sketch.lower_bound("x");
@@ -289,7 +289,7 @@ fn test_decay() {
     }
 
     const FACTOR: f64 = 0.5;
-    sketch.decay(FACTOR);
+    sketch.decay(FACTOR).unwrap();
 
     for i in 0..1000usize {
         let expected = ((i as f64) * FACTOR).floor() as u64;
@@ -311,7 +311,7 @@ fn test_decay_preserves_large_integer_precision() {
         ] {
             let mut sketch = CountMinSketch::<u64>::new(3, 128).unwrap();
             sketch.update_with_weight("item", weight);
-            sketch.decay(factor);
+            sketch.decay(factor).unwrap();
             assert_eq!(
                 sketch.total_weight(),
                 expected,
@@ -334,7 +334,7 @@ fn decay_truncates_the_exact_binary_product() {
     ] {
         let mut sketch = CountMinSketch::<u64>::new(3, 128).unwrap();
         sketch.update_with_weight("item", weight);
-        sketch.decay(factor);
+        sketch.decay(factor).unwrap();
         assert_eq!(sketch.total_weight(), expected);
         assert_eq!(sketch.estimate("item"), expected);
     }
@@ -349,10 +349,10 @@ fn decay_identity_and_halving_preserve_the_whole_sketch() 
{
         }
 
         let mut decayed = sketch.clone();
-        decayed.decay(1.0);
+        decayed.decay(1.0).unwrap();
         assert_eq!(sketch_snapshot(&decayed), sketch_snapshot(&sketch));
 
-        decayed.decay(0.5);
+        decayed.decay(0.5).unwrap();
         sketch.halve();
         assert_eq!(sketch_snapshot(&decayed), sketch_snapshot(&sketch));
     }
@@ -363,6 +363,34 @@ fn decay_identity_and_halving_preserve_the_whole_sketch() {
     check([u64::MAX / 2, u64::MAX / 4, 1]);
 }
 
+#[test]
+fn decay_rejects_invalid_factors_without_modifying_sketch() {
+    for weight in [0u64, 100] {
+        let mut sketch = CountMinSketch::<u64>::new(3, 128).unwrap();
+        if weight > 0 {
+            sketch.update_with_weight("item", weight);
+        }
+        let before = sketch.clone();
+        for factor in [
+            f64::NAN,
+            0.0,
+            -0.0,
+            -0.5,
+            1.0_f64.next_up(),
+            f64::INFINITY,
+            f64::NEG_INFINITY,
+        ] {
+            let error = sketch.decay(factor).unwrap_err();
+            assert_eq!(
+                error.kind(),
+                ErrorKind::InvalidArgument,
+                "factor={factor:?}"
+            );
+            assert_eq!(sketch_snapshot(&sketch), sketch_snapshot(&before));
+        }
+    }
+}
+
 #[test]
 fn test_merge() {
     let mut left = CountMinSketch::<i64>::new(3, 64).unwrap();
diff --git a/tests-integration/tests/kll_test/core.rs 
b/tests-integration/tests/kll_test/core.rs
index 381301b..4748a99 100644
--- a/tests-integration/tests/kll_test/core.rs
+++ b/tests-integration/tests/kll_test/core.rs
@@ -96,17 +96,15 @@ fn weight_overflow_preserves_state() {
     let mut sketch = one.clone();
     // Doubling and adding one reaches the exact limit through valid public 
operations.
     for _ in 0..63 {
-        sketch.merge(&sketch.clone()).unwrap();
+        sketch.merge(&sketch.clone());
         sketch.update(0);
     }
     assert_eq!(sketch.total_weight(), u64::MAX);
     let before = sketch.serialize();
 
+    sketch.merge(&KllSketch::new(8).unwrap());
     assert!(catch_unwind(AssertUnwindSafe(|| sketch.update(1))).is_err());
     assert!(sketch.serialize() == before, "overflow changed the sketch");
-    assert_eq!(
-        sketch.merge(&one).unwrap_err().kind(),
-        ErrorKind::InvalidArgument
-    );
+    assert!(catch_unwind(AssertUnwindSafe(|| sketch.merge(&one))).is_err());
     assert!(sketch.serialize() == before, "overflow changed the sketch");
 }
diff --git a/tests-integration/tests/kll_test/merge.rs 
b/tests-integration/tests/kll_test/merge.rs
index 24797a5..d91437a 100644
--- a/tests-integration/tests/kll_test/merge.rs
+++ b/tests-integration/tests/kll_test/merge.rs
@@ -27,7 +27,7 @@ fn merge_preserves_weight_extrema_and_query_invariants() {
         right.update(19_999 - item);
     }
 
-    left.merge(&right).unwrap();
+    left.merge(&right);
 
     assert_eq!(left.total_weight(), 20_000);
     assert_eq!(left.min_item(), Some(&0));
@@ -49,7 +49,7 @@ fn merge_tracks_the_smallest_estimation_k() {
         right.update(20_000 - item);
     }
 
-    left.merge(&right).unwrap();
+    left.merge(&right);
 
     assert_eq!(left.min_k(), right.min_k());
     assert_eq!(left.normalized_rank_error(), right.normalized_rank_error());
@@ -65,7 +65,7 @@ fn merging_an_empty_lower_k_sketch_does_not_change_accuracy() 
{
     let empty = KllSketch::<i64>::new(128).unwrap();
     let rank_error = sketch.normalized_rank_error();
 
-    sketch.merge(&empty).unwrap();
+    sketch.merge(&empty);
 
     assert_eq!(sketch.total_weight(), 10_000);
     assert_eq!(sketch.normalized_rank_error(), rank_error);
@@ -78,7 +78,7 @@ fn merge_updates_extrema_from_either_side() {
     first.update(1);
     second.update(2);
 
-    second.merge(&first).unwrap();
+    second.merge(&first);
 
     assert_eq!(second.min_item(), Some(&1));
     assert_eq!(second.max_item(), Some(&2));
diff --git a/tests-integration/tests/kll_test/query.rs 
b/tests-integration/tests/kll_test/query.rs
index ac100e1..866d3bd 100644
--- a/tests-integration/tests/kll_test/query.rs
+++ b/tests-integration/tests/kll_test/query.rs
@@ -61,7 +61,7 @@ fn quantile_endpoints_with_large_stream_weight() {
     let mut sketch = KllSketch::<i64>::new(8).unwrap();
     sketch.update(0);
     for _ in 0..53 {
-        sketch.merge(&sketch.clone()).unwrap();
+        sketch.merge(&sketch.clone());
     }
     sketch.update(1);
     assert_eq!(sketch.total_weight(), (1 << 53) + 1);
diff --git a/tests-integration/tests/serde_tests/frequencies.rs 
b/tests-integration/tests/serde_tests/frequencies.rs
index e8508bf..e9370ea 100644
--- a/tests-integration/tests/serde_tests/frequencies.rs
+++ b/tests-integration/tests/serde_tests/frequencies.rs
@@ -221,6 +221,37 @@ fn 
test_deserialize_rejects_counters_exceeding_stream_weight() {
     }
 }
 
+#[test]
+fn test_deserialize_rejects_zero_item_weight() {
+    let mut sketch = FrequentItemsSketch::<i64>::new(32).unwrap();
+    sketch.update_with_weight(1, 5);
+    let mut corrupt = sketch.serialize();
+    corrupt[32..40].fill(0);
+    let error = FrequentItemsSketch::<i64>::deserialize(&corrupt).unwrap_err();
+    assert_eq!(error.kind(), ErrorKind::InvalidData);
+}
+
+#[test]
+fn test_deserialize_rejects_weights_and_offset_exceeding_stream_weight() {
+    let mut active = FrequentItemsSketch::<i64>::new(32).unwrap();
+    active.update_with_weight(1, 3);
+    active.update_with_weight(2, 4);
+    let mut active_corrupt = active.serialize();
+    active_corrupt[24..32].copy_from_slice(&1u64.to_le_bytes());
+
+    let mut purged = FrequentItemsSketch::<i64>::new(32).unwrap();
+    for item in 0..=(32 * 3 / 4) {
+        purged.update(item);
+    }
+    let mut purged_corrupt = purged.serialize();
+    purged_corrupt[24..32].copy_from_slice(&(purged.total_weight() + 
1).to_le_bytes());
+
+    for corrupt in [active_corrupt, purged_corrupt] {
+        let error = 
FrequentItemsSketch::<i64>::deserialize(&corrupt).unwrap_err();
+        assert_eq!(error.kind(), ErrorKind::InvalidData);
+    }
+}
+
 #[test]
 fn test_deserialize_empty_legacy_flags() {
     let mut bytes = FrequentItemsSketch::<i64>::new(256).unwrap().serialize();


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to