1 /* Test the allocate_once function.
2 Copyright (C) 2018-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 #include <allocate_once.h>
20 #include <mcheck.h>
21 #include <string.h>
22 #include <support/check.h>
23 #include <support/support.h>
24
25 /* Allocate a new string. */
26 static void *
27 allocate_string (void *closure)
28 {
29 return xstrdup (closure);
30 }
31
32 /* Allocation and deallocation functions which are not expected to be
33 called. */
34
35 static void *
36 allocate_not_called (void *closure)
37 {
38 FAIL_EXIT1 ("allocation function called unexpectedly (%p)", closure);
39 }
40
41 static void
42 deallocate_not_called (void *closure, void *ptr)
43 {
44 FAIL_EXIT1 ("deallocate function called unexpectedly (%p, %p)",
45 closure, ptr);
46 }
47
48 /* Counter for various function calls. */
49 static int function_called;
50
51 /* An allocation function which returns NULL and records that it has
52 been called. */
53 static void *
54 allocate_return_null (void *closure)
55 {
56 /* The function should only be called once. */
57 TEST_COMPARE (function_called, 0);
58 ++function_called;
59 return NULL;
60 }
61
62
63 /* The following is used to check the retry logic, by causing a fake
64 race condition. */
65 static void *fake_race_place;
66 static char fake_race_region[3]; /* To obtain unique addresses. */
67
68 static void *
69 fake_race_allocate (void *closure)
70 {
71 TEST_VERIFY (closure == &fake_race_region[0]);
72 TEST_COMPARE (function_called, 0);
73 ++function_called;
74 /* Fake allocation by another thread. */
75 fake_race_place = &fake_race_region[1];
76 return &fake_race_region[2];
77 }
78
79 static void
80 fake_race_deallocate (void *closure, void *ptr)
81 {
82 /* Check that the pointer returned from fake_race_allocate is
83 deallocated (and not the one stored in fake_race_place). */
84 TEST_VERIFY (ptr == &fake_race_region[2]);
85
86 TEST_VERIFY (fake_race_place == &fake_race_region[1]);
87 TEST_VERIFY (closure == &fake_race_region[0]);
88 TEST_COMPARE (function_called, 1);
89 ++function_called;
90 }
91
92 /* Similar to fake_race_allocate, but expects to be paired with free
93 as the deallocation function. */
94 static void *
95 fake_race_allocate_for_free (void *closure)
96 {
97 TEST_VERIFY (closure == &fake_race_region[0]);
98 TEST_COMPARE (function_called, 0);
99 ++function_called;
100 /* Fake allocation by another thread. */
101 fake_race_place = &fake_race_region[1];
102 return xstrdup ("to be freed");
103 }
104
105 static int
106 do_test (void)
107 {
108 mtrace ();
109
110 /* Simple allocation. */
111 void *place1 = NULL;
112 char *string1 = allocate_once (&place1, allocate_string,
113 deallocate_not_called,
114 (char *) "test string 1");
115 TEST_VERIFY_EXIT (string1 != NULL);
116 TEST_VERIFY (strcmp ("test string 1", string1) == 0);
117 /* Second call returns the first pointer, without calling any
118 callbacks. */
119 TEST_VERIFY (string1
120 == allocate_once (&place1, allocate_not_called,
121 deallocate_not_called,
122 (char *) "test string 1a"));
123
124 /* Different place should result in another call. */
125 void *place2 = NULL;
126 char *string2 = allocate_once (&place2, allocate_string,
127 deallocate_not_called,
128 (char *) "test string 2");
129 TEST_VERIFY_EXIT (string2 != NULL);
130 TEST_VERIFY (strcmp ("test string 2", string2) == 0);
131 TEST_VERIFY (string1 != string2);
132
133 /* Check error reporting (NULL return value from the allocation
134 function). */
135 void *place3 = NULL;
136 char *string3 = allocate_once (&place3, allocate_return_null,
137 deallocate_not_called, NULL);
138 TEST_VERIFY (string3 == NULL);
139 TEST_COMPARE (function_called, 1);
140
141 /* Check that the deallocation function is called if the race is
142 lost. */
143 function_called = 0;
144 TEST_VERIFY (allocate_once (&fake_race_place,
145 fake_race_allocate,
146 fake_race_deallocate,
147 &fake_race_region[0])
148 == &fake_race_region[1]);
149 TEST_COMPARE (function_called, 2);
150 function_called = 3;
151 TEST_VERIFY (allocate_once (&fake_race_place,
152 fake_race_allocate,
153 fake_race_deallocate,
154 &fake_race_region[0])
155 == &fake_race_region[1]);
156 TEST_COMPARE (function_called, 3);
157
158 /* Similar, but this time rely on that free is called. */
159 function_called = 0;
160 fake_race_place = NULL;
161 TEST_VERIFY (allocate_once (&fake_race_place,
162 fake_race_allocate_for_free,
163 NULL,
164 &fake_race_region[0])
165 == &fake_race_region[1]);
166 TEST_COMPARE (function_called, 1);
167 function_called = 3;
168 TEST_VERIFY (allocate_once (&fake_race_place,
169 fake_race_allocate_for_free,
170 NULL,
171 &fake_race_region[0])
172 == &fake_race_region[1]);
173 TEST_COMPARE (function_called, 3);
174
175 free (place2);
176 free (place1);
177
178 return 0;
179 }
180
181 #include <support/test-driver.c>