RIOT-OS/RIOT
RIOT-OS/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2025-01-17 05:12:57 +01:00
Code Releases Activity

nanocoap: add unittests for nanocoap-cache

Browse Source
This commit is contained in:
Cenk Gündoğan 2020-04-17 13:50:06 +02:00
parent c5eb53095d
commit b4cae9d09d
No known key found for this signature in database
GPG Key ID: A3DBC2F744D484D2
4 changed files with 314 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
tests/unittests/tests-nanocoap_cache/Makefile Normal file
View File

@ -0,0 +1 @@
include $(RIOTBASE)/Makefile.base

1
tests/unittests/tests-nanocoap_cache/Makefile.include Normal file
View File

@ -0,0 +1 @@
USEMODULE += nanocoap_cache

275
tests/unittests/tests-nanocoap_cache/tests-nanocoap_cache.c Normal file
View File

@ -0,0 +1,275 @@
/*
* Copyright (c) 2020 Cenk Gündoğan
*
* This file is subject to the terms and conditions of the GNU Lesser
* General Public License v2.1. See the file LICENSE in the top level
* directory for more details.
*/
/**
* @{
*
* @file
*/
#include <errno.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include "embUnit.h"
#include "net/nanocoap/cache.h"
#include "ztimer.h"
#include "hashes/sha256.h"
#include "unittests-constants.h"
#include "tests-nanocoap_cache.h"
#define _BUF_SIZE (128U)
static void test_nanocoap_cache__cachekey(void)
{
uint8_t digest1[SHA256_DIGEST_LENGTH];
uint8_t digest2[SHA256_DIGEST_LENGTH];
uint8_t buf1[_BUF_SIZE];
uint8_t buf2[_BUF_SIZE];
coap_pkt_t pkt1;
coap_pkt_t pkt2;
uint16_t msgid = 0xABCD;
uint8_t token[2] = {0xDA, 0xEC};
char path[] = "/time";
char path2[] = "/time2";
size_t len;
/* 1. packet */
len = coap_build_hdr((coap_hdr_t *)&buf1[0], COAP_TYPE_NON,
&token[0], 2, COAP_METHOD_GET, msgid);
coap_pkt_init(&pkt1, &buf1[0], sizeof(buf1), len);
coap_opt_add_string(&pkt1, COAP_OPT_URI_PATH, &path[0], '/');
coap_opt_finish(&pkt1, COAP_OPT_FINISH_NONE);
/* 2. packet */
len = coap_build_hdr((coap_hdr_t *)&buf2[0], COAP_TYPE_NON,
&token[0], 2, COAP_METHOD_GET, msgid);
coap_pkt_init(&pkt2, &buf2[0], sizeof(buf2), len);
coap_opt_add_string(&pkt2, COAP_OPT_URI_PATH, &path[0], '/');
coap_opt_finish(&pkt2, COAP_OPT_FINISH_NONE);
nanocoap_cache_key_generate((const coap_pkt_t *) &pkt1, digest1);
nanocoap_cache_key_generate((const coap_pkt_t *) &pkt2, digest2);
/* compare 1. and 2. packet */
TEST_ASSERT_EQUAL_INT(0, nanocoap_cache_key_compare(digest1, digest2));
/* 3. packet */
len = coap_build_hdr((coap_hdr_t *)&buf2[0], COAP_TYPE_NON,
&token[0], 2, COAP_METHOD_GET, msgid);
coap_pkt_init(&pkt2, &buf2[0], sizeof(buf2), len);
coap_opt_add_string(&pkt2, COAP_OPT_URI_PATH, &path2[0], '/');
coap_opt_finish(&pkt2, COAP_OPT_FINISH_NONE);
nanocoap_cache_key_generate((const coap_pkt_t *) &pkt2, digest2);
/* compare 1. and 3. packet */
TEST_ASSERT_EQUAL_INT(-1, nanocoap_cache_key_compare(digest1, digest2));
/* compare 3. and 1. packet */
TEST_ASSERT_EQUAL_INT(1, nanocoap_cache_key_compare(digest2, digest1));
}
static void test_nanocoap_cache__add(void)
{
uint8_t buf[_BUF_SIZE];
uint8_t rbuf[_BUF_SIZE];
coap_pkt_t req, resp;
uint16_t msgid = 0xABCD;
uint8_t token[2] = {0xDA, 0xEC};
char path[16];
nanocoap_cache_entry_t *c = NULL;
size_t len;
uint8_t temp_cache_key[CONFIG_NANOCOAP_CACHE_KEY_LENGTH];
/* initialize the nanocoap cache */
nanocoap_cache_init();
/* add more entries to test LRU replacement */
for (unsigned i = 0; i < CONFIG_NANOCOAP_CACHE_ENTRIES + 4; i++) {
if (i < CONFIG_NANOCOAP_CACHE_ENTRIES) {
TEST_ASSERT_EQUAL_INT(CONFIG_NANOCOAP_CACHE_ENTRIES - i,
nanocoap_cache_free_count());
TEST_ASSERT_EQUAL_INT(i, nanocoap_cache_used_count());
}
else {
TEST_ASSERT_EQUAL_INT(0, nanocoap_cache_free_count());
TEST_ASSERT_EQUAL_INT(CONFIG_NANOCOAP_CACHE_ENTRIES,
nanocoap_cache_used_count());
}
snprintf(path, sizeof(path), "/path_%u", i);
/* request */
len = coap_build_hdr((coap_hdr_t *)&buf[0], COAP_TYPE_NON,
&token[0], 2, COAP_METHOD_GET, msgid);
coap_pkt_init(&req, &buf[0], sizeof(buf), len);
coap_opt_add_string(&req, COAP_OPT_URI_PATH, &path[0], '/');
coap_opt_finish(&req, COAP_OPT_FINISH_NONE);
/* response */
len = coap_build_hdr((coap_hdr_t *)&rbuf[0], COAP_TYPE_NON,
&token[0], 2, COAP_CODE_205, msgid);
coap_pkt_init(&resp, &rbuf[0], sizeof(rbuf), len);
coap_opt_finish(&resp, COAP_OPT_FINISH_NONE);
/* add a fake response buffer with fake response length */
c = nanocoap_cache_add_by_req((const coap_pkt_t *)&req,
(const coap_pkt_t *)&req,
CONFIG_NANOCOAP_CACHE_RESPONSE_SIZE);
TEST_ASSERT_NOT_NULL(c);
/* keep a pointer to the first cache entry for testing the LRU
replacement */
if (i == 0) {
memcpy(temp_cache_key, c->cache_key,
CONFIG_NANOCOAP_CACHE_KEY_LENGTH);
}
if (i == CONFIG_NANOCOAP_CACHE_ENTRIES-1) {
/* lookup the first entry to update its list position */
nanocoap_cache_key_lookup(temp_cache_key);
}
}
/* the first entry should NOT be cached out, because we updated
* its list position */
c = nanocoap_cache_key_lookup(temp_cache_key);
TEST_ASSERT_NOT_NULL(c);
}
static void test_nanocoap_cache__del(void)
{
uint8_t buf[_BUF_SIZE];
uint8_t rbuf[_BUF_SIZE];
coap_pkt_t req, resp;
uint16_t msgid = 0xABCD;
uint8_t token[2] = {0xDA, 0xEC};
char *path = "/path";
nanocoap_cache_entry_t *c = NULL;
size_t len;
int res;
/* initialize the nanocoap cache */
nanocoap_cache_init();
TEST_ASSERT_EQUAL_INT(CONFIG_NANOCOAP_CACHE_ENTRIES,
nanocoap_cache_free_count());
TEST_ASSERT_EQUAL_INT(0, nanocoap_cache_used_count());
/* request */
len = coap_build_hdr((coap_hdr_t *)&buf[0], COAP_TYPE_NON,
&token[0], 2, COAP_METHOD_GET, msgid);
coap_pkt_init(&req, &buf[0], sizeof(buf), len);
coap_opt_add_string(&req, COAP_OPT_URI_PATH, &path[0], '/');
coap_opt_finish(&req, COAP_OPT_FINISH_NONE);
/* response */
len = coap_build_hdr((coap_hdr_t *)&rbuf[0], COAP_TYPE_NON,
&token[0], 2, COAP_CODE_205, msgid);
coap_pkt_init(&resp, &rbuf[0], sizeof(rbuf), len);
coap_opt_finish(&resp, COAP_OPT_FINISH_NONE);
c = nanocoap_cache_add_by_req((const coap_pkt_t *)&req,
(const coap_pkt_t *)&resp,
CONFIG_NANOCOAP_CACHE_RESPONSE_SIZE);
TEST_ASSERT_NOT_NULL(c);
TEST_ASSERT_EQUAL_INT(CONFIG_NANOCOAP_CACHE_ENTRIES - 1,
nanocoap_cache_free_count());
TEST_ASSERT_EQUAL_INT(1, nanocoap_cache_used_count());
/* delete previously added cache entry */
res = nanocoap_cache_del(c);
TEST_ASSERT_EQUAL_INT(0, res);
TEST_ASSERT_EQUAL_INT(CONFIG_NANOCOAP_CACHE_ENTRIES,
nanocoap_cache_free_count());
TEST_ASSERT_EQUAL_INT(0, nanocoap_cache_used_count());
}
static void test_nanocoap_cache__max_age(void)
{
uint8_t buf[_BUF_SIZE];
uint8_t rbuf[_BUF_SIZE];
coap_pkt_t req, resp;
uint16_t msgid = 0xABCD;
uint8_t token[2] = {0xDA, 0xEC};
char *path = "/path";
nanocoap_cache_entry_t *c = NULL;
size_t len;
uint32_t now;
/* initialize the nanocoap cache */
nanocoap_cache_init();
/* request */
len = coap_build_hdr((coap_hdr_t *)&buf[0], COAP_TYPE_NON,
&token[0], 2, COAP_METHOD_GET, msgid);
coap_pkt_init(&req, &buf[0], sizeof(buf), len);
coap_opt_add_string(&req, COAP_OPT_URI_PATH, &path[0], '/');
coap_opt_finish(&req, COAP_OPT_FINISH_NONE);
/* response with max-age 30 sec */
len = coap_build_hdr((coap_hdr_t *)&rbuf[0], COAP_TYPE_NON,
&token[0], 2, COAP_CODE_205, msgid);
coap_pkt_init(&resp, &rbuf[0], sizeof(rbuf), len);
coap_opt_add_uint(&resp, COAP_OPT_MAX_AGE, 30);
coap_opt_finish(&resp, COAP_OPT_FINISH_NONE);
c = nanocoap_cache_add_by_req((const coap_pkt_t *)&req,
(const coap_pkt_t *)&resp,
CONFIG_NANOCOAP_CACHE_RESPONSE_SIZE);
/* the absolute time of max-age should be at approx. now + 30 sec
(1 sec buffer) */
now = ztimer_now(ZTIMER_SEC);
TEST_ASSERT(c->max_age < (now + 31));
/* delete previously added cache entry */
nanocoap_cache_del(c);
/* response with max-age 60 sec (default, if option is missing) */
len = coap_build_hdr((coap_hdr_t *)&rbuf[0], COAP_TYPE_NON,
&token[0], 2, COAP_CODE_205, msgid);
coap_pkt_init(&resp, &rbuf[0], sizeof(rbuf), len);
coap_opt_finish(&resp, COAP_OPT_FINISH_NONE);
now = ztimer_now(ZTIMER_SEC);
c = nanocoap_cache_add_by_req((const coap_pkt_t *)&req,
(const coap_pkt_t *)&resp,
CONFIG_NANOCOAP_CACHE_RESPONSE_SIZE);
/* the absolute time of max-age should be at approx. now + 60 sec
(1 sec buffer) */
now = ztimer_now(ZTIMER_SEC);
TEST_ASSERT(c->max_age < (now + 61));
}
Test *tests_nanocoap_cache_tests(void)
{
EMB_UNIT_TESTFIXTURES(fixtures) {
new_TestFixture(test_nanocoap_cache__add),
new_TestFixture(test_nanocoap_cache__del),
new_TestFixture(test_nanocoap_cache__cachekey),
new_TestFixture(test_nanocoap_cache__max_age),
};
EMB_UNIT_TESTCALLER(nanocoap_cache_entry_tests, NULL, NULL, fixtures);
return (Test *)&nanocoap_cache_entry_tests;
}
void tests_nanocoap_cache(void)
{
TESTS_RUN(tests_nanocoap_cache_tests());
}
/** @} */

37
tests/unittests/tests-nanocoap_cache/tests-nanocoap_cache.h Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (c) 2020 HAW Hamburg
*
* This file is subject to the terms and conditions of the GNU Lesser
* General Public License v2.1. See the file LICENSE in the top level
* directory for more details.
*/
/**
* @addtogroup unittests
* @{
*
* @file
* @brief Unit tests for the nanocoap-cache module
*
* @author Cenk Gündoğan <cenk.guendogan@haw-hamburg.de>
*/
#ifndef TESTS_NANOCOAP_CACHE_H
#define TESTS_NANOCOAP_CACHE_H
#include "embUnit.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief The entry point of this test suite.
*/
void tests_nanocoap_cache(void);
#ifdef __cplusplus
}
#endif
#endif /* TESTS_NANOCOAP_CACHE_H */
/** @} */