LCOV - code coverage report
Current view: top level - message/msg_stream.c (source / functions) Coverage Total Hit
Test: coverage-filtered.info Lines: 100.0 % 54 54
Test Date: 2026-04-10 08:50:57 Functions: 100.0 % 6 6
Branches: 60.9 % 46 28
MC/DC: 60.9 % 46 28

             Branch data      MC/DC data    Line data    Source code
       1                 :              :             : #include <stdint.h>
       2                 :              :             : #include <string.h>
       3                 :              :             : 
       4                 :              :             : #include "common.h"
       5                 :              :             : 
       6                 :              :             : #include "can.h"
       7                 :              :             : #include "message_types.h"
       8                 :              :             : #include "msg_common.h"
       9                 :              :             : #include "msg_stream.h"
      10                 :              :             : 
      11                 :              :             : // Fields are 24-bit big-endian.
      12                 :              :             : #define STREAM_SIZE_MAX 0xFFFFFFu
      13                 :              :             : 
      14                 :              :           1 : void build_stream_status_msg(can_msg_prio_t prio, uint16_t timestamp, uint32_t total_size,
      15                 :              :             :                                                          uint32_t tx_size, can_msg_t *output) {
      16         [ +  - ]:      [ T  f ]:           1 :         w_assert(output);
      17         [ +  - ]:      [ T  f ]:           1 :         w_assert(total_size <= STREAM_SIZE_MAX);
      18         [ +  - ]:      [ T  f ]:           1 :         w_assert(tx_size <= STREAM_SIZE_MAX);
      19                 :              :             : 
      20                 :              :           1 :         output->sid = build_sid(prio, MSG_STREAM_STATUS, 0);
      21                 :              :           1 :         write_timestamp(timestamp, output);
      22                 :              :             : 
      23                 :              :           1 :         output->data[2] = (uint8_t)((total_size >> 16) & 0xFF);
      24                 :              :           1 :         output->data[3] = (uint8_t)((total_size >> 8) & 0xFF);
      25                 :              :           1 :         output->data[4] = (uint8_t)(total_size & 0xFF);
      26                 :              :           1 :         output->data[5] = (uint8_t)((tx_size >> 16) & 0xFF);
      27                 :              :           1 :         output->data[6] = (uint8_t)((tx_size >> 8) & 0xFF);
      28                 :              :           1 :         output->data[7] = (uint8_t)(tx_size & 0xFF);
      29                 :              :           1 :         output->data_len = 8;
      30                 :              :           1 : }
      31                 :              :             : 
      32                 :              :           1 : void build_stream_data_msg(can_msg_prio_t prio, uint16_t timestamp, uint8_t seq_id,
      33                 :              :             :                                                    const uint8_t *payload, uint8_t payload_len, can_msg_t *output) {
      34         [ +  - ]:      [ T  f ]:           1 :         w_assert(output);
      35         [ +  - ]:      [ T  f ]:           1 :         w_assert(payload);
      36         [ +  - ]:      [ T  f ]:           1 :         w_assert(payload_len <= STREAM_DATA_MAX_PAYLOAD_LEN);
      37                 :              :             : 
      38                 :              :           1 :         output->sid = build_sid(prio, MSG_STREAM_DATA, seq_id);
      39                 :              :           1 :         write_timestamp(timestamp, output);
      40                 :              :             : 
      41                 :              :           1 :         memcpy(&output->data[2], payload, payload_len);
      42                 :              :             : 
      43                 :              :           1 :         output->data_len = (uint8_t)(payload_len + 2);
      44                 :              :           1 : }
      45                 :              :             : 
      46                 :              :           1 : void build_stream_retry_msg(can_msg_prio_t prio, uint16_t timestamp, uint8_t seq_id,
      47                 :              :             :                                                         can_msg_t *output) {
      48         [ +  - ]:      [ T  f ]:           1 :         w_assert(output);
      49                 :              :             : 
      50                 :              :           1 :         output->sid = build_sid(prio, MSG_STREAM_RETRY, seq_id);
      51                 :              :           1 :         write_timestamp(timestamp, output);
      52                 :              :             : 
      53                 :              :           1 :         output->data_len = 2;
      54                 :              :           1 : }
      55                 :              :             : 
      56                 :              :           2 : bool get_stream_status(const can_msg_t *msg, uint32_t *total_size, uint32_t *tx_size) {
      57         [ +  - ]:      [ T  f ]:           2 :         w_assert(msg);
      58         [ +  - ]:      [ T  f ]:           2 :         w_assert(total_size);
      59         [ +  - ]:      [ T  f ]:           2 :         w_assert(tx_size);
      60                 :              :             : 
      61   [ +  +  +  - ]:[ T  F  t  F ]:           2 :         if (get_message_type(msg) != MSG_STREAM_STATUS || msg->data_len != 8) {
      62                 :              :             :                 return false;
      63                 :              :             :         }
      64                 :              :             : 
      65                 :              :           1 :         *total_size = ((uint32_t)msg->data[2] << 16) | ((uint32_t)msg->data[3] << 8) | msg->data[4];
      66                 :              :           1 :         *tx_size = ((uint32_t)msg->data[5] << 16) | ((uint32_t)msg->data[6] << 8) | msg->data[7];
      67                 :              :             : 
      68                 :              :           1 :         return true;
      69                 :              :             : }
      70                 :              :             : 
      71                 :              :           3 : bool get_stream_data(const can_msg_t *msg, uint8_t *seq_id, uint8_t *payload,
      72                 :              :             :                                          uint8_t *payload_len) {
      73         [ +  - ]:      [ T  f ]:           3 :         w_assert(msg);
      74         [ +  - ]:      [ T  f ]:           3 :         w_assert(seq_id);
      75         [ +  - ]:      [ T  f ]:           3 :         w_assert(payload);
      76         [ +  - ]:      [ T  f ]:           3 :         w_assert(payload_len);
      77                 :              :             : 
      78   [ +  +  +  +  :[ T  F  T  F  :           3 :         if ((get_message_type(msg) != MSG_STREAM_DATA) || (msg->data_len < 4) || (msg->data_len > 8)) {
                   +  - ]         t  F ]
      79                 :              :             :                 return false;
      80                 :              :             :         }
      81                 :              :             : 
      82                 :              :           1 :         uint8_t msg_payload_len = (uint8_t)(msg->data_len - 2);
      83                 :              :           1 :         memcpy(payload, &msg->data[2], msg_payload_len);
      84                 :              :             : 
      85                 :              :           1 :         *seq_id = msg->sid & 0xff;
      86                 :              :           1 :         *payload_len = msg_payload_len;
      87                 :              :             : 
      88                 :              :           1 :         return true;
      89                 :              :             : }
      90                 :              :             : 
      91                 :              :           3 : bool get_stream_retry_seq_id(const can_msg_t *msg, uint8_t *seq_id) {
      92         [ +  - ]:      [ T  f ]:           3 :         w_assert(msg);
      93         [ +  - ]:      [ T  f ]:           3 :         w_assert(seq_id);
      94                 :              :             : 
      95   [ +  +  +  + ]:[ T  F  T  F ]:           3 :         if (get_message_type(msg) != MSG_STREAM_RETRY || msg->data_len != 2) {
      96                 :              :             :                 return false;
      97                 :              :             :         }
      98                 :              :             : 
      99                 :              :           1 :         *seq_id = get_message_metadata(msg);
     100                 :              :             : 
     101                 :              :           1 :         return true;
     102                 :              :             : }
        

Generated by: LCOV version 2.0-1