The FreeRADIUS server $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
Loading...
Searching...
No Matches
edit_tests.c
Go to the documentation of this file.
1/*
2 * This library is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU Lesser General Public
4 * License as published by the Free Software Foundation; either
5 * version 2.1 of the License, or (at your option) any later version.
6 *
7 * This library is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
10 * Lesser General Public License for more details.
11 *
12 * You should have received a copy of the GNU Lesser General Public
13 * License along with this library; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
15 */
16
17/** Tests for a AVP manipulation and search API.
18 *
19 * @file src/lib/util/test//edit_tests.c
20 * @author Alan DeKok (aland@networkradius.com)
21 * @copyright 2021 Network RADIUS SAS (legal@networkradius.com)
22 */
23
24/**
25 * The 'TEST_INIT' macro provided by 'acutest.h' allowing to register a function to be called
26 * before call the unit tests. Therefore, It calls the function ALL THE TIME causing an overhead.
27 * That is why we are initializing test_init() by "__attribute__((constructor));" reducing the
28 * test execution by 50% of the time.
29 */
30#define USE_CONSTRUCTOR
31
32/*
33 * It should be declared before include the "acutest.h"
34 */
35#ifdef USE_CONSTRUCTOR
36static void test_init(void) __attribute__((constructor));
37#else
38static void test_init(void);
39# define TEST_INIT test_init()
40#endif
41
42#include "acutest.h"
43#include"acutest_helpers.h"
44#include "pair_test_helpers.h"
45
46#include <freeradius-devel/util/conf.h>
47#include <freeradius-devel/util/dict.h>
48#include <freeradius-devel/util/edit.h>
49
50#ifdef HAVE_GPERFTOOLS_PROFILER_H
51# include <gperftools/profiler.h>
52#endif
53
54static TALLOC_CTX *autofree;
55static fr_pair_list_t test_pairs;
56static fr_dict_t *test_dict;
57
58/** Global initialisation
59 */
60static void test_init(void)
61{
62 autofree = talloc_autofree_context();
63 if (!autofree) {
64 error:
65 fr_perror("edit_tests");
66 fr_exit_now(EXIT_FAILURE);
67 }
68
69 /*
70 * Mismatch between the binary and the libraries it depends on
71 */
72 if (fr_check_lib_magic(RADIUSD_MAGIC_NUMBER) < 0) goto error;
73
74 if (fr_dict_test_init(autofree, &test_dict, NULL) < 0) goto error;
75
76 /* Initialize the "test_pairs" list */
77 fr_pair_list_init(&test_pairs);
78
79 if (fr_pair_test_list_alloc(autofree, &test_pairs, NULL) < 0) goto error;
80}
81
105
106static void expect3(fr_pair_list_t *local_pairs)
107{
108 int count;
109 fr_pair_t *vp;
110
111 count = fr_pair_list_num_elements(local_pairs);
112 TEST_CASE("Expected (count == 3) after undoing the edits");
113 TEST_CHECK(count == 3);
114
115 vp = fr_pair_list_head(local_pairs);
116 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
117
118 vp = fr_pair_list_tail(local_pairs);
119 TEST_CHECK(vp->da == fr_dict_attr_test_tlv);
120
121 fr_pair_list_free(local_pairs);
122}
123
124/*
125 * Tests functions
126 */
127static void test_pair_delete_head(void)
128{
129 fr_pair_t *vp;
130 fr_pair_list_t local_pairs;
131 size_t count;
132 fr_edit_list_t *el;
133 int rcode;
134
135 TEST_CASE("Add 3 pairs and delete the first one");
136
137 add_pairs(&local_pairs);
138
139 vp = fr_pair_list_head(&local_pairs);
140
141 el = fr_edit_list_alloc(NULL, 5, NULL);
142 fr_assert(el != NULL);
143
144 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp);
145 TEST_CHECK(rcode == 0);
146
147 fr_edit_list_commit(el);
148
149 count = fr_pair_list_num_elements(&local_pairs);
150 TEST_CASE("Expected (count == 2) after deleting the head");
151 TEST_CHECK(count == 2);
152
153 vp = fr_pair_list_head(&local_pairs);
154 TEST_CASE("head is now what was the second pair");
155 TEST_CHECK(vp->da == fr_dict_attr_test_octets);
156
157 fr_pair_list_free(&local_pairs);
158}
159
160static void test_pair_delete_head_abort(void)
161{
162 fr_pair_t *vp;
163 fr_pair_list_t local_pairs;
164 size_t count;
165 fr_edit_list_t *el;
166 int rcode;
167
168 TEST_CASE("Add 3 pairs and delete the first one");
169
170 add_pairs(&local_pairs);
171
172 vp = fr_pair_list_head(&local_pairs);
173
174 el = fr_edit_list_alloc(NULL, 5, NULL);
175 fr_assert(el != NULL);
176
177 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp);
178 TEST_CHECK(rcode == 0);
179
180 count = fr_pair_list_num_elements(&local_pairs);
181 TEST_CASE("Expected (count == 2) after deleting the head");
182 TEST_CHECK(count == 2);
183
184 /*
185 * Abort the edit
186 */
187 fr_edit_list_abort(el);
188
189 expect3(&local_pairs);
190}
191
192static void test_pair_delete_middle(void)
193{
194 fr_pair_t *vp;
195 fr_pair_list_t local_pairs;
196 size_t count;
197 fr_edit_list_t *el;
198 int rcode;
199
200 TEST_CASE("Add 3 pairs and delete the middle one");
201
202 add_pairs(&local_pairs);
203
204 vp = fr_pair_list_head(&local_pairs);
205 vp = fr_pair_list_next(&local_pairs, vp);
206 fr_assert(vp != NULL);
207
208 el = fr_edit_list_alloc(NULL, 5, NULL);
209 fr_assert(el != NULL);
210
211 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp);
212 TEST_CHECK(rcode == 0);
213
214 fr_edit_list_commit(el);
215
216 /* let's count */
217 count = fr_pair_list_num_elements(&local_pairs);
218 TEST_CASE("Expected (count == 2) after deleting the middle");
219 TEST_CHECK(count == 2);
220
221 vp = fr_pair_list_head(&local_pairs);
222 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
223
224 vp = fr_pair_list_tail(&local_pairs);
225 TEST_CHECK(vp->da == fr_dict_attr_test_tlv);
226
227 fr_pair_list_free(&local_pairs);
228}
229
230static void test_pair_delete_middle_abort(void)
231{
232 fr_pair_t *vp, *middle;
233 fr_pair_list_t local_pairs;
234 size_t count;
235 fr_edit_list_t *el;
236 int rcode;
237
238 TEST_CASE("Add 3 pairs and delete the middle one, then abort");
239
240 add_pairs(&local_pairs);
241
242 vp = fr_pair_list_head(&local_pairs);
243 middle = fr_pair_list_next(&local_pairs, vp);
244 fr_assert(middle != NULL);
245 TEST_CHECK(middle->da == fr_dict_attr_test_octets);
246
247 el = fr_edit_list_alloc(NULL, 5, NULL);
248 fr_assert(el != NULL);
249
250 rcode = fr_edit_list_pair_delete(el, &local_pairs, middle);
251 TEST_CHECK(rcode == 0);
252
253 count = fr_pair_list_num_elements(&local_pairs);
254 TEST_CASE("Expected (count == 2) after deleting the middle");
255 TEST_CHECK(count == 2);
256
257 vp = fr_pair_list_head(&local_pairs);
258 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
259
260 vp = fr_pair_list_tail(&local_pairs);
261 TEST_CHECK(vp->da == fr_dict_attr_test_tlv);
262
263 /*
264 * Abort the edit
265 */
266 fr_edit_list_abort(el);
267
268 expect3(&local_pairs);
269}
270
271static void test_pair_delete_multiple(void)
272{
273 fr_pair_t *vp;
274 fr_pair_list_t local_pairs;
275 size_t count;
276 fr_edit_list_t *el;
277 int rcode;
278
279 TEST_CASE("Add 3 pairs and delete the last 2");
280
281 add_pairs(&local_pairs);
282
283 vp = fr_pair_list_head(&local_pairs);
284 vp = fr_pair_list_next(&local_pairs, vp);
285 fr_assert(vp != NULL);
286
287 el = fr_edit_list_alloc(NULL, 5, NULL);
288 fr_assert(el != NULL);
289
290 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp); /* middle */
291 TEST_CHECK(rcode == 0);
292
293 vp = fr_pair_list_tail(&local_pairs);
294 fr_assert(vp != NULL);
295
296 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp); /* tail */
297 TEST_CHECK(rcode == 0);
298
299 fr_edit_list_commit(el);
300
301 count = fr_pair_list_num_elements(&local_pairs);
302 TEST_CASE("Expected (count == 1) after deleting the last 2");
303 TEST_CHECK(count == 1);
304
305 vp = fr_pair_list_head(&local_pairs);
306 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
307
308 vp = fr_pair_list_tail(&local_pairs);
309 TEST_CHECK(vp->da == fr_dict_attr_test_uint32); /* head == tail */
310
311 fr_pair_list_free(&local_pairs);
312}
313
314static void test_pair_delete_multiple_abort(void)
315{
316 fr_pair_t *vp;
317 fr_pair_list_t local_pairs;
318 size_t count;
319 fr_edit_list_t *el;
320 int rcode;
321
322 TEST_CASE("Add 3 pairs and delete the last two, then abort");
323
324 add_pairs(&local_pairs);
325
326 vp = fr_pair_list_head(&local_pairs);
327 fr_assert(vp != NULL);
328 vp = fr_pair_list_next(&local_pairs, vp);
329 fr_assert(vp != NULL);
330 TEST_CHECK(vp->da == fr_dict_attr_test_octets);
331
332 el = fr_edit_list_alloc(NULL, 5, NULL);
333 fr_assert(el != NULL);
334
335 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp); /* middle */
336 TEST_CHECK(rcode == 0);
337
338 vp = fr_pair_list_tail(&local_pairs);
339 fr_assert(vp != NULL);
340
341 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp); /* tail */
342 TEST_CHECK(rcode == 0);
343
344 count = fr_pair_list_num_elements(&local_pairs);
345 TEST_CASE("Expected (count == 1) after deleting the last 2");
346 TEST_CHECK(count == 1);
347
348 vp = fr_pair_list_head(&local_pairs);
349 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
350
351 vp = fr_pair_list_tail(&local_pairs);
352 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
353
354 /*
355 * Abort the edit
356 */
357 fr_edit_list_abort(el);
358
359 expect3(&local_pairs);
360}
361
362
363static void test_pair_edit_value(void)
364{
365 fr_pair_t *vp;
366 fr_pair_list_t local_pairs;
367 fr_edit_list_t *el;
368 int rcode;
369
370 TEST_CASE("Add 3 pairs and change the value of the first one");
371
372 add_pairs(&local_pairs);
373
374 vp = fr_pair_list_head(&local_pairs);
375 fr_assert(vp != NULL);
376
377 el = fr_edit_list_alloc(NULL, 5, NULL);
378 fr_assert(el != NULL);
379
380 rcode = fr_edit_list_save_pair_value(el, vp);
381 TEST_CHECK(rcode == 0);
382
383 TEST_CHECK(vp->vp_uint32 == 0);
384
385 vp->vp_uint32 = 1;
386 TEST_CHECK(vp->vp_uint32 == 1);
387
388 fr_edit_list_commit(el);
389
390 vp = fr_pair_list_head(&local_pairs);
391 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
392 TEST_CHECK(vp->vp_uint32 == 1);
393
394 expect3(&local_pairs);
395}
396
397static void test_pair_edit_value_abort(void)
398{
399 fr_pair_t *vp;
400 fr_pair_list_t local_pairs;
401 fr_edit_list_t *el;
402 int rcode;
403
404 TEST_CASE("Add 3 pairs and change the value of the first one, then abort");
405
406 add_pairs(&local_pairs);
407
408 vp = fr_pair_list_head(&local_pairs);
409 fr_assert(vp != NULL);
410
411 el = fr_edit_list_alloc(NULL, 5, NULL);
412 fr_assert(el != NULL);
413
414 rcode = fr_edit_list_save_pair_value(el, vp);
415 TEST_CHECK(rcode == 0);
416
417 TEST_CHECK(vp->vp_uint32 == 0);
418
419 vp->vp_uint32 = 1;
420 TEST_CHECK(vp->vp_uint32 == 1);
421
422 /*
423 * Abort the edit
424 */
425 fr_edit_list_abort(el);
426
427 vp = fr_pair_list_head(&local_pairs);
428 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
429 TEST_CHECK(vp->vp_uint32 == 0);
430
431 expect3(&local_pairs);
432}
433
434static void test_pair_insert_after_head(void)
435{
436 fr_pair_t *vp;
437 fr_pair_list_t local_pairs;
438 size_t count;
439 fr_edit_list_t *el;
440 int rcode;
441
442 TEST_CASE("Add 3 pairs and insert a new one at the head");
443
444 add_pairs(&local_pairs);
445
446 el = fr_edit_list_alloc(NULL, 5, NULL);
447 fr_assert(el != NULL);
448
449 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string);
450 fr_assert(vp != NULL);
451 rcode = fr_edit_list_insert_pair_after(el, &local_pairs, NULL, vp);
452 TEST_CHECK(rcode == 0);
453
454 fr_edit_list_commit(el);
455
456 count = fr_pair_list_num_elements(&local_pairs);
457 TEST_CASE("Expected (count == 4) after inserting a new one");
458 TEST_CHECK(count == 4);
459
460 vp = fr_pair_list_head(&local_pairs);
461 TEST_CASE("head is now what was the second pair");
462 TEST_CHECK(vp->da == fr_dict_attr_test_string);
463
464 fr_pair_list_free(&local_pairs);
465}
466
467static void test_pair_insert_after_head_abort(void)
468{
469 fr_pair_t *vp;
470 fr_pair_list_t local_pairs;
471 size_t count;
472 fr_edit_list_t *el;
473 int rcode;
474
475 TEST_CASE("Add 3 pairs and insert a new one at the head, then abort");
476
477 add_pairs(&local_pairs);
478
479 el = fr_edit_list_alloc(NULL, 5, NULL);
480 fr_assert(el != NULL);
481
482 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string);
483 fr_assert(vp != NULL);
484 rcode = fr_edit_list_insert_pair_after(el, &local_pairs, NULL, vp);
485 TEST_CHECK(rcode == 0);
486
487 count = fr_pair_list_num_elements(&local_pairs);
488 TEST_CASE("Expected (count == 4) after inserting a new one");
489 TEST_CHECK(count == 4);
490
491 /*
492 * Abort the edit
493 */
494 fr_edit_list_abort(el);
495
496 expect3(&local_pairs);
497}
498
499static void test_pair_insert_after_middle(void)
500{
501 fr_pair_t *vp, *middle;
502 fr_pair_list_t local_pairs;
503 size_t count;
504 fr_edit_list_t *el;
505 int rcode;
506
507 TEST_CASE("Add 3 pairs and insert a new one at the head");
508
509 add_pairs(&local_pairs);
510
511 vp = fr_pair_list_head(&local_pairs);
512 middle = fr_pair_list_next(&local_pairs, vp);
513 fr_assert(middle != NULL);
514
515 el = fr_edit_list_alloc(NULL, 5, NULL);
516 fr_assert(el != NULL);
517
518 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string);
519 fr_assert(vp != NULL);
520 rcode = fr_edit_list_insert_pair_after(el, &local_pairs, middle, vp);
521 TEST_CHECK(rcode == 0);
522
523 fr_edit_list_commit(el);
524
525 count = fr_pair_list_num_elements(&local_pairs);
526 TEST_CASE("Expected (count == 4) after inserting a new one");
527 TEST_CHECK(count == 4);
528
529 fr_pair_list_free(&local_pairs);
530}
531
532static void test_pair_insert_after_middle_abort(void)
533{
534 fr_pair_t *vp, *middle;
535 fr_pair_list_t local_pairs;
536 size_t count;
537 fr_edit_list_t *el;
538 int rcode;
539
540 TEST_CASE("Add 3 pairs and insert a new one at the head, then abort");
541
542 add_pairs(&local_pairs);
543
544 vp = fr_pair_list_head(&local_pairs);
545 middle = fr_pair_list_next(&local_pairs, vp);
546 fr_assert(middle != NULL);
547
548 el = fr_edit_list_alloc(NULL, 5, NULL);
549 fr_assert(el != NULL);
550
551 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string);
552 fr_assert(vp != NULL);
553 rcode = fr_edit_list_insert_pair_after(el, &local_pairs, middle, vp);
554 TEST_CHECK(rcode == 0);
555
556 count = fr_pair_list_num_elements(&local_pairs);
557 TEST_CASE("Expected (count == 4) after inserting a new one");
558 TEST_CHECK(count == 4);
559
560 /*
561 * Abort the edit
562 */
563 fr_edit_list_abort(el);
564
565 expect3(&local_pairs);
566}
567
568static void test_pair_edit_value_delete(void)
569{
570 fr_pair_t *vp;
571 fr_pair_list_t local_pairs;
572 fr_edit_list_t *el;
573 int rcode, count;
574
575 TEST_CASE("Add 3 pairs, change the value of the first one, and delete it");
576
577 add_pairs(&local_pairs);
578
579 vp = fr_pair_list_head(&local_pairs);
580 fr_assert(vp != NULL);
581
582 el = fr_edit_list_alloc(NULL, 5, NULL);
583 fr_assert(el != NULL);
584
585 rcode = fr_edit_list_save_pair_value(el, vp);
586 TEST_CHECK(rcode == 0);
587
588 TEST_CHECK(vp->vp_uint32 == 0);
589
590 vp->vp_uint32 = 1;
591 TEST_CHECK(vp->vp_uint32 == 1);
592
593 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp);
594 TEST_CHECK(rcode == 0);
595
596 fr_edit_list_commit(el);
597
598 vp = fr_pair_list_head(&local_pairs);
599 TEST_CHECK(vp->da == fr_dict_attr_test_octets);
600
601 count = fr_pair_list_num_elements(&local_pairs);
602 TEST_CASE("Expected (count == 2) after deleting the edited pair");
603 TEST_CHECK(count == 2);
604}
605
606static void test_pair_edit_value_delete_abort(void)
607{
608 fr_pair_t *vp;
609 fr_pair_list_t local_pairs;
610 fr_edit_list_t *el;
611 int rcode;
612
613 TEST_CASE("Add 3 pairs, change the value of the first one, and delete it, then abort");
614
615 add_pairs(&local_pairs);
616
617 vp = fr_pair_list_head(&local_pairs);
618 fr_assert(vp != NULL);
619
620 el = fr_edit_list_alloc(NULL, 5, NULL);
621 fr_assert(el != NULL);
622
623 rcode = fr_edit_list_save_pair_value(el, vp);
624 TEST_CHECK(rcode == 0);
625
626 TEST_CHECK(vp->vp_uint32 == 0);
627
628 vp->vp_uint32 = 1;
629 TEST_CHECK(vp->vp_uint32 == 1);
630
631 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp);
632 TEST_CHECK(rcode == 0);
633
634 /*
635 * Abort the edit
636 */
637 fr_edit_list_abort(el);
638
639 vp = fr_pair_list_head(&local_pairs);
640 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
641 TEST_CHECK(vp->vp_uint32 == 0);
642
643 expect3(&local_pairs);
644}
645
646static void test_pair_insert_after_head_delete(void)
647{
648 fr_pair_t *vp;
649 fr_pair_list_t local_pairs;
650 size_t count;
651 fr_edit_list_t *el;
652 int rcode;
653
654 TEST_CASE("Add 3 pairs and insert a new one at the head, and delete it");
655
656 add_pairs(&local_pairs);
657
658 el = fr_edit_list_alloc(NULL, 5, NULL);
659 fr_assert(el != NULL);
660
661 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string);
662 fr_assert(vp != NULL);
663 rcode = fr_edit_list_insert_pair_after(el, &local_pairs, NULL, vp);
664 TEST_CHECK(rcode == 0);
665
666 count = fr_pair_list_num_elements(&local_pairs);
667 TEST_CASE("Expected (count == 4) after inserting a new one");
668 TEST_CHECK(count == 4);
669
670 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp);
671 TEST_CHECK(rcode == 0);
672
673 count = fr_pair_list_num_elements(&local_pairs);
674 TEST_CASE("Expected (count == 3) after deleting the just inserted on");
675 TEST_CHECK(count == 3);
676
677 fr_edit_list_commit(el);
678
679 expect3(&local_pairs);
680}
681
682static void test_pair_insert_after_head_delete_abort(void)
683{
684 fr_pair_t *vp;
685 fr_pair_list_t local_pairs;
686 size_t count;
687 fr_edit_list_t *el;
688 int rcode;
689
690 TEST_CASE("Add 3 pairs and insert a new one at the head and delete it, then abort");
691
692 add_pairs(&local_pairs);
693
694 el = fr_edit_list_alloc(NULL, 5, NULL);
695 fr_assert(el != NULL);
696
697 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string);
698 fr_assert(vp != NULL);
699 rcode = fr_edit_list_insert_pair_after(el, &local_pairs, NULL, vp);
700 TEST_CHECK(rcode == 0);
701
702 count = fr_pair_list_num_elements(&local_pairs);
703 TEST_CASE("Expected (count == 4) after inserting a new one");
704 TEST_CHECK(count == 4);
705
706 /*
707 * Abort the edit
708 */
709 fr_edit_list_abort(el);
710
711 expect3(&local_pairs);
712}
713
714
715static void test_pair_edit_child_value(void)
716{
717 fr_pair_t *vp;
718 fr_pair_list_t local_pairs;
719 fr_edit_list_t *el, *child;
720 int rcode;
721
722 TEST_CASE("Add 3 pairs and change the value of the first one in a child transaction");
723
724 add_pairs(&local_pairs);
725
726 vp = fr_pair_list_head(&local_pairs);
727 fr_assert(vp != NULL);
728
729 el = fr_edit_list_alloc(NULL, 5, NULL);
730 fr_assert(el != NULL);
731
732 rcode = fr_edit_list_save_pair_value(el, vp);
733 TEST_CHECK(rcode == 0);
734
735 TEST_CHECK(vp->vp_uint32 == 0);
736
737 vp->vp_uint32 = 1;
738 TEST_CHECK(vp->vp_uint32 == 1);
739
740 child = fr_edit_list_alloc(NULL, 5, el);
741 fr_assert(child != NULL);
742
743 rcode = fr_edit_list_save_pair_value(child, vp); /* CHILD */
744 TEST_CHECK(rcode == 0);
745
746 TEST_CHECK(vp->vp_uint32 == 1);
747
748 vp->vp_uint32 = 2;
749 TEST_CHECK(vp->vp_uint32 == 2);
750
751 fr_edit_list_commit(child); /* should do nothing */
752
753 TEST_CHECK(vp->vp_uint32 == 2);
754
755 fr_edit_list_commit(el);
756
757 vp = fr_pair_list_head(&local_pairs);
758 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
759 TEST_CHECK(vp->vp_uint32 == 2);
760
761 expect3(&local_pairs);
762}
763
764static void test_pair_edit_child_value_abort(void)
765{
766 fr_pair_t *vp;
767 fr_pair_list_t local_pairs;
768 fr_edit_list_t *el, *child;
769 int rcode;
770
771 TEST_CASE("Add 3 pairs and change the value of the first one, then abort");
772
773 add_pairs(&local_pairs);
774
775 vp = fr_pair_list_head(&local_pairs);
776 fr_assert(vp != NULL);
777
778 el = fr_edit_list_alloc(NULL, 5, NULL);
779 fr_assert(el != NULL);
780
781 rcode = fr_edit_list_save_pair_value(el, vp);
782 TEST_CHECK(rcode == 0);
783
784 TEST_CHECK(vp->vp_uint32 == 0);
785
786 vp->vp_uint32 = 1;
787 TEST_CHECK(vp->vp_uint32 == 1);
788
789 child = fr_edit_list_alloc(NULL, 5, el);
790 fr_assert(child != NULL);
791
792 rcode = fr_edit_list_save_pair_value(child, vp); /* CHILD */
793 TEST_CHECK(rcode == 0);
794
795 TEST_CHECK(vp->vp_uint32 == 1);
796
797 vp->vp_uint32 = 2;
798 TEST_CHECK(vp->vp_uint32 == 2);
799
800 fr_edit_list_abort(child); /* CHILD */
801
802 TEST_CHECK(vp->vp_uint32 == 1);
803
804 fr_edit_list_commit(el);
805
806 vp = fr_pair_list_head(&local_pairs);
807 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
808 TEST_CHECK(vp->vp_uint32 == 1);
809
810 expect3(&local_pairs);
811}
812
813static void test_pair_delete_tail(void)
814{
815 fr_pair_t *vp;
816 fr_pair_list_t local_pairs;
817 size_t count;
818 fr_edit_list_t *el;
819 int rcode;
820
821 TEST_CASE("Add 3 pairs and delete the tail");
822
823 add_pairs(&local_pairs);
824
825 vp = fr_pair_list_tail(&local_pairs);
826 fr_assert(vp != NULL);
827 TEST_CHECK(vp->da == fr_dict_attr_test_tlv);
828
829 el = fr_edit_list_alloc(NULL, 5, NULL);
830 fr_assert(el != NULL);
831
832 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp);
833 TEST_CHECK(rcode == 0);
834
835 fr_edit_list_commit(el);
836
837 count = fr_pair_list_num_elements(&local_pairs);
838 TEST_CASE("Expected (count == 2) after deleting the tail");
839 TEST_CHECK(count == 2);
840
841 vp = fr_pair_list_tail(&local_pairs);
842 TEST_CHECK(vp->da == fr_dict_attr_test_octets);
843
844 fr_pair_list_free(&local_pairs);
845}
846
847static void test_pair_delete_tail_abort(void)
848{
849 fr_pair_t *vp;
850 fr_pair_list_t local_pairs;
851 size_t count;
852 fr_edit_list_t *el;
853 int rcode;
854
855 TEST_CASE("Add 3 pairs and delete the tail, then abort");
856
857 add_pairs(&local_pairs);
858
859 vp = fr_pair_list_tail(&local_pairs);
860 fr_assert(vp != NULL);
861 TEST_CHECK(vp->da == fr_dict_attr_test_tlv);
862
863 el = fr_edit_list_alloc(NULL, 5, NULL);
864 fr_assert(el != NULL);
865
866 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp);
867 TEST_CHECK(rcode == 0);
868
869 count = fr_pair_list_num_elements(&local_pairs);
870 TEST_CHECK(count == 2);
871
872 fr_edit_list_abort(el);
873
874 expect3(&local_pairs);
875}
876
877static void test_pair_delete_by_da(void)
878{
879 fr_pair_t *vp;
880 fr_pair_list_t local_pairs;
881 size_t count;
882 fr_edit_list_t *el;
883 int rcode;
884
885 TEST_CASE("Add pairs and delete all with a matching da");
886
887 add_pairs(&local_pairs);
888
889 /* Add another uint32 at the tail */
890 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_uint32);
891 fr_assert(vp != NULL);
892 vp->vp_uint32 = 42;
893 fr_pair_append(&local_pairs, vp);
894
895 count = fr_pair_list_num_elements(&local_pairs);
896 TEST_CHECK(count == 4);
897
898 el = fr_edit_list_alloc(NULL, 5, NULL);
899 fr_assert(el != NULL);
900
901 rcode = fr_edit_list_pair_delete_by_da(el, &local_pairs, fr_dict_attr_test_uint32);
902 TEST_CHECK(rcode == 0);
903
904 fr_edit_list_commit(el);
905
906 count = fr_pair_list_num_elements(&local_pairs);
907 TEST_CASE("Expected (count == 2) after deleting all uint32 pairs");
908 TEST_CHECK(count == 2);
909
910 vp = fr_pair_list_head(&local_pairs);
911 TEST_CHECK(vp->da == fr_dict_attr_test_octets);
912
913 vp = fr_pair_list_tail(&local_pairs);
914 TEST_CHECK(vp->da == fr_dict_attr_test_tlv);
915
916 fr_pair_list_free(&local_pairs);
917}
918
919static void test_pair_delete_by_da_abort(void)
920{
921 fr_pair_t *vp;
922 fr_pair_list_t local_pairs;
923 size_t count;
924 fr_edit_list_t *el;
925 int rcode;
926
927 TEST_CASE("Add pairs and delete all with a matching da, then abort");
928
929 add_pairs(&local_pairs);
930
931 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_uint32);
932 fr_assert(vp != NULL);
933 vp->vp_uint32 = 42;
934 fr_pair_append(&local_pairs, vp);
935
936 count = fr_pair_list_num_elements(&local_pairs);
937 TEST_CHECK(count == 4);
938
939 el = fr_edit_list_alloc(NULL, 5, NULL);
940 fr_assert(el != NULL);
941
942 rcode = fr_edit_list_pair_delete_by_da(el, &local_pairs, fr_dict_attr_test_uint32);
943 TEST_CHECK(rcode == 0);
944
945 count = fr_pair_list_num_elements(&local_pairs);
946 TEST_CHECK(count == 2);
947
948 fr_edit_list_abort(el);
949
950 count = fr_pair_list_num_elements(&local_pairs);
951 TEST_CASE("Expected (count == 4) after aborting the delete");
952 TEST_CHECK(count == 4);
953
954 vp = fr_pair_list_head(&local_pairs);
955 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
956 TEST_CHECK(vp->vp_uint32 == 0);
957
958 vp = fr_pair_list_tail(&local_pairs);
959 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
960 TEST_CHECK(vp->vp_uint32 == 42);
961
962 fr_pair_list_free(&local_pairs);
963}
964
965static void test_pair_replace_value(void)
966{
967 fr_pair_t *vp;
968 fr_pair_list_t local_pairs;
969 fr_edit_list_t *el;
970 int rcode;
971 fr_value_box_t box;
972
973 TEST_CASE("Add 3 pairs and replace the value of the first one");
974
975 add_pairs(&local_pairs);
976
977 vp = fr_pair_list_head(&local_pairs);
978 fr_assert(vp != NULL);
979
980 el = fr_edit_list_alloc(NULL, 5, NULL);
981 fr_assert(el != NULL);
982
983 TEST_CHECK(vp->vp_uint32 == 0);
984
985 fr_value_box_init(&box, FR_TYPE_UINT32, NULL, false);
986 box.vb_uint32 = 42;
987
988 rcode = fr_edit_list_replace_pair_value(el, vp, &box);
989 TEST_CHECK(rcode == 0);
990 TEST_CHECK(vp->vp_uint32 == 42);
991
992 fr_edit_list_commit(el);
993
994 vp = fr_pair_list_head(&local_pairs);
995 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
996 TEST_CHECK(vp->vp_uint32 == 42);
997
998 expect3(&local_pairs);
999}
1000
1001static void test_pair_replace_value_abort(void)
1002{
1003 fr_pair_t *vp;
1004 fr_pair_list_t local_pairs;
1005 fr_edit_list_t *el;
1006 int rcode;
1007 fr_value_box_t box;
1008
1009 TEST_CASE("Add 3 pairs and replace the value of the first one, then abort");
1010
1011 add_pairs(&local_pairs);
1012
1013 vp = fr_pair_list_head(&local_pairs);
1014 fr_assert(vp != NULL);
1015
1016 el = fr_edit_list_alloc(NULL, 5, NULL);
1017 fr_assert(el != NULL);
1018
1019 TEST_CHECK(vp->vp_uint32 == 0);
1020
1021 fr_value_box_init(&box, FR_TYPE_UINT32, NULL, false);
1022 box.vb_uint32 = 42;
1023
1024 rcode = fr_edit_list_replace_pair_value(el, vp, &box);
1025 TEST_CHECK(rcode == 0);
1026 TEST_CHECK(vp->vp_uint32 == 42);
1027
1028 fr_edit_list_abort(el);
1029
1030 vp = fr_pair_list_head(&local_pairs);
1031 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
1032 TEST_CHECK(vp->vp_uint32 == 0);
1033
1034 expect3(&local_pairs);
1035}
1036
1037static void test_pair_replace_pair(void)
1038{
1039 fr_pair_t *vp, *new_vp;
1040 fr_pair_list_t local_pairs;
1041 size_t count;
1042 fr_edit_list_t *el;
1043 int rcode;
1044
1045 TEST_CASE("Add 3 pairs and replace the head with a new pair");
1046
1047 add_pairs(&local_pairs);
1048
1049 vp = fr_pair_list_head(&local_pairs);
1050 fr_assert(vp != NULL);
1051
1052 el = fr_edit_list_alloc(NULL, 5, NULL);
1053 fr_assert(el != NULL);
1054
1055 new_vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_uint32);
1056 fr_assert(new_vp != NULL);
1057 new_vp->vp_uint32 = 99;
1058
1059 rcode = fr_edit_list_replace_pair(el, &local_pairs, vp, new_vp);
1060 TEST_CHECK(rcode == 0);
1061
1062 fr_edit_list_commit(el);
1063
1064 count = fr_pair_list_num_elements(&local_pairs);
1065 TEST_CASE("Expected (count == 3) after replacing a pair");
1066 TEST_CHECK(count == 3);
1067
1068 vp = fr_pair_list_head(&local_pairs);
1069 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
1070 TEST_CHECK(vp->vp_uint32 == 99);
1071
1072 fr_pair_list_free(&local_pairs);
1073}
1074
1075static void test_pair_replace_pair_abort(void)
1076{
1077 fr_pair_t *vp, *new_vp;
1078 fr_pair_list_t local_pairs;
1079 fr_edit_list_t *el;
1080 int rcode;
1081
1082 TEST_CASE("Add 3 pairs and replace the head, then abort");
1083
1084 add_pairs(&local_pairs);
1085
1086 vp = fr_pair_list_head(&local_pairs);
1087 fr_assert(vp != NULL);
1088
1089 el = fr_edit_list_alloc(NULL, 5, NULL);
1090 fr_assert(el != NULL);
1091
1092 new_vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_uint32);
1093 fr_assert(new_vp != NULL);
1094 new_vp->vp_uint32 = 99;
1095
1096 rcode = fr_edit_list_replace_pair(el, &local_pairs, vp, new_vp);
1097 TEST_CHECK(rcode == 0);
1098
1099 vp = fr_pair_list_head(&local_pairs);
1100 TEST_CHECK(vp->vp_uint32 == 99);
1101
1102 fr_edit_list_abort(el);
1103
1104 vp = fr_pair_list_head(&local_pairs);
1105 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
1106 TEST_CHECK(vp->vp_uint32 == 0);
1107
1108 expect3(&local_pairs);
1109}
1110
1111static void test_pair_insert_after_tail(void)
1112{
1113 fr_pair_t *vp;
1114 fr_pair_list_t local_pairs;
1115 size_t count;
1116 fr_edit_list_t *el;
1117 int rcode;
1118
1119 TEST_CASE("Add 3 pairs and insert a new one at the tail");
1120
1121 add_pairs(&local_pairs);
1122
1123 el = fr_edit_list_alloc(NULL, 5, NULL);
1124 fr_assert(el != NULL);
1125
1126 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string);
1127 fr_assert(vp != NULL);
1128 rcode = fr_edit_list_insert_pair_tail(el, &local_pairs, vp);
1129 TEST_CHECK(rcode == 0);
1130
1131 fr_edit_list_commit(el);
1132
1133 count = fr_pair_list_num_elements(&local_pairs);
1134 TEST_CASE("Expected (count == 4) after inserting at the tail");
1135 TEST_CHECK(count == 4);
1136
1137 vp = fr_pair_list_tail(&local_pairs);
1138 TEST_CHECK(vp->da == fr_dict_attr_test_string);
1139
1140 fr_pair_list_free(&local_pairs);
1141}
1142
1143static void test_pair_insert_after_tail_abort(void)
1144{
1145 fr_pair_t *vp;
1146 fr_pair_list_t local_pairs;
1147 size_t count;
1148 fr_edit_list_t *el;
1149 int rcode;
1150
1151 TEST_CASE("Add 3 pairs and insert a new one at the tail, then abort");
1152
1153 add_pairs(&local_pairs);
1154
1155 el = fr_edit_list_alloc(NULL, 5, NULL);
1156 fr_assert(el != NULL);
1157
1158 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string);
1159 fr_assert(vp != NULL);
1160 rcode = fr_edit_list_insert_pair_tail(el, &local_pairs, vp);
1161 TEST_CHECK(rcode == 0);
1162
1163 count = fr_pair_list_num_elements(&local_pairs);
1164 TEST_CHECK(count == 4);
1165
1166 fr_edit_list_abort(el);
1167
1168 expect3(&local_pairs);
1169}
1170
1171static void test_pair_free_children(void)
1172{
1173 fr_pair_t *vp, *child;
1174 fr_pair_list_t local_pairs;
1175 size_t count;
1176 fr_edit_list_t *el;
1177 int rcode;
1178
1179 TEST_CASE("Add children to a TLV pair and free them");
1180
1181 add_pairs(&local_pairs);
1182
1183 vp = fr_pair_list_tail(&local_pairs);
1184 TEST_CHECK(vp->da == fr_dict_attr_test_tlv);
1185
1186 child = fr_pair_afrom_da(vp, fr_dict_attr_test_tlv_string);
1187 fr_assert(child != NULL);
1188 fr_pair_append(&vp->vp_group, child);
1189 TEST_CHECK(fr_pair_list_num_elements(&vp->vp_group) == 1);
1190
1191 el = fr_edit_list_alloc(NULL, 5, NULL);
1192 fr_assert(el != NULL);
1193
1194 rcode = fr_edit_list_free_pair_children(el, vp);
1195 TEST_CHECK(rcode == 0);
1196 TEST_CHECK(fr_pair_list_empty(&vp->vp_group));
1197
1198 fr_edit_list_commit(el);
1199
1200 TEST_CHECK(fr_pair_list_empty(&vp->vp_group));
1201
1202 count = fr_pair_list_num_elements(&local_pairs);
1203 TEST_CHECK(count == 3);
1204
1205 fr_pair_list_free(&local_pairs);
1206}
1207
1208static void test_pair_free_children_abort(void)
1209{
1210 fr_pair_t *vp, *child;
1211 fr_pair_list_t local_pairs;
1212 fr_edit_list_t *el;
1213 int rcode;
1214
1215 TEST_CASE("Add children to a TLV pair, free them, then abort");
1216
1217 add_pairs(&local_pairs);
1218
1219 vp = fr_pair_list_tail(&local_pairs);
1220 TEST_CHECK(vp->da == fr_dict_attr_test_tlv);
1221
1222 child = fr_pair_afrom_da(vp, fr_dict_attr_test_tlv_string);
1223 fr_assert(child != NULL);
1224 fr_pair_append(&vp->vp_group, child);
1225 TEST_CHECK(fr_pair_list_num_elements(&vp->vp_group) == 1);
1226
1227 el = fr_edit_list_alloc(NULL, 5, NULL);
1228 fr_assert(el != NULL);
1229
1230 rcode = fr_edit_list_free_pair_children(el, vp);
1231 TEST_CHECK(rcode == 0);
1232 TEST_CHECK(fr_pair_list_empty(&vp->vp_group));
1233
1234 fr_edit_list_abort(el);
1235
1236 TEST_CHECK(fr_pair_list_num_elements(&vp->vp_group) == 1);
1237
1238 child = fr_pair_list_head(&vp->vp_group);
1239 TEST_CHECK(child->da == fr_dict_attr_test_tlv_string);
1240
1241 expect3(&local_pairs);
1242}
1243
1244static void test_pair_insert_list_tail(void)
1245{
1246 fr_pair_t *vp;
1247 fr_pair_list_t local_pairs, to_insert;
1248 size_t count;
1249 fr_edit_list_t *el;
1250 int rcode;
1251
1252 TEST_CASE("Add 3 pairs and insert a list of 2 at the tail");
1253
1254 add_pairs(&local_pairs);
1255
1256 fr_pair_list_init(&to_insert);
1257
1258 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string);
1259 fr_assert(vp != NULL);
1260 fr_pair_append(&to_insert, vp);
1261
1262 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_uint16);
1263 fr_assert(vp != NULL);
1264 fr_pair_append(&to_insert, vp);
1265
1266 el = fr_edit_list_alloc(NULL, 5, NULL);
1267 fr_assert(el != NULL);
1268
1269 rcode = fr_edit_list_insert_list_tail(el, &local_pairs, &to_insert);
1270 TEST_CHECK(rcode == 0);
1271
1272 fr_edit_list_commit(el);
1273
1274 count = fr_pair_list_num_elements(&local_pairs);
1275 TEST_CASE("Expected (count == 5) after inserting a list of 2");
1276 TEST_CHECK(count == 5);
1277
1278 vp = fr_pair_list_tail(&local_pairs);
1279 TEST_CHECK(vp->da == fr_dict_attr_test_uint16);
1280
1281 fr_pair_list_free(&local_pairs);
1282}
1283
1284static void test_pair_insert_list_tail_abort(void)
1285{
1286 fr_pair_t *vp;
1287 fr_pair_list_t local_pairs, to_insert;
1288 size_t count;
1289 fr_edit_list_t *el;
1290 int rcode;
1291
1292 TEST_CASE("Add 3 pairs and insert a list of 2 at the tail, then abort");
1293
1294 add_pairs(&local_pairs);
1295
1296 fr_pair_list_init(&to_insert);
1297
1298 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string);
1299 fr_assert(vp != NULL);
1300 fr_pair_append(&to_insert, vp);
1301
1302 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_uint16);
1303 fr_assert(vp != NULL);
1304 fr_pair_append(&to_insert, vp);
1305
1306 el = fr_edit_list_alloc(NULL, 5, NULL);
1307 fr_assert(el != NULL);
1308
1309 rcode = fr_edit_list_insert_list_tail(el, &local_pairs, &to_insert);
1310 TEST_CHECK(rcode == 0);
1311
1312 count = fr_pair_list_num_elements(&local_pairs);
1313 TEST_CHECK(count == 5);
1314
1315 fr_edit_list_abort(el);
1316
1317 expect3(&local_pairs);
1318}
1319
1320static void test_pair_edit_child_commit_parent_abort(void)
1321{
1322 fr_pair_t *vp;
1323 fr_pair_list_t local_pairs;
1324 fr_edit_list_t *el, *child;
1325 int rcode;
1326
1327 TEST_CASE("Child commits value change, parent aborts - everything reverted");
1328
1329 add_pairs(&local_pairs);
1330
1331 vp = fr_pair_list_head(&local_pairs);
1332 fr_assert(vp != NULL);
1333
1334 el = fr_edit_list_alloc(NULL, 5, NULL);
1335 fr_assert(el != NULL);
1336
1337 rcode = fr_edit_list_save_pair_value(el, vp);
1338 TEST_CHECK(rcode == 0);
1339
1340 TEST_CHECK(vp->vp_uint32 == 0);
1341
1342 vp->vp_uint32 = 1;
1343 TEST_CHECK(vp->vp_uint32 == 1);
1344
1345 child = fr_edit_list_alloc(NULL, 5, el);
1346 fr_assert(child != NULL);
1347
1348 rcode = fr_edit_list_save_pair_value(child, vp);
1349 TEST_CHECK(rcode == 0);
1350
1351 vp->vp_uint32 = 2;
1352 TEST_CHECK(vp->vp_uint32 == 2);
1353
1354 fr_edit_list_commit(child); /* does nothing, value stays at 2 */
1355 TEST_CHECK(vp->vp_uint32 == 2);
1356
1357 /* Abort parent - everything should revert */
1358 fr_edit_list_abort(el);
1359
1360 vp = fr_pair_list_head(&local_pairs);
1361 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
1362 TEST_CHECK(vp->vp_uint32 == 0);
1363
1364 expect3(&local_pairs);
1365}
1366
1367TEST_LIST = {
1368 /*
1369 * Deletion.
1370 */
1371 { "pair_delete_head", test_pair_delete_head },
1372 { "pair_delete_head_abort", test_pair_delete_head_abort },
1373
1374 { "pair_delete_middle", test_pair_delete_middle },
1375 { "pair_delete_middle_abort", test_pair_delete_middle_abort },
1376
1377 { "pair_delete_multiple", test_pair_delete_multiple },
1378 { "pair_delete_multiple_abort", test_pair_delete_multiple_abort },
1379
1380 /*
1381 * Insert after
1382 */
1383 { "pair_insert_after_head", test_pair_insert_after_head },
1384 { "pair_insert_after_head_abort", test_pair_insert_after_head_abort },
1385
1386 { "pair_insert_after_middle", test_pair_insert_after_middle },
1387 { "pair_insert_after_middle_abort", test_pair_insert_after_middle_abort },
1388
1389 /*
1390 * Value modification
1391 */
1392 { "pair_edit_value", test_pair_edit_value },
1393 { "pair_edit_value_abort", test_pair_edit_value_abort },
1394
1395 /*
1396 * Value modification, then deletion
1397 */
1398 { "pair_edit_value_delete", test_pair_edit_value_delete },
1399 { "pair_edit_value_delete_abort", test_pair_edit_value_delete_abort },
1400
1401 /*
1402 * Insert after, then delete
1403 */
1404 { "pair_insert_after_head_delete", test_pair_insert_after_head_delete },
1405 { "pair_insert_after_head_delete_abort", test_pair_insert_after_head_delete_abort },
1406
1407 /*
1408 * Value modification in child list
1409 */
1410 { "pair_edit_child_value", test_pair_edit_child_value },
1411 { "pair_edit_child_value_abort", test_pair_edit_child_value_abort },
1412
1413 /*
1414 * Deletion of tail
1415 */
1416 { "pair_delete_tail", test_pair_delete_tail },
1417 { "pair_delete_tail_abort", test_pair_delete_tail_abort },
1418
1419 /*
1420 * Deletion by da
1421 */
1422 { "pair_delete_by_da", test_pair_delete_by_da },
1423 { "pair_delete_by_da_abort", test_pair_delete_by_da_abort },
1424
1425 /*
1426 * Value replacement (fr_edit_list_replace_pair_value)
1427 */
1428 { "pair_replace_value", test_pair_replace_value },
1429 { "pair_replace_value_abort", test_pair_replace_value_abort },
1430
1431 /*
1432 * Pair replacement (fr_edit_list_replace_pair)
1433 */
1434 { "pair_replace_pair", test_pair_replace_pair },
1435 { "pair_replace_pair_abort", test_pair_replace_pair_abort },
1436
1437 /*
1438 * Insert at tail
1439 */
1440 { "pair_insert_after_tail", test_pair_insert_after_tail },
1441 { "pair_insert_after_tail_abort", test_pair_insert_after_tail_abort },
1442
1443 /*
1444 * Free children of structural pair
1445 */
1446 { "pair_free_children", test_pair_free_children },
1447 { "pair_free_children_abort", test_pair_free_children_abort },
1448
1449 /*
1450 * Insert list at tail
1451 */
1452 { "pair_insert_list_tail", test_pair_insert_list_tail },
1453 { "pair_insert_list_tail_abort", test_pair_insert_list_tail_abort },
1454
1455 /*
1456 * Child commit + parent abort
1457 */
1458 { "pair_edit_child_commit_parent_abort", test_pair_edit_child_commit_parent_abort },
1459
1460 TEST_TERMINATOR
1461};
TEST_CHECK
#define TEST_CHECK(cond)
Definition acutest.h:87
TEST_CASE
#define TEST_CASE(name)
Definition acutest.h:186
TEST_TERMINATOR
#define TEST_TERMINATOR
Definition acutest.h:64
acutest_helpers.h
__attribute__
Definition bfd.h:63
autofree
static TALLOC_CTX * autofree
Definition fuzzer.c:46
fr_exit_now
#define fr_exit_now(_x)
Exit without calling atexit() handlers, producing a log message in debug builds.
Definition debug.h:226
fr_dict_attr_test_tlv_string
fr_dict_attr_t const * fr_dict_attr_test_tlv_string
Definition dict_test.c:65
fr_dict_attr_test_tlv
fr_dict_attr_t const * fr_dict_attr_test_tlv
Definition dict_test.c:64
fr_dict_attr_test_uint32
fr_dict_attr_t const * fr_dict_attr_test_uint32
Definition dict_test.c:47
fr_dict_attr_test_octets
fr_dict_attr_t const * fr_dict_attr_test_octets
Definition dict_test.c:31
fr_dict_attr_test_string
fr_dict_attr_t const * fr_dict_attr_test_string
Definition dict_test.c:30
fr_dict_test_init
int fr_dict_test_init(TALLOC_CTX *ctx, fr_dict_t **dict_p, fr_dict_test_attr_t const *test_defs)
Initialise a test dictionary and add our test_defs to it.
Definition dict_test.c:248
fr_dict_attr_test_uint16
fr_dict_attr_t const * fr_dict_attr_test_uint16
Definition dict_test.c:46
test_pair_delete_multiple
static void test_pair_delete_multiple(void)
Definition edit_tests.c:271
test_pair_insert_list_tail
static void test_pair_insert_list_tail(void)
Definition edit_tests.c:1244
test_pair_delete_head
static void test_pair_delete_head(void)
Definition edit_tests.c:127
TEST_LIST
TEST_LIST
Definition edit_tests.c:1367
test_pair_delete_head_abort
static void test_pair_delete_head_abort(void)
Definition edit_tests.c:160
test_pair_delete_tail
static void test_pair_delete_tail(void)
Definition edit_tests.c:813
test_pair_replace_value_abort
static void test_pair_replace_value_abort(void)
Definition edit_tests.c:1001
test_pair_delete_multiple_abort
static void test_pair_delete_multiple_abort(void)
Definition edit_tests.c:314
test_pair_edit_value_delete_abort
static void test_pair_edit_value_delete_abort(void)
Definition edit_tests.c:606
test_pair_insert_after_head_delete_abort
static void test_pair_insert_after_head_delete_abort(void)
Definition edit_tests.c:682
test_pair_delete_middle_abort
static void test_pair_delete_middle_abort(void)
Definition edit_tests.c:230
expect3
static void expect3(fr_pair_list_t *local_pairs)
Definition edit_tests.c:106
test_pair_replace_pair
static void test_pair_replace_pair(void)
Definition edit_tests.c:1037
test_pair_edit_child_commit_parent_abort
static void test_pair_edit_child_commit_parent_abort(void)
Definition edit_tests.c:1320
test_pair_delete_by_da
static void test_pair_delete_by_da(void)
Definition edit_tests.c:877
test_pair_edit_value
static void test_pair_edit_value(void)
Definition edit_tests.c:363
test_pair_free_children
static void test_pair_free_children(void)
Definition edit_tests.c:1171
test_pair_insert_after_tail_abort
static void test_pair_insert_after_tail_abort(void)
Definition edit_tests.c:1143
test_pair_delete_by_da_abort
static void test_pair_delete_by_da_abort(void)
Definition edit_tests.c:919
test_pair_replace_value
static void test_pair_replace_value(void)
Definition edit_tests.c:965
test_pair_insert_after_middle
static void test_pair_insert_after_middle(void)
Definition edit_tests.c:499
test_pair_edit_child_value
static void test_pair_edit_child_value(void)
Definition edit_tests.c:715
add_pairs
static void add_pairs(fr_pair_list_t *local_pairs)
Definition edit_tests.c:82
test_pair_insert_after_head_abort
static void test_pair_insert_after_head_abort(void)
Definition edit_tests.c:467
test_pair_insert_after_tail
static void test_pair_insert_after_tail(void)
Definition edit_tests.c:1111
test_pair_insert_after_head
static void test_pair_insert_after_head(void)
Definition edit_tests.c:434
test_pair_insert_after_head_delete
static void test_pair_insert_after_head_delete(void)
Definition edit_tests.c:646
test_pair_edit_child_value_abort
static void test_pair_edit_child_value_abort(void)
Definition edit_tests.c:764
test_pair_delete_middle
static void test_pair_delete_middle(void)
Definition edit_tests.c:192
test_pair_free_children_abort
static void test_pair_free_children_abort(void)
Definition edit_tests.c:1208
test_pair_insert_list_tail_abort
static void test_pair_insert_list_tail_abort(void)
Definition edit_tests.c:1284
test_pair_edit_value_delete
static void test_pair_edit_value_delete(void)
Definition edit_tests.c:568
test_pair_delete_tail_abort
static void test_pair_delete_tail_abort(void)
Definition edit_tests.c:847
test_init
static void test_init(void)
Global initialisation.
Definition edit_tests.c:36
test_pair_replace_pair_abort
static void test_pair_replace_pair_abort(void)
Definition edit_tests.c:1075
test_pair_edit_value_abort
static void test_pair_edit_value_abort(void)
Definition edit_tests.c:397
test_pair_insert_after_middle_abort
static void test_pair_insert_after_middle_abort(void)
Definition edit_tests.c:532
FR_TYPE_UINT32
@ FR_TYPE_UINT32
32 Bit unsigned integer.
Definition merged_model.c:99
fr_dict_t
Definition merged_model.c:198
fr_value_box_t
Definition merged_model.c:136
fr_pair_append
int fr_pair_append(fr_pair_list_t *list, fr_pair_t *to_add)
Add a VP to the end of the list.
Definition pair.c:1354
fr_pair_afrom_da
fr_pair_t * fr_pair_afrom_da(TALLOC_CTX *ctx, fr_dict_attr_t const *da)
Dynamically allocate a new attribute and assign a fr_dict_attr_t.
Definition pair.c:290
fr_pair_list_init
void fr_pair_list_init(fr_pair_list_t *list)
Initialise a pair list header.
Definition pair.c:46
test_pairs
static fr_pair_list_t test_pairs
Definition pair_server_tests.c:42
test_dict
static fr_dict_t * test_dict
Definition pair_server_tests.c:43
pair_test_helpers.h
Helper functions for pair tests.
fr_pair_test_list_alloc
static int fr_pair_test_list_alloc(TALLOC_CTX *ctx, fr_pair_list_t *out, fr_dict_test_attr_t const *test_defs)
Definition pair_test_helpers.h:43
fr_assert
#define fr_assert(_expr)
Definition rad_assert.h:38
local_pairs
#define local_pairs
Convenience macro for accessing the state list.
Definition request.h:160
count
return count
Definition module.c:155
vp
fr_pair_t * vp
Definition state_machine.c:2289
pair_list_s
Definition pair.h:52
value_pair_s
Stores an attribute, a value and various bits of other data.
Definition pair.h:68
value_pair_s::da
fr_dict_attr_t const *_CONST da
Dictionary attribute defines the attribute number, vendor and type of the pair.
Definition pair.h:69
talloc_autofree_context
#define talloc_autofree_context
The original function is deprecated, so replace it with our version.
Definition talloc.h:51
el
static fr_event_list_t * el
Definition unit_test_attribute.c:281
fr_edit_list_pair_delete
int fr_edit_list_pair_delete(fr_edit_list_t *el, fr_pair_list_t *list, fr_pair_t *vp)
Delete a VP.
Definition edit.c:607
fr_edit_list_replace_pair_value
int fr_edit_list_replace_pair_value(fr_edit_list_t *el, fr_pair_t *vp, fr_value_box_t *box)
Write a new value to the fr_value_box_t.
Definition edit.c:658
fr_edit_list_commit
void fr_edit_list_commit(fr_edit_list_t *el)
Commit an edit list.
Definition edit.c:852
fr_edit_list_insert_pair_after
int fr_edit_list_insert_pair_after(fr_edit_list_t *el, fr_pair_list_t *list, fr_pair_t *pos, fr_pair_t *vp)
Insert a new VP after an existing one.
Definition edit.c:594
fr_edit_list_save_pair_value
int fr_edit_list_save_pair_value(fr_edit_list_t *el, fr_pair_t *vp)
Record the value of a leaf fr_value_box_t.
Definition edit.c:645
fr_edit_list_abort
void fr_edit_list_abort(fr_edit_list_t *el)
Abort the entries in an edit list.
Definition edit.c:202
fr_edit_list_replace_pair
int fr_edit_list_replace_pair(fr_edit_list_t *el, fr_pair_list_t *list, fr_pair_t *to_replace, fr_pair_t *vp)
Replace a pair with another one.
Definition edit.c:676
fr_edit_list_free_pair_children
int fr_edit_list_free_pair_children(fr_edit_list_t *el, fr_pair_t *vp)
Free children of a structural pair.
Definition edit.c:722
fr_edit_list_pair_delete_by_da
int fr_edit_list_pair_delete_by_da(fr_edit_list_t *el, fr_pair_list_t *list, fr_dict_attr_t const *da)
Delete VPs with a matching da.
Definition edit.c:621
fr_edit_list_alloc
fr_edit_list_t * fr_edit_list_alloc(TALLOC_CTX *ctx, int hint, fr_edit_list_t *parent)
Allocate an edit list.
Definition edit.c:801
fr_edit_list_s
Track a series of edits.
Definition edit.c:101
fr_edit_list_insert_pair_tail
#define fr_edit_list_insert_pair_tail(_el, _list, _vp)
Definition edit.h:51
fr_edit_list_insert_list_tail
#define fr_edit_list_insert_list_tail(_el, _list, _to_insert)
Definition edit.h:74
fr_pair_list_empty
bool fr_pair_list_empty(fr_pair_list_t const *list)
Is a valuepair list empty.
Definition pair_inline.c:124
fr_pair_list_next
fr_pair_t * fr_pair_list_next(fr_pair_list_t const *list, fr_pair_t const *item))
Get the next item in a valuepair list after a specific entry.
Definition pair_inline.c:69
fr_pair_list_tail
fr_pair_t * fr_pair_list_tail(fr_pair_list_t const *list)
Get the tail of a valuepair list.
Definition pair_inline.c:55
fr_pair_list_free
void fr_pair_list_free(fr_pair_list_t *list)
Free memory used by a valuepair list.
Definition pair_inline.c:112
fr_pair_list_head
fr_pair_t * fr_pair_list_head(fr_pair_list_t const *list)
Get the head of a valuepair list.
Definition pair_inline.c:42
fr_pair_list_num_elements
size_t fr_pair_list_num_elements(fr_pair_list_t const *list)
Get the length of a list of fr_pair_t.
Definition pair_inline.c:150
fr_perror
void fr_perror(char const *fmt,...)
Print the current error to stderr with a prefix.
Definition strerror.c:732
fr_check_lib_magic
int fr_check_lib_magic(uint64_t magic)
Check if the application linking to the library has the correct magic number.
Definition version.c:40
RADIUSD_MAGIC_NUMBER
#define RADIUSD_MAGIC_NUMBER
Definition version.h:81
fr_value_box_init
#define fr_value_box_init(_vb, _type, _enumv, _tainted)
Initialise a fr_value_box_t.
Definition value.h:610
Generated by   doxygen 1.9.8