2 * Copyright (c) 2014 Michihiro NAKAJIMA
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
28 __FBSDID("$FreeBSD$");
31 * A basic exercise of lz4 reading and writing.
34 DEFINE_TEST(test_write_filter_lz4)
36 struct archive_entry *ae;
39 size_t buffsize, datasize;
42 int i, r, use_prog = 0, filecount;
44 assert((a = archive_write_new()) != NULL);
45 r = archive_write_add_filter_lz4(a);
46 if (archive_liblz4_version() == NULL) {
48 skipping("lz4 writing not supported on this platform");
49 assertEqualInt(ARCHIVE_WARN, r);
50 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
53 assertEqualInt(ARCHIVE_WARN, r);
57 assertEqualInt(ARCHIVE_OK, r);
59 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
62 assert(NULL != (buff = (char *)malloc(buffsize)));
65 assert(NULL != (data = (char *)calloc(1, datasize)));
69 * Write a filecount files and read them all back.
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));
91 == (size_t)archive_write_data(a, data, datasize));
93 archive_entry_free(ae);
94 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
95 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
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));
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)))
114 assertEqualString(path, archive_entry_pathname(ae));
115 assertEqualInt((int)datasize, archive_entry_size(ae));
117 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
118 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
121 * Repeat the cycle again, this time setting some compression
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(
153 archive_entry_free(ae);
155 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
156 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
158 failure("compression-level=9 wrote %d bytes, default wrote %d bytes",
159 (int)used2, (int)used1);
160 assert(used2 < used1);
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");
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)))
177 assertEqualString(path, archive_entry_pathname(ae));
178 assertEqualInt((int)datasize, archive_entry_size(ae));
180 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
182 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
185 * Repeat again, with much lower compression.
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);
209 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
210 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
213 failure("Compression-level=1 wrote %d bytes; default wrote %d bytes",
214 (int)used2, (int)used1);
215 assert(used2 > used1);
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");
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)))
232 assertEqualString(path, archive_entry_pathname(ae));
233 assertEqualInt((int)datasize, archive_entry_size(ae));
235 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
237 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
240 * Test various premature shutdown scenarios to make sure we
241 * don't crash or leak memory.
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));
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));
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));
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));
278 test_options(const char *options)
280 struct archive_entry *ae;
283 size_t buffsize, datasize;
286 int i, r, use_prog = 0, filecount;
288 assert((a = archive_write_new()) != NULL);
289 r = archive_write_add_filter_lz4(a);
290 if (archive_liblz4_version() == NULL) {
292 skipping("lz4 writing not supported on this platform");
293 assertEqualInt(ARCHIVE_WARN, r);
294 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
297 assertEqualInt(ARCHIVE_WARN, r);
301 assertEqualInt(ARCHIVE_OK, r);
303 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
306 assert(NULL != (buff = (char *)malloc(buffsize)));
309 assert(NULL != (data = (char *)calloc(1, datasize)));
313 * Write a filecount files and read them all back.
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));
337 == (size_t)archive_write_data(a, data, datasize));
339 archive_entry_free(ae);
340 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
341 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
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");
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)))
357 assertEqualString(path, archive_entry_pathname(ae));
358 assertEqualInt((int)datasize, archive_entry_size(ae));
360 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
362 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
371 DEFINE_TEST(test_write_filter_lz4_disable_stream_checksum)
373 test_options("lz4:!stream-checksum");
376 DEFINE_TEST(test_write_filter_lz4_enable_block_checksum)
378 test_options("lz4:block-checksum");
381 DEFINE_TEST(test_write_filter_lz4_block_size_4)
383 test_options("lz4:block-size=4");
386 DEFINE_TEST(test_write_filter_lz4_block_size_5)
388 test_options("lz4:block-size=5");
391 DEFINE_TEST(test_write_filter_lz4_block_size_6)
393 test_options("lz4:block-size=6");
396 DEFINE_TEST(test_write_filter_lz4_block_dependence)
398 test_options("lz4:block-dependence");
402 * TODO: Figure out how to correctly handle this.
404 * This option simply fails on some versions of the LZ4 libraries.
407 XXXDEFINE_TEST(test_write_filter_lz4_block_dependence_hc)
409 test_options("lz4:block-dependence,lz4:compression-level=9");