iox-eclipse-iceoryx#27-1: renaming of config consts

Signed-off-by: Poehnl Michael (CC-AD/ESW1) <[email protected]>

Author: Poehnl Michael (CC-AD/ESW1)

doc/installation-guide.md

@@ -80,12 +80,12 @@ The `CMakeLists.txt` from `iceoryx_meta` can be used to easily develop iceoryx w
  |  switch  |  description |
  |:---------|:-------------|
  | `IOX_MAX_PUBLISHERS` | the maximum number of publishers one `RouDi` instance can manage |
+ | `IOX_MAX_SUBSCRIBERS_PER_PUBLISHER` | the maximum number of subscriber a publisher can deliver chunks to|
+ | `IOX_MAX_PUBLISHER_HISTORY` | the maximum number chunks available for the publisher history |
+ | `IOX_MAX_CHUNKS_ALLOCATED_PER_PUBLISHER_SIMULTANEOUSLY` | the maximum number of chunks a sender can allocate at a given time |
  | `IOX_MAX_SUBSCRIBERS` | the maximum number of subscribers one `RouDi` instance can manage |
+ | `IOX_MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY` | the maximum number of chunks a subscriber can hold at a given time |
  | `IOX_MAX_INTERFACE_NUMBER` | the maximum number for interface ports, which are used for e.g. gateways |
- | `IOX_MAX_SUBSCRIBERS_PER_PUBLISHER` | the maximum number of subscriber a publisher can deliver chunks |
- | `IOX_MAX_CHUNKS_ALLOCATE_PER_SENDER` | the maximum number of chunks a sender can hold at a given time |
- | `IOX_MAX_HISTORY_CAPACITY_OF_CHUNK_DISTRIBUTOR` | the maximum number chunks available for the chunk history |
- | `IOX_MAX_CHUNKS_HELD_PER_RECEIVER` | the maximum number of chunks a receiver can hold at a given time |
 
 Have a look at `iceoryx_posh/cmake/iceoryx_posh_deployment.cmake` for the default values of this constants.
 

iceoryx_posh/cmake/iceoryx_posh_deployment.cmake

@@ -15,16 +15,16 @@ if(NOT IOX_MAX_SUBSCRIBERS_PER_PUBLISHER)
     set(IOX_MAX_SUBSCRIBERS_PER_PUBLISHER 256)
 endif()
 
-if(NOT IOX_MAX_CHUNKS_ALLOCATE_PER_SENDER)
-    set(IOX_MAX_CHUNKS_ALLOCATE_PER_SENDER 8)
+if(NOT IOX_MAX_CHUNKS_ALLOCATED_PER_PUBLISHER_SIMULTANEOUSLY)
+    set(IOX_MAX_CHUNKS_ALLOCATED_PER_PUBLISHER_SIMULTANEOUSLY 8)
 endif()
 
-if(NOT IOX_MAX_HISTORY_CAPACITY_OF_CHUNK_DISTRIBUTOR)
-    set(IOX_MAX_HISTORY_CAPACITY_OF_CHUNK_DISTRIBUTOR 16)
+if(NOT IOX_MAX_PUBLISHER_HISTORY)
+    set(IOX_MAX_PUBLISHER_HISTORY 16)
 endif()
 
-if(NOT IOX_MAX_CHUNKS_HELD_PER_RECEIVER)
-    set(IOX_MAX_CHUNKS_HELD_PER_RECEIVER 256)
+if(NOT IOX_MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY)
+    set(IOX_MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY 256)
 endif()
 
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/iceoryx_posh_deployment.hpp.in"

iceoryx_posh/cmake/iceoryx_posh_deployment.hpp.in

@@ -29,9 +29,9 @@ constexpr uint32_t IOX_MAX_PUBLISHERS = static_cast<uint32_t>(@IOX_MAX_PUBLISHER
 constexpr uint32_t IOX_MAX_SUBSCRIBERS = static_cast<uint32_t>(@IOX_MAX_SUBSCRIBERS@);
 constexpr uint32_t IOX_MAX_INTERFACE_NUMBER  = static_cast<uint32_t>(@IOX_MAX_INTERFACE_NUMBER@);
 constexpr uint32_t IOX_MAX_SUBSCRIBERS_PER_PUBLISHER  = static_cast<uint32_t>(@IOX_MAX_SUBSCRIBERS_PER_PUBLISHER@);
-constexpr uint32_t IOX_MAX_CHUNKS_ALLOCATE_PER_SENDER  = static_cast<uint32_t>(@IOX_MAX_CHUNKS_ALLOCATE_PER_SENDER@);
-constexpr uint64_t IOX_MAX_HISTORY_CAPACITY_OF_CHUNK_DISTRIBUTOR  = static_cast<uint32_t>(@IOX_MAX_HISTORY_CAPACITY_OF_CHUNK_DISTRIBUTOR@);
-constexpr uint32_t IOX_MAX_CHUNKS_HELD_PER_RECEIVER  = static_cast<uint32_t>(@IOX_MAX_CHUNKS_HELD_PER_RECEIVER@);
+constexpr uint32_t IOX_MAX_CHUNKS_ALLOCATED_PER_PUBLISHER_SIMULTANEOUSLY  = static_cast<uint32_t>(@IOX_MAX_CHUNKS_ALLOCATED_PER_PUBLISHER_SIMULTANEOUSLY@);
+constexpr uint64_t IOX_MAX_PUBLISHER_HISTORY  = static_cast<uint32_t>(@IOX_MAX_PUBLISHER_HISTORY@);
+constexpr uint32_t IOX_MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY  = static_cast<uint32_t>(@IOX_MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY@);
 } // namespace build
 } // namespace iox
 

iceoryx_posh/include/iceoryx_posh/iceoryx_posh_types.hpp

@@ -69,17 +69,17 @@ constexpr units::Duration PROCESS_KEEP_ALIVE_TIMEOUT = 5 * PROCESS_KEEP_ALIVE_IN
 /// @todo remove MAX_RECEIVERS_PER_SENDERPORT when the new port building blocks are used
 constexpr uint32_t MAX_RECEIVERS_PER_SENDERPORT = build::IOX_MAX_SUBSCRIBERS_PER_PUBLISHER;
 
-//--------- Communication Resources Start--------------------- 
+//--------- Communication Resources Start---------------------
 // Publisher
 constexpr uint32_t MAX_PUBLISHERS = build::IOX_MAX_PUBLISHERS;
 constexpr uint32_t MAX_SUBSCRIBERS_PER_PUBLISHER = build::IOX_MAX_SUBSCRIBERS_PER_PUBLISHER;
-constexpr uint32_t MAX_CHUNKS_ALLOCATE_PER_SENDER = build::IOX_MAX_CHUNKS_ALLOCATE_PER_SENDER;
-constexpr uint64_t MAX_HISTORY_CAPACITY_OF_CHUNK_DISTRIBUTOR = build::IOX_MAX_HISTORY_CAPACITY_OF_CHUNK_DISTRIBUTOR;
+constexpr uint32_t MAX_CHUNKS_ALLOCATED_PER_PUBLISHER_SIMULTANEOUSLY = build::IOX_MAX_CHUNKS_ALLOCATED_PER_PUBLISHER_SIMULTANEOUSLY;
+constexpr uint64_t MAX_PUBLISHER_HISTORY = build::IOX_MAX_PUBLISHER_HISTORY;
 // Subscriber
 constexpr uint32_t MAX_SUBSCRIBERS = build::IOX_MAX_SUBSCRIBERS;
-constexpr uint32_t MAX_CHUNKS_HELD_PER_RECEIVER = build::IOX_MAX_CHUNKS_HELD_PER_RECEIVER;
-constexpr uint32_t MAX_RECEIVER_QUEUE_CAPACITY = MAX_CHUNKS_HELD_PER_RECEIVER;
-/// With MAX_RECEIVER_QUEUE_CAPACITY = MAX_CHUNKS_HELD_PER_RECEIVER we couple the maximum number of chunks a user is
+constexpr uint32_t MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY = build::IOX_MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY;
+constexpr uint32_t MAX_SUBSCRIBER_QUEUE_CAPACITY = MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY;
+/// With MAX_SUBSCRIBER_QUEUE_CAPACITY = MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY we couple the maximum number of chunks a user is
 /// allowed to hold with the maximum queue capacity.
 /// This allows that a polling user can replace all the held chunks in one execution with all new ones
 /// from a completely filled queue. Or the other way round, when we have a contract with the user
@@ -89,20 +89,20 @@ constexpr uint32_t MAX_RECEIVER_QUEUE_CAPACITY = MAX_CHUNKS_HELD_PER_RECEIVER;
 constexpr uint32_t MAX_INTERFACE_NUMBER = build::IOX_MAX_INTERFACE_NUMBER;
 constexpr uint32_t MAX_INTERFACE_CAPRO_FIFO_SIZE = MAX_PUBLISHERS;
 // Client
-constexpr uint32_t MAX_CLIENTS = build::IOX_MAX_PUBLISHERS; /// @todo 
+constexpr uint32_t MAX_CLIENTS = build::IOX_MAX_SUBSCRIBERS; /// @todo
 constexpr uint32_t MAX_REQUESTS_ALLOCATED_SIMULTANEOUSLY = 4U;
 constexpr uint32_t MAX_RESPONSES_PROCESSED_SIMULTANEOUSLY = 16U;
 constexpr uint32_t MAX_RESPONSE_QUEUE_CAPACITY = 16U;
 // Server
-constexpr uint32_t MAX_SERVERS = build::IOX_MAX_PUBLISHERS; /// @todo 
+constexpr uint32_t MAX_SERVERS = build::IOX_MAX_PUBLISHERS; /// @todo
 constexpr uint32_t MAX_CLIENTS_PER_SERVER = 256U;
 constexpr uint32_t MAX_REQUESTS_PROCESSED_SIMULTANEOUSLY = 4U;
 constexpr uint32_t MAX_RESPONSES_ALLOCATED_SIMULTANEOUSLY = MAX_REQUESTS_PROCESSED_SIMULTANEOUSLY;
 constexpr uint32_t MAX_REQUEST_QUEUE_CAPACITY = 1024;
 // Waitset
 constexpr uint32_t MAX_NUMBER_OF_CONDITION_VARIABLES = 1024U;
-constexpr uint32_t MAX_NUMBER_OF_CONDITIONS = 128U;
-//--------- Communication Resources End--------------------- 
+constexpr uint32_t MAX_NUMBER_OF_CONDITIONS_PER_WAITSET = 128U;
+//--------- Communication Resources End---------------------
 
 constexpr uint32_t MAX_APPLICATION_CAPRO_FIFO_SIZE = 128U;
 
@@ -158,13 +158,13 @@ enum class ConnectionState : uint32_t
 struct DefaultChunkDistributorConfig
 {
     static constexpr uint32_t MAX_QUEUES = MAX_SUBSCRIBERS_PER_PUBLISHER;
-    static constexpr uint64_t MAX_HISTORY_CAPACITY = MAX_HISTORY_CAPACITY_OF_CHUNK_DISTRIBUTOR;
+    static constexpr uint64_t MAX_HISTORY_CAPACITY = MAX_PUBLISHER_HISTORY;
 };
 
 // Default properties of ChunkQueueData
 struct DefaultChunkQueueConfig
 {
-    static constexpr uint64_t MAX_QUEUE_CAPACITY = MAX_RECEIVER_QUEUE_CAPACITY;
+    static constexpr uint64_t MAX_QUEUE_CAPACITY = MAX_SUBSCRIBER_QUEUE_CAPACITY;
 };
 
 // alias for cxx::string

iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_queue_popper.hpp

@@ -61,7 +61,7 @@ class ChunkQueuePopper
     uint64_t size() noexcept;
 
     /// @brief set the capacity of the queue
-    /// @param[in] newCapacity valid values are 0 < newCapacity < MAX_RECEIVER_QUEUE_CAPACITY
+    /// @param[in] newCapacity valid values are 0 < newCapacity < MAX_SUBSCRIBER_QUEUE_CAPACITY
     /// @pre it is important that no pop or push calls occur during this call
     /// @concurrent not thread safe
     void setCapacity(const uint64_t newCapacity) noexcept;

iceoryx_posh/include/iceoryx_posh/internal/popo/delivery_fifo.hpp

@@ -56,7 +56,7 @@ class DeliveryFiFo
     uint64_t getSize() const;
 
   private:
-    concurrent::SoFi<ChunkManagementTransport, MAX_RECEIVER_QUEUE_CAPACITY> m_fifo;
+    concurrent::SoFi<ChunkManagementTransport, MAX_SUBSCRIBER_QUEUE_CAPACITY> m_fifo;
 };
 
 } // namespace popo

iceoryx_posh/include/iceoryx_posh/internal/popo/ports/publisher_port_data.hpp

@@ -41,7 +41,7 @@ struct PublisherPortData : public BasePortData
     using ChunkQueueData_t = SubscriberPortData::ChunkQueueData_t;
     using ChunkDistributorData_t =
         ChunkDistributorData<DefaultChunkDistributorConfig, ThreadSafePolicy, ChunkQueuePusher<ChunkQueueData_t>>;
-    using ChunkSenderData_t = ChunkSenderData<MAX_CHUNKS_ALLOCATE_PER_SENDER, ChunkDistributorData_t>;
+    using ChunkSenderData_t = ChunkSenderData<MAX_CHUNKS_ALLOCATED_PER_PUBLISHER_SIMULTANEOUSLY, ChunkDistributorData_t>;
 
     ChunkSenderData_t m_chunkSenderData;
     std::atomic_bool m_offeringRequested{false};

iceoryx_posh/include/iceoryx_posh/internal/popo/ports/subscriber_port_data.hpp

@@ -37,7 +37,7 @@ struct SubscriberPortData : public BasePortData
                        const mepoo::MemoryInfo& memoryInfo = mepoo::MemoryInfo()) noexcept;
 
     using ChunkQueueData_t = ChunkQueueData<DefaultChunkQueueConfig, ThreadSafePolicy>;
-    using ChunkReceiverData_t = ChunkReceiverData<MAX_CHUNKS_HELD_PER_RECEIVER, ChunkQueueData_t>;
+    using ChunkReceiverData_t = ChunkReceiverData<MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY, ChunkQueueData_t>;
 
     ChunkReceiverData_t m_chunkReceiverData;
     const uint64_t m_historyRequest;

iceoryx_posh/include/iceoryx_posh/internal/popo/receiver_port.hpp

@@ -60,8 +60,8 @@ class ReceiverPort : public BasePort
     // BEGIN REGION__APPLICATION // /* access from Application-------------------------------
 
     virtual void subscribe(const bool f_autoResubscribe = false,
-                           const uint32_t f_deliverySize = MAX_RECEIVER_QUEUE_CAPACITY); // deprecated
-    virtual void subscribe(const uint32_t f_deliverySize = MAX_RECEIVER_QUEUE_CAPACITY);
+                           const uint32_t f_deliverySize = MAX_SUBSCRIBER_QUEUE_CAPACITY); // deprecated
+    virtual void subscribe(const uint32_t f_deliverySize = MAX_SUBSCRIBER_QUEUE_CAPACITY);
     void unsubscribe();
     bool isSubscribed() const;
     SubscribeState getSubscribeState() const;

iceoryx_posh/include/iceoryx_posh/internal/popo/receiver_port_data.hpp

@@ -46,7 +46,7 @@ struct ReceiverPortData : public BasePortData
     std::atomic<SubscribeState> m_subscriptionState{SubscribeState::NOT_SUBSCRIBED};
 
     DeliveryFiFo m_deliveryFiFo;
-    static constexpr uint32_t DELIVERED_LIST_SIZE = 2u * MAX_RECEIVER_QUEUE_CAPACITY;
+    static constexpr uint32_t DELIVERED_LIST_SIZE = 2u * MAX_SUBSCRIBER_QUEUE_CAPACITY;
     UsedChunkList<DELIVERED_LIST_SIZE> m_deliveredChunkList;
 
     // event callback related

iceoryx_posh/include/iceoryx_posh/internal/popo/sender_port_data.hpp

@@ -64,7 +64,7 @@ struct SenderPortData : public BasePortData
     bool m_isUnique{false};
 
 
-    UsedChunkList<MAX_CHUNKS_ALLOCATE_PER_SENDER> m_allocatedChunksList;
+    UsedChunkList<MAX_CHUNKS_ALLOCATED_PER_PUBLISHER_SIMULTANEOUSLY> m_allocatedChunksList;
 
     mepoo::SequenceNumberType m_sequenceNumber{0u};
     // throughput related members

iceoryx_posh/include/iceoryx_posh/internal/popo/subscriber.inl

@@ -47,11 +47,11 @@ inline void Subscriber_t<ReceiverPortType>::subscribe(const uint32_t cacheSize)
 {
     m_subscribeDemand = true;
     uint32_t size = cacheSize;
-    if (size > MAX_RECEIVER_QUEUE_CAPACITY)
+    if (size > MAX_SUBSCRIBER_QUEUE_CAPACITY)
     {
         LogWarn() << "Cache size for subscribe too large " << size
-                  << ", limiting to MAX_RECEIVER_QUEUE_CAPACITY = " << MAX_RECEIVER_QUEUE_CAPACITY;
-        size = MAX_RECEIVER_QUEUE_CAPACITY;
+                  << ", limiting to MAX_SUBSCRIBER_QUEUE_CAPACITY = " << MAX_SUBSCRIBER_QUEUE_CAPACITY;
+        size = MAX_SUBSCRIBER_QUEUE_CAPACITY;
     }
     m_receiver.subscribe(true, size);
 }

iceoryx_posh/include/iceoryx_posh/popo/subscriber.hpp

@@ -65,7 +65,7 @@ class Subscriber_t
 
     /// @brief Function for subscribing to event
     /// @param[in] cacheSize Size of the receiver queue
-    void subscribe(const uint32_t cacheSize = MAX_RECEIVER_QUEUE_CAPACITY) noexcept;
+    void subscribe(const uint32_t cacheSize = MAX_SUBSCRIBER_QUEUE_CAPACITY) noexcept;
 
     /// @brief Get function for retrieving subsription state
     /// @return enum value of subsription state

iceoryx_posh/include/iceoryx_posh/popo/wait_set.hpp

@@ -94,7 +94,7 @@ enum class WaitSetError : uint8_t
 class WaitSet
 {
   public:
-    using ConditionVector = cxx::vector<Condition*, MAX_NUMBER_OF_CONDITIONS>;
+    using ConditionVector = cxx::vector<Condition*, MAX_NUMBER_OF_CONDITIONS_PER_WAITSET>;
 
     enum class WaitPolicy : uint16_t
     {

iceoryx_posh/test/integrationtests/test_popo_chunk_building_blocks.cpp

@@ -38,7 +38,7 @@ struct DummySample
     uint64_t m_dummy{42};
 };
 
-static constexpr uint32_t NUM_CHUNKS_IN_POOL = 3 * iox::MAX_RECEIVER_QUEUE_CAPACITY;
+static constexpr uint32_t NUM_CHUNKS_IN_POOL = 3 * iox::MAX_SUBSCRIBER_QUEUE_CAPACITY;
 static constexpr uint32_t SMALL_CHUNK = 128;
 static constexpr uint32_t CHUNK_META_INFO_SIZE = 256;
 static constexpr size_t MEMORY_SIZE = NUM_CHUNKS_IN_POOL * (SMALL_CHUNK + CHUNK_META_INFO_SIZE);
@@ -49,7 +49,7 @@ static constexpr uint32_t MAX_NUMBER_QUEUES = 128;
 struct ChunkDistributorConfig
 {
     static constexpr uint32_t MAX_QUEUES = MAX_NUMBER_QUEUES;
-    static constexpr uint64_t MAX_HISTORY_CAPACITY = iox::MAX_HISTORY_CAPACITY_OF_CHUNK_DISTRIBUTOR;
+    static constexpr uint64_t MAX_HISTORY_CAPACITY = iox::MAX_PUBLISHER_HISTORY;
 };
 
 struct ChunkQueueConfig
@@ -62,8 +62,8 @@ using ChunkDistributorData_t =
     ChunkDistributorData<ChunkDistributorConfig, ThreadSafePolicy, ChunkQueuePusher<ChunkQueueData_t>>;
 using ChunkDistributor_t = ChunkDistributor<ChunkDistributorData_t>;
 using ChunkQueuePopper_t = ChunkQueuePopper<ChunkQueueData_t>;
-using ChunkSenderData_t = ChunkSenderData<iox::MAX_CHUNKS_ALLOCATE_PER_SENDER, ChunkDistributorData_t>;
-using ChunkReceiverData_t = ChunkReceiverData<iox::MAX_CHUNKS_HELD_PER_RECEIVER, ChunkQueueData_t>;
+using ChunkSenderData_t = ChunkSenderData<iox::MAX_CHUNKS_ALLOCATED_PER_PUBLISHER_SIMULTANEOUSLY, ChunkDistributorData_t>;
+using ChunkReceiverData_t = ChunkReceiverData<iox::MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY, ChunkQueueData_t>;
 
 class ChunkBuildingBlocks_IntegrationTest : public Test
 {

iceoryx_posh/test/mocks/receiverport_mock.hpp

@@ -44,12 +44,12 @@ class ReceiverPort_MOCK
     MOCK_METHOD0(cleanup, void());
 
     MOCK_METHOD1(subscribe_impl, void(const uint32_t));
-    void subscribe(const bool f_autoResubscribe = false, const uint32_t f_deliverySize = iox::MAX_RECEIVER_QUEUE_CAPACITY)
+    void subscribe(const bool f_autoResubscribe = false, const uint32_t f_deliverySize = iox::MAX_SUBSCRIBER_QUEUE_CAPACITY)
     {
         (void)f_autoResubscribe;
         subscribe_impl(f_deliverySize);
     }
-    void subscribe(const uint32_t f_deliverySize = iox::MAX_RECEIVER_QUEUE_CAPACITY)
+    void subscribe(const uint32_t f_deliverySize = iox::MAX_SUBSCRIBER_QUEUE_CAPACITY)
     {
         subscribe_impl(f_deliverySize);
     }

iceoryx_posh/test/moduletests/test_popo_chunk_distributor.cpp

@@ -68,7 +68,7 @@ class ChunkDistributor_test : public Test
     struct ChunkDistributorConfig
     {
         static constexpr uint32_t MAX_QUEUES = MAX_NUMBER_QUEUES;
-        static constexpr uint64_t MAX_HISTORY_CAPACITY = iox::MAX_HISTORY_CAPACITY_OF_CHUNK_DISTRIBUTOR;
+        static constexpr uint64_t MAX_HISTORY_CAPACITY = iox::MAX_PUBLISHER_HISTORY;
     };
 
     struct ChunkQueueConfig

iceoryx_posh/test/moduletests/test_popo_chunk_queue.cpp

@@ -48,8 +48,8 @@ class ChunkQueue_testBase
     static constexpr size_t MEMORY_SIZE = 4 * MEGABYTE;
     std::unique_ptr<char[]> memory{new char[MEMORY_SIZE]};
     iox::posix::Allocator allocator{memory.get(), MEMORY_SIZE};
-    MemPool mempool{128, 2 * iox::MAX_RECEIVER_QUEUE_CAPACITY, &allocator, &allocator};
-    MemPool chunkMgmtPool{128, 2 * iox::MAX_RECEIVER_QUEUE_CAPACITY, &allocator, &allocator};
+    MemPool mempool{128, 2 * iox::MAX_SUBSCRIBER_QUEUE_CAPACITY, &allocator, &allocator};
+    MemPool chunkMgmtPool{128, 2 * iox::MAX_SUBSCRIBER_QUEUE_CAPACITY, &allocator, &allocator};
 
     static constexpr uint32_t RESIZED_CAPACITY{5u};
 };
@@ -237,7 +237,7 @@ TYPED_TEST(ChunkQueueFiFo_test, DISABLED_InitialSize)
 /// @note API currently not supported
 TYPED_TEST(ChunkQueueFiFo_test, DISABLED_Capacity)
 {
-    EXPECT_THAT(this->m_popper.getCurrentCapacity(), Eq(iox::MAX_RECEIVER_QUEUE_CAPACITY));
+    EXPECT_THAT(this->m_popper.getCurrentCapacity(), Eq(iox::MAX_SUBSCRIBER_QUEUE_CAPACITY));
 }
 
 /// @note API currently not supported
@@ -249,7 +249,7 @@ TYPED_TEST(ChunkQueueFiFo_test, DISABLED_SetCapacity)
 
 TYPED_TEST(ChunkQueueFiFo_test, PushFull)
 {
-    for (auto i = 0u; i < iox::MAX_RECEIVER_QUEUE_CAPACITY; ++i)
+    for (auto i = 0u; i < iox::MAX_SUBSCRIBER_QUEUE_CAPACITY; ++i)
     {
         auto chunk = this->allocateChunk();
         this->m_pusher.push(chunk);
@@ -290,7 +290,7 @@ TYPED_TEST(ChunkQueueSoFi_test, InitialSize)
 
 TYPED_TEST(ChunkQueueSoFi_test, Capacity)
 {
-    EXPECT_THAT(this->m_popper.getCurrentCapacity(), Eq(iox::MAX_RECEIVER_QUEUE_CAPACITY));
+    EXPECT_THAT(this->m_popper.getCurrentCapacity(), Eq(iox::MAX_SUBSCRIBER_QUEUE_CAPACITY));
 }
 
 
@@ -302,7 +302,7 @@ TYPED_TEST(ChunkQueueSoFi_test, SetCapacity)
 
 TYPED_TEST(ChunkQueueSoFi_test, PushFull)
 {
-    for (auto i = 0u; i < iox::MAX_RECEIVER_QUEUE_CAPACITY * 2; ++i)
+    for (auto i = 0u; i < iox::MAX_SUBSCRIBER_QUEUE_CAPACITY * 2; ++i)
     {
         auto chunk = this->allocateChunk();
         this->m_pusher.push(chunk);