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