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

13
src/core/ddsc/include/dds/dds.h
View file

@ -26,17 +26,10 @@
#include "dds/export.h" #include "dds/export.h"
/* TODO: Move to appropriate location */
/**
* Return code indicating success (DDS_RETCODE_OK) or failure. If a given
* operation failed the value will be a unique error code and dds_err_nr() must
* be used to extract the DDS_RETCODE_* value.
*/
typedef int32_t dds_return_t;
/** /**
* Handle to an entity. A valid entity handle will always have a positive * Handle to an entity. A valid entity handle will always have a positive
* integer value. Should the value be negative, the value represents a unique * integer value. Should the value be negative, it is one of the DDS_RETCODE_*
* error code. dds_err_nr() can be used to extract the DDS_RETCODE_* value. * error codes.
*/ */
typedef int32_t dds_entity_t; typedef int32_t dds_entity_t;
@ -1223,7 +1216,7 @@ dds_create_reader(
* @returns a status, 0 on success, TIMEOUT on timeout or a negative value to indicate error. * @returns a status, 0 on success, TIMEOUT on timeout or a negative value to indicate error.
*/ */
/* TODO: Complete list of error codes */ /* TODO: Complete list of error codes */
DDS_EXPORT int DDS_EXPORT dds_return_t
dds_reader_wait_for_historical_data( dds_reader_wait_for_historical_data(
dds_entity_t reader, dds_entity_t reader,
dds_duration_t max_wait); dds_duration_t max_wait);

8
src/core/ddsc/include/dds/ddsc/dds_public_error.h
View file

@ -28,6 +28,8 @@
extern "C" { extern "C" {
#endif #endif
/* ** DEPRECATED ** */
/* Error masks for returned status values */ /* Error masks for returned status values */
#define DDS_ERR_NR_MASK 0x000000ff #define DDS_ERR_NR_MASK 0x000000ff
@ -37,13 +39,13 @@ extern "C" {
/* Error code handling functions */ /* Error code handling functions */
/** Macro to extract error number */ /** Macro to extract error number */
#define dds_err_nr(e) ((-(e)) & DDS_ERR_NR_MASK) #define dds_err_nr(e) (e))
/** Macro to extract line number */ /** Macro to extract line number */
#define dds_err_line(e) (((-(e)) & DDS_ERR_LINE_MASK) >> 8) #define dds_err_line(e) (0)
/** Macro to extract file identifier */ /** Macro to extract file identifier */
#define dds_err_file_id(e) (((-(e)) & DDS_ERR_FILE_ID_MASK) >> 22) #define dds_err_file_id(e) (0)
#if defined (__cplusplus) #if defined (__cplusplus)
} }

16
src/core/ddsc/include/dds/ddsc/dds_public_status.h
View file

@ -185,7 +185,7 @@ dds_inconsistent_topic_status_t;
* @param[out] status The pointer to \ref DCPS_Status_InconsistentTopic to get the status * @param[out] status The pointer to \ref DCPS_Status_InconsistentTopic to get the status
* *
* @returns 0 - Success * @returns 0 - Success
* @returns <0 - Failure (use dds_err_nr() to get error value). * @returns <0 - Failure
* *
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* An internal error has occurred. * An internal error has occurred.
@ -212,7 +212,7 @@ dds_get_inconsistent_topic_status (
* @param[out] status The pointer to \ref DCPS_Status_PublicationMatched to get the status * @param[out] status The pointer to \ref DCPS_Status_PublicationMatched to get the status
* *
* @returns 0 - Success * @returns 0 - Success
* @returns <0 - Failure (use dds_err_nr() to get error value). * @returns <0 - Failure
* *
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* An internal error has occurred. * An internal error has occurred.
@ -239,7 +239,7 @@ dds_get_publication_matched_status (
* @param[out] status The pointer to \ref DCPS_Status_LivelinessLost to get the status * @param[out] status The pointer to \ref DCPS_Status_LivelinessLost to get the status
* *
* @returns 0 - Success * @returns 0 - Success
* @returns <0 - Failure (use dds_err_nr() to get error value). * @returns <0 - Failure
* *
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* An internal error has occurred. * An internal error has occurred.
@ -266,7 +266,7 @@ dds_get_liveliness_lost_status (
* @param[out] status The pointer to \ref DCPS_Status_OfferedDeadlineMissed to get the status * @param[out] status The pointer to \ref DCPS_Status_OfferedDeadlineMissed to get the status
* *
* @returns 0 - Success * @returns 0 - Success
* @returns <0 - Failure (use dds_err_nr() to get error value). * @returns <0 - Failure
* *
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* An internal error has occurred. * An internal error has occurred.
@ -293,7 +293,7 @@ dds_get_offered_deadline_missed_status(
* @param[out] status The pointer to \ref DCPS_Status_OfferedIncompatibleQoS to get the status * @param[out] status The pointer to \ref DCPS_Status_OfferedIncompatibleQoS to get the status
* *
* @returns 0 - Success * @returns 0 - Success
* @returns <0 - Failure (use dds_err_nr() to get error value). * @returns <0 - Failure
* *
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* An internal error has occurred. * An internal error has occurred.
@ -320,7 +320,7 @@ dds_get_offered_incompatible_qos_status (
* @param[out] status The pointer to \ref DCPS_Status_SubscriptionMatched to get the status * @param[out] status The pointer to \ref DCPS_Status_SubscriptionMatched to get the status
* *
* @returns 0 - Success * @returns 0 - Success
* @returns <0 - Failure (use dds_err_nr() to get error value). * @returns <0 - Failure
* *
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* An internal error has occurred. * An internal error has occurred.
@ -347,7 +347,7 @@ dds_get_subscription_matched_status (
* @param[out] status The pointer to \ref DCPS_Status_LivelinessChanged to get the status * @param[out] status The pointer to \ref DCPS_Status_LivelinessChanged to get the status
* *
* @returns 0 - Success * @returns 0 - Success
* @returns <0 - Failure (use dds_err_nr() to get error value). * @returns <0 - Failure
* *
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* An internal error has occurred. * An internal error has occurred.
@ -374,7 +374,7 @@ dds_get_liveliness_changed_status (
* @param[out] status The pointer to \ref DCPS_Status_SampleRejected to get the status * @param[out] status The pointer to \ref DCPS_Status_SampleRejected to get the status
* *
* @returns 0 - Success * @returns 0 - Success
* @returns <0 - Failure (use dds_err_nr() to get error value). * @returns <0 - Failure
* *
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* An internal error has occurred. * An internal error has occurred.

18
src/core/ddsc/src/dds__entity.h
View file

@ -35,9 +35,9 @@ DDS_EXPORT void
dds_entity_add_ref_nolock(dds_entity *e); dds_entity_add_ref_nolock(dds_entity *e);
#define DEFINE_ENTITY_LOCK_UNLOCK(qualifier_, type_, kind_) \ #define DEFINE_ENTITY_LOCK_UNLOCK(qualifier_, type_, kind_) \
qualifier_ dds_retcode_t type_##_lock (dds_entity_t hdl, type_ **x) \ qualifier_ dds_return_t type_##_lock (dds_entity_t hdl, type_ **x) \
{ \ { \
dds_retcode_t rc; \ dds_return_t rc; \
dds_entity *e; \ dds_entity *e; \
if ((rc = dds_entity_lock (hdl, kind_, &e)) != DDS_RETCODE_OK) \ if ((rc = dds_entity_lock (hdl, kind_, &e)) != DDS_RETCODE_OK) \
return rc; \ return rc; \
@ -50,7 +50,7 @@ dds_entity_add_ref_nolock(dds_entity *e);
dds_entity_unlock (&x->m_entity); \ dds_entity_unlock (&x->m_entity); \
} }
#define DECL_ENTITY_LOCK_UNLOCK(qualifier_, type_) \ #define DECL_ENTITY_LOCK_UNLOCK(qualifier_, type_) \
qualifier_ dds_retcode_t type_##_lock (dds_entity_t hdl, type_ **x); \ qualifier_ dds_return_t type_##_lock (dds_entity_t hdl, type_ **x); \
qualifier_ void type_##_unlock (type_ *x); qualifier_ void type_##_unlock (type_ *x);
DDS_EXPORT inline dds_entity *dds_entity_from_handle_link (struct dds_handle_link *hdllink) { DDS_EXPORT inline dds_entity *dds_entity_from_handle_link (struct dds_handle_link *hdllink) {
@ -79,7 +79,7 @@ DDS_EXPORT void dds_entity_status_signal (dds_entity *e);
DDS_EXPORT void dds_entity_invoke_listener (const dds_entity *entity, enum dds_status_id which, const void *vst); DDS_EXPORT void dds_entity_invoke_listener (const dds_entity *entity, enum dds_status_id which, const void *vst);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
dds_entity_claim ( dds_entity_claim (
dds_entity_t hdl, dds_entity_t hdl,
dds_entity **eptr); dds_entity **eptr);
@ -87,7 +87,7 @@ dds_entity_claim (
DDS_EXPORT void dds_entity_release ( DDS_EXPORT void dds_entity_release (
dds_entity *e); dds_entity *e);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
dds_entity_lock( dds_entity_lock(
dds_entity_t hdl, dds_entity_t hdl,
dds_entity_kind_t kind, dds_entity_kind_t kind,
@ -96,24 +96,24 @@ dds_entity_lock(
DDS_EXPORT void DDS_EXPORT void
dds_entity_unlock(dds_entity *e); dds_entity_unlock(dds_entity *e);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
dds_entity_observer_register_nl( dds_entity_observer_register_nl(
dds_entity *observed, dds_entity *observed,
dds_entity_t observer, dds_entity_t observer,
dds_entity_callback cb); dds_entity_callback cb);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
dds_entity_observer_register( dds_entity_observer_register(
dds_entity_t observed, dds_entity_t observed,
dds_entity_t observer, dds_entity_t observer,
dds_entity_callback cb); dds_entity_callback cb);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
dds_entity_observer_unregister_nl( dds_entity_observer_unregister_nl(
dds_entity *observed, dds_entity *observed,
dds_entity_t observer); dds_entity_t observer);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
dds_entity_observer_unregister( dds_entity_observer_unregister(
dds_entity_t observed, dds_entity_t observed,
dds_entity_t observer); dds_entity_t observer);

28
src/core/ddsc/src/dds__err.h
View file

@ -1,28 +0,0 @@
/*
* Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
* v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#ifndef _DDS_ERR_H_
#define _DDS_ERR_H_
#include <assert.h>
#include "dds/ddsrt/retcode.h"
#if defined (__cplusplus)
extern "C" {
#endif
#define DDS_ERRNO(err) (assert(err > DDS_RETCODE_OK), -(err))
#if defined (__cplusplus)
}
#endif
#endif

3
src/core/ddsc/src/dds_builtin.c
View file

@ -18,7 +18,6 @@
#include "dds__qos.h" #include "dds__qos.h"
#include "dds__domain.h" #include "dds__domain.h"
#include "dds__participant.h" #include "dds__participant.h"
#include "dds__err.h"
#include "dds__types.h" #include "dds__types.h"
#include "dds__builtin.h" #include "dds__builtin.h"
#include "dds__subscriber.h" #include "dds__subscriber.h"
@ -93,7 +92,7 @@ dds_entity_t dds__get_builtin_topic (dds_entity_t e, dds_entity_t topic)
sertopic = builtin_reader_topic; sertopic = builtin_reader_topic;
} else { } else {
assert (0); assert (0);
return DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
} }
dds_qos_t *qos = dds__create_builtin_qos (); dds_qos_t *qos = dds__create_builtin_qos ();

1
src/core/ddsc/src/dds_coherent.c
View file

@ -15,7 +15,6 @@
#include "dds__entity.h" #include "dds__entity.h"
#include "dds__subscriber.h" #include "dds__subscriber.h"
#include "dds__publisher.h" #include "dds__publisher.h"
#include "dds__err.h"
dds_return_t dds_return_t
dds_begin_coherent( dds_begin_coherent(

163
src/core/ddsc/src/dds_entity.c
View file

@ -19,7 +19,6 @@
#include "dds__writer.h" #include "dds__writer.h"
#include "dds__reader.h" #include "dds__reader.h"
#include "dds__listener.h" #include "dds__listener.h"
#include "dds__err.h"
#include "dds/version.h" #include "dds/version.h"
extern inline dds_entity *dds_entity_from_handle_link (struct dds_handle_link *hdllink); extern inline dds_entity *dds_entity_from_handle_link (struct dds_handle_link *hdllink);
@ -51,7 +50,7 @@ dds_domain *dds__entity_domain (dds_entity *e)
static void dds_set_explicit (dds_entity_t entity) static void dds_set_explicit (dds_entity_t entity)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t rc; dds_return_t rc;
if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) == DDS_RETCODE_OK) if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) == DDS_RETCODE_OK)
{ {
e->m_flags &= ~DDS_ENTITY_IMPLICIT; e->m_flags &= ~DDS_ENTITY_IMPLICIT;
@ -142,13 +141,13 @@ dds_return_t dds_delete_impl (dds_entity_t entity, bool keep_if_explicit)
dds_entity *prev = NULL; dds_entity *prev = NULL;
dds_entity *next = NULL; dds_entity *next = NULL;
dds_return_t ret; dds_return_t ret;
dds_retcode_t rc; dds_return_t rc;
rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e); rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e);
if (rc != DDS_RETCODE_OK) if (rc != DDS_RETCODE_OK)
{ {
DDS_TRACE ("dds_delete_impl: error on locking entity %"PRIu32" keep_if_explicit %d\n", entity, (int) keep_if_explicit); DDS_TRACE ("dds_delete_impl: error on locking entity %"PRIu32" keep_if_explicit %d\n", entity, (int) keep_if_explicit);
return DDS_ERRNO (rc); return rc;
} }
if (keep_if_explicit == true && (e->m_flags & DDS_ENTITY_IMPLICIT) == 0) if (keep_if_explicit == true && (e->m_flags & DDS_ENTITY_IMPLICIT) == 0)
@ -275,9 +274,9 @@ dds_return_t dds_delete_impl (dds_entity_t entity, bool keep_if_explicit)
dds_entity_t dds_get_parent (dds_entity_t entity) dds_entity_t dds_get_parent (dds_entity_t entity)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t rc; dds_return_t rc;
if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return rc;
else else
{ {
dds_entity *parent; dds_entity *parent;
@ -297,9 +296,9 @@ dds_entity_t dds_get_parent (dds_entity_t entity)
dds_entity_t dds_get_participant (dds_entity_t entity) dds_entity_t dds_get_participant (dds_entity_t entity)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t rc; dds_return_t rc;
if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return rc;
else else
{ {
dds_entity_t hdl = e->m_participant->m_hdllink.hdl; dds_entity_t hdl = e->m_participant->m_hdllink.hdl;
@ -311,15 +310,15 @@ dds_entity_t dds_get_participant (dds_entity_t entity)
dds_return_t dds_get_children (dds_entity_t entity, dds_entity_t *children, size_t size) dds_return_t dds_get_children (dds_entity_t entity, dds_entity_t *children, size_t size)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t rc; dds_return_t rc;
if (children != NULL && (size <= 0 || size >= INT32_MAX)) if (children != NULL && (size <= 0 || size >= INT32_MAX))
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
if (children == NULL && size != 0) if (children == NULL && size != 0)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return rc;
else else
{ {
dds_return_t n = 0; dds_return_t n = 0;
@ -342,17 +341,16 @@ dds_return_t dds_get_children (dds_entity_t entity, dds_entity_t *children, size
dds_return_t dds_get_qos (dds_entity_t entity, dds_qos_t *qos) dds_return_t dds_get_qos (dds_entity_t entity, dds_qos_t *qos)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t rc;
dds_return_t ret; dds_return_t ret;
if (qos == NULL) if (qos == NULL)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) if ((ret = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return ret;
if (e->m_deriver.set_qos == 0) if (e->m_deriver.set_qos == 0)
ret = DDS_ERRNO(DDS_RETCODE_ILLEGAL_OPERATION); ret = DDS_RETCODE_ILLEGAL_OPERATION;
else else
{ {
dds_reset_qos (qos); dds_reset_qos (qos);
@ -365,25 +363,23 @@ dds_return_t dds_get_qos (dds_entity_t entity, dds_qos_t *qos)
dds_return_t dds_set_qos (dds_entity_t entity, const dds_qos_t *qos) dds_return_t dds_set_qos (dds_entity_t entity, const dds_qos_t *qos)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t rc;
dds_return_t ret; dds_return_t ret;
if (qos == NULL) if (qos == NULL)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) if ((ret = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return ret;
if (e->m_deriver.set_qos == 0) if (e->m_deriver.set_qos == 0)
ret = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); ret = DDS_RETCODE_ILLEGAL_OPERATION;
else else
{ {
if ((ret = e->m_deriver.set_qos (e, qos, e->m_flags & DDS_ENTITY_ENABLED)) == DDS_RETCODE_OK) if ((ret = e->m_deriver.set_qos (e, qos, e->m_flags & DDS_ENTITY_ENABLED)) == DDS_RETCODE_OK)
{ {
if (e->m_qos == NULL) if (e->m_qos == NULL)
e->m_qos = dds_create_qos (); e->m_qos = dds_create_qos ();
rc = dds_copy_qos (e->m_qos, qos); ret = dds_copy_qos (e->m_qos, qos);
ret = DDS_ERRNO (rc);
} }
} }
dds_entity_unlock (e); dds_entity_unlock (e);
@ -393,24 +389,19 @@ dds_return_t dds_set_qos (dds_entity_t entity, const dds_qos_t *qos)
dds_return_t dds_get_listener (dds_entity_t entity, dds_listener_t *listener) dds_return_t dds_get_listener (dds_entity_t entity, dds_listener_t *listener)
{ {
dds_entity *e; dds_entity *e;
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret;
dds_retcode_t rc; if (listener == NULL)
return DDS_RETCODE_BAD_PARAMETER;
if (listener != NULL) { else if ((ret = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
rc = dds_entity_lock(entity, DDS_KIND_DONTCARE, &e); return ret;
if (rc == DDS_RETCODE_OK) { else
{
ddsrt_mutex_lock (&e->m_observers_lock); ddsrt_mutex_lock (&e->m_observers_lock);
dds_copy_listener (listener, &e->m_listener); dds_copy_listener (listener, &e->m_listener);
ddsrt_mutex_unlock (&e->m_observers_lock); ddsrt_mutex_unlock (&e->m_observers_lock);
dds_entity_unlock(e); dds_entity_unlock(e);
} else { return DDS_RETCODE_OK;
ret = DDS_ERRNO(rc);
} }
} else {
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER);
}
return ret;
} }
void dds_entity_invoke_listener (const dds_entity *entity, enum dds_status_id which, const void *vst) void dds_entity_invoke_listener (const dds_entity *entity, enum dds_status_id which, const void *vst)
@ -548,10 +539,10 @@ static void pushdown_listener (dds_entity_t entity)
dds_return_t dds_set_listener (dds_entity_t entity, const dds_listener_t *listener) dds_return_t dds_set_listener (dds_entity_t entity, const dds_listener_t *listener)
{ {
dds_entity *e, *x; dds_entity *e, *x;
dds_retcode_t rc; dds_return_t rc;
if ((rc = dds_entity_claim (entity, &e)) != DDS_RETCODE_OK) if ((rc = dds_entity_claim (entity, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return rc;
ddsrt_mutex_lock (&e->m_observers_lock); ddsrt_mutex_lock (&e->m_observers_lock);
while (e->m_cb_count > 0) while (e->m_cb_count > 0)
@ -579,10 +570,10 @@ dds_return_t dds_set_listener (dds_entity_t entity, const dds_listener_t *listen
dds_return_t dds_enable (dds_entity_t entity) dds_return_t dds_enable (dds_entity_t entity)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t rc; dds_return_t rc;
if ((rc = dds_entity_lock(entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) if ((rc = dds_entity_lock(entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return rc;
if ((e->m_flags & DDS_ENTITY_ENABLED) == 0) if ((e->m_flags & DDS_ENTITY_ENABLED) == 0)
{ {
@ -597,17 +588,16 @@ dds_return_t dds_enable (dds_entity_t entity)
dds_return_t dds_get_status_changes (dds_entity_t entity, uint32_t *status) dds_return_t dds_get_status_changes (dds_entity_t entity, uint32_t *status)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t rc;
dds_return_t ret; dds_return_t ret;
if (status == NULL) if (status == NULL)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) if ((ret = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return ret;
if (e->m_deriver.validate_status == 0) if (e->m_deriver.validate_status == 0)
ret = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); ret = DDS_RETCODE_ILLEGAL_OPERATION;
else else
{ {
ddsrt_mutex_lock (&e->m_observers_lock); ddsrt_mutex_lock (&e->m_observers_lock);
@ -622,17 +612,16 @@ dds_return_t dds_get_status_changes (dds_entity_t entity, uint32_t *status)
dds_return_t dds_get_status_mask (dds_entity_t entity, uint32_t *mask) dds_return_t dds_get_status_mask (dds_entity_t entity, uint32_t *mask)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t rc;
dds_return_t ret; dds_return_t ret;
if (mask == NULL) if (mask == NULL)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
if ((rc = dds_entity_claim (entity, &e)) != DDS_RETCODE_OK) if ((ret = dds_entity_claim (entity, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return ret;
if (e->m_deriver.validate_status == 0) if (e->m_deriver.validate_status == 0)
ret = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); ret = DDS_RETCODE_ILLEGAL_OPERATION;
else else
{ {
ddsrt_mutex_lock (&e->m_observers_lock); ddsrt_mutex_lock (&e->m_observers_lock);
@ -652,14 +641,13 @@ dds_return_t dds_get_enabled_status (dds_entity_t entity, uint32_t *status)
dds_return_t dds_set_status_mask (dds_entity_t entity, uint32_t mask) dds_return_t dds_set_status_mask (dds_entity_t entity, uint32_t mask)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t rc;
dds_return_t ret; dds_return_t ret;
if ((rc = dds_entity_claim (entity, &e)) != DDS_RETCODE_OK) if ((ret = dds_entity_claim (entity, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return ret;
if (e->m_deriver.validate_status == 0) if (e->m_deriver.validate_status == 0)
ret = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); ret = DDS_RETCODE_ILLEGAL_OPERATION;
else if ((ret = e->m_deriver.validate_status (mask)) == DDS_RETCODE_OK) else if ((ret = e->m_deriver.validate_status (mask)) == DDS_RETCODE_OK)
{ {
ddsrt_mutex_lock (&e->m_observers_lock); ddsrt_mutex_lock (&e->m_observers_lock);
@ -684,17 +672,16 @@ dds_return_t dds_set_enabled_status(dds_entity_t entity, uint32_t mask)
static dds_return_t dds_readtake_status (dds_entity_t entity, uint32_t *status, uint32_t mask, bool reset) static dds_return_t dds_readtake_status (dds_entity_t entity, uint32_t *status, uint32_t mask, bool reset)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t rc;
dds_return_t ret; dds_return_t ret;
if (status == NULL) if (status == NULL)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) if ((ret = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return ret;
if (e->m_deriver.validate_status == 0) if (e->m_deriver.validate_status == 0)
ret = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); ret = DDS_RETCODE_ILLEGAL_OPERATION;
else if ((ret = e->m_deriver.validate_status (mask)) == DDS_RETCODE_OK) else if ((ret = e->m_deriver.validate_status (mask)) == DDS_RETCODE_OK)
{ {
ddsrt_mutex_lock (&e->m_observers_lock); ddsrt_mutex_lock (&e->m_observers_lock);
@ -721,13 +708,13 @@ dds_return_t dds_take_status (dds_entity_t entity, uint32_t *status, uint32_t ma
dds_return_t dds_get_domainid (dds_entity_t entity, dds_domainid_t *id) dds_return_t dds_get_domainid (dds_entity_t entity, dds_domainid_t *id)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t rc; dds_return_t rc;
if (id == NULL) if (id == NULL)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return rc;
*id = e->m_domainid; *id = e->m_domainid;
dds_entity_unlock(e); dds_entity_unlock(e);
@ -737,26 +724,25 @@ dds_return_t dds_get_domainid (dds_entity_t entity, dds_domainid_t *id)
dds_return_t dds_get_instance_handle (dds_entity_t entity, dds_instance_handle_t *ihdl) dds_return_t dds_get_instance_handle (dds_entity_t entity, dds_instance_handle_t *ihdl)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t rc;
dds_return_t ret; dds_return_t ret;
if (ihdl == NULL) if (ihdl == NULL)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) if ((ret = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return ret;
if (e->m_deriver.get_instance_hdl) if (e->m_deriver.get_instance_hdl)
ret = e->m_deriver.get_instance_hdl (e, ihdl); ret = e->m_deriver.get_instance_hdl (e, ihdl);
else else
ret = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); ret = DDS_RETCODE_ILLEGAL_OPERATION;
dds_entity_unlock(e); dds_entity_unlock(e);
return ret; return ret;
} }
dds_retcode_t dds_entity_claim (dds_entity_t hdl, dds_entity **eptr) dds_return_t dds_entity_claim (dds_entity_t hdl, dds_entity **eptr)
{ {
dds_retcode_t hres; dds_return_t hres;
struct dds_handle_link *hdllink; struct dds_handle_link *hdllink;
if ((hres = dds_handle_claim (hdl, &hdllink)) != DDS_RETCODE_OK) if ((hres = dds_handle_claim (hdl, &hdllink)) != DDS_RETCODE_OK)
return hres; return hres;
@ -772,9 +758,9 @@ void dds_entity_release (dds_entity *e)
dds_handle_release (&e->m_hdllink); dds_handle_release (&e->m_hdllink);
} }
dds_retcode_t dds_entity_lock (dds_entity_t hdl, dds_entity_kind_t kind, dds_entity **eptr) dds_return_t dds_entity_lock (dds_entity_t hdl, dds_entity_kind_t kind, dds_entity **eptr)
{ {
dds_retcode_t hres; dds_return_t hres;
dds_entity *e; dds_entity *e;
/* When the given handle already contains an error, then return that /* When the given handle already contains an error, then return that
@ -817,10 +803,9 @@ dds_return_t dds_triggered (dds_entity_t entity)
{ {
dds_entity *e; dds_entity *e;
dds_return_t ret; dds_return_t ret;
dds_retcode_t rc;
if ((rc = dds_entity_lock(entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) if ((ret = dds_entity_lock(entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return ret;
ddsrt_mutex_lock (&e->m_observers_lock); ddsrt_mutex_lock (&e->m_observers_lock);
ret = (e->m_trigger != 0); ret = (e->m_trigger != 0);
ddsrt_mutex_unlock (&e->m_observers_lock); ddsrt_mutex_unlock (&e->m_observers_lock);
@ -837,9 +822,9 @@ static bool in_observer_list_p (const struct dds_entity *observed, const dds_ent
return false; return false;
} }
dds_retcode_t dds_entity_observer_register_nl (dds_entity *observed, dds_entity_t observer, dds_entity_callback cb) dds_return_t dds_entity_observer_register_nl (dds_entity *observed, dds_entity_t observer, dds_entity_callback cb)
{ {
dds_retcode_t rc; dds_return_t rc;
assert (observed); assert (observed);
ddsrt_mutex_lock (&observed->m_observers_lock); ddsrt_mutex_lock (&observed->m_observers_lock);
if (in_observer_list_p (observed, observer)) if (in_observer_list_p (observed, observer))
@ -857,9 +842,9 @@ dds_retcode_t dds_entity_observer_register_nl (dds_entity *observed, dds_entity_
return rc; return rc;
} }
dds_retcode_t dds_entity_observer_register (dds_entity_t observed, dds_entity_t observer, dds_entity_callback cb) dds_return_t dds_entity_observer_register (dds_entity_t observed, dds_entity_t observer, dds_entity_callback cb)
{ {
dds_retcode_t rc; dds_return_t rc;
dds_entity *e; dds_entity *e;
assert (cb); assert (cb);
if ((rc = dds_entity_lock (observed, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) if ((rc = dds_entity_lock (observed, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
@ -869,9 +854,9 @@ dds_retcode_t dds_entity_observer_register (dds_entity_t observed, dds_entity_t
return rc; return rc;
} }
dds_retcode_t dds_entity_observer_unregister_nl (dds_entity *observed, dds_entity_t observer) dds_return_t dds_entity_observer_unregister_nl (dds_entity *observed, dds_entity_t observer)
{ {
dds_retcode_t rc; dds_return_t rc;
dds_entity_observer *prev, *idx; dds_entity_observer *prev, *idx;
ddsrt_mutex_lock (&observed->m_observers_lock); ddsrt_mutex_lock (&observed->m_observers_lock);
@ -897,9 +882,9 @@ dds_retcode_t dds_entity_observer_unregister_nl (dds_entity *observed, dds_entit
return rc; return rc;
} }
dds_retcode_t dds_entity_observer_unregister (dds_entity_t observed, dds_entity_t observer) dds_return_t dds_entity_observer_unregister (dds_entity_t observed, dds_entity_t observer)
{ {
dds_retcode_t rc; dds_return_t rc;
dds_entity *e; dds_entity *e;
if ((rc = dds_entity_lock (observed, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) if ((rc = dds_entity_lock (observed, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
return rc; return rc;
@ -947,12 +932,12 @@ void dds_entity_status_set (dds_entity *e, uint32_t t)
dds_entity_t dds_get_topic (dds_entity_t entity) dds_entity_t dds_get_topic (dds_entity_t entity)
{ {
dds_retcode_t rc; dds_return_t rc;
dds_entity_t hdl; dds_entity_t hdl;
dds_entity *e; dds_entity *e;
if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return rc;
switch (dds_entity_kind (e)) switch (dds_entity_kind (e))
{ {
case DDS_KIND_READER: { case DDS_KIND_READER: {
@ -973,7 +958,7 @@ dds_entity_t dds_get_topic (dds_entity_t entity)
break; break;
} }
default: { default: {
hdl = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); hdl = DDS_RETCODE_ILLEGAL_OPERATION;
break; break;
} }
} }
@ -984,9 +969,9 @@ dds_entity_t dds_get_topic (dds_entity_t entity)
dds_return_t dds_generic_unimplemented_operation_manykinds (dds_entity_t handle, size_t nkinds, const dds_entity_kind_t *kinds) dds_return_t dds_generic_unimplemented_operation_manykinds (dds_entity_t handle, size_t nkinds, const dds_entity_kind_t *kinds)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t ret; dds_return_t ret;
if ((ret = dds_entity_claim (handle, &e)) != DDS_RETCODE_OK) if ((ret = dds_entity_claim (handle, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (ret); return ret;
else else
{ {
const dds_entity_kind_t actual = dds_entity_kind (e); const dds_entity_kind_t actual = dds_entity_kind (e);
@ -1001,7 +986,7 @@ dds_return_t dds_generic_unimplemented_operation_manykinds (dds_entity_t handle,
} }
} }
dds_entity_release (e); dds_entity_release (e);
return DDS_ERRNO (ret); return ret;
} }
} }

21
src/core/ddsc/src/dds_guardcond.c
View file

@ -14,7 +14,6 @@
#include "dds__reader.h" #include "dds__reader.h"
#include "dds__guardcond.h" #include "dds__guardcond.h"
#include "dds__participant.h" #include "dds__participant.h"
#include "dds__err.h"
#include "dds/ddsi/q_ephash.h" #include "dds/ddsi/q_ephash.h"
#include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_entity.h"
#include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_thread.h"
@ -24,10 +23,10 @@ DECL_ENTITY_LOCK_UNLOCK(extern inline, dds_guardcond)
dds_entity_t dds_create_guardcondition (dds_entity_t participant) dds_entity_t dds_create_guardcondition (dds_entity_t participant)
{ {
dds_participant *pp; dds_participant *pp;
dds_retcode_t rc; dds_return_t rc;
if ((rc = dds_participant_lock (participant, &pp)) != DDS_RETCODE_OK) if ((rc = dds_participant_lock (participant, &pp)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return rc;
else else
{ {
dds_guardcond * gcond = dds_alloc (sizeof (*gcond)); dds_guardcond * gcond = dds_alloc (sizeof (*gcond));
@ -40,10 +39,10 @@ dds_entity_t dds_create_guardcondition (dds_entity_t participant)
dds_return_t dds_set_guardcondition (dds_entity_t condition, bool triggered) dds_return_t dds_set_guardcondition (dds_entity_t condition, bool triggered)
{ {
dds_guardcond *gcond; dds_guardcond *gcond;
dds_retcode_t rc; dds_return_t rc;
if ((rc = dds_guardcond_lock (condition, &gcond)) != DDS_RETCODE_OK) if ((rc = dds_guardcond_lock (condition, &gcond)) != DDS_RETCODE_OK)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return rc;
else else
{ {
ddsrt_mutex_lock (&gcond->m_entity.m_observers_lock); ddsrt_mutex_lock (&gcond->m_entity.m_observers_lock);
@ -60,14 +59,14 @@ dds_return_t dds_set_guardcondition (dds_entity_t condition, bool triggered)
dds_return_t dds_read_guardcondition (dds_entity_t condition, bool *triggered) dds_return_t dds_read_guardcondition (dds_entity_t condition, bool *triggered)
{ {
dds_guardcond *gcond; dds_guardcond *gcond;
dds_retcode_t rc; dds_return_t rc;
if (triggered == NULL) if (triggered == NULL)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
*triggered = false; *triggered = false;
if ((rc = dds_guardcond_lock (condition, &gcond)) != DDS_RETCODE_OK) if ((rc = dds_guardcond_lock (condition, &gcond)) != DDS_RETCODE_OK)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return rc;
else else
{ {
ddsrt_mutex_lock (&gcond->m_entity.m_observers_lock); ddsrt_mutex_lock (&gcond->m_entity.m_observers_lock);
@ -81,14 +80,14 @@ dds_return_t dds_read_guardcondition (dds_entity_t condition, bool *triggered)
dds_return_t dds_take_guardcondition (dds_entity_t condition, bool *triggered) dds_return_t dds_take_guardcondition (dds_entity_t condition, bool *triggered)
{ {
dds_guardcond *gcond; dds_guardcond *gcond;
dds_retcode_t rc; dds_return_t rc;
if (triggered == NULL) if (triggered == NULL)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
*triggered = false; *triggered = false;
if ((rc = dds_guardcond_lock (condition, &gcond)) != DDS_RETCODE_OK) if ((rc = dds_guardcond_lock (condition, &gcond)) != DDS_RETCODE_OK)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return rc;
else else
{ {
ddsrt_mutex_lock (&gcond->m_entity.m_observers_lock); ddsrt_mutex_lock (&gcond->m_entity.m_observers_lock);

3
src/core/ddsc/src/dds_handles.c
View file

@ -19,7 +19,6 @@
#include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_thread.h"
#include "dds__handles.h" #include "dds__handles.h"
#include "dds__types.h" #include "dds__types.h"
#include "dds__err.h"
/* FIXME: this code isn't really correct when USE_CHH is set: /* FIXME: this code isn't really correct when USE_CHH is set:
- the DDS entity code doesn't really play by the awake/asleep mechanism - the DDS entity code doesn't really play by the awake/asleep mechanism
@ -128,7 +127,7 @@ dds_handle_t dds_handle_create (struct dds_handle_link *link)
if (handles.count == MAX_HANDLES) if (handles.count == MAX_HANDLES)
{ {
ddsrt_mutex_unlock (&handles.lock); ddsrt_mutex_unlock (&handles.lock);
ret = DDS_ERRNO (DDS_RETCODE_OUT_OF_RESOURCES); ret = DDS_RETCODE_OUT_OF_RESOURCES;
} }
else else
{ {

21
src/core/ddsc/src/dds_init.c
View file

@ -20,7 +20,6 @@
#include "dds__init.h" #include "dds__init.h"
#include "dds__rhc.h" #include "dds__rhc.h"
#include "dds__domain.h" #include "dds__domain.h"
#include "dds__err.h"
#include "dds__builtin.h" #include "dds__builtin.h"
#include "dds__whc_builtintopic.h" #include "dds__whc_builtintopic.h"
#include "dds/ddsi/ddsi_iid.h" #include "dds/ddsi/ddsi_iid.h"
@ -87,7 +86,7 @@ dds_init(dds_domainid_t domain)
if (dds_cfgst == NULL) if (dds_cfgst == NULL)
{ {
DDS_LOG(DDS_LC_CONFIG, "Failed to parse configuration XML file %s\n", uri); DDS_LOG(DDS_LC_CONFIG, "Failed to parse configuration XML file %s\n", uri);
ret = DDS_ERRNO(DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
goto fail_config; goto fail_config;
} }
@ -97,7 +96,7 @@ dds_init(dds_domainid_t domain)
if (domain < 0 || domain > 230) if (domain < 0 || domain > 230)
{ {
DDS_ERROR("requested domain id %"PRId32" is out of range\n", domain); DDS_ERROR("requested domain id %"PRId32" is out of range\n", domain);
ret = DDS_ERRNO(DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
goto fail_config_domainid; goto fail_config_domainid;
} }
else if (config.domainId.isdefault) else if (config.domainId.isdefault)
@ -107,7 +106,7 @@ dds_init(dds_domainid_t domain)
else if (domain != config.domainId.value) else if (domain != config.domainId.value)
{ {
DDS_ERROR("requested domain id %"PRId32" is inconsistent with configured value %"PRId32"\n", domain, config.domainId.value); DDS_ERROR("requested domain id %"PRId32" is inconsistent with configured value %"PRId32"\n", domain, config.domainId.value);
ret = DDS_ERRNO(DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
goto fail_config_domainid; goto fail_config_domainid;
} }
} }
@ -119,7 +118,7 @@ dds_init(dds_domainid_t domain)
if (rtps_config_prep(dds_cfgst) != 0) if (rtps_config_prep(dds_cfgst) != 0)
{ {
DDS_LOG(DDS_LC_CONFIG, "Failed to configure RTPS\n"); DDS_LOG(DDS_LC_CONFIG, "Failed to configure RTPS\n");
ret = DDS_ERRNO(DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
goto fail_rtps_config; goto fail_rtps_config;
} }
@ -135,7 +134,7 @@ dds_init(dds_domainid_t domain)
if (gv.threadmon == NULL) if (gv.threadmon == NULL)
{ {
DDS_ERROR("Failed to create a thread monitor\n"); DDS_ERROR("Failed to create a thread monitor\n");
ret = DDS_ERRNO(DDS_RETCODE_OUT_OF_RESOURCES); ret = DDS_RETCODE_OUT_OF_RESOURCES;
goto fail_threadmon_new; goto fail_threadmon_new;
} }
} }
@ -143,14 +142,14 @@ dds_init(dds_domainid_t domain)
if (rtps_init () < 0) if (rtps_init () < 0)
{ {
DDS_LOG(DDS_LC_CONFIG, "Failed to initialize RTPS\n"); DDS_LOG(DDS_LC_CONFIG, "Failed to initialize RTPS\n");
ret = DDS_ERRNO(DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
goto fail_rtps_init; goto fail_rtps_init;
} }
if (dds_handle_server_init (free_via_gc) != DDS_RETCODE_OK) if (dds_handle_server_init (free_via_gc) != DDS_RETCODE_OK)
{ {
DDS_ERROR("Failed to initialize internal handle server\n"); DDS_ERROR("Failed to initialize internal handle server\n");
ret = DDS_ERRNO(DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
goto fail_handleserver; goto fail_handleserver;
} }
@ -159,14 +158,14 @@ dds_init(dds_domainid_t domain)
if (rtps_start () < 0) if (rtps_start () < 0)
{ {
DDS_LOG(DDS_LC_CONFIG, "Failed to start RTPS\n"); DDS_LOG(DDS_LC_CONFIG, "Failed to start RTPS\n");
ret = DDS_ERRNO(DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
goto fail_rtps_start; goto fail_rtps_start;
} }
if (gv.threadmon && ddsi_threadmon_start(gv.threadmon) < 0) if (gv.threadmon && ddsi_threadmon_start(gv.threadmon) < 0)
{ {
DDS_ERROR("Failed to start the servicelease\n"); DDS_ERROR("Failed to start the servicelease\n");
ret = DDS_ERRNO(DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
goto fail_threadmon_start; goto fail_threadmon_start;
} }
@ -299,7 +298,7 @@ dds__check_domain(
{ {
DDS_ERROR("Inconsistent domain configuration detected: domain on " DDS_ERROR("Inconsistent domain configuration detected: domain on "
"configuration: %"PRId32", domain %"PRId32"\n", dds_global.m_default_domain, domain); "configuration: %"PRId32", domain %"PRId32"\n", dds_global.m_default_domain, domain);
ret = DDS_ERRNO(DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
} }
} }
return ret; return ret;

64
src/core/ddsc/src/dds_instance.c
View file

@ -17,7 +17,6 @@
#include "dds__write.h" #include "dds__write.h"
#include "dds__writer.h" #include "dds__writer.h"
#include "dds__rhc.h" #include "dds__rhc.h"
#include "dds__err.h"
#include "dds/ddsi/ddsi_tkmap.h" #include "dds/ddsi/ddsi_tkmap.h"
#include "dds/ddsi/ddsi_serdata.h" #include "dds/ddsi/ddsi_serdata.h"
#include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_entity.h"
@ -104,7 +103,7 @@ static const dds_topic *dds_instance_info (dds_entity *e)
static const dds_topic * dds_instance_info_by_hdl (dds_entity_t e) static const dds_topic * dds_instance_info_by_hdl (dds_entity_t e)
{ {
const dds_topic * topic = NULL; const dds_topic * topic = NULL;
dds_retcode_t rc; dds_return_t rc;
dds_entity *w_or_r; dds_entity *w_or_r;
rc = dds_entity_lock(e, DDS_KIND_WRITER, &w_or_r); rc = dds_entity_lock(e, DDS_KIND_WRITER, &w_or_r);
@ -131,19 +130,15 @@ dds_register_instance(
struct ddsi_tkmap_instance * inst; struct ddsi_tkmap_instance * inst;
dds_writer *wr; dds_writer *wr;
dds_return_t ret; dds_return_t ret;
dds_retcode_t rc;
if(data == NULL){ if(data == NULL){
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
goto err;
} }
if(handle == NULL){ if(handle == NULL){
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
goto err;
} }
rc = dds_writer_lock(writer, &wr); ret = dds_writer_lock(writer, &wr);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
ret = DDS_ERRNO(rc);
goto err; goto err;
} }
thread_state_awake (ts1); thread_state_awake (ts1);
@ -152,7 +147,7 @@ dds_register_instance(
*handle = inst->m_iid; *handle = inst->m_iid;
ret = DDS_RETCODE_OK; ret = DDS_RETCODE_OK;
} else { } else {
ret = DDS_ERRNO(DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
} }
thread_state_asleep (ts1); thread_state_asleep (ts1);
dds_writer_unlock(wr); dds_writer_unlock(wr);
@ -184,22 +179,20 @@ dds_unregister_instance_ts(
{ {
struct thread_state1 * const ts1 = lookup_thread_state (); struct thread_state1 * const ts1 = lookup_thread_state ();
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret = DDS_RETCODE_OK;
dds_retcode_t rc;
bool autodispose = true; bool autodispose = true;
dds_write_action action = DDS_WR_ACTION_UNREGISTER; dds_write_action action = DDS_WR_ACTION_UNREGISTER;
dds_writer *wr; dds_writer *wr;
if (data == NULL){ if (data == NULL){
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto err; goto err;
} }
if(timestamp < 0){ if(timestamp < 0){
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto err; goto err;
} }
rc = dds_writer_lock(writer, &wr); ret = dds_writer_lock(writer, &wr);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
ret = DDS_ERRNO(rc);
goto err; goto err;
} }
@ -226,15 +219,13 @@ dds_unregister_instance_ih_ts(
{ {
struct thread_state1 * const ts1 = lookup_thread_state (); struct thread_state1 * const ts1 = lookup_thread_state ();
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret = DDS_RETCODE_OK;
dds_retcode_t rc;
bool autodispose = true; bool autodispose = true;
dds_write_action action = DDS_WR_ACTION_UNREGISTER; dds_write_action action = DDS_WR_ACTION_UNREGISTER;
dds_writer *wr; dds_writer *wr;
struct ddsi_tkmap_instance *tk; struct ddsi_tkmap_instance *tk;
rc = dds_writer_lock(writer, &wr); ret = dds_writer_lock(writer, &wr);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
ret = DDS_ERRNO(rc);
goto err; goto err;
} }
@ -255,7 +246,7 @@ dds_unregister_instance_ih_ts(
ret = dds_write_impl (wr, sample, timestamp, action); ret = dds_write_impl (wr, sample, timestamp, action);
ddsi_sertopic_free_sample (tp, sample, DDS_FREE_ALL); ddsi_sertopic_free_sample (tp, sample, DDS_FREE_ALL);
} else { } else {
ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); ret = DDS_RETCODE_PRECONDITION_NOT_MET;
} }
thread_state_asleep (ts1); thread_state_asleep (ts1);
dds_writer_unlock(wr); dds_writer_unlock(wr);
@ -271,11 +262,10 @@ dds_writedispose_ts(
{ {
struct thread_state1 * const ts1 = lookup_thread_state (); struct thread_state1 * const ts1 = lookup_thread_state ();
dds_return_t ret; dds_return_t ret;
dds_retcode_t rc;
dds_writer *wr; dds_writer *wr;
rc = dds_writer_lock(writer, &wr); ret = dds_writer_lock(writer, &wr);
if (rc == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
thread_state_awake (ts1); thread_state_awake (ts1);
ret = dds_write_impl (wr, data, timestamp, DDS_WR_ACTION_WRITE_DISPOSE); ret = dds_write_impl (wr, data, timestamp, DDS_WR_ACTION_WRITE_DISPOSE);
if (ret == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
@ -283,8 +273,6 @@ dds_writedispose_ts(
} }
thread_state_asleep (ts1); thread_state_asleep (ts1);
dds_writer_unlock(wr); dds_writer_unlock(wr);
} else {
ret = DDS_ERRNO(rc);
} }
return ret; return ret;
@ -315,17 +303,14 @@ dds_dispose_ts(
{ {
struct thread_state1 * const ts1 = lookup_thread_state (); struct thread_state1 * const ts1 = lookup_thread_state ();
dds_return_t ret; dds_return_t ret;
dds_retcode_t rc;
dds_writer *wr; dds_writer *wr;
rc = dds_writer_lock(writer, &wr); ret = dds_writer_lock(writer, &wr);
if (rc == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
thread_state_awake (ts1); thread_state_awake (ts1);
ret = dds_dispose_impl(wr, data, DDS_HANDLE_NIL, timestamp); ret = dds_dispose_impl(wr, data, DDS_HANDLE_NIL, timestamp);
thread_state_asleep (ts1); thread_state_asleep (ts1);
dds_writer_unlock(wr); dds_writer_unlock(wr);
} else {
ret = DDS_ERRNO(rc);
} }
return ret; return ret;
@ -339,11 +324,10 @@ dds_dispose_ih_ts(
{ {
struct thread_state1 * const ts1 = lookup_thread_state (); struct thread_state1 * const ts1 = lookup_thread_state ();
dds_return_t ret; dds_return_t ret;
dds_retcode_t rc;
dds_writer *wr; dds_writer *wr;
rc = dds_writer_lock(writer, &wr); ret = dds_writer_lock(writer, &wr);
if (rc == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
struct ddsi_tkmap_instance *tk; struct ddsi_tkmap_instance *tk;
thread_state_awake (ts1); thread_state_awake (ts1);
if ((tk = ddsi_tkmap_find_by_id (gv.m_tkmap, handle)) != NULL) { if ((tk = ddsi_tkmap_find_by_id (gv.m_tkmap, handle)) != NULL) {
@ -354,12 +338,10 @@ dds_dispose_ih_ts(
ret = dds_dispose_impl (wr, sample, handle, timestamp); ret = dds_dispose_impl (wr, sample, handle, timestamp);
ddsi_sertopic_free_sample (tp, sample, DDS_FREE_ALL); ddsi_sertopic_free_sample (tp, sample, DDS_FREE_ALL);
} else { } else {
ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); ret = DDS_RETCODE_PRECONDITION_NOT_MET;
} }
thread_state_asleep (ts1); thread_state_asleep (ts1);
dds_writer_unlock(wr); dds_writer_unlock(wr);
} else {
ret = DDS_ERRNO(rc);
} }
return ret; return ret;
@ -412,13 +394,13 @@ dds_instance_get_key(
struct ddsi_tkmap_instance * tk; struct ddsi_tkmap_instance * tk;
if(data == NULL){ if(data == NULL){
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto err; goto err;
} }
topic = dds_instance_info_by_hdl (entity); topic = dds_instance_info_by_hdl (entity);
if(topic == NULL){ if(topic == NULL){
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto err; goto err;
} }
thread_state_awake (ts1); thread_state_awake (ts1);
@ -428,7 +410,7 @@ dds_instance_get_key(
ddsi_tkmap_instance_unref (tk); ddsi_tkmap_instance_unref (tk);
ret = DDS_RETCODE_OK; ret = DDS_RETCODE_OK;
} else { } else {
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
} }
thread_state_asleep (ts1); thread_state_asleep (ts1);
err: err:

15
src/core/ddsc/src/dds_participant.c
View file

@ -19,7 +19,6 @@
#include "dds__qos.h" #include "dds__qos.h"
#include "dds__domain.h" #include "dds__domain.h"
#include "dds__participant.h" #include "dds__participant.h"
#include "dds__err.h"
#include "dds__builtin.h" #include "dds__builtin.h"
DECL_ENTITY_LOCK_UNLOCK(extern inline, dds_participant) DECL_ENTITY_LOCK_UNLOCK(extern inline, dds_participant)
@ -37,7 +36,7 @@ dds_participant_status_validate(
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret = DDS_RETCODE_OK;
if (mask & ~(DDS_PARTICIPANT_STATUS_MASK)) { if (mask & ~(DDS_PARTICIPANT_STATUS_MASK)) {
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
} }
return ret; return ret;
@ -106,11 +105,11 @@ dds_participant_qos_validate(
/* Check consistency. */ /* Check consistency. */
if ((qos->present & QP_USER_DATA) && !validate_octetseq(&qos->user_data)) { if ((qos->present & QP_USER_DATA) && !validate_octetseq(&qos->user_data)) {
DDS_ERROR("User data QoS policy is inconsistent and caused an error\n"); DDS_ERROR("User data QoS policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if ((qos->present & QP_PRISMTECH_ENTITY_FACTORY) && !validate_entityfactory_qospolicy(&qos->entity_factory)) { if ((qos->present & QP_PRISMTECH_ENTITY_FACTORY) && !validate_entityfactory_qospolicy(&qos->entity_factory)) {
DDS_ERROR("Prismtech entity factory QoS policy is inconsistent and caused an error\n"); DDS_ERROR("Prismtech entity factory QoS policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
return ret; return ret;
} }
@ -128,7 +127,7 @@ dds_participant_qos_set(
if (enabled) { if (enabled) {
/* TODO: CHAM-95: DDSI does not support changing QoS policies. */ /* TODO: CHAM-95: DDSI does not support changing QoS policies. */
DDS_ERROR("Changing the participant QoS is not supported\n"); DDS_ERROR("Changing the participant QoS is not supported\n");
ret = DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); ret = DDS_RETCODE_UNSUPPORTED;
} }
} }
return ret; return ret;
@ -188,7 +187,7 @@ dds_create_participant(
nn_plist_fini (&plist); nn_plist_fini (&plist);
if (q_rc != 0) { if (q_rc != 0) {
DDS_ERROR("Internal error"); DDS_ERROR("Internal error");
e = DDS_ERRNO(DDS_RETCODE_ERROR); e = DDS_RETCODE_ERROR;
goto fail_new_participant; goto fail_new_participant;
} }
@ -241,12 +240,12 @@ dds_lookup_participant(
if ((participants != NULL) && ((size <= 0) || (size >= INT32_MAX))) { if ((participants != NULL) && ((size <= 0) || (size >= INT32_MAX))) {
DDS_ERROR("Array is given, but with invalid size\n"); DDS_ERROR("Array is given, but with invalid size\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto err; goto err;
} }
if ((participants == NULL) && (size != 0)) { if ((participants == NULL) && (size != 0)) {
DDS_ERROR("Size is given, but no array\n"); DDS_ERROR("Size is given, but no array\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto err; goto err;
} }

30
src/core/ddsc/src/dds_publisher.c
View file

@ -15,7 +15,6 @@
#include "dds__listener.h" #include "dds__listener.h"
#include "dds__publisher.h" #include "dds__publisher.h"
#include "dds__qos.h" #include "dds__qos.h"
#include "dds__err.h"
#include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_entity.h"
#include "dds/version.h" #include "dds/version.h"
@ -32,7 +31,7 @@ dds_publisher_instance_hdl(
(void)i; (void)i;
/* TODO: Get/generate proper handle. */ /* TODO: Get/generate proper handle. */
DDS_ERROR("Getting publisher instance handle is not supported\n"); DDS_ERROR("Getting publisher instance handle is not supported\n");
return DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); return DDS_RETCODE_UNSUPPORTED;
} }
static dds_return_t static dds_return_t
@ -46,24 +45,24 @@ dds_publisher_qos_validate(
/* Check consistency. */ /* Check consistency. */
if((qos->present & QP_GROUP_DATA) && !validate_octetseq(&qos->group_data)){ if((qos->present & QP_GROUP_DATA) && !validate_octetseq(&qos->group_data)){
DDS_ERROR("Group data policy is inconsistent and caused an error\n"); DDS_ERROR("Group data policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if((qos->present & QP_PRESENTATION) && (validate_presentation_qospolicy(&qos->presentation) != 0)){ if((qos->present & QP_PRESENTATION) && (validate_presentation_qospolicy(&qos->presentation) != 0)){
DDS_ERROR("Presentation policy is inconsistent and caused an error\n"); DDS_ERROR("Presentation policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if((qos->present & QP_PARTITION) && !validate_stringseq(&qos->partition)){ if((qos->present & QP_PARTITION) && !validate_stringseq(&qos->partition)){
DDS_ERROR("Partition policy is inconsistent and caused an error\n"); DDS_ERROR("Partition policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if((qos->present & QP_PRISMTECH_ENTITY_FACTORY) && !validate_entityfactory_qospolicy(&qos->entity_factory)){ if((qos->present & QP_PRISMTECH_ENTITY_FACTORY) && !validate_entityfactory_qospolicy(&qos->entity_factory)){
DDS_ERROR("Prismtech entity factory policy is inconsistent and caused an error\n"); DDS_ERROR("Prismtech entity factory policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if(ret == DDS_RETCODE_OK && enabled && (qos->present & QP_PRESENTATION)){ if(ret == DDS_RETCODE_OK && enabled && (qos->present & QP_PRESENTATION)){
/* TODO: Improve/check immutable check. */ /* TODO: Improve/check immutable check. */
DDS_ERROR("Presentation policy is immutable\n"); DDS_ERROR("Presentation policy is immutable\n");
ret = DDS_ERRNO(DDS_RETCODE_IMMUTABLE_POLICY); ret = DDS_RETCODE_IMMUTABLE_POLICY;
} }
return ret; return ret;
} }
@ -80,7 +79,7 @@ dds_publisher_qos_set(
if (enabled) { if (enabled) {
/* TODO: CHAM-95: DDSI does not support changing QoS policies. */ /* TODO: CHAM-95: DDSI does not support changing QoS policies. */
DDS_ERROR(DDS_PROJECT_NAME" does not support changing QoS policies yet\n"); DDS_ERROR(DDS_PROJECT_NAME" does not support changing QoS policies yet\n");
ret = DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); ret = DDS_RETCODE_UNSUPPORTED;
} }
} }
return ret; return ret;
@ -92,7 +91,7 @@ static dds_return_t dds_publisher_status_validate (uint32_t mask)
if (mask & ~(DDS_PUBLISHER_STATUS_MASK)) { if (mask & ~(DDS_PUBLISHER_STATUS_MASK)) {
DDS_ERROR("Invalid status mask\n"); DDS_ERROR("Invalid status mask\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
} }
return ret; return ret;
@ -109,12 +108,11 @@ dds_create_publisher(
dds_entity_t hdl; dds_entity_t hdl;
dds_qos_t * new_qos = NULL; dds_qos_t * new_qos = NULL;
dds_return_t ret; dds_return_t ret;
dds_retcode_t rc;
rc = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &par); ret = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &par);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking participant\n"); DDS_ERROR("Error occurred on locking participant\n");
hdl = DDS_ERRNO(rc); hdl = ret;
goto lock_err; goto lock_err;
} }
@ -164,7 +162,7 @@ dds_wait_for_acks(
dds_duration_t timeout) dds_duration_t timeout)
{ {
if (timeout < 0) if (timeout < 0)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
static const dds_entity_kind_t kinds[] = { DDS_KIND_WRITER, DDS_KIND_PUBLISHER }; static const dds_entity_kind_t kinds[] = { DDS_KIND_WRITER, DDS_KIND_PUBLISHER };
return dds_generic_unimplemented_operation_manykinds (publisher_or_writer, sizeof (kinds) / sizeof (kinds[0]), kinds); return dds_generic_unimplemented_operation_manykinds (publisher_or_writer, sizeof (kinds) / sizeof (kinds[0]), kinds);
} }
@ -176,7 +174,7 @@ dds_publisher_begin_coherent(
/* TODO: CHAM-124 Currently unsupported. */ /* TODO: CHAM-124 Currently unsupported. */
(void)e; (void)e;
DDS_ERROR("Using coherency to get a coherent data set is not being supported yet\n"); DDS_ERROR("Using coherency to get a coherent data set is not being supported yet\n");
return DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); return DDS_RETCODE_UNSUPPORTED;
} }
dds_return_t dds_return_t
@ -186,6 +184,6 @@ dds_publisher_end_coherent(
/* TODO: CHAM-124 Currently unsupported. */ /* TODO: CHAM-124 Currently unsupported. */
(void)e; (void)e;
DDS_ERROR("Using coherency to get a coherent data set is not being supported yet\n"); DDS_ERROR("Using coherency to get a coherent data set is not being supported yet\n");
return DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); return DDS_RETCODE_UNSUPPORTED;
} }

19
src/core/ddsc/src/dds_qos.c
View file

@ -12,7 +12,6 @@
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
#include "dds__qos.h" #include "dds__qos.h"
#include "dds__err.h"
#include "dds/ddsi/q_config.h" #include "dds/ddsi/q_config.h"
/* TODO: dd_duration_t is converted to nn_ddsi_time_t declared in q_time.h /* TODO: dd_duration_t is converted to nn_ddsi_time_t declared in q_time.h
@ -144,31 +143,31 @@ dds_qos_validate_mutable_common (
/* TODO: Check whether immutable QoS are changed should actually incorporate change to current QoS */ /* TODO: Check whether immutable QoS are changed should actually incorporate change to current QoS */
if (qos->present & QP_DEADLINE) { if (qos->present & QP_DEADLINE) {
DDS_ERROR("Deadline QoS policy caused immutable error\n"); DDS_ERROR("Deadline QoS policy caused immutable error\n");
ret = DDS_ERRNO(DDS_RETCODE_IMMUTABLE_POLICY); ret = DDS_RETCODE_IMMUTABLE_POLICY;
} }
if (qos->present & QP_OWNERSHIP) { if (qos->present & QP_OWNERSHIP) {
DDS_ERROR("Ownership QoS policy caused immutable error\n"); DDS_ERROR("Ownership QoS policy caused immutable error\n");
ret = DDS_ERRNO(DDS_RETCODE_IMMUTABLE_POLICY); ret = DDS_RETCODE_IMMUTABLE_POLICY;
} }
if (qos->present & QP_LIVELINESS) { if (qos->present & QP_LIVELINESS) {
DDS_ERROR("Liveliness QoS policy caused immutable error\n"); DDS_ERROR("Liveliness QoS policy caused immutable error\n");
ret = DDS_ERRNO(DDS_RETCODE_IMMUTABLE_POLICY); ret = DDS_RETCODE_IMMUTABLE_POLICY;
} }
if (qos->present & QP_RELIABILITY) { if (qos->present & QP_RELIABILITY) {
DDS_ERROR("Reliability QoS policy caused immutable error\n"); DDS_ERROR("Reliability QoS policy caused immutable error\n");
ret = DDS_ERRNO(DDS_RETCODE_IMMUTABLE_POLICY); ret = DDS_RETCODE_IMMUTABLE_POLICY;
} }
if (qos->present & QP_DESTINATION_ORDER) { if (qos->present & QP_DESTINATION_ORDER) {
DDS_ERROR("Destination order QoS policy caused immutable error\n"); DDS_ERROR("Destination order QoS policy caused immutable error\n");
ret = DDS_ERRNO(DDS_RETCODE_IMMUTABLE_POLICY); ret = DDS_RETCODE_IMMUTABLE_POLICY;
} }
if (qos->present & QP_HISTORY) { if (qos->present & QP_HISTORY) {
DDS_ERROR("History QoS policy caused immutable error\n"); DDS_ERROR("History QoS policy caused immutable error\n");
ret = DDS_ERRNO(DDS_RETCODE_IMMUTABLE_POLICY); ret = DDS_RETCODE_IMMUTABLE_POLICY;
} }
if (qos->present & QP_RESOURCE_LIMITS) { if (qos->present & QP_RESOURCE_LIMITS) {
DDS_ERROR("Resource limits QoS policy caused immutable error\n"); DDS_ERROR("Resource limits QoS policy caused immutable error\n");
ret = DDS_ERRNO(DDS_RETCODE_IMMUTABLE_POLICY); ret = DDS_RETCODE_IMMUTABLE_POLICY;
} }
return ret; return ret;
@ -263,11 +262,11 @@ dds_copy_qos (
{ {
if(!src){ if(!src){
DDS_ERROR("Argument source(src) is NULL\n"); DDS_ERROR("Argument source(src) is NULL\n");
return DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
} }
if(!dst){ if(!dst){
DDS_ERROR("Argument destination(dst) is NULL\n"); DDS_ERROR("Argument destination(dst) is NULL\n");
return DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
} }
nn_xqos_copy (dst, src); nn_xqos_copy (dst, src);
return DDS_RETCODE_OK; return DDS_RETCODE_OK;

7
src/core/ddsc/src/dds_querycond.c
View file

@ -18,7 +18,6 @@
#include "dds__topic.h" #include "dds__topic.h"
#include "dds__querycond.h" #include "dds__querycond.h"
#include "dds__readcond.h" #include "dds__readcond.h"
#include "dds__err.h"
#include "dds/ddsi/ddsi_serdata.h" #include "dds/ddsi/ddsi_serdata.h"
#include "dds/ddsi/ddsi_sertopic.h" #include "dds/ddsi/ddsi_sertopic.h"
@ -29,7 +28,7 @@ dds_create_querycondition(
dds_querycondition_filter_fn filter) dds_querycondition_filter_fn filter)
{ {
dds_entity_t hdl; dds_entity_t hdl;
dds_retcode_t rc; dds_return_t rc;
dds_reader *r; dds_reader *r;
rc = dds_reader_lock(reader, &r); rc = dds_reader_lock(reader, &r);
@ -42,11 +41,11 @@ dds_create_querycondition(
hdl = cond->m_entity.m_hdllink.hdl; hdl = cond->m_entity.m_hdllink.hdl;
} else { } else {
dds_delete (cond->m_entity.m_hdllink.hdl); dds_delete (cond->m_entity.m_hdllink.hdl);
hdl = DDS_ERRNO(DDS_RETCODE_OUT_OF_RESOURCES); hdl = DDS_RETCODE_OUT_OF_RESOURCES;
} }
} else { } else {
DDS_ERROR("Error occurred on locking reader\n"); DDS_ERROR("Error occurred on locking reader\n");
hdl = DDS_ERRNO(rc); hdl = rc;
} }
return hdl; return hdl;

56
src/core/ddsc/src/dds_read.c
View file

@ -15,16 +15,15 @@
#include "dds__reader.h" #include "dds__reader.h"
#include "dds/ddsi/ddsi_tkmap.h" #include "dds/ddsi/ddsi_tkmap.h"
#include "dds__rhc.h" #include "dds__rhc.h"
#include "dds__err.h"
#include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_thread.h"
#include "dds/ddsi/q_ephash.h" #include "dds/ddsi/q_ephash.h"
#include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_entity.h"
#include "dds/ddsi/q_globals.h" #include "dds/ddsi/q_globals.h"
#include "dds/ddsi/ddsi_sertopic.h" #include "dds/ddsi/ddsi_sertopic.h"
static dds_retcode_t dds_read_lock (dds_entity_t hdl, dds_reader **reader, dds_readcond **condition, bool only_reader) static dds_return_t dds_read_lock (dds_entity_t hdl, dds_reader **reader, dds_readcond **condition, bool only_reader)
{ {
dds_retcode_t rc; dds_return_t rc;
dds_entity *entity, *parent_entity; dds_entity *entity, *parent_entity;
if ((rc = dds_entity_lock (hdl, DDS_KIND_DONTCARE, &entity)) != DDS_RETCODE_OK) if ((rc = dds_entity_lock (hdl, DDS_KIND_DONTCARE, &entity)) != DDS_RETCODE_OK)
{ {
@ -91,7 +90,6 @@ dds_read_impl(
{ {
struct thread_state1 * const ts1 = lookup_thread_state (); struct thread_state1 * const ts1 = lookup_thread_state ();
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret = DDS_RETCODE_OK;
dds_retcode_t rc;
struct dds_reader * rd; struct dds_reader * rd;
struct dds_readcond * cond; struct dds_readcond * cond;
unsigned nodata_cleanups = 0; unsigned nodata_cleanups = 0;
@ -101,40 +99,39 @@ dds_read_impl(
if (buf == NULL) { if (buf == NULL) {
DDS_ERROR("The provided buffer is NULL\n"); DDS_ERROR("The provided buffer is NULL\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto fail; goto fail;
} }
if (si == NULL) { if (si == NULL) {
DDS_ERROR("Provided pointer to an array of dds_sample_info_t is NULL\n"); DDS_ERROR("Provided pointer to an array of dds_sample_info_t is NULL\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto fail; goto fail;
} }
if (maxs == 0) { if (maxs == 0) {
DDS_ERROR("The maximum number of samples to read is zero\n"); DDS_ERROR("The maximum number of samples to read is zero\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto fail; goto fail;
} }
if (bufsz == 0) { if (bufsz == 0) {
DDS_ERROR("The size of buffer is zero\n"); DDS_ERROR("The size of buffer is zero\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto fail; goto fail;
} }
if (bufsz < maxs) { if (bufsz < maxs) {
DDS_ERROR("The provided size of buffer is smaller than the maximum number of samples to read\n"); DDS_ERROR("The provided size of buffer is smaller than the maximum number of samples to read\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto fail; goto fail;
} }
thread_state_awake (ts1); thread_state_awake (ts1);
rc = dds_read_lock(reader_or_condition, &rd, &cond, only_reader); ret = dds_read_lock(reader_or_condition, &rd, &cond, only_reader);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
ret = DDS_ERRNO(rc);
goto fail_awake; goto fail_awake;
} }
if (hand != DDS_HANDLE_NIL) { if (hand != DDS_HANDLE_NIL) {
if (ddsi_tkmap_find_by_id(gv.m_tkmap, hand) == NULL) { if (ddsi_tkmap_find_by_id(gv.m_tkmap, hand) == NULL) {
DDS_ERROR("Could not find instance\n"); DDS_ERROR("Could not find instance\n");
ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); ret = DDS_RETCODE_PRECONDITION_NOT_MET;
dds_read_unlock(rd, cond); dds_read_unlock(rd, cond);
goto fail_awake; goto fail_awake;
} }
@ -217,7 +214,6 @@ dds_readcdr_impl(
{ {
struct thread_state1 * const ts1 = lookup_thread_state (); struct thread_state1 * const ts1 = lookup_thread_state ();
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret = DDS_RETCODE_OK;
dds_retcode_t rc;
struct dds_reader * rd; struct dds_reader * rd;
struct dds_readcond * cond; struct dds_readcond * cond;
@ -229,8 +225,8 @@ dds_readcdr_impl(
(void)take; (void)take;
thread_state_awake (ts1); thread_state_awake (ts1);
rc = dds_read_lock(reader_or_condition, &rd, &cond, false); ret = dds_read_lock(reader_or_condition, &rd, &cond, false);
if (rc == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
/* read/take resets data available status -- must reset before reading because /* read/take resets data available status -- must reset before reading because
the actual writing is protected by RHC lock, not by rd->m_entity.m_lock */ the actual writing is protected by RHC lock, not by rd->m_entity.m_lock */
ddsrt_mutex_lock (&rd->m_entity.m_observers_lock); ddsrt_mutex_lock (&rd->m_entity.m_observers_lock);
@ -251,8 +247,6 @@ dds_readcdr_impl(
); );
dds_read_unlock(rd, cond); dds_read_unlock(rd, cond);
} else {
ret = DDS_ERRNO(rc);
} }
thread_state_asleep (ts1); thread_state_asleep (ts1);
@ -349,7 +343,7 @@ dds_read_instance(
if (handle == DDS_HANDLE_NIL) { if (handle == DDS_HANDLE_NIL) {
DDS_ERROR("DDS_HANDLE_NIL was provided\n"); DDS_ERROR("DDS_HANDLE_NIL was provided\n");
ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); ret = DDS_RETCODE_PRECONDITION_NOT_MET;
goto fail; goto fail;
} }
@ -377,7 +371,7 @@ dds_read_instance_wl(
if (handle == DDS_HANDLE_NIL) { if (handle == DDS_HANDLE_NIL) {
DDS_ERROR("DDS_HANDLE_NIL was provided\n"); DDS_ERROR("DDS_HANDLE_NIL was provided\n");
ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); ret = DDS_RETCODE_PRECONDITION_NOT_MET;
goto fail; goto fail;
} }
@ -407,7 +401,7 @@ dds_read_instance_mask(
if (handle == DDS_HANDLE_NIL) { if (handle == DDS_HANDLE_NIL) {
DDS_ERROR("DDS_HANDLE_NIL was provided\n"); DDS_ERROR("DDS_HANDLE_NIL was provided\n");
ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); ret = DDS_RETCODE_PRECONDITION_NOT_MET;
goto fail; goto fail;
} }
@ -436,7 +430,7 @@ dds_read_instance_mask_wl(
if (handle == DDS_HANDLE_NIL) { if (handle == DDS_HANDLE_NIL) {
DDS_ERROR("DDS_HANDLE_NIL was provided\n"); DDS_ERROR("DDS_HANDLE_NIL was provided\n");
ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); ret = DDS_RETCODE_PRECONDITION_NOT_MET;
goto fail; goto fail;
} }
if (maxs == DDS_READ_WITHOUT_LOCK) { if (maxs == DDS_READ_WITHOUT_LOCK) {
@ -579,7 +573,7 @@ dds_take_instance(
if (handle == DDS_HANDLE_NIL) { if (handle == DDS_HANDLE_NIL) {
DDS_ERROR("DDS_HANDLE_NIL was provided\n"); DDS_ERROR("DDS_HANDLE_NIL was provided\n");
ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); ret = DDS_RETCODE_PRECONDITION_NOT_MET;
goto fail; goto fail;
} }
@ -607,7 +601,7 @@ dds_take_instance_wl(
if (handle == DDS_HANDLE_NIL) { if (handle == DDS_HANDLE_NIL) {
DDS_ERROR("DDS_HANDLE_NIL was provided\n"); DDS_ERROR("DDS_HANDLE_NIL was provided\n");
ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); ret = DDS_RETCODE_PRECONDITION_NOT_MET;
goto fail; goto fail;
} }
if (maxs == DDS_READ_WITHOUT_LOCK) { if (maxs == DDS_READ_WITHOUT_LOCK) {
@ -636,7 +630,7 @@ dds_take_instance_mask(
if (handle == DDS_HANDLE_NIL) { if (handle == DDS_HANDLE_NIL) {
DDS_ERROR("DDS_HANDLE_NIL was provided\n"); DDS_ERROR("DDS_HANDLE_NIL was provided\n");
ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); ret = DDS_RETCODE_PRECONDITION_NOT_MET;
goto fail; goto fail;
} }
if (maxs == DDS_READ_WITHOUT_LOCK) { if (maxs == DDS_READ_WITHOUT_LOCK) {
@ -664,7 +658,7 @@ dds_take_instance_mask_wl(
if (handle == DDS_HANDLE_NIL) { if (handle == DDS_HANDLE_NIL) {
DDS_ERROR("DDS_HANDLE_NIL was provided\n"); DDS_ERROR("DDS_HANDLE_NIL was provided\n");
ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); ret = DDS_RETCODE_PRECONDITION_NOT_MET;
goto fail; goto fail;
} }
if (maxs == DDS_READ_WITHOUT_LOCK) { if (maxs == DDS_READ_WITHOUT_LOCK) {
@ -704,7 +698,6 @@ dds_return_loan(
void **buf, void **buf,
int32_t bufsz) int32_t bufsz)
{ {
dds_retcode_t rc;
const struct ddsi_sertopic *st; const struct ddsi_sertopic *st;
dds_reader *rd; dds_reader *rd;
dds_readcond *cond; dds_readcond *cond;
@ -712,17 +705,16 @@ dds_return_loan(
if (!buf) { if (!buf) {
DDS_ERROR("Argument buf is NULL\n"); DDS_ERROR("Argument buf is NULL\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto fail; goto fail;
} }
if (*buf == NULL && bufsz > 0) { if (*buf == NULL && bufsz > 0) {
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto fail; goto fail;
} }
rc = dds_read_lock(reader_or_condition, &rd, &cond, false); ret = dds_read_lock(reader_or_condition, &rd, &cond, false);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
ret = DDS_ERRNO(rc);
goto fail; goto fail;
} }
st = rd->m_topic->m_stopic; st = rd->m_topic->m_stopic;

19
src/core/ddsc/src/dds_readcond.c
View file

@ -14,7 +14,6 @@
#include "dds__readcond.h" #include "dds__readcond.h"
#include "dds__rhc.h" #include "dds__rhc.h"
#include "dds__entity.h" #include "dds__entity.h"
#include "dds__err.h"
#include "dds/ddsi/q_ephash.h" #include "dds/ddsi/q_ephash.h"
#include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_entity.h"
#include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_thread.h"
@ -63,7 +62,7 @@ dds_create_readcondition(
{ {
dds_entity_t hdl; dds_entity_t hdl;
dds_reader * rd; dds_reader * rd;
dds_retcode_t rc; dds_return_t rc;
rc = dds_reader_lock(reader, &rd); rc = dds_reader_lock(reader, &rd);
if (rc == DDS_RETCODE_OK) { if (rc == DDS_RETCODE_OK) {
@ -74,7 +73,7 @@ dds_create_readcondition(
dds_reader_unlock(rd); dds_reader_unlock(rd);
} else { } else {
DDS_ERROR("Error occurred on locking reader\n"); DDS_ERROR("Error occurred on locking reader\n");
hdl = DDS_ERRNO(rc); hdl = rc;
} }
return hdl; return hdl;
@ -83,9 +82,9 @@ dds_create_readcondition(
dds_entity_t dds_get_datareader (dds_entity_t condition) dds_entity_t dds_get_datareader (dds_entity_t condition)
{ {
struct dds_entity *e; struct dds_entity *e;
dds_retcode_t rc; dds_return_t rc;
if ((rc = dds_entity_claim (condition, &e)) != DDS_RETCODE_OK) if ((rc = dds_entity_claim (condition, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return rc;
else else
{ {
dds_entity_t rdh; dds_entity_t rdh;
@ -97,7 +96,7 @@ dds_entity_t dds_get_datareader (dds_entity_t condition)
rdh = e->m_parent->m_hdllink.hdl; rdh = e->m_parent->m_hdllink.hdl;
break; break;
default: default:
rdh = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); rdh = DDS_RETCODE_ILLEGAL_OPERATION;
break; break;
} }
dds_entity_release (e); dds_entity_release (e);
@ -108,17 +107,17 @@ dds_entity_t dds_get_datareader (dds_entity_t condition)
dds_return_t dds_get_mask (dds_entity_t condition, uint32_t *mask) dds_return_t dds_get_mask (dds_entity_t condition, uint32_t *mask)
{ {
dds_entity *entity; dds_entity *entity;
dds_retcode_t rc; dds_return_t rc;
if (mask == NULL) if (mask == NULL)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
if ((rc = dds_entity_lock (condition, DDS_KIND_DONTCARE, &entity)) != DDS_RETCODE_OK) if ((rc = dds_entity_lock (condition, DDS_KIND_DONTCARE, &entity)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return rc;
else if (dds_entity_kind (entity) != DDS_KIND_COND_READ && dds_entity_kind (entity) != DDS_KIND_COND_QUERY) else if (dds_entity_kind (entity) != DDS_KIND_COND_READ && dds_entity_kind (entity) != DDS_KIND_COND_QUERY)
{ {
dds_entity_unlock (entity); dds_entity_unlock (entity);
return DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); return DDS_RETCODE_ILLEGAL_OPERATION;
} }
else else
{ {

100
src/core/ddsc/src/dds_reader.c
View file

@ -19,7 +19,6 @@
#include "dds__qos.h" #include "dds__qos.h"
#include "dds__init.h" #include "dds__init.h"
#include "dds__rhc.h" #include "dds__rhc.h"
#include "dds__err.h"
#include "dds__topic.h" #include "dds__topic.h"
#include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_entity.h"
#include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_thread.h"
@ -53,7 +52,6 @@ static dds_return_t
dds_reader_close( dds_reader_close(
dds_entity *e) dds_entity *e)
{ {
dds_retcode_t rc;
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret = DDS_RETCODE_OK;
assert(e); assert(e);
@ -61,8 +59,7 @@ dds_reader_close(
thread_state_awake (lookup_thread_state ()); thread_state_awake (lookup_thread_state ());
if (delete_reader(&e->m_guid) != 0) { if (delete_reader(&e->m_guid) != 0) {
DDS_ERROR("Internal error"); DDS_ERROR("Internal error");
rc = DDS_RETCODE_ERROR; ret = DDS_RETCODE_ERROR;
ret = DDS_ERRNO(rc);
} }
thread_state_asleep (lookup_thread_state ()); thread_state_asleep (lookup_thread_state ());
return ret; return ret;
@ -78,7 +75,7 @@ dds_reader_delete(
ret = dds_delete(rd->m_topic->m_entity.m_hdllink.hdl); ret = dds_delete(rd->m_topic->m_entity.m_hdllink.hdl);
if(ret == DDS_RETCODE_OK){ if(ret == DDS_RETCODE_OK){
ret = dds_delete_impl(e->m_parent->m_hdllink.hdl, true); ret = dds_delete_impl(e->m_parent->m_hdllink.hdl, true);
if(dds_err_nr(ret) == DDS_RETCODE_BAD_PARAMETER){ if(ret == DDS_RETCODE_BAD_PARAMETER){
ret = DDS_RETCODE_OK; ret = DDS_RETCODE_OK;
} }
} }
@ -98,27 +95,27 @@ dds_reader_qos_validate(
/* Check consistency. */ /* Check consistency. */
if(!dds_qos_validate_common(qos)) { if(!dds_qos_validate_common(qos)) {
DDS_ERROR("Argument Qos is not valid\n"); DDS_ERROR("Argument Qos is not valid\n");
ret = DDS_ERRNO(DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
} }
if((qos->present & QP_USER_DATA) && !(validate_octetseq (&qos->user_data))) { if((qos->present & QP_USER_DATA) && !(validate_octetseq (&qos->user_data))) {
DDS_ERROR("User data policy is inconsistent and caused an error\n"); DDS_ERROR("User data policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if((qos->present & QP_PRISMTECH_READER_DATA_LIFECYCLE) && (validate_reader_data_lifecycle (&qos->reader_data_lifecycle) != 0)) { if((qos->present & QP_PRISMTECH_READER_DATA_LIFECYCLE) && (validate_reader_data_lifecycle (&qos->reader_data_lifecycle) != 0)) {
DDS_ERROR("Prismtech reader data lifecycle policy is inconsistent and caused an error\n"); DDS_ERROR("Prismtech reader data lifecycle policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if((qos->present & QP_TIME_BASED_FILTER) && (validate_duration (&qos->time_based_filter.minimum_separation) != 0)) { if((qos->present & QP_TIME_BASED_FILTER) && (validate_duration (&qos->time_based_filter.minimum_separation) != 0)) {
DDS_ERROR("Time based filter policy is inconsistent and caused an error\n"); DDS_ERROR("Time based filter policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if((qos->present & QP_HISTORY) && (qos->present & QP_RESOURCE_LIMITS) && (validate_history_and_resource_limits (&qos->history, &qos->resource_limits) != 0)) { if((qos->present & QP_HISTORY) && (qos->present & QP_RESOURCE_LIMITS) && (validate_history_and_resource_limits (&qos->history, &qos->resource_limits) != 0)) {
DDS_ERROR("History and resource limits policy is inconsistent and caused an error\n"); DDS_ERROR("History and resource limits policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if((qos->present & QP_TIME_BASED_FILTER) && (qos->present & QP_DEADLINE) && !(validate_deadline_and_timebased_filter (qos->deadline.deadline, qos->time_based_filter.minimum_separation))) { if((qos->present & QP_TIME_BASED_FILTER) && (qos->present & QP_DEADLINE) && !(validate_deadline_and_timebased_filter (qos->deadline.deadline, qos->time_based_filter.minimum_separation))) {
DDS_ERROR("Time based filter and deadline policy is inconsistent and caused an error\n"); DDS_ERROR("Time based filter and deadline policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if(ret == DDS_RETCODE_OK && enabled) { if(ret == DDS_RETCODE_OK && enabled) {
ret = dds_qos_validate_mutable_common(qos); ret = dds_qos_validate_mutable_common(qos);
@ -139,7 +136,7 @@ dds_reader_qos_set(
if (enabled) { if (enabled) {
/* TODO: CHAM-95: DDSI does not support changing QoS policies. */ /* TODO: CHAM-95: DDSI does not support changing QoS policies. */
DDS_ERROR(DDS_PROJECT_NAME" does not support changing QoS policies\n"); DDS_ERROR(DDS_PROJECT_NAME" does not support changing QoS policies\n");
ret = DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); ret = DDS_RETCODE_UNSUPPORTED;
} }
} }
return ret; return ret;
@ -150,7 +147,7 @@ dds_reader_status_validate(
uint32_t mask) uint32_t mask)
{ {
return (mask & ~(DDS_READER_STATUS_MASK)) ? return (mask & ~(DDS_READER_STATUS_MASK)) ?
DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER) : DDS_RETCODE_BAD_PARAMETER :
DDS_RETCODE_OK; DDS_RETCODE_OK;
} }
@ -360,7 +357,6 @@ dds_create_reader(
const dds_listener_t *listener) const dds_listener_t *listener)
{ {
dds_qos_t * rqos; dds_qos_t * rqos;
dds_retcode_t rc;
dds_subscriber * sub = NULL; dds_subscriber * sub = NULL;
dds_entity_t subscriber; dds_entity_t subscriber;
dds_reader * rd; dds_reader * rd;
@ -383,8 +379,8 @@ dds_create_reader(
default: { default: {
dds_entity *p_or_s; dds_entity *p_or_s;
if ((rc = dds_entity_claim (participant_or_subscriber, &p_or_s)) != DDS_RETCODE_OK) { if ((ret = dds_entity_claim (participant_or_subscriber, &p_or_s)) != DDS_RETCODE_OK) {
return DDS_ERRNO (rc); return ret;
} }
if (dds_entity_kind (p_or_s) == DDS_KIND_PARTICIPANT) { if (dds_entity_kind (p_or_s) == DDS_KIND_PARTICIPANT) {
subscriber = dds_create_subscriber(participant_or_subscriber, qos, NULL); subscriber = dds_create_subscriber(participant_or_subscriber, qos, NULL);
@ -398,8 +394,8 @@ dds_create_reader(
} }
} }
if ((rc = dds_subscriber_lock (subscriber, &sub)) != DDS_RETCODE_OK) { if ((ret = dds_subscriber_lock (subscriber, &sub)) != DDS_RETCODE_OK) {
reader = DDS_ERRNO (rc); reader = ret;
goto err_sub_lock; goto err_sub_lock;
} }
@ -408,10 +404,10 @@ dds_create_reader(
sub->m_entity.m_flags |= DDS_ENTITY_IMPLICIT; sub->m_entity.m_flags |= DDS_ENTITY_IMPLICIT;
} }
rc = dds_topic_lock(t, &tp); ret = dds_topic_lock(t, &tp);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking topic\n"); DDS_ERROR("Error occurred on locking topic\n");
reader = DDS_ERRNO(rc); reader = ret;
goto err_tp_lock; goto err_tp_lock;
} }
assert (tp->m_stopic); assert (tp->m_stopic);
@ -448,7 +444,7 @@ dds_create_reader(
if (internal_topic && !dds__validate_builtin_reader_qos(topic, qos)) { if (internal_topic && !dds__validate_builtin_reader_qos(topic, qos)) {
dds_delete_qos(rqos); dds_delete_qos(rqos);
DDS_ERROR("Invalid QoS specified for built-in topic reader"); DDS_ERROR("Invalid QoS specified for built-in topic reader");
reader = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); reader = DDS_RETCODE_INCONSISTENT_POLICY;
goto err_bad_qos; goto err_bad_qos;
} }
@ -573,12 +569,12 @@ uint32_t dds_reader_lock_samples (dds_entity_t reader)
return n; return n;
} }
int dds_reader_wait_for_historical_data (dds_entity_t reader, dds_duration_t max_wait) dds_return_t dds_reader_wait_for_historical_data (dds_entity_t reader, dds_duration_t max_wait)
{ {
dds_reader *rd; dds_reader *rd;
int ret; dds_return_t ret;
if ((ret = dds_reader_lock (reader, &rd)) != DDS_RETCODE_OK) if ((ret = dds_reader_lock (reader, &rd)) != DDS_RETCODE_OK)
return DDS_ERRNO (ret); return ret;
switch (rd->m_entity.m_qos->durability.kind) switch (rd->m_entity.m_qos->durability.kind)
{ {
case DDS_DURABILITY_VOLATILE: case DDS_DURABILITY_VOLATILE:
@ -598,9 +594,9 @@ int dds_reader_wait_for_historical_data (dds_entity_t reader, dds_duration_t max
dds_entity_t dds_get_subscriber (dds_entity_t entity) dds_entity_t dds_get_subscriber (dds_entity_t entity)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t ret; dds_return_t ret;
if ((ret = dds_entity_claim (entity, &e)) != DDS_RETCODE_OK) if ((ret = dds_entity_claim (entity, &e)) != DDS_RETCODE_OK)
return (dds_entity_t) DDS_ERRNO (ret); return ret;
else else
{ {
dds_entity_t subh; dds_entity_t subh;
@ -617,7 +613,7 @@ dds_entity_t dds_get_subscriber (dds_entity_t entity)
subh = e->m_parent->m_parent->m_hdllink.hdl; subh = e->m_parent->m_parent->m_hdllink.hdl;
break; break;
default: default:
subh = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); subh = DDS_RETCODE_ILLEGAL_OPERATION;
break; break;
} }
dds_entity_release (e); dds_entity_release (e);
@ -630,14 +626,12 @@ dds_get_subscription_matched_status (
dds_entity_t reader, dds_entity_t reader,
dds_subscription_matched_status_t * status) dds_subscription_matched_status_t * status)
{ {
dds_retcode_t rc;
dds_reader *rd; dds_reader *rd;
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret;
rc = dds_reader_lock(reader, &rd); ret = dds_reader_lock(reader, &rd);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking reader\n"); DDS_ERROR("Error occurred on locking reader\n");
ret = DDS_ERRNO(rc);
goto fail; goto fail;
} }
/* status = NULL, application do not need the status, but reset the counter & triggered bit */ /* status = NULL, application do not need the status, but reset the counter & triggered bit */
@ -661,14 +655,12 @@ dds_get_liveliness_changed_status (
dds_entity_t reader, dds_entity_t reader,
dds_liveliness_changed_status_t * status) dds_liveliness_changed_status_t * status)
{ {
dds_retcode_t rc;
dds_reader *rd; dds_reader *rd;
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret;
rc = dds_reader_lock(reader, &rd); ret = dds_reader_lock(reader, &rd);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking reader\n"); DDS_ERROR("Error occurred on locking reader\n");
ret = DDS_ERRNO(rc);
goto fail; goto fail;
} }
/* status = NULL, application do not need the status, but reset the counter & triggered bit */ /* status = NULL, application do not need the status, but reset the counter & triggered bit */
@ -691,14 +683,12 @@ dds_return_t dds_get_sample_rejected_status (
dds_entity_t reader, dds_entity_t reader,
dds_sample_rejected_status_t * status) dds_sample_rejected_status_t * status)
{ {
dds_retcode_t rc;
dds_reader *rd; dds_reader *rd;
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret;
rc = dds_reader_lock(reader, &rd); ret = dds_reader_lock(reader, &rd);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking reader\n"); DDS_ERROR("Error occurred on locking reader\n");
ret = DDS_ERRNO(rc);
goto fail; goto fail;
} }
/* status = NULL, application do not need the status, but reset the counter & triggered bit */ /* status = NULL, application do not need the status, but reset the counter & triggered bit */
@ -721,14 +711,12 @@ dds_return_t dds_get_sample_lost_status (
dds_entity_t reader, dds_entity_t reader,
dds_sample_lost_status_t * status) dds_sample_lost_status_t * status)
{ {
dds_retcode_t rc;
dds_reader *rd; dds_reader *rd;
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret;
rc = dds_reader_lock(reader, &rd); ret = dds_reader_lock(reader, &rd);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking reader\n"); DDS_ERROR("Error occurred on locking reader\n");
ret = DDS_ERRNO(rc);
goto fail; goto fail;
} }
/* status = NULL, application do not need the status, but reset the counter & triggered bit */ /* status = NULL, application do not need the status, but reset the counter & triggered bit */
@ -750,14 +738,12 @@ dds_return_t dds_get_requested_deadline_missed_status (
dds_entity_t reader, dds_entity_t reader,
dds_requested_deadline_missed_status_t * status) dds_requested_deadline_missed_status_t * status)
{ {
dds_retcode_t rc;
dds_reader *rd; dds_reader *rd;
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret;
rc = dds_reader_lock(reader, &rd); ret = dds_reader_lock(reader, &rd);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking reader\n"); DDS_ERROR("Error occurred on locking reader\n");
ret = DDS_ERRNO(rc);
goto fail; goto fail;
} }
/* status = NULL, application do not need the status, but reset the counter & triggered bit */ /* status = NULL, application do not need the status, but reset the counter & triggered bit */
@ -779,14 +765,12 @@ dds_return_t dds_get_requested_incompatible_qos_status (
dds_entity_t reader, dds_entity_t reader,
dds_requested_incompatible_qos_status_t * status) dds_requested_incompatible_qos_status_t * status)
{ {
dds_retcode_t rc;
dds_reader *rd; dds_reader *rd;
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret;
rc = dds_reader_lock(reader, &rd); ret = dds_reader_lock(reader, &rd);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking reader\n"); DDS_ERROR("Error occurred on locking reader\n");
ret = DDS_ERRNO(rc);
goto fail; goto fail;
} }
/* status = NULL, application do not need the status, but reset the counter & triggered bit */ /* status = NULL, application do not need the status, but reset the counter & triggered bit */

1
src/core/ddsc/src/dds_rhc.c
View file

@ -30,7 +30,6 @@
#include "dds/ddsrt/hopscotch.h" #include "dds/ddsrt/hopscotch.h"
#include "dds/ddsrt/avl.h" #include "dds/ddsrt/avl.h"
#include "dds/ddsi/q_xqos.h" #include "dds/ddsi/q_xqos.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/q_unused.h" #include "dds/ddsi/q_unused.h"
#include "dds/ddsi/q_config.h" #include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_globals.h" #include "dds/ddsi/q_globals.h"

34
src/core/ddsc/src/dds_subscriber.c
View file

@ -12,7 +12,6 @@
#include <string.h> #include <string.h>
#include "dds__listener.h" #include "dds__listener.h"
#include "dds__qos.h" #include "dds__qos.h"
#include "dds__err.h"
#include "dds__subscriber.h" #include "dds__subscriber.h"
#include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_entity.h"
#include "dds/version.h" #include "dds/version.h"
@ -31,7 +30,7 @@ dds_subscriber_instance_hdl(
(void)i; (void)i;
/* TODO: Get/generate proper handle. */ /* TODO: Get/generate proper handle. */
DDS_ERROR("Generating subscriber instance handle is not supported"); DDS_ERROR("Generating subscriber instance handle is not supported");
return DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); return DDS_RETCODE_UNSUPPORTED;
} }
static dds_return_t static dds_return_t
@ -45,24 +44,24 @@ dds__subscriber_qos_validate(
if((qos->present & QP_GROUP_DATA) && !validate_octetseq(&qos->group_data)) { if((qos->present & QP_GROUP_DATA) && !validate_octetseq(&qos->group_data)) {
DDS_ERROR("Group data policy is inconsistent and caused an error\n"); DDS_ERROR("Group data policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if((qos->present & QP_PARTITION) && !validate_stringseq(&qos->partition)) { if((qos->present & QP_PARTITION) && !validate_stringseq(&qos->partition)) {
DDS_ERROR("Partition policy is inconsistent and caused an error\n"); DDS_ERROR("Partition policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if((qos->present & QP_PRESENTATION) && validate_presentation_qospolicy(&qos->presentation)) { if((qos->present & QP_PRESENTATION) && validate_presentation_qospolicy(&qos->presentation)) {
DDS_ERROR("Presentation policy is inconsistent and caused an error\n"); DDS_ERROR("Presentation policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if((qos->present & QP_PRISMTECH_ENTITY_FACTORY) && !validate_entityfactory_qospolicy(&qos->entity_factory)) { if((qos->present & QP_PRISMTECH_ENTITY_FACTORY) && !validate_entityfactory_qospolicy(&qos->entity_factory)) {
DDS_ERROR("Prismtech entity factory policy is inconsistent and caused an error\n"); DDS_ERROR("Prismtech entity factory policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if(ret == DDS_RETCODE_OK && enabled && (qos->present & QP_PRESENTATION)) { if(ret == DDS_RETCODE_OK && enabled && (qos->present & QP_PRESENTATION)) {
/* TODO: Improve/check immutable check. */ /* TODO: Improve/check immutable check. */
DDS_ERROR("Presentation QoS policy is immutable\n"); DDS_ERROR("Presentation QoS policy is immutable\n");
ret = DDS_ERRNO(DDS_RETCODE_IMMUTABLE_POLICY); ret = DDS_RETCODE_IMMUTABLE_POLICY;
} }
return ret; return ret;
@ -80,7 +79,7 @@ dds_subscriber_qos_set(
if (enabled) { if (enabled) {
/* TODO: CHAM-95: DDSI does not support changing QoS policies. */ /* TODO: CHAM-95: DDSI does not support changing QoS policies. */
DDS_ERROR(DDS_PROJECT_NAME" does not support changing QoS policies yet\n"); DDS_ERROR(DDS_PROJECT_NAME" does not support changing QoS policies yet\n");
ret = DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); ret = DDS_RETCODE_UNSUPPORTED;
} }
} }
return ret; return ret;
@ -94,7 +93,7 @@ dds_subscriber_status_validate(
if (mask & ~(DDS_SUBSCRIBER_STATUS_MASK)) { if (mask & ~(DDS_SUBSCRIBER_STATUS_MASK)) {
DDS_ERROR("Invalid status mask\n"); DDS_ERROR("Invalid status mask\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
} }
return ret; return ret;
@ -146,12 +145,12 @@ dds_create_subscriber(
{ {
dds_entity * par; dds_entity * par;
dds_entity_t hdl; dds_entity_t hdl;
dds_retcode_t errnr; dds_return_t errnr;
errnr = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &par); errnr = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &par);
if (errnr != DDS_RETCODE_OK) { if (errnr != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking participant\n"); DDS_ERROR("Error occurred on locking participant\n");
hdl = DDS_ERRNO(errnr); hdl = errnr;
return hdl; return hdl;
} }
@ -167,14 +166,12 @@ dds_notify_readers(
{ {
dds_entity *iter; dds_entity *iter;
dds_entity *sub; dds_entity *sub;
dds_retcode_t errnr;
dds_return_t ret; dds_return_t ret;
errnr = dds_entity_lock(subscriber, DDS_KIND_SUBSCRIBER, &sub); ret = dds_entity_lock(subscriber, DDS_KIND_SUBSCRIBER, &sub);
if (errnr == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
errnr = DDS_RETCODE_UNSUPPORTED; ret = DDS_RETCODE_UNSUPPORTED;
DDS_ERROR("Unsupported operation\n"); DDS_ERROR("Unsupported operation\n");
ret = DDS_ERRNO(errnr);
iter = sub->m_children; iter = sub->m_children;
while (iter) { while (iter) {
ddsrt_mutex_lock(&iter->m_mutex); ddsrt_mutex_lock(&iter->m_mutex);
@ -185,7 +182,6 @@ dds_notify_readers(
dds_entity_unlock(sub); dds_entity_unlock(sub);
} else { } else {
DDS_ERROR("Error occurred on locking subscriber\n"); DDS_ERROR("Error occurred on locking subscriber\n");
ret = DDS_ERRNO(errnr);
} }
return ret; return ret;
@ -198,7 +194,7 @@ dds_subscriber_begin_coherent(
/* TODO: CHAM-124 Currently unsupported. */ /* TODO: CHAM-124 Currently unsupported. */
(void)e; (void)e;
DDS_ERROR("Using coherency to get a coherent data set is not currently being supported\n"); DDS_ERROR("Using coherency to get a coherent data set is not currently being supported\n");
return DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); return DDS_RETCODE_UNSUPPORTED;
} }
dds_return_t dds_return_t
@ -208,6 +204,6 @@ dds_subscriber_end_coherent(
/* TODO: CHAM-124 Currently unsupported. */ /* TODO: CHAM-124 Currently unsupported. */
(void)e; (void)e;
DDS_ERROR("Using coherency to get a coherent data set is not currently being supported\n"); DDS_ERROR("Using coherency to get a coherent data set is not currently being supported\n");
return DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); return DDS_RETCODE_UNSUPPORTED;
} }

69
src/core/ddsc/src/dds_topic.c
View file

@ -20,7 +20,6 @@
#include "dds__stream.h" #include "dds__stream.h"
#include "dds__init.h" #include "dds__init.h"
#include "dds__domain.h" #include "dds__domain.h"
#include "dds__err.h"
#include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_entity.h"
#include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_thread.h"
#include "dds/ddsi/ddsi_sertopic.h" #include "dds/ddsi/ddsi_sertopic.h"
@ -76,7 +75,7 @@ dds_topic_status_validate(
if (mask & ~(DDS_TOPIC_STATUS_MASK)) { if (mask & ~(DDS_TOPIC_STATUS_MASK)) {
DDS_ERROR("Argument mask is invalid\n"); DDS_ERROR("Argument mask is invalid\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
} }
return ret; return ret;
@ -183,7 +182,7 @@ dds_find_topic(
dds_entity_t tp; dds_entity_t tp;
dds_entity *p = NULL; dds_entity *p = NULL;
struct ddsi_sertopic *st; struct ddsi_sertopic *st;
dds_retcode_t rc; dds_return_t rc;
if (name) { if (name) {
rc = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &p); rc = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &p);
@ -200,16 +199,16 @@ dds_find_topic(
tp = st->status_cb_entity->m_entity.m_hdllink.hdl; tp = st->status_cb_entity->m_entity.m_hdllink.hdl;
} else { } else {
DDS_ERROR("Topic is not being created yet\n"); DDS_ERROR("Topic is not being created yet\n");
tp = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); tp = DDS_RETCODE_PRECONDITION_NOT_MET;
} }
ddsrt_mutex_unlock (&dds_global.m_mutex); ddsrt_mutex_unlock (&dds_global.m_mutex);
dds_entity_unlock(p); dds_entity_unlock(p);
} else { } else {
tp = DDS_ERRNO(rc); tp = rc;
} }
} else { } else {
DDS_ERROR("Argument name is not valid\n"); DDS_ERROR("Argument name is not valid\n");
tp = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); tp = DDS_RETCODE_BAD_PARAMETER;
} }
return tp; return tp;
@ -234,23 +233,23 @@ dds_topic_qos_validate(
/* Check consistency. */ /* Check consistency. */
if (!dds_qos_validate_common(qos)) { if (!dds_qos_validate_common(qos)) {
DDS_ERROR("Argument QoS is not valid\n"); DDS_ERROR("Argument QoS is not valid\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
} }
if ((qos->present & QP_GROUP_DATA) && !validate_octetseq (&qos->group_data)) { if ((qos->present & QP_GROUP_DATA) && !validate_octetseq (&qos->group_data)) {
DDS_ERROR("Group data QoS policy is inconsistent and caused an error\n"); DDS_ERROR("Group data QoS policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if ((qos->present & QP_DURABILITY_SERVICE) && (validate_durability_service_qospolicy(&qos->durability_service) != 0)) { if ((qos->present & QP_DURABILITY_SERVICE) && (validate_durability_service_qospolicy(&qos->durability_service) != 0)) {
DDS_ERROR("Durability service QoS policy is inconsistent and caused an error\n"); DDS_ERROR("Durability service QoS policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if ((qos->present & QP_LIFESPAN) && (validate_duration(&qos->lifespan.duration) != 0)) { if ((qos->present & QP_LIFESPAN) && (validate_duration(&qos->lifespan.duration) != 0)) {
DDS_ERROR("Lifespan QoS policy is inconsistent and caused an error\n"); DDS_ERROR("Lifespan QoS policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if (qos->present & QP_HISTORY && (qos->present & QP_RESOURCE_LIMITS) && (validate_history_and_resource_limits(&qos->history, &qos->resource_limits) != 0)) { if (qos->present & QP_HISTORY && (qos->present & QP_RESOURCE_LIMITS) && (validate_history_and_resource_limits(&qos->history, &qos->resource_limits) != 0)) {
DDS_ERROR("Lifespan QoS policy is inconsistent and caused an error\n"); DDS_ERROR("Lifespan QoS policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if(ret == DDS_RETCODE_OK && enabled){ if(ret == DDS_RETCODE_OK && enabled){
ret = dds_qos_validate_mutable_common(qos); ret = dds_qos_validate_mutable_common(qos);
@ -271,7 +270,7 @@ dds_topic_qos_set(
if (enabled) { if (enabled) {
/* TODO: CHAM-95: DDSI does not support changing QoS policies. */ /* TODO: CHAM-95: DDSI does not support changing QoS policies. */
DDS_ERROR("Changing the topic QoS is not supported\n"); DDS_ERROR("Changing the topic QoS is not supported\n");
ret = DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); ret = DDS_RETCODE_UNSUPPORTED;
} }
} }
return ret; return ret;
@ -310,7 +309,7 @@ dds_create_topic_arbitrary (
const nn_plist_t *sedp_plist) const nn_plist_t *sedp_plist)
{ {
struct ddsi_sertopic *stgeneric; struct ddsi_sertopic *stgeneric;
dds_retcode_t rc; dds_return_t rc;
dds_entity *par; dds_entity *par;
dds_topic *top; dds_topic *top;
dds_qos_t *new_qos = NULL; dds_qos_t *new_qos = NULL;
@ -319,13 +318,13 @@ dds_create_topic_arbitrary (
if (sertopic == NULL){ if (sertopic == NULL){
DDS_ERROR("Topic description is NULL\n"); DDS_ERROR("Topic description is NULL\n");
hdl = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); hdl = DDS_RETCODE_BAD_PARAMETER;
goto bad_param_err; goto bad_param_err;
} }
rc = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &par); rc = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &par);
if (rc != DDS_RETCODE_OK) { if (rc != DDS_RETCODE_OK) {
hdl = DDS_ERRNO(rc); hdl = rc;
goto lock_err; goto lock_err;
} }
@ -345,11 +344,11 @@ dds_create_topic_arbitrary (
if (!sertopic_equivalent (stgeneric, sertopic)) { if (!sertopic_equivalent (stgeneric, sertopic)) {
/* FIXME: should copy the type, perhaps? but then the pointers will no longer be the same */ /* FIXME: should copy the type, perhaps? but then the pointers will no longer be the same */
DDS_ERROR("Create topic with mismatching type\n"); DDS_ERROR("Create topic with mismatching type\n");
hdl = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); hdl = DDS_RETCODE_PRECONDITION_NOT_MET;
} else if (!dupdef_qos_ok(qos, stgeneric)) { } else if (!dupdef_qos_ok(qos, stgeneric)) {
/* FIXME: should copy the type, perhaps? but then the pointers will no longer be the same */ /* FIXME: should copy the type, perhaps? but then the pointers will no longer be the same */
DDS_ERROR("Create topic with mismatching qos\n"); DDS_ERROR("Create topic with mismatching qos\n");
hdl = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); hdl = DDS_RETCODE_INCONSISTENT_POLICY;
} else { } else {
/* FIXME: calling addref is wrong because the Cyclone library has no /* FIXME: calling addref is wrong because the Cyclone library has no
knowledge of the reference and hence simply deleting the participant knowledge of the reference and hence simply deleting the participant
@ -417,19 +416,19 @@ dds_create_topic(
if (desc == NULL){ if (desc == NULL){
DDS_ERROR("Topic description is NULL"); DDS_ERROR("Topic description is NULL");
hdl = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); hdl = DDS_RETCODE_BAD_PARAMETER;
goto bad_param_err; goto bad_param_err;
} }
if (name == NULL) { if (name == NULL) {
DDS_ERROR("Topic name is NULL"); DDS_ERROR("Topic name is NULL");
hdl = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); hdl = DDS_RETCODE_BAD_PARAMETER;
goto bad_param_err; goto bad_param_err;
} }
if (!is_valid_name(name)) { if (!is_valid_name(name)) {
DDS_ERROR("Topic name contains characters that are not allowed."); DDS_ERROR("Topic name contains characters that are not allowed.");
hdl = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); hdl = DDS_RETCODE_BAD_PARAMETER;
goto bad_param_err; goto bad_param_err;
} }
@ -586,27 +585,24 @@ dds_get_name(
{ {
dds_topic *t; dds_topic *t;
dds_return_t ret; dds_return_t ret;
dds_retcode_t rc;
if(size <= 0){ if(size <= 0){
DDS_ERROR("Argument size is smaller than 0\n"); DDS_ERROR("Argument size is smaller than 0\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto fail; goto fail;
} }
if(name == NULL){ if(name == NULL){
DDS_ERROR("Argument name is NULL\n"); DDS_ERROR("Argument name is NULL\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto fail; goto fail;
} }
name[0] = '\0'; name[0] = '\0';
rc = dds_topic_lock(topic, &t); ret = dds_topic_lock(topic, &t);
if (rc == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
(void)snprintf(name, size, "%s", t->m_stopic->name); (void)snprintf(name, size, "%s", t->m_stopic->name);
dds_topic_unlock(t); dds_topic_unlock(t);
ret = DDS_RETCODE_OK;
} else { } else {
DDS_ERROR("Error occurred on locking topic\n"); DDS_ERROR("Error occurred on locking topic\n");
ret = DDS_ERRNO(rc);
goto fail; goto fail;
} }
fail: fail:
@ -620,29 +616,26 @@ dds_get_type_name(
size_t size) size_t size)
{ {
dds_topic *t; dds_topic *t;
dds_retcode_t rc;
dds_return_t ret; dds_return_t ret;
if(size <= 0){ if(size <= 0){
DDS_ERROR("Argument size is smaller than 0\n"); DDS_ERROR("Argument size is smaller than 0\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto fail; goto fail;
} }
if(name == NULL){ if(name == NULL){
DDS_ERROR("Argument name is NULL\n"); DDS_ERROR("Argument name is NULL\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
goto fail; goto fail;
} }
name[0] = '\0'; name[0] = '\0';
rc = dds_topic_lock(topic, &t); ret = dds_topic_lock(topic, &t);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking topic\n"); DDS_ERROR("Error occurred on locking topic\n");
ret = DDS_ERRNO(rc);
goto fail; goto fail;
} }
(void)snprintf(name, size, "%s", t->m_stopic->type_name); (void)snprintf(name, size, "%s", t->m_stopic->type_name);
dds_topic_unlock(t); dds_topic_unlock(t);
ret = DDS_RETCODE_OK;
fail: fail:
return ret; return ret;
} }
@ -652,14 +645,12 @@ dds_get_inconsistent_topic_status(
dds_entity_t topic, dds_entity_t topic,
dds_inconsistent_topic_status_t *status) dds_inconsistent_topic_status_t *status)
{ {
dds_retcode_t rc;
dds_topic *t; dds_topic *t;
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret;
rc = dds_topic_lock(topic, &t); ret = dds_topic_lock(topic, &t);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking topic\n"); DDS_ERROR("Error occurred on locking topic\n");
ret = DDS_ERRNO(rc);
goto fail; goto fail;
} }
/* status = NULL, application do not need the status, but reset the counter & triggered bit */ /* status = NULL, application do not need the status, but reset the counter & triggered bit */

79
src/core/ddsc/src/dds_waitset.c
View file

@ -17,7 +17,6 @@
#include "dds__querycond.h" #include "dds__querycond.h"
#include "dds__readcond.h" #include "dds__readcond.h"
#include "dds__rhc.h" #include "dds__rhc.h"
#include "dds__err.h"
DEFINE_ENTITY_LOCK_UNLOCK(static, dds_waitset, DDS_KIND_WAITSET) DEFINE_ENTITY_LOCK_UNLOCK(static, dds_waitset, DDS_KIND_WAITSET)
@ -50,24 +49,23 @@ dds_waitset_wait_impl(
{ {
dds_waitset *ws; dds_waitset *ws;
dds_return_t ret; dds_return_t ret;
dds_retcode_t rc;
dds_attachment *idx; dds_attachment *idx;
dds_attachment *next; dds_attachment *next;
dds_attachment *prev; dds_attachment *prev;
if ((xs == NULL) && (nxs != 0)){ if ((xs == NULL) && (nxs != 0)){
DDS_ERROR("A size was given, but no array\n"); DDS_ERROR("A size was given, but no array\n");
return DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
} }
if ((xs != NULL) && (nxs == 0)){ if ((xs != NULL) && (nxs == 0)){
DDS_ERROR("Array is given with an invalid size\n"); DDS_ERROR("Array is given with an invalid size\n");
return DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
} }
/* Locking the waitset here will delay a possible deletion until it is /* Locking the waitset here will delay a possible deletion until it is
* unlocked. Even when the related mutex is unlocked by a conditioned wait. */ * unlocked. Even when the related mutex is unlocked by a conditioned wait. */
rc = dds_waitset_lock(waitset, &ws); ret = dds_waitset_lock(waitset, &ws);
if (rc == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
/* Check if any of any previous triggered entities has changed there status /* Check if any of any previous triggered entities has changed there status
* and thus it trigger value could be false now. */ * and thus it trigger value could be false now. */
idx = ws->triggered; idx = ws->triggered;
@ -97,12 +95,11 @@ dds_waitset_wait_impl(
} }
/* Only wait/keep waiting when whe have something to observer and there aren't any triggers yet. */ /* Only wait/keep waiting when whe have something to observer and there aren't any triggers yet. */
rc = DDS_RETCODE_OK; while ((ws->observed != NULL) && (ws->triggered == NULL) && (ret == DDS_RETCODE_OK)) {
while ((ws->observed != NULL) && (ws->triggered == NULL) && (rc == DDS_RETCODE_OK)) {
if (abstimeout == DDS_NEVER) { if (abstimeout == DDS_NEVER) {
ddsrt_cond_wait(&ws->m_entity.m_cond, &ws->m_entity.m_mutex); ddsrt_cond_wait(&ws->m_entity.m_cond, &ws->m_entity.m_mutex);
} else if (abstimeout <= tnow) { } else if (abstimeout <= tnow) {
rc = DDS_RETCODE_TIMEOUT; ret = DDS_RETCODE_TIMEOUT;
} else { } else {
dds_duration_t dt = abstimeout - tnow; dds_duration_t dt = abstimeout - tnow;
(void)ddsrt_cond_waitfor(&ws->m_entity.m_cond, &ws->m_entity.m_mutex, dt); (void)ddsrt_cond_waitfor(&ws->m_entity.m_cond, &ws->m_entity.m_mutex, dt);
@ -113,7 +110,7 @@ dds_waitset_wait_impl(
/* Get number of triggered entities /* Get number of triggered entities
* - set attach array when needed * - set attach array when needed
* - swap them back to observed */ * - swap them back to observed */
if (rc == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
ret = 0; ret = 0;
idx = ws->triggered; idx = ws->triggered;
while (idx != NULL) { while (idx != NULL) {
@ -127,17 +124,15 @@ dds_waitset_wait_impl(
dds_waitset_swap(&(ws->observed), &(ws->triggered), NULL, idx); dds_waitset_swap(&(ws->observed), &(ws->triggered), NULL, idx);
idx = next; idx = next;
} }
} else if (rc == DDS_RETCODE_TIMEOUT) { } else if (ret == DDS_RETCODE_TIMEOUT) {
ret = 0; ret = 0;
} else { } else {
DDS_ERROR("Internal error"); DDS_ERROR("Internal error");
ret = DDS_ERRNO(rc);
} }
dds_waitset_unlock(ws); dds_waitset_unlock(ws);
} else { } else {
DDS_ERROR("Error occurred on locking waitset\n"); DDS_ERROR("Error occurred on locking waitset\n");
ret = DDS_ERRNO(rc);
} }
return ret; return ret;
@ -206,7 +201,7 @@ dds_create_waitset(
{ {
dds_entity_t hdl; dds_entity_t hdl;
dds_entity *par; dds_entity *par;
dds_retcode_t rc; dds_return_t rc;
rc = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &par); rc = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &par);
if (rc == DDS_RETCODE_OK) { if (rc == DDS_RETCODE_OK) {
@ -217,7 +212,7 @@ dds_create_waitset(
waitset->triggered = NULL; waitset->triggered = NULL;
dds_entity_unlock(par); dds_entity_unlock(par);
} else { } else {
hdl = DDS_ERRNO(rc); hdl = rc;
} }
return hdl; return hdl;
@ -230,14 +225,14 @@ dds_waitset_get_entities(
dds_entity_t *entities, dds_entity_t *entities,
size_t size) size_t size)
{ {
dds_return_t ret = 0; dds_return_t ret;
dds_retcode_t rc;
dds_waitset *ws; dds_waitset *ws;
rc = dds_waitset_lock(waitset, &ws); ret = dds_waitset_lock(waitset, &ws);
if (rc == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
dds_attachment* iter; dds_attachment* iter;
ret = 0;
iter = ws->observed; iter = ws->observed;
while (iter) { while (iter) {
if (((size_t)ret < size) && (entities != NULL)) { if (((size_t)ret < size) && (entities != NULL)) {
@ -258,7 +253,6 @@ dds_waitset_get_entities(
dds_waitset_unlock(ws); dds_waitset_unlock(ws);
} else { } else {
DDS_ERROR("Error occurred on locking waitset\n"); DDS_ERROR("Error occurred on locking waitset\n");
ret = DDS_ERRNO(rc);
} }
return ret; return ret;
@ -330,14 +324,13 @@ dds_waitset_attach(
{ {
dds_entity *e = NULL; dds_entity *e = NULL;
dds_waitset *ws; dds_waitset *ws;
dds_retcode_t rc;
dds_return_t ret; dds_return_t ret;
rc = dds_waitset_lock(waitset, &ws); ret = dds_waitset_lock(waitset, &ws);
if (rc == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
if (waitset != entity) { if (waitset != entity) {
rc = dds_entity_lock(entity, DDS_KIND_DONTCARE, &e); ret = dds_entity_lock(entity, DDS_KIND_DONTCARE, &e);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
e = NULL; e = NULL;
} }
} else { } else {
@ -345,11 +338,11 @@ dds_waitset_attach(
} }
/* This will fail if given entity is already attached (or deleted). */ /* This will fail if given entity is already attached (or deleted). */
if (rc == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
rc = dds_entity_observer_register_nl(e, waitset, dds_waitset_observer); ret = dds_entity_observer_register_nl(e, waitset, dds_waitset_observer);
} }
if (rc == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
dds_attachment *a = ddsrt_malloc(sizeof(dds_attachment)); dds_attachment *a = ddsrt_malloc(sizeof(dds_attachment));
a->arg = x; a->arg = x;
a->entity = e; a->entity = e;
@ -361,12 +354,11 @@ dds_waitset_attach(
ws->observed = a; ws->observed = a;
} }
ret = DDS_RETCODE_OK; ret = DDS_RETCODE_OK;
} else if (rc != DDS_RETCODE_PRECONDITION_NOT_MET) { } else if (ret != DDS_RETCODE_PRECONDITION_NOT_MET) {
DDS_ERROR("Entity is not valid\n"); DDS_ERROR("Entity is not valid\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
} else { } else {
DDS_ERROR("Entity is already attached\n"); DDS_ERROR("Entity is already attached\n");
ret = DDS_ERRNO(rc);
} }
if ((e != NULL) && (waitset != entity)) { if ((e != NULL) && (waitset != entity)) {
dds_entity_unlock(e); dds_entity_unlock(e);
@ -374,7 +366,6 @@ dds_waitset_attach(
dds_waitset_unlock(ws); dds_waitset_unlock(ws);
} else { } else {
DDS_ERROR("Error occurred on locking waitset\n"); DDS_ERROR("Error occurred on locking waitset\n");
ret = DDS_ERRNO(rc);
} }
return ret; return ret;
@ -386,31 +377,27 @@ dds_waitset_detach(
dds_entity_t entity) dds_entity_t entity)
{ {
dds_waitset *ws; dds_waitset *ws;
dds_retcode_t rc;
dds_return_t ret; dds_return_t ret;
rc = dds_waitset_lock(waitset, &ws); ret = dds_waitset_lock(waitset, &ws);
if (rc == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
/* Possibly fails when entity was not attached. */ /* Possibly fails when entity was not attached. */
if (waitset == entity) { if (waitset == entity) {
rc = dds_entity_observer_unregister_nl(&ws->m_entity, waitset); ret = dds_entity_observer_unregister_nl(&ws->m_entity, waitset);
} else { } else {
rc = dds_entity_observer_unregister(entity, waitset); ret = dds_entity_observer_unregister(entity, waitset);
} }
if (rc == DDS_RETCODE_OK) { if (ret == DDS_RETCODE_OK) {
dds_waitset_remove(ws, entity); dds_waitset_remove(ws, entity);
ret = DDS_RETCODE_OK; } else if (ret != DDS_RETCODE_PRECONDITION_NOT_MET) {
} else if (rc != DDS_RETCODE_PRECONDITION_NOT_MET) {
DDS_ERROR("The given entity to detach is invalid\n"); DDS_ERROR("The given entity to detach is invalid\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
} else { } else {
DDS_ERROR("The given entity to detach was not attached previously\n"); DDS_ERROR("The given entity to detach was not attached previously\n");
ret = DDS_ERRNO(rc);
} }
dds_waitset_unlock(ws); dds_waitset_unlock(ws);
} else { } else {
DDS_ERROR("Error occurred on locking waitset\n"); DDS_ERROR("Error occurred on locking waitset\n");
ret = DDS_ERRNO(rc);
} }
return ret; return ret;
@ -441,7 +428,7 @@ dds_waitset_wait(
ret = dds_waitset_wait_impl(waitset, xs, nxs, abstimeout, tnow); ret = dds_waitset_wait_impl(waitset, xs, nxs, abstimeout, tnow);
} else{ } else{
DDS_ERROR("Negative timeout\n"); DDS_ERROR("Negative timeout\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
} }
return ret; return ret;
@ -450,10 +437,10 @@ dds_waitset_wait(
dds_return_t dds_waitset_set_trigger (dds_entity_t waitset, bool trigger) dds_return_t dds_waitset_set_trigger (dds_entity_t waitset, bool trigger)
{ {
dds_waitset *ws; dds_waitset *ws;
dds_retcode_t rc; dds_return_t rc;
if ((rc = dds_waitset_lock (waitset, &ws)) != DDS_RETCODE_OK) if ((rc = dds_waitset_lock (waitset, &ws)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return rc;
ddsrt_mutex_unlock (&ws->m_entity.m_mutex); ddsrt_mutex_unlock (&ws->m_entity.m_mutex);

49
src/core/ddsc/src/dds_write.c
View file

@ -14,12 +14,10 @@
#include "dds__writer.h" #include "dds__writer.h"
#include "dds__write.h" #include "dds__write.h"
#include "dds/ddsi/ddsi_tkmap.h" #include "dds/ddsi/ddsi_tkmap.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_thread.h"
#include "dds/ddsi/q_xmsg.h" #include "dds/ddsi/q_xmsg.h"
#include "dds/ddsi/ddsi_serdata.h" #include "dds/ddsi/ddsi_serdata.h"
#include "dds__stream.h" #include "dds__stream.h"
#include "dds__err.h"
#include "dds/ddsi/q_transmit.h" #include "dds/ddsi/q_transmit.h"
#include "dds/ddsi/q_ephash.h" #include "dds/ddsi/q_ephash.h"
#include "dds/ddsi/q_config.h" #include "dds/ddsi/q_config.h"
@ -29,14 +27,13 @@
dds_return_t dds_write (dds_entity_t writer, const void *data) dds_return_t dds_write (dds_entity_t writer, const void *data)
{ {
dds_return_t ret; dds_return_t ret;
dds_retcode_t rc;
dds_writer *wr; dds_writer *wr;
if (data == NULL) if (data == NULL)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
if ((rc = dds_writer_lock (writer, &wr)) != DDS_RETCODE_OK) if ((ret = dds_writer_lock (writer, &wr)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return ret;
ret = dds_write_impl (wr, data, dds_time (), 0); ret = dds_write_impl (wr, data, dds_time (), 0);
dds_writer_unlock (wr); dds_writer_unlock (wr);
return ret; return ret;
@ -45,14 +42,13 @@ dds_return_t dds_write (dds_entity_t writer, const void *data)
dds_return_t dds_writecdr (dds_entity_t writer, struct ddsi_serdata *serdata) dds_return_t dds_writecdr (dds_entity_t writer, struct ddsi_serdata *serdata)
{ {
dds_return_t ret; dds_return_t ret;
dds_retcode_t rc;
dds_writer *wr; dds_writer *wr;
if (serdata == NULL) if (serdata == NULL)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
if ((rc = dds_writer_lock (writer, &wr)) != DDS_RETCODE_OK) if ((ret = dds_writer_lock (writer, &wr)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return ret;
ret = dds_writecdr_impl (wr, serdata, dds_time (), 0); ret = dds_writecdr_impl (wr, serdata, dds_time (), 0);
dds_writer_unlock (wr); dds_writer_unlock (wr);
return ret; return ret;
@ -61,14 +57,13 @@ dds_return_t dds_writecdr (dds_entity_t writer, struct ddsi_serdata *serdata)
dds_return_t dds_write_ts (dds_entity_t writer, const void *data, dds_time_t timestamp) dds_return_t dds_write_ts (dds_entity_t writer, const void *data, dds_time_t timestamp)
{ {
dds_return_t ret; dds_return_t ret;
dds_retcode_t rc;
dds_writer *wr; dds_writer *wr;
if (data == NULL || timestamp < 0) if (data == NULL || timestamp < 0)
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
if ((rc = dds_writer_lock (writer, &wr)) != DDS_RETCODE_OK) if ((ret = dds_writer_lock (writer, &wr)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return ret;
ret = dds_write_impl (wr, data, timestamp, 0); ret = dds_write_impl (wr, data, timestamp, 0);
dds_writer_unlock (wr); dds_writer_unlock (wr);
return ret; return ret;
@ -86,7 +81,7 @@ static dds_return_t try_store (struct rhc *rhc, const struct proxy_writer_info *
else else
{ {
DDS_ERROR ("The writer could not deliver data on time, probably due to a local reader resources being full\n"); DDS_ERROR ("The writer could not deliver data on time, probably due to a local reader resources being full\n");
return DDS_ERRNO (DDS_RETCODE_TIMEOUT); return DDS_RETCODE_TIMEOUT;
} }
} }
return DDS_RETCODE_OK; return DDS_RETCODE_OK;
@ -159,7 +154,7 @@ dds_return_t dds_write_impl (dds_writer *wr, const void * data, dds_time_t tstam
if (data == NULL) if (data == NULL)
{ {
DDS_ERROR("No data buffer provided\n"); DDS_ERROR("No data buffer provided\n");
return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); return DDS_RETCODE_BAD_PARAMETER;
} }
/* Check for topic filter */ /* Check for topic filter */
@ -183,15 +178,15 @@ dds_return_t dds_write_impl (dds_writer *wr, const void * data, dds_time_t tstam
if (!config.whc_batch) if (!config.whc_batch)
nn_xpack_send (wr->m_xp, false); nn_xpack_send (wr->m_xp, false);
ret = DDS_RETCODE_OK; ret = DDS_RETCODE_OK;
} else if (w_rc == Q_ERR_TIMEOUT) { } else if (w_rc == DDS_RETCODE_TIMEOUT) {
DDS_ERROR ("The writer could not deliver data on time, probably due to a reader resources being full\n"); DDS_ERROR ("The writer could not deliver data on time, probably due to a reader resources being full\n");
ret = DDS_ERRNO (DDS_RETCODE_TIMEOUT); ret = DDS_RETCODE_TIMEOUT;
} else if (w_rc == Q_ERR_INVALID_DATA) { } else if (w_rc == DDS_RETCODE_BAD_PARAMETER) {
DDS_ERROR ("Invalid data provided\n"); DDS_ERROR ("Invalid data provided\n");
ret = DDS_ERRNO (DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
} else { } else {
DDS_ERROR ("Internal error\n"); DDS_ERROR ("Internal error\n");
ret = DDS_ERRNO (DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
} }
if (ret == DDS_RETCODE_OK) if (ret == DDS_RETCODE_OK)
ret = deliver_locally (ddsi_wr, d, tk); ret = deliver_locally (ddsi_wr, d, tk);
@ -217,15 +212,15 @@ dds_return_t dds_writecdr_impl_lowlevel (struct writer *ddsi_wr, struct nn_xpack
if (!config.whc_batch && xp != NULL) if (!config.whc_batch && xp != NULL)
nn_xpack_send (xp, false); nn_xpack_send (xp, false);
ret = DDS_RETCODE_OK; ret = DDS_RETCODE_OK;
} else if (w_rc == Q_ERR_TIMEOUT) { } else if (w_rc == DDS_RETCODE_TIMEOUT) {
DDS_ERROR ("The writer could not deliver data on time, probably due to a reader resources being full\n"); DDS_ERROR ("The writer could not deliver data on time, probably due to a reader resources being full\n");
ret = DDS_ERRNO(DDS_RETCODE_TIMEOUT); ret = DDS_RETCODE_TIMEOUT;
} else if (w_rc == Q_ERR_INVALID_DATA) { } else if (w_rc == DDS_RETCODE_BAD_PARAMETER) {
DDS_ERROR ("Invalid data provided\n"); DDS_ERROR ("Invalid data provided\n");
ret = DDS_ERRNO (DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
} else { } else {
DDS_ERROR ("Internal error\n"); DDS_ERROR ("Internal error\n");
ret = DDS_ERRNO (DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
} }
if (ret == DDS_RETCODE_OK) if (ret == DDS_RETCODE_OK)
@ -255,7 +250,7 @@ void dds_write_flush (dds_entity_t writer)
{ {
struct thread_state1 * const ts1 = lookup_thread_state (); struct thread_state1 * const ts1 = lookup_thread_state ();
dds_writer *wr; dds_writer *wr;
dds_retcode_t rc; dds_return_t rc;
thread_state_awake (ts1); thread_state_awake (ts1);
if ((rc = dds_writer_lock (writer, &wr)) != DDS_RETCODE_OK) if ((rc = dds_writer_lock (writer, &wr)) != DDS_RETCODE_OK)
DDS_ERROR ("Error occurred on locking writer\n"); DDS_ERROR ("Error occurred on locking writer\n");

67
src/core/ddsc/src/dds_writer.c
View file

@ -21,7 +21,6 @@
#include "dds__writer.h" #include "dds__writer.h"
#include "dds__listener.h" #include "dds__listener.h"
#include "dds__qos.h" #include "dds__qos.h"
#include "dds__err.h"
#include "dds__init.h" #include "dds__init.h"
#include "dds__publisher.h" #include "dds__publisher.h"
#include "dds__topic.h" #include "dds__topic.h"
@ -55,7 +54,7 @@ dds_writer_status_validate(
if (mask & ~(DDS_WRITER_STATUS_MASK)) { if (mask & ~(DDS_WRITER_STATUS_MASK)) {
DDS_ERROR("Invalid status mask\n"); DDS_ERROR("Invalid status mask\n");
ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); ret = DDS_RETCODE_BAD_PARAMETER;
} }
return ret; return ret;
@ -200,7 +199,7 @@ dds_writer_close(
nn_xpack_send (wr->m_xp, false); nn_xpack_send (wr->m_xp, false);
if (delete_writer (&e->m_guid) != 0) { if (delete_writer (&e->m_guid) != 0) {
DDS_ERROR("Internal error"); DDS_ERROR("Internal error");
ret = DDS_ERRNO(DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
} }
thread_state_asleep (lookup_thread_state ()); thread_state_asleep (lookup_thread_state ());
return ret; return ret;
@ -219,7 +218,7 @@ dds_writer_delete(
ret = dds_delete(wr->m_topic->m_entity.m_hdllink.hdl); ret = dds_delete(wr->m_topic->m_entity.m_hdllink.hdl);
if(ret == DDS_RETCODE_OK){ if(ret == DDS_RETCODE_OK){
ret = dds_delete_impl(e->m_parent->m_hdllink.hdl, true); ret = dds_delete_impl(e->m_parent->m_hdllink.hdl, true);
if(dds_err_nr(ret) == DDS_RETCODE_BAD_PARAMETER){ if(ret == DDS_RETCODE_BAD_PARAMETER){
ret = DDS_RETCODE_OK; ret = DDS_RETCODE_OK;
} }
} }
@ -239,23 +238,23 @@ dds_writer_qos_validate(
/* Check consistency. */ /* Check consistency. */
if(dds_qos_validate_common(qos) != true){ if(dds_qos_validate_common(qos) != true){
DDS_ERROR("Provided inconsistent QoS policy\n"); DDS_ERROR("Provided inconsistent QoS policy\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if((qos->present & QP_USER_DATA) && validate_octetseq(&qos->user_data) != true){ if((qos->present & QP_USER_DATA) && validate_octetseq(&qos->user_data) != true){
DDS_ERROR("User Data QoS policy is inconsistent and caused an error\n"); DDS_ERROR("User Data QoS policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if ((qos->present & QP_DURABILITY_SERVICE) && validate_durability_service_qospolicy(&qos->durability_service) != 0){ if ((qos->present & QP_DURABILITY_SERVICE) && validate_durability_service_qospolicy(&qos->durability_service) != 0){
DDS_ERROR("Durability service QoS policy is inconsistent and caused an error\n"); DDS_ERROR("Durability service QoS policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if ((qos->present & QP_LIFESPAN) && validate_duration(&qos->lifespan.duration) != 0){ if ((qos->present & QP_LIFESPAN) && validate_duration(&qos->lifespan.duration) != 0){
DDS_ERROR("Lifespan QoS policy is inconsistent and caused an error\n"); DDS_ERROR("Lifespan QoS policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if ((qos->present & QP_HISTORY) && (qos->present & QP_RESOURCE_LIMITS) && (validate_history_and_resource_limits(&qos->history, &qos->resource_limits) != 0)){ if ((qos->present & QP_HISTORY) && (qos->present & QP_RESOURCE_LIMITS) && (validate_history_and_resource_limits(&qos->history, &qos->resource_limits) != 0)){
DDS_ERROR("Resource limits QoS policy is inconsistent and caused an error\n"); DDS_ERROR("Resource limits QoS policy is inconsistent and caused an error\n");
ret = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); ret = DDS_RETCODE_INCONSISTENT_POLICY;
} }
if(ret == DDS_RETCODE_OK && enabled) { if(ret == DDS_RETCODE_OK && enabled) {
ret = dds_qos_validate_mutable_common(qos); ret = dds_qos_validate_mutable_common(qos);
@ -299,12 +298,12 @@ dds_writer_qos_set(
thread_state_asleep (lookup_thread_state ()); thread_state_asleep (lookup_thread_state ());
} else { } else {
DDS_ERROR("Setting ownership strength doesn't make sense when the ownership is shared\n"); DDS_ERROR("Setting ownership strength doesn't make sense when the ownership is shared\n");
ret = DDS_ERRNO(DDS_RETCODE_ERROR); ret = DDS_RETCODE_ERROR;
} }
} else { } else {
if (enabled) { if (enabled) {
DDS_ERROR(DDS_PROJECT_NAME" does not support changing QoS policies yet\n"); DDS_ERROR(DDS_PROJECT_NAME" does not support changing QoS policies yet\n");
ret = DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); ret = DDS_RETCODE_UNSUPPORTED;
} }
} }
} }
@ -342,7 +341,7 @@ dds_create_writer(
const dds_qos_t *qos, const dds_qos_t *qos,
const dds_listener_t *listener) const dds_listener_t *listener)
{ {
dds_retcode_t rc; dds_return_t rc;
dds_qos_t * wqos; dds_qos_t * wqos;
dds_writer * wr; dds_writer * wr;
dds_entity_t writer; dds_entity_t writer;
@ -355,7 +354,7 @@ dds_create_writer(
{ {
dds_entity *p_or_p; dds_entity *p_or_p;
if ((rc = dds_entity_claim (participant_or_publisher, &p_or_p)) != DDS_RETCODE_OK) { if ((rc = dds_entity_claim (participant_or_publisher, &p_or_p)) != DDS_RETCODE_OK) {
return DDS_ERRNO (rc); return rc;
} }
if (dds_entity_kind (p_or_p) == DDS_KIND_PARTICIPANT) { if (dds_entity_kind (p_or_p) == DDS_KIND_PARTICIPANT) {
publisher = dds_create_publisher(participant_or_publisher, qos, NULL); publisher = dds_create_publisher(participant_or_publisher, qos, NULL);
@ -366,7 +365,7 @@ dds_create_writer(
} }
if ((rc = dds_publisher_lock(publisher, &pub)) != DDS_RETCODE_OK) { if ((rc = dds_publisher_lock(publisher, &pub)) != DDS_RETCODE_OK) {
writer = DDS_ERRNO(rc); writer = rc;
goto err_pub_lock; goto err_pub_lock;
} }
@ -377,7 +376,7 @@ dds_create_writer(
rc = dds_topic_lock(topic, &tp); rc = dds_topic_lock(topic, &tp);
if (rc != DDS_RETCODE_OK) { if (rc != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking topic\n"); DDS_ERROR("Error occurred on locking topic\n");
writer = DDS_ERRNO(rc); writer = rc;
goto err_tp_lock; goto err_tp_lock;
} }
assert(tp->m_stopic); assert(tp->m_stopic);
@ -455,14 +454,14 @@ dds_get_publisher(
dds_entity_t writer) dds_entity_t writer)
{ {
dds_entity *e; dds_entity *e;
dds_retcode_t rc; dds_return_t rc;
if ((rc = dds_entity_claim (writer, &e)) != DDS_RETCODE_OK) if ((rc = dds_entity_claim (writer, &e)) != DDS_RETCODE_OK)
return DDS_ERRNO (rc); return rc;
else else
{ {
dds_entity_t pubh; dds_entity_t pubh;
if (dds_entity_kind (e) != DDS_KIND_WRITER) if (dds_entity_kind (e) != DDS_KIND_WRITER)
pubh = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); pubh = DDS_RETCODE_ILLEGAL_OPERATION;
else else
{ {
assert (dds_entity_kind (e->m_parent) == DDS_KIND_PUBLISHER); assert (dds_entity_kind (e->m_parent) == DDS_KIND_PUBLISHER);
@ -478,14 +477,12 @@ dds_get_publication_matched_status (
dds_entity_t writer, dds_entity_t writer,
dds_publication_matched_status_t * status) dds_publication_matched_status_t * status)
{ {
dds_retcode_t rc;
dds_writer *wr; dds_writer *wr;
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret;
rc = dds_writer_lock(writer, &wr); ret = dds_writer_lock(writer, &wr);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking writer\n"); DDS_ERROR("Error occurred on locking writer\n");
ret = DDS_ERRNO(rc);
goto fail; goto fail;
} }
/* status = NULL, application do not need the status, but reset the counter & triggered bit */ /* status = NULL, application do not need the status, but reset the counter & triggered bit */
@ -509,14 +506,12 @@ dds_get_liveliness_lost_status (
dds_entity_t writer, dds_entity_t writer,
dds_liveliness_lost_status_t * status) dds_liveliness_lost_status_t * status)
{ {
dds_retcode_t rc;
dds_writer *wr; dds_writer *wr;
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret;
rc = dds_writer_lock(writer, &wr); ret = dds_writer_lock(writer, &wr);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking writer\n"); DDS_ERROR("Error occurred on locking writer\n");
ret = DDS_ERRNO(rc);
goto fail; goto fail;
} }
/* status = NULL, application do not need the status, but reset the counter & triggered bit */ /* status = NULL, application do not need the status, but reset the counter & triggered bit */
@ -539,14 +534,12 @@ dds_get_offered_deadline_missed_status(
dds_entity_t writer, dds_entity_t writer,
dds_offered_deadline_missed_status_t *status) dds_offered_deadline_missed_status_t *status)
{ {
dds_retcode_t rc;
dds_writer *wr; dds_writer *wr;
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret;
rc = dds_writer_lock(writer, &wr); ret = dds_writer_lock(writer, &wr);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking writer\n"); DDS_ERROR("Error occurred on locking writer\n");
ret = DDS_ERRNO(rc);
goto fail; goto fail;
} }
/* status = NULL, application do not need the status, but reset the counter & triggered bit */ /* status = NULL, application do not need the status, but reset the counter & triggered bit */
@ -569,14 +562,12 @@ dds_get_offered_incompatible_qos_status (
dds_entity_t writer, dds_entity_t writer,
dds_offered_incompatible_qos_status_t * status) dds_offered_incompatible_qos_status_t * status)
{ {
dds_retcode_t rc;
dds_writer *wr; dds_writer *wr;
dds_return_t ret = DDS_RETCODE_OK; dds_return_t ret;
rc = dds_writer_lock(writer, &wr); ret = dds_writer_lock(writer, &wr);
if (rc != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
DDS_ERROR("Error occurred on locking writer\n"); DDS_ERROR("Error occurred on locking writer\n");
ret = DDS_ERRNO(rc);
goto fail; goto fail;
} }
/* status = NULL, application do not need the status, but reset the counter & triggered bit */ /* status = NULL, application do not need the status, but reset the counter & triggered bit */

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

@ -49,7 +49,7 @@ static void config__check_env(
} }
if ( !env_ok ) { if ( !env_ok ) {
dds_retcode_t r; dds_return_t r;
r = ddsrt_setenv(env_variable, expected_value); r = ddsrt_setenv(env_variable, expected_value);
CU_ASSERT_EQUAL_FATAL(r, DDS_RETCODE_OK); 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose(g_writer, NULL); ret = dds_writedispose(g_writer, NULL);
DDSRT_WARNING_MSVC_ON(6387); 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose(g_writer, NULL); ret = dds_writedispose(g_writer, NULL);
DDSRT_WARNING_MSVC_ON(6387); 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) 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; dds_return_t ret;
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose(writer, NULL); ret = dds_writedispose(writer, NULL);
DDSRT_WARNING_MSVC_ON(6387); 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose(*writer, NULL); ret = dds_writedispose(*writer, NULL);
DDSRT_WARNING_MSVC_ON(6387); 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); ret = dds_writedispose(g_writer, &newInstance1);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_writedispose(g_writer, &newInstance2); 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose_ts(g_writer, NULL, g_present); ret = dds_writedispose_ts(g_writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387); 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose_ts(g_writer, NULL, g_present); ret = dds_writedispose_ts(g_writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387); 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); ret = dds_writedispose_ts(g_writer, &newInstance1, g_present);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_writedispose_ts(g_writer, &newInstance2, g_present); 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) 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; dds_return_t ret;
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose_ts(writer, NULL, g_present); ret = dds_writedispose_ts(writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387); 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_writedispose_ts(*writer, NULL, g_present); ret = dds_writedispose_ts(*writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387); 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose(g_writer, NULL); ret = dds_dispose(g_writer, NULL);
DDSRT_WARNING_MSVC_ON(6387); 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose(g_writer, NULL); ret = dds_dispose(g_writer, NULL);
DDSRT_WARNING_MSVC_ON(6387); 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); ret = dds_dispose(g_writer, &newInstance1);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_dispose(g_writer, &newInstance2); 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) 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; dds_return_t ret;
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose(writer, NULL); ret = dds_dispose(writer, NULL);
DDSRT_WARNING_MSVC_ON(6387); 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose(*writer, NULL); ret = dds_dispose(*writer, NULL);
DDSRT_WARNING_MSVC_ON(6387); 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose_ts(g_writer, NULL, g_present); ret = dds_dispose_ts(g_writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387); /* Disable SAL warning on intentional misuse of the API */ 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose_ts(g_writer, NULL, g_present); ret = dds_dispose_ts(g_writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387); 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); ret = dds_dispose_ts(g_writer, &newInstance1, g_present);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_dispose_ts(g_writer, &newInstance2, g_present); 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) 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; dds_return_t ret;
DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose_ts(writer, NULL, g_present); ret = dds_dispose_ts(writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387); 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_dispose_ts(*writer, NULL, g_present); ret = dds_dispose_ts(*writer, NULL, g_present);
DDSRT_WARNING_MSVC_ON(6387); 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_return_t ret;
dds_delete(g_writer); dds_delete(g_writer);
ret = dds_dispose_ih(g_writer, DDS_HANDLE_NIL); 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; dds_return_t ret;
ret = dds_dispose_ih(g_writer, handle); 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) 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; dds_return_t ret;
ret = dds_dispose_ih(writer, DDS_HANDLE_NIL); 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; dds_return_t ret;
ret = dds_dispose_ih(*writer, DDS_HANDLE_NIL); 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_return_t ret;
dds_delete(g_writer); dds_delete(g_writer);
ret = dds_dispose_ih_ts(g_writer, DDS_HANDLE_NIL, g_present); 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; dds_return_t ret;
ret = dds_dispose_ih_ts(g_writer, handle, g_present); 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) 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; dds_return_t ret;
ret = dds_dispose_ih_ts(writer, DDS_HANDLE_NIL, g_present); 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; dds_return_t ret;
ret = dds_dispose_ih_ts(*writer, DDS_HANDLE_NIL, g_present); 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; 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 */ /* Fixture to create prerequisite entity */
void create_entity(void) void create_entity(void)
{ {
@ -38,7 +36,7 @@ void delete_entity(void)
{ {
CU_ASSERT_FATAL(entity > 0); CU_ASSERT_FATAL(entity > 0);
dds_return_t ret = dds_delete(entity); 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; entity = -1;
} }
@ -55,17 +53,17 @@ CU_Test(ddsc_entity, enable, .init = create_entity, .fini = delete_entity)
/* Check enabling with bad parameters. */ /* Check enabling with bad parameters. */
status = dds_enable(0); 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. */ /* Check actual enabling. */
/* TODO: CHAM-96: Check enabling. /* TODO: CHAM-96: Check enabling.
status = dds_enable(&entity); 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). */ /* Check re-enabling (should be a noop). */
status = dds_enable(entity); 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) 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. */ /* Get QoS. */
status = dds_get_qos (e, 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*/ 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); 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. */ /* Check getting QoS with bad parameters. */
status = dds_get_qos (0, NULL); 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); 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); 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. */ /* Check setting QoS with bad parameters. */
status = dds_set_qos (0, NULL); 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); 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); 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. */ /* Check set/get with entity without initial qos. */
entity_qos_get_set(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. */ /* Check getting Listener with bad parameters. */
status = dds_get_listener (0, NULL); 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); 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); 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. */ /* Get Listener, which should be unset. */
status = dds_get_listener (entity, l1); 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 (l1, (dds_on_liveliness_changed_fn*)&cb1);
CU_ASSERT_EQUAL_FATAL(cb1, DDS_LUNSET); CU_ASSERT_EQUAL_FATAL(cb1, DDS_LUNSET);
dds_lget_requested_deadline_missed (l1, (dds_on_requested_deadline_missed_fn*)&cb1); 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. */ /* Check setting Listener with bad parameters. */
status = dds_set_listener (0, NULL); 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); 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. */ /* Getting after setting should return set listener. */
status = dds_set_listener (entity, l2); 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); 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 (l1, (dds_on_liveliness_changed_fn*)&cb1);
dds_lget_liveliness_changed (l2, (dds_on_liveliness_changed_fn*)&cb2); dds_lget_liveliness_changed (l2, (dds_on_liveliness_changed_fn*)&cb2);
CU_ASSERT_EQUAL_FATAL(cb1, cb2); CU_ASSERT_EQUAL_FATAL(cb1, cb2);
@ -189,9 +187,9 @@ CU_Test(ddsc_entity, listener, .init = create_entity, .fini = delete_entity)
/* Reset listener. */ /* Reset listener. */
status = dds_set_listener (entity, NULL); 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); 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); dds_lget_liveliness_changed (l2, (dds_on_liveliness_changed_fn*)&cb2);
CU_ASSERT_EQUAL_FATAL(cb2, DDS_LUNSET); CU_ASSERT_EQUAL_FATAL(cb2, DDS_LUNSET);
dds_lget_requested_deadline_missed (l2, (dds_on_requested_deadline_missed_fn*)&cb2); 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. */ /* Check getting Status with bad parameters. */
status1 = dds_get_status_mask (0, NULL); 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); 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); 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. */ /* Get Status, which should be 0 for a participant. */
status1 = dds_get_status_mask (entity, &s1); 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); CU_ASSERT_EQUAL_FATAL(s1, 0);
/* Check setting Status with bad parameters. */ /* Check setting Status with bad parameters. */
status1 = dds_set_status_mask (0, 0); 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. */ /* I shouldn't be able to set statuses on a participant. */
status1 = dds_set_status_mask (entity, 0); 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); 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. */ /* Check getting Status changes with bad parameters. */
status1 = dds_get_status_changes (0, NULL); 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); 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); 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); 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. */ /* Status read and take shouldn't work either. */
status1 = dds_read_status (0, &s1, 0); 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); 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); 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); 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. */ /* Check getting Handle with bad parameters. */
status = dds_get_instance_handle (0, NULL); 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); 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); 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. */ /* Get Instance Handle, which should not be 0 for a participant. */
status = dds_get_instance_handle (entity, &hdl); 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); 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. */ /* Check getting Parent with bad parameters. */
par = dds_get_parent (0); 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. */ /* Get Parent, a participant doesn't have a parent. */
par = dds_get_parent (entity); 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 ------------ */ /* ---------- Get Participant ------------ */
/* Check getting Participant with bad parameters. */ /* Check getting Participant with bad parameters. */
par = dds_get_participant (0); 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. */ /* Get Participant, a participants' participant is itself. */
par = dds_get_participant (entity); 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. */ /* Check getting Children with bad parameters. */
status = dds_get_children (0, &child, 1); 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); 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); 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); 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); 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. */ /* Get Children, of which there are currently none. */
status = dds_get_children (entity, NULL, 0); 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. */ /* Check getting ID with bad parameters. */
status = dds_get_domainid (0, NULL); 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); 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); 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. */ /* Get and check the domain id. */
status = dds_get_domainid (entity, &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); CU_ASSERT_FATAL(id != -1);
} }
@ -358,10 +356,10 @@ CU_Test(ddsc_entity, delete, .init = create_entity)
{ {
dds_return_t status; dds_return_t status;
status = dds_delete(0); 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); status = dds_delete(entity);
cu_assert_status_eq(status, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK);
entity = 0; 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. */ /* First be sure that 'dds_get_domainid' returns ok. */
ret = dds_get_domainid(g_participant, &id); 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); 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); 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); 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); 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); 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); 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); 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. */ /* Deleting the top dog (participant) should delete all children. */
ret = dds_delete(g_participant); 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. */ /* Check if all the entities are deleted now. */
ret = dds_get_domainid(g_participant, &id); 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); 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); 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); 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); 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); 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); 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); 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 * reference to the topic and thus will delete it when it itself is
* deleted. */ * deleted. */
ret = dds_delete(g_topic); 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 /* Third, deleting the participant should delete all children of which
* the writer with the last topic reference is one. */ * the writer with the last topic reference is one. */
ret = dds_delete(g_participant); ret = dds_delete(g_participant);
/* Before the CHAM-424 fix, we would not get here because of a crash, /* Before the CHAM-424 fix, we would not get here because of a crash,
* or it (incidentally) continued but returned an error. */ * 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. */ /* Check if the entities are actually deleted. */
ret = dds_get_domainid(g_participant, &id); 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); 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); 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); 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_entity_t participant;
dds_delete(*entity); dds_delete(*entity);
participant = dds_get_participant(*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) 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; dds_entity_t participant;
participant = dds_get_participant(entity); 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; dds_entity_t parent;
parent = dds_get_parent(g_participant); 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_entity_t parent;
dds_delete(*entity); dds_delete(*entity);
parent = dds_get_parent(*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) 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; dds_entity_t parent;
parent = dds_get_parent(entity); 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_return_t ret;
dds_entity_t child; dds_entity_t child;
ret = dds_get_children(g_participant, &child, INT32_MAX); 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_entity_t children[4];
dds_delete(*entity); dds_delete(*entity);
ret = dds_get_children(*entity, children, 4); 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) 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_entity_t children[4];
dds_return_t ret; dds_return_t ret;
ret = dds_get_children(entity, children, 4); 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_entity_t topic;
dds_delete(*entity); dds_delete(*entity);
topic = dds_get_topic(*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) 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; dds_entity_t topic;
topic = dds_get_topic(entity); 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; dds_entity_t topic;
topic = dds_get_topic(*entity); 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_entity_t publisher;
dds_delete(g_writer); dds_delete(g_writer);
publisher = dds_get_publisher(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) 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; dds_entity_t publisher;
publisher = dds_get_publisher(entity); 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; dds_entity_t publisher;
publisher = dds_get_publisher(*cond); 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_entity_t subscriber;
dds_delete(*entity); dds_delete(*entity);
subscriber = dds_get_subscriber(*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) 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; dds_entity_t subscriber;
subscriber = dds_get_subscriber(entity); 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; dds_entity_t subscriber;
subscriber = dds_get_subscriber(*cond); 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_entity_t reader;
dds_delete(*cond); dds_delete(*cond);
reader = dds_get_datareader(*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) 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; dds_entity_t reader;
reader = dds_get_datareader(cond); 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; dds_entity_t reader;
reader = dds_get_datareader(*cond); 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); dds_delete(writer);
ret = dds_delete(parent); 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); dds_delete(participant);
} }
/*************************************************************************************************/ /*************************************************************************************************/
@ -985,7 +978,7 @@ CU_Test(ddsc_entity_get_parent, implicit_subscriber)
dds_delete(reader); dds_delete(reader);
ret = dds_delete(parent); 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); 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, /* Getting the status should have reset the trigger,
* meaning that the wait should timeout. */ * meaning that the wait should timeout. */
ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, shortTimeout); 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. */ /* Un-match the publication by deleting the reader. */
dds_delete(rea); 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, /* Getting the status should have reset the trigger,
* meaning that the wait should timeout. */ * meaning that the wait should timeout. */
ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); 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. */ /* Un-match the subscription by deleting the writer. */
dds_delete(wri); 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 */ /*Getting the status should have reset the trigger, waitset should timeout */
ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); 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 */ /* Wait for offered incompatible QoS status */
ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, waitTimeout); 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 */ /*Getting the status should have reset the trigger, waitset should timeout */
ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); 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); ret = dds_waitset_detach(waitSetrd, reader2);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); 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 */ /*Getting the status should have reset the trigger, waitset should timeout */
ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); 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 */ /* Reset writer */
ret = dds_waitset_detach(waitSetwr, wri); 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 */ /*Getting the status should have reset the trigger, waitset should timeout */
ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); 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 #if 0
@ -370,7 +370,7 @@ Test(ddsc_entity, inconsistent_topic)
/*Getting the status should have reset the trigger, waitset should timeout */ /*Getting the status should have reset the trigger, waitset should timeout */
status = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); 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 */ /* Wait for sub inconsistent topic status callback */
ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout); 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 */ /*Getting the status should have reset the trigger, waitset should timeout */
status = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); 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); 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 */ /*Getting the status should have reset the trigger, waitset should timeout */
ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); 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) CU_Theory((dds_entity_t e), ddsc_get_enabled_status, bad_param, .init=init_entity_status, .fini=fini_entity_status)
{ {
uint32_t mask; uint32_t mask;
dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_status_mask(e, &mask); 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) 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; uint32_t mask;
dds_delete(rea); dds_delete(rea);
ret = dds_get_status_mask(rea, &mask); 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) CU_Test(ddsc_get_enabled_status, illegal, .init=init_entity_status, .fini=fini_entity_status)
{ {
uint32_t mask; uint32_t mask;
ret = dds_get_status_mask(waitSetrd, &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) = { 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) 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*/); 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) CU_Test(ddsc_set_enabled_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status)
{ {
dds_delete(rea); dds_delete(rea);
ret = dds_set_status_mask(rea, 0 /*mask*/); 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) CU_Test(ddsc_set_enabled_status, illegal, .init=init_entity_status, .fini=fini_entity_status)
{ {
ret = dds_set_status_mask(waitSetrd, 0); 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) = { 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) CU_Theory((dds_entity_t e), ddsc_read_status, bad_param, .init=init_entity_status, .fini=fini_entity_status)
{ {
uint32_t status; uint32_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_read_status(e, &status, 0 /*mask*/); 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) 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; uint32_t status;
dds_delete(rea); dds_delete(rea);
ret = dds_read_status(rea, &status, 0 /*mask*/); 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) CU_Test(ddsc_read_status, illegal, .init=init_entity_status, .fini=fini_entity_status)
{ {
uint32_t status; uint32_t status;
ret = dds_read_status(waitSetrd, &status, 0); 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_TheoryDataPoints(ddsc_read_status, status_ok) = {
CU_DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber), 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; uint32_t status;
ret = dds_read_status(rea, &status, DDS_PUBLICATION_MATCHED_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) CU_Test(ddsc_read_status, invalid_status_on_writer, .init=init_entity_status, .fini=fini_entity_status)
{ {
uint32_t status; uint32_t status;
ret = dds_read_status(wri, &status, DDS_SUBSCRIPTION_MATCHED_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) CU_Theory((dds_entity_t e), ddsc_take_status, bad_param, .init=init_entity_status, .fini=fini_entity_status)
{ {
uint32_t status; uint32_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_take_status(e, &status, 0 /*mask*/); 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) 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; uint32_t status;
dds_delete(rea); dds_delete(rea);
ret = dds_take_status(rea, &status, 0 /*mask*/); 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) CU_Test(ddsc_take_status, illegal, .init=init_entity_status, .fini=fini_entity_status)
{ {
uint32_t status; uint32_t status;
ret = dds_take_status(waitSetrd, &status, 0); 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) = { 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) CU_Theory((dds_entity_t e), ddsc_get_status_changes, bad_param, .init=init_entity_status, .fini=fini_entity_status)
{ {
uint32_t status; uint32_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_status_changes(e, &status); 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) 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; uint32_t status;
dds_delete(rea); dds_delete(rea);
ret = dds_get_status_changes(rea, &status); 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) CU_Test(ddsc_get_status_changes, illegal, .init=init_entity_status, .fini=fini_entity_status)
{ {
uint32_t status; uint32_t status;
ret = dds_get_status_changes(waitSetrd, &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) = { 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) 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); 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) CU_Test(ddsc_triggered, deleted_reader, .init=init_entity_status, .fini=fini_entity_status)
{ {
dds_delete(rea); dds_delete(rea);
ret = dds_triggered(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) = { 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; dds_inconsistent_topic_status_t inconsistent_topic_status;
ret = dds_get_inconsistent_topic_status(top, &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, 0);
CU_ASSERT_EQUAL_FATAL(inconsistent_topic_status.total_count_change, 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) 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_inconsistent_topic_status_t topic_status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_inconsistent_topic_status(topic, &topic_status); 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); dds_set_status_mask(top, 0);
ret = dds_get_inconsistent_topic_status(top, NULL); 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) 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); 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); dds_delete(top);
ret = dds_get_inconsistent_topic_status(top, NULL); 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) 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_publication_matched_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_publication_matched_status(writer, &status); 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); dds_set_status_mask(wri, 0);
ret = dds_get_publication_matched_status(wri, NULL); 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) 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); 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); dds_delete(wri);
ret = dds_get_publication_matched_status(wri, NULL); 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; dds_liveliness_lost_status_t liveliness_lost_status;
ret = dds_get_liveliness_lost_status(wri, &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, 0);
CU_ASSERT_EQUAL_FATAL(liveliness_lost_status.total_count_change, 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) 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_liveliness_lost_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_liveliness_lost_status(writer, &status); 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); dds_set_status_mask(wri, 0);
ret = dds_get_liveliness_lost_status(wri, NULL); 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) 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); 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); dds_delete(wri);
ret = dds_get_liveliness_lost_status(wri, NULL); 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; dds_offered_deadline_missed_status_t offered_deadline_missed_status;
ret = dds_get_offered_deadline_missed_status(wri, &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, 0);
CU_ASSERT_EQUAL_FATAL(offered_deadline_missed_status.total_count_change, 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); 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) 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_offered_deadline_missed_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_offered_deadline_missed_status(writer, &status); 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); dds_set_status_mask(wri, 0);
ret = dds_get_offered_deadline_missed_status(wri, NULL); 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) 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); 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); dds_delete(wri);
ret = dds_get_offered_deadline_missed_status(wri, NULL); 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) 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_offered_incompatible_qos_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_offered_incompatible_qos_status(writer, &status); 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); dds_set_status_mask(wri, 0);
ret = dds_get_offered_incompatible_qos_status(wri, NULL); 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) 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); 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); dds_delete(wri);
ret = dds_get_offered_incompatible_qos_status(wri, NULL); 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) 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_subscription_matched_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_subscription_matched_status(reader, &status); 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); dds_set_status_mask(rea, 0);
ret = dds_get_subscription_matched_status(rea, NULL); 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) 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); 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); dds_delete(rea);
ret = dds_get_subscription_matched_status(rea, NULL); 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) 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_liveliness_changed_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_liveliness_changed_status(reader, &status); 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); dds_set_status_mask(rea, 0);
ret = dds_get_liveliness_changed_status(rea, NULL); 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) 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); 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); dds_delete(rea);
ret = dds_get_liveliness_changed_status(rea, NULL); 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) 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_sample_rejected_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_sample_rejected_status(reader, &status); 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); dds_set_status_mask(rea, 0);
ret = dds_get_sample_rejected_status(rea, NULL); 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) 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); 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); dds_delete(rea);
ret = dds_get_sample_rejected_status(rea, NULL); 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) 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_sample_lost_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_sample_lost_status(reader, &status); 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); dds_set_status_mask(rea, 0);
ret = dds_get_sample_lost_status(rea, NULL); 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) 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); 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); dds_delete(rea);
ret = dds_get_sample_lost_status(rea, NULL); 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; dds_requested_deadline_missed_status_t requested_deadline_missed_status;
ret = dds_get_requested_deadline_missed_status(rea, &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, 0);
CU_ASSERT_EQUAL_FATAL(requested_deadline_missed_status.total_count_change, 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); 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) 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_requested_deadline_missed_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_requested_deadline_missed_status(reader, &status); 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); dds_set_status_mask(rea, 0);
ret = dds_get_requested_deadline_missed_status(rea, NULL); 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) 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); 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); dds_delete(rea);
ret = dds_get_requested_deadline_missed_status(rea, NULL); 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) 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_requested_incompatible_qos_status_t status;
dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
ret = dds_get_requested_incompatible_qos_status(reader, &status); 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); dds_set_status_mask(rea, 0);
ret = dds_get_requested_incompatible_qos_status(rea, NULL); 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) 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); 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); dds_delete(rea);
ret = dds_get_requested_incompatible_qos_status(rea, NULL); 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; dds_return_t ret;
ret = dds_instance_get_key(participant, handle, &data); 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) 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; dds_return_t ret;
ret = dds_register_instance(writer, &handle, NULL); 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) 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); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_instance_get_key(writer, DDS_HANDLE_NIL, &data); 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) 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_PTR_NOT_NULL_FATAL(key_data.ip);
CU_ASSERT_STRING_EQUAL_FATAL(key_data.ip, 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(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); 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/version.h"
#include "dds/ddsrt/environ.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) { 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); participant2 = dds_create_participant (valid_domain, NULL, NULL);
CU_ASSERT_FATAL(participant2 > 0); CU_ASSERT_FATAL(participant2 > 0);
status = dds_get_domainid(participant2, &domain_id); 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); CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain);
//DDS_DOMAIN_DEFAULT from user //DDS_DOMAIN_DEFAULT from user
participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
CU_ASSERT_FATAL(participant3 > 0); CU_ASSERT_FATAL(participant3 > 0);
status = dds_get_domainid(participant3, &domain_id); 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); CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain);
dds_delete(participant2); dds_delete(participant2);
@ -98,7 +96,7 @@ CU_Test(ddsc_participant, create_with_conf_no_env) {
participant2 = dds_create_participant (valid_domain, NULL, NULL); participant2 = dds_create_participant (valid_domain, NULL, NULL);
CU_ASSERT_FATAL(participant2 > 0); CU_ASSERT_FATAL(participant2 > 0);
status = dds_get_domainid(participant2, &domain_id); 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); 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); participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
CU_ASSERT_FATAL(participant3 > 0); CU_ASSERT_FATAL(participant3 > 0);
status = dds_get_domainid(participant3, &domain_id); 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); CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain);
dds_delete(participant2); dds_delete(participant2);
@ -127,7 +125,7 @@ CU_Test(ddsc_participant_lookup, one) {
/* Get domain id */ /* Get domain id */
status = dds_get_domainid(participant, &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); num_of_found_pp = dds_lookup_participant( domain_id, participants, size);
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 1); CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 1);
@ -153,7 +151,7 @@ CU_Test(ddsc_participant_lookup, multiple) {
/* Get domain id */ /* Get domain id */
status = dds_get_domainid(participant, &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); num_of_found_pp = dds_lookup_participant( domain_id, participants, size);
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 2); CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 2);
@ -185,7 +183,7 @@ CU_Test(ddsc_participant_lookup, array_too_small) {
/* Get domain id */ /* Get domain id */
status = dds_get_domainid(participant, &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); num_of_found_pp = dds_lookup_participant( domain_id, participants, size);
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 3); CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 3);
@ -211,7 +209,7 @@ CU_Test(ddsc_participant_lookup, null_zero){
/* Get domain id */ /* Get domain id */
status = dds_get_domainid(participant, &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); num_of_found_pp = dds_lookup_participant( domain_id, NULL, size);
CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 1); CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 1);
@ -232,10 +230,10 @@ CU_Test(ddsc_participant_lookup, null_nonzero){
/* Get domain id */ /* Get domain id */
status = dds_get_domainid(participant, &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); 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); dds_delete (participant);
} }
@ -254,7 +252,7 @@ CU_Test(ddsc_participant_lookup, unknown_id) {
/* Get domain id */ /* Get domain id */
status = dds_get_domainid(participant, &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 ++; domain_id ++;
num_of_found_pp = dds_lookup_participant( domain_id, participants, size); 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 */ /* Get domain id */
status = dds_get_domainid(participant, &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); dds_delete (participant);
@ -312,7 +310,7 @@ CU_Test(ddsc_participant_lookup, deleted) {
/* Get domain id */ /* Get domain id */
status = dds_get_domainid(participant, &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); dds_delete (participant2);

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

@ -19,8 +19,6 @@
#pragma warning(disable: 28020) #pragma warning(disable: 28020)
#endif #endif
#define cu_assert_status_eq(s1, s2) CU_ASSERT_EQUAL_FATAL(dds_err_nr(s1), s2)
/* Dummy callback */ /* Dummy callback */
static void data_available_cb(dds_entity_t reader, void* arg) static void data_available_cb(dds_entity_t reader, void* arg)
{ {
@ -42,7 +40,7 @@ CU_Test(ddsc_publisher, create)
/* Use NULL participant */ /* Use NULL participant */
publisher = dds_create_publisher(0, NULL, NULL); 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); participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
CU_ASSERT_FATAL(participant > 0); CU_ASSERT_FATAL(participant > 0);
@ -53,7 +51,7 @@ CU_Test(ddsc_publisher, create)
/* Use entity that is not a participant */ /* Use entity that is not a participant */
publisher1 = dds_create_publisher(publisher, NULL, NULL); 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); dds_delete(publisher);
/* Create a non-null qos */ /* Create a non-null qos */
@ -143,35 +141,35 @@ CU_Test(ddsc_publisher, suspend_resume)
/* Suspend a 0 publisher */ /* Suspend a 0 publisher */
status = dds_suspend(0); 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 */ /* Resume a 0 publisher */
status = dds_resume(0); 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 */ /* Uae dds_suspend on something else than a publisher */
participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
CU_ASSERT_FATAL(participant > 0); CU_ASSERT_FATAL(participant > 0);
status = dds_suspend(participant); 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 */ /* Use dds_resume on something else than a publisher */
status = dds_resume(participant); 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 */ /* Use dds_resume without calling dds_suspend */
publisher = dds_create_publisher(participant, NULL, NULL); publisher = dds_create_publisher(participant, NULL, NULL);
CU_ASSERT_FATAL(publisher > 0); CU_ASSERT_FATAL(publisher > 0);
status = dds_resume(publisher); /* Should be precondition not met? */ 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 */ /* Use dds_suspend on non-null publisher */
status = dds_suspend(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 */ /* Use dds_resume on non-null publisher */
status = dds_resume(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(publisher);
dds_delete(participant); 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 */ /* Wait_for_acks on 0 publisher or writer and minusOneSec timeout */
status = dds_wait_for_acks(0, minusOneSec); 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 */ /* Wait_for_acks on NULL publisher or writer and zeroSec timeout */
status = dds_wait_for_acks(0, zeroSec); 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 */ /* wait_for_acks on NULL publisher or writer and oneSec timeout */
status = dds_wait_for_acks(0, oneSec); 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 */ /* wait_for_acks on NULL publisher or writer and DDS_INFINITE timeout */
status = dds_wait_for_acks(0, DDS_INFINITY); 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); participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL);
CU_ASSERT_FATAL(participant > 0); CU_ASSERT_FATAL(participant > 0);
/* Wait_for_acks on participant and minusOneSec timeout */ /* Wait_for_acks on participant and minusOneSec timeout */
status = dds_wait_for_acks(participant, minusOneSec); 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 */ /* Wait_for_acks on participant and zeroSec timeout */
status = dds_wait_for_acks(participant, zeroSec); 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 */ /* Wait_for_acks on participant and oneSec timeout */
status = dds_wait_for_acks(participant, oneSec); 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 */ /* Wait_for_acks on participant and DDS_INFINITE timeout */
status = dds_wait_for_acks(participant, DDS_INFINITY); 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); publisher = dds_create_publisher(participant, NULL, NULL);
CU_ASSERT_FATAL(publisher > 0); CU_ASSERT_FATAL(publisher > 0);
@ -228,40 +226,40 @@ CU_Test(ddsc_publisher, wait_for_acks)
/* Wait_for_acks on publisher and minusOneSec timeout -- /* Wait_for_acks on publisher and minusOneSec timeout --
either BAD_PARAMETER or UNSUPPORTED would be both be ok, really */ either BAD_PARAMETER or UNSUPPORTED would be both be ok, really */
status = dds_wait_for_acks(publisher, minusOneSec); 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 */ /* Wait_for_acks on publisher and zeroSec timeout */
status = dds_wait_for_acks(publisher, zeroSec); 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 */ /* Wait_for_acks on publisher and oneSec timeout */
status = dds_wait_for_acks(publisher, oneSec); 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 */ /* Wait_for_acks on publisher and DDS_INFINITE timeout */
status = dds_wait_for_acks(publisher, DDS_INFINITY); 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 */ /* TODO: create tests by calling dds_qwait_for_acks on writers */
status = dds_suspend(publisher); 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 */ /* Wait_for_acks on suspended publisher and minusOneSec timeout */
status = dds_wait_for_acks(publisher, minusOneSec); 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 */ /* Wait_for_acks on suspended publisher and zeroSec timeout */
status = dds_wait_for_acks(publisher, zeroSec); 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 */ /* Wait_for_acks on suspended publisher and oneSec timeout */
status = dds_wait_for_acks(publisher, oneSec); 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 */ /* Wait_for_acks on suspended publisher and DDS_INFINITE timeout */
status = dds_wait_for_acks(publisher, DDS_INFINITY); 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(publisher);
dds_delete(participant); 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; dds_return_t result;
result = dds_copy_qos(g_qos, NULL); 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) 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; dds_return_t result;
result = dds_copy_qos(NULL, g_qos); 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) 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_entity_t cond;
dds_delete(g_reader); dds_delete(g_reader);
cond = dds_create_querycondition(g_reader, mask, filter_mod2); 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) 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; 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; dds_entity_t cond;
cond = dds_create_querycondition(rdr, mask, filter_mod2); 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; uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_entity_t cond; dds_entity_t cond;
cond = dds_create_querycondition(*rdr, mask, filter_mod2); 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); dds_delete(condition);
mask = 0; mask = 0;
ret = dds_get_mask(condition, &mask); 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_get_mask(condition, NULL); ret = dds_get_mask(condition, NULL);
DDSRT_WARNING_MSVC_ON(6387); 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); 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) 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; dds_return_t ret;
uint32_t mask; uint32_t mask;
ret = dds_get_mask(cond, &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; dds_return_t ret;
uint32_t mask; uint32_t mask;
ret = dds_get_mask(*cond, &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); CU_ASSERT_FATAL(condition > 0);
ret = dds_get_mask(condition, &maskOut); 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); CU_ASSERT_EQUAL_FATAL(maskIn, maskOut);
dds_delete(condition); 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. */ /* Try to read with a deleted condition. */
ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); 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. */ /* Try to take with a deleted condition. */
ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); 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. */ * However, that's not the case yet. So don't test it. */
if (buf != g_loans) { if (buf != g_loans) {
ret = dds_read_instance(*ent, buf, si, bufsz, maxs, g_hdl_valid); 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 { } else {
CU_PASS("Skipped"); 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. */ * invalid and neither is the handle. So, don't test that. */
if ((buf != g_loans) || (si != g_info) || (maxs == 0)) { if ((buf != g_loans) || (si != g_info) || (maxs == 0)) {
ret = dds_read_instance_wl(*ent, buf, si, maxs, g_hdl_valid); 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 { } else {
CU_PASS("Skipped"); 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. */ * However, that's not the case yet. So don't test it. */
if (buf != g_loans) { if (buf != g_loans) {
ret = dds_read_instance_mask(*ent, buf, si, bufsz, maxs, g_hdl_valid, mask); 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 { } else {
CU_PASS("Skipped"); 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. */ * invalid and neither is the handle. So, don't test that. */
CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); 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); 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; dds_return_t ret;
ret = dds_read_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl); 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; dds_return_t ret;
ret = dds_read_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl); 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; uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret; dds_return_t ret;
ret = dds_read_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl, mask); 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; uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret; dds_return_t ret;
ret = dds_read_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl, mask); 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) 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; dds_return_t ret;
ret = dds_read_instance(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); 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) 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; dds_return_t ret;
ret = dds_read_instance_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); 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) 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; 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; dds_return_t ret;
ret = dds_read_instance_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); 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) 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; 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; dds_return_t ret;
ret = dds_read_instance_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); 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; dds_return_t ret;
ret = dds_read_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); 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; dds_return_t ret;
ret = dds_read_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); 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; uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret; dds_return_t ret;
ret = dds_read_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); 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; uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret; dds_return_t ret;
ret = dds_read_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); 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); ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_read_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); 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); ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_read_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); 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); ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); 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); 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); ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); 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); 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_entity_t cond;
dds_delete(g_reader); dds_delete(g_reader);
cond = dds_create_readcondition(g_reader, mask); 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) 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; 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; dds_entity_t cond;
cond = dds_create_readcondition(rdr, mask); 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; uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_entity_t cond; dds_entity_t cond;
cond = dds_create_readcondition(*rdr, mask); 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); dds_delete(condition);
mask = 0; mask = 0;
ret = dds_get_mask(condition, &mask); 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_get_mask(condition, NULL); ret = dds_get_mask(condition, NULL);
DDSRT_WARNING_MSVC_ON(6387); 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); 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) 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; dds_return_t ret;
uint32_t mask; uint32_t mask;
ret = dds_get_mask(cond, &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; dds_return_t ret;
uint32_t mask; uint32_t mask;
ret = dds_get_mask(*cond, &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); CU_ASSERT_FATAL(condition > 0);
ret = dds_get_mask(condition, &maskOut); 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); CU_ASSERT_EQUAL_FATAL(maskIn, maskOut);
dds_delete(condition); 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. */ /* Try to read with a deleted condition. */
ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); 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. */ /* Try to take with a deleted condition. */
ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); 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)); dds_qset_reader_data_lifecycle(qos, DDS_SECS(-1), DDS_SECS(-1));
DDSRT_WARNING_MSVC_ON(28020); DDSRT_WARNING_MSVC_ON(28020);
rdr = dds_create_reader(g_participant, g_topic, qos, NULL); 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); 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)); dds_qset_reader_data_lifecycle(qos, DDS_SECS(-1), DDS_SECS(-1));
DDSRT_WARNING_MSVC_ON(28020); DDSRT_WARNING_MSVC_ON(28020);
rdr = dds_create_reader(g_subscriber, g_topic, qos, NULL); 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); 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. */ * actually the topic. So, don't test that permutation. */
CU_ASSERT_FATAL((par != &g_participant) || (top != &g_topic)); CU_ASSERT_FATAL((par != &g_participant) || (top != &g_topic));
rdr = dds_create_reader(*par, *top, NULL, NULL); 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. */ * However, that's not the case yet. So don't test it. */
if (buf != g_loans) { if (buf != g_loans) {
ret = dds_read(g_reader, buf, si, bufsz, maxs); 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 { } else {
CU_PASS("Skipped"); 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) 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; dds_return_t ret;
ret = dds_read(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); 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; dds_return_t ret;
ret = dds_read(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); 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. */ /* Try to read with a deleted reader. */
dds_delete(g_reader); dds_delete(g_reader);
ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); 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. */ * invalid. So, don't test that. */
CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0));
ret = dds_read_wl(g_reader, buf, si, maxs); 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) 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; dds_return_t ret;
ret = dds_read_wl(rdr, g_loans, g_info, MAX_SAMPLES); 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; dds_return_t ret;
ret = dds_read_wl(*rdr, g_loans, g_info, MAX_SAMPLES); 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. */ /* Try to read with a deleted reader. */
dds_delete(g_reader); dds_delete(g_reader);
ret = dds_read_wl(g_reader, g_loans, g_info, MAX_SAMPLES); 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. */ * However, that's not the case yet. So don't test it. */
if (buf != g_loans) { if (buf != g_loans) {
ret = dds_read_mask(g_reader, buf, si, bufsz, maxs, mask); 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 { } else {
CU_PASS("Skipped"); 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) 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; 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; dds_return_t ret;
ret = dds_read_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); 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; uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret; dds_return_t ret;
ret = dds_read_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); 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. */ /* Try to read with a deleted reader. */
dds_delete(g_reader); dds_delete(g_reader);
ret = dds_read_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); 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. */ * invalid. So, don't test that. */
CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0));
ret = dds_read_mask_wl(g_reader, buf, si, maxs, mask); 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) 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; 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; dds_return_t ret;
ret = dds_read_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, mask); 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; uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret; dds_return_t ret;
ret = dds_read_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, mask); 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. */ /* Try to read with a deleted reader. */
dds_delete(g_reader); dds_delete(g_reader);
ret = dds_read_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); 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. */ * However, that's not the case yet. So don't test it. */
if (buf != g_loans) { if (buf != g_loans) {
ret = dds_take(g_reader, buf, si, bufsz, maxs); 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 { } else {
CU_PASS("Skipped"); 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) 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; dds_return_t ret;
ret = dds_take(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); 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; dds_return_t ret;
ret = dds_take(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); 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. */ /* Try to take with a deleted reader. */
dds_delete(g_reader); dds_delete(g_reader);
ret = dds_take(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); 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. */ * invalid. So, don't test that. */
CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0));
ret = dds_take_wl(g_reader, buf, si, maxs); 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) 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; dds_return_t ret;
ret = dds_take_wl(rdr, g_loans, g_info, MAX_SAMPLES); 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; dds_return_t ret;
ret = dds_take_wl(*rdr, g_loans, g_info, MAX_SAMPLES); 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. */ /* Try to read with a deleted reader. */
dds_delete(g_reader); dds_delete(g_reader);
ret = dds_take_wl(g_reader, g_loans, g_info, MAX_SAMPLES); 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. */ * However, that's not the case yet. So don't test it. */
if (buf != g_loans) { if (buf != g_loans) {
ret = dds_take_mask(g_reader, buf, si, bufsz, maxs, mask); 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 { } else {
CU_PASS("Skipped"); 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) 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; 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; dds_return_t ret;
ret = dds_take_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); 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; uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret; dds_return_t ret;
ret = dds_take_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); 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. */ /* Try to read with a deleted reader. */
dds_delete(g_reader); dds_delete(g_reader);
ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); 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. */ * invalid. So, don't test that. */
CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0));
ret = dds_take_mask_wl(g_reader, buf, si, maxs, mask); 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) 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; 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; dds_return_t ret;
ret = dds_take_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, mask); 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; uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret; dds_return_t ret;
ret = dds_take_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, mask); 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. */ /* Try to read with a deleted reader. */
dds_delete(g_reader); dds_delete(g_reader);
ret = dds_take_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); 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) 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; dds_return_t ret;
ret = dds_read_next(rdr, g_samples, g_info); 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; dds_return_t ret;
ret = dds_read_next(*rdr, g_samples, g_info); 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); ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_read_next(*rdr, g_samples, g_info); 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; dds_return_t ret;
if ((buf != g_samples || si != g_info) && (buf != g_loans)) { if ((buf != g_samples || si != g_info) && (buf != g_loans)) {
ret = dds_read_next(g_reader, buf, si); 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 { } else {
CU_PASS("Skipped"); 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) 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; dds_return_t ret;
ret = dds_read_next_wl(rdr, g_loans, g_info); 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; dds_return_t ret;
ret = dds_read_next_wl(*rdr, g_loans, g_info); 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); ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_read_next_wl(*rdr, g_loans, g_info); 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; dds_return_t ret;
if (buf != g_loans || si != g_info) { if (buf != g_loans || si != g_info) {
ret = dds_read_next_wl(g_reader, buf, si); 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 { } else {
CU_PASS("Skipped"); 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) 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; dds_return_t ret;
ret = dds_take_next(rdr, g_samples, g_info); 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; dds_return_t ret;
ret = dds_take_next(*rdr, g_samples, g_info); 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); ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_take_next(*rdr, g_samples, g_info); 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; dds_return_t ret;
if ((buf != g_samples || si != g_info) && (buf != g_loans)) { if ((buf != g_samples || si != g_info) && (buf != g_loans)) {
ret = dds_take_next(g_reader, buf, si); 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 { } else {
CU_PASS("Skipped"); 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) 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; dds_return_t ret;
ret = dds_take_next_wl(rdr, g_loans, g_info); 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; dds_return_t ret;
ret = dds_take_next_wl(*rdr, g_loans, g_info); 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); ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_take_next_wl(*rdr, g_loans, g_info); 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; dds_return_t ret;
if (buf != g_loans || si != g_info) { if (buf != g_loans || si != g_info) {
ret = dds_take_next_wl(g_reader, buf, si); 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 { } else {
CU_PASS("Skipped"); 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_instance_handle_t handle;
dds_delete(g_writer); dds_delete(g_writer);
ret = dds_register_instance(g_writer, &handle, g_data); 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; 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
ret = dds_register_instance(g_writer, hndl2, datap); ret = dds_register_instance(g_writer, hndl2, datap);
DDSRT_WARNING_MSVC_ON(6387); 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) = { 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) 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_return_t ret;
dds_instance_handle_t handle; dds_instance_handle_t handle;
ret = dds_register_instance(writer, &handle, g_data); 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) = { 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_return_t ret;
dds_instance_handle_t handle; dds_instance_handle_t handle;
ret = dds_register_instance(*writer, &handle, g_data); 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) 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; dds_return_t result;
result = dds_delete(participant); 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); dds_delete(read_condition);
} }
@ -86,7 +86,7 @@ CU_Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = de
void **buf = NULL; void **buf = NULL;
result = dds_return_loan(reader, NULL, 0); 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 #ifdef _MSC_VER
#pragma warning(push) #pragma warning(push)
@ -96,7 +96,7 @@ CU_Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = de
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(pop) #pragma warning(pop)
#endif #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); buf = create_loan_buf(10, false);
#ifdef _MSC_VER #ifdef _MSC_VER
@ -107,10 +107,10 @@ CU_Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = de
#ifdef _MSC_VER #ifdef _MSC_VER
#pragma warning(pop) #pragma warning(pop)
#endif #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); 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); 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); buf = create_loan_buf(10, false);
result = dds_return_loan(reader, buf, 10); 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); 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); delete_loan_buf(buf, 10, true);
buf = create_loan_buf(10, false); buf = create_loan_buf(10, false);
result = dds_return_loan(read_condition, buf, 10); 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); 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); 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 */ /* todo implement tests */
ret = dds_notify_readers(subscriber); 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(subscriber);
dds_delete(participant); dds_delete(participant);
@ -67,7 +67,7 @@ CU_Test(ddsc_subscriber, create) {
/*** Verify participant parameter ***/ /*** Verify participant parameter ***/
subscriber = dds_create_subscriber(0, NULL, NULL); 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); subscriber = dds_create_subscriber(participant, NULL, NULL);
CU_ASSERT_FATAL(subscriber > 0); CU_ASSERT_FATAL(subscriber > 0);
@ -91,7 +91,7 @@ CU_Test(ddsc_subscriber, create) {
sqos = dds_create_qos(); sqos = dds_create_qos();
dds_qset_presentation(sqos, 123, 1, 1); /* Set invalid presentation policy */ dds_qset_presentation(sqos, 123, 1, 1); /* Set invalid presentation policy */
subscriber = dds_create_subscriber(participant, sqos, NULL); 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); dds_delete_qos(sqos);
/*** Verify listener parameter ***/ /*** 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. */ * However, that's not the case yet. So don't test it. */
if (buf != g_loans) { if (buf != g_loans) {
ret = dds_take_instance(*ent, buf, si, bufsz, maxs, g_hdl_valid); 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 { } else {
CU_PASS("Skipped"); 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. */ * invalid and neither is the handle. So, don't test that. */
CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0));
ret = dds_take_instance_wl(*ent, buf, si, maxs, g_hdl_valid); 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. */ * However, that's not the case yet. So don't test it. */
if (buf != g_loans) { if (buf != g_loans) {
ret = dds_take_instance_mask(*ent, buf, si, bufsz, maxs, g_hdl_valid, mask); 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 { } else {
CU_PASS("Skipped"); 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. */ * invalid and neither is the handle. So, don't test that. */
CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); 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); 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; dds_return_t ret;
ret = dds_take_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl); 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; dds_return_t ret;
ret = dds_take_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl); 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; uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret; dds_return_t ret;
ret = dds_take_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl, mask); 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; uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret; dds_return_t ret;
ret = dds_take_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl, mask); 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) 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; dds_return_t ret;
ret = dds_take_instance(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); 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) 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; dds_return_t ret;
ret = dds_take_instance_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); 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) 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; 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; dds_return_t ret;
ret = dds_take_instance_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); 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) 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; 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; dds_return_t ret;
ret = dds_take_instance_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); 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; dds_return_t ret;
ret = dds_take_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); 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; dds_return_t ret;
ret = dds_take_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); 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; uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret; dds_return_t ret;
ret = dds_take_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); 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; uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE;
dds_return_t ret; dds_return_t ret;
ret = dds_take_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); 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); ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_take_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); 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); ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_take_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); 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); ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); 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); 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); ret = dds_delete(*rdr);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); 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); 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)); dds_qset_lifespan(qos, DDS_SECS(-1));
DDSRT_WARNING_MSVC_OFF(28020); DDSRT_WARNING_MSVC_OFF(28020);
topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, "inconsistent", qos, NULL); 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); 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; dds_entity_t topic;
topic = dds_create_topic(g_topicRtmDataType, &RoundTripModule_DataType_desc, "non_participant", NULL, NULL); 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; dds_entity_t topic;
/* Creating the different topic with same name should fail. */ /* Creating the different topic with same name should fail. */
topic = dds_create_topic(g_participant, &RoundTripModule_Address_desc, g_topicRtmDataTypeName, NULL, NULL); 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 */ 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); topic = dds_create_topic (g_participant, NULL, "desc_null", NULL, NULL);
DDSRT_WARNING_MSVC_ON(6387); 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; dds_entity_t topic;
topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, name, NULL, NULL); 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; dds_entity_t topic;
topic = dds_find_topic(g_topicRtmDataType, "non_participant"); 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 */ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */
topic = dds_find_topic(g_participant, NULL); topic = dds_find_topic(g_participant, NULL);
DDSRT_WARNING_MSVC_ON(6387); 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; dds_entity_t topic;
topic = dds_find_topic(g_participant, "unknown"); 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_entity_t topic;
dds_delete(g_topicRtmDataType); dds_delete(g_topicRtmDataType);
topic = dds_find_topic(g_participant, g_topicRtmDataTypeName); 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]; char name[MAX_NAME_SIZE];
dds_return_t ret; dds_return_t ret;
ret = dds_get_name(g_participant, name, MAX_NAME_SIZE); 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; dds_return_t ret;
CU_ASSERT_FATAL((name != g_nameBuffer) || (size != MAX_NAME_SIZE)); CU_ASSERT_FATAL((name != g_nameBuffer) || (size != MAX_NAME_SIZE));
ret = dds_get_name(g_topicRtmDataType, name, size); 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_return_t ret;
dds_delete(g_topicRtmDataType); dds_delete(g_topicRtmDataType);
ret = dds_get_name(g_topicRtmDataType, name, MAX_NAME_SIZE); 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]; char name[MAX_NAME_SIZE];
dds_return_t ret; dds_return_t ret;
ret = dds_get_type_name(g_participant, name, MAX_NAME_SIZE); 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; dds_return_t ret;
CU_ASSERT_FATAL((name != g_nameBuffer) || (size != MAX_NAME_SIZE)); CU_ASSERT_FATAL((name != g_nameBuffer) || (size != MAX_NAME_SIZE));
ret = dds_get_type_name(g_topicRtmDataType, name, size); 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_return_t ret;
dds_delete(g_topicRtmDataType); dds_delete(g_topicRtmDataType);
ret = dds_get_type_name(g_topicRtmDataType, name, MAX_NAME_SIZE); 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. */ /* Latency is the only one allowed to change. */
dds_qset_latency_budget(g_qos, DDS_SECS(1)); dds_qset_latency_budget(g_qos, DDS_SECS(1));
ret = dds_set_qos(g_topicRtmDataType, g_qos); 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)); dds_qset_lifespan(g_qos, DDS_SECS(-1));
DDSRT_WARNING_MSVC_ON(28020); DDSRT_WARNING_MSVC_ON(28020);
ret = dds_set_qos(g_topicRtmDataType, g_qos); 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_return_t ret;
dds_qset_destination_order(g_qos, DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP); /* Immutable */ dds_qset_destination_order(g_qos, DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP); /* Immutable */
ret = dds_set_qos(g_topicRtmDataType, g_qos); 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); \ CU_ASSERT_FATAL(wri > 0); \
\ \
status = dds_write(wri, &data); \ 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(wri); \
dds_delete(top); \ dds_delete(top); \
@ -114,7 +114,7 @@ CU_Test(ddsc_types, alltypeskey)
CU_ASSERT_FATAL(wri > 0); CU_ASSERT_FATAL(wri > 0);
status = dds_write(wri, &atk_data); 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(wri);
dds_delete(top); 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); dds_delete(g_writer);
ret = dds_unregister_instance(g_writer, g_data); 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; dds_return_t ret;
ret = dds_unregister_instance(g_writer, NULL); 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) 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; dds_return_t ret;
ret = dds_unregister_instance(writer, g_data); 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; dds_return_t ret;
ret = dds_unregister_instance(*writer, g_data); 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_return_t ret;
dds_delete(g_writer); dds_delete(g_writer);
ret = dds_unregister_instance_ts(g_writer, g_data, g_present); 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; dds_return_t ret;
ret = dds_unregister_instance_ts(g_writer, NULL, g_present); 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) 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; dds_return_t ret;
ret = dds_unregister_instance_ts(writer, g_data, g_present); 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; dds_return_t ret;
ret = dds_unregister_instance_ts(*writer, g_data, g_present); 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_return_t ret;
dds_delete(g_writer); dds_delete(g_writer);
ret = dds_unregister_instance_ih(g_writer, DDS_HANDLE_NIL); 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; dds_return_t ret;
ret = dds_unregister_instance_ih(g_writer, handle); 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) 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; dds_return_t ret;
ret = dds_unregister_instance_ih(writer, DDS_HANDLE_NIL); 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; dds_return_t ret;
ret = dds_unregister_instance_ih(*writer, DDS_HANDLE_NIL); 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_return_t ret;
dds_delete(g_writer); dds_delete(g_writer);
ret = dds_unregister_instance_ih_ts(g_writer, DDS_HANDLE_NIL, g_present); 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; dds_return_t ret;
ret = dds_unregister_instance_ih_ts(g_writer, handle, g_present); 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) 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; dds_return_t ret;
ret = dds_unregister_instance_ih_ts(writer, DDS_HANDLE_NIL, g_present); 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; dds_return_t ret;
ret = dds_unregister_instance_ih_ts(*writer, DDS_HANDLE_NIL, g_present); 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++) { for (int i=0; i < 5; i++) {
result = dds_begin_coherent(e[pars[i].index]); 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]); 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++) { for (int i=0; i< 3; i++) {
result = dds_wait_for_acks(e[pars[i].index], 0); 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++) { for (int i=0; i< 3; i++) {
result = dds_suspend(e[pars[i].index]); 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]); 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++) { for (int i=0; i < 5; i++) {
result = dds_get_instance_handle(e[pars[i].index], &ih); 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(); qos = dds_create_qos();
for (int i=0; i < 8;i++) { for (int i=0; i < 8;i++) {
result = dds_set_qos(e[pars[i].index], qos); 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); 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); deleted = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL);
dds_delete(deleted); dds_delete(deleted);
ws = dds_create_waitset(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) 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; dds_entity_t ws;
ws = dds_create_waitset(par); 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; dds_entity_t ws;
ws = dds_create_waitset(*par); 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; dds_return_t ret;
ret = dds_waitset_attach(waitset, e, a); 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) 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; dds_return_t ret;
ret = dds_waitset_attach(ws, participant, a); 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; dds_return_t ret;
ret = dds_waitset_attach(*ws, *e, a); 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_return_t ret;
dds_delete(waitset); dds_delete(waitset);
ret = dds_waitset_attach(waitset, participant, 0); 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. */ /* Try to attach. */
ret = dds_waitset_attach(*ws, *e, a); 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. */ /* Detach when needed. */
if (ret == DDS_RETCODE_OK) { 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); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_attach(waitset, waitset, 0); 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); ret = dds_waitset_detach(waitset, waitset);
CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
ret = dds_waitset_detach(waitset, waitset); 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; dds_return_t ret;
ret = dds_waitset_detach(waitset, e); 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) 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; dds_return_t ret;
ret = dds_waitset_detach(ws, participant); 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); 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_return_t ret;
dds_delete(waitset); dds_delete(waitset);
ret = dds_waitset_set_trigger(waitset, true); 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) 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; dds_return_t ret;
ret = dds_waitset_set_trigger(ws, true); 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; dds_return_t ret;
ret = dds_waitset_set_trigger(*ws, true); 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_return_t ret;
dds_delete(waitset); dds_delete(waitset);
ret = dds_waitset_wait(waitset, &triggered, 1, DDS_SECS(1)); 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) 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_attach_t triggered;
dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret; dds_return_t ret;
ret = dds_waitset_wait(ws, &triggered, 1, DDS_SECS(1)); 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_attach_t triggered;
dds_return_t ret; dds_return_t ret;
ret = dds_waitset_wait(*ws, &triggered, 1, DDS_SECS(1)); 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)); CU_ASSERT_FATAL(((a == NULL) && (size != 0)) || ((a != NULL) && (size == 0)) || (msec < 0));
ret = dds_waitset_wait(waitset, a, size, DDS_MSECS(msec)); 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_return_t ret;
dds_delete(waitset); dds_delete(waitset);
ret = dds_waitset_wait_until(waitset, &triggered, 1, dds_time()); 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) 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_attach_t triggered;
dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
dds_return_t ret; dds_return_t ret;
ret = dds_waitset_wait_until(ws, &triggered, 1, dds_time()); 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_attach_t triggered;
dds_return_t ret; dds_return_t ret;
ret = dds_waitset_wait_until(*ws, &triggered, 1, dds_time()); 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))); CU_ASSERT_FATAL(((a == NULL) && (size != 0)) || ((a != NULL) && (size == 0)));
ret = dds_waitset_wait_until(waitset, a, size, dds_time()); 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_entity_t entities[MAX_ENTITIES_CNT];
dds_delete(waitset); dds_delete(waitset);
ret = dds_waitset_get_entities(waitset, entities, MAX_ENTITIES_CNT); 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) 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_entity_t entities[MAX_ENTITIES_CNT];
dds_return_t ret; dds_return_t ret;
ret = dds_waitset_get_entities(ws, entities, MAX_ENTITIES_CNT); 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_entity_t entities[MAX_ENTITIES_CNT];
dds_return_t ret; dds_return_t ret;
ret = dds_waitset_get_entities(*ws, entities, MAX_ENTITIES_CNT); 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; return 0;
} }
static dds_retcode_t static dds_return_t
thread_reached_state(thread_state_t *actual, thread_state_t expected, int32_t msec) thread_reached_state(thread_state_t *actual, thread_state_t expected, int32_t msec)
{ {
/* Convenience function. */ /* Convenience function. */
@ -1090,7 +1083,7 @@ waiting_thread_start(struct thread_arg_t *arg, dds_entity_t expected)
{ {
ddsrt_thread_t thread_id; ddsrt_thread_t thread_id;
ddsrt_threadattr_t thread_attr; ddsrt_threadattr_t thread_attr;
dds_retcode_t rc; dds_return_t rc;
assert(arg); assert(arg);
@ -1115,7 +1108,7 @@ waiting_thread_start(struct thread_arg_t *arg, dds_entity_t expected)
static dds_return_t static dds_return_t
waiting_thread_expect_exit(struct thread_arg_t *arg) waiting_thread_expect_exit(struct thread_arg_t *arg)
{ {
dds_retcode_t rc; dds_return_t rc;
assert(arg); assert(arg);
rc = thread_reached_state(&(arg->state), STOPPED, 5000); rc = thread_reached_state(&(arg->state), STOPPED, 5000);
if (rc == DDS_RETCODE_OK) { 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; dds_return_t status;
status = dds_write(writer, &data); 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) 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); DDSRT_WARNING_MSVC_OFF(28020);
status = dds_write(0, &data); status = dds_write(0, &data);
DDSRT_WARNING_MSVC_ON(28020); 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) 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; dds_return_t status;
status = dds_write(publisher, &data); 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) 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; dds_return_t status;
status = dds_delete(writer); 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); status = dds_write(writer, &data);
writer = 0; 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) 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); status = dds_write(writer, NULL);
DDSRT_WARNING_MSVC_ON(6387); 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) 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; dds_return_t status;
status = dds_write_ts(writer, &data, dds_time()); 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) 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; dds_return_t status;
status = dds_write_ts(writer, &data, -1); 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) CU_Test(ddsc_write, simpletypes)
@ -152,7 +152,7 @@ CU_Test(ddsc_write, simpletypes)
CU_ASSERT_FATAL(wri > 0); CU_ASSERT_FATAL(wri > 0);
status = dds_write(wri, &st_data); 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(wri);
dds_delete(top); 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 */ DDSRT_WARNING_MSVC_OFF(28020); /* Disable SAL warning on intentional misuse of the API */
writer = dds_create_writer(0, topic, NULL, NULL); writer = dds_create_writer(0, topic, NULL, NULL);
DDSRT_WARNING_MSVC_ON(28020); 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) CU_Test(ddsc_create_writer, bad_parent, .init = setup, .fini = teardown)
{ {
writer = dds_create_writer(topic, topic, NULL, NULL); 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) 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); dds_delete(publisher);
writer = dds_create_writer(publisher, topic, NULL, NULL); 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) 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 */ DDSRT_WARNING_MSVC_OFF(28020); /* Disable SAL warning on intentional misuse of the API */
writer = dds_create_writer(publisher, 0, NULL, NULL); writer = dds_create_writer(publisher, 0, NULL, NULL);
DDSRT_WARNING_MSVC_ON(28020); 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) CU_Test(ddsc_create_writer, bad_topic, .init = setup, .fini = teardown)
{ {
writer = dds_create_writer(publisher, publisher, NULL, NULL); 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) 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); dds_delete(topic);
writer = dds_create_writer(publisher, topic, NULL, NULL); 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);
} }

1
src/core/ddsi/CMakeLists.txt
View file

@ -86,7 +86,6 @@ PREPEND(hdrs_private_ddsi "${CMAKE_CURRENT_LIST_DIR}/include/dds/ddsi"
q_debmon.h q_debmon.h
q_entity.h q_entity.h
q_ephash.h q_ephash.h
q_error.h
q_feature_check.h q_feature_check.h
q_freelist.h q_freelist.h
q_gc.h q_gc.h

4
src/core/ddsi/include/dds/ddsi/ddsi_tcp.h
View file

@ -28,8 +28,8 @@ struct ddsi_ssl_plugins
void (*fini) (void); void (*fini) (void);
void (*ssl_free) (SSL *ssl); void (*ssl_free) (SSL *ssl);
void (*bio_vfree) (BIO *bio); void (*bio_vfree) (BIO *bio);
ssize_t (*read) (SSL *ssl, void *buf, size_t len, dds_retcode_t *err); ssize_t (*read) (SSL *ssl, void *buf, size_t len, dds_return_t *err);
ssize_t (*write) (SSL *ssl, const void *msg, size_t len, dds_retcode_t *err); ssize_t (*write) (SSL *ssl, const void *msg, size_t len, dds_return_t *err);
SSL * (*connect) (ddsrt_socket_t sock); SSL * (*connect) (ddsrt_socket_t sock);
BIO * (*listen) (ddsrt_socket_t sock); BIO * (*listen) (ddsrt_socket_t sock);
SSL * (*accept) (BIO *bio, ddsrt_socket_t *sock); SSL * (*accept) (BIO *bio, ddsrt_socket_t *sock);

2
src/core/ddsi/include/dds/ddsi/ddsi_threadmon.h
View file

@ -19,7 +19,7 @@ extern "C" {
struct ddsi_threadmon; struct ddsi_threadmon;
struct ddsi_threadmon *ddsi_threadmon_new (void); struct ddsi_threadmon *ddsi_threadmon_new (void);
int ddsi_threadmon_start (struct ddsi_threadmon *sl); dds_return_t ddsi_threadmon_start (struct ddsi_threadmon *sl);
void ddsi_threadmon_stop (struct ddsi_threadmon *sl); void ddsi_threadmon_stop (struct ddsi_threadmon *sl);
void ddsi_threadmon_free (struct ddsi_threadmon *sl); void ddsi_threadmon_free (struct ddsi_threadmon *sl);
void ddsi_threadmon_statechange_barrier (struct ddsi_threadmon *sl); void ddsi_threadmon_statechange_barrier (struct ddsi_threadmon *sl);

104
src/core/ddsi/include/dds/ddsi/q_entity.h
View file

@ -400,9 +400,6 @@ int is_writer_entityid (nn_entityid_t id);
int is_reader_entityid (nn_entityid_t id); int is_reader_entityid (nn_entityid_t id);
nn_vendorid_t get_entity_vendorid (const struct entity_common *e); nn_vendorid_t get_entity_vendorid (const struct entity_common *e);
int pp_allocate_entityid (nn_entityid_t *id, unsigned kind, struct participant *pp);
void pp_release_entityid(struct participant *pp, nn_entityid_t id);
/* Interface for glue code between the OpenSplice kernel and the DDSI /* Interface for glue code between the OpenSplice kernel and the DDSI
entities. These all return 0 iff successful. All GIDs supplied entities. These all return 0 iff successful. All GIDs supplied
__MUST_BE_UNIQUE__. All hell may break loose if they aren't. __MUST_BE_UNIQUE__. All hell may break loose if they aren't.
@ -456,20 +453,93 @@ void pp_release_entityid(struct participant *pp, nn_entityid_t id);
/* Set this flag to mark the participant as an local entity only. */ /* Set this flag to mark the participant as an local entity only. */
#define RTPS_PF_ONLY_LOCAL 16u #define RTPS_PF_ONLY_LOCAL 16u
/* To create a DDSI participant given a GUID. May return ERR_OUT_OF_IDS /**
(a.o.) */ * @brief Create a new participant with a given GUID in the domain.
int new_participant_guid (const nn_guid_t *ppguid, unsigned flags, const struct nn_plist *plist); *
* @param[in] ppguid
* The GUID of the new participant.
* @param[in] flags
* Zero or more of:
* - RTPS_PF_NO_BUILTIN_READERS do not create discovery readers in new ppant
* - RTPS_PF_NO_BUILTIN_WRITERS do not create discvoery writers in new ppant
* - RTPS_PF_PRIVILEGED_PP FIXME: figure out how to describe this ...
* - RTPS_PF_IS_DDSI2_PP FIXME: OSPL holdover - there is no DDSI2E here
* - RTPS_PF_ONLY_LOCAL FIXME: not used, it seems
* @param[in] plist
* Parameters/QoS for this participant
* @param[out] dest
* Filled with the recognized parameters in the input if successful, otherwise
* initialized to an empty parameter list. Where possible, pointers alias the
* input (indicated by the "aliased" bits in the plist/xqos structures), but
* some things cannot be aliased (e.g., the array of pointers to strings for a
* sequence of strings).
* Generally, nn_plist_fini should be called when done with the parameter list,
* even when nn_plist_unlias or nn_xqos_unlias hasn't been called.
* @param[out] nextafterplist
* If non-NULL, *nextafterplist is set to the first byte following the parameter
* list sentinel on successful parse, or to NULL on failure
*
* @returns A dds_return_t indicating success or failure.
*
* @retval DDS_RETCODE_OK
* All parameters valid (or ignored), dest and *nextafterplist have been set
* accordingly.
* @retval DDS_RETCODE_PRECONDITION_NOT_MET
* A participant with GUID *ppguid already exists.
* @retval DDS_RETCODE_OUT_OF_RESOURCES
* The configured maximum number of participants has been reached.
*/
dds_return_t new_participant_guid (const nn_guid_t *ppguid, unsigned flags, const struct nn_plist *plist);
int new_participant (struct nn_guid *ppguid, unsigned flags, const struct nn_plist *plist); /**
* @brief Create a new participant in the domain. See also new_participant_guid.
*
* @param[out] ppguid
* On successful return: the GUID of the new participant;
* Undefined on error.
* @param[in] flags
* See new_participant_guid
* @param[in] plist
* See new_participant_guid
*
* @returns A dds_return_t indicating success or failure.
*
* @retval DDS_RETCODE_OK
* Success, there is now a local participant with the GUID stored in
* *ppguid
* @retval DDS_RETCODE_OUT_OF_RESOURCES
* Failed to allocate a new GUID (note: currently this will always
* happen after 2**24-1 successful calls to new_participant ...).
* @retval DDS_RETCODE_OUT_OF_RESOURCES
* The configured maximum number of participants has been reached.
*/
dds_return_t new_participant (struct nn_guid *ppguid, unsigned flags, const struct nn_plist *plist);
/* To delete a DDSI participant: this only removes the participant /**
from the hash tables and schedules the actual delete operation, * @brief Initiate the deletion of the participant:
which will start doing scary things once all but the DDSI built-in * - dispose/unregister built-in topic
endpoints are gone. It is acceptable to call delete_participant() * - list it as one of the recently deleted participants
before all its readers and writers have been deleted (which also * - remote it from the GUID hash tables
fits nicely with model where the glue calls merely schedules * - schedule the scare stuff to really delete it via the GC
garbage-collection). */ *
int delete_participant (const struct nn_guid *ppguid); * It is ok to call delete_participant without deleting all DDSI-level
* readers/writers: those will simply be deleted. (New ones can't be
* created anymore because the participant can no longer be located via
* the hash tables).
*
* @param[in] ppguid
* GUID of the participant to be deleted.
*
* @returns A dds_return_t indicating success or failure.
*
* @retval DDS_RETCODE_OK
* Success, it is no longer visible and GC events have
* been scheduled for eventual deleting of all remaining
* readers and writers and freeing of memory
* @retval DDS_RETCODE_BAD_PARAMETER
* ppguid lookup failed.
*/
dds_return_t delete_participant (const struct nn_guid *ppguid);
/* To obtain the builtin writer to be used for publishing SPDP, SEDP, /* To obtain the builtin writer to be used for publishing SPDP, SEDP,
PMD stuff for PP and its endpoints, given the entityid. If PP has PMD stuff for PP and its endpoints, given the entityid. If PP has
@ -480,9 +550,9 @@ struct writer *get_builtin_writer (const struct participant *pp, unsigned entity
GUID "ppguid". May return NULL if participant unknown or GUID "ppguid". May return NULL if participant unknown or
writer/reader already known. */ writer/reader already known. */
dds_retcode_t new_writer (struct writer **wr_out, struct nn_guid *wrguid, const struct nn_guid *group_guid, const struct nn_guid *ppguid, const struct ddsi_sertopic *topic, const struct nn_xqos *xqos, struct whc * whc, status_cb_t status_cb, void *status_cb_arg); dds_return_t new_writer (struct writer **wr_out, struct nn_guid *wrguid, const struct nn_guid *group_guid, const struct nn_guid *ppguid, const struct ddsi_sertopic *topic, const struct nn_xqos *xqos, struct whc * whc, status_cb_t status_cb, void *status_cb_arg);
dds_retcode_t new_reader (struct reader **rd_out, struct nn_guid *rdguid, const struct nn_guid *group_guid, const struct nn_guid *ppguid, const struct ddsi_sertopic *topic, const struct nn_xqos *xqos, struct rhc * rhc, status_cb_t status_cb, void *status_cb_arg); dds_return_t new_reader (struct reader **rd_out, struct nn_guid *rdguid, const struct nn_guid *group_guid, const struct nn_guid *ppguid, const struct ddsi_sertopic *topic, const struct nn_xqos *xqos, struct rhc * rhc, status_cb_t status_cb, void *status_cb_arg);
struct whc_node; struct whc_node;
struct whc_state; struct whc_state;

27
src/core/ddsi/include/dds/ddsi/q_error.h
View file

@ -1,27 +0,0 @@
/*
* Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
* v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#ifndef NN_ERROR_H
#define NN_ERROR_H
#define Q_ERR_UNSPECIFIED -1
#define Q_ERR_INVALID -2
#define Q_ERR_OUT_OF_MEMORY -3
#define Q_ERR_ENTITY_EXISTS -4
#define Q_ERR_UNKNOWN_ENTITY -5
#define Q_ERR_OUT_OF_IDS -6
#define Q_ERR_INVALID_DATA -7
#define Q_ERR_BUSY -8
#define Q_ERR_NO_ADDRESS -9
#define Q_ERR_TIMEOUT -10
#define Q_ERR_INCOMPATIBLE -11
#endif /* NN_ERROR_H */

74
src/core/ddsi/include/dds/ddsi/q_plist.h
View file

@ -196,24 +196,68 @@ DDS_EXPORT void nn_plist_init_empty (nn_plist_t *dest);
DDS_EXPORT void nn_plist_mergein_missing (nn_plist_t *a, const nn_plist_t *b); DDS_EXPORT void nn_plist_mergein_missing (nn_plist_t *a, const nn_plist_t *b);
DDS_EXPORT void nn_plist_copy (nn_plist_t *dst, const nn_plist_t *src); DDS_EXPORT void nn_plist_copy (nn_plist_t *dst, const nn_plist_t *src);
DDS_EXPORT nn_plist_t *nn_plist_dup (const nn_plist_t *src); DDS_EXPORT nn_plist_t *nn_plist_dup (const nn_plist_t *src);
DDS_EXPORT int nn_plist_init_frommsg (nn_plist_t *dest, char **nextafterplist, uint64_t pwanted, uint64_t qwanted, const nn_plist_src_t *src);
/**
* @brief Initialize an nn_plist_t from a PL_CDR_{LE,BE} paylaod.
*
* @param[in] pwanted
* PP_... flags indicating which non-QoS parameters are of interest, treated as
* a hint. Parameters in the input that are outside the mask may or may not be
* ignored.
* @param[in] qwanted
* QP_... flags indicating which QoS settings are of interest, and is treated as
* a hint. Parameters in the input that are outside the mask may or may not be
* ignored.
* @param[in] src
* Serialized payload to be parsed, validated and copied into dest
* - protocol_version is the version protocol version according to which the list
* should be parsed
* - vendorid is the vendor id code for the source of the parameter list (for
* handling vendor-specific parameters and compatibility workarounds)
* - encoding is PL_CDR_LE or PL_CDR_BE
* - buf is a pointer to the first parameter header
* - bufsz is the size in bytes of the input buffer
* @param[out] dest
* Filled with the recognized parameters in the input if successful, otherwise
* initialized to an empty parameter list. Where possible, pointers alias the
* input (indicated by the "aliased" bits in the plist/xqos structures), but
* some things cannot be aliased (e.g., the array of pointers to strings for a
* sequence of strings).
* Generally, nn_plist_fini should be called when done with the parameter list,
* even when nn_plist_unlias or nn_xqos_unlias hasn't been called.
* @param[out] nextafterplist
* If non-NULL, *nextafterplist is set to the first byte following the parameter
* list sentinel on successful parse, or to NULL on failure
*
* @returns A dds_return_t indicating success or failure.
*
* @retval DDS_RETCODE_OK
* All parameters valid (or ignored), dest and *nextafterplist have been set
* accordingly.
* @retval DDS_RETCODE_BAD_PARAMETER
* Input contained invalid data; dest is cleared, *nextafterplist is NULL.
* @retval DDS_RETCODE_UNSUPPORTED
* Input contained an unrecognized parameter with the "incompatible-if-unknown"
* flag set; dest is cleared, *nextafterplist is NULL.
*/
DDS_EXPORT dds_return_t nn_plist_init_frommsg (nn_plist_t *dest, char **nextafterplist, uint64_t pwanted, uint64_t qwanted, const nn_plist_src_t *src);
DDS_EXPORT void nn_plist_fini (nn_plist_t *ps); DDS_EXPORT void nn_plist_fini (nn_plist_t *ps);
DDS_EXPORT void nn_plist_addtomsg (struct nn_xmsg *m, const nn_plist_t *ps, uint64_t pwanted, uint64_t qwanted); DDS_EXPORT void nn_plist_addtomsg (struct nn_xmsg *m, const nn_plist_t *ps, uint64_t pwanted, uint64_t qwanted);
DDS_EXPORT int nn_plist_init_default_participant (nn_plist_t *plist); DDS_EXPORT void nn_plist_init_default_participant (nn_plist_t *plist);
DDS_EXPORT int validate_history_qospolicy (const nn_history_qospolicy_t *q); DDS_EXPORT dds_return_t validate_history_qospolicy (const nn_history_qospolicy_t *q);
DDS_EXPORT int validate_durability_qospolicy (const nn_durability_qospolicy_t *q); DDS_EXPORT dds_return_t validate_durability_qospolicy (const nn_durability_qospolicy_t *q);
DDS_EXPORT int validate_resource_limits_qospolicy (const nn_resource_limits_qospolicy_t *q); DDS_EXPORT dds_return_t validate_resource_limits_qospolicy (const nn_resource_limits_qospolicy_t *q);
DDS_EXPORT int validate_history_and_resource_limits (const nn_history_qospolicy_t *qh, const nn_resource_limits_qospolicy_t *qr); DDS_EXPORT dds_return_t validate_history_and_resource_limits (const nn_history_qospolicy_t *qh, const nn_resource_limits_qospolicy_t *qr);
DDS_EXPORT int validate_durability_service_qospolicy (const nn_durability_service_qospolicy_t *q); DDS_EXPORT dds_return_t validate_durability_service_qospolicy (const nn_durability_service_qospolicy_t *q);
DDS_EXPORT int validate_liveliness_qospolicy (const nn_liveliness_qospolicy_t *q); DDS_EXPORT dds_return_t validate_liveliness_qospolicy (const nn_liveliness_qospolicy_t *q);
DDS_EXPORT int validate_destination_order_qospolicy (const nn_destination_order_qospolicy_t *q); DDS_EXPORT dds_return_t validate_destination_order_qospolicy (const nn_destination_order_qospolicy_t *q);
DDS_EXPORT int validate_ownership_qospolicy (const nn_ownership_qospolicy_t *q); DDS_EXPORT dds_return_t validate_ownership_qospolicy (const nn_ownership_qospolicy_t *q);
DDS_EXPORT int validate_ownership_strength_qospolicy (const nn_ownership_strength_qospolicy_t *q); DDS_EXPORT dds_return_t validate_ownership_strength_qospolicy (const nn_ownership_strength_qospolicy_t *q);
DDS_EXPORT int validate_presentation_qospolicy (const nn_presentation_qospolicy_t *q); DDS_EXPORT dds_return_t validate_presentation_qospolicy (const nn_presentation_qospolicy_t *q);
DDS_EXPORT int validate_transport_priority_qospolicy (const nn_transport_priority_qospolicy_t *q); DDS_EXPORT dds_return_t validate_transport_priority_qospolicy (const nn_transport_priority_qospolicy_t *q);
DDS_EXPORT int validate_reader_data_lifecycle (const nn_reader_data_lifecycle_qospolicy_t *q); DDS_EXPORT dds_return_t validate_reader_data_lifecycle (const nn_reader_data_lifecycle_qospolicy_t *q);
DDS_EXPORT int validate_duration (const nn_duration_t *d); DDS_EXPORT dds_return_t validate_duration (const nn_duration_t *d);
struct nn_rmsg; struct nn_rmsg;

4
src/core/ddsi/include/dds/ddsi/q_thread.h
View file

@ -98,9 +98,9 @@ DDS_EXPORT void thread_states_fini (void);
DDS_EXPORT void upgrade_main_thread (void); DDS_EXPORT void upgrade_main_thread (void);
DDS_EXPORT void downgrade_main_thread (void); DDS_EXPORT void downgrade_main_thread (void);
DDS_EXPORT const struct config_thread_properties_listelem *lookup_thread_properties (const char *name); DDS_EXPORT const struct config_thread_properties_listelem *lookup_thread_properties (const char *name);
DDS_EXPORT dds_retcode_t create_thread (struct thread_state1 **ts, const char *name, uint32_t (*f) (void *arg), void *arg); DDS_EXPORT dds_return_t create_thread (struct thread_state1 **ts, const char *name, uint32_t (*f) (void *arg), void *arg);
DDS_EXPORT struct thread_state1 *lookup_thread_state_real (void); DDS_EXPORT struct thread_state1 *lookup_thread_state_real (void);
DDS_EXPORT int join_thread (struct thread_state1 *ts1); DDS_EXPORT dds_return_t join_thread (struct thread_state1 *ts1);
DDS_EXPORT void log_stack_traces (void); DDS_EXPORT void log_stack_traces (void);
DDS_EXPORT void reset_thread_state (struct thread_state1 *ts1); DDS_EXPORT void reset_thread_state (struct thread_state1 *ts1);
DDS_EXPORT int thread_exists (const char *name); DDS_EXPORT int thread_exists (const char *name);

2
src/core/ddsi/include/dds/ddsi/q_transmit.h
View file

@ -40,7 +40,7 @@ int write_sample_gc_notk (struct thread_state1 * const ts1, struct nn_xpack *xp,
int write_sample_nogc_notk (struct thread_state1 * const ts1, struct nn_xpack *xp, struct writer *wr, struct ddsi_serdata *serdata); int write_sample_nogc_notk (struct thread_state1 * const ts1, struct nn_xpack *xp, struct writer *wr, struct ddsi_serdata *serdata);
/* When calling the following functions, wr->lock must be held */ /* When calling the following functions, wr->lock must be held */
int create_fragment_message (struct writer *wr, seqno_t seq, const struct nn_plist *plist, struct ddsi_serdata *serdata, unsigned fragnum, struct proxy_reader *prd,struct nn_xmsg **msg, int isnew); dds_return_t create_fragment_message (struct writer *wr, seqno_t seq, const struct nn_plist *plist, struct ddsi_serdata *serdata, unsigned fragnum, struct proxy_reader *prd,struct nn_xmsg **msg, int isnew);
int enqueue_sample_wrlock_held (struct writer *wr, seqno_t seq, const struct nn_plist *plist, struct ddsi_serdata *serdata, struct proxy_reader *prd, int isnew); int enqueue_sample_wrlock_held (struct writer *wr, seqno_t seq, const struct nn_plist *plist, struct ddsi_serdata *serdata, struct proxy_reader *prd, int isnew);
void add_Heartbeat (struct nn_xmsg *msg, struct writer *wr, const struct whc_state *whcst, int hbansreq, nn_entityid_t dst, int issync); void add_Heartbeat (struct nn_xmsg *msg, struct writer *wr, const struct whc_state *whcst, int hbansreq, nn_entityid_t dst, int issync);

2
src/core/ddsi/include/dds/ddsi/q_xevent.h
View file

@ -42,7 +42,7 @@ struct xeventq *xeventq_new
/* xeventq_free calls callback handlers with t = T_NEVER, at which point they are required to free /* xeventq_free calls callback handlers with t = T_NEVER, at which point they are required to free
whatever memory is claimed for the argument and call delete_xevent. */ whatever memory is claimed for the argument and call delete_xevent. */
DDS_EXPORT void xeventq_free (struct xeventq *evq); DDS_EXPORT void xeventq_free (struct xeventq *evq);
DDS_EXPORT int xeventq_start (struct xeventq *evq, const char *name); /* <0 => error, =0 => ok */ DDS_EXPORT dds_return_t xeventq_start (struct xeventq *evq, const char *name); /* <0 => error, =0 => ok */
DDS_EXPORT void xeventq_stop (struct xeventq *evq); DDS_EXPORT void xeventq_stop (struct xeventq *evq);
DDS_EXPORT void qxev_msg (struct xeventq *evq, struct nn_xmsg *msg); DDS_EXPORT void qxev_msg (struct xeventq *evq, struct nn_xmsg *msg);

4
src/core/ddsi/include/dds/ddsi/q_xmsg.h
View file

@ -64,8 +64,8 @@ void nn_xmsg_setdst1 (struct nn_xmsg *m, const nn_guid_prefix_t *gp, const nn_lo
/* For sending to a particular proxy reader; this is a convenience /* For sending to a particular proxy reader; this is a convenience
routine that extracts a suitable address from the proxy reader's routine that extracts a suitable address from the proxy reader's
address sets and calls setdst1. */ address sets and calls setdst1. */
int nn_xmsg_setdstPRD (struct nn_xmsg *m, const struct proxy_reader *prd); dds_return_t nn_xmsg_setdstPRD (struct nn_xmsg *m, const struct proxy_reader *prd);
int nn_xmsg_setdstPWR (struct nn_xmsg *m, const struct proxy_writer *pwr); dds_return_t nn_xmsg_setdstPWR (struct nn_xmsg *m, const struct proxy_writer *pwr);
/* For sending to all in the address set AS -- typically, the writer's /* For sending to all in the address set AS -- typically, the writer's
address set to multicast to all matched readers */ address set to multicast to all matched readers */

7
src/core/ddsi/src/ddsi_raweth.c
View file

@ -16,7 +16,6 @@
#include "dds/ddsi/q_nwif.h" #include "dds/ddsi/q_nwif.h"
#include "dds/ddsi/q_config.h" #include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h" #include "dds/ddsi/q_log.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/q_pcap.h" #include "dds/ddsi/q_pcap.h"
#include "dds/ddsi/q_globals.h" #include "dds/ddsi/q_globals.h"
#include "dds/ddsrt/atomics.h" #include "dds/ddsrt/atomics.h"
@ -69,7 +68,7 @@ static char *ddsi_raweth_to_string (ddsi_tran_factory_t tran, char *dst, size_t
static ssize_t ddsi_raweth_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, size_t len, bool allow_spurious, nn_locator_t *srcloc) static ssize_t ddsi_raweth_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, size_t len, bool allow_spurious, nn_locator_t *srcloc)
{ {
dds_retcode_t rc; dds_return_t rc;
ssize_t ret = 0; ssize_t ret = 0;
struct msghdr msghdr; struct msghdr msghdr;
struct sockaddr_ll src; struct sockaddr_ll src;
@ -127,7 +126,7 @@ static ssize_t ddsi_raweth_conn_read (ddsi_tran_conn_t conn, unsigned char * buf
static ssize_t ddsi_raweth_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *dst, size_t niov, const ddsrt_iovec_t *iov, uint32_t flags) static ssize_t ddsi_raweth_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *dst, size_t niov, const ddsrt_iovec_t *iov, uint32_t flags)
{ {
ddsi_raweth_conn_t uc = (ddsi_raweth_conn_t) conn; ddsi_raweth_conn_t uc = (ddsi_raweth_conn_t) conn;
dds_retcode_t rc; dds_return_t rc;
ssize_t ret; ssize_t ret;
unsigned retry = 2; unsigned retry = 2;
int sendflags = 0; int sendflags = 0;
@ -191,7 +190,7 @@ static int ddsi_raweth_conn_locator (ddsi_tran_base_t base, nn_locator_t *loc)
static ddsi_tran_conn_t ddsi_raweth_create_conn (uint32_t port, ddsi_tran_qos_t qos) static ddsi_tran_conn_t ddsi_raweth_create_conn (uint32_t port, ddsi_tran_qos_t qos)
{ {
ddsrt_socket_t sock; ddsrt_socket_t sock;
dds_retcode_t rc; dds_return_t rc;
ddsi_raweth_conn_t uc = NULL; ddsi_raweth_conn_t uc = NULL;
struct sockaddr_ll addr; struct sockaddr_ll addr;
bool mcast = (bool) (qos ? qos->m_multicast : 0); bool mcast = (bool) (qos ? qos->m_multicast : 0);

4
src/core/ddsi/src/ddsi_ssl.c
View file

@ -63,7 +63,7 @@ static int ddsi_ssl_verify (int ok, X509_STORE_CTX *store)
return ok; return ok;
} }
static ssize_t ddsi_ssl_read (SSL *ssl, void *buf, size_t len, dds_retcode_t *rc) static ssize_t ddsi_ssl_read (SSL *ssl, void *buf, size_t len, dds_return_t *rc)
{ {
assert (len <= INT32_MAX); assert (len <= INT32_MAX);
if (SSL_get_shutdown (ssl) != 0) if (SSL_get_shutdown (ssl) != 0)
@ -95,7 +95,7 @@ static ssize_t ddsi_ssl_read (SSL *ssl, void *buf, size_t len, dds_retcode_t *rc
return rcvd; return rcvd;
} }
static ssize_t ddsi_ssl_write (SSL *ssl, const void *buf, size_t len, dds_retcode_t *rc) static ssize_t ddsi_ssl_write (SSL *ssl, const void *buf, size_t len, dds_return_t *rc)
{ {
assert(len <= INT32_MAX); assert(len <= INT32_MAX);

32
src/core/ddsi/src/ddsi_tcp.c
View file

@ -150,7 +150,7 @@ static unsigned short get_socket_port (ddsrt_socket_t socket)
{ {
struct sockaddr_storage addr; struct sockaddr_storage addr;
socklen_t addrlen = sizeof (addr); socklen_t addrlen = sizeof (addr);
dds_retcode_t ret; dds_return_t ret;
ret = ddsrt_getsockname(socket, (struct sockaddr *)&addr, &addrlen); ret = ddsrt_getsockname(socket, (struct sockaddr *)&addr, &addrlen);
if (ret != DDS_RETCODE_OK) { if (ret != DDS_RETCODE_OK) {
@ -197,7 +197,7 @@ static void ddsi_tcp_conn_connect (ddsi_tcp_conn_t conn, const ddsrt_msghdr_t *
{ {
char buff[DDSI_LOCSTRLEN]; char buff[DDSI_LOCSTRLEN];
ddsrt_socket_t sock; ddsrt_socket_t sock;
dds_retcode_t ret; dds_return_t ret;
ddsi_tcp_sock_new (&sock, 0); ddsi_tcp_sock_new (&sock, 0);
if (sock != DDSRT_INVALID_SOCKET) if (sock != DDSRT_INVALID_SOCKET)
@ -341,7 +341,7 @@ static ddsi_tcp_conn_t ddsi_tcp_cache_find (const ddsrt_msghdr_t * msg)
return ret; return ret;
} }
static ssize_t ddsi_tcp_conn_read_plain (ddsi_tcp_conn_t tcp, void * buf, size_t len, dds_retcode_t *rc) static ssize_t ddsi_tcp_conn_read_plain (ddsi_tcp_conn_t tcp, void * buf, size_t len, dds_return_t *rc)
{ {
ssize_t rcvd = -1; ssize_t rcvd = -1;
@ -352,7 +352,7 @@ static ssize_t ddsi_tcp_conn_read_plain (ddsi_tcp_conn_t tcp, void * buf, size_t
} }
#ifdef DDSI_INCLUDE_SSL #ifdef DDSI_INCLUDE_SSL
static ssize_t ddsi_tcp_conn_read_ssl (ddsi_tcp_conn_t tcp, void * buf, size_t len, dds_retcode_t *rc) static ssize_t ddsi_tcp_conn_read_ssl (ddsi_tcp_conn_t tcp, void * buf, size_t len, dds_return_t *rc)
{ {
return (ddsi_tcp_ssl_plugin.read) (tcp->m_ssl, buf, len, rc); return (ddsi_tcp_ssl_plugin.read) (tcp->m_ssl, buf, len, rc);
} }
@ -360,7 +360,7 @@ static ssize_t ddsi_tcp_conn_read_ssl (ddsi_tcp_conn_t tcp, void * buf, size_t l
static bool ddsi_tcp_select (ddsrt_socket_t sock, bool read, size_t pos) static bool ddsi_tcp_select (ddsrt_socket_t sock, bool read, size_t pos)
{ {
dds_retcode_t rc; dds_return_t rc;
fd_set fds; fd_set fds;
fd_set * rdset = read ? &fds : NULL; fd_set * rdset = read ? &fds : NULL;
fd_set * wrset = read ? NULL : &fds; fd_set * wrset = read ? NULL : &fds;
@ -395,9 +395,9 @@ static bool ddsi_tcp_select (ddsrt_socket_t sock, bool read, size_t pos)
static ssize_t ddsi_tcp_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, size_t len, bool allow_spurious, nn_locator_t *srcloc) static ssize_t ddsi_tcp_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, size_t len, bool allow_spurious, nn_locator_t *srcloc)
{ {
dds_retcode_t rc; dds_return_t rc;
ddsi_tcp_conn_t tcp = (ddsi_tcp_conn_t) conn; ddsi_tcp_conn_t tcp = (ddsi_tcp_conn_t) conn;
ssize_t (*rd) (ddsi_tcp_conn_t, void *, size_t, dds_retcode_t * err) = ddsi_tcp_conn_read_plain; ssize_t (*rd) (ddsi_tcp_conn_t, void *, size_t, dds_return_t * err) = ddsi_tcp_conn_read_plain;
size_t pos = 0; size_t pos = 0;
ssize_t n; ssize_t n;
@ -452,7 +452,7 @@ static ssize_t ddsi_tcp_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, s
return -1; return -1;
} }
static ssize_t ddsi_tcp_conn_write_plain (ddsi_tcp_conn_t conn, const void * buf, size_t len, dds_retcode_t *rc) static ssize_t ddsi_tcp_conn_write_plain (ddsi_tcp_conn_t conn, const void * buf, size_t len, dds_return_t *rc)
{ {
ssize_t sent = -1; ssize_t sent = -1;
int sendflags = 0; int sendflags = 0;
@ -466,7 +466,7 @@ static ssize_t ddsi_tcp_conn_write_plain (ddsi_tcp_conn_t conn, const void * buf
} }
#ifdef DDSI_INCLUDE_SSL #ifdef DDSI_INCLUDE_SSL
static ssize_t ddsi_tcp_conn_write_ssl (ddsi_tcp_conn_t conn, const void * buf, size_t len, dds_retcode_t *rc) static ssize_t ddsi_tcp_conn_write_ssl (ddsi_tcp_conn_t conn, const void * buf, size_t len, dds_return_t *rc)
{ {
return (ddsi_tcp_ssl_plugin.write) (conn->m_ssl, buf, len, rc); return (ddsi_tcp_ssl_plugin.write) (conn->m_ssl, buf, len, rc);
} }
@ -474,7 +474,7 @@ static ssize_t ddsi_tcp_conn_write_ssl (ddsi_tcp_conn_t conn, const void * buf,
static ssize_t ddsi_tcp_block_write static ssize_t ddsi_tcp_block_write
( (
ssize_t (*wr) (ddsi_tcp_conn_t, const void *, size_t, dds_retcode_t *), ssize_t (*wr) (ddsi_tcp_conn_t, const void *, size_t, dds_return_t *),
ddsi_tcp_conn_t conn, ddsi_tcp_conn_t conn,
const void * buf, const void * buf,
size_t sz size_t sz
@ -482,7 +482,7 @@ static ssize_t ddsi_tcp_block_write
{ {
/* Write all bytes of buf even in the presence of signals, /* Write all bytes of buf even in the presence of signals,
partial writes and blocking (typically write buffer full) */ partial writes and blocking (typically write buffer full) */
dds_retcode_t rc; dds_return_t rc;
size_t pos = 0; size_t pos = 0;
ssize_t n = -1; ssize_t n = -1;
@ -615,7 +615,7 @@ static ssize_t ddsi_tcp_conn_write (ddsi_tran_conn_t base, const nn_locator_t *d
#endif #endif
{ {
int sendflags = 0; int sendflags = 0;
dds_retcode_t rc; dds_return_t rc;
#ifdef MSG_NOSIGNAL #ifdef MSG_NOSIGNAL
sendflags |= MSG_NOSIGNAL; sendflags |= MSG_NOSIGNAL;
#endif #endif
@ -661,7 +661,7 @@ static ssize_t ddsi_tcp_conn_write (ddsi_tran_conn_t base, const nn_locator_t *d
if (piecewise) if (piecewise)
{ {
ssize_t (*wr) (ddsi_tcp_conn_t, const void *, size_t, dds_retcode_t *) = ddsi_tcp_conn_write_plain; ssize_t (*wr) (ddsi_tcp_conn_t, const void *, size_t, dds_return_t *) = ddsi_tcp_conn_write_plain;
int i = 0; int i = 0;
#ifdef DDSI_INCLUDE_SSL #ifdef DDSI_INCLUDE_SSL
if (ddsi_tcp_ssl_plugin.write) if (ddsi_tcp_ssl_plugin.write)
@ -749,7 +749,7 @@ static ddsi_tran_conn_t ddsi_tcp_accept (ddsi_tran_listener_t listener)
struct sockaddr_storage addr; struct sockaddr_storage addr;
socklen_t addrlen = sizeof (addr); socklen_t addrlen = sizeof (addr);
char buff[DDSI_LOCSTRLEN]; char buff[DDSI_LOCSTRLEN];
dds_retcode_t rc = DDS_RETCODE_OK; dds_return_t rc = DDS_RETCODE_OK;
#ifdef DDSI_INCLUDE_SSL #ifdef DDSI_INCLUDE_SSL
SSL * ssl = NULL; SSL * ssl = NULL;
#endif #endif
@ -875,7 +875,7 @@ static ddsi_tran_listener_t ddsi_tcp_create_listener (int port, ddsi_tran_qos_t
if (sock != DDSRT_INVALID_SOCKET) if (sock != DDSRT_INVALID_SOCKET)
{ {
dds_retcode_t ret; dds_return_t ret;
tl = (ddsi_tcp_listener_t) ddsrt_malloc (sizeof (*tl)); tl = (ddsi_tcp_listener_t) ddsrt_malloc (sizeof (*tl));
memset (tl, 0, sizeof (*tl)); memset (tl, 0, sizeof (*tl));
@ -953,7 +953,7 @@ static void ddsi_tcp_unblock_listener (ddsi_tran_listener_t listener)
{ {
ddsi_tcp_listener_t tl = (ddsi_tcp_listener_t) listener; ddsi_tcp_listener_t tl = (ddsi_tcp_listener_t) listener;
ddsrt_socket_t sock; ddsrt_socket_t sock;
dds_retcode_t ret; dds_return_t ret;
/* Connect to own listener socket to wake listener from blocking 'accept()' */ /* Connect to own listener socket to wake listener from blocking 'accept()' */
ddsi_tcp_sock_new (&sock, 0); ddsi_tcp_sock_new (&sock, 0);

5
src/core/ddsi/src/ddsi_threadmon.c
View file

@ -21,7 +21,6 @@
#include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_thread.h"
#include "dds/ddsi/q_time.h" #include "dds/ddsi/q_time.h"
#include "dds/ddsi/q_unused.h" #include "dds/ddsi/q_unused.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/q_globals.h" /* for mattr, cattr */ #include "dds/ddsi/q_globals.h" /* for mattr, cattr */
#include "dds/ddsi/q_receive.h" #include "dds/ddsi/q_receive.h"
@ -166,7 +165,7 @@ struct ddsi_threadmon *ddsi_threadmon_new (void)
return NULL; return NULL;
} }
int ddsi_threadmon_start (struct ddsi_threadmon *sl) dds_return_t ddsi_threadmon_start (struct ddsi_threadmon *sl)
{ {
ddsrt_mutex_lock (&sl->lock); ddsrt_mutex_lock (&sl->lock);
assert (sl->keepgoing == -1); assert (sl->keepgoing == -1);
@ -179,7 +178,7 @@ int ddsi_threadmon_start (struct ddsi_threadmon *sl)
fail_thread: fail_thread:
sl->keepgoing = -1; sl->keepgoing = -1;
return Q_ERR_UNSPECIFIED; return DDS_RETCODE_ERROR;
} }
void ddsi_threadmon_statechange_barrier (struct ddsi_threadmon *sl) void ddsi_threadmon_statechange_barrier (struct ddsi_threadmon *sl)

12
src/core/ddsi/src/ddsi_udp.c
View file

@ -54,7 +54,7 @@ static ddsrt_atomic_uint32_t ddsi_udp_init_g = DDSRT_ATOMIC_UINT32_INIT(0);
static ssize_t ddsi_udp_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, size_t len, bool allow_spurious, nn_locator_t *srcloc) static ssize_t ddsi_udp_conn_read (ddsi_tran_conn_t conn, unsigned char * buf, size_t len, bool allow_spurious, nn_locator_t *srcloc)
{ {
dds_retcode_t rc; dds_return_t rc;
ssize_t ret = 0; ssize_t ret = 0;
ddsrt_msghdr_t msghdr; ddsrt_msghdr_t msghdr;
struct sockaddr_storage src; struct sockaddr_storage src;
@ -117,7 +117,7 @@ static void set_msghdr_iov (ddsrt_msghdr_t *mhdr, ddsrt_iovec_t *iov, size_t iov
static ssize_t ddsi_udp_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *dst, size_t niov, const ddsrt_iovec_t *iov, uint32_t flags) static ssize_t ddsi_udp_conn_write (ddsi_tran_conn_t conn, const nn_locator_t *dst, size_t niov, const ddsrt_iovec_t *iov, uint32_t flags)
{ {
dds_retcode_t rc; dds_return_t rc;
ssize_t ret = -1; ssize_t ret = -1;
unsigned retry = 2; unsigned retry = 2;
int sendflags = 0; int sendflags = 0;
@ -214,7 +214,7 @@ static int ddsi_udp_conn_locator (ddsi_tran_base_t base, nn_locator_t *loc)
static unsigned short get_socket_port (ddsrt_socket_t socket) static unsigned short get_socket_port (ddsrt_socket_t socket)
{ {
dds_retcode_t ret; dds_return_t ret;
struct sockaddr_storage addr; struct sockaddr_storage addr;
socklen_t addrlen = sizeof (addr); socklen_t addrlen = sizeof (addr);
@ -282,7 +282,7 @@ static ddsi_tran_conn_t ddsi_udp_create_conn
#ifdef DDSI_INCLUDE_NETWORK_CHANNELS #ifdef DDSI_INCLUDE_NETWORK_CHANNELS
if ((uc->m_diffserv != 0) && (ddsi_udp_factory_g.m_kind == NN_LOCATOR_KIND_UDPv4)) if ((uc->m_diffserv != 0) && (ddsi_udp_factory_g.m_kind == NN_LOCATOR_KIND_UDPv4))
{ {
dds_retcode_t rc; dds_return_t rc;
rc = ddsrt_setsockopt(sock, IPPROTO_IP, IP_TOS, (char *)&uc->m_diffserv, sizeof(uc->m_diffserv)); rc = ddsrt_setsockopt(sock, IPPROTO_IP, IP_TOS, (char *)&uc->m_diffserv, sizeof(uc->m_diffserv));
if (rc != DDS_RETCODE_OK) if (rc != DDS_RETCODE_OK)
DDS_ERROR("ddsi_udp_create_conn: set diffserv retcode %"PRId32"\n", rc); DDS_ERROR("ddsi_udp_create_conn: set diffserv retcode %"PRId32"\n", rc);
@ -307,7 +307,7 @@ static ddsi_tran_conn_t ddsi_udp_create_conn
static int joinleave_asm_mcgroup (ddsrt_socket_t socket, int join, const nn_locator_t *mcloc, const struct nn_interface *interf) static int joinleave_asm_mcgroup (ddsrt_socket_t socket, int join, const nn_locator_t *mcloc, const struct nn_interface *interf)
{ {
dds_retcode_t rc; dds_return_t rc;
struct sockaddr_storage mcip; struct sockaddr_storage mcip;
ddsi_ipaddr_from_loc(&mcip, mcloc); ddsi_ipaddr_from_loc(&mcip, mcloc);
#if DDSRT_HAVE_IPV6 #if DDSRT_HAVE_IPV6
@ -336,7 +336,7 @@ static int joinleave_asm_mcgroup (ddsrt_socket_t socket, int join, const nn_loca
#ifdef DDSI_INCLUDE_SSM #ifdef DDSI_INCLUDE_SSM
static int joinleave_ssm_mcgroup (ddsrt_socket_t socket, int join, const nn_locator_t *srcloc, const nn_locator_t *mcloc, const struct nn_interface *interf) static int joinleave_ssm_mcgroup (ddsrt_socket_t socket, int join, const nn_locator_t *srcloc, const nn_locator_t *mcloc, const struct nn_interface *interf)
{ {
dds_retcode_t rc; dds_return_t rc;
struct sockaddr_storage mcip, srcip; struct sockaddr_storage mcip, srcip;
ddsi_ipaddr_from_loc(&mcip, mcloc); ddsi_ipaddr_from_loc(&mcip, mcloc);
ddsi_ipaddr_from_loc(&srcip, srcloc); ddsi_ipaddr_from_loc(&srcip, srcloc);

1
src/core/ddsi/src/q_config.c
View file

@ -31,7 +31,6 @@
#include "dds/ddsi/q_misc.h" #include "dds/ddsi/q_misc.h"
#include "dds/ddsi/q_addrset.h" #include "dds/ddsi/q_addrset.h"
#include "dds/ddsi/q_nwif.h" #include "dds/ddsi/q_nwif.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsrt/xmlparser.h" #include "dds/ddsrt/xmlparser.h"

21
src/core/ddsi/src/q_ddsi_discovery.c
View file

@ -40,7 +40,6 @@
#include "dds/ddsi/q_bswap.h" #include "dds/ddsi/q_bswap.h"
#include "dds/ddsi/q_transmit.h" #include "dds/ddsi/q_transmit.h"
#include "dds/ddsi/q_lease.h" #include "dds/ddsi/q_lease.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/ddsi_serdata_default.h" #include "dds/ddsi/ddsi_serdata_default.h"
#include "dds/ddsi/q_feature_check.h" #include "dds/ddsi/q_feature_check.h"
@ -793,7 +792,7 @@ static void handle_SPDP (const struct receiver_state *rst, nn_wctime_t timestamp
nn_plist_t decoded_data; nn_plist_t decoded_data;
nn_plist_src_t src; nn_plist_src_t src;
int interesting = 0; int interesting = 0;
int plist_ret; dds_return_t plist_ret;
src.protocol_version = rst->protocol_version; src.protocol_version = rst->protocol_version;
src.vendorid = rst->vendor; src.vendorid = rst->vendor;
src.encoding = data->identifier; src.encoding = data->identifier;
@ -801,7 +800,7 @@ static void handle_SPDP (const struct receiver_state *rst, nn_wctime_t timestamp
src.bufsz = len - 4; src.bufsz = len - 4;
if ((plist_ret = nn_plist_init_frommsg (&decoded_data, NULL, ~(uint64_t)0, ~(uint64_t)0, &src)) < 0) if ((plist_ret = nn_plist_init_frommsg (&decoded_data, NULL, ~(uint64_t)0, ~(uint64_t)0, &src)) < 0)
{ {
if (plist_ret != Q_ERR_INCOMPATIBLE) if (plist_ret != DDS_RETCODE_UNSUPPORTED)
DDS_WARNING("SPDP (vendor %u.%u): invalid qos/parameters\n", src.vendorid.id[0], src.vendorid.id[1]); DDS_WARNING("SPDP (vendor %u.%u): invalid qos/parameters\n", src.vendorid.id[0], src.vendorid.id[1]);
return; return;
} }
@ -1335,7 +1334,7 @@ static void handle_SEDP (const struct receiver_state *rst, nn_wctime_t timestamp
{ {
nn_plist_t decoded_data; nn_plist_t decoded_data;
nn_plist_src_t src; nn_plist_src_t src;
int plist_ret; dds_return_t plist_ret;
src.protocol_version = rst->protocol_version; src.protocol_version = rst->protocol_version;
src.vendorid = rst->vendor; src.vendorid = rst->vendor;
src.encoding = data->identifier; src.encoding = data->identifier;
@ -1343,7 +1342,7 @@ static void handle_SEDP (const struct receiver_state *rst, nn_wctime_t timestamp
src.bufsz = len - 4; src.bufsz = len - 4;
if ((plist_ret = nn_plist_init_frommsg (&decoded_data, NULL, ~(uint64_t)0, ~(uint64_t)0, &src)) < 0) if ((plist_ret = nn_plist_init_frommsg (&decoded_data, NULL, ~(uint64_t)0, ~(uint64_t)0, &src)) < 0)
{ {
if (plist_ret != Q_ERR_INCOMPATIBLE) if (plist_ret != DDS_RETCODE_UNSUPPORTED)
DDS_WARNING("SEDP (vendor %u.%u): invalid qos/parameters\n", src.vendorid.id[0], src.vendorid.id[1]); DDS_WARNING("SEDP (vendor %u.%u): invalid qos/parameters\n", src.vendorid.id[0], src.vendorid.id[1]);
return; return;
} }
@ -1463,7 +1462,7 @@ static void handle_SEDP_CM (const struct receiver_state *rst, nn_entityid_t wr_e
{ {
nn_plist_t decoded_data; nn_plist_t decoded_data;
nn_plist_src_t src; nn_plist_src_t src;
int plist_ret; dds_return_t plist_ret;
src.protocol_version = rst->protocol_version; src.protocol_version = rst->protocol_version;
src.vendorid = rst->vendor; src.vendorid = rst->vendor;
src.encoding = data->identifier; src.encoding = data->identifier;
@ -1471,7 +1470,7 @@ static void handle_SEDP_CM (const struct receiver_state *rst, nn_entityid_t wr_e
src.bufsz = len - 4; src.bufsz = len - 4;
if ((plist_ret = nn_plist_init_frommsg (&decoded_data, NULL, ~(uint64_t)0, ~(uint64_t)0, &src)) < 0) if ((plist_ret = nn_plist_init_frommsg (&decoded_data, NULL, ~(uint64_t)0, ~(uint64_t)0, &src)) < 0)
{ {
if (plist_ret != Q_ERR_INCOMPATIBLE) if (plist_ret != DDS_RETCODE_UNSUPPORTED)
DDS_WARNING("SEDP_CM (vendor %u.%u): invalid qos/parameters\n", src.vendorid.id[0], src.vendorid.id[1]); DDS_WARNING("SEDP_CM (vendor %u.%u): invalid qos/parameters\n", src.vendorid.id[0], src.vendorid.id[1]);
return; return;
} }
@ -1625,7 +1624,7 @@ static void handle_SEDP_GROUP (const struct receiver_state *rst, nn_wctime_t tim
{ {
nn_plist_t decoded_data; nn_plist_t decoded_data;
nn_plist_src_t src; nn_plist_src_t src;
int plist_ret; dds_return_t plist_ret;
src.protocol_version = rst->protocol_version; src.protocol_version = rst->protocol_version;
src.vendorid = rst->vendor; src.vendorid = rst->vendor;
src.encoding = data->identifier; src.encoding = data->identifier;
@ -1633,7 +1632,7 @@ static void handle_SEDP_GROUP (const struct receiver_state *rst, nn_wctime_t tim
src.bufsz = len - 4; src.bufsz = len - 4;
if ((plist_ret = nn_plist_init_frommsg (&decoded_data, NULL, ~(uint64_t)0, ~(uint64_t)0, &src)) < 0) if ((plist_ret = nn_plist_init_frommsg (&decoded_data, NULL, ~(uint64_t)0, ~(uint64_t)0, &src)) < 0)
{ {
if (plist_ret != Q_ERR_INCOMPATIBLE) if (plist_ret != DDS_RETCODE_UNSUPPORTED)
DDS_WARNING("SEDP_GROUP (vendor %u.%u): invalid qos/parameters\n", src.vendorid.id[0], src.vendorid.id[1]); DDS_WARNING("SEDP_GROUP (vendor %u.%u): invalid qos/parameters\n", src.vendorid.id[0], src.vendorid.id[1]);
return; return;
} }
@ -1748,7 +1747,7 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str
{ {
nn_plist_src_t src; nn_plist_src_t src;
size_t qos_offset = NN_RDATA_SUBMSG_OFF (fragchain) + offsetof (Data_DataFrag_common_t, octetsToInlineQos) + sizeof (msg->octetsToInlineQos) + msg->octetsToInlineQos; size_t qos_offset = NN_RDATA_SUBMSG_OFF (fragchain) + offsetof (Data_DataFrag_common_t, octetsToInlineQos) + sizeof (msg->octetsToInlineQos) + msg->octetsToInlineQos;
int plist_ret; dds_return_t plist_ret;
src.protocol_version = sampleinfo->rst->protocol_version; src.protocol_version = sampleinfo->rst->protocol_version;
src.vendorid = sampleinfo->rst->vendor; src.vendorid = sampleinfo->rst->vendor;
src.encoding = (msg->smhdr.flags & SMFLAG_ENDIANNESS) ? PL_CDR_LE : PL_CDR_BE; src.encoding = (msg->smhdr.flags & SMFLAG_ENDIANNESS) ? PL_CDR_LE : PL_CDR_BE;
@ -1756,7 +1755,7 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str
src.bufsz = NN_RDATA_PAYLOAD_OFF (fragchain) - qos_offset; src.bufsz = NN_RDATA_PAYLOAD_OFF (fragchain) - qos_offset;
if ((plist_ret = nn_plist_init_frommsg (&qos, NULL, PP_STATUSINFO | PP_KEYHASH, 0, &src)) < 0) if ((plist_ret = nn_plist_init_frommsg (&qos, NULL, PP_STATUSINFO | PP_KEYHASH, 0, &src)) < 0)
{ {
if (plist_ret != Q_ERR_INCOMPATIBLE) if (plist_ret != DDS_RETCODE_UNSUPPORTED)
DDS_WARNING("data(builtin, vendor %u.%u): "PGUIDFMT" #%"PRId64": invalid inline qos\n", DDS_WARNING("data(builtin, vendor %u.%u): "PGUIDFMT" #%"PRId64": invalid inline qos\n",
src.vendorid.id[0], src.vendorid.id[1], PGUID (srcguid), sampleinfo->seq); src.vendorid.id[0], src.vendorid.id[1], PGUID (srcguid), sampleinfo->seq);
goto done_upd_deliv; goto done_upd_deliv;

1
src/core/ddsi/src/q_debmon.c
View file

@ -33,7 +33,6 @@
#include "dds/ddsi/q_ddsi_discovery.h" #include "dds/ddsi/q_ddsi_discovery.h"
#include "dds/ddsi/q_protocol.h" /* NN_ENTITYID_... */ #include "dds/ddsi/q_protocol.h" /* NN_ENTITYID_... */
#include "dds/ddsi/q_unused.h" #include "dds/ddsi/q_unused.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/q_debmon.h" #include "dds/ddsi/q_debmon.h"
#include "dds/ddsi/ddsi_serdata.h" #include "dds/ddsi/ddsi_serdata.h"
#include "dds/ddsi/ddsi_tran.h" #include "dds/ddsi/ddsi_tran.h"

69
src/core/ddsi/src/q_entity.c
View file

@ -38,7 +38,6 @@
#include "dds/ddsi/q_radmin.h" #include "dds/ddsi/q_radmin.h"
#include "dds/ddsi/q_protocol.h" /* NN_ENTITYID_... */ #include "dds/ddsi/q_protocol.h" /* NN_ENTITYID_... */
#include "dds/ddsi/q_unused.h" #include "dds/ddsi/q_unused.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/ddsi_serdata_default.h" #include "dds/ddsi/ddsi_serdata_default.h"
#include "dds/ddsi/ddsi_mcgroup.h" #include "dds/ddsi/ddsi_mcgroup.h"
#include "dds/ddsi/q_receive.h" #include "dds/ddsi/q_receive.h"
@ -88,8 +87,8 @@ static const unsigned prismtech_builtin_writers_besmask =
NN_DISC_BUILTIN_ENDPOINT_CM_PUBLISHER_WRITER | NN_DISC_BUILTIN_ENDPOINT_CM_PUBLISHER_WRITER |
NN_DISC_BUILTIN_ENDPOINT_CM_SUBSCRIBER_WRITER; NN_DISC_BUILTIN_ENDPOINT_CM_SUBSCRIBER_WRITER;
static dds_retcode_t new_writer_guid (struct writer **wr_out, const struct nn_guid *guid, const struct nn_guid *group_guid, struct participant *pp, const struct ddsi_sertopic *topic, const struct nn_xqos *xqos, struct whc *whc, status_cb_t status_cb, void *status_cbarg); static dds_return_t new_writer_guid (struct writer **wr_out, const struct nn_guid *guid, const struct nn_guid *group_guid, struct participant *pp, const struct ddsi_sertopic *topic, const struct nn_xqos *xqos, struct whc *whc, status_cb_t status_cb, void *status_cbarg);
static dds_retcode_t new_reader_guid (struct reader **rd_out, const struct nn_guid *guid, const struct nn_guid *group_guid, struct participant *pp, const struct ddsi_sertopic *topic, const struct nn_xqos *xqos, struct rhc *rhc, status_cb_t status_cb, void *status_cbarg); static dds_return_t new_reader_guid (struct reader **rd_out, const struct nn_guid *guid, const struct nn_guid *group_guid, struct participant *pp, const struct ddsi_sertopic *topic, const struct nn_xqos *xqos, struct rhc *rhc, status_cb_t status_cb, void *status_cbarg);
static struct participant *ref_participant (struct participant *pp, const struct nn_guid *guid_of_refing_entity); static struct participant *ref_participant (struct participant *pp, const struct nn_guid *guid_of_refing_entity);
static void unref_participant (struct participant *pp, const struct nn_guid *guid_of_refing_entity); static void unref_participant (struct participant *pp, const struct nn_guid *guid_of_refing_entity);
static void delete_proxy_group_locked (struct proxy_group *pgroup, nn_wctime_t timestamp, int isimplicit); static void delete_proxy_group_locked (struct proxy_group *pgroup, nn_wctime_t timestamp, int isimplicit);
@ -376,7 +375,7 @@ static void remove_deleted_participant_guid (const struct nn_guid *guid, unsigne
/* PARTICIPANT ------------------------------------------------------ */ /* PARTICIPANT ------------------------------------------------------ */
int pp_allocate_entityid(nn_entityid_t *id, unsigned kind, struct participant *pp) static dds_return_t pp_allocate_entityid(nn_entityid_t *id, unsigned kind, struct participant *pp)
{ {
uint32_t id1; uint32_t id1;
int ret = 0; int ret = 0;
@ -389,20 +388,20 @@ int pp_allocate_entityid(nn_entityid_t *id, unsigned kind, struct participant *p
else else
{ {
DDS_ERROR("pp_allocate_entityid("PGUIDFMT"): all ids in use\n", PGUID(pp->e.guid)); DDS_ERROR("pp_allocate_entityid("PGUIDFMT"): all ids in use\n", PGUID(pp->e.guid));
ret = Q_ERR_OUT_OF_IDS; ret = DDS_RETCODE_OUT_OF_RESOURCES;
} }
ddsrt_mutex_unlock (&pp->e.lock); ddsrt_mutex_unlock (&pp->e.lock);
return ret; return ret;
} }
void pp_release_entityid(struct participant *pp, nn_entityid_t id) static void pp_release_entityid(struct participant *pp, nn_entityid_t id)
{ {
ddsrt_mutex_lock (&pp->e.lock); ddsrt_mutex_lock (&pp->e.lock);
inverse_uint32_set_free(&pp->avail_entityids.x, id.u / NN_ENTITYID_ALLOCSTEP); inverse_uint32_set_free(&pp->avail_entityids.x, id.u / NN_ENTITYID_ALLOCSTEP);
ddsrt_mutex_unlock (&pp->e.lock); ddsrt_mutex_unlock (&pp->e.lock);
} }
int new_participant_guid (const nn_guid_t *ppguid, unsigned flags, const nn_plist_t *plist) dds_return_t new_participant_guid (const nn_guid_t *ppguid, unsigned flags, const nn_plist_t *plist)
{ {
struct participant *pp; struct participant *pp;
nn_guid_t subguid, group_guid; nn_guid_t subguid, group_guid;
@ -420,7 +419,7 @@ int new_participant_guid (const nn_guid_t *ppguid, unsigned flags, const nn_plis
used to exist, but is currently being deleted and we're trying to used to exist, but is currently being deleted and we're trying to
recreate it. */ recreate it. */
if (ephash_lookup_participant_guid (ppguid) != NULL) if (ephash_lookup_participant_guid (ppguid) != NULL)
return Q_ERR_ENTITY_EXISTS; return DDS_RETCODE_PRECONDITION_NOT_MET;
if (config.max_participants == 0) if (config.max_participants == 0)
{ {
@ -440,7 +439,7 @@ int new_participant_guid (const nn_guid_t *ppguid, unsigned flags, const nn_plis
{ {
ddsrt_mutex_unlock (&gv.participant_set_lock); ddsrt_mutex_unlock (&gv.participant_set_lock);
DDS_ERROR("new_participant("PGUIDFMT", %x) failed: max participants reached\n", PGUID (*ppguid), flags); DDS_ERROR("new_participant("PGUIDFMT", %x) failed: max participants reached\n", PGUID (*ppguid), flags);
return Q_ERR_OUT_OF_IDS; return DDS_RETCODE_OUT_OF_RESOURCES;
} }
} }
@ -658,7 +657,7 @@ int new_participant_guid (const nn_guid_t *ppguid, unsigned flags, const nn_plis
return 0; return 0;
} }
int new_participant (nn_guid_t *p_ppguid, unsigned flags, const nn_plist_t *plist) dds_return_t new_participant (nn_guid_t *p_ppguid, unsigned flags, const nn_plist_t *plist)
{ {
nn_guid_t ppguid; nn_guid_t ppguid;
@ -667,7 +666,7 @@ int new_participant (nn_guid_t *p_ppguid, unsigned flags, const nn_plist_t *plis
if (gv.next_ppguid.prefix.u[2]++ == ~0u) if (gv.next_ppguid.prefix.u[2]++ == ~0u)
{ {
ddsrt_mutex_unlock (&gv.privileged_pp_lock); ddsrt_mutex_unlock (&gv.privileged_pp_lock);
return Q_ERR_OUT_OF_IDS; return DDS_RETCODE_OUT_OF_RESOURCES;
} }
ddsrt_mutex_unlock (&gv.privileged_pp_lock); ddsrt_mutex_unlock (&gv.privileged_pp_lock);
*p_ppguid = ppguid; *p_ppguid = ppguid;
@ -858,11 +857,11 @@ static void gc_delete_participant (struct gcreq *gcreq)
unref_participant (pp, NULL); unref_participant (pp, NULL);
} }
int delete_participant (const struct nn_guid *ppguid) dds_return_t delete_participant (const struct nn_guid *ppguid)
{ {
struct participant *pp; struct participant *pp;
if ((pp = ephash_lookup_participant_guid (ppguid)) == NULL) if ((pp = ephash_lookup_participant_guid (ppguid)) == NULL)
return Q_ERR_UNKNOWN_ENTITY; return DDS_RETCODE_BAD_PARAMETER;
ddsi_plugin.builtintopic_write (&pp->e, now(), false); ddsi_plugin.builtintopic_write (&pp->e, now(), false);
remember_deleted_participant_guid (&pp->e.guid); remember_deleted_participant_guid (&pp->e.guid);
ephash_remove_participant_guid (pp); ephash_remove_participant_guid (pp);
@ -2821,7 +2820,7 @@ static void new_writer_guid_common_init (struct writer *wr, const struct ddsi_se
local_reader_ary_init (&wr->rdary); local_reader_ary_init (&wr->rdary);
} }
static dds_retcode_t new_writer_guid (struct writer **wr_out, const struct nn_guid *guid, const struct nn_guid *group_guid, struct participant *pp, const struct ddsi_sertopic *topic, const struct nn_xqos *xqos, struct whc *whc, status_cb_t status_cb, void *status_entity) static dds_return_t new_writer_guid (struct writer **wr_out, const struct nn_guid *guid, const struct nn_guid *group_guid, struct participant *pp, const struct ddsi_sertopic *topic, const struct nn_xqos *xqos, struct whc *whc, status_cb_t status_cb, void *status_entity)
{ {
struct writer *wr; struct writer *wr;
nn_mtime_t tnow = now_mt (); nn_mtime_t tnow = now_mt ();
@ -2868,24 +2867,25 @@ static dds_retcode_t new_writer_guid (struct writer **wr_out, const struct nn_gu
resched_xevent_if_earlier (pp->pmd_update_xevent, tsched); resched_xevent_if_earlier (pp->pmd_update_xevent, tsched);
} }
return DDS_RETCODE_OK; return 0;
} }
dds_retcode_t new_writer (struct writer **wr_out, struct nn_guid *wrguid, const struct nn_guid *group_guid, const struct nn_guid *ppguid, const struct ddsi_sertopic *topic, const struct nn_xqos *xqos, struct whc * whc, status_cb_t status_cb, void *status_cb_arg) dds_return_t new_writer (struct writer **wr_out, struct nn_guid *wrguid, const struct nn_guid *group_guid, const struct nn_guid *ppguid, const struct ddsi_sertopic *topic, const struct nn_xqos *xqos, struct whc * whc, status_cb_t status_cb, void *status_cb_arg)
{ {
struct participant *pp; struct participant *pp;
dds_return_t rc;
if ((pp = ephash_lookup_participant_guid (ppguid)) == NULL) if ((pp = ephash_lookup_participant_guid (ppguid)) == NULL)
{ {
DDS_LOG(DDS_LC_DISCOVERY, "new_writer - participant "PGUIDFMT" not found\n", PGUID (*ppguid)); DDS_LOG(DDS_LC_DISCOVERY, "new_writer - participant "PGUIDFMT" not found\n", PGUID (*ppguid));
return DDS_RETCODE_NOT_FOUND; return DDS_RETCODE_BAD_PARAMETER;
} }
/* participant can't be freed while we're mucking around cos we are /* participant can't be freed while we're mucking around cos we are
awake and do not touch the thread's vtime (ephash_lookup already awake and do not touch the thread's vtime (ephash_lookup already
verifies we're awake) */ verifies we're awake) */
wrguid->prefix = pp->e.guid.prefix; wrguid->prefix = pp->e.guid.prefix;
if (pp_allocate_entityid (&wrguid->entityid, NN_ENTITYID_KIND_WRITER_WITH_KEY, pp) < 0) if ((rc = pp_allocate_entityid (&wrguid->entityid, NN_ENTITYID_KIND_WRITER_WITH_KEY, pp)) < 0)
return DDS_RETCODE_OUT_OF_RESOURCES; return rc;
return new_writer_guid (wr_out, wrguid, group_guid, pp, topic, xqos, whc, status_cb, status_cb_arg); return new_writer_guid (wr_out, wrguid, group_guid, pp, topic, xqos, whc, status_cb, status_cb_arg);
} }
@ -3027,7 +3027,7 @@ int delete_writer_nolinger (const struct nn_guid *guid)
if ((wr = ephash_lookup_writer_guid (guid)) == NULL) if ((wr = ephash_lookup_writer_guid (guid)) == NULL)
{ {
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer_nolinger(guid "PGUIDFMT") - unknown guid\n", PGUID (*guid)); DDS_LOG(DDS_LC_DISCOVERY, "delete_writer_nolinger(guid "PGUIDFMT") - unknown guid\n", PGUID (*guid));
return Q_ERR_UNKNOWN_ENTITY; return DDS_RETCODE_BAD_PARAMETER;
} }
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer_nolinger(guid "PGUIDFMT") ...\n", PGUID (*guid)); DDS_LOG(DDS_LC_DISCOVERY, "delete_writer_nolinger(guid "PGUIDFMT") ...\n", PGUID (*guid));
ddsrt_mutex_lock (&wr->e.lock); ddsrt_mutex_lock (&wr->e.lock);
@ -3050,7 +3050,7 @@ int delete_writer (const struct nn_guid *guid)
if ((wr = ephash_lookup_writer_guid (guid)) == NULL) if ((wr = ephash_lookup_writer_guid (guid)) == NULL)
{ {
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer(guid "PGUIDFMT") - unknown guid\n", PGUID (*guid)); DDS_LOG(DDS_LC_DISCOVERY, "delete_writer(guid "PGUIDFMT") - unknown guid\n", PGUID (*guid));
return Q_ERR_UNKNOWN_ENTITY; return DDS_RETCODE_BAD_PARAMETER;
} }
DDS_LOG(DDS_LC_DISCOVERY, "delete_writer(guid "PGUIDFMT") ...\n", PGUID (*guid)); DDS_LOG(DDS_LC_DISCOVERY, "delete_writer(guid "PGUIDFMT") ...\n", PGUID (*guid));
ddsrt_mutex_lock (&wr->e.lock); ddsrt_mutex_lock (&wr->e.lock);
@ -3196,7 +3196,7 @@ static void leave_mcast_helper (const nn_locator_t *n, void * varg)
} }
#endif /* DDSI_INCLUDE_NETWORK_PARTITIONS */ #endif /* DDSI_INCLUDE_NETWORK_PARTITIONS */
static dds_retcode_t new_reader_guid static dds_return_t new_reader_guid
( (
struct reader **rd_out, struct reader **rd_out,
const struct nn_guid *guid, const struct nn_guid *guid,
@ -3332,10 +3332,10 @@ static dds_retcode_t new_reader_guid
match_reader_with_proxy_writers (rd, tnow); match_reader_with_proxy_writers (rd, tnow);
match_reader_with_local_writers (rd, tnow); match_reader_with_local_writers (rd, tnow);
sedp_write_reader (rd); sedp_write_reader (rd);
return DDS_RETCODE_OK; return 0;
} }
dds_retcode_t new_reader dds_return_t new_reader
( (
struct reader **rd_out, struct reader **rd_out,
struct nn_guid *rdguid, struct nn_guid *rdguid,
@ -3349,15 +3349,16 @@ dds_retcode_t new_reader
) )
{ {
struct participant * pp; struct participant * pp;
dds_return_t rc;
if ((pp = ephash_lookup_participant_guid (ppguid)) == NULL) if ((pp = ephash_lookup_participant_guid (ppguid)) == NULL)
{ {
DDS_LOG(DDS_LC_DISCOVERY, "new_reader - participant "PGUIDFMT" not found\n", PGUID (*ppguid)); DDS_LOG(DDS_LC_DISCOVERY, "new_reader - participant "PGUIDFMT" not found\n", PGUID (*ppguid));
return DDS_RETCODE_NOT_FOUND; return DDS_RETCODE_BAD_PARAMETER;
} }
rdguid->prefix = pp->e.guid.prefix; rdguid->prefix = pp->e.guid.prefix;
if (pp_allocate_entityid (&rdguid->entityid, NN_ENTITYID_KIND_READER_WITH_KEY, pp) < 0) if ((rc = pp_allocate_entityid (&rdguid->entityid, NN_ENTITYID_KIND_READER_WITH_KEY, pp)) < 0)
return DDS_RETCODE_OUT_OF_RESOURCES; return rc;
return new_reader_guid (rd_out, rdguid, group_guid, pp, topic, xqos, rhc, status_cb, status_cbarg); return new_reader_guid (rd_out, rdguid, group_guid, pp, topic, xqos, rhc, status_cb, status_cbarg);
} }
@ -3415,7 +3416,7 @@ int delete_reader (const struct nn_guid *guid)
if ((rd = ephash_lookup_reader_guid (guid)) == NULL) if ((rd = ephash_lookup_reader_guid (guid)) == NULL)
{ {
DDS_LOG(DDS_LC_DISCOVERY, "delete_reader_guid(guid "PGUIDFMT") - unknown guid\n", PGUID (*guid)); DDS_LOG(DDS_LC_DISCOVERY, "delete_reader_guid(guid "PGUIDFMT") - unknown guid\n", PGUID (*guid));
return Q_ERR_UNKNOWN_ENTITY; return DDS_RETCODE_BAD_PARAMETER;
} }
DDS_LOG(DDS_LC_DISCOVERY, "delete_reader_guid(guid "PGUIDFMT") ...\n", PGUID (*guid)); DDS_LOG(DDS_LC_DISCOVERY, "delete_reader_guid(guid "PGUIDFMT") ...\n", PGUID (*guid));
ddsi_plugin.builtintopic_write (&rd->e, now(), false); ddsi_plugin.builtintopic_write (&rd->e, now(), false);
@ -3918,7 +3919,7 @@ int delete_proxy_participant_by_guid (const struct nn_guid * guid, nn_wctime_t t
{ {
ddsrt_mutex_unlock (&gv.lock); ddsrt_mutex_unlock (&gv.lock);
DDS_LOG(DDS_LC_DISCOVERY, "- unknown\n"); DDS_LOG(DDS_LC_DISCOVERY, "- unknown\n");
return Q_ERR_UNKNOWN_ENTITY; return DDS_RETCODE_BAD_PARAMETER;
} }
DDS_LOG(DDS_LC_DISCOVERY, "- deleting\n"); DDS_LOG(DDS_LC_DISCOVERY, "- deleting\n");
ddsi_plugin.builtintopic_write (&ppt->e, timestamp, false); ddsi_plugin.builtintopic_write (&ppt->e, timestamp, false);
@ -3973,7 +3974,7 @@ int new_proxy_group (const struct nn_guid *guid, const char *name, const struct
break; break;
default: default:
DDS_WARNING("new_proxy_group: unrecognised entityid: %"PRIx32"\n", guid->entityid.u); DDS_WARNING("new_proxy_group: unrecognised entityid: %"PRIx32"\n", guid->entityid.u);
return Q_ERR_INVALID_DATA; return DDS_RETCODE_BAD_PARAMETER;
} }
ddsrt_mutex_lock (&proxypp->e.lock); ddsrt_mutex_lock (&proxypp->e.lock);
if ((pgroup = ddsrt_avl_lookup_ipath (&proxypp_groups_treedef, &proxypp->groups, guid, &ipath)) != NULL) if ((pgroup = ddsrt_avl_lookup_ipath (&proxypp_groups_treedef, &proxypp->groups, guid, &ipath)) != NULL)
@ -4102,7 +4103,7 @@ int new_proxy_writer (const struct nn_guid *ppguid, const struct nn_guid *guid,
if ((proxypp = ephash_lookup_proxy_participant_guid (ppguid)) == NULL) if ((proxypp = ephash_lookup_proxy_participant_guid (ppguid)) == NULL)
{ {
DDS_WARNING("new_proxy_writer("PGUIDFMT"): proxy participant unknown\n", PGUID (*guid)); DDS_WARNING("new_proxy_writer("PGUIDFMT"): proxy participant unknown\n", PGUID (*guid));
return Q_ERR_UNKNOWN_ENTITY; return DDS_RETCODE_BAD_PARAMETER;
} }
pwr = ddsrt_malloc (sizeof (*pwr)); pwr = ddsrt_malloc (sizeof (*pwr));
@ -4301,7 +4302,7 @@ int delete_proxy_writer (const struct nn_guid *guid, nn_wctime_t timestamp, int
{ {
ddsrt_mutex_unlock (&gv.lock); ddsrt_mutex_unlock (&gv.lock);
DDS_LOG(DDS_LC_DISCOVERY, "- unknown\n"); DDS_LOG(DDS_LC_DISCOVERY, "- unknown\n");
return Q_ERR_UNKNOWN_ENTITY; return DDS_RETCODE_BAD_PARAMETER;
} }
/* Set "deleting" flag in particular for Lite, to signal to the receive path it can't /* Set "deleting" flag in particular for Lite, to signal to the receive path it can't
trust rdary[] anymore, which is because removing the proxy writer from the hash trust rdary[] anymore, which is because removing the proxy writer from the hash
@ -4334,7 +4335,7 @@ int new_proxy_reader (const struct nn_guid *ppguid, const struct nn_guid *guid,
if ((proxypp = ephash_lookup_proxy_participant_guid (ppguid)) == NULL) if ((proxypp = ephash_lookup_proxy_participant_guid (ppguid)) == NULL)
{ {
DDS_WARNING("new_proxy_reader("PGUIDFMT"): proxy participant unknown\n", PGUID (*guid)); DDS_WARNING("new_proxy_reader("PGUIDFMT"): proxy participant unknown\n", PGUID (*guid));
return Q_ERR_UNKNOWN_ENTITY; return DDS_RETCODE_BAD_PARAMETER;
} }
prd = ddsrt_malloc (sizeof (*prd)); prd = ddsrt_malloc (sizeof (*prd));
@ -4437,7 +4438,7 @@ int delete_proxy_reader (const struct nn_guid *guid, nn_wctime_t timestamp, int
{ {
ddsrt_mutex_unlock (&gv.lock); ddsrt_mutex_unlock (&gv.lock);
DDS_LOG(DDS_LC_DISCOVERY, "- unknown\n"); DDS_LOG(DDS_LC_DISCOVERY, "- unknown\n");
return Q_ERR_UNKNOWN_ENTITY; return DDS_RETCODE_BAD_PARAMETER;
} }
ddsi_plugin.builtintopic_write (&prd->e, timestamp, false); ddsi_plugin.builtintopic_write (&prd->e, timestamp, false);
ephash_remove_proxy_reader_guid (prd); ephash_remove_proxy_reader_guid (prd);

1
src/core/ddsi/src/q_init.c
View file

@ -36,7 +36,6 @@
#include "dds/ddsi/q_addrset.h" #include "dds/ddsi/q_addrset.h"
#include "dds/ddsi/q_ddsi_discovery.h" #include "dds/ddsi/q_ddsi_discovery.h"
#include "dds/ddsi/q_radmin.h" #include "dds/ddsi/q_radmin.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_thread.h"
#include "dds/ddsi/q_ephash.h" #include "dds/ddsi/q_ephash.h"
#include "dds/ddsi/q_lease.h" #include "dds/ddsi/q_lease.h"

12
src/core/ddsi/src/q_nwif.c
View file

@ -96,7 +96,7 @@ static int set_rcvbuf (ddsrt_socket_t socket)
uint32_t ReceiveBufferSize; uint32_t ReceiveBufferSize;
socklen_t optlen = (socklen_t) sizeof (ReceiveBufferSize); socklen_t optlen = (socklen_t) sizeof (ReceiveBufferSize);
uint32_t socket_min_rcvbuf_size; uint32_t socket_min_rcvbuf_size;
dds_retcode_t rc; dds_return_t rc;
if (config.socket_min_rcvbuf_size.isdefault) if (config.socket_min_rcvbuf_size.isdefault)
socket_min_rcvbuf_size = 1048576; socket_min_rcvbuf_size = 1048576;
else else
@ -145,7 +145,7 @@ static int set_sndbuf (ddsrt_socket_t socket)
{ {
unsigned SendBufferSize; unsigned SendBufferSize;
socklen_t optlen = (socklen_t) sizeof(SendBufferSize); socklen_t optlen = (socklen_t) sizeof(SendBufferSize);
dds_retcode_t rc; dds_return_t rc;
rc = ddsrt_getsockopt( rc = ddsrt_getsockopt(
socket, SOL_SOCKET, SO_SNDBUF,(char *)&SendBufferSize, &optlen); socket, SOL_SOCKET, SO_SNDBUF,(char *)&SendBufferSize, &optlen);
if (rc == DDS_RETCODE_BAD_PARAMETER) { if (rc == DDS_RETCODE_BAD_PARAMETER) {
@ -202,7 +202,7 @@ static int set_reuse_options (ddsrt_socket_t socket)
/* Set REUSEADDR (if available on platform) for /* Set REUSEADDR (if available on platform) for
multicast sockets, leave unicast sockets alone. */ multicast sockets, leave unicast sockets alone. */
int one = 1; int one = 1;
dds_retcode_t rc = ddsrt_setsockopt ( dds_return_t rc = ddsrt_setsockopt (
socket, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof (one)); socket, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof (one));
if (rc == DDS_RETCODE_BAD_PARAMETER) { if (rc == DDS_RETCODE_BAD_PARAMETER) {
DDS_LOG(DDS_LC_CONFIG, "cannot enable address reuse on socket\n"); DDS_LOG(DDS_LC_CONFIG, "cannot enable address reuse on socket\n");
@ -217,7 +217,7 @@ static int set_reuse_options (ddsrt_socket_t socket)
static int bind_socket (ddsrt_socket_t socket, unsigned short port) static int bind_socket (ddsrt_socket_t socket, unsigned short port)
{ {
dds_retcode_t rc = DDS_RETCODE_ERROR; dds_return_t rc = DDS_RETCODE_ERROR;
#if DDSRT_HAVE_IPV6 #if DDSRT_HAVE_IPV6
if (config.transport_selector == TRANS_TCP6 || config.transport_selector == TRANS_UDP6) if (config.transport_selector == TRANS_TCP6 || config.transport_selector == TRANS_UDP6)
@ -279,7 +279,7 @@ static int set_mc_options_transmit_ipv4 (ddsrt_socket_t socket)
{ {
unsigned char ttl = (unsigned char) config.multicast_ttl; unsigned char ttl = (unsigned char) config.multicast_ttl;
unsigned char loop; unsigned char loop;
dds_retcode_t ret; dds_return_t ret;
#if (defined(__linux) || defined(__APPLE__)) && !LWIP_SOCKET #if (defined(__linux) || defined(__APPLE__)) && !LWIP_SOCKET
if (config.use_multicast_if_mreqn) if (config.use_multicast_if_mreqn)
@ -348,7 +348,7 @@ int make_socket
) )
{ {
int rc = -2; int rc = -2;
dds_retcode_t ret; dds_return_t ret;
#if DDSRT_HAVE_IPV6 #if DDSRT_HAVE_IPV6
if (config.transport_selector == TRANS_TCP6 || config.transport_selector == TRANS_UDP6) if (config.transport_selector == TRANS_TCP6 || config.transport_selector == TRANS_UDP6)

359
src/core/ddsi/src/q_plist.c
View file

File diff suppressed because it is too large Load diff

5
src/core/ddsi/src/q_receive.c
View file

@ -36,7 +36,6 @@
#include "dds/ddsi/q_addrset.h" #include "dds/ddsi/q_addrset.h"
#include "dds/ddsi/q_ddsi_discovery.h" #include "dds/ddsi/q_ddsi_discovery.h"
#include "dds/ddsi/q_radmin.h" #include "dds/ddsi/q_radmin.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_thread.h"
#include "dds/ddsi/q_ephash.h" #include "dds/ddsi/q_ephash.h"
#include "dds/ddsi/q_lease.h" #include "dds/ddsi/q_lease.h"
@ -1953,7 +1952,7 @@ static int deliver_user_data (const struct nn_rsample_info *sampleinfo, const st
{ {
nn_plist_src_t src; nn_plist_src_t src;
size_t qos_offset = NN_RDATA_SUBMSG_OFF (fragchain) + offsetof (Data_DataFrag_common_t, octetsToInlineQos) + sizeof (msg->octetsToInlineQos) + msg->octetsToInlineQos; size_t qos_offset = NN_RDATA_SUBMSG_OFF (fragchain) + offsetof (Data_DataFrag_common_t, octetsToInlineQos) + sizeof (msg->octetsToInlineQos) + msg->octetsToInlineQos;
int plist_ret; dds_return_t plist_ret;
src.protocol_version = rst->protocol_version; src.protocol_version = rst->protocol_version;
src.vendorid = rst->vendor; src.vendorid = rst->vendor;
src.encoding = (msg->smhdr.flags & SMFLAG_ENDIANNESS) ? PL_CDR_LE : PL_CDR_BE; src.encoding = (msg->smhdr.flags & SMFLAG_ENDIANNESS) ? PL_CDR_LE : PL_CDR_BE;
@ -1961,7 +1960,7 @@ static int deliver_user_data (const struct nn_rsample_info *sampleinfo, const st
src.bufsz = NN_RDATA_PAYLOAD_OFF (fragchain) - qos_offset; src.bufsz = NN_RDATA_PAYLOAD_OFF (fragchain) - qos_offset;
if ((plist_ret = nn_plist_init_frommsg (&qos, NULL, PP_STATUSINFO | PP_KEYHASH | PP_COHERENT_SET | PP_PRISMTECH_EOTINFO, 0, &src)) < 0) if ((plist_ret = nn_plist_init_frommsg (&qos, NULL, PP_STATUSINFO | PP_KEYHASH | PP_COHERENT_SET | PP_PRISMTECH_EOTINFO, 0, &src)) < 0)
{ {
if (plist_ret != Q_ERR_INCOMPATIBLE) if (plist_ret != DDS_RETCODE_UNSUPPORTED)
DDS_WARNING ("data(application, vendor %u.%u): "PGUIDFMT" #%"PRId64": invalid inline qos\n", DDS_WARNING ("data(application, vendor %u.%u): "PGUIDFMT" #%"PRId64": invalid inline qos\n",
src.vendorid.id[0], src.vendorid.id[1], PGUID (pwr->e.guid), sampleinfo->seq); src.vendorid.id[0], src.vendorid.id[1], PGUID (pwr->e.guid), sampleinfo->seq);
return 0; return 0;

3
src/core/ddsi/src/q_security.c
View file

@ -14,7 +14,6 @@
#include "dds/ddsi/q_security.h" #include "dds/ddsi/q_security.h"
#include "dds/ddsi/q_config.h" #include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h" #include "dds/ddsi/q_log.h"
#include "dds/ddsi/q_error.h"
#include "os/os_stdlib.h" #include "os/os_stdlib.h"
#include "os/os_process.h" #include "os/os_process.h"
#include "os/os_thread.h" #include "os/os_thread.h"
@ -1657,7 +1656,7 @@ static os_ssize_t q_security_sendmsg
char stbuf[2048], *buf; char stbuf[2048], *buf;
size_t sz, data_size; size_t sz, data_size;
uint32_t sz32, data_size32; uint32_t sz32, data_size32;
ssize_t ret = Q_ERR_UNSPECIFIED; ssize_t ret = DDS_RETCODE_ERROR;
PT_InfoContainer_t * securityHeader; PT_InfoContainer_t * securityHeader;
unsigned i; unsigned i;

2
src/core/ddsi/src/q_sockwaitset.c
View file

@ -893,7 +893,7 @@ os_sockWaitsetCtx os_sockWaitsetWait (os_sockWaitset ws)
do do
{ {
dds_retcode_t rc = ddsrt_select (fdmax, rdset, NULL, NULL, DDS_INFINITY, &n); dds_return_t rc = ddsrt_select (fdmax, rdset, NULL, NULL, DDS_INFINITY, &n);
if (rc != DDS_RETCODE_OK && rc != DDS_RETCODE_INTERRUPTED && rc != DDS_RETCODE_TRY_AGAIN) if (rc != DDS_RETCODE_OK && rc != DDS_RETCODE_INTERRUPTED && rc != DDS_RETCODE_TRY_AGAIN)
{ {
DDS_WARNING("os_sockWaitsetWait: select failed, retcode = %"PRId32, rc); DDS_WARNING("os_sockWaitsetWait: select failed, retcode = %"PRId32, rc);

12
src/core/ddsi/src/q_thread.c
View file

@ -23,7 +23,6 @@
#include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_thread.h"
#include "dds/ddsi/ddsi_threadmon.h" #include "dds/ddsi/ddsi_threadmon.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/q_log.h" #include "dds/ddsi/q_log.h"
#include "dds/ddsi/q_config.h" #include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_globals.h" #include "dds/ddsi/q_globals.h"
@ -245,7 +244,7 @@ static struct thread_state1 *init_thread_state (const char *tname, enum thread_s
return ts; return ts;
} }
dds_retcode_t create_thread (struct thread_state1 **ts1, const char *name, uint32_t (*f) (void *arg), void *arg) dds_return_t create_thread (struct thread_state1 **ts1, const char *name, uint32_t (*f) (void *arg), void *arg)
{ {
struct config_thread_properties_listelem const * const tprops = lookup_thread_properties (name); struct config_thread_properties_listelem const * const tprops = lookup_thread_properties (name);
ddsrt_threadattr_t tattr; ddsrt_threadattr_t tattr;
@ -300,14 +299,11 @@ static void reap_thread_state (struct thread_state1 *ts1, int sync_with_servicel
ddsrt_mutex_unlock (&thread_states.lock); ddsrt_mutex_unlock (&thread_states.lock);
} }
int join_thread (struct thread_state1 *ts1) dds_return_t join_thread (struct thread_state1 *ts1)
{ {
int ret; dds_return_t ret;
assert (ts1->state == THREAD_STATE_ALIVE); assert (ts1->state == THREAD_STATE_ALIVE);
if (ddsrt_thread_join (ts1->extTid, NULL) == DDS_RETCODE_OK) ret = ddsrt_thread_join (ts1->extTid, NULL);
ret = 0;
else
ret = Q_ERR_UNSPECIFIED;
assert (vtime_asleep_p (ts1->vtime)); assert (vtime_asleep_p (ts1->vtime));
reap_thread_state (ts1, 1); reap_thread_state (ts1, 1);
return ret; return ret;

26
src/core/ddsi/src/q_transmit.c
View file

@ -26,7 +26,6 @@
#include "dds/ddsi/q_time.h" #include "dds/ddsi/q_time.h"
#include "dds/ddsi/q_config.h" #include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_globals.h" #include "dds/ddsi/q_globals.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/q_transmit.h" #include "dds/ddsi/q_transmit.h"
#include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_entity.h"
#include "dds/ddsi/q_unused.h" #include "dds/ddsi/q_unused.h"
@ -387,7 +386,7 @@ void add_Heartbeat (struct nn_xmsg *msg, struct writer *wr, const struct whc_sta
nn_xmsg_submsg_setnext (msg, sm_marker); nn_xmsg_submsg_setnext (msg, sm_marker);
} }
static int create_fragment_message_simple (struct writer *wr, seqno_t seq, struct ddsi_serdata *serdata, struct nn_xmsg **pmsg) static dds_return_t create_fragment_message_simple (struct writer *wr, seqno_t seq, struct ddsi_serdata *serdata, struct nn_xmsg **pmsg)
{ {
#define TEST_KEYHASH 0 #define TEST_KEYHASH 0
/* actual expected_inline_qos_size is typically 0, but always claiming 32 bytes won't make /* actual expected_inline_qos_size is typically 0, but always claiming 32 bytes won't make
@ -417,7 +416,7 @@ static int create_fragment_message_simple (struct writer *wr, seqno_t seq, struc
/* INFO_TS: 12 bytes, Data_t: 24 bytes, expected inline QoS: 32 => should be single chunk */ /* INFO_TS: 12 bytes, Data_t: 24 bytes, expected inline QoS: 32 => should be single chunk */
if ((*pmsg = nn_xmsg_new (gv.xmsgpool, &wr->e.guid.prefix, sizeof (InfoTimestamp_t) + sizeof (Data_t) + expected_inline_qos_size, NN_XMSG_KIND_DATA)) == NULL) if ((*pmsg = nn_xmsg_new (gv.xmsgpool, &wr->e.guid.prefix, sizeof (InfoTimestamp_t) + sizeof (Data_t) + expected_inline_qos_size, NN_XMSG_KIND_DATA)) == NULL)
return Q_ERR_OUT_OF_MEMORY; return DDS_RETCODE_OUT_OF_RESOURCES;
#ifdef DDSI_INCLUDE_NETWORK_PARTITIONS #ifdef DDSI_INCLUDE_NETWORK_PARTITIONS
/* use the partition_id from the writer to select the proper encoder */ /* use the partition_id from the writer to select the proper encoder */
@ -461,7 +460,7 @@ static int create_fragment_message_simple (struct writer *wr, seqno_t seq, struc
return 0; return 0;
} }
int create_fragment_message (struct writer *wr, seqno_t seq, const struct nn_plist *plist, struct ddsi_serdata *serdata, unsigned fragnum, struct proxy_reader *prd, struct nn_xmsg **pmsg, int isnew) dds_return_t create_fragment_message (struct writer *wr, seqno_t seq, const struct nn_plist *plist, struct ddsi_serdata *serdata, unsigned fragnum, struct proxy_reader *prd, struct nn_xmsg **pmsg, int isnew)
{ {
/* We always fragment into FRAGMENT_SIZEd fragments, which are near /* We always fragment into FRAGMENT_SIZEd fragments, which are near
the smallest allowed fragment size & can't be bothered (yet) to the smallest allowed fragment size & can't be bothered (yet) to
@ -484,7 +483,7 @@ int create_fragment_message (struct writer *wr, seqno_t seq, const struct nn_pli
uint32_t fragstart, fraglen; uint32_t fragstart, fraglen;
enum nn_xmsg_kind xmsg_kind = isnew ? NN_XMSG_KIND_DATA : NN_XMSG_KIND_DATA_REXMIT; enum nn_xmsg_kind xmsg_kind = isnew ? NN_XMSG_KIND_DATA : NN_XMSG_KIND_DATA_REXMIT;
const uint32_t size = ddsi_serdata_size (serdata); const uint32_t size = ddsi_serdata_size (serdata);
int ret = 0; dds_return_t ret = 0;
(void)plist; (void)plist;
ASSERT_MUTEX_HELD (&wr->e.lock); ASSERT_MUTEX_HELD (&wr->e.lock);
@ -495,14 +494,14 @@ int create_fragment_message (struct writer *wr, seqno_t seq, const struct nn_pli
an non-existent fragment, which a malicious (or buggy) remote an non-existent fragment, which a malicious (or buggy) remote
reader can trigger. So we return an error instead of asserting reader can trigger. So we return an error instead of asserting
as we used to. */ as we used to. */
return Q_ERR_INVALID; return DDS_RETCODE_BAD_PARAMETER;
} }
fragging = (config.fragment_size < size); fragging = (config.fragment_size < size);
/* INFO_TS: 12 bytes, DataFrag_t: 36 bytes, expected inline QoS: 32 => should be single chunk */ /* INFO_TS: 12 bytes, DataFrag_t: 36 bytes, expected inline QoS: 32 => should be single chunk */
if ((*pmsg = nn_xmsg_new (gv.xmsgpool, &wr->e.guid.prefix, sizeof (InfoTimestamp_t) + sizeof (DataFrag_t) + expected_inline_qos_size, xmsg_kind)) == NULL) if ((*pmsg = nn_xmsg_new (gv.xmsgpool, &wr->e.guid.prefix, sizeof (InfoTimestamp_t) + sizeof (DataFrag_t) + expected_inline_qos_size, xmsg_kind)) == NULL)
return Q_ERR_OUT_OF_MEMORY; return DDS_RETCODE_OUT_OF_RESOURCES;
#ifdef DDSI_INCLUDE_NETWORK_PARTITIONS #ifdef DDSI_INCLUDE_NETWORK_PARTITIONS
/* use the partition_id from the writer to select the proper encoder */ /* use the partition_id from the writer to select the proper encoder */
@ -515,7 +514,7 @@ int create_fragment_message (struct writer *wr, seqno_t seq, const struct nn_pli
{ {
nn_xmsg_free (*pmsg); nn_xmsg_free (*pmsg);
*pmsg = NULL; *pmsg = NULL;
return Q_ERR_NO_ADDRESS; return DDS_RETCODE_PRECONDITION_NOT_MET;
} }
/* retransmits: latency budget doesn't apply */ /* retransmits: latency budget doesn't apply */
} }
@ -901,7 +900,7 @@ static int writer_may_continue (const struct writer *wr, const struct whc_state
} }
static dds_retcode_t throttle_writer (struct thread_state1 * const ts1, struct nn_xpack *xp, struct writer *wr) static dds_return_t throttle_writer (struct thread_state1 * const ts1, struct nn_xpack *xp, struct writer *wr)
{ {
/* Sleep (cond_wait) without updating the thread's vtime: the /* Sleep (cond_wait) without updating the thread's vtime: the
garbage collector won't free the writer while we leave it garbage collector won't free the writer while we leave it
@ -937,7 +936,7 @@ static dds_retcode_t throttle_writer (struct thread_state1 * const ts1, struct n
reader. This implicitly clears the whc and unblocks the reader. This implicitly clears the whc and unblocks the
writer. */ writer. */
dds_retcode_t result = DDS_RETCODE_OK; dds_return_t result = DDS_RETCODE_OK;
nn_mtime_t tnow = now_mt (); nn_mtime_t tnow = now_mt ();
const nn_mtime_t abstimeout = add_duration_to_mtime (tnow, nn_from_ddsi_duration (wr->xqos->reliability.max_blocking_time)); const nn_mtime_t abstimeout = add_duration_to_mtime (tnow, nn_from_ddsi_duration (wr->xqos->reliability.max_blocking_time));
struct whc_state whcst; struct whc_state whcst;
@ -1040,7 +1039,7 @@ static int write_sample_eot (struct thread_state1 * const ts1, struct nn_xpack *
ddsi_serdata_size (serdata), config.max_sample_size, ddsi_serdata_size (serdata), config.max_sample_size,
PGUID (wr->e.guid), tname, ttname, ppbuf, PGUID (wr->e.guid), tname, ttname, ppbuf,
tmp < (int) sizeof (ppbuf) ? "" : " (trunc)"); tmp < (int) sizeof (ppbuf) ? "" : " (trunc)");
r = Q_ERR_INVALID_DATA; r = DDS_RETCODE_BAD_PARAMETER;
goto drop; goto drop;
} }
@ -1057,7 +1056,7 @@ static int write_sample_eot (struct thread_state1 * const ts1, struct nn_xpack *
whc_get_state(wr->whc, &whcst); whc_get_state(wr->whc, &whcst);
if (whcst.unacked_bytes > wr->whc_high) if (whcst.unacked_bytes > wr->whc_high)
{ {
dds_retcode_t ores; dds_return_t ores;
assert(gc_allowed); /* also see beginning of the function */ assert(gc_allowed); /* also see beginning of the function */
if (config.prioritize_retransmit && wr->retransmitting) if (config.prioritize_retransmit && wr->retransmitting)
ores = throttle_writer (ts1, xp, wr); ores = throttle_writer (ts1, xp, wr);
@ -1072,7 +1071,7 @@ static int write_sample_eot (struct thread_state1 * const ts1, struct nn_xpack *
if (ores == DDS_RETCODE_TIMEOUT) if (ores == DDS_RETCODE_TIMEOUT)
{ {
ddsrt_mutex_unlock (&wr->e.lock); ddsrt_mutex_unlock (&wr->e.lock);
r = Q_ERR_TIMEOUT; r = DDS_RETCODE_TIMEOUT;
goto drop; goto drop;
} }
} }
@ -1189,4 +1188,3 @@ int write_sample_nogc_notk (struct thread_state1 * const ts1, struct nn_xpack *x
ddsi_tkmap_instance_unref (tk); ddsi_tkmap_instance_unref (tk);
return res; return res;
} }

7
src/core/ddsi/src/q_xevent.c
View file

@ -30,7 +30,6 @@
#include "dds/ddsi/q_globals.h" #include "dds/ddsi/q_globals.h"
#include "dds/ddsi/q_ephash.h" #include "dds/ddsi/q_ephash.h"
#include "dds/ddsi/q_transmit.h" #include "dds/ddsi/q_transmit.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/q_bswap.h" #include "dds/ddsi/q_bswap.h"
#include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_entity.h"
#include "dds/ddsi/q_misc.h" #include "dds/ddsi/q_misc.h"
@ -477,9 +476,9 @@ struct xeventq * xeventq_new
return evq; return evq;
} }
int xeventq_start (struct xeventq *evq, const char *name) dds_return_t xeventq_start (struct xeventq *evq, const char *name)
{ {
dds_retcode_t rc; dds_return_t rc;
char * evqname = "tev"; char * evqname = "tev";
assert (evq->ts == NULL); assert (evq->ts == NULL);
@ -497,7 +496,7 @@ int xeventq_start (struct xeventq *evq, const char *name)
{ {
ddsrt_free (evqname); ddsrt_free (evqname);
} }
return (rc != DDS_RETCODE_OK) ? Q_ERR_UNSPECIFIED : 0; return rc;
} }
void xeventq_stop (struct xeventq *evq) void xeventq_stop (struct xeventq *evq)

17
src/core/ddsi/src/q_xmsg.c
View file

@ -31,7 +31,6 @@
#include "dds/ddsi/q_bswap.h" #include "dds/ddsi/q_bswap.h"
#include "dds/ddsi/q_rtps.h" #include "dds/ddsi/q_rtps.h"
#include "dds/ddsi/q_addrset.h" #include "dds/ddsi/q_addrset.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/q_misc.h" #include "dds/ddsi/q_misc.h"
#include "dds/ddsi/q_log.h" #include "dds/ddsi/q_log.h"
#include "dds/ddsi/q_unused.h" #include "dds/ddsi/q_unused.h"
@ -148,7 +147,7 @@ typedef struct {
ddsrt_cond_t cv; ddsrt_cond_t cv;
} ddsi_sem_t; } ddsi_sem_t;
dds_retcode_t dds_return_t
ddsi_sem_init (ddsi_sem_t *sem, uint32_t value) ddsi_sem_init (ddsi_sem_t *sem, uint32_t value)
{ {
sem->value = value; sem->value = value;
@ -157,7 +156,7 @@ ddsi_sem_init (ddsi_sem_t *sem, uint32_t value)
return DDS_RETCODE_OK; return DDS_RETCODE_OK;
} }
dds_retcode_t dds_return_t
ddsi_sem_destroy (ddsi_sem_t *sem) ddsi_sem_destroy (ddsi_sem_t *sem)
{ {
ddsrt_cond_destroy (&sem->cv); ddsrt_cond_destroy (&sem->cv);
@ -165,7 +164,7 @@ ddsi_sem_destroy (ddsi_sem_t *sem)
return DDS_RETCODE_OK; return DDS_RETCODE_OK;
} }
dds_retcode_t dds_return_t
ddsi_sem_post (ddsi_sem_t *sem) ddsi_sem_post (ddsi_sem_t *sem)
{ {
ddsrt_mutex_lock (&sem->mtx); ddsrt_mutex_lock (&sem->mtx);
@ -175,7 +174,7 @@ ddsi_sem_post (ddsi_sem_t *sem)
return DDS_RETCODE_OK; return DDS_RETCODE_OK;
} }
dds_retcode_t dds_return_t
ddsi_sem_wait (ddsi_sem_t *sem) ddsi_sem_wait (ddsi_sem_t *sem)
{ {
ddsrt_mutex_lock (&sem->mtx); ddsrt_mutex_lock (&sem->mtx);
@ -586,7 +585,7 @@ void nn_xmsg_setdst1 (struct nn_xmsg *m, const nn_guid_prefix_t *gp, const nn_lo
m->data->dst.guid_prefix = nn_hton_guid_prefix (*gp); m->data->dst.guid_prefix = nn_hton_guid_prefix (*gp);
} }
int nn_xmsg_setdstPRD (struct nn_xmsg *m, const struct proxy_reader *prd) dds_return_t nn_xmsg_setdstPRD (struct nn_xmsg *m, const struct proxy_reader *prd)
{ {
nn_locator_t loc; nn_locator_t loc;
if (addrset_any_uc (prd->c.as, &loc) || addrset_any_mc (prd->c.as, &loc)) if (addrset_any_uc (prd->c.as, &loc) || addrset_any_mc (prd->c.as, &loc))
@ -597,11 +596,11 @@ int nn_xmsg_setdstPRD (struct nn_xmsg *m, const struct proxy_reader *prd)
else else
{ {
DDS_WARNING("nn_xmsg_setdstPRD: no address for "PGUIDFMT"", PGUID (prd->e.guid)); DDS_WARNING("nn_xmsg_setdstPRD: no address for "PGUIDFMT"", PGUID (prd->e.guid));
return Q_ERR_NO_ADDRESS; return DDS_RETCODE_PRECONDITION_NOT_MET;
} }
} }
int nn_xmsg_setdstPWR (struct nn_xmsg *m, const struct proxy_writer *pwr) dds_return_t nn_xmsg_setdstPWR (struct nn_xmsg *m, const struct proxy_writer *pwr)
{ {
nn_locator_t loc; nn_locator_t loc;
if (addrset_any_uc (pwr->c.as, &loc) || addrset_any_mc (pwr->c.as, &loc)) if (addrset_any_uc (pwr->c.as, &loc) || addrset_any_mc (pwr->c.as, &loc))
@ -610,7 +609,7 @@ int nn_xmsg_setdstPWR (struct nn_xmsg *m, const struct proxy_writer *pwr)
return 0; return 0;
} }
DDS_WARNING("nn_xmsg_setdstPRD: no address for "PGUIDFMT, PGUID (pwr->e.guid)); DDS_WARNING("nn_xmsg_setdstPRD: no address for "PGUIDFMT, PGUID (pwr->e.guid));
return Q_ERR_NO_ADDRESS; return DDS_RETCODE_PRECONDITION_NOT_MET;
} }
void nn_xmsg_setdstN (struct nn_xmsg *m, struct addrset *as, struct addrset *as_group) void nn_xmsg_setdstN (struct nn_xmsg *m, struct addrset *as, struct addrset *as_group)

1
src/core/ddsi/src/sysdeps.c
View file

@ -15,7 +15,6 @@
#include "dds/ddsrt/atomics.h" #include "dds/ddsrt/atomics.h"
#include "dds/ddsrt/misc.h" #include "dds/ddsrt/misc.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/q_log.h" #include "dds/ddsi/q_log.h"
#include "dds/ddsi/q_config.h" #include "dds/ddsi/q_config.h"
#include "dds/ddsi/sysdeps.h" #include "dds/ddsi/sysdeps.h"

10
src/ddsrt/CMakeLists.txt
View file

@ -121,10 +121,10 @@ list(APPEND sources
"${source_path}/strtol.c") "${source_path}/strtol.c")
list(APPEND headers list(APPEND headers
"${source_path}/dds/ddsrt/avl.h" "${include_path}/dds/ddsrt/avl.h"
"${source_path}/dds/ddsrt/fibheap.h" "${include_path}/dds/ddsrt/fibheap.h"
"${source_path}/dds/ddsrt/hopscotch.h" "${include_path}/dds/ddsrt/hopscotch.h"
"${source_path}/dds/ddsrt/thread_pool.h") "${include_path}/dds/ddsrt/thread_pool.h")
list(APPEND sources list(APPEND sources
"${source_path}/avl.c" "${source_path}/avl.c"
@ -221,7 +221,7 @@ foreach(feature atomics cdtors environ heap ifaddrs random rusage
endif() endif()
endforeach() endforeach()
target_sources(ddsrt INTERFACE ${sources}) target_sources(ddsrt INTERFACE ${sources} ${headers})
set(HAVE_MULTI_PROCESS ${HAVE_MULTI_PROCESS} PARENT_SCOPE) set(HAVE_MULTI_PROCESS ${HAVE_MULTI_PROCESS} PARENT_SCOPE)

12
src/ddsrt/include/dds/ddsrt/environ.h
View file

@ -30,7 +30,7 @@ extern "C" {
* byte), or would have been written would @buf have been * byte), or would have been written would @buf have been
* sufficiently large enough. * sufficiently large enough.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* Environment variable written to @buf. * Environment variable written to @buf.
@ -43,7 +43,7 @@ extern "C" {
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* Unspecified error. * Unspecified error.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_getenv( ddsrt_getenv(
const char *name, const char *name,
char **value) char **value)
@ -58,7 +58,7 @@ ddsrt_nonnull_all;
* @param[in] name Environment variable name. * @param[in] name Environment variable name.
* @param[in] value Value to set environment variable to. * @param[in] value Value to set environment variable to.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* Environment variable successfully set to @value. * Environment variable successfully set to @value.
@ -69,7 +69,7 @@ ddsrt_nonnull_all;
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* Unspecified system error. * Unspecified system error.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_setenv( ddsrt_setenv(
const char *name, const char *name,
const char *value) const char *value)
@ -80,7 +80,7 @@ ddsrt_nonnull_all;
* *
* @param[in] name Environment variable name. * @param[in] name Environment variable name.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* Environment variable successfully unset. * Environment variable successfully unset.
@ -91,7 +91,7 @@ ddsrt_nonnull_all;
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* Unspecified system error. * Unspecified system error.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_unsetenv( ddsrt_unsetenv(
const char *name) const char *name)
ddsrt_nonnull_all; ddsrt_nonnull_all;

2
src/ddsrt/include/dds/ddsrt/ifaddrs.h
View file

@ -30,7 +30,7 @@ struct ddsrt_ifaddrs {
typedef struct ddsrt_ifaddrs ddsrt_ifaddrs_t; typedef struct ddsrt_ifaddrs ddsrt_ifaddrs_t;
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_getifaddrs( ddsrt_getifaddrs(
ddsrt_ifaddrs_t **ifap, ddsrt_ifaddrs_t **ifap,
const int *afs); const int *afs);

20
src/ddsrt/include/dds/ddsrt/process.h
View file

@ -72,7 +72,7 @@ ddsrt_getpid(void);
* @param[in] argv Arguments array. * @param[in] argv Arguments array.
* @param[out] pid ID of the created process. * @param[out] pid ID of the created process.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* Process successfully created. * Process successfully created.
@ -85,7 +85,7 @@ ddsrt_getpid(void);
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* Process could not be created. * Process could not be created.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_proc_create( ddsrt_proc_create(
const char *executable, const char *executable,
char *const argv[], char *const argv[],
@ -109,7 +109,7 @@ ddsrt_proc_create(
* @param[in] timemout Time within the process is expected to finish. * @param[in] timemout Time within the process is expected to finish.
* @param[out] code The exit code of the process. * @param[out] code The exit code of the process.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* Process has terminated and its exit code has been captured. * Process has terminated and its exit code has been captured.
@ -124,7 +124,7 @@ ddsrt_proc_create(
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* Getting the exit code failed for an unknown reason. * Getting the exit code failed for an unknown reason.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_proc_waitpid( ddsrt_proc_waitpid(
ddsrt_pid_t pid, ddsrt_pid_t pid,
dds_duration_t timeout, dds_duration_t timeout,
@ -149,7 +149,7 @@ ddsrt_proc_waitpid(
* @param[out] pid Process ID (PID) of the finished process. * @param[out] pid Process ID (PID) of the finished process.
* @param[out] code The exit code of the process. * @param[out] code The exit code of the process.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* A process has terminated. * A process has terminated.
@ -165,7 +165,7 @@ ddsrt_proc_waitpid(
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* Getting the exit code failed for an unknown reason. * Getting the exit code failed for an unknown reason.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_proc_waitpids( ddsrt_proc_waitpids(
dds_duration_t timeout, dds_duration_t timeout,
ddsrt_pid_t *pid, ddsrt_pid_t *pid,
@ -176,7 +176,7 @@ ddsrt_proc_waitpids(
* *
* @param[in] pid Process ID (PID) to check if it exists. * @param[in] pid Process ID (PID) to check if it exists.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* The process exists. * The process exists.
@ -185,7 +185,7 @@ ddsrt_proc_waitpids(
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* Determining if a process exists or not, failed. * Determining if a process exists or not, failed.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_proc_exists( ddsrt_proc_exists(
ddsrt_pid_t pid); ddsrt_pid_t pid);
@ -202,7 +202,7 @@ ddsrt_proc_exists(
* *
* @param[in] pid Process ID (PID) of the process to terminate. * @param[in] pid Process ID (PID) of the process to terminate.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* Kill attempt has been started. * Kill attempt has been started.
@ -213,7 +213,7 @@ ddsrt_proc_exists(
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* Kill failed for an unknown reason. * Kill failed for an unknown reason.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_proc_kill( ddsrt_proc_kill(
ddsrt_pid_t pid); ddsrt_pid_t pid);

34
src/ddsrt/include/dds/ddsrt/retcode.h
View file

@ -9,7 +9,7 @@
extern "C" { extern "C" {
#endif #endif
typedef int32_t dds_retcode_t; typedef int32_t dds_return_t;
/* /*
State is unchanged following a function call returning an error State is unchanged following a function call returning an error
@ -29,25 +29,25 @@ typedef int32_t dds_retcode_t;
* @{ * @{
*/ */
#define DDS_RETCODE_OK 0 /**< Success */ #define DDS_RETCODE_OK 0 /**< Success */
#define DDS_RETCODE_ERROR 1 /**< Non specific error */ #define DDS_RETCODE_ERROR -1 /**< Non specific error */
#define DDS_RETCODE_UNSUPPORTED 2 /**< Feature unsupported */ #define DDS_RETCODE_UNSUPPORTED -2 /**< Feature unsupported */
#define DDS_RETCODE_BAD_PARAMETER 3 /**< Bad parameter value */ #define DDS_RETCODE_BAD_PARAMETER -3 /**< Bad parameter value */
#define DDS_RETCODE_PRECONDITION_NOT_MET 4 /**< Precondition for operation not met */ #define DDS_RETCODE_PRECONDITION_NOT_MET -4 /**< Precondition for operation not met */
#define DDS_RETCODE_OUT_OF_RESOURCES 5 /**< When an operation fails because of a lack of resources */ #define DDS_RETCODE_OUT_OF_RESOURCES -5 /**< When an operation fails because of a lack of resources */
#define DDS_RETCODE_NOT_ENABLED 6 /**< When a configurable feature is not enabled */ #define DDS_RETCODE_NOT_ENABLED -6 /**< When a configurable feature is not enabled */
#define DDS_RETCODE_IMMUTABLE_POLICY 7 /**< When an attempt is made to modify an immutable policy */ #define DDS_RETCODE_IMMUTABLE_POLICY -7 /**< When an attempt is made to modify an immutable policy */
#define DDS_RETCODE_INCONSISTENT_POLICY 8 /**< When a policy is used with inconsistent values */ #define DDS_RETCODE_INCONSISTENT_POLICY -8 /**< When a policy is used with inconsistent values */
#define DDS_RETCODE_ALREADY_DELETED 9 /**< When an attempt is made to delete something more than once */ #define DDS_RETCODE_ALREADY_DELETED -9 /**< When an attempt is made to delete something more than once */
#define DDS_RETCODE_TIMEOUT 10 /**< When a timeout has occurred */ #define DDS_RETCODE_TIMEOUT -10 /**< When a timeout has occurred */
#define DDS_RETCODE_NO_DATA 11 /**< When expected data is not provided */ #define DDS_RETCODE_NO_DATA -11 /**< When expected data is not provided */
#define DDS_RETCODE_ILLEGAL_OPERATION 12 /**< When a function is called when it should not be */ #define DDS_RETCODE_ILLEGAL_OPERATION -12 /**< When a function is called when it should not be */
#define DDS_RETCODE_NOT_ALLOWED_BY_SECURITY 13 /**< When credentials are not enough to use the function */ #define DDS_RETCODE_NOT_ALLOWED_BY_SECURITY -13 /**< When credentials are not enough to use the function */
/* Extended return codes are not in the DDS specification and are meant /* Extended return codes are not in the DDS specification and are meant
exclusively for internal use and must not be returned by the C API. */ exclusively for internal use and must not be returned by the C API. */
#define DDS_XRETCODE_BASE (50) #define DDS_XRETCODE_BASE (-50)
#define DDS_XRETCODE(x) (DDS_XRETCODE_BASE + (x)) #define DDS_XRETCODE(x) (DDS_XRETCODE_BASE - (x))
/** Requested resource is busy */ /** Requested resource is busy */
#define DDS_RETCODE_IN_PROGRESS DDS_XRETCODE(1) #define DDS_RETCODE_IN_PROGRESS DDS_XRETCODE(1)
@ -88,7 +88,7 @@ typedef int32_t dds_retcode_t;
* *
* @returns String corresponding to the error value * @returns String corresponding to the error value
*/ */
DDS_EXPORT const char *dds_strretcode(dds_retcode_t ret); DDS_EXPORT const char *dds_strretcode(dds_return_t ret);
#if defined (__cplusplus) #if defined (__cplusplus)
} }

4
src/ddsrt/include/dds/ddsrt/rusage.h
View file

@ -52,7 +52,7 @@ typedef struct {
* @param[in] who DDSRT_RUSAGE_SELF or DDSRT_RUSAGE_THREAD. * @param[in] who DDSRT_RUSAGE_SELF or DDSRT_RUSAGE_THREAD.
* @param[in] usage Structure where resource usage is returned. * @param[in] usage Structure where resource usage is returned.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* Resource usage successfully returned in @usage. * Resource usage successfully returned in @usage.
@ -61,7 +61,7 @@ typedef struct {
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* An unidentified error occurred. * An unidentified error occurred.
*/ */
DDS_EXPORT dds_retcode_t ddsrt_getrusage(int who, ddsrt_rusage_t *usage); DDS_EXPORT dds_return_t ddsrt_getrusage(int who, ddsrt_rusage_t *usage);
#if defined (__cplusplus) #if defined (__cplusplus)
} }

40
src/ddsrt/include/dds/ddsrt/sockets.h
View file

@ -32,53 +32,53 @@ extern const struct in6_addr ddsrt_in6addr_loopback;
#define DDSRT_AF_TERM (-1) #define DDSRT_AF_TERM (-1)
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_gethostname( ddsrt_gethostname(
char *hostname, char *hostname,
size_t buffersize); size_t buffersize);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_socket( ddsrt_socket(
ddsrt_socket_t *sockptr, ddsrt_socket_t *sockptr,
int domain, int domain,
int type, int type,
int protocol); int protocol);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_close( ddsrt_close(
ddsrt_socket_t sock); ddsrt_socket_t sock);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_connect( ddsrt_connect(
ddsrt_socket_t sock, ddsrt_socket_t sock,
const struct sockaddr *addr, const struct sockaddr *addr,
socklen_t addrlen); socklen_t addrlen);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_accept( ddsrt_accept(
ddsrt_socket_t sock, ddsrt_socket_t sock,
struct sockaddr *addr, struct sockaddr *addr,
socklen_t *addrlen, socklen_t *addrlen,
ddsrt_socket_t *connptr); ddsrt_socket_t *connptr);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_listen( ddsrt_listen(
ddsrt_socket_t sock, ddsrt_socket_t sock,
int backlog); int backlog);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_bind( ddsrt_bind(
ddsrt_socket_t sock, ddsrt_socket_t sock,
const struct sockaddr *addr, const struct sockaddr *addr,
socklen_t addrlen); socklen_t addrlen);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_getsockname( ddsrt_getsockname(
ddsrt_socket_t sock, ddsrt_socket_t sock,
struct sockaddr *addr, struct sockaddr *addr,
socklen_t *addrlen); socklen_t *addrlen);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_send( ddsrt_send(
ddsrt_socket_t sock, ddsrt_socket_t sock,
const void *buf, const void *buf,
@ -86,14 +86,14 @@ ddsrt_send(
int flags, int flags,
ssize_t *sent); ssize_t *sent);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_sendmsg( ddsrt_sendmsg(
ddsrt_socket_t sock, ddsrt_socket_t sock,
const ddsrt_msghdr_t *msg, const ddsrt_msghdr_t *msg,
int flags, int flags,
ssize_t *sent); ssize_t *sent);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_recv( ddsrt_recv(
ddsrt_socket_t sock, ddsrt_socket_t sock,
void *buf, void *buf,
@ -101,14 +101,14 @@ ddsrt_recv(
int flags, int flags,
ssize_t *rcvd); ssize_t *rcvd);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_recvmsg( ddsrt_recvmsg(
ddsrt_socket_t sock, ddsrt_socket_t sock,
ddsrt_msghdr_t *msg, ddsrt_msghdr_t *msg,
int flags, int flags,
ssize_t *rcvd); ssize_t *rcvd);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_getsockopt( ddsrt_getsockopt(
ddsrt_socket_t sock, ddsrt_socket_t sock,
int32_t level, /* SOL_SOCKET */ int32_t level, /* SOL_SOCKET */
@ -116,7 +116,7 @@ ddsrt_getsockopt(
void *optval, void *optval,
socklen_t *optlen); socklen_t *optlen);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_setsockopt( ddsrt_setsockopt(
ddsrt_socket_t sock, ddsrt_socket_t sock,
int32_t level, /* SOL_SOCKET */ int32_t level, /* SOL_SOCKET */
@ -130,7 +130,7 @@ ddsrt_setsockopt(
* @param[in] sock Socket to set I/O mode for. * @param[in] sock Socket to set I/O mode for.
* @param[in] nonblock true for nonblocking, or false for blocking I/O. * @param[in] nonblock true for nonblocking, or false for blocking I/O.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* I/O mode successfully set to (non)blocking. * I/O mode successfully set to (non)blocking.
@ -141,7 +141,7 @@ ddsrt_setsockopt(
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* An unknown error error occurred. * An unknown error error occurred.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_setsocknonblocking( ddsrt_setsocknonblocking(
ddsrt_socket_t sock, ddsrt_socket_t sock,
bool nonblock); bool nonblock);
@ -228,11 +228,11 @@ ddsrt_sockaddr_insamesubnet(
const struct sockaddr *mask) const struct sockaddr *mask)
ddsrt_nonnull_all; ddsrt_nonnull_all;
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_sockaddrfromstr( ddsrt_sockaddrfromstr(
int af, const char *str, void *sa); int af, const char *str, void *sa);
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_sockaddrtostr( ddsrt_sockaddrtostr(
const void *sa, char *buf, size_t size); const void *sa, char *buf, size_t size);
@ -249,7 +249,7 @@ typedef struct {
* @param[in] af Address family, either AF_INET, AF_INET6 or AF_UNSPEC. * @param[in] af Address family, either AF_INET, AF_INET6 or AF_UNSPEC.
* @param[out] hent Structure of type ddsrt_hostent_t. * @param[out] hent Structure of type ddsrt_hostent_t.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* Host name successfully resolved to address(es). * Host name successfully resolved to address(es).
@ -262,7 +262,7 @@ typedef struct {
* @retval DDS_RETCODE_TRY_AGAIN * @retval DDS_RETCODE_TRY_AGAIN
* Nonauthoratitative host not found. * Nonauthoratitative host not found.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_gethostbyname( ddsrt_gethostbyname(
const char *name, const char *name,
int af, int af,

4
src/ddsrt/include/dds/ddsrt/string.h
View file

@ -176,7 +176,7 @@ ddsrt_nonnull((1,2));
* @param[in] buf Buffer where description is copied to. * @param[in] buf Buffer where description is copied to.
* @param[in] buflen Number of bytes available in @buf. * @param[in] buflen Number of bytes available in @buf.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* Description for @errnum was successfully copied to @buf. * Description for @errnum was successfully copied to @buf.
@ -185,7 +185,7 @@ ddsrt_nonnull((1,2));
* @retval DDS_RETCODE_NOT_ENOUGH_SPACE * @retval DDS_RETCODE_NOT_ENOUGH_SPACE
* Buffer was not large enough to hold the description. * Buffer was not large enough to hold the description.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_strerror_r( ddsrt_strerror_r(
int errnum, int errnum,
char *buf, char *buf,

8
src/ddsrt/include/dds/ddsrt/strtod.h
View file

@ -34,9 +34,9 @@ extern "C" {
* character is stored. * character is stored.
* @param[out] dblptr A double where the result is stored. * @param[out] dblptr A double where the result is stored.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_strtod(const char *nptr, char **endptr, double *dblptr); ddsrt_strtod(const char *nptr, char **endptr, double *dblptr);
/** /**
@ -47,9 +47,9 @@ ddsrt_strtod(const char *nptr, char **endptr, double *dblptr);
* character is stored. * character is stored.
* @param[out] fltptr A float where the floating-point number is stored. * @param[out] fltptr A float where the floating-point number is stored.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_strtof(const char *nptr, char **endptr, float *fltptr); ddsrt_strtof(const char *nptr, char **endptr, float *fltptr);
/** /**

16
src/ddsrt/include/dds/ddsrt/strtol.h
View file

@ -37,7 +37,7 @@ extern "C" {
* determine from @str. * determine from @str.
* @param[out] llng A long long integer where the number is stored. * @param[out] llng A long long integer where the number is stored.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* String successfully converted to an integer. * String successfully converted to an integer.
@ -46,7 +46,7 @@ extern "C" {
* @retval DDS_RETCODE_OUT_OF_RANGE * @retval DDS_RETCODE_OUT_OF_RANGE
* String converted to an integer, but was out of range. * String converted to an integer, but was out of range.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_strtoll( ddsrt_strtoll(
const char *str, const char *str,
char **endptr, char **endptr,
@ -69,7 +69,7 @@ ddsrt_strtoll(
* determine from @str. * determine from @str.
* @param[out] ullng A long long integer where the number is stored. * @param[out] ullng A long long integer where the number is stored.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* String successfully converted to an integer. * String successfully converted to an integer.
@ -78,7 +78,7 @@ ddsrt_strtoll(
* @retval DDS_RETCODE_OUT_OF_RANGE * @retval DDS_RETCODE_OUT_OF_RANGE
* String converted to an integer, but was out of range. * String converted to an integer, but was out of range.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_strtoull( ddsrt_strtoull(
const char *str, const char *str,
char **endptr, char **endptr,
@ -91,7 +91,7 @@ ddsrt_strtoull(
* @param[in] str String to convert into a long long integer. * @param[in] str String to convert into a long long integer.
* @param[in] llng A long long integer where the number is stored. * @param[in] llng A long long integer where the number is stored.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* String successfully converted to an integer. * String successfully converted to an integer.
@ -100,7 +100,7 @@ ddsrt_strtoull(
* @retval DDS_RETCODE_OUT_OF_RANGE * @retval DDS_RETCODE_OUT_OF_RANGE
* String converted to an integer, but was out of range. * String converted to an integer, but was out of range.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_atoll( ddsrt_atoll(
const char *str, const char *str,
long long *llng); long long *llng);
@ -111,7 +111,7 @@ ddsrt_atoll(
* @param[in] str String to conver into an unsigned long long integer. * @param[in] str String to conver into an unsigned long long integer.
* @param[out] ullng An unsigned long long integer where the number is stored. * @param[out] ullng An unsigned long long integer where the number is stored.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* String successfully converted to an integer. * String successfully converted to an integer.
@ -120,7 +120,7 @@ ddsrt_atoll(
* @retval DDS_RETCODE_OUT_OF_RANGE * @retval DDS_RETCODE_OUT_OF_RANGE
* String converted to an integer, but was out of range. * String converted to an integer, but was out of range.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_atoull( ddsrt_atoull(
const char *str, const char *str,
unsigned long long *ullng); unsigned long long *ullng);

2
src/ddsrt/include/dds/ddsrt/thread_pool.h
View file

@ -55,7 +55,7 @@ DDS_EXPORT void ddsrt_thread_pool_purge (ddsrt_thread_pool pool);
Note that if the pool queue has reached it's maximum DDS_RETCODE_TRY_AGAIN is returned. Note that if the pool queue has reached it's maximum DDS_RETCODE_TRY_AGAIN is returned.
*/ */
DDS_EXPORT dds_retcode_t ddsrt_thread_pool_submit DDS_EXPORT dds_return_t ddsrt_thread_pool_submit
( (
ddsrt_thread_pool pool, /* Thread pool instance */ ddsrt_thread_pool pool, /* Thread pool instance */
void (*fn) (void *arg), /* Function to be invoked by thread from pool */ void (*fn) (void *arg), /* Function to be invoked by thread from pool */

12
src/ddsrt/include/dds/ddsrt/threads.h
View file

@ -121,14 +121,14 @@ ddsrt_nonnull_all;
* @param[in] start_routine Function to execute in created thread. * @param[in] start_routine Function to execute in created thread.
* @param[in] arg Argument passed to @start_routine. * @param[in] arg Argument passed to @start_routine.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* Thread successfully created. * Thread successfully created.
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* Thread could not be created. * Thread could not be created.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_thread_create( ddsrt_thread_create(
ddsrt_thread_t *thread, ddsrt_thread_t *thread,
const char *name, const char *name,
@ -172,14 +172,14 @@ ddsrt_thread_equal(ddsrt_thread_t t1, ddsrt_thread_t t2);
* @param[in] thread Id of thread to wait for. * @param[in] thread Id of thread to wait for.
* @param[out] thread_result Location where thread result is stored. * @param[out] thread_result Location where thread result is stored.
* *
* @returns A dds_retcode_t indicating success or failure. * @returns A dds_return_t indicating success or failure.
* *
* @retval DDS_RETCODE_OK * @retval DDS_RETCODE_OK
* Target thread terminated. * Target thread terminated.
* @retval DDS_RETCODE_ERROR * @retval DDS_RETCODE_ERROR
* An error occurred while waiting for the thread to terminate. * An error occurred while waiting for the thread to terminate.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_thread_join( ddsrt_thread_join(
ddsrt_thread_t thread, ddsrt_thread_t thread,
uint32_t *thread_result); uint32_t *thread_result);
@ -224,7 +224,7 @@ ddsrt_thread_setname(
* @param[in] routine Cleanup handler to push onto the thread cleanup stack. * @param[in] routine Cleanup handler to push onto the thread cleanup stack.
* @param[in] arg Argument that will be passed to the cleanup handler. * @param[in] arg Argument that will be passed to the cleanup handler.
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_thread_cleanup_push( ddsrt_thread_cleanup_push(
void (*routine)(void*), void (*routine)(void*),
void *arg); void *arg);
@ -235,7 +235,7 @@ ddsrt_thread_cleanup_push(
* Remove routine at the top of the calling thread's cleanup stack and * Remove routine at the top of the calling thread's cleanup stack and
* optionally invoke it (if execute is non-zero). * optionally invoke it (if execute is non-zero).
*/ */
DDS_EXPORT dds_retcode_t DDS_EXPORT dds_return_t
ddsrt_thread_cleanup_pop( ddsrt_thread_cleanup_pop(
int execute); int execute);

6
src/ddsrt/src/environ/posix/environ.c
View file

@ -23,7 +23,7 @@ isenvvar(const char *name)
return (*name == '\0' || strchr(name, '=') != NULL) == 0; return (*name == '\0' || strchr(name, '=') != NULL) == 0;
} }
dds_retcode_t dds_return_t
ddsrt_getenv(const char *name, char **value) ddsrt_getenv(const char *name, char **value)
{ {
char *env; char *env;
@ -40,7 +40,7 @@ ddsrt_getenv(const char *name, char **value)
return DDS_RETCODE_NOT_FOUND; return DDS_RETCODE_NOT_FOUND;
} }
dds_retcode_t dds_return_t
ddsrt_setenv(const char *name, const char *value) ddsrt_setenv(const char *name, const char *value)
{ {
assert(name != NULL); assert(name != NULL);
@ -65,7 +65,7 @@ ddsrt_setenv(const char *name, const char *value)
return DDS_RETCODE_ERROR; return DDS_RETCODE_ERROR;
} }
dds_retcode_t dds_return_t
ddsrt_unsetenv(const char *name) ddsrt_unsetenv(const char *name)
{ {
assert(name != NULL); assert(name != NULL);

6
src/ddsrt/src/environ/windows/environ.c
View file

@ -25,7 +25,7 @@ isenvvar(const char *name)
} }
DDSRT_WARNING_MSVC_OFF(4996) DDSRT_WARNING_MSVC_OFF(4996)
dds_retcode_t dds_return_t
ddsrt_getenv(const char *name, char **value) ddsrt_getenv(const char *name, char **value)
{ {
char *env; char *env;
@ -43,7 +43,7 @@ ddsrt_getenv(const char *name, char **value)
} }
DDSRT_WARNING_MSVC_ON(4996) DDSRT_WARNING_MSVC_ON(4996)
dds_retcode_t dds_return_t
ddsrt_setenv(const char *name, const char *value) ddsrt_setenv(const char *name, const char *value)
{ {
assert(name != NULL); assert(name != NULL);
@ -65,7 +65,7 @@ ddsrt_setenv(const char *name, const char *value)
return DDS_RETCODE_ERROR; return DDS_RETCODE_ERROR;
} }
dds_retcode_t dds_return_t
ddsrt_unsetenv(const char *name) ddsrt_unsetenv(const char *name)
{ {
assert(name != NULL); assert(name != NULL);

8
src/ddsrt/src/ifaddrs/posix/ifaddrs.c
View file

@ -21,10 +21,10 @@
extern const int *const os_supp_afs; extern const int *const os_supp_afs;
static dds_retcode_t static dds_return_t
copyaddr(ddsrt_ifaddrs_t **ifap, const struct ifaddrs *sys_ifa) copyaddr(ddsrt_ifaddrs_t **ifap, const struct ifaddrs *sys_ifa)
{ {
dds_retcode_t err = DDS_RETCODE_OK; dds_return_t err = DDS_RETCODE_OK;
ddsrt_ifaddrs_t *ifa; ddsrt_ifaddrs_t *ifa;
size_t sz; size_t sz;
@ -64,12 +64,12 @@ copyaddr(ddsrt_ifaddrs_t **ifap, const struct ifaddrs *sys_ifa)
return err; return err;
} }
dds_retcode_t dds_return_t
ddsrt_getifaddrs( ddsrt_getifaddrs(
ddsrt_ifaddrs_t **ifap, ddsrt_ifaddrs_t **ifap,
const int *afs) const int *afs)
{ {
dds_retcode_t err = DDS_RETCODE_OK; dds_return_t err = DDS_RETCODE_OK;
int use; int use;
ddsrt_ifaddrs_t *ifa, *ifa_root, *ifa_next; ddsrt_ifaddrs_t *ifa, *ifa_root, *ifa_next;
struct ifaddrs *sys_ifa, *sys_ifa_root; struct ifaddrs *sys_ifa, *sys_ifa_root;

12
src/ddsrt/src/ifaddrs/windows/ifaddrs.c
View file

@ -23,10 +23,10 @@
extern const int *const os_supp_afs; extern const int *const os_supp_afs;
static dds_retcode_t static dds_return_t
getifaces(PIP_ADAPTER_ADDRESSES *ptr) getifaces(PIP_ADAPTER_ADDRESSES *ptr)
{ {
dds_retcode_t err = DDS_RETCODE_NOT_ENOUGH_SPACE; dds_return_t err = DDS_RETCODE_NOT_ENOUGH_SPACE;
PIP_ADAPTER_ADDRESSES buf = NULL; PIP_ADAPTER_ADDRESSES buf = NULL;
ULONG bufsz = 0; /* Size is determined on first iteration. */ ULONG bufsz = 0; /* Size is determined on first iteration. */
ULONG ret; ULONG ret;
@ -72,10 +72,10 @@ getifaces(PIP_ADAPTER_ADDRESSES *ptr)
return err; return err;
} }
static dds_retcode_t static dds_return_t
getaddrtable(PMIB_IPADDRTABLE *ptr) getaddrtable(PMIB_IPADDRTABLE *ptr)
{ {
dds_retcode_t err = DDS_RETCODE_NOT_ENOUGH_SPACE; dds_return_t err = DDS_RETCODE_NOT_ENOUGH_SPACE;
PMIB_IPADDRTABLE buf = NULL; PMIB_IPADDRTABLE buf = NULL;
ULONG bufsz = 0; ULONG bufsz = 0;
DWORD ret; DWORD ret;
@ -159,7 +159,7 @@ copyaddr(
const PMIB_IPADDRTABLE addrtable, const PMIB_IPADDRTABLE addrtable,
const PIP_ADAPTER_UNICAST_ADDRESS addr) const PIP_ADAPTER_UNICAST_ADDRESS addr)
{ {
dds_retcode_t err = DDS_RETCODE_OK; dds_return_t err = DDS_RETCODE_OK;
ddsrt_ifaddrs_t *ifa; ddsrt_ifaddrs_t *ifa;
struct sockaddr *sa; struct sockaddr *sa;
size_t sz; size_t sz;
@ -220,7 +220,7 @@ copyaddr(
return err; return err;
} }
dds_retcode_t dds_return_t
ddsrt_getifaddrs( ddsrt_getifaddrs(
ddsrt_ifaddrs_t **ifap, ddsrt_ifaddrs_t **ifap,
const int *afs) const int *afs)

16
src/ddsrt/src/process/posix/process.c
View file

@ -72,7 +72,7 @@ static void no_op(int sig)
} }
static dds_retcode_t static dds_return_t
waitpids( waitpids(
ddsrt_pid_t request_pid, ddsrt_pid_t request_pid,
dds_duration_t timeout, dds_duration_t timeout,
@ -81,7 +81,7 @@ waitpids(
{ {
struct sigaction sigactold; struct sigaction sigactold;
struct sigaction sigact; struct sigaction sigact;
dds_retcode_t rv; dds_return_t rv;
int options = 0; int options = 0;
int ret; int ret;
int s; int s;
@ -148,13 +148,13 @@ waitpids(
dds_retcode_t dds_return_t
ddsrt_proc_create( ddsrt_proc_create(
const char *executable, const char *executable,
char *const argv[], char *const argv[],
ddsrt_pid_t *pid) ddsrt_pid_t *pid)
{ {
dds_retcode_t rv; dds_return_t rv;
char **exec_argv; char **exec_argv;
int exec_fds[2]; int exec_fds[2];
int exec_err; int exec_err;
@ -253,7 +253,7 @@ fail_pipe:
dds_retcode_t dds_return_t
ddsrt_proc_waitpid( ddsrt_proc_waitpid(
ddsrt_pid_t pid, ddsrt_pid_t pid,
dds_duration_t timeout, dds_duration_t timeout,
@ -267,7 +267,7 @@ ddsrt_proc_waitpid(
dds_retcode_t dds_return_t
ddsrt_proc_waitpids( ddsrt_proc_waitpids(
dds_duration_t timeout, dds_duration_t timeout,
ddsrt_pid_t *pid, ddsrt_pid_t *pid,
@ -278,7 +278,7 @@ ddsrt_proc_waitpids(
dds_retcode_t dds_return_t
ddsrt_proc_exists( ddsrt_proc_exists(
ddsrt_pid_t pid) ddsrt_pid_t pid)
{ {
@ -294,7 +294,7 @@ ddsrt_proc_exists(
dds_retcode_t dds_return_t
ddsrt_proc_kill( ddsrt_proc_kill(
ddsrt_pid_t pid) ddsrt_pid_t pid)
{ {

30
src/ddsrt/src/process/windows/process.c
View file

@ -30,8 +30,8 @@ ddsrt_getpid(void)
static HANDLE pid_to_phdl (ddsrt_pid_t pid); static HANDLE pid_to_phdl (ddsrt_pid_t pid);
static dds_retcode_t process_get_exit_code(HANDLE phdl, int32_t *code); static dds_return_t process_get_exit_code(HANDLE phdl, int32_t *code);
static dds_retcode_t process_kill (HANDLE phdl); static dds_return_t process_kill (HANDLE phdl);
static char* commandline (const char *exe, char *const argv_in[]); static char* commandline (const char *exe, char *const argv_in[]);
static BOOL child_add (HANDLE phdl); static BOOL child_add (HANDLE phdl);
static void child_remove (HANDLE phdl); static void child_remove (HANDLE phdl);
@ -40,13 +40,13 @@ static HANDLE child_handle (ddsrt_pid_t pid);
dds_retcode_t dds_return_t
ddsrt_proc_create( ddsrt_proc_create(
const char *executable, const char *executable,
char *const argv[], char *const argv[],
ddsrt_pid_t *pid) ddsrt_pid_t *pid)
{ {
dds_retcode_t rv = DDS_RETCODE_ERROR; dds_return_t rv = DDS_RETCODE_ERROR;
PROCESS_INFORMATION process_info; PROCESS_INFORMATION process_info;
STARTUPINFO si; STARTUPINFO si;
char *cmd; char *cmd;
@ -111,13 +111,13 @@ ddsrt_proc_create(
dds_retcode_t dds_return_t
ddsrt_proc_waitpid( ddsrt_proc_waitpid(
ddsrt_pid_t pid, ddsrt_pid_t pid,
dds_duration_t timeout, dds_duration_t timeout,
int32_t *code) int32_t *code)
{ {
dds_retcode_t rv = DDS_RETCODE_OK; dds_return_t rv = DDS_RETCODE_OK;
HANDLE phdl; HANDLE phdl;
DWORD ret; DWORD ret;
@ -155,13 +155,13 @@ ddsrt_proc_waitpid(
dds_retcode_t dds_return_t
ddsrt_proc_waitpids( ddsrt_proc_waitpids(
dds_duration_t timeout, dds_duration_t timeout,
ddsrt_pid_t *pid, ddsrt_pid_t *pid,
int32_t *code) int32_t *code)
{ {
dds_retcode_t rv = DDS_RETCODE_OK; dds_return_t rv = DDS_RETCODE_OK;
HANDLE hdls[MAXIMUM_WAIT_OBJECTS]; HANDLE hdls[MAXIMUM_WAIT_OBJECTS];
HANDLE phdl; HANDLE phdl;
DWORD cnt; DWORD cnt;
@ -208,11 +208,11 @@ ddsrt_proc_waitpids(
dds_retcode_t dds_return_t
ddsrt_proc_exists( ddsrt_proc_exists(
ddsrt_pid_t pid) ddsrt_pid_t pid)
{ {
dds_retcode_t rv = DDS_RETCODE_NOT_FOUND; dds_return_t rv = DDS_RETCODE_NOT_FOUND;
HANDLE phdl; HANDLE phdl;
phdl = pid_to_phdl(pid); phdl = pid_to_phdl(pid);
@ -235,11 +235,11 @@ ddsrt_proc_exists(
dds_retcode_t dds_return_t
ddsrt_proc_kill( ddsrt_proc_kill(
ddsrt_pid_t pid) ddsrt_pid_t pid)
{ {
dds_retcode_t rv = DDS_RETCODE_BAD_PARAMETER; dds_return_t rv = DDS_RETCODE_BAD_PARAMETER;
HANDLE phdl; HANDLE phdl;
phdl = pid_to_phdl(pid); phdl = pid_to_phdl(pid);
@ -262,12 +262,12 @@ pid_to_phdl(ddsrt_pid_t pid)
static dds_retcode_t static dds_return_t
process_get_exit_code( process_get_exit_code(
HANDLE phdl, HANDLE phdl,
int32_t *code) int32_t *code)
{ {
dds_retcode_t rv = DDS_RETCODE_ERROR; dds_return_t rv = DDS_RETCODE_ERROR;
DWORD tr; DWORD tr;
assert(phdl != 0); assert(phdl != 0);
@ -289,7 +289,7 @@ process_get_exit_code(
/* Forcefully kill the given process. */ /* Forcefully kill the given process. */
static dds_retcode_t static dds_return_t
process_kill(HANDLE phdl) process_kill(HANDLE phdl)
{ {
assert(phdl != 0); assert(phdl != 0);

26
src/ddsrt/src/retcode.c
View file

@ -11,8 +11,7 @@
*/ */
#include "dds/ddsrt/retcode.h" #include "dds/ddsrt/retcode.h"
static const char *retcodes[] = static const char *retcodes[] = {
{
"Success", "Success",
"Error", "Error",
"Unsupported", "Unsupported",
@ -42,19 +41,20 @@ static const char *xretcodes[] = {
"Not found" "Not found"
}; };
const char * const char *dds_strretcode (dds_return_t rc)
dds_strretcode (dds_retcode_t rc)
{ {
if (rc >= 0 && const dds_return_t nretcodes = (dds_return_t) (sizeof (retcodes) / sizeof (retcodes[0]));
rc < (dds_retcode_t)(sizeof(retcodes) / sizeof(retcodes[0]))) const dds_return_t nxretcodes = (dds_return_t) (sizeof (xretcodes) / sizeof (xretcodes[0]));
{ /* Retcodes used to be positive, but return values from the API would be a negative
and so there are/were/may be places outside the core library where dds_strretcode
is called with a -N for N a API return value, so ... play it safe and use the
magnitude */
if (rc < 0)
rc = -rc;
if (rc >= 0 && rc < nretcodes)
return retcodes[rc]; return retcodes[rc];
} else if (rc >= (DDS_XRETCODE_BASE) && else if (rc >= DDS_XRETCODE_BASE && rc < DDS_XRETCODE_BASE + nxretcodes)
rc < (dds_retcode_t)(DDS_XRETCODE_BASE + (sizeof(xretcodes) / sizeof(xretcodes[0]))))
{
return xretcodes[rc - DDS_XRETCODE_BASE]; return xretcodes[rc - DDS_XRETCODE_BASE];
} else
return "Unknown return code"; return "Unknown return code";
} }

4
src/ddsrt/src/rusage/posix/rusage.c
View file

@ -23,12 +23,12 @@
#include "dds/ddsrt/rusage.h" #include "dds/ddsrt/rusage.h"
dds_retcode_t dds_return_t
ddsrt_getrusage(int who, ddsrt_rusage_t *usage) ddsrt_getrusage(int who, ddsrt_rusage_t *usage)
{ {
int err = 0; int err = 0;
struct rusage buf; struct rusage buf;
dds_retcode_t rc; dds_return_t rc;
assert(who == DDSRT_RUSAGE_SELF || who == DDSRT_RUSAGE_THREAD); assert(who == DDSRT_RUSAGE_SELF || who == DDSRT_RUSAGE_THREAD);
assert(usage != NULL); assert(usage != NULL);

Some files were not shown because too many files have changed in this diff Show more