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]