[eclipse-iceoryx#690] Add dynamic API tests

Author: elfenpiff

iceoryx2/tests/service_request_response_tests.rs

@@ -17,6 +17,7 @@ mod service_request_response {
     use iceoryx2::node::NodeBuilder;
     use iceoryx2::port::client::Client;
     use iceoryx2::port::server::Server;
+    use iceoryx2::port::LoanError;
     use iceoryx2::prelude::{PortFactory, *};
     use iceoryx2::service::builder::publish_subscribe::{CustomHeaderMarker, CustomPayloadMarker};
     use iceoryx2::service::static_config::message_type_details::{TypeDetail, TypeVariant};
@@ -1001,7 +1002,7 @@ mod service_request_response {
         assert_that!(response.header().number_of_elements(), eq NUMBER_OF_ELEMENTS as u64);
         let payload_ptr = response.payload().as_ptr() as *const u8;
         for n in 0..type_details.size {
-            assert_that!(unsafe { *payload_ptr.add(n) }, eq(n % 255) as u8);
+            assert_that!(unsafe { *payload_ptr.add(n) }, eq(n % 89) as u8);
         }
     }
 
@@ -1029,7 +1030,7 @@ mod service_request_response {
                 .request_user_header::<CustomHeaderMarker>()
                 .response_user_header::<CustomHeaderMarker>()
                 .__internal_set_request_header_type_details(&type_details)
-                .create()
+                .open()
                 .unwrap()
         };
 
@@ -1051,7 +1052,7 @@ mod service_request_response {
     }
 
     #[test]
-    fn sending_responses_with_custom_header_works<Sut: Service>() {
+    fn sending_response_with_custom_header_works<Sut: Service>() {
         let service_name = generate_service_name();
         let config = generate_isolated_config();
         let node = NodeBuilder::new().config(&config).create::<Sut>().unwrap();
@@ -1074,7 +1075,7 @@ mod service_request_response {
                 .request_user_header::<CustomHeaderMarker>()
                 .response_user_header::<CustomHeaderMarker>()
                 .__internal_set_response_header_type_details(&type_details)
-                .create()
+                .open()
                 .unwrap()
         };
 
@@ -1090,6 +1091,7 @@ mod service_request_response {
         for n in 0..type_details.size {
             unsafe { header_ptr.add(n).write((n % 229) as u8) };
         }
+        unsafe { response.assume_init().send().unwrap() };
 
         let response = unsafe { pending_response.receive_custom_payload().unwrap().unwrap() };
         let header_ptr = (response.user_header() as *const CustomHeaderMarker) as *const u8;
@@ -1098,6 +1100,172 @@ mod service_request_response {
         }
     }
 
+    #[test]
+    fn send_increasing_requests_with_static_allocation_strategy_fails<Sut: Service>() {
+        const SLICE_SIZE: usize = 1024;
+        let service_name = generate_service_name();
+        let config = generate_isolated_config();
+        let node = NodeBuilder::new().config(&config).create::<Sut>().unwrap();
+
+        let service = node
+            .service_builder(&service_name)
+            .request_response::<[u8], u64>()
+            .create()
+            .unwrap();
+
+        let client = service
+            .client_builder()
+            .initial_max_slice_len(SLICE_SIZE)
+            .allocation_strategy(AllocationStrategy::Static)
+            .create()
+            .unwrap();
+
+        let request = client.loan_slice(SLICE_SIZE - 1);
+        assert_that!(request, is_ok);
+
+        let request = client.loan_slice(SLICE_SIZE);
+        assert_that!(request, is_ok);
+
+        let request = client.loan_slice(SLICE_SIZE + 1);
+        assert_that!(request.err(), eq Some(LoanError::ExceedsMaxLoanSize));
+    }
+
+    #[test]
+    fn send_increasing_responses_with_static_allocation_strategy_fails<Sut: Service>() {
+        const SLICE_SIZE: usize = 1024;
+        let service_name = generate_service_name();
+        let config = generate_isolated_config();
+        let node = NodeBuilder::new().config(&config).create::<Sut>().unwrap();
+
+        let service = node
+            .service_builder(&service_name)
+            .request_response::<u64, [u8]>()
+            .create()
+            .unwrap();
+
+        let client = service.client_builder().create().unwrap();
+        let server = service
+            .server_builder()
+            .initial_max_slice_len(SLICE_SIZE)
+            .allocation_strategy(AllocationStrategy::Static)
+            .create()
+            .unwrap();
+        let _pending_response = client.send_copy(0).unwrap();
+        let active_request = server.receive().unwrap().unwrap();
+
+        let response = active_request.loan_slice(SLICE_SIZE - 1);
+        assert_that!(response, is_ok);
+
+        let response = active_request.loan_slice(SLICE_SIZE);
+        assert_that!(response, is_ok);
+
+        let response = active_request.loan_slice(SLICE_SIZE + 1);
+        assert_that!(response.err(), eq Some(LoanError::ExceedsMaxLoanSize));
+    }
+
+    fn send_and_receive_increasing_requests_works<Sut: Service>(
+        allocation_strategy: AllocationStrategy,
+    ) {
+        const ITERATIONS: usize = 128;
+        let service_name = generate_service_name();
+        let config = generate_isolated_config();
+        let node = NodeBuilder::new().config(&config).create::<Sut>().unwrap();
+
+        let service = node
+            .service_builder(&service_name)
+            .request_response::<[u8], u64>()
+            .create()
+            .unwrap();
+
+        let client = service
+            .client_builder()
+            .initial_max_slice_len(1)
+            .allocation_strategy(allocation_strategy)
+            .create()
+            .unwrap();
+        let server = service.server_builder().create().unwrap();
+
+        for n in 0..ITERATIONS {
+            let request_size = (n + 1) * 32;
+            let mut request = client.loan_slice(request_size).unwrap();
+            for byte in request.payload_mut() {
+                *byte = n as u8;
+            }
+
+            let _pending_response = request.send().unwrap();
+
+            let active_request = server.receive().unwrap().unwrap();
+            assert_that!(active_request.payload(), len request_size);
+            for byte in active_request.payload() {
+                assert_that!(*byte, eq n as u8);
+            }
+        }
+    }
+
+    #[test]
+    fn send_and_receive_increasing_requests_with_best_fit_allocation_works<Sut: Service>() {
+        send_and_receive_increasing_requests_works::<Sut>(AllocationStrategy::BestFit);
+    }
+
+    #[test]
+    fn send_and_receive_increasing_requests_with_power_of_two_allocation_works<Sut: Service>() {
+        send_and_receive_increasing_requests_works::<Sut>(AllocationStrategy::PowerOfTwo);
+    }
+
+    fn send_and_receive_increasing_responses_works<Sut: Service>(
+        allocation_strategy: AllocationStrategy,
+    ) {
+        const ITERATIONS: usize = 128;
+        let service_name = generate_service_name();
+        let config = generate_isolated_config();
+        let node = NodeBuilder::new().config(&config).create::<Sut>().unwrap();
+
+        let service = node
+            .service_builder(&service_name)
+            .request_response::<u64, [u8]>()
+            .create()
+            .unwrap();
+
+        let client = service.client_builder().create().unwrap();
+        let server = service
+            .server_builder()
+            .initial_max_slice_len(1)
+            .allocation_strategy(allocation_strategy)
+            .create()
+            .unwrap();
+        let pending_response = client.send_copy(0).unwrap();
+        let active_request = server.receive().unwrap().unwrap();
+
+        for n in 0..ITERATIONS {
+            let response_size = (n + 1) * 32;
+            let mut response = active_request.loan_slice(response_size).unwrap();
+            for byte in response.payload_mut() {
+                *byte = n as u8 + 5;
+            }
+            response.send().unwrap();
+
+            let response = pending_response.receive().unwrap().unwrap();
+            assert_that!(response.payload(), len response_size);
+            for byte in response.payload() {
+                assert_that!(*byte, eq n as u8 + 5);
+            }
+        }
+    }
+
+    #[test]
+    fn send_and_receive_increasing_responses_with_best_fit_allocation_strategy_works<
+        Sut: Service,
+    >() {
+        send_and_receive_increasing_responses_works::<Sut>(AllocationStrategy::BestFit);
+    }
+
+    #[test]
+    fn send_and_receive_increasing_responses_with_power_of_two_allocation_strategy_works<
+        Sut: Service,
+    >() {
+        send_and_receive_increasing_responses_works::<Sut>(AllocationStrategy::PowerOfTwo);
+    }
+
     #[instantiate_tests(<iceoryx2::service::ipc::Service>)]
     mod ipc {}