Hi Vu,
here is one small example on one way how to implement:
#include <iostream>
#include <functional>
// only to illustrate, the existing SAF C functions with dummy arguments
#include <stdio.h>
extern "C" int saImmOmInitialize(int i) {
printf("foo1 called, i = %d\n", i);
return 2;
}
extern "C" int saImmOmSelectionObjectGet(int i, const char* str) {
printf("foo2 called, i = %d, str = %s\n", i, str);
return 3;
}
//
template <typename> struct Decorator;
template <typename T, class... Args>
struct Decorator<T(Args ...)> {
Decorator(std::function<T(Args ...)> f) : f_(f) {}
T operator()(Args ... args) {
std::cout << "Call the decorated function" << std::endl;
int rc = f_(args...);
std::cout << "return code is " << rc << std::endl;
std::cout << "add all common retry logic here, etc " << std::endl;
return rc;
}
std::function<T(Args ...)> f_;
};
template<typename T, class... Args>
Decorator<T(Args...)> make_decorator(T (*f)(Args ...)) {
return Decorator<T(Args...)>(std::function<T(Args...)>(f));
}
int main() {
int rc = 0;
auto foo1 = make_decorator(saImmOmInitialize);
rc = foo1(4711);
std::cout << "rc: " << rc << std::endl;
auto foo2 = make_decorator(saImmOmSelectionObjectGet);
rc = foo2(4712, "hello world!");
std::cout << "rc: " << rc << std::endl;
return 0;
}
/Hans
________________________________
Från: Vu Minh Nguyen <vu.m.ngu...@dektech.com.au>
Skickat: den 1 november 2017 12:11:40
Till: Hans Nordebäck; Anders Widell
Kopia: opensaf-devel@lists.sourceforge.net
Ämne: RE: [PATCH 1/1] clm: wrapper CLM APIs with try_again handle inside [#2634]
Hi Hans,
Thanks for your comments and proposal.
I will think about that and send prototype code when done.
Regards, Vu
> -----Original Message-----
> From: Hans Nordebäck [mailto:hans.nordeb...@ericsson.com]
> Sent: Tuesday, October 31, 2017 4:41 PM
> To: Vu Minh Nguyen <vu.m.ngu...@dektech.com.au>;
> anders.wid...@ericsson.com
> Cc: opensaf-devel@lists.sourceforge.net
> Subject: Re: [PATCH 1/1] clm: wrapper CLM APIs with try_again handle inside
> [#2634]
>
> Hi Vu,
>
> I think it would be good if we can align this with the style of the
> Pyhton decorators in pyosaf/utils, now there is a lot of redundant code and
>
> it should be possible to have e.g. one C++ object for each function
> where just the function pointer is unique and the code is shared/common.
>
> /Regards Hans
>
>
> On 10/19/2017 06:45 AM, Vu Minh Nguyen wrote:
> > All calls to CLM APIs in clmtest do not handle SA_AIS_ERR_TRY_AGAIN.
> > Running clmtest sometimes get failed because of this miss.
> >
> > Create wrappers which handling try again error code inside.
> > ---
> > src/clm/Makefile.am | 4 +-
> > src/clm/apitest/clm_util.c | 385
> > +++++++++++++++++++++
> > src/clm/apitest/clm_util.h | 114 ++++++
> > src/clm/apitest/clmtest.h | 1 +
> > src/clm/apitest/tet_ClmLongRdn.c | 34 +-
> > src/clm/apitest/tet_saClmClusterNodeGet.c | 113 +++---
> > src/clm/apitest/tet_saClmClusterNodeGetAsync.c | 105 +++---
> > src/clm/apitest/tet_saClmClusterNotificationFree.c | 19 +-
> > src/clm/apitest/tet_saClmClusterTrack.c | 307 ++++++++--------
> > src/clm/apitest/tet_saClmClusterTrackStop.c | 29 +-
> > src/clm/apitest/tet_saClmDispatch.c | 29 +-
> > src/clm/apitest/tet_saClmFinalize.c | 17 +-
> > src/clm/apitest/tet_saClmInitialize.c | 76 ++--
> > src/clm/apitest/tet_saClmResponse.c | 59 ++--
> > src/clm/apitest/tet_saClmSelectionObjectGet.c | 25 +-
> > 15 files changed, 907 insertions(+), 410 deletions(-)
> > create mode 100644 src/clm/apitest/clm_util.c
> > create mode 100644 src/clm/apitest/clm_util.h
> >
> > diff --git a/src/clm/Makefile.am b/src/clm/Makefile.am
> > index 884e39b..2340a9b 100644
> > --- a/src/clm/Makefile.am
> > +++ b/src/clm/Makefile.am
> > @@ -183,7 +183,8 @@ if ENABLE_TESTS
> > bin_PROGRAMS += bin/clmtest
> >
> > noinst_HEADERS += \
> > - src/clm/apitest/clmtest.h
> > + src/clm/apitest/clmtest.h \
> > + src/clm/apitest/clm_util.h
> >
> > bin_clmtest_CPPFLAGS = \
> > -DSA_CLM_B01=1 \
> > @@ -191,6 +192,7 @@ bin_clmtest_CPPFLAGS = \
> >
> > bin_clmtest_SOURCES = \
> > src/clm/apitest/clmtest.c \
> > + src/clm/apitest/clm_util.c \
> > src/clm/apitest/tet_saClmInitialize.c \
> > src/clm/apitest/tet_saClmClusterNodeGetAsync.c \
> > src/clm/apitest/tet_saClmClusterTrack.c \
> > diff --git a/src/clm/apitest/clm_util.c b/src/clm/apitest/clm_util.c
> > new file mode 100644
> > index 0000000..3b2baf3
> > --- /dev/null
> > +++ b/src/clm/apitest/clm_util.c
> > @@ -0,0 +1,385 @@
> > +/* -*- OpenSAF -*-
> > + *
> > + * Copyright Ericsson AB 2017 - All Rights Reserved.
> > + *
> > + * This program is distributed in the hope that it will be useful, but
> > + * WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY
> > + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are
> licensed
> > + * under the GNU Lesser General Public License Version 2.1, February
> 1999.
> > + * The complete license can be accessed from the following location:
> > + * http://opensource.org/licenses/lgpl-license.php
> > + * See the Copying file included with the OpenSAF distribution for full
> > + * licensing terms.
> > + *
> > + */
> > +
> > +#include "clm_util.h"
> > +#include "base/osaf_time.h"
> > +
> > +struct RetryControl {
> > + // Sleep time b/w retries
> > + struct timespec interval;
> > + // Maximum time for retries (ms)
> > + uint64_t timeout;
> > +};
> > +
> > +static struct RetryControl retry_ctrl = {
> > + .interval = {0, 40*1000*1000}, // 40ms
> > + .timeout = 10*1000 // 10ms
> > +};
> > +
> > +#if defined(SA_CLM_B01) || defined(SA_CLM_B02)
> > +SaAisErrorT clmutil_saClmInitialize(
> > + SaClmHandleT *handle,
> > + const SaClmCallbacksT *cbs,
> > + SaVersionT *version)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + SaVersionT ver;
> > + struct timespec timeout;
> > +
> > + // Avoid coredump when user passes NULL to version.
> > + if (version) ver = *version;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &timeout);
> > + while (osaf_timeout_time_left(&timeout)) {
> > + ais_rc = saClmInitialize(handle, cbs, version ? &ver : NULL);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + if (version) ver = *version;
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +
> > +#endif
> > +
> > +#ifdef SA_CLM_B03
> > +SaAisErrorT clmutil_saClmInitialize_3(
> > + SaClmHandleT *handle,
> > + const SaClmCallbacksT_3 *cbs,
> > + SaVersionT *version)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + SaVersionT ver;
> > + struct timespec timeout;
> > +
> > + // Avoid coredump when user passes NULL to version.
> > + if (version) ver = *version;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &timeout);
> > + while (osaf_timeout_time_left(&timeout)) {
> > + ais_rc = saClmInitialize_3(handle, cbs, version ? &ver : NULL);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + if (version) ver = *version;
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +#endif
> > +
> > +SaAisErrorT clmutil_saClmInitialize_4(
> > + SaClmHandleT *handle,
> > + const SaClmCallbacksT_4 *cbs,
> > + SaVersionT *version)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + SaVersionT ver;
> > + struct timespec timeout;
> > +
> > + // Avoid coredump when user passes NULL to version.
> > + if (version) ver = *version;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &timeout);
> > + while (osaf_timeout_time_left(&timeout)) {
> > + ais_rc = saClmInitialize_4(handle, cbs, version ? &ver : NULL);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + ver = *version;
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +
> > +SaAisErrorT clmutil_saClmSelectionObjectGet(
> > + SaClmHandleT handle,
> > + SaSelectionObjectT *selectionObject)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + struct timespec timeout;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &timeout);
> > + while (osaf_timeout_time_left(&timeout)) {
> > + ais_rc = saClmSelectionObjectGet(handle, selectionObject);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +
> > +SaAisErrorT clmutil_saClmDispatch(
> > + SaClmHandleT handle,
> > + SaDispatchFlagsT dispatchFlags)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + struct timespec timeout;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &timeout);
> > + while (osaf_timeout_time_left(&timeout)) {
> > + ais_rc = saClmDispatch(handle, dispatchFlags);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +
> > +SaAisErrorT clmutil_saClmFinalize(
> > + SaClmHandleT handle)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + struct timespec timeout;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &timeout);
> > + while (osaf_timeout_time_left(&timeout)) {
> > + ais_rc = saClmFinalize(handle);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +
> > +#if defined(SA_CLM_B01) || defined(SA_CLM_B02) ||
> defined(SA_CLM_B03)
> > +SaAisErrorT clmutil_saClmClusterTrack(
> > + SaClmHandleT handle,
> > + SaUint8T trackFlags,
> > + SaClmClusterNotificationBufferT *buffer)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + struct timespec timeout;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &timeout);
> > + while (osaf_timeout_time_left(&timeout)) {
> > + ais_rc = saClmClusterTrack(handle, trackFlags, buffer);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +
> > +SaAisErrorT clmutil_saClmClusterNodeGet(
> > + SaClmHandleT handle,
> > + SaClmNodeIdT nodeId,
> > + SaTimeT timeout,
> > + SaClmClusterNodeT *clNode)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + struct timespec tout;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &tout);
> > + while (osaf_timeout_time_left(&tout)) {
> > + ais_rc = saClmClusterNodeGet(handle, nodeId, timeout,
> clNode);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +#endif
> > +
> > +#if defined(SA_CLM_B02) || defined(SA_CLM_B03)
> > +SaAisErrorT clmutil_saClmClusterNotificationFree(
> > + SaClmHandleT handle,
> > + SaClmClusterNotificationT *notification)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + struct timespec timeout;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &timeout);
> > + while (osaf_timeout_time_left(&timeout)) {
> > + ais_rc = saClmClusterNotificationFree(handle, notification);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +#endif
> > +
> > +#ifdef SA_CLM_B03
> > +SaAisErrorT clmutil_saClmResponse(
> > + SaClmHandleT handle,
> > + SaInvocationT invocation,
> > + SaAisErrorT error)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + struct timespec timeout;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &timeout);
> > + while (osaf_timeout_time_left(&timeout)) {
> > + ais_rc = saClmResponse(handle, invocation, error);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +#endif
> > +
> > +SaAisErrorT clmutil_saClmClusterTrack_4(
> > + SaClmHandleT handle,
> > + SaUint8T trackFlags,
> > + SaClmClusterNotificationBufferT_4 *buffer)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + struct timespec timeout;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &timeout);
> > + while (osaf_timeout_time_left(&timeout)) {
> > + ais_rc = saClmClusterTrack_4(handle, trackFlags, buffer);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +
> > +SaAisErrorT clmutil_saClmClusterTrackStop(
> > + SaClmHandleT handle)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + struct timespec timeout;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &timeout);
> > + while (osaf_timeout_time_left(&timeout)) {
> > + ais_rc = saClmClusterTrackStop(handle);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +
> > +SaAisErrorT clmutil_saClmClusterNotificationFree_4(
> > + SaClmHandleT handle,
> > + SaClmClusterNotificationT_4 *notification)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + struct timespec timeout;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &timeout);
> > + while (osaf_timeout_time_left(&timeout)) {
> > + ais_rc = saClmClusterNotificationFree_4(handle,
> notification);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +
> > +SaAisErrorT clmutil_saClmClusterNodeGet_4(
> > + SaClmHandleT handle,
> > + SaClmNodeIdT nodeId,
> > + SaTimeT timeout,
> > + SaClmClusterNodeT_4 *clNode)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + struct timespec tout;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &tout);
> > + while (osaf_timeout_time_left(&tout)) {
> > + ais_rc = saClmClusterNodeGet_4(handle, nodeId, timeout,
> clNode);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +
> > +SaAisErrorT clmutil_saClmClusterNodeGetAsync(
> > + SaClmHandleT handle,
> > + SaInvocationT invocation,
> > + SaClmNodeIdT nodeId)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + struct timespec timeout;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &timeout);
> > + while (osaf_timeout_time_left(&timeout)) {
> > + ais_rc = saClmClusterNodeGetAsync(handle, invocation,
> nodeId);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > +
> > +SaAisErrorT clmutil_saClmResponse_4(
> > + SaClmHandleT handle,
> > + SaInvocationT invocation,
> > + SaClmResponseT response)
> > +{
> > + SaAisErrorT ais_rc = SA_AIS_OK;
> > + struct timespec timeout;
> > +
> > + osaf_set_millis_timeout(retry_ctrl.timeout, &timeout);
> > + while (osaf_timeout_time_left(&timeout)) {
> > + ais_rc = saClmResponse_4(handle, invocation, response);
> > + if (ais_rc == SA_AIS_ERR_TRY_AGAIN) {
> > + osaf_nanosleep(&retry_ctrl.interval);
> > + continue;
> > + }
> > + break;
> > + }
> > +
> > + return ais_rc;
> > +}
> > diff --git a/src/clm/apitest/clm_util.h b/src/clm/apitest/clm_util.h
> > new file mode 100644
> > index 0000000..cdff1e8
> > --- /dev/null
> > +++ b/src/clm/apitest/clm_util.h
> > @@ -0,0 +1,114 @@
> > +/* -*- OpenSAF -*-
> > + *
> > + * Copyright Ericsson AB 2017 - All Rights Reserved.
> > + *
> > + * This program is distributed in the hope that it will be useful, but
> > + * WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY
> > + * or FITNESS FOR A PARTICULAR PURPOSE. This file and program are
> licensed
> > + * under the GNU Lesser General Public License Version 2.1, February
> 1999.
> > + * The complete license can be accessed from the following location:
> > + * http://opensource.org/licenses/lgpl-license.php
> > + * See the Copying file included with the OpenSAF distribution for full
> > + * licensing terms.
> > + *
> > + */
> > +
> > +#ifndef CLM_APITEST_CLM_UTIL_H_
> > +#define CLM_APITEST_CLM_UTIL_H_
> > +
> > +#include "ais/include/saClm.h"
> > +
> > +#ifdef __cplusplus
> > +extern "C" {
> > +#endif
> > +
> > +#if defined(SA_CLM_B01) || defined(SA_CLM_B02)
> > +SaAisErrorT clmutil_saClmInitialize(
> > + SaClmHandleT *clmHandle,
> > + const SaClmCallbacksT *clmCallbacks,
> > + SaVersionT *version);
> > +#endif /* SA_CLM_B01 || SA_CLM_B02 */
> > +
> > +#ifdef SA_CLM_B03
> > +SaAisErrorT clmutil_saClmInitialize_3(
> > + SaClmHandleT *clmHandle,
> > + const SaClmCallbacksT_3 *clmCallbacks,
> > + SaVersionT *version);
> > +#endif /* SA_CLM_B03 */
> > +
> > +SaAisErrorT clmutil_saClmInitialize_4(
> > + SaClmHandleT *clmHandle,
> > + const SaClmCallbacksT_4 *clmCallbacks,
> > + SaVersionT *version);
> > +
> > +
> > +SaAisErrorT clmutil_saClmSelectionObjectGet(
> > + SaClmHandleT clmHandle,
> > + SaSelectionObjectT *selectionObject);
> > +
> > +SaAisErrorT clmutil_saClmDispatch(
> > + SaClmHandleT clmHandle,
> > + SaDispatchFlagsT dispatchFlags);
> > +
> > +SaAisErrorT clmutil_saClmFinalize(
> > + SaClmHandleT clmHandle);
> > +
> > +#if defined(SA_CLM_B01) || defined(SA_CLM_B02) ||
> defined(SA_CLM_B03)
> > +SaAisErrorT clmutil_saClmClusterTrack(
> > + SaClmHandleT clmHandle,
> > + SaUint8T trackFlags,
> > + SaClmClusterNotificationBufferT *notificationBuffer);
> > +
> > +SaAisErrorT clmutil_saClmClusterNodeGet(
> > + SaClmHandleT clmHandle,
> > + SaClmNodeIdT nodeId,
> > + SaTimeT timeout,
> > + SaClmClusterNodeT *clusterNode);
> > +#endif /* SA_CLM_B01 || SA_CLM_B02 || SA_CLM_B03 */
> > +
> > +#if defined(SA_CLM_B02) || defined(SA_CLM_B03)
> > +SaAisErrorT clmutil_saClmClusterNotificationFree(
> > + SaClmHandleT clmHandle,
> > + SaClmClusterNotificationT *notification);
> > +#endif /* SA_CLM_B02 || SA_CLM_B03 */
> > +
> > +#ifdef SA_CLM_B03
> > +SaAisErrorT clmutil_saClmResponse(
> > + SaClmHandleT clmHandle,
> > + SaInvocationT invocation,
> > + SaAisErrorT error);
> > +#endif /* SA_CLM_B03 */
> > +
> > +SaAisErrorT clmutil_saClmClusterTrack_4(
> > + SaClmHandleT clmHandle,
> > + SaUint8T trackFlags,
> > + SaClmClusterNotificationBufferT_4 *notificationBuffer);
> > +
> > +SaAisErrorT clmutil_saClmClusterTrackStop(
> > + SaClmHandleT clmHandle);
> > +
> > +SaAisErrorT clmutil_saClmClusterNotificationFree_4(
> > + SaClmHandleT clmHandle,
> > + SaClmClusterNotificationT_4 *notification);
> > +
> > +SaAisErrorT clmutil_saClmClusterNodeGet_4(
> > + SaClmHandleT clmHandle,
> > + SaClmNodeIdT nodeId,
> > + SaTimeT timeout,
> > + SaClmClusterNodeT_4 *clusterNode);
> > +
> > +SaAisErrorT clmutil_saClmClusterNodeGetAsync(
> > + SaClmHandleT clmHandle,
> > + SaInvocationT invocation,
> > + SaClmNodeIdT nodeId);
> > +
> > +SaAisErrorT clmutil_saClmResponse_4(
> > + SaClmHandleT clmHandle,
> > + SaInvocationT invocation,
> > + SaClmResponseT response);
> > +
> > +#ifdef __cplusplus
> > +}
> > +#endif
> > +
> > +#endif //< CLM_APITEST_CLM_UTIL_H_
> > diff --git a/src/clm/apitest/clmtest.h b/src/clm/apitest/clmtest.h
> > index 02449a0..a34e823 100644
> > --- a/src/clm/apitest/clmtest.h
> > +++ b/src/clm/apitest/clmtest.h
> > @@ -26,6 +26,7 @@
> > #include <assert.h>
> > #include "osaf/apitest/utest.h"
> > #include "osaf/apitest/util.h"
> > +#include "clm_util.h"
> > #include <poll.h>
> > #include <unistd.h>
> >
> > diff --git a/src/clm/apitest/tet_ClmLongRdn.c
> b/src/clm/apitest/tet_ClmLongRdn.c
> > index 53e6c1d..12ea770 100644
> > --- a/src/clm/apitest/tet_ClmLongRdn.c
> > +++ b/src/clm/apitest/tet_ClmLongRdn.c
> > @@ -307,13 +307,13 @@ void saClmLongRdn_02(void)
> > return;
> > }
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > if (rc != SA_AIS_OK) {
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > // Failed at saClmClusterTrack_4
> > test_validate(rc, SA_AIS_OK);
> > return;
> > @@ -336,9 +336,9 @@ void saClmLongRdn_02(void)
> > break;
> > }
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(s_clmTrackCallback_err, SA_AIS_OK);
> >
> > unlock_node(nodeName);
> > @@ -362,13 +362,13 @@ void saClmLongRdn_03(void)
> > return;
> > }
> >
> > - safassert(saClmInitialize(&clmHandle, &clmCallback,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallback,
> &clmVersion_1),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, NULL);
> > if (rc != SA_AIS_OK) {
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > // Failed at saClmClusterTrack
> > test_validate(rc, SA_AIS_OK);
> > return;
> > @@ -391,9 +391,9 @@ void saClmLongRdn_03(void)
> > break;
> > }
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(s_clmTrackCallback_err, SA_AIS_OK);
> >
> > unlock_node(nodeName);
> > @@ -467,10 +467,10 @@ void saClmLongRdn_05(void)
> > nodeId = getClmNodeId(nodeName);
> > assert(nodeId != 0);
> >
> > - safassert(saClmInitialize_4(&clmHandle, NULL, &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, NULL,
> &clmVersion_4),
> > SA_AIS_OK);
> >
> > - rc = saClmClusterNodeGet_4(clmHandle, nodeId, 10000000000ll,
> > + rc = clmutil_saClmClusterNodeGet_4(clmHandle, nodeId,
> 10000000000ll,
> > &clusterNode);
> >
> > // SaNameT value cannot be longer than 255, so we don't need to
> use
> > @@ -506,7 +506,7 @@ void saClmLongRdn_06(void)
> > nodeId = getClmNodeId(nodeName);
> > assert(nodeId != 0);
> >
> > - safassert(saClmInitialize(&clmHandle, NULL, &clmVersion_1),
> SA_AIS_OK);
> > + safassert(clmutil_saClmInitialize(&clmHandle, NULL,
> &clmVersion_1), SA_AIS_OK);
> >
> > rc =
> > saClmClusterNodeGet(clmHandle, nodeId, 10000000000ll,
> &clusterNode);
> > diff --git a/src/clm/apitest/tet_saClmClusterNodeGet.c
> b/src/clm/apitest/tet_saClmClusterNodeGet.c
> > index c26939d..84a8e05 100644
> > --- a/src/clm/apitest/tet_saClmClusterNodeGet.c
> > +++ b/src/clm/apitest/tet_saClmClusterNodeGet.c
> > @@ -1,6 +1,7 @@
> > /* -*- OpenSAF -*-
> > *
> > * (C) Copyright 13134308 The OpenSAF Foundation
> > + * Copyright Ericsson AB 2017 - All Rights Reserved.
> > *
> > * This program is distributed in the hope that it will be useful, but
> > * WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY
> > @@ -25,120 +26,120 @@ SaTimeT timeout = 10000000000ll;
> > void saClmClusterNodeGet_01(void)
> > {
> > nodeId = 131343;
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet(clmHandle, nodeId, timeout,
> &clusterNode_1);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet(clmHandle, nodeId, timeout,
> &clusterNode_1);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > void saClmClusterNodeGet_02(void)
> > {
> > nodeId = 131343;
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet_4(clmHandle, nodeId, timeout,
> &clusterNode_4);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet_4(clmHandle, nodeId, timeout,
> &clusterNode_4);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > void saClmClusterNodeGet_03(void)
> > {
> > nodeId = 131343;
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet(0, nodeId, timeout, &clusterNode_1);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet(0, nodeId, timeout,
> &clusterNode_1);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> >
> > nodeId = 131343;
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet(-1, nodeId, timeout, &clusterNode_1);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet(-1, nodeId, timeout,
> &clusterNode_1);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> >
> > nodeId = 131343;
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet_4(0, nodeId, timeout, &clusterNode_4);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet_4(0, nodeId, timeout,
> &clusterNode_4);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> >
> > nodeId = 131343;
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet_4(-1, nodeId, timeout, &clusterNode_4);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet_4(-1, nodeId, timeout,
> &clusterNode_4);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> > }
> >
> > void saClmClusterNodeGet_04(void)
> > {
> > nodeId = 131343;
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet(clmHandle, nodeId, 0, &clusterNode_1);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet(clmHandle, nodeId, 0,
> &clusterNode_1);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> >
> > nodeId = 131343;
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet_4(clmHandle, nodeId, 0,
> &clusterNode_4);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet_4(clmHandle, nodeId, 0,
> &clusterNode_4);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > void saClmClusterNodeGet_05(void)
> > {
> > nodeId = 131343;
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet(clmHandle, nodeId, timeout, NULL);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet(clmHandle, nodeId, timeout,
> NULL);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> >
> > nodeId = 131343;
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet_4(clmHandle, nodeId, timeout, NULL);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet_4(clmHandle, nodeId, timeout,
> NULL);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> > }
> >
> > void saClmClusterNodeGet_06(void)
> > {
> > nodeId = 255; /*node does not exist*/
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet(clmHandle, nodeId, timeout,
> &clusterNode_1);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet(clmHandle, nodeId, timeout,
> &clusterNode_1);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_NOT_EXIST);
> >
> > nodeId = 255;
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet_4(clmHandle, nodeId, timeout,
> &clusterNode_4);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet_4(clmHandle, nodeId, timeout,
> &clusterNode_4);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_NOT_EXIST);
> > }
> >
> > void saClmClusterNodeGet_07(void)
> > {
> > nodeId = 170255; /*node is non member, 0x2990F*/
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet(clmHandle, nodeId, timeout,
> &clusterNode_1);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet(clmHandle, nodeId, timeout,
> &clusterNode_1);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > /*test_validate(rc, SA_AIS_ERR_UNAVAILABLE);*/
> > test_validate(rc, SA_AIS_ERR_NOT_EXIST);
> >
> > nodeId = 170255;
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet_4(clmHandle, nodeId, timeout,
> &clusterNode_4);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet_4(clmHandle, nodeId, timeout,
> &clusterNode_4);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > /*test_validate(rc, SA_AIS_ERR_UNAVAILABLE);*/
> > test_validate(rc, SA_AIS_ERR_NOT_EXIST);
> > }
> > @@ -146,36 +147,36 @@ void saClmClusterNodeGet_07(void)
> > void saClmClusterNodeGet_08(void)
> > {
> > nodeId = 5;
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet_4(clmHandle, nodeId, timeout,
> &clusterNode_4);
> > - /*rc = saClmClusterNodeGet(clmHandle, nodeId, timeout, NULL);*/
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet_4(clmHandle, nodeId, timeout,
> &clusterNode_4);
> > + /*rc = clmutil_saClmClusterNodeGet(clmHandle, nodeId, timeout,
> NULL);*/
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_VERSION);
> >
> > nodeId = 5;
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet(clmHandle, nodeId, timeout,
> &clusterNode_1);
> > - /*rc = saClmClusterNodeGet(clmHandle, nodeId, timeout, NULL);*/
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGet(clmHandle, nodeId, timeout,
> &clusterNode_1);
> > + /*rc = clmutil_saClmClusterNodeGet(clmHandle, nodeId, timeout,
> NULL);*/
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_VERSION);
> > }
> >
> > void saClmClusterNodeGet_09(void)
> > {
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet(clmHandle, SA_CLM_LOCAL_NODE_ID,
> timeout,
> > + rc = clmutil_saClmClusterNodeGet(clmHandle,
> SA_CLM_LOCAL_NODE_ID, timeout,
> > &clusterNode_1);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGet_4(clmHandle, SA_CLM_LOCAL_NODE_ID,
> timeout,
> > + rc = clmutil_saClmClusterNodeGet_4(clmHandle,
> SA_CLM_LOCAL_NODE_ID, timeout,
> > &clusterNode_4);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > diff --git a/src/clm/apitest/tet_saClmClusterNodeGetAsync.c
> b/src/clm/apitest/tet_saClmClusterNodeGetAsync.c
> > index cb7290a..0562c90 100644
> > --- a/src/clm/apitest/tet_saClmClusterNodeGetAsync.c
> > +++ b/src/clm/apitest/tet_saClmClusterNodeGetAsync.c
> > @@ -1,6 +1,7 @@
> > /* -*- OpenSAF -*-
> > *
> > * (C) Copyright 13134308 The OpenSAF Foundation
> > + * Copyright Ericsson AB 2017 - All Rights Reserved.
> > *
> > * This program is distributed in the hope that it will be useful, but
> > * WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY
> > @@ -47,19 +48,19 @@ void saClmClusterNodeGetAsync_01(void)
> > invocation = 600;
> > SaAisErrorT rc;
> >
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGetAsync(clmHandle, invocation, nodeId);
> > + rc = clmutil_saClmClusterNodeGetAsync(clmHandle, invocation,
> nodeId);
> > /*
> > fds[0].fd = (int) selectionObject;
> > fds[0].events = POLLIN;
> > ret = poll(fds, 1, 1000);
> > assert(ret == 1);
> > */
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -71,19 +72,19 @@ void saClmClusterNodeGetAsync_02(void)
> > invocation = 700;
> > SaAisErrorT rc;
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGetAsync(clmHandle, invocation, nodeId);
> > + rc = clmutil_saClmClusterNodeGetAsync(clmHandle, invocation,
> nodeId);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > ret = poll(fds, 1, 1000);
> > assert(ret == 1);
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -91,28 +92,28 @@ void saClmClusterNodeGetAsync_03(void)
> > {
> > nodeId = 131343;
> > invocation = 300;
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGetAsync(0, invocation, nodeId);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGetAsync(0, invocation, nodeId);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> >
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGetAsync(-1, invocation, nodeId);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGetAsync(-1, invocation, nodeId);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGetAsync(0, invocation, nodeId);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGetAsync(0, invocation, nodeId);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGetAsync(-1, invocation, nodeId);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGetAsync(-1, invocation, nodeId);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> > }
> >
> > @@ -120,10 +121,10 @@ void saClmClusterNodeGetAsync_04(void)
> > {
> > nodeId = 131343;
> > invocation = 400;
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGetAsync(clmHandle, 0, nodeId);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGetAsync(clmHandle, 0, nodeId);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> > }
> >
> > @@ -131,10 +132,10 @@ void saClmClusterNodeGetAsync_05(void)
> > {
> > nodeId = 131343;
> > invocation = 500;
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGetAsync(clmHandle, invocation, 0);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterNodeGetAsync(clmHandle, invocation, 0);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> > }
> > void saClmClusterNodeGetAsync_06(void)
> > @@ -145,19 +146,19 @@ void saClmClusterNodeGetAsync_06(void)
> > invocation = 600;
> > SaAisErrorT rc;
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGetAsync(clmHandle, invocation, nodeId);
> > + rc = clmutil_saClmClusterNodeGetAsync(clmHandle, invocation,
> nodeId);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > ret = poll(fds, 1, 1000);
> > assert(ret == 1);
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -168,18 +169,18 @@ void saClmClusterNodeGetAsync_07(void)
> >
> > nodeId = 131855; /*node is non member*/
> > invocation = 700;
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGetAsync(clmHandle, invocation, nodeId);
> > + rc = clmutil_saClmClusterNodeGetAsync(clmHandle, invocation,
> nodeId);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > ret = poll(fds, 1, 1000);
> > assert(ret == 1);
> >
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -189,11 +190,11 @@ void saClmClusterNodeGetAsync_08(void)
> > SaAisErrorT rc;
> > int ret;
> > invocation = 900;
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGetAsync(clmHandle, invocation,
> > + rc = clmutil_saClmClusterNodeGetAsync(clmHandle, invocation,
> > SA_CLM_LOCAL_NODE_ID);
> >
> > fds[0].fd = (int)selectionObject;
> > @@ -201,8 +202,8 @@ void saClmClusterNodeGetAsync_08(void)
> > ret = poll(fds, 1, 1000);
> > assert(ret == 1);
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -214,33 +215,33 @@ void saClmClusterNodeGetAsync_09(void)
> > invocation = 600;
> > SaAisErrorT rc;
> >
> > - safassert(saClmInitialize(&clmHandle, NULL, &clmVersion_1),
> SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmInitialize(&clmHandle, NULL,
> &clmVersion_1), SA_AIS_OK);
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGetAsync(clmHandle, invocation, nodeId);
> > + rc = clmutil_saClmClusterNodeGetAsync(clmHandle, invocation,
> nodeId);
> > /*
> > fds[0].fd = (int) selectionObject;
> > fds[0].events = POLLIN;
> > ret = poll(fds, 1, 1000);
> > assert(ret == 1);
> > */
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_INIT);
> >
> > - safassert(saClmInitialize_4(&clmHandle, NULL, &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, NULL,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterNodeGetAsync(clmHandle, invocation, nodeId);
> > + rc = clmutil_saClmClusterNodeGetAsync(clmHandle, invocation,
> nodeId);
> > /*
> > fds[0].fd = (int) selectionObject;
> > fds[0].events = POLLIN;
> > ret = poll(fds, 1, 1000);
> > assert(ret == 1);
> > */
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_INIT);
> > }
> >
> > diff --git a/src/clm/apitest/tet_saClmClusterNotificationFree.c
> b/src/clm/apitest/tet_saClmClusterNotificationFree.c
> > index 22faf15..a799e48 100644
> > --- a/src/clm/apitest/tet_saClmClusterNotificationFree.c
> > +++ b/src/clm/apitest/tet_saClmClusterNotificationFree.c
> > @@ -1,6 +1,7 @@
> > /* -*- OpenSAF -*-
> > *
> > * (C) Copyright 2008 The OpenSAF Foundation
> > + * Copyright Ericsson AB 2017 - All Rights Reserved.
> > *
> > * This program is distributed in the hope that it will be useful, but
> > * WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY
> > @@ -26,12 +27,12 @@ void saClmClusterNotificationFree_01(void)
> > sizeof(SaClmClusterNotificationT_4) *
> > notificationBuffer_4.numberOfItems);
> >
> > - safassert(saClmInitialize_4(&clmHandle, NULL, &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, NULL,
> &clmVersion_4),
> > SA_AIS_OK);
> >
> > - rc = saClmClusterNotificationFree_4(clmHandle,
> > + rc = clmutil_saClmClusterNotificationFree_4(clmHandle,
> > notificationBuffer_4.notification);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -43,11 +44,11 @@ void saClmClusterNotificationFree_02(void)
> > sizeof(SaClmClusterNotificationT_4) *
> > notificationBuffer_4.numberOfItems);
> >
> > - safassert(saClmInitialize(&clmHandle, NULL, &clmVersion_1),
> SA_AIS_OK);
> > + safassert(clmutil_saClmInitialize(&clmHandle, NULL,
> &clmVersion_1), SA_AIS_OK);
> >
> > - rc = saClmClusterNotificationFree_4(clmHandle,
> > + rc = clmutil_saClmClusterNotificationFree_4(clmHandle,
> > notificationBuffer_4.notification);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_VERSION);
> > }
> >
> > @@ -59,10 +60,10 @@ void saClmClusterNotificationFree_03(void)
> > sizeof(SaClmClusterNotificationT_4) *
> > notificationBuffer_4.numberOfItems);
> >
> > - rc = saClmClusterNotificationFree_4(0,
> > + rc = clmutil_saClmClusterNotificationFree_4(0,
> > notificationBuffer_4.notification);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> > - rc = saClmClusterNotificationFree_4(clmHandle, NULL);
> > + rc = clmutil_saClmClusterNotificationFree_4(clmHandle, NULL);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> > }
> >
> > @@ -74,7 +75,7 @@ void saClmClusterNotificationFree_04(void)
> > sizeof(SaClmClusterNotificationT_4) *
> > notificationBuffer_4.numberOfItems);
> >
> > - rc = saClmClusterNotificationFree_4(-1,
> > + rc = clmutil_saClmClusterNotificationFree_4(-1,
> > notificationBuffer_4.notification);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> > }
> > diff --git a/src/clm/apitest/tet_saClmClusterTrack.c
> b/src/clm/apitest/tet_saClmClusterTrack.c
> > index 8a8ca89..cbbe728 100644
> > --- a/src/clm/apitest/tet_saClmClusterTrack.c
> > +++ b/src/clm/apitest/tet_saClmClusterTrack.c
> > @@ -1,6 +1,7 @@
> > /* -*- OpenSAF -*-
> > *
> > * (C) Copyright 2008 The OpenSAF Foundation
> > + * Copyright Ericsson AB 2017 - All Rights Reserved.
> > *
> > * This program is distributed in the hope that it will be useful, but
> > * WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY
> > @@ -253,13 +254,13 @@ void saClmClusterTrack_01(void)
> > sizeof(SaClmClusterNotificationT) *
> > notificationBuffer_1.numberOfItems);
> >
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack(clmHandle, trackFlags,
> ¬ificationBuffer_1);
> > + rc = clmutil_saClmClusterTrack(clmHandle, trackFlags,
> ¬ificationBuffer_1);
> > printf("rc = %u", rc);
> > - safassert(saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > free(notificationBuffer_1.notification);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -272,15 +273,15 @@ void saClmClusterTrack_02(void)
> > sizeof(SaClmClusterNotificationT_4) *
> > notificationBuffer_4.numberOfItems);
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags,
> ¬ificationBuffer_4);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags,
> ¬ificationBuffer_4);
> > clmTrackbuf_4(¬ificationBuffer_4);
> > - safassert(saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > - safassert(saClmClusterNotificationFree_4(
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > + safassert(clmutil_saClmClusterNotificationFree_4(
> > clmHandle, notificationBuffer_4.notification),
> > SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -292,12 +293,12 @@ void saClmClusterTrack_03(void)
> > sizeof(SaClmClusterNotificationT) *
> > notificationBuffer_1.numberOfItems);
> >
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack(clmHandle, trackFlags,
> ¬ificationBuffer_1);
> > - safassert(saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > + rc = clmutil_saClmClusterTrack(clmHandle, trackFlags,
> ¬ificationBuffer_1);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > free(notificationBuffer_1.notification);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -310,15 +311,15 @@ void saClmClusterTrack_04(void)
> > sizeof(SaClmClusterNotificationT_4) *
> > notificationBuffer_4.numberOfItems);
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags,
> ¬ificationBuffer_4);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags,
> ¬ificationBuffer_4);
> > clmTrackbuf_4(¬ificationBuffer_4);
> > - safassert(saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > - safassert(saClmClusterNotificationFree_4(
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > + safassert(clmutil_saClmClusterNotificationFree_4(
> > clmHandle, notificationBuffer_4.notification),
> > SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -330,12 +331,12 @@ void saClmClusterTrack_05(void)
> > sizeof(SaClmClusterNotificationT) *
> > notificationBuffer_1.numberOfItems);
> >
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack(0, trackFlags, ¬ificationBuffer_1);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > + rc = clmutil_saClmClusterTrack(0, trackFlags, ¬ificationBuffer_1);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > free(notificationBuffer_1.notification);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> >
> > trackFlags = (SA_TRACK_CURRENT | SA_TRACK_LOCAL);
> > @@ -344,12 +345,12 @@ void saClmClusterTrack_05(void)
> > sizeof(SaClmClusterNotificationT) *
> > notificationBuffer_1.numberOfItems);
> >
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack(-1, trackFlags, ¬ificationBuffer_1);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > + rc = clmutil_saClmClusterTrack(-1, trackFlags,
> ¬ificationBuffer_1);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > free(notificationBuffer_1.notification);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> > }
> >
> > @@ -361,12 +362,12 @@ void saClmClusterTrack_06(void)
> > sizeof(SaClmClusterNotificationT) *
> > notificationBuffer_1.numberOfItems);
> >
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack(clmHandle, 0, ¬ificationBuffer_1);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > + rc = clmutil_saClmClusterTrack(clmHandle, 0, ¬ificationBuffer_1);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > free(notificationBuffer_1.notification);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_FLAGS);
> > }
> >
> > @@ -378,15 +379,15 @@ void saClmClusterTrack_07(void)
> > sizeof(SaClmClusterNotificationT) *
> > notificationBuffer_1.numberOfItems);
> >
> > - /*safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + /*safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > * SA_AIS_OK);*/
> > - safassert(saClmInitialize(&clmHandle, NULL, &clmVersion_1),
> SA_AIS_OK);
> > - /*rc = saClmClusterTrack(clmHandle, trackFlags,
> ¬ificationBuffer_1);
> > + safassert(clmutil_saClmInitialize(&clmHandle, NULL,
> &clmVersion_1), SA_AIS_OK);
> > + /*rc = clmutil_saClmClusterTrack(clmHandle, trackFlags,
> ¬ificationBuffer_1);
> > */
> > - rc = saClmClusterTrack(clmHandle, trackFlags, NULL);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > + rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, NULL);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > free(notificationBuffer_1.notification);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_INIT);
> > }
> >
> > @@ -399,14 +400,14 @@ void saClmClusterTrack_08(void)
> > sizeof(SaClmClusterNotificationT_4) *
> > notificationBuffer_4.numberOfItems);
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(0, trackFlags, ¬ificationBuffer_4);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > - safassert(saClmClusterNotificationFree_4(
> > + rc = clmutil_saClmClusterTrack_4(0, trackFlags,
> ¬ificationBuffer_4);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > + safassert(clmutil_saClmClusterNotificationFree_4(
> > clmHandle, notificationBuffer_4.notification),
> > SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> >
> > trackFlags = (SA_TRACK_CURRENT | SA_TRACK_LOCAL);
> > @@ -416,14 +417,14 @@ void saClmClusterTrack_08(void)
> > sizeof(SaClmClusterNotificationT_4) *
> > notificationBuffer_4.numberOfItems);
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(-1, trackFlags, ¬ificationBuffer_4);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > - safassert(saClmClusterNotificationFree_4(
> > + rc = clmutil_saClmClusterTrack_4(-1, trackFlags,
> ¬ificationBuffer_4);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > + safassert(clmutil_saClmClusterNotificationFree_4(
> > clmHandle, notificationBuffer_4.notification),
> > SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> > }
> >
> > @@ -436,14 +437,14 @@ void saClmClusterTrack_09(void)
> > sizeof(SaClmClusterNotificationT_4) *
> > notificationBuffer_4.numberOfItems);
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, 0, ¬ificationBuffer_4);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > - safassert(saClmClusterNotificationFree_4(
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, 0,
> ¬ificationBuffer_4);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > + safassert(clmutil_saClmClusterNotificationFree_4(
> > clmHandle, notificationBuffer_4.notification),
> > SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_FLAGS);
> > }
> >
> > @@ -456,14 +457,14 @@ void saClmClusterTrack_10(void)
> > sizeof(SaClmClusterNotificationT_4) *
> > notificationBuffer_4.numberOfItems);
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > - safassert(saClmClusterNotificationFree_4(
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > + safassert(clmutil_saClmClusterNotificationFree_4(
> > clmHandle, notificationBuffer_4.notification),
> > SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_INIT);
> > }
> >
> > @@ -476,12 +477,12 @@ void saClmClusterTrack_11(void)
> > sizeof(SaClmClusterNotificationT_4) *
> > notificationBuffer_1.numberOfItems);
> >
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags,
> ¬ificationBuffer_4);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags,
> ¬ificationBuffer_4);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > free(notificationBuffer_4.notification);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_VERSION);
> > }
> >
> > @@ -493,24 +494,24 @@ void saClmClusterTrack_12(void)
> > sizeof(SaClmClusterNotificationT) *
> > notificationBuffer_1.numberOfItems);
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack(clmHandle, trackFlags,
> ¬ificationBuffer_1);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > + rc = clmutil_saClmClusterTrack(clmHandle, trackFlags,
> ¬ificationBuffer_1);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > free(notificationBuffer_1.notification);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_VERSION);
> > }
> >
> > void saClmClusterTrack_13(void)
> > {
> > trackFlags = SA_TRACK_CURRENT;
> > - safassert(saClmInitialize(&clmHandle, &clmCallback1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallback1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack(clmHandle, trackFlags, NULL);
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, NULL);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -520,20 +521,20 @@ void saClmClusterTrack_14(void)
> > struct pollfd fds[1];
> > int ret;
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > ret = poll(fds, 1, 3000);
> > assert(ret == 1);
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -541,11 +542,11 @@ void saClmClusterTrack_14(void)
> > void saClmClusterTrack_15(void)
> > {
> > trackFlags = SA_TRACK_START_STEP;
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_FLAGS);
> > }
> >
> > @@ -553,11 +554,11 @@ void saClmClusterTrack_15(void)
> > void saClmClusterTrack_16(void)
> > {
> > trackFlags = SA_TRACK_VALIDATE_STEP;
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_FLAGS);
> > }
> >
> > @@ -565,22 +566,22 @@ void saClmClusterTrack_16(void)
> > void saClmClusterTrack_17(void)
> > {
> > trackFlags = SA_TRACK_CHANGES | SA_TRACK_CHANGES_ONLY;
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_FLAGS);
> > }
> > /*Bad Flags - only start step without changes/changes only for old API's*/
> > void saClmClusterTrack_18(void)
> > {
> > trackFlags = SA_TRACK_START_STEP;
> > - safassert(saClmInitialize(&clmHandle, &clmCallback1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallback1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack(clmHandle, trackFlags, NULL);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, NULL);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_FLAGS);
> > }
> >
> > @@ -588,11 +589,11 @@ void saClmClusterTrack_18(void)
> > void saClmClusterTrack_19(void)
> > {
> > trackFlags = SA_TRACK_VALIDATE_STEP;
> > - safassert(saClmInitialize(&clmHandle, &clmCallback1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallback1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack(clmHandle, trackFlags, NULL);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, NULL);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_FLAGS);
> > }
> >
> > @@ -600,11 +601,11 @@ void saClmClusterTrack_19(void)
> > void saClmClusterTrack_20(void)
> > {
> > trackFlags = SA_TRACK_CHANGES | SA_TRACK_CHANGES_ONLY;
> > - safassert(saClmInitialize(&clmHandle, &clmCallback1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallback1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack(clmHandle, trackFlags, NULL);
> > - /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, NULL);
> > + /*safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_OK);*/
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_FLAGS);
> > }
> >
> > @@ -616,11 +617,11 @@ void saClmClusterTrack_21(void)
> >
> > trackFlags = SA_TRACK_CHANGES_ONLY;
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > @@ -637,9 +638,9 @@ void saClmClusterTrack_21(void)
> > break;
> > }
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> >
> > // Reset CLM state
> > @@ -657,11 +658,11 @@ void saClmClusterTrack_22(void)
> >
> > trackFlags = SA_TRACK_CHANGES_ONLY;
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > @@ -677,9 +678,9 @@ void saClmClusterTrack_22(void)
> > break;
> > }
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -691,11 +692,11 @@ void saClmClusterTrack_23(void)
> >
> > trackFlags = SA_TRACK_CHANGES;
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > @@ -711,9 +712,9 @@ void saClmClusterTrack_23(void)
> > break;
> > }
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> >
> > // Reset CLM state
> > @@ -728,11 +729,11 @@ void saClmClusterTrack_24(void)
> >
> > trackFlags = SA_TRACK_CHANGES | SA_TRACK_START_STEP;
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > @@ -747,7 +748,7 @@ void saClmClusterTrack_24(void)
> > break;
> > }
> > }
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > safassert(
> > saClmResponse_4(clmHandle, lock_inv,
> SA_CLM_CALLBACK_RESPONSE_OK),
> > SA_AIS_OK);
> > @@ -762,10 +763,10 @@ void saClmClusterTrack_24(void)
> > }
> > }
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> >
> > - safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> >
> > // Reset CLM state
> > @@ -780,11 +781,11 @@ void saClmClusterTrack_25(void)
> >
> > trackFlags = SA_TRACK_CHANGES_ONLY | SA_TRACK_START_STEP;
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > @@ -800,7 +801,7 @@ void saClmClusterTrack_25(void)
> > break;
> > }
> > }
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > safassert(
> > saClmResponse_4(clmHandle, lock_inv,
> SA_CLM_CALLBACK_RESPONSE_OK),
> > SA_AIS_OK);
> > @@ -815,10 +816,10 @@ void saClmClusterTrack_25(void)
> > }
> > }
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> >
> > - safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> >
> > // Reset CLM state
> > @@ -833,11 +834,11 @@ void saClmClusterTrack_27(void)
> >
> > trackFlags = SA_TRACK_CHANGES_ONLY | SA_TRACK_START_STEP;
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > @@ -853,7 +854,7 @@ void saClmClusterTrack_27(void)
> > break;
> > }
> > }
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > safassert(
> > saClmResponse_4(clmHandle, lock_inv,
> SA_CLM_CALLBACK_RESPONSE_OK),
> > SA_AIS_OK);
> > @@ -868,10 +869,10 @@ void saClmClusterTrack_27(void)
> > }
> > }
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> >
> > - safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> >
> > // Reset CLM state
> > @@ -885,11 +886,11 @@ void saClmClusterTrack_28(void)
> >
> > trackFlags = SA_TRACK_CHANGES | SA_TRACK_START_STEP;
> >
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > @@ -905,7 +906,7 @@ void saClmClusterTrack_28(void)
> > break;
> > }
> > }
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > safassert(
> > saClmResponse_4(clmHandle, lock_inv,
> SA_CLM_CALLBACK_RESPONSE_OK),
> > SA_AIS_OK);
> > @@ -920,10 +921,10 @@ void saClmClusterTrack_28(void)
> > }
> > }
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> >
> > - safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> >
> > // Reset CLM state
> > @@ -943,11 +944,11 @@ void saClmClusterTrack_31(void)
> > printf("This test case can run only if PLM is enabled in the
> > system\n");
> > fflush(stdout);
> > return;
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > @@ -966,7 +967,7 @@ void saClmClusterTrack_31(void)
> > break;
> > }
> > }
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > safassert(
> > saClmResponse_4(clmHandle, lock_inv,
> SA_CLM_CALLBACK_RESPONSE_OK),
> > SA_AIS_OK);
> > @@ -985,7 +986,7 @@ void saClmClusterTrack_31(void)
> > }
> > }
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > safassert(
> > saClmResponse_4(clmHandle, lock_inv,
> SA_CLM_CALLBACK_RESPONSE_OK),
> > SA_AIS_OK);
> > @@ -1003,9 +1004,9 @@ void saClmClusterTrack_31(void)
> > break;
> > }
> > }
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > diff --git a/src/clm/apitest/tet_saClmClusterTrackStop.c
> b/src/clm/apitest/tet_saClmClusterTrackStop.c
> > index 0904561..a806b8b 100644
> > --- a/src/clm/apitest/tet_saClmClusterTrackStop.c
> > +++ b/src/clm/apitest/tet_saClmClusterTrackStop.c
> > @@ -1,6 +1,7 @@
> > /* -*- OpenSAF -*-
> > *
> > * (C) Copyright 2008 The OpenSAF Foundation
> > + * Copyright Ericsson AB 2017 - All Rights Reserved.
> > *
> > * This program is distributed in the hope that it will be useful, but
> > * WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY
> > @@ -69,26 +70,26 @@ void saClmClusterTrackStop_01(void)
> > trackFlags = SA_TRACK_CURRENT;
> > nodeId = 131343;
> > invocation = 600;
> > - safassert(saClmInitialize(&clmHandle, &clmCallback11,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallback11,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack(clmHandle, trackFlags, NULL);
> > - rc = saClmClusterTrack(clmHandle, trackFlags, NULL);
> > - rc = saClmClusterNodeGetAsync(clmHandle, invocation, nodeId);
> > - rc = saClmClusterTrack(clmHandle, trackFlags, NULL);
> > - rc = saClmClusterNodeGetAsync(clmHandle, invocation, nodeId);
> > - rc = saClmClusterNodeGetAsync(clmHandle, invocation, nodeId);
> > - rc = saClmClusterTrack(clmHandle, trackFlags, NULL);
> > - safassert(saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - rc = saClmClusterTrack(clmHandle, trackFlags, NULL);
> > - safassert(saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterNodeGetAsync(clmHandle, invocation,
> nodeId);
> > + rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterNodeGetAsync(clmHandle, invocation,
> nodeId);
> > + rc = clmutil_saClmClusterNodeGetAsync(clmHandle, invocation,
> nodeId);
> > + rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, NULL);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, NULL);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle),
> SA_AIS_ERR_NOT_EXIST);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > void saClmClusterTrackStop_02(void)
> > {
> > - rc = saClmClusterTrackStop(clmHandle);
> > + rc = clmutil_saClmClusterTrackStop(clmHandle);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> > }
> >
> > diff --git a/src/clm/apitest/tet_saClmDispatch.c
> b/src/clm/apitest/tet_saClmDispatch.c
> > index c0772b2..159d20a 100644
> > --- a/src/clm/apitest/tet_saClmDispatch.c
> > +++ b/src/clm/apitest/tet_saClmDispatch.c
> > @@ -1,6 +1,7 @@
> > /* -*- OpenSAF -*-
> > *
> > * (C) Copyright 2008 The OpenSAF Foundation
> > + * Copyright Ericsson AB 2017 - All Rights Reserved.
> > *
> > * This program is distributed in the hope that it will be useful, but
> > * WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY
> > @@ -36,11 +37,11 @@ void saClmDispatch_01(void)
> > invocation = 600;
> > SaAisErrorT rc;
> >
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks,
> &clmVersion_1),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - safassert(saClmClusterNodeGetAsync(clmHandle, invocation,
> nodeId),
> > + safassert(clmutil_saClmClusterNodeGetAsync(clmHandle, invocation,
> nodeId),
> > SA_AIS_OK);
> >
> > fds[0].fd = (int)selectionObject;
> > @@ -48,23 +49,23 @@ void saClmDispatch_01(void)
> > ret = poll(fds, 1, 1000);
> > assert(ret == 1);
> >
> > - rc = saClmDispatch(clmHandle, SA_DISPATCH_ALL);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > void saClmDispatch_02(void)
> > {
> > - rc = saClmDispatch(0, SA_DISPATCH_ALL);
> > + rc = clmutil_saClmDispatch(0, SA_DISPATCH_ALL);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> > }
> >
> > void saClmDispatch_03(void)
> > {
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmDispatch(clmHandle, 0);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmDispatch(clmHandle, 0);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> > }
> >
> > @@ -76,11 +77,11 @@ void saClmDispatch_04(void)
> > invocation = 600;
> > SaAisErrorT rc;
> >
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks,
> &clmVersion_1),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - safassert(saClmClusterNodeGetAsync(clmHandle, invocation,
> nodeId),
> > + safassert(clmutil_saClmClusterNodeGetAsync(clmHandle, invocation,
> nodeId),
> > SA_AIS_OK);
> >
> > fds[0].fd = (int)selectionObject;
> > @@ -88,8 +89,8 @@ void saClmDispatch_04(void)
> > ret = poll(fds, 1, 1000);
> > assert(ret == 1);
> >
> > - rc = saClmDispatch(clmHandle, SA_DISPATCH_ONE);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ONE);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > diff --git a/src/clm/apitest/tet_saClmFinalize.c
> b/src/clm/apitest/tet_saClmFinalize.c
> > index 3b2a8dc..80ff61f 100644
> > --- a/src/clm/apitest/tet_saClmFinalize.c
> > +++ b/src/clm/apitest/tet_saClmFinalize.c
> > @@ -1,6 +1,7 @@
> > /* -*- OpenSAF -*-
> > *
> > * (C) Copyright 2008 The OpenSAF Foundation
> > + * Copyright Ericsson AB 2017 - All Rights Reserved.
> > *
> > * This program is distributed in the hope that it will be useful, but
> > * WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY
> > @@ -18,28 +19,28 @@
> >
> > void saClmFinalize_01(void)
> > {
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmFinalize(clmHandle);
> > + rc = clmutil_saClmFinalize(clmHandle);
> > test_validate(rc, SA_AIS_OK);
> > - safassert(saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmFinalize(clmHandle);
> > + rc = clmutil_saClmFinalize(clmHandle);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > void saClmFinalize_02(void)
> > {
> > - rc = saClmFinalize(-1);
> > + rc = clmutil_saClmFinalize(-1);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> > }
> >
> > void saClmFinalize_03(void)
> > {
> > - safassert(saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1),
> > SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > - rc = saClmFinalize(clmHandle);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmFinalize(clmHandle);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> > }
> >
> > diff --git a/src/clm/apitest/tet_saClmInitialize.c
> b/src/clm/apitest/tet_saClmInitialize.c
> > index 3922abb..7fca6b4 100644
> > --- a/src/clm/apitest/tet_saClmInitialize.c
> > +++ b/src/clm/apitest/tet_saClmInitialize.c
> > @@ -1,6 +1,7 @@
> > /* -*- OpenSAF -*-
> > *
> > * (C) Copyright 2008 The OpenSAF Foundation
> > + * Copyright Ericsson AB 2017 - All Rights Reserved.
> > *
> > * This program is distributed in the hope that it will be useful, but
> > * WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY
> > @@ -19,58 +20,58 @@
> >
> > void saClmInitialize_01(void)
> > {
> > - rc = saClmInitialize(&clmHandle, &clmCallbacks_1, &clmVersion_1);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > void saClmInitialize_02(void)
> > {
> > - rc = saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > void saClmInitialize_03(void)
> > {
> > - rc = saClmInitialize(NULL, &clmCallbacks_1, &clmVersion_1);
> > + rc = clmutil_saClmInitialize(NULL, &clmCallbacks_1, &clmVersion_1);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> > }
> >
> > void saClmInitialize_04(void)
> > {
> > - rc = saClmInitialize_4(NULL, &clmCallbacks_4, &clmVersion_4);
> > + rc = clmutil_saClmInitialize_4(NULL, &clmCallbacks_4,
> &clmVersion_4);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> > }
> >
> > void saClmInitialize_05(void)
> > {
> > - rc = saClmInitialize(&clmHandle, NULL, &clmVersion_1);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmInitialize(&clmHandle, NULL, &clmVersion_1);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > void saClmInitialize_06(void)
> > {
> > - rc = saClmInitialize_4(&clmHandle, NULL, &clmVersion_4);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmInitialize_4(&clmHandle, NULL, &clmVersion_4);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > void saClmInitialize_07(void)
> > {
> > - rc = saClmInitialize(&clmHandle, NULL, NULL);
> > + rc = clmutil_saClmInitialize(&clmHandle, NULL, NULL);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> > - rc = saClmInitialize_4(&clmHandle, NULL, NULL);
> > + rc = clmutil_saClmInitialize_4(&clmHandle, NULL, NULL);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> > }
> >
> > void saClmInitialize_08(void)
> > {
> > SaVersionT version1, version4;
> > - rc = saClmInitialize(&clmHandle, &clmCallbacks_1, &version1);
> > + rc = clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &version1);
> > test_validate(rc, SA_AIS_ERR_VERSION);
> > - rc = saClmInitialize_4(&clmHandle, &clmCallbacks_4, &version4);
> > + rc = clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &version4);
> > test_validate(rc, SA_AIS_ERR_VERSION);
> > }
> >
> > @@ -78,9 +79,9 @@ void saClmInitialize_09(void)
> > {
> > SaVersionT version1 = {'C', 1, 1};
> > SaVersionT version4 = {'C', 1, 1};
> > - rc = saClmInitialize(&clmHandle, &clmCallbacks_1, &version1);
> > + rc = clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &version1);
> > test_validate(rc, SA_AIS_ERR_VERSION);
> > - rc = saClmInitialize_4(&clmHandle, &clmCallbacks_4, &version4);
> > + rc = clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &version4);
> > test_validate(rc, SA_AIS_ERR_VERSION);
> > }
> >
> > @@ -88,21 +89,21 @@ void saClmInitialize_10(void)
> > {
> > SaVersionT version1 = {'B', 5, 1};
> > SaVersionT version4 = {'B', 5, 1};
> > - rc = saClmInitialize(&clmHandle, &clmCallbacks_1, &version1);
> > + rc = clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &version1);
> > test_validate(rc, SA_AIS_ERR_VERSION);
> > - rc = saClmInitialize_4(&clmHandle, &clmCallbacks_4, &version4);
> > + rc = clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &version4);
> > test_validate(rc, SA_AIS_ERR_VERSION);
> > }
> >
> > void saClmInitialize_11(void)
> > {
> > clmVersion_1.minorVersion--;
> > - rc = saClmInitialize(&clmHandle, &clmCallbacks_1, &clmVersion_1);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &clmVersion_1);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > clmVersion_4.minorVersion--;
> > - rc = saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &clmVersion_4);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -110,9 +111,9 @@ void saClmInitialize_12(void)
> > {
> > SaVersionT version1 = {'B', 0, 0};
> > SaVersionT version4 = {'B', 0, 0};
> > - rc = saClmInitialize(&clmHandle, &clmCallbacks_1, &version1);
> > + rc = clmutil_saClmInitialize(&clmHandle, &clmCallbacks_1,
> &version1);
> > test_validate(rc, SA_AIS_ERR_VERSION);
> > - rc = saClmInitialize_4(&clmHandle, &clmCallbacks_4, &version4);
> > + rc = clmutil_saClmInitialize_4(&clmHandle, &clmCallbacks_4,
> &version4);
> > test_validate(rc, SA_AIS_ERR_VERSION);
> > }
> >
> > @@ -120,29 +121,14 @@ void saClmInitialize_12(void)
> > void saClmInitialize_13(void)
> > {
> > SaClmHandleT clmHandle1, clmHandle2, clmHandle3;
> > - rc = saClmInitialize(&clmHandle1, &clmCallbacks_1, &clmVersion_1);
> > - rc = saClmInitialize(&clmHandle2, &clmCallbacks_1, &clmVersion_1);
> > - rc = saClmInitialize(&clmHandle3, &clmCallbacks_1, &clmVersion_1);
> > - safassert(saClmFinalize(clmHandle1), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle2), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle3), SA_AIS_OK);
> > + rc = clmutil_saClmInitialize(&clmHandle1, &clmCallbacks_1,
> &clmVersion_1);
> > + rc = clmutil_saClmInitialize(&clmHandle2, &clmCallbacks_1,
> &clmVersion_1);
> > + rc = clmutil_saClmInitialize(&clmHandle3, &clmCallbacks_1,
> &clmVersion_1);
> > + safassert(clmutil_saClmFinalize(clmHandle1), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle2), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle3), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> > -#if 0
> > -void saClmInitialize_13(void)
> > - rc = saClmInitialize(&clmHandle, &clmCallbacks_1, &clmVersion_1);
> > - test_validate(rc, SA_AIS_ERR_LIBRARY);
> > - rc = saClmInitialize_4(&clmHandle, &clmCallbacks_4, &clmVersion_4);
> > - test_validate(rc, SA_AIS_ERR_LIBRARY);
> > -}
> > -
> > -void saClmInitialize_14(void)
> > - rc = saClmInitialize(&clmHandle, &clmCallbacks_1, &clmVersion_1);
> > - test_validate(rc, SA_AIS_ERR_TRY_AGAIN);
> > - rc = saClmInitialize_4(&clmHandle, &clmCallbacks_4, &clmVersion_4);
> > - test_validate(rc, SA_AIS_ERR_TRY_AGAIN);
> > -}
> > -#endif
> >
> > __attribute__((constructor)) static void saNtfInitialize_constructor(void)
> > {
> > diff --git a/src/clm/apitest/tet_saClmResponse.c
> b/src/clm/apitest/tet_saClmResponse.c
> > index af40e32..ec8ba0f 100644
> > --- a/src/clm/apitest/tet_saClmResponse.c
> > +++ b/src/clm/apitest/tet_saClmResponse.c
> > @@ -1,6 +1,7 @@
> > /* -*- OpenSAF -*-
> > *
> > * (C) Copyright 2008 The OpenSAF Foundation
> > + * Copyright Ericsson AB 2017 - All Rights Reserved.
> > *
> > * This program is distributed in the hope that it will be useful, but
> > * WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY
> > @@ -111,11 +112,11 @@ void saClmResponse_01(void)
> > trackFlags = SA_TRACK_CHANGES | SA_TRACK_START_STEP;
> > printf(" This test case needs (manual) admin op simulation\n");
> > return; /* uncomment this and run*/
> > - safassert(saClmInitialize_4(&clmHandle, &Callback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &Callback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > @@ -125,7 +126,7 @@ void saClmResponse_01(void)
> > break;
> > }
> > }
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > safassert(
> > saClmResponse_4(clmHandle, lock_inv,
> SA_CLM_CALLBACK_RESPONSE_OK),
> > SA_AIS_OK);
> > @@ -139,10 +140,10 @@ void saClmResponse_01(void)
> > }
> > }
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> >
> > - safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -154,11 +155,11 @@ void saClmResponse_02(void)
> > printf("This test case needs (manual) admin op simulation\n");
> > return; /* uncomment this and run*/
> >
> > - safassert(saClmInitialize_4(&clmHandle, &Callback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &Callback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > @@ -168,8 +169,8 @@ void saClmResponse_02(void)
> > break;
> > }
> > }
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmResponse_4(clmHandle, lock_inv,
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmResponse_4(clmHandle, lock_inv,
> > SA_CLM_CALLBACK_RESPONSE_ERROR),
> > SA_AIS_OK);
> >
> > @@ -182,10 +183,10 @@ void saClmResponse_02(void)
> > }
> > }
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> >
> > - safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -198,11 +199,11 @@ void saClmResponse_03(void)
> > printf("This test case needs (manual) admin op simulation\n");
> > return; /* uncomment this and run*/
> >
> > - safassert(saClmInitialize_4(&clmHandle, &Callback4,
> &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, &Callback4,
> &clmVersion_4),
> > SA_AIS_OK);
> > - safassert(saClmSelectionObjectGet(clmHandle, &selectionObject),
> > + safassert(clmutil_saClmSelectionObjectGet(clmHandle,
> &selectionObject),
> > SA_AIS_OK);
> > - rc = saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> > + rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, NULL);
> >
> > fds[0].fd = (int)selectionObject;
> > fds[0].events = POLLIN;
> > @@ -212,8 +213,8 @@ void saClmResponse_03(void)
> > break;
> > }
> > }
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > - safassert(saClmResponse_4(clmHandle, lock_inv,
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmResponse_4(clmHandle, lock_inv,
> > SA_CLM_CALLBACK_RESPONSE_REJECTED),
> > SA_AIS_OK);
> >
> > @@ -226,10 +227,10 @@ void saClmResponse_03(void)
> > }
> > }
> >
> > - safassert(saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> > + safassert(clmutil_saClmDispatch(clmHandle, SA_DISPATCH_ALL),
> SA_AIS_OK);
> >
> > - safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmClusterTrackStop(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_OK);
> > }
> >
> > @@ -237,21 +238,21 @@ void saClmResponse_04(void)
> > {
> > printf("This test case needs (manual) admin op simulation\n");
> > return; /* uncomment this and run*/
> > - rc = saClmResponse_4(0, 200,
> SA_CLM_CALLBACK_RESPONSE_REJECTED);
> > + rc = clmutil_saClmResponse_4(0, 200,
> SA_CLM_CALLBACK_RESPONSE_REJECTED);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> > - rc = saClmResponse_4(1234, 0,
> SA_CLM_CALLBACK_RESPONSE_REJECTED);
> > + rc = clmutil_saClmResponse_4(1234, 0,
> SA_CLM_CALLBACK_RESPONSE_REJECTED);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> > - rc = saClmResponse_4(1234, 200, 10);
> > + rc = clmutil_saClmResponse_4(1234, 200, 10);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> > - rc = saClmResponse_4(-1, 200,
> SA_CLM_CALLBACK_RESPONSE_REJECTED);
> > + rc = clmutil_saClmResponse_4(-1, 200,
> SA_CLM_CALLBACK_RESPONSE_REJECTED);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> > }
> >
> > void saClmResponse_05(void)
> > {
> > - safassert(saClmInitialize_4(&clmHandle, NULL, &clmVersion_4),
> > + safassert(clmutil_saClmInitialize_4(&clmHandle, NULL,
> &clmVersion_4),
> > SA_AIS_OK);
> > - rc = saClmResponse_4(clmHandle, 100,
> SA_CLM_CALLBACK_RESPONSE_OK);
> > + rc = clmutil_saClmResponse_4(clmHandle, 100,
> SA_CLM_CALLBACK_RESPONSE_OK);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> > }
> >
> > diff --git a/src/clm/apitest/tet_saClmSelectionObjectGet.c
> b/src/clm/apitest/tet_saClmSelectionObjectGet.c
> > index 34961c1..2d35f5f 100644
> > --- a/src/clm/apitest/tet_saClmSelectionObjectGet.c
> > +++ b/src/clm/apitest/tet_saClmSelectionObjectGet.c
> > @@ -1,6 +1,7 @@
> > /* -*- OpenSAF -*-
> > *
> > * (C) Copyright 2008 The OpenSAF Foundation
> > + * Copyright Ericsson AB 2017 - All Rights Reserved.
> > *
> > * This program is distributed in the hope that it will be useful, but
> > * WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY
> > @@ -28,37 +29,37 @@ SaClmCallbacksT clmCallback = {nodeGetCallBack,
> NULL};
> >
> > void saClmSelectionObjectGet_01(void)
> > {
> > - safassert(saClmInitialize(&clmHandle, &clmCallback,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallback,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmSelectionObjectGet(clmHandle, &selectionObject);
> > + rc = clmutil_saClmSelectionObjectGet(clmHandle, &selectionObject);
> > test_validate(rc, SA_AIS_OK);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > }
> >
> > void saClmSelectionObjectGet_02(void)
> > {
> > - safassert(saClmInitialize(&clmHandle, &clmCallback,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallback,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmSelectionObjectGet(0, &selectionObject);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmSelectionObjectGet(0, &selectionObject);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> > }
> >
> > void saClmSelectionObjectGet_03(void)
> > {
> > - safassert(saClmInitialize(&clmHandle, &clmCallback,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallback,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmSelectionObjectGet(-1, &selectionObject);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmSelectionObjectGet(-1, &selectionObject);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
> > }
> >
> > void saClmSelectionObjectGet_04(void)
> > {
> > - safassert(saClmInitialize(&clmHandle, &clmCallback,
> &clmVersion_1),
> > + safassert(clmutil_saClmInitialize(&clmHandle, &clmCallback,
> &clmVersion_1),
> > SA_AIS_OK);
> > - rc = saClmSelectionObjectGet(clmHandle, NULL);
> > - safassert(saClmFinalize(clmHandle), SA_AIS_OK);
> > + rc = clmutil_saClmSelectionObjectGet(clmHandle, NULL);
> > + safassert(clmutil_saClmFinalize(clmHandle), SA_AIS_OK);
> > test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
> > }
> >
------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most
engaging tech sites, Slashdot.org! http://sdm.link/slashdot
_______________________________________________
Opensaf-devel mailing list
Opensaf-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/opensaf-devel
