void RegressionTask(void *arg1, void *arg2, void *arg3)
{
u32_t nCalls = 0;
ARG_UNUSED(arg1);
ARG_UNUSED(arg2);
ARG_UNUSED(arg3);
k_sem_give(&ALT_SEM); /* Activate AlternateTask() */
nCalls = criticalLoop(nCalls);
/* Wait for AlternateTask() to complete */
zassert_true(k_sem_take(®RESS_SEM, TEST_TIMEOUT) == 0,
"Timed out waiting for REGRESS_SEM");
zassert_equal(criticalVar, nCalls + altTaskIterations,
"Unexpected value for <criticalVar>");
k_sched_time_slice_set(10, 10);
k_sem_give(&ALT_SEM); /* Re-activate AlternateTask() */
nCalls = criticalLoop(nCalls);
/* Wait for AlternateTask() to finish */
zassert_true(k_sem_take(®RESS_SEM, TEST_TIMEOUT) == 0,
"Timed out waiting for REGRESS_SEM");
zassert_equal(criticalVar, nCalls + altTaskIterations,
"Unexpected value for <criticalVar>");
k_sem_give(&TEST_SEM);
}
/*test cases*/
void test_msgq_purge_when_put(void)
{
struct k_msgq msgq;
int ret;
k_msgq_init(&msgq, tbuffer, MSG_SIZE, MSGQ_LEN);
/*fill the queue to full*/
for (int i = 0; i < MSGQ_LEN; i++) {
ret = k_msgq_put(&msgq, (void *)&data[i], K_NO_WAIT);
zassert_equal(ret, 0, NULL);
}
/*create another thread waiting to put msg*/
k_tid_t tid = k_thread_spawn(tstack, STACK_SIZE,
tThread_entry, &msgq, NULL, NULL,
K_PRIO_PREEMPT(0), 0, 0);
k_sleep(TIMEOUT >> 1);
/**TESTPOINT: msgq purge while another thread waiting to put msg*/
k_msgq_purge(&msgq);
k_sleep(TIMEOUT >> 1);
k_thread_abort(tid);
/*verify msg put after purge*/
for (int i = 0; i < MSGQ_LEN; i++) {
ret = k_msgq_put(&msgq, (void *)&data[i], K_NO_WAIT);
zassert_equal(ret, 0, NULL);
}
}
static void test_get_single_buffer(void)
{
struct net_buf *buf;
buf = net_buf_alloc(&bufs_pool, K_NO_WAIT);
zassert_equal(buf->ref, 1, "Invalid refcount");
zassert_equal(buf->len, 0, "Invalid length");
zassert_equal(buf->flags, 0, "Invalid flags");
zassert_equal_ptr(buf->frags, NULL, "Frags not NULL");
}
void test_sema_reset(void)
{
k_sem_init(&sema, SEM_INITIAL, SEM_LIMIT);
k_sem_give(&sema);
k_sem_reset(&sema);
zassert_false(k_sem_count_get(&sema), NULL);
/**TESTPOINT: sem take return -EBUSY*/
zassert_equal(k_sem_take(&sema, K_NO_WAIT), -EBUSY, NULL);
/**TESTPOINT: sem take return -EAGAIN*/
zassert_equal(k_sem_take(&sema, TIMEOUT), -EAGAIN, NULL);
k_sem_give(&sema);
zassert_false(k_sem_take(&sema, K_FOREVER), NULL);
}
void test_dns_response(void)
{
struct dns_response_test test1 = { .dname = DNAME1,
.res = resp_ipv4,
.res_len = sizeof(resp_ipv4),
.tid = 0xb041,
.answer_type = DNS_RR_TYPE_A,
.ancount = 1,
.ttl = 3028,
.ra = 1,
.rdlen = 4, /* IPv4 test */
.rdata = resp_ipv4_addr };
int rc;
rc = eval_response1(&test1);
zassert_equal(rc, 0, "Response test failed for domain: "DNAME1);
}
void test_main(void)
{
ztest_test_suite(dns_tests,
ztest_unit_test(test_dns_query),
ztest_unit_test(test_dns_response));
ztest_run_test_suite(dns_tests);
/* TODO:
* 1) add malformed DNS data
* 2) add validations against buffer overflows
* 3) add debug info to detect the exit point (or split the tests)
* 4) add test data with CNAME and more RR
*/
}
void test_sema_count_get(void)
{
k_sem_init(&sema, SEM_INITIAL, SEM_LIMIT);
/**TESTPOINT: sem count get upon init*/
zassert_equal(k_sem_count_get(&sema), SEM_INITIAL, NULL);
k_sem_give(&sema);
/**TESTPOINT: sem count get after give*/
zassert_equal(k_sem_count_get(&sema), SEM_INITIAL + 1, NULL);
k_sem_take(&sema, K_FOREVER);
/**TESTPOINT: sem count get after take*/
for (int i = 0; i < SEM_LIMIT; i++) {
zassert_equal(k_sem_count_get(&sema), SEM_INITIAL + i, NULL);
k_sem_give(&sema);
}
/**TESTPOINT: sem give above limit*/
k_sem_give(&sema);
zassert_equal(k_sem_count_get(&sema), SEM_LIMIT, NULL);
}
static void tpipe_block_put(struct k_pipe *ppipe, struct k_sem *sema)
{
struct k_mem_block block;
for (int i = 0; i < PIPE_LEN; i += BYTES_TO_WRITE) {
/**TESTPOINT: pipe block put*/
zassert_equal(k_mem_pool_alloc(&mpool, &block, BYTES_TO_WRITE,
K_NO_WAIT), 0, NULL);
memcpy(block.data, &data[i], BYTES_TO_WRITE);
k_pipe_block_put(ppipe, &block, BYTES_TO_WRITE, sema);
if (sema) {
k_sem_take(sema, K_FOREVER);
}
k_mem_pool_free(&block);
}
}
/*test cases*/
void test_threads_cancel_undelayed(void)
{
int cur_prio = k_thread_priority_get(k_current_get());
/* spawn thread with lower priority */
int spawn_prio = cur_prio + 1;
k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
thread_entry, NULL, NULL, NULL,
spawn_prio, 0, 0);
/**TESTPOINT: check cancel retcode when thread is not delayed*/
int cancel_ret = k_thread_cancel(tid);
zassert_equal(cancel_ret, -EINVAL, NULL);
k_thread_abort(tid);
}
static void tpipe_get(struct k_pipe *ppipe)
{
unsigned char rx_data[PIPE_LEN];
size_t to_rd, rd_byte = 0;
/*get pipe data from "pipe_put"*/
for (int i = 0; i < PIPE_LEN; i += rd_byte) {
/**TESTPOINT: pipe get*/
to_rd = (PIPE_LEN - i) >= BYTES_TO_READ ?
BYTES_TO_READ : (PIPE_LEN - i);
zassert_false(k_pipe_get(ppipe, &rx_data[i], to_rd,
&rd_byte, 1, K_FOREVER), NULL);
zassert_true(rd_byte == to_rd || rd_byte == 1, NULL);
}
for (int i = 0; i < PIPE_LEN; i++) {
zassert_equal(rx_data[i], data[i], NULL);
}
}
void test_dns_query(void)
{
int rc;
rc = eval_query(DNAME1, tid1, DNS_RR_TYPE_A,
query_ipv4, sizeof(query_ipv4));
zassert_equal(rc, 0, "Query test failed for domain: "DNAME1);
rc = eval_query(NULL, tid1, DNS_RR_TYPE_A,
query_ipv4, sizeof(query_ipv4));
zassert_not_equal(rc, 0, "Query test with invalid domain name failed");
rc = eval_query(DNAME1, tid1, DNS_RR_TYPE_AAAA,
query_ipv4, sizeof(query_ipv4));
zassert_not_equal(rc, 0, "Query test for IPv4 with RR type AAAA failed");
rc = eval_query(DNAME1, tid1 + 1, DNS_RR_TYPE_A,
query_ipv4, sizeof(query_ipv4));
zassert_not_equal(rc, 0, "Query test with invalid ID failed");
}
static void adc_test(void)
{
int result = TC_FAIL;
struct device *adc;
unsigned int loops = 10;
unsigned int bufi0 = ~0, bufi;
adc = device_get_binding(ADC_DEVICE_NAME);
zassert_not_null(adc, "Cannot get adc controller\n");
adc_enable(adc);
while (loops--) {
bufi = loops & 0x1;
/* .buffer should be void * ... */
sample.buffer = (void *) seq_buffer[bufi];
result = adc_read(adc, &table);
zassert_equal(result, 0, "Sampling could not proceed, "
"an error occurred\n");
printk("loop %u: sampling done to buffer #%u\n", loops, bufi);
_print_sample_in_hex(seq_buffer[bufi], BUFFER_SIZE);
if (bufi0 != ~0) {
unsigned int cnt;
long delta;
for (cnt = 0; cnt < BUFFER_SIZE; cnt++) {
delta = _abs((long)seq_buffer[bufi][cnt]
- seq_buffer[bufi0][cnt]);
printk("loop %u delta %u = %ld\n",
loops, cnt, delta);
}
}
k_sleep(SLEEPTIME);
bufi0 = bufi;
}
adc_disable(adc);
}
static void test_fragment_split(void)
{
#define TEST_FRAG_COUNT (FRAG_COUNT - 2)
#define FRAGA (FRAG_COUNT - 2)
#define FRAGB (FRAG_COUNT - 1)
struct net_pkt *pkt;
struct net_buf *frags[FRAG_COUNT], *frag, *frag_a, *frag_b;
int i, total, split_a, split_b;
int ret, frag_size;
memset(frags, 0, FRAG_COUNT * sizeof(void *));
pkt = net_pkt_get_reserve_rx(0, K_FOREVER);
frag = NULL;
for (i = 0, total = 0; i < TEST_FRAG_COUNT; i++) {
frags[i] = net_pkt_get_reserve_rx_data(12, K_FOREVER);
if (frag) {
net_buf_frag_add(frag, frags[i]);
}
frag = frags[i];
/* Copy some test data in front of the fragment */
memcpy(net_buf_add(frags[i], sizeof(frag_data)),
frag_data, sizeof(frag_data));
total++;
}
if (total != TEST_FRAG_COUNT) {
printk("There should be %d fragments but was %d\n",
TEST_FRAG_COUNT, total);
zassert_true(false, "Frags missing");
}
frag_size = frags[0]->size;
zassert_true(frag_size > 0, "Invalid frag size");
net_pkt_frag_add(pkt, frags[0]);
frag_a = frags[FRAGA];
frag_b = frags[FRAGB];
zassert_is_null(frag_a, "frag_a is not NULL");
zassert_is_null(frag_b, "frag_b is not NULL");
split_a = frag_size * 2 / 3;
split_b = frag_size - split_a;
zassert_true(split_a > 0, "A size is 0");
zassert_true(split_a > split_b, "A is smaller than B");
/* Test some error cases first */
ret = net_pkt_split(NULL, NULL, 1024, &frag_a, &frag_b, K_NO_WAIT);
zassert_equal(ret, -EINVAL, "Invalid buf pointers");
ret = net_pkt_split(pkt, pkt->frags, CONFIG_NET_BUF_DATA_SIZE + 1,
&frag_a, &frag_b, K_NO_WAIT);
zassert_equal(ret, 0, "Split failed");
ret = net_pkt_split(pkt, pkt->frags, split_a,
&frag_a, &frag_b, K_NO_WAIT);
zassert_equal(ret, 0, "Cannot split frag");
if (frag_a->len != split_a) {
printk("Frag_a len %d not %d\n", frag_a->len, split_a);
zassert_equal(frag_a->len, split_a, "Frag_a len wrong");
}
if (frag_b->len != split_b) {
printk("Frag_b len %d not %d\n", frag_b->len, split_b);
zassert_true(false, "Frag_b len wrong");
}
zassert_false(memcmp(pkt->frags->data, frag_a->data, split_a),
"Frag_a data mismatch");
zassert_false(memcmp(pkt->frags->data + split_a, frag_b->data, split_b),
"Frag_b data mismatch");
}
static void tThread_entry(void *p1, void *p2, void *p3)
{
int ret = k_msgq_put((struct k_msgq *)p1, (void *)&data[0], TIMEOUT);
zassert_equal(ret, -ENOMSG, NULL);
}
static void iface_setup(void)
{
struct net_if_mcast_addr *maddr;
struct net_if_addr *ifaddr;
int idx;
/* The semaphore is there to wait the data to be received. */
k_sem_init(&wait_data, 0, UINT_MAX);
iface1 = net_if_get_by_index(0);
iface2 = net_if_get_by_index(1);
iface3 = net_if_get_by_index(2);
((struct net_if_test *)iface1->dev->driver_data)->idx = 0;
((struct net_if_test *)iface2->dev->driver_data)->idx = 1;
((struct net_if_test *)iface3->dev->driver_data)->idx = 2;
idx = net_if_get_by_iface(iface1);
zassert_equal(idx, 0, "Invalid index iface1");
idx = net_if_get_by_iface(iface2);
zassert_equal(idx, 1, "Invalid index iface2");
idx = net_if_get_by_iface(iface3);
zassert_equal(idx, 2, "Invalid index iface3");
DBG("Interfaces: [%d] iface1 %p, [%d] iface2 %p, [%d] iface3 %p\n",
net_if_get_by_iface(iface1), iface1,
net_if_get_by_iface(iface2), iface2,
net_if_get_by_iface(iface3), iface3);
zassert_not_null(iface1, "Interface 1");
zassert_not_null(iface2, "Interface 2");
zassert_not_null(iface3, "Interface 3");
ifaddr = net_if_ipv6_addr_add(iface1, &my_addr1,
NET_ADDR_MANUAL, 0);
if (!ifaddr) {
DBG("Cannot add IPv6 address %s\n",
net_sprint_ipv6_addr(&my_addr1));
zassert_not_null(ifaddr, "addr1");
}
/* For testing purposes we need to set the adddresses preferred */
ifaddr->addr_state = NET_ADDR_PREFERRED;
ifaddr = net_if_ipv6_addr_add(iface1, &ll_addr,
NET_ADDR_MANUAL, 0);
if (!ifaddr) {
DBG("Cannot add IPv6 address %s\n",
net_sprint_ipv6_addr(&ll_addr));
zassert_not_null(ifaddr, "ll_addr");
}
ifaddr->addr_state = NET_ADDR_PREFERRED;
ifaddr = net_if_ipv6_addr_add(iface2, &my_addr2,
NET_ADDR_MANUAL, 0);
if (!ifaddr) {
DBG("Cannot add IPv6 address %s\n",
net_sprint_ipv6_addr(&my_addr2));
zassert_not_null(ifaddr, "addr2");
}
ifaddr->addr_state = NET_ADDR_PREFERRED;
ifaddr = net_if_ipv6_addr_add(iface2, &my_addr3,
NET_ADDR_MANUAL, 0);
if (!ifaddr) {
DBG("Cannot add IPv6 address %s\n",
net_sprint_ipv6_addr(&my_addr3));
zassert_not_null(ifaddr, "addr3");
}
ifaddr->addr_state = NET_ADDR_PREFERRED;
net_ipv6_addr_create(&in6addr_mcast, 0xff02, 0, 0, 0, 0, 0, 0, 0x0001);
maddr = net_if_ipv6_maddr_add(iface1, &in6addr_mcast);
if (!maddr) {
DBG("Cannot add multicast IPv6 address %s\n",
net_sprint_ipv6_addr(&in6addr_mcast));
zassert_not_null(maddr, "mcast");
}
net_if_up(iface1);
net_if_up(iface2);
net_if_up(iface3);
/* The interface might receive data which might fail the checks
* in the iface sending function, so we need to reset the failure
* flag.
*/
test_failed = false;
test_started = true;
}
