~mdw / dpkg / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
dpkg (1.18.25) stretch; urgency=medium
[dpkg] / lib / dpkg / t / t-varbuf.c
CommitLineData
1479465f
GJ		 1/*
2 * libdpkg - Debian packaging suite library routines
3 * t-verbuf.c - test varbuf implementation
4 *
5 * Copyright © 2009-2011, 2013-2015 Guillem Jover <guillem@debian.org>
6 *
7 * This is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <https://www.gnu.org/licenses/>.
19 */
20
21#include <config.h>
22#include <compat.h>
23
24#include <dpkg/test.h>
25#include <dpkg/varbuf.h>
26
27#include <string.h>
28#include <stdlib.h>
29
30static void
31test_varbuf_init(void)
32{
33 struct varbuf vb;
34
35 varbuf_init(&vb, 0);
36 test_pass(vb.used == 0);
37 test_pass(vb.size == 0);
38 test_pass(vb.buf == NULL);
39
40 varbuf_destroy(&vb);
41 test_pass(vb.used == 0);
42 test_pass(vb.size == 0);
43 test_pass(vb.buf == NULL);
44}
45
46static void
47test_varbuf_prealloc(void)
48{
49 struct varbuf vb;
50
51 varbuf_init(&vb, 10);
52 test_pass(vb.used == 0);
53 test_pass(vb.size >= 10);
54 test_pass(vb.buf != NULL);
55
56 varbuf_destroy(&vb);
57 test_pass(vb.used == 0);
58 test_pass(vb.size == 0);
59 test_pass(vb.buf == NULL);
60}
61
62static void
63test_varbuf_grow(void)
64{
65 struct varbuf vb;
66 size_t old_size;
67 int i;
68
69 varbuf_init(&vb, 10);
70
71 /* Test that we grow when needed. */
72 varbuf_grow(&vb, 100);
73 test_pass(vb.used == 0);
74 test_pass(vb.size >= 100);
75
76 old_size = vb.size;
77
78 /* Test that we are not leaking. */
79 for (i = 0; i < 10; i++) {
80 varbuf_grow(&vb, 100);
81 test_pass(vb.used == 0);
82 test_pass(vb.size >= 100);
83 test_pass(vb.size == old_size);
84 }
85
86 /* Test that we grow when needed, with used space. */
87 vb.used = 10;
88 varbuf_grow(&vb, 100);
89 test_pass(vb.used == 10);
90 test_pass(vb.size >= 110);
91
92 varbuf_destroy(&vb);
93}
94
95static void
96test_varbuf_trunc(void)
97{
98 struct varbuf vb;
99
100 varbuf_init(&vb, 50);
101
102 /* Test that we truncate (grow). */
103 varbuf_trunc(&vb, 20);
104 test_pass(vb.used == 20);
105 test_pass(vb.size >= 50);
106
107 /* Test that we truncate (shrink). */
108 varbuf_trunc(&vb, 10);
109 test_pass(vb.used == 10);
110 test_pass(vb.size >= 50);
111
112 varbuf_destroy(&vb);
113}
114
115static void
116test_varbuf_add_buf(void)
117{
118 struct varbuf vb;
119
120 varbuf_init(&vb, 5);
121
122 varbuf_add_buf(&vb, "1234567890", 10);
123 test_pass(vb.used == 10);
124 test_pass(vb.size >= vb.used);
125 test_mem(vb.buf, ==, "1234567890", 10);
126
127 varbuf_add_buf(&vb, "abcde", 5);
128 test_pass(vb.used == 15);
129 test_pass(vb.size >= vb.used);
130 test_mem(vb.buf, ==, "1234567890abcde", 15);
131
132 varbuf_destroy(&vb);
133}
134
135static void
136test_varbuf_add_char(void)
137{
138 struct varbuf vb;
139
140 varbuf_init(&vb, 1);
141
142 varbuf_add_char(&vb, 'a');
143 test_pass(vb.used == 1);
144 test_pass(vb.size >= vb.used);
145 test_pass(vb.buf[0] == 'a');
146
147 varbuf_add_char(&vb, 'b');
148 test_pass(vb.used == 2);
149 test_pass(vb.size >= vb.used);
150 test_mem(vb.buf, ==, "ab", 2);
151
152 varbuf_add_char(&vb, 'c');
153 test_pass(vb.used == 3);
154 test_pass(vb.size >= vb.used);
155 test_mem(vb.buf, ==, "abc", 3);
156
157 varbuf_add_char(&vb, 'd');
158 test_pass(vb.used == 4);
159 test_pass(vb.size >= vb.used);
160 test_mem(vb.buf, ==, "abcd", 4);
161
162 varbuf_destroy(&vb);
163}
164
165static void
166test_varbuf_dup_char(void)
167{
168 struct varbuf vb;
169
170 varbuf_init(&vb, 5);
171
172 varbuf_dup_char(&vb, 'z', 10);
173 test_pass(vb.used == 10);
174 test_pass(vb.size >= vb.used);
175 test_mem(vb.buf, ==, "zzzzzzzzzz", 10);
176
177 varbuf_dup_char(&vb, 'y', 5);
178 test_pass(vb.used == 15);
179 test_pass(vb.size >= vb.used);
180 test_mem(vb.buf, ==, "zzzzzzzzzzyyyyy", 15);
181
182 varbuf_destroy(&vb);
183}
184
185static void
186test_varbuf_map_char(void)
187{
188 struct varbuf vb;
189
190 varbuf_init(&vb, 5);
191
192 varbuf_add_buf(&vb, "1234a5678a9012a", 15);
193
194 varbuf_map_char(&vb, 'a', 'z');
195 test_pass(vb.used == 15);
196 test_pass(vb.size >= vb.used);
197 test_mem(vb.buf, ==, "1234z5678z9012z", 15);
198
199 varbuf_destroy(&vb);
200}
201
202static void
203test_varbuf_end_str(void)
204{
205 struct varbuf vb;
206
207 varbuf_init(&vb, 10);
208
209 varbuf_add_buf(&vb, "1234567890X", 11);
210 test_pass(vb.used == 11);
211 test_pass(vb.size >= vb.used);
212 test_mem(vb.buf, ==, "1234567890X", 11);
213
214 varbuf_trunc(&vb, 10);
215
216 varbuf_end_str(&vb);
217 test_pass(vb.used == 10);
218 test_pass(vb.size >= vb.used + 1);
219 test_pass(vb.buf[10] == '\0');
220 test_str(vb.buf, ==, "1234567890");
221
222 varbuf_destroy(&vb);
223}
224
225static void
226test_varbuf_get_str(void)
227{
228 struct varbuf vb;
229 const char *str;
230
231 varbuf_init(&vb, 10);
232
233 varbuf_add_buf(&vb, "1234567890", 10);
234 str = varbuf_get_str(&vb);
235 test_pass(vb.buf == str);
236 test_pass(vb.used == 10);
237 test_pass(vb.buf[vb.used] == '\0');
238 test_pass(str[vb.used] == '\0');
239 test_str(vb.buf, ==, "1234567890");
240 test_str(str, ==, "1234567890");
241
242 varbuf_add_buf(&vb, "abcde", 5);
243 str = varbuf_get_str(&vb);
244 test_pass(vb.buf == str);
245 test_pass(vb.used == 15);
246 test_pass(vb.buf[vb.used] == '\0');
247 test_pass(str[vb.used] == '\0');
248 test_str(vb.buf, ==, "1234567890abcde");
249 test_str(str, ==, "1234567890abcde");
250
251 varbuf_destroy(&vb);
252}
253
254static void
255test_varbuf_printf(void)
256{
257 struct varbuf vb;
258
259 varbuf_init(&vb, 5);
260
261 /* Test normal format printing. */
262 varbuf_printf(&vb, "format %s number %d", "string", 10);
263 test_pass(vb.used == strlen("format string number 10"));
264 test_pass(vb.size >= vb.used);
265 test_str(vb.buf, ==, "format string number 10");
266
267 varbuf_reset(&vb);
268
269 /* Test concatenated format printing. */
270 varbuf_printf(&vb, "format %s number %d", "string", 10);
271 varbuf_printf(&vb, " extra %s", "string");
272 test_pass(vb.used == strlen("format string number 10 extra string"));
273 test_pass(vb.size >= vb.used);
274 test_str(vb.buf, ==, "format string number 10 extra string");
275
276 varbuf_destroy(&vb);
277}
278
279static void
280test_varbuf_reset(void)
281{
282 struct varbuf vb;
283
284 varbuf_init(&vb, 10);
285
286 varbuf_add_buf(&vb, "1234567890", 10);
287
288 varbuf_reset(&vb);
289 test_pass(vb.used == 0);
290 test_pass(vb.size >= vb.used);
291
292 varbuf_add_buf(&vb, "abcdefghijklmno", 15);
293 test_pass(vb.used == 15);
294 test_pass(vb.size >= vb.used);
295 test_mem(vb.buf, ==, "abcdefghijklmno", 15);
296
297 varbuf_destroy(&vb);
298}
299
300static void
301test_varbuf_snapshot(void)
302{
303 struct varbuf vb;
304 struct varbuf_state vbs;
305
306 varbuf_init(&vb, 0);
307
308 test_pass(vb.used == 0);
309 varbuf_snapshot(&vb, &vbs);
310 test_pass(vb.used == 0);
311 test_pass(vb.used == vbs.used);
312
313 varbuf_add_buf(&vb, "1234567890", 10);
314 test_pass(vb.used == 10);
315 varbuf_rollback(&vb, &vbs);
316 test_pass(vb.used == 0);
317
318 varbuf_add_buf(&vb, "1234567890", 10);
319 test_pass(vb.used == 10);
320 varbuf_snapshot(&vb, &vbs);
321 test_pass(vb.used == 10);
322
323 varbuf_add_buf(&vb, "1234567890", 10);
324 test_pass(vb.used == 20);
325 varbuf_rollback(&vb, &vbs);
326 test_pass(vb.used == 10);
327
328 varbuf_destroy(&vb);
329}
330
331static void
332test_varbuf_detach(void)
333{
334 struct varbuf vb;
335 char *str;
336
337 varbuf_init(&vb, 0);
338
339 varbuf_add_buf(&vb, "1234567890", 10);
340
341 str = varbuf_detach(&vb);
342
343 test_mem(str, ==, "1234567890", 10);
344 test_pass(vb.used == 0);
345 test_pass(vb.size == 0);
346 test_pass(vb.buf == NULL);
347
348 free(str);
349}
350
351TEST_ENTRY(test)
352{
353 test_plan(120);
354
355 test_varbuf_init();
356 test_varbuf_prealloc();
357 test_varbuf_grow();
358 test_varbuf_trunc();
359 test_varbuf_add_buf();
360 test_varbuf_add_char();
361 test_varbuf_dup_char();
362 test_varbuf_map_char();
363 test_varbuf_end_str();
364 test_varbuf_get_str();
365 test_varbuf_printf();
366 test_varbuf_reset();
367 test_varbuf_snapshot();
368 test_varbuf_detach();
369
370 /* FIXME: Complete. */
371}
Debian package manager -- local hacks