From b63393a81275cca2fd90b952041b06d551706faf Mon Sep 17 00:00:00 2001 From: "Martin Tomka (from Dev Box)" Date: Fri, 13 Nov 2026 15:51:14 +0100 Subject: [PATCH 1/7] test: exercise batch 2 packages through public APIs Move reachable unit tests in arty_io_host, arty_macros_impl, and bytesbuf to integration targets. Keep private-path tests with rationale. Audit arty_macros and arty_tokio without changing them. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- crates/arty_io_host/src/driver_host.rs | 77 -- crates/arty_io_host/src/runtime.rs | 1 + crates/arty_io_host/src/telemetry.rs | 1 + .../arty_io_host/tests/context_reentrancy.rs | 104 ++ crates/arty_macros_impl/src/lib.rs | 675 +--------- crates/arty_macros_impl/tests/expansion.rs | 697 ++++++++++ crates/bytesbuf/Cargo.toml | 4 + crates/bytesbuf/src/buf.rs | 1143 +--------------- crates/bytesbuf/src/buf_put.rs | 224 +--- crates/bytesbuf/src/buf_writer.rs | 132 -- crates/bytesbuf/src/bytes_compat/buf.rs | 49 - .../bytesbuf/src/bytes_compat/from_bytes.rs | 49 +- crates/bytesbuf/src/bytes_compat/to_bytes.rs | 82 -- crates/bytesbuf/src/bytes_compat/view.rs | 62 - crates/bytesbuf/src/lib.rs | 3 - crates/bytesbuf/src/mem/block_ref.rs | 155 +-- crates/bytesbuf/src/mem/callback_memory.rs | 143 -- crates/bytesbuf/src/mem/global.rs | 245 +--- crates/bytesbuf/src/mem/memory.rs | 47 - crates/bytesbuf/src/mem/opaque_memory.rs | 68 - .../bytesbuf/src/mem/testing/fixed_block.rs | 36 - .../bytesbuf/src/mem/testing/transparent.rs | 52 - crates/bytesbuf/src/memory_guard.rs | 1 + crates/bytesbuf/src/span.rs | 1 + crates/bytesbuf/src/span_builder.rs | 1 + crates/bytesbuf/src/telemetry.rs | 1 + crates/bytesbuf/src/vec.rs | 59 +- crates/bytesbuf/src/view.rs | 1050 +-------------- crates/bytesbuf/src/view_get.rs | 270 ---- crates/bytesbuf/src/view_read.rs | 89 -- crates/bytesbuf/tests/public_api.rs | 54 + crates/bytesbuf/tests/public_api/buf.rs | 1155 +++++++++++++++++ crates/bytesbuf/tests/public_api/buf_put.rs | 228 ++++ .../bytesbuf/tests/public_api/buf_writer.rs | 125 ++ .../tests/public_api/bytes_compat_buf.rs | 49 + .../public_api/bytes_compat_from_bytes.rs | 54 + .../tests/public_api/bytes_compat_to_bytes.rs | 80 ++ .../tests/public_api/bytes_compat_view.rs | 63 + .../tests/public_api/mem_block_ref.rs | 208 +++ .../tests/public_api/mem_callback_memory.rs | 142 ++ .../bytesbuf/tests/public_api/mem_global.rs | 246 ++++ .../bytesbuf/tests/public_api/mem_memory.rs | 47 + .../tests/public_api/mem_opaque_memory.rs | 66 + .../public_api/mem_testing_fixed_block.rs | 36 + .../public_api/mem_testing_transparent.rs | 52 + crates/bytesbuf/tests/public_api/vec.rs | 63 + crates/bytesbuf/tests/public_api/view.rs | 1026 +++++++++++++++ crates/bytesbuf/tests/public_api/view_get.rs | 272 ++++ crates/bytesbuf/tests/public_api/view_read.rs | 89 ++ .../support/system_memory.rs} | 0 50 files changed, 4876 insertions(+), 4700 deletions(-) create mode 100644 crates/arty_io_host/tests/context_reentrancy.rs create mode 100644 crates/arty_macros_impl/tests/expansion.rs create mode 100644 crates/bytesbuf/tests/public_api.rs create mode 100644 crates/bytesbuf/tests/public_api/buf.rs create mode 100644 crates/bytesbuf/tests/public_api/buf_put.rs create mode 100644 crates/bytesbuf/tests/public_api/buf_writer.rs create mode 100644 crates/bytesbuf/tests/public_api/bytes_compat_buf.rs create mode 100644 crates/bytesbuf/tests/public_api/bytes_compat_from_bytes.rs create mode 100644 crates/bytesbuf/tests/public_api/bytes_compat_to_bytes.rs create mode 100644 crates/bytesbuf/tests/public_api/bytes_compat_view.rs create mode 100644 crates/bytesbuf/tests/public_api/mem_block_ref.rs create mode 100644 crates/bytesbuf/tests/public_api/mem_callback_memory.rs create mode 100644 crates/bytesbuf/tests/public_api/mem_global.rs create mode 100644 crates/bytesbuf/tests/public_api/mem_memory.rs create mode 100644 crates/bytesbuf/tests/public_api/mem_opaque_memory.rs create mode 100644 crates/bytesbuf/tests/public_api/mem_testing_fixed_block.rs create mode 100644 crates/bytesbuf/tests/public_api/mem_testing_transparent.rs create mode 100644 crates/bytesbuf/tests/public_api/vec.rs create mode 100644 crates/bytesbuf/tests/public_api/view.rs create mode 100644 crates/bytesbuf/tests/public_api/view_get.rs create mode 100644 crates/bytesbuf/tests/public_api/view_read.rs rename crates/bytesbuf/{src/testing.rs => tests/support/system_memory.rs} (100%) diff --git a/crates/arty_io_host/src/driver_host.rs b/crates/arty_io_host/src/driver_host.rs index 0086a01f7e..16f3505a55 100644 --- a/crates/arty_io_host/src/driver_host.rs +++ b/crates/arty_io_host/src/driver_host.rs @@ -374,80 +374,3 @@ impl Drop for DriverHost { self.shutdown_drivers(); } } - -#[cfg(test)] -#[cfg_attr(coverage_nightly, coverage(off))] -mod tests { - use std::task::Waker; - - use arty_io_core::{Cycle, Driver, DriverError, DriverOptions, IoContext}; - use observed::Sink; - use thread_aware::{Thread, ThreadAware, ThreadBuilder}; - - use crate::IoRuntime; - - #[derive(Clone)] - struct TestContext; - - impl ThreadAware for TestContext { - fn relocate(&mut self, _source: Option<&Thread>, _destination: &Thread) {} - } - - impl IoContext for TestContext { - type ContextOptions = (); - type Driver = TestDriver; - - fn new((): Self::ContextOptions) -> Self { - Self - } - - fn driver(&mut self, _options: DriverOptions) -> Result { - Ok(TestDriver) - } - } - - struct TestDriver; - - impl Driver for TestDriver { - fn waker(&self) -> Waker { - Waker::noop().clone() - } - - fn execute_cycle(&mut self, _cycle: &mut Cycle) -> Result<(), DriverError> { - Ok(()) - } - - fn shutdown(self) -> Result<(), DriverError> { - Ok(()) - } - } - - #[test] - fn nested_context_retrieval_is_rejected_during_initialization() { - let thread = ThreadBuilder::default().build(std::thread::current().id()); - let runtime = IoRuntime::new(Sink::noop()); - let host = runtime.driver_host(thread, Waker::noop().clone()).unwrap(); - host.initializing.set(true); - - let Err(error) = host.context::(()) else { - panic!("nested context retrieval should fail"); - }; - - assert_eq!(error.to_string(), "I/O context retrieval cannot be nested during initialization"); - } - - #[test] - fn context_retrieval_is_rejected_while_drivers_are_borrowed() { - let thread = ThreadBuilder::default().build(std::thread::current().id()); - let runtime = IoRuntime::new(Sink::noop()); - let host = runtime.driver_host(thread, Waker::noop().clone()).unwrap(); - let drivers = host.drivers.borrow_mut(); - - let Err(error) = host.context::(()) else { - panic!("context retrieval should fail while drivers are borrowed"); - }; - assert_eq!(error.to_string(), "I/O context retrieval cannot overlap driver cycle execution"); - drop(drivers); - host.context::(()).unwrap(); - } -} diff --git a/crates/arty_io_host/src/runtime.rs b/crates/arty_io_host/src/runtime.rs index 9c6fe1e089..1ea06acc37 100644 --- a/crates/arty_io_host/src/runtime.rs +++ b/crates/arty_io_host/src/runtime.rs @@ -254,6 +254,7 @@ impl IoRuntime { #[cfg(test)] #[cfg_attr(coverage_nightly, coverage(off))] mod tests { + // The public API cannot pause both resolutions between slot lookup and initialization. use std::any::TypeId; use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::{Arc, Barrier}; diff --git a/crates/arty_io_host/src/telemetry.rs b/crates/arty_io_host/src/telemetry.rs index ec639a1e9e..52c0e3cdf6 100644 --- a/crates/arty_io_host/src/telemetry.rs +++ b/crates/arty_io_host/src/telemetry.rs @@ -91,6 +91,7 @@ pub(crate) struct IoDriverShutdownFailed { #[cfg(test)] #[cfg_attr(coverage_nightly, coverage(off))] mod tests { + // These assertions inspect private classified values before an event emits them. use arty_io_core::{DriverError, DriverRole}; use super::{IoDriverErrorMessage, IoDriverRoleLabel}; diff --git a/crates/arty_io_host/tests/context_reentrancy.rs b/crates/arty_io_host/tests/context_reentrancy.rs new file mode 100644 index 0000000000..48b2440e54 --- /dev/null +++ b/crates/arty_io_host/tests/context_reentrancy.rs @@ -0,0 +1,104 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Context retrieval during provider callbacks. + +use std::cell::RefCell; +use std::rc::Rc; +use std::sync::{Arc, Mutex}; +use std::task::Waker; +use std::time::Duration; + +use arty_io_core::{Cycle, Driver, DriverError, DriverOptions, IoContext}; +use arty_io_host::{DriverHost, IoRuntime}; +use observed::Sink; +use thread_aware::{Thread, ThreadAware, ThreadBuilder}; + +thread_local! { + static HOST: RefCell>> = const { RefCell::new(None) }; +} + +#[derive(Clone)] +struct TestContext { + during_initialization: bool, + errors: Arc>>, +} + +impl ThreadAware for TestContext { + fn relocate(&mut self, _source: Option<&Thread>, _destination: &Thread) {} +} + +impl TestContext { + fn retrieve_again(&self) { + let host = HOST.with_borrow(|host| Rc::clone(host.as_ref().unwrap())); + let error = host.context::(self.clone()).err().unwrap(); + self.errors.lock().unwrap().push(error.to_string()); + } +} + +impl IoContext for TestContext { + type ContextOptions = Self; + type Driver = Self; + + fn new(options: Self::ContextOptions) -> Self { + options + } + + fn driver(&mut self, _options: DriverOptions) -> Result { + if self.during_initialization { + self.retrieve_again(); + } + Ok(self.clone()) + } +} + +impl Driver for TestContext { + fn waker(&self) -> Waker { + Waker::noop().clone() + } + + fn execute_cycle(&mut self, _cycle: &mut Cycle) -> Result<(), DriverError> { + self.retrieve_again(); + Ok(()) + } + + fn shutdown(self) -> Result<(), DriverError> { + Ok(()) + } +} + +fn exercise_retrieval(during_initialization: bool) -> Vec { + let thread = ThreadBuilder::default().build(std::thread::current().id()); + let runtime = IoRuntime::new(Sink::noop()); + let host = Rc::new(runtime.driver_host(thread, Waker::noop().clone()).unwrap()); + HOST.with_borrow_mut(|installed| *installed = Some(Rc::clone(&host))); + let errors = Arc::new(Mutex::new(Vec::new())); + let context = TestContext { + during_initialization, + errors: Arc::clone(&errors), + }; + + host.context::(context.clone()).unwrap(); + if !during_initialization { + host.execute_cycle(Duration::ZERO).unwrap(); + } + host.context::(context).unwrap(); + HOST.with_borrow_mut(Option::take); + errors.lock().unwrap().clone() +} + +#[test] +fn nested_context_retrieval_is_rejected_during_initialization() { + assert_eq!( + exercise_retrieval(true), + ["I/O context retrieval cannot be nested during initialization"] + ); +} + +#[test] +fn context_retrieval_is_rejected_while_drivers_are_borrowed() { + assert_eq!( + exercise_retrieval(false), + ["I/O context retrieval cannot overlap driver cycle execution"] + ); +} diff --git a/crates/arty_macros_impl/src/lib.rs b/crates/arty_macros_impl/src/lib.rs index 4c3662886a..d908647827 100644 --- a/crates/arty_macros_impl/src/lib.rs +++ b/crates/arty_macros_impl/src/lib.rs @@ -303,10 +303,8 @@ fn entrypoint(args: TokenStream, item: TokenStream, test: bool) -> TokenStream { } #[cfg(test)] -#[cfg_attr(coverage_nightly, coverage(off))] // Test scaffolding is not runtime behavior. mod tests { - use insta::assert_snapshot; - use testing_aids::render_expansion; + // Dependency discovery branches require private injected Cargo metadata. use super::*; @@ -324,675 +322,4 @@ mod tests { fn arty_path_supports_a_keyword_dependency_alias() { assert_eq!(arty_path_for(Some(FoundCrate::Name("type".to_owned()))).to_string(), ":: r#type"); } - - #[test] - fn main_preserves_visibility_and_return_type() { - let expansion = main( - TokenStream::new(), - quote! { - pub async fn main(cx: arty::task::Context) -> Result<(), Error> { - run(cx).await - } - }, - ); - assert_snapshot!(render_expansion(&expansion), @r#" - pub fn main() -> Result<(), Error> { - let __arty_runtime = ::arty::runtime::Runtime::new() - .expect("failed to create the runtime for the entry point"); - let __arty_result = __arty_runtime - .scheduler() - .block_on(async move |cx: arty::task::Context| { run(cx).await }); - let __arty_shutdown = __arty_runtime.stop(); - __arty_result - .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) - .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) - } - "#); - } - - #[test] - fn test_preserves_attributes() { - let expansion = test( - TokenStream::new(), - quote! { - #[should_panic(expected = "original payload")] - async fn fails(mut cx: arty::task::Context) { - fail(&mut cx).await; - } - }, - ); - assert_snapshot!(render_expansion(&expansion), @r#" - #[should_panic(expected = "original payload")] - #[::core::prelude::v1::test] - fn fails() { - let __arty_runtime = ::arty::runtime::Runtime::builder() - .monitor(::arty::runtime::MonitorPolicy::disabled()) - .build() - .expect("failed to create the runtime for the entry point"); - let __arty_result = __arty_runtime - .scheduler() - .block_on(async move |mut cx: arty::task::Context| { - fail(&mut cx).await; - }); - let __arty_shutdown = __arty_runtime.stop(); - __arty_result - .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) - .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) - } - "#); - } - - #[test] - fn workers_selects_exactly_the_literal_count() { - let expansion = main( - quote!(workers = 4usize, monitor = disabled), - quote! { - pub async fn run(cx: ::Context) -> AppResult { - run(cx).await - } - }, - ); - let expected = quote! { - pub fn run() -> AppResult { - let __arty_runtime = ::arty::runtime::Runtime::builder() - .workers(::arty::runtime::WorkersPolicy::exactly(4usize)) - .monitor(::arty::runtime::MonitorPolicy::disabled()) - .build() - .expect("failed to create the runtime for the entry point"); - let __arty_result = __arty_runtime - .scheduler() - .block_on(async move |cx: ::Context| { run(cx).await }); - let __arty_shutdown = __arty_runtime.stop(); - __arty_result - .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) - .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) - } - }; - assert_eq!(expansion.to_string(), expected.to_string()); - } - - #[test] - fn all_workers_selects_all_available_processors() { - let input = quote! { - async fn run(cx: Context) {} - }; - let main_expansion = main(quote!(workers = all), input.clone()); - let expected_main = quote! { - fn run() { - let __arty_runtime = ::arty::runtime::Runtime::builder() - .workers(::arty::runtime::WorkersPolicy::all()) - .build() - .expect("failed to create the runtime for the entry point"); - let __arty_result = __arty_runtime - .scheduler() - .block_on(async move |cx: Context| {}); - let __arty_shutdown = __arty_runtime.stop(); - __arty_result - .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) - .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) - } - }; - assert_eq!(main_expansion.to_string(), expected_main.to_string()); - - let test_expansion = test(quote!(workers = all), input); - let expected_test = quote! { - #[::core::prelude::v1::test] - fn run() { - let __arty_runtime = ::arty::runtime::Runtime::builder() - .workers(::arty::runtime::WorkersPolicy::all()) - .monitor(::arty::runtime::MonitorPolicy::disabled()) - .build() - .expect("failed to create the runtime for the entry point"); - let __arty_result = __arty_runtime - .scheduler() - .block_on(async move |cx: Context| {}); - let __arty_shutdown = __arty_runtime.stop(); - __arty_result - .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) - .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) - } - }; - assert_eq!(test_expansion.to_string(), expected_test.to_string()); - } - - #[test] - fn controlled_test_can_select_all_workers() { - let expansion = test( - quote!(workers = all), - quote! { - async fn run(cx: Context, time: ClockControl) {} - }, - ); - let expected = quote! { - #[::core::prelude::v1::test] - fn run() { - let __arty_clock_control = ::arty::runtime::__private::ClockControl::new(); - let __arty_runtime = ::arty::runtime::Runtime::builder() - .workers(::arty::runtime::WorkersPolicy::all()) - .monitor(::arty::runtime::MonitorPolicy::disabled()) - .clock(::core::clone::Clone::clone(&__arty_clock_control)) - .build() - .expect("failed to create the runtime for the entry point"); - let __arty_result = __arty_runtime - .scheduler() - .block_on(async move |cx: Context| { - let time: ClockControl = __arty_clock_control; - {} - }); - let __arty_shutdown = __arty_runtime.stop(); - __arty_result - .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) - .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) - } - }; - assert_eq!(expansion.to_string(), expected.to_string()); - } - - #[test] - fn controlled_test_shares_one_clock_and_preserves_qualified_types() { - let expansion = test( - quote!(monitor = enabled, workers = 1), - quote! { - #[ignore = "manual test"] - #[should_panic(expected = "original payload")] - async fn run(cx: ::Context, mut time: ::Control) { - run(cx, &mut time).await; - } - }, - ); - let expected = quote! { - #[ignore = "manual test"] - #[should_panic(expected = "original payload")] - #[::core::prelude::v1::test] - fn run() { - let __arty_clock_control = ::arty::runtime::__private::ClockControl::new(); - let __arty_runtime = ::arty::runtime::Runtime::builder() - .workers(::arty::runtime::WorkersPolicy::exactly(1)) - .monitor(::arty::runtime::MonitorPolicy::enabled()) - .clock(::core::clone::Clone::clone(&__arty_clock_control)) - .build() - .expect("failed to create the runtime for the entry point"); - let __arty_result = __arty_runtime - .scheduler() - .block_on(async move |cx: ::Context| { - let mut time: ::Control = __arty_clock_control; - { - run(cx, &mut time).await; - } - }); - let __arty_shutdown = __arty_runtime.stop(); - __arty_result - .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) - .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) - } - }; - assert_eq!(expansion.to_string(), expected.to_string()); - } - - #[test] - fn controlled_test_without_workers_uses_the_runtime_default() { - let expansion = test( - TokenStream::new(), - quote! { - async fn run(cx: Context, time: ClockControl) { - run(cx, time).await; - } - }, - ); - let expected = quote! { - #[::core::prelude::v1::test] - fn run() { - let __arty_clock_control = ::arty::runtime::__private::ClockControl::new(); - let __arty_runtime = ::arty::runtime::Runtime::builder() - .monitor(::arty::runtime::MonitorPolicy::disabled()) - .clock(::core::clone::Clone::clone(&__arty_clock_control)) - .build() - .expect("failed to create the runtime for the entry point"); - let __arty_result = __arty_runtime - .scheduler() - .block_on(async move |cx: Context| { - let time: ClockControl = __arty_clock_control; - { - run(cx, time).await; - } - }); - let __arty_shutdown = __arty_runtime.stop(); - __arty_result - .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) - .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) - } - }; - - assert_eq!(expansion.to_string(), expected.to_string()); - } - - #[test] - fn main_monitor_settings_are_forwarded_exactly() { - for (setting, policy) in [(quote!(enabled), quote!(enabled)), (quote!(disabled), quote!(disabled))] { - let expansion = main( - quote!(monitor = #setting), - quote! { - async fn run(cx: Context) {} - }, - ); - let expected = quote! { - fn run() { - let __arty_runtime = ::arty::runtime::Runtime::builder() - .monitor(::arty::runtime::MonitorPolicy::#policy()) - .build() - .expect("failed to create the runtime for the entry point"); - let __arty_result = __arty_runtime - .scheduler() - .block_on(async move |cx: Context| {}); - let __arty_shutdown = __arty_runtime.stop(); - __arty_result - .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) - .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) - } - }; - - assert_eq!(expansion.to_string(), expected.to_string(), "monitor = {setting}"); - } - } - - #[test] - fn test_monitor_settings_are_forwarded_exactly() { - for (setting, policy) in [(quote!(enabled), quote!(enabled)), (quote!(disabled), quote!(disabled))] { - let expansion = test( - quote!(monitor = #setting), - quote! { - async fn run(cx: Context) {} - }, - ); - let expected = quote! { - #[::core::prelude::v1::test] - fn run() { - let __arty_runtime = ::arty::runtime::Runtime::builder() - .monitor(::arty::runtime::MonitorPolicy::#policy()) - .build() - .expect("failed to create the runtime for the entry point"); - let __arty_result = __arty_runtime - .scheduler() - .block_on(async move |cx: Context| {}); - let __arty_shutdown = __arty_runtime.stop(); - __arty_result - .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) - .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) - } - }; - - assert_eq!(expansion.to_string(), expected.to_string(), "monitor = {setting}"); - } - } - - #[test] - fn main_panic_settings_are_forwarded_exactly() { - for (policy, constant) in [(quote!(shutdown), quote!(SHUTDOWN)), (quote!(ignore), quote!(IGNORE))] { - let expansion = main( - quote!(panic = #policy), - quote! { - async fn run(cx: Context) {} - }, - ); - let expected = quote! { - fn run() { - let __arty_runtime = ::arty::runtime::Runtime::builder() - .on(::arty::runtime::hook::Panic::#constant) - .build() - .expect("failed to create the runtime for the entry point"); - let __arty_result = __arty_runtime - .scheduler() - .block_on(async move |cx: Context| {}); - let __arty_shutdown = __arty_runtime.stop(); - __arty_result - .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) - .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) - } - }; - - assert_eq!(expansion.to_string(), expected.to_string(), "panic = {policy}"); - } - } - - #[test] - fn test_panic_settings_are_forwarded_exactly() { - for (policy, constant) in [(quote!(shutdown), quote!(SHUTDOWN)), (quote!(ignore), quote!(IGNORE))] { - let expansion = test( - quote!(panic = #policy), - quote! { - async fn run(cx: Context) {} - }, - ); - let expected = quote! { - #[::core::prelude::v1::test] - fn run() { - let __arty_runtime = ::arty::runtime::Runtime::builder() - .monitor(::arty::runtime::MonitorPolicy::disabled()) - .on(::arty::runtime::hook::Panic::#constant) - .build() - .expect("failed to create the runtime for the entry point"); - let __arty_result = __arty_runtime - .scheduler() - .block_on(async move |cx: Context| {}); - let __arty_shutdown = __arty_runtime.stop(); - __arty_result - .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) - .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) - } - }; - - assert_eq!(expansion.to_string(), expected.to_string(), "panic = {policy}"); - } - } - - #[test] - fn monitor_composes_independently_of_argument_order() { - for expand in [main, test] { - let input = quote! { - async fn run(cx: Context) {} - }; - let workers_first = expand(quote!(workers = 2, monitor = disabled), input.clone()); - let monitor_first = expand(quote!(monitor = disabled, workers = 2), input); - - assert_eq!(workers_first.to_string(), monitor_first.to_string()); - } - } - - #[test] - fn panic_composes_with_other_settings_independently_of_argument_order() { - for expand in [main, test] { - let input = quote! { - async fn run(cx: Context) {} - }; - let panic_last = expand(quote!(workers = 2, monitor = disabled, panic = ignore), input.clone()); - let panic_first = expand(quote!(panic = ignore, monitor = disabled, workers = 2), input); - - assert_eq!(panic_last.to_string(), panic_first.to_string()); - } - } - - #[test] - fn worker_literals_are_not_limited_to_the_macro_hosts_pointer_width() { - let forwarded = proc_macro2::TokenTree::Group(proc_macro2::Group::new(proc_macro2::Delimiter::None, quote!(2))); - for workers in [ - quote!(0), - quote!(0x0usize), - quote!(1), - quote!(0x10usize), - quote!(340282366920938463463374607431768211456), - TokenStream::from(forwarded), - ] { - let expansion = main( - quote!(workers = #workers), - quote! { - async fn run(cx: Context) {} - }, - ); - assert!(!expansion.to_string().contains("compile_error")); - } - } - - #[test] - fn worker_policy_unwraps_nested_expression_groups() { - for (mut value, expected) in [ - (parse_quote!(4usize), quote!(::arty::runtime::WorkersPolicy::exactly(4usize))), - (parse_quote!(all), quote!(::arty::runtime::WorkersPolicy::all())), - ] { - for _ in 0..2 { - value = Expr::Group(syn::ExprGroup { - attrs: Vec::new(), - group_token: syn::token::Group::default(), - expr: Box::new(value), - }); - } - - let policy = worker_policy(&value, "e!(::arty)).unwrap(); - assert_eq!(policy.to_string(), expected.to_string()); - } - } - - #[test] - fn invalid_worker_counts_report_errors() { - for workers in [ - quote!(-0), - quote!(-1), - quote!(-1usize), - quote!(-0x10), - quote!(1u32), - quote!(1.5), - quote!("2"), - quote!("ALL"), - quote!(""), - quote!("all"), - quote!(ALL), - quote!(module::all), - quote!(::all), - quote!(all::), - quote!(::all), - quote!(true), - quote!(COUNT), - quote!(1 + 1), - quote!(WorkersPolicy::all()), - ] { - for expand in [main, test] { - let expansion = expand( - quote!(workers = #workers), - quote! { - async fn run(cx: Context) {} - }, - ) - .to_string(); - assert!(expansion.contains("compile_error"), "workers = {workers}: {expansion}"); - assert!(expansion.contains("nonnegative integer literal"), "{expansion}"); - } - } - } - - #[test] - fn invalid_monitor_settings_report_errors() { - let expected = quote!(::core::compile_error! { "`monitor` must be the bare identifier `enabled` or `disabled`" }).to_string(); - for monitor in [ - quote!(true), - quote!(false), - quote!("enabled"), - quote!("disabled"), - quote!(automatic), - quote!(MonitorPolicy::enabled()), - quote!(::enabled), - ] { - for expand in [main, test] { - let expansion = expand( - quote!(monitor = #monitor), - quote! { - async fn run(cx: Context) {} - }, - ) - .to_string(); - - assert_eq!(expansion, expected, "monitor = {monitor}"); - } - } - } - - #[test] - fn duplicate_monitor_settings_report_errors() { - let expected = quote!(::core::compile_error! { "Duplicate field `monitor`" }).to_string(); - for expand in [main, test] { - let expansion = expand( - quote!(monitor = enabled, monitor = disabled), - quote! { - async fn run(cx: Context) {} - }, - ) - .to_string(); - - assert_eq!(expansion, expected); - } - } - - #[test] - fn invalid_panic_settings_report_errors() { - let expected = quote!(::core::compile_error! { "`panic` must be the bare identifier `shutdown` or `ignore`" }).to_string(); - for panic in [ - quote!(true), - quote!(false), - quote!("shutdown"), - quote!("ignore"), - quote!(continue), - quote!(abort), - quote!(Panic::shutdown()), - quote!(::shutdown), - ] { - for expand in [main, test] { - let expansion = expand( - quote!(panic = #panic), - quote! { - async fn run(cx: Context) {} - }, - ) - .to_string(); - - assert_eq!(expansion, expected, "panic = {panic}"); - } - } - } - - #[test] - fn duplicate_panic_settings_report_errors() { - let expected = quote!(::core::compile_error! { "Duplicate field `panic`" }).to_string(); - for expand in [main, test] { - let expansion = expand( - quote!(panic = shutdown, panic = ignore), - quote! { - async fn run(cx: Context) {} - }, - ) - .to_string(); - - assert_eq!(expansion, expected); - } - } - - #[test] - fn removed_configuration_options_are_rejected() { - for args in [quote!(builder = configure()), quote!(runtime_path = ::renamed)] { - for expand in [main, test] { - let expansion = expand( - args.clone(), - quote! { - async fn run(cx: Context) {} - }, - ) - .to_string(); - assert!(expansion.contains("compile_error"), "{expansion}"); - assert!(expansion.contains("Unknown field"), "{expansion}"); - } - } - } - - #[test] - fn injected_clock_requires_a_named_owned_second_test_parameter() { - for input in [ - quote!( - async fn run(cx: Context, _: ClockControl) {} - ), - quote!( - async fn run(cx: Context, control: &ClockControl) {} - ), - quote!( - async fn run(cx: Context, control: ClockControl, extra: ClockControl) {} - ), - quote!( - async fn run(cx: Context, cx: ClockControl) {} - ), - quote!( - async fn run(cx: Context, r#cx: ClockControl) {} - ), - ] { - for expand in [main, test] { - let expansion = expand(TokenStream::new(), input.clone()).to_string(); - assert!(expansion.starts_with(&input.to_string())); - assert!(expansion.contains("compile_error"), "{expansion}"); - } - } - let expansion = main( - TokenStream::new(), - quote!( - async fn run(cx: Context, control: ClockControl) {} - ), - ) - .to_string(); - assert!(expansion.contains("unexpected arguments")); - } - - #[test] - fn invalid_signatures_preserve_input_and_report_errors() { - let cases = [ - ( - quote!( - fn run(cx: Context) {} - ), - "function must be async", - ), - ( - quote!( - async fn run() {} - ), - "function must take an Arty task context argument", - ), - ( - quote!( - async fn run(_: Context) {} - ), - "argument must have an identifier", - ), - ( - quote!( - async fn run(cx: &Context) {} - ), - "arty::task::Context by value", - ), - ( - quote!( - async fn run(cx: Context, extra: ()) {} - ), - "unexpected arguments", - ), - ]; - for (input, message) in cases { - for expand in [main, test] { - let expansion = expand(TokenStream::new(), input.clone()).to_string(); - assert!(expansion.starts_with(&input.to_string())); - assert!(expansion.contains(message), "{expansion}"); - assert!(expansion.contains("compile_error")); - } - } - } - - #[test] - fn malformed_items_and_arguments_report_errors() { - for (args, input) in [ - (TokenStream::new(), quote!(not a function)), - ( - quote!(@), - quote!( - async fn run(cx: Context) {} - ), - ), - ( - quote!(unknown = 1), - quote!( - async fn run(cx: Context) {} - ), - ), - ( - quote!(workers = 1, workers = 2), - quote!( - async fn run(cx: Context) {} - ), - ), - ] { - assert!(main(args, input).to_string().contains("compile_error")); - } - } } diff --git a/crates/arty_macros_impl/tests/expansion.rs b/crates/arty_macros_impl/tests/expansion.rs new file mode 100644 index 0000000000..d78e6345d0 --- /dev/null +++ b/crates/arty_macros_impl/tests/expansion.rs @@ -0,0 +1,697 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use arty_macros_impl::{main, test}; +use insta::assert_snapshot; +use proc_macro2::{Delimiter, Group, TokenStream, TokenTree}; +use quote::quote; +use testing_aids::render_expansion; + +#[test] +fn main_preserves_visibility_and_return_type() { + let expansion = main( + TokenStream::new(), + quote! { + pub async fn main(cx: arty::task::Context) -> Result<(), Error> { + run(cx).await + } + }, + ); + assert_snapshot!(render_expansion(&expansion), @r#" + pub fn main() -> Result<(), Error> { + let __arty_runtime = ::arty::runtime::Runtime::new() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |cx: arty::task::Context| { run(cx).await }); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + "#); +} + +#[test] +fn test_preserves_attributes() { + let expansion = test( + TokenStream::new(), + quote! { + #[should_panic(expected = "original payload")] + async fn fails(mut cx: arty::task::Context) { + fail(&mut cx).await; + } + }, + ); + assert_snapshot!(render_expansion(&expansion), @r#" + #[should_panic(expected = "original payload")] + #[::core::prelude::v1::test] + fn fails() { + let __arty_runtime = ::arty::runtime::Runtime::builder() + .monitor(::arty::runtime::MonitorPolicy::disabled()) + .build() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |mut cx: arty::task::Context| { + fail(&mut cx).await; + }); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + "#); +} + +#[test] +fn workers_selects_exactly_the_literal_count() { + let expansion = main( + quote!(workers = 4usize, monitor = disabled), + quote! { + pub async fn run(cx: ::Context) -> AppResult { + run(cx).await + } + }, + ); + let expected = quote! { + pub fn run() -> AppResult { + let __arty_runtime = ::arty::runtime::Runtime::builder() + .workers(::arty::runtime::WorkersPolicy::exactly(4usize)) + .monitor(::arty::runtime::MonitorPolicy::disabled()) + .build() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |cx: ::Context| { run(cx).await }); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + }; + assert_eq!(expansion.to_string(), expected.to_string()); +} + +#[test] +fn all_workers_selects_all_available_processors() { + let input = quote! { + async fn run(cx: Context) {} + }; + let main_expansion = main(quote!(workers = all), input.clone()); + let expected_main = quote! { + fn run() { + let __arty_runtime = ::arty::runtime::Runtime::builder() + .workers(::arty::runtime::WorkersPolicy::all()) + .build() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |cx: Context| {}); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + }; + assert_eq!(main_expansion.to_string(), expected_main.to_string()); + + let test_expansion = test(quote!(workers = all), input); + let expected_test = quote! { + #[::core::prelude::v1::test] + fn run() { + let __arty_runtime = ::arty::runtime::Runtime::builder() + .workers(::arty::runtime::WorkersPolicy::all()) + .monitor(::arty::runtime::MonitorPolicy::disabled()) + .build() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |cx: Context| {}); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + }; + assert_eq!(test_expansion.to_string(), expected_test.to_string()); +} + +#[test] +fn controlled_test_can_select_all_workers() { + let expansion = test( + quote!(workers = all), + quote! { + async fn run(cx: Context, time: ClockControl) {} + }, + ); + let expected = quote! { + #[::core::prelude::v1::test] + fn run() { + let __arty_clock_control = ::arty::runtime::__private::ClockControl::new(); + let __arty_runtime = ::arty::runtime::Runtime::builder() + .workers(::arty::runtime::WorkersPolicy::all()) + .monitor(::arty::runtime::MonitorPolicy::disabled()) + .clock(::core::clone::Clone::clone(&__arty_clock_control)) + .build() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |cx: Context| { + let time: ClockControl = __arty_clock_control; + {} + }); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + }; + assert_eq!(expansion.to_string(), expected.to_string()); +} + +#[test] +fn controlled_test_shares_one_clock_and_preserves_qualified_types() { + let expansion = test( + quote!(monitor = enabled, workers = 1), + quote! { + #[ignore = "manual test"] + #[should_panic(expected = "original payload")] + async fn run(cx: ::Context, mut time: ::Control) { + run(cx, &mut time).await; + } + }, + ); + let expected = quote! { + #[ignore = "manual test"] + #[should_panic(expected = "original payload")] + #[::core::prelude::v1::test] + fn run() { + let __arty_clock_control = ::arty::runtime::__private::ClockControl::new(); + let __arty_runtime = ::arty::runtime::Runtime::builder() + .workers(::arty::runtime::WorkersPolicy::exactly(1)) + .monitor(::arty::runtime::MonitorPolicy::enabled()) + .clock(::core::clone::Clone::clone(&__arty_clock_control)) + .build() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |cx: ::Context| { + let mut time: ::Control = __arty_clock_control; + { + run(cx, &mut time).await; + } + }); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + }; + assert_eq!(expansion.to_string(), expected.to_string()); +} + +#[test] +fn controlled_test_without_workers_uses_the_runtime_default() { + let expansion = test( + TokenStream::new(), + quote! { + async fn run(cx: Context, time: ClockControl) { + run(cx, time).await; + } + }, + ); + let expected = quote! { + #[::core::prelude::v1::test] + fn run() { + let __arty_clock_control = ::arty::runtime::__private::ClockControl::new(); + let __arty_runtime = ::arty::runtime::Runtime::builder() + .monitor(::arty::runtime::MonitorPolicy::disabled()) + .clock(::core::clone::Clone::clone(&__arty_clock_control)) + .build() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |cx: Context| { + let time: ClockControl = __arty_clock_control; + { + run(cx, time).await; + } + }); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + }; + + assert_eq!(expansion.to_string(), expected.to_string()); +} + +#[test] +fn main_monitor_settings_are_forwarded_exactly() { + for (setting, policy) in [(quote!(enabled), quote!(enabled)), (quote!(disabled), quote!(disabled))] { + let expansion = main( + quote!(monitor = #setting), + quote! { + async fn run(cx: Context) {} + }, + ); + let expected = quote! { + fn run() { + let __arty_runtime = ::arty::runtime::Runtime::builder() + .monitor(::arty::runtime::MonitorPolicy::#policy()) + .build() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |cx: Context| {}); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + }; + + assert_eq!(expansion.to_string(), expected.to_string(), "monitor = {setting}"); + } +} + +#[test] +fn test_monitor_settings_are_forwarded_exactly() { + for (setting, policy) in [(quote!(enabled), quote!(enabled)), (quote!(disabled), quote!(disabled))] { + let expansion = test( + quote!(monitor = #setting), + quote! { + async fn run(cx: Context) {} + }, + ); + let expected = quote! { + #[::core::prelude::v1::test] + fn run() { + let __arty_runtime = ::arty::runtime::Runtime::builder() + .monitor(::arty::runtime::MonitorPolicy::#policy()) + .build() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |cx: Context| {}); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + }; + + assert_eq!(expansion.to_string(), expected.to_string(), "monitor = {setting}"); + } +} + +#[test] +fn main_panic_settings_are_forwarded_exactly() { + for (policy, constant) in [(quote!(shutdown), quote!(SHUTDOWN)), (quote!(ignore), quote!(IGNORE))] { + let expansion = main( + quote!(panic = #policy), + quote! { + async fn run(cx: Context) {} + }, + ); + let expected = quote! { + fn run() { + let __arty_runtime = ::arty::runtime::Runtime::builder() + .on(::arty::runtime::hook::Panic::#constant) + .build() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |cx: Context| {}); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + }; + + assert_eq!(expansion.to_string(), expected.to_string(), "panic = {policy}"); + } +} + +#[test] +fn test_panic_settings_are_forwarded_exactly() { + for (policy, constant) in [(quote!(shutdown), quote!(SHUTDOWN)), (quote!(ignore), quote!(IGNORE))] { + let expansion = test( + quote!(panic = #policy), + quote! { + async fn run(cx: Context) {} + }, + ); + let expected = quote! { + #[::core::prelude::v1::test] + fn run() { + let __arty_runtime = ::arty::runtime::Runtime::builder() + .monitor(::arty::runtime::MonitorPolicy::disabled()) + .on(::arty::runtime::hook::Panic::#constant) + .build() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |cx: Context| {}); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + }; + + assert_eq!(expansion.to_string(), expected.to_string(), "panic = {policy}"); + } +} + +#[test] +fn monitor_composes_independently_of_argument_order() { + for expand in [main, test] { + let input = quote! { + async fn run(cx: Context) {} + }; + let workers_first = expand(quote!(workers = 2, monitor = disabled), input.clone()); + let monitor_first = expand(quote!(monitor = disabled, workers = 2), input); + + assert_eq!(workers_first.to_string(), monitor_first.to_string()); + } +} + +#[test] +fn panic_composes_with_other_settings_independently_of_argument_order() { + for expand in [main, test] { + let input = quote! { + async fn run(cx: Context) {} + }; + let panic_last = expand(quote!(workers = 2, monitor = disabled, panic = ignore), input.clone()); + let panic_first = expand(quote!(panic = ignore, monitor = disabled, workers = 2), input); + + assert_eq!(panic_last.to_string(), panic_first.to_string()); + } +} + +#[test] +fn worker_literals_are_not_limited_to_the_macro_hosts_pointer_width() { + let forwarded = proc_macro2::TokenTree::Group(proc_macro2::Group::new(proc_macro2::Delimiter::None, quote!(2))); + for workers in [ + quote!(0), + quote!(0x0usize), + quote!(1), + quote!(0x10usize), + quote!(340282366920938463463374607431768211456), + TokenStream::from(forwarded), + ] { + let expansion = main( + quote!(workers = #workers), + quote! { + async fn run(cx: Context) {} + }, + ); + assert!(!expansion.to_string().contains("compile_error")); + } +} + +#[test] +fn worker_policy_unwraps_nested_expression_groups() { + for (value, expected) in [ + (quote!(4usize), quote!(::arty::runtime::WorkersPolicy::exactly(4usize))), + (quote!(all), quote!(::arty::runtime::WorkersPolicy::all())), + ] { + let value = TokenTree::Group(Group::new( + Delimiter::None, + TokenStream::from(TokenTree::Group(Group::new(Delimiter::None, value))), + )); + let expansion = main( + quote!(workers = #value), + quote!( + async fn run(cx: Context) {} + ), + ); + let expected = quote! { + fn run() { + let __arty_runtime = ::arty::runtime::Runtime::builder() + .workers(#expected) + .build() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |cx: Context| {}); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + }; + assert_eq!(expansion.to_string(), expected.to_string()); + } +} + +#[test] +fn invalid_worker_counts_report_errors() { + for workers in [ + quote!(-0), + quote!(-1), + quote!(-1usize), + quote!(-0x10), + quote!(1u32), + quote!(1.5), + quote!("2"), + quote!("ALL"), + quote!(""), + quote!("all"), + quote!(ALL), + quote!(module::all), + quote!(::all), + quote!(all::), + quote!(::all), + quote!(true), + quote!(COUNT), + quote!(1 + 1), + quote!(WorkersPolicy::all()), + ] { + for expand in [main, test] { + let expansion = expand( + quote!(workers = #workers), + quote! { + async fn run(cx: Context) {} + }, + ) + .to_string(); + assert!(expansion.contains("compile_error"), "workers = {workers}: {expansion}"); + assert!(expansion.contains("nonnegative integer literal"), "{expansion}"); + } + } +} + +#[test] +fn invalid_monitor_settings_report_errors() { + let expected = quote!(::core::compile_error! { "`monitor` must be the bare identifier `enabled` or `disabled`" }).to_string(); + for monitor in [ + quote!(true), + quote!(false), + quote!("enabled"), + quote!("disabled"), + quote!(automatic), + quote!(MonitorPolicy::enabled()), + quote!(::enabled), + ] { + for expand in [main, test] { + let expansion = expand( + quote!(monitor = #monitor), + quote! { + async fn run(cx: Context) {} + }, + ) + .to_string(); + + assert_eq!(expansion, expected, "monitor = {monitor}"); + } + } +} + +#[test] +fn duplicate_monitor_settings_report_errors() { + let expected = quote!(::core::compile_error! { "Duplicate field `monitor`" }).to_string(); + for expand in [main, test] { + let expansion = expand( + quote!(monitor = enabled, monitor = disabled), + quote! { + async fn run(cx: Context) {} + }, + ) + .to_string(); + + assert_eq!(expansion, expected); + } +} + +#[test] +fn invalid_panic_settings_report_errors() { + let expected = quote!(::core::compile_error! { "`panic` must be the bare identifier `shutdown` or `ignore`" }).to_string(); + for panic in [ + quote!(true), + quote!(false), + quote!("shutdown"), + quote!("ignore"), + quote!(continue), + quote!(abort), + quote!(Panic::shutdown()), + quote!(::shutdown), + ] { + for expand in [main, test] { + let expansion = expand( + quote!(panic = #panic), + quote! { + async fn run(cx: Context) {} + }, + ) + .to_string(); + + assert_eq!(expansion, expected, "panic = {panic}"); + } + } +} + +#[test] +fn duplicate_panic_settings_report_errors() { + let expected = quote!(::core::compile_error! { "Duplicate field `panic`" }).to_string(); + for expand in [main, test] { + let expansion = expand( + quote!(panic = shutdown, panic = ignore), + quote! { + async fn run(cx: Context) {} + }, + ) + .to_string(); + + assert_eq!(expansion, expected); + } +} + +#[test] +fn removed_configuration_options_are_rejected() { + for args in [quote!(builder = configure()), quote!(runtime_path = ::renamed)] { + for expand in [main, test] { + let expansion = expand( + args.clone(), + quote! { + async fn run(cx: Context) {} + }, + ) + .to_string(); + assert!(expansion.contains("compile_error"), "{expansion}"); + assert!(expansion.contains("Unknown field"), "{expansion}"); + } + } +} + +#[test] +fn injected_clock_requires_a_named_owned_second_test_parameter() { + for input in [ + quote!( + async fn run(cx: Context, _: ClockControl) {} + ), + quote!( + async fn run(cx: Context, control: &ClockControl) {} + ), + quote!( + async fn run(cx: Context, control: ClockControl, extra: ClockControl) {} + ), + quote!( + async fn run(cx: Context, cx: ClockControl) {} + ), + quote!( + async fn run(cx: Context, r#cx: ClockControl) {} + ), + ] { + for expand in [main, test] { + let expansion = expand(TokenStream::new(), input.clone()).to_string(); + assert!(expansion.starts_with(&input.to_string())); + assert!(expansion.contains("compile_error"), "{expansion}"); + } + } + let expansion = main( + TokenStream::new(), + quote!( + async fn run(cx: Context, control: ClockControl) {} + ), + ) + .to_string(); + assert!(expansion.contains("unexpected arguments")); +} + +#[test] +fn invalid_signatures_preserve_input_and_report_errors() { + let cases = [ + ( + quote!( + fn run(cx: Context) {} + ), + "function must be async", + ), + ( + quote!( + async fn run() {} + ), + "function must take an Arty task context argument", + ), + ( + quote!( + async fn run(_: Context) {} + ), + "argument must have an identifier", + ), + ( + quote!( + async fn run(cx: &Context) {} + ), + "arty::task::Context by value", + ), + ( + quote!( + async fn run(cx: Context, extra: ()) {} + ), + "unexpected arguments", + ), + ]; + for (input, message) in cases { + for expand in [main, test] { + let expansion = expand(TokenStream::new(), input.clone()).to_string(); + assert!(expansion.starts_with(&input.to_string())); + assert!(expansion.contains(message), "{expansion}"); + assert!(expansion.contains("compile_error")); + } + } +} + +#[test] +fn malformed_items_and_arguments_report_errors() { + for (args, input) in [ + (TokenStream::new(), quote!(not a function)), + ( + quote!(@), + quote!( + async fn run(cx: Context) {} + ), + ), + ( + quote!(unknown = 1), + quote!( + async fn run(cx: Context) {} + ), + ), + ( + quote!(workers = 1, workers = 2), + quote!( + async fn run(cx: Context) {} + ), + ), + ] { + assert!(main(args, input).to_string().contains("compile_error")); + } +} diff --git a/crates/bytesbuf/Cargo.toml b/crates/bytesbuf/Cargo.toml index a34a125c98..8862182b90 100644 --- a/crates/bytesbuf/Cargo.toml +++ b/crates/bytesbuf/Cargo.toml @@ -83,6 +83,10 @@ windows-sys = { workspace = true, features = [ "Win32_System_SystemInformation", ] } +[[test]] +name = "public_api" +required-features = ["test-util"] + [[bench]] name = "buf" harness = false diff --git a/crates/bytesbuf/src/buf.rs b/crates/bytesbuf/src/buf.rs index 7890f5e954..06902a4046 100644 --- a/crates/bytesbuf/src/buf.rs +++ b/crates/bytesbuf/src/buf.rs @@ -4,6 +4,7 @@ use alloc::format; #[cfg(not(test))] use alloc::string::ToString; +#[cfg(not(test))] use alloc::vec::Vec; use core::any::type_name; use core::mem::{self, MaybeUninit}; @@ -1508,797 +1509,19 @@ impl seismograph_io::Buffer for BytesBuf { } } -#[cfg_attr(coverage_nightly, coverage(off))] #[cfg(test)] mod tests { + // These assertions require private spans, consume manifests, identity size, or synthetic overflow inputs. #![allow(clippy::indexing_slicing, reason = "Fine in test code, we prefer panic on error")] use std::pin::pin; use new_zealand::nz; - use static_assertions::assert_impl_all; use testing_aids::assert_panic; use super::*; - #[cfg(feature = "std")] - use crate::mem::GlobalPool; use crate::mem::testing::{FixedBlockMemory, TestMemoryBlock}; - const U64_SIZE: usize = size_of::(); - const TWO_U64_SIZE: usize = size_of::() + size_of::(); - const THREE_U64_SIZE: usize = size_of::() + size_of::() + size_of::(); - - assert_impl_all!(BytesBuf: Send, Sync); - - #[cfg(feature = "seismograph")] - #[test] - fn seismograph_identity_follows_consumed_data() { - use seismograph_io::Buffer; - - let memory = GlobalPool::new(); - let mut buffer = memory.reserve(16); - buffer.put_slice(*b"abcd"); - let original_id = buffer.recording_state().id(); - - let view = buffer.consume(2); - let cloned = view.clone(); - - assert_eq!(view.recording_state().id(), original_id); - assert_ne!(buffer.recording_state().id(), original_id); - assert_ne!(cloned.recording_state().id(), original_id); - assert_ne!(view.range(..1).recording_state().id(), original_id); - } - - #[cfg(feature = "seismograph")] - #[test] - fn seismograph_recording_state_reports_exact_buffer_shape() { - use seismograph_io::Buffer; - - let memory = FixedBlockMemory::new(nz!(4)); - let mut buffer = memory.reserve(8); - buffer.put_slice(*b"abcdef"); - - let state = buffer.recording_state(); - assert_eq!((state.len(), state.span_count()), (6, 2)); - - let empty = BytesBuf::new(); - let state = empty.recording_state(); - assert_eq!((state.len(), state.span_count()), (0, 0)); - } - - #[cfg(feature = "seismograph")] - #[test] - fn seismograph_io_recording_is_gated_and_captures_buffer_state_delta() { - use seismograph::recorder::event::EventKind; - use seismograph::recorder::{Configuration, EventBufferCapacity, Policy}; - use seismograph::snapshot::{EventBufferDisposition, SnapshotOptions}; - use seismograph_io::{Buffer, IoOutcome, IoResourceKind, Operation, Resource}; - - let release = SnapshotOptions { - event_buffers: EventBufferDisposition::Release, - }; - let memory = FixedBlockMemory::new(nz!(4)); - let mut buffer = memory.reserve(8); - buffer.put_slice(*b"abcdef"); - let resource = Resource::new(IoResourceKind::Other); - - seismograph::recorder(Configuration::default()); - seismograph::snapshot(release).unwrap(); - let disabled = Operation::write_started(&resource, 2, || buffer.recording_state()); - assert!(!disabled.was_recorded()); - disabled.finish(0, IoOutcome::Canceled, || buffer.recording_state()); - let snapshot = seismograph::snapshot(release).unwrap(); - let disabled_events = seismograph::snapshot::decode(snapshot.as_bytes()).unwrap().events; - assert_eq!( - ( - disabled_events.total_events, - disabled_events.lost_events, - disabled_events.threads.len(), - disabled_events.events.len(), - ), - (0, 0, 0, 0) - ); - - seismograph::recorder(Configuration { - io: Policy::all(false), - event_capacity_per_thread: EventBufferCapacity::new(64), - ..Configuration::default() - }); - let initial_state = buffer.recording_state(); - let operation = Operation::write_started(&resource, 2, || buffer.recording_state()); - buffer.put_slice(*b"gh"); - operation.finish(2, IoOutcome::Success, || buffer.recording_state()); - - let snapshot = seismograph::snapshot(release).unwrap(); - let events = seismograph::snapshot::decode(snapshot.as_bytes()).unwrap().events; - let io = events - .events - .iter() - .map(|event| (event.kind, event.io().unwrap())) - .collect::>(); - assert_eq!( - ( - events.total_events, - events.lost_events, - events.threads.len(), - io.iter() - .map(|(kind, event)| (*kind, event.buffer_id, event.buffer_len, event.buffer_span_count)) - .collect::>(), - ), - ( - 2, - 0, - 1, - vec![ - ( - EventKind::IoWriteStarted, - initial_state.id(), - initial_state.len(), - initial_state.span_count(), - ), - (EventKind::IoWriteFinished, initial_state.id(), 8, 2), - ], - ) - ); - seismograph::recorder(Configuration::default()); - } - - #[test] - fn smoke_test() { - let memory = FixedBlockMemory::new(nz!(1234)); - - let min_length = 1000; - - let mut buf = memory.reserve(min_length); - - assert!(buf.capacity() >= min_length); - assert!(buf.remaining_capacity() >= min_length); - assert_eq!(buf.capacity(), buf.remaining_capacity()); - assert_eq!(buf.len(), 0); - assert!(buf.is_empty()); - - buf.put_u64_ne(1234); - buf.put_u64_ne(5678); - buf.put_u64_ne(1234); - buf.put_u64_ne(5678); - - assert_eq!(buf.len(), 32); - assert!(!buf.is_empty()); - - // SAFETY: Writing 0 bytes is always valid. - unsafe { - buf.advance(0); - } - - let mut first_two = buf.consume(TWO_U64_SIZE); - let mut second_two = buf.consume(TWO_U64_SIZE); - - assert_eq!(first_two.len(), 16); - assert_eq!(second_two.len(), 16); - assert_eq!(buf.len(), 0); - - assert_eq!(first_two.get_u64_ne(), 1234); - assert_eq!(first_two.get_u64_ne(), 5678); - - assert_eq!(second_two.get_u64_ne(), 1234); - assert_eq!(second_two.get_u64_ne(), 5678); - - buf.put_u64_ne(1111); - - assert_eq!(buf.len(), 8); - - let mut last = buf.consume(U64_SIZE); - - assert_eq!(last.len(), 8); - assert_eq!(buf.len(), 0); - - assert_eq!(last.get_u64_ne(), 1111); - - assert!(buf.consume_checked(1).is_none()); - assert!(buf.consume_all().is_empty()); - } - - #[test] - fn extend_capacity() { - let mut buf = BytesBuf::new(); - - assert_eq!(buf.capacity(), 0); - assert_eq!(buf.remaining_capacity(), 0); - - let memory = FixedBlockMemory::new(nz!(100)); - - // Have 0, desired 10, requesting 10, will get 100. - buf.reserve(10, &memory); - - assert_eq!(buf.capacity(), 100); - assert_eq!(buf.remaining_capacity(), 100); - - // Write 10 bytes of data just to verify that it does not affect "capacity" logic. - buf.put_u64_ne(1234); - buf.put_u16_ne(5678); - - assert_eq!(buf.len(), 10); - assert_eq!(buf.remaining_capacity(), 90); - assert_eq!(buf.capacity(), 100); - - // Have 100, desired 10+140=150, requesting 50, will get another 100 for a total of 200. - buf.reserve(140, &memory); - - assert_eq!(buf.len(), 10); - assert_eq!(buf.remaining_capacity(), 190); - assert_eq!(buf.capacity(), 200); - - // Have 200, desired 10+200=210, 210-200=10, will get another 100. - buf.reserve(200, &memory); - - assert_eq!(buf.len(), 10); - assert_eq!(buf.remaining_capacity(), 290); - assert_eq!(buf.capacity(), 300); - } - - #[test] - fn append_existing_view() { - let memory = FixedBlockMemory::new(nz!(1234)); - - let min_length = 1000; - - // This one we use to prepare some data to append. - let mut payload_buffer = memory.reserve(min_length); - - // This is where we append the data to. - let mut target_buffer = memory.reserve(min_length); - - // First we make a couple pieces to append. - payload_buffer.put_u64_ne(1111); - payload_buffer.put_u64_ne(2222); - payload_buffer.put_u64_ne(3333); - payload_buffer.put_u64_ne(4444); - - let payload1 = payload_buffer.consume(TWO_U64_SIZE); - let payload2 = payload_buffer.consume(TWO_U64_SIZE); - - // Then we prefill some data to start us off. - target_buffer.put_u64_ne(5555); - target_buffer.put_u64_ne(6666); - - // Consume a little just for extra complexity. - let _ = target_buffer.consume(U64_SIZE); - - // Append the payloads. - target_buffer.put_bytes(payload1); - target_buffer.put_bytes(payload2); - - // Appending an empty byte sequence does nothing. - target_buffer.put_bytes(BytesView::default()); - - // Add some custom data at the end. - target_buffer.put_u64_ne(7777); - - assert_eq!(target_buffer.len(), 48); - - let mut result = target_buffer.consume(48); - - assert_eq!(result.get_u64_ne(), 6666); - assert_eq!(result.get_u64_ne(), 1111); - assert_eq!(result.get_u64_ne(), 2222); - assert_eq!(result.get_u64_ne(), 3333); - assert_eq!(result.get_u64_ne(), 4444); - assert_eq!(result.get_u64_ne(), 7777); - } - - #[test] - fn consume_all_mixed() { - let mut buf = BytesBuf::new(); - let memory = FixedBlockMemory::new(nz!(8)); - - // Reserve some capacity and add initial data. - buf.reserve(16, &memory); - buf.put_u64_ne(1111); - buf.put_u64_ne(2222); - - // Consume some data (the 1111). - let _ = buf.consume(8); - - // Append a sequence (the 3333). - let mut append_buf = BytesBuf::new(); - append_buf.reserve(8, &memory); - append_buf.put_u64_ne(3333); - let reused_bytes_to_append = append_buf.consume_all(); - buf.append(reused_bytes_to_append); - - // Add more data (the 4444). - buf.reserve(8, &memory); - buf.put_u64_ne(4444); - - // Consume all data and validate we got all the pieces. - let mut result = buf.consume_all(); - - assert_eq!(result.len(), 24); - assert_eq!(result.get_u64_ne(), 2222); - assert_eq!(result.get_u64_ne(), 3333); - assert_eq!(result.get_u64_ne(), 4444); - } - - #[test] - #[expect(clippy::cognitive_complexity, reason = "test code")] - fn peek_basic() { - let mut buf = BytesBuf::new(); - - assert_eq!(buf.capacity(), 0); - assert_eq!(buf.remaining_capacity(), 0); - - let memory = FixedBlockMemory::new(nz!(10)); - - // Peeking an empty buffer is fine, it is just an empty BytesView in that case. - let peeked = buf.peek(); - assert_eq!(peeked.len(), 0); - - buf.reserve(100, &memory); - - assert_eq!(buf.capacity(), 100); - - buf.put_u64_ne(1111); - - // We have 0 frozen spans and 10 span builders, - // the first of which has 8 bytes of filled content. - let mut peeked = buf.peek(); - assert_eq!(peeked.first_slice().len(), 8); - assert_eq!(peeked.get_u64_ne(), 1111); - assert_eq!(peeked.len(), 0); - - buf.put_u64_ne(2222); - buf.put_u64_ne(3333); - buf.put_u64_ne(4444); - buf.put_u64_ne(5555); - buf.put_u64_ne(6666); - buf.put_u64_ne(7777); - buf.put_u64_ne(8888); - // These will cross a span boundary so we can also observe - // crossing that boundary during peeking. - buf.put_byte_repeated(9, 8); - - assert_eq!(buf.len(), 72); - assert_eq!(buf.capacity(), 100); - assert_eq!(buf.remaining_capacity(), 28); - - // We should have 7 frozen spans and 3 span builders, - // the first of which has 2 bytes of filled content. - let mut peeked = buf.peek(); - - assert_eq!(peeked.len(), 72); - - // This should be the first frozen span of 10 bytes. - assert_eq!(peeked.first_slice().len(), 10); - - assert_eq!(peeked.get_u64_ne(), 1111); - assert_eq!(peeked.get_u64_ne(), 2222); - - // The length of the buffer does not change just because we peek at its data. - assert_eq!(buf.len(), 72); - - // We consumed 16 bytes from the peeked view, so should be looking at the remaining 4 bytes in the 2nd span. - assert_eq!(peeked.first_slice().len(), 4); - - assert_eq!(peeked.get_u64_ne(), 3333); - assert_eq!(peeked.get_u64_ne(), 4444); - assert_eq!(peeked.get_u64_ne(), 5555); - assert_eq!(peeked.get_u64_ne(), 6666); - assert_eq!(peeked.get_u64_ne(), 7777); - assert_eq!(peeked.get_u64_ne(), 8888); - - for _ in 0..8 { - assert_eq!(peeked.get_byte(), 9); - } - - assert_eq!(peeked.len(), 0); - assert_eq!(peeked.first_slice().len(), 0); - - // Fill up the remaining 28 bytes of data so we have a full sequence builder. - buf.put_byte_repeated(88, 28); - - let mut peeked = buf.peek(); - peeked.advance(72); - - assert_eq!(peeked.len(), 28); - - for _ in 0..28 { - assert_eq!(peeked.get_byte(), 88); - } - } - - #[test] - fn consume_part_of_frozen_span() { - let mut buf = BytesBuf::new(); - - assert_eq!(buf.capacity(), 0); - assert_eq!(buf.remaining_capacity(), 0); - - let memory = FixedBlockMemory::new(nz!(10)); - - buf.reserve(100, &memory); - - assert_eq!(buf.capacity(), 100); - - buf.put_u64_ne(1111); - // This freezes the first span of 10, as we filled it all up. - buf.put_u64_ne(2222); - - let mut first8 = buf.consume(U64_SIZE); - assert_eq!(first8.get_u64_ne(), 1111); - assert!(first8.is_empty()); - - buf.put_u64_ne(3333); - - let mut second16 = buf.consume(16); - assert_eq!(second16.get_u64_ne(), 2222); - assert_eq!(second16.get_u64_ne(), 3333); - assert!(second16.is_empty()); - } - - #[test] - fn empty_buffer() { - let mut buf = BytesBuf::new(); - assert!(buf.is_empty()); - assert!(buf.peek().is_empty()); - assert_eq!(0, buf.first_unfilled_slice().len()); - - let consumed = buf.consume(0); - assert!(consumed.is_empty()); - - let consumed = buf.consume_all(); - assert!(consumed.is_empty()); - } - - #[test] - fn iter_available_empty_with_capacity() { - let mut buf = BytesBuf::new(); - - assert_eq!(buf.capacity(), 0); - assert_eq!(buf.remaining_capacity(), 0); - - let memory = FixedBlockMemory::new(nz!(100)); - - // Capacity: 0 -> 1000 (10x100) - buf.reserve(1000, &memory); - - assert_eq!(buf.capacity(), 1000); - assert_eq!(buf.remaining_capacity(), 1000); - - let iter = buf.iter_available_capacity(None); - - // Demonstrating that we can access slices concurrently, not only one by one. - let slices: Vec<_> = iter.map(|(s, _)| s).collect(); - - assert_eq!(slices.len(), 10); - - for slice in slices { - assert_eq!(slice.len(), 100); - } - - // After we have dropped all slice references, it is again legal to access the buffer. - // This is blocked by the borrow checker while slice references still exist. - buf.reserve(100, &memory); - } - - #[test] - fn iter_available_nonempty() { - let mut buf = BytesBuf::new(); - - assert_eq!(buf.capacity(), 0); - assert_eq!(buf.remaining_capacity(), 0); - - let memory = FixedBlockMemory::new(nz!(8)); - - // Capacity: 0 -> 16 (2x8) - buf.reserve(TWO_U64_SIZE, &memory); - - assert_eq!(buf.capacity(), 16); - assert_eq!(buf.remaining_capacity(), 16); - - // We write an u64 - this fills half the capacity and should result in - // the first span builder being frozen and the second remaining in its entirety. - buf.put_u64_ne(1234); - - assert_eq!(buf.len(), 8); - assert_eq!(buf.remaining_capacity(), 8); - - let available_slices: Vec<_> = buf.iter_available_capacity(None).map(|(s, _)| s).collect(); - assert_eq!(available_slices.len(), 1); - assert_eq!(available_slices[0].len(), 8); - - // We write a u32 - this fills half the remaining capacity, which results - // in a half-filled span builder remaining in the buffer. - buf.put_u32_ne(5678); - - assert_eq!(buf.len(), 12); - assert_eq!(buf.remaining_capacity(), 4); - - let available_slices: Vec<_> = buf.iter_available_capacity(None).map(|(s, _)| s).collect(); - assert_eq!(available_slices.len(), 1); - assert_eq!(available_slices[0].len(), 4); - - // We write a final u32 to use up all the capacity. - buf.put_u32_ne(9012); - - assert_eq!(buf.len(), 16); - assert_eq!(buf.remaining_capacity(), 0); - - assert_eq!(buf.iter_available_capacity(None).count(), 0); - } - - #[test] - fn iter_available_empty_no_capacity() { - let mut buf = BytesBuf::new(); - - assert_eq!(buf.capacity(), 0); - assert_eq!(buf.remaining_capacity(), 0); - assert_eq!(buf.iter_available_capacity(None).count(), 0); - } - - #[test] - fn vectored_write_zero() { - let mut buf = BytesBuf::new(); - - assert_eq!(buf.capacity(), 0); - assert_eq!(buf.remaining_capacity(), 0); - - let memory = FixedBlockMemory::new(nz!(8)); - - // Capacity: 0 -> 16 (2x8) - buf.reserve(TWO_U64_SIZE, &memory); - - assert_eq!(buf.capacity(), 16); - assert_eq!(buf.remaining_capacity(), 16); - - let vectored_write = buf.begin_vectored_write(None); - - // SAFETY: Yes, we really wrote 0 bytes. - unsafe { - vectored_write.commit(0); - } - - assert_eq!(buf.capacity(), 16); - assert_eq!(buf.remaining_capacity(), 16); - } - - #[test] - fn vectored_write_one_slice() { - let mut buf = BytesBuf::new(); - - assert_eq!(buf.capacity(), 0); - assert_eq!(buf.remaining_capacity(), 0); - - let memory = FixedBlockMemory::new(nz!(8)); - - // Capacity: 0 -> 8 (1x8) - buf.reserve(U64_SIZE, &memory); - - assert_eq!(buf.capacity(), 8); - assert_eq!(buf.remaining_capacity(), 8); - - let mut vectored_write = buf.begin_vectored_write(None); - - let mut slices: Vec<_> = vectored_write.slices_mut().map(|(s, _)| s).collect(); - assert_eq!(slices.len(), 1); - assert_eq!(slices[0].len(), 8); - - write_copy_of_slice(slices[0], &0x3333_3333_3333_3333_u64.to_ne_bytes()); - - // SAFETY: Yes, we really wrote 8 bytes. - unsafe { - vectored_write.commit(8); - } - - assert_eq!(buf.len(), 8); - assert_eq!(buf.remaining_capacity(), 0); - assert_eq!(buf.capacity(), 8); - - let mut result = buf.consume(U64_SIZE); - assert_eq!(result.get_u64_ne(), 0x3333_3333_3333_3333); - } - - #[test] - fn vectored_write_multiple_slices() { - let mut buf = BytesBuf::new(); - - assert_eq!(buf.capacity(), 0); - assert_eq!(buf.remaining_capacity(), 0); - - let memory = FixedBlockMemory::new(nz!(8)); - - // Capacity: 0 -> 24 (3x8) - buf.reserve(THREE_U64_SIZE, &memory); - - assert_eq!(buf.capacity(), 24); - assert_eq!(buf.remaining_capacity(), 24); - - let mut vectored_write = buf.begin_vectored_write(None); - - let mut slices: Vec<_> = vectored_write.slices_mut().map(|(s, _)| s).collect(); - assert_eq!(slices.len(), 3); - assert_eq!(slices[0].len(), 8); - assert_eq!(slices[1].len(), 8); - assert_eq!(slices[2].len(), 8); - - // We fill 12 bytes, leaving middle chunk split in half between filled/available. - - write_copy_of_slice(slices[0], &0x3333_3333_3333_3333_u64.to_ne_bytes()); - write_copy_of_slice(slices[1], &0x4444_4444_u32.to_ne_bytes()); - - // SAFETY: Yes, we really wrote 12 bytes. - unsafe { - vectored_write.commit(12); - } - - assert_eq!(buf.len(), 12); - assert_eq!(buf.remaining_capacity(), 12); - assert_eq!(buf.capacity(), 24); - - let mut vectored_write = buf.begin_vectored_write(None); - - let mut slices: Vec<_> = vectored_write.slices_mut().map(|(s, _)| s).collect(); - assert_eq!(slices.len(), 2); - assert_eq!(slices[0].len(), 4); - assert_eq!(slices[1].len(), 8); - - // We fill the remaining 12 bytes. - - write_copy_of_slice(slices[0], &0x5555_5555_u32.to_ne_bytes()); - write_copy_of_slice(slices[1], &0x6666_6666_6666_6666_u64.to_ne_bytes()); - - // SAFETY: Yes, we really wrote 12 bytes. - unsafe { - vectored_write.commit(12); - } - - assert_eq!(buf.len(), 24); - assert_eq!(buf.remaining_capacity(), 0); - assert_eq!(buf.capacity(), 24); - - let mut result = buf.consume(THREE_U64_SIZE); - assert_eq!(result.get_u64_ne(), 0x3333_3333_3333_3333); - assert_eq!(result.get_u32_ne(), 0x4444_4444); - assert_eq!(result.get_u32_ne(), 0x5555_5555); - assert_eq!(result.get_u64_ne(), 0x6666_6666_6666_6666); - } - - #[test] - fn vectored_write_max_len() { - let mut buf = BytesBuf::new(); - - assert_eq!(buf.capacity(), 0); - assert_eq!(buf.remaining_capacity(), 0); - - let memory = FixedBlockMemory::new(nz!(8)); - - // Capacity: 0 -> 24 (3x8) - buf.reserve(THREE_U64_SIZE, &memory); - - assert_eq!(buf.capacity(), 24); - assert_eq!(buf.remaining_capacity(), 24); - - // We limit to 13 bytes of visible capacity, of which we will fill 12. - let mut vectored_write = buf.begin_vectored_write(Some(13)); - - let mut slices: Vec<_> = vectored_write.slices_mut().map(|(s, _)| s).collect(); - assert_eq!(slices.len(), 2); - assert_eq!(slices[0].len(), 8); - assert_eq!(slices[1].len(), 5); - - // We fill 12 bytes, leaving middle chunk split in half between filled/available. - - write_copy_of_slice(slices[0], &0x3333_3333_3333_3333_u64.to_ne_bytes()); - write_copy_of_slice(slices[1], &0x4444_4444_u32.to_ne_bytes()); - - // SAFETY: Yes, we really wrote 12 bytes. - unsafe { - vectored_write.commit(12); - } - - assert_eq!(buf.len(), 12); - assert_eq!(buf.remaining_capacity(), 12); - assert_eq!(buf.capacity(), 24); - - // There are 12 remaining and we set max_limit to exactly cover those 12 - let mut vectored_write = buf.begin_vectored_write(Some(12)); - - let mut slices: Vec<_> = vectored_write.slices_mut().map(|(s, _)| s).collect(); - assert_eq!(slices.len(), 2); - assert_eq!(slices[0].len(), 4); - assert_eq!(slices[1].len(), 8); - - write_copy_of_slice(slices[0], &0x5555_5555_u32.to_ne_bytes()); - write_copy_of_slice(slices[1], &0x6666_6666_6666_6666_u64.to_ne_bytes()); - - // SAFETY: Yes, we really wrote 12 bytes. - unsafe { - vectored_write.commit(12); - } - - assert_eq!(buf.len(), 24); - assert_eq!(buf.remaining_capacity(), 0); - assert_eq!(buf.capacity(), 24); - - let mut result = buf.consume(THREE_U64_SIZE); - assert_eq!(result.get_u64_ne(), 0x3333_3333_3333_3333); - assert_eq!(result.get_u32_ne(), 0x4444_4444); - assert_eq!(result.get_u32_ne(), 0x5555_5555); - assert_eq!(result.get_u64_ne(), 0x6666_6666_6666_6666); - } - - #[test] - fn vectored_write_max_len_overflow() { - let mut buf = BytesBuf::new(); - - let memory = FixedBlockMemory::new(nz!(8)); - - // Capacity: 0 -> 24 (3x8) - buf.reserve(THREE_U64_SIZE, &memory); - - assert_eq!(buf.capacity(), 24); - assert_eq!(buf.remaining_capacity(), 24); - - // We ask for 25 bytes of capacity but there are only 24 available. Oops! - assert_panic!(buf.begin_vectored_write(Some(25))); - } - - #[test] - fn vectored_write_overcommit() { - let mut buf = BytesBuf::new(); - - assert_eq!(buf.capacity(), 0); - assert_eq!(buf.remaining_capacity(), 0); - - let memory = FixedBlockMemory::new(nz!(8)); - - // Capacity: 0 -> 16 (2x8) - buf.reserve(TWO_U64_SIZE, &memory); - - assert_eq!(buf.capacity(), 16); - assert_eq!(buf.remaining_capacity(), 16); - - let vectored_write = buf.begin_vectored_write(None); - - assert_panic!( - // SAFETY: Intentionally lying here to trigger a panic. - unsafe { - vectored_write.commit(17); - } - ); - } - - #[test] - fn vectored_write_abort() { - let mut buf = BytesBuf::new(); - - assert_eq!(buf.capacity(), 0); - assert_eq!(buf.remaining_capacity(), 0); - - let memory = FixedBlockMemory::new(nz!(8)); - - // Capacity: 0 -> 8 (1x8) - buf.reserve(U64_SIZE, &memory); - - assert_eq!(buf.capacity(), 8); - assert_eq!(buf.remaining_capacity(), 8); - - let mut vectored_write = buf.begin_vectored_write(None); - - let mut slices: Vec<_> = vectored_write.slices_mut().map(|(s, _)| s).collect(); - assert_eq!(slices.len(), 1); - assert_eq!(slices[0].len(), 8); - - write_copy_of_slice(slices[0], &0x3333_3333_3333_3333_u64.to_ne_bytes()); - - // Actually never mind - we drop it here. - #[expect(clippy::drop_non_drop, reason = "Just being explicit for illustration")] - drop(vectored_write); - - assert_eq!(buf.len(), 0); - assert_eq!(buf.remaining_capacity(), 8); - assert_eq!(buf.capacity(), 8); - } - #[test] fn extend_lifetime_references_all_blocks() { // We need to detect here whether a block is being released (i.e. ref count goes to zero). @@ -2389,20 +1612,6 @@ mod tests { assert_eq!(block2.ref_count(), 0); } - #[test] - #[cfg(feature = "std")] - fn from_view() { - let memory = GlobalPool::new(); - - let view1 = BytesView::copied_from_slice(b"bla bla bla", &memory); - - let mut buf: BytesBuf = view1.clone().into(); - - let view2 = buf.consume_all(); - - assert_eq!(view1, view2); - } - #[test] fn consume_manifest_correctly_calculated() { let memory = FixedBlockMemory::new(nz!(10)); @@ -2467,347 +1676,6 @@ mod tests { assert_eq!(size_of::(), 552 + size_of::()); } - #[test] - fn peek_empty_builder() { - let buf = BytesBuf::new(); - let peeked = buf.peek(); - - assert!(peeked.is_empty()); - assert_eq!(peeked.len(), 0); - } - - #[test] - fn peek_with_frozen_spans_only() { - let memory = FixedBlockMemory::new(nz!(10)); - let mut buf = BytesBuf::new(); - - buf.reserve(20, &memory); - buf.put_u64_ne(0x1111_1111_1111_1111); - buf.put_u64_ne(0x2222_2222_2222_2222); - // Both blocks are now frozen (filled completely) - assert_eq!(buf.len(), 16); - - let mut peeked = buf.peek(); - - assert_eq!(peeked.len(), 16); - assert_eq!(peeked.get_u64_ne(), 0x1111_1111_1111_1111); - assert_eq!(peeked.get_u64_ne(), 0x2222_2222_2222_2222); - - // Original builder still has the data - assert_eq!(buf.len(), 16); - } - - #[test] - fn peek_with_partially_filled_span_builder() { - let memory = FixedBlockMemory::new(nz!(10)); - let mut buf = BytesBuf::new(); - - buf.reserve(10, &memory); - buf.put_u64_ne(0x3333_3333_3333_3333); - buf.put_u16_ne(0x4444); - // We have 10 bytes filled in a 10-byte block - assert_eq!(buf.len(), 10); - - let mut peeked = buf.peek(); - - assert_eq!(peeked.len(), 10); - assert_eq!(peeked.get_u64_ne(), 0x3333_3333_3333_3333); - assert_eq!(peeked.get_u16_ne(), 0x4444); - - // Original builder still has the data - assert_eq!(buf.len(), 10); - } - - #[test] - fn peek_preserves_capacity_of_partial_span_builder() { - let memory = FixedBlockMemory::new(nz!(20)); - let mut buf = BytesBuf::new(); - - buf.reserve(20, &memory); - buf.put_u64_ne(0x5555_5555_5555_5555); - - // We have 8 bytes filled and 12 bytes remaining capacity - assert_eq!(buf.len(), 8); - assert_eq!(buf.remaining_capacity(), 12); - - let mut peeked = buf.peek(); - - assert_eq!(peeked.len(), 8); - assert_eq!(peeked.get_u64_ne(), 0x5555_5555_5555_5555); - - // CRITICAL TEST: Capacity should be preserved - assert_eq!(buf.len(), 8); - assert_eq!(buf.remaining_capacity(), 12); - - // We should still be able to write more data - buf.put_u32_ne(0x6666_6666); - assert_eq!(buf.len(), 12); - assert_eq!(buf.remaining_capacity(), 8); - - // And we can peek again to see the updated data - let mut peeked2 = buf.peek(); - assert_eq!(peeked2.len(), 12); - assert_eq!(peeked2.get_u64_ne(), 0x5555_5555_5555_5555); - assert_eq!(peeked2.get_u32_ne(), 0x6666_6666); - } - - #[test] - fn peek_with_mixed_frozen_and_unfrozen() { - let memory = FixedBlockMemory::new(nz!(10)); - let mut buf = BytesBuf::new(); - - buf.reserve(30, &memory); - - // Fill first block completely (10 bytes) - will be frozen - buf.put_u64_ne(0x1111_1111_1111_1111); - buf.put_u16_ne(0x2222); - - // Fill second block completely (10 bytes) - will be frozen - buf.put_u64_ne(0x3333_3333_3333_3333); - buf.put_u16_ne(0x4444); - - // Partially fill third block (only 4 bytes) - will remain unfrozen - buf.put_u32_ne(0x5555_5555); - - assert_eq!(buf.len(), 24); - assert_eq!(buf.remaining_capacity(), 6); - - let mut peeked = buf.peek(); - - assert_eq!(peeked.len(), 24); - assert_eq!(peeked.get_u64_ne(), 0x1111_1111_1111_1111); - assert_eq!(peeked.get_u16_ne(), 0x2222); - assert_eq!(peeked.get_u64_ne(), 0x3333_3333_3333_3333); - assert_eq!(peeked.get_u16_ne(), 0x4444); - assert_eq!(peeked.get_u32_ne(), 0x5555_5555); - // Original builder still has all the data and capacity - assert_eq!(buf.len(), 24); - assert_eq!(buf.remaining_capacity(), 6); - } - - #[test] - fn peek_then_consume() { - let memory = FixedBlockMemory::new(nz!(20)); - let mut buf = BytesBuf::new(); - - buf.reserve(20, &memory); - buf.put_u64_ne(0x7777_7777_7777_7777); - buf.put_u32_ne(0x8888_8888); - assert_eq!(buf.len(), 12); - - // Peek at the data - let mut peeked = buf.peek(); - assert_eq!(peeked.len(), 12); - assert_eq!(peeked.get_u64_ne(), 0x7777_7777_7777_7777); - - // Original builder still has the data - assert_eq!(buf.len(), 12); - - // Now consume some of it - let mut consumed = buf.consume(8); - assert_eq!(consumed.get_u64_ne(), 0x7777_7777_7777_7777); - - // Builder should have less data now - assert_eq!(buf.len(), 4); - - // Peek again should show the remaining data - let mut peeked2 = buf.peek(); - assert_eq!(peeked2.len(), 4); - assert_eq!(peeked2.get_u32_ne(), 0x8888_8888); - } - - #[test] - fn peek_multiple_times() { - let memory = FixedBlockMemory::new(nz!(20)); - let mut buf = BytesBuf::new(); - - buf.reserve(20, &memory); - buf.put_u64_ne(0xAAAA_AAAA_AAAA_AAAA); - - // Peek multiple times - each should work independently - let mut peeked1 = buf.peek(); - let mut peeked2 = buf.peek(); - - assert_eq!(peeked1.get_u64_ne(), 0xAAAA_AAAA_AAAA_AAAA); - assert_eq!(peeked2.get_u64_ne(), 0xAAAA_AAAA_AAAA_AAAA); - - // Original builder still intact - assert_eq!(buf.len(), 8); - } - - #[test] - fn first_unfilled_slice_meta_no_capacity() { - let buf = BytesBuf::new(); - assert!(buf.first_unfilled_slice_meta().is_none()); - } - - #[test] - fn first_unfilled_slice_meta_no_meta() { - let memory = FixedBlockMemory::new(nz!(64)); - let buf = memory.reserve(64); - assert!(buf.first_unfilled_slice_meta().is_none()); - } - - #[test] - fn first_unfilled_slice_meta_with_meta() { - #[derive(Debug)] - struct CustomMeta; - - impl BlockMeta for CustomMeta {} - - // SAFETY: We are not allowed to drop this until all BlockRef are gone. This is fine - // because it is dropped at the end of the function, after all BlockRef instances. - let block = unsafe { TestMemoryBlock::new(nz!(100), Some(Box::new(CustomMeta))) }; - let block = pin!(block); - - // SAFETY: We guarantee exclusive access to the memory capacity. - let block = unsafe { block.as_ref().to_block() }; - - let buf = BytesBuf::from_blocks([block]); - let meta = buf.first_unfilled_slice_meta().expect("should have metadata"); - assert!(meta.is::()); - assert!(!meta.is::()); - } - - // To be stabilized soon: https://github.com/rust-lang/rust/issues/79995 - fn write_copy_of_slice(dst: &mut [MaybeUninit], src: &[u8]) { - assert!(dst.len() >= src.len()); - - // SAFETY: We have verified that dst is large enough. - unsafe { - src.as_ptr().copy_to_nonoverlapping(dst.as_mut_ptr().cast(), src.len()); - } - } - - #[test] - fn split_off_remaining_basic() { - let memory = FixedBlockMemory::new(nz!(100)); - let mut buf = memory.reserve(100); - - buf.put_u64_ne(1234); - - let remaining_before_split = buf.remaining_capacity(); - - let split = buf.split_off_remaining(20); - - // Original keeps its data and lost the split capacity. - assert_eq!(buf.len(), U64_SIZE); - assert_eq!(buf.remaining_capacity(), remaining_before_split - 20); - - // Split-off buffer has the requested capacity and no data. - assert!(split.remaining_capacity() >= 20); - assert!(split.is_empty()); - } - - #[test] - fn split_off_remaining_write_to_split() { - let memory = FixedBlockMemory::new(nz!(100)); - let mut buf = memory.reserve(100); - - buf.put_u64_ne(1111); - - let mut split = buf.split_off_remaining(40); - - // Write into the split-off buffer. - split.put_u64_ne(2222); - split.put_u64_ne(3333); - - assert_eq!(split.len(), TWO_U64_SIZE); - - let mut split_view = split.consume_all(); - assert_eq!(split_view.get_u64_ne(), 2222); - assert_eq!(split_view.get_u64_ne(), 3333); - - // Original buffer data is unaffected. - let mut original_view = buf.consume_all(); - assert_eq!(original_view.get_u64_ne(), 1111); - } - - #[test] - fn split_off_remaining_all_capacity() { - let memory = FixedBlockMemory::new(nz!(100)); - let mut buf = memory.reserve(100); - let full_capacity = buf.remaining_capacity(); - - let split = buf.split_off_remaining(full_capacity); - - assert_eq!(buf.remaining_capacity(), 0); - assert_eq!(split.remaining_capacity(), full_capacity); - } - - #[test] - fn split_off_remaining_zero() { - let memory = FixedBlockMemory::new(nz!(100)); - let mut buf = memory.reserve(100); - let original_capacity = buf.remaining_capacity(); - - let split = buf.split_off_remaining(0); - - assert_eq!(buf.remaining_capacity(), original_capacity); - assert!(split.is_empty()); - assert_eq!(split.remaining_capacity(), 0); - } - - #[test] - fn split_off_remaining_multi_block() { - let memory = FixedBlockMemory::new(nz!(10)); - - // Reserve enough to trigger multiple blocks. - let mut buf = memory.reserve(30); - - buf.put_u64_ne(1234); - - let original_remaining = buf.remaining_capacity(); - - // Split off more than one block's capacity to exercise draining + partial split. - let mut split = buf.split_off_remaining(15); - - assert_eq!(buf.remaining_capacity(), original_remaining - 15); - assert_eq!(buf.len(), U64_SIZE); - - // The split-off buffer capacity is usable. - split.put_byte_repeated(0xAA, 15); - assert_eq!(split.len(), 15); - - // Original data is unaffected. - let mut original_view = buf.consume(U64_SIZE); - assert_eq!(original_view.get_u64_ne(), 1234); - } - - #[test] - fn split_off_remaining_empty_buffer_no_capacity() { - let mut buf = BytesBuf::new(); - assert_eq!(buf.remaining_capacity(), 0); - - let split = buf.split_off_remaining(0); - - assert_eq!(buf.len(), 0); - assert_eq!(buf.remaining_capacity(), 0); - assert_eq!(split.len(), 0); - assert_eq!(split.remaining_capacity(), 0); - } - - #[test] - fn split_off_remaining_panics_on_overflow() { - let memory = FixedBlockMemory::new(nz!(100)); - let mut buf = memory.reserve(100); - let capacity = buf.remaining_capacity(); - - assert_panic!(buf.split_off_remaining(capacity + 1)); - } - - #[test] - fn split_off_remaining_checked_returns_none() { - let memory = FixedBlockMemory::new(nz!(100)); - let mut buf = memory.reserve(100); - let capacity = buf.remaining_capacity(); - - assert!(buf.split_off_remaining_checked(capacity + 1).is_none()); - - // Buffer is unmodified. - assert_eq!(buf.remaining_capacity(), capacity); - } - #[test] fn capacity_bounds_check_accepts_maximum_total() { // The largest representable total capacity is permitted; only exceeding it is rejected. @@ -2827,11 +1695,4 @@ mod tests { assert_panic!(assert_capacity_within_bounds(usize::MAX - 4, 8)); assert_panic!(assert_capacity_within_bounds(usize::MAX / 2 + 1, usize::MAX / 2 + 1)); } - - // Compile time test - #[cfg(feature = "std")] - fn _can_use_in_dyn_traits(mem: &dyn Memory) { - let buf = mem.reserve(123); - let _ = buf.into_writer(mem); - } } diff --git a/crates/bytesbuf/src/buf_put.rs b/crates/bytesbuf/src/buf_put.rs index df94eeb432..5c88509e00 100644 --- a/crates/bytesbuf/src/buf_put.rs +++ b/crates/bytesbuf/src/buf_put.rs @@ -250,31 +250,13 @@ impl BytesBuf { put_num_accessors!(f64, put_f64_le, put_f64_be, put_f64_ne); } -#[cfg_attr(coverage_nightly, coverage(off))] #[cfg(test)] mod tests { + // Only the private fast-path return value distinguishes handled writes from fallback. use std::num::NonZero; - use super::*; use crate::mem::testing::{FixedBlockMemory, TransparentMemory}; - #[test] - fn put_slice() { - let memory = TransparentMemory::new(); - let mut buf = memory.reserve(100); - - let data = [1u8, 2, 3, 4, 5]; - buf.put_slice(data); - - assert_eq!(buf.len(), 5); - assert_eq!(buf.remaining_capacity(), 95); - - let bytes = buf.consume_all(); - - assert_eq!(bytes.len(), 5); - assert_eq!(bytes, &data); - } - #[test] fn put_small_takes_fast_path_when_value_fits() { let memory = TransparentMemory::new(); @@ -303,208 +285,4 @@ mod tests { assert_eq!(buf.len(), 0); assert_eq!(buf.remaining_capacity(), 8); } - - #[test] - fn put_slice_empty() { - let memory = TransparentMemory::new(); - let mut buf = memory.reserve(100); - - buf.put_slice([]); - - assert_eq!(buf.len(), 0); - assert_eq!(buf.remaining_capacity(), 100); - } - - #[test] - fn put_view_single_span() { - let memory = TransparentMemory::new(); - let mut buf = memory.reserve(100); - - let data = [10_u8, 20, 30, 40, 50]; - let view = BytesView::copied_from_slice(&data, &memory); - - buf.put_bytes(view); - - assert_eq!(buf.len(), 5); - // Appending a view brings along its existing memory capacity, consuming none. - assert_eq!(buf.remaining_capacity(), 100); - - let bytes = buf.consume_all(); - - assert_eq!(bytes.len(), 5); - assert_eq!(bytes, &data); - } - - #[test] - fn put_view_multi_span() { - let memory = TransparentMemory::new(); - let mut buf = memory.reserve(100); - - let data_part1 = [10_u8, 20]; - let data_part2 = [30_u8, 40, 50]; - let view_part1 = BytesView::copied_from_slice(&data_part1, &memory); - let view_part2 = BytesView::copied_from_slice(&data_part2, &memory); - let view_combined = BytesView::from_views([view_part1, view_part2]); - - buf.put_bytes(view_combined); - - assert_eq!(buf.len(), 5); - // Appending a view brings along its existing memory capacity, consuming none. - assert_eq!(buf.remaining_capacity(), 100); - - let bytes = buf.consume_all(); - - assert_eq!(bytes.len(), 5); - assert_eq!(bytes, &[10_u8, 20, 30, 40, 50]); - } - - #[test] - fn put_view_empty() { - let memory = TransparentMemory::new(); - let mut buf = memory.reserve(100); - - let view = BytesView::new(); - - buf.put_bytes(view); - - assert_eq!(buf.len(), 0); - assert_eq!(buf.remaining_capacity(), 100); - } - - #[test] - fn put_view_peeked_from_self() { - let memory = TransparentMemory::new(); - let mut buf = memory.reserve(100); - - let data = [1u8, 2, 3, 4, 5]; - buf.put_slice(data); - - let peeked = buf.peek(); - assert_eq!(peeked.len(), 5); - - buf.put_bytes(peeked); - - assert_eq!(buf.len(), 10); - // The peeked view brings along its existing memory capacity, consuming none. - assert_eq!(buf.remaining_capacity(), 95); - - let bytes = buf.consume_all(); - - assert_eq!(bytes.len(), 10); - assert_eq!(bytes, &[1u8, 2, 3, 4, 5, 1, 2, 3, 4, 5]); - } - - #[test] - fn put_byte() { - let memory = TransparentMemory::new(); - let mut buf = memory.reserve(10); - - buf.put_byte(0xAB); - buf.put_byte(0xCD); - - assert_eq!(buf.len(), 2); - assert_eq!(buf.remaining_capacity(), 8); - - let bytes = buf.consume_all(); - - assert_eq!(bytes.len(), 2); - assert_eq!(bytes, &[0xAB, 0xCD]); - } - - #[test] - fn put_bytes() { - let memory = TransparentMemory::new(); - let mut buf = memory.reserve(10); - - buf.put_byte_repeated(0xFF, 5); - - assert_eq!(buf.len(), 5); - assert_eq!(buf.remaining_capacity(), 5); - - let bytes = buf.consume_all(); - - assert_eq!(bytes.len(), 5); - assert_eq!(bytes, &[0xFF; 5]); - } - - #[test] - fn put_bytes_into_multi_span() { - let memory = TransparentMemory::new(); - let mut buf = BytesBuf::new(); - - // Result: 5 - buf.reserve(5, &memory); - // Result: 5 + 5 - buf.reserve(10, &memory); - - buf.put_byte_repeated(0xAA, 10); - - assert_eq!(buf.len(), 10); - assert_eq!(buf.remaining_capacity(), 0); - - let bytes = buf.consume_all(); - - assert_eq!(bytes.len(), 10); - assert_eq!(bytes, &[0xAA; 10]); - } - - #[test] - fn put_num() { - let memory = TransparentMemory::new(); - let mut buf = memory.reserve(16); - - buf.put_u32_le(0x1234_5678); - buf.put_u32_be(0x9ABC_DEF0); - buf.put_u64_ne(0x1122_3344_5566_7788); - - assert_eq!(buf.len(), 16); - assert_eq!(buf.remaining_capacity(), 0); - - let bytes = buf.consume_all(); - - assert_eq!(bytes.len(), 16); - - if cfg!(target_endian = "big") { - assert_eq!( - bytes, - &[ - 0x78, 0x56, 0x34, 0x12, // Little-endian 0x12345678 - 0x9A, 0xBC, 0xDE, 0xF0, // Big-endian 0x9ABCDEF0 - 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 // Native-endian 0x1122334455667788 - ] - ); - } else { - assert_eq!( - bytes, - &[ - 0x78, 0x56, 0x34, 0x12, // Little-endian 0x12345678 - 0x9A, 0xBC, 0xDE, 0xF0, // Big-endian 0x9ABCDEF0 - 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11 // Native-endian 0x1122334455667788 - ] - ); - } - } - - #[test] - fn put_num_signed_and_float_round_trip() { - let memory = TransparentMemory::new(); - let mut buf = memory.reserve(64); - - buf.put_i16_le(-12345); - buf.put_i32_be(-2_000_000_000); - buf.put_i64_le(-9_000_000_000_000); - buf.put_i128_be(i128::MIN); - buf.put_f32_le(std::f32::consts::PI); - buf.put_f64_be(std::f64::consts::E); - - let mut view = buf.consume_all(); - - assert_eq!(view.get_i16_le(), -12345); - assert_eq!(view.get_i32_be(), -2_000_000_000); - assert_eq!(view.get_i64_le(), -9_000_000_000_000); - assert_eq!(view.get_i128_be(), i128::MIN); - assert_eq!(view.get_f32_le().to_bits(), std::f32::consts::PI.to_bits()); - assert_eq!(view.get_f64_be().to_bits(), std::f64::consts::E.to_bits()); - assert!(view.is_empty()); - } } diff --git a/crates/bytesbuf/src/buf_writer.rs b/crates/bytesbuf/src/buf_writer.rs index e167931b1f..9a259edf44 100644 --- a/crates/bytesbuf/src/buf_writer.rs +++ b/crates/bytesbuf/src/buf_writer.rs @@ -83,135 +83,3 @@ impl Write for BytesBufWriter { Ok(()) } } - -#[cfg_attr(coverage_nightly, coverage(off))] -#[cfg(test)] -mod tests { - use new_zealand::nz; - - use super::*; - use crate::mem::testing::{FixedBlockMemory, TransparentMemory}; - - #[test] - fn smoke_test_write_and_verify_data() { - let test_data = b"Hello, world! This is a test."; - - let memory = TransparentMemory::new(); - let builder = memory.reserve(100); - - let mut write_adapter = builder.into_writer(&memory); - - // no-op - write_adapter.flush().unwrap(); - - let bytes_written = write_adapter.write(test_data).expect("write should succeed"); - assert_eq!(bytes_written, test_data.len()); - - let mut builder = write_adapter.into_inner(); - let data = builder.consume_all(); - assert_eq!(data, test_data.as_slice()); - } - - #[test] - fn existing_content_is_preserved() { - let memory = TransparentMemory::new(); - let mut builder = memory.reserve(100); - - // Add some initial content to the builder - let initial_data = b"Initial content"; - builder.put_slice(initial_data.as_slice()); - - let mut write_adapter = builder.into_writer(&memory); - - let additional_data = b" - Additional data"; - let bytes_written = write_adapter.write(additional_data).expect("write should succeed"); - assert_eq!(bytes_written, additional_data.len()); - - let mut builder = write_adapter.into_inner(); - // Verify both initial and additional data are present - let data = builder.consume_all(); - let expected = b"Initial content - Additional data"; - assert_eq!(data, expected.as_slice()); - } - - #[test] - fn sufficient_capacity_not_extended() { - let test_data = b"Small data"; // Much smaller than 100 bytes - - let memory = FixedBlockMemory::new(nz!(1024)); - let builder = memory.reserve(100); - - let initial_capacity = builder.capacity(); - assert!(initial_capacity >= 100); - - let mut write_adapter = builder.into_writer(&memory); - - // Write data that fits within existing capacity - let bytes_written = write_adapter.write(test_data).expect("write should succeed"); - assert_eq!(bytes_written, test_data.len()); - - let mut builder = write_adapter.into_inner(); - - // Verify capacity hasn't changed (no new allocation needed) - assert_eq!(builder.capacity(), initial_capacity); - - // Verify the data is there - let data = builder.consume_all(); - assert_eq!(data, test_data.as_slice()); - } - - #[test] - fn empty_buffer_small_write_reserves_initial_size() { - let memory = TransparentMemory::new(); - let buf = BytesBuf::new(); - assert_eq!(buf.capacity(), 0); - - let mut writer = buf.into_writer(&memory); - writer.write_all(b"hello").unwrap(); - - let buf = writer.into_inner(); - assert!( - buf.capacity() >= INITIAL_RESERVATION_BYTES, - "expected capacity >= {INITIAL_RESERVATION_BYTES}, got {}", - buf.capacity() - ); - } - - #[test] - fn empty_buffer_large_write_reserves_growth_size() { - let memory = TransparentMemory::new(); - let buf = BytesBuf::new(); - - let payload = vec![0u8; INITIAL_RESERVATION_BYTES + 1]; - - let mut writer = buf.into_writer(&memory); - writer.write_all(&payload).unwrap(); - - let buf = writer.into_inner(); - assert!( - buf.capacity() >= GROWTH_RESERVATION_BYTES, - "expected capacity >= {GROWTH_RESERVATION_BYTES}, got {}", - buf.capacity() - ); - } - - #[test] - fn non_empty_buffer_reserves_growth_size() { - let memory = TransparentMemory::new(); - let mut buf = memory.reserve(16); - buf.put_slice([1; 16]); - assert_eq!(buf.remaining_capacity(), 0); - assert!(buf.capacity() > 0); - - let mut writer = buf.into_writer(&memory); - writer.write_all(b"more data").unwrap(); - - let buf = writer.into_inner(); - assert!( - buf.capacity() >= 16 + GROWTH_RESERVATION_BYTES, - "expected capacity >= {}, got {}", - 16 + GROWTH_RESERVATION_BYTES, - buf.capacity() - ); - } -} diff --git a/crates/bytesbuf/src/bytes_compat/buf.rs b/crates/bytesbuf/src/bytes_compat/buf.rs index de09acfb06..5e326b4a5e 100644 --- a/crates/bytesbuf/src/bytes_compat/buf.rs +++ b/crates/bytesbuf/src/bytes_compat/buf.rs @@ -27,52 +27,3 @@ unsafe impl BufMut for BytesBuf { UninitSlice::uninit(self.first_unfilled_slice()) } } - -#[cfg_attr(coverage_nightly, coverage(off))] -#[cfg(test)] -mod tests { - use super::*; - use crate::mem::testing::TransparentMemory; - - #[test] - fn buf_mut_compat() { - let memory = TransparentMemory::new(); - let mut buf = memory.reserve(100); - - assert_eq!(BufMut::remaining_mut(&buf), 100); - - // 100 + 100 - buf.reserve(200, &memory); - - assert_eq!(BufMut::remaining_mut(&buf), 200); - - let chunk = BufMut::chunk_mut(&mut buf); - assert_eq!(chunk.len(), 100); - - // SAFETY: Lies - we did not write anything. But we will also - // not touch the data - we are only inspecting the bookkeeping. - // Good enough for test code. - unsafe { - BufMut::advance_mut(&mut buf, 50); - } - - let chunk = BufMut::chunk_mut(&mut buf); - assert_eq!(chunk.len(), 50); - - // SAFETY: See above. - unsafe { - BufMut::advance_mut(&mut buf, 50); - } - - let chunk = BufMut::chunk_mut(&mut buf); - assert_eq!(chunk.len(), 100); - - // SAFETY: See above. - unsafe { - BufMut::advance_mut(&mut buf, 100); - } - - let chunk = BufMut::chunk_mut(&mut buf); - assert_eq!(chunk.len(), 0); - } -} diff --git a/crates/bytesbuf/src/bytes_compat/from_bytes.rs b/crates/bytesbuf/src/bytes_compat/from_bytes.rs index 0823756f03..afea97bf51 100644 --- a/crates/bytesbuf/src/bytes_compat/from_bytes.rs +++ b/crates/bytesbuf/src/bytes_compat/from_bytes.rs @@ -191,60 +191,13 @@ impl Iterator for BytesBlockIterator { } } -#[cfg_attr(coverage_nightly, coverage(off))] #[cfg(test)] mod tests { + // These cases inspect the size hint of the private block iterator. use bytes::{BufMut, BytesMut}; use super::*; - #[test] - fn test_bytes_to_view() { - let bytes = Bytes::from_static(b"Hello, world!"); - - let bytes_data_ptr = bytes.as_ptr(); - - let view: BytesView = bytes.into(); - - assert_eq!(view.len(), 13); - assert_eq!(view, b"Hello, world!"); - - // We expect this to be zero-copy - Bytes to BytesView always is. - assert_eq!(view.first_slice().as_ptr(), bytes_data_ptr); - } - - #[test] - fn zero_sized_bytes() { - let bytes = Bytes::new(); - let view: BytesView = bytes.into(); - - assert_eq!(view.len(), 0); - assert!(view.is_empty()); - } - - #[test] - fn test_giant_bytes_to_view() { - // This test requires at least 5 GB of memory to run. The publishing pipeline runs on a system - // where this may not be available, so we skip this test in that environment. - #[cfg(all(not(miri), any(target_os = "linux", target_os = "windows")))] - if crate::testing::system_memory() < 10_000_000_000 { - eprintln!("Skipping giant allocation test due to insufficient memory."); - return; - } - - let mut bytes = BytesMut::new(); - - // This is bigger than fits into a single memory block, so will be split in two blocks. - bytes.put_bytes(0, 5_000_000_000); - - let bytes = bytes.freeze(); - - let view: BytesView = bytes.into(); - assert_eq!(view.len(), 5_000_000_000); - assert_eq!(view.first_slice().len(), u32::MAX as usize); - assert_eq!(view.into_spans_reversed().len(), 2); - } - #[test] fn test_bytes_block_iterator_size_hint_single_block() { let bytes = Bytes::from_static(b"Hello, world!"); diff --git a/crates/bytesbuf/src/bytes_compat/to_bytes.rs b/crates/bytesbuf/src/bytes_compat/to_bytes.rs index 52bb961bf0..8e44ee37d9 100644 --- a/crates/bytesbuf/src/bytes_compat/to_bytes.rs +++ b/crates/bytesbuf/src/bytes_compat/to_bytes.rs @@ -98,85 +98,3 @@ std::thread_local! { .name("bytesbuf_view_to_bytes_copied") .build(); } - -#[cfg_attr(coverage_nightly, coverage(off))] -#[cfg(test)] -mod tests { - use bytes::Buf; - use new_zealand::nz; - - use super::*; - use crate::mem::testing::{TransparentMemory, std_alloc_block}; - - #[test] - fn view_to_bytes() { - let mut builder = std_alloc_block::allocate(nz!(100)).into_span_builder(); - - builder.put_slice(&1234_u64.to_ne_bytes()); - builder.put_slice(&5678_u64.to_ne_bytes()); - - let span1 = builder.consume(nz!(8)); - let span2 = builder.consume(nz!(8)); - - let view_single_span = BytesView::from_spans(vec![span1.clone()]); - let view_multi_span = BytesView::from_spans(vec![span1, span2]); - - let mut bytes = view_single_span.to_bytes(); - assert_eq!(8, bytes.len()); - assert_eq!(1234, bytes.get_u64_ne()); - - let mut bytes = view_single_span.to_bytes(); - assert_eq!(8, bytes.len()); - assert_eq!(1234, bytes.get_u64_ne()); - - let mut bytes = view_multi_span.to_bytes(); - assert_eq!(16, bytes.len()); - assert_eq!(1234, bytes.get_u64_ne()); - assert_eq!(5678, bytes.get_u64_ne()); - } - - #[test] - fn empty_view_to_bytes() { - let view = BytesView::default(); - let bytes = view.to_bytes(); - assert_eq!(0, bytes.len()); - } - - #[test] - fn into_bytes() { - let memory = TransparentMemory::new(); - let view = BytesView::copied_from_slice(b"Hello, world!", &memory); - - let bytes: Bytes = view.into(); - - assert_eq!(bytes.as_ref(), b"Hello, world!"); - } - - #[test] - fn test_view_to_bytes() { - let memory = TransparentMemory::new(); - - let view = BytesView::copied_from_slice(b"Hello, world!", &memory); - - let view_chunk_ptr = view.first_slice().as_ptr(); - - let bytes = view.to_bytes(); - - assert_eq!(bytes.as_ref(), b"Hello, world!"); - - // We expect this to be zero-copy since we used the passthrough allocator. - assert_eq!(bytes.as_ptr(), view_chunk_ptr); - } - - #[test] - fn test_multi_block_view_to_bytes() { - let memory = TransparentMemory::new(); - - let hello = BytesView::copied_from_slice(b"Hello, ", &memory); - let world = BytesView::copied_from_slice(b"world!", &memory); - let view = BytesView::from_views([hello, world]); - - let bytes = view.to_bytes(); - assert_eq!(bytes.as_ref(), b"Hello, world!"); - } -} diff --git a/crates/bytesbuf/src/bytes_compat/view.rs b/crates/bytesbuf/src/bytes_compat/view.rs index 962fda8de0..fd30950906 100644 --- a/crates/bytesbuf/src/bytes_compat/view.rs +++ b/crates/bytesbuf/src/bytes_compat/view.rs @@ -36,65 +36,3 @@ impl Buf for BytesView { self.advance(cnt); } } - -#[cfg_attr(coverage_nightly, coverage(off))] -#[cfg(all(test, feature = "std"))] -mod tests { - use new_zealand::nz; - - use super::*; - use crate::mem::testing::FixedBlockMemory; - - #[test] - fn buf_compat() { - let memory = FixedBlockMemory::new(nz!(25)); - - // 25 x 4 - let mut buf = memory.reserve(100); - buf.put_byte_repeated(0x44, 100); - - let mut bytes = buf.consume_all(); - - assert_eq!(Buf::remaining(&bytes), 100); - - let chunk = Buf::chunk(&bytes); - assert_eq!(chunk.len(), 25); - assert_eq!(chunk, &[0x44; 25]); - - Buf::advance(&mut bytes, 20); - - let chunk = Buf::chunk(&bytes); - assert_eq!(chunk.len(), 5); - assert_eq!(chunk, &[0x44; 5]); - - Buf::advance(&mut bytes, 5); - - let chunk = Buf::chunk(&bytes); - assert_eq!(chunk.len(), 25); - assert_eq!(chunk, &[0x44; 25]); - - Buf::advance(&mut bytes, 5); - - let mut io_slices = [IoSlice::new(&[]); 4]; - let n = Buf::chunks_vectored(&bytes, &mut io_slices); - - // We have already advanced past the first 30 bytes - // but the remaining 70 should still be here for us as 20 + 25 + 25. - assert_eq!(n, 3); - - assert_eq!(&*io_slices[0], &[0x44; 20]); - assert_eq!(&*io_slices[1], &[0x44; 25]); - assert_eq!(&*io_slices[2], &[0x44; 25]); - } - - #[test] - fn chunks_vectored_empty_dst() { - let memory = FixedBlockMemory::new(nz!(25)); - let mut buf = memory.reserve(25); - buf.put_byte_repeated(0x44, 25); - - let bytes = buf.consume_all(); - let n = Buf::chunks_vectored(&bytes, &mut []); - assert_eq!(n, 0); - } -} diff --git a/crates/bytesbuf/src/lib.rs b/crates/bytesbuf/src/lib.rs index c6e9e6ed9c..b4a6b7d930 100644 --- a/crates/bytesbuf/src/lib.rs +++ b/crates/bytesbuf/src/lib.rs @@ -663,6 +663,3 @@ pub use memory_guard::MemoryGuard; pub(crate) use span::Span; pub(crate) use span_builder::SpanBuilder; pub use view::{BytesView, BytesViewSlices}; - -#[cfg(test)] -mod testing; diff --git a/crates/bytesbuf/src/mem/block_ref.rs b/crates/bytesbuf/src/mem/block_ref.rs index b0cbaba528..427a0a49d4 100644 --- a/crates/bytesbuf/src/mem/block_ref.rs +++ b/crates/bytesbuf/src/mem/block_ref.rs @@ -312,9 +312,9 @@ pub unsafe trait BlockRefDynamicWithMeta: BlockRefDynamic { fn meta(state_ptr: NonNull) -> NonNull; } -#[cfg_attr(coverage_nightly, coverage(off))] #[cfg(test)] mod tests { + // These cases inspect private vtable fields as well as dispatch behavior. use std::sync::atomic::{self, AtomicUsize}; use super::*; @@ -365,83 +365,6 @@ mod tests { } } - const TEST_BLOCK_REF_FNS: BlockRefVTable = BlockRefVTable::from_trait_with_meta(); - - const TEST_BLOCK_REF_FNS_WITHOUT_META: BlockRefVTable = BlockRefVTable::from_trait(); - - #[test] - fn smoke_test() { - let meta_ptr = NonNull::new(Box::into_raw(Box::new(TestBlockMeta { - label: "Test Block".to_string(), - }))) - .unwrap(); - - let block_ptr = NonNull::new(Box::into_raw(Box::new(TestBlock { - ref_count: AtomicUsize::new(1), - meta: Some(meta_ptr), - }))) - .unwrap(); - - // SAFETY: block_ptr must remain valid for reads and writes until drop() - // is called via the dynamic fns. Yep, it does - the dynamic impl type takes ownership. - let block_ref = unsafe { BlockRef::new(block_ptr, &TEST_BLOCK_REF_FNS) }; - - let meta = block_ref.meta().unwrap(); - - assert_eq!(meta.downcast_ref::().unwrap().label, "Test Block"); - - let block_ref_clone = block_ref.clone(); - - let meta = block_ref_clone.meta().unwrap(); - - assert_eq!(meta.downcast_ref::().unwrap().label, "Test Block"); - - // SAFETY: That is our block and it is perfectly valid for reads. - let ref_count = unsafe { block_ptr.as_ref() }.ref_count.load(atomic::Ordering::Relaxed); - - assert_eq!(2, ref_count); - - drop(block_ref_clone); - drop(block_ref); - - // SAFETY: That is our block and it is perfectly valid for reads. - let ref_count = unsafe { block_ptr.as_ref() }.ref_count.load(atomic::Ordering::Relaxed); - - assert_eq!(0, ref_count); - - // All done, clean up please. - // SAFETY: Yep, that is our block. - drop(unsafe { Box::from_raw(block_ptr.as_ptr()) }); - // SAFETY: Yep, that is our meta. - drop(unsafe { Box::from_raw(meta_ptr.as_ptr()) }); - } - - #[test] - fn without_meta_returns_none_meta() { - let block_ptr = NonNull::new(Box::into_raw(Box::new(TestBlock { - ref_count: AtomicUsize::new(1), - meta: None, - }))) - .unwrap(); - - // SAFETY: block_ptr must remain valid for reads and writes until drop() - // is called via the dynamic fns. Yep, it does - the dynamic impl type takes ownership. - let block_ref = unsafe { BlockRef::new(block_ptr, &TEST_BLOCK_REF_FNS_WITHOUT_META) }; - - assert!(block_ref.meta().is_none()); - - let block_ref_clone = block_ref.clone(); - - assert!(block_ref_clone.meta().is_none()); - - drop(block_ref_clone); - drop(block_ref); - - // All done, clean up please. - // SAFETY: Yep, that is our block. - drop(unsafe { Box::from_raw(block_ptr.as_ptr()) }); - } - #[test] #[cfg_attr(miri, ignore)] fn from_trait_with_meta_creates_vtable_with_meta_fn() { @@ -511,80 +434,4 @@ mod tests { // SAFETY: Yep, that is our block. drop(unsafe { Box::from_raw(block_ptr.as_ptr()) }); } - - #[test] - #[cfg_attr(miri, ignore)] - fn from_trait_with_meta_vtable_handles_clone_correctly() { - // Create vtable at runtime to ensure we measure test coverage. - // We leak the Box to get a 'static reference, which is okay as long as Miri is not looking. - let vtable: &'static BlockRefVTable = Box::leak(Box::new(BlockRefVTable::from_trait_with_meta())); - - let block_ptr = NonNull::new(Box::into_raw(Box::new(TestBlock { - ref_count: AtomicUsize::new(1), - meta: None, - }))) - .unwrap(); - - // SAFETY: block_ptr must remain valid for reads and writes until drop() - // is called via the dynamic fns. It is - we clean it up at the end. - let block_ref = unsafe { BlockRef::new(block_ptr, vtable) }; - - // Clone the block ref - let block_ref_clone = block_ref.clone(); - - // Verify reference count increased - // SAFETY: That is our block and it is perfectly valid for reads. - let ref_count = unsafe { block_ptr.as_ref() }.ref_count.load(atomic::Ordering::Relaxed); - assert_eq!(ref_count, 2); - - drop(block_ref_clone); - drop(block_ref); - - // Verify reference count decreased to 0 - // SAFETY: That is our block and it is perfectly valid for reads. - let ref_count = unsafe { block_ptr.as_ref() }.ref_count.load(atomic::Ordering::Relaxed); - assert_eq!(ref_count, 0); - - // Clean up - // SAFETY: Yep, that is our block. - drop(unsafe { Box::from_raw(block_ptr.as_ptr()) }); - } - - #[test] - #[cfg_attr(miri, ignore)] - fn from_trait_vtable_handles_clone_correctly() { - // Create vtable at runtime to ensure we measure test coverage. - // We leak the Box to get a 'static reference, which is okay as long as Miri is not looking. - let vtable: &'static BlockRefVTable = Box::leak(Box::new(BlockRefVTable::from_trait())); - - let block_ptr = NonNull::new(Box::into_raw(Box::new(TestBlock { - ref_count: AtomicUsize::new(1), - meta: None, - }))) - .unwrap(); - - // SAFETY: block_ptr must remain valid for reads and writes until drop() - // is called via the dynamic fns. It is - we clean it up at the end. - let block_ref = unsafe { BlockRef::new(block_ptr, vtable) }; - - // Clone the block ref - let block_ref_clone = block_ref.clone(); - - // Verify reference count increased - // SAFETY: That is our block and it is perfectly valid for reads. - let ref_count = unsafe { block_ptr.as_ref() }.ref_count.load(atomic::Ordering::Relaxed); - assert_eq!(ref_count, 2); - - drop(block_ref_clone); - drop(block_ref); - - // Verify reference count decreased to 0 - // SAFETY: That is our block and it is perfectly valid for reads. - let ref_count = unsafe { block_ptr.as_ref() }.ref_count.load(atomic::Ordering::Relaxed); - assert_eq!(ref_count, 0); - - // Clean up - // SAFETY: Yep, that is our block. - drop(unsafe { Box::from_raw(block_ptr.as_ptr()) }); - } } diff --git a/crates/bytesbuf/src/mem/callback_memory.rs b/crates/bytesbuf/src/mem/callback_memory.rs index c849c09e6d..d0aada23fe 100644 --- a/crates/bytesbuf/src/mem/callback_memory.rs +++ b/crates/bytesbuf/src/mem/callback_memory.rs @@ -123,146 +123,3 @@ impl Memory for CallbackMemory: MemoryShared); - - /// Thread-aware callback data carrying an observable call counter alongside the wrapped provider. - #[derive(Clone, Debug, ThreadAware)] - struct CountingData { - inner: TransparentMemory, - // The counter is inert shared state, so relocation does not affect it. - #[thread_aware(skip)] - reserve_calls: Arc, - } - - impl CountingData { - fn new() -> Self { - Self { - inner: TransparentMemory::new(), - reserve_calls: Arc::new(AtomicUsize::new(0)), - } - } - } - - // A relocation observer bundled into the data, so we can assert forwarding without a bare skip. - #[derive(Clone, Debug)] - struct RelocationObserver { - inner: TransparentMemory, - relocations: Arc, - } - - impl ThreadAware for RelocationObserver { - fn relocate(&mut self, _source: Option<&Thread>, _destination: &Thread) { - self.relocations.fetch_add(1, atomic::Ordering::SeqCst); - } - } - - fn count_reserve(data: &CountingData, min_bytes: usize) -> BytesBuf { - data.reserve_calls.fetch_add(1, atomic::Ordering::SeqCst); - data.inner.reserve(min_bytes) - } - - #[test] - fn calls_back_to_provided_fn() { - let data = CountingData::new(); - let reserve_calls = Arc::clone(&data.reserve_calls); - - let provider = CallbackMemory::new(data, count_reserve); - - _ = Memory::reserve(&provider, 100); - - assert_eq!(reserve_calls.load(atomic::Ordering::SeqCst), 1); - } - - #[test] - fn clone_shares_behavior() { - let data = CountingData::new(); - let reserve_calls = Arc::clone(&data.reserve_calls); - - let provider = CallbackMemory::new(data, count_reserve); - let cloned_provider = provider.clone(); - - _ = Memory::reserve(&provider, 50); - assert_eq!(reserve_calls.load(atomic::Ordering::SeqCst), 1); - - _ = Memory::reserve(&cloned_provider, 75); - assert_eq!(reserve_calls.load(atomic::Ordering::SeqCst), 2); - } - - #[test] - fn reserve_produces_capacity() { - let provider = CallbackMemory::new(TransparentMemory::new(), TransparentMemory::reserve); - - let buf = provider.reserve(64); - assert!(buf.capacity() >= 64); - } - - #[test] - fn multi_field_tuple_data() { - // The data can carry more than the wrapped provider: here a tuple pairs it with an offset - // that the callback adds to every reservation. - const EXTRA: usize = 16; - let provider = CallbackMemory::new( - (TransparentMemory::new(), EXTRA), - |(inner, extra): &(TransparentMemory, usize), min_bytes| inner.reserve(min_bytes + *extra), - ); - - // TransparentMemory reserves exactly the requested capacity, so the offset is observable. - let buf = provider.reserve(64); - assert_eq!(buf.capacity(), 64 + EXTRA); - } - - #[test] - fn relocate_forwards_to_data() { - let relocations = Arc::new(AtomicUsize::new(0)); - let mut provider = CallbackMemory::new( - RelocationObserver { - inner: TransparentMemory::new(), - relocations: Arc::clone(&relocations), - }, - |observer: &RelocationObserver, min_bytes| observer.inner.reserve(min_bytes), - ); - - _ = Relocator::between_threads().relocate(&mut provider); - - assert_eq!(relocations.load(atomic::Ordering::SeqCst), 1); - - // The provider remains usable after relocation. - assert!(provider.reserve(32).capacity() >= 32); - } - - #[test] - fn works_with_non_debug_data() { - // Data that is intentionally not `Debug`, to confirm `CallbackMemory` does not require it. - #[derive(Clone, ThreadAware)] - struct NotDebug { - inner: TransparentMemory, - } - - let provider = CallbackMemory::new( - NotDebug { - inner: TransparentMemory::new(), - }, - |data: &NotDebug, min_bytes| data.inner.reserve(min_bytes), - ); - - assert!(Memory::reserve(&provider, 64).capacity() >= 64); - - // `CallbackMemory` is still `Debug` even though its data is not. - let rendered = format!("{provider:?}"); - assert!(rendered.contains("CallbackMemory")); - } -} diff --git a/crates/bytesbuf/src/mem/global.rs b/crates/bytesbuf/src/mem/global.rs index ea4721eb67..7fa1e8ad10 100644 --- a/crates/bytesbuf/src/mem/global.rs +++ b/crates/bytesbuf/src/mem/global.rs @@ -492,21 +492,14 @@ std::thread_local! { .build(); } -#[cfg_attr(coverage_nightly, coverage(off))] #[cfg(test)] mod tests { + // Pool occupancy, chunk sizing, and injected initializer panics have no public observations. #![allow(clippy::indexing_slicing, reason = "panic is fine in tests")] use std::thread; - use static_assertions::assert_impl_all; - use thread_aware::Relocator; - use super::*; - use crate::mem::MemoryShared; - - assert_impl_all!(GlobalPool: MemoryShared); - assert_impl_all!(GlobalPool: ThreadAware); /// Helper to assert all sub-pools are empty. fn assert_all_pools_empty(inner: &GlobalPoolInner) { @@ -551,70 +544,6 @@ mod tests { assert!(pool.is_empty()); } - #[test] - fn smoke_test() { - let memory = GlobalPool::new(); - - // Nothing to assert with 0-sized, any capacity is acceptable. Just as long as it works. - _ = memory.reserve(0); - - let builder = memory.reserve(1); - assert!(builder.capacity() >= 1); - - let builder = memory.reserve(100); - assert!(builder.capacity() >= 100); - - let builder = memory.reserve(1000); - assert!(builder.capacity() >= 1000); - - let builder = memory.reserve(10000); - assert!(builder.capacity() >= 10000); - - let builder = memory.reserve(100_000); - assert!(builder.capacity() >= 100_000); - - let builder = memory.reserve(1_000_000); - assert!(builder.capacity() >= 1_000_000); - } - - #[test] - fn piece_by_piece() { - const BLOCK_SIZE: usize = 65_536; - const LEN_BYTES: BlockSize = 1000; - - // We grab a block of memory and split the single block into multiple views piece by piece. - let memory = GlobalPool::new(); - - let mut buf = memory.reserve(BLOCK_SIZE); - - let mut views = Vec::new(); - - while buf.remaining_capacity() > 0 { - #[expect(clippy::cast_possible_truncation, reason = "intentionally truncating")] - let value = views.len() as u8; - - buf.put_byte_repeated(value, (LEN_BYTES as usize).min(buf.remaining_capacity())); - - // Sanity check against silly mutations. - debug_assert!(!buf.is_empty()); - - views.push(buf.consume_all()); - } - - #[expect(clippy::cast_possible_truncation, reason = "block size is small")] - let expected_count = (BLOCK_SIZE as BlockSize).div_ceil(LEN_BYTES); - assert_eq!(views.len(), expected_count as usize); - - assert!(!views.is_empty()); - - for (i, sequence) in views.iter().enumerate() { - #[expect(clippy::cast_possible_truncation, reason = "intentionally truncating")] - let expected_value = i as u8; - - assert_eq!(sequence.first_slice()[0], expected_value); - } - } - #[test] fn release_on_other_thread() { let memory = GlobalPool::new(); @@ -634,151 +563,8 @@ mod tests { .unwrap(); } - #[test] - #[cfg_attr(miri, ignore)] // Miri runtime scales with memory access size, so this takes forever. - fn large_content_survives_trip() { - const SIZE_10MB: usize = 10 * 1024 * 1024; - - let pattern = testing_aids::repeating_incrementing_bytes().take(SIZE_10MB).collect::>(); - - let memory = GlobalPool::new(); - - let mut buf = memory.reserve(SIZE_10MB); - - buf.put_slice(pattern.as_slice()); - - let message = buf.consume_all(); - - // Verify the sequence contains the expected pattern - assert_eq!(message.len(), SIZE_10MB); - assert_eq!(message, pattern.as_slice()); - } - - #[test] - #[cfg_attr(miri, ignore)] // Miri runtime scales with memory access size, so this takes forever. - fn two_large_views_different_patterns() { - const SIZE_10MB: usize = 10 * 1024 * 1024; - - let pattern1 = testing_aids::repeating_incrementing_bytes().take(SIZE_10MB).collect::>(); - - let pattern2 = testing_aids::repeating_reverse_incrementing_bytes() - .take(SIZE_10MB) - .collect::>(); - - let memory = GlobalPool::new(); - - // Create first sequence with ascending pattern - let mut sb1 = memory.reserve(SIZE_10MB); - sb1.put_slice(pattern1.as_slice()); - - // Create second sequence with descending pattern - let mut sb2 = memory.reserve(SIZE_10MB); - sb2.put_slice(pattern2.as_slice()); - - let view1 = sb1.consume_all(); - let view2 = sb2.consume_all(); - - // Verify both views have correct size - assert_eq!(view1.len(), SIZE_10MB); - assert_eq!(view2.len(), SIZE_10MB); - - assert_eq!(view1, pattern1.as_slice()); - assert_eq!(view2, pattern2.as_slice()); - } - // --- Block selection tests --- - #[test] - fn small_reservation_uses_1k_block() { - let memory = GlobalPool::new(); - - let buf = memory.reserve(500); - assert_eq!(buf.capacity(), 1024); - } - - #[test] - fn exact_1k_uses_1k_block() { - let memory = GlobalPool::new(); - - let buf = memory.reserve(1024); - assert_eq!(buf.capacity(), 1024); - } - - #[test] - fn just_over_1k_uses_4k_block() { - let memory = GlobalPool::new(); - - let buf = memory.reserve(1025); - assert_eq!(buf.capacity(), 4096); - } - - #[test] - fn exact_4k_uses_4k_block() { - let memory = GlobalPool::new(); - - let buf = memory.reserve(4096); - assert_eq!(buf.capacity(), 4096); - } - - #[test] - fn just_over_4k_uses_16k_block() { - let memory = GlobalPool::new(); - - let buf = memory.reserve(4097); - assert_eq!(buf.capacity(), 16_384); - } - - #[test] - fn exact_16k_uses_16k_block() { - let memory = GlobalPool::new(); - - let buf = memory.reserve(16_384); - assert_eq!(buf.capacity(), 16_384); - } - - #[test] - fn just_over_16k_uses_64k_block() { - let memory = GlobalPool::new(); - - let buf = memory.reserve(16_385); - assert_eq!(buf.capacity(), 65_536); - } - - #[test] - fn exact_64k_uses_64k_block() { - let memory = GlobalPool::new(); - - let buf = memory.reserve(65_536); - assert_eq!(buf.capacity(), 65_536); - } - - #[test] - fn multi_block_uniform_64k() { - // 70KB exceeds 64KB, so uses multiple 64KB blocks (all same size). - let memory = GlobalPool::new(); - - let buf = memory.reserve(70_000); - assert_eq!(buf.capacity(), 65_536 * 2); - } - - #[test] - fn multi_block_many_64k() { - // 200KB = ceil(200_000 / 65_536) = 4 blocks of 64KB. - let memory = GlobalPool::new(); - - let buf = memory.reserve(200_000); - assert_eq!(buf.capacity(), 65_536 * 4); - } - - #[test] - fn zero_reservation() { - let memory = GlobalPool::new(); - - let buf = memory.reserve(0); - // Zero reservation should not panic and should result in zero capacity (no blocks). - assert_eq!(buf.capacity(), 0); - } - #[test] fn pool_isolation_small_block() { let memory = GlobalPool::new(); @@ -803,33 +589,4 @@ mod tests { assert_all_pools_empty(&memory.inner); } - - #[test] - fn multi_block_just_over_64k() { - // 66_036 > 64KB, so 2x 64KB blocks (uniform sizing). - let memory = GlobalPool::new(); - - let buf = memory.reserve(66_036); - assert_eq!(buf.capacity(), 65_536 * 2); - } - - #[test] - fn relocated_pool_works() { - let mut memory = GlobalPool::new(); - - // Allocate from the original pool. - let mut buf = memory.reserve(100); - buf.put_byte(42); - let view = buf.consume_all(); - assert_eq!(view.first_slice()[0], 42); - - // Relocate the pool to a different thread coordinate. - _ = Relocator::between_threads().relocate(&mut memory); - - // The relocated pool should work independently. - let mut buf2 = memory.reserve(200); - buf2.put_byte(99); - let view2 = buf2.consume_all(); - assert_eq!(view2.first_slice()[0], 99); - } } diff --git a/crates/bytesbuf/src/mem/memory.rs b/crates/bytesbuf/src/mem/memory.rs index 107985d372..4426b64db0 100644 --- a/crates/bytesbuf/src/mem/memory.rs +++ b/crates/bytesbuf/src/mem/memory.rs @@ -42,50 +42,3 @@ impl Memory for &M { (*self).reserve(min_bytes) } } - -#[cfg_attr(coverage_nightly, coverage(off))] -#[cfg(test)] -mod tests { - use std::sync::atomic::{AtomicUsize, Ordering}; - - use super::Memory; - use crate::BytesBuf; - use crate::mem::testing::TransparentMemory; - - #[derive(Debug)] - struct CountingMemory { - reserve_calls: AtomicUsize, - inner: TransparentMemory, - } - - impl CountingMemory { - fn new() -> Self { - Self { - reserve_calls: AtomicUsize::new(0), - inner: TransparentMemory::new(), - } - } - } - - impl Memory for CountingMemory { - fn reserve(&self, min_bytes: usize) -> BytesBuf { - self.reserve_calls.fetch_add(1, Ordering::SeqCst); - self.inner.reserve(min_bytes + 16) - } - } - - fn reserve_from_generic(memory: M, min_bytes: usize) -> BytesBuf { - memory.reserve(min_bytes) - } - - #[test] - fn memory_impl_for_reference_forwards_reserve_to_underlying() { - let memory = CountingMemory::new(); - let min_bytes = 64; - - let buf = reserve_from_generic(&memory, min_bytes); - - assert_eq!(memory.reserve_calls.load(Ordering::SeqCst), 1); - assert!(buf.capacity() >= min_bytes + 16); - } -} diff --git a/crates/bytesbuf/src/mem/opaque_memory.rs b/crates/bytesbuf/src/mem/opaque_memory.rs index a66b74b1ab..209cbb4d77 100644 --- a/crates/bytesbuf/src/mem/opaque_memory.rs +++ b/crates/bytesbuf/src/mem/opaque_memory.rs @@ -68,71 +68,3 @@ impl Memory for OpaqueMemory { self.reserve(min_bytes) } } - -#[cfg_attr(coverage_nightly, coverage(off))] -#[cfg(all(test, feature = "std"))] -mod tests { - use std::sync::Arc; - use std::sync::atomic::{self, AtomicUsize}; - - use static_assertions::assert_impl_all; - use thread_aware::{Relocator, Thread}; - - use super::*; - use crate::mem::GlobalPool; - - assert_impl_all!(OpaqueMemory: MemoryShared, ThreadAware); - - #[test] - fn wraps_inner() { - let provider = GlobalPool::new(); - let memory = OpaqueMemory::new(provider); - let cloned = memory.clone(); - - assert!(memory.reserve(1024).capacity() >= 1024); - assert!(cloned.reserve(1024).capacity() >= 1024); - } - - #[test] - fn memory_trait() { - let provider = GlobalPool::new(); - let memory = OpaqueMemory::new(provider); - - // Call reserve via the Memory trait to verify the impl block - let builder = Memory::reserve(&memory, 1024); - assert!(builder.capacity() >= 1024); - } - - #[test] - fn relocate_forwards_to_wrapped_provider() { - // A provider whose relocate is observable, to verify forwarding. - #[derive(Clone, Debug)] - struct TrackingMemory { - relocated: Arc, - inner: GlobalPool, - } - - impl Memory for TrackingMemory { - fn reserve(&self, min_bytes: usize) -> crate::BytesBuf { - self.inner.reserve(min_bytes) - } - } - - impl ThreadAware for TrackingMemory { - fn relocate(&mut self, source: Option<&Thread>, destination: &Thread) { - self.relocated.fetch_add(1, atomic::Ordering::SeqCst); - self.inner.relocate(source, destination); - } - } - - let relocated = Arc::new(AtomicUsize::new(0)); - let mut memory = OpaqueMemory::new(TrackingMemory { - relocated: Arc::clone(&relocated), - inner: GlobalPool::new(), - }); - - _ = Relocator::between_threads().relocate(&mut memory); - - assert_eq!(relocated.load(atomic::Ordering::SeqCst), 1); - } -} diff --git a/crates/bytesbuf/src/mem/testing/fixed_block.rs b/crates/bytesbuf/src/mem/testing/fixed_block.rs index 651cf82a3d..ef7f2920c0 100644 --- a/crates/bytesbuf/src/mem/testing/fixed_block.rs +++ b/crates/bytesbuf/src/mem/testing/fixed_block.rs @@ -125,39 +125,3 @@ impl FixedBlockMemoryInner { BytesBuf::from_blocks(blocks) } } - -#[cfg_attr(coverage_nightly, coverage(off))] -#[cfg(test)] -mod tests { - use new_zealand::nz; - use static_assertions::assert_impl_all; - - use super::*; - use crate::BytesView; - use crate::mem::MemoryShared; - - assert_impl_all!(FixedBlockMemory: MemoryShared, ThreadAware); - - #[test] - fn byte_by_byte() { - let memory = FixedBlockMemory::new(nz!(1)); - - let buf = memory.reserve(0); - assert_eq!(buf.len(), 0); - assert_eq!(buf.capacity(), 0); - - let mut data = BytesView::copied_from_slice(b"Hello, world", &memory); - assert_eq!(data, b"Hello, world"); - - assert_eq!(data.first_slice().len(), 1); - - let mut chunks_encountered: usize = 0; - - data.consume_all_slices(|chunk| { - chunks_encountered = chunks_encountered.saturating_add(1); - assert_eq!(chunk.len(), 1); - }); - - assert_eq!(chunks_encountered, 12); - } -} diff --git a/crates/bytesbuf/src/mem/testing/transparent.rs b/crates/bytesbuf/src/mem/testing/transparent.rs index fb42f8ccbb..7480f3582a 100644 --- a/crates/bytesbuf/src/mem/testing/transparent.rs +++ b/crates/bytesbuf/src/mem/testing/transparent.rs @@ -108,55 +108,3 @@ fn reserve(min_bytes: usize) -> crate::BytesBuf { BytesBuf::from_blocks(blocks) } - -#[cfg_attr(coverage_nightly, coverage(off))] -#[cfg(test)] -mod tests { - use static_assertions::assert_impl_all; - - use super::*; - use crate::mem::MemoryShared; - - assert_impl_all!(TransparentMemory: MemoryShared, ThreadAware); - - #[test] - fn smoke_test() { - let memory = TransparentMemory::new(); - - let mut buf = memory.reserve(0); - assert_eq!(buf.len(), 0); - assert_eq!(buf.capacity(), 0); - - buf = memory.reserve(1313); - - assert_eq!(buf.capacity(), 1313); - - buf.put_byte_repeated(3, 1313); - - let data = buf.consume_all(); - - assert_eq!(data.len(), 1313); - assert_eq!(data.first_slice().len(), 1313); - } - - #[test] - fn giant_allocation() { - // This test requires at least 5 GB of memory to run. The publishing pipeline runs on a system - // where this may not be available, so we skip this test in that environment. - #[cfg(all(not(miri), any(target_os = "linux", target_os = "windows")))] - if crate::testing::system_memory() < 10_000_000_000 { - eprintln!("Skipping giant allocation test due to insufficient memory."); - return; - } - - // This is a giant allocation that does not fit into one memory block. - - let memory = TransparentMemory::new(); - let buf = memory.reserve(5_000_000_000); - - assert_eq!(buf.capacity(), 5_000_000_000); - - // NB! We cannot simply check the first chunk length because there is no guarantee on which - // order a BytesBuf consumes its blocks in - the first might not be u32::MAX here! - } -} diff --git a/crates/bytesbuf/src/memory_guard.rs b/crates/bytesbuf/src/memory_guard.rs index 34be9ccd88..0a0956867d 100644 --- a/crates/bytesbuf/src/memory_guard.rs +++ b/crates/bytesbuf/src/memory_guard.rs @@ -47,6 +47,7 @@ impl Default for MemoryGuard { #[cfg_attr(coverage_nightly, coverage(off))] #[cfg(test)] mod tests { + // The assertion inspects the private block-reference collection. use super::*; #[expect(clippy::used_underscore_binding, reason = "Sometimes, you gotta do what you gotta do.")] diff --git a/crates/bytesbuf/src/span.rs b/crates/bytesbuf/src/span.rs index fecd3ecd7d..5cb202b62f 100644 --- a/crates/bytesbuf/src/span.rs +++ b/crates/bytesbuf/src/span.rs @@ -198,6 +198,7 @@ unsafe impl Sync for Span {} #[cfg_attr(coverage_nightly, coverage(off))] #[cfg(test)] mod tests { + // Span operations and layout are private and cannot be called through the public API. use std::num::NonZero; use new_zealand::nz; diff --git a/crates/bytesbuf/src/span_builder.rs b/crates/bytesbuf/src/span_builder.rs index 493b366317..53a0b35478 100644 --- a/crates/bytesbuf/src/span_builder.rs +++ b/crates/bytesbuf/src/span_builder.rs @@ -287,6 +287,7 @@ unsafe impl Sync for SpanBuilder {} #[cfg_attr(coverage_nightly, coverage(off))] #[cfg(test)] mod tests { + // SpanBuilder operations and layout are private and cannot be called through the public API. use new_zealand::nz; use static_assertions::assert_impl_all; diff --git a/crates/bytesbuf/src/telemetry.rs b/crates/bytesbuf/src/telemetry.rs index 8535a26b82..961bbce1de 100644 --- a/crates/bytesbuf/src/telemetry.rs +++ b/crates/bytesbuf/src/telemetry.rs @@ -97,6 +97,7 @@ const fn identity_after_allocation_race(existing: u64) -> u64 { #[cfg(all(test, feature = "seismograph"))] mod tests { + // The test exercises private identity transfer and clearing primitives. use super::*; #[test] diff --git a/crates/bytesbuf/src/vec.rs b/crates/bytesbuf/src/vec.rs index 99769872aa..0484badebb 100644 --- a/crates/bytesbuf/src/vec.rs +++ b/crates/bytesbuf/src/vec.rs @@ -198,68 +198,11 @@ impl Iterator for VecBlockIterator { } } -#[cfg_attr(coverage_nightly, coverage(off))] #[cfg(test)] mod tests { + // These cases inspect the size hint of the private block iterator. use super::*; - #[test] - fn vec_into_view() { - let vec = vec![1, 2, 3, 4, 5]; - let mut view: BytesView = vec.into(); - assert_eq!(view.len(), 5); - - assert_eq!(view.get_byte(), 1); - assert_eq!(view.get_byte(), 2); - assert_eq!(view.get_byte(), 3); - assert_eq!(view.get_byte(), 4); - assert_eq!(view.get_byte(), 5); - - assert!(view.is_empty()); - } - - #[test] - fn zero_sized_vec() { - let vec = Vec::::new(); - let view: BytesView = vec.into(); - - assert_eq!(view.len(), 0); - assert!(view.is_empty()); - } - - #[test] - fn test_vec_to_view() { - let vec = vec![b'H', b'e', b'l', b'l', b'o', b',', b' ', b'w', b'o', b'r', b'l', b'd', b'!']; - - let vec_data_ptr = vec.as_ptr(); - - let view: BytesView = vec.into(); - - assert_eq!(view.len(), 13); - assert_eq!(view, b"Hello, world!"); - - // We expect this to be zero-copy - Vec to BytesView always is. - assert_eq!(view.first_slice().as_ptr(), vec_data_ptr); - } - - #[test] - fn test_giant_vec_to_view() { - // This test requires at least 5 GB of memory to run. The publishing pipeline runs on a system - // where this may not be available, so we skip this test in that environment. - #[cfg(all(not(miri), any(target_os = "linux", target_os = "windows")))] - if crate::testing::system_memory() < 10_000_000_000 { - eprintln!("Skipping giant allocation test due to insufficient memory."); - return; - } - - let vec = vec![0u8; 5_000_000_000]; - - let view: BytesView = vec.into(); - assert_eq!(view.len(), 5_000_000_000); - assert_eq!(view.first_slice().len(), u32::MAX as usize); - assert_eq!(view.into_spans_reversed().len(), 2); - } - #[test] fn test_vec_block_iterator_size_hint_single_block() { let vec = vec![b'H', b'e', b'l', b'l', b'o', b',', b' ', b'w', b'o', b'r', b'l', b'd', b'!']; diff --git a/crates/bytesbuf/src/view.rs b/crates/bytesbuf/src/view.rs index 6c36a3c5e4..b62e05f3ce 100644 --- a/crates/bytesbuf/src/view.rs +++ b/crates/bytesbuf/src/view.rs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +#[cfg(not(test))] use alloc::vec::Vec; use core::hash::{Hash, Hasher}; use core::iter; @@ -127,20 +128,6 @@ impl BytesView { } } - /// (For testing) Concatenates a number of spans, yielding a view that combines the spans. - /// - /// Later changes made to the input spans will not be reflected in the resulting view. - #[cfg(test)] - pub(crate) fn from_spans(spans: I) -> Self - where - I: IntoIterator, - ::IntoIter: iter::DoubleEndedIterator, - { - let spans_reversed = spans.into_iter().rev().collect::>(); - - Self::from_spans_reversed(spans_reversed) - } - /// Concatenates a number of existing byte sequences, yielding a combined view. /// /// # Example @@ -1126,848 +1113,10 @@ std::thread_local! { .build(); } -#[cfg_attr(coverage_nightly, coverage(off))] #[cfg(test)] mod tests { - #![allow( - clippy::indexing_slicing, - clippy::needless_range_loop, - clippy::arithmetic_side_effects, - reason = "This is all fine in test code" - )] - - use std::pin::pin; - use std::thread; - - use new_zealand::nz; - use static_assertions::{assert_impl_all, assert_not_impl_any}; - use testing_aids::assert_panic; - + // The size assertion includes the private BufferIdentity layout. use super::*; - use crate::BytesBuf; - use crate::mem::testing::{TestMemoryBlock, TransparentMemory, std_alloc_block}; - - assert_impl_all!(BytesView: Send, Sync, Eq); - - // BytesView intentionally does not implement From<&[u8]> because creating a view - // requires a memory provider to ensure optimal memory configuration. Users should - // call `BytesView::copied_from_slice()` instead, which makes the memory provider - // requirement explicit. - assert_not_impl_any!(BytesView: From<&'static [u8]>); - - #[test] - fn smoke_test() { - let mut span_builder = std_alloc_block::allocate(nz!(10)).into_span_builder(); - - span_builder.put_slice(&1234_u64.to_ne_bytes()); - span_builder.put_slice(&16_u16.to_ne_bytes()); - - let span1 = span_builder.consume(nz!(4)); - let span2 = span_builder.consume(nz!(3)); - let span3 = span_builder.consume(nz!(3)); - - assert_eq!(0, span_builder.remaining_capacity()); - assert_eq!(span1.len(), 4); - assert_eq!(span2.len(), 3); - assert_eq!(span3.len(), 3); - - let mut view = BytesView::from_spans(vec![span1, span2, span3]); - - assert!(!view.is_empty()); - assert_eq!(10, view.len()); - - let slice = view.first_slice(); - assert_eq!(4, slice.len()); - - // We read 8 bytes here, so should land straight inside span3. - assert_eq!(view.get_u64_ne(), 1234); - - assert_eq!(2, view.len()); - - let slice = view.first_slice(); - assert_eq!(2, slice.len()); - - assert_eq!(view.get_u16_ne(), 16); - - assert_eq!(0, view.len()); - assert!(view.is_empty()); - } - - #[test] - fn oob_is_panic() { - let mut span_builder = std_alloc_block::allocate(nz!(10)).into_span_builder(); - - span_builder.put_slice(&1234_u64.to_ne_bytes()); - span_builder.put_slice(&16_u16.to_ne_bytes()); - - let span1 = span_builder.consume(nz!(4)); - let span2 = span_builder.consume(nz!(3)); - let span3 = span_builder.consume(nz!(3)); - - let mut view = BytesView::from_spans(vec![span1, span2, span3]); - - assert_eq!(10, view.len()); - - assert_eq!(view.get_u64_ne(), 1234); - assert_panic!(_ = view.get_u32_ne()); // Reads 4 but only has 2 remaining. - } - - #[test] - fn extend_lifetime_references_all_blocks() { - // We need to detect here whether a block is being released (i.e. ref count goes to zero). - - // SAFETY: We are not allowed to drop this until all BlockRef are gone. This is fine - // because it is dropped at the end of the function, after all BlockRef instances. - let block1 = unsafe { TestMemoryBlock::new(nz!(8), None) }; - let block1 = pin!(block1); - - // SAFETY: We are not allowed to drop this until all BlockRef are gone. This is fine - // because it is dropped at the end of the function, after all BlockRef instances. - let block2 = unsafe { TestMemoryBlock::new(nz!(8), None) }; - let block2 = pin!(block2); - - let guard = { - // SAFETY: We guarantee exclusive access to the memory capacity. - let mut span_builder1 = unsafe { block1.as_ref().to_block() }.into_span_builder(); - // SAFETY: We guarantee exclusive access to the memory capacity. - let mut span_builder2 = unsafe { block2.as_ref().to_block() }.into_span_builder(); - - span_builder1.put_slice(&1234_u64.to_ne_bytes()); - span_builder2.put_slice(&1234_u64.to_ne_bytes()); - - let span1 = span_builder1.consume(nz!(8)); - let span2 = span_builder2.consume(nz!(8)); - - let view = BytesView::from_spans(vec![span1, span2]); - - view.extend_lifetime() - }; - - // The sequence was destroyed and all BlockRefs it was holding are gone. - // However, the lifetime guard is still alive and has a BlockRef. - - assert_eq!(block1.ref_count(), 1); - assert_eq!(block2.ref_count(), 1); - - drop(guard); - - // And now they should all be dead. - assert_eq!(block1.ref_count(), 0); - assert_eq!(block2.ref_count(), 0); - } - - #[test] - fn from_views() { - let mut span_builder = std_alloc_block::allocate(nz!(100)).into_span_builder(); - - span_builder.put_slice(&1234_u64.to_ne_bytes()); - span_builder.put_slice(&5678_u64.to_ne_bytes()); - - let span1 = span_builder.consume(nz!(8)); - let span2 = span_builder.consume(nz!(8)); - - let view1 = BytesView::from_spans(vec![span1]); - let view2 = BytesView::from_spans(vec![span2]); - - let mut combined_view = BytesView::from_views(vec![view1, view2]); - - assert_eq!(16, combined_view.len()); - - assert_eq!(combined_view.get_u64_ne(), 1234); - assert_eq!(combined_view.get_u64_ne(), 5678); - } - - #[test] - fn empty_view() { - let view = BytesView::default(); - - assert!(view.is_empty()); - assert_eq!(0, view.len()); - assert_eq!(0, view.first_slice().len()); - } - - #[test] - fn slice_from_single_span_view() { - // A very simple view to start with, consisting of just one 100 byte span. - let span_builder = std_alloc_block::allocate(nz!(100)).into_span_builder(); - - let mut buf = BytesBuf::from_span_builders([span_builder]); - - for i in 0..100 { - buf.put_byte(i); - } - - let view = buf.consume_all(); - - let mut sliced_view = view.range(50..55); - - assert_eq!(5, sliced_view.len()); - assert_eq!(100, view.len()); - - assert_eq!(50, sliced_view.get_byte()); - - assert_eq!(4, sliced_view.len()); - assert_eq!(100, view.len()); - - assert_eq!(51, sliced_view.get_byte()); - assert_eq!(52, sliced_view.get_byte()); - assert_eq!(53, sliced_view.get_byte()); - assert_eq!(54, sliced_view.get_byte()); - - assert_eq!(0, sliced_view.len()); - - assert!(view.range_checked(0..101).is_none()); - assert!(view.range_checked(100..101).is_none()); - assert!(view.range_checked(101..101).is_none()); - } - - #[test] - fn slice_from_multi_span_view() { - const SPAN_SIZE: NonZero = nz!(10); - - // A multi-span view, 10 bytes x10. - let span_builders = iter::repeat_with(|| std_alloc_block::allocate(SPAN_SIZE).into_span_builder()) - .take(10) - .collect::>(); - - let mut buf = BytesBuf::from_span_builders(span_builders); - - for i in 0..100 { - buf.put_byte(i); - } - - let view = buf.consume_all(); - - let mut first5 = view.range(0..5); - assert_eq!(5, first5.len()); - assert_eq!(100, view.len()); - assert_eq!(0, first5.get_byte()); - - let mut last5 = view.range(95..100); - assert_eq!(5, last5.len()); - assert_eq!(100, view.len()); - assert_eq!(95, last5.get_byte()); - - let mut middle5 = view.range(49..54); - assert_eq!(5, middle5.len()); - assert_eq!(100, view.len()); - assert_eq!(49, middle5.get_byte()); - assert_eq!(50, middle5.get_byte()); - assert_eq!(51, middle5.get_byte()); - assert_eq!(52, middle5.get_byte()); - assert_eq!(53, middle5.get_byte()); - - assert!(view.range_checked(0..101).is_none()); - assert!(view.range_checked(100..101).is_none()); - assert!(view.range_checked(101..101).is_none()); - } - - #[test] - fn slice_indexing_kinds() { - let span_builder = std_alloc_block::allocate(nz!(10)).into_span_builder(); - - let mut buf = BytesBuf::from_span_builders([span_builder]); - buf.put_byte(0); - buf.put_byte(1); - buf.put_byte(2); - buf.put_byte(3); - buf.put_byte(4); - buf.put_byte(5); - - let data = buf.consume_all(); - - let mut middle_four = data.range(1..5); - assert_eq!(4, middle_four.len()); - assert_eq!(1, middle_four.get_byte()); - assert_eq!(2, middle_four.get_byte()); - assert_eq!(3, middle_four.get_byte()); - assert_eq!(4, middle_four.get_byte()); - - let mut middle_four = data.range(1..=4); - assert_eq!(4, middle_four.len()); - assert_eq!(1, middle_four.get_byte()); - assert_eq!(2, middle_four.get_byte()); - assert_eq!(3, middle_four.get_byte()); - assert_eq!(4, middle_four.get_byte()); - - let mut last_two = data.range(4..); - assert_eq!(2, last_two.len()); - assert_eq!(4, last_two.get_byte()); - assert_eq!(5, last_two.get_byte()); - - let mut first_two = data.range(..2); - assert_eq!(2, first_two.len()); - assert_eq!(0, first_two.get_byte()); - assert_eq!(1, first_two.get_byte()); - - let mut first_two = data.range(..=1); - assert_eq!(2, first_two.len()); - assert_eq!(0, first_two.get_byte()); - assert_eq!(1, first_two.get_byte()); - } - - #[test] - fn slice_checked_with_excluded_start_bound() { - let span_builder = std_alloc_block::allocate(nz!(100)).into_span_builder(); - - let mut buf = BytesBuf::from_span_builders([span_builder]); - buf.put_byte(0); - buf.put_byte(1); - buf.put_byte(2); - buf.put_byte(3); - buf.put_byte(4); - buf.put_byte(5); - buf.put_byte(6); - buf.put_byte(7); - buf.put_byte(8); - - let view = buf.consume_all(); - - // Test with excluded start bound: (Bound::Excluded(1), Bound::Excluded(5)) - // This should be equivalent to 2..5 (items at indices 2, 3, 4) - let sliced = view.range_checked((Bound::Excluded(1), Bound::Excluded(5))); - assert!(sliced.is_some()); - let mut sliced = sliced.unwrap(); - assert_eq!(3, sliced.len()); - assert_eq!(2, sliced.get_byte()); - assert_eq!(3, sliced.get_byte()); - assert_eq!(4, sliced.get_byte()); - - // Test edge case: excluded start at the last valid index returns empty sequence - let sliced = view.range_checked((Bound::Excluded(8), Bound::Unbounded)); - assert!(sliced.is_some()); - assert_eq!(0, sliced.unwrap().len()); - - // Test edge case: excluded start that would overflow when adding 1 - let sliced = view.range_checked((Bound::Excluded(usize::MAX), Bound::Unbounded)); - assert!(sliced.is_none()); - } - - #[test] - fn slice_oob_is_panic() { - let span_builder = std_alloc_block::allocate(nz!(1000)).into_span_builder(); - - let mut buf = BytesBuf::from_span_builders([span_builder]); - buf.put_byte_repeated(0, 100); - - let view = buf.consume_all(); - - assert_panic!(_ = view.range(0..101)); - assert_panic!(_ = view.range(0..=100)); - assert_panic!(_ = view.range(100..=100)); - assert_panic!(_ = view.range(100..101)); - assert_panic!(_ = view.range(101..)); - assert_panic!(_ = view.range(101..101)); - assert_panic!(_ = view.range(101..=101)); - } - - #[test] - fn slice_at_boundary_is_not_panic() { - let span_builder = std_alloc_block::allocate(nz!(100)).into_span_builder(); - - let mut buf = BytesBuf::from_span_builders([span_builder]); - buf.put_byte_repeated(0, 100); - - let view = buf.consume_all(); - - assert_eq!(0, view.range(0..0).len()); - assert_eq!(1, view.range(0..=0).len()); - assert_eq!(0, view.range(..0).len()); - assert_eq!(1, view.range(..=0).len()); - assert_eq!(0, view.range(100..100).len()); - assert_eq!(0, view.range(99..99).len()); - assert_eq!(1, view.range(99..=99).len()); - assert_eq!(1, view.range(99..).len()); - assert_eq!(100, view.range(..).len()); - } - - #[test] - fn slice_empty_is_empty_if_not_oob() { - let span_builder = std_alloc_block::allocate(nz!(100)).into_span_builder(); - - let mut buf = BytesBuf::from_span_builders([span_builder]); - - for i in 0..100 { - buf.put_byte(i); - } - - let view = buf.consume_all(); - - let sub_view = view.range(50..50); - assert_eq!(0, sub_view.len()); - - // 100 is the index at the end of the view - still in-bounds, if at edge. - let sub_view = view.range(100..100); - assert_eq!(0, sub_view.len()); - assert!(view.range_checked(101..101).is_none()); - } - - #[test] - fn consume_all_slices() { - const SPAN_SIZE: NonZero = nz!(10); - - // A multi-span sequence, 10 bytes x10. - let span_builders = iter::repeat_with(|| std_alloc_block::allocate(SPAN_SIZE).into_span_builder()) - .take(10) - .collect::>(); - - let mut buf = BytesBuf::from_span_builders(span_builders); - - for i in 0..100 { - buf.put_byte(i); - } - - let mut view = buf.consume_all(); - - let mut slice_index = 0; - let mut bytes_consumed = 0; - - view.consume_all_slices(|slice| { - assert_eq!(slice.len(), 10); - bytes_consumed += slice.len(); - - for i in 0..10 { - assert_eq!(slice_index * 10 + i, slice[i] as usize); - } - - slice_index += 1; - }); - - assert_eq!(bytes_consumed, 100); - - view.consume_all_slices(|_| unreachable!("view should now be empty")); - } - - #[test] - fn multithreaded_usage() { - fn post_to_another_thread(view: BytesView) { - thread::spawn(move || { - let mut view = view; - assert_eq!(view.get_byte(), b'H'); - assert_eq!(view.get_byte(), b'e'); - assert_eq!(view.get_byte(), b'l'); - assert_eq!(view.get_byte(), b'l'); - assert_eq!(view.get_byte(), b'o'); - }) - .join() - .unwrap(); - } - - let memory = TransparentMemory::new(); - let view = BytesView::copied_from_slice(b"Hello, world!", &memory); - - post_to_another_thread(view); - } - - #[test] - fn slices_iterator() { - let memory = TransparentMemory::new(); - let segment1 = BytesView::copied_from_slice(b"Hello, world!", &memory); - let segment2 = BytesView::copied_from_slice(b"Hello, another world!", &memory); - - let view = BytesView::from_views(vec![segment1.clone(), segment2.clone()]); - - let slices: Vec<_> = view.slices().collect(); - - assert_eq!(slices.len(), 2); - assert_eq!(slices[0].0.len(), segment1.len()); - assert_eq!(slices[1].0.len(), segment2.len()); - } - - #[test] - fn slices_iterator_empty() { - let view = BytesView::new(); - assert_eq!(view.slices().count(), 0); - } - - #[test] - fn to_vec_single_span() { - let memory = TransparentMemory::new(); - let view = BytesView::copied_from_slice(b"Hello, world!", &memory); - - let bytes = view.to_vec(); - - assert_eq!(bytes, b"Hello, world!"); - // The view is left unchanged. - assert_eq!(view.len(), 13); - } - - #[test] - fn to_vec_multi_span() { - let memory = TransparentMemory::new(); - let segment1 = BytesView::copied_from_slice(b"Hello, ", &memory); - let segment2 = BytesView::copied_from_slice(b"world!", &memory); - - let view = BytesView::from_views(vec![segment1, segment2]); - - let bytes = view.to_vec(); - - assert_eq!(bytes, b"Hello, world!"); - } - - #[test] - fn to_vec_empty() { - let view = BytesView::new(); - - let bytes = view.to_vec(); - - assert!(bytes.is_empty()); - } - - #[test] - fn eq_view() { - let memory = TransparentMemory::new(); - - let view1 = BytesView::copied_from_slice(b"Hello, world!", &memory); - let view2 = BytesView::copied_from_slice(b"Hello, world!", &memory); - - assert_eq!(view1, view2); - - let view3 = BytesView::copied_from_slice(b"Jello, world!", &memory); - - assert_ne!(view1, view3); - - let view4 = BytesView::copied_from_slice(b"Hello, world! ", &memory); - - assert_ne!(view1, view4); - - let view5_part1 = BytesView::copied_from_slice(b"Hello, ", &memory); - let view5_part2 = BytesView::copied_from_slice(b"world!", &memory); - let view5 = BytesView::from_views([view5_part1, view5_part2]); - - assert_eq!(view1, view5); - assert_ne!(view5, view3); - - let view6 = BytesView::copied_from_slice(b"Hello, ", &memory); - - assert_ne!(view1, view6); - assert_ne!(view5, view6); - - // Compare two multi-span views with misaligned span boundaries to exercise - // span index advancement on both sides of the comparison. - let view7_part1 = BytesView::copied_from_slice(b"Hel", &memory); - let view7_part2 = BytesView::copied_from_slice(b"lo, world!", &memory); - let view7 = BytesView::from_views([view7_part1, view7_part2]); - - assert_eq!(view5, view7); - assert_eq!(view7, view5); - } - - #[test] - fn eq_slice() { - let memory = TransparentMemory::new(); - - let view1 = BytesView::copied_from_slice(b"Hello, world!", &memory); - - assert_eq!(view1, b"Hello, world!".as_slice()); - assert_ne!(view1, b"Jello, world!".as_slice()); - assert_ne!(view1, b"Hello, world! ".as_slice()); - - assert_eq!(b"Hello, world!".as_slice(), view1); - assert_ne!(b"Jello, world!".as_slice(), view1); - assert_ne!(b"Hello, world! ".as_slice(), view1); - - let view2_part1 = BytesView::copied_from_slice(b"Hello, ", &memory); - let view2_part2 = BytesView::copied_from_slice(b"world!", &memory); - let view2 = BytesView::from_views([view2_part1, view2_part2]); - - assert_eq!(view2, b"Hello, world!".as_slice()); - assert_ne!(view2, b"Jello, world!".as_slice()); - assert_ne!(view2, b"Hello, world! ".as_slice()); - assert_ne!(view2, b"Hello, ".as_slice()); - - assert_eq!(b"Hello, world!".as_slice(), view2); - assert_ne!(b"Jello, world!".as_slice(), view2); - assert_ne!(b"Hello, world! ".as_slice(), view2); - assert_ne!(b"Hello, ".as_slice(), view2); - } - - #[test] - fn eq_array() { - let memory = TransparentMemory::new(); - - let view1 = BytesView::copied_from_slice(b"Hello, world!", &memory); - - assert_eq!(view1, b"Hello, world!"); - assert_ne!(view1, b"Jello, world!"); - assert_ne!(view1, b"Hello, world! "); - - assert_eq!(b"Hello, world!", view1); - assert_ne!(b"Jello, world!", view1); - assert_ne!(b"Hello, world! ", view1); - - let view2_part1 = BytesView::copied_from_slice(b"Hello, ", &memory); - let view2_part2 = BytesView::copied_from_slice(b"world!", &memory); - let view2 = BytesView::from_views([view2_part1, view2_part2]); - - assert_eq!(view2, b"Hello, world!"); - assert_ne!(view2, b"Jello, world!"); - assert_ne!(view2, b"Hello, world! "); - assert_ne!(view2, b"Hello, "); - - assert_eq!(b"Hello, world!", view2); - assert_ne!(b"Jello, world!", view2); - assert_ne!(b"Hello, world! ", view2); - assert_ne!(b"Hello, ", view2); - } - - #[test] - fn first_slice_meta_empty_view() { - let view = BytesView::new(); - assert!(view.first_slice_meta().is_none()); - } - - #[test] - fn first_slice_meta_no_metadata() { - let memory = TransparentMemory::new(); - let view = BytesView::copied_from_slice(b"Hello", &memory); - // TransparentMemory does not attach metadata. - assert!(view.first_slice_meta().is_none()); - } - - #[test] - fn first_slice_meta_with_metadata() { - #[derive(Debug)] - struct TestMeta; - impl BlockMeta for TestMeta {} - - // SAFETY: We are not allowed to drop this until all BlockRef are gone. This is fine - // because it is dropped at the end of the function, after all BlockRef instances. - let block = unsafe { TestMemoryBlock::new(nz!(100), Some(Box::new(TestMeta))) }; - let block = pin!(block); - - // SAFETY: We guarantee exclusive access to the memory capacity. - let mut span_builder = unsafe { block.as_ref().to_block() }.into_span_builder(); - span_builder.put_slice(b"Hello"); - let span = span_builder.consume(nz!(5)); - - let view = BytesView::from_spans(vec![span]); - - let meta = view.first_slice_meta(); - assert!(meta.is_some()); - assert!(meta.unwrap().is::()); - } - - #[test] - fn meta_none() { - let memory = TransparentMemory::new(); - - let view1 = BytesView::copied_from_slice(b"Hello, ", &memory); - let view2 = BytesView::copied_from_slice(b"world!", &memory); - - let view = BytesView::from_views([view1, view2]); - - let mut slices_iter = view.slices(); - - // We have two chunks, both without metadata. - let (data1, meta1) = slices_iter.next().expect("should have first slice"); - assert!(!data1.is_empty()); - assert!(meta1.is_none()); - - let (data2, meta2) = slices_iter.next().expect("should have second slice"); - assert!(!data2.is_empty()); - assert!(meta2.is_none()); - - assert!(slices_iter.next().is_none()); - } - - #[test] - fn meta_some() { - #[derive(Debug)] - struct GreenMeta; - #[derive(Debug)] - struct BlueMeta; - - impl BlockMeta for GreenMeta {} - impl BlockMeta for BlueMeta {} - - // SAFETY: We are not allowed to drop this until all BlockRef are gone. This is fine - // because it is dropped at the end of the function, after all BlockRef instances. - let block1 = unsafe { TestMemoryBlock::new(nz!(100), Some(Box::new(GreenMeta {}))) }; - let block1 = pin!(block1); - - // SAFETY: We are not allowed to drop this until all BlockRef are gone. This is fine - // because it is dropped at the end of the function, after all BlockRef instances. - let block2 = unsafe { TestMemoryBlock::new(nz!(100), Some(Box::new(BlueMeta {}))) }; - let block2 = pin!(block2); - - // SAFETY: We guarantee exclusive access to the memory capacity. - let block1 = unsafe { block1.as_ref().to_block() }; - // SAFETY: We guarantee exclusive access to the memory capacity. - let block2 = unsafe { block2.as_ref().to_block() }; - - let mut buf = BytesBuf::from_blocks([block1, block2]); - - // Add enough bytes to make use of both blocks. - buf.put_byte_repeated(123, 166); - - let view = buf.consume_all(); - - let mut slices_iter = view.slices(); - - // NB! There is no requirement that the BytesBuf use the blocks in the order we gave - // them in. We use white-box knowledge here to know that it actually reverses the order. - // This behavior may change in a future version - be ready to change the test if so. - - let (data1, meta1) = slices_iter.next().expect("should have first block"); - assert!(!data1.is_empty()); - assert!(meta1.is_some()); - assert!(meta1.unwrap().is::()); - assert!(!meta1.unwrap().is::()); - - let (data2, meta2) = slices_iter.next().expect("should have second block"); - assert!(!data2.is_empty()); - assert!(meta2.is_some()); - assert!(meta2.unwrap().is::()); - assert!(!meta2.unwrap().is::()); - - assert!(slices_iter.next().is_none(), "should have no more slices"); - } - - #[test] - fn append_single_span() { - let memory = TransparentMemory::new(); - - // Create two single-span views. - let mut view1 = BytesView::copied_from_slice(b"Hello, ", &memory); - let view2 = BytesView::copied_from_slice(b"world!", &memory); - - assert_eq!(view1.len(), 7); - assert_eq!(view2.len(), 6); - - view1.append(view2); - - assert_eq!(view1.len(), 13); - assert_eq!(view1, b"Hello, world!"); - } - - #[test] - fn append_multi_span() { - let memory = TransparentMemory::new(); - - // Create two multi-span views (2 spans each) - let view1_part1 = BytesView::copied_from_slice(b"AAA", &memory); - let view1_part2 = BytesView::copied_from_slice(b"BBB", &memory); - let mut view1 = BytesView::from_views([view1_part1, view1_part2]); - - let view2_part1 = BytesView::copied_from_slice(b"CCC", &memory); - let view2_part2 = BytesView::copied_from_slice(b"DDD", &memory); - let view2 = BytesView::from_views([view2_part1, view2_part2]); - - assert_eq!(view1.len(), 6); - assert_eq!(view2.len(), 6); - - view1.append(view2); - - assert_eq!(view1.len(), 12); - assert_eq!(view1, b"AAABBBCCCDDD"); - } - - #[test] - fn append_empty_view() { - let memory = TransparentMemory::new(); - - let mut view1 = BytesView::copied_from_slice(b"Hello", &memory); - let view2 = BytesView::new(); - - view1.append(view2); - assert_eq!(view1.len(), 5); - assert_eq!(view1, b"Hello"); - - let mut view3 = BytesView::new(); - let view4 = BytesView::copied_from_slice(b"world", &memory); - - view3.append(view4); - assert_eq!(view3.len(), 5); - assert_eq!(view3, b"world"); - } - - #[cfg(feature = "seismograph")] - #[test] - fn append_preserves_identity_when_only_one_view_has_data() { - let memory = TransparentMemory::new(); - let mut populated = BytesView::copied_from_slice(b"Hello", &memory); - let populated_id = populated.identity.get_or_allocate(); - populated.append(BytesView::new()); - - let mut empty = BytesView::new(); - let transferred = BytesView::copied_from_slice(b"world", &memory); - let transferred_id = transferred.identity.get_or_allocate(); - empty.append(transferred); - - assert_eq!( - (populated.identity.get_or_allocate(), empty.identity.get_or_allocate()), - (populated_id, transferred_id) - ); - } - - #[test] - fn concat_single_span() { - let memory = TransparentMemory::new(); - - // Create two single-span views - let view1 = BytesView::copied_from_slice(b"Hello, ", &memory); - let view2 = BytesView::copied_from_slice(b"world!", &memory); - - assert_eq!(view1.len(), 7); - assert_eq!(view2.len(), 6); - - let view3 = view1.concat(view2); - - // Original view unchanged - assert_eq!(view1.len(), 7); - assert_eq!(view1, b"Hello, "); - - // New view contains combined data - assert_eq!(view3.len(), 13); - assert_eq!(view3, b"Hello, world!"); - } - - #[test] - fn concat_multi_span() { - let memory = TransparentMemory::new(); - - // Create two multi-span views (2 spans each) - let view1_part1 = BytesView::copied_from_slice(b"AAA", &memory); - let view1_part2 = BytesView::copied_from_slice(b"BBB", &memory); - let view1 = BytesView::from_views([view1_part1, view1_part2]); - - let view2_part1 = BytesView::copied_from_slice(b"CCC", &memory); - let view2_part2 = BytesView::copied_from_slice(b"DDD", &memory); - let view2 = BytesView::from_views([view2_part1, view2_part2]); - - assert_eq!(view1.len(), 6); - assert_eq!(view2.len(), 6); - - let view3 = view1.concat(view2); - - // Original view unchanged - assert_eq!(view1.len(), 6); - assert_eq!(view1, b"AAABBB"); - - // New view contains combined data - assert_eq!(view3.len(), 12); - assert_eq!(view3, b"AAABBBCCCDDD"); - } - - #[test] - fn concat_empty_views() { - let memory = TransparentMemory::new(); - - let view1 = BytesView::copied_from_slice(b"Hello", &memory); - let view2 = BytesView::new(); - - let view3 = view1.concat(view2); - assert_eq!(view3.len(), 5); - assert_eq!(view3, b"Hello"); - - let view4 = BytesView::new(); - let view5 = BytesView::copied_from_slice(b"world", &memory); - - let view6 = view4.concat(view5); - assert_eq!(view6.len(), 5); - assert_eq!(view6, b"world"); - } #[test] fn size_change_detector() { @@ -1976,199 +1125,4 @@ mod tests { // We assume 64-bit pointers - any support for 32-bit is problem for the future. assert_eq!(size_of::(), 272 + size_of::()); } - - #[test] - fn hash_equal_views_produce_same_hash() { - use std::hash::{DefaultHasher, Hash, Hasher}; - - let a = BytesView::from(vec![1, 2, 3, 4, 5]); - let b = BytesView::from(vec![1, 2, 3, 4, 5]); - - let hash_of = |v: &BytesView| { - let mut h = DefaultHasher::new(); - v.hash(&mut h); - h.finish() - }; - - assert_eq!(hash_of(&a), hash_of(&b)); - } - - #[test] - fn hash_multi_span_matches_single_span() { - use std::hash::{DefaultHasher, Hash, Hasher}; - - let single = BytesView::from(vec![1, 2, 3, 4, 5, 6]); - - let mut multi = BytesView::from(vec![1, 2, 3]); - multi.append(BytesView::from(vec![4, 5, 6])); - - let hash_of = |v: &BytesView| { - let mut h = DefaultHasher::new(); - v.hash(&mut h); - h.finish() - }; - - assert_eq!(single, multi); - assert_eq!(hash_of(&single), hash_of(&multi)); - } - - #[test] - fn hash_different_views_produce_different_hash() { - use std::hash::{DefaultHasher, Hash, Hasher}; - - let a = BytesView::from(vec![1, 2, 3]); - let b = BytesView::from(vec![4, 5, 6]); - - let hash_of = |v: &BytesView| { - let mut h = DefaultHasher::new(); - v.hash(&mut h); - h.finish() - }; - - assert_ne!(hash_of(&a), hash_of(&b)); - } - - /// A `Hasher` for which `write(a); write(b)` differs from `write(a ++ b)`, because it mixes the - /// length of every individual `write` call into the state. A correct [`Hash`] implementation - /// must not depend on how the bytes are chunked across `write` calls, so it must produce the - /// same hash for equal views regardless of their span segmentation even under such a hasher. - #[derive(Default)] - struct BoundarySensitiveHasher { - state: u64, - } - - impl Hasher for BoundarySensitiveHasher { - fn finish(&self) -> u64 { - self.state - } - - fn write(&mut self, bytes: &[u8]) { - self.state = self.state.wrapping_mul(31).wrapping_add(bytes.len() as u64); - for &byte in bytes { - self.state = self.state.wrapping_mul(31).wrapping_add(u64::from(byte)); - } - } - } - - #[test] - fn hash_is_independent_of_span_segmentation() { - // Same logical bytes, three different span segmentations: one, two, and three spans. - let one_span = BytesView::from(vec![1, 2, 3, 4, 5, 6]); - - let mut two_spans = BytesView::from(vec![1, 2, 3]); - two_spans.append(BytesView::from(vec![4, 5, 6])); - - let mut three_spans = BytesView::from(vec![1, 2]); - three_spans.append(BytesView::from(vec![3, 4])); - three_spans.append(BytesView::from(vec![5, 6])); - - // All three are equal per the boundary-independent equality. - assert_eq!(one_span, two_spans); - assert_eq!(one_span, three_spans); - - let hash_of = |v: &BytesView| { - let mut h = BoundarySensitiveHasher::default(); - v.hash(&mut h); - h.finish() - }; - - // The Hash/Eq contract requires equal values to hash equally, even under a hasher that is - // sensitive to how bytes are chunked across write() calls. - assert_eq!(hash_of(&one_span), hash_of(&two_spans)); - assert_eq!(hash_of(&one_span), hash_of(&three_spans)); - } - - #[test] - fn hash_is_independent_of_span_segmentation_across_block_boundary() { - // Content longer than HASH_BLOCK_BYTES so hashing spills across multiple blocks, with span - // splits that do not line up with the block boundaries. The hash must still ignore how the - // bytes are segmented into spans. - let content: Vec = (0..=u8::MAX).cycle().take(HASH_BLOCK_BYTES * 2 + 5).collect(); - - let one_span = BytesView::from(content.clone()); - - // Split at offsets that straddle the 64-byte block boundary (before, on, and after it). - let split_points = [1, HASH_BLOCK_BYTES - 3, HASH_BLOCK_BYTES, HASH_BLOCK_BYTES + 7]; - let mut many_spans = BytesView::new(); - let mut previous = 0; - for &point in &split_points { - many_spans.append(BytesView::from(content[previous..point].to_vec())); - previous = point; - } - many_spans.append(BytesView::from(content[previous..].to_vec())); - - assert_eq!(one_span, many_spans); - - let hash_of = |v: &BytesView| { - let mut h = BoundarySensitiveHasher::default(); - v.hash(&mut h); - h.finish() - }; - - assert_eq!(hash_of(&one_span), hash_of(&many_spans)); - } - - /// A `Hasher` that records the exact bytes of every `write` call, so tests can assert that two - /// views drive the hasher with an identical sequence of calls rather than only comparing the - /// final (potentially colliding) hash value. - #[derive(Default)] - struct RecordingHasher { - writes: Vec>, - } - - impl Hasher for RecordingHasher { - fn finish(&self) -> u64 { - 0 - } - - fn write(&mut self, bytes: &[u8]) { - self.writes.push(bytes.to_vec()); - } - } - - #[test] - fn hash_write_sequence_is_identical_regardless_of_segmentation() { - // Splits `content` into spans of at most `segment_len` bytes each. - fn segmented_view(content: &[u8], segment_len: usize) -> BytesView { - let mut view = BytesView::new(); - for chunk in content.chunks(segment_len) { - view.append(BytesView::from(chunk.to_vec())); - } - view - } - - let record = |v: &BytesView| { - let mut h = RecordingHasher::default(); - v.hash(&mut h); - h.writes - }; - - // Cover lengths around the block boundary (HASH_BLOCK_BYTES == 64) and beyond. - for len in [0_usize, 1, 63, 64, 65, 128, 130, 200] { - let content: Vec = (0..=u8::MAX).cycle().take(len).collect(); - - let single = BytesView::from(content.clone()); - let baseline = record(&single); - - // Pin the absolute write sequence: the length prefix followed by the content split - // into HASH_BLOCK_BYTES chunks, with no trailing empty write (`chunks` never yields an - // empty slice, including for an empty view). Asserting the exact sequence - rather than - // only comparing segmentations against each other - is what catches a spurious empty - // trailing write when the length is an exact multiple of the block size. - let mut expected: Vec> = vec![len.to_ne_bytes().to_vec()]; - expected.extend(content.chunks(HASH_BLOCK_BYTES).map(<[u8]>::to_vec)); - assert_eq!(baseline, expected, "unexpected hash write sequence for len {len}"); - - for segment_len in [1, 7, 63, 64, 65, 100] { - let segmented = segmented_view(&content, segment_len); - - assert_eq!(single, segmented, "len {len}, segment {segment_len}"); - assert_eq!( - record(&segmented), - baseline, - "hash write sequence differs for len {len}, segment {segment_len}", - ); - } - } - } } diff --git a/crates/bytesbuf/src/view_get.rs b/crates/bytesbuf/src/view_get.rs index 55db3ba28d..e4525f2ba1 100644 --- a/crates/bytesbuf/src/view_get.rs +++ b/crates/bytesbuf/src/view_get.rs @@ -293,273 +293,3 @@ impl BytesView { get_num_accessors!(f32, get_f32_le, get_f32_be, get_f32_ne); get_num_accessors!(f64, get_f64_le, get_f64_be, get_f64_ne); } - -#[cfg_attr(coverage_nightly, coverage(off))] -#[cfg(test)] -mod tests { - use super::*; - use crate::mem::testing::TransparentMemory; - - #[test] - fn get_byte() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); - - assert_eq!(view.get_byte(), 1); - assert_eq!(view.get_byte(), 2); - assert_eq!(view.get_byte(), 3); - assert_eq!(view.get_byte(), 4); - assert!(view.is_empty()); - } - - #[test] - fn copy_to_slice() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); - - let mut dst = [0u8; 4]; - view.copy_to_slice(&mut dst); - - assert_eq!(dst, [1, 2, 3, 4]); - assert!(view.is_empty()); - } - - #[test] - fn copy_to_smaller_slice_copies_partially() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); - - let mut dst = [0u8; 3]; - view.copy_to_slice(&mut dst); - - assert_eq!(dst, [1, 2, 3]); - assert_eq!(view.len(), 1); - } - - #[test] - #[should_panic] - fn copy_to_bigger_slice_panics() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); - - let mut dst = [0u8; 8]; - view.copy_to_slice(&mut dst); - } - - #[test] - fn copy_to_uninit_slice() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); - - let mut dst = MaybeUninit::<[u8; 4]>::uninit(); - view.copy_to_uninit_slice(dst.as_mut()); - - // SAFETY: It has now been initialized. - let dst = unsafe { dst.assume_init() }; - - assert_eq!(dst, [1, 2, 3, 4]); - assert!(view.is_empty()); - } - - #[test] - fn copy_to_uninit_smaller_slice_copies_partially() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); - - let mut dst = MaybeUninit::<[u8; 3]>::uninit(); - view.copy_to_uninit_slice(dst.as_mut()); - - // SAFETY: It has now been initialized. - let dst = unsafe { dst.assume_init() }; - - assert_eq!(dst, [1, 2, 3]); - assert_eq!(view.len(), 1); - } - - #[test] - #[should_panic] - fn copy_to_uninit_bigger_slice_panics() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); - - let mut dst = [MaybeUninit::::uninit(); 8]; - view.copy_to_uninit_slice(&mut dst); - } - - #[test] - fn copy_to_slice_multi_span() { - let memory = TransparentMemory::new(); - let data_part1 = [10_u8, 20]; - let data_part2 = [30_u8, 40, 50]; - let view_part1 = BytesView::copied_from_slice(&data_part1, &memory); - let view_part2 = BytesView::copied_from_slice(&data_part2, &memory); - let mut view_combined = BytesView::from_views([view_part1, view_part2]); - - let mut dst = [0u8; 5]; - view_combined.copy_to_slice(&mut dst); - assert!(view_combined.is_empty()); - - assert_eq!(dst, [10_u8, 20, 30, 40, 50]); - } - - #[test] - fn copy_to_uninit_slice_multi_span() { - let memory = TransparentMemory::new(); - let data_part1 = [10_u8, 20]; - let data_part2 = [30_u8, 40, 50]; - let view_part1 = BytesView::copied_from_slice(&data_part1, &memory); - let view_part2 = BytesView::copied_from_slice(&data_part2, &memory); - let mut view_combined = BytesView::from_views([view_part1, view_part2]); - - let mut dst = MaybeUninit::<[u8; 5]>::uninit(); - view_combined.copy_to_uninit_slice(dst.as_mut()); - assert!(view_combined.is_empty()); - - // SAFETY: It has now been initialized. - let dst = unsafe { dst.assume_init() }; - - assert_eq!(dst, [10_u8, 20, 30, 40, 50]); - } - - #[test] - fn get_u16_le() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(&[0x34, 0x12, 0x78, 0x56], &memory); - - assert_eq!(view.get_u16_le(), 0x1234); - assert_eq!(view.get_u16_le(), 0x5678); - - assert!(view.is_empty()); - } - - #[test] - fn get_u32_le_multi_span() { - let memory = TransparentMemory::new(); - let view_part1 = BytesView::copied_from_slice(&[0x78_u8, 0x56], &memory); - let view_part2 = BytesView::copied_from_slice(&[0x34_u8, 0x12], &memory); - let mut view_combined = BytesView::from_views([view_part1, view_part2]); - - assert_eq!(view_combined.get_u32_le(), 0x1234_5678); - - assert!(view_combined.is_empty()); - } - - #[test] - fn get_u16_be() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(&[0x12, 0x34, 0x56, 0x78], &memory); - - assert_eq!(view.get_u16_be(), 0x1234); - assert_eq!(view.get_u16_be(), 0x5678); - - assert!(view.is_empty()); - } - - #[test] - fn get_u32_be_multi_span() { - let memory = TransparentMemory::new(); - let view_part1 = BytesView::copied_from_slice(&[0x12_u8, 0x34], &memory); - let view_part2 = BytesView::copied_from_slice(&[0x56_u8, 0x78], &memory); - let mut view_combined = BytesView::from_views([view_part1, view_part2]); - - assert_eq!(view_combined.get_u32_be(), 0x1234_5678); - - assert!(view_combined.is_empty()); - } - - #[test] - fn get_u16_ne() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(&[0x34, 0x12, 0x78, 0x56], &memory); - - if cfg!(target_endian = "big") { - assert_eq!(view.get_u16_ne(), 0x3412); - assert_eq!(view.get_u16_ne(), 0x7856); - } else { - assert_eq!(view.get_u16_ne(), 0x1234); - assert_eq!(view.get_u16_ne(), 0x5678); - } - - assert!(view.is_empty()); - } - - #[test] - fn get_u32_ne_multi_span() { - let memory = TransparentMemory::new(); - let view_part1 = BytesView::copied_from_slice(&[0x78_u8, 0x56], &memory); - let view_part2 = BytesView::copied_from_slice(&[0x34_u8, 0x12], &memory); - let mut view_combined = BytesView::from_views([view_part1, view_part2]); - - if cfg!(target_endian = "big") { - assert_eq!(view_combined.get_u32_ne(), 0x7856_3412); - } else { - assert_eq!(view_combined.get_u32_ne(), 0x1234_5678); - } - - assert!(view_combined.is_empty()); - } - - #[test] - fn get_signed_and_float_round_trip() { - let memory = TransparentMemory::new(); - - let mut data = Vec::new(); - data.extend_from_slice(&(-12345_i16).to_le_bytes()); - data.extend_from_slice(&(-2_000_000_000_i32).to_be_bytes()); - data.extend_from_slice(&(-9_000_000_000_000_i64).to_le_bytes()); - data.extend_from_slice(&i128::MIN.to_be_bytes()); - data.extend_from_slice(&std::f32::consts::PI.to_le_bytes()); - data.extend_from_slice(&std::f64::consts::E.to_be_bytes()); - - let mut view = BytesView::copied_from_slice(&data, &memory); - - assert_eq!(view.get_i16_le(), -12345); - assert_eq!(view.get_i32_be(), -2_000_000_000); - assert_eq!(view.get_i64_le(), -9_000_000_000_000); - assert_eq!(view.get_i128_be(), i128::MIN); - assert_eq!(view.get_f32_le().to_bits(), std::f32::consts::PI.to_bits()); - assert_eq!(view.get_f64_be().to_bits(), std::f64::consts::E.to_bits()); - assert!(view.is_empty()); - } - - #[test] - fn get_wide_value_multi_span() { - let memory = TransparentMemory::new(); - let value: u128 = 0x0123_4567_89AB_CDEF_FEDC_BA98_7654_3210; - let bytes = value.to_le_bytes(); - - // Split at an odd offset so the value straddles the span boundary and exercises buffering. - let view_part1 = BytesView::copied_from_slice(&bytes[..5], &memory); - let view_part2 = BytesView::copied_from_slice(&bytes[5..], &memory); - let mut view = BytesView::from_views([view_part1, view_part2]); - - assert_eq!(view.get_u128_le(), value); - assert!(view.is_empty()); - } - - #[test] - fn get_misaligned_single_span() { - let memory = TransparentMemory::new(); - - // Drop a single leading byte so the eight value bytes sit at an odd offset from the - // allocation base, exercising the fast path against a misaligned source. - let value: u64 = 0x0123_4567_89AB_CDEF; - let mut data = vec![0xFF_u8]; - data.extend_from_slice(&value.to_le_bytes()); - let mut view = BytesView::copied_from_slice(&data, &memory); - - assert_eq!(view.get_byte(), 0xFF); - assert_eq!(view.get_u64_le(), value); - assert!(view.is_empty()); - } - - #[test] - #[should_panic] - fn get_num_insufficient_bytes_panics() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(&[0x00, 0x01, 0x02], &memory); - - // Only three bytes are available, so reading a four-byte value must panic. - let _ = view.get_u32_le(); - } -} diff --git a/crates/bytesbuf/src/view_read.rs b/crates/bytesbuf/src/view_read.rs index 73b3dbee11..7eb24c4318 100644 --- a/crates/bytesbuf/src/view_read.rs +++ b/crates/bytesbuf/src/view_read.rs @@ -28,92 +28,3 @@ impl BufRead for BytesView { self.advance(amount); } } - -#[cfg_attr(coverage_nightly, coverage(off))] -#[cfg(test)] -mod tests { - use std::io::{BufRead, Read}; - - use crate::BytesView; - use crate::mem::testing::TransparentMemory; - - #[test] - fn smoke_test() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(b"Hello, world", &memory); - - let mut buffer = [0u8; 5]; - let bytes_read = view.read(&mut buffer).unwrap(); - - // We use white-box knowledge to know that we always read as much as is available, - // there are no partial reads unless at end of data. This simplifies the test logic. - assert_eq!(bytes_read, 5); - assert_eq!(&buffer, b"Hello"); - - let bytes_read = view.read(&mut buffer).unwrap(); - - assert_eq!(bytes_read, 5); - assert_eq!(&buffer, b", wor"); - - let bytes_read = view.read(&mut buffer).unwrap(); - assert_eq!(bytes_read, 2); - assert_eq!(&buffer[..2], b"ld"); - - let bytes_read = view.read(&mut buffer).unwrap(); - assert_eq!(bytes_read, 0); - } - - #[test] - fn buf_read_fill_buf_and_consume() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(b"Hello, world", &memory); - - // fill_buf returns the first contiguous slice without consuming it. - let buf = view.fill_buf().unwrap(); - assert_eq!(buf, b"Hello, world"); - - // Calling fill_buf again returns the same data (no consumption). - let buf = view.fill_buf().unwrap(); - assert_eq!(buf, b"Hello, world"); - - // Consume some bytes and verify the remainder. - BufRead::consume(&mut view, 7); - let buf = view.fill_buf().unwrap(); - assert_eq!(buf, b"world"); - - // Consume remaining bytes. - BufRead::consume(&mut view, 5); - let buf = view.fill_buf().unwrap(); - assert!(buf.is_empty()); - } - - #[test] - fn buf_read_read_line() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(b"first\nsecond\n", &memory); - - let mut line = String::new(); - let bytes_read = view.read_line(&mut line).unwrap(); - assert_eq!(bytes_read, 6); - assert_eq!(line, "first\n"); - - line.clear(); - let bytes_read = view.read_line(&mut line).unwrap(); - assert_eq!(bytes_read, 7); - assert_eq!(line, "second\n"); - - line.clear(); - let bytes_read = view.read_line(&mut line).unwrap(); - assert_eq!(bytes_read, 0); - assert!(line.is_empty()); - } - - #[test] - fn buf_read_on_empty_view() { - let memory = TransparentMemory::new(); - let mut view = BytesView::copied_from_slice(b"", &memory); - - let buf = view.fill_buf().unwrap(); - assert!(buf.is_empty()); - } -} diff --git a/crates/bytesbuf/tests/public_api.rs b/crates/bytesbuf/tests/public_api.rs new file mode 100644 index 0000000000..5a81273568 --- /dev/null +++ b/crates/bytesbuf/tests/public_api.rs @@ -0,0 +1,54 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests byte sequences through public APIs and existing test fixtures. + +#![cfg_attr(coverage_nightly, feature(coverage_attribute))] + +use bytesbuf::mem; + +#[path = "../src/mem/testing/test_block.rs"] +mod test_block; +#[path = "support/system_memory.rs"] +mod testing; + +#[path = "public_api/buf.rs"] +mod buf; +#[path = "public_api/buf_put.rs"] +mod buf_put; +#[path = "public_api/buf_writer.rs"] +mod buf_writer; +#[cfg(feature = "bytes-compat")] +#[path = "public_api/bytes_compat_buf.rs"] +mod bytes_compat_buf; +#[cfg(feature = "bytes-compat")] +#[path = "public_api/bytes_compat_from_bytes.rs"] +mod bytes_compat_from_bytes; +#[cfg(feature = "bytes-compat")] +#[path = "public_api/bytes_compat_to_bytes.rs"] +mod bytes_compat_to_bytes; +#[cfg(feature = "bytes-compat")] +#[path = "public_api/bytes_compat_view.rs"] +mod bytes_compat_view; +#[path = "public_api/mem_block_ref.rs"] +mod mem_block_ref; +#[path = "public_api/mem_callback_memory.rs"] +mod mem_callback_memory; +#[path = "public_api/mem_global.rs"] +mod mem_global; +#[path = "public_api/mem_memory.rs"] +mod mem_memory; +#[path = "public_api/mem_opaque_memory.rs"] +mod mem_opaque_memory; +#[path = "public_api/mem_testing_fixed_block.rs"] +mod mem_testing_fixed_block; +#[path = "public_api/mem_testing_transparent.rs"] +mod mem_testing_transparent; +#[path = "public_api/vec.rs"] +mod vec; +#[path = "public_api/view.rs"] +mod view; +#[path = "public_api/view_get.rs"] +mod view_get; +#[path = "public_api/view_read.rs"] +mod view_read; diff --git a/crates/bytesbuf/tests/public_api/buf.rs b/crates/bytesbuf/tests/public_api/buf.rs new file mode 100644 index 0000000000..3d7d56d969 --- /dev/null +++ b/crates/bytesbuf/tests/public_api/buf.rs @@ -0,0 +1,1155 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +#![allow(clippy::indexing_slicing, reason = "Fine in test code, we prefer panic on error")] + +use std::mem::MaybeUninit; +use std::pin::pin; + +use bytesbuf::mem::testing::FixedBlockMemory; +use bytesbuf::mem::{BlockMeta, GlobalPool, Memory}; +use bytesbuf::{BytesBuf, BytesView}; +use new_zealand::nz; +use static_assertions::assert_impl_all; +use testing_aids::assert_panic; + +use crate::test_block::TestMemoryBlock; + +const U64_SIZE: usize = size_of::(); +const TWO_U64_SIZE: usize = size_of::() + size_of::(); +const THREE_U64_SIZE: usize = size_of::() + size_of::() + size_of::(); + +assert_impl_all!(BytesBuf: Send, Sync); + +fn write_copy_of_slice(dst: &mut [MaybeUninit], src: &[u8]) { + assert!(dst.len() >= src.len()); + // SAFETY: The destination has enough capacity and does not overlap the source. + unsafe { + src.as_ptr().copy_to_nonoverlapping(dst.as_mut_ptr().cast(), src.len()); + } +} + +// Compile time test +fn _can_use_in_dyn_traits(mem: &dyn Memory) { + let buf = mem.reserve(123); + let _ = buf.into_writer(mem); +} + +#[cfg(feature = "seismograph")] +#[test] +fn seismograph_identity_follows_consumed_data() { + use seismograph_io::Buffer; + + let memory = GlobalPool::new(); + let mut buffer = memory.reserve(16); + buffer.put_slice(*b"abcd"); + let original_id = buffer.recording_state().id(); + + let view = buffer.consume(2); + let cloned = view.clone(); + + assert_eq!(view.recording_state().id(), original_id); + assert_ne!(buffer.recording_state().id(), original_id); + assert_ne!(cloned.recording_state().id(), original_id); + assert_ne!(view.range(..1).recording_state().id(), original_id); +} + +#[cfg(feature = "seismograph")] +#[test] +fn seismograph_recording_state_reports_exact_buffer_shape() { + use seismograph_io::Buffer; + + let memory = FixedBlockMemory::new(nz!(4)); + let mut buffer = memory.reserve(8); + buffer.put_slice(*b"abcdef"); + + let state = buffer.recording_state(); + assert_eq!((state.len(), state.span_count()), (6, 2)); + + let empty = BytesBuf::new(); + let state = empty.recording_state(); + assert_eq!((state.len(), state.span_count()), (0, 0)); +} + +#[cfg(feature = "seismograph")] +#[test] +fn seismograph_io_recording_is_gated_and_captures_buffer_state_delta() { + use seismograph::recorder::event::EventKind; + use seismograph::recorder::{Configuration, EventBufferCapacity, Policy}; + use seismograph::snapshot::{EventBufferDisposition, SnapshotOptions}; + use seismograph_io::{Buffer, IoOutcome, IoResourceKind, Operation, Resource}; + + let release = SnapshotOptions { + event_buffers: EventBufferDisposition::Release, + }; + let memory = FixedBlockMemory::new(nz!(4)); + let mut buffer = memory.reserve(8); + buffer.put_slice(*b"abcdef"); + let resource = Resource::new(IoResourceKind::Other); + + seismograph::recorder(Configuration::default()); + seismograph::snapshot(release).unwrap(); + let disabled = Operation::write_started(&resource, 2, || buffer.recording_state()); + assert!(!disabled.was_recorded()); + disabled.finish(0, IoOutcome::Canceled, || buffer.recording_state()); + let snapshot = seismograph::snapshot(release).unwrap(); + let disabled_events = seismograph::snapshot::decode(snapshot.as_bytes()).unwrap().events; + assert_eq!( + ( + disabled_events.total_events, + disabled_events.lost_events, + disabled_events.threads.len(), + disabled_events.events.len(), + ), + (0, 0, 0, 0) + ); + + seismograph::recorder(Configuration { + io: Policy::all(false), + event_capacity_per_thread: EventBufferCapacity::new(64), + ..Configuration::default() + }); + let initial_state = buffer.recording_state(); + let operation = Operation::write_started(&resource, 2, || buffer.recording_state()); + buffer.put_slice(*b"gh"); + operation.finish(2, IoOutcome::Success, || buffer.recording_state()); + + let snapshot = seismograph::snapshot(release).unwrap(); + let events = seismograph::snapshot::decode(snapshot.as_bytes()).unwrap().events; + let io = events + .events + .iter() + .map(|event| (event.kind, event.io().unwrap())) + .collect::>(); + assert_eq!( + ( + events.total_events, + events.lost_events, + events.threads.len(), + io.iter() + .map(|(kind, event)| (*kind, event.buffer_id, event.buffer_len, event.buffer_span_count)) + .collect::>(), + ), + ( + 2, + 0, + 1, + vec![ + ( + EventKind::IoWriteStarted, + initial_state.id(), + initial_state.len(), + initial_state.span_count(), + ), + (EventKind::IoWriteFinished, initial_state.id(), 8, 2), + ], + ) + ); + seismograph::recorder(Configuration::default()); +} + +#[test] +fn smoke_test() { + let memory = FixedBlockMemory::new(nz!(1234)); + + let min_length = 1000; + + let mut buf = memory.reserve(min_length); + + assert!(buf.capacity() >= min_length); + assert!(buf.remaining_capacity() >= min_length); + assert_eq!(buf.capacity(), buf.remaining_capacity()); + assert_eq!(buf.len(), 0); + assert!(buf.is_empty()); + + buf.put_u64_ne(1234); + buf.put_u64_ne(5678); + buf.put_u64_ne(1234); + buf.put_u64_ne(5678); + + assert_eq!(buf.len(), 32); + assert!(!buf.is_empty()); + + // SAFETY: Writing 0 bytes is always valid. + unsafe { + buf.advance(0); + } + + let mut first_two = buf.consume(TWO_U64_SIZE); + let mut second_two = buf.consume(TWO_U64_SIZE); + + assert_eq!(first_two.len(), 16); + assert_eq!(second_two.len(), 16); + assert_eq!(buf.len(), 0); + + assert_eq!(first_two.get_u64_ne(), 1234); + assert_eq!(first_two.get_u64_ne(), 5678); + + assert_eq!(second_two.get_u64_ne(), 1234); + assert_eq!(second_two.get_u64_ne(), 5678); + + buf.put_u64_ne(1111); + + assert_eq!(buf.len(), 8); + + let mut last = buf.consume(U64_SIZE); + + assert_eq!(last.len(), 8); + assert_eq!(buf.len(), 0); + + assert_eq!(last.get_u64_ne(), 1111); + + assert!(buf.consume_checked(1).is_none()); + assert!(buf.consume_all().is_empty()); +} + +#[test] +fn extend_capacity() { + let mut buf = BytesBuf::new(); + + assert_eq!(buf.capacity(), 0); + assert_eq!(buf.remaining_capacity(), 0); + + let memory = FixedBlockMemory::new(nz!(100)); + + // Have 0, desired 10, requesting 10, will get 100. + buf.reserve(10, &memory); + + assert_eq!(buf.capacity(), 100); + assert_eq!(buf.remaining_capacity(), 100); + + // Write 10 bytes of data just to verify that it does not affect "capacity" logic. + buf.put_u64_ne(1234); + buf.put_u16_ne(5678); + + assert_eq!(buf.len(), 10); + assert_eq!(buf.remaining_capacity(), 90); + assert_eq!(buf.capacity(), 100); + + // Have 100, desired 10+140=150, requesting 50, will get another 100 for a total of 200. + buf.reserve(140, &memory); + + assert_eq!(buf.len(), 10); + assert_eq!(buf.remaining_capacity(), 190); + assert_eq!(buf.capacity(), 200); + + // Have 200, desired 10+200=210, 210-200=10, will get another 100. + buf.reserve(200, &memory); + + assert_eq!(buf.len(), 10); + assert_eq!(buf.remaining_capacity(), 290); + assert_eq!(buf.capacity(), 300); +} + +#[test] +fn append_existing_view() { + let memory = FixedBlockMemory::new(nz!(1234)); + + let min_length = 1000; + + // This one we use to prepare some data to append. + let mut payload_buffer = memory.reserve(min_length); + + // This is where we append the data to. + let mut target_buffer = memory.reserve(min_length); + + // First we make a couple pieces to append. + payload_buffer.put_u64_ne(1111); + payload_buffer.put_u64_ne(2222); + payload_buffer.put_u64_ne(3333); + payload_buffer.put_u64_ne(4444); + + let payload1 = payload_buffer.consume(TWO_U64_SIZE); + let payload2 = payload_buffer.consume(TWO_U64_SIZE); + + // Then we prefill some data to start us off. + target_buffer.put_u64_ne(5555); + target_buffer.put_u64_ne(6666); + + // Consume a little just for extra complexity. + let _ = target_buffer.consume(U64_SIZE); + + // Append the payloads. + target_buffer.put_bytes(payload1); + target_buffer.put_bytes(payload2); + + // Appending an empty byte sequence does nothing. + target_buffer.put_bytes(BytesView::default()); + + // Add some custom data at the end. + target_buffer.put_u64_ne(7777); + + assert_eq!(target_buffer.len(), 48); + + let mut result = target_buffer.consume(48); + + assert_eq!(result.get_u64_ne(), 6666); + assert_eq!(result.get_u64_ne(), 1111); + assert_eq!(result.get_u64_ne(), 2222); + assert_eq!(result.get_u64_ne(), 3333); + assert_eq!(result.get_u64_ne(), 4444); + assert_eq!(result.get_u64_ne(), 7777); +} + +#[test] +fn consume_all_mixed() { + let mut buf = BytesBuf::new(); + let memory = FixedBlockMemory::new(nz!(8)); + + // Reserve some capacity and add initial data. + buf.reserve(16, &memory); + buf.put_u64_ne(1111); + buf.put_u64_ne(2222); + + // Consume some data (the 1111). + let _ = buf.consume(8); + + // Append a sequence (the 3333). + let mut append_buf = BytesBuf::new(); + append_buf.reserve(8, &memory); + append_buf.put_u64_ne(3333); + let reused_bytes_to_append = append_buf.consume_all(); + buf.put_bytes(reused_bytes_to_append); + + // Add more data (the 4444). + buf.reserve(8, &memory); + buf.put_u64_ne(4444); + + // Consume all data and validate we got all the pieces. + let mut result = buf.consume_all(); + + assert_eq!(result.len(), 24); + assert_eq!(result.get_u64_ne(), 2222); + assert_eq!(result.get_u64_ne(), 3333); + assert_eq!(result.get_u64_ne(), 4444); +} + +#[test] +#[expect(clippy::cognitive_complexity, reason = "test code")] +fn peek_basic() { + let mut buf = BytesBuf::new(); + + assert_eq!(buf.capacity(), 0); + assert_eq!(buf.remaining_capacity(), 0); + + let memory = FixedBlockMemory::new(nz!(10)); + + // Peeking an empty buffer is fine, it is just an empty BytesView in that case. + let peeked = buf.peek(); + assert_eq!(peeked.len(), 0); + + buf.reserve(100, &memory); + + assert_eq!(buf.capacity(), 100); + + buf.put_u64_ne(1111); + + // We have 0 frozen spans and 10 span builders, + // the first of which has 8 bytes of filled content. + let mut peeked = buf.peek(); + assert_eq!(peeked.first_slice().len(), 8); + assert_eq!(peeked.get_u64_ne(), 1111); + assert_eq!(peeked.len(), 0); + + buf.put_u64_ne(2222); + buf.put_u64_ne(3333); + buf.put_u64_ne(4444); + buf.put_u64_ne(5555); + buf.put_u64_ne(6666); + buf.put_u64_ne(7777); + buf.put_u64_ne(8888); + // These will cross a span boundary so we can also observe + // crossing that boundary during peeking. + buf.put_byte_repeated(9, 8); + + assert_eq!(buf.len(), 72); + assert_eq!(buf.capacity(), 100); + assert_eq!(buf.remaining_capacity(), 28); + + // We should have 7 frozen spans and 3 span builders, + // the first of which has 2 bytes of filled content. + let mut peeked = buf.peek(); + + assert_eq!(peeked.len(), 72); + + // This should be the first frozen span of 10 bytes. + assert_eq!(peeked.first_slice().len(), 10); + + assert_eq!(peeked.get_u64_ne(), 1111); + assert_eq!(peeked.get_u64_ne(), 2222); + + // The length of the buffer does not change just because we peek at its data. + assert_eq!(buf.len(), 72); + + // We consumed 16 bytes from the peeked view, so should be looking at the remaining 4 bytes in the 2nd span. + assert_eq!(peeked.first_slice().len(), 4); + + assert_eq!(peeked.get_u64_ne(), 3333); + assert_eq!(peeked.get_u64_ne(), 4444); + assert_eq!(peeked.get_u64_ne(), 5555); + assert_eq!(peeked.get_u64_ne(), 6666); + assert_eq!(peeked.get_u64_ne(), 7777); + assert_eq!(peeked.get_u64_ne(), 8888); + + for _ in 0..8 { + assert_eq!(peeked.get_byte(), 9); + } + + assert_eq!(peeked.len(), 0); + assert_eq!(peeked.first_slice().len(), 0); + + // Fill up the remaining 28 bytes of data so we have a full sequence builder. + buf.put_byte_repeated(88, 28); + + let mut peeked = buf.peek(); + peeked.advance(72); + + assert_eq!(peeked.len(), 28); + + for _ in 0..28 { + assert_eq!(peeked.get_byte(), 88); + } +} + +#[test] +fn consume_part_of_frozen_span() { + let mut buf = BytesBuf::new(); + + assert_eq!(buf.capacity(), 0); + assert_eq!(buf.remaining_capacity(), 0); + + let memory = FixedBlockMemory::new(nz!(10)); + + buf.reserve(100, &memory); + + assert_eq!(buf.capacity(), 100); + + buf.put_u64_ne(1111); + // This freezes the first span of 10, as we filled it all up. + buf.put_u64_ne(2222); + + let mut first8 = buf.consume(U64_SIZE); + assert_eq!(first8.get_u64_ne(), 1111); + assert!(first8.is_empty()); + + buf.put_u64_ne(3333); + + let mut second16 = buf.consume(16); + assert_eq!(second16.get_u64_ne(), 2222); + assert_eq!(second16.get_u64_ne(), 3333); + assert!(second16.is_empty()); +} + +#[test] +fn empty_buffer() { + let mut buf = BytesBuf::new(); + assert!(buf.is_empty()); + assert!(buf.peek().is_empty()); + assert_eq!(0, buf.first_unfilled_slice().len()); + + let consumed = buf.consume(0); + assert!(consumed.is_empty()); + + let consumed = buf.consume_all(); + assert!(consumed.is_empty()); +} + +#[test] +fn iter_available_empty_with_capacity() { + let mut buf = BytesBuf::new(); + + assert_eq!(buf.capacity(), 0); + assert_eq!(buf.remaining_capacity(), 0); + + let memory = FixedBlockMemory::new(nz!(100)); + + // Capacity: 0 -> 1000 (10x100) + buf.reserve(1000, &memory); + + assert_eq!(buf.capacity(), 1000); + assert_eq!(buf.remaining_capacity(), 1000); + + let mut write = buf.begin_vectored_write(None); + let iter = write.slices_mut(); + + // Demonstrating that we can access slices concurrently, not only one by one. + let slices: Vec<_> = iter.map(|(s, _)| s).collect(); + + assert_eq!(slices.len(), 10); + + for slice in slices { + assert_eq!(slice.len(), 100); + } + + // After we have dropped all slice references, it is again legal to access the buffer. + // This is blocked by the borrow checker while slice references still exist. + buf.reserve(100, &memory); +} + +#[test] +fn iter_available_nonempty() { + let mut buf = BytesBuf::new(); + + assert_eq!(buf.capacity(), 0); + assert_eq!(buf.remaining_capacity(), 0); + + let memory = FixedBlockMemory::new(nz!(8)); + + // Capacity: 0 -> 16 (2x8) + buf.reserve(TWO_U64_SIZE, &memory); + + assert_eq!(buf.capacity(), 16); + assert_eq!(buf.remaining_capacity(), 16); + + // We write an u64 - this fills half the capacity and should result in + // the first span builder being frozen and the second remaining in its entirety. + buf.put_u64_ne(1234); + + assert_eq!(buf.len(), 8); + assert_eq!(buf.remaining_capacity(), 8); + + let mut write = buf.begin_vectored_write(None); + let available_slices: Vec<_> = write.slices_mut().map(|(s, _)| s).collect(); + assert_eq!(available_slices.len(), 1); + assert_eq!(available_slices[0].len(), 8); + + // We write a u32 - this fills half the remaining capacity, which results + // in a half-filled span builder remaining in the buffer. + buf.put_u32_ne(5678); + + assert_eq!(buf.len(), 12); + assert_eq!(buf.remaining_capacity(), 4); + + let mut write = buf.begin_vectored_write(None); + let available_slices: Vec<_> = write.slices_mut().map(|(s, _)| s).collect(); + assert_eq!(available_slices.len(), 1); + assert_eq!(available_slices[0].len(), 4); + + // We write a final u32 to use up all the capacity. + buf.put_u32_ne(9012); + + assert_eq!(buf.len(), 16); + assert_eq!(buf.remaining_capacity(), 0); + + assert_eq!(buf.begin_vectored_write(None).slices_mut().count(), 0); +} + +#[test] +fn iter_available_empty_no_capacity() { + let mut buf = BytesBuf::new(); + + assert_eq!(buf.capacity(), 0); + assert_eq!(buf.remaining_capacity(), 0); + assert_eq!(buf.begin_vectored_write(None).slices_mut().count(), 0); +} + +#[test] +fn vectored_write_zero() { + let mut buf = BytesBuf::new(); + + assert_eq!(buf.capacity(), 0); + assert_eq!(buf.remaining_capacity(), 0); + + let memory = FixedBlockMemory::new(nz!(8)); + + // Capacity: 0 -> 16 (2x8) + buf.reserve(TWO_U64_SIZE, &memory); + + assert_eq!(buf.capacity(), 16); + assert_eq!(buf.remaining_capacity(), 16); + + let vectored_write = buf.begin_vectored_write(None); + + // SAFETY: Yes, we really wrote 0 bytes. + unsafe { + vectored_write.commit(0); + } + + assert_eq!(buf.capacity(), 16); + assert_eq!(buf.remaining_capacity(), 16); +} + +#[test] +fn vectored_write_one_slice() { + let mut buf = BytesBuf::new(); + + assert_eq!(buf.capacity(), 0); + assert_eq!(buf.remaining_capacity(), 0); + + let memory = FixedBlockMemory::new(nz!(8)); + + // Capacity: 0 -> 8 (1x8) + buf.reserve(U64_SIZE, &memory); + + assert_eq!(buf.capacity(), 8); + assert_eq!(buf.remaining_capacity(), 8); + + let mut vectored_write = buf.begin_vectored_write(None); + + let mut slices: Vec<_> = vectored_write.slices_mut().map(|(s, _)| s).collect(); + assert_eq!(slices.len(), 1); + assert_eq!(slices[0].len(), 8); + + write_copy_of_slice(slices[0], &0x3333_3333_3333_3333_u64.to_ne_bytes()); + + // SAFETY: Yes, we really wrote 8 bytes. + unsafe { + vectored_write.commit(8); + } + + assert_eq!(buf.len(), 8); + assert_eq!(buf.remaining_capacity(), 0); + assert_eq!(buf.capacity(), 8); + + let mut result = buf.consume(U64_SIZE); + assert_eq!(result.get_u64_ne(), 0x3333_3333_3333_3333); +} + +#[test] +fn vectored_write_multiple_slices() { + let mut buf = BytesBuf::new(); + + assert_eq!(buf.capacity(), 0); + assert_eq!(buf.remaining_capacity(), 0); + + let memory = FixedBlockMemory::new(nz!(8)); + + // Capacity: 0 -> 24 (3x8) + buf.reserve(THREE_U64_SIZE, &memory); + + assert_eq!(buf.capacity(), 24); + assert_eq!(buf.remaining_capacity(), 24); + + let mut vectored_write = buf.begin_vectored_write(None); + + let mut slices: Vec<_> = vectored_write.slices_mut().map(|(s, _)| s).collect(); + assert_eq!(slices.len(), 3); + assert_eq!(slices[0].len(), 8); + assert_eq!(slices[1].len(), 8); + assert_eq!(slices[2].len(), 8); + + // We fill 12 bytes, leaving middle chunk split in half between filled/available. + + write_copy_of_slice(slices[0], &0x3333_3333_3333_3333_u64.to_ne_bytes()); + write_copy_of_slice(slices[1], &0x4444_4444_u32.to_ne_bytes()); + + // SAFETY: Yes, we really wrote 12 bytes. + unsafe { + vectored_write.commit(12); + } + + assert_eq!(buf.len(), 12); + assert_eq!(buf.remaining_capacity(), 12); + assert_eq!(buf.capacity(), 24); + + let mut vectored_write = buf.begin_vectored_write(None); + + let mut slices: Vec<_> = vectored_write.slices_mut().map(|(s, _)| s).collect(); + assert_eq!(slices.len(), 2); + assert_eq!(slices[0].len(), 4); + assert_eq!(slices[1].len(), 8); + + // We fill the remaining 12 bytes. + + write_copy_of_slice(slices[0], &0x5555_5555_u32.to_ne_bytes()); + write_copy_of_slice(slices[1], &0x6666_6666_6666_6666_u64.to_ne_bytes()); + + // SAFETY: Yes, we really wrote 12 bytes. + unsafe { + vectored_write.commit(12); + } + + assert_eq!(buf.len(), 24); + assert_eq!(buf.remaining_capacity(), 0); + assert_eq!(buf.capacity(), 24); + + let mut result = buf.consume(THREE_U64_SIZE); + assert_eq!(result.get_u64_ne(), 0x3333_3333_3333_3333); + assert_eq!(result.get_u32_ne(), 0x4444_4444); + assert_eq!(result.get_u32_ne(), 0x5555_5555); + assert_eq!(result.get_u64_ne(), 0x6666_6666_6666_6666); +} + +#[test] +fn vectored_write_max_len() { + let mut buf = BytesBuf::new(); + + assert_eq!(buf.capacity(), 0); + assert_eq!(buf.remaining_capacity(), 0); + + let memory = FixedBlockMemory::new(nz!(8)); + + // Capacity: 0 -> 24 (3x8) + buf.reserve(THREE_U64_SIZE, &memory); + + assert_eq!(buf.capacity(), 24); + assert_eq!(buf.remaining_capacity(), 24); + + // We limit to 13 bytes of visible capacity, of which we will fill 12. + let mut vectored_write = buf.begin_vectored_write(Some(13)); + + let mut slices: Vec<_> = vectored_write.slices_mut().map(|(s, _)| s).collect(); + assert_eq!(slices.len(), 2); + assert_eq!(slices[0].len(), 8); + assert_eq!(slices[1].len(), 5); + + // We fill 12 bytes, leaving middle chunk split in half between filled/available. + + write_copy_of_slice(slices[0], &0x3333_3333_3333_3333_u64.to_ne_bytes()); + write_copy_of_slice(slices[1], &0x4444_4444_u32.to_ne_bytes()); + + // SAFETY: Yes, we really wrote 12 bytes. + unsafe { + vectored_write.commit(12); + } + + assert_eq!(buf.len(), 12); + assert_eq!(buf.remaining_capacity(), 12); + assert_eq!(buf.capacity(), 24); + + // There are 12 remaining and we set max_limit to exactly cover those 12 + let mut vectored_write = buf.begin_vectored_write(Some(12)); + + let mut slices: Vec<_> = vectored_write.slices_mut().map(|(s, _)| s).collect(); + assert_eq!(slices.len(), 2); + assert_eq!(slices[0].len(), 4); + assert_eq!(slices[1].len(), 8); + + write_copy_of_slice(slices[0], &0x5555_5555_u32.to_ne_bytes()); + write_copy_of_slice(slices[1], &0x6666_6666_6666_6666_u64.to_ne_bytes()); + + // SAFETY: Yes, we really wrote 12 bytes. + unsafe { + vectored_write.commit(12); + } + + assert_eq!(buf.len(), 24); + assert_eq!(buf.remaining_capacity(), 0); + assert_eq!(buf.capacity(), 24); + + let mut result = buf.consume(THREE_U64_SIZE); + assert_eq!(result.get_u64_ne(), 0x3333_3333_3333_3333); + assert_eq!(result.get_u32_ne(), 0x4444_4444); + assert_eq!(result.get_u32_ne(), 0x5555_5555); + assert_eq!(result.get_u64_ne(), 0x6666_6666_6666_6666); +} + +#[test] +fn vectored_write_max_len_overflow() { + let mut buf = BytesBuf::new(); + + let memory = FixedBlockMemory::new(nz!(8)); + + // Capacity: 0 -> 24 (3x8) + buf.reserve(THREE_U64_SIZE, &memory); + + assert_eq!(buf.capacity(), 24); + assert_eq!(buf.remaining_capacity(), 24); + + // We ask for 25 bytes of capacity but there are only 24 available. Oops! + assert_panic!(buf.begin_vectored_write(Some(25))); +} + +#[test] +fn vectored_write_overcommit() { + let mut buf = BytesBuf::new(); + + assert_eq!(buf.capacity(), 0); + assert_eq!(buf.remaining_capacity(), 0); + + let memory = FixedBlockMemory::new(nz!(8)); + + // Capacity: 0 -> 16 (2x8) + buf.reserve(TWO_U64_SIZE, &memory); + + assert_eq!(buf.capacity(), 16); + assert_eq!(buf.remaining_capacity(), 16); + + let vectored_write = buf.begin_vectored_write(None); + + assert_panic!( + // SAFETY: Intentionally lying here to trigger a panic. + unsafe { + vectored_write.commit(17); + } + ); +} + +#[test] +fn vectored_write_abort() { + let mut buf = BytesBuf::new(); + + assert_eq!(buf.capacity(), 0); + assert_eq!(buf.remaining_capacity(), 0); + + let memory = FixedBlockMemory::new(nz!(8)); + + // Capacity: 0 -> 8 (1x8) + buf.reserve(U64_SIZE, &memory); + + assert_eq!(buf.capacity(), 8); + assert_eq!(buf.remaining_capacity(), 8); + + let mut vectored_write = buf.begin_vectored_write(None); + + let mut slices: Vec<_> = vectored_write.slices_mut().map(|(s, _)| s).collect(); + assert_eq!(slices.len(), 1); + assert_eq!(slices[0].len(), 8); + + write_copy_of_slice(slices[0], &0x3333_3333_3333_3333_u64.to_ne_bytes()); + + // Actually never mind - we drop it here. + #[expect(clippy::drop_non_drop, reason = "Just being explicit for illustration")] + drop(vectored_write); + + assert_eq!(buf.len(), 0); + assert_eq!(buf.remaining_capacity(), 8); + assert_eq!(buf.capacity(), 8); +} + +#[test] +#[cfg(feature = "std")] +fn from_view() { + let memory = GlobalPool::new(); + + let view1 = BytesView::copied_from_slice(b"bla bla bla", &memory); + + let mut buf: BytesBuf = view1.clone().into(); + + let view2 = buf.consume_all(); + + assert_eq!(view1, view2); +} + +#[test] +fn peek_empty_builder() { + let buf = BytesBuf::new(); + let peeked = buf.peek(); + + assert!(peeked.is_empty()); + assert_eq!(peeked.len(), 0); +} + +#[test] +fn peek_with_frozen_spans_only() { + let memory = FixedBlockMemory::new(nz!(10)); + let mut buf = BytesBuf::new(); + + buf.reserve(20, &memory); + buf.put_u64_ne(0x1111_1111_1111_1111); + buf.put_u64_ne(0x2222_2222_2222_2222); + // Both blocks are now frozen (filled completely) + assert_eq!(buf.len(), 16); + + let mut peeked = buf.peek(); + + assert_eq!(peeked.len(), 16); + assert_eq!(peeked.get_u64_ne(), 0x1111_1111_1111_1111); + assert_eq!(peeked.get_u64_ne(), 0x2222_2222_2222_2222); + + // Original builder still has the data + assert_eq!(buf.len(), 16); +} + +#[test] +fn peek_with_partially_filled_span_builder() { + let memory = FixedBlockMemory::new(nz!(10)); + let mut buf = BytesBuf::new(); + + buf.reserve(10, &memory); + buf.put_u64_ne(0x3333_3333_3333_3333); + buf.put_u16_ne(0x4444); + // We have 10 bytes filled in a 10-byte block + assert_eq!(buf.len(), 10); + + let mut peeked = buf.peek(); + + assert_eq!(peeked.len(), 10); + assert_eq!(peeked.get_u64_ne(), 0x3333_3333_3333_3333); + assert_eq!(peeked.get_u16_ne(), 0x4444); + + // Original builder still has the data + assert_eq!(buf.len(), 10); +} + +#[test] +fn peek_preserves_capacity_of_partial_span_builder() { + let memory = FixedBlockMemory::new(nz!(20)); + let mut buf = BytesBuf::new(); + + buf.reserve(20, &memory); + buf.put_u64_ne(0x5555_5555_5555_5555); + + // We have 8 bytes filled and 12 bytes remaining capacity + assert_eq!(buf.len(), 8); + assert_eq!(buf.remaining_capacity(), 12); + + let mut peeked = buf.peek(); + + assert_eq!(peeked.len(), 8); + assert_eq!(peeked.get_u64_ne(), 0x5555_5555_5555_5555); + + // CRITICAL TEST: Capacity should be preserved + assert_eq!(buf.len(), 8); + assert_eq!(buf.remaining_capacity(), 12); + + // We should still be able to write more data + buf.put_u32_ne(0x6666_6666); + assert_eq!(buf.len(), 12); + assert_eq!(buf.remaining_capacity(), 8); + + // And we can peek again to see the updated data + let mut peeked2 = buf.peek(); + assert_eq!(peeked2.len(), 12); + assert_eq!(peeked2.get_u64_ne(), 0x5555_5555_5555_5555); + assert_eq!(peeked2.get_u32_ne(), 0x6666_6666); +} + +#[test] +fn peek_with_mixed_frozen_and_unfrozen() { + let memory = FixedBlockMemory::new(nz!(10)); + let mut buf = BytesBuf::new(); + + buf.reserve(30, &memory); + + // Fill first block completely (10 bytes) - will be frozen + buf.put_u64_ne(0x1111_1111_1111_1111); + buf.put_u16_ne(0x2222); + + // Fill second block completely (10 bytes) - will be frozen + buf.put_u64_ne(0x3333_3333_3333_3333); + buf.put_u16_ne(0x4444); + + // Partially fill third block (only 4 bytes) - will remain unfrozen + buf.put_u32_ne(0x5555_5555); + + assert_eq!(buf.len(), 24); + assert_eq!(buf.remaining_capacity(), 6); + + let mut peeked = buf.peek(); + + assert_eq!(peeked.len(), 24); + assert_eq!(peeked.get_u64_ne(), 0x1111_1111_1111_1111); + assert_eq!(peeked.get_u16_ne(), 0x2222); + assert_eq!(peeked.get_u64_ne(), 0x3333_3333_3333_3333); + assert_eq!(peeked.get_u16_ne(), 0x4444); + assert_eq!(peeked.get_u32_ne(), 0x5555_5555); + // Original builder still has all the data and capacity + assert_eq!(buf.len(), 24); + assert_eq!(buf.remaining_capacity(), 6); +} + +#[test] +fn peek_then_consume() { + let memory = FixedBlockMemory::new(nz!(20)); + let mut buf = BytesBuf::new(); + + buf.reserve(20, &memory); + buf.put_u64_ne(0x7777_7777_7777_7777); + buf.put_u32_ne(0x8888_8888); + assert_eq!(buf.len(), 12); + + // Peek at the data + let mut peeked = buf.peek(); + assert_eq!(peeked.len(), 12); + assert_eq!(peeked.get_u64_ne(), 0x7777_7777_7777_7777); + + // Original builder still has the data + assert_eq!(buf.len(), 12); + + // Now consume some of it + let mut consumed = buf.consume(8); + assert_eq!(consumed.get_u64_ne(), 0x7777_7777_7777_7777); + + // Builder should have less data now + assert_eq!(buf.len(), 4); + + // Peek again should show the remaining data + let mut peeked2 = buf.peek(); + assert_eq!(peeked2.len(), 4); + assert_eq!(peeked2.get_u32_ne(), 0x8888_8888); +} + +#[test] +fn peek_multiple_times() { + let memory = FixedBlockMemory::new(nz!(20)); + let mut buf = BytesBuf::new(); + + buf.reserve(20, &memory); + buf.put_u64_ne(0xAAAA_AAAA_AAAA_AAAA); + + // Peek multiple times - each should work independently + let mut peeked1 = buf.peek(); + let mut peeked2 = buf.peek(); + + assert_eq!(peeked1.get_u64_ne(), 0xAAAA_AAAA_AAAA_AAAA); + assert_eq!(peeked2.get_u64_ne(), 0xAAAA_AAAA_AAAA_AAAA); + + // Original builder still intact + assert_eq!(buf.len(), 8); +} + +#[test] +fn first_unfilled_slice_meta_no_capacity() { + let buf = BytesBuf::new(); + assert!(buf.first_unfilled_slice_meta().is_none()); +} + +#[test] +fn first_unfilled_slice_meta_no_meta() { + let memory = FixedBlockMemory::new(nz!(64)); + let buf = memory.reserve(64); + assert!(buf.first_unfilled_slice_meta().is_none()); +} + +#[test] +fn first_unfilled_slice_meta_with_meta() { + #[derive(Debug)] + struct CustomMeta; + + impl BlockMeta for CustomMeta {} + + // SAFETY: We are not allowed to drop this until all BlockRef are gone. This is fine + // because it is dropped at the end of the function, after all BlockRef instances. + let block = unsafe { TestMemoryBlock::new(nz!(100), Some(Box::new(CustomMeta))) }; + let block = pin!(block); + + // SAFETY: We guarantee exclusive access to the memory capacity. + let block = unsafe { block.as_ref().to_block() }; + + let buf = BytesBuf::from_blocks([block]); + let meta = buf.first_unfilled_slice_meta().expect("should have metadata"); + assert!(meta.is::()); + assert!(!meta.is::()); +} + +#[test] +fn split_off_remaining_basic() { + let memory = FixedBlockMemory::new(nz!(100)); + let mut buf = memory.reserve(100); + + buf.put_u64_ne(1234); + + let remaining_before_split = buf.remaining_capacity(); + + let split = buf.split_off_remaining(20); + + // Original keeps its data and lost the split capacity. + assert_eq!(buf.len(), U64_SIZE); + assert_eq!(buf.remaining_capacity(), remaining_before_split - 20); + + // Split-off buffer has the requested capacity and no data. + assert!(split.remaining_capacity() >= 20); + assert!(split.is_empty()); +} + +#[test] +fn split_off_remaining_write_to_split() { + let memory = FixedBlockMemory::new(nz!(100)); + let mut buf = memory.reserve(100); + + buf.put_u64_ne(1111); + + let mut split = buf.split_off_remaining(40); + + // Write into the split-off buffer. + split.put_u64_ne(2222); + split.put_u64_ne(3333); + + assert_eq!(split.len(), TWO_U64_SIZE); + + let mut split_view = split.consume_all(); + assert_eq!(split_view.get_u64_ne(), 2222); + assert_eq!(split_view.get_u64_ne(), 3333); + + // Original buffer data is unaffected. + let mut original_view = buf.consume_all(); + assert_eq!(original_view.get_u64_ne(), 1111); +} + +#[test] +fn split_off_remaining_all_capacity() { + let memory = FixedBlockMemory::new(nz!(100)); + let mut buf = memory.reserve(100); + let full_capacity = buf.remaining_capacity(); + + let split = buf.split_off_remaining(full_capacity); + + assert_eq!(buf.remaining_capacity(), 0); + assert_eq!(split.remaining_capacity(), full_capacity); +} + +#[test] +fn split_off_remaining_zero() { + let memory = FixedBlockMemory::new(nz!(100)); + let mut buf = memory.reserve(100); + let original_capacity = buf.remaining_capacity(); + + let split = buf.split_off_remaining(0); + + assert_eq!(buf.remaining_capacity(), original_capacity); + assert!(split.is_empty()); + assert_eq!(split.remaining_capacity(), 0); +} + +#[test] +fn split_off_remaining_multi_block() { + let memory = FixedBlockMemory::new(nz!(10)); + + // Reserve enough to trigger multiple blocks. + let mut buf = memory.reserve(30); + + buf.put_u64_ne(1234); + + let original_remaining = buf.remaining_capacity(); + + // Split off more than one block's capacity to exercise draining + partial split. + let mut split = buf.split_off_remaining(15); + + assert_eq!(buf.remaining_capacity(), original_remaining - 15); + assert_eq!(buf.len(), U64_SIZE); + + // The split-off buffer capacity is usable. + split.put_byte_repeated(0xAA, 15); + assert_eq!(split.len(), 15); + + // Original data is unaffected. + let mut original_view = buf.consume(U64_SIZE); + assert_eq!(original_view.get_u64_ne(), 1234); +} + +#[test] +fn split_off_remaining_empty_buffer_no_capacity() { + let mut buf = BytesBuf::new(); + assert_eq!(buf.remaining_capacity(), 0); + + let split = buf.split_off_remaining(0); + + assert_eq!(buf.len(), 0); + assert_eq!(buf.remaining_capacity(), 0); + assert_eq!(split.len(), 0); + assert_eq!(split.remaining_capacity(), 0); +} + +#[test] +fn split_off_remaining_panics_on_overflow() { + let memory = FixedBlockMemory::new(nz!(100)); + let mut buf = memory.reserve(100); + let capacity = buf.remaining_capacity(); + + assert_panic!(buf.split_off_remaining(capacity + 1)); +} + +#[test] +fn split_off_remaining_checked_returns_none() { + let memory = FixedBlockMemory::new(nz!(100)); + let mut buf = memory.reserve(100); + let capacity = buf.remaining_capacity(); + + assert!(buf.split_off_remaining_checked(capacity + 1).is_none()); + + // Buffer is unmodified. + assert_eq!(buf.remaining_capacity(), capacity); +} diff --git a/crates/bytesbuf/tests/public_api/buf_put.rs b/crates/bytesbuf/tests/public_api/buf_put.rs new file mode 100644 index 0000000000..5f4f6720ed --- /dev/null +++ b/crates/bytesbuf/tests/public_api/buf_put.rs @@ -0,0 +1,228 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use bytesbuf::mem::testing::TransparentMemory; +use bytesbuf::{BytesBuf, BytesView}; + +#[test] +fn put_slice() { + let memory = TransparentMemory::new(); + let mut buf = memory.reserve(100); + + let data = [1u8, 2, 3, 4, 5]; + buf.put_slice(data); + + assert_eq!(buf.len(), 5); + assert_eq!(buf.remaining_capacity(), 95); + + let bytes = buf.consume_all(); + + assert_eq!(bytes.len(), 5); + assert_eq!(bytes, &data); +} + +#[test] +fn put_slice_empty() { + let memory = TransparentMemory::new(); + let mut buf = memory.reserve(100); + + buf.put_slice([]); + + assert_eq!(buf.len(), 0); + assert_eq!(buf.remaining_capacity(), 100); +} + +#[test] +fn put_view_single_span() { + let memory = TransparentMemory::new(); + let mut buf = memory.reserve(100); + + let data = [10_u8, 20, 30, 40, 50]; + let view = BytesView::copied_from_slice(&data, &memory); + + buf.put_bytes(view); + + assert_eq!(buf.len(), 5); + // Appending a view brings along its existing memory capacity, consuming none. + assert_eq!(buf.remaining_capacity(), 100); + + let bytes = buf.consume_all(); + + assert_eq!(bytes.len(), 5); + assert_eq!(bytes, &data); +} + +#[test] +fn put_view_multi_span() { + let memory = TransparentMemory::new(); + let mut buf = memory.reserve(100); + + let data_part1 = [10_u8, 20]; + let data_part2 = [30_u8, 40, 50]; + let view_part1 = BytesView::copied_from_slice(&data_part1, &memory); + let view_part2 = BytesView::copied_from_slice(&data_part2, &memory); + let view_combined = BytesView::from_views([view_part1, view_part2]); + + buf.put_bytes(view_combined); + + assert_eq!(buf.len(), 5); + // Appending a view brings along its existing memory capacity, consuming none. + assert_eq!(buf.remaining_capacity(), 100); + + let bytes = buf.consume_all(); + + assert_eq!(bytes.len(), 5); + assert_eq!(bytes, &[10_u8, 20, 30, 40, 50]); +} + +#[test] +fn put_view_empty() { + let memory = TransparentMemory::new(); + let mut buf = memory.reserve(100); + + let view = BytesView::new(); + + buf.put_bytes(view); + + assert_eq!(buf.len(), 0); + assert_eq!(buf.remaining_capacity(), 100); +} + +#[test] +fn put_view_peeked_from_self() { + let memory = TransparentMemory::new(); + let mut buf = memory.reserve(100); + + let data = [1u8, 2, 3, 4, 5]; + buf.put_slice(data); + + let peeked = buf.peek(); + assert_eq!(peeked.len(), 5); + + buf.put_bytes(peeked); + + assert_eq!(buf.len(), 10); + // The peeked view brings along its existing memory capacity, consuming none. + assert_eq!(buf.remaining_capacity(), 95); + + let bytes = buf.consume_all(); + + assert_eq!(bytes.len(), 10); + assert_eq!(bytes, &[1u8, 2, 3, 4, 5, 1, 2, 3, 4, 5]); +} + +#[test] +fn put_byte() { + let memory = TransparentMemory::new(); + let mut buf = memory.reserve(10); + + buf.put_byte(0xAB); + buf.put_byte(0xCD); + + assert_eq!(buf.len(), 2); + assert_eq!(buf.remaining_capacity(), 8); + + let bytes = buf.consume_all(); + + assert_eq!(bytes.len(), 2); + assert_eq!(bytes, &[0xAB, 0xCD]); +} + +#[test] +fn put_bytes() { + let memory = TransparentMemory::new(); + let mut buf = memory.reserve(10); + + buf.put_byte_repeated(0xFF, 5); + + assert_eq!(buf.len(), 5); + assert_eq!(buf.remaining_capacity(), 5); + + let bytes = buf.consume_all(); + + assert_eq!(bytes.len(), 5); + assert_eq!(bytes, &[0xFF; 5]); +} + +#[test] +fn put_bytes_into_multi_span() { + let memory = TransparentMemory::new(); + let mut buf = BytesBuf::new(); + + // Result: 5 + buf.reserve(5, &memory); + // Result: 5 + 5 + buf.reserve(10, &memory); + + buf.put_byte_repeated(0xAA, 10); + + assert_eq!(buf.len(), 10); + assert_eq!(buf.remaining_capacity(), 0); + + let bytes = buf.consume_all(); + + assert_eq!(bytes.len(), 10); + assert_eq!(bytes, &[0xAA; 10]); +} + +#[test] +fn put_num() { + let memory = TransparentMemory::new(); + let mut buf = memory.reserve(16); + + buf.put_u32_le(0x1234_5678); + buf.put_u32_be(0x9ABC_DEF0); + buf.put_u64_ne(0x1122_3344_5566_7788); + + assert_eq!(buf.len(), 16); + assert_eq!(buf.remaining_capacity(), 0); + + let bytes = buf.consume_all(); + + assert_eq!(bytes.len(), 16); + + if cfg!(target_endian = "big") { + assert_eq!( + bytes, + &[ + 0x78, 0x56, 0x34, 0x12, // Little-endian 0x12345678 + 0x9A, 0xBC, 0xDE, 0xF0, // Big-endian 0x9ABCDEF0 + 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 // Native-endian 0x1122334455667788 + ] + ); + } else { + assert_eq!( + bytes, + &[ + 0x78, 0x56, 0x34, 0x12, // Little-endian 0x12345678 + 0x9A, 0xBC, 0xDE, 0xF0, // Big-endian 0x9ABCDEF0 + 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11 // Native-endian 0x1122334455667788 + ] + ); + } +} + +#[test] +fn put_num_signed_and_float_round_trip() { + let memory = TransparentMemory::new(); + let mut buf = memory.reserve(64); + + buf.put_i16_le(-12345); + buf.put_i32_be(-2_000_000_000); + buf.put_i64_le(-9_000_000_000_000); + buf.put_i128_be(i128::MIN); + buf.put_f32_le(std::f32::consts::PI); + buf.put_f64_be(std::f64::consts::E); + + let mut view = buf.consume_all(); + + assert_eq!(view.get_i16_le(), -12345); + assert_eq!(view.get_i32_be(), -2_000_000_000); + assert_eq!(view.get_i64_le(), -9_000_000_000_000); + assert_eq!(view.get_i128_be(), i128::MIN); + assert_eq!(view.get_f32_le().to_bits(), std::f32::consts::PI.to_bits()); + assert_eq!(view.get_f64_be().to_bits(), std::f64::consts::E.to_bits()); + assert!(view.is_empty()); +} diff --git a/crates/bytesbuf/tests/public_api/buf_writer.rs b/crates/bytesbuf/tests/public_api/buf_writer.rs new file mode 100644 index 0000000000..71bb4d01fe --- /dev/null +++ b/crates/bytesbuf/tests/public_api/buf_writer.rs @@ -0,0 +1,125 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use std::io::Write; + +use bytesbuf::BytesBuf; +use bytesbuf::mem::testing::{FixedBlockMemory, TransparentMemory}; +use new_zealand::nz; + +#[test] +fn smoke_test_write_and_verify_data() { + let test_data = b"Hello, world! This is a test."; + + let memory = TransparentMemory::new(); + let builder = memory.reserve(100); + + let mut write_adapter = builder.into_writer(&memory); + + // no-op + write_adapter.flush().unwrap(); + + let bytes_written = write_adapter.write(test_data).expect("write should succeed"); + assert_eq!(bytes_written, test_data.len()); + + let mut builder = write_adapter.into_inner(); + let data = builder.consume_all(); + assert_eq!(data, test_data.as_slice()); +} + +#[test] +fn existing_content_is_preserved() { + let memory = TransparentMemory::new(); + let mut builder = memory.reserve(100); + + // Add some initial content to the builder + let initial_data = b"Initial content"; + builder.put_slice(initial_data.as_slice()); + + let mut write_adapter = builder.into_writer(&memory); + + let additional_data = b" - Additional data"; + let bytes_written = write_adapter.write(additional_data).expect("write should succeed"); + assert_eq!(bytes_written, additional_data.len()); + + let mut builder = write_adapter.into_inner(); + // Verify both initial and additional data are present + let data = builder.consume_all(); + let expected = b"Initial content - Additional data"; + assert_eq!(data, expected.as_slice()); +} + +#[test] +fn sufficient_capacity_not_extended() { + let test_data = b"Small data"; // Much smaller than 100 bytes + + let memory = FixedBlockMemory::new(nz!(1024)); + let builder = memory.reserve(100); + + let initial_capacity = builder.capacity(); + assert!(initial_capacity >= 100); + + let mut write_adapter = builder.into_writer(&memory); + + // Write data that fits within existing capacity + let bytes_written = write_adapter.write(test_data).expect("write should succeed"); + assert_eq!(bytes_written, test_data.len()); + + let mut builder = write_adapter.into_inner(); + + // Verify capacity hasn't changed (no new allocation needed) + assert_eq!(builder.capacity(), initial_capacity); + + // Verify the data is there + let data = builder.consume_all(); + assert_eq!(data, test_data.as_slice()); +} + +#[test] +fn empty_buffer_small_write_reserves_initial_size() { + let memory = TransparentMemory::new(); + let buf = BytesBuf::new(); + assert_eq!(buf.capacity(), 0); + + let mut writer = buf.into_writer(&memory); + writer.write_all(b"hello").unwrap(); + + let buf = writer.into_inner(); + assert!(buf.capacity() >= 4096, "expected capacity >= 4096, got {}", buf.capacity()); +} + +#[test] +fn empty_buffer_large_write_reserves_growth_size() { + let memory = TransparentMemory::new(); + let buf = BytesBuf::new(); + + let payload = vec![0u8; 4096 + 1]; + + let mut writer = buf.into_writer(&memory); + writer.write_all(&payload).unwrap(); + + let buf = writer.into_inner(); + assert!(buf.capacity() >= 65536, "expected capacity >= 65536, got {}", buf.capacity()); +} + +#[test] +fn non_empty_buffer_reserves_growth_size() { + let memory = TransparentMemory::new(); + let mut buf = memory.reserve(16); + buf.put_slice([1; 16]); + assert_eq!(buf.remaining_capacity(), 0); + assert!(buf.capacity() > 0); + + let mut writer = buf.into_writer(&memory); + writer.write_all(b"more data").unwrap(); + + let buf = writer.into_inner(); + assert!( + buf.capacity() >= 16 + 65536, + "expected capacity >= {}, got {}", + 16 + 65536, + buf.capacity() + ); +} diff --git a/crates/bytesbuf/tests/public_api/bytes_compat_buf.rs b/crates/bytesbuf/tests/public_api/bytes_compat_buf.rs new file mode 100644 index 0000000000..7c310f953b --- /dev/null +++ b/crates/bytesbuf/tests/public_api/bytes_compat_buf.rs @@ -0,0 +1,49 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use bytes::BufMut; +use bytesbuf::mem::testing::TransparentMemory; + +#[test] +fn buf_mut_compat() { + let memory = TransparentMemory::new(); + let mut buf = memory.reserve(100); + + assert_eq!(BufMut::remaining_mut(&buf), 100); + + // 100 + 100 + buf.reserve(200, &memory); + + assert_eq!(BufMut::remaining_mut(&buf), 200); + + let chunk = BufMut::chunk_mut(&mut buf); + assert_eq!(chunk.len(), 100); + + // SAFETY: Lies - we did not write anything. But we will also + // not touch the data - we are only inspecting the bookkeeping. + // Good enough for test code. + unsafe { + BufMut::advance_mut(&mut buf, 50); + } + + let chunk = BufMut::chunk_mut(&mut buf); + assert_eq!(chunk.len(), 50); + + // SAFETY: See above. + unsafe { + BufMut::advance_mut(&mut buf, 50); + } + + let chunk = BufMut::chunk_mut(&mut buf); + assert_eq!(chunk.len(), 100); + + // SAFETY: See above. + unsafe { + BufMut::advance_mut(&mut buf, 100); + } + + let chunk = BufMut::chunk_mut(&mut buf); + assert_eq!(chunk.len(), 0); +} diff --git a/crates/bytesbuf/tests/public_api/bytes_compat_from_bytes.rs b/crates/bytesbuf/tests/public_api/bytes_compat_from_bytes.rs new file mode 100644 index 0000000000..c9ac40a4eb --- /dev/null +++ b/crates/bytesbuf/tests/public_api/bytes_compat_from_bytes.rs @@ -0,0 +1,54 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use bytes::{BufMut, Bytes, BytesMut}; +use bytesbuf::BytesView; + +#[test] +fn test_bytes_to_view() { + let bytes = Bytes::from_static(b"Hello, world!"); + + let bytes_data_ptr = bytes.as_ptr(); + + let view: BytesView = bytes.into(); + + assert_eq!(view.len(), 13); + assert_eq!(view, b"Hello, world!"); + + // We expect this to be zero-copy - Bytes to BytesView always is. + assert_eq!(view.first_slice().as_ptr(), bytes_data_ptr); +} + +#[test] +fn zero_sized_bytes() { + let bytes = Bytes::new(); + let view: BytesView = bytes.into(); + + assert_eq!(view.len(), 0); + assert!(view.is_empty()); +} + +#[test] +fn test_giant_bytes_to_view() { + // This test requires at least 5 GB of memory to run. The publishing pipeline runs on a system + // where this may not be available, so we skip this test in that environment. + #[cfg(all(not(miri), any(target_os = "linux", target_os = "windows")))] + if crate::testing::system_memory() < 10_000_000_000 { + eprintln!("Skipping giant allocation test due to insufficient memory."); + return; + } + + let mut bytes = BytesMut::new(); + + // This is bigger than fits into a single memory block, so will be split in two blocks. + bytes.put_bytes(0, 5_000_000_000); + + let bytes = bytes.freeze(); + + let view: BytesView = bytes.into(); + assert_eq!(view.len(), 5_000_000_000); + assert_eq!(view.first_slice().len(), u32::MAX as usize); + assert_eq!(view.slices().count(), 2); +} diff --git a/crates/bytesbuf/tests/public_api/bytes_compat_to_bytes.rs b/crates/bytesbuf/tests/public_api/bytes_compat_to_bytes.rs new file mode 100644 index 0000000000..88886a3c25 --- /dev/null +++ b/crates/bytesbuf/tests/public_api/bytes_compat_to_bytes.rs @@ -0,0 +1,80 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use bytes::{Buf, Bytes}; +use bytesbuf::BytesView; +use bytesbuf::mem::testing::TransparentMemory; + +#[test] +fn view_to_bytes() { + let mut builder = TransparentMemory::new().reserve(100); + + builder.put_slice(1234_u64.to_ne_bytes()); + builder.put_slice(5678_u64.to_ne_bytes()); + + let span1 = builder.consume(8); + let span2 = builder.consume(8); + + let view_single_span = BytesView::from_views(vec![span1.clone()]); + let view_multi_span = BytesView::from_views(vec![span1, span2]); + + let mut bytes = view_single_span.to_bytes(); + assert_eq!(8, bytes.len()); + assert_eq!(1234, bytes.get_u64_ne()); + + let mut bytes = view_single_span.to_bytes(); + assert_eq!(8, bytes.len()); + assert_eq!(1234, bytes.get_u64_ne()); + + let mut bytes = view_multi_span.to_bytes(); + assert_eq!(16, bytes.len()); + assert_eq!(1234, bytes.get_u64_ne()); + assert_eq!(5678, bytes.get_u64_ne()); +} + +#[test] +fn empty_view_to_bytes() { + let view = BytesView::default(); + let bytes = view.to_bytes(); + assert_eq!(0, bytes.len()); +} + +#[test] +fn into_bytes() { + let memory = TransparentMemory::new(); + let view = BytesView::copied_from_slice(b"Hello, world!", &memory); + + let bytes: Bytes = view.into(); + + assert_eq!(bytes.as_ref(), b"Hello, world!"); +} + +#[test] +fn test_view_to_bytes() { + let memory = TransparentMemory::new(); + + let view = BytesView::copied_from_slice(b"Hello, world!", &memory); + + let view_chunk_ptr = view.first_slice().as_ptr(); + + let bytes = view.to_bytes(); + + assert_eq!(bytes.as_ref(), b"Hello, world!"); + + // We expect this to be zero-copy since we used the passthrough allocator. + assert_eq!(bytes.as_ptr(), view_chunk_ptr); +} + +#[test] +fn test_multi_block_view_to_bytes() { + let memory = TransparentMemory::new(); + + let hello = BytesView::copied_from_slice(b"Hello, ", &memory); + let world = BytesView::copied_from_slice(b"world!", &memory); + let view = BytesView::from_views([hello, world]); + + let bytes = view.to_bytes(); + assert_eq!(bytes.as_ref(), b"Hello, world!"); +} diff --git a/crates/bytesbuf/tests/public_api/bytes_compat_view.rs b/crates/bytesbuf/tests/public_api/bytes_compat_view.rs new file mode 100644 index 0000000000..31b19f90d7 --- /dev/null +++ b/crates/bytesbuf/tests/public_api/bytes_compat_view.rs @@ -0,0 +1,63 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use std::io::IoSlice; + +use bytes::Buf; +use bytesbuf::mem::testing::FixedBlockMemory; +use new_zealand::nz; + +#[test] +fn buf_compat() { + let memory = FixedBlockMemory::new(nz!(25)); + + // 25 x 4 + let mut buf = memory.reserve(100); + buf.put_byte_repeated(0x44, 100); + + let mut bytes = buf.consume_all(); + + assert_eq!(Buf::remaining(&bytes), 100); + + let chunk = Buf::chunk(&bytes); + assert_eq!(chunk.len(), 25); + assert_eq!(chunk, &[0x44; 25]); + + Buf::advance(&mut bytes, 20); + + let chunk = Buf::chunk(&bytes); + assert_eq!(chunk.len(), 5); + assert_eq!(chunk, &[0x44; 5]); + + Buf::advance(&mut bytes, 5); + + let chunk = Buf::chunk(&bytes); + assert_eq!(chunk.len(), 25); + assert_eq!(chunk, &[0x44; 25]); + + Buf::advance(&mut bytes, 5); + + let mut io_slices = [IoSlice::new(&[]); 4]; + let n = Buf::chunks_vectored(&bytes, &mut io_slices); + + // We have already advanced past the first 30 bytes + // but the remaining 70 should still be here for us as 20 + 25 + 25. + assert_eq!(n, 3); + + assert_eq!(&*io_slices[0], &[0x44; 20]); + assert_eq!(&*io_slices[1], &[0x44; 25]); + assert_eq!(&*io_slices[2], &[0x44; 25]); +} + +#[test] +fn chunks_vectored_empty_dst() { + let memory = FixedBlockMemory::new(nz!(25)); + let mut buf = memory.reserve(25); + buf.put_byte_repeated(0x44, 25); + + let bytes = buf.consume_all(); + let n = Buf::chunks_vectored(&bytes, &mut []); + assert_eq!(n, 0); +} diff --git a/crates/bytesbuf/tests/public_api/mem_block_ref.rs b/crates/bytesbuf/tests/public_api/mem_block_ref.rs new file mode 100644 index 0000000000..312d1eefb5 --- /dev/null +++ b/crates/bytesbuf/tests/public_api/mem_block_ref.rs @@ -0,0 +1,208 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use std::ptr::NonNull; +use std::sync::atomic::{self, AtomicUsize}; + +use bytesbuf::mem::{BlockMeta, BlockRef, BlockRefDynamic, BlockRefDynamicWithMeta, BlockRefVTable}; + +struct TestBlock { + ref_count: AtomicUsize, + meta: Option>, +} + +#[derive(Debug)] +struct TestBlockMeta { + label: String, +} + +impl BlockMeta for TestBlockMeta {} + +// SAFETY: We must ensure thread-safety of the implementation. We do. +unsafe impl BlockRefDynamic for TestBlock { + type State = Self; + + fn clone(state_ptr: NonNull) -> NonNull { + // SAFETY: The state pointer is always valid for reads. + let state = unsafe { state_ptr.as_ref() }; + + state.ref_count.fetch_add(1, atomic::Ordering::Relaxed); + + state_ptr + } + + fn drop(state_ptr: NonNull) { + // SAFETY: The state pointer is always valid for reads. + let state = unsafe { state_ptr.as_ref() }; + + state.ref_count.fetch_sub(1, atomic::Ordering::Release); + + // We do not actually deallocate anything - the test logic will do that because it + // first needs to inspect the block structure to verify the reference count. + } +} + +// SAFETY: We must ensure thread-safety of the implementation. We do. +unsafe impl BlockRefDynamicWithMeta for TestBlock { + fn meta(state_ptr: NonNull) -> NonNull { + // SAFETY: The state pointer is always valid for reads. + let state = unsafe { state_ptr.as_ref() }; + + state.meta.unwrap() + } +} + +const TEST_BLOCK_REF_FNS: BlockRefVTable = BlockRefVTable::from_trait_with_meta(); + +const TEST_BLOCK_REF_FNS_WITHOUT_META: BlockRefVTable = BlockRefVTable::from_trait(); + +#[test] +fn smoke_test() { + let meta_ptr = NonNull::new(Box::into_raw(Box::new(TestBlockMeta { + label: "Test Block".to_string(), + }))) + .unwrap(); + + let block_ptr = NonNull::new(Box::into_raw(Box::new(TestBlock { + ref_count: AtomicUsize::new(1), + meta: Some(meta_ptr), + }))) + .unwrap(); + + // SAFETY: block_ptr must remain valid for reads and writes until drop() + // is called via the dynamic fns. Yep, it does - the dynamic impl type takes ownership. + let block_ref = unsafe { BlockRef::new(block_ptr, &TEST_BLOCK_REF_FNS) }; + + let meta = block_ref.meta().unwrap(); + + assert_eq!(meta.downcast_ref::().unwrap().label, "Test Block"); + + let block_ref_clone = block_ref.clone(); + + let meta = block_ref_clone.meta().unwrap(); + + assert_eq!(meta.downcast_ref::().unwrap().label, "Test Block"); + + // SAFETY: That is our block and it is perfectly valid for reads. + let ref_count = unsafe { block_ptr.as_ref() }.ref_count.load(atomic::Ordering::Relaxed); + + assert_eq!(2, ref_count); + + drop(block_ref_clone); + drop(block_ref); + + // SAFETY: That is our block and it is perfectly valid for reads. + let ref_count = unsafe { block_ptr.as_ref() }.ref_count.load(atomic::Ordering::Relaxed); + + assert_eq!(0, ref_count); + + // All done, clean up please. + // SAFETY: Yep, that is our block. + drop(unsafe { Box::from_raw(block_ptr.as_ptr()) }); + // SAFETY: Yep, that is our meta. + drop(unsafe { Box::from_raw(meta_ptr.as_ptr()) }); +} + +#[test] +fn without_meta_returns_none_meta() { + let block_ptr = NonNull::new(Box::into_raw(Box::new(TestBlock { + ref_count: AtomicUsize::new(1), + meta: None, + }))) + .unwrap(); + + // SAFETY: block_ptr must remain valid for reads and writes until drop() + // is called via the dynamic fns. Yep, it does - the dynamic impl type takes ownership. + let block_ref = unsafe { BlockRef::new(block_ptr, &TEST_BLOCK_REF_FNS_WITHOUT_META) }; + + assert!(block_ref.meta().is_none()); + + let block_ref_clone = block_ref.clone(); + + assert!(block_ref_clone.meta().is_none()); + + drop(block_ref_clone); + drop(block_ref); + + // All done, clean up please. + // SAFETY: Yep, that is our block. + drop(unsafe { Box::from_raw(block_ptr.as_ptr()) }); +} + +#[test] +#[cfg_attr(miri, ignore)] +fn from_trait_with_meta_vtable_handles_clone_correctly() { + // Create vtable at runtime to ensure we measure test coverage. + // We leak the Box to get a 'static reference, which is okay as long as Miri is not looking. + let vtable: &'static BlockRefVTable = Box::leak(Box::new(BlockRefVTable::from_trait_with_meta())); + + let block_ptr = NonNull::new(Box::into_raw(Box::new(TestBlock { + ref_count: AtomicUsize::new(1), + meta: None, + }))) + .unwrap(); + + // SAFETY: block_ptr must remain valid for reads and writes until drop() + // is called via the dynamic fns. It is - we clean it up at the end. + let block_ref = unsafe { BlockRef::new(block_ptr, vtable) }; + + // Clone the block ref + let block_ref_clone = block_ref.clone(); + + // Verify reference count increased + // SAFETY: That is our block and it is perfectly valid for reads. + let ref_count = unsafe { block_ptr.as_ref() }.ref_count.load(atomic::Ordering::Relaxed); + assert_eq!(ref_count, 2); + + drop(block_ref_clone); + drop(block_ref); + + // Verify reference count decreased to 0 + // SAFETY: That is our block and it is perfectly valid for reads. + let ref_count = unsafe { block_ptr.as_ref() }.ref_count.load(atomic::Ordering::Relaxed); + assert_eq!(ref_count, 0); + + // Clean up + // SAFETY: Yep, that is our block. + drop(unsafe { Box::from_raw(block_ptr.as_ptr()) }); +} + +#[test] +#[cfg_attr(miri, ignore)] +fn from_trait_vtable_handles_clone_correctly() { + // Create vtable at runtime to ensure we measure test coverage. + // We leak the Box to get a 'static reference, which is okay as long as Miri is not looking. + let vtable: &'static BlockRefVTable = Box::leak(Box::new(BlockRefVTable::from_trait())); + + let block_ptr = NonNull::new(Box::into_raw(Box::new(TestBlock { + ref_count: AtomicUsize::new(1), + meta: None, + }))) + .unwrap(); + + // SAFETY: block_ptr must remain valid for reads and writes until drop() + // is called via the dynamic fns. It is - we clean it up at the end. + let block_ref = unsafe { BlockRef::new(block_ptr, vtable) }; + + // Clone the block ref + let block_ref_clone = block_ref.clone(); + + // Verify reference count increased + // SAFETY: That is our block and it is perfectly valid for reads. + let ref_count = unsafe { block_ptr.as_ref() }.ref_count.load(atomic::Ordering::Relaxed); + assert_eq!(ref_count, 2); + + drop(block_ref_clone); + drop(block_ref); + + // Verify reference count decreased to 0 + // SAFETY: That is our block and it is perfectly valid for reads. + let ref_count = unsafe { block_ptr.as_ref() }.ref_count.load(atomic::Ordering::Relaxed); + assert_eq!(ref_count, 0); + + // Clean up + // SAFETY: Yep, that is our block. + drop(unsafe { Box::from_raw(block_ptr.as_ptr()) }); +} diff --git a/crates/bytesbuf/tests/public_api/mem_callback_memory.rs b/crates/bytesbuf/tests/public_api/mem_callback_memory.rs new file mode 100644 index 0000000000..f2b1e0f147 --- /dev/null +++ b/crates/bytesbuf/tests/public_api/mem_callback_memory.rs @@ -0,0 +1,142 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use std::sync::Arc; +use std::sync::atomic::{self, AtomicUsize}; + +use bytesbuf::BytesBuf; +use bytesbuf::mem::testing::TransparentMemory; +use bytesbuf::mem::{CallbackMemory, Memory, MemoryShared}; +use static_assertions::assert_impl_all; +use thread_aware::{Relocator, Thread, ThreadAware}; + +assert_impl_all!(CallbackMemory: MemoryShared); + +/// Thread-aware callback data carrying an observable call counter alongside the wrapped provider. +#[derive(Clone, Debug, ThreadAware)] +struct CountingData { + inner: TransparentMemory, + // The counter is inert shared state, so relocation does not affect it. + #[thread_aware(skip)] + reserve_calls: Arc, +} + +impl CountingData { + fn new() -> Self { + Self { + inner: TransparentMemory::new(), + reserve_calls: Arc::new(AtomicUsize::new(0)), + } + } +} + +// A relocation observer bundled into the data, so we can assert forwarding without a bare skip. +#[derive(Clone, Debug)] +struct RelocationObserver { + inner: TransparentMemory, + relocations: Arc, +} + +impl ThreadAware for RelocationObserver { + fn relocate(&mut self, _source: Option<&Thread>, _destination: &Thread) { + self.relocations.fetch_add(1, atomic::Ordering::SeqCst); + } +} + +fn count_reserve(data: &CountingData, min_bytes: usize) -> BytesBuf { + data.reserve_calls.fetch_add(1, atomic::Ordering::SeqCst); + data.inner.reserve(min_bytes) +} + +#[test] +fn calls_back_to_provided_fn() { + let data = CountingData::new(); + let reserve_calls = Arc::clone(&data.reserve_calls); + + let provider = CallbackMemory::new(data, count_reserve); + + _ = Memory::reserve(&provider, 100); + + assert_eq!(reserve_calls.load(atomic::Ordering::SeqCst), 1); +} + +#[test] +fn clone_shares_behavior() { + let data = CountingData::new(); + let reserve_calls = Arc::clone(&data.reserve_calls); + + let provider = CallbackMemory::new(data, count_reserve); + let cloned_provider = provider.clone(); + + _ = Memory::reserve(&provider, 50); + assert_eq!(reserve_calls.load(atomic::Ordering::SeqCst), 1); + + _ = Memory::reserve(&cloned_provider, 75); + assert_eq!(reserve_calls.load(atomic::Ordering::SeqCst), 2); +} + +#[test] +fn reserve_produces_capacity() { + let provider = CallbackMemory::new(TransparentMemory::new(), TransparentMemory::reserve); + + let buf = provider.reserve(64); + assert!(buf.capacity() >= 64); +} + +#[test] +fn multi_field_tuple_data() { + // The data can carry more than the wrapped provider: here a tuple pairs it with an offset + // that the callback adds to every reservation. + const EXTRA: usize = 16; + let provider = CallbackMemory::new( + (TransparentMemory::new(), EXTRA), + |(inner, extra): &(TransparentMemory, usize), min_bytes| inner.reserve(min_bytes + *extra), + ); + + // TransparentMemory reserves exactly the requested capacity, so the offset is observable. + let buf = provider.reserve(64); + assert_eq!(buf.capacity(), 64 + EXTRA); +} + +#[test] +fn relocate_forwards_to_data() { + let relocations = Arc::new(AtomicUsize::new(0)); + let mut provider = CallbackMemory::new( + RelocationObserver { + inner: TransparentMemory::new(), + relocations: Arc::clone(&relocations), + }, + |observer: &RelocationObserver, min_bytes| observer.inner.reserve(min_bytes), + ); + + _ = Relocator::between_threads().relocate(&mut provider); + + assert_eq!(relocations.load(atomic::Ordering::SeqCst), 1); + + // The provider remains usable after relocation. + assert!(provider.reserve(32).capacity() >= 32); +} + +#[test] +fn works_with_non_debug_data() { + // Data that is intentionally not `Debug`, to confirm `CallbackMemory` does not require it. + #[derive(Clone, ThreadAware)] + struct NotDebug { + inner: TransparentMemory, + } + + let provider = CallbackMemory::new( + NotDebug { + inner: TransparentMemory::new(), + }, + |data: &NotDebug, min_bytes| data.inner.reserve(min_bytes), + ); + + assert!(Memory::reserve(&provider, 64).capacity() >= 64); + + // `CallbackMemory` is still `Debug` even though its data is not. + let rendered = format!("{provider:?}"); + assert!(rendered.contains("CallbackMemory")); +} diff --git a/crates/bytesbuf/tests/public_api/mem_global.rs b/crates/bytesbuf/tests/public_api/mem_global.rs new file mode 100644 index 0000000000..bd62ceccf4 --- /dev/null +++ b/crates/bytesbuf/tests/public_api/mem_global.rs @@ -0,0 +1,246 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use bytesbuf::mem::{BlockSize, GlobalPool, MemoryShared}; +use static_assertions::assert_impl_all; +use thread_aware::{Relocator, ThreadAware}; + +assert_impl_all!(GlobalPool: MemoryShared, ThreadAware); + +#[test] +fn smoke_test() { + let memory = GlobalPool::new(); + + // Nothing to assert with 0-sized, any capacity is acceptable. Just as long as it works. + _ = memory.reserve(0); + + let builder = memory.reserve(1); + assert!(builder.capacity() >= 1); + + let builder = memory.reserve(100); + assert!(builder.capacity() >= 100); + + let builder = memory.reserve(1000); + assert!(builder.capacity() >= 1000); + + let builder = memory.reserve(10000); + assert!(builder.capacity() >= 10000); + + let builder = memory.reserve(100_000); + assert!(builder.capacity() >= 100_000); + + let builder = memory.reserve(1_000_000); + assert!(builder.capacity() >= 1_000_000); +} + +#[test] +fn piece_by_piece() { + const BLOCK_SIZE: usize = 65_536; + const LEN_BYTES: BlockSize = 1000; + + // We grab a block of memory and split the single block into multiple views piece by piece. + let memory = GlobalPool::new(); + + let mut buf = memory.reserve(BLOCK_SIZE); + + let mut views = Vec::new(); + + while buf.remaining_capacity() > 0 { + #[expect(clippy::cast_possible_truncation, reason = "intentionally truncating")] + let value = views.len() as u8; + + buf.put_byte_repeated(value, (LEN_BYTES as usize).min(buf.remaining_capacity())); + + // Sanity check against silly mutations. + debug_assert!(!buf.is_empty()); + + views.push(buf.consume_all()); + } + + #[expect(clippy::cast_possible_truncation, reason = "block size is small")] + let expected_count = (BLOCK_SIZE as BlockSize).div_ceil(LEN_BYTES); + assert_eq!(views.len(), expected_count as usize); + + assert!(!views.is_empty()); + + for (i, sequence) in views.iter().enumerate() { + #[expect(clippy::cast_possible_truncation, reason = "intentionally truncating")] + let expected_value = i as u8; + + assert_eq!(sequence.first_slice()[0], expected_value); + } +} + +#[test] +#[cfg_attr(miri, ignore)] // Miri runtime scales with memory access size, so this takes forever. +fn large_content_survives_trip() { + const SIZE_10MB: usize = 10 * 1024 * 1024; + + let pattern = testing_aids::repeating_incrementing_bytes().take(SIZE_10MB).collect::>(); + + let memory = GlobalPool::new(); + + let mut buf = memory.reserve(SIZE_10MB); + + buf.put_slice(pattern.as_slice()); + + let message = buf.consume_all(); + + // Verify the sequence contains the expected pattern + assert_eq!(message.len(), SIZE_10MB); + assert_eq!(message, pattern.as_slice()); +} + +#[test] +#[cfg_attr(miri, ignore)] // Miri runtime scales with memory access size, so this takes forever. +fn two_large_views_different_patterns() { + const SIZE_10MB: usize = 10 * 1024 * 1024; + + let pattern1 = testing_aids::repeating_incrementing_bytes().take(SIZE_10MB).collect::>(); + + let pattern2 = testing_aids::repeating_reverse_incrementing_bytes() + .take(SIZE_10MB) + .collect::>(); + + let memory = GlobalPool::new(); + + // Create first sequence with ascending pattern + let mut sb1 = memory.reserve(SIZE_10MB); + sb1.put_slice(pattern1.as_slice()); + + // Create second sequence with descending pattern + let mut sb2 = memory.reserve(SIZE_10MB); + sb2.put_slice(pattern2.as_slice()); + + let view1 = sb1.consume_all(); + let view2 = sb2.consume_all(); + + // Verify both views have correct size + assert_eq!(view1.len(), SIZE_10MB); + assert_eq!(view2.len(), SIZE_10MB); + + assert_eq!(view1, pattern1.as_slice()); + assert_eq!(view2, pattern2.as_slice()); +} + +#[test] +fn small_reservation_uses_1k_block() { + let memory = GlobalPool::new(); + + let buf = memory.reserve(500); + assert_eq!(buf.capacity(), 1024); +} + +#[test] +fn exact_1k_uses_1k_block() { + let memory = GlobalPool::new(); + + let buf = memory.reserve(1024); + assert_eq!(buf.capacity(), 1024); +} + +#[test] +fn just_over_1k_uses_4k_block() { + let memory = GlobalPool::new(); + + let buf = memory.reserve(1025); + assert_eq!(buf.capacity(), 4096); +} + +#[test] +fn exact_4k_uses_4k_block() { + let memory = GlobalPool::new(); + + let buf = memory.reserve(4096); + assert_eq!(buf.capacity(), 4096); +} + +#[test] +fn just_over_4k_uses_16k_block() { + let memory = GlobalPool::new(); + + let buf = memory.reserve(4097); + assert_eq!(buf.capacity(), 16_384); +} + +#[test] +fn exact_16k_uses_16k_block() { + let memory = GlobalPool::new(); + + let buf = memory.reserve(16_384); + assert_eq!(buf.capacity(), 16_384); +} + +#[test] +fn just_over_16k_uses_64k_block() { + let memory = GlobalPool::new(); + + let buf = memory.reserve(16_385); + assert_eq!(buf.capacity(), 65_536); +} + +#[test] +fn exact_64k_uses_64k_block() { + let memory = GlobalPool::new(); + + let buf = memory.reserve(65_536); + assert_eq!(buf.capacity(), 65_536); +} + +#[test] +fn multi_block_uniform_64k() { + // 70KB exceeds 64KB, so uses multiple 64KB blocks (all same size). + let memory = GlobalPool::new(); + + let buf = memory.reserve(70_000); + assert_eq!(buf.capacity(), 65_536 * 2); +} + +#[test] +fn multi_block_many_64k() { + // 200KB = ceil(200_000 / 65_536) = 4 blocks of 64KB. + let memory = GlobalPool::new(); + + let buf = memory.reserve(200_000); + assert_eq!(buf.capacity(), 65_536 * 4); +} + +#[test] +fn zero_reservation() { + let memory = GlobalPool::new(); + + let buf = memory.reserve(0); + // Zero reservation should not panic and should result in zero capacity (no blocks). + assert_eq!(buf.capacity(), 0); +} + +#[test] +fn multi_block_just_over_64k() { + // 66_036 > 64KB, so 2x 64KB blocks (uniform sizing). + let memory = GlobalPool::new(); + + let buf = memory.reserve(66_036); + assert_eq!(buf.capacity(), 65_536 * 2); +} + +#[test] +fn relocated_pool_works() { + let mut memory = GlobalPool::new(); + + // Allocate from the original pool. + let mut buf = memory.reserve(100); + buf.put_byte(42); + let view = buf.consume_all(); + assert_eq!(view.first_slice()[0], 42); + + // Relocate the pool to a different thread coordinate. + _ = Relocator::between_threads().relocate(&mut memory); + + // The relocated pool should work independently. + let mut buf2 = memory.reserve(200); + buf2.put_byte(99); + let view2 = buf2.consume_all(); + assert_eq!(view2.first_slice()[0], 99); +} diff --git a/crates/bytesbuf/tests/public_api/mem_memory.rs b/crates/bytesbuf/tests/public_api/mem_memory.rs new file mode 100644 index 0000000000..f3aa527f2d --- /dev/null +++ b/crates/bytesbuf/tests/public_api/mem_memory.rs @@ -0,0 +1,47 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use std::sync::atomic::{AtomicUsize, Ordering}; + +use bytesbuf::BytesBuf; +use bytesbuf::mem::Memory; +use bytesbuf::mem::testing::TransparentMemory; + +#[derive(Debug)] +struct CountingMemory { + reserve_calls: AtomicUsize, + inner: TransparentMemory, +} + +impl CountingMemory { + fn new() -> Self { + Self { + reserve_calls: AtomicUsize::new(0), + inner: TransparentMemory::new(), + } + } +} + +impl Memory for CountingMemory { + fn reserve(&self, min_bytes: usize) -> BytesBuf { + self.reserve_calls.fetch_add(1, Ordering::SeqCst); + self.inner.reserve(min_bytes + 16) + } +} + +fn reserve_from_generic(memory: M, min_bytes: usize) -> BytesBuf { + memory.reserve(min_bytes) +} + +#[test] +fn memory_impl_for_reference_forwards_reserve_to_underlying() { + let memory = CountingMemory::new(); + let min_bytes = 64; + + let buf = reserve_from_generic(&memory, min_bytes); + + assert_eq!(memory.reserve_calls.load(Ordering::SeqCst), 1); + assert!(buf.capacity() >= min_bytes + 16); +} diff --git a/crates/bytesbuf/tests/public_api/mem_opaque_memory.rs b/crates/bytesbuf/tests/public_api/mem_opaque_memory.rs new file mode 100644 index 0000000000..1a1162ba1f --- /dev/null +++ b/crates/bytesbuf/tests/public_api/mem_opaque_memory.rs @@ -0,0 +1,66 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use std::sync::Arc; +use std::sync::atomic::{self, AtomicUsize}; + +use bytesbuf::mem::{GlobalPool, Memory, MemoryShared, OpaqueMemory}; +use static_assertions::assert_impl_all; +use thread_aware::{Relocator, Thread, ThreadAware}; + +assert_impl_all!(OpaqueMemory: MemoryShared, ThreadAware); + +#[test] +fn wraps_inner() { + let provider = GlobalPool::new(); + let memory = OpaqueMemory::new(provider); + let cloned = memory.clone(); + + assert!(memory.reserve(1024).capacity() >= 1024); + assert!(cloned.reserve(1024).capacity() >= 1024); +} + +#[test] +fn memory_trait() { + let provider = GlobalPool::new(); + let memory = OpaqueMemory::new(provider); + + // Call reserve via the Memory trait to verify the impl block + let builder = Memory::reserve(&memory, 1024); + assert!(builder.capacity() >= 1024); +} + +#[test] +fn relocate_forwards_to_wrapped_provider() { + // A provider whose relocate is observable, to verify forwarding. + #[derive(Clone, Debug)] + struct TrackingMemory { + relocated: Arc, + inner: GlobalPool, + } + + impl Memory for TrackingMemory { + fn reserve(&self, min_bytes: usize) -> bytesbuf::BytesBuf { + self.inner.reserve(min_bytes) + } + } + + impl ThreadAware for TrackingMemory { + fn relocate(&mut self, source: Option<&Thread>, destination: &Thread) { + self.relocated.fetch_add(1, atomic::Ordering::SeqCst); + self.inner.relocate(source, destination); + } + } + + let relocated = Arc::new(AtomicUsize::new(0)); + let mut memory = OpaqueMemory::new(TrackingMemory { + relocated: Arc::clone(&relocated), + inner: GlobalPool::new(), + }); + + _ = Relocator::between_threads().relocate(&mut memory); + + assert_eq!(relocated.load(atomic::Ordering::SeqCst), 1); +} diff --git a/crates/bytesbuf/tests/public_api/mem_testing_fixed_block.rs b/crates/bytesbuf/tests/public_api/mem_testing_fixed_block.rs new file mode 100644 index 0000000000..4bf9e91c17 --- /dev/null +++ b/crates/bytesbuf/tests/public_api/mem_testing_fixed_block.rs @@ -0,0 +1,36 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use bytesbuf::BytesView; +use bytesbuf::mem::MemoryShared; +use bytesbuf::mem::testing::FixedBlockMemory; +use new_zealand::nz; +use static_assertions::assert_impl_all; +use thread_aware::ThreadAware; + +assert_impl_all!(FixedBlockMemory: MemoryShared, ThreadAware); + +#[test] +fn byte_by_byte() { + let memory = FixedBlockMemory::new(nz!(1)); + + let buf = memory.reserve(0); + assert_eq!(buf.len(), 0); + assert_eq!(buf.capacity(), 0); + + let mut data = BytesView::copied_from_slice(b"Hello, world", &memory); + assert_eq!(data, b"Hello, world"); + + assert_eq!(data.first_slice().len(), 1); + + let mut chunks_encountered: usize = 0; + + data.consume_all_slices(|chunk| { + chunks_encountered = chunks_encountered.saturating_add(1); + assert_eq!(chunk.len(), 1); + }); + + assert_eq!(chunks_encountered, 12); +} diff --git a/crates/bytesbuf/tests/public_api/mem_testing_transparent.rs b/crates/bytesbuf/tests/public_api/mem_testing_transparent.rs new file mode 100644 index 0000000000..81e36b1c2d --- /dev/null +++ b/crates/bytesbuf/tests/public_api/mem_testing_transparent.rs @@ -0,0 +1,52 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use bytesbuf::mem::MemoryShared; +use bytesbuf::mem::testing::TransparentMemory; +use static_assertions::assert_impl_all; +use thread_aware::ThreadAware; + +assert_impl_all!(TransparentMemory: MemoryShared, ThreadAware); + +#[test] +fn smoke_test() { + let memory = TransparentMemory::new(); + + let mut buf = memory.reserve(0); + assert_eq!(buf.len(), 0); + assert_eq!(buf.capacity(), 0); + + buf = memory.reserve(1313); + + assert_eq!(buf.capacity(), 1313); + + buf.put_byte_repeated(3, 1313); + + let data = buf.consume_all(); + + assert_eq!(data.len(), 1313); + assert_eq!(data.first_slice().len(), 1313); +} + +#[test] +fn giant_allocation() { + // This test requires at least 5 GB of memory to run. The publishing pipeline runs on a system + // where this may not be available, so we skip this test in that environment. + #[cfg(all(not(miri), any(target_os = "linux", target_os = "windows")))] + if crate::testing::system_memory() < 10_000_000_000 { + eprintln!("Skipping giant allocation test due to insufficient memory."); + return; + } + + // This is a giant allocation that does not fit into one memory block. + + let memory = TransparentMemory::new(); + let buf = memory.reserve(5_000_000_000); + + assert_eq!(buf.capacity(), 5_000_000_000); + + // NB! We cannot simply check the first chunk length because there is no guarantee on which + // order a BytesBuf consumes its blocks in - the first might not be u32::MAX here! +} diff --git a/crates/bytesbuf/tests/public_api/vec.rs b/crates/bytesbuf/tests/public_api/vec.rs new file mode 100644 index 0000000000..06b448a38e --- /dev/null +++ b/crates/bytesbuf/tests/public_api/vec.rs @@ -0,0 +1,63 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use bytesbuf::BytesView; + +#[test] +fn vec_into_view() { + let vec = vec![1, 2, 3, 4, 5]; + let mut view: BytesView = vec.into(); + assert_eq!(view.len(), 5); + + assert_eq!(view.get_byte(), 1); + assert_eq!(view.get_byte(), 2); + assert_eq!(view.get_byte(), 3); + assert_eq!(view.get_byte(), 4); + assert_eq!(view.get_byte(), 5); + + assert!(view.is_empty()); +} + +#[test] +fn zero_sized_vec() { + let vec = Vec::::new(); + let view: BytesView = vec.into(); + + assert_eq!(view.len(), 0); + assert!(view.is_empty()); +} + +#[test] +fn test_vec_to_view() { + let vec = vec![b'H', b'e', b'l', b'l', b'o', b',', b' ', b'w', b'o', b'r', b'l', b'd', b'!']; + + let vec_data_ptr = vec.as_ptr(); + + let view: BytesView = vec.into(); + + assert_eq!(view.len(), 13); + assert_eq!(view, b"Hello, world!"); + + // We expect this to be zero-copy - Vec to BytesView always is. + assert_eq!(view.first_slice().as_ptr(), vec_data_ptr); +} + +#[test] +fn test_giant_vec_to_view() { + // This test requires at least 5 GB of memory to run. The publishing pipeline runs on a system + // where this may not be available, so we skip this test in that environment. + #[cfg(all(not(miri), any(target_os = "linux", target_os = "windows")))] + if crate::testing::system_memory() < 10_000_000_000 { + eprintln!("Skipping giant allocation test due to insufficient memory."); + return; + } + + let vec = vec![0u8; 5_000_000_000]; + + let view: BytesView = vec.into(); + assert_eq!(view.len(), 5_000_000_000); + assert_eq!(view.first_slice().len(), u32::MAX as usize); + assert_eq!(view.slices().count(), 2); +} diff --git a/crates/bytesbuf/tests/public_api/view.rs b/crates/bytesbuf/tests/public_api/view.rs new file mode 100644 index 0000000000..f94305fea7 --- /dev/null +++ b/crates/bytesbuf/tests/public_api/view.rs @@ -0,0 +1,1026 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +#![allow( + clippy::indexing_slicing, + clippy::needless_range_loop, + clippy::arithmetic_side_effects, + reason = "This is all fine in test code" +)] + +use std::hash::{Hash, Hasher}; +use std::ops::Bound; +use std::pin::pin; +use std::thread; + +use bytesbuf::mem::BlockMeta; +use bytesbuf::mem::testing::{FixedBlockMemory, TransparentMemory}; +use bytesbuf::{BytesBuf, BytesView}; +use new_zealand::nz; +use static_assertions::{assert_impl_all, assert_not_impl_any}; +use testing_aids::assert_panic; + +use crate::test_block::TestMemoryBlock; + +assert_impl_all!(BytesView: Send, Sync, Eq); +assert_not_impl_any!(BytesView: From<&'static [u8]>); + +/// A `Hasher` for which `write(a); write(b)` differs from `write(a ++ b)`, because it mixes the +/// length of every individual `write` call into the state. A correct [`Hash`] implementation +/// must not depend on how the bytes are chunked across `write` calls, so it must produce the +/// same hash for equal views regardless of their span segmentation even under such a hasher. +#[derive(Default)] +struct BoundarySensitiveHasher { + state: u64, +} + +impl Hasher for BoundarySensitiveHasher { + fn finish(&self) -> u64 { + self.state + } + + fn write(&mut self, bytes: &[u8]) { + self.state = self.state.wrapping_mul(31).wrapping_add(bytes.len() as u64); + for &byte in bytes { + self.state = self.state.wrapping_mul(31).wrapping_add(u64::from(byte)); + } + } +} + +/// A `Hasher` that records the exact bytes of every `write` call, so tests can assert that two +/// views drive the hasher with an identical sequence of calls rather than only comparing the +/// final (potentially colliding) hash value. +#[derive(Default)] +struct RecordingHasher { + writes: Vec>, +} + +impl Hasher for RecordingHasher { + fn finish(&self) -> u64 { + 0 + } + + fn write(&mut self, bytes: &[u8]) { + self.writes.push(bytes.to_vec()); + } +} + +#[test] +fn smoke_test() { + let mut span_builder = TransparentMemory::new().reserve(10); + + span_builder.put_slice(1234_u64.to_ne_bytes()); + span_builder.put_slice(16_u16.to_ne_bytes()); + + let span1 = span_builder.consume(4); + let span2 = span_builder.consume(3); + let span3 = span_builder.consume(3); + + assert_eq!(0, span_builder.remaining_capacity()); + assert_eq!(span1.len(), 4); + assert_eq!(span2.len(), 3); + assert_eq!(span3.len(), 3); + + let mut view = BytesView::from_views(vec![span1, span2, span3]); + + assert!(!view.is_empty()); + assert_eq!(10, view.len()); + + let slice = view.first_slice(); + assert_eq!(4, slice.len()); + + // We read 8 bytes here, so should land straight inside span3. + assert_eq!(view.get_u64_ne(), 1234); + + assert_eq!(2, view.len()); + + let slice = view.first_slice(); + assert_eq!(2, slice.len()); + + assert_eq!(view.get_u16_ne(), 16); + + assert_eq!(0, view.len()); + assert!(view.is_empty()); +} + +#[test] +fn oob_is_panic() { + let mut span_builder = TransparentMemory::new().reserve(10); + + span_builder.put_slice(1234_u64.to_ne_bytes()); + span_builder.put_slice(16_u16.to_ne_bytes()); + + let span1 = span_builder.consume(4); + let span2 = span_builder.consume(3); + let span3 = span_builder.consume(3); + + let mut view = BytesView::from_views(vec![span1, span2, span3]); + + assert_eq!(10, view.len()); + + assert_eq!(view.get_u64_ne(), 1234); + assert_panic!(_ = view.get_u32_ne()); // Reads 4 but only has 2 remaining. +} + +#[test] +fn extend_lifetime_references_all_blocks() { + // We need to detect here whether a block is being released (i.e. ref count goes to zero). + + // SAFETY: We are not allowed to drop this until all BlockRef are gone. This is fine + // because it is dropped at the end of the function, after all BlockRef instances. + let block1 = unsafe { TestMemoryBlock::new(nz!(8), None) }; + let block1 = pin!(block1); + + // SAFETY: We are not allowed to drop this until all BlockRef are gone. This is fine + // because it is dropped at the end of the function, after all BlockRef instances. + let block2 = unsafe { TestMemoryBlock::new(nz!(8), None) }; + let block2 = pin!(block2); + + let guard = { + // SAFETY: We guarantee exclusive access to the memory capacity. + let mut span_builder1 = BytesBuf::from_blocks([unsafe { block1.as_ref().to_block() }]); + // SAFETY: We guarantee exclusive access to the memory capacity. + let mut span_builder2 = BytesBuf::from_blocks([unsafe { block2.as_ref().to_block() }]); + + span_builder1.put_slice(1234_u64.to_ne_bytes()); + span_builder2.put_slice(1234_u64.to_ne_bytes()); + + let span1 = span_builder1.consume(8); + let span2 = span_builder2.consume(8); + + let view = BytesView::from_views(vec![span1, span2]); + + view.extend_lifetime() + }; + + // The sequence was destroyed and all BlockRefs it was holding are gone. + // However, the lifetime guard is still alive and has a BlockRef. + + assert_eq!(block1.ref_count(), 1); + assert_eq!(block2.ref_count(), 1); + + drop(guard); + + // And now they should all be dead. + assert_eq!(block1.ref_count(), 0); + assert_eq!(block2.ref_count(), 0); +} + +#[test] +fn from_views() { + let mut span_builder = TransparentMemory::new().reserve(100); + + span_builder.put_slice(1234_u64.to_ne_bytes()); + span_builder.put_slice(5678_u64.to_ne_bytes()); + + let span1 = span_builder.consume(8); + let span2 = span_builder.consume(8); + + let view1 = BytesView::from_views(vec![span1]); + let view2 = BytesView::from_views(vec![span2]); + + let mut combined_view = BytesView::from_views(vec![view1, view2]); + + assert_eq!(16, combined_view.len()); + + assert_eq!(combined_view.get_u64_ne(), 1234); + assert_eq!(combined_view.get_u64_ne(), 5678); +} + +#[test] +fn empty_view() { + let view = BytesView::default(); + + assert!(view.is_empty()); + assert_eq!(0, view.len()); + assert_eq!(0, view.first_slice().len()); +} + +#[test] +fn slice_from_single_span_view() { + // A very simple view to start with, consisting of just one 100 byte span. + let span_builder = TransparentMemory::new().reserve(100); + + let mut buf = span_builder; + + for i in 0..100 { + buf.put_byte(i); + } + + let view = buf.consume_all(); + + let mut sliced_view = view.range(50..55); + + assert_eq!(5, sliced_view.len()); + assert_eq!(100, view.len()); + + assert_eq!(50, sliced_view.get_byte()); + + assert_eq!(4, sliced_view.len()); + assert_eq!(100, view.len()); + + assert_eq!(51, sliced_view.get_byte()); + assert_eq!(52, sliced_view.get_byte()); + assert_eq!(53, sliced_view.get_byte()); + assert_eq!(54, sliced_view.get_byte()); + + assert_eq!(0, sliced_view.len()); + + assert!(view.range_checked(0..101).is_none()); + assert!(view.range_checked(100..101).is_none()); + assert!(view.range_checked(101..101).is_none()); +} + +#[test] +fn slice_from_multi_span_view() { + let memory = FixedBlockMemory::new(nz!(10)); + let mut buf = memory.reserve(100); + + for i in 0..100 { + buf.put_byte(i); + } + + let view = buf.consume_all(); + + let mut first5 = view.range(0..5); + assert_eq!(5, first5.len()); + assert_eq!(100, view.len()); + assert_eq!(0, first5.get_byte()); + + let mut last5 = view.range(95..100); + assert_eq!(5, last5.len()); + assert_eq!(100, view.len()); + assert_eq!(95, last5.get_byte()); + + let mut middle5 = view.range(49..54); + assert_eq!(5, middle5.len()); + assert_eq!(100, view.len()); + assert_eq!(49, middle5.get_byte()); + assert_eq!(50, middle5.get_byte()); + assert_eq!(51, middle5.get_byte()); + assert_eq!(52, middle5.get_byte()); + assert_eq!(53, middle5.get_byte()); + + assert!(view.range_checked(0..101).is_none()); + assert!(view.range_checked(100..101).is_none()); + assert!(view.range_checked(101..101).is_none()); +} + +#[test] +fn slice_indexing_kinds() { + let span_builder = TransparentMemory::new().reserve(10); + + let mut buf = span_builder; + buf.put_byte(0); + buf.put_byte(1); + buf.put_byte(2); + buf.put_byte(3); + buf.put_byte(4); + buf.put_byte(5); + + let data = buf.consume_all(); + + let mut middle_four = data.range(1..5); + assert_eq!(4, middle_four.len()); + assert_eq!(1, middle_four.get_byte()); + assert_eq!(2, middle_four.get_byte()); + assert_eq!(3, middle_four.get_byte()); + assert_eq!(4, middle_four.get_byte()); + + let mut middle_four = data.range(1..=4); + assert_eq!(4, middle_four.len()); + assert_eq!(1, middle_four.get_byte()); + assert_eq!(2, middle_four.get_byte()); + assert_eq!(3, middle_four.get_byte()); + assert_eq!(4, middle_four.get_byte()); + + let mut last_two = data.range(4..); + assert_eq!(2, last_two.len()); + assert_eq!(4, last_two.get_byte()); + assert_eq!(5, last_two.get_byte()); + + let mut first_two = data.range(..2); + assert_eq!(2, first_two.len()); + assert_eq!(0, first_two.get_byte()); + assert_eq!(1, first_two.get_byte()); + + let mut first_two = data.range(..=1); + assert_eq!(2, first_two.len()); + assert_eq!(0, first_two.get_byte()); + assert_eq!(1, first_two.get_byte()); +} + +#[test] +fn slice_checked_with_excluded_start_bound() { + let span_builder = TransparentMemory::new().reserve(100); + + let mut buf = span_builder; + buf.put_byte(0); + buf.put_byte(1); + buf.put_byte(2); + buf.put_byte(3); + buf.put_byte(4); + buf.put_byte(5); + buf.put_byte(6); + buf.put_byte(7); + buf.put_byte(8); + + let view = buf.consume_all(); + + // Test with excluded start bound: (Bound::Excluded(1), Bound::Excluded(5)) + // This should be equivalent to 2..5 (items at indices 2, 3, 4) + let sliced = view.range_checked((Bound::Excluded(1), Bound::Excluded(5))); + assert!(sliced.is_some()); + let mut sliced = sliced.unwrap(); + assert_eq!(3, sliced.len()); + assert_eq!(2, sliced.get_byte()); + assert_eq!(3, sliced.get_byte()); + assert_eq!(4, sliced.get_byte()); + + // Test edge case: excluded start at the last valid index returns empty sequence + let sliced = view.range_checked((Bound::Excluded(8), Bound::Unbounded)); + assert!(sliced.is_some()); + assert_eq!(0, sliced.unwrap().len()); + + // Test edge case: excluded start that would overflow when adding 1 + let sliced = view.range_checked((Bound::Excluded(usize::MAX), Bound::Unbounded)); + assert!(sliced.is_none()); +} + +#[test] +fn slice_oob_is_panic() { + let span_builder = TransparentMemory::new().reserve(1000); + + let mut buf = span_builder; + buf.put_byte_repeated(0, 100); + + let view = buf.consume_all(); + + assert_panic!(_ = view.range(0..101)); + assert_panic!(_ = view.range(0..=100)); + assert_panic!(_ = view.range(100..=100)); + assert_panic!(_ = view.range(100..101)); + assert_panic!(_ = view.range(101..)); + assert_panic!(_ = view.range(101..101)); + assert_panic!(_ = view.range(101..=101)); +} + +#[test] +fn slice_at_boundary_is_not_panic() { + let span_builder = TransparentMemory::new().reserve(100); + + let mut buf = span_builder; + buf.put_byte_repeated(0, 100); + + let view = buf.consume_all(); + + assert_eq!(0, view.range(0..0).len()); + assert_eq!(1, view.range(0..=0).len()); + assert_eq!(0, view.range(..0).len()); + assert_eq!(1, view.range(..=0).len()); + assert_eq!(0, view.range(100..100).len()); + assert_eq!(0, view.range(99..99).len()); + assert_eq!(1, view.range(99..=99).len()); + assert_eq!(1, view.range(99..).len()); + assert_eq!(100, view.range(..).len()); +} + +#[test] +fn slice_empty_is_empty_if_not_oob() { + let span_builder = TransparentMemory::new().reserve(100); + + let mut buf = span_builder; + + for i in 0..100 { + buf.put_byte(i); + } + + let view = buf.consume_all(); + + let sub_view = view.range(50..50); + assert_eq!(0, sub_view.len()); + + // 100 is the index at the end of the view - still in-bounds, if at edge. + let sub_view = view.range(100..100); + assert_eq!(0, sub_view.len()); + assert!(view.range_checked(101..101).is_none()); +} + +#[test] +fn consume_all_slices() { + let memory = FixedBlockMemory::new(nz!(10)); + let mut buf = memory.reserve(100); + + for i in 0..100 { + buf.put_byte(i); + } + + let mut view = buf.consume_all(); + + let mut slice_index = 0; + let mut bytes_consumed = 0; + + view.consume_all_slices(|slice| { + assert_eq!(slice.len(), 10); + bytes_consumed += slice.len(); + + for i in 0..10 { + assert_eq!(slice_index * 10 + i, slice[i] as usize); + } + + slice_index += 1; + }); + + assert_eq!(bytes_consumed, 100); + + view.consume_all_slices(|_| unreachable!("view should now be empty")); +} + +#[test] +fn multithreaded_usage() { + fn post_to_another_thread(view: BytesView) { + thread::spawn(move || { + let mut view = view; + assert_eq!(view.get_byte(), b'H'); + assert_eq!(view.get_byte(), b'e'); + assert_eq!(view.get_byte(), b'l'); + assert_eq!(view.get_byte(), b'l'); + assert_eq!(view.get_byte(), b'o'); + }) + .join() + .unwrap(); + } + + let memory = TransparentMemory::new(); + let view = BytesView::copied_from_slice(b"Hello, world!", &memory); + + post_to_another_thread(view); +} + +#[test] +fn slices_iterator() { + let memory = TransparentMemory::new(); + let segment1 = BytesView::copied_from_slice(b"Hello, world!", &memory); + let segment2 = BytesView::copied_from_slice(b"Hello, another world!", &memory); + + let view = BytesView::from_views(vec![segment1.clone(), segment2.clone()]); + + let slices: Vec<_> = view.slices().collect(); + + assert_eq!(slices.len(), 2); + assert_eq!(slices[0].0.len(), segment1.len()); + assert_eq!(slices[1].0.len(), segment2.len()); +} + +#[test] +fn slices_iterator_empty() { + let view = BytesView::new(); + assert_eq!(view.slices().count(), 0); +} + +#[test] +fn to_vec_single_span() { + let memory = TransparentMemory::new(); + let view = BytesView::copied_from_slice(b"Hello, world!", &memory); + + let bytes = view.to_vec(); + + assert_eq!(bytes, b"Hello, world!"); + // The view is left unchanged. + assert_eq!(view.len(), 13); +} + +#[test] +fn to_vec_multi_span() { + let memory = TransparentMemory::new(); + let segment1 = BytesView::copied_from_slice(b"Hello, ", &memory); + let segment2 = BytesView::copied_from_slice(b"world!", &memory); + + let view = BytesView::from_views(vec![segment1, segment2]); + + let bytes = view.to_vec(); + + assert_eq!(bytes, b"Hello, world!"); +} + +#[test] +fn to_vec_empty() { + let view = BytesView::new(); + + let bytes = view.to_vec(); + + assert!(bytes.is_empty()); +} + +#[test] +fn eq_view() { + let memory = TransparentMemory::new(); + + let view1 = BytesView::copied_from_slice(b"Hello, world!", &memory); + let view2 = BytesView::copied_from_slice(b"Hello, world!", &memory); + + assert_eq!(view1, view2); + + let view3 = BytesView::copied_from_slice(b"Jello, world!", &memory); + + assert_ne!(view1, view3); + + let view4 = BytesView::copied_from_slice(b"Hello, world! ", &memory); + + assert_ne!(view1, view4); + + let view5_part1 = BytesView::copied_from_slice(b"Hello, ", &memory); + let view5_part2 = BytesView::copied_from_slice(b"world!", &memory); + let view5 = BytesView::from_views([view5_part1, view5_part2]); + + assert_eq!(view1, view5); + assert_ne!(view5, view3); + + let view6 = BytesView::copied_from_slice(b"Hello, ", &memory); + + assert_ne!(view1, view6); + assert_ne!(view5, view6); + + // Compare two multi-span views with misaligned span boundaries to exercise + // span index advancement on both sides of the comparison. + let view7_part1 = BytesView::copied_from_slice(b"Hel", &memory); + let view7_part2 = BytesView::copied_from_slice(b"lo, world!", &memory); + let view7 = BytesView::from_views([view7_part1, view7_part2]); + + assert_eq!(view5, view7); + assert_eq!(view7, view5); +} + +#[test] +fn eq_slice() { + let memory = TransparentMemory::new(); + + let view1 = BytesView::copied_from_slice(b"Hello, world!", &memory); + + assert_eq!(view1, b"Hello, world!".as_slice()); + assert_ne!(view1, b"Jello, world!".as_slice()); + assert_ne!(view1, b"Hello, world! ".as_slice()); + + assert_eq!(b"Hello, world!".as_slice(), view1); + assert_ne!(b"Jello, world!".as_slice(), view1); + assert_ne!(b"Hello, world! ".as_slice(), view1); + + let view2_part1 = BytesView::copied_from_slice(b"Hello, ", &memory); + let view2_part2 = BytesView::copied_from_slice(b"world!", &memory); + let view2 = BytesView::from_views([view2_part1, view2_part2]); + + assert_eq!(view2, b"Hello, world!".as_slice()); + assert_ne!(view2, b"Jello, world!".as_slice()); + assert_ne!(view2, b"Hello, world! ".as_slice()); + assert_ne!(view2, b"Hello, ".as_slice()); + + assert_eq!(b"Hello, world!".as_slice(), view2); + assert_ne!(b"Jello, world!".as_slice(), view2); + assert_ne!(b"Hello, world! ".as_slice(), view2); + assert_ne!(b"Hello, ".as_slice(), view2); +} + +#[test] +fn eq_array() { + let memory = TransparentMemory::new(); + + let view1 = BytesView::copied_from_slice(b"Hello, world!", &memory); + + assert_eq!(view1, b"Hello, world!"); + assert_ne!(view1, b"Jello, world!"); + assert_ne!(view1, b"Hello, world! "); + + assert_eq!(b"Hello, world!", view1); + assert_ne!(b"Jello, world!", view1); + assert_ne!(b"Hello, world! ", view1); + + let view2_part1 = BytesView::copied_from_slice(b"Hello, ", &memory); + let view2_part2 = BytesView::copied_from_slice(b"world!", &memory); + let view2 = BytesView::from_views([view2_part1, view2_part2]); + + assert_eq!(view2, b"Hello, world!"); + assert_ne!(view2, b"Jello, world!"); + assert_ne!(view2, b"Hello, world! "); + assert_ne!(view2, b"Hello, "); + + assert_eq!(b"Hello, world!", view2); + assert_ne!(b"Jello, world!", view2); + assert_ne!(b"Hello, world! ", view2); + assert_ne!(b"Hello, ", view2); +} + +#[test] +fn first_slice_meta_empty_view() { + let view = BytesView::new(); + assert!(view.first_slice_meta().is_none()); +} + +#[test] +fn first_slice_meta_no_metadata() { + let memory = TransparentMemory::new(); + let view = BytesView::copied_from_slice(b"Hello", &memory); + // TransparentMemory does not attach metadata. + assert!(view.first_slice_meta().is_none()); +} + +#[test] +fn first_slice_meta_with_metadata() { + #[derive(Debug)] + struct TestMeta; + impl BlockMeta for TestMeta {} + + // SAFETY: We are not allowed to drop this until all BlockRef are gone. This is fine + // because it is dropped at the end of the function, after all BlockRef instances. + let block = unsafe { TestMemoryBlock::new(nz!(100), Some(Box::new(TestMeta))) }; + let block = pin!(block); + + // SAFETY: We guarantee exclusive access to the memory capacity. + let mut span_builder = BytesBuf::from_blocks([unsafe { block.as_ref().to_block() }]); + span_builder.put_slice(*b"Hello"); + let span = span_builder.consume(5); + + let view = BytesView::from_views(vec![span]); + + let meta = view.first_slice_meta(); + assert!(meta.is_some()); + assert!(meta.unwrap().is::()); +} + +#[test] +fn meta_none() { + let memory = TransparentMemory::new(); + + let view1 = BytesView::copied_from_slice(b"Hello, ", &memory); + let view2 = BytesView::copied_from_slice(b"world!", &memory); + + let view = BytesView::from_views([view1, view2]); + + let mut slices_iter = view.slices(); + + // We have two chunks, both without metadata. + let (data1, meta1) = slices_iter.next().expect("should have first slice"); + assert!(!data1.is_empty()); + assert!(meta1.is_none()); + + let (data2, meta2) = slices_iter.next().expect("should have second slice"); + assert!(!data2.is_empty()); + assert!(meta2.is_none()); + + assert!(slices_iter.next().is_none()); +} + +#[test] +fn meta_some() { + #[derive(Debug)] + struct GreenMeta; + #[derive(Debug)] + struct BlueMeta; + + impl BlockMeta for GreenMeta {} + impl BlockMeta for BlueMeta {} + + // SAFETY: We are not allowed to drop this until all BlockRef are gone. This is fine + // because it is dropped at the end of the function, after all BlockRef instances. + let block1 = unsafe { TestMemoryBlock::new(nz!(100), Some(Box::new(GreenMeta {}))) }; + let block1 = pin!(block1); + + // SAFETY: We are not allowed to drop this until all BlockRef are gone. This is fine + // because it is dropped at the end of the function, after all BlockRef instances. + let block2 = unsafe { TestMemoryBlock::new(nz!(100), Some(Box::new(BlueMeta {}))) }; + let block2 = pin!(block2); + + // SAFETY: We guarantee exclusive access to the memory capacity. + let block1 = unsafe { block1.as_ref().to_block() }; + // SAFETY: We guarantee exclusive access to the memory capacity. + let block2 = unsafe { block2.as_ref().to_block() }; + + let mut buf = BytesBuf::from_blocks([block1, block2]); + + // Add enough bytes to make use of both blocks. + buf.put_byte_repeated(123, 166); + + let view = buf.consume_all(); + + let mut slices_iter = view.slices(); + + // NB! There is no requirement that the BytesBuf use the blocks in the order we gave + // them in. We use white-box knowledge here to know that it actually reverses the order. + // This behavior may change in a future version - be ready to change the test if so. + + let (data1, meta1) = slices_iter.next().expect("should have first block"); + assert!(!data1.is_empty()); + assert!(meta1.is_some()); + assert!(meta1.unwrap().is::()); + assert!(!meta1.unwrap().is::()); + + let (data2, meta2) = slices_iter.next().expect("should have second block"); + assert!(!data2.is_empty()); + assert!(meta2.is_some()); + assert!(meta2.unwrap().is::()); + assert!(!meta2.unwrap().is::()); + + assert!(slices_iter.next().is_none(), "should have no more slices"); +} + +#[test] +fn append_single_span() { + let memory = TransparentMemory::new(); + + // Create two single-span views. + let mut view1 = BytesView::copied_from_slice(b"Hello, ", &memory); + let view2 = BytesView::copied_from_slice(b"world!", &memory); + + assert_eq!(view1.len(), 7); + assert_eq!(view2.len(), 6); + + view1.append(view2); + + assert_eq!(view1.len(), 13); + assert_eq!(view1, b"Hello, world!"); +} + +#[test] +fn append_multi_span() { + let memory = TransparentMemory::new(); + + // Create two multi-span views (2 spans each) + let view1_part1 = BytesView::copied_from_slice(b"AAA", &memory); + let view1_part2 = BytesView::copied_from_slice(b"BBB", &memory); + let mut view1 = BytesView::from_views([view1_part1, view1_part2]); + + let view2_part1 = BytesView::copied_from_slice(b"CCC", &memory); + let view2_part2 = BytesView::copied_from_slice(b"DDD", &memory); + let view2 = BytesView::from_views([view2_part1, view2_part2]); + + assert_eq!(view1.len(), 6); + assert_eq!(view2.len(), 6); + + view1.append(view2); + + assert_eq!(view1.len(), 12); + assert_eq!(view1, b"AAABBBCCCDDD"); +} + +#[test] +fn append_empty_view() { + let memory = TransparentMemory::new(); + + let mut view1 = BytesView::copied_from_slice(b"Hello", &memory); + let view2 = BytesView::new(); + + view1.append(view2); + assert_eq!(view1.len(), 5); + assert_eq!(view1, b"Hello"); + + let mut view3 = BytesView::new(); + let view4 = BytesView::copied_from_slice(b"world", &memory); + + view3.append(view4); + assert_eq!(view3.len(), 5); + assert_eq!(view3, b"world"); +} + +#[cfg(feature = "seismograph")] +#[test] +fn append_preserves_identity_when_only_one_view_has_data() { + use seismograph_io::Buffer; + let memory = TransparentMemory::new(); + let mut populated = BytesView::copied_from_slice(b"Hello", &memory); + let populated_id = populated.recording_state().id(); + populated.append(BytesView::new()); + + let mut empty = BytesView::new(); + let transferred = BytesView::copied_from_slice(b"world", &memory); + let transferred_id = transferred.recording_state().id(); + empty.append(transferred); + + assert_eq!( + (populated.recording_state().id(), empty.recording_state().id()), + (populated_id, transferred_id) + ); +} + +#[test] +fn concat_single_span() { + let memory = TransparentMemory::new(); + + // Create two single-span views + let view1 = BytesView::copied_from_slice(b"Hello, ", &memory); + let view2 = BytesView::copied_from_slice(b"world!", &memory); + + assert_eq!(view1.len(), 7); + assert_eq!(view2.len(), 6); + + let view3 = view1.concat(view2); + + // Original view unchanged + assert_eq!(view1.len(), 7); + assert_eq!(view1, b"Hello, "); + + // New view contains combined data + assert_eq!(view3.len(), 13); + assert_eq!(view3, b"Hello, world!"); +} + +#[test] +fn concat_multi_span() { + let memory = TransparentMemory::new(); + + // Create two multi-span views (2 spans each) + let view1_part1 = BytesView::copied_from_slice(b"AAA", &memory); + let view1_part2 = BytesView::copied_from_slice(b"BBB", &memory); + let view1 = BytesView::from_views([view1_part1, view1_part2]); + + let view2_part1 = BytesView::copied_from_slice(b"CCC", &memory); + let view2_part2 = BytesView::copied_from_slice(b"DDD", &memory); + let view2 = BytesView::from_views([view2_part1, view2_part2]); + + assert_eq!(view1.len(), 6); + assert_eq!(view2.len(), 6); + + let view3 = view1.concat(view2); + + // Original view unchanged + assert_eq!(view1.len(), 6); + assert_eq!(view1, b"AAABBB"); + + // New view contains combined data + assert_eq!(view3.len(), 12); + assert_eq!(view3, b"AAABBBCCCDDD"); +} + +#[test] +fn concat_empty_views() { + let memory = TransparentMemory::new(); + + let view1 = BytesView::copied_from_slice(b"Hello", &memory); + let view2 = BytesView::new(); + + let view3 = view1.concat(view2); + assert_eq!(view3.len(), 5); + assert_eq!(view3, b"Hello"); + + let view4 = BytesView::new(); + let view5 = BytesView::copied_from_slice(b"world", &memory); + + let view6 = view4.concat(view5); + assert_eq!(view6.len(), 5); + assert_eq!(view6, b"world"); +} + +#[test] +fn hash_equal_views_produce_same_hash() { + use std::hash::{DefaultHasher, Hash, Hasher}; + + let a = BytesView::from(vec![1, 2, 3, 4, 5]); + let b = BytesView::from(vec![1, 2, 3, 4, 5]); + + let hash_of = |v: &BytesView| { + let mut h = DefaultHasher::new(); + v.hash(&mut h); + h.finish() + }; + + assert_eq!(hash_of(&a), hash_of(&b)); +} + +#[test] +fn hash_multi_span_matches_single_span() { + use std::hash::{DefaultHasher, Hash, Hasher}; + + let single = BytesView::from(vec![1, 2, 3, 4, 5, 6]); + + let mut multi = BytesView::from(vec![1, 2, 3]); + multi.append(BytesView::from(vec![4, 5, 6])); + + let hash_of = |v: &BytesView| { + let mut h = DefaultHasher::new(); + v.hash(&mut h); + h.finish() + }; + + assert_eq!(single, multi); + assert_eq!(hash_of(&single), hash_of(&multi)); +} + +#[test] +fn hash_different_views_produce_different_hash() { + use std::hash::{DefaultHasher, Hash, Hasher}; + + let a = BytesView::from(vec![1, 2, 3]); + let b = BytesView::from(vec![4, 5, 6]); + + let hash_of = |v: &BytesView| { + let mut h = DefaultHasher::new(); + v.hash(&mut h); + h.finish() + }; + + assert_ne!(hash_of(&a), hash_of(&b)); +} + +#[test] +fn hash_is_independent_of_span_segmentation() { + // Same logical bytes, three different span segmentations: one, two, and three spans. + let one_span = BytesView::from(vec![1, 2, 3, 4, 5, 6]); + + let mut two_spans = BytesView::from(vec![1, 2, 3]); + two_spans.append(BytesView::from(vec![4, 5, 6])); + + let mut three_spans = BytesView::from(vec![1, 2]); + three_spans.append(BytesView::from(vec![3, 4])); + three_spans.append(BytesView::from(vec![5, 6])); + + // All three are equal per the boundary-independent equality. + assert_eq!(one_span, two_spans); + assert_eq!(one_span, three_spans); + + let hash_of = |v: &BytesView| { + let mut h = BoundarySensitiveHasher::default(); + v.hash(&mut h); + h.finish() + }; + + // The Hash/Eq contract requires equal values to hash equally, even under a hasher that is + // sensitive to how bytes are chunked across write() calls. + assert_eq!(hash_of(&one_span), hash_of(&two_spans)); + assert_eq!(hash_of(&one_span), hash_of(&three_spans)); +} + +#[test] +fn hash_is_independent_of_span_segmentation_across_block_boundary() { + // Content longer than 64 so hashing spills across multiple blocks, with span + // splits that do not line up with the block boundaries. The hash must still ignore how the + // bytes are segmented into spans. + let content: Vec = (0..=u8::MAX).cycle().take(64 * 2 + 5).collect(); + + let one_span = BytesView::from(content.clone()); + + // Split at offsets that straddle the 64-byte block boundary (before, on, and after it). + let split_points = [1, 64 - 3, 64, 64 + 7]; + let mut many_spans = BytesView::new(); + let mut previous = 0; + for &point in &split_points { + many_spans.append(BytesView::from(content[previous..point].to_vec())); + previous = point; + } + many_spans.append(BytesView::from(content[previous..].to_vec())); + + assert_eq!(one_span, many_spans); + + let hash_of = |v: &BytesView| { + let mut h = BoundarySensitiveHasher::default(); + v.hash(&mut h); + h.finish() + }; + + assert_eq!(hash_of(&one_span), hash_of(&many_spans)); +} + +#[test] +fn hash_write_sequence_is_identical_regardless_of_segmentation() { + // Splits `content` into spans of at most `segment_len` bytes each. + fn segmented_view(content: &[u8], segment_len: usize) -> BytesView { + let mut view = BytesView::new(); + for chunk in content.chunks(segment_len) { + view.append(BytesView::from(chunk.to_vec())); + } + view + } + + let record = |v: &BytesView| { + let mut h = RecordingHasher::default(); + v.hash(&mut h); + h.writes + }; + + // Cover lengths around the block boundary (64 == 64) and beyond. + for len in [0_usize, 1, 63, 64, 65, 128, 130, 200] { + let content: Vec = (0..=u8::MAX).cycle().take(len).collect(); + + let single = BytesView::from(content.clone()); + let baseline = record(&single); + + // Pin the absolute write sequence: the length prefix followed by the content split + // into 64 chunks, with no trailing empty write (`chunks` never yields an + // empty slice, including for an empty view). Asserting the exact sequence - rather than + // only comparing segmentations against each other - is what catches a spurious empty + // trailing write when the length is an exact multiple of the block size. + let mut expected: Vec> = vec![len.to_ne_bytes().to_vec()]; + expected.extend(content.chunks(64).map(<[u8]>::to_vec)); + assert_eq!(baseline, expected, "unexpected hash write sequence for len {len}"); + + for segment_len in [1, 7, 63, 64, 65, 100] { + let segmented = segmented_view(&content, segment_len); + + assert_eq!(single, segmented, "len {len}, segment {segment_len}"); + assert_eq!( + record(&segmented), + baseline, + "hash write sequence differs for len {len}, segment {segment_len}", + ); + } + } +} diff --git a/crates/bytesbuf/tests/public_api/view_get.rs b/crates/bytesbuf/tests/public_api/view_get.rs new file mode 100644 index 0000000000..e99f0e2c65 --- /dev/null +++ b/crates/bytesbuf/tests/public_api/view_get.rs @@ -0,0 +1,272 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use std::mem::MaybeUninit; + +use bytesbuf::BytesView; +use bytesbuf::mem::testing::TransparentMemory; + +#[test] +fn get_byte() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); + + assert_eq!(view.get_byte(), 1); + assert_eq!(view.get_byte(), 2); + assert_eq!(view.get_byte(), 3); + assert_eq!(view.get_byte(), 4); + assert!(view.is_empty()); +} + +#[test] +fn copy_to_slice() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); + + let mut dst = [0u8; 4]; + view.copy_to_slice(&mut dst); + + assert_eq!(dst, [1, 2, 3, 4]); + assert!(view.is_empty()); +} + +#[test] +fn copy_to_smaller_slice_copies_partially() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); + + let mut dst = [0u8; 3]; + view.copy_to_slice(&mut dst); + + assert_eq!(dst, [1, 2, 3]); + assert_eq!(view.len(), 1); +} + +#[test] +#[should_panic] +fn copy_to_bigger_slice_panics() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); + + let mut dst = [0u8; 8]; + view.copy_to_slice(&mut dst); +} + +#[test] +fn copy_to_uninit_slice() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); + + let mut dst = MaybeUninit::<[u8; 4]>::uninit(); + view.copy_to_uninit_slice(dst.as_mut()); + + // SAFETY: It has now been initialized. + let dst = unsafe { dst.assume_init() }; + + assert_eq!(dst, [1, 2, 3, 4]); + assert!(view.is_empty()); +} + +#[test] +fn copy_to_uninit_smaller_slice_copies_partially() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); + + let mut dst = MaybeUninit::<[u8; 3]>::uninit(); + view.copy_to_uninit_slice(dst.as_mut()); + + // SAFETY: It has now been initialized. + let dst = unsafe { dst.assume_init() }; + + assert_eq!(dst, [1, 2, 3]); + assert_eq!(view.len(), 1); +} + +#[test] +#[should_panic] +fn copy_to_uninit_bigger_slice_panics() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); + + let mut dst = [MaybeUninit::::uninit(); 8]; + view.copy_to_uninit_slice(&mut dst); +} + +#[test] +fn copy_to_slice_multi_span() { + let memory = TransparentMemory::new(); + let data_part1 = [10_u8, 20]; + let data_part2 = [30_u8, 40, 50]; + let view_part1 = BytesView::copied_from_slice(&data_part1, &memory); + let view_part2 = BytesView::copied_from_slice(&data_part2, &memory); + let mut view_combined = BytesView::from_views([view_part1, view_part2]); + + let mut dst = [0u8; 5]; + view_combined.copy_to_slice(&mut dst); + assert!(view_combined.is_empty()); + + assert_eq!(dst, [10_u8, 20, 30, 40, 50]); +} + +#[test] +fn copy_to_uninit_slice_multi_span() { + let memory = TransparentMemory::new(); + let data_part1 = [10_u8, 20]; + let data_part2 = [30_u8, 40, 50]; + let view_part1 = BytesView::copied_from_slice(&data_part1, &memory); + let view_part2 = BytesView::copied_from_slice(&data_part2, &memory); + let mut view_combined = BytesView::from_views([view_part1, view_part2]); + + let mut dst = MaybeUninit::<[u8; 5]>::uninit(); + view_combined.copy_to_uninit_slice(dst.as_mut()); + assert!(view_combined.is_empty()); + + // SAFETY: It has now been initialized. + let dst = unsafe { dst.assume_init() }; + + assert_eq!(dst, [10_u8, 20, 30, 40, 50]); +} + +#[test] +fn get_u16_le() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(&[0x34, 0x12, 0x78, 0x56], &memory); + + assert_eq!(view.get_u16_le(), 0x1234); + assert_eq!(view.get_u16_le(), 0x5678); + + assert!(view.is_empty()); +} + +#[test] +fn get_u32_le_multi_span() { + let memory = TransparentMemory::new(); + let view_part1 = BytesView::copied_from_slice(&[0x78_u8, 0x56], &memory); + let view_part2 = BytesView::copied_from_slice(&[0x34_u8, 0x12], &memory); + let mut view_combined = BytesView::from_views([view_part1, view_part2]); + + assert_eq!(view_combined.get_u32_le(), 0x1234_5678); + + assert!(view_combined.is_empty()); +} + +#[test] +fn get_u16_be() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(&[0x12, 0x34, 0x56, 0x78], &memory); + + assert_eq!(view.get_u16_be(), 0x1234); + assert_eq!(view.get_u16_be(), 0x5678); + + assert!(view.is_empty()); +} + +#[test] +fn get_u32_be_multi_span() { + let memory = TransparentMemory::new(); + let view_part1 = BytesView::copied_from_slice(&[0x12_u8, 0x34], &memory); + let view_part2 = BytesView::copied_from_slice(&[0x56_u8, 0x78], &memory); + let mut view_combined = BytesView::from_views([view_part1, view_part2]); + + assert_eq!(view_combined.get_u32_be(), 0x1234_5678); + + assert!(view_combined.is_empty()); +} + +#[test] +fn get_u16_ne() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(&[0x34, 0x12, 0x78, 0x56], &memory); + + if cfg!(target_endian = "big") { + assert_eq!(view.get_u16_ne(), 0x3412); + assert_eq!(view.get_u16_ne(), 0x7856); + } else { + assert_eq!(view.get_u16_ne(), 0x1234); + assert_eq!(view.get_u16_ne(), 0x5678); + } + + assert!(view.is_empty()); +} + +#[test] +fn get_u32_ne_multi_span() { + let memory = TransparentMemory::new(); + let view_part1 = BytesView::copied_from_slice(&[0x78_u8, 0x56], &memory); + let view_part2 = BytesView::copied_from_slice(&[0x34_u8, 0x12], &memory); + let mut view_combined = BytesView::from_views([view_part1, view_part2]); + + if cfg!(target_endian = "big") { + assert_eq!(view_combined.get_u32_ne(), 0x7856_3412); + } else { + assert_eq!(view_combined.get_u32_ne(), 0x1234_5678); + } + + assert!(view_combined.is_empty()); +} + +#[test] +fn get_signed_and_float_round_trip() { + let memory = TransparentMemory::new(); + + let mut data = Vec::new(); + data.extend_from_slice(&(-12345_i16).to_le_bytes()); + data.extend_from_slice(&(-2_000_000_000_i32).to_be_bytes()); + data.extend_from_slice(&(-9_000_000_000_000_i64).to_le_bytes()); + data.extend_from_slice(&i128::MIN.to_be_bytes()); + data.extend_from_slice(&std::f32::consts::PI.to_le_bytes()); + data.extend_from_slice(&std::f64::consts::E.to_be_bytes()); + + let mut view = BytesView::copied_from_slice(&data, &memory); + + assert_eq!(view.get_i16_le(), -12345); + assert_eq!(view.get_i32_be(), -2_000_000_000); + assert_eq!(view.get_i64_le(), -9_000_000_000_000); + assert_eq!(view.get_i128_be(), i128::MIN); + assert_eq!(view.get_f32_le().to_bits(), std::f32::consts::PI.to_bits()); + assert_eq!(view.get_f64_be().to_bits(), std::f64::consts::E.to_bits()); + assert!(view.is_empty()); +} + +#[test] +fn get_wide_value_multi_span() { + let memory = TransparentMemory::new(); + let value: u128 = 0x0123_4567_89AB_CDEF_FEDC_BA98_7654_3210; + let bytes = value.to_le_bytes(); + + // Split at an odd offset so the value straddles the span boundary and exercises buffering. + let view_part1 = BytesView::copied_from_slice(&bytes[..5], &memory); + let view_part2 = BytesView::copied_from_slice(&bytes[5..], &memory); + let mut view = BytesView::from_views([view_part1, view_part2]); + + assert_eq!(view.get_u128_le(), value); + assert!(view.is_empty()); +} + +#[test] +fn get_misaligned_single_span() { + let memory = TransparentMemory::new(); + + // Drop a single leading byte so the eight value bytes sit at an odd offset from the + // allocation base, exercising the fast path against a misaligned source. + let value: u64 = 0x0123_4567_89AB_CDEF; + let mut data = vec![0xFF_u8]; + data.extend_from_slice(&value.to_le_bytes()); + let mut view = BytesView::copied_from_slice(&data, &memory); + + assert_eq!(view.get_byte(), 0xFF); + assert_eq!(view.get_u64_le(), value); + assert!(view.is_empty()); +} + +#[test] +#[should_panic] +fn get_num_insufficient_bytes_panics() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(&[0x00, 0x01, 0x02], &memory); + + // Only three bytes are available, so reading a four-byte value must panic. + let _ = view.get_u32_le(); +} diff --git a/crates/bytesbuf/tests/public_api/view_read.rs b/crates/bytesbuf/tests/public_api/view_read.rs new file mode 100644 index 0000000000..40e0fc4a15 --- /dev/null +++ b/crates/bytesbuf/tests/public_api/view_read.rs @@ -0,0 +1,89 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Tests behavior through the public API. + +use std::io::{BufRead, Read}; + +use bytesbuf::BytesView; +use bytesbuf::mem::testing::TransparentMemory; + +#[test] +fn smoke_test() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(b"Hello, world", &memory); + + let mut buffer = [0u8; 5]; + let bytes_read = view.read(&mut buffer).unwrap(); + + // We use white-box knowledge to know that we always read as much as is available, + // there are no partial reads unless at end of data. This simplifies the test logic. + assert_eq!(bytes_read, 5); + assert_eq!(&buffer, b"Hello"); + + let bytes_read = view.read(&mut buffer).unwrap(); + + assert_eq!(bytes_read, 5); + assert_eq!(&buffer, b", wor"); + + let bytes_read = view.read(&mut buffer).unwrap(); + assert_eq!(bytes_read, 2); + assert_eq!(&buffer[..2], b"ld"); + + let bytes_read = view.read(&mut buffer).unwrap(); + assert_eq!(bytes_read, 0); +} + +#[test] +fn buf_read_fill_buf_and_consume() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(b"Hello, world", &memory); + + // fill_buf returns the first contiguous slice without consuming it. + let buf = view.fill_buf().unwrap(); + assert_eq!(buf, b"Hello, world"); + + // Calling fill_buf again returns the same data (no consumption). + let buf = view.fill_buf().unwrap(); + assert_eq!(buf, b"Hello, world"); + + // Consume some bytes and verify the remainder. + BufRead::consume(&mut view, 7); + let buf = view.fill_buf().unwrap(); + assert_eq!(buf, b"world"); + + // Consume remaining bytes. + BufRead::consume(&mut view, 5); + let buf = view.fill_buf().unwrap(); + assert!(buf.is_empty()); +} + +#[test] +fn buf_read_read_line() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(b"first\nsecond\n", &memory); + + let mut line = String::new(); + let bytes_read = view.read_line(&mut line).unwrap(); + assert_eq!(bytes_read, 6); + assert_eq!(line, "first\n"); + + line.clear(); + let bytes_read = view.read_line(&mut line).unwrap(); + assert_eq!(bytes_read, 7); + assert_eq!(line, "second\n"); + + line.clear(); + let bytes_read = view.read_line(&mut line).unwrap(); + assert_eq!(bytes_read, 0); + assert!(line.is_empty()); +} + +#[test] +fn buf_read_on_empty_view() { + let memory = TransparentMemory::new(); + let mut view = BytesView::copied_from_slice(b"", &memory); + + let buf = view.fill_buf().unwrap(); + assert!(buf.is_empty()); +} diff --git a/crates/bytesbuf/src/testing.rs b/crates/bytesbuf/tests/support/system_memory.rs similarity index 100% rename from crates/bytesbuf/src/testing.rs rename to crates/bytesbuf/tests/support/system_memory.rs From d10b80588a0d4d4a41efccb3bb286117c20dbdc0 Mon Sep 17 00:00:00 2001 From: "Martin Tomka (from Dev Box)" Date: Fri, 13 Nov 2026 16:02:09 +0100 Subject: [PATCH 2/7] test(bytesbuf): group integration tests by behavior Use nested module discovery for buffer, view, conversion, and memory-provider targets. Share test fixtures without expanding public APIs. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- crates/bytesbuf/Cargo.toml | 14 ++++- crates/bytesbuf/tests/buffers.rs | 16 ++++++ .../tests/{public_api => buffers}/buf.rs | 8 ++- .../{public_api/buf_put.rs => buffers/put.rs} | 0 .../buf_writer.rs => buffers/writer.rs} | 0 crates/bytesbuf/tests/conversions.rs | 20 +++++++ .../buf.rs} | 0 .../from_bytes.rs} | 2 +- .../vec.rs => conversions/from_vec.rs} | 2 +- .../to_bytes.rs} | 0 .../view.rs} | 0 crates/bytesbuf/tests/memory_providers.rs | 18 +++++++ .../block_ref.rs} | 0 .../callback.rs} | 0 .../fixed_block.rs} | 0 .../global.rs} | 0 .../memory.rs} | 0 .../opaque.rs} | 0 .../transparent.rs} | 2 +- crates/bytesbuf/tests/public_api.rs | 54 ------------------- .../support/{system_memory.rs => mod.rs} | 0 crates/bytesbuf/tests/views.rs | 16 ++++++ .../{public_api/view_get.rs => views/get.rs} | 0 .../view_read.rs => views/read.rs} | 0 .../tests/{public_api => views}/view.rs | 0 25 files changed, 92 insertions(+), 60 deletions(-) create mode 100644 crates/bytesbuf/tests/buffers.rs rename crates/bytesbuf/tests/{public_api => buffers}/buf.rs (99%) rename crates/bytesbuf/tests/{public_api/buf_put.rs => buffers/put.rs} (100%) rename crates/bytesbuf/tests/{public_api/buf_writer.rs => buffers/writer.rs} (100%) create mode 100644 crates/bytesbuf/tests/conversions.rs rename crates/bytesbuf/tests/{public_api/bytes_compat_buf.rs => conversions/buf.rs} (100%) rename crates/bytesbuf/tests/{public_api/bytes_compat_from_bytes.rs => conversions/from_bytes.rs} (96%) rename crates/bytesbuf/tests/{public_api/vec.rs => conversions/from_vec.rs} (96%) rename crates/bytesbuf/tests/{public_api/bytes_compat_to_bytes.rs => conversions/to_bytes.rs} (100%) rename crates/bytesbuf/tests/{public_api/bytes_compat_view.rs => conversions/view.rs} (100%) create mode 100644 crates/bytesbuf/tests/memory_providers.rs rename crates/bytesbuf/tests/{public_api/mem_block_ref.rs => memory_providers/block_ref.rs} (100%) rename crates/bytesbuf/tests/{public_api/mem_callback_memory.rs => memory_providers/callback.rs} (100%) rename crates/bytesbuf/tests/{public_api/mem_testing_fixed_block.rs => memory_providers/fixed_block.rs} (100%) rename crates/bytesbuf/tests/{public_api/mem_global.rs => memory_providers/global.rs} (100%) rename crates/bytesbuf/tests/{public_api/mem_memory.rs => memory_providers/memory.rs} (100%) rename crates/bytesbuf/tests/{public_api/mem_opaque_memory.rs => memory_providers/opaque.rs} (100%) rename crates/bytesbuf/tests/{public_api/mem_testing_transparent.rs => memory_providers/transparent.rs} (96%) delete mode 100644 crates/bytesbuf/tests/public_api.rs rename crates/bytesbuf/tests/support/{system_memory.rs => mod.rs} (100%) create mode 100644 crates/bytesbuf/tests/views.rs rename crates/bytesbuf/tests/{public_api/view_get.rs => views/get.rs} (100%) rename crates/bytesbuf/tests/{public_api/view_read.rs => views/read.rs} (100%) rename crates/bytesbuf/tests/{public_api => views}/view.rs (100%) diff --git a/crates/bytesbuf/Cargo.toml b/crates/bytesbuf/Cargo.toml index 8862182b90..970da318aa 100644 --- a/crates/bytesbuf/Cargo.toml +++ b/crates/bytesbuf/Cargo.toml @@ -84,7 +84,19 @@ windows-sys = { workspace = true, features = [ ] } [[test]] -name = "public_api" +name = "buffers" +required-features = ["test-util"] + +[[test]] +name = "views" +required-features = ["test-util"] + +[[test]] +name = "conversions" +required-features = ["test-util"] + +[[test]] +name = "memory_providers" required-features = ["test-util"] [[bench]] diff --git a/crates/bytesbuf/tests/buffers.rs b/crates/bytesbuf/tests/buffers.rs new file mode 100644 index 0000000000..e627299645 --- /dev/null +++ b/crates/bytesbuf/tests/buffers.rs @@ -0,0 +1,16 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Buffer construction, writes, and standard I/O adapters. + +use bytesbuf::mem; + +// Shared fixture for integration tests and private unit tests. +#[path = "../src/mem/testing/test_block.rs"] +mod test_block; + +mod buffers { + mod buf; + mod put; + mod writer; +} diff --git a/crates/bytesbuf/tests/public_api/buf.rs b/crates/bytesbuf/tests/buffers/buf.rs similarity index 99% rename from crates/bytesbuf/tests/public_api/buf.rs rename to crates/bytesbuf/tests/buffers/buf.rs index 3d7d56d969..722d2ee595 100644 --- a/crates/bytesbuf/tests/public_api/buf.rs +++ b/crates/bytesbuf/tests/buffers/buf.rs @@ -1017,12 +1017,16 @@ fn first_unfilled_slice_meta_with_meta() { let block = pin!(block); // SAFETY: We guarantee exclusive access to the memory capacity. - let block = unsafe { block.as_ref().to_block() }; + let memory_block = unsafe { block.as_ref().to_block() }; - let buf = BytesBuf::from_blocks([block]); + let buf = BytesBuf::from_blocks([memory_block]); + assert_eq!(block.ref_count(), 1); let meta = buf.first_unfilled_slice_meta().expect("should have metadata"); assert!(meta.is::()); assert!(!meta.is::()); + + drop(buf); + assert_eq!(block.ref_count(), 0); } #[test] diff --git a/crates/bytesbuf/tests/public_api/buf_put.rs b/crates/bytesbuf/tests/buffers/put.rs similarity index 100% rename from crates/bytesbuf/tests/public_api/buf_put.rs rename to crates/bytesbuf/tests/buffers/put.rs diff --git a/crates/bytesbuf/tests/public_api/buf_writer.rs b/crates/bytesbuf/tests/buffers/writer.rs similarity index 100% rename from crates/bytesbuf/tests/public_api/buf_writer.rs rename to crates/bytesbuf/tests/buffers/writer.rs diff --git a/crates/bytesbuf/tests/conversions.rs b/crates/bytesbuf/tests/conversions.rs new file mode 100644 index 0000000000..fb30a13d7d --- /dev/null +++ b/crates/bytesbuf/tests/conversions.rs @@ -0,0 +1,20 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Vector conversions and compatibility with the `bytes` crate. + +#![cfg_attr(coverage_nightly, feature(coverage_attribute))] + +mod support; + +mod conversions { + #[cfg(feature = "bytes-compat")] + mod buf; + #[cfg(feature = "bytes-compat")] + mod from_bytes; + mod from_vec; + #[cfg(feature = "bytes-compat")] + mod to_bytes; + #[cfg(feature = "bytes-compat")] + mod view; +} diff --git a/crates/bytesbuf/tests/public_api/bytes_compat_buf.rs b/crates/bytesbuf/tests/conversions/buf.rs similarity index 100% rename from crates/bytesbuf/tests/public_api/bytes_compat_buf.rs rename to crates/bytesbuf/tests/conversions/buf.rs diff --git a/crates/bytesbuf/tests/public_api/bytes_compat_from_bytes.rs b/crates/bytesbuf/tests/conversions/from_bytes.rs similarity index 96% rename from crates/bytesbuf/tests/public_api/bytes_compat_from_bytes.rs rename to crates/bytesbuf/tests/conversions/from_bytes.rs index c9ac40a4eb..4e64e0a4d2 100644 --- a/crates/bytesbuf/tests/public_api/bytes_compat_from_bytes.rs +++ b/crates/bytesbuf/tests/conversions/from_bytes.rs @@ -35,7 +35,7 @@ fn test_giant_bytes_to_view() { // This test requires at least 5 GB of memory to run. The publishing pipeline runs on a system // where this may not be available, so we skip this test in that environment. #[cfg(all(not(miri), any(target_os = "linux", target_os = "windows")))] - if crate::testing::system_memory() < 10_000_000_000 { + if crate::support::system_memory() < 10_000_000_000 { eprintln!("Skipping giant allocation test due to insufficient memory."); return; } diff --git a/crates/bytesbuf/tests/public_api/vec.rs b/crates/bytesbuf/tests/conversions/from_vec.rs similarity index 96% rename from crates/bytesbuf/tests/public_api/vec.rs rename to crates/bytesbuf/tests/conversions/from_vec.rs index 06b448a38e..e99f04a49a 100644 --- a/crates/bytesbuf/tests/public_api/vec.rs +++ b/crates/bytesbuf/tests/conversions/from_vec.rs @@ -49,7 +49,7 @@ fn test_giant_vec_to_view() { // This test requires at least 5 GB of memory to run. The publishing pipeline runs on a system // where this may not be available, so we skip this test in that environment. #[cfg(all(not(miri), any(target_os = "linux", target_os = "windows")))] - if crate::testing::system_memory() < 10_000_000_000 { + if crate::support::system_memory() < 10_000_000_000 { eprintln!("Skipping giant allocation test due to insufficient memory."); return; } diff --git a/crates/bytesbuf/tests/public_api/bytes_compat_to_bytes.rs b/crates/bytesbuf/tests/conversions/to_bytes.rs similarity index 100% rename from crates/bytesbuf/tests/public_api/bytes_compat_to_bytes.rs rename to crates/bytesbuf/tests/conversions/to_bytes.rs diff --git a/crates/bytesbuf/tests/public_api/bytes_compat_view.rs b/crates/bytesbuf/tests/conversions/view.rs similarity index 100% rename from crates/bytesbuf/tests/public_api/bytes_compat_view.rs rename to crates/bytesbuf/tests/conversions/view.rs diff --git a/crates/bytesbuf/tests/memory_providers.rs b/crates/bytesbuf/tests/memory_providers.rs new file mode 100644 index 0000000000..81563b815a --- /dev/null +++ b/crates/bytesbuf/tests/memory_providers.rs @@ -0,0 +1,18 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! Memory providers, block references, and their public contracts. + +#![cfg_attr(coverage_nightly, feature(coverage_attribute))] + +mod support; + +mod memory_providers { + mod block_ref; + mod callback; + mod fixed_block; + mod global; + mod memory; + mod opaque; + mod transparent; +} diff --git a/crates/bytesbuf/tests/public_api/mem_block_ref.rs b/crates/bytesbuf/tests/memory_providers/block_ref.rs similarity index 100% rename from crates/bytesbuf/tests/public_api/mem_block_ref.rs rename to crates/bytesbuf/tests/memory_providers/block_ref.rs diff --git a/crates/bytesbuf/tests/public_api/mem_callback_memory.rs b/crates/bytesbuf/tests/memory_providers/callback.rs similarity index 100% rename from crates/bytesbuf/tests/public_api/mem_callback_memory.rs rename to crates/bytesbuf/tests/memory_providers/callback.rs diff --git a/crates/bytesbuf/tests/public_api/mem_testing_fixed_block.rs b/crates/bytesbuf/tests/memory_providers/fixed_block.rs similarity index 100% rename from crates/bytesbuf/tests/public_api/mem_testing_fixed_block.rs rename to crates/bytesbuf/tests/memory_providers/fixed_block.rs diff --git a/crates/bytesbuf/tests/public_api/mem_global.rs b/crates/bytesbuf/tests/memory_providers/global.rs similarity index 100% rename from crates/bytesbuf/tests/public_api/mem_global.rs rename to crates/bytesbuf/tests/memory_providers/global.rs diff --git a/crates/bytesbuf/tests/public_api/mem_memory.rs b/crates/bytesbuf/tests/memory_providers/memory.rs similarity index 100% rename from crates/bytesbuf/tests/public_api/mem_memory.rs rename to crates/bytesbuf/tests/memory_providers/memory.rs diff --git a/crates/bytesbuf/tests/public_api/mem_opaque_memory.rs b/crates/bytesbuf/tests/memory_providers/opaque.rs similarity index 100% rename from crates/bytesbuf/tests/public_api/mem_opaque_memory.rs rename to crates/bytesbuf/tests/memory_providers/opaque.rs diff --git a/crates/bytesbuf/tests/public_api/mem_testing_transparent.rs b/crates/bytesbuf/tests/memory_providers/transparent.rs similarity index 96% rename from crates/bytesbuf/tests/public_api/mem_testing_transparent.rs rename to crates/bytesbuf/tests/memory_providers/transparent.rs index 81e36b1c2d..e7afa8b127 100644 --- a/crates/bytesbuf/tests/public_api/mem_testing_transparent.rs +++ b/crates/bytesbuf/tests/memory_providers/transparent.rs @@ -35,7 +35,7 @@ fn giant_allocation() { // This test requires at least 5 GB of memory to run. The publishing pipeline runs on a system // where this may not be available, so we skip this test in that environment. #[cfg(all(not(miri), any(target_os = "linux", target_os = "windows")))] - if crate::testing::system_memory() < 10_000_000_000 { + if crate::support::system_memory() < 10_000_000_000 { eprintln!("Skipping giant allocation test due to insufficient memory."); return; } diff --git a/crates/bytesbuf/tests/public_api.rs b/crates/bytesbuf/tests/public_api.rs deleted file mode 100644 index 5a81273568..0000000000 --- a/crates/bytesbuf/tests/public_api.rs +++ /dev/null @@ -1,54 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT License. - -//! Tests byte sequences through public APIs and existing test fixtures. - -#![cfg_attr(coverage_nightly, feature(coverage_attribute))] - -use bytesbuf::mem; - -#[path = "../src/mem/testing/test_block.rs"] -mod test_block; -#[path = "support/system_memory.rs"] -mod testing; - -#[path = "public_api/buf.rs"] -mod buf; -#[path = "public_api/buf_put.rs"] -mod buf_put; -#[path = "public_api/buf_writer.rs"] -mod buf_writer; -#[cfg(feature = "bytes-compat")] -#[path = "public_api/bytes_compat_buf.rs"] -mod bytes_compat_buf; -#[cfg(feature = "bytes-compat")] -#[path = "public_api/bytes_compat_from_bytes.rs"] -mod bytes_compat_from_bytes; -#[cfg(feature = "bytes-compat")] -#[path = "public_api/bytes_compat_to_bytes.rs"] -mod bytes_compat_to_bytes; -#[cfg(feature = "bytes-compat")] -#[path = "public_api/bytes_compat_view.rs"] -mod bytes_compat_view; -#[path = "public_api/mem_block_ref.rs"] -mod mem_block_ref; -#[path = "public_api/mem_callback_memory.rs"] -mod mem_callback_memory; -#[path = "public_api/mem_global.rs"] -mod mem_global; -#[path = "public_api/mem_memory.rs"] -mod mem_memory; -#[path = "public_api/mem_opaque_memory.rs"] -mod mem_opaque_memory; -#[path = "public_api/mem_testing_fixed_block.rs"] -mod mem_testing_fixed_block; -#[path = "public_api/mem_testing_transparent.rs"] -mod mem_testing_transparent; -#[path = "public_api/vec.rs"] -mod vec; -#[path = "public_api/view.rs"] -mod view; -#[path = "public_api/view_get.rs"] -mod view_get; -#[path = "public_api/view_read.rs"] -mod view_read; diff --git a/crates/bytesbuf/tests/support/system_memory.rs b/crates/bytesbuf/tests/support/mod.rs similarity index 100% rename from crates/bytesbuf/tests/support/system_memory.rs rename to crates/bytesbuf/tests/support/mod.rs diff --git a/crates/bytesbuf/tests/views.rs b/crates/bytesbuf/tests/views.rs new file mode 100644 index 0000000000..878cef665a --- /dev/null +++ b/crates/bytesbuf/tests/views.rs @@ -0,0 +1,16 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +//! View construction, reads, ranges, and lifetime handling. + +use bytesbuf::mem; + +// Shared fixture for integration tests and private unit tests. +#[path = "../src/mem/testing/test_block.rs"] +mod test_block; + +mod views { + mod get; + mod read; + mod view; +} diff --git a/crates/bytesbuf/tests/public_api/view_get.rs b/crates/bytesbuf/tests/views/get.rs similarity index 100% rename from crates/bytesbuf/tests/public_api/view_get.rs rename to crates/bytesbuf/tests/views/get.rs diff --git a/crates/bytesbuf/tests/public_api/view_read.rs b/crates/bytesbuf/tests/views/read.rs similarity index 100% rename from crates/bytesbuf/tests/public_api/view_read.rs rename to crates/bytesbuf/tests/views/read.rs diff --git a/crates/bytesbuf/tests/public_api/view.rs b/crates/bytesbuf/tests/views/view.rs similarity index 100% rename from crates/bytesbuf/tests/public_api/view.rs rename to crates/bytesbuf/tests/views/view.rs From e5559ee506caa3e6042b3461c96f4b3b7a992290 Mon Sep 17 00:00:00 2001 From: "Martin Tomka (from Dev Box)" Date: Fri, 13 Nov 2026 16:09:29 +0100 Subject: [PATCH 3/7] test(bytesbuf): preserve no-std integration coverage Initialize compatibility chunks before advancing them and use public memory contracts in core integration fixtures. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- crates/bytesbuf/Cargo.toml | 12 --- crates/bytesbuf/tests/buffers.rs | 3 + crates/bytesbuf/tests/buffers/buf.rs | 73 ++++++++++--------- crates/bytesbuf/tests/buffers/put.rs | 25 ++++--- crates/bytesbuf/tests/buffers/writer.rs | 15 ++-- crates/bytesbuf/tests/conversions.rs | 6 ++ crates/bytesbuf/tests/conversions/buf.rs | 16 ++-- crates/bytesbuf/tests/conversions/to_bytes.rs | 11 +-- crates/bytesbuf/tests/conversions/view.rs | 28 ++++--- crates/bytesbuf/tests/test_memory/mod.rs | 48 ++++++++++++ crates/bytesbuf/tests/views.rs | 3 + crates/bytesbuf/tests/views/get.rs | 41 ++++++----- crates/bytesbuf/tests/views/read.rs | 11 +-- crates/bytesbuf/tests/views/view.rs | 58 +++++++-------- 14 files changed, 207 insertions(+), 143 deletions(-) create mode 100644 crates/bytesbuf/tests/test_memory/mod.rs diff --git a/crates/bytesbuf/Cargo.toml b/crates/bytesbuf/Cargo.toml index 970da318aa..36f6665adf 100644 --- a/crates/bytesbuf/Cargo.toml +++ b/crates/bytesbuf/Cargo.toml @@ -83,18 +83,6 @@ windows-sys = { workspace = true, features = [ "Win32_System_SystemInformation", ] } -[[test]] -name = "buffers" -required-features = ["test-util"] - -[[test]] -name = "views" -required-features = ["test-util"] - -[[test]] -name = "conversions" -required-features = ["test-util"] - [[test]] name = "memory_providers" required-features = ["test-util"] diff --git a/crates/bytesbuf/tests/buffers.rs b/crates/bytesbuf/tests/buffers.rs index e627299645..1a58e2cd85 100644 --- a/crates/bytesbuf/tests/buffers.rs +++ b/crates/bytesbuf/tests/buffers.rs @@ -9,8 +9,11 @@ use bytesbuf::mem; #[path = "../src/mem/testing/test_block.rs"] mod test_block; +mod test_memory; + mod buffers { mod buf; mod put; + #[cfg(feature = "std")] mod writer; } diff --git a/crates/bytesbuf/tests/buffers/buf.rs b/crates/bytesbuf/tests/buffers/buf.rs index 722d2ee595..1b8525257f 100644 --- a/crates/bytesbuf/tests/buffers/buf.rs +++ b/crates/bytesbuf/tests/buffers/buf.rs @@ -8,14 +8,16 @@ use std::mem::MaybeUninit; use std::pin::pin; -use bytesbuf::mem::testing::FixedBlockMemory; -use bytesbuf::mem::{BlockMeta, GlobalPool, Memory}; +#[cfg(feature = "std")] +use bytesbuf::mem::GlobalPool; +use bytesbuf::mem::{BlockMeta, Memory}; use bytesbuf::{BytesBuf, BytesView}; use new_zealand::nz; use static_assertions::assert_impl_all; use testing_aids::assert_panic; use crate::test_block::TestMemoryBlock; +use crate::test_memory::TestMemory; const U64_SIZE: usize = size_of::(); const TWO_U64_SIZE: usize = size_of::() + size_of::(); @@ -33,8 +35,9 @@ fn write_copy_of_slice(dst: &mut [MaybeUninit], src: &[u8]) { // Compile time test fn _can_use_in_dyn_traits(mem: &dyn Memory) { - let buf = mem.reserve(123); - let _ = buf.into_writer(mem); + let _ = mem.reserve(123); + #[cfg(feature = "std")] + let _ = BytesBuf::new().into_writer(mem); } #[cfg(feature = "seismograph")] @@ -61,7 +64,7 @@ fn seismograph_identity_follows_consumed_data() { fn seismograph_recording_state_reports_exact_buffer_shape() { use seismograph_io::Buffer; - let memory = FixedBlockMemory::new(nz!(4)); + let memory = TestMemory::with_block_size(nz!(4)); let mut buffer = memory.reserve(8); buffer.put_slice(*b"abcdef"); @@ -84,7 +87,7 @@ fn seismograph_io_recording_is_gated_and_captures_buffer_state_delta() { let release = SnapshotOptions { event_buffers: EventBufferDisposition::Release, }; - let memory = FixedBlockMemory::new(nz!(4)); + let memory = TestMemory::with_block_size(nz!(4)); let mut buffer = memory.reserve(8); buffer.put_slice(*b"abcdef"); let resource = Resource::new(IoResourceKind::Other); @@ -152,7 +155,7 @@ fn seismograph_io_recording_is_gated_and_captures_buffer_state_delta() { #[test] fn smoke_test() { - let memory = FixedBlockMemory::new(nz!(1234)); + let memory = TestMemory::with_block_size(nz!(1234)); let min_length = 1000; @@ -212,7 +215,7 @@ fn extend_capacity() { assert_eq!(buf.capacity(), 0); assert_eq!(buf.remaining_capacity(), 0); - let memory = FixedBlockMemory::new(nz!(100)); + let memory = TestMemory::with_block_size(nz!(100)); // Have 0, desired 10, requesting 10, will get 100. buf.reserve(10, &memory); @@ -245,7 +248,7 @@ fn extend_capacity() { #[test] fn append_existing_view() { - let memory = FixedBlockMemory::new(nz!(1234)); + let memory = TestMemory::with_block_size(nz!(1234)); let min_length = 1000; @@ -296,7 +299,7 @@ fn append_existing_view() { #[test] fn consume_all_mixed() { let mut buf = BytesBuf::new(); - let memory = FixedBlockMemory::new(nz!(8)); + let memory = TestMemory::with_block_size(nz!(8)); // Reserve some capacity and add initial data. buf.reserve(16, &memory); @@ -334,7 +337,7 @@ fn peek_basic() { assert_eq!(buf.capacity(), 0); assert_eq!(buf.remaining_capacity(), 0); - let memory = FixedBlockMemory::new(nz!(10)); + let memory = TestMemory::with_block_size(nz!(10)); // Peeking an empty buffer is fine, it is just an empty BytesView in that case. let peeked = buf.peek(); @@ -420,7 +423,7 @@ fn consume_part_of_frozen_span() { assert_eq!(buf.capacity(), 0); assert_eq!(buf.remaining_capacity(), 0); - let memory = FixedBlockMemory::new(nz!(10)); + let memory = TestMemory::with_block_size(nz!(10)); buf.reserve(100, &memory); @@ -463,7 +466,7 @@ fn iter_available_empty_with_capacity() { assert_eq!(buf.capacity(), 0); assert_eq!(buf.remaining_capacity(), 0); - let memory = FixedBlockMemory::new(nz!(100)); + let memory = TestMemory::with_block_size(nz!(100)); // Capacity: 0 -> 1000 (10x100) buf.reserve(1000, &memory); @@ -495,7 +498,7 @@ fn iter_available_nonempty() { assert_eq!(buf.capacity(), 0); assert_eq!(buf.remaining_capacity(), 0); - let memory = FixedBlockMemory::new(nz!(8)); + let memory = TestMemory::with_block_size(nz!(8)); // Capacity: 0 -> 16 (2x8) buf.reserve(TWO_U64_SIZE, &memory); @@ -552,7 +555,7 @@ fn vectored_write_zero() { assert_eq!(buf.capacity(), 0); assert_eq!(buf.remaining_capacity(), 0); - let memory = FixedBlockMemory::new(nz!(8)); + let memory = TestMemory::with_block_size(nz!(8)); // Capacity: 0 -> 16 (2x8) buf.reserve(TWO_U64_SIZE, &memory); @@ -578,7 +581,7 @@ fn vectored_write_one_slice() { assert_eq!(buf.capacity(), 0); assert_eq!(buf.remaining_capacity(), 0); - let memory = FixedBlockMemory::new(nz!(8)); + let memory = TestMemory::with_block_size(nz!(8)); // Capacity: 0 -> 8 (1x8) buf.reserve(U64_SIZE, &memory); @@ -614,7 +617,7 @@ fn vectored_write_multiple_slices() { assert_eq!(buf.capacity(), 0); assert_eq!(buf.remaining_capacity(), 0); - let memory = FixedBlockMemory::new(nz!(8)); + let memory = TestMemory::with_block_size(nz!(8)); // Capacity: 0 -> 24 (3x8) buf.reserve(THREE_U64_SIZE, &memory); @@ -679,7 +682,7 @@ fn vectored_write_max_len() { assert_eq!(buf.capacity(), 0); assert_eq!(buf.remaining_capacity(), 0); - let memory = FixedBlockMemory::new(nz!(8)); + let memory = TestMemory::with_block_size(nz!(8)); // Capacity: 0 -> 24 (3x8) buf.reserve(THREE_U64_SIZE, &memory); @@ -740,7 +743,7 @@ fn vectored_write_max_len() { fn vectored_write_max_len_overflow() { let mut buf = BytesBuf::new(); - let memory = FixedBlockMemory::new(nz!(8)); + let memory = TestMemory::with_block_size(nz!(8)); // Capacity: 0 -> 24 (3x8) buf.reserve(THREE_U64_SIZE, &memory); @@ -759,7 +762,7 @@ fn vectored_write_overcommit() { assert_eq!(buf.capacity(), 0); assert_eq!(buf.remaining_capacity(), 0); - let memory = FixedBlockMemory::new(nz!(8)); + let memory = TestMemory::with_block_size(nz!(8)); // Capacity: 0 -> 16 (2x8) buf.reserve(TWO_U64_SIZE, &memory); @@ -784,7 +787,7 @@ fn vectored_write_abort() { assert_eq!(buf.capacity(), 0); assert_eq!(buf.remaining_capacity(), 0); - let memory = FixedBlockMemory::new(nz!(8)); + let memory = TestMemory::with_block_size(nz!(8)); // Capacity: 0 -> 8 (1x8) buf.reserve(U64_SIZE, &memory); @@ -834,7 +837,7 @@ fn peek_empty_builder() { #[test] fn peek_with_frozen_spans_only() { - let memory = FixedBlockMemory::new(nz!(10)); + let memory = TestMemory::with_block_size(nz!(10)); let mut buf = BytesBuf::new(); buf.reserve(20, &memory); @@ -855,7 +858,7 @@ fn peek_with_frozen_spans_only() { #[test] fn peek_with_partially_filled_span_builder() { - let memory = FixedBlockMemory::new(nz!(10)); + let memory = TestMemory::with_block_size(nz!(10)); let mut buf = BytesBuf::new(); buf.reserve(10, &memory); @@ -876,7 +879,7 @@ fn peek_with_partially_filled_span_builder() { #[test] fn peek_preserves_capacity_of_partial_span_builder() { - let memory = FixedBlockMemory::new(nz!(20)); + let memory = TestMemory::with_block_size(nz!(20)); let mut buf = BytesBuf::new(); buf.reserve(20, &memory); @@ -909,7 +912,7 @@ fn peek_preserves_capacity_of_partial_span_builder() { #[test] fn peek_with_mixed_frozen_and_unfrozen() { - let memory = FixedBlockMemory::new(nz!(10)); + let memory = TestMemory::with_block_size(nz!(10)); let mut buf = BytesBuf::new(); buf.reserve(30, &memory); @@ -943,7 +946,7 @@ fn peek_with_mixed_frozen_and_unfrozen() { #[test] fn peek_then_consume() { - let memory = FixedBlockMemory::new(nz!(20)); + let memory = TestMemory::with_block_size(nz!(20)); let mut buf = BytesBuf::new(); buf.reserve(20, &memory); @@ -974,7 +977,7 @@ fn peek_then_consume() { #[test] fn peek_multiple_times() { - let memory = FixedBlockMemory::new(nz!(20)); + let memory = TestMemory::with_block_size(nz!(20)); let mut buf = BytesBuf::new(); buf.reserve(20, &memory); @@ -999,7 +1002,7 @@ fn first_unfilled_slice_meta_no_capacity() { #[test] fn first_unfilled_slice_meta_no_meta() { - let memory = FixedBlockMemory::new(nz!(64)); + let memory = TestMemory::with_block_size(nz!(64)); let buf = memory.reserve(64); assert!(buf.first_unfilled_slice_meta().is_none()); } @@ -1031,7 +1034,7 @@ fn first_unfilled_slice_meta_with_meta() { #[test] fn split_off_remaining_basic() { - let memory = FixedBlockMemory::new(nz!(100)); + let memory = TestMemory::with_block_size(nz!(100)); let mut buf = memory.reserve(100); buf.put_u64_ne(1234); @@ -1051,7 +1054,7 @@ fn split_off_remaining_basic() { #[test] fn split_off_remaining_write_to_split() { - let memory = FixedBlockMemory::new(nz!(100)); + let memory = TestMemory::with_block_size(nz!(100)); let mut buf = memory.reserve(100); buf.put_u64_ne(1111); @@ -1075,7 +1078,7 @@ fn split_off_remaining_write_to_split() { #[test] fn split_off_remaining_all_capacity() { - let memory = FixedBlockMemory::new(nz!(100)); + let memory = TestMemory::with_block_size(nz!(100)); let mut buf = memory.reserve(100); let full_capacity = buf.remaining_capacity(); @@ -1087,7 +1090,7 @@ fn split_off_remaining_all_capacity() { #[test] fn split_off_remaining_zero() { - let memory = FixedBlockMemory::new(nz!(100)); + let memory = TestMemory::with_block_size(nz!(100)); let mut buf = memory.reserve(100); let original_capacity = buf.remaining_capacity(); @@ -1100,7 +1103,7 @@ fn split_off_remaining_zero() { #[test] fn split_off_remaining_multi_block() { - let memory = FixedBlockMemory::new(nz!(10)); + let memory = TestMemory::with_block_size(nz!(10)); // Reserve enough to trigger multiple blocks. let mut buf = memory.reserve(30); @@ -1139,7 +1142,7 @@ fn split_off_remaining_empty_buffer_no_capacity() { #[test] fn split_off_remaining_panics_on_overflow() { - let memory = FixedBlockMemory::new(nz!(100)); + let memory = TestMemory::with_block_size(nz!(100)); let mut buf = memory.reserve(100); let capacity = buf.remaining_capacity(); @@ -1148,7 +1151,7 @@ fn split_off_remaining_panics_on_overflow() { #[test] fn split_off_remaining_checked_returns_none() { - let memory = FixedBlockMemory::new(nz!(100)); + let memory = TestMemory::with_block_size(nz!(100)); let mut buf = memory.reserve(100); let capacity = buf.remaining_capacity(); diff --git a/crates/bytesbuf/tests/buffers/put.rs b/crates/bytesbuf/tests/buffers/put.rs index 5f4f6720ed..bf45504d72 100644 --- a/crates/bytesbuf/tests/buffers/put.rs +++ b/crates/bytesbuf/tests/buffers/put.rs @@ -3,12 +3,13 @@ //! Tests behavior through the public API. -use bytesbuf::mem::testing::TransparentMemory; use bytesbuf::{BytesBuf, BytesView}; +use crate::test_memory::TestMemory; + #[test] fn put_slice() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut buf = memory.reserve(100); let data = [1u8, 2, 3, 4, 5]; @@ -25,7 +26,7 @@ fn put_slice() { #[test] fn put_slice_empty() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut buf = memory.reserve(100); buf.put_slice([]); @@ -36,7 +37,7 @@ fn put_slice_empty() { #[test] fn put_view_single_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut buf = memory.reserve(100); let data = [10_u8, 20, 30, 40, 50]; @@ -56,7 +57,7 @@ fn put_view_single_span() { #[test] fn put_view_multi_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut buf = memory.reserve(100); let data_part1 = [10_u8, 20]; @@ -79,7 +80,7 @@ fn put_view_multi_span() { #[test] fn put_view_empty() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut buf = memory.reserve(100); let view = BytesView::new(); @@ -92,7 +93,7 @@ fn put_view_empty() { #[test] fn put_view_peeked_from_self() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut buf = memory.reserve(100); let data = [1u8, 2, 3, 4, 5]; @@ -115,7 +116,7 @@ fn put_view_peeked_from_self() { #[test] fn put_byte() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut buf = memory.reserve(10); buf.put_byte(0xAB); @@ -132,7 +133,7 @@ fn put_byte() { #[test] fn put_bytes() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut buf = memory.reserve(10); buf.put_byte_repeated(0xFF, 5); @@ -148,7 +149,7 @@ fn put_bytes() { #[test] fn put_bytes_into_multi_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut buf = BytesBuf::new(); // Result: 5 @@ -169,7 +170,7 @@ fn put_bytes_into_multi_span() { #[test] fn put_num() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut buf = memory.reserve(16); buf.put_u32_le(0x1234_5678); @@ -206,7 +207,7 @@ fn put_num() { #[test] fn put_num_signed_and_float_round_trip() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut buf = memory.reserve(64); buf.put_i16_le(-12345); diff --git a/crates/bytesbuf/tests/buffers/writer.rs b/crates/bytesbuf/tests/buffers/writer.rs index 71bb4d01fe..0b6542d748 100644 --- a/crates/bytesbuf/tests/buffers/writer.rs +++ b/crates/bytesbuf/tests/buffers/writer.rs @@ -6,14 +6,15 @@ use std::io::Write; use bytesbuf::BytesBuf; -use bytesbuf::mem::testing::{FixedBlockMemory, TransparentMemory}; use new_zealand::nz; +use crate::test_memory::TestMemory; + #[test] fn smoke_test_write_and_verify_data() { let test_data = b"Hello, world! This is a test."; - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let builder = memory.reserve(100); let mut write_adapter = builder.into_writer(&memory); @@ -31,7 +32,7 @@ fn smoke_test_write_and_verify_data() { #[test] fn existing_content_is_preserved() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut builder = memory.reserve(100); // Add some initial content to the builder @@ -55,7 +56,7 @@ fn existing_content_is_preserved() { fn sufficient_capacity_not_extended() { let test_data = b"Small data"; // Much smaller than 100 bytes - let memory = FixedBlockMemory::new(nz!(1024)); + let memory = TestMemory::with_block_size(nz!(1024)); let builder = memory.reserve(100); let initial_capacity = builder.capacity(); @@ -79,7 +80,7 @@ fn sufficient_capacity_not_extended() { #[test] fn empty_buffer_small_write_reserves_initial_size() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let buf = BytesBuf::new(); assert_eq!(buf.capacity(), 0); @@ -92,7 +93,7 @@ fn empty_buffer_small_write_reserves_initial_size() { #[test] fn empty_buffer_large_write_reserves_growth_size() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let buf = BytesBuf::new(); let payload = vec![0u8; 4096 + 1]; @@ -106,7 +107,7 @@ fn empty_buffer_large_write_reserves_growth_size() { #[test] fn non_empty_buffer_reserves_growth_size() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut buf = memory.reserve(16); buf.put_slice([1; 16]); assert_eq!(buf.remaining_capacity(), 0); diff --git a/crates/bytesbuf/tests/conversions.rs b/crates/bytesbuf/tests/conversions.rs index fb30a13d7d..96c225beaa 100644 --- a/crates/bytesbuf/tests/conversions.rs +++ b/crates/bytesbuf/tests/conversions.rs @@ -5,8 +5,14 @@ #![cfg_attr(coverage_nightly, feature(coverage_attribute))] +#[cfg(feature = "bytes-compat")] +use bytesbuf::mem; + mod support; +#[cfg(feature = "bytes-compat")] +mod test_memory; + mod conversions { #[cfg(feature = "bytes-compat")] mod buf; diff --git a/crates/bytesbuf/tests/conversions/buf.rs b/crates/bytesbuf/tests/conversions/buf.rs index 7c310f953b..b7b5afdb06 100644 --- a/crates/bytesbuf/tests/conversions/buf.rs +++ b/crates/bytesbuf/tests/conversions/buf.rs @@ -4,11 +4,12 @@ //! Tests behavior through the public API. use bytes::BufMut; -use bytesbuf::mem::testing::TransparentMemory; + +use crate::test_memory::TestMemory; #[test] fn buf_mut_compat() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut buf = memory.reserve(100); assert_eq!(BufMut::remaining_mut(&buf), 100); @@ -20,26 +21,27 @@ fn buf_mut_compat() { let chunk = BufMut::chunk_mut(&mut buf); assert_eq!(chunk.len(), 100); + chunk.copy_from_slice(&[0; 100]); - // SAFETY: Lies - we did not write anything. But we will also - // not touch the data - we are only inspecting the bookkeeping. - // Good enough for test code. + // SAFETY: The first 50 bytes of this chunk were initialized above. unsafe { BufMut::advance_mut(&mut buf, 50); } let chunk = BufMut::chunk_mut(&mut buf); assert_eq!(chunk.len(), 50); + chunk.copy_from_slice(&[0; 50]); - // SAFETY: See above. + // SAFETY: All 50 bytes of this chunk were initialized above. unsafe { BufMut::advance_mut(&mut buf, 50); } let chunk = BufMut::chunk_mut(&mut buf); assert_eq!(chunk.len(), 100); + chunk.copy_from_slice(&[0; 100]); - // SAFETY: See above. + // SAFETY: All 100 bytes of this chunk were initialized above. unsafe { BufMut::advance_mut(&mut buf, 100); } diff --git a/crates/bytesbuf/tests/conversions/to_bytes.rs b/crates/bytesbuf/tests/conversions/to_bytes.rs index 88886a3c25..bb22de22fd 100644 --- a/crates/bytesbuf/tests/conversions/to_bytes.rs +++ b/crates/bytesbuf/tests/conversions/to_bytes.rs @@ -5,11 +5,12 @@ use bytes::{Buf, Bytes}; use bytesbuf::BytesView; -use bytesbuf::mem::testing::TransparentMemory; + +use crate::test_memory::TestMemory; #[test] fn view_to_bytes() { - let mut builder = TransparentMemory::new().reserve(100); + let mut builder = TestMemory::new().reserve(100); builder.put_slice(1234_u64.to_ne_bytes()); builder.put_slice(5678_u64.to_ne_bytes()); @@ -43,7 +44,7 @@ fn empty_view_to_bytes() { #[test] fn into_bytes() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let view = BytesView::copied_from_slice(b"Hello, world!", &memory); let bytes: Bytes = view.into(); @@ -53,7 +54,7 @@ fn into_bytes() { #[test] fn test_view_to_bytes() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let view = BytesView::copied_from_slice(b"Hello, world!", &memory); @@ -69,7 +70,7 @@ fn test_view_to_bytes() { #[test] fn test_multi_block_view_to_bytes() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let hello = BytesView::copied_from_slice(b"Hello, ", &memory); let world = BytesView::copied_from_slice(b"world!", &memory); diff --git a/crates/bytesbuf/tests/conversions/view.rs b/crates/bytesbuf/tests/conversions/view.rs index 31b19f90d7..f39c8edaa6 100644 --- a/crates/bytesbuf/tests/conversions/view.rs +++ b/crates/bytesbuf/tests/conversions/view.rs @@ -3,15 +3,17 @@ //! Tests behavior through the public API. +#[cfg(feature = "std")] use std::io::IoSlice; use bytes::Buf; -use bytesbuf::mem::testing::FixedBlockMemory; use new_zealand::nz; +use crate::test_memory::TestMemory; + #[test] fn buf_compat() { - let memory = FixedBlockMemory::new(nz!(25)); + let memory = TestMemory::with_block_size(nz!(25)); // 25 x 4 let mut buf = memory.reserve(100); @@ -39,21 +41,25 @@ fn buf_compat() { Buf::advance(&mut bytes, 5); - let mut io_slices = [IoSlice::new(&[]); 4]; - let n = Buf::chunks_vectored(&bytes, &mut io_slices); + #[cfg(feature = "std")] + { + let mut io_slices = [IoSlice::new(&[]); 4]; + let n = Buf::chunks_vectored(&bytes, &mut io_slices); - // We have already advanced past the first 30 bytes - // but the remaining 70 should still be here for us as 20 + 25 + 25. - assert_eq!(n, 3); + // We have already advanced past the first 30 bytes + // but the remaining 70 should still be here for us as 20 + 25 + 25. + assert_eq!(n, 3); - assert_eq!(&*io_slices[0], &[0x44; 20]); - assert_eq!(&*io_slices[1], &[0x44; 25]); - assert_eq!(&*io_slices[2], &[0x44; 25]); + assert_eq!(&*io_slices[0], &[0x44; 20]); + assert_eq!(&*io_slices[1], &[0x44; 25]); + assert_eq!(&*io_slices[2], &[0x44; 25]); + } } +#[cfg(feature = "std")] #[test] fn chunks_vectored_empty_dst() { - let memory = FixedBlockMemory::new(nz!(25)); + let memory = TestMemory::with_block_size(nz!(25)); let mut buf = memory.reserve(25); buf.put_byte_repeated(0x44, 25); diff --git a/crates/bytesbuf/tests/test_memory/mod.rs b/crates/bytesbuf/tests/test_memory/mod.rs new file mode 100644 index 0000000000..884efb6305 --- /dev/null +++ b/crates/bytesbuf/tests/test_memory/mod.rs @@ -0,0 +1,48 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +use std::num::NonZero; + +use bytesbuf::BytesBuf; +use bytesbuf::mem::{BlockSize, Memory}; + +// Reuse the allocation fixture through the public Block and BlockRef APIs. +#[path = "../../src/mem/testing/std_alloc_block.rs"] +mod std_alloc_block; + +/// Controls block sizes without enabling the library's `std` feature. +#[derive(Debug, Default)] +pub(crate) struct TestMemory { + block_size: Option>, +} + +impl TestMemory { + pub(crate) fn new() -> Self { + Self::default() + } + + pub(crate) const fn with_block_size(block_size: NonZero) -> Self { + Self { + block_size: Some(block_size), + } + } + + pub(crate) fn reserve(&self, min_bytes: usize) -> BytesBuf { + let mut remaining = min_bytes; + let blocks = std::iter::from_fn(|| { + NonZero::new(remaining)?; + let len = self + .block_size + .map_or_else(|| remaining.min(BlockSize::MAX as usize), |size| size.get() as usize); + remaining = remaining.saturating_sub(len); + Some(std_alloc_block::allocate(NonZero::new(BlockSize::try_from(len).unwrap()).unwrap())) + }); + BytesBuf::from_blocks(blocks) + } +} + +impl Memory for TestMemory { + fn reserve(&self, min_bytes: usize) -> BytesBuf { + self.reserve(min_bytes) + } +} diff --git a/crates/bytesbuf/tests/views.rs b/crates/bytesbuf/tests/views.rs index 878cef665a..ec549572e0 100644 --- a/crates/bytesbuf/tests/views.rs +++ b/crates/bytesbuf/tests/views.rs @@ -9,8 +9,11 @@ use bytesbuf::mem; #[path = "../src/mem/testing/test_block.rs"] mod test_block; +mod test_memory; + mod views { mod get; + #[cfg(feature = "std")] mod read; mod view; } diff --git a/crates/bytesbuf/tests/views/get.rs b/crates/bytesbuf/tests/views/get.rs index e99f0e2c65..78eb2747e6 100644 --- a/crates/bytesbuf/tests/views/get.rs +++ b/crates/bytesbuf/tests/views/get.rs @@ -6,11 +6,12 @@ use std::mem::MaybeUninit; use bytesbuf::BytesView; -use bytesbuf::mem::testing::TransparentMemory; + +use crate::test_memory::TestMemory; #[test] fn get_byte() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); assert_eq!(view.get_byte(), 1); @@ -22,7 +23,7 @@ fn get_byte() { #[test] fn copy_to_slice() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); let mut dst = [0u8; 4]; @@ -34,7 +35,7 @@ fn copy_to_slice() { #[test] fn copy_to_smaller_slice_copies_partially() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); let mut dst = [0u8; 3]; @@ -47,7 +48,7 @@ fn copy_to_smaller_slice_copies_partially() { #[test] #[should_panic] fn copy_to_bigger_slice_panics() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); let mut dst = [0u8; 8]; @@ -56,7 +57,7 @@ fn copy_to_bigger_slice_panics() { #[test] fn copy_to_uninit_slice() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); let mut dst = MaybeUninit::<[u8; 4]>::uninit(); @@ -71,7 +72,7 @@ fn copy_to_uninit_slice() { #[test] fn copy_to_uninit_smaller_slice_copies_partially() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); let mut dst = MaybeUninit::<[u8; 3]>::uninit(); @@ -87,7 +88,7 @@ fn copy_to_uninit_smaller_slice_copies_partially() { #[test] #[should_panic] fn copy_to_uninit_bigger_slice_panics() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(&[1, 2, 3, 4], &memory); let mut dst = [MaybeUninit::::uninit(); 8]; @@ -96,7 +97,7 @@ fn copy_to_uninit_bigger_slice_panics() { #[test] fn copy_to_slice_multi_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let data_part1 = [10_u8, 20]; let data_part2 = [30_u8, 40, 50]; let view_part1 = BytesView::copied_from_slice(&data_part1, &memory); @@ -112,7 +113,7 @@ fn copy_to_slice_multi_span() { #[test] fn copy_to_uninit_slice_multi_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let data_part1 = [10_u8, 20]; let data_part2 = [30_u8, 40, 50]; let view_part1 = BytesView::copied_from_slice(&data_part1, &memory); @@ -131,7 +132,7 @@ fn copy_to_uninit_slice_multi_span() { #[test] fn get_u16_le() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(&[0x34, 0x12, 0x78, 0x56], &memory); assert_eq!(view.get_u16_le(), 0x1234); @@ -142,7 +143,7 @@ fn get_u16_le() { #[test] fn get_u32_le_multi_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let view_part1 = BytesView::copied_from_slice(&[0x78_u8, 0x56], &memory); let view_part2 = BytesView::copied_from_slice(&[0x34_u8, 0x12], &memory); let mut view_combined = BytesView::from_views([view_part1, view_part2]); @@ -154,7 +155,7 @@ fn get_u32_le_multi_span() { #[test] fn get_u16_be() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(&[0x12, 0x34, 0x56, 0x78], &memory); assert_eq!(view.get_u16_be(), 0x1234); @@ -165,7 +166,7 @@ fn get_u16_be() { #[test] fn get_u32_be_multi_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let view_part1 = BytesView::copied_from_slice(&[0x12_u8, 0x34], &memory); let view_part2 = BytesView::copied_from_slice(&[0x56_u8, 0x78], &memory); let mut view_combined = BytesView::from_views([view_part1, view_part2]); @@ -177,7 +178,7 @@ fn get_u32_be_multi_span() { #[test] fn get_u16_ne() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(&[0x34, 0x12, 0x78, 0x56], &memory); if cfg!(target_endian = "big") { @@ -193,7 +194,7 @@ fn get_u16_ne() { #[test] fn get_u32_ne_multi_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let view_part1 = BytesView::copied_from_slice(&[0x78_u8, 0x56], &memory); let view_part2 = BytesView::copied_from_slice(&[0x34_u8, 0x12], &memory); let mut view_combined = BytesView::from_views([view_part1, view_part2]); @@ -209,7 +210,7 @@ fn get_u32_ne_multi_span() { #[test] fn get_signed_and_float_round_trip() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut data = Vec::new(); data.extend_from_slice(&(-12345_i16).to_le_bytes()); @@ -232,7 +233,7 @@ fn get_signed_and_float_round_trip() { #[test] fn get_wide_value_multi_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let value: u128 = 0x0123_4567_89AB_CDEF_FEDC_BA98_7654_3210; let bytes = value.to_le_bytes(); @@ -247,7 +248,7 @@ fn get_wide_value_multi_span() { #[test] fn get_misaligned_single_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); // Drop a single leading byte so the eight value bytes sit at an odd offset from the // allocation base, exercising the fast path against a misaligned source. @@ -264,7 +265,7 @@ fn get_misaligned_single_span() { #[test] #[should_panic] fn get_num_insufficient_bytes_panics() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(&[0x00, 0x01, 0x02], &memory); // Only three bytes are available, so reading a four-byte value must panic. diff --git a/crates/bytesbuf/tests/views/read.rs b/crates/bytesbuf/tests/views/read.rs index 40e0fc4a15..c963dd692a 100644 --- a/crates/bytesbuf/tests/views/read.rs +++ b/crates/bytesbuf/tests/views/read.rs @@ -6,11 +6,12 @@ use std::io::{BufRead, Read}; use bytesbuf::BytesView; -use bytesbuf::mem::testing::TransparentMemory; + +use crate::test_memory::TestMemory; #[test] fn smoke_test() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(b"Hello, world", &memory); let mut buffer = [0u8; 5]; @@ -36,7 +37,7 @@ fn smoke_test() { #[test] fn buf_read_fill_buf_and_consume() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(b"Hello, world", &memory); // fill_buf returns the first contiguous slice without consuming it. @@ -60,7 +61,7 @@ fn buf_read_fill_buf_and_consume() { #[test] fn buf_read_read_line() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(b"first\nsecond\n", &memory); let mut line = String::new(); @@ -81,7 +82,7 @@ fn buf_read_read_line() { #[test] fn buf_read_on_empty_view() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view = BytesView::copied_from_slice(b"", &memory); let buf = view.fill_buf().unwrap(); diff --git a/crates/bytesbuf/tests/views/view.rs b/crates/bytesbuf/tests/views/view.rs index f94305fea7..8b424fa44b 100644 --- a/crates/bytesbuf/tests/views/view.rs +++ b/crates/bytesbuf/tests/views/view.rs @@ -16,13 +16,13 @@ use std::pin::pin; use std::thread; use bytesbuf::mem::BlockMeta; -use bytesbuf::mem::testing::{FixedBlockMemory, TransparentMemory}; use bytesbuf::{BytesBuf, BytesView}; use new_zealand::nz; use static_assertions::{assert_impl_all, assert_not_impl_any}; use testing_aids::assert_panic; use crate::test_block::TestMemoryBlock; +use crate::test_memory::TestMemory; assert_impl_all!(BytesView: Send, Sync, Eq); assert_not_impl_any!(BytesView: From<&'static [u8]>); @@ -69,7 +69,7 @@ impl Hasher for RecordingHasher { #[test] fn smoke_test() { - let mut span_builder = TransparentMemory::new().reserve(10); + let mut span_builder = TestMemory::new().reserve(10); span_builder.put_slice(1234_u64.to_ne_bytes()); span_builder.put_slice(16_u16.to_ne_bytes()); @@ -107,7 +107,7 @@ fn smoke_test() { #[test] fn oob_is_panic() { - let mut span_builder = TransparentMemory::new().reserve(10); + let mut span_builder = TestMemory::new().reserve(10); span_builder.put_slice(1234_u64.to_ne_bytes()); span_builder.put_slice(16_u16.to_ne_bytes()); @@ -170,7 +170,7 @@ fn extend_lifetime_references_all_blocks() { #[test] fn from_views() { - let mut span_builder = TransparentMemory::new().reserve(100); + let mut span_builder = TestMemory::new().reserve(100); span_builder.put_slice(1234_u64.to_ne_bytes()); span_builder.put_slice(5678_u64.to_ne_bytes()); @@ -201,7 +201,7 @@ fn empty_view() { #[test] fn slice_from_single_span_view() { // A very simple view to start with, consisting of just one 100 byte span. - let span_builder = TransparentMemory::new().reserve(100); + let span_builder = TestMemory::new().reserve(100); let mut buf = span_builder; @@ -235,7 +235,7 @@ fn slice_from_single_span_view() { #[test] fn slice_from_multi_span_view() { - let memory = FixedBlockMemory::new(nz!(10)); + let memory = TestMemory::with_block_size(nz!(10)); let mut buf = memory.reserve(100); for i in 0..100 { @@ -270,7 +270,7 @@ fn slice_from_multi_span_view() { #[test] fn slice_indexing_kinds() { - let span_builder = TransparentMemory::new().reserve(10); + let span_builder = TestMemory::new().reserve(10); let mut buf = span_builder; buf.put_byte(0); @@ -314,7 +314,7 @@ fn slice_indexing_kinds() { #[test] fn slice_checked_with_excluded_start_bound() { - let span_builder = TransparentMemory::new().reserve(100); + let span_builder = TestMemory::new().reserve(100); let mut buf = span_builder; buf.put_byte(0); @@ -351,7 +351,7 @@ fn slice_checked_with_excluded_start_bound() { #[test] fn slice_oob_is_panic() { - let span_builder = TransparentMemory::new().reserve(1000); + let span_builder = TestMemory::new().reserve(1000); let mut buf = span_builder; buf.put_byte_repeated(0, 100); @@ -369,7 +369,7 @@ fn slice_oob_is_panic() { #[test] fn slice_at_boundary_is_not_panic() { - let span_builder = TransparentMemory::new().reserve(100); + let span_builder = TestMemory::new().reserve(100); let mut buf = span_builder; buf.put_byte_repeated(0, 100); @@ -389,7 +389,7 @@ fn slice_at_boundary_is_not_panic() { #[test] fn slice_empty_is_empty_if_not_oob() { - let span_builder = TransparentMemory::new().reserve(100); + let span_builder = TestMemory::new().reserve(100); let mut buf = span_builder; @@ -410,7 +410,7 @@ fn slice_empty_is_empty_if_not_oob() { #[test] fn consume_all_slices() { - let memory = FixedBlockMemory::new(nz!(10)); + let memory = TestMemory::with_block_size(nz!(10)); let mut buf = memory.reserve(100); for i in 0..100 { @@ -453,7 +453,7 @@ fn multithreaded_usage() { .unwrap(); } - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let view = BytesView::copied_from_slice(b"Hello, world!", &memory); post_to_another_thread(view); @@ -461,7 +461,7 @@ fn multithreaded_usage() { #[test] fn slices_iterator() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let segment1 = BytesView::copied_from_slice(b"Hello, world!", &memory); let segment2 = BytesView::copied_from_slice(b"Hello, another world!", &memory); @@ -482,7 +482,7 @@ fn slices_iterator_empty() { #[test] fn to_vec_single_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let view = BytesView::copied_from_slice(b"Hello, world!", &memory); let bytes = view.to_vec(); @@ -494,7 +494,7 @@ fn to_vec_single_span() { #[test] fn to_vec_multi_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let segment1 = BytesView::copied_from_slice(b"Hello, ", &memory); let segment2 = BytesView::copied_from_slice(b"world!", &memory); @@ -516,7 +516,7 @@ fn to_vec_empty() { #[test] fn eq_view() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let view1 = BytesView::copied_from_slice(b"Hello, world!", &memory); let view2 = BytesView::copied_from_slice(b"Hello, world!", &memory); @@ -555,7 +555,7 @@ fn eq_view() { #[test] fn eq_slice() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let view1 = BytesView::copied_from_slice(b"Hello, world!", &memory); @@ -584,7 +584,7 @@ fn eq_slice() { #[test] fn eq_array() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let view1 = BytesView::copied_from_slice(b"Hello, world!", &memory); @@ -619,9 +619,9 @@ fn first_slice_meta_empty_view() { #[test] fn first_slice_meta_no_metadata() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let view = BytesView::copied_from_slice(b"Hello", &memory); - // TransparentMemory does not attach metadata. + // TestMemory does not attach metadata. assert!(view.first_slice_meta().is_none()); } @@ -650,7 +650,7 @@ fn first_slice_meta_with_metadata() { #[test] fn meta_none() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let view1 = BytesView::copied_from_slice(b"Hello, ", &memory); let view2 = BytesView::copied_from_slice(b"world!", &memory); @@ -726,7 +726,7 @@ fn meta_some() { #[test] fn append_single_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); // Create two single-span views. let mut view1 = BytesView::copied_from_slice(b"Hello, ", &memory); @@ -743,7 +743,7 @@ fn append_single_span() { #[test] fn append_multi_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); // Create two multi-span views (2 spans each) let view1_part1 = BytesView::copied_from_slice(b"AAA", &memory); @@ -765,7 +765,7 @@ fn append_multi_span() { #[test] fn append_empty_view() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut view1 = BytesView::copied_from_slice(b"Hello", &memory); let view2 = BytesView::new(); @@ -786,7 +786,7 @@ fn append_empty_view() { #[test] fn append_preserves_identity_when_only_one_view_has_data() { use seismograph_io::Buffer; - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let mut populated = BytesView::copied_from_slice(b"Hello", &memory); let populated_id = populated.recording_state().id(); populated.append(BytesView::new()); @@ -804,7 +804,7 @@ fn append_preserves_identity_when_only_one_view_has_data() { #[test] fn concat_single_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); // Create two single-span views let view1 = BytesView::copied_from_slice(b"Hello, ", &memory); @@ -826,7 +826,7 @@ fn concat_single_span() { #[test] fn concat_multi_span() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); // Create two multi-span views (2 spans each) let view1_part1 = BytesView::copied_from_slice(b"AAA", &memory); @@ -853,7 +853,7 @@ fn concat_multi_span() { #[test] fn concat_empty_views() { - let memory = TransparentMemory::new(); + let memory = TestMemory::new(); let view1 = BytesView::copied_from_slice(b"Hello", &memory); let view2 = BytesView::new(); From 079b1e73947309e01495f07de1a400e1723d23d4 Mon Sep 17 00:00:00 2001 From: "Martin Tomka (from Dev Box)" Date: Fri, 13 Nov 2026 16:17:33 +0100 Subject: [PATCH 4/7] test(arty_macros_impl): assert complete expansion output Preserve all migrated cases and compare full expected tokens. Exercise both macros for worker literals and malformed inputs. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- crates/arty_macros_impl/tests/expansion.rs | 175 +++++++++++++++------ 1 file changed, 123 insertions(+), 52 deletions(-) diff --git a/crates/arty_macros_impl/tests/expansion.rs b/crates/arty_macros_impl/tests/expansion.rs index d78e6345d0..bf4a87ab5d 100644 --- a/crates/arty_macros_impl/tests/expansion.rs +++ b/crates/arty_macros_impl/tests/expansion.rs @@ -406,13 +406,46 @@ fn worker_literals_are_not_limited_to_the_macro_hosts_pointer_width() { quote!(340282366920938463463374607431768211456), TokenStream::from(forwarded), ] { - let expansion = main( - quote!(workers = #workers), - quote! { - async fn run(cx: Context) {} - }, - ); - assert!(!expansion.to_string().contains("compile_error")); + let input = quote! { + async fn run(cx: Context) {} + }; + let expansion = main(quote!(workers = #workers), input.clone()); + let expected = quote! { + fn run() { + let __arty_runtime = ::arty::runtime::Runtime::builder() + .workers(::arty::runtime::WorkersPolicy::exactly(#workers)) + .build() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |cx: Context| {}); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + }; + assert_eq!(expansion.to_string(), expected.to_string(), "workers = {workers}"); + + let expansion = test(quote!(workers = #workers), input); + let expected = quote! { + #[::core::prelude::v1::test] + fn run() { + let __arty_runtime = ::arty::runtime::Runtime::builder() + .workers(::arty::runtime::WorkersPolicy::exactly(#workers)) + .monitor(::arty::runtime::MonitorPolicy::disabled()) + .build() + .expect("failed to create the runtime for the entry point"); + let __arty_result = __arty_runtime + .scheduler() + .block_on(async move |cx: Context| {}); + let __arty_shutdown = __arty_runtime.stop(); + __arty_result + .and_then(|__arty_value| __arty_shutdown.map(|()| __arty_value)) + .unwrap_or_else(|error| ::arty::runtime::__private::resume_error(error)) + } + }; + assert_eq!(expansion.to_string(), expected.to_string(), "workers = {workers}"); } } @@ -453,6 +486,14 @@ fn worker_policy_unwraps_nested_expression_groups() { #[test] fn invalid_worker_counts_report_errors() { + let input = quote! { + async fn run(cx: Context) {} + }; + let message = "`workers` must be a nonnegative integer literal, optionally suffixed with `usize`, or `all`; use explicit runtime construction for expressions or other processor policies"; + let expected = quote! { + #input + ::core::compile_error! { #message } + }; for workers in [ quote!(-0), quote!(-1), @@ -475,15 +516,8 @@ fn invalid_worker_counts_report_errors() { quote!(WorkersPolicy::all()), ] { for expand in [main, test] { - let expansion = expand( - quote!(workers = #workers), - quote! { - async fn run(cx: Context) {} - }, - ) - .to_string(); - assert!(expansion.contains("compile_error"), "workers = {workers}: {expansion}"); - assert!(expansion.contains("nonnegative integer literal"), "{expansion}"); + let expansion = expand(quote!(workers = #workers), input.clone()); + assert_eq!(expansion.to_string(), expected.to_string(), "workers = {workers}"); } } } @@ -575,7 +609,17 @@ fn duplicate_panic_settings_report_errors() { #[test] fn removed_configuration_options_are_rejected() { - for args in [quote!(builder = configure()), quote!(runtime_path = ::renamed)] { + for (args, message) in [ + ( + quote!(builder = configure()), + "Unknown field: `builder`. Available values: `monitor`, `panic`, `workers`", + ), + ( + quote!(runtime_path = ::renamed), + "Unknown field: `runtime_path`. Available values: `monitor`, `panic`, `workers`", + ), + ] { + let expected = quote!(::core::compile_error! { #message }); for expand in [main, test] { let expansion = expand( args.clone(), @@ -584,45 +628,63 @@ fn removed_configuration_options_are_rejected() { }, ) .to_string(); - assert!(expansion.contains("compile_error"), "{expansion}"); - assert!(expansion.contains("Unknown field"), "{expansion}"); + assert_eq!(expansion, expected.to_string(), "args = {args}"); } } } #[test] fn injected_clock_requires_a_named_owned_second_test_parameter() { - for input in [ - quote!( - async fn run(cx: Context, _: ClockControl) {} + for (input, test_message) in [ + ( + quote!( + async fn run(cx: Context, _: ClockControl) {} + ), + "argument must have an identifier", ), - quote!( - async fn run(cx: Context, control: &ClockControl) {} + ( + quote!( + async fn run(cx: Context, control: &ClockControl) {} + ), + "unexpected arguments", ), - quote!( - async fn run(cx: Context, control: ClockControl, extra: ClockControl) {} + ( + quote!( + async fn run(cx: Context, control: ClockControl, extra: ClockControl) {} + ), + "unexpected arguments", ), - quote!( - async fn run(cx: Context, cx: ClockControl) {} + ( + quote!( + async fn run(cx: Context, cx: ClockControl) {} + ), + "arguments must have distinct identifiers", ), - quote!( - async fn run(cx: Context, r#cx: ClockControl) {} + ( + quote!( + async fn run(cx: Context, r#cx: ClockControl) {} + ), + "arguments must have distinct identifiers", ), ] { - for expand in [main, test] { - let expansion = expand(TokenStream::new(), input.clone()).to_string(); - assert!(expansion.starts_with(&input.to_string())); - assert!(expansion.contains("compile_error"), "{expansion}"); + for (expand, message) in [main, test].into_iter().zip(["unexpected arguments", test_message]) { + let expansion = expand(TokenStream::new(), input.clone()); + let expected = quote! { + #input + ::core::compile_error! { #message } + }; + assert_eq!(expansion.to_string(), expected.to_string(), "input = {input}"); } } - let expansion = main( - TokenStream::new(), - quote!( - async fn run(cx: Context, control: ClockControl) {} - ), - ) - .to_string(); - assert!(expansion.contains("unexpected arguments")); + let input = quote!( + async fn run(cx: Context, control: ClockControl) {} + ); + let expansion = main(TokenStream::new(), input.clone()); + let expected = quote! { + #input + ::core::compile_error! { "unexpected arguments" } + }; + assert_eq!(expansion.to_string(), expected.to_string()); } #[test] @@ -632,13 +694,13 @@ fn invalid_signatures_preserve_input_and_report_errors() { quote!( fn run(cx: Context) {} ), - "function must be async", + "function must be async to use the attribute", ), ( quote!( async fn run() {} ), - "function must take an Arty task context argument", + "function must take an Arty task context argument, such as cx: arty::task::Context", ), ( quote!( @@ -650,7 +712,7 @@ fn invalid_signatures_preserve_input_and_report_errors() { quote!( async fn run(cx: &Context) {} ), - "arty::task::Context by value", + "the first parameter must take arty::task::Context by value, such as cx: arty::task::Context", ), ( quote!( @@ -660,38 +722,47 @@ fn invalid_signatures_preserve_input_and_report_errors() { ), ]; for (input, message) in cases { + let expected = quote! { + #input + ::core::compile_error! { #message } + }; for expand in [main, test] { - let expansion = expand(TokenStream::new(), input.clone()).to_string(); - assert!(expansion.starts_with(&input.to_string())); - assert!(expansion.contains(message), "{expansion}"); - assert!(expansion.contains("compile_error")); + let expansion = expand(TokenStream::new(), input.clone()); + assert_eq!(expansion.to_string(), expected.to_string(), "input = {input}"); } } } #[test] fn malformed_items_and_arguments_report_errors() { - for (args, input) in [ - (TokenStream::new(), quote!(not a function)), + for (args, input, message) in [ + (TokenStream::new(), quote!(not a function), "expected `fn`"), ( quote!(@), quote!( async fn run(cx: Context) {} ), + "expected identifier or literal", ), ( quote!(unknown = 1), quote!( async fn run(cx: Context) {} ), + "Unknown field: `unknown`. Available values: `monitor`, `panic`, `workers`", ), ( quote!(workers = 1, workers = 2), quote!( async fn run(cx: Context) {} ), + "Duplicate field `workers`", ), ] { - assert!(main(args, input).to_string().contains("compile_error")); + let expected = quote!(::core::compile_error! { #message }); + for expand in [main, test] { + let expansion = expand(args.clone(), input.clone()); + assert_eq!(expansion.to_string(), expected.to_string(), "args = {args}, input = {input}"); + } } } From 1e649cf4dfd024e57c10c8e41a1bad10f31e755e Mon Sep 17 00:00:00 2001 From: "Martin Tomka (from Dev Box)" Date: Fri, 13 Nov 2026 16:52:02 +0100 Subject: [PATCH 5/7] test(bytesbuf): mark shared block fixture as test-only Declare the fixture's existing test-only scope in the file so released-surface coverage filtering can classify it across module paths. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- crates/bytesbuf/src/mem/testing/test_block.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/bytesbuf/src/mem/testing/test_block.rs b/crates/bytesbuf/src/mem/testing/test_block.rs index 3c084e25f9..31e32407ca 100644 --- a/crates/bytesbuf/src/mem/testing/test_block.rs +++ b/crates/bytesbuf/src/mem/testing/test_block.rs @@ -1,6 +1,9 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +// Make the shared fixture's test-only scope explicit for coverage filtering. +#![cfg(test)] + use std::alloc::{Layout, alloc, dealloc}; use std::mem::MaybeUninit; use std::num::NonZero; From 9d32f29be6ebf684b47e82fcff2b1a815aaacc22 Mon Sep 17 00:00:00 2001 From: "Martin Tomka (from Dev Box)" Date: Fri, 13 Nov 2026 17:37:26 +0100 Subject: [PATCH 6/7] test(arty_io_host): mark context integration target as test-only Keep helper unwraps inside their existing test-only scope so Clippy applies the repository's test policy. Preserve both discovered cases and all assertions. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- crates/arty_io_host/tests/context_reentrancy.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/crates/arty_io_host/tests/context_reentrancy.rs b/crates/arty_io_host/tests/context_reentrancy.rs index 48b2440e54..d23745c73e 100644 --- a/crates/arty_io_host/tests/context_reentrancy.rs +++ b/crates/arty_io_host/tests/context_reentrancy.rs @@ -1,6 +1,8 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +#![cfg(test)] + //! Context retrieval during provider callbacks. use std::cell::RefCell; From 921ac49293e878eea15548fc1699c7fe03e8d1f9 Mon Sep 17 00:00:00 2001 From: "Martin Tomka (from Dev Box)" Date: Fri, 13 Nov 2026 18:24:05 +0100 Subject: [PATCH 7/7] test(bytesbuf): mark integration helpers as test-only Express the helpers' existing test-only scope for Clippy. Preserve unwraps, panic behavior, assertions, test selection, and memory guards. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- crates/bytesbuf/tests/memory_providers/block_ref.rs | 2 ++ crates/bytesbuf/tests/support/mod.rs | 2 ++ crates/bytesbuf/tests/test_memory/mod.rs | 2 ++ 3 files changed, 6 insertions(+) diff --git a/crates/bytesbuf/tests/memory_providers/block_ref.rs b/crates/bytesbuf/tests/memory_providers/block_ref.rs index 312d1eefb5..17f75b3d12 100644 --- a/crates/bytesbuf/tests/memory_providers/block_ref.rs +++ b/crates/bytesbuf/tests/memory_providers/block_ref.rs @@ -1,6 +1,8 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +#![cfg(test)] + //! Tests behavior through the public API. use std::ptr::NonNull; diff --git a/crates/bytesbuf/tests/support/mod.rs b/crates/bytesbuf/tests/support/mod.rs index 976ad155eb..a753ee3336 100644 --- a/crates/bytesbuf/tests/support/mod.rs +++ b/crates/bytesbuf/tests/support/mod.rs @@ -1,6 +1,8 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +#![cfg(test)] + #[cfg(all(not(miri), target_os = "linux"))] #[cfg_attr(coverage_nightly, coverage(off))] // Test utility function, not meant to be covered pub(crate) fn system_memory() -> usize { diff --git a/crates/bytesbuf/tests/test_memory/mod.rs b/crates/bytesbuf/tests/test_memory/mod.rs index 884efb6305..3d2bc309b5 100644 --- a/crates/bytesbuf/tests/test_memory/mod.rs +++ b/crates/bytesbuf/tests/test_memory/mod.rs @@ -1,6 +1,8 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. +#![cfg(test)] + use std::num::NonZero; use bytesbuf::BytesBuf;