diff --git a/src/fixed_tests.rs b/src/fixed_tests.rs index 4235cdd..210770c 100644 --- a/src/fixed_tests.rs +++ b/src/fixed_tests.rs @@ -12,63 +12,63 @@ mod tests { #[test] fn test_u32_enc() { - let result = (32 as u32).encode_fixed_vec(); + let result = 32_u32.encode_fixed_vec(); assert_eq!(result, vec![32, 0, 0, 0]); } #[test] fn test_u16_enc() { - let result = (256 as u16).encode_fixed_vec(); + let result = 256_u16.encode_fixed_vec(); assert_eq!(result, vec![0, 1]); } #[test] fn test_u16_endian() { - let le = 1 as u16; + let le = 1_u16; let be = le.switch_endianness(); assert_eq!(be, 256); } #[test] fn test_u32_endian() { - let le = 1 as u32; + let le = 1_u32; let be = le.switch_endianness(); assert_eq!(be, 1 << 24); assert_eq!(be.switch_endianness(), 1); } #[test] - fn test_allones_endian() { + fn test_all_ones_endian() { assert_eq!(u64::MAX.switch_endianness(), u64::MAX); } #[test] fn test_signed_endian() { // x86: two's complement, LE. - let le = -2 as i16; + let le = -2_i16; let be = le.switch_endianness(); assert_eq!(be, -257); } #[test] fn test_u8_enc() { - let result = (255 as u8).encode_fixed_vec(); + let result = 255_u8.encode_fixed_vec(); assert_eq!(result, vec![255]); } #[test] fn test_i8_enc() { - let result = (-1 as i8).encode_fixed_vec(); + let result = (-1_i8).encode_fixed_vec(); assert_eq!(result, vec![255]); } #[test] fn test_i16_enc() { - let result = (-32768 as i16).encode_fixed_vec(); + let result = (-32768_i16).encode_fixed_vec(); assert_eq!(result, vec![0, 128]); } #[test] fn test_i32_enc() { - let result = (-32767 as i32).encode_fixed_vec(); + let result = (-32767_i32).encode_fixed_vec(); assert_eq!(result, vec![1, 128, 255, 255]); } // This must fail to compile: /* fn test() -> &'static [u8] { - let int = -32767 as i32; + let int = -32767_i32; let result = int.encode_fixed_light(); assert_eq!(result, &[1, 128, 255, 255]); result @@ -77,7 +77,7 @@ mod tests { #[test] fn test_i32_enc_light() { - let int = -32767 as i32; + let int = -32767_i32; let result = int.encode_fixed_light(); assert_eq!(result, [1, 128, 255, 255]); } @@ -137,8 +137,8 @@ mod tests { #[should_panic] #[test] fn test_invalid_encode_size() { - let mut buf = [0 as u8; 4]; - (11 as u64).encode_fixed(&mut buf).unwrap(); + let mut buf = [0_u8; 4]; + 11_u64.encode_fixed(&mut buf).unwrap(); } #[cfg(any(feature = "tokio_async", feature = "futures_async"))] diff --git a/src/varint.rs b/src/varint.rs index 61032d2..96e8ad6 100644 --- a/src/varint.rs +++ b/src/varint.rs @@ -2,7 +2,7 @@ use std::mem::size_of; /// Most-significant byte, == 0x80 pub const MSB: u8 = 0b1000_0000; -/// All bits except for the most significant. Can be used as bitmask to drop the most-signficant +/// All bits except for the most significant. Can be used as bitmask to drop the most-significant /// bit using `&` (binary-and). const DROP_MSB: u8 = 0b0111_1111; @@ -134,9 +134,9 @@ impl VarInt for u64 { let mut shift = 0; let mut success = false; - for b in src.iter() { + for b in src { let msb_dropped = b & DROP_MSB; - result |= (msb_dropped as u64) << shift; + result |= u64::from(msb_dropped) << shift; shift += 7; if b & MSB == 0 || shift > (9 * 7) { @@ -177,7 +177,7 @@ impl VarInt for i64 { #[inline] fn decode_var(src: &[u8]) -> Option<(Self, usize)> { if let Some((result, size)) = u64::decode_var(src) { - Some((zigzag_decode(result) as Self, size)) + Some((zigzag_decode(result), size)) } else { None } diff --git a/src/varint_tests.rs b/src/varint_tests.rs index 7a543a7..75feb83 100644 --- a/src/varint_tests.rs +++ b/src/varint_tests.rs @@ -11,29 +11,29 @@ mod tests { #[test] fn test_required_space() { - assert_eq!((0 as u32).required_space(), 1); - assert_eq!((1 as u32).required_space(), 1); - assert_eq!((128 as u32).required_space(), 2); - assert_eq!((16384 as u32).required_space(), 3); - assert_eq!((2097151 as u32).required_space(), 3); - assert_eq!((2097152 as u32).required_space(), 4); + assert_eq!(0_u32.required_space(), 1); + assert_eq!(1_u32.required_space(), 1); + assert_eq!(128_u32.required_space(), 2); + assert_eq!(16384_u32.required_space(), 3); + assert_eq!(2097151_u32.required_space(), 3); + assert_eq!(2097152_u32.required_space(), 4); } #[test] fn test_encode_u64() { - assert_eq!((0 as u32).encode_var_vec(), vec![0b00000000]); - assert_eq!((300 as u32).encode_var_vec(), vec![0b10101100, 0b00000010]); + assert_eq!(0_u32.encode_var_vec(), vec![0b00000000]); + assert_eq!(300_u32.encode_var_vec(), vec![0b10101100, 0b00000010]); } #[test] fn test_identity_u64() { - for i in 1 as u64..100 { + for i in 1_u64..100 { assert_eq!( u64::decode_var(i.encode_var_vec().as_slice()).unwrap(), (i, 1) ); } - for i in 16400 as u64..16500 { + for i in 16400_u64..16500 { assert_eq!( u64::decode_var(i.encode_var_vec().as_slice()).unwrap(), (i, 3) @@ -46,28 +46,25 @@ mod tests { let max_vec_encoded = vec![0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01]; assert_eq!( u64::decode_var(max_vec_encoded.as_slice()).unwrap().0, - u64::max_value() + u64::MAX ); } #[test] fn test_encode_i64() { - assert_eq!((0 as i64).encode_var_vec(), (0 as u32).encode_var_vec()); - assert_eq!((150 as i64).encode_var_vec(), (300 as u32).encode_var_vec()); + assert_eq!(0_i64.encode_var_vec(), 0_u32.encode_var_vec()); + assert_eq!(150_i64.encode_var_vec(), 300_u32.encode_var_vec()); + assert_eq!((-150_i64).encode_var_vec(), 299_u32.encode_var_vec()); assert_eq!( - (-150 as i64).encode_var_vec(), - (299 as u32).encode_var_vec() + (-2147483648_i64).encode_var_vec(), + 4294967295_u64.encode_var_vec() ); assert_eq!( - (-2147483648 as i64).encode_var_vec(), - (4294967295 as u64).encode_var_vec() - ); - assert_eq!( - (i64::max_value() as i64).encode_var_vec(), + i64::MAX.encode_var_vec(), &[0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01] ); assert_eq!( - (i64::min_value() as i64).encode_var_vec(), + i64::MIN.encode_var_vec(), &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01] ); } @@ -77,7 +74,7 @@ mod tests { let min_vec_encoded = vec![0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01]; assert_eq!( i64::decode_var(min_vec_encoded.as_slice()).unwrap().0, - i64::min_value() + i64::MIN ); } @@ -86,17 +83,14 @@ mod tests { let max_vec_encoded = vec![0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01]; assert_eq!( i64::decode_var(max_vec_encoded.as_slice()).unwrap().0, - i64::max_value() + i64::MAX ); } #[test] fn test_encode_i16() { - assert_eq!((150 as i16).encode_var_vec(), (300 as u32).encode_var_vec()); - assert_eq!( - (-150 as i16).encode_var_vec(), - (299 as u32).encode_var_vec() - ); + assert_eq!(150_i16.encode_var_vec(), 300_u32.encode_var_vec()); + assert_eq!((-150_i16).encode_var_vec(), 299_u32.encode_var_vec()); } #[test] @@ -155,7 +149,7 @@ mod tests { #[test] fn test_unterminated_varint() { - let buf = vec![0xff as u8; 12]; + let buf = vec![0xff_u8; 12]; let mut read = buf.as_slice(); assert!(read.read_varint::().is_err()); } @@ -203,7 +197,7 @@ mod tests { #[test] fn test_regression_22() { - let encoded: Vec = (0x112233 as u64).encode_var_vec(); + let encoded: Vec = 0x112233_u64.encode_var_vec(); assert_eq!( encoded.as_slice().read_varint::().unwrap_err().kind(), std::io::ErrorKind::InvalidData diff --git a/src/writer.rs b/src/writer.rs index 3671980..224b6e3 100644 --- a/src/writer.rs +++ b/src/writer.rs @@ -60,18 +60,18 @@ pub trait FixedIntAsyncWriter { impl FixedIntAsyncWriter for AW { async fn write_fixedint_async(&mut self, n: FI) -> Result { let mut buf = [0_u8; 8]; - n.encode_fixed(&mut buf[..std::mem::size_of::()]); - self.write_all(&buf[..std::mem::size_of::()]).await?; - Ok(std::mem::size_of::()) + n.encode_fixed(&mut buf[..size_of::()]); + self.write_all(&buf[..size_of::()]).await?; + Ok(size_of::()) } } impl FixedIntWriter for W { fn write_fixedint(&mut self, n: FI) -> Result { let mut buf = [0_u8; 8]; - n.encode_fixed(&mut buf[..std::mem::size_of::()]); + n.encode_fixed(&mut buf[..size_of::()]); - self.write_all(&buf[..std::mem::size_of::()])?; - Ok(std::mem::size_of::()) + self.write_all(&buf[..size_of::()])?; + Ok(size_of::()) } }