void can_protocol_send(void)
{
canProtocolState_t state;
canProtocolEvent_t event = CAN_PROTOCOL_DUMMY_EVENT;
state = can_protocol_state_process(event);
BYTES_EQUAL(CAN_PROTOCOL_IDLE_STATE, state);
can_protocol_setSend(&command);
event = CAN_PROTOCOL_SEND_EVENT;
state = can_protocol_state_process(event);
BYTES_EQUAL(CAN_PROTOCOL_SENDING_COMMAND_STATE, state);
event = CAN_PROTOCOL_DUMMY_EVENT;
state = can_protocol_state_process(event);
state = can_protocol_state_process(event);
BYTES_EQUAL(CAN_PROTOCOL_SENT_COMMAND_STATE, state);
rxMsg.StdId = 0x0509;
rxMsg.IDE = CAN_ID_STD;
rxMsg.DLC = 8;
rxMsg.Data[0] = 0x89;
/* data as below */
rxMsg.Data[1] = 0x00;
rxMsg.Data[2] = 0;
rxMsg.Data[3] = 3;
rxMsg.Data[4] = 0;
rxMsg.Data[5] = 7;
rxMsg.Data[6] = (uint8_t)((can_protocol_getRdrID() & 0xFF00) >> 8);
rxMsg.Data[7] = (uint8_t)(can_protocol_getRdrID() & 0x00FF);
can_command_setEvent(CAN_COMMAND_PACKET_RECEIVED_EVENT);
state = can_protocol_state_process(event);
rxMsg.StdId = 0x0509;
rxMsg.IDE = CAN_ID_STD;
rxMsg.DLC = 5;
rxMsg.Data[0] = 0x89;
/* data as below */
rxMsg.Data[1] = 0x81;
rxMsg.Data[2] = 0x0A;
rxMsg.Data[3] = 0x0B;
rxMsg.Data[4] = 0x0C;
can_command_setEvent(CAN_COMMAND_PACKET_RECEIVED_EVENT);
state = can_protocol_state_process(event);
BYTES_EQUAL(CAN_PROTOCOL_IDLE_STATE, state);
}
TEST(BitManip, ClearBitNumber_MostSignificantBit)
{
eightBit = 0xff;
CLEAR_BIT_NUMBER(eightBit, 7);
BYTES_EQUAL(0x7f, eightBit);
}
static int functionThatReturnsAValue()
{
CHECK(0 == 0);
CHECK_TEXT(0 == 0, "Shouldn't fail");
CHECK_TRUE(0 == 0);
CHECK_TRUE_TEXT(0 == 0, "Shouldn't fail");
CHECK_FALSE(0 != 0);
CHECK_FALSE_TEXT(0 != 0, "Shouldn't fail");
LONGS_EQUAL(1,1);
LONGS_EQUAL_TEXT(1, 1, "Shouldn't fail");
BYTES_EQUAL(0xab,0xab);
BYTES_EQUAL_TEXT(0xab, 0xab, "Shouldn't fail");
CHECK_EQUAL(100,100);
CHECK_EQUAL_TEXT(100, 100, "Shouldn't fail");
STRCMP_EQUAL("THIS", "THIS");
STRCMP_EQUAL_TEXT("THIS", "THIS", "Shouldn't fail");
DOUBLES_EQUAL(1.0, 1.0, .01);
DOUBLES_EQUAL_TEXT(1.0, 1.0, .01, "Shouldn't fail");
POINTERS_EQUAL(0, 0);
POINTERS_EQUAL_TEXT(0, 0, "Shouldn't fail");
MEMCMP_EQUAL("THIS", "THIS", 5);
MEMCMP_EQUAL_TEXT("THIS", "THIS", 5, "Shouldn't fail");
BITS_EQUAL(0x01, (unsigned char )0x01, 0xFF);
BITS_EQUAL(0x0001, (unsigned short )0x0001, 0xFFFF);
BITS_EQUAL(0x00000001, (unsigned long )0x00000001, 0xFFFFFFFF);
BITS_EQUAL_TEXT(0x01, (unsigned char )0x01, 0xFF, "Shouldn't fail");
return 0;
}
void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){
int i;
for (i=0; i<size; i++){
if (expected[i] != actual[i]) {
printf("offset %u wrong\n", i);
printf("expected: "); printf_hexdump(expected, size);
printf("actual: "); printf_hexdump(actual, size);
}
BYTES_EQUAL(expected[i], actual[i]);
}
}
TEST(BitManip, SetBitmaskShiftValue_ClearFewerBitsThanBitmask)
{
eightBit = 0xc3;
BYTES_EQUAL(0xff, SHIFT_AND_SET_BITMASK_TO(eightBit, 0xff, 0x3c));
}
TEST(BitManip, SetBitmaskShiftValue_ClearMostSignificantBit)
{
eightBit = 0xff;
BYTES_EQUAL(0x7f, SHIFT_AND_SET_BITMASK_TO(eightBit, 0x00, 0x80));
}
TEST(BitManip, SetBitmaskShiftValue_ClearWithinButNotOutsideBitmask)
{
eightBit = 0xff;
BYTES_EQUAL(0xc3, SHIFT_AND_SET_BITMASK_TO(eightBit, 0x00, 0x3c));
}
TEST(BitManip, RightMostBit_NoBitsSet)
{
BYTES_EQUAL(0, RIGHTMOST_BIT_NUMBER(0x00));
}
TEST(BitManip, SetBitmaskShiftValue_ClearEntireBitmask)
{
eightBit = 0xff;
BYTES_EQUAL(0x00, SHIFT_AND_SET_BITMASK_TO(eightBit, 0x00, 0xff));
}
TEST(BitManip, ClearBits_MostSignificantBit)
{
eightBit = 0xff;
CLEAR_BITS(eightBit, (1<<7));
BYTES_EQUAL(0x7f, eightBit);
}
TEST(String, BaseN)
{
char str[1024];
const char *str_abc = "abc";
const char *str_abc_base64 = "YWJj";
const char *str_base64[][2] =
{ { "", "" },
{ "A", "QQ==" },
{ "B", "Qg==" },
{ "C", "Qw==" },
{ "D", "RA==" },
{ "abc", "YWJj" },
{ "This is a test.", "VGhpcyBpcyBhIHRlc3Qu" },
{ "This is a test..", "VGhpcyBpcyBhIHRlc3QuLg==" },
{ "This is a test...", "VGhpcyBpcyBhIHRlc3QuLi4=" },
{ "This is a test....", "VGhpcyBpcyBhIHRlc3QuLi4u" },
{ "This is a long long long sentence here...",
"VGhpcyBpcyBhIGxvbmcgbG9uZyBsb25nIHNlbnRlbmNlIGhlcmUuLi4=" },
{ "Another example for base64",
"QW5vdGhlciBleGFtcGxlIGZvciBiYXNlNjQ=" },
{ "Another example for base64.",
"QW5vdGhlciBleGFtcGxlIGZvciBiYXNlNjQu" },
{ "Another example for base64..",
"QW5vdGhlciBleGFtcGxlIGZvciBiYXNlNjQuLg==" },
{ "Another example for base64...",
"QW5vdGhlciBleGFtcGxlIGZvciBiYXNlNjQuLi4=" },
{ NULL, NULL } };
int i, length;
/* string_encode_base16 */
string_encode_base16 (NULL, 0, NULL);
string_encode_base16 (NULL, 0, str);
string_encode_base16 ("", 0, NULL);
str[0] = 0xAA;
string_encode_base16 ("", -1, str);
BYTES_EQUAL(0x0, str[0]);
str[0] = 0xAA;
string_encode_base16 ("", 0, str);
BYTES_EQUAL(0x0, str[0]);
string_encode_base16 ("abc", 3, str);
STRCMP_EQUAL("616263", str);
/* string_decode_base16 */
LONGS_EQUAL(0, string_decode_base16 (NULL, NULL));
LONGS_EQUAL(0, string_decode_base16 (NULL, str));
LONGS_EQUAL(0, string_decode_base16 ("", NULL));
LONGS_EQUAL(0, string_decode_base16 ("", str));
LONGS_EQUAL(3, string_decode_base16 ("616263", str));
STRCMP_EQUAL("abc", str);
/* string_encode_base64 */
string_encode_base64 (NULL, 0, NULL);
string_encode_base64 (NULL, 0, str);
string_encode_base64 ("", 0, NULL);
str[0] = 0xAA;
string_encode_base64 ("", -1, str);
BYTES_EQUAL(0x0, str[0]);
str[0] = 0xAA;
string_encode_base64 ("", 0, str);
BYTES_EQUAL(0x0, str[0]);
for (i = 0; str_base64[i][0]; i++)
{
string_encode_base64 (str_base64[i][0], strlen (str_base64[i][0]),
str);
STRCMP_EQUAL(str_base64[i][1], str);
}
/* string_decode_base64 */
LONGS_EQUAL(0, string_decode_base64 (NULL, NULL));
LONGS_EQUAL(0, string_decode_base64 (NULL, str));
LONGS_EQUAL(0, string_decode_base64 ("", NULL));
LONGS_EQUAL(0, string_decode_base64 ("", str));
for (i = 0; str_base64[i][0]; i++)
{
length = string_decode_base64 (str_base64[i][1], str);
STRCMP_EQUAL(str_base64[i][0], str);
LONGS_EQUAL(strlen (str_base64[i][0]), length);
}
}
TEST(BitManip, SetBitmaskShiftValue_etMostSignificantBit)
{
BYTES_EQUAL(0x80, SHIFT_AND_SET_BITMASK_TO(eightBit, 0x01, 0x80));
}
TEST(BitManip, SetBitmaskShiftValue_SetBitsWithinButNotOutsideBitmask)
{
BYTES_EQUAL(0x14, SHIFT_AND_SET_BITMASK_TO(eightBit, 0xff, 0x14));
}
TEST(BitManip, SetBitmaskShiftValue_NoNewValueSetsNothing)
{
BYTES_EQUAL(0x00, SHIFT_AND_SET_BITMASK_TO(eightBit, 0x00, 0xff));
}
TEST(BitManip, SetBitmaskShiftValue_SetEntireBitmask)
{
BYTES_EQUAL(0xff, SHIFT_AND_SET_BITMASK_TO(eightBit, 0xff, 0xff));
}
TEST(BitManip, RightMostBit_SeveralBitsSet)
{
BYTES_EQUAL(3, RIGHTMOST_BIT_NUMBER(0x18));
}
TEST(BitManip, RightMostBit_MostSignificantBitSet)
{
BYTES_EQUAL(7, RIGHTMOST_BIT_NUMBER(0x80));
}
TEST(BitManip, RightMostBit_LeastSignificantBitSet)
{
BYTES_EQUAL(0, RIGHTMOST_BIT_NUMBER(0x01));
}
TEST(BitManip, SetBitNumber_LeastSignificantBit)
{
SET_BIT_NUMBER(eightBit, 0);
BYTES_EQUAL(0x01, eightBit);
}
void given(int charsWritten)
{
LONGS_EQUAL(strlen(expected), charsWritten);
STRCMP_EQUAL(expected, output);
BYTES_EQUAL(0xaa, output[strlen(expected) + 1]);
}
TEST(BitManip, SetBitNumber_MostSignificantBit)
{
SET_BIT_NUMBER(eightBit, 7);
BYTES_EQUAL(0x80, eightBit);
}
TEST(Utf8, Convert)
{
char result[5];
/* get UTF-8 char as integer */
BYTES_EQUAL(0, utf8_char_int (NULL));
BYTES_EQUAL(0, utf8_char_int (""));
BYTES_EQUAL(65, utf8_char_int ("ABC"));
BYTES_EQUAL(235, utf8_char_int ("ë"));
BYTES_EQUAL(0x20ac, utf8_char_int ("€"));
BYTES_EQUAL(0x24b62, utf8_char_int (han_char));
BYTES_EQUAL(0x0, utf8_char_int ("\xc0\x80")); /* invalid */
BYTES_EQUAL(0x7f, utf8_char_int ("\xc1\xbf")); /* invalid */
BYTES_EQUAL(0x80, utf8_char_int ("\xc2\x80"));
BYTES_EQUAL(0x7ff, utf8_char_int ("\xdf\xbf"));
BYTES_EQUAL(0x0, utf8_char_int ("\xe0\x80\x80")); /* invalid */
BYTES_EQUAL(0x7ff, utf8_char_int ("\xe0\x9f\xbf")); /* invalid */
LONGS_EQUAL(0xd800, utf8_char_int ("\xed\xa0\x80")); /* invalid */
LONGS_EQUAL(0xdfff, utf8_char_int ("\xed\xbf\xbf")); /* invalid */
BYTES_EQUAL(0x800, utf8_char_int ("\xe0\xa0\x80"));
BYTES_EQUAL(0xd7ff, utf8_char_int ("\xed\x9f\xbf"));
BYTES_EQUAL(0xe000, utf8_char_int ("\xe7\x80\x80"));
BYTES_EQUAL(0xffff, utf8_char_int ("\xef\xbf\xbf"));
BYTES_EQUAL(0x0, utf8_char_int ("\xf0\x80\x80\x80")); /* invalid */
BYTES_EQUAL(0xffff, utf8_char_int ("\xf0\x8f\xbf\xbf")); /* invalid */
BYTES_EQUAL(0x10000, utf8_char_int ("\xf0\x90\x80\x80"));
BYTES_EQUAL(0x1fffff, utf8_char_int ("\xf7\xbf\xbf\xbf"));
/* convert unicode char to a string */
utf8_int_string (0, NULL);
utf8_int_string (0, result);
STRCMP_EQUAL("", result);
utf8_int_string (235, result);
STRCMP_EQUAL("ë", result);
utf8_int_string (0x20ac, result);
STRCMP_EQUAL("€", result);
utf8_int_string (0x24b62, result);
STRCMP_EQUAL(han_char, result);
/* get wide char */
BYTES_EQUAL(WEOF, utf8_wide_char (NULL));
BYTES_EQUAL(WEOF, utf8_wide_char (""));
BYTES_EQUAL(65, utf8_wide_char ("A"));
BYTES_EQUAL(0xc3ab, utf8_wide_char ("ë"));
BYTES_EQUAL(0xe282ac, utf8_wide_char ("€"));
BYTES_EQUAL(0xf0a4ada2, utf8_wide_char (han_char));
}
void can_protocol_receive(void)
{
canProtocolState_t state;
canProtocolEvent_t event = CAN_PROTOCOL_DUMMY_EVENT;
uint8_t data[4];
rxMsg.StdId = 0x0509;
rxMsg.IDE = CAN_ID_STD;
rxMsg.DLC = 8;
rxMsg.Data[0] = 0x89;
/* data as below */
rxMsg.Data[1] = 0x00;
rxMsg.Data[2] = 0;
rxMsg.Data[3] = 1;
rxMsg.Data[4] = 0;
rxMsg.Data[5] = 13;
rxMsg.Data[6] = (uint8_t)((can_protocol_getCtrlID() & 0xFF00) >> 8);
rxMsg.Data[7] = (uint8_t)(can_protocol_getCtrlID() & 0x00FF);
can_command_setEvent(CAN_COMMAND_PACKET_RECEIVED_EVENT);
state = can_protocol_state_process(event);
BYTES_EQUAL(CAN_PROTOCOL_IDLE_STATE, state);
rxMsg.StdId = 0x0509;
rxMsg.IDE = CAN_ID_STD;
rxMsg.DLC = 8;
rxMsg.Data[0] = 0x89;
/* data as below */
rxMsg.Data[1] = 0x41;
rxMsg.Data[2] = 6;
rxMsg.Data[3] = 7;
rxMsg.Data[4] = 8;
rxMsg.Data[5] = 9;
rxMsg.Data[6] = 10;
rxMsg.Data[7] = 11;
can_command_setEvent(CAN_COMMAND_PACKET_RECEIVED_EVENT);
state = can_protocol_state_process(event);
BYTES_EQUAL(CAN_PROTOCOL_IDLE_STATE, state);
rxMsg.StdId = 0x0509;
rxMsg.IDE = CAN_ID_STD;
rxMsg.DLC = 5;
rxMsg.Data[0] = 0x89;
/* data as below */
rxMsg.Data[1] = 0x82;
rxMsg.Data[2] = 12;
rxMsg.Data[3] = 13;
rxMsg.Data[4] = 14;
rxMsg.Data[5] = 0;
rxMsg.Data[6] = 0;
rxMsg.Data[7] = 0;
can_command_setEvent(CAN_COMMAND_PACKET_RECEIVED_EVENT);
state = can_protocol_state_process(event);
BYTES_EQUAL(CAN_PROTOCOL_RCV_COMMAND_STATE, state);
data[0] = 1;
data[1] = 2;
data[2] = 3;
data[3] = 5;
can_protocol_setReply(0x03, 8, data);
event = CAN_PROTOCOL_REPLY_EVENT;
state = can_protocol_state_process(event);
event = CAN_PROTOCOL_DUMMY_EVENT;
state = can_protocol_state_process(event);
BYTES_EQUAL(CAN_PROTOCOL_REPLYING_COMMAND_STATE, state);
LONGS_EQUAL(0x0509, txMsg.StdId);
BYTES_EQUAL(CAN_ID_STD, txMsg.IDE);
BYTES_EQUAL(8, txMsg.DLC);
BYTES_EQUAL(0x89, txMsg.Data[0]);
BYTES_EQUAL(0x00, txMsg.Data[1]);
BYTES_EQUAL(0x00, txMsg.Data[2]); // command
BYTES_EQUAL(0x03, txMsg.Data[3]); // command_type
BYTES_EQUAL(0x00, txMsg.Data[4]); //
BYTES_EQUAL(0x08, txMsg.Data[5]); // data_length
BYTES_EQUAL(0x00, txMsg.Data[6]); //
BYTES_EQUAL((uint8_t)can_protocol_getCtrlID(), txMsg.Data[7]); // message_id
state = can_protocol_state_process(event);
BYTES_EQUAL(CAN_PROTOCOL_IDLE_STATE, state);
LONGS_EQUAL(0x0509, txMsg.StdId);
BYTES_EQUAL(CAN_ID_STD, txMsg.IDE);
BYTES_EQUAL(6, txMsg.DLC);
BYTES_EQUAL(0x89, txMsg.Data[0]);
BYTES_EQUAL(0x81, txMsg.Data[1]);
BYTES_EQUAL(0x01, txMsg.Data[2]); // command
BYTES_EQUAL(0x02, txMsg.Data[3]); // command_type
BYTES_EQUAL(0x03, txMsg.Data[4]); //
BYTES_EQUAL(0x05, txMsg.Data[5]); // data_length
}
TEST(BitManip, SetBitmaskTo_BitsToSetLimitsValueActuallySet)
{
SET_BITMASK_TO(eightBit, 0x3c, 0x18);
BYTES_EQUAL(0x18, eightBit);
}
TEST(BitManip, SetBitmaskShiftValue_SetFewerBitsThanInBitmask)
{
BYTES_EQUAL(0x42, SHIFT_AND_SET_BITMASK_TO(eightBit, 0x42, 0xff));
}
TEST(BitManip, SetBitmaskTo_WillClearBits)
{
eightBit = 0xff;
SET_BITMASK_TO(eightBit, 0x00, 0x18);
BYTES_EQUAL(eightBit, 0xe7);
}
void CHECK_EQUAL_ARRAY(const uint8_t * expected, uint8_t * actual, int size){
for (int i=0; i<size; i++){
BYTES_EQUAL(expected[i], actual[i]);
}
}
TEST(BitManip, SetBitmaskShiftValue_AllNewValueBitSetFullBitmaskClearsNothing)
{
eightBit = 0xff;
BYTES_EQUAL(0xff, SHIFT_AND_SET_BITMASK_TO(eightBit, 0xff, 0xff));
}
TEST(SimpleString, at)
{
SimpleString str("Hello World");
BYTES_EQUAL('H', str.at(0));
}
TEST(BitManip, SetBitmaskShiftValue_NoBitmaskClearsNothing)
{
eightBit = 0xff;
BYTES_EQUAL(0xff, SHIFT_AND_SET_BITMASK_TO(eightBit, 0xff, 0x00));
}
