1206 lines
40 KiB
C
1206 lines
40 KiB
C
/*
|
|
* 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();
|
|
}
|