contrib/libarchive/libarchive/test/test_write_filter_lz4.c

   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                 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
 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
 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 */