---
.../apitest/management/test_saImmOmClassCreate_2.c | 129 +++++++++++++++++++++
.../apitest/management/test_saImmOmClassDelete.c | 27 +++++
.../management/test_saImmOmClassDescriptionGet_2.c | 32 +++++
src/imm/apitest/management/test_saImmOmDispatch.c | 122 +++++++++++++++++++
src/imm/apitest/management/test_saImmOmFinalize.c | 26 +++++
.../apitest/management/test_saImmOmInitialize.c | 53 +++++++++
.../management/test_saImmOmSelectionObjectGet.c | 26 +++++
7 files changed, 415 insertions(+)
diff --git a/src/imm/apitest/management/test_saImmOmClassCreate_2.c
b/src/imm/apitest/management/test_saImmOmClassCreate_2.c
index 4f25f8b..f43884e 100644
--- a/src/imm/apitest/management/test_saImmOmClassCreate_2.c
+++ b/src/imm/apitest/management/test_saImmOmClassCreate_2.c
@@ -426,6 +426,110 @@ void saImmOmClassCreate_2_19(void)
safassert(immutil_saImmOmFinalize(immOmHandle), SA_AIS_OK);
}
+/* Object to test: saImmOmClassCreate_2() API:
+ * Test: Creating a config class with invalid handle
+ * step1:Call saImmOmInitialize() API and it returns SA_AIS_OK
+ * step2:Now call the saImmOmClassCreate_2() with -1
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmClassCreate_2_with_invalid_handle_with_config_class(void)
+{
+ const SaImmClassNameT className = (SaImmClassNameT) __FUNCTION__;
+ SaImmAttrDefinitionT_2 attr1 = {"rdn", SA_IMM_ATTR_SANAMET,
+ SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_RDN,
+ NULL};
+ const SaImmAttrDefinitionT_2 *attrDefinitions[] = {&attr1, NULL};
+
+ safassert(immutil_saImmOmInitialize(&immOmHandle, &immOmCallbacks,
&immVersion),
+ SA_AIS_OK);
+ rc = immutil_saImmOmClassCreate_2(-1, className, SA_IMM_CLASS_CONFIG,
+ attrDefinitions);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+ safassert(immutil_saImmOmFinalize(immOmHandle), SA_AIS_OK);
+}
+
+/* Object to test: saImmOmClassCreate_2() API:
+ * Test: Creating a config class with uninitialized handle
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmClassCreate_2_uninitialized_handle_with_config_class(void)
+{
+ const SaImmClassNameT className = (SaImmClassNameT) __FUNCTION__;
+ SaImmAttrDefinitionT_2 attr1 = {"rdn", SA_IMM_ATTR_SANAMET,
+ SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_RDN,
+ NULL};
+ const SaImmAttrDefinitionT_2 *attrDefinitions[] = {&attr1, NULL};
+
+ rc = immutil_saImmOmClassCreate_2(immOmHandle, className,
SA_IMM_CLASS_CONFIG,
+ attrDefinitions);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+}
+
+/* Object to test: saImmOmClassCreate_2() API:
+ * Test: Creating a runtime class with uninitialized handle
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmClassCreate_2_with_uninitialized_handle_with_runtime_class(void)
+{
+ const SaImmClassNameT className = (SaImmClassNameT) __FUNCTION__;
+ SaImmAttrDefinitionT_2 attr1 = {
+ "rdn", SA_IMM_ATTR_SANAMET,
+ SA_IMM_ATTR_RUNTIME | SA_IMM_ATTR_RDN | SA_IMM_ATTR_CACHED, NULL};
+ const SaImmAttrDefinitionT_2 *attrDefinitions[] = {&attr1, NULL};
+
+ rc = immutil_saImmOmClassCreate_2(immOmHandle, className,
SA_IMM_CLASS_RUNTIME,
+ attrDefinitions);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+}
+
+
+/* Object to test: saImmOmClassCreate_2() API:
+ * Test: Creating a config class with invalid handle
+ * step1:Call saImmOmInitialize() API and it returns SA_AIS_OK
+ * step2:Call saImmOmFinalize()
+ * step3:Now call the saImmOmClassCreate_2() with immOmHandle
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmClassCreate_2_with_finalized_handle_config_class(void)
+{
+ const SaImmClassNameT className = (SaImmClassNameT) __FUNCTION__;
+ SaImmAttrDefinitionT_2 attr1 = {"rdn", SA_IMM_ATTR_SANAMET,
+ SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_RDN,
+ NULL};
+ const SaImmAttrDefinitionT_2 *attrDefinitions[] = {&attr1, NULL};
+
+ safassert(immutil_saImmOmInitialize(&immOmHandle, &immOmCallbacks,
&immVersion),
+ SA_AIS_OK);
+ immutil_saImmOmFinalize(immOmHandle);
+ rc = immutil_saImmOmClassCreate_2(immOmHandle, className,
SA_IMM_CLASS_CONFIG,
+ attrDefinitions);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+}
+
+
+/* Object to test: saImmOmClassCreate_2() API:
+ * Test: Creating a runtime class with invalid handle
+ * step1:Call saImmOmInitialize() API and it returns SA_AIS_OK
+ * step2:Call saImmOmFinalize()
+ * step3:Now call the saImmOmClassCreate_2() with immOmHandle
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmClassCreate_2_with_finalized_handle_runtime_class(void)
+{
+ const SaImmClassNameT className = (SaImmClassNameT) __FUNCTION__;
+ SaImmAttrDefinitionT_2 attr1 = {
+ "rdn", SA_IMM_ATTR_SANAMET,
+ SA_IMM_ATTR_RUNTIME | SA_IMM_ATTR_RDN | SA_IMM_ATTR_CACHED, NULL};
+ const SaImmAttrDefinitionT_2 *attrDefinitions[] = {&attr1, NULL};
+
+ safassert(immutil_saImmOmInitialize(&immOmHandle, &immOmCallbacks,
&immVersion),
+ SA_AIS_OK);
+ immutil_saImmOmFinalize(immOmHandle);
+ rc = immutil_saImmOmClassCreate_2(immOmHandle, className,
SA_IMM_CLASS_RUNTIME,
+ attrDefinitions);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+}
+
/*
Verify it is not allowed to create IMM object class with reserved name.
NOTE: As the list of reserved class names is read from the environment
@@ -1435,6 +1539,7 @@ extern void saImmOmClassDescriptionGet_2_02(void);
extern void saImmOmClassDescriptionGet_2_03(void);
extern void saImmOmClassDescriptionGet_2_04(void);
extern void saImmOmClassDescriptionGet_2_05(void);
+extern void saImmOmClassDescriptionGet_2_with_className_as_null(void);
extern void saImmOmClassDescriptionMemoryFree_2_01(void);
extern void saImmOmClassDescriptionMemoryFree_2_02(void);
@@ -1442,6 +1547,7 @@ extern void saImmOmClassDelete_2_01(void);
extern void saImmOmClassDelete_2_02(void);
extern void saImmOmClassDelete_2_03(void);
extern void saImmOmClassDelete_2_04(void);
+extern void saImmOmClassDelete_2_with_deleted_class(void);
__attribute__((constructor)) static void saImmOmInitialize_constructor(void)
{
@@ -1497,6 +1603,22 @@ __attribute__((constructor)) static void
saImmOmInitialize_constructor(void)
test_case_add(
2, saImmOmClassCreate_2_19,
"saImmOmClassCreate_2 - SA_AIS_OK, Create a class that has
STRONG_DEFAULT flag without having default value");
+ test_case_add(2,
saImmOmClassCreate_2_with_invalid_handle_with_config_class,
+ "saImmOmClassCreate_2 - SA_AIS_ERR_BAD_HANDLE, create
config"
+ " class with invalid handle");
+ test_case_add(2,
saImmOmClassCreate_2_uninitialized_handle_with_config_class,
+ "saImmOmClassCreate_2 - SA_AIS_ERR_BAD_HANDLE, create
config"
+ " class with uninitialized handle");
+ test_case_add(2,
saImmOmClassCreate_2_with_uninitialized_handle_with_runtime_class,
+ "saImmOmClassCreate_2 - SA_AIS_ERR_BAD_HANDLE, create
runtime"
+ " class with uninitialized handle ");
+ test_case_add(2,
saImmOmClassCreate_2_with_finalized_handle_config_class,
+ "saImmOmClassCreate_2 - SA_AIS_ERR_BAD_HANDLE, create
config"
+ " class with finalized handle");
+ test_case_add(2,
saImmOmClassCreate_2_with_finalized_handle_runtime_class,
+ "saImmOmClassCreate_2 - SA_AIS_ERR_BAD_HANDLE, create
runtime"
+ " class with finalized handle");
+
test_case_add(
2, saImmOmClassCreate_with_reserved_name_01,
"saImmOmClassCreate_2 - SA_AIS_ERR_INVALID_PARAM,"
@@ -1519,6 +1641,9 @@ __attribute__((constructor)) static void
saImmOmInitialize_constructor(void)
test_case_add(
2, saImmOmClassDescriptionGet_2_05,
"saImmOmClassDescriptionGet_2 - SA_AIS_OK, Fetch includes
SA_IMM_ATTR_NO_DANGLING");
+ test_case_add(2, saImmOmClassDescriptionGet_2_with_className_as_null,
+ "saImmOmClassDescriptionGet_2 - SA_AIS_ERR_INVALID_PARAM"
+ "Get class descriptor of an invalid class name");
test_case_add(2, saImmOmClassDescriptionMemoryFree_2_01,
"saImmOmClassDescriptionMemoryFree_2 - SA_AIS_OK");
@@ -1539,6 +1664,10 @@ __attribute__((constructor)) static void
saImmOmInitialize_constructor(void)
test_case_add(
2, saImmOmClassDelete_2_04,
"saImmOmClassDelete_2 - SA_AIS_ERR_INVALID_PARAM, Empty
classname");
+ test_case_add(
+ 2, saImmOmClassDelete_2_with_deleted_class,
+ "saImmOmClassDelete_2 - SA_AIS_ERR_NOT_EXIST "
+ "Double delete class name");
test_case_add(
2, saImmOmClassCreate_SchemaChange_2_01,
diff --git a/src/imm/apitest/management/test_saImmOmClassDelete.c
b/src/imm/apitest/management/test_saImmOmClassDelete.c
index 273d192..ffcf481 100644
--- a/src/imm/apitest/management/test_saImmOmClassDelete.c
+++ b/src/imm/apitest/management/test_saImmOmClassDelete.c
@@ -76,3 +76,30 @@ void saImmOmClassDelete_2_04(void)
test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
safassert(immutil_saImmOmFinalize(immOmHandle), SA_AIS_OK);
}
+
+/* Object to test: saImmOmClassDelete() API:
+ * Test: deleting the class which is already deleted
+ * step1:Call saImmOmInitialize() API and it returns SA_AIS_OK
+ * step2:Call saImmOmClassCreate_2()
+ * step3:Now call the saImmOmClassDelete()
+ * step4:Now again call this saImmOmClassDelete()
+ * Result: Shall fail with return code SA_AIS_ERR_NOT_EXIST
+ */
+void saImmOmClassDelete_2_with_deleted_class(void)
+{
+ const SaImmClassNameT className = (SaImmClassNameT) __FUNCTION__;
+ SaImmAttrDefinitionT_2 attr1 = {"rdn", SA_IMM_ATTR_SANAMET,
+ SA_IMM_ATTR_CONFIG | SA_IMM_ATTR_RDN,
+ NULL};
+ const SaImmAttrDefinitionT_2 *attrDefinitions[] = {&attr1, NULL};
+
+ safassert(immutil_saImmOmInitialize(&immOmHandle, &immOmCallbacks,
&immVersion),
+ SA_AIS_OK);
+ safassert(immutil_saImmOmClassCreate_2(immOmHandle, className,
+ SA_IMM_CLASS_CONFIG, attrDefinitions),
+ SA_AIS_OK);
+ immutil_saImmOmClassDelete(immOmHandle, className);
+ rc = immutil_saImmOmClassDelete(immOmHandle, className);
+ test_validate(rc, SA_AIS_ERR_NOT_EXIST);
+ safassert(immutil_saImmOmFinalize(immOmHandle), SA_AIS_OK);
+}
diff --git a/src/imm/apitest/management/test_saImmOmClassDescriptionGet_2.c
b/src/imm/apitest/management/test_saImmOmClassDescriptionGet_2.c
index ecf7ceb..1d4e8eb 100644
--- a/src/imm/apitest/management/test_saImmOmClassDescriptionGet_2.c
+++ b/src/imm/apitest/management/test_saImmOmClassDescriptionGet_2.c
@@ -175,3 +175,35 @@ void saImmOmClassDescriptionGet_2_05(void)
safassert(immutil_saImmOmClassDelete(immOmHandle, className),
SA_AIS_OK);
safassert(immutil_saImmOmFinalize(immOmHandle), SA_AIS_OK);
}
+
+/* Object to test: saImmOmClassDescriptionGet_2() API:
+ * Test: Getting the class description with invalid params
+ * step1:Call saImmOmInitialize() API and it returns SA_AIS_OK
+ * step2:Call saImmOmClassCreate_2()
+ * step3:Now call the saImmOmClassDescriptionGet_2() with class name as null
+ * Result: Shall fail with return code SA_AIS_ERR_INVALID_PARAM
+ */
+void saImmOmClassDescriptionGet_2_with_className_as_null(void)
+{
+ const SaImmClassNameT className = (SaImmClassNameT) __FUNCTION__;
+ SaImmAttrDefinitionT_2 attr1 = {
+ "rdn", SA_IMM_ATTR_SANAMET,
+ SA_IMM_ATTR_RUNTIME | SA_IMM_ATTR_RDN | SA_IMM_ATTR_CACHED, NULL};
+ const SaImmAttrDefinitionT_2 *attrDefinitionsIn[] = {&attr1, NULL};
+ SaImmClassCategoryT classCategory;
+ SaImmAttrDefinitionT_2 **attrDefinitionsOut;
+
+ safassert(immutil_saImmOmInitialize(&immOmHandle, &immOmCallbacks,
&immVersion),
+ SA_AIS_OK);
+ safassert(immutil_saImmOmClassCreate_2(immOmHandle, className,
+ SA_IMM_CLASS_RUNTIME, attrDefinitionsIn),
+ SA_AIS_OK);
+ rc = immutil_saImmOmClassDescriptionGet_2(immOmHandle, NULL,
+ &classCategory, &attrDefinitionsOut);
+ test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
+ safassert(immutil_saImmOmClassDescriptionMemoryFree_2(immOmHandle,
+ attrDefinitionsOut),
+ SA_AIS_OK);
+ safassert(immutil_saImmOmClassDelete(immOmHandle, className),
SA_AIS_OK);
+ safassert(immutil_saImmOmFinalize(immOmHandle), SA_AIS_OK);
+}
diff --git a/src/imm/apitest/management/test_saImmOmDispatch.c
b/src/imm/apitest/management/test_saImmOmDispatch.c
index 3648a95..c5c411c 100644
--- a/src/imm/apitest/management/test_saImmOmDispatch.c
+++ b/src/imm/apitest/management/test_saImmOmDispatch.c
@@ -52,3 +52,125 @@ void saImmOmDispatch_04(void)
test_validate(rc, SA_AIS_ERR_INVALID_PARAM);
safassert(immutil_saImmOmFinalize(immOmHandle), SA_AIS_OK);
}
+
+/* Object to test: saImmOmDispatch() API:
+ * Test:Dispatching with uninitialized handle and SA_DISPATCH_ONE
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmDispatch_with_uninitialized_handle_with_SA_DISPATCH_ONE(void)
+{
+ rc = saImmOmDispatch(immOmHandle, SA_DISPATCH_ONE);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+}
+
+/* Object to test: saImmOmDispatch() API:
+ * Test: Dispatching with finalized handle and SA_DISPATCH_ONE
+ * step1:Call saImmOmInitialize() API and it returns SA_AIS_OK
+ * step2:call saImmOmFinalize()
+ * step3:Now call the saImmOmDispatch() with immOmHandle
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmDispatch_with_finalized_handle_with_SA_DISPATCH_ONE(void)
+{
+ safassert(immutil_saImmOmInitialize(&immOmHandle, &immOmCallbacks,
&immVersion),
+ SA_AIS_OK);
+ immutil_saImmOmFinalize(immOmHandle);
+ rc = saImmOmDispatch(immOmHandle, SA_DISPATCH_ONE);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+}
+
+/* Object to test: saImmOmDispatch() API:
+ * Test:Dispatching with initialized handle and SA_DISPATCH_BLOCKING
+ * Result: Shall pass with return code SA_AIS_OK
+ */
+void saImmOmDispatch_with_SA_DISPATCH_BLOCKING(void)
+{
+ safassert(immutil_saImmOmInitialize(&immOmHandle, &immOmCallbacks,
&immVersion),
+ SA_AIS_OK);
+ rc = saImmOmDispatch(immOmHandle, SA_DISPATCH_BLOCKING);
+ test_validate(rc, SA_AIS_OK);
+ safassert(immutil_saImmOmFinalize(immOmHandle), SA_AIS_OK);
+}
+
+/* Object to test: saImmOmDispatch() API:
+ * Test: Dispatching with invalid handle and SA_DISPATCH_ALL
+ * step1:Call saImmOmInitialize() API and it returns SA_AIS_OK
+ * step2:Now call the saImmOmDispatch() with -1
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmDispatch_with_invalid_handle_with_SA_DISPATCH_ALL(void)
+{
+ safassert(immutil_saImmOmInitialize(&immOmHandle, &immOmCallbacks,
&immVersion),
+ SA_AIS_OK);
+ rc = saImmOmDispatch(-1, SA_DISPATCH_ALL);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+ safassert(immutil_saImmOmFinalize(immOmHandle), SA_AIS_OK);
+}
+
+/* Object to test: saImmOmDispatch() API:
+ * Test:Dispatching with uninitialized handle and SA_DISPATCH_ALL
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmDispatch_with_uninitialized_handle_with_SA_DISPATCH_ALL(void)
+{
+ rc = saImmOmDispatch(immOmHandle, SA_DISPATCH_ALL);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+}
+
+/* Object to test: saImmOmDispatch() API:
+ * Test: Dispatching with finalized handle and SA_DISPATCH_ALL
+ * step1:Call saImmOmInitialize() API and it returns SA_AIS_OK
+ * step2:call saImmOmFinalize()
+ * step3:Now call the saImmOmDispatch() with immOmHandle
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+
+void saImmOmDispatch_with_finalized_handle_with_SA_DISPATCH_ALL(void)
+{
+ safassert(immutil_saImmOmInitialize(&immOmHandle, &immOmCallbacks,
&immVersion),
+ SA_AIS_OK);
+ immutil_saImmOmFinalize(immOmHandle);
+ rc = saImmOmDispatch(immOmHandle, SA_DISPATCH_ALL);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+}
+
+/* Object to test: saImmOmDispatch() API:
+ * Test: Dispatching with invalid handle and SA_DISPATCH_BLOCKING
+ * step1:Call saImmOmInitialize() API and it returns SA_AIS_OK
+ * step2:Now call the saImmOmDispatch() with -1
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmDispatch_with_invalid_handle_with_SA_DISPATCH_BLOCKING(void)
+{
+ safassert(immutil_saImmOmInitialize(&immOmHandle, &immOmCallbacks,
&immVersion),
+ SA_AIS_OK);
+ rc = saImmOmDispatch(-1, SA_DISPATCH_BLOCKING);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+ safassert(immutil_saImmOmFinalize(immOmHandle), SA_AIS_OK);
+}
+
+/* Object to test: saImmOmDispatch() API:
+ * Test:Dispatching with uninitialized handle and SA_DISPATCH_BLOCKING
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmDispatch_with_uninitialized_handle_with_SA_DISPATCH_BLOCKING(void)
+{
+ rc = saImmOmDispatch(immOmHandle, SA_DISPATCH_BLOCKING);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+}
+
+/* Object to test: saImmOmDispatch() API:
+ * Test: Dispatching with finalized handle and SA_DISPATCH_BLOCKING
+ * step1:Call saImmOmInitialize() API and it returns SA_AIS_OK
+ * step2:call saImmOmFinalize()
+ * step3:Now call the saImmOmDispatch() with immOmHandle
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmDispatch_with_finalized_handle_with_SA_DISPATCH_BLOCKING(void)
+{
+ safassert(immutil_saImmOmInitialize(&immOmHandle, &immOmCallbacks,
&immVersion),
+ SA_AIS_OK);
+ immutil_saImmOmFinalize(immOmHandle);
+ rc = saImmOmDispatch(immOmHandle, SA_DISPATCH_BLOCKING);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+}
diff --git a/src/imm/apitest/management/test_saImmOmFinalize.c
b/src/imm/apitest/management/test_saImmOmFinalize.c
index 1c60657..421d64d 100644
--- a/src/imm/apitest/management/test_saImmOmFinalize.c
+++ b/src/imm/apitest/management/test_saImmOmFinalize.c
@@ -33,3 +33,29 @@ void saImmOmFinalize_02(void)
test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
safassert(immutil_saImmOmFinalize(immOmHandle), SA_AIS_OK);
}
+
+/* Object to test: saImmOmFinalize() API:
+ * Test: Finalizing with finalized handle
+ * step1:Call saImmOmInitialize() API and it returns SA_AIS_OK
+ * step2:call saImmOmFinalize()
+ * step3:call saImmOmFinalize() with immOmHandle handle
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmFinalize_with_finalized_handle(void)
+{
+ safassert(immutil_saImmOmInitialize(&immOmHandle, &immOmCallbacks,
&immVersion),
+ SA_AIS_OK);
+ rc = immutil_saImmOmFinalize(immOmHandle);
+ rc = immutil_saImmOmFinalize(immOmHandle);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+}
+
+/* Object to test: saImmOmFinalize() API:
+ * Test: Finalizing with uninitialized handle
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmFinalize_with_uninitialized_handle(void)
+{
+ rc = immutil_saImmOmFinalize(immOmHandle);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+}
diff --git a/src/imm/apitest/management/test_saImmOmInitialize.c
b/src/imm/apitest/management/test_saImmOmInitialize.c
index 9dcfe7a..e97da1d 100644
--- a/src/imm/apitest/management/test_saImmOmInitialize.c
+++ b/src/imm/apitest/management/test_saImmOmInitialize.c
@@ -303,12 +303,25 @@ void saImmOmInitialize_11(void)
extern void saImmOmSelectionObjectGet_01(void);
extern void saImmOmSelectionObjectGet_02(void);
+extern void saImmOmSelectionObjectGet_with_uninitialized_handle(void);
+extern void saImmOmSelectionObjectGet_with_finalized_handle(void);
extern void saImmOmDispatch_01(void);
extern void saImmOmDispatch_02(void);
extern void saImmOmDispatch_03(void);
extern void saImmOmDispatch_04(void);
+extern void
saImmOmDispatch_with_uninitialized_handle_with_SA_DISPATCH_ONE(void);
+extern void saImmOmDispatch_with_finalized_handle_with_SA_DISPATCH_ONE(void);
+extern void saImmOmDispatch_with_SA_DISPATCH_BLOCKING(void);
+extern void saImmOmDispatch_with_invalid_handle_with_SA_DISPATCH_ALL(void);
+extern void
saImmOmDispatch_with_uninitialized_handle_with_SA_DISPATCH_ALL(void);
+extern void saImmOmDispatch_with_finalized_handle_with_SA_DISPATCH_ALL(void);
+extern void
saImmOmDispatch_with_invalid_handle_with_SA_DISPATCH_BLOCKING(void);
+extern void
saImmOmDispatch_with_uninitialized_handle_with_SA_DISPATCH_BLOCKING(void);
+extern void
saImmOmDispatch_with_finalized_handle_with_SA_DISPATCH_BLOCKING(void);
extern void saImmOmFinalize_01(void);
extern void saImmOmFinalize_02(void);
+extern void saImmOmFinalize_with_finalized_handle(void);
+extern void saImmOmFinalize_with_uninitialized_handle(void);
extern void saImmOmThreadInterference_01(void);
__attribute__((constructor)) static void saImmOmInitialize_constructor(void)
@@ -350,6 +363,14 @@ __attribute__((constructor)) static void
saImmOmInitialize_constructor(void)
test_case_add(
1, saImmOmSelectionObjectGet_02,
"saImmOmSelectionObjectGet - SA_AIS_ERR_BAD_HANDLE - invalid
handle");
+ test_case_add(
+ 1, saImmOmSelectionObjectGet_with_uninitialized_handle,
+ "saImmOmSelectionObjectGet - SA_AIS_ERR_BAD_HANDLE "
+ "- uninitialized handle");
+ test_case_add(
+ 1, saImmOmSelectionObjectGet_with_finalized_handle,
+ "saImmOmSelectionObjectGet - SA_AIS_ERR_BAD_HANDLE "
+ "- finalized handle");
test_case_add(1, saImmOmDispatch_01,
"saImmOmDispatch - SA_AIS_OK SA_DISPATCH_ALL");
@@ -361,11 +382,43 @@ __attribute__((constructor)) static void
saImmOmInitialize_constructor(void)
test_case_add(
1, saImmOmDispatch_04,
"saImmOmDispatch - SA_AIS_ERR_INVALID_PARAM - invalid
dispatchFlags");
+ test_case_add(
+ 1, saImmOmDispatch_with_uninitialized_handle_with_SA_DISPATCH_ONE,
+ "saImmOmDispatch - SA_AIS_ERR_BAD_HANDLE - uninitialized handle
SA_DISPATCH_ONE");
+ test_case_add(
+ 1, saImmOmDispatch_with_finalized_handle_with_SA_DISPATCH_ONE,
+ "saImmOmDispatch - SA_AIS_ERR_BAD_HANDLE - finalized handle
SA_DISPATCH_ONE");
+ test_case_add(1, saImmOmDispatch_with_SA_DISPATCH_BLOCKING,
+ "saImmOmDispatch - SA_AIS_OK SA_DISPATCH_BLOCKING");
+ test_case_add(
+ 1, saImmOmDispatch_with_invalid_handle_with_SA_DISPATCH_ALL,
+ "saImmOmDispatch - SA_AIS_ERR_BAD_HANDLE - invalid handle
SA_DISPATCH_ALL");
+ test_case_add(
+ 1, saImmOmDispatch_with_uninitialized_handle_with_SA_DISPATCH_ALL,
+ "saImmOmDispatch - SA_AIS_ERR_BAD_HANDLE - uninitialized handle
SA_DISPATCH_ALL");
+ test_case_add(
+ 1, saImmOmDispatch_with_finalized_handle_with_SA_DISPATCH_ALL,
+ "saImmOmDispatch - SA_AIS_ERR_BAD_HANDLE - finalized handle
SA_DISPATCH_ALL");
+ test_case_add(
+ 1, saImmOmDispatch_with_invalid_handle_with_SA_DISPATCH_BLOCKING,
+ "saImmOmDispatch - SA_AIS_ERR_BAD_HANDLE - invalid handle
SA_DISPATCH_BLOCKING");
+ test_case_add(
+ 1,
saImmOmDispatch_with_uninitialized_handle_with_SA_DISPATCH_BLOCKING,
+ "saImmOmDispatch - SA_AIS_ERR_BAD_HANDLE - uninitialized handle
SA_DISPATCH_BLOCKING");
+ test_case_add(
+ 1, saImmOmDispatch_with_finalized_handle_with_SA_DISPATCH_BLOCKING,
+ "saImmOmDispatch - SA_AIS_ERR_BAD_HANDLE - finalized handle
SA_DISPATCH_BLOCKING");
test_case_add(1, saImmOmFinalize_01, "saImmOmFinalize - SA_AIS_OK");
test_case_add(
1, saImmOmFinalize_02,
"saImmOmFinalize - SA_AIS_ERR_BAD_HANDLE - invalid handle");
+ test_case_add(
+ 1, saImmOmFinalize_with_finalized_handle,
+ "saImmOmFinalize - SA_AIS_ERR_BAD_HANDLE - finalized handle");
+ test_case_add(
+ 1, saImmOmFinalize_with_uninitialized_handle,
+ "saImmOmFinalize - SA_AIS_ERR_BAD_HANDLE - uninitialized handle");
test_case_add(
1, saImmOmThreadInterference_01,
diff --git a/src/imm/apitest/management/test_saImmOmSelectionObjectGet.c
b/src/imm/apitest/management/test_saImmOmSelectionObjectGet.c
index 017fd70..3a56fd3 100644
--- a/src/imm/apitest/management/test_saImmOmSelectionObjectGet.c
+++ b/src/imm/apitest/management/test_saImmOmSelectionObjectGet.c
@@ -35,3 +35,29 @@ void saImmOmSelectionObjectGet_02(void)
test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
safassert(immutil_saImmOmFinalize(immOmHandle), SA_AIS_OK);
}
+
+/* Object to test: saImmOmSelectionObjectGet() API:
+ * Test: Getting the selectionObject with uninitialized handle
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmSelectionObjectGet_with_uninitialized_handle(void)
+{
+ rc = immutil_saImmOmSelectionObjectGet(immOmHandle, &selectionObject);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+}
+
+/* Object to test: saImmOmSelectionObjectGet() API:
+ * Test: Getting the SelectionObject with finalized handle
+ * step1:Call saImmOmInitialize() API and it returns SA_AIS_OK
+ * step2:call saImmOmFinalize()
+ * step3:Now call the saImmOmSelectionObjectGet() with immOmHandle
+ * Result: Shall fail with return code SA_AIS_ERR_BAD_HANDLE
+ */
+void saImmOmSelectionObjectGet_with_finalized_handle(void)
+{
+ safassert(immutil_saImmOmInitialize(&immOmHandle, &immOmCallbacks,
&immVersion),
+ SA_AIS_OK);
+ immutil_saImmOmFinalize(immOmHandle);
+ rc = immutil_saImmOmSelectionObjectGet(immOmHandle, &selectionObject);
+ test_validate(rc, SA_AIS_ERR_BAD_HANDLE);
+}
--
2.7.4
_______________________________________________
Opensaf-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/opensaf-devel
