niklas/cyclonedds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Replace Criterion by CUnit

Browse source 
Signed-off-by: Jeroen Koekkoek <jeroen@koekkoek.nl>
This commit is contained in:
Jeroen Koekkoek 2018-12-04 23:01:46 +01:00
parent 60752b3fd8
commit 74a48c5731
47 changed files with 4486 additions and 5388 deletions
Download patch file Download diff file Expand all files Collapse all files

61
src/core/ddsc/tests/CMakeLists.txt
View file

@ -9,29 +9,62 @@
#
# SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
#
include(Criterion)
include(CUnit)
idlc_generate(RoundTrip RoundTrip.idl)
idlc_generate(Space Space.idl)
idlc_generate(TypesArrayKey TypesArrayKey.idl)
add_criterion_executable(criterion_ddsc .)
target_include_directories(criterion_ddsc PRIVATE
set(ddsc_test_sources
"basic.c"
"builtin_topics.c"
"config.c"
"dispose.c"
"entity_api.c"
"entity_hierarchy.c"
"entity_status.c"
"err.c"
"file_id.c"
"instance_get_key.c"
"listener.c"
"participant.c"
"publisher.c"
"qos.c"
"querycondition.c"
"readcondition.c"
"reader.c"
"reader_iterator.c"
"read_instance.c"
"register.c"
"return_loan.c"
"subscriber.c"
"take_instance.c"
"time.c"
"topic.c"
"transientlocal.c"
"types.c"
"unregister.c"
"unsupported.c"
"waitset.c"
"write.c"
"writer.c")
add_cunit_executable(cunit_ddsc ${ddsc_test_sources})
target_include_directories(cunit_ddsc PRIVATE
"$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/src/include/>")
target_link_libraries(criterion_ddsc RoundTrip Space TypesArrayKey ddsc OSAPI)
target_link_libraries(cunit_ddsc RoundTrip Space TypesArrayKey ddsc OSAPI)
# Setup environment for config-tests
get_test_property(Criterion_ddsc_config_simple_udp ENVIRONMENT Criterion_ddsc_config_simple_udp_env)
set(Criterion_ddsc_config_simple_udp_file "${CMAKE_CURRENT_LIST_DIR}/config_simple_udp.xml")
set(Criterion_ddsc_config_simple_udp_uri "file://${Criterion_ddsc_config_simple_udp_file}")
set(Criterion_ddsc_config_simple_udp_max_participants "0")
set(Criterion_ddsc_config_simple_udp_env "${CMAKE_PROJECT_NAME_CAPS}_URI=${Criterion_ddsc_config_simple_udp_uri};MAX_PARTICIPANTS=${Criterion_ddsc_config_simple_udp_max_participants};${Criterion_ddsc_config_simple_udp_env}")
message(STATUS "ENV: ${Criterion_ddsc_config_simple_udp_env}")
get_test_property(CUnit_ddsc_config_simple_udp ENVIRONMENT CUnit_ddsc_config_simple_udp_env)
set(CUnit_ddsc_config_simple_udp_file "${CMAKE_CURRENT_LIST_DIR}/config_simple_udp.xml")
set(CUnit_ddsc_config_simple_udp_uri "file://${CUnit_ddsc_config_simple_udp_file}")
set(CUnit_ddsc_config_simple_udp_max_participants "0")
set(CUnit_ddsc_config_simple_udp_env "${CMAKE_PROJECT_NAME_CAPS}_URI=${CUnit_ddsc_config_simple_udp_uri};MAX_PARTICIPANTS=${CUnit_ddsc_config_simple_udp_max_participants};${CUnit_ddsc_config_simple_udp_env}")
set_tests_properties(
Criterion_ddsc_config_simple_udp
CUnit_ddsc_config_simple_udp
PROPERTIES
REQUIRED_FILES ${Criterion_ddsc_config_simple_udp_file}
ENVIRONMENT "${Criterion_ddsc_config_simple_udp_env}")
REQUIRED_FILES ${CUnit_ddsc_config_simple_udp_file}
ENVIRONMENT "${CUnit_ddsc_config_simple_udp_env}")
configure_file("config_env.h.in" "config_env.h")

19
src/core/ddsc/tests/basic.c
View file

@ -10,19 +10,16 @@
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include "ddsc/dds.h"
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
Test(ddsc_basic, test)
CU_Test(ddsc_basic, test)
{
dds_entity_t participant;
dds_return_t status;
dds_entity_t participant;
dds_return_t status;
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0);
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
CU_ASSERT_FATAL(participant > 0);
/* TODO: CHAM-108: Add some simple read/write test(s). */
status = dds_delete(participant);
cr_assert_eq(status, DDS_RETCODE_OK);
status = dds_delete(participant);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
}

388
src/core/ddsc/tests/builtin_topics.c Executable file → Normal file
View file

@ -14,8 +14,8 @@
#include "ddsc/dds.h"
#include "os/os.h"
#include "test-common.h"
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
static dds_entity_t g_participant = 0;
static dds_entity_t g_subscriber = 0;
@ -59,7 +59,7 @@ static void
qos_init(void)
{
g_qos = dds_create_qos();
cr_assert_not_null(g_qos);
CU_ASSERT_PTR_NOT_NULL_FATAL(g_qos);
g_pol_userdata.value._buffer = dds_alloc(strlen(c_userdata) + 1);
g_pol_userdata.value._length = (uint32_t)strlen(c_userdata) + 1;
@ -149,13 +149,13 @@ 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");
CU_ASSERT_FATAL(g_participant > 0);
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");
CU_ASSERT_FATAL(g_topic> 0);
g_subscriber = dds_create_subscriber(g_participant, NULL, NULL);
cr_assert_gt(g_subscriber, 0, "Failed to create prerequisite g_subscriber");
CU_ASSERT_FATAL(g_subscriber> 0);
g_publisher = dds_create_publisher(g_participant, NULL, NULL);
cr_assert_gt(g_publisher, 0, "Failed to create prerequisite g_publisher");
CU_ASSERT_FATAL(g_publisher> 0);
}
static void
@ -197,10 +197,10 @@ check_default_qos_of_builtin_entity(dds_entity_t entity)
uint32_t plen;
dds_qos_t *qos = dds_create_qos();
cr_assert_not_null(qos);
CU_ASSERT_PTR_NOT_NULL_FATAL(qos);
ret = dds_get_qos(entity, qos);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to get QOS of builtin entity");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
dds_qget_durability(qos, &durability_kind);
dds_qget_presentation(qos, &presentation_access_scope_kind, &g_pol_presentation.coherent_access, &g_pol_presentation.ordered_access);
@ -217,31 +217,31 @@ check_default_qos_of_builtin_entity(dds_entity_t entity)
// no getter for ENTITY_FACTORY
if ((entity & DDS_ENTITY_KIND_MASK) == DDS_KIND_SUBSCRIBER) {
cr_expect_eq(plen, 1);
CU_ASSERT_EQUAL(plen, 1);
if (plen > 0) {
cr_expect_str_eq(partitions[0], "__BUILT-IN PARTITION__");
CU_ASSERT_STRING_EQUAL(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);
CU_ASSERT_EQUAL(durability_kind, DDS_DURABILITY_TRANSIENT_LOCAL);
CU_ASSERT_EQUAL(presentation_access_scope_kind, DDS_PRESENTATION_TOPIC);
CU_ASSERT_EQUAL(g_pol_presentation.coherent_access, false);
CU_ASSERT_EQUAL(g_pol_presentation.ordered_access, false);
CU_ASSERT_EQUAL(deadline, DDS_INFINITY);
CU_ASSERT_EQUAL(ownership_kind, DDS_OWNERSHIP_SHARED);
CU_ASSERT_EQUAL(liveliness_kind, DDS_LIVELINESS_AUTOMATIC);
CU_ASSERT_EQUAL(minimum_separation, 0);
CU_ASSERT_EQUAL(reliability_kind, DDS_RELIABILITY_RELIABLE);
CU_ASSERT_EQUAL(max_blocking_time, DDS_MSECS(100));
CU_ASSERT_EQUAL(destination_order_kind, DDS_DESTINATIONORDER_BY_RECEPTION_TIMESTAMP);
CU_ASSERT_EQUAL(history_kind, DDS_HISTORY_KEEP_LAST);
CU_ASSERT_EQUAL(g_pol_history.depth, 1);
CU_ASSERT_EQUAL(g_pol_resource_limits.max_instances, DDS_LENGTH_UNLIMITED);
CU_ASSERT_EQUAL(g_pol_resource_limits.max_samples, DDS_LENGTH_UNLIMITED);
CU_ASSERT_EQUAL(g_pol_resource_limits.max_samples_per_instance, DDS_LENGTH_UNLIMITED);
CU_ASSERT_EQUAL(autopurge_nowriter_samples_delay, DDS_INFINITY);
CU_ASSERT_EQUAL(autopurge_disposed_samples_delay, DDS_INFINITY);
} else {
cr_assert_fail("Unsupported entity kind %s", entity_kind_str(entity));
CU_FAIL_FATAL("Unsupported entity kind");
}
if (plen > 0) {
for (uint32_t i = 0; i < plen; i++) {
@ -254,11 +254,11 @@ check_default_qos_of_builtin_entity(dds_entity_t entity)
static dds_entity_t builtin_topic_handles[10];
Test(ddsc_builtin_topics, types_allocation)
CU_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"); \
CU_ASSERT_PTR_NOT_NULL(data); \
DDS_##type##BuiltinTopicData_free(data, DDS_FREE_ALL); \
} while(0)
@ -275,28 +275,28 @@ Test(ddsc_builtin_topics, types_allocation)
#undef TEST_ALLOC
}
Test(ddsc_builtin_topics, availability_builtin_topics, .init = setup, .fini = teardown)
CU_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);
CU_ASSERT_FATAL(topic > 0);
dds_delete(topic);
topic = dds_find_topic(g_participant, "DCPSTopic");
cr_assert_lt(topic, 0);
CU_ASSERT_FATAL(topic < 0);
//TODO CHAM-347: dds_delete(topic);
topic = dds_find_topic(g_participant, "DCPSType");
cr_assert_lt(topic, 0);
CU_ASSERT_FATAL(topic < 0);
//TODO CHAM-347: dds_delete(topic);
topic = dds_find_topic(g_participant, "DCPSSubscription");
cr_assert_lt(topic, 0);
CU_ASSERT_FATAL(topic < 0);
//TODO CHAM-347: dds_delete(topic);
topic = dds_find_topic(g_participant, "DCSPPublication");
cr_assert_lt(topic, 0);
CU_ASSERT_FATAL(topic < 0);
//TODO CHAM-347: dds_delete(topic);
}
Test(ddsc_builtin_topics, read_publication_data, .init = setup, .fini = teardown)
CU_Test(ddsc_builtin_topics, read_publication_data, .init = setup, .fini = teardown)
{
dds_entity_t reader;
#if 0 /* disabled pending CHAM-347 */
@ -307,28 +307,28 @@ Test(ddsc_builtin_topics, read_publication_data, .init = setup, .fini = teardown
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.");
CU_ASSERT_FATAL(reader > 0);
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");
CU_ASSERT_FATAL(ret > 0);
data = (DDS_PublicationBuiltinTopicData *)samples;
cr_assert_str_eq(data->topic_name, "DCPSPublication");
CU_ASSERT_STRING_EQUAL_FATAL(data->topic_name, "DCPSPublication");
#endif
DDS_PublicationBuiltinTopicData_free(samples[0], DDS_FREE_ALL);
}
Test(ddsc_builtin_topics, create_reader)
CU_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");
CU_ASSERT_FATAL(participant > 0);
/*
* The topics are created by the middleware as soon as a participant
@ -336,7 +336,7 @@ Test(ddsc_builtin_topics, create_reader)
*/
#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"); \
CU_ASSERT(t1 > 0); \
dds_delete(t1); \
} while(0);
@ -350,7 +350,7 @@ Test(ddsc_builtin_topics, create_reader)
*/
#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"); \
CU_ASSERT(t1 < 0); \
} while(0);
/* A builtin-topic proxy is created 'on demand' and should not exist before a reader is created for it */
@ -383,18 +383,18 @@ Test(ddsc_builtin_topics, create_reader)
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]);
CU_ASSERT(readers[i]> 0);
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");
CU_ASSERT_FATAL(builtin_subscriber > 0);
CU_ASSERT_EQUAL_FATAL(builtin_subscriber & DDS_ENTITY_KIND_MASK, DDS_KIND_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);
CU_ASSERT_FATAL(s > 0);
CU_ASSERT_EQUAL_FATAL(s, builtin_subscriber);
//dds_delete(s);
}
}
@ -402,7 +402,7 @@ Test(ddsc_builtin_topics, create_reader)
#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)); \
CU_ASSERT(t1 > 0); \
if (t1 > 0) { \
dds_delete(t1); \
} \
@ -424,7 +424,7 @@ Test(ddsc_builtin_topics, create_reader)
dds_delete(participant);
}
Test(ddsc_builtin_topics, read_subscription_data, .init = setup, .fini = teardown)
CU_Test(ddsc_builtin_topics, read_subscription_data, .init = setup, .fini = teardown)
{
dds_entity_t reader;
#if 0 /* not supported yet */
@ -434,68 +434,66 @@ Test(ddsc_builtin_topics, read_subscription_data, .init = setup, .fini = teardow
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.");
CU_ASSERT_FATAL(reader> 0);
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");
CU_ASSERT_FATAL(ret> 0);
data = (DDS_SubscriptionBuiltinTopicData *)samples;
cr_assert_str_eq(data->topic_name, "DCPSSubscription");
CU_ASSERT_STRING_EQUAL_FATAL(data->topic_name, "DCPSSubscription");
#endif
DDS_SubscriptionBuiltinTopicData_free(samples[0], DDS_FREE_ALL);
}
Test(ddsc_builtin_topics, read_participant_data, .init = setup, .fini = teardown)
CU_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.");
CU_ASSERT_FATAL(reader > 0);
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");
CU_ASSERT_FATAL(ret > 0);
#if 0
{
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);
}
#endif
DDS_ParticipantBuiltinTopicData_free(samples[0], DDS_FREE_ALL);
}
Test(ddsc_builtin_topics, read_cmparticipant_data, .init = setup, .fini = teardown)
CU_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.");
CU_ASSERT_FATAL(reader > 0);
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");
CU_ASSERT_FATAL(ret > 0);
#if 0
{
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);
}
#endif
DDS_CMParticipantBuiltinTopicData_free(samples[0], DDS_FREE_ALL);
}
Test(ddsc_builtin_topics, read_topic_data, .init = setup, .fini = teardown)
CU_Test(ddsc_builtin_topics, read_topic_data, .init = setup, .fini = teardown)
{
dds_entity_t reader;
#if 0 /* disabled pending CHAM-347 */
@ -506,20 +504,20 @@ Test(ddsc_builtin_topics, read_topic_data, .init = setup, .fini = teardown)
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.");
CU_ASSERT_FATAL(reader > 0);
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");
CU_ASSERT_FATAL(ret> 0);
data = (DDS_TopicBuiltinTopicData *)samples;
cr_assert_str_eq(data->name, "DCPSSubscription");
CU_ASSERT_STRING_EQUAL_FATAL(data->name, "DCPSSubscription");
#endif
DDS_ParticipantBuiltinTopicData_free(samples[0], DDS_FREE_ALL);
}
Test(ddsc_builtin_topics, read_type_data, .init = setup, .fini = teardown)
CU_Test(ddsc_builtin_topics, read_type_data, .init = setup, .fini = teardown)
{
dds_entity_t reader;
#if 0 /* disabled pending CHAM-347 */
@ -529,20 +527,20 @@ Test(ddsc_builtin_topics, read_type_data, .init = setup, .fini = teardown)
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.");
CU_ASSERT_FATAL(reader > 0);
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");
CU_ASSERT_FATAL(ret > 0);
data = (DDS_TypeBuiltinTopicData *)samples;
cr_assert_str_eq(data->name, "DCPSType");
CU_ASSERT_STRING_EQUAL_FATAL(data->name, "DCPSType");
#endif
DDS_TypeBuiltinTopicData_free(samples[0], DDS_FREE_ALL);
}
Test(ddsc_builtin_topics, same_subscriber, .init = setup, .fini = teardown)
CU_Test(ddsc_builtin_topics, same_subscriber, .init = setup, .fini = teardown)
{
dds_entity_t subscription_rdr;
dds_entity_t subscription_subscriber;
@ -560,54 +558,54 @@ Test(ddsc_builtin_topics, same_subscriber, .init = setup, .fini = teardown)
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.");
CU_ASSERT_FATAL(subscription_rdr > 0);
subscription_subscriber = dds_get_parent(subscription_rdr);
cr_assert_gt(subscription_subscriber, 0, "Could not find builtin subscriber for DSCPSSubscription-reader.");
CU_ASSERT_FATAL(subscription_subscriber > 0);
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.");
CU_ASSERT_FATAL(publication_rdr > 0);
publication_subscriber = dds_get_parent(publication_rdr);
cr_assert_gt(publication_subscriber, 0, "Could not find builtin subscriber for DSCPSPublication-reader.");
CU_ASSERT_FATAL(publication_subscriber > 0);
cr_assert_eq(subscription_subscriber, publication_subscriber);
CU_ASSERT_EQUAL_FATAL(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.");
CU_ASSERT_FATAL(participant_rdr > 0);
participant_subscriber = dds_get_parent(participant_rdr);
cr_assert_gt(participant_subscriber, 0, "Could not find builtin subscriber for DSCPSParticipant-reader.");
CU_ASSERT_FATAL(participant_subscriber > 0);
cr_assert_eq(publication_subscriber, participant_subscriber);
CU_ASSERT_EQUAL_FATAL(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.");
CU_ASSERT_FATAL(topic_rdr > 0);
topic_subscriber = dds_get_parent(topic_rdr);
cr_assert_gt(topic_subscriber, 0, "Could not find builtin subscriber for DSCPSTopic-reader.");
CU_ASSERT_FATAL(topic_subscriber > 0);
cr_assert_eq(participant_subscriber, topic_subscriber);
CU_ASSERT_EQUAL_FATAL(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.");
CU_ASSERT_FATAL(type_rdr > 0);
type_subscriber = dds_get_parent(type_rdr);
cr_assert_gt(type_subscriber, 0, "Could not find builtin subscriber for DSCPSType-reader.");
CU_ASSERT_FATAL(type_subscriber > 0);
cr_assert_eq(topic_subscriber, type_subscriber);
CU_ASSERT_EQUAL_FATAL(topic_subscriber, type_subscriber);
}
Test(ddsc_builtin_topics, builtin_qos, .init = setup, .fini = teardown)
CU_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.");
CU_ASSERT_FATAL(dds_sub_rdr > 0);
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.");
CU_ASSERT_FATAL(dds_sub_subscriber > 0);
check_default_qos_of_builtin_entity(dds_sub_subscriber);
}
Test(ddsc_builtin_topics, datareader_qos, .init = setup, .fini = teardown)
CU_Test(ddsc_builtin_topics, datareader_qos, .init = setup, .fini = teardown)
{
dds_entity_t rdr;
dds_entity_t subscription_rdr;
@ -633,57 +631,57 @@ Test(ddsc_builtin_topics, datareader_qos, .init = setup, .fini = teardown)
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);
cr_assert_gt(rdr, 0, "Failed to create a data reader.");
CU_ASSERT_FATAL(rdr > 0);
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");
CU_ASSERT_FATAL(subscription_rdr > 0);
#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");
CU_ASSERT_FATAL(ret > 0);
// 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);
CU_ASSERT_STRING_EQUAL_FATAL(subscription_data->topic_name, "RoundTrip");
CU_ASSERT_STRING_EQUAL_FATAL(subscription_data->type_name, "RoundTripModule::DataType");
CU_ASSERT_EQUAL_FATAL(subscription_data->durability.kind, g_pol_durability.kind);
CU_ASSERT_EQUAL_FATAL(subscription_data->deadline.period.sec, g_pol_deadline.period.sec);
CU_ASSERT_EQUAL_FATAL(subscription_data->deadline.period.nanosec, g_pol_deadline.period.nanosec);
CU_ASSERT_EQUAL_FATAL(subscription_data->latency_budget.duration.sec, g_pol_latency_budget.duration.sec);
CU_ASSERT_EQUAL_FATAL(subscription_data->latency_budget.duration.nanosec, g_pol_latency_budget.duration.nanosec);
CU_ASSERT_EQUAL_FATAL(subscription_data->liveliness.kind, g_pol_liveliness.kind);
CU_ASSERT_EQUAL_FATAL(subscription_data->liveliness.lease_duration.sec, g_pol_liveliness.lease_duration.sec);
CU_ASSERT_EQUAL_FATAL(subscription_data->liveliness.lease_duration.nanosec, g_pol_liveliness.lease_duration.nanosec);
CU_ASSERT_EQUAL_FATAL(subscription_data->reliability.kind, g_pol_reliability.kind);
CU_ASSERT_EQUAL_FATAL(subscription_data->reliability.max_blocking_time.sec, g_pol_reliability.max_blocking_time.sec);
CU_ASSERT_EQUAL_FATAL(subscription_data->reliability.max_blocking_time.nanosec, g_pol_reliability.max_blocking_time.nanosec);
CU_ASSERT_EQUAL_FATAL(subscription_data->ownership.kind, g_pol_ownership.kind);
CU_ASSERT_EQUAL_FATAL(subscription_data->destination_order.kind, g_pol_destination_order.kind);
CU_ASSERT_EQUAL_FATAL(subscription_data->user_data.value._buffer, g_pol_userdata.value._buffer);
CU_ASSERT_EQUAL_FATAL(subscription_data->user_data.value._length, g_pol_userdata.value._length);
CU_ASSERT_EQUAL_FATAL(subscription_data->time_based_filter.minimum_separation.sec, g_pol_time_based_filter.minimum_separation.sec);
CU_ASSERT_EQUAL_FATAL(subscription_data->time_based_filter.minimum_separation.nanosec, g_pol_time_based_filter.minimum_separation.nanosec);
CU_ASSERT_EQUAL_FATAL(subscription_data->presentation.access_scope, g_pol_presentation.access_scope);
CU_ASSERT_EQUAL_FATAL(subscription_data->presentation.coherent_access, g_pol_presentation.coherent_access);
CU_ASSERT_EQUAL_FATAL(subscription_data->presentation.ordered_access, g_pol_presentation.ordered_access);
cr_assert_eq(subscription_data->partition.name._length, g_pol_partition.name._length);
CU_ASSERT_EQUAL_FATAL(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]);
CU_ASSERT_STRING_EQUAL_FATAL(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);
CU_ASSERT_STRING_EQUAL_FATAL(subscription_data->topic_data.value._buffer, g_pol_topicdata.value._buffer);
CU_ASSERT_EQUAL_FATAL(subscription_data->topic_data.value._length, g_pol_topicdata.value._length);
CU_ASSERT_STRING_EQUAL_FATAL(subscription_data->group_data.value._buffer, g_pol_groupdata.value._buffer);
CU_ASSERT_EQUAL_FATAL(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)
CU_Test(ddsc_builtin_topics, datawriter_qos, .init = setup, .fini = teardown)
{
dds_entity_t wrtr;
dds_entity_t publication_rdr;
@ -709,59 +707,59 @@ Test(ddsc_builtin_topics, datawriter_qos, .init = setup, .fini = teardown)
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);
cr_assert_gt(wrtr, 0, "Failed to create a data writer.");
CU_ASSERT_FATAL(wrtr > 0);
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");
CU_ASSERT_FATAL(publication_rdr > 0);
#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");
CU_ASSERT_FATAL(ret> 0);
// 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);
CU_ASSERT_STRING_EQUAL_FATAL(publication_data->topic_name, "RoundTrip");
CU_ASSERT_STRING_EQUAL_FATAL(publication_data->type_name, "RoundTripModule::DataType");
CU_ASSERT_EQUAL_FATAL(publication_data->durability.kind, g_pol_durability.kind);
CU_ASSERT_EQUAL_FATAL(publication_data->deadline.period.sec, g_pol_deadline.period.sec);
CU_ASSERT_EQUAL_FATAL(publication_data->deadline.period.nanosec, g_pol_deadline.period.nanosec);
CU_ASSERT_EQUAL_FATAL(publication_data->latency_budget.duration.sec, g_pol_latency_budget.duration.sec);
CU_ASSERT_EQUAL_FATAL(publication_data->latency_budget.duration.nanosec, g_pol_latency_budget.duration.nanosec);
CU_ASSERT_EQUAL_FATAL(publication_data->liveliness.kind, g_pol_liveliness.kind);
CU_ASSERT_EQUAL_FATAL(publication_data->liveliness.lease_duration.sec, g_pol_liveliness.lease_duration.sec);
CU_ASSERT_EQUAL_FATAL(publication_data->liveliness.lease_duration.nanosec, g_pol_liveliness.lease_duration.nanosec);
CU_ASSERT_EQUAL_FATAL(publication_data->reliability.kind, g_pol_reliability.kind);
CU_ASSERT_EQUAL_FATAL(publication_data->reliability.max_blocking_time.sec, g_pol_reliability.max_blocking_time.sec);
CU_ASSERT_EQUAL_FATAL(publication_data->reliability.max_blocking_time.nanosec, g_pol_reliability.max_blocking_time.nanosec);
CU_ASSERT_EQUAL_FATAL(publication_data->lifespan.duration.sec, g_pol_lifespan.duration.sec);
CU_ASSERT_EQUAL_FATAL(publication_data->lifespan.duration.nanosec, g_pol_lifespan.duration.nanosec);
CU_ASSERT_EQUAL_FATAL(publication_data->destination_order.kind, g_pol_destination_order.kind);
CU_ASSERT_EQUAL_FATAL(publication_data->user_data.value._buffer, g_pol_userdata.value._buffer);
CU_ASSERT_EQUAL_FATAL(publication_data->user_data.value._length, g_pol_userdata.value._length);
CU_ASSERT_EQUAL_FATAL(publication_data->ownership.kind, g_pol_ownership.kind);
CU_ASSERT_EQUAL_FATAL(publication_data->ownership_strength.value, g_pol_ownership_strength.value);
CU_ASSERT_EQUAL_FATAL(publication_data->presentation.access_scope, g_pol_presentation.access_scope);
CU_ASSERT_EQUAL_FATAL(publication_data->presentation.coherent_access, g_pol_presentation.coherent_access);
CU_ASSERT_EQUAL_FATAL(publication_data->presentation.ordered_access, g_pol_presentation.ordered_access);
cr_assert_eq(publication_data->partition.name._length, g_pol_partition.name._length);
CU_ASSERT_EQUAL_FATAL(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]);
CU_ASSERT_STRING_EQUAL_FATAL(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);
CU_ASSERT_STRING_EQUAL_FATAL(publication_data->topic_data.value._buffer, g_pol_topicdata.value._buffer);
CU_ASSERT_EQUAL_FATAL(publication_data->topic_data.value._length, g_pol_topicdata.value._length);
CU_ASSERT_STRING_EQUAL_FATAL(publication_data->group_data.value._buffer, g_pol_groupdata.value._buffer);
CU_ASSERT_EQUAL_FATAL(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)
CU_Test(ddsc_builtin_topics, topic_qos, .init = setup, .fini = teardown)
{
dds_entity_t tpc;
dds_entity_t topic_rdr;
@ -796,50 +794,50 @@ Test(ddsc_builtin_topics, topic_qos, .init = setup, .fini = teardown)
tpc = dds_create_topic(g_participant, &Space_Type1_desc, "SpaceType1", g_qos, NULL);
cr_assert_gt(tpc, 0, "Failed to create a topic.");
CU_ASSERT_FATAL(tpc > 0);
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");
CU_ASSERT_FATAL(topic_rdr > 0 );
#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");
CU_ASSERT_FATAL(ret > 0);
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);
CU_ASSERT_STRING_EQUAL_FATAL(topic_data->name, "SpaceType1");
CU_ASSERT_STRING_EQUAL_FATAL(topic_data->type_name, "RoundTripModule::DataType");
CU_ASSERT_EQUAL_FATAL(topic_data->durability.kind, g_pol_durability.kind);
CU_ASSERT_EQUAL_FATAL(topic_data->durability_service.service_cleanup_delay.sec, g_pol_durability_service.service_cleanup_delay.sec);
CU_ASSERT_EQUAL(topic_data->durability_service.service_cleanup_delay.nanosec, g_pol_durability_service.service_cleanup_delay.nanosec);
CU_ASSERT_EQUAL_FATAL(topic_data->durability_service.history_kind, g_pol_durability_service.history_kind);
CU_ASSERT_EQUAL_FATAL(topic_data->durability_service.history_depth, g_pol_durability_service.history_depth);
CU_ASSERT_EQUAL_FATAL(topic_data->durability_service.max_samples, g_pol_durability_service.max_samples);
CU_ASSERT_EQUAL_FATAL(topic_data->durability_service.max_instances, g_pol_durability_service.max_instances);
CU_ASSERT_EQUAL_FATAL(topic_data->durability_service.max_samples_per_instance, g_pol_durability_service.max_samples_per_instance);
CU_ASSERT_EQUAL_FATAL(topic_data->deadline.period.sec, g_pol_deadline.period.sec);
CU_ASSERT_EQUAL_FATAL(topic_data->deadline.period.nanosec, g_pol_deadline.period.nanosec);
CU_ASSERT_EQUAL_FATAL(topic_data->latency_budget.duration.sec, g_pol_latency_budget.duration.sec);
CU_ASSERT_EQUAL_FATAL(topic_data->latency_budget.duration.nanosec, g_pol_latency_budget.duration.nanosec);
CU_ASSERT_EQUAL_FATAL(topic_data->liveliness.kind, g_pol_liveliness.kind);
CU_ASSERT_EQUAL_FATAL(topic_data->liveliness.lease_duration.sec, g_pol_liveliness.lease_duration.sec);
CU_ASSERT_EQUAL_FATAL(topic_data->liveliness.lease_duration.nanosec, g_pol_liveliness.lease_duration.nanosec);
CU_ASSERT_EQUAL_FATAL(topic_data->reliability.kind, g_pol_reliability.kind);
CU_ASSERT_EQUAL_FATAL(topic_data->reliability.max_blocking_time.sec, g_pol_reliability.max_blocking_time.sec);
CU_ASSERT_EQUAL_FATAL(topic_data->reliability.max_blocking_time.nanosec, g_pol_reliability.max_blocking_time.nanosec);
CU_ASSERT_EQUAL_FATAL(topic_data->transport_priority.value, g_pol_transport_priority.value);
CU_ASSERT_EQUAL_FATAL(topic_data->lifespan.duration.sec, g_pol_lifespan.duration.sec);
CU_ASSERT_EQUAL_FATAL(topic_data->lifespan.duration.nanosec, g_pol_lifespan.duration.nanosec);
CU_ASSERT_EQUAL_FATAL(topic_data->destination_order.kind, g_pol_destination_order.kind);
CU_ASSERT_EQUAL_FATAL(topic_data->history.kind, g_pol_history.kind);
CU_ASSERT_EQUAL_FATAL(topic_data->history.depth, g_pol_history.depth);
CU_ASSERT_EQUAL_FATAL(topic_data->resource_limits.max_samples, g_pol_resource_limits.max_samples);
CU_ASSERT_EQUAL_FATAL(topic_data->resource_limits.max_instances, g_pol_resource_limits.max_instances);
CU_ASSERT_EQUAL_FATAL(topic_data->resource_limits.max_samples_per_instance, g_pol_resource_limits.max_samples_per_instance);
CU_ASSERT_EQUAL_FATAL(topic_data->ownership.kind, g_pol_ownership.kind);
CU_ASSERT_STRING_EQUAL_FATAL(topic_data->topic_data.value._buffer, g_pol_topicdata.value._buffer);
CU_ASSERT_EQUAL_FATAL(topic_data->topic_data.value._length, g_pol_topicdata.value._length);
#endif
DDS_TopicBuiltinTopicData_free(topic_samples[0], DDS_FREE_ALL);
}

18
src/core/ddsc/tests/config.c
View file

@ -10,8 +10,7 @@
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include "ddsc/dds.h"
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
#include "os/os.h"
#include "config_env.h"
#include "ddsc/ddsc_project.h"
@ -26,18 +25,18 @@ static void config__check_env(
_In_z_ const char * expected_value)
{
const char * env_uri = os_getenv(env_variable);
#if 0
const char * const env_not_set = "Environment variable '%s' isn't set. This needs to be set to '%s' for this test to run.";
const char * const env_not_as_expected = "Environment variable '%s' has an unexpected value: '%s' (expected: '%s')";
#endif
#ifdef FORCE_ENV
{
bool env_ok;
if ( env_uri == NULL ) {
cr_log_info(env_not_set, env_variable, expected_value);
env_ok = false;
} else if ( strncmp(env_uri, expected_value, strlen(expected_value)) != 0 ) {
cr_log_info(env_not_as_expected, env_variable, env_uri, expected_value);
env_ok = false;
} else {
env_ok = true;
@ -51,20 +50,19 @@ static void config__check_env(
(void) sprintf(envstr, "%s=%s", env_variable, expected_value);
r = os_putenv(envstr);
cr_assert_eq(r, os_resultSuccess, "Invoking os_putenv(\"%s\") failed", envstr);
cr_log_warn("Environment variable '%s' set to expected value '%s'", env_variable, expected_value);
CU_ASSERT_EQUAL_FATAL(r, os_resultSuccess);
os_free(envstr);
}
}
#else
cr_assert_not_null(env_uri, env_not_set, env_variable, expected_value);
cr_assert_str_eq(env_uri, expected_value, env_not_as_expected, env_variable, env_uri, expected_value);
CU_ASSERT_PTR_NOT_NULL_FATAL(env_uri);
CU_ASSERT_STRING_EQUAL_FATAL(env_uri, expected_value);
#endif /* FORCE_ENV */
}
Test(ddsc_config, simple_udp, .init = os_osInit, .fini = os_osExit) {
CU_Test(ddsc_config, simple_udp, .init = os_osInit, .fini = os_osExit) {
dds_entity_t participant;
@ -73,7 +71,7 @@ Test(ddsc_config, simple_udp, .init = os_osInit, .fini = os_osExit) {
participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "dds_create_participant");
CU_ASSERT_FATAL(participant> 0);
dds_delete(participant);
}

4
src/core/ddsc/tests/config_env.h.in
View file

@ -12,7 +12,7 @@
#ifndef CONFIG_ENV_H
#define CONFIG_ENV_H
#define CONFIG_ENV_SIMPLE_UDP "@Criterion_ddsc_config_simple_udp_uri@"
#define CONFIG_ENV_MAX_PARTICIPANTS "@Criterion_ddsc_config_simple_udp_max_participants@"
#define CONFIG_ENV_SIMPLE_UDP "@CUnit_ddsc_config_simple_udp_uri@"
#define CONFIG_ENV_MAX_PARTICIPANTS "@CUnit_ddsc_config_simple_udp_max_participants@"
#endif /* CONFIG_ENV_H */

614
src/core/ddsc/tests/dispose.c
View file

File diff suppressed because it is too large Load diff

183
src/core/ddsc/tests/entity_api.c
View file

@ -10,8 +10,7 @@
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include "ddsc/dds.h"
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
/* We are deliberately testing some bad arguments that SAL will complain about.
* So, silence SAL regarding these issues. */
@ -24,49 +23,49 @@
static dds_entity_t entity = -1;
#define cr_assert_status_eq(s1, s2, ...) cr_assert_eq(dds_err_nr(s1), s2, __VA_ARGS__)
#define cu_assert_status_eq(s1, s2) CU_ASSERT_FATAL(dds_err_nr(s1)== s2)
/* Fixture to create prerequisite entity */
void create_entity(void)
{
cr_assert_eq(entity, -1, "entity already created pre create_entity fixture");
CU_ASSERT_EQUAL_FATAL(entity, -1);
entity = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(entity, 0, "create_entity fixture failed");
CU_ASSERT_FATAL(entity > 0);
}
/* Fixture to delete prerequisite entity */
void delete_entity(void)
{
cr_assert_gt(entity, 0, "entity not created pre delete_entity fixture");
CU_ASSERT_FATAL(entity > 0);
dds_return_t ret = dds_delete(entity);
cr_assert_status_eq(ret, DDS_RETCODE_OK, "delete_entity fixture failed (ret: %d)", dds_err_nr(ret));
cu_assert_status_eq(ret, DDS_RETCODE_OK);
entity = -1;
}
Test(ddsc_entity, create, .fini = delete_entity)
CU_Test(ddsc_entity, create, .fini = delete_entity)
{
/* Use participant as entity in the tests. */
entity = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(entity, 0, "dds_create_participant");
CU_ASSERT_FATAL(entity > 0 );
}
Test(ddsc_entity, enable, .init = create_entity, .fini = delete_entity)
CU_Test(ddsc_entity, enable, .init = create_entity, .fini = delete_entity)
{
dds_return_t status;
/* Check enabling with bad parameters. */
status = dds_enable(0);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_enable (NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Check actual enabling. */
/* TODO: CHAM-96: Check enabling.
status = dds_enable(&entity);
cr_assert_status_eq(status, dds_err_nr(DDS_RETCODE_OK), "dds_enable (delayed enable)");
cu_assert_status_eq(status, dds_err_nr(DDS_RETCODE_OK), "dds_enable (delayed enable)");
*/
/* Check re-enabling (should be a noop). */
status = dds_enable(entity);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_enable (already enabled)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
}
void entity_qos_get_set(dds_entity_t e, const char* info)
@ -74,17 +73,19 @@ void entity_qos_get_set(dds_entity_t e, const char* info)
dds_return_t status;
dds_qos_t *qos = dds_create_qos();
(void)info;
/* Get QoS. */
status = dds_get_qos (e, qos);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_qos(e, qos) ret: %d, %s", dds_err_nr(status), info);
cu_assert_status_eq(status, DDS_RETCODE_OK);
status = dds_set_qos (e, qos); /* Doesn't change anything, so no need to forbid. But we return NOT_SUPPORTED anyway for now*/
cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_set_qos(entity, qos) %s", info);
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
dds_delete_qos(qos);
}
Test(ddsc_entity, qos, .init = create_entity, .fini = delete_entity)
CU_Test(ddsc_entity, qos, .init = create_entity, .fini = delete_entity)
{
dds_return_t status;
dds_qos_t *qos = dds_create_qos();
@ -94,19 +95,19 @@ Test(ddsc_entity, qos, .init = create_entity, .fini = delete_entity)
/* Check getting QoS with bad parameters. */
status = dds_get_qos (0, NULL);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_qos(NULL, NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_qos (entity, NULL);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_qos(entity, NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_qos (0, qos);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_qos(NULL, qos)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Check setting QoS with bad parameters. */
status = dds_set_qos (0, NULL);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_set_qos(NULL, NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_set_qos (entity, NULL);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_set_qos(entity, NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_set_qos (0, qos);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_set_qos(NULL, qos)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Check set/get with entity without initial qos. */
entity_qos_get_set(entity, "{without initial qos}");
@ -122,7 +123,7 @@ Test(ddsc_entity, qos, .init = create_entity, .fini = delete_entity)
dds_delete_qos(qos);
}
Test(ddsc_entity, listener, .init = create_entity, .fini = delete_entity)
CU_Test(ddsc_entity, listener, .init = create_entity, .fini = delete_entity)
{
dds_return_t status;
dds_listener_t *l1 = dds_create_listener(NULL);
@ -144,67 +145,67 @@ Test(ddsc_entity, listener, .init = create_entity, .fini = delete_entity)
/* Check getting Listener with bad parameters. */
status = dds_get_listener (0, NULL);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_listener(NULL, NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_listener (entity, NULL);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_listener(entity, NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_listener (0, l1);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_listener(NULL, listener)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Get Listener, which should be unset. */
status = dds_get_listener (entity, l1);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_listener(entity, listener)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
dds_lget_liveliness_changed (l1, (dds_on_liveliness_changed_fn*)&cb1);
cr_assert_eq(cb1, DDS_LUNSET, "Listener not initialized to NULL");
CU_ASSERT_EQUAL_FATAL(cb1, DDS_LUNSET);
dds_lget_requested_deadline_missed (l1, (dds_on_requested_deadline_missed_fn*)&cb1);
cr_assert_eq(cb1, DDS_LUNSET, "Listener not initialized to NULL");
CU_ASSERT_EQUAL_FATAL(cb1, DDS_LUNSET);
dds_lget_requested_incompatible_qos (l1, (dds_on_requested_incompatible_qos_fn*)&cb1);
cr_assert_eq(cb1, DDS_LUNSET, "Listener not initialized to NULL");
CU_ASSERT_EQUAL_FATAL(cb1, DDS_LUNSET);
dds_lget_publication_matched (l1, (dds_on_publication_matched_fn*)&cb1);
cr_assert_eq(cb1, DDS_LUNSET, "Listener not initialized to NULL");
CU_ASSERT_EQUAL_FATAL(cb1, DDS_LUNSET);
/* Check setting Listener with bad parameters. */
status = dds_set_listener (0, NULL);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_set_listener(NULL, NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_set_listener (0, l2);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_set_listener(NULL, listener)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Getting after setting should return set listener. */
status = dds_set_listener (entity, l2);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_set_listener(entity, listener)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
status = dds_get_listener (entity, l1);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_listener(entity, listener)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
dds_lget_liveliness_changed (l1, (dds_on_liveliness_changed_fn*)&cb1);
dds_lget_liveliness_changed (l2, (dds_on_liveliness_changed_fn*)&cb2);
cr_assert_eq(cb1, cb2, "Listeners are not equal");
CU_ASSERT_EQUAL_FATAL(cb1, cb2);
dds_lget_requested_deadline_missed (l1, (dds_on_requested_deadline_missed_fn*)&cb1);
dds_lget_requested_deadline_missed (l2, (dds_on_requested_deadline_missed_fn*)&cb2);
cr_assert_eq(cb1, cb2, "Listeners are not equal");
CU_ASSERT_EQUAL_FATAL(cb1, cb2);
dds_lget_requested_incompatible_qos (l1, (dds_on_requested_incompatible_qos_fn*)&cb1);
dds_lget_requested_incompatible_qos (l2, (dds_on_requested_incompatible_qos_fn*)&cb2);
cr_assert_eq(cb1, cb2, "Listeners are not equal");
CU_ASSERT_EQUAL_FATAL(cb1, cb2);
dds_lget_publication_matched (l1, (dds_on_publication_matched_fn*)&cb1);
dds_lget_publication_matched (l2, (dds_on_publication_matched_fn*)&cb2);
cr_assert_eq(cb1, cb2, "Listeners are not equal");
CU_ASSERT_EQUAL_FATAL(cb1, cb2);
/* Reset listener. */
status = dds_set_listener (entity, NULL);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_set_listener(entity, NULL)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
status = dds_get_listener (entity, l2);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_listener(entity, listener)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
dds_lget_liveliness_changed (l2, (dds_on_liveliness_changed_fn*)&cb2);
cr_assert_eq(cb2, DDS_LUNSET, "Listener not reset");
CU_ASSERT_EQUAL_FATAL(cb2, DDS_LUNSET);
dds_lget_requested_deadline_missed (l2, (dds_on_requested_deadline_missed_fn*)&cb2);
cr_assert_eq(cb2, DDS_LUNSET, "Listener not reset");
CU_ASSERT_EQUAL_FATAL(cb2, DDS_LUNSET);
dds_lget_requested_incompatible_qos (l2, (dds_on_requested_incompatible_qos_fn*)&cb2);
cr_assert_eq(cb2, DDS_LUNSET, "Listener not reset");
CU_ASSERT_EQUAL_FATAL(cb2, DDS_LUNSET);
dds_lget_publication_matched (l2, (dds_on_publication_matched_fn*)&cb2);
cr_assert_eq(cb2, DDS_LUNSET, "Listener not reset");
CU_ASSERT_EQUAL_FATAL(cb2, DDS_LUNSET);
dds_free(l2);
dds_free(l1);
}
Test(ddsc_entity, status, .init = create_entity, .fini = delete_entity)
CU_Test(ddsc_entity, status, .init = create_entity, .fini = delete_entity)
{
dds_return_t status1;
uint32_t s1 = 0;
@ -214,50 +215,50 @@ Test(ddsc_entity, status, .init = create_entity, .fini = delete_entity)
/* Check getting Status with bad parameters. */
status1 = dds_get_enabled_status (0, NULL);
cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_get_enabled_status(NULL, NULL)");
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
status1 = dds_get_enabled_status (entity, NULL);
cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_get_enabled_status(entity, NULL)");
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
status1 = dds_get_enabled_status (0, &s1);
cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_get_enabled_status(NULL, status)");
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
/* Get Status, which should be 0 for a participant. */
status1 = dds_get_enabled_status (entity, &s1);
cr_assert_status_eq(status1, DDS_RETCODE_OK, "dds_get_enabled_status(entity, status)");
cr_assert_eq(s1, 0, "Enabled status mask is not 0");
cu_assert_status_eq(status1, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(s1, 0);
/* Check setting Status with bad parameters. */
status1 = dds_set_enabled_status (0, 0);
cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_set_enabled_status(NULL, 0)");
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
/* I shouldn't be able to set statuses on a participant. */
status1 = dds_set_enabled_status (entity, 0);
cr_assert_status_eq(status1, DDS_RETCODE_OK, "dds_set_enabled_status(entity, 0) %d", dds_err_nr(status1));
cu_assert_status_eq(status1, DDS_RETCODE_OK);
status1 = dds_set_enabled_status (entity, DDS_DATA_AVAILABLE_STATUS);
cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_set_enabled_status(entity, status)");
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
/* Check getting Status changes with bad parameters. */
status1 = dds_get_status_changes (0, NULL);
cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_get_status_changes(NULL, NULL)");
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
status1 = dds_get_status_changes (entity, NULL);
cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_get_status_changes(entity, NULL)");
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
status1 = dds_get_status_changes (0, &s1);
cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_get_status_changes(NULL, status)");
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
status1 = dds_get_status_changes (entity, &s1);
cr_assert_status_eq(status1, DDS_RETCODE_OK, "dds_get_status_changes(entity, status)");
cu_assert_status_eq(status1, DDS_RETCODE_OK);
/* Status read and take shouldn't work either. */
status1 = dds_read_status (0, &s1, 0);
cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_read_status(NULL, status, 0)");
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
status1 = dds_read_status (entity, &s1, 0);
cr_assert_status_eq(status1, DDS_RETCODE_OK, "dds_read_status(entity, status, 0)");
cu_assert_status_eq(status1, DDS_RETCODE_OK);
status1 = dds_take_status (0, &s1, 0);
cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_take_status(NULL, status, 0)");
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
status1 = dds_take_status (entity, &s1, 0);
cr_assert_status_eq(status1, DDS_RETCODE_OK, "dds_take_status(entity, status, 0)");
cu_assert_status_eq(status1, DDS_RETCODE_OK);
}
Test(ddsc_entity, instance_handle, .init = create_entity, .fini = delete_entity)
CU_Test(ddsc_entity, instance_handle, .init = create_entity, .fini = delete_entity)
{
dds_return_t status;
dds_instance_handle_t hdl;
@ -267,19 +268,19 @@ Test(ddsc_entity, instance_handle, .init = create_entity, .fini = delete_entity)
/* Check getting Handle with bad parameters. */
status = dds_get_instance_handle (0, NULL);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_instancehandle_get(NULL, NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_instance_handle (entity, NULL);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_instancehandle_get(entity, NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_instance_handle (0, &hdl);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_instancehandle_get(NULL, handle)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Get Instance Handle, which should not be 0 for a participant. */
status = dds_get_instance_handle (entity, &hdl);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_instancehandle_get(entity, handle)");
cr_assert_neq(hdl, 0, "Entity instance handle is 0");
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_NOT_EQUAL_FATAL(hdl, 0);
}
Test(ddsc_entity, get_entities, .init = create_entity, .fini = delete_entity)
CU_Test(ddsc_entity, get_entities, .init = create_entity, .fini = delete_entity)
{
dds_return_t status;
dds_entity_t par;
@ -289,78 +290,78 @@ Test(ddsc_entity, get_entities, .init = create_entity, .fini = delete_entity)
/* Check getting Parent with bad parameters. */
par = dds_get_parent (0);
cr_assert_eq(dds_err_nr(par), DDS_RETCODE_BAD_PARAMETER, "Parent was returned (despite of bad parameter)");
CU_ASSERT_EQUAL_FATAL(dds_err_nr(par), DDS_RETCODE_BAD_PARAMETER);
/* Get Parent, a participant doesn't have a parent. */
par = dds_get_parent (entity);
cr_assert_eq(dds_err_nr(par), DDS_ENTITY_NIL, "Parent was returned (despite of it being a participant)");
CU_ASSERT_EQUAL_FATAL(dds_err_nr(par), DDS_ENTITY_NIL);
/* ---------- Get Participant ------------ */
/* Check getting Participant with bad parameters. */
par = dds_get_participant (0);
cr_assert_eq(dds_err_nr(par), DDS_RETCODE_BAD_PARAMETER, "Participant was returned (despite of bad parameter)");
CU_ASSERT_EQUAL_FATAL(dds_err_nr(par), DDS_RETCODE_BAD_PARAMETER);
/* Get Participant, a participants' participant is itself. */
par = dds_get_participant (entity);
cr_assert_eq(par, entity, "Returned participant was not expected");
CU_ASSERT_EQUAL_FATAL(par, entity);
/* ---------- Get Children ------------ */
/* Check getting Children with bad parameters. */
status = dds_get_children (0, &child, 1);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_children(NULL, child, 1)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_children (entity, NULL, 1);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_children(entity, NULL, 1)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_children (entity, &child, 0);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_children(entity, child, 0)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_children (0, NULL, 1);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_children(NULL, NULL, 1)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_children (0, &child, 0);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_children(NULL, child, 0)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Get Children, of which there are currently none. */
status = dds_get_children (entity, NULL, 0);
if (status > 0) {
cr_assert(false, "dds_get_children(entity, NULL, 0) un-expectantly found children");
CU_ASSERT_FATAL(false);
} else {
cr_assert_eq(status, 0, "dds_get_children(entity, NULL, 0) failed");
CU_ASSERT_EQUAL_FATAL(status, 0);
}
status = dds_get_children (entity, &child, 1);
if (status > 0) {
cr_assert(false, "dds_get_children(entity, child, 1) un-expectantly returned children");
CU_ASSERT_FATAL(false);
} else {
cr_assert_eq(status, 0, "dds_get_children(entity, child, 1) failed");
CU_ASSERT_EQUAL_FATAL(status, 0);
}
}
Test(ddsc_entity, get_domainid, .init = create_entity, .fini = delete_entity)
CU_Test(ddsc_entity, get_domainid, .init = create_entity, .fini = delete_entity)
{
dds_return_t status;
dds_domainid_t id;
/* Check getting ID with bad parameters. */
status = dds_get_domainid (0, NULL);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_domainid(NULL, NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_domainid (entity, NULL);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_domainid(entity, NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_domainid (0, &id);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_domainid(NULL, id)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Get and check the domain id. */
status = dds_get_domainid (entity, &id);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(entity, id)");
cr_assert_eq(id, 0, "Different domain_id was returned than expected");
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(id, 0);
}
Test(ddsc_entity, delete, .init = create_entity)
CU_Test(ddsc_entity, delete, .init = create_entity)
{
dds_return_t status;
status = dds_delete(0);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_delete(NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_delete(entity);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_delete(entity)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
entity = 0;
}

467
src/core/ddsc/tests/entity_hierarchy.c
View file

File diff suppressed because it is too large Load diff

767
src/core/ddsc/tests/entity_status.c
View file

File diff suppressed because it is too large Load diff

35
src/core/ddsc/tests/err.c
View file

@ -10,24 +10,23 @@
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include "ddsc/dds.h"
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
Test(ddsc_err, str)
CU_Test(ddsc_err, str)
{
cr_assert_str_eq(dds_err_str(1 ), "Success");
cr_assert_str_eq(dds_err_str(-255 ), "Unknown");
cr_assert_str_eq(dds_err_str(DDS_RETCODE_OK * -1), "Success");
cr_assert_str_eq(dds_err_str(DDS_RETCODE_ERROR * -1), "Error");
cr_assert_str_eq(dds_err_str(DDS_RETCODE_UNSUPPORTED * -1), "Unsupported");
cr_assert_str_eq(dds_err_str(DDS_RETCODE_BAD_PARAMETER * -1), "Bad Parameter");
cr_assert_str_eq(dds_err_str(DDS_RETCODE_PRECONDITION_NOT_MET * -1), "Precondition Not Met");
cr_assert_str_eq(dds_err_str(DDS_RETCODE_OUT_OF_RESOURCES * -1), "Out Of Resources");
cr_assert_str_eq(dds_err_str(DDS_RETCODE_NOT_ENABLED * -1), "Not Enabled");
cr_assert_str_eq(dds_err_str(DDS_RETCODE_IMMUTABLE_POLICY * -1), "Immutable Policy");
cr_assert_str_eq(dds_err_str(DDS_RETCODE_INCONSISTENT_POLICY * -1), "Inconsistent Policy");
cr_assert_str_eq(dds_err_str(DDS_RETCODE_ALREADY_DELETED * -1), "Already Deleted");
cr_assert_str_eq(dds_err_str(DDS_RETCODE_TIMEOUT * -1), "Timeout");
cr_assert_str_eq(dds_err_str(DDS_RETCODE_NO_DATA * -1), "No Data");
cr_assert_str_eq(dds_err_str(DDS_RETCODE_ILLEGAL_OPERATION * -1), "Illegal Operation");
CU_ASSERT_STRING_EQUAL(dds_err_str(1 ), "Success");
CU_ASSERT_STRING_EQUAL(dds_err_str(-255 ), "Unknown");
CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_OK * -1), "Success");
CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_ERROR * -1), "Error");
CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_UNSUPPORTED * -1), "Unsupported");
CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_BAD_PARAMETER * -1), "Bad Parameter");
CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_PRECONDITION_NOT_MET * -1), "Precondition Not Met");
CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_OUT_OF_RESOURCES * -1), "Out Of Resources");
CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_NOT_ENABLED * -1), "Not Enabled");
CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_IMMUTABLE_POLICY * -1), "Immutable Policy");
CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_INCONSISTENT_POLICY * -1), "Inconsistent Policy");
CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_ALREADY_DELETED * -1), "Already Deleted");
CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_TIMEOUT * -1), "Timeout");
CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_NO_DATA * -1), "No Data");
CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_ILLEGAL_OPERATION * -1), "Illegal Operation");
}

15
src/core/ddsc/tests/file_id.c
View file

@ -10,30 +10,27 @@
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include "ddsc/dds.h"
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
#include "os/os.h"
Test(ddsc_err, unique_file_id)
CU_Test(ddsc_err, unique_file_id)
{
dds_entity_t participant, reader, writer;
participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0);
CU_ASSERT_FATAL(participant > 0);
/* Disable SAL warning on intentional misuse of the API */
OS_WARNING_MSVC_OFF(28020);
reader = dds_create_reader(0, 0, NULL, NULL);
cr_assert_lt(reader, 0);
CU_ASSERT_FATAL(reader < 0);
writer = dds_create_writer(0, 0, NULL, NULL);
cr_assert_lt(writer, 0);
CU_ASSERT_FATAL(writer < 0);
OS_WARNING_MSVC_ON(28020);
cr_log_info("file_id for dds_create_reader: %d", dds_err_file_id(reader));
cr_log_info("file_id for dds_create_writer: %d", dds_err_file_id(writer));
cr_assert_neq(dds_err_file_id(reader), dds_err_file_id(writer));
CU_ASSERT_NOT_EQUAL_FATAL(dds_err_file_id(reader), dds_err_file_id(writer));
dds_delete(participant);
}

50
src/core/ddsc/tests/instance_get_key.c
View file

@ -1,8 +1,18 @@
/*
* 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 <assert.h>
#include <stdlib.h>
#include <string.h>
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
#include "os/os.h"
#include "ddsc/dds.h"
@ -21,19 +31,19 @@ static RoundTripModule_Address data;
static void setup(void)
{
participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0);
CU_ASSERT_FATAL(participant > 0);
topic = dds_create_topic(participant, &RoundTripModule_Address_desc, "ddsc_instance_get_key", NULL, NULL);
cr_assert_gt(topic, 0);
CU_ASSERT_FATAL(topic > 0);
publisher = dds_create_publisher(participant, NULL, NULL);
cr_assert_gt(publisher, 0);
CU_ASSERT_FATAL(publisher > 0);
writer = dds_create_writer(publisher, topic, NULL, NULL);
cr_assert_gt(writer, 0);
CU_ASSERT_FATAL(writer > 0);
memset(&data, 0, sizeof(data));
data.ip = os_strdup("some data");
cr_assert_not_null(data.ip);
CU_ASSERT_PTR_NOT_NULL_FATAL(data.ip);
data.port = 1;
}
@ -48,48 +58,48 @@ static void teardown(void)
dds_delete(participant);
}
Test(ddsc_instance_get_key, bad_entity, .init=setup, .fini=teardown)
CU_Test(ddsc_instance_get_key, bad_entity, .init=setup, .fini=teardown)
{
dds_return_t ret;
ret = dds_instance_get_key(participant, handle, &data);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
}
Test(ddsc_instance_get_key, null_data, .init=setup, .fini=teardown)
CU_Test(ddsc_instance_get_key, null_data, .init=setup, .fini=teardown)
{
dds_return_t ret;
ret = dds_register_instance(writer, &handle, NULL);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "Argument data is NULL");
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
}
Test(ddsc_instance_get_key, null_handle, .init=setup, .fini=teardown)
CU_Test(ddsc_instance_get_key, null_handle, .init=setup, .fini=teardown)
{
dds_return_t ret;
ret = dds_register_instance(writer, &handle, &data);
cr_assert_eq(ret, DDS_RETCODE_OK, "dds_register_instance succeeded (ret: %d)", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_instance_get_key(writer, DDS_HANDLE_NIL, &data);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "Argument data is not null, but handle is null");
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
}
Test(ddsc_instance_get_key, registered_instance, .init=setup, .fini=teardown)
CU_Test(ddsc_instance_get_key, registered_instance, .init=setup, .fini=teardown)
{
dds_return_t ret;
RoundTripModule_Address key_data;
ret = dds_register_instance(writer, &handle, &data);
cr_assert_eq(ret, DDS_RETCODE_OK, "dds_register_instance succeeded (ret: %d)", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
memset(&key_data, 0, sizeof(key_data));
ret = dds_instance_get_key(writer, handle, &key_data);
cr_assert_not_null(key_data.ip);
cr_assert_eq(strcmp(key_data.ip, data.ip) , 0);
cr_assert_eq(key_data.port, data.port);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_PTR_NOT_NULL_FATAL(key_data.ip);
CU_ASSERT_STRING_EQUAL_FATAL(key_data.ip, data.ip);
CU_ASSERT_EQUAL_FATAL(key_data.port, data.port);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
RoundTripModule_Address_free(&key_data, DDS_FREE_CONTENTS);
}

329
src/core/ddsc/tests/listener.c
View file

@ -12,8 +12,7 @@
#include "ddsc/dds.h"
#include "os/os.h"
#include "RoundTrip.h"
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
/****************************************************************************
* TODO: (CHAM-279) Add DDS_INCONSISTENT_TOPIC_STATUS test
@ -31,7 +30,7 @@
do { \
dds_on_##fntype##_fn cb; \
dds_lget_##fntype(listener, &cb); \
cr_expect_eq(cb, expected, "Callback 'on_" #fntype "' matched expected value '" #expected "'"); \
CU_ASSERT_EQUAL(cb, expected); \
} while (0)
#define STR(fntype) #fntype##_cb
@ -46,7 +45,7 @@
dds_lget_##fntype(NULL, NULL); \
dds_lget_##fntype(listener, NULL); \
dds_lget_##fntype(NULL, &dummy); \
cr_expect_eq(dummy, NULL, "lget 'on_" #fntype "' with NULL listener was not a noop"); \
CU_ASSERT_EQUAL_FATAL(dummy, NULL); \
/* Set to NULL, get to confirm it succeeds */ \
dds_lset_##fntype(listener, NULL); \
ASSERT_CALLBACK_EQUAL(fntype, listener, NULL); \
@ -330,22 +329,22 @@ init_triggering_base(void)
os_condInit(&g_cond, &g_mutex);
g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant");
CU_ASSERT_FATAL(g_participant > 0);
g_subscriber = dds_create_subscriber(g_participant, NULL, NULL);
cr_assert_gt(g_subscriber, 0, "Failed to create prerequisite g_subscriber");
CU_ASSERT_FATAL(g_subscriber > 0);
g_publisher = dds_create_publisher(g_participant, NULL, NULL);
cr_assert_gt(g_publisher, 0, "Failed to create prerequisite g_publisher");
CU_ASSERT_FATAL(g_publisher > 0);
g_topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, create_topic_name("ddsc_listener_test", name, 100), NULL, NULL);
cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic");
CU_ASSERT_FATAL(g_topic > 0);
g_listener = dds_create_listener(NULL);
cr_assert_not_null(g_listener, "Failed to create prerequisite g_listener");
CU_ASSERT_PTR_NOT_NULL_FATAL(g_listener);
g_qos = dds_create_qos();
cr_assert_not_null(g_qos, "Failed to create prerequisite g_qos");
CU_ASSERT_PTR_NOT_NULL_FATAL(g_qos);
dds_qset_reliability(g_qos, DDS_RELIABILITY_RELIABLE, DDS_SECS(1));
dds_qset_history(g_qos, DDS_HISTORY_KEEP_ALL, 0);
}
@ -370,15 +369,15 @@ init_triggering_test(void)
/* Create reader and writer with proper listeners. */
g_writer = dds_create_writer(g_publisher, g_topic, g_qos, g_listener);
cr_assert_gt(g_writer, 0, "Failed to create prerequisite writer");
CU_ASSERT(g_writer > 0);
g_reader = dds_create_reader(g_subscriber, g_topic, g_qos, g_listener);
cr_assert_gt(g_reader, 0, "Failed to create prerequisite reader");
CU_ASSERT(g_reader > 0);
/* Sync. */
triggered = waitfor_cb(DDS_PUBLICATION_MATCHED_STATUS | DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_LIVELINESS_CHANGED_STATUS);
cr_assert_eq(triggered & DDS_LIVELINESS_CHANGED_STATUS, DDS_LIVELINESS_CHANGED_STATUS);
cr_assert_eq(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS);
cr_assert_eq(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_LIVELINESS_CHANGED_STATUS, DDS_LIVELINESS_CHANGED_STATUS);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS);
}
static void
@ -401,17 +400,15 @@ fini_triggering_test(void)
}
#if 0
#else
/****************************************************************************
* API tests
****************************************************************************/
Test(ddsc_listener, create_and_delete)
CU_Test(ddsc_listener, create_and_delete)
{
/* Verify create doesn't return null */
dds_listener_t *listener;
listener = dds_create_listener(NULL);
cr_assert_not_null(listener);
CU_ASSERT_PTR_NOT_NULL_FATAL(listener);
/* Check default cb's are set */
ASSERT_CALLBACK_EQUAL(inconsistent_topic, listener, DDS_LUNSET);
@ -434,11 +431,11 @@ Test(ddsc_listener, create_and_delete)
OS_WARNING_MSVC_ON(6387);
}
Test(ddsc_listener, reset)
CU_Test(ddsc_listener, reset)
{
dds_listener_t *listener;
listener = dds_create_listener(NULL);
cr_assert_not_null(listener);
CU_ASSERT_PTR_NOT_NULL_FATAL(listener);
/* Set a listener cb to a non-default value */
dds_lset_data_available(listener, NULL);
@ -454,13 +451,13 @@ Test(ddsc_listener, reset)
dds_delete_listener(listener);
}
Test(ddsc_listener, copy)
CU_Test(ddsc_listener, copy)
{
dds_listener_t *listener1 = NULL, *listener2 = NULL;
listener1 = dds_create_listener(NULL);
listener2 = dds_create_listener(NULL);
cr_assert_not_null(listener1);
cr_assert_not_null(listener2);
CU_ASSERT_PTR_NOT_NULL_FATAL(listener1);
CU_ASSERT_PTR_NOT_NULL_FATAL(listener2);
/* Set some listener1 callbacks to non-default values */
dds_lset_data_available(listener1, NULL);
@ -488,13 +485,13 @@ Test(ddsc_listener, copy)
dds_delete_listener(listener2);
}
Test(ddsc_listener, merge)
CU_Test(ddsc_listener, merge)
{
dds_listener_t *listener1 = NULL, *listener2 = NULL;
listener1 = dds_create_listener(NULL);
listener2 = dds_create_listener(NULL);
cr_assert_not_null(listener1);
cr_assert_not_null(listener2);
CU_ASSERT_PTR_NOT_NULL_FATAL(listener1);
CU_ASSERT_PTR_NOT_NULL_FATAL(listener2);
/* Set all listener1 callbacks to non-default values */
dds_lset_inconsistent_topic (listener1, inconsistent_topic_cb);
@ -565,11 +562,11 @@ Test(ddsc_listener, merge)
dds_delete_listener(listener2);
}
Test(ddsc_listener, getters_setters)
CU_Test(ddsc_listener, getters_setters)
{
/* test all individual cb get/set methods */
dds_listener_t *listener = dds_create_listener(NULL);
cr_assert_not_null(listener);
CU_ASSERT_PTR_NOT_NULL_FATAL(listener);
OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ \
TEST_GET_SET(listener, inconsistent_topic, inconsistent_topic_cb);
@ -595,7 +592,7 @@ Test(ddsc_listener, getters_setters)
/****************************************************************************
* Triggering tests
****************************************************************************/
Test(ddsc_listener, propagation, .init=init_triggering_base, .fini=fini_triggering_base)
CU_Test(ddsc_listener, propagation, .init=init_triggering_base, .fini=fini_triggering_base)
{
dds_listener_t *listener_par = NULL;
dds_listener_t *listener_pub = NULL;
@ -607,57 +604,57 @@ Test(ddsc_listener, propagation, .init=init_triggering_base, .fini=fini_triggeri
/* Let participant be interested in data. */
listener_par = dds_create_listener(NULL);
cr_assert_not_null(listener_par, "Failed to create prerequisite listener_par");
CU_ASSERT_PTR_NOT_NULL_FATAL(listener_par);
dds_lset_data_on_readers(listener_par, data_on_readers_cb);
ret = dds_set_listener(g_participant, listener_par);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite listener_par");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
dds_delete_listener(listener_par);
/* Let publisher be interested in publication matched. */
listener_pub = dds_create_listener(NULL);
cr_assert_not_null(listener_pub, "Failed to create prerequisite listener_pub");
CU_ASSERT_PTR_NOT_NULL_FATAL(listener_pub);
dds_lset_publication_matched(listener_pub, publication_matched_cb);
ret = dds_set_listener(g_publisher, listener_pub);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite listener_pub");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
dds_delete_listener(listener_pub);
/* Let subscriber be interested in subscription matched. */
listener_sub = dds_create_listener(NULL);
cr_assert_not_null(listener_pub, "Failed to create prerequisite listener_sub");
CU_ASSERT_PTR_NOT_NULL_FATAL(listener_pub);
dds_lset_subscription_matched(listener_sub, subscription_matched_cb);
ret = dds_set_listener(g_subscriber, listener_sub);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite listener_sub");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
dds_delete_listener(listener_sub);
/* Create reader and writer without listeners. */
g_reader = dds_create_reader(g_subscriber, g_topic, g_qos, NULL);
cr_assert_gt(g_reader, 0, "Failed to create prerequisite reader");
CU_ASSERT_FATAL(g_reader > 0);
g_writer = dds_create_writer(g_publisher, g_topic, g_qos, NULL);
cr_assert_gt(g_writer, 0, "Failed to create prerequisite writer");
CU_ASSERT_FATAL(g_writer > 0);
/* Publication and Subscription should be matched. */
triggered = waitfor_cb(DDS_PUBLICATION_MATCHED_STATUS | DDS_SUBSCRIPTION_MATCHED_STATUS);
cr_assert_eq(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS, "DDS_SUBSCRIPTION_MATCHED_STATUS not triggered");
cr_assert_eq(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS, "DDS_PUBLICATION_MATCHED_STATUS not triggered");
cr_assert_eq(cb_writer, g_writer);
cr_assert_eq(cb_reader, g_reader);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS);
CU_ASSERT_EQUAL_FATAL(cb_writer, g_writer);
CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader);
/* Write sample. */
ret = dds_write(g_writer, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write prerequisite data");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Data on readers should be triggered with the right status. */
triggered = waitfor_cb(DDS_DATA_ON_READERS_STATUS);
cr_assert_eq(triggered & DDS_DATA_ON_READERS_STATUS, DDS_DATA_ON_READERS_STATUS, "DDS_DATA_ON_READERS_STATUS not triggered");
cr_assert_eq(cb_subscriber, g_subscriber);
cr_assert_neq(triggered & DDS_DATA_AVAILABLE_STATUS, DDS_DATA_AVAILABLE_STATUS, "DDS_DATA_AVAILABLE_STATUS triggered");
CU_ASSERT_EQUAL_FATAL(triggered & DDS_DATA_ON_READERS_STATUS, DDS_DATA_ON_READERS_STATUS);
CU_ASSERT_EQUAL_FATAL(cb_subscriber, g_subscriber);
CU_ASSERT_NOT_EQUAL_FATAL(triggered & DDS_DATA_AVAILABLE_STATUS, DDS_DATA_AVAILABLE_STATUS);
dds_delete(g_writer);
dds_delete(g_reader);
}
Test(ddsc_listener, matched, .init=init_triggering_base, .fini=fini_triggering_base)
CU_Test(ddsc_listener, matched, .init=init_triggering_base, .fini=fini_triggering_base)
{
uint32_t triggered;
@ -672,22 +669,22 @@ Test(ddsc_listener, matched, .init=init_triggering_base, .fini=fini_triggering_b
/* Create reader and writer with proper listeners.
* The creation order is deliberately different from publication_matched and subscription_matched. */
g_reader = dds_create_reader(g_participant, g_topic, g_qos, g_listener);
cr_assert_gt(g_reader, 0, "Failed to create prerequisite reader");
CU_ASSERT_FATAL(g_reader > 0);
g_writer = dds_create_writer(g_participant, g_topic, g_qos, g_listener);
cr_assert_gt(g_writer, 0, "Failed to create prerequisite writer");
CU_ASSERT_FATAL(g_writer > 0);
/* Both matched should be triggered on the right entities. */
triggered = waitfor_cb(DDS_PUBLICATION_MATCHED_STATUS | DDS_SUBSCRIPTION_MATCHED_STATUS);
cr_assert_eq(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS, "DDS_SUBSCRIPTION_MATCHED_STATUS not triggered");
cr_assert_eq(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS, "DDS_PUBLICATION_MATCHED_STATUS not triggered");
cr_assert_eq(cb_writer, g_writer);
cr_assert_eq(cb_reader, g_reader);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS);
CU_ASSERT_EQUAL_FATAL(cb_writer, g_writer);
CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader);
dds_delete(g_writer);
dds_delete(g_reader);
}
Test(ddsc_listener, publication_matched, .init=init_triggering_test, .fini=fini_triggering_test)
CU_Test(ddsc_listener, publication_matched, .init=init_triggering_test, .fini=fini_triggering_test)
{
dds_instance_handle_t reader_hdl;
dds_return_t ret;
@ -696,22 +693,22 @@ Test(ddsc_listener, publication_matched, .init=init_triggering_test, .fini=fini_
/* Get reader handle that should be part of the status. */
ret = dds_get_instance_handle(g_reader, &reader_hdl);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to get prerequisite reader_hdl");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Publication matched should be triggered with the right status. */
triggered = waitfor_cb(DDS_PUBLICATION_MATCHED_STATUS);
cr_assert_eq(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS, "DDS_PUBLICATION_MATCHED_STATUS not triggered");
cr_assert_eq(cb_writer, g_writer);
cr_assert_eq(cb_publication_matched_status.current_count, 1);
cr_assert_eq(cb_publication_matched_status.current_count_change, 1);
cr_assert_eq(cb_publication_matched_status.total_count, 1);
cr_assert_eq(cb_publication_matched_status.total_count_change, 1);
cr_assert_eq(cb_publication_matched_status.last_subscription_handle, reader_hdl);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS);
CU_ASSERT_EQUAL_FATAL(cb_writer, g_writer);
CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.current_count, 1);
CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.current_count_change, 1);
CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.total_count, 1);
CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.total_count_change, 1);
CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.last_subscription_handle, reader_hdl);
/* The listener should have swallowed the status. */
ret = dds_read_status(g_writer, &status, DDS_PUBLICATION_MATCHED_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed");
cr_assert_eq(status, 0);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, 0);
/* Reset the trigger flags. */
cb_called = 0;
@ -721,16 +718,16 @@ Test(ddsc_listener, publication_matched, .init=init_triggering_test, .fini=fini_
/* Publication matched should be triggered with the right status. */
triggered = waitfor_cb(DDS_PUBLICATION_MATCHED_STATUS);
cr_assert_eq(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS, "DDS_PUBLICATION_MATCHED_STATUS not triggered");
cr_assert_eq(cb_writer, g_writer);
cr_assert_eq(cb_publication_matched_status.current_count, 0);
cr_assert_eq(cb_publication_matched_status.current_count_change, -1);
cr_assert_eq(cb_publication_matched_status.total_count, 1);
cr_assert_eq(cb_publication_matched_status.total_count_change, 0);
cr_assert_eq(cb_publication_matched_status.last_subscription_handle, reader_hdl);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS);
CU_ASSERT_EQUAL_FATAL(cb_writer, g_writer);
CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.current_count, 0);
CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.current_count_change, -1);
CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.total_count, 1);
CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.total_count_change, 0);
CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.last_subscription_handle, reader_hdl);
}
Test(ddsc_listener, subscription_matched, .init=init_triggering_test, .fini=fini_triggering_test)
CU_Test(ddsc_listener, subscription_matched, .init=init_triggering_test, .fini=fini_triggering_test)
{
dds_instance_handle_t writer_hdl;
dds_return_t ret;
@ -739,22 +736,22 @@ Test(ddsc_listener, subscription_matched, .init=init_triggering_test, .fini=fini
/* Get writer handle that should be part of the status. */
ret = dds_get_instance_handle(g_writer, &writer_hdl);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to get prerequisite writer_hdl");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Subscription matched should be triggered with the right status. */
triggered = waitfor_cb(DDS_SUBSCRIPTION_MATCHED_STATUS);
cr_assert_eq(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS, "DDS_SUBSCRIPTION_MATCHED_STATUS not triggered");
cr_assert_eq(cb_reader, g_reader);
cr_assert_eq(cb_subscription_matched_status.current_count, 1);
cr_assert_eq(cb_subscription_matched_status.current_count_change, 1);
cr_assert_eq(cb_subscription_matched_status.total_count, 1);
cr_assert_eq(cb_subscription_matched_status.total_count_change, 1);
cr_assert_eq(cb_subscription_matched_status.last_publication_handle, writer_hdl);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS);
CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader);
CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.current_count, 1);
CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.current_count_change, 1);
CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.total_count, 1);
CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.total_count_change, 1);
CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.last_publication_handle, writer_hdl);
/* The listener should have swallowed the status. */
ret = dds_read_status(g_reader, &status, DDS_SUBSCRIPTION_MATCHED_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed");
cr_assert_eq(status, 0);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, 0);
/* Reset the trigger flags. */
cb_called = 0;
@ -764,16 +761,16 @@ Test(ddsc_listener, subscription_matched, .init=init_triggering_test, .fini=fini
/* Subscription matched should be triggered with the right status. */
triggered = waitfor_cb(DDS_SUBSCRIPTION_MATCHED_STATUS);
cr_assert_eq(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS, "DDS_SUBSCRIPTION_MATCHED_STATUS not triggered");
cr_assert_eq(cb_reader, g_reader);
cr_assert_eq(cb_subscription_matched_status.current_count, 0);
cr_assert_eq(cb_subscription_matched_status.current_count_change, -1);
cr_assert_eq(cb_subscription_matched_status.total_count, 1);
cr_assert_eq(cb_subscription_matched_status.total_count_change, 0);
cr_assert_eq(cb_subscription_matched_status.last_publication_handle, writer_hdl);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS);
CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader);
CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.current_count, 0);
CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.current_count_change, -1);
CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.total_count, 1);
CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.total_count_change, 0);
CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.last_publication_handle, writer_hdl);
}
Test(ddsc_listener, incompatible_qos, .init=init_triggering_base, .fini=fini_triggering_base)
CU_Test(ddsc_listener, incompatible_qos, .init=init_triggering_base, .fini=fini_triggering_base)
{
dds_return_t ret;
uint32_t triggered;
@ -786,37 +783,37 @@ Test(ddsc_listener, incompatible_qos, .init=init_triggering_base, .fini=fini_tri
/* Create reader and writer with proper listeners.
* But create reader with persistent durability to get incompatible qos. */
g_writer = dds_create_writer(g_participant, g_topic, g_qos, g_listener);
cr_assert_gt(g_writer, 0, "Failed to create prerequisite writer");
CU_ASSERT_FATAL(g_writer > 0);
dds_qset_durability (g_qos, DDS_DURABILITY_PERSISTENT);
g_reader = dds_create_reader(g_participant, g_topic, g_qos, g_listener);
cr_assert_gt(g_reader, 0, "Failed to create prerequisite reader");
CU_ASSERT_FATAL(g_reader > 0);
/* Incompatible QoS should be triggered with the right status. */
triggered = waitfor_cb(DDS_OFFERED_INCOMPATIBLE_QOS_STATUS | DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS);
cr_assert_eq(triggered & DDS_OFFERED_INCOMPATIBLE_QOS_STATUS, DDS_OFFERED_INCOMPATIBLE_QOS_STATUS, "DDS_OFFERED_INCOMPATIBLE_QOS_STATUS not triggered");
cr_assert_eq(triggered & DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS, DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS, "DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS not triggered");
cr_assert_eq(cb_reader, g_reader);
cr_assert_eq(cb_writer, g_writer);
cr_assert_eq(cb_offered_incompatible_qos_status.total_count, 1, "cb_offered_incompatible_qos_status.total_count(%d) != 1", cb_offered_incompatible_qos_status.total_count);
cr_assert_eq(cb_offered_incompatible_qos_status.total_count_change, 1);
cr_assert_eq(cb_offered_incompatible_qos_status.last_policy_id, DDS_DURABILITY_QOS_POLICY_ID);
cr_assert_eq(cb_requested_incompatible_qos_status.total_count, 1, "cb_requested_incompatible_qos_status.total_count(%d) != 1", cb_requested_incompatible_qos_status.total_count);
cr_assert_eq(cb_requested_incompatible_qos_status.total_count_change, 1);
cr_assert_eq(cb_requested_incompatible_qos_status.last_policy_id, DDS_DURABILITY_QOS_POLICY_ID);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_OFFERED_INCOMPATIBLE_QOS_STATUS, DDS_OFFERED_INCOMPATIBLE_QOS_STATUS);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS, DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS);
CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader);
CU_ASSERT_EQUAL_FATAL(cb_writer, g_writer);
CU_ASSERT_EQUAL_FATAL(cb_offered_incompatible_qos_status.total_count, 1);
CU_ASSERT_EQUAL_FATAL(cb_offered_incompatible_qos_status.total_count_change, 1);
CU_ASSERT_EQUAL_FATAL(cb_offered_incompatible_qos_status.last_policy_id, DDS_DURABILITY_QOS_POLICY_ID);
CU_ASSERT_EQUAL_FATAL(cb_requested_incompatible_qos_status.total_count, 1);
CU_ASSERT_EQUAL_FATAL(cb_requested_incompatible_qos_status.total_count_change, 1);
CU_ASSERT_EQUAL_FATAL(cb_requested_incompatible_qos_status.last_policy_id, DDS_DURABILITY_QOS_POLICY_ID);
/* The listener should have swallowed the status. */
ret = dds_read_status(g_writer, &status, DDS_OFFERED_INCOMPATIBLE_QOS_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed");
cr_assert_eq(status, 0);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, 0);
ret = dds_read_status(g_reader, &status, DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed");
cr_assert_eq(status, 0);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, 0);
dds_delete(g_writer);
dds_delete(g_reader);
}
Test(ddsc_listener, data_available, .init=init_triggering_test, .fini=fini_triggering_test)
CU_Test(ddsc_listener, data_available, .init=init_triggering_test, .fini=fini_triggering_test)
{
dds_return_t ret;
uint32_t triggered;
@ -827,27 +824,27 @@ Test(ddsc_listener, data_available, .init=init_triggering_test, .fini=fini_trigg
/* We are interested in data available notifications. */
dds_lset_data_available(g_listener, data_available_cb);
ret = dds_set_listener(g_reader, g_listener);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set listener");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Write sample. */
ret = dds_write(g_writer, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write prerequisite data");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Data available should be triggered with the right status. */
triggered = waitfor_cb(DDS_DATA_AVAILABLE_STATUS);
cr_assert_eq(triggered & DDS_DATA_AVAILABLE_STATUS, DDS_DATA_AVAILABLE_STATUS, "DDS_DATA_AVAILABLE_STATUS not triggered");
cr_assert_eq(cb_reader, g_reader);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_DATA_AVAILABLE_STATUS, DDS_DATA_AVAILABLE_STATUS);
CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader);
/* The listener should have swallowed the status. */
ret = dds_read_status(g_subscriber, &status, DDS_DATA_ON_READERS_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed");
cr_assert_eq(status, 0);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, 0);
ret = dds_read_status(g_reader, &status, DDS_DATA_AVAILABLE_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed");
cr_assert_eq(status, 0);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, 0);
}
Test(ddsc_listener, data_on_readers, .init=init_triggering_test, .fini=fini_triggering_test)
CU_Test(ddsc_listener, data_on_readers, .init=init_triggering_test, .fini=fini_triggering_test)
{
dds_return_t ret;
uint32_t triggered;
@ -858,34 +855,34 @@ Test(ddsc_listener, data_on_readers, .init=init_triggering_test, .fini=fini_trig
/* We are interested in data available notifications. */
dds_lset_data_on_readers(g_listener, data_on_readers_cb);
ret = dds_set_listener(g_subscriber, g_listener);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set listener");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Setting data available notifications should not 'sabotage' the on_readers call. */
dds_lset_data_available(g_listener, data_available_cb);
ret = dds_set_listener(g_reader, g_listener);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set listener");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Write sample. */
ret = dds_write(g_writer, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write prerequisite data");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Data on readers should be triggered with the right status. */
triggered = waitfor_cb(DDS_DATA_ON_READERS_STATUS);
cr_assert_eq(triggered & DDS_DATA_ON_READERS_STATUS, DDS_DATA_ON_READERS_STATUS, "DDS_DATA_ON_READERS_STATUS not triggered");
cr_assert_eq(cb_subscriber, g_subscriber);
cr_assert_neq(triggered & DDS_DATA_AVAILABLE_STATUS, DDS_DATA_AVAILABLE_STATUS, "DDS_DATA_AVAILABLE_STATUS triggered");
CU_ASSERT_EQUAL_FATAL(triggered & DDS_DATA_ON_READERS_STATUS, DDS_DATA_ON_READERS_STATUS);
CU_ASSERT_EQUAL_FATAL(cb_subscriber, g_subscriber);
CU_ASSERT_NOT_EQUAL_FATAL(triggered & DDS_DATA_AVAILABLE_STATUS, DDS_DATA_AVAILABLE_STATUS);
/* The listener should have swallowed the status. */
ret = dds_read_status(g_subscriber, &status, DDS_DATA_ON_READERS_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed");
cr_assert_eq(status, 0);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, 0);
ret = dds_read_status(g_reader, &status, DDS_DATA_AVAILABLE_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed");
cr_assert_eq(status, 0);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, 0);
}
Test(ddsc_listener, sample_lost, .init=init_triggering_test, .fini=fini_triggering_test)
CU_Test(ddsc_listener, sample_lost, .init=init_triggering_test, .fini=fini_triggering_test)
{
dds_return_t ret;
uint32_t triggered;
@ -900,30 +897,30 @@ Test(ddsc_listener, sample_lost, .init=init_triggering_test, .fini=fini_triggeri
/* We are interested in sample lost notifications. */
dds_lset_sample_lost(g_listener, sample_lost_cb);
ret = dds_set_listener(g_reader, g_listener);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set listener");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Write first sample with current timestamp. */
ret = dds_write_ts(g_writer, &sample, dds_time());
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write contemporary data");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Write second sample with older timestamp. */
ret = dds_write_ts(g_writer, &sample, the_past);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write pre-historic data");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Sample lost should be triggered with the right status. */
triggered = waitfor_cb(DDS_SAMPLE_LOST_STATUS);
cr_assert_eq(triggered & DDS_SAMPLE_LOST_STATUS, DDS_SAMPLE_LOST_STATUS, "DDS_SAMPLE_LOST_STATUS not triggered");
cr_assert_eq(cb_reader, g_reader);
cr_assert_eq(cb_sample_lost_status.total_count, 1);
cr_assert_eq(cb_sample_lost_status.total_count_change, 1);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_SAMPLE_LOST_STATUS, DDS_SAMPLE_LOST_STATUS);
CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader);
CU_ASSERT_EQUAL_FATAL(cb_sample_lost_status.total_count, 1);
CU_ASSERT_EQUAL_FATAL(cb_sample_lost_status.total_count_change, 1);
/* The listener should have swallowed the status. */
ret = dds_read_status(g_reader, &status, DDS_SAMPLE_LOST_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed");
cr_assert_eq(status, 0);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, 0);
}
Test(ddsc_listener, sample_rejected, .init=init_triggering_test, .fini=fini_triggering_test)
CU_Test(ddsc_listener, sample_rejected, .init=init_triggering_test, .fini=fini_triggering_test)
{
dds_return_t ret;
uint32_t triggered;
@ -934,30 +931,30 @@ Test(ddsc_listener, sample_rejected, .init=init_triggering_test, .fini=fini_trig
/* We are interested in sample rejected notifications. */
dds_lset_sample_rejected(g_listener, sample_rejected_cb);
ret = dds_set_listener(g_reader, g_listener);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set listener");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Write more than resource limits set by the reader. */
ret = dds_write(g_writer, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write data 1");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_write(g_writer, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write data 2");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_write(g_writer, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write data 3");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Sample lost should be triggered with the right status. */
triggered = waitfor_cb(DDS_SAMPLE_REJECTED_STATUS);
cr_assert_eq(triggered & DDS_SAMPLE_REJECTED_STATUS, DDS_SAMPLE_REJECTED_STATUS, "DDS_SAMPLE_REJECTED_STATUS not triggered");
cr_assert_eq(cb_reader, g_reader);
cr_assert_eq(cb_sample_rejected_status.total_count, 2);
cr_assert_eq(cb_sample_rejected_status.total_count_change, 1);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_SAMPLE_REJECTED_STATUS, DDS_SAMPLE_REJECTED_STATUS);
CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader);
CU_ASSERT_EQUAL_FATAL(cb_sample_rejected_status.total_count, 2);
CU_ASSERT_EQUAL_FATAL(cb_sample_rejected_status.total_count_change, 1);
/* The listener should have swallowed the status. */
ret = dds_read_status(g_reader, &status, DDS_SAMPLE_REJECTED_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed");
cr_assert_eq(status, 0);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, 0);
}
Test(ddsc_listener, liveliness_changed, .init=init_triggering_test, .fini=fini_triggering_base)
CU_Test(ddsc_listener, liveliness_changed, .init=init_triggering_test, .fini=fini_triggering_base)
{
dds_instance_handle_t writer_hdl;
dds_return_t ret;
@ -968,22 +965,22 @@ Test(ddsc_listener, liveliness_changed, .init=init_triggering_test, .fini=fini_t
/* Get writer handle that should be part of the status. */
ret = dds_get_instance_handle(g_writer, &writer_hdl);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to get prerequisite writer_hdl");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Liveliness changed should be triggered with the right status. */
triggered = waitfor_cb(DDS_LIVELINESS_CHANGED_STATUS);
cr_assert_eq(triggered & DDS_LIVELINESS_CHANGED_STATUS, DDS_LIVELINESS_CHANGED_STATUS, "DDS_LIVELINESS_CHANGED_STATUS not triggered");
cr_assert_eq(cb_reader, g_reader);
cr_assert_eq(cb_liveliness_changed_status.alive_count, 1);
cr_assert_eq(cb_liveliness_changed_status.alive_count_change, 1);
cr_assert_eq(cb_liveliness_changed_status.not_alive_count, 0);
cr_assert_eq(cb_liveliness_changed_status.not_alive_count_change, 0);
cr_assert_eq(cb_liveliness_changed_status.last_publication_handle, writer_hdl);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_LIVELINESS_CHANGED_STATUS, DDS_LIVELINESS_CHANGED_STATUS);
CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader);
CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.alive_count, 1);
CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.alive_count_change, 1);
CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.not_alive_count, 0);
CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.not_alive_count_change, 0);
CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.last_publication_handle, writer_hdl);
/* The listener should have swallowed the status. */
ret = dds_read_status(g_reader, &status, DDS_LIVELINESS_CHANGED_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed");
cr_assert_eq(status, 0);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, 0);
/* Reset the trigger flags. */
cb_called = 0;
@ -993,13 +990,13 @@ Test(ddsc_listener, liveliness_changed, .init=init_triggering_test, .fini=fini_t
/* Liveliness changed should be triggered with the right status. */
triggered = waitfor_cb(DDS_LIVELINESS_CHANGED_STATUS);
cr_assert_eq(triggered & DDS_LIVELINESS_CHANGED_STATUS, DDS_LIVELINESS_CHANGED_STATUS, "DDS_LIVELINESS_CHANGED_STATUS not triggered");
cr_assert_eq(cb_reader, g_reader);
cr_assert_eq(cb_liveliness_changed_status.alive_count, 0);
cr_assert_eq(cb_liveliness_changed_status.alive_count_change, 0);
cr_assert_eq(cb_liveliness_changed_status.not_alive_count, 1);
cr_assert_eq(cb_liveliness_changed_status.not_alive_count_change, 1);
cr_assert_eq(cb_liveliness_changed_status.last_publication_handle, writer_hdl);
CU_ASSERT_EQUAL_FATAL(triggered & DDS_LIVELINESS_CHANGED_STATUS, DDS_LIVELINESS_CHANGED_STATUS);
CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader);
CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.alive_count, 0);
CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.alive_count_change, 0);
CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.not_alive_count, 1);
CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.not_alive_count_change, 1);
CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.last_publication_handle, writer_hdl);
}
#if 0
@ -1059,4 +1056,4 @@ Test(ddsc_listener, inconsistent_topic, .init=init_triggering_base, .fini=fini_t
dds_delete_qos(g_qos);
}
#endif
#endif

193
src/core/ddsc/tests/participant.c
View file

@ -10,30 +10,30 @@
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include "ddsc/dds.h"
#include <criterion/criterion.h>
#include "CUnit/Test.h"
#include <os/os.h>
#include "config_env.h"
#include "ddsc/ddsc_project.h"
#define cr_assert_status_eq(s1, s2, ...) cr_assert_eq(dds_err_nr(s1), s2, __VA_ARGS__)
#define cu_assert_status_eq(s1, s2) CU_ASSERT_EQUAL_FATAL(dds_err_nr(s1), s2)
Test(ddsc_participant, create_and_delete) {
CU_Test(ddsc_participant, create_and_delete) {
dds_entity_t participant, participant2, participant3;
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant > 0);
participant2 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant2, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant2 > 0);
dds_delete (participant);
dds_delete (participant2);
participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant3, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant3 > 0);
dds_delete (participant3);
@ -41,32 +41,32 @@ Test(ddsc_participant, create_and_delete) {
/* Test for creating participant with no configuration file */
Test(ddsc_participant, create_with_no_conf_no_env) {
CU_Test(ddsc_participant, create_with_no_conf_no_env) {
dds_entity_t participant, participant2, participant3;
dds_return_t status;
dds_domainid_t domain_id;
dds_domainid_t valid_domain=3;
const char * env_uri = os_getenv(DDSC_PROJECT_NAME_NOSPACE_CAPS"_URI");
cr_assert_eq(env_uri, NULL, DDSC_PROJECT_NAME_NOSPACE_CAPS"_URI must be NULL");
CU_ASSERT_EQUAL_FATAL(env_uri, NULL);
//invalid domain
participant = dds_create_participant (-2, NULL, NULL);
cr_assert_lt(participant, 0, "Error must be received for invalid domain value");
CU_ASSERT_FATAL(participant < 0);
//valid specific domain value
participant2 = dds_create_participant (valid_domain, NULL, NULL);
cr_assert_gt(participant2, 0, "Valid participant must be received for valid specific domain value");
CU_ASSERT_FATAL(participant2 > 0);
status = dds_get_domainid(participant2, &domain_id);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)");
cr_assert_eq(domain_id, valid_domain, "Retrieved domain ID must be valid");
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain);
//DDS_DOMAIN_DEFAULT from user
participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant3, 0, "Valid participant must be received for DDS_DOMAIN_DEFAULT");
CU_ASSERT_FATAL(participant3 > 0);
status = dds_get_domainid(participant3, &domain_id);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)");
cr_assert_eq(domain_id, valid_domain, "Retrieved domain ID must be valid");
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain);
dds_delete(participant2);
dds_delete(participant3);
@ -78,50 +78,49 @@ Test(ddsc_participant, create_with_no_conf_no_env) {
////WITH CONF
/* Test for creating participant with valid configuration file */
Test(ddsc_participant, create_with_conf_no_env) {
dds_entity_t participant, participant2, participant3;
dds_return_t status;
dds_domainid_t domain_id;
dds_domainid_t valid_domain=3;
CU_Test(ddsc_participant, create_with_conf_no_env) {
dds_entity_t participant, participant2, participant3;
dds_return_t status;
dds_domainid_t domain_id;
dds_domainid_t valid_domain=3;
static char env_uri_str[1000];
(void) sprintf(env_uri_str, "%s=%s", DDSC_PROJECT_NAME_NOSPACE_CAPS"_URI", CONFIG_ENV_SIMPLE_UDP);
os_putenv(env_uri_str);
static char env_uri_str[1000];
(void) sprintf(env_uri_str, "%s=%s", DDSC_PROJECT_NAME_NOSPACE_CAPS"_URI", CONFIG_ENV_SIMPLE_UDP);
os_putenv(env_uri_str);
printf("env_uri_str %s\n", env_uri_str);
static char env_mp_str[100];
(void) sprintf(env_mp_str, "%s=%s", "MAX_PARTICIPANTS", CONFIG_ENV_MAX_PARTICIPANTS);
os_putenv(env_mp_str);
static char env_mp_str[100];
(void) sprintf(env_mp_str, "%s=%s", "MAX_PARTICIPANTS", CONFIG_ENV_MAX_PARTICIPANTS);
os_putenv(env_mp_str);
const char * env_uri = os_getenv(DDSC_PROJECT_NAME_NOSPACE_CAPS"_URI");
CU_ASSERT_NOT_EQUAL_FATAL(env_uri, NULL);
//invalid domain
participant = dds_create_participant (1, NULL, NULL);
printf("\n participant is %d\n", participant);
CU_ASSERT_FATAL(participant < 0);
//valid specific domain value
participant2 = dds_create_participant (valid_domain, NULL, NULL);
CU_ASSERT_FATAL(participant2 > 0);
status = dds_get_domainid(participant2, &domain_id);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain);
const char * env_uri = os_getenv(DDSC_PROJECT_NAME_NOSPACE_CAPS"_URI");
cr_assert_neq(env_uri, NULL, DDSC_PROJECT_NAME_NOSPACE_CAPS"_URI must be set");
//invalid domain
participant = dds_create_participant (1, NULL, NULL);
cr_assert_lt(participant, 0, "Error must be received for invalid domain value");
//valid specific domain value
participant2 = dds_create_participant (valid_domain, NULL, NULL);
cr_assert_gt(participant2, 0, "Valid participant must be received for valid specific domain value");
status = dds_get_domainid(participant2, &domain_id);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)");
cr_assert_eq(domain_id, valid_domain, "Retrieved domain ID must be valid");
//DDS_DOMAIN_DEFAULT from the user
participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant3, 0, "Valid participant must be received for DDS_DOMAIN_DEFAULT");
status = dds_get_domainid(participant3, &domain_id);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)");
cr_assert_eq(domain_id, valid_domain, "Retrieved domain ID must be valid");
dds_delete(participant2);
dds_delete(participant3);
//DDS_DOMAIN_DEFAULT from the user
participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
CU_ASSERT_FATAL(participant3 > 0);
status = dds_get_domainid(participant3, &domain_id);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain);
dds_delete(participant2);
dds_delete(participant3);
}
Test(ddsc_participant_lookup, one) {
CU_Test(ddsc_participant_lookup, one) {
dds_entity_t participant;
dds_entity_t participants[3];
@ -131,20 +130,20 @@ Test(ddsc_participant_lookup, one) {
/* Create a participant */
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant > 0);
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
num_of_found_pp = dds_lookup_participant( domain_id, participants, size);
cr_assert_eq(num_of_found_pp, 1, "dds_lookup_participant(domain_id, participants, size)");
cr_assert_eq(participants[0], participant,"dds_lookup_participant did not return the participant");
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 1);
CU_ASSERT_EQUAL_FATAL(participants[0], participant);
dds_delete (participant);
}
Test(ddsc_participant_lookup, multiple) {
CU_Test(ddsc_participant_lookup, multiple) {
dds_entity_t participant, participant2;
dds_entity_t participants[2];
@ -154,26 +153,26 @@ Test(ddsc_participant_lookup, multiple) {
/* Create participants */
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant > 0);
participant2 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant2, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant2 > 0);
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
num_of_found_pp = dds_lookup_participant( domain_id, participants, size);
cr_assert_eq(num_of_found_pp, 2, "dds_lookup_participant(domain_id, participants, size)");
cr_assert(participants[0] == participant || participants[0] == participant2,"ddsc_participant_lookup");
cr_assert(participants[1] == participant || participants[1] == participant2,"ddsc_participant_lookup");
cr_assert_neq(participants[0], participants[1], "dds_lookup_participant returned a participant twice");
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 2);
CU_ASSERT_FATAL(participants[0] == participant || participants[0] == participant2);
CU_ASSERT_FATAL(participants[1] == participant || participants[1] == participant2);
CU_ASSERT_NOT_EQUAL_FATAL(participants[0], participants[1]);
dds_delete (participant2);
dds_delete (participant);
}
Test(ddsc_participant_lookup, array_too_small) {
CU_Test(ddsc_participant_lookup, array_too_small) {
dds_entity_t participant, participant2, participant3;
dds_entity_t participants[2];
@ -183,30 +182,30 @@ Test(ddsc_participant_lookup, array_too_small) {
/* Create participants */
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant > 0);
participant2 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant2, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant2 > 0);
participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant3, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant3 > 0);
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
num_of_found_pp = dds_lookup_participant( domain_id, participants, size);
cr_assert_eq(num_of_found_pp, 3, "dds_lookup_participant(domain_id, participants, size)");
cr_assert(participants[0] == participant || participants[0] == participant2 || participants[0] == participant3,"ddsc_participant_lookup");
cr_assert(participants[1] == participant || participants[1] == participant2 || participants[1] == participant3,"ddsc_participant_lookup");
cr_assert_neq(participants[0], participants[1], "dds_lookup_participant returned a participant twice");
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 3);
CU_ASSERT_FATAL(participants[0] == participant || participants[0] == participant2 || participants[0] == participant3);
CU_ASSERT_FATAL(participants[1] == participant || participants[1] == participant2 || participants[1] == participant3);
CU_ASSERT_NOT_EQUAL_FATAL(participants[0], participants[1]);
dds_delete (participant3);
dds_delete (participant2);
dds_delete (participant);
}
Test(ddsc_participant_lookup, null_zero){
CU_Test(ddsc_participant_lookup, null_zero){
dds_entity_t participant;
dds_domainid_t domain_id;
@ -215,19 +214,19 @@ Test(ddsc_participant_lookup, null_zero){
/* Create a participant */
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant > 0);
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
num_of_found_pp = dds_lookup_participant( domain_id, NULL, size);
cr_assert_eq(num_of_found_pp, 1, "dds_lookup_participant(domain_id, participants, size)");
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 1);
dds_delete (participant);
}
Test(ddsc_participant_lookup, null_nonzero){
CU_Test(ddsc_participant_lookup, null_nonzero){
dds_entity_t participant;
dds_domainid_t domain_id;
@ -236,19 +235,19 @@ Test(ddsc_participant_lookup, null_nonzero){
/* Create a participant */
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant > 0);
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
num_of_found_pp = dds_lookup_participant( domain_id, NULL, size);
cr_assert_status_eq(num_of_found_pp, DDS_RETCODE_BAD_PARAMETER, "dds_lookup_participant did not return bad parameter");
cu_assert_status_eq(num_of_found_pp, DDS_RETCODE_BAD_PARAMETER);
dds_delete (participant);
}
Test(ddsc_participant_lookup, unknown_id) {
CU_Test(ddsc_participant_lookup, unknown_id) {
dds_entity_t participant;
dds_entity_t participants[3];
@ -258,30 +257,30 @@ Test(ddsc_participant_lookup, unknown_id) {
/* Create a participant */
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant > 0);
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
domain_id ++;
num_of_found_pp = dds_lookup_participant( domain_id, participants, size);
cr_assert_eq(num_of_found_pp, 0, "dds_lookup_participant(domain_id, participants, size)");
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 0);
dds_delete (participant);
}
Test(ddsc_participant_lookup, none) {
CU_Test(ddsc_participant_lookup, none) {
dds_entity_t participants[2];
dds_return_t num_of_found_pp;
size_t size = 2;
num_of_found_pp = dds_lookup_participant( 0, participants, size);
cr_assert_eq(num_of_found_pp, 0, "dds_lookup_participant did not return 0");
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 0);
}
Test(ddsc_participant_lookup, no_more) {
CU_Test(ddsc_participant_lookup, no_more) {
dds_entity_t participant;
dds_entity_t participants[3];
@ -291,19 +290,19 @@ Test(ddsc_participant_lookup, no_more) {
/* Create a participant */
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant > 0);
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
dds_delete (participant);
num_of_found_pp = dds_lookup_participant( domain_id, participants, size);
cr_assert_eq(num_of_found_pp, 0, "dds_lookup_participant did not return 0");
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 0);
}
Test(ddsc_participant_lookup, deleted) {
CU_Test(ddsc_participant_lookup, deleted) {
dds_entity_t participant, participant2;
dds_entity_t participants[2];
@ -313,20 +312,20 @@ Test(ddsc_participant_lookup, deleted) {
/* Create participants */
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant > 0);
participant2 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant2, 0, "dds_participant_create");
CU_ASSERT_FATAL(participant2 > 0);
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)");
cu_assert_status_eq(status, DDS_RETCODE_OK);
dds_delete (participant2);
num_of_found_pp = dds_lookup_participant( domain_id, participants, size);
cr_assert_eq(num_of_found_pp, 1, "dds_lookup_participant did not return one participant");
cr_assert(participants[0] == participant,"ddsc_participant_lookup");
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 1);
CU_ASSERT_FATAL(participants[0] == participant);
dds_delete (participant);
}

99
src/core/ddsc/tests/publisher.c
View file

@ -10,8 +10,7 @@
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include "ddsc/dds.h"
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
/* We are deliberately testing some bad arguments that SAL will complain about.
* So, silence SAL regarding these issues. */
@ -20,7 +19,7 @@
#pragma warning(disable: 28020)
#endif
#define cr_assert_status_eq(s1, s2, ...) cr_assert_eq(dds_err_nr(s1), s2, __VA_ARGS__)
#define cu_assert_status_eq(s1, s2) CU_ASSERT_EQUAL_FATAL(dds_err_nr(s1), s2)
/* Dummy callback */
static void data_available_cb(dds_entity_t reader, void* arg)
@ -30,7 +29,7 @@ static void data_available_cb(dds_entity_t reader, void* arg)
}
Test(ddsc_publisher, create)
CU_Test(ddsc_publisher, create)
{
const char *singlePartitions[] = { "partition" };
const char *multiplePartitions[] = { "partition1", "partition2" };
@ -43,27 +42,27 @@ Test(ddsc_publisher, create)
/* Use NULL participant */
publisher = dds_create_publisher(0, NULL, NULL);
cr_assert_eq(dds_err_nr(publisher), DDS_RETCODE_BAD_PARAMETER, "dds_create_publisher(NULL,NULL,NULL)");
CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher), DDS_RETCODE_BAD_PARAMETER);
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "dds_create_participant(DDS_DOMAIN_DEFAULT,NULL,NULL)");
CU_ASSERT_FATAL(participant > 0);
/* Use non-null participant */
publisher = dds_create_publisher(participant, NULL, NULL);
cr_assert_gt(publisher, 0, "dds_create_publisher(participant,NULL,NULL)");
CU_ASSERT_FATAL(publisher > 0);
/* Use entity that is not a participant */
publisher1 = dds_create_publisher(publisher, NULL, NULL);
cr_assert_eq(dds_err_nr(publisher1), DDS_RETCODE_ILLEGAL_OPERATION, "dds_create_publisher(publisher,NULL,NULL)");
CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher1), DDS_RETCODE_ILLEGAL_OPERATION);
dds_delete(publisher);
/* Create a non-null qos */
qos = dds_create_qos();
cr_assert_neq(qos, NULL, "dds_create_qos()");
CU_ASSERT_NOT_EQUAL_FATAL(qos, NULL);
/* Use qos without partition; in that case the default partition should be used */
publisher = dds_create_publisher(participant, qos, NULL);
cr_assert_gt(publisher, 0, "dds_create_publisher(participant,qos,NULL) where qos with default partition");
CU_ASSERT_FATAL(publisher > 0);
dds_delete(publisher);
/* Somehow, the compiler thinks the char arrays might not be zero-terminated... */
@ -75,19 +74,19 @@ Test(ddsc_publisher, create)
/* Use qos with single partition */
dds_qset_partition (qos, 1, singlePartitions);
publisher = dds_create_publisher(participant, qos, NULL);
cr_assert_gt(publisher, 0, "dds_create_publisher(participant,qos,NULL) where qos with single partition");
CU_ASSERT_FATAL(publisher > 0);
dds_delete(publisher);
/* Use qos with multiple partitions */
dds_qset_partition (qos, 2, multiplePartitions);
publisher = dds_create_publisher(participant, qos, NULL);
cr_assert_gt(publisher, 0, "dds_create_publisher(participant,qos,NULL) where qos with multiple partitions");
CU_ASSERT_FATAL(publisher > 0);
dds_delete(publisher);
/* Use qos with multiple partitions */
dds_qset_partition (qos, 2, duplicatePartitions);
publisher = dds_create_publisher(participant, qos, NULL);
cr_assert_gt(publisher, 0, "dds_create_publisher(participant,qos,NULL) where qos with duplicate partitions");
CU_ASSERT_FATAL(publisher > 0);
dds_delete(publisher);
#ifdef _MSC_VER
@ -96,9 +95,9 @@ Test(ddsc_publisher, create)
/* Use listener(NULL) */
listener = dds_create_listener(NULL);
cr_assert_neq(listener, NULL, "dds_create_listener(NULL)");
CU_ASSERT_NOT_EQUAL_FATAL(listener, NULL);
publisher = dds_create_publisher(participant, NULL, listener);
cr_assert_gt(publisher, 0, "dds_create_publisher(participant,NULL,listener(NULL))");
CU_ASSERT_FATAL(publisher > 0);
dds_delete(publisher);
dds_reset_listener(listener);
@ -106,7 +105,7 @@ Test(ddsc_publisher, create)
/* Use listener for data_available */
dds_lset_data_available(listener, NULL);
publisher = dds_create_publisher(participant, NULL, listener);
cr_assert_gt(publisher, 0, "dds_create_publisher(participant,NULL,listener) with dds_lset_data_available(listener, NULL)");
CU_ASSERT_FATAL(publisher > 0);
dds_delete(publisher);
dds_reset_listener(listener);
@ -114,7 +113,7 @@ Test(ddsc_publisher, create)
/* Use DDS_LUNSET for data_available */
dds_lset_data_available(listener, DDS_LUNSET);
publisher = dds_create_publisher(participant, NULL, listener);
cr_assert_gt(publisher, 0, "dds_create_publisher(participant,NULL,listener) with dds_lset_data_available(listener, DDS_LUNSET)");
CU_ASSERT_FATAL(publisher > 0);
dds_delete(publisher);
dds_reset_listener(listener);
@ -122,13 +121,13 @@ Test(ddsc_publisher, create)
/* Use callback for data_available */
dds_lset_data_available(listener, data_available_cb);
publisher = dds_create_publisher(participant, NULL, listener);
cr_assert_gt(publisher, 0, "dds_create_publisher(participant,NULL,listener) with dds_lset_data_available(listener, data_available_cb)");
CU_ASSERT_FATAL(publisher > 0);
dds_delete(publisher);
/* Use both qos setting and callback listener */
dds_lset_data_available(listener, data_available_cb);
publisher = dds_create_publisher(participant, qos, listener);
cr_assert_gt(publisher, 0, "dds_create_publisher(participant,qos,listener) with dds_lset_data_available(listener, data_available_cb)");
CU_ASSERT(publisher > 0);
dds_delete(publisher);
dds_delete_listener(listener);
@ -136,7 +135,7 @@ Test(ddsc_publisher, create)
dds_delete (participant);
}
Test(ddsc_publisher, suspend_resume)
CU_Test(ddsc_publisher, suspend_resume)
{
dds_entity_t participant, publisher;
@ -144,35 +143,35 @@ Test(ddsc_publisher, suspend_resume)
/* Suspend a 0 publisher */
status = dds_suspend(0);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_suspend(NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Resume a 0 publisher */
status = dds_resume(0);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_resume(NULL)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Uae dds_suspend on something else than a publisher */
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "dds_create_participant(DDS_DOMAIN_DEFAULT,NULL,NULL)");
CU_ASSERT_FATAL(participant > 0);
status = dds_suspend(participant);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_suspend(participant)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Use dds_resume on something else than a publisher */
status = dds_resume(participant);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_resume(participant)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Use dds_resume without calling dds_suspend */
publisher = dds_create_publisher(participant, NULL, NULL);
cr_assert_gt(publisher, 0, "dds_create_publisher(participant,NULL,NULL)");
CU_ASSERT_FATAL(publisher > 0);
status = dds_resume(publisher); /* Should be precondition not met? */
cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_resume(publisher) without prior suspend");
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
/* Use dds_suspend on non-null publisher */
status = dds_suspend(publisher);
cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_suspend(publisher)");
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
/* Use dds_resume on non-null publisher */
status = dds_resume(publisher);
cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_resume(publisher)");
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
dds_delete(publisher);
dds_delete(participant);
@ -180,7 +179,7 @@ Test(ddsc_publisher, suspend_resume)
return;
}
Test(ddsc_publisher, wait_for_acks)
CU_Test(ddsc_publisher, wait_for_acks)
{
dds_entity_t participant, publisher;
dds_return_t status;
@ -190,78 +189,78 @@ Test(ddsc_publisher, wait_for_acks)
/* Wait_for_acks on 0 publisher or writer and minusOneSec timeout */
status = dds_wait_for_acks(0, minusOneSec);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(NULL,-1)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Wait_for_acks on NULL publisher or writer and zeroSec timeout */
status = dds_wait_for_acks(0, zeroSec);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(NULL,0)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* wait_for_acks on NULL publisher or writer and oneSec timeout */
status = dds_wait_for_acks(0, oneSec);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(NULL,1)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* wait_for_acks on NULL publisher or writer and DDS_INFINITE timeout */
status = dds_wait_for_acks(0, DDS_INFINITY);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(NULL,DDS_INFINITY)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "dds_create_participant(DDS_DOMAIN_DEFAULT,NULL,NULL)");
CU_ASSERT_FATAL(participant > 0);
/* Wait_for_acks on participant and minusOneSec timeout */
status = dds_wait_for_acks(participant, minusOneSec);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(participant,-1)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Wait_for_acks on participant and zeroSec timeout */
status = dds_wait_for_acks(participant, zeroSec);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(participant,0)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Wait_for_acks on participant and oneSec timeout */
status = dds_wait_for_acks(participant, oneSec);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(participant,1)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
/* Wait_for_acks on participant and DDS_INFINITE timeout */
status = dds_wait_for_acks(participant, DDS_INFINITY);
cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(participant,DDS_INFINITY)");
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
publisher = dds_create_publisher(participant, NULL, NULL);
cr_assert_gt(publisher, 0, "dds_create_publisher(participant,NULL,NULL)");
CU_ASSERT_FATAL(publisher > 0);
/* Wait_for_acks on publisher and minusOneSec timeout */
status = dds_wait_for_acks(publisher, minusOneSec);
cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(publisher,-1)");
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
/* Wait_for_acks on publisher and zeroSec timeout */
status = dds_wait_for_acks(publisher, zeroSec);
cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(publisher,0)");
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
/* Wait_for_acks on publisher and oneSec timeout */
status = dds_wait_for_acks(publisher, oneSec);
cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(publisher,1)");
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
/* Wait_for_acks on publisher and DDS_INFINITE timeout */
status = dds_wait_for_acks(publisher, DDS_INFINITY);
cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(publisher,DDS_INFINITY)");
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
/* TODO: create tests by calling dds_qwait_for_acks on writers */
status = dds_suspend(publisher);
cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_suspend(publisher)");
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
/* Wait_for_acks on suspended publisher and minusOneSec timeout */
status = dds_wait_for_acks(publisher, minusOneSec);
cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(suspended_publisher,-1)");
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
/* Wait_for_acks on suspended publisher and zeroSec timeout */
status = dds_wait_for_acks(publisher, zeroSec);
cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(suspended_publisher,0)");
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
/* Wait_for_acks on suspended publisher and oneSec timeout */
status = dds_wait_for_acks(publisher, oneSec);
cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(suspended_publisher,1)");
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
/* Wait_for_acks on suspended publisher and DDS_INFINITE timeout */
status = dds_wait_for_acks(publisher, DDS_INFINITY);
cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(suspended_publisher,DDS_INFINITY)");
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
dds_delete(publisher);
dds_delete(participant);
@ -269,7 +268,7 @@ Test(ddsc_publisher, wait_for_acks)
return;
}
Test(ddsc_publisher, coherency)
CU_Test(ddsc_publisher, coherency)
{
return;
}

145
src/core/ddsc/tests/qos.c
View file

@ -9,10 +9,9 @@
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include "CUnit/Test.h"
#include "ddsc/dds.h"
#include "os/os.h"
#include <criterion/criterion.h>
#include <criterion/logging.h>
/* We are deliberately testing some bad arguments that SAL will complain about.
* So, silence SAL regarding these issues. */
@ -168,7 +167,7 @@ static void
qos_init(void)
{
g_qos = dds_create_qos();
cr_assert_not_null(g_qos);
CU_ASSERT_PTR_NOT_NULL_FATAL(g_qos);
g_pol_userdata.value = (void*)c_userdata;
g_pol_userdata.sz = strlen((char*)g_pol_userdata.value) + 1;
@ -239,46 +238,46 @@ qos_fini(void)
/****************************************************************************
* API tests
****************************************************************************/
Test(ddsc_qos, copy_bad_source, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, copy_bad_source, .init=qos_init, .fini=qos_fini)
{
dds_return_t result;
result = dds_copy_qos(g_qos, NULL);
cr_assert_eq(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(result));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER);
}
Test(ddsc_qos, copy_bad_destination, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, copy_bad_destination, .init=qos_init, .fini=qos_fini)
{
dds_return_t result;
result = dds_copy_qos(NULL, g_qos);
cr_assert_eq(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(result));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER);
}
Test(ddsc_qos, copy_with_partition, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, copy_with_partition, .init=qos_init, .fini=qos_fini)
{
dds_return_t result;
dds_qos_t *qos;
struct pol_partition p = { 0, NULL };
qos = dds_create_qos();
cr_assert_not_null(qos);
CU_ASSERT_PTR_NOT_NULL_FATAL(qos);
dds_qset_partition(g_qos, g_pol_partition.n, (const char **)g_pol_partition.ps);
result = dds_copy_qos(qos, g_qos);
cr_assert_eq(result, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(result, DDS_RETCODE_OK);
dds_qget_partition(qos, &p.n, &p.ps);
cr_assert_eq(p.n, g_pol_partition.n);
CU_ASSERT_EQUAL_FATAL(p.n, g_pol_partition.n);
for (uint32_t cnt = 0; cnt < p.n; cnt++) {
cr_assert_str_eq(p.ps[cnt], g_pol_partition.ps[cnt]);
CU_ASSERT_STRING_EQUAL_FATAL(p.ps[cnt], g_pol_partition.ps[cnt]);
}
dds_delete_qos(qos);
}
Test(ddsc_qos, userdata, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, userdata, .init=qos_init, .fini=qos_fini)
{
struct pol_userdata p = { NULL, 0 };
@ -290,13 +289,13 @@ Test(ddsc_qos, userdata, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_userdata(g_qos, g_pol_userdata.value, g_pol_userdata.sz);
dds_qget_userdata(g_qos, &p.value, &p.sz);
cr_assert_eq(p.sz, g_pol_userdata.sz);
cr_assert_str_eq(p.value, g_pol_userdata.value);
CU_ASSERT_EQUAL_FATAL(p.sz, g_pol_userdata.sz);
CU_ASSERT_STRING_EQUAL_FATAL(p.value, g_pol_userdata.value);
dds_free(p.value);
}
Test(ddsc_qos, topicdata, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, topicdata, .init=qos_init, .fini=qos_fini)
{
struct pol_topicdata p = { NULL, 0 };
@ -308,13 +307,13 @@ Test(ddsc_qos, topicdata, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_topicdata(g_qos, g_pol_topicdata.value, g_pol_topicdata.sz);
dds_qget_topicdata(g_qos, &p.value, &p.sz);
cr_assert_eq(p.sz, g_pol_topicdata.sz);
cr_assert_str_eq(p.value, g_pol_topicdata.value);
CU_ASSERT_EQUAL_FATAL(p.sz, g_pol_topicdata.sz);
CU_ASSERT_STRING_EQUAL_FATAL(p.value, g_pol_topicdata.value);
dds_free(p.value);
}
Test(ddsc_qos, groupdata, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, groupdata, .init=qos_init, .fini=qos_fini)
{
struct pol_groupdata p = { NULL, 0 };
@ -326,13 +325,13 @@ Test(ddsc_qos, groupdata, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_groupdata(g_qos, g_pol_groupdata.value, g_pol_groupdata.sz);
dds_qget_groupdata(g_qos, &p.value, &p.sz);
cr_assert_eq(p.sz, g_pol_groupdata.sz);
cr_assert_str_eq(p.value, g_pol_groupdata.value);
CU_ASSERT_EQUAL_FATAL(p.sz, g_pol_groupdata.sz);
CU_ASSERT_STRING_EQUAL_FATAL(p.value, g_pol_groupdata.value);
dds_free(p.value);
}
Test(ddsc_qos, durability, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, durability, .init=qos_init, .fini=qos_fini)
{
struct pol_durability p = { DDS_DURABILITY_VOLATILE };
@ -344,10 +343,10 @@ Test(ddsc_qos, durability, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_durability(g_qos, g_pol_durability.kind);
dds_qget_durability(g_qos, &p.kind);
cr_assert_eq(p.kind, g_pol_durability.kind);
CU_ASSERT_EQUAL_FATAL(p.kind, g_pol_durability.kind);
}
Test(ddsc_qos, history, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, history, .init=qos_init, .fini=qos_fini)
{
struct pol_history p = { DDS_HISTORY_KEEP_ALL, 0 };
@ -359,11 +358,11 @@ Test(ddsc_qos, history, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_history(g_qos, g_pol_history.kind, g_pol_history.depth);
dds_qget_history(g_qos, &p.kind, &p.depth);
cr_assert_eq(p.kind, g_pol_history.kind);
cr_assert_eq(p.depth, g_pol_history.depth);
CU_ASSERT_EQUAL_FATAL(p.kind, g_pol_history.kind);
CU_ASSERT_EQUAL_FATAL(p.depth, g_pol_history.depth);
}
Test(ddsc_qos, resource_limits, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, resource_limits, .init=qos_init, .fini=qos_fini)
{
struct pol_resource_limits p = { 0, 0, 0 };
@ -375,12 +374,12 @@ Test(ddsc_qos, resource_limits, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
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_qget_resource_limits(g_qos, &p.max_samples, &p.max_instances, &p.max_samples_per_instance);
cr_assert_eq(p.max_samples, g_pol_resource_limits.max_samples);
cr_assert_eq(p.max_instances, g_pol_resource_limits.max_instances);
cr_assert_eq(p.max_samples_per_instance, g_pol_resource_limits.max_samples_per_instance);
CU_ASSERT_EQUAL_FATAL(p.max_samples, g_pol_resource_limits.max_samples);
CU_ASSERT_EQUAL_FATAL(p.max_instances, g_pol_resource_limits.max_instances);
CU_ASSERT_EQUAL_FATAL(p.max_samples_per_instance, g_pol_resource_limits.max_samples_per_instance);
}
Test(ddsc_qos, presentation, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, presentation, .init=qos_init, .fini=qos_fini)
{
struct pol_presentation p = { DDS_PRESENTATION_INSTANCE, false, false };
@ -392,12 +391,12 @@ Test(ddsc_qos, presentation, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_presentation(g_qos, g_pol_presentation.access_scope, g_pol_presentation.coherent_access, g_pol_presentation.ordered_access);
dds_qget_presentation(g_qos, &p.access_scope, &p.coherent_access, &p.ordered_access);
cr_assert_eq(p.access_scope, g_pol_presentation.access_scope);
cr_assert_eq(p.coherent_access, g_pol_presentation.coherent_access);
cr_assert_eq(p.ordered_access, g_pol_presentation.ordered_access);
CU_ASSERT_EQUAL_FATAL(p.access_scope, g_pol_presentation.access_scope);
CU_ASSERT_EQUAL_FATAL(p.coherent_access, g_pol_presentation.coherent_access);
CU_ASSERT_EQUAL_FATAL(p.ordered_access, g_pol_presentation.ordered_access);
}
Test(ddsc_qos, lifespan, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, lifespan, .init=qos_init, .fini=qos_fini)
{
struct pol_lifespan p = { 0 };
@ -409,10 +408,10 @@ Test(ddsc_qos, lifespan, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_lifespan(g_qos, g_pol_lifespan.lifespan);
dds_qget_lifespan(g_qos, &p.lifespan);
cr_assert_eq(p.lifespan, g_pol_lifespan.lifespan);
CU_ASSERT_EQUAL_FATAL(p.lifespan, g_pol_lifespan.lifespan);
}
Test(ddsc_qos, deadline, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, deadline, .init=qos_init, .fini=qos_fini)
{
struct pol_deadline p = { 0 };
@ -424,10 +423,10 @@ Test(ddsc_qos, deadline, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_deadline(g_qos, g_pol_deadline.deadline);
dds_qget_deadline(g_qos, &p.deadline);
cr_assert_eq(p.deadline, g_pol_deadline.deadline);
CU_ASSERT_EQUAL_FATAL(p.deadline, g_pol_deadline.deadline);
}
Test(ddsc_qos, latency_budget, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, latency_budget, .init=qos_init, .fini=qos_fini)
{
struct pol_latency_budget p = { 0 };
@ -439,10 +438,10 @@ Test(ddsc_qos, latency_budget, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_latency_budget(g_qos, g_pol_latency_budget.duration);
dds_qget_latency_budget(g_qos, &p.duration);
cr_assert_eq(p.duration, g_pol_latency_budget.duration);
CU_ASSERT_EQUAL_FATAL(p.duration, g_pol_latency_budget.duration);
}
Test(ddsc_qos, ownership, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, ownership, .init=qos_init, .fini=qos_fini)
{
struct pol_ownership p = { DDS_OWNERSHIP_SHARED };
@ -454,10 +453,10 @@ Test(ddsc_qos, ownership, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_ownership(g_qos, g_pol_ownership.kind);
dds_qget_ownership(g_qos, &p.kind);
cr_assert_eq(p.kind, g_pol_ownership.kind);
CU_ASSERT_EQUAL_FATAL(p.kind, g_pol_ownership.kind);
}
Test(ddsc_qos, ownership_strength, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, ownership_strength, .init=qos_init, .fini=qos_fini)
{
struct pol_ownership_strength p = { 0 };
@ -469,10 +468,10 @@ Test(ddsc_qos, ownership_strength, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_ownership_strength(g_qos, g_pol_ownership_strength.value);
dds_qget_ownership_strength(g_qos, &p.value);
cr_assert_eq(p.value, g_pol_ownership_strength.value);
CU_ASSERT_EQUAL_FATAL(p.value, g_pol_ownership_strength.value);
}
Test(ddsc_qos, liveliness, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, liveliness, .init=qos_init, .fini=qos_fini)
{
struct pol_liveliness p = { DDS_LIVELINESS_AUTOMATIC, 0 };
@ -484,11 +483,11 @@ Test(ddsc_qos, liveliness, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_liveliness(g_qos, g_pol_liveliness.kind, g_pol_liveliness.lease_duration);
dds_qget_liveliness(g_qos, &p.kind, &p.lease_duration);
cr_assert_eq(p.kind, g_pol_liveliness.kind);
cr_assert_eq(p.lease_duration, g_pol_liveliness.lease_duration);
CU_ASSERT_EQUAL_FATAL(p.kind, g_pol_liveliness.kind);
CU_ASSERT_EQUAL_FATAL(p.lease_duration, g_pol_liveliness.lease_duration);
}
Test(ddsc_qos, time_base_filter, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, time_base_filter, .init=qos_init, .fini=qos_fini)
{
struct pol_time_based_filter p = { 0 };
@ -500,10 +499,10 @@ Test(ddsc_qos, time_base_filter, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_time_based_filter(g_qos, g_pol_time_based_filter.minimum_separation);
dds_qget_time_based_filter(g_qos, &p.minimum_separation);
cr_assert_eq(p.minimum_separation, g_pol_time_based_filter.minimum_separation);
CU_ASSERT_EQUAL_FATAL(p.minimum_separation, g_pol_time_based_filter.minimum_separation);
}
Test(ddsc_qos, partition, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, partition, .init=qos_init, .fini=qos_fini)
{
struct pol_partition p = { 0, NULL };
@ -515,17 +514,17 @@ Test(ddsc_qos, partition, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_partition(g_qos, g_pol_partition.n, c_partitions);
dds_qget_partition(g_qos, &p.n, &p.ps);
cr_assert_eq(p.n, 2);
cr_assert_eq(p.n, g_pol_partition.n);
cr_assert_str_eq(p.ps[0], g_pol_partition.ps[0]);
cr_assert_str_eq(p.ps[1], g_pol_partition.ps[1]);
CU_ASSERT_EQUAL_FATAL(p.n, 2);
CU_ASSERT_EQUAL_FATAL(p.n, g_pol_partition.n);
CU_ASSERT_STRING_EQUAL_FATAL(p.ps[0], g_pol_partition.ps[0]);
CU_ASSERT_STRING_EQUAL_FATAL(p.ps[1], g_pol_partition.ps[1]);
dds_free(p.ps[0]);
dds_free(p.ps[1]);
dds_free(p.ps);
}
Test(ddsc_qos, reliability, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, reliability, .init=qos_init, .fini=qos_fini)
{
struct pol_reliability p = { DDS_RELIABILITY_BEST_EFFORT, 0 };
@ -537,11 +536,11 @@ Test(ddsc_qos, reliability, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_reliability(g_qos, g_pol_reliability.kind, g_pol_reliability.max_blocking_time);
dds_qget_reliability(g_qos, &p.kind, &p.max_blocking_time);
cr_assert_eq(p.kind, g_pol_reliability.kind);
cr_assert_eq(p.max_blocking_time, g_pol_reliability.max_blocking_time);
CU_ASSERT_EQUAL_FATAL(p.kind, g_pol_reliability.kind);
CU_ASSERT_EQUAL_FATAL(p.max_blocking_time, g_pol_reliability.max_blocking_time);
}
Test(ddsc_qos, transport_priority, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, transport_priority, .init=qos_init, .fini=qos_fini)
{
struct pol_transport_priority p = { 0 };
@ -553,10 +552,10 @@ Test(ddsc_qos, transport_priority, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_transport_priority(g_qos, g_pol_transport_priority.value);
dds_qget_transport_priority(g_qos, &p.value);
cr_assert_eq(p.value, g_pol_transport_priority.value);
CU_ASSERT_EQUAL_FATAL(p.value, g_pol_transport_priority.value);
}
Test(ddsc_qos, destination_order, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, destination_order, .init=qos_init, .fini=qos_fini)
{
struct pol_destination_order p = { DDS_DESTINATIONORDER_BY_RECEPTION_TIMESTAMP };
@ -568,10 +567,10 @@ Test(ddsc_qos, destination_order, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_destination_order(g_qos, g_pol_destination_order.kind);
dds_qget_destination_order(g_qos, &p.kind);
cr_assert_eq(p.kind, g_pol_destination_order.kind);
CU_ASSERT_EQUAL_FATAL(p.kind, g_pol_destination_order.kind);
}
Test(ddsc_qos, writer_data_lifecycle, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, writer_data_lifecycle, .init=qos_init, .fini=qos_fini)
{
struct pol_writer_data_lifecycle p = { false };
@ -583,10 +582,10 @@ Test(ddsc_qos, writer_data_lifecycle, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_writer_data_lifecycle(g_qos, g_pol_writer_data_lifecycle.autodispose);
dds_qget_writer_data_lifecycle(g_qos, &p.autodispose);
cr_assert_eq(p.autodispose, g_pol_writer_data_lifecycle.autodispose);
CU_ASSERT_EQUAL_FATAL(p.autodispose, g_pol_writer_data_lifecycle.autodispose);
}
Test(ddsc_qos, reader_data_lifecycle, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, reader_data_lifecycle, .init=qos_init, .fini=qos_fini)
{
struct pol_reader_data_lifecycle p = { 0, 0 };
@ -598,11 +597,11 @@ Test(ddsc_qos, reader_data_lifecycle, .init=qos_init, .fini=qos_fini)
/* Getting after setting, should yield the original input. */
dds_qset_reader_data_lifecycle(g_qos, g_pol_reader_data_lifecycle.autopurge_nowriter_samples_delay, g_pol_reader_data_lifecycle.autopurge_disposed_samples_delay);
dds_qget_reader_data_lifecycle(g_qos, &p.autopurge_nowriter_samples_delay, &p.autopurge_disposed_samples_delay);
cr_assert_eq(p.autopurge_nowriter_samples_delay, g_pol_reader_data_lifecycle.autopurge_nowriter_samples_delay);
cr_assert_eq(p.autopurge_disposed_samples_delay, g_pol_reader_data_lifecycle.autopurge_disposed_samples_delay);
CU_ASSERT_EQUAL_FATAL(p.autopurge_nowriter_samples_delay, g_pol_reader_data_lifecycle.autopurge_nowriter_samples_delay);
CU_ASSERT_EQUAL_FATAL(p.autopurge_disposed_samples_delay, g_pol_reader_data_lifecycle.autopurge_disposed_samples_delay);
}
Test(ddsc_qos, durability_service, .init=qos_init, .fini=qos_fini)
CU_Test(ddsc_qos, durability_service, .init=qos_init, .fini=qos_fini)
{
struct pol_durability_service p = { 0, DDS_HISTORY_KEEP_LAST, 0, 0, 0, 0 };
@ -644,12 +643,12 @@ Test(ddsc_qos, durability_service, .init=qos_init, .fini=qos_fini)
&p.max_samples,
&p.max_instances,
&p.max_samples_per_instance);
cr_assert_eq(p.service_cleanup_delay, g_pol_durability_service.service_cleanup_delay);
cr_assert_eq(p.history_kind, g_pol_durability_service.history_kind);
cr_assert_eq(p.history_depth, g_pol_durability_service.history_depth);
cr_assert_eq(p.max_samples, g_pol_durability_service.max_samples);
cr_assert_eq(p.max_instances, g_pol_durability_service.max_instances);
cr_assert_eq(p.max_samples_per_instance, g_pol_durability_service.max_samples_per_instance);
CU_ASSERT_EQUAL_FATAL(p.service_cleanup_delay, g_pol_durability_service.service_cleanup_delay);
CU_ASSERT_EQUAL_FATAL(p.history_kind, g_pol_durability_service.history_kind);
CU_ASSERT_EQUAL_FATAL(p.history_depth, g_pol_durability_service.history_depth);
CU_ASSERT_EQUAL_FATAL(p.max_samples, g_pol_durability_service.max_samples);
CU_ASSERT_EQUAL_FATAL(p.max_instances, g_pol_durability_service.max_instances);
CU_ASSERT_EQUAL_FATAL(p.max_samples_per_instance, g_pol_durability_service.max_samples_per_instance);
}
#ifdef _MSC_VER

595
src/core/ddsc/tests/querycondition.c
View file

File diff suppressed because it is too large Load diff

572
src/core/ddsc/tests/read_instance.c
View file

File diff suppressed because it is too large Load diff

596
src/core/ddsc/tests/readcondition.c
View file

File diff suppressed because it is too large Load diff

1444
src/core/ddsc/tests/reader.c
View file

File diff suppressed because it is too large Load diff

381
src/core/ddsc/tests/reader_iterator.c
View file

@ -15,16 +15,8 @@
#include "os/os.h"
#include "Space.h"
#include "RoundTrip.h"
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include <criterion/theories.h>
#if 0
#define PRINT_SAMPLE(info, sample) cr_log_info("%s (%d, %d, %d)\n", info, sample.long_1, sample.long_2, sample.long_3);
#else
#define PRINT_SAMPLE(info, sample)
#endif
#include "CUnit/Test.h"
#include "CUnit/Theory.h"
/**************************************************************************************************
*
@ -132,62 +124,62 @@ reader_iterator_init(void)
dds_qos_t *qos;
qos = dds_create_qos();
cr_assert_not_null(qos, "Failed to create prerequisite qos");
CU_ASSERT_PTR_NOT_NULL_FATAL(qos);
g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant");
CU_ASSERT_FATAL(g_participant > 0);
g_subscriber = dds_create_subscriber(g_participant, NULL, NULL);
cr_assert_gt(g_subscriber, 0, "Failed to create prerequisite g_subscriber");
CU_ASSERT_FATAL(g_subscriber > 0);
g_publisher = dds_create_publisher(g_participant, NULL, NULL);
cr_assert_gt(g_publisher, 0, "Failed to create prerequisite g_publisher");
CU_ASSERT_FATAL(g_publisher > 0);
g_waitset = dds_create_waitset(g_participant);
cr_assert_gt(g_waitset, 0, "Failed to create g_waitset");
CU_ASSERT_FATAL(g_waitset > 0);
g_topic = dds_create_topic(g_participant, &Space_Type1_desc, create_topic_name("ddsc_read_iterator_test", name, sizeof name), NULL, NULL);
cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic");
CU_ASSERT_FATAL(g_topic > 0);
/* Create a writer that will not automatically dispose unregistered samples. */
dds_qset_writer_data_lifecycle(qos, false);
g_writer = dds_create_writer(g_publisher, g_topic, qos, NULL);
cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer");
CU_ASSERT_FATAL(g_writer > 0);
/* Create a reader that keeps all samples when not taken. */
dds_qset_history(qos, DDS_HISTORY_KEEP_ALL, DDS_LENGTH_UNLIMITED);
g_reader = dds_create_reader(g_subscriber, g_topic, qos, NULL);
cr_assert_gt(g_reader, 0, "Failed to create prerequisite g_reader");
CU_ASSERT_FATAL(g_reader > 0);
/* Create a read condition that only reads old samples. */
g_rcond = dds_create_readcondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE);
cr_assert_gt(g_rcond, 0, "Failed to create prerequisite g_rcond");
CU_ASSERT_FATAL(g_rcond > 0);
/* Create a query condition that only reads of instances mod2. */
g_qcond = dds_create_querycondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2);
cr_assert_gt(g_qcond, 0, "Failed to create prerequisite g_qcond");
CU_ASSERT_FATAL(g_qcond > 0);
/* Sync g_reader to g_writer. */
ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1));
cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_reader r");
cr_assert_eq(g_reader, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_reader a");
CU_ASSERT_EQUAL_FATAL(ret, 1);
CU_ASSERT_EQUAL_FATAL(g_reader, (dds_entity_t)(intptr_t)triggered);
ret = dds_waitset_detach(g_waitset, g_reader);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_reader");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Sync g_writer to g_reader. */
ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_writer status");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_attach(g_waitset, g_writer, g_writer);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_writer");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1));
cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_writer r");
cr_assert_eq(g_writer, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_writer a");
CU_ASSERT_EQUAL_FATAL(ret, 1);
CU_ASSERT_EQUAL_FATAL(g_writer, (dds_entity_t)(intptr_t)triggered);
ret = dds_waitset_detach(g_waitset, g_writer);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_writer");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Initialize reading buffers. */
memset (g_data, 0, sizeof (g_data));
@ -205,7 +197,7 @@ reader_iterator_init(void)
sample.long_2 = i;
sample.long_3 = i*2;
ret = dds_write(g_writer, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/* | long_1 | long_2 | long_3 | sst | vst | ist |
* -----------------------------------------------------
@ -239,50 +231,25 @@ reader_iterator_init(void)
/* Create a query condition that reads the specific sample to get a set of 'read' samples after init. */
qcond = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_init);
cr_assert_gt(g_qcond, 0, "Failed to create prerequisite qcond");
CU_ASSERT_FATAL(g_qcond > 0);
ret = dds_read(qcond, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
cr_assert_gt(ret, 0, "Failed prerequisite read: %d", dds_err_nr(ret));
CU_ASSERT_FATAL(ret > 0);
dds_delete(qcond);
}
/* | long_1 | long_2 | long_3 | sst | vst | ist |
* -----------------------------------------------------
* | 0 | 0 | 0 | not_read | new | alive |
* | 0 | 1 | 2 | not_read | new | alive |
* | 0 | 2 | 4 | not_read | new | alive |
* | 1 | 3 | 6 | read | old | alive |
* | 1 | 4 | 8 | read | old | alive |
* | 1 | 5 | 10 | read | old | alive |
* | 2 | 6 | 12 | not_read | old | alive |
* | 2 | 7 | 14 | not_read | old | alive |
* | 2 | 8 | 16 | read | old | alive |
* | 3 | 9 | 18 | not_read | old | alive |
* | 3 | 10 | 20 | read | old | alive |
* | 3 | 11 | 22 | not_read | old | alive |
* | 4 | 12 | 24 | read | old | alive |
* | 4 | 13 | 26 | not_read | old | alive |
* | 4 | 14 | 28 | not_read | old | alive |
* | 5 | 15 | 30 | read | old | alive |
* | 5 | 16 | 32 | not_read | old | alive |
* | 5 | 17 | 34 | read | old | alive |
* | 6 | 18 | 36 | read | old | alive |
* | 6 | 19 | 38 | not_read | old | alive |
* | 6 | 20 | 40 | read | old | alive |
*/
/* Dispose and unregister the last two samples. */
sample.long_1 = 5;
sample.long_2 = 15;
sample.long_3 = 30;
ret = dds_dispose(g_writer, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite dispose");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
sample.long_1 = 6;
sample.long_2 = 16;
sample.long_3 = 32;
ret = dds_unregister_instance(g_writer, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite unregister");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* | long_1 | long_2 | long_3 | sst | vst | ist |
* ----------------------------------------------------------
* | 0 | 0 | 0 | not_read | new | alive |
@ -330,7 +297,7 @@ samples_cnt(void)
{
dds_return_t ret;
ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
cr_assert_geq(ret, 0, "Failed samples count read: %d", dds_err_nr(ret));
CU_ASSERT_FATAL(ret >= 0);
return ret;
}
@ -340,17 +307,16 @@ samples_cnt(void)
*
*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_read_next, reader, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Test(ddsc_read_next, reader, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t cnt = 0, cntinv = 0;
dds_return_t ret = 1;
while (ret == 1){
ret = dds_read_next(g_reader, g_samples, g_info);
cr_assert_geq(ret, 0 , "# read %d", ret);
CU_ASSERT_FATAL(ret >= 0 );
if(ret == 1 && g_info[0].valid_data){
Space_Type1 *sample = (Space_Type1*)g_samples[0];
PRINT_SAMPLE("ddsc_read_next::reader: Read", (*sample));
/* Expected states. */
int expected_long_2 = rdr_expected_long_2[cnt];
@ -361,84 +327,86 @@ Test(ddsc_read_next, reader, .init=reader_iterator_init, .fini=reader_iterator_f
dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1);
/* Check data. */
cr_assert_eq(sample->long_1, expected_long_1);
cr_assert_eq(sample->long_2, expected_long_2);
cr_assert_eq(sample->long_3, expected_long_3);
CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1);
CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2);
CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_3);
/* Check states. */
cr_assert_eq(g_info[0].valid_data, true);
cr_assert_eq(g_info[0].sample_state, expected_sst);
cr_assert_eq(g_info[0].view_state, expected_vst);
cr_assert_eq(g_info[0].instance_state, expected_ist);
CU_ASSERT_EQUAL_FATAL(g_info[0].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[0].sample_state, expected_sst);
CU_ASSERT_EQUAL_FATAL(g_info[0].view_state, expected_vst);
CU_ASSERT_EQUAL_FATAL(g_info[0].instance_state, expected_ist);
cnt ++;
} else if (ret == 1 && !g_info[0].valid_data) {
cntinv ++;
}
}
cr_assert_eq(cnt, RDR_NOT_READ_CNT);
cr_assert_eq(cntinv, RDR_INV_READ_CNT);
CU_ASSERT_EQUAL_FATAL(cnt, RDR_NOT_READ_CNT);
CU_ASSERT_EQUAL_FATAL(cntinv, RDR_INV_READ_CNT);
/* All samples should still be available. */
ret = samples_cnt();
cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_read_next, invalid_readers) = {
DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
CU_TheoryDataPoints(ddsc_read_next, invalid_readers) = {
CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
};
Theory((dds_entity_t rdr), ddsc_read_next, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((dds_entity_t rdr), ddsc_read_next, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_read_next(rdr, g_samples, g_info);
cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_read_next, non_readers) = {
DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond),
CU_TheoryDataPoints(ddsc_read_next, non_readers) = {
CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond),
};
Theory((dds_entity_t *rdr), ddsc_read_next, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((dds_entity_t *rdr), ddsc_read_next, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t ret;
ret = dds_read_next(*rdr, g_samples, g_info);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_read_next, already_deleted) = {
DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader),
CU_TheoryDataPoints(ddsc_read_next, already_deleted) = {
CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader),
};
Theory((dds_entity_t *rdr), ddsc_read_next, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((dds_entity_t *rdr), ddsc_read_next, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t ret;
ret = dds_delete(*rdr);
cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_read_next(*rdr, g_samples, g_info);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_read_next, invalid_buffers) = {
DataPoints(void**, g_samples, g_loans, (void**)0),
DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ),
CU_TheoryDataPoints(ddsc_read_next, invalid_buffers) = {
CU_DataPoints(void**, g_samples, g_loans, (void**)0),
CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL),
};
Theory((void **buf, dds_sample_info_t *si), ddsc_read_next, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((void **buf, dds_sample_info_t *si), ddsc_read_next, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t ret;
cr_assume((buf != g_samples) || (si != g_info));
cr_assume(buf != g_loans);
ret = dds_read_next(g_reader, buf, si);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret));
if ((buf != g_samples || si != g_info) && (buf != g_loans)) {
ret = dds_read_next(g_reader, buf, si);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS();
}
}
/*************************************************************************************************/
@ -452,17 +420,16 @@ Theory((void **buf, dds_sample_info_t *si), ddsc_read_next, invalid_buffers, .in
*
*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_read_next_wl, reader, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Test(ddsc_read_next_wl, reader, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t cnt = 0, cntinv = 0;
dds_return_t ret = 1;
while (ret == 1){
ret = dds_read_next_wl(g_reader, g_loans, g_info);
cr_assert_geq(ret, 0 , "# read %d", ret);
CU_ASSERT_FATAL(ret >= 0 );
if(ret == 1 && g_info[0].valid_data){
Space_Type1 *sample = (Space_Type1*)g_loans[0];
PRINT_SAMPLE("ddsc_read_next_wl::reader: Read", (*sample));
/* Expected states. */
int expected_long_2 = rdr_expected_long_2[cnt];
@ -473,86 +440,89 @@ Test(ddsc_read_next_wl, reader, .init=reader_iterator_init, .fini=reader_iterato
dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1);
/* Check data. */
cr_assert_eq(sample->long_1, expected_long_1);
cr_assert_eq(sample->long_2, expected_long_2);
cr_assert_eq(sample->long_3, expected_long_3);
CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1);
CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2);
CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_3);
/* Check states. */
cr_assert_eq(g_info[0].valid_data, true);
cr_assert_eq(g_info[0].sample_state, expected_sst);
cr_assert_eq(g_info[0].view_state, expected_vst);
cr_assert_eq(g_info[0].instance_state, expected_ist);
cnt ++;
CU_ASSERT_EQUAL_FATAL(g_info[0].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[0].sample_state, expected_sst);
CU_ASSERT_EQUAL_FATAL(g_info[0].view_state, expected_vst);
CU_ASSERT_EQUAL_FATAL(g_info[0].instance_state, expected_ist);
cnt++;
} else if (ret == 1 && !g_info[0].valid_data) {
cntinv ++;
cntinv++;
}
}
cr_assert_eq(cnt, RDR_NOT_READ_CNT);
cr_assert_eq(cntinv, RDR_INV_READ_CNT);
CU_ASSERT_EQUAL_FATAL(cnt, RDR_NOT_READ_CNT);
CU_ASSERT_EQUAL_FATAL(cntinv, RDR_INV_READ_CNT);
ret = dds_return_loan(g_reader, g_loans, ret);
cr_assert_eq (ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* All samples should still be available. */
ret = samples_cnt();
cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_read_next_wl, invalid_readers) = {
DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
CU_TheoryDataPoints(ddsc_read_next_wl, invalid_readers) = {
CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
};
Theory((dds_entity_t rdr), ddsc_read_next_wl, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((dds_entity_t rdr), ddsc_read_next_wl, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_read_next_wl(rdr, g_loans, g_info);
cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_read_next_wl, non_readers) = {
DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond),
CU_TheoryDataPoints(ddsc_read_next_wl, non_readers) = {
CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond),
};
Theory((dds_entity_t *rdr), ddsc_read_next_wl, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((dds_entity_t *rdr), ddsc_read_next_wl, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t ret;
ret = dds_read_next_wl(*rdr, g_loans, g_info);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_read_next_wl, already_deleted) = {
DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader),
CU_TheoryDataPoints(ddsc_read_next_wl, already_deleted) = {
CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader),
};
Theory((dds_entity_t *rdr), ddsc_read_next_wl, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((dds_entity_t *rdr), ddsc_read_next_wl, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t ret;
ret = dds_delete(*rdr);
cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_read_next_wl(*rdr, g_loans, g_info);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_read_next_wl, invalid_buffers) = {
DataPoints(void**, g_loans, (void**)0),
DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ),
CU_TheoryDataPoints(ddsc_read_next_wl, invalid_buffers) = {
CU_DataPoints(void**, g_loans, (void**)0),
CU_DataPoints(dds_sample_info_t*, g_info, NULL),
};
Theory((void **buf, dds_sample_info_t *si), ddsc_read_next_wl, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((void **buf, dds_sample_info_t *si), ddsc_read_next_wl, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t ret;
cr_assume((buf != g_loans) || (si != g_info));
ret = dds_read_next_wl(g_reader, buf, si);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret));
if (buf != g_loans || si != g_info) {
ret = dds_read_next_wl(g_reader, buf, si);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS();
}
}
/*************************************************************************************************/
@ -566,17 +536,16 @@ Theory((void **buf, dds_sample_info_t *si), ddsc_read_next_wl, invalid_buffers,
*
*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_take_next, reader, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Test(ddsc_take_next, reader, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t cnt = 0, cntinv = 0;
dds_return_t ret = 1;
while (ret == 1){
ret = dds_take_next(g_reader, g_samples, g_info);
cr_assert_geq(ret, 0 , "# read %d", ret);
CU_ASSERT_FATAL(ret >= 0 );
if(ret == 1 && g_info[0].valid_data){
Space_Type1 *sample = (Space_Type1*)g_samples[0];
PRINT_SAMPLE("ddsc_take_next::reader: Read", (*sample));
/* Expected states. */
int expected_long_2 = rdr_expected_long_2[cnt];
@ -587,82 +556,83 @@ Test(ddsc_take_next, reader, .init=reader_iterator_init, .fini=reader_iterator_f
dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1);
/* Check data. */
cr_assert_eq(sample->long_1, expected_long_1);
cr_assert_eq(sample->long_2, expected_long_2);
cr_assert_eq(sample->long_3, expected_long_3);
CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1);
CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2);
CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_3);
/* Check states. */
cr_assert_eq(g_info[0].valid_data, true);
cr_assert_eq(g_info[0].sample_state, expected_sst);
cr_assert_eq(g_info[0].view_state, expected_vst);
cr_assert_eq(g_info[0].instance_state, expected_ist);
cnt ++;
CU_ASSERT_EQUAL_FATAL(g_info[0].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[0].sample_state, expected_sst);
CU_ASSERT_EQUAL_FATAL(g_info[0].view_state, expected_vst);
CU_ASSERT_EQUAL_FATAL(g_info[0].instance_state, expected_ist);
cnt++;
} else if (ret == 1 && !g_info[0].valid_data) {
cntinv ++;
cntinv++;
}
}
cr_assert_eq(cnt, RDR_NOT_READ_CNT);
cr_assert_eq(cntinv, RDR_INV_READ_CNT);
CU_ASSERT_EQUAL_FATAL(cnt, RDR_NOT_READ_CNT);
CU_ASSERT_EQUAL_FATAL(cntinv, RDR_INV_READ_CNT);
/* All samples should still be available. */
ret = samples_cnt();
cr_assert_eq(ret, (MAX_SAMPLES - RDR_NOT_READ_CNT), "# samples %d, expected %d", ret, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(ret, (MAX_SAMPLES - RDR_NOT_READ_CNT));
}
/*************************************************************************************************/
TheoryDataPoints(ddsc_take_next, invalid_readers) = {
DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
CU_TheoryDataPoints(ddsc_take_next, invalid_readers) = {
CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
};
Theory((dds_entity_t rdr), ddsc_take_next, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((dds_entity_t rdr), ddsc_take_next, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_take_next(rdr, g_samples, g_info);
cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_take_next, non_readers) = {
DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond),
CU_TheoryDataPoints(ddsc_take_next, non_readers) = {
CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond),
};
Theory((dds_entity_t *rdr), ddsc_take_next, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((dds_entity_t *rdr), ddsc_take_next, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t ret;
ret = dds_take_next(*rdr, g_samples, g_info);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_take_next, already_deleted) = {
DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader),
CU_TheoryDataPoints(ddsc_take_next, already_deleted) = {
CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader),
};
Theory((dds_entity_t *rdr), ddsc_take_next, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((dds_entity_t *rdr), ddsc_take_next, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t ret;
ret = dds_delete(*rdr);
cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_take_next(*rdr, g_samples, g_info);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_take_next, invalid_buffers) = {
DataPoints(void**, g_samples, g_loans, (void**)0),
DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ),
CU_TheoryDataPoints(ddsc_take_next, invalid_buffers) = {
CU_DataPoints(void**, g_samples, g_loans, (void**)0),
CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL),
};
Theory((void **buf, dds_sample_info_t *si), ddsc_take_next, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((void **buf, dds_sample_info_t *si), ddsc_take_next, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t ret;
cr_assume((buf != g_samples) || (si != g_info));
cr_assume(buf != g_loans);
ret = dds_take_next(g_reader, buf, si);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret));
if ((buf != g_samples || si != g_info) && (buf != g_loans)) {
ret = dds_take_next(g_reader, buf, si);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS();
}
}
/*************************************************************************************************/
@ -676,17 +646,16 @@ Theory((void **buf, dds_sample_info_t *si), ddsc_take_next, invalid_buffers, .in
*
*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_take_next_wl, reader, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Test(ddsc_take_next_wl, reader, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t cnt = 0, cntinv = 0;
dds_return_t ret = 1;
while (ret == 1){
ret = dds_take_next_wl(g_reader, g_loans, g_info);
cr_assert_geq(ret, 0 , "# read %d", ret);
CU_ASSERT_FATAL(ret >= 0);
if(ret == 1 && g_info[0].valid_data){
Space_Type1 *sample = (Space_Type1*)g_loans[0];
PRINT_SAMPLE("ddsc_read_next_wl::reader: Read", (*sample));
/* Expected states. */
int expected_long_2 = rdr_expected_long_2[cnt];
@ -697,83 +666,85 @@ Test(ddsc_take_next_wl, reader, .init=reader_iterator_init, .fini=reader_iterato
dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1);
/* Check data. */
cr_assert_eq(sample->long_1, expected_long_1);
cr_assert_eq(sample->long_2, expected_long_2);
cr_assert_eq(sample->long_3, expected_long_3);
CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1);
CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2);
CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_3);
/* Check states. */
cr_assert_eq(g_info[0].valid_data, true);
cr_assert_eq(g_info[0].sample_state, expected_sst);
cr_assert_eq(g_info[0].view_state, expected_vst);
cr_assert_eq(g_info[0].instance_state, expected_ist);
cnt ++;
CU_ASSERT_EQUAL_FATAL(g_info[0].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[0].sample_state, expected_sst);
CU_ASSERT_EQUAL_FATAL(g_info[0].view_state, expected_vst);
CU_ASSERT_EQUAL_FATAL(g_info[0].instance_state, expected_ist);
cnt++;
} else if (ret == 1 && !g_info[0].valid_data) {
cntinv ++;
cntinv++;
}
}
cr_assert_eq(cnt, RDR_NOT_READ_CNT);
cr_assert_eq(cntinv, RDR_INV_READ_CNT);
CU_ASSERT_EQUAL_FATAL(cnt, RDR_NOT_READ_CNT);
CU_ASSERT_EQUAL_FATAL(cntinv, RDR_INV_READ_CNT);
ret = dds_return_loan(g_reader, g_loans, ret);
cr_assert_eq (ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* All samples should still be available. */
ret = samples_cnt();
cr_assert_eq(ret, (MAX_SAMPLES - RDR_NOT_READ_CNT), "# samples %d, expected %d", ret, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(ret, (MAX_SAMPLES - RDR_NOT_READ_CNT));
}
/*************************************************************************************************/
TheoryDataPoints(ddsc_take_next_wl, invalid_readers) = {
DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
CU_TheoryDataPoints(ddsc_take_next_wl, invalid_readers) = {
CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
};
Theory((dds_entity_t rdr), ddsc_take_next_wl, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((dds_entity_t rdr), ddsc_take_next_wl, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_take_next_wl(rdr, g_loans, g_info);
cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_take_next_wl, non_readers) = {
DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond),
CU_TheoryDataPoints(ddsc_take_next_wl, non_readers) = {
CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond),
};
Theory((dds_entity_t *rdr), ddsc_take_next_wl, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((dds_entity_t *rdr), ddsc_take_next_wl, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t ret;
ret = dds_take_next_wl(*rdr, g_loans, g_info);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_take_next_wl, already_deleted) = {
DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader),
CU_TheoryDataPoints(ddsc_take_next_wl, already_deleted) = {
CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader),
};
Theory((dds_entity_t *rdr), ddsc_take_next_wl, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((dds_entity_t *rdr), ddsc_take_next_wl, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t ret;
ret = dds_delete(*rdr);
cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_take_next_wl(*rdr, g_loans, g_info);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_take_next_wl, invalid_buffers) = {
DataPoints(void**, g_loans, (void**)0),
DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ),
CU_TheoryDataPoints(ddsc_take_next_wl, invalid_buffers) = {
CU_DataPoints(void**, g_loans, (void**)0),
CU_DataPoints(dds_sample_info_t*, g_info, NULL),
};
Theory((void **buf, dds_sample_info_t *si), ddsc_take_next_wl, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini)
CU_Theory((void **buf, dds_sample_info_t *si), ddsc_take_next_wl, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini)
{
dds_return_t ret;
cr_assume((buf != g_loans) || (si != g_info));
ret = dds_take_next_wl(g_reader, buf, si);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret));
if (buf != g_loans || si != g_info) {
ret = dds_take_next_wl(g_reader, buf, si);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS();
}
}
/*************************************************************************************************/

88
src/core/ddsc/tests/register.c
View file

@ -13,9 +13,8 @@
#include "ddsc/dds.h"
#include "os/os.h"
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include <criterion/theories.h>
#include "CUnit/Test.h"
#include "CUnit/Theory.h"
#include "Space.h"
@ -63,46 +62,46 @@ registering_init(void)
dds_qset_destination_order(qos, DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP);
g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant");
CU_ASSERT_FATAL(g_participant > 0);
g_waitset = dds_create_waitset(g_participant);
cr_assert_gt(g_waitset, 0, "Failed to create g_waitset");
CU_ASSERT_FATAL(g_waitset > 0);
g_topic = dds_create_topic(g_participant, &Space_Type1_desc, create_topic_name("ddsc_registering_test", name, sizeof name), qos, NULL);
cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic");
CU_ASSERT_FATAL(g_topic > 0);
/* Create a reader that keeps one sample on three instances. */
dds_qset_reliability(qos, DDS_RELIABILITY_RELIABLE, DDS_MSECS(100));
dds_qset_resource_limits(qos, DDS_LENGTH_UNLIMITED, 3, 1);
g_reader = dds_create_reader(g_participant, g_topic, qos, NULL);
cr_assert_gt(g_reader, 0, "Failed to create prerequisite g_reader");
CU_ASSERT_FATAL(g_reader > 0);
/* Create a writer that will not automatically dispose unregistered samples. */
dds_qset_writer_data_lifecycle(qos, false);
g_writer = dds_create_writer(g_participant, g_topic, qos, NULL);
cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer");
CU_ASSERT_FATAL(g_writer > 0);
/* Sync g_writer to g_reader. */
ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_writer status");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_attach(g_waitset, g_writer, g_writer);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_writer");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1));
cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_writer r");
cr_assert_eq(g_writer, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_writer a");
CU_ASSERT_EQUAL_FATAL(ret, 1);
CU_ASSERT_EQUAL_FATAL(g_writer, (dds_entity_t)(intptr_t)triggered);
ret = dds_waitset_detach(g_waitset, g_writer);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_writer");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Sync g_reader to g_writer. */
ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1));
cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_reader r");
cr_assert_eq(g_reader, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_reader a");
CU_ASSERT_EQUAL_FATAL(ret, 1);
CU_ASSERT_EQUAL_FATAL(g_reader, (dds_entity_t)(intptr_t)triggered);
ret = dds_waitset_detach(g_waitset, g_reader);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_reader");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Write initial samples. */
for (int i = 0; i < INITIAL_SAMPLES; i++) {
@ -110,7 +109,7 @@ registering_init(void)
sample.long_2 = i*2;
sample.long_3 = i*3;
ret = dds_write(g_writer, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/* Initialize reading buffers. */
@ -137,89 +136,86 @@ registering_fini(void)
}
#if 0
#else
/**************************************************************************************************
*
* These will check the dds_register_instance() in various ways.
*
*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_register_instance, deleted_entity, .init=registering_init, .fini=registering_fini)
CU_Test(ddsc_register_instance, deleted_entity, .init=registering_init, .fini=registering_fini)
{
dds_return_t ret;
dds_instance_handle_t handle;
dds_delete(g_writer);
ret = dds_register_instance(g_writer, &handle, g_data);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED);
}
static dds_instance_handle_t hndle = 0;
static Space_Type1 data;
TheoryDataPoints(ddsc_register_instance, invalid_params) = {
DataPoints(dds_instance_handle_t *, &hndle, NULL),
DataPoints(void*, &data, NULL)
CU_TheoryDataPoints(ddsc_register_instance, invalid_params) = {
CU_DataPoints(dds_instance_handle_t *, &hndle, NULL),
CU_DataPoints(void*, NULL, &data)
};
Theory((dds_instance_handle_t *hndl2, void *datap), ddsc_register_instance, invalid_params/*, .init=registering_init, .fini=registering_fini*/)
CU_Theory((dds_instance_handle_t *hndl2, void *datap), ddsc_register_instance, invalid_params, .init=registering_init, .fini=registering_fini)
{
dds_return_t ret;
/* Only test when the combination of parameters is actually invalid.*/
cr_assume((hndl2 == NULL) || (datap == NULL));
CU_ASSERT_FATAL((hndl2 == NULL) || (datap == NULL));
OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_register_instance(g_writer, hndl2, datap);
OS_WARNING_MSVC_ON(6387);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d != expected %d", dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
}
TheoryDataPoints(ddsc_register_instance, invalid_writers) = {
DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
CU_TheoryDataPoints(ddsc_register_instance, invalid_writers) = {
CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
};
Theory((dds_entity_t writer), ddsc_register_instance, invalid_writers, .init=registering_init, .fini=registering_fini)
CU_Theory((dds_entity_t writer), ddsc_register_instance, invalid_writers, .init=registering_init, .fini=registering_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
dds_instance_handle_t handle;
ret = dds_register_instance(writer, &handle, g_data);
cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
}
TheoryDataPoints(ddsc_register_instance, non_writers) = {
DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant),
CU_TheoryDataPoints(ddsc_register_instance, non_writers) = {
CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant),
};
Theory((dds_entity_t *writer), ddsc_register_instance, non_writers, .init=registering_init, .fini=registering_fini)
CU_Theory((dds_entity_t *writer), ddsc_register_instance, non_writers, .init=registering_init, .fini=registering_fini)
{
dds_return_t ret;
dds_instance_handle_t handle;
ret = dds_register_instance(*writer, &handle, g_data);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
}
Test(ddsc_register_instance, registering_new_instance, .init=registering_init, .fini=registering_fini)
CU_Test(ddsc_register_instance, registering_new_instance, .init=registering_init, .fini=registering_fini)
{
dds_instance_handle_t instHndl, instHndl2;
dds_return_t ret;
Space_Type1 newInstance = { INITIAL_SAMPLES, 0, 0 };
instHndl = dds_instance_lookup(g_writer, &newInstance);
cr_assert_eq(instHndl, DDS_HANDLE_NIL);
CU_ASSERT_EQUAL_FATAL(instHndl, DDS_HANDLE_NIL);
ret = dds_register_instance(g_writer, &instHndl2, &newInstance);
cr_assert_eq(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
instHndl = dds_instance_lookup(g_writer, &newInstance);
cr_assert_eq(instHndl, instHndl2);
CU_ASSERT_EQUAL_FATAL(instHndl, instHndl2);
}
Test(ddsc_register_instance, data_already_available, .init=registering_init, .fini=registering_fini)
CU_Test(ddsc_register_instance, data_already_available, .init=registering_init, .fini=registering_fini)
{
dds_instance_handle_t instHndl, instHndl2;
dds_return_t ret;
instHndl = dds_instance_lookup(g_writer, &g_data);
cr_assert_neq(instHndl, DDS_HANDLE_NIL);
CU_ASSERT_NOT_EQUAL_FATAL(instHndl, DDS_HANDLE_NIL);
ret = dds_register_instance(g_writer, &instHndl2, &g_data);
cr_assert_eq(ret, DDS_RETCODE_OK);
cr_assert_eq(instHndl2, instHndl);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(instHndl2, instHndl);
}
#endif

51
src/core/ddsc/tests/return_loan.c
View file

@ -14,31 +14,30 @@
#include "os/os.h"
#include <stdio.h>
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
dds_entity_t participant = 0, topic = 0, reader = 0, read_condition = 0;
void create_entities(void)
{
participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0);
CU_ASSERT_FATAL(participant > 0);
topic = dds_create_topic(participant, &RoundTripModule_DataType_desc, "ddsc_reader_return_loan_RoundTrip", NULL, NULL);
cr_assert_gt(topic, 0);
CU_ASSERT_FATAL(topic > 0);
reader = dds_create_reader(participant, topic, NULL, NULL);
cr_assert_gt(reader, 0);
CU_ASSERT_FATAL(reader > 0);
read_condition = dds_create_readcondition(reader, DDS_ANY_STATE);
cr_assert_gt(read_condition, 0);
CU_ASSERT_FATAL(read_condition > 0);
}
void delete_entities(void)
{
dds_return_t result;
result = dds_delete(participant);
cr_assert_eq(dds_err_nr(result), DDS_RETCODE_OK, "Recursively delete entities, Expected(%s) Returned(%s)", DDS_TO_STRING(DDS_RETCODE_OK), dds_err_str(result));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(result), DDS_RETCODE_OK);
dds_delete(read_condition);
}
@ -69,7 +68,7 @@ static void delete_loan_buf(void **buf, size_t sz, bool empty)
for (i = 0; i < sz; i++) {
RoundTripModule_DataType *s = buf[i];
if (!empty) {
cr_expect_gt(s->payload._length, 0, "Expected allocated 'payload'-sequence in sample-contents of loan");
CU_ASSERT(s->payload._length > 0);
if (s->payload._length > 0) {
/* Freed by a successful dds_return_loan */
dds_free(s->payload._buffer);
@ -82,15 +81,13 @@ static void delete_loan_buf(void **buf, size_t sz, bool empty)
}
/* Verify DDS_RETCODE_BAD_PARAMETER is returned */
Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = delete_entities)
CU_Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = delete_entities)
{
dds_return_t result;
void **buf = NULL;
result = dds_return_loan(reader, NULL, 0);
cr_expect_eq(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER, "Invalid buffer(null), Expected(%s) Returned(%s)",
DDS_TO_STRING(DDS_RETCODE_BAD_PARAMETER),
dds_err_str(result));
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER);
#ifdef _MSC_VER
#pragma warning(push)
@ -100,9 +97,7 @@ Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = delet
#ifdef _MSC_VER
#pragma warning(pop)
#endif
cr_expect_eq(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER, "Invalid buffer size, Expected(%s) Returned(%s)",
DDS_TO_STRING(DDS_RETCODE_BAD_PARAMETER),
dds_err_str(result));
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER);
buf = create_loan_buf(10, false);
#ifdef _MSC_VER
@ -113,20 +108,16 @@ Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = delet
#ifdef _MSC_VER
#pragma warning(pop)
#endif
cr_expect_eq(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER, "Invalid entity, Expected(%s) Returned(%s)",
DDS_TO_STRING(DDS_RETCODE_BAD_PARAMETER),
dds_err_str(result));
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER);
result = dds_return_loan(participant, buf, 0);
cr_expect_eq(dds_err_nr(result), DDS_RETCODE_ILLEGAL_OPERATION, "Invalid entity-kind, Expected(%s) Returned(%s)",
DDS_TO_STRING(DDS_RETCODE_ILLEGAL_OPERATION),
dds_err_str(result));
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_ILLEGAL_OPERATION);
delete_loan_buf(buf, 10, false);
}
/* Verify DDS_RETCODE_OK is returned */
Test(ddsc_reader, return_loan_success, .init = create_entities, .fini = delete_entities)
CU_Test(ddsc_reader, return_loan_success, .init = create_entities, .fini = delete_entities)
{
void **buf;
void *buf2 = NULL;
@ -134,25 +125,17 @@ Test(ddsc_reader, return_loan_success, .init = create_entities, .fini = delete_e
buf = create_loan_buf(10, false);
result = dds_return_loan(reader, buf, 10);
cr_expect_eq(dds_err_nr(result), DDS_RETCODE_OK, "Return loan of size 10 via reader entity, Expected(%s) Returned(%s)",
DDS_TO_STRING(DDS_RETCODE_OK),
dds_err_str(result));
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK);
result = dds_return_loan(reader, &buf2, 0);
cr_expect_eq(dds_err_nr(result), DDS_RETCODE_OK, "Return empty loan via reader entity, Expected(%s) Returned(%s)",
DDS_TO_STRING(DDS_RETCODE_OK),
dds_err_str(result));
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK);
delete_loan_buf(buf, 10, true);
buf = create_loan_buf(10, false);
result = dds_return_loan(read_condition, buf, 10);
cr_expect_eq(dds_err_nr(result), DDS_RETCODE_OK, "Return loan of size 10 via read-condition entity, Expected(%s) Returned(%s)",
DDS_TO_STRING(DDS_RETCODE_OK),
dds_err_str(result));
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK);
result = dds_return_loan(read_condition, &buf2, 0);
cr_expect_eq(dds_err_nr(result), DDS_RETCODE_OK, "Return empty loan via read-condition entity, Expected(%s) Returned(%s)",
DDS_TO_STRING(DDS_RETCODE_OK),
dds_err_str(result));
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK);
delete_loan_buf(buf, 10, true);
}

31
src/core/ddsc/tests/subscriber.c
View file

@ -12,8 +12,7 @@
#include "ddsc/dds.h"
#include <stdio.h>
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
/* We are deliberately testing some bad arguments that SAL will complain about.
* So, silence SAL regarding these issues. */
@ -35,27 +34,27 @@ static void on_publication_matched(dds_entity_t writer, const dds_publication_ma
(void)arg;
}
Test(ddsc_subscriber, notify_readers) {
CU_Test(ddsc_subscriber, notify_readers) {
dds_entity_t participant;
dds_entity_t subscriber;
dds_return_t ret;
participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "Failed to create prerequisite participant");
CU_ASSERT_FATAL(participant > 0);
subscriber = dds_create_subscriber(participant, NULL, NULL);
cr_assert_gt(subscriber, 0, "Failed to create prerequisite subscriber");
CU_ASSERT_FATAL(subscriber > 0);
/* todo implement tests */
ret = dds_notify_readers(subscriber);
cr_expect_eq(dds_err_nr(ret), DDS_RETCODE_UNSUPPORTED, "Invalid return code %d", ret);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_UNSUPPORTED);
dds_delete(subscriber);
dds_delete(participant);
}
Test(ddsc_subscriber, create) {
CU_Test(ddsc_subscriber, create) {
dds_entity_t participant;
dds_entity_t subscriber;
@ -63,57 +62,57 @@ Test(ddsc_subscriber, create) {
dds_qos_t *sqos;
participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0, "Failed to create prerequisite participant");
CU_ASSERT_FATAL(participant > 0);
/*** Verify participant parameter ***/
subscriber = dds_create_subscriber(0, NULL, NULL);
cr_assert_eq(dds_err_nr(subscriber), DDS_RETCODE_BAD_PARAMETER, "dds_create_subscriber: invalid participant parameter");
CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), DDS_RETCODE_BAD_PARAMETER);
subscriber = dds_create_subscriber(participant, NULL, NULL);
cr_assert_gt(subscriber, 0, "dds_create_subscriber: valid participant parameter");
CU_ASSERT_FATAL(subscriber > 0);
dds_delete(subscriber);
/*** Verify qos parameter ***/
sqos = dds_create_qos(); /* Use defaults (no user-defined policies) */
subscriber = dds_create_subscriber(participant, sqos, NULL);
cr_assert_gt(subscriber, 0, "dds_create_subscriber: default QoS parameter");
CU_ASSERT_FATAL(subscriber > 0);
dds_delete(subscriber);
dds_delete_qos(sqos);
sqos = dds_create_qos();
dds_qset_destination_order(sqos, 3); /* Set invalid dest. order (ignored, not applicable for subscriber) */
subscriber = dds_create_subscriber(participant, sqos, NULL);
cr_assert_gt(subscriber, 0, "dds_create_subscriber: invalid non-applicable QoS parameter");
CU_ASSERT_FATAL(subscriber > 0);
dds_delete(subscriber);
dds_delete_qos(sqos);
sqos = dds_create_qos();
dds_qset_presentation(sqos, 123, 1, 1); /* Set invalid presentation policy */
subscriber = dds_create_subscriber(participant, sqos, NULL);
cr_assert_eq(dds_err_nr(subscriber), DDS_RETCODE_INCONSISTENT_POLICY, "dds_create_subscriber: invalid presentation access_scope QoS parameter");
CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), DDS_RETCODE_INCONSISTENT_POLICY);
dds_delete_qos(sqos);
/*** Verify listener parameter ***/
listener = dds_create_listener(NULL); /* Use defaults (all listeners unset) */
subscriber = dds_create_subscriber(participant, NULL, listener);
cr_assert_gt(subscriber, 0, "dds_create_subscriber: unset listeners");
CU_ASSERT_FATAL(subscriber > 0);
dds_delete(subscriber);
dds_delete_listener(listener);
listener = dds_create_listener(NULL);
dds_lset_data_available(listener, &on_data_available); /* Set on_data_available listener */
subscriber = dds_create_subscriber(participant, NULL, listener);
cr_assert_gt(subscriber, 0, "dds_create_subscriber: on_data_available listener");
CU_ASSERT_FATAL(subscriber > 0);
dds_delete(subscriber);
dds_delete_listener(listener);
listener = dds_create_listener(NULL);
dds_lset_publication_matched(listener, &on_publication_matched); /* Set on_publication_matched listener (ignored, not applicable for subscriber) */
subscriber = dds_create_subscriber(participant, NULL, listener);
cr_assert_gt(subscriber, 0, "dds_create_subscriber: on_publication_matched listener");
CU_ASSERT_FATAL(subscriber > 0);
dds_delete(subscriber);
dds_delete_listener(listener);

566
src/core/ddsc/tests/take_instance.c
View file

File diff suppressed because it is too large Load diff

21
src/core/ddsc/tests/time.c
View file

@ -1,17 +1,26 @@
#include <criterion/criterion.h>
#include <criterion/logging.h>
/*
* 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 "CUnit/Test.h"
#include "ddsc/dds.h"
Test(ddsc_time, request_time)
CU_Test(ddsc_time, request_time)
{
dds_time_t now, then;
dds_duration_t pause = 1 * DDS_NSECS_IN_SEC;
now = dds_time();
cr_assert_gt(now, 0);
CU_ASSERT_FATAL(now > 0);
/* Sleep for 1 second, every platform should (hopefully) support that */
dds_sleepfor(pause);
then = dds_time();
cr_assert_geq(then, now + pause);
CU_ASSERT_FATAL(then >= (now + pause));
}

171
src/core/ddsc/tests/topic.c
View file

@ -12,9 +12,8 @@
#include "ddsc/dds.h"
#include "os/os.h"
#include "RoundTrip.h"
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include <criterion/theories.h>
#include "CUnit/Test.h"
#include "CUnit/Theory.h"
/**************************************************************************************************
*
@ -52,13 +51,13 @@ ddsc_topic_init(void)
create_topic_name("ddsc_topic_test_rtm_datatype", g_topicRtmDataTypeName, MAX_NAME_SIZE);
g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant");
CU_ASSERT_FATAL(g_participant > 0);
g_topicRtmAddress = dds_create_topic(g_participant, &RoundTripModule_Address_desc, g_topicRtmAddressName, NULL, NULL);
cr_assert_gt(g_topicRtmAddress, 0, "Failed to create prerequisite g_topicRtmAddress");
g_topicRtmAddress = dds_create_topic(g_participant, &RoundTripModule_Address_desc, g_topicRtmAddressName, NULL, NULL);
CU_ASSERT_FATAL(g_topicRtmAddress > 0);
g_topicRtmDataType = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, g_topicRtmDataTypeName, NULL, NULL);
cr_assert_gt(g_topicRtmDataType, 0, "Failed to create prerequisite g_topicRtmDataType");
CU_ASSERT_FATAL(g_topicRtmDataType > 0);
g_qos = dds_create_qos();
g_listener = dds_create_listener(NULL);
@ -82,24 +81,24 @@ ddsc_topic_fini(void)
*
*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_topic_create, valid) = {
DataPoints(char *, "valid", "_VALID", "Val1d", "valid_", "vA_1d"),
DataPoints(dds_qos_t**, &g_qos_null, &g_qos ),
DataPoints(dds_listener_t**, &g_list_null, &g_listener ),
CU_TheoryDataPoints(ddsc_topic_create, valid) = {
CU_DataPoints(char *, "valid", "_VALID", "Val1d", "valid_", "vA_1d"),
CU_DataPoints(dds_qos_t**, &g_qos_null, &g_qos, &g_qos_null, &g_qos_null, &g_qos_null),
CU_DataPoints(dds_listener_t**, &g_list_null, &g_listener, &g_list_null, &g_list_null, &g_list_null),
};
Theory((char *name, dds_qos_t **qos, dds_listener_t **listener), ddsc_topic_create, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Theory((char *name, dds_qos_t **qos, dds_listener_t **listener), ddsc_topic_create, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_entity_t topic;
dds_return_t ret;
topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, name, *qos, *listener);
cr_assert_gt(topic, 0, "Failed dds_create_topic(par, desc, %s, %p, %p): %s", name, *qos, *listener, dds_err_str(topic));
CU_ASSERT_FATAL(topic > 0);
ret = dds_delete(topic);
cr_assert_eq(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_create, invalid_qos, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_create, invalid_qos, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_entity_t topic;
dds_qos_t *qos = dds_create_qos();
@ -107,82 +106,82 @@ Test(ddsc_topic_create, invalid_qos, .init=ddsc_topic_init, .fini=ddsc_topic_fin
dds_qset_lifespan(qos, DDS_SECS(-1));
OS_WARNING_MSVC_OFF(28020);
topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, "inconsistent", qos, NULL);
cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_INCONSISTENT_POLICY, "returned %s", dds_err_str(topic));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_INCONSISTENT_POLICY);
dds_delete_qos(qos);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_create, non_participants, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_create, non_participants, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_entity_t topic;
topic = dds_create_topic(g_topicRtmDataType, &RoundTripModule_DataType_desc, "non_participant", NULL, NULL);
cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION, "returned %s", dds_err_str(topic));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_create, duplicate, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_create, duplicate, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_entity_t topic;
dds_return_t ret;
/* Creating the same topic should succeed. */
topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, g_topicRtmDataTypeName, NULL, NULL);
cr_assert_gt(topic, 0, "returned %s", dds_err_str(topic));
CU_ASSERT_FATAL(topic > 0);
ret = dds_delete(topic);
cr_assert_eq(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_create, same_name, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_create, same_name, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_entity_t topic;
/* Creating the different topic with same name should fail. */
topic = dds_create_topic(g_participant, &RoundTripModule_Address_desc, g_topicRtmDataTypeName, NULL, NULL);
cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %s", dds_err_str(topic));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_create, recreate, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_create, recreate, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_entity_t topic;
dds_return_t ret;
/* Re-creating previously created topic should succeed. */
ret = dds_delete(g_topicRtmDataType);
cr_assert_eq(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
topic = dds_create_topic (g_participant, &RoundTripModule_DataType_desc, g_topicRtmDataTypeName, NULL, NULL);
cr_assert_gt(topic, 0, "returned %s", dds_err_str(topic));
CU_ASSERT_FATAL(topic > 0);
ret = dds_delete(topic);
cr_assert_eq(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_create, desc_null, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_create, desc_null, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_entity_t topic;
OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
topic = dds_create_topic (g_participant, NULL, "desc_null", NULL, NULL);
OS_WARNING_MSVC_ON(6387);
cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER, "returned %s", dds_err_str(topic));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_topic_create, invalid_names) = {
DataPoints(char *, NULL, "", "mi-dle", "-start", "end-", "1st", "Thus$", "pl+s", "t(4)"),
CU_TheoryDataPoints(ddsc_topic_create, invalid_names) = {
CU_DataPoints(char *, NULL, "", "mi-dle", "-start", "end-", "1st", "Thus$", "pl+s", "t(4)"),
};
Theory((char *name), ddsc_topic_create, invalid_names, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Theory((char *name), ddsc_topic_create, invalid_names, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_entity_t topic;
topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, name, NULL, NULL);
cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER, "dds_create_topic(%s) returned %s", name, dds_err_str(topic));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -194,55 +193,55 @@ Theory((char *name), ddsc_topic_create, invalid_names, .init=ddsc_topic_init, .f
*
*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_find, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_find, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_entity_t topic;
dds_return_t ret;
topic = dds_find_topic(g_participant, g_topicRtmDataTypeName);
cr_assert_eq(topic, g_topicRtmDataType, "returned %s", dds_err_str(topic));
CU_ASSERT_EQUAL_FATAL(topic, g_topicRtmDataType);
ret = dds_delete(topic);
cr_assert_eq(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_find, non_participants, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_find, non_participants, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_entity_t topic;
topic = dds_find_topic(g_topicRtmDataType, "non_participant");
cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION, "returned %s", dds_err_str(topic));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_find, null, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_find, null, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_entity_t topic;
OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
topic = dds_find_topic(g_participant, NULL);
OS_WARNING_MSVC_ON(6387);
cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER, "returned %s", dds_err_str(topic));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_find, unknown, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_find, unknown, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_entity_t topic;
topic = dds_find_topic(g_participant, "unknown");
cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %s", dds_err_str(topic));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_find, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_find, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_entity_t topic;
dds_delete(g_topicRtmDataType);
topic = dds_find_topic(g_participant, g_topicRtmDataTypeName);
cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %s", dds_err_str(topic));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -254,66 +253,66 @@ Test(ddsc_topic_find, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
*
*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_get_name, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_get_name, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
char name[MAX_NAME_SIZE];
dds_return_t ret;
ret = dds_get_name(g_topicRtmDataType, name, MAX_NAME_SIZE);
cr_assert_eq(ret, DDS_RETCODE_OK);
cr_assert_str_eq(name, g_topicRtmDataTypeName);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_STRING_EQUAL_FATAL(name, g_topicRtmDataTypeName);
ret = dds_get_name(g_topicRtmAddress, name, MAX_NAME_SIZE);
cr_assert_eq(ret, DDS_RETCODE_OK);
cr_assert_str_eq(name, g_topicRtmAddressName);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_STRING_EQUAL_FATAL(name, g_topicRtmAddressName);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_get_name, too_small, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_get_name, too_small, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
char name[10];
dds_return_t ret;
ret = dds_get_name(g_topicRtmDataType, name, 10);
cr_assert_eq(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
g_topicRtmDataTypeName[9] = '\0';
cr_assert_str_eq(name, g_topicRtmDataTypeName);
CU_ASSERT_STRING_EQUAL_FATAL(name, g_topicRtmDataTypeName);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_get_name, non_topic, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_get_name, non_topic, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
char name[MAX_NAME_SIZE];
dds_return_t ret;
ret = dds_get_name(g_participant, name, MAX_NAME_SIZE);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %s", dds_err_str(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_topic_get_name, invalid_params) = {
DataPoints(char*, (char*)0, g_nameBuffer),
DataPoints(size_t, 0, MAX_NAME_SIZE),
CU_TheoryDataPoints(ddsc_topic_get_name, invalid_params) = {
CU_DataPoints(char*, g_nameBuffer, NULL),
CU_DataPoints(size_t, 0, MAX_NAME_SIZE),
};
Theory((char *name, size_t size), ddsc_topic_get_name, invalid_params, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Theory((char *name, size_t size), ddsc_topic_get_name, invalid_params, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_return_t ret;
cr_assume((name != g_nameBuffer) || (size != MAX_NAME_SIZE));
CU_ASSERT_FATAL((name != g_nameBuffer) || (size != MAX_NAME_SIZE));
ret = dds_get_name(g_topicRtmDataType, name, size);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %s", dds_err_str(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_get_name, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_get_name, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
char name[MAX_NAME_SIZE];
dds_return_t ret;
dds_delete(g_topicRtmDataType);
ret = dds_get_name(g_topicRtmDataType, name, MAX_NAME_SIZE);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %s", dds_err_str(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED);
}
/*************************************************************************************************/
@ -325,7 +324,7 @@ Test(ddsc_topic_get_name, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
*
*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_get_type_name, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_get_type_name, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
const char *rtmDataTypeType = "RoundTripModule::DataType";
const char *rtmAddressType = "RoundTripModule::Address";
@ -333,60 +332,60 @@ Test(ddsc_topic_get_type_name, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fi
dds_return_t ret;
ret = dds_get_type_name(g_topicRtmDataType, name, MAX_NAME_SIZE);
cr_assert_eq(ret, DDS_RETCODE_OK);
cr_assert_str_eq(name, rtmDataTypeType);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_STRING_EQUAL_FATAL(name, rtmDataTypeType);
ret = dds_get_type_name(g_topicRtmAddress, name, MAX_NAME_SIZE);
cr_assert_eq(ret, DDS_RETCODE_OK);
cr_assert_str_eq(name, rtmAddressType);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_STRING_EQUAL_FATAL(name, rtmAddressType);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_get_type_name, too_small, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_get_type_name, too_small, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
const char *rtmDataTypeType = "RoundTrip";
char name[10];
dds_return_t ret;
ret = dds_get_type_name(g_topicRtmDataType, name, 10);
cr_assert_eq(ret, DDS_RETCODE_OK);
cr_assert_str_eq(name, rtmDataTypeType);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_STRING_EQUAL_FATAL(name, rtmDataTypeType);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_get_type_name, non_topic, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_get_type_name, non_topic, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
char name[MAX_NAME_SIZE];
dds_return_t ret;
ret = dds_get_type_name(g_participant, name, MAX_NAME_SIZE);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %s", dds_err_str(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_topic_get_type_name, invalid_params) = {
DataPoints(char*, (char*)0, g_nameBuffer),
DataPoints(size_t, 0, MAX_NAME_SIZE),
CU_TheoryDataPoints(ddsc_topic_get_type_name, invalid_params) = {
CU_DataPoints(char*, g_nameBuffer, NULL),
CU_DataPoints(size_t, 0, MAX_NAME_SIZE),
};
Theory((char *name, size_t size), ddsc_topic_get_type_name, invalid_params, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Theory((char *name, size_t size), ddsc_topic_get_type_name, invalid_params, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_return_t ret;
cr_assume((name != g_nameBuffer) || (size != MAX_NAME_SIZE));
CU_ASSERT_FATAL((name != g_nameBuffer) || (size != MAX_NAME_SIZE));
ret = dds_get_type_name(g_topicRtmDataType, name, size);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %s", dds_err_str(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_get_type_name, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_get_type_name, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
char name[MAX_NAME_SIZE];
dds_return_t ret;
dds_delete(g_topicRtmDataType);
ret = dds_get_type_name(g_topicRtmDataType, name, MAX_NAME_SIZE);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %s", dds_err_str(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED);
}
/*************************************************************************************************/
@ -398,34 +397,34 @@ Test(ddsc_topic_get_type_name, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_
*
*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_set_qos, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_set_qos, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_return_t ret;
/* Latency is the only one allowed to change. */
dds_qset_latency_budget(g_qos, DDS_SECS(1));
ret = dds_set_qos(g_topicRtmDataType, g_qos);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_UNSUPPORTED, "returned %s", dds_err_str(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_UNSUPPORTED);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_set_qos, inconsistent, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_set_qos, inconsistent, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_return_t ret;
OS_WARNING_MSVC_OFF(28020); /* Disable SAL warning on intentional misuse of the API */
dds_qset_lifespan(g_qos, DDS_SECS(-1));
OS_WARNING_MSVC_ON(28020);
ret = dds_set_qos(g_topicRtmDataType, g_qos);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_INCONSISTENT_POLICY, "returned %s", dds_err_str(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_INCONSISTENT_POLICY);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_topic_set_qos, immutable, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
CU_Test(ddsc_topic_set_qos, immutable, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
{
dds_return_t ret;
dds_qset_destination_order(g_qos, DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP); /* Immutable */
ret = dds_set_qos(g_topicRtmDataType, g_qos);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_IMMUTABLE_POLICY, "returned %s", dds_err_str(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_IMMUTABLE_POLICY);
}
/*************************************************************************************************/

38
src/core/ddsc/tests/transientlocal.c
View file

@ -12,12 +12,10 @@
#include <stdio.h>
#include "ddsc/dds.h"
#include "Space.h"
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
#define TRACE_SAMPLE(info, sample) cr_log_info("%s (%d, %d, %d)\n", info, sample.long_1, sample.long_2, sample.long_3);
#define MAX_SAMPLES (7)
Test(ddsc_transient_local, late_joiner)
CU_Test(ddsc_transient_local, late_joiner)
{
Space_Type1 sample = { 0, 0, 0 };
dds_return_t ret;
@ -45,60 +43,54 @@ Test(ddsc_transient_local, late_joiner)
/* Create participant and topic. */
par = dds_create_participant(DDS_DOMAIN_DEFAULT, qos, NULL);
cr_assert_gt(par, 0, "Failed to create prerequisite par");
CU_ASSERT_FATAL(par > 0);
top = dds_create_topic(par, &Space_Type1_desc, "ddsc_transient_local_happy_days", qos, NULL);
cr_assert_gt(par, 0, "Failed to create prerequisite top");
CU_ASSERT_FATAL(par > 0);
/* Create publishing entities. */
cr_log_info("Create writer\n");
pub = dds_create_publisher(par, qos, NULL);
cr_assert_gt(pub, 0, "Failed to create prerequisite pub");
CU_ASSERT_FATAL(pub > 0);
wrt = dds_create_writer(pub, top, qos, NULL);
cr_assert_gt(wrt, 0, "Failed to create prerequisite wrt");
CU_ASSERT_FATAL(wrt > 0);
/* Write first set of samples. */
sample.long_1 = 1;
sample.long_2 = 1;
sample.long_3 = 1;
TRACE_SAMPLE("Write ", sample);
ret = dds_write(wrt, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
sample.long_1 = 2;
sample.long_2 = 2;
sample.long_3 = 2;
TRACE_SAMPLE("Write ", sample);
ret = dds_write(wrt, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Create subscribing entities. */
cr_log_info("Create reader\n");
sub = dds_create_subscriber(par, qos, NULL);
cr_assert_gt(sub, 0, "Failed to create prerequisite sub");
CU_ASSERT_FATAL(sub > 0);
rdr = dds_create_reader(sub, top, qos, NULL);
cr_assert_gt(rdr, 0, "Failed to create prerequisite g_reader");
CU_ASSERT_FATAL(rdr > 0);
/* Write second set of samples. */
sample.long_1 = 8;
sample.long_2 = 8;
sample.long_3 = 8;
TRACE_SAMPLE("Write ", sample);
ret = dds_write(wrt, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
sample.long_1 = 9;
sample.long_2 = 9;
sample.long_3 = 9;
TRACE_SAMPLE("Write ", sample);
ret = dds_write(wrt, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Read samples, which should be all four. */
ret = dds_read(rdr, samples, info, MAX_SAMPLES, MAX_SAMPLES);
cr_log_info("Read cnt %d\n", ret);
#if 0
for(int i = 0; i < ret; i++) {
Space_Type1 *sample = (Space_Type1*)samples[i];
TRACE_SAMPLE("Read ", (*sample));
}
cr_assert_eq(ret, 4, "# read %d, expected 4", ret);
#endif
CU_ASSERT_EQUAL_FATAL(ret, 4);
dds_delete(par);
dds_delete_qos(qos);

41
src/core/ddsc/tests/types.c
View file

@ -9,8 +9,7 @@
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
#include "ddsc/dds.h"
#include "TypesArrayKey.h"
@ -24,14 +23,14 @@
for( unsigned i = 0; i < (sizeof data.key / sizeof *data.key); i++) data.key[i] = (init); \
\
par = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); \
cr_assert_gt(par, 0); \
CU_ASSERT_FATAL(par > 0); \
top = dds_create_topic(par, &TypesArrayKey_##type##_arraytypekey_desc, strfy(type), NULL, NULL); \
cr_assert_gt(top, 0); \
CU_ASSERT_FATAL(top > 0); \
wri = dds_create_writer(par, top, NULL, NULL); \
cr_assert_gt(wri, 0); \
CU_ASSERT_FATAL(wri > 0); \
\
status = dds_write(wri, &data); \
cr_assert_eq(dds_err_nr(status), DDS_RETCODE_OK); \
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK); \
\
dds_delete(wri); \
dds_delete(top); \
@ -39,57 +38,57 @@
} while (0)
Test(ddsc_types, long_arraytypekey)
CU_Test(ddsc_types, long_arraytypekey)
{
DDSC_ARRAYTYPEKEY_TEST(long, 1);
}
Test(ddsc_types, longlong_arraytypekey)
CU_Test(ddsc_types, longlong_arraytypekey)
{
DDSC_ARRAYTYPEKEY_TEST(longlong, 1);
}
Test(ddsc_types, unsignedshort_arraytypekey)
CU_Test(ddsc_types, unsignedshort_arraytypekey)
{
DDSC_ARRAYTYPEKEY_TEST(unsignedshort, 1);
}
Test(ddsc_types, unsignedlong_arraytypekey)
CU_Test(ddsc_types, unsignedlong_arraytypekey)
{
DDSC_ARRAYTYPEKEY_TEST(unsignedlong, 1);
}
Test(ddsc_types, unsignedlonglong_arraytypekey)
CU_Test(ddsc_types, unsignedlonglong_arraytypekey)
{
DDSC_ARRAYTYPEKEY_TEST(unsignedlonglong, 1);
}
Test(ddsc_types, float_arraytypekey)
CU_Test(ddsc_types, float_arraytypekey)
{
DDSC_ARRAYTYPEKEY_TEST(float, 1.0f);
}
Test(ddsc_types, double_arraytypekey)
CU_Test(ddsc_types, double_arraytypekey)
{
DDSC_ARRAYTYPEKEY_TEST(double, 1.0f);
}
Test(ddsc_types, char_arraytypekey)
CU_Test(ddsc_types, char_arraytypekey)
{
DDSC_ARRAYTYPEKEY_TEST(char, '1');
}
Test(ddsc_types, boolean_arraytypekey)
CU_Test(ddsc_types, boolean_arraytypekey)
{
DDSC_ARRAYTYPEKEY_TEST(boolean, true);
}
Test(ddsc_types, octet_arraytypekey)
CU_Test(ddsc_types, octet_arraytypekey)
{
DDSC_ARRAYTYPEKEY_TEST(octet, 1);
}
Test(ddsc_types, alltypeskey)
CU_Test(ddsc_types, alltypeskey)
{
dds_return_t status;
dds_entity_t par, top, wri;
@ -108,14 +107,14 @@ Test(ddsc_types, alltypeskey)
};
par = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(par, 0);
CU_ASSERT_FATAL(par > 0);
top = dds_create_topic(par, &TypesArrayKey_alltypeskey_desc, "AllTypesKey", NULL, NULL);
cr_assert_gt(top, 0);
CU_ASSERT_FATAL(top > 0);
wri = dds_create_writer(par, top, NULL, NULL);
cr_assert_gt(wri, 0);
CU_ASSERT_FATAL(wri > 0);
status = dds_write(wri, &atk_data);
cr_assert_eq(dds_err_nr(status), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK);
dds_delete(wri);
dds_delete(top);

389
src/core/ddsc/tests/unregister.c
View file

@ -13,9 +13,8 @@
#include "ddsc/dds.h"
#include "os/os.h"
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include <criterion/theories.h>
#include "CUnit/Test.h"
#include "CUnit/Theory.h"
#include "Space.h"
@ -63,46 +62,46 @@ unregistering_init(void)
dds_qset_destination_order(qos, DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP);
g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant");
CU_ASSERT_FATAL(g_participant > 0);
g_waitset = dds_create_waitset(g_participant);
cr_assert_gt(g_waitset, 0, "Failed to create g_waitset");
CU_ASSERT_FATAL(g_waitset > 0);
g_topic = dds_create_topic(g_participant, &Space_Type1_desc, create_topic_name("ddsc_unregistering_test", name, 100), qos, NULL);
cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic");
CU_ASSERT_FATAL(g_topic > 0);
/* Create a reader that keeps one sample on three instances. */
dds_qset_reliability(qos, DDS_RELIABILITY_RELIABLE, DDS_MSECS(100));
dds_qset_resource_limits(qos, DDS_LENGTH_UNLIMITED, 3, 1);
g_reader = dds_create_reader(g_participant, g_topic, qos, NULL);
cr_assert_gt(g_reader, 0, "Failed to create prerequisite g_reader");
CU_ASSERT_FATAL(g_reader > 0);
/* Create a writer that will not automatically dispose unregistered samples. */
dds_qset_writer_data_lifecycle(qos, false);
g_writer = dds_create_writer(g_participant, g_topic, qos, NULL);
cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer");
CU_ASSERT_FATAL(g_writer > 0);
/* Sync g_writer to g_reader. */
ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_writer status");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_attach(g_waitset, g_writer, g_writer);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_writer");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1));
cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_writer r");
cr_assert_eq(g_writer, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_writer a");
CU_ASSERT_EQUAL_FATAL(ret, 1);
CU_ASSERT_EQUAL_FATAL(g_writer, (dds_entity_t)(intptr_t)triggered);
ret = dds_waitset_detach(g_waitset, g_writer);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_writer");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Sync g_reader to g_writer. */
ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1));
cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_reader r");
cr_assert_eq(g_reader, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_reader a");
CU_ASSERT_EQUAL_FATAL(ret, 1);
CU_ASSERT_EQUAL_FATAL(g_reader, (dds_entity_t)(intptr_t)triggered);
ret = dds_waitset_detach(g_waitset, g_reader);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_reader");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Write initial samples. */
for (int i = 0; i < INITIAL_SAMPLES; i++) {
@ -110,7 +109,7 @@ unregistering_init(void)
sample.long_2 = i*2;
sample.long_3 = i*3;
ret = dds_write(g_writer, &sample);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/* Initialize reading buffers. */
@ -145,87 +144,87 @@ unregistering_fini(void)
*
*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_unregister_instance, deleted, .init=unregistering_init, .fini=unregistering_fini)
CU_Test(ddsc_unregister_instance, deleted, .init=unregistering_init, .fini=unregistering_fini)
{
dds_return_t ret;
dds_delete(g_writer);
ret = dds_unregister_instance(g_writer, g_data);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_unregister_instance, null, .init=unregistering_init, .fini=unregistering_fini)
CU_Test(ddsc_unregister_instance, null, .init=unregistering_init, .fini=unregistering_fini)
{
dds_return_t ret;
ret = dds_unregister_instance(g_writer, NULL);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_unregister_instance, invalid_writers) = {
DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
CU_TheoryDataPoints(ddsc_unregister_instance, invalid_writers) = {
CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
};
Theory((dds_entity_t writer), ddsc_unregister_instance, invalid_writers, .init=unregistering_init, .fini=unregistering_fini)
CU_Theory((dds_entity_t writer), ddsc_unregister_instance, invalid_writers, .init=unregistering_init, .fini=unregistering_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_unregister_instance(writer, g_data);
cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_unregister_instance, non_writers) = {
DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant),
CU_TheoryDataPoints(ddsc_unregister_instance, non_writers) = {
CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant),
};
Theory((dds_entity_t *writer), ddsc_unregister_instance, non_writers, .init=unregistering_init, .fini=unregistering_fini)
CU_Theory((dds_entity_t *writer), ddsc_unregister_instance, non_writers, .init=unregistering_init, .fini=unregistering_fini)
{
dds_return_t ret;
ret = dds_unregister_instance(*writer, g_data);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_unregister_instance, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini)
CU_Test(ddsc_unregister_instance, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini)
{
Space_Type1 oldInstance = { 0, 22, 22 };
dds_return_t ret;
ret = dds_unregister_instance(g_writer, &oldInstance);
cr_assert_eq(ret, DDS_RETCODE_OK, "Unregistering old instance returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Read all available samples. */
ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2);
CU_ASSERT_EQUAL_FATAL(ret, 2);
for(int i = 0; i < ret; i++) {
Space_Type1 *sample = (Space_Type1*)g_samples[i];
if (sample->long_1 == 0) {
/* Check data. */
cr_assert_eq(sample->long_2, 0);
cr_assert_eq(sample->long_3, 0);
CU_ASSERT_EQUAL_FATAL(sample->long_2, 0);
CU_ASSERT_EQUAL_FATAL(sample->long_3, 0);
/* Check states. */
cr_assert_eq(g_info[i].valid_data, true);
cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ);
cr_assert_eq(g_info[i].view_state, DDS_VST_NEW);
cr_assert_eq(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ);
CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW);
CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
} else if (sample->long_1 == 1) {
/* Check data. */
cr_assert_eq(sample->long_2, sample->long_1 * 2);
cr_assert_eq(sample->long_3, sample->long_1 * 3);
CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2);
CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3);
/* Check states. */
cr_assert_eq(g_info[i].valid_data, true);
cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ);
cr_assert_eq(g_info[i].view_state, DDS_VST_NEW);
cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE);
CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ);
CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW);
CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE);
} else {
cr_assert(false, "Unknown sample read");
CU_FAIL_FATAL("Unknown sample read");
}
}
}
@ -240,93 +239,93 @@ Test(ddsc_unregister_instance, unregistering_old_instance, .init=unregistering_i
*
*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_unregister_instance_ts, deleted, .init=unregistering_init, .fini=unregistering_fini)
CU_Test(ddsc_unregister_instance_ts, deleted, .init=unregistering_init, .fini=unregistering_fini)
{
dds_return_t ret;
dds_delete(g_writer);
ret = dds_unregister_instance_ts(g_writer, g_data, g_present);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_unregister_instance_ts, null, .init=unregistering_init, .fini=unregistering_fini)
CU_Test(ddsc_unregister_instance_ts, null, .init=unregistering_init, .fini=unregistering_fini)
{
dds_return_t ret;
ret = dds_unregister_instance_ts(g_writer, NULL, g_present);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_unregister_instance_ts, invalid_writers) = {
DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
CU_TheoryDataPoints(ddsc_unregister_instance_ts, invalid_writers) = {
CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
};
Theory((dds_entity_t writer), ddsc_unregister_instance_ts, invalid_writers, .init=unregistering_init, .fini=unregistering_fini)
CU_Theory((dds_entity_t writer), ddsc_unregister_instance_ts, invalid_writers, .init=unregistering_init, .fini=unregistering_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_unregister_instance_ts(writer, g_data, g_present);
cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_unregister_instance_ts, non_writers) = {
DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant),
CU_TheoryDataPoints(ddsc_unregister_instance_ts, non_writers) = {
CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant),
};
Theory((dds_entity_t *writer), ddsc_unregister_instance_ts, non_writers, .init=unregistering_init, .fini=unregistering_fini)
CU_Theory((dds_entity_t *writer), ddsc_unregister_instance_ts, non_writers, .init=unregistering_init, .fini=unregistering_fini)
{
dds_return_t ret;
ret = dds_unregister_instance_ts(*writer, g_data, g_present);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_unregister_instance_ts, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini)
CU_Test(ddsc_unregister_instance_ts, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini)
{
Space_Type1 oldInstance = { 0, 22, 22 };
dds_return_t ret;
ret = dds_unregister_instance_ts(g_writer, &oldInstance, g_present);
cr_assert_eq(ret, DDS_RETCODE_OK, "Unregistering old instance returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Read all available samples. */
ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2);
CU_ASSERT_EQUAL_FATAL(ret, 2);
for(int i = 0; i < ret; i++) {
Space_Type1 *sample = (Space_Type1*)g_samples[i];
if (sample->long_1 == 0) {
/* Check data (data part of unregister is not used, only the key part). */
cr_assert_eq(sample->long_2, sample->long_1 * 2);
cr_assert_eq(sample->long_3, sample->long_1 * 3);
CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2);
CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3);
/* Check states. */
cr_assert_eq(g_info[i].valid_data, true);
cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ);
cr_assert_eq(g_info[i].view_state, DDS_VST_NEW);
cr_assert_eq(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ);
CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW);
CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
} else if (sample->long_1 == 1) {
/* Check data. */
cr_assert_eq(sample->long_2, sample->long_1 * 2);
cr_assert_eq(sample->long_3, sample->long_1 * 3);
CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2);
CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3);
/* Check states. */
cr_assert_eq(g_info[i].valid_data, true);
cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ);
cr_assert_eq(g_info[i].view_state, DDS_VST_NEW);
cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE);
CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ);
CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW);
CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE);
} else {
cr_assert(false, "Unknown sample read");
CU_FAIL_FATAL( "Unknown sample read");
}
}
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_unregister_instance_ts, unregistering_past_sample, .init=unregistering_init, .fini=unregistering_fini)
CU_Test(ddsc_unregister_instance_ts, unregistering_past_sample, .init=unregistering_init, .fini=unregistering_fini)
{
Space_Type1 oldInstance = { 0, 0, 0 };
dds_attach_t triggered;
@ -334,34 +333,34 @@ Test(ddsc_unregister_instance_ts, unregistering_past_sample, .init=unregistering
/* Unregistering a sample in the past should trigger a lost sample. */
ret = dds_set_enabled_status(g_reader, DDS_SAMPLE_LOST_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Now, unregister a sample in the past. */
ret = dds_unregister_instance_ts(g_writer, &oldInstance, g_past);
cr_assert_eq(ret, DDS_RETCODE_OK, "Unregistering old instance returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Wait for 'sample lost'. */
ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1));
cr_assert_eq(ret, 1, "Unregistering past sample did not trigger 'sample lost'");
CU_ASSERT_EQUAL_FATAL(ret, 1);
/* Read all available samples. */
ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2);
CU_ASSERT_EQUAL_FATAL(ret, 2);
for(int i = 0; i < ret; i++) {
Space_Type1 *sample = (Space_Type1*)g_samples[i];
if ((sample->long_1 == 0) || (sample->long_1 == 1)) {
/* Check data. */
cr_assert_eq(sample->long_2, sample->long_1 * 2);
cr_assert_eq(sample->long_3, sample->long_1 * 3);
CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2);
CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3);
/* Check states. */
cr_assert_eq(g_info[i].valid_data, true);
cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ);
cr_assert_eq(g_info[i].view_state, DDS_VST_NEW);
CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ);
CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW);
} else {
cr_assert(false, "Unknown sample read");
CU_FAIL_FATAL("Unknown sample read");
}
}
@ -377,90 +376,90 @@ Test(ddsc_unregister_instance_ts, unregistering_past_sample, .init=unregistering
*
*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_unregister_instance_ih, deleted, .init=unregistering_init, .fini=unregistering_fini)
CU_Test(ddsc_unregister_instance_ih, deleted, .init=unregistering_init, .fini=unregistering_fini)
{
dds_return_t ret;
dds_delete(g_writer);
ret = dds_unregister_instance_ih(g_writer, DDS_HANDLE_NIL);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_unregister_instance_ih, invalid_handles) = {
DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX),
CU_TheoryDataPoints(ddsc_unregister_instance_ih, invalid_handles) = {
CU_DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX),
};
Theory((dds_instance_handle_t handle), ddsc_unregister_instance_ih, invalid_handles, .init=unregistering_init, .fini=unregistering_fini)
CU_Theory((dds_instance_handle_t handle), ddsc_unregister_instance_ih, invalid_handles, .init=unregistering_init, .fini=unregistering_fini)
{
dds_return_t ret;
ret = dds_unregister_instance_ih(g_writer, handle);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_unregister_instance_ih, invalid_writers) = {
DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
CU_TheoryDataPoints(ddsc_unregister_instance_ih, invalid_writers) = {
CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
};
Theory((dds_entity_t writer), ddsc_unregister_instance_ih, invalid_writers, .init=unregistering_init, .fini=unregistering_fini)
CU_Theory((dds_entity_t writer), ddsc_unregister_instance_ih, invalid_writers, .init=unregistering_init, .fini=unregistering_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_unregister_instance_ih(writer, DDS_HANDLE_NIL);
cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_unregister_instance_ih, non_writers) = {
DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant),
CU_TheoryDataPoints(ddsc_unregister_instance_ih, non_writers) = {
CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant),
};
Theory((dds_entity_t *writer), ddsc_unregister_instance_ih, non_writers, .init=unregistering_init, .fini=unregistering_fini)
CU_Theory((dds_entity_t *writer), ddsc_unregister_instance_ih, non_writers, .init=unregistering_init, .fini=unregistering_fini)
{
dds_return_t ret;
ret = dds_unregister_instance_ih(*writer, DDS_HANDLE_NIL);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_unregister_instance_ih, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini)
CU_Test(ddsc_unregister_instance_ih, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini)
{
Space_Type1 oldInstance = { 0, 22, 22 };
dds_instance_handle_t hdl = dds_instance_lookup(g_writer, &oldInstance);
dds_return_t ret;
ret = dds_unregister_instance_ih(g_writer, hdl);
cr_assert_eq(ret, DDS_RETCODE_OK, "Unregistering old instance returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Read all available samples. */
ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2);
CU_ASSERT_EQUAL_FATAL(ret, 2);
for(int i = 0; i < ret; i++) {
Space_Type1 *sample = (Space_Type1*)g_samples[i];
if (sample->long_1 == 0) {
/* Check data. */
cr_assert_eq(sample->long_2, 0);
cr_assert_eq(sample->long_3, 0);
CU_ASSERT_EQUAL_FATAL(sample->long_2, 0);
CU_ASSERT_EQUAL_FATAL(sample->long_3, 0);
/* Check states. */
cr_assert_eq(g_info[i].valid_data, true);
cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ);
cr_assert_eq(g_info[i].view_state, DDS_VST_NEW);
cr_assert_eq(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ);
CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW);
CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
} else if (sample->long_1 == 1) {
/* Check data. */
cr_assert_eq(sample->long_2, sample->long_1 * 2);
cr_assert_eq(sample->long_3, sample->long_1 * 3);
CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2);
CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3);
/* Check states. */
cr_assert_eq(g_info[i].valid_data, true);
cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ);
cr_assert_eq(g_info[i].view_state, DDS_VST_NEW);
cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE);
CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ);
CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW);
CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE);
} else {
cr_assert(false, "Unknown sample read");
CU_FAIL_FATAL("Unknown sample read");
}
}
}
@ -475,97 +474,97 @@ Test(ddsc_unregister_instance_ih, unregistering_old_instance, .init=unregisterin
*
*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_unregister_instance_ih_ts, deleted, .init=unregistering_init, .fini=unregistering_fini)
CU_Test(ddsc_unregister_instance_ih_ts, deleted, .init=unregistering_init, .fini=unregistering_fini)
{
dds_return_t ret;
dds_delete(g_writer);
ret = dds_unregister_instance_ih_ts(g_writer, DDS_HANDLE_NIL, g_present);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_unregister_instance_ih_ts, invalid_handles) = {
DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX),
CU_TheoryDataPoints(ddsc_unregister_instance_ih_ts, invalid_handles) = {
CU_DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX),
};
Theory((dds_instance_handle_t handle), ddsc_unregister_instance_ih_ts, invalid_handles, .init=unregistering_init, .fini=unregistering_fini)
CU_Theory((dds_instance_handle_t handle), ddsc_unregister_instance_ih_ts, invalid_handles, .init=unregistering_init, .fini=unregistering_fini)
{
dds_return_t ret;
ret = dds_unregister_instance_ih_ts(g_writer, handle, g_present);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_unregister_instance_ih_ts, invalid_writers) = {
DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
CU_TheoryDataPoints(ddsc_unregister_instance_ih_ts, invalid_writers) = {
CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN),
};
Theory((dds_entity_t writer), ddsc_unregister_instance_ih_ts, invalid_writers, .init=unregistering_init, .fini=unregistering_fini)
CU_Theory((dds_entity_t writer), ddsc_unregister_instance_ih_ts, invalid_writers, .init=unregistering_init, .fini=unregistering_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_unregister_instance_ih_ts(writer, DDS_HANDLE_NIL, g_present);
cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
}
/*************************************************************************************************/
/*************************************************************************************************/
TheoryDataPoints(ddsc_unregister_instance_ih_ts, non_writers) = {
DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant),
CU_TheoryDataPoints(ddsc_unregister_instance_ih_ts, non_writers) = {
CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant),
};
Theory((dds_entity_t *writer), ddsc_unregister_instance_ih_ts, non_writers, .init=unregistering_init, .fini=unregistering_fini)
CU_Theory((dds_entity_t *writer), ddsc_unregister_instance_ih_ts, non_writers, .init=unregistering_init, .fini=unregistering_fini)
{
dds_return_t ret;
ret = dds_unregister_instance_ih_ts(*writer, DDS_HANDLE_NIL, g_present);
cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_unregister_instance_ih_ts, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini)
CU_Test(ddsc_unregister_instance_ih_ts, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini)
{
Space_Type1 oldInstance = { 0, 22, 22 };
dds_instance_handle_t hdl = dds_instance_lookup(g_writer, &oldInstance);
dds_return_t ret;
ret = dds_unregister_instance_ih_ts(g_writer, hdl, g_present);
cr_assert_eq(ret, DDS_RETCODE_OK, "Unregistering old instance returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Read all available samples. */
ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2);
CU_ASSERT_EQUAL_FATAL(ret, 2);
for(int i = 0; i < ret; i++) {
Space_Type1 *sample = (Space_Type1*)g_samples[i];
if (sample->long_1 == 0) {
/* Check data (data part of unregister is not used, only the key part). */
cr_assert_eq(sample->long_2, sample->long_1 * 2);
cr_assert_eq(sample->long_3, sample->long_1 * 3);
CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2);
CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3);
/* Check states. */
cr_assert_eq(g_info[i].valid_data, true);
cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ);
cr_assert_eq(g_info[i].view_state, DDS_VST_NEW);
cr_assert_eq(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ);
CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW);
CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE);
} else if (sample->long_1 == 1) {
/* Check data. */
cr_assert_eq(sample->long_2, sample->long_1 * 2);
cr_assert_eq(sample->long_3, sample->long_1 * 3);
CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2);
CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3);
/* Check states. */
cr_assert_eq(g_info[i].valid_data, true);
cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ);
cr_assert_eq(g_info[i].view_state, DDS_VST_NEW);
cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE);
CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ);
CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW);
CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE);
} else {
cr_assert(false, "Unknown sample read");
CU_FAIL_FATAL("Unknown sample read");
}
}
}
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_unregister_instance_ih_ts, unregistering_past_sample, .init=unregistering_init, .fini=unregistering_fini)
CU_Test(ddsc_unregister_instance_ih_ts, unregistering_past_sample, .init=unregistering_init, .fini=unregistering_fini)
{
Space_Type1 oldInstance = { 0, 0, 0 };
dds_instance_handle_t hdl = dds_instance_lookup(g_writer, &oldInstance);
@ -574,34 +573,34 @@ Test(ddsc_unregister_instance_ih_ts, unregistering_past_sample, .init=unregister
/* Unregistering a sample in the past should trigger a lost sample. */
ret = dds_set_enabled_status(g_reader, DDS_SAMPLE_LOST_STATUS);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Now, unregister a sample in the past. */
ret = dds_unregister_instance_ih_ts(g_writer, hdl, g_past);
cr_assert_eq(ret, DDS_RETCODE_OK, "Unregistering old instance returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Wait for 'sample lost'. */
ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1));
cr_assert_eq(ret, 1, "Unregistering past sample did not trigger 'sample lost'");
CU_ASSERT_EQUAL_FATAL(ret, 1);
/* Read all available samples. */
ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2);
CU_ASSERT_EQUAL_FATAL(ret, 2);
for(int i = 0; i < ret; i++) {
Space_Type1 *sample = (Space_Type1*)g_samples[i];
if ((sample->long_1 == 0) || (sample->long_1 == 1)) {
/* Check data. */
cr_assert_eq(sample->long_2, sample->long_1 * 2);
cr_assert_eq(sample->long_3, sample->long_1 * 3);
CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2);
CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3);
/* Check states. */
cr_assert_eq(g_info[i].valid_data, true);
cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ);
cr_assert_eq(g_info[i].view_state, DDS_VST_NEW);
CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ);
CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW);
} else {
cr_assert(false, "Unknown sample read");
CU_FAIL_FATAL("Unknown sample read");
}
}
@ -609,48 +608,48 @@ Test(ddsc_unregister_instance_ih_ts, unregistering_past_sample, .init=unregister
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_unregister_instance, dispose_unregistered_sample, .init=unregistering_init, .fini=unregistering_fini)
CU_Test(ddsc_unregister_instance, dispose_unregistered_sample, .init=unregistering_init, .fini=unregistering_fini)
{
dds_entity_t writer;
writer = dds_create_writer(g_participant, g_topic, NULL, NULL);
cr_assert_gt(g_writer, 0, "Failed to create writer");
CU_ASSERT_FATAL(g_writer > 0);
Space_Type1 newInstance = { INITIAL_SAMPLES, 0, 0 };
dds_return_t ret;
ret = dds_write(writer, &newInstance);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed write");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_unregister_instance(writer, &newInstance);
cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing unregistered sample returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Read all available samples. */
ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
cr_assert_eq(ret, 3, "# read %d, expected %d", ret, 3);
CU_ASSERT_EQUAL_FATAL(ret, 3);
for(int i = 0; i < ret; i++) {
Space_Type1 *sample = (Space_Type1*)g_samples[i];
if (sample->long_1 <= 1) {
/* Check data. */
cr_assert_eq(sample->long_2, sample->long_1 * 2);
cr_assert_eq(sample->long_3, sample->long_1 * 3);
CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2);
CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3);
/* Check states. */
cr_assert_eq(g_info[i].valid_data, true);
cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ);
cr_assert_eq(g_info[i].view_state, DDS_VST_NEW);
cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE);
CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ);
CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW);
CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE);
} else if (sample->long_1 == 2) {
/* Check data. */
cr_assert_eq(sample->long_2, 0);
cr_assert_eq(sample->long_3, 0);
CU_ASSERT_EQUAL_FATAL(sample->long_2, 0);
CU_ASSERT_EQUAL_FATAL(sample->long_3, 0);
/* Check states. */
cr_assert_eq(g_info[i].valid_data, true);
cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ);
cr_assert_eq(g_info[i].view_state, DDS_VST_NEW);
cr_assert_eq(g_info[i].instance_state, DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE);
CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ);
CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW);
CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE);
} else {
cr_assert(false, "Unknown sample read");
CU_FAIL_FATAL("Unknown sample read");
}
}
dds_delete(writer);
@ -658,48 +657,48 @@ Test(ddsc_unregister_instance, dispose_unregistered_sample, .init=unregistering_
/*************************************************************************************************/
/*************************************************************************************************/
Test(ddsc_unregister_instance_ts, dispose_unregistered_sample, .init=unregistering_init, .fini=unregistering_fini)
CU_Test(ddsc_unregister_instance_ts, dispose_unregistered_sample, .init=unregistering_init, .fini=unregistering_fini)
{
dds_entity_t writer;
writer = dds_create_writer(g_participant, g_topic, NULL, NULL);
cr_assert_gt(g_writer, 0, "Failed to create writer");
CU_ASSERT_FATAL(g_writer > 0);
Space_Type1 newInstance = { INITIAL_SAMPLES, 0, 0 };
dds_return_t ret;
ret = dds_write(writer, &newInstance);
cr_assert_eq(ret, DDS_RETCODE_OK, "Failed write");
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_unregister_instance(writer, &newInstance);
cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing unregistered sample returned %d", dds_err_nr(ret));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Read all available samples. */
ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
cr_assert_eq(ret, 3, "# read %d, expected %d", ret, 3);
CU_ASSERT_EQUAL_FATAL(ret, 3);
for(int i = 0; i < ret; i++) {
Space_Type1 *sample = (Space_Type1*)g_samples[i];
if (sample->long_1 <= 1) {
/* Check data. */
cr_assert_eq(sample->long_2, sample->long_1 * 2);
cr_assert_eq(sample->long_3, sample->long_1 * 3);
CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2);
CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3);
/* Check states. */
cr_assert_eq(g_info[i].valid_data, true);
cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ);
cr_assert_eq(g_info[i].view_state, DDS_VST_NEW);
cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE);
CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ);
CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW);
CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE);
} else if (sample->long_1 == 2) {
/* Check data. */
cr_assert_eq(sample->long_2, 0);
cr_assert_eq(sample->long_3, 0);
CU_ASSERT_EQUAL_FATAL(sample->long_2, 0);
CU_ASSERT_EQUAL_FATAL(sample->long_3, 0);
/* Check states. */
cr_assert_eq(g_info[i].valid_data, true);
cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ);
cr_assert_eq(g_info[i].view_state, DDS_VST_NEW);
cr_assert_eq(g_info[i].instance_state, DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE);
CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true);
CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ);
CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW);
CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE);
} else {
cr_assert(false, "Unknown sample read");
CU_FAIL_FATAL("Unknown sample read");
}
}
dds_delete(writer);

168
src/core/ddsc/tests/unsupported.c
View file

@ -10,9 +10,7 @@
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include <stdio.h>
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include <criterion/parameterized.h>
#include "CUnit/Test.h"
#include "ddsc/dds.h"
#include "RoundTrip.h"
@ -30,23 +28,28 @@ static dds_entity_t e[8];
#define RCD (6) /* ReadCondition */
#define BAD (7) /* Bad (non-entity) */
struct index_result {
unsigned index;
dds_return_t exp_res;
};
static void
setup(void)
{
e[PAR] = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(e[PAR], 0);
CU_ASSERT_FATAL(e[PAR] > 0);
e[TOP] = dds_create_topic(e[PAR], &RoundTripModule_DataType_desc, "RoundTrip", NULL, NULL);
cr_assert_gt(e[TOP], 0);
CU_ASSERT_FATAL(e[TOP] > 0);
e[PUB] = dds_create_publisher(e[PAR], NULL, NULL);
cr_assert_gt(e[PUB], 0);
CU_ASSERT_FATAL(e[PUB] > 0);
e[WRI] = dds_create_writer(e[PUB], e[TOP], NULL, NULL);
cr_assert_gt(e[WRI], 0);
CU_ASSERT_FATAL(e[WRI] > 0);
e[SUB] = dds_create_subscriber(e[PAR], NULL, NULL);
cr_assert_gt(e[SUB], 0);
CU_ASSERT_FATAL(e[SUB] > 0);
e[REA] = dds_create_reader(e[SUB], e[TOP], NULL, NULL);
cr_assert_gt(e[REA], 0);
CU_ASSERT_FATAL(e[REA] > 0);
e[RCD] = dds_create_readcondition(e[REA], DDS_ANY_STATE);
cr_assert_gt(e[RCD], 0);
CU_ASSERT_FATAL(e[RCD] > 0);
e[BAD] = 1;
}
@ -59,124 +62,97 @@ teardown(void)
}
/*************************************************************************************************/
struct index_result {
unsigned index;
dds_return_t exp_res;
};
/*************************************************************************************************/
ParameterizedTestParameters(ddsc_unsupported, dds_begin_end_coherent) {
/* The parameters seem to be initialized before spawning children,
* so it makes no sense to try and store anything dynamic here. */
static struct index_result pars[] = {
{PUB, DDS_RETCODE_UNSUPPORTED},
{WRI, DDS_RETCODE_UNSUPPORTED},
{SUB, DDS_RETCODE_UNSUPPORTED},
{REA, DDS_RETCODE_UNSUPPORTED},
{BAD, DDS_RETCODE_BAD_PARAMETER}
};
return cr_make_param_array(struct index_result, pars, sizeof pars / sizeof *pars);
};
ParameterizedTest(struct index_result *par, ddsc_unsupported, dds_begin_end_coherent, .init = setup, .fini = teardown)
CU_Test(ddsc_unsupported, dds_begin_end_coherent, .init = setup, .fini = teardown)
{
dds_return_t result;
result = dds_begin_coherent(e[par->index]);
cr_expect_eq(dds_err_nr(result), par->exp_res, "Unexpected return code %d \"%s\" (expected %d \"%s\") from dds_begin_coherent(%s): (%d)", dds_err_nr(result), dds_err_str(result), par->exp_res, dds_err_str(-par->exp_res), entity_kind_str(e[par->index]), result);
result = dds_end_coherent(e[par->index]);
cr_expect_eq(dds_err_nr(result), par->exp_res, "Unexpected return code %d \"%s\" (expected %d \"%s\") from dds_end_coherent(%s): (%d)", dds_err_nr(result), dds_err_str(result), par->exp_res, dds_err_str(-par->exp_res), entity_kind_str(e[par->index]), result);
}
/*************************************************************************************************/
ParameterizedTestParameters(ddsc_unsupported, dds_wait_for_acks) {
static struct index_result pars[] = {
{PUB, DDS_RETCODE_UNSUPPORTED},
{WRI, DDS_RETCODE_UNSUPPORTED},
{BAD, DDS_RETCODE_BAD_PARAMETER}
{PUB, DDS_RETCODE_UNSUPPORTED},
{WRI, DDS_RETCODE_UNSUPPORTED},
{SUB, DDS_RETCODE_UNSUPPORTED},
{REA, DDS_RETCODE_UNSUPPORTED},
{BAD, DDS_RETCODE_BAD_PARAMETER}
};
return cr_make_param_array(struct index_result, pars, sizeof pars / sizeof *pars);
};
for (int i=0; i < 5; i++) {
result = dds_begin_coherent(e[pars[i].index]);
CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res);
result = dds_end_coherent(e[pars[i].index]);
CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res);
}
}
ParameterizedTest(struct index_result *par, ddsc_unsupported, dds_wait_for_acks, .init = setup, .fini = teardown)
CU_Test(ddsc_unsupported, dds_wait_for_acks, .init = setup, .fini = teardown)
{
dds_return_t result;
result = dds_wait_for_acks(e[par->index], 0);
cr_expect_eq(dds_err_nr(result), par->exp_res, "Unexpected return code %d \"%s\" (expected %d \"%s\") from dds_wait_for_acks(%s, 0): (%d)", dds_err_nr(result), dds_err_str(result), par->exp_res, dds_err_str(-par->exp_res), entity_kind_str(e[par->index]), result);
}
/*************************************************************************************************/
ParameterizedTestParameters(ddsc_unsupported, dds_suspend_resume) {
static struct index_result pars[] = {
{PUB, DDS_RETCODE_UNSUPPORTED},
{WRI, DDS_RETCODE_BAD_PARAMETER},
{BAD, DDS_RETCODE_BAD_PARAMETER}
{PUB, DDS_RETCODE_UNSUPPORTED},
{WRI, DDS_RETCODE_UNSUPPORTED},
{BAD, DDS_RETCODE_BAD_PARAMETER}
};
return cr_make_param_array(struct index_result, pars, sizeof pars / sizeof *pars);
};
for (int i=0; i< 3; i++) {
result = dds_wait_for_acks(e[pars[i].index], 0);
CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res);
}
}
ParameterizedTest(struct index_result *par, ddsc_unsupported, dds_suspend_resume, .init = setup, .fini = teardown)
CU_Test(ddsc_unsupported, dds_suspend_resume, .init = setup, .fini = teardown)
{
dds_return_t result;
result = dds_suspend(e[par->index]);
cr_expect_eq(dds_err_nr(result), par->exp_res, "Unexpected return code %d \"%s\" (expected %d \"%s\") from dds_suspend(%s): (%d)", dds_err_nr(result), dds_err_str(result), par->exp_res, dds_err_str(-par->exp_res), entity_kind_str(e[par->index]), result);
result = dds_resume(e[par->index]);
cr_expect_eq(dds_err_nr(result), par->exp_res, "Unexpected return code %d \"%s\" (expected %d \"%s\") from dds_resume(%s): (%d)", dds_err_nr(result), dds_err_str(result), par->exp_res, dds_err_str(-par->exp_res), entity_kind_str(e[par->index]), result);
}
/*************************************************************************************************/
ParameterizedTestParameters(ddsc_unsupported, dds_get_instance_handle) {
/* The parameters seem to be initialized before spawning children,
* so it makes no sense to try and store anything dynamic here. */
static struct index_result pars[] = {
{TOP, DDS_RETCODE_ILLEGAL_OPERATION}, /* TODO: Shouldn't this be either supported or unsupported? */
{PUB, DDS_RETCODE_UNSUPPORTED},
{SUB, DDS_RETCODE_UNSUPPORTED},
{RCD, DDS_RETCODE_ILLEGAL_OPERATION},
{BAD, DDS_RETCODE_BAD_PARAMETER}
{PUB, DDS_RETCODE_UNSUPPORTED},
{WRI, DDS_RETCODE_BAD_PARAMETER},
{BAD, DDS_RETCODE_BAD_PARAMETER}
};
return cr_make_param_array(struct index_result, pars, sizeof pars / sizeof *pars);
};
for (int i=0; i< 3; i++) {
result = dds_suspend(e[pars[i].index]);
CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res);
result = dds_resume(e[pars[i].index]);
CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res);
}
}
ParameterizedTest(struct index_result *par, ddsc_unsupported, dds_get_instance_handle, .init = setup, .fini = teardown)
CU_Test(ddsc_unsupported, dds_get_instance_handle, .init = setup, .fini = teardown)
{
dds_return_t result;
dds_instance_handle_t ih;
result = dds_get_instance_handle(e[par->index], &ih);
cr_expect_eq(dds_err_nr(result), par->exp_res, "Unexpected return code %d \"%s\" (expected %d \"%s\") from dds_get_instance_handle(%s): (%d)", dds_err_nr(result), dds_err_str(result), par->exp_res, dds_err_str(-par->exp_res), entity_kind_str(e[par->index]), result);
}
/*************************************************************************************************/
ParameterizedTestParameters(ddsc_unsupported, dds_set_qos) {
/* The parameters seem to be initialized before spawning children,
* so it makes no sense to try and store anything dynamic here. */
static struct index_result pars[] = {
{PAR, DDS_RETCODE_UNSUPPORTED},
{TOP, DDS_RETCODE_UNSUPPORTED},
{PUB, DDS_RETCODE_UNSUPPORTED},
{WRI, DDS_RETCODE_UNSUPPORTED},
{SUB, DDS_RETCODE_UNSUPPORTED},
{REA, DDS_RETCODE_UNSUPPORTED},
{RCD, DDS_RETCODE_ILLEGAL_OPERATION},
{BAD, DDS_RETCODE_BAD_PARAMETER}
{TOP, DDS_RETCODE_ILLEGAL_OPERATION}, /* TODO: Shouldn't this be either supported or unsupported? */
{PUB, DDS_RETCODE_UNSUPPORTED},
{SUB, DDS_RETCODE_UNSUPPORTED},
{RCD, DDS_RETCODE_ILLEGAL_OPERATION},
{BAD, DDS_RETCODE_BAD_PARAMETER}
};
return cr_make_param_array(struct index_result, pars, sizeof pars / sizeof *pars);
};
for (int i=0; i < 5; i++) {
result = dds_get_instance_handle(e[pars[i].index], &ih);
CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res);
}
}
ParameterizedTest(struct index_result *par, ddsc_unsupported, dds_set_qos, .init = setup, .fini = teardown)
CU_Test(ddsc_unsupported, dds_set_qos, .init = setup, .fini = teardown)
{
dds_return_t result;
dds_qos_t *qos;
static struct index_result pars[] = {
{PAR, DDS_RETCODE_UNSUPPORTED},
{TOP, DDS_RETCODE_UNSUPPORTED},
{PUB, DDS_RETCODE_UNSUPPORTED},
{WRI, DDS_RETCODE_UNSUPPORTED},
{SUB, DDS_RETCODE_UNSUPPORTED},
{REA, DDS_RETCODE_UNSUPPORTED},
{RCD, DDS_RETCODE_ILLEGAL_OPERATION},
{BAD, DDS_RETCODE_BAD_PARAMETER}
};
qos = dds_create_qos();
result = dds_set_qos(e[par->index], qos);
cr_expect_eq(dds_err_nr(result), par->exp_res, "Unexpected return code %d \"%s\" (expected %d \"%s\") from dds_set_qos(%s, qos): (%d)", dds_err_nr(result), dds_err_str(result), par->exp_res, dds_err_str(-par->exp_res), entity_kind_str(e[par->index]), result);
for (int i=0; i < 8;i++) {
result = dds_set_qos(e[pars[i].index], qos);
CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res);
}
dds_delete_qos(qos);
}

413
src/core/ddsc/tests/waitset.c
View file

File diff suppressed because it is too large Load diff

52
src/core/ddsc/tests/write.c
View file

@ -10,8 +10,8 @@
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include <stdio.h>
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
#include "CUnit/Theory.h"
#include "ddsc/dds.h"
#include "RoundTrip.h"
#include "Space.h"
@ -32,13 +32,13 @@ static void
setup(void)
{
participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0);
CU_ASSERT_FATAL(participant > 0);
topic = dds_create_topic(participant, &RoundTripModule_DataType_desc, "RoundTrip", NULL, NULL);
cr_assert_gt(topic, 0);
CU_ASSERT_FATAL(topic > 0);
publisher = dds_create_publisher(participant, NULL, NULL);
cr_assert_gt(publisher, 0);
CU_ASSERT_FATAL(publisher > 0);
writer = dds_create_writer(participant, topic, NULL, NULL);
cr_assert_gt(writer, 0);
CU_ASSERT_FATAL(writer > 0);
memset(&data, 0, sizeof(data));
data.payload._length = payloadSize;
@ -60,15 +60,15 @@ teardown(void)
dds_delete(participant);
}
Test(ddsc_write, basic, .init = setup, .fini = teardown)
CU_Test(ddsc_write, basic, .init = setup, .fini = teardown)
{
dds_return_t status;
status = dds_write(writer, &data);
cr_assert_eq(dds_err_nr(status), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK);
}
Test(ddsc_write, null_writer, .init = setup, .fini = teardown)
CU_Test(ddsc_write, null_writer, .init = setup, .fini = teardown)
{
dds_return_t status;
@ -76,29 +76,29 @@ Test(ddsc_write, null_writer, .init = setup, .fini = teardown)
OS_WARNING_MSVC_OFF(28020);
status = dds_write(0, &data);
OS_WARNING_MSVC_ON(28020);
cr_assert_eq(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER);
}
Test(ddsc_write, bad_writer, .init = setup, .fini = teardown)
CU_Test(ddsc_write, bad_writer, .init = setup, .fini = teardown)
{
dds_return_t status;
status = dds_write(publisher, &data);
cr_assert_eq(dds_err_nr(status), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_ILLEGAL_OPERATION);
}
Test(ddsc_write, closed_writer, .init = setup, .fini = teardown)
CU_Test(ddsc_write, closed_writer, .init = setup, .fini = teardown)
{
dds_return_t status;
status = dds_delete(writer);
cr_assert_eq(dds_err_nr(status), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK);
status = dds_write(writer, &data);
writer = 0;
cr_assert_eq(dds_err_nr(status), DDS_RETCODE_ALREADY_DELETED);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_ALREADY_DELETED);
}
Test(ddsc_write, null_sample, .init = setup, .fini = teardown)
CU_Test(ddsc_write, null_sample, .init = setup, .fini = teardown)
{
dds_return_t status;
@ -107,26 +107,26 @@ Test(ddsc_write, null_sample, .init = setup, .fini = teardown)
status = dds_write(writer, NULL);
OS_WARNING_MSVC_ON(6387);
cr_assert_eq(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER);
}
Test(ddsc_write_ts, basic, .init = setup, .fini = teardown)
CU_Test(ddsc_write_ts, basic, .init = setup, .fini = teardown)
{
dds_return_t status;
status = dds_write_ts(writer, &data, dds_time());
cr_assert_eq(dds_err_nr(status), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK);
}
Test(ddsc_write_ts, bad_timestamp, .init = setup, .fini = teardown)
CU_Test(ddsc_write_ts, bad_timestamp, .init = setup, .fini = teardown)
{
dds_return_t status;
status = dds_write_ts(writer, &data, -1);
cr_assert_eq(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER);
}
Test(ddsc_write, simpletypes)
CU_Test(ddsc_write, simpletypes)
{
dds_return_t status;
dds_entity_t par, top, wri;
@ -145,14 +145,14 @@ Test(ddsc_write, simpletypes)
};
par = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(par, 0);
CU_ASSERT_FATAL(par > 0);
top = dds_create_topic(par, &Space_simpletypes_desc, "SimpleTypes", NULL, NULL);
cr_assert_gt(top, 0);
CU_ASSERT_FATAL(top > 0);
wri = dds_create_writer(par, top, NULL, NULL);
cr_assert_gt(wri, 0);
CU_ASSERT_FATAL(wri > 0);
status = dds_write(wri, &st_data);
cr_assert_eq(dds_err_nr(status), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK);
dds_delete(wri);
dds_delete(top);

48
src/core/ddsc/tests/writer.c
View file

@ -10,9 +10,7 @@
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include <stdio.h>
#include <criterion/criterion.h>
#include <criterion/logging.h>
#include "CUnit/Test.h"
#include "ddsc/dds.h"
#include "RoundTrip.h"
#include "os/os.h"
@ -26,11 +24,11 @@ static void
setup(void)
{
participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
cr_assert_gt(participant, 0);
CU_ASSERT_FATAL(participant > 0);
topic = dds_create_topic(participant, &RoundTripModule_DataType_desc, "RoundTrip", NULL, NULL);
cr_assert_gt(topic, 0);
CU_ASSERT_FATAL(topic > 0);
publisher = dds_create_publisher(participant, NULL, NULL);
cr_assert_gt(publisher, 0);
CU_ASSERT_FATAL(publisher > 0);
}
static void
@ -42,69 +40,69 @@ teardown(void)
dds_delete(participant);
}
Test(ddsc_create_writer, basic, .init = setup, .fini = teardown)
CU_Test(ddsc_create_writer, basic, .init = setup, .fini = teardown)
{
dds_return_t result;
writer = dds_create_writer(participant, topic, NULL, NULL);
cr_assert_gt(writer, 0);
CU_ASSERT_FATAL(writer > 0);
result = dds_delete(writer);
cr_assert_eq(result, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(result, DDS_RETCODE_OK);
}
Test(ddsc_create_writer, null_parent, .init = setup, .fini = teardown)
CU_Test(ddsc_create_writer, null_parent, .init = setup, .fini = teardown)
{
OS_WARNING_MSVC_OFF(28020); /* Disable SAL warning on intentional misuse of the API */
writer = dds_create_writer(0, topic, NULL, NULL);
OS_WARNING_MSVC_ON(28020);
cr_assert_eq(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER);
}
Test(ddsc_create_writer, bad_parent, .init = setup, .fini = teardown)
CU_Test(ddsc_create_writer, bad_parent, .init = setup, .fini = teardown)
{
writer = dds_create_writer(topic, topic, NULL, NULL);
cr_assert_eq(dds_err_nr(writer), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_ILLEGAL_OPERATION);
}
Test(ddsc_create_writer, participant, .init = setup, .fini = teardown)
CU_Test(ddsc_create_writer, participant, .init = setup, .fini = teardown)
{
writer = dds_create_writer(participant, topic, NULL, NULL);
cr_assert_gt(writer, 0);
CU_ASSERT_FATAL(writer > 0);
}
Test(ddsc_create_writer, publisher, .init = setup, .fini = teardown)
CU_Test(ddsc_create_writer, publisher, .init = setup, .fini = teardown)
{
writer = dds_create_writer(publisher, topic, NULL, NULL);
cr_assert_gt(writer, 0);
CU_ASSERT_FATAL(writer > 0);
}
Test(ddsc_create_writer, deleted_publisher, .init = setup, .fini = teardown)
CU_Test(ddsc_create_writer, deleted_publisher, .init = setup, .fini = teardown)
{
dds_delete(publisher);
writer = dds_create_writer(publisher, topic, NULL, NULL);
cr_assert_eq(dds_err_nr(writer), DDS_RETCODE_ALREADY_DELETED);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_ALREADY_DELETED);
}
Test(ddsc_create_writer, null_topic, .init = setup, .fini = teardown)
CU_Test(ddsc_create_writer, null_topic, .init = setup, .fini = teardown)
{
OS_WARNING_MSVC_OFF(28020); /* Disable SAL warning on intentional misuse of the API */
writer = dds_create_writer(publisher, 0, NULL, NULL);
OS_WARNING_MSVC_ON(28020);
cr_assert_eq(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER);
}
Test(ddsc_create_writer, bad_topic, .init = setup, .fini = teardown)
CU_Test(ddsc_create_writer, bad_topic, .init = setup, .fini = teardown)
{
writer = dds_create_writer(publisher, publisher, NULL, NULL);
cr_assert_eq(dds_err_nr(writer), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_ILLEGAL_OPERATION);
}
Test(ddsc_create_writer, deleted_topic, .init = setup, .fini = teardown)
CU_Test(ddsc_create_writer, deleted_topic, .init = setup, .fini = teardown)
{
dds_delete(topic);
writer = dds_create_writer(publisher, topic, NULL, NULL);
cr_assert_eq(dds_err_nr(writer), DDS_RETCODE_ALREADY_DELETED);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_ALREADY_DELETED);
}