Merge pull request 'Bump MSRV' (#216) from bump-msrv into main

Reviewed-on: #216

.github/workflows/ci.yml

@@ -29,7 +29,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@1.83
+      - uses: dtolnay/rust-toolchain@1.85
       - run: cargo check --release
 
   cross-check:

CHANGELOG.md

@@ -10,6 +10,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [v0.18.0] 2026-07-14
 
+- Bumped Rust version to 2024
+- Bumped MSRV to 1.85
+
 ## Changed
 
 - Added distinction between `CcsdsPacketReader::user_data` and `CcsdsPacketReader::packet_data`.

Cargo.lock

@@ -526,7 +526,7 @@ checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
 
 [[package]]
 name = "spacepackets"
-version = "0.17.0"
+version = "0.18.0"
 dependencies = [
  "arbitrary-int",
  "bitbybit",

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "spacepackets"
-version = "0.17.0"
+version = "0.18.0"
-edition = "2021"
+edition = "2024"
-rust-version = "1.83"
+rust-version = "1.85"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 description = "Generic implementations for various CCSDS and ECSS packet standards"
 homepage = "https://egit.irs.uni-stuttgart.de/rust/spacepackets"

src/cfdp/pdu/ack.rs

@@ -1,12 +1,12 @@
 //! # Acknowledgement (ACK) PDU packet implementation.
 use crate::{
-    cfdp::{ConditionCode, CrcFlag, Direction, TransactionStatus},
     ByteConversionError,
+    cfdp::{ConditionCode, CrcFlag, Direction, TransactionStatus},
 };
 
 use super::{
-    add_pdu_crc, generic_length_checks_pdu_deserialization, CfdpPdu, FileDirectiveType, PduError,
+    CfdpPdu, FileDirectiveType, PduError, PduHeader, WritablePduPacket, add_pdu_crc,
-    PduHeader, WritablePduPacket,
+    generic_length_checks_pdu_deserialization,
 };
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -228,8 +228,8 @@ impl WritablePduPacket for AckPdu {
 #[cfg(test)]
 mod tests {
     use crate::cfdp::{
-        pdu::tests::{common_pdu_conf, verify_raw_header, TEST_DEST_ID, TEST_SEQ_NUM, TEST_SRC_ID},
         LargeFileFlag, PduType, TransmissionMode,
+        pdu::tests::{TEST_DEST_ID, TEST_SEQ_NUM, TEST_SRC_ID, common_pdu_conf, verify_raw_header},
     };
 
     use super::*;

src/cfdp/pdu/eof.rs

@@ -1,11 +1,11 @@
 //! # End-of-File (EOF) PDU packet implementation.
+use crate::ByteConversionError;
 use crate::cfdp::pdu::{
-    add_pdu_crc, generic_length_checks_pdu_deserialization, read_fss_field, write_fss_field,
+    FileDirectiveType, PduError, PduHeader, add_pdu_crc, generic_length_checks_pdu_deserialization,
-    FileDirectiveType, PduError, PduHeader,
+    read_fss_field, write_fss_field,
 };
 use crate::cfdp::tlv::{EntityIdTlv, WritableTlv};
 use crate::cfdp::{ConditionCode, CrcFlag, Direction, LargeFileFlag};
-use crate::ByteConversionError;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -205,7 +205,7 @@ impl WritablePduPacket for EofPdu {
 mod tests {
     use super::*;
     use crate::cfdp::pdu::tests::{
-        common_pdu_conf, verify_raw_header, TEST_DEST_ID, TEST_SEQ_NUM, TEST_SRC_ID,
+        TEST_DEST_ID, TEST_SEQ_NUM, TEST_SRC_ID, common_pdu_conf, verify_raw_header,
     };
     use crate::cfdp::pdu::{FileDirectiveType, PduHeader};
     use crate::cfdp::{ConditionCode, CrcFlag, LargeFileFlag, PduType, TransmissionMode};

src/cfdp/pdu/file_data.rs

@@ -1,10 +1,10 @@
 //! # File Data PDU packet implementation
+use crate::ByteConversionError;
 use crate::cfdp::pdu::{
-    add_pdu_crc, generic_length_checks_pdu_deserialization, read_fss_field, write_fss_field,
+    PduError, PduHeader, add_pdu_crc, generic_length_checks_pdu_deserialization, read_fss_field,
-    PduError, PduHeader,
+    write_fss_field,
 };
 use crate::cfdp::{CrcFlag, LargeFileFlag, PduType, SegmentMetadataFlag};
-use crate::ByteConversionError;
 use num_enum::{IntoPrimitive, TryFromPrimitive};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};

src/cfdp/pdu/finished.rs

@@ -1,12 +1,12 @@
 //! # Finished PDU packet implementation.
+use crate::ByteConversionError;
 use crate::cfdp::pdu::{
-    add_pdu_crc, generic_length_checks_pdu_deserialization, FileDirectiveType, PduError, PduHeader,
+    FileDirectiveType, PduError, PduHeader, add_pdu_crc, generic_length_checks_pdu_deserialization,
 };
 use crate::cfdp::tlv::{
     EntityIdTlv, FilestoreResponseTlv, GenericTlv, Tlv, TlvType, TlvTypeField, WritableTlv,
 };
 use crate::cfdp::{ConditionCode, CrcFlag, Direction, PduType};
-use crate::ByteConversionError;
 use num_enum::{IntoPrimitive, TryFromPrimitive};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -453,7 +453,7 @@ mod tests {
     use super::*;
     use crate::cfdp::lv::Lv;
     use crate::cfdp::pdu::tests::{
-        common_pdu_conf, verify_raw_header, TEST_DEST_ID, TEST_SEQ_NUM, TEST_SRC_ID,
+        TEST_DEST_ID, TEST_SEQ_NUM, TEST_SRC_ID, common_pdu_conf, verify_raw_header,
     };
     use crate::cfdp::pdu::{FileDirectiveType, PduHeader};
     use crate::cfdp::tlv::FilestoreResponseTlv;

src/cfdp/pdu/metadata.rs

@@ -1,14 +1,14 @@
 //! # Metadata PDU packet implementation.
 #[cfg(feature = "alloc")]
 use super::tlv::TlvOwned;
+use crate::ByteConversionError;
 use crate::cfdp::lv::Lv;
 use crate::cfdp::pdu::{
-    add_pdu_crc, generic_length_checks_pdu_deserialization, read_fss_field, write_fss_field,
+    FileDirectiveType, PduError, PduHeader, add_pdu_crc, generic_length_checks_pdu_deserialization,
-    FileDirectiveType, PduError, PduHeader,
+    read_fss_field, write_fss_field,
 };
 use crate::cfdp::tlv::{Tlv, WritableTlv};
 use crate::cfdp::{ChecksumType, CrcFlag, Direction, LargeFileFlag, PduType};
-use crate::ByteConversionError;
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
 #[cfg(feature = "serde")]
@@ -418,11 +418,11 @@ mod tests {
 
     use crate::cfdp::lv::Lv;
     use crate::cfdp::pdu::metadata::{
-        build_metadata_opts_from_slice, build_metadata_opts_from_vec, MetadataGenericParams,
+        MetadataGenericParams, MetadataPduCreator, MetadataPduReader,
-        MetadataPduCreator, MetadataPduReader,
+        build_metadata_opts_from_slice, build_metadata_opts_from_vec,
     };
     use crate::cfdp::pdu::tests::{
-        common_pdu_conf, verify_raw_header, TEST_DEST_ID, TEST_SEQ_NUM, TEST_SRC_ID,
+        TEST_DEST_ID, TEST_SEQ_NUM, TEST_SRC_ID, common_pdu_conf, verify_raw_header,
     };
     use crate::cfdp::pdu::{CfdpPdu, PduError, WritablePduPacket};
     use crate::cfdp::pdu::{FileDirectiveType, PduHeader};

src/cfdp/pdu/mod.rs

@@ -1,10 +1,10 @@
 //! CFDP Packet Data Unit (PDU) support.
+use crate::ByteConversionError;
 use crate::cfdp::pdu::ack::InvalidAckedDirectiveCodeError;
 use crate::cfdp::pdu::nak::InvalidStartOrEndOfScopeError;
 use crate::cfdp::*;
 use crate::crc::CRC_CCITT_FALSE;
 use crate::util::{UnsignedByteField, UnsignedByteFieldU8, UnsignedEnum};
-use crate::ByteConversionError;
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
 
@@ -725,15 +725,15 @@ pub(crate) fn add_pdu_crc(buf: &mut [u8], mut current_idx: usize) -> usize {
 mod tests {
     use alloc::string::ToString;
 
-    use crate::cfdp::pdu::{CommonPduConfig, PduError, PduHeader, FIXED_HEADER_LEN};
+    use crate::ByteConversionError;
+    use crate::cfdp::pdu::{CommonPduConfig, FIXED_HEADER_LEN, PduError, PduHeader};
     use crate::cfdp::{
-        CrcFlag, Direction, LargeFileFlag, PduType, SegmentMetadataFlag, SegmentationControl,
+        CFDP_VERSION_2, CrcFlag, Direction, LargeFileFlag, PduType, SegmentMetadataFlag,
-        TransmissionMode, CFDP_VERSION_2,
+        SegmentationControl, TransmissionMode,
     };
     use crate::util::{
-        UbfU16, UbfU8, UnsignedByteField, UnsignedByteFieldU16, UnsignedByteFieldU8, UnsignedEnum,
+        UbfU8, UbfU16, UnsignedByteField, UnsignedByteFieldU8, UnsignedByteFieldU16, UnsignedEnum,
     };
-    use crate::ByteConversionError;
     use std::format;
 
     pub(crate) const TEST_SRC_ID: UbfU8 = UbfU8::new(5);

src/cfdp/pdu/nak.rs

@@ -1,12 +1,12 @@
 //! # NAK PDU packet implementation.
 use crate::{
-    cfdp::{CrcFlag, Direction, LargeFileFlag},
     ByteConversionError,
+    cfdp::{CrcFlag, Direction, LargeFileFlag},
 };
 
 use super::{
-    add_pdu_crc, generic_length_checks_pdu_deserialization, CfdpPdu, FileDirectiveType, PduError,
+    CfdpPdu, FileDirectiveType, PduError, PduHeader, WritablePduPacket, add_pdu_crc,
-    PduHeader, WritablePduPacket,
+    generic_length_checks_pdu_deserialization,
 };
 
 /// Invalid start or end of scope value.
@@ -761,8 +761,8 @@ mod tests {
     use alloc::string::ToString;
 
     use crate::cfdp::{
-        pdu::tests::{common_pdu_conf, verify_raw_header, TEST_DEST_ID, TEST_SEQ_NUM, TEST_SRC_ID},
         PduType, TransmissionMode,
+        pdu::tests::{TEST_DEST_ID, TEST_SEQ_NUM, TEST_SRC_ID, common_pdu_conf, verify_raw_header},
     };
 
     use super::*;

src/cfdp/tlv/mod.rs

@@ -1,10 +1,10 @@
 //! Generic CFDP type-length-value (TLV) abstraction as specified in CFDP 5.1.9.
-use crate::cfdp::lv::{
-    generic_len_check_data_serialization, generic_len_check_deserialization, Lv, MIN_LV_LEN,
-};
-use crate::cfdp::TlvLvError;
-use crate::util::{UnsignedByteField, UnsignedByteFieldError, UnsignedEnum};
 use crate::ByteConversionError;
+use crate::cfdp::TlvLvError;
+use crate::cfdp::lv::{
+    Lv, MIN_LV_LEN, generic_len_check_data_serialization, generic_len_check_deserialization,
+};
+use crate::util::{UnsignedByteField, UnsignedByteFieldError, UnsignedEnum};
 #[cfg(feature = "alloc")]
 use alloc::vec;
 #[cfg(feature = "alloc")]
@@ -1015,10 +1015,10 @@ pub(crate) fn verify_tlv_type(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::cfdp::TlvLvError;
     use crate::cfdp::lv::Lv;
     use crate::cfdp::tlv::{FilestoreActionCode, FilestoreRequestTlv, Tlv, TlvType, TlvTypeField};
-    use crate::cfdp::TlvLvError;
+    use crate::util::{UbfU8, UbfU16, UnsignedEnum};
-    use crate::util::{UbfU16, UbfU8, UnsignedEnum};
     use alloc::string::ToString;
 
     const TLV_TEST_STR_0: &str = "hello.txt";

src/cfdp/tlv/msg_to_user.rs

@@ -3,8 +3,8 @@
 use super::TlvOwned;
 use super::{GenericTlv, ReadableTlv, Tlv, TlvLvError, TlvType, TlvTypeField, WritableTlv};
 use crate::{
-    cfdp::{InvalidTlvTypeFieldError, TlvLvDataTooLargeError},
     ByteConversionError,
+    cfdp::{InvalidTlvTypeFieldError, TlvLvDataTooLargeError},
 };
 use delegate::delegate;
 

src/ecss/mod.rs

@@ -4,8 +4,8 @@
 //! You can find the PUS telecommand types in the [tc] module and the the PUS telemetry
 //! types inside the [tm] module.
 use crate::{
-    crc::{CRC_CCITT_FALSE, CRC_CCITT_FALSE_NO_TABLE},
     ByteConversionError, CcsdsPacket,
+    crc::{CRC_CCITT_FALSE, CRC_CCITT_FALSE_NO_TABLE},
 };
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
@@ -529,8 +529,8 @@ impl Default for CreatorConfig {
 mod tests {
     use alloc::string::ToString;
 
-    use crate::ecss::{EcssEnumU16, EcssEnumU32, EcssEnumU8, UnsignedEnum};
     use crate::ByteConversionError;
+    use crate::ecss::{EcssEnumU8, EcssEnumU16, EcssEnumU32, UnsignedEnum};
 
     use super::*;
     #[cfg(feature = "serde")]

src/ecss/tc.rs

@@ -42,15 +42,14 @@
 //! assert_eq!(pus_tc_by_builder, pus_tc);
 //! ```
 use crate::crc::{CRC_CCITT_FALSE, CRC_CCITT_FALSE_NO_TABLE};
-use crate::ecss::{
-    crc_from_raw_data, sp_header_impls, user_data_from_raw,
-    verify_crc16_ccitt_false_from_raw_to_pus_error, PusError, PusPacket, PusVersion,
-    WritablePusPacket,
-};
 pub use crate::ecss::{CreatorConfig, MessageTypeId};
-use crate::{ByteConversionError, CcsdsPacket, PacketType, SequenceFlags, CCSDS_HEADER_LEN};
+use crate::ecss::{
+    PusError, PusPacket, PusVersion, WritablePusPacket, crc_from_raw_data, sp_header_impls,
+    user_data_from_raw, verify_crc16_ccitt_false_from_raw_to_pus_error,
+};
+use crate::{ByteConversionError, CCSDS_HEADER_LEN, CcsdsPacket, PacketType, SequenceFlags};
 use crate::{PacketId, PacketSequenceControl, SpHeader};
-use arbitrary_int::{u11, u14, u3, u4};
+use arbitrary_int::{u3, u4, u11, u14};
 use core::mem::size_of;
 use delegate::delegate;
 #[cfg(feature = "serde")]
@@ -133,7 +132,7 @@ pub mod zc {
     use crate::ecss::{MessageTypeId, PusError, PusVersion};
     use arbitrary_int::traits::Integer;
     use arbitrary_int::u4;
-    use zerocopy::{FromBytes, Immutable, IntoBytes, NetworkEndian, Unaligned, U16};
+    use zerocopy::{FromBytes, Immutable, IntoBytes, NetworkEndian, U16, Unaligned};
 
     /// PUS TC secondary header.
     #[derive(FromBytes, IntoBytes, Immutable, Unaligned)]

src/ecss/tc_pus_a.rs

@@ -33,17 +33,16 @@
 //! assert_eq!(pus_tc.message_subtype_id(), 1);
 //! assert_eq!(pus_tc.apid().value(), 0x02);
 //! ```
+use crate::SpHeader;
 use crate::crc::{CRC_CCITT_FALSE, CRC_CCITT_FALSE_NO_TABLE};
-use crate::ecss::tc::{AckFlags, ACK_ALL};
+use crate::ecss::tc::{ACK_ALL, AckFlags};
 use crate::ecss::{
-    crc_from_raw_data, sp_header_impls, user_data_from_raw,
+    MessageTypeId, PusError, PusPacket, PusVersion, WritablePusPacket, crc_from_raw_data,
-    verify_crc16_ccitt_false_from_raw_to_pus_error, MessageTypeId, PusError, PusPacket, PusVersion,
+    sp_header_impls, user_data_from_raw, verify_crc16_ccitt_false_from_raw_to_pus_error,
-    WritablePusPacket,
 };
 use crate::util::{UnsignedByteField, UnsignedEnum};
-use crate::SpHeader;
+use crate::{ByteConversionError, CCSDS_HEADER_LEN, CcsdsPacket, PacketType, SequenceFlags};
-use crate::{ByteConversionError, CcsdsPacket, PacketType, SequenceFlags, CCSDS_HEADER_LEN};
+use arbitrary_int::{u3, u4, u11, u14};
-use arbitrary_int::{u11, u14, u3, u4};
 use core::mem::size_of;
 use delegate::delegate;
 use num_enum::{IntoPrimitive, TryFromPrimitive};
@@ -922,7 +921,7 @@ mod tests {
 
     use super::*;
     use crate::ecss::{PusError, PusPacket, WritablePusPacket};
-    use crate::util::{UnsignedByteFieldU16, UnsignedByteFieldU8};
+    use crate::util::{UnsignedByteFieldU8, UnsignedByteFieldU16};
     use crate::{ByteConversionError, SpHeader};
     use crate::{CcsdsPacket, SequenceFlags};
     use alloc::string::ToString;

src/ecss/tm.rs

@@ -51,18 +51,17 @@
 //! assert_eq!(pus_tm_by_builder, ping_tm);
 //! ```
 use crate::crc::{CRC_CCITT_FALSE, CRC_CCITT_FALSE_NO_TABLE};
-use crate::ecss::{
-    calc_pus_crc16, crc_from_raw_data, sp_header_impls, user_data_from_raw,
-    verify_crc16_ccitt_false_from_raw_to_pus_error, PusError, PusPacket, PusVersion,
-    WritablePusPacket,
-};
 pub use crate::ecss::{CreatorConfig, MessageTypeId};
+use crate::ecss::{
+    PusError, PusPacket, PusVersion, WritablePusPacket, calc_pus_crc16, crc_from_raw_data,
+    sp_header_impls, user_data_from_raw, verify_crc16_ccitt_false_from_raw_to_pus_error,
+};
 use crate::{
-    ByteConversionError, CcsdsPacket, PacketId, PacketSequenceControl, PacketType, SequenceFlags,
+    ByteConversionError, CCSDS_HEADER_LEN, CcsdsPacket, MAX_APID, PacketId, PacketSequenceControl,
-    SpHeader, CCSDS_HEADER_LEN, MAX_APID,
+    PacketType, SequenceFlags, SpHeader,
 };
 use arbitrary_int::traits::Integer;
-use arbitrary_int::{u11, u14, u3, u4};
+use arbitrary_int::{u3, u4, u11, u14};
 use core::mem::size_of;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -118,7 +117,7 @@ pub mod zc {
     use super::GenericPusTmSecondaryHeader;
     use crate::ecss::{MessageTypeId, PusError, PusVersion};
     use arbitrary_int::{traits::Integer as _, u4};
-    use zerocopy::{FromBytes, Immutable, IntoBytes, NetworkEndian, Unaligned, U16};
+    use zerocopy::{FromBytes, Immutable, IntoBytes, NetworkEndian, U16, Unaligned};
 
     /// PUS TM secondary header without a timestamp.
     #[derive(FromBytes, IntoBytes, Immutable, Unaligned)]
@@ -1490,11 +1489,11 @@ impl GenericPusTmSecondaryHeader for PusTmZeroCopyWriter<'_> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::time::cds::CdsTime;
+    use crate::SpHeader;
     #[cfg(feature = "serde")]
     use crate::time::CcsdsTimeProvider;
-    use crate::SpHeader;
+    use crate::time::cds::CdsTime;
-    use crate::{ecss::PusVersion::PusC, MAX_SEQ_COUNT};
+    use crate::{MAX_SEQ_COUNT, ecss::PusVersion::PusC};
     use alloc::string::ToString;
     #[cfg(feature = "serde")]
     use postcard::{from_bytes, to_allocvec};

src/ecss/tm_pus_a.rs

@@ -50,17 +50,17 @@
 use crate::crc::{CRC_CCITT_FALSE, CRC_CCITT_FALSE_NO_TABLE};
 use crate::ecss::tm::IsPusTelemetry;
 use crate::ecss::{
-    calc_pus_crc16, crc_from_raw_data, sp_header_impls, user_data_from_raw,
+    CrcType, MessageTypeId, PusError, PusPacket, PusVersion, WritablePusPacket, calc_pus_crc16,
-    verify_crc16_ccitt_false_from_raw_to_pus_error, CrcType, MessageTypeId, PusError, PusPacket,
+    crc_from_raw_data, sp_header_impls, user_data_from_raw,
-    PusVersion, WritablePusPacket,
+    verify_crc16_ccitt_false_from_raw_to_pus_error,
 };
 use crate::util::{UnsignedByteField, UnsignedEnum};
 use crate::{
-    ByteConversionError, CcsdsPacket, PacketType, SequenceFlags, SpHeader, CCSDS_HEADER_LEN,
+    ByteConversionError, CCSDS_HEADER_LEN, CcsdsPacket, MAX_APID, PacketType, SequenceFlags,
-    MAX_APID,
+    SpHeader,
 };
 use arbitrary_int::traits::Integer;
-use arbitrary_int::{u11, u14, u3, u4};
+use arbitrary_int::{u3, u4, u11, u14};
 use core::mem::size_of;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -1232,8 +1232,8 @@ mod tests {
 
     use super::*;
     use crate::time::cds::CdsTime;
+    use crate::{MAX_SEQ_COUNT, SpHeader};
     use crate::{ecss::PusVersion::PusA, util::UnsignedByteFieldU16};
-    use crate::{SpHeader, MAX_SEQ_COUNT};
     #[cfg(feature = "serde")]
     use postcard::{from_bytes, to_allocvec};
 

src/lib.rs

@@ -784,7 +784,7 @@ pub mod zc {
     use arbitrary_int::traits::Integer;
     use arbitrary_int::u3;
     use zerocopy::byteorder::NetworkEndian;
-    use zerocopy::{FromBytes, Immutable, IntoBytes, Unaligned, U16};
+    use zerocopy::{FromBytes, Immutable, IntoBytes, U16, Unaligned};
 
     /// [zerocopy] space packet header.
     #[derive(FromBytes, IntoBytes, Immutable, Unaligned, Debug)]
@@ -1852,11 +1852,11 @@ pub(crate) mod tests {
     use std::collections::HashSet;
 
     use super::*;
-    use crate::crc::CRC_CCITT_FALSE;
     #[allow(unused_imports)]
     use crate::ByteConversionError;
     #[cfg(feature = "serde")]
     use crate::CcsdsPrimaryHeader;
+    use crate::crc::CRC_CCITT_FALSE;
     use crate::{SequenceFlags, SpHeader};
     use alloc::vec;
     use arbitrary_int::{u11, u14};
@@ -1865,7 +1865,7 @@ pub(crate) mod tests {
     #[cfg(feature = "serde")]
     use postcard::{from_bytes, to_allocvec};
     #[cfg(feature = "serde")]
-    use serde::{de::DeserializeOwned, Serialize};
+    use serde::{Serialize, de::DeserializeOwned};
     use zerocopy::FromBytes;
 
     const CONST_SP: SpHeader = SpHeader::new(
@@ -2223,17 +2223,18 @@ pub(crate) mod tests {
     #[test]
     fn test_ccsds_size_function_invalid_size_with_checksum() {
         // 2 less bytes available because of the checksum.
-        assert!(ccsds_packet_len_for_user_data_len(
+        assert!(
-            u16::MAX as usize - 1,
+            ccsds_packet_len_for_user_data_len(
-            Some(ChecksumType::WithCrc16)
+                u16::MAX as usize - 1,
-        )
+                Some(ChecksumType::WithCrc16)
-        .is_some());
+            )
+            .is_some()
+        );
         // This is too much.
-        assert!(ccsds_packet_len_for_user_data_len(
+        assert!(
-            u16::MAX as usize,
+            ccsds_packet_len_for_user_data_len(u16::MAX as usize, Some(ChecksumType::WithCrc16))
-            Some(ChecksumType::WithCrc16)
+                .is_none()
-        )
+        );
-        .is_none());
     }
 
     #[test]

src/seq_count.rs

@@ -492,17 +492,17 @@ pub mod std_mod {
     }
 
     impl<
-            Inner: SequenceCounter<Raw = RawTy>,
+        Inner: SequenceCounter<Raw = RawTy>,
-            RawTy: core::fmt::Debug
+        RawTy: core::fmt::Debug
-                + Copy
+            + Copy
-                + Clone
+            + Clone
-                + Into<u64>
+            + Into<u64>
-                + TryFrom<u64>
+            + TryFrom<u64>
-                + FromStr
+            + FromStr
-                + Default
+            + Default
-                + PartialEq
+            + PartialEq
-                + Eq,
+            + Eq,
-        > SequenceCounterOnFile<Inner, RawTy>
+    > SequenceCounterOnFile<Inner, RawTy>
     {
         /// Initialize a new persistent sequence counter using a file at the given path and
         /// any non persistent inner [SequenceCounter] implementation.
@@ -549,17 +549,17 @@ pub mod std_mod {
     }
 
     impl<
-            Inner: SequenceCounter<Raw = RawTy>,
+        Inner: SequenceCounter<Raw = RawTy>,
-            RawTy: core::fmt::Debug
+        RawTy: core::fmt::Debug
-                + Copy
+            + Copy
-                + Clone
+            + Clone
-                + Into<u64>
+            + Into<u64>
-                + TryFrom<u64, Error: core::fmt::Debug>
+            + TryFrom<u64, Error: core::fmt::Debug>
-                + FromStr
+            + FromStr
-                + Default
+            + Default
-                + PartialEq
+            + PartialEq
-                + Eq,
+            + Eq,
-        > SequenceCounter for SequenceCounterOnFile<Inner, RawTy>
+    > SequenceCounter for SequenceCounterOnFile<Inner, RawTy>
     {
         type Raw = RawTy;
 
@@ -590,17 +590,17 @@ pub mod std_mod {
     }
 
     impl<
-            Inner: SequenceCounter<Raw = RawTy>,
+        Inner: SequenceCounter<Raw = RawTy>,
-            RawTy: core::fmt::Debug
+        RawTy: core::fmt::Debug
-                + Copy
+            + Copy
-                + Clone
+            + Clone
-                + Into<u64>
+            + Into<u64>
-                + TryFrom<u64>
+            + TryFrom<u64>
-                + FromStr
+            + FromStr
-                + Default
+            + Default
-                + PartialEq
+            + PartialEq
-                + Eq,
+            + Eq,
-        > Drop for SequenceCounterOnFile<Inner, RawTy>
+    > Drop for SequenceCounterOnFile<Inner, RawTy>
     {
         fn drop(&mut self) {
             if self.save_on_drop {
@@ -632,14 +632,14 @@ pub mod std_mod {
 
 #[cfg(test)]
 mod tests {
-    use core::sync::atomic::{AtomicU16, AtomicU32, AtomicU64, AtomicU8};
+    use core::sync::atomic::{AtomicU8, AtomicU16, AtomicU32, AtomicU64};
     use std::boxed::Box;
 
+    use crate::MAX_SEQ_COUNT;
     use crate::seq_count::{
         SequenceCounter, SequenceCounterCcsdsSimple, SequenceCounterSimple,
         SequenceCounterSyncCustomWrapU8,
     };
-    use crate::MAX_SEQ_COUNT;
 
     #[test]
     fn test_u8_counter() {

src/time/ascii.rs

@@ -36,8 +36,8 @@ pub const FMT_STR_CODE_B_TERMINATED_WITH_SIZE: (&str, usize) = ("%Y-%jT%T%.3fZ",
 pub mod alloc_mod_chrono {
     use super::*;
     use chrono::{
-        format::{DelayedFormat, StrftimeItems},
         DateTime, Utc,
+        format::{DelayedFormat, StrftimeItems},
     };
 
     /// Generates a time code formatter using the [FMT_STR_CODE_A_WITH_SIZE] format.

src/time/cds.rs

@@ -4,8 +4,8 @@
 //! The core data structure to do this is the [CdsTime] struct and the
 //! [get_dyn_time_provider_from_bytes] function to retrieve correct instances of the
 //! struct from a bytestream.
-use crate::private::Sealed;
 use crate::ByteConversionError;
+use crate::private::Sealed;
 use core::cmp::Ordering;
 use core::fmt::Debug;
 use core::ops::{Add, AddAssign};
@@ -30,9 +30,8 @@ use core::any::Any;
 use serde::{Deserialize, Serialize};
 
 use super::{
-    ccsds_to_unix_days, unix_to_ccsds_days, CcsdsTimeCode, CcsdsTimeProvider,
+    CcsdsTimeCode, CcsdsTimeProvider, DateBeforeCcsdsEpochError, MS_PER_DAY, SECONDS_PER_DAY,
-    DateBeforeCcsdsEpochError, TimeReader, TimeWriter, TimestampError, UnixTime, MS_PER_DAY,
+    TimeReader, TimeWriter, TimestampError, UnixTime, ccsds_to_unix_days, unix_to_ccsds_days,
-    SECONDS_PER_DAY,
 };
 
 /// Base value for the preamble field for a time field parser to determine the time field type.
@@ -1314,9 +1313,9 @@ impl CdsTimestamp for CdsTime<DaysLen24Bits> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::time::TimestampError::{ByteConversion, InvalidTimeCode};
-    use crate::time::{UnixTime, DAYS_CCSDS_TO_UNIX, MS_PER_DAY};
     use crate::ByteConversionError::FromSliceTooSmall;
+    use crate::time::TimestampError::{ByteConversion, InvalidTimeCode};
+    use crate::time::{DAYS_CCSDS_TO_UNIX, MS_PER_DAY, UnixTime};
     use alloc::string::ToString;
     use chrono::{Datelike, NaiveDate, Timelike};
     #[cfg(feature = "serde")]

src/time/cuc.rs

@@ -15,9 +15,9 @@ use crate::ByteConversionError;
 #[cfg(feature = "std")]
 use super::StdTimestampError;
 use super::{
-    ccsds_epoch_to_unix_epoch, ccsds_time_code_from_p_field, unix_epoch_to_ccsds_epoch,
     CcsdsTimeCode, CcsdsTimeProvider, DateBeforeCcsdsEpochError, TimeReader, TimeWriter,
-    TimestampError, UnixTime,
+    TimestampError, UnixTime, ccsds_epoch_to_unix_epoch, ccsds_time_code_from_p_field,
+    unix_epoch_to_ccsds_epoch,
 };
 #[cfg(feature = "std")]
 use std::time::SystemTime;
@@ -884,7 +884,7 @@ impl Add<Duration> for &CucTime {
 
 #[cfg(test)]
 mod tests {
-    use crate::time::{UnixTime, DAYS_CCSDS_TO_UNIX, SECONDS_PER_DAY};
+    use crate::time::{DAYS_CCSDS_TO_UNIX, SECONDS_PER_DAY, UnixTime};
 
     use super::*;
     use alloc::string::ToString;

src/time/mod.rs

@@ -431,14 +431,14 @@ impl Ord for UnixTime {
                     Ordering::Greater
                 } else {
                     Ordering::Less
-                }
+                };
             }
             Ordering::Greater => {
                 return if self.secs < 0 {
                     Ordering::Less
                 } else {
                     Ordering::Greater
-                }
+                };
             }
             Ordering::Equal => (),
         }

src/uslp/mod.rs

@@ -3,7 +3,7 @@
 
 use arbitrary_int::{prelude::*, u4, u6};
 
-use crate::{crc::CRC_CCITT_FALSE, ByteConversionError};
+use crate::{ByteConversionError, crc::CRC_CCITT_FALSE};
 
 /// Only this version is supported by the library
 pub const USLP_VERSION_NUMBER: u8 = 0b1100;

src/util.rs

@@ -384,11 +384,11 @@ impl TryFrom<UnsignedByteField> for UnsignedByteFieldU64 {
 
 #[cfg(test)]
 mod tests {
-    use crate::util::{
-        UnsignedByteField, UnsignedByteFieldError, UnsignedByteFieldU16, UnsignedByteFieldU32,
-        UnsignedByteFieldU64, UnsignedByteFieldU8, UnsignedEnum,
-    };
     use crate::ByteConversionError;
+    use crate::util::{
+        UnsignedByteField, UnsignedByteFieldError, UnsignedByteFieldU8, UnsignedByteFieldU16,
+        UnsignedByteFieldU32, UnsignedByteFieldU64, UnsignedEnum,
+    };
     use std::format;
 
     #[test]