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

Clean up return code types

Browse source 
* Remove dds_return_t / dds_retcode_t distinction (now there is only
  dds_return_t and all error codes are always negative)

* Remove Q_ERR_... error codes and replace them by DDS_RETCODE_...
  ones so that there is only one set of error codes

* Replace a whole bunch "int" return types that were used to return
  Q_ERR_... codes by "dds_return_t" return types

Signed-off-by: Erik Boasson <eb@ilities.com>
This commit is contained in:
Erik Boasson 2019-05-23 16:51:43 +02:00 • committed by eboasson
parent a652ecb78e
commit 19aec98b8a
126 changed files with 1565 additions and 1722 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -49,7 +49,7 @@ static void config__check_env(
}
if ( !env_ok ) {
dds_retcode_t r;
dds_return_t r;
r = ddsrt_setenv(env_variable, expected_value);
CU_ASSERT_EQUAL_FATAL(r, DDS_RETCODE_OK);

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

@ -153,7 +153,7 @@ CU_Test(ddsc_writedispose, deleted, .init=disposing_init, .fini=disposing_fini)
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose(g_writer, NULL);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -164,7 +164,7 @@ CU_Test(ddsc_writedispose, null, .init=disposing_init, .fini=disposing_fini)
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose(g_writer, NULL);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -174,13 +174,12 @@ CU_TheoryDataPoints(ddsc_writedispose, invalid_writers) = {
};
CU_Theory((dds_entity_t writer), ddsc_writedispose, invalid_writers, .init=disposing_init, .fini=disposing_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose(writer, NULL);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -194,7 +193,7 @@ CU_Theory((dds_entity_t *writer), ddsc_writedispose, non_writers, .init=disposin
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose(*writer, NULL);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -290,7 +289,7 @@ CU_Test(ddsc_writedispose, timeout, .init=disposing_init, .fini=disposing_fini)
ret = dds_writedispose(g_writer, &newInstance1);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_writedispose(g_writer, &newInstance2);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_TIMEOUT);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_TIMEOUT);
}
/*************************************************************************************************/
@ -310,7 +309,7 @@ CU_Test(ddsc_writedispose_ts, deleted, .init=disposing_init, .fini=disposing_fin
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose_ts(g_writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -321,7 +320,7 @@ CU_Test(ddsc_writedispose_ts, null, .init=disposing_init, .fini=disposing_fini)
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose_ts(g_writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -335,7 +334,7 @@ CU_Test(ddsc_writedispose_ts, timeout, .init=disposing_init, .fini=disposing_fin
ret = dds_writedispose_ts(g_writer, &newInstance1, g_present);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_writedispose_ts(g_writer, &newInstance2, g_present);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_TIMEOUT);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_TIMEOUT);
}
/*************************************************************************************************/
@ -345,13 +344,12 @@ CU_TheoryDataPoints(ddsc_writedispose_ts, invalid_writers) = {
};
CU_Theory((dds_entity_t writer), ddsc_writedispose_ts, invalid_writers, .init=disposing_init, .fini=disposing_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose_ts(writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -365,7 +363,7 @@ CU_Theory((dds_entity_t *writer), ddsc_writedispose_ts, non_writers, .init=dispo
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose_ts(*writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -510,7 +508,7 @@ CU_Test(ddsc_dispose, deleted, .init=disposing_init, .fini=disposing_fini)
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose(g_writer, NULL);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -521,7 +519,7 @@ CU_Test(ddsc_dispose, null, .init=disposing_init, .fini=disposing_fini)
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose(g_writer, NULL);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -535,7 +533,7 @@ CU_Test(ddsc_dispose, timeout, .init=disposing_init, .fini=disposing_fini)
ret = dds_dispose(g_writer, &newInstance1);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_dispose(g_writer, &newInstance2);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_TIMEOUT);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_TIMEOUT);
}
/*************************************************************************************************/
@ -545,13 +543,12 @@ CU_TheoryDataPoints(ddsc_dispose, invalid_writers) = {
};
CU_Theory((dds_entity_t writer), ddsc_dispose, invalid_writers, .init=disposing_init, .fini=disposing_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose(writer, NULL);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -565,7 +562,7 @@ CU_Theory((dds_entity_t *writer), ddsc_dispose, non_writers, .init=disposing_ini
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose(*writer, NULL);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -665,7 +662,7 @@ CU_Test(ddsc_dispose_ts, deleted, .init=disposing_init, .fini=disposing_fini)
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose_ts(g_writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387); /* Disable SAL warning on intentional misuse of the API */
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -676,7 +673,7 @@ CU_Test(ddsc_dispose_ts, null, .init=disposing_init, .fini=disposing_fini)
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose_ts(g_writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -690,7 +687,7 @@ CU_Test(ddsc_dispose_ts, timeout, .init=disposing_init, .fini=disposing_fini)
ret = dds_dispose_ts(g_writer, &newInstance1, g_present);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_dispose_ts(g_writer, &newInstance2, g_present);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_TIMEOUT);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_TIMEOUT);
}
/*************************************************************************************************/
@ -700,13 +697,12 @@ CU_TheoryDataPoints(ddsc_dispose_ts, invalid_writers) = {
};
CU_Theory((dds_entity_t writer), ddsc_dispose_ts, invalid_writers, .init=disposing_init, .fini=disposing_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose_ts(writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -720,7 +716,7 @@ CU_Theory((dds_entity_t *writer), ddsc_dispose_ts, non_writers, .init=disposing_
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose_ts(*writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -861,7 +857,7 @@ CU_Test(ddsc_dispose_ih, deleted, .init=disposing_init, .fini=disposing_fini)
dds_return_t ret;
dds_delete(g_writer);
ret = dds_dispose_ih(g_writer, DDS_HANDLE_NIL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -873,7 +869,7 @@ CU_Theory((dds_instance_handle_t handle), ddsc_dispose_ih, invalid_handles, .ini
{
dds_return_t ret;
ret = dds_dispose_ih(g_writer, handle);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -883,11 +879,10 @@ CU_TheoryDataPoints(ddsc_dispose_ih, invalid_writers) = {
};
CU_Theory((dds_entity_t writer), ddsc_dispose_ih, invalid_writers, .init=disposing_init, .fini=disposing_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_dispose_ih(writer, DDS_HANDLE_NIL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -899,7 +894,7 @@ CU_Theory((dds_entity_t *writer), ddsc_dispose_ih, non_writers, .init=disposing_
{
dds_return_t ret;
ret = dds_dispose_ih(*writer, DDS_HANDLE_NIL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -959,7 +954,7 @@ CU_Test(ddsc_dispose_ih_ts, deleted, .init=disposing_init, .fini=disposing_fini)
dds_return_t ret;
dds_delete(g_writer);
ret = dds_dispose_ih_ts(g_writer, DDS_HANDLE_NIL, g_present);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -971,7 +966,7 @@ CU_Theory((dds_instance_handle_t handle), ddsc_dispose_ih_ts, invalid_handles, .
{
dds_return_t ret;
ret = dds_dispose_ih_ts(g_writer, handle, g_present);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -981,11 +976,10 @@ CU_TheoryDataPoints(ddsc_dispose_ih_ts, invalid_writers) = {
};
CU_Theory((dds_entity_t writer), ddsc_dispose_ih_ts, invalid_writers, .init=disposing_init, .fini=disposing_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_dispose_ih_ts(writer, DDS_HANDLE_NIL, g_present);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -997,7 +991,7 @@ CU_Theory((dds_entity_t *writer), ddsc_dispose_ih_ts, non_writers, .init=disposi
{
dds_return_t ret;
ret = dds_dispose_ih_ts(*writer, DDS_HANDLE_NIL, g_present);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/

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

@ -23,8 +23,6 @@
static dds_entity_t entity = -1;
#define cu_assert_status_eq(s1, s2) CU_ASSERT_FATAL(dds_err_nr(s1)== s2)
/* Fixture to create prerequisite entity */
void create_entity(void)
{
@ -38,7 +36,7 @@ void delete_entity(void)
{
CU_ASSERT_FATAL(entity > 0);
dds_return_t ret = dds_delete(entity);
cu_assert_status_eq(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
entity = -1;
}
@ -55,17 +53,17 @@ CU_Test(ddsc_entity, enable, .init = create_entity, .fini = delete_entity)
/* Check enabling with bad parameters. */
status = dds_enable(0);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
/* Check actual enabling. */
/* TODO: CHAM-96: Check enabling.
status = dds_enable(&entity);
cu_assert_status_eq(status, dds_err_nr(DDS_RETCODE_OK), "dds_enable (delayed enable)");
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK, "dds_enable (delayed enable)");
*/
/* Check re-enabling (should be a noop). */
status = dds_enable(entity);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
}
void entity_qos_get_set(dds_entity_t e, const char* info)
@ -77,10 +75,10 @@ void entity_qos_get_set(dds_entity_t e, const char* info)
/* Get QoS. */
status = dds_get_qos (e, qos);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(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*/
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED);
dds_delete_qos(qos);
}
@ -95,19 +93,19 @@ CU_Test(ddsc_entity, qos, .init = create_entity, .fini = delete_entity)
/* Check getting QoS with bad parameters. */
status = dds_get_qos (0, NULL);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_qos (entity, NULL);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_qos (0, qos);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
/* Check setting QoS with bad parameters. */
status = dds_set_qos (0, NULL);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_set_qos (entity, NULL);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_set_qos (0, qos);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
/* Check set/get with entity without initial qos. */
entity_qos_get_set(entity, "{without initial qos}");
@ -145,15 +143,15 @@ CU_Test(ddsc_entity, listener, .init = create_entity, .fini = delete_entity)
/* Check getting Listener with bad parameters. */
status = dds_get_listener (0, NULL);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_listener (entity, NULL);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_listener (0, l1);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
/* Get Listener, which should be unset. */
status = dds_get_listener (entity, l1);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
dds_lget_liveliness_changed (l1, (dds_on_liveliness_changed_fn*)&cb1);
CU_ASSERT_EQUAL_FATAL(cb1, DDS_LUNSET);
dds_lget_requested_deadline_missed (l1, (dds_on_requested_deadline_missed_fn*)&cb1);
@ -165,15 +163,15 @@ CU_Test(ddsc_entity, listener, .init = create_entity, .fini = delete_entity)
/* Check setting Listener with bad parameters. */
status = dds_set_listener (0, NULL);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_set_listener (0, l2);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
/* Getting after setting should return set listener. */
status = dds_set_listener (entity, l2);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
status = dds_get_listener (entity, l1);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(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);
CU_ASSERT_EQUAL_FATAL(cb1, cb2);
@ -189,9 +187,9 @@ CU_Test(ddsc_entity, listener, .init = create_entity, .fini = delete_entity)
/* Reset listener. */
status = dds_set_listener (entity, NULL);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
status = dds_get_listener (entity, l2);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
dds_lget_liveliness_changed (l2, (dds_on_liveliness_changed_fn*)&cb2);
CU_ASSERT_EQUAL_FATAL(cb2, DDS_LUNSET);
dds_lget_requested_deadline_missed (l2, (dds_on_requested_deadline_missed_fn*)&cb2);
@ -215,46 +213,46 @@ CU_Test(ddsc_entity, status, .init = create_entity, .fini = delete_entity)
/* Check getting Status with bad parameters. */
status1 = dds_get_status_mask (0, NULL);
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER);
status1 = dds_get_status_mask (entity, NULL);
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER);
status1 = dds_get_status_mask (0, &s1);
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER);
/* Get Status, which should be 0 for a participant. */
status1 = dds_get_status_mask (entity, &s1);
cu_assert_status_eq(status1, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(s1, 0);
/* Check setting Status with bad parameters. */
status1 = dds_set_status_mask (0, 0);
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER);
/* I shouldn't be able to set statuses on a participant. */
status1 = dds_set_status_mask (entity, 0);
cu_assert_status_eq(status1, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_OK);
status1 = dds_set_status_mask (entity, DDS_DATA_AVAILABLE_STATUS);
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER);
/* Check getting Status changes with bad parameters. */
status1 = dds_get_status_changes (0, NULL);
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER);
status1 = dds_get_status_changes (entity, NULL);
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER);
status1 = dds_get_status_changes (0, &s1);
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER);
status1 = dds_get_status_changes (entity, &s1);
cu_assert_status_eq(status1, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_OK);
/* Status read and take shouldn't work either. */
status1 = dds_read_status (0, &s1, 0);
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER);
status1 = dds_read_status (entity, &s1, 0);
cu_assert_status_eq(status1, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_OK);
status1 = dds_take_status (0, &s1, 0);
cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER);
status1 = dds_take_status (entity, &s1, 0);
cu_assert_status_eq(status1, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_OK);
}
@ -268,15 +266,15 @@ CU_Test(ddsc_entity, instance_handle, .init = create_entity, .fini = delete_enti
/* Check getting Handle with bad parameters. */
status = dds_get_instance_handle (0, NULL);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_instance_handle (entity, NULL);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_instance_handle (0, &hdl);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
/* Get Instance Handle, which should not be 0 for a participant. */
status = dds_get_instance_handle (entity, &hdl);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
CU_ASSERT_NOT_EQUAL_FATAL(hdl, 0);
}
@ -290,17 +288,17 @@ CU_Test(ddsc_entity, get_entities, .init = create_entity, .fini = delete_entity)
/* Check getting Parent with bad parameters. */
par = dds_get_parent (0);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(par), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(par, DDS_RETCODE_BAD_PARAMETER);
/* Get Parent, a participant doesn't have a parent. */
par = dds_get_parent (entity);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(par), DDS_ENTITY_NIL);
CU_ASSERT_EQUAL_FATAL(par, DDS_ENTITY_NIL);
/* ---------- Get Participant ------------ */
/* Check getting Participant with bad parameters. */
par = dds_get_participant (0);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(par), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(par, DDS_RETCODE_BAD_PARAMETER);
/* Get Participant, a participants' participant is itself. */
par = dds_get_participant (entity);
@ -310,15 +308,15 @@ CU_Test(ddsc_entity, get_entities, .init = create_entity, .fini = delete_entity)
/* Check getting Children with bad parameters. */
status = dds_get_children (0, &child, 1);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_children (entity, NULL, 1);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_children (entity, &child, 0);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_children (0, NULL, 1);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_children (0, &child, 0);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
/* Get Children, of which there are currently none. */
status = dds_get_children (entity, NULL, 0);
@ -342,15 +340,15 @@ CU_Test(ddsc_entity, get_domainid, .init = create_entity, .fini = delete_entity)
/* Check getting ID with bad parameters. */
status = dds_get_domainid (0, NULL);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_domainid (entity, NULL);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_get_domainid (0, &id);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
/* Get and check the domain id. */
status = dds_get_domainid (entity, &id);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
CU_ASSERT_FATAL(id != -1);
}
@ -358,10 +356,10 @@ CU_Test(ddsc_entity, delete, .init = create_entity)
{
dds_return_t status;
status = dds_delete(0);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
status = dds_delete(entity);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
entity = 0;
}

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

@ -125,43 +125,43 @@ CU_Test(ddsc_entity_delete, recursive, .init=hierarchy_init, .fini=hierarchy_fin
/* First be sure that 'dds_get_domainid' returns ok. */
ret = dds_get_domainid(g_participant, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_get_domainid(g_topic, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_get_domainid(g_publisher, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_get_domainid(g_subscriber, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_get_domainid(g_writer, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_get_domainid(g_reader, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_get_domainid(g_readcond, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_get_domainid(g_querycond, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Deleting the top dog (participant) should delete all children. */
ret = dds_delete(g_participant);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Check if all the entities are deleted now. */
ret = dds_get_domainid(g_participant, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
ret = dds_get_domainid(g_topic, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
ret = dds_get_domainid(g_publisher, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
ret = dds_get_domainid(g_subscriber, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
ret = dds_get_domainid(g_writer, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
ret = dds_get_domainid(g_reader, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
ret = dds_get_domainid(g_readcond, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
ret = dds_get_domainid(g_querycond, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -190,22 +190,22 @@ CU_Test(ddsc_entity_delete, recursive_with_deleted_topic)
* reference to the topic and thus will delete it when it itself is
* deleted. */
ret = dds_delete(g_topic);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Third, deleting the participant should delete all children of which
* the writer with the last topic reference is one. */
ret = dds_delete(g_participant);
/* Before the CHAM-424 fix, we would not get here because of a crash,
* or it (incidentally) continued but returned an error. */
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
/* Check if the entities are actually deleted. */
ret = dds_get_domainid(g_participant, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER );
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER );
ret = dds_get_domainid(g_topic, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
ret = dds_get_domainid(g_writer, &id);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
dds_delete(g_keep);
}
@ -240,7 +240,7 @@ CU_Theory((dds_entity_t *entity), ddsc_entity_get_participant, deleted_entities,
dds_entity_t participant;
dds_delete(*entity);
participant = dds_get_participant(*entity);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(participant), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(participant, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -250,11 +250,10 @@ CU_TheoryDataPoints(ddsc_entity_get_participant, invalid_entities) = {
};
CU_Theory((dds_entity_t entity), ddsc_entity_get_participant, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_entity_t participant;
participant = dds_get_participant(entity);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(participant), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(participant, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -314,7 +313,7 @@ CU_Test(ddsc_entity_get_parent, participant, .init=hierarchy_init, .fini=hierarc
{
dds_entity_t parent;
parent = dds_get_parent(g_participant);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(parent), DDS_ENTITY_NIL);
CU_ASSERT_EQUAL_FATAL(parent, DDS_ENTITY_NIL);
}
/*************************************************************************************************/
@ -327,7 +326,7 @@ CU_Theory((dds_entity_t *entity), ddsc_entity_get_parent, deleted_entities, .ini
dds_entity_t parent;
dds_delete(*entity);
parent = dds_get_parent(*entity);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(parent), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(parent, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -337,11 +336,10 @@ CU_TheoryDataPoints(ddsc_entity_get_parent, invalid_entities) = {
};
CU_Theory((dds_entity_t entity), ddsc_entity_get_parent, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_entity_t parent;
parent = dds_get_parent(entity);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(parent), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(parent, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -369,7 +367,7 @@ CU_Test(ddsc_entity_get_children, invalid_size, .init=hierarchy_init, .fini=hier
dds_return_t ret;
dds_entity_t child;
ret = dds_get_children(g_participant, &child, INT32_MAX);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -478,7 +476,7 @@ CU_Theory((dds_entity_t *entity), ddsc_entity_get_children, deleted_entities, .i
dds_entity_t children[4];
dds_delete(*entity);
ret = dds_get_children(*entity, children, 4);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -488,12 +486,11 @@ CU_TheoryDataPoints(ddsc_entity_get_children, invalid_entities) = {
};
CU_Theory((dds_entity_t entity), ddsc_entity_get_children, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_entity_t children[4];
dds_return_t ret;
ret = dds_get_children(entity, children, 4);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -527,7 +524,7 @@ CU_Theory((dds_entity_t *entity), ddsc_entity_get_topic, deleted_entities, .init
dds_entity_t topic;
dds_delete(*entity);
topic = dds_get_topic(*entity);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -537,11 +534,10 @@ CU_TheoryDataPoints(ddsc_entity_get_topic, invalid_entities) = {
};
CU_Theory((dds_entity_t entity), ddsc_entity_get_topic, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_entity_t topic;
topic = dds_get_topic(entity);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -553,7 +549,7 @@ CU_Theory((dds_entity_t *entity), ddsc_entity_get_topic, non_data_entities, .ini
{
dds_entity_t topic;
topic = dds_get_topic(*entity);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -581,7 +577,7 @@ CU_Test(ddsc_entity_get_publisher, deleted_writer, .init=hierarchy_init, .fini=h
dds_entity_t publisher;
dds_delete(g_writer);
publisher = dds_get_publisher(g_writer);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(publisher, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -591,11 +587,10 @@ CU_TheoryDataPoints(ddsc_entity_get_publisher, invalid_writers) = {
};
CU_Theory((dds_entity_t entity), ddsc_entity_get_publisher, invalid_writers, .init=hierarchy_init, .fini=hierarchy_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_entity_t publisher;
publisher = dds_get_publisher(entity);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(publisher, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -607,7 +602,7 @@ CU_Theory((dds_entity_t *cond), ddsc_entity_get_publisher, non_writers, .init=hi
{
dds_entity_t publisher;
publisher = dds_get_publisher(*cond);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(publisher, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -640,7 +635,7 @@ CU_Theory((dds_entity_t *entity), ddsc_entity_get_subscriber, deleted_readers, .
dds_entity_t subscriber;
dds_delete(*entity);
subscriber = dds_get_subscriber(*entity);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(subscriber, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -650,11 +645,10 @@ CU_TheoryDataPoints(ddsc_entity_get_subscriber, invalid_readers) = {
};
CU_Theory((dds_entity_t entity), ddsc_entity_get_subscriber, invalid_readers, .init=hierarchy_init, .fini=hierarchy_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_entity_t subscriber;
subscriber = dds_get_subscriber(entity);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(subscriber, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -666,7 +660,7 @@ CU_Theory((dds_entity_t *cond), ddsc_entity_get_subscriber, non_readers, .init=h
{
dds_entity_t subscriber;
subscriber = dds_get_subscriber(*cond);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(subscriber, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -701,7 +695,7 @@ CU_Theory((dds_entity_t *cond), ddsc_entity_get_datareader, deleted_conds, .init
dds_entity_t reader;
dds_delete(*cond);
reader = dds_get_datareader(*cond);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(reader), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(reader, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -711,11 +705,10 @@ CU_TheoryDataPoints(ddsc_entity_get_datareader, invalid_conds) = {
};
CU_Theory((dds_entity_t cond), ddsc_entity_get_datareader, invalid_conds, .init=hierarchy_init, .fini=hierarchy_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_entity_t reader;
reader = dds_get_datareader(cond);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(reader), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(reader, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -727,7 +720,7 @@ CU_Theory((dds_entity_t *cond), ddsc_entity_get_datareader, non_conds, .init=hie
{
dds_entity_t reader;
reader = dds_get_datareader(*cond);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(reader), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(reader, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -954,7 +947,7 @@ CU_Test(ddsc_entity_get_parent, implicit_publisher)
dds_delete(writer);
ret = dds_delete(parent);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
dds_delete(participant);
}
/*************************************************************************************************/
@ -985,7 +978,7 @@ CU_Test(ddsc_entity_get_parent, implicit_subscriber)
dds_delete(reader);
ret = dds_delete(parent);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
dds_delete(participant);
}

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

@ -141,7 +141,7 @@ CU_Test(ddsc_entity_status, publication_matched, .init=init_entity_status, .fini
/* Getting the status should have reset the trigger,
* meaning that the wait should timeout. */
ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, shortTimeout);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0);
CU_ASSERT_EQUAL_FATAL(ret, 0);
/* Un-match the publication by deleting the reader. */
dds_delete(rea);
@ -178,7 +178,7 @@ CU_Test(ddsc_entity_status, subscription_matched, .init=init_entity_status, .fin
/* Getting the status should have reset the trigger,
* meaning that the wait should timeout. */
ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0);
CU_ASSERT_EQUAL_FATAL(ret, 0);
/* Un-match the subscription by deleting the writer. */
dds_delete(wri);
@ -233,7 +233,7 @@ CU_Test(ddsc_entity, incompatible_qos, .init=init_entity_status, .fini=fini_enti
/*Getting the status should have reset the trigger, waitset should timeout */
ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0);
CU_ASSERT_EQUAL_FATAL(ret, 0);
/* Wait for offered incompatible QoS status */
ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, waitTimeout);
@ -246,7 +246,7 @@ CU_Test(ddsc_entity, incompatible_qos, .init=init_entity_status, .fini=fini_enti
/*Getting the status should have reset the trigger, waitset should timeout */
ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0);
CU_ASSERT_EQUAL_FATAL(ret, 0);
ret = dds_waitset_detach(waitSetrd, reader2);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@ -280,7 +280,7 @@ CU_Test(ddsc_entity, liveliness_changed, .init=init_entity_status, .fini=fini_en
/*Getting the status should have reset the trigger, waitset should timeout */
ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0);
CU_ASSERT_EQUAL_FATAL(ret, 0);
/* Reset writer */
ret = dds_waitset_detach(waitSetwr, wri);
@ -341,7 +341,7 @@ CU_Test(ddsc_entity, sample_rejected, .init=init_entity_status, .fini=fini_entit
/*Getting the status should have reset the trigger, waitset should timeout */
ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0);
CU_ASSERT_EQUAL_FATAL(ret, 0);
}
#if 0
@ -370,7 +370,7 @@ Test(ddsc_entity, inconsistent_topic)
/*Getting the status should have reset the trigger, waitset should timeout */
status = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), 0, "returned %d", dds_err_nr(status));
CU_ASSERT_EQUAL_FATAL(status, 0, "returned %d", status);
/* Wait for sub inconsistent topic status callback */
ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout);
@ -381,7 +381,7 @@ Test(ddsc_entity, inconsistent_topic)
/*Getting the status should have reset the trigger, waitset should timeout */
status = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), 0);
CU_ASSERT_EQUAL_FATAL(status, 0);
dds_delete(top);
}
@ -431,7 +431,7 @@ CU_Test(ddsc_entity, sample_lost, .init=init_entity_status, .fini=fini_entity_st
/*Getting the status should have reset the trigger, waitset should timeout */
ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0);
CU_ASSERT_EQUAL_FATAL(ret, 0);
}
@ -594,10 +594,9 @@ CU_TheoryDataPoints(ddsc_get_enabled_status, bad_param) = {
CU_Theory((dds_entity_t e), ddsc_get_enabled_status, bad_param, .init=init_entity_status, .fini=fini_entity_status)
{
uint32_t mask;
dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_status_mask(e, &mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_get_enabled_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status)
@ -605,14 +604,14 @@ CU_Test(ddsc_get_enabled_status, deleted_reader, .init=init_entity_status, .fini
uint32_t mask;
dds_delete(rea);
ret = dds_get_status_mask(rea, &mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_get_enabled_status, illegal, .init=init_entity_status, .fini=fini_entity_status)
{
uint32_t mask;
ret = dds_get_status_mask(waitSetrd, &mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
CU_TheoryDataPoints(ddsc_get_enabled_status, status_ok) = {
@ -632,23 +631,21 @@ CU_TheoryDataPoints(ddsc_set_enabled_status, bad_param) = {
};
CU_Theory((dds_entity_t e), ddsc_set_enabled_status, bad_param, .init=init_entity_status, .fini=fini_entity_status)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_set_status_mask(e, 0 /*mask*/);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_set_enabled_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status)
{
dds_delete(rea);
ret = dds_set_status_mask(rea, 0 /*mask*/);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_set_enabled_status, illegal, .init=init_entity_status, .fini=fini_entity_status)
{
ret = dds_set_status_mask(waitSetrd, 0);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
CU_TheoryDataPoints(ddsc_set_enabled_status, status_ok) = {
@ -668,10 +665,9 @@ CU_TheoryDataPoints(ddsc_read_status, bad_param) = {
CU_Theory((dds_entity_t e), ddsc_read_status, bad_param, .init=init_entity_status, .fini=fini_entity_status)
{
uint32_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_read_status(e, &status, 0 /*mask*/);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_read_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status)
@ -679,14 +675,14 @@ CU_Test(ddsc_read_status, deleted_reader, .init=init_entity_status, .fini=fini_e
uint32_t status;
dds_delete(rea);
ret = dds_read_status(rea, &status, 0 /*mask*/);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_read_status, illegal, .init=init_entity_status, .fini=fini_entity_status)
{
uint32_t status;
ret = dds_read_status(waitSetrd, &status, 0);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
CU_TheoryDataPoints(ddsc_read_status, status_ok) = {
CU_DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber),
@ -702,14 +698,14 @@ CU_Test(ddsc_read_status, invalid_status_on_reader, .init=init_entity_status, .f
{
uint32_t status;
ret = dds_read_status(rea, &status, DDS_PUBLICATION_MATCHED_STATUS);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_read_status, invalid_status_on_writer, .init=init_entity_status, .fini=fini_entity_status)
{
uint32_t status;
ret = dds_read_status(wri, &status, DDS_SUBSCRIPTION_MATCHED_STATUS);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -720,10 +716,9 @@ CU_TheoryDataPoints(ddsc_take_status, bad_param) = {
CU_Theory((dds_entity_t e), ddsc_take_status, bad_param, .init=init_entity_status, .fini=fini_entity_status)
{
uint32_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_take_status(e, &status, 0 /*mask*/);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_take_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status)
@ -731,13 +726,13 @@ CU_Test(ddsc_take_status, deleted_reader, .init=init_entity_status, .fini=fini_e
uint32_t status;
dds_delete(rea);
ret = dds_take_status(rea, &status, 0 /*mask*/);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_take_status, illegal, .init=init_entity_status, .fini=fini_entity_status)
{
uint32_t status;
ret = dds_take_status(waitSetrd, &status, 0);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
CU_TheoryDataPoints(ddsc_take_status, status_ok) = {
@ -759,10 +754,9 @@ CU_TheoryDataPoints(ddsc_get_status_changes, bad_param) = {
CU_Theory((dds_entity_t e), ddsc_get_status_changes, bad_param, .init=init_entity_status, .fini=fini_entity_status)
{
uint32_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_status_changes(e, &status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_get_status_changes, deleted_reader, .init=init_entity_status, .fini=fini_entity_status)
@ -770,14 +764,14 @@ CU_Test(ddsc_get_status_changes, deleted_reader, .init=init_entity_status, .fini
uint32_t status;
dds_delete(rea);
ret = dds_get_status_changes(rea, &status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_get_status_changes, illegal, .init=init_entity_status, .fini=fini_entity_status)
{
uint32_t status;
ret = dds_get_status_changes(waitSetrd, &status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
CU_TheoryDataPoints(ddsc_get_status_changes, status_ok) = {
@ -797,17 +791,15 @@ CU_TheoryDataPoints(ddsc_triggered, bad_param) = {
};
CU_Theory((dds_entity_t e), ddsc_triggered, bad_param, .init=init_entity_status, .fini=fini_entity_status)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_triggered(e);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_triggered, deleted_reader, .init=init_entity_status, .fini=fini_entity_status)
{
dds_delete(rea);
ret = dds_triggered(rea);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_TheoryDataPoints(ddsc_triggered, status_ok) = {
@ -825,7 +817,7 @@ CU_Test(ddsc_get_inconsistent_topic_status, inconsistent_topic_status, .init=ini
{
dds_inconsistent_topic_status_t inconsistent_topic_status;
ret = dds_get_inconsistent_topic_status(top, &inconsistent_topic_status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(inconsistent_topic_status.total_count, 0);
CU_ASSERT_EQUAL_FATAL(inconsistent_topic_status.total_count_change, 0);
}
@ -838,10 +830,9 @@ CU_TheoryDataPoints(ddsc_get_inconsistent_topic_status, bad_params) = {
CU_Theory((dds_entity_t topic), ddsc_get_inconsistent_topic_status, bad_params, .init=init_entity_status, .fini=fini_entity_status)
{
dds_inconsistent_topic_status_t topic_status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_inconsistent_topic_status(topic, &topic_status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -850,7 +841,7 @@ CU_Test(ddsc_get_inconsistent_topic_status, null, .init=init_entity_status, .fin
{
dds_set_status_mask(top, 0);
ret = dds_get_inconsistent_topic_status(top, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
@ -861,7 +852,7 @@ CU_TheoryDataPoints(ddsc_get_inconsistent_topic_status, non_topics) = {
CU_Theory((dds_entity_t *topic), ddsc_get_inconsistent_topic_status, non_topics, .init=init_entity_status, .fini=fini_entity_status)
{
ret = dds_get_inconsistent_topic_status(*topic, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -870,7 +861,7 @@ CU_Test(ddsc_get_inconsistent_topic_status, deleted_topic, .init=init_entity_sta
{
dds_delete(top);
ret = dds_get_inconsistent_topic_status(top, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
@ -881,10 +872,9 @@ CU_TheoryDataPoints(ddsc_get_publication_matched_status, bad_params) = {
CU_Theory((dds_entity_t writer), ddsc_get_publication_matched_status, bad_params, .init=init_entity_status, .fini=fini_entity_status)
{
dds_publication_matched_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_publication_matched_status(writer, &status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -893,7 +883,7 @@ CU_Test(ddsc_get_publication_matched_status, null, .init=init_entity_status, .fi
{
dds_set_status_mask(wri, 0);
ret = dds_get_publication_matched_status(wri, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
@ -904,7 +894,7 @@ CU_TheoryDataPoints(ddsc_get_publication_matched_status, non_writers) = {
CU_Theory((dds_entity_t *writer), ddsc_get_publication_matched_status, non_writers, .init=init_entity_status, .fini=fini_entity_status)
{
ret = dds_get_publication_matched_status(*writer, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -913,7 +903,7 @@ CU_Test(ddsc_get_publication_matched_status, deleted_writer, .init=init_entity_s
{
dds_delete(wri);
ret = dds_get_publication_matched_status(wri, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -922,7 +912,7 @@ CU_Test(ddsc_get_liveliness_lost_status, liveliness_lost_status, .init=init_enti
{
dds_liveliness_lost_status_t liveliness_lost_status;
ret = dds_get_liveliness_lost_status(wri, &liveliness_lost_status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(liveliness_lost_status.total_count, 0);
CU_ASSERT_EQUAL_FATAL(liveliness_lost_status.total_count_change, 0);
}
@ -935,10 +925,9 @@ CU_TheoryDataPoints(ddsc_get_liveliness_lost_status, bad_params) = {
CU_Theory((dds_entity_t writer), ddsc_get_liveliness_lost_status, bad_params, .init=init_entity_status, .fini=fini_entity_status)
{
dds_liveliness_lost_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_liveliness_lost_status(writer, &status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -947,7 +936,7 @@ CU_Test(ddsc_get_liveliness_lost_status, null, .init=init_entity_status, .fini=f
{
dds_set_status_mask(wri, 0);
ret = dds_get_liveliness_lost_status(wri, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
@ -958,7 +947,7 @@ CU_TheoryDataPoints(ddsc_get_liveliness_lost_status, non_writers) = {
CU_Theory((dds_entity_t *writer), ddsc_get_liveliness_lost_status, non_writers, .init=init_entity_status, .fini=fini_entity_status)
{
ret = dds_get_liveliness_lost_status(*writer, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -967,7 +956,7 @@ CU_Test(ddsc_get_liveliness_lost_status, deleted_writer, .init=init_entity_statu
{
dds_delete(wri);
ret = dds_get_liveliness_lost_status(wri, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -976,7 +965,7 @@ CU_Test(ddsc_get_offered_deadline_missed_status, offered_deadline_missed_status,
{
dds_offered_deadline_missed_status_t offered_deadline_missed_status;
ret = dds_get_offered_deadline_missed_status(wri, &offered_deadline_missed_status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(offered_deadline_missed_status.total_count, 0);
CU_ASSERT_EQUAL_FATAL(offered_deadline_missed_status.total_count_change, 0);
CU_ASSERT_EQUAL_FATAL(offered_deadline_missed_status.last_instance_handle, 0);
@ -990,10 +979,9 @@ CU_TheoryDataPoints(ddsc_get_offered_deadline_missed_status, bad_params) = {
CU_Theory((dds_entity_t writer), ddsc_get_offered_deadline_missed_status, bad_params, .init=init_entity_status, .fini=fini_entity_status)
{
dds_offered_deadline_missed_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_offered_deadline_missed_status(writer, &status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1002,7 +990,7 @@ CU_Test(ddsc_get_offered_deadline_missed_status, null, .init=init_entity_status,
{
dds_set_status_mask(wri, 0);
ret = dds_get_offered_deadline_missed_status(wri, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
@ -1013,7 +1001,7 @@ CU_TheoryDataPoints(ddsc_get_offered_deadline_missed_status, non_writers) = {
CU_Theory((dds_entity_t *writer), ddsc_get_offered_deadline_missed_status, non_writers, .init=init_entity_status, .fini=fini_entity_status)
{
ret = dds_get_offered_deadline_missed_status(*writer, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -1022,7 +1010,7 @@ CU_Test(ddsc_get_offered_deadline_missed_status, deleted_writer, .init=init_enti
{
dds_delete(wri);
ret = dds_get_offered_deadline_missed_status(wri, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1033,10 +1021,9 @@ CU_TheoryDataPoints(ddsc_get_offered_incompatible_qos_status, bad_params) = {
CU_Theory((dds_entity_t writer), ddsc_get_offered_incompatible_qos_status, bad_params, .init=init_entity_status, .fini=fini_entity_status)
{
dds_offered_incompatible_qos_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_offered_incompatible_qos_status(writer, &status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1045,7 +1032,7 @@ CU_Test(ddsc_get_offered_incompatible_qos_status, null, .init=init_entity_status
{
dds_set_status_mask(wri, 0);
ret = dds_get_offered_incompatible_qos_status(wri, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
@ -1056,7 +1043,7 @@ CU_TheoryDataPoints(ddsc_get_offered_incompatible_qos_status, non_writers) = {
CU_Theory((dds_entity_t *writer), ddsc_get_offered_incompatible_qos_status, non_writers, .init=init_entity_status, .fini=fini_entity_status)
{
ret = dds_get_offered_incompatible_qos_status(*writer, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -1065,7 +1052,7 @@ CU_Test(ddsc_get_offered_incompatible_qos_status, deleted_writer, .init=init_ent
{
dds_delete(wri);
ret = dds_get_offered_incompatible_qos_status(wri, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1076,10 +1063,9 @@ CU_TheoryDataPoints(ddsc_get_subscription_matched_status, bad_params) = {
CU_Theory((dds_entity_t reader), ddsc_get_subscription_matched_status, bad_params, .init=init_entity_status, .fini=fini_entity_status)
{
dds_subscription_matched_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_subscription_matched_status(reader, &status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1088,7 +1074,7 @@ CU_Test(ddsc_get_subscription_matched_status, null, .init=init_entity_status, .f
{
dds_set_status_mask(rea, 0);
ret = dds_get_subscription_matched_status(rea, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
@ -1099,7 +1085,7 @@ CU_TheoryDataPoints(ddsc_get_subscription_matched_status, non_readers) = {
CU_Theory((dds_entity_t *reader), ddsc_get_subscription_matched_status, non_readers, .init=init_entity_status, .fini=fini_entity_status)
{
ret = dds_get_subscription_matched_status(*reader, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -1108,7 +1094,7 @@ CU_Test(ddsc_get_subscription_matched_status, deleted_reader, .init=init_entity_
{
dds_delete(rea);
ret = dds_get_subscription_matched_status(rea, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1119,10 +1105,9 @@ CU_TheoryDataPoints(ddsc_get_liveliness_changed_status, bad_params) = {
CU_Theory((dds_entity_t reader), ddsc_get_liveliness_changed_status, bad_params, .init=init_entity_status, .fini=fini_entity_status)
{
dds_liveliness_changed_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_liveliness_changed_status(reader, &status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1131,7 +1116,7 @@ CU_Test(ddsc_get_liveliness_changed_status, null, .init=init_entity_status, .fin
{
dds_set_status_mask(rea, 0);
ret = dds_get_liveliness_changed_status(rea, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
@ -1142,7 +1127,7 @@ CU_TheoryDataPoints(ddsc_get_liveliness_changed_status, non_readers) = {
CU_Theory((dds_entity_t *reader), ddsc_get_liveliness_changed_status, non_readers, .init=init_entity_status, .fini=fini_entity_status)
{
ret = dds_get_liveliness_changed_status(*reader, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -1151,7 +1136,7 @@ CU_Test(ddsc_get_liveliness_changed_status, deleted_reader, .init=init_entity_st
{
dds_delete(rea);
ret = dds_get_liveliness_changed_status(rea, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1162,10 +1147,9 @@ CU_TheoryDataPoints(ddsc_get_sample_rejected_status, bad_params) = {
CU_Theory((dds_entity_t reader), ddsc_get_sample_rejected_status, bad_params, .init=init_entity_status, .fini=fini_entity_status)
{
dds_sample_rejected_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_sample_rejected_status(reader, &status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1174,7 +1158,7 @@ CU_Test(ddsc_get_sample_rejected_status, null, .init=init_entity_status, .fini=f
{
dds_set_status_mask(rea, 0);
ret = dds_get_sample_rejected_status(rea, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
@ -1185,7 +1169,7 @@ CU_TheoryDataPoints(ddsc_get_sample_rejected_status, non_readers) = {
CU_Theory((dds_entity_t *reader), ddsc_get_sample_rejected_status, non_readers, .init=init_entity_status, .fini=fini_entity_status)
{
ret = dds_get_sample_rejected_status(*reader, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -1194,7 +1178,7 @@ CU_Test(ddsc_get_sample_rejected_status, deleted_reader, .init=init_entity_statu
{
dds_delete(rea);
ret = dds_get_sample_rejected_status(rea, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1205,10 +1189,9 @@ CU_TheoryDataPoints(ddsc_get_sample_lost_status, bad_params) = {
CU_Theory((dds_entity_t reader), ddsc_get_sample_lost_status, bad_params, .init=init_entity_status, .fini=fini_entity_status)
{
dds_sample_lost_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_sample_lost_status(reader, &status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1217,7 +1200,7 @@ CU_Test(ddsc_get_sample_lost_status, null, .init=init_entity_status, .fini=fini_
{
dds_set_status_mask(rea, 0);
ret = dds_get_sample_lost_status(rea, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
@ -1228,7 +1211,7 @@ CU_TheoryDataPoints(ddsc_get_sample_lost_status, non_readers) = {
CU_Theory((dds_entity_t *reader), ddsc_get_sample_lost_status, non_readers, .init=init_entity_status, .fini=fini_entity_status)
{
ret = dds_get_sample_lost_status(*reader, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -1237,7 +1220,7 @@ CU_Test(ddsc_get_sample_lost_status, deleted_reader, .init=init_entity_status, .
{
dds_delete(rea);
ret = dds_get_sample_lost_status(rea, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1246,7 +1229,7 @@ CU_Test(ddsc_get_requested_deadline_missed_status, requested_deadline_missed_sta
{
dds_requested_deadline_missed_status_t requested_deadline_missed_status;
ret = dds_get_requested_deadline_missed_status(rea, &requested_deadline_missed_status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(requested_deadline_missed_status.total_count, 0);
CU_ASSERT_EQUAL_FATAL(requested_deadline_missed_status.total_count_change, 0);
CU_ASSERT_EQUAL_FATAL(requested_deadline_missed_status.last_instance_handle, DDS_HANDLE_NIL);
@ -1260,10 +1243,9 @@ CU_TheoryDataPoints(ddsc_get_requested_deadline_missed_status, bad_params) = {
CU_Theory((dds_entity_t reader), ddsc_get_requested_deadline_missed_status, bad_params, .init=init_entity_status, .fini=fini_entity_status)
{
dds_requested_deadline_missed_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_requested_deadline_missed_status(reader, &status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1272,7 +1254,7 @@ CU_Test(ddsc_get_requested_deadline_missed_status, null, .init=init_entity_statu
{
dds_set_status_mask(rea, 0);
ret = dds_get_requested_deadline_missed_status(rea, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
@ -1283,7 +1265,7 @@ CU_TheoryDataPoints(ddsc_get_requested_deadline_missed_status, non_readers) = {
CU_Theory((dds_entity_t *reader), ddsc_get_requested_deadline_missed_status, non_readers, .init=init_entity_status, .fini=fini_entity_status)
{
ret = dds_get_requested_deadline_missed_status(*reader, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -1292,7 +1274,7 @@ CU_Test(ddsc_get_requested_deadline_missed_status, deleted_reader, .init=init_en
{
dds_delete(rea);
ret = dds_get_requested_deadline_missed_status(rea, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1303,10 +1285,9 @@ CU_TheoryDataPoints(ddsc_get_requested_incompatible_qos_status, bad_params) = {
CU_Theory((dds_entity_t reader), ddsc_get_requested_incompatible_qos_status, bad_params, .init=init_entity_status, .fini=fini_entity_status)
{
dds_requested_incompatible_qos_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_requested_incompatible_qos_status(reader, &status);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1315,7 +1296,7 @@ CU_Test(ddsc_get_requested_incompatible_qos_status, null, .init=init_entity_stat
{
dds_set_status_mask(rea, 0);
ret = dds_get_requested_incompatible_qos_status(rea, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
}
/*************************************************************************************************/
@ -1326,7 +1307,7 @@ CU_TheoryDataPoints(ddsc_get_requested_incompatible_qos_status, non_readers) = {
CU_Theory((dds_entity_t *reader), ddsc_get_requested_incompatible_qos_status, non_readers, .init=init_entity_status, .fini=fini_entity_status)
{
ret = dds_get_requested_incompatible_qos_status(*reader, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -1335,7 +1316,7 @@ CU_Test(ddsc_get_requested_incompatible_qos_status, deleted_reader, .init=init_e
{
dds_delete(rea);
ret = dds_get_requested_incompatible_qos_status(rea, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/

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

@ -63,7 +63,7 @@ CU_Test(ddsc_instance_get_key, bad_entity, .init=setup, .fini=teardown)
dds_return_t ret;
ret = dds_instance_get_key(participant, handle, &data);
CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_instance_get_key, null_data, .init=setup, .fini=teardown)
@ -71,7 +71,7 @@ CU_Test(ddsc_instance_get_key, null_data, .init=setup, .fini=teardown)
dds_return_t ret;
ret = dds_register_instance(writer, &handle, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_instance_get_key, null_handle, .init=setup, .fini=teardown)
@ -81,7 +81,7 @@ CU_Test(ddsc_instance_get_key, null_handle, .init=setup, .fini=teardown)
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_instance_get_key(writer, DDS_HANDLE_NIL, &data);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_instance_get_key, registered_instance, .init=setup, .fini=teardown)
@ -99,7 +99,7 @@ CU_Test(ddsc_instance_get_key, registered_instance, .init=setup, .fini=teardown)
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);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
RoundTripModule_Address_free(&key_data, DDS_FREE_CONTENTS);
}

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

@ -17,8 +17,6 @@
#include "dds/version.h"
#include "dds/ddsrt/environ.h"
#define cu_assert_status_eq(s1, s2) CU_ASSERT_EQUAL_FATAL(dds_err_nr(s1), s2)
CU_Test(ddsc_participant, create_and_delete) {
@ -59,14 +57,14 @@ CU_Test(ddsc_participant, create_with_no_conf_no_env)
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(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);
CU_ASSERT_FATAL(participant3 > 0);
status = dds_get_domainid(participant3, &domain_id);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain);
dds_delete(participant2);
@ -98,7 +96,7 @@ CU_Test(ddsc_participant, create_with_conf_no_env) {
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(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain);
@ -106,7 +104,7 @@ CU_Test(ddsc_participant, create_with_conf_no_env) {
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(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain);
dds_delete(participant2);
@ -127,7 +125,7 @@ CU_Test(ddsc_participant_lookup, one) {
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
num_of_found_pp = dds_lookup_participant( domain_id, participants, size);
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 1);
@ -153,7 +151,7 @@ CU_Test(ddsc_participant_lookup, multiple) {
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
num_of_found_pp = dds_lookup_participant( domain_id, participants, size);
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 2);
@ -185,7 +183,7 @@ CU_Test(ddsc_participant_lookup, array_too_small) {
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
num_of_found_pp = dds_lookup_participant( domain_id, participants, size);
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 3);
@ -211,7 +209,7 @@ CU_Test(ddsc_participant_lookup, null_zero){
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
num_of_found_pp = dds_lookup_participant( domain_id, NULL, size);
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 1);
@ -232,10 +230,10 @@ CU_Test(ddsc_participant_lookup, null_nonzero){
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
num_of_found_pp = dds_lookup_participant( domain_id, NULL, size);
cu_assert_status_eq(num_of_found_pp, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, DDS_RETCODE_BAD_PARAMETER);
dds_delete (participant);
}
@ -254,7 +252,7 @@ CU_Test(ddsc_participant_lookup, unknown_id) {
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
domain_id ++;
num_of_found_pp = dds_lookup_participant( domain_id, participants, size);
@ -287,7 +285,7 @@ CU_Test(ddsc_participant_lookup, no_more) {
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
dds_delete (participant);
@ -312,7 +310,7 @@ CU_Test(ddsc_participant_lookup, deleted) {
/* Get domain id */
status = dds_get_domainid(participant, &domain_id);
cu_assert_status_eq(status, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
dds_delete (participant2);

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

@ -19,8 +19,6 @@
#pragma warning(disable: 28020)
#endif
#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)
{
@ -42,7 +40,7 @@ CU_Test(ddsc_publisher, create)
/* Use NULL participant */
publisher = dds_create_publisher(0, NULL, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(publisher, DDS_RETCODE_PRECONDITION_NOT_MET);
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
CU_ASSERT_FATAL(participant > 0);
@ -53,7 +51,7 @@ CU_Test(ddsc_publisher, create)
/* Use entity that is not a participant */
publisher1 = dds_create_publisher(publisher, NULL, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher1), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(publisher1, DDS_RETCODE_ILLEGAL_OPERATION);
dds_delete(publisher);
/* Create a non-null qos */
@ -143,35 +141,35 @@ CU_Test(ddsc_publisher, suspend_resume)
/* Suspend a 0 publisher */
status = dds_suspend(0);
cu_assert_status_eq(status, DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_PRECONDITION_NOT_MET);
/* Resume a 0 publisher */
status = dds_resume(0);
cu_assert_status_eq(status, DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_PRECONDITION_NOT_MET);
/* Uae dds_suspend on something else than a publisher */
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
CU_ASSERT_FATAL(participant > 0);
status = dds_suspend(participant);
cu_assert_status_eq(status, DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_ILLEGAL_OPERATION);
/* Use dds_resume on something else than a publisher */
status = dds_resume(participant);
cu_assert_status_eq(status, DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_ILLEGAL_OPERATION);
/* Use dds_resume without calling dds_suspend */
publisher = dds_create_publisher(participant, NULL, NULL);
CU_ASSERT_FATAL(publisher > 0);
status = dds_resume(publisher); /* Should be precondition not met? */
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED);
/* Use dds_suspend on non-null publisher */
status = dds_suspend(publisher);
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED);
/* Use dds_resume on non-null publisher */
status = dds_resume(publisher);
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED);
dds_delete(publisher);
dds_delete(participant);
@ -189,38 +187,38 @@ CU_Test(ddsc_publisher, wait_for_acks)
/* Wait_for_acks on 0 publisher or writer and minusOneSec timeout */
status = dds_wait_for_acks(0, minusOneSec);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
/* Wait_for_acks on NULL publisher or writer and zeroSec timeout */
status = dds_wait_for_acks(0, zeroSec);
cu_assert_status_eq(status, DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_PRECONDITION_NOT_MET);
/* wait_for_acks on NULL publisher or writer and oneSec timeout */
status = dds_wait_for_acks(0, oneSec);
cu_assert_status_eq(status, DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_PRECONDITION_NOT_MET);
/* wait_for_acks on NULL publisher or writer and DDS_INFINITE timeout */
status = dds_wait_for_acks(0, DDS_INFINITY);
cu_assert_status_eq(status, DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_PRECONDITION_NOT_MET);
participant = 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);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
/* Wait_for_acks on participant and zeroSec timeout */
status = dds_wait_for_acks(participant, zeroSec);
cu_assert_status_eq(status, DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_ILLEGAL_OPERATION);
/* Wait_for_acks on participant and oneSec timeout */
status = dds_wait_for_acks(participant, oneSec);
cu_assert_status_eq(status, DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_ILLEGAL_OPERATION);
/* Wait_for_acks on participant and DDS_INFINITE timeout */
status = dds_wait_for_acks(participant, DDS_INFINITY);
cu_assert_status_eq(status, DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_ILLEGAL_OPERATION);
publisher = dds_create_publisher(participant, NULL, NULL);
CU_ASSERT_FATAL(publisher > 0);
@ -228,40 +226,40 @@ CU_Test(ddsc_publisher, wait_for_acks)
/* Wait_for_acks on publisher and minusOneSec timeout --
either BAD_PARAMETER or UNSUPPORTED would be both be ok, really */
status = dds_wait_for_acks(publisher, minusOneSec);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
/* Wait_for_acks on publisher and zeroSec timeout */
status = dds_wait_for_acks(publisher, zeroSec);
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED);
/* Wait_for_acks on publisher and oneSec timeout */
status = dds_wait_for_acks(publisher, oneSec);
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED);
/* Wait_for_acks on publisher and DDS_INFINITE timeout */
status = dds_wait_for_acks(publisher, DDS_INFINITY);
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED);
/* TODO: create tests by calling dds_qwait_for_acks on writers */
status = dds_suspend(publisher);
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED);
/* Wait_for_acks on suspended publisher and minusOneSec timeout */
status = dds_wait_for_acks(publisher, minusOneSec);
cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
/* Wait_for_acks on suspended publisher and zeroSec timeout */
status = dds_wait_for_acks(publisher, zeroSec);
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED);
/* Wait_for_acks on suspended publisher and oneSec timeout */
status = dds_wait_for_acks(publisher, oneSec);
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED);
/* Wait_for_acks on suspended publisher and DDS_INFINITE timeout */
status = dds_wait_for_acks(publisher, DDS_INFINITY);
cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED);
dds_delete(publisher);
dds_delete(participant);

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

@ -234,7 +234,7 @@ CU_Test(ddsc_qos, copy_bad_source, .init=qos_init, .fini=qos_fini)
dds_return_t result;
result = dds_copy_qos(g_qos, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(result, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_qos, copy_bad_destination, .init=qos_init, .fini=qos_fini)
@ -242,7 +242,7 @@ CU_Test(ddsc_qos, copy_bad_destination, .init=qos_init, .fini=qos_fini)
dds_return_t result;
result = dds_copy_qos(NULL, g_qos);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(result, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_qos, copy_with_partition, .init=qos_init, .fini=qos_fini)

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

@ -245,7 +245,7 @@ CU_Test(ddsc_querycondition_create, deleted_reader, .init=querycondition_init, .
dds_entity_t cond;
dds_delete(g_reader);
cond = dds_create_querycondition(g_reader, mask, filter_mod2);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(cond, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -256,11 +256,10 @@ CU_TheoryDataPoints(ddsc_querycondition_create, invalid_readers) = {
CU_Theory((dds_entity_t rdr), ddsc_querycondition_create, invalid_readers, .init=querycondition_init, .fini=querycondition_fini)
{
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_entity_t cond;
cond = dds_create_querycondition(rdr, mask, filter_mod2);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(cond, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -273,7 +272,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_querycondition_create, non_readers, .init=qu
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_entity_t cond;
cond = dds_create_querycondition(*rdr, mask, filter_mod2);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(cond, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -297,7 +296,7 @@ CU_Test(ddsc_querycondition_get_mask, deleted, .init=querycondition_init, .fini=
dds_delete(condition);
mask = 0;
ret = dds_get_mask(condition, &mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -312,7 +311,7 @@ CU_Test(ddsc_querycondition_get_mask, null, .init=querycondition_init, .fini=que
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_get_mask(condition, NULL);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
dds_delete(condition);
}
/*************************************************************************************************/
@ -323,12 +322,11 @@ CU_TheoryDataPoints(ddsc_querycondition_get_mask, invalid_conditions) = {
};
CU_Theory((dds_entity_t cond), ddsc_querycondition_get_mask, invalid_conditions, .init=querycondition_init, .fini=querycondition_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
uint32_t mask;
ret = dds_get_mask(cond, &mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -341,7 +339,7 @@ CU_Theory((dds_entity_t *cond), ddsc_querycondition_get_mask, non_conditions, .i
dds_return_t ret;
uint32_t mask;
ret = dds_get_mask(*cond, &mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -362,7 +360,7 @@ CU_Theory((uint32_t ss, uint32_t vs, uint32_t is), ddsc_querycondition_get_mask,
CU_ASSERT_FATAL(condition > 0);
ret = dds_get_mask(condition, &maskOut);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(maskIn, maskOut);
dds_delete(condition);
@ -924,7 +922,7 @@ CU_Test(ddsc_querycondition_read, already_deleted, .init=querycondition_init, .f
/* Try to read with a deleted condition. */
ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1487,7 +1485,7 @@ CU_Test(ddsc_querycondition_take, already_deleted, .init=querycondition_init, .f
/* Try to take with a deleted condition. */
ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/

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

@ -299,7 +299,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, u
* However, that's not the case yet. So don't test it. */
if (buf != g_loans) {
ret = dds_read_instance(*ent, buf, si, bufsz, maxs, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS("Skipped");
}
@ -320,7 +320,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs),
* invalid and neither is the handle. So, don't test that. */
if ((buf != g_loans) || (si != g_info) || (maxs == 0)) {
ret = dds_read_instance_wl(*ent, buf, si, maxs, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS("Skipped");
}
@ -350,7 +350,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, u
* However, that's not the case yet. So don't test it. */
if (buf != g_loans) {
ret = dds_read_instance_mask(*ent, buf, si, bufsz, maxs, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS("Skipped");
}
@ -372,7 +372,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs),
* invalid and neither is the handle. So, don't test that. */
CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0));
ret = dds_read_instance_mask_wl(*ent, buf, si, maxs, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -394,7 +394,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance, in
{
dds_return_t ret;
ret = dds_read_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -407,7 +407,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance_wl,
{
dds_return_t ret;
ret = dds_read_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -421,7 +421,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance_mas
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret;
ret = dds_read_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -435,7 +435,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance_mas
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret;
ret = dds_read_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -454,11 +454,10 @@ CU_TheoryDataPoints(ddsc_read_instance, invalid_readers) = {
};
CU_Theory((dds_entity_t rdr), ddsc_read_instance, invalid_readers, .init=read_instance_init, .fini=read_instance_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_read_instance(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -468,11 +467,10 @@ CU_TheoryDataPoints(ddsc_read_instance_wl, invalid_readers) = {
};
CU_Theory((dds_entity_t rdr), ddsc_read_instance_wl, invalid_readers, .init=read_instance_init, .fini=read_instance_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_read_instance_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -483,11 +481,10 @@ CU_TheoryDataPoints(ddsc_read_instance_mask, invalid_readers) = {
CU_Theory((dds_entity_t rdr), ddsc_read_instance_mask, invalid_readers, .init=read_instance_init, .fini=read_instance_fini)
{
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_read_instance_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -498,11 +495,10 @@ CU_TheoryDataPoints(ddsc_read_instance_mask_wl, invalid_readers) = {
CU_Theory((dds_entity_t rdr), ddsc_read_instance_mask_wl, invalid_readers, .init=read_instance_init, .fini=read_instance_fini)
{
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_read_instance_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -524,7 +520,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance, non_readers, .init=read_insta
{
dds_return_t ret;
ret = dds_read_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -536,7 +532,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance_wl, non_readers, .init=read_in
{
dds_return_t ret;
ret = dds_read_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -549,7 +545,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance_mask, non_readers, .init=read_
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret;
ret = dds_read_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -562,7 +558,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance_mask_wl, non_readers, .init=re
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret;
ret = dds_read_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -586,7 +582,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance, already_deleted, .init=read_i
ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_read_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -600,7 +596,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance_wl, already_deleted, .init=rea
ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_read_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -615,7 +611,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance_mask, already_deleted, .init=r
ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_read_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -630,7 +626,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance_mask_wl, already_deleted, .ini
ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_read_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/

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

@ -227,7 +227,7 @@ CU_Test(ddsc_readcondition_create, deleted_reader, .init=readcondition_init, .fi
dds_entity_t cond;
dds_delete(g_reader);
cond = dds_create_readcondition(g_reader, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(cond, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -238,11 +238,10 @@ CU_TheoryDataPoints(ddsc_readcondition_create, invalid_readers) = {
CU_Theory((dds_entity_t rdr), ddsc_readcondition_create, invalid_readers, .init=readcondition_init, .fini=readcondition_fini)
{
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_entity_t cond;
cond = dds_create_readcondition(rdr, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(cond, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -255,7 +254,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_readcondition_create, non_readers, .init=rea
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_entity_t cond;
cond = dds_create_readcondition(*rdr, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(cond, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -279,7 +278,7 @@ CU_Test(ddsc_readcondition_get_mask, deleted, .init=readcondition_init, .fini=re
dds_delete(condition);
mask = 0;
ret = dds_get_mask(condition, &mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -294,7 +293,7 @@ CU_Test(ddsc_readcondition_get_mask, null, .init=readcondition_init, .fini=readc
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_get_mask(condition, NULL);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
dds_delete(condition);
}
/*************************************************************************************************/
@ -305,12 +304,11 @@ CU_TheoryDataPoints(ddsc_readcondition_get_mask, invalid_conditions) = {
};
CU_Theory((dds_entity_t cond), ddsc_readcondition_get_mask, invalid_conditions, .init=readcondition_init, .fini=readcondition_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
uint32_t mask;
ret = dds_get_mask(cond, &mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -323,7 +321,7 @@ CU_Theory((dds_entity_t *cond), ddsc_readcondition_get_mask, non_conditions, .in
dds_return_t ret;
uint32_t mask;
ret = dds_get_mask(*cond, &mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -344,7 +342,7 @@ CU_Theory((uint32_t ss, uint32_t vs, uint32_t is), ddsc_readcondition_get_mask,
CU_ASSERT_FATAL(condition > 0);
ret = dds_get_mask(condition, &maskOut);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(maskIn, maskOut);
dds_delete(condition);
@ -906,7 +904,7 @@ CU_Test(ddsc_readcondition_read, already_deleted, .init=readcondition_init, .fin
/* Try to read with a deleted condition. */
ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1462,7 +1460,7 @@ CU_Test(ddsc_readcondition_take, already_deleted, .init=readcondition_init, .fin
/* Try to take with a deleted condition. */
ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/

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

@ -241,7 +241,7 @@ CU_Test(ddsc_reader_create, invalid_qos_participant, .init=reader_init, .fini=re
dds_qset_reader_data_lifecycle(qos, DDS_SECS(-1), DDS_SECS(-1));
DDSRT_WARNING_MSVC_ON(28020);
rdr = dds_create_reader(g_participant, g_topic, qos, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(rdr), DDS_RETCODE_INCONSISTENT_POLICY);
CU_ASSERT_EQUAL_FATAL(rdr, DDS_RETCODE_INCONSISTENT_POLICY);
dds_delete_qos(qos);
}
/*************************************************************************************************/
@ -256,7 +256,7 @@ CU_Test(ddsc_reader_create, invalid_qos_subscriber, .init=reader_init, .fini=rea
dds_qset_reader_data_lifecycle(qos, DDS_SECS(-1), DDS_SECS(-1));
DDSRT_WARNING_MSVC_ON(28020);
rdr = dds_create_reader(g_subscriber, g_topic, qos, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(rdr), DDS_RETCODE_INCONSISTENT_POLICY);
CU_ASSERT_EQUAL_FATAL(rdr, DDS_RETCODE_INCONSISTENT_POLICY);
dds_delete_qos(qos);
}
/*************************************************************************************************/
@ -273,7 +273,7 @@ CU_Theory((dds_entity_t *par, dds_entity_t *top), ddsc_reader_create, non_partic
* actually the topic. So, don't test that permutation. */
CU_ASSERT_FATAL((par != &g_participant) || (top != &g_topic));
rdr = dds_create_reader(*par, *top, NULL, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(rdr), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(rdr, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -307,7 +307,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc
* However, that's not the case yet. So don't test it. */
if (buf != g_loans) {
ret = dds_read(g_reader, buf, si, bufsz, maxs);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS("Skipped");
}
@ -320,11 +320,10 @@ CU_TheoryDataPoints(ddsc_read, invalid_readers) = {
};
CU_Theory((dds_entity_t rdr), ddsc_read, invalid_readers, .init=reader_init, .fini=reader_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_read(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -336,7 +335,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read, non_readers, .init=reader_init, .fini=
{
dds_return_t ret;
ret = dds_read(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -347,7 +346,7 @@ CU_Test(ddsc_read, already_deleted, .init=reader_init, .fini=reader_fini)
/* Try to read with a deleted reader. */
dds_delete(g_reader);
ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -420,7 +419,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_read_wl, inva
* invalid. So, don't test that. */
CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0));
ret = dds_read_wl(g_reader, buf, si, maxs);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -430,11 +429,10 @@ CU_TheoryDataPoints(ddsc_read_wl, invalid_readers) = {
};
CU_Theory((dds_entity_t rdr), ddsc_read_wl, invalid_readers, .init=reader_init, .fini=reader_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_read_wl(rdr, g_loans, g_info, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -446,7 +444,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_wl, non_readers, .init=reader_init, .fi
{
dds_return_t ret;
ret = dds_read_wl(*rdr, g_loans, g_info, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -457,7 +455,7 @@ CU_Test(ddsc_read_wl, already_deleted, .init=reader_init, .fini=reader_fini)
/* Try to read with a deleted reader. */
dds_delete(g_reader);
ret = dds_read_wl(g_reader, g_loans, g_info, MAX_SAMPLES);
CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -541,7 +539,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc
* However, that's not the case yet. So don't test it. */
if (buf != g_loans) {
ret = dds_read_mask(g_reader, buf, si, bufsz, maxs, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS("Skipped");
}
@ -555,11 +553,10 @@ CU_TheoryDataPoints(ddsc_read_mask, invalid_readers) = {
CU_Theory((dds_entity_t rdr), ddsc_read_mask, invalid_readers, .init=reader_init, .fini=reader_fini)
{
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_read_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -572,7 +569,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_mask, non_readers, .init=reader_init, .
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret;
ret = dds_read_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -584,7 +581,7 @@ CU_Test(ddsc_read_mask, already_deleted, .init=reader_init, .fini=reader_fini)
/* Try to read with a deleted reader. */
dds_delete(g_reader);
ret = dds_read_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask);
CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1092,7 +1089,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_read_mask_wl,
* invalid. So, don't test that. */
CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0));
ret = dds_read_mask_wl(g_reader, buf, si, maxs, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1103,11 +1100,10 @@ CU_TheoryDataPoints(ddsc_read_mask_wl, invalid_readers) = {
CU_Theory((dds_entity_t rdr), ddsc_read_mask_wl, invalid_readers, .init=reader_init, .fini=reader_fini)
{
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_read_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1120,7 +1116,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_mask_wl, non_readers, .init=reader_init
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret;
ret = dds_read_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -1132,7 +1128,7 @@ CU_Test(ddsc_read_mask_wl, already_deleted, .init=reader_init, .fini=reader_fini
/* Try to read with a deleted reader. */
dds_delete(g_reader);
ret = dds_read_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask);
CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1677,7 +1673,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc
* However, that's not the case yet. So don't test it. */
if (buf != g_loans) {
ret = dds_take(g_reader, buf, si, bufsz, maxs);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS("Skipped");
}
@ -1690,11 +1686,10 @@ CU_TheoryDataPoints(ddsc_take, invalid_readers) = {
};
CU_Theory((dds_entity_t rdr), ddsc_take, invalid_readers, .init=reader_init, .fini=reader_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_take(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1706,7 +1701,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take, non_readers, .init=reader_init, .fini=
{
dds_return_t ret;
ret = dds_take(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -1717,7 +1712,7 @@ CU_Test(ddsc_take, already_deleted, .init=reader_init, .fini=reader_fini)
/* Try to take with a deleted reader. */
dds_delete(g_reader);
ret = dds_take(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES);
CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1790,7 +1785,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_take_wl, inva
* invalid. So, don't test that. */
CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0));
ret = dds_take_wl(g_reader, buf, si, maxs);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1800,11 +1795,10 @@ CU_TheoryDataPoints(ddsc_take_wl, invalid_readers) = {
};
CU_Theory((dds_entity_t rdr), ddsc_take_wl, invalid_readers, .init=reader_init, .fini=reader_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_take_wl(rdr, g_loans, g_info, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1816,7 +1810,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_wl, non_readers, .init=reader_init, .fi
{
dds_return_t ret;
ret = dds_take_wl(*rdr, g_loans, g_info, MAX_SAMPLES);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -1827,7 +1821,7 @@ CU_Test(ddsc_take_wl, already_deleted, .init=reader_init, .fini=reader_fini)
/* Try to read with a deleted reader. */
dds_delete(g_reader);
ret = dds_take_wl(g_reader, g_loans, g_info, MAX_SAMPLES);
CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1912,7 +1906,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc
* However, that's not the case yet. So don't test it. */
if (buf != g_loans) {
ret = dds_take_mask(g_reader, buf, si, bufsz, maxs, mask);
CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS("Skipped");
}
@ -1926,11 +1920,10 @@ CU_TheoryDataPoints(ddsc_take_mask, invalid_readers) = {
CU_Theory((dds_entity_t rdr), ddsc_take_mask, invalid_readers, .init=reader_init, .fini=reader_fini)
{
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_take_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask);
CU_ASSERT_EQUAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -1943,7 +1936,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_mask, non_readers, .init=reader_init, .
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret;
ret = dds_take_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask);
CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -1955,7 +1948,7 @@ CU_Test(ddsc_take_mask, already_deleted, .init=reader_init, .fini=reader_fini)
/* Try to read with a deleted reader. */
dds_delete(g_reader);
ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask);
CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -2596,7 +2589,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_take_mask_wl,
* invalid. So, don't test that. */
CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0));
ret = dds_take_mask_wl(g_reader, buf, si, maxs, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -2607,11 +2600,10 @@ CU_TheoryDataPoints(ddsc_take_mask_wl, invalid_readers) = {
CU_Theory((dds_entity_t rdr), ddsc_take_mask_wl, invalid_readers, .init=reader_init, .fini=reader_fini)
{
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_take_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -2624,7 +2616,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_mask_wl, non_readers, .init=reader_init
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret;
ret = dds_take_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -2636,7 +2628,7 @@ CU_Test(ddsc_take_mask_wl, already_deleted, .init=reader_init, .fini=reader_fini
/* Try to read with a deleted reader. */
dds_delete(g_reader);
ret = dds_take_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/

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

@ -360,11 +360,10 @@ CU_TheoryDataPoints(ddsc_read_next, invalid_readers) = {
};
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);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -376,7 +375,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_next, non_readers, .init=reader_iterato
{
dds_return_t ret;
ret = dds_read_next(*rdr, g_samples, g_info);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -390,7 +389,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_next, already_deleted, .init=reader_ite
ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_read_next(*rdr, g_samples, g_info);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -405,7 +404,7 @@ CU_Theory((void **buf, dds_sample_info_t *si), ddsc_read_next, invalid_buffers,
dds_return_t 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);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS("Skipped");
}
@ -476,11 +475,10 @@ CU_TheoryDataPoints(ddsc_read_next_wl, invalid_readers) = {
};
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);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -492,7 +490,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_next_wl, non_readers, .init=reader_iter
{
dds_return_t ret;
ret = dds_read_next_wl(*rdr, g_loans, g_info);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -506,7 +504,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_next_wl, already_deleted, .init=reader_
ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_read_next_wl(*rdr, g_loans, g_info);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -521,7 +519,7 @@ CU_Theory((void **buf, dds_sample_info_t *si), ddsc_read_next_wl, invalid_buffer
dds_return_t 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);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS("Skipped");
}
@ -586,11 +584,10 @@ CU_TheoryDataPoints(ddsc_take_next, invalid_readers) = {
};
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);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -602,7 +599,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_next, non_readers, .init=reader_iterato
{
dds_return_t ret;
ret = dds_take_next(*rdr, g_samples, g_info);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -616,7 +613,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_next, already_deleted, .init=reader_ite
ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_take_next(*rdr, g_samples, g_info);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -631,7 +628,7 @@ CU_Theory((void **buf, dds_sample_info_t *si), ddsc_take_next, invalid_buffers,
dds_return_t 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);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS("Skipped");
}
@ -699,11 +696,10 @@ CU_TheoryDataPoints(ddsc_take_next_wl, invalid_readers) = {
};
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);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -715,7 +711,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_next_wl, non_readers, .init=reader_iter
{
dds_return_t ret;
ret = dds_take_next_wl(*rdr, g_loans, g_info);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -729,7 +725,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_next_wl, already_deleted, .init=reader_
ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_take_next_wl(*rdr, g_loans, g_info);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -743,7 +739,7 @@ CU_Theory((void **buf, dds_sample_info_t *si), ddsc_take_next_wl, invalid_buffer
dds_return_t 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);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS("Skipped");
}

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

@ -150,7 +150,7 @@ CU_Test(ddsc_register_instance, deleted_entity, .init=registering_init, .fini=re
dds_instance_handle_t handle;
dds_delete(g_writer);
ret = dds_register_instance(g_writer, &handle, g_data);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
static dds_instance_handle_t hndle = 0;
@ -169,7 +169,7 @@ CU_Theory((dds_instance_handle_t *hndl2, void *datap), ddsc_register_instance, i
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_register_instance(g_writer, hndl2, datap);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_TheoryDataPoints(ddsc_register_instance, invalid_writers) = {
@ -177,12 +177,11 @@ CU_TheoryDataPoints(ddsc_register_instance, invalid_writers) = {
};
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);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
CU_TheoryDataPoints(ddsc_register_instance, non_writers) = {
@ -193,7 +192,7 @@ CU_Theory((dds_entity_t *writer), ddsc_register_instance, non_writers, .init=reg
dds_return_t ret;
dds_instance_handle_t handle;
ret = dds_register_instance(*writer, &handle, g_data);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
CU_Test(ddsc_register_instance, registering_new_instance, .init=registering_init, .fini=registering_fini)

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

@ -36,7 +36,7 @@ void delete_entities(void)
{
dds_return_t result;
result = dds_delete(participant);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(result), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(result, DDS_RETCODE_OK);
dds_delete(read_condition);
}
@ -86,7 +86,7 @@ CU_Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = de
void **buf = NULL;
result = dds_return_loan(reader, NULL, 0);
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL(result, DDS_RETCODE_BAD_PARAMETER);
#ifdef _MSC_VER
#pragma warning(push)
@ -96,7 +96,7 @@ CU_Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = de
#ifdef _MSC_VER
#pragma warning(pop)
#endif
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL(result, DDS_RETCODE_BAD_PARAMETER);
buf = create_loan_buf(10, false);
#ifdef _MSC_VER
@ -107,10 +107,10 @@ CU_Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = de
#ifdef _MSC_VER
#pragma warning(pop)
#endif
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL(result, DDS_RETCODE_BAD_PARAMETER);
result = dds_return_loan(participant, buf, 0);
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL(result, DDS_RETCODE_ILLEGAL_OPERATION);
delete_loan_buf(buf, 10, false);
}
@ -124,17 +124,17 @@ CU_Test(ddsc_reader, return_loan_success, .init = create_entities, .fini = delet
buf = create_loan_buf(10, false);
result = dds_return_loan(reader, buf, 10);
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK);
CU_ASSERT_EQUAL(result, DDS_RETCODE_OK);
result = dds_return_loan(reader, &buf2, 0);
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK);
CU_ASSERT_EQUAL(result, DDS_RETCODE_OK);
delete_loan_buf(buf, 10, true);
buf = create_loan_buf(10, false);
result = dds_return_loan(read_condition, buf, 10);
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK);
CU_ASSERT_EQUAL(result, DDS_RETCODE_OK);
result = dds_return_loan(read_condition, &buf2, 0);
CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK);
CU_ASSERT_EQUAL(result, DDS_RETCODE_OK);
delete_loan_buf(buf, 10, true);
}

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

@ -48,7 +48,7 @@ CU_Test(ddsc_subscriber, notify_readers) {
/* todo implement tests */
ret = dds_notify_readers(subscriber);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_UNSUPPORTED);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_UNSUPPORTED);
dds_delete(subscriber);
dds_delete(participant);
@ -67,7 +67,7 @@ CU_Test(ddsc_subscriber, create) {
/*** Verify participant parameter ***/
subscriber = dds_create_subscriber(0, NULL, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(subscriber, DDS_RETCODE_BAD_PARAMETER);
subscriber = dds_create_subscriber(participant, NULL, NULL);
CU_ASSERT_FATAL(subscriber > 0);
@ -91,7 +91,7 @@ CU_Test(ddsc_subscriber, create) {
sqos = dds_create_qos();
dds_qset_presentation(sqos, 123, 1, 1); /* Set invalid presentation policy */
subscriber = dds_create_subscriber(participant, sqos, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), DDS_RETCODE_INCONSISTENT_POLICY);
CU_ASSERT_EQUAL_FATAL(subscriber, DDS_RETCODE_INCONSISTENT_POLICY);
dds_delete_qos(sqos);
/*** Verify listener parameter ***/

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

@ -299,7 +299,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, u
* However, that's not the case yet. So don't test it. */
if (buf != g_loans) {
ret = dds_take_instance(*ent, buf, si, bufsz, maxs, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS("Skipped");
}
@ -320,7 +320,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs),
* invalid and neither is the handle. So, don't test that. */
CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0));
ret = dds_take_instance_wl(*ent, buf, si, maxs, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -347,7 +347,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, u
* However, that's not the case yet. So don't test it. */
if (buf != g_loans) {
ret = dds_take_instance_mask(*ent, buf, si, bufsz, maxs, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
} else {
CU_PASS("Skipped");
}
@ -369,7 +369,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs),
* invalid and neither is the handle. So, don't test that. */
CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0));
ret = dds_take_instance_mask_wl(*ent, buf, si, maxs, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -391,7 +391,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance, in
{
dds_return_t ret;
ret = dds_take_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -404,7 +404,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance_wl,
{
dds_return_t ret;
ret = dds_take_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -418,7 +418,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance_mas
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret;
ret = dds_take_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -432,7 +432,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance_mas
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret;
ret = dds_take_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -451,11 +451,10 @@ CU_TheoryDataPoints(ddsc_take_instance, invalid_readers) = {
};
CU_Theory((dds_entity_t rdr), ddsc_take_instance, invalid_readers, .init=take_instance_init, .fini=take_instance_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_take_instance(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -465,11 +464,10 @@ CU_TheoryDataPoints(ddsc_take_instance_wl, invalid_readers) = {
};
CU_Theory((dds_entity_t rdr), ddsc_take_instance_wl, invalid_readers, .init=take_instance_init, .fini=take_instance_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_take_instance_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -480,11 +478,10 @@ CU_TheoryDataPoints(ddsc_take_instance_mask, invalid_readers) = {
CU_Theory((dds_entity_t rdr), ddsc_take_instance_mask, invalid_readers, .init=take_instance_init, .fini=take_instance_fini)
{
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_take_instance_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -495,11 +492,10 @@ CU_TheoryDataPoints(ddsc_take_instance_mask_wl, invalid_readers) = {
CU_Theory((dds_entity_t rdr), ddsc_take_instance_mask_wl, invalid_readers, .init=take_instance_init, .fini=take_instance_fini)
{
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_take_instance_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -521,7 +517,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance, non_readers, .init=take_insta
{
dds_return_t ret;
ret = dds_take_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -533,7 +529,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance_wl, non_readers, .init=take_in
{
dds_return_t ret;
ret = dds_take_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -546,7 +542,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance_mask, non_readers, .init=take_
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret;
ret = dds_take_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -559,7 +555,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance_mask_wl, non_readers, .init=ta
uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret;
ret = dds_take_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -583,7 +579,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance, already_deleted, .init=take_i
ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_take_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -597,7 +593,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance_wl, already_deleted, .init=tak
ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_take_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -612,7 +608,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance_mask, already_deleted, .init=t
ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_take_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -627,7 +623,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance_mask_wl, already_deleted, .ini
ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_take_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/

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

@ -108,7 +108,7 @@ CU_Test(ddsc_topic_create, invalid_qos, .init=ddsc_topic_init, .fini=ddsc_topic_
dds_qset_lifespan(qos, DDS_SECS(-1));
DDSRT_WARNING_MSVC_OFF(28020);
topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, "inconsistent", qos, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_INCONSISTENT_POLICY);
CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_INCONSISTENT_POLICY);
dds_delete_qos(qos);
}
/*************************************************************************************************/
@ -118,7 +118,7 @@ CU_Test(ddsc_topic_create, non_participants, .init=ddsc_topic_init, .fini=ddsc_t
{
dds_entity_t topic;
topic = dds_create_topic(g_topicRtmDataType, &RoundTripModule_DataType_desc, "non_participant", NULL, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -141,7 +141,7 @@ CU_Test(ddsc_topic_create, same_name, .init=ddsc_topic_init, .fini=ddsc_topic_fi
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);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -169,7 +169,7 @@ CU_Test(ddsc_topic_create, desc_null, .init=ddsc_topic_init, .fini=ddsc_topic_fi
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
topic = dds_create_topic (g_participant, NULL, "desc_null", NULL, NULL);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -183,7 +183,7 @@ CU_Theory((char *name), ddsc_topic_create, invalid_names, .init=ddsc_topic_init,
{
dds_entity_t topic;
topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, name, NULL, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -213,7 +213,7 @@ CU_Test(ddsc_topic_find, non_participants, .init=ddsc_topic_init, .fini=ddsc_top
{
dds_entity_t topic;
topic = dds_find_topic(g_topicRtmDataType, "non_participant");
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -224,7 +224,7 @@ CU_Test(ddsc_topic_find, null, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
topic = dds_find_topic(g_participant, NULL);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -233,7 +233,7 @@ 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");
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -243,7 +243,7 @@ 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);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -289,7 +289,7 @@ CU_Test(ddsc_topic_get_name, non_topic, .init=ddsc_topic_init, .fini=ddsc_topic_
char name[MAX_NAME_SIZE];
dds_return_t ret;
ret = dds_get_name(g_participant, name, MAX_NAME_SIZE);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -303,7 +303,7 @@ CU_Theory((char *name, size_t size), ddsc_topic_get_name, invalid_params, .init=
dds_return_t ret;
CU_ASSERT_FATAL((name != g_nameBuffer) || (size != MAX_NAME_SIZE));
ret = dds_get_name(g_topicRtmDataType, name, size);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -314,7 +314,7 @@ CU_Test(ddsc_topic_get_name, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fi
dds_return_t ret;
dds_delete(g_topicRtmDataType);
ret = dds_get_name(g_topicRtmDataType, name, MAX_NAME_SIZE);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -362,7 +362,7 @@ CU_Test(ddsc_topic_get_type_name, non_topic, .init=ddsc_topic_init, .fini=ddsc_t
char name[MAX_NAME_SIZE];
dds_return_t ret;
ret = dds_get_type_name(g_participant, name, MAX_NAME_SIZE);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -376,7 +376,7 @@ CU_Theory((char *name, size_t size), ddsc_topic_get_type_name, invalid_params, .
dds_return_t ret;
CU_ASSERT_FATAL((name != g_nameBuffer) || (size != MAX_NAME_SIZE));
ret = dds_get_type_name(g_topicRtmDataType, name, size);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -387,7 +387,7 @@ CU_Test(ddsc_topic_get_type_name, deleted, .init=ddsc_topic_init, .fini=ddsc_top
dds_return_t ret;
dds_delete(g_topicRtmDataType);
ret = dds_get_type_name(g_topicRtmDataType, name, MAX_NAME_SIZE);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -405,7 +405,7 @@ CU_Test(ddsc_topic_set_qos, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini)
/* 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);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_UNSUPPORTED);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_UNSUPPORTED);
}
/*************************************************************************************************/
@ -417,7 +417,7 @@ CU_Test(ddsc_topic_set_qos, inconsistent, .init=ddsc_topic_init, .fini=ddsc_topi
dds_qset_lifespan(g_qos, DDS_SECS(-1));
DDSRT_WARNING_MSVC_ON(28020);
ret = dds_set_qos(g_topicRtmDataType, g_qos);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_INCONSISTENT_POLICY);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_INCONSISTENT_POLICY);
}
/*************************************************************************************************/
@ -427,6 +427,6 @@ CU_Test(ddsc_topic_set_qos, immutable, .init=ddsc_topic_init, .fini=ddsc_topic_f
dds_return_t ret;
dds_qset_destination_order(g_qos, DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP); /* Immutable */
ret = dds_set_qos(g_topicRtmDataType, g_qos);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_IMMUTABLE_POLICY);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_IMMUTABLE_POLICY);
}
/*************************************************************************************************/

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

@ -30,7 +30,7 @@
CU_ASSERT_FATAL(wri > 0); \
\
status = dds_write(wri, &data); \
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK); \
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); \
\
dds_delete(wri); \
dds_delete(top); \
@ -114,7 +114,7 @@ CU_Test(ddsc_types, alltypeskey)
CU_ASSERT_FATAL(wri > 0);
status = dds_write(wri, &atk_data);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
dds_delete(wri);
dds_delete(top);

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

@ -152,7 +152,7 @@ CU_Test(ddsc_unregister_instance, deleted, .init=unregistering_init, .fini=unreg
dds_delete(g_writer);
ret = dds_unregister_instance(g_writer, g_data);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -161,7 +161,7 @@ CU_Test(ddsc_unregister_instance, null, .init=unregistering_init, .fini=unregist
{
dds_return_t ret;
ret = dds_unregister_instance(g_writer, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -171,11 +171,10 @@ CU_TheoryDataPoints(ddsc_unregister_instance, invalid_writers) = {
};
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);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -187,7 +186,7 @@ CU_Theory((dds_entity_t *writer), ddsc_unregister_instance, non_writers, .init=u
{
dds_return_t ret;
ret = dds_unregister_instance(*writer, g_data);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -246,7 +245,7 @@ CU_Test(ddsc_unregister_instance_ts, deleted, .init=unregistering_init, .fini=un
dds_return_t ret;
dds_delete(g_writer);
ret = dds_unregister_instance_ts(g_writer, g_data, g_present);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -255,7 +254,7 @@ CU_Test(ddsc_unregister_instance_ts, null, .init=unregistering_init, .fini=unreg
{
dds_return_t ret;
ret = dds_unregister_instance_ts(g_writer, NULL, g_present);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -265,11 +264,10 @@ CU_TheoryDataPoints(ddsc_unregister_instance_ts, invalid_writers) = {
};
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);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -281,7 +279,7 @@ CU_Theory((dds_entity_t *writer), ddsc_unregister_instance_ts, non_writers, .ini
{
dds_return_t ret;
ret = dds_unregister_instance_ts(*writer, g_data, g_present);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -383,7 +381,7 @@ CU_Test(ddsc_unregister_instance_ih, deleted, .init=unregistering_init, .fini=un
dds_return_t ret;
dds_delete(g_writer);
ret = dds_unregister_instance_ih(g_writer, DDS_HANDLE_NIL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -395,7 +393,7 @@ CU_Theory((dds_instance_handle_t handle), ddsc_unregister_instance_ih, invalid_h
{
dds_return_t ret;
ret = dds_unregister_instance_ih(g_writer, handle);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -405,11 +403,10 @@ CU_TheoryDataPoints(ddsc_unregister_instance_ih, invalid_writers) = {
};
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);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -421,7 +418,7 @@ CU_Theory((dds_entity_t *writer), ddsc_unregister_instance_ih, non_writers, .ini
{
dds_return_t ret;
ret = dds_unregister_instance_ih(*writer, DDS_HANDLE_NIL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -481,7 +478,7 @@ CU_Test(ddsc_unregister_instance_ih_ts, deleted, .init=unregistering_init, .fini
dds_return_t ret;
dds_delete(g_writer);
ret = dds_unregister_instance_ih_ts(g_writer, DDS_HANDLE_NIL, g_present);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -493,7 +490,7 @@ CU_Theory((dds_instance_handle_t handle), ddsc_unregister_instance_ih_ts, invali
{
dds_return_t ret;
ret = dds_unregister_instance_ih_ts(g_writer, handle, g_present);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -503,11 +500,10 @@ CU_TheoryDataPoints(ddsc_unregister_instance_ih_ts, invalid_writers) = {
};
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);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -519,7 +515,7 @@ CU_Theory((dds_entity_t *writer), ddsc_unregister_instance_ih_ts, non_writers, .
{
dds_return_t ret;
ret = dds_unregister_instance_ih_ts(*writer, DDS_HANDLE_NIL, g_present);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/

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

@ -78,9 +78,9 @@ CU_Test(ddsc_unsupported, dds_begin_end_coherent, .init = setup, .fini = teardow
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);
CU_ASSERT_EQUAL(result, pars[i].exp_res);
result = dds_end_coherent(e[pars[i].index]);
CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res);
CU_ASSERT_EQUAL(result, pars[i].exp_res);
}
}
@ -95,7 +95,7 @@ CU_Test(ddsc_unsupported, dds_wait_for_acks, .init = setup, .fini = teardown)
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);
CU_ASSERT_EQUAL(result, pars[i].exp_res);
}
}
@ -110,9 +110,9 @@ CU_Test(ddsc_unsupported, dds_suspend_resume, .init = setup, .fini = teardown)
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);
CU_ASSERT_EQUAL(result, pars[i].exp_res);
result = dds_resume(e[pars[i].index]);
CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res);
CU_ASSERT_EQUAL(result, pars[i].exp_res);
}
}
@ -130,7 +130,7 @@ CU_Test(ddsc_unsupported, dds_get_instance_handle, .init = setup, .fini = teardo
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);
CU_ASSERT_EQUAL(result, pars[i].exp_res);
}
}
@ -152,7 +152,7 @@ CU_Test(ddsc_unsupported, dds_set_qos, .init = setup, .fini = teardown)
qos = dds_create_qos();
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);
CU_ASSERT_EQUAL(result, pars[i].exp_res);
}
dds_delete_qos(qos);
}

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

@ -226,7 +226,7 @@ CU_Test(ddsc_waitset_create, deleted_participant, .init=ddsc_waitset_basic_init,
deleted = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
dds_delete(deleted);
ws = dds_create_waitset(deleted);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ws), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ws, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -236,11 +236,10 @@ CU_TheoryDataPoints(ddsc_waitset_create, invalid_params) = {
};
CU_Theory((dds_entity_t par), ddsc_waitset_create, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini)
{
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_entity_t ws;
ws = dds_create_waitset(par);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ws), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ws, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -252,7 +251,7 @@ CU_Theory((dds_entity_t *par), ddsc_waitset_create, non_participants, .init=ddsc
{
dds_entity_t ws;
ws = dds_create_waitset(*par);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ws), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ws, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -276,7 +275,7 @@ CU_Theory((dds_entity_t e, dds_attach_t a), ddsc_waitset_attach, invalid_params,
{
dds_return_t ret;
ret = dds_waitset_attach(waitset, e, a);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -287,11 +286,10 @@ CU_TheoryDataPoints(ddsc_waitset_attach, invalid_waitsets) = {
};
CU_Theory((dds_entity_t ws, dds_attach_t a), ddsc_waitset_attach, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini)
{
dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_waitset_attach(ws, participant, a);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -305,7 +303,7 @@ CU_Theory((dds_entity_t *ws, dds_entity_t *e, dds_attach_t a), ddsc_waitset_atta
{
dds_return_t ret;
ret = dds_waitset_attach(*ws, *e, a);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -315,7 +313,7 @@ CU_Test(ddsc_waitset_attach, deleted_waitset, .init=ddsc_waitset_basic_init, .fi
dds_return_t ret;
dds_delete(waitset);
ret = dds_waitset_attach(waitset, participant, 0);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -347,7 +345,7 @@ CU_Theory((dds_entity_t *ws, dds_entity_t *e, dds_attach_t a), ddsc_waitset_atta
/* Try to attach. */
ret = dds_waitset_attach(*ws, *e, a);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), exp);
CU_ASSERT_EQUAL_FATAL(ret, exp);
/* Detach when needed. */
if (ret == DDS_RETCODE_OK) {
@ -366,13 +364,13 @@ CU_Test(ddsc_waitset_attach_detach, second, .init=ddsc_waitset_basic_init, .fini
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_attach(waitset, waitset, 0);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET);
ret = dds_waitset_detach(waitset, waitset);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_detach(waitset, waitset);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET);
}
/*************************************************************************************************/
@ -399,7 +397,7 @@ CU_Theory((dds_entity_t e), ddsc_waitset_detach, invalid_params, .init=ddsc_wait
{
dds_return_t ret;
ret = dds_waitset_detach(waitset, e);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -409,11 +407,10 @@ CU_TheoryDataPoints(ddsc_waitset_detach, invalid_waitsets) = {
};
CU_Theory((dds_entity_t ws), ddsc_waitset_detach, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini)
{
dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_waitset_detach(ws, participant);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -436,7 +433,7 @@ CU_Theory((dds_entity_t *ws, dds_entity_t *e), ddsc_waitset_detach, valid_entiti
}
ret = dds_waitset_detach(*ws, *e);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), exp);
CU_ASSERT_EQUAL_FATAL(ret, exp);
}
/*************************************************************************************************/
@ -580,7 +577,7 @@ CU_Test(ddsc_waitset_set_trigger, deleted_waitset, .init=ddsc_waitset_basic_init
dds_return_t ret;
dds_delete(waitset);
ret = dds_waitset_set_trigger(waitset, true);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -590,11 +587,10 @@ CU_TheoryDataPoints(ddsc_waitset_set_trigger, invalid_params) = {
};
CU_Theory((dds_entity_t ws), ddsc_waitset_set_trigger, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini)
{
dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_waitset_set_trigger(ws, true);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -606,7 +602,7 @@ CU_Theory((dds_entity_t *ws), ddsc_waitset_set_trigger, non_waitsets, .init=ddsc
{
dds_return_t ret;
ret = dds_waitset_set_trigger(*ws, true);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -625,7 +621,7 @@ CU_Test(ddsc_waitset_wait, deleted_waitset, .init=ddsc_waitset_attached_init, .f
dds_return_t ret;
dds_delete(waitset);
ret = dds_waitset_wait(waitset, &triggered, 1, DDS_SECS(1));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -636,11 +632,10 @@ CU_TheoryDataPoints(ddsc_waitset_wait, invalid_waitsets) = {
CU_Theory((dds_entity_t ws), ddsc_waitset_wait, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini)
{
dds_attach_t triggered;
dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_waitset_wait(ws, &triggered, 1, DDS_SECS(1));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -653,7 +648,7 @@ CU_Theory((dds_entity_t *ws), ddsc_waitset_wait, non_waitsets, .init=ddsc_waitse
dds_attach_t triggered;
dds_return_t ret;
ret = dds_waitset_wait(*ws, &triggered, 1, DDS_SECS(1));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -672,7 +667,7 @@ CU_Theory((dds_attach_t *a, size_t size, int msec), ddsc_waitset_wait, invalid_p
CU_ASSERT_FATAL(((a == NULL) && (size != 0)) || ((a != NULL) && (size == 0)) || (msec < 0));
ret = dds_waitset_wait(waitset, a, size, DDS_MSECS(msec));
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -683,7 +678,7 @@ CU_Test(ddsc_waitset_wait_until, deleted_waitset, .init=ddsc_waitset_attached_in
dds_return_t ret;
dds_delete(waitset);
ret = dds_waitset_wait_until(waitset, &triggered, 1, dds_time());
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -694,11 +689,10 @@ CU_TheoryDataPoints(ddsc_waitset_wait_until, invalid_waitsets) = {
CU_Theory((dds_entity_t ws), ddsc_waitset_wait_until, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini)
{
dds_attach_t triggered;
dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret;
ret = dds_waitset_wait_until(ws, &triggered, 1, dds_time());
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -711,7 +705,7 @@ CU_Theory((dds_entity_t *ws), ddsc_waitset_wait_until, non_waitsets, .init=ddsc_
dds_attach_t triggered;
dds_return_t ret;
ret = dds_waitset_wait_until(*ws, &triggered, 1, dds_time());
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -729,7 +723,7 @@ CU_Theory((dds_attach_t *a, size_t size), ddsc_waitset_wait_until, invalid_param
CU_ASSERT_FATAL(((a == NULL) && (size != 0)) || ((a != NULL) && (size == 0)));
ret = dds_waitset_wait_until(waitset, a, size, dds_time());
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -843,7 +837,7 @@ CU_Test(ddsc_waitset_get_entities, deleted_waitset, .init=ddsc_waitset_attached_
dds_entity_t entities[MAX_ENTITIES_CNT];
dds_delete(waitset);
ret = dds_waitset_get_entities(waitset, entities, MAX_ENTITIES_CNT);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -853,12 +847,11 @@ CU_TheoryDataPoints(ddsc_waitset_get_entities, invalid_params) = {
};
CU_Theory((dds_entity_t ws), ddsc_waitset_get_entities, invalid_params, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini)
{
dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_entity_t entities[MAX_ENTITIES_CNT];
dds_return_t ret;
ret = dds_waitset_get_entities(ws, entities, MAX_ENTITIES_CNT);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER);
}
/*************************************************************************************************/
@ -871,7 +864,7 @@ CU_Theory((dds_entity_t *ws), ddsc_waitset_get_entities, non_waitsets, .init=dds
dds_entity_t entities[MAX_ENTITIES_CNT];
dds_return_t ret;
ret = dds_waitset_get_entities(*ws, entities, MAX_ENTITIES_CNT);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION);
}
/*************************************************************************************************/
@ -1073,7 +1066,7 @@ waiting_thread(void *a)
return 0;
}
static dds_retcode_t
static dds_return_t
thread_reached_state(thread_state_t *actual, thread_state_t expected, int32_t msec)
{
/* Convenience function. */
@ -1090,7 +1083,7 @@ waiting_thread_start(struct thread_arg_t *arg, dds_entity_t expected)
{
ddsrt_thread_t thread_id;
ddsrt_threadattr_t thread_attr;
dds_retcode_t rc;
dds_return_t rc;
assert(arg);
@ -1115,7 +1108,7 @@ waiting_thread_start(struct thread_arg_t *arg, dds_entity_t expected)
static dds_return_t
waiting_thread_expect_exit(struct thread_arg_t *arg)
{
dds_retcode_t rc;
dds_return_t rc;
assert(arg);
rc = thread_reached_state(&(arg->state), STOPPED, 5000);
if (rc == DDS_RETCODE_OK) {

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

@ -65,7 +65,7 @@ CU_Test(ddsc_write, basic, .init = setup, .fini = teardown)
dds_return_t status;
status = dds_write(writer, &data);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
}
CU_Test(ddsc_write, null_writer, .init = setup, .fini = teardown)
@ -76,7 +76,7 @@ CU_Test(ddsc_write, null_writer, .init = setup, .fini = teardown)
DDSRT_WARNING_MSVC_OFF(28020);
status = dds_write(0, &data);
DDSRT_WARNING_MSVC_ON(28020);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_write, bad_writer, .init = setup, .fini = teardown)
@ -84,7 +84,7 @@ CU_Test(ddsc_write, bad_writer, .init = setup, .fini = teardown)
dds_return_t status;
status = dds_write(publisher, &data);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_ILLEGAL_OPERATION);
}
CU_Test(ddsc_write, closed_writer, .init = setup, .fini = teardown)
@ -92,10 +92,10 @@ CU_Test(ddsc_write, closed_writer, .init = setup, .fini = teardown)
dds_return_t status;
status = dds_delete(writer);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
status = dds_write(writer, &data);
writer = 0;
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_write, null_sample, .init = setup, .fini = teardown)
@ -107,7 +107,7 @@ CU_Test(ddsc_write, null_sample, .init = setup, .fini = teardown)
status = dds_write(writer, NULL);
DDSRT_WARNING_MSVC_ON(6387);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_write_ts, basic, .init = setup, .fini = teardown)
@ -115,7 +115,7 @@ CU_Test(ddsc_write_ts, basic, .init = setup, .fini = teardown)
dds_return_t status;
status = dds_write_ts(writer, &data, dds_time());
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
}
CU_Test(ddsc_write_ts, bad_timestamp, .init = setup, .fini = teardown)
@ -123,7 +123,7 @@ CU_Test(ddsc_write_ts, bad_timestamp, .init = setup, .fini = teardown)
dds_return_t status;
status = dds_write_ts(writer, &data, -1);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_write, simpletypes)
@ -152,7 +152,7 @@ CU_Test(ddsc_write, simpletypes)
CU_ASSERT_FATAL(wri > 0);
status = dds_write(wri, &st_data);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK);
CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
dds_delete(wri);
dds_delete(top);

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

@ -57,13 +57,13 @@ CU_Test(ddsc_create_writer, null_parent, .init = setup, .fini = teardown)
DDSRT_WARNING_MSVC_OFF(28020); /* Disable SAL warning on intentional misuse of the API */
writer = dds_create_writer(0, topic, NULL, NULL);
DDSRT_WARNING_MSVC_ON(28020);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(writer, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_create_writer, bad_parent, .init = setup, .fini = teardown)
{
writer = dds_create_writer(topic, topic, NULL, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(writer, DDS_RETCODE_ILLEGAL_OPERATION);
}
CU_Test(ddsc_create_writer, participant, .init = setup, .fini = teardown)
@ -83,7 +83,7 @@ CU_Test(ddsc_create_writer, deleted_publisher, .init = setup, .fini = teardown)
dds_delete(publisher);
writer = dds_create_writer(publisher, topic, NULL, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(writer, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_create_writer, null_topic, .init = setup, .fini = teardown)
@ -91,13 +91,13 @@ CU_Test(ddsc_create_writer, null_topic, .init = setup, .fini = teardown)
DDSRT_WARNING_MSVC_OFF(28020); /* Disable SAL warning on intentional misuse of the API */
writer = dds_create_writer(publisher, 0, NULL, NULL);
DDSRT_WARNING_MSVC_ON(28020);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(writer, DDS_RETCODE_BAD_PARAMETER);
}
CU_Test(ddsc_create_writer, bad_topic, .init = setup, .fini = teardown)
{
writer = dds_create_writer(publisher, publisher, NULL, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_ILLEGAL_OPERATION);
CU_ASSERT_EQUAL_FATAL(writer, DDS_RETCODE_ILLEGAL_OPERATION);
}
CU_Test(ddsc_create_writer, deleted_topic, .init = setup, .fini = teardown)
@ -105,5 +105,5 @@ CU_Test(ddsc_create_writer, deleted_topic, .init = setup, .fini = teardown)
dds_delete(topic);
writer = dds_create_writer(publisher, topic, NULL, NULL);
CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER);
CU_ASSERT_EQUAL_FATAL(writer, DDS_RETCODE_BAD_PARAMETER);
}