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);
61 assert(NULL != (buff = (char *)malloc(buffsize)));
64 assert(NULL != (data = (char *)calloc(1, datasize)));
68 * Write a filecount files and read them all back.
70 assert((a = archive_write_new()) != NULL);
71 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
72 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
73 archive_write_add_filter_lz4(a));
74 assertEqualIntA(a, ARCHIVE_OK,
75 archive_write_set_bytes_per_block(a, 1024));
76 assertEqualIntA(a, ARCHIVE_OK,
77 archive_write_set_bytes_in_last_block(a, 1024));
78 assertEqualInt(ARCHIVE_FILTER_LZ4, archive_filter_code(a, 0));
79 assertEqualString("lz4", archive_filter_name(a, 0));
80 assertEqualIntA(a, ARCHIVE_OK,
81 archive_write_open_memory(a, buff, buffsize, &used1));
82 assert((ae = archive_entry_new()) != NULL);
83 archive_entry_set_filetype(ae, AE_IFREG);
84 archive_entry_set_size(ae, datasize);
85 for (i = 0; i < filecount; i++) {
86 sprintf(path, "file%03d", i);
87 archive_entry_copy_pathname(ae, path);
88 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
90 == (size_t)archive_write_data(a, data, datasize));
92 archive_entry_free(ae);
93 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
94 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
96 assert((a = archive_read_new()) != NULL);
97 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
98 r = archive_read_support_filter_lz4(a);
99 if (r == ARCHIVE_WARN) {
100 skipping("Can't verify lz4 writing by reading back;"
101 " lz4 reading not fully supported on this platform");
102 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
106 assertEqualIntA(a, ARCHIVE_OK,
107 archive_read_open_memory(a, buff, used1));
108 for (i = 0; i < filecount; i++) {
109 sprintf(path, "file%03d", i);
110 if (!assertEqualInt(ARCHIVE_OK,
111 archive_read_next_header(a, &ae)))
113 assertEqualString(path, archive_entry_pathname(ae));
114 assertEqualInt((int)datasize, archive_entry_size(ae));
116 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
117 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
120 * Repeat the cycle again, this time setting some compression
123 assert((a = archive_write_new()) != NULL);
124 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
125 assertEqualIntA(a, ARCHIVE_OK,
126 archive_write_set_bytes_per_block(a, 10));
127 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
128 archive_write_add_filter_lz4(a));
129 assertEqualIntA(a, ARCHIVE_FAILED,
130 archive_write_set_options(a, "lz4:nonexistent-option=0"));
131 assertEqualIntA(a, ARCHIVE_OK,
132 archive_write_set_options(a, "lz4:compression-level=1"));
133 assertEqualIntA(a, ARCHIVE_OK,
134 archive_write_set_filter_option(a, NULL, "compression-level", "9"));
135 assertEqualIntA(a, ARCHIVE_FAILED,
136 archive_write_set_filter_option(a, NULL, "compression-level", "abc"));
137 assertEqualIntA(a, ARCHIVE_FAILED,
138 archive_write_set_filter_option(a, NULL, "compression-level", "99"));
139 assertEqualIntA(a, ARCHIVE_OK,
140 archive_write_set_options(a, "lz4:compression-level=9"));
141 assertEqualIntA(a, ARCHIVE_OK,
142 archive_write_open_memory(a, buff, buffsize, &used2));
143 for (i = 0; i < filecount; i++) {
144 sprintf(path, "file%03d", i);
145 assert((ae = archive_entry_new()) != NULL);
146 archive_entry_copy_pathname(ae, path);
147 archive_entry_set_size(ae, datasize);
148 archive_entry_set_filetype(ae, AE_IFREG);
149 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
150 assertA(datasize == (size_t)archive_write_data(
152 archive_entry_free(ae);
154 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
155 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
157 failure("compression-level=9 wrote %d bytes, default wrote %d bytes",
158 (int)used2, (int)used1);
159 assert(used2 < used1);
161 assert((a = archive_read_new()) != NULL);
162 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
163 r = archive_read_support_filter_lz4(a);
164 if (r != ARCHIVE_OK && !use_prog) {
165 skipping("lz4 reading not fully supported on this platform");
167 assertEqualIntA(a, ARCHIVE_OK,
168 archive_read_support_filter_all(a));
169 assertEqualIntA(a, ARCHIVE_OK,
170 archive_read_open_memory(a, buff, used2));
171 for (i = 0; i < filecount; i++) {
172 sprintf(path, "file%03d", i);
173 if (!assertEqualInt(ARCHIVE_OK,
174 archive_read_next_header(a, &ae)))
176 assertEqualString(path, archive_entry_pathname(ae));
177 assertEqualInt((int)datasize, archive_entry_size(ae));
179 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
181 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
184 * Repeat again, with much lower compression.
186 assert((a = archive_write_new()) != NULL);
187 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
188 assertEqualIntA(a, ARCHIVE_OK,
189 archive_write_set_bytes_per_block(a, 10));
190 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
191 archive_write_add_filter_lz4(a));
192 assertEqualIntA(a, ARCHIVE_OK,
193 archive_write_set_filter_option(a, NULL, "compression-level", "1"));
194 assertEqualIntA(a, ARCHIVE_OK,
195 archive_write_open_memory(a, buff, buffsize, &used2));
196 for (i = 0; i < filecount; i++) {
197 sprintf(path, "file%03d", i);
198 assert((ae = archive_entry_new()) != NULL);
199 archive_entry_copy_pathname(ae, path);
200 archive_entry_set_size(ae, datasize);
201 archive_entry_set_filetype(ae, AE_IFREG);
202 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
203 failure("Writing file %s", path);
204 assertEqualIntA(a, datasize,
205 (size_t)archive_write_data(a, data, datasize));
206 archive_entry_free(ae);
208 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
209 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
212 failure("Compression-level=1 wrote %d bytes; default wrote %d bytes",
213 (int)used2, (int)used1);
214 assert(used2 > used1);
217 assert((a = archive_read_new()) != NULL);
218 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
219 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
220 r = archive_read_support_filter_lz4(a);
221 if (r == ARCHIVE_WARN) {
222 skipping("lz4 reading not fully supported on this platform");
224 assertEqualIntA(a, ARCHIVE_OK,
225 archive_read_open_memory(a, buff, used2));
226 for (i = 0; i < filecount; i++) {
227 sprintf(path, "file%03d", i);
228 if (!assertEqualInt(ARCHIVE_OK,
229 archive_read_next_header(a, &ae)))
231 assertEqualString(path, archive_entry_pathname(ae));
232 assertEqualInt((int)datasize, archive_entry_size(ae));
234 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
236 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
239 * Test various premature shutdown scenarios to make sure we
240 * don't crash or leak memory.
242 assert((a = archive_write_new()) != NULL);
243 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
244 archive_write_add_filter_lz4(a));
245 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
247 assert((a = archive_write_new()) != NULL);
248 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
249 archive_write_add_filter_lz4(a));
250 assertEqualInt(ARCHIVE_OK, archive_write_close(a));
251 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
253 assert((a = archive_write_new()) != NULL);
254 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
255 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
256 archive_write_add_filter_lz4(a));
257 assertEqualInt(ARCHIVE_OK, archive_write_close(a));
258 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
260 assert((a = archive_write_new()) != NULL);
261 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
262 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
263 archive_write_add_filter_lz4(a));
264 assertEqualIntA(a, ARCHIVE_OK,
265 archive_write_open_memory(a, buff, buffsize, &used2));
266 assertEqualInt(ARCHIVE_OK, archive_write_close(a));
267 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
277 test_options(const char *options)
279 struct archive_entry *ae;
282 size_t buffsize, datasize;
285 int i, r, use_prog = 0, filecount;
287 assert((a = archive_write_new()) != NULL);
288 r = archive_write_add_filter_lz4(a);
289 if (archive_liblz4_version() == NULL) {
291 skipping("lz4 writing not supported on this platform");
292 assertEqualInt(ARCHIVE_WARN, r);
293 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
296 assertEqualInt(ARCHIVE_WARN, r);
300 assertEqualInt(ARCHIVE_OK, r);
304 assert(NULL != (buff = (char *)malloc(buffsize)));
307 assert(NULL != (data = (char *)calloc(1, datasize)));
311 * Write a filecount files and read them all back.
313 assert((a = archive_write_new()) != NULL);
314 assertEqualIntA(a, ARCHIVE_OK, archive_write_set_format_ustar(a));
315 assertEqualIntA(a, (use_prog)?ARCHIVE_WARN:ARCHIVE_OK,
316 archive_write_add_filter_lz4(a));
317 assertEqualIntA(a, ARCHIVE_OK,
318 archive_write_set_options(a, options));
319 assertEqualIntA(a, ARCHIVE_OK,
320 archive_write_set_bytes_per_block(a, 1024));
321 assertEqualIntA(a, ARCHIVE_OK,
322 archive_write_set_bytes_in_last_block(a, 1024));
323 assertEqualInt(ARCHIVE_FILTER_LZ4, archive_filter_code(a, 0));
324 assertEqualString("lz4", archive_filter_name(a, 0));
325 assertEqualIntA(a, ARCHIVE_OK,
326 archive_write_open_memory(a, buff, buffsize, &used1));
327 assert((ae = archive_entry_new()) != NULL);
328 archive_entry_set_filetype(ae, AE_IFREG);
329 archive_entry_set_size(ae, datasize);
330 for (i = 0; i < filecount; i++) {
331 sprintf(path, "file%03d", i);
332 archive_entry_copy_pathname(ae, path);
333 assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
335 == (size_t)archive_write_data(a, data, datasize));
337 archive_entry_free(ae);
338 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));
339 assertEqualInt(ARCHIVE_OK, archive_write_free(a));
341 assert((a = archive_read_new()) != NULL);
342 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
343 r = archive_read_support_filter_lz4(a);
344 if (r == ARCHIVE_WARN) {
345 skipping("Can't verify lz4 writing by reading back;"
346 " lz4 reading not fully supported on this platform");
348 assertEqualIntA(a, ARCHIVE_OK,
349 archive_read_open_memory(a, buff, used1));
350 for (i = 0; i < filecount; i++) {
351 sprintf(path, "file%03d", i);
352 if (!assertEqualInt(ARCHIVE_OK,
353 archive_read_next_header(a, &ae)))
355 assertEqualString(path, archive_entry_pathname(ae));
356 assertEqualInt((int)datasize, archive_entry_size(ae));
358 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
360 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
369 DEFINE_TEST(test_write_filter_lz4_disable_stream_checksum)
371 test_options("lz4:!stream-checksum");
374 DEFINE_TEST(test_write_filter_lz4_enable_block_checksum)
376 test_options("lz4:block-checksum");
379 DEFINE_TEST(test_write_filter_lz4_block_size_4)
381 test_options("lz4:block-size=4");
384 DEFINE_TEST(test_write_filter_lz4_block_size_5)
386 test_options("lz4:block-size=5");
389 DEFINE_TEST(test_write_filter_lz4_block_size_6)
391 test_options("lz4:block-size=6");
394 DEFINE_TEST(test_write_filter_lz4_block_dependence)
396 test_options("lz4:block-dependence");
400 * TODO: Figure out how to correctly handle this.
402 * This option simply fails on some versions of the LZ4 libraries.
405 XXXDEFINE_TEST(test_write_filter_lz4_block_dependence_hc)
407 test_options("lz4:block-dependence,lz4:compression-level=9");