libamxc  1.10.3
C Generic Data Containers
Functions
test_amx_rbuffer.c File Reference
#include <stdlib.h>
#include <stdio.h>
#include <setjmp.h>
#include <string.h>
#include <cmocka.h>
#include <amxc/amxc_rbuffer.h>
#include "test_amxc_rbuffer.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

void amxc_rbuffer_new_delete_null_check (UNUSED void **state)
 
void amxc_rbuffer_new_delete_check (UNUSED void **state)
 
void amxc_rbuffer_init_clean_null_check (UNUSED void **state)
 
void amxc_rbuffer_init_clean_check (UNUSED void **state)
 
void amxc_rbuffer_grow_shrink_null_check (UNUSED void **state)
 
void amxc_rbuffer_grow_check (UNUSED void **state)
 
void amxc_rbuffer_grow_read_before_write_check (UNUSED void **state)
 
void amxc_rbuffer_grow_write_before_read_check (UNUSED void **state)
 
void amxc_rbuffer_shrink_check (UNUSED void **state)
 
void amxc_rbuffer_shrink_read_before_write_check (UNUSED void **state)
 
void amxc_rbuffer_shrink_read_before_write_data_loss_check (UNUSED void **state)
 
void amxc_rbuffer_shrink_write_before_read_check (UNUSED void **state)
 
void amxc_rbuffer_shrink_write_before_read_data_loss_check (UNUSED void **state)
 
void amxc_rbuffer_shrink_full (UNUSED void **state)
 
void amxc_rbuffer_size_null_check (UNUSED void **state)
 
void amxc_rbuffer_size_check (UNUSED void **state)
 
void amxc_rbuffer_capacity_null_check (UNUSED void **state)
 
void amxc_rbuffer_capacity_check (UNUSED void **state)
 
void amxc_rbuffer_is_empty_null_check (UNUSED void **state)
 
void amxc_rbuffer_is_empty_check (UNUSED void **state)
 
void amxc_rbuffer_write_null_check (UNUSED void **state)
 
void amxc_rbuffer_write_buffer_empty_check (UNUSED void **state)
 
void amxc_rbuffer_write_buffer_wrap_buffer_check (UNUSED void **state)
 
void amxc_rbuffer_write_buffer_need_to_grow_check (UNUSED void **state)
 
void amxc_rbuffer_read_null_check (UNUSED void **state)
 
void amxc_rbuffer_read_buffer_empty_check (UNUSED void **state)
 
void amxc_rbuffer_read_zero_bytes_check (UNUSED void **state)
 
void amxc_rbuffer_read_check (UNUSED void **state)
 
void amxc_rbuffer_read_short_check (UNUSED void **state)
 
void amxc_rbuffer_read_wrap_check (UNUSED void **state)
 

Function Documentation

◆ amxc_rbuffer_capacity_check()

void amxc_rbuffer_capacity_check ( UNUSED void **  state)

Definition at line 305 of file test_amx_rbuffer.c.

305  {
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 }
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_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
The ring buffer structure.
Definition: amxc_rbuffer.h:84

◆ amxc_rbuffer_capacity_null_check()

void amxc_rbuffer_capacity_null_check ( UNUSED void **  state)

Definition at line 300 of file test_amx_rbuffer.c.

300  {
301  // passing NULL pointers should not lead to segfault
302  assert_int_equal(amxc_rbuffer_capacity(NULL), 0);
303 }

◆ amxc_rbuffer_grow_check()

void amxc_rbuffer_grow_check ( UNUSED void **  state)

Definition at line 124 of file test_amx_rbuffer.c.

124  {
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 }
_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_read_before_write_check()

void amxc_rbuffer_grow_read_before_write_check ( UNUSED void **  state)

Definition at line 138 of file test_amx_rbuffer.c.

138  {
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 }

◆ amxc_rbuffer_grow_shrink_null_check()

void amxc_rbuffer_grow_shrink_null_check ( UNUSED void **  state)

Definition at line 118 of file test_amx_rbuffer.c.

118  {
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 }

◆ amxc_rbuffer_grow_write_before_read_check()

void amxc_rbuffer_grow_write_before_read_check ( UNUSED void **  state)

Definition at line 154 of file test_amx_rbuffer.c.

154  {
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 }

◆ amxc_rbuffer_init_clean_check()

void amxc_rbuffer_init_clean_check ( UNUSED void **  state)

Definition at line 102 of file test_amx_rbuffer.c.

102  {
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 }
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_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_init_clean_null_check()

void amxc_rbuffer_init_clean_null_check ( UNUSED void **  state)

Definition at line 96 of file test_amx_rbuffer.c.

96  {
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 }

◆ amxc_rbuffer_is_empty_check()

void amxc_rbuffer_is_empty_check ( UNUSED void **  state)

Definition at line 325 of file test_amx_rbuffer.c.

325  {
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 }
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_is_empty_null_check()

void amxc_rbuffer_is_empty_null_check ( UNUSED void **  state)

Definition at line 320 of file test_amx_rbuffer.c.

320  {
321  // passing NULL pointers should not lead to segfault
322  assert_int_equal(amxc_rbuffer_is_empty(NULL), true);
323 }

◆ amxc_rbuffer_new_delete_check()

void amxc_rbuffer_new_delete_check ( UNUSED void **  state)

Definition at line 72 of file test_amx_rbuffer.c.

72  {
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 }

◆ amxc_rbuffer_new_delete_null_check()

void amxc_rbuffer_new_delete_null_check ( UNUSED void **  state)

Definition at line 66 of file test_amx_rbuffer.c.

66  {
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 }

◆ amxc_rbuffer_read_buffer_empty_check()

void amxc_rbuffer_read_buffer_empty_check ( UNUSED void **  state)

Definition at line 414 of file test_amx_rbuffer.c.

414  {
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 }
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_read_check()

void amxc_rbuffer_read_check ( UNUSED void **  state)

Definition at line 443 of file test_amx_rbuffer.c.

443  {
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 }
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
data
char data[]
Definition: test_amxc_array.c:69

◆ amxc_rbuffer_read_null_check()

void amxc_rbuffer_read_null_check ( UNUSED void **  state)

Definition at line 404 of file test_amx_rbuffer.c.

404  {
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 }

◆ amxc_rbuffer_read_short_check()

void amxc_rbuffer_read_short_check ( UNUSED void **  state)

Definition at line 469 of file test_amx_rbuffer.c.

469  {
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 }

◆ amxc_rbuffer_read_wrap_check()

void amxc_rbuffer_read_wrap_check ( UNUSED void **  state)

Definition at line 498 of file test_amx_rbuffer.c.

498  {
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_rbuffer_read_zero_bytes_check()

void amxc_rbuffer_read_zero_bytes_check ( UNUSED void **  state)

Definition at line 427 of file test_amx_rbuffer.c.

427  {
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 }

◆ amxc_rbuffer_shrink_check()

void amxc_rbuffer_shrink_check ( UNUSED void **  state)

Definition at line 170 of file test_amx_rbuffer.c.

170  {
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 }

◆ amxc_rbuffer_shrink_full()

void amxc_rbuffer_shrink_full ( UNUSED void **  state)

Definition at line 262 of file test_amx_rbuffer.c.

262  {
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 }

◆ amxc_rbuffer_shrink_read_before_write_check()

void amxc_rbuffer_shrink_read_before_write_check ( UNUSED void **  state)

Definition at line 186 of file test_amx_rbuffer.c.

186  {
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 }

◆ amxc_rbuffer_shrink_read_before_write_data_loss_check()

void amxc_rbuffer_shrink_read_before_write_data_loss_check ( UNUSED void **  state)

Definition at line 202 of file test_amx_rbuffer.c.

202  {
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 }

◆ amxc_rbuffer_shrink_write_before_read_check()

void amxc_rbuffer_shrink_write_before_read_check ( UNUSED void **  state)

Definition at line 218 of file test_amx_rbuffer.c.

218  {
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 }

◆ amxc_rbuffer_shrink_write_before_read_data_loss_check()

void amxc_rbuffer_shrink_write_before_read_data_loss_check ( UNUSED void **  state)

Definition at line 234 of file test_amx_rbuffer.c.

234  {
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 }

◆ amxc_rbuffer_size_check()

void amxc_rbuffer_size_check ( UNUSED void **  state)

Definition at line 283 of file test_amx_rbuffer.c.

283  {
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 }
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_size_null_check()

void amxc_rbuffer_size_null_check ( UNUSED void **  state)

Definition at line 278 of file test_amx_rbuffer.c.

278  {
279  // passing NULL pointers should not lead to segfault
280  assert_int_equal(amxc_rbuffer_size(NULL), 0);
281 }

◆ amxc_rbuffer_write_buffer_empty_check()

void amxc_rbuffer_write_buffer_empty_check ( UNUSED void **  state)

Definition at line 350 of file test_amx_rbuffer.c.

350  {
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 }

◆ amxc_rbuffer_write_buffer_need_to_grow_check()

void amxc_rbuffer_write_buffer_need_to_grow_check ( UNUSED void **  state)

Definition at line 387 of file test_amx_rbuffer.c.

387  {
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 }

◆ amxc_rbuffer_write_buffer_wrap_buffer_check()

void amxc_rbuffer_write_buffer_wrap_buffer_check ( UNUSED void **  state)

Definition at line 370 of file test_amx_rbuffer.c.

370  {
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 }

◆ amxc_rbuffer_write_null_check()

void amxc_rbuffer_write_null_check ( UNUSED void **  state)

Definition at line 345 of file test_amx_rbuffer.c.

345  {
346  // passing NULL pointers should not lead to segfault
347  assert_int_equal(amxc_rbuffer_write(NULL, NULL, 0), -1);
348 }