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

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);
}
/*************************************************************************************************/