test_write_filter_lz4.c revision 302001
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: stable/10/contrib/libarchive/libarchive/test/test_write_filter_lz4.c 302001 2016-06-17 22:40:10Z mm $"); 29 30/* 31 * A basic exercise of lz4 reading and writing. 32 */ 33 34DEFINE_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 60 buffsize = 2000000; 61 assert(NULL != (buff = (char *)malloc(buffsize))); 62 63 datasize = 10000; 64 assert(NULL != (data = (char *)calloc(1, datasize))); 65 filecount = 10; 66 67 /* 68 * Write a filecount files and read them all back. 69 */ 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)); 89 assertA(datasize 90 == (size_t)archive_write_data(a, data, datasize)); 91 } 92 archive_entry_free(ae); 93 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a)); 94 assertEqualInt(ARCHIVE_OK, archive_write_free(a)); 95 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)); 103 return; 104 } 105 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))) 112 break; 113 assertEqualString(path, archive_entry_pathname(ae)); 114 assertEqualInt((int)datasize, archive_entry_size(ae)); 115 } 116 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 117 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 118 119 /* 120 * Repeat the cycle again, this time setting some compression 121 * options. 122 */ 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( 151 a, data, datasize)); 152 archive_entry_free(ae); 153 } 154 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a)); 155 assertEqualInt(ARCHIVE_OK, archive_write_free(a)); 156 157 failure("compression-level=9 wrote %d bytes, default wrote %d bytes", 158 (int)used2, (int)used1); 159 assert(used2 < used1); 160 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"); 166 } else { 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))) 175 break; 176 assertEqualString(path, archive_entry_pathname(ae)); 177 assertEqualInt((int)datasize, archive_entry_size(ae)); 178 } 179 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 180 } 181 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 182 183 /* 184 * Repeat again, with much lower compression. 185 */ 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); 207 } 208 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a)); 209 assertEqualInt(ARCHIVE_OK, archive_write_free(a)); 210 211#if 0 212 failure("Compression-level=1 wrote %d bytes; default wrote %d bytes", 213 (int)used2, (int)used1); 214 assert(used2 > used1); 215#endif 216 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"); 223 } else { 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))) 230 break; 231 assertEqualString(path, archive_entry_pathname(ae)); 232 assertEqualInt((int)datasize, archive_entry_size(ae)); 233 } 234 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 235 } 236 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 237 238 /* 239 * Test various premature shutdown scenarios to make sure we 240 * don't crash or leak memory. 241 */ 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)); 246 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)); 252 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)); 259 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)); 268 269 /* 270 * Clean up. 271 */ 272 free(data); 273 free(buff); 274} 275 276static void 277test_options(const char *options) 278{ 279 struct archive_entry *ae; 280 struct archive* a; 281 char *buff, *data; 282 size_t buffsize, datasize; 283 char path[16]; 284 size_t used1; 285 int i, r, use_prog = 0, filecount; 286 287 assert((a = archive_write_new()) != NULL); 288 r = archive_write_add_filter_lz4(a); 289 if (archive_liblz4_version() == NULL) { 290 if (!canLz4()) { 291 skipping("lz4 writing not supported on this platform"); 292 assertEqualInt(ARCHIVE_WARN, r); 293 assertEqualInt(ARCHIVE_OK, archive_write_free(a)); 294 return; 295 } else { 296 assertEqualInt(ARCHIVE_WARN, r); 297 use_prog = 1; 298 } 299 } else { 300 assertEqualInt(ARCHIVE_OK, r); 301 } 302 303 buffsize = 2000000; 304 assert(NULL != (buff = (char *)malloc(buffsize))); 305 306 datasize = 10000; 307 assert(NULL != (data = (char *)calloc(1, datasize))); 308 filecount = 10; 309 310 /* 311 * Write a filecount files and read them all back. 312 */ 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)); 334 assertA(datasize 335 == (size_t)archive_write_data(a, data, datasize)); 336 } 337 archive_entry_free(ae); 338 assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a)); 339 assertEqualInt(ARCHIVE_OK, archive_write_free(a)); 340 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"); 347 } else { 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))) 354 break; 355 assertEqualString(path, archive_entry_pathname(ae)); 356 assertEqualInt((int)datasize, archive_entry_size(ae)); 357 } 358 assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a)); 359 } 360 assertEqualInt(ARCHIVE_OK, archive_read_free(a)); 361 362 /* 363 * Clean up. 364 */ 365 free(data); 366 free(buff); 367} 368 369DEFINE_TEST(test_write_filter_lz4_disable_stream_checksum) 370{ 371 test_options("lz4:!stream-checksum"); 372} 373 374DEFINE_TEST(test_write_filter_lz4_enable_block_checksum) 375{ 376 test_options("lz4:block-checksum"); 377} 378 379DEFINE_TEST(test_write_filter_lz4_block_size_4) 380{ 381 test_options("lz4:block-size=4"); 382} 383 384DEFINE_TEST(test_write_filter_lz4_block_size_5) 385{ 386 test_options("lz4:block-size=5"); 387} 388 389DEFINE_TEST(test_write_filter_lz4_block_size_6) 390{ 391 test_options("lz4:block-size=6"); 392} 393 394DEFINE_TEST(test_write_filter_lz4_block_dependence) 395{ 396 test_options("lz4:block-dependence"); 397} 398 399/* 400 * TODO: Figure out how to correctly handle this. 401 * 402 * This option simply fails on some versions of the LZ4 libraries. 403 */ 404/* 405XXXDEFINE_TEST(test_write_filter_lz4_block_dependence_hc) 406{ 407 test_options("lz4:block-dependence,lz4:compression-level=9"); 408} 409*/ 410