[eclipse-iceoryx#139] Add dynamic storage tests for dropping

Author: elfenpiff

iceoryx2-bb/testing/src/lib.rs

@@ -12,6 +12,7 @@
 
 #[macro_use]
 pub mod assert;
+pub mod lifetime_tracker;
 pub mod watchdog;
 
 #[macro_export(local_inner_macros)]

iceoryx2-bb/testing/src/lifetime_tracker.rs

@@ -0,0 +1,48 @@
+// Copyright (c) 2024 Contributors to the Eclipse Foundation
+//
+// See the NOTICE file(s) distributed with this work for additional
+// information regarding copyright ownership.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Apache Software License 2.0 which is available at
+// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
+// which is available at https://opensource.org/licenses/MIT.
+//
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+static CREATION_COUNTER: AtomicUsize = AtomicUsize::new(0);
+static DROP_COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+#[derive(Debug)]
+pub struct LifetimeTracker {}
+
+impl LifetimeTracker {
+    pub fn new() -> Self {
+        CREATION_COUNTER.fetch_add(1, Ordering::Relaxed);
+
+        Self {}
+    }
+
+    pub fn start_tracking() {
+        CREATION_COUNTER.store(0, Ordering::Relaxed);
+        DROP_COUNTER.store(0, Ordering::Relaxed);
+    }
+
+    pub fn number_of_living_instances() -> usize {
+        CREATION_COUNTER.load(Ordering::Relaxed) - DROP_COUNTER.load(Ordering::Relaxed)
+    }
+}
+
+impl Clone for LifetimeTracker {
+    fn clone(&self) -> Self {
+        Self::new()
+    }
+}
+
+impl Drop for LifetimeTracker {
+    fn drop(&mut self) {
+        DROP_COUNTER.fetch_add(1, Ordering::Relaxed);
+    }
+}

iceoryx2-cal/tests/dynamic_storage_trait_tests.rs

@@ -17,6 +17,7 @@ mod dynamic_storage {
     use iceoryx2_bb_elementary::math::ToB64;
     use iceoryx2_bb_posix::unique_system_id::UniqueSystemId;
     use iceoryx2_bb_system_types::file_name::FileName;
+    use iceoryx2_bb_testing::lifetime_tracker::LifetimeTracker;
     use iceoryx2_bb_testing::{assert_that, test_requires};
     use iceoryx2_cal::dynamic_storage::*;
     use iceoryx2_cal::named_concept::*;
@@ -34,6 +35,7 @@ mod dynamic_storage {
         value: AtomicI64,
         supplementary_ptr: *mut u8,
         supplementary_len: usize,
+        _lifetime_tracker: LifetimeTracker,
     }
 
     impl TestData {
@@ -42,6 +44,7 @@ mod dynamic_storage {
                 value: AtomicI64::new(value),
                 supplementary_ptr: std::ptr::null_mut::<u8>(),
                 supplementary_len: 0,
+                _lifetime_tracker: LifetimeTracker::new(),
             }
         }
     }
@@ -462,6 +465,68 @@ mod dynamic_storage {
         assert_that!(Sut::does_exist(&sut_name), eq Ok(false));
     }
 
+    #[test]
+    fn when_storage_is_removed_it_calls_drop<Sut: DynamicStorage<TestData>>() {
+        let storage_name = generate_name();
+
+        LifetimeTracker::start_tracking();
+
+        let sut = Sut::Builder::new(&storage_name)
+            .create(TestData::new(123))
+            .unwrap();
+
+        assert_that!(sut.has_ownership(), eq true);
+        drop(sut);
+
+        assert_that!(LifetimeTracker::number_of_living_instances(), eq 0);
+    }
+
+    #[test]
+    fn when_storage_is_persistent_it_does_not_call_drop<Sut: DynamicStorage<TestData>>() {
+        if Sut::does_support_persistency() {
+            let storage_name = generate_name();
+
+            LifetimeTracker::start_tracking();
+
+            let sut = Sut::Builder::new(&storage_name)
+                .create(TestData::new(123))
+                .unwrap();
+            sut.release_ownership();
+            drop(sut);
+
+            assert_that!(LifetimeTracker::number_of_living_instances(), eq 1);
+        }
+    }
+
+    #[test]
+    fn explicit_remove_of_persistent_storage_calls_drop<Sut: DynamicStorage<TestData>>() {
+        let storage_name = generate_name();
+
+        LifetimeTracker::start_tracking();
+
+        let sut = Sut::Builder::new(&storage_name)
+            .create(TestData::new(123))
+            .unwrap();
+        sut.release_ownership();
+        // it leaks a memory mapping here but this we want explicitly to test remove also
+        // for platforms that do not support persistent dynamic storage
+        std::mem::forget(sut);
+
+        assert_that!(unsafe { Sut::remove(&storage_name) }, eq Ok(true));
+        assert_that!(LifetimeTracker::number_of_living_instances(), eq 0);
+    }
+
+    #[test]
+    fn remove_storage_with_unfinished_initialization_does_not_call_drop<
+        Sut: DynamicStorage<TestData>,
+    >() {
+    }
+
+    #[test]
+    fn opening_dynamic_storage_with_wrong_type_fails<Sut: DynamicStorage<TestData>>() {}
+
+    fn removing_dynamic_storage_with_wrong_type_fails<Sut: DynamicStorage<TestData>>() {}
+
     #[instantiate_tests(<iceoryx2_cal::dynamic_storage::posix_shared_memory::Storage<TestData>>)]
     mod posix_shared_memory {}