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 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 snprintf(path, sizeof(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 snprintf(path, sizeof(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 snprintf(path, sizeof(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 snprintf(path, sizeof(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 snprintf(path, sizeof(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 snprintf(path, sizeof(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 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 snprintf(path, sizeof(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 snprintf(path, sizeof(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 371 DEFINE_TEST(test_write_filter_lz4_disable_stream_checksum) 372 { 373 test_options("lz4:!stream-checksum"); 374 } 375 376 DEFINE_TEST(test_write_filter_lz4_enable_block_checksum) 377 { 378 test_options("lz4:block-checksum"); 379 } 380 381 DEFINE_TEST(test_write_filter_lz4_block_size_4) 382 { 383 test_options("lz4:block-size=4"); 384 } 385 386 DEFINE_TEST(test_write_filter_lz4_block_size_5) 387 { 388 test_options("lz4:block-size=5"); 389 } 390 391 DEFINE_TEST(test_write_filter_lz4_block_size_6) 392 { 393 test_options("lz4:block-size=6"); 394 } 395 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