1 /* Unit test for ldconfig string tables.
2 Copyright (C) 2020-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; version 2 of the License, or
8 (at your option) any later version.
9
10 This program 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
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, see <https://www.gnu.org/licenses/>. */
17
18 #include <array_length.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <stringtable.h>
22 #include <support/check.h>
23 #include <support/support.h>
24
25 static int
26 do_test (void)
27 {
28 /* Empty string table. */
29 {
30 struct stringtable s = { 0, };
31 struct stringtable_finalized f;
32 stringtable_finalize (&s, &f);
33 TEST_COMPARE_STRING (f.strings, "");
34 TEST_COMPARE (f.size, 0);
35 free (f.strings);
36 stringtable_free (&s);
37 }
38
39 /* String table with one empty string. */
40 {
41 struct stringtable s = { 0, };
42 struct stringtable_entry *e = stringtable_add (&s, "");
43 TEST_COMPARE_STRING (e->string, "");
44 TEST_COMPARE (e->length, 0);
45 TEST_COMPARE (s.count, 1);
46
47 struct stringtable_finalized f;
48 stringtable_finalize (&s, &f);
49 TEST_COMPARE (e->offset, 0);
50 TEST_COMPARE_STRING (f.strings, "");
51 TEST_COMPARE (f.size, 1);
52 free (f.strings);
53 stringtable_free (&s);
54 }
55
56 /* String table with one non-empty string. */
57 {
58 struct stringtable s = { 0, };
59 struct stringtable_entry *e = stringtable_add (&s, "name");
60 TEST_COMPARE_STRING (e->string, "name");
61 TEST_COMPARE (e->length, 4);
62 TEST_COMPARE (s.count, 1);
63
64 struct stringtable_finalized f;
65 stringtable_finalize (&s, &f);
66 TEST_COMPARE (e->offset, 0);
67 TEST_COMPARE_STRING (f.strings, "name");
68 TEST_COMPARE (f.size, 5);
69 free (f.strings);
70 stringtable_free (&s);
71 }
72
73 /* Two strings, one is a prefix of the other. Tail-merging can only
74 happen in one way in this case. */
75 {
76 struct stringtable s = { 0, };
77 struct stringtable_entry *suffix = stringtable_add (&s, "suffix");
78 TEST_COMPARE_STRING (suffix->string, "suffix");
79 TEST_COMPARE (suffix->length, 6);
80 TEST_COMPARE (s.count, 1);
81
82 struct stringtable_entry *prefix
83 = stringtable_add (&s, "prefix-suffix");
84 TEST_COMPARE_STRING (prefix->string, "prefix-suffix");
85 TEST_COMPARE (prefix->length, strlen ("prefix-suffix"));
86 TEST_COMPARE (s.count, 2);
87
88 struct stringtable_finalized f;
89 stringtable_finalize (&s, &f);
90 TEST_COMPARE (prefix->offset, 0);
91 TEST_COMPARE (suffix->offset, strlen ("prefix-"));
92 TEST_COMPARE_STRING (f.strings, "prefix-suffix");
93 TEST_COMPARE (f.size, sizeof ("prefix-suffix"));
94 free (f.strings);
95 stringtable_free (&s);
96 }
97
98 /* String table with various shared prefixes. Triggers hash
99 resizing. */
100 {
101 enum { count = 1500 };
102 char *strings[2 * count];
103 struct stringtable_entry *entries[2 * count];
104 struct stringtable s = { 0, };
105 for (int i = 0; i < count; ++i)
106 {
107 strings[i] = xasprintf ("%d", i);
108 entries[i] = stringtable_add (&s, strings[i]);
109 TEST_COMPARE (entries[i]->length, strlen (strings[i]));
110 TEST_COMPARE_STRING (entries[i]->string, strings[i]);
111 strings[i + count] = xasprintf ("prefix/%d", i);
112 entries[i + count] = stringtable_add (&s, strings[i + count]);
113 TEST_COMPARE (entries[i + count]->length, strlen (strings[i + count]));
114 TEST_COMPARE_STRING (entries[i + count]->string, strings[i + count]);
115 }
116
117 struct stringtable_finalized f;
118 stringtable_finalize (&s, &f);
119
120 for (int i = 0; i < 2 * count; ++i)
121 {
122 TEST_COMPARE (entries[i]->length, strlen (strings[i]));
123 TEST_COMPARE_STRING (entries[i]->string, strings[i]);
124 TEST_COMPARE_STRING (f.strings + entries[i]->offset, strings[i]);
125 free (strings[i]);
126 }
127
128 free (f.strings);
129 stringtable_free (&s);
130 }
131
132 /* Verify that maximum tail merging happens. */
133 {
134 struct stringtable s = { 0, };
135 const char *strings[] = {
136 "",
137 "a",
138 "b",
139 "aa",
140 "aaa",
141 "aa",
142 "bb",
143 "b",
144 "a",
145 "ba",
146 "baa",
147 };
148 struct stringtable_entry *entries[array_length (strings)];
149 for (int i = 0; i < array_length (strings); ++i)
150 entries[i] = stringtable_add (&s, strings[i]);
151 for (int i = 0; i < array_length (strings); ++i)
152 TEST_COMPARE_STRING (entries[i]->string, strings[i]);
153
154 struct stringtable_finalized f;
155 stringtable_finalize (&s, &f);
156
157 /* There are only four different strings, "aaa", "ba", "baa",
158 "bb". The rest is shared in an unspecified fashion. */
159 TEST_COMPARE (f.size, 4 + 3 + 4 + 3);
160
161 for (int i = 0; i < array_length (strings); ++i)
162 {
163 TEST_COMPARE_STRING (entries[i]->string, strings[i]);
164 TEST_COMPARE_STRING (f.strings + entries[i]->offset, strings[i]);
165 }
166
167 free (f.strings);
168 stringtable_free (&s);
169 }
170
171 return 0;
172 }
173
174 #include <support/test-driver.c>
175
176 /* Re-compile the string table implementation here. It is not
177 possible to link against the actual build because it was built for
178 use in ldconfig. */
179 #define _(arg) arg
180 #include "stringtable.c"
181 #include "stringtable_free.c"