Game of Trees Repos

Blob

Date:: Wed Mar 8 09:27:14 2023 UTC
Message:: portable: regress: imply compat When building tests, compat needs to be built. Do this prior to running any tests. This ensures tests can be run from a clean tree. Furthermore, add got_compat.h to all test headers. This wasn't necessary before as this was implicitly being included, but now isn't.
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2021 Stefan Sperling <stsp@openbsd.org>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include "got_compat.h"
18 
19 #include <sys/queue.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <err.h>
24 #include <unistd.h>
25 #include <getopt.h>
26 
27 #include "got_error.h"
28 #include "got_opentemp.h"
29 
30 #include "got_lib_deltify.h"
31 
32 #ifndef nitems
33 #define nitems(_a) (sizeof(_a) / sizeof((_a)[0]))
34 #endif
35 
36 static int
37 deltify_abc_axc(void)
38 {
39 	const struct got_error *err = NULL;
40 	size_t i;
41 	FILE *base_file, *derived_file, *result_file;
42 	struct got_delta_table *dt;
43 	struct got_delta_instruction *deltas;
44 	int ndeltas;
45 	int have_nblocks = 0;
46 	uint32_t seed;
47 
48 	seed = arc4random();
49 
50 	base_file = got_opentemp();
51 	if (base_file == NULL)
52 		return 1;
53 
54 	derived_file = got_opentemp();
55 	if (derived_file == NULL)
56 		return 1;
57 
58 	result_file = got_opentemp();
59 	if (result_file == NULL)
60 		return 1;
61 
62 	for (i = 0; i < GOT_DELTIFY_MAXCHUNK; i++) {
63 		fputc('a', base_file);
64 		fputc('a', derived_file);
65 	}
66 	for (i = 0; i < GOT_DELTIFY_MAXCHUNK; i++) {
67 		fputc('b', base_file);
68 		fputc('x', derived_file);
69 	}
70 	for (i = 0; i < GOT_DELTIFY_MAXCHUNK; i++) {
71 		fputc('c', base_file);
72 		fputc('c', derived_file);
73 	}
74 
75 	rewind(base_file);
76 	rewind(derived_file);
77 
78 	err = got_deltify_init(&dt, base_file, 0, 3 * GOT_DELTIFY_MAXCHUNK,
79 	    seed);
80 	if (err)
81 		goto done;
82 
83 	for (i = 0; i < dt->nalloc; i++) {
84 		if (dt->blocks[i].len > 0)
85 			have_nblocks++;
86 	}
87 	if (have_nblocks != dt->nblocks) {
88 		err = got_error(GOT_ERR_BAD_DELTA);
89 		goto done;
90 	}
91 
92 	err = got_deltify(&deltas, &ndeltas, derived_file, 0,
93 	    3 * GOT_DELTIFY_MAXCHUNK, seed, dt, base_file, 0,
94 	    3 * GOT_DELTIFY_MAXCHUNK);
95 	if (err)
96 		goto done;
97 
98 	if (ndeltas != 3) {
99 		err = got_error(GOT_ERR_BAD_DELTA);
100 		goto done;
101 	}
102 	/* Copy 'aaaa...' from base file. */
103 	if (!(deltas[0].copy == 1 && deltas[0].offset == 0 &&
104 	    deltas[0].len == GOT_DELTIFY_MAXCHUNK)) {
105 		err = got_error(GOT_ERR_BAD_DELTA);
106 		goto done;
107 	}
108 	/* Copy 'xxxx...' from derived file. */
109 	if (!(deltas[1].copy == 0 && deltas[1].offset == GOT_DELTIFY_MAXCHUNK &&
110 	    deltas[1].len == GOT_DELTIFY_MAXCHUNK)) {
111 		err = got_error(GOT_ERR_BAD_DELTA);
112 		goto done;
113 	}
114 	/* Copy 'ccccc...' from base file. */
115 	if (!(deltas[2].copy == 1 &&
116 	    deltas[2].offset == 2 * GOT_DELTIFY_MAXCHUNK &&
117 	    deltas[2].len == GOT_DELTIFY_MAXCHUNK)) {
118 		err = got_error(GOT_ERR_BAD_DELTA);
119 		goto done;
120 	}
121 
122 done:
123 	got_deltify_free(dt);
124 	fclose(base_file);
125 	fclose(derived_file);
126 	fclose(result_file);
127 	return (err == NULL);
128 }
129 
130 static int
131 deltify_abc_axc_file_mem(void)
132 {
133 	const struct got_error *err = NULL;
134 	size_t i;
135 	uint8_t base_data[3 * GOT_DELTIFY_MAXCHUNK];
136 	FILE *derived_file, *result_file;
137 	struct got_delta_table *dt;
138 	struct got_delta_instruction *deltas;
139 	int ndeltas;
140 	int have_nblocks = 0;
141 	uint32_t seed;
142 
143 	seed = arc4random();
144 
145 	derived_file = got_opentemp();
146 	if (derived_file == NULL)
147 		return 1;
148 
149 	result_file = got_opentemp();
150 	if (result_file == NULL)
151 		return 1;
152 
153 	for (i = 0; i < GOT_DELTIFY_MAXCHUNK; i++) {
154 		base_data[i] = 'a';
155 		fputc('a', derived_file);
156 	}
157 	for (i = 0; i < GOT_DELTIFY_MAXCHUNK; i++) {
158 		base_data[GOT_DELTIFY_MAXCHUNK + i] = 'b';
159 		fputc('x', derived_file);
160 	}
161 	for (i = 0; i < GOT_DELTIFY_MAXCHUNK; i++) {
162 		base_data[2 * GOT_DELTIFY_MAXCHUNK + i] = 'c';
163 		fputc('c', derived_file);
164 	}
165 
166 	rewind(derived_file);
167 
168 	err = got_deltify_init_mem(&dt, base_data, 0, 3 * GOT_DELTIFY_MAXCHUNK,
169 	    seed);
170 	if (err)
171 		goto done;
172 
173 	for (i = 0; i < dt->nalloc; i++) {
174 		if (dt->blocks[i].len > 0)
175 			have_nblocks++;
176 	}
177 	if (have_nblocks != dt->nblocks) {
178 		err = got_error(GOT_ERR_BAD_DELTA);
179 		goto done;
180 	}
181 
182 	err = got_deltify_file_mem(&deltas, &ndeltas, derived_file, 0,
183 	    3 * GOT_DELTIFY_MAXCHUNK, seed, dt, base_data, 0,
184 	    3 * GOT_DELTIFY_MAXCHUNK);
185 	if (err)
186 		goto done;
187 
188 	if (ndeltas != 3) {
189 		err = got_error(GOT_ERR_BAD_DELTA);
190 		goto done;
191 	}
192 	/* Copy 'aaaa...' from base file. */
193 	if (!(deltas[0].copy == 1 && deltas[0].offset == 0 &&
194 	    deltas[0].len == GOT_DELTIFY_MAXCHUNK)) {
195 		err = got_error(GOT_ERR_BAD_DELTA);
196 		goto done;
197 	}
198 	/* Copy 'xxxx...' from derived file. */
199 	if (!(deltas[1].copy == 0 && deltas[1].offset == GOT_DELTIFY_MAXCHUNK &&
200 	    deltas[1].len == GOT_DELTIFY_MAXCHUNK)) {
201 		err = got_error(GOT_ERR_BAD_DELTA);
202 		goto done;
203 	}
204 	/* Copy 'ccccc...' from base file. */
205 	if (!(deltas[2].copy == 1 &&
206 	    deltas[2].offset == 2 * GOT_DELTIFY_MAXCHUNK &&
207 	    deltas[2].len == GOT_DELTIFY_MAXCHUNK)) {
208 		err = got_error(GOT_ERR_BAD_DELTA);
209 		goto done;
210 	}
211 
212 done:
213 	got_deltify_free(dt);
214 	fclose(derived_file);
215 	fclose(result_file);
216 	return (err == NULL);
217 }
218 
219 static int
220 deltify_abc_axc_mem_file(void)
221 {
222 	const struct got_error *err = NULL;
223 	size_t i;
224 	FILE *base_file, *result_file;
225 	uint8_t derived_file[3 * GOT_DELTIFY_MAXCHUNK];
226 	struct got_delta_table *dt;
227 	struct got_delta_instruction *deltas;
228 	int ndeltas;
229 	int have_nblocks = 0;
230 	uint32_t seed;
231 
232 	seed = arc4random();
233 
234 	base_file = got_opentemp();
235 	if (base_file == NULL)
236 		return 1;
237 
238 	result_file = got_opentemp();
239 	if (result_file == NULL)
240 		return 1;
241 
242 	for (i = 0; i < GOT_DELTIFY_MAXCHUNK; i++) {
243 		fputc('a', base_file);
244 		derived_file[i] = 'a';
245 	}
246 	for (i = 0; i < GOT_DELTIFY_MAXCHUNK; i++) {
247 		fputc('b', base_file);
248 		derived_file[GOT_DELTIFY_MAXCHUNK + i] = 'x';
249 	}
250 	for (i = 0; i < GOT_DELTIFY_MAXCHUNK; i++) {
251 		fputc('c', base_file);
252 		derived_file[2 * GOT_DELTIFY_MAXCHUNK + i] = 'c';
253 	}
254 
255 	rewind(base_file);
256 
257 	err = got_deltify_init(&dt, base_file, 0, 3 * GOT_DELTIFY_MAXCHUNK,
258 	    seed);
259 	if (err)
260 		goto done;
261 
262 	for (i = 0; i < dt->nalloc; i++) {
263 		if (dt->blocks[i].len > 0)
264 			have_nblocks++;
265 	}
266 	if (have_nblocks != dt->nblocks) {
267 		err = got_error(GOT_ERR_BAD_DELTA);
268 		goto done;
269 	}
270 
271 	err = got_deltify_mem_file(&deltas, &ndeltas, derived_file, 0,
272 	    3 * GOT_DELTIFY_MAXCHUNK, seed, dt, base_file, 0,
273 	    3 * GOT_DELTIFY_MAXCHUNK);
274 	if (err)
275 		goto done;
276 
277 	if (ndeltas != 3) {
278 		err = got_error(GOT_ERR_BAD_DELTA);
279 		goto done;
280 	}
281 	/* Copy 'aaaa...' from base file. */
282 	if (!(deltas[0].copy == 1 && deltas[0].offset == 0 &&
283 	    deltas[0].len == GOT_DELTIFY_MAXCHUNK)) {
284 		err = got_error(GOT_ERR_BAD_DELTA);
285 		goto done;
286 	}
287 	/* Copy 'xxxx...' from derived file. */
288 	if (!(deltas[1].copy == 0 && deltas[1].offset == GOT_DELTIFY_MAXCHUNK &&
289 	    deltas[1].len == GOT_DELTIFY_MAXCHUNK)) {
290 		err = got_error(GOT_ERR_BAD_DELTA);
291 		goto done;
292 	}
293 	/* Copy 'ccccc...' from base file. */
294 	if (!(deltas[2].copy == 1 &&
295 	    deltas[2].offset == 2 * GOT_DELTIFY_MAXCHUNK &&
296 	    deltas[2].len == GOT_DELTIFY_MAXCHUNK)) {
297 		err = got_error(GOT_ERR_BAD_DELTA);
298 		goto done;
299 	}
300 
301 done:
302 	got_deltify_free(dt);
303 	fclose(base_file);
304 	fclose(result_file);
305 	return (err == NULL);
306 }
307 
308 static int
309 deltify_abc_axc_mem_mem(void)
310 {
311 	const struct got_error *err = NULL;
312 	size_t i;
313 	FILE *result_file;
314 	uint8_t base_file[3 * GOT_DELTIFY_MAXCHUNK];
315 	uint8_t derived_file[3 * GOT_DELTIFY_MAXCHUNK];
316 	struct got_delta_table *dt;
317 	struct got_delta_instruction *deltas;
318 	int ndeltas;
319 	int have_nblocks = 0;
320 	uint32_t seed;
321 
322 	seed = arc4random();
323 
324 	result_file = got_opentemp();
325 	if (result_file == NULL)
326 		return 1;
327 
328 	for (i = 0; i < GOT_DELTIFY_MAXCHUNK; i++) {
329 		base_file[i] = 'a';
330 		derived_file[i] = 'a';
331 	}
332 	for (i = 0; i < GOT_DELTIFY_MAXCHUNK; i++) {
333 		base_file[GOT_DELTIFY_MAXCHUNK + i] = 'b';
334 		derived_file[GOT_DELTIFY_MAXCHUNK + i] = 'x';
335 	}
336 	for (i = 0; i < GOT_DELTIFY_MAXCHUNK; i++) {
337 		base_file[2 * GOT_DELTIFY_MAXCHUNK + i] = 'c';
338 		derived_file[2 * GOT_DELTIFY_MAXCHUNK + i] = 'c';
339 	}
340 
341 	err = got_deltify_init_mem(&dt, base_file, 0, 3 * GOT_DELTIFY_MAXCHUNK,
342 	    seed);
343 	if (err)
344 		goto done;
345 
346 	for (i = 0; i < dt->nalloc; i++) {
347 		if (dt->blocks[i].len > 0)
348 			have_nblocks++;
349 	}
350 	if (have_nblocks != dt->nblocks) {
351 		err = got_error(GOT_ERR_BAD_DELTA);
352 		goto done;
353 	}
354 
355 	err = got_deltify_mem_mem(&deltas, &ndeltas, derived_file, 0,
356 	    3 * GOT_DELTIFY_MAXCHUNK, seed, dt, base_file, 0,
357 	    3 * GOT_DELTIFY_MAXCHUNK);
358 	if (err)
359 		goto done;
360 
361 	if (ndeltas != 3) {
362 		err = got_error(GOT_ERR_BAD_DELTA);
363 		goto done;
364 	}
365 	/* Copy 'aaaa...' from base file. */
366 	if (!(deltas[0].copy == 1 && deltas[0].offset == 0 &&
367 	    deltas[0].len == GOT_DELTIFY_MAXCHUNK)) {
368 		err = got_error(GOT_ERR_BAD_DELTA);
369 		goto done;
370 	}
371 	/* Copy 'xxxx...' from derived file. */
372 	if (!(deltas[1].copy == 0 && deltas[1].offset == GOT_DELTIFY_MAXCHUNK &&
373 	    deltas[1].len == GOT_DELTIFY_MAXCHUNK)) {
374 		err = got_error(GOT_ERR_BAD_DELTA);
375 		goto done;
376 	}
377 	/* Copy 'ccccc...' from base file. */
378 	if (!(deltas[2].copy == 1 &&
379 	    deltas[2].offset == 2 * GOT_DELTIFY_MAXCHUNK &&
380 	    deltas[2].len == GOT_DELTIFY_MAXCHUNK)) {
381 		err = got_error(GOT_ERR_BAD_DELTA);
382 		goto done;
383 	}
384 
385 done:
386 	got_deltify_free(dt);
387 	fclose(result_file);
388 	return (err == NULL);
389 }
390 
391 static int quiet;
392 
393 #define RUN_TEST(expr, name) \
394 	{ test_ok = (expr);  \
395 	if (!quiet) printf("test_%s %s\n", (name), test_ok ? "ok" : "failed"); \
396 	failure = (failure || !test_ok); }
397 
398 static void
399 usage(void)
400 {
401 	fprintf(stderr, "usage: delta_test [-q]\n");
402 }
403 
404 int
405 main(int argc, char *argv[])
406 {
407 	int test_ok;
408 	int failure = 0;
409 	int ch;
410 
411 	while ((ch = getopt(argc, argv, "q")) != -1) {
412 		switch (ch) {
413 		case 'q':
414 			quiet = 1;
415 			break;
416 		default:
417 			usage();
418 			return 1;
419 		}
420 	}
421 
422 	argc -= optind;
423 	argv += optind;
424 
425 	if (argc != 0) {
426 		usage();
427 		return 1;
428 	}
429 
430 #ifndef PROFILE
431 	if (pledge("stdio rpath wpath cpath unveil", NULL) == -1)
432 		err(1, "pledge");
433 #endif
434 	if (unveil(GOT_TMPDIR_STR, "rwc") != 0)
435 		err(1, "unveil");
436 
437 	if (unveil(NULL, NULL) != 0)
438 		err(1, "unveil");
439 
440 	RUN_TEST(deltify_abc_axc(), "deltify_abc_axc");
441 	RUN_TEST(deltify_abc_axc_file_mem(), "deltify_abc_axc_file_mem");
442 	RUN_TEST(deltify_abc_axc_mem_file(), "deltify_abc_axc_mem_file");
443 	RUN_TEST(deltify_abc_axc_mem_mem(), "deltify_abc_axc_mem_mem");
444 
445 	return failure ? 1 : 0;
446 }