diff --git a/src/core/ddsc/include/dds/dds.h b/src/core/ddsc/include/dds/dds.h index add219b..beff47b 100644 --- a/src/core/ddsc/include/dds/dds.h +++ b/src/core/ddsc/include/dds/dds.h @@ -26,17 +26,10 @@ #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 - * integer value. Should the value be negative, the value represents a unique - * error code. dds_err_nr() can be used to extract the DDS_RETCODE_* value. + * integer value. Should the value be negative, it is one of the DDS_RETCODE_* + * error codes. */ 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. */ /* TODO: Complete list of error codes */ -DDS_EXPORT int +DDS_EXPORT dds_return_t dds_reader_wait_for_historical_data( dds_entity_t reader, dds_duration_t max_wait); diff --git a/src/core/ddsc/include/dds/ddsc/dds_public_error.h b/src/core/ddsc/include/dds/ddsc/dds_public_error.h index b574371..bc73a57 100644 --- a/src/core/ddsc/include/dds/ddsc/dds_public_error.h +++ b/src/core/ddsc/include/dds/ddsc/dds_public_error.h @@ -28,6 +28,8 @@ extern "C" { #endif +/* ** DEPRECATED ** */ + /* Error masks for returned status values */ #define DDS_ERR_NR_MASK 0x000000ff @@ -37,13 +39,13 @@ extern "C" { /* Error code handling functions */ /** 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 */ -#define dds_err_line(e) (((-(e)) & DDS_ERR_LINE_MASK) >> 8) +#define dds_err_line(e) (0) /** 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) } diff --git a/src/core/ddsc/include/dds/ddsc/dds_public_status.h b/src/core/ddsc/include/dds/ddsc/dds_public_status.h index ce9ae79..40df7d6 100644 --- a/src/core/ddsc/include/dds/ddsc/dds_public_status.h +++ b/src/core/ddsc/include/dds/ddsc/dds_public_status.h @@ -185,7 +185,7 @@ dds_inconsistent_topic_status_t; * @param[out] status The pointer to \ref DCPS_Status_InconsistentTopic to get the status * * @returns 0 - Success - * @returns <0 - Failure (use dds_err_nr() to get error value). + * @returns <0 - Failure * * @retval DDS_RETCODE_ERROR * 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 * * @returns 0 - Success - * @returns <0 - Failure (use dds_err_nr() to get error value). + * @returns <0 - Failure * * @retval DDS_RETCODE_ERROR * 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 * * @returns 0 - Success - * @returns <0 - Failure (use dds_err_nr() to get error value). + * @returns <0 - Failure * * @retval DDS_RETCODE_ERROR * 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 * * @returns 0 - Success - * @returns <0 - Failure (use dds_err_nr() to get error value). + * @returns <0 - Failure * * @retval DDS_RETCODE_ERROR * 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 * * @returns 0 - Success - * @returns <0 - Failure (use dds_err_nr() to get error value). + * @returns <0 - Failure * * @retval DDS_RETCODE_ERROR * 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 * * @returns 0 - Success - * @returns <0 - Failure (use dds_err_nr() to get error value). + * @returns <0 - Failure * * @retval DDS_RETCODE_ERROR * 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 * * @returns 0 - Success - * @returns <0 - Failure (use dds_err_nr() to get error value). + * @returns <0 - Failure * * @retval DDS_RETCODE_ERROR * 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 * * @returns 0 - Success - * @returns <0 - Failure (use dds_err_nr() to get error value). + * @returns <0 - Failure * * @retval DDS_RETCODE_ERROR * An internal error has occurred. diff --git a/src/core/ddsc/src/dds__entity.h b/src/core/ddsc/src/dds__entity.h index 34c13c5..f74b03e 100644 --- a/src/core/ddsc/src/dds__entity.h +++ b/src/core/ddsc/src/dds__entity.h @@ -35,9 +35,9 @@ DDS_EXPORT void dds_entity_add_ref_nolock(dds_entity *e); #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; \ if ((rc = dds_entity_lock (hdl, kind_, &e)) != DDS_RETCODE_OK) \ return rc; \ @@ -50,7 +50,7 @@ dds_entity_add_ref_nolock(dds_entity *e); dds_entity_unlock (&x->m_entity); \ } #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); 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 dds_retcode_t +DDS_EXPORT dds_return_t dds_entity_claim ( dds_entity_t hdl, dds_entity **eptr); @@ -87,7 +87,7 @@ dds_entity_claim ( DDS_EXPORT void dds_entity_release ( dds_entity *e); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t dds_entity_lock( dds_entity_t hdl, dds_entity_kind_t kind, @@ -96,24 +96,24 @@ dds_entity_lock( DDS_EXPORT void dds_entity_unlock(dds_entity *e); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t dds_entity_observer_register_nl( dds_entity *observed, dds_entity_t observer, dds_entity_callback cb); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t dds_entity_observer_register( dds_entity_t observed, dds_entity_t observer, dds_entity_callback cb); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t dds_entity_observer_unregister_nl( dds_entity *observed, dds_entity_t observer); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t dds_entity_observer_unregister( dds_entity_t observed, dds_entity_t observer); diff --git a/src/core/ddsc/src/dds__err.h b/src/core/ddsc/src/dds__err.h deleted file mode 100644 index a54be27..0000000 --- a/src/core/ddsc/src/dds__err.h +++ /dev/null @@ -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 - -#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 diff --git a/src/core/ddsc/src/dds_builtin.c b/src/core/ddsc/src/dds_builtin.c index fff187a..01c98e5 100644 --- a/src/core/ddsc/src/dds_builtin.c +++ b/src/core/ddsc/src/dds_builtin.c @@ -18,7 +18,6 @@ #include "dds__qos.h" #include "dds__domain.h" #include "dds__participant.h" -#include "dds__err.h" #include "dds__types.h" #include "dds__builtin.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; } else { assert (0); - return DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + return DDS_RETCODE_BAD_PARAMETER; } dds_qos_t *qos = dds__create_builtin_qos (); diff --git a/src/core/ddsc/src/dds_coherent.c b/src/core/ddsc/src/dds_coherent.c index 6123a47..f2f1063 100644 --- a/src/core/ddsc/src/dds_coherent.c +++ b/src/core/ddsc/src/dds_coherent.c @@ -15,7 +15,6 @@ #include "dds__entity.h" #include "dds__subscriber.h" #include "dds__publisher.h" -#include "dds__err.h" dds_return_t dds_begin_coherent( diff --git a/src/core/ddsc/src/dds_entity.c b/src/core/ddsc/src/dds_entity.c index 7d62349..176a7eb 100644 --- a/src/core/ddsc/src/dds_entity.c +++ b/src/core/ddsc/src/dds_entity.c @@ -19,7 +19,6 @@ #include "dds__writer.h" #include "dds__reader.h" #include "dds__listener.h" -#include "dds__err.h" #include "dds/version.h" 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) { dds_entity *e; - dds_retcode_t rc; + dds_return_t rc; if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) == DDS_RETCODE_OK) { 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 *next = NULL; dds_return_t ret; - dds_retcode_t rc; + dds_return_t rc; rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e); 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); - return DDS_ERRNO (rc); + return rc; } 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 *e; - dds_retcode_t rc; + dds_return_t rc; if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) - return DDS_ERRNO (rc); + return rc; else { 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 *e; - dds_retcode_t rc; + dds_return_t rc; if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) - return DDS_ERRNO (rc); + return rc; else { 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_entity *e; - dds_retcode_t rc; + dds_return_t rc; 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) - 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) - return DDS_ERRNO (rc); + return rc; else { 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_entity *e; - dds_retcode_t rc; dds_return_t ret; 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) - return DDS_ERRNO (rc); + if ((ret = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) + return ret; if (e->m_deriver.set_qos == 0) - ret = DDS_ERRNO(DDS_RETCODE_ILLEGAL_OPERATION); + ret = DDS_RETCODE_ILLEGAL_OPERATION; else { 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_entity *e; - dds_retcode_t rc; dds_return_t ret; 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) - return DDS_ERRNO (rc); + if ((ret = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) + return ret; if (e->m_deriver.set_qos == 0) - ret = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); + ret = DDS_RETCODE_ILLEGAL_OPERATION; else { if ((ret = e->m_deriver.set_qos (e, qos, e->m_flags & DDS_ENTITY_ENABLED)) == DDS_RETCODE_OK) { if (e->m_qos == NULL) e->m_qos = dds_create_qos (); - rc = dds_copy_qos (e->m_qos, qos); - ret = DDS_ERRNO (rc); + ret = dds_copy_qos (e->m_qos, qos); } } 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_entity *e; - dds_return_t ret = DDS_RETCODE_OK; - dds_retcode_t rc; - - if (listener != NULL) { - rc = dds_entity_lock(entity, DDS_KIND_DONTCARE, &e); - if (rc == DDS_RETCODE_OK) { - ddsrt_mutex_lock (&e->m_observers_lock); - dds_copy_listener (listener, &e->m_listener); - ddsrt_mutex_unlock (&e->m_observers_lock); - dds_entity_unlock(e); - } else { - ret = DDS_ERRNO(rc); - } - } else { - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + dds_return_t ret; + if (listener == NULL) + return DDS_RETCODE_BAD_PARAMETER; + else if ((ret = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) + return ret; + else + { + ddsrt_mutex_lock (&e->m_observers_lock); + dds_copy_listener (listener, &e->m_listener); + ddsrt_mutex_unlock (&e->m_observers_lock); + dds_entity_unlock(e); + return DDS_RETCODE_OK; } - - return ret; } 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_entity *e, *x; - dds_retcode_t rc; + dds_return_t rc; if ((rc = dds_entity_claim (entity, &e)) != DDS_RETCODE_OK) - return DDS_ERRNO (rc); + return rc; ddsrt_mutex_lock (&e->m_observers_lock); 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_entity *e; - dds_retcode_t rc; + dds_return_t rc; 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) { @@ -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_entity *e; - dds_retcode_t rc; dds_return_t ret; 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) - return DDS_ERRNO (rc); + if ((ret = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) + return ret; if (e->m_deriver.validate_status == 0) - ret = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); + ret = DDS_RETCODE_ILLEGAL_OPERATION; else { 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_entity *e; - dds_retcode_t rc; dds_return_t ret; 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) - return DDS_ERRNO (rc); + if ((ret = dds_entity_claim (entity, &e)) != DDS_RETCODE_OK) + return ret; if (e->m_deriver.validate_status == 0) - ret = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); + ret = DDS_RETCODE_ILLEGAL_OPERATION; else { 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_entity *e; - dds_retcode_t rc; dds_return_t ret; - if ((rc = dds_entity_claim (entity, &e)) != DDS_RETCODE_OK) - return DDS_ERRNO (rc); + if ((ret = dds_entity_claim (entity, &e)) != DDS_RETCODE_OK) + return ret; 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) { 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) { dds_entity *e; - dds_retcode_t rc; dds_return_t ret; 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) - return DDS_ERRNO (rc); + if ((ret = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) + return ret; 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) { 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_entity *e; - dds_retcode_t rc; + dds_return_t rc; 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) - return DDS_ERRNO (rc); + return rc; *id = e->m_domainid; 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_entity *e; - dds_retcode_t rc; dds_return_t ret; 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) - return DDS_ERRNO (rc); + if ((ret = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) + return ret; if (e->m_deriver.get_instance_hdl) ret = e->m_deriver.get_instance_hdl (e, ihdl); else - ret = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); + ret = DDS_RETCODE_ILLEGAL_OPERATION; dds_entity_unlock(e); 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; if ((hres = dds_handle_claim (hdl, &hdllink)) != DDS_RETCODE_OK) return hres; @@ -772,9 +758,9 @@ void dds_entity_release (dds_entity *e) 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; /* 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_return_t ret; - dds_retcode_t rc; - if ((rc = dds_entity_lock(entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) - return DDS_ERRNO (rc); + if ((ret = dds_entity_lock(entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) + return ret; ddsrt_mutex_lock (&e->m_observers_lock); ret = (e->m_trigger != 0); 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; } -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); ddsrt_mutex_lock (&observed->m_observers_lock); 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; } -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; assert (cb); 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; } -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; 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; } -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; if ((rc = dds_entity_lock (observed, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) 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_retcode_t rc; + dds_return_t rc; dds_entity_t hdl; dds_entity *e; if ((rc = dds_entity_lock (entity, DDS_KIND_DONTCARE, &e)) != DDS_RETCODE_OK) - return DDS_ERRNO (rc); + return rc; switch (dds_entity_kind (e)) { case DDS_KIND_READER: { @@ -973,7 +958,7 @@ dds_entity_t dds_get_topic (dds_entity_t entity) break; } default: { - hdl = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); + hdl = DDS_RETCODE_ILLEGAL_OPERATION; 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_entity *e; - dds_retcode_t ret; + dds_return_t ret; if ((ret = dds_entity_claim (handle, &e)) != DDS_RETCODE_OK) - return DDS_ERRNO (ret); + return ret; else { 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); - return DDS_ERRNO (ret); + return ret; } } diff --git a/src/core/ddsc/src/dds_guardcond.c b/src/core/ddsc/src/dds_guardcond.c index c4feee0..9b3b0ca 100644 --- a/src/core/ddsc/src/dds_guardcond.c +++ b/src/core/ddsc/src/dds_guardcond.c @@ -14,7 +14,6 @@ #include "dds__reader.h" #include "dds__guardcond.h" #include "dds__participant.h" -#include "dds__err.h" #include "dds/ddsi/q_ephash.h" #include "dds/ddsi/q_entity.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_participant *pp; - dds_retcode_t rc; + dds_return_t rc; if ((rc = dds_participant_lock (participant, &pp)) != DDS_RETCODE_OK) - return DDS_ERRNO (rc); + return rc; else { 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_guardcond *gcond; - dds_retcode_t rc; + dds_return_t rc; if ((rc = dds_guardcond_lock (condition, &gcond)) != DDS_RETCODE_OK) - return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); + return rc; else { 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_guardcond *gcond; - dds_retcode_t rc; + dds_return_t rc; if (triggered == NULL) - return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); + return DDS_RETCODE_BAD_PARAMETER; *triggered = false; if ((rc = dds_guardcond_lock (condition, &gcond)) != DDS_RETCODE_OK) - return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); + return rc; else { 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_guardcond *gcond; - dds_retcode_t rc; + dds_return_t rc; if (triggered == NULL) - return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); + return DDS_RETCODE_BAD_PARAMETER; *triggered = false; if ((rc = dds_guardcond_lock (condition, &gcond)) != DDS_RETCODE_OK) - return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); + return rc; else { ddsrt_mutex_lock (&gcond->m_entity.m_observers_lock); diff --git a/src/core/ddsc/src/dds_handles.c b/src/core/ddsc/src/dds_handles.c index dd509dd..eff8005 100644 --- a/src/core/ddsc/src/dds_handles.c +++ b/src/core/ddsc/src/dds_handles.c @@ -19,7 +19,6 @@ #include "dds/ddsi/q_thread.h" #include "dds__handles.h" #include "dds__types.h" -#include "dds__err.h" /* 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 @@ -128,7 +127,7 @@ dds_handle_t dds_handle_create (struct dds_handle_link *link) if (handles.count == MAX_HANDLES) { ddsrt_mutex_unlock (&handles.lock); - ret = DDS_ERRNO (DDS_RETCODE_OUT_OF_RESOURCES); + ret = DDS_RETCODE_OUT_OF_RESOURCES; } else { diff --git a/src/core/ddsc/src/dds_init.c b/src/core/ddsc/src/dds_init.c index 9db9187..ce068eb 100644 --- a/src/core/ddsc/src/dds_init.c +++ b/src/core/ddsc/src/dds_init.c @@ -20,7 +20,6 @@ #include "dds__init.h" #include "dds__rhc.h" #include "dds__domain.h" -#include "dds__err.h" #include "dds__builtin.h" #include "dds__whc_builtintopic.h" #include "dds/ddsi/ddsi_iid.h" @@ -87,7 +86,7 @@ dds_init(dds_domainid_t domain) if (dds_cfgst == NULL) { 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; } @@ -97,7 +96,7 @@ dds_init(dds_domainid_t domain) if (domain < 0 || domain > 230) { 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; } else if (config.domainId.isdefault) @@ -107,7 +106,7 @@ dds_init(dds_domainid_t domain) else if (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; } } @@ -119,7 +118,7 @@ dds_init(dds_domainid_t domain) if (rtps_config_prep(dds_cfgst) != 0) { DDS_LOG(DDS_LC_CONFIG, "Failed to configure RTPS\n"); - ret = DDS_ERRNO(DDS_RETCODE_ERROR); + ret = DDS_RETCODE_ERROR; goto fail_rtps_config; } @@ -135,7 +134,7 @@ dds_init(dds_domainid_t domain) if (gv.threadmon == NULL) { 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; } } @@ -143,14 +142,14 @@ dds_init(dds_domainid_t domain) if (rtps_init () < 0) { DDS_LOG(DDS_LC_CONFIG, "Failed to initialize RTPS\n"); - ret = DDS_ERRNO(DDS_RETCODE_ERROR); + ret = DDS_RETCODE_ERROR; goto fail_rtps_init; } if (dds_handle_server_init (free_via_gc) != DDS_RETCODE_OK) { DDS_ERROR("Failed to initialize internal handle server\n"); - ret = DDS_ERRNO(DDS_RETCODE_ERROR); + ret = DDS_RETCODE_ERROR; goto fail_handleserver; } @@ -159,14 +158,14 @@ dds_init(dds_domainid_t domain) if (rtps_start () < 0) { DDS_LOG(DDS_LC_CONFIG, "Failed to start RTPS\n"); - ret = DDS_ERRNO(DDS_RETCODE_ERROR); + ret = DDS_RETCODE_ERROR; goto fail_rtps_start; } if (gv.threadmon && ddsi_threadmon_start(gv.threadmon) < 0) { DDS_ERROR("Failed to start the servicelease\n"); - ret = DDS_ERRNO(DDS_RETCODE_ERROR); + ret = DDS_RETCODE_ERROR; goto fail_threadmon_start; } @@ -299,7 +298,7 @@ dds__check_domain( { DDS_ERROR("Inconsistent domain configuration detected: domain on " "configuration: %"PRId32", domain %"PRId32"\n", dds_global.m_default_domain, domain); - ret = DDS_ERRNO(DDS_RETCODE_ERROR); + ret = DDS_RETCODE_ERROR; } } return ret; diff --git a/src/core/ddsc/src/dds_instance.c b/src/core/ddsc/src/dds_instance.c index 7b8b93e..cef2032 100644 --- a/src/core/ddsc/src/dds_instance.c +++ b/src/core/ddsc/src/dds_instance.c @@ -17,7 +17,6 @@ #include "dds__write.h" #include "dds__writer.h" #include "dds__rhc.h" -#include "dds__err.h" #include "dds/ddsi/ddsi_tkmap.h" #include "dds/ddsi/ddsi_serdata.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) { const dds_topic * topic = NULL; - dds_retcode_t rc; + dds_return_t rc; dds_entity *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; dds_writer *wr; dds_return_t ret; - dds_retcode_t rc; if(data == NULL){ - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); - goto err; + return DDS_RETCODE_BAD_PARAMETER; } if(handle == NULL){ - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); - goto err; + return DDS_RETCODE_BAD_PARAMETER; } - rc = dds_writer_lock(writer, &wr); - if (rc != DDS_RETCODE_OK) { - ret = DDS_ERRNO(rc); + ret = dds_writer_lock(writer, &wr); + if (ret != DDS_RETCODE_OK) { goto err; } thread_state_awake (ts1); @@ -152,7 +147,7 @@ dds_register_instance( *handle = inst->m_iid; ret = DDS_RETCODE_OK; } else { - ret = DDS_ERRNO(DDS_RETCODE_ERROR); + ret = DDS_RETCODE_ERROR; } thread_state_asleep (ts1); dds_writer_unlock(wr); @@ -184,22 +179,20 @@ dds_unregister_instance_ts( { struct thread_state1 * const ts1 = lookup_thread_state (); dds_return_t ret = DDS_RETCODE_OK; - dds_retcode_t rc; bool autodispose = true; dds_write_action action = DDS_WR_ACTION_UNREGISTER; dds_writer *wr; if (data == NULL){ - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; goto err; } if(timestamp < 0){ - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; goto err; } - rc = dds_writer_lock(writer, &wr); - if (rc != DDS_RETCODE_OK) { - ret = DDS_ERRNO(rc); + ret = dds_writer_lock(writer, &wr); + if (ret != DDS_RETCODE_OK) { goto err; } @@ -226,15 +219,13 @@ dds_unregister_instance_ih_ts( { struct thread_state1 * const ts1 = lookup_thread_state (); dds_return_t ret = DDS_RETCODE_OK; - dds_retcode_t rc; bool autodispose = true; dds_write_action action = DDS_WR_ACTION_UNREGISTER; dds_writer *wr; struct ddsi_tkmap_instance *tk; - rc = dds_writer_lock(writer, &wr); - if (rc != DDS_RETCODE_OK) { - ret = DDS_ERRNO(rc); + ret = dds_writer_lock(writer, &wr); + if (ret != DDS_RETCODE_OK) { goto err; } @@ -255,7 +246,7 @@ dds_unregister_instance_ih_ts( ret = dds_write_impl (wr, sample, timestamp, action); ddsi_sertopic_free_sample (tp, sample, DDS_FREE_ALL); } else { - ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); + ret = DDS_RETCODE_PRECONDITION_NOT_MET; } thread_state_asleep (ts1); dds_writer_unlock(wr); @@ -271,11 +262,10 @@ dds_writedispose_ts( { struct thread_state1 * const ts1 = lookup_thread_state (); dds_return_t ret; - dds_retcode_t rc; dds_writer *wr; - rc = dds_writer_lock(writer, &wr); - if (rc == DDS_RETCODE_OK) { + ret = dds_writer_lock(writer, &wr); + if (ret == DDS_RETCODE_OK) { thread_state_awake (ts1); ret = dds_write_impl (wr, data, timestamp, DDS_WR_ACTION_WRITE_DISPOSE); if (ret == DDS_RETCODE_OK) { @@ -283,8 +273,6 @@ dds_writedispose_ts( } thread_state_asleep (ts1); dds_writer_unlock(wr); - } else { - ret = DDS_ERRNO(rc); } return ret; @@ -315,17 +303,14 @@ dds_dispose_ts( { struct thread_state1 * const ts1 = lookup_thread_state (); dds_return_t ret; - dds_retcode_t rc; dds_writer *wr; - rc = dds_writer_lock(writer, &wr); - if (rc == DDS_RETCODE_OK) { + ret = dds_writer_lock(writer, &wr); + if (ret == DDS_RETCODE_OK) { thread_state_awake (ts1); ret = dds_dispose_impl(wr, data, DDS_HANDLE_NIL, timestamp); thread_state_asleep (ts1); dds_writer_unlock(wr); - } else { - ret = DDS_ERRNO(rc); } return ret; @@ -339,11 +324,10 @@ dds_dispose_ih_ts( { struct thread_state1 * const ts1 = lookup_thread_state (); dds_return_t ret; - dds_retcode_t rc; dds_writer *wr; - rc = dds_writer_lock(writer, &wr); - if (rc == DDS_RETCODE_OK) { + ret = dds_writer_lock(writer, &wr); + if (ret == DDS_RETCODE_OK) { struct ddsi_tkmap_instance *tk; thread_state_awake (ts1); 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); ddsi_sertopic_free_sample (tp, sample, DDS_FREE_ALL); } else { - ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); + ret = DDS_RETCODE_PRECONDITION_NOT_MET; } thread_state_asleep (ts1); dds_writer_unlock(wr); - } else { - ret = DDS_ERRNO(rc); } return ret; @@ -412,13 +394,13 @@ dds_instance_get_key( struct ddsi_tkmap_instance * tk; if(data == NULL){ - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; goto err; } topic = dds_instance_info_by_hdl (entity); if(topic == NULL){ - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; goto err; } thread_state_awake (ts1); @@ -428,7 +410,7 @@ dds_instance_get_key( ddsi_tkmap_instance_unref (tk); ret = DDS_RETCODE_OK; } else { - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; } thread_state_asleep (ts1); err: diff --git a/src/core/ddsc/src/dds_participant.c b/src/core/ddsc/src/dds_participant.c index a0c3c03..30f1330 100644 --- a/src/core/ddsc/src/dds_participant.c +++ b/src/core/ddsc/src/dds_participant.c @@ -19,7 +19,6 @@ #include "dds__qos.h" #include "dds__domain.h" #include "dds__participant.h" -#include "dds__err.h" #include "dds__builtin.h" DECL_ENTITY_LOCK_UNLOCK(extern inline, dds_participant) @@ -37,7 +36,7 @@ dds_participant_status_validate( dds_return_t ret = DDS_RETCODE_OK; if (mask & ~(DDS_PARTICIPANT_STATUS_MASK)) { - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; } return ret; @@ -106,11 +105,11 @@ dds_participant_qos_validate( /* Check consistency. */ if ((qos->present & QP_USER_DATA) && !validate_octetseq(&qos->user_data)) { 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)) { 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; } @@ -128,7 +127,7 @@ dds_participant_qos_set( if (enabled) { /* TODO: CHAM-95: DDSI does not support changing QoS policies. */ DDS_ERROR("Changing the participant QoS is not supported\n"); - ret = DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); + ret = DDS_RETCODE_UNSUPPORTED; } } return ret; @@ -188,7 +187,7 @@ dds_create_participant( nn_plist_fini (&plist); if (q_rc != 0) { DDS_ERROR("Internal error"); - e = DDS_ERRNO(DDS_RETCODE_ERROR); + e = DDS_RETCODE_ERROR; goto fail_new_participant; } @@ -241,12 +240,12 @@ dds_lookup_participant( if ((participants != NULL) && ((size <= 0) || (size >= INT32_MAX))) { DDS_ERROR("Array is given, but with invalid size\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; goto err; } if ((participants == NULL) && (size != 0)) { DDS_ERROR("Size is given, but no array\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; goto err; } diff --git a/src/core/ddsc/src/dds_publisher.c b/src/core/ddsc/src/dds_publisher.c index 47365c7..39ffc85 100644 --- a/src/core/ddsc/src/dds_publisher.c +++ b/src/core/ddsc/src/dds_publisher.c @@ -15,7 +15,6 @@ #include "dds__listener.h" #include "dds__publisher.h" #include "dds__qos.h" -#include "dds__err.h" #include "dds/ddsi/q_entity.h" #include "dds/version.h" @@ -32,7 +31,7 @@ dds_publisher_instance_hdl( (void)i; /* TODO: Get/generate proper handle. */ DDS_ERROR("Getting publisher instance handle is not supported\n"); - return DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); + return DDS_RETCODE_UNSUPPORTED; } static dds_return_t @@ -46,24 +45,24 @@ dds_publisher_qos_validate( /* Check consistency. */ if((qos->present & QP_GROUP_DATA) && !validate_octetseq(&qos->group_data)){ 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)){ 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)){ 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)){ 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)){ /* TODO: Improve/check immutable check. */ DDS_ERROR("Presentation policy is immutable\n"); - ret = DDS_ERRNO(DDS_RETCODE_IMMUTABLE_POLICY); + ret = DDS_RETCODE_IMMUTABLE_POLICY; } return ret; } @@ -80,7 +79,7 @@ dds_publisher_qos_set( if (enabled) { /* TODO: CHAM-95: DDSI does not support changing QoS policies. */ 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; @@ -92,7 +91,7 @@ static dds_return_t dds_publisher_status_validate (uint32_t mask) if (mask & ~(DDS_PUBLISHER_STATUS_MASK)) { DDS_ERROR("Invalid status mask\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; } return ret; @@ -109,12 +108,11 @@ dds_create_publisher( dds_entity_t hdl; dds_qos_t * new_qos = NULL; dds_return_t ret; - dds_retcode_t rc; - rc = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &par); - if (rc != DDS_RETCODE_OK) { + ret = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &par); + if (ret != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking participant\n"); - hdl = DDS_ERRNO(rc); + hdl = ret; goto lock_err; } @@ -164,7 +162,7 @@ dds_wait_for_acks( dds_duration_t timeout) { 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 }; 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. */ (void)e; 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 @@ -186,6 +184,6 @@ dds_publisher_end_coherent( /* TODO: CHAM-124 Currently unsupported. */ (void)e; 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; } diff --git a/src/core/ddsc/src/dds_qos.c b/src/core/ddsc/src/dds_qos.c index b53d046..24584be 100644 --- a/src/core/ddsc/src/dds_qos.c +++ b/src/core/ddsc/src/dds_qos.c @@ -12,7 +12,6 @@ #include #include #include "dds__qos.h" -#include "dds__err.h" #include "dds/ddsi/q_config.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 */ if (qos->present & QP_DEADLINE) { 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) { 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) { 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) { 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) { 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) { 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) { DDS_ERROR("Resource limits QoS policy caused immutable error\n"); - ret = DDS_ERRNO(DDS_RETCODE_IMMUTABLE_POLICY); + ret = DDS_RETCODE_IMMUTABLE_POLICY; } return ret; @@ -263,11 +262,11 @@ dds_copy_qos ( { if(!src){ DDS_ERROR("Argument source(src) is NULL\n"); - return DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + return DDS_RETCODE_BAD_PARAMETER; } if(!dst){ 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); return DDS_RETCODE_OK; diff --git a/src/core/ddsc/src/dds_querycond.c b/src/core/ddsc/src/dds_querycond.c index 0a5e50d..ca972dd 100644 --- a/src/core/ddsc/src/dds_querycond.c +++ b/src/core/ddsc/src/dds_querycond.c @@ -18,7 +18,6 @@ #include "dds__topic.h" #include "dds__querycond.h" #include "dds__readcond.h" -#include "dds__err.h" #include "dds/ddsi/ddsi_serdata.h" #include "dds/ddsi/ddsi_sertopic.h" @@ -29,7 +28,7 @@ dds_create_querycondition( dds_querycondition_filter_fn filter) { dds_entity_t hdl; - dds_retcode_t rc; + dds_return_t rc; dds_reader *r; rc = dds_reader_lock(reader, &r); @@ -42,11 +41,11 @@ dds_create_querycondition( hdl = cond->m_entity.m_hdllink.hdl; } else { dds_delete (cond->m_entity.m_hdllink.hdl); - hdl = DDS_ERRNO(DDS_RETCODE_OUT_OF_RESOURCES); + hdl = DDS_RETCODE_OUT_OF_RESOURCES; } } else { DDS_ERROR("Error occurred on locking reader\n"); - hdl = DDS_ERRNO(rc); + hdl = rc; } return hdl; diff --git a/src/core/ddsc/src/dds_read.c b/src/core/ddsc/src/dds_read.c index 1702a25..5d1c4e8 100644 --- a/src/core/ddsc/src/dds_read.c +++ b/src/core/ddsc/src/dds_read.c @@ -15,16 +15,15 @@ #include "dds__reader.h" #include "dds/ddsi/ddsi_tkmap.h" #include "dds__rhc.h" -#include "dds__err.h" #include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_ephash.h" #include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_globals.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; 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 (); dds_return_t ret = DDS_RETCODE_OK; - dds_retcode_t rc; struct dds_reader * rd; struct dds_readcond * cond; unsigned nodata_cleanups = 0; @@ -101,40 +99,39 @@ dds_read_impl( if (buf == NULL) { DDS_ERROR("The provided buffer is NULL\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; goto fail; } if (si == NULL) { 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; } if (maxs == 0) { 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; } if (bufsz == 0) { DDS_ERROR("The size of buffer is zero\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; goto fail; } if (bufsz < maxs) { 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; } thread_state_awake (ts1); - rc = dds_read_lock(reader_or_condition, &rd, &cond, only_reader); - if (rc != DDS_RETCODE_OK) { - ret = DDS_ERRNO(rc); + ret = dds_read_lock(reader_or_condition, &rd, &cond, only_reader); + if (ret != DDS_RETCODE_OK) { goto fail_awake; } if (hand != DDS_HANDLE_NIL) { if (ddsi_tkmap_find_by_id(gv.m_tkmap, hand) == NULL) { 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); goto fail_awake; } @@ -217,7 +214,6 @@ dds_readcdr_impl( { struct thread_state1 * const ts1 = lookup_thread_state (); dds_return_t ret = DDS_RETCODE_OK; - dds_retcode_t rc; struct dds_reader * rd; struct dds_readcond * cond; @@ -229,8 +225,8 @@ dds_readcdr_impl( (void)take; thread_state_awake (ts1); - rc = dds_read_lock(reader_or_condition, &rd, &cond, false); - if (rc == DDS_RETCODE_OK) { + ret = dds_read_lock(reader_or_condition, &rd, &cond, false); + if (ret == DDS_RETCODE_OK) { /* 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 */ ddsrt_mutex_lock (&rd->m_entity.m_observers_lock); @@ -251,8 +247,6 @@ dds_readcdr_impl( ); dds_read_unlock(rd, cond); - } else { - ret = DDS_ERRNO(rc); } thread_state_asleep (ts1); @@ -349,7 +343,7 @@ dds_read_instance( if (handle == DDS_HANDLE_NIL) { DDS_ERROR("DDS_HANDLE_NIL was provided\n"); - ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); + ret = DDS_RETCODE_PRECONDITION_NOT_MET; goto fail; } @@ -377,7 +371,7 @@ dds_read_instance_wl( if (handle == DDS_HANDLE_NIL) { DDS_ERROR("DDS_HANDLE_NIL was provided\n"); - ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); + ret = DDS_RETCODE_PRECONDITION_NOT_MET; goto fail; } @@ -407,7 +401,7 @@ dds_read_instance_mask( if (handle == DDS_HANDLE_NIL) { DDS_ERROR("DDS_HANDLE_NIL was provided\n"); - ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); + ret = DDS_RETCODE_PRECONDITION_NOT_MET; goto fail; } @@ -436,7 +430,7 @@ dds_read_instance_mask_wl( if (handle == DDS_HANDLE_NIL) { DDS_ERROR("DDS_HANDLE_NIL was provided\n"); - ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); + ret = DDS_RETCODE_PRECONDITION_NOT_MET; goto fail; } if (maxs == DDS_READ_WITHOUT_LOCK) { @@ -579,7 +573,7 @@ dds_take_instance( if (handle == DDS_HANDLE_NIL) { DDS_ERROR("DDS_HANDLE_NIL was provided\n"); - ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); + ret = DDS_RETCODE_PRECONDITION_NOT_MET; goto fail; } @@ -607,7 +601,7 @@ dds_take_instance_wl( if (handle == DDS_HANDLE_NIL) { DDS_ERROR("DDS_HANDLE_NIL was provided\n"); - ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); + ret = DDS_RETCODE_PRECONDITION_NOT_MET; goto fail; } if (maxs == DDS_READ_WITHOUT_LOCK) { @@ -636,7 +630,7 @@ dds_take_instance_mask( if (handle == DDS_HANDLE_NIL) { DDS_ERROR("DDS_HANDLE_NIL was provided\n"); - ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); + ret = DDS_RETCODE_PRECONDITION_NOT_MET; goto fail; } if (maxs == DDS_READ_WITHOUT_LOCK) { @@ -664,7 +658,7 @@ dds_take_instance_mask_wl( if (handle == DDS_HANDLE_NIL) { DDS_ERROR("DDS_HANDLE_NIL was provided\n"); - ret = DDS_ERRNO(DDS_RETCODE_PRECONDITION_NOT_MET); + ret = DDS_RETCODE_PRECONDITION_NOT_MET; goto fail; } if (maxs == DDS_READ_WITHOUT_LOCK) { @@ -704,7 +698,6 @@ dds_return_loan( void **buf, int32_t bufsz) { - dds_retcode_t rc; const struct ddsi_sertopic *st; dds_reader *rd; dds_readcond *cond; @@ -712,17 +705,16 @@ dds_return_loan( if (!buf) { DDS_ERROR("Argument buf is NULL\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; goto fail; } if (*buf == NULL && bufsz > 0) { - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; goto fail; } - rc = dds_read_lock(reader_or_condition, &rd, &cond, false); - if (rc != DDS_RETCODE_OK) { - ret = DDS_ERRNO(rc); + ret = dds_read_lock(reader_or_condition, &rd, &cond, false); + if (ret != DDS_RETCODE_OK) { goto fail; } st = rd->m_topic->m_stopic; diff --git a/src/core/ddsc/src/dds_readcond.c b/src/core/ddsc/src/dds_readcond.c index ee37521..ae889be 100644 --- a/src/core/ddsc/src/dds_readcond.c +++ b/src/core/ddsc/src/dds_readcond.c @@ -14,7 +14,6 @@ #include "dds__readcond.h" #include "dds__rhc.h" #include "dds__entity.h" -#include "dds__err.h" #include "dds/ddsi/q_ephash.h" #include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_thread.h" @@ -63,7 +62,7 @@ dds_create_readcondition( { dds_entity_t hdl; dds_reader * rd; - dds_retcode_t rc; + dds_return_t rc; rc = dds_reader_lock(reader, &rd); if (rc == DDS_RETCODE_OK) { @@ -74,7 +73,7 @@ dds_create_readcondition( dds_reader_unlock(rd); } else { DDS_ERROR("Error occurred on locking reader\n"); - hdl = DDS_ERRNO(rc); + hdl = rc; } return hdl; @@ -83,9 +82,9 @@ dds_create_readcondition( dds_entity_t dds_get_datareader (dds_entity_t condition) { struct dds_entity *e; - dds_retcode_t rc; + dds_return_t rc; if ((rc = dds_entity_claim (condition, &e)) != DDS_RETCODE_OK) - return DDS_ERRNO (rc); + return rc; else { 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; break; default: - rdh = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); + rdh = DDS_RETCODE_ILLEGAL_OPERATION; break; } 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_entity *entity; - dds_retcode_t rc; + dds_return_t rc; 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) - return DDS_ERRNO (rc); + return rc; else if (dds_entity_kind (entity) != DDS_KIND_COND_READ && dds_entity_kind (entity) != DDS_KIND_COND_QUERY) { dds_entity_unlock (entity); - return DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); + return DDS_RETCODE_ILLEGAL_OPERATION; } else { diff --git a/src/core/ddsc/src/dds_reader.c b/src/core/ddsc/src/dds_reader.c index be86ed3..49a6c0c 100644 --- a/src/core/ddsc/src/dds_reader.c +++ b/src/core/ddsc/src/dds_reader.c @@ -19,7 +19,6 @@ #include "dds__qos.h" #include "dds__init.h" #include "dds__rhc.h" -#include "dds__err.h" #include "dds__topic.h" #include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_thread.h" @@ -53,7 +52,6 @@ static dds_return_t dds_reader_close( dds_entity *e) { - dds_retcode_t rc; dds_return_t ret = DDS_RETCODE_OK; assert(e); @@ -61,8 +59,7 @@ dds_reader_close( thread_state_awake (lookup_thread_state ()); if (delete_reader(&e->m_guid) != 0) { DDS_ERROR("Internal error"); - rc = DDS_RETCODE_ERROR; - ret = DDS_ERRNO(rc); + ret = DDS_RETCODE_ERROR; } thread_state_asleep (lookup_thread_state ()); return ret; @@ -78,7 +75,7 @@ dds_reader_delete( ret = dds_delete(rd->m_topic->m_entity.m_hdllink.hdl); if(ret == DDS_RETCODE_OK){ 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; } } @@ -98,27 +95,27 @@ dds_reader_qos_validate( /* Check consistency. */ if(!dds_qos_validate_common(qos)) { 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))) { 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)) { 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)) { 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)) { 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))) { 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) { ret = dds_qos_validate_mutable_common(qos); @@ -139,7 +136,7 @@ dds_reader_qos_set( if (enabled) { /* TODO: CHAM-95: DDSI does not support changing QoS policies. */ DDS_ERROR(DDS_PROJECT_NAME" does not support changing QoS policies\n"); - ret = DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); + ret = DDS_RETCODE_UNSUPPORTED; } } return ret; @@ -150,7 +147,7 @@ dds_reader_status_validate( uint32_t mask) { return (mask & ~(DDS_READER_STATUS_MASK)) ? - DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER) : + DDS_RETCODE_BAD_PARAMETER : DDS_RETCODE_OK; } @@ -360,7 +357,6 @@ dds_create_reader( const dds_listener_t *listener) { dds_qos_t * rqos; - dds_retcode_t rc; dds_subscriber * sub = NULL; dds_entity_t subscriber; dds_reader * rd; @@ -383,8 +379,8 @@ dds_create_reader( default: { dds_entity *p_or_s; - if ((rc = dds_entity_claim (participant_or_subscriber, &p_or_s)) != DDS_RETCODE_OK) { - return DDS_ERRNO (rc); + if ((ret = dds_entity_claim (participant_or_subscriber, &p_or_s)) != DDS_RETCODE_OK) { + return ret; } if (dds_entity_kind (p_or_s) == DDS_KIND_PARTICIPANT) { 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) { - reader = DDS_ERRNO (rc); + if ((ret = dds_subscriber_lock (subscriber, &sub)) != DDS_RETCODE_OK) { + reader = ret; goto err_sub_lock; } @@ -408,10 +404,10 @@ dds_create_reader( sub->m_entity.m_flags |= DDS_ENTITY_IMPLICIT; } - rc = dds_topic_lock(t, &tp); - if (rc != DDS_RETCODE_OK) { + ret = dds_topic_lock(t, &tp); + if (ret != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking topic\n"); - reader = DDS_ERRNO(rc); + reader = ret; goto err_tp_lock; } assert (tp->m_stopic); @@ -448,7 +444,7 @@ dds_create_reader( if (internal_topic && !dds__validate_builtin_reader_qos(topic, qos)) { dds_delete_qos(rqos); 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; } @@ -573,12 +569,12 @@ uint32_t dds_reader_lock_samples (dds_entity_t reader) 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; - int ret; + dds_return_t ret; if ((ret = dds_reader_lock (reader, &rd)) != DDS_RETCODE_OK) - return DDS_ERRNO (ret); + return ret; switch (rd->m_entity.m_qos->durability.kind) { 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 *e; - dds_retcode_t ret; + dds_return_t ret; if ((ret = dds_entity_claim (entity, &e)) != DDS_RETCODE_OK) - return (dds_entity_t) DDS_ERRNO (ret); + return ret; else { 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; break; default: - subh = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); + subh = DDS_RETCODE_ILLEGAL_OPERATION; break; } dds_entity_release (e); @@ -630,14 +626,12 @@ dds_get_subscription_matched_status ( dds_entity_t reader, dds_subscription_matched_status_t * status) { - dds_retcode_t rc; dds_reader *rd; - dds_return_t ret = DDS_RETCODE_OK; + dds_return_t ret; - rc = dds_reader_lock(reader, &rd); - if (rc != DDS_RETCODE_OK) { + ret = dds_reader_lock(reader, &rd); + if (ret != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking reader\n"); - ret = DDS_ERRNO(rc); goto fail; } /* 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_liveliness_changed_status_t * status) { - dds_retcode_t rc; dds_reader *rd; - dds_return_t ret = DDS_RETCODE_OK; + dds_return_t ret; - rc = dds_reader_lock(reader, &rd); - if (rc != DDS_RETCODE_OK) { + ret = dds_reader_lock(reader, &rd); + if (ret != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking reader\n"); - ret = DDS_ERRNO(rc); goto fail; } /* 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_sample_rejected_status_t * status) { - dds_retcode_t rc; dds_reader *rd; - dds_return_t ret = DDS_RETCODE_OK; + dds_return_t ret; - rc = dds_reader_lock(reader, &rd); - if (rc != DDS_RETCODE_OK) { + ret = dds_reader_lock(reader, &rd); + if (ret != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking reader\n"); - ret = DDS_ERRNO(rc); goto fail; } /* 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_sample_lost_status_t * status) { - dds_retcode_t rc; dds_reader *rd; - dds_return_t ret = DDS_RETCODE_OK; + dds_return_t ret; - rc = dds_reader_lock(reader, &rd); - if (rc != DDS_RETCODE_OK) { + ret = dds_reader_lock(reader, &rd); + if (ret != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking reader\n"); - ret = DDS_ERRNO(rc); goto fail; } /* 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_requested_deadline_missed_status_t * status) { - dds_retcode_t rc; dds_reader *rd; - dds_return_t ret = DDS_RETCODE_OK; + dds_return_t ret; - rc = dds_reader_lock(reader, &rd); - if (rc != DDS_RETCODE_OK) { + ret = dds_reader_lock(reader, &rd); + if (ret != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking reader\n"); - ret = DDS_ERRNO(rc); goto fail; } /* 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_requested_incompatible_qos_status_t * status) { - dds_retcode_t rc; dds_reader *rd; - dds_return_t ret = DDS_RETCODE_OK; + dds_return_t ret; - rc = dds_reader_lock(reader, &rd); - if (rc != DDS_RETCODE_OK) { + ret = dds_reader_lock(reader, &rd); + if (ret != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking reader\n"); - ret = DDS_ERRNO(rc); goto fail; } /* status = NULL, application do not need the status, but reset the counter & triggered bit */ diff --git a/src/core/ddsc/src/dds_rhc.c b/src/core/ddsc/src/dds_rhc.c index 79a134a..99f4508 100644 --- a/src/core/ddsc/src/dds_rhc.c +++ b/src/core/ddsc/src/dds_rhc.c @@ -30,7 +30,6 @@ #include "dds/ddsrt/hopscotch.h" #include "dds/ddsrt/avl.h" #include "dds/ddsi/q_xqos.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsi/q_unused.h" #include "dds/ddsi/q_config.h" #include "dds/ddsi/q_globals.h" diff --git a/src/core/ddsc/src/dds_subscriber.c b/src/core/ddsc/src/dds_subscriber.c index 1a51775..91efce6 100644 --- a/src/core/ddsc/src/dds_subscriber.c +++ b/src/core/ddsc/src/dds_subscriber.c @@ -12,7 +12,6 @@ #include #include "dds__listener.h" #include "dds__qos.h" -#include "dds__err.h" #include "dds__subscriber.h" #include "dds/ddsi/q_entity.h" #include "dds/version.h" @@ -31,7 +30,7 @@ dds_subscriber_instance_hdl( (void)i; /* TODO: Get/generate proper handle. */ DDS_ERROR("Generating subscriber instance handle is not supported"); - return DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); + return DDS_RETCODE_UNSUPPORTED; } static dds_return_t @@ -45,24 +44,24 @@ dds__subscriber_qos_validate( if((qos->present & QP_GROUP_DATA) && !validate_octetseq(&qos->group_data)) { 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)) { 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)) { 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)) { 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)) { /* TODO: Improve/check immutable check. */ DDS_ERROR("Presentation QoS policy is immutable\n"); - ret = DDS_ERRNO(DDS_RETCODE_IMMUTABLE_POLICY); + ret = DDS_RETCODE_IMMUTABLE_POLICY; } return ret; @@ -80,7 +79,7 @@ dds_subscriber_qos_set( if (enabled) { /* TODO: CHAM-95: DDSI does not support changing QoS policies. */ 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; @@ -94,7 +93,7 @@ dds_subscriber_status_validate( if (mask & ~(DDS_SUBSCRIBER_STATUS_MASK)) { DDS_ERROR("Invalid status mask\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; } return ret; @@ -146,12 +145,12 @@ dds_create_subscriber( { dds_entity * par; dds_entity_t hdl; - dds_retcode_t errnr; + dds_return_t errnr; errnr = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &par); if (errnr != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking participant\n"); - hdl = DDS_ERRNO(errnr); + hdl = errnr; return hdl; } @@ -167,14 +166,12 @@ dds_notify_readers( { dds_entity *iter; dds_entity *sub; - dds_retcode_t errnr; dds_return_t ret; - errnr = dds_entity_lock(subscriber, DDS_KIND_SUBSCRIBER, &sub); - if (errnr == DDS_RETCODE_OK) { - errnr = DDS_RETCODE_UNSUPPORTED; + ret = dds_entity_lock(subscriber, DDS_KIND_SUBSCRIBER, &sub); + if (ret == DDS_RETCODE_OK) { + ret = DDS_RETCODE_UNSUPPORTED; DDS_ERROR("Unsupported operation\n"); - ret = DDS_ERRNO(errnr); iter = sub->m_children; while (iter) { ddsrt_mutex_lock(&iter->m_mutex); @@ -185,7 +182,6 @@ dds_notify_readers( dds_entity_unlock(sub); } else { DDS_ERROR("Error occurred on locking subscriber\n"); - ret = DDS_ERRNO(errnr); } return ret; @@ -198,7 +194,7 @@ dds_subscriber_begin_coherent( /* TODO: CHAM-124 Currently unsupported. */ (void)e; 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 @@ -208,6 +204,6 @@ dds_subscriber_end_coherent( /* TODO: CHAM-124 Currently unsupported. */ (void)e; 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; } diff --git a/src/core/ddsc/src/dds_topic.c b/src/core/ddsc/src/dds_topic.c index c0cb41d..384c250 100644 --- a/src/core/ddsc/src/dds_topic.c +++ b/src/core/ddsc/src/dds_topic.c @@ -20,7 +20,6 @@ #include "dds__stream.h" #include "dds__init.h" #include "dds__domain.h" -#include "dds__err.h" #include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_thread.h" #include "dds/ddsi/ddsi_sertopic.h" @@ -76,7 +75,7 @@ dds_topic_status_validate( if (mask & ~(DDS_TOPIC_STATUS_MASK)) { DDS_ERROR("Argument mask is invalid\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; } return ret; @@ -183,7 +182,7 @@ dds_find_topic( dds_entity_t tp; dds_entity *p = NULL; struct ddsi_sertopic *st; - dds_retcode_t rc; + dds_return_t rc; if (name) { 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; } else { 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); dds_entity_unlock(p); } else { - tp = DDS_ERRNO(rc); + tp = rc; } } else { DDS_ERROR("Argument name is not valid\n"); - tp = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + tp = DDS_RETCODE_BAD_PARAMETER; } return tp; @@ -234,23 +233,23 @@ dds_topic_qos_validate( /* Check consistency. */ if (!dds_qos_validate_common(qos)) { 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)) { 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)) { 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)) { 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)) { 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){ ret = dds_qos_validate_mutable_common(qos); @@ -271,7 +270,7 @@ dds_topic_qos_set( if (enabled) { /* TODO: CHAM-95: DDSI does not support changing QoS policies. */ DDS_ERROR("Changing the topic QoS is not supported\n"); - ret = DDS_ERRNO(DDS_RETCODE_UNSUPPORTED); + ret = DDS_RETCODE_UNSUPPORTED; } } return ret; @@ -310,7 +309,7 @@ dds_create_topic_arbitrary ( const nn_plist_t *sedp_plist) { struct ddsi_sertopic *stgeneric; - dds_retcode_t rc; + dds_return_t rc; dds_entity *par; dds_topic *top; dds_qos_t *new_qos = NULL; @@ -319,13 +318,13 @@ dds_create_topic_arbitrary ( if (sertopic == NULL){ DDS_ERROR("Topic description is NULL\n"); - hdl = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + hdl = DDS_RETCODE_BAD_PARAMETER; goto bad_param_err; } rc = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &par); if (rc != DDS_RETCODE_OK) { - hdl = DDS_ERRNO(rc); + hdl = rc; goto lock_err; } @@ -345,11 +344,11 @@ dds_create_topic_arbitrary ( if (!sertopic_equivalent (stgeneric, sertopic)) { /* FIXME: should copy the type, perhaps? but then the pointers will no longer be the same */ 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)) { /* FIXME: should copy the type, perhaps? but then the pointers will no longer be the same */ DDS_ERROR("Create topic with mismatching qos\n"); - hdl = DDS_ERRNO(DDS_RETCODE_INCONSISTENT_POLICY); + hdl = DDS_RETCODE_INCONSISTENT_POLICY; } else { /* FIXME: calling addref is wrong because the Cyclone library has no knowledge of the reference and hence simply deleting the participant @@ -417,19 +416,19 @@ dds_create_topic( if (desc == NULL){ DDS_ERROR("Topic description is NULL"); - hdl = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + hdl = DDS_RETCODE_BAD_PARAMETER; goto bad_param_err; } if (name == NULL) { DDS_ERROR("Topic name is NULL"); - hdl = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + hdl = DDS_RETCODE_BAD_PARAMETER; goto bad_param_err; } if (!is_valid_name(name)) { 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; } @@ -586,27 +585,24 @@ dds_get_name( { dds_topic *t; dds_return_t ret; - dds_retcode_t rc; if(size <= 0){ DDS_ERROR("Argument size is smaller than 0\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; goto fail; } if(name == NULL){ DDS_ERROR("Argument name is NULL\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; goto fail; } name[0] = '\0'; - rc = dds_topic_lock(topic, &t); - if (rc == DDS_RETCODE_OK) { + ret = dds_topic_lock(topic, &t); + if (ret == DDS_RETCODE_OK) { (void)snprintf(name, size, "%s", t->m_stopic->name); dds_topic_unlock(t); - ret = DDS_RETCODE_OK; } else { DDS_ERROR("Error occurred on locking topic\n"); - ret = DDS_ERRNO(rc); goto fail; } fail: @@ -620,29 +616,26 @@ dds_get_type_name( size_t size) { dds_topic *t; - dds_retcode_t rc; dds_return_t ret; if(size <= 0){ DDS_ERROR("Argument size is smaller than 0\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; goto fail; } if(name == NULL){ DDS_ERROR("Argument name is NULL\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; goto fail; } name[0] = '\0'; - rc = dds_topic_lock(topic, &t); - if (rc != DDS_RETCODE_OK) { + ret = dds_topic_lock(topic, &t); + if (ret != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking topic\n"); - ret = DDS_ERRNO(rc); goto fail; } (void)snprintf(name, size, "%s", t->m_stopic->type_name); dds_topic_unlock(t); - ret = DDS_RETCODE_OK; fail: return ret; } @@ -652,14 +645,12 @@ dds_get_inconsistent_topic_status( dds_entity_t topic, dds_inconsistent_topic_status_t *status) { - dds_retcode_t rc; dds_topic *t; - dds_return_t ret = DDS_RETCODE_OK; + dds_return_t ret; - rc = dds_topic_lock(topic, &t); - if (rc != DDS_RETCODE_OK) { + ret = dds_topic_lock(topic, &t); + if (ret != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking topic\n"); - ret = DDS_ERRNO(rc); goto fail; } /* status = NULL, application do not need the status, but reset the counter & triggered bit */ diff --git a/src/core/ddsc/src/dds_waitset.c b/src/core/ddsc/src/dds_waitset.c index 4d5bd4b..357d8fb 100644 --- a/src/core/ddsc/src/dds_waitset.c +++ b/src/core/ddsc/src/dds_waitset.c @@ -17,7 +17,6 @@ #include "dds__querycond.h" #include "dds__readcond.h" #include "dds__rhc.h" -#include "dds__err.h" DEFINE_ENTITY_LOCK_UNLOCK(static, dds_waitset, DDS_KIND_WAITSET) @@ -50,24 +49,23 @@ dds_waitset_wait_impl( { dds_waitset *ws; dds_return_t ret; - dds_retcode_t rc; dds_attachment *idx; dds_attachment *next; dds_attachment *prev; if ((xs == NULL) && (nxs != 0)){ 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)){ 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 * unlocked. Even when the related mutex is unlocked by a conditioned wait. */ - rc = dds_waitset_lock(waitset, &ws); - if (rc == DDS_RETCODE_OK) { + ret = dds_waitset_lock(waitset, &ws); + if (ret == DDS_RETCODE_OK) { /* Check if any of any previous triggered entities has changed there status * and thus it trigger value could be false now. */ 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. */ - rc = DDS_RETCODE_OK; - while ((ws->observed != NULL) && (ws->triggered == NULL) && (rc == DDS_RETCODE_OK)) { + while ((ws->observed != NULL) && (ws->triggered == NULL) && (ret == DDS_RETCODE_OK)) { if (abstimeout == DDS_NEVER) { ddsrt_cond_wait(&ws->m_entity.m_cond, &ws->m_entity.m_mutex); } else if (abstimeout <= tnow) { - rc = DDS_RETCODE_TIMEOUT; + ret = DDS_RETCODE_TIMEOUT; } else { dds_duration_t dt = abstimeout - tnow; (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 * - set attach array when needed * - swap them back to observed */ - if (rc == DDS_RETCODE_OK) { + if (ret == DDS_RETCODE_OK) { ret = 0; idx = ws->triggered; while (idx != NULL) { @@ -127,17 +124,15 @@ dds_waitset_wait_impl( dds_waitset_swap(&(ws->observed), &(ws->triggered), NULL, idx); idx = next; } - } else if (rc == DDS_RETCODE_TIMEOUT) { + } else if (ret == DDS_RETCODE_TIMEOUT) { ret = 0; } else { DDS_ERROR("Internal error"); - ret = DDS_ERRNO(rc); } dds_waitset_unlock(ws); } else { DDS_ERROR("Error occurred on locking waitset\n"); - ret = DDS_ERRNO(rc); } return ret; @@ -206,7 +201,7 @@ dds_create_waitset( { dds_entity_t hdl; dds_entity *par; - dds_retcode_t rc; + dds_return_t rc; rc = dds_entity_lock(participant, DDS_KIND_PARTICIPANT, &par); if (rc == DDS_RETCODE_OK) { @@ -217,7 +212,7 @@ dds_create_waitset( waitset->triggered = NULL; dds_entity_unlock(par); } else { - hdl = DDS_ERRNO(rc); + hdl = rc; } return hdl; @@ -230,14 +225,14 @@ dds_waitset_get_entities( dds_entity_t *entities, size_t size) { - dds_return_t ret = 0; - dds_retcode_t rc; + dds_return_t ret; dds_waitset *ws; - rc = dds_waitset_lock(waitset, &ws); - if (rc == DDS_RETCODE_OK) { + ret = dds_waitset_lock(waitset, &ws); + if (ret == DDS_RETCODE_OK) { dds_attachment* iter; + ret = 0; iter = ws->observed; while (iter) { if (((size_t)ret < size) && (entities != NULL)) { @@ -258,7 +253,6 @@ dds_waitset_get_entities( dds_waitset_unlock(ws); } else { DDS_ERROR("Error occurred on locking waitset\n"); - ret = DDS_ERRNO(rc); } return ret; @@ -330,14 +324,13 @@ dds_waitset_attach( { dds_entity *e = NULL; dds_waitset *ws; - dds_retcode_t rc; dds_return_t ret; - rc = dds_waitset_lock(waitset, &ws); - if (rc == DDS_RETCODE_OK) { + ret = dds_waitset_lock(waitset, &ws); + if (ret == DDS_RETCODE_OK) { if (waitset != entity) { - rc = dds_entity_lock(entity, DDS_KIND_DONTCARE, &e); - if (rc != DDS_RETCODE_OK) { + ret = dds_entity_lock(entity, DDS_KIND_DONTCARE, &e); + if (ret != DDS_RETCODE_OK) { e = NULL; } } else { @@ -345,11 +338,11 @@ dds_waitset_attach( } /* This will fail if given entity is already attached (or deleted). */ - if (rc == DDS_RETCODE_OK) { - rc = dds_entity_observer_register_nl(e, waitset, dds_waitset_observer); + if (ret == DDS_RETCODE_OK) { + 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)); a->arg = x; a->entity = e; @@ -361,12 +354,11 @@ dds_waitset_attach( ws->observed = a; } 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"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; } else { DDS_ERROR("Entity is already attached\n"); - ret = DDS_ERRNO(rc); } if ((e != NULL) && (waitset != entity)) { dds_entity_unlock(e); @@ -374,7 +366,6 @@ dds_waitset_attach( dds_waitset_unlock(ws); } else { DDS_ERROR("Error occurred on locking waitset\n"); - ret = DDS_ERRNO(rc); } return ret; @@ -386,31 +377,27 @@ dds_waitset_detach( dds_entity_t entity) { dds_waitset *ws; - dds_retcode_t rc; dds_return_t ret; - rc = dds_waitset_lock(waitset, &ws); - if (rc == DDS_RETCODE_OK) { + ret = dds_waitset_lock(waitset, &ws); + if (ret == DDS_RETCODE_OK) { /* Possibly fails when entity was not attached. */ if (waitset == entity) { - rc = dds_entity_observer_unregister_nl(&ws->m_entity, waitset); + ret = dds_entity_observer_unregister_nl(&ws->m_entity, waitset); } 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); - ret = DDS_RETCODE_OK; - } else if (rc != DDS_RETCODE_PRECONDITION_NOT_MET) { + } else if (ret != DDS_RETCODE_PRECONDITION_NOT_MET) { DDS_ERROR("The given entity to detach is invalid\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; } else { DDS_ERROR("The given entity to detach was not attached previously\n"); - ret = DDS_ERRNO(rc); } dds_waitset_unlock(ws); } else { DDS_ERROR("Error occurred on locking waitset\n"); - ret = DDS_ERRNO(rc); } return ret; @@ -441,7 +428,7 @@ dds_waitset_wait( ret = dds_waitset_wait_impl(waitset, xs, nxs, abstimeout, tnow); } else{ DDS_ERROR("Negative timeout\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; } return ret; @@ -450,10 +437,10 @@ dds_waitset_wait( dds_return_t dds_waitset_set_trigger (dds_entity_t waitset, bool trigger) { dds_waitset *ws; - dds_retcode_t rc; + dds_return_t rc; if ((rc = dds_waitset_lock (waitset, &ws)) != DDS_RETCODE_OK) - return DDS_ERRNO (rc); + return rc; ddsrt_mutex_unlock (&ws->m_entity.m_mutex); diff --git a/src/core/ddsc/src/dds_write.c b/src/core/ddsc/src/dds_write.c index 032141a..2ef7f1f 100644 --- a/src/core/ddsc/src/dds_write.c +++ b/src/core/ddsc/src/dds_write.c @@ -14,12 +14,10 @@ #include "dds__writer.h" #include "dds__write.h" #include "dds/ddsi/ddsi_tkmap.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_xmsg.h" #include "dds/ddsi/ddsi_serdata.h" #include "dds__stream.h" -#include "dds__err.h" #include "dds/ddsi/q_transmit.h" #include "dds/ddsi/q_ephash.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 ret; - dds_retcode_t rc; dds_writer *wr; 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) - return DDS_ERRNO (rc); + if ((ret = dds_writer_lock (writer, &wr)) != DDS_RETCODE_OK) + return ret; ret = dds_write_impl (wr, data, dds_time (), 0); dds_writer_unlock (wr); 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 ret; - dds_retcode_t rc; dds_writer *wr; 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) - return DDS_ERRNO (rc); + if ((ret = dds_writer_lock (writer, &wr)) != DDS_RETCODE_OK) + return ret; ret = dds_writecdr_impl (wr, serdata, dds_time (), 0); dds_writer_unlock (wr); 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 ret; - dds_retcode_t rc; dds_writer *wr; 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) - return DDS_ERRNO (rc); + if ((ret = dds_writer_lock (writer, &wr)) != DDS_RETCODE_OK) + return ret; ret = dds_write_impl (wr, data, timestamp, 0); dds_writer_unlock (wr); return ret; @@ -86,7 +81,7 @@ static dds_return_t try_store (struct rhc *rhc, const struct proxy_writer_info * else { 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; @@ -159,7 +154,7 @@ dds_return_t dds_write_impl (dds_writer *wr, const void * data, dds_time_t tstam if (data == NULL) { DDS_ERROR("No data buffer provided\n"); - return DDS_ERRNO (DDS_RETCODE_BAD_PARAMETER); + return DDS_RETCODE_BAD_PARAMETER; } /* 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) nn_xpack_send (wr->m_xp, false); 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"); - ret = DDS_ERRNO (DDS_RETCODE_TIMEOUT); - } else if (w_rc == Q_ERR_INVALID_DATA) { + ret = DDS_RETCODE_TIMEOUT; + } else if (w_rc == DDS_RETCODE_BAD_PARAMETER) { DDS_ERROR ("Invalid data provided\n"); - ret = DDS_ERRNO (DDS_RETCODE_ERROR); + ret = DDS_RETCODE_ERROR; } else { DDS_ERROR ("Internal error\n"); - ret = DDS_ERRNO (DDS_RETCODE_ERROR); + ret = DDS_RETCODE_ERROR; } if (ret == DDS_RETCODE_OK) 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) nn_xpack_send (xp, false); 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"); - ret = DDS_ERRNO(DDS_RETCODE_TIMEOUT); - } else if (w_rc == Q_ERR_INVALID_DATA) { + ret = DDS_RETCODE_TIMEOUT; + } else if (w_rc == DDS_RETCODE_BAD_PARAMETER) { DDS_ERROR ("Invalid data provided\n"); - ret = DDS_ERRNO (DDS_RETCODE_ERROR); + ret = DDS_RETCODE_ERROR; } else { DDS_ERROR ("Internal error\n"); - ret = DDS_ERRNO (DDS_RETCODE_ERROR); + ret = DDS_RETCODE_ERROR; } 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 (); dds_writer *wr; - dds_retcode_t rc; + dds_return_t rc; thread_state_awake (ts1); if ((rc = dds_writer_lock (writer, &wr)) != DDS_RETCODE_OK) DDS_ERROR ("Error occurred on locking writer\n"); diff --git a/src/core/ddsc/src/dds_writer.c b/src/core/ddsc/src/dds_writer.c index f144e35..534ba86 100644 --- a/src/core/ddsc/src/dds_writer.c +++ b/src/core/ddsc/src/dds_writer.c @@ -21,7 +21,6 @@ #include "dds__writer.h" #include "dds__listener.h" #include "dds__qos.h" -#include "dds__err.h" #include "dds__init.h" #include "dds__publisher.h" #include "dds__topic.h" @@ -55,7 +54,7 @@ dds_writer_status_validate( if (mask & ~(DDS_WRITER_STATUS_MASK)) { DDS_ERROR("Invalid status mask\n"); - ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER); + ret = DDS_RETCODE_BAD_PARAMETER; } return ret; @@ -200,7 +199,7 @@ dds_writer_close( nn_xpack_send (wr->m_xp, false); if (delete_writer (&e->m_guid) != 0) { DDS_ERROR("Internal error"); - ret = DDS_ERRNO(DDS_RETCODE_ERROR); + ret = DDS_RETCODE_ERROR; } thread_state_asleep (lookup_thread_state ()); return ret; @@ -219,7 +218,7 @@ dds_writer_delete( ret = dds_delete(wr->m_topic->m_entity.m_hdllink.hdl); if(ret == DDS_RETCODE_OK){ 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; } } @@ -239,23 +238,23 @@ dds_writer_qos_validate( /* Check consistency. */ if(dds_qos_validate_common(qos) != true){ 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){ 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){ 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){ 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)){ 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) { ret = dds_qos_validate_mutable_common(qos); @@ -299,12 +298,12 @@ dds_writer_qos_set( thread_state_asleep (lookup_thread_state ()); } else { 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 { if (enabled) { 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_listener_t *listener) { - dds_retcode_t rc; + dds_return_t rc; dds_qos_t * wqos; dds_writer * wr; dds_entity_t writer; @@ -355,7 +354,7 @@ dds_create_writer( { dds_entity *p_or_p; 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) { 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) { - writer = DDS_ERRNO(rc); + writer = rc; goto err_pub_lock; } @@ -377,7 +376,7 @@ dds_create_writer( rc = dds_topic_lock(topic, &tp); if (rc != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking topic\n"); - writer = DDS_ERRNO(rc); + writer = rc; goto err_tp_lock; } assert(tp->m_stopic); @@ -455,14 +454,14 @@ dds_get_publisher( dds_entity_t writer) { dds_entity *e; - dds_retcode_t rc; + dds_return_t rc; if ((rc = dds_entity_claim (writer, &e)) != DDS_RETCODE_OK) - return DDS_ERRNO (rc); + return rc; else { dds_entity_t pubh; if (dds_entity_kind (e) != DDS_KIND_WRITER) - pubh = DDS_ERRNO (DDS_RETCODE_ILLEGAL_OPERATION); + pubh = DDS_RETCODE_ILLEGAL_OPERATION; else { assert (dds_entity_kind (e->m_parent) == DDS_KIND_PUBLISHER); @@ -478,14 +477,12 @@ dds_get_publication_matched_status ( dds_entity_t writer, dds_publication_matched_status_t * status) { - dds_retcode_t rc; dds_writer *wr; - dds_return_t ret = DDS_RETCODE_OK; + dds_return_t ret; - rc = dds_writer_lock(writer, &wr); - if (rc != DDS_RETCODE_OK) { + ret = dds_writer_lock(writer, &wr); + if (ret != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking writer\n"); - ret = DDS_ERRNO(rc); goto fail; } /* 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_liveliness_lost_status_t * status) { - dds_retcode_t rc; dds_writer *wr; - dds_return_t ret = DDS_RETCODE_OK; + dds_return_t ret; - rc = dds_writer_lock(writer, &wr); - if (rc != DDS_RETCODE_OK) { + ret = dds_writer_lock(writer, &wr); + if (ret != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking writer\n"); - ret = DDS_ERRNO(rc); goto fail; } /* 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_offered_deadline_missed_status_t *status) { - dds_retcode_t rc; dds_writer *wr; - dds_return_t ret = DDS_RETCODE_OK; + dds_return_t ret; - rc = dds_writer_lock(writer, &wr); - if (rc != DDS_RETCODE_OK) { + ret = dds_writer_lock(writer, &wr); + if (ret != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking writer\n"); - ret = DDS_ERRNO(rc); goto fail; } /* 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_offered_incompatible_qos_status_t * status) { - dds_retcode_t rc; dds_writer *wr; - dds_return_t ret = DDS_RETCODE_OK; + dds_return_t ret; - rc = dds_writer_lock(writer, &wr); - if (rc != DDS_RETCODE_OK) { + ret = dds_writer_lock(writer, &wr); + if (ret != DDS_RETCODE_OK) { DDS_ERROR("Error occurred on locking writer\n"); - ret = DDS_ERRNO(rc); goto fail; } /* status = NULL, application do not need the status, but reset the counter & triggered bit */ diff --git a/src/core/ddsc/tests/config.c b/src/core/ddsc/tests/config.c index b751a2c..76f92b0 100644 --- a/src/core/ddsc/tests/config.c +++ b/src/core/ddsc/tests/config.c @@ -49,7 +49,7 @@ static void config__check_env( } if ( !env_ok ) { - dds_retcode_t r; + dds_return_t r; r = ddsrt_setenv(env_variable, expected_value); CU_ASSERT_EQUAL_FATAL(r, DDS_RETCODE_OK); diff --git a/src/core/ddsc/tests/dispose.c b/src/core/ddsc/tests/dispose.c index 0e10c60..2df1714 100644 --- a/src/core/ddsc/tests/dispose.c +++ b/src/core/ddsc/tests/dispose.c @@ -153,7 +153,7 @@ CU_Test(ddsc_writedispose, deleted, .init=disposing_init, .fini=disposing_fini) DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose(g_writer, NULL); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -164,7 +164,7 @@ CU_Test(ddsc_writedispose, null, .init=disposing_init, .fini=disposing_fini) DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose(g_writer, NULL); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -174,13 +174,12 @@ CU_TheoryDataPoints(ddsc_writedispose, invalid_writers) = { }; CU_Theory((dds_entity_t writer), ddsc_writedispose, invalid_writers, .init=disposing_init, .fini=disposing_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose(writer, NULL); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -194,7 +193,7 @@ CU_Theory((dds_entity_t *writer), ddsc_writedispose, non_writers, .init=disposin DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose(*writer, NULL); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -290,7 +289,7 @@ CU_Test(ddsc_writedispose, timeout, .init=disposing_init, .fini=disposing_fini) ret = dds_writedispose(g_writer, &newInstance1); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_writedispose(g_writer, &newInstance2); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_TIMEOUT); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_TIMEOUT); } /*************************************************************************************************/ @@ -310,7 +309,7 @@ CU_Test(ddsc_writedispose_ts, deleted, .init=disposing_init, .fini=disposing_fin DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose_ts(g_writer, NULL, g_present); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -321,7 +320,7 @@ CU_Test(ddsc_writedispose_ts, null, .init=disposing_init, .fini=disposing_fini) DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose_ts(g_writer, NULL, g_present); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -335,7 +334,7 @@ CU_Test(ddsc_writedispose_ts, timeout, .init=disposing_init, .fini=disposing_fin ret = dds_writedispose_ts(g_writer, &newInstance1, g_present); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_writedispose_ts(g_writer, &newInstance2, g_present); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_TIMEOUT); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_TIMEOUT); } /*************************************************************************************************/ @@ -345,13 +344,12 @@ CU_TheoryDataPoints(ddsc_writedispose_ts, invalid_writers) = { }; CU_Theory((dds_entity_t writer), ddsc_writedispose_ts, invalid_writers, .init=disposing_init, .fini=disposing_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose_ts(writer, NULL, g_present); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -365,7 +363,7 @@ CU_Theory((dds_entity_t *writer), ddsc_writedispose_ts, non_writers, .init=dispo DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose_ts(*writer, NULL, g_present); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -510,7 +508,7 @@ CU_Test(ddsc_dispose, deleted, .init=disposing_init, .fini=disposing_fini) DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose(g_writer, NULL); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -521,7 +519,7 @@ CU_Test(ddsc_dispose, null, .init=disposing_init, .fini=disposing_fini) DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose(g_writer, NULL); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -535,7 +533,7 @@ CU_Test(ddsc_dispose, timeout, .init=disposing_init, .fini=disposing_fini) ret = dds_dispose(g_writer, &newInstance1); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_dispose(g_writer, &newInstance2); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_TIMEOUT); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_TIMEOUT); } /*************************************************************************************************/ @@ -545,13 +543,12 @@ CU_TheoryDataPoints(ddsc_dispose, invalid_writers) = { }; CU_Theory((dds_entity_t writer), ddsc_dispose, invalid_writers, .init=disposing_init, .fini=disposing_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose(writer, NULL); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -565,7 +562,7 @@ CU_Theory((dds_entity_t *writer), ddsc_dispose, non_writers, .init=disposing_ini DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose(*writer, NULL); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -665,7 +662,7 @@ CU_Test(ddsc_dispose_ts, deleted, .init=disposing_init, .fini=disposing_fini) DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose_ts(g_writer, NULL, g_present); DDSRT_WARNING_MSVC_ON(6387); /* Disable SAL warning on intentional misuse of the API */ - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -676,7 +673,7 @@ CU_Test(ddsc_dispose_ts, null, .init=disposing_init, .fini=disposing_fini) DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose_ts(g_writer, NULL, g_present); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -690,7 +687,7 @@ CU_Test(ddsc_dispose_ts, timeout, .init=disposing_init, .fini=disposing_fini) ret = dds_dispose_ts(g_writer, &newInstance1, g_present); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_dispose_ts(g_writer, &newInstance2, g_present); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_TIMEOUT); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_TIMEOUT); } /*************************************************************************************************/ @@ -700,13 +697,12 @@ CU_TheoryDataPoints(ddsc_dispose_ts, invalid_writers) = { }; CU_Theory((dds_entity_t writer), ddsc_dispose_ts, invalid_writers, .init=disposing_init, .fini=disposing_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose_ts(writer, NULL, g_present); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -720,7 +716,7 @@ CU_Theory((dds_entity_t *writer), ddsc_dispose_ts, non_writers, .init=disposing_ DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose_ts(*writer, NULL, g_present); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -861,7 +857,7 @@ CU_Test(ddsc_dispose_ih, deleted, .init=disposing_init, .fini=disposing_fini) dds_return_t ret; dds_delete(g_writer); ret = dds_dispose_ih(g_writer, DDS_HANDLE_NIL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -873,7 +869,7 @@ CU_Theory((dds_instance_handle_t handle), ddsc_dispose_ih, invalid_handles, .ini { dds_return_t ret; ret = dds_dispose_ih(g_writer, handle); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -883,11 +879,10 @@ CU_TheoryDataPoints(ddsc_dispose_ih, invalid_writers) = { }; CU_Theory((dds_entity_t writer), ddsc_dispose_ih, invalid_writers, .init=disposing_init, .fini=disposing_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_dispose_ih(writer, DDS_HANDLE_NIL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -899,7 +894,7 @@ CU_Theory((dds_entity_t *writer), ddsc_dispose_ih, non_writers, .init=disposing_ { dds_return_t ret; ret = dds_dispose_ih(*writer, DDS_HANDLE_NIL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -959,7 +954,7 @@ CU_Test(ddsc_dispose_ih_ts, deleted, .init=disposing_init, .fini=disposing_fini) dds_return_t ret; dds_delete(g_writer); ret = dds_dispose_ih_ts(g_writer, DDS_HANDLE_NIL, g_present); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -971,7 +966,7 @@ CU_Theory((dds_instance_handle_t handle), ddsc_dispose_ih_ts, invalid_handles, . { dds_return_t ret; ret = dds_dispose_ih_ts(g_writer, handle, g_present); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -981,11 +976,10 @@ CU_TheoryDataPoints(ddsc_dispose_ih_ts, invalid_writers) = { }; CU_Theory((dds_entity_t writer), ddsc_dispose_ih_ts, invalid_writers, .init=disposing_init, .fini=disposing_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_dispose_ih_ts(writer, DDS_HANDLE_NIL, g_present); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -997,7 +991,7 @@ CU_Theory((dds_entity_t *writer), ddsc_dispose_ih_ts, non_writers, .init=disposi { dds_return_t ret; ret = dds_dispose_ih_ts(*writer, DDS_HANDLE_NIL, g_present); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/entity_api.c b/src/core/ddsc/tests/entity_api.c index 8befa14..fa098b5 100644 --- a/src/core/ddsc/tests/entity_api.c +++ b/src/core/ddsc/tests/entity_api.c @@ -23,8 +23,6 @@ static dds_entity_t entity = -1; -#define cu_assert_status_eq(s1, s2) CU_ASSERT_FATAL(dds_err_nr(s1)== s2) - /* Fixture to create prerequisite entity */ void create_entity(void) { @@ -38,7 +36,7 @@ void delete_entity(void) { CU_ASSERT_FATAL(entity > 0); dds_return_t ret = dds_delete(entity); - cu_assert_status_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); entity = -1; } @@ -55,17 +53,17 @@ CU_Test(ddsc_entity, enable, .init = create_entity, .fini = delete_entity) /* Check enabling with bad parameters. */ status = dds_enable(0); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); /* Check actual enabling. */ /* TODO: CHAM-96: Check enabling. status = dds_enable(&entity); - cu_assert_status_eq(status, dds_err_nr(DDS_RETCODE_OK), "dds_enable (delayed enable)"); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK, "dds_enable (delayed enable)"); */ /* Check re-enabling (should be a noop). */ status = dds_enable(entity); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); } void entity_qos_get_set(dds_entity_t e, const char* info) @@ -77,10 +75,10 @@ void entity_qos_get_set(dds_entity_t e, const char* info) /* Get QoS. */ status = dds_get_qos (e, qos); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); status = dds_set_qos (e, qos); /* Doesn't change anything, so no need to forbid. But we return NOT_SUPPORTED anyway for now*/ - cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED); dds_delete_qos(qos); } @@ -95,19 +93,19 @@ CU_Test(ddsc_entity, qos, .init = create_entity, .fini = delete_entity) /* Check getting QoS with bad parameters. */ status = dds_get_qos (0, NULL); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_qos (entity, NULL); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_qos (0, qos); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); /* Check setting QoS with bad parameters. */ status = dds_set_qos (0, NULL); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_set_qos (entity, NULL); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_set_qos (0, qos); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); /* Check set/get with entity without initial qos. */ entity_qos_get_set(entity, "{without initial qos}"); @@ -145,15 +143,15 @@ CU_Test(ddsc_entity, listener, .init = create_entity, .fini = delete_entity) /* Check getting Listener with bad parameters. */ status = dds_get_listener (0, NULL); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_listener (entity, NULL); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_listener (0, l1); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); /* Get Listener, which should be unset. */ status = dds_get_listener (entity, l1); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); dds_lget_liveliness_changed (l1, (dds_on_liveliness_changed_fn*)&cb1); CU_ASSERT_EQUAL_FATAL(cb1, DDS_LUNSET); dds_lget_requested_deadline_missed (l1, (dds_on_requested_deadline_missed_fn*)&cb1); @@ -165,15 +163,15 @@ CU_Test(ddsc_entity, listener, .init = create_entity, .fini = delete_entity) /* Check setting Listener with bad parameters. */ status = dds_set_listener (0, NULL); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_set_listener (0, l2); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); /* Getting after setting should return set listener. */ status = dds_set_listener (entity, l2); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); status = dds_get_listener (entity, l1); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); dds_lget_liveliness_changed (l1, (dds_on_liveliness_changed_fn*)&cb1); dds_lget_liveliness_changed (l2, (dds_on_liveliness_changed_fn*)&cb2); CU_ASSERT_EQUAL_FATAL(cb1, cb2); @@ -189,9 +187,9 @@ CU_Test(ddsc_entity, listener, .init = create_entity, .fini = delete_entity) /* Reset listener. */ status = dds_set_listener (entity, NULL); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); status = dds_get_listener (entity, l2); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); dds_lget_liveliness_changed (l2, (dds_on_liveliness_changed_fn*)&cb2); CU_ASSERT_EQUAL_FATAL(cb2, DDS_LUNSET); dds_lget_requested_deadline_missed (l2, (dds_on_requested_deadline_missed_fn*)&cb2); @@ -215,46 +213,46 @@ CU_Test(ddsc_entity, status, .init = create_entity, .fini = delete_entity) /* Check getting Status with bad parameters. */ status1 = dds_get_status_mask (0, NULL); - cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER); status1 = dds_get_status_mask (entity, NULL); - cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER); status1 = dds_get_status_mask (0, &s1); - cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER); /* Get Status, which should be 0 for a participant. */ status1 = dds_get_status_mask (entity, &s1); - cu_assert_status_eq(status1, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(s1, 0); /* Check setting Status with bad parameters. */ status1 = dds_set_status_mask (0, 0); - cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER); /* I shouldn't be able to set statuses on a participant. */ status1 = dds_set_status_mask (entity, 0); - cu_assert_status_eq(status1, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_OK); status1 = dds_set_status_mask (entity, DDS_DATA_AVAILABLE_STATUS); - cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER); /* Check getting Status changes with bad parameters. */ status1 = dds_get_status_changes (0, NULL); - cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER); status1 = dds_get_status_changes (entity, NULL); - cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER); status1 = dds_get_status_changes (0, &s1); - cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER); status1 = dds_get_status_changes (entity, &s1); - cu_assert_status_eq(status1, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_OK); /* Status read and take shouldn't work either. */ status1 = dds_read_status (0, &s1, 0); - cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER); status1 = dds_read_status (entity, &s1, 0); - cu_assert_status_eq(status1, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_OK); status1 = dds_take_status (0, &s1, 0); - cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_BAD_PARAMETER); status1 = dds_take_status (entity, &s1, 0); - cu_assert_status_eq(status1, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status1, DDS_RETCODE_OK); } @@ -268,15 +266,15 @@ CU_Test(ddsc_entity, instance_handle, .init = create_entity, .fini = delete_enti /* Check getting Handle with bad parameters. */ status = dds_get_instance_handle (0, NULL); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_instance_handle (entity, NULL); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_instance_handle (0, &hdl); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); /* Get Instance Handle, which should not be 0 for a participant. */ status = dds_get_instance_handle (entity, &hdl); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); CU_ASSERT_NOT_EQUAL_FATAL(hdl, 0); } @@ -290,17 +288,17 @@ CU_Test(ddsc_entity, get_entities, .init = create_entity, .fini = delete_entity) /* Check getting Parent with bad parameters. */ par = dds_get_parent (0); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(par), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(par, DDS_RETCODE_BAD_PARAMETER); /* Get Parent, a participant doesn't have a parent. */ par = dds_get_parent (entity); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(par), DDS_ENTITY_NIL); + CU_ASSERT_EQUAL_FATAL(par, DDS_ENTITY_NIL); /* ---------- Get Participant ------------ */ /* Check getting Participant with bad parameters. */ par = dds_get_participant (0); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(par), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(par, DDS_RETCODE_BAD_PARAMETER); /* Get Participant, a participants' participant is itself. */ par = dds_get_participant (entity); @@ -310,15 +308,15 @@ CU_Test(ddsc_entity, get_entities, .init = create_entity, .fini = delete_entity) /* Check getting Children with bad parameters. */ status = dds_get_children (0, &child, 1); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_children (entity, NULL, 1); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_children (entity, &child, 0); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_children (0, NULL, 1); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_children (0, &child, 0); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); /* Get Children, of which there are currently none. */ status = dds_get_children (entity, NULL, 0); @@ -342,15 +340,15 @@ CU_Test(ddsc_entity, get_domainid, .init = create_entity, .fini = delete_entity) /* Check getting ID with bad parameters. */ status = dds_get_domainid (0, NULL); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_domainid (entity, NULL); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_domainid (0, &id); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); /* Get and check the domain id. */ status = dds_get_domainid (entity, &id); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); CU_ASSERT_FATAL(id != -1); } @@ -358,10 +356,10 @@ CU_Test(ddsc_entity, delete, .init = create_entity) { dds_return_t status; status = dds_delete(0); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); status = dds_delete(entity); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); entity = 0; } diff --git a/src/core/ddsc/tests/entity_hierarchy.c b/src/core/ddsc/tests/entity_hierarchy.c index ec7e2dc..a54f3cd 100644 --- a/src/core/ddsc/tests/entity_hierarchy.c +++ b/src/core/ddsc/tests/entity_hierarchy.c @@ -125,43 +125,43 @@ CU_Test(ddsc_entity_delete, recursive, .init=hierarchy_init, .fini=hierarchy_fin /* First be sure that 'dds_get_domainid' returns ok. */ ret = dds_get_domainid(g_participant, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_get_domainid(g_topic, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_get_domainid(g_publisher, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_get_domainid(g_subscriber, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_get_domainid(g_writer, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_get_domainid(g_reader, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_get_domainid(g_readcond, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_get_domainid(g_querycond, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Deleting the top dog (participant) should delete all children. */ ret = dds_delete(g_participant); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Check if all the entities are deleted now. */ ret = dds_get_domainid(g_participant, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); ret = dds_get_domainid(g_topic, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); ret = dds_get_domainid(g_publisher, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); ret = dds_get_domainid(g_subscriber, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); ret = dds_get_domainid(g_writer, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); ret = dds_get_domainid(g_reader, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); ret = dds_get_domainid(g_readcond, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); ret = dds_get_domainid(g_querycond, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -190,22 +190,22 @@ CU_Test(ddsc_entity_delete, recursive_with_deleted_topic) * reference to the topic and thus will delete it when it itself is * deleted. */ ret = dds_delete(g_topic); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Third, deleting the participant should delete all children of which * the writer with the last topic reference is one. */ ret = dds_delete(g_participant); /* Before the CHAM-424 fix, we would not get here because of a crash, * or it (incidentally) continued but returned an error. */ - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Check if the entities are actually deleted. */ ret = dds_get_domainid(g_participant, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER ); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER ); ret = dds_get_domainid(g_topic, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); ret = dds_get_domainid(g_writer, &id); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); dds_delete(g_keep); } @@ -240,7 +240,7 @@ CU_Theory((dds_entity_t *entity), ddsc_entity_get_participant, deleted_entities, dds_entity_t participant; dds_delete(*entity); participant = dds_get_participant(*entity); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(participant), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(participant, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -250,11 +250,10 @@ CU_TheoryDataPoints(ddsc_entity_get_participant, invalid_entities) = { }; CU_Theory((dds_entity_t entity), ddsc_entity_get_participant, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t participant; participant = dds_get_participant(entity); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(participant), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(participant, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -314,7 +313,7 @@ CU_Test(ddsc_entity_get_parent, participant, .init=hierarchy_init, .fini=hierarc { dds_entity_t parent; parent = dds_get_parent(g_participant); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(parent), DDS_ENTITY_NIL); + CU_ASSERT_EQUAL_FATAL(parent, DDS_ENTITY_NIL); } /*************************************************************************************************/ @@ -327,7 +326,7 @@ CU_Theory((dds_entity_t *entity), ddsc_entity_get_parent, deleted_entities, .ini dds_entity_t parent; dds_delete(*entity); parent = dds_get_parent(*entity); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(parent), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(parent, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -337,11 +336,10 @@ CU_TheoryDataPoints(ddsc_entity_get_parent, invalid_entities) = { }; CU_Theory((dds_entity_t entity), ddsc_entity_get_parent, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t parent; parent = dds_get_parent(entity); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(parent), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(parent, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -369,7 +367,7 @@ CU_Test(ddsc_entity_get_children, invalid_size, .init=hierarchy_init, .fini=hier dds_return_t ret; dds_entity_t child; ret = dds_get_children(g_participant, &child, INT32_MAX); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -478,7 +476,7 @@ CU_Theory((dds_entity_t *entity), ddsc_entity_get_children, deleted_entities, .i dds_entity_t children[4]; dds_delete(*entity); ret = dds_get_children(*entity, children, 4); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -488,12 +486,11 @@ CU_TheoryDataPoints(ddsc_entity_get_children, invalid_entities) = { }; CU_Theory((dds_entity_t entity), ddsc_entity_get_children, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t children[4]; dds_return_t ret; ret = dds_get_children(entity, children, 4); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -527,7 +524,7 @@ CU_Theory((dds_entity_t *entity), ddsc_entity_get_topic, deleted_entities, .init dds_entity_t topic; dds_delete(*entity); topic = dds_get_topic(*entity); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -537,11 +534,10 @@ CU_TheoryDataPoints(ddsc_entity_get_topic, invalid_entities) = { }; CU_Theory((dds_entity_t entity), ddsc_entity_get_topic, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t topic; topic = dds_get_topic(entity); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -553,7 +549,7 @@ CU_Theory((dds_entity_t *entity), ddsc_entity_get_topic, non_data_entities, .ini { dds_entity_t topic; topic = dds_get_topic(*entity); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -581,7 +577,7 @@ CU_Test(ddsc_entity_get_publisher, deleted_writer, .init=hierarchy_init, .fini=h dds_entity_t publisher; dds_delete(g_writer); publisher = dds_get_publisher(g_writer); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(publisher, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -591,11 +587,10 @@ CU_TheoryDataPoints(ddsc_entity_get_publisher, invalid_writers) = { }; CU_Theory((dds_entity_t entity), ddsc_entity_get_publisher, invalid_writers, .init=hierarchy_init, .fini=hierarchy_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t publisher; publisher = dds_get_publisher(entity); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(publisher, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -607,7 +602,7 @@ CU_Theory((dds_entity_t *cond), ddsc_entity_get_publisher, non_writers, .init=hi { dds_entity_t publisher; publisher = dds_get_publisher(*cond); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(publisher, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -640,7 +635,7 @@ CU_Theory((dds_entity_t *entity), ddsc_entity_get_subscriber, deleted_readers, . dds_entity_t subscriber; dds_delete(*entity); subscriber = dds_get_subscriber(*entity); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(subscriber, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -650,11 +645,10 @@ CU_TheoryDataPoints(ddsc_entity_get_subscriber, invalid_readers) = { }; CU_Theory((dds_entity_t entity), ddsc_entity_get_subscriber, invalid_readers, .init=hierarchy_init, .fini=hierarchy_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t subscriber; subscriber = dds_get_subscriber(entity); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(subscriber, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -666,7 +660,7 @@ CU_Theory((dds_entity_t *cond), ddsc_entity_get_subscriber, non_readers, .init=h { dds_entity_t subscriber; subscriber = dds_get_subscriber(*cond); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(subscriber, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -701,7 +695,7 @@ CU_Theory((dds_entity_t *cond), ddsc_entity_get_datareader, deleted_conds, .init dds_entity_t reader; dds_delete(*cond); reader = dds_get_datareader(*cond); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(reader), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(reader, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -711,11 +705,10 @@ CU_TheoryDataPoints(ddsc_entity_get_datareader, invalid_conds) = { }; CU_Theory((dds_entity_t cond), ddsc_entity_get_datareader, invalid_conds, .init=hierarchy_init, .fini=hierarchy_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t reader; reader = dds_get_datareader(cond); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(reader), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(reader, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -727,7 +720,7 @@ CU_Theory((dds_entity_t *cond), ddsc_entity_get_datareader, non_conds, .init=hie { dds_entity_t reader; reader = dds_get_datareader(*cond); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(reader), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(reader, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -954,7 +947,7 @@ CU_Test(ddsc_entity_get_parent, implicit_publisher) dds_delete(writer); ret = dds_delete(parent); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); dds_delete(participant); } /*************************************************************************************************/ @@ -985,7 +978,7 @@ CU_Test(ddsc_entity_get_parent, implicit_subscriber) dds_delete(reader); ret = dds_delete(parent); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); dds_delete(participant); } diff --git a/src/core/ddsc/tests/entity_status.c b/src/core/ddsc/tests/entity_status.c index 45883fe..737fbf7 100644 --- a/src/core/ddsc/tests/entity_status.c +++ b/src/core/ddsc/tests/entity_status.c @@ -141,7 +141,7 @@ CU_Test(ddsc_entity_status, publication_matched, .init=init_entity_status, .fini /* Getting the status should have reset the trigger, * meaning that the wait should timeout. */ ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, shortTimeout); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); /* Un-match the publication by deleting the reader. */ dds_delete(rea); @@ -178,7 +178,7 @@ CU_Test(ddsc_entity_status, subscription_matched, .init=init_entity_status, .fin /* Getting the status should have reset the trigger, * meaning that the wait should timeout. */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); /* Un-match the subscription by deleting the writer. */ dds_delete(wri); @@ -233,7 +233,7 @@ CU_Test(ddsc_entity, incompatible_qos, .init=init_entity_status, .fini=fini_enti /*Getting the status should have reset the trigger, waitset should timeout */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); /* Wait for offered incompatible QoS status */ ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, waitTimeout); @@ -246,7 +246,7 @@ CU_Test(ddsc_entity, incompatible_qos, .init=init_entity_status, .fini=fini_enti /*Getting the status should have reset the trigger, waitset should timeout */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); ret = dds_waitset_detach(waitSetrd, reader2); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); @@ -280,7 +280,7 @@ CU_Test(ddsc_entity, liveliness_changed, .init=init_entity_status, .fini=fini_en /*Getting the status should have reset the trigger, waitset should timeout */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); /* Reset writer */ ret = dds_waitset_detach(waitSetwr, wri); @@ -341,7 +341,7 @@ CU_Test(ddsc_entity, sample_rejected, .init=init_entity_status, .fini=fini_entit /*Getting the status should have reset the trigger, waitset should timeout */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); } #if 0 @@ -370,7 +370,7 @@ Test(ddsc_entity, inconsistent_topic) /*Getting the status should have reset the trigger, waitset should timeout */ status = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), 0, "returned %d", dds_err_nr(status)); + CU_ASSERT_EQUAL_FATAL(status, 0, "returned %d", status); /* Wait for sub inconsistent topic status callback */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout); @@ -381,7 +381,7 @@ Test(ddsc_entity, inconsistent_topic) /*Getting the status should have reset the trigger, waitset should timeout */ status = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), 0); + CU_ASSERT_EQUAL_FATAL(status, 0); dds_delete(top); } @@ -431,7 +431,7 @@ CU_Test(ddsc_entity, sample_lost, .init=init_entity_status, .fini=fini_entity_st /*Getting the status should have reset the trigger, waitset should timeout */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); } @@ -594,10 +594,9 @@ CU_TheoryDataPoints(ddsc_get_enabled_status, bad_param) = { CU_Theory((dds_entity_t e), ddsc_get_enabled_status, bad_param, .init=init_entity_status, .fini=fini_entity_status) { uint32_t mask; - dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_status_mask(e, &mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_get_enabled_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) @@ -605,14 +604,14 @@ CU_Test(ddsc_get_enabled_status, deleted_reader, .init=init_entity_status, .fini uint32_t mask; dds_delete(rea); ret = dds_get_status_mask(rea, &mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_get_enabled_status, illegal, .init=init_entity_status, .fini=fini_entity_status) { uint32_t mask; ret = dds_get_status_mask(waitSetrd, &mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } CU_TheoryDataPoints(ddsc_get_enabled_status, status_ok) = { @@ -632,23 +631,21 @@ CU_TheoryDataPoints(ddsc_set_enabled_status, bad_param) = { }; CU_Theory((dds_entity_t e), ddsc_set_enabled_status, bad_param, .init=init_entity_status, .fini=fini_entity_status) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; - ret = dds_set_status_mask(e, 0 /*mask*/); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_set_enabled_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(rea); ret = dds_set_status_mask(rea, 0 /*mask*/); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_set_enabled_status, illegal, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_set_status_mask(waitSetrd, 0); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } CU_TheoryDataPoints(ddsc_set_enabled_status, status_ok) = { @@ -668,10 +665,9 @@ CU_TheoryDataPoints(ddsc_read_status, bad_param) = { CU_Theory((dds_entity_t e), ddsc_read_status, bad_param, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_read_status(e, &status, 0 /*mask*/); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_read_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) @@ -679,14 +675,14 @@ CU_Test(ddsc_read_status, deleted_reader, .init=init_entity_status, .fini=fini_e uint32_t status; dds_delete(rea); ret = dds_read_status(rea, &status, 0 /*mask*/); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_read_status, illegal, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; ret = dds_read_status(waitSetrd, &status, 0); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } CU_TheoryDataPoints(ddsc_read_status, status_ok) = { CU_DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber), @@ -702,14 +698,14 @@ CU_Test(ddsc_read_status, invalid_status_on_reader, .init=init_entity_status, .f { uint32_t status; ret = dds_read_status(rea, &status, DDS_PUBLICATION_MATCHED_STATUS); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_read_status, invalid_status_on_writer, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; ret = dds_read_status(wri, &status, DDS_SUBSCRIPTION_MATCHED_STATUS); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -720,10 +716,9 @@ CU_TheoryDataPoints(ddsc_take_status, bad_param) = { CU_Theory((dds_entity_t e), ddsc_take_status, bad_param, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_take_status(e, &status, 0 /*mask*/); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_take_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) @@ -731,13 +726,13 @@ CU_Test(ddsc_take_status, deleted_reader, .init=init_entity_status, .fini=fini_e uint32_t status; dds_delete(rea); ret = dds_take_status(rea, &status, 0 /*mask*/); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_take_status, illegal, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; ret = dds_take_status(waitSetrd, &status, 0); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } CU_TheoryDataPoints(ddsc_take_status, status_ok) = { @@ -759,10 +754,9 @@ CU_TheoryDataPoints(ddsc_get_status_changes, bad_param) = { CU_Theory((dds_entity_t e), ddsc_get_status_changes, bad_param, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_status_changes(e, &status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_get_status_changes, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) @@ -770,14 +764,14 @@ CU_Test(ddsc_get_status_changes, deleted_reader, .init=init_entity_status, .fini uint32_t status; dds_delete(rea); ret = dds_get_status_changes(rea, &status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_get_status_changes, illegal, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; ret = dds_get_status_changes(waitSetrd, &status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } CU_TheoryDataPoints(ddsc_get_status_changes, status_ok) = { @@ -797,17 +791,15 @@ CU_TheoryDataPoints(ddsc_triggered, bad_param) = { }; CU_Theory((dds_entity_t e), ddsc_triggered, bad_param, .init=init_entity_status, .fini=fini_entity_status) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; - ret = dds_triggered(e); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_triggered, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(rea); ret = dds_triggered(rea); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_TheoryDataPoints(ddsc_triggered, status_ok) = { @@ -825,7 +817,7 @@ CU_Test(ddsc_get_inconsistent_topic_status, inconsistent_topic_status, .init=ini { dds_inconsistent_topic_status_t inconsistent_topic_status; ret = dds_get_inconsistent_topic_status(top, &inconsistent_topic_status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(inconsistent_topic_status.total_count, 0); CU_ASSERT_EQUAL_FATAL(inconsistent_topic_status.total_count_change, 0); } @@ -838,10 +830,9 @@ CU_TheoryDataPoints(ddsc_get_inconsistent_topic_status, bad_params) = { CU_Theory((dds_entity_t topic), ddsc_get_inconsistent_topic_status, bad_params, .init=init_entity_status, .fini=fini_entity_status) { dds_inconsistent_topic_status_t topic_status; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_inconsistent_topic_status(topic, &topic_status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -850,7 +841,7 @@ CU_Test(ddsc_get_inconsistent_topic_status, null, .init=init_entity_status, .fin { dds_set_status_mask(top, 0); ret = dds_get_inconsistent_topic_status(top, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -861,7 +852,7 @@ CU_TheoryDataPoints(ddsc_get_inconsistent_topic_status, non_topics) = { CU_Theory((dds_entity_t *topic), ddsc_get_inconsistent_topic_status, non_topics, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_inconsistent_topic_status(*topic, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -870,7 +861,7 @@ CU_Test(ddsc_get_inconsistent_topic_status, deleted_topic, .init=init_entity_sta { dds_delete(top); ret = dds_get_inconsistent_topic_status(top, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -881,10 +872,9 @@ CU_TheoryDataPoints(ddsc_get_publication_matched_status, bad_params) = { CU_Theory((dds_entity_t writer), ddsc_get_publication_matched_status, bad_params, .init=init_entity_status, .fini=fini_entity_status) { dds_publication_matched_status_t status; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_publication_matched_status(writer, &status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -893,7 +883,7 @@ CU_Test(ddsc_get_publication_matched_status, null, .init=init_entity_status, .fi { dds_set_status_mask(wri, 0); ret = dds_get_publication_matched_status(wri, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -904,7 +894,7 @@ CU_TheoryDataPoints(ddsc_get_publication_matched_status, non_writers) = { CU_Theory((dds_entity_t *writer), ddsc_get_publication_matched_status, non_writers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_publication_matched_status(*writer, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -913,7 +903,7 @@ CU_Test(ddsc_get_publication_matched_status, deleted_writer, .init=init_entity_s { dds_delete(wri); ret = dds_get_publication_matched_status(wri, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -922,7 +912,7 @@ CU_Test(ddsc_get_liveliness_lost_status, liveliness_lost_status, .init=init_enti { dds_liveliness_lost_status_t liveliness_lost_status; ret = dds_get_liveliness_lost_status(wri, &liveliness_lost_status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(liveliness_lost_status.total_count, 0); CU_ASSERT_EQUAL_FATAL(liveliness_lost_status.total_count_change, 0); } @@ -935,10 +925,9 @@ CU_TheoryDataPoints(ddsc_get_liveliness_lost_status, bad_params) = { CU_Theory((dds_entity_t writer), ddsc_get_liveliness_lost_status, bad_params, .init=init_entity_status, .fini=fini_entity_status) { dds_liveliness_lost_status_t status; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_liveliness_lost_status(writer, &status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -947,7 +936,7 @@ CU_Test(ddsc_get_liveliness_lost_status, null, .init=init_entity_status, .fini=f { dds_set_status_mask(wri, 0); ret = dds_get_liveliness_lost_status(wri, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -958,7 +947,7 @@ CU_TheoryDataPoints(ddsc_get_liveliness_lost_status, non_writers) = { CU_Theory((dds_entity_t *writer), ddsc_get_liveliness_lost_status, non_writers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_liveliness_lost_status(*writer, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -967,7 +956,7 @@ CU_Test(ddsc_get_liveliness_lost_status, deleted_writer, .init=init_entity_statu { dds_delete(wri); ret = dds_get_liveliness_lost_status(wri, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -976,7 +965,7 @@ CU_Test(ddsc_get_offered_deadline_missed_status, offered_deadline_missed_status, { dds_offered_deadline_missed_status_t offered_deadline_missed_status; ret = dds_get_offered_deadline_missed_status(wri, &offered_deadline_missed_status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(offered_deadline_missed_status.total_count, 0); CU_ASSERT_EQUAL_FATAL(offered_deadline_missed_status.total_count_change, 0); CU_ASSERT_EQUAL_FATAL(offered_deadline_missed_status.last_instance_handle, 0); @@ -990,10 +979,9 @@ CU_TheoryDataPoints(ddsc_get_offered_deadline_missed_status, bad_params) = { CU_Theory((dds_entity_t writer), ddsc_get_offered_deadline_missed_status, bad_params, .init=init_entity_status, .fini=fini_entity_status) { dds_offered_deadline_missed_status_t status; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_offered_deadline_missed_status(writer, &status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1002,7 +990,7 @@ CU_Test(ddsc_get_offered_deadline_missed_status, null, .init=init_entity_status, { dds_set_status_mask(wri, 0); ret = dds_get_offered_deadline_missed_status(wri, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -1013,7 +1001,7 @@ CU_TheoryDataPoints(ddsc_get_offered_deadline_missed_status, non_writers) = { CU_Theory((dds_entity_t *writer), ddsc_get_offered_deadline_missed_status, non_writers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_offered_deadline_missed_status(*writer, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -1022,7 +1010,7 @@ CU_Test(ddsc_get_offered_deadline_missed_status, deleted_writer, .init=init_enti { dds_delete(wri); ret = dds_get_offered_deadline_missed_status(wri, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1033,10 +1021,9 @@ CU_TheoryDataPoints(ddsc_get_offered_incompatible_qos_status, bad_params) = { CU_Theory((dds_entity_t writer), ddsc_get_offered_incompatible_qos_status, bad_params, .init=init_entity_status, .fini=fini_entity_status) { dds_offered_incompatible_qos_status_t status; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_offered_incompatible_qos_status(writer, &status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1045,7 +1032,7 @@ CU_Test(ddsc_get_offered_incompatible_qos_status, null, .init=init_entity_status { dds_set_status_mask(wri, 0); ret = dds_get_offered_incompatible_qos_status(wri, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -1056,7 +1043,7 @@ CU_TheoryDataPoints(ddsc_get_offered_incompatible_qos_status, non_writers) = { CU_Theory((dds_entity_t *writer), ddsc_get_offered_incompatible_qos_status, non_writers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_offered_incompatible_qos_status(*writer, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -1065,7 +1052,7 @@ CU_Test(ddsc_get_offered_incompatible_qos_status, deleted_writer, .init=init_ent { dds_delete(wri); ret = dds_get_offered_incompatible_qos_status(wri, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1076,10 +1063,9 @@ CU_TheoryDataPoints(ddsc_get_subscription_matched_status, bad_params) = { CU_Theory((dds_entity_t reader), ddsc_get_subscription_matched_status, bad_params, .init=init_entity_status, .fini=fini_entity_status) { dds_subscription_matched_status_t status; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_subscription_matched_status(reader, &status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1088,7 +1074,7 @@ CU_Test(ddsc_get_subscription_matched_status, null, .init=init_entity_status, .f { dds_set_status_mask(rea, 0); ret = dds_get_subscription_matched_status(rea, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -1099,7 +1085,7 @@ CU_TheoryDataPoints(ddsc_get_subscription_matched_status, non_readers) = { CU_Theory((dds_entity_t *reader), ddsc_get_subscription_matched_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_subscription_matched_status(*reader, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -1108,7 +1094,7 @@ CU_Test(ddsc_get_subscription_matched_status, deleted_reader, .init=init_entity_ { dds_delete(rea); ret = dds_get_subscription_matched_status(rea, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1119,10 +1105,9 @@ CU_TheoryDataPoints(ddsc_get_liveliness_changed_status, bad_params) = { CU_Theory((dds_entity_t reader), ddsc_get_liveliness_changed_status, bad_params, .init=init_entity_status, .fini=fini_entity_status) { dds_liveliness_changed_status_t status; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_liveliness_changed_status(reader, &status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1131,7 +1116,7 @@ CU_Test(ddsc_get_liveliness_changed_status, null, .init=init_entity_status, .fin { dds_set_status_mask(rea, 0); ret = dds_get_liveliness_changed_status(rea, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -1142,7 +1127,7 @@ CU_TheoryDataPoints(ddsc_get_liveliness_changed_status, non_readers) = { CU_Theory((dds_entity_t *reader), ddsc_get_liveliness_changed_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_liveliness_changed_status(*reader, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -1151,7 +1136,7 @@ CU_Test(ddsc_get_liveliness_changed_status, deleted_reader, .init=init_entity_st { dds_delete(rea); ret = dds_get_liveliness_changed_status(rea, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1162,10 +1147,9 @@ CU_TheoryDataPoints(ddsc_get_sample_rejected_status, bad_params) = { CU_Theory((dds_entity_t reader), ddsc_get_sample_rejected_status, bad_params, .init=init_entity_status, .fini=fini_entity_status) { dds_sample_rejected_status_t status; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_sample_rejected_status(reader, &status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1174,7 +1158,7 @@ CU_Test(ddsc_get_sample_rejected_status, null, .init=init_entity_status, .fini=f { dds_set_status_mask(rea, 0); ret = dds_get_sample_rejected_status(rea, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -1185,7 +1169,7 @@ CU_TheoryDataPoints(ddsc_get_sample_rejected_status, non_readers) = { CU_Theory((dds_entity_t *reader), ddsc_get_sample_rejected_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_sample_rejected_status(*reader, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -1194,7 +1178,7 @@ CU_Test(ddsc_get_sample_rejected_status, deleted_reader, .init=init_entity_statu { dds_delete(rea); ret = dds_get_sample_rejected_status(rea, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1205,10 +1189,9 @@ CU_TheoryDataPoints(ddsc_get_sample_lost_status, bad_params) = { CU_Theory((dds_entity_t reader), ddsc_get_sample_lost_status, bad_params, .init=init_entity_status, .fini=fini_entity_status) { dds_sample_lost_status_t status; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_sample_lost_status(reader, &status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1217,7 +1200,7 @@ CU_Test(ddsc_get_sample_lost_status, null, .init=init_entity_status, .fini=fini_ { dds_set_status_mask(rea, 0); ret = dds_get_sample_lost_status(rea, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -1228,7 +1211,7 @@ CU_TheoryDataPoints(ddsc_get_sample_lost_status, non_readers) = { CU_Theory((dds_entity_t *reader), ddsc_get_sample_lost_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_sample_lost_status(*reader, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -1237,7 +1220,7 @@ CU_Test(ddsc_get_sample_lost_status, deleted_reader, .init=init_entity_status, . { dds_delete(rea); ret = dds_get_sample_lost_status(rea, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1246,7 +1229,7 @@ CU_Test(ddsc_get_requested_deadline_missed_status, requested_deadline_missed_sta { dds_requested_deadline_missed_status_t requested_deadline_missed_status; ret = dds_get_requested_deadline_missed_status(rea, &requested_deadline_missed_status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(requested_deadline_missed_status.total_count, 0); CU_ASSERT_EQUAL_FATAL(requested_deadline_missed_status.total_count_change, 0); CU_ASSERT_EQUAL_FATAL(requested_deadline_missed_status.last_instance_handle, DDS_HANDLE_NIL); @@ -1260,10 +1243,9 @@ CU_TheoryDataPoints(ddsc_get_requested_deadline_missed_status, bad_params) = { CU_Theory((dds_entity_t reader), ddsc_get_requested_deadline_missed_status, bad_params, .init=init_entity_status, .fini=fini_entity_status) { dds_requested_deadline_missed_status_t status; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_requested_deadline_missed_status(reader, &status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1272,7 +1254,7 @@ CU_Test(ddsc_get_requested_deadline_missed_status, null, .init=init_entity_statu { dds_set_status_mask(rea, 0); ret = dds_get_requested_deadline_missed_status(rea, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -1283,7 +1265,7 @@ CU_TheoryDataPoints(ddsc_get_requested_deadline_missed_status, non_readers) = { CU_Theory((dds_entity_t *reader), ddsc_get_requested_deadline_missed_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_requested_deadline_missed_status(*reader, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -1292,7 +1274,7 @@ CU_Test(ddsc_get_requested_deadline_missed_status, deleted_reader, .init=init_en { dds_delete(rea); ret = dds_get_requested_deadline_missed_status(rea, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1303,10 +1285,9 @@ CU_TheoryDataPoints(ddsc_get_requested_incompatible_qos_status, bad_params) = { CU_Theory((dds_entity_t reader), ddsc_get_requested_incompatible_qos_status, bad_params, .init=init_entity_status, .fini=fini_entity_status) { dds_requested_incompatible_qos_status_t status; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_requested_incompatible_qos_status(reader, &status); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1315,7 +1296,7 @@ CU_Test(ddsc_get_requested_incompatible_qos_status, null, .init=init_entity_stat { dds_set_status_mask(rea, 0); ret = dds_get_requested_incompatible_qos_status(rea, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -1326,7 +1307,7 @@ CU_TheoryDataPoints(ddsc_get_requested_incompatible_qos_status, non_readers) = { CU_Theory((dds_entity_t *reader), ddsc_get_requested_incompatible_qos_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_requested_incompatible_qos_status(*reader, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -1335,7 +1316,7 @@ CU_Test(ddsc_get_requested_incompatible_qos_status, deleted_reader, .init=init_e { dds_delete(rea); ret = dds_get_requested_incompatible_qos_status(rea, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/instance_get_key.c b/src/core/ddsc/tests/instance_get_key.c index 48bd0d3..9c25d1a 100644 --- a/src/core/ddsc/tests/instance_get_key.c +++ b/src/core/ddsc/tests/instance_get_key.c @@ -63,7 +63,7 @@ CU_Test(ddsc_instance_get_key, bad_entity, .init=setup, .fini=teardown) dds_return_t ret; ret = dds_instance_get_key(participant, handle, &data); - CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_instance_get_key, null_data, .init=setup, .fini=teardown) @@ -71,7 +71,7 @@ CU_Test(ddsc_instance_get_key, null_data, .init=setup, .fini=teardown) dds_return_t ret; ret = dds_register_instance(writer, &handle, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_instance_get_key, null_handle, .init=setup, .fini=teardown) @@ -81,7 +81,7 @@ CU_Test(ddsc_instance_get_key, null_handle, .init=setup, .fini=teardown) CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_instance_get_key(writer, DDS_HANDLE_NIL, &data); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_instance_get_key, registered_instance, .init=setup, .fini=teardown) @@ -99,7 +99,7 @@ CU_Test(ddsc_instance_get_key, registered_instance, .init=setup, .fini=teardown) CU_ASSERT_PTR_NOT_NULL_FATAL(key_data.ip); CU_ASSERT_STRING_EQUAL_FATAL(key_data.ip, data.ip); CU_ASSERT_EQUAL_FATAL(key_data.port, data.port); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); RoundTripModule_Address_free(&key_data, DDS_FREE_CONTENTS); } diff --git a/src/core/ddsc/tests/participant.c b/src/core/ddsc/tests/participant.c index 6b7155d..8225d2d 100644 --- a/src/core/ddsc/tests/participant.c +++ b/src/core/ddsc/tests/participant.c @@ -17,8 +17,6 @@ #include "dds/version.h" #include "dds/ddsrt/environ.h" -#define cu_assert_status_eq(s1, s2) CU_ASSERT_EQUAL_FATAL(dds_err_nr(s1), s2) - CU_Test(ddsc_participant, create_and_delete) { @@ -59,14 +57,14 @@ CU_Test(ddsc_participant, create_with_no_conf_no_env) participant2 = dds_create_participant (valid_domain, NULL, NULL); CU_ASSERT_FATAL(participant2 > 0); status = dds_get_domainid(participant2, &domain_id); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain); //DDS_DOMAIN_DEFAULT from user participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); CU_ASSERT_FATAL(participant3 > 0); status = dds_get_domainid(participant3, &domain_id); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain); dds_delete(participant2); @@ -98,7 +96,7 @@ CU_Test(ddsc_participant, create_with_conf_no_env) { participant2 = dds_create_participant (valid_domain, NULL, NULL); CU_ASSERT_FATAL(participant2 > 0); status = dds_get_domainid(participant2, &domain_id); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain); @@ -106,7 +104,7 @@ CU_Test(ddsc_participant, create_with_conf_no_env) { participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); CU_ASSERT_FATAL(participant3 > 0); status = dds_get_domainid(participant3, &domain_id); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain); dds_delete(participant2); @@ -127,7 +125,7 @@ CU_Test(ddsc_participant_lookup, one) { /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); num_of_found_pp = dds_lookup_participant( domain_id, participants, size); CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 1); @@ -153,7 +151,7 @@ CU_Test(ddsc_participant_lookup, multiple) { /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); num_of_found_pp = dds_lookup_participant( domain_id, participants, size); CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 2); @@ -185,7 +183,7 @@ CU_Test(ddsc_participant_lookup, array_too_small) { /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); num_of_found_pp = dds_lookup_participant( domain_id, participants, size); CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 3); @@ -211,7 +209,7 @@ CU_Test(ddsc_participant_lookup, null_zero){ /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); num_of_found_pp = dds_lookup_participant( domain_id, NULL, size); CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 1); @@ -232,10 +230,10 @@ CU_Test(ddsc_participant_lookup, null_nonzero){ /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); num_of_found_pp = dds_lookup_participant( domain_id, NULL, size); - cu_assert_status_eq(num_of_found_pp, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(num_of_found_pp, DDS_RETCODE_BAD_PARAMETER); dds_delete (participant); } @@ -254,7 +252,7 @@ CU_Test(ddsc_participant_lookup, unknown_id) { /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); domain_id ++; num_of_found_pp = dds_lookup_participant( domain_id, participants, size); @@ -287,7 +285,7 @@ CU_Test(ddsc_participant_lookup, no_more) { /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); dds_delete (participant); @@ -312,7 +310,7 @@ CU_Test(ddsc_participant_lookup, deleted) { /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); dds_delete (participant2); diff --git a/src/core/ddsc/tests/publisher.c b/src/core/ddsc/tests/publisher.c index 78c5bb1..2035e4a 100644 --- a/src/core/ddsc/tests/publisher.c +++ b/src/core/ddsc/tests/publisher.c @@ -19,8 +19,6 @@ #pragma warning(disable: 28020) #endif -#define cu_assert_status_eq(s1, s2) CU_ASSERT_EQUAL_FATAL(dds_err_nr(s1), s2) - /* Dummy callback */ static void data_available_cb(dds_entity_t reader, void* arg) { @@ -42,7 +40,7 @@ CU_Test(ddsc_publisher, create) /* Use NULL participant */ publisher = dds_create_publisher(0, NULL, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(publisher, DDS_RETCODE_PRECONDITION_NOT_MET); participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); CU_ASSERT_FATAL(participant > 0); @@ -53,7 +51,7 @@ CU_Test(ddsc_publisher, create) /* Use entity that is not a participant */ publisher1 = dds_create_publisher(publisher, NULL, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher1), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(publisher1, DDS_RETCODE_ILLEGAL_OPERATION); dds_delete(publisher); /* Create a non-null qos */ @@ -143,35 +141,35 @@ CU_Test(ddsc_publisher, suspend_resume) /* Suspend a 0 publisher */ status = dds_suspend(0); - cu_assert_status_eq(status, DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_PRECONDITION_NOT_MET); /* Resume a 0 publisher */ status = dds_resume(0); - cu_assert_status_eq(status, DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_PRECONDITION_NOT_MET); /* Uae dds_suspend on something else than a publisher */ participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); CU_ASSERT_FATAL(participant > 0); status = dds_suspend(participant); - cu_assert_status_eq(status, DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_ILLEGAL_OPERATION); /* Use dds_resume on something else than a publisher */ status = dds_resume(participant); - cu_assert_status_eq(status, DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_ILLEGAL_OPERATION); /* Use dds_resume without calling dds_suspend */ publisher = dds_create_publisher(participant, NULL, NULL); CU_ASSERT_FATAL(publisher > 0); status = dds_resume(publisher); /* Should be precondition not met? */ - cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED); /* Use dds_suspend on non-null publisher */ status = dds_suspend(publisher); - cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED); /* Use dds_resume on non-null publisher */ status = dds_resume(publisher); - cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED); dds_delete(publisher); dds_delete(participant); @@ -189,38 +187,38 @@ CU_Test(ddsc_publisher, wait_for_acks) /* Wait_for_acks on 0 publisher or writer and minusOneSec timeout */ status = dds_wait_for_acks(0, minusOneSec); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); /* Wait_for_acks on NULL publisher or writer and zeroSec timeout */ status = dds_wait_for_acks(0, zeroSec); - cu_assert_status_eq(status, DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_PRECONDITION_NOT_MET); /* wait_for_acks on NULL publisher or writer and oneSec timeout */ status = dds_wait_for_acks(0, oneSec); - cu_assert_status_eq(status, DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_PRECONDITION_NOT_MET); /* wait_for_acks on NULL publisher or writer and DDS_INFINITE timeout */ status = dds_wait_for_acks(0, DDS_INFINITY); - cu_assert_status_eq(status, DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_PRECONDITION_NOT_MET); participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); CU_ASSERT_FATAL(participant > 0); /* Wait_for_acks on participant and minusOneSec timeout */ status = dds_wait_for_acks(participant, minusOneSec); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); /* Wait_for_acks on participant and zeroSec timeout */ status = dds_wait_for_acks(participant, zeroSec); - cu_assert_status_eq(status, DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_ILLEGAL_OPERATION); /* Wait_for_acks on participant and oneSec timeout */ status = dds_wait_for_acks(participant, oneSec); - cu_assert_status_eq(status, DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_ILLEGAL_OPERATION); /* Wait_for_acks on participant and DDS_INFINITE timeout */ status = dds_wait_for_acks(participant, DDS_INFINITY); - cu_assert_status_eq(status, DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_ILLEGAL_OPERATION); publisher = dds_create_publisher(participant, NULL, NULL); CU_ASSERT_FATAL(publisher > 0); @@ -228,40 +226,40 @@ CU_Test(ddsc_publisher, wait_for_acks) /* Wait_for_acks on publisher and minusOneSec timeout -- either BAD_PARAMETER or UNSUPPORTED would be both be ok, really */ status = dds_wait_for_acks(publisher, minusOneSec); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); /* Wait_for_acks on publisher and zeroSec timeout */ status = dds_wait_for_acks(publisher, zeroSec); - cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED); /* Wait_for_acks on publisher and oneSec timeout */ status = dds_wait_for_acks(publisher, oneSec); - cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED); /* Wait_for_acks on publisher and DDS_INFINITE timeout */ status = dds_wait_for_acks(publisher, DDS_INFINITY); - cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED); /* TODO: create tests by calling dds_qwait_for_acks on writers */ status = dds_suspend(publisher); - cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED); /* Wait_for_acks on suspended publisher and minusOneSec timeout */ status = dds_wait_for_acks(publisher, minusOneSec); - cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); /* Wait_for_acks on suspended publisher and zeroSec timeout */ status = dds_wait_for_acks(publisher, zeroSec); - cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED); /* Wait_for_acks on suspended publisher and oneSec timeout */ status = dds_wait_for_acks(publisher, oneSec); - cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED); /* Wait_for_acks on suspended publisher and DDS_INFINITE timeout */ status = dds_wait_for_acks(publisher, DDS_INFINITY); - cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_UNSUPPORTED); dds_delete(publisher); dds_delete(participant); diff --git a/src/core/ddsc/tests/qos.c b/src/core/ddsc/tests/qos.c index a947390..88fe4e6 100644 --- a/src/core/ddsc/tests/qos.c +++ b/src/core/ddsc/tests/qos.c @@ -234,7 +234,7 @@ CU_Test(ddsc_qos, copy_bad_source, .init=qos_init, .fini=qos_fini) dds_return_t result; result = dds_copy_qos(g_qos, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(result, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_qos, copy_bad_destination, .init=qos_init, .fini=qos_fini) @@ -242,7 +242,7 @@ CU_Test(ddsc_qos, copy_bad_destination, .init=qos_init, .fini=qos_fini) dds_return_t result; result = dds_copy_qos(NULL, g_qos); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(result, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_qos, copy_with_partition, .init=qos_init, .fini=qos_fini) diff --git a/src/core/ddsc/tests/querycondition.c b/src/core/ddsc/tests/querycondition.c index 107fdd1..d1afbf5 100644 --- a/src/core/ddsc/tests/querycondition.c +++ b/src/core/ddsc/tests/querycondition.c @@ -245,7 +245,7 @@ CU_Test(ddsc_querycondition_create, deleted_reader, .init=querycondition_init, . dds_entity_t cond; dds_delete(g_reader); cond = dds_create_querycondition(g_reader, mask, filter_mod2); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(cond, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -256,11 +256,10 @@ CU_TheoryDataPoints(ddsc_querycondition_create, invalid_readers) = { CU_Theory((dds_entity_t rdr), ddsc_querycondition_create, invalid_readers, .init=querycondition_init, .fini=querycondition_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t cond; cond = dds_create_querycondition(rdr, mask, filter_mod2); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(cond, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -273,7 +272,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_querycondition_create, non_readers, .init=qu uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t cond; cond = dds_create_querycondition(*rdr, mask, filter_mod2); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(cond, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -297,7 +296,7 @@ CU_Test(ddsc_querycondition_get_mask, deleted, .init=querycondition_init, .fini= dds_delete(condition); mask = 0; ret = dds_get_mask(condition, &mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -312,7 +311,7 @@ CU_Test(ddsc_querycondition_get_mask, null, .init=querycondition_init, .fini=que DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_get_mask(condition, NULL); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); dds_delete(condition); } /*************************************************************************************************/ @@ -323,12 +322,11 @@ CU_TheoryDataPoints(ddsc_querycondition_get_mask, invalid_conditions) = { }; CU_Theory((dds_entity_t cond), ddsc_querycondition_get_mask, invalid_conditions, .init=querycondition_init, .fini=querycondition_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; uint32_t mask; ret = dds_get_mask(cond, &mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -341,7 +339,7 @@ CU_Theory((dds_entity_t *cond), ddsc_querycondition_get_mask, non_conditions, .i dds_return_t ret; uint32_t mask; ret = dds_get_mask(*cond, &mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -362,7 +360,7 @@ CU_Theory((uint32_t ss, uint32_t vs, uint32_t is), ddsc_querycondition_get_mask, CU_ASSERT_FATAL(condition > 0); ret = dds_get_mask(condition, &maskOut); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(maskIn, maskOut); dds_delete(condition); @@ -924,7 +922,7 @@ CU_Test(ddsc_querycondition_read, already_deleted, .init=querycondition_init, .f /* Try to read with a deleted condition. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1487,7 +1485,7 @@ CU_Test(ddsc_querycondition_take, already_deleted, .init=querycondition_init, .f /* Try to take with a deleted condition. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/read_instance.c b/src/core/ddsc/tests/read_instance.c index 063d003..db46759 100644 --- a/src/core/ddsc/tests/read_instance.c +++ b/src/core/ddsc/tests/read_instance.c @@ -299,7 +299,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, u * However, that's not the case yet. So don't test it. */ if (buf != g_loans) { ret = dds_read_instance(*ent, buf, si, bufsz, maxs, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } else { CU_PASS("Skipped"); } @@ -320,7 +320,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs), * invalid and neither is the handle. So, don't test that. */ if ((buf != g_loans) || (si != g_info) || (maxs == 0)) { ret = dds_read_instance_wl(*ent, buf, si, maxs, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } else { CU_PASS("Skipped"); } @@ -350,7 +350,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, u * However, that's not the case yet. So don't test it. */ if (buf != g_loans) { ret = dds_read_instance_mask(*ent, buf, si, bufsz, maxs, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } else { CU_PASS("Skipped"); } @@ -372,7 +372,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs), * invalid and neither is the handle. So, don't test that. */ CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); ret = dds_read_instance_mask_wl(*ent, buf, si, maxs, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -394,7 +394,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance, in { dds_return_t ret; ret = dds_read_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -407,7 +407,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance_wl, { dds_return_t ret; ret = dds_read_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -421,7 +421,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance_mas uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_read_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -435,7 +435,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance_mas uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_read_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -454,11 +454,10 @@ CU_TheoryDataPoints(ddsc_read_instance, invalid_readers) = { }; CU_Theory((dds_entity_t rdr), ddsc_read_instance, invalid_readers, .init=read_instance_init, .fini=read_instance_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_instance(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -468,11 +467,10 @@ CU_TheoryDataPoints(ddsc_read_instance_wl, invalid_readers) = { }; CU_Theory((dds_entity_t rdr), ddsc_read_instance_wl, invalid_readers, .init=read_instance_init, .fini=read_instance_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_instance_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -483,11 +481,10 @@ CU_TheoryDataPoints(ddsc_read_instance_mask, invalid_readers) = { CU_Theory((dds_entity_t rdr), ddsc_read_instance_mask, invalid_readers, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_instance_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -498,11 +495,10 @@ CU_TheoryDataPoints(ddsc_read_instance_mask_wl, invalid_readers) = { CU_Theory((dds_entity_t rdr), ddsc_read_instance_mask_wl, invalid_readers, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_instance_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -524,7 +520,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance, non_readers, .init=read_insta { dds_return_t ret; ret = dds_read_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -536,7 +532,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance_wl, non_readers, .init=read_in { dds_return_t ret; ret = dds_read_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -549,7 +545,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance_mask, non_readers, .init=read_ uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_read_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -562,7 +558,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance_mask_wl, non_readers, .init=re uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_read_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -586,7 +582,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance, already_deleted, .init=read_i ret = dds_delete(*rdr); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_read_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -600,7 +596,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance_wl, already_deleted, .init=rea ret = dds_delete(*rdr); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_read_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -615,7 +611,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance_mask, already_deleted, .init=r ret = dds_delete(*rdr); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_read_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -630,7 +626,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_instance_mask_wl, already_deleted, .ini ret = dds_delete(*rdr); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_read_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/readcondition.c b/src/core/ddsc/tests/readcondition.c index 694d463..4566d0c 100644 --- a/src/core/ddsc/tests/readcondition.c +++ b/src/core/ddsc/tests/readcondition.c @@ -227,7 +227,7 @@ CU_Test(ddsc_readcondition_create, deleted_reader, .init=readcondition_init, .fi dds_entity_t cond; dds_delete(g_reader); cond = dds_create_readcondition(g_reader, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(cond, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -238,11 +238,10 @@ CU_TheoryDataPoints(ddsc_readcondition_create, invalid_readers) = { CU_Theory((dds_entity_t rdr), ddsc_readcondition_create, invalid_readers, .init=readcondition_init, .fini=readcondition_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t cond; cond = dds_create_readcondition(rdr, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(cond, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -255,7 +254,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_readcondition_create, non_readers, .init=rea uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t cond; cond = dds_create_readcondition(*rdr, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(cond, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -279,7 +278,7 @@ CU_Test(ddsc_readcondition_get_mask, deleted, .init=readcondition_init, .fini=re dds_delete(condition); mask = 0; ret = dds_get_mask(condition, &mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -294,7 +293,7 @@ CU_Test(ddsc_readcondition_get_mask, null, .init=readcondition_init, .fini=readc DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_get_mask(condition, NULL); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); dds_delete(condition); } /*************************************************************************************************/ @@ -305,12 +304,11 @@ CU_TheoryDataPoints(ddsc_readcondition_get_mask, invalid_conditions) = { }; CU_Theory((dds_entity_t cond), ddsc_readcondition_get_mask, invalid_conditions, .init=readcondition_init, .fini=readcondition_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; uint32_t mask; ret = dds_get_mask(cond, &mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -323,7 +321,7 @@ CU_Theory((dds_entity_t *cond), ddsc_readcondition_get_mask, non_conditions, .in dds_return_t ret; uint32_t mask; ret = dds_get_mask(*cond, &mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -344,7 +342,7 @@ CU_Theory((uint32_t ss, uint32_t vs, uint32_t is), ddsc_readcondition_get_mask, CU_ASSERT_FATAL(condition > 0); ret = dds_get_mask(condition, &maskOut); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); CU_ASSERT_EQUAL_FATAL(maskIn, maskOut); dds_delete(condition); @@ -906,7 +904,7 @@ CU_Test(ddsc_readcondition_read, already_deleted, .init=readcondition_init, .fin /* Try to read with a deleted condition. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1462,7 +1460,7 @@ CU_Test(ddsc_readcondition_take, already_deleted, .init=readcondition_init, .fin /* Try to take with a deleted condition. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/reader.c b/src/core/ddsc/tests/reader.c index ad80be7..bf8e9dc 100644 --- a/src/core/ddsc/tests/reader.c +++ b/src/core/ddsc/tests/reader.c @@ -241,7 +241,7 @@ CU_Test(ddsc_reader_create, invalid_qos_participant, .init=reader_init, .fini=re dds_qset_reader_data_lifecycle(qos, DDS_SECS(-1), DDS_SECS(-1)); DDSRT_WARNING_MSVC_ON(28020); rdr = dds_create_reader(g_participant, g_topic, qos, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(rdr), DDS_RETCODE_INCONSISTENT_POLICY); + CU_ASSERT_EQUAL_FATAL(rdr, DDS_RETCODE_INCONSISTENT_POLICY); dds_delete_qos(qos); } /*************************************************************************************************/ @@ -256,7 +256,7 @@ CU_Test(ddsc_reader_create, invalid_qos_subscriber, .init=reader_init, .fini=rea dds_qset_reader_data_lifecycle(qos, DDS_SECS(-1), DDS_SECS(-1)); DDSRT_WARNING_MSVC_ON(28020); rdr = dds_create_reader(g_subscriber, g_topic, qos, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(rdr), DDS_RETCODE_INCONSISTENT_POLICY); + CU_ASSERT_EQUAL_FATAL(rdr, DDS_RETCODE_INCONSISTENT_POLICY); dds_delete_qos(qos); } /*************************************************************************************************/ @@ -273,7 +273,7 @@ CU_Theory((dds_entity_t *par, dds_entity_t *top), ddsc_reader_create, non_partic * actually the topic. So, don't test that permutation. */ CU_ASSERT_FATAL((par != &g_participant) || (top != &g_topic)); rdr = dds_create_reader(*par, *top, NULL, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(rdr), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(rdr, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -307,7 +307,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc * However, that's not the case yet. So don't test it. */ if (buf != g_loans) { ret = dds_read(g_reader, buf, si, bufsz, maxs); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } else { CU_PASS("Skipped"); } @@ -320,11 +320,10 @@ CU_TheoryDataPoints(ddsc_read, invalid_readers) = { }; CU_Theory((dds_entity_t rdr), ddsc_read, invalid_readers, .init=reader_init, .fini=reader_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -336,7 +335,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read, non_readers, .init=reader_init, .fini= { dds_return_t ret; ret = dds_read(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -347,7 +346,7 @@ CU_Test(ddsc_read, already_deleted, .init=reader_init, .fini=reader_fini) /* Try to read with a deleted reader. */ dds_delete(g_reader); ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -420,7 +419,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_read_wl, inva * invalid. So, don't test that. */ CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); ret = dds_read_wl(g_reader, buf, si, maxs); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -430,11 +429,10 @@ CU_TheoryDataPoints(ddsc_read_wl, invalid_readers) = { }; CU_Theory((dds_entity_t rdr), ddsc_read_wl, invalid_readers, .init=reader_init, .fini=reader_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_wl(rdr, g_loans, g_info, MAX_SAMPLES); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -446,7 +444,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_wl, non_readers, .init=reader_init, .fi { dds_return_t ret; ret = dds_read_wl(*rdr, g_loans, g_info, MAX_SAMPLES); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -457,7 +455,7 @@ CU_Test(ddsc_read_wl, already_deleted, .init=reader_init, .fini=reader_fini) /* Try to read with a deleted reader. */ dds_delete(g_reader); ret = dds_read_wl(g_reader, g_loans, g_info, MAX_SAMPLES); - CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -541,7 +539,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc * However, that's not the case yet. So don't test it. */ if (buf != g_loans) { ret = dds_read_mask(g_reader, buf, si, bufsz, maxs, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } else { CU_PASS("Skipped"); } @@ -555,11 +553,10 @@ CU_TheoryDataPoints(ddsc_read_mask, invalid_readers) = { CU_Theory((dds_entity_t rdr), ddsc_read_mask, invalid_readers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -572,7 +569,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_mask, non_readers, .init=reader_init, . uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_read_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -584,7 +581,7 @@ CU_Test(ddsc_read_mask, already_deleted, .init=reader_init, .fini=reader_fini) /* Try to read with a deleted reader. */ dds_delete(g_reader); ret = dds_read_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1092,7 +1089,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_read_mask_wl, * invalid. So, don't test that. */ CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); ret = dds_read_mask_wl(g_reader, buf, si, maxs, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1103,11 +1100,10 @@ CU_TheoryDataPoints(ddsc_read_mask_wl, invalid_readers) = { CU_Theory((dds_entity_t rdr), ddsc_read_mask_wl, invalid_readers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1120,7 +1116,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_mask_wl, non_readers, .init=reader_init uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_read_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -1132,7 +1128,7 @@ CU_Test(ddsc_read_mask_wl, already_deleted, .init=reader_init, .fini=reader_fini /* Try to read with a deleted reader. */ dds_delete(g_reader); ret = dds_read_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1677,7 +1673,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc * However, that's not the case yet. So don't test it. */ if (buf != g_loans) { ret = dds_take(g_reader, buf, si, bufsz, maxs); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } else { CU_PASS("Skipped"); } @@ -1690,11 +1686,10 @@ CU_TheoryDataPoints(ddsc_take, invalid_readers) = { }; CU_Theory((dds_entity_t rdr), ddsc_take, invalid_readers, .init=reader_init, .fini=reader_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1706,7 +1701,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take, non_readers, .init=reader_init, .fini= { dds_return_t ret; ret = dds_take(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -1717,7 +1712,7 @@ CU_Test(ddsc_take, already_deleted, .init=reader_init, .fini=reader_fini) /* Try to take with a deleted reader. */ dds_delete(g_reader); ret = dds_take(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1790,7 +1785,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_take_wl, inva * invalid. So, don't test that. */ CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); ret = dds_take_wl(g_reader, buf, si, maxs); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1800,11 +1795,10 @@ CU_TheoryDataPoints(ddsc_take_wl, invalid_readers) = { }; CU_Theory((dds_entity_t rdr), ddsc_take_wl, invalid_readers, .init=reader_init, .fini=reader_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_wl(rdr, g_loans, g_info, MAX_SAMPLES); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1816,7 +1810,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_wl, non_readers, .init=reader_init, .fi { dds_return_t ret; ret = dds_take_wl(*rdr, g_loans, g_info, MAX_SAMPLES); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -1827,7 +1821,7 @@ CU_Test(ddsc_take_wl, already_deleted, .init=reader_init, .fini=reader_fini) /* Try to read with a deleted reader. */ dds_delete(g_reader); ret = dds_take_wl(g_reader, g_loans, g_info, MAX_SAMPLES); - CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1912,7 +1906,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc * However, that's not the case yet. So don't test it. */ if (buf != g_loans) { ret = dds_take_mask(g_reader, buf, si, bufsz, maxs, mask); - CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER); } else { CU_PASS("Skipped"); } @@ -1926,11 +1920,10 @@ CU_TheoryDataPoints(ddsc_take_mask, invalid_readers) = { CU_Theory((dds_entity_t rdr), ddsc_take_mask, invalid_readers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - CU_ASSERT_EQUAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -1943,7 +1936,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_mask, non_readers, .init=reader_init, . uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_take_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -1955,7 +1948,7 @@ CU_Test(ddsc_take_mask, already_deleted, .init=reader_init, .fini=reader_fini) /* Try to read with a deleted reader. */ dds_delete(g_reader); ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -2596,7 +2589,7 @@ CU_Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_take_mask_wl, * invalid. So, don't test that. */ CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); ret = dds_take_mask_wl(g_reader, buf, si, maxs, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -2607,11 +2600,10 @@ CU_TheoryDataPoints(ddsc_take_mask_wl, invalid_readers) = { CU_Theory((dds_entity_t rdr), ddsc_take_mask_wl, invalid_readers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -2624,7 +2616,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_mask_wl, non_readers, .init=reader_init uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_take_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -2636,7 +2628,7 @@ CU_Test(ddsc_take_mask_wl, already_deleted, .init=reader_init, .fini=reader_fini /* Try to read with a deleted reader. */ dds_delete(g_reader); ret = dds_take_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/reader_iterator.c b/src/core/ddsc/tests/reader_iterator.c index c0dbe6a..a714a67 100644 --- a/src/core/ddsc/tests/reader_iterator.c +++ b/src/core/ddsc/tests/reader_iterator.c @@ -360,11 +360,10 @@ CU_TheoryDataPoints(ddsc_read_next, invalid_readers) = { }; CU_Theory((dds_entity_t rdr), ddsc_read_next, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_next(rdr, g_samples, g_info); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -376,7 +375,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_next, non_readers, .init=reader_iterato { dds_return_t ret; ret = dds_read_next(*rdr, g_samples, g_info); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -390,7 +389,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_next, already_deleted, .init=reader_ite ret = dds_delete(*rdr); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_read_next(*rdr, g_samples, g_info); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -405,7 +404,7 @@ CU_Theory((void **buf, dds_sample_info_t *si), ddsc_read_next, invalid_buffers, dds_return_t ret; if ((buf != g_samples || si != g_info) && (buf != g_loans)) { ret = dds_read_next(g_reader, buf, si); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } else { CU_PASS("Skipped"); } @@ -476,11 +475,10 @@ CU_TheoryDataPoints(ddsc_read_next_wl, invalid_readers) = { }; CU_Theory((dds_entity_t rdr), ddsc_read_next_wl, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_next_wl(rdr, g_loans, g_info); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -492,7 +490,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_next_wl, non_readers, .init=reader_iter { dds_return_t ret; ret = dds_read_next_wl(*rdr, g_loans, g_info); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -506,7 +504,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_read_next_wl, already_deleted, .init=reader_ ret = dds_delete(*rdr); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_read_next_wl(*rdr, g_loans, g_info); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -521,7 +519,7 @@ CU_Theory((void **buf, dds_sample_info_t *si), ddsc_read_next_wl, invalid_buffer dds_return_t ret; if (buf != g_loans || si != g_info) { ret = dds_read_next_wl(g_reader, buf, si); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } else { CU_PASS("Skipped"); } @@ -586,11 +584,10 @@ CU_TheoryDataPoints(ddsc_take_next, invalid_readers) = { }; CU_Theory((dds_entity_t rdr), ddsc_take_next, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_next(rdr, g_samples, g_info); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -602,7 +599,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_next, non_readers, .init=reader_iterato { dds_return_t ret; ret = dds_take_next(*rdr, g_samples, g_info); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -616,7 +613,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_next, already_deleted, .init=reader_ite ret = dds_delete(*rdr); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_take_next(*rdr, g_samples, g_info); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -631,7 +628,7 @@ CU_Theory((void **buf, dds_sample_info_t *si), ddsc_take_next, invalid_buffers, dds_return_t ret; if ((buf != g_samples || si != g_info) && (buf != g_loans)) { ret = dds_take_next(g_reader, buf, si); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } else { CU_PASS("Skipped"); } @@ -699,11 +696,10 @@ CU_TheoryDataPoints(ddsc_take_next_wl, invalid_readers) = { }; CU_Theory((dds_entity_t rdr), ddsc_take_next_wl, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_next_wl(rdr, g_loans, g_info); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -715,7 +711,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_next_wl, non_readers, .init=reader_iter { dds_return_t ret; ret = dds_take_next_wl(*rdr, g_loans, g_info); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -729,7 +725,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_next_wl, already_deleted, .init=reader_ ret = dds_delete(*rdr); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_take_next_wl(*rdr, g_loans, g_info); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -743,7 +739,7 @@ CU_Theory((void **buf, dds_sample_info_t *si), ddsc_take_next_wl, invalid_buffer dds_return_t ret; if (buf != g_loans || si != g_info) { ret = dds_take_next_wl(g_reader, buf, si); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } else { CU_PASS("Skipped"); } diff --git a/src/core/ddsc/tests/register.c b/src/core/ddsc/tests/register.c index 11249dd..b04d35f 100644 --- a/src/core/ddsc/tests/register.c +++ b/src/core/ddsc/tests/register.c @@ -150,7 +150,7 @@ CU_Test(ddsc_register_instance, deleted_entity, .init=registering_init, .fini=re dds_instance_handle_t handle; dds_delete(g_writer); ret = dds_register_instance(g_writer, &handle, g_data); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } static dds_instance_handle_t hndle = 0; @@ -169,7 +169,7 @@ CU_Theory((dds_instance_handle_t *hndl2, void *datap), ddsc_register_instance, i DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_register_instance(g_writer, hndl2, datap); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_TheoryDataPoints(ddsc_register_instance, invalid_writers) = { @@ -177,12 +177,11 @@ CU_TheoryDataPoints(ddsc_register_instance, invalid_writers) = { }; CU_Theory((dds_entity_t writer), ddsc_register_instance, invalid_writers, .init=registering_init, .fini=registering_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; dds_instance_handle_t handle; ret = dds_register_instance(writer, &handle, g_data); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } CU_TheoryDataPoints(ddsc_register_instance, non_writers) = { @@ -193,7 +192,7 @@ CU_Theory((dds_entity_t *writer), ddsc_register_instance, non_writers, .init=reg dds_return_t ret; dds_instance_handle_t handle; ret = dds_register_instance(*writer, &handle, g_data); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } CU_Test(ddsc_register_instance, registering_new_instance, .init=registering_init, .fini=registering_fini) diff --git a/src/core/ddsc/tests/return_loan.c b/src/core/ddsc/tests/return_loan.c index 365ea76..4ff1fcc 100644 --- a/src/core/ddsc/tests/return_loan.c +++ b/src/core/ddsc/tests/return_loan.c @@ -36,7 +36,7 @@ void delete_entities(void) { dds_return_t result; result = dds_delete(participant); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(result), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(result, DDS_RETCODE_OK); dds_delete(read_condition); } @@ -86,7 +86,7 @@ CU_Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = de void **buf = NULL; result = dds_return_loan(reader, NULL, 0); - CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL(result, DDS_RETCODE_BAD_PARAMETER); #ifdef _MSC_VER #pragma warning(push) @@ -96,7 +96,7 @@ CU_Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = de #ifdef _MSC_VER #pragma warning(pop) #endif - CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL(result, DDS_RETCODE_BAD_PARAMETER); buf = create_loan_buf(10, false); #ifdef _MSC_VER @@ -107,10 +107,10 @@ CU_Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = de #ifdef _MSC_VER #pragma warning(pop) #endif - CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL(result, DDS_RETCODE_BAD_PARAMETER); result = dds_return_loan(participant, buf, 0); - CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL(result, DDS_RETCODE_ILLEGAL_OPERATION); delete_loan_buf(buf, 10, false); } @@ -124,17 +124,17 @@ CU_Test(ddsc_reader, return_loan_success, .init = create_entities, .fini = delet buf = create_loan_buf(10, false); result = dds_return_loan(reader, buf, 10); - CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK); + CU_ASSERT_EQUAL(result, DDS_RETCODE_OK); result = dds_return_loan(reader, &buf2, 0); - CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK); + CU_ASSERT_EQUAL(result, DDS_RETCODE_OK); delete_loan_buf(buf, 10, true); buf = create_loan_buf(10, false); result = dds_return_loan(read_condition, buf, 10); - CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK); + CU_ASSERT_EQUAL(result, DDS_RETCODE_OK); result = dds_return_loan(read_condition, &buf2, 0); - CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK); + CU_ASSERT_EQUAL(result, DDS_RETCODE_OK); delete_loan_buf(buf, 10, true); } diff --git a/src/core/ddsc/tests/subscriber.c b/src/core/ddsc/tests/subscriber.c index 7e881d1..cc9144a 100644 --- a/src/core/ddsc/tests/subscriber.c +++ b/src/core/ddsc/tests/subscriber.c @@ -48,7 +48,7 @@ CU_Test(ddsc_subscriber, notify_readers) { /* todo implement tests */ ret = dds_notify_readers(subscriber); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_UNSUPPORTED); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_UNSUPPORTED); dds_delete(subscriber); dds_delete(participant); @@ -67,7 +67,7 @@ CU_Test(ddsc_subscriber, create) { /*** Verify participant parameter ***/ subscriber = dds_create_subscriber(0, NULL, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(subscriber, DDS_RETCODE_BAD_PARAMETER); subscriber = dds_create_subscriber(participant, NULL, NULL); CU_ASSERT_FATAL(subscriber > 0); @@ -91,7 +91,7 @@ CU_Test(ddsc_subscriber, create) { sqos = dds_create_qos(); dds_qset_presentation(sqos, 123, 1, 1); /* Set invalid presentation policy */ subscriber = dds_create_subscriber(participant, sqos, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), DDS_RETCODE_INCONSISTENT_POLICY); + CU_ASSERT_EQUAL_FATAL(subscriber, DDS_RETCODE_INCONSISTENT_POLICY); dds_delete_qos(sqos); /*** Verify listener parameter ***/ diff --git a/src/core/ddsc/tests/take_instance.c b/src/core/ddsc/tests/take_instance.c index 6fba4a6..e8cba48 100644 --- a/src/core/ddsc/tests/take_instance.c +++ b/src/core/ddsc/tests/take_instance.c @@ -299,7 +299,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, u * However, that's not the case yet. So don't test it. */ if (buf != g_loans) { ret = dds_take_instance(*ent, buf, si, bufsz, maxs, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } else { CU_PASS("Skipped"); } @@ -320,7 +320,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs), * invalid and neither is the handle. So, don't test that. */ CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); ret = dds_take_instance_wl(*ent, buf, si, maxs, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -347,7 +347,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, u * However, that's not the case yet. So don't test it. */ if (buf != g_loans) { ret = dds_take_instance_mask(*ent, buf, si, bufsz, maxs, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } else { CU_PASS("Skipped"); } @@ -369,7 +369,7 @@ CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs), * invalid and neither is the handle. So, don't test that. */ CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); ret = dds_take_instance_mask_wl(*ent, buf, si, maxs, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -391,7 +391,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance, in { dds_return_t ret; ret = dds_take_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -404,7 +404,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance_wl, { dds_return_t ret; ret = dds_take_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -418,7 +418,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance_mas uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_take_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -432,7 +432,7 @@ CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance_mas uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_take_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -451,11 +451,10 @@ CU_TheoryDataPoints(ddsc_take_instance, invalid_readers) = { }; CU_Theory((dds_entity_t rdr), ddsc_take_instance, invalid_readers, .init=take_instance_init, .fini=take_instance_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_instance(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -465,11 +464,10 @@ CU_TheoryDataPoints(ddsc_take_instance_wl, invalid_readers) = { }; CU_Theory((dds_entity_t rdr), ddsc_take_instance_wl, invalid_readers, .init=take_instance_init, .fini=take_instance_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_instance_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -480,11 +478,10 @@ CU_TheoryDataPoints(ddsc_take_instance_mask, invalid_readers) = { CU_Theory((dds_entity_t rdr), ddsc_take_instance_mask, invalid_readers, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_instance_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -495,11 +492,10 @@ CU_TheoryDataPoints(ddsc_take_instance_mask_wl, invalid_readers) = { CU_Theory((dds_entity_t rdr), ddsc_take_instance_mask_wl, invalid_readers, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_instance_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -521,7 +517,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance, non_readers, .init=take_insta { dds_return_t ret; ret = dds_take_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -533,7 +529,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance_wl, non_readers, .init=take_in { dds_return_t ret; ret = dds_take_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -546,7 +542,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance_mask, non_readers, .init=take_ uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_take_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -559,7 +555,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance_mask_wl, non_readers, .init=ta uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_take_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -583,7 +579,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance, already_deleted, .init=take_i ret = dds_delete(*rdr); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_take_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -597,7 +593,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance_wl, already_deleted, .init=tak ret = dds_delete(*rdr); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_take_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -612,7 +608,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance_mask, already_deleted, .init=t ret = dds_delete(*rdr); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_take_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -627,7 +623,7 @@ CU_Theory((dds_entity_t *rdr), ddsc_take_instance_mask_wl, already_deleted, .ini ret = dds_delete(*rdr); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_take_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/topic.c b/src/core/ddsc/tests/topic.c index 43dde13..085926b 100644 --- a/src/core/ddsc/tests/topic.c +++ b/src/core/ddsc/tests/topic.c @@ -108,7 +108,7 @@ CU_Test(ddsc_topic_create, invalid_qos, .init=ddsc_topic_init, .fini=ddsc_topic_ dds_qset_lifespan(qos, DDS_SECS(-1)); DDSRT_WARNING_MSVC_OFF(28020); topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, "inconsistent", qos, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_INCONSISTENT_POLICY); + CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_INCONSISTENT_POLICY); dds_delete_qos(qos); } /*************************************************************************************************/ @@ -118,7 +118,7 @@ CU_Test(ddsc_topic_create, non_participants, .init=ddsc_topic_init, .fini=ddsc_t { dds_entity_t topic; topic = dds_create_topic(g_topicRtmDataType, &RoundTripModule_DataType_desc, "non_participant", NULL, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -141,7 +141,7 @@ CU_Test(ddsc_topic_create, same_name, .init=ddsc_topic_init, .fini=ddsc_topic_fi dds_entity_t topic; /* Creating the different topic with same name should fail. */ topic = dds_create_topic(g_participant, &RoundTripModule_Address_desc, g_topicRtmDataTypeName, NULL, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -169,7 +169,7 @@ CU_Test(ddsc_topic_create, desc_null, .init=ddsc_topic_init, .fini=ddsc_topic_fi DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ topic = dds_create_topic (g_participant, NULL, "desc_null", NULL, NULL); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -183,7 +183,7 @@ CU_Theory((char *name), ddsc_topic_create, invalid_names, .init=ddsc_topic_init, { dds_entity_t topic; topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, name, NULL, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -213,7 +213,7 @@ CU_Test(ddsc_topic_find, non_participants, .init=ddsc_topic_init, .fini=ddsc_top { dds_entity_t topic; topic = dds_find_topic(g_topicRtmDataType, "non_participant"); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -224,7 +224,7 @@ CU_Test(ddsc_topic_find, null, .init=ddsc_topic_init, .fini=ddsc_topic_fini) DDSRT_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ topic = dds_find_topic(g_participant, NULL); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -233,7 +233,7 @@ CU_Test(ddsc_topic_find, unknown, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_entity_t topic; topic = dds_find_topic(g_participant, "unknown"); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -243,7 +243,7 @@ CU_Test(ddsc_topic_find, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini) dds_entity_t topic; dds_delete(g_topicRtmDataType); topic = dds_find_topic(g_participant, g_topicRtmDataTypeName); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(topic, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -289,7 +289,7 @@ CU_Test(ddsc_topic_get_name, non_topic, .init=ddsc_topic_init, .fini=ddsc_topic_ char name[MAX_NAME_SIZE]; dds_return_t ret; ret = dds_get_name(g_participant, name, MAX_NAME_SIZE); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -303,7 +303,7 @@ CU_Theory((char *name, size_t size), ddsc_topic_get_name, invalid_params, .init= dds_return_t ret; CU_ASSERT_FATAL((name != g_nameBuffer) || (size != MAX_NAME_SIZE)); ret = dds_get_name(g_topicRtmDataType, name, size); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -314,7 +314,7 @@ CU_Test(ddsc_topic_get_name, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fi dds_return_t ret; dds_delete(g_topicRtmDataType); ret = dds_get_name(g_topicRtmDataType, name, MAX_NAME_SIZE); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -362,7 +362,7 @@ CU_Test(ddsc_topic_get_type_name, non_topic, .init=ddsc_topic_init, .fini=ddsc_t char name[MAX_NAME_SIZE]; dds_return_t ret; ret = dds_get_type_name(g_participant, name, MAX_NAME_SIZE); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -376,7 +376,7 @@ CU_Theory((char *name, size_t size), ddsc_topic_get_type_name, invalid_params, . dds_return_t ret; CU_ASSERT_FATAL((name != g_nameBuffer) || (size != MAX_NAME_SIZE)); ret = dds_get_type_name(g_topicRtmDataType, name, size); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -387,7 +387,7 @@ CU_Test(ddsc_topic_get_type_name, deleted, .init=ddsc_topic_init, .fini=ddsc_top dds_return_t ret; dds_delete(g_topicRtmDataType); ret = dds_get_type_name(g_topicRtmDataType, name, MAX_NAME_SIZE); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -405,7 +405,7 @@ CU_Test(ddsc_topic_set_qos, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini) /* Latency is the only one allowed to change. */ dds_qset_latency_budget(g_qos, DDS_SECS(1)); ret = dds_set_qos(g_topicRtmDataType, g_qos); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_UNSUPPORTED); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_UNSUPPORTED); } /*************************************************************************************************/ @@ -417,7 +417,7 @@ CU_Test(ddsc_topic_set_qos, inconsistent, .init=ddsc_topic_init, .fini=ddsc_topi dds_qset_lifespan(g_qos, DDS_SECS(-1)); DDSRT_WARNING_MSVC_ON(28020); ret = dds_set_qos(g_topicRtmDataType, g_qos); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_INCONSISTENT_POLICY); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_INCONSISTENT_POLICY); } /*************************************************************************************************/ @@ -427,6 +427,6 @@ CU_Test(ddsc_topic_set_qos, immutable, .init=ddsc_topic_init, .fini=ddsc_topic_f dds_return_t ret; dds_qset_destination_order(g_qos, DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP); /* Immutable */ ret = dds_set_qos(g_topicRtmDataType, g_qos); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_IMMUTABLE_POLICY); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_IMMUTABLE_POLICY); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/types.c b/src/core/ddsc/tests/types.c index a2f6c28..427fe53 100644 --- a/src/core/ddsc/tests/types.c +++ b/src/core/ddsc/tests/types.c @@ -30,7 +30,7 @@ CU_ASSERT_FATAL(wri > 0); \ \ status = dds_write(wri, &data); \ - CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK); \ + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); \ \ dds_delete(wri); \ dds_delete(top); \ @@ -114,7 +114,7 @@ CU_Test(ddsc_types, alltypeskey) CU_ASSERT_FATAL(wri > 0); status = dds_write(wri, &atk_data); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); dds_delete(wri); dds_delete(top); diff --git a/src/core/ddsc/tests/unregister.c b/src/core/ddsc/tests/unregister.c index b7b03d5..538c661 100644 --- a/src/core/ddsc/tests/unregister.c +++ b/src/core/ddsc/tests/unregister.c @@ -152,7 +152,7 @@ CU_Test(ddsc_unregister_instance, deleted, .init=unregistering_init, .fini=unreg dds_delete(g_writer); ret = dds_unregister_instance(g_writer, g_data); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -161,7 +161,7 @@ CU_Test(ddsc_unregister_instance, null, .init=unregistering_init, .fini=unregist { dds_return_t ret; ret = dds_unregister_instance(g_writer, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -171,11 +171,10 @@ CU_TheoryDataPoints(ddsc_unregister_instance, invalid_writers) = { }; CU_Theory((dds_entity_t writer), ddsc_unregister_instance, invalid_writers, .init=unregistering_init, .fini=unregistering_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_unregister_instance(writer, g_data); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -187,7 +186,7 @@ CU_Theory((dds_entity_t *writer), ddsc_unregister_instance, non_writers, .init=u { dds_return_t ret; ret = dds_unregister_instance(*writer, g_data); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -246,7 +245,7 @@ CU_Test(ddsc_unregister_instance_ts, deleted, .init=unregistering_init, .fini=un dds_return_t ret; dds_delete(g_writer); ret = dds_unregister_instance_ts(g_writer, g_data, g_present); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -255,7 +254,7 @@ CU_Test(ddsc_unregister_instance_ts, null, .init=unregistering_init, .fini=unreg { dds_return_t ret; ret = dds_unregister_instance_ts(g_writer, NULL, g_present); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -265,11 +264,10 @@ CU_TheoryDataPoints(ddsc_unregister_instance_ts, invalid_writers) = { }; CU_Theory((dds_entity_t writer), ddsc_unregister_instance_ts, invalid_writers, .init=unregistering_init, .fini=unregistering_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_unregister_instance_ts(writer, g_data, g_present); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -281,7 +279,7 @@ CU_Theory((dds_entity_t *writer), ddsc_unregister_instance_ts, non_writers, .ini { dds_return_t ret; ret = dds_unregister_instance_ts(*writer, g_data, g_present); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -383,7 +381,7 @@ CU_Test(ddsc_unregister_instance_ih, deleted, .init=unregistering_init, .fini=un dds_return_t ret; dds_delete(g_writer); ret = dds_unregister_instance_ih(g_writer, DDS_HANDLE_NIL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -395,7 +393,7 @@ CU_Theory((dds_instance_handle_t handle), ddsc_unregister_instance_ih, invalid_h { dds_return_t ret; ret = dds_unregister_instance_ih(g_writer, handle); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -405,11 +403,10 @@ CU_TheoryDataPoints(ddsc_unregister_instance_ih, invalid_writers) = { }; CU_Theory((dds_entity_t writer), ddsc_unregister_instance_ih, invalid_writers, .init=unregistering_init, .fini=unregistering_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_unregister_instance_ih(writer, DDS_HANDLE_NIL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -421,7 +418,7 @@ CU_Theory((dds_entity_t *writer), ddsc_unregister_instance_ih, non_writers, .ini { dds_return_t ret; ret = dds_unregister_instance_ih(*writer, DDS_HANDLE_NIL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -481,7 +478,7 @@ CU_Test(ddsc_unregister_instance_ih_ts, deleted, .init=unregistering_init, .fini dds_return_t ret; dds_delete(g_writer); ret = dds_unregister_instance_ih_ts(g_writer, DDS_HANDLE_NIL, g_present); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -493,7 +490,7 @@ CU_Theory((dds_instance_handle_t handle), ddsc_unregister_instance_ih_ts, invali { dds_return_t ret; ret = dds_unregister_instance_ih_ts(g_writer, handle, g_present); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -503,11 +500,10 @@ CU_TheoryDataPoints(ddsc_unregister_instance_ih_ts, invalid_writers) = { }; CU_Theory((dds_entity_t writer), ddsc_unregister_instance_ih_ts, invalid_writers, .init=unregistering_init, .fini=unregistering_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_unregister_instance_ih_ts(writer, DDS_HANDLE_NIL, g_present); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -519,7 +515,7 @@ CU_Theory((dds_entity_t *writer), ddsc_unregister_instance_ih_ts, non_writers, . { dds_return_t ret; ret = dds_unregister_instance_ih_ts(*writer, DDS_HANDLE_NIL, g_present); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/unsupported.c b/src/core/ddsc/tests/unsupported.c index 68bf4a5..279e8cd 100644 --- a/src/core/ddsc/tests/unsupported.c +++ b/src/core/ddsc/tests/unsupported.c @@ -78,9 +78,9 @@ CU_Test(ddsc_unsupported, dds_begin_end_coherent, .init = setup, .fini = teardow for (int i=0; i < 5; i++) { result = dds_begin_coherent(e[pars[i].index]); - CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res); + CU_ASSERT_EQUAL(result, pars[i].exp_res); result = dds_end_coherent(e[pars[i].index]); - CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res); + CU_ASSERT_EQUAL(result, pars[i].exp_res); } } @@ -95,7 +95,7 @@ CU_Test(ddsc_unsupported, dds_wait_for_acks, .init = setup, .fini = teardown) for (int i=0; i< 3; i++) { result = dds_wait_for_acks(e[pars[i].index], 0); - CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res); + CU_ASSERT_EQUAL(result, pars[i].exp_res); } } @@ -110,9 +110,9 @@ CU_Test(ddsc_unsupported, dds_suspend_resume, .init = setup, .fini = teardown) for (int i=0; i< 3; i++) { result = dds_suspend(e[pars[i].index]); - CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res); + CU_ASSERT_EQUAL(result, pars[i].exp_res); result = dds_resume(e[pars[i].index]); - CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res); + CU_ASSERT_EQUAL(result, pars[i].exp_res); } } @@ -130,7 +130,7 @@ CU_Test(ddsc_unsupported, dds_get_instance_handle, .init = setup, .fini = teardo for (int i=0; i < 5; i++) { result = dds_get_instance_handle(e[pars[i].index], &ih); - CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res); + CU_ASSERT_EQUAL(result, pars[i].exp_res); } } @@ -152,7 +152,7 @@ CU_Test(ddsc_unsupported, dds_set_qos, .init = setup, .fini = teardown) qos = dds_create_qos(); for (int i=0; i < 8;i++) { result = dds_set_qos(e[pars[i].index], qos); - CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res); + CU_ASSERT_EQUAL(result, pars[i].exp_res); } dds_delete_qos(qos); } diff --git a/src/core/ddsc/tests/waitset.c b/src/core/ddsc/tests/waitset.c index 9c401cb..cffa069 100644 --- a/src/core/ddsc/tests/waitset.c +++ b/src/core/ddsc/tests/waitset.c @@ -226,7 +226,7 @@ CU_Test(ddsc_waitset_create, deleted_participant, .init=ddsc_waitset_basic_init, deleted = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); dds_delete(deleted); ws = dds_create_waitset(deleted); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ws), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ws, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -236,11 +236,10 @@ CU_TheoryDataPoints(ddsc_waitset_create, invalid_params) = { }; CU_Theory((dds_entity_t par), ddsc_waitset_create, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { - dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t ws; ws = dds_create_waitset(par); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ws), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ws, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -252,7 +251,7 @@ CU_Theory((dds_entity_t *par), ddsc_waitset_create, non_participants, .init=ddsc { dds_entity_t ws; ws = dds_create_waitset(*par); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ws), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ws, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -276,7 +275,7 @@ CU_Theory((dds_entity_t e, dds_attach_t a), ddsc_waitset_attach, invalid_params, { dds_return_t ret; ret = dds_waitset_attach(waitset, e, a); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -287,11 +286,10 @@ CU_TheoryDataPoints(ddsc_waitset_attach, invalid_waitsets) = { }; CU_Theory((dds_entity_t ws, dds_attach_t a), ddsc_waitset_attach, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { - dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_waitset_attach(ws, participant, a); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -305,7 +303,7 @@ CU_Theory((dds_entity_t *ws, dds_entity_t *e, dds_attach_t a), ddsc_waitset_atta { dds_return_t ret; ret = dds_waitset_attach(*ws, *e, a); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -315,7 +313,7 @@ CU_Test(ddsc_waitset_attach, deleted_waitset, .init=ddsc_waitset_basic_init, .fi dds_return_t ret; dds_delete(waitset); ret = dds_waitset_attach(waitset, participant, 0); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -347,7 +345,7 @@ CU_Theory((dds_entity_t *ws, dds_entity_t *e, dds_attach_t a), ddsc_waitset_atta /* Try to attach. */ ret = dds_waitset_attach(*ws, *e, a); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), exp); + CU_ASSERT_EQUAL_FATAL(ret, exp); /* Detach when needed. */ if (ret == DDS_RETCODE_OK) { @@ -366,13 +364,13 @@ CU_Test(ddsc_waitset_attach_detach, second, .init=ddsc_waitset_basic_init, .fini CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(waitset, waitset, 0); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); ret = dds_waitset_detach(waitset, waitset); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_detach(waitset, waitset); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -399,7 +397,7 @@ CU_Theory((dds_entity_t e), ddsc_waitset_detach, invalid_params, .init=ddsc_wait { dds_return_t ret; ret = dds_waitset_detach(waitset, e); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -409,11 +407,10 @@ CU_TheoryDataPoints(ddsc_waitset_detach, invalid_waitsets) = { }; CU_Theory((dds_entity_t ws), ddsc_waitset_detach, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { - dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_waitset_detach(ws, participant); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -436,7 +433,7 @@ CU_Theory((dds_entity_t *ws, dds_entity_t *e), ddsc_waitset_detach, valid_entiti } ret = dds_waitset_detach(*ws, *e); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), exp); + CU_ASSERT_EQUAL_FATAL(ret, exp); } /*************************************************************************************************/ @@ -580,7 +577,7 @@ CU_Test(ddsc_waitset_set_trigger, deleted_waitset, .init=ddsc_waitset_basic_init dds_return_t ret; dds_delete(waitset); ret = dds_waitset_set_trigger(waitset, true); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -590,11 +587,10 @@ CU_TheoryDataPoints(ddsc_waitset_set_trigger, invalid_params) = { }; CU_Theory((dds_entity_t ws), ddsc_waitset_set_trigger, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { - dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_waitset_set_trigger(ws, true); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -606,7 +602,7 @@ CU_Theory((dds_entity_t *ws), ddsc_waitset_set_trigger, non_waitsets, .init=ddsc { dds_return_t ret; ret = dds_waitset_set_trigger(*ws, true); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -625,7 +621,7 @@ CU_Test(ddsc_waitset_wait, deleted_waitset, .init=ddsc_waitset_attached_init, .f dds_return_t ret; dds_delete(waitset); ret = dds_waitset_wait(waitset, &triggered, 1, DDS_SECS(1)); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -636,11 +632,10 @@ CU_TheoryDataPoints(ddsc_waitset_wait, invalid_waitsets) = { CU_Theory((dds_entity_t ws), ddsc_waitset_wait, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_attach_t triggered; - dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_waitset_wait(ws, &triggered, 1, DDS_SECS(1)); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -653,7 +648,7 @@ CU_Theory((dds_entity_t *ws), ddsc_waitset_wait, non_waitsets, .init=ddsc_waitse dds_attach_t triggered; dds_return_t ret; ret = dds_waitset_wait(*ws, &triggered, 1, DDS_SECS(1)); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -672,7 +667,7 @@ CU_Theory((dds_attach_t *a, size_t size, int msec), ddsc_waitset_wait, invalid_p CU_ASSERT_FATAL(((a == NULL) && (size != 0)) || ((a != NULL) && (size == 0)) || (msec < 0)); ret = dds_waitset_wait(waitset, a, size, DDS_MSECS(msec)); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -683,7 +678,7 @@ CU_Test(ddsc_waitset_wait_until, deleted_waitset, .init=ddsc_waitset_attached_in dds_return_t ret; dds_delete(waitset); ret = dds_waitset_wait_until(waitset, &triggered, 1, dds_time()); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -694,11 +689,10 @@ CU_TheoryDataPoints(ddsc_waitset_wait_until, invalid_waitsets) = { CU_Theory((dds_entity_t ws), ddsc_waitset_wait_until, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_attach_t triggered; - dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_waitset_wait_until(ws, &triggered, 1, dds_time()); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -711,7 +705,7 @@ CU_Theory((dds_entity_t *ws), ddsc_waitset_wait_until, non_waitsets, .init=ddsc_ dds_attach_t triggered; dds_return_t ret; ret = dds_waitset_wait_until(*ws, &triggered, 1, dds_time()); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -729,7 +723,7 @@ CU_Theory((dds_attach_t *a, size_t size), ddsc_waitset_wait_until, invalid_param CU_ASSERT_FATAL(((a == NULL) && (size != 0)) || ((a != NULL) && (size == 0))); ret = dds_waitset_wait_until(waitset, a, size, dds_time()); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -843,7 +837,7 @@ CU_Test(ddsc_waitset_get_entities, deleted_waitset, .init=ddsc_waitset_attached_ dds_entity_t entities[MAX_ENTITIES_CNT]; dds_delete(waitset); ret = dds_waitset_get_entities(waitset, entities, MAX_ENTITIES_CNT); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -853,12 +847,11 @@ CU_TheoryDataPoints(ddsc_waitset_get_entities, invalid_params) = { }; CU_Theory((dds_entity_t ws), ddsc_waitset_get_entities, invalid_params, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) { - dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t entities[MAX_ENTITIES_CNT]; dds_return_t ret; ret = dds_waitset_get_entities(ws, entities, MAX_ENTITIES_CNT); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -871,7 +864,7 @@ CU_Theory((dds_entity_t *ws), ddsc_waitset_get_entities, non_waitsets, .init=dds dds_entity_t entities[MAX_ENTITIES_CNT]; dds_return_t ret; ret = dds_waitset_get_entities(*ws, entities, MAX_ENTITIES_CNT); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -1073,7 +1066,7 @@ waiting_thread(void *a) return 0; } -static dds_retcode_t +static dds_return_t thread_reached_state(thread_state_t *actual, thread_state_t expected, int32_t msec) { /* Convenience function. */ @@ -1090,7 +1083,7 @@ waiting_thread_start(struct thread_arg_t *arg, dds_entity_t expected) { ddsrt_thread_t thread_id; ddsrt_threadattr_t thread_attr; - dds_retcode_t rc; + dds_return_t rc; assert(arg); @@ -1115,7 +1108,7 @@ waiting_thread_start(struct thread_arg_t *arg, dds_entity_t expected) static dds_return_t waiting_thread_expect_exit(struct thread_arg_t *arg) { - dds_retcode_t rc; + dds_return_t rc; assert(arg); rc = thread_reached_state(&(arg->state), STOPPED, 5000); if (rc == DDS_RETCODE_OK) { diff --git a/src/core/ddsc/tests/write.c b/src/core/ddsc/tests/write.c index 2cd3f15..b5523ce 100644 --- a/src/core/ddsc/tests/write.c +++ b/src/core/ddsc/tests/write.c @@ -65,7 +65,7 @@ CU_Test(ddsc_write, basic, .init = setup, .fini = teardown) dds_return_t status; status = dds_write(writer, &data); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); } CU_Test(ddsc_write, null_writer, .init = setup, .fini = teardown) @@ -76,7 +76,7 @@ CU_Test(ddsc_write, null_writer, .init = setup, .fini = teardown) DDSRT_WARNING_MSVC_OFF(28020); status = dds_write(0, &data); DDSRT_WARNING_MSVC_ON(28020); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_write, bad_writer, .init = setup, .fini = teardown) @@ -84,7 +84,7 @@ CU_Test(ddsc_write, bad_writer, .init = setup, .fini = teardown) dds_return_t status; status = dds_write(publisher, &data); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_ILLEGAL_OPERATION); } CU_Test(ddsc_write, closed_writer, .init = setup, .fini = teardown) @@ -92,10 +92,10 @@ CU_Test(ddsc_write, closed_writer, .init = setup, .fini = teardown) dds_return_t status; status = dds_delete(writer); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); status = dds_write(writer, &data); writer = 0; - CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_write, null_sample, .init = setup, .fini = teardown) @@ -107,7 +107,7 @@ CU_Test(ddsc_write, null_sample, .init = setup, .fini = teardown) status = dds_write(writer, NULL); DDSRT_WARNING_MSVC_ON(6387); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_write_ts, basic, .init = setup, .fini = teardown) @@ -115,7 +115,7 @@ CU_Test(ddsc_write_ts, basic, .init = setup, .fini = teardown) dds_return_t status; status = dds_write_ts(writer, &data, dds_time()); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); } CU_Test(ddsc_write_ts, bad_timestamp, .init = setup, .fini = teardown) @@ -123,7 +123,7 @@ CU_Test(ddsc_write_ts, bad_timestamp, .init = setup, .fini = teardown) dds_return_t status; status = dds_write_ts(writer, &data, -1); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_write, simpletypes) @@ -152,7 +152,7 @@ CU_Test(ddsc_write, simpletypes) CU_ASSERT_FATAL(wri > 0); status = dds_write(wri, &st_data); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); dds_delete(wri); dds_delete(top); diff --git a/src/core/ddsc/tests/writer.c b/src/core/ddsc/tests/writer.c index 66ce1ea..4a9a8c2 100644 --- a/src/core/ddsc/tests/writer.c +++ b/src/core/ddsc/tests/writer.c @@ -57,13 +57,13 @@ CU_Test(ddsc_create_writer, null_parent, .init = setup, .fini = teardown) DDSRT_WARNING_MSVC_OFF(28020); /* Disable SAL warning on intentional misuse of the API */ writer = dds_create_writer(0, topic, NULL, NULL); DDSRT_WARNING_MSVC_ON(28020); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(writer, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_create_writer, bad_parent, .init = setup, .fini = teardown) { writer = dds_create_writer(topic, topic, NULL, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(writer, DDS_RETCODE_ILLEGAL_OPERATION); } CU_Test(ddsc_create_writer, participant, .init = setup, .fini = teardown) @@ -83,7 +83,7 @@ CU_Test(ddsc_create_writer, deleted_publisher, .init = setup, .fini = teardown) dds_delete(publisher); writer = dds_create_writer(publisher, topic, NULL, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(writer, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_create_writer, null_topic, .init = setup, .fini = teardown) @@ -91,13 +91,13 @@ CU_Test(ddsc_create_writer, null_topic, .init = setup, .fini = teardown) DDSRT_WARNING_MSVC_OFF(28020); /* Disable SAL warning on intentional misuse of the API */ writer = dds_create_writer(publisher, 0, NULL, NULL); DDSRT_WARNING_MSVC_ON(28020); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(writer, DDS_RETCODE_BAD_PARAMETER); } CU_Test(ddsc_create_writer, bad_topic, .init = setup, .fini = teardown) { writer = dds_create_writer(publisher, publisher, NULL, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(writer, DDS_RETCODE_ILLEGAL_OPERATION); } CU_Test(ddsc_create_writer, deleted_topic, .init = setup, .fini = teardown) @@ -105,5 +105,5 @@ CU_Test(ddsc_create_writer, deleted_topic, .init = setup, .fini = teardown) dds_delete(topic); writer = dds_create_writer(publisher, topic, NULL, NULL); - CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(writer, DDS_RETCODE_BAD_PARAMETER); } diff --git a/src/core/ddsi/CMakeLists.txt b/src/core/ddsi/CMakeLists.txt index 4a6bb0f..70c2837 100644 --- a/src/core/ddsi/CMakeLists.txt +++ b/src/core/ddsi/CMakeLists.txt @@ -86,7 +86,6 @@ PREPEND(hdrs_private_ddsi "${CMAKE_CURRENT_LIST_DIR}/include/dds/ddsi" q_debmon.h q_entity.h q_ephash.h - q_error.h q_feature_check.h q_freelist.h q_gc.h diff --git a/src/core/ddsi/include/dds/ddsi/ddsi_tcp.h b/src/core/ddsi/include/dds/ddsi/ddsi_tcp.h index 380dac3..c1b8f42 100644 --- a/src/core/ddsi/include/dds/ddsi/ddsi_tcp.h +++ b/src/core/ddsi/include/dds/ddsi/ddsi_tcp.h @@ -28,8 +28,8 @@ struct ddsi_ssl_plugins void (*fini) (void); void (*ssl_free) (SSL *ssl); void (*bio_vfree) (BIO *bio); - ssize_t (*read) (SSL *ssl, void *buf, size_t len, dds_retcode_t *err); - ssize_t (*write) (SSL *ssl, const void *msg, 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_return_t *err); SSL * (*connect) (ddsrt_socket_t sock); BIO * (*listen) (ddsrt_socket_t sock); SSL * (*accept) (BIO *bio, ddsrt_socket_t *sock); diff --git a/src/core/ddsi/include/dds/ddsi/ddsi_threadmon.h b/src/core/ddsi/include/dds/ddsi/ddsi_threadmon.h index 7d9d346..4a967f5 100644 --- a/src/core/ddsi/include/dds/ddsi/ddsi_threadmon.h +++ b/src/core/ddsi/include/dds/ddsi/ddsi_threadmon.h @@ -19,7 +19,7 @@ extern "C" { struct ddsi_threadmon; 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_free (struct ddsi_threadmon *sl); void ddsi_threadmon_statechange_barrier (struct ddsi_threadmon *sl); diff --git a/src/core/ddsi/include/dds/ddsi/q_entity.h b/src/core/ddsi/include/dds/ddsi/q_entity.h index 603b88f..5836165 100644 --- a/src/core/ddsi/include/dds/ddsi/q_entity.h +++ b/src/core/ddsi/include/dds/ddsi/q_entity.h @@ -400,9 +400,6 @@ int is_writer_entityid (nn_entityid_t id); int is_reader_entityid (nn_entityid_t id); 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 entities. These all return 0 iff successful. All GIDs supplied __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. */ #define RTPS_PF_ONLY_LOCAL 16u -/* To create a DDSI participant given a GUID. May return ERR_OUT_OF_IDS - (a.o.) */ -int new_participant_guid (const nn_guid_t *ppguid, unsigned flags, const struct nn_plist *plist); +/** + * @brief Create a new participant with a given GUID in the domain. + * + * @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, - which will start doing scary things once all but the DDSI built-in - endpoints are gone. It is acceptable to call delete_participant() - before all its readers and writers have been deleted (which also - fits nicely with model where the glue calls merely schedules - garbage-collection). */ -int delete_participant (const struct nn_guid *ppguid); +/** + * @brief Initiate the deletion of the participant: + * - dispose/unregister built-in topic + * - list it as one of the recently deleted participants + * - remote it from the GUID hash tables + * - schedule the scare stuff to really delete it via the GC + * + * 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, 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 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_state; diff --git a/src/core/ddsi/include/dds/ddsi/q_error.h b/src/core/ddsi/include/dds/ddsi/q_error.h deleted file mode 100644 index 8c4f840..0000000 --- a/src/core/ddsi/include/dds/ddsi/q_error.h +++ /dev/null @@ -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 */ diff --git a/src/core/ddsi/include/dds/ddsi/q_plist.h b/src/core/ddsi/include/dds/ddsi/q_plist.h index 6481caa..639401f 100644 --- a/src/core/ddsi/include/dds/ddsi/q_plist.h +++ b/src/core/ddsi/include/dds/ddsi/q_plist.h @@ -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_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 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_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 int 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 int 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 int 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 int 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 int 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 int 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_history_qospolicy (const nn_history_qospolicy_t *q); +DDS_EXPORT dds_return_t validate_durability_qospolicy (const nn_durability_qospolicy_t *q); +DDS_EXPORT dds_return_t validate_resource_limits_qospolicy (const nn_resource_limits_qospolicy_t *q); +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 dds_return_t validate_durability_service_qospolicy (const nn_durability_service_qospolicy_t *q); +DDS_EXPORT dds_return_t validate_liveliness_qospolicy (const nn_liveliness_qospolicy_t *q); +DDS_EXPORT dds_return_t validate_destination_order_qospolicy (const nn_destination_order_qospolicy_t *q); +DDS_EXPORT dds_return_t validate_ownership_qospolicy (const nn_ownership_qospolicy_t *q); +DDS_EXPORT dds_return_t validate_ownership_strength_qospolicy (const nn_ownership_strength_qospolicy_t *q); +DDS_EXPORT dds_return_t validate_presentation_qospolicy (const nn_presentation_qospolicy_t *q); +DDS_EXPORT dds_return_t validate_transport_priority_qospolicy (const nn_transport_priority_qospolicy_t *q); +DDS_EXPORT dds_return_t validate_reader_data_lifecycle (const nn_reader_data_lifecycle_qospolicy_t *q); +DDS_EXPORT dds_return_t validate_duration (const nn_duration_t *d); struct nn_rmsg; diff --git a/src/core/ddsi/include/dds/ddsi/q_thread.h b/src/core/ddsi/include/dds/ddsi/q_thread.h index 4d572d2..230e625 100644 --- a/src/core/ddsi/include/dds/ddsi/q_thread.h +++ b/src/core/ddsi/include/dds/ddsi/q_thread.h @@ -98,9 +98,9 @@ DDS_EXPORT void thread_states_fini (void); DDS_EXPORT void upgrade_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 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 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 reset_thread_state (struct thread_state1 *ts1); DDS_EXPORT int thread_exists (const char *name); diff --git a/src/core/ddsi/include/dds/ddsi/q_transmit.h b/src/core/ddsi/include/dds/ddsi/q_transmit.h index 19cc947..9fc3f2d 100644 --- a/src/core/ddsi/include/dds/ddsi/q_transmit.h +++ b/src/core/ddsi/include/dds/ddsi/q_transmit.h @@ -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); /* 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); void add_Heartbeat (struct nn_xmsg *msg, struct writer *wr, const struct whc_state *whcst, int hbansreq, nn_entityid_t dst, int issync); diff --git a/src/core/ddsi/include/dds/ddsi/q_xevent.h b/src/core/ddsi/include/dds/ddsi/q_xevent.h index ef356f4..4e1513c 100644 --- a/src/core/ddsi/include/dds/ddsi/q_xevent.h +++ b/src/core/ddsi/include/dds/ddsi/q_xevent.h @@ -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 whatever memory is claimed for the argument and call delete_xevent. */ 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 qxev_msg (struct xeventq *evq, struct nn_xmsg *msg); diff --git a/src/core/ddsi/include/dds/ddsi/q_xmsg.h b/src/core/ddsi/include/dds/ddsi/q_xmsg.h index ef634a9..f9abcfa 100644 --- a/src/core/ddsi/include/dds/ddsi/q_xmsg.h +++ b/src/core/ddsi/include/dds/ddsi/q_xmsg.h @@ -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 routine that extracts a suitable address from the proxy reader's address sets and calls setdst1. */ -int 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_setdstPRD (struct nn_xmsg *m, const struct proxy_reader *prd); +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 address set to multicast to all matched readers */ diff --git a/src/core/ddsi/src/ddsi_raweth.c b/src/core/ddsi/src/ddsi_raweth.c index dc409c7..ef63a73 100644 --- a/src/core/ddsi/src/ddsi_raweth.c +++ b/src/core/ddsi/src/ddsi_raweth.c @@ -16,7 +16,6 @@ #include "dds/ddsi/q_nwif.h" #include "dds/ddsi/q_config.h" #include "dds/ddsi/q_log.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsi/q_pcap.h" #include "dds/ddsi/q_globals.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) { - dds_retcode_t rc; + dds_return_t rc; ssize_t ret = 0; struct msghdr msghdr; 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) { ddsi_raweth_conn_t uc = (ddsi_raweth_conn_t) conn; - dds_retcode_t rc; + dds_return_t rc; ssize_t ret; unsigned retry = 2; 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) { ddsrt_socket_t sock; - dds_retcode_t rc; + dds_return_t rc; ddsi_raweth_conn_t uc = NULL; struct sockaddr_ll addr; bool mcast = (bool) (qos ? qos->m_multicast : 0); diff --git a/src/core/ddsi/src/ddsi_ssl.c b/src/core/ddsi/src/ddsi_ssl.c index 2d85f0e..64f8051 100644 --- a/src/core/ddsi/src/ddsi_ssl.c +++ b/src/core/ddsi/src/ddsi_ssl.c @@ -63,7 +63,7 @@ static int ddsi_ssl_verify (int ok, X509_STORE_CTX *store) 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); 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; } -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); diff --git a/src/core/ddsi/src/ddsi_tcp.c b/src/core/ddsi/src/ddsi_tcp.c index 676099c..bc65a40 100644 --- a/src/core/ddsi/src/ddsi_tcp.c +++ b/src/core/ddsi/src/ddsi_tcp.c @@ -150,7 +150,7 @@ static unsigned short get_socket_port (ddsrt_socket_t socket) { struct sockaddr_storage addr; socklen_t addrlen = sizeof (addr); - dds_retcode_t ret; + dds_return_t ret; ret = ddsrt_getsockname(socket, (struct sockaddr *)&addr, &addrlen); 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]; ddsrt_socket_t sock; - dds_retcode_t ret; + dds_return_t ret; ddsi_tcp_sock_new (&sock, 0); 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; } -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; @@ -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 -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); } @@ -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) { - dds_retcode_t rc; + dds_return_t rc; fd_set fds; fd_set * rdset = read ? &fds : NULL; 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) { - dds_retcode_t rc; + dds_return_t rc; 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; 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; } -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; 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 -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); } @@ -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 ( - 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, const void * buf, 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, partial writes and blocking (typically write buffer full) */ - dds_retcode_t rc; + dds_return_t rc; size_t pos = 0; 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 { int sendflags = 0; - dds_retcode_t rc; + dds_return_t rc; #ifdef MSG_NOSIGNAL sendflags |= MSG_NOSIGNAL; #endif @@ -661,7 +661,7 @@ static ssize_t ddsi_tcp_conn_write (ddsi_tran_conn_t base, const nn_locator_t *d 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; #ifdef DDSI_INCLUDE_SSL 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; socklen_t addrlen = sizeof (addr); char buff[DDSI_LOCSTRLEN]; - dds_retcode_t rc = DDS_RETCODE_OK; + dds_return_t rc = DDS_RETCODE_OK; #ifdef DDSI_INCLUDE_SSL SSL * ssl = NULL; #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) { - dds_retcode_t ret; + dds_return_t ret; tl = (ddsi_tcp_listener_t) ddsrt_malloc (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; ddsrt_socket_t sock; - dds_retcode_t ret; + dds_return_t ret; /* Connect to own listener socket to wake listener from blocking 'accept()' */ ddsi_tcp_sock_new (&sock, 0); diff --git a/src/core/ddsi/src/ddsi_threadmon.c b/src/core/ddsi/src/ddsi_threadmon.c index 1f9d4af..d687b9f 100644 --- a/src/core/ddsi/src/ddsi_threadmon.c +++ b/src/core/ddsi/src/ddsi_threadmon.c @@ -21,7 +21,6 @@ #include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_time.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_receive.h" @@ -166,7 +165,7 @@ struct ddsi_threadmon *ddsi_threadmon_new (void) 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); assert (sl->keepgoing == -1); @@ -179,7 +178,7 @@ int ddsi_threadmon_start (struct ddsi_threadmon *sl) fail_thread: sl->keepgoing = -1; - return Q_ERR_UNSPECIFIED; + return DDS_RETCODE_ERROR; } void ddsi_threadmon_statechange_barrier (struct ddsi_threadmon *sl) diff --git a/src/core/ddsi/src/ddsi_udp.c b/src/core/ddsi/src/ddsi_udp.c index e2e1576..85fde82 100644 --- a/src/core/ddsi/src/ddsi_udp.c +++ b/src/core/ddsi/src/ddsi_udp.c @@ -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) { - dds_retcode_t rc; + dds_return_t rc; ssize_t ret = 0; ddsrt_msghdr_t msghdr; 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) { - dds_retcode_t rc; + dds_return_t rc; ssize_t ret = -1; unsigned retry = 2; 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) { - dds_retcode_t ret; + dds_return_t ret; struct sockaddr_storage addr; socklen_t addrlen = sizeof (addr); @@ -282,7 +282,7 @@ static ddsi_tran_conn_t ddsi_udp_create_conn #ifdef DDSI_INCLUDE_NETWORK_CHANNELS 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)); if (rc != DDS_RETCODE_OK) 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) { - dds_retcode_t rc; + dds_return_t rc; struct sockaddr_storage mcip; ddsi_ipaddr_from_loc(&mcip, mcloc); #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 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; ddsi_ipaddr_from_loc(&mcip, mcloc); ddsi_ipaddr_from_loc(&srcip, srcloc); diff --git a/src/core/ddsi/src/q_config.c b/src/core/ddsi/src/q_config.c index 98f030b..383534c 100644 --- a/src/core/ddsi/src/q_config.c +++ b/src/core/ddsi/src/q_config.c @@ -31,7 +31,6 @@ #include "dds/ddsi/q_misc.h" #include "dds/ddsi/q_addrset.h" #include "dds/ddsi/q_nwif.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsrt/xmlparser.h" diff --git a/src/core/ddsi/src/q_ddsi_discovery.c b/src/core/ddsi/src/q_ddsi_discovery.c index 8a75416..654ce2c 100644 --- a/src/core/ddsi/src/q_ddsi_discovery.c +++ b/src/core/ddsi/src/q_ddsi_discovery.c @@ -40,7 +40,6 @@ #include "dds/ddsi/q_bswap.h" #include "dds/ddsi/q_transmit.h" #include "dds/ddsi/q_lease.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsi/ddsi_serdata_default.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_src_t src; int interesting = 0; - int plist_ret; + dds_return_t plist_ret; src.protocol_version = rst->protocol_version; src.vendorid = rst->vendor; 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; 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]); 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_src_t src; - int plist_ret; + dds_return_t plist_ret; src.protocol_version = rst->protocol_version; src.vendorid = rst->vendor; 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; 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]); 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_src_t src; - int plist_ret; + dds_return_t plist_ret; src.protocol_version = rst->protocol_version; src.vendorid = rst->vendor; 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; 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]); 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_src_t src; - int plist_ret; + dds_return_t plist_ret; src.protocol_version = rst->protocol_version; src.vendorid = rst->vendor; 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; 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]); return; } @@ -1748,7 +1747,7 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str { 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; - int plist_ret; + dds_return_t plist_ret; src.protocol_version = sampleinfo->rst->protocol_version; src.vendorid = sampleinfo->rst->vendor; 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; 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", src.vendorid.id[0], src.vendorid.id[1], PGUID (srcguid), sampleinfo->seq); goto done_upd_deliv; diff --git a/src/core/ddsi/src/q_debmon.c b/src/core/ddsi/src/q_debmon.c index 9ea929f..a3362cb 100644 --- a/src/core/ddsi/src/q_debmon.c +++ b/src/core/ddsi/src/q_debmon.c @@ -33,7 +33,6 @@ #include "dds/ddsi/q_ddsi_discovery.h" #include "dds/ddsi/q_protocol.h" /* NN_ENTITYID_... */ #include "dds/ddsi/q_unused.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsi/q_debmon.h" #include "dds/ddsi/ddsi_serdata.h" #include "dds/ddsi/ddsi_tran.h" diff --git a/src/core/ddsi/src/q_entity.c b/src/core/ddsi/src/q_entity.c index 9dc0024..18d2895 100644 --- a/src/core/ddsi/src/q_entity.c +++ b/src/core/ddsi/src/q_entity.c @@ -38,7 +38,6 @@ #include "dds/ddsi/q_radmin.h" #include "dds/ddsi/q_protocol.h" /* NN_ENTITYID_... */ #include "dds/ddsi/q_unused.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsi/ddsi_serdata_default.h" #include "dds/ddsi/ddsi_mcgroup.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_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_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_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_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 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); @@ -376,7 +375,7 @@ static void remove_deleted_participant_guid (const struct nn_guid *guid, unsigne /* 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; int ret = 0; @@ -389,20 +388,20 @@ int pp_allocate_entityid(nn_entityid_t *id, unsigned kind, struct participant *p else { 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); 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); inverse_uint32_set_free(&pp->avail_entityids.x, id.u / NN_ENTITYID_ALLOCSTEP); 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; 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 recreate it. */ if (ephash_lookup_participant_guid (ppguid) != NULL) - return Q_ERR_ENTITY_EXISTS; + return DDS_RETCODE_PRECONDITION_NOT_MET; 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); 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; } -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; @@ -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) { 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); *p_ppguid = ppguid; @@ -858,11 +857,11 @@ static void gc_delete_participant (struct gcreq *gcreq) 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; 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); remember_deleted_participant_guid (&pp->e.guid); 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); } -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; 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); } - 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; + dds_return_t rc; if ((pp = ephash_lookup_participant_guid (ppguid)) == NULL) { 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 awake and do not touch the thread's vtime (ephash_lookup already verifies we're awake) */ wrguid->prefix = pp->e.guid.prefix; - if (pp_allocate_entityid (&wrguid->entityid, NN_ENTITYID_KIND_WRITER_WITH_KEY, pp) < 0) - return DDS_RETCODE_OUT_OF_RESOURCES; + if ((rc = pp_allocate_entityid (&wrguid->entityid, NN_ENTITYID_KIND_WRITER_WITH_KEY, pp)) < 0) + return rc; 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) { 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)); 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) { 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)); 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 */ -static dds_retcode_t new_reader_guid +static dds_return_t new_reader_guid ( struct reader **rd_out, 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_local_writers (rd, tnow); 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 nn_guid *rdguid, @@ -3349,15 +3349,16 @@ dds_retcode_t new_reader ) { struct participant * pp; + dds_return_t rc; if ((pp = ephash_lookup_participant_guid (ppguid)) == NULL) { 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; - if (pp_allocate_entityid (&rdguid->entityid, NN_ENTITYID_KIND_READER_WITH_KEY, pp) < 0) - return DDS_RETCODE_OUT_OF_RESOURCES; + if ((rc = pp_allocate_entityid (&rdguid->entityid, NN_ENTITYID_KIND_READER_WITH_KEY, pp)) < 0) + return rc; 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) { 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)); 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); DDS_LOG(DDS_LC_DISCOVERY, "- unknown\n"); - return Q_ERR_UNKNOWN_ENTITY; + return DDS_RETCODE_BAD_PARAMETER; } DDS_LOG(DDS_LC_DISCOVERY, "- deleting\n"); 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; default: 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); 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) { 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)); @@ -4301,7 +4302,7 @@ int delete_proxy_writer (const struct nn_guid *guid, nn_wctime_t timestamp, int { ddsrt_mutex_unlock (&gv.lock); 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 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) { 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)); @@ -4437,7 +4438,7 @@ int delete_proxy_reader (const struct nn_guid *guid, nn_wctime_t timestamp, int { ddsrt_mutex_unlock (&gv.lock); 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); ephash_remove_proxy_reader_guid (prd); diff --git a/src/core/ddsi/src/q_init.c b/src/core/ddsi/src/q_init.c index df26b1d..f224960 100644 --- a/src/core/ddsi/src/q_init.c +++ b/src/core/ddsi/src/q_init.c @@ -36,7 +36,6 @@ #include "dds/ddsi/q_addrset.h" #include "dds/ddsi/q_ddsi_discovery.h" #include "dds/ddsi/q_radmin.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_ephash.h" #include "dds/ddsi/q_lease.h" diff --git a/src/core/ddsi/src/q_nwif.c b/src/core/ddsi/src/q_nwif.c index f15f9dd..839eacf 100644 --- a/src/core/ddsi/src/q_nwif.c +++ b/src/core/ddsi/src/q_nwif.c @@ -96,7 +96,7 @@ static int set_rcvbuf (ddsrt_socket_t socket) uint32_t ReceiveBufferSize; socklen_t optlen = (socklen_t) sizeof (ReceiveBufferSize); uint32_t socket_min_rcvbuf_size; - dds_retcode_t rc; + dds_return_t rc; if (config.socket_min_rcvbuf_size.isdefault) socket_min_rcvbuf_size = 1048576; else @@ -145,7 +145,7 @@ static int set_sndbuf (ddsrt_socket_t socket) { unsigned SendBufferSize; socklen_t optlen = (socklen_t) sizeof(SendBufferSize); - dds_retcode_t rc; + dds_return_t rc; rc = ddsrt_getsockopt( socket, SOL_SOCKET, SO_SNDBUF,(char *)&SendBufferSize, &optlen); 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 multicast sockets, leave unicast sockets alone. */ int one = 1; - dds_retcode_t rc = ddsrt_setsockopt ( + dds_return_t rc = ddsrt_setsockopt ( socket, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof (one)); if (rc == DDS_RETCODE_BAD_PARAMETER) { 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) { - dds_retcode_t rc = DDS_RETCODE_ERROR; + dds_return_t rc = DDS_RETCODE_ERROR; #if DDSRT_HAVE_IPV6 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 loop; - dds_retcode_t ret; + dds_return_t ret; #if (defined(__linux) || defined(__APPLE__)) && !LWIP_SOCKET if (config.use_multicast_if_mreqn) @@ -348,7 +348,7 @@ int make_socket ) { int rc = -2; - dds_retcode_t ret; + dds_return_t ret; #if DDSRT_HAVE_IPV6 if (config.transport_selector == TRANS_TCP6 || config.transport_selector == TRANS_UDP6) diff --git a/src/core/ddsi/src/q_plist.c b/src/core/ddsi/src/q_plist.c index a83f9f9..bae275b 100644 --- a/src/core/ddsi/src/q_plist.c +++ b/src/core/ddsi/src/q_plist.c @@ -22,7 +22,6 @@ #include "dds/ddsi/q_bswap.h" #include "dds/ddsi/q_unused.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsi/q_plist.h" #include "dds/ddsi/q_time.h" #include "dds/ddsi/q_xmsg.h" @@ -87,31 +86,31 @@ static int protocol_version_is_newer (nn_protocol_version_t pv) return (pv.major < RTPS_MAJOR) ? 0 : (pv.major > RTPS_MAJOR) ? 1 : (pv.minor > RTPS_MINOR); } -static int validate_string (const struct dd *dd, size_t *len) +static dds_return_t validate_string (const struct dd *dd, size_t *len) { const struct cdrstring *x = (const struct cdrstring *) dd->buf; if (dd->bufsz < sizeof (struct cdrstring)) { DDS_TRACE("plist/validate_string: buffer too small (header)\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } *len = dd->bswap ? bswap4u (x->length) : x->length; if (*len < 1 || *len > dd->bufsz - offsetof (struct cdrstring, contents)) { DDS_TRACE("plist/validate_string: length %" PRIuSIZE " out of range\n", *len); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if (x->contents[*len-1] != 0) { DDS_TRACE("plist/validate_string: terminator missing\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } return 0; } -static int alias_string (const unsigned char **ptr, const struct dd *dd, size_t *len) +static dds_return_t alias_string (const unsigned char **ptr, const struct dd *dd, size_t *len) { - int rc; + dds_return_t rc; if ((rc = validate_string (dd, len)) < 0) return rc; else @@ -139,21 +138,21 @@ static void unalias_string (char **str, int bswap) memcpy (*str, alias, len); } -static int validate_octetseq (const struct dd *dd, size_t *len) +static dds_return_t validate_octetseq (const struct dd *dd, size_t *len) { const struct cdroctetseq *x = (const struct cdroctetseq *) dd->buf; if (dd->bufsz < offsetof (struct cdroctetseq, value)) - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; *len = dd->bswap ? bswap4u (x->len) : x->len; if (*len > dd->bufsz - offsetof (struct cdroctetseq, value) || *len >= UINT32_MAX) - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; return 0; } -static int alias_octetseq (nn_octetseq_t *oseq, const struct dd *dd) +static dds_return_t alias_octetseq (nn_octetseq_t *oseq, const struct dd *dd) { size_t len; - int rc; + dds_return_t rc; if ((rc = validate_octetseq (dd, &len)) < 0) return rc; else @@ -166,7 +165,7 @@ static int alias_octetseq (nn_octetseq_t *oseq, const struct dd *dd) } } -static int alias_blob (nn_octetseq_t *oseq, const struct dd *dd) +static dds_return_t alias_blob (nn_octetseq_t *oseq, const struct dd *dd) { assert (dd->bufsz < UINT32_MAX); oseq->length = (uint32_t)dd->bufsz; @@ -185,7 +184,7 @@ static void unalias_octetseq (nn_octetseq_t *oseq, UNUSED_ARG (int bswap)) } } -static int validate_stringseq (const struct dd *dd) +static dds_return_t validate_stringseq (const struct dd *dd) { const unsigned char *seq = dd->buf; const unsigned char *seqend = seq + dd->bufsz; @@ -194,7 +193,7 @@ static int validate_stringseq (const struct dd *dd) if (dd->bufsz < sizeof (int)) { DDS_TRACE("plist/validate_stringseq: buffer too small (header)\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } memcpy (&n, seq, sizeof (n)); if (dd->bswap) @@ -203,7 +202,7 @@ static int validate_stringseq (const struct dd *dd) if (n < 0) { DDS_TRACE("plist/validate_stringseq: length %d out of range\n", n); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } else if (n == 0) { @@ -227,7 +226,7 @@ static int validate_stringseq (const struct dd *dd) if (i < n) { DDS_TRACE("plist/validate_stringseq: buffer too small (contents)\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } /* Should I worry about junk between the last string & the end of @@ -235,7 +234,7 @@ static int validate_stringseq (const struct dd *dd) return 0; } -static int alias_stringseq (nn_stringseq_t *strseq, const struct dd *dd) +static dds_return_t alias_stringseq (nn_stringseq_t *strseq, const struct dd *dd) { /* Not truly an alias: it allocates an array of pointers that alias the individual null-terminated strings. Also: see @@ -245,11 +244,11 @@ static int alias_stringseq (nn_stringseq_t *strseq, const struct dd *dd) struct dd dd1 = *dd; char **strs; unsigned i; - int result; + dds_return_t result; if (dd->bufsz < sizeof (int)) { DDS_TRACE("plist/alias_stringseq: buffer too small (header)\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } memcpy (&strseq->n, seq, sizeof (strseq->n)); if (dd->bswap) @@ -258,7 +257,7 @@ static int alias_stringseq (nn_stringseq_t *strseq, const struct dd *dd) if (strseq->n >= UINT_MAX / sizeof(*strs)) { DDS_TRACE("plist/alias_stringseq: length %"PRIu32" out of range\n", strseq->n); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } else if (strseq->n == 0) { @@ -285,7 +284,7 @@ static int alias_stringseq (nn_stringseq_t *strseq, const struct dd *dd) if (i != strseq->n) { DDS_TRACE("plist/validate_stringseq: buffer too small (contents)\n"); - result = Q_ERR_INVALID; + result = DDS_RETCODE_BAD_PARAMETER; goto fail; } strseq->strs = strs; @@ -300,16 +299,12 @@ static void free_stringseq (nn_stringseq_t *strseq) { unsigned i; for (i = 0; i < strseq->n; i++) - { if (strseq->strs[i]) - { ddsrt_free (strseq->strs[i]); - } - } ddsrt_free (strseq->strs); } -static int unalias_stringseq (nn_stringseq_t *strseq, int bswap) +static dds_return_t unalias_stringseq (nn_stringseq_t *strseq, int bswap) { unsigned i; char **strs; @@ -465,9 +460,9 @@ void nn_plist_unalias (nn_plist_t *ps) } #endif -static int do_octetseq (nn_octetseq_t *dst, uint64_t *present, uint64_t *aliased, uint64_t wanted, uint64_t fl, const struct dd *dd) +static dds_return_t do_octetseq (nn_octetseq_t *dst, uint64_t *present, uint64_t *aliased, uint64_t wanted, uint64_t fl, const struct dd *dd) { - int res; + dds_return_t res; size_t len; if (!(wanted & fl)) return NN_STRICT_P ? validate_octetseq (dd, &len) : 0; @@ -479,9 +474,9 @@ static int do_octetseq (nn_octetseq_t *dst, uint64_t *present, uint64_t *aliased return res; } -static int do_blob (nn_octetseq_t *dst, uint64_t *present, uint64_t *aliased, uint64_t wanted, uint64_t fl, const struct dd *dd) +static dds_return_t do_blob (nn_octetseq_t *dst, uint64_t *present, uint64_t *aliased, uint64_t wanted, uint64_t fl, const struct dd *dd) { - int res; + dds_return_t res; if (!(wanted & fl)) return 0; if ((res = alias_blob (dst, dd)) >= 0) @@ -492,9 +487,9 @@ static int do_blob (nn_octetseq_t *dst, uint64_t *present, uint64_t *aliased, ui return res; } -static int do_string (char **dst, uint64_t *present, uint64_t *aliased, uint64_t wanted, uint64_t fl, const struct dd *dd) +static dds_return_t do_string (char **dst, uint64_t *present, uint64_t *aliased, uint64_t wanted, uint64_t fl, const struct dd *dd) { - int res; + dds_return_t res; size_t len; if (!(wanted & fl)) return NN_STRICT_P ? validate_string (dd, &len) : 0; @@ -506,9 +501,9 @@ static int do_string (char **dst, uint64_t *present, uint64_t *aliased, uint64_t return res; } -static int do_stringseq (nn_stringseq_t *dst, uint64_t *present, uint64_t *aliased, uint64_t wanted, uint64_t fl, const struct dd *dd) +static dds_return_t do_stringseq (nn_stringseq_t *dst, uint64_t *present, uint64_t *aliased, uint64_t wanted, uint64_t fl, const struct dd *dd) { - int res; + dds_return_t res; if (!(wanted & fl)) return NN_STRICT_P ? validate_stringseq (dd) : 0; if ((res = alias_stringseq (dst, dd)) >= 0) @@ -525,9 +520,9 @@ static void bswap_time (nn_ddsi_time_t *t) t->fraction = bswap4u (t->fraction); } -static int validate_time (const nn_ddsi_time_t *t) +static dds_return_t validate_time (const nn_ddsi_time_t *t) { - /* Accepter are zero, positive, infinite or invalid as defined in + /* Accepted are zero, positive, infinite or invalid as defined in the DDS 2.1 spec, table 9.4. */ if (t->seconds >= 0) return 0; @@ -536,7 +531,7 @@ static int validate_time (const nn_ddsi_time_t *t) else { DDS_TRACE("plist/validate_time: invalid timestamp (%08x.%08x)\n", t->seconds, t->fraction); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } @@ -545,18 +540,18 @@ static void bswap_duration (nn_duration_t *d) bswap_time (d); } -int validate_duration (const nn_duration_t *d) +dds_return_t validate_duration (const nn_duration_t *d) { return validate_time (d); } -static int do_duration (nn_duration_t *q, uint64_t *present, uint64_t fl, const struct dd *dd) +static dds_return_t do_duration (nn_duration_t *q, uint64_t *present, uint64_t fl, const struct dd *dd) { - int res; + dds_return_t res; if (dd->bufsz < sizeof (*q)) { DDS_TRACE("plist/do_duration: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } memcpy (q, dd->buf, sizeof (*q)); if (dd->bswap) @@ -572,7 +567,7 @@ static void bswap_durability_qospolicy (nn_durability_qospolicy_t *q) q->kind = bswap4u (q->kind); } -int validate_durability_qospolicy (const nn_durability_qospolicy_t *q) +dds_return_t validate_durability_qospolicy (const nn_durability_qospolicy_t *q) { switch (q->kind) { @@ -583,7 +578,7 @@ int validate_durability_qospolicy (const nn_durability_qospolicy_t *q) break; default: DDS_TRACE("plist/validate_durability_qospolicy: invalid kind (%d)\n", (int) q->kind); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } return 0; } @@ -599,7 +594,7 @@ static int history_qospolicy_allzero (const nn_history_qospolicy_t *q) return q->kind == NN_KEEP_LAST_HISTORY_QOS && q->depth == 0; } -int validate_history_qospolicy (const nn_history_qospolicy_t *q) +dds_return_t validate_history_qospolicy (const nn_history_qospolicy_t *q) { /* Validity of history setting and of resource limits are dependent, but we don't have access to the resource limits here ... the @@ -615,7 +610,7 @@ int validate_history_qospolicy (const nn_history_qospolicy_t *q) break; default: DDS_TRACE("plist/validate_history_qospolicy: invalid kind (%d)\n", (int) q->kind); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } /* Accept all values for depth if kind = ALL */ if (q->kind == NN_KEEP_LAST_HISTORY_QOS) @@ -623,7 +618,7 @@ int validate_history_qospolicy (const nn_history_qospolicy_t *q) if (q->depth < 1) { DDS_TRACE("plist/validate_history_qospolicy: invalid depth (%d)\n", (int) q->depth); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } return 0; @@ -641,7 +636,7 @@ static int resource_limits_qospolicy_allzero (const nn_resource_limits_qospolicy return q->max_samples == 0 && q->max_instances == 0 && q->max_samples_per_instance == 0; } -int validate_resource_limits_qospolicy (const nn_resource_limits_qospolicy_t *q) +dds_return_t validate_resource_limits_qospolicy (const nn_resource_limits_qospolicy_t *q) { const int unlimited = NN_DDS_LENGTH_UNLIMITED; /* Note: dependent on history setting as well (see @@ -650,17 +645,17 @@ int validate_resource_limits_qospolicy (const nn_resource_limits_qospolicy_t *q) if (q->max_samples < 1 && q->max_samples != unlimited) { DDS_TRACE("plist/validate_resource_limits_qospolicy: max_samples invalid (%d)\n", (int) q->max_samples); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if (q->max_instances < 1 && q->max_instances != unlimited) { DDS_TRACE("plist/validate_resource_limits_qospolicy: max_instances invalid (%d)\n", (int) q->max_instances); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if (q->max_samples_per_instance < 1 && q->max_samples_per_instance != unlimited) { DDS_TRACE("plist/validate_resource_limits_qospolicy: max_samples_per_instance invalid (%d)\n", (int) q->max_samples_per_instance); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if (q->max_samples != unlimited && q->max_samples_per_instance != unlimited) { @@ -669,16 +664,16 @@ int validate_resource_limits_qospolicy (const nn_resource_limits_qospolicy_t *q) if (q->max_samples < q->max_samples_per_instance) { DDS_TRACE("plist/validate_resource_limits_qospolicy: max_samples (%d) and max_samples_per_instance (%d) incompatible\n", (int) q->max_samples, (int) q->max_samples_per_instance); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } return 0; } -int validate_history_and_resource_limits (const nn_history_qospolicy_t *qh, const nn_resource_limits_qospolicy_t *qr) +dds_return_t validate_history_and_resource_limits (const nn_history_qospolicy_t *qh, const nn_resource_limits_qospolicy_t *qr) { const int unlimited = NN_DDS_LENGTH_UNLIMITED; - int res; + dds_return_t res; if ((res = validate_history_qospolicy (qh)) < 0) { DDS_TRACE("plist/validate_history_and_resource_limits: history policy invalid\n"); @@ -696,7 +691,7 @@ int validate_history_and_resource_limits (const nn_history_qospolicy_t *qh, cons if (qr->max_samples_per_instance != unlimited) { DDS_TRACE("plist/validate_history_and_resource_limits: max_samples_per_instance (%d) incompatible with KEEP_ALL policy\n", (int) qr->max_samples_per_instance); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } #endif break; @@ -704,7 +699,7 @@ int validate_history_and_resource_limits (const nn_history_qospolicy_t *qh, cons if (qr->max_samples_per_instance != unlimited && qh->depth > qr->max_samples_per_instance) { DDS_TRACE("plist/validate_history_and_resource_limits: depth (%d) and max_samples_per_instance (%d) incompatible with KEEP_LAST policy\n", (int) qh->depth, (int) qr->max_samples_per_instance); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } break; } @@ -725,9 +720,9 @@ static int durability_service_qospolicy_allzero (const nn_durability_service_qos q->service_cleanup_delay.seconds == 0 && q->service_cleanup_delay.fraction == 0); } -static int validate_durability_service_qospolicy_acceptzero (const nn_durability_service_qospolicy_t *q, bool acceptzero) +static dds_return_t validate_durability_service_qospolicy_acceptzero (const nn_durability_service_qospolicy_t *q, bool acceptzero) { - int res; + dds_return_t res; if (acceptzero && durability_service_qospolicy_allzero (q)) return 0; if ((res = validate_duration (&q->service_cleanup_delay)) < 0) @@ -743,7 +738,7 @@ static int validate_durability_service_qospolicy_acceptzero (const nn_durability return 0; } -int validate_durability_service_qospolicy (const nn_durability_service_qospolicy_t *q) +dds_return_t validate_durability_service_qospolicy (const nn_durability_service_qospolicy_t *q) { return validate_durability_service_qospolicy_acceptzero (q, false); } @@ -754,9 +749,9 @@ static void bswap_liveliness_qospolicy (nn_liveliness_qospolicy_t *q) bswap_duration (&q->lease_duration); } -int validate_liveliness_qospolicy (const nn_liveliness_qospolicy_t *q) +dds_return_t validate_liveliness_qospolicy (const nn_liveliness_qospolicy_t *q) { - int res; + dds_return_t res; switch (q->kind) { case NN_AUTOMATIC_LIVELINESS_QOS: @@ -767,7 +762,7 @@ int validate_liveliness_qospolicy (const nn_liveliness_qospolicy_t *q) return res; default: DDS_TRACE("plist/validate_liveliness_qospolicy: invalid kind (%d)\n", (int) q->kind); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } @@ -777,9 +772,9 @@ static void bswap_external_reliability_qospolicy (nn_external_reliability_qospol bswap_duration (&qext->max_blocking_time); } -static int validate_xform_reliability_qospolicy (nn_reliability_qospolicy_t *qdst, const nn_external_reliability_qospolicy_t *qext) +static dds_return_t validate_xform_reliability_qospolicy (nn_reliability_qospolicy_t *qdst, const nn_external_reliability_qospolicy_t *qext) { - int res; + dds_return_t res; qdst->max_blocking_time = qext->max_blocking_time; if (NN_PEDANTIC_P) { @@ -795,7 +790,7 @@ static int validate_xform_reliability_qospolicy (nn_reliability_qospolicy_t *qds return res; default: DDS_TRACE("plist/validate_xform_reliability_qospolicy[pedantic]: invalid kind (%d)\n", (int) qext->kind); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } else @@ -812,7 +807,7 @@ static int validate_xform_reliability_qospolicy (nn_reliability_qospolicy_t *qds return res; default: DDS_TRACE("plist/validate_xform_reliability_qospolicy[!pedantic]: invalid kind (%d)\n", (int) qext->kind); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } } @@ -822,7 +817,7 @@ static void bswap_destination_order_qospolicy (nn_destination_order_qospolicy_t q->kind = bswap4u (q->kind); } -int validate_destination_order_qospolicy (const nn_destination_order_qospolicy_t *q) +dds_return_t validate_destination_order_qospolicy (const nn_destination_order_qospolicy_t *q) { switch (q->kind) { @@ -831,7 +826,7 @@ int validate_destination_order_qospolicy (const nn_destination_order_qospolicy_t return 0; default: DDS_TRACE("plist/validate_destination_order_qospolicy: invalid kind (%d)\n", (int) q->kind); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } @@ -840,7 +835,7 @@ static void bswap_ownership_qospolicy (nn_ownership_qospolicy_t *q) q->kind = bswap4u (q->kind); } -int validate_ownership_qospolicy (const nn_ownership_qospolicy_t *q) +dds_return_t validate_ownership_qospolicy (const nn_ownership_qospolicy_t *q) { switch (q->kind) { @@ -849,7 +844,7 @@ int validate_ownership_qospolicy (const nn_ownership_qospolicy_t *q) return 0; default: DDS_TRACE("plist/validate_ownership_qospolicy: invalid kind (%d)\n", (int) q->kind); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } @@ -858,9 +853,9 @@ static void bswap_ownership_strength_qospolicy (nn_ownership_strength_qospolicy_ q->value = bswap4 (q->value); } -int validate_ownership_strength_qospolicy (UNUSED_ARG (const nn_ownership_strength_qospolicy_t *q)) +dds_return_t validate_ownership_strength_qospolicy (UNUSED_ARG (const nn_ownership_strength_qospolicy_t *q)) { - return 1; + return 0; } static void bswap_presentation_qospolicy (nn_presentation_qospolicy_t *q) @@ -868,7 +863,7 @@ static void bswap_presentation_qospolicy (nn_presentation_qospolicy_t *q) q->access_scope = bswap4u (q->access_scope); } -int validate_presentation_qospolicy (const nn_presentation_qospolicy_t *q) +dds_return_t validate_presentation_qospolicy (const nn_presentation_qospolicy_t *q) { switch (q->access_scope) { @@ -878,18 +873,18 @@ int validate_presentation_qospolicy (const nn_presentation_qospolicy_t *q) break; default: DDS_TRACE("plist/validate_presentation_qospolicy: invalid access_scope (%d)\n", (int) q->access_scope); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } /* Bools must be 0 or 1, i.e., only the lsb may be set */ if (q->coherent_access & ~1) { DDS_TRACE("plist/validate_presentation_qospolicy: coherent_access invalid (%d)\n", (int) q->coherent_access); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if (q->ordered_access & ~1) { DDS_TRACE("plist/validate_presentation_qospolicy: ordered_access invalid (%d)\n", (int) q->ordered_access); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } /* coherent_access & ordered_access are a bit irrelevant for instance presentation qos, but it appears as if their values are @@ -902,12 +897,12 @@ static void bswap_transport_priority_qospolicy (nn_transport_priority_qospolicy_ q->value = bswap4 (q->value); } -int validate_transport_priority_qospolicy (UNUSED_ARG (const nn_transport_priority_qospolicy_t *q)) +dds_return_t validate_transport_priority_qospolicy (UNUSED_ARG (const nn_transport_priority_qospolicy_t *q)) { - return 1; + return 0; } -static int add_locator (nn_locators_t *ls, uint64_t *present, uint64_t wanted, uint64_t fl, const nn_locator_t *loc) +static dds_return_t add_locator (nn_locators_t *ls, uint64_t *present, uint64_t wanted, uint64_t fl, const nn_locator_t *loc) { if (wanted & fl) { @@ -951,7 +946,7 @@ static int locator_address_zero (const nn_locator_t *loc) return (u[0] == 0 && u[1] == 0 && u[2] == 0 && u[3] == 0); } -static int do_locator +static dds_return_t do_locator ( nn_locators_t *ls, uint64_t *present, @@ -965,7 +960,7 @@ static int do_locator if (dd->bufsz < sizeof (loc)) { DDS_TRACE("plist/do_locator: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } memcpy (&loc, dd->buf, sizeof (loc)); if (dd->bswap) @@ -980,12 +975,12 @@ static int do_locator if (loc.port <= 0 || loc.port > 65535) { DDS_TRACE("plist/do_locator[kind=IPv4]: invalid port (%d)\n", (int) loc.port); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if (!locator_address_prefix12_zero (&loc)) { DDS_TRACE("plist/do_locator[kind=IPv4]: junk in address prefix\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } break; case NN_LOCATOR_KIND_UDPv6: @@ -993,7 +988,7 @@ static int do_locator if (loc.port <= 0 || loc.port > 65535) { DDS_TRACE("plist/do_locator[kind=IPv6]: invalid port (%d)\n", (int) loc.port); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } break; case NN_LOCATOR_KIND_UDPv4MCGEN: { @@ -1003,12 +998,12 @@ static int do_locator if (loc.port <= 0 || loc.port > 65536) { DDS_TRACE("plist/do_locator[kind=IPv4MCGEN]: invalid port (%d)\n", (int) loc.port); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if ((int)x->base + x->count >= 28 || x->count == 0 || x->idx >= x->count) { DDS_TRACE("plist/do_locator[kind=IPv4MCGEN]: invalid base/count/idx (%u,%u,%u)\n", x->base, x->count, x->idx); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } break; } @@ -1016,12 +1011,12 @@ static int do_locator if (!locator_address_zero (&loc)) { DDS_TRACE("plist/do_locator[kind=INVALID]: junk in address\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if (loc.port != 0) { DDS_TRACE("plist/do_locator[kind=INVALID]: junk in port\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } /* silently dropped correctly formatted "invalid" locators. */ return 0; @@ -1030,7 +1025,7 @@ static int do_locator return 0; default: DDS_TRACE("plist/do_locator: invalid kind (%d)\n", (int) loc.kind); - return NN_PEDANTIC_P ? Q_ERR_INVALID : 0; + return NN_PEDANTIC_P ? DDS_RETCODE_BAD_PARAMETER : 0; } return add_locator (ls, present, wanted, fl, &loc); } @@ -1043,7 +1038,7 @@ static void locator_from_ipv4address_port (nn_locator_t *loc, const nn_ipv4addre memcpy (loc->address + 12, a, 4); } -static int do_ipv4address (nn_plist_t *dest, nn_ipaddress_params_tmp_t *dest_tmp, uint64_t wanted, unsigned fl_tmp, const struct dd *dd) +static dds_return_t do_ipv4address (nn_plist_t *dest, nn_ipaddress_params_tmp_t *dest_tmp, uint64_t wanted, unsigned fl_tmp, const struct dd *dd) { nn_ipv4address_t *a; nn_port_t *p; @@ -1053,7 +1048,7 @@ static int do_ipv4address (nn_plist_t *dest, nn_ipaddress_params_tmp_t *dest_tmp if (dd->bufsz < sizeof (*a)) { DDS_TRACE("plist/do_ipv4address: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } switch (fl_tmp) { @@ -1113,7 +1108,7 @@ static int do_ipv4address (nn_plist_t *dest, nn_ipaddress_params_tmp_t *dest_tmp } } -static int do_port (nn_plist_t *dest, nn_ipaddress_params_tmp_t *dest_tmp, uint64_t wanted, unsigned fl_tmp, const struct dd *dd) +static dds_return_t do_port (nn_plist_t *dest, nn_ipaddress_params_tmp_t *dest_tmp, uint64_t wanted, unsigned fl_tmp, const struct dd *dd) { nn_ipv4address_t *a; nn_port_t *p; @@ -1123,7 +1118,7 @@ static int do_port (nn_plist_t *dest, nn_ipaddress_params_tmp_t *dest_tmp, uint6 if (dd->bufsz < sizeof (*p)) { DDS_TRACE("plist/do_port: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } switch (fl_tmp) { @@ -1157,7 +1152,7 @@ static int do_port (nn_plist_t *dest, nn_ipaddress_params_tmp_t *dest_tmp, uint6 if (*p <= 0 || *p > 65535) { DDS_TRACE("plist/do_port: invalid port (%d)\n", (int) *p); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } dest_tmp->present |= fl_tmp; if ((dest_tmp->present & (fl_tmp | fl1_tmp)) == (fl_tmp | fl1_tmp)) @@ -1176,7 +1171,7 @@ static int do_port (nn_plist_t *dest, nn_ipaddress_params_tmp_t *dest_tmp, uint6 } } -static int valid_participant_guid (const nn_guid_t *g, UNUSED_ARG (const struct dd *dd)) +static dds_return_t valid_participant_guid (const nn_guid_t *g, UNUSED_ARG (const struct dd *dd)) { /* All 0 is GUID_UNKNOWN, which is a defined GUID */ if (g->prefix.u[0] == 0 && g->prefix.u[1] == 0 && g->prefix.u[2] == 0) @@ -1186,7 +1181,7 @@ static int valid_participant_guid (const nn_guid_t *g, UNUSED_ARG (const struct else { DDS_TRACE("plist/valid_participant_guid: prefix is 0 but entityid is not (%"PRIu32")\n", g->entityid.u); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } else if (g->entityid.u == NN_ENTITYID_PARTICIPANT) @@ -1196,11 +1191,11 @@ static int valid_participant_guid (const nn_guid_t *g, UNUSED_ARG (const struct else { DDS_TRACE("plist/valid_participant_guid: entityid not a participant entityid (%"PRIu32")\n", g->entityid.u); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } -static int valid_group_guid (const nn_guid_t *g, UNUSED_ARG (const struct dd *dd)) +static dds_return_t valid_group_guid (const nn_guid_t *g, UNUSED_ARG (const struct dd *dd)) { /* All 0 is GUID_UNKNOWN, which is a defined GUID */ if (g->prefix.u[0] == 0 && g->prefix.u[1] == 0 && g->prefix.u[2] == 0) @@ -1210,7 +1205,7 @@ static int valid_group_guid (const nn_guid_t *g, UNUSED_ARG (const struct dd *dd else { DDS_TRACE("plist/valid_group_guid: prefix is 0 but entityid is not (%"PRIu32")\n", g->entityid.u); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } else if (g->entityid.u != 0) @@ -1221,11 +1216,11 @@ static int valid_group_guid (const nn_guid_t *g, UNUSED_ARG (const struct dd *dd else { DDS_TRACE("plist/valid_group_guid: entityid is 0\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } -static int valid_endpoint_guid (const nn_guid_t *g, const struct dd *dd) +static dds_return_t valid_endpoint_guid (const nn_guid_t *g, const struct dd *dd) { /* All 0 is GUID_UNKNOWN, which is a defined GUID */ if (g->prefix.u[0] == 0 && g->prefix.u[1] == 0 && g->prefix.u[2] == 0) @@ -1235,7 +1230,7 @@ static int valid_endpoint_guid (const nn_guid_t *g, const struct dd *dd) else { DDS_TRACE("plist/valid_endpoint_guid: prefix is 0 but entityid is not (%"PRIx32")\n", g->entityid.u); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } switch (g->entityid.u & NN_ENTITYID_SOURCE_MASK) @@ -1256,7 +1251,7 @@ static int valid_endpoint_guid (const nn_guid_t *g, const struct dd *dd) DDS_TRACE("plist/valid_endpoint_guid[src=USER,proto=%u.%u]: invalid kind (%"PRIx32")\n", dd->protocol_version.major, dd->protocol_version.minor, g->entityid.u & NN_ENTITYID_KIND_MASK); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } case NN_ENTITYID_SOURCE_BUILTIN: @@ -1280,7 +1275,7 @@ static int valid_endpoint_guid (const nn_guid_t *g, const struct dd *dd) { DDS_TRACE("plist/valid_endpoint_guid[src=BUILTIN,proto=%u.%u]: invalid entityid (%"PRIx32")\n", dd->protocol_version.major, dd->protocol_version.minor, g->entityid.u); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } case NN_ENTITYID_SOURCE_VENDOR: @@ -1310,16 +1305,16 @@ static int valid_endpoint_guid (const nn_guid_t *g, const struct dd *dd) } default: DDS_TRACE("plist/valid_endpoint_guid: invalid source (%"PRIx32")\n", g->entityid.u); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } -static int do_guid (nn_guid_t *dst, uint64_t *present, uint64_t fl, int (*valid) (const nn_guid_t *g, const struct dd *dd), const struct dd *dd) +static dds_return_t do_guid (nn_guid_t *dst, uint64_t *present, uint64_t fl, int (*valid) (const nn_guid_t *g, const struct dd *dd), const struct dd *dd) { if (dd->bufsz < sizeof (*dst)) { DDS_TRACE("plist/do_guid: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } memcpy (dst, dd->buf, sizeof (*dst)); *dst = nn_ntoh_guid (*dst); @@ -1335,7 +1330,7 @@ static int do_guid (nn_guid_t *dst, uint64_t *present, uint64_t fl, int (*valid) } else { - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } } *present |= fl; @@ -1352,18 +1347,18 @@ static void bswap_prismtech_participant_version_info (nn_prismtech_participant_v pvi->unused[i] = bswap4u (pvi->unused[i]); } -static int do_prismtech_participant_version_info (nn_prismtech_participant_version_info_t *pvi, uint64_t *present, uint64_t *aliased, const struct dd *dd) +static dds_return_t do_prismtech_participant_version_info (nn_prismtech_participant_version_info_t *pvi, uint64_t *present, uint64_t *aliased, const struct dd *dd) { if (!vendor_is_eclipse_or_prismtech (dd->vendorid)) return 0; else if (dd->bufsz < NN_PRISMTECH_PARTICIPANT_VERSION_INFO_FIXED_CDRSIZE) { DDS_TRACE("plist/do_prismtech_participant_version_info[pid=PRISMTECH_PARTICIPANT_VERSION_INFO]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } else { - int res; + dds_return_t res; unsigned sz = NN_PRISMTECH_PARTICIPANT_VERSION_INFO_FIXED_CDRSIZE - sizeof(uint32_t); uint32_t *pu = (uint32_t *)dd->buf; size_t len; @@ -1385,22 +1380,20 @@ static int do_prismtech_participant_version_info (nn_prismtech_participant_versi } } - - -static int do_subscription_keys_qospolicy (nn_subscription_keys_qospolicy_t *q, uint64_t *present, uint64_t *aliased, uint64_t fl, const struct dd *dd) +static dds_return_t do_subscription_keys_qospolicy (nn_subscription_keys_qospolicy_t *q, uint64_t *present, uint64_t *aliased, uint64_t fl, const struct dd *dd) { struct dd dd1; - int res; + dds_return_t res; if (dd->bufsz < 4) { DDS_TRACE("plist/do_subscription_keys: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } q->use_key_list = (unsigned char) dd->buf[0]; if (q->use_key_list != 0 && q->use_key_list != 1) { DDS_TRACE("plist/do_subscription_keys: invalid use_key_list (%d)\n", (int) q->use_key_list); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } dd1 = *dd; dd1.buf += 4; @@ -1413,18 +1406,18 @@ static int do_subscription_keys_qospolicy (nn_subscription_keys_qospolicy_t *q, return res; } -static int unalias_subscription_keys_qospolicy (nn_subscription_keys_qospolicy_t *q, int bswap) +static dds_return_t unalias_subscription_keys_qospolicy (nn_subscription_keys_qospolicy_t *q, int bswap) { return unalias_stringseq (&q->key_list, bswap); } -static int do_reader_lifespan_qospolicy (nn_reader_lifespan_qospolicy_t *q, uint64_t *present, uint64_t fl, const struct dd *dd) +static dds_return_t do_reader_lifespan_qospolicy (nn_reader_lifespan_qospolicy_t *q, uint64_t *present, uint64_t fl, const struct dd *dd) { - int res; + dds_return_t res; if (dd->bufsz < sizeof (*q)) { DDS_TRACE("plist/do_reader_lifespan: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } *q = *((nn_reader_lifespan_qospolicy_t *) dd->buf); if (dd->bswap) @@ -1432,47 +1425,47 @@ static int do_reader_lifespan_qospolicy (nn_reader_lifespan_qospolicy_t *q, uint if (q->use_lifespan != 0 && q->use_lifespan != 1) { DDS_TRACE("plist/do_reader_lifespan: invalid use_lifespan (%d)\n", (int) q->use_lifespan); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if ((res = validate_duration (&q->duration)) >= 0) *present |= fl; return res; } -static int do_entity_factory_qospolicy (nn_entity_factory_qospolicy_t *q, uint64_t *present, uint64_t fl, const struct dd *dd) +static dds_return_t do_entity_factory_qospolicy (nn_entity_factory_qospolicy_t *q, uint64_t *present, uint64_t fl, const struct dd *dd) { if (dd->bufsz < sizeof (*q)) { DDS_TRACE("plist/do_entity_factory: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } q->autoenable_created_entities = dd->buf[0]; if (q->autoenable_created_entities != 0 && q->autoenable_created_entities != 1) { DDS_TRACE("plist/do_entity_factory: invalid autoenable_created_entities (%d)\n", (int) q->autoenable_created_entities); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } *present |= fl; return 0; } -int validate_reader_data_lifecycle (const nn_reader_data_lifecycle_qospolicy_t *q) +dds_return_t validate_reader_data_lifecycle (const nn_reader_data_lifecycle_qospolicy_t *q) { if (validate_duration (&q->autopurge_nowriter_samples_delay) < 0 || validate_duration (&q->autopurge_disposed_samples_delay) < 0) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_READER_DATA_LIFECYCLE]: invalid autopurge_nowriter_sample_delay or autopurge_disposed_samples_delay\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if (q->autopurge_dispose_all != 0 && q->autopurge_dispose_all != 1) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_READER_DATA_LIFECYCLE]: invalid autopurge_dispose_all\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if (q->enable_invalid_samples != 0 && q->enable_invalid_samples != 1) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_READER_DATA_LIFECYCLE]: invalid enable_invalid_samples\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } /* Don't check consistency between enable_invalid_samples and invalid_samples_mode (yet) */ switch (q->invalid_sample_visibility) @@ -1483,12 +1476,12 @@ int validate_reader_data_lifecycle (const nn_reader_data_lifecycle_qospolicy_t * break; default: DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_READER_DATA_LIFECYCLE]: invalid invalid_sample_visibility\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } return 0; } -static int do_reader_data_lifecycle_v0 (nn_reader_data_lifecycle_qospolicy_t *q, const struct dd *dd) +static dds_return_t do_reader_data_lifecycle_v0 (nn_reader_data_lifecycle_qospolicy_t *q, const struct dd *dd) { memcpy (q, dd->buf, 2 * sizeof (nn_duration_t)); q->autopurge_dispose_all = 0; @@ -1502,7 +1495,7 @@ static int do_reader_data_lifecycle_v0 (nn_reader_data_lifecycle_qospolicy_t *q, return validate_reader_data_lifecycle (q); } -static int do_reader_data_lifecycle_v1 (nn_reader_data_lifecycle_qospolicy_t *q, const struct dd *dd) +static dds_return_t do_reader_data_lifecycle_v1 (nn_reader_data_lifecycle_qospolicy_t *q, const struct dd *dd) { memcpy (q, dd->buf, sizeof (*q)); if (dd->bswap) @@ -1514,7 +1507,7 @@ static int do_reader_data_lifecycle_v1 (nn_reader_data_lifecycle_qospolicy_t *q, return validate_reader_data_lifecycle (q); } -static int init_one_parameter +static dds_return_t init_one_parameter ( nn_plist_t *dest, nn_ipaddress_params_tmp_t *dest_tmp, @@ -1524,7 +1517,7 @@ static int init_one_parameter const struct dd *dd ) { - int res; + dds_return_t res; switch (pid) { case PID_PAD: @@ -1536,7 +1529,7 @@ static int init_one_parameter if (dd->bufsz < sizeof (nn_##name_##_qospolicy_t)) \ { \ DDS_TRACE("plist/init_one_parameter[pid=%s]: buffer too small\n", #NAME_); \ - return Q_ERR_INVALID; \ + return DDS_RETCODE_BAD_PARAMETER; \ } \ else \ { \ @@ -1563,7 +1556,7 @@ static int init_one_parameter if (dd->bufsz < sizeof (nn_durability_service_qospolicy_t)) { DDS_TRACE("plist/init_one_parameter[pid=DURABILITY_SERVICE]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } else { @@ -1590,7 +1583,7 @@ static int init_one_parameter if (dd->bufsz < sizeof (nn_external_reliability_qospolicy_t)) { DDS_TRACE("plist/init_one_parameter[pid=RELIABILITY]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } else { @@ -1631,7 +1624,7 @@ static int init_one_parameter case PID_PRISMTECH_READER_DATA_LIFECYCLE: /* PrismTech specific */ { - int ret; + dds_return_t ret; if (!vendor_is_eclipse_or_prismtech (dd->vendorid)) return 0; if (dd->bufsz >= sizeof (nn_reader_data_lifecycle_qospolicy_t)) @@ -1641,7 +1634,7 @@ static int init_one_parameter else { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_READER_DATA_LIFECYCLE]: buffer too small\n"); - ret = Q_ERR_INVALID; + ret = DDS_RETCODE_BAD_PARAMETER; } if (ret >= 0) dest->qos.present |= QP_PRISMTECH_READER_DATA_LIFECYCLE; @@ -1656,7 +1649,7 @@ static int init_one_parameter if (dd->bufsz < 1) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_WRITER_DATA_LIFECYCLE]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } else if (dd->bufsz < sizeof (*q)) { @@ -1677,13 +1670,13 @@ static int init_one_parameter if (q->autodispose_unregistered_instances & ~1) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_WRITER_DATA_LIFECYCLE]: invalid autodispose_unregistered_instances (%d)\n", (int) q->autodispose_unregistered_instances); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if (validate_duration (&q->autounregister_instance_delay) < 0 || validate_duration (&q->autopurge_suspended_samples_delay) < 0) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_WRITER_DATA_LIFECYCLE]: invalid autounregister_instance_delay or autopurge_suspended_samples_delay\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } dest->qos.present |= QP_PRISMTECH_WRITER_DATA_LIFECYCLE; return 0; @@ -1695,7 +1688,7 @@ static int init_one_parameter else if (dd->bufsz < sizeof (dest->qos.relaxed_qos_matching)) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_RELAXED_QOS_MATCHING]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } else { @@ -1704,7 +1697,7 @@ static int init_one_parameter if (rqm->value != 0 && rqm->value != 1) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_RELAXED_QOS_MATCHING]: invalid\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } dest->qos.present |= QP_PRISMTECH_RELAXED_QOS_MATCHING; return 0; @@ -1716,7 +1709,7 @@ static int init_one_parameter else if (dd->bufsz < sizeof (dest->qos.synchronous_endpoint)) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_SYNCHRONOUS_ENDPOINT]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } else { @@ -1725,7 +1718,7 @@ static int init_one_parameter if (q->value != 0 && q->value != 1) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_SYNCHRONOUS_ENDPOINT]: invalid value for synchronous flag\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } dest->qos.present |= QP_PRISMTECH_SYNCHRONOUS_ENDPOINT; return 0; @@ -1736,7 +1729,7 @@ static int init_one_parameter if (dd->bufsz < sizeof (nn_protocol_version_t)) { DDS_TRACE("plist/init_one_parameter[pid=PROTOCOL_VERSION]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } memcpy (&dest->protocol_version, dd->buf, sizeof (dest->protocol_version)); if (NN_STRICT_P && @@ -1749,14 +1742,14 @@ static int init_one_parameter DDS_TRACE("plist/init_one_parameter[pid=PROTOCOL_VERSION,mode=STRICT]: version (%u.%u) mismatch with message (%u.%u)\n", dest->protocol_version.major, dest->protocol_version.minor, dd->protocol_version.major, dd->protocol_version.minor); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } dest->present |= PP_PROTOCOL_VERSION; return 0; case PID_VENDORID: if (dd->bufsz < sizeof (nn_vendorid_t)) - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; memcpy (&dest->vendorid, dd->buf, sizeof (dest->vendorid)); if (NN_STRICT_P && (dest->vendorid.id[0] != dd->vendorid.id[0] || @@ -1765,7 +1758,7 @@ static int init_one_parameter /* see PROTOCOL_VERSION */ DDS_TRACE("plist/init_one_parameter[pid=VENDORID,mode=STRICT]: vendor (%u.%u) mismatch with message (%u.%u)\n", dest->vendorid.id[0], dest->vendorid.id[1], dd->vendorid.id[0], dd->vendorid.id[1]); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } dest->present |= PP_VENDORID; return 0; @@ -1809,7 +1802,7 @@ static int init_one_parameter if (dd->bufsz < sizeof (dest->expects_inline_qos)) { DDS_TRACE("plist/init_one_parameter[pid=EXPECTS_INLINE_QOS]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } dest->expects_inline_qos = dd->buf[0]; /* boolean: only lsb may be set */ @@ -1817,7 +1810,7 @@ static int init_one_parameter { DDS_TRACE("plist/init_one_parameter[pid=EXPECTS_INLINE_QOS]: invalid expects_inline_qos (%d)\n", (int) dest->expects_inline_qos); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } dest->present |= PP_EXPECTS_INLINE_QOS; return 0; @@ -1829,7 +1822,7 @@ static int init_one_parameter if (dd->bufsz < sizeof (dest->participant_manual_liveliness_count)) { DDS_TRACE("plist/init_one_parameter[pid=PARTICIPANT_MANUAL_LIVELINESS_COUNT]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } memcpy (&dest->participant_manual_liveliness_count, dd->buf, sizeof (dest->participant_manual_liveliness_count)); if (dd->bswap) @@ -1863,7 +1856,7 @@ static int init_one_parameter if (dd->bufsz < sizeof (dest->builtin_endpoint_set)) { DDS_TRACE("plist/init_one_parameter[pid=BUILTIN_ENDPOINT_SET(%u)]: buffer too small\n", pid); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } memcpy (&dest->builtin_endpoint_set, dd->buf, sizeof (dest->builtin_endpoint_set)); if (dd->bswap) @@ -1888,7 +1881,7 @@ static int init_one_parameter { DDS_TRACE("plist/init_one_parameter[pid=BUILTIN_ENDPOINT_SET(%u),mode=STRICT,proto=%u.%u]: invalid set (0x%x)\n", pid, dd->protocol_version.major, dd->protocol_version.minor, dest->builtin_endpoint_set); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } dest->present |= PP_BUILTIN_ENDPOINT_SET; return 0; @@ -1899,7 +1892,7 @@ static int init_one_parameter else if (dd->bufsz < sizeof (dest->prismtech_builtin_endpoint_set)) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_BUILTIN_ENDPOINT_SET(%u)]: buffer too small\n", pid); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } else { @@ -1922,7 +1915,7 @@ static int init_one_parameter if (dd->bufsz < sizeof (dest->keyhash)) { DDS_TRACE("plist/init_one_parameter[pid=KEYHASH]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } memcpy (&dest->keyhash, dd->buf, sizeof (dest->keyhash)); dest->present |= PP_KEYHASH; @@ -1932,7 +1925,7 @@ static int init_one_parameter if (dd->bufsz < sizeof (dest->statusinfo)) { DDS_TRACE("plist/init_one_parameter[pid=STATUSINFO]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } memcpy (&dest->statusinfo, dd->buf, sizeof (dest->statusinfo)); dest->statusinfo = fromBE4u (dest->statusinfo); @@ -1943,7 +1936,7 @@ static int init_one_parameter may use them in this version of the specification */ DDS_TRACE("plist/init_one_parameter[pid=STATUSINFO,mode=STRICT,proto=%u.%u]: invalid statusinfo (0x%x)\n", dd->protocol_version.major, dd->protocol_version.minor, dest->statusinfo); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } /* Clear all bits we don't understand, then add the extended bits if present */ dest->statusinfo &= NN_STATUSINFO_STANDARDIZED; @@ -1963,7 +1956,7 @@ static int init_one_parameter if (dd->bufsz < sizeof (dest->coherent_set_seqno)) { DDS_TRACE("plist/init_one_parameter[pid=COHERENT_SET]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } else { @@ -1979,7 +1972,7 @@ static int init_one_parameter if (seqno <= 0 && seqno != NN_SEQUENCE_NUMBER_UNKNOWN) { DDS_TRACE("plist/init_one_parameter[pid=COHERENT_SET]: invalid sequence number (%" PRId64 ")\n", seqno); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } dest->present |= PP_COHERENT_SET; return 0; @@ -2000,7 +1993,7 @@ static int init_one_parameter ignore it. */ DDS_TRACE("plist/init_one_parameter[pid=ENDPOINT_GUID,mode=PEDANTIC,proto=%u.%u]: undefined pid\n", dd->protocol_version.major, dd->protocol_version.minor); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } return do_guid (&dest->endpoint_guid, &dest->present, PP_ENDPOINT_GUID, valid_endpoint_guid, dd); @@ -2021,7 +2014,6 @@ static int init_one_parameter return 0; } - case PID_PRISMTECH_PARTICIPANT_VERSION_INFO: return do_prismtech_participant_version_info(&dest->prismtech_participant_version_info, &dest->present, &dest->aliased, dd); @@ -2035,7 +2027,6 @@ static int init_one_parameter return 0; return do_reader_lifespan_qospolicy (&dest->qos.reader_lifespan, &dest->qos.present, QP_PRISMTECH_READER_LIFESPAN, dd); - case PID_PRISMTECH_ENTITY_FACTORY: if (!vendor_is_eclipse_or_prismtech (dd->vendorid)) return 0; @@ -2057,7 +2048,7 @@ static int init_one_parameter if (dd->bufsz < sizeof (dest->service_type)) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_SERVICE_TYPE]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } memcpy (&dest->service_type, dd->buf, sizeof (dest->service_type)); if (dd->bswap) @@ -2071,7 +2062,7 @@ static int init_one_parameter if (dd->bufsz < sizeof (dest->process_id)) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_PROCESS_ID]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } memcpy (&dest->process_id, dd->buf, sizeof (dest->process_id)); if (dd->bswap) @@ -2090,7 +2081,7 @@ static int init_one_parameter else if (dd->bufsz < 2*sizeof (uint32_t)) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_EOTINFO]: buffer too small (1)\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } else { @@ -2106,7 +2097,7 @@ static int init_one_parameter if (q->n > (dd->bufsz - 2*sizeof (uint32_t)) / sizeof (nn_prismtech_eotgroup_tid_t)) { DDS_TRACE("plist/init_one_parameter[pid=PRISMTECH_EOTINFO]: buffer too small (2)\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if (q->n == 0) q->tids = NULL; @@ -2135,7 +2126,7 @@ static int init_one_parameter if (dd->bufsz < sizeof (dest->reader_favours_ssm)) { DDS_TRACE("plist/init_one_parameter[pid=READER_FAVOURS_SSM]: buffer too small\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } else { @@ -2175,13 +2166,13 @@ static int init_one_parameter bugs & the buffer overflows originate! */ if (pid & PID_UNRECOGNIZED_INCOMPATIBLE_FLAG) { dest->present |= PP_INCOMPATIBLE; - return Q_ERR_INCOMPATIBLE; + return DDS_RETCODE_UNSUPPORTED; } else if (pid & PID_VENDORSPECIFIC_FLAG) { return 0; } else if (!protocol_version_is_newer (dd->protocol_version) && NN_STRICT_P) { DDS_TRACE("plist/init_one_parameter[pid=%u,mode=STRICT,proto=%u.%u]: undefined paramter id\n", pid, dd->protocol_version.major, dd->protocol_version.minor); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } else { return 0; } @@ -2189,7 +2180,7 @@ static int init_one_parameter assert (0); DDS_TRACE("plist/init_one_parameter: can't happen\n"); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } static void default_resource_limits (nn_resource_limits_qospolicy_t *q) @@ -2299,7 +2290,7 @@ nn_plist_t *nn_plist_dup (const nn_plist_t *src) return dst; } -static int final_validation (nn_plist_t *dest, nn_protocol_version_t protocol_version, nn_vendorid_t vendorid) +static dds_return_t final_validation (nn_plist_t *dest, nn_protocol_version_t protocol_version, nn_vendorid_t vendorid) { /* Resource limits & history are related, so if only one is given, set the other to the default, claim it has been provided & @@ -2317,7 +2308,7 @@ static int final_validation (nn_plist_t *dest, nn_protocol_version_t protocol_ve } if (dest->qos.present & (QP_HISTORY | QP_RESOURCE_LIMITS)) { - int res; + dds_return_t res; assert ((dest->qos.present & (QP_HISTORY | QP_RESOURCE_LIMITS)) == (QP_HISTORY | QP_RESOURCE_LIMITS)); if ((res = validate_history_and_resource_limits (&dest->qos.history, &dest->qos.resource_limits)) < 0) return res; @@ -2357,7 +2348,7 @@ static int final_validation (nn_plist_t *dest, nn_protocol_version_t protocol_ve /* if it is still present, it must be valid */ if (dest->qos.present & QP_DURABILITY_SERVICE) { - int res; + dds_return_t res; if ((res = validate_durability_service_qospolicy (&dest->qos.durability_service)) < 0) return res; } @@ -2365,7 +2356,7 @@ static int final_validation (nn_plist_t *dest, nn_protocol_version_t protocol_ve return 0; } -int nn_plist_init_frommsg +dds_return_t nn_plist_init_frommsg ( nn_plist_t *dest, char **nextafterplist, @@ -2405,7 +2396,7 @@ int nn_plist_init_frommsg default: DDS_WARNING ("plist(vendor %u.%u): unknown encoding (%d)\n", src->vendorid.id[0], src->vendorid.id[1], src->encoding); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } nn_plist_init_empty (dest); dest->unalias_needs_bswap = dd.bswap; @@ -2419,7 +2410,7 @@ int nn_plist_init_frommsg nn_parameter_t *par = (nn_parameter_t *) pl; nn_parameterid_t pid; unsigned short length; - int res; + dds_return_t res; /* swapping header partially based on wireshark dissector output, partially on intuition, and in a small part based on the spec */ @@ -2432,7 +2423,7 @@ int nn_plist_init_frommsg if ((res = final_validation (dest, src->protocol_version, src->vendorid)) < 0) { nn_plist_fini (dest); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } else { @@ -2447,14 +2438,14 @@ int nn_plist_init_frommsg DDS_WARNING("plist(vendor %u.%u): parameter length %u out of bounds\n", src->vendorid.id[0], src->vendorid.id[1], length); nn_plist_fini (dest); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if ((length % 4) != 0) /* DDSI 9.4.2.11 */ { DDS_WARNING("plist(vendor %u.%u): parameter length %u mod 4 != 0\n", src->vendorid.id[0], src->vendorid.id[1], length); nn_plist_fini (dest); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } if (dds_get_log_mask() & DDS_LC_PLIST) @@ -2480,7 +2471,7 @@ int nn_plist_init_frommsg DDS_WARNING("plist(vendor %u.%u): invalid parameter list: sentinel missing\n", src->vendorid.id[0], src->vendorid.id[1]); nn_plist_fini (dest); - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } const unsigned char *nn_plist_findparam_native_unchecked (const void *src, nn_parameterid_t pid) @@ -2591,7 +2582,6 @@ unsigned char *nn_plist_quickscan (struct nn_rsample_info *dest, const struct nn return NULL; } - void nn_xqos_init_empty (nn_xqos_t *dest) { #ifndef NDEBUG @@ -2600,12 +2590,11 @@ void nn_xqos_init_empty (nn_xqos_t *dest) dest->present = dest->aliased = 0; } -int nn_plist_init_default_participant (nn_plist_t *plist) +void nn_plist_init_default_participant (nn_plist_t *plist) { nn_plist_init_empty (plist); plist->qos.present |= QP_PRISMTECH_ENTITY_FACTORY; plist->qos.entity_factory.autoenable_created_entities = 0; - return 0; } static void xqos_init_default_common (nn_xqos_t *xqos) diff --git a/src/core/ddsi/src/q_receive.c b/src/core/ddsi/src/q_receive.c index 58ae5c3..9923a91 100644 --- a/src/core/ddsi/src/q_receive.c +++ b/src/core/ddsi/src/q_receive.c @@ -36,7 +36,6 @@ #include "dds/ddsi/q_addrset.h" #include "dds/ddsi/q_ddsi_discovery.h" #include "dds/ddsi/q_radmin.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsi/q_thread.h" #include "dds/ddsi/q_ephash.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; 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.vendorid = rst->vendor; 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; 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", src.vendorid.id[0], src.vendorid.id[1], PGUID (pwr->e.guid), sampleinfo->seq); return 0; diff --git a/src/core/ddsi/src/q_security.c b/src/core/ddsi/src/q_security.c index 408c077..000ba0d 100644 --- a/src/core/ddsi/src/q_security.c +++ b/src/core/ddsi/src/q_security.c @@ -14,7 +14,6 @@ #include "dds/ddsi/q_security.h" #include "dds/ddsi/q_config.h" #include "dds/ddsi/q_log.h" -#include "dds/ddsi/q_error.h" #include "os/os_stdlib.h" #include "os/os_process.h" #include "os/os_thread.h" @@ -1657,7 +1656,7 @@ static os_ssize_t q_security_sendmsg char stbuf[2048], *buf; size_t sz, data_size; uint32_t sz32, data_size32; - ssize_t ret = Q_ERR_UNSPECIFIED; + ssize_t ret = DDS_RETCODE_ERROR; PT_InfoContainer_t * securityHeader; unsigned i; diff --git a/src/core/ddsi/src/q_sockwaitset.c b/src/core/ddsi/src/q_sockwaitset.c index 833312d..c1876d5 100644 --- a/src/core/ddsi/src/q_sockwaitset.c +++ b/src/core/ddsi/src/q_sockwaitset.c @@ -893,7 +893,7 @@ os_sockWaitsetCtx os_sockWaitsetWait (os_sockWaitset ws) 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) { DDS_WARNING("os_sockWaitsetWait: select failed, retcode = %"PRId32, rc); diff --git a/src/core/ddsi/src/q_thread.c b/src/core/ddsi/src/q_thread.c index 6cf4a47..5518176 100644 --- a/src/core/ddsi/src/q_thread.c +++ b/src/core/ddsi/src/q_thread.c @@ -23,7 +23,6 @@ #include "dds/ddsi/q_thread.h" #include "dds/ddsi/ddsi_threadmon.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsi/q_log.h" #include "dds/ddsi/q_config.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; } -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); 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); } -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); - if (ddsrt_thread_join (ts1->extTid, NULL) == DDS_RETCODE_OK) - ret = 0; - else - ret = Q_ERR_UNSPECIFIED; + ret = ddsrt_thread_join (ts1->extTid, NULL); assert (vtime_asleep_p (ts1->vtime)); reap_thread_state (ts1, 1); return ret; diff --git a/src/core/ddsi/src/q_transmit.c b/src/core/ddsi/src/q_transmit.c index cc086a6..499b6f0 100644 --- a/src/core/ddsi/src/q_transmit.c +++ b/src/core/ddsi/src/q_transmit.c @@ -26,7 +26,6 @@ #include "dds/ddsi/q_time.h" #include "dds/ddsi/q_config.h" #include "dds/ddsi/q_globals.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsi/q_transmit.h" #include "dds/ddsi/q_entity.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); } -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 /* 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 */ 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 /* 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; } -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 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; enum nn_xmsg_kind xmsg_kind = isnew ? NN_XMSG_KIND_DATA : NN_XMSG_KIND_DATA_REXMIT; const uint32_t size = ddsi_serdata_size (serdata); - int ret = 0; + dds_return_t ret = 0; (void)plist; 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 reader can trigger. So we return an error instead of asserting as we used to. */ - return Q_ERR_INVALID; + return DDS_RETCODE_BAD_PARAMETER; } fragging = (config.fragment_size < size); /* 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) - return Q_ERR_OUT_OF_MEMORY; + return DDS_RETCODE_OUT_OF_RESOURCES; #ifdef DDSI_INCLUDE_NETWORK_PARTITIONS /* 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); *pmsg = NULL; - return Q_ERR_NO_ADDRESS; + return DDS_RETCODE_PRECONDITION_NOT_MET; } /* 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 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 writer. */ - dds_retcode_t result = DDS_RETCODE_OK; + dds_return_t result = DDS_RETCODE_OK; 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)); 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, PGUID (wr->e.guid), tname, ttname, ppbuf, tmp < (int) sizeof (ppbuf) ? "" : " (trunc)"); - r = Q_ERR_INVALID_DATA; + r = DDS_RETCODE_BAD_PARAMETER; 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); if (whcst.unacked_bytes > wr->whc_high) { - dds_retcode_t ores; + dds_return_t ores; assert(gc_allowed); /* also see beginning of the function */ if (config.prioritize_retransmit && wr->retransmitting) 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) { ddsrt_mutex_unlock (&wr->e.lock); - r = Q_ERR_TIMEOUT; + r = DDS_RETCODE_TIMEOUT; 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); return res; } - diff --git a/src/core/ddsi/src/q_xevent.c b/src/core/ddsi/src/q_xevent.c index 9eca691..baaf10f 100644 --- a/src/core/ddsi/src/q_xevent.c +++ b/src/core/ddsi/src/q_xevent.c @@ -30,7 +30,6 @@ #include "dds/ddsi/q_globals.h" #include "dds/ddsi/q_ephash.h" #include "dds/ddsi/q_transmit.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsi/q_bswap.h" #include "dds/ddsi/q_entity.h" #include "dds/ddsi/q_misc.h" @@ -477,9 +476,9 @@ struct xeventq * xeventq_new 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"; assert (evq->ts == NULL); @@ -497,7 +496,7 @@ int xeventq_start (struct xeventq *evq, const char *name) { ddsrt_free (evqname); } - return (rc != DDS_RETCODE_OK) ? Q_ERR_UNSPECIFIED : 0; + return rc; } void xeventq_stop (struct xeventq *evq) diff --git a/src/core/ddsi/src/q_xmsg.c b/src/core/ddsi/src/q_xmsg.c index 3c0eae0..b443e25 100644 --- a/src/core/ddsi/src/q_xmsg.c +++ b/src/core/ddsi/src/q_xmsg.c @@ -31,7 +31,6 @@ #include "dds/ddsi/q_bswap.h" #include "dds/ddsi/q_rtps.h" #include "dds/ddsi/q_addrset.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsi/q_misc.h" #include "dds/ddsi/q_log.h" #include "dds/ddsi/q_unused.h" @@ -148,7 +147,7 @@ typedef struct { ddsrt_cond_t cv; } ddsi_sem_t; -dds_retcode_t +dds_return_t ddsi_sem_init (ddsi_sem_t *sem, uint32_t value) { sem->value = value; @@ -157,7 +156,7 @@ ddsi_sem_init (ddsi_sem_t *sem, uint32_t value) return DDS_RETCODE_OK; } -dds_retcode_t +dds_return_t ddsi_sem_destroy (ddsi_sem_t *sem) { ddsrt_cond_destroy (&sem->cv); @@ -165,7 +164,7 @@ ddsi_sem_destroy (ddsi_sem_t *sem) return DDS_RETCODE_OK; } -dds_retcode_t +dds_return_t ddsi_sem_post (ddsi_sem_t *sem) { ddsrt_mutex_lock (&sem->mtx); @@ -175,7 +174,7 @@ ddsi_sem_post (ddsi_sem_t *sem) return DDS_RETCODE_OK; } -dds_retcode_t +dds_return_t ddsi_sem_wait (ddsi_sem_t *sem) { 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); } -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; 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 { 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; 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; } 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) diff --git a/src/core/ddsi/src/sysdeps.c b/src/core/ddsi/src/sysdeps.c index c233f16..73262f6 100644 --- a/src/core/ddsi/src/sysdeps.c +++ b/src/core/ddsi/src/sysdeps.c @@ -15,7 +15,6 @@ #include "dds/ddsrt/atomics.h" #include "dds/ddsrt/misc.h" -#include "dds/ddsi/q_error.h" #include "dds/ddsi/q_log.h" #include "dds/ddsi/q_config.h" #include "dds/ddsi/sysdeps.h" diff --git a/src/ddsrt/CMakeLists.txt b/src/ddsrt/CMakeLists.txt index 28069d0..4a2f5b1 100644 --- a/src/ddsrt/CMakeLists.txt +++ b/src/ddsrt/CMakeLists.txt @@ -121,10 +121,10 @@ list(APPEND sources "${source_path}/strtol.c") list(APPEND headers - "${source_path}/dds/ddsrt/avl.h" - "${source_path}/dds/ddsrt/fibheap.h" - "${source_path}/dds/ddsrt/hopscotch.h" - "${source_path}/dds/ddsrt/thread_pool.h") + "${include_path}/dds/ddsrt/avl.h" + "${include_path}/dds/ddsrt/fibheap.h" + "${include_path}/dds/ddsrt/hopscotch.h" + "${include_path}/dds/ddsrt/thread_pool.h") list(APPEND sources "${source_path}/avl.c" @@ -221,7 +221,7 @@ foreach(feature atomics cdtors environ heap ifaddrs random rusage endif() endforeach() -target_sources(ddsrt INTERFACE ${sources}) +target_sources(ddsrt INTERFACE ${sources} ${headers}) set(HAVE_MULTI_PROCESS ${HAVE_MULTI_PROCESS} PARENT_SCOPE) diff --git a/src/ddsrt/include/dds/ddsrt/environ.h b/src/ddsrt/include/dds/ddsrt/environ.h index 67a8c29..ddc4167 100644 --- a/src/ddsrt/include/dds/ddsrt/environ.h +++ b/src/ddsrt/include/dds/ddsrt/environ.h @@ -30,7 +30,7 @@ extern "C" { * byte), or would have been written would @buf have been * 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 * Environment variable written to @buf. @@ -43,7 +43,7 @@ extern "C" { * @retval DDS_RETCODE_ERROR * Unspecified error. */ -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_getenv( const char *name, char **value) @@ -58,7 +58,7 @@ ddsrt_nonnull_all; * @param[in] name Environment variable name. * @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 * Environment variable successfully set to @value. @@ -69,7 +69,7 @@ ddsrt_nonnull_all; * @retval DDS_RETCODE_ERROR * Unspecified system error. */ -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_setenv( const char *name, const char *value) @@ -80,7 +80,7 @@ ddsrt_nonnull_all; * * @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 * Environment variable successfully unset. @@ -91,7 +91,7 @@ ddsrt_nonnull_all; * @retval DDS_RETCODE_ERROR * Unspecified system error. */ -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_unsetenv( const char *name) ddsrt_nonnull_all; diff --git a/src/ddsrt/include/dds/ddsrt/ifaddrs.h b/src/ddsrt/include/dds/ddsrt/ifaddrs.h index b98d5b8..389356e 100644 --- a/src/ddsrt/include/dds/ddsrt/ifaddrs.h +++ b/src/ddsrt/include/dds/ddsrt/ifaddrs.h @@ -30,7 +30,7 @@ struct ddsrt_ifaddrs { typedef struct ddsrt_ifaddrs ddsrt_ifaddrs_t; -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_getifaddrs( ddsrt_ifaddrs_t **ifap, const int *afs); diff --git a/src/ddsrt/include/dds/ddsrt/process.h b/src/ddsrt/include/dds/ddsrt/process.h index 592508c..6a39c4a 100644 --- a/src/ddsrt/include/dds/ddsrt/process.h +++ b/src/ddsrt/include/dds/ddsrt/process.h @@ -72,7 +72,7 @@ ddsrt_getpid(void); * @param[in] argv Arguments array. * @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 * Process successfully created. @@ -85,7 +85,7 @@ ddsrt_getpid(void); * @retval DDS_RETCODE_ERROR * Process could not be created. */ -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_proc_create( const char *executable, char *const argv[], @@ -109,7 +109,7 @@ ddsrt_proc_create( * @param[in] timemout Time within the process is expected to finish. * @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 * Process has terminated and its exit code has been captured. @@ -124,7 +124,7 @@ ddsrt_proc_create( * @retval DDS_RETCODE_ERROR * Getting the exit code failed for an unknown reason. */ -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_proc_waitpid( ddsrt_pid_t pid, dds_duration_t timeout, @@ -149,7 +149,7 @@ ddsrt_proc_waitpid( * @param[out] pid Process ID (PID) of the finished 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 * A process has terminated. @@ -165,7 +165,7 @@ ddsrt_proc_waitpid( * @retval DDS_RETCODE_ERROR * Getting the exit code failed for an unknown reason. */ -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_proc_waitpids( dds_duration_t timeout, ddsrt_pid_t *pid, @@ -176,7 +176,7 @@ ddsrt_proc_waitpids( * * @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 * The process exists. @@ -185,7 +185,7 @@ ddsrt_proc_waitpids( * @retval DDS_RETCODE_ERROR * Determining if a process exists or not, failed. */ -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_proc_exists( ddsrt_pid_t pid); @@ -202,7 +202,7 @@ ddsrt_proc_exists( * * @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 * Kill attempt has been started. @@ -213,7 +213,7 @@ ddsrt_proc_exists( * @retval DDS_RETCODE_ERROR * Kill failed for an unknown reason. */ -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_proc_kill( ddsrt_pid_t pid); diff --git a/src/ddsrt/include/dds/ddsrt/retcode.h b/src/ddsrt/include/dds/ddsrt/retcode.h index f57626d..ca2cc8a 100644 --- a/src/ddsrt/include/dds/ddsrt/retcode.h +++ b/src/ddsrt/include/dds/ddsrt/retcode.h @@ -9,7 +9,7 @@ extern "C" { #endif -typedef int32_t dds_retcode_t; +typedef int32_t dds_return_t; /* 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_ERROR 1 /**< Non specific error */ -#define DDS_RETCODE_UNSUPPORTED 2 /**< Feature unsupported */ -#define DDS_RETCODE_BAD_PARAMETER 3 /**< Bad parameter value */ -#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_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_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_TIMEOUT 10 /**< When a timeout has occurred */ -#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_NOT_ALLOWED_BY_SECURITY 13 /**< When credentials are not enough to use the function */ +#define DDS_RETCODE_ERROR -1 /**< Non specific error */ +#define DDS_RETCODE_UNSUPPORTED -2 /**< Feature unsupported */ +#define DDS_RETCODE_BAD_PARAMETER -3 /**< Bad parameter value */ +#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_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_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_TIMEOUT -10 /**< When a timeout has occurred */ +#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_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 exclusively for internal use and must not be returned by the C API. */ -#define DDS_XRETCODE_BASE (50) -#define DDS_XRETCODE(x) (DDS_XRETCODE_BASE + (x)) +#define DDS_XRETCODE_BASE (-50) +#define DDS_XRETCODE(x) (DDS_XRETCODE_BASE - (x)) /** Requested resource is busy */ #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 */ -DDS_EXPORT const char *dds_strretcode(dds_retcode_t ret); +DDS_EXPORT const char *dds_strretcode(dds_return_t ret); #if defined (__cplusplus) } diff --git a/src/ddsrt/include/dds/ddsrt/rusage.h b/src/ddsrt/include/dds/ddsrt/rusage.h index a58de6b..8150df3 100644 --- a/src/ddsrt/include/dds/ddsrt/rusage.h +++ b/src/ddsrt/include/dds/ddsrt/rusage.h @@ -52,7 +52,7 @@ typedef struct { * @param[in] who DDSRT_RUSAGE_SELF or DDSRT_RUSAGE_THREAD. * @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 * Resource usage successfully returned in @usage. @@ -61,7 +61,7 @@ typedef struct { * @retval DDS_RETCODE_ERROR * 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) } diff --git a/src/ddsrt/include/dds/ddsrt/sockets.h b/src/ddsrt/include/dds/ddsrt/sockets.h index 3876320..e783b89 100644 --- a/src/ddsrt/include/dds/ddsrt/sockets.h +++ b/src/ddsrt/include/dds/ddsrt/sockets.h @@ -32,53 +32,53 @@ extern const struct in6_addr ddsrt_in6addr_loopback; #define DDSRT_AF_TERM (-1) -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_gethostname( char *hostname, size_t buffersize); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_socket( ddsrt_socket_t *sockptr, int domain, int type, int protocol); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_close( ddsrt_socket_t sock); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_connect( ddsrt_socket_t sock, const struct sockaddr *addr, socklen_t addrlen); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_accept( ddsrt_socket_t sock, struct sockaddr *addr, socklen_t *addrlen, ddsrt_socket_t *connptr); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_listen( ddsrt_socket_t sock, int backlog); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_bind( ddsrt_socket_t sock, const struct sockaddr *addr, socklen_t addrlen); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_getsockname( ddsrt_socket_t sock, struct sockaddr *addr, socklen_t *addrlen); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_send( ddsrt_socket_t sock, const void *buf, @@ -86,14 +86,14 @@ ddsrt_send( int flags, ssize_t *sent); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_sendmsg( ddsrt_socket_t sock, const ddsrt_msghdr_t *msg, int flags, ssize_t *sent); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_recv( ddsrt_socket_t sock, void *buf, @@ -101,14 +101,14 @@ ddsrt_recv( int flags, ssize_t *rcvd); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_recvmsg( ddsrt_socket_t sock, ddsrt_msghdr_t *msg, int flags, ssize_t *rcvd); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_getsockopt( ddsrt_socket_t sock, int32_t level, /* SOL_SOCKET */ @@ -116,7 +116,7 @@ ddsrt_getsockopt( void *optval, socklen_t *optlen); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_setsockopt( ddsrt_socket_t sock, int32_t level, /* SOL_SOCKET */ @@ -130,7 +130,7 @@ ddsrt_setsockopt( * @param[in] sock Socket to set I/O mode for. * @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 * I/O mode successfully set to (non)blocking. @@ -141,7 +141,7 @@ ddsrt_setsockopt( * @retval DDS_RETCODE_ERROR * An unknown error error occurred. */ -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_setsocknonblocking( ddsrt_socket_t sock, bool nonblock); @@ -228,11 +228,11 @@ ddsrt_sockaddr_insamesubnet( const struct sockaddr *mask) ddsrt_nonnull_all; -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_sockaddrfromstr( int af, const char *str, void *sa); -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_sockaddrtostr( 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[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 * Host name successfully resolved to address(es). @@ -262,7 +262,7 @@ typedef struct { * @retval DDS_RETCODE_TRY_AGAIN * Nonauthoratitative host not found. */ -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_gethostbyname( const char *name, int af, diff --git a/src/ddsrt/include/dds/ddsrt/string.h b/src/ddsrt/include/dds/ddsrt/string.h index 0023d12..68d3181 100644 --- a/src/ddsrt/include/dds/ddsrt/string.h +++ b/src/ddsrt/include/dds/ddsrt/string.h @@ -176,7 +176,7 @@ ddsrt_nonnull((1,2)); * @param[in] buf Buffer where description is copied to. * @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 * Description for @errnum was successfully copied to @buf. @@ -185,7 +185,7 @@ ddsrt_nonnull((1,2)); * @retval DDS_RETCODE_NOT_ENOUGH_SPACE * Buffer was not large enough to hold the description. */ -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_strerror_r( int errnum, char *buf, diff --git a/src/ddsrt/include/dds/ddsrt/strtod.h b/src/ddsrt/include/dds/ddsrt/strtod.h index f8bb511..4db08e7 100644 --- a/src/ddsrt/include/dds/ddsrt/strtod.h +++ b/src/ddsrt/include/dds/ddsrt/strtod.h @@ -34,9 +34,9 @@ extern "C" { * character 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); /** @@ -47,9 +47,9 @@ ddsrt_strtod(const char *nptr, char **endptr, double *dblptr); * character 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); /** diff --git a/src/ddsrt/include/dds/ddsrt/strtol.h b/src/ddsrt/include/dds/ddsrt/strtol.h index a862c06..c4cb059 100644 --- a/src/ddsrt/include/dds/ddsrt/strtol.h +++ b/src/ddsrt/include/dds/ddsrt/strtol.h @@ -37,7 +37,7 @@ extern "C" { * determine from @str. * @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 * String successfully converted to an integer. @@ -46,7 +46,7 @@ extern "C" { * @retval DDS_RETCODE_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( const char *str, char **endptr, @@ -69,7 +69,7 @@ ddsrt_strtoll( * determine from @str. * @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 * String successfully converted to an integer. @@ -78,7 +78,7 @@ ddsrt_strtoll( * @retval DDS_RETCODE_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( const char *str, char **endptr, @@ -91,7 +91,7 @@ ddsrt_strtoull( * @param[in] str String to convert into a long long integer. * @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 * String successfully converted to an integer. @@ -100,7 +100,7 @@ ddsrt_strtoull( * @retval DDS_RETCODE_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( const char *str, long long *llng); @@ -111,7 +111,7 @@ ddsrt_atoll( * @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. * - * @returns A dds_retcode_t indicating success or failure. + * @returns A dds_return_t indicating success or failure. * * @retval DDS_RETCODE_OK * String successfully converted to an integer. @@ -120,7 +120,7 @@ ddsrt_atoll( * @retval DDS_RETCODE_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( const char *str, unsigned long long *ullng); diff --git a/src/ddsrt/include/dds/ddsrt/thread_pool.h b/src/ddsrt/include/dds/ddsrt/thread_pool.h index f03fe46..4bcdc77 100644 --- a/src/ddsrt/include/dds/ddsrt/thread_pool.h +++ b/src/ddsrt/include/dds/ddsrt/thread_pool.h @@ -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. */ -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 */ void (*fn) (void *arg), /* Function to be invoked by thread from pool */ diff --git a/src/ddsrt/include/dds/ddsrt/threads.h b/src/ddsrt/include/dds/ddsrt/threads.h index 32f49bd..ce8ee30 100644 --- a/src/ddsrt/include/dds/ddsrt/threads.h +++ b/src/ddsrt/include/dds/ddsrt/threads.h @@ -121,14 +121,14 @@ ddsrt_nonnull_all; * @param[in] start_routine Function to execute in created thread. * @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 * Thread successfully created. * @retval DDS_RETCODE_ERROR * Thread could not be created. */ -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_thread_create( ddsrt_thread_t *thread, 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[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 * Target thread terminated. * @retval DDS_RETCODE_ERROR * 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_t thread, 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] arg Argument that will be passed to the cleanup handler. */ -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_thread_cleanup_push( void (*routine)(void*), void *arg); @@ -235,7 +235,7 @@ ddsrt_thread_cleanup_push( * Remove routine at the top of the calling thread's cleanup stack and * optionally invoke it (if execute is non-zero). */ -DDS_EXPORT dds_retcode_t +DDS_EXPORT dds_return_t ddsrt_thread_cleanup_pop( int execute); diff --git a/src/ddsrt/src/environ/posix/environ.c b/src/ddsrt/src/environ/posix/environ.c index b05769c..1f8b84f 100644 --- a/src/ddsrt/src/environ/posix/environ.c +++ b/src/ddsrt/src/environ/posix/environ.c @@ -23,7 +23,7 @@ isenvvar(const char *name) return (*name == '\0' || strchr(name, '=') != NULL) == 0; } -dds_retcode_t +dds_return_t ddsrt_getenv(const char *name, char **value) { char *env; @@ -40,7 +40,7 @@ ddsrt_getenv(const char *name, char **value) return DDS_RETCODE_NOT_FOUND; } -dds_retcode_t +dds_return_t ddsrt_setenv(const char *name, const char *value) { assert(name != NULL); @@ -65,7 +65,7 @@ ddsrt_setenv(const char *name, const char *value) return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_unsetenv(const char *name) { assert(name != NULL); diff --git a/src/ddsrt/src/environ/windows/environ.c b/src/ddsrt/src/environ/windows/environ.c index 076aea1..a5b2f90 100644 --- a/src/ddsrt/src/environ/windows/environ.c +++ b/src/ddsrt/src/environ/windows/environ.c @@ -25,7 +25,7 @@ isenvvar(const char *name) } DDSRT_WARNING_MSVC_OFF(4996) -dds_retcode_t +dds_return_t ddsrt_getenv(const char *name, char **value) { char *env; @@ -43,7 +43,7 @@ ddsrt_getenv(const char *name, char **value) } DDSRT_WARNING_MSVC_ON(4996) -dds_retcode_t +dds_return_t ddsrt_setenv(const char *name, const char *value) { assert(name != NULL); @@ -65,7 +65,7 @@ ddsrt_setenv(const char *name, const char *value) return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_unsetenv(const char *name) { assert(name != NULL); diff --git a/src/ddsrt/src/ifaddrs/posix/ifaddrs.c b/src/ddsrt/src/ifaddrs/posix/ifaddrs.c index 88606b1..208c4e0 100644 --- a/src/ddsrt/src/ifaddrs/posix/ifaddrs.c +++ b/src/ddsrt/src/ifaddrs/posix/ifaddrs.c @@ -21,10 +21,10 @@ 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) { - dds_retcode_t err = DDS_RETCODE_OK; + dds_return_t err = DDS_RETCODE_OK; ddsrt_ifaddrs_t *ifa; size_t sz; @@ -64,12 +64,12 @@ copyaddr(ddsrt_ifaddrs_t **ifap, const struct ifaddrs *sys_ifa) return err; } -dds_retcode_t +dds_return_t ddsrt_getifaddrs( ddsrt_ifaddrs_t **ifap, const int *afs) { - dds_retcode_t err = DDS_RETCODE_OK; + dds_return_t err = DDS_RETCODE_OK; int use; ddsrt_ifaddrs_t *ifa, *ifa_root, *ifa_next; struct ifaddrs *sys_ifa, *sys_ifa_root; diff --git a/src/ddsrt/src/ifaddrs/windows/ifaddrs.c b/src/ddsrt/src/ifaddrs/windows/ifaddrs.c index 1bd41da..7dcb8aa 100644 --- a/src/ddsrt/src/ifaddrs/windows/ifaddrs.c +++ b/src/ddsrt/src/ifaddrs/windows/ifaddrs.c @@ -23,10 +23,10 @@ extern const int *const os_supp_afs; -static dds_retcode_t +static dds_return_t 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; ULONG bufsz = 0; /* Size is determined on first iteration. */ ULONG ret; @@ -72,10 +72,10 @@ getifaces(PIP_ADAPTER_ADDRESSES *ptr) return err; } -static dds_retcode_t +static dds_return_t 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; ULONG bufsz = 0; DWORD ret; @@ -159,7 +159,7 @@ copyaddr( const PMIB_IPADDRTABLE addrtable, const PIP_ADAPTER_UNICAST_ADDRESS addr) { - dds_retcode_t err = DDS_RETCODE_OK; + dds_return_t err = DDS_RETCODE_OK; ddsrt_ifaddrs_t *ifa; struct sockaddr *sa; size_t sz; @@ -220,7 +220,7 @@ copyaddr( return err; } -dds_retcode_t +dds_return_t ddsrt_getifaddrs( ddsrt_ifaddrs_t **ifap, const int *afs) diff --git a/src/ddsrt/src/process/posix/process.c b/src/ddsrt/src/process/posix/process.c index d42877f..f8de0fc 100644 --- a/src/ddsrt/src/process/posix/process.c +++ b/src/ddsrt/src/process/posix/process.c @@ -72,7 +72,7 @@ static void no_op(int sig) } -static dds_retcode_t +static dds_return_t waitpids( ddsrt_pid_t request_pid, dds_duration_t timeout, @@ -81,7 +81,7 @@ waitpids( { struct sigaction sigactold; struct sigaction sigact; - dds_retcode_t rv; + dds_return_t rv; int options = 0; int ret; int s; @@ -148,13 +148,13 @@ waitpids( -dds_retcode_t +dds_return_t ddsrt_proc_create( const char *executable, char *const argv[], ddsrt_pid_t *pid) { - dds_retcode_t rv; + dds_return_t rv; char **exec_argv; int exec_fds[2]; int exec_err; @@ -253,7 +253,7 @@ fail_pipe: -dds_retcode_t +dds_return_t ddsrt_proc_waitpid( ddsrt_pid_t pid, dds_duration_t timeout, @@ -267,7 +267,7 @@ ddsrt_proc_waitpid( -dds_retcode_t +dds_return_t ddsrt_proc_waitpids( dds_duration_t timeout, ddsrt_pid_t *pid, @@ -278,7 +278,7 @@ ddsrt_proc_waitpids( -dds_retcode_t +dds_return_t ddsrt_proc_exists( ddsrt_pid_t pid) { @@ -294,7 +294,7 @@ ddsrt_proc_exists( -dds_retcode_t +dds_return_t ddsrt_proc_kill( ddsrt_pid_t pid) { diff --git a/src/ddsrt/src/process/windows/process.c b/src/ddsrt/src/process/windows/process.c index 91cebec..65c5125 100644 --- a/src/ddsrt/src/process/windows/process.c +++ b/src/ddsrt/src/process/windows/process.c @@ -29,24 +29,24 @@ ddsrt_getpid(void) -static HANDLE pid_to_phdl (ddsrt_pid_t pid); -static dds_retcode_t process_get_exit_code(HANDLE phdl, int32_t *code); -static dds_retcode_t process_kill (HANDLE phdl); -static char* commandline (const char *exe, char *const argv_in[]); -static BOOL child_add (HANDLE phdl); -static void child_remove (HANDLE phdl); -static DWORD child_list (HANDLE *list, DWORD max); -static HANDLE child_handle (ddsrt_pid_t pid); +static HANDLE pid_to_phdl (ddsrt_pid_t pid); +static dds_return_t process_get_exit_code(HANDLE phdl, int32_t *code); +static dds_return_t process_kill (HANDLE phdl); +static char* commandline (const char *exe, char *const argv_in[]); +static BOOL child_add (HANDLE phdl); +static void child_remove (HANDLE phdl); +static DWORD child_list (HANDLE *list, DWORD max); +static HANDLE child_handle (ddsrt_pid_t pid); -dds_retcode_t +dds_return_t ddsrt_proc_create( const char *executable, char *const argv[], ddsrt_pid_t *pid) { - dds_retcode_t rv = DDS_RETCODE_ERROR; + dds_return_t rv = DDS_RETCODE_ERROR; PROCESS_INFORMATION process_info; STARTUPINFO si; char *cmd; @@ -111,13 +111,13 @@ ddsrt_proc_create( -dds_retcode_t +dds_return_t ddsrt_proc_waitpid( ddsrt_pid_t pid, dds_duration_t timeout, int32_t *code) { - dds_retcode_t rv = DDS_RETCODE_OK; + dds_return_t rv = DDS_RETCODE_OK; HANDLE phdl; DWORD ret; @@ -155,13 +155,13 @@ ddsrt_proc_waitpid( -dds_retcode_t +dds_return_t ddsrt_proc_waitpids( dds_duration_t timeout, ddsrt_pid_t *pid, int32_t *code) { - dds_retcode_t rv = DDS_RETCODE_OK; + dds_return_t rv = DDS_RETCODE_OK; HANDLE hdls[MAXIMUM_WAIT_OBJECTS]; HANDLE phdl; DWORD cnt; @@ -208,11 +208,11 @@ ddsrt_proc_waitpids( -dds_retcode_t +dds_return_t ddsrt_proc_exists( ddsrt_pid_t pid) { - dds_retcode_t rv = DDS_RETCODE_NOT_FOUND; + dds_return_t rv = DDS_RETCODE_NOT_FOUND; HANDLE phdl; phdl = pid_to_phdl(pid); @@ -235,11 +235,11 @@ ddsrt_proc_exists( -dds_retcode_t +dds_return_t ddsrt_proc_kill( ddsrt_pid_t pid) { - dds_retcode_t rv = DDS_RETCODE_BAD_PARAMETER; + dds_return_t rv = DDS_RETCODE_BAD_PARAMETER; HANDLE phdl; 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( HANDLE phdl, int32_t *code) { - dds_retcode_t rv = DDS_RETCODE_ERROR; + dds_return_t rv = DDS_RETCODE_ERROR; DWORD tr; assert(phdl != 0); @@ -289,7 +289,7 @@ process_get_exit_code( /* Forcefully kill the given process. */ -static dds_retcode_t +static dds_return_t process_kill(HANDLE phdl) { assert(phdl != 0); diff --git a/src/ddsrt/src/retcode.c b/src/ddsrt/src/retcode.c index 6484f23..930a327 100644 --- a/src/ddsrt/src/retcode.c +++ b/src/ddsrt/src/retcode.c @@ -11,8 +11,7 @@ */ #include "dds/ddsrt/retcode.h" -static const char *retcodes[] = -{ +static const char *retcodes[] = { "Success", "Error", "Unsupported", @@ -42,19 +41,20 @@ static const char *xretcodes[] = { "Not found" }; -const char * -dds_strretcode (dds_retcode_t rc) +const char *dds_strretcode (dds_return_t rc) { - if (rc >= 0 && - rc < (dds_retcode_t)(sizeof(retcodes) / sizeof(retcodes[0]))) - { + const dds_return_t nretcodes = (dds_return_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]; - } else if (rc >= (DDS_XRETCODE_BASE) && - rc < (dds_retcode_t)(DDS_XRETCODE_BASE + (sizeof(xretcodes) / sizeof(xretcodes[0])))) - { + else if (rc >= DDS_XRETCODE_BASE && rc < DDS_XRETCODE_BASE + nxretcodes) return xretcodes[rc - DDS_XRETCODE_BASE]; - } - - return "Unknown return code"; + else + return "Unknown return code"; } - diff --git a/src/ddsrt/src/rusage/posix/rusage.c b/src/ddsrt/src/rusage/posix/rusage.c index 878bd1d..d200007 100644 --- a/src/ddsrt/src/rusage/posix/rusage.c +++ b/src/ddsrt/src/rusage/posix/rusage.c @@ -23,12 +23,12 @@ #include "dds/ddsrt/rusage.h" -dds_retcode_t +dds_return_t ddsrt_getrusage(int who, ddsrt_rusage_t *usage) { int err = 0; struct rusage buf; - dds_retcode_t rc; + dds_return_t rc; assert(who == DDSRT_RUSAGE_SELF || who == DDSRT_RUSAGE_THREAD); assert(usage != NULL); diff --git a/src/ddsrt/src/rusage/windows/rusage.c b/src/ddsrt/src/rusage/windows/rusage.c index 71d763d..ca83658 100644 --- a/src/ddsrt/src/rusage/windows/rusage.c +++ b/src/ddsrt/src/rusage/windows/rusage.c @@ -24,7 +24,7 @@ filetime_to_time(const FILETIME *ft) return ((ft->dwHighDateTime << 31) + (ft->dwLowDateTime)) * 100; } -dds_retcode_t +dds_return_t ddsrt_getrusage(int who, ddsrt_rusage_t *usage) { FILETIME stime, utime, ctime, etime; diff --git a/src/ddsrt/src/sockets.c b/src/ddsrt/src/sockets.c index 48e3282..2aaffb8 100644 --- a/src/ddsrt/src/sockets.c +++ b/src/ddsrt/src/sockets.c @@ -177,7 +177,7 @@ ddsrt_sockaddr_insamesubnet( return eq; } -dds_retcode_t +dds_return_t ddsrt_sockaddrfromstr(int af, const char *str, void *sa) { assert(str != NULL); @@ -213,7 +213,7 @@ ddsrt_sockaddrfromstr(int af, const char *str, void *sa) return DDS_RETCODE_OK; } -dds_retcode_t ddsrt_sockaddrtostr(const void *sa, char *buf, size_t size) +dds_return_t ddsrt_sockaddrtostr(const void *sa, char *buf, size_t size) { const char *ptr; @@ -249,7 +249,7 @@ DDSRT_WARNING_GNUC_ON(sign-conversion) } #if DDSRT_HAVE_DNS -dds_retcode_t +dds_return_t ddsrt_gethostbyname(const char *name, int af, ddsrt_hostent_t **hentp) { int gai_err = 0; diff --git a/src/ddsrt/src/sockets/posix/gethostname.c b/src/ddsrt/src/sockets/posix/gethostname.c index fbdd7c4..fcf7618 100644 --- a/src/ddsrt/src/sockets/posix/gethostname.c +++ b/src/ddsrt/src/sockets/posix/gethostname.c @@ -34,7 +34,7 @@ #if LWIP_SOCKET -dds_retcode_t +dds_return_t ddsrt_gethostname( char *name, size_t len) @@ -45,7 +45,7 @@ ddsrt_gethostname( return DDS_RETCODE_OK; } #else -dds_retcode_t +dds_return_t ddsrt_gethostname( char *name, size_t len) diff --git a/src/ddsrt/src/sockets/posix/socket.c b/src/ddsrt/src/sockets/posix/socket.c index 7334483..e3fa47e 100644 --- a/src/ddsrt/src/sockets/posix/socket.c +++ b/src/ddsrt/src/sockets/posix/socket.c @@ -37,7 +37,7 @@ #endif /* __APPLE__ */ #endif /* LWIP_SOCKET */ -dds_retcode_t +dds_return_t ddsrt_socket(ddsrt_socket_t *sockptr, int domain, int type, int protocol) { ddsrt_socket_t sock; @@ -68,7 +68,7 @@ ddsrt_socket(ddsrt_socket_t *sockptr, int domain, int type, int protocol) return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_close( ddsrt_socket_t sock) { @@ -87,7 +87,7 @@ ddsrt_close( return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_bind( ddsrt_socket_t sock, const struct sockaddr *addr, @@ -112,7 +112,7 @@ ddsrt_bind( return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_listen( ddsrt_socket_t sock, int backlog) @@ -135,7 +135,7 @@ ddsrt_listen( return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_connect( ddsrt_socket_t sock, const struct sockaddr *addr, @@ -177,7 +177,7 @@ ddsrt_connect( return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_accept( ddsrt_socket_t sock, struct sockaddr *addr, @@ -224,7 +224,7 @@ ddsrt_accept( return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_getsockname( ddsrt_socket_t sock, struct sockaddr *addr, @@ -248,7 +248,7 @@ ddsrt_getsockname( return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_getsockopt( ddsrt_socket_t sock, int32_t level, @@ -282,7 +282,7 @@ ddsrt_getsockopt( return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_setsockopt( ddsrt_socket_t sock, int32_t level, @@ -339,7 +339,7 @@ err_setsockopt: return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_setsocknonblocking( ddsrt_socket_t sock, bool nonblock) @@ -377,7 +377,7 @@ err_fcntl: return DDS_RETCODE_ERROR; } -static inline dds_retcode_t +static inline dds_return_t recv_error_to_retcode(int errnum) { switch (errnum) { @@ -406,7 +406,7 @@ recv_error_to_retcode(int errnum) return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_recv( ddsrt_socket_t sock, void *buf, @@ -443,7 +443,7 @@ static ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags) } #endif /* LWIP_SOCKET */ -dds_retcode_t +dds_return_t ddsrt_recvmsg( ddsrt_socket_t sock, ddsrt_msghdr_t *msg, @@ -461,7 +461,7 @@ ddsrt_recvmsg( return recv_error_to_retcode(errno); } -static inline dds_retcode_t +static inline dds_return_t send_error_to_retcode(int errnum) { switch (errnum) { @@ -503,7 +503,7 @@ send_error_to_retcode(int errnum) return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_send( ddsrt_socket_t sock, const void *buf, @@ -522,7 +522,7 @@ ddsrt_send( return send_error_to_retcode(errno); } -dds_retcode_t +dds_return_t ddsrt_sendmsg( ddsrt_socket_t sock, const ddsrt_msghdr_t *msg, @@ -540,7 +540,7 @@ ddsrt_sendmsg( return send_error_to_retcode(errno); } -dds_retcode_t +dds_return_t ddsrt_select( int32_t nfds, fd_set *readfds, diff --git a/src/ddsrt/src/sockets/windows/socket.c b/src/ddsrt/src/sockets/windows/socket.c index bc96301..d2b3221 100644 --- a/src/ddsrt/src/sockets/windows/socket.c +++ b/src/ddsrt/src/sockets/windows/socket.c @@ -52,11 +52,11 @@ ddsrt_winsock_fini(void) WSACleanup(); } -dds_retcode_t +dds_return_t ddsrt_socket(ddsrt_socket_t *sockptr, int domain, int type, int protocol) { int err; - dds_retcode_t ret = DDS_RETCODE_OK; + dds_return_t ret = DDS_RETCODE_OK; ddsrt_socket_t sock = DDSRT_INVALID_SOCKET; assert(sockptr != NULL); @@ -93,7 +93,7 @@ ddsrt_socket(ddsrt_socket_t *sockptr, int domain, int type, int protocol) return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_close(ddsrt_socket_t sock) { int err; @@ -120,7 +120,7 @@ ddsrt_close(ddsrt_socket_t sock) return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_accept( ddsrt_socket_t sock, struct sockaddr *addr, @@ -162,7 +162,7 @@ ddsrt_accept( return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_bind(ddsrt_socket_t sock, const struct sockaddr *addr, socklen_t addrlen) { int err; @@ -195,7 +195,7 @@ ddsrt_bind(ddsrt_socket_t sock, const struct sockaddr *addr, socklen_t addrlen) return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_listen( ddsrt_socket_t sock, int backlog) @@ -227,7 +227,7 @@ ddsrt_listen( return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_connect( ddsrt_socket_t sock, const struct sockaddr *addr, @@ -275,7 +275,7 @@ ddsrt_connect( return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_getsockname( ddsrt_socket_t sock, struct sockaddr *addr, @@ -309,7 +309,7 @@ ddsrt_getsockname( return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_getsockopt( ddsrt_socket_t sock, int32_t level, @@ -358,7 +358,7 @@ ddsrt_getsockopt( return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_setsockopt( ddsrt_socket_t sock, int32_t level, @@ -404,7 +404,7 @@ ddsrt_setsockopt( return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_setsocknonblocking( ddsrt_socket_t sock, bool nonblock) @@ -435,7 +435,7 @@ ddsrt_setsocknonblocking( return DDS_RETCODE_ERROR; } -static dds_retcode_t recv_error_to_retcode(int errnum) +static dds_return_t recv_error_to_retcode(int errnum) { assert(errnum != WSANOTINITIALISED); switch (errnum) { @@ -470,7 +470,7 @@ static dds_retcode_t recv_error_to_retcode(int errnum) return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_recv( ddsrt_socket_t sock, void *buf, @@ -490,7 +490,7 @@ ddsrt_recv( return recv_error_to_retcode(WSAGetLastError()); } -dds_retcode_t +dds_return_t ddsrt_recvmsg( ddsrt_socket_t sock, ddsrt_msghdr_t *msg, @@ -531,7 +531,7 @@ ddsrt_recvmsg( return recv_error_to_retcode(err); } -static dds_retcode_t +static dds_return_t send_error_to_retcode(int errnum) { assert(errnum != WSANOTINITIALISED); @@ -577,7 +577,7 @@ send_error_to_retcode(int errnum) return DDS_RETCODE_ERROR; } -dds_retcode_t +dds_return_t ddsrt_send( ddsrt_socket_t sock, const void *buf, @@ -608,7 +608,7 @@ struct iovec_matches_WSABUF { char len_size_matches[sizeof(((ddsrt_iovec_t *)8)->iov_len) == sizeof(((WSABUF *)8)->len) ? 1 : -1]; }; -dds_retcode_t +dds_return_t ddsrt_sendmsg( ddsrt_socket_t sock, const ddsrt_msghdr_t *msg, @@ -639,7 +639,7 @@ ddsrt_sendmsg( return send_error_to_retcode(WSAGetLastError()); } -dds_retcode_t +dds_return_t ddsrt_select( int32_t nfds, fd_set *readfds, diff --git a/src/ddsrt/src/string/posix/strerror.c b/src/ddsrt/src/string/posix/strerror.c index f467e30..cbd1009 100644 --- a/src/ddsrt/src/string/posix/strerror.c +++ b/src/ddsrt/src/string/posix/strerror.c @@ -21,7 +21,7 @@ #include "dds/ddsrt/string.h" -dds_retcode_t +dds_return_t ddsrt_strerror_r(int errnum, char *buf, size_t buflen) { assert(buf != NULL); diff --git a/src/ddsrt/src/strtod.c b/src/ddsrt/src/strtod.c index 99e4f05..7d0c0ba 100644 --- a/src/ddsrt/src/strtod.c +++ b/src/ddsrt/src/strtod.c @@ -96,12 +96,12 @@ os_lcNumericReplace(char *str) { } } -dds_retcode_t +dds_return_t ddsrt_strtod(const char *nptr, char **endptr, double *dblptr) { double dbl; int orig_errno; - dds_retcode_t ret = DDS_RETCODE_OK; + dds_return_t ret = DDS_RETCODE_OK; assert(nptr != NULL); assert(dblptr != NULL); @@ -161,7 +161,7 @@ ddsrt_strtod(const char *nptr, char **endptr, double *dblptr) return ret; } -dds_retcode_t +dds_return_t ddsrt_strtof(const char *nptr, char **endptr, float *fltptr) { /* Just use os_strtod(). */ @@ -169,7 +169,7 @@ ddsrt_strtof(const char *nptr, char **endptr, float *fltptr) point number is definitely not a double-precision floating point number. */ double dbl = 0.0; - dds_retcode_t ret; + dds_return_t ret; assert(nptr != NULL); assert(fltptr != NULL); diff --git a/src/ddsrt/src/strtol.c b/src/ddsrt/src/strtol.c index c6b6a5f..009c012 100644 --- a/src/ddsrt/src/strtol.c +++ b/src/ddsrt/src/strtol.c @@ -29,7 +29,7 @@ int ddsrt_todigit(const int chr) return -1; } -static dds_retcode_t +static dds_return_t ullfstr( const char *str, char **endptr, @@ -37,7 +37,7 @@ ullfstr( unsigned long long *ullng, unsigned long long max) { - dds_retcode_t rc = DDS_RETCODE_OK; + dds_return_t rc = DDS_RETCODE_OK; int num; size_t cnt = 0; unsigned long long tot = 0; @@ -86,14 +86,14 @@ ullfstr( return rc; } -dds_retcode_t +dds_return_t ddsrt_strtoll( const char *str, char **endptr, int32_t base, long long *llng) { - dds_retcode_t rc = DDS_RETCODE_OK; + dds_return_t rc = DDS_RETCODE_OK; size_t cnt = 0; long long tot = 1; unsigned long long ullng = 0, max = INT64_MAX; @@ -122,14 +122,14 @@ ddsrt_strtoll( return rc; } -dds_retcode_t +dds_return_t ddsrt_strtoull( const char *str, char **endptr, int32_t base, unsigned long long *ullng) { - dds_retcode_t rc = DDS_RETCODE_OK; + dds_return_t rc = DDS_RETCODE_OK; size_t cnt = 0; unsigned long long tot = 1; unsigned long long max = UINT64_MAX; @@ -157,7 +157,7 @@ ddsrt_strtoull( return rc; } -dds_retcode_t +dds_return_t ddsrt_atoll( const char *str, long long *llng) @@ -165,7 +165,7 @@ ddsrt_atoll( return ddsrt_strtoll(str, NULL, 10, llng); } -dds_retcode_t +dds_return_t ddsrt_atoull( const char *str, unsigned long long *ullng) diff --git a/src/ddsrt/src/thread_pool.c b/src/ddsrt/src/thread_pool.c index 48cba27..bc240e4 100644 --- a/src/ddsrt/src/thread_pool.c +++ b/src/ddsrt/src/thread_pool.c @@ -88,13 +88,13 @@ static uint32_t ddsrt_thread_start_fn (void * arg) return 0; } -static dds_retcode_t ddsrt_thread_pool_new_thread (ddsrt_thread_pool pool) +static dds_return_t ddsrt_thread_pool_new_thread (ddsrt_thread_pool pool) { static unsigned char pools = 0; /* Pool counter - TODO make atomic */ char name [64]; ddsrt_thread_t id; - dds_retcode_t res; + dds_return_t res; (void) snprintf (name, sizeof (name), "OSPL-%u-%u", pools++, pool->m_count++); res = ddsrt_thread_create (&id, name, &pool->m_attr, &ddsrt_thread_start_fn, pool); @@ -205,9 +205,9 @@ void ddsrt_thread_pool_free (ddsrt_thread_pool pool) ddsrt_free (pool); } -dds_retcode_t ddsrt_thread_pool_submit (ddsrt_thread_pool pool, void (*fn) (void *arg), void * arg) +dds_return_t ddsrt_thread_pool_submit (ddsrt_thread_pool pool, void (*fn) (void *arg), void * arg) { - dds_retcode_t res = DDS_RETCODE_OK; + dds_return_t res = DDS_RETCODE_OK; ddsi_work_queue_job_t job; ddsrt_mutex_lock (&pool->m_mutex); diff --git a/src/ddsrt/src/threads/posix/threads.c b/src/ddsrt/src/threads/posix/threads.c index 92eec22..bca8e36 100644 --- a/src/ddsrt/src/threads/posix/threads.c +++ b/src/ddsrt/src/threads/posix/threads.c @@ -187,7 +187,7 @@ static void *os_startRoutineWrapper (void *threadContext) return (void *)resultValue; } -dds_retcode_t +dds_return_t ddsrt_thread_create ( ddsrt_thread_t *threadptr, const char *name, @@ -346,7 +346,7 @@ bool ddsrt_thread_equal(ddsrt_thread_t a, ddsrt_thread_t b) return (pthread_equal(a.v, b.v) != 0); } -dds_retcode_t +dds_return_t ddsrt_thread_join(ddsrt_thread_t thread, uint32_t *thread_result) { int err; @@ -386,7 +386,7 @@ static void thread_init(void) (void)pthread_once(&thread_once, &thread_init_once); } -dds_retcode_t ddsrt_thread_cleanup_push (void (*routine) (void *), void *arg) +dds_return_t ddsrt_thread_cleanup_push (void (*routine) (void *), void *arg) { int err; thread_cleanup_t *prev, *tail; @@ -408,7 +408,7 @@ dds_retcode_t ddsrt_thread_cleanup_push (void (*routine) (void *), void *arg) return DDS_RETCODE_OUT_OF_RESOURCES; } -dds_retcode_t ddsrt_thread_cleanup_pop (int execute) +dds_return_t ddsrt_thread_cleanup_pop (int execute) { int err; thread_cleanup_t *tail; diff --git a/src/ddsrt/src/threads/windows/threads.c b/src/ddsrt/src/threads/windows/threads.c index 23830ab..97615ab 100644 --- a/src/ddsrt/src/threads/windows/threads.c +++ b/src/ddsrt/src/threads/windows/threads.c @@ -43,7 +43,7 @@ os_startRoutineWrapper( return resultValue; } -dds_retcode_t +dds_return_t ddsrt_thread_create( ddsrt_thread_t *thrptr, const char *name, @@ -139,7 +139,7 @@ bool ddsrt_thread_equal(ddsrt_thread_t a, ddsrt_thread_t b) * should not be closed until the os_threadWaitExit(...) call is called. * CloseHandle (threadHandle); */ -dds_retcode_t +dds_return_t ddsrt_thread_join( ddsrt_thread_t thread, uint32_t *thread_result) @@ -248,7 +248,7 @@ ddsrt_thread_setname( static ddsrt_thread_local thread_cleanup_t *thread_cleanup = NULL; -dds_retcode_t ddsrt_thread_cleanup_push(void (*routine)(void *), void *arg) +dds_return_t ddsrt_thread_cleanup_push(void (*routine)(void *), void *arg) { thread_cleanup_t *tail; @@ -265,7 +265,7 @@ dds_retcode_t ddsrt_thread_cleanup_push(void (*routine)(void *), void *arg) return DDS_RETCODE_OUT_OF_RESOURCES; } -dds_retcode_t ddsrt_thread_cleanup_pop(int execute) +dds_return_t ddsrt_thread_cleanup_pop(int execute) { thread_cleanup_t *tail; diff --git a/src/ddsrt/tests/environ.c b/src/ddsrt/tests/environ.c index b69acf4..0700546 100644 --- a/src/ddsrt/tests/environ.c +++ b/src/ddsrt/tests/environ.c @@ -22,7 +22,7 @@ CU_TheoryDataPoints(ddsrt_environ, bad_name) = { CU_Theory((const char *name), ddsrt_environ, bad_name) { - dds_retcode_t rc; + dds_return_t rc; static const char value[] = "bar"; static char dummy[] = "foobar"; char *ptr; @@ -40,7 +40,7 @@ CU_Theory((const char *name), ddsrt_environ, bad_name) DDSRT_WARNING_MSVC_OFF(4996) CU_Test(ddsrt_environ, setenv) { - dds_retcode_t rc; + dds_return_t rc; static const char name[] = "foo"; static char value[] = "bar"; char *ptr; @@ -64,7 +64,7 @@ DDSRT_WARNING_MSVC_ON(4996) CU_Test(ddsrt_environ, getenv) { - dds_retcode_t rc; + dds_return_t rc; static const char name[] = "foo"; static const char value[] = "bar"; static char dummy[] = "foobar"; @@ -111,7 +111,7 @@ CU_TheoryDataPoints(ddsrt_environ, expand) = { }; CU_Theory((const char *var, const char *expect), ddsrt_environ, expand) { - dds_retcode_t rc; + dds_return_t rc; static const char x_name[] = "X"; static const char x_value[] = "TEST"; static const char y_name[] = "Y"; @@ -163,7 +163,7 @@ CU_TheoryDataPoints(ddsrt_environ, expand_sh) = { }; CU_Theory((const char *var, const char *expect), ddsrt_environ, expand_sh) { - dds_retcode_t rc; + dds_return_t rc; static const char x_name[] = "X"; static const char x_value[] = "TEST"; static const char y_name[] = "Y"; diff --git a/src/ddsrt/tests/ifaddrs.c b/src/ddsrt/tests/ifaddrs.c index 50166da..6035724 100644 --- a/src/ddsrt/tests/ifaddrs.c +++ b/src/ddsrt/tests/ifaddrs.c @@ -64,7 +64,7 @@ CU_Clean(ddsrt_getifaddrs) IFF_LOOPBACK flags are properly set. */ CU_Test(ddsrt_getifaddrs, ipv4) { - dds_retcode_t ret; + dds_return_t ret; int seen = 0; ddsrt_ifaddrs_t *ifa_root, *ifa; const int afs[] = { AF_INET, DDSRT_AF_TERM }; @@ -90,7 +90,7 @@ CU_Test(ddsrt_getifaddrs, ipv4) CU_Test(ddsrt_getifaddrs, null_filter) { - dds_retcode_t ret; + dds_return_t ret; int cnt = 0; ddsrt_ifaddrs_t *ifa_root, *ifa; @@ -107,7 +107,7 @@ CU_Test(ddsrt_getifaddrs, null_filter) CU_Test(ddsrt_getifaddrs, empty_filter) { - dds_retcode_t ret; + dds_return_t ret; ddsrt_ifaddrs_t *ifa_root; const int afs[] = { DDSRT_AF_TERM }; @@ -121,7 +121,7 @@ CU_Test(ddsrt_getifaddrs, ipv6) { #ifdef DDSRT_HAVE_IPV6 if (ipv6_enabled == 1) { - dds_retcode_t ret; + dds_return_t ret; int have_ipv6 = 0; ddsrt_ifaddrs_t *ifa_root, *ifa; const int afs[] = { AF_INET6, DDSRT_AF_TERM }; @@ -160,7 +160,7 @@ CU_Test(ddsrt_getifaddrs, ipv4_n_ipv6) { #if DDSRT_HAVE_IPV6 if (ipv6_enabled == 1) { - dds_retcode_t ret; + dds_return_t ret; int have_ipv4 = 0; int have_ipv6 = 0; ddsrt_ifaddrs_t *ifa_root, *ifa; diff --git a/src/ddsrt/tests/log.c b/src/ddsrt/tests/log.c index a5e66cf..63c0438 100644 --- a/src/ddsrt/tests/log.c +++ b/src/ddsrt/tests/log.c @@ -349,7 +349,7 @@ CU_Test(dds_log, synchronous_sink_changes, .fini=reset) struct arg arg; ddsrt_thread_t tid; ddsrt_threadattr_t tattr; - dds_retcode_t ret; + dds_return_t ret; ddsrt_mutex_init(&mutex); ddsrt_cond_init(&cond); diff --git a/src/ddsrt/tests/process.c b/src/ddsrt/tests/process.c index c000cf7..90ac385 100644 --- a/src/ddsrt/tests/process.c +++ b/src/ddsrt/tests/process.c @@ -26,7 +26,7 @@ */ static void create_and_test_exit(const char *arg, int code) { - dds_retcode_t ret; + dds_return_t ret; ddsrt_pid_t pid; int32_t status; char *argv[] = { NULL, NULL }; @@ -64,7 +64,7 @@ CU_Test(ddsrt_process, create) */ CU_Test(ddsrt_process, kill) { - dds_retcode_t ret; + dds_return_t ret; ddsrt_pid_t pid; /* Sleep for 20 seconds. It should be killed before then. */ @@ -98,7 +98,7 @@ CU_Test(ddsrt_process, kill) */ CU_Test(ddsrt_process, pid) { - dds_retcode_t ret; + dds_return_t ret; ddsrt_pid_t pid; int32_t status; char *argv[] = { TEST_PID_ARG, NULL }; @@ -126,7 +126,7 @@ CU_Test(ddsrt_process, pid) */ CU_Test(ddsrt_process, env) { - dds_retcode_t ret; + dds_return_t ret; ret = ddsrt_setenv(TEST_ENV_VAR_NAME, TEST_ENV_VAR_VALUE); CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); @@ -141,7 +141,7 @@ CU_Test(ddsrt_process, env) */ CU_Test(ddsrt_process, invalid) { - dds_retcode_t ret; + dds_return_t ret; ddsrt_pid_t pid; ret = ddsrt_proc_create("ProbablyNotAnValidExecutable", NULL, &pid); @@ -177,7 +177,7 @@ CU_Test(ddsrt_process, arg_dquote) */ CU_Test(ddsrt_process, waitpids) { - dds_retcode_t ret; + dds_return_t ret; ddsrt_pid_t child; ddsrt_pid_t pid1 = 0; ddsrt_pid_t pid2 = 0; @@ -225,7 +225,7 @@ CU_Test(ddsrt_process, waitpids) */ CU_Test(ddsrt_process, waitpid_timeout) { - dds_retcode_t ret; + dds_return_t ret; ddsrt_pid_t pid; /* Sleep for 20 seconds. We should have a timeout before then. */ @@ -238,7 +238,7 @@ CU_Test(ddsrt_process, waitpid_timeout) ret = ddsrt_proc_waitpid(pid, 0, NULL); CU_ASSERT_EQUAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); - /* Valid timeout should return DDS_RETCODE_TIMEOUT when alive. */ + /* Valid timeout should return DDS_RETURN_TIMEOUT when alive. */ ret = ddsrt_proc_waitpid(pid, DDS_SECS(1), NULL); CU_ASSERT_EQUAL(ret, DDS_RETCODE_TIMEOUT); @@ -257,7 +257,7 @@ CU_Test(ddsrt_process, waitpid_timeout) */ CU_Test(ddsrt_process, waitpids_timeout) { - dds_retcode_t ret; + dds_return_t ret; ddsrt_pid_t pid; /* Sleep for 20 seconds. We should have a timeout before then. */ @@ -270,7 +270,7 @@ CU_Test(ddsrt_process, waitpids_timeout) ret = ddsrt_proc_waitpids(0, NULL, NULL); CU_ASSERT_EQUAL(ret, DDS_RETCODE_PRECONDITION_NOT_MET); - /* Valid timeout should return DDS_RETCODE_TIMEOUT when alive. */ + /* Valid timeout should return DDS_RETURN_TIMEOUT when alive. */ ret = ddsrt_proc_waitpids(DDS_SECS(1), NULL, NULL); CU_ASSERT_EQUAL(ret, DDS_RETCODE_TIMEOUT); diff --git a/src/ddsrt/tests/select.c b/src/ddsrt/tests/select.c index 7d99096..e23b261 100644 --- a/src/ddsrt/tests/select.c +++ b/src/ddsrt/tests/select.c @@ -107,7 +107,7 @@ typedef struct { static void sockets_pipe(ddsrt_socket_t socks[2]) { - dds_retcode_t rc; + dds_return_t rc; ddsrt_socket_t sock; int reuseaddr = 1; @@ -140,7 +140,7 @@ static const char mesg[] = "foobar"; static uint32_t select_timeout_routine(void *ptr) { int32_t cnt = -1; - dds_retcode_t rc; + dds_return_t rc; dds_time_t before, after; dds_duration_t delay; fd_set rdset; @@ -179,7 +179,7 @@ static uint32_t select_timeout_routine(void *ptr) CU_Test(ddsrt_select, timeout) { - dds_retcode_t rc; + dds_return_t rc; ddsrt_socket_t socks[2]; ddsrt_thread_t thr; ddsrt_threadattr_t attr; @@ -242,7 +242,7 @@ static uint32_t recv_routine(void *ptr) CU_Test(ddsrt_select, send_recv) { - dds_retcode_t rc; + dds_return_t rc; ddsrt_socket_t socks[2]; ddsrt_thread_t thr; ddsrt_threadattr_t attr; @@ -309,7 +309,7 @@ static uint32_t recvmsg_routine(void *ptr) CU_Test(ddsrt_select, sendmsg_recvmsg) { - dds_retcode_t rc; + dds_return_t rc; ddsrt_socket_t socks[2]; ddsrt_thread_t thr; ddsrt_threadattr_t attr; diff --git a/src/ddsrt/tests/socket.c b/src/ddsrt/tests/socket.c index 366c4b2..411524b 100644 --- a/src/ddsrt/tests/socket.c +++ b/src/ddsrt/tests/socket.c @@ -48,15 +48,15 @@ static void teardown(void) CU_Test(ddsrt_sockaddrfromstr, bad_family) { - dds_retcode_t rc; + dds_return_t rc; struct sockaddr_storage sa; rc = ddsrt_sockaddrfromstr(AF_UNSPEC, "127.0.0.1", &sa); CU_ASSERT_EQUAL(rc, DDS_RETCODE_BAD_PARAMETER); } -static void sockaddrfromstr_test(char *str, int af, dds_retcode_t exp) +static void sockaddrfromstr_test(char *str, int af, dds_return_t exp) { - dds_retcode_t rc; + dds_return_t rc; struct sockaddr_storage ss; rc = ddsrt_sockaddrfromstr(af, str, &ss); CU_ASSERT_EQUAL(rc, exp); @@ -70,11 +70,11 @@ CU_TheoryDataPoints(ddsrt_sockaddrfromstr, ipv4) = { "nip"), CU_DataPoints(int, AF_INET, AF_INET, AF_INET), - CU_DataPoints(dds_retcode_t, DDS_RETCODE_OK, DDS_RETCODE_OK, + CU_DataPoints(dds_return_t, DDS_RETCODE_OK, DDS_RETCODE_OK, DDS_RETCODE_BAD_PARAMETER) }; -CU_Theory((char *str, int af, dds_retcode_t exp), ddsrt_sockaddrfromstr, ipv4, .init=setup, .fini=teardown) +CU_Theory((char *str, int af, dds_return_t exp), ddsrt_sockaddrfromstr, ipv4, .init=setup, .fini=teardown) { sockaddrfromstr_test(str, af, exp); } @@ -87,13 +87,13 @@ CU_TheoryDataPoints(ddsrt_sockaddrfromstr, ipv6) = { CU_DataPoints(int, AF_INET6, AF_INET6, AF_INET, AF_INET6, AF_INET6), - CU_DataPoints(dds_retcode_t, DDS_RETCODE_BAD_PARAMETER, DDS_RETCODE_OK, + CU_DataPoints(dds_return_t, DDS_RETCODE_BAD_PARAMETER, DDS_RETCODE_OK, DDS_RETCODE_BAD_PARAMETER, DDS_RETCODE_OK, DDS_RETCODE_BAD_PARAMETER) #endif /* DDSRT_HAVE_IPV6 */ }; -CU_Theory((char *str, int af, dds_retcode_t exp), ddsrt_sockaddrfromstr, ipv6, .init=setup, .fini=teardown) +CU_Theory((char *str, int af, dds_return_t exp), ddsrt_sockaddrfromstr, ipv6, .init=setup, .fini=teardown) { #if DDSRT_HAVE_IPV6 sockaddrfromstr_test(str, af, exp); @@ -107,7 +107,7 @@ CU_Theory((char *str, int af, dds_retcode_t exp), ddsrt_sockaddrfromstr, ipv6, . CU_Test(ddsrt_sockaddrtostr, bad_sockaddr, .init=setup, .fini=teardown) { - dds_retcode_t rc; + dds_return_t rc; char buf[128] = { 0 }; struct sockaddr_in sa; memcpy(&sa, &ipv4_loopback, sizeof(ipv4_loopback)); @@ -118,7 +118,7 @@ CU_Test(ddsrt_sockaddrtostr, bad_sockaddr, .init=setup, .fini=teardown) CU_Test(ddsrt_sockaddrtostr, no_space, .init=setup, .fini=teardown) { - dds_retcode_t rc; + dds_return_t rc; char buf[1] = { 0 }; rc = ddsrt_sockaddrtostr(&ipv4_loopback, buf, sizeof(buf)); CU_ASSERT_EQUAL(rc, DDS_RETCODE_NOT_ENOUGH_SPACE); @@ -126,7 +126,7 @@ CU_Test(ddsrt_sockaddrtostr, no_space, .init=setup, .fini=teardown) CU_Test(ddsrt_sockaddrtostr, ipv4) { - dds_retcode_t rc; + dds_return_t rc; char buf[128] = { 0 }; rc = ddsrt_sockaddrtostr(&ipv4_loopback, buf, sizeof(buf)); CU_ASSERT_EQUAL(rc, DDS_RETCODE_OK); @@ -136,7 +136,7 @@ CU_Test(ddsrt_sockaddrtostr, ipv4) CU_Test(ddsrt_sockaddrtostr, ipv6) { #if DDSRT_HAVE_IPV6 - dds_retcode_t rc; + dds_return_t rc; char buf[128] = { 0 }; rc = ddsrt_sockaddrtostr(&ipv6_loopback, buf, sizeof(buf)); CU_ASSERT_EQUAL(rc, DDS_RETCODE_OK); @@ -148,7 +148,7 @@ CU_Test(ddsrt_sockaddrtostr, ipv6) CU_Test(ddsrt_sockets, gethostname) { - dds_retcode_t rc; + dds_return_t rc; char sysbuf[200], buf[200]; buf[0] = '\0'; @@ -169,9 +169,9 @@ CU_Test(ddsrt_sockets, gethostname) } #if DDSRT_HAVE_DNS -static void gethostbyname_test(char *name, int af, dds_retcode_t exp) +static void gethostbyname_test(char *name, int af, dds_return_t exp) { - dds_retcode_t rc; + dds_return_t rc; ddsrt_hostent_t *hent = NULL; rc = ddsrt_gethostbyname(name, af, &hent); CU_ASSERT_EQUAL(rc, exp); @@ -188,10 +188,10 @@ static void gethostbyname_test(char *name, int af, dds_retcode_t exp) CU_TheoryDataPoints(ddsrt_gethostbyname, ipv4) = { CU_DataPoints(char *, "", "127.0.0.1", "127.0.0.1"), CU_DataPoints(int, AF_UNSPEC, AF_INET, AF_UNSPEC), - CU_DataPoints(dds_retcode_t, DDS_RETCODE_HOST_NOT_FOUND, DDS_RETCODE_OK, DDS_RETCODE_OK) + CU_DataPoints(dds_return_t, DDS_RETCODE_HOST_NOT_FOUND, DDS_RETCODE_OK, DDS_RETCODE_OK) }; -CU_Theory((char *name, int af, dds_retcode_t exp), ddsrt_gethostbyname, ipv4, .init=setup, .fini=teardown) +CU_Theory((char *name, int af, dds_return_t exp), ddsrt_gethostbyname, ipv4, .init=setup, .fini=teardown) { #if DDSRT_HAVE_DNS gethostbyname_test(name, af, exp); @@ -209,11 +209,11 @@ CU_TheoryDataPoints(ddsrt_gethostbyname, ipv6) = { #if DDSRT_HAVE_IPV6 && DDSRT_HAVE_DNS CU_DataPoints(char *, "::1", "::1", "::1"), CU_DataPoints(int, AF_INET, AF_INET6, AF_UNSPEC), - CU_DataPoints(dds_retcode_t, DDS_RETCODE_HOST_NOT_FOUND, DDS_RETCODE_OK, DDS_RETCODE_OK) + CU_DataPoints(dds_return_t, DDS_RETCODE_HOST_NOT_FOUND, DDS_RETCODE_OK, DDS_RETCODE_OK) #endif /* DDSRT_HAVE_IPV6 */ }; -CU_Theory((char *name, int af, dds_retcode_t exp), ddsrt_gethostbyname, ipv6, .init=setup, .fini=teardown) +CU_Theory((char *name, int af, dds_return_t exp), ddsrt_gethostbyname, ipv6, .init=setup, .fini=teardown) { #if DDSRT_HAVE_IPV6 && DDSRT_HAVE_DNS gethostbyname_test(name, af, exp); diff --git a/src/ddsrt/tests/strtoll.c b/src/ddsrt/tests/strtoll.c index d22e813..525ddf1 100644 --- a/src/ddsrt/tests/strtoll.c +++ b/src/ddsrt/tests/strtoll.c @@ -52,7 +52,7 @@ CU_Clean(ddstr_strtoll) CU_Test(ddsrt_strtoll, strtoll) { - dds_retcode_t rc; + dds_return_t rc; long long ll; static char dummy[] = "dummy"; @@ -248,7 +248,7 @@ CU_Test(ddsrt_strtoll, strtoll) CU_Test(ddsrt_strtoll, strtoull) { - dds_retcode_t rc; + dds_return_t rc; unsigned long long ull; str = "0xffffffffffffffff"; @@ -272,7 +272,7 @@ CU_Test(ddsrt_strtoll, strtoull) CU_Test(ddsrt_strtoll, atoll) { - dds_retcode_t rc; + dds_return_t rc; long long ll; str = "10"; @@ -284,7 +284,7 @@ CU_Test(ddsrt_strtoll, atoll) CU_Test(ddsrt_strtoll, atoull) { - dds_retcode_t rc; + dds_return_t rc; unsigned long long ull; str = "10"; diff --git a/src/ddsrt/tests/sync.c b/src/ddsrt/tests/sync.c index d009353..e2b2cda 100644 --- a/src/ddsrt/tests/sync.c +++ b/src/ddsrt/tests/sync.c @@ -55,7 +55,7 @@ static uint32_t mutex_lock_routine(void *ptr) main thread before a lock operation is attempted by the second thread. */ CU_Test(ddsrt_sync, mutex_lock_conc) { - dds_retcode_t ret; + dds_return_t ret; ddsrt_thread_t thr; ddsrt_threadattr_t attr; thread_arg_t arg = { .cnt = DDSRT_ATOMIC_UINT32_INIT(0) }; @@ -133,7 +133,7 @@ static uint32_t rwlock_trywrite_routine(void *ptr) CU_Test(ddsrt_sync, mutex_trylock_conc) { - dds_retcode_t ret; + dds_return_t ret; ddsrt_thread_t thr; ddsrt_threadattr_t attr; thread_arg_t arg = { .cnt = DDSRT_ATOMIC_UINT32_INIT(1) }; @@ -164,7 +164,7 @@ CU_TheoryDataPoints(ddsrt_sync, rwlock_trylock_conc) = { CU_Theory((uint32_t lock, uint32_t trylock, uint32_t exp), ddsrt_sync, rwlock_trylock_conc) { - dds_retcode_t ret; + dds_return_t ret; ddsrt_thread_t thr; ddsrt_threadattr_t attr; ddsrt_thread_routine_t func; @@ -219,7 +219,7 @@ static uint32_t once_routine(void *ptr) CU_Test(ddsrt_sync, once_conc) { - dds_retcode_t ret; + dds_return_t ret; ddsrt_thread_t thrs[ONCE_THREADS]; ddsrt_threadattr_t attr; uint32_t res; @@ -284,7 +284,7 @@ static uint32_t waitfor_routine(void *ptr) CU_Test(ddsrt_sync, cond_waitfor) { - dds_retcode_t rc; + dds_return_t rc; ddsrt_thread_t thr; ddsrt_threadattr_t attr; thread_arg_t arg = { .cnt = DDSRT_ATOMIC_UINT32_INIT(0), .reltime = DDS_MSECS(100) }; @@ -333,7 +333,7 @@ static uint32_t waituntil_routine(void *ptr) CU_Test(ddsrt_sync, cond_waituntil) { - dds_retcode_t rc; + dds_return_t rc; dds_duration_t delay = DDS_MSECS(100); ddsrt_thread_t thr; ddsrt_threadattr_t attr; diff --git a/src/ddsrt/tests/thread.c b/src/ddsrt/tests/thread.c index 8814440..2e6b5d6 100644 --- a/src/ddsrt/tests/thread.c +++ b/src/ddsrt/tests/thread.c @@ -119,7 +119,7 @@ CU_Theory((ddsrt_sched_t sched, int32_t *prio, uint32_t exp), ddsrt_thread, crea { int skip = 0; uint32_t res = 50505; - dds_retcode_t ret; + dds_return_t ret; ddsrt_thread_t thr; ddsrt_threadattr_t attr; thread_arg_t arg; @@ -215,7 +215,7 @@ uint32_t thread_main_waitforit(void *ptr) CU_Test(ddsrt_thread, stacked_join) { - dds_retcode_t ret; + dds_return_t ret; ddsrt_thread_t thrs[2]; ddsrt_threadattr_t attr; uint32_t res = 0; diff --git a/src/ddsrt/tests/thread_cleanup.c b/src/ddsrt/tests/thread_cleanup.c index 4e9bf24..795819c 100644 --- a/src/ddsrt/tests/thread_cleanup.c +++ b/src/ddsrt/tests/thread_cleanup.c @@ -122,7 +122,7 @@ static void setup( struct thread_argument *arg) { - dds_retcode_t rc; + dds_return_t rc; ddsrt_thread_t thr; ddsrt_threadattr_t attr; diff --git a/src/examples/throughput/publisher.c b/src/examples/throughput/publisher.c index 5109d6b..bf1d20c 100644 --- a/src/examples/throughput/publisher.c +++ b/src/examples/throughput/publisher.c @@ -232,7 +232,7 @@ static void start_writing( if (burstCount < burstSize) { status = dds_write (writer, sample); - if (dds_err_nr(status) == DDS_RETCODE_TIMEOUT) + if (status == DDS_RETCODE_TIMEOUT) { timedOut = true; } @@ -285,7 +285,7 @@ static void start_writing( static void finalize_dds(dds_entity_t participant, dds_entity_t writer, ThroughputModule_DataType sample) { dds_return_t status = dds_dispose (writer, &sample); - if (dds_err_nr (status) != DDS_RETCODE_TIMEOUT && status < 0) + if (status != DDS_RETCODE_TIMEOUT && status < 0) DDS_FATAL("dds_dispose: %s\n", dds_strretcode(-status)); dds_free (sample.payload._buffer); diff --git a/src/mpt/mpt/src/main.c.in b/src/mpt/mpt/src/main.c.in index b48f3a6..5aa3580 100644 --- a/src/mpt/mpt/src/main.c.in +++ b/src/mpt/mpt/src/main.c.in @@ -298,7 +298,7 @@ mpt_run_test(const char *exe, mpt_suite_t *suite, mpt_test_t *test) { int result = EXIT_SUCCESS; mpt_process_t *proc; - dds_retcode_t retcode; + dds_return_t retcode; char *argv[] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }; argv[0] = "-s"; diff --git a/src/tools/ddsperf/ddsperf.c b/src/tools/ddsperf/ddsperf.c index d270095..eaaefc9 100644 --- a/src/tools/ddsperf/ddsperf.c +++ b/src/tools/ddsperf/ddsperf.c @@ -564,7 +564,7 @@ static uint32_t pubthread (void *varg) { printf ("write error: %d\n", result); fflush (stdout); - if (dds_err_nr (result) != DDS_RETCODE_TIMEOUT) + if (result != DDS_RETCODE_TIMEOUT) exit (2); timeouts++; /* retry with original timestamp, it really is just a way of reporting @@ -800,7 +800,7 @@ static bool process_data (dds_entity_t rd, struct subthread_arg *arg) if ((wr_pong = get_pong_writer (iseq[i].publication_handle)) != 0) { dds_return_t rc; - if ((rc = dds_write_ts (wr_pong, mseq[i], iseq[i].source_timestamp - 1)) < 0 && dds_err_nr(rc) != DDS_RETCODE_TIMEOUT) + if ((rc = dds_write_ts (wr_pong, mseq[i], iseq[i].source_timestamp - 1)) < 0 && rc != DDS_RETCODE_TIMEOUT) error2 ("dds_write_ts (wr_pong, mseq[i], iseq[i].source_timestamp): %d\n", (int) rc); dds_write_flush (wr_pong); } @@ -828,7 +828,7 @@ static bool process_ping (dds_entity_t rd, struct subthread_arg *arg) if ((wr_pong = get_pong_writer (iseq[i].publication_handle)) != 0) { dds_return_t rc; - if ((rc = dds_write_ts (wr_pong, mseq[i], iseq[i].source_timestamp | 1)) < 0 && dds_err_nr(rc) != DDS_RETCODE_TIMEOUT) + if ((rc = dds_write_ts (wr_pong, mseq[i], iseq[i].source_timestamp | 1)) < 0 && rc != DDS_RETCODE_TIMEOUT) error2 ("dds_write_ts (wr_pong, mseq[i], iseq[i].source_timestamp): %d\n", (int) rc); dds_write_flush (wr_pong); } @@ -863,7 +863,7 @@ static bool process_pong (dds_entity_t rd, struct subthread_arg *arg) cur_ping_time = dds_time (); cur_ping_seq = ++(*seq); ddsrt_mutex_unlock (&pongwr_lock); - if ((rc = dds_write_ts (wr_ping, mseq[i], dds_time () | 1)) < 0 && dds_err_nr(rc) != DDS_RETCODE_TIMEOUT) + if ((rc = dds_write_ts (wr_ping, mseq[i], dds_time () | 1)) < 0 && rc != DDS_RETCODE_TIMEOUT) error2 ("dds_write (wr_ping, mseq[i]): %d\n", (int) rc); dds_write_flush (wr_ping); } @@ -916,7 +916,7 @@ static void maybe_send_new_ping (dds_time_t tnow, dds_time_t *tnextping) cur_ping_seq++; baggage = init_sample (&data, cur_ping_seq); ddsrt_mutex_unlock (&pongwr_lock); - if ((rc = dds_write_ts (wr_ping, &data, dds_time () | 1)) < 0 && dds_err_nr (rc) != DDS_RETCODE_TIMEOUT) + if ((rc = dds_write_ts (wr_ping, &data, dds_time () | 1)) < 0 && rc != DDS_RETCODE_TIMEOUT) error2 ("send_new_ping: dds_write (wr_ping, &data): %d\n", (int) rc); dds_write_flush (wr_ping); if (baggage) diff --git a/src/tools/pubsub/common.h b/src/tools/pubsub/common.h index e4a0b5f..1beca88 100644 --- a/src/tools/pubsub/common.h +++ b/src/tools/pubsub/common.h @@ -119,7 +119,7 @@ bool dds_err_check (dds_return_t err, unsigned flags, const char *where); #define DDS_CHECK_FAIL 0x02 #define DDS_CHECK_EXIT 0x04 -#define dds_err_str(x) (dds_strretcode(dds_err_nr(x))) +#define dds_err_str(x) (dds_strretcode(x)) #define DDS_TO_STRING(n) #n #define DDS_INT_TO_STRING(n) DDS_TO_STRING(n) diff --git a/src/tools/pubsub/pubsub.c b/src/tools/pubsub/pubsub.c index e775f10..60f9fc6 100644 --- a/src/tools/pubsub/pubsub.c +++ b/src/tools/pubsub/pubsub.c @@ -2792,7 +2792,7 @@ int main(int argc, char *argv[]) { ddsrt_threadattr_t attr; ddsrt_threadattr_init(&attr); - dds_retcode_t osres; + dds_return_t osres; if (want_writer) { for (i = 0; i <= specidx; i++) {