The FreeRADIUS server  $Id: 15bac2a4c627c01d1aa2047687b3418955ac7f00 $
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
36 static void test_init(void) __attribute__((constructor));
37 #else
38 static 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 
54 static TALLOC_CTX *autofree;
55 static fr_pair_list_t test_pairs;
56 static fr_dict_t *test_dict;
57 
58 /** Global initialisation
59  */
60 static 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 
82 static 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 
109 static 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  */
130 static 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 
163 static 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 
195 static 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 
233 static 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 
274 static 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 
317 static 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 
366 static 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 
400 static 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 
437 static 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 
470 static 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 
502 static 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 
535 static 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 
571 static 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 
609 static 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 
649 static 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 
685 static 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 
718 static 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 
767 static 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 
816 TEST_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__
typedef __attribute__
fr_exit_now
#define fr_exit_now(_x)
Exit without calling atexit() handlers, producing a log message in debug builds.
Definition: debug.h:232
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_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:278
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:1340
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:47
test_dict
static fr_dict_t * test_dict
Definition: pair_server_tests.c:48
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
autofree
static TALLOC_CTX * autofree
Definition: radclient-ng.c:104
local_pairs
#define local_pairs
Convenience macro for accessing the state list.
Definition: request.h:134
count
return count
Definition: module.c:175
fr_assert
fr_assert(0)
vp
fr_pair_t * vp
Definition: state_machine.c:2271
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:268
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_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_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_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_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_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.1