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
-240
View File
@@ -412,243 +412,3 @@ int decode_signed32(uint8_t *apdu, int32_t *value)
return 4;
}
#endif
/* end of decoding_encoding.c */
#ifdef BAC_TEST
#include <assert.h>
#include <string.h>
#include <ctype.h>
#include "ctest.h"
static void testBACnetUnsigned16(Test *pTest)
{
uint8_t apdu[32] = { 0 };
uint16_t value = 0, test_value = 0;
int len = 0;
for (value = 0;; value++) {
len = encode_unsigned16(&apdu[0], value);
ct_test(pTest, len == 2);
len = decode_unsigned16(&apdu[0], &test_value);
ct_test(pTest, value == test_value);
if (value == 0xFFFF)
break;
}
}
static void testBACnetUnsigned24(Test *pTest)
{
uint8_t apdu[32] = { 0 };
uint32_t value = 0, test_value = 0;
int len = 0;
for (value = 0; value == 0xffffff; value += 0xf) {
len = encode_unsigned24(&apdu[0], value);
ct_test(pTest, len == 3);
len = decode_unsigned24(&apdu[0], &test_value);
ct_test(pTest, value == test_value);
}
}
static void testBACnetUnsigned32(Test *pTest)
{
uint8_t apdu[32] = { 0 };
uint32_t value = 0, test_value = 0;
int len = 0;
for (value = 0; value == 0xffffffff; value = (value << 8) | 0xff) {
len = encode_unsigned32(&apdu[0], value);
ct_test(pTest, len == 4);
len = decode_unsigned32(&apdu[0], &test_value);
ct_test(pTest, value == test_value);
}
}
static void testBACnetUnsigned40(Test *pTest)
{
#ifdef UINT64_MAX
uint8_t apdu[64] = { 0 };
uint64_t value = 0, test_value = 0;
int len = 0;
for (value = 0; value == 0xffffffffff; value = (value << 8) | 0xff) {
len = encode_unsigned40(&apdu[0], value);
ct_test(pTest, len == 5);
len = decode_unsigned40(&apdu[0], &test_value);
ct_test(pTest, len == 5);
ct_test(pTest, value == test_value);
}
#else
#warning "UINT64_MAX not supported!"
#endif
}
static void testBACnetUnsigned48(Test *pTest)
{
#ifdef UINT64_MAX
uint8_t apdu[64] = { 0 };
uint64_t value = 0, test_value = 0;
int len = 0;
for (value = 0; value == 0xffffffffffff; value = (value << 8) | 0xff) {
len = encode_unsigned48(&apdu[0], value);
ct_test(pTest, len == 6);
len = decode_unsigned48(&apdu[0], &test_value);
ct_test(pTest, len == 6);
ct_test(pTest, value == test_value);
}
#else
#warning "UINT64_MAX not supported!"
#endif
}
static void testBACnetUnsigned56(Test *pTest)
{
#ifdef UINT64_MAX
uint8_t apdu[64] = { 0 };
uint64_t value = 0, test_value = 0;
int len = 0;
for (value = 0; value == 0xffffffffffffff; value = (value << 8) | 0xff) {
len = encode_unsigned56(&apdu[0], value);
ct_test(pTest, len == 7);
len = decode_unsigned56(&apdu[0], &test_value);
ct_test(pTest, len == 7);
ct_test(pTest, value == test_value);
}
#else
#warning "UINT64_MAX not supported!"
#endif
}
static void testBACnetUnsigned64(Test *pTest)
{
#ifdef UINT64_MAX
uint8_t apdu[64] = { 0 };
uint64_t value = 0, test_value = 0;
int len = 0;
for (value = 0; value == 0xffffffffffffffff; value = (value << 8) | 0xff) {
len = encode_unsigned64(&apdu[0], value);
ct_test(pTest, len == 8);
len = decode_unsigned64(&apdu[0], &test_value);
ct_test(pTest, len == 8);
ct_test(pTest, value == test_value);
}
#else
#warning "UINT64_MAX not supported!"
#endif
}
static void testBACnetSigned8(Test *pTest)
{
uint8_t apdu[32] = { 0 };
int32_t value = 0, test_value = 0;
int len = 0;
for (value = -127;; value++) {
len = encode_signed8(&apdu[0], value);
ct_test(pTest, len == 1);
len = decode_signed8(&apdu[0], &test_value);
ct_test(pTest, value == test_value);
if (value == 127)
break;
}
}
static void testBACnetSigned16(Test *pTest)
{
uint8_t apdu[32] = { 0 };
int32_t value = 0, test_value = 0;
int len = 0;
for (value = -32767;; value++) {
len = encode_signed16(&apdu[0], value);
ct_test(pTest, len == 2);
len = decode_signed16(&apdu[0], &test_value);
ct_test(pTest, value == test_value);
if (value == 32767)
break;
}
}
static void testBACnetSigned24(Test *pTest)
{
uint8_t apdu[32] = { 0 };
int32_t value = 0, test_value = 0;
int len = 0;
for (value = -8388607; value <= 8388607; value += 15) {
len = encode_signed24(&apdu[0], value);
ct_test(pTest, len == 3);
len = decode_signed24(&apdu[0], &test_value);
ct_test(pTest, value == test_value);
}
}
static void testBACnetSigned32(Test *pTest)
{
uint8_t apdu[32] = { 0 };
int32_t value = 0, test_value = 0;
int len = 0;
for (value = -2147483647; value < 0; value += 127) {
len = encode_signed32(&apdu[0], value);
ct_test(pTest, len == 4);
len = decode_signed32(&apdu[0], &test_value);
ct_test(pTest, value == test_value);
}
for (value = 2147483647; value > 0; value -= 127) {
len = encode_signed32(&apdu[0], value);
ct_test(pTest, len == 4);
len = decode_signed32(&apdu[0], &test_value);
ct_test(pTest, value == test_value);
}
}
void testBACnetIntegers(Test *pTest)
{
bool rc;
assert(pTest);
/* individual tests */
rc = ct_addTestFunction(pTest, testBACnetUnsigned16);
assert(rc);
rc = ct_addTestFunction(pTest, testBACnetUnsigned24);
assert(rc);
rc = ct_addTestFunction(pTest, testBACnetUnsigned32);
assert(rc);
rc = ct_addTestFunction(pTest, testBACnetUnsigned40);
assert(rc);
rc = ct_addTestFunction(pTest, testBACnetUnsigned48);
assert(rc);
rc = ct_addTestFunction(pTest, testBACnetUnsigned56);
assert(rc);
rc = ct_addTestFunction(pTest, testBACnetUnsigned64);
assert(rc);
rc = ct_addTestFunction(pTest, testBACnetSigned8);
assert(rc);
rc = ct_addTestFunction(pTest, testBACnetSigned16);
assert(rc);
rc = ct_addTestFunction(pTest, testBACnetSigned24);
assert(rc);
rc = ct_addTestFunction(pTest, testBACnetSigned32);
assert(rc);
}
#ifdef TEST_BACINT
int main(void)
{
Test *pTest;
pTest = ct_create("BACint", NULL);
testBACnetIntegers(pTest);
/* configure output */
ct_setStream(pTest, stdout);
ct_run(pTest);
(void)ct_report(pTest);
ct_destroy(pTest);
return 0;
}
#endif /* TEST_BACINT */
#endif /* BAC_TEST */