libamxc  1.10.3
C Generic Data Containers
test_amx_rbuffer.c
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** SPDX-License-Identifier: BSD-2-Clause-Patent
4 **
5 ** SPDX-FileCopyrightText: Copyright (c) 2023 SoftAtHome
6 **
7 ** Redistribution and use in source and binary forms, with or without modification,
8 ** are permitted provided that the following conditions are met:
9 **
10 ** 1. Redistributions of source code must retain the above copyright notice,
11 ** this list of conditions and the following disclaimer.
12 **
13 ** 2. Redistributions in binary form must reproduce the above copyright notice,
14 ** this list of conditions and the following disclaimer in the documentation
15 ** and/or other materials provided with the distribution.
16 **
17 ** Subject to the terms and conditions of this license, each copyright holder
18 ** and contributor hereby grants to those receiving rights under this license
19 ** a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
20 ** (except for failure to satisfy the conditions of this license) patent license
21 ** to make, have made, use, offer to sell, sell, import, and otherwise transfer
22 ** this software, where such license applies only to those patent claims, already
23 ** acquired or hereafter acquired, licensable by such copyright holder or contributor
24 ** that are necessarily infringed by:
25 **
26 ** (a) their Contribution(s) (the licensed copyrights of copyright holders and
27 ** non-copyrightable additions of contributors, in source or binary form) alone;
28 ** or
29 **
30 ** (b) combination of their Contribution(s) with the work of authorship to which
31 ** such Contribution(s) was added by such copyright holder or contributor, if,
32 ** at the time the Contribution is added, such addition causes such combination
33 ** to be necessarily infringed. The patent license shall not apply to any other
34 ** combinations which include the Contribution.
35 **
36 ** Except as expressly stated above, no rights or licenses from any copyright
37 ** holder or contributor is granted under this license, whether expressly, by
38 ** implication, estoppel or otherwise.
39 **
40 ** DISCLAIMER
41 **
42 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
43 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
46 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47 ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
48 ** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
49 ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
50 ** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
51 ** USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
52 **
53 ****************************************************************************/
54 
55 #include <stdlib.h>
56 #include <stdio.h>
57 #include <setjmp.h>
58 #include <string.h>
59 #include <cmocka.h>
60 
61 #include <amxc/amxc_rbuffer.h>
62 
63 #include "test_amxc_rbuffer.h"
64 
65 #include <amxc/amxc_macros.h>
66 void amxc_rbuffer_new_delete_null_check(UNUSED void** state) {
67  // passing NULL pointers should not lead to segfault
68  assert_int_equal(amxc_rbuffer_new(NULL, 0), -1);
69  amxc_rbuffer_delete(NULL);
70 }
71 
72 void amxc_rbuffer_new_delete_check(UNUSED void** state) {
73  amxc_rbuffer_t* rbuffer = NULL;
74 
75  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
76  assert_ptr_not_equal(rbuffer, NULL);
77  assert_ptr_not_equal(rbuffer->buffer_start, NULL);
78  assert_ptr_equal(rbuffer->buffer_end, rbuffer->buffer_start + 30);
79  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start);
80  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start);
81 
82  amxc_rbuffer_delete(&rbuffer);
83  assert_ptr_equal(rbuffer, NULL);
84 
85  assert_int_equal(amxc_rbuffer_new(&rbuffer, 0), 0);
86  assert_ptr_not_equal(rbuffer, NULL);
87  assert_ptr_equal(rbuffer->buffer_start, NULL);
88  assert_ptr_equal(rbuffer->buffer_end, NULL);
89  assert_ptr_equal(rbuffer->read_pos, NULL);
90  assert_ptr_equal(rbuffer->write_pos, NULL);
91 
92  amxc_rbuffer_delete(&rbuffer);
93  assert_ptr_equal(rbuffer, NULL);
94 }
95 
96 void amxc_rbuffer_init_clean_null_check(UNUSED void** state) {
97  // passing NULL pointers should not lead to segfault
98  assert_int_equal(amxc_rbuffer_init(NULL, 0), -1);
99  amxc_rbuffer_clean(NULL);
100 }
101 
102 void amxc_rbuffer_init_clean_check(UNUSED void** state) {
103  amxc_rbuffer_t rbuffer;
104 
105  assert_int_equal(amxc_rbuffer_init(&rbuffer, 30), 0);
106  assert_ptr_not_equal(rbuffer.buffer_start, NULL);
107  assert_ptr_equal(rbuffer.buffer_end, rbuffer.buffer_start + 30);
108  assert_ptr_equal(rbuffer.read_pos, rbuffer.buffer_start);
109  assert_ptr_equal(rbuffer.write_pos, rbuffer.buffer_start);
110 
111  amxc_rbuffer_clean(&rbuffer);
112  assert_ptr_equal(rbuffer.buffer_start, NULL);
113  assert_ptr_equal(rbuffer.buffer_end, NULL);
114  assert_ptr_equal(rbuffer.read_pos, NULL);
115  assert_ptr_equal(rbuffer.write_pos, NULL);
116 }
117 
118 void amxc_rbuffer_grow_shrink_null_check(UNUSED void** state) {
119  // passing NULL pointers should not lead to segfault
120  assert_int_equal(amxc_rbuffer_grow(NULL, 0), -1);
121  assert_int_equal(amxc_rbuffer_shrink(NULL, 0), -1);
122 }
123 
124 void amxc_rbuffer_grow_check(UNUSED void** state) {
125  amxc_rbuffer_t* rbuffer = NULL;
126 
127  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
128 
129  assert_int_equal(amxc_rbuffer_grow(rbuffer, 10), 0);
130  assert_ptr_not_equal(rbuffer->buffer_start, NULL);
131  assert_ptr_equal(rbuffer->buffer_end, rbuffer->buffer_start + 40);
132  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start);
133  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start);
134 
135  amxc_rbuffer_delete(&rbuffer);
136 }
137 
138 void amxc_rbuffer_grow_read_before_write_check(UNUSED void** state) {
139  amxc_rbuffer_t* rbuffer = NULL;
140 
141  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
142  rbuffer->read_pos = rbuffer->buffer_start + 10;
143  rbuffer->write_pos = rbuffer->buffer_start + 20;
144 
145  assert_int_equal(amxc_rbuffer_grow(rbuffer, 10), 0);
146  assert_ptr_not_equal(rbuffer->buffer_start, NULL);
147  assert_ptr_equal(rbuffer->buffer_end, rbuffer->buffer_start + 40);
148  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start + 10);
149  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 20);
150 
151  amxc_rbuffer_delete(&rbuffer);
152 }
153 
154 void amxc_rbuffer_grow_write_before_read_check(UNUSED void** state) {
155  amxc_rbuffer_t* rbuffer = NULL;
156 
157  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
158  rbuffer->read_pos = rbuffer->buffer_start + 20;
159  rbuffer->write_pos = rbuffer->buffer_start + 10;
160 
161  assert_int_equal(amxc_rbuffer_grow(rbuffer, 10), 0);
162  assert_ptr_not_equal(rbuffer->buffer_start, NULL);
163  assert_ptr_equal(rbuffer->buffer_end, rbuffer->buffer_start + 40);
164  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start + 30);
165  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 10);
166 
167  amxc_rbuffer_delete(&rbuffer);
168 }
169 
170 void amxc_rbuffer_shrink_check(UNUSED void** state) {
171  amxc_rbuffer_t* rbuffer = NULL;
172 
173  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
174 
175  assert_int_equal(amxc_rbuffer_shrink(rbuffer, 10), 0);
176  assert_ptr_not_equal(rbuffer->buffer_start, NULL);
177  assert_ptr_equal(rbuffer->buffer_end, rbuffer->buffer_start + 20);
178  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start);
179  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start);
180 
181  assert_int_equal(amxc_rbuffer_shrink(rbuffer, 30), -1);
182 
183  amxc_rbuffer_delete(&rbuffer);
184 }
185 
186 void amxc_rbuffer_shrink_read_before_write_check(UNUSED void** state) {
187  amxc_rbuffer_t* rbuffer = NULL;
188 
189  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
190  rbuffer->read_pos = rbuffer->buffer_start + 5;
191  rbuffer->write_pos = rbuffer->buffer_start + 15;
192 
193  assert_int_equal(amxc_rbuffer_shrink(rbuffer, 10), 0);
194  assert_ptr_not_equal(rbuffer->buffer_start, NULL);
195  assert_ptr_equal(rbuffer->buffer_end, rbuffer->buffer_start + 20);
196  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start);
197  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 10);
198 
199  amxc_rbuffer_delete(&rbuffer);
200 }
201 
202 void amxc_rbuffer_shrink_read_before_write_data_loss_check(UNUSED void** state) {
203  amxc_rbuffer_t* rbuffer = NULL;
204 
205  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
206  rbuffer->read_pos = rbuffer->buffer_start + 5;
207  rbuffer->write_pos = rbuffer->buffer_start + 25;
208 
209  assert_int_equal(amxc_rbuffer_shrink(rbuffer, 15), 0);
210  assert_ptr_not_equal(rbuffer->buffer_start, NULL);
211  assert_ptr_equal(rbuffer->buffer_end, rbuffer->buffer_start + 15);
212  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start);
213  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 15);
214 
215  amxc_rbuffer_delete(&rbuffer);
216 }
217 
218 void amxc_rbuffer_shrink_write_before_read_check(UNUSED void** state) {
219  amxc_rbuffer_t* rbuffer = NULL;
220 
221  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
222  rbuffer->read_pos = rbuffer->buffer_start + 25;
223  rbuffer->write_pos = rbuffer->buffer_start + 5;
224 
225  assert_int_equal(amxc_rbuffer_shrink(rbuffer, 10), 0);
226  assert_ptr_not_equal(rbuffer->buffer_start, NULL);
227  assert_ptr_equal(rbuffer->buffer_end, rbuffer->buffer_start + 20);
228  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start + 15);
229  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 5);
230 
231  amxc_rbuffer_delete(&rbuffer);
232 }
233 
234 void amxc_rbuffer_shrink_write_before_read_data_loss_check(UNUSED void** state) {
235  amxc_rbuffer_t* rbuffer = NULL;
236 
237  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
238  rbuffer->read_pos = rbuffer->buffer_start + 15;
239  rbuffer->write_pos = rbuffer->buffer_start + 5;
240 
241  assert_int_equal(amxc_rbuffer_shrink(rbuffer, 15), 0);
242  assert_ptr_not_equal(rbuffer->buffer_start, NULL);
243  assert_ptr_equal(rbuffer->buffer_end, rbuffer->buffer_start + 15);
244  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start);
245  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 15);
246 
247  amxc_rbuffer_delete(&rbuffer);
248 
249  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
250  rbuffer->read_pos = rbuffer->buffer_start + 14;
251  rbuffer->write_pos = rbuffer->buffer_start + 5;
252 
253  assert_int_equal(amxc_rbuffer_shrink(rbuffer, 10), 0);
254  assert_ptr_not_equal(rbuffer->buffer_start, NULL);
255  assert_ptr_equal(rbuffer->buffer_end, rbuffer->buffer_start + 20);
256  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start + 4);
257  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 3);
258 
259  amxc_rbuffer_delete(&rbuffer);
260 }
261 
262 void amxc_rbuffer_shrink_full(UNUSED void** state) {
263  amxc_rbuffer_t* rbuffer = NULL;
264 
265  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
266  rbuffer->read_pos = rbuffer->buffer_start + 15;
267  rbuffer->write_pos = rbuffer->buffer_start + 5;
268 
269  assert_int_equal(amxc_rbuffer_shrink(rbuffer, 30), 0);
270  assert_ptr_equal(rbuffer->buffer_start, NULL);
271  assert_ptr_equal(rbuffer->buffer_end, NULL);
272  assert_ptr_equal(rbuffer->read_pos, NULL);
273  assert_ptr_equal(rbuffer->write_pos, NULL);
274 
275  amxc_rbuffer_delete(&rbuffer);
276 }
277 
278 void amxc_rbuffer_size_null_check(UNUSED void** state) {
279  // passing NULL pointers should not lead to segfault
280  assert_int_equal(amxc_rbuffer_size(NULL), 0);
281 }
282 
283 void amxc_rbuffer_size_check(UNUSED void** state) {
284  amxc_rbuffer_t* rbuffer = NULL;
285 
286  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
287  assert_int_equal(amxc_rbuffer_size(rbuffer), 0);
288 
289  rbuffer->read_pos = rbuffer->buffer_start + 10;
290  rbuffer->write_pos = rbuffer->buffer_start + 25;
291  assert_int_equal(amxc_rbuffer_size(rbuffer), 15);
292 
293  rbuffer->read_pos = rbuffer->buffer_start + 20;
294  rbuffer->write_pos = rbuffer->buffer_start + 5;
295  assert_int_equal(amxc_rbuffer_size(rbuffer), 15);
296 
297  amxc_rbuffer_delete(&rbuffer);
298 }
299 
300 void amxc_rbuffer_capacity_null_check(UNUSED void** state) {
301  // passing NULL pointers should not lead to segfault
302  assert_int_equal(amxc_rbuffer_capacity(NULL), 0);
303 }
304 
305 void amxc_rbuffer_capacity_check(UNUSED void** state) {
306  amxc_rbuffer_t* rbuffer = NULL;
307 
308  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
309  assert_int_equal(amxc_rbuffer_capacity(rbuffer), 30);
310 
311  amxc_rbuffer_grow(rbuffer, 10);
312  assert_int_equal(amxc_rbuffer_capacity(rbuffer), 40);
313 
314  amxc_rbuffer_shrink(rbuffer, 20);
315  assert_int_equal(amxc_rbuffer_capacity(rbuffer), 20);
316 
317  amxc_rbuffer_delete(&rbuffer);
318 }
319 
320 void amxc_rbuffer_is_empty_null_check(UNUSED void** state) {
321  // passing NULL pointers should not lead to segfault
322  assert_int_equal(amxc_rbuffer_is_empty(NULL), true);
323 }
324 
325 void amxc_rbuffer_is_empty_check(UNUSED void** state) {
326  amxc_rbuffer_t* rbuffer = NULL;
327 
328  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
329  assert_int_equal(amxc_rbuffer_is_empty(rbuffer), true);
330 
331  rbuffer->read_pos = rbuffer->buffer_start + 10;
332  rbuffer->write_pos = rbuffer->buffer_start + 10;
333  assert_int_equal(amxc_rbuffer_is_empty(rbuffer), true);
334 
335  rbuffer->write_pos = rbuffer->buffer_start + 15;
336  assert_int_equal(amxc_rbuffer_is_empty(rbuffer), false);
337 
338  rbuffer->read_pos = rbuffer->buffer_start + 10;
339  rbuffer->write_pos = rbuffer->buffer_start + 5;
340  assert_int_equal(amxc_rbuffer_is_empty(rbuffer), false);
341 
342  amxc_rbuffer_delete(&rbuffer);
343 }
344 
345 void amxc_rbuffer_write_null_check(UNUSED void** state) {
346  // passing NULL pointers should not lead to segfault
347  assert_int_equal(amxc_rbuffer_write(NULL, NULL, 0), -1);
348 }
349 
350 void amxc_rbuffer_write_buffer_empty_check(UNUSED void** state) {
351  amxc_rbuffer_t* rbuffer = NULL;
352  const char* data = "0123456789";
353 
354  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
355 
356  assert_int_equal(amxc_rbuffer_write(rbuffer, data, 5), 5);
357  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start);
358  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 5);
359  assert_int_equal(strncmp(rbuffer->buffer_start, data, 5), 0);
360 
361  assert_int_equal(amxc_rbuffer_write(rbuffer, data, 7), 7);
362  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start);
363  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 12);
364  assert_int_equal(strncmp(rbuffer->buffer_start, data, 5), 0);
365  assert_int_equal(strncmp(rbuffer->buffer_start + 5, data, 7), 0);
366 
367  amxc_rbuffer_delete(&rbuffer);
368 }
369 
370 void amxc_rbuffer_write_buffer_wrap_buffer_check(UNUSED void** state) {
371  amxc_rbuffer_t* rbuffer = NULL;
372  const char* data = "0123456789";
373 
374  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
375  rbuffer->read_pos = rbuffer->buffer_start + 25;
376  rbuffer->write_pos = rbuffer->buffer_start + 25;
377 
378  assert_int_equal(amxc_rbuffer_write(rbuffer, data, 10), 10);
379  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start + 25);
380  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 5);
381  assert_int_equal(strncmp(rbuffer->buffer_start + 25, data, 5), 0);
382  assert_int_equal(strncmp(rbuffer->buffer_start, data + 5, 5), 0);
383 
384  amxc_rbuffer_delete(&rbuffer);
385 }
386 
387 void amxc_rbuffer_write_buffer_need_to_grow_check(UNUSED void** state) {
388  amxc_rbuffer_t* rbuffer = NULL;
389  const char* data = "0123456789";
390 
391  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
392  rbuffer->read_pos = rbuffer->buffer_start + 1;
393  rbuffer->write_pos = rbuffer->buffer_start + 0;
394 
395  assert_int_equal(amxc_rbuffer_write(rbuffer, data, 10), 10);
396  assert_int_equal(amxc_rbuffer_capacity(rbuffer), 50);
397  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start + 21);
398  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 10);
399  assert_int_equal(strncmp(rbuffer->buffer_start, data, 10), 0);
400 
401  amxc_rbuffer_delete(&rbuffer);
402 }
403 
404 void amxc_rbuffer_read_null_check(UNUSED void** state) {
405  // passing NULL pointers should not lead to segfault
406  assert_int_equal(amxc_rbuffer_read(NULL, NULL, 10), -1);
407 
408  amxc_rbuffer_t* rbuffer = NULL;
409  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
410  assert_int_equal(amxc_rbuffer_read(rbuffer, NULL, 10), -1);
411  amxc_rbuffer_delete(&rbuffer);
412 }
413 
414 void amxc_rbuffer_read_buffer_empty_check(UNUSED void** state) {
415  amxc_rbuffer_t* rbuffer = NULL;
416  char buffer[10] = "";
417 
418  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
419 
420  assert_int_equal(amxc_rbuffer_read(rbuffer, buffer, 5), 0);
421  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start);
422  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start);
423 
424  amxc_rbuffer_delete(&rbuffer);
425 }
426 
427 void amxc_rbuffer_read_zero_bytes_check(UNUSED void** state) {
428  amxc_rbuffer_t* rbuffer = NULL;
429  const char* data = "0123456789";
430  char buffer[10] = "";
431 
432  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
433 
434  assert_int_equal(amxc_rbuffer_write(rbuffer, data, 10), 10);
435 
436  assert_int_equal(amxc_rbuffer_read(rbuffer, buffer, 0), 0);
437  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start);
438  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 10);
439 
440  amxc_rbuffer_delete(&rbuffer);
441 }
442 
443 void amxc_rbuffer_read_check(UNUSED void** state) {
444  amxc_rbuffer_t* rbuffer = NULL;
445  const char* data = "0123456789";
446  char buffer[10] = "";
447 
448  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
449 
450  assert_int_equal(amxc_rbuffer_write(rbuffer, data, 10), 10);
451 
452  assert_int_equal(amxc_rbuffer_read(rbuffer, buffer, 5), 5);
453  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start + 5);
454  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 10);
455  assert_int_equal(strncmp(buffer, data, 5), 0);
456 
457  assert_int_equal(amxc_rbuffer_read(rbuffer, buffer, 5), 5);
458  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start + 10);
459  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 10);
460  assert_int_equal(strncmp(buffer, data + 5, 5), 0);
461 
462  assert_int_equal(amxc_rbuffer_read(rbuffer, buffer, 5), 0);
463  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start + 10);
464  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 10);
465 
466  amxc_rbuffer_delete(&rbuffer);
467 }
468 
469 void amxc_rbuffer_read_short_check(UNUSED void** state) {
470  amxc_rbuffer_t* rbuffer = NULL;
471  const char* data = "0123456789";
472  char buffer[30] = "";
473 
474  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
475 
476  assert_int_equal(amxc_rbuffer_write(rbuffer, data, 10), 10);
477  assert_int_equal(amxc_rbuffer_write(rbuffer, data, 10), 10);
478 
479  assert_int_equal(amxc_rbuffer_read(rbuffer, buffer, 30), 20);
480  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start + 20);
481  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 20);
482  assert_int_equal(strncmp(buffer, data, 10), 0);
483  assert_int_equal(strncmp(buffer + 10, data, 10), 0);
484 
485  rbuffer->read_pos = rbuffer->buffer_start + 15;
486  rbuffer->write_pos = rbuffer->buffer_start + 15;
487  assert_int_equal(amxc_rbuffer_write(rbuffer, data, 10), 10);
488  assert_int_equal(amxc_rbuffer_write(rbuffer, data, 10), 10);
489 
490  assert_int_equal(amxc_rbuffer_read(rbuffer, buffer, 10), 10);
491  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start + 25);
492  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 5);
493  assert_int_equal(strncmp(buffer, data, 10), 0);
494 
495  amxc_rbuffer_delete(&rbuffer);
496 }
497 
498 void amxc_rbuffer_read_wrap_check(UNUSED void** state) {
499  amxc_rbuffer_t* rbuffer = NULL;
500  const char* data = "0123456789";
501  char buffer[10] = "";
502 
503  assert_int_equal(amxc_rbuffer_new(&rbuffer, 30), 0);
504  rbuffer->read_pos = rbuffer->buffer_start + 25;
505  rbuffer->write_pos = rbuffer->buffer_start + 25;
506 
507  assert_int_equal(amxc_rbuffer_write(rbuffer, data, 10), 10);
508  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start + 25);
509  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 5);
510 
511  assert_int_equal(amxc_rbuffer_read(rbuffer, buffer, 10), 10);
512  assert_ptr_equal(rbuffer->read_pos, rbuffer->buffer_start + 5);
513  assert_ptr_equal(rbuffer->write_pos, rbuffer->buffer_start + 5);
514  assert_int_equal(strncmp(buffer, data, 10), 0);
515 
516  amxc_rbuffer_delete(&rbuffer);
517 }
amxc_macros.h
UNUSED
#define UNUSED
Definition: amxc_macros.h:70
amxc_rbuffer.h
Ambiorix ring buffer API header file.
amxc_rbuffer_size
size_t amxc_rbuffer_size(const amxc_rbuffer_t *const rb)
Get the size of the data stored in the ring buffer.
Definition: amxc_rbuffer.c:327
amxc_rbuffer_shrink
int amxc_rbuffer_shrink(amxc_rbuffer_t *const rb, const size_t size)
Shrinks the ring buffer.
Definition: amxc_rbuffer.c:190
amxc_rbuffer_clean
void amxc_rbuffer_clean(amxc_rbuffer_t *const rb)
Frees the buffer and sets all pointers of the ring buffer structure to NULL.
Definition: amxc_rbuffer.c:134
amxc_rbuffer_write
ssize_t amxc_rbuffer_write(amxc_rbuffer_t *const rb, const char *const buf, const size_t count)
Writes a number of bytes to the ring buffer.
Definition: amxc_rbuffer.c:292
amxc_rbuffer_new
int amxc_rbuffer_new(amxc_rbuffer_t **rb, const size_t size)
Allocates a ring buffer.
Definition: amxc_rbuffer.c:79
amxc_rbuffer_grow
int amxc_rbuffer_grow(amxc_rbuffer_t *const rb, const size_t size)
Grows the ring buffer.
Definition: amxc_rbuffer.c:147
amxc_rbuffer_capacity
AMXC_INLINE size_t amxc_rbuffer_capacity(const amxc_rbuffer_t *const rb)
Get the capacity of the ring buffer.
Definition: amxc_rbuffer.h:286
amxc_rbuffer_delete
void amxc_rbuffer_delete(amxc_rbuffer_t **rb)
Frees the previously allocated ring buffer.
Definition: amxc_rbuffer.c:96
amxc_rbuffer_is_empty
AMXC_INLINE bool amxc_rbuffer_is_empty(const amxc_rbuffer_t *const rb)
Checks that the ring buffer is empty.
Definition: amxc_rbuffer.h:302
amxc_rbuffer_init
int amxc_rbuffer_init(amxc_rbuffer_t *const rb, const size_t size)
Initializes a ring buffer.
Definition: amxc_rbuffer.c:107
amxc_rbuffer_read
ssize_t amxc_rbuffer_read(amxc_rbuffer_t *const rb, char *const buf, size_t count)
Reads a number of bytes from the ring buffer.
Definition: amxc_rbuffer.c:250
_amxc_rbuffer
The ring buffer structure.
Definition: amxc_rbuffer.h:84
_amxc_rbuffer::buffer_end
char * buffer_end
Definition: amxc_rbuffer.h:86
_amxc_rbuffer::buffer_start
char * buffer_start
Definition: amxc_rbuffer.h:85
_amxc_rbuffer::write_pos
char * write_pos
Definition: amxc_rbuffer.h:88
_amxc_rbuffer::read_pos
char * read_pos
Definition: amxc_rbuffer.h:87
amxc_rbuffer_grow_write_before_read_check
void amxc_rbuffer_grow_write_before_read_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:154
amxc_rbuffer_is_empty_null_check
void amxc_rbuffer_is_empty_null_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:320
amxc_rbuffer_new_delete_null_check
void amxc_rbuffer_new_delete_null_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:66
amxc_rbuffer_capacity_check
void amxc_rbuffer_capacity_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:305
amxc_rbuffer_new_delete_check
void amxc_rbuffer_new_delete_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:72
amxc_rbuffer_is_empty_check
void amxc_rbuffer_is_empty_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:325
amxc_rbuffer_init_clean_check
void amxc_rbuffer_init_clean_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:102
amxc_rbuffer_size_check
void amxc_rbuffer_size_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:283
amxc_rbuffer_shrink_write_before_read_data_loss_check
void amxc_rbuffer_shrink_write_before_read_data_loss_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:234
amxc_rbuffer_shrink_read_before_write_data_loss_check
void amxc_rbuffer_shrink_read_before_write_data_loss_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:202
amxc_rbuffer_read_null_check
void amxc_rbuffer_read_null_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:404
amxc_rbuffer_shrink_read_before_write_check
void amxc_rbuffer_shrink_read_before_write_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:186
amxc_rbuffer_read_short_check
void amxc_rbuffer_read_short_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:469
amxc_rbuffer_read_wrap_check
void amxc_rbuffer_read_wrap_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:498
amxc_rbuffer_shrink_full
void amxc_rbuffer_shrink_full(UNUSED void **state)
Definition: test_amx_rbuffer.c:262
amxc_rbuffer_grow_check
void amxc_rbuffer_grow_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:124
amxc_rbuffer_capacity_null_check
void amxc_rbuffer_capacity_null_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:300
amxc_rbuffer_read_check
void amxc_rbuffer_read_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:443
amxc_rbuffer_grow_shrink_null_check
void amxc_rbuffer_grow_shrink_null_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:118
amxc_rbuffer_shrink_write_before_read_check
void amxc_rbuffer_shrink_write_before_read_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:218
amxc_rbuffer_write_buffer_empty_check
void amxc_rbuffer_write_buffer_empty_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:350
amxc_rbuffer_init_clean_null_check
void amxc_rbuffer_init_clean_null_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:96
amxc_rbuffer_grow_read_before_write_check
void amxc_rbuffer_grow_read_before_write_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:138
amxc_rbuffer_write_buffer_need_to_grow_check
void amxc_rbuffer_write_buffer_need_to_grow_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:387
amxc_rbuffer_read_buffer_empty_check
void amxc_rbuffer_read_buffer_empty_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:414
amxc_rbuffer_size_null_check
void amxc_rbuffer_size_null_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:278
amxc_rbuffer_read_zero_bytes_check
void amxc_rbuffer_read_zero_bytes_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:427
amxc_rbuffer_write_buffer_wrap_buffer_check
void amxc_rbuffer_write_buffer_wrap_buffer_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:370
amxc_rbuffer_write_null_check
void amxc_rbuffer_write_null_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:345
amxc_rbuffer_shrink_check
void amxc_rbuffer_shrink_check(UNUSED void **state)
Definition: test_amx_rbuffer.c:170
data
char data[]
Definition: test_amxc_array.c:69
test_amxc_rbuffer.h