berkus
/
bincode-orig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Made all encode and decode functions always require a Config, removed _with_config functions

This commit is contained in:
Victor Koenders 2021-10-21 14:19:40 +02:00
parent dd7e8e8e43
commit 707d0d238f
11 changed files with 98 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
benches/varint.rs
View File

@ -10,11 +10,11 @@ fn slice_varint_u8(c: &mut Criterion) {
.take(10_000) .take(10_000)
.collect(); .collect();
let config = Configuration::standard(); let config = Configuration::standard();
let bytes = bincode::encode_to_vec_with_config(&input, config).unwrap(); let bytes = bincode::encode_to_vec(&input, config).unwrap();
c.bench_function("slice_varint_u8", |b| { c.bench_function("slice_varint_u8", |b| {
b.iter(|| { b.iter(|| {
let _: Vec<u8> = bincode::decode_with_config(&bytes, config).unwrap(); let _: Vec<u8> = bincode::decode_from_slice(&bytes, config).unwrap();
}) })
}); });
} }
@ -26,11 +26,11 @@ fn slice_varint_u16(c: &mut Criterion) {
.take(10_000) .take(10_000)
.collect(); .collect();
let config = Configuration::standard(); let config = Configuration::standard();
let bytes = bincode::encode_to_vec_with_config(&input, config).unwrap(); let bytes = bincode::encode_to_vec(&input, config).unwrap();
c.bench_function("slice_varint_u16", |b| { c.bench_function("slice_varint_u16", |b| {
b.iter(|| { b.iter(|| {
let _: Vec<u16> = bincode::decode_with_config(&bytes, config).unwrap(); let _: Vec<u16> = bincode::decode_from_slice(&bytes, config).unwrap();
}) })
}); });
} }
@ -42,11 +42,11 @@ fn slice_varint_u32(c: &mut Criterion) {
.take(10_000) .take(10_000)
.collect(); .collect();
let config = Configuration::standard(); let config = Configuration::standard();
let bytes = bincode::encode_to_vec_with_config(&input, config).unwrap(); let bytes = bincode::encode_to_vec(&input, config).unwrap();
c.bench_function("slice_varint_u32", |b| { c.bench_function("slice_varint_u32", |b| {
b.iter(|| { b.iter(|| {
let _: Vec<u32> = bincode::decode_with_config(&bytes, config).unwrap(); let _: Vec<u32> = bincode::decode_from_slice(&bytes, config).unwrap();
}) })
}); });
} }
@ -58,11 +58,11 @@ fn slice_varint_u64(c: &mut Criterion) {
.take(10_000) .take(10_000)
.collect(); .collect();
let config = Configuration::standard(); let config = Configuration::standard();
let bytes = bincode::encode_to_vec_with_config(&input, config).unwrap(); let bytes = bincode::encode_to_vec(&input, config).unwrap();
c.bench_function("slice_varint_u64", |b| { c.bench_function("slice_varint_u64", |b| {
b.iter(|| { b.iter(|| {
let _: Vec<u64> = bincode::decode_with_config(&bytes, config).unwrap(); let _: Vec<u64> = bincode::decode_from_slice(&bytes, config).unwrap();
}) })
}); });
} }
@ -74,12 +74,12 @@ fn bufreader_varint_u8(c: &mut Criterion) {
.take(10_000) .take(10_000)
.collect(); .collect();
let config = Configuration::standard(); let config = Configuration::standard();
let bytes = bincode::encode_to_vec_with_config(&input, config).unwrap(); let bytes = bincode::encode_to_vec(&input, config).unwrap();
c.bench_function("bufreader_varint_u8", |b| { c.bench_function("bufreader_varint_u8", |b| {
b.iter(|| { b.iter(|| {
let _: Vec<u8> = let _: Vec<u8> =
bincode::decode_from_with_config(&mut std::io::BufReader::new(&bytes[..]), config) bincode::decode_from_reader(&mut std::io::BufReader::new(&bytes[..]), config)
.unwrap(); .unwrap();
}) })
}); });
@ -92,12 +92,12 @@ fn bufreader_varint_u16(c: &mut Criterion) {
.take(10_000) .take(10_000)
.collect(); .collect();
let config = Configuration::standard(); let config = Configuration::standard();
let bytes = bincode::encode_to_vec_with_config(&input, config).unwrap(); let bytes = bincode::encode_to_vec(&input, config).unwrap();
c.bench_function("bufreader_varint_u16", |b| { c.bench_function("bufreader_varint_u16", |b| {
b.iter(|| { b.iter(|| {
let _: Vec<u16> = let _: Vec<u16> =
bincode::decode_from_with_config(&mut std::io::BufReader::new(&bytes[..]), config) bincode::decode_from_reader(&mut std::io::BufReader::new(&bytes[..]), config)
.unwrap(); .unwrap();
}) })
}); });
@ -110,12 +110,12 @@ fn bufreader_varint_u32(c: &mut Criterion) {
.take(10_000) .take(10_000)
.collect(); .collect();
let config = Configuration::standard(); let config = Configuration::standard();
let bytes = bincode::encode_to_vec_with_config(&input, config).unwrap(); let bytes = bincode::encode_to_vec(&input, config).unwrap();
c.bench_function("bufreader_varint_u32", |b| { c.bench_function("bufreader_varint_u32", |b| {
b.iter(|| { b.iter(|| {
let _: Vec<u32> = let _: Vec<u32> =
bincode::decode_from_with_config(&mut std::io::BufReader::new(&bytes[..]), config) bincode::decode_from_reader(&mut std::io::BufReader::new(&bytes[..]), config)
.unwrap(); .unwrap();
}) })
}); });
@ -128,12 +128,12 @@ fn bufreader_varint_u64(c: &mut Criterion) {
.take(10_000) .take(10_000)
.collect(); .collect();
let config = Configuration::standard(); let config = Configuration::standard();
let bytes = bincode::encode_to_vec_with_config(&input, config).unwrap(); let bytes = bincode::encode_to_vec(&input, config).unwrap();
c.bench_function("bufreader_varint_u64", |b| { c.bench_function("bufreader_varint_u64", |b| {
b.iter(|| { b.iter(|| {
let _: Vec<u64> = let _: Vec<u64> =
bincode::decode_from_with_config(&mut std::io::BufReader::new(&bytes[..]), config) bincode::decode_from_reader(&mut std::io::BufReader::new(&bytes[..]), config)
.unwrap(); .unwrap();
}) })
}); });

16
docs/spec.md
View File

@ -21,7 +21,7 @@ All tuples have no additional bytes, and are encoded in their specified order, e
use bincode::config::Configuration; use bincode::config::Configuration;
let tuple = (u32::min_value(), i32::max_value()); // 8 bytes let tuple = (u32::min_value(), i32::max_value()); // 8 bytes
let encoded = bincode::encode_to_vec_with_config(tuple, Configuration::legacy()).unwrap(); let encoded = bincode::encode_to_vec(tuple, Configuration::legacy()).unwrap();
assert_eq!(encoded.as_slice(), &[ assert_eq!(encoded.as_slice(), &[
0, 0, 0, 0, // 4 bytes for first type: u32 0, 0, 0, 0, // 4 bytes for first type: u32
255, 255, 255, 127 // 4 bytes for second type: i32 255, 255, 255, 127 // 4 bytes for second type: i32
@ -69,21 +69,21 @@ pub enum SomeEnum {
} }
// SomeEnum::A // SomeEnum::A
let encoded = bincode::encode_to_vec_with_config(SomeEnum::A, Configuration::legacy()).unwrap(); let encoded = bincode::encode_to_vec(SomeEnum::A, Configuration::legacy()).unwrap();
assert_eq!(encoded.as_slice(), &[ assert_eq!(encoded.as_slice(), &[
0, 0, 0, 0, // first variant, A 0, 0, 0, 0, // first variant, A
// no extra bytes because A has no fields // no extra bytes because A has no fields
]); ]);
// SomeEnum::B(0) // SomeEnum::B(0)
let encoded = bincode::encode_to_vec_with_config(SomeEnum::B(0), Configuration::legacy()).unwrap(); let encoded = bincode::encode_to_vec(SomeEnum::B(0), Configuration::legacy()).unwrap();
assert_eq!(encoded.as_slice(), &[ assert_eq!(encoded.as_slice(), &[
1, 0, 0, 0, // first variant, B 1, 0, 0, 0, // first variant, B
0, 0, 0, 0 // B has 1 unnamed field, which is an u32, so 4 bytes 0, 0, 0, 0 // B has 1 unnamed field, which is an u32, so 4 bytes
]); ]);
// SomeEnum::C { value: 0u32 } // SomeEnum::C { value: 0u32 }
let encoded = bincode::encode_to_vec_with_config(SomeEnum::C { value: 0u32 }, Configuration::legacy()).unwrap(); let encoded = bincode::encode_to_vec(SomeEnum::C { value: 0u32 }, Configuration::legacy()).unwrap();
assert_eq!(encoded.as_slice(), &[ assert_eq!(encoded.as_slice(), &[
2, 0, 0, 0, // first variant, C 2, 0, 0, 0, // first variant, C
0, 0, 0, 0 // C has 1 named field which is a u32, so 4 bytes 0, 0, 0, 0 // C has 1 named field which is a u32, so 4 bytes
@ -104,7 +104,7 @@ let list = vec![
2u8 2u8
]; ];
let encoded = bincode::encode_to_vec_with_config(list, Configuration::legacy()).unwrap(); let encoded = bincode::encode_to_vec(list, Configuration::legacy()).unwrap();
assert_eq!(encoded.as_slice(), &[ assert_eq!(encoded.as_slice(), &[
3, 0, 0, 0, 0, 0, 0, 0, // length of 3u64 3, 0, 0, 0, 0, 0, 0, 0, // length of 3u64
0, // entry 0 0, // entry 0
@ -124,7 +124,7 @@ use bincode::config::Configuration;
let str = "Hello"; // Could also be `String::new(...)` let str = "Hello"; // Could also be `String::new(...)`
let encoded = bincode::encode_to_vec_with_config(str, Configuration::legacy()).unwrap(); let encoded = bincode::encode_to_vec(str, Configuration::legacy()).unwrap();
assert_eq!(encoded.as_slice(), &[ assert_eq!(encoded.as_slice(), &[
5, 0, 0, 0, 0, 0, 0, 0, // length of the string, 5 bytes 5, 0, 0, 0, 0, 0, 0, 0, // length of the string, 5 bytes
b'H', b'e', b'l', b'l', b'o' b'H', b'e', b'l', b'l', b'o'
@ -139,7 +139,7 @@ Arrays are encoded *with* a length by default.
use bincode::config::Configuration; use bincode::config::Configuration;
let arr: [u8; 5] = [10, 20, 30, 40, 50]; let arr: [u8; 5] = [10, 20, 30, 40, 50];
let encoded = bincode::encode_to_vec_with_config(arr, Configuration::legacy()).unwrap(); let encoded = bincode::encode_to_vec(arr, Configuration::legacy()).unwrap();
assert_eq!(encoded.as_slice(), &[ assert_eq!(encoded.as_slice(), &[
5, 0, 0, 0, 0, 0, 0, 0, // The length, as a u64 5, 0, 0, 0, 0, 0, 0, 0, // The length, as a u64
10, 20, 30, 40, 50, // the bytes 10, 20, 30, 40, 50, // the bytes
@ -168,7 +168,7 @@ let arr: [Foo; 2] = [
}, },
]; ];
let encoded = bincode::encode_to_vec_with_config(arr, Configuration::legacy()).unwrap(); let encoded = bincode::encode_to_vec(arr, Configuration::legacy()).unwrap();
assert_eq!(encoded.as_slice(), &[ assert_eq!(encoded.as_slice(), &[
2, 0, 0, 0, 0, 0, 0, 0, // Length of the array 2, 0, 0, 0, 0, 0, 0, 0, // Length of the array
10, 20, // First Foo 10, 20, // First Foo

14
src/features/impl_alloc.rs
View File

@ -1,5 +1,4 @@
use crate::{ use crate::{
config,
de::{Decode, Decoder}, de::{Decode, Decoder},
enc::{self, Encode, Encoder}, enc::{self, Encode, Encoder},
error::{DecodeError, EncodeError}, error::{DecodeError, EncodeError},
@ -21,18 +20,11 @@ impl enc::write::Writer for VecWriter {
} }
} }
/// Encode the given value into a `Vec<u8>`.
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
pub fn encode_to_vec<E: enc::Encode>(val: E) -> Result<Vec<u8>, EncodeError> {
encode_to_vec_with_config(val, config::Configuration::standard())
}
/// Encode the given value into a `Vec<u8>` with the given `Config`. See the [config] module for more information. /// Encode the given value into a `Vec<u8>` with the given `Config`. See the [config] module for more information.
///
/// [config]: config/index.html
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))] #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
pub fn encode_to_vec_with_config<E: enc::Encode, C: Config>( pub fn encode_to_vec<E: enc::Encode, C: Config>(val: E, config: C) -> Result<Vec<u8>, EncodeError> {
val: E,
config: C,
) -> Result<Vec<u8>, EncodeError> {
let writer = VecWriter::default(); let writer = VecWriter::default();
let mut encoder = enc::EncoderImpl::<_, C>::new(writer, config); let mut encoder = enc::EncoderImpl::<_, C>::new(writer, config);
val.encode(&mut encoder)?; val.encode(&mut encoder)?;

28
src/features/impl_std.rs
View File

@ -1,5 +1,5 @@
use crate::{ use crate::{
config::{self, Config}, config::Config,
de::{read::Reader, BorrowDecode, BorrowDecoder, Decode, Decoder, DecoderImpl}, de::{read::Reader, BorrowDecode, BorrowDecoder, Decode, Decoder, DecoderImpl},
enc::{write::Writer, Encode, Encoder, EncoderImpl}, enc::{write::Writer, Encode, Encoder, EncoderImpl},
error::{DecodeError, EncodeError}, error::{DecodeError, EncodeError},
@ -13,17 +13,13 @@ use std::{
time::SystemTime, time::SystemTime,
}; };
/// Decode type `D` from the given reader. The reader can be any type that implements `std::io::Read`, e.g. `std::fs::File`.
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
pub fn decode_from<D: Decode, R: std::io::Read>(src: &mut R) -> Result<D, DecodeError> {
decode_from_with_config(src, config::Configuration::standard())
}
/// Decode type `D` from the given reader with the given `Config`. The reader can be any type that implements `std::io::Read`, e.g. `std::fs::File`. /// Decode type `D` from the given reader with the given `Config`. The reader can be any type that implements `std::io::Read`, e.g. `std::fs::File`.
/// ///
/// See the [config] module for more information about config options. /// See the [config] module for more information about config options.
///
/// [config]: config/index.html
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
pub fn decode_from_with_config<D: Decode, C: Config, R: std::io::Read>( pub fn decode_from_reader<D: Decode, C: Config, R: std::io::Read>(
src: &mut R, src: &mut R,
_config: C, _config: C,
) -> Result<D, DecodeError> { ) -> Result<D, DecodeError> {
@ -41,18 +37,12 @@ impl<R: std::io::Read> Reader for R {
} }
} }
/// Encode the given value into any type that implements `std::io::Write`, e.g. `std::fs::File`. /// Encode the given value into any type that implements `std::io::Write`, e.g. `std::fs::File`, with the given `Config`.
/// See the [config] module for more information.
///
/// [config]: config/index.html
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
pub fn encode_into_write<E: Encode, W: std::io::Write>( pub fn encode_into_writer<E: Encode, C: Config, W: std::io::Write>(
val: E,
dst: &mut W,
) -> Result<usize, EncodeError> {
encode_into_write_with_config(val, dst, config::Configuration::standard())
}
/// Encode the given value into any type that implements `std::io::Write`, e.g. `std::fs::File`, with the given `Config`. See the [config] module for more information.
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
pub fn encode_into_write_with_config<E: Encode, C: Config, W: std::io::Write>(
val: E, val: E,
dst: &mut W, dst: &mut W,
config: C, config: C,

39
src/lib.rs
View File

@ -15,11 +15,11 @@
//! //!
//! |Name |Default?|Supported types for Encode/Decode|Enabled methods |Other| //! |Name |Default?|Supported types for Encode/Decode|Enabled methods |Other|
//! |------|--------|-----------------------------------------|-----------------------------------------------------------------|-----| //! |------|--------|-----------------------------------------|-----------------------------------------------------------------|-----|
//! |std | Yes ||`decode_from[_with_config]` and `encode_into_write[_with_config]`| //! |std | Yes ||`decode_from_reader` and `encode_into_writer`|
//! |alloc | Yes |All common containers in alloc, like `Vec`, `String`, `Box`|`encode_to_vec[_with_config]`| //! |alloc | Yes |All common containers in alloc, like `Vec`, `String`, `Box`|`encode_to_vec`|
//! |atomic| Yes |All `Atomic*` integer types, e.g. `AtomicUsize`, and `AtomicBool`|| //! |atomic| Yes |All `Atomic*` integer types, e.g. `AtomicUsize`, and `AtomicBool`||
//! |derive| Yes |||Enables the `Encode` and `Decode` derive macro| //! |derive| Yes |||Enables the `Encode` and `Decode` derive macro|
//! |serde | No ||`serde_decode_from[_with_config]`, `serde_encode_into[_with_config]`|Also enables `_to_vec` when `alloc` is enabled| //! |serde | No |TODO|TODO|TODO|
#![doc(html_root_url = "https://docs.rs/bincode/2.0.0-alpha.0")] #![doc(html_root_url = "https://docs.rs/bincode/2.0.0-alpha.0")]
#![crate_name = "bincode"] #![crate_name = "bincode"]
@ -43,22 +43,12 @@ pub mod error;
use config::Config; use config::Config;
/// Encode the given value into the given slice. Returns the amount of bytes that have been written.
///
/// Will take the [standard] configuration. See the [config] module for more information.
///
/// [standard]: config/struct.Configuration.html#method.standard
pub fn encode_into_slice<E: enc::Encode>(
val: E,
dst: &mut [u8],
) -> Result<usize, error::EncodeError> {
encode_into_slice_with_config(val, dst, config::Configuration::standard())
}
/// Encode the given value into the given slice. Returns the amount of bytes that have been written. /// Encode the given value into the given slice. Returns the amount of bytes that have been written.
/// ///
/// See the [config] module for more information on configurations. /// See the [config] module for more information on configurations.
pub fn encode_into_slice_with_config<E: enc::Encode, C: Config>( ///
/// [config]: config/index.html
pub fn encode_into_slice<E: enc::Encode, C: Config>(
val: E, val: E,
dst: &mut [u8], dst: &mut [u8],
config: C, config: C,
@ -69,22 +59,13 @@ pub fn encode_into_slice_with_config<E: enc::Encode, C: Config>(
Ok(encoder.into_writer().bytes_written()) Ok(encoder.into_writer().bytes_written())
} }
/// Attempt to decode a given type `D` from the given slice.
///
/// Will take the [Default] configuration. See the [config] module for more information.
///
/// [Default]: config/struct.Default.html
pub fn decode<'__de, D: de::BorrowDecode<'__de>>(
src: &'__de [u8],
) -> Result<D, error::DecodeError> {
decode_with_config(src, config::Configuration::standard())
}
/// Attempt to decode a given type `D` from the given slice. /// Attempt to decode a given type `D` from the given slice.
/// ///
/// See the [config] module for more information on configurations. /// See the [config] module for more information on configurations.
pub fn decode_with_config<'__de, D: de::BorrowDecode<'__de>, C: Config>( ///
src: &'__de [u8], /// [config]: config/index.html
pub fn decode_from_slice<'a, D: de::BorrowDecode<'a>, C: Config>(
src: &'a [u8],
_config: C, _config: C,
) -> Result<D, error::DecodeError> { ) -> Result<D, error::DecodeError> {
let reader = de::read::SliceReader::new(src); let reader = de::read::SliceReader::new(src);

5
tests/alloc.rs
View File

@ -9,6 +9,7 @@ use alloc::collections::*;
use alloc::rc::Rc; use alloc::rc::Rc;
#[cfg(feature = "atomic")] #[cfg(feature = "atomic")]
use alloc::sync::Arc; use alloc::sync::Arc;
use bincode::config::Configuration;
use utils::{the_same, the_same_with_comparer}; use utils::{the_same, the_same_with_comparer};
struct Foo { struct Foo {
@ -40,10 +41,10 @@ impl bincode::de::Decode for Foo {
#[test] #[test]
fn test_vec() { fn test_vec() {
let vec = bincode::encode_to_vec(Foo { a: 5, b: 10 }).unwrap(); let vec = bincode::encode_to_vec(Foo { a: 5, b: 10 }, Configuration::standard()).unwrap();
assert_eq!(vec, &[5, 10]); assert_eq!(vec, &[5, 10]);
let foo: Foo = bincode::decode(&vec).unwrap(); let foo: Foo = bincode::decode_from_slice(&vec, Configuration::standard()).unwrap();
assert_eq!(foo.a, 5); assert_eq!(foo.a, 5);
assert_eq!(foo.b, 10); assert_eq!(foo.b, 10);
} }

18
tests/basic_types.rs
View File

@ -1,5 +1,6 @@
mod utils; mod utils;
use bincode::config::Configuration;
use core::cell::{Cell, RefCell}; use core::cell::{Cell, RefCell};
use core::ops::Bound; use core::ops::Bound;
use core::time::Duration; use core::time::Duration;
@ -119,7 +120,7 @@ fn test_refcell_already_borrowed() {
let _mutable_guard = cell.borrow_mut(); let _mutable_guard = cell.borrow_mut();
// now try to encode it // now try to encode it
let mut slice = [0u8; 10]; let mut slice = [0u8; 10];
let result = bincode::encode_into_slice(&cell, &mut slice) let result = bincode::encode_into_slice(&cell, &mut slice, Configuration::standard())
.expect_err("Encoding a borrowed refcell should fail"); .expect_err("Encoding a borrowed refcell should fail");
match result { match result {
@ -132,10 +133,11 @@ fn test_refcell_already_borrowed() {
fn test_slice() { fn test_slice() {
let mut buffer = [0u8; 32]; let mut buffer = [0u8; 32];
let input: &[u8] = &[1, 2, 3, 4, 5, 6, 7]; let input: &[u8] = &[1, 2, 3, 4, 5, 6, 7];
bincode::encode_into_slice(input, &mut buffer).unwrap(); bincode::encode_into_slice(input, &mut buffer, Configuration::standard()).unwrap();
assert_eq!(&buffer[..8], &[7, 1, 2, 3, 4, 5, 6, 7]); assert_eq!(&buffer[..8], &[7, 1, 2, 3, 4, 5, 6, 7]);
let output: &[u8] = bincode::decode(&mut buffer[..8]).unwrap(); let output: &[u8] =
bincode::decode_from_slice(&mut buffer[..8], Configuration::standard()).unwrap();
assert_eq!(input, output); assert_eq!(input, output);
} }
@ -143,13 +145,14 @@ fn test_slice() {
fn test_str() { fn test_str() {
let mut buffer = [0u8; 32]; let mut buffer = [0u8; 32];
let input: &str = "Hello world"; let input: &str = "Hello world";
bincode::encode_into_slice(input, &mut buffer).unwrap(); bincode::encode_into_slice(input, &mut buffer, Configuration::standard()).unwrap();
assert_eq!( assert_eq!(
&buffer[..12], &buffer[..12],
&[11, 72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100] &[11, 72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]
); );
let output: &str = bincode::decode(&mut buffer[..12]).unwrap(); let output: &str =
bincode::decode_from_slice(&mut buffer[..12], Configuration::standard()).unwrap();
assert_eq!(input, output); assert_eq!(input, output);
} }
@ -157,9 +160,10 @@ fn test_str() {
fn test_array() { fn test_array() {
let mut buffer = [0u8; 32]; let mut buffer = [0u8; 32];
let input: [u8; 10] = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]; let input: [u8; 10] = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
bincode::encode_into_slice(input, &mut buffer).unwrap(); bincode::encode_into_slice(input, &mut buffer, Configuration::standard()).unwrap();
assert_eq!(&buffer[..10], &[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]); assert_eq!(&buffer[..10], &[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]);
let output: [u8; 10] = bincode::decode(&mut buffer[..10]).unwrap(); let output: [u8; 10] =
bincode::decode_from_slice(&mut buffer[..10], Configuration::standard()).unwrap();
assert_eq!(input, output); assert_eq!(input, output);
} }

31
tests/derive.rs
View File

@ -1,5 +1,6 @@
#![cfg(feature = "derive")] #![cfg(feature = "derive")]
use bincode::config::Configuration;
use bincode::{de::Decode, enc::Encode}; use bincode::{de::Decode, enc::Encode};
#[derive(bincode::Encode, PartialEq, Debug)] #[derive(bincode::Encode, PartialEq, Debug)]
@ -48,7 +49,8 @@ fn test_encode() {
c: 20u8, c: 20u8,
}; };
let mut slice = [0u8; 1024]; let mut slice = [0u8; 1024];
let bytes_written = bincode::encode_into_slice(start, &mut slice).unwrap(); let bytes_written =
bincode::encode_into_slice(start, &mut slice, Configuration::standard()).unwrap();
assert_eq!(bytes_written, 3); assert_eq!(bytes_written, 3);
assert_eq!(&slice[..bytes_written], &[10, 10, 20]); assert_eq!(&slice[..bytes_written], &[10, 10, 20]);
} }
@ -62,7 +64,8 @@ fn test_decode() {
c: 1024u32, c: 1024u32,
}; };
let slice = [5, 10, 251, 0, 4]; let slice = [5, 10, 251, 0, 4];
let result: Test2<u32> = bincode::decode_from(&mut slice.as_ref()).unwrap(); let result: Test2<u32> =
bincode::decode_from_reader(&mut slice.as_ref(), Configuration::standard()).unwrap();
assert_eq!(result, start); assert_eq!(result, start);
} }
@ -70,7 +73,8 @@ fn test_decode() {
fn test_encode_tuple() { fn test_encode_tuple() {
let start = TestTupleStruct(5, 10, 1024); let start = TestTupleStruct(5, 10, 1024);
let mut slice = [0u8; 1024]; let mut slice = [0u8; 1024];
let bytes_written = bincode::encode_into_slice(start, &mut slice).unwrap(); let bytes_written =
bincode::encode_into_slice(start, &mut slice, Configuration::standard()).unwrap();
assert_eq!(bytes_written, 5); assert_eq!(bytes_written, 5);
assert_eq!(&slice[..bytes_written], &[5, 10, 251, 0, 4]); assert_eq!(&slice[..bytes_written], &[5, 10, 251, 0, 4]);
} }
@ -79,7 +83,8 @@ fn test_encode_tuple() {
fn test_decode_tuple() { fn test_decode_tuple() {
let start = TestTupleStruct(5, 10, 1024); let start = TestTupleStruct(5, 10, 1024);
let mut slice = [5, 10, 251, 0, 4]; let mut slice = [5, 10, 251, 0, 4];
let result: TestTupleStruct = bincode::decode(&mut slice).unwrap(); let result: TestTupleStruct =
bincode::decode_from_slice(&mut slice, Configuration::standard()).unwrap();
assert_eq!(result, start); assert_eq!(result, start);
} }
@ -87,7 +92,8 @@ fn test_decode_tuple() {
fn test_encode_enum_struct_variant() { fn test_encode_enum_struct_variant() {
let start = TestEnum::Bar { name: 5u32 }; let start = TestEnum::Bar { name: 5u32 };
let mut slice = [0u8; 1024]; let mut slice = [0u8; 1024];
let bytes_written = bincode::encode_into_slice(start, &mut slice).unwrap(); let bytes_written =
bincode::encode_into_slice(start, &mut slice, Configuration::standard()).unwrap();
assert_eq!(bytes_written, 2); assert_eq!(bytes_written, 2);
assert_eq!(&slice[..bytes_written], &[1, 5]); assert_eq!(&slice[..bytes_written], &[1, 5]);
} }
@ -96,7 +102,8 @@ fn test_encode_enum_struct_variant() {
fn test_decode_enum_struct_variant() { fn test_decode_enum_struct_variant() {
let start = TestEnum::Bar { name: 5u32 }; let start = TestEnum::Bar { name: 5u32 };
let mut slice = [1, 5]; let mut slice = [1, 5];
let result: TestEnum = bincode::decode(&mut slice).unwrap(); let result: TestEnum =
bincode::decode_from_slice(&mut slice, Configuration::standard()).unwrap();
assert_eq!(result, start); assert_eq!(result, start);
} }
@ -104,7 +111,8 @@ fn test_decode_enum_struct_variant() {
fn test_encode_enum_tuple_variant() { fn test_encode_enum_tuple_variant() {
let start = TestEnum::Baz(5, 10, 1024); let start = TestEnum::Baz(5, 10, 1024);
let mut slice = [0u8; 1024]; let mut slice = [0u8; 1024];
let bytes_written = bincode::encode_into_slice(start, &mut slice).unwrap(); let bytes_written =
bincode::encode_into_slice(start, &mut slice, Configuration::standard()).unwrap();
assert_eq!(bytes_written, 6); assert_eq!(bytes_written, 6);
assert_eq!(&slice[..bytes_written], &[2, 5, 10, 251, 0, 4]); assert_eq!(&slice[..bytes_written], &[2, 5, 10, 251, 0, 4]);
} }
@ -113,7 +121,8 @@ fn test_encode_enum_tuple_variant() {
fn test_decode_enum_unit_variant() { fn test_decode_enum_unit_variant() {
let start = TestEnum::Foo; let start = TestEnum::Foo;
let mut slice = [0]; let mut slice = [0];
let result: TestEnum = bincode::decode(&mut slice).unwrap(); let result: TestEnum =
bincode::decode_from_slice(&mut slice, Configuration::standard()).unwrap();
assert_eq!(result, start); assert_eq!(result, start);
} }
@ -121,7 +130,8 @@ fn test_decode_enum_unit_variant() {
fn test_encode_enum_unit_variant() { fn test_encode_enum_unit_variant() {
let start = TestEnum::Foo; let start = TestEnum::Foo;
let mut slice = [0u8; 1024]; let mut slice = [0u8; 1024];
let bytes_written = bincode::encode_into_slice(start, &mut slice).unwrap(); let bytes_written =
bincode::encode_into_slice(start, &mut slice, Configuration::standard()).unwrap();
assert_eq!(bytes_written, 1); assert_eq!(bytes_written, 1);
assert_eq!(&slice[..bytes_written], &[0]); assert_eq!(&slice[..bytes_written], &[0]);
} }
@ -130,6 +140,7 @@ fn test_encode_enum_unit_variant() {
fn test_decode_enum_tuple_variant() { fn test_decode_enum_tuple_variant() {
let start = TestEnum::Baz(5, 10, 1024); let start = TestEnum::Baz(5, 10, 1024);
let mut slice = [2, 5, 10, 251, 0, 4]; let mut slice = [2, 5, 10, 251, 0, 4];
let result: TestEnum = bincode::decode(&mut slice).unwrap(); let result: TestEnum =
bincode::decode_from_slice(&mut slice, Configuration::standard()).unwrap();
assert_eq!(result, start); assert_eq!(result, start);
} }

7
tests/serde.rs
View File

@ -1,5 +1,6 @@
#![cfg(all(feature = "serde", feature = "alloc", feature = "derive"))] #![cfg(all(feature = "serde", feature = "alloc", feature = "derive"))]
use bincode::config::Configuration;
use serde_derive::{Deserialize, Serialize}; use serde_derive::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, bincode::Encode, bincode::Decode)] #[derive(Serialize, Deserialize, bincode::Encode, bincode::Decode)]
@ -20,9 +21,11 @@ fn test_serde_round_trip() {
assert_eq!(result.b, 0); assert_eq!(result.b, 0);
// validate bincode working // validate bincode working
let bytes = bincode::encode_to_vec(SerdeRoundtrip { a: 15, b: 15 }).unwrap(); let bytes =
bincode::encode_to_vec(SerdeRoundtrip { a: 15, b: 15 }, Configuration::standard()).unwrap();
assert_eq!(bytes, &[15, 15]); assert_eq!(bytes, &[15, 15]);
let result: SerdeRoundtrip = bincode::decode(&bytes).unwrap(); let result: SerdeRoundtrip =
bincode::decode_from_slice(&bytes, Configuration::standard()).unwrap();
assert_eq!(result.a, 15); assert_eq!(result.a, 15);
assert_eq!(result.b, 15); assert_eq!(result.b, 15);
} }

17
tests/std.rs
View File

@ -2,6 +2,7 @@
mod utils; mod utils;
use bincode::config::Configuration;
use std::{ use std::{
ffi::{CStr, CString}, ffi::{CStr, CString},
io::{Cursor, Seek, SeekFrom}, io::{Cursor, Seek, SeekFrom},
@ -43,7 +44,7 @@ impl bincode::de::Decode for Foo {
#[test] #[test]
fn test_std_cursor() { fn test_std_cursor() {
let mut cursor = Cursor::<&[u8]>::new(&[5, 10]); let mut cursor = Cursor::<&[u8]>::new(&[5, 10]);
let foo: Foo = bincode::decode_from(&mut cursor).unwrap(); let foo: Foo = bincode::decode_from_reader(&mut cursor, Configuration::standard()).unwrap();
assert_eq!(foo.a, 5); assert_eq!(foo.a, 5);
assert_eq!(foo.b, 10); assert_eq!(foo.b, 10);
@ -53,11 +54,13 @@ fn test_std_cursor() {
fn test_std_file() { fn test_std_file() {
let mut file = tempfile::tempfile().expect("Could not create temp file"); let mut file = tempfile::tempfile().expect("Could not create temp file");
let bytes_written = bincode::encode_into_write(Foo { a: 30, b: 50 }, &mut file).unwrap(); let bytes_written =
bincode::encode_into_writer(Foo { a: 30, b: 50 }, &mut file, Configuration::standard())
.unwrap();
assert_eq!(bytes_written, 2); assert_eq!(bytes_written, 2);
file.seek(SeekFrom::Start(0)).unwrap(); file.seek(SeekFrom::Start(0)).unwrap();
let foo: Foo = bincode::decode_from(&mut file).unwrap(); let foo: Foo = bincode::decode_from_reader(&mut file, Configuration::standard()).unwrap();
assert_eq!(foo.a, 30); assert_eq!(foo.a, 30);
assert_eq!(foo.b, 50); assert_eq!(foo.b, 50);
@ -96,13 +99,13 @@ fn test_std_commons() {
// &CStr // &CStr
let cstr = CStr::from_bytes_with_nul(b"Hello world\0").unwrap(); let cstr = CStr::from_bytes_with_nul(b"Hello world\0").unwrap();
let len = bincode::encode_into_slice_with_config(cstr, &mut buffer, config).unwrap(); let len = bincode::encode_into_slice(cstr, &mut buffer, config).unwrap();
let decoded: &CStr = bincode::decode_with_config(&mut buffer[..len], config).unwrap(); let decoded: &CStr = bincode::decode_from_slice(&mut buffer[..len], config).unwrap();
assert_eq!(cstr, decoded); assert_eq!(cstr, decoded);
// Path // Path
let path = Path::new("C:/Program Files/Foo"); let path = Path::new("C:/Program Files/Foo");
let len = bincode::encode_into_slice_with_config(path, &mut buffer, config).unwrap(); let len = bincode::encode_into_slice(path, &mut buffer, config).unwrap();
let decoded: &Path = bincode::decode_with_config(&mut buffer[..len], config).unwrap(); let decoded: &Path = bincode::decode_from_slice(&mut buffer[..len], config).unwrap();
assert_eq!(path, decoded); assert_eq!(path, decoded);
} }

4
tests/utils.rs
View File

@ -8,14 +8,14 @@ where
CMP: Fn(&V, &V) -> bool, CMP: Fn(&V, &V) -> bool,
{ {
let mut buffer = [0u8; 2048]; let mut buffer = [0u8; 2048];
let len = bincode::encode_into_slice_with_config(&element, &mut buffer, config).unwrap(); let len = bincode::encode_into_slice(&element, &mut buffer, config).unwrap();
println!( println!(
"{:?}: {:?} ({:?})", "{:?}: {:?} ({:?})",
element, element,
&buffer[..len], &buffer[..len],
core::any::type_name::<C>() core::any::type_name::<C>()
); );
let decoded: V = bincode::decode_with_config(&mut buffer, config).unwrap(); let decoded: V = bincode::decode_from_slice(&mut buffer, config).unwrap();
assert!( assert!(
cmp(&element, &decoded), cmp(&element, &decoded),