tests/logsv/logtest.c | 22 +++
tests/logsv/logtest.h | 2 +
tests/logsv/tet_saLogStreamOpen_2.c | 36 +++++
tests/logsv/tet_saLogWriteLogAsync.c | 237 ++++++++++++++++++++++++++++++++++-
4 files changed, 296 insertions(+), 1 deletions(-)
Add testcases for testing SaNameT with length 256
diff --git a/tests/logsv/logtest.c b/tests/logsv/logtest.c
--- a/tests/logsv/logtest.c
+++ b/tests/logsv/logtest.c
@@ -61,6 +61,28 @@ SaNameT notificationObject =
.length = sizeof(DEFAULT_NOTIFICATION_OBJECT)
};
+SaNameT saNameT_Object_256 =
+{
+ .value = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "bbbbb",
+ .length = 256
+};
+
+SaNameT saNameT_appstream_name_256 =
+{
+ .value = "safLgStr=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "bbbbb",
+ .length = 256
+};
+
static char buf[2048];
SaLogBufferT alarmStreamBuffer =
diff --git a/tests/logsv/logtest.h b/tests/logsv/logtest.h
--- a/tests/logsv/logtest.h
+++ b/tests/logsv/logtest.h
@@ -49,6 +49,8 @@ extern SaNameT notificationStreamName;
extern SaNameT app1StreamName;
extern SaNameT notifyingObject;
extern SaNameT notificationObject;
+extern SaNameT saNameT_Object_256;
+extern SaNameT saNameT_appstream_name_256;
extern SaVersionT logVersion;
extern SaAisErrorT rc;
extern SaLogHandleT logHandle;
diff --git a/tests/logsv/tet_saLogStreamOpen_2.c
b/tests/logsv/tet_saLogStreamOpen_2.c
--- a/tests/logsv/tet_saLogStreamOpen_2.c
+++ b/tests/logsv/tet_saLogStreamOpen_2.c
@@ -299,6 +299,35 @@ void saLogStreamOpen_2_22(void)
test_validate(rc, SA_AIS_ERR_NOT_EXIST);
}
+/**
+ * Open with stream name length == 256
+ */
+void saLogStreamOpen_2_23(void)
+{
+ SaAisErrorT rc_17 = SA_AIS_OK;
+
+ strcpy((char*)genLogRecord.logBuffer->logBuf, __FUNCTION__);
+ genLogRecord.logBuffer->logBufSize = strlen(__FUNCTION__);
+ genLogRecord.logHeader.genericHdr.logSvcUsrName =
&saNameT_appstream_name_256;
+
+ safassert(saLogInitialize(&logHandle, &logCallbacks, &logVersion),
SA_AIS_OK);
+ rc_17 = saLogStreamOpen_2(logHandle, &saNameT_appstream_name_256, NULL, 0,
+ SA_TIME_ONE_SECOND, &logStreamHandle);
+ safassert(saLogFinalize(logHandle), SA_AIS_OK);
+
+ /* restore genLogRecord */
+ genLogRecord.logHeader.genericHdr.logSvcUsrName = &logSvcUsrName;
+
+ /* If tested length is >= 256 the server will stop decoding write
message
+ * and the message is ignored. This will result in no answer message
from
+ * the server and waiting for message will timeout. When this happen the
+ * saLogStreamOpen_2 returns SA_AIS_ERR_TRY_AGAIN
+ * Note that normally the API is checking length. But if testing with
this
+ * check disabled the server shall not crash.
+ */
+ test_validate(rc_17, SA_AIS_ERR_INVALID_PARAM);
+}
+
extern void saLogStreamOpenAsync_2_01(void);
extern void saLogStreamOpenCallbackT_01(void);
extern void saLogWriteLog_01(void);
@@ -316,6 +345,9 @@ extern void saLogWriteLogAsync_11(void);
extern void saLogWriteLogAsync_12(void);
extern void saLogWriteLogAsync_13(void);
extern void saLogWriteLogAsync_14(void);
+extern void saLogWriteLogAsync_15(void);
+extern void saLogWriteLogAsync_16(void);
+extern void saLogWriteLogAsync_17(void);
extern void saLogWriteLogCallbackT_01(void);
extern void saLogWriteLogCallbackT_02(void);
extern void saLogWriteLogCallbackT_03(void);
@@ -346,6 +378,7 @@ extern void saLogStreamClose_01(void);
test_case_add(2, saLogStreamOpen_2_20, "Open app stream with invalid
logFileFmt");
test_case_add(2, saLogStreamOpen_2_21, "Open app stream with unsupported
logFullAction");
test_case_add(2, saLogStreamOpen_2_22, "Open non exist app stream with
NULL create attrs");
+ test_case_add(2, saLogStreamOpen_2_23, "Open with stream name length ==
256");
test_case_add(2, saLogStreamOpenAsync_2_01, "saLogStreamOpenAsync_2(), Not
supported");
test_case_add(2, saLogStreamOpenCallbackT_01, "saLogStreamOpenCallbackT()
OK");
test_case_add(2, saLogWriteLog_01, "saLogWriteLog(), Not supported");
@@ -362,6 +395,9 @@ extern void saLogStreamClose_01(void);
test_case_add(2, saLogWriteLogAsync_12, "saLogWriteAsyncLog() without
logTimeStamp set");
test_case_add(2, saLogWriteLogAsync_13, "saLogWriteAsyncLog() 1800 bytes
logrecord (ticket #203)");
test_case_add(2, saLogWriteLogAsync_14, "saLogWriteAsyncLog() invalid
severity");
+ test_case_add(2, saLogWriteLogAsync_15, "saLogWriteAsyncLog() NTF
notificationObject length == 256");
+ test_case_add(2, saLogWriteLogAsync_16, "saLogWriteAsyncLog() NTF
notifyingObject length == 256");
+ test_case_add(2, saLogWriteLogAsync_17, "saLogWriteLogAsync() Generic
logSvcUsrName length == 256");
test_case_add(2, saLogWriteLogCallbackT_01, "saLogWriteLogCallbackT()
SA_DISPATCH_ONE");
test_case_add(2, saLogWriteLogCallbackT_02, "saLogWriteLogCallbackT()
SA_DISPATCH_ALL");
test_case_add(2, saLogFilterSetCallbackT_01, "saLogFilterSetCallbackT OK");
diff --git a/tests/logsv/tet_saLogWriteLogAsync.c
b/tests/logsv/tet_saLogWriteLogAsync.c
--- a/tests/logsv/tet_saLogWriteLogAsync.c
+++ b/tests/logsv/tet_saLogWriteLogAsync.c
@@ -21,9 +21,85 @@
#include <fcntl.h>
#include <sys/stat.h>
#include <aio.h>
+#include <saLog.h>
+#include <poll.h>
#include "logtest.h"
+static void salogWriteLogCallback(SaInvocationT invocation, SaAisErrorT error);
+static SaLogCallbacksT logCallbacks_on = { 0, 0, salogWriteLogCallback };
+static SaInvocationT cb_invocation;
+static SaAisErrorT cb_error;
+
+static void salogWriteLogCallback(SaInvocationT invocation, SaAisErrorT error)
+{
+ cb_invocation = invocation;
+ cb_error = error;
+ printf("salogWriteLogCallback invoked\n");
+}
+
+/**
+ * Wait for log server asynchronous event and dispatch the callback
+ *
+ * @param logHandle
+ * @param selectionObject
+ *
+ * @return wlc_rc_t
+ *
+ */
+typedef enum {
+ WLC_OK,
+ WLC_POLL_FAIL,
+ WLC_POLL_TIMEOUT,
+ WLC_DISPATCH_FAIL,
+ WLC_INVOCATION_ERR,
+ WLC_CB_ERR
+} wlc_rc_t;
+
+static wlc_rc_t wait_log_callback(SaLogHandleT logHandle,
+ SaSelectionObjectT selectionObject,
+ SaInvocationT invocation)
+{
+ struct pollfd fds[1];
+ int rc = WLC_OK;
+ SaAisErrorT errorCode;
+
+ printf("Waiting for log write callback\n");
+
+ fds[0].fd = (int) selectionObject;
+ fds[0].events = POLLIN;
+
+ while ((rc = poll(fds, 1, 20000)) == EINTR);
+
+ if (rc == -1) {
+ printf("Write callback poll FAILED: %s\n", strerror(errno));
+ return WLC_POLL_FAIL;
+ }
+
+ if (rc == 0) {
+ printf("Poll timeout\n");
+ return WLC_POLL_TIMEOUT;
+ }
+
+ errorCode = saLogDispatch(logHandle, SA_DISPATCH_ONE);
+ if (errorCode != SA_AIS_OK) {
+ printf("saLogDispatch FAILED: %u\n", errorCode);
+ return WLC_DISPATCH_FAIL;
+ }
+
+ /* Verify the callback info */
+ rc = 0;
+ if (cb_invocation != invocation) {
+ printf("Write callback invocation error\n");
+ rc = WLC_INVOCATION_ERR;
+ }
+ if (cb_error != SA_AIS_OK) {
+ printf("Write callback error response: %d", cb_error);
+ rc = WLC_CB_ERR;
+ }
+ return rc;
+}
+
void saLogWriteLogAsync_01(void)
{
SaInvocationT invocation = 0;
@@ -247,8 +323,9 @@ void saLogWriteLogAsync_13(void)
SaInvocationT invocation = 0;
SaNameT appStreamName = {
.value = "safLgStr=ticket203",
- .length = sizeof(appStreamName.value)
+ .length = 0
};
+ appStreamName.length = strlen((char *) appStreamName.value);
memset(genLogRecord.logBuffer->logBuf, 'X', 1800);
genLogRecord.logBuffer->logBufSize = 1800;
@@ -262,6 +339,9 @@ void saLogWriteLogAsync_13(void)
test_validate(rc, SA_AIS_OK);
}
+/**
+ * saLogWriteAsyncLog() invalid severity
+ */
void saLogWriteLogAsync_14(void)
{
SaInvocationT invocation = 0;
@@ -279,3 +359,158 @@ void saLogWriteLogAsync_14(void)
genLogRecord.logHeader.genericHdr.logSeverity = SA_LOG_SEV_INFO;
}
+/**
+ * Check notificationObject length == 256
+ * NTF Header
+ */
+void saLogWriteLogAsync_15(void)
+{
+ SaInvocationT invocation = random();
+ SaLogRecordT ntfLogRecord;
+ SaNtfIdentifierT notificationId = random();
+ SaNtfClassIdT notificationClassId;
+ SaAisErrorT rc1 = SA_AIS_OK;
+ wlc_rc_t rc2 = WLC_OK;
+
+ ntfLogRecord.logBuffer = ¬ificationStreamBuffer;
+ strcpy((char*)ntfLogRecord.logBuffer->logBuf, __FUNCTION__);
+ ntfLogRecord.logBuffer->logBufSize = strlen(__FUNCTION__);
+
+ notificationClassId.vendorId = 193;
+ notificationClassId.majorId = 1;
+ notificationClassId.minorId = 2;
+ ntfLogRecord.logTimeStamp = getSaTimeT();
+ ntfLogRecord.logHdrType = SA_LOG_NTF_HEADER;
+ ntfLogRecord.logHeader.ntfHdr.notificationId = notificationId;
+ ntfLogRecord.logHeader.ntfHdr.eventType = SA_NTF_ALARM_QOS;
+ ntfLogRecord.logHeader.ntfHdr.notificationObject = &saNameT_Object_256;
+ ntfLogRecord.logHeader.ntfHdr.notifyingObject = ¬ifyingObject;
+ ntfLogRecord.logHeader.ntfHdr.notificationClassId = ¬ificationClassId;
+ ntfLogRecord.logHeader.ntfHdr.eventTime = getSaTimeT();
+
+ safassert(saLogInitialize(&logHandle, &logCallbacks_on, &logVersion),
SA_AIS_OK);
+ safassert(saLogSelectionObjectGet(logHandle, &selectionObject),
SA_AIS_OK);
+
+ safassert(saLogStreamOpen_2(logHandle, &alarmStreamName, NULL, 0,
+ SA_TIME_ONE_SECOND, &logStreamHandle), SA_AIS_OK);
+ rc1 = saLogWriteLogAsync(logStreamHandle, invocation,
SA_LOG_RECORD_WRITE_ACK,
+ &ntfLogRecord);
+ if (rc1 == SA_AIS_OK) {
+ rc2 = wait_log_callback(logHandle, selectionObject, invocation);
+ }
+
+ safassert(saLogFinalize(logHandle), SA_AIS_OK);
+
+ /* If tested length is >= 256 the server will stop decoding write
message
+ * and the message is ignored. This will result in no callback message
from
+ * the server and waiting for callback will timeout.
+ * Note that normally the API is checking length. But if testing with
this
+ * check disabled the server shall not crash.
+ */
+ if (rc2 != WLC_OK) {
+ test_validate(rc2, WLC_POLL_TIMEOUT);
+ } else {
+ test_validate(rc1, SA_AIS_ERR_INVALID_PARAM);
+ }
+}
+
+/**
+ * Check notifyingObject length == 256
+ * NTF Header
+ */
+void saLogWriteLogAsync_16(void)
+{
+ SaInvocationT invocation = random();
+ SaLogRecordT ntfLogRecord;
+ SaNtfIdentifierT notificationId = random();
+ SaNtfClassIdT notificationClassId;
+ SaAisErrorT rc1 = SA_AIS_OK;
+ wlc_rc_t rc2 = WLC_OK;
+
+ ntfLogRecord.logBuffer = ¬ificationStreamBuffer;
+ strcpy((char*)ntfLogRecord.logBuffer->logBuf, __FUNCTION__);
+ ntfLogRecord.logBuffer->logBufSize = strlen(__FUNCTION__);
+
+ notificationClassId.vendorId = 193;
+ notificationClassId.majorId = 1;
+ notificationClassId.minorId = 2;
+ ntfLogRecord.logTimeStamp = getSaTimeT();
+ ntfLogRecord.logHdrType = SA_LOG_NTF_HEADER;
+ ntfLogRecord.logHeader.ntfHdr.notificationId = notificationId;
+ ntfLogRecord.logHeader.ntfHdr.eventType = SA_NTF_ALARM_QOS;
+ ntfLogRecord.logHeader.ntfHdr.notificationObject = ¬ificationObject;
+ ntfLogRecord.logHeader.ntfHdr.notifyingObject = &saNameT_Object_256;
+ ntfLogRecord.logHeader.ntfHdr.notificationClassId = ¬ificationClassId;
+ ntfLogRecord.logHeader.ntfHdr.eventTime = getSaTimeT();
+
+ safassert(saLogInitialize(&logHandle, &logCallbacks_on, &logVersion),
SA_AIS_OK);
+ safassert(saLogSelectionObjectGet(logHandle, &selectionObject),
SA_AIS_OK);
+
+ safassert(saLogStreamOpen_2(logHandle, &alarmStreamName, NULL, 0,
+ SA_TIME_ONE_SECOND, &logStreamHandle), SA_AIS_OK);
+ rc1 = saLogWriteLogAsync(logStreamHandle, invocation, 0, &ntfLogRecord);
+
+ if (rc1 == SA_AIS_OK) {
+ rc2 = wait_log_callback(logHandle, selectionObject, invocation);
+ }
+
+ safassert(saLogFinalize(logHandle), SA_AIS_OK);
+
+ /* If tested length is >= 256 the server will stop decoding write
message
+ * and the message is ignored. This will result in no callback message
from
+ * the server and waiting for callback will timeout.
+ * Note that normally the API is checking length. But if testing with
this
+ * check disabled the server shall not crash.
+ */
+ if (rc2 != WLC_OK) {
+ test_validate(rc2, WLC_POLL_TIMEOUT);
+ } else {
+ test_validate(rc1, SA_AIS_ERR_INVALID_PARAM);
+ }
+}
+
+/**
+ * saLogWriteLogAsync() Generic header logSvcUsrName length = 256
+ */
+void saLogWriteLogAsync_17(void)
+{
+ SaInvocationT invocation = random();
+ SaLogRecordT genLogRecord_is;
+ SaLogBufferT log_buffer;
+ char record[] ="saLogWriteLogAsync_17";
+ SaAisErrorT rc1 = SA_AIS_OK;
+ wlc_rc_t rc2 = WLC_OK;
+
+ log_buffer.logBuf = (SaUint8T *) record;
+ log_buffer.logBufSize = strlen(record) + 1;
+ genLogRecord_is.logBuffer = &log_buffer;
+ genLogRecord_is.logHdrType = SA_LOG_GENERIC_HEADER;
+ genLogRecord_is.logHeader.genericHdr.notificationClassId = NULL;
+ genLogRecord_is.logHeader.genericHdr.logSeverity = SA_LOG_SEV_INFO;
+ genLogRecord_is.logHeader.genericHdr.logSvcUsrName =
&saNameT_appstream_name_256;
+
+ safassert(saLogInitialize(&logHandle, &logCallbacks_on, &logVersion),
SA_AIS_OK);
+ safassert(saLogSelectionObjectGet(logHandle, &selectionObject),
SA_AIS_OK);
+
+ safassert(saLogStreamOpen_2(logHandle, &systemStreamName, NULL, 0,
+ SA_TIME_ONE_SECOND, &logStreamHandle), SA_AIS_OK);
+ rc1 = saLogWriteLogAsync(logStreamHandle, invocation, 0, &genLogRecord_is);
+
+ if (rc1 == SA_AIS_OK) {
+ rc2 = wait_log_callback(logHandle, selectionObject, invocation);
+ }
+
+ safassert(saLogFinalize(logHandle), SA_AIS_OK);
+
+ /* If tested length is >= 256 the server will stop decoding write
message
+ * and the message is ignored. This will result in no callback message
from
+ * the server and waiting for callback will timeout.
+ * Note that normally the API is checking length. But if testing with
this
+ * check disabled the server shall not crash.
+ */
+ if (rc2 != WLC_OK) {
+ test_validate(rc2, WLC_POLL_TIMEOUT);
+ } else {
+ test_validate(rc1, SA_AIS_ERR_INVALID_PARAM);
+ }
+}
------------------------------------------------------------------------------
HPCC Systems Open Source Big Data Platform from LexisNexis Risk Solutions
Find What Matters Most in Your Big Data with HPCC Systems
Open Source. Fast. Scalable. Simple. Ideal for Dirty Data.
Leverages Graph Analysis for Fast Processing & Easy Data Exploration
http://p.sf.net/sfu/hpccsystems
_______________________________________________
Opensaf-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/opensaf-devel
