Modbus Library Test Coverage Report

lib/queue/
Coverage:
low: ≥ 0%
medium: ≥ 75.0%
high: ≥ 90.0%
Lines:
66 of 66, 0 excluded
100.0%
Functions:
8 of 8, 0 excluded
100.0%
Branches:
37 of 38, 0 excluded
97.4%
queue.c
Line Branch Exec Source
1 /**
2 * @file queue.c
3 * @brief Generic FIFO queue implementation for embedded safety-critical use.
4 * @version 1.0.4
5 * @date 2026-03-05
6 *
7 * @details
8 * Provides deterministic enqueue/dequeue operations on a caller-supplied
9 * memory buffer. Implementation uses explicit byte-wise copying and avoids
10 * standard library dependencies to ensure predictable timing.
11 *
12 * MISRA Deviation: DV-QUEUE-001 (Rule 11.4)
13 * Controlled cast from `void*` to `uint8_t*` for raw byte access.
14 * Safe because data is not type-reinterpreted.
15 *
16 * @ingroup queue
17 */
18
19 #include "queue.h"
20 #include <stddef.h> /* for NULL */
21
22 /* PRIVATE macro controls linkage:
23 * - static in production builds
24 * - global in UNIT_TESTS build for unit test visibility.
25 */
26 #ifdef UNIT_TESTS
27 #define PRIVATE
28 #else
29 #define PRIVATE static
30 #endif
31
32 /* Internal helper: byte-wise deterministic copy.
33 * @note MISRA Deviation DV-QUEUE-001 applies here.
34 * Do not expose externally; tested via queue_push/queue_pop. */
35 PRIVATE void copy_bytes(uint8_t *dst, const uint8_t *src, uint16_t size);
36 static bool validate_init_arg(const queue_t *q, const void *buffer, uint16_t buffer_element_size, uint16_t queue_capacity);
37
38 /* -------------------------- */
39 /* Queue API implementation */
40 /* -------------------------- */
41
42 62 queue_status_t queue_init(queue_t *q, void *buffer, uint16_t buffer_element_size, uint16_t queue_capacity)
43 {
44 62 queue_status_t ret_status = QUEUE_OK;
45
46
2/2
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 56 times.
 62 if (validate_init_arg(q, buffer, buffer_element_size, queue_capacity))
47 {
48 6 ret_status = QUEUE_ERROR;
49 }
50 else
51 {
52 56 q->buffer = buffer;
53 56 q->buffer_element_size = buffer_element_size;
54 56 q->capacity = queue_capacity;
55 56 q->head = 0U;
56 56 q->tail = 0U;
57 56 q->count = 0U;
58 }
59
60 62 return ret_status;
61 }
62
63 57 queue_status_t queue_push(queue_t *q, const void *item)
64 {
65 57 queue_status_t ret_status = QUEUE_OK;
66
67
3/4
✓ Branch 0 taken 57 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 54 times.
 57 if ((q == NULL) || (item == NULL))
68 {
69 3 ret_status = QUEUE_ERROR;
70 }
71
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 51 times.
 54 else if (q->count >= q->capacity)
72 {
73 3 ret_status = QUEUE_FULL;
74 }
75 else
76 {
77 /* MISRA Deviation DV-QUEUE-001: controlled cast for byte-wise copy */
78 51 uint8_t *base = (uint8_t *)q->buffer;
79 51 const uint32_t offset = (uint32_t)q->tail * (uint32_t)q->buffer_element_size;
80
81 51 copy_bytes(&base[offset], (const uint8_t *)item, q->buffer_element_size);
82
83 51 q->tail = (uint16_t)(((uint32_t)q->tail + 1U) % (uint32_t)q->capacity);
84 51 q->count = (uint16_t)((uint32_t)q->count + 1U);
85 }
86
87 57 return ret_status;
88 }
89
90 42 queue_status_t queue_pop(queue_t *q, void *item)
91 {
92 42 queue_status_t ret_status = QUEUE_OK;
93
94
4/4
✓ Branch 0 taken 41 times.
✓ Branch 1 taken 1 time.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 38 times.
 42 if ((q == NULL) || (item == NULL))
95 {
96 4 ret_status = QUEUE_ERROR;
97 }
98
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 34 times.
 38 else if (q->count == 0U)
99 {
100 4 ret_status = QUEUE_EMPTY;
101 }
102 else
103 {
104 /* MISRA Deviation DV-QUEUE-001: controlled cast for byte-wise copy */
105 34 const uint8_t *base = (const uint8_t *)q->buffer;
106 34 const uint32_t offset = (uint32_t)q->head * (uint32_t)q->buffer_element_size;
107
108 34 copy_bytes((uint8_t *)item, &base[offset], q->buffer_element_size);
109
110 34 q->head = (uint16_t)(((uint32_t)q->head + 1U) % (uint32_t)q->capacity);
111 34 q->count = (uint16_t)((uint32_t)q->count - 1U);
112 }
113
114 42 return ret_status;
115 }
116
117 8 queue_status_t queue_peek(const queue_t *q, void *item)
118 {
119
4/4
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 1 time.
✓ Branch 2 taken 1 time.
✓ Branch 3 taken 6 times.
 8 if ((q == NULL) || (item == NULL))
120 {
121 2 return QUEUE_ERROR;
122 }
123
2/2
✓ Branch 0 taken 1 time.
✓ Branch 1 taken 5 times.
 6 if (q->count == 0U)
124 {
125 1 return QUEUE_EMPTY;
126 }
127 5 const uint8_t *base = (const uint8_t *)q->buffer;
128 5 uint32_t offset = (uint32_t)q->head * q->buffer_element_size;
129
130 5 copy_bytes((uint8_t *)item, &base[offset], q->buffer_element_size);
131
132 5 return QUEUE_OK;
133 }
134
135 23 bool queue_is_empty(const queue_t *q)
136 {
137 23 bool is_empty = true;
138
139
2/2
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 1 time.
 23 if (q != NULL)
140 {
141 22 is_empty = (q->count == 0U);
142 }
143
144 23 return is_empty;
145 }
146
147 14 bool queue_is_full(const queue_t *q)
148 {
149 14 bool is_full = false;
150
151
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 1 time.
 14 if (q != NULL)
152 {
153 13 is_full = (q->count == q->capacity);
154 }
155
156 14 return is_full;
157 }
158
159 /* -------------------------- */
160 /* Internal helper functions */
161 /* -------------------------- */
162 /**
163 * @defgroup queue_internal Queue Internal Functions
164 * @ingroup queue
165 * @brief Internal helper functions for the queue module (not part of public API).
166 * @details
167 * These functions are local to `queue.c` and not exposed in `queue.h`.
168 * They support deterministic byte copying and argument validation.
169 * @{
170 */
171
172 /**
173 * @brief Deterministic byte-wise copy of memory.
174 *
175 * @param[out] dst Destination buffer (non-NULL).
176 * @param[in] src Source buffer (non-NULL).
177 * @param[in] size Number of bytes to copy.
178 *
179 * @details
180 * Used internally by queue_push/queue_pop to copy arbitrary elements
181 * in a deterministic, type-agnostic way.
182 *
183 * @note MISRA Deviation DV-QUEUE-001 applies.
184 */
185 93 PRIVATE void copy_bytes(uint8_t *dst, const uint8_t *src, uint16_t size)
186 {
187
4/4
✓ Branch 0 taken 91 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 90 times.
✓ Branch 3 taken 1 time.
 93 if ((dst != NULL) && (src != NULL))
188 {
189
2/2
✓ Branch 0 taken 354 times.
✓ Branch 1 taken 90 times.
 444 for (uint16_t i = 0U; i < size; i = (uint16_t)(i + 1U))
190 {
191 354 dst[i] = src[i];
192 }
193 }
194 else
195 {
196 /* Defensive path: do nothing if invalid pointers */
197 }
198 93 }
199
200 /**
201 * @brief Validate queue initialization parameters.
202 *
203 * @param[in] q Queue structure pointer.
204 * @param[in] buffer Data buffer pointer.
205 * @param[in] buffer_element_size Element size in bytes.
206 * @param[in] queue_capacity Maximum number of elements.
207 *
208 * @return true — invalid argument(s).
209 * @return false — all parameters valid.
210 */
211 62 PRIVATE bool validate_init_arg(const queue_t *q, const void *buffer, uint16_t buffer_element_size, uint16_t queue_capacity)
212 {
213 62 bool invalid = false;
214
215
4/4
✓ Branch 0 taken 60 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 58 times.
✓ Branch 3 taken 2 times.
 62 if ((q == NULL) ||
216
2/2
✓ Branch 0 taken 57 times.
✓ Branch 1 taken 1 time.
 58 (buffer == NULL) ||
217
2/2
✓ Branch 0 taken 1 time.
✓ Branch 1 taken 56 times.
 57 (buffer_element_size == 0U) ||
218 (queue_capacity == 0U))
219 {
220 6 invalid = true;
221 }
222
223 62 return invalid;
224 }
225
226 /** @} */ /* end of queue_internal group */
227