842 lines
38 KiB
C
Executable file
842 lines
38 KiB
C
Executable file
/*
|
|
* Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
|
|
*
|
|
* This program and the accompanying materials are made available under the
|
|
* terms of the Eclipse Public License v. 2.0 which is available at
|
|
* http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
|
|
* v. 1.0 which is available at
|
|
* http://www.eclipse.org/org/documents/edl-v10.php.
|
|
*
|
|
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
|
*/
|
|
#include "RoundTrip.h"
|
|
#include "Space.h"
|
|
#include "ddsc/dds.h"
|
|
#include "os/os.h"
|
|
#include "test-common.h"
|
|
#include <criterion/criterion.h>
|
|
#include <criterion/logging.h>
|
|
|
|
static dds_entity_t g_participant = 0;
|
|
static dds_entity_t g_subscriber = 0;
|
|
static dds_entity_t g_publisher = 0;
|
|
static dds_entity_t g_topic = 0;
|
|
|
|
#define MAX_SAMPLES 1
|
|
|
|
static dds_sample_info_t g_info[MAX_SAMPLES];
|
|
|
|
static struct DDS_UserDataQosPolicy g_pol_userdata;
|
|
static struct DDS_TopicDataQosPolicy g_pol_topicdata;
|
|
static struct DDS_GroupDataQosPolicy g_pol_groupdata;
|
|
static struct DDS_DurabilityQosPolicy g_pol_durability;
|
|
static struct DDS_HistoryQosPolicy g_pol_history;
|
|
static struct DDS_ResourceLimitsQosPolicy g_pol_resource_limits;
|
|
static struct DDS_PresentationQosPolicy g_pol_presentation;
|
|
static struct DDS_LifespanQosPolicy g_pol_lifespan;
|
|
static struct DDS_DeadlineQosPolicy g_pol_deadline;
|
|
static struct DDS_LatencyBudgetQosPolicy g_pol_latency_budget;
|
|
static struct DDS_OwnershipQosPolicy g_pol_ownership;
|
|
static struct DDS_OwnershipStrengthQosPolicy g_pol_ownership_strength;
|
|
static struct DDS_LivelinessQosPolicy g_pol_liveliness;
|
|
static struct DDS_TimeBasedFilterQosPolicy g_pol_time_based_filter;
|
|
static struct DDS_PartitionQosPolicy g_pol_partition;
|
|
static struct DDS_ReliabilityQosPolicy g_pol_reliability;
|
|
static struct DDS_TransportPriorityQosPolicy g_pol_transport_priority;
|
|
static struct DDS_DestinationOrderQosPolicy g_pol_destination_order;
|
|
static struct DDS_WriterDataLifecycleQosPolicy g_pol_writer_data_lifecycle;
|
|
static struct DDS_ReaderDataLifecycleQosPolicy g_pol_reader_data_lifecycle;
|
|
static struct DDS_DurabilityServiceQosPolicy g_pol_durability_service;
|
|
|
|
static const char* c_userdata = "user_key";
|
|
static const char* c_topicdata = "topic_key";
|
|
static const char* c_groupdata = "group_key";
|
|
static const char* c_partitions[] = {"Partition1", "Partition2"};
|
|
|
|
static dds_qos_t *g_qos = NULL;
|
|
|
|
static void
|
|
qos_init(void)
|
|
{
|
|
g_qos = dds_qos_create();
|
|
cr_assert_not_null(g_qos);
|
|
|
|
g_pol_userdata.value._buffer = dds_alloc(strlen(c_userdata) + 1);
|
|
g_pol_userdata.value._length = (uint32_t)strlen(c_userdata) + 1;
|
|
g_pol_userdata.value._release = true;
|
|
g_pol_userdata.value._maximum = 0;
|
|
|
|
g_pol_topicdata.value._buffer = dds_alloc(strlen(c_topicdata) + 1);
|
|
g_pol_topicdata.value._length = (uint32_t)strlen(c_topicdata) + 1;
|
|
g_pol_topicdata.value._release = true;
|
|
g_pol_topicdata.value._maximum = 0;
|
|
|
|
g_pol_groupdata.value._buffer = dds_alloc(strlen(c_groupdata) + 1);
|
|
g_pol_groupdata.value._length = (uint32_t)strlen(c_groupdata) + 1;
|
|
g_pol_groupdata.value._release = true;
|
|
g_pol_groupdata.value._maximum = 0;
|
|
|
|
g_pol_history.kind = DDS_KEEP_LAST_HISTORY_QOS;
|
|
g_pol_history.depth = 1;
|
|
|
|
g_pol_resource_limits.max_samples = 1;
|
|
g_pol_resource_limits.max_instances = 1;
|
|
g_pol_resource_limits.max_samples_per_instance = 1;
|
|
|
|
g_pol_presentation.access_scope = DDS_INSTANCE_PRESENTATION_QOS;
|
|
g_pol_presentation.coherent_access = true;
|
|
g_pol_presentation.ordered_access = true;
|
|
|
|
g_pol_lifespan.duration.sec = 10000;
|
|
g_pol_lifespan.duration.nanosec = 11000;
|
|
|
|
g_pol_deadline.period.sec = 20000;
|
|
g_pol_deadline.period.nanosec = 220000;
|
|
|
|
g_pol_latency_budget.duration.sec = 30000;
|
|
g_pol_latency_budget.duration.nanosec = 33000;
|
|
|
|
g_pol_ownership.kind = DDS_EXCLUSIVE_OWNERSHIP_QOS;
|
|
|
|
g_pol_ownership_strength.value = 10;
|
|
|
|
g_pol_liveliness.kind = DDS_AUTOMATIC_LIVELINESS_QOS;
|
|
g_pol_liveliness.lease_duration.sec = 40000;
|
|
g_pol_liveliness.lease_duration.nanosec = 44000;
|
|
|
|
g_pol_time_based_filter.minimum_separation.sec = 50000;
|
|
g_pol_time_based_filter.minimum_separation.nanosec = 55000;
|
|
|
|
g_pol_partition.name._buffer = (char**)c_partitions;
|
|
g_pol_partition.name._length = 2;
|
|
|
|
g_pol_reliability.kind = DDS_RELIABLE_RELIABILITY_QOS;
|
|
g_pol_reliability.max_blocking_time.sec = 60000;
|
|
g_pol_reliability.max_blocking_time.nanosec = 66000;
|
|
|
|
g_pol_transport_priority.value = 42;
|
|
|
|
g_pol_destination_order.kind = DDS_BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS;
|
|
|
|
g_pol_writer_data_lifecycle.autodispose_unregistered_instances = true;
|
|
|
|
g_pol_reader_data_lifecycle.autopurge_disposed_samples_delay.sec = 70000;
|
|
g_pol_reader_data_lifecycle.autopurge_disposed_samples_delay.nanosec= 77000;
|
|
g_pol_reader_data_lifecycle.autopurge_nowriter_samples_delay.sec = 80000;
|
|
g_pol_reader_data_lifecycle.autopurge_nowriter_samples_delay.nanosec = 88000;
|
|
|
|
g_pol_durability_service.history_depth = 1;
|
|
g_pol_durability_service.history_kind = DDS_KEEP_LAST_HISTORY_QOS;
|
|
g_pol_durability_service.max_samples = 2;
|
|
g_pol_durability_service.max_instances = 3;
|
|
g_pol_durability_service.max_samples_per_instance = 4;
|
|
g_pol_durability_service.service_cleanup_delay.sec = 90000;
|
|
g_pol_durability_service.service_cleanup_delay.nanosec = 99000;
|
|
}
|
|
|
|
static void
|
|
qos_fini(void)
|
|
{
|
|
dds_qos_delete(g_qos);
|
|
dds_free(g_pol_userdata.value._buffer);
|
|
dds_free(g_pol_groupdata.value._buffer);
|
|
dds_free(g_pol_topicdata.value._buffer);
|
|
}
|
|
|
|
static void
|
|
setup(void)
|
|
{
|
|
qos_init();
|
|
|
|
g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
|
|
cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant");
|
|
g_topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, "RoundTrip", NULL, NULL);
|
|
cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic");
|
|
g_subscriber = dds_create_subscriber(g_participant, NULL, NULL);
|
|
cr_assert_gt(g_subscriber, 0, "Failed to create prerequisite g_subscriber");
|
|
g_publisher = dds_create_publisher(g_participant, NULL, NULL);
|
|
cr_assert_gt(g_publisher, 0, "Failed to create prerequisite g_publisher");
|
|
}
|
|
|
|
static void
|
|
teardown(void)
|
|
{
|
|
qos_fini();
|
|
dds_delete(g_participant);
|
|
}
|
|
#define T_MILLISECOND 1000000ll
|
|
#define T_SECOND (1000 * T_MILLISECOND)
|
|
|
|
int64_t from_ddsi_duration (DDS_Duration_t x)
|
|
{
|
|
int64_t t;
|
|
t = x.sec * 10^9 + x.nanosec;
|
|
return t;
|
|
}
|
|
|
|
static void
|
|
check_default_qos_of_builtin_entity(dds_entity_t entity)
|
|
{
|
|
dds_return_t ret;
|
|
int64_t deadline;
|
|
int64_t liveliness_lease_duration;
|
|
int64_t minimum_separation;
|
|
int64_t max_blocking_time;
|
|
int64_t autopurge_nowriter_samples_delay;
|
|
int64_t autopurge_disposed_samples_delay;
|
|
|
|
dds_durability_kind_t durability_kind;
|
|
dds_presentation_access_scope_kind_t presentation_access_scope_kind;
|
|
dds_ownership_kind_t ownership_kind;
|
|
dds_liveliness_kind_t liveliness_kind;
|
|
dds_reliability_kind_t reliability_kind;
|
|
dds_destination_order_kind_t destination_order_kind;
|
|
dds_history_kind_t history_kind;
|
|
|
|
char **partitions;
|
|
uint32_t plen;
|
|
|
|
dds_qos_t *qos = dds_qos_create();
|
|
cr_assert_not_null(qos);
|
|
|
|
ret = dds_get_qos(entity, qos);
|
|
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to get QOS of builtin entity");
|
|
|
|
dds_qget_durability(qos, &durability_kind);
|
|
dds_qget_presentation(qos, &presentation_access_scope_kind, &g_pol_presentation.coherent_access, &g_pol_presentation.ordered_access);
|
|
dds_qget_deadline(qos, &deadline);
|
|
dds_qget_ownership(qos, &ownership_kind);
|
|
dds_qget_liveliness(qos, &liveliness_kind, &liveliness_lease_duration);
|
|
dds_qget_time_based_filter(qos, &minimum_separation);
|
|
dds_qget_reliability(qos, &reliability_kind, &max_blocking_time);
|
|
dds_qget_destination_order(qos, &destination_order_kind);
|
|
dds_qget_history(qos, &history_kind, &g_pol_history.depth);
|
|
dds_qget_resource_limits(qos, &g_pol_resource_limits.max_samples, &g_pol_resource_limits.max_instances, &g_pol_resource_limits.max_samples_per_instance);
|
|
dds_qget_reader_data_lifecycle(qos, &autopurge_nowriter_samples_delay, &autopurge_disposed_samples_delay);
|
|
dds_qget_partition(qos, &plen, &partitions);
|
|
// no getter for ENTITY_FACTORY
|
|
|
|
if ((entity & DDS_ENTITY_KIND_MASK) == DDS_KIND_SUBSCRIBER) {
|
|
cr_expect_eq(plen, 1);
|
|
if (plen > 0) {
|
|
cr_expect_str_eq(partitions[0], "__BUILT-IN PARTITION__");
|
|
}
|
|
} else if ((entity & DDS_ENTITY_KIND_MASK) == DDS_KIND_READER) {
|
|
cr_expect_eq(durability_kind, DDS_DURABILITY_TRANSIENT_LOCAL);
|
|
cr_expect_eq(presentation_access_scope_kind, DDS_PRESENTATION_TOPIC);
|
|
cr_expect_eq(g_pol_presentation.coherent_access, false);
|
|
cr_expect_eq(g_pol_presentation.ordered_access, false);
|
|
cr_expect_eq(deadline, DDS_INFINITY);
|
|
cr_expect_eq(ownership_kind, DDS_OWNERSHIP_SHARED);
|
|
cr_expect_eq(liveliness_kind, DDS_LIVELINESS_AUTOMATIC);
|
|
cr_expect_eq(minimum_separation, 0);
|
|
cr_expect_eq(reliability_kind, DDS_RELIABILITY_RELIABLE);
|
|
cr_expect_eq(max_blocking_time, DDS_MSECS(100));
|
|
cr_expect_eq(destination_order_kind, DDS_DESTINATIONORDER_BY_RECEPTION_TIMESTAMP);
|
|
cr_expect_eq(history_kind, DDS_HISTORY_KEEP_LAST);
|
|
cr_expect_eq(g_pol_history.depth, 1);
|
|
cr_expect_eq(g_pol_resource_limits.max_instances, DDS_LENGTH_UNLIMITED);
|
|
cr_expect_eq(g_pol_resource_limits.max_samples, DDS_LENGTH_UNLIMITED);
|
|
cr_expect_eq(g_pol_resource_limits.max_samples_per_instance, DDS_LENGTH_UNLIMITED);
|
|
cr_expect_eq(autopurge_nowriter_samples_delay, DDS_INFINITY);
|
|
cr_expect_eq(autopurge_disposed_samples_delay, DDS_INFINITY);
|
|
} else {
|
|
cr_assert_fail("Unsupported entity kind %s", entity_kind_str(entity));
|
|
}
|
|
if (plen > 0) {
|
|
for (uint32_t i = 0; i < plen; i++) {
|
|
dds_free(partitions[i]);
|
|
}
|
|
dds_free(partitions);
|
|
}
|
|
dds_qos_delete(qos);
|
|
}
|
|
|
|
static dds_entity_t builtin_topic_handles[10];
|
|
|
|
Test(ddsc_builtin_topics, types_allocation)
|
|
{
|
|
#define TEST_ALLOC(type) do { \
|
|
DDS_##type##BuiltinTopicData *data = DDS_##type##BuiltinTopicData__alloc(); \
|
|
cr_expect_not_null(data, "Failed to allocate DDS_" #type "BuiltinTopicData"); \
|
|
DDS_##type##BuiltinTopicData_free(data, DDS_FREE_ALL); \
|
|
} while(0)
|
|
|
|
TEST_ALLOC(Participant);
|
|
TEST_ALLOC(CMParticipant);
|
|
TEST_ALLOC(Type);
|
|
TEST_ALLOC(Topic);
|
|
TEST_ALLOC(Publication);
|
|
TEST_ALLOC(CMPublisher);
|
|
TEST_ALLOC(Subscription);
|
|
TEST_ALLOC(CMSubscriber);
|
|
TEST_ALLOC(CMDataWriter);
|
|
TEST_ALLOC(CMDataReader);
|
|
#undef TEST_ALLOC
|
|
}
|
|
|
|
Test(ddsc_builtin_topics, availability_builtin_topics, .init = setup, .fini = teardown)
|
|
{
|
|
dds_entity_t topic;
|
|
|
|
topic = dds_find_topic(g_participant, "DCPSParticipant");
|
|
cr_assert_gt(topic, 0);
|
|
dds_delete(topic);
|
|
topic = dds_find_topic(g_participant, "DCPSTopic");
|
|
cr_assert_lt(topic, 0);
|
|
//TODO CHAM-347: dds_delete(topic);
|
|
topic = dds_find_topic(g_participant, "DCPSType");
|
|
cr_assert_lt(topic, 0);
|
|
//TODO CHAM-347: dds_delete(topic);
|
|
topic = dds_find_topic(g_participant, "DCPSSubscription");
|
|
cr_assert_lt(topic, 0);
|
|
//TODO CHAM-347: dds_delete(topic);
|
|
topic = dds_find_topic(g_participant, "DCSPPublication");
|
|
cr_assert_lt(topic, 0);
|
|
//TODO CHAM-347: dds_delete(topic);
|
|
}
|
|
|
|
Test(ddsc_builtin_topics, read_publication_data, .init = setup, .fini = teardown)
|
|
{
|
|
dds_entity_t reader;
|
|
#if 0 /* disabled pending CHAM-347 */
|
|
dds_return_t ret;
|
|
DDS_PublicationBuiltinTopicData *data;
|
|
#endif
|
|
void *samples[MAX_SAMPLES];
|
|
|
|
|
|
reader = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSPUBLICATION, NULL, NULL);
|
|
cr_assert_gt(reader, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSPUBLICATION.");
|
|
|
|
samples[0] = DDS_PublicationBuiltinTopicData__alloc();
|
|
#if 0 /* disabled pending CHAM-347 */
|
|
ret = dds_read(reader, samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
|
|
cr_assert_gt(ret, 0, "Failed to read samples DCPSPublication");
|
|
|
|
data = (DDS_PublicationBuiltinTopicData *)samples;
|
|
cr_assert_str_eq(data->topic_name, "DCPSPublication");
|
|
#endif
|
|
|
|
DDS_PublicationBuiltinTopicData_free(samples[0], DDS_FREE_ALL);
|
|
}
|
|
|
|
Test(ddsc_builtin_topics, create_reader)
|
|
{
|
|
dds_entity_t participant;
|
|
dds_entity_t t1;
|
|
|
|
/* Create a participant */
|
|
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
|
|
cr_assert_gt(participant, 0, "dds_participant_create");
|
|
|
|
/*
|
|
* The topics are created by the middleware as soon as a participant
|
|
* is created.
|
|
*/
|
|
#define TEST_FIND(p, t) do { \
|
|
t1 = dds_find_topic(p, t); \
|
|
cr_expect_gt(t1, 0, "dds_find_topic(\"" t "\") returned a valid handle"); \
|
|
dds_delete(t1); \
|
|
} while(0);
|
|
|
|
/* A builtin-topic proxy is created 'on demand' and should not exist before a reader is created for it */
|
|
TEST_FIND(participant, "DCPSParticipant");
|
|
TEST_FIND(participant, "CMParticipant");
|
|
#undef TEST_FIND
|
|
|
|
/*
|
|
* TODO CHAM-347: Not all builtin topics are created at the start.
|
|
*/
|
|
#define TEST_NOTFOUND(p, t) do { \
|
|
t1 = dds_find_topic(p, t); \
|
|
cr_expect_lt(t1, 0, "dds_find_topic(\"" t "\") returned a valid handle"); \
|
|
} while(0);
|
|
|
|
/* A builtin-topic proxy is created 'on demand' and should not exist before a reader is created for it */
|
|
TEST_NOTFOUND(participant, "DCPSType");
|
|
TEST_NOTFOUND(participant, "DCPSTopic");
|
|
TEST_NOTFOUND(participant, "DCPSPublication");
|
|
TEST_NOTFOUND(participant, "CMPublisher");
|
|
TEST_NOTFOUND(participant, "DCPSSubscription");
|
|
TEST_NOTFOUND(participant, "CMSubscriber");
|
|
TEST_NOTFOUND(participant, "CMDataWriter");
|
|
TEST_NOTFOUND(participant, "CMDataReader");
|
|
#undef TEST_NOTFOUND
|
|
|
|
/* A reader is created by providing a special builtin-topic handle */
|
|
{
|
|
dds_entity_t readers[10];
|
|
dds_entity_t builtin_subscriber, s;
|
|
|
|
builtin_topic_handles[0] = DDS_BUILTIN_TOPIC_DCPSPARTICIPANT;
|
|
builtin_topic_handles[1] = DDS_BUILTIN_TOPIC_CMPARTICIPANT;
|
|
builtin_topic_handles[2] = DDS_BUILTIN_TOPIC_DCPSTYPE;
|
|
builtin_topic_handles[3] = DDS_BUILTIN_TOPIC_DCPSTOPIC;
|
|
builtin_topic_handles[4] = DDS_BUILTIN_TOPIC_DCPSPUBLICATION;
|
|
builtin_topic_handles[5] = DDS_BUILTIN_TOPIC_CMPUBLISHER;
|
|
builtin_topic_handles[6] = DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION;
|
|
builtin_topic_handles[7] = DDS_BUILTIN_TOPIC_CMSUBSCRIBER;
|
|
builtin_topic_handles[8] = DDS_BUILTIN_TOPIC_CMDATAWRITER;
|
|
builtin_topic_handles[9] = DDS_BUILTIN_TOPIC_CMDATAREADER;
|
|
|
|
|
|
for (int i = 0; i < 10; i++) {
|
|
readers[i] = dds_create_reader(participant, builtin_topic_handles[i], NULL, NULL);
|
|
cr_expect_gt(readers[i], 0, "Failed to created reader for builtin topic handle %d", builtin_topic_handles[i]);
|
|
|
|
if (i == 0) {
|
|
/* Check the parent of reader is a subscriber */
|
|
builtin_subscriber = dds_get_parent(readers[i]);
|
|
cr_assert_gt(builtin_subscriber, 0, "Failed to get parent of first builtin-reader (%s)", dds_err_str(builtin_subscriber));
|
|
cr_assert_eq(builtin_subscriber & DDS_ENTITY_KIND_MASK, DDS_KIND_SUBSCRIBER, "Parent is not a subscriber");
|
|
} else {
|
|
/* Check the parent of reader equals parent of first reader */
|
|
s = dds_get_parent(readers[i]);
|
|
cr_assert_gt(s, 0, "Failed to get parent of builtin-reader (%s)", dds_err_str(s));
|
|
cr_assert_eq(s, builtin_subscriber, "Parent subscriber of reader(%d) doesn't equal builtin-subscriber", i);
|
|
//dds_delete(s);
|
|
}
|
|
}
|
|
}
|
|
|
|
#define TEST_FOUND(p, t) do { \
|
|
t1 = dds_find_topic(p, t); \
|
|
cr_expect_gt(t1, 0, "dds_find_topic(\"" t "\") returned an invalid handle (%s)", dds_err_str(t1)); \
|
|
if (t1 > 0) { \
|
|
dds_delete(t1); \
|
|
} \
|
|
} while(0);
|
|
|
|
/* Builtin-topics proxies should now be created */
|
|
TEST_FOUND(participant, "DCPSParticipant");
|
|
TEST_FOUND(participant, "CMParticipant");
|
|
TEST_FOUND(participant, "DCPSType");
|
|
TEST_FOUND(participant, "DCPSTopic");
|
|
TEST_FOUND(participant, "DCPSPublication");
|
|
TEST_FOUND(participant, "CMPublisher");
|
|
TEST_FOUND(participant, "DCPSSubscription");
|
|
TEST_FOUND(participant, "CMSubscriber");
|
|
TEST_FOUND(participant, "CMDataWriter");
|
|
TEST_FOUND(participant, "CMDataReader");
|
|
#undef TEST_FOUND
|
|
|
|
dds_delete(participant);
|
|
}
|
|
|
|
Test(ddsc_builtin_topics, read_subscription_data, .init = setup, .fini = teardown)
|
|
{
|
|
dds_entity_t reader;
|
|
#if 0 /* not supported yet */
|
|
dds_return_t ret;
|
|
DDS_SubscriptionBuiltinTopicData *data;
|
|
#endif
|
|
void * samples[MAX_SAMPLES];
|
|
|
|
reader = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION, NULL, NULL);
|
|
cr_assert_gt(reader, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION.");
|
|
|
|
samples[0] = DDS_SubscriptionBuiltinTopicData__alloc();
|
|
|
|
#if 0 /* not supported yet */
|
|
ret = dds_read(reader, samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
|
|
cr_assert_gt(ret, 0, "Failed to read samples DCPSSubscription");
|
|
|
|
data = (DDS_SubscriptionBuiltinTopicData *)samples;
|
|
cr_assert_str_eq(data->topic_name, "DCPSSubscription");
|
|
#endif
|
|
|
|
DDS_SubscriptionBuiltinTopicData_free(samples[0], DDS_FREE_ALL);
|
|
}
|
|
|
|
Test(ddsc_builtin_topics, read_participant_data, .init = setup, .fini = teardown)
|
|
{
|
|
dds_entity_t reader;
|
|
dds_return_t ret;
|
|
void * samples[MAX_SAMPLES];
|
|
|
|
reader = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSPARTICIPANT, NULL, NULL);
|
|
cr_assert_gt(reader, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSPARTICIPANT.");
|
|
|
|
samples[0] = DDS_ParticipantBuiltinTopicData__alloc();
|
|
|
|
ret = dds_read(reader, samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
|
|
cr_assert_gt(ret, 0, "Failed to read samples DCPSParticipant");
|
|
|
|
{
|
|
DDS_ParticipantBuiltinTopicData *data = (DDS_ParticipantBuiltinTopicData*)samples[0];
|
|
cr_log_info("Participant.key: %x.%x.%x\n", data->key[0], data->key[1], data->key[2]);
|
|
cr_log_info("Participant.userdata: %s\n", data->user_data.value._buffer);
|
|
}
|
|
|
|
DDS_ParticipantBuiltinTopicData_free(samples[0], DDS_FREE_ALL);
|
|
}
|
|
|
|
Test(ddsc_builtin_topics, read_cmparticipant_data, .init = setup, .fini = teardown)
|
|
{
|
|
dds_entity_t reader;
|
|
dds_return_t ret;
|
|
void * samples[MAX_SAMPLES];
|
|
|
|
reader = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_CMPARTICIPANT, NULL, NULL);
|
|
cr_assert_gt(reader, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSPARTICIPANT.");
|
|
|
|
samples[0] = DDS_CMParticipantBuiltinTopicData__alloc();
|
|
|
|
ret = dds_read(reader, samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
|
|
cr_assert_gt(ret, 0, "Failed to read samples CMParticipant");
|
|
|
|
{
|
|
DDS_CMParticipantBuiltinTopicData *data = (DDS_CMParticipantBuiltinTopicData*)samples[0];
|
|
cr_log_info("CMParticipant.key: %x.%x.%x\n", data->key[0], data->key[1], data->key[2]);
|
|
cr_log_info("CMParticipant.product: %s\n", data->product.value);
|
|
}
|
|
|
|
DDS_CMParticipantBuiltinTopicData_free(samples[0], DDS_FREE_ALL);
|
|
}
|
|
|
|
Test(ddsc_builtin_topics, read_topic_data, .init = setup, .fini = teardown)
|
|
{
|
|
dds_entity_t reader;
|
|
#if 0 /* disabled pending CHAM-347 */
|
|
dds_return_t ret;
|
|
DDS_TopicBuiltinTopicData *data;
|
|
#endif
|
|
void * samples[MAX_SAMPLES];
|
|
|
|
|
|
reader = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSTOPIC, NULL, NULL);
|
|
cr_assert_gt(reader, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSTOPIC.");
|
|
|
|
samples[0] = DDS_TopicBuiltinTopicData__alloc();
|
|
#if 0 /* disabled pending CHAM-347 */
|
|
ret = dds_read(reader, samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
|
|
cr_assert_gt(ret, 0, "Failed to read samples DCPSTopic");
|
|
|
|
data = (DDS_TopicBuiltinTopicData *)samples;
|
|
cr_assert_str_eq(data->name, "DCPSSubscription");
|
|
#endif
|
|
DDS_ParticipantBuiltinTopicData_free(samples[0], DDS_FREE_ALL);
|
|
}
|
|
|
|
Test(ddsc_builtin_topics, read_type_data, .init = setup, .fini = teardown)
|
|
{
|
|
dds_entity_t reader;
|
|
#if 0 /* disabled pending CHAM-347 */
|
|
dds_return_t ret;
|
|
DDS_TypeBuiltinTopicData *data;
|
|
#endif
|
|
void * samples[MAX_SAMPLES];
|
|
|
|
reader = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSTYPE, NULL, NULL);
|
|
cr_assert_gt(reader, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSTYPE.");
|
|
|
|
samples[0] = DDS_TypeBuiltinTopicData__alloc();
|
|
#if 0 /* disabled pending CHAM-347 */
|
|
ret = dds_read(reader, samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
|
|
cr_assert_gt(ret, 0, "Failed to read samples DCPSType");
|
|
|
|
data = (DDS_TypeBuiltinTopicData *)samples;
|
|
cr_assert_str_eq(data->name, "DCPSType");
|
|
#endif
|
|
DDS_TypeBuiltinTopicData_free(samples[0], DDS_FREE_ALL);
|
|
}
|
|
|
|
Test(ddsc_builtin_topics, same_subscriber, .init = setup, .fini = teardown)
|
|
{
|
|
dds_entity_t subscription_rdr;
|
|
dds_entity_t subscription_subscriber;
|
|
|
|
dds_entity_t publication_rdr;
|
|
dds_entity_t publication_subscriber;
|
|
|
|
dds_entity_t participant_rdr;
|
|
dds_entity_t participant_subscriber;
|
|
|
|
dds_entity_t topic_rdr;
|
|
dds_entity_t topic_subscriber;
|
|
|
|
dds_entity_t type_rdr;
|
|
dds_entity_t type_subscriber;
|
|
|
|
subscription_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION, NULL, NULL);
|
|
cr_assert_gt(subscription_rdr, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION.");
|
|
subscription_subscriber = dds_get_parent(subscription_rdr);
|
|
cr_assert_gt(subscription_subscriber, 0, "Could not find builtin subscriber for DSCPSSubscription-reader.");
|
|
|
|
publication_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSPUBLICATION, NULL, NULL);
|
|
cr_assert_gt(publication_rdr, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSPUBLICATION.");
|
|
publication_subscriber = dds_get_parent(publication_rdr);
|
|
cr_assert_gt(publication_subscriber, 0, "Could not find builtin subscriber for DSCPSPublication-reader.");
|
|
|
|
cr_assert_eq(subscription_subscriber, publication_subscriber);
|
|
|
|
participant_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSPARTICIPANT, NULL, NULL);
|
|
cr_assert_gt(participant_rdr, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSPARTICIPANT.");
|
|
participant_subscriber = dds_get_parent(participant_rdr);
|
|
cr_assert_gt(participant_subscriber, 0, "Could not find builtin subscriber for DSCPSParticipant-reader.");
|
|
|
|
cr_assert_eq(publication_subscriber, participant_subscriber);
|
|
|
|
topic_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSTOPIC, NULL, NULL);
|
|
cr_assert_gt(topic_rdr, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSTOPIC.");
|
|
topic_subscriber = dds_get_parent(topic_rdr);
|
|
cr_assert_gt(topic_subscriber, 0, "Could not find builtin subscriber for DSCPSTopic-reader.");
|
|
|
|
cr_assert_eq(participant_subscriber, topic_subscriber);
|
|
|
|
type_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSTYPE, NULL, NULL);
|
|
cr_assert_gt(type_rdr, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSTYPE.");
|
|
type_subscriber = dds_get_parent(type_rdr);
|
|
cr_assert_gt(type_subscriber, 0, "Could not find builtin subscriber for DSCPSType-reader.");
|
|
|
|
cr_assert_eq(topic_subscriber, type_subscriber);
|
|
}
|
|
|
|
Test(ddsc_builtin_topics, builtin_qos, .init = setup, .fini = teardown)
|
|
{
|
|
dds_entity_t dds_sub_rdr;
|
|
dds_entity_t dds_sub_subscriber;
|
|
|
|
dds_sub_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION, NULL, NULL);
|
|
cr_assert_gt(dds_sub_rdr, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION.");
|
|
check_default_qos_of_builtin_entity(dds_sub_rdr);
|
|
|
|
dds_sub_subscriber = dds_get_parent(dds_sub_rdr);
|
|
cr_assert_gt(dds_sub_subscriber, 0, "Could not find builtin subscriber for DSCPSSubscription-reader.");
|
|
check_default_qos_of_builtin_entity(dds_sub_subscriber);
|
|
}
|
|
|
|
Test(ddsc_builtin_topics, datareader_qos, .init = setup, .fini = teardown)
|
|
{
|
|
dds_entity_t rdr;
|
|
dds_entity_t subscription_rdr;
|
|
void * subscription_samples[MAX_SAMPLES];
|
|
#if 0 /* disabled pending CHAM-347 */
|
|
dds_return_t ret;
|
|
DDS_SubscriptionBuiltinTopicData *subscription_data;
|
|
#endif
|
|
|
|
// Set some qos' which differ from the default
|
|
dds_qset_durability(g_qos, (dds_durability_kind_t)g_pol_durability.kind);
|
|
dds_qset_deadline(g_qos, from_ddsi_duration(g_pol_deadline.period));
|
|
dds_qset_latency_budget(g_qos, from_ddsi_duration(g_pol_latency_budget.duration));
|
|
dds_qset_liveliness(g_qos, (dds_liveliness_kind_t)g_pol_liveliness.kind, from_ddsi_duration(g_pol_liveliness.lease_duration));
|
|
dds_qset_reliability(g_qos, (dds_reliability_kind_t)g_pol_reliability.kind, from_ddsi_duration(g_pol_reliability.max_blocking_time));
|
|
dds_qset_ownership(g_qos, (dds_ownership_kind_t)g_pol_ownership.kind);
|
|
dds_qset_destination_order(g_qos, (dds_destination_order_kind_t)g_pol_destination_order.kind);
|
|
dds_qset_userdata(g_qos, g_pol_userdata.value._buffer, g_pol_userdata.value._length);
|
|
dds_qset_time_based_filter(g_qos, from_ddsi_duration(g_pol_time_based_filter.minimum_separation));
|
|
dds_qset_presentation(g_qos, g_pol_presentation.access_scope, g_pol_presentation.coherent_access, g_pol_presentation.ordered_access);
|
|
dds_qset_partition(g_qos, g_pol_partition.name._length, c_partitions);
|
|
dds_qset_topicdata(g_qos, g_pol_topicdata.value._buffer, g_pol_topicdata.value._length);
|
|
dds_qset_groupdata(g_qos, g_pol_groupdata.value._buffer, g_pol_groupdata.value._length);
|
|
|
|
rdr = dds_create_reader(g_subscriber, g_topic, g_qos, NULL);
|
|
|
|
subscription_samples[0] = DDS_SubscriptionBuiltinTopicData__alloc();
|
|
|
|
subscription_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION, NULL, NULL);
|
|
cr_assert_gt(subscription_rdr, 0, "Failed to retrieve built-in datareader for DCPSSubscription");
|
|
#if 0 /* disabled pending CHAM-347 */
|
|
ret = dds_read(subscription_rdr, subscription_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
|
|
cr_assert_gt(ret, 0, "Failed to read Subscription data");
|
|
|
|
// Check the QOS settings of the 'remote' qos'
|
|
subscription_data = (DDS_SubscriptionBuiltinTopicData *)subscription_samples[0];
|
|
|
|
cr_assert_str_eq(subscription_data->topic_name, "RoundTrip");
|
|
cr_assert_str_eq(subscription_data->type_name, "RoundTripModule::DataType");
|
|
cr_assert_eq(subscription_data->durability.kind, g_pol_durability.kind);
|
|
cr_assert_eq(subscription_data->deadline.period.sec, g_pol_deadline.period.sec);
|
|
cr_assert_eq(subscription_data->deadline.period.nanosec, g_pol_deadline.period.nanosec);
|
|
cr_assert_eq(subscription_data->latency_budget.duration.sec, g_pol_latency_budget.duration.sec);
|
|
cr_assert_eq(subscription_data->latency_budget.duration.nanosec, g_pol_latency_budget.duration.nanosec);
|
|
cr_assert_eq(subscription_data->liveliness.kind, g_pol_liveliness.kind);
|
|
cr_assert_eq(subscription_data->liveliness.lease_duration.sec, g_pol_liveliness.lease_duration.sec);
|
|
cr_assert_eq(subscription_data->liveliness.lease_duration.nanosec, g_pol_liveliness.lease_duration.nanosec);
|
|
cr_assert_eq(subscription_data->reliability.kind, g_pol_reliability.kind);
|
|
cr_assert_eq(subscription_data->reliability.max_blocking_time.sec, g_pol_reliability.max_blocking_time.sec);
|
|
cr_assert_eq(subscription_data->reliability.max_blocking_time.nanosec, g_pol_reliability.max_blocking_time.nanosec);
|
|
cr_assert_eq(subscription_data->ownership.kind, g_pol_ownership.kind);
|
|
cr_assert_eq(subscription_data->destination_order.kind, g_pol_destination_order.kind);
|
|
cr_assert_eq(subscription_data->user_data.value._buffer, g_pol_userdata.value._buffer);
|
|
cr_assert_eq(subscription_data->user_data.value._length, g_pol_userdata.value._length);
|
|
cr_assert_eq(subscription_data->time_based_filter.minimum_separation.sec, g_pol_time_based_filter.minimum_separation.sec);
|
|
cr_assert_eq(subscription_data->time_based_filter.minimum_separation.nanosec, g_pol_time_based_filter.minimum_separation.nanosec);
|
|
cr_assert_eq(subscription_data->presentation.access_scope, g_pol_presentation.access_scope);
|
|
cr_assert_eq(subscription_data->presentation.coherent_access, g_pol_presentation.coherent_access);
|
|
cr_assert_eq(subscription_data->presentation.ordered_access, g_pol_presentation.ordered_access);
|
|
|
|
cr_assert_eq(subscription_data->partition.name._length, g_pol_partition.name._length);
|
|
for (uint32_t i = 0; i < subscription_data->partition.name._length; ++i)
|
|
{
|
|
cr_assert_str_eq(subscription_data->partition.name._buffer[i], c_partitions[i]);
|
|
}
|
|
|
|
cr_assert_str_eq(subscription_data->topic_data.value._buffer, g_pol_topicdata.value._buffer);
|
|
cr_assert_eq(subscription_data->topic_data.value._length, g_pol_topicdata.value._length);
|
|
cr_assert_str_eq(subscription_data->group_data.value._buffer, g_pol_groupdata.value._buffer);
|
|
cr_assert_eq(subscription_data->group_data.value._length, g_pol_groupdata.value._length);
|
|
#endif
|
|
DDS_SubscriptionBuiltinTopicData_free(subscription_samples[0], DDS_FREE_ALL);
|
|
}
|
|
|
|
Test(ddsc_builtin_topics, datawriter_qos, .init = setup, .fini = teardown)
|
|
{
|
|
dds_entity_t wrtr;
|
|
dds_entity_t publication_rdr;
|
|
#if 0 /* disabled pending CHAM-347 */
|
|
dds_return_t ret;
|
|
DDS_PublicationBuiltinTopicData *publication_data;
|
|
#endif
|
|
void * publication_samples[MAX_SAMPLES];
|
|
|
|
|
|
dds_qset_durability(g_qos, g_pol_durability.kind);
|
|
dds_qset_deadline(g_qos, from_ddsi_duration(g_pol_deadline.period));
|
|
dds_qset_latency_budget(g_qos, from_ddsi_duration(g_pol_latency_budget.duration));
|
|
dds_qset_liveliness(g_qos, (dds_liveliness_kind_t)g_pol_liveliness.kind, from_ddsi_duration(g_pol_liveliness.lease_duration));
|
|
dds_qset_reliability(g_qos, (dds_reliability_kind_t)g_pol_reliability.kind, from_ddsi_duration(g_pol_reliability.max_blocking_time));
|
|
dds_qset_lifespan(g_qos, from_ddsi_duration(g_pol_lifespan.duration));
|
|
dds_qset_destination_order(g_qos, (dds_destination_order_kind_t)g_pol_destination_order.kind);
|
|
dds_qset_userdata(g_qos, g_pol_userdata.value._buffer, g_pol_userdata.value._length);
|
|
dds_qset_ownership(g_qos, (dds_ownership_kind_t)g_pol_ownership.kind);
|
|
dds_qset_ownership_strength(g_qos, g_pol_ownership_strength.value);
|
|
dds_qset_presentation(g_qos, g_pol_presentation.access_scope, g_pol_presentation.coherent_access, g_pol_presentation.ordered_access);
|
|
dds_qset_partition(g_qos, g_pol_partition.name._length, c_partitions);
|
|
dds_qset_topicdata(g_qos, g_pol_topicdata.value._buffer, g_pol_topicdata.value._length);
|
|
|
|
wrtr = dds_create_writer(g_publisher, g_topic, g_qos, NULL);
|
|
|
|
publication_samples[0] = DDS_PublicationBuiltinTopicData__alloc();
|
|
|
|
publication_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSPUBLICATION, NULL, NULL);
|
|
cr_assert_gt(publication_rdr, 0, "Failed to retrieve built-in datareader for DCPSPublication");
|
|
|
|
#if 0 /* disabled pending CHAM-347 */
|
|
ret = dds_read(publication_rdr, publication_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
|
|
cr_assert_gt(ret, 0, "Failed to read Publication data");
|
|
|
|
// Check the QOS settings of the 'remote' qos'
|
|
publication_data = (DDS_PublicationBuiltinTopicData *)publication_samples[0];
|
|
|
|
cr_assert_str_eq(publication_data->topic_name, "RoundTrip");
|
|
cr_assert_str_eq(publication_data->type_name, "RoundTripModule::DataType");
|
|
cr_assert_eq(publication_data->durability.kind, g_pol_durability.kind);
|
|
cr_assert_eq(publication_data->deadline.period.sec, g_pol_deadline.period.sec);
|
|
cr_assert_eq(publication_data->deadline.period.nanosec, g_pol_deadline.period.nanosec);
|
|
cr_assert_eq(publication_data->latency_budget.duration.sec, g_pol_latency_budget.duration.sec);
|
|
cr_assert_eq(publication_data->latency_budget.duration.nanosec, g_pol_latency_budget.duration.nanosec);
|
|
cr_assert_eq(publication_data->liveliness.kind, g_pol_liveliness.kind);
|
|
cr_assert_eq(publication_data->liveliness.lease_duration.sec, g_pol_liveliness.lease_duration.sec);
|
|
cr_assert_eq(publication_data->liveliness.lease_duration.nanosec, g_pol_liveliness.lease_duration.nanosec);
|
|
cr_assert_eq(publication_data->reliability.kind, g_pol_reliability.kind);
|
|
cr_assert_eq(publication_data->reliability.max_blocking_time.sec, g_pol_reliability.max_blocking_time.sec);
|
|
cr_assert_eq(publication_data->reliability.max_blocking_time.nanosec, g_pol_reliability.max_blocking_time.nanosec);
|
|
cr_assert_eq(publication_data->lifespan.duration.sec, g_pol_lifespan.duration.sec);
|
|
cr_assert_eq(publication_data->lifespan.duration.nanosec, g_pol_lifespan.duration.nanosec);
|
|
cr_assert_eq(publication_data->destination_order.kind, g_pol_destination_order.kind);
|
|
cr_assert_eq(publication_data->user_data.value._buffer, g_pol_userdata.value._buffer);
|
|
cr_assert_eq(publication_data->user_data.value._length, g_pol_userdata.value._length);
|
|
cr_assert_eq(publication_data->ownership.kind, g_pol_ownership.kind);
|
|
cr_assert_eq(publication_data->ownership_strength.value, g_pol_ownership_strength.value);
|
|
cr_assert_eq(publication_data->presentation.access_scope, g_pol_presentation.access_scope);
|
|
cr_assert_eq(publication_data->presentation.coherent_access, g_pol_presentation.coherent_access);
|
|
cr_assert_eq(publication_data->presentation.ordered_access, g_pol_presentation.ordered_access);
|
|
|
|
cr_assert_eq(publication_data->partition.name._length, g_pol_partition.name._length);
|
|
for (uint32_t i = 0; i < publication_data->partition.name._length; ++i)
|
|
{
|
|
cr_assert_str_eq(publication_data->partition.name._buffer[i], c_partitions[i]);
|
|
}
|
|
|
|
cr_assert_str_eq(publication_data->topic_data.value._buffer, g_pol_topicdata.value._buffer);
|
|
cr_assert_eq(publication_data->topic_data.value._length, g_pol_topicdata.value._length);
|
|
cr_assert_str_eq(publication_data->group_data.value._buffer, g_pol_groupdata.value._buffer);
|
|
cr_assert_eq(publication_data->group_data.value._length, g_pol_groupdata.value._length);
|
|
#endif
|
|
DDS_PublicationBuiltinTopicData_free(publication_samples[0], DDS_FREE_ALL);
|
|
}
|
|
|
|
Test(ddsc_builtin_topics, topic_qos, .init = setup, .fini = teardown)
|
|
{
|
|
dds_entity_t tpc;
|
|
dds_entity_t topic_rdr;
|
|
|
|
#if 0 /* disabled pending CHAM-347 */
|
|
dds_return_t ret;
|
|
DDS_TopicBuiltinTopicData *topic_data;
|
|
#endif
|
|
|
|
void * topic_samples[MAX_SAMPLES];
|
|
|
|
dds_qset_durability(g_qos, g_pol_durability.kind);
|
|
dds_qset_durability_service(g_qos,
|
|
from_ddsi_duration(g_pol_durability_service.service_cleanup_delay),
|
|
(dds_history_kind_t)g_pol_durability_service.history_kind,
|
|
g_pol_durability_service.history_depth,
|
|
g_pol_durability_service.max_samples,
|
|
g_pol_durability_service.max_instances,
|
|
g_pol_durability_service.max_samples_per_instance);
|
|
dds_qset_deadline(g_qos, from_ddsi_duration(g_pol_deadline.period));
|
|
dds_qset_latency_budget(g_qos, from_ddsi_duration(g_pol_latency_budget.duration));
|
|
dds_qset_liveliness(g_qos, (dds_liveliness_kind_t)g_pol_liveliness.kind, from_ddsi_duration(g_pol_liveliness.lease_duration));
|
|
dds_qset_reliability(g_qos, (dds_reliability_kind_t)g_pol_reliability.kind, from_ddsi_duration(g_pol_reliability.max_blocking_time));
|
|
dds_qset_transport_priority(g_qos, g_pol_transport_priority.value);
|
|
dds_qset_lifespan(g_qos, from_ddsi_duration(g_pol_lifespan.duration));
|
|
dds_qset_destination_order(g_qos, (dds_destination_order_kind_t)g_pol_destination_order.kind);
|
|
dds_qset_history(g_qos, (dds_history_kind_t)g_pol_history.kind, g_pol_history.depth);
|
|
dds_qset_resource_limits(g_qos, g_pol_resource_limits.max_samples, g_pol_resource_limits.max_instances,
|
|
g_pol_resource_limits.max_samples_per_instance);
|
|
dds_qset_ownership(g_qos, (dds_ownership_kind_t)g_pol_ownership.kind);
|
|
dds_qset_topicdata(g_qos, g_pol_topicdata.value._buffer, g_pol_topicdata.value._length);
|
|
|
|
|
|
tpc = dds_create_topic(g_participant, &Space_Type1_desc, "SpaceType1", g_qos, NULL);
|
|
|
|
topic_samples[0] = DDS_PublicationBuiltinTopicData__alloc();
|
|
|
|
topic_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSTOPIC, NULL, NULL);
|
|
cr_assert_gt(topic_rdr, 0, "Failed to retrieve built-in datareader for DCPSPublication");
|
|
#if 0 /* disabled pending CHAM-347 */
|
|
ret = dds_read(topic_rdr, topic_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
|
|
cr_assert_gt(ret, 0, "Failed to read Topic data");
|
|
|
|
topic_data = (DDS_TopicBuiltinTopicData *)topic_samples[0];
|
|
|
|
cr_assert_str_eq(topic_data->name, "SpaceType1");
|
|
cr_assert_str_eq(topic_data->type_name, "RoundTripModule::DataType");
|
|
cr_assert_eq(topic_data->durability.kind, g_pol_durability.kind);
|
|
cr_assert_eq(topic_data->durability_service.service_cleanup_delay.sec, g_pol_durability_service.service_cleanup_delay.sec);
|
|
cr_assert_eq(topic_data->durability_service.service_cleanup_delay.nanosec, g_pol_durability_service.service_cleanup_delay.nanosec);
|
|
cr_assert_eq(topic_data->durability_service.history_kind, g_pol_durability_service.history_kind);
|
|
cr_assert_eq(topic_data->durability_service.history_depth, g_pol_durability_service.history_depth);
|
|
cr_assert_eq(topic_data->durability_service.max_samples, g_pol_durability_service.max_samples);
|
|
cr_assert_eq(topic_data->durability_service.max_instances, g_pol_durability_service.max_instances);
|
|
cr_assert_eq(topic_data->durability_service.max_samples_per_instance, g_pol_durability_service.max_samples_per_instance);
|
|
cr_assert_eq(topic_data->deadline.period.sec, g_pol_deadline.period.sec);
|
|
cr_assert_eq(topic_data->deadline.period.nanosec, g_pol_deadline.period.nanosec);
|
|
cr_assert_eq(topic_data->latency_budget.duration.sec, g_pol_latency_budget.duration.sec);
|
|
cr_assert_eq(topic_data->latency_budget.duration.nanosec, g_pol_latency_budget.duration.nanosec);
|
|
cr_assert_eq(topic_data->liveliness.kind, g_pol_liveliness.kind);
|
|
cr_assert_eq(topic_data->liveliness.lease_duration.sec, g_pol_liveliness.lease_duration.sec);
|
|
cr_assert_eq(topic_data->liveliness.lease_duration.nanosec, g_pol_liveliness.lease_duration.nanosec);
|
|
cr_assert_eq(topic_data->reliability.kind, g_pol_reliability.kind);
|
|
cr_assert_eq(topic_data->reliability.max_blocking_time.sec, g_pol_reliability.max_blocking_time.sec);
|
|
cr_assert_eq(topic_data->reliability.max_blocking_time.nanosec, g_pol_reliability.max_blocking_time.nanosec);
|
|
cr_assert_eq(topic_data->transport_priority.value, g_pol_transport_priority.value);
|
|
cr_assert_eq(topic_data->lifespan.duration.sec, g_pol_lifespan.duration.sec);
|
|
cr_assert_eq(topic_data->lifespan.duration.nanosec, g_pol_lifespan.duration.nanosec);
|
|
cr_assert_eq(topic_data->destination_order.kind, g_pol_destination_order.kind);
|
|
cr_assert_eq(topic_data->history.kind, g_pol_history.kind);
|
|
cr_assert_eq(topic_data->history.depth, g_pol_history.depth);
|
|
cr_assert_eq(topic_data->resource_limits.max_samples, g_pol_resource_limits.max_samples);
|
|
cr_assert_eq(topic_data->resource_limits.max_instances, g_pol_resource_limits.max_instances);
|
|
cr_assert_eq(topic_data->resource_limits.max_samples_per_instance, g_pol_resource_limits.max_samples_per_instance);
|
|
cr_assert_eq(topic_data->ownership.kind, g_pol_ownership.kind);
|
|
cr_assert_str_eq(topic_data->topic_data.value._buffer, g_pol_topicdata.value._buffer);
|
|
cr_assert_eq(topic_data->topic_data.value._length, g_pol_topicdata.value._length);
|
|
#endif
|
|
DDS_TopicBuiltinTopicData_free(topic_samples[0], DDS_FREE_ALL);
|
|
}
|