Re: [devel] [PATCH 1/1] clm: wrapper CLM APIs with try_again handle inside [#2634]

[Hans Nordebäck]

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, &notificationBuffer_1);
+       rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, 
&notificationBuffer_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, &notificationBuffer_4);
+       rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, 
&notificationBuffer_4);
        clmTrackbuf_4(&notificationBuffer_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, &notificationBuffer_1);
-       safassert(saClmClusterTrackStop(clmHandle), SA_AIS_ERR_NOT_EXIST);
+       rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, 
&notificationBuffer_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, &notificationBuffer_4);
+       rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, 
&notificationBuffer_4);
        clmTrackbuf_4(&notificationBuffer_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, &notificationBuffer_1);
-       /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
+       rc = clmutil_saClmClusterTrack(0, trackFlags, &notificationBuffer_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, &notificationBuffer_1);
-       /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
+       rc = clmutil_saClmClusterTrack(-1, trackFlags, &notificationBuffer_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, &notificationBuffer_1);
-       /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
+       rc = clmutil_saClmClusterTrack(clmHandle, 0, &notificationBuffer_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, &notificationBuffer_1);
+       safassert(clmutil_saClmInitialize(&clmHandle, NULL, &clmVersion_1), 
SA_AIS_OK);
+       /*rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, 
&notificationBuffer_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, &notificationBuffer_4);
-       /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
-       safassert(saClmClusterNotificationFree_4(
+       rc = clmutil_saClmClusterTrack_4(0, trackFlags, &notificationBuffer_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, &notificationBuffer_4);
-       /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
-       safassert(saClmClusterNotificationFree_4(
+       rc = clmutil_saClmClusterTrack_4(-1, trackFlags, &notificationBuffer_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, &notificationBuffer_4);
-       /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
-       safassert(saClmClusterNotificationFree_4(
+       rc = clmutil_saClmClusterTrack_4(clmHandle, 0, &notificationBuffer_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, &notificationBuffer_4);
-       /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
+       rc = clmutil_saClmClusterTrack_4(clmHandle, trackFlags, 
&notificationBuffer_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, &notificationBuffer_1);
-       /*safassert(saClmClusterTrackStop(clmHandle), SA_AIS_OK);*/
+       rc = clmutil_saClmClusterTrack(clmHandle, trackFlags, 
&notificationBuffer_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