robin/bitbuffer
1
0
Fork 0
mirror of https://codeberg.org/icewind/bitbuffer.git synced 2026-06-03 08:34:07 +02:00
Code Issues Releases Wiki Activity

clippy fixes

Browse source
This commit is contained in:
Robin Appelman 2023-11-11 22:03:10 +01:00
commit 834c3f2f95
9 changed files with 57 additions and 68 deletions
Download patch file Download diff file Expand all files Collapse all files

2
bitbuffer_derive/src/lib.rs
View file

@ -270,5 +270,5 @@ trait DeriveParams: Sized {
}
fn err<R, Msg: Display>(msg: Msg, span: Span) -> Result<R> {
return Err(Error::new(span, msg));
Err(Error::new(span, msg))
}

2
bitbuffer_derive/src/params/enum.rs
View file

@ -41,7 +41,7 @@ impl EnumParam {
.discriminant_bits
.ok_or_else(|| {
Error::new(
span.clone(),
span,
"'discriminant_bits' attribute is required when deriving `BinRead` for enums",
)
})?

19
bitbuffer_derive/src/params/mod.rs
View file

@ -68,7 +68,7 @@ impl ToTokens for Size {
fn to_tokens(&self, tokens: &mut TokenStream) {
match self {
Size::Expression(expr, span) => {
let span = span.clone();
let span = *span;
tokens.append_all(quote_spanned! {span => {
#[allow(clippy::unnecessary_cast)]
let __size = (#expr) as usize;
@ -77,7 +77,7 @@ impl ToTokens for Size {
});
}
Size::Bits(bits, span) => {
let span = span.clone();
let span = *span;
tokens.append_all(quote_spanned! {span => {
__stream.read_int::<usize>(#bits)?
}
@ -236,9 +236,7 @@ impl InputParams {
}
}
pub fn generics_for_impl<'a>(
&'a self,
) -> (ImplGenerics<'a>, TypeGenerics<'a>, Option<&'a WhereClause>) {
pub fn generics_for_impl(&self) -> (ImplGenerics, TypeGenerics, Option<&WhereClause>) {
// we need these separate generics to only add out Endianness param to the 'impl'
let (_, ty_generics, where_clause) = self.generics.split_for_impl();
let (impl_generics, _, _) = self.generics_with_endianness.split_for_impl();
@ -247,14 +245,11 @@ impl InputParams {
}
pub fn endianness(&self) -> Ident {
Ident::new(
self.endianness.as_deref().unwrap_or_else(|| "_E"),
self.span,
)
Ident::new(self.endianness.as_deref().unwrap_or("_E"), self.span)
}
}
const BARE_ATTRS: &'static [&'static str] = &[
const BARE_ATTRS: &[&str] = &[
"size",
"size_bits",
"discriminant_bits",
@ -279,8 +274,8 @@ fn parse_attrs<T: Parse + Default + Merge>(attrs: &[Attribute]) -> Result<T> {
});
let wrapped = Attribute {
pound_token: attr.pound_token,
style: attr.style.clone(),
bracket_token: attr.bracket_token.clone(),
style: attr.style,
bracket_token: attr.bracket_token,
meta: wrapped_meta,
};
wrapped.parse_args()

10
bitbuffer_derive/src/params/variant.rs
View file

@ -114,18 +114,12 @@ impl VariantParam {
.collect::<Result<Vec<FieldParam>>>()?;
// align and size attributes on the variant go to the first field
match (fields.first_mut(), align) {
(Some(field), Alignment::Auto) => {
if let (Some(field), Alignment::Auto) = (fields.first_mut(), align) {
field.align = align;
}
_ => {}
}
match (fields.first_mut(), size) {
(Some(field), Some(size)) => {
if let (Some(field), Some(size)) = (fields.first_mut(), size) {
field.size = Some(size);
}
_ => {}
}
VariantBody::Fields(fields)
};

2
bitbuffer_derive/src/read/enum.rs
View file

@ -26,7 +26,7 @@ pub fn derive_encode_enum(params: &EnumParam, unchecked: bool) -> TokenStream {
Ok(#ident::#variant_name)
},
VariantBody::Fields(fields) => {
read_struct_or_enum(&variant_path, fields, span.clone(), unchecked)
read_struct_or_enum(&variant_path, fields, span, unchecked)
}
};

2
bitbuffer_derive/src/size_hint.rs
View file

@ -37,7 +37,7 @@ impl SizeHint for VariantParam {
fn size_hint(&self) -> TokenStream {
match &self.body {
VariantBody::Unit => quote!(Some(0)),
VariantBody::Fields(fields) => product_size_hint(&fields, self.span),
VariantBody::Fields(fields) => product_size_hint(fields, self.span),
}
}
}

2
bitbuffer_derive/src/write/enum.rs
View file

@ -45,7 +45,7 @@ pub fn derive_encode_enum(params: &EnumParam) -> TokenStream {
#path => {},
}
}
VariantBody::Fields(fields) => write_enum_variant(path, &fields, span),
VariantBody::Fields(fields) => write_enum_variant(path, fields, span),
}
});

40
tests/read_tests.rs
View file

@ -25,13 +25,13 @@ fn read_u8_le() {
let buffer = BitReadBuffer::new(BYTES, LittleEndian);
assert_eq!(buffer.read_int::<u8>(0, 1).unwrap(), 0b1);
assert_eq!(buffer.read_bool(0).unwrap(), true);
assert!(buffer.read_bool(0).unwrap());
assert_eq!(buffer.read_int::<u8>(1, 1).unwrap(), 0b0);
assert_eq!(buffer.read_bool(1).unwrap(), false);
assert!(!buffer.read_bool(1).unwrap());
assert_eq!(buffer.read_int::<u8>(2, 2).unwrap(), 0b01);
assert_eq!(buffer.read_int::<u8>(0, 3).unwrap(), 0b101);
assert_eq!(buffer.read_int::<u8>(7, 5).unwrap(), 0b1_0101);
assert_eq!(buffer.read_int::<u8>(6, 5).unwrap(), 0b010_10);
assert_eq!(buffer.read_int::<u8>(6, 5).unwrap(), 0b0_1010);
assert_eq!(buffer.read_int::<u8>(12, 5).unwrap(), 0b0_0110);
}
@ -46,22 +46,22 @@ fn read_u8_be() {
assert_eq!(buffer.read_int::<u8>(7, 5).unwrap(), 0b1_0110);
assert_eq!(buffer.read_int::<u8>(6, 5).unwrap(), 0b0_1011);
assert_eq!(buffer.read_bool(0).unwrap(), true);
assert_eq!(buffer.read_bool(8).unwrap(), false);
assert!(buffer.read_bool(0).unwrap());
assert!(!buffer.read_bool(8).unwrap());
}
#[test]
fn read_u16_le() {
let buffer = BitReadBuffer::new(BYTES, LittleEndian);
assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b00_0110_1010_10);
assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b0001_1010_1010);
}
#[test]
fn read_u16_be() {
let buffer = BitReadBuffer::new(BYTES, BigEndian);
assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b01_0110_1010_10);
assert_eq!(buffer.read_int::<u16>(6, 12).unwrap(), 0b0101_1010_1010);
}
#[test]
@ -70,7 +70,7 @@ fn read_u32_le() {
assert_eq!(
buffer.read_int::<u32>(6, 24).unwrap(),
0b01_1001_1010_1100_0110_1010_10
0b0110_0110_1011_0001_1010_1010
);
}
@ -80,7 +80,7 @@ fn read_u32_be() {
assert_eq!(
buffer.read_int::<u32>(6, 24).unwrap(),
0b01_0110_1010_1010_1100_1001_10
0b0101_1010_1010_1011_0010_0110
);
}
@ -90,15 +90,15 @@ fn read_u64_le() {
assert_eq!(
buffer.read_int::<u64>(6, 34).unwrap(),
0b1001_1001_1001_1001_1010_1100_0110_1010_10
0b10_0110_0110_0110_0110_1011_0001_1010_1010
);
assert_eq!(
buffer.read_int::<u64>(6, 60).unwrap(),
0b01_1110_0111_1001_1001_1001_1001_1001_1001_1001_1001_1010_1100_0110_1010_10
0b0111_1001_1110_0110_0110_0110_0110_0110_0110_0110_0110_1011_0001_1010_1010
);
assert_eq!(
buffer.read_int::<u64>(6, 64).unwrap(),
0b01_1001_1110_0111_1001_1001_1001_1001_1001_1001_1001_1001_1010_1100_0110_1010_10
0b0110_0111_1001_1110_0110_0110_0110_0110_0110_0110_0110_0110_1011_0001_1010_1010
);
assert_eq!(
buffer.read_int::<u64>(8, 62).unwrap(),
@ -116,11 +116,11 @@ fn read_u64_be() {
);
assert_eq!(
buffer.read_int::<u64>(6, 60).unwrap(),
0b01_0110_1010_1010_1100_1001_1001_1001_1001_1001_1001_1001_1001_1110_0111_10
0b0101_1010_1010_1011_0010_0110_0110_0110_0110_0110_0110_0110_0111_1001_1110
);
assert_eq!(
buffer.read_int::<u64>(6, 64).unwrap(),
0b01_0110_1010_1010_1100_1001_1001_1001_1001_1001_1001_1001_1001_1110_0111_1001_10
0b0101_1010_1010_1011_0010_0110_0110_0110_0110_0110_0110_0110_0111_1001_1110_0110
);
}
@ -145,15 +145,15 @@ fn read_i8_be() {
fn read_i16_le() {
let buffer = BitReadBuffer::new(BYTES, LittleEndian);
assert_eq!(buffer.read_int::<i16>(6, 12).unwrap(), 0b0_0110_1010_10);
assert_eq!(buffer.read_int::<i16>(6, 13).unwrap(), -0b11_1001_0101_10);
assert_eq!(buffer.read_int::<i16>(6, 12).unwrap(), 0b001_1010_1010);
assert_eq!(buffer.read_int::<i16>(6, 13).unwrap(), -0b1110_0101_0110);
}
#[test]
fn read_i16_be() {
let buffer = BitReadBuffer::new(BYTES, BigEndian);
assert_eq!(buffer.read_int::<i16>(6, 12).unwrap(), 0b1_0110_1010_10);
assert_eq!(buffer.read_int::<i16>(6, 12).unwrap(), 0b101_1010_1010);
assert_eq!(buffer.read_int::<i16>(7, 12).unwrap(), -0b100_1010_1011);
}
@ -163,7 +163,7 @@ fn read_i32_le() {
assert_eq!(
buffer.read_int::<i32>(6, 24).unwrap(),
0b1_1001_1010_1100_0110_1010_10
0b110_0110_1011_0001_1010_1010
);
assert_eq!(buffer.read_int::<i32>(6, 26).unwrap(), -26824278);
}
@ -287,7 +287,7 @@ fn read_trait() {
let c: i16 = stream.read().unwrap();
assert_eq!(-0b101_0011_0110_0111, c);
let d: bool = stream.read().unwrap();
assert_eq!(true, d);
assert!(d);
let e: Option<u8> = stream.read().unwrap();
assert_eq!(None, e);
stream.set_pos(0).unwrap();
@ -321,7 +321,7 @@ fn read_trait_unchecked() {
let c: i16 = stream.read_unchecked(true).unwrap();
assert_eq!(-0b101_0011_0110_0111, c);
let d: bool = stream.read_unchecked(true).unwrap();
assert_eq!(true, d);
assert!(d);
let e: Option<u8> = stream.read_unchecked(true).unwrap();
assert_eq!(None, e);
stream.set_pos(0).unwrap();

42
tests/write_tests.rs
View file

@ -16,13 +16,13 @@ fn test_write_bool_le() {
let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
assert_eq!(true, read.read_bool().unwrap());
assert_eq!(true, read.read_bool().unwrap());
assert_eq!(false, read.read_bool().unwrap());
assert_eq!(true, read.read_bool().unwrap());
assert!(read.read_bool().unwrap());
assert!(read.read_bool().unwrap());
assert!(!read.read_bool().unwrap());
assert!(read.read_bool().unwrap());
// 0 padded
assert_eq!(false, read.read_bool().unwrap());
assert!(!read.read_bool().unwrap());
}
#[test]
@ -39,13 +39,13 @@ fn test_write_bool_be() {
let mut read = BitReadStream::from(BitReadBuffer::new(&data, BigEndian));
assert_eq!(true, read.read_bool().unwrap());
assert_eq!(true, read.read_bool().unwrap());
assert_eq!(false, read.read_bool().unwrap());
assert_eq!(true, read.read_bool().unwrap());
assert!(read.read_bool().unwrap());
assert!(read.read_bool().unwrap());
assert!(!read.read_bool().unwrap());
assert!(read.read_bool().unwrap());
// 0 padded
assert_eq!(false, read.read_bool().unwrap());
assert!(!read.read_bool().unwrap());
}
#[test]
@ -61,12 +61,12 @@ fn test_write_bool_number_le() {
let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
assert_eq!(true, read.read_bool().unwrap());
assert!(read.read_bool().unwrap());
assert_eq!(3253u16, read.read::<u16>().unwrap());
assert_eq!(13253u64, read.read::<u64>().unwrap());
// 0 padded
assert_eq!(false, read.read_bool().unwrap());
assert!(!read.read_bool().unwrap());
}
#[test]
@ -87,7 +87,7 @@ fn test_write_bool_number_be() {
assert_eq!(13253u64, read.read::<u64>().unwrap());
// 0 padded
assert_eq!(false, read.read_bool().unwrap());
assert!(!read.read_bool().unwrap());
}
#[test]
@ -102,11 +102,11 @@ fn test_write_float_le() {
let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
assert_eq!(true, read.read_bool().unwrap());
assert!(read.read_bool().unwrap());
assert_eq!(3253.12f32, read.read::<f32>().unwrap());
// 0 padded
assert_eq!(false, read.read_bool().unwrap());
assert!(!read.read_bool().unwrap());
}
#[test]
@ -125,7 +125,7 @@ fn test_write_float_be() {
assert_eq!(3253.12f32, read.read::<f32>().unwrap());
// 0 padded
assert_eq!(false, read.read_bool().unwrap());
assert!(!read.read_bool().unwrap());
}
#[test]
@ -160,13 +160,13 @@ fn test_write_string_le_unaligned() {
let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
assert_eq!(true, read.read_bool().unwrap());
assert!(read.read_bool().unwrap());
assert_eq!("null terminated", read.read_string(None).unwrap());
assert_eq!("fixed length1", read.read_string(Some(16)).unwrap());
assert_eq!("fixed length2", read.read_string(Some(16)).unwrap());
// 0 padded
assert_eq!(false, read.read_bool().unwrap());
assert!(!read.read_bool().unwrap());
}
#[test]
@ -182,7 +182,7 @@ fn test_write_signed() {
let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
assert_eq!(true, read.read_bool().unwrap());
assert!(read.read_bool().unwrap());
assert_eq!(-17i32, read.read_int::<i32>(32).unwrap());
assert_eq!(-9i32, read.read_int::<i32>(8).unwrap());
}
@ -220,10 +220,10 @@ fn test_write_to_slice() {
let mut read = BitReadStream::from(BitReadBuffer::new(&data[..], LittleEndian));
assert_eq!(true, read.read_bool().unwrap());
assert!(read.read_bool().unwrap());
assert_eq!(3253u16, read.read::<u16>().unwrap());
assert_eq!(13253u64, read.read::<u64>().unwrap());
// 0 padded
assert_eq!(false, read.read_bool().unwrap());
assert!(!read.read_bool().unwrap());
}