1 /*-
2 * Copyright (c) 2014 Michihiro NAKAJIMA
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer
10 * in this position and unchanged.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27 #include "test.h"
28 __FBSDID("$FreeBSD$");
29
30 /*
31 * A basic exercise of lz4 reading and writing.
32 */
33
DEFINE_TEST(test_write_filter_lz4)34 DEFINE_TEST(test_write_filter_lz4)
35 {
36 struct archive_entry *ae;
37 struct archive* a;
38 char *buff, *data;
39 size_t buffsize, datasize;
40 char path[16];
41 size_t used1, used2;
42 int i, r, use_prog = 0, filecount;
43
44 assert((a = archive_write_new()) != NULL);
45 r = archive_write_add_filter_lz4(a);
46 if (archive_liblz4_version() == NULL) {
47 if (!canLz4()) {
48 skipping("lz4 writing not supported on this platform");
49 assertEqualInt(ARCHIVE_WARN, r);
50 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
51 return;
52 } else {
53 assertEqualInt(ARCHIVE_WARN, r);
54 use_prog = 1;
55 }
56 } else {
57 assertEqualInt(ARCHIVE_OK, r);
58 }
59 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
60
61 buffsize = 2000000;
62 assert(NULL != (buff = (char *)malloc(buffsize)));
63
64 datasize = 10000;
65 assert(NULL != (data = (char *)calloc(1, datasize)));
66 filecount = 10;
67
68 /*
69 * Write a filecount files and read them all back.
70 */
71 assert((a = archive_write_new()) != NULL);
72 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
73 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
74 archive_write_add_filter_lz4(a));
75 assertEqualIntA(a, ARCHIVE_OK,
76 archive_write_set_bytes_per_block(a, 1024));
77 assertEqualIntA(a, ARCHIVE_OK,
78 archive_write_set_bytes_in_last_block(a, 1024));
79 assertEqualInt(ARCHIVE_FILTER_LZ4, archive_filter_code(a, 0));
80 assertEqualString("lz4", archive_filter_name(a, 0));
81 assertEqualIntA(a, ARCHIVE_OK,
82 archive_write_open_memory(a, buff, buffsize, &used1));
83 assert((ae = archive_entry_new()) != NULL);
84 archive_entry_set_filetype(ae, AE_IFREG);
85 archive_entry_set_size(ae, datasize);
86 for (i = 0; i < filecount; i++) {
87 sprintf(path, "file%03d", i);
88 archive_entry_copy_pathname(ae, path);
89 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
90 assertA(datasize
91 == (size_t)archive_write_data(a, data, datasize));
92 }
93 archive_entry_free(ae);
94 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
95 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
96
97 assert((a = archive_read_new()) != NULL);
98 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
99 r = archive_read_support_filter_lz4(a);
100 if (r == ARCHIVE_WARN) {
101 skipping("Can't verify lz4 writing by reading back;"
102 " lz4 reading not fully supported on this platform");
103 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
104 return;
105 }
106
107 assertEqualIntA(a, ARCHIVE_OK,
108 archive_read_open_memory(a, buff, used1));
109 for (i = 0; i < filecount; i++) {
110 sprintf(path, "file%03d", i);
111 if (!assertEqualInt(ARCHIVE_OK,
112 archive_read_next_header(a, &ae)))
113 break;
114 assertEqualString(path, archive_entry_pathname(ae));
115 assertEqualInt((int)datasize, archive_entry_size(ae));
116 }
117 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
118 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
119
120 /*
121 * Repeat the cycle again, this time setting some compression
122 * options.
123 */
124 assert((a = archive_write_new()) != NULL);
125 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
126 assertEqualIntA(a, ARCHIVE_OK,
127 archive_write_set_bytes_per_block(a, 10));
128 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
129 archive_write_add_filter_lz4(a));
130 assertEqualIntA(a, ARCHIVE_FAILED,
131 archive_write_set_options(a, "lz4:nonexistent-option=0"));
132 assertEqualIntA(a, ARCHIVE_OK,
133 archive_write_set_options(a, "lz4:compression-level=1"));
134 assertEqualIntA(a, ARCHIVE_OK,
135 archive_write_set_filter_option(a, NULL, "compression-level", "9"));
136 assertEqualIntA(a, ARCHIVE_FAILED,
137 archive_write_set_filter_option(a, NULL, "compression-level", "abc"));
138 assertEqualIntA(a, ARCHIVE_FAILED,
139 archive_write_set_filter_option(a, NULL, "compression-level", "99"));
140 assertEqualIntA(a, ARCHIVE_OK,
141 archive_write_set_options(a, "lz4:compression-level=9"));
142 assertEqualIntA(a, ARCHIVE_OK,
143 archive_write_open_memory(a, buff, buffsize, &used2));
144 for (i = 0; i < filecount; i++) {
145 sprintf(path, "file%03d", i);
146 assert((ae = archive_entry_new()) != NULL);
147 archive_entry_copy_pathname(ae, path);
148 archive_entry_set_size(ae, datasize);
149 archive_entry_set_filetype(ae, AE_IFREG);
150 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
151 assertA(datasize == (size_t)archive_write_data(
152 a, data, datasize));
153 archive_entry_free(ae);
154 }
155 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
156 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
157
158 failure("compression-level=9 wrote %d bytes, default wrote %d bytes",
159 (int)used2, (int)used1);
160 assert(used2 < used1);
161
162 assert((a = archive_read_new()) != NULL);
163 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
164 r = archive_read_support_filter_lz4(a);
165 if (r != ARCHIVE_OK && !use_prog) {
166 skipping("lz4 reading not fully supported on this platform");
167 } else {
168 assertEqualIntA(a, ARCHIVE_OK,
169 archive_read_support_filter_all(a));
170 assertEqualIntA(a, ARCHIVE_OK,
171 archive_read_open_memory(a, buff, used2));
172 for (i = 0; i < filecount; i++) {
173 sprintf(path, "file%03d", i);
174 if (!assertEqualInt(ARCHIVE_OK,
175 archive_read_next_header(a, &ae)))
176 break;
177 assertEqualString(path, archive_entry_pathname(ae));
178 assertEqualInt((int)datasize, archive_entry_size(ae));
179 }
180 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
181 }
182 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
183
184 /*
185 * Repeat again, with much lower compression.
186 */
187 assert((a = archive_write_new()) != NULL);
188 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
189 assertEqualIntA(a, ARCHIVE_OK,
190 archive_write_set_bytes_per_block(a, 10));
191 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
192 archive_write_add_filter_lz4(a));
193 assertEqualIntA(a, ARCHIVE_OK,
194 archive_write_set_filter_option(a, NULL, "compression-level", "1"));
195 assertEqualIntA(a, ARCHIVE_OK,
196 archive_write_open_memory(a, buff, buffsize, &used2));
197 for (i = 0; i < filecount; i++) {
198 sprintf(path, "file%03d", i);
199 assert((ae = archive_entry_new()) != NULL);
200 archive_entry_copy_pathname(ae, path);
201 archive_entry_set_size(ae, datasize);
202 archive_entry_set_filetype(ae, AE_IFREG);
203 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
204 failure("Writing file %s", path);
205 assertEqualIntA(a, datasize,
206 (size_t)archive_write_data(a, data, datasize));
207 archive_entry_free(ae);
208 }
209 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
210 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
211
212 #if 0
213 failure("Compression-level=1 wrote %d bytes; default wrote %d bytes",
214 (int)used2, (int)used1);
215 assert(used2 > used1);
216 #endif
217
218 assert((a = archive_read_new()) != NULL);
219 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
220 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
221 r = archive_read_support_filter_lz4(a);
222 if (r == ARCHIVE_WARN) {
223 skipping("lz4 reading not fully supported on this platform");
224 } else {
225 assertEqualIntA(a, ARCHIVE_OK,
226 archive_read_open_memory(a, buff, used2));
227 for (i = 0; i < filecount; i++) {
228 sprintf(path, "file%03d", i);
229 if (!assertEqualInt(ARCHIVE_OK,
230 archive_read_next_header(a, &ae)))
231 break;
232 assertEqualString(path, archive_entry_pathname(ae));
233 assertEqualInt((int)datasize, archive_entry_size(ae));
234 }
235 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
236 }
237 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
238
239 /*
240 * Test various premature shutdown scenarios to make sure we
241 * don't crash or leak memory.
242 */
243 assert((a = archive_write_new()) != NULL);
244 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
245 archive_write_add_filter_lz4(a));
246 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
247
248 assert((a = archive_write_new()) != NULL);
249 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
250 archive_write_add_filter_lz4(a));
251 assertEqualInt(ARCHIVE_OK, archive_write_close(a));
252 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
253
254 assert((a = archive_write_new()) != NULL);
255 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
256 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
257 archive_write_add_filter_lz4(a));
258 assertEqualInt(ARCHIVE_OK, archive_write_close(a));
259 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
260
261 assert((a = archive_write_new()) != NULL);
262 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
263 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
264 archive_write_add_filter_lz4(a));
265 assertEqualIntA(a, ARCHIVE_OK,
266 archive_write_open_memory(a, buff, buffsize, &used2));
267 assertEqualInt(ARCHIVE_OK, archive_write_close(a));
268 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
269
270 /*
271 * Clean up.
272 */
273 free(data);
274 free(buff);
275 }
276
277 static void
test_options(const char * options)278 test_options(const char *options)
279 {
280 struct archive_entry *ae;
281 struct archive* a;
282 char *buff, *data;
283 size_t buffsize, datasize;
284 char path[16];
285 size_t used1;
286 int i, r, use_prog = 0, filecount;
287
288 assert((a = archive_write_new()) != NULL);
289 r = archive_write_add_filter_lz4(a);
290 if (archive_liblz4_version() == NULL) {
291 if (!canLz4()) {
292 skipping("lz4 writing not supported on this platform");
293 assertEqualInt(ARCHIVE_WARN, r);
294 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
295 return;
296 } else {
297 assertEqualInt(ARCHIVE_WARN, r);
298 use_prog = 1;
299 }
300 } else {
301 assertEqualInt(ARCHIVE_OK, r);
302 }
303 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
304
305 buffsize = 2000000;
306 assert(NULL != (buff = (char *)malloc(buffsize)));
307
308 datasize = 10000;
309 assert(NULL != (data = (char *)calloc(1, datasize)));
310 filecount = 10;
311
312 /*
313 * Write a filecount files and read them all back.
314 */
315 assert((a = archive_write_new()) != NULL);
316 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
317 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
318 archive_write_add_filter_lz4(a));
319 assertEqualIntA(a, ARCHIVE_OK,
320 archive_write_set_options(a, options));
321 assertEqualIntA(a, ARCHIVE_OK,
322 archive_write_set_bytes_per_block(a, 1024));
323 assertEqualIntA(a, ARCHIVE_OK,
324 archive_write_set_bytes_in_last_block(a, 1024));
325 assertEqualInt(ARCHIVE_FILTER_LZ4, archive_filter_code(a, 0));
326 assertEqualString("lz4", archive_filter_name(a, 0));
327 assertEqualIntA(a, ARCHIVE_OK,
328 archive_write_open_memory(a, buff, buffsize, &used1));
329 assert((ae = archive_entry_new()) != NULL);
330 archive_entry_set_filetype(ae, AE_IFREG);
331 archive_entry_set_size(ae, datasize);
332 for (i = 0; i < filecount; i++) {
333 sprintf(path, "file%03d", i);
334 archive_entry_copy_pathname(ae, path);
335 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
336 assertA(datasize
337 == (size_t)archive_write_data(a, data, datasize));
338 }
339 archive_entry_free(ae);
340 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
341 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
342
343 assert((a = archive_read_new()) != NULL);
344 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
345 r = archive_read_support_filter_lz4(a);
346 if (r == ARCHIVE_WARN) {
347 skipping("Can't verify lz4 writing by reading back;"
348 " lz4 reading not fully supported on this platform");
349 } else {
350 assertEqualIntA(a, ARCHIVE_OK,
351 archive_read_open_memory(a, buff, used1));
352 for (i = 0; i < filecount; i++) {
353 sprintf(path, "file%03d", i);
354 if (!assertEqualInt(ARCHIVE_OK,
355 archive_read_next_header(a, &ae)))
356 break;
357 assertEqualString(path, archive_entry_pathname(ae));
358 assertEqualInt((int)datasize, archive_entry_size(ae));
359 }
360 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
361 }
362 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
363
364 /*
365 * Clean up.
366 */
367 free(data);
368 free(buff);
369 }
370
DEFINE_TEST(test_write_filter_lz4_disable_stream_checksum)371 DEFINE_TEST(test_write_filter_lz4_disable_stream_checksum)
372 {
373 test_options("lz4:!stream-checksum");
374 }
375
DEFINE_TEST(test_write_filter_lz4_enable_block_checksum)376 DEFINE_TEST(test_write_filter_lz4_enable_block_checksum)
377 {
378 test_options("lz4:block-checksum");
379 }
380
DEFINE_TEST(test_write_filter_lz4_block_size_4)381 DEFINE_TEST(test_write_filter_lz4_block_size_4)
382 {
383 test_options("lz4:block-size=4");
384 }
385
DEFINE_TEST(test_write_filter_lz4_block_size_5)386 DEFINE_TEST(test_write_filter_lz4_block_size_5)
387 {
388 test_options("lz4:block-size=5");
389 }
390
DEFINE_TEST(test_write_filter_lz4_block_size_6)391 DEFINE_TEST(test_write_filter_lz4_block_size_6)
392 {
393 test_options("lz4:block-size=6");
394 }
395
DEFINE_TEST(test_write_filter_lz4_block_dependence)396 DEFINE_TEST(test_write_filter_lz4_block_dependence)
397 {
398 test_options("lz4:block-dependence");
399 }
400
401 /*
402 * TODO: Figure out how to correctly handle this.
403 *
404 * This option simply fails on some versions of the LZ4 libraries.
405 */
406 /*
407 XXXDEFINE_TEST(test_write_filter_lz4_block_dependence_hc)
408 {
409 test_options("lz4:block-dependence,lz4:compression-level=9");
410 }
411 */
412