Add missing files

fuzz/fuzz_targets/local_nb/bulk_consume.rs

@@ -0,0 +1,49 @@
+#![no_main]
+
+use std::num::NonZeroUsize;
+
+use libfuzzer_sys::fuzz_target;
+use ufotofu::sync::{consumer::TestConsumer, BulkConsumer, Consumer};
+
+fuzz_target!(
+    |data: (TestConsumer<u16, u16, u16>, Box<[u16]>, Box<[NonZeroUsize]>)| {
+        smol::block_on(async {
+            let (mut con, items, slice_lengths) = data;
+            let mut control = con.clone();
+
+            // Pit individual consume calls against bulk consume calls, assert equality of the results and the consumer states.
+
+            let mut consumed_so_far = 0;
+            let mut slice_length_index = 0;
+
+            while slice_length_index < slice_lengths.len() && items[consumed_so_far..].len() > 0 {
+                let slice_length: usize = core::cmp::min(
+                    slice_lengths[slice_length_index].into(),
+                    items.len() - consumed_so_far,
+                );
+
+                if slice_length == 0 {
+                    break;
+                }
+
+                match con.bulk_consume(&items[consumed_so_far..consumed_so_far + slice_length]) {
+                    Ok(num_consumed) => {
+                        for _ in 0..num_consumed {
+                            assert!(control.consume(items[consumed_so_far]).is_ok());
+                            consumed_so_far += 1;
+                        }
+                    }
+                    Err(err) => {
+                        assert_eq!(err, control.consume(items[consumed_so_far]).unwrap_err());
+                        break;
+                    }
+                }
+
+                slice_length_index += 1;
+                assert_eq!(con, control);
+            }
+
+            assert_eq!(con, control);
+        });
+    }
+);

fuzz/fuzz_targets/local_nb/bulk_consume_full_slice.rs

@@ -0,0 +1,17 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use ufotofu::sync::{consumer::TestConsumer, BulkConsumer, Consumer};
+
+fuzz_target!(|data: (TestConsumer<u16, u16, u16>, Box<[u16]>)| {
+    smol::block_on(async {
+        let (mut con, items) = data;
+        let mut control = con.clone();
+
+        assert_eq!(
+            con.bulk_consume_full_slice(&items[..]),
+            control.consume_full_slice(&items[..])
+        );
+        assert_eq!(con, control);
+    });
+});

fuzz/fuzz_targets/local_nb/consume_full_slice.rs

@@ -0,0 +1,29 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use ufotofu::{
+    common::errors::ConsumeFullSliceError,
+    local_nb::{consumer::TestConsumer, Consumer},
+};
+
+fuzz_target!(|data: (TestConsumer<u16, u16, u16>, Box<[u16]>)| {
+    smol::block_on(async {
+        let (mut con, items) = data;
+
+        let expected_err = con.peek_error().unwrap().clone();
+
+        match con.consume_full_slice(&items[..]).await {
+            Ok(()) => {
+                assert!(!con.did_error());
+                assert_eq!(con.consumed(), &items[..]);
+                assert!(con.final_consumed().is_none());
+            }
+            Err(ConsumeFullSliceError { consumed, reason }) => {
+                assert!(con.did_error());
+                assert_eq!(reason, expected_err);
+                assert_eq!(con.consumed(), &items[..consumed]);
+                assert!(con.final_consumed().is_none());
+            }
+        }
+    })
+});

fuzz/fuzz_targets/sync/bulk_consume.rs

@@ -0,0 +1,47 @@
+#![no_main]
+
+use std::num::NonZeroUsize;
+
+use libfuzzer_sys::fuzz_target;
+use ufotofu::sync::{consumer::TestConsumer, BulkConsumer, Consumer};
+
+fuzz_target!(
+    |data: (TestConsumer<u16, u16, u16>, Box<[u16]>, Box<[NonZeroUsize]>)| {
+        let (mut con, items, slice_lengths) = data;
+        let mut control = con.clone();
+
+        // Pit individual consume calls against bulk consume calls, assert equality of the results and the consumer states.
+
+        let mut consumed_so_far = 0;
+        let mut slice_length_index = 0;
+
+        while slice_length_index < slice_lengths.len() && items[consumed_so_far..].len() > 0 {
+            let slice_length: usize = core::cmp::min(
+                slice_lengths[slice_length_index].into(),
+                items.len() - consumed_so_far,
+            );
+
+            if slice_length == 0 {
+                break;
+            }
+
+            match con.bulk_consume(&items[consumed_so_far..consumed_so_far + slice_length]) {
+                Ok(num_consumed) => {
+                    for _ in 0..num_consumed {
+                        assert!(control.consume(items[consumed_so_far]).is_ok());
+                        consumed_so_far += 1;
+                    }
+                }
+                Err(err) => {
+                    assert_eq!(err, control.consume(items[consumed_so_far]).unwrap_err());
+                    break;
+                }
+            }
+
+            slice_length_index += 1;
+            assert_eq!(con, control);
+        }
+
+        assert_eq!(con, control);
+    }
+);

fuzz/fuzz_targets/sync/bulk_consume_full_slice.rs

@@ -0,0 +1,15 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use ufotofu::sync::{consumer::TestConsumer, BulkConsumer, Consumer};
+
+fuzz_target!(|data: (TestConsumer<u16, u16, u16>, Box<[u16]>)| {
+    let (mut con, items) = data;
+    let mut control = con.clone();
+
+    assert_eq!(
+        con.bulk_consume_full_slice(&items[..]),
+        control.consume_full_slice(&items[..])
+    );
+    assert_eq!(con, control);
+});

fuzz/fuzz_targets/sync/consume_full_slice.rs

@@ -0,0 +1,27 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use ufotofu::{
+    common::errors::ConsumeFullSliceError,
+    sync::{consumer::TestConsumer, Consumer},
+};
+
+fuzz_target!(|data: (TestConsumer<u16, u16, u16>, Box<[u16]>)| {
+    let (mut con, items) = data;
+
+    let expected_err = con.peek_error().unwrap().clone();
+
+    match con.consume_full_slice(&items[..]) {
+        Ok(()) => {
+            assert!(!con.did_error());
+            assert_eq!(con.consumed(), &items[..]);
+            assert!(con.final_consumed().is_none());
+        }
+        Err(ConsumeFullSliceError { consumed, reason }) => {
+            assert!(con.did_error());
+            assert_eq!(reason, expected_err);
+            assert_eq!(con.consumed(), &items[..consumed]);
+            assert!(con.final_consumed().is_none());
+        }
+    }
+});