diff --git a/include/fastdds/dds/domain/qos/DomainParticipantQos.hpp b/include/fastdds/dds/domain/qos/DomainParticipantQos.hpp
index 0f040b583d7..a15afd1d91c 100644
--- a/include/fastdds/dds/domain/qos/DomainParticipantQos.hpp
+++ b/include/fastdds/dds/domain/qos/DomainParticipantQos.hpp
@@ -22,6 +22,13 @@
 
 #include <string>
 
+<<<<<<< HEAD
+=======
+#include <fastdds/dds/core/policy/QosPolicies.hpp>
+#include <fastdds/rtps/attributes/BuiltinTransports.hpp>
+#include <fastdds/rtps/attributes/ThreadSettings.hpp>
+#include <fastdds/rtps/flowcontrol/FlowControllerDescriptor.hpp>
+>>>>>>> 8cbd46144 (Methods to configure transport scenarios (#4098))
 #include <fastrtps/fastrtps_dll.h>
 #include <fastdds/dds/core/policy/QosPolicies.hpp>
 #include <fastdds/rtps/flowcontrol/FlowControllerDescriptor.hpp>
@@ -321,6 +328,144 @@ class DomainParticipantQos
         return flow_controllers_;
     }
 
+<<<<<<< HEAD
+=======
+    /**
+     * Getter for builtin flow controllers sender threads ThreadSettings
+     *
+     * @return rtps::ThreadSettings reference
+     */
+    rtps::ThreadSettings& builtin_controllers_sender_thread()
+    {
+        return builtin_controllers_sender_thread_;
+    }
+
+    /**
+     * Getter for builtin flow controllers sender threads ThreadSettings
+     *
+     * @return rtps::ThreadSettings reference
+     */
+    const rtps::ThreadSettings& builtin_controllers_sender_thread() const
+    {
+        return builtin_controllers_sender_thread_;
+    }
+
+    /**
+     * Provides a way of easily configuring transport related configuration on certain pre-defined scenarios.
+     *
+     * @param transports Defines the transport configuration scenario to setup.
+     */
+    RTPS_DllAPI void setup_transports(
+            rtps::BuiltinTransports transports);
+
+    /**
+     * Setter for the builtin flow controllers sender threads ThreadSettings
+     *
+     * @param value New ThreadSettings to be set
+     */
+    void builtin_controllers_sender_thread(
+            const rtps::ThreadSettings& value)
+    {
+        builtin_controllers_sender_thread_ = value;
+    }
+
+    /**
+     * Getter for timed event ThreadSettings
+     *
+     * @return rtps::ThreadSettings reference
+     */
+    rtps::ThreadSettings& timed_events_thread()
+    {
+        return timed_events_thread_;
+    }
+
+    /**
+     * Getter for timed event ThreadSettings
+     *
+     * @return rtps::ThreadSettings reference
+     */
+    const rtps::ThreadSettings& timed_events_thread() const
+    {
+        return timed_events_thread_;
+    }
+
+    /**
+     * Setter for the timed event ThreadSettings
+     *
+     * @param value New ThreadSettings to be set
+     */
+    void timed_events_thread(
+            const rtps::ThreadSettings& value)
+    {
+        timed_events_thread_ = value;
+    }
+
+    /**
+     * Getter for discovery server ThreadSettings
+     *
+     * @return rtps::ThreadSettings reference
+     */
+    rtps::ThreadSettings& discovery_server_thread()
+    {
+        return discovery_server_thread_;
+    }
+
+    /**
+     * Getter for discovery server ThreadSettings
+     *
+     * @return rtps::ThreadSettings reference
+     */
+    const rtps::ThreadSettings& discovery_server_thread() const
+    {
+        return discovery_server_thread_;
+    }
+
+    /**
+     * Setter for the discovery server ThreadSettings
+     *
+     * @param value New ThreadSettings to be set
+     */
+    void discovery_server_thread(
+            const rtps::ThreadSettings& value)
+    {
+        discovery_server_thread_ = value;
+    }
+
+#if HAVE_SECURITY
+    /**
+     * Getter for security log ThreadSettings
+     *
+     * @return rtps::ThreadSettings reference
+     */
+    rtps::ThreadSettings& security_log_thread()
+    {
+        return security_log_thread_;
+    }
+
+    /**
+     * Getter for security log ThreadSettings
+     *
+     * @return rtps::ThreadSettings reference
+     */
+    const rtps::ThreadSettings& security_log_thread() const
+    {
+        return security_log_thread_;
+    }
+
+    /**
+     * Setter for the security log ThreadSettings
+     *
+     * @param value New ThreadSettings to be set
+     */
+    void security_log_thread(
+            const rtps::ThreadSettings& value)
+    {
+        security_log_thread_ = value;
+    }
+
+#endif // if HAVE_SECURITY
+
+>>>>>>> 8cbd46144 (Methods to configure transport scenarios (#4098))
 private:
 
     //!UserData Qos, implemented in the library.
diff --git a/include/fastdds/rtps/attributes/BuiltinTransports.hpp b/include/fastdds/rtps/attributes/BuiltinTransports.hpp
new file mode 100644
index 00000000000..6f297d77567
--- /dev/null
+++ b/include/fastdds/rtps/attributes/BuiltinTransports.hpp
@@ -0,0 +1,85 @@
+// Copyright 2023 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @file BuiltinTransports.hpp
+ */
+
+#ifndef _FASTDDS_RTPS_ATTRIBUTES__BUILTINTRANSPORTS_HPP_
+#define _FASTDDS_RTPS_ATTRIBUTES__BUILTINTRANSPORTS_HPP_
+
+#include <ostream>
+#include <cstdint>
+
+namespace eprosima {
+namespace fastdds {
+namespace rtps {
+
+/**
+ * Defines the kind of transports automatically instantiated upon the creation of a participant
+ */
+enum class BuiltinTransports : uint16_t
+{
+    NONE = 0,      //< No transport will be instantiated
+    DEFAULT = 1,   //< Default value that will instantiate UDPv4 and SHM transports
+    DEFAULTv6 = 2,     //< Instantiate UDPv6 and SHM transports
+    SHM = 3,           //< Instantiate SHM transport only
+    UDPv4 = 4,         //< Instantiate UDPv4 transport only
+    UDPv6 = 5,         //< Instantiate UDPv6 transport only
+    LARGE_DATA = 6,    //< Instantiate SHM, UDPv4 and TCPv4 transports, but UDPv4 is only used for bootstrapping discovery
+    LARGE_DATAv6 = 7   //< Instantiate SHM, UDPv6 and TCPv6 transports, but UDPv6 is only used for bootstrapping discovery
+};
+
+inline std::ostream& operator <<(
+        std::ostream& output,
+        BuiltinTransports transports)
+{
+    switch (transports)
+    {
+        case BuiltinTransports::NONE:
+            output << "NONE";
+            break;
+        case BuiltinTransports::DEFAULT:
+            output << "DEFAULT";
+            break;
+        case BuiltinTransports::DEFAULTv6:
+            output << "DEFAULTv6";
+            break;
+        case BuiltinTransports::SHM:
+            output << "SHM";
+            break;
+        case BuiltinTransports::UDPv4:
+            output << "UDPv4";
+            break;
+        case BuiltinTransports::UDPv6:
+            output << "UDPv6";
+            break;
+        case BuiltinTransports::LARGE_DATA:
+            output << "LARGE_DATA";
+            break;
+        case BuiltinTransports::LARGE_DATAv6:
+            output << "LARGE_DATAv6";
+            break;
+        default:
+            output << "UNKNOWN";
+            break;
+    }
+    return output;
+}
+
+}  // namespace rtps
+}  // namespace fastdds
+}  // namespace eprosima
+
+#endif  // _FASTDDS_RTPS_ATTRIBUTES__BUILTINTRANSPORTS_HPP_
diff --git a/include/fastdds/rtps/attributes/RTPSParticipantAttributes.h b/include/fastdds/rtps/attributes/RTPSParticipantAttributes.h
index 09be3da4531..8418b5f4e08 100644
--- a/include/fastdds/rtps/attributes/RTPSParticipantAttributes.h
+++ b/include/fastdds/rtps/attributes/RTPSParticipantAttributes.h
@@ -19,6 +19,13 @@
 #ifndef _FASTDDS_RTPSPARTICIPANTPARAMETERS_H_
 #define _FASTDDS_RTPSPARTICIPANTPARAMETERS_H_
 
+<<<<<<< HEAD
+=======
+#include <memory>
+#include <sstream>
+
+#include <fastdds/rtps/attributes/BuiltinTransports.hpp>
+>>>>>>> 8cbd46144 (Methods to configure transport scenarios (#4098))
 #include <fastdds/rtps/attributes/ExternalLocators.hpp>
 #include <fastdds/rtps/attributes/PropertyPolicy.h>
 #include <fastdds/rtps/attributes/RTPSParticipantAllocationAttributes.hpp>
@@ -36,14 +43,12 @@
 #include <sstream>
 
 namespace eprosima {
-
 namespace fastdds {
-
 namespace rtps {
 
 /**
  * Struct to define participant types to set participant type parameter property
- *@ingroup DISCOVERY_MODULE
+ * @ingroup DISCOVERY_MODULE
  */
 struct ParticipantType
 {
@@ -57,14 +62,13 @@ struct ParticipantType
     static constexpr const char* UNKNOWN = "UNKNOWN";
 };
 
-} /* namespace rtps */
-} /* namespace fastdds */
+}  // namespace rtps
+}  // namespace fastdds
 
 namespace fastrtps {
 namespace rtps {
 
-
-//!PDP subclass choice
+//! PDP subclass choice
 typedef enum DiscoveryProtocol
 {
     NONE,
@@ -127,7 +131,7 @@ inline std::ostream& operator <<(
     return output;
 }
 
-//!Filtering flags when discovering participants
+//! Filtering flags when discovering participants
 typedef enum ParticipantFilteringFlags : uint32_t
 {
     NO_FILTER = 0,
@@ -440,7 +444,7 @@ class BuiltinAttributes
 
 /**
  * Class RTPSParticipantAttributes used to define different aspects of a RTPSParticipant.
- *@ingroup RTPS_ATTRIBUTES_MODULE
+ * @ingroup RTPS_ATTRIBUTES_MODULE
  */
 class RTPSParticipantAttributes
 {
@@ -448,18 +452,9 @@ class RTPSParticipantAttributes
 
 public:
 
-    RTPSParticipantAttributes()
-    {
-        setName("RTPSParticipant");
-        sendSocketBufferSize = 0;
-        listenSocketBufferSize = 0;
-        participantID = -1;
-        useBuiltinTransports = true;
-    }
+    RTPSParticipantAttributes() = default;
 
-    virtual ~RTPSParticipantAttributes()
-    {
-    }
+    virtual ~RTPSParticipantAttributes() = default;
 
     bool operator ==(
             const RTPSParticipantAttributes& b) const
@@ -482,6 +477,14 @@ class RTPSParticipantAttributes
                (this->flow_controllers == b.flow_controllers);
     }
 
+    /**
+     * Provides a way of easily configuring transport related configuration on certain pre-defined scenarios.
+     *
+     * @param transports Defines the transport configuration scenario to setup.
+     */
+    RTPS_DllAPI void setup_transports(
+            fastdds::rtps::BuiltinTransports transports);
+
     /**
      * Default list of Unicast Locators to be used for any Endpoint defined inside this RTPSParticipant in the case
      * that it was defined with NO UnicastLocators. At least ONE locator should be included in this list.
@@ -508,12 +511,12 @@ class RTPSParticipantAttributes
      * @brief Send socket buffer size for the send resource. Zero value indicates to use default system buffer size.
      * Default value: 0.
      */
-    uint32_t sendSocketBufferSize;
+    uint32_t sendSocketBufferSize = 0;
 
     /*! Listen socket buffer for all listen resources. Zero value indicates to use default system buffer size.
      * Default value: 0.
      */
-    uint32_t listenSocketBufferSize;
+    uint32_t listenSocketBufferSize = 0;
 
     //! Optionally allows user to define the GuidPrefix_t
     GuidPrefix_t prefix;
@@ -534,7 +537,7 @@ class RTPSParticipantAttributes
     std::vector<octet> userData;
 
     //! Participant ID
-    int32_t participantID;
+    int32_t participantID = -1;
 
     /**
      * @brief Throughput controller parameters. Leave default for uncontrolled flow.
@@ -546,8 +549,8 @@ class RTPSParticipantAttributes
     //! User defined transports to use alongside or in place of builtins.
     std::vector<std::shared_ptr<fastdds::rtps::TransportDescriptorInterface>> userTransports;
 
-    //! Set as false to disable the default UDPv4 implementation.
-    bool useBuiltinTransports;
+    //! Set as false to disable the creation of the default transports.
+    bool useBuiltinTransports = true;
 
     //! Holds allocation limits affecting collections managed by a participant.
     RTPSParticipantAllocationAttributes allocation;
@@ -574,11 +577,11 @@ class RTPSParticipantAttributes
 private:
 
     //! Name of the participant.
-    string_255 name;
+    string_255 name{"RTPSParticipant"};
 };
 
-} /* namespace rtps */
-} /* namespace fastrtps */
-} /* namespace eprosima */
+}  // namespace rtps
+}  // namespace fastrtps
+}  // namespace eprosima
 
-#endif /* _FASTDDS_RTPSPARTICIPANTPARAMETERS_H_ */
+#endif  // _FASTDDS_RTPSPARTICIPANTPARAMETERS_H_
diff --git a/include/fastrtps/xmlparser/XMLParser.h b/include/fastrtps/xmlparser/XMLParser.h
index 980d24a7641..d59072cdf68 100644
--- a/include/fastrtps/xmlparser/XMLParser.h
+++ b/include/fastrtps/xmlparser/XMLParser.h
@@ -608,6 +608,31 @@ class XMLParser
             tinyxml2::XMLElement* elem,
             SubscriberAttributes& subscriber,
             uint8_t ident);
+<<<<<<< HEAD
+=======
+
+    RTPS_DllAPI static XMLP_ret getXMLThreadSettings(
+            tinyxml2::XMLElement& elem,
+            fastdds::rtps::ThreadSettings& thread_setting);
+
+    /*
+        Return XMLP_ret::XML_OK when OK, XMLP_ret::XML_NOK when port attribute is not present, and
+        XMLP_ret::XML_ERROR if error
+     */
+    RTPS_DllAPI static XMLP_ret getXMLThreadSettingsWithPort(
+            tinyxml2::XMLElement& elem,
+            fastdds::rtps::ThreadSettings& thread_setting,
+            uint32_t& port);
+
+    RTPS_DllAPI static XMLP_ret getXMLEntityFactoryQos(
+            tinyxml2::XMLElement& elem,
+            fastdds::dds::EntityFactoryQosPolicy& entity_factory);
+
+    RTPS_DllAPI static XMLP_ret getXMLBuiltinTransports(
+            tinyxml2::XMLElement* elem,
+            eprosima::fastdds::rtps::BuiltinTransports* bt,
+            uint8_t ident);
+>>>>>>> 8cbd46144 (Methods to configure transport scenarios (#4098))
 };
 
 } // namespace xmlparser
diff --git a/include/fastrtps/xmlparser/XMLParserCommon.h b/include/fastrtps/xmlparser/XMLParserCommon.h
index 502d7772ebc..510c66ce776 100644
--- a/include/fastrtps/xmlparser/XMLParserCommon.h
+++ b/include/fastrtps/xmlparser/XMLParserCommon.h
@@ -117,6 +117,7 @@ extern const char* IP6_TO_SEND;
 extern const char* THROUGHPUT_CONT;
 extern const char* USER_TRANS;
 extern const char* USE_BUILTIN_TRANS;
+extern const char* BUILTIN_TRANS;
 extern const char* PROPERTIES_POLICY;
 extern const char* NAME;
 extern const char* REMOTE_LOCATORS;
@@ -175,6 +176,10 @@ extern const char* UDPv6;
 extern const char* TCPv4;
 extern const char* TCPv6;
 extern const char* SHM;
+extern const char* DEFAULT_C;
+extern const char* DEFAULTv6;
+extern const char* LARGE_DATA;
+extern const char* LARGE_DATAv6;
 extern const char* INIT_ACKNACK_DELAY;
 extern const char* HEARTB_RESP_DELAY;
 extern const char* INIT_HEARTB_DELAY;
diff --git a/resources/xsd/fastRTPS_profiles.xsd b/resources/xsd/fastRTPS_profiles.xsd
index e03a2237b77..e98c7818c06 100644
--- a/resources/xsd/fastRTPS_profiles.xsd
+++ b/resources/xsd/fastRTPS_profiles.xsd
@@ -99,6 +99,7 @@
         |
         ├ domainID [uint32], (0~232)
         └ rtps     [0~1]
+<<<<<<< HEAD
             ├ name                              [string],
             ├ defaultUnicastLocatorList         [0~1],
             ├ defaultMulticastLocatorList       [0~1],
@@ -116,6 +117,31 @@
             ├ allocation                        [0~1],
             ├ userData                          [0~1],
             └ prefix                            [0~1]-->
+=======
+            ├ name                                 [string],
+            ├ defaultUnicastLocatorList            [0~1],
+            ├ defaultMulticastLocatorList          [0~1],
+            ├ default_external_unicast_locators    [0~1],
+            ├ ignore_non_matching_locators         [bool],
+            ├ sendSocketBufferSize                 [uint32],
+            ├ listenSocketBufferSize               [uint32],
+            ├ builtin                              [0~1],
+            ├ port                                 [0~1],
+            ├ participantID                        [int32],
+            ├ userTransports                       [0~1],
+            |   └ transport_id                     [1~*] [string],
+            ├ useBuiltinTransports                 [bool],
+            ├ builtinTransports                    [0~1][string]
+            ├ propertiesPolicy                     [0~1],
+            ├ allocation                           [0~1],
+            ├ userData                             [0~1],
+            ├ prefix                               [0~1],
+            ├ builtin_controllers_sender_thread    [threadSettingsType],
+            ├ timed_events_thread                  [threadSettingsType],
+            ├ discovery_server_thread              [threadSettingsType],
+            ├ builtin_transports_reception_threads [threadSettingsType],
+            └ security_log_thread                  [threadSettingsType]-->
+>>>>>>> 8cbd46144 (Methods to configure transport scenarios (#4098))
     <!-- TODO:  How to ensure that the userTransports identifiers exist in transport descriptors in the XML file? -->
     <xs:complexType name="participantProfileType">
         <xs:all>
@@ -141,6 +167,20 @@
                             </xs:complexType>
                         </xs:element>
                         <xs:element name="useBuiltinTransports" type="boolean" minOccurs="0" maxOccurs="1"/>
+                        <xs:element name="builtinTransports" minOccurs="0" maxOccurs="1">
+                            <xs:simpleType>
+                                <xs:restriction base="xs:string">
+                                    <xs:enumeration value="NONE"/>
+                                    <xs:enumeration value="DEFAULT"/>
+                                    <xs:enumeration value="DEFAULTv6"/>
+                                    <xs:enumeration value="SHM"/>
+                                    <xs:enumeration value="UDPv4"/>
+                                    <xs:enumeration value="UDPv6"/>
+                                    <xs:enumeration value="LARGE_DATA"/>
+                                    <xs:enumeration value="LARGE_DATAv6"/>
+                                </xs:restriction>
+                            </xs:simpleType>
+                        </xs:element>
                         <xs:element name="propertiesPolicy" type="propertyPolicyType" minOccurs="0" maxOccurs="1"/>
                         <xs:element name="allocation" type="rtpsParticipantAllocationAttributesType"  minOccurs="0" maxOccurs="1"/>
                         <xs:element name="userData" type="octectVectorQosPolicyType" minOccurs="0" maxOccurs="1"/>
@@ -504,9 +544,6 @@
         <xs:attribute name="mapMaxLength" type="int32" use="optional"/>
     </xs:complexType>
 
-
-
-
     <!--| LOG ELEMENTS |-->
     <!--Log consumer:
         ├ class         [string] ("StdoutConsumer" OR "StdoutErrConsumer" OR "FileConsumer"),
@@ -853,12 +890,24 @@
             <xs:element name="maxInitialPeersRange" type="uint32" minOccurs="0" maxOccurs="1"/>
             <xs:element name="interfaceWhiteList" minOccurs="0" maxOccurs="1">
                 <xs:complexType>
+<<<<<<< HEAD
                     <xs:sequence minOccurs="0" maxOccurs="unbounded">
                         <xs:element name="address" minOccurs="0" maxOccurs="unbounded">
                             <xs:simpleType>
                                 <xs:union memberTypes="ipv4Address ipv6Address"/>
                             </xs:simpleType>
                         </xs:element>
+=======
+                    <xs:sequence minOccurs="1" maxOccurs="unbounded">
+                        <xs:choice minOccurs="1">
+                            <xs:element name="address" maxOccurs="unbounded">
+                                <xs:simpleType>
+                                    <xs:union memberTypes="ipv4Address ipv6Address"/>
+                                </xs:simpleType>
+                            </xs:element>
+                            <xs:element name="interface" type="string" maxOccurs="unbounded"/>
+                        </xs:choice>
+>>>>>>> 8cbd46144 (Methods to configure transport scenarios (#4098))
                     </xs:sequence>
                 </xs:complexType>
             </xs:element>
diff --git a/src/cpp/CMakeLists.txt b/src/cpp/CMakeLists.txt
index efff95a806f..9a4fb442ffa 100644
--- a/src/cpp/CMakeLists.txt
+++ b/src/cpp/CMakeLists.txt
@@ -78,6 +78,7 @@ set(${PROJECT_NAME}_source_files
     rtps/network/ExternalLocatorsProcessor.cpp
     rtps/network/NetworkFactory.cpp
     rtps/network/ReceiverResource.cpp
+    rtps/attributes/RTPSParticipantAttributes.cpp
     rtps/participant/RTPSParticipant.cpp
     rtps/participant/RTPSParticipantImpl.cpp
     rtps/RTPSDomain.cpp
diff --git a/src/cpp/fastdds/domain/qos/DomainParticipantQos.cpp b/src/cpp/fastdds/domain/qos/DomainParticipantQos.cpp
index b38ed9fd319..296182cb360 100644
--- a/src/cpp/fastdds/domain/qos/DomainParticipantQos.cpp
+++ b/src/cpp/fastdds/domain/qos/DomainParticipantQos.cpp
@@ -19,12 +19,27 @@
 
 #include <fastdds/dds/domain/qos/DomainParticipantQos.hpp>
 
+#include <fastdds/rtps/attributes/BuiltinTransports.hpp>
+#include <fastdds/rtps/attributes/RTPSParticipantAttributes.h>
+#include <fastdds/utils/QosConverters.hpp>
+
 namespace eprosima {
 namespace fastdds {
 namespace dds {
 
 const DomainParticipantQos PARTICIPANT_QOS_DEFAULT;
 
+void DomainParticipantQos::setup_transports(
+        rtps::BuiltinTransports transports)
+{
+    fastrtps::rtps::RTPSParticipantAttributes attr;
+    utils::set_attributes_from_qos(attr, *this);
+
+    attr.setup_transports(transports);
+
+    utils::set_qos_from_attributes(*this, attr);
+}
+
 } /* namespace dds */
 } /* namespace fastdds */
 } /* namespace eprosima */
diff --git a/src/cpp/rtps/attributes/RTPSParticipantAttributes.cpp b/src/cpp/rtps/attributes/RTPSParticipantAttributes.cpp
new file mode 100644
index 00000000000..74cfbb5e829
--- /dev/null
+++ b/src/cpp/rtps/attributes/RTPSParticipantAttributes.cpp
@@ -0,0 +1,318 @@
+// Copyright 2023 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <fastdds/rtps/attributes/RTPSParticipantAttributes.h>
+
+#include <algorithm>
+#include <memory>
+
+#include <fastdds/dds/log/Log.hpp>
+#include <fastdds/rtps/attributes/BuiltinTransports.hpp>
+#include <fastdds/rtps/common/Locator.h>
+#include <fastdds/rtps/transport/TCPv4TransportDescriptor.h>
+#include <fastdds/rtps/transport/TCPv6TransportDescriptor.h>
+#include <fastdds/rtps/transport/UDPv4TransportDescriptor.h>
+#include <fastdds/rtps/transport/UDPv6TransportDescriptor.h>
+#include <fastdds/rtps/transport/shared_mem/SharedMemTransportDescriptor.h>
+#include <fastrtps/utils/IPLocator.h>
+#include <fastrtps/xmlparser/XMLProfileManager.h>
+
+#include <rtps/transport/shared_mem/SHMLocator.hpp>
+
+namespace eprosima {
+namespace fastrtps {
+namespace rtps {
+
+static bool is_intraprocess_only(
+        const RTPSParticipantAttributes& att)
+{
+    return
+        xmlparser::XMLProfileManager::library_settings().intraprocess_delivery == INTRAPROCESS_FULL &&
+        att.builtin.discovery_config.ignoreParticipantFlags ==
+        (ParticipantFilteringFlags::FILTER_DIFFERENT_HOST | ParticipantFilteringFlags::FILTER_DIFFERENT_PROCESS);
+}
+
+static std::shared_ptr<fastdds::rtps::SharedMemTransportDescriptor> create_shm_transport(
+        const RTPSParticipantAttributes& att)
+{
+    auto descriptor = std::make_shared<fastdds::rtps::SharedMemTransportDescriptor>();
+
+    // We assume (Linux) UDP doubles the user socket buffer size in kernel, so
+    // the equivalent segment size in SHM would be socket buffer size x 2
+    auto segment_size_udp_equivalent =
+            std::max(att.sendSocketBufferSize, att.listenSocketBufferSize) * 2;
+    descriptor->segment_size(segment_size_udp_equivalent);
+    descriptor->default_reception_threads(att.builtin_transports_reception_threads);
+    return descriptor;
+}
+
+static std::shared_ptr<fastdds::rtps::UDPv4TransportDescriptor> create_udpv4_transport(
+        const RTPSParticipantAttributes& att,
+        bool intraprocess_only)
+{
+    auto descriptor = std::make_shared<fastdds::rtps::UDPv4TransportDescriptor>();
+    descriptor->sendBufferSize = att.sendSocketBufferSize;
+    descriptor->receiveBufferSize = att.listenSocketBufferSize;
+    descriptor->default_reception_threads(att.builtin_transports_reception_threads);
+    if (intraprocess_only)
+    {
+        // Avoid multicast leaving the host for intraprocess-only participants
+        descriptor->TTL = 0;
+    }
+    return descriptor;
+}
+
+static std::shared_ptr<fastdds::rtps::UDPv6TransportDescriptor> create_udpv6_transport(
+        const RTPSParticipantAttributes& att,
+        bool intraprocess_only)
+{
+    auto descriptor = std::make_shared<fastdds::rtps::UDPv6TransportDescriptor>();
+    descriptor->sendBufferSize = att.sendSocketBufferSize;
+    descriptor->receiveBufferSize = att.listenSocketBufferSize;
+    descriptor->default_reception_threads(att.builtin_transports_reception_threads);
+    if (intraprocess_only)
+    {
+        // Avoid multicast leaving the host for intraprocess-only participants
+        descriptor->TTL = 0;
+    }
+    return descriptor;
+}
+
+static std::shared_ptr<fastdds::rtps::TCPv4TransportDescriptor> create_tcpv4_transport(
+        const RTPSParticipantAttributes& att)
+{
+    auto descriptor = std::make_shared<fastdds::rtps::TCPv4TransportDescriptor>();
+    descriptor->add_listener_port(0);
+    descriptor->sendBufferSize = att.sendSocketBufferSize;
+    descriptor->receiveBufferSize = att.listenSocketBufferSize;
+
+    descriptor->calculate_crc = false;
+    descriptor->check_crc = false;
+    descriptor->apply_security = false;
+    descriptor->enable_tcp_nodelay = true;
+
+    descriptor->default_reception_threads(att.builtin_transports_reception_threads);
+    descriptor->accept_thread = att.builtin_transports_reception_threads;
+    descriptor->keep_alive_thread = att.builtin_transports_reception_threads;
+    return descriptor;
+}
+
+static std::shared_ptr<fastdds::rtps::TCPv6TransportDescriptor> create_tcpv6_transport(
+        const RTPSParticipantAttributes& att)
+{
+    auto descriptor = std::make_shared<fastdds::rtps::TCPv6TransportDescriptor>();
+    descriptor->add_listener_port(0);
+    descriptor->sendBufferSize = att.sendSocketBufferSize;
+    descriptor->receiveBufferSize = att.listenSocketBufferSize;
+
+    descriptor->calculate_crc = false;
+    descriptor->check_crc = false;
+    descriptor->apply_security = false;
+    descriptor->enable_tcp_nodelay = true;
+
+    descriptor->default_reception_threads(att.builtin_transports_reception_threads);
+    descriptor->accept_thread = att.builtin_transports_reception_threads;
+    descriptor->keep_alive_thread = att.builtin_transports_reception_threads;
+    return descriptor;
+}
+
+static void setup_transports_default(
+        RTPSParticipantAttributes& att,
+        bool intraprocess_only)
+{
+    auto descriptor = create_udpv4_transport(att, intraprocess_only);
+
+#ifdef SHM_TRANSPORT_BUILTIN
+    if (!intraprocess_only)
+    {
+        auto shm_transport = create_shm_transport(att);
+        // Use same default max_message_size on both UDP and SHM
+        shm_transport->max_message_size(descriptor->max_message_size());
+        att.userTransports.push_back(shm_transport);
+    }
+#endif // ifdef SHM_TRANSPORT_BUILTIN
+
+    att.userTransports.push_back(descriptor);
+}
+
+static void setup_transports_defaultv6(
+        RTPSParticipantAttributes& att,
+        bool intraprocess_only)
+{
+    auto descriptor = create_udpv6_transport(att, intraprocess_only);
+
+#ifdef SHM_TRANSPORT_BUILTIN
+    if (!intraprocess_only)
+    {
+        auto shm_transport = create_shm_transport(att);
+        // Use same default max_message_size on both UDP and SHM
+        shm_transport->max_message_size(descriptor->max_message_size());
+        att.userTransports.push_back(shm_transport);
+    }
+#endif // ifdef SHM_TRANSPORT_BUILTIN
+
+    att.userTransports.push_back(descriptor);
+}
+
+static void setup_transports_shm(
+        RTPSParticipantAttributes& att)
+{
+#ifdef FASTDDS_SHM_TRANSPORT_DISABLED
+    EPROSIMA_LOG_ERROR(RTPS_PARTICIPANT, "Trying to configure SHM transport only, " <<
+            "but Fast DDS was built without SHM transport support.");
+#else
+    auto descriptor = create_shm_transport(att);
+    att.userTransports.push_back(descriptor);
+#endif  // FASTDDS_SHM_TRANSPORT_DISABLED
+}
+
+static void setup_transports_udpv4(
+        RTPSParticipantAttributes& att,
+        bool intraprocess_only)
+{
+    auto descriptor = create_udpv4_transport(att, intraprocess_only);
+    att.userTransports.push_back(descriptor);
+}
+
+static void setup_transports_udpv6(
+        RTPSParticipantAttributes& att,
+        bool intraprocess_only)
+{
+    auto descriptor = create_udpv6_transport(att, intraprocess_only);
+    att.userTransports.push_back(descriptor);
+}
+
+static void setup_transports_large_data(
+        RTPSParticipantAttributes& att,
+        bool intraprocess_only)
+{
+    if (!intraprocess_only)
+    {
+        auto shm_transport = create_shm_transport(att);
+        att.userTransports.push_back(shm_transport);
+
+        auto shm_loc = fastdds::rtps::SHMLocator::create_locator(0, fastdds::rtps::SHMLocator::Type::UNICAST);
+        att.builtin.metatrafficUnicastLocatorList.push_back(shm_loc);
+        att.defaultUnicastLocatorList.push_back(shm_loc);
+
+        auto tcp_transport = create_tcpv4_transport(att);
+        att.userTransports.push_back(tcp_transport);
+
+        Locator_t tcp_loc;
+        tcp_loc.kind = LOCATOR_KIND_TCPv4;
+        IPLocator::setIPv4(tcp_loc, "0.0.0.0");
+        IPLocator::setPhysicalPort(tcp_loc, 0);
+        IPLocator::setLogicalPort(tcp_loc, 0);
+        att.builtin.metatrafficUnicastLocatorList.push_back(tcp_loc);
+        att.defaultUnicastLocatorList.push_back(tcp_loc);
+    }
+
+    auto udp_descriptor = create_udpv4_transport(att, intraprocess_only);
+    att.userTransports.push_back(udp_descriptor);
+
+    if (!intraprocess_only)
+    {
+        Locator_t pdp_locator;
+        pdp_locator.kind = LOCATOR_KIND_UDPv4;
+        IPLocator::setIPv4(pdp_locator, "239.255.0.1");
+        att.builtin.metatrafficMulticastLocatorList.push_back(pdp_locator);
+    }
+}
+
+static void setup_transports_large_datav6(
+        RTPSParticipantAttributes& att,
+        bool intraprocess_only)
+{
+    if (!intraprocess_only)
+    {
+        auto shm_transport = create_shm_transport(att);
+        att.userTransports.push_back(shm_transport);
+
+        auto shm_loc = fastdds::rtps::SHMLocator::create_locator(0, fastdds::rtps::SHMLocator::Type::UNICAST);
+        att.builtin.metatrafficUnicastLocatorList.push_back(shm_loc);
+        att.defaultUnicastLocatorList.push_back(shm_loc);
+
+        auto tcp_transport = create_tcpv6_transport(att);
+        att.userTransports.push_back(tcp_transport);
+
+        Locator_t tcp_loc;
+        tcp_loc.kind = LOCATOR_KIND_TCPv6;
+        IPLocator::setIPv6(tcp_loc, "::");
+        IPLocator::setPhysicalPort(tcp_loc, 0);
+        IPLocator::setLogicalPort(tcp_loc, 0);
+        att.builtin.metatrafficUnicastLocatorList.push_back(tcp_loc);
+        att.defaultUnicastLocatorList.push_back(tcp_loc);
+    }
+
+    auto udp_descriptor = create_udpv6_transport(att, intraprocess_only);
+    att.userTransports.push_back(udp_descriptor);
+
+    if (!intraprocess_only)
+    {
+        Locator_t pdp_locator;
+        pdp_locator.kind = LOCATOR_KIND_UDPv6;
+        att.builtin.metatrafficMulticastLocatorList.push_back(pdp_locator);
+    }
+}
+
+void RTPSParticipantAttributes::setup_transports(
+        fastdds::rtps::BuiltinTransports transports)
+{
+    bool intraprocess_only = is_intraprocess_only(*this);
+
+    switch (transports)
+    {
+        case fastdds::rtps::BuiltinTransports::NONE:
+            break;
+
+        case fastdds::rtps::BuiltinTransports::DEFAULT:
+            setup_transports_default(*this, intraprocess_only);
+            break;
+
+        case fastdds::rtps::BuiltinTransports::DEFAULTv6:
+            setup_transports_defaultv6(*this, intraprocess_only);
+            break;
+
+        case fastdds::rtps::BuiltinTransports::SHM:
+            setup_transports_shm(*this);
+            break;
+
+        case fastdds::rtps::BuiltinTransports::UDPv4:
+            setup_transports_udpv4(*this, intraprocess_only);
+            break;
+
+        case fastdds::rtps::BuiltinTransports::UDPv6:
+            setup_transports_udpv6(*this, intraprocess_only);
+            break;
+
+        case fastdds::rtps::BuiltinTransports::LARGE_DATA:
+            setup_transports_large_data(*this, intraprocess_only);
+            break;
+
+        case fastdds::rtps::BuiltinTransports::LARGE_DATAv6:
+            setup_transports_large_datav6(*this, intraprocess_only);
+            break;
+
+        default:
+            EPROSIMA_LOG_ERROR(RTPS_PARTICIPANT,
+                    "Setup for '" << transports << "' transport configuration not yet supported.");
+            return;
+    }
+
+    useBuiltinTransports = false;
+}
+
+} // namespace rtps
+} // namespace fastdds
+} // namespace eprosima
diff --git a/src/cpp/rtps/participant/RTPSParticipantImpl.cpp b/src/cpp/rtps/participant/RTPSParticipantImpl.cpp
index 07f8d108e67..d0c518e2429 100644
--- a/src/cpp/rtps/participant/RTPSParticipantImpl.cpp
+++ b/src/cpp/rtps/participant/RTPSParticipantImpl.cpp
@@ -24,6 +24,7 @@
 #include <sstream>
 
 #include <fastdds/dds/log/Log.hpp>
+#include <fastdds/rtps/attributes/BuiltinTransports.hpp>
 #include <fastdds/rtps/attributes/ServerAttributes.h>
 #include <fastdds/rtps/builtin/BuiltinProtocols.h>
 #include <fastdds/rtps/builtin/discovery/endpoint/EDP.h>
@@ -61,6 +62,8 @@
 #include <rtps/participant/RTPSParticipantImpl.h>
 #include <rtps/persistence/PersistenceService.h>
 #include <statistics/rtps/GuidUtils.hpp>
+#include <utils/SystemInfo.hpp>
+#include <utils/string_utilities.hpp>
 
 namespace eprosima {
 namespace fastrtps {
@@ -69,6 +72,35 @@ namespace rtps {
 using UDPv4TransportDescriptor = fastdds::rtps::UDPv4TransportDescriptor;
 using TCPTransportDescriptor = fastdds::rtps::TCPTransportDescriptor;
 using SharedMemTransportDescriptor = fastdds::rtps::SharedMemTransportDescriptor;
+using BuiltinTransports = fastdds::rtps::BuiltinTransports;
+
+/**
+ * Parse the environment variable specifying the transports to instantiate
+ */
+static BuiltinTransports get_builtin_transports_from_env_var()
+{
+    static constexpr const char* env_var_name = "FASTDDS_BUILTIN_TRANSPORTS";
+
+    BuiltinTransports ret_val = BuiltinTransports::DEFAULT;
+    std::string env_value;
+    if (SystemInfo::get_env(env_var_name, env_value) == ReturnCode_t::RETCODE_OK)
+    {
+        if (!get_element_enum_value(env_value.c_str(), ret_val,
+                "NONE", BuiltinTransports::NONE,
+                "DEFAULT", BuiltinTransports::DEFAULT,
+                "DEFAULTv6", BuiltinTransports::DEFAULTv6,
+                "SHM", BuiltinTransports::SHM,
+                "UDPv4", BuiltinTransports::UDPv4,
+                "UDPv6", BuiltinTransports::UDPv6,
+                "LARGE_DATA", BuiltinTransports::LARGE_DATA,
+                "LARGE_DATAv6", BuiltinTransports::LARGE_DATAv6))
+        {
+            EPROSIMA_LOG_ERROR(RTPS_PARTICIPANT, "Wrong value '" << env_value << "' for environment variable '" <<
+                    env_var_name << "'. Leaving as DEFAULT");
+        }
+    }
+    return ret_val;
+}
 
 static EntityId_t TrustedWriter(
         const EntityId_t& reader)
@@ -150,6 +182,7 @@ RTPSParticipantImpl::RTPSParticipantImpl(
     {
         m_persistence_guid = GUID_t(persistence_guid, c_EntityId_RTPSParticipant);
     }
+<<<<<<< HEAD
     // Builtin transports by default
     if (PParam.useBuiltinTransports)
     {
@@ -177,10 +210,17 @@ RTPSParticipantImpl::RTPSParticipantImpl(
             has_shm_transport_ |= m_network_Factory.RegisterTransport(&shm_transport);
         }
 #endif // ifdef SHM_TRANSPORT_BUILTIN
+=======
+
+    // Setup builtin transports
+    if (m_att.useBuiltinTransports)
+    {
+        m_att.setup_transports(get_builtin_transports_from_env_var());
+>>>>>>> 8cbd46144 (Methods to configure transport scenarios (#4098))
     }
 
     // BACKUP servers guid is its persistence one
-    if (PParam.builtin.discovery_config.discoveryProtocol == DiscoveryProtocol::BACKUP)
+    if (m_att.builtin.discovery_config.discoveryProtocol == DiscoveryProtocol::BACKUP)
     {
         m_persistence_guid = m_guid;
     }
@@ -191,14 +231,14 @@ RTPSParticipantImpl::RTPSParticipantImpl(
     guid_str_ = guid_sstr.str();
 
     // Client-server discovery protocol requires that every TCP transport has a listening port
-    switch (PParam.builtin.discovery_config.discoveryProtocol)
+    switch (m_att.builtin.discovery_config.discoveryProtocol)
     {
         case DiscoveryProtocol::BACKUP:
         case DiscoveryProtocol::CLIENT:
         case DiscoveryProtocol::SERVER:
         case DiscoveryProtocol::SUPER_CLIENT:
             // Verify if listening ports are provided
-            for (auto& transportDescriptor : PParam.userTransports)
+            for (auto& transportDescriptor : m_att.userTransports)
             {
                 TCPTransportDescriptor* pT = dynamic_cast<TCPTransportDescriptor*>(transportDescriptor.get());
                 if (pT && pT->listening_ports.empty())
@@ -213,7 +253,7 @@ RTPSParticipantImpl::RTPSParticipantImpl(
     }
 
     // User defined transports
-    for (const auto& transportDescriptor : PParam.userTransports)
+    for (const auto& transportDescriptor : m_att.userTransports)
     {
         if (m_network_Factory.RegisterTransport(transportDescriptor.get(), &m_att.properties))
         {
@@ -339,7 +379,7 @@ RTPSParticipantImpl::RTPSParticipantImpl(
     // Start security
     if (!m_security_manager.init(
                 security_attributes_,
-                PParam.properties))
+                m_att.properties))
     {
         // Participant will be deleted, no need to allocate buffers or create builtin endpoints
         return;
@@ -392,12 +432,12 @@ RTPSParticipantImpl::RTPSParticipantImpl(
     flow_controller_factory_.init(this);
 
     // Support old API
-    if (PParam.throughputController.bytesPerPeriod != UINT32_MAX && PParam.throughputController.periodMillisecs != 0)
+    if (m_att.throughputController.bytesPerPeriod != UINT32_MAX && m_att.throughputController.periodMillisecs != 0)
     {
         fastdds::rtps::FlowControllerDescriptor old_descriptor;
         old_descriptor.name = guid_str_.c_str();
-        old_descriptor.max_bytes_per_period = PParam.throughputController.bytesPerPeriod;
-        old_descriptor.period_ms = PParam.throughputController.periodMillisecs;
+        old_descriptor.max_bytes_per_period = m_att.throughputController.bytesPerPeriod;
+        old_descriptor.period_ms = m_att.throughputController.periodMillisecs;
         flow_controller_factory_.register_flow_controller(old_descriptor);
     }
 
diff --git a/src/cpp/rtps/xmlparser/XMLElementParser.cpp b/src/cpp/rtps/xmlparser/XMLElementParser.cpp
index 883462a66bd..a257d52a719 100644
--- a/src/cpp/rtps/xmlparser/XMLElementParser.cpp
+++ b/src/cpp/rtps/xmlparser/XMLElementParser.cpp
@@ -25,7 +25,77 @@
 #include <fastrtps/utils/IPLocator.h>
 #include <fastdds/dds/log/Log.hpp>
 
+<<<<<<< HEAD
 using namespace eprosima::fastrtps;
+=======
+#include <rtps/xmlparser/XMLParserUtils.hpp>
+#include <utils/SystemInfo.hpp>
+#include <utils/string_utilities.hpp>
+
+namespace eprosima {
+namespace fastdds {
+namespace xml {
+namespace detail {
+
+static std::string process_environment(
+        const std::string& input)
+{
+    std::string ret_val = input;
+    /* From [IEEE Std 1003.1]:(https://pubs.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap08.html)
+     * Environment variable names used ... consist solely of uppercase letters, digits, and the '_' (underscore)
+     * from the characters defined in Portable Character Set and do not begin with a digit.
+     */
+    std::regex expression("\\$\\{([A-Z_][A-Z0-9_]*)\\}");
+    std::smatch match;
+
+    do
+    {
+        std::regex_search(ret_val, match, expression);
+        if (!match.empty())
+        {
+            std::string var_name = match[1];
+            std::string value;
+            if (ReturnCode_t::RETCODE_OK == SystemInfo::get_env(var_name, value))
+            {
+                ret_val = match.prefix().str() + value + match.suffix().str();
+            }
+            else
+            {
+                ret_val = match.prefix().str() + match.suffix().str();
+                EPROSIMA_LOG_ERROR(XMLPARSER, "Could not find a value for environment variable " << var_name);
+            }
+        }
+    } while (!match.empty());
+
+    return ret_val;
+}
+
+std::string get_element_text(
+        tinyxml2::XMLElement* element)
+{
+    std::string ret_val{};
+
+    assert(nullptr != element);
+    const char* text = element->GetText();
+    if (nullptr != text)
+    {
+        ret_val = process_environment(text);
+    }
+
+    return ret_val;
+}
+
+}  // namespace detail
+}  // namespace xml
+}  // namespace fastdds
+}  // namespace eprosima
+
+
+namespace eprosima {
+namespace fastrtps {
+namespace xmlparser {
+
+>>>>>>> 8cbd46144 (Methods to configure transport scenarios (#4098))
 using namespace eprosima::fastrtps::rtps;
 using namespace eprosima::fastrtps::xmlparser;
 
@@ -4341,3 +4411,244 @@ XMLP_ret XMLParser::getXMLSubscriberAttributes(
 
     return XMLP_ret::XML_OK;
 }
+<<<<<<< HEAD
+=======
+
+XMLP_ret XMLParser::getXMLThreadSettings(
+        tinyxml2::XMLElement& elem,
+        fastdds::rtps::ThreadSettings& thread_setting)
+{
+    /*
+        <xs:complexType name="threadSettingsType">
+            <xs:all>
+                <xs:element name="scheduling_policy" type="int32" minOccurs="0" maxOccurs="1"/>
+                <xs:element name="priority" type="int32" minOccurs="0" maxOccurs="1"/>
+                <xs:element name="affinity" type="uint32" minOccurs="0" maxOccurs="1"/>
+                <xs:element name="stack_size" type="int32" minOccurs="0" maxOccurs="1"/>
+            </xs:all>
+        </xs:complexType>
+     */
+    uint32_t port = 0;
+    return getXMLThreadSettingsWithPort(elem, thread_setting,
+                   port) != XMLP_ret::XML_ERROR ? XMLP_ret::XML_OK : XMLP_ret::XML_ERROR;
+}
+
+XMLP_ret XMLParser::getXMLThreadSettingsWithPort(
+        tinyxml2::XMLElement& elem,
+        fastdds::rtps::ThreadSettings& thread_setting,
+        uint32_t& port)
+{
+    /*
+        <xs:complexType name="threadSettingsWithPortType">
+            <xs:complexContent>
+                <xs:extension base="threadSettingsType">
+                    <xs:attribute name="port" type="uint32" use="optional"/>
+                </xs:extension>
+            </xs:complexContent>
+        </xs:complexType>
+     */
+
+    /*
+     * The are 4 allowed elements, all their min occurrences are 0, and their max are 1.
+     * In case port is not present, return NOK instead of ERROR
+     */
+    XMLP_ret ret = XMLP_ret::XML_OK;
+    bool port_found = false;
+    for (const tinyxml2::XMLAttribute* attrib = elem.FirstAttribute(); attrib != nullptr; attrib = attrib->Next())
+    {
+        if (strcmp(attrib->Name(), PORT) == 0)
+        {
+            try
+            {
+                std::string temp = attrib->Value();
+                temp.erase(std::remove_if(temp.begin(), temp.end(), [](unsigned char c)
+                        {
+                            return std::isspace(c);
+                        }), temp.end());
+                if (attrib->Value()[0] == '-')
+                {
+                    throw std::invalid_argument("Negative value detected");
+                }
+                port = static_cast<uint32_t>(std::stoul(attrib->Value()));
+                port_found = true;
+            }
+            catch (std::invalid_argument& except)
+            {
+                EPROSIMA_LOG_ERROR(XMLPARSER,
+                        "Found wrong value " << attrib->Value() << " for port attribute. " <<
+                        except.what());
+                ret = XMLP_ret::XML_ERROR;
+                break;
+            }
+        }
+        else
+        {
+            EPROSIMA_LOG_ERROR(XMLPARSER, "Found wrong attribute " << attrib->Name() << " in 'thread_settings");
+            ret = XMLP_ret::XML_ERROR;
+            break;
+        }
+    }
+
+    // Set ret to NOK is port attribute was not present
+    if (ret == XMLP_ret::XML_OK && !port_found)
+    {
+        ret = XMLP_ret::XML_NOK;
+    }
+
+    const uint8_t ident = 1;
+    std::set<std::string> tags_present;
+
+    for (tinyxml2::XMLElement* current_elem = elem.FirstChildElement();
+            current_elem != nullptr && ret != XMLP_ret::XML_ERROR;
+            current_elem = current_elem->NextSiblingElement())
+    {
+        const char* name = current_elem->Name();
+        if (tags_present.count(name) != 0)
+        {
+            EPROSIMA_LOG_ERROR(XMLPARSER, "Duplicated element found in 'thread_settings'. Tag: " << name);
+            ret = XMLP_ret::XML_ERROR;
+            break;
+        }
+        tags_present.emplace(name);
+
+        if (strcmp(current_elem->Name(), SCHEDULING_POLICY) == 0)
+        {
+            // scheduling_policy - int32Type
+            if (XMLP_ret::XML_OK != getXMLInt(current_elem, &thread_setting.scheduling_policy, ident) ||
+                    thread_setting.scheduling_policy < -1)
+            {
+                ret = XMLP_ret::XML_ERROR;
+                break;
+            }
+        }
+        else if (strcmp(current_elem->Name(), PRIORITY) == 0)
+        {
+            // priority - int32Type
+            if (XMLP_ret::XML_OK != getXMLInt(current_elem, &thread_setting.priority, ident))
+            {
+                ret = XMLP_ret::XML_ERROR;
+                break;
+            }
+        }
+        else if (strcmp(current_elem->Name(), AFFINITY) == 0)
+        {
+            // affinity - uint64Type
+            if (XMLP_ret::XML_OK != getXMLUint(current_elem, &thread_setting.affinity, ident))
+            {
+                ret = XMLP_ret::XML_ERROR;
+                break;
+            }
+        }
+        else if (strcmp(current_elem->Name(), STACK_SIZE) == 0)
+        {
+            // stack_size - int32Type
+            if (XMLP_ret::XML_OK != getXMLInt(current_elem, &thread_setting.stack_size, ident) ||
+                    thread_setting.stack_size < -1)
+            {
+                ret = XMLP_ret::XML_ERROR;
+                break;
+            }
+        }
+        else
+        {
+            EPROSIMA_LOG_ERROR(XMLPARSER, "Found incorrect tag '" << current_elem->Name() << "'");
+            ret = XMLP_ret::XML_ERROR;
+            break;
+        }
+    }
+    return ret;
+}
+
+XMLP_ret XMLParser::getXMLEntityFactoryQos(
+        tinyxml2::XMLElement& elem,
+        fastdds::dds::EntityFactoryQosPolicy& entity_factory)
+{
+    /*
+        <xs:complexType name="entityFactoryQosPolicyType">
+            <xs:all>
+                <xs:element name="autoenable_created_entities" type="boolean" minOccurs="0" maxOccurs="1"/>
+            </xs:all>
+        </xs:complexType>
+     */
+
+    /*
+     * The only allowed element is autoenable_created_entities, its min occurrences is 0, and its max is 1.
+     */
+    const uint8_t ident = 1;
+    std::set<std::string> tags_present;
+
+    for (tinyxml2::XMLElement* current_elem = elem.FirstChildElement(); current_elem != nullptr;
+            current_elem = current_elem->NextSiblingElement())
+    {
+        const char* name = current_elem->Name();
+        if (tags_present.count(name) != 0)
+        {
+            EPROSIMA_LOG_ERROR(XMLPARSER, "Duplicated element found in 'entityFactoryQosPolicyType'. Tag: " << name);
+            return XMLP_ret::XML_ERROR;
+        }
+        tags_present.emplace(name);
+
+        if (strcmp(current_elem->Name(), AUTOENABLE_CREATED_ENTITIES) == 0)
+        {
+            // autoenable_created_entities - boolean
+            if (XMLP_ret::XML_OK != getXMLBool(current_elem, &entity_factory.autoenable_created_entities, ident))
+            {
+                return XMLP_ret::XML_ERROR;
+            }
+        }
+        else
+        {
+            EPROSIMA_LOG_ERROR(XMLPARSER, "Found incorrect tag '" << current_elem->Name() << "'");
+            return XMLP_ret::XML_ERROR;
+        }
+    }
+    return XMLP_ret::XML_OK;
+}
+
+XMLP_ret XMLParser::getXMLBuiltinTransports(
+        tinyxml2::XMLElement* elem,
+        eprosima::fastdds::rtps::BuiltinTransports* bt,
+        uint8_t /*ident*/)
+{
+    /*
+        <xs:simpleType name="builtinTransports">
+            <xs:restriction base="xs:string">
+                <xs:enumeration value="NONE"/>
+                <xs:enumeration value="DEFAULT"/>
+                <xs:enumeration value="DEFAULTv6"/>
+                <xs:enumeration value="SHM"/>
+                <xs:enumeration value="UDPv4"/>
+                <xs:enumeration value="UDPv6"/>
+                <xs:enumeration value="LARGE_DATA"/>
+                <xs:enumeration value="LARGE_DATAv6"/>
+            </xs:restriction>
+        </xs:simpleType>
+     */
+    std::string text = get_element_text(elem);
+    if (text.empty())
+    {
+        EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' without content");
+        return XMLP_ret::XML_ERROR;
+    }
+
+    if (!get_element_enum_value(text.c_str(), *bt,
+            NONE, eprosima::fastdds::rtps::BuiltinTransports::NONE,
+            DEFAULT_C, eprosima::fastdds::rtps::BuiltinTransports::DEFAULT,
+            DEFAULTv6, eprosima::fastdds::rtps::BuiltinTransports::DEFAULTv6,
+            SHM, eprosima::fastdds::rtps::BuiltinTransports::SHM,
+            UDPv4, eprosima::fastdds::rtps::BuiltinTransports::UDPv4,
+            UDPv6, eprosima::fastdds::rtps::BuiltinTransports::UDPv6,
+            LARGE_DATA, eprosima::fastdds::rtps::BuiltinTransports::LARGE_DATA,
+            LARGE_DATAv6, eprosima::fastdds::rtps::BuiltinTransports::LARGE_DATAv6))
+    {
+        EPROSIMA_LOG_ERROR(XMLPARSER, "Node '" << KIND << "' bad content");
+        return XMLP_ret::XML_ERROR;
+    }
+
+    return XMLP_ret::XML_OK;
+}
+
+}  // namespace xmlparser
+}  // namespace fastrtps
+}  // namespace eprosima
+>>>>>>> 8cbd46144 (Methods to configure transport scenarios (#4098))
diff --git a/src/cpp/rtps/xmlparser/XMLParser.cpp b/src/cpp/rtps/xmlparser/XMLParser.cpp
index f82b731d891..189175e458d 100644
--- a/src/cpp/rtps/xmlparser/XMLParser.cpp
+++ b/src/cpp/rtps/xmlparser/XMLParser.cpp
@@ -1959,6 +1959,16 @@ XMLP_ret XMLParser::fillDataNode(
                 return XMLP_ret::XML_ERROR;
             }
         }
+        else if (strcmp(name, BUILTIN_TRANS) == 0)
+        {
+            // builtinTransports
+            eprosima::fastdds::rtps::BuiltinTransports bt;
+            if (XMLP_ret::XML_OK != getXMLBuiltinTransports(p_aux0, &bt, ident))
+            {
+                return XMLP_ret::XML_ERROR;
+            }
+            participant_node.get()->rtps.setup_transports(bt);
+        }
         else if (strcmp(name, PROPERTIES_POLICY) == 0)
         {
             // propertiesPolicy
diff --git a/src/cpp/rtps/xmlparser/XMLParserCommon.cpp b/src/cpp/rtps/xmlparser/XMLParserCommon.cpp
index de07d213a3b..4e96ea72afa 100644
--- a/src/cpp/rtps/xmlparser/XMLParserCommon.cpp
+++ b/src/cpp/rtps/xmlparser/XMLParserCommon.cpp
@@ -101,6 +101,7 @@ const char* PART_ID = "participantID";
 const char* THROUGHPUT_CONT = "throughputController";
 const char* USER_TRANS = "userTransports";
 const char* USE_BUILTIN_TRANS = "useBuiltinTransports";
+const char* BUILTIN_TRANS = "builtinTransports";
 const char* PROPERTIES_POLICY = "propertiesPolicy";
 const char* NAME = "name";
 const char* REMOTE_LOCATORS = "remote_locators";
@@ -159,6 +160,10 @@ const char* UDPv6 = "UDPv6";
 const char* TCPv4 = "TCPv4";
 const char* TCPv6 = "TCPv6";
 const char* SHM = "SHM";
+const char* DEFAULT_C = "DEFAULT";
+const char* DEFAULTv6 = "DEFAULTv6";
+const char* LARGE_DATA = "LARGE_DATA";
+const char* LARGE_DATAv6 = "LARGE_DATAv6";
 const char* INIT_ACKNACK_DELAY = "initialAcknackDelay";
 const char* HEARTB_RESP_DELAY = "heartbeatResponseDelay";
 const char* INIT_HEARTB_DELAY = "initialHeartbeatDelay";
diff --git a/src/cpp/utils/string_utilities.hpp b/src/cpp/utils/string_utilities.hpp
new file mode 100644
index 00000000000..ae5b4772f00
--- /dev/null
+++ b/src/cpp/utils/string_utilities.hpp
@@ -0,0 +1,51 @@
+// Copyright 2023 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef UTILS__STRING_UTILITIES_HPP_
+#define UTILS__STRING_UTILITIES_HPP_
+
+template<typename _Enum>
+static bool get_element_enum_value(
+        const char* input,
+        _Enum& output,
+        const char* name,
+        _Enum value)
+{
+    if (0 == strcmp(input, name))
+    {
+        output = value;
+        return true;
+    }
+
+    return false;
+}
+
+template<typename _Enum, typename ... Targs>
+static bool get_element_enum_value(
+        const char* input,
+        _Enum& output,
+        const char* name,
+        _Enum value,
+        Targs... args)
+{
+    if (0 == strcmp(input, name))
+    {
+        output = value;
+        return true;
+    }
+
+    return get_element_enum_value(input, output, args ...);
+}
+
+#endif // UTILS__STRING_UTILITIES_HPP_
diff --git a/test/blackbox/CMakeLists.txt b/test/blackbox/CMakeLists.txt
index 6bca2464ec6..aa8e8afbc9b 100644
--- a/test/blackbox/CMakeLists.txt
+++ b/test/blackbox/CMakeLists.txt
@@ -339,6 +339,8 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/utils/check_guid.py
     ${CMAKE_CURRENT_BINARY_DIR}/check_guid.py)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/partitions_profile.xml
     ${CMAKE_CURRENT_BINARY_DIR}/partitions_profile.xml)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/builtin_transports_profile.xml
+    ${CMAKE_CURRENT_BINARY_DIR}/builtin_transports_profile.xml)
 file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/datagrams" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
 
 if(FASTRTPS_API_TESTS)
diff --git a/test/blackbox/api/dds-pim/PubSubReader.hpp b/test/blackbox/api/dds-pim/PubSubReader.hpp
index 29b8257bb36..39f499bfab3 100644
--- a/test/blackbox/api/dds-pim/PubSubReader.hpp
+++ b/test/blackbox/api/dds-pim/PubSubReader.hpp
@@ -958,6 +958,13 @@ class PubSubReader
         return *this;
     }
 
+    PubSubReader& setup_transports(
+            eprosima::fastdds::rtps::BuiltinTransports transports)
+    {
+        participant_qos_.setup_transports(transports);
+        return *this;
+    }
+
     PubSubReader& disable_builtin_transport()
     {
         participant_qos_.transport().use_builtin_transports = false;
diff --git a/test/blackbox/api/dds-pim/PubSubWriter.hpp b/test/blackbox/api/dds-pim/PubSubWriter.hpp
index 3566f295578..9eba412ba12 100644
--- a/test/blackbox/api/dds-pim/PubSubWriter.hpp
+++ b/test/blackbox/api/dds-pim/PubSubWriter.hpp
@@ -946,6 +946,13 @@ class PubSubWriter
         return *this;
     }
 
+    PubSubWriter& setup_transports(
+            eprosima::fastdds::rtps::BuiltinTransports transports)
+    {
+        participant_qos_.setup_transports(transports);
+        return *this;
+    }
+
     PubSubWriter& disable_builtin_transport()
     {
         participant_qos_.transport().use_builtin_transports = false;
diff --git a/test/blackbox/api/fastrtps_deprecated/PubSubReader.hpp b/test/blackbox/api/fastrtps_deprecated/PubSubReader.hpp
index aa7233b4736..d5bbab3c66f 100644
--- a/test/blackbox/api/fastrtps_deprecated/PubSubReader.hpp
+++ b/test/blackbox/api/fastrtps_deprecated/PubSubReader.hpp
@@ -291,15 +291,33 @@ class PubSubReader
 
     void init()
     {
-        participant_attr_.domainId = (uint32_t)GET_PID() % 230;
-
+        //Create participant
         // Use local copies of attributes to catch #6507 issues with valgrind
         eprosima::fastrtps::ParticipantAttributes participant_attr;
         eprosima::fastrtps::SubscriberAttributes subscriber_attr;
-        participant_attr = participant_attr_;
-        subscriber_attr = subscriber_attr_;
 
-        participant_ = eprosima::fastrtps::Domain::createParticipant(participant_attr, &participant_listener_);
+        if (!xml_file_.empty())
+        {
+            eprosima::fastrtps::Domain::loadXMLProfilesFile(xml_file_);
+            if (!participant_profile_.empty())
+            {
+                // Need to specify ID in XML
+                participant_ = eprosima::fastrtps::Domain::createParticipant(participant_profile_,
+                                &participant_listener_);
+                ASSERT_NE(participant_, nullptr);
+                participant_attr = participant_->getAttributes();
+                subscriber_attr = subscriber_attr_;
+            }
+        }
+        if (participant_ == nullptr)
+        {
+            participant_attr_.domainId = (uint32_t)GET_PID() % 230;
+
+            participant_attr = participant_attr_;
+            subscriber_attr = subscriber_attr_;
+
+            participant_ = eprosima::fastrtps::Domain::createParticipant(participant_attr, &participant_listener_);
+        }
 
         if (participant_ != nullptr)
         {
@@ -713,6 +731,13 @@ class PubSubReader
         return *this;
     }
 
+    PubSubReader& setup_transports(
+            eprosima::fastdds::rtps::BuiltinTransports transports)
+    {
+        participant_attr_.rtps.setup_transports(transports);
+        return *this;
+    }
+
     PubSubReader& disable_builtin_transport()
     {
         participant_attr_.rtps.useBuiltinTransports = false;
@@ -1298,6 +1323,18 @@ class PubSubReader
         return matched_;
     }
 
+    void set_xml_filename(
+            const std::string& name)
+    {
+        xml_file_ = name;
+    }
+
+    void set_participant_profile(
+            const std::string& profile)
+    {
+        participant_profile_ = profile;
+    }
+
     const eprosima::fastrtps::rtps::GUID_t& participant_guid() const
     {
         return participant_guid_;
@@ -1409,6 +1446,9 @@ class PubSubReader
     std::atomic<size_t> number_samples_expected_;
     bool discovery_result_;
 
+    std::string xml_file_ = "";
+    std::string participant_profile_ = "";
+
     std::function<bool(const eprosima::fastrtps::rtps::ParticipantDiscoveryInfo& info)> onDiscovery_;
     std::function<bool(const eprosima::fastrtps::rtps::WriterDiscoveryInfo& info)> onEndpointDiscovery_;
 
diff --git a/test/blackbox/api/fastrtps_deprecated/PubSubWriter.hpp b/test/blackbox/api/fastrtps_deprecated/PubSubWriter.hpp
index 5351498eca1..1d3fac6b6f2 100644
--- a/test/blackbox/api/fastrtps_deprecated/PubSubWriter.hpp
+++ b/test/blackbox/api/fastrtps_deprecated/PubSubWriter.hpp
@@ -289,15 +289,32 @@ class PubSubWriter
     void init()
     {
         //Create participant
-        participant_attr_.domainId = (uint32_t)GET_PID() % 230;
-
         // Use local copies of attributes to catch #6507 issues with valgrind
         eprosima::fastrtps::ParticipantAttributes participant_attr;
         eprosima::fastrtps::PublisherAttributes publisher_attr;
-        participant_attr = participant_attr_;
-        publisher_attr = publisher_attr_;
 
-        participant_ = eprosima::fastrtps::Domain::createParticipant(participant_attr, &participant_listener_);
+        if (!xml_file_.empty())
+        {
+            eprosima::fastrtps::Domain::loadXMLProfilesFile(xml_file_);
+            if (!participant_profile_.empty())
+            {
+                // Need to specify ID in XML
+                participant_ = eprosima::fastrtps::Domain::createParticipant(participant_profile_,
+                                &participant_listener_);
+                ASSERT_NE(participant_, nullptr);
+                participant_attr = participant_->getAttributes();
+                publisher_attr = publisher_attr_;
+            }
+        }
+        if (participant_ == nullptr)
+        {
+            participant_attr_.domainId = (uint32_t)GET_PID() % 230;
+
+            participant_attr = participant_attr_;
+            publisher_attr = publisher_attr_;
+
+            participant_ = eprosima::fastrtps::Domain::createParticipant(participant_attr, &participant_listener_);
+        }
 
         if (participant_ != nullptr)
         {
@@ -726,6 +743,13 @@ class PubSubWriter
         return *this;
     }
 
+    PubSubWriter& setup_transports(
+            eprosima::fastdds::rtps::BuiltinTransports transports)
+    {
+        participant_attr_.rtps.setup_transports(transports);
+        return *this;
+    }
+
     PubSubWriter& disable_builtin_transport()
     {
         participant_attr_.rtps.useBuiltinTransports = false;
@@ -1208,6 +1232,18 @@ class PubSubWriter
         return matched_;
     }
 
+    void set_xml_filename(
+            const std::string& name)
+    {
+        xml_file_ = name;
+    }
+
+    void set_participant_profile(
+            const std::string& profile)
+    {
+        participant_profile_ = profile;
+    }
+
     unsigned int missed_deadlines() const
     {
         return listener_.missed_deadlines();
@@ -1488,6 +1524,9 @@ class PubSubWriter
     std::map<std::string,  int> mapPartitionCountList_;
     bool discovery_result_;
 
+    std::string xml_file_ = "";
+    std::string participant_profile_ = "";
+
     std::function<bool(const eprosima::fastrtps::rtps::ParticipantDiscoveryInfo& info)> onDiscovery_;
 
     //! A mutex for liveliness
diff --git a/test/blackbox/builtin_transports_profile.xml b/test/blackbox/builtin_transports_profile.xml
new file mode 100644
index 00000000000..0163b1674ec
--- /dev/null
+++ b/test/blackbox/builtin_transports_profile.xml
@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"  ?>
+<dds xmlns="http://www.eprosima.com/XMLSchemas/fastRTPS_Profiles">
+    <profiles>
+        <transport_descriptors>
+            <transport_descriptor>
+                    <transport_id>transport</transport_id>
+                    <type>UDPv4</type>
+            </transport_descriptor>
+        </transport_descriptors>
+
+        <participant profile_name="participant_none">
+            <domainId>0</domainId>
+            <rtps>
+                <name>Participant.builtin_transports_none</name>
+                <builtinTransports>NONE</builtinTransports>
+                <!--
+                    Need to add at least one transport in
+                    order to be able to create the participant
+                -->
+                <userTransports>
+                    <transport_id>transport</transport_id>
+                </userTransports>
+            </rtps>
+        </participant>
+
+        <participant profile_name="participant_default">
+            <domainId>0</domainId>
+            <rtps>
+                <name>Participant.builtin_transports_default</name>
+                <builtinTransports>DEFAULT</builtinTransports>
+            </rtps>
+        </participant>
+
+        <participant profile_name="participant_defaultv6">
+            <domainId>0</domainId>
+            <rtps>
+                <name>Participant.builtin_transports_defaultv6</name>
+                <builtinTransports>DEFAULTv6</builtinTransports>
+            </rtps>
+        </participant>
+
+        <participant profile_name="participant_shm">
+            <domainId>0</domainId>
+            <rtps>
+                <name>Participant.builtin_transports_shm</name>
+                <builtinTransports>SHM</builtinTransports>
+            </rtps>
+        </participant>
+
+        <participant profile_name="participant_udp">
+            <domainId>0</domainId>
+            <rtps>
+                <name>Participant.builtin_transports_udp</name>
+                <builtinTransports>UDPv4</builtinTransports>
+            </rtps>
+        </participant>
+
+        <participant profile_name="participant_udpv6">
+            <domainId>0</domainId>
+            <rtps>
+                <name>Participant.builtin_transports_udpv6</name>
+                <builtinTransports>UDPv6</builtinTransports>
+            </rtps>
+        </participant>
+
+        <participant profile_name="participant_largedata">
+            <domainId>0</domainId>
+            <rtps>
+                <name>Participant.builtin_transports_largedata</name>
+                <builtinTransports>LARGE_DATA</builtinTransports>
+            </rtps>
+        </participant>
+
+        <participant profile_name="participant_largedatav6">
+            <domainId>0</domainId>
+            <rtps>
+                <name>Participant.builtin_transports_largedatav6</name>
+                <builtinTransports>LARGE_DATAv6</builtinTransports>
+            </rtps>
+        </participant>
+
+    </profiles>
+</dds>
diff --git a/test/blackbox/common/BlackboxTestsTransportCustom.cpp b/test/blackbox/common/BlackboxTestsTransportCustom.cpp
index 8b879bd7249..7efc7747e3b 100644
--- a/test/blackbox/common/BlackboxTestsTransportCustom.cpp
+++ b/test/blackbox/common/BlackboxTestsTransportCustom.cpp
@@ -24,6 +24,8 @@
 
 #include <gtest/gtest.h>
 
+using BuiltinTransports = eprosima::fastdds::rtps::BuiltinTransports;
+
 class TestChainingTransportDescriptor : public eprosima::fastdds::rtps::ChainingTransportDescriptor
 {
 public:
@@ -305,4 +307,191 @@ TEST(ChainingTransportTests, tcp_client_server_with_wan_correct_sender_resources
     //! is being created
     ASSERT_LE(times_writer_send_function_called.load(), 30);
     ASSERT_LE(times_reader_receive_function_called.load(), 30);
-}
\ No newline at end of file
+}
+
+TEST(ChainingTransportTests, builtin_transports_basic_test)
+{
+    std::vector<BuiltinTransports> bt_list;
+    bt_list.push_back(BuiltinTransports::DEFAULT);
+    bt_list.push_back(BuiltinTransports::DEFAULTv6);
+    bt_list.push_back(BuiltinTransports::SHM);
+    bt_list.push_back(BuiltinTransports::UDPv4);
+    bt_list.push_back(BuiltinTransports::UDPv6);
+    bt_list.push_back(BuiltinTransports::LARGE_DATA);
+#ifndef __APPLE__
+    bt_list.push_back(BuiltinTransports::LARGE_DATAv6);
+#endif // __APPLE__
+
+    for (auto test_transport : bt_list)
+    {
+        {
+            PubSubWriter<HelloWorldPubSubType> writer(TEST_TOPIC_NAME);
+            PubSubReader<HelloWorldPubSubType> reader(TEST_TOPIC_NAME);
+
+            writer.setup_transports(test_transport)
+                    .history_kind(eprosima::fastrtps::KEEP_ALL_HISTORY_QOS)
+                    .init();
+
+            ASSERT_TRUE(writer.isInitialized());
+
+            reader.setup_transports(test_transport)
+                    .reliability(eprosima::fastrtps::RELIABLE_RELIABILITY_QOS)
+                    .history_kind(eprosima::fastrtps::KEEP_ALL_HISTORY_QOS)
+                    .init();
+
+            ASSERT_TRUE(reader.isInitialized());
+
+            // Wait for discovery.
+            writer.wait_discovery();
+            reader.wait_discovery();
+
+            auto data = default_helloworld_data_generator();
+            // size_t num_messages = data.size();
+            reader.startReception(data);
+            writer.send(data);
+            ASSERT_TRUE(data.empty());
+            reader.block_for_all();
+
+            // Check reception
+            // reader.wait_for_all_received(std::chrono::seconds(3), num_messages);
+            EXPECT_TRUE(writer.waitForAllAcked(std::chrono::seconds(3)));
+        }
+    }
+
+    PubSubWriter<HelloWorldPubSubType> writer(TEST_TOPIC_NAME);
+    PubSubReader<HelloWorldPubSubType> reader(TEST_TOPIC_NAME);
+
+    BuiltinTransports test_transport = BuiltinTransports::NONE;
+
+    writer.setup_transports(test_transport)
+            .init();
+
+    ASSERT_FALSE(writer.isInitialized());
+
+    reader.setup_transports(test_transport)
+            .init();
+
+    ASSERT_FALSE(reader.isInitialized());
+}
+
+TEST(ChainingTransportTests, builtin_transports_env_var_test)
+{
+    const std::string env_var_name("FASTDDS_BUILTIN_TRANSPORTS");
+
+    std::vector<std::string> bt_list;
+    bt_list.push_back("DEFAULT");
+    bt_list.push_back("DEFAULTv6");
+    bt_list.push_back("SHM");
+    bt_list.push_back("UDPv4");
+    bt_list.push_back("UDPv6");
+    bt_list.push_back("LARGE_DATA");
+#ifndef __APPLE__
+    bt_list.push_back("LARGE_DATAv6");
+#endif // __APPLE__
+
+    for (auto test_transport : bt_list)
+    {
+        {
+#ifdef _WIN32
+            _putenv_s(env_var_name.c_str(), test_transport.c_str());
+#else
+            setenv(env_var_name.c_str(), test_transport.c_str(), 1);
+#endif // _WIN32
+
+            PubSubWriter<HelloWorldPubSubType> writer(TEST_TOPIC_NAME);
+            PubSubReader<HelloWorldPubSubType> reader(TEST_TOPIC_NAME);
+
+            writer.history_kind(eprosima::fastrtps::KEEP_ALL_HISTORY_QOS)
+                    .init();
+
+            ASSERT_TRUE(writer.isInitialized());
+
+            reader.reliability(eprosima::fastrtps::RELIABLE_RELIABILITY_QOS)
+                    .history_kind(eprosima::fastrtps::KEEP_ALL_HISTORY_QOS)
+                    .init();
+
+            ASSERT_TRUE(reader.isInitialized());
+
+            // Wait for discovery.
+            writer.wait_discovery();
+            reader.wait_discovery();
+
+            auto data = default_helloworld_data_generator();
+            // size_t num_messages = data.size();
+            reader.startReception(data);
+            writer.send(data);
+            ASSERT_TRUE(data.empty());
+            reader.block_for_all();
+
+            // Check reception
+            EXPECT_TRUE(writer.waitForAllAcked(std::chrono::seconds(3)));
+        }
+    }
+
+    std::string value("NONE");
+#ifdef _WIN32
+    _putenv_s(env_var_name.c_str(), value.c_str());
+#else
+    setenv(env_var_name.c_str(), value.c_str(), 1);
+#endif // _WIN32
+
+    PubSubWriter<HelloWorldPubSubType> writer(TEST_TOPIC_NAME);
+    PubSubReader<HelloWorldPubSubType> reader(TEST_TOPIC_NAME);
+
+    writer.init();
+
+    ASSERT_FALSE(writer.isInitialized());
+
+    reader.init();
+
+    ASSERT_FALSE(reader.isInitialized());
+}
+
+TEST(ChainingTransportTests, builtin_transports_xml_test)
+{
+    std::vector<std::string> bt_list;
+    bt_list.push_back("participant_none");
+    bt_list.push_back("participant_default");
+    bt_list.push_back("participant_defaultv6");
+    bt_list.push_back("participant_shm");
+    bt_list.push_back("participant_udp");
+    bt_list.push_back("participant_udpv6");
+    bt_list.push_back("participant_largedata");
+#ifndef __APPLE__
+    bt_list.push_back("participant_largedatav6");
+#endif // __APPLE__
+
+    for (auto test_transport : bt_list)
+    {
+        {
+            PubSubWriter<HelloWorldPubSubType> writer(TEST_TOPIC_NAME);
+            PubSubReader<HelloWorldPubSubType> reader(TEST_TOPIC_NAME);
+
+            writer.set_xml_filename("builtin_transports_profile.xml");
+            writer.set_participant_profile(test_transport);
+            writer.init();
+
+            ASSERT_TRUE(writer.isInitialized());
+
+            reader.set_xml_filename("builtin_transports_profile.xml");
+            reader.set_participant_profile(test_transport);
+            reader.init();
+
+            ASSERT_TRUE(reader.isInitialized());
+
+            // Wait for discovery.
+            writer.wait_discovery();
+            reader.wait_discovery();
+
+            auto data = default_helloworld_data_generator();
+            // size_t num_messages = data.size();
+            reader.startReception(data);
+            writer.send(data);
+            ASSERT_TRUE(data.empty());
+            reader.block_for_all();
+
+            // Check reception
+            EXPECT_TRUE(writer.waitForAllAcked(std::chrono::seconds(3)));
+        }
+    }
+}
diff --git a/test/mock/rtps/RTPSParticipantAttributes/fastdds/rtps/attributes/RTPSParticipantAttributes.h b/test/mock/rtps/RTPSParticipantAttributes/fastdds/rtps/attributes/RTPSParticipantAttributes.h
new file mode 100644
index 00000000000..b78b00af769
--- /dev/null
+++ b/test/mock/rtps/RTPSParticipantAttributes/fastdds/rtps/attributes/RTPSParticipantAttributes.h
@@ -0,0 +1,638 @@
+// Copyright 2023 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @file RTPSParticipantAttributes.h
+ */
+
+#ifndef _FASTDDS_RTPSPARTICIPANTPARAMETERS_H_
+#define _FASTDDS_RTPSPARTICIPANTPARAMETERS_H_
+
+#include <memory>
+#include <sstream>
+
+#include <fastdds/rtps/attributes/BuiltinTransports.hpp>
+#include <fastdds/rtps/attributes/ExternalLocators.hpp>
+#include <fastdds/rtps/attributes/PropertyPolicy.h>
+#include <fastdds/rtps/attributes/RTPSParticipantAllocationAttributes.hpp>
+#include <fastdds/rtps/attributes/ServerAttributes.h>
+#include <fastdds/rtps/attributes/ThreadSettings.hpp>
+#include <fastdds/rtps/common/Locator.h>
+#include <fastdds/rtps/common/PortParameters.h>
+#include <fastdds/rtps/common/Time_t.h>
+#include <fastdds/rtps/common/Types.h>
+#include <fastdds/rtps/flowcontrol/FlowControllerDescriptor.hpp>
+#include <fastdds/rtps/flowcontrol/ThroughputControllerDescriptor.h>
+#include <fastdds/rtps/resources/ResourceManagement.h>
+#include <fastdds/rtps/transport/TransportInterface.h>
+#include <fastrtps/fastrtps_dll.h>
+#include <fastrtps/utils/fixed_size_string.hpp>
+#include <fastrtps/transport/UDPv4TransportDescriptor.h>
+
+namespace eprosima {
+namespace fastdds {
+namespace rtps {
+
+/**
+ * Struct to define participant types to set participant type parameter property
+ * @ingroup DISCOVERY_MODULE
+ */
+struct ParticipantType
+{
+    static constexpr const char* SIMPLE = "SIMPLE";
+    static constexpr const char* SERVER = "SERVER";
+    static constexpr const char* CLIENT = "CLIENT";
+    static constexpr const char* SUPER_CLIENT = "SUPER_CLIENT";
+    static constexpr const char* BACKUP = "BACKUP";
+    static constexpr const char* NONE = "NONE";
+    static constexpr const char* EXTERNAL = "EXTERNAL";
+    static constexpr const char* UNKNOWN = "UNKNOWN";
+};
+
+}  // namespace rtps
+}  // namespace fastdds
+
+namespace fastrtps {
+namespace rtps {
+
+//! PDP subclass choice
+typedef enum DiscoveryProtocol
+{
+    NONE,
+    /*!<
+        NO discovery whatsoever would be used.
+        Publisher and Subscriber defined with the same topic name would NOT be linked.
+        All matching must be done manually through the addReaderLocator, addReaderProxy, addWriterProxy methods.
+     */
+    SIMPLE,
+    /*!<
+        Discovery works according to 'The Real-time Publish-Subscribe Protocol(RTPS) DDS
+        Interoperability Wire Protocol Specification'
+     */
+    EXTERNAL,
+    /*!<
+        A user defined PDP subclass object must be provided in the attributes that deals with the discovery.
+        Framework is not responsible of this object lifetime.
+     */
+    CLIENT, /*!< The participant will behave as a client concerning discovery operation.
+                 Server locators should be specified as attributes. */
+    SERVER, /*!< The participant will behave as a server concerning discovery operation.
+                 Discovery operation is volatile (discovery handshake must take place if shutdown). */
+    BACKUP,  /*!< The participant will behave as a server concerning discovery operation.
+                 Discovery operation persist on a file (discovery handshake wouldn't repeat if shutdown). */
+    SUPER_CLIENT  /*!< The participant will behave as a client concerning all internal behaviour.
+                     Remote servers will treat it as a server and will share every discovery information. */
+
+} DiscoveryProtocol_t;
+
+inline std::ostream& operator <<(
+        std::ostream& output,
+        const DiscoveryProtocol& discovery_protocol)
+{
+    switch (discovery_protocol)
+    {
+        case DiscoveryProtocol::NONE:
+            output << fastdds::rtps::ParticipantType::NONE;
+            break;
+        case DiscoveryProtocol::SIMPLE:
+            output << fastdds::rtps::ParticipantType::SIMPLE;
+            break;
+        case DiscoveryProtocol::EXTERNAL:
+            output << fastdds::rtps::ParticipantType::EXTERNAL;
+            break;
+        case DiscoveryProtocol::CLIENT:
+            output << fastdds::rtps::ParticipantType::CLIENT;
+            break;
+        case DiscoveryProtocol::SUPER_CLIENT:
+            output << fastdds::rtps::ParticipantType::SUPER_CLIENT;
+            break;
+        case DiscoveryProtocol::SERVER:
+            output << fastdds::rtps::ParticipantType::SERVER;
+            break;
+        case DiscoveryProtocol::BACKUP:
+            output << fastdds::rtps::ParticipantType::BACKUP;
+            break;
+        default:
+            output << fastdds::rtps::ParticipantType::UNKNOWN;
+    }
+    return output;
+}
+
+//! Filtering flags when discovering participants
+typedef enum ParticipantFilteringFlags : uint32_t
+{
+    NO_FILTER = 0,
+    FILTER_DIFFERENT_HOST = 0x1,
+    FILTER_DIFFERENT_PROCESS = 0x2,
+    FILTER_SAME_PROCESS = 0x4
+} ParticipantFilteringFlags_t;
+
+#define BUILTIN_DATA_MAX_SIZE 512
+
+//! PDP factory for EXTERNAL type
+class PDP;
+class BuiltinProtocols;
+
+typedef struct _PDPFactory
+{
+    // Pointer to the PDP creator
+    PDP* (*CreatePDPInstance)(BuiltinProtocols*);
+    // Pointer to the PDP destructor
+    void (* ReleasePDPInstance)(
+            PDP*);
+
+    bool operator ==(
+            const struct _PDPFactory& e) const
+    {
+        return (CreatePDPInstance == e.CreatePDPInstance)
+               && (ReleasePDPInstance == e.ReleasePDPInstance);
+    }
+
+} PDPFactory;
+
+/**
+ * Class SimpleEDPAttributes, to define the attributes of the Simple Endpoint Discovery Protocol.
+ * @ingroup RTPS_ATTRIBUTES_MODULE
+ */
+class SimpleEDPAttributes
+{
+public:
+
+    //!Default value true.
+    bool use_PublicationWriterANDSubscriptionReader;
+
+    //!Default value true.
+    bool use_PublicationReaderANDSubscriptionWriter;
+
+#if HAVE_SECURITY
+    bool enable_builtin_secure_publications_writer_and_subscriptions_reader;
+
+    bool enable_builtin_secure_subscriptions_writer_and_publications_reader;
+#endif // if HAVE_SECURITY
+
+    SimpleEDPAttributes()
+        : use_PublicationWriterANDSubscriptionReader(true)
+        , use_PublicationReaderANDSubscriptionWriter(true)
+#if HAVE_SECURITY
+        , enable_builtin_secure_publications_writer_and_subscriptions_reader(true)
+        , enable_builtin_secure_subscriptions_writer_and_publications_reader(true)
+#endif // if HAVE_SECURITY
+    {
+    }
+
+    bool operator ==(
+            const SimpleEDPAttributes& b) const
+    {
+        return (this->use_PublicationWriterANDSubscriptionReader == b.use_PublicationWriterANDSubscriptionReader) &&
+#if HAVE_SECURITY
+               (this->enable_builtin_secure_publications_writer_and_subscriptions_reader ==
+               b.enable_builtin_secure_publications_writer_and_subscriptions_reader) &&
+               (this->enable_builtin_secure_subscriptions_writer_and_publications_reader ==
+               b.enable_builtin_secure_subscriptions_writer_and_publications_reader) &&
+#endif // if HAVE_SECURITY
+               (this->use_PublicationReaderANDSubscriptionWriter == b.use_PublicationReaderANDSubscriptionWriter);
+    }
+
+};
+
+/**
+ * Struct InitialAnnouncementConfig defines the behavior of the RTPSParticipant initial announcements.
+ * @ingroup RTPS_ATTRIBUTES_MODULE
+ */
+struct InitialAnnouncementConfig
+{
+    /// Number of initial announcements with specific period (default 5)
+    uint32_t count = 5u;
+
+    /// Specific period for initial announcements (default 100ms)
+    Duration_t period = { 0, 100000000u };
+
+    bool operator ==(
+            const InitialAnnouncementConfig& b) const
+    {
+        return (count == b.count) && (period == b.period);
+    }
+
+};
+
+/**
+ * Class DiscoverySettings, to define the attributes of the several discovery protocols available
+ * @ingroup RTPS_ATTRIBUTES_MODULE
+ */
+
+class DiscoverySettings
+{
+public:
+
+    //! Chosen discovery protocol
+    DiscoveryProtocol_t discoveryProtocol = DiscoveryProtocol_t::SIMPLE;
+
+    /**
+     * If set to true, SimpleEDP would be used.
+     */
+    bool use_SIMPLE_EndpointDiscoveryProtocol = true;
+
+    /**
+     * If set to true, StaticEDP based on an XML file would be implemented.
+     * The XML filename must be provided.
+     */
+    bool use_STATIC_EndpointDiscoveryProtocol = false;
+
+    /**
+     * Lease Duration of the RTPSParticipant,
+     * indicating how much time remote RTPSParticipants should consider this RTPSParticipant alive.
+     */
+    Duration_t leaseDuration = { 20, 0 };
+
+    /**
+     * The period for the RTPSParticipant to send its Discovery Message to all other discovered RTPSParticipants
+     * as well as to all Multicast ports.
+     */
+    Duration_t leaseDuration_announcementperiod = { 3, 0 };
+
+    //!Initial announcements configuration
+    InitialAnnouncementConfig initial_announcements;
+
+    //!Attributes of the SimpleEDP protocol
+    SimpleEDPAttributes m_simpleEDP;
+
+    //! function that returns a PDP object (only if EXTERNAL selected)
+    PDPFactory m_PDPfactory{};
+    /**
+     * The period for the RTPSParticipant to:
+     *  send its Discovery Message to its servers
+     *  check for EDP endpoints matching
+     */
+    Duration_t discoveryServer_client_syncperiod = { 0, 450 * 1000000}; // 450 milliseconds
+
+    //! Discovery Server settings, only needed if use_CLIENT_DiscoveryProtocol=true
+    eprosima::fastdds::rtps::RemoteServerList_t m_DiscoveryServers;
+
+    //! Filtering participants out depending on location
+    ParticipantFilteringFlags_t ignoreParticipantFlags = ParticipantFilteringFlags::NO_FILTER;
+
+    DiscoverySettings() = default;
+
+    bool operator ==(
+            const DiscoverySettings& b) const
+    {
+        return (this->discoveryProtocol == b.discoveryProtocol) &&
+               (this->use_SIMPLE_EndpointDiscoveryProtocol == b.use_SIMPLE_EndpointDiscoveryProtocol) &&
+               (this->use_STATIC_EndpointDiscoveryProtocol == b.use_STATIC_EndpointDiscoveryProtocol) &&
+               (this->discoveryServer_client_syncperiod == b.discoveryServer_client_syncperiod) &&
+               (this->m_PDPfactory == b.m_PDPfactory) &&
+               (this->leaseDuration == b.leaseDuration) &&
+               (this->leaseDuration_announcementperiod == b.leaseDuration_announcementperiod) &&
+               (this->initial_announcements == b.initial_announcements) &&
+               (this->m_simpleEDP == b.m_simpleEDP) &&
+               (this->static_edp_xml_config_ == b.static_edp_xml_config_) &&
+               (this->m_DiscoveryServers == b.m_DiscoveryServers) &&
+               (this->ignoreParticipantFlags == b.ignoreParticipantFlags);
+    }
+
+    /**
+     * Get the static endpoint XML filename
+     * @return Static endpoint XML filename
+     */
+    FASTRTPS_DEPRECATED("Use static_edp_xml_config()")
+    const char* getStaticEndpointXMLFilename() const
+    {
+        return static_edp_xml_config();
+    }
+
+    /**
+     * Set the static endpoint XML filename
+     * @param str Static endpoint XML filename
+     * @deprecated
+     */
+    FASTRTPS_DEPRECATED("Use static_edp_xml_config()")
+    void setStaticEndpointXMLFilename(
+            const char* str)
+    {
+        static_edp_xml_config_ = "file://" + std::string(str);
+    }
+
+    /**
+     * Set the static endpoint XML configuration.
+     * @param str URI specifying the static endpoint XML configuration.
+     * The string could contain a filename (file://) or the XML content directly (data://).
+     */
+    void static_edp_xml_config(
+            const char* str)
+    {
+        static_edp_xml_config_ = str;
+    }
+
+    /**
+     * Get the static endpoint XML configuration.
+     * @return URI specifying the static endpoint XML configuration.
+     * The string could contain a filename (file://) or the XML content directly (data://).
+     */
+    const char* static_edp_xml_config() const
+    {
+        return static_edp_xml_config_.c_str();
+    }
+
+private:
+
+    //! URI specifying the static EDP XML configuration, only necessary if use_STATIC_EndpointDiscoveryProtocol=true
+    //! This string could contain a filename or the XML content directly.
+    std::string static_edp_xml_config_ = "";
+};
+
+/**
+ * TypeLookupService settings.
+ */
+class TypeLookupSettings
+{
+public:
+
+    //!Indicates to use the TypeLookup Service client endpoints
+    bool use_client = false;
+
+    //!Indicates to use the TypeLookup Service server endpoints
+    bool use_server = false;
+
+};
+
+/**
+ * Class BuiltinAttributes, to define the behavior of the RTPSParticipant builtin protocols.
+ * @ingroup RTPS_ATTRIBUTES_MODULE
+ */
+class BuiltinAttributes
+{
+public:
+
+    //! Discovery protocol related attributes
+    DiscoverySettings discovery_config;
+
+    //! Indicates to use the WriterLiveliness protocol.
+    bool use_WriterLivelinessProtocol = true;
+
+    //! TypeLookup Service settings
+    TypeLookupSettings typelookup_config;
+
+    //! Network Configuration
+    NetworkConfigSet_t network_configuration;
+
+    //! Metatraffic Unicast Locator List
+    LocatorList_t metatrafficUnicastLocatorList;
+
+    //! Metatraffic Multicast Locator List.
+    LocatorList_t metatrafficMulticastLocatorList;
+
+    //! The collection of external locators to use for communication on metatraffic topics.
+    fastdds::rtps::ExternalLocators metatraffic_external_unicast_locators;
+
+    //! Initial peers.
+    LocatorList_t initialPeersList;
+
+    //! Memory policy for builtin readers
+    MemoryManagementPolicy_t readerHistoryMemoryPolicy =
+            MemoryManagementPolicy_t::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
+
+    //! Maximum payload size for builtin readers
+    uint32_t readerPayloadSize = BUILTIN_DATA_MAX_SIZE;
+
+    //! Memory policy for builtin writers
+    MemoryManagementPolicy_t writerHistoryMemoryPolicy =
+            MemoryManagementPolicy_t::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
+
+    //! Maximum payload size for builtin writers
+    uint32_t writerPayloadSize = BUILTIN_DATA_MAX_SIZE;
+
+    //! Mutation tries if the port is being used.
+    uint32_t mutation_tries = 100u;
+
+    //! Set to true to avoid multicast traffic on builtin endpoints
+    bool avoid_builtin_multicast = true;
+
+    BuiltinAttributes() = default;
+
+    virtual ~BuiltinAttributes() = default;
+
+    bool operator ==(
+            const BuiltinAttributes& b) const
+    {
+        return (this->discovery_config == b.discovery_config) &&
+               (this->use_WriterLivelinessProtocol == b.use_WriterLivelinessProtocol) &&
+               (typelookup_config.use_client == b.typelookup_config.use_client) &&
+               (typelookup_config.use_server == b.typelookup_config.use_server) &&
+               (this->network_configuration == b.network_configuration) &&
+               (this->metatrafficUnicastLocatorList == b.metatrafficUnicastLocatorList) &&
+               (this->metatrafficMulticastLocatorList == b.metatrafficMulticastLocatorList) &&
+               (this->metatraffic_external_unicast_locators == b.metatraffic_external_unicast_locators) &&
+               (this->initialPeersList == b.initialPeersList) &&
+               (this->readerHistoryMemoryPolicy == b.readerHistoryMemoryPolicy) &&
+               (this->readerPayloadSize == b.readerPayloadSize) &&
+               (this->writerHistoryMemoryPolicy == b.writerHistoryMemoryPolicy) &&
+               (this->writerPayloadSize == b.writerPayloadSize) &&
+               (this->mutation_tries == b.mutation_tries) &&
+               (this->avoid_builtin_multicast == b.avoid_builtin_multicast);
+    }
+
+};
+
+/**
+ * Class RTPSParticipantAttributes used to define different aspects of a RTPSParticipant.
+ * @ingroup RTPS_ATTRIBUTES_MODULE
+ */
+class RTPSParticipantAttributes
+{
+    using FlowControllerDescriptorList = std::vector<std::shared_ptr<fastdds::rtps::FlowControllerDescriptor>>;
+
+public:
+
+    RTPSParticipantAttributes() = default;
+
+    virtual ~RTPSParticipantAttributes() = default;
+
+    bool operator ==(
+            const RTPSParticipantAttributes& b) const
+    {
+        return (this->name == b.name) &&
+               (this->defaultUnicastLocatorList == b.defaultUnicastLocatorList) &&
+               (this->defaultMulticastLocatorList == b.defaultMulticastLocatorList) &&
+               (this->default_external_unicast_locators == b.default_external_unicast_locators) &&
+               (this->ignore_non_matching_locators == b.ignore_non_matching_locators) &&
+               (this->sendSocketBufferSize == b.sendSocketBufferSize) &&
+               (this->listenSocketBufferSize == b.listenSocketBufferSize) &&
+               (this->builtin == b.builtin) &&
+               (this->port == b.port) &&
+               (this->userData == b.userData) &&
+               (this->participantID == b.participantID) &&
+               (this->throughputController == b.throughputController) &&
+               (this->useBuiltinTransports == b.useBuiltinTransports) &&
+               (this->properties == b.properties) &&
+               (this->prefix == b.prefix) &&
+               (this->flow_controllers == b.flow_controllers) &&
+               (this->builtin_controllers_sender_thread == b.builtin_controllers_sender_thread) &&
+               (this->timed_events_thread == b.timed_events_thread) &&
+#if HAVE_SECURITY
+               (this->security_log_thread == b.security_log_thread) &&
+#endif // if HAVE_SECURITY
+               (this->discovery_server_thread == b.discovery_server_thread) &&
+               (this->builtin_transports_reception_threads == b.builtin_transports_reception_threads);
+
+    }
+
+    /**
+     * Provides a way of easily configuring transport related configuration on certain pre-defined scenarios.
+     *
+     * @param transports Defines the transport configuration scenario to setup.
+     */
+    void setup_transports(
+            fastdds::rtps::BuiltinTransports /*transports*/)
+    {
+        // Only include UDPv4 behavior for mock tests
+        setup_transports_default(*this);
+        useBuiltinTransports = false;
+    }
+
+    static void setup_transports_default(
+            RTPSParticipantAttributes& att)
+    {
+        auto descriptor = create_udpv4_transport(att);
+
+        att.userTransports.push_back(descriptor);
+    }
+
+    static std::shared_ptr<fastrtps::rtps::UDPv4TransportDescriptor> create_udpv4_transport(
+            const RTPSParticipantAttributes& att)
+    {
+        auto descriptor = std::make_shared<fastrtps::rtps::UDPv4TransportDescriptor>();
+        descriptor->sendBufferSize = att.sendSocketBufferSize;
+        descriptor->receiveBufferSize = att.listenSocketBufferSize;
+        descriptor->default_reception_threads(att.builtin_transports_reception_threads);
+
+        return descriptor;
+    }
+
+    /**
+     * Default list of Unicast Locators to be used for any Endpoint defined inside this RTPSParticipant in the case
+     * that it was defined with NO UnicastLocators. At least ONE locator should be included in this list.
+     */
+    LocatorList_t defaultUnicastLocatorList;
+
+    /**
+     * Default list of Multicast Locators to be used for any Endpoint defined inside this RTPSParticipant in the
+     * case that it was defined with NO MulticastLocators. This is usually left empty.
+     */
+    LocatorList_t defaultMulticastLocatorList;
+
+    /**
+     * The collection of external locators to use for communication on user created topics.
+     */
+    fastdds::rtps::ExternalLocators default_external_unicast_locators;
+
+    /**
+     * Whether locators that don't match with the announced locators should be kept.
+     */
+    bool ignore_non_matching_locators = false;
+
+    /*!
+     * @brief Send socket buffer size for the send resource. Zero value indicates to use default system buffer size.
+     * Default value: 0.
+     */
+    uint32_t sendSocketBufferSize = 0;
+
+    /*! Listen socket buffer for all listen resources. Zero value indicates to use default system buffer size.
+     * Default value: 0.
+     */
+    uint32_t listenSocketBufferSize = 0;
+
+    //! Optionally allows user to define the GuidPrefix_t
+    GuidPrefix_t prefix;
+
+    RTPS_DllAPI inline bool ReadguidPrefix(
+            const char* pfx)
+    {
+        return bool(std::istringstream(pfx) >> prefix);
+    }
+
+    //! Builtin parameters.
+    BuiltinAttributes builtin;
+
+    //! Port Parameters
+    PortParameters port;
+
+    //! User Data of the participant
+    std::vector<octet> userData;
+
+    //! Participant ID
+    int32_t participantID = -1;
+
+    /**
+     * @brief Throughput controller parameters. Leave default for uncontrolled flow.
+     *
+     * @deprecated Use flow_controllers on RTPSParticipantAttributes
+     */
+    ThroughputControllerDescriptor throughputController;
+
+    //! User defined transports to use alongside or in place of builtins.
+    std::vector<std::shared_ptr<fastdds::rtps::TransportDescriptorInterface>> userTransports;
+
+    //! Set as false to disable the creation of the default transports.
+    bool useBuiltinTransports = true;
+
+    //! Holds allocation limits affecting collections managed by a participant.
+    RTPSParticipantAllocationAttributes allocation;
+
+    //! Property policies
+    PropertyPolicy properties;
+
+    //! Set the name of the participant.
+    inline void setName(
+            const char* nam)
+    {
+        name = nam;
+    }
+
+    //! Get the name of the participant.
+    inline const char* getName() const
+    {
+        return name.c_str();
+    }
+
+    //! Flow controllers.
+    FlowControllerDescriptorList flow_controllers;
+
+    //! Thread settings for the builtin flow controllers sender threads
+    fastdds::rtps::ThreadSettings builtin_controllers_sender_thread;
+
+    //! Thread settings for the timed events thread
+    fastdds::rtps::ThreadSettings timed_events_thread;
+
+    //! Thread settings for the discovery server thread
+    fastdds::rtps::ThreadSettings discovery_server_thread;
+
+    //! Thread settings for the builtin transports reception threads
+    fastdds::rtps::ThreadSettings builtin_transports_reception_threads;
+
+#if HAVE_SECURITY
+    //! Thread settings for the security log thread
+    fastdds::rtps::ThreadSettings security_log_thread;
+#endif // if HAVE_SECURITY
+
+private:
+
+    //! Name of the participant.
+    string_255 name{"RTPSParticipant"};
+};
+
+}  // namespace rtps
+}  // namespace fastrtps
+}  // namespace eprosima
+
+#endif  // _FASTDDS_RTPSPARTICIPANTPARAMETERS_H_
diff --git a/test/unittest/dds/participant/CMakeLists.txt b/test/unittest/dds/participant/CMakeLists.txt
index 9d3b8c74adb..2234b8a879a 100644
--- a/test/unittest/dds/participant/CMakeLists.txt
+++ b/test/unittest/dds/participant/CMakeLists.txt
@@ -47,7 +47,7 @@ target_link_libraries(ParticipantTests fastrtps fastcdr foonathan_memory
     ${CMAKE_DL_LIBS})
 
 if(EPROSIMA_TEST_DNS_NOT_SET_UP)
-    set(dns_filter "-ParticipantTests.SimpleParticipantRemoteServerListConfigurationDNS")
+    set(dns_filter "ParticipantTests.SimpleParticipantRemoteServerListConfigurationDNS")
 endif()
 
 add_gtest(ParticipantTests SOURCES ${PARTICIPANTTESTS_SOURCE} IGNORE ${dns_filter})
diff --git a/test/unittest/dds/participant/ParticipantTests.cpp b/test/unittest/dds/participant/ParticipantTests.cpp
index 2e880b0a97a..a06cc064c84 100644
--- a/test/unittest/dds/participant/ParticipantTests.cpp
+++ b/test/unittest/dds/participant/ParticipantTests.cpp
@@ -49,7 +49,11 @@
 #include <fastdds/rtps/attributes/ServerAttributes.h>
 #include <fastdds/rtps/common/Locator.h>
 #include <fastdds/rtps/participant/RTPSParticipant.h>
+#include <fastdds/rtps/transport/UDPv4TransportDescriptor.h>
 #include <fastdds/rtps/transport/UDPv6TransportDescriptor.h>
+#include <fastdds/rtps/transport/TCPv4TransportDescriptor.h>
+#include <fastdds/rtps/transport/TCPv6TransportDescriptor.h>
+#include <fastdds/rtps/transport/shared_mem/SharedMemTransportDescriptor.h>
 #include <fastrtps/attributes/PublisherAttributes.h>
 #include <fastrtps/attributes/SubscriberAttributes.h>
 #include <fastrtps/types/DynamicDataFactory.h>
@@ -76,6 +80,7 @@
 #define GET_PID getpid
 #endif // if defined(_WIN32)
 
+
 namespace eprosima {
 namespace fastdds {
 namespace dds {
@@ -92,7 +97,6 @@ using fastrtps::types::TypeDescriptor;
 using fastrtps::xmlparser::XMLP_ret;
 using fastrtps::xmlparser::XMLProfileManager;
 
-
 // Mocked TopicDataType for Topic creation tests
 class TopicDataTypeMock : public TopicDataType
 {
@@ -4017,6 +4021,230 @@ TEST(ParticipantTests, TwoParticipantWithSameFixedId)
     }
 }
 
+
+TEST(ParticipantTests, ParticipantCreationWithBuiltinTransport)
+{
+    {
+        DomainParticipantQos qos;
+        fastrtps::rtps::RTPSParticipantAttributes attributes_;
+        qos.setup_transports(rtps::BuiltinTransports::DEFAULT);
+
+        DomainParticipant* participant_ = DomainParticipantFactory::get_instance()->create_participant(
+            (uint32_t)GET_PID() % 230, qos);
+        ASSERT_NE(nullptr, participant_);
+
+        get_rtps_attributes(participant_, attributes_);
+
+        auto transport_check = [](fastrtps::rtps::RTPSParticipantAttributes& attributes_) -> bool
+                {
+                    for (auto& transportDescriptor : attributes_.userTransports)
+                    {
+                        if ( nullptr !=
+                                dynamic_cast<fastdds::rtps::UDPv4TransportDescriptor*>(transportDescriptor.get()))
+                        {
+                            return true;
+                        }
+                    }
+                    return false;
+                };
+        EXPECT_TRUE(transport_check(attributes_));
+        EXPECT_FALSE(attributes_.useBuiltinTransports);
+    }
+
+    {
+        DomainParticipantQos qos;
+        fastrtps::rtps::RTPSParticipantAttributes attributes_;
+        qos.setup_transports(rtps::BuiltinTransports::DEFAULTv6);
+
+        DomainParticipant* participant_ = DomainParticipantFactory::get_instance()->create_participant(
+            (uint32_t)GET_PID() % 230, qos);
+        ASSERT_NE(nullptr, participant_);
+
+        get_rtps_attributes(participant_, attributes_);
+
+        auto transport_check = [](fastrtps::rtps::RTPSParticipantAttributes& attributes_) -> bool
+                {
+                    for (auto& transportDescriptor : attributes_.userTransports)
+                    {
+                        if ( nullptr !=
+                                dynamic_cast<fastdds::rtps::UDPv6TransportDescriptor*>(transportDescriptor.get()))
+                        {
+                            return true;
+                        }
+                    }
+                    return false;
+                };
+        EXPECT_TRUE(transport_check(attributes_));
+        EXPECT_FALSE(attributes_.useBuiltinTransports);
+    }
+
+    {
+        DomainParticipantQos qos;
+        fastrtps::rtps::RTPSParticipantAttributes attributes_;
+        qos.setup_transports(rtps::BuiltinTransports::SHM);
+
+        DomainParticipant* participant_ = DomainParticipantFactory::get_instance()->create_participant(
+            (uint32_t)GET_PID() % 230, qos);
+        ASSERT_NE(nullptr, participant_);
+
+        get_rtps_attributes(participant_, attributes_);
+
+        auto transport_check = [](fastrtps::rtps::RTPSParticipantAttributes& attributes_) -> bool
+                {
+                    for (auto& transportDescriptor : attributes_.userTransports)
+                    {
+                        if ( nullptr !=
+                                dynamic_cast<fastdds::rtps::SharedMemTransportDescriptor*>(transportDescriptor.get()))
+                        {
+                            return true;
+                        }
+                    }
+                    return false;
+                };
+        EXPECT_TRUE(transport_check(attributes_));
+        EXPECT_FALSE(attributes_.useBuiltinTransports);
+
+    }
+
+    {
+        DomainParticipantQos qos;
+        fastrtps::rtps::RTPSParticipantAttributes attributes_;
+        qos.setup_transports(rtps::BuiltinTransports::UDPv4);
+
+        DomainParticipant* participant_ = DomainParticipantFactory::get_instance()->create_participant(
+            (uint32_t)GET_PID() % 230, qos);
+        ASSERT_NE(nullptr, participant_);
+
+        get_rtps_attributes(participant_, attributes_);
+
+        auto transport_check = [](fastrtps::rtps::RTPSParticipantAttributes& attributes_) -> bool
+                {
+                    for (auto& transportDescriptor : attributes_.userTransports)
+                    {
+                        if ( nullptr !=
+                                dynamic_cast<fastdds::rtps::UDPv4TransportDescriptor*>(transportDescriptor.get()))
+                        {
+                            return true;
+                        }
+                    }
+                    return false;
+                };
+        EXPECT_TRUE(transport_check(attributes_));
+        EXPECT_FALSE(attributes_.useBuiltinTransports);
+    }
+
+    {
+        DomainParticipantQos qos;
+        fastrtps::rtps::RTPSParticipantAttributes attributes_;
+        qos.setup_transports(rtps::BuiltinTransports::UDPv6);
+
+        DomainParticipant* participant_ = DomainParticipantFactory::get_instance()->create_participant(
+            (uint32_t)GET_PID() % 230, qos);
+        ASSERT_NE(nullptr, participant_);
+
+        get_rtps_attributes(participant_, attributes_);
+
+        auto transport_check = [](fastrtps::rtps::RTPSParticipantAttributes& attributes_) -> bool
+                {
+                    for (auto& transportDescriptor : attributes_.userTransports)
+                    {
+                        if ( nullptr !=
+                                dynamic_cast<fastdds::rtps::UDPv6TransportDescriptor*>(transportDescriptor.get()))
+                        {
+                            return true;
+                        }
+                    }
+                    return false;
+                };
+        EXPECT_TRUE(transport_check(attributes_));
+        EXPECT_FALSE(attributes_.useBuiltinTransports);
+    }
+
+    {
+        DomainParticipantQos qos;
+        fastrtps::rtps::RTPSParticipantAttributes attributes_;
+        qos.setup_transports(rtps::BuiltinTransports::LARGE_DATA);
+
+        DomainParticipant* participant_ = DomainParticipantFactory::get_instance()->create_participant(
+            (uint32_t)GET_PID() % 230, qos);
+        ASSERT_NE(nullptr, participant_);
+
+        get_rtps_attributes(participant_, attributes_);
+
+        auto transport_check = [](fastrtps::rtps::RTPSParticipantAttributes& attributes_) -> bool
+                {
+                    bool hasSHM = false;
+                    bool hasUDP = false;
+                    bool hasTCP = false;
+                    for (auto& transportDescriptor : attributes_.userTransports)
+                    {
+                        if ( nullptr !=
+                                dynamic_cast<fastdds::rtps::SharedMemTransportDescriptor*>(transportDescriptor.get()))
+                        {
+                            hasSHM = true;
+                        }
+                        else if ( nullptr !=
+                                dynamic_cast<fastdds::rtps::UDPv4TransportDescriptor*>(transportDescriptor.get()))
+                        {
+                            hasUDP = true;
+                        }
+                        else if ( nullptr !=
+                                dynamic_cast<fastdds::rtps::TCPv4TransportDescriptor*>(transportDescriptor.get()))
+                        {
+                            hasTCP = true;
+                        }
+                    }
+
+                    return (hasSHM && hasUDP && hasTCP);
+                };
+        EXPECT_TRUE(transport_check(attributes_));
+        EXPECT_FALSE(attributes_.useBuiltinTransports);
+    }
+
+    {
+        DomainParticipantQos qos;
+        fastrtps::rtps::RTPSParticipantAttributes attributes_;
+        qos.setup_transports(rtps::BuiltinTransports::LARGE_DATAv6);
+
+        DomainParticipant* participant_ = DomainParticipantFactory::get_instance()->create_participant(
+            (uint32_t)GET_PID() % 230, qos);
+        ASSERT_NE(nullptr, participant_);
+
+        get_rtps_attributes(participant_, attributes_);
+
+        auto transport_check = [](fastrtps::rtps::RTPSParticipantAttributes& attributes_) -> bool
+                {
+                    bool hasSHM = false;
+                    bool hasUDP = false;
+                    bool hasTCP = false;
+                    for (auto& transportDescriptor : attributes_.userTransports)
+                    {
+                        if ( nullptr !=
+                                dynamic_cast<fastdds::rtps::SharedMemTransportDescriptor*>(transportDescriptor.get()))
+                        {
+                            hasSHM = true;
+                        }
+                        else if ( nullptr !=
+                                dynamic_cast<fastdds::rtps::UDPv6TransportDescriptor*>(transportDescriptor.get()))
+                        {
+                            hasUDP = true;
+                        }
+                        else if ( nullptr !=
+                                dynamic_cast<fastdds::rtps::TCPv6TransportDescriptor*>(transportDescriptor.get()))
+                        {
+                            hasTCP = true;
+                        }
+                    }
+
+                    return (hasSHM && hasUDP && hasTCP);
+                };
+        EXPECT_TRUE(transport_check(attributes_));
+        EXPECT_FALSE(attributes_.useBuiltinTransports);
+    }
+}
+
+
+
 } // namespace dds
 } // namespace fastdds
 } // namespace eprosima
diff --git a/test/unittest/dds/publisher/CMakeLists.txt b/test/unittest/dds/publisher/CMakeLists.txt
index 5153df653aa..704514fa87b 100644
--- a/test/unittest/dds/publisher/CMakeLists.txt
+++ b/test/unittest/dds/publisher/CMakeLists.txt
@@ -152,6 +152,7 @@ set(DATAWRITERTESTS_SOURCE DataWriterTests.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/network/ExternalLocatorsProcessor.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/network/NetworkFactory.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/network/ReceiverResource.cpp
+    ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/RTPSParticipantAttributes.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/participant/RTPSParticipant.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/participant/RTPSParticipantImpl.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/persistence/PersistenceFactory.cpp
diff --git a/test/unittest/dds/status/CMakeLists.txt b/test/unittest/dds/status/CMakeLists.txt
index 80d2d823545..e9cb3fb34aa 100644
--- a/test/unittest/dds/status/CMakeLists.txt
+++ b/test/unittest/dds/status/CMakeLists.txt
@@ -160,6 +160,7 @@ target_include_directories(ListenerTests PRIVATE
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/RTPSWriter
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/RTPSDomain
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/RTPSDomainImpl
+    ${PROJECT_SOURCE_DIR}/test/mock/rtps/RTPSParticipantAttributes
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/RTPSParticipant
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/RTPSParticipantImpl
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/Endpoint
diff --git a/test/unittest/dynamic_types/CMakeLists.txt b/test/unittest/dynamic_types/CMakeLists.txt
index a709601897a..fd317b387b9 100644
--- a/test/unittest/dynamic_types/CMakeLists.txt
+++ b/test/unittest/dynamic_types/CMakeLists.txt
@@ -121,7 +121,11 @@ target_include_directories(DynamicTypesTests PRIVATE
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/UDPTransportDescriptor
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/UDPv4TransportDescriptor
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/UDPv6TransportDescriptor
+<<<<<<< HEAD
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/SharedMemTransportDescriptor
+=======
+    ${PROJECT_SOURCE_DIR}/test/mock/rtps/RTPSParticipantAttributes
+>>>>>>> 8cbd46144 (Methods to configure transport scenarios (#4098))
     $<$<BOOL:${TINYXML2_INCLUDE_DIR}>:${TINYXML2_INCLUDE_DIR}>
     ${PROJECT_SOURCE_DIR}/include ${PROJECT_BINARY_DIR}/include
     ${PROJECT_SOURCE_DIR}/src/cpp
diff --git a/test/unittest/statistics/dds/CMakeLists.txt b/test/unittest/statistics/dds/CMakeLists.txt
index 8e001e00892..2c50773918e 100644
--- a/test/unittest/statistics/dds/CMakeLists.txt
+++ b/test/unittest/statistics/dds/CMakeLists.txt
@@ -143,6 +143,203 @@ if (SQLITE3_SUPPORT AND FASTDDS_STATISTICS AND NOT QNX)
         ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/publisher/DataWriter.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/publisher/DataWriterHistory.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/publisher/DataWriterImpl.cpp
+<<<<<<< HEAD
+=======
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/publisher/DataWriterHistory.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/publisher/PublisherImpl.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/publisher/qos/DataWriterQos.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/publisher/qos/PublisherQos.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/publisher/qos/WriterQos.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/subscriber/DataReader.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/subscriber/DataReaderImpl.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/subscriber/history/DataReaderHistory.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/subscriber/qos/DataReaderQos.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/subscriber/qos/ReaderQos.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/subscriber/qos/SubscriberQos.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/subscriber/ReadCondition.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/subscriber/Subscriber.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/subscriber/SubscriberImpl.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/topic/ContentFilteredTopic.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/topic/ContentFilteredTopicImpl.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/topic/qos/TopicQos.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/topic/Topic.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/topic/TopicImpl.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/topic/TopicProxyFactory.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/topic/TypeSupport.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/topic/TopicDataType.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/utils/QosConverters.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/PropertyPolicy.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/ThreadSettings.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/BuiltinProtocols.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/data/ParticipantProxyData.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/data/ReaderProxyData.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/data/WriterProxyData.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/database/backup/SharedBackupFunctions.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/database/DiscoveryDataBase.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/database/DiscoveryParticipantInfo.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/database/DiscoveryParticipantsAckStatus.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/database/DiscoverySharedInfo.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/endpoint/EDP.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/endpoint/EDPClient.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/endpoint/EDPServer.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/endpoint/EDPServerListeners.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/endpoint/EDPSimple.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/endpoint/EDPSimpleListeners.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/endpoint/EDPStatic.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/DirectMessageSender.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDP.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPClient.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPListener.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPServer.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPServerListener.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPSimple.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/ServerAttributes.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/timedevent/DSClientEvent.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/timedevent/DServerEvent.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/liveliness/WLP.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/liveliness/WLPListener.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/common/Time_t.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/DataSharing/DataSharingListener.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/DataSharing/DataSharingNotification.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/DataSharing/DataSharingPayloadPool.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/flowcontrol/FlowControllerConsts.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/flowcontrol/FlowControllerFactory.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/flowcontrol/ThroughputControllerDescriptor.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/history/CacheChangePool.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/history/History.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/history/ReaderHistory.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/history/TopicPayloadPool.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/history/TopicPayloadPoolRegistry.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/history/WriterHistory.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/messages/MessageReceiver.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/messages/RTPSGapBuilder.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/messages/RTPSMessageCreator.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/messages/RTPSMessageGroup.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/messages/SendBuffersManager.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/network/ExternalLocatorsProcessor.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/network/NetworkFactory.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/network/ReceiverResource.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/RTPSParticipantAttributes.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/participant/RTPSParticipant.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/participant/RTPSParticipantImpl.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/persistence/PersistenceFactory.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/persistence/sqlite3.c
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/persistence/SQLite3PersistenceService.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/reader/RTPSReader.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/reader/StatefulPersistentReader.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/reader/StatefulReader.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/reader/StatelessPersistentReader.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/reader/StatelessReader.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/reader/WriterProxy.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/resources/ResourceEvent.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/resources/TimedEvent.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/resources/TimedEventImpl.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/RTPSDomain.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/ChannelResource.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/PortBasedTransportDescriptor.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/shared_mem/SharedMemTransportDescriptor.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/tcp/RTCPMessageManager.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/tcp/TCPControlMessage.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/TCPAcceptor.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/TCPAcceptorBasic.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/TCPChannelResource.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/TCPChannelResourceBasic.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/TCPTransportInterface.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/TCPv4Transport.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/TCPv6Transport.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/UDPChannelResource.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/UDPTransportInterface.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/UDPv4Transport.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/transport/UDPv6Transport.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/writer/LivelinessManager.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/writer/LocatorSelectorSender.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/writer/PersistentWriter.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/writer/ReaderLocator.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/writer/ReaderProxy.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/writer/RTPSWriter.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/writer/StatefulPersistentWriter.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/writer/StatefulWriter.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/writer/StatelessPersistentWriter.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/writer/StatelessWriter.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/xmlparser/XMLDynamicParser.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/xmlparser/XMLElementParser.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/xmlparser/XMLEndpointParser.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/xmlparser/XMLParser.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/xmlparser/XMLParserCommon.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/xmlparser/XMLProfileManager.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/fastdds/domain/DomainParticipant.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/fastdds/domain/DomainParticipantImpl.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/fastdds/domain/DomainParticipantStatisticsListener.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/fastdds/publisher/qos/DataWriterQos.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/rtps/reader/StatisticsReaderImpl.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/rtps/StatisticsBase.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/rtps/monitor-service/MonitorService.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/rtps/monitor-service/MonitorServiceListener.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/rtps/writer/StatisticsWriterImpl.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/types/types.cxx
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/types/typesv1.cxx
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/types/typesPubSubTypes.cxx
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/types/monitorservice_typesPubSubTypes.cxx
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/types/monitorservice_types.cxx
+        ${PROJECT_SOURCE_DIR}/src/cpp/statistics/types/monitorservice_typesv1.cxx
+        ${PROJECT_SOURCE_DIR}/src/cpp/utils/IPFinder.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/utils/IPLocator.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/utils/md5.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/utils/string_convert.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/utils/StringMatching.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/utils/SystemInfo.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/utils/TimedConditionVariable.cpp
+        )
+
+    set(STATISTICS_DOMAINPARTICIPANT_STATUS_QUERYABLE_TESTS_SOURCE
+        StatisticsDomainParticipantStatusQueryableTests.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/AnnotationDescriptor.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/AnnotationParameterValue.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/BuiltinAnnotationsTypeObject.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/DynamicData.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/DynamicDataFactory.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/DynamicPubSubType.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/DynamicType.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/DynamicTypeBuilder.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/DynamicTypeBuilderFactory.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/DynamicTypeBuilderPtr.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/DynamicTypeMember.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/DynamicTypePtr.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/MemberDescriptor.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/TypeDescriptor.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/TypeIdentifier.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/TypeIdentifierTypes.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/TypeNamesGenerator.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/TypeObject.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/TypeObjectFactory.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/TypeObjectHashId.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/dynamic-types/TypesBase.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/builtin/common/RPCHeadersImpl.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/builtin/typelookup/TypeLookupManager.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/builtin/typelookup/TypeLookupReplyListener.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/builtin/typelookup/TypeLookupRequestListener.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/builtin/typelookup/common/TypeLookupTypes.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/core/Entity.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/core/condition/Condition.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/core/condition/ConditionNotifier.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/core/condition/StatusCondition.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/core/condition/StatusConditionImpl.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/core/condition/WaitSetImpl.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/core/policy/ParameterList.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/core/policy/QosPolicyUtils.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/core/policy/QosPolicyUtils.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/domain/DomainParticipant.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/domain/DomainParticipantFactory.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/domain/qos/DomainParticipantFactoryQos.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/domain/qos/DomainParticipantQos.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/log/FileConsumer.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/log/Log.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/log/OStreamConsumer.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/log/StdoutConsumer.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/log/StdoutErrConsumer.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/publisher/DataWriter.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/publisher/DataWriterHistory.cpp
+>>>>>>> 8cbd46144 (Methods to configure transport scenarios (#4098))
         ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/publisher/PublisherImpl.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/publisher/qos/DataWriterQos.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/publisher/qos/PublisherQos.cpp
@@ -374,7 +571,58 @@ if (SQLITE3_SUPPORT AND FASTDDS_STATISTICS AND NOT QNX)
             iphlpapi Shlwapi
             )
     endif()
+<<<<<<< HEAD
     add_gtest(StatisticsDomainParticipantMockTests SOURCES ${STATISTICS_DOMAINPARTICIPANT_MOCK_TESTS_SOURCE})
+=======
+
+    gtest_discover_tests(StatisticsDomainParticipantMockTests)
+
+    add_executable(StatisticsDomainParticipantStatusQueryableTests ${STATISTICS_DOMAINPARTICIPANT_STATUS_QUERYABLE_TESTS_SOURCE})
+    target_compile_definitions(StatisticsDomainParticipantStatusQueryableTests PRIVATE FASTRTPS_NO_LIB
+        BOOST_ASIO_STANDALONE
+        ASIO_STANDALONE
+        SQLITE_WIN32_GETVERSIONEX=0
+        $<$<AND:$<NOT:$<BOOL:${WIN32}>>,$<STREQUAL:"${CMAKE_BUILD_TYPE}","Debug">>:__DEBUG>
+        $<$<BOOL:${INTERNAL_DEBUG}>:__INTERNALDEBUG> # Internal debug activated.
+        $<$<AND:$<BOOL:${WIN32}>,$<STREQUAL:"${CMAKE_SYSTEM_NAME}","WindowsStore">>:_WIN32_WINNT=0x0603>
+        $<$<AND:$<BOOL:${WIN32}>,$<NOT:$<STREQUAL:"${CMAKE_SYSTEM_NAME}","WindowsStore">>>:_WIN32_WINNT=0x0601>
+        $<$<AND:$<BOOL:${WIN32}>,$<STREQUAL:"${CMAKE_SYSTEM_NAME}","WindowsStore">>:SQLITE_OS_WINRT>
+        $<$<AND:$<BOOL:${ANDROID}>,$<NOT:$<BOOL:${HAVE_CXX14}>>,$<NOT:$<BOOL:${HAVE_CXX1Y}>>>:ASIO_DISABLE_STD_STRING_VIEW>
+        $<$<BOOL:${WIN32}>:_ENABLE_ATOMIC_ALIGNMENT_FIX>
+        $<$<NOT:$<BOOL:${IS_THIRDPARTY_BOOST_SUPPORTED}>>:FASTDDS_SHM_TRANSPORT_DISABLED> # Do not compile SHM Transport
+        $<$<BOOL:${SHM_TRANSPORT_DEFAULT}>:SHM_TRANSPORT_BUILTIN> # Enable SHM as built-in transport
+        $<$<BOOL:${STDOUTERR_LOG_CONSUMER}>:STDOUTERR_LOG_CONSUMER> # Enable StdoutErrConsumer as default LogConsumer
+        )
+    target_include_directories(StatisticsDomainParticipantStatusQueryableTests PRIVATE
+        $<$<BOOL:${OPENSSL_INCLUDE_DIR}>:${OPENSSL_INCLUDE_DIR}>
+        StatisticsDomainParticipantStatusQueryableTests/mock/
+        ${PROJECT_SOURCE_DIR}/test/mock/dds/Publisher/
+        ${PROJECT_SOURCE_DIR}/test/mock/dds/DomainParticipantImpl/
+        ${PROJECT_SOURCE_DIR}/test/mock/rtps/RTPSParticipantAttributes
+        ${PROJECT_SOURCE_DIR}/include
+        ${PROJECT_BINARY_DIR}/include
+        ${Asio_INCLUDE_DIR}
+        ${PROJECT_SOURCE_DIR}/src/cpp
+        ${THIRDPARTY_BOOST_INCLUDE_DIR})
+    target_link_libraries(StatisticsDomainParticipantStatusQueryableTests ${PRIVACY}
+        fastcdr
+        foonathan_memory
+        GTest::gmock
+        ${CMAKE_DL_LIBS}
+        ${TINYXML2_LIBRARY}
+        $<$<BOOL:${LINK_SSL}>:OpenSSL::SSL$<SEMICOLON>OpenSSL::Crypto>
+        $<$<BOOL:${WIN32}>:iphlpapi$<SEMICOLON>Shlwapi>
+        ${THIRDPARTY_BOOST_LINK_LIBS}
+        eProsima_atomic
+        )
+    if(MSVC OR MSVC_IDE)
+        target_link_libraries(StatisticsDomainParticipantStatusQueryableTests ${PRIVACY}
+            iphlpapi Shlwapi
+            )
+    endif()
+    gtest_discover_tests(StatisticsDomainParticipantStatusQueryableTests)
+
+>>>>>>> 8cbd46144 (Methods to configure transport scenarios (#4098))
 endif (SQLITE3_SUPPORT AND FASTDDS_STATISTICS AND NOT QNX)
 
 if(ANDROID)
diff --git a/test/unittest/xmlparser/CMakeLists.txt b/test/unittest/xmlparser/CMakeLists.txt
index d314e15da64..4885f0327de 100644
--- a/test/unittest/xmlparser/CMakeLists.txt
+++ b/test/unittest/xmlparser/CMakeLists.txt
@@ -149,6 +149,7 @@ target_include_directories(XMLProfileParserTests PRIVATE
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/UDPTransportDescriptor
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/UDPv4TransportDescriptor
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/UDPv6TransportDescriptor
+    ${PROJECT_SOURCE_DIR}/test/mock/rtps/RTPSParticipantAttributes
     ${PROJECT_SOURCE_DIR}/include ${PROJECT_BINARY_DIR}/include
     ${Asio_INCLUDE_DIR}
     $<$<BOOL:${ANDROID}>:${ANDROID_IFADDRS_INCLUDE_DIR}>
@@ -246,7 +247,11 @@ target_include_directories(XMLParserTests PRIVATE
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/UDPTransportDescriptor
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/UDPv4TransportDescriptor
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/UDPv6TransportDescriptor
+<<<<<<< HEAD
     ${PROJECT_SOURCE_DIR}/test/mock/rtps/SharedMemTransportDescriptor
+=======
+    ${PROJECT_SOURCE_DIR}/test/mock/rtps/RTPSParticipantAttributes
+>>>>>>> 8cbd46144 (Methods to configure transport scenarios (#4098))
     ${PROJECT_SOURCE_DIR}/include
     ${PROJECT_BINARY_DIR}/include
     ${PROJECT_SOURCE_DIR}/src/cpp
diff --git a/test/unittest/xmlparser/XMLElementParserTests.cpp b/test/unittest/xmlparser/XMLElementParserTests.cpp
index 0f854c27de2..35022c5bd14 100644
--- a/test/unittest/xmlparser/XMLElementParserTests.cpp
+++ b/test/unittest/xmlparser/XMLElementParserTests.cpp
@@ -467,8 +467,8 @@ TEST_F(XMLParserTests, getXMLLocatorTCPv4)
  * 1. Correct parsing of a valid element.
  * 2. Check an empty definition of <physical_port> .
  * 3. Check an empty definition of <port>.
- * 5. Check an empty definition of <address>.
- * 6. Check an bad element as a child xml element.
+ * 4. Check an empty definition of <address>.
+ * 5. Check an bad element as a child xml element.
  */
 TEST_F(XMLParserTests, getXMLLocatorTCPv6)
 {
@@ -537,8 +537,8 @@ TEST_F(XMLParserTests, getXMLLocatorTCPv6)
  * 1. Correct parsing of a valid descriptor present in the XmlProfileManager.
  * 2. Check a reference to a non existentTransportDescriptorInterface.
  * 3. Check an empty definition of <transport_id>.
- * 5. Check an empty definition of <transport_descriptor>.
- * 6. Check an empty list of transports.
+ * 4. Check an empty definition of <transport_descriptor>.
+ * 5. Check an empty list of transports.
  */
 TEST_F(XMLParserTests, getXMLTransports)
 {
@@ -602,14 +602,70 @@ TEST_F(XMLParserTests, getXMLTransports)
     xmlparser::XMLProfileManager::DeleteInstance();
 }
 
+/*
+ * This test checks the proper parsing of the <builtinTransports> xml elements and negative cases.
+ * 1. Correct parsing of all valid values of BuiltinTransport.
+ * 2. Check a wrong definition of <builtinTransports>.
+ * 3. Check an empty definition of <builtinTransports>.
+ */
+TEST_F(XMLParserTests, getXMLbuiltinTransports)
+{
+    uint8_t ident = 1;
+    eprosima::fastdds::rtps::BuiltinTransports bt;
+    tinyxml2::XMLDocument xml_doc;
+    tinyxml2::XMLElement* titleElement;
+
+    // Parametrized XML
+    const char* xml_p =
+            "\
+            <builtinTransports>%s</builtinTransports>\
+            ";
+    constexpr size_t xml_len {500};
+    char xml[xml_len];
+
+    // Valid XML
+    std::vector<std::string> bt_list;
+    bt_list.push_back("NONE");
+    bt_list.push_back("DEFAULT");
+    bt_list.push_back("DEFAULTv6");
+    bt_list.push_back("SHM");
+    bt_list.push_back("UDPv4");
+    bt_list.push_back("UDPv6");
+    bt_list.push_back("LARGE_DATA");
+    bt_list.push_back("LARGE_DATAv6");
+
+    for (auto test_transport : bt_list)
+    {
+        snprintf(xml, xml_len, xml_p, test_transport.c_str());
+        ASSERT_EQ(tinyxml2::XMLError::XML_SUCCESS, xml_doc.Parse(xml));
+        titleElement = xml_doc.RootElement();
+        ASSERT_EQ(XMLP_ret::XML_OK, XMLParserTest::getXMLBuiltinTransports_wrapper(titleElement, &bt, ident));
+    }
+
+    // Wrong ID
+    snprintf(xml, xml_len, xml_p, "WrongBuiltinTransport");
+    ASSERT_EQ(tinyxml2::XMLError::XML_SUCCESS, xml_doc.Parse(xml));
+    titleElement = xml_doc.RootElement();
+    ASSERT_EQ(XMLP_ret::XML_ERROR, XMLParserTest::getXMLBuiltinTransports_wrapper(titleElement, &bt, ident));
+
+    // Missing data
+    snprintf(xml, xml_len, xml_p, "");
+    ASSERT_EQ(tinyxml2::XMLError::XML_SUCCESS, xml_doc.Parse(xml));
+    titleElement = xml_doc.RootElement();
+    ASSERT_EQ(XMLP_ret::XML_ERROR, XMLParserTest::getXMLBuiltinTransports_wrapper(titleElement, &bt, ident));
+
+    // Clean up
+    xmlparser::XMLProfileManager::DeleteInstance();
+}
+
 /*
  * This test checks the proper parsing of the <property_policy> xml elements to a PropertyPolicy object, and negative
  * cases.
  * 1. Correct parsing of a valid <property_policy>.
  * 2. Check missing values for the possible elemnts of the properties.
  * 3. Check an empty list of <properties>.
- * 5. Check an empty list of <binary_properties>.
- * 6. Check an wrong descriptor for properties.
+ * 4. Check an empty list of <binary_properties>.
+ * 5. Check an wrong descriptor for properties.
  */
 TEST_F(XMLParserTests, getXMLPropertiesPolicy)
 {
diff --git a/test/unittest/xmlparser/wrapper/XMLParserTest.hpp b/test/unittest/xmlparser/wrapper/XMLParserTest.hpp
index 9c4fe763afd..1941eafbbe5 100644
--- a/test/unittest/xmlparser/wrapper/XMLParserTest.hpp
+++ b/test/unittest/xmlparser/wrapper/XMLParserTest.hpp
@@ -150,6 +150,14 @@ class XMLParserTest : public XMLParser
         return getXMLTransports(elem, transports, ident);
     }
 
+    static XMLP_ret getXMLBuiltinTransports_wrapper(
+            tinyxml2::XMLElement* elem,
+            eprosima::fastdds::rtps::BuiltinTransports* bt,
+            uint8_t ident)
+    {
+        return getXMLBuiltinTransports(elem, bt, ident);
+    }
+
     static XMLP_ret getXMLguidPrefix_wrapper(
             tinyxml2::XMLElement* elem,
             GuidPrefix_t& prefix,
diff --git a/versions.md b/versions.md
index 1c0fcad933e..01276352a77 100644
--- a/versions.md
+++ b/versions.md
@@ -1,6 +1,18 @@
 Forthcoming
 -----------
 
+<<<<<<< HEAD
+=======
+* Enable configuration of thread setting for all threads.
+* Added monitor service feature.
+* Added the possibility to define interfaces in the whitelist by interface name.
+* Enable support for DataRepresentationQos to select the CDR encoding.
+* Added the possibility to define a listening port equal to 0 in TCP Transport
+* Added support for TCP to Fast DDS CLI and environment variable
+* Enable Discovery Server example through TCP
+* Added configuration of builtin transports through DomainParticipantQos, environment
+  variable and XML.
+>>>>>>> 8cbd46144 (Methods to configure transport scenarios (#4098))
 
 Version 2.11.2
 --------------