453 lines
17 KiB
C
453 lines
17 KiB
C
#include "Unity/src/unity.h"
|
||
#include "message_parser.h" // Stellt sicher, dass deine Header-Datei message_parser.h korrekt ist
|
||
#include <stdint.h>
|
||
#include <string.h> // Für memcpy
|
||
|
||
// Globale Variablen für Callback-Überprüfung
|
||
static uint8_t received_msgid = 0xFF;
|
||
static uint8_t
|
||
received_payload[MAX_TOTAL_CONTENT_LENGTH]; // Muss groß genug sein
|
||
static size_t received_payload_len = 0;
|
||
static enum ParserError received_error = NoError;
|
||
static bool message_received_flag = false;
|
||
static bool message_fail_flag = false;
|
||
|
||
// Mock-Implementierungen für die Callbacks
|
||
void mock_on_message_received(uint8_t msgid, const uint8_t *payload,
|
||
size_t payload_len) {
|
||
received_msgid = msgid;
|
||
received_payload_len = payload_len;
|
||
// Sicherstellen, dass der Puffer nicht überläuft
|
||
memcpy(received_payload, payload,
|
||
(payload_len < MAX_TOTAL_CONTENT_LENGTH) ? payload_len
|
||
: MAX_TOTAL_CONTENT_LENGTH);
|
||
message_received_flag = true;
|
||
}
|
||
|
||
void mock_on_message_fail(uint8_t msgid, const uint8_t *payload,
|
||
size_t payload_len, enum ParserError error) {
|
||
received_msgid = msgid; // Auch bei Fehlern kann die ID relevant sein
|
||
received_payload_len = payload_len;
|
||
// Auch hier, um sicherzustellen, dass wir den Zustand des Puffers beim Fehler
|
||
// sehen können
|
||
memcpy(received_payload, payload,
|
||
(payload_len < MAX_TOTAL_CONTENT_LENGTH) ? payload_len
|
||
: MAX_TOTAL_CONTENT_LENGTH);
|
||
received_error = error;
|
||
message_fail_flag = true;
|
||
}
|
||
|
||
// --- UNITY SETUP/TEARDOWN ---
|
||
void setUp(void) {
|
||
// Reset der globalen Variablen vor jedem Test
|
||
received_msgid = 0xFF;
|
||
received_payload_len = 0;
|
||
received_error = NoError;
|
||
message_received_flag = false;
|
||
message_fail_flag = false;
|
||
memset(received_payload, 0, MAX_TOTAL_CONTENT_LENGTH);
|
||
|
||
// Registrierung der Mock-Callbacks (muss vor den Tests erfolgen)
|
||
register_message_callback(mock_on_message_received);
|
||
register_message_fail_callback(mock_on_message_fail);
|
||
}
|
||
|
||
void tearDown(void) {} // optional
|
||
|
||
// --- Hilfsfunktion zur Checksummenberechnung (für Tests) ---
|
||
// Berechnet die Checksumme für MSGID + Payload + Checksummen-Byte
|
||
// Ergibt 0x00, wenn die gesamte Kette XORiert wird
|
||
uint8_t calculate_test_checksum_final(uint8_t msgid, const uint8_t *payload,
|
||
size_t payload_len,
|
||
uint8_t actual_checksum_byte) {
|
||
uint8_t cs = msgid;
|
||
for (size_t i = 0; i < payload_len; ++i) {
|
||
cs ^= payload[i];
|
||
}
|
||
cs ^=
|
||
actual_checksum_byte; // Das gesendete Checksummen-Byte wird auch XORiert
|
||
return cs;
|
||
}
|
||
// Hilfsfunktion zur Berechnung des *zu sendenden* Checksummen-Bytes
|
||
// Dies ist der Wert, der im Frame an der Checksummen-Position steht,
|
||
// sodass die finale XOR-Summe der Nutzdaten (MSGID + Payload + dieses Byte)
|
||
// 0x00 ergibt.
|
||
uint8_t calculate_payload_checksum_byte(uint8_t msgid, const uint8_t *payload,
|
||
size_t payload_len) {
|
||
uint8_t cs = msgid;
|
||
for (size_t i = 0; i < payload_len; ++i) {
|
||
cs ^= payload[i];
|
||
}
|
||
return cs; // Dies ist der Wert, der gesendet werden muss, damit die finale
|
||
// XOR-Summe 0x00 wird
|
||
}
|
||
|
||
// Test 1: Gültige Nachricht mit Payload
|
||
void test_1_valid_message_parses_correctly(void) {
|
||
struct MessageReceive mr = InitMessageReceive();
|
||
|
||
uint8_t msgid = 0x01;
|
||
uint8_t payload[] = {0x01, 0x02, 0x03};
|
||
size_t payload_len = sizeof(payload);
|
||
|
||
// Berechne das Checksummen-Byte, das gesendet werden muss
|
||
uint8_t checksum_byte_to_send =
|
||
calculate_payload_checksum_byte(msgid, payload, payload_len);
|
||
|
||
uint8_t full_message[] = {
|
||
StartByte, // 0xAA
|
||
msgid, // 0x01
|
||
0x01,
|
||
0x02,
|
||
0x03, // Payload
|
||
checksum_byte_to_send, // Das Checksummen-Byte
|
||
EndByte // 0xCC
|
||
};
|
||
|
||
for (uint8_t i = 0; i < sizeof(full_message); ++i) {
|
||
parse_byte(&mr, full_message[i]);
|
||
}
|
||
|
||
TEST_ASSERT_TRUE(message_received_flag);
|
||
TEST_ASSERT_FALSE(message_fail_flag);
|
||
TEST_ASSERT_EQUAL_UINT8(msgid, received_msgid);
|
||
TEST_ASSERT_EQUAL_UINT8(payload_len, received_payload_len); // Payload-Länge
|
||
TEST_ASSERT_EQUAL_UINT8_ARRAY(payload, received_payload, payload_len);
|
||
TEST_ASSERT_EQUAL_UINT8(WaitingForStartByte, mr.state);
|
||
TEST_ASSERT_EQUAL_UINT8(NoError, mr.error);
|
||
}
|
||
|
||
// Test 2: Ungültige Checksumme – Fehler gemeldet und Zustand zurückgesetzt
|
||
void test_2_invalid_checksum_resets_state(void) {
|
||
struct MessageReceive mr = InitMessageReceive();
|
||
|
||
uint8_t msgid = 0x02;
|
||
uint8_t payload[] = {0x10, 0x20};
|
||
size_t payload_len = sizeof(payload);
|
||
uint8_t wrong_checksum_byte = 0x01; // Absichtlich falsche Checksumme
|
||
|
||
uint8_t full_message[] = {StartByte,
|
||
msgid,
|
||
0x10,
|
||
0x20,
|
||
wrong_checksum_byte, // Falsches Checksummen-Byte
|
||
EndByte};
|
||
|
||
for (uint8_t i = 0; i < sizeof(full_message); ++i) {
|
||
parse_byte(&mr, full_message[i]);
|
||
}
|
||
|
||
TEST_ASSERT_FALSE(message_received_flag);
|
||
TEST_ASSERT_TRUE(message_fail_flag);
|
||
TEST_ASSERT_EQUAL_UINT8(msgid, received_msgid);
|
||
// received_payload_len sollte die Länge der Daten sein, die bis zum Fehler
|
||
// empfangen wurden, d.h., Payload-Länge + das falsche Checksummen-Byte.
|
||
TEST_ASSERT_EQUAL_UINT8(payload_len + 1, received_payload_len);
|
||
TEST_ASSERT_EQUAL_UINT8(WrongCheckSum, received_error);
|
||
TEST_ASSERT_EQUAL_UINT8(WaitingForStartByte, mr.state);
|
||
TEST_ASSERT_EQUAL_UINT8(WrongCheckSum, mr.error);
|
||
}
|
||
|
||
// Test 3: Gültige Nachricht ohne Payload (Länge 0)
|
||
void test_3_zero_length_message(void) {
|
||
struct MessageReceive mr = InitMessageReceive();
|
||
|
||
uint8_t msgid = 0x03;
|
||
uint8_t payload[] = {}; // Leerer Payload
|
||
size_t payload_len = sizeof(payload);
|
||
|
||
uint8_t checksum_byte_to_send =
|
||
calculate_payload_checksum_byte(msgid, payload, payload_len);
|
||
|
||
uint8_t full_message[] = {
|
||
StartByte, msgid,
|
||
checksum_byte_to_send, // Checksummen-Byte (hier gleich MSGID, da Payload
|
||
// leer)
|
||
EndByte};
|
||
|
||
for (uint8_t i = 0; i < sizeof(full_message); ++i) {
|
||
parse_byte(&mr, full_message[i]);
|
||
}
|
||
|
||
TEST_ASSERT_TRUE(message_received_flag);
|
||
TEST_ASSERT_FALSE(message_fail_flag);
|
||
TEST_ASSERT_EQUAL_UINT8(msgid, received_msgid);
|
||
TEST_ASSERT_EQUAL_UINT8(0, received_payload_len); // Payload-Länge ist 0
|
||
TEST_ASSERT_EQUAL_UINT8(WaitingForStartByte, mr.state);
|
||
TEST_ASSERT_EQUAL_UINT8(NoError, mr.error);
|
||
}
|
||
|
||
// Test 4: Escapete MSGID (0xAA im MSGID-Feld)
|
||
void test_4_escaped_message_id(void) {
|
||
struct MessageReceive mr = InitMessageReceive();
|
||
|
||
uint8_t msgid = 0xAA; // MSGID ist ein Steuerzeichen, muss escapet werden
|
||
uint8_t payload[] = {0x42};
|
||
size_t payload_len = sizeof(payload);
|
||
|
||
uint8_t checksum_byte_to_send =
|
||
calculate_payload_checksum_byte(msgid, payload, payload_len);
|
||
|
||
uint8_t full_message[] = {StartByte,
|
||
EscapeByte,
|
||
msgid, // Escapete MSGID (0xBB 0xAA)
|
||
0x42, // Payload
|
||
checksum_byte_to_send,
|
||
EndByte};
|
||
|
||
for (uint8_t i = 0; i < sizeof(full_message); ++i) {
|
||
parse_byte(&mr, full_message[i]);
|
||
}
|
||
|
||
TEST_ASSERT_TRUE(message_received_flag);
|
||
TEST_ASSERT_FALSE(message_fail_flag);
|
||
TEST_ASSERT_EQUAL_UINT8(msgid, received_msgid);
|
||
TEST_ASSERT_EQUAL_UINT8(payload_len, received_payload_len);
|
||
TEST_ASSERT_EQUAL_UINT8_ARRAY(payload, received_payload, payload_len);
|
||
TEST_ASSERT_EQUAL_UINT8(WaitingForStartByte, mr.state);
|
||
TEST_ASSERT_EQUAL_UINT8(NoError, mr.error);
|
||
}
|
||
|
||
// Test 5: Escapetes Payload-Byte (z.B. ein StartByte im Payload)
|
||
void test_5_escaped_payload_byte(void) {
|
||
struct MessageReceive mr = InitMessageReceive();
|
||
|
||
uint8_t msgid = 0x05;
|
||
uint8_t payload[] = {
|
||
0x11, StartByte}; // StartByte (0xAA) im Payload, muss escapet werden
|
||
size_t payload_len = sizeof(payload);
|
||
|
||
uint8_t checksum_byte_to_send =
|
||
calculate_payload_checksum_byte(msgid, payload, payload_len);
|
||
|
||
uint8_t full_message[] = {
|
||
StartByte,
|
||
msgid,
|
||
0x11,
|
||
EscapeByte,
|
||
StartByte, // Escaptes StartByte (0xBB 0xAA) im Payload
|
||
checksum_byte_to_send,
|
||
EndByte};
|
||
|
||
for (uint8_t i = 0; i < sizeof(full_message); ++i) {
|
||
parse_byte(&mr, full_message[i]);
|
||
}
|
||
|
||
TEST_ASSERT_TRUE(message_received_flag);
|
||
TEST_ASSERT_FALSE(message_fail_flag);
|
||
TEST_ASSERT_EQUAL_UINT8(msgid, received_msgid);
|
||
TEST_ASSERT_EQUAL_UINT8(payload_len, received_payload_len);
|
||
TEST_ASSERT_EQUAL_UINT8_ARRAY(payload, received_payload, payload_len);
|
||
TEST_ASSERT_EQUAL_UINT8(WaitingForStartByte, mr.state);
|
||
TEST_ASSERT_EQUAL_UINT8(NoError, mr.error);
|
||
}
|
||
|
||
// Test 6: Escapetes Checksummen-Byte (z.B. ein EndByte als Checksumme)
|
||
void test_6_escaped_checksum_byte(void) {
|
||
struct MessageReceive mr = InitMessageReceive();
|
||
|
||
uint8_t msgid = 0x01;
|
||
uint8_t payload[] = {
|
||
0xCD}; // payload[0] ^ msgid = 0xCD ^ 0x01 = 0xCC (EndByte)
|
||
size_t payload_len = sizeof(payload);
|
||
|
||
uint8_t checksum_byte_to_send = calculate_payload_checksum_byte(
|
||
msgid, payload, payload_len); // Dies ist 0xCC
|
||
|
||
uint8_t full_message[] = {
|
||
StartByte,
|
||
msgid,
|
||
payload[0], // Payload
|
||
EscapeByte,
|
||
checksum_byte_to_send, // Escaptes 0xCC als Checksummen-Byte (0xBB 0xCC)
|
||
EndByte};
|
||
|
||
for (uint8_t i = 0; i < sizeof(full_message); ++i) {
|
||
parse_byte(&mr, full_message[i]);
|
||
}
|
||
|
||
TEST_ASSERT_TRUE(message_received_flag);
|
||
TEST_ASSERT_FALSE(message_fail_flag);
|
||
TEST_ASSERT_EQUAL_UINT8(msgid, received_msgid);
|
||
TEST_ASSERT_EQUAL_UINT8(payload_len, received_payload_len);
|
||
TEST_ASSERT_EQUAL_UINT8_ARRAY(payload, received_payload, payload_len);
|
||
TEST_ASSERT_EQUAL_UINT8(WaitingForStartByte, mr.state);
|
||
TEST_ASSERT_EQUAL_UINT8(NoError, mr.error);
|
||
}
|
||
|
||
// Test 7: Nachricht zu lang (Pufferüberlauf)
|
||
void test_7_message_too_long(void) {
|
||
struct MessageReceive mr =
|
||
InitMessageReceive(); // mr.max_total_content_length wird auf
|
||
// MAX_TOTAL_CONTENT_LENGTH gesetzt
|
||
|
||
uint8_t msgid = 0x07;
|
||
// Dieser Payload ist absichtlich 1 Byte zu lang für
|
||
// MAX_MESSAGE_PAYLOAD_LENGTH. D.h., der gesamte Inhalt für mr.message[]
|
||
// (Payload + Checksumme) ist MAX_TOTAL_CONTENT_LENGTH + 1 Bytes lang. Dadurch
|
||
// wird der Puffer definitiv überlaufen.
|
||
uint8_t oversized_data_for_buffer[MAX_TOTAL_CONTENT_LENGTH +
|
||
1]; // Ein Byte zu viel für mr.message[]
|
||
for (size_t i = 0; i < sizeof(oversized_data_for_buffer); ++i) {
|
||
oversized_data_for_buffer[i] = (uint8_t)(i + 1); // Beliebige Daten
|
||
}
|
||
|
||
// Wir brauchen eine korrekte Checksumme, auch wenn die Nachricht zu lang ist,
|
||
// da der Sender diese theoretisch senden würde.
|
||
// Die Berechnung erfolgt über die tatsächlich gesendeten Payload-Daten (die
|
||
// zu lang sind).
|
||
uint8_t checksum_byte_for_oversized_msg = calculate_payload_checksum_byte(
|
||
msgid, oversized_data_for_buffer, MAX_MESSAGE_PAYLOAD_LENGTH + 1);
|
||
|
||
// Simuliere den Versand der Nachricht Byte für Byte
|
||
parse_byte(&mr, StartByte); // mr.state = GetMessageType
|
||
parse_byte(&mr, msgid); // mr.state = InPayload, mr.messageid = 0x07
|
||
|
||
// Sende MAX_TOTAL_CONTENT_LENGTH Bytes, die den Puffer `mr.message`
|
||
// vollständig füllen. Index läuft von 0 bis MAX_TOTAL_CONTENT_LENGTH-1.
|
||
for (size_t i = 0; i < MAX_TOTAL_CONTENT_LENGTH; ++i) {
|
||
// Hier schicken wir die ersten MAX_TOTAL_CONTENT_LENGTH Bytes des
|
||
// übergroßen Payloads (inklusive dem eigentlichen Checksummen-Byte an
|
||
// Position MAX_MESSAGE_PAYLOAD_LENGTH). Das wird den Puffer anfüllen, aber
|
||
// noch keinen Overflow melden.
|
||
parse_byte(&mr, oversized_data_for_buffer[i]);
|
||
}
|
||
|
||
// An diesem Punkt sollte mr.index = MAX_TOTAL_CONTENT_LENGTH sein.
|
||
// Der Puffer `mr.message` ist jetzt voll.
|
||
TEST_ASSERT_EQUAL_UINT8(MAX_TOTAL_CONTENT_LENGTH,
|
||
mr.index); // Der Puffer ist genau gefüllt.
|
||
TEST_ASSERT_EQUAL_UINT8(InPayload, mr.state); // Noch im Payload-Zustand.
|
||
|
||
// Das nächste Byte (das letzte Byte von oversized_data_for_buffer)
|
||
// wird den Overflow auslösen, da mr->index dann mr->max_total_content_length
|
||
// überschreitet.
|
||
parse_byte(&mr, oversized_data_for_buffer[MAX_TOTAL_CONTENT_LENGTH]);
|
||
|
||
TEST_ASSERT_FALSE(message_received_flag);
|
||
TEST_ASSERT_TRUE(message_fail_flag);
|
||
TEST_ASSERT_EQUAL_UINT8(msgid, received_msgid); // MSGID ist korrekt gesetzt
|
||
// received_payload_len sollte die max. Puffergröße sein, bis der Fehler
|
||
// auftrat
|
||
TEST_ASSERT_EQUAL_UINT8(MAX_TOTAL_CONTENT_LENGTH, received_payload_len);
|
||
TEST_ASSERT_EQUAL_UINT8(MessageToLong, received_error);
|
||
TEST_ASSERT_EQUAL_UINT8(WaitingForStartByte, mr.state);
|
||
TEST_ASSERT_EQUAL_UINT8(MessageToLong, mr.error);
|
||
}
|
||
|
||
// Test 8: Unerwartetes StartByte mitten im Frame
|
||
void test_8_unexpected_start_byte_in_payload(void) {
|
||
struct MessageReceive mr = InitMessageReceive();
|
||
|
||
uint8_t msgid = 0x08;
|
||
|
||
uint8_t full_message[] = {
|
||
StartByte, msgid,
|
||
0x10, // Teil des Payloads
|
||
StartByte, // Unerwartetes StartByte mitten im Payload
|
||
0x20, // Dies würde danach kommen
|
||
0x00, // Dummy-Checksumme
|
||
EndByte // Dummy-EndByte
|
||
};
|
||
|
||
parse_byte(&mr, full_message[0]); // StartByte
|
||
parse_byte(&mr, full_message[1]); // MSGID
|
||
parse_byte(&mr, full_message[2]); // Payload 0x10
|
||
|
||
// Hier kommt das unerwartete StartByte, sollte den Fehler auslösen und
|
||
// resetten
|
||
parse_byte(&mr, full_message[3]);
|
||
|
||
TEST_ASSERT_FALSE(message_received_flag);
|
||
TEST_ASSERT_TRUE(message_fail_flag);
|
||
TEST_ASSERT_EQUAL_UINT8(msgid, received_msgid);
|
||
// received_payload_len sollte die Länge der Daten sein, die vor dem Fehler
|
||
// empfangen wurden.
|
||
TEST_ASSERT_EQUAL_UINT8(1, received_payload_len); // Nur 0x10 empfangen
|
||
TEST_ASSERT_EQUAL_UINT8_ARRAY(((uint8_t[]){0x10}), received_payload, 1);
|
||
TEST_ASSERT_EQUAL_UINT8(UnexpectedCommandByte, received_error);
|
||
TEST_ASSERT_EQUAL_UINT8(WaitingForStartByte, mr.state);
|
||
TEST_ASSERT_EQUAL_UINT8(UnexpectedCommandByte, mr.error);
|
||
}
|
||
|
||
// Test 9: Unerwartetes EndByte an der Position der MSGID
|
||
void test_9_unexpected_end_byte_at_msgid(void) {
|
||
struct MessageReceive mr = InitMessageReceive();
|
||
|
||
uint8_t full_message[] = {StartByte, EndByte, // EndByte anstelle von MSGID
|
||
0x01, 0x02, 0x03, 0x04, EndByte};
|
||
|
||
parse_byte(&mr, full_message[0]); // StartByte
|
||
parse_byte(&mr, full_message[1]); // EndByte anstelle MSGID
|
||
|
||
TEST_ASSERT_FALSE(message_received_flag);
|
||
TEST_ASSERT_TRUE(message_fail_flag);
|
||
TEST_ASSERT_EQUAL_UINT8(
|
||
0x00, received_msgid); // MSGID ist noch 0, da keine empfangen
|
||
TEST_ASSERT_EQUAL_UINT8(0, received_payload_len); // Noch kein Payload
|
||
TEST_ASSERT_EQUAL_UINT8(UnexpectedCommandByte, received_error);
|
||
TEST_ASSERT_EQUAL_UINT8(WaitingForStartByte, mr.state);
|
||
TEST_ASSERT_EQUAL_UINT8(UnexpectedCommandByte, mr.error);
|
||
}
|
||
|
||
// Test 10: Kein StartByte zu Beginn der Sequenz (Parser sollte ignorieren)
|
||
void test_10_no_startbyte_at_beginning_ignored(void) {
|
||
struct MessageReceive mr = InitMessageReceive();
|
||
|
||
uint8_t msg[] = {0x01, 0x02, 0x03, 0x04}; // Beginnt nicht mit StartByte
|
||
|
||
for (uint8_t i = 0; i < sizeof(msg); ++i) {
|
||
parse_byte(&mr, msg[i]);
|
||
}
|
||
|
||
TEST_ASSERT_FALSE(message_received_flag);
|
||
TEST_ASSERT_FALSE(
|
||
message_fail_flag); // Sollte keinen Fehler melden, nur ignorieren
|
||
TEST_ASSERT_EQUAL_UINT8(WaitingForStartByte,
|
||
mr.state); // Sollte im Wartezustand bleiben
|
||
TEST_ASSERT_EQUAL_UINT8(0, mr.index); // Index sollte 0 bleiben
|
||
TEST_ASSERT_EQUAL_UINT8(NoError, mr.error); // Kein Fehler gemeldet
|
||
}
|
||
|
||
// Test 11: Ungültige Länge (z.B. EndByte kommt zu früh, ohne Checksumme)
|
||
// Angenommen, das Protokoll erwartet immer mindestens MSGID + Checksumme.
|
||
// Ein leeres Payload ist OK (MSGID + Checksumme + EndByte), aber nur MSGID +
|
||
// EndByte ist Fehler.
|
||
void test_11_frame_too_short_no_checksum(void) {
|
||
struct MessageReceive mr = InitMessageReceive();
|
||
|
||
uint8_t msgid = 0x09;
|
||
uint8_t full_message[] = {
|
||
StartByte, msgid, EndByte // Kein Payload, keine Checksumme
|
||
};
|
||
|
||
for (uint8_t i = 0; i < sizeof(full_message); ++i) {
|
||
parse_byte(&mr, full_message[i]);
|
||
}
|
||
|
||
TEST_ASSERT_FALSE(message_received_flag);
|
||
TEST_ASSERT_TRUE(message_fail_flag);
|
||
TEST_ASSERT_EQUAL_UINT8(msgid, received_msgid); // MSGID ist bekannt
|
||
TEST_ASSERT_EQUAL_UINT8(0, received_payload_len); // Payload-Puffer ist leer
|
||
TEST_ASSERT_EQUAL_UINT8(WrongCheckSum,
|
||
received_error); // Checksumme kann nicht 0x00 sein
|
||
TEST_ASSERT_EQUAL_UINT8(WaitingForStartByte, mr.state);
|
||
TEST_ASSERT_EQUAL_UINT8(WrongCheckSum, mr.error);
|
||
}
|
||
|
||
int main(void) {
|
||
UNITY_BEGIN();
|
||
RUN_TEST(test_1_valid_message_parses_correctly);
|
||
RUN_TEST(test_2_invalid_checksum_resets_state);
|
||
RUN_TEST(test_3_zero_length_message);
|
||
RUN_TEST(test_4_escaped_message_id);
|
||
RUN_TEST(test_5_escaped_payload_byte);
|
||
RUN_TEST(test_6_escaped_checksum_byte);
|
||
RUN_TEST(test_7_message_too_long);
|
||
RUN_TEST(test_8_unexpected_start_byte_in_payload);
|
||
RUN_TEST(test_9_unexpected_end_byte_at_msgid);
|
||
RUN_TEST(test_10_no_startbyte_at_beginning_ignored);
|
||
RUN_TEST(test_11_frame_too_short_no_checksum);
|
||
return UNITY_END();
|
||
}
|