From d8acaaf58020778de43ab8d8caf3e054ed5d53ad Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 23 Jan 2024 18:43:09 +0100 Subject: [PATCH] add test for requested closure --- satrs-core/src/cfdp/dest.rs | 58 ++++++++++++++++++++++++++++++------- 1 file changed, 48 insertions(+), 10 deletions(-) diff --git a/satrs-core/src/cfdp/dest.rs b/satrs-core/src/cfdp/dest.rs index 8969e5f..be4eb88 100644 --- a/satrs-core/src/cfdp/dest.rs +++ b/satrs-core/src/cfdp/dest.rs @@ -815,6 +815,13 @@ mod tests { Ok(()) } } + + impl TestCfdpSender { + pub fn queue_empty(&self) -> bool { + self.packet_queue.lock().unwrap().is_empty() + } + } + #[derive(Default)] struct TestCfdpUser { next_expected_seq_num: u64, @@ -1066,20 +1073,21 @@ mod tests { struct DestHandlerTester { check_timer_expired: Arc, - test_sender: TestCfdpSender, + pdu_sender: TestCfdpSender, handler: DestinationHandler, src_path: PathBuf, dest_path: PathBuf, check_dest_file: bool, check_handler_idle_at_drop: bool, expected_file_size: u64, + closure_requested: bool, pdu_header: PduHeader, expected_full_data: Vec, buf: [u8; 512], } impl DestHandlerTester { - fn new(fault_handler: TestFaultHandler) -> Self { + fn new(fault_handler: TestFaultHandler, closure_requested: bool) -> Self { let check_timer_expired = Arc::new(AtomicBool::new(false)); let test_sender = TestCfdpSender::default(); let dest_handler = default_dest_handler( @@ -1091,9 +1099,10 @@ mod tests { assert!(!Path::exists(&dest_path)); let handler = Self { check_timer_expired, - test_sender, + pdu_sender: test_sender, handler: dest_handler, src_path, + closure_requested, dest_path, check_dest_file: false, check_handler_idle_at_drop: false, @@ -1144,6 +1153,7 @@ mod tests { self.src_path.as_path(), self.dest_path.as_path(), file_size, + self.closure_requested ); let packet_info = create_packet_info(&metadata_pdu, &mut self.buf); self.handler.state_machine(user, Some(&packet_info))?; @@ -1274,13 +1284,14 @@ mod tests { src_name: &'filename Path, dest_name: &'filename Path, file_size: u64, + closure_requested: bool ) -> MetadataPduCreator<'filename, 'filename, 'static> { let checksum_type = if file_size == 0 { ChecksumType::NullChecksum } else { ChecksumType::Crc32 }; - let metadata_params = MetadataGenericParams::new(false, checksum_type, file_size); + let metadata_params = MetadataGenericParams::new(closure_requested, checksum_type, file_size); MetadataPduCreator::new_no_opts( *pdu_header, metadata_params, @@ -1320,9 +1331,9 @@ mod tests { } #[test] - fn test_empty_file_transfer_not_acked() { + fn test_empty_file_transfer_not_acked_no_closure() { let fault_handler = TestFaultHandler::default(); - let mut test_obj = DestHandlerTester::new(fault_handler.clone()); + let mut test_obj = DestHandlerTester::new(fault_handler.clone(), false); let mut test_user = test_obj.test_user_from_cached_paths(0); test_obj .generic_transfer_init(&mut test_user, 0) @@ -1332,6 +1343,8 @@ mod tests { .generic_eof_no_error(&mut test_user, Vec::new()) .expect("EOF no error insertion failed"); assert!(fault_handler.all_queues_empty()); + assert!(test_obj.pdu_sender.queue_empty()); + test_obj.state_check(State::Idle, TransactionStep::Idle); } #[test] @@ -1341,7 +1354,7 @@ mod tests { let file_size = file_data.len() as u64; let fault_handler = TestFaultHandler::default(); - let mut test_obj = DestHandlerTester::new(fault_handler.clone()); + let mut test_obj = DestHandlerTester::new(fault_handler.clone(), false); let mut test_user = test_obj.test_user_from_cached_paths(file_size); test_obj .generic_transfer_init(&mut test_user, file_size) @@ -1354,6 +1367,8 @@ mod tests { .generic_eof_no_error(&mut test_user, file_data.to_vec()) .expect("EOF no error insertion failed"); assert!(fault_handler.all_queues_empty()); + assert!(test_obj.pdu_sender.queue_empty()); + test_obj.state_check(State::Idle, TransactionStep::Idle); } #[test] @@ -1365,7 +1380,7 @@ mod tests { let segment_len = 256; let fault_handler = TestFaultHandler::default(); - let mut test_obj = DestHandlerTester::new(fault_handler.clone()); + let mut test_obj = DestHandlerTester::new(fault_handler.clone(), false); let mut test_user = test_obj.test_user_from_cached_paths(file_size); test_obj .generic_transfer_init(&mut test_user, file_size) @@ -1385,6 +1400,8 @@ mod tests { .generic_eof_no_error(&mut test_user, random_data.to_vec()) .expect("EOF no error insertion failed"); assert!(fault_handler.all_queues_empty()); + assert!(test_obj.pdu_sender.queue_empty()); + test_obj.state_check(State::Idle, TransactionStep::Idle); } #[test] @@ -1396,7 +1413,7 @@ mod tests { let segment_len = 256; let fault_handler = TestFaultHandler::default(); - let mut test_obj = DestHandlerTester::new(fault_handler.clone()); + let mut test_obj = DestHandlerTester::new(fault_handler.clone(), false); let mut test_user = test_obj.test_user_from_cached_paths(file_size); let transaction_id = test_obj .generic_transfer_init(&mut test_user, file_size) @@ -1432,6 +1449,8 @@ mod tests { assert_eq!(cancelled.0, transaction_id); assert_eq!(cancelled.1, ConditionCode::FileChecksumFailure); assert_eq!(cancelled.2, segment_len as u64); + assert!(test_obj.pdu_sender.queue_empty()); + test_obj.state_check(State::Idle, TransactionStep::Idle); } #[test] @@ -1443,7 +1462,7 @@ mod tests { let segment_len = 256; let fault_handler = TestFaultHandler::default(); - let mut test_obj = DestHandlerTester::new(fault_handler.clone()); + let mut test_obj = DestHandlerTester::new(fault_handler.clone(), false); let mut test_user = test_obj.test_user_from_cached_paths(file_size); let transaction_id = test_obj .generic_transfer_init(&mut test_user, file_size) @@ -1498,6 +1517,8 @@ mod tests { drop(cancelled_queue); + assert!(test_obj.pdu_sender.queue_empty()); + // Check that the broken file exists. test_obj.check_dest_file = false; assert!(Path::exists(test_obj.dest_path())); @@ -1506,4 +1527,21 @@ mod tests { assert_eq!(read_content, &random_data[0..segment_len]); assert!(fs::remove_file(test_obj.dest_path().as_path()).is_ok()); } + + #[test] + fn test_file_transfer_with_closure() { + let fault_handler = TestFaultHandler::default(); + let mut test_obj = DestHandlerTester::new(fault_handler.clone(), true); + let mut test_user = test_obj.test_user_from_cached_paths(0); + test_obj + .generic_transfer_init(&mut test_user, 0) + .expect("transfer init failed"); + test_obj.state_check(State::Busy, TransactionStep::ReceivingFileDataPdus); + test_obj + .generic_eof_no_error(&mut test_user, Vec::new()) + .expect("EOF no error insertion failed"); + assert!(fault_handler.all_queues_empty()); + test_obj.state_check(State::Idle, TransactionStep::Idle); + // assert!(!test_obj.pdu_sender.queue_empty()); + } }