dali/bacnet_stack
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Issue 87 execute tests with GitHub ci (#234)

Browse Source 
* Enable lcov coverage in unit testing via cmake.

* fix pipeline build error

* add compile options for unit test to silence some warnings

* remove all BAC_TEST unit tests in src/bacnet/ folder. They are now in test/bacnet/ folders using ztest.

* removed key.c - only used for unit test.

* produce XML test result output for parsing

* produce junit XML test result output

* change lint workflow to quality

* update readme badge for quality results

Co-authored-by: Steve Karg <skarg@users.sourceforge.net>
This commit is contained in:
Steve Karg
2022-02-28 20:09:46 -06:00
committed by GitHub
parent 585cdb4a7d
commit c3a4c229fe
182 changed files with 231 additions and 16779 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ports/arduino_uno/av.c
-50
View File
@@ -197,53 +197,3 @@ bool Analog_Value_Write_Property(BACNET_WRITE_PROPERTY_DATA *wp_data,
return status;
}
#ifdef BAC_TEST
#include <assert.h>
#include <string.h>
#include "ctest.h"
void testAnalog_Value(Test *pTest)
{
uint8_t apdu[MAX_APDU] = { 0 };
int len = 0;
uint32_t len_value = 0;
uint8_t tag_number = 0;
BACNET_OBJECT_TYPE decoded_type = OBJECT_ANALOG_VALUE;
uint32_t decoded_instance = 0;
uint32_t instance = 123;
BACNET_ERROR_CLASS error_class;
BACNET_ERROR_CODE error_code;
len = Analog_Value_Encode_Property_APDU(&apdu[0], instance,
PROP_OBJECT_IDENTIFIER, BACNET_ARRAY_ALL, &error_class, &error_code);
ct_test(pTest, len != 0);
len = decode_tag_number_and_value(&apdu[0], &tag_number, &len_value);
ct_test(pTest, tag_number == BACNET_APPLICATION_TAG_OBJECT_ID);
len = decode_object_id(&apdu[len], (int *)&decoded_type, &decoded_instance);
ct_test(pTest, decoded_type == OBJECT_ANALOG_VALUE);
ct_test(pTest, decoded_instance == instance);
return;
}
#ifdef TEST_ANALOG_VALUE
int main(void)
{
Test *pTest;
bool rc;
pTest = ct_create("BACnet Analog Value", NULL);
/* individual tests */
rc = ct_addTestFunction(pTest, testAnalog_Value);
assert(rc);
ct_setStream(pTest, stdout);
ct_run(pTest);
(void)ct_report(pTest);
ct_destroy(pTest);
return 0;
}
#endif /* TEST_ANALOG_VALUE */
#endif /* BAC_TEST */
ports/arduino_uno/av.h
-5
View File
@@ -64,11 +64,6 @@ extern "C" {
void Analog_Value_Init(void);
#ifdef BAC_TEST
#include "ctest.h"
void testAnalog_Value(Test * pTest);
#endif
#ifdef __cplusplus
}
#endif /* __cplusplus */
ports/arduino_uno/bv.c
-50
View File
@@ -244,53 +244,3 @@ bool Binary_Value_Write_Property(BACNET_WRITE_PROPERTY_DATA *wp_data,
return status;
}
#ifdef BAC_TEST
#include <assert.h>
#include <string.h>
#include "ctest.h"
void testBinary_Value(Test *pTest)
{
uint8_t apdu[MAX_APDU] = { 0 };
int len = 0;
uint32_t len_value = 0;
uint8_t tag_number = 0;
BACNET_OBJECT_TYPE decoded_type = OBJECT_BINARY_VALUE;
uint32_t decoded_instance = 0;
uint32_t instance = 123;
BACNET_ERROR_CLASS error_class;
BACNET_ERROR_CODE error_code;
len = Binary_Value_Encode_Property_APDU(&apdu[0], instance,
PROP_OBJECT_IDENTIFIER, BACNET_ARRAY_ALL, &error_class, &error_code);
ct_test(pTest, len != 0);
len = decode_tag_number_and_value(&apdu[0], &tag_number, &len_value);
ct_test(pTest, tag_number == BACNET_APPLICATION_TAG_OBJECT_ID);
len = decode_object_id(&apdu[len], (int *)&decoded_type, &decoded_instance);
ct_test(pTest, decoded_type == OBJECT_BINARY_VALUE);
ct_test(pTest, decoded_instance == instance);
return;
}
#ifdef TEST_BINARY_VALUE
int main(void)
{
Test *pTest;
bool rc;
pTest = ct_create("BACnet Binary_Value", NULL);
/* individual tests */
rc = ct_addTestFunction(pTest, testBinary_Value);
assert(rc);
ct_setStream(pTest, stdout);
ct_run(pTest);
(void)ct_report(pTest);
ct_destroy(pTest);
return 0;
}
#endif /* TEST_BINARY_VALUE */
#endif /* BAC_TEST */
ports/arduino_uno/bv.h
-5
View File
@@ -61,11 +61,6 @@ extern "C" {
BACNET_ERROR_CLASS * error_class,
BACNET_ERROR_CODE * error_code);
#ifdef BAC_TEST
#include "ctest.h"
void testBinary_Value(Test * pTest);
#endif
#ifdef __cplusplus
}
#endif /* __cplusplus */
ports/atmega168/ai.h
-6
View File
@@ -82,12 +82,6 @@ extern "C" {
void Analog_Input_Init(
void);
#ifdef BAC_TEST
#include "ctest.h"
void testAnalogInput(
Test * pTest);
#endif
#ifdef __cplusplus
}
#endif /* __cplusplus */
ports/atmega168/av.c
-50
View File
@@ -216,53 +216,3 @@ bool Analog_Value_Write_Property(BACNET_WRITE_PROPERTY_DATA *wp_data)
return status;
}
#ifdef BAC_TEST
#include <assert.h>
#include <string.h>
#include "ctest.h"
void testAnalog_Value(Test *pTest)
{
uint8_t apdu[MAX_APDU] = { 0 };
int len = 0;
uint32_t len_value = 0;
uint8_t tag_number = 0;
BACNET_OBJECT_TYPE decoded_type = OBJECT_ANALOG_VALUE;
uint32_t decoded_instance = 0;
uint32_t instance = 123;
BACNET_ERROR_CLASS error_class;
BACNET_ERROR_CODE error_code;
len = Analog_Value_Encode_Property_APDU(&apdu[0], instance,
PROP_OBJECT_IDENTIFIER, BACNET_ARRAY_ALL, &error_class, &error_code);
ct_test(pTest, len != 0);
len = decode_tag_number_and_value(&apdu[0], &tag_number, &len_value);
ct_test(pTest, tag_number == BACNET_APPLICATION_TAG_OBJECT_ID);
len = decode_object_id(&apdu[len], (int *)&decoded_type, &decoded_instance);
ct_test(pTest, decoded_type == OBJECT_ANALOG_VALUE);
ct_test(pTest, decoded_instance == instance);
return;
}
#ifdef TEST_ANALOG_VALUE
int main(void)
{
Test *pTest;
bool rc;
pTest = ct_create("BACnet Analog Value", NULL);
/* individual tests */
rc = ct_addTestFunction(pTest, testAnalog_Value);
assert(rc);
ct_setStream(pTest, stdout);
ct_run(pTest);
(void)ct_report(pTest);
ct_destroy(pTest);
return 0;
}
#endif /* TEST_ANALOG_VALUE */
#endif /* BAC_TEST */
ports/atmega168/av.h
-6
View File
@@ -74,12 +74,6 @@ extern "C" {
void Analog_Value_Init(
void);
#ifdef BAC_TEST
#include "ctest.h"
void testAnalog_Value(
Test * pTest);
#endif
#ifdef __cplusplus
}
#endif /* __cplusplus */
ports/atmega168/bv.c
-50
View File
@@ -260,53 +260,3 @@ bool Binary_Value_Write_Property(BACNET_WRITE_PROPERTY_DATA *wp_data)
return status;
}
#ifdef BAC_TEST
#include <assert.h>
#include <string.h>
#include "ctest.h"
void testBinary_Value(Test *pTest)
{
uint8_t apdu[MAX_APDU] = { 0 };
int len = 0;
uint32_t len_value = 0;
uint8_t tag_number = 0;
BACNET_OBJECT_TYPE decoded_type = OBJECT_BINARY_VALUE;
uint32_t decoded_instance = 0;
uint32_t instance = 123;
BACNET_ERROR_CLASS error_class;
BACNET_ERROR_CODE error_code;
len = Binary_Value_Encode_Property_APDU(&apdu[0], instance,
PROP_OBJECT_IDENTIFIER, BACNET_ARRAY_ALL, &error_class, &error_code);
ct_test(pTest, len != 0);
len = decode_tag_number_and_value(&apdu[0], &tag_number, &len_value);
ct_test(pTest, tag_number == BACNET_APPLICATION_TAG_OBJECT_ID);
len = decode_object_id(&apdu[len], (int *)&decoded_type, &decoded_instance);
ct_test(pTest, decoded_type == OBJECT_BINARY_VALUE);
ct_test(pTest, decoded_instance == instance);
return;
}
#ifdef TEST_BINARY_VALUE
int main(void)
{
Test *pTest;
bool rc;
pTest = ct_create("BACnet Binary_Value", NULL);
/* individual tests */
rc = ct_addTestFunction(pTest, testBinary_Value);
assert(rc);
ct_setStream(pTest, stdout);
ct_run(pTest);
(void)ct_report(pTest);
ct_destroy(pTest);
return 0;
}
#endif /* TEST_BINARY_VALUE */
#endif /* BAC_TEST */
ports/atmega168/bv.h
-6
View File
@@ -69,12 +69,6 @@ extern "C" {
BACNET_ERROR_CLASS * error_class,
BACNET_ERROR_CODE * error_code);
#ifdef BAC_TEST
#include "ctest.h"
void testBinary_Value(
Test * pTest);
#endif
#ifdef __cplusplus
}
#endif /* __cplusplus */
ports/esp32/src/ai.h
-6
View File
@@ -162,12 +162,6 @@ extern "C" {
void Analog_Input_Init(
void);
#ifdef BAC_TEST
#include "ctest.h"
void testAnalogInput(
Test * pTest);
#endif
#ifdef __cplusplus
}
#endif /* __cplusplus */
ports/esp32/src/bo.h
-6
View File
@@ -129,12 +129,6 @@ extern "C" {
void Binary_Output_Cleanup(
void);
#ifdef BAC_TEST
#include "ctest.h"
void testBinaryOutput(
Test * pTest);
#endif
#ifdef __cplusplus
}
#endif /* __cplusplus */
ports/zephyr/event.c
-941
View File
@@ -1137,944 +1137,3 @@ int event_notify_decode_service_request(
return len;
}
#ifdef BAC_TEST
#include <assert.h>
#include <string.h>
#include "ctest.h"
BACNET_EVENT_NOTIFICATION_DATA data;
BACNET_EVENT_NOTIFICATION_DATA data2;
void testBaseEventState(Test *pTest)
{
ct_test(pTest, data.processIdentifier == data2.processIdentifier);
ct_test(pTest,
data.initiatingObjectIdentifier.instance ==
data2.initiatingObjectIdentifier.instance);
ct_test(pTest,
data.initiatingObjectIdentifier.type ==
data2.initiatingObjectIdentifier.type);
ct_test(pTest,
data.eventObjectIdentifier.instance ==
data2.eventObjectIdentifier.instance);
ct_test(pTest,
data.eventObjectIdentifier.type == data2.eventObjectIdentifier.type);
ct_test(pTest, data.notificationClass == data2.notificationClass);
ct_test(pTest, data.priority == data2.priority);
ct_test(pTest, data.notifyType == data2.notifyType);
ct_test(pTest, data.fromState == data2.fromState);
ct_test(pTest, data.toState == data2.toState);
ct_test(pTest, data.toState == data2.toState);
if (data.messageText != NULL && data2.messageText != NULL) {
ct_test(
pTest, data.messageText->encoding == data2.messageText->encoding);
ct_test(pTest, data.messageText->length == data2.messageText->length);
ct_test(pTest,
strcmp(data.messageText->value, data2.messageText->value) == 0);
}
ct_test(pTest, data.timeStamp.tag == data2.timeStamp.tag);
switch (data.timeStamp.tag) {
case TIME_STAMP_SEQUENCE:
ct_test(pTest,
data.timeStamp.value.sequenceNum ==
data2.timeStamp.value.sequenceNum);
break;
case TIME_STAMP_DATETIME:
ct_test(pTest,
data.timeStamp.value.dateTime.time.hour ==
data2.timeStamp.value.dateTime.time.hour);
ct_test(pTest,
data.timeStamp.value.dateTime.time.min ==
data2.timeStamp.value.dateTime.time.min);
ct_test(pTest,
data.timeStamp.value.dateTime.time.sec ==
data2.timeStamp.value.dateTime.time.sec);
ct_test(pTest,
data.timeStamp.value.dateTime.time.hundredths ==
data2.timeStamp.value.dateTime.time.hundredths);
ct_test(pTest,
data.timeStamp.value.dateTime.date.day ==
data2.timeStamp.value.dateTime.date.day);
ct_test(pTest,
data.timeStamp.value.dateTime.date.month ==
data2.timeStamp.value.dateTime.date.month);
ct_test(pTest,
data.timeStamp.value.dateTime.date.wday ==
data2.timeStamp.value.dateTime.date.wday);
ct_test(pTest,
data.timeStamp.value.dateTime.date.year ==
data2.timeStamp.value.dateTime.date.year);
break;
case TIME_STAMP_TIME:
ct_test(pTest,
data.timeStamp.value.time.hour ==
data2.timeStamp.value.time.hour);
ct_test(pTest,
data.timeStamp.value.time.min ==
data2.timeStamp.value.time.min);
ct_test(pTest,
data.timeStamp.value.time.sec ==
data2.timeStamp.value.time.sec);
ct_test(pTest,
data.timeStamp.value.time.hundredths ==
data2.timeStamp.value.time.hundredths);
break;
default:
ct_fail(pTest, "Unknown type");
break;
}
}
void testEventEventState(Test *pTest)
{
uint8_t buffer[MAX_APDU];
int inLen;
int outLen;
BACNET_CHARACTER_STRING messageText;
BACNET_CHARACTER_STRING messageText2;
characterstring_init_ansi(
&messageText, "This is a test of the message text\n");
data.messageText = &messageText;
data2.messageText = &messageText2;
data.processIdentifier = 1234;
data.initiatingObjectIdentifier.type = OBJECT_ANALOG_INPUT;
data.initiatingObjectIdentifier.instance = 100;
data.eventObjectIdentifier.type = OBJECT_ANALOG_INPUT;
data.eventObjectIdentifier.instance = 200;
data.timeStamp.value.sequenceNum = 1234;
data.timeStamp.tag = TIME_STAMP_SEQUENCE;
data.notificationClass = 50;
data.priority = 50;
data.notifyType = NOTIFY_ALARM;
data.fromState = EVENT_STATE_NORMAL;
data.toState = EVENT_STATE_OFFNORMAL;
data.eventType = EVENT_CHANGE_OF_STATE;
data.notificationParams.changeOfState.newState.tag = UNITS;
data.notificationParams.changeOfState.newState.state.units =
UNITS_SQUARE_METERS;
bitstring_init(&data.notificationParams.changeOfState.statusFlags);
bitstring_set_bit(&data.notificationParams.changeOfState.statusFlags,
STATUS_FLAG_IN_ALARM, true);
bitstring_set_bit(&data.notificationParams.changeOfState.statusFlags,
STATUS_FLAG_FAULT, false);
bitstring_set_bit(&data.notificationParams.changeOfState.statusFlags,
STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&data.notificationParams.changeOfState.statusFlags,
STATUS_FLAG_OUT_OF_SERVICE, false);
inLen = event_notify_encode_service_request(&buffer[0], &data);
outLen = event_notify_decode_service_request(&buffer[0], inLen, &data2);
ct_test(pTest, inLen == outLen);
testBaseEventState(pTest);
ct_test(pTest,
data.notificationParams.changeOfState.newState.tag ==
data2.notificationParams.changeOfState.newState.tag);
ct_test(pTest,
data.notificationParams.changeOfState.newState.state.units ==
data2.notificationParams.changeOfState.newState.state.units);
ct_test(pTest,
bitstring_same(&data.notificationParams.changeOfState.statusFlags,
&data2.notificationParams.changeOfState.statusFlags));
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/*
** Same, but timestamp of
*/
data.timeStamp.tag = TIME_STAMP_DATETIME;
data.timeStamp.value.dateTime.time.hour = 1;
data.timeStamp.value.dateTime.time.min = 2;
data.timeStamp.value.dateTime.time.sec = 3;
data.timeStamp.value.dateTime.time.hundredths = 4;
data.timeStamp.value.dateTime.date.day = 1;
data.timeStamp.value.dateTime.date.month = 1;
data.timeStamp.value.dateTime.date.wday = 1;
data.timeStamp.value.dateTime.date.year = 1945;
memset(buffer, 0, MAX_APDU);
inLen = event_notify_encode_service_request(&buffer[0], &data);
memset(&data2, 0, sizeof(data2));
data2.messageText = &messageText2;
outLen = event_notify_decode_service_request(&buffer[0], inLen, &data2);
ct_test(pTest, inLen == outLen);
testBaseEventState(pTest);
ct_test(pTest,
data.notificationParams.changeOfState.newState.tag ==
data2.notificationParams.changeOfState.newState.tag);
ct_test(pTest,
data.notificationParams.changeOfState.newState.state.units ==
data2.notificationParams.changeOfState.newState.state.units);
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/*
** Event Type = EVENT_CHANGE_OF_BITSTRING
*/
data.timeStamp.value.sequenceNum = 1234;
data.timeStamp.tag = TIME_STAMP_SEQUENCE;
data.eventType = EVENT_CHANGE_OF_BITSTRING;
bitstring_init(
&data.notificationParams.changeOfBitstring.referencedBitString);
bitstring_set_bit(
&data.notificationParams.changeOfBitstring.referencedBitString, 0,
true);
bitstring_set_bit(
&data.notificationParams.changeOfBitstring.referencedBitString, 1,
false);
bitstring_set_bit(
&data.notificationParams.changeOfBitstring.referencedBitString, 2,
true);
bitstring_set_bit(
&data.notificationParams.changeOfBitstring.referencedBitString, 2,
false);
bitstring_init(&data.notificationParams.changeOfBitstring.statusFlags);
bitstring_set_bit(&data.notificationParams.changeOfBitstring.statusFlags,
STATUS_FLAG_IN_ALARM, true);
bitstring_set_bit(&data.notificationParams.changeOfBitstring.statusFlags,
STATUS_FLAG_FAULT, false);
bitstring_set_bit(&data.notificationParams.changeOfBitstring.statusFlags,
STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&data.notificationParams.changeOfBitstring.statusFlags,
STATUS_FLAG_OUT_OF_SERVICE, false);
memset(buffer, 0, MAX_APDU);
inLen = event_notify_encode_service_request(&buffer[0], &data);
memset(&data2, 0, sizeof(data2));
data2.messageText = &messageText2;
outLen = event_notify_decode_service_request(&buffer[0], inLen, &data2);
ct_test(pTest, inLen == outLen);
testBaseEventState(pTest);
ct_test(pTest,
bitstring_same(
&data.notificationParams.changeOfBitstring.referencedBitString,
&data2.notificationParams.changeOfBitstring.referencedBitString));
ct_test(pTest,
bitstring_same(&data.notificationParams.changeOfBitstring.statusFlags,
&data2.notificationParams.changeOfBitstring.statusFlags));
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/*
** Event Type = EVENT_CHANGE_OF_VALUE - float value
*/
data.eventType = EVENT_CHANGE_OF_VALUE;
data.notificationParams.changeOfValue.tag = CHANGE_OF_VALUE_REAL;
data.notificationParams.changeOfValue.newValue.changeValue = 1.23f;
bitstring_init(&data.notificationParams.changeOfValue.statusFlags);
bitstring_set_bit(&data.notificationParams.changeOfValue.statusFlags,
STATUS_FLAG_IN_ALARM, true);
bitstring_set_bit(&data.notificationParams.changeOfValue.statusFlags,
STATUS_FLAG_FAULT, false);
bitstring_set_bit(&data.notificationParams.changeOfValue.statusFlags,
STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&data.notificationParams.changeOfValue.statusFlags,
STATUS_FLAG_OUT_OF_SERVICE, false);
memset(buffer, 0, MAX_APDU);
inLen = event_notify_encode_service_request(&buffer[0], &data);
memset(&data2, 0, sizeof(data2));
data2.messageText = &messageText2;
outLen = event_notify_decode_service_request(&buffer[0], inLen, &data2);
ct_test(pTest, inLen == outLen);
testBaseEventState(pTest);
ct_test(pTest,
bitstring_same(&data.notificationParams.changeOfValue.statusFlags,
&data2.notificationParams.changeOfValue.statusFlags));
ct_test(pTest,
data.notificationParams.changeOfValue.tag ==
data2.notificationParams.changeOfValue.tag);
ct_test(pTest,
data.notificationParams.changeOfValue.newValue.changeValue ==
data2.notificationParams.changeOfValue.newValue.changeValue);
/*
** Event Type = EVENT_CHANGE_OF_VALUE - bitstring value
*/
data.notificationParams.changeOfValue.tag = CHANGE_OF_VALUE_BITS;
bitstring_init(&data.notificationParams.changeOfValue.newValue.changedBits);
bitstring_set_bit(
&data.notificationParams.changeOfValue.newValue.changedBits, 0, true);
bitstring_set_bit(
&data.notificationParams.changeOfValue.newValue.changedBits, 1, false);
bitstring_set_bit(
&data.notificationParams.changeOfValue.newValue.changedBits, 2, false);
bitstring_set_bit(
&data.notificationParams.changeOfValue.newValue.changedBits, 3, false);
memset(buffer, 0, MAX_APDU);
inLen = event_notify_encode_service_request(&buffer[0], &data);
memset(&data2, 0, sizeof(data2));
data2.messageText = &messageText2;
outLen = event_notify_decode_service_request(&buffer[0], inLen, &data2);
ct_test(pTest, inLen == outLen);
testBaseEventState(pTest);
ct_test(pTest,
bitstring_same(&data.notificationParams.changeOfValue.statusFlags,
&data2.notificationParams.changeOfValue.statusFlags));
ct_test(pTest,
data.notificationParams.changeOfValue.tag ==
data2.notificationParams.changeOfValue.tag);
ct_test(pTest,
bitstring_same(
&data.notificationParams.changeOfValue.newValue.changedBits,
&data2.notificationParams.changeOfValue.newValue.changedBits));
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/*
** Event Type = EVENT_COMMAND_FAILURE
*/
/*
** commandValue = enumerated
*/
data.eventType = EVENT_COMMAND_FAILURE;
data.notificationParams.commandFailure.tag = COMMAND_FAILURE_BINARY_PV;
data.notificationParams.commandFailure.commandValue.binaryValue =
BINARY_INACTIVE;
data.notificationParams.commandFailure.feedbackValue.binaryValue =
BINARY_ACTIVE;
bitstring_init(&data.notificationParams.commandFailure.statusFlags);
bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
STATUS_FLAG_IN_ALARM, true);
bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
STATUS_FLAG_FAULT, false);
bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
STATUS_FLAG_OUT_OF_SERVICE, false);
memset(buffer, 0, MAX_APDU);
inLen = event_notify_encode_service_request(&buffer[0], &data);
memset(&data2, 0, sizeof(data2));
data2.messageText = &messageText2;
outLen = event_notify_decode_service_request(&buffer[0], inLen, &data2);
ct_test(pTest, inLen == outLen);
testBaseEventState(pTest);
ct_test(pTest,
data.notificationParams.commandFailure.commandValue.binaryValue ==
data2.notificationParams.commandFailure.commandValue.binaryValue);
ct_test(pTest,
data.notificationParams.commandFailure.feedbackValue.binaryValue ==
data2.notificationParams.commandFailure.feedbackValue.binaryValue);
ct_test(pTest,
bitstring_same(&data.notificationParams.commandFailure.statusFlags,
&data2.notificationParams.commandFailure.statusFlags));
/*
** commandValue = unsigned
*/
data.eventType = EVENT_COMMAND_FAILURE;
data.notificationParams.commandFailure.tag = COMMAND_FAILURE_UNSIGNED;
data.notificationParams.commandFailure.commandValue.unsignedValue = 10;
data.notificationParams.commandFailure.feedbackValue.unsignedValue = 2;
bitstring_init(&data.notificationParams.commandFailure.statusFlags);
bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
STATUS_FLAG_IN_ALARM, true);
bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
STATUS_FLAG_FAULT, false);
bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
STATUS_FLAG_OUT_OF_SERVICE, false);
memset(buffer, 0, MAX_APDU);
inLen = event_notify_encode_service_request(&buffer[0], &data);
memset(&data2, 0, sizeof(data2));
data2.messageText = &messageText2;
outLen = event_notify_decode_service_request(&buffer[0], inLen, &data2);
ct_test(pTest, inLen == outLen);
testBaseEventState(pTest);
ct_test(pTest,
data.notificationParams.commandFailure.commandValue.unsignedValue ==
data2.notificationParams.commandFailure.commandValue.unsignedValue);
ct_test(pTest,
data.notificationParams.commandFailure.feedbackValue.unsignedValue ==
data2.notificationParams.commandFailure.feedbackValue.unsignedValue);
ct_test(pTest,
bitstring_same(&data.notificationParams.commandFailure.statusFlags,
&data2.notificationParams.commandFailure.statusFlags));
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/*
** Event Type = EVENT_FLOATING_LIMIT
*/
data.eventType = EVENT_FLOATING_LIMIT;
data.notificationParams.floatingLimit.referenceValue = 1.23f;
data.notificationParams.floatingLimit.setPointValue = 2.34f;
data.notificationParams.floatingLimit.errorLimit = 3.45f;
bitstring_init(&data.notificationParams.floatingLimit.statusFlags);
bitstring_set_bit(&data.notificationParams.floatingLimit.statusFlags,
STATUS_FLAG_IN_ALARM, true);
bitstring_set_bit(&data.notificationParams.floatingLimit.statusFlags,
STATUS_FLAG_FAULT, false);
bitstring_set_bit(&data.notificationParams.floatingLimit.statusFlags,
STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&data.notificationParams.floatingLimit.statusFlags,
STATUS_FLAG_OUT_OF_SERVICE, false);
memset(buffer, 0, MAX_APDU);
inLen = event_notify_encode_service_request(&buffer[0], &data);
memset(&data2, 0, sizeof(data2));
data2.messageText = &messageText2;
outLen = event_notify_decode_service_request(&buffer[0], inLen, &data2);
ct_test(pTest, inLen == outLen);
testBaseEventState(pTest);
ct_test(pTest,
data.notificationParams.floatingLimit.referenceValue ==
data2.notificationParams.floatingLimit.referenceValue);
ct_test(pTest,
data.notificationParams.floatingLimit.setPointValue ==
data2.notificationParams.floatingLimit.setPointValue);
ct_test(pTest,
data.notificationParams.floatingLimit.errorLimit ==
data2.notificationParams.floatingLimit.errorLimit);
ct_test(pTest,
bitstring_same(&data.notificationParams.floatingLimit.statusFlags,
&data2.notificationParams.floatingLimit.statusFlags));
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/*
** Event Type = EVENT_OUT_OF_RANGE
*/
data.eventType = EVENT_OUT_OF_RANGE;
data.notificationParams.outOfRange.exceedingValue = 3.45f;
data.notificationParams.outOfRange.deadband = 2.34f;
data.notificationParams.outOfRange.exceededLimit = 1.23f;
bitstring_init(&data.notificationParams.outOfRange.statusFlags);
bitstring_set_bit(&data.notificationParams.outOfRange.statusFlags,
STATUS_FLAG_IN_ALARM, true);
bitstring_set_bit(&data.notificationParams.outOfRange.statusFlags,
STATUS_FLAG_FAULT, false);
bitstring_set_bit(&data.notificationParams.outOfRange.statusFlags,
STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&data.notificationParams.outOfRange.statusFlags,
STATUS_FLAG_OUT_OF_SERVICE, false);
memset(buffer, 0, MAX_APDU);
inLen = event_notify_encode_service_request(&buffer[0], &data);
memset(&data2, 0, sizeof(data2));
data2.messageText = &messageText2;
outLen = event_notify_decode_service_request(&buffer[0], inLen, &data2);
ct_test(pTest, inLen == outLen);
testBaseEventState(pTest);
ct_test(pTest,
data.notificationParams.outOfRange.deadband ==
data2.notificationParams.outOfRange.deadband);
ct_test(pTest,
data.notificationParams.outOfRange.exceededLimit ==
data2.notificationParams.outOfRange.exceededLimit);
ct_test(pTest,
data.notificationParams.outOfRange.exceedingValue ==
data2.notificationParams.outOfRange.exceedingValue);
ct_test(pTest,
bitstring_same(&data.notificationParams.outOfRange.statusFlags,
&data2.notificationParams.outOfRange.statusFlags));
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/*
** Event Type = EVENT_CHANGE_OF_LIFE_SAFETY
*/
data.eventType = EVENT_CHANGE_OF_LIFE_SAFETY;
data.notificationParams.changeOfLifeSafety.newState =
LIFE_SAFETY_STATE_ALARM;
data.notificationParams.changeOfLifeSafety.newMode = LIFE_SAFETY_MODE_ARMED;
data.notificationParams.changeOfLifeSafety.operationExpected =
LIFE_SAFETY_OP_RESET;
bitstring_init(&data.notificationParams.changeOfLifeSafety.statusFlags);
bitstring_set_bit(&data.notificationParams.changeOfLifeSafety.statusFlags,
STATUS_FLAG_IN_ALARM, true);
bitstring_set_bit(&data.notificationParams.changeOfLifeSafety.statusFlags,
STATUS_FLAG_FAULT, false);
bitstring_set_bit(&data.notificationParams.changeOfLifeSafety.statusFlags,
STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&data.notificationParams.changeOfLifeSafety.statusFlags,
STATUS_FLAG_OUT_OF_SERVICE, false);
memset(buffer, 0, MAX_APDU);
inLen = event_notify_encode_service_request(&buffer[0], &data);
memset(&data2, 0, sizeof(data2));
data2.messageText = &messageText2;
outLen = event_notify_decode_service_request(&buffer[0], inLen, &data2);
ct_test(pTest, inLen == outLen);
testBaseEventState(pTest);
ct_test(pTest,
data.notificationParams.changeOfLifeSafety.newMode ==
data2.notificationParams.changeOfLifeSafety.newMode);
ct_test(pTest,
data.notificationParams.changeOfLifeSafety.newState ==
data2.notificationParams.changeOfLifeSafety.newState);
ct_test(pTest,
data.notificationParams.changeOfLifeSafety.operationExpected ==
data2.notificationParams.changeOfLifeSafety.operationExpected);
ct_test(pTest,
bitstring_same(&data.notificationParams.changeOfLifeSafety.statusFlags,
&data2.notificationParams.changeOfLifeSafety.statusFlags));
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/*
** Event Type = EVENT_UNSIGNED_RANGE
*/
data.eventType = EVENT_UNSIGNED_RANGE;
data.notificationParams.unsignedRange.exceedingValue = 1234;
data.notificationParams.unsignedRange.exceededLimit = 2345;
bitstring_init(&data.notificationParams.unsignedRange.statusFlags);
bitstring_set_bit(&data.notificationParams.unsignedRange.statusFlags,
STATUS_FLAG_IN_ALARM, true);
bitstring_set_bit(&data.notificationParams.unsignedRange.statusFlags,
STATUS_FLAG_FAULT, false);
bitstring_set_bit(&data.notificationParams.unsignedRange.statusFlags,
STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&data.notificationParams.unsignedRange.statusFlags,
STATUS_FLAG_OUT_OF_SERVICE, false);
memset(buffer, 0, MAX_APDU);
inLen = event_notify_encode_service_request(&buffer[0], &data);
memset(&data2, 0, sizeof(data2));
data2.messageText = &messageText2;
outLen = event_notify_decode_service_request(&buffer[0], inLen, &data2);
ct_test(pTest, inLen == outLen);
testBaseEventState(pTest);
ct_test(pTest,
data.notificationParams.unsignedRange.exceedingValue ==
data2.notificationParams.unsignedRange.exceedingValue);
ct_test(pTest,
data.notificationParams.unsignedRange.exceededLimit ==
data2.notificationParams.unsignedRange.exceededLimit);
ct_test(pTest,
bitstring_same(&data.notificationParams.unsignedRange.statusFlags,
&data2.notificationParams.unsignedRange.statusFlags));
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/*
** Event Type = EVENT_BUFFER_READY
*/
data.eventType = EVENT_BUFFER_READY;
data.notificationParams.bufferReady.previousNotification = 1234;
data.notificationParams.bufferReady.currentNotification = 2345;
data.notificationParams.bufferReady.bufferProperty.deviceIdentifier.type =
OBJECT_DEVICE;
data.notificationParams.bufferReady.bufferProperty.deviceIdentifier
.instance = 500;
data.notificationParams.bufferReady.bufferProperty.objectIdentifier.type =
OBJECT_ANALOG_INPUT;
data.notificationParams.bufferReady.bufferProperty.objectIdentifier
.instance = 100;
data.notificationParams.bufferReady.bufferProperty.propertyIdentifier =
PROP_PRESENT_VALUE;
data.notificationParams.bufferReady.bufferProperty.arrayIndex = 0;
memset(buffer, 0, MAX_APDU);
inLen = event_notify_encode_service_request(&buffer[0], &data);
memset(&data2, 0, sizeof(data2));
data2.messageText = &messageText2;
outLen = event_notify_decode_service_request(&buffer[0], inLen, &data2);
ct_test(pTest, inLen == outLen);
testBaseEventState(pTest);
ct_test(pTest,
data.notificationParams.bufferReady.previousNotification ==
data2.notificationParams.bufferReady.previousNotification);
ct_test(pTest,
data.notificationParams.bufferReady.currentNotification ==
data2.notificationParams.bufferReady.currentNotification);
ct_test(pTest,
data.notificationParams.bufferReady.bufferProperty.deviceIdentifier
.type ==
data2.notificationParams.bufferReady.bufferProperty.deviceIdentifier
.type);
ct_test(pTest,
data.notificationParams.bufferReady.bufferProperty.deviceIdentifier
.instance ==
data2.notificationParams.bufferReady.bufferProperty.deviceIdentifier
.instance);
ct_test(pTest,
data.notificationParams.bufferReady.bufferProperty.objectIdentifier
.instance ==
data2.notificationParams.bufferReady.bufferProperty.objectIdentifier
.instance);
ct_test(pTest,
data.notificationParams.bufferReady.bufferProperty.objectIdentifier
.type ==
data2.notificationParams.bufferReady.bufferProperty.objectIdentifier
.type);
ct_test(pTest,
data.notificationParams.bufferReady.bufferProperty.propertyIdentifier ==
data2.notificationParams.bufferReady.bufferProperty
.propertyIdentifier);
ct_test(pTest,
data.notificationParams.bufferReady.bufferProperty.arrayIndex ==
data2.notificationParams.bufferReady.bufferProperty.arrayIndex);
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/**********************************************************************************/
/*
** Event Type = EVENT_ACCESS_EVENT
*/
// OPTIONAL authenticationFactor omitted
data.eventType = EVENT_ACCESS_EVENT;
data.notificationParams.accessEvent.accessEvent =
ACCESS_EVENT_LOCKED_BY_HIGHER_AUTHORITY;
data.notificationParams.accessEvent.accessEventTag = 7;
data.notificationParams.accessEvent.accessEventTime.tag =
TIME_STAMP_SEQUENCE;
data.notificationParams.accessEvent.accessEventTime.value.sequenceNum = 17;
data.notificationParams.accessEvent.accessCredential.
deviceIdentifier.instance = 1234;
data.notificationParams.accessEvent.accessCredential.
deviceIdentifier.type = OBJECT_DEVICE;
data.notificationParams.accessEvent.accessCredential.
objectIdentifier.instance = 17;
data.notificationParams.accessEvent.accessCredential.
objectIdentifier.type = OBJECT_ACCESS_POINT;
data.notificationParams.accessEvent.authenticationFactor.format_type = AUTHENTICATION_FACTOR_MAX; // omit authenticationFactor
bitstring_init(&data.notificationParams.accessEvent.statusFlags);
bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
STATUS_FLAG_IN_ALARM, true);
bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
STATUS_FLAG_FAULT, false);
bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
STATUS_FLAG_OUT_OF_SERVICE, false);
memset(buffer, 0, MAX_APDU);
inLen = event_notify_encode_service_request(&buffer[0], &data);
memset(&data2, 0, sizeof(data2));
data2.messageText = &messageText2;
outLen = event_notify_decode_service_request(&buffer[0], inLen, &data2);
ct_test(pTest, inLen == outLen);
testBaseEventState(pTest);
ct_test(pTest,
data.notificationParams.accessEvent.accessEvent ==
data2.notificationParams.accessEvent.accessEvent);
ct_test(pTest,
bitstring_same(&data.notificationParams.accessEvent.statusFlags,
&data2.notificationParams.accessEvent.statusFlags));
ct_test(pTest,
data.notificationParams.accessEvent.accessEventTag ==
data2.notificationParams.accessEvent.accessEventTag);
ct_test(pTest,
data.notificationParams.accessEvent.accessEventTime.tag ==
data2.notificationParams.accessEvent.accessEventTime.tag);
ct_test(pTest,
data.notificationParams.accessEvent.accessEventTime.
value.sequenceNum ==
data2.notificationParams.accessEvent.accessEventTime.
value.sequenceNum);
ct_test(pTest,
data.notificationParams.accessEvent.accessCredential.
deviceIdentifier.instance ==
data2.notificationParams.accessEvent.accessCredential.
deviceIdentifier.instance);
ct_test(pTest,
data.notificationParams.accessEvent.accessCredential.
deviceIdentifier.type ==
data2.notificationParams.accessEvent.accessCredential.
deviceIdentifier.type);
ct_test(pTest,
data.notificationParams.accessEvent.accessCredential.
objectIdentifier.instance ==
data2.notificationParams.accessEvent.accessCredential.
objectIdentifier.instance);
ct_test(pTest,
data.notificationParams.accessEvent.accessCredential.
objectIdentifier.type ==
data2.notificationParams.accessEvent.accessCredential.
objectIdentifier.type);
// OPTIONAL authenticationFactor included
data.eventType = EVENT_ACCESS_EVENT;
data.notificationParams.accessEvent.accessEvent =
ACCESS_EVENT_LOCKED_BY_HIGHER_AUTHORITY;
data.notificationParams.accessEvent.accessEventTag = 7;
data.notificationParams.accessEvent.accessEventTime.tag =
TIME_STAMP_SEQUENCE;
data.notificationParams.accessEvent.accessEventTime.value.sequenceNum = 17;
data.notificationParams.accessEvent.accessCredential.
deviceIdentifier.instance = 1234;
data.notificationParams.accessEvent.accessCredential.
deviceIdentifier.type = OBJECT_DEVICE;
data.notificationParams.accessEvent.accessCredential.
objectIdentifier.instance = 17;
data.notificationParams.accessEvent.accessCredential.
objectIdentifier.type = OBJECT_ACCESS_POINT;
data.notificationParams.accessEvent.authenticationFactor.format_type =
AUTHENTICATION_FACTOR_SIMPLE_NUMBER16;
data.notificationParams.accessEvent.authenticationFactor.format_class =
215;
uint8_t octetstringValue[2] = { 0x00, 0x10 };
octetstring_init(&data.notificationParams.accessEvent.
authenticationFactor.value, octetstringValue, 2);
bitstring_init(&data.notificationParams.accessEvent.statusFlags);
bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
STATUS_FLAG_IN_ALARM, true);
bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
STATUS_FLAG_FAULT, false);
bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
STATUS_FLAG_OUT_OF_SERVICE, false);
memset(buffer, 0, MAX_APDU);
inLen = event_notify_encode_service_request(&buffer[0], &data);
memset(&data2, 0, sizeof(data2));
data2.messageText = &messageText2;
outLen = event_notify_decode_service_request(&buffer[0], inLen, &data2);
ct_test(pTest, inLen == outLen);
testBaseEventState(pTest);
ct_test(pTest,
data.notificationParams.accessEvent.accessEvent ==
data2.notificationParams.accessEvent.accessEvent);
ct_test(pTest,
bitstring_same(&data.notificationParams.accessEvent.statusFlags,
&data2.notificationParams.accessEvent.statusFlags));
ct_test(pTest,
data.notificationParams.accessEvent.accessEventTag ==
data2.notificationParams.accessEvent.accessEventTag);
ct_test(pTest,
data.notificationParams.accessEvent.accessEventTime.tag ==
data2.notificationParams.accessEvent.accessEventTime.tag);
ct_test(pTest,
data.notificationParams.accessEvent.accessEventTime.
value.sequenceNum ==
data2.notificationParams.accessEvent.accessEventTime.
value.sequenceNum);
ct_test(pTest,
data.notificationParams.accessEvent.accessCredential.
deviceIdentifier.instance ==
data2.notificationParams.accessEvent.accessCredential.
deviceIdentifier.instance);
ct_test(pTest,
data.notificationParams.accessEvent.accessCredential.
deviceIdentifier.type ==
data2.notificationParams.accessEvent.accessCredential.
deviceIdentifier.type);
ct_test(pTest,
data.notificationParams.accessEvent.accessCredential.
objectIdentifier.instance ==
data2.notificationParams.accessEvent.accessCredential.
objectIdentifier.instance);
ct_test(pTest,
data.notificationParams.accessEvent.accessCredential.
objectIdentifier.type ==
data2.notificationParams.accessEvent.accessCredential.
objectIdentifier.type);
ct_test(pTest,
data.notificationParams.accessEvent.authenticationFactor.format_type ==
data2.notificationParams.accessEvent.authenticationFactor.format_type);
ct_test(pTest,
data.notificationParams.accessEvent.
authenticationFactor.format_class ==
data2.notificationParams.accessEvent.
authenticationFactor.format_class);
ct_test(pTest,
octetstring_value_same(&data.notificationParams.
accessEvent.authenticationFactor.value,
&data2.notificationParams.accessEvent.authenticationFactor.value));
}
#ifdef TEST_EVENT
int main(void)
{
Test *pTest;
bool rc;
pTest = ct_create("BACnet Event", NULL);
/* individual tests */
rc = ct_addTestFunction(pTest, testEventEventState);
assert(rc);
ct_setStream(pTest, stdout);
ct_run(pTest);
(void)ct_report(pTest);
ct_destroy(pTest);
return 0;
}
#endif /* TEST_EVENT */
#endif /* BAC_TEST */