giomba/nes-proj
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
c3ed24d531
nes-proj/tests/13-ieee802154/code-6tisch/test-sixp-trans.c
Yasuyuki Tanaka c7d60bc8a6 sixtop: update to draft-ietf-6tisch-6top-protocol-10 
- remove the schedule generation management using GEN field
- add SIGNAL command
- add RC_ERR_SEQNUM
- rename and reorder return codes
2018-03-29 16:19:21 +02:00

1206 lines
40 KiB
C
Raw Blame History

/*
* Copyright (c) 2017, Yasuyuki Tanaka
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY STEP OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include "contiki.h"
#include "contiki-net.h"
#include "contiki-lib.h"
#include "lib/assert.h"
#include "net/packetbuf.h"
#include "net/mac/tsch/tsch.h"
#include "net/mac/tsch/sixtop/sixtop.h"
#include "net/mac/tsch/sixtop/sixp-nbr.h"
#include "net/mac/tsch/sixtop/sixp-trans.h"
#include "unit-test/unit-test.h"
#include "common.h"
#define TEST_SF_SFID 0xfe
#define TEST_SF_TIMEOUT_VALUE (5 * CLOCK_SECOND)
static void test_setup(void);
static void timeout_handler(sixp_pkt_cmd_t cmd, const linkaddr_t *peer_addr);
static void sent_callback(void *arg, uint16_t arg_len,
const linkaddr_t *dest_addr,
sixp_output_status_t status);
static uint8_t timeout_handler_is_called;
static uint8_t sent_callback_is_called;
PROCESS(test_process, "6P transaction APIs test");
AUTOSTART_PROCESSES(&test_process);
static const sixtop_sf_t test_sf = {
TEST_SF_SFID,
TEST_SF_TIMEOUT_VALUE,
NULL,
NULL,
timeout_handler
};
static void
test_setup(void)
{
sixtop_init();
assert(sixtop_add_sf(&test_sf) == 0);
timeout_handler_is_called = 0;
sent_callback_is_called = 0;
}
static void
timeout_handler(sixp_pkt_cmd_t cmd, const linkaddr_t *peer_addr)
{
timeout_handler_is_called = 1;
}
static void
sent_callback(void *arg, uint16_t arg_len, const linkaddr_t *dest_addr,
sixp_output_status_t status)
{
sent_callback_is_called = 1;
}
UNIT_TEST_REGISTER(test_alloc_2_step_trans,
"test sixp_trans_alloc(2_step_transaction)");
UNIT_TEST(test_alloc_2_step_trans)
{
sixp_pkt_t pkt;
linkaddr_t peer_addr;
sixp_trans_t *trans;
uint8_t req_body[8];
UNIT_TEST_BEGIN();
test_setup();
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_ADD;
pkt.seqno = 10;
pkt.body = req_body;
pkt.body_len = 8; /* Metadata, CellOptions, NumCells, and CellList */
peer_addr.u8[0] = 0;
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
UNIT_TEST_ASSERT(sixp_trans_get_cmd(trans) == SIXP_PKT_CMD_ADD);
UNIT_TEST_ASSERT(sixp_trans_get_seqno(trans) == 10);
UNIT_TEST_ASSERT(sixp_trans_get_mode(trans) == SIXP_TRANS_MODE_2_STEP);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
/* allocate a transaction for the clear request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_CLEAR;
pkt.seqno = 0;
pkt.body = req_body;
pkt.body_len = 2; /* only Metadata */
peer_addr.u8[0] = 1;
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
UNIT_TEST_ASSERT(sixp_trans_get_seqno(trans) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_cmd(trans) == SIXP_PKT_CMD_CLEAR);
UNIT_TEST_ASSERT(sixp_trans_get_mode(trans) == SIXP_TRANS_MODE_2_STEP);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_alloc_3_step_trans,
"test sixp_trans_alloc(3_step_transaction)");
UNIT_TEST(test_alloc_3_step_trans)
{
sixp_pkt_t pkt;
linkaddr_t peer_addr;
sixp_trans_t *trans;
uint8_t req_body[8];
UNIT_TEST_BEGIN();
test_setup();
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_ADD;
pkt.seqno = 7;
pkt.body = req_body;
pkt.body_len = 4; /* Metadata, CellOptions, NumCells */
peer_addr.u8[0] = 0;
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
UNIT_TEST_ASSERT(sixp_trans_get_seqno(trans) == 7);
UNIT_TEST_ASSERT(sixp_trans_get_cmd(trans) == SIXP_PKT_CMD_ADD);
UNIT_TEST_ASSERT(sixp_trans_get_mode(trans) == SIXP_TRANS_MODE_3_STEP);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_DELETE;
pkt.seqno = 5;
pkt.body = req_body;
pkt.body_len = 4; /* Metadata, CellOptions, NumCells */
peer_addr.u8[0] = 1;
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
UNIT_TEST_ASSERT(sixp_trans_get_seqno(trans) == 5);
UNIT_TEST_ASSERT(sixp_trans_get_cmd(trans) == SIXP_PKT_CMD_DELETE);
UNIT_TEST_ASSERT(sixp_trans_get_mode(trans) == SIXP_TRANS_MODE_3_STEP);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_alloc_duplicate_peer,
"test sixp_trans_alloc(duplicate_peer)");
UNIT_TEST(test_alloc_duplicate_peer)
{
sixp_pkt_t pkt;
linkaddr_t peer_addr;
sixp_trans_t *trans;
uint8_t req_body[8];
UNIT_TEST_BEGIN();
test_setup();
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_ADD;
pkt.seqno = 7;
pkt.body = req_body;
pkt.body_len = 4; /* Metadata, CellOptions, NumCells */
peer_addr.u8[0] = 0;
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
UNIT_TEST_ASSERT(sixp_trans_get_seqno(trans) == 7);
UNIT_TEST_ASSERT(sixp_trans_get_cmd(trans) == SIXP_PKT_CMD_ADD);
UNIT_TEST_ASSERT(sixp_trans_get_mode(trans) == SIXP_TRANS_MODE_3_STEP);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_DELETE;
pkt.seqno = 5;
pkt.body = req_body;
pkt.body_len = 4; /* Metadata, CellOptions, NumCells */
peer_addr.u8[0] = 0; /* the same address used above to allocate a trans */
/* a new transaction should not be allocated */
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) == NULL);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_alloc_lack_of_memory,
"test sixp_trans_alloc(lack_of_memory)");
UNIT_TEST(test_alloc_lack_of_memory)
{
sixp_pkt_t pkt;
linkaddr_t peer_addr;
uint8_t req_body[8];
/* SIXTOP_CONF_MAX_TRANSACTIONS is set with 2; see project-conf.h */
UNIT_TEST_BEGIN();
test_setup();
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_ADD;
pkt.seqno = 7;
pkt.body = req_body;
pkt.body_len = 4; /* Metadata, CellOptions, NumCells */
peer_addr.u8[0] = 0;
UNIT_TEST_ASSERT(sixp_trans_alloc(&pkt, &peer_addr) != NULL);
peer_addr.u8[0] = 1;
UNIT_TEST_ASSERT(sixp_trans_alloc(&pkt, &peer_addr) != NULL);
/* allocation should fail because of lack of memory */
peer_addr.u8[0] = 2;
UNIT_TEST_ASSERT(sixp_trans_alloc(&pkt, &peer_addr) == NULL);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_alloc_null_pkt,
"test sixp_trans_alloc(null_pkt)");
UNIT_TEST(test_alloc_null_pkt)
{
linkaddr_t peer_addr;
uint8_t req_body[8];
UNIT_TEST_BEGIN();
test_setup();
/* allocate a transaction for the add request */
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
peer_addr.u8[0] = 0;
/* allocation should fail because of NULL specified as the 1st arg */
UNIT_TEST_ASSERT(sixp_trans_alloc(NULL, &peer_addr) == NULL);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_alloc_null_peer_addr,
"test sixp_trans_alloc(null_peer_addr)");
UNIT_TEST(test_alloc_null_peer_addr)
{
sixp_pkt_t pkt;
uint8_t req_body[8];
/* SIXTOP_CONF_6P_MAX_TRANSACTIONS is set with 2; see project-conf.h */
UNIT_TEST_BEGIN();
test_setup();
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_ADD;
pkt.seqno = 7;
pkt.body = req_body;
pkt.body_len = 4; /* Metadata, CellOptions, NumCells */
/* allocation should fail because of NULL specified as the 2nd arg */
UNIT_TEST_ASSERT(sixp_trans_alloc(&pkt, NULL) == NULL);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_find,
"test sixp_trans_find()");
UNIT_TEST(test_find)
{
sixp_pkt_t pkt;
linkaddr_t peer_addr;
sixp_trans_t *trans, *returned_trans;
uint8_t req_body[8];
UNIT_TEST_BEGIN();
test_setup();
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_CLEAR;
pkt.seqno = 7;
pkt.body = req_body;
pkt.body_len = 2; /* Metadata */
peer_addr.u8[0] = 0;
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
/* find the trans */
UNIT_TEST_ASSERT((returned_trans = sixp_trans_find(&peer_addr)) == trans);
/* no trans by another peer_addr */
peer_addr.u8[0] = 1;
UNIT_TEST_ASSERT(sixp_trans_find(&peer_addr) == NULL);
/* no trans by null peer_addr */
UNIT_TEST_ASSERT(sixp_trans_find(NULL) == NULL);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_callback,
"test sixp_trans_{set,invoke}_callback()");
UNIT_TEST(test_callback)
{
sixp_pkt_t pkt;
linkaddr_t peer_addr;
sixp_trans_t *trans;
uint8_t req_body[8];
UNIT_TEST_BEGIN();
test_setup();
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_CLEAR;
pkt.seqno = 7;
pkt.body = req_body;
pkt.body_len = 2; /* Metadata */
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
UNIT_TEST_ASSERT(sent_callback_is_called == 0);
sixp_trans_invoke_callback(trans, SIXP_OUTPUT_STATUS_SUCCESS);
UNIT_TEST_ASSERT(sent_callback_is_called == 0);
sixp_trans_set_callback(trans, sent_callback, NULL, 0);
sixp_trans_invoke_callback(trans, SIXP_OUTPUT_STATUS_SUCCESS);
UNIT_TEST_ASSERT(sent_callback_is_called == 1);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_state_transition_2_step_initiator,
"test sixp_trans_{transit,get}_state(2-step-initiator)");
UNIT_TEST(test_state_transition_2_step_initiator)
{
sixp_pkt_t pkt;
linkaddr_t peer_addr;
sixp_trans_t *trans;
uint8_t req_body[8];
UNIT_TEST_BEGIN();
test_setup();
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_ADD;
pkt.seqno = 10;
pkt.body = req_body;
pkt.body_len = 8; /* Metadata, CellOptions, NumCells, and CellList */
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans, SIXP_TRANS_STATE_REQUEST_SENT) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_REQUEST_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans, SIXP_TRANS_STATE_RESPONSE_RECEIVED) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_RESPONSE_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans, SIXP_TRANS_STATE_TERMINATING) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_TERMINATING);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_state_transition_2_step_responder,
"test sixp_trans_{transit,get}_state(2-step-responder)");
UNIT_TEST(test_state_transition_2_step_responder)
{
sixp_pkt_t pkt;
linkaddr_t peer_addr;
sixp_trans_t *trans;
uint8_t req_body[8];
UNIT_TEST_BEGIN();
test_setup();
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_ADD;
pkt.seqno = 10;
pkt.body = req_body;
pkt.body_len = 8; /* Metadata, CellOptions, NumCells, and CellList */
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans, SIXP_TRANS_STATE_REQUEST_RECEIVED) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_REQUEST_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans, SIXP_TRANS_STATE_RESPONSE_SENT) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_RESPONSE_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans, SIXP_TRANS_STATE_TERMINATING) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_TERMINATING);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_state_transition_3_step_initiator,
"test sixp_trans_{transit,get}_state(3-step-initiator)");
UNIT_TEST(test_state_transition_3_step_initiator)
{
sixp_pkt_t pkt;
linkaddr_t peer_addr;
sixp_trans_t *trans;
uint8_t req_body[8];
UNIT_TEST_BEGIN();
test_setup();
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_ADD;
pkt.seqno = 10;
pkt.body = req_body;
pkt.body_len = 4; /* Metadata, CellOptions, and NumCells */
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(sixp_trans_get_mode(trans) == SIXP_TRANS_MODE_3_STEP);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans, SIXP_TRANS_STATE_REQUEST_SENT) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_REQUEST_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans, SIXP_TRANS_STATE_RESPONSE_RECEIVED) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_RESPONSE_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans, SIXP_TRANS_STATE_CONFIRMATION_SENT) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_CONFIRMATION_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans, SIXP_TRANS_STATE_TERMINATING) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_TERMINATING);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_state_transition_3_step_responder,
"test sixp_trans_{transit,get}_state(3-step-responder)");
UNIT_TEST(test_state_transition_3_step_responder)
{
sixp_pkt_t pkt;
linkaddr_t peer_addr;
sixp_trans_t *trans;
uint8_t req_body[8];
UNIT_TEST_BEGIN();
test_setup();
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_ADD;
pkt.seqno = 10;
pkt.body = req_body;
pkt.body_len = 4; /* Metadata, CellOptions, and NumCells */
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(sixp_trans_get_mode(trans) == SIXP_TRANS_MODE_3_STEP);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans, SIXP_TRANS_STATE_REQUEST_RECEIVED) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_REQUEST_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans, SIXP_TRANS_STATE_RESPONSE_SENT) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_RESPONSE_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_RECEIVED) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_CONFIRMATION_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans, SIXP_TRANS_STATE_TERMINATING) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_TERMINATING);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_state_transition_invalid_transition_initiator,
"test sixp_trans_{transit,get}_state(invalid_transition_i)");
UNIT_TEST(test_state_transition_invalid_transition_initiator)
{
sixp_pkt_t pkt;
linkaddr_t peer_addr;
sixp_trans_t *trans;
uint8_t req_body[8];
UNIT_TEST_BEGIN();
test_setup();
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_ADD;
pkt.seqno = 10;
pkt.body = req_body;
pkt.body_len = 4; /* Metadata, CellOptions, and NumCells */
/* 3-step */
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
/* from INIT */
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_UNAVAILABLE) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_INIT) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_SENT) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_RECEIVED) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_SENT) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_RECEIVED) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
/* from REQUEST_SENT */
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_SENT) == 0);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_REQUEST_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_UNAVAILABLE) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_REQUEST_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_INIT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_REQUEST_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_REQUEST_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_REQUEST_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_REQUEST_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_REQUEST_SENT);
/* from RESPONSE_RECEIVE */
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_RECEIVED) == 0);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_UNAVAILABLE) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_INIT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_RECEIVED);
/* from CONFIRMATION_SENT */
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_SENT) == 0);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_UNAVAILABLE) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_INIT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_SENT);
pkt.body_len = 8; /* Metadata, CellOptions, and NumCells CellList */
peer_addr.u8[0] = 1;
/* 2-step */
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_SENT) == 0);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_REQUEST_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_RECEIVED) == 0);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_TERMINATING) == 0);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_TERMINATING);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_state_transition_invalid_transition_responder,
"test sixp_trans_{transit,get}_state(invalid_transition_r)");
UNIT_TEST(test_state_transition_invalid_transition_responder)
{
sixp_pkt_t pkt;
linkaddr_t peer_addr;
sixp_trans_t *trans;
uint8_t req_body[8];
UNIT_TEST_BEGIN();
test_setup();
/* allocate a transaction for the add request */
memset(&pkt, 0, sizeof(pkt));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(req_body, 0, sizeof(req_body));
pkt.sfid = TEST_SF_SFID;
pkt.type = SIXP_PKT_TYPE_REQUEST;
pkt.code = (sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_ADD;
pkt.seqno = 10;
pkt.body = req_body;
pkt.body_len = 4; /* Metadata, CellOptions, and NumCells CellList */
/* 3-step */
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
/* from INIT */
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_UNAVAILABLE) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_INIT) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_SENT) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_RECEIVED) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_SENT) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_RECEIVED) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
/* from REQUEST_RECEIVED */
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_RECEIVED) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_REQUEST_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_UNAVAILABLE) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_REQUEST_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_INIT) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_REQUEST_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_REQUEST_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_REQUEST_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_REQUEST_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_REQUEST_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_REQUEST_RECEIVED);
/* from RESPONSE_SENT */
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_SENT) == 0);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_RESPONSE_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_UNAVAILABLE) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_RESPONSE_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_INIT) == -1);
UNIT_TEST_ASSERT(sixp_trans_get_state(trans) ==
SIXP_TRANS_STATE_RESPONSE_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_SENT);
/* from CONFIRMATION_RECEIVED */
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_RECEIVED) == 0);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_UNAVAILABLE) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_INIT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_SENT) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_RECEIVED);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_CONFIRMATION_RECEIVED);
pkt.body_len = 8; /* Metadata, CellOptions, and NumCells CellList */
peer_addr.u8[0] = 1;
/* 2-step */
UNIT_TEST_ASSERT((trans = sixp_trans_alloc(&pkt, &peer_addr)) != NULL);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_INIT);
UNIT_TEST_ASSERT(sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_RECEIVED) == 0);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_REQUEST_RECEIVED);
UNIT_TEST_ASSERT(sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_SENT) == 0);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_CONFIRMATION_RECEIVED) == -1);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_RESPONSE_SENT);
UNIT_TEST_ASSERT(
sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_TERMINATING) == 0);
UNIT_TEST_ASSERT(
sixp_trans_get_state(trans) == SIXP_TRANS_STATE_TERMINATING);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_next_seqno_increment_on_request_sent,
"test next_seqno is incremented on request_sent");
UNIT_TEST(test_next_seqno_increment_on_request_sent)
{
linkaddr_t peer_addr;
sixp_nbr_t *nbr;
sixp_trans_t *trans;
UNIT_TEST_BEGIN();
test_setup();
peer_addr.u8[0] = 1;
UNIT_TEST_ASSERT((nbr = sixp_nbr_alloc(&peer_addr)) != NULL);
UNIT_TEST_ASSERT(sixp_nbr_set_next_seqno(nbr, 10) == 0);
UNIT_TEST_ASSERT(sixp_nbr_get_next_seqno(nbr) == 10);
UNIT_TEST_ASSERT(sixp_output(SIXP_PKT_TYPE_REQUEST,
(sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_ADD,
TEST_SF_SFID, NULL, 0, &peer_addr,
NULL, NULL, 0) == 0);
/* next_seqno must not be changed by sixp_output() */
UNIT_TEST_ASSERT((trans = sixp_trans_find(&peer_addr)) != NULL);
UNIT_TEST_ASSERT(sixp_nbr_get_next_seqno(nbr) == 10);
UNIT_TEST_ASSERT(sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_REQUEST_SENT)
== 0);
UNIT_TEST_ASSERT(sixp_nbr_get_next_seqno(nbr) == 11);
UNIT_TEST_END();
}
UNIT_TEST_REGISTER(test_next_seqno_increment_on_response_sent,
"test next_seqno is incremented on response_sent");
UNIT_TEST(test_next_seqno_increment_on_response_sent)
{
linkaddr_t peer_addr;
sixp_nbr_t *nbr;
sixp_trans_t *trans;
uint32_t body;
UNIT_TEST_BEGIN();
test_setup();
peer_addr.u8[0] = 1;
UNIT_TEST_ASSERT((nbr = sixp_nbr_alloc(&peer_addr)) != NULL);
UNIT_TEST_ASSERT(sixp_nbr_set_next_seqno(nbr, 100) == 0);
UNIT_TEST_ASSERT(sixp_nbr_get_next_seqno(nbr) == 100);
UNIT_TEST_ASSERT(sixp_pkt_create(SIXP_PKT_TYPE_REQUEST,
(sixp_pkt_code_t)(uint8_t)SIXP_PKT_CMD_ADD,
TEST_SF_SFID, 10,
(const uint8_t *)&body, sizeof(body), NULL)
== 0);
UNIT_TEST_ASSERT((trans = sixp_trans_find(&peer_addr)) == NULL);
sixp_input(packetbuf_hdrptr(), packetbuf_totlen(), &peer_addr);
UNIT_TEST_ASSERT((trans = sixp_trans_find(&peer_addr)) != NULL);
/* next_seqno must not be changed yet */
UNIT_TEST_ASSERT(sixp_nbr_get_next_seqno(nbr) == 100);
UNIT_TEST_ASSERT(sixp_output(SIXP_PKT_TYPE_RESPONSE,
(sixp_pkt_code_t)(uint8_t)SIXP_PKT_RC_SUCCESS,
TEST_SF_SFID, NULL, 0, &peer_addr,
NULL, NULL, 0) == 0);
UNIT_TEST_ASSERT(sixp_trans_transit_state(trans,
SIXP_TRANS_STATE_RESPONSE_SENT)
== 0);
/*
* next_seqno is overridden by the seqno of the request and
* incremented by 1
*/
UNIT_TEST_ASSERT(sixp_nbr_get_next_seqno(nbr) == 11);
UNIT_TEST_END();
}
PROCESS_THREAD(test_process, ev, data)
{
static struct etimer et;
PROCESS_BEGIN();
/* wait until the sixtop module gets ready */
etimer_set(&et, CLOCK_SECOND);
tschmac_driver.init();
tschmac_driver.on();
tsch_set_coordinator(1);
while(tsch_is_associated == 0) {
PROCESS_YIELD_UNTIL(etimer_expired(&et));
etimer_reset(&et);
}
printf("Run unit-test\n");
printf("---\n");
/* sixp_trans_alloc() */
UNIT_TEST_RUN(test_alloc_2_step_trans);
UNIT_TEST_RUN(test_alloc_3_step_trans);
UNIT_TEST_RUN(test_alloc_duplicate_peer);
UNIT_TEST_RUN(test_alloc_lack_of_memory);
UNIT_TEST_RUN(test_alloc_null_pkt);
UNIT_TEST_RUN(test_alloc_null_peer_addr);
/* sixp_trans_find() */
UNIT_TEST_RUN(test_find);
/* sixp_set_callback() & sixp_invoke_callback() */
UNIT_TEST_RUN(test_callback);
/* sixp_trans_transit_state() and sixp_trans_get_state() */
UNIT_TEST_RUN(test_state_transition_2_step_initiator);
UNIT_TEST_RUN(test_state_transition_2_step_responder);
UNIT_TEST_RUN(test_state_transition_3_step_initiator);
UNIT_TEST_RUN(test_state_transition_3_step_responder);
UNIT_TEST_RUN(test_state_transition_invalid_transition_initiator);
UNIT_TEST_RUN(test_state_transition_invalid_transition_responder);
/* seqno management*/
UNIT_TEST_RUN(test_next_seqno_increment_on_request_sent);
UNIT_TEST_RUN(test_next_seqno_increment_on_response_sent);
printf("=check-me= DONE\n");
PROCESS_END();
}
Reference in New Issue View Git Blame Copy Permalink