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/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 <freeradius-devel/util/acutest.h>
43#include <freeradius-devel/util/acutest_helpers.h>
44#include <freeradius-devel/util/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
82static void add_pairs(fr_pair_list_t *local_pairs)
83{
84 int count;
85 fr_pair_t *vp;
86
87 fr_pair_list_init(local_pairs);
88
89 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_uint32);
90 TEST_CHECK(vp != NULL);
91 if (!vp) return;
92 fr_pair_append(local_pairs, vp);
93
94 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_octets);
95 TEST_CHECK(vp != NULL);
96 if (!vp) return;
97 fr_pair_append(local_pairs, vp);
98
99 vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_tlv);
100 TEST_CHECK(vp != NULL);
101 if (!vp) return;
102 fr_pair_append(local_pairs, vp);
103
104 count = fr_pair_list_num_elements(local_pairs);
105 TEST_CASE("Expected (count == 3)");
106 TEST_CHECK(count == 3);
107}
108
109static void expect3(fr_pair_list_t *local_pairs)
110{
111 int count;
112 fr_pair_t *vp;
113
114 count = fr_pair_list_num_elements(local_pairs);
115 TEST_CASE("Expected (count == 3) after undoing the edits");
116 TEST_CHECK(count == 3);
117
118 vp = fr_pair_list_head(local_pairs);
119 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
120
121 vp = fr_pair_list_tail(local_pairs);
122 TEST_CHECK(vp->da == fr_dict_attr_test_tlv);
123
124 fr_pair_list_free(local_pairs);
125}
126
127/*
128 * Tests functions
129 */
130static void test_pair_delete_head(void)
131{
132 fr_pair_t *vp;
133 fr_pair_list_t local_pairs;
134 size_t count;
135 fr_edit_list_t *el;
136 int rcode;
137
138 TEST_CASE("Add 3 pairs and delete the first one");
139
140 add_pairs(&local_pairs);
141
142 vp = fr_pair_list_head(&local_pairs);
143
144 el = fr_edit_list_alloc(NULL, 5, NULL);
145 fr_assert(el != NULL);
146
147 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp);
148 TEST_CHECK(rcode == 0);
149
150 fr_edit_list_commit(el);
151
152 count = fr_pair_list_num_elements(&local_pairs);
153 TEST_CASE("Expected (count == 2) after deleting the head");
154 TEST_CHECK(count == 2);
155
156 vp = fr_pair_list_head(&local_pairs);
157 TEST_CASE("head is now what was the second pair");
158 TEST_CHECK(vp->da == fr_dict_attr_test_octets);
159
160 fr_pair_list_free(&local_pairs);
161}
162
163static void test_pair_delete_head_abort(void)
164{
165 fr_pair_t *vp;
166 fr_pair_list_t local_pairs;
167 size_t count;
168 fr_edit_list_t *el;
169 int rcode;
170
171 TEST_CASE("Add 3 pairs and delete the first one");
172
173 add_pairs(&local_pairs);
174
175 vp = fr_pair_list_head(&local_pairs);
176
177 el = fr_edit_list_alloc(NULL, 5, NULL);
178 fr_assert(el != NULL);
179
180 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp);
181 TEST_CHECK(rcode == 0);
182
183 count = fr_pair_list_num_elements(&local_pairs);
184 TEST_CASE("Expected (count == 2) after deleting the head");
185 TEST_CHECK(count == 2);
186
187 /*
188 * Abort the edit
189 */
190 fr_edit_list_abort(el);
191
192 expect3(&local_pairs);
193}
194
195static void test_pair_delete_middle(void)
196{
197 fr_pair_t *vp;
198 fr_pair_list_t local_pairs;
199 size_t count;
200 fr_edit_list_t *el;
201 int rcode;
202
203 TEST_CASE("Add 3 pairs and delete the middle one");
204
205 add_pairs(&local_pairs);
206
207 vp = fr_pair_list_head(&local_pairs);
208 vp = fr_pair_list_next(&local_pairs, vp);
209 fr_assert(vp != NULL);
210
211 el = fr_edit_list_alloc(NULL, 5, NULL);
212 fr_assert(el != NULL);
213
214 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp);
215 TEST_CHECK(rcode == 0);
216
217 fr_edit_list_commit(el);
218
219 /* let's count */
220 count = fr_pair_list_num_elements(&local_pairs);
221 TEST_CASE("Expected (count == 2) after deleting the middle");
222 TEST_CHECK(count == 2);
223
224 vp = fr_pair_list_head(&local_pairs);
225 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
226
227 vp = fr_pair_list_tail(&local_pairs);
228 TEST_CHECK(vp->da == fr_dict_attr_test_tlv);
229
230 fr_pair_list_free(&local_pairs);
231}
232
233static void test_pair_delete_middle_abort(void)
234{
235 fr_pair_t *vp, *middle;
236 fr_pair_list_t local_pairs;
237 size_t count;
238 fr_edit_list_t *el;
239 int rcode;
240
241 TEST_CASE("Add 3 pairs and delete the middle one, then abort");
242
243 add_pairs(&local_pairs);
244
245 vp = fr_pair_list_head(&local_pairs);
246 middle = fr_pair_list_next(&local_pairs, vp);
247 fr_assert(middle != NULL);
248 TEST_CHECK(middle->da == fr_dict_attr_test_octets);
249
250 el = fr_edit_list_alloc(NULL, 5, NULL);
251 fr_assert(el != NULL);
252
253 rcode = fr_edit_list_pair_delete(el, &local_pairs, middle);
254 TEST_CHECK(rcode == 0);
255
256 count = fr_pair_list_num_elements(&local_pairs);
257 TEST_CASE("Expected (count == 2) after deleting the middle");
258 TEST_CHECK(count == 2);
259
260 vp = fr_pair_list_head(&local_pairs);
261 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
262
263 vp = fr_pair_list_tail(&local_pairs);
264 TEST_CHECK(vp->da == fr_dict_attr_test_tlv);
265
266 /*
267 * Abort the edit
268 */
269 fr_edit_list_abort(el);
270
271 expect3(&local_pairs);
272}
273
274static void test_pair_delete_multiple(void)
275{
276 fr_pair_t *vp;
277 fr_pair_list_t local_pairs;
278 size_t count;
279 fr_edit_list_t *el;
280 int rcode;
281
282 TEST_CASE("Add 3 pairs and delete the last 2");
283
284 add_pairs(&local_pairs);
285
286 vp = fr_pair_list_head(&local_pairs);
287 vp = fr_pair_list_next(&local_pairs, vp);
288 fr_assert(vp != NULL);
289
290 el = fr_edit_list_alloc(NULL, 5, NULL);
291 fr_assert(el != NULL);
292
293 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp); /* middle */
294 TEST_CHECK(rcode == 0);
295
296 vp = fr_pair_list_tail(&local_pairs);
297 fr_assert(vp != NULL);
298
299 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp); /* tail */
300 TEST_CHECK(rcode == 0);
301
302 fr_edit_list_commit(el);
303
304 count = fr_pair_list_num_elements(&local_pairs);
305 TEST_CASE("Expected (count == 1) after deleting the last 2");
306 TEST_CHECK(count == 1);
307
308 vp = fr_pair_list_head(&local_pairs);
309 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
310
311 vp = fr_pair_list_tail(&local_pairs);
312 TEST_CHECK(vp->da == fr_dict_attr_test_uint32); /* head == tail */
313
314 fr_pair_list_free(&local_pairs);
315}
316
317static void test_pair_delete_multiple_abort(void)
318{
319 fr_pair_t *vp;
320 fr_pair_list_t local_pairs;
321 size_t count;
322 fr_edit_list_t *el;
323 int rcode;
324
325 TEST_CASE("Add 3 pairs and delete the last two, then abort");
326
327 add_pairs(&local_pairs);
328
329 vp = fr_pair_list_head(&local_pairs);
330 fr_assert(vp != NULL);
331 vp = fr_pair_list_next(&local_pairs, vp);
332 fr_assert(vp != NULL);
333 TEST_CHECK(vp->da == fr_dict_attr_test_octets);
334
335 el = fr_edit_list_alloc(NULL, 5, NULL);
336 fr_assert(el != NULL);
337
338 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp); /* middle */
339 TEST_CHECK(rcode == 0);
340
341 vp = fr_pair_list_tail(&local_pairs);
342 fr_assert(vp != NULL);
343
344 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp); /* tail */
345 TEST_CHECK(rcode == 0);
346
347 count = fr_pair_list_num_elements(&local_pairs);
348 TEST_CASE("Expected (count == 1) after deleting the last 2");
349 TEST_CHECK(count == 1);
350
351 vp = fr_pair_list_head(&local_pairs);
352 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
353
354 vp = fr_pair_list_tail(&local_pairs);
355 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
356
357 /*
358 * Abort the edit
359 */
360 fr_edit_list_abort(el);
361
362 expect3(&local_pairs);
363}
364
365
366static void test_pair_edit_value(void)
367{
368 fr_pair_t *vp;
369 fr_pair_list_t local_pairs;
370 fr_edit_list_t *el;
371 int rcode;
372
373 TEST_CASE("Add 3 pairs and change the value of the first one");
374
375 add_pairs(&local_pairs);
376
377 vp = fr_pair_list_head(&local_pairs);
378 fr_assert(vp != NULL);
379
380 el = fr_edit_list_alloc(NULL, 5, NULL);
381 fr_assert(el != NULL);
382
383 rcode = fr_edit_list_save_pair_value(el, vp);
384 TEST_CHECK(rcode == 0);
385
386 TEST_CHECK(vp->vp_uint32 == 0);
387
388 vp->vp_uint32 = 1;
389 TEST_CHECK(vp->vp_uint32 == 1);
390
391 fr_edit_list_commit(el);
392
393 vp = fr_pair_list_head(&local_pairs);
394 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
395 TEST_CHECK(vp->vp_uint32 == 1);
396
397 expect3(&local_pairs);
398}
399
400static void test_pair_edit_value_abort(void)
401{
402 fr_pair_t *vp;
403 fr_pair_list_t local_pairs;
404 fr_edit_list_t *el;
405 int rcode;
406
407 TEST_CASE("Add 3 pairs and change the value of the first one, then abort");
408
409 add_pairs(&local_pairs);
410
411 vp = fr_pair_list_head(&local_pairs);
412 fr_assert(vp != NULL);
413
414 el = fr_edit_list_alloc(NULL, 5, NULL);
415 fr_assert(el != NULL);
416
417 rcode = fr_edit_list_save_pair_value(el, vp);
418 TEST_CHECK(rcode == 0);
419
420 TEST_CHECK(vp->vp_uint32 == 0);
421
422 vp->vp_uint32 = 1;
423 TEST_CHECK(vp->vp_uint32 == 1);
424
425 /*
426 * Abort the edit
427 */
428 fr_edit_list_abort(el);
429
430 vp = fr_pair_list_head(&local_pairs);
431 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
432 TEST_CHECK(vp->vp_uint32 == 0);
433
434 expect3(&local_pairs);
435}
436
437static void test_pair_insert_after_head(void)
438{
439 fr_pair_t *vp;
440 fr_pair_list_t local_pairs;
441 size_t count;
442 fr_edit_list_t *el;
443 int rcode;
444
445 TEST_CASE("Add 3 pairs and insert a new one at the head");
446
447 add_pairs(&local_pairs);
448
449 el = fr_edit_list_alloc(NULL, 5, NULL);
450 fr_assert(el != NULL);
451
452 TEST_CHECK((vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string)) != NULL);
453
454 rcode = fr_edit_list_insert_pair_after(el, &local_pairs, NULL, vp);
455 TEST_CHECK(rcode == 0);
456
457 fr_edit_list_commit(el);
458
459 count = fr_pair_list_num_elements(&local_pairs);
460 TEST_CASE("Expected (count == 4) after inserting a new one");
461 TEST_CHECK(count == 4);
462
463 vp = fr_pair_list_head(&local_pairs);
464 TEST_CASE("head is now what was the second pair");
465 TEST_CHECK(vp->da == fr_dict_attr_test_string);
466
467 fr_pair_list_free(&local_pairs);
468}
469
470static void test_pair_insert_after_head_abort(void)
471{
472 fr_pair_t *vp;
473 fr_pair_list_t local_pairs;
474 size_t count;
475 fr_edit_list_t *el;
476 int rcode;
477
478 TEST_CASE("Add 3 pairs and insert a new one at the head, then abort");
479
480 add_pairs(&local_pairs);
481
482 el = fr_edit_list_alloc(NULL, 5, NULL);
483 fr_assert(el != NULL);
484
485 TEST_CHECK((vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string)) != NULL);
486
487 rcode = fr_edit_list_insert_pair_after(el, &local_pairs, NULL, vp);
488 TEST_CHECK(rcode == 0);
489
490 count = fr_pair_list_num_elements(&local_pairs);
491 TEST_CASE("Expected (count == 4) after inserting a new one");
492 TEST_CHECK(count == 4);
493
494 /*
495 * Abort the edit
496 */
497 fr_edit_list_abort(el);
498
499 expect3(&local_pairs);
500}
501
502static void test_pair_insert_after_middle(void)
503{
504 fr_pair_t *vp, *middle;
505 fr_pair_list_t local_pairs;
506 size_t count;
507 fr_edit_list_t *el;
508 int rcode;
509
510 TEST_CASE("Add 3 pairs and insert a new one at the head");
511
512 add_pairs(&local_pairs);
513
514 vp = fr_pair_list_head(&local_pairs);
515 middle = fr_pair_list_next(&local_pairs, vp);
516 fr_assert(middle != NULL);
517
518 el = fr_edit_list_alloc(NULL, 5, NULL);
519 fr_assert(el != NULL);
520
521 TEST_CHECK((vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string)) != NULL);
522
523 rcode = fr_edit_list_insert_pair_after(el, &local_pairs, middle, vp);
524 TEST_CHECK(rcode == 0);
525
526 fr_edit_list_commit(el);
527
528 count = fr_pair_list_num_elements(&local_pairs);
529 TEST_CASE("Expected (count == 4) after inserting a new one");
530 TEST_CHECK(count == 4);
531
532 fr_pair_list_free(&local_pairs);
533}
534
535static void test_pair_insert_after_middle_abort(void)
536{
537 fr_pair_t *vp, *middle;
538 fr_pair_list_t local_pairs;
539 size_t count;
540 fr_edit_list_t *el;
541 int rcode;
542
543 TEST_CASE("Add 3 pairs and insert a new one at the head, then abort");
544
545 add_pairs(&local_pairs);
546
547 vp = fr_pair_list_head(&local_pairs);
548 middle = fr_pair_list_next(&local_pairs, vp);
549 fr_assert(middle != NULL);
550
551 el = fr_edit_list_alloc(NULL, 5, NULL);
552 fr_assert(el != NULL);
553
554 TEST_CHECK((vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string)) != NULL);
555
556 rcode = fr_edit_list_insert_pair_after(el, &local_pairs, middle, vp);
557 TEST_CHECK(rcode == 0);
558
559 count = fr_pair_list_num_elements(&local_pairs);
560 TEST_CASE("Expected (count == 4) after inserting a new one");
561 TEST_CHECK(count == 4);
562
563 /*
564 * Abort the edit
565 */
566 fr_edit_list_abort(el);
567
568 expect3(&local_pairs);
569}
570
571static void test_pair_edit_value_delete(void)
572{
573 fr_pair_t *vp;
574 fr_pair_list_t local_pairs;
575 fr_edit_list_t *el;
576 int rcode, count;
577
578 TEST_CASE("Add 3 pairs, change the value of the first one, and delete it");
579
580 add_pairs(&local_pairs);
581
582 vp = fr_pair_list_head(&local_pairs);
583 fr_assert(vp != NULL);
584
585 el = fr_edit_list_alloc(NULL, 5, NULL);
586 fr_assert(el != NULL);
587
588 rcode = fr_edit_list_save_pair_value(el, vp);
589 TEST_CHECK(rcode == 0);
590
591 TEST_CHECK(vp->vp_uint32 == 0);
592
593 vp->vp_uint32 = 1;
594 TEST_CHECK(vp->vp_uint32 == 1);
595
596 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp);
597 TEST_CHECK(rcode == 0);
598
599 fr_edit_list_commit(el);
600
601 vp = fr_pair_list_head(&local_pairs);
602 TEST_CHECK(vp->da == fr_dict_attr_test_octets);
603
604 count = fr_pair_list_num_elements(&local_pairs);
605 TEST_CASE("Expected (count == 2) after deleting the edited pair");
606 TEST_CHECK(count == 2);
607}
608
609static void test_pair_edit_value_delete_abort(void)
610{
611 fr_pair_t *vp;
612 fr_pair_list_t local_pairs;
613 fr_edit_list_t *el;
614 int rcode;
615
616 TEST_CASE("Add 3 pairs, change the value of the first one, and delete it, then abort");
617
618 add_pairs(&local_pairs);
619
620 vp = fr_pair_list_head(&local_pairs);
621 fr_assert(vp != NULL);
622
623 el = fr_edit_list_alloc(NULL, 5, NULL);
624 fr_assert(el != NULL);
625
626 rcode = fr_edit_list_save_pair_value(el, vp);
627 TEST_CHECK(rcode == 0);
628
629 TEST_CHECK(vp->vp_uint32 == 0);
630
631 vp->vp_uint32 = 1;
632 TEST_CHECK(vp->vp_uint32 == 1);
633
634 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp);
635 TEST_CHECK(rcode == 0);
636
637 /*
638 * Abort the edit
639 */
640 fr_edit_list_abort(el);
641
642 vp = fr_pair_list_head(&local_pairs);
643 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
644 TEST_CHECK(vp->vp_uint32 == 0);
645
646 expect3(&local_pairs);
647}
648
649static void test_pair_insert_after_head_delete(void)
650{
651 fr_pair_t *vp;
652 fr_pair_list_t local_pairs;
653 size_t count;
654 fr_edit_list_t *el;
655 int rcode;
656
657 TEST_CASE("Add 3 pairs and insert a new one at the head, and delete it");
658
659 add_pairs(&local_pairs);
660
661 el = fr_edit_list_alloc(NULL, 5, NULL);
662 fr_assert(el != NULL);
663
664 TEST_CHECK((vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string)) != NULL);
665
666 rcode = fr_edit_list_insert_pair_after(el, &local_pairs, NULL, vp);
667 TEST_CHECK(rcode == 0);
668
669 count = fr_pair_list_num_elements(&local_pairs);
670 TEST_CASE("Expected (count == 4) after inserting a new one");
671 TEST_CHECK(count == 4);
672
673 rcode = fr_edit_list_pair_delete(el, &local_pairs, vp);
674 TEST_CHECK(rcode == 0);
675
676 count = fr_pair_list_num_elements(&local_pairs);
677 TEST_CASE("Expected (count == 3) after deleting the just inserted on");
678 TEST_CHECK(count == 3);
679
680 fr_edit_list_commit(el);
681
682 expect3(&local_pairs);
683}
684
685static void test_pair_insert_after_head_delete_abort(void)
686{
687 fr_pair_t *vp;
688 fr_pair_list_t local_pairs;
689 size_t count;
690 fr_edit_list_t *el;
691 int rcode;
692
693 TEST_CASE("Add 3 pairs and insert a new one at the head and delete it, then abort");
694
695 add_pairs(&local_pairs);
696
697 el = fr_edit_list_alloc(NULL, 5, NULL);
698 fr_assert(el != NULL);
699
700 TEST_CHECK((vp = fr_pair_afrom_da(autofree, fr_dict_attr_test_string)) != NULL);
701
702 rcode = fr_edit_list_insert_pair_after(el, &local_pairs, NULL, vp);
703 TEST_CHECK(rcode == 0);
704
705 count = fr_pair_list_num_elements(&local_pairs);
706 TEST_CASE("Expected (count == 4) after inserting a new one");
707 TEST_CHECK(count == 4);
708
709 /*
710 * Abort the edit
711 */
712 fr_edit_list_abort(el);
713
714 expect3(&local_pairs);
715}
716
717
718static void test_pair_edit_child_value(void)
719{
720 fr_pair_t *vp;
721 fr_pair_list_t local_pairs;
722 fr_edit_list_t *el, *child;
723 int rcode;
724
725 TEST_CASE("Add 3 pairs and change the value of the first one in a child transaction");
726
727 add_pairs(&local_pairs);
728
729 vp = fr_pair_list_head(&local_pairs);
730 fr_assert(vp != NULL);
731
732 el = fr_edit_list_alloc(NULL, 5, NULL);
733 fr_assert(el != NULL);
734
735 rcode = fr_edit_list_save_pair_value(el, vp);
736 TEST_CHECK(rcode == 0);
737
738 TEST_CHECK(vp->vp_uint32 == 0);
739
740 vp->vp_uint32 = 1;
741 TEST_CHECK(vp->vp_uint32 == 1);
742
743 child = fr_edit_list_alloc(NULL, 5, el);
744 fr_assert(child != NULL);
745
746 rcode = fr_edit_list_save_pair_value(child, vp); /* CHILD */
747 TEST_CHECK(rcode == 0);
748
749 TEST_CHECK(vp->vp_uint32 == 1);
750
751 vp->vp_uint32 = 2;
752 TEST_CHECK(vp->vp_uint32 == 2);
753
754 fr_edit_list_commit(child); /* should do nothing */
755
756 TEST_CHECK(vp->vp_uint32 == 2);
757
758 fr_edit_list_commit(el);
759
760 vp = fr_pair_list_head(&local_pairs);
761 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
762 TEST_CHECK(vp->vp_uint32 == 2);
763
764 expect3(&local_pairs);
765}
766
767static void test_pair_edit_child_value_abort(void)
768{
769 fr_pair_t *vp;
770 fr_pair_list_t local_pairs;
771 fr_edit_list_t *el, *child;
772 int rcode;
773
774 TEST_CASE("Add 3 pairs and change the value of the first one, then abort");
775
776 add_pairs(&local_pairs);
777
778 vp = fr_pair_list_head(&local_pairs);
779 fr_assert(vp != NULL);
780
781 el = fr_edit_list_alloc(NULL, 5, NULL);
782 fr_assert(el != NULL);
783
784 rcode = fr_edit_list_save_pair_value(el, vp);
785 TEST_CHECK(rcode == 0);
786
787 TEST_CHECK(vp->vp_uint32 == 0);
788
789 vp->vp_uint32 = 1;
790 TEST_CHECK(vp->vp_uint32 == 1);
791
792 child = fr_edit_list_alloc(NULL, 5, el);
793 fr_assert(child != NULL);
794
795 rcode = fr_edit_list_save_pair_value(child, vp); /* CHILD */
796 TEST_CHECK(rcode == 0);
797
798 TEST_CHECK(vp->vp_uint32 == 1);
799
800 vp->vp_uint32 = 2;
801 TEST_CHECK(vp->vp_uint32 == 2);
802
803 fr_edit_list_abort(child); /* CHILD */
804
805 TEST_CHECK(vp->vp_uint32 == 1);
806
807 fr_edit_list_commit(el);
808
809 vp = fr_pair_list_head(&local_pairs);
810 TEST_CHECK(vp->da == fr_dict_attr_test_uint32);
811 TEST_CHECK(vp->vp_uint32 == 1);
812
813 expect3(&local_pairs);
814}
815
816TEST_LIST = {
817 /*
818 * Deletion.
819 */
820 { "pair_delete_head", test_pair_delete_head },
821 { "pair_delete_head_abort", test_pair_delete_head_abort },
822
823 { "pair_delete_middle", test_pair_delete_middle },
824 { "pair_delete_middle_abort", test_pair_delete_middle_abort },
825
826 { "pair_delete_multiple", test_pair_delete_multiple },
827 { "pair_delete_multiple_abort", test_pair_delete_multiple_abort },
828
829 /*
830 * Insert after
831 */
832 { "pair_insert_after_head", test_pair_insert_after_head },
833 { "pair_insert_after_head_abort", test_pair_insert_after_head_abort },
834
835 { "pair_insert_after_middle", test_pair_insert_after_middle },
836 { "pair_insert_after_middle_abort", test_pair_insert_after_middle_abort },
837
838 /*
839 * Value modification
840 */
841 { "pair_edit_value", test_pair_edit_value },
842 { "pair_edit_value_abort", test_pair_edit_value_abort },
843
844 /*
845 * Value modification, then deletion
846 */
847 { "pair_edit_value_delete", test_pair_edit_value_delete },
848 { "pair_edit_value_delete_abort", test_pair_edit_value_delete_abort },
849
850 /*
851 * Insert after, then delete
852 */
853 { "pair_insert_after_head_delete", test_pair_insert_after_head_delete },
854 { "pair_insert_after_head_delete_abort", test_pair_insert_after_head_delete_abort },
855
856 /*
857 * Value modification in child list
858 */
859 { "pair_edit_child_value", test_pair_edit_child_value },
860 { "pair_edit_child_value_abort", test_pair_edit_child_value_abort },
861
862 { NULL }
863};
TEST_CHECK
#define TEST_CHECK(cond)
Definition acutest.h:85
TEST_CASE
#define TEST_CASE(name)
Definition acutest.h:184
__attribute__
Definition bfd.h:63
fr_exit_now
#define fr_exit_now(_x)
Exit without calling atexit() handlers, producing a log message in debug builds.
Definition debug.h:234
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
test_pair_delete_multiple
static void test_pair_delete_multiple(void)
Definition edit_tests.c:274
test_pair_delete_head
static void test_pair_delete_head(void)
Definition edit_tests.c:130
TEST_LIST
TEST_LIST
Definition edit_tests.c:816
test_pair_delete_head_abort
static void test_pair_delete_head_abort(void)
Definition edit_tests.c:163
test_pair_delete_multiple_abort
static void test_pair_delete_multiple_abort(void)
Definition edit_tests.c:317
test_pair_edit_value_delete_abort
static void test_pair_edit_value_delete_abort(void)
Definition edit_tests.c:609
test_pair_insert_after_head_delete_abort
static void test_pair_insert_after_head_delete_abort(void)
Definition edit_tests.c:685
test_pair_delete_middle_abort
static void test_pair_delete_middle_abort(void)
Definition edit_tests.c:233
expect3
static void expect3(fr_pair_list_t *local_pairs)
Definition edit_tests.c:109
test_pair_edit_value
static void test_pair_edit_value(void)
Definition edit_tests.c:366
test_pair_insert_after_middle
static void test_pair_insert_after_middle(void)
Definition edit_tests.c:502
test_pair_edit_child_value
static void test_pair_edit_child_value(void)
Definition edit_tests.c:718
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:470
test_pair_insert_after_head
static void test_pair_insert_after_head(void)
Definition edit_tests.c:437
test_pair_insert_after_head_delete
static void test_pair_insert_after_head_delete(void)
Definition edit_tests.c:649
test_pair_edit_child_value_abort
static void test_pair_edit_child_value_abort(void)
Definition edit_tests.c:767
test_pair_delete_middle
static void test_pair_delete_middle(void)
Definition edit_tests.c:195
test_pair_edit_value_delete
static void test_pair_edit_value_delete(void)
Definition edit_tests.c:571
test_init
static void test_init(void)
Global initialisation.
Definition edit_tests.c:36
test_pair_edit_value_abort
static void test_pair_edit_value_abort(void)
Definition edit_tests.c:400
test_pair_insert_after_middle_abort
static void test_pair_insert_after_middle_abort(void)
Definition edit_tests.c:535
fr_dict_t
Definition merged_model.c:198
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:1345
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:283
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:45
test_dict
static fr_dict_t * test_dict
Definition pair_server_tests.c:46
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
autofree
static TALLOC_CTX * autofree
Definition radclient-ng.c:107
local_pairs
#define local_pairs
Convenience macro for accessing the state list.
Definition request.h:134
count
return count
Definition module.c:163
vp
fr_pair_t * vp
Definition state_machine.c:2262
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:270
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:575
fr_edit_list_commit
void fr_edit_list_commit(fr_edit_list_t *el)
Commit an edit list.
Definition edit.c:841
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:562
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:622
fr_edit_list_abort
void fr_edit_list_abort(fr_edit_list_t *el)
Abort the entries in an edit list.
Definition edit.c:194
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:790
fr_edit_list_s
Track a series of edits.
Definition edit.c:102
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:70
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:56
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:113
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:43
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:151
fr_perror
void fr_perror(char const *fmt,...)
Print the current error to stderr with a prefix.
Definition strerror.c:733
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
Generated by   doxygen 1.9.8