LCOV - code coverage report
Current view: top level - message/msg_stream.c (source / functions) Coverage Total Hit
Test: coverage-filtered.info Lines: 100.0 % 53 53
Test Date: 2026-03-20 08:45:03 Functions: 100.0 % 6 6
Branches: 65.9 % 44 29
MC/DC: 65.9 % 44 29

             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                 :              :           3 : bool 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 ]:           3 :         w_assert(output);
      17                 :              :             : 
      18         [ +  + ]:      [ T  F ]:           3 :         if ((total_size > STREAM_SIZE_MAX) || (tx_size > STREAM_SIZE_MAX)) {
      19                 :              :             :                 return false;
      20                 :              :             :         }
      21                 :              :             : 
      22                 :              :           1 :         output->sid = build_sid(prio, MSG_STREAM_STATUS, 0);
      23                 :              :           1 :         write_timestamp(timestamp, output);
      24                 :              :             : 
      25                 :              :           1 :         output->data[2] = (uint8_t)((total_size >> 16) & 0xFF);
      26                 :              :           1 :         output->data[3] = (uint8_t)((total_size >> 8) & 0xFF);
      27                 :              :           1 :         output->data[4] = (uint8_t)(total_size & 0xFF);
      28                 :              :           1 :         output->data[5] = (uint8_t)((tx_size >> 16) & 0xFF);
      29                 :              :           1 :         output->data[6] = (uint8_t)((tx_size >> 8) & 0xFF);
      30                 :              :           1 :         output->data[7] = (uint8_t)(tx_size & 0xFF);
      31                 :              :           1 :         output->data_len = 8;
      32                 :              :             : 
      33                 :              :           1 :         return true;
      34                 :              :             : }
      35                 :              :             : 
      36                 :              :           2 : bool build_stream_data_msg(can_msg_prio_t prio, uint16_t timestamp, uint8_t seq_id,
      37                 :              :             :                                                    const uint8_t *payload, uint8_t payload_len, can_msg_t *output) {
      38         [ +  - ]:      [ T  f ]:           2 :         w_assert(output);
      39         [ +  - ]:      [ T  f ]:           2 :         w_assert(payload);
      40                 :              :             : 
      41         [ +  + ]:      [ T  F ]:           2 :         if (payload_len > STREAM_DATA_MAX_PAYLOAD_LEN) {
      42                 :              :             :                 return false;
      43                 :              :             :         }
      44                 :              :             : 
      45                 :              :           1 :         output->sid = build_sid(prio, MSG_STREAM_DATA, seq_id);
      46                 :              :           1 :         write_timestamp(timestamp, output);
      47                 :              :             : 
      48                 :              :           1 :         memcpy(&output->data[2], payload, payload_len);
      49                 :              :             : 
      50                 :              :           1 :         output->data_len = (uint8_t)(payload_len + 2);
      51                 :              :             : 
      52                 :              :           1 :         return true;
      53                 :              :             : }
      54                 :              :             : 
      55                 :              :           1 : bool build_stream_retry_msg(can_msg_prio_t prio, uint16_t timestamp, uint8_t seq_id,
      56                 :              :             :                                                         can_msg_t *output) {
      57         [ +  - ]:      [ T  f ]:           1 :         w_assert(output);
      58                 :              :             : 
      59                 :              :           1 :         output->sid = build_sid(prio, MSG_STREAM_RETRY, seq_id);
      60                 :              :           1 :         write_timestamp(timestamp, output);
      61                 :              :             : 
      62                 :              :           1 :         output->data_len = 2;
      63                 :              :             : 
      64                 :              :           1 :         return true;
      65                 :              :             : }
      66                 :              :             : 
      67                 :              :           2 : bool get_stream_status(const can_msg_t *msg, uint32_t *total_size, uint32_t *tx_size) {
      68         [ +  - ]:      [ T  f ]:           2 :         w_assert(msg);
      69         [ +  - ]:      [ T  f ]:           2 :         w_assert(total_size);
      70         [ +  - ]:      [ T  f ]:           2 :         w_assert(tx_size);
      71                 :              :             : 
      72   [ +  +  +  - ]:[ T  F  t  F ]:           2 :         if (get_message_type(msg) != MSG_STREAM_STATUS || msg->data_len != 8) {
      73                 :              :             :                 return false;
      74                 :              :             :         }
      75                 :              :             : 
      76                 :              :           1 :         *total_size = ((uint32_t)msg->data[2] << 16) | ((uint32_t)msg->data[3] << 8) | msg->data[4];
      77                 :              :           1 :         *tx_size = ((uint32_t)msg->data[5] << 16) | ((uint32_t)msg->data[6] << 8) | msg->data[7];
      78                 :              :             : 
      79                 :              :           1 :         return true;
      80                 :              :             : }
      81                 :              :             : 
      82                 :              :           3 : bool get_stream_data(const can_msg_t *msg, uint8_t *seq_id, uint8_t *payload,
      83                 :              :             :                                          uint8_t *payload_len) {
      84         [ +  - ]:      [ T  f ]:           3 :         w_assert(msg);
      85         [ +  - ]:      [ T  f ]:           3 :         w_assert(seq_id);
      86         [ +  - ]:      [ T  f ]:           3 :         w_assert(payload);
      87         [ +  - ]:      [ T  f ]:           3 :         w_assert(payload_len);
      88                 :              :             : 
      89   [ +  +  +  +  :[ T  F  T  F  :           3 :         if ((get_message_type(msg) != MSG_STREAM_DATA) || (msg->data_len < 4) || (msg->data_len > 8)) {
                   +  - ]         t  F ]
      90                 :              :             :                 return false;
      91                 :              :             :         }
      92                 :              :             : 
      93                 :              :           1 :         uint8_t msg_payload_len = (uint8_t)(msg->data_len - 2);
      94                 :              :           1 :         memcpy(payload, &msg->data[2], msg_payload_len);
      95                 :              :             : 
      96                 :              :           1 :         *seq_id = msg->sid & 0xff;
      97                 :              :           1 :         *payload_len = msg_payload_len;
      98                 :              :             : 
      99                 :              :           1 :         return true;
     100                 :              :             : }
     101                 :              :             : 
     102                 :              :           3 : bool get_stream_retry_seq_id(const can_msg_t *msg, uint8_t *seq_id) {
     103         [ +  - ]:      [ T  f ]:           3 :         w_assert(msg);
     104         [ +  - ]:      [ T  f ]:           3 :         w_assert(seq_id);
     105                 :              :             : 
     106   [ +  +  +  + ]:[ T  F  T  F ]:           3 :         if (get_message_type(msg) != MSG_STREAM_RETRY || msg->data_len != 2) {
     107                 :              :             :                 return false;
     108                 :              :             :         }
     109                 :              :             : 
     110                 :              :           1 :         *seq_id = get_message_metadata(msg);
     111                 :              :             : 
     112                 :              :           1 :         return true;
     113                 :              :             : }
        

Generated by: LCOV version 2.0-1