src.dualinventive.com/fw/dncm/libdi/tests/can_msg_recv.cpp

/**
 * @file tests/can_msg_recv.cpp
 * @brief CAN message unit test
 * @date Sep 30, 2015
 * @author jjacobs
 * @copyright 2015 Dual Inventive Technology Centre B.V.
 *
 * CAN Message unit test
 */
#include "tests/can.h"
#include <gtest/gtest.h>
#include <di/can.h>

TEST_CAN_INIT_DECL

/**
 * Check if the initial can_msg_recv state is correct
 */
TEST(can_msg_recv, init) {
	ASSERT_EQ(0U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.net_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.log_cnt);
}

/**
 * Test message receive counter reset
 */
TEST(can_msg_recv, reset) {
	can_ctx.msg.recv.any_cnt = 4;
	can_ctx.msg.recv.raw_cnt = 1;
	can_ctx.msg.recv.rpc_cnt = 1;
	can_ctx.msg.recv.net_cnt = 1;
	can_ctx.msg.recv.log_cnt = 1;

	di_can_msg_recv_reset(&can_ctx);

	ASSERT_EQ(0U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.net_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.log_cnt);
}

/**
 * Test message receive counter increment
 */
TEST(can_msg_recv, incr) {
	/* One RAW message */
	di_can_msg_recv_incr(&can_ctx, DI_CAN_MSGTYPE_RAW);
	ASSERT_EQ(1U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.net_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.log_cnt);

	/* One RPC message */
	di_can_msg_recv_incr(&can_ctx, DI_CAN_MSGTYPE_RPC);
	ASSERT_EQ(2U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.net_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.log_cnt);

	/* One NET message */
	di_can_msg_recv_incr(&can_ctx, DI_CAN_MSGTYPE_NET);
	ASSERT_EQ(3U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.net_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.log_cnt);

	/* One LOG message */
	di_can_msg_recv_incr(&can_ctx, DI_CAN_MSGTYPE_LOG);
	ASSERT_EQ(4U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.net_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.log_cnt);

	/* One ANY message this is invalid  */
	di_can_msg_recv_incr(&can_ctx, DI_CAN_MSGTYPE_ANY);
	ASSERT_EQ(4U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.net_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.log_cnt);

	di_can_msg_recv_reset(&can_ctx);
}

/**
 * Test message receive counter increment overflow protection
 */
TEST(can_msg_recv, incr_overflow) {
	can_ctx.msg.recv.any_cnt = SIZE_MAX;
	can_ctx.msg.recv.raw_cnt = SIZE_MAX;
	can_ctx.msg.recv.rpc_cnt = 0;
	can_ctx.msg.recv.net_cnt = 0;

	di_can_msg_recv_incr(&can_ctx, DI_CAN_MSGTYPE_RAW);

	ASSERT_EQ(SIZE_MAX, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(SIZE_MAX, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.net_cnt);

	di_can_msg_recv_incr(&can_ctx, DI_CAN_MSGTYPE_RPC);
	ASSERT_EQ(SIZE_MAX, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(SIZE_MAX, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.net_cnt);

	di_can_msg_recv_reset(&can_ctx);
}

/**
 * Test message receive counter decrement
 */
TEST(can_msg_recv, decr) {
	can_ctx.msg.recv.any_cnt = 3;
	can_ctx.msg.recv.raw_cnt = 1;
	can_ctx.msg.recv.rpc_cnt = 1;
	can_ctx.msg.recv.net_cnt = 1;

	/* One ANY message, this is invalid */
	di_can_msg_recv_decr(&can_ctx, DI_CAN_MSGTYPE_ANY);
	ASSERT_EQ(3U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.net_cnt);

	/* One RAW message */
	di_can_msg_recv_decr(&can_ctx, DI_CAN_MSGTYPE_RAW);
	ASSERT_EQ(2U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.net_cnt);

	/* One RPC message */
	di_can_msg_recv_decr(&can_ctx, DI_CAN_MSGTYPE_RPC);
	ASSERT_EQ(1U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.net_cnt);

	/* One NET message */
	di_can_msg_recv_decr(&can_ctx, DI_CAN_MSGTYPE_NET);
	ASSERT_EQ(0U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.net_cnt);

	di_can_msg_recv_reset(&can_ctx);
}

/**
 * Test message receive counter decrement underflow protection
 */
TEST(can_msg_recv, decr_underflow) {
	can_ctx.msg.recv.any_cnt = 0;
	can_ctx.msg.recv.raw_cnt = 0;
	can_ctx.msg.recv.rpc_cnt = 0;
	can_ctx.msg.recv.net_cnt = 0;
	can_ctx.msg.recv.log_cnt = 0;

	di_can_msg_recv_decr(&can_ctx, DI_CAN_MSGTYPE_RAW);
	ASSERT_EQ(0U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.net_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.log_cnt);

	di_can_msg_recv_decr(&can_ctx, DI_CAN_MSGTYPE_RPC);
	ASSERT_EQ(0U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.net_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.log_cnt);

	di_can_msg_recv_decr(&can_ctx, DI_CAN_MSGTYPE_NET);
	ASSERT_EQ(0U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.net_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.log_cnt);

	di_can_msg_recv_decr(&can_ctx, DI_CAN_MSGTYPE_LOG);
	ASSERT_EQ(0U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.net_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.log_cnt);

	can_ctx.msg.recv.any_cnt = 1;
	can_ctx.msg.recv.raw_cnt = 1;
	can_ctx.msg.recv.rpc_cnt = 0;
	can_ctx.msg.recv.net_cnt = 0;
	can_ctx.msg.recv.log_cnt = 0;

	di_can_msg_recv_decr(&can_ctx, DI_CAN_MSGTYPE_RPC);
	ASSERT_EQ(1U, can_ctx.msg.recv.any_cnt);
	ASSERT_EQ(1U, can_ctx.msg.recv.raw_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.rpc_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.net_cnt);
	ASSERT_EQ(0U, can_ctx.msg.recv.log_cnt);

	di_can_msg_recv_reset(&can_ctx);
}

/**
 * Test message receive ready flag
 */
TEST(can_msg_recv, is_ready) {
	di_can_msg_recv_reset(&can_ctx);

	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_ANY));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RAW));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RPC));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_NET));

	/* RAW */
	di_can_msg_recv_incr(&can_ctx, DI_CAN_MSGTYPE_RAW);

	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_ANY));
	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RAW));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RPC));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_NET));

	di_can_msg_recv_reset(&can_ctx);

	/* RPC */
	di_can_msg_recv_incr(&can_ctx, DI_CAN_MSGTYPE_RPC);

	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_ANY));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RAW));
	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RPC));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_NET));

	di_can_msg_recv_reset(&can_ctx);

	/* NET */
	di_can_msg_recv_incr(&can_ctx, DI_CAN_MSGTYPE_NET);

	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_ANY));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RAW));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RPC));
	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_NET));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_LOG));

	di_can_msg_recv_reset(&can_ctx);

	/* LOG */
	di_can_msg_recv_incr(&can_ctx, DI_CAN_MSGTYPE_LOG);

	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_ANY));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RAW));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RPC));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_NET));
	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_LOG));

	di_can_msg_recv_reset(&can_ctx);

	/* Combined RAW + RPC + NET */
	di_can_msg_recv_incr(&can_ctx, DI_CAN_MSGTYPE_RAW);
	di_can_msg_recv_incr(&can_ctx, DI_CAN_MSGTYPE_RPC);
	di_can_msg_recv_incr(&can_ctx, DI_CAN_MSGTYPE_NET);

	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_ANY));
	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RAW));
	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RPC));
	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_NET));

	/* Decr NET */
	di_can_msg_recv_decr(&can_ctx, DI_CAN_MSGTYPE_NET);
	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_ANY));
	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RAW));
	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RPC));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_NET));

	/* Decr RPC */
	di_can_msg_recv_decr(&can_ctx, DI_CAN_MSGTYPE_RPC);
	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_ANY));
	ASSERT_TRUE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RAW));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RPC));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_NET));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_LOG));

	/* Decr RAW */
	di_can_msg_recv_decr(&can_ctx, DI_CAN_MSGTYPE_RAW);
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_ANY));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RAW));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_RPC));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_NET));
	ASSERT_FALSE(di_can_msg_recv_is_ready(&can_ctx, DI_CAN_MSGTYPE_LOG));

	di_can_msg_recv_reset(&can_ctx);
}

/**
 * Test
 */
TEST(can_msg_recv, test_blocking_api) {
	di_can_msg_recv_reset(&can_ctx);

	di_can_msg_recv_set_timeout(&can_ctx, 1);
	di_can_msg_recv_set_blocking(&can_ctx, true);

	/* Make sure all semaphores are taken */
	di_can_msg_recv_wait(&can_ctx, DI_CAN_MSGTYPE_ANY);
	di_can_msg_recv_wait(&can_ctx, DI_CAN_MSGTYPE_RAW);
	di_can_msg_recv_wait(&can_ctx, DI_CAN_MSGTYPE_RPC);
	di_can_msg_recv_wait(&can_ctx, DI_CAN_MSGTYPE_NET);
	di_can_msg_recv_wait(&can_ctx, DI_CAN_MSGTYPE_LOG);

	ASSERT_EQ(DNE_TIMEOUT, di_can_msg_recv_wait(&can_ctx, DI_CAN_MSGTYPE_ANY));
	ASSERT_EQ(DNE_TIMEOUT, di_can_msg_recv_wait(&can_ctx, DI_CAN_MSGTYPE_RAW));
	ASSERT_EQ(DNE_TIMEOUT, di_can_msg_recv_wait(&can_ctx, DI_CAN_MSGTYPE_RPC));
	ASSERT_EQ(DNE_TIMEOUT, di_can_msg_recv_wait(&can_ctx, DI_CAN_MSGTYPE_NET));
	ASSERT_EQ(DNE_TIMEOUT, di_can_msg_recv_wait(&can_ctx, DI_CAN_MSGTYPE_LOG));

	di_can_msg_recv_set_timeout(&can_ctx, 0);
	di_can_msg_recv_set_blocking(&can_ctx, false);
}