Issue 87 execute tests with GitHub ci (#234)

* 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
-371
View File
@@ -983,374 +983,3 @@ bool cov_value_list_encode_character_string(
return status;
}
#endif
#ifdef BAC_TEST
#include <assert.h>
#include <string.h>
#include "ctest.h"
#include "bacnet/bacapp.h"
int ccov_notify_decode_apdu(
uint8_t *apdu, unsigned apdu_len, uint8_t *invoke_id, BACNET_COV_DATA *data)
{
int len = 0;
unsigned offset = 0;
if (!apdu) {
return -1;
}
/* optional checking - most likely was already done prior to this call */
if (apdu[0] != PDU_TYPE_CONFIRMED_SERVICE_REQUEST)
return -2;
/* apdu[1] = encode_max_segs_max_apdu(0, MAX_APDU); */
*invoke_id = apdu[2]; /* invoke id - filled in by net layer */
if (apdu[3] != SERVICE_CONFIRMED_COV_NOTIFICATION)
return -3;
offset = 4;
/* optional limits - must be used as a pair */
if (apdu_len > offset) {
len = cov_notify_decode_service_request(
&apdu[offset], apdu_len - offset, data);
}
return len;
}
int ucov_notify_decode_apdu(
uint8_t *apdu, unsigned apdu_len, BACNET_COV_DATA *data)
{
int len = 0;
unsigned offset = 0;
if (!apdu)
return -1;
/* optional checking - most likely was already done prior to this call */
if (apdu[0] != PDU_TYPE_UNCONFIRMED_SERVICE_REQUEST)
return -2;
if (apdu[1] != SERVICE_UNCONFIRMED_COV_NOTIFICATION)
return -3;
/* optional limits - must be used as a pair */
offset = 2;
if (apdu_len > offset) {
len = cov_notify_decode_service_request(
&apdu[offset], apdu_len - offset, data);
}
return len;
}
int cov_subscribe_decode_apdu(uint8_t *apdu,
unsigned apdu_len,
uint8_t *invoke_id,
BACNET_SUBSCRIBE_COV_DATA *data)
{
int len = 0;
unsigned offset = 0;
if (!apdu)
return -1;
/* optional checking - most likely was already done prior to this call */
if (apdu[0] != PDU_TYPE_CONFIRMED_SERVICE_REQUEST)
return -2;
/* apdu[1] = encode_max_segs_max_apdu(0, MAX_APDU); */
*invoke_id = apdu[2]; /* invoke id - filled in by net layer */
if (apdu[3] != SERVICE_CONFIRMED_SUBSCRIBE_COV)
return -3;
offset = 4;
/* optional limits - must be used as a pair */
if (apdu_len > offset) {
len = cov_subscribe_decode_service_request(
&apdu[offset], apdu_len - offset, data);
}
return len;
}
int cov_subscribe_property_decode_apdu(uint8_t *apdu,
unsigned apdu_len,
uint8_t *invoke_id,
BACNET_SUBSCRIBE_COV_DATA *data)
{
int len = 0;
unsigned offset = 0;
if (!apdu)
return -1;
/* optional checking - most likely was already done prior to this call */
if (apdu[0] != PDU_TYPE_CONFIRMED_SERVICE_REQUEST)
return -2;
/* apdu[1] = encode_max_segs_max_apdu(0, MAX_APDU); */
*invoke_id = apdu[2]; /* invoke id - filled in by net layer */
if (apdu[3] != SERVICE_CONFIRMED_SUBSCRIBE_COV_PROPERTY)
return -3;
offset = 4;
/* optional limits - must be used as a pair */
if (apdu_len > offset) {
len = cov_subscribe_property_decode_service_request(
&apdu[offset], apdu_len - offset, data);
}
return len;
}
/* dummy function stubs */
void testCOVNotifyData(
Test *pTest, BACNET_COV_DATA *data, BACNET_COV_DATA *test_data)
{
BACNET_PROPERTY_VALUE *value = NULL;
BACNET_PROPERTY_VALUE *test_value = NULL;
ct_test(pTest,
test_data->subscriberProcessIdentifier ==
data->subscriberProcessIdentifier);
ct_test(pTest,
test_data->initiatingDeviceIdentifier ==
data->initiatingDeviceIdentifier);
ct_test(pTest,
test_data->monitoredObjectIdentifier.type ==
data->monitoredObjectIdentifier.type);
ct_test(pTest,
test_data->monitoredObjectIdentifier.instance ==
data->monitoredObjectIdentifier.instance);
ct_test(pTest, test_data->timeRemaining == data->timeRemaining);
/* test the listOfValues in some clever manner */
value = data->listOfValues;
test_value = test_data->listOfValues;
while (value) {
ct_test(pTest, test_value);
if (test_value) {
ct_test(pTest,
test_value->propertyIdentifier == value->propertyIdentifier);
ct_test(pTest,
test_value->propertyArrayIndex == value->propertyArrayIndex);
ct_test(pTest, test_value->priority == value->priority);
ct_test(
pTest, bacapp_same_value(&test_value->value, &value->value));
test_value = test_value->next;
}
value = value->next;
}
}
void testUCOVNotifyData(Test *pTest, BACNET_COV_DATA *data)
{
uint8_t apdu[480] = { 0 };
int len = 0;
int apdu_len = 0;
BACNET_COV_DATA test_data;
BACNET_PROPERTY_VALUE value_list[5] = { { 0 } };
len = ucov_notify_encode_apdu(&apdu[0], sizeof(apdu), data);
ct_test(pTest, len > 0);
apdu_len = len;
cov_data_value_list_link(&test_data, &value_list[0], 5);
len = ucov_notify_decode_apdu(&apdu[0], apdu_len, &test_data);
ct_test(pTest, len != -1);
testCOVNotifyData(pTest, data, &test_data);
}
void testCCOVNotifyData(Test *pTest, uint8_t invoke_id, BACNET_COV_DATA *data)
{
uint8_t apdu[480] = { 0 };
int len = 0;
int apdu_len = 0;
BACNET_COV_DATA test_data;
BACNET_PROPERTY_VALUE value_list[2] = { { 0 } };
uint8_t test_invoke_id = 0;
len = ccov_notify_encode_apdu(&apdu[0], sizeof(apdu), invoke_id, data);
ct_test(pTest, len != 0);
apdu_len = len;
cov_data_value_list_link(&test_data, &value_list[0], 2);
len = ccov_notify_decode_apdu(
&apdu[0], apdu_len, &test_invoke_id, &test_data);
ct_test(pTest, len > 0);
ct_test(pTest, test_invoke_id == invoke_id);
testCOVNotifyData(pTest, data, &test_data);
}
void testCOVNotify(Test *pTest)
{
uint8_t invoke_id = 12;
BACNET_COV_DATA data;
BACNET_PROPERTY_VALUE value_list[2] = { { 0 } };
data.subscriberProcessIdentifier = 1;
data.initiatingDeviceIdentifier = 123;
data.monitoredObjectIdentifier.type = OBJECT_ANALOG_INPUT;
data.monitoredObjectIdentifier.instance = 321;
data.timeRemaining = 456;
cov_data_value_list_link(&data, &value_list[0], 2);
/* first value */
value_list[0].propertyIdentifier = PROP_PRESENT_VALUE;
value_list[0].propertyArrayIndex = BACNET_ARRAY_ALL;
bacapp_parse_application_data(
BACNET_APPLICATION_TAG_REAL, "21.0", &value_list[0].value);
value_list[0].priority = 0;
/* second value */
value_list[1].propertyIdentifier = PROP_STATUS_FLAGS;
value_list[1].propertyArrayIndex = BACNET_ARRAY_ALL;
bacapp_parse_application_data(
BACNET_APPLICATION_TAG_BIT_STRING, "0000", &value_list[1].value);
value_list[1].priority = 0;
testUCOVNotifyData(pTest, &data);
testCCOVNotifyData(pTest, invoke_id, &data);
}
void testCOVSubscribeData(Test *pTest,
BACNET_SUBSCRIBE_COV_DATA *data,
BACNET_SUBSCRIBE_COV_DATA *test_data)
{
ct_test(pTest,
test_data->subscriberProcessIdentifier ==
data->subscriberProcessIdentifier);
ct_test(pTest,
test_data->monitoredObjectIdentifier.type ==
data->monitoredObjectIdentifier.type);
ct_test(pTest,
test_data->monitoredObjectIdentifier.instance ==
data->monitoredObjectIdentifier.instance);
ct_test(pTest, test_data->cancellationRequest == data->cancellationRequest);
if (test_data->cancellationRequest != data->cancellationRequest) {
printf("cancellation request failed!\n");
}
if (!test_data->cancellationRequest) {
ct_test(pTest,
test_data->issueConfirmedNotifications ==
data->issueConfirmedNotifications);
ct_test(pTest, test_data->lifetime == data->lifetime);
}
}
void testCOVSubscribePropertyData(Test *pTest,
BACNET_SUBSCRIBE_COV_DATA *data,
BACNET_SUBSCRIBE_COV_DATA *test_data)
{
testCOVSubscribeData(pTest, data, test_data);
ct_test(pTest,
test_data->monitoredProperty.propertyIdentifier ==
data->monitoredProperty.propertyIdentifier);
ct_test(pTest,
test_data->monitoredProperty.propertyArrayIndex ==
data->monitoredProperty.propertyArrayIndex);
ct_test(pTest, test_data->covIncrementPresent == data->covIncrementPresent);
if (test_data->covIncrementPresent) {
ct_test(pTest, test_data->covIncrement == data->covIncrement);
}
}
void testCOVSubscribeEncoding(
Test *pTest, uint8_t invoke_id, BACNET_SUBSCRIBE_COV_DATA *data)
{
uint8_t apdu[480] = { 0 };
int len = 0;
int apdu_len = 0;
BACNET_SUBSCRIBE_COV_DATA test_data;
uint8_t test_invoke_id = 0;
len = cov_subscribe_encode_apdu(&apdu[0], sizeof(apdu), invoke_id, data);
ct_test(pTest, len != 0);
apdu_len = len;
len = cov_subscribe_decode_apdu(
&apdu[0], apdu_len, &test_invoke_id, &test_data);
ct_test(pTest, len > 0);
ct_test(pTest, test_invoke_id == invoke_id);
testCOVSubscribeData(pTest, data, &test_data);
}
void testCOVSubscribePropertyEncoding(
Test *pTest, uint8_t invoke_id, BACNET_SUBSCRIBE_COV_DATA *data)
{
uint8_t apdu[480] = { 0 };
int len = 0;
int apdu_len = 0;
BACNET_SUBSCRIBE_COV_DATA test_data;
uint8_t test_invoke_id = 0;
len = cov_subscribe_property_encode_apdu(
&apdu[0], sizeof(apdu), invoke_id, data);
ct_test(pTest, len != 0);
apdu_len = len;
len = cov_subscribe_property_decode_apdu(
&apdu[0], apdu_len, &test_invoke_id, &test_data);
ct_test(pTest, len > 0);
ct_test(pTest, test_invoke_id == invoke_id);
testCOVSubscribePropertyData(pTest, data, &test_data);
}
void testCOVSubscribe(Test *pTest)
{
uint8_t invoke_id = 12;
BACNET_SUBSCRIBE_COV_DATA data;
data.subscriberProcessIdentifier = 1;
data.monitoredObjectIdentifier.type = OBJECT_ANALOG_INPUT;
data.monitoredObjectIdentifier.instance = 321;
data.cancellationRequest = false;
data.issueConfirmedNotifications = true;
data.lifetime = 456;
testCOVSubscribeEncoding(pTest, invoke_id, &data);
data.cancellationRequest = true;
testCOVSubscribeEncoding(pTest, invoke_id, &data);
}
void testCOVSubscribeProperty(Test *pTest)
{
uint8_t invoke_id = 12;
BACNET_SUBSCRIBE_COV_DATA data;
data.subscriberProcessIdentifier = 1;
data.monitoredObjectIdentifier.type = OBJECT_ANALOG_INPUT;
data.monitoredObjectIdentifier.instance = 321;
data.cancellationRequest = false;
data.issueConfirmedNotifications = true;
data.lifetime = 456;
data.monitoredProperty.propertyIdentifier = PROP_FILE_SIZE;
data.monitoredProperty.propertyArrayIndex = BACNET_ARRAY_ALL;
data.covIncrementPresent = true;
data.covIncrement = 1.0;
testCOVSubscribePropertyEncoding(pTest, invoke_id, &data);
data.cancellationRequest = true;
testCOVSubscribePropertyEncoding(pTest, invoke_id, &data);
data.cancellationRequest = false;
data.covIncrementPresent = false;
testCOVSubscribePropertyEncoding(pTest, invoke_id, &data);
}
#ifdef TEST_COV
int main(int argc, char *argv[])
{
Test *pTest;
bool rc;
pTest = ct_create("BACnet COV", NULL);
/* individual tests */
rc = ct_addTestFunction(pTest, testCOVNotify);
assert(rc);
rc = ct_addTestFunction(pTest, testCOVSubscribe);
assert(rc);
rc = ct_addTestFunction(pTest, testCOVSubscribeProperty);
assert(rc);
ct_setStream(pTest, stdout);
ct_run(pTest);
(void)ct_report(pTest);
ct_destroy(pTest);
return 0;
}
#endif /* TEST_COV */
#endif /* BAC_TEST */