contrib/libarchive/libarchive/test/test_read_format_7zip.c

   1 /*-
   2  * Copyright (c) 2011 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  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25 #include "test.h"
  26 __FBSDID("$FreeBSD");
  27
  28 /*
  29  * Extract a non-encoded file.
  30  * The header of the 7z archive files is not encoded.
  31  */
  32 static void
  33 test_copy()
  34 {
  35         const char *refname = "test_read_format_7zip_copy.7z";
  36         struct archive_entry *ae;
  37         struct archive *a;
  38         char buff[128];
  39
  40         extract_reference_file(refname);
  41         assert((a = archive_read_new()) != NULL);
  42         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
  43         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
  44         assertEqualIntA(a, ARCHIVE_OK,
  45             archive_read_open_filename(a, refname, 10240));
  46
  47         /* Verify regular file1. */
  48         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
  49         assertEqualInt((AE_IFREG | 0666), archive_entry_mode(ae));
  50         assertEqualString("file1", archive_entry_pathname(ae));
  51         assertEqualInt(86401, archive_entry_mtime(ae));
  52         assertEqualInt(60, archive_entry_size(ae));
  53         assertEqualInt(60, archive_read_data(a, buff, sizeof(buff)));
  54         assertEqualMem(buff, "    ", 4);
  55
  56         assertEqualInt(1, archive_file_count(a));
  57
  58         /* End of archive. */
  59         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
  60
  61         /* Verify archive format. */
  62         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
  63         assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a));
  64
  65         /* Close the archive. */
  66         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
  67         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
  68 }
  69
  70 /*
  71  * An archive file has no entry.
  72  */
  73 static void
  74 test_empty_archive()
  75 {
  76         const char *refname = "test_read_format_7zip_empty_archive.7z";
  77         struct archive_entry *ae;
  78         struct archive *a;
  79
  80         extract_reference_file(refname);
  81         assert((a = archive_read_new()) != NULL);
  82         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
  83         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
  84         assertEqualIntA(a, ARCHIVE_OK,
  85             archive_read_open_filename(a, refname, 10240));
  86
  87         /* End of archive. */
  88         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
  89
  90         assertEqualInt(0, archive_file_count(a));
  91
  92         /* Verify archive format. */
  93         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
  94         assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a));
  95
  96         /* Close the archive. */
  97         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
  98         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
  99 }
 100
 101 /*
 102  * An archive file has one empty file. It means there is no content
 103  * in the archive file except for a header.
 104  */
 105 static void
 106 test_empty_file()
 107 {
 108         const char *refname = "test_read_format_7zip_empty_file.7z";
 109         struct archive_entry *ae;
 110         struct archive *a;
 111
 112         extract_reference_file(refname);
 113         assert((a = archive_read_new()) != NULL);
 114         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 115         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 116         assertEqualIntA(a, ARCHIVE_OK,
 117             archive_read_open_filename(a, refname, 10240));
 118
 119         /* Verify regular empty. */
 120         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 121         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 122         assertEqualString("empty", archive_entry_pathname(ae));
 123         assertEqualInt(86401, archive_entry_mtime(ae));
 124         assertEqualInt(0, archive_entry_size(ae));
 125
 126         assertEqualInt(1, archive_file_count(a));
 127
 128         /* End of archive. */
 129         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 130
 131         /* Verify archive format. */
 132         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 133         assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a));
 134
 135         /* Close the archive. */
 136         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 137         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 138 }
 139
 140 /*
 141  * Extract an encoded file.
 142  * The header of the 7z archive files is not encoded.
 143  */
 144 static void
 145 test_plain_header(const char *refname)
 146 {
 147         struct archive_entry *ae;
 148         struct archive *a;
 149         char buff[128];
 150
 151         extract_reference_file(refname);
 152         assert((a = archive_read_new()) != NULL);
 153         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 154         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 155         assertEqualIntA(a, ARCHIVE_OK,
 156             archive_read_open_filename(a, refname, 10240));
 157
 158         /* Verify regular file1. */
 159         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 160         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 161         assertEqualString("file1", archive_entry_pathname(ae));
 162         assertEqualInt(1322058763, archive_entry_mtime(ae));
 163         assertEqualInt(2844, archive_entry_size(ae));
 164         assertEqualInt(sizeof(buff), archive_read_data(a, buff, sizeof(buff)));
 165         assertEqualMem(buff, "The libarchive distribution ", 28);
 166
 167         assertEqualInt(1, archive_file_count(a));
 168
 169         /* End of archive. */
 170         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 171
 172         /* Verify archive format. */
 173         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 174         assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a));
 175
 176         /* Close the archive. */
 177         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 178         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 179 }
 180
 181 /*
 182  * Extract multi files.
 183  * The header of the 7z archive files is encoded with LZMA.
 184  */
 185 static void
 186 test_extract_all_files(const char *refname)
 187 {
 188         struct archive_entry *ae;
 189         struct archive *a;
 190         char buff[128];
 191
 192         extract_reference_file(refname);
 193         assert((a = archive_read_new()) != NULL);
 194         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 195         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 196         assertEqualIntA(a, ARCHIVE_OK,
 197             archive_read_open_filename(a, refname, 10240));
 198
 199         /* Verify regular file1. */
 200         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 201         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 202         assertEqualString("dir1/file1", archive_entry_pathname(ae));
 203         assertEqualInt(86401, archive_entry_mtime(ae));
 204         assertEqualInt(13, archive_entry_size(ae));
 205         assertEqualInt(13, archive_read_data(a, buff, sizeof(buff)));
 206         assertEqualMem(buff, "aaaaaaaaaaaa\n", 13);
 207
 208         /* Verify regular file2. */
 209         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 210         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 211         assertEqualString("file2", archive_entry_pathname(ae));
 212         assertEqualInt(86401, archive_entry_mtime(ae));
 213         assertEqualInt(26, archive_entry_size(ae));
 214         assertEqualInt(26, archive_read_data(a, buff, sizeof(buff)));
 215         assertEqualMem(buff, "aaaaaaaaaaaa\nbbbbbbbbbbbb\n", 26);
 216
 217         /* Verify regular file3. */
 218         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 219         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 220         assertEqualString("file3", archive_entry_pathname(ae));
 221         assertEqualInt(86401, archive_entry_mtime(ae));
 222         assertEqualInt(39, archive_entry_size(ae));
 223         assertEqualInt(39, archive_read_data(a, buff, sizeof(buff)));
 224         assertEqualMem(buff, "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\n", 39);
 225
 226         /* Verify regular file4. */
 227         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 228         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 229         assertEqualString("file4", archive_entry_pathname(ae));
 230         assertEqualInt(86401, archive_entry_mtime(ae));
 231         assertEqualInt(52, archive_entry_size(ae));
 232         assertEqualInt(52, archive_read_data(a, buff, sizeof(buff)));
 233         assertEqualMem(buff,
 234             "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\ndddddddddddd\n", 52);
 235
 236         /* Verify directory dir1. */
 237         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 238         assertEqualInt((AE_IFDIR | 0755), archive_entry_mode(ae));
 239         assertEqualString("dir1/", archive_entry_pathname(ae));
 240         assertEqualInt(2764801, archive_entry_mtime(ae));
 241
 242         assertEqualInt(5, archive_file_count(a));
 243
 244         /* End of archive. */
 245         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 246
 247         /* Verify archive format. */
 248         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 249         assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a));
 250
 251         /* Close the archive. */
 252         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 253         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 254 }
 255
 256 /*
 257  * Extract last file.
 258  * The header of the 7z archive files is encoded with LZMA.
 259  */
 260 static void
 261 test_extract_last_file(const char *refname)
 262 {
 263         struct archive_entry *ae;
 264         struct archive *a;
 265         char buff[128];
 266
 267         extract_reference_file(refname);
 268         assert((a = archive_read_new()) != NULL);
 269         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 270         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 271         assertEqualIntA(a, ARCHIVE_OK,
 272             archive_read_open_filename(a, refname, 10240));
 273
 274         /* Verify regular file1. */
 275         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 276         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 277         assertEqualString("dir1/file1", archive_entry_pathname(ae));
 278         assertEqualInt(86401, archive_entry_mtime(ae));
 279         assertEqualInt(13, archive_entry_size(ae));
 280
 281         /* Verify regular file2. */
 282         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 283         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 284         assertEqualString("file2", archive_entry_pathname(ae));
 285         assertEqualInt(86401, archive_entry_mtime(ae));
 286         assertEqualInt(26, archive_entry_size(ae));
 287
 288         /* Verify regular file3. */
 289         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 290         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 291         assertEqualString("file3", archive_entry_pathname(ae));
 292         assertEqualInt(86401, archive_entry_mtime(ae));
 293         assertEqualInt(39, archive_entry_size(ae));
 294
 295         /* Verify regular file4. */
 296         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 297         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 298         assertEqualString("file4", archive_entry_pathname(ae));
 299         assertEqualInt(86401, archive_entry_mtime(ae));
 300         assertEqualInt(52, archive_entry_size(ae));
 301         assertEqualInt(52, archive_read_data(a, buff, sizeof(buff)));
 302         assertEqualMem(buff,
 303             "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\ndddddddddddd\n", 52);
 304
 305         /* Verify directory dir1. */
 306         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 307         assertEqualInt((AE_IFDIR | 0755), archive_entry_mode(ae));
 308         assertEqualString("dir1/", archive_entry_pathname(ae));
 309         assertEqualInt(2764801, archive_entry_mtime(ae));
 310
 311         assertEqualInt(5, archive_file_count(a));
 312
 313         /* End of archive. */
 314         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 315
 316         /* Verify archive format. */
 317         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 318         assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a));
 319
 320         /* Close the archive. */
 321         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 322         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 323 }
 324
 325 /*
 326  * Extract a mixed archive file which has both LZMA and LZMA2 encoded files.
 327  *  LZMA: file1, file2, file3, file4
 328  *  LZMA2: zfile1, zfile2, zfile3, zfile4
 329  */
 330 static void
 331 test_extract_all_files2(const char *refname)
 332 {
 333         struct archive_entry *ae;
 334         struct archive *a;
 335         char buff[128];
 336
 337         extract_reference_file(refname);
 338         assert((a = archive_read_new()) != NULL);
 339         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 340         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 341         assertEqualIntA(a, ARCHIVE_OK,
 342             archive_read_open_filename(a, refname, 10240));
 343
 344         /* Verify regular file1. */
 345         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 346         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 347         assertEqualString("dir1/file1", archive_entry_pathname(ae));
 348         assertEqualInt(86401, archive_entry_mtime(ae));
 349         assertEqualInt(13, archive_entry_size(ae));
 350         assertEqualInt(13, archive_read_data(a, buff, sizeof(buff)));
 351         assertEqualMem(buff, "aaaaaaaaaaaa\n", 13);
 352
 353         /* Verify regular file2. */
 354         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 355         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 356         assertEqualString("file2", archive_entry_pathname(ae));
 357         assertEqualInt(86401, archive_entry_mtime(ae));
 358         assertEqualInt(26, archive_entry_size(ae));
 359         assertEqualInt(26, archive_read_data(a, buff, sizeof(buff)));
 360         assertEqualMem(buff, "aaaaaaaaaaaa\nbbbbbbbbbbbb\n", 26);
 361
 362         /* Verify regular file3. */
 363         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 364         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 365         assertEqualString("file3", archive_entry_pathname(ae));
 366         assertEqualInt(86401, archive_entry_mtime(ae));
 367         assertEqualInt(39, archive_entry_size(ae));
 368         assertEqualInt(39, archive_read_data(a, buff, sizeof(buff)));
 369         assertEqualMem(buff, "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\n", 39);
 370
 371         /* Verify regular file4. */
 372         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 373         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 374         assertEqualString("file4", archive_entry_pathname(ae));
 375         assertEqualInt(86401, archive_entry_mtime(ae));
 376         assertEqualInt(52, archive_entry_size(ae));
 377         assertEqualInt(52, archive_read_data(a, buff, sizeof(buff)));
 378         assertEqualMem(buff,
 379             "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\ndddddddddddd\n", 52);
 380
 381         /* Verify regular zfile1. */
 382         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 383         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 384         assertEqualString("dir1/zfile1", archive_entry_pathname(ae));
 385         assertEqualInt(5184001, archive_entry_mtime(ae));
 386         assertEqualInt(13, archive_entry_size(ae));
 387         assertEqualInt(13, archive_read_data(a, buff, sizeof(buff)));
 388         assertEqualMem(buff, "aaaaaaaaaaaa\n", 13);
 389
 390         /* Verify regular zfile2. */
 391         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 392         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 393         assertEqualString("zfile2", archive_entry_pathname(ae));
 394         assertEqualInt(5184001, archive_entry_mtime(ae));
 395         assertEqualInt(26, archive_entry_size(ae));
 396         assertEqualInt(26, archive_read_data(a, buff, sizeof(buff)));
 397         assertEqualMem(buff, "aaaaaaaaaaaa\nbbbbbbbbbbbb\n", 26);
 398
 399         /* Verify regular zfile3. */
 400         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 401         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 402         assertEqualString("zfile3", archive_entry_pathname(ae));
 403         assertEqualInt(5184001, archive_entry_mtime(ae));
 404         assertEqualInt(39, archive_entry_size(ae));
 405         assertEqualInt(39, archive_read_data(a, buff, sizeof(buff)));
 406         assertEqualMem(buff, "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\n", 39);
 407
 408         /* Verify regular zfile4. */
 409         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 410         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 411         assertEqualString("zfile4", archive_entry_pathname(ae));
 412         assertEqualInt(5184001, archive_entry_mtime(ae));
 413         assertEqualInt(52, archive_entry_size(ae));
 414         assertEqualInt(52, archive_read_data(a, buff, sizeof(buff)));
 415         assertEqualMem(buff,
 416             "aaaaaaaaaaaa\nbbbbbbbbbbbb\ncccccccccccc\ndddddddddddd\n", 52);
 417
 418         /* Verify directory dir1. */
 419         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 420         assertEqualInt((AE_IFDIR | 0755), archive_entry_mode(ae));
 421         assertEqualString("dir1/", archive_entry_pathname(ae));
 422         assertEqualInt(2764801, archive_entry_mtime(ae));
 423
 424         assertEqualInt(9, archive_file_count(a));
 425
 426         /* End of archive. */
 427         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 428
 429         /* Verify archive format. */
 430         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 431         assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a));
 432
 433         /* Close the archive. */
 434         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 435         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 436 }
 437
 438 /*
 439  * Extract a file compressed with DELTA + LZMA[12].
 440  */
 441 static void
 442 test_delta_lzma(const char *refname)
 443 {
 444         struct archive_entry *ae;
 445         struct archive *a;
 446         size_t remaining;
 447         ssize_t bytes;
 448         char buff[1024];
 449
 450         extract_reference_file(refname);
 451         assert((a = archive_read_new()) != NULL);
 452         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 453         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 454         assertEqualIntA(a, ARCHIVE_OK,
 455             archive_read_open_filename(a, refname, 10240));
 456
 457         /* Verify regular file1. */
 458         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 459         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 460         assertEqualString("file1", archive_entry_pathname(ae));
 461         assertEqualInt(172802, archive_entry_mtime(ae));
 462         assertEqualInt(27627, archive_entry_size(ae));
 463         remaining = (size_t)archive_entry_size(ae);
 464         while (remaining) {
 465                 if (remaining < sizeof(buff))
 466                         assertEqualInt(remaining,
 467                             bytes = archive_read_data(a, buff, sizeof(buff)));
 468                 else
 469                         assertEqualInt(sizeof(buff),
 470                             bytes = archive_read_data(a, buff, sizeof(buff)));
 471                 if (bytes > 0)
 472                         remaining -= bytes;
 473                 else
 474                         break;
 475         }
 476         assertEqualInt(0, remaining);
 477
 478         assertEqualInt(1, archive_file_count(a));
 479
 480         /* End of archive. */
 481         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 482
 483         /* Verify archive format. */
 484         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 485         assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a));
 486
 487         /* Close the archive. */
 488         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 489         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 490 }
 491
 492 /*
 493  * Extract a file compressed with BCJ + LZMA2.
 494  */
 495 static void
 496 test_bcj(const char *refname)
 497 {
 498         struct archive_entry *ae;
 499         struct archive *a;
 500         size_t remaining;
 501         ssize_t bytes;
 502         char buff[1024];
 503
 504         extract_reference_file(refname);
 505         assert((a = archive_read_new()) != NULL);
 506         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 507         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 508         assertEqualIntA(a, ARCHIVE_OK,
 509             archive_read_open_filename(a, refname, 10240));
 510
 511         /* Verify regular x86exe. */
 512         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 513         assertEqualInt((AE_IFREG | 0444), archive_entry_mode(ae) & ~0111);
 514         assertEqualString("x86exe", archive_entry_pathname(ae));
 515         assertEqualInt(172802, archive_entry_mtime(ae));
 516         assertEqualInt(27328, archive_entry_size(ae));
 517         remaining = (size_t)archive_entry_size(ae);
 518         while (remaining) {
 519                 if (remaining < sizeof(buff))
 520                         assertEqualInt(remaining,
 521                             bytes = archive_read_data(a, buff, sizeof(buff)));
 522                 else
 523                         assertEqualInt(sizeof(buff),
 524                             bytes = archive_read_data(a, buff, sizeof(buff)));
 525                 if (bytes > 0)
 526                         remaining -= bytes;
 527                 else
 528                         break;
 529         }
 530         assertEqualInt(0, remaining);
 531
 532         assertEqualInt(1, archive_file_count(a));
 533
 534         /* End of archive. */
 535         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 536
 537         /* Verify archive format. */
 538         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 539         assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a));
 540
 541         /* Close the archive. */
 542         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 543         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 544 }
 545
 546 /*
 547  * Extract a file compressed with PPMd.
 548  */
 549 static void
 550 test_ppmd()
 551 {
 552         const char *refname = "test_read_format_7zip_ppmd.7z";
 553         struct archive_entry *ae;
 554         struct archive *a;
 555         size_t remaining;
 556         ssize_t bytes;
 557         char buff[1024];
 558
 559         extract_reference_file(refname);
 560         assert((a = archive_read_new()) != NULL);
 561         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 562         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 563         assertEqualIntA(a, ARCHIVE_OK,
 564             archive_read_open_filename(a, refname, 10240));
 565
 566         /* Verify regular file1. */
 567         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 568         assertEqualInt((AE_IFREG | 0666), archive_entry_mode(ae));
 569         assertEqualString("ppmd_test.txt", archive_entry_pathname(ae));
 570         assertEqualInt(1322464589, archive_entry_mtime(ae));
 571         assertEqualInt(102400, archive_entry_size(ae));
 572         remaining = (size_t)archive_entry_size(ae);
 573         while (remaining) {
 574                 if (remaining < sizeof(buff))
 575                         assertEqualInt(remaining,
 576                             bytes = archive_read_data(a, buff, sizeof(buff)));
 577                 else
 578                         assertEqualInt(sizeof(buff),
 579                             bytes = archive_read_data(a, buff, sizeof(buff)));
 580                 if (bytes > 0)
 581                         remaining -= bytes;
 582                 else
 583                         break;
 584         }
 585         assertEqualInt(0, remaining);
 586
 587         assertEqualInt(1, archive_file_count(a));
 588
 589         /* End of archive. */
 590         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 591
 592         /* Verify archive format. */
 593         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 594         assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a));
 595
 596         /* Close the archive. */
 597         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 598         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 599 }
 600
 601 static void
 602 test_symname()
 603 {
 604         const char *refname = "test_read_format_7zip_symbolic_name.7z";
 605         struct archive_entry *ae;
 606         struct archive *a;
 607         char buff[128];
 608
 609         extract_reference_file(refname);
 610         assert((a = archive_read_new()) != NULL);
 611         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 612         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 613         assertEqualIntA(a, ARCHIVE_OK,
 614             archive_read_open_filename(a, refname, 10240));
 615
 616         /* Verify regular file1. */
 617         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 618         assertEqualInt((AE_IFREG | 0644), archive_entry_mode(ae));
 619         assertEqualString("file1", archive_entry_pathname(ae));
 620         assertEqualInt(86401, archive_entry_mtime(ae));
 621         assertEqualInt(32, archive_entry_size(ae));
 622         assertEqualInt(32, archive_read_data(a, buff, sizeof(buff)));
 623         assertEqualMem(buff, "hellohellohello\nhellohellohello\n", 32);
 624
 625         /* Verify symbolic-linke symlinkfile. */
 626         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 627         assertEqualInt((AE_IFLNK | 0755), archive_entry_mode(ae));
 628         assertEqualString("symlinkfile", archive_entry_pathname(ae));
 629         assertEqualString("file1", archive_entry_symlink(ae));
 630         assertEqualInt(86401, archive_entry_mtime(ae));
 631
 632         assertEqualInt(2, archive_file_count(a));
 633
 634         /* End of archive. */
 635         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 636
 637         /* Verify archive format. */
 638         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 639         assertEqualIntA(a, ARCHIVE_FORMAT_7ZIP, archive_format(a));
 640
 641         /* Close the archive. */
 642         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 643         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 644 }
 645
 646
 647 DEFINE_TEST(test_read_format_7zip)
 648 {
 649         struct archive *a;
 650
 651         assert((a = archive_read_new()) != NULL);
 652
 653         /* Extracting with liblzma */
 654         if (ARCHIVE_OK != archive_read_support_filter_xz(a)) {
 655                 skipping("7zip:lzma decoding is not supported on this platform");
 656         } else {
 657                 test_symname();
 658                 test_extract_all_files("test_read_format_7zip_copy_2.7z");
 659                 test_extract_last_file("test_read_format_7zip_copy_2.7z");
 660                 test_extract_all_files2("test_read_format_7zip_lzma1_lzma2.7z");
 661                 test_bcj("test_read_format_7zip_bcj2_copy_lzma.7z");
 662         }
 663         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 664 }
 665
 666 DEFINE_TEST(test_read_format_7zip_bzip2)
 667 {
 668         struct archive *a;
 669
 670         assert((a = archive_read_new()) != NULL);
 671
 672         /* Extracting with libbzip2 */
 673         if (ARCHIVE_OK != archive_read_support_filter_bzip2(a)) {
 674                 skipping("7zip:bzip2 decoding is not supported on this platform");
 675         } else {
 676                 test_plain_header("test_read_format_7zip_bzip2.7z");
 677                 test_bcj("test_read_format_7zip_bcj_bzip2.7z");
 678                 test_bcj("test_read_format_7zip_bcj2_bzip2.7z");
 679         }
 680
 681         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 682 }
 683
 684 DEFINE_TEST(test_read_format_7zip_copy)
 685 {
 686         test_copy();
 687         test_bcj("test_read_format_7zip_bcj_copy.7z");
 688         test_bcj("test_read_format_7zip_bcj2_copy_1.7z");
 689         test_bcj("test_read_format_7zip_bcj2_copy_2.7z");
 690 }
 691
 692 DEFINE_TEST(test_read_format_7zip_deflate)
 693 {
 694         struct archive *a;
 695
 696         assert((a = archive_read_new()) != NULL);
 697
 698         /* Extracting with libz */
 699         if (ARCHIVE_OK != archive_read_support_filter_gzip(a)) {
 700                 skipping(
 701                     "7zip:deflate decoding is not supported on this platform");
 702         } else {
 703                 test_plain_header("test_read_format_7zip_deflate.7z");
 704                 test_bcj("test_read_format_7zip_bcj_deflate.7z");
 705                 test_bcj("test_read_format_7zip_bcj2_deflate.7z");
 706         }
 707
 708         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 709 }
 710
 711 DEFINE_TEST(test_read_format_7zip_empty)
 712 {
 713         test_empty_archive();
 714         test_empty_file();
 715 }
 716
 717 DEFINE_TEST(test_read_format_7zip_lzma1)
 718 {
 719         struct archive *a;
 720
 721         assert((a = archive_read_new()) != NULL);
 722
 723         /* Extracting with liblzma */
 724         if (ARCHIVE_OK != archive_read_support_filter_xz(a)) {
 725                 skipping("7zip:lzma decoding is not supported on this platform");
 726         } else {
 727                 test_plain_header("test_read_format_7zip_lzma1.7z");
 728                 test_extract_all_files("test_read_format_7zip_lzma1_2.7z");
 729                 test_extract_last_file("test_read_format_7zip_lzma1_2.7z");
 730                 test_bcj("test_read_format_7zip_bcj_lzma1.7z");
 731                 test_bcj("test_read_format_7zip_bcj2_lzma1_1.7z");
 732                 test_bcj("test_read_format_7zip_bcj2_lzma1_2.7z");
 733                 test_delta_lzma("test_read_format_7zip_delta_lzma1.7z");
 734         }
 735         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 736 }
 737
 738 DEFINE_TEST(test_read_format_7zip_lzma2)
 739 {
 740         struct archive *a;
 741
 742         assert((a = archive_read_new()) != NULL);
 743
 744         /* Extracting with liblzma */
 745         if (ARCHIVE_OK != archive_read_support_filter_xz(a)) {
 746                 skipping("7zip:lzma decoding is not supported on this platform");
 747         } else {
 748                 test_plain_header("test_read_format_7zip_lzma2.7z");
 749                 test_bcj("test_read_format_7zip_bcj_lzma2.7z");
 750                 test_bcj("test_read_format_7zip_bcj2_lzma2_1.7z");
 751                 test_bcj("test_read_format_7zip_bcj2_lzma2_2.7z");
 752                 test_delta_lzma("test_read_format_7zip_delta_lzma2.7z");
 753         }
 754         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 755 }
 756
 757 DEFINE_TEST(test_read_format_7zip_ppmd)
 758 {
 759         test_ppmd();
 760 }