//! This module contains the implementation of the CCSDS File Delivery Protocol (CFDP) high level

//! abstractions as specified in CCSDS 727.0-B-5.

//!

//! The basic idea of CFDP is to convert files of any size into a stream of packets called packet

//! data units (PDU). CFPD has an unacknowledged and acknowledged mode, with the option to request

//! a transaction closure for the unacknowledged mode. Using the unacknowledged mode with no

//! transaction closure is applicable for simplex communication paths, while the unacknowledged

//! mode with closure is the easiest way to get a confirmation of a successful file transfer,

//! including a CRC check on the remote side to verify file integrity. The acknowledged mode is

//! the most complex mode which includes multiple mechanism to ensure succesfull packet transaction

//! even for unreliable connections, including lost segment detection. As such, it can be compared

//! to a specialized TCP for file transfers with remote systems.

//!

//! The goal of this library is to be flexible enough to support the use-cases of both on-board

//! software and of ground software. It has support to make integration on [std] systems as simple

//! as possible, but also has sufficient abstraction to allow for integration on `no_std`

//! environments. Currently, the handlers still require the [std] feature until

//! [thiserror supports `error_in_core`](https://github.com/dtolnay/thiserror/pull/304).

//! It is recommended to activate the `alloc` feature at the very least to allow using the primary

//! components provided by this crate. These components will only allocate memory at initialization

//! time and thus are still viable for systems where run-time allocation is prohibited.

//!

//! The core of this library are the [crate::dest::DestinationHandler] and the

//! [crate::source::SourceHandler] components which model the CFDP destination and source entity

//! respectively. You can find high-level and API documentation for both handlers in the respective

//! [crate::dest] and [crate::source] module.

//!

//! # Examples

//!

//! This library currently features two example application which showcase how the provided

//! components could be used to provide CFDP services.

//!

//! The [end-to-end test](https://egit.irs.uni-stuttgart.de/rust/cfdp/src/branch/main/tests/end-to-end.rs)

//! is an integration tests which spawns a CFDP source entity and a CFDP destination entity,

//! moves them to separate threads and then performs a small file copy operation.

//! You can run the integration test for a transfer with no closure and with printout to the

//! standard console by running:

//!

//! ```sh

//! cargo test end_to_end_test_no_closure -- --nocapture

//! ```

//!

//! or with closure:

//!

//! ```sh

//! cargo test end_to_end_test_with_closure -- --nocapture

//! ```

//!

//! The [Python Interoperability](https://egit.irs.uni-stuttgart.de/rust/cfdp/src/branch/main/examples/python-interop)

//! example showcases the interoperability of the CFDP handlers written in Rust with a Python

//! implementation. The dedicated example documentation shows how to run this example.

//!

//! # Notes on the user hooks and scheduling

//!

//! Both examples feature implementations of the [UserFaultHookProvider] and the [user::CfdpUser]

//! trait which simply print some information to the console to monitor the progress of a file

//! copy operation. These implementations could be adapted for other handler integrations. For

//! example, they could signal a GUI application to display some information for the user.

//!

//! Even though both examples move the newly spawned handlers to dedicated threads, this is not

//! the only way they could be scheduled. For example, to support an arbitrary (or bounded)

//! amount of file copy operations on either source or destination side, those handlers could be

//! moved into a [std::collections::HashMap] structure which is then scheduled inside a thread, or

//! you could schedule a fixed amount of handlers inside a

//! [threadpool](https://docs.rs/threadpool/latest/threadpool/).

#![no_std]

#![cfg_attr(docsrs, feature(doc_auto_cfg))]

#[cfg(feature = "alloc")]

extern crate alloc;

#[cfg(any(feature = "std", test))]

extern crate std;

#[cfg(feature = "std")]

pub mod dest;

#[cfg(feature = "alloc")]

pub mod filestore;

pub mod request;

#[cfg(feature = "std")]

pub mod source;

pub mod time;

pub mod user;

use crate::time::CountdownProvider;

use core::{cell::RefCell, fmt::Debug, hash::Hash};

use crc::{Crc, CRC_32_ISCSI, CRC_32_ISO_HDLC};

#[cfg(feature = "std")]

use hashbrown::HashMap;

#[cfg(feature = "alloc")]

pub use alloc_mod::*;

use core::time::Duration;

#[cfg(feature = "serde")]

use serde::{Deserialize, Serialize};

use spacepackets::{

    cfdp::{

        pdu::{FileDirectiveType, PduError, PduHeader},

        ChecksumType, ConditionCode, FaultHandlerCode, PduType, TransmissionMode,

    },

    util::{UnsignedByteField, UnsignedEnum},

};

#[cfg(feature = "std")]

pub use std_mod::*;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

pub enum EntityType {

    Sending,

    Receiving,

}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

pub enum TimerContext {

    CheckLimit {

        local_id: UnsignedByteField,

        remote_id: UnsignedByteField,

        entity_type: EntityType,

    },

    NakActivity {

        expiry_time: Duration,

    },

    PositiveAck {

        expiry_time: Duration,

    },

}

/// A generic trait which allows CFDP entities to create check timers which are required to

/// implement special procedures in unacknowledged transmission mode, as specified in 4.6.3.2

/// and 4.6.3.3.

///

/// This trait also allows the creation of different check timers depending on context and purpose

/// of the timer, the runtime environment (e.g. standard clock timer vs. timer using a RTC) or

/// other factors.

///

/// The countdown timer is used by 3 mechanisms of the CFDP protocol.

///

/// ## 1. Check limit handling

///

/// The first mechanism is the check limit handling for unacknowledged transfers as specified

/// in 4.6.3.2 and 4.6.3.3 of the CFDP standard.

/// For this mechanism, the timer has different functionality depending on whether

/// the using entity is the sending entity or the receiving entity for the unacknowledged

/// transmission mode.

///

/// For the sending entity, this timer determines the expiry period for declaring a check limit

/// fault after sending an EOF PDU with requested closure. This allows a timeout of the transfer.

/// Also see 4.6.3.2 of the CFDP standard.

///

/// For the receiving entity, this timer determines the expiry period for incrementing a check

/// counter after an EOF PDU is received for an incomplete file transfer. This allows out-of-order

/// reception of file data PDUs and EOF PDUs. Also see 4.6.3.3 of the CFDP standard.

///

/// ## 2. NAK activity limit

///

/// The timer will be used to perform the NAK activity check as specified in 4.6.4.7 of the CFDP

/// standard. The expiration period will be provided by the NAK timer expiration limit of the

/// remote entity configuration.

///

/// ## 3. Positive ACK procedures

///

/// The timer will be used to perform the Positive Acknowledgement Procedures as specified in

/// 4.7. 1of the CFDP standard. The expiration period will be provided by the Positive ACK timer

/// interval of the remote entity configuration.

pub trait TimerCreatorProvider {

    type Countdown: CountdownProvider;

    fn create_countdown(&self, timer_context: TimerContext) -> Self::Countdown;

}

/// This structure models the remote entity configuration information as specified in chapter 8.3

/// of the CFDP standard.

/// Some of the fields which were not considered necessary for the Rust implementation

/// were omitted. Some other fields which are not contained inside the standard but are considered

/// necessary for the Rust implementation are included.

///

/// ## Notes on Positive Acknowledgment Procedures

///

/// The `positive_ack_timer_interval_seconds` and `positive_ack_timer_expiration_limit` will

/// be used for positive acknowledgement procedures as specified in CFDP chapter 4.7. The sending

/// entity will start the timer for any PDUs where an acknowledgment is required (e.g. EOF PDU).

/// Once the expected ACK response has not been received for that interval, as counter will be

/// incremented and the timer will be reset. Once the counter exceeds the

/// `positive_ack_timer_expiration_limit`, a Positive ACK Limit Reached fault will be declared.

///

/// ## Notes on Deferred Lost Segment Procedures

///

/// This procedure will be active if an EOF (No Error) PDU is received in acknowledged mode. After

/// issuing the NAK sequence which has the whole file scope, a timer will be started. The timer is

/// reset when missing segments or missing metadata is received. The timer will be deactivated if

/// all missing data is received. If the timer expires, a new NAK sequence will be issued and a

/// counter will be incremented, which can lead to a NAK Limit Reached fault being declared.

///

/// ## Fields

///

/// * `entity_id` - The ID of the remote entity.

/// * `max_packet_len` - This determines of all PDUs generated for that remote entity in addition

///    to the `max_file_segment_len` attribute which also determines the size of file data PDUs.

/// * `max_file_segment_len` The maximum file segment length which determines the maximum size

///   of file data PDUs in addition to the `max_packet_len` attribute. If this field is set

///   to None, the maximum file segment length will be derived from the maximum packet length.

///   If this has some value which is smaller than the segment value derived from

///   `max_packet_len`, this value will be picked.

/// * `closure_requested_by_default` - If the closure requested field is not supplied as part of

///    the Put Request, it will be determined from this field in the remote configuration.

/// * `crc_on_transmission_by_default` - If the CRC option is not supplied as part of the Put

///    Request, it will be determined from this field in the remote configuration.

/// * `default_transmission_mode` - If the transmission mode is not supplied as part of the

///   Put Request, it will be determined from this field in the remote configuration.

/// * `disposition_on_cancellation` - Determines whether an incomplete received file is discard on

///   transaction cancellation. Defaults to False.

/// * `default_crc_type` - Default checksum type used to calculate for all file transmissions to

///   this remote entity.

/// * `check_limit` - This timer determines the expiry period for incrementing a check counter

///   after an EOF PDU is received for an incomplete file transfer. This allows out-of-order

///   reception of file data PDUs and EOF PDUs. Also see 4.6.3.3 of the CFDP standard. Defaults to

///   2, so the check limit timer may expire twice.

/// * `positive_ack_timer_interval_seconds`- See the notes on the Positive Acknowledgment

///    Procedures inside the class documentation. Expected as floating point seconds. Defaults to

///    10 seconds.

/// * `positive_ack_timer_expiration_limit` - See the notes on the Positive Acknowledgment

///    Procedures inside the class documentation. Defaults to 2, so the timer may expire twice.

/// * `immediate_nak_mode` - Specifies whether a NAK sequence should be issued immediately when a

///    file data gap or lost metadata is detected in the acknowledged mode. Defaults to True.

/// * `nak_timer_interval_seconds` -  See the notes on the Deferred Lost Segment Procedure inside

///    the class documentation. Expected as floating point seconds. Defaults to 10 seconds.

/// * `nak_timer_expiration_limit` - See the notes on the Deferred Lost Segment Procedure inside

///    the class documentation. Defaults to 2, so the timer may expire two times.

#[derive(Debug, Copy, Clone)]

pub struct RemoteEntityConfig {

    pub entity_id: UnsignedByteField,

    pub max_packet_len: usize,

    pub max_file_segment_len: Option<usize>,

    pub closure_requested_by_default: bool,

    pub crc_on_transmission_by_default: bool,

    pub default_transmission_mode: TransmissionMode,

    pub default_crc_type: ChecksumType,

    pub positive_ack_timer_interval_seconds: f32,

    pub positive_ack_timer_expiration_limit: u32,

    pub check_limit: u32,

    pub disposition_on_cancellation: bool,

    pub immediate_nak_mode: bool,

    pub nak_timer_interval_seconds: f32,

    pub nak_timer_expiration_limit: u32,

}

impl RemoteEntityConfig {

}

pub trait RemoteEntityConfigProvider {

    /// Retrieve the remote entity configuration for the given remote ID.

    fn get(&self, remote_id: u64) -> Option<&RemoteEntityConfig>;

    fn get_mut(&mut self, remote_id: u64) -> Option<&mut RemoteEntityConfig>;

    /// Add a new remote configuration. Return [true] if the configuration was

    /// inserted successfully, and [false] if a configuration already exists.

    fn add_config(&mut self, cfg: &RemoteEntityConfig) -> bool;

    /// Remote a configuration. Returns [true] if the configuration was removed successfully,

    /// and [false] if no configuration exists for the given remote ID.

    fn remove_config(&mut self, remote_id: u64) -> bool;

}

/// This is a thin wrapper around a [HashMap] to store remote entity configurations.

/// It implements the full [RemoteEntityConfigProvider] trait.

#[cfg(feature = "std")]

#[derive(Default, Debug)]

pub struct StdRemoteEntityConfigProvider(pub HashMap<u64, RemoteEntityConfig>);

#[cfg(feature = "std")]

impl RemoteEntityConfigProvider for StdRemoteEntityConfigProvider {

}

/// This is a thin wrapper around a [alloc::vec::Vec] to store remote entity configurations.

/// It implements the full [RemoteEntityConfigProvider] trait.

#[cfg(feature = "alloc")]

#[derive(Default, Debug)]

pub struct VecRemoteEntityConfigProvider(pub alloc::vec::Vec<RemoteEntityConfig>);

#[cfg(feature = "alloc")]

impl RemoteEntityConfigProvider for VecRemoteEntityConfigProvider {

        }

}

/// A remote entity configurations also implements the [RemoteEntityConfigProvider], but the

/// [RemoteEntityConfigProvider::add_config] and [RemoteEntityConfigProvider::remove_config]

/// are no-ops and always returns [false].

impl RemoteEntityConfigProvider for RemoteEntityConfig {

}

/// This trait introduces some callbacks which will be called when a particular CFDP fault

/// handler is called.

///

/// It is passed into the CFDP handlers as part of the [UserFaultHookProvider] and the local entity

/// configuration and provides a way to specify custom user error handlers. This allows to

/// implement some CFDP features like fault handler logging, which would not be possible

/// generically otherwise.

///

/// For each error reported by the [FaultHandler], the appropriate fault handler callback

/// will be called depending on the [FaultHandlerCode].

pub trait UserFaultHookProvider {

    fn notice_of_suspension_cb(

        &mut self,

        transaction_id: TransactionId,

        cond: ConditionCode,

        progress: u64,

    );

    fn notice_of_cancellation_cb(

        &mut self,

        transaction_id: TransactionId,

        cond: ConditionCode,

        progress: u64,

    );

    fn abandoned_cb(&mut self, transaction_id: TransactionId, cond: ConditionCode, progress: u64);

    fn ignore_cb(&mut self, transaction_id: TransactionId, cond: ConditionCode, progress: u64);

}

/// Dummy fault hook which implements [UserFaultHookProvider] but only provides empty

/// implementations.

#[derive(Default, Debug, PartialEq, Eq, Copy, Clone)]

pub struct DummyFaultHook {}

impl UserFaultHookProvider for DummyFaultHook {

}

/// This structure is used to implement the fault handling as specified in chapter 4.8 of the CFDP

/// standard.

///

/// It does so by mapping each applicable [spacepackets::cfdp::ConditionCode] to a fault handler

/// which is denoted by the four [spacepackets::cfdp::FaultHandlerCode]s. This code is used

/// to select the error handling inside the CFDP handler itself in addition to dispatching to a

/// user-provided callback function provided by the [UserFaultHookProvider].

///

/// Some note on the provided default settings:

///

/// - Checksum failures will be ignored by default. This is because for unacknowledged transfers,

///   cancelling the transfer immediately would interfere with the check limit mechanism specified

///   in chapter 4.6.3.3.

/// - Unsupported checksum types will also be ignored by default. Even if the checksum type is

///   not supported the file transfer might still have worked properly.

///

/// For all other faults, the default fault handling operation will be to cancel the transaction.

/// These defaults can be overriden by using the [Self::set_fault_handler] method.

/// Please note that in any case, fault handler overrides can be specified by the sending CFDP

/// entity.

pub struct FaultHandler<UserHandler: UserFaultHookProvider> {

    handler_array: [FaultHandlerCode; 10],

    // Could also change the user fault handler trait to have non mutable methods, but that limits

    // flexbility on the user side..

    pub user_hook: RefCell<UserHandler>,

}

impl<UserHandler: UserFaultHookProvider> FaultHandler<UserHandler> {

        })

        }

}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

pub struct IndicationConfig {

    pub eof_sent: bool,

    pub eof_recv: bool,

    pub file_segment_recv: bool,

    pub transaction_finished: bool,

    pub suspended: bool,

    pub resumed: bool,

}

impl Default for IndicationConfig {

}

/// Each CFDP entity handler has a [LocalEntityConfig]uration.

pub struct LocalEntityConfig<UserFaultHook: UserFaultHookProvider> {

    pub id: UnsignedByteField,

    pub indication_cfg: IndicationConfig,

    pub fault_handler: FaultHandler<UserFaultHook>,

}

impl<UserFaultHook: UserFaultHookProvider> LocalEntityConfig<UserFaultHook> {

}

impl<UserFaultHook: UserFaultHookProvider> LocalEntityConfig<UserFaultHook> {

}

/// Generic error type for sending a PDU via a message queue.

#[cfg(feature = "std")]

#[non_exhaustive]

pub enum GenericSendError {

    #[error("RX disconnected")]

    RxDisconnected,

    #[error("queue is full, fill count {0:?}")]

    QueueFull(Option<u32>),

    #[error("other send error")]

    Other,

}

#[cfg(feature = "std")]

pub trait PduSendProvider {

    fn send_pdu(

        &self,

        pdu_type: PduType,

        file_directive_type: Option<FileDirectiveType>,

        raw_pdu: &[u8],

    ) -> Result<(), GenericSendError>;

}

#[cfg(feature = "std")]

pub mod std_mod {

    use std::sync::mpsc;

    use super::*;

    impl PduSendProvider for mpsc::Sender<PduOwnedWithInfo> {

    }

    /// Simple implementation of the [CountdownProvider] trait assuming a standard runtime.

    #[derive(Debug)]

    pub struct StdCountdown {

        expiry_time: Duration,

        start_time: std::time::Instant,

    }

    impl StdCountdown {

    }

    impl CountdownProvider for StdCountdown {

    }

    pub struct StdTimerCreator {

        pub check_limit_timeout: Duration,

    }

    impl StdTimerCreator {

    }

    impl Default for StdTimerCreator {

    }

    impl TimerCreatorProvider for StdTimerCreator {

        type Countdown = StdCountdown;

                TimerContext::CheckLimit {

                    local_id: _,

                    remote_id: _,

                    entity_type: _,

            }

    }

}

/// The CFDP transaction ID of a CFDP transaction consists of the source entity ID and the sequence

/// number of that transfer which is also determined by the CFDP source entity.

#[derive(Debug, Eq, Copy, Clone)]

pub struct TransactionId {

    source_id: UnsignedByteField,

    seq_num: UnsignedByteField,

}

impl TransactionId {

}

impl Hash for TransactionId {

}

impl PartialEq for TransactionId {

}

#[derive(Debug, Copy, Clone, PartialEq, Eq)]

pub enum State {

    Idle = 0,

    Busy = 1,

    Suspended = 2,

}

/// [crc::Crc] instance using [crc::CRC_32_ISO_HDLC].

///

/// SANA registry entry: <https://sanaregistry.org/r/checksum_identifiers/records/4>,

/// Entry in CRC catalogue: <https://reveng.sourceforge.io/crc-catalogue/all.htm#crc.cat.crc-32>

pub const CRC_32: Crc<u32> = Crc::<u32>::new(&CRC_32_ISO_HDLC);

/// [crc::Crc] instance using [crc::CRC_32_ISCSI].

///

/// SANA registry entry: <https://sanaregistry.org/r/checksum_identifiers/records/3>,

/// Entry in CRC catalogue: <https://reveng.sourceforge.io/crc-catalogue/all.htm#crc.cat.crc-32-iscsi>

pub const CRC_32C: Crc<u32> = Crc::<u32>::new(&CRC_32_ISCSI);

#[derive(Debug, PartialEq, Eq, Copy, Clone)]

pub enum PacketTarget {

    SourceEntity,

    DestEntity,

}

/// Generic trait which models a raw CFDP packet data unit (PDU) block with some additional context

/// information.

pub trait PduProvider {

    fn pdu_type(&self) -> PduType;

    fn file_directive_type(&self) -> Option<FileDirectiveType>;

    fn pdu(&self) -> &[u8];

    fn packet_target(&self) -> Result<PacketTarget, PduError>;

}

pub struct DummyPduProvider(());

impl PduProvider for DummyPduProvider {

}

/// This is a helper struct which contains base information about a particular PDU packet.

/// This is also necessary information for CFDP packet routing. For example, some packet types

/// like file data PDUs can only be used by CFDP source entities.

pub struct PduRawWithInfo<'raw_packet> {

    pdu_type: PduType,

    file_directive_type: Option<FileDirectiveType>,

    packet_len: usize,

    raw_packet: &'raw_packet [u8],

}

            // Section c) of 4.5.3: These PDUs should always be targeted towards the file sender a.k.a.

            // the source handler

            FileDirectiveType::NakPdu

            | FileDirectiveType::FinishedPdu

            // Section b) of 4.5.3: These PDUs should always be targeted towards the file receiver a.k.a.

            // the destination handler

            FileDirectiveType::MetadataPdu

            | FileDirectiveType::EofPdu

            // Section a): Recipient depends of the type of PDU that is being acknowledged. We can simply

            // extract the PDU type from the raw stream. If it is an EOF PDU, this packet is passed to

            // the source handler, for a Finished PDU, it is passed to the destination handler.

            FileDirectiveType::AckPdu => {

                } else {

                    // TODO: Maybe a better error? This might be confusing..

                }

            }

        };

impl<'raw> PduRawWithInfo<'raw> {

        // Route depending on PDU type and directive type if applicable. Retrieve directive type

        // from the raw stream for better performance (with sanity and directive code check).

        // The routing is based on section 4.5 of the CFDP standard which specifies the PDU forwarding

        // procedure.

}

impl PduProvider for PduRawWithInfo<'_> {

}

#[cfg(feature = "alloc")]

pub mod alloc_mod {

    use spacepackets::cfdp::{

        pdu::{FileDirectiveType, PduError},

        PduType,

    };

    use crate::{determine_packet_target, PacketTarget, PduProvider, PduRawWithInfo};

    #[derive(Debug, PartialEq, Eq, Clone)]

    pub struct PduOwnedWithInfo {

        pub pdu_type: PduType,

        pub file_directive_type: Option<FileDirectiveType>,

        pub pdu: alloc::vec::Vec<u8>,

    }

    impl PduOwnedWithInfo {

    }

    impl From<PduRawWithInfo<'_>> for PduOwnedWithInfo {

    }

    impl PduProvider for PduOwnedWithInfo {

    }

}

#[cfg(test)]

pub(crate) mod tests {

    use core::cell::RefCell;

    use alloc::{collections::VecDeque, string::String, vec::Vec};

    use spacepackets::{

        cfdp::{

            lv::Lv,

            pdu::{

                eof::EofPdu,

                file_data::FileDataPdu,

                metadata::{MetadataGenericParams, MetadataPduCreator},

                CommonPduConfig, FileDirectiveType, PduHeader, WritablePduPacket,

            },

            ChecksumType, ConditionCode, PduType, TransmissionMode,

        },

        util::{UnsignedByteField, UnsignedByteFieldU16, UnsignedByteFieldU8, UnsignedEnum},

    };

    use user::{CfdpUser, OwnedMetadataRecvdParams, TransactionFinishedParams};

    use crate::{PacketTarget, StdCountdown};

    use super::*;

    pub const LOCAL_ID: UnsignedByteFieldU16 = UnsignedByteFieldU16::new(1);

    pub const REMOTE_ID: UnsignedByteFieldU16 = UnsignedByteFieldU16::new(2);

    pub struct FileSegmentRecvdParamsNoSegMetadata {

        #[allow(dead_code)]

        pub id: TransactionId,

        pub offset: u64,

        pub length: usize,

    }

    #[derive(Default)]

    pub struct TestCfdpUser {

        pub next_expected_seq_num: u64,

        pub expected_full_src_name: String,

        pub expected_full_dest_name: String,

        pub expected_file_size: u64,

        pub transaction_indication_call_count: u32,

        pub eof_sent_call_count: u32,

        pub eof_recvd_call_count: u32,

        pub finished_indic_queue: VecDeque<TransactionFinishedParams>,

        pub metadata_recv_queue: VecDeque<OwnedMetadataRecvdParams>,

        pub file_seg_recvd_queue: VecDeque<FileSegmentRecvdParamsNoSegMetadata>,

    }

    impl TestCfdpUser {

    }

    impl CfdpUser for TestCfdpUser {

        }

        }

        }

    }

    #[derive(Default, Debug)]

    pub(crate) struct TestFaultHandler {

        pub notice_of_suspension_queue: VecDeque<(TransactionId, ConditionCode, u64)>,

        pub notice_of_cancellation_queue: VecDeque<(TransactionId, ConditionCode, u64)>,

        pub abandoned_queue: VecDeque<(TransactionId, ConditionCode, u64)>,

        pub ignored_queue: VecDeque<(TransactionId, ConditionCode, u64)>,

    }

    impl UserFaultHookProvider for TestFaultHandler {

    }

    impl TestFaultHandler {

    }

    pub struct SentPdu {

        pub pdu_type: PduType,

        pub file_directive_type: Option<FileDirectiveType>,

        pub raw_pdu: Vec<u8>,

    }

    #[derive(Default)]

    pub struct TestCfdpSender {

        pub packet_queue: RefCell<VecDeque<SentPdu>>,

    }

    impl PduSendProvider for TestCfdpSender {

    }

    impl TestCfdpSender {

    }

    #[test]

    #[test]

    #[test]