tests/ntfsv/Makefile.am | 3 +-
tests/ntfsv/test_ntf_imcn.c | 508 ++++++++++++++-
tests/ntfsv/tet_longDnObject_notification.c | 972 ++++++++++++++++++++++++++++
tests/unit_test_fw/inc/util.h | 5 +-
tests/unit_test_fw/src/Makefile.am | 1 +
tests/unit_test_fw/src/util.c | 14 +-
6 files changed, 1483 insertions(+), 20 deletions(-)
(1) Add testcase for AdditionInfo with extended name
(2) Add testcase for create/modify/delete runtime&config object with extended
name attribute
diff --git a/tests/ntfsv/Makefile.am b/tests/ntfsv/Makefile.am
--- a/tests/ntfsv/Makefile.am
+++ b/tests/ntfsv/Makefile.am
@@ -64,7 +64,8 @@ ntftest_SOURCES = \
tet_saNtfPtrValAllocate.c \
tet_saNtfArrayValGet.c \
tet_saNtfPtrValGet.c \
- test_ntfFilterVerification.c
+ test_ntfFilterVerification.c \
+ tet_longDnObject_notification.c
ntftest_LDADD = \
$(top_builddir)/tests/unit_test_fw/src/libutest.la
diff --git a/tests/ntfsv/test_ntf_imcn.c b/tests/ntfsv/test_ntf_imcn.c
--- a/tests/ntfsv/test_ntf_imcn.c
+++ b/tests/ntfsv/test_ntf_imcn.c
@@ -39,6 +39,12 @@
static SaNtfHandleT ntfHandle;
static NotifData rec_notif_data;
static SaImmOiHandleT immOiHnd = 0;
+#define DEFAULT_EXT_NAME_LENGTH 300
+static char extended_name_string_01[DEFAULT_EXT_NAME_LENGTH];
+static char extended_name_string_02[DEFAULT_EXT_NAME_LENGTH];
+
+extern void saAisNameLend(SaConstStringT value, SaNameT* name);
+extern SaConstStringT saAisNameBorrow(const SaNameT* name);
/**
* Callback routine, called when subscribed notification arrives.
@@ -976,6 +982,31 @@ static SaAisErrorT set_attr_buf(NotifDat
return error;
}
+static SaAisErrorT set_attr_extended_name(NotifData* n_exp, SaUint16T idx,
+ SaNtfElementIdT attrId, SaNtfValueTypeT valType, void*
attrValue)
+{
+ safassert(valType == SA_NTF_VALUE_LDAP_NAME, true);
+ SaAisErrorT error = SA_AIS_OK;
+ SaUint16T numAlloc = strlen(saAisNameBorrow((SaNameT*)attrValue));
+ SaUint8T* temp = NULL;
+ SaUint8T* srcPtr = (SaUint8T*)saAisNameBorrow((SaNameT*)attrValue);
+
+ if (n_exp->c_d_notif_ptr != NULL) {
+ error = saNtfPtrValAllocate(n_exp->nHandle,
+ numAlloc,
+ (void**) &temp,
+
&n_exp->c_d_notif_ptr->objectAttributes[idx].attributeValue);
+ if (error == SA_AIS_OK) {
+ memcpy(temp, srcPtr, numAlloc);
+ n_exp->c_d_notif_ptr->objectAttributes[idx].attributeId
= attrId;
+
n_exp->c_d_notif_ptr->objectAttributes[idx].attributeType = valType;
+ }
+ } else {
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+ return error;
+}
+
/**
* Set an expected attribute value, type is string.
*/
@@ -1038,6 +1069,34 @@ static SaAisErrorT set_attr_change_buf(N
return error;
}
+static SaAisErrorT set_attr_change_extended_name(NotifData* n_exp, SaUint16T
idx,
+ SaNtfElementIdT attrId, SaNtfValueTypeT valType, const void*
newValue)
+{
+ safassert(valType == SA_NTF_VALUE_LDAP_NAME, true);
+ SaAisErrorT error = SA_AIS_OK;
+ SaUint16T numAlloc = strlen(saAisNameBorrow((SaNameT*)newValue));
+ SaUint8T* temp = NULL;
+ SaUint8T* srcPtr = (SaUint8T*)saAisNameBorrow((SaNameT*)newValue);
+
+ if (n_exp->a_c_notif_ptr != NULL) {
+
n_exp->a_c_notif_ptr->changedAttributes[idx].oldAttributePresent = SA_FALSE;
+ error = saNtfPtrValAllocate(n_exp->nHandle,
+ numAlloc,
+ (void**) &temp,
+
&n_exp->a_c_notif_ptr->changedAttributes[idx].newAttributeValue);
+ if (error == SA_AIS_OK) {
+ memcpy(temp, srcPtr, numAlloc);
+
n_exp->a_c_notif_ptr->changedAttributes[idx].attributeId = attrId;
+
n_exp->a_c_notif_ptr->changedAttributes[idx].attributeType = valType;
+ } else {
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+ } else {
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+ return error;
+}
+
/**
* Set expected attribute change value, type is
UINT32/INT32/UINT64/INT64/FLOAT/DOUBLE.
*/
@@ -4256,6 +4315,432 @@ void objectDeleteTest_3404(void)
test_validate(error, SA_AIS_OK);
}
+/**
+ * Create a runtime test object with extended name attribute and verify
correctness
+ * of generated notification.
+ */
+void objectCreateTest_3501(void)
+{
+ SaAisErrorT error = SA_AIS_OK;
+ safassert(init_ntf(), SA_AIS_OK);
+ safassert(subscribe_notifications(), SA_AIS_OK);
+ rec_notif_data.populated = SA_FALSE;
+
+ /* create the runtime object */
+ SaInt32T int32Var = INT32VAR1;
+ SaUint32T uint32Var = UINT32VAR1;
+ SaInt64T int64Var = INT64VAR1;
+ SaUint64T uint64Var = UINT64VAR1;
+ SaTimeT timeVar = TIMEVAR1;
+ SaNameT nameVar;
+ saAisNameLend((SaConstStringT)&extended_name_string_01, &nameVar);
+ SaFloatT floatVar = FLOATVAR1;
+ SaDoubleT doubleVar = DOUBLEVAR1;
+ SaStringT stringVar = STRINGVAR1;
+ SaAnyT anyVar = {.bufferSize = sizeof (BUF1), .bufferAddr = (SaUint8T*)
BUF1};
+
+ /*
+ * Create the object in IMM.
+ */
+ create_rt_test_object("OsafNtfCmTestRT", DNTESTRT, int32Var, uint32Var,
int64Var, uint64Var,
+ &timeVar, &nameVar, floatVar, doubleVar, &stringVar,
&anyVar);
+
+ /*
+ * Wait for notification reception.
+ */
+ int dwCnt = 0;
+ while (dwCnt++ < POLLWAIT && !rec_notif_data.populated) {
+ saNtfDispatch(ntfHandle, SA_DISPATCH_ALL);
+ if (!rec_notif_data.populated) usleep(100);
+ }
+
+ if (rec_notif_data.populated) {
+ NotifData n_exp;
+ safassert(set_ntf(&n_exp, SA_NTF_OBJECT_CREATION, DNTESTRT, 12,
12), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 0, 0,
"SaImmAttrImplementerName"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 1, 1, "SaImmAttrClassName"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 2, 2, "testUint32"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 3, 3, "testInt32"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 4, 4, "testUint64"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 5, 5, "testInt64"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 6, 6, "testString"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 7, 7, "testFloat"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 8, 8, "testDouble"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 9, 9, "testName"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 10, 10, "testTime"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 11, 11, "testAny"), SA_AIS_OK);
+ safassert(set_attr_str(&n_exp, 0, 0, IMPLEMENTERNAME_RT),
SA_AIS_OK);
+ safassert(set_attr_str(&n_exp, 1, 1, "OsafNtfCmTestRT"),
SA_AIS_OK);
+ safassert(set_attr_scalar(&n_exp, 2, 2, SA_NTF_VALUE_UINT32,
&uint32Var), SA_AIS_OK);
+ safassert(set_attr_scalar(&n_exp, 3, 3, SA_NTF_VALUE_INT32,
&int32Var), SA_AIS_OK);
+ safassert(set_attr_scalar(&n_exp, 4, 4, SA_NTF_VALUE_UINT64,
&uint64Var), SA_AIS_OK);
+ safassert(set_attr_scalar(&n_exp, 5, 5, SA_NTF_VALUE_INT64,
&int64Var), SA_AIS_OK);
+ safassert(set_attr_str(&n_exp, 6, 6, stringVar), SA_AIS_OK);
+ safassert(set_attr_scalar(&n_exp, 7, 7, SA_NTF_VALUE_FLOAT,
&floatVar), SA_AIS_OK);
+ safassert(set_attr_scalar(&n_exp, 8, 8, SA_NTF_VALUE_DOUBLE,
&doubleVar), SA_AIS_OK);
+ safassert(set_attr_extended_name(&n_exp, 9, 9,
SA_NTF_VALUE_LDAP_NAME, &nameVar), SA_AIS_OK);
+ safassert(set_attr_scalar(&n_exp, 10, 10, SA_NTF_VALUE_INT64,
&timeVar), SA_AIS_OK);
+ safassert(set_attr_buf(&n_exp, 11, 11, SA_NTF_VALUE_BINARY,
&anyVar), SA_AIS_OK);
+
+ if (!compare_notifs(&n_exp, &rec_notif_data)) {
+ print_notif(&n_exp);
+ print_notif(&rec_notif_data);
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+
+ safassert(saNtfNotificationFree(rec_notif_data.nHandle),
SA_AIS_OK);
+ safassert(saNtfNotificationFree(n_exp.nHandle), SA_AIS_OK);
+ } else {
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+ safassert(unsub_notifications(), SA_AIS_OK);
+ safassert(saNtfFinalize(ntfHandle), SA_AIS_OK);
+ test_validate(error, SA_AIS_OK);
+}
+
+/**
+ * Modify a runtime test object with extended name attribute and verify
correctness
+ * of generated notification.
+ */
+void objectModifyTest_3502(void)
+{
+ SaAisErrorT error = SA_AIS_OK;
+ safassert(init_ntf(), SA_AIS_OK);
+ safassert(subscribe_notifications(), SA_AIS_OK);
+ rec_notif_data.populated = SA_FALSE;
+
+ SaNameT var1;
+ saAisNameLend((SaConstStringT)&extended_name_string_02, &var1);
+
+ SaAnyT var2 = {.bufferSize = sizeof (BUF2), .bufferAddr = (SaUint8T*)
BUF2};
+ void* v1[] = {&var1};
+ void* v2[] = {&var2};
+ TestAttributeValue att1 = {
+ .attrName = "testName", .attrType = SA_IMM_ATTR_SANAMET,
.attrValues = v1
+ };
+ TestAttributeValue att2 = {
+ .attrName = "testAny", .attrType = SA_IMM_ATTR_SAANYT,
.attrValues = v2
+ };
+ TestAttributeValue * attrs[] = {&att1, &att2, NULL};
+
+ /*
+ * Modify (REPLACE) the object in IMM.
+ */
+ modify_rt_test_object(DNTESTRT, SA_IMM_ATTR_VALUES_REPLACE, attrs);
+
+ /*
+ * Wait for notification reception.
+ */
+ int dwCnt = 0;
+ while (dwCnt++ < POLLWAIT && !rec_notif_data.populated) {
+ saNtfDispatch(ntfHandle, SA_DISPATCH_ALL);
+ if (!rec_notif_data.populated) usleep(100);
+ }
+
+ if (rec_notif_data.populated) {
+ NotifData n_exp;
+ safassert(set_ntf(&n_exp, SA_NTF_ATTRIBUTE_CHANGED, DNTESTRT,
4, 4), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 0, 0,
"SaImmAttrImplementerName"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 1, 1, "SaImmAttrClassName"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 2, 2, "testName"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 3, 3, "testAny"), SA_AIS_OK);
+ safassert(set_attr_change_str(&n_exp, 0, 0,
IMPLEMENTERNAME_RT), SA_AIS_OK);
+ safassert(set_attr_change_str(&n_exp, 1, 1, "OsafNtfCmTestRT"),
SA_AIS_OK);
+ safassert(set_attr_change_extended_name(&n_exp, 2, 2,
SA_NTF_VALUE_LDAP_NAME, &var1), SA_AIS_OK);
+ safassert(set_attr_change_buf(&n_exp, 3, 3,
SA_NTF_VALUE_BINARY, &var2), SA_AIS_OK);
+
+ if (!compare_notifs(&n_exp, &rec_notif_data)) {
+ print_notif(&n_exp);
+ print_notif(&rec_notif_data);
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+ safassert(saNtfNotificationFree(rec_notif_data.nHandle),
SA_AIS_OK);
+ safassert(saNtfNotificationFree(n_exp.nHandle), SA_AIS_OK);
+ } else {
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+ safassert(unsub_notifications(), SA_AIS_OK);
+ safassert(saNtfFinalize(ntfHandle), SA_AIS_OK);
+ test_validate(error, SA_AIS_OK);
+}
+
+
+/**
+ * Modify a runtime test object with extended name attribute and verify
correctness
+ * of generated notification.
+ */
+void objectModifyTest_3503(void)
+{
+ SaAisErrorT error = SA_AIS_OK;
+ safassert(init_ntf(), SA_AIS_OK);
+ safassert(subscribe_notifications(), SA_AIS_OK);
+ rec_notif_data.populated = SA_FALSE;
+
+ /* modify the runtime object */
+
+ SaNameT oldvar;
+ saAisNameLend((SaConstStringT)&extended_name_string_02, &oldvar);
+ SaNameT addvar;
+ saAisNameLend((SaConstStringT)&extended_name_string_01, &addvar);
+ void* v[] = {&addvar};
+ TestAttributeValue att = {
+ .attrName = "testName", .attrType = SA_IMM_ATTR_SANAMET,
.attrValues = v
+ };
+ TestAttributeValue * attrs[] = {&att, NULL};
+
+ /*
+ * Modify (ADD) the object in IMM.
+ */
+ modify_rt_test_object(DNTESTRT, SA_IMM_ATTR_VALUES_ADD, attrs);
+
+ /*
+ * Wait for notification reception.
+ */
+ int dwCnt = 0;
+ while (dwCnt++ < POLLWAIT && !rec_notif_data.populated) {
+ saNtfDispatch(ntfHandle, SA_DISPATCH_ALL);
+ if (!rec_notif_data.populated) usleep(100);
+ }
+
+ if (rec_notif_data.populated) {
+ NotifData n_exp;
+ safassert(set_ntf(&n_exp, SA_NTF_ATTRIBUTE_CHANGED, DNTESTRT,
3, 4), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 0, 0,
"SaImmAttrImplementerName"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 1, 1, "SaImmAttrClassName"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 2, 2, "testName"), SA_AIS_OK);
+ safassert(set_attr_change_str(&n_exp, 0, 0,
IMPLEMENTERNAME_RT), SA_AIS_OK);
+ safassert(set_attr_change_str(&n_exp, 1, 1, "OsafNtfCmTestRT"),
SA_AIS_OK);
+ safassert(set_attr_change_extended_name(&n_exp, 2, 2,
SA_NTF_VALUE_LDAP_NAME, &oldvar), SA_AIS_OK);
+ safassert(set_attr_change_extended_name(&n_exp, 3, 2,
SA_NTF_VALUE_LDAP_NAME, &addvar), SA_AIS_OK);
+
+ if (!compare_notifs(&n_exp, &rec_notif_data)) {
+ print_notif(&n_exp);
+ print_notif(&rec_notif_data);
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+ safassert(saNtfNotificationFree(rec_notif_data.nHandle),
SA_AIS_OK);
+ safassert(saNtfNotificationFree(n_exp.nHandle), SA_AIS_OK);
+ } else {
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+ safassert(unsub_notifications(), SA_AIS_OK);
+ safassert(saNtfFinalize(ntfHandle), SA_AIS_OK);
+ test_validate(error, SA_AIS_OK);
+}
+
+
+/**
+ * Create a config object with extended name attribute and verify correctness
of
+ * generated notification.
+ */
+void objectCreateTest_3505(void)
+{
+ char command[1024];
+ SaAisErrorT error = SA_AIS_OK;
+ safassert(init_ntf(), SA_AIS_OK);
+ safassert(subscribe_notifications(), SA_AIS_OK);
+ rec_notif_data.populated = SA_FALSE;
+
+ /* create an object */
+ sprintf(command, "immcfg -t 20 -c OsafNtfCmTestCFG %s -a testNameCfg=%s
-a testStringCfg=%s -a testAnyCfg=%s",
+ DNTESTCFG, extended_name_string_01, STRINGVAR1, BUF1);
+ assert(system(command) != -1);
+
+ /*
+ * Wait for notification reception.
+ */
+ int dwCnt = 0;
+ while (dwCnt++ < POLLWAIT && !rec_notif_data.populated) {
+ saNtfDispatch(ntfHandle, SA_DISPATCH_ALL);
+ if (!rec_notif_data.populated) usleep(100);
+ }
+
+ if (rec_notif_data.populated) {
+ NotifData n_exp;
+ SaInt32T int32Var = INT32VAR1;
+ SaUint32T uint32Var = UINT32VAR1;
+ SaInt64T int64Var = INT64VAR1;
+ SaUint64T uint64Var = UINT64VAR1;
+ SaTimeT timeVar = TIMEVAR1;
+ SaNameT nameVar;
+ saAisNameLend((SaConstStringT)&extended_name_string_01,
&nameVar);
+ SaFloatT floatVar = FLOATVAR1;
+ SaDoubleT doubleVar = DOUBLEVAR1;
+ SaStringT stringVar = STRINGVAR1;
+ SaAnyT anyVar = {.bufferSize = sizeof (BUF1), .bufferAddr =
(SaUint8T*) BUF1};
+
+ safassert(set_ntf(&n_exp, SA_NTF_OBJECT_CREATION, DNTESTCFG,
14, 14), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 0, 0,
"SaImmAttrAdminOwnerName"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 1, 1, "SaImmAttrClassName"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 2, 2, "SaImmOiCcbIdT"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 3, 3, "ccbLast"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 4, 4, "testUint32Cfg"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 5, 5, "testInt32Cfg"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 6, 6, "testUint64Cfg"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 7, 7, "testInt64Cfg"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 8, 8, "testStringCfg"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 9, 9, "testFloatCfg"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 10, 10, "testDoubleCfg"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 11, 11, "testNameCfg"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 12, 12, "testTimeCfg"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 13, 13, "testAnyCfg"),
SA_AIS_OK);
+ safassert(set_attr_str(&n_exp, 0, 0, "immcfg_xxx"), SA_AIS_OK);
+ safassert(set_attr_str(&n_exp, 1, 1, "OsafNtfCmTestCFG"),
SA_AIS_OK);
+ SaUint64T ccidVar = 2;
+ safassert(set_attr_scalar(&n_exp, 2, 2, SA_NTF_VALUE_UINT64,
&ccidVar), SA_AIS_OK);
+ SaUint32T ccbLast = 1;
+ safassert(set_attr_scalar(&n_exp, 3, 3, SA_NTF_VALUE_UINT32,
&ccbLast), SA_AIS_OK);
+ safassert(set_attr_scalar(&n_exp, 4, 4, SA_NTF_VALUE_UINT32,
&uint32Var), SA_AIS_OK);
+ safassert(set_attr_scalar(&n_exp, 5, 5, SA_NTF_VALUE_INT32,
&int32Var), SA_AIS_OK);
+ safassert(set_attr_scalar(&n_exp, 6, 6, SA_NTF_VALUE_UINT64,
&uint64Var), SA_AIS_OK);
+ safassert(set_attr_scalar(&n_exp, 7, 7, SA_NTF_VALUE_INT64,
&int64Var), SA_AIS_OK);
+ safassert(set_attr_str(&n_exp, 8, 8, stringVar), SA_AIS_OK);
+ safassert(set_attr_scalar(&n_exp, 9, 9, SA_NTF_VALUE_FLOAT,
&floatVar), SA_AIS_OK);
+ safassert(set_attr_scalar(&n_exp, 10, 10, SA_NTF_VALUE_DOUBLE,
&doubleVar), SA_AIS_OK);
+ safassert(set_attr_extended_name(&n_exp, 11, 11,
SA_NTF_VALUE_LDAP_NAME, &nameVar), SA_AIS_OK);
+ safassert(set_attr_scalar(&n_exp, 12, 12, SA_NTF_VALUE_INT64,
&timeVar), SA_AIS_OK);
+ safassert(set_attr_buf(&n_exp, 13, 13, SA_NTF_VALUE_BINARY,
&anyVar), SA_AIS_OK);
+
+ if (!compare_notifs(&n_exp, &rec_notif_data)) {
+ print_notif(&n_exp);
+ print_notif(&rec_notif_data);
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+ safassert(saNtfNotificationFree(rec_notif_data.nHandle),
SA_AIS_OK);
+ safassert(saNtfNotificationFree(n_exp.nHandle), SA_AIS_OK);
+ } else {
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+ safassert(unsub_notifications(), SA_AIS_OK);
+ safassert(saNtfFinalize(ntfHandle), SA_AIS_OK);
+ test_validate(error, SA_AIS_OK);
+}
+
+
+/**
+ * Modify a config object with extended name and verify correctness
+ * of generated notification.
+ */
+void objectModifyTest_3506(void)
+{
+ char command[1024];
+ SaAisErrorT error = SA_AIS_OK;
+ safassert(init_ntf(), SA_AIS_OK);
+ safassert(subscribe_notifications(), SA_AIS_OK);
+ rec_notif_data.populated = SA_FALSE;
+
+ SaNameT var1;
+ saAisNameLend((SaConstStringT)&extended_name_string_02, &var1);
+
+ SaAnyT var2 = {.bufferSize = sizeof (BUF2), .bufferAddr = (SaUint8T*)
BUF2};
+
+ /* modify an object */
+ sprintf(command, "immcfg -t 20 -a testNameCfg=%s -a testAnyCfg=%s %s",
+ extended_name_string_02, BUF2, DNTESTCFG);
+ assert(system(command) != -1);
+
+ /*
+ * Wait for notification reception.
+ */
+ int dwCnt = 0;
+ while (dwCnt++ < POLLWAIT && !rec_notif_data.populated) {
+ saNtfDispatch(ntfHandle, SA_DISPATCH_ALL);
+ if (!rec_notif_data.populated) usleep(100);
+ }
+
+ if (rec_notif_data.populated) {
+ NotifData n_exp;
+ safassert(set_ntf(&n_exp, SA_NTF_ATTRIBUTE_CHANGED, DNTESTCFG,
6, 6), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 0, 0,
"SaImmAttrAdminOwnerName"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 1, 1, "SaImmAttrClassName"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 2, 2, "SaImmOiCcbIdT"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 3, 3, "ccbLast"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 4, 4, "testNameCfg"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 5, 5, "testAnyCfg"), SA_AIS_OK);
+ safassert(set_attr_change_str(&n_exp, 0, 0, "immcfg_xxx"),
SA_AIS_OK);
+ safassert(set_attr_change_str(&n_exp, 1, 1,
"OsafNtfCmTestCFG"), SA_AIS_OK);
+ SaUint64T ccidVar = 3;
+ safassert(set_attr_change_scalar(&n_exp, 2, 2,
SA_NTF_VALUE_UINT64, &ccidVar), SA_AIS_OK);
+ SaUint32T ccbLast = 1;
+ safassert(set_attr_change_scalar(&n_exp, 3, 3,
SA_NTF_VALUE_UINT32, &ccbLast), SA_AIS_OK);
+ safassert(set_attr_change_extended_name(&n_exp, 4, 4,
SA_NTF_VALUE_LDAP_NAME, &var1), SA_AIS_OK);
+ safassert(set_attr_change_buf(&n_exp, 5, 5,
SA_NTF_VALUE_BINARY, &var2), SA_AIS_OK);
+
+ if (!compare_notifs(&n_exp, &rec_notif_data)) {
+ print_notif(&n_exp);
+ print_notif(&rec_notif_data);
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+ safassert(saNtfNotificationFree(rec_notif_data.nHandle),
SA_AIS_OK);
+ safassert(saNtfNotificationFree(n_exp.nHandle), SA_AIS_OK);
+ } else {
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+ safassert(unsub_notifications(), SA_AIS_OK);
+ safassert(saNtfFinalize(ntfHandle), SA_AIS_OK);
+ test_validate(error, SA_AIS_OK);
+}
+
+/**
+ * Modify a config object with extended name attribute and verify correctness
+ * of generated notification.
+ */
+void objectModifyTest_3507(void)
+{
+ char command[1024];
+ SaAisErrorT error = SA_AIS_OK;
+ safassert(init_ntf(), SA_AIS_OK);
+ safassert(subscribe_notifications(), SA_AIS_OK);
+ rec_notif_data.populated = SA_FALSE;
+
+ /* modify an object */
+ SaNameT oldvar;
+ saAisNameLend((SaConstStringT)&extended_name_string_02, &oldvar);
+ SaNameT addvar;
+ saAisNameLend((SaConstStringT)&extended_name_string_01, &addvar);
+ sprintf(command, "immcfg -a testNameCfg+=%s %s",
extended_name_string_01, DNTESTCFG);
+ assert(system(command) != -1);
+
+ /*
+ * Wait for notification reception.
+ */
+ int dwCnt = 0;
+ while (dwCnt++ < POLLWAIT && !rec_notif_data.populated) {
+ saNtfDispatch(ntfHandle, SA_DISPATCH_ALL);
+ if (!rec_notif_data.populated) usleep(100);
+ }
+
+ if (rec_notif_data.populated) {
+ NotifData n_exp;
+ safassert(set_ntf(&n_exp, SA_NTF_ATTRIBUTE_CHANGED, DNTESTCFG,
5, 6), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 0, 0,
"SaImmAttrAdminOwnerName"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 1, 1, "SaImmAttrClassName"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 2, 2, "SaImmOiCcbIdT"),
SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 3, 3, "ccbLast"), SA_AIS_OK);
+ safassert(set_add_info(&n_exp, 4, 4, "testNameCfg"), SA_AIS_OK);
+ safassert(set_attr_change_str(&n_exp, 0, 0, "immcfg_xxx"),
SA_AIS_OK);
+ safassert(set_attr_change_str(&n_exp, 1, 1,
"OsafNtfCmTestCFG"), SA_AIS_OK);
+ SaUint64T ccidVar = 3;
+ safassert(set_attr_change_scalar(&n_exp, 2, 2,
SA_NTF_VALUE_UINT64, &ccidVar), SA_AIS_OK);
+ SaUint32T ccbLast = 1;
+ safassert(set_attr_change_scalar(&n_exp, 3, 3,
SA_NTF_VALUE_UINT32, &ccbLast), SA_AIS_OK);
+ safassert(set_attr_change_extended_name(&n_exp, 4, 4,
SA_NTF_VALUE_LDAP_NAME, &oldvar), SA_AIS_OK);
+ safassert(set_attr_change_extended_name(&n_exp, 5, 4,
SA_NTF_VALUE_LDAP_NAME, &addvar), SA_AIS_OK);
+
+ if (!compare_notifs(&n_exp, &rec_notif_data)) {
+ print_notif(&n_exp);
+ print_notif(&rec_notif_data);
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+ safassert(saNtfNotificationFree(rec_notif_data.nHandle),
SA_AIS_OK);
+ safassert(saNtfNotificationFree(n_exp.nHandle), SA_AIS_OK);
+ } else {
+ error = SA_AIS_ERR_FAILED_OPERATION;
+ }
+ safassert(unsub_notifications(), SA_AIS_OK);
+ safassert(saNtfFinalize(ntfHandle), SA_AIS_OK);
+ test_validate(error, SA_AIS_OK);
+}
__attribute__((constructor)) static void ntf_imcn_constructor(void)
{
@@ -4290,9 +4775,15 @@ void objectDeleteTest_3404(void)
rc = system("immcfg -f //tmp//ntfsv_test_classes.xml");
}
if (rc != 0) {
- printf("ntfsv_test_classes.xml file not installed (see README)");
- return;
- }
+ printf("ntfsv_test_classes.xml file not installed (see
README)");
+ return;
+ }
+ memset(&extended_name_string_01, 'C', DEFAULT_EXT_NAME_LENGTH - 1);
+ extended_name_string_01[DEFAULT_EXT_NAME_LENGTH - 1] = '\0';
+
+ memset(&extended_name_string_02, 'D', DEFAULT_EXT_NAME_LENGTH - 1);
+ extended_name_string_02[DEFAULT_EXT_NAME_LENGTH - 1] = '\0';
+
test_suite_add(32, "CM notifications test");
test_case_add(32, objectCreateTest_01, "CREATE, runtime
(OsafNtfCmTestRT) object");
test_case_add(32, objectModifyTest_02, "runtime, attr ch, REPLACE
(UINT32, FLOAT)");
@@ -4334,10 +4825,21 @@ void objectDeleteTest_3404(void)
test_case_add(32, objectMultiCcbTest_38, "config, multiple op in ccb, 2
REPLACE");
test_case_add(32, objectMultiCcbTest_39, "config, multiple op in ccb,
ADD, REPLACE, DELETE");
test_case_add(32, objectDeleteTest_40, "DELETE, config
(OsafNtfCmTestCFG) object");
+
test_suite_add(34, "CM notifications test, persistent runtime");
test_case_add(34, objectCreateTest_3401, "CREATE, runtime
(OsafNtfCmTestRT1) object");
test_case_add(34, objectModifyTest_3402, "runtime, attr ch, REPLACE
(UINT32, FLOAT)");
test_case_add(34, objectModifyTest_3403, "runtime, attr ch, ADD
(INT32)");
test_case_add(34, objectDeleteTest_3404, "DELETE, runtime
(OsafNtfCmTestRT1) object");
+
+ test_suite_add(35, "CM notification test for extended name attribute");
+ test_case_add(35, objectCreateTest_3501, "CREATE, runtime
(OsafNtfCmTestRT) object, extended name attribute");
+ test_case_add(35, objectModifyTest_3502, "runtime, attr ch, REPLACE
(EXTENDED NAME, ANY)");
+ test_case_add(35, objectModifyTest_3503, "runtime, attr ch, ADD
(EXTENDED NAME)");
+ test_case_add(35, objectDeleteTest_19, "DELETE, runtime
(OsafNtfCmTestRT) object");
+ test_case_add(35, objectCreateTest_3505, "CREATE, config
(OsafNtfCmTestCFG) object, extended name attribute");
+ test_case_add(35, objectModifyTest_3506, "config, attr ch, REPLACE
(EXTENDED NAME, ANY)");
+ test_case_add(35, objectModifyTest_3507, "config, attr ch, ADD
(EXTENDED NAME)");
+ test_case_add(35, objectDeleteTest_40, "DELETE, config
(OsafNtfCmTestCFG) object");
}
diff --git a/tests/ntfsv/tet_longDnObject_notification.c
b/tests/ntfsv/tet_longDnObject_notification.c
new file mode 100644
--- /dev/null
+++ b/tests/ntfsv/tet_longDnObject_notification.c
@@ -0,0 +1,972 @@
+/* -*- OpenSAF -*-
+ *
+ * (C) Copyright 2009 The OpenSAF Foundation
+ *
+ * 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.
+ *
+ * Author(s): Ericsson AB
+ *
+ */
+/**
+
+ */
+#include <utest.h>
+#include <util.h>
+#include "tet_ntf.h"
+#include "tet_ntf_common.h"
+//#include "util.h"
+#define NOTIFYING_OBJECT_TEST "AVND"
+#define NTF_REST_MAX_IDS 30
+
+#define DEFAULT_EXT_NAME_LENGTH 300
+#define DEFAULT_UNEXT_NAME_STRING "This is unextended SaNameT string (<256)"
+struct not_idsT {
+ int length;
+ SaNtfIdentifierT ids[NTF_REST_MAX_IDS];
+};
+
+static struct not_idsT received_ids = {0,};
+static struct not_idsT ok_ids = {0,};
+
+static char default_ext_notification_object[DEFAULT_EXT_NAME_LENGTH];
+static char default_ext_notifying_object[DEFAULT_EXT_NAME_LENGTH];
+static char test_longdn_object_1[DEFAULT_EXT_NAME_LENGTH];
+static char test_longdn_object_2[DEFAULT_EXT_NAME_LENGTH];
+static char test_longdn_object_3[DEFAULT_EXT_NAME_LENGTH];
+
+static SaNtfNotificationTypeFilterHandlesT myNotificationFilterHandles;
+
+/* Used to keep track of which ntf we got */
+static SaNtfNotificationTypeFilterHandlesT ntfRecieved;
+
+static int errors;
+static SaNtfSubscriptionIdT subscriptionId;
+static SaNtfAlarmNotificationT myAlarmNotification;
+static SaNtfObjectCreateDeleteNotificationT myObjCrDelNotification;
+static SaNtfAttributeChangeNotificationT myAttrChangeNotification;
+static SaNtfStateChangeNotificationT myStateChangeNotification;
+static SaNtfSecurityAlarmNotificationT mySecAlarmNotification;
+
+extern void saAisNameLend(SaConstStringT value, SaNameT* name);
+extern SaConstStringT saAisNameBorrow(const SaNameT* name);
+
+/**
+ * Init default long dn objects
+ */
+static void init_ext_object()
+{
+ safassert(setenv("SA_ENABLE_EXTENDED_NAMES", "1", 1), 0);
+
+ memset(&default_ext_notification_object, 'A', DEFAULT_EXT_NAME_LENGTH -
1);
+ default_ext_notification_object[DEFAULT_EXT_NAME_LENGTH - 1] = '\0';
+
+ memset(&default_ext_notifying_object, 'B', DEFAULT_EXT_NAME_LENGTH - 1);
+ default_ext_notifying_object[DEFAULT_EXT_NAME_LENGTH - 1] = '\0';
+
+ memset(&test_longdn_object_1, 'C', DEFAULT_EXT_NAME_LENGTH - 1);
+ test_longdn_object_1[DEFAULT_EXT_NAME_LENGTH - 1] = '\0';
+
+ memset(&test_longdn_object_2, 'D', DEFAULT_EXT_NAME_LENGTH - 1);
+ test_longdn_object_2[DEFAULT_EXT_NAME_LENGTH - 1] = '\0';
+
+ memset(&test_longdn_object_3, 'E', DEFAULT_EXT_NAME_LENGTH - 1);
+ test_longdn_object_3[DEFAULT_EXT_NAME_LENGTH - 1] = '\0';
+
+}
+
+/**
+ * Store all recieved notificationIds
+ */
+static void ntf_id_store(SaNtfIdentifierT n_id)
+{
+ assert(NTF_REST_MAX_IDS > received_ids.length);
+ received_ids.ids[received_ids.length++] = n_id;
+}
+
+/**
+ * Post process all recived notificationIds towards the ids that
+ * are expected to be received.
+ */
+static SaAisErrorT check_errors()
+{
+ int i, j, found;
+ SaAisErrorT rc = SA_AIS_OK;
+
+ for (i = 0; i< received_ids.length; i++) {
+ found=0;
+ for (j= 0; j< ok_ids.length; j++) {
+ if (received_ids.ids[i] == ok_ids.ids[j]){
+ found = 1;
+ break;
+ }
+ }
+ if(!found)
+ errors++;
+ }
+ if(errors)
+ {
+ rc = SA_AIS_ERR_FAILED_OPERATION;
+ printf("num of failed notifications: %d\n", errors);
+ }
+ return rc;
+}
+
+static void resetCounters()
+{
+ errors = 0;
+ received_ids.length = 0;
+ ok_ids.length = 0;
+ ntfRecieved.alarmFilterHandle = 0;
+ ntfRecieved.attributeChangeFilterHandle = 0;
+ ntfRecieved.objectCreateDeleteFilterHandle = 0;
+ ntfRecieved.securityAlarmFilterHandle = 0;
+ ntfRecieved.stateChangeFilterHandle = 0;
+}
+
+/**
+ * Creates an ObjectCreateDeleteNotification with default values.
+ *
+ * @param ntfHandle
+ * @param myObjCreDelNotification
+ */
+void extCreateObjectCreateDeleteNotification(SaNtfHandleT ntfHandle,
+ SaNtfObjectCreateDeleteNotificationT *myObjCrDelNotification)
+{
+ SaNtfNotificationHeaderT *head;
+
+ createObjectCreateDeleteNotification(ntfHandle, myObjCrDelNotification);
+ head = &myObjCrDelNotification->notificationHeader;
+ /* Overwrite with long dn object */
+ saAisNameLend((SaConstStringT)&default_ext_notification_object,
head->notificationObject);
+ saAisNameLend((SaConstStringT)&default_ext_notifying_object,
head->notifyingObject);
+}
+
+/**
+ * Creates an AttributeChangeNotification with default values.
+ *
+ * @param ntfhandle
+ * @param myAttrChangeNotification
+ */
+void extCreateAttributeChangeNotification(SaNtfHandleT ntfHandle,
+ SaNtfAttributeChangeNotificationT *myAttrChangeNotification)
+{
+ SaNtfNotificationHeaderT *head;
+
+ createAttributeChangeNotification(ntfHandle, myAttrChangeNotification);
+ head = &myAttrChangeNotification->notificationHeader;
+ /* Overwrite with long dn object */
+ saAisNameLend((SaConstStringT)&default_ext_notification_object,
head->notificationObject);
+ saAisNameLend((SaConstStringT)&default_ext_notifying_object,
head->notifyingObject);
+}
+
+/**
+ * Create a StateChangeNotification with default values.
+ *
+ * @param ntfHandle
+ * @param myStateChangeNotification
+ */
+void extCreateStateChangeNotification(SaNtfHandleT ntfHandle,
+ SaNtfStateChangeNotificationT *myStateChangeNotification)
+{
+ SaNtfNotificationHeaderT *head;
+
+ createStateChangeNotification(ntfHandle, myStateChangeNotification);
+ head = &myStateChangeNotification->notificationHeader;
+ /* Overwrite with long dn object */
+ saAisNameLend((SaConstStringT)&default_ext_notification_object,
head->notificationObject);
+ saAisNameLend((SaConstStringT)&default_ext_notifying_object,
head->notifyingObject);
+}
+
+/**
+ * Create a SecurityAlarmNotification with default values.
+ *
+ * @param ntfHandle
+ * @param mySecAlarmNotification
+ */
+void extCreateSecurityAlarmNotification(SaNtfHandleT ntfHandle,
+ SaNtfSecurityAlarmNotificationT *mySecAlarmNotification)
+{
+ SaNtfNotificationHeaderT *head;
+
+ createSecurityAlarmNotification(ntfHandle, mySecAlarmNotification);
+ head = &mySecAlarmNotification->notificationHeader;
+ /* Overwrite with long dn object */
+ saAisNameLend((SaConstStringT)&default_ext_notification_object,
head->notificationObject);
+ saAisNameLend((SaConstStringT)&default_ext_notifying_object,
head->notifyingObject);
+}
+
+/**
+ * Verify the contents in the notification.
+ * We use the myNotificationFilterHandles to know which notifications to
expect.
+ */
+static void saNtfNotificationCallbackT(
+ SaNtfSubscriptionIdT subscriptionId,
+ const SaNtfNotificationsT *notification)
+{
+ SaNtfNotificationHandleT notificationHandle = 0;
+ switch(notification->notificationType)
+ {
+ case SA_NTF_TYPE_OBJECT_CREATE_DELETE:
+ notificationHandle =
notification->notification.objectCreateDeleteNotification.notificationHandle;
+ ntfRecieved.objectCreateDeleteFilterHandle += 1;
+
if(myNotificationFilterHandles.objectCreateDeleteFilterHandle == 0)
+ errors +=1;
+ else
+
ntf_id_store(*notification->notification.objectCreateDeleteNotification.notificationHeader.notificationId);
+ break;
+
+ case SA_NTF_TYPE_ATTRIBUTE_CHANGE:
+ notificationHandle =
notification->notification.attributeChangeNotification.notificationHandle;
+ ntfRecieved.attributeChangeFilterHandle += 1;
+
if(myNotificationFilterHandles.attributeChangeFilterHandle == 0)
+ errors += 1;
+ else
+
ntf_id_store(*notification->notification.attributeChangeNotification.notificationHeader.notificationId);
+ break;
+
+ case SA_NTF_TYPE_STATE_CHANGE:
+ notificationHandle =
notification->notification.stateChangeNotification.notificationHandle;
+ ntfRecieved.stateChangeFilterHandle += 1;
+ if(myNotificationFilterHandles.stateChangeFilterHandle
== 0)
+ errors += 1;
+ else
+
ntf_id_store(*notification->notification.stateChangeNotification.notificationHeader.notificationId);
+ break;
+
+ case SA_NTF_TYPE_ALARM:
+ notificationHandle =
notification->notification.alarmNotification.notificationHandle;
+ ntfRecieved.alarmFilterHandle += 1;
+ if(myNotificationFilterHandles.alarmFilterHandle == 0) {
+ printf("alarmFilterHandle == 0\n");
+ errors +=1;
+ } else
+
ntf_id_store(*notification->notification.alarmNotification.notificationHeader.notificationId);
+ break;
+
+ case SA_NTF_TYPE_SECURITY_ALARM:
+ notificationHandle =
notification->notification.securityAlarmNotification.notificationHandle;
+ ntfRecieved.securityAlarmFilterHandle += 1;
+
if(myNotificationFilterHandles.securityAlarmFilterHandle == 0)
+ errors += 1;
+ else
+
ntf_id_store(*notification->notification.securityAlarmNotification.notificationHeader.notificationId);
+ break;
+
+ default:
+ errors +=1;
+ assert(0);
+ break;
+ }
+ last_not_id = get_ntf_id(notification);
+ if (notificationHandle != 0)
+ safassert(saNtfNotificationFree(notificationHandle), SA_AIS_OK);
+}
+
+
+static SaNtfCallbacksT ntfCbTest = {
+ saNtfNotificationCallbackT,
+ NULL
+};
+
+/**
+ * Fill the filter header with long dn objects
+ */
+void extFillFilterHeader(SaNtfNotificationFilterHeaderT *head)
+{
+ fillFilterHeader(head);
+ /* Overwrite the objects with long dn */
+ saAisNameLend((SaConstStringT)&default_ext_notification_object,
&head->notificationObjects[0]);
+ saAisNameLend((SaConstStringT)&default_ext_notifying_object,
&head->notifyingObjects[0]);
+}
+
+/**
+ * Fill the header with long dn objects
+ */
+void extFillHeader(SaNtfNotificationHeaderT *head)
+{
+ fillHeader(head);
+ /* Overwrite the objects with long dn */
+ saAisNameLend((SaConstStringT)&default_ext_notification_object,
head->notificationObject);
+ saAisNameLend((SaConstStringT)&default_ext_notifying_object,
head->notifyingObject);
+}
+
+
+/**
+ * Fill header with extended SaNameT in additionalInfo
+ */
+ void extFillHeaderAddInfo(SaNtfNotificationHeaderT *head,
SaNtfNotificationHandleT notHandle)
+ {
+ int i;
+ SaStringT dest_ptr;
+ SaNameT name1, name2, name3, name4, name5;
+ *(head->eventType) = SA_NTF_ALARM_COMMUNICATION;
+ *(head->eventTime) = SA_TIME_UNKNOWN;
+
+ saAisNameLend((SaConstStringT)&default_ext_notification_object,
head->notificationObject);
+ saAisNameLend((SaConstStringT)&default_ext_notifying_object,
head->notifyingObject);
+
+ head->notificationClassId->vendorId = ERICSSON_VENDOR_ID;
+ head->notificationClassId->majorId = 92;
+ head->notificationClassId->minorId = 12;
+
+ /* set additional text */
+ (void)strncpy(head->additionalText,
+ DEFAULT_ADDITIONAL_TEXT,
+ (SaUint16T)(strlen(DEFAULT_ADDITIONAL_TEXT) + 1));
+
+ for (i = 0; i < head->numCorrelatedNotifications; i++)
+ head->correlatedNotifications[i] = (SaNtfIdentifierT) (i + 400);
+
+ // Fill first additionalInfo as extended SaNameT including NULL
character
+ head->additionalInfo[0].infoType = SA_NTF_VALUE_LDAP_NAME;
+ head->additionalInfo[0].infoId = 1;
+ saAisNameLend((SaConstStringT)&test_longdn_object_1, &name1);
+
+ safassert(saNtfPtrValAllocate(notHandle,
+ strlen(saAisNameBorrow(&name1)) + 3,
+ (void**)&dest_ptr,
+ &(head->additionalInfo[0].infoValue)),
SA_AIS_OK);
+
+ saAisNameLend(saAisNameBorrow(&name1), (SaNameT*) dest_ptr);
+
+ // Fill sencond additionalInfo as extended SaNameT excluding NULL
character
+ head->additionalInfo[1].infoType = SA_NTF_VALUE_LDAP_NAME;
+ head->additionalInfo[1].infoId = 1;
+ saAisNameLend((SaConstStringT)&test_longdn_object_2, &name2);
+
+ safassert(saNtfPtrValAllocate(notHandle,
+ strlen(saAisNameBorrow(&name2)) + 2,
+ (void**)&dest_ptr,
+ &(head->additionalInfo[1].infoValue)),
SA_AIS_OK);
+
+ saAisNameLend(saAisNameBorrow(&name2), (SaNameT*) dest_ptr);
+
+
+ //Fill third additionalInfo as extended SaNameT as legacy code ->
object is truncated
+ head->additionalInfo[2].infoType = SA_NTF_VALUE_LDAP_NAME;
+ head->additionalInfo[2].infoId = 1;
+ saAisNameLend((SaConstStringT)&test_longdn_object_3, &name3);
+ safassert(saNtfPtrValAllocate(notHandle,
+ sizeof(name3) + 1,
+ (void**)&dest_ptr,
+ &(head->additionalInfo[2].infoValue)),
SA_AIS_OK);
+
+ memcpy(dest_ptr, &name3, sizeof(name3));
+
+ // Fill fourth additionalInfo as unextended SaNameT as legacy code
+ head->additionalInfo[3].infoType = SA_NTF_VALUE_LDAP_NAME;
+ head->additionalInfo[3].infoId = 1;
+ saAisNameLend(DEFAULT_UNEXT_NAME_STRING, &name4);
+
+ safassert(saNtfPtrValAllocate(notHandle,
+ sizeof(name4) + 1,
+ (void**)&dest_ptr,
+ &(head->additionalInfo[3].infoValue)),
SA_AIS_OK);
+
+ memcpy(dest_ptr, &name4, sizeof(name4));
+
+ //Fill the fifth additionalInfo as unextended SaNameT as modern code
+ head->additionalInfo[4].infoType = SA_NTF_VALUE_LDAP_NAME;
+ head->additionalInfo[4].infoId = 1;
+ saAisNameLend(DEFAULT_UNEXT_NAME_STRING, &name5);
+
+ safassert(saNtfPtrValAllocate(notHandle,
+ strlen(saAisNameBorrow(&name5)) + 3,
+ (void**)&dest_ptr,
+ &(head->additionalInfo[4].infoValue)),
SA_AIS_OK);
+
+ saAisNameLend(saAisNameBorrow(&name5), (SaNameT*) dest_ptr);
+ }
+
+ /**
+ * Test AdditionalInfo with extended SaNameT type
+ */
+ void extAdditionalInfoTest(void)
+ {
+ SaNtfAlarmNotificationFilterT myAlarmFilter;
+ subscriptionId = 1;
+ SaNtfNotificationHeaderT *head;
+
+ rc = SA_AIS_OK;
+
+ resetCounters();
+
+ safassert(saNtfInitialize(&ntfHandle, &ntfCbTest, &ntfVersion) ,
SA_AIS_OK);
+ safassert(saNtfSelectionObjectGet(ntfHandle, &selectionObject) ,
SA_AIS_OK);
+
+ /* specify complex filter */
+ safassert(saNtfAlarmNotificationFilterAllocate(
+ ntfHandle,
+ &myAlarmFilter,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0), SA_AIS_OK);
+ /* set header filter specific fields */
+ extFillFilterHeader(&myAlarmFilter.notificationFilterHeader);
+
+ /* Initialize filter handles */
+ myNotificationFilterHandles.alarmFilterHandle =
+ myAlarmFilter.notificationFilterHandle;
+ myNotificationFilterHandles.attributeChangeFilterHandle = 0;
+ myNotificationFilterHandles.objectCreateDeleteFilterHandle = 0;
+ myNotificationFilterHandles.securityAlarmFilterHandle = 0;
+ myNotificationFilterHandles.stateChangeFilterHandle = 0;
+
+ safassert(saNtfNotificationSubscribe(&myNotificationFilterHandles,
+ subscriptionId), SA_AIS_OK);
+
+ /* Create a notification and send it */
+ safassert(saNtfAlarmNotificationAllocate(
+ ntfHandle,
+ &myAlarmNotification,
+ 0,
+ (SaUint16T)(strlen(DEFAULT_ADDITIONAL_TEXT) + 1),
+ 5,
+ 0,
+ 0,
+ 0,
+ SA_NTF_ALLOC_SYSTEM_LIMIT), SA_AIS_OK);
+
+ head = &myAlarmNotification.notificationHeader;
+ extFillHeaderAddInfo(head, myAlarmNotification.notificationHandle);
+ /* These 3 fields is alarm filter items */
+ *(myAlarmNotification.perceivedSeverity) = SA_NTF_SEVERITY_WARNING;
+ *(myAlarmNotification.probableCause) = SA_NTF_BANDWIDTH_REDUCED;
+ *myAlarmNotification.trend = SA_NTF_TREND_MORE_SEVERE;
+
+ myAlarmNotification.thresholdInformation->thresholdValueType =
SA_NTF_VALUE_UINT32;
+ myAlarmNotification.thresholdInformation->thresholdValue.uint32Val =
600;
+ myAlarmNotification.thresholdInformation->thresholdHysteresis.uint32Val
= 100;
+ myAlarmNotification.thresholdInformation->observedValue.uint32Val = 567;
+ myAlarmNotification.thresholdInformation->armTime = SA_TIME_UNKNOWN;
+
+
safassert(saNtfNotificationSend(myAlarmNotification.notificationHandle),
SA_AIS_OK);
+
+ /* only this notification should be caught */
+ ok_ids.ids[ok_ids.length++] =
*myAlarmNotification.notificationHeader.notificationId;
+ poll_until_received(ntfHandle,
*myAlarmNotification.notificationHeader.notificationId);
+
+ if(ntfRecieved.alarmFilterHandle != 1 ||
+ ntfRecieved.attributeChangeFilterHandle != 0 ||
+ ntfRecieved.objectCreateDeleteFilterHandle !=0 ||
+ ntfRecieved.securityAlarmFilterHandle != 0 ||
+ ntfRecieved.stateChangeFilterHandle != 0)
safassert(SA_AIS_ERR_BAD_FLAGS, SA_AIS_OK);
+
+ safassert(saNtfNotificationFree(myAlarmNotification.notificationHandle)
, SA_AIS_OK);
+
safassert(saNtfNotificationFilterFree(myAlarmFilter.notificationFilterHandle),
SA_AIS_OK);
+ safassert(saNtfNotificationUnsubscribe(subscriptionId), SA_AIS_OK);
+
+ safassert(saNtfFinalize(ntfHandle), SA_AIS_OK);
+ rc = check_errors();
+ test_validate(rc, SA_AIS_OK);
+ }
+
+/**
+ * Test all filter header fields
+ */
+void extFilterNotificationTest(void)
+{
+ SaNtfAlarmNotificationFilterT myAlarmFilter;
+ subscriptionId = 1;
+ SaNtfNotificationHeaderT *head;
+
+ rc = SA_AIS_OK;
+
+ resetCounters();
+
+ safassert(saNtfInitialize(&ntfHandle, &ntfCbTest, &ntfVersion) ,
SA_AIS_OK);
+ safassert(saNtfSelectionObjectGet(ntfHandle, &selectionObject) ,
SA_AIS_OK);
+
+ /* specify complex filter */
+ safassert(saNtfAlarmNotificationFilterAllocate(
+ ntfHandle,
+ &myAlarmFilter,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0), SA_AIS_OK);
+ /* set header filter specific fields */
+ extFillFilterHeader(&myAlarmFilter.notificationFilterHeader);
+
+ /* Initialize filter handles */
+ myNotificationFilterHandles.alarmFilterHandle =
+ myAlarmFilter.notificationFilterHandle;
+ myNotificationFilterHandles.attributeChangeFilterHandle = 0;
+ myNotificationFilterHandles.objectCreateDeleteFilterHandle = 0;
+ myNotificationFilterHandles.securityAlarmFilterHandle = 0;
+ myNotificationFilterHandles.stateChangeFilterHandle = 0;
+
+ safassert(saNtfNotificationSubscribe(&myNotificationFilterHandles,
+ subscriptionId), SA_AIS_OK);
+
+ /* Create a notification and send it */
+ safassert(saNtfAlarmNotificationAllocate(
+ ntfHandle,
+ &myAlarmNotification,
+ 0,
+ (SaUint16T)(strlen(DEFAULT_ADDITIONAL_TEXT) + 1),
+ 0,
+ 0,
+ 0,
+ 0,
+ SA_NTF_ALLOC_SYSTEM_LIMIT), SA_AIS_OK);
+
+ head = &myAlarmNotification.notificationHeader;
+ extFillHeader(head);
+
+ /* These 3 fields is alarm filter items */
+ *(myAlarmNotification.perceivedSeverity) = SA_NTF_SEVERITY_WARNING;
+ *(myAlarmNotification.probableCause) = SA_NTF_BANDWIDTH_REDUCED;
+ *myAlarmNotification.trend = SA_NTF_TREND_MORE_SEVERE;
+
+ myAlarmNotification.thresholdInformation->thresholdValueType =
SA_NTF_VALUE_UINT32;
+ myAlarmNotification.thresholdInformation->thresholdValue.uint32Val =
600;
+ myAlarmNotification.thresholdInformation->thresholdHysteresis.uint32Val
= 100;
+ myAlarmNotification.thresholdInformation->observedValue.uint32Val = 567;
+ myAlarmNotification.thresholdInformation->armTime = SA_TIME_UNKNOWN;
+
+ *(head->eventType) = SA_NTF_ALARM_EQUIPMENT;
+
safassert(saNtfNotificationSend(myAlarmNotification.notificationHandle),
SA_AIS_OK);
+
+ saAisNameLend((SaConstStringT)&test_longdn_object_1,
head->notificationObject);
+
safassert(saNtfNotificationSend(myAlarmNotification.notificationHandle),
SA_AIS_OK);
+
+ extFillHeader(head);
+ saAisNameLend(NOTIFYING_OBJECT_TEST, head->notifyingObject);
+
safassert(saNtfNotificationSend(myAlarmNotification.notificationHandle),
SA_AIS_OK);
+
+ extFillHeader(head);
+ head->notificationClassId->vendorId = 199;
+
safassert(saNtfNotificationSend(myAlarmNotification.notificationHandle),
SA_AIS_OK);
+
+ extFillHeader(head);
+ head->notificationClassId->majorId = 89;
+
safassert(saNtfNotificationSend(myAlarmNotification.notificationHandle),
SA_AIS_OK);
+
+ extFillHeader(head);
+ head->notificationClassId->minorId = 24;
+
safassert(saNtfNotificationSend(myAlarmNotification.notificationHandle),
SA_AIS_OK);
+
+ extFillHeader(head);
+
safassert(saNtfNotificationSend(myAlarmNotification.notificationHandle),
SA_AIS_OK);
+
+ /* only this notification should be caught */
+ ok_ids.ids[ok_ids.length++] =
*myAlarmNotification.notificationHeader.notificationId;
+ poll_until_received(ntfHandle,
*myAlarmNotification.notificationHeader.notificationId);
+
+ if(ntfRecieved.alarmFilterHandle != 1 ||
+ ntfRecieved.attributeChangeFilterHandle != 0 ||
+ ntfRecieved.objectCreateDeleteFilterHandle !=0 ||
+ ntfRecieved.securityAlarmFilterHandle != 0 ||
+ ntfRecieved.stateChangeFilterHandle != 0)
safassert(SA_AIS_ERR_BAD_FLAGS, SA_AIS_OK);
+
+ safassert(saNtfNotificationFree(myAlarmNotification.notificationHandle)
, SA_AIS_OK);
+
safassert(saNtfNotificationFilterFree(myAlarmFilter.notificationFilterHandle),
SA_AIS_OK);
+ safassert(saNtfNotificationUnsubscribe(subscriptionId), SA_AIS_OK);
+
+ safassert(saNtfFinalize(ntfHandle), SA_AIS_OK);
+ rc = check_errors();
+ test_validate(rc, SA_AIS_OK);
+}
+
+/**
+ * Test Alarm notification with long dn objects
+ */
+void extAlarmNotificationTest(void)
+{
+ SaNtfAlarmNotificationFilterT myAlarmFilter;
+ subscriptionId = 1;
+
+ rc = SA_AIS_OK;
+
+ resetCounters();
+
+ safassert(saNtfInitialize(&ntfHandle, &ntfCbTest, &ntfVersion) ,
SA_AIS_OK);
+ safassert(saNtfSelectionObjectGet(ntfHandle, &selectionObject) ,
SA_AIS_OK);
+
+ safassert(saNtfAlarmNotificationFilterAllocate(
+ ntfHandle,
+ &myAlarmFilter,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1), SA_AIS_OK);
+ /* Set perceived severities */
+ myAlarmFilter.perceivedSeverities[0] = SA_NTF_SEVERITY_WARNING;
+ myAlarmFilter.probableCauses[0] = SA_NTF_BANDWIDTH_REDUCED;
+ myAlarmFilter.trends[0] = SA_NTF_TREND_MORE_SEVERE;
+
+ /* Initialize filter handles */
+ myNotificationFilterHandles.alarmFilterHandle =
+ myAlarmFilter.notificationFilterHandle;
+ myNotificationFilterHandles.attributeChangeFilterHandle = 0;
+ myNotificationFilterHandles.objectCreateDeleteFilterHandle = 0;
+ myNotificationFilterHandles.securityAlarmFilterHandle = 0;
+ myNotificationFilterHandles.stateChangeFilterHandle = 0;
+
+ safassert(saNtfNotificationSubscribe(&myNotificationFilterHandles,
+ subscriptionId), SA_AIS_OK);
+
+ /* Create a notification and send it */
+ safassert(saNtfAlarmNotificationAllocate(
+ ntfHandle,
+ &myAlarmNotification,
+ 0,
+ (SaUint16T)(strlen(DEFAULT_ADDITIONAL_TEXT) +
1),
+ 0,
+ 0,
+ 0,
+ 0,
+ SA_NTF_ALLOC_SYSTEM_LIMIT), SA_AIS_OK);
+ extFillHeader(&myAlarmNotification.notificationHeader);
+
+ *(myAlarmNotification.perceivedSeverity) = SA_NTF_SEVERITY_CRITICAL;
+ *(myAlarmNotification.probableCause) = SA_NTF_CALL_ESTABLISHMENT_ERROR;
+ *myAlarmNotification.trend = SA_NTF_TREND_NO_CHANGE;
+
safassert(saNtfNotificationSend(myAlarmNotification.notificationHandle),
SA_AIS_OK);
+
+ *(myAlarmNotification.perceivedSeverity) = SA_NTF_SEVERITY_WARNING;
+ *(myAlarmNotification.probableCause) = SA_NTF_PRESSURE_UNACCEPTABLE;
+
safassert(saNtfNotificationSend(myAlarmNotification.notificationHandle),
SA_AIS_OK);
+
+ *(myAlarmNotification.perceivedSeverity) = SA_NTF_SEVERITY_WARNING;
+ *(myAlarmNotification.probableCause) = SA_NTF_BANDWIDTH_REDUCED;
+ *myAlarmNotification.trend = SA_NTF_TREND_NO_CHANGE;
+
safassert(saNtfNotificationSend(myAlarmNotification.notificationHandle),
SA_AIS_OK);
+
+ extFillHeader(&myAlarmNotification.notificationHeader);
+ /* These 3 fields is filter items */
+ *(myAlarmNotification.perceivedSeverity) = SA_NTF_SEVERITY_WARNING;
+ *(myAlarmNotification.probableCause) = SA_NTF_BANDWIDTH_REDUCED;
+ *myAlarmNotification.trend = SA_NTF_TREND_MORE_SEVERE;
+ myAlarmNotification.thresholdInformation->thresholdValueType =
SA_NTF_VALUE_UINT32;
+ myAlarmNotification.thresholdInformation->thresholdValue.uint32Val =
600;
+ myAlarmNotification.thresholdInformation->thresholdHysteresis.uint32Val
= 100;
+ myAlarmNotification.thresholdInformation->observedValue.uint32Val = 567;
+ myAlarmNotification.thresholdInformation->armTime = SA_TIME_UNKNOWN;
+
safassert(saNtfNotificationSend(myAlarmNotification.notificationHandle),
SA_AIS_OK);
+ /* only this notification should be caught*/
+ ok_ids.ids[ok_ids.length++] =
*myAlarmNotification.notificationHeader.notificationId;
+ poll_until_received(ntfHandle,
*myAlarmNotification.notificationHeader.notificationId);
+ if(ntfRecieved.alarmFilterHandle != 1 ||
+ ntfRecieved.attributeChangeFilterHandle != 0 ||
+ ntfRecieved.objectCreateDeleteFilterHandle !=0 ||
+ ntfRecieved.securityAlarmFilterHandle != 0 ||
+ ntfRecieved.stateChangeFilterHandle != 0)
safassert(SA_AIS_ERR_BAD_FLAGS, SA_AIS_OK);
+
+ safassert(saNtfNotificationFree(myAlarmNotification.notificationHandle)
, SA_AIS_OK);
+
safassert(saNtfNotificationFilterFree(myAlarmFilter.notificationFilterHandle),
SA_AIS_OK);
+
+ safassert(saNtfNotificationUnsubscribe(subscriptionId), SA_AIS_OK);
+ safassert(saNtfFinalize(ntfHandle), SA_AIS_OK);
+ rc = check_errors();
+ test_validate(rc, SA_AIS_OK);
+}
+
+/**
+ * Test Object Create/Delete notification with long dn objects
+ */
+void extObjectCreateDeleteNotificationTest(void)
+{
+ SaNtfObjectCreateDeleteNotificationFilterT myFilter;
+
+ subscriptionId = 2;
+
+ resetCounters();
+
+ safassert(saNtfInitialize(&ntfHandle, &ntfCbTest, &ntfVersion) ,
SA_AIS_OK);
+ safassert(saNtfSelectionObjectGet(ntfHandle, &selectionObject) ,
SA_AIS_OK);
+
+ safassert(saNtfObjectCreateDeleteNotificationFilterAllocate(
+ ntfHandle,
+ &myFilter,
+ 1,
+ 1,
+ 1,
+ 1,
+ 2), SA_AIS_OK);
+ myFilter.sourceIndicators[0] = SA_NTF_OBJECT_OPERATION;
+ myFilter.sourceIndicators[1] = SA_NTF_MANAGEMENT_OPERATION;
+ extFillFilterHeader(&myFilter.notificationFilterHeader);
+ myFilter.notificationFilterHeader.eventTypes[0] =
SA_NTF_OBJECT_CREATION;
+ /* Initialize filter handles */
+ myNotificationFilterHandles.alarmFilterHandle = 0;
+ myNotificationFilterHandles.attributeChangeFilterHandle = 0;
+ myNotificationFilterHandles.objectCreateDeleteFilterHandle =
+ myFilter.notificationFilterHandle;
+ myNotificationFilterHandles.securityAlarmFilterHandle = 0;
+ myNotificationFilterHandles.stateChangeFilterHandle = 0;
+ safassert(saNtfNotificationSubscribe(&myNotificationFilterHandles,
+ subscriptionId), SA_AIS_OK);
+ extCreateObjectCreateDeleteNotification(ntfHandle,
&myObjCrDelNotification);
+ *(myObjCrDelNotification.sourceIndicator) = SA_NTF_OBJECT_OPERATION;
+
safassert(saNtfNotificationSend(myObjCrDelNotification.notificationHandle),
SA_AIS_OK);
+ /* this notification should be caught*/
+ ok_ids.ids[ok_ids.length++] =
*myObjCrDelNotification.notificationHeader.notificationId;
+
+ *(myObjCrDelNotification.sourceIndicator) = SA_NTF_UNKNOWN_OPERATION;
+
safassert(saNtfNotificationSend(myObjCrDelNotification.notificationHandle),
SA_AIS_OK);
+
+ *(myObjCrDelNotification.sourceIndicator) =
SA_NTF_MANAGEMENT_OPERATION;
+
safassert(saNtfNotificationSend(myObjCrDelNotification.notificationHandle),
SA_AIS_OK);
+ /* this notification should be caught*/
+ ok_ids.ids[ok_ids.length++] =
*myObjCrDelNotification.notificationHeader.notificationId;
+ poll_until_received(ntfHandle,
*myObjCrDelNotification.notificationHeader.notificationId);
+ if(ntfRecieved.alarmFilterHandle != 0 ||
+ ntfRecieved.attributeChangeFilterHandle != 0 ||
+ ntfRecieved.objectCreateDeleteFilterHandle !=
ok_ids.length||
+ ntfRecieved.securityAlarmFilterHandle != 0 ||
+ ntfRecieved.stateChangeFilterHandle != 0)
safassert(SA_AIS_ERR_BAD_FLAGS, SA_AIS_OK);
+
safassert(saNtfNotificationFree(myObjCrDelNotification.notificationHandle),
SA_AIS_OK);
+
safassert(saNtfNotificationFilterFree(myFilter.notificationFilterHandle),
SA_AIS_OK);
+
+ safassert(saNtfNotificationUnsubscribe(subscriptionId), SA_AIS_OK);
+ safassert(saNtfFinalize(ntfHandle) , SA_AIS_OK);
+ rc = check_errors();
+ test_validate(rc, SA_AIS_OK);
+}
+
+/**
+ * Test Attribute Change notification with long dn objects
+ */
+void extAttributeChangeNotificationTest(void)
+{
+ SaNtfAttributeChangeNotificationFilterT myFilter;
+
+ subscriptionId = 2;
+
+ resetCounters();
+
+ safassert(saNtfInitialize(&ntfHandle, &ntfCbTest, &ntfVersion) ,
SA_AIS_OK);
+ safassert(saNtfSelectionObjectGet(ntfHandle, &selectionObject) ,
SA_AIS_OK);
+
+ safassert(saNtfAttributeChangeNotificationFilterAllocate(
+ ntfHandle,
+ &myFilter,
+ 1,
+ 1,
+ 1,
+ 1,
+ 2), SA_AIS_OK);
+
+ myFilter.sourceIndicators[0] = SA_NTF_OBJECT_OPERATION;
+ myFilter.sourceIndicators[1] = SA_NTF_MANAGEMENT_OPERATION;
+ extFillFilterHeader(&myFilter.notificationFilterHeader);
+ myFilter.notificationFilterHeader.eventTypes[0] =
SA_NTF_ATTRIBUTE_CHANGED;
+ /* Initialize filter handles */
+ myNotificationFilterHandles.alarmFilterHandle = 0;
+ myNotificationFilterHandles.attributeChangeFilterHandle =
+ myFilter.notificationFilterHandle;
+ myNotificationFilterHandles.objectCreateDeleteFilterHandle = 0;
+ myNotificationFilterHandles.securityAlarmFilterHandle = 0;
+ myNotificationFilterHandles.stateChangeFilterHandle = 0;
+ safassert(saNtfNotificationSubscribe(&myNotificationFilterHandles,
+ subscriptionId), SA_AIS_OK);
+ extCreateAttributeChangeNotification(ntfHandle,
&myAttrChangeNotification);
+ *(myAttrChangeNotification.sourceIndicator) = SA_NTF_OBJECT_OPERATION;
+
safassert(saNtfNotificationSend(myAttrChangeNotification.notificationHandle),
SA_AIS_OK);
+ /* this notification should be caught*/
+ ok_ids.ids[ok_ids.length++] =
*myAttrChangeNotification.notificationHeader.notificationId;
+
+ *(myAttrChangeNotification.sourceIndicator) = SA_NTF_UNKNOWN_OPERATION;
+
safassert(saNtfNotificationSend(myAttrChangeNotification.notificationHandle),
SA_AIS_OK);
+
+ *(myAttrChangeNotification.sourceIndicator) =
SA_NTF_MANAGEMENT_OPERATION;
+
safassert(saNtfNotificationSend(myAttrChangeNotification.notificationHandle),
SA_AIS_OK);
+ /* this notification should be caught*/
+ ok_ids.ids[ok_ids.length++] =
*myAttrChangeNotification.notificationHeader.notificationId;
+ poll_until_received(ntfHandle,
*myAttrChangeNotification.notificationHeader.notificationId);
+ if(ntfRecieved.alarmFilterHandle != 0 ||
+ ntfRecieved.attributeChangeFilterHandle !=
ok_ids.length ||
+ ntfRecieved.objectCreateDeleteFilterHandle != 0||
+ ntfRecieved.securityAlarmFilterHandle != 0 ||
+ ntfRecieved.stateChangeFilterHandle != 0)
safassert(SA_AIS_ERR_BAD_FLAGS, SA_AIS_OK);
+
safassert(saNtfNotificationFree(myAttrChangeNotification.notificationHandle),
SA_AIS_OK);
+
safassert(saNtfNotificationFilterFree(myFilter.notificationFilterHandle),
SA_AIS_OK);
+
+
+ safassert(saNtfNotificationUnsubscribe(subscriptionId), SA_AIS_OK);
+ safassert(saNtfFinalize(ntfHandle) , SA_AIS_OK);
+ rc = check_errors();
+ test_validate(rc, SA_AIS_OK);
+}
+
+/**
+ * Test State Change notification with long dn objects
+ */
+void extStateChangeNotificationTest(void)
+{
+ SaNtfStateChangeNotificationFilterT myFilter;
+
+ subscriptionId = 2;
+
+ resetCounters();
+
+ safassert(saNtfInitialize(&ntfHandle, &ntfCbTest, &ntfVersion) ,
SA_AIS_OK);
+ safassert(saNtfSelectionObjectGet(ntfHandle, &selectionObject) ,
SA_AIS_OK);
+
+ safassert(saNtfStateChangeNotificationFilterAllocate(
+ ntfHandle,
+ &myFilter,
+ 1,
+ 1,
+ 1,
+ 1,
+ 2,
+ 0), SA_AIS_OK);
+
+ myFilter.sourceIndicators[0] = SA_NTF_OBJECT_OPERATION;
+ myFilter.sourceIndicators[1] = SA_NTF_MANAGEMENT_OPERATION;
+ extFillFilterHeader(&myFilter.notificationFilterHeader);
+ myFilter.notificationFilterHeader.eventTypes[0] =
SA_NTF_OBJECT_STATE_CHANGE;
+ /* Initialize filter handles */
+ myNotificationFilterHandles.alarmFilterHandle = 0;
+ myNotificationFilterHandles.attributeChangeFilterHandle = 0;
+ myNotificationFilterHandles.objectCreateDeleteFilterHandle = 0;
+ myNotificationFilterHandles.securityAlarmFilterHandle = 0;
+ myNotificationFilterHandles.stateChangeFilterHandle =
myFilter.notificationFilterHandle;
+ safassert(saNtfNotificationSubscribe(&myNotificationFilterHandles,
+ subscriptionId), SA_AIS_OK);
+
+ extCreateStateChangeNotification(ntfHandle,
&myStateChangeNotification);
+ *(myStateChangeNotification.sourceIndicator) = SA_NTF_OBJECT_OPERATION;
+
safassert(saNtfNotificationSend(myStateChangeNotification.notificationHandle),
SA_AIS_OK);
+ /* this notification should be caught*/
+ ok_ids.ids[ok_ids.length++] =
*myStateChangeNotification.notificationHeader.notificationId;
+
+ *(myStateChangeNotification.sourceIndicator) = SA_NTF_UNKNOWN_OPERATION;
+
safassert(saNtfNotificationSend(myStateChangeNotification.notificationHandle),
SA_AIS_OK);
+
+ *(myStateChangeNotification.sourceIndicator) =
SA_NTF_MANAGEMENT_OPERATION;
+
safassert(saNtfNotificationSend(myStateChangeNotification.notificationHandle),
SA_AIS_OK);
+ /* this notification should be caught*/
+ ok_ids.ids[ok_ids.length++] =
*myStateChangeNotification.notificationHeader.notificationId;
+ poll_until_received(ntfHandle,
*myStateChangeNotification.notificationHeader.notificationId);
+ if(ntfRecieved.alarmFilterHandle != 0 ||
+ ntfRecieved.attributeChangeFilterHandle != 0 ||
+ ntfRecieved.objectCreateDeleteFilterHandle != 0||
+ ntfRecieved.securityAlarmFilterHandle != 0 ||
+ ntfRecieved.stateChangeFilterHandle != ok_ids.length)
safassert(SA_AIS_ERR_BAD_FLAGS, SA_AIS_OK);
+
safassert(saNtfNotificationFree(myStateChangeNotification.notificationHandle),
SA_AIS_OK);
+
safassert(saNtfNotificationFilterFree(myFilter.notificationFilterHandle),
SA_AIS_OK);
+
+ safassert(saNtfNotificationUnsubscribe(subscriptionId), SA_AIS_OK);
+ safassert(saNtfFinalize(ntfHandle), SA_AIS_OK);
+ rc = check_errors();
+ test_validate(rc, SA_AIS_OK);
+}
+
+/**
+ * Test Security Alarm notification with long dn objects
+ */
+void extSecurityAlarmNotificationTest(void)
+{
+ SaNtfSecurityAlarmNotificationFilterT myFilter;
+
+ subscriptionId = 5;
+
+ resetCounters();
+ safassert(saNtfInitialize(&ntfHandle, &ntfCbTest, &ntfVersion) ,
SA_AIS_OK);
+ safassert(saNtfSelectionObjectGet(ntfHandle, &selectionObject) ,
SA_AIS_OK);
+
+ safassert(saNtfSecurityAlarmNotificationFilterAllocate(
+ ntfHandle,
+ &myFilter,
+ 0,
+ 0,
+ 0,
+ 0,
+ 3,
+ 0,
+ 0,
+ 0,
+ 0), SA_AIS_OK);
+
+ /* Initialize filter handles */
+ myNotificationFilterHandles.alarmFilterHandle = 0;
+ myNotificationFilterHandles.attributeChangeFilterHandle = 0;
+ myNotificationFilterHandles.objectCreateDeleteFilterHandle = 0;
+ myNotificationFilterHandles.securityAlarmFilterHandle =
+
myFilter.notificationFilterHandle;
+ myNotificationFilterHandles.stateChangeFilterHandle = 0;
+ myFilter.probableCauses[0] = SA_NTF_ADAPTER_ERROR;
+ myFilter.probableCauses[1] = SA_NTF_EQUIPMENT_MALFUNCTION;
+ myFilter.probableCauses[2] = SA_NTF_VERSION_MISMATCH;
+
+ /* subscribe */
+ safassert(saNtfNotificationSubscribe(&myNotificationFilterHandles,
+ subscriptionId), SA_AIS_OK);
+ extCreateSecurityAlarmNotification(ntfHandle, &mySecAlarmNotification);
+
safassert(saNtfNotificationSend(mySecAlarmNotification.notificationHandle),
SA_AIS_OK);
+
+ *mySecAlarmNotification.probableCause = SA_NTF_VERSION_MISMATCH;
+
safassert(saNtfNotificationSend(mySecAlarmNotification.notificationHandle),
SA_AIS_OK);
+ ok_ids.ids[ok_ids.length++] =
*mySecAlarmNotification.notificationHeader.notificationId;
+
+ *mySecAlarmNotification.probableCause = SA_NTF_RESPONSE_TIME_EXCESSIVE;
+
safassert(saNtfNotificationSend(mySecAlarmNotification.notificationHandle),
SA_AIS_OK);
+
+ *mySecAlarmNotification.probableCause = SA_NTF_NON_REPUDIATION_FAILURE;
+
safassert(saNtfNotificationSend(mySecAlarmNotification.notificationHandle),
SA_AIS_OK);
+
+ *mySecAlarmNotification.probableCause = SA_NTF_EQUIPMENT_MALFUNCTION;
+
safassert(saNtfNotificationSend(mySecAlarmNotification.notificationHandle),
SA_AIS_OK);
+ ok_ids.ids[ok_ids.length++] =
*mySecAlarmNotification.notificationHeader.notificationId;
+ *mySecAlarmNotification.probableCause =
SA_NTF_STORAGE_CAPACITY_PROBLEM;
+
safassert(saNtfNotificationSend(mySecAlarmNotification.notificationHandle),
SA_AIS_OK);
+ *mySecAlarmNotification.probableCause = SA_NTF_DENIAL_OF_SERVICE;
+
safassert(saNtfNotificationSend(mySecAlarmNotification.notificationHandle),
SA_AIS_OK);
+ *mySecAlarmNotification.probableCause = SA_NTF_ADAPTER_ERROR;
+
safassert(saNtfNotificationSend(mySecAlarmNotification.notificationHandle),
SA_AIS_OK);
+ ok_ids.ids[ok_ids.length++] =
*mySecAlarmNotification.notificationHeader.notificationId;
+ poll_until_received(ntfHandle,
*mySecAlarmNotification.notificationHeader.notificationId);
+ if(ntfRecieved.alarmFilterHandle != 0 ||
+ ntfRecieved.attributeChangeFilterHandle != 0 ||
+ ntfRecieved.objectCreateDeleteFilterHandle !=0 ||
+ ntfRecieved.securityAlarmFilterHandle != ok_ids.length
||
+ ntfRecieved.stateChangeFilterHandle != 0)
safassert(SA_AIS_ERR_BAD_FLAGS, SA_AIS_OK);
+
safassert(saNtfNotificationFree(mySecAlarmNotification.notificationHandle),
SA_AIS_OK);
+
safassert(saNtfNotificationFilterFree(myFilter.notificationFilterHandle),
SA_AIS_OK);
+
+ safassert(saNtfNotificationUnsubscribe(subscriptionId), SA_AIS_OK);
+ safassert(saNtfFinalize(ntfHandle) , SA_AIS_OK);
+ rc = check_errors();
+ test_validate(rc, SA_AIS_OK);
+}
+
+__attribute__ ((constructor)) static void
longDnObject_notification_constructor(void)
+{
+ init_ext_object();
+ test_suite_add(36, "Long DNs Test");
+ test_case_add(36, extAdditionalInfoTest
+ , "Test additional info with extended
SaNameT type");
+ test_case_add(36, extFilterNotificationTest
+ , "Test filter with longDn objects");
+ test_case_add(36, extAlarmNotificationTest
+ , "Test Alarm notification with longDn
objects");
+ test_case_add(36, extObjectCreateDeleteNotificationTest
+ , "Test Object Create/Delete
notification with longDn objects");
+ test_case_add(36, extAttributeChangeNotificationTest
+ , "Test Attribute Change notification
with longDn objects");
+ test_case_add(36, extStateChangeNotificationTest
+ , "Test State Change notification with
longDn objects");
+ test_case_add(36, extSecurityAlarmNotificationTest
+ , "Test Security Alarm notification
with longDn objects");
+}
diff --git a/tests/unit_test_fw/inc/util.h b/tests/unit_test_fw/inc/util.h
--- a/tests/unit_test_fw/inc/util.h
+++ b/tests/unit_test_fw/inc/util.h
@@ -19,11 +19,10 @@
#ifndef util_h
#define util_h
+#include <saAis.h>
+
extern SaTimeT getSaTimeT(void);
-extern void create_dn(char *rdn, char *parent, SaNameT *dn);
-extern void sa_namet_init(char *value, SaNameT *namet);
extern const char *get_saf_error(SaAisErrorT rc);
-
extern void safassert_impl(const char* file, unsigned int line, SaAisErrorT
actual, SaAisErrorT expected);
/**
diff --git a/tests/unit_test_fw/src/Makefile.am
b/tests/unit_test_fw/src/Makefile.am
--- a/tests/unit_test_fw/src/Makefile.am
+++ b/tests/unit_test_fw/src/Makefile.am
@@ -22,6 +22,7 @@ noinst_LTLIBRARIES = libutest.la
libutest_la_CPPFLAGS = \
$(AM_CPPFLAGS) \
+ -DSA_EXTENDED_NAME_SOURCE \
-I$(top_srcdir)/tests/unit_test_fw/inc \
-I$(top_srcdir)/osaf/libs/saf/include
diff --git a/tests/unit_test_fw/src/util.c b/tests/unit_test_fw/src/util.c
--- a/tests/unit_test_fw/src/util.c
+++ b/tests/unit_test_fw/src/util.c
@@ -21,8 +21,7 @@
#include <sys/time.h>
#include <unistd.h>
#include <assert.h>
-#include <saAis.h>
-
+#include "util.h"
static const char *saf_error[] =
{
"SA_AIS_NOT_VALID",
@@ -65,17 +64,6 @@ SaTimeT getSaTimeT(void)
(tp.tv_usec * SA_TIME_ONE_MICROSECOND);
}
-void create_dn(char *rdn, char *parent, SaNameT *dn)
-{
- dn->length = sprintf((char*)dn->value, "%s,%s", rdn, parent);
- assert(dn->length < SA_MAX_NAME_LENGTH);
-}
-
-void sa_namet_init(char *value, SaNameT *namet)
-{
- namet->length = sprintf((char*)namet->value, "%s", value);
-}
-
const char *get_saf_error(SaAisErrorT rc)
{
if (rc <= SA_AIS_ERR_UNAVAILABLE)
------------------------------------------------------------------------------
Want fast and easy access to all the code in your enterprise? Index and
search up to 200,000 lines of code with a free copy of Black Duck
Code Sight - the same software that powers the world's largest code
search on Ohloh, the Black Duck Open Hub! Try it now.
http://p.sf.net/sfu/bds
_______________________________________________
Opensaf-devel mailing list
Opensaf-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/opensaf-devel
