contrib/libarchive/libarchive/test/test_read_format_rar.c

   1 /*-
   2  * Copyright (c) 2003-2007 Tim Kientzle
   3  * Copyright (c) 2011 Andres Mejia
   4  * Copyright (c) 2011-2012 Michihiro NAKAJIMA
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27 #include "test.h"
  28
  29 #include <locale.h>
  30
  31 DEFINE_TEST(test_read_format_rar_set_format)
  32 {
  33     struct archive *a;
  34     struct archive_entry *ae;
  35     const char reffile[] = "test_read_format_rar.rar";
  36
  37     extract_reference_file(reffile);
  38     assert((a = archive_read_new()) != NULL);
  39     assertA(0 == archive_read_support_filter_all(a));
  40     assertA(0 == archive_read_set_format(a, ARCHIVE_FORMAT_RAR));
  41     assertA(0 == archive_read_open_filename(a, reffile, 10240));
  42     assertA(0 == archive_read_next_header(a, &ae));
  43     assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
  44     assertEqualInt(ARCHIVE_OK, archive_read_free(a));
  45 }
  46
  47 DEFINE_TEST(test_read_format_rar_basic)
  48 {
  49   char buff[64];
  50   const char reffile[] = "test_read_format_rar.rar";
  51   const char test_txt[] = "test text document\r\n";
  52   int size = sizeof(test_txt)-1;
  53   struct archive_entry *ae;
  54   struct archive *a;
  55
  56   extract_reference_file(reffile);
  57   assert((a = archive_read_new()) != NULL);
  58   assertA(0 == archive_read_support_filter_all(a));
  59   assertA(0 == archive_read_support_format_all(a));
  60   assertA(0 == archive_read_open_filename(a, reffile, 10240));
  61
  62   /* First header. */
  63   assertA(0 == archive_read_next_header(a, &ae));
  64   assertEqualString("test.txt", archive_entry_pathname(ae));
  65   assertA((int)archive_entry_mtime(ae));
  66   assertA((int)archive_entry_ctime(ae));
  67   assertA((int)archive_entry_atime(ae));
  68   assertEqualInt(20, archive_entry_size(ae));
  69   assertEqualInt(33188, archive_entry_mode(ae));
  70   assertA(size == archive_read_data(a, buff, size));
  71   assertEqualMem(buff, test_txt, size);
  72   assertEqualInt(archive_entry_is_encrypted(ae), 0);
  73   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  74
  75   /* Second header. */
  76   assertA(0 == archive_read_next_header(a, &ae));
  77   assertEqualString("testlink", archive_entry_pathname(ae));
  78   assertA((int)archive_entry_mtime(ae));
  79   assertA((int)archive_entry_ctime(ae));
  80   assertA((int)archive_entry_atime(ae));
  81   assertEqualInt(0, archive_entry_size(ae));
  82   assertEqualInt(41471, archive_entry_mode(ae));
  83   assertEqualString("test.txt", archive_entry_symlink(ae));
  84   assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));
  85   assertEqualInt(archive_entry_is_encrypted(ae), 0);
  86   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
  87
  88   /* Third header. */
  89   assertA(0 == archive_read_next_header(a, &ae));
  90   assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
  91   assertA((int)archive_entry_mtime(ae));
  92   assertA((int)archive_entry_ctime(ae));
  93   assertA((int)archive_entry_atime(ae));
  94   assertEqualInt(20, archive_entry_size(ae));
  95   assertEqualInt(33188, archive_entry_mode(ae));
  96   assertA(size == archive_read_data(a, buff, size));
  97   assertEqualMem(buff, test_txt, size);
  98   assertEqualInt(archive_entry_is_encrypted(ae), 0);
  99   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 100
 101   /* Fourth header. */
 102   assertA(0 == archive_read_next_header(a, &ae));
 103   assertEqualString("testdir", archive_entry_pathname(ae));
 104   assertA((int)archive_entry_mtime(ae));
 105   assertA((int)archive_entry_ctime(ae));
 106   assertA((int)archive_entry_atime(ae));
 107   assertEqualInt(0, archive_entry_size(ae));
 108   assertEqualInt(16877, archive_entry_mode(ae));
 109   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 110   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 111
 112   /* Fifth header. */
 113   assertA(0 == archive_read_next_header(a, &ae));
 114   assertEqualString("testemptydir", archive_entry_pathname(ae));
 115   assertA((int)archive_entry_mtime(ae));
 116   assertA((int)archive_entry_ctime(ae));
 117   assertA((int)archive_entry_atime(ae));
 118   assertEqualInt(0, archive_entry_size(ae));
 119   assertEqualInt(16877, archive_entry_mode(ae));
 120   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 121   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 122
 123   /* Test EOF */
 124   assertA(1 == archive_read_next_header(a, &ae));
 125   assertEqualInt(5, archive_file_count(a));
 126   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 127   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 128 }
 129
 130 DEFINE_TEST(test_read_format_rar_subblock)
 131 {
 132   char buff[64];
 133   const char reffile[] = "test_read_format_rar_subblock.rar";
 134   const char test_txt[] = "test text document\r\n";
 135   int size = sizeof(test_txt)-1;
 136   struct archive_entry *ae;
 137   struct archive *a;
 138
 139   extract_reference_file(reffile);
 140   assert((a = archive_read_new()) != NULL);
 141   assertA(0 == archive_read_support_filter_all(a));
 142   assertA(0 == archive_read_support_format_all(a));
 143   assertA(0 == archive_read_open_filename(a, reffile, 10240));
 144
 145   /* First header. */
 146   assertA(0 == archive_read_next_header(a, &ae));
 147   assertEqualString("test.txt", archive_entry_pathname(ae));
 148   assertA((int)archive_entry_mtime(ae));
 149   assertA((int)archive_entry_ctime(ae));
 150   assertA((int)archive_entry_atime(ae));
 151   assertEqualInt(20, archive_entry_size(ae));
 152   assertEqualInt(33188, archive_entry_mode(ae));
 153   assertA(size == archive_read_data(a, buff, size));
 154   assertEqualMem(buff, test_txt, size);
 155   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 156   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 157
 158   /* Test EOF */
 159   assertA(1 == archive_read_next_header(a, &ae));
 160   assertEqualInt(1, archive_file_count(a));
 161   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 162   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 163 }
 164
 165 DEFINE_TEST(test_read_format_rar_noeof)
 166 {
 167   char buff[64];
 168   const char reffile[] = "test_read_format_rar_noeof.rar";
 169   const char test_txt[] = "test text document\r\n";
 170   int size = sizeof(test_txt)-1;
 171   struct archive_entry *ae;
 172   struct archive *a;
 173
 174   extract_reference_file(reffile);
 175   assert((a = archive_read_new()) != NULL);
 176   assertA(0 == archive_read_support_filter_all(a));
 177   assertA(0 == archive_read_support_format_all(a));
 178   assertA(0 == archive_read_open_filename(a, reffile, 10240));
 179
 180   /* First header. */
 181   assertA(0 == archive_read_next_header(a, &ae));
 182   assertEqualString("test.txt", archive_entry_pathname(ae));
 183   assertA((int)archive_entry_mtime(ae));
 184   assertA((int)archive_entry_ctime(ae));
 185   assertA((int)archive_entry_atime(ae));
 186   assertEqualInt(20, archive_entry_size(ae));
 187   assertEqualInt(33188, archive_entry_mode(ae));
 188   assertA(size == archive_read_data(a, buff, size));
 189   assertEqualMem(buff, test_txt, size);
 190   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 191   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 192
 193   /* Test EOF */
 194   assertA(1 == archive_read_next_header(a, &ae));
 195   assertEqualInt(1, archive_file_count(a));
 196   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 197   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 198 }
 199
 200 DEFINE_TEST(test_read_format_rar_unicode_UTF8)
 201 {
 202   char buff[30];
 203   const char reffile[] = "test_read_format_rar_unicode.rar";
 204   const char test_txt[] = "kanji";
 205   struct archive_entry *ae;
 206   struct archive *a;
 207
 208   if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
 209         skipping("en_US.UTF-8 locale not available on this system.");
 210         return;
 211   }
 212
 213   extract_reference_file(reffile);
 214   assert((a = archive_read_new()) != NULL);
 215   assertA(0 == archive_read_support_filter_all(a));
 216   assertA(0 == archive_read_support_format_all(a));
 217   assertA(0 == archive_read_open_filename(a, reffile, 10240));
 218
 219   /* First header. */
 220   assertA(0 == archive_read_next_header(a, &ae));
 221 #if defined(__APPLE__)
 222 #define f1name "\xE8\xA1\xA8\xE3\x81\x9F\xE3\x82\x99\xE3\x82\x88/"\
 223       "\xE6\x96\xB0\xE3\x81\x97\xE3\x81\x84\xE3\x83\x95\xE3\x82\xA9"\
 224       "\xE3\x83\xAB\xE3\x82\xBF\xE3\x82\x99/\xE6\x96\xB0\xE8\xA6\x8F"\
 225       "\xE3\x83\x86\xE3\x82\xAD\xE3\x82\xB9\xE3\x83\x88 "\
 226       "\xE3\x83\x88\xE3\x82\x99\xE3\x82\xAD\xE3\x83\xA5\xE3\x83\xA1"\
 227       "\xE3\x83\xB3\xE3\x83\x88.txt" /* NFD */
 228 #else
 229 #define f1name "\xE8\xA1\xA8\xE3\x81\xA0\xE3\x82\x88/"\
 230       "\xE6\x96\xB0\xE3\x81\x97\xE3\x81\x84\xE3\x83\x95\xE3\x82\xA9"\
 231       "\xE3\x83\xAB\xE3\x83\x80/\xE6\x96\xB0\xE8\xA6\x8F"\
 232       "\xE3\x83\x86\xE3\x82\xAD\xE3\x82\xB9\xE3\x83\x88 "\
 233       "\xE3\x83\x89\xE3\x82\xAD\xE3\x83\xA5\xE3\x83\xA1"\
 234       "\xE3\x83\xB3\xE3\x83\x88.txt" /* NFC */
 235 #endif
 236   assertEqualUTF8String(f1name, archive_entry_pathname(ae));
 237   assertA((int)archive_entry_mtime(ae));
 238   assertEqualInt(0, archive_entry_size(ae));
 239   assertEqualInt(33188, archive_entry_mode(ae));
 240
 241   /* Second header. */
 242   assertA(0 == archive_read_next_header(a, &ae));
 243 #if defined(__APPLE__)
 244 #define f2name "\xE8\xA1\xA8\xE3\x81\x9F\xE3\x82\x99\xE3\x82\x88/"\
 245       "\xE6\xBC\xA2\xE5\xAD\x97\xE9\x95\xB7\xE3\x81\x84\xE3\x83\x95"\
 246       "\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB\xE5\x90\x8Dlong-filename-in-"\
 247       "\xE6\xBC\xA2\xE5\xAD\x97.txt" /* NFD */
 248 #else
 249 #define f2name "\xE8\xA1\xA8\xE3\x81\xA0\xE3\x82\x88/"\
 250       "\xE6\xBC\xA2\xE5\xAD\x97\xE9\x95\xB7\xE3\x81\x84\xE3\x83\x95"\
 251       "\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB\xE5\x90\x8Dlong-filename-in-"\
 252       "\xE6\xBC\xA2\xE5\xAD\x97.txt" /* NFC */
 253 #endif
 254   assertEqualUTF8String(f2name, archive_entry_pathname(ae));
 255   assertA((int)archive_entry_mtime(ae));
 256   assertEqualInt(5, archive_entry_size(ae));
 257   assertEqualInt(33188, archive_entry_mode(ae));
 258   assertEqualIntA(a, 5, archive_read_data(a, buff, 5));
 259   assertEqualMem(buff, test_txt, 5);
 260   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 261   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 262
 263   /* Third header. */
 264   assertA(0 == archive_read_next_header(a, &ae));
 265 #if defined(__APPLE__)
 266 #define f3name "\xE8\xA1\xA8\xE3\x81\x9F\xE3\x82\x99\xE3\x82\x88/"\
 267       "\xE6\x96\xB0\xE3\x81\x97\xE3\x81\x84\xE3\x83\x95\xE3\x82"\
 268       "\xA9\xE3\x83\xAB\xE3\x82\xBF\xE3\x82\x99" /* NFD */
 269 #else
 270 #define f3name "\xE8\xA1\xA8\xE3\x81\xA0\xE3\x82\x88/"\
 271       "\xE6\x96\xB0\xE3\x81\x97\xE3\x81\x84\xE3\x83\x95\xE3\x82"\
 272       "\xA9\xE3\x83\xAB\xE3\x83\x80" /* NFC */
 273 #endif
 274   assertEqualUTF8String(f3name, archive_entry_pathname(ae));
 275   assertA((int)archive_entry_mtime(ae));
 276   assertEqualInt(0, archive_entry_size(ae));
 277   assertEqualInt(16877, archive_entry_mode(ae));
 278
 279   /* Fourth header. */
 280   assertA(0 == archive_read_next_header(a, &ae));
 281 #if defined(__APPLE__)
 282 #define f4name "\xE8\xA1\xA8\xE3\x81\x9F\xE3\x82\x99\xE3\x82\x88" /* NFD */
 283 #else
 284 #define f4name "\xE8\xA1\xA8\xE3\x81\xA0\xE3\x82\x88" /* NFC */
 285 #endif
 286   assertEqualUTF8String(f4name, archive_entry_pathname(ae));
 287   assertA((int)archive_entry_mtime(ae));
 288   assertEqualInt(0, archive_entry_size(ae));
 289   assertEqualInt(16877, archive_entry_mode(ae));
 290
 291   /* Fifth header, which has a symbolic-link name in multi-byte characters. */
 292   assertA(0 == archive_read_next_header(a, &ae));
 293 #if defined(__APPLE__)
 294 #define f5name "\xE8\xA1\xA8\xE3\x81\x9F\xE3\x82\x99\xE3\x82\x88/"\
 295       "\xE3\x83\x95\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB" /* NFD */
 296 #else
 297 #define f5name "\xE8\xA1\xA8\xE3\x81\xA0\xE3\x82\x88/"\
 298       "\xE3\x83\x95\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB" /* NFC */
 299 #endif
 300   assertEqualUTF8String(f5name, archive_entry_pathname(ae));
 301   assertEqualUTF8String(
 302       "\xE6\xBC\xA2\xE5\xAD\x97\xE9\x95\xB7\xE3\x81\x84\xE3\x83\x95"
 303       "\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB\xE5\x90\x8Dlong-filename-in-"
 304       "\xE6\xBC\xA2\xE5\xAD\x97.txt", archive_entry_symlink(ae));
 305   assertA((int)archive_entry_mtime(ae));
 306   assertEqualInt(0, archive_entry_size(ae));
 307   assertEqualInt(41453, archive_entry_mode(ae));
 308   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 309   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 310   assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));
 311
 312   /* Sixth header */
 313   assertA(0 == archive_read_next_header(a, &ae));
 314   assertEqualUTF8String(
 315     "abcdefghijklmnopqrs\xE3\x83\x86\xE3\x82\xB9\xE3\x83\x88.txt",
 316     archive_entry_pathname(ae));
 317   assertA((int)archive_entry_mtime(ae));
 318   assertEqualInt(16, archive_entry_size(ae));
 319   assertEqualInt(33204, archive_entry_mode(ae));
 320   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 321   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 322   assertEqualIntA(a, 16, archive_read_data(a, buff, sizeof(buff)));
 323
 324   /* Test EOF */
 325   assertA(1 == archive_read_next_header(a, &ae));
 326   assertEqualInt(6, archive_file_count(a));
 327   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 328   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 329 }
 330
 331 DEFINE_TEST(test_read_format_rar_unicode_CP932)
 332 {
 333   char buff[30];
 334   const char reffile[] = "test_read_format_rar_unicode.rar";
 335   const char test_txt[] = "kanji";
 336   struct archive_entry *ae;
 337   struct archive *a;
 338
 339   if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
 340     NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
 341         skipping("CP932 locale not available on this system.");
 342         return;
 343   }
 344
 345   extract_reference_file(reffile);
 346   assert((a = archive_read_new()) != NULL);
 347   assertA(0 == archive_read_support_filter_all(a));
 348   assertA(0 == archive_read_support_format_all(a));
 349   /* Specify the charset of symbolic-link file name. */
 350   if (ARCHIVE_OK != archive_read_set_options(a, "rar:hdrcharset=UTF-8")) {
 351         skipping("This system cannot convert character-set"
 352             " from UTF-8 to CP932.");
 353         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 354         return;
 355   }
 356   assertA(0 == archive_read_open_filename(a, reffile, 10240));
 357
 358   /* First header. */
 359   assertA(0 == archive_read_next_header(a, &ae));
 360   assertEqualString("\x95\x5c\x82\xbe\x82\xe6/\x90\x56\x82\xb5\x82\xa2"
 361       "\x83\x74\x83\x48\x83\x8b\x83\x5f/\x90\x56\x8b\x4b\x83\x65\x83\x4c"
 362       "\x83\x58\x83\x67 \x83\x68\x83\x4c\x83\x85\x83\x81\x83\x93\x83\x67.txt",
 363       archive_entry_pathname(ae));
 364   assertA((int)archive_entry_mtime(ae));
 365   assertEqualInt(0, archive_entry_size(ae));
 366   assertEqualInt(33188, archive_entry_mode(ae));
 367   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 368   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 369
 370   /* Second header. */
 371   assertA(0 == archive_read_next_header(a, &ae));
 372   assertEqualString("\x95\x5c\x82\xbe\x82\xe6/\x8a\xbf\x8e\x9a"
 373       "\x92\xb7\x82\xa2\x83\x74\x83\x40\x83\x43\x83\x8b\x96\xbc\x6c"
 374       "\x6f\x6e\x67\x2d\x66\x69\x6c\x65\x6e\x61\x6d\x65\x2d\x69\x6e"
 375       "\x2d\x8a\xbf\x8e\x9a.txt", archive_entry_pathname(ae));
 376   assertA((int)archive_entry_mtime(ae));
 377   assertEqualInt(5, archive_entry_size(ae));
 378   assertEqualInt(33188, archive_entry_mode(ae));
 379   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 380   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 381   assertA(5 == archive_read_data(a, buff, 5));
 382   assertEqualMem(buff, test_txt, 5);
 383
 384   /* Third header. */
 385   assertA(0 == archive_read_next_header(a, &ae));
 386   assertEqualString("\x95\x5c\x82\xbe\x82\xe6/"
 387       "\x90\x56\x82\xb5\x82\xa2\x83\x74\x83\x48\x83\x8b\x83\x5f",
 388       archive_entry_pathname(ae));
 389   assertA((int)archive_entry_mtime(ae));
 390   assertEqualInt(0, archive_entry_size(ae));
 391   assertEqualInt(16877, archive_entry_mode(ae));
 392   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 393   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 394
 395   /* Fourth header. */
 396   assertA(0 == archive_read_next_header(a, &ae));
 397   assertEqualString("\x95\x5c\x82\xbe\x82\xe6", archive_entry_pathname(ae));
 398   assertA((int)archive_entry_mtime(ae));
 399   assertEqualInt(0, archive_entry_size(ae));
 400   assertEqualInt(16877, archive_entry_mode(ae));
 401   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 402   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 403
 404   /* Fifth header, which has a symbolic-link name in multi-byte characters. */
 405   assertA(0 == archive_read_next_header(a, &ae));
 406   assertEqualString("\x95\x5c\x82\xbe\x82\xe6/"
 407       "\x83\x74\x83\x40\x83\x43\x83\x8B", archive_entry_pathname(ae));
 408   assertEqualString("\x8a\xbf\x8e\x9a"
 409       "\x92\xb7\x82\xa2\x83\x74\x83\x40\x83\x43\x83\x8b\x96\xbc\x6c"
 410       "\x6f\x6e\x67\x2d\x66\x69\x6c\x65\x6e\x61\x6d\x65\x2d\x69\x6e"
 411       "\x2d\x8a\xbf\x8e\x9a.txt", archive_entry_symlink(ae));
 412   assertA((int)archive_entry_mtime(ae));
 413   assertEqualInt(0, archive_entry_size(ae));
 414   assertEqualInt(41453, archive_entry_mode(ae));
 415   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 416   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 417   assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));
 418
 419   /* Sixth header */
 420   assertA(0 == archive_read_next_header(a, &ae));
 421   assertEqualUTF8String(
 422     "abcdefghijklmnopqrs\x83\x65\x83\x58\x83\x67.txt",
 423     archive_entry_pathname(ae));
 424   assertA((int)archive_entry_mtime(ae));
 425   assertEqualInt(16, archive_entry_size(ae));
 426   assertEqualInt(33204, archive_entry_mode(ae));
 427   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 428   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 429   assertEqualIntA(a, 16, archive_read_data(a, buff, sizeof(buff)));
 430
 431   /* Test EOF */
 432   assertA(1 == archive_read_next_header(a, &ae));
 433   assertEqualInt(6, archive_file_count(a));
 434   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 435   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 436 }
 437
 438 DEFINE_TEST(test_read_format_rar_compress_normal)
 439 {
 440   const char reffile[] = "test_read_format_rar_compress_normal.rar";
 441   char file1_buff[20111];
 442   int file1_size = sizeof(file1_buff);
 443   const char file1_test_txt[] = "<P STYLE=\"margin-bottom: 0in\"><BR>\n"
 444                                 "</P>\n"
 445                                 "</BODY>\n"
 446                                 "</HTML>";
 447   char file2_buff[20];
 448   int file2_size = sizeof(file2_buff);
 449   const char file2_test_txt[] = "test text document\r\n";
 450   struct archive_entry *ae;
 451   struct archive *a;
 452
 453   extract_reference_file(reffile);
 454   assert((a = archive_read_new()) != NULL);
 455   assertA(0 == archive_read_support_filter_all(a));
 456   assertA(0 == archive_read_support_format_all(a));
 457   assertA(0 == archive_read_open_filename(a, reffile, 10240));
 458
 459   /* First header. */
 460   assertA(0 == archive_read_next_header(a, &ae));
 461   assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
 462   assertA((int)archive_entry_mtime(ae));
 463   assertA((int)archive_entry_ctime(ae));
 464   assertA((int)archive_entry_atime(ae));
 465   assertEqualInt(file1_size, archive_entry_size(ae));
 466   assertEqualInt(33188, archive_entry_mode(ae));
 467   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 468   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 469   assertA(file1_size == archive_read_data(a, file1_buff, file1_size));
 470   assertEqualMem(&file1_buff[file1_size - sizeof(file1_test_txt) + 1],
 471                  file1_test_txt, sizeof(file1_test_txt) - 1);
 472
 473     /* Second header. */
 474   assertA(0 == archive_read_next_header(a, &ae));
 475   assertEqualString("testlink", archive_entry_pathname(ae));
 476   assertA((int)archive_entry_mtime(ae));
 477   assertA((int)archive_entry_ctime(ae));
 478   assertA((int)archive_entry_atime(ae));
 479   assertEqualInt(0, archive_entry_size(ae));
 480   assertEqualInt(41471, archive_entry_mode(ae));
 481   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 482   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 483   assertEqualString("LibarchiveAddingTest.html", archive_entry_symlink(ae));
 484   assertEqualIntA(a, 0, archive_read_data(a, file1_buff, 30));
 485
 486   /* Third header. */
 487   assertA(0 == archive_read_next_header(a, &ae));
 488   assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
 489   assertA((int)archive_entry_mtime(ae));
 490   assertA((int)archive_entry_ctime(ae));
 491   assertA((int)archive_entry_atime(ae));
 492   assertEqualInt(file2_size, archive_entry_size(ae));
 493   assertEqualInt(33188, archive_entry_mode(ae));
 494   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 495   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 496   assertA(file2_size == archive_read_data(a, file2_buff, file2_size));
 497   assertEqualMem(&file2_buff[file2_size + 1 - sizeof(file2_test_txt)],
 498                  file2_test_txt, sizeof(file2_test_txt) - 1);
 499
 500   /* Fourth header. */
 501   assertA(0 == archive_read_next_header(a, &ae));
 502   assertEqualString("testdir/LibarchiveAddingTest.html",
 503                     archive_entry_pathname(ae));
 504   assertA((int)archive_entry_mtime(ae));
 505   assertA((int)archive_entry_ctime(ae));
 506   assertA((int)archive_entry_atime(ae));
 507   assertEqualInt(file1_size, archive_entry_size(ae));
 508   assertEqualInt(33188, archive_entry_mode(ae));
 509   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 510   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 511   assertA(file1_size == archive_read_data(a, file1_buff, file1_size));
 512   assertEqualMem(&file1_buff[file1_size - sizeof(file1_test_txt) + 1],
 513                  file1_test_txt, sizeof(file1_test_txt) - 1);
 514
 515   /* Fifth header. */
 516   assertA(0 == archive_read_next_header(a, &ae));
 517   assertEqualString("testdir", archive_entry_pathname(ae));
 518   assertA((int)archive_entry_mtime(ae));
 519   assertA((int)archive_entry_ctime(ae));
 520   assertA((int)archive_entry_atime(ae));
 521   assertEqualInt(0, archive_entry_size(ae));
 522   assertEqualInt(16877, archive_entry_mode(ae));
 523   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 524   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 525
 526   /* Sixth header. */
 527   assertA(0 == archive_read_next_header(a, &ae));
 528   assertEqualString("testemptydir", archive_entry_pathname(ae));
 529   assertA((int)archive_entry_mtime(ae));
 530   assertA((int)archive_entry_ctime(ae));
 531   assertA((int)archive_entry_atime(ae));
 532   assertEqualInt(0, archive_entry_size(ae));
 533   assertEqualInt(16877, archive_entry_mode(ae));
 534   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 535   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 536
 537   /* Test EOF */
 538   assertA(1 == archive_read_next_header(a, &ae));
 539   assertEqualInt(6, archive_file_count(a));
 540   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 541   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 542 }
 543
 544 /* This test is for sufficiently large files that would have been compressed
 545  * using multiple lzss blocks.
 546  */
 547 DEFINE_TEST(test_read_format_rar_multi_lzss_blocks)
 548 {
 549   const char reffile[] = "test_read_format_rar_multi_lzss_blocks.rar";
 550   const char test_txt[] = "-bottom: 0in\"><BR>\n</P>\n</BODY>\n</HTML>";
 551   int size = 20131111, offset = 0;
 552   char buff[64];
 553   struct archive_entry *ae;
 554   struct archive *a;
 555
 556   extract_reference_file(reffile);
 557   assert((a = archive_read_new()) != NULL);
 558   assertA(0 == archive_read_support_filter_all(a));
 559   assertA(0 == archive_read_support_format_all(a));
 560   assertA(0 == archive_read_open_filename(a, reffile, 10240));
 561
 562   /* First header. */
 563   assertA(0 == archive_read_next_header(a, &ae));
 564   assertEqualString("multi_lzss_blocks_test.txt", archive_entry_pathname(ae));
 565   assertA((int)archive_entry_mtime(ae));
 566   assertA((int)archive_entry_ctime(ae));
 567   assertA((int)archive_entry_atime(ae));
 568   assertEqualInt(size, archive_entry_size(ae));
 569   assertEqualInt(33188, archive_entry_mode(ae));
 570   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 571   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 572   while (offset + (int)sizeof(buff) < size)
 573   {
 574     assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
 575     offset += sizeof(buff);
 576   }
 577   assertA(size - offset == archive_read_data(a, buff, size - offset));
 578   assertEqualMem(buff, test_txt, size - offset);
 579
 580   /* Test EOF */
 581   assertA(1 == archive_read_next_header(a, &ae));
 582   assertEqualInt(1, archive_file_count(a));
 583   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 584   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 585 }
 586
 587 DEFINE_TEST(test_read_format_rar_compress_best)
 588 {
 589   const char reffile[] = "test_read_format_rar_compress_best.rar";
 590   char file1_buff[20111];
 591   int file1_size = sizeof(file1_buff);
 592   const char file1_test_txt[] = "<P STYLE=\"margin-bottom: 0in\"><BR>\n"
 593                                 "</P>\n"
 594                                 "</BODY>\n"
 595                                 "</HTML>";
 596   char file2_buff[20];
 597   int file2_size = sizeof(file2_buff);
 598   const char file2_test_txt[] = "test text document\r\n";
 599   struct archive_entry *ae;
 600   struct archive *a;
 601
 602   extract_reference_file(reffile);
 603   assert((a = archive_read_new()) != NULL);
 604   assertA(0 == archive_read_support_filter_all(a));
 605   assertA(0 == archive_read_support_format_all(a));
 606   assertA(0 == archive_read_open_filename(a, reffile, 10240));
 607
 608   /* First header. */
 609   assertA(0 == archive_read_next_header(a, &ae));
 610   assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
 611   assertA((int)archive_entry_mtime(ae));
 612   assertA((int)archive_entry_ctime(ae));
 613   assertA((int)archive_entry_atime(ae));
 614   assertEqualInt(file1_size, archive_entry_size(ae));
 615   assertEqualInt(33188, archive_entry_mode(ae));
 616   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 617   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 618   assertA(file1_size == archive_read_data(a, file1_buff, file1_size));
 619   assertEqualMem(&file1_buff[file1_size - sizeof(file1_test_txt) + 1],
 620                  file1_test_txt, sizeof(file1_test_txt) - 1);
 621
 622     /* Second header. */
 623   assertA(0 == archive_read_next_header(a, &ae));
 624   assertEqualString("testlink", archive_entry_pathname(ae));
 625   assertA((int)archive_entry_mtime(ae));
 626   assertA((int)archive_entry_ctime(ae));
 627   assertA((int)archive_entry_atime(ae));
 628   assertEqualInt(0, archive_entry_size(ae));
 629   assertEqualInt(41471, archive_entry_mode(ae));
 630   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 631   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 632   assertEqualString("LibarchiveAddingTest.html", archive_entry_symlink(ae));
 633   assertEqualIntA(a, 0, archive_read_data(a, file1_buff, 30));
 634
 635   /* Third header. */
 636   assertA(0 == archive_read_next_header(a, &ae));
 637   assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
 638   assertA((int)archive_entry_mtime(ae));
 639   assertA((int)archive_entry_ctime(ae));
 640   assertA((int)archive_entry_atime(ae));
 641   assertEqualInt(file2_size, archive_entry_size(ae));
 642   assertEqualInt(33188, archive_entry_mode(ae));
 643   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 644   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 645   assertA(file2_size == archive_read_data(a, file2_buff, file2_size));
 646   assertEqualMem(&file2_buff[file2_size + 1 - sizeof(file2_test_txt)],
 647                  file2_test_txt, sizeof(file2_test_txt) - 1);
 648
 649   /* Fourth header. */
 650   assertA(0 == archive_read_next_header(a, &ae));
 651   assertEqualString("testdir/LibarchiveAddingTest.html",
 652                     archive_entry_pathname(ae));
 653   assertA((int)archive_entry_mtime(ae));
 654   assertA((int)archive_entry_ctime(ae));
 655   assertA((int)archive_entry_atime(ae));
 656   assertEqualInt(file1_size, archive_entry_size(ae));
 657   assertEqualInt(33188, archive_entry_mode(ae));
 658   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 659   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 660   assertA(file1_size == archive_read_data(a, file1_buff, file1_size));
 661   assertEqualMem(&file1_buff[file1_size - sizeof(file1_test_txt) + 1],
 662                  file1_test_txt, sizeof(file1_test_txt) - 1);
 663
 664   /* Fifth header. */
 665   assertA(0 == archive_read_next_header(a, &ae));
 666   assertEqualString("testdir", archive_entry_pathname(ae));
 667   assertA((int)archive_entry_mtime(ae));
 668   assertA((int)archive_entry_ctime(ae));
 669   assertA((int)archive_entry_atime(ae));
 670   assertEqualInt(0, archive_entry_size(ae));
 671   assertEqualInt(16877, archive_entry_mode(ae));
 672   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 673   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 674
 675   /* Sixth header. */
 676   assertA(0 == archive_read_next_header(a, &ae));
 677   assertEqualString("testemptydir", archive_entry_pathname(ae));
 678   assertA((int)archive_entry_mtime(ae));
 679   assertA((int)archive_entry_ctime(ae));
 680   assertA((int)archive_entry_atime(ae));
 681   assertEqualInt(0, archive_entry_size(ae));
 682   assertEqualInt(16877, archive_entry_mode(ae));
 683   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 684   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 685
 686   /* Test EOF */
 687   assertA(1 == archive_read_next_header(a, &ae));
 688   assertEqualInt(6, archive_file_count(a));
 689   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 690   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 691 }
 692
 693 /* This is a test for RAR files compressed using a technique where compression
 694  * switches back and forth to and from ppmd and lzss decoding.
 695  */
 696 DEFINE_TEST(test_read_format_rar_ppmd_lzss_conversion)
 697 {
 698   const char reffile[] = "test_read_format_rar_ppmd_lzss_conversion.rar";
 699   const char test_txt[] = "gin-bottom: 0in\"><BR>\n</P>\n</BODY>\n</HTML>";
 700   int size = 241647978, offset = 0;
 701   char buff[64];
 702   struct archive_entry *ae;
 703   struct archive *a;
 704
 705   extract_reference_file(reffile);
 706   assert((a = archive_read_new()) != NULL);
 707   assertA(0 == archive_read_support_filter_all(a));
 708   assertA(0 == archive_read_support_format_all(a));
 709   assertA(0 == archive_read_open_filename(a, reffile, 10240));
 710
 711   /* First header. */
 712   assertA(0 == archive_read_next_header(a, &ae));
 713   assertEqualString("ppmd_lzss_conversion_test.txt",
 714                     archive_entry_pathname(ae));
 715   assertA((int)archive_entry_mtime(ae));
 716   assertA((int)archive_entry_ctime(ae));
 717   assertA((int)archive_entry_atime(ae));
 718   assertEqualInt(size, archive_entry_size(ae));
 719   assertEqualInt(33188, archive_entry_mode(ae));
 720   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 721   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 722   while (offset + (int)sizeof(buff) < size)
 723   {
 724     assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
 725     offset += sizeof(buff);
 726   }
 727   assertA(size - offset == archive_read_data(a, buff, size - offset));
 728   assertEqualMem(buff, test_txt, size - offset);
 729
 730   /* Test EOF */
 731   assertA(1 == archive_read_next_header(a, &ae));
 732   assertEqualInt(1, archive_file_count(a));
 733   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 734   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 735 }
 736
 737 DEFINE_TEST(test_read_format_rar_binary)
 738 {
 739   const char reffile[] = "test_read_format_rar_binary_data.rar";
 740   char *file1_buff = malloc(1048576);
 741   int file1_size = 1048576;
 742   const char file1_test_txt[] = "\x37\xef\xb2\xbe\x33\xf6\xcc\xcb\xee\x2a\x10"
 743                                 "\x9d\x2e\x01\xe9\xf6\xf9\xe5\xe6\x67\x0c\x2b"
 744                                 "\xd8\x6b\xa0\x26\x9a\xf7\x93\x87\x42\xf1\x08"
 745                                 "\x42\xdc\x9b\x76\x91\x20\xa4\x01\xbe\x67\xbd"
 746                                 "\x08\x74\xde\xec";
 747   char file2_buff[32618];
 748   int file2_size = sizeof(file2_buff);
 749   const char file2_test_txt[] = "\x00\xee\x78\x00\x00\x4d\x45\x54\x41\x2d\x49"
 750                                 "\x4e\x46\x2f\x6d\x61\x6e\x69\x66\x65\x73\x74"
 751                                 "\x2e\x78\x6d\x6c\x50\x4b\x05\x06\x00\x00\x00"
 752                                 "\x00\x12\x00\x12\x00\xaa\x04\x00\x00\xaa\x7a"
 753                                 "\x00\x00\x00\x00";
 754   struct archive_entry *ae;
 755   struct archive *a;
 756
 757   extract_reference_file(reffile);
 758   assert((a = archive_read_new()) != NULL);
 759   assertA(0 == archive_read_support_filter_all(a));
 760   assertA(0 == archive_read_support_format_all(a));
 761   assertA(0 == archive_read_open_filename(a, reffile, 10240));
 762
 763   /* First header. */
 764   assertA(0 == archive_read_next_header(a, &ae));
 765   assertEqualString("random_data.bin", archive_entry_pathname(ae));
 766   assertA((int)archive_entry_mtime(ae));
 767   assertA((int)archive_entry_ctime(ae));
 768   assertA((int)archive_entry_atime(ae));
 769   assertEqualInt(file1_size, archive_entry_size(ae));
 770   assertEqualInt(33188, archive_entry_mode(ae));
 771   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 772   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 773   assertA(file1_size == archive_read_data(a, file1_buff, file1_size));
 774   assertEqualMem(&file1_buff[file1_size - sizeof(file1_test_txt) + 1],
 775                  file1_test_txt, sizeof(file1_test_txt) - 1);
 776
 777     /* Second header. */
 778   assertA(0 == archive_read_next_header(a, &ae));
 779   assertEqualString("LibarchiveAddingTest.odt", archive_entry_pathname(ae));
 780   assertA((int)archive_entry_mtime(ae));
 781   assertA((int)archive_entry_ctime(ae));
 782   assertA((int)archive_entry_atime(ae));
 783   assertEqualInt(file2_size, archive_entry_size(ae));
 784   assertEqualInt(33188, archive_entry_mode(ae));
 785   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 786   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 787   assertA(file2_size == archive_read_data(a, file2_buff, file2_size));
 788   assertEqualMem(&file2_buff[file2_size + 1 - sizeof(file2_test_txt)],
 789                  file2_test_txt, sizeof(file2_test_txt) - 1);
 790
 791   /* Test EOF */
 792   assertA(1 == archive_read_next_header(a, &ae));
 793   assertEqualInt(2, archive_file_count(a));
 794   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 795   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 796
 797   free(file1_buff);
 798 }
 799
 800 DEFINE_TEST(test_read_format_rar_windows)
 801 {
 802   char buff[441];
 803   const char reffile[] = "test_read_format_rar_windows.rar";
 804   const char test_txt[] = "test text file\r\n";
 805   int size = sizeof(test_txt)-1;
 806   struct archive_entry *ae;
 807   struct archive *a;
 808
 809   extract_reference_file(reffile);
 810   assert((a = archive_read_new()) != NULL);
 811   assertA(0 == archive_read_support_filter_all(a));
 812   assertA(0 == archive_read_support_format_all(a));
 813   assertA(0 == archive_read_open_filename(a, reffile, 10240));
 814
 815   /* First header. */
 816   assertA(0 == archive_read_next_header(a, &ae));
 817   assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
 818   assertA((int)archive_entry_mtime(ae));
 819   assertA((int)archive_entry_ctime(ae));
 820   assertA((int)archive_entry_atime(ae));
 821   assertEqualInt(16, archive_entry_size(ae));
 822   assertEqualInt(33188, archive_entry_mode(ae));
 823   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 824   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 825   assertA(size == archive_read_data(a, buff, size));
 826   assertEqualMem(buff, test_txt, size);
 827
 828   /* Second header. */
 829   assertA(0 == archive_read_next_header(a, &ae));
 830   assertEqualString("test.txt", archive_entry_pathname(ae));
 831   assertA((int)archive_entry_mtime(ae));
 832   assertA((int)archive_entry_ctime(ae));
 833   assertA((int)archive_entry_atime(ae));
 834   assertEqualInt(16, archive_entry_size(ae));
 835   assertEqualInt(33188, archive_entry_mode(ae));
 836   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 837   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 838   assertA(size == archive_read_data(a, buff, size));
 839   assertEqualMem(buff, test_txt, size);
 840
 841   /* Third header. */
 842   assertA(0 == archive_read_next_header(a, &ae));
 843   assertEqualString("testshortcut.lnk", archive_entry_pathname(ae));
 844   assertA((int)archive_entry_mtime(ae));
 845   assertA((int)archive_entry_ctime(ae));
 846   assertA((int)archive_entry_atime(ae));
 847   assertEqualInt(sizeof(buff), archive_entry_size(ae));
 848   assertEqualInt(33188, archive_entry_mode(ae));
 849   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 850   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 851   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
 852
 853   /* Fourth header. */
 854   assertA(0 == archive_read_next_header(a, &ae));
 855   assertEqualString("testdir", archive_entry_pathname(ae));
 856   assertA((int)archive_entry_mtime(ae));
 857   assertA((int)archive_entry_ctime(ae));
 858   assertA((int)archive_entry_atime(ae));
 859   assertEqualInt(0, archive_entry_size(ae));
 860   assertEqualInt(16877, archive_entry_mode(ae));
 861   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 862   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 863
 864   /* Fifth header. */
 865   assertA(0 == archive_read_next_header(a, &ae));
 866   assertEqualString("testemptydir", archive_entry_pathname(ae));
 867   assertA((int)archive_entry_mtime(ae));
 868   assertA((int)archive_entry_ctime(ae));
 869   assertA((int)archive_entry_atime(ae));
 870   assertEqualInt(0, archive_entry_size(ae));
 871   assertEqualInt(16877, archive_entry_mode(ae));
 872   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 873   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 874
 875   /* Test EOF */
 876   assertA(1 == archive_read_next_header(a, &ae));
 877   assertEqualInt(5, archive_file_count(a));
 878   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
 879   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 880 }
 881
 882 DEFINE_TEST(test_read_format_rar_multivolume)
 883 {
 884   const char *reffiles[] =
 885   {
 886     "test_read_format_rar_multivolume.part0001.rar",
 887     "test_read_format_rar_multivolume.part0002.rar",
 888     "test_read_format_rar_multivolume.part0003.rar",
 889     "test_read_format_rar_multivolume.part0004.rar",
 890     NULL
 891   };
 892   int file1_size = 241647978, offset = 0;
 893   char buff[64];
 894   const char file1_test_txt[] = "gin-bottom: 0in\"><BR>\n</P>\n</BODY>\n"
 895                                 "</HTML>";
 896   char file2_buff[20111];
 897   int file2_size = sizeof(file2_buff);
 898   const char file2_test_txt[] = "<P STYLE=\"margin-bottom: 0in\"><BR>\n"
 899                                 "</P>\n"
 900                                 "</BODY>\n"
 901                                 "</HTML>";
 902   char file3_buff[20];
 903   int file3_size = sizeof(file3_buff);
 904   const char file3_test_txt[] = "test text document\r\n";
 905   struct archive_entry *ae;
 906   struct archive *a;
 907
 908   extract_reference_files(reffiles);
 909   assert((a = archive_read_new()) != NULL);
 910   assertA(0 == archive_read_support_filter_all(a));
 911   assertA(0 == archive_read_support_format_all(a));
 912   assertA(0 == archive_read_open_filenames(a, reffiles, 10240));
 913
 914   /* First header. */
 915   assertA(0 == archive_read_next_header(a, &ae));
 916   assertEqualString("ppmd_lzss_conversion_test.txt",
 917                     archive_entry_pathname(ae));
 918   assertA((int)archive_entry_mtime(ae));
 919   assertA((int)archive_entry_ctime(ae));
 920   assertA((int)archive_entry_atime(ae));
 921   assertEqualInt(file1_size, archive_entry_size(ae));
 922   assertEqualInt(33188, archive_entry_mode(ae));
 923   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 924   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 925   while (offset + (int)sizeof(buff) < file1_size)
 926   {
 927     assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
 928     offset += sizeof(buff);
 929   }
 930   assertA(file1_size - offset ==
 931     archive_read_data(a, buff, file1_size - offset));
 932   assertEqualMem(buff, file1_test_txt, file1_size - offset);
 933
 934   /* Second header. */
 935   assertA(0 == archive_read_next_header(a, &ae));
 936   assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
 937   assertA((int)archive_entry_mtime(ae));
 938   assertA((int)archive_entry_ctime(ae));
 939   assertA((int)archive_entry_atime(ae));
 940   assertEqualInt(file2_size, archive_entry_size(ae));
 941   assertEqualInt(33188, archive_entry_mode(ae));
 942   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 943   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 944   assertA(file2_size == archive_read_data(a, file2_buff, file2_size));
 945   assertEqualMem(&file2_buff[file2_size - sizeof(file2_test_txt) + 1],
 946                  file2_test_txt, sizeof(file2_test_txt) - 1);
 947
 948   /* Third header. */
 949   assertA(0 == archive_read_next_header(a, &ae));
 950   assertEqualString("testlink", archive_entry_pathname(ae));
 951   assertA((int)archive_entry_mtime(ae));
 952   assertA((int)archive_entry_ctime(ae));
 953   assertA((int)archive_entry_atime(ae));
 954   assertEqualInt(0, archive_entry_size(ae));
 955   assertEqualInt(41471, archive_entry_mode(ae));
 956   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 957   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 958   assertEqualString("LibarchiveAddingTest.html", archive_entry_symlink(ae));
 959   assertEqualIntA(a, 0, archive_read_data(a, file2_buff, 30));
 960
 961   /* Fourth header. */
 962   assertA(0 == archive_read_next_header(a, &ae));
 963   assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
 964   assertA((int)archive_entry_mtime(ae));
 965   assertA((int)archive_entry_ctime(ae));
 966   assertA((int)archive_entry_atime(ae));
 967   assertEqualInt(file3_size, archive_entry_size(ae));
 968   assertEqualInt(33188, archive_entry_mode(ae));
 969   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 970   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 971   assertA(file3_size == archive_read_data(a, file3_buff, file3_size));
 972   assertEqualMem(&file3_buff[file3_size + 1 - sizeof(file3_test_txt)],
 973                  file3_test_txt, sizeof(file3_test_txt) - 1);
 974
 975   /* Fifth header. */
 976   assertA(0 == archive_read_next_header(a, &ae));
 977   assertEqualString("testdir/LibarchiveAddingTest.html",
 978                     archive_entry_pathname(ae));
 979   assertA((int)archive_entry_mtime(ae));
 980   assertA((int)archive_entry_ctime(ae));
 981   assertA((int)archive_entry_atime(ae));
 982   assertEqualInt(file2_size, archive_entry_size(ae));
 983   assertEqualInt(33188, archive_entry_mode(ae));
 984   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 985   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
 986   assertA(file2_size == archive_read_data(a, file2_buff, file2_size));
 987   assertEqualMem(&file2_buff[file2_size - sizeof(file2_test_txt) + 1],
 988                  file2_test_txt, sizeof(file2_test_txt) - 1);
 989
 990   /* Sixth header. */
 991   assertA(0 == archive_read_next_header(a, &ae));
 992   assertEqualString("testdir", archive_entry_pathname(ae));
 993   assertA((int)archive_entry_mtime(ae));
 994   assertA((int)archive_entry_ctime(ae));
 995   assertA((int)archive_entry_atime(ae));
 996   assertEqualInt(0, archive_entry_size(ae));
 997   assertEqualInt(16877, archive_entry_mode(ae));
 998   assertEqualInt(archive_entry_is_encrypted(ae), 0);
 999   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1000
1001   /* Seventh header. */
1002   assertA(0 == archive_read_next_header(a, &ae));
1003   assertEqualString("testemptydir", archive_entry_pathname(ae));
1004   assertA((int)archive_entry_mtime(ae));
1005   assertA((int)archive_entry_ctime(ae));
1006   assertA((int)archive_entry_atime(ae));
1007   assertEqualInt(0, archive_entry_size(ae));
1008   assertEqualInt(16877, archive_entry_mode(ae));
1009   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1010   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1011
1012   /* Test EOF */
1013   assertA(1 == archive_read_next_header(a, &ae));
1014   assertEqualInt(7, archive_file_count(a));
1015   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1016   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1017 }
1018
1019 DEFINE_TEST(test_read_format_rar_multivolume_skip)
1020 {
1021   const char *reffiles[] =
1022   {
1023     "test_read_format_rar_multivolume.part0001.rar",
1024     "test_read_format_rar_multivolume.part0002.rar",
1025     "test_read_format_rar_multivolume.part0003.rar",
1026     "test_read_format_rar_multivolume.part0004.rar",
1027     NULL
1028   };
1029   int file1_size = 241647978;
1030   int file2_size = 20111;
1031   int file3_size = 20;
1032   struct archive_entry *ae;
1033   struct archive *a;
1034
1035   extract_reference_files(reffiles);
1036   assert((a = archive_read_new()) != NULL);
1037   assertA(0 == archive_read_support_filter_all(a));
1038   assertA(0 == archive_read_support_format_all(a));
1039   assertA(0 == archive_read_open_filenames(a, reffiles, 10240));
1040
1041   /* First header. */
1042   assertA(0 == archive_read_next_header(a, &ae));
1043   assertEqualString("ppmd_lzss_conversion_test.txt",
1044                     archive_entry_pathname(ae));
1045   assertA((int)archive_entry_mtime(ae));
1046   assertA((int)archive_entry_ctime(ae));
1047   assertA((int)archive_entry_atime(ae));
1048   assertEqualInt(file1_size, archive_entry_size(ae));
1049   assertEqualInt(33188, archive_entry_mode(ae));
1050   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1051   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1052
1053   /* Second header. */
1054   assertA(0 == archive_read_next_header(a, &ae));
1055   assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
1056   assertA((int)archive_entry_mtime(ae));
1057   assertA((int)archive_entry_ctime(ae));
1058   assertA((int)archive_entry_atime(ae));
1059   assertEqualInt(file2_size, archive_entry_size(ae));
1060   assertEqualInt(33188, archive_entry_mode(ae));
1061   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1062   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1063
1064   /* Third header. */
1065   assertA(0 == archive_read_next_header(a, &ae));
1066   assertEqualString("testlink", archive_entry_pathname(ae));
1067   assertA((int)archive_entry_mtime(ae));
1068   assertA((int)archive_entry_ctime(ae));
1069   assertA((int)archive_entry_atime(ae));
1070   assertEqualInt(0, archive_entry_size(ae));
1071   assertEqualInt(41471, archive_entry_mode(ae));
1072   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1073   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1074   assertEqualString("LibarchiveAddingTest.html", archive_entry_symlink(ae));
1075
1076   /* Fourth header. */
1077   assertA(0 == archive_read_next_header(a, &ae));
1078   assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
1079   assertA((int)archive_entry_mtime(ae));
1080   assertA((int)archive_entry_ctime(ae));
1081   assertA((int)archive_entry_atime(ae));
1082   assertEqualInt(file3_size, archive_entry_size(ae));
1083   assertEqualInt(33188, archive_entry_mode(ae));
1084   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1085   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1086
1087   /* Fifth header. */
1088   assertA(0 == archive_read_next_header(a, &ae));
1089   assertEqualString("testdir/LibarchiveAddingTest.html",
1090                     archive_entry_pathname(ae));
1091   assertA((int)archive_entry_mtime(ae));
1092   assertA((int)archive_entry_ctime(ae));
1093   assertA((int)archive_entry_atime(ae));
1094   assertEqualInt(file2_size, archive_entry_size(ae));
1095   assertEqualInt(33188, archive_entry_mode(ae));
1096   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1097   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1098
1099   /* Sixth header. */
1100   assertA(0 == archive_read_next_header(a, &ae));
1101   assertEqualString("testdir", archive_entry_pathname(ae));
1102   assertA((int)archive_entry_mtime(ae));
1103   assertA((int)archive_entry_ctime(ae));
1104   assertA((int)archive_entry_atime(ae));
1105   assertEqualInt(0, archive_entry_size(ae));
1106   assertEqualInt(16877, archive_entry_mode(ae));
1107   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1108   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1109
1110   /* Seventh header. */
1111   assertA(0 == archive_read_next_header(a, &ae));
1112   assertEqualString("testemptydir", archive_entry_pathname(ae));
1113   assertA((int)archive_entry_mtime(ae));
1114   assertA((int)archive_entry_ctime(ae));
1115   assertA((int)archive_entry_atime(ae));
1116   assertEqualInt(0, archive_entry_size(ae));
1117   assertEqualInt(16877, archive_entry_mode(ae));
1118   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1119   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1120
1121   /* Test EOF */
1122   assertA(1 == archive_read_next_header(a, &ae));
1123   assertEqualInt(7, archive_file_count(a));
1124   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1125   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1126 }
1127
1128 DEFINE_TEST(test_read_format_rar_sfx)
1129 {
1130   char buff[441];
1131   const char reffile[] = "test_read_format_rar_sfx.exe";
1132   const char test_txt[] = "test text file\r\n";
1133   int size = sizeof(test_txt)-1;
1134   struct archive_entry *ae;
1135   struct archive *a;
1136
1137   extract_reference_file(reffile);
1138   assert((a = archive_read_new()) != NULL);
1139   assertA(0 == archive_read_support_filter_all(a));
1140   assertA(0 == archive_read_support_format_all(a));
1141   assertA(0 == archive_read_open_filename(a, reffile, 10240));
1142
1143   /* First header. */
1144   assertA(0 == archive_read_next_header(a, &ae));
1145   assertEqualString("test.txt", archive_entry_pathname(ae));
1146   assertA((int)archive_entry_mtime(ae));
1147   assertA((int)archive_entry_ctime(ae));
1148   assertA((int)archive_entry_atime(ae));
1149   assertEqualInt(16, archive_entry_size(ae));
1150   assertEqualInt(33188, archive_entry_mode(ae));
1151   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1152   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1153   assertA(size == archive_read_data(a, buff, size));
1154   assertEqualMem(buff, test_txt, size);
1155
1156   /* Second header. */
1157   assertA(0 == archive_read_next_header(a, &ae));
1158   assertEqualString("testshortcut.lnk", archive_entry_pathname(ae));
1159   assertA((int)archive_entry_mtime(ae));
1160   assertA((int)archive_entry_ctime(ae));
1161   assertA((int)archive_entry_atime(ae));
1162   assertEqualInt(sizeof(buff), archive_entry_size(ae));
1163   assertEqualInt(33188, archive_entry_mode(ae));
1164   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1165   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1166   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1167
1168   /* Third header. */
1169   assertA(0 == archive_read_next_header(a, &ae));
1170   assertEqualString("testdir/test.txt", archive_entry_pathname(ae));
1171   assertA((int)archive_entry_mtime(ae));
1172   assertA((int)archive_entry_ctime(ae));
1173   assertA((int)archive_entry_atime(ae));
1174   assertEqualInt(16, archive_entry_size(ae));
1175   assertEqualInt(33188, archive_entry_mode(ae));
1176   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1177   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1178   assertA(size == archive_read_data(a, buff, size));
1179   assertEqualMem(buff, test_txt, size);
1180
1181   /* Fourth header. */
1182   assertA(0 == archive_read_next_header(a, &ae));
1183   assertEqualString("testdir", archive_entry_pathname(ae));
1184   assertA((int)archive_entry_mtime(ae));
1185   assertA((int)archive_entry_ctime(ae));
1186   assertA((int)archive_entry_atime(ae));
1187   assertEqualInt(0, archive_entry_size(ae));
1188   assertEqualInt(16877, archive_entry_mode(ae));
1189   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1190   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1191
1192   /* Fifth header. */
1193   assertA(0 == archive_read_next_header(a, &ae));
1194   assertEqualString("testemptydir", archive_entry_pathname(ae));
1195   assertA((int)archive_entry_mtime(ae));
1196   assertA((int)archive_entry_ctime(ae));
1197   assertA((int)archive_entry_atime(ae));
1198   assertEqualInt(0, archive_entry_size(ae));
1199   assertEqualInt(16877, archive_entry_mode(ae));
1200   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1201   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1202
1203   /* Test EOF */
1204   assertA(1 == archive_read_next_header(a, &ae));
1205   assertEqualInt(5, archive_file_count(a));
1206   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1207   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1208 }
1209
1210 DEFINE_TEST(test_read_format_rar_multivolume_stored_file)
1211 {
1212   const char *reffiles[] =
1213   {
1214     "test_rar_multivolume_single_file.part1.rar",
1215     "test_rar_multivolume_single_file.part2.rar",
1216     "test_rar_multivolume_single_file.part3.rar",
1217     NULL
1218   };
1219   char file_buff[20111];
1220   int file_size = sizeof(file_buff);
1221   const char file_test_txt[] = "<P STYLE=\"margin-bottom: 0in\"><BR>\n"
1222                                 "</P>\n"
1223                                 "</BODY>\n"
1224                                 "</HTML>";
1225   struct archive_entry *ae;
1226   struct archive *a;
1227
1228   extract_reference_files(reffiles);
1229   assert((a = archive_read_new()) != NULL);
1230   assertA(0 == archive_read_support_filter_all(a));
1231   assertA(0 == archive_read_support_format_all(a));
1232   assertA(0 == archive_read_open_filenames(a, reffiles, 10240));
1233
1234   /* First header. */
1235   assertA(0 == archive_read_next_header(a, &ae));
1236   assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
1237   assertA((int)archive_entry_mtime(ae));
1238   assertA((int)archive_entry_ctime(ae));
1239   assertA((int)archive_entry_atime(ae));
1240   assertEqualInt(file_size, archive_entry_size(ae));
1241   assertEqualInt(33188, archive_entry_mode(ae));
1242   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1243   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1244   assertA(file_size == archive_read_data(a, file_buff, file_size));
1245   assertEqualMem(&file_buff[file_size - sizeof(file_test_txt) + 1],
1246                  file_test_txt, sizeof(file_test_txt) - 1);
1247
1248   /* Test EOF */
1249   assertA(1 == archive_read_next_header(a, &ae));
1250   assertEqualInt(1, archive_file_count(a));
1251   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1252   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1253 }
1254
1255 DEFINE_TEST(test_read_format_rar_multivolume_stored_file_skip)
1256 {
1257   const char *reffiles[] =
1258   {
1259     "test_rar_multivolume_single_file.part1.rar",
1260     "test_rar_multivolume_single_file.part2.rar",
1261     "test_rar_multivolume_single_file.part3.rar",
1262     NULL
1263   };
1264   int file_size = 20111;
1265   struct archive_entry *ae;
1266   struct archive *a;
1267
1268   extract_reference_files(reffiles);
1269   assert((a = archive_read_new()) != NULL);
1270   assertA(0 == archive_read_support_filter_all(a));
1271   assertA(0 == archive_read_support_format_all(a));
1272   assertA(0 == archive_read_open_filenames(a, reffiles, 10240));
1273
1274   /* First header. */
1275   assertA(0 == archive_read_next_header(a, &ae));
1276   assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
1277   assertA((int)archive_entry_mtime(ae));
1278   assertA((int)archive_entry_ctime(ae));
1279   assertA((int)archive_entry_atime(ae));
1280   assertEqualInt(file_size, archive_entry_size(ae));
1281   assertEqualInt(33188, archive_entry_mode(ae));
1282   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1283   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1284
1285   /* Test EOF */
1286   assertA(1 == archive_read_next_header(a, &ae));
1287   assertEqualInt(1, archive_file_count(a));
1288   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1289   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1290 }
1291
1292 DEFINE_TEST(test_read_format_rar_multivolume_seek_data)
1293 {
1294   const char *reffiles[] =
1295   {
1296     "test_rar_multivolume_single_file.part1.rar",
1297     "test_rar_multivolume_single_file.part2.rar",
1298     "test_rar_multivolume_single_file.part3.rar",
1299     NULL
1300   };
1301   char buff[64];
1302   int file_size = 20111;
1303   const char file_test_txt1[] = "d. \n</P>\n<P STYLE=\"margin-bottom: 0in\">"
1304                                 "<BR>\n</P>\n</BODY>\n</HTML>";
1305   const char file_test_txt2[] = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4."
1306                                 "0 Transitional//EN\">\n<";
1307   const char file_test_txt3[] = "mplify writing such tests,\ntry to use plat"
1308                                 "form-independent codin";
1309   const char file_test_txt4[] = "lString</TT> in the example above)\ngenerat"
1310                                 "e detailed log message";
1311   const char file_test_txt5[] = "SS=\"western\">make check</TT> will usually"
1312                                 " run\n\tall of the tests.";
1313   struct archive_entry *ae;
1314   struct archive *a;
1315
1316   extract_reference_files(reffiles);
1317   assert((a = archive_read_new()) != NULL);
1318   assertA(0 == archive_read_support_filter_all(a));
1319   assertA(0 == archive_read_support_format_all(a));
1320   assertA(0 == archive_read_open_filenames(a, reffiles, 10240));
1321
1322   /* First header. */
1323   assertA(0 == archive_read_next_header(a, &ae));
1324   assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
1325   assertA((int)archive_entry_mtime(ae));
1326   assertA((int)archive_entry_ctime(ae));
1327   assertA((int)archive_entry_atime(ae));
1328   assertEqualInt(file_size, archive_entry_size(ae));
1329   assertEqualInt(33188, archive_entry_mode(ae));
1330   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1331   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1332
1333   /* Seek to the end minus 64 bytes */
1334   assertA(file_size - (int)sizeof(buff) ==
1335     archive_seek_data(a, file_size - (int)sizeof(buff), SEEK_SET));
1336   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1337   assertEqualMem(buff, file_test_txt1, sizeof(file_test_txt1) - 1);
1338
1339   /* Seek back to the beginning */
1340   assertA(0 == archive_seek_data(a, 0, SEEK_SET));
1341   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1342   assertEqualMem(buff, file_test_txt2, sizeof(file_test_txt2) - 1);
1343
1344   /* Seek to the middle of the combined data block */
1345   assertA(10054 == archive_seek_data(a, 10054, SEEK_SET));
1346   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1347   assertEqualMem(buff, file_test_txt3, sizeof(file_test_txt3) - 1);
1348
1349   /* Seek to 32 bytes before the end of the first data sub-block */
1350   assertA(6860 == archive_seek_data(a, 6860, SEEK_SET));
1351   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1352   assertEqualMem(buff, file_test_txt4, sizeof(file_test_txt4) - 1);
1353
1354   /* Seek to 32 bytes before the end of the second data sub-block */
1355   assertA(13752 == archive_seek_data(a, 13752, SEEK_SET));
1356   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1357   assertEqualMem(buff, file_test_txt5, sizeof(file_test_txt5) - 1);
1358
1359   /* Use various combinations of SEEK_SET, SEEK_CUR, and SEEK_END */
1360   assertEqualInt(file_size, archive_seek_data(a, 0, SEEK_END));
1361   assertEqualInt(0, archive_seek_data(a, 0, SEEK_SET));
1362   assertEqualInt(0, archive_seek_data(a, 0, SEEK_CUR));
1363   assertEqualInt(-1, archive_seek_data(a, -10, SEEK_CUR));
1364   assertEqualInt(10, archive_seek_data(a, 10, SEEK_CUR));
1365   assertEqualInt(-1, archive_seek_data(a, -20, SEEK_CUR));
1366   assertEqualInt(10, archive_seek_data(a, 0, SEEK_CUR));
1367   assertEqualInt(file_size, archive_seek_data(a, 0, SEEK_END));
1368   assertEqualInt(file_size - 20, archive_seek_data(a, -20, SEEK_END));
1369   assertEqualInt(file_size + 40, archive_seek_data(a, 40, SEEK_END));
1370   assertEqualInt(file_size + 40, archive_seek_data(a, 0, SEEK_CUR));
1371   assertEqualInt(file_size + 40 + 20, archive_seek_data(a, 20, SEEK_CUR));
1372   assertEqualInt(file_size + 40 + 20 + 20, archive_seek_data(a, 20, SEEK_CUR));
1373   assertEqualInt(file_size + 20, archive_seek_data(a, 20, SEEK_END));
1374   assertEqualInt(file_size - 20, archive_seek_data(a, -20, SEEK_END));
1375
1376   /*
1377    * Attempt to read from the end of the file. These should return
1378    * 0 for end of file.
1379    */
1380   assertEqualInt(file_size, archive_seek_data(a, 0, SEEK_END));
1381   assertA(0 == archive_read_data(a, buff, sizeof(buff)));
1382   assertEqualInt(file_size + 40, archive_seek_data(a, 40, SEEK_CUR));
1383   assertA(0 == archive_read_data(a, buff, sizeof(buff)));
1384
1385   /* Seek to the end minus 64 bytes */
1386   assertA(0 == archive_seek_data(a, 0, SEEK_SET));
1387   assertA(file_size - (int)sizeof(buff) ==
1388     archive_seek_data(a, -(int)sizeof(buff), SEEK_END));
1389   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1390   assertEqualMem(buff, file_test_txt1, sizeof(file_test_txt1) - 1);
1391
1392   /* The file position should be at the end of the file here */
1393   assertA(file_size == archive_seek_data(a, 0, SEEK_CUR));
1394
1395   /* Seek back to the beginning */
1396   assertA(0 == archive_seek_data(a, -file_size, SEEK_CUR));
1397   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1398   assertEqualMem(buff, file_test_txt2, sizeof(file_test_txt2) - 1);
1399
1400   /* Seek to the middle of the combined data block */
1401   assertA(10054 == archive_seek_data(a, 10054 - (int)sizeof(buff), SEEK_CUR));
1402   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1403   assertEqualMem(buff, file_test_txt3, sizeof(file_test_txt3) - 1);
1404
1405   /* Seek to 32 bytes before the end of the first data sub-block */
1406   assertA(6860 == archive_seek_data(a, 6860 - (10054 + (int)sizeof(buff)),
1407                                     SEEK_CUR));
1408   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1409   assertEqualMem(buff, file_test_txt4, sizeof(file_test_txt4) - 1);
1410
1411   /* Seek to 32 bytes before the end of the second data sub-block */
1412   assertA(13752 == archive_seek_data(a, 13752 - file_size, SEEK_END));
1413   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1414   assertEqualMem(buff, file_test_txt5, sizeof(file_test_txt5) - 1);
1415
1416   /* Test EOF */
1417   assertA(1 == archive_read_next_header(a, &ae));
1418   assertEqualInt(1, archive_file_count(a));
1419   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1420   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1421 }
1422
1423 DEFINE_TEST(test_read_format_rar_multivolume_seek_multiple_files)
1424 {
1425   const char *reffiles[] =
1426   {
1427     "test_rar_multivolume_multiple_files.part1.rar",
1428     "test_rar_multivolume_multiple_files.part2.rar",
1429     "test_rar_multivolume_multiple_files.part3.rar",
1430     "test_rar_multivolume_multiple_files.part4.rar",
1431     "test_rar_multivolume_multiple_files.part5.rar",
1432     "test_rar_multivolume_multiple_files.part6.rar",
1433     NULL
1434   };
1435   char buff[64];
1436   int file_size = 20111;
1437   const char file_test_txt1[] = "d. \n</P>\n<P STYLE=\"margin-bottom: 0in\">"
1438                                 "<BR>\n</P>\n</BODY>\n</HTML>";
1439   const char file_test_txt2[] = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4."
1440                                 "0 Transitional//EN\">\n<";
1441   const char file_test_txt3[] = "mplify writing such tests,\ntry to use plat"
1442                                 "form-independent codin";
1443   const char file_test_txt4[] = "\nfailures. \n</P>\n<H1 CLASS=\"western\"><"
1444                                 "A NAME=\"Life_cycle_of_a_te";
1445   const char file_test_txt5[] = "LE=\"margin-bottom: 0in\">DO use runtime te"
1446                                 "sts for platform\n\tfeatu";
1447   const char file_test_txt6[] = "rough test suite is essential\nboth for ver"
1448                                 "ifying new ports and f";
1449   const char file_test_txt7[] = "m: 0in\">Creates a temporary directory\n\tw"
1450                                 "hose name matches the na";
1451   const char file_test_txt8[] = "lt\ninput file and verify the results. Thes"
1452                                 "e use <TT CLASS=\"weste";
1453   struct archive_entry *ae;
1454   struct archive *a;
1455
1456   extract_reference_files(reffiles);
1457   assert((a = archive_read_new()) != NULL);
1458   assertA(0 == archive_read_support_filter_all(a));
1459   assertA(0 == archive_read_support_format_all(a));
1460   assertA(0 == archive_read_open_filenames(a, reffiles, 10240));
1461
1462   /* First header. */
1463   assertA(0 == archive_read_next_header(a, &ae));
1464   assertEqualString("LibarchiveAddingTest2.html", archive_entry_pathname(ae));
1465   assertA((int)archive_entry_mtime(ae));
1466   assertA((int)archive_entry_ctime(ae));
1467   assertA((int)archive_entry_atime(ae));
1468   assertEqualInt(file_size, archive_entry_size(ae));
1469   assertEqualInt(33188, archive_entry_mode(ae));
1470   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1471   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1472
1473   /* Attempt to read past end of file */
1474   assertEqualInt(file_size, archive_seek_data(a, 0, SEEK_END));
1475   assertA(0 == archive_read_data(a, buff, sizeof(buff)));
1476   assertEqualInt(file_size + 40, archive_seek_data(a, 40, SEEK_CUR));
1477   assertA(0 == archive_read_data(a, buff, sizeof(buff)));
1478
1479   /* Seek to the end minus 64 bytes */
1480   assertA(file_size - (int)sizeof(buff) ==
1481     archive_seek_data(a, -(int)sizeof(buff), SEEK_END));
1482   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1483   assertEqualMem(buff, file_test_txt1, sizeof(file_test_txt1) - 1);
1484
1485   /* Seek back to the beginning */
1486   assertA(0 == archive_seek_data(a, -file_size, SEEK_END));
1487   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1488   assertEqualMem(buff, file_test_txt2, sizeof(file_test_txt2) - 1);
1489
1490   /* Seek to the middle of the combined data block */
1491   assertA(10054 == archive_seek_data(a, 10054 - (int)sizeof(buff), SEEK_CUR));
1492   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1493   assertEqualMem(buff, file_test_txt3, sizeof(file_test_txt3) - 1);
1494
1495   /* Seek to 32 bytes before the end of the first data sub-block */
1496   assertA(7027 == archive_seek_data(a, 7027 - (10054 + (int)sizeof(buff)),
1497                                     SEEK_CUR));
1498   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1499   assertEqualMem(buff, file_test_txt4, sizeof(file_test_txt4) - 1);
1500
1501   /* Seek to 32 bytes before the end of the second data sub-block */
1502   assertA(14086 == archive_seek_data(a, 14086 - file_size, SEEK_END));
1503   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1504   assertEqualMem(buff, file_test_txt5, sizeof(file_test_txt5) - 1);
1505
1506   /* Attempt to read past end of file */
1507   assertEqualInt(file_size, archive_seek_data(a, 0, SEEK_END));
1508   assertA(0 == archive_read_data(a, buff, sizeof(buff)));
1509   assertEqualInt(file_size + 40, archive_seek_data(a, 40, SEEK_CUR));
1510   assertA(0 == archive_read_data(a, buff, sizeof(buff)));
1511
1512   /* Second header. */
1513   assertA(0 == archive_read_next_header(a, &ae));
1514   assertEqualString("LibarchiveAddingTest.html", archive_entry_pathname(ae));
1515   assertA((int)archive_entry_mtime(ae));
1516   assertA((int)archive_entry_ctime(ae));
1517   assertA((int)archive_entry_atime(ae));
1518   assertEqualInt(file_size, archive_entry_size(ae));
1519   assertEqualInt(33188, archive_entry_mode(ae));
1520   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1521   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1522
1523   /* Attempt to read past end of file */
1524   assertEqualInt(file_size, archive_seek_data(a, 0, SEEK_END));
1525   assertA(0 == archive_read_data(a, buff, sizeof(buff)));
1526   assertEqualInt(file_size + 40, archive_seek_data(a, 40, SEEK_CUR));
1527   assertA(0 == archive_read_data(a, buff, sizeof(buff)));
1528
1529   /* Seek to the end minus 64 bytes */
1530   assertA(file_size - (int)sizeof(buff) ==
1531     archive_seek_data(a, file_size - (int)sizeof(buff), SEEK_SET));
1532   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1533   assertEqualMem(buff, file_test_txt1, sizeof(file_test_txt1) - 1);
1534
1535   /* Seek back to the beginning */
1536   assertA(0 == archive_seek_data(a, 0, SEEK_SET));
1537   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1538   assertEqualMem(buff, file_test_txt2, sizeof(file_test_txt2) - 1);
1539
1540   /* Seek to the middle of the combined data block */
1541   assertA(10054 == archive_seek_data(a, 10054 - (int)sizeof(buff), SEEK_CUR));
1542   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1543   assertEqualMem(buff, file_test_txt3, sizeof(file_test_txt3) - 1);
1544
1545   /* Seek to 32 bytes before the end of the first data sub-block */
1546   assertA(969 == archive_seek_data(a, 969 - (10054 + (int)sizeof(buff)), SEEK_CUR));
1547   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1548   assertEqualMem(buff, file_test_txt6, sizeof(file_test_txt4) - 1);
1549
1550   /* Seek to 32 bytes before the end of the second data sub-block */
1551   assertA(8029 == archive_seek_data(a, 8029 - file_size, SEEK_END));
1552   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1553   assertEqualMem(buff, file_test_txt7, sizeof(file_test_txt5) - 1);
1554
1555   /* Seek to 32 bytes before the end of the third data sub-block */
1556   assertA(15089 == archive_seek_data(a, 15089 - file_size, SEEK_END));
1557   assertA(sizeof(buff) == archive_read_data(a, buff, sizeof(buff)));
1558   assertEqualMem(buff, file_test_txt8, sizeof(file_test_txt5) - 1);
1559
1560   /* Attempt to read past end of file */
1561   assertEqualInt(file_size, archive_seek_data(a, 0, SEEK_END));
1562   assertA(0 == archive_read_data(a, buff, sizeof(buff)));
1563   assertEqualInt(file_size + 40, archive_seek_data(a, 40, SEEK_CUR));
1564   assertA(0 == archive_read_data(a, buff, sizeof(buff)));
1565
1566   /* Test EOF */
1567   assertA(1 == archive_read_next_header(a, &ae));
1568   assertEqualInt(2, archive_file_count(a));
1569   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
1570   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1571 }
1572
1573 static void
1574 test_read_format_rar_multivolume_uncompressed_files_helper(struct archive *a)
1575 {
1576   char buff[64];
1577
1578   /* Do checks for seeks/reads past beginning and end of file */
1579   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
1580   memset(buff, 0, sizeof(buff));
1581   assertEqualIntA(a, -1, archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_SET));
1582   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_CUR));
1583   assertEqualIntA(a, (sizeof(buff)-1),
1584     archive_read_data(a, buff, (sizeof(buff)-1)));
1585   assertEqualIntA(a, (sizeof(buff)-1), archive_seek_data(a, 0, SEEK_CUR));
1586   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD "
1587                         "HTML 4.0 Transitional//EN\">\n", buff);
1588   memset(buff, 0, sizeof(buff));
1589   assertEqualIntA(a, -1, archive_seek_data(a, -(((int)sizeof(buff)-1)*2), SEEK_CUR));
1590   assertEqualIntA(a, (sizeof(buff)-1), archive_seek_data(a, 0, SEEK_CUR));
1591   assertEqualIntA(a, (sizeof(buff)-1),
1592     archive_read_data(a, buff, (sizeof(buff)-1)));
1593   assertEqualIntA(a, ((sizeof(buff)-1)*2), archive_seek_data(a, 0, SEEK_CUR));
1594   assertEqualStringA(a, "<HTML>\n<HEAD>\n\t<META HTTP-EQUIV=\"CONTENT-TYPE\" "
1595                         "CONTENT=\"text/ht", buff);
1596   memset(buff, 0, sizeof(buff));
1597   assertEqualIntA(a, -1, archive_seek_data(a, -(20111+32), SEEK_END));
1598   assertEqualIntA(a, ((sizeof(buff)-1)*2), archive_seek_data(a, 0, SEEK_CUR));
1599   assertEqualIntA(a, (sizeof(buff)-1),
1600     archive_read_data(a, buff, (sizeof(buff)-1)));
1601   assertEqualIntA(a, ((sizeof(buff)-1)*3), archive_seek_data(a, 0, SEEK_CUR));
1602   assertEqualStringA(a, "ml; charset=utf-8\">\n\t<TITLE></TITLE>\n\t<META "
1603                         "NAME=\"GENERATOR\" CO", buff);
1604
1605   memset(buff, 0, sizeof(buff));
1606   assertEqualIntA(a, 20111, archive_seek_data(a, 20111, SEEK_SET));
1607   assertEqualIntA(a, 20111, archive_seek_data(a, 0, SEEK_CUR));
1608   assertEqualIntA(a, 0, archive_read_data(a, buff, (sizeof(buff)-1)));
1609   assertEqualIntA(a, 20111, archive_seek_data(a, 0, SEEK_CUR));
1610   assertEqualStringA(a, "", buff);
1611   memset(buff, 0, sizeof(buff));
1612   assertEqualIntA(a, 20111 + (sizeof(buff)-1),
1613     archive_seek_data(a, (sizeof(buff)-1), SEEK_CUR));
1614   assertEqualIntA(a, 0, archive_read_data(a, buff, (sizeof(buff)-1)));
1615   assertEqualIntA(a, 20111 + (sizeof(buff)-1),
1616     archive_seek_data(a, 0, SEEK_CUR));
1617   assertEqualStringA(a, "", buff);
1618   memset(buff, 0, sizeof(buff));
1619   assertEqualIntA(a, 20111 + ((sizeof(buff)-1)*2),
1620     archive_seek_data(a, ((sizeof(buff)-1)*2), SEEK_END));
1621   assertEqualIntA(a, 0, archive_read_data(a, buff, (sizeof(buff)-1)));
1622   assertEqualIntA(a, 20111 + ((sizeof(buff)-1)*2),
1623     archive_seek_data(a, 0, SEEK_CUR));
1624   assertEqualStringA(a, "", buff);
1625 }
1626
1627 DEFINE_TEST(test_read_format_rar_multivolume_uncompressed_files)
1628 {
1629   const char *reffiles[] =
1630   {
1631     "test_rar_multivolume_uncompressed_files.part01.rar",
1632     "test_rar_multivolume_uncompressed_files.part02.rar",
1633     "test_rar_multivolume_uncompressed_files.part03.rar",
1634     "test_rar_multivolume_uncompressed_files.part04.rar",
1635     "test_rar_multivolume_uncompressed_files.part05.rar",
1636     "test_rar_multivolume_uncompressed_files.part06.rar",
1637     "test_rar_multivolume_uncompressed_files.part07.rar",
1638     "test_rar_multivolume_uncompressed_files.part08.rar",
1639     "test_rar_multivolume_uncompressed_files.part09.rar",
1640     "test_rar_multivolume_uncompressed_files.part10.rar",
1641     NULL
1642   };
1643   char buff[64];
1644   ssize_t bytes_read;
1645   struct archive *a;
1646   struct archive_entry *ae;
1647
1648   extract_reference_files(reffiles);
1649   assert((a = archive_read_new()) != NULL);
1650   assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1651   assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1652   assertEqualIntA(a, ARCHIVE_OK,
1653                   archive_read_open_filenames(a, reffiles, 10240));
1654
1655   /*
1656    * First header.
1657    */
1658   assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1659   assertEqualStringA(a, "testdir/LibarchiveAddingTest2.html",
1660                      archive_entry_pathname(ae));
1661   assertA((int)archive_entry_mtime(ae));
1662   assertA((int)archive_entry_ctime(ae));
1663   assertA((int)archive_entry_atime(ae));
1664   assertEqualIntA(a, 20111, archive_entry_size(ae));
1665   assertEqualIntA(a, 33188, archive_entry_mode(ae));
1666   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1667   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1668
1669   test_read_format_rar_multivolume_uncompressed_files_helper(a);
1670
1671   /* Read from the beginning to the end of the file */
1672   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
1673   do
1674   {
1675     memset(buff, 0, sizeof(buff));
1676     bytes_read = archive_read_data(a, buff, (sizeof(buff)-1));
1677   } while (bytes_read > 0);
1678
1679   /* Seek to the end minus (sizeof(buff)-1) bytes */
1680   memset(buff, 0, sizeof(buff));
1681   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
1682     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
1683   assertEqualIntA(a, (sizeof(buff)-1),
1684     archive_read_data(a, buff, (sizeof(buff)-1)));
1685   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
1686                         "</P>\n</BODY>\n</HTML>", buff);
1687
1688   /* Seek back to the beginning */
1689   memset(buff, 0, sizeof(buff));
1690   assertEqualIntA(a, 0, archive_seek_data(a, -20111, SEEK_END));
1691   assertEqualIntA(a, (sizeof(buff)-1),
1692     archive_read_data(a, buff, (sizeof(buff)-1)));
1693   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
1694                         "Transitional//EN\">\n", buff);
1695
1696   /* Test that SEEK_SET works correctly between data blocks */
1697   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
1698   memset(buff, 0, sizeof(buff));
1699   assertEqualIntA(a, 13164,
1700     archive_seek_data(a, 13164, SEEK_SET));
1701   assertEqualIntA(a, (sizeof(buff)-1),
1702     archive_read_data(a, buff, (sizeof(buff)-1)));
1703   assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
1704                         "assertEqualMem to test equalit", buff);
1705
1706   memset(buff, 0, sizeof(buff));
1707   assertEqualIntA(a, 0,
1708     archive_seek_data(a, 0, SEEK_SET));
1709   assertEqualIntA(a, (sizeof(buff)-1),
1710     archive_read_data(a, buff, (sizeof(buff)-1)));
1711   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
1712                         "Transitional//EN\">\n", buff);
1713
1714   memset(buff, 0, sizeof(buff));
1715   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
1716     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
1717   assertEqualIntA(a, (sizeof(buff)-1),
1718     archive_read_data(a, buff, (sizeof(buff)-1)));
1719   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
1720                         "</P>\n</BODY>\n</HTML>", buff);
1721
1722   memset(buff, 0, sizeof(buff));
1723   assertEqualIntA(a, 13164,
1724     archive_seek_data(a, 13164, SEEK_SET));
1725   assertEqualIntA(a, (sizeof(buff)-1),
1726     archive_read_data(a, buff, (sizeof(buff)-1)));
1727   assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
1728                         "assertEqualMem to test equalit", buff);
1729
1730   memset(buff, 0, sizeof(buff));
1731   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
1732     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
1733   assertEqualIntA(a, (sizeof(buff)-1),
1734     archive_read_data(a, buff, (sizeof(buff)-1)));
1735   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
1736                         "</P>\n</BODY>\n</HTML>", buff);
1737
1738   memset(buff, 0, sizeof(buff));
1739   assertEqualIntA(a, 0,
1740     archive_seek_data(a, 0, SEEK_SET));
1741   assertEqualIntA(a, (sizeof(buff)-1),
1742     archive_read_data(a, buff, (sizeof(buff)-1)));
1743   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
1744                         "Transitional//EN\">\n", buff);
1745
1746   memset(buff, 0, sizeof(buff));
1747   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
1748     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
1749   assertEqualIntA(a, (sizeof(buff)-1),
1750     archive_read_data(a, buff, (sizeof(buff)-1)));
1751   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
1752                         "</P>\n</BODY>\n</HTML>", buff);
1753
1754   memset(buff, 0, sizeof(buff));
1755   assertEqualIntA(a, 13164,
1756     archive_seek_data(a, 13164, SEEK_SET));
1757   assertEqualIntA(a, (sizeof(buff)-1),
1758     archive_read_data(a, buff, (sizeof(buff)-1)));
1759   assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
1760                         "assertEqualMem to test equalit", buff);
1761
1762   memset(buff, 0, sizeof(buff));
1763   assertEqualIntA(a, 0,
1764     archive_seek_data(a, 0, SEEK_SET));
1765   assertEqualIntA(a, (sizeof(buff)-1),
1766     archive_read_data(a, buff, (sizeof(buff)-1)));
1767   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
1768                         "Transitional//EN\">\n", buff);
1769
1770   /* Test that SEEK_CUR works correctly between data blocks */
1771   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
1772   memset(buff, 0, sizeof(buff));
1773   assertEqualIntA(a, 13164,
1774     archive_seek_data(a, 13164, SEEK_CUR));
1775   assertEqualIntA(a, (sizeof(buff)-1),
1776     archive_read_data(a, buff, (sizeof(buff)-1)));
1777   assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
1778                         "assertEqualMem to test equalit", buff);
1779
1780   memset(buff, 0, sizeof(buff));
1781   assertEqualIntA(a, 0,
1782     archive_seek_data(a, -13227, SEEK_CUR));
1783   assertEqualIntA(a, (sizeof(buff)-1),
1784     archive_read_data(a, buff, (sizeof(buff)-1)));
1785   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
1786                         "Transitional//EN\">\n", buff);
1787
1788   memset(buff, 0, sizeof(buff));
1789   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
1790     archive_seek_data(a, 19985, SEEK_CUR));
1791   assertEqualIntA(a, (sizeof(buff)-1),
1792     archive_read_data(a, buff, (sizeof(buff)-1)));
1793   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
1794                         "</P>\n</BODY>\n</HTML>", buff);
1795
1796   memset(buff, 0, sizeof(buff));
1797   assertEqualIntA(a, 13164,
1798     archive_seek_data(a, -6947, SEEK_CUR));
1799   assertEqualIntA(a, (sizeof(buff)-1),
1800     archive_read_data(a, buff, (sizeof(buff)-1)));
1801   assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
1802                         "assertEqualMem to test equalit", buff);
1803
1804   memset(buff, 0, sizeof(buff));
1805   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
1806     archive_seek_data(a, 6821, SEEK_CUR));
1807   assertEqualIntA(a, (sizeof(buff)-1),
1808     archive_read_data(a, buff, (sizeof(buff)-1)));
1809   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
1810                         "</P>\n</BODY>\n</HTML>", buff);
1811
1812   memset(buff, 0, sizeof(buff));
1813   assertEqualIntA(a, 0,
1814     archive_seek_data(a, -20111, SEEK_CUR));
1815   assertEqualIntA(a, (sizeof(buff)-1),
1816     archive_read_data(a, buff, (sizeof(buff)-1)));
1817   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
1818                         "Transitional//EN\">\n", buff);
1819
1820   memset(buff, 0, sizeof(buff));
1821   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
1822     archive_seek_data(a, 19985, SEEK_CUR));
1823   assertEqualIntA(a, (sizeof(buff)-1),
1824     archive_read_data(a, buff, (sizeof(buff)-1)));
1825   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
1826                         "</P>\n</BODY>\n</HTML>", buff);
1827
1828   memset(buff, 0, sizeof(buff));
1829   assertEqualIntA(a, 13164,
1830     archive_seek_data(a, -6947, SEEK_CUR));
1831   assertEqualIntA(a, (sizeof(buff)-1),
1832     archive_read_data(a, buff, (sizeof(buff)-1)));
1833   assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
1834                         "assertEqualMem to test equalit", buff);
1835
1836   memset(buff, 0, sizeof(buff));
1837   assertEqualIntA(a, 0,
1838     archive_seek_data(a, -13227, SEEK_CUR));
1839   assertEqualIntA(a, (sizeof(buff)-1),
1840     archive_read_data(a, buff, (sizeof(buff)-1)));
1841   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
1842                         "Transitional//EN\">\n", buff);
1843
1844   /* Test that SEEK_END works correctly between data blocks */
1845   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
1846   memset(buff, 0, sizeof(buff));
1847   assertEqualIntA(a, 13164,
1848     archive_seek_data(a, -6947, SEEK_END));
1849   assertEqualIntA(a, (sizeof(buff)-1),
1850     archive_read_data(a, buff, (sizeof(buff)-1)));
1851   assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
1852                         "assertEqualMem to test equalit", buff);
1853
1854   memset(buff, 0, sizeof(buff));
1855   assertEqualIntA(a, 0,
1856     archive_seek_data(a, -20111, SEEK_END));
1857   assertEqualIntA(a, (sizeof(buff)-1),
1858     archive_read_data(a, buff, (sizeof(buff)-1)));
1859   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
1860                         "Transitional//EN\">\n", buff);
1861
1862   memset(buff, 0, sizeof(buff));
1863   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
1864     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
1865   assertEqualIntA(a, (sizeof(buff)-1),
1866     archive_read_data(a, buff, (sizeof(buff)-1)));
1867   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
1868                         "</P>\n</BODY>\n</HTML>", buff);
1869
1870   memset(buff, 0, sizeof(buff));
1871   assertEqualIntA(a, 13164,
1872     archive_seek_data(a, -6947, SEEK_END));
1873   assertEqualIntA(a, (sizeof(buff)-1),
1874     archive_read_data(a, buff, (sizeof(buff)-1)));
1875   assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
1876                         "assertEqualMem to test equalit", buff);
1877
1878   memset(buff, 0, sizeof(buff));
1879   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
1880     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
1881   assertEqualIntA(a, (sizeof(buff)-1),
1882     archive_read_data(a, buff, (sizeof(buff)-1)));
1883   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
1884                         "</P>\n</BODY>\n</HTML>", buff);
1885
1886   memset(buff, 0, sizeof(buff));
1887   assertEqualIntA(a, 0,
1888     archive_seek_data(a, -20111, SEEK_END));
1889   assertEqualIntA(a, (sizeof(buff)-1),
1890     archive_read_data(a, buff, (sizeof(buff)-1)));
1891   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
1892                         "Transitional//EN\">\n", buff);
1893
1894   memset(buff, 0, sizeof(buff));
1895   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
1896     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
1897   assertEqualIntA(a, (sizeof(buff)-1),
1898     archive_read_data(a, buff, (sizeof(buff)-1)));
1899   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
1900                         "</P>\n</BODY>\n</HTML>", buff);
1901
1902   memset(buff, 0, sizeof(buff));
1903   assertEqualIntA(a, 13164,
1904     archive_seek_data(a, -6947, SEEK_END));
1905   assertEqualIntA(a, (sizeof(buff)-1),
1906     archive_read_data(a, buff, (sizeof(buff)-1)));
1907   assertEqualStringA(a, "ertEqualInt,\n\tassertEqualString, "
1908                         "assertEqualMem to test equalit", buff);
1909
1910   memset(buff, 0, sizeof(buff));
1911   assertEqualIntA(a, 0,
1912     archive_seek_data(a, -20111, SEEK_END));
1913   assertEqualIntA(a, (sizeof(buff)-1),
1914     archive_read_data(a, buff, (sizeof(buff)-1)));
1915   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
1916                         "Transitional//EN\">\n", buff);
1917
1918   test_read_format_rar_multivolume_uncompressed_files_helper(a);
1919
1920   /*
1921    * Second header.
1922    */
1923   assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1924   assertEqualStringA(a, "testdir/testsubdir/LibarchiveAddingTest2.html",
1925                      archive_entry_pathname(ae));
1926   assertA((int)archive_entry_mtime(ae));
1927   assertA((int)archive_entry_ctime(ae));
1928   assertA((int)archive_entry_atime(ae));
1929   assertEqualIntA(a, 20111, archive_entry_size(ae));
1930   assertEqualIntA(a, 33188, archive_entry_mode(ae));
1931   assertEqualInt(archive_entry_is_encrypted(ae), 0);
1932   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1933
1934   test_read_format_rar_multivolume_uncompressed_files_helper(a);
1935
1936   /* Read from the beginning to the end of the file */
1937   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
1938   do
1939   {
1940     memset(buff, 0, sizeof(buff));
1941     bytes_read = archive_read_data(a, buff, (sizeof(buff)-1));
1942   } while (bytes_read > 0);
1943
1944   /* Seek to the end minus (sizeof(buff)-1) bytes */
1945   memset(buff, 0, sizeof(buff));
1946   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
1947     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
1948   assertEqualIntA(a, (sizeof(buff)-1),
1949     archive_read_data(a, buff, (sizeof(buff)-1)));
1950   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
1951                         "</P>\n</BODY>\n</HTML>", buff);
1952
1953   /* Seek back to the beginning */
1954   memset(buff, 0, sizeof(buff));
1955   assertEqualIntA(a, 0, archive_seek_data(a, -20111, SEEK_END));
1956   assertEqualIntA(a, (sizeof(buff)-1),
1957     archive_read_data(a, buff, (sizeof(buff)-1)));
1958   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
1959                         "Transitional//EN\">\n", buff);
1960
1961   /* Test that SEEK_SET works correctly between data blocks */
1962   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
1963   memset(buff, 0, sizeof(buff));
1964   assertEqualIntA(a, 6162,
1965     archive_seek_data(a, 6162, SEEK_SET));
1966   assertEqualIntA(a, (sizeof(buff)-1),
1967     archive_read_data(a, buff, (sizeof(buff)-1)));
1968   assertEqualStringA(a, "arguments satisfy certain conditions. "
1969                         "If the assertion fails--f", buff);
1970
1971   memset(buff, 0, sizeof(buff));
1972   assertEqualIntA(a, 19347,
1973     archive_seek_data(a, 19347, SEEK_SET));
1974   assertEqualIntA(a, (sizeof(buff)-1),
1975     archive_read_data(a, buff, (sizeof(buff)-1)));
1976   assertEqualStringA(a, " when a block being written out by\n"
1977                         "the archive writer is the sa", buff);
1978
1979   memset(buff, 0, sizeof(buff));
1980   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
1981     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
1982   assertEqualIntA(a, (sizeof(buff)-1),
1983     archive_read_data(a, buff, (sizeof(buff)-1)));
1984   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
1985                         "</P>\n</BODY>\n</HTML>", buff);
1986
1987   memset(buff, 0, sizeof(buff));
1988   assertEqualIntA(a, 19347,
1989     archive_seek_data(a, 19347, SEEK_SET));
1990   assertEqualIntA(a, (sizeof(buff)-1),
1991     archive_read_data(a, buff, (sizeof(buff)-1)));
1992   assertEqualStringA(a, " when a block being written out by\n"
1993                         "the archive writer is the sa", buff);
1994
1995   memset(buff, 0, sizeof(buff));
1996   assertEqualIntA(a, 6162,
1997     archive_seek_data(a, 6162, SEEK_SET));
1998   assertEqualIntA(a, (sizeof(buff)-1),
1999     archive_read_data(a, buff, (sizeof(buff)-1)));
2000   assertEqualStringA(a, "arguments satisfy certain conditions. "
2001                         "If the assertion fails--f", buff);
2002
2003   memset(buff, 0, sizeof(buff));
2004   assertEqualIntA(a, 0,
2005     archive_seek_data(a, 0, SEEK_SET));
2006   assertEqualIntA(a, (sizeof(buff)-1),
2007     archive_read_data(a, buff, (sizeof(buff)-1)));
2008   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2009                         "Transitional//EN\">\n", buff);
2010
2011   memset(buff, 0, sizeof(buff));
2012   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2013     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
2014   assertEqualIntA(a, (sizeof(buff)-1),
2015     archive_read_data(a, buff, (sizeof(buff)-1)));
2016   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2017                         "</P>\n</BODY>\n</HTML>", buff);
2018
2019   memset(buff, 0, sizeof(buff));
2020   assertEqualIntA(a, 6162,
2021     archive_seek_data(a, 6162, SEEK_SET));
2022   assertEqualIntA(a, (sizeof(buff)-1),
2023     archive_read_data(a, buff, (sizeof(buff)-1)));
2024   assertEqualStringA(a, "arguments satisfy certain conditions. "
2025                         "If the assertion fails--f", buff);
2026
2027   memset(buff, 0, sizeof(buff));
2028   assertEqualIntA(a, 19347,
2029     archive_seek_data(a, 19347, SEEK_SET));
2030   assertEqualIntA(a, (sizeof(buff)-1),
2031     archive_read_data(a, buff, (sizeof(buff)-1)));
2032   assertEqualStringA(a, " when a block being written out by\n"
2033                         "the archive writer is the sa", buff);
2034
2035   memset(buff, 0, sizeof(buff));
2036   assertEqualIntA(a, 0,
2037     archive_seek_data(a, 0, SEEK_SET));
2038   assertEqualIntA(a, (sizeof(buff)-1),
2039     archive_read_data(a, buff, (sizeof(buff)-1)));
2040   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2041                         "Transitional//EN\">\n", buff);
2042
2043   memset(buff, 0, sizeof(buff));
2044   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2045     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
2046   assertEqualIntA(a, (sizeof(buff)-1),
2047     archive_read_data(a, buff, (sizeof(buff)-1)));
2048   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2049                         "</P>\n</BODY>\n</HTML>", buff);
2050
2051   memset(buff, 0, sizeof(buff));
2052   assertEqualIntA(a, 0,
2053     archive_seek_data(a, 0, SEEK_SET));
2054   assertEqualIntA(a, (sizeof(buff)-1),
2055     archive_read_data(a, buff, (sizeof(buff)-1)));
2056   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2057                         "Transitional//EN\">\n", buff);
2058
2059   memset(buff, 0, sizeof(buff));
2060   assertEqualIntA(a, 19347,
2061     archive_seek_data(a, 19347, SEEK_SET));
2062   assertEqualIntA(a, (sizeof(buff)-1),
2063     archive_read_data(a, buff, (sizeof(buff)-1)));
2064   assertEqualStringA(a, " when a block being written out by\n"
2065                         "the archive writer is the sa", buff);
2066
2067   memset(buff, 0, sizeof(buff));
2068   assertEqualIntA(a, 6162,
2069     archive_seek_data(a, 6162, SEEK_SET));
2070   assertEqualIntA(a, (sizeof(buff)-1),
2071     archive_read_data(a, buff, (sizeof(buff)-1)));
2072   assertEqualStringA(a, "arguments satisfy certain conditions. "
2073                         "If the assertion fails--f", buff);
2074
2075   /* Test that SEEK_CUR works correctly between data blocks */
2076   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
2077   memset(buff, 0, sizeof(buff));
2078   assertEqualIntA(a, 6162,
2079     archive_seek_data(a, 6162, SEEK_CUR));
2080   assertEqualIntA(a, (sizeof(buff)-1),
2081     archive_read_data(a, buff, (sizeof(buff)-1)));
2082   assertEqualStringA(a, "arguments satisfy certain conditions. "
2083                         "If the assertion fails--f", buff);
2084
2085   memset(buff, 0, sizeof(buff));
2086   assertEqualIntA(a, 19347,
2087     archive_seek_data(a, 13122, SEEK_CUR));
2088   assertEqualIntA(a, (sizeof(buff)-1),
2089     archive_read_data(a, buff, (sizeof(buff)-1)));
2090   assertEqualStringA(a, " when a block being written out by\n"
2091                         "the archive writer is the sa", buff);
2092
2093   memset(buff, 0, sizeof(buff));
2094   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2095     archive_seek_data(a, 638, SEEK_CUR));
2096   assertEqualIntA(a, (sizeof(buff)-1),
2097     archive_read_data(a, buff, (sizeof(buff)-1)));
2098   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2099                         "</P>\n</BODY>\n</HTML>", buff);
2100
2101   memset(buff, 0, sizeof(buff));
2102   assertEqualIntA(a, 19347,
2103     archive_seek_data(a, -764, SEEK_CUR));
2104   assertEqualIntA(a, (sizeof(buff)-1),
2105     archive_read_data(a, buff, (sizeof(buff)-1)));
2106   assertEqualStringA(a, " when a block being written out by\n"
2107                         "the archive writer is the sa", buff);
2108
2109   memset(buff, 0, sizeof(buff));
2110   assertEqualIntA(a, 6162,
2111     archive_seek_data(a, -13248, SEEK_CUR));
2112   assertEqualIntA(a, (sizeof(buff)-1),
2113     archive_read_data(a, buff, (sizeof(buff)-1)));
2114   assertEqualStringA(a, "arguments satisfy certain conditions. "
2115                         "If the assertion fails--f", buff);
2116
2117   memset(buff, 0, sizeof(buff));
2118   assertEqualIntA(a, 0,
2119     archive_seek_data(a, -6225, SEEK_CUR));
2120   assertEqualIntA(a, (sizeof(buff)-1),
2121     archive_read_data(a, buff, (sizeof(buff)-1)));
2122   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2123                         "Transitional//EN\">\n", buff);
2124
2125   memset(buff, 0, sizeof(buff));
2126   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2127     archive_seek_data(a, 19985, SEEK_CUR));
2128   assertEqualIntA(a, (sizeof(buff)-1),
2129     archive_read_data(a, buff, (sizeof(buff)-1)));
2130   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2131                         "</P>\n</BODY>\n</HTML>", buff);
2132
2133   memset(buff, 0, sizeof(buff));
2134   assertEqualIntA(a, 6162,
2135     archive_seek_data(a, -13949, SEEK_CUR));
2136   assertEqualIntA(a, (sizeof(buff)-1),
2137     archive_read_data(a, buff, (sizeof(buff)-1)));
2138   assertEqualStringA(a, "arguments satisfy certain conditions. "
2139                         "If the assertion fails--f", buff);
2140
2141   memset(buff, 0, sizeof(buff));
2142   assertEqualIntA(a, 19347,
2143     archive_seek_data(a, 13122, SEEK_CUR));
2144   assertEqualIntA(a, (sizeof(buff)-1),
2145     archive_read_data(a, buff, (sizeof(buff)-1)));
2146   assertEqualStringA(a, " when a block being written out by\n"
2147                         "the archive writer is the sa", buff);
2148
2149   memset(buff, 0, sizeof(buff));
2150   assertEqualIntA(a, 0,
2151     archive_seek_data(a, -19410, SEEK_CUR));
2152   assertEqualIntA(a, (sizeof(buff)-1),
2153     archive_read_data(a, buff, (sizeof(buff)-1)));
2154   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2155                         "Transitional//EN\">\n", buff);
2156
2157   memset(buff, 0, sizeof(buff));
2158   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2159     archive_seek_data(a, 19985, SEEK_CUR));
2160   assertEqualIntA(a, (sizeof(buff)-1),
2161     archive_read_data(a, buff, (sizeof(buff)-1)));
2162   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2163                         "</P>\n</BODY>\n</HTML>", buff);
2164
2165   memset(buff, 0, sizeof(buff));
2166   assertEqualIntA(a, 0,
2167     archive_seek_data(a, -20111, SEEK_CUR));
2168   assertEqualIntA(a, (sizeof(buff)-1),
2169     archive_read_data(a, buff, (sizeof(buff)-1)));
2170   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2171                         "Transitional//EN\">\n", buff);
2172
2173   memset(buff, 0, sizeof(buff));
2174   assertEqualIntA(a, 19347,
2175     archive_seek_data(a, 19284, SEEK_CUR));
2176   assertEqualIntA(a, (sizeof(buff)-1),
2177     archive_read_data(a, buff, (sizeof(buff)-1)));
2178   assertEqualStringA(a, " when a block being written out by\n"
2179                         "the archive writer is the sa", buff);
2180
2181   memset(buff, 0, sizeof(buff));
2182   assertEqualIntA(a, 6162,
2183     archive_seek_data(a, -13248, SEEK_CUR));
2184   assertEqualIntA(a, (sizeof(buff)-1),
2185     archive_read_data(a, buff, (sizeof(buff)-1)));
2186   assertEqualStringA(a, "arguments satisfy certain conditions. "
2187                         "If the assertion fails--f", buff);
2188
2189   /* Test that SEEK_END works correctly between data blocks */
2190   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
2191   memset(buff, 0, sizeof(buff));
2192   assertEqualIntA(a, 6162,
2193     archive_seek_data(a, -13949, SEEK_END));
2194   assertEqualIntA(a, (sizeof(buff)-1),
2195     archive_read_data(a, buff, (sizeof(buff)-1)));
2196   assertEqualStringA(a, "arguments satisfy certain conditions. "
2197                         "If the assertion fails--f", buff);
2198
2199   memset(buff, 0, sizeof(buff));
2200   assertEqualIntA(a, 19347,
2201     archive_seek_data(a, -764, SEEK_END));
2202   assertEqualIntA(a, (sizeof(buff)-1),
2203     archive_read_data(a, buff, (sizeof(buff)-1)));
2204   assertEqualStringA(a, " when a block being written out by\n"
2205                         "the archive writer is the sa", buff);
2206
2207   memset(buff, 0, sizeof(buff));
2208   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2209     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
2210   assertEqualIntA(a, (sizeof(buff)-1),
2211     archive_read_data(a, buff, (sizeof(buff)-1)));
2212   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2213                         "</P>\n</BODY>\n</HTML>", buff);
2214
2215   memset(buff, 0, sizeof(buff));
2216   assertEqualIntA(a, 19347,
2217     archive_seek_data(a, -764, SEEK_END));
2218   assertEqualIntA(a, (sizeof(buff)-1),
2219     archive_read_data(a, buff, (sizeof(buff)-1)));
2220   assertEqualStringA(a, " when a block being written out by\n"
2221                         "the archive writer is the sa", buff);
2222
2223   memset(buff, 0, sizeof(buff));
2224   assertEqualIntA(a, 6162,
2225     archive_seek_data(a, -13949, SEEK_END));
2226   assertEqualIntA(a, (sizeof(buff)-1),
2227     archive_read_data(a, buff, (sizeof(buff)-1)));
2228   assertEqualStringA(a, "arguments satisfy certain conditions. "
2229                         "If the assertion fails--f", buff);
2230
2231   memset(buff, 0, sizeof(buff));
2232   assertEqualIntA(a, 0,
2233     archive_seek_data(a, -20111, SEEK_END));
2234   assertEqualIntA(a, (sizeof(buff)-1),
2235     archive_read_data(a, buff, (sizeof(buff)-1)));
2236   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2237                         "Transitional//EN\">\n", buff);
2238
2239   memset(buff, 0, sizeof(buff));
2240   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2241     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
2242   assertEqualIntA(a, (sizeof(buff)-1),
2243     archive_read_data(a, buff, (sizeof(buff)-1)));
2244   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2245                         "</P>\n</BODY>\n</HTML>", buff);
2246
2247   memset(buff, 0, sizeof(buff));
2248   assertEqualIntA(a, 6162,
2249     archive_seek_data(a, -13949, SEEK_END));
2250   assertEqualIntA(a, (sizeof(buff)-1),
2251     archive_read_data(a, buff, (sizeof(buff)-1)));
2252   assertEqualStringA(a, "arguments satisfy certain conditions. "
2253                         "If the assertion fails--f", buff);
2254
2255   memset(buff, 0, sizeof(buff));
2256   assertEqualIntA(a, 19347,
2257     archive_seek_data(a, -764, SEEK_END));
2258   assertEqualIntA(a, (sizeof(buff)-1),
2259     archive_read_data(a, buff, (sizeof(buff)-1)));
2260   assertEqualStringA(a, " when a block being written out by\n"
2261                         "the archive writer is the sa", buff);
2262
2263   memset(buff, 0, sizeof(buff));
2264   assertEqualIntA(a, 0,
2265     archive_seek_data(a, -20111, SEEK_END));
2266   assertEqualIntA(a, (sizeof(buff)-1),
2267     archive_read_data(a, buff, (sizeof(buff)-1)));
2268   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2269                         "Transitional//EN\">\n", buff);
2270
2271   memset(buff, 0, sizeof(buff));
2272   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2273     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
2274   assertEqualIntA(a, (sizeof(buff)-1),
2275     archive_read_data(a, buff, (sizeof(buff)-1)));
2276   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2277                         "</P>\n</BODY>\n</HTML>", buff);
2278
2279   memset(buff, 0, sizeof(buff));
2280   assertEqualIntA(a, 0,
2281     archive_seek_data(a, -20111, SEEK_END));
2282   assertEqualIntA(a, (sizeof(buff)-1),
2283     archive_read_data(a, buff, (sizeof(buff)-1)));
2284   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2285                         "Transitional//EN\">\n", buff);
2286
2287   memset(buff, 0, sizeof(buff));
2288   assertEqualIntA(a, 19347,
2289     archive_seek_data(a, -764, SEEK_END));
2290   assertEqualIntA(a, (sizeof(buff)-1),
2291     archive_read_data(a, buff, (sizeof(buff)-1)));
2292   assertEqualStringA(a, " when a block being written out by\n"
2293                         "the archive writer is the sa", buff);
2294
2295   memset(buff, 0, sizeof(buff));
2296   assertEqualIntA(a, 6162,
2297     archive_seek_data(a, -13949, SEEK_END));
2298   assertEqualIntA(a, (sizeof(buff)-1),
2299     archive_read_data(a, buff, (sizeof(buff)-1)));
2300   assertEqualStringA(a, "arguments satisfy certain conditions. "
2301                         "If the assertion fails--f", buff);
2302
2303   test_read_format_rar_multivolume_uncompressed_files_helper(a);
2304
2305   /*
2306    * Third header.
2307    */
2308   assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
2309   assertEqualStringA(a, "LibarchiveAddingTest2.html",
2310                      archive_entry_pathname(ae));
2311   assertA((int)archive_entry_mtime(ae));
2312   assertA((int)archive_entry_ctime(ae));
2313   assertA((int)archive_entry_atime(ae));
2314   assertEqualIntA(a, 20111, archive_entry_size(ae));
2315   assertEqualIntA(a, 33188, archive_entry_mode(ae));
2316   assertEqualInt(archive_entry_is_encrypted(ae), 0);
2317   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
2318
2319   test_read_format_rar_multivolume_uncompressed_files_helper(a);
2320
2321   /* Read from the beginning to the end of the file */
2322   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
2323   do
2324   {
2325     memset(buff, 0, sizeof(buff));
2326     bytes_read = archive_read_data(a, buff, (sizeof(buff)-1));
2327   } while (bytes_read > 0);
2328
2329   /* Seek to the end minus (sizeof(buff)-1) bytes */
2330   memset(buff, 0, sizeof(buff));
2331   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2332     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
2333   assertEqualIntA(a, (sizeof(buff)-1),
2334     archive_read_data(a, buff, (sizeof(buff)-1)));
2335   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2336                         "</P>\n</BODY>\n</HTML>", buff);
2337
2338   /* Seek back to the beginning */
2339   memset(buff, 0, sizeof(buff));
2340   assertEqualIntA(a, 0, archive_seek_data(a, -20111, SEEK_END));
2341   assertEqualIntA(a, (sizeof(buff)-1),
2342     archive_read_data(a, buff, (sizeof(buff)-1)));
2343   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2344                         "Transitional//EN\">\n", buff);
2345
2346   /* Test that SEEK_SET works correctly between data blocks */
2347   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
2348   memset(buff, 0, sizeof(buff));
2349   assertEqualIntA(a, 12353,
2350     archive_seek_data(a, 12353, SEEK_SET));
2351   assertEqualIntA(a, (sizeof(buff)-1),
2352     archive_read_data(a, buff, (sizeof(buff)-1)));
2353   assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
2354                         "extract_reference_file(&quot;test_foo.tar", buff);
2355
2356   memset(buff, 0, sizeof(buff));
2357   assertEqualIntA(a, 0,
2358     archive_seek_data(a, 0, SEEK_SET));
2359   assertEqualIntA(a, (sizeof(buff)-1),
2360     archive_read_data(a, buff, (sizeof(buff)-1)));
2361   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2362                         "Transitional//EN\">\n", buff);
2363
2364   memset(buff, 0, sizeof(buff));
2365   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2366     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
2367   assertEqualIntA(a, (sizeof(buff)-1),
2368     archive_read_data(a, buff, (sizeof(buff)-1)));
2369   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2370                         "</P>\n</BODY>\n</HTML>", buff);
2371
2372   memset(buff, 0, sizeof(buff));
2373   assertEqualIntA(a, 12353,
2374     archive_seek_data(a, 12353, SEEK_SET));
2375   assertEqualIntA(a, (sizeof(buff)-1),
2376     archive_read_data(a, buff, (sizeof(buff)-1)));
2377   assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
2378                         "extract_reference_file(&quot;test_foo.tar", buff);
2379
2380   memset(buff, 0, sizeof(buff));
2381   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2382     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
2383   assertEqualIntA(a, (sizeof(buff)-1),
2384     archive_read_data(a, buff, (sizeof(buff)-1)));
2385   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2386                         "</P>\n</BODY>\n</HTML>", buff);
2387
2388   memset(buff, 0, sizeof(buff));
2389   assertEqualIntA(a, 0,
2390     archive_seek_data(a, 0, SEEK_SET));
2391   assertEqualIntA(a, (sizeof(buff)-1),
2392     archive_read_data(a, buff, (sizeof(buff)-1)));
2393   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2394                         "Transitional//EN\">\n", buff);
2395
2396   memset(buff, 0, sizeof(buff));
2397   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2398     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
2399   assertEqualIntA(a, (sizeof(buff)-1),
2400     archive_read_data(a, buff, (sizeof(buff)-1)));
2401   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2402                         "</P>\n</BODY>\n</HTML>", buff);
2403
2404   memset(buff, 0, sizeof(buff));
2405   assertEqualIntA(a, 12353,
2406     archive_seek_data(a, 12353, SEEK_SET));
2407   assertEqualIntA(a, (sizeof(buff)-1),
2408     archive_read_data(a, buff, (sizeof(buff)-1)));
2409   assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
2410                         "extract_reference_file(&quot;test_foo.tar", buff);
2411
2412   memset(buff, 0, sizeof(buff));
2413   assertEqualIntA(a, 0,
2414     archive_seek_data(a, 0, SEEK_SET));
2415   assertEqualIntA(a, (sizeof(buff)-1),
2416     archive_read_data(a, buff, (sizeof(buff)-1)));
2417   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2418                         "Transitional//EN\">\n", buff);
2419
2420   /* Test that SEEK_CUR works correctly between data blocks */
2421   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
2422   memset(buff, 0, sizeof(buff));
2423   assertEqualIntA(a, 12353,
2424     archive_seek_data(a, 12353, SEEK_CUR));
2425   assertEqualIntA(a, (sizeof(buff)-1),
2426     archive_read_data(a, buff, (sizeof(buff)-1)));
2427   assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
2428                         "extract_reference_file(&quot;test_foo.tar", buff);
2429
2430   memset(buff, 0, sizeof(buff));
2431   assertEqualIntA(a, 0,
2432     archive_seek_data(a, -12416, SEEK_CUR));
2433   assertEqualIntA(a, (sizeof(buff)-1),
2434     archive_read_data(a, buff, (sizeof(buff)-1)));
2435   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2436                         "Transitional//EN\">\n", buff);
2437
2438   memset(buff, 0, sizeof(buff));
2439   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2440     archive_seek_data(a, 19985, SEEK_CUR));
2441   assertEqualIntA(a, (sizeof(buff)-1),
2442     archive_read_data(a, buff, (sizeof(buff)-1)));
2443   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2444                         "</P>\n</BODY>\n</HTML>", buff);
2445
2446   memset(buff, 0, sizeof(buff));
2447   assertEqualIntA(a, 12353,
2448     archive_seek_data(a, -7758, SEEK_CUR));
2449   assertEqualIntA(a, (sizeof(buff)-1),
2450     archive_read_data(a, buff, (sizeof(buff)-1)));
2451   assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
2452                         "extract_reference_file(&quot;test_foo.tar", buff);
2453
2454   memset(buff, 0, sizeof(buff));
2455   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2456     archive_seek_data(a, 7632, SEEK_CUR));
2457   assertEqualIntA(a, (sizeof(buff)-1),
2458     archive_read_data(a, buff, (sizeof(buff)-1)));
2459   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2460                         "</P>\n</BODY>\n</HTML>", buff);
2461
2462   memset(buff, 0, sizeof(buff));
2463   assertEqualIntA(a, 0,
2464     archive_seek_data(a, -20111, SEEK_CUR));
2465   assertEqualIntA(a, (sizeof(buff)-1),
2466     archive_read_data(a, buff, (sizeof(buff)-1)));
2467   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2468                         "Transitional//EN\">\n", buff);
2469
2470   memset(buff, 0, sizeof(buff));
2471   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2472     archive_seek_data(a, 19985, SEEK_CUR));
2473   assertEqualIntA(a, (sizeof(buff)-1),
2474     archive_read_data(a, buff, (sizeof(buff)-1)));
2475   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2476                         "</P>\n</BODY>\n</HTML>", buff);
2477
2478   memset(buff, 0, sizeof(buff));
2479   assertEqualIntA(a, 12353,
2480     archive_seek_data(a, -7758, SEEK_CUR));
2481   assertEqualIntA(a, (sizeof(buff)-1),
2482     archive_read_data(a, buff, (sizeof(buff)-1)));
2483   assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
2484                         "extract_reference_file(&quot;test_foo.tar", buff);
2485
2486   memset(buff, 0, sizeof(buff));
2487   assertEqualIntA(a, 0,
2488     archive_seek_data(a, -12416, SEEK_CUR));
2489   assertEqualIntA(a, (sizeof(buff)-1),
2490     archive_read_data(a, buff, (sizeof(buff)-1)));
2491   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2492                         "Transitional//EN\">\n", buff);
2493
2494   /* Test that SEEK_END works correctly between data blocks */
2495   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
2496   memset(buff, 0, sizeof(buff));
2497   assertEqualIntA(a, 12353,
2498     archive_seek_data(a, -7758, SEEK_END));
2499   assertEqualIntA(a, (sizeof(buff)-1),
2500     archive_read_data(a, buff, (sizeof(buff)-1)));
2501   assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
2502                         "extract_reference_file(&quot;test_foo.tar", buff);
2503
2504   memset(buff, 0, sizeof(buff));
2505   assertEqualIntA(a, 0,
2506     archive_seek_data(a, -20111, SEEK_END));
2507   assertEqualIntA(a, (sizeof(buff)-1),
2508     archive_read_data(a, buff, (sizeof(buff)-1)));
2509   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2510                         "Transitional//EN\">\n", buff);
2511
2512   memset(buff, 0, sizeof(buff));
2513   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2514     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
2515   assertEqualIntA(a, (sizeof(buff)-1),
2516     archive_read_data(a, buff, (sizeof(buff)-1)));
2517   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2518                         "</P>\n</BODY>\n</HTML>", buff);
2519
2520   memset(buff, 0, sizeof(buff));
2521   assertEqualIntA(a, 12353,
2522     archive_seek_data(a, -7758, SEEK_END));
2523   assertEqualIntA(a, (sizeof(buff)-1),
2524     archive_read_data(a, buff, (sizeof(buff)-1)));
2525   assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
2526                         "extract_reference_file(&quot;test_foo.tar", buff);
2527
2528   memset(buff, 0, sizeof(buff));
2529   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2530     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
2531   assertEqualIntA(a, (sizeof(buff)-1),
2532     archive_read_data(a, buff, (sizeof(buff)-1)));
2533   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2534                         "</P>\n</BODY>\n</HTML>", buff);
2535
2536   memset(buff, 0, sizeof(buff));
2537   assertEqualIntA(a, 0,
2538     archive_seek_data(a, -20111, SEEK_END));
2539   assertEqualIntA(a, (sizeof(buff)-1),
2540     archive_read_data(a, buff, (sizeof(buff)-1)));
2541   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2542                         "Transitional//EN\">\n", buff);
2543
2544   memset(buff, 0, sizeof(buff));
2545   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2546     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
2547   assertEqualIntA(a, (sizeof(buff)-1),
2548     archive_read_data(a, buff, (sizeof(buff)-1)));
2549   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2550                         "</P>\n</BODY>\n</HTML>", buff);
2551
2552   memset(buff, 0, sizeof(buff));
2553   assertEqualIntA(a, 12353,
2554     archive_seek_data(a, -7758, SEEK_END));
2555   assertEqualIntA(a, (sizeof(buff)-1),
2556     archive_read_data(a, buff, (sizeof(buff)-1)));
2557   assertEqualStringA(a, " 0.2in\">&nbsp; &nbsp; "
2558                         "extract_reference_file(&quot;test_foo.tar", buff);
2559
2560   memset(buff, 0, sizeof(buff));
2561   assertEqualIntA(a, 0,
2562     archive_seek_data(a, -20111, SEEK_END));
2563   assertEqualIntA(a, (sizeof(buff)-1),
2564     archive_read_data(a, buff, (sizeof(buff)-1)));
2565   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2566                         "Transitional//EN\">\n", buff);
2567
2568   test_read_format_rar_multivolume_uncompressed_files_helper(a);
2569
2570   /*
2571    * Fourth header.
2572    */
2573   assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
2574   assertEqualStringA(a, "testdir/LibarchiveAddingTest.html",
2575                      archive_entry_pathname(ae));
2576   assertA((int)archive_entry_mtime(ae));
2577   assertA((int)archive_entry_ctime(ae));
2578   assertA((int)archive_entry_atime(ae));
2579   assertEqualIntA(a, 20111, archive_entry_size(ae));
2580   assertEqualIntA(a, 33188, archive_entry_mode(ae));
2581   assertEqualInt(archive_entry_is_encrypted(ae), 0);
2582   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
2583
2584   test_read_format_rar_multivolume_uncompressed_files_helper(a);
2585
2586   /* Read from the beginning to the end of the file */
2587   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
2588   do
2589   {
2590     memset(buff, 0, sizeof(buff));
2591     bytes_read = archive_read_data(a, buff, (sizeof(buff)-1));
2592   } while (bytes_read > 0);
2593
2594   /* Seek to the end minus (sizeof(buff)-1) bytes */
2595   memset(buff, 0, sizeof(buff));
2596   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2597     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
2598   assertEqualIntA(a, (sizeof(buff)-1),
2599     archive_read_data(a, buff, (sizeof(buff)-1)));
2600   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2601                         "</P>\n</BODY>\n</HTML>", buff);
2602
2603   /* Seek back to the beginning */
2604   memset(buff, 0, sizeof(buff));
2605   assertEqualIntA(a, 0, archive_seek_data(a, -20111, SEEK_END));
2606   assertEqualIntA(a, (sizeof(buff)-1),
2607     archive_read_data(a, buff, (sizeof(buff)-1)));
2608   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2609                         "Transitional//EN\">\n", buff);
2610
2611   /* Test that SEEK_SET works correctly between data blocks */
2612   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
2613   memset(buff, 0, sizeof(buff));
2614   assertEqualIntA(a, 5371,
2615     archive_seek_data(a, 5371, SEEK_SET));
2616   assertEqualIntA(a, (sizeof(buff)-1),
2617     archive_read_data(a, buff, (sizeof(buff)-1)));
2618   assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
2619                         "/* ... setup omitted ... */\n&nbsp; ", buff);
2620
2621   memset(buff, 0, sizeof(buff));
2622   assertEqualIntA(a, 13165,
2623     archive_seek_data(a, 13165, SEEK_SET));
2624   assertEqualIntA(a, (sizeof(buff)-1),
2625     archive_read_data(a, buff, (sizeof(buff)-1)));
2626   assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
2627                         "assertEqualMem to test equality", buff);
2628
2629   memset(buff, 0, sizeof(buff));
2630   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2631     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
2632   assertEqualIntA(a, (sizeof(buff)-1),
2633     archive_read_data(a, buff, (sizeof(buff)-1)));
2634   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2635                         "</P>\n</BODY>\n</HTML>", buff);
2636
2637   memset(buff, 0, sizeof(buff));
2638   assertEqualIntA(a, 13165,
2639     archive_seek_data(a, 13165, SEEK_SET));
2640   assertEqualIntA(a, (sizeof(buff)-1),
2641     archive_read_data(a, buff, (sizeof(buff)-1)));
2642   assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
2643                         "assertEqualMem to test equality", buff);
2644
2645   memset(buff, 0, sizeof(buff));
2646   assertEqualIntA(a, 5371,
2647     archive_seek_data(a, 5371, SEEK_SET));
2648   assertEqualIntA(a, (sizeof(buff)-1),
2649     archive_read_data(a, buff, (sizeof(buff)-1)));
2650   assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
2651                         "/* ... setup omitted ... */\n&nbsp; ", buff);
2652
2653   memset(buff, 0, sizeof(buff));
2654   assertEqualIntA(a, 0,
2655     archive_seek_data(a, 0, SEEK_SET));
2656   assertEqualIntA(a, (sizeof(buff)-1),
2657     archive_read_data(a, buff, (sizeof(buff)-1)));
2658   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2659                         "Transitional//EN\">\n", buff);
2660
2661   memset(buff, 0, sizeof(buff));
2662   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2663     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
2664   assertEqualIntA(a, (sizeof(buff)-1),
2665     archive_read_data(a, buff, (sizeof(buff)-1)));
2666   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2667                         "</P>\n</BODY>\n</HTML>", buff);
2668
2669   memset(buff, 0, sizeof(buff));
2670   assertEqualIntA(a, 5371,
2671     archive_seek_data(a, 5371, SEEK_SET));
2672   assertEqualIntA(a, (sizeof(buff)-1),
2673     archive_read_data(a, buff, (sizeof(buff)-1)));
2674   assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
2675                         "/* ... setup omitted ... */\n&nbsp; ", buff);
2676
2677   memset(buff, 0, sizeof(buff));
2678   assertEqualIntA(a, 13165,
2679     archive_seek_data(a, 13165, SEEK_SET));
2680   assertEqualIntA(a, (sizeof(buff)-1),
2681     archive_read_data(a, buff, (sizeof(buff)-1)));
2682   assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
2683                         "assertEqualMem to test equality", buff);
2684
2685   memset(buff, 0, sizeof(buff));
2686   assertEqualIntA(a, 0,
2687     archive_seek_data(a, 0, SEEK_SET));
2688   assertEqualIntA(a, (sizeof(buff)-1),
2689     archive_read_data(a, buff, (sizeof(buff)-1)));
2690   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2691                         "Transitional//EN\">\n", buff);
2692
2693   memset(buff, 0, sizeof(buff));
2694   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2695     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
2696   assertEqualIntA(a, (sizeof(buff)-1),
2697     archive_read_data(a, buff, (sizeof(buff)-1)));
2698   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2699                         "</P>\n</BODY>\n</HTML>", buff);
2700
2701   memset(buff, 0, sizeof(buff));
2702   assertEqualIntA(a, 0,
2703     archive_seek_data(a, 0, SEEK_SET));
2704   assertEqualIntA(a, (sizeof(buff)-1),
2705     archive_read_data(a, buff, (sizeof(buff)-1)));
2706   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2707                         "Transitional//EN\">\n", buff);
2708
2709   memset(buff, 0, sizeof(buff));
2710   assertEqualIntA(a, 13165,
2711     archive_seek_data(a, 13165, SEEK_SET));
2712   assertEqualIntA(a, (sizeof(buff)-1),
2713     archive_read_data(a, buff, (sizeof(buff)-1)));
2714   assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
2715                         "assertEqualMem to test equality", buff);
2716
2717   memset(buff, 0, sizeof(buff));
2718   assertEqualIntA(a, 5371,
2719     archive_seek_data(a, 5371, SEEK_SET));
2720   assertEqualIntA(a, (sizeof(buff)-1),
2721     archive_read_data(a, buff, (sizeof(buff)-1)));
2722   assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
2723                         "/* ... setup omitted ... */\n&nbsp; ", buff);
2724
2725   /* Test that SEEK_CUR works correctly between data blocks */
2726   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
2727   memset(buff, 0, sizeof(buff));
2728   assertEqualIntA(a, 5371,
2729     archive_seek_data(a, 5371, SEEK_CUR));
2730   assertEqualIntA(a, (sizeof(buff)-1),
2731     archive_read_data(a, buff, (sizeof(buff)-1)));
2732   assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
2733                         "/* ... setup omitted ... */\n&nbsp; ", buff);
2734
2735   memset(buff, 0, sizeof(buff));
2736   assertEqualIntA(a, 13165,
2737     archive_seek_data(a, 7731, SEEK_CUR));
2738   assertEqualIntA(a, (sizeof(buff)-1),
2739     archive_read_data(a, buff, (sizeof(buff)-1)));
2740   assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
2741                         "assertEqualMem to test equality", buff);
2742
2743   memset(buff, 0, sizeof(buff));
2744   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2745     archive_seek_data(a, 6820, SEEK_CUR));
2746   assertEqualIntA(a, (sizeof(buff)-1),
2747     archive_read_data(a, buff, (sizeof(buff)-1)));
2748   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2749                         "</P>\n</BODY>\n</HTML>", buff);
2750
2751   memset(buff, 0, sizeof(buff));
2752   assertEqualIntA(a, 13165,
2753     archive_seek_data(a, -6946, SEEK_CUR));
2754   assertEqualIntA(a, (sizeof(buff)-1),
2755     archive_read_data(a, buff, (sizeof(buff)-1)));
2756   assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
2757                         "assertEqualMem to test equality", buff);
2758
2759   memset(buff, 0, sizeof(buff));
2760   assertEqualIntA(a, 5371,
2761     archive_seek_data(a, -7857, SEEK_CUR));
2762   assertEqualIntA(a, (sizeof(buff)-1),
2763     archive_read_data(a, buff, (sizeof(buff)-1)));
2764   assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
2765                         "/* ... setup omitted ... */\n&nbsp; ", buff);
2766
2767   memset(buff, 0, sizeof(buff));
2768   assertEqualIntA(a, 0,
2769     archive_seek_data(a, -5434, SEEK_CUR));
2770   assertEqualIntA(a, (sizeof(buff)-1),
2771     archive_read_data(a, buff, (sizeof(buff)-1)));
2772   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2773                         "Transitional//EN\">\n", buff);
2774
2775   memset(buff, 0, sizeof(buff));
2776   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2777     archive_seek_data(a, 19985, SEEK_CUR));
2778   assertEqualIntA(a, (sizeof(buff)-1),
2779     archive_read_data(a, buff, (sizeof(buff)-1)));
2780   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2781                         "</P>\n</BODY>\n</HTML>", buff);
2782
2783   memset(buff, 0, sizeof(buff));
2784   assertEqualIntA(a, 5371,
2785     archive_seek_data(a, -14740, SEEK_CUR));
2786   assertEqualIntA(a, (sizeof(buff)-1),
2787     archive_read_data(a, buff, (sizeof(buff)-1)));
2788   assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
2789                         "/* ... setup omitted ... */\n&nbsp; ", buff);
2790
2791   memset(buff, 0, sizeof(buff));
2792   assertEqualIntA(a, 13165,
2793     archive_seek_data(a, 7731, SEEK_CUR));
2794   assertEqualIntA(a, (sizeof(buff)-1),
2795     archive_read_data(a, buff, (sizeof(buff)-1)));
2796   assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
2797                         "assertEqualMem to test equality", buff);
2798
2799   memset(buff, 0, sizeof(buff));
2800   assertEqualIntA(a, 0,
2801     archive_seek_data(a, -13228, SEEK_CUR));
2802   assertEqualIntA(a, (sizeof(buff)-1),
2803     archive_read_data(a, buff, (sizeof(buff)-1)));
2804   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2805                         "Transitional//EN\">\n", buff);
2806
2807   memset(buff, 0, sizeof(buff));
2808   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2809     archive_seek_data(a, 19985, SEEK_CUR));
2810   assertEqualIntA(a, (sizeof(buff)-1),
2811     archive_read_data(a, buff, (sizeof(buff)-1)));
2812   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2813                         "</P>\n</BODY>\n</HTML>", buff);
2814
2815   memset(buff, 0, sizeof(buff));
2816   assertEqualIntA(a, 0,
2817     archive_seek_data(a, -20111, SEEK_CUR));
2818   assertEqualIntA(a, (sizeof(buff)-1),
2819     archive_read_data(a, buff, (sizeof(buff)-1)));
2820   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2821                         "Transitional//EN\">\n", buff);
2822
2823   memset(buff, 0, sizeof(buff));
2824   assertEqualIntA(a, 13165,
2825     archive_seek_data(a, 13102, SEEK_CUR));
2826   assertEqualIntA(a, (sizeof(buff)-1),
2827     archive_read_data(a, buff, (sizeof(buff)-1)));
2828   assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
2829                         "assertEqualMem to test equality", buff);
2830
2831   memset(buff, 0, sizeof(buff));
2832   assertEqualIntA(a, 5371,
2833     archive_seek_data(a, -7857, SEEK_CUR));
2834   assertEqualIntA(a, (sizeof(buff)-1),
2835     archive_read_data(a, buff, (sizeof(buff)-1)));
2836   assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
2837                         "/* ... setup omitted ... */\n&nbsp; ", buff);
2838
2839   /* Test that SEEK_END works correctly between data blocks */
2840   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
2841   memset(buff, 0, sizeof(buff));
2842   assertEqualIntA(a, 5371,
2843     archive_seek_data(a, -14740, SEEK_END));
2844   assertEqualIntA(a, (sizeof(buff)-1),
2845     archive_read_data(a, buff, (sizeof(buff)-1)));
2846   assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
2847                         "/* ... setup omitted ... */\n&nbsp; ", buff);
2848
2849   memset(buff, 0, sizeof(buff));
2850   assertEqualIntA(a, 13165,
2851     archive_seek_data(a, -6946, SEEK_END));
2852   assertEqualIntA(a, (sizeof(buff)-1),
2853     archive_read_data(a, buff, (sizeof(buff)-1)));
2854   assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
2855                         "assertEqualMem to test equality", buff);
2856
2857   memset(buff, 0, sizeof(buff));
2858   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2859     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
2860   assertEqualIntA(a, (sizeof(buff)-1),
2861     archive_read_data(a, buff, (sizeof(buff)-1)));
2862   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2863                         "</P>\n</BODY>\n</HTML>", buff);
2864
2865   memset(buff, 0, sizeof(buff));
2866   assertEqualIntA(a, 13165,
2867     archive_seek_data(a, -6946, SEEK_END));
2868   assertEqualIntA(a, (sizeof(buff)-1),
2869     archive_read_data(a, buff, (sizeof(buff)-1)));
2870   assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
2871                         "assertEqualMem to test equality", buff);
2872
2873   memset(buff, 0, sizeof(buff));
2874   assertEqualIntA(a, 5371,
2875     archive_seek_data(a, -14740, SEEK_END));
2876   assertEqualIntA(a, (sizeof(buff)-1),
2877     archive_read_data(a, buff, (sizeof(buff)-1)));
2878   assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
2879                         "/* ... setup omitted ... */\n&nbsp; ", buff);
2880
2881   memset(buff, 0, sizeof(buff));
2882   assertEqualIntA(a, 0,
2883     archive_seek_data(a, -20111, SEEK_END));
2884   assertEqualIntA(a, (sizeof(buff)-1),
2885     archive_read_data(a, buff, (sizeof(buff)-1)));
2886   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2887                         "Transitional//EN\">\n", buff);
2888
2889   memset(buff, 0, sizeof(buff));
2890   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2891     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
2892   assertEqualIntA(a, (sizeof(buff)-1),
2893     archive_read_data(a, buff, (sizeof(buff)-1)));
2894   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2895                         "</P>\n</BODY>\n</HTML>", buff);
2896
2897   memset(buff, 0, sizeof(buff));
2898   assertEqualIntA(a, 5371,
2899     archive_seek_data(a, -14740, SEEK_END));
2900   assertEqualIntA(a, (sizeof(buff)-1),
2901     archive_read_data(a, buff, (sizeof(buff)-1)));
2902   assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
2903                         "/* ... setup omitted ... */\n&nbsp; ", buff);
2904
2905   memset(buff, 0, sizeof(buff));
2906   assertEqualIntA(a, 13165,
2907     archive_seek_data(a, -6946, SEEK_END));
2908   assertEqualIntA(a, (sizeof(buff)-1),
2909     archive_read_data(a, buff, (sizeof(buff)-1)));
2910   assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
2911                         "assertEqualMem to test equality", buff);
2912
2913   memset(buff, 0, sizeof(buff));
2914   assertEqualIntA(a, 0,
2915     archive_seek_data(a, -20111, SEEK_END));
2916   assertEqualIntA(a, (sizeof(buff)-1),
2917     archive_read_data(a, buff, (sizeof(buff)-1)));
2918   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2919                         "Transitional//EN\">\n", buff);
2920
2921   memset(buff, 0, sizeof(buff));
2922   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2923     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
2924   assertEqualIntA(a, (sizeof(buff)-1),
2925     archive_read_data(a, buff, (sizeof(buff)-1)));
2926   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2927                         "</P>\n</BODY>\n</HTML>", buff);
2928
2929   memset(buff, 0, sizeof(buff));
2930   assertEqualIntA(a, 0,
2931     archive_seek_data(a, -20111, SEEK_END));
2932   assertEqualIntA(a, (sizeof(buff)-1),
2933     archive_read_data(a, buff, (sizeof(buff)-1)));
2934   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2935                         "Transitional//EN\">\n", buff);
2936
2937   memset(buff, 0, sizeof(buff));
2938   assertEqualIntA(a, 13165,
2939     archive_seek_data(a, -6946, SEEK_END));
2940   assertEqualIntA(a, (sizeof(buff)-1),
2941     archive_read_data(a, buff, (sizeof(buff)-1)));
2942   assertEqualStringA(a, "rtEqualInt,\n\tassertEqualString, "
2943                         "assertEqualMem to test equality", buff);
2944
2945   memset(buff, 0, sizeof(buff));
2946   assertEqualIntA(a, 5371,
2947     archive_seek_data(a, -14740, SEEK_END));
2948   assertEqualIntA(a, (sizeof(buff)-1),
2949     archive_read_data(a, buff, (sizeof(buff)-1)));
2950   assertEqualStringA(a, "zip)\n&nbsp; {\n&nbsp; &nbsp; "
2951                         "/* ... setup omitted ... */\n&nbsp; ", buff);
2952
2953   test_read_format_rar_multivolume_uncompressed_files_helper(a);
2954
2955   /*
2956    * Fifth header.
2957    */
2958   assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
2959   assertEqualStringA(a, "testdir/testsubdir/LibarchiveAddingTest.html",
2960                      archive_entry_pathname(ae));
2961   assertA((int)archive_entry_mtime(ae));
2962   assertA((int)archive_entry_ctime(ae));
2963   assertA((int)archive_entry_atime(ae));
2964   assertEqualIntA(a, 20111, archive_entry_size(ae));
2965   assertEqualIntA(a, 33188, archive_entry_mode(ae));
2966   assertEqualInt(archive_entry_is_encrypted(ae), 0);
2967   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
2968
2969   test_read_format_rar_multivolume_uncompressed_files_helper(a);
2970
2971   /* Read from the beginning to the end of the file */
2972   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
2973   do
2974   {
2975     memset(buff, 0, sizeof(buff));
2976     bytes_read = archive_read_data(a, buff, (sizeof(buff)-1));
2977   } while (bytes_read > 0);
2978
2979   /* Seek to the end minus (sizeof(buff)-1) bytes */
2980   memset(buff, 0, sizeof(buff));
2981   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
2982     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
2983   assertEqualIntA(a, (sizeof(buff)-1),
2984     archive_read_data(a, buff, (sizeof(buff)-1)));
2985   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
2986                         "</P>\n</BODY>\n</HTML>", buff);
2987
2988   /* Seek back to the beginning */
2989   memset(buff, 0, sizeof(buff));
2990   assertEqualIntA(a, 0, archive_seek_data(a, -20111, SEEK_END));
2991   assertEqualIntA(a, (sizeof(buff)-1),
2992     archive_read_data(a, buff, (sizeof(buff)-1)));
2993   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
2994                         "Transitional//EN\">\n", buff);
2995
2996   /* Test that SEEK_SET works correctly between data blocks */
2997   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
2998   memset(buff, 0, sizeof(buff));
2999   assertEqualIntA(a, 11568,
3000     archive_seek_data(a, 11568, SEEK_SET));
3001   assertEqualIntA(a, (sizeof(buff)-1),
3002     archive_read_data(a, buff, (sizeof(buff)-1)));
3003   assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
3004                         "\n\t<TT CLASS=\"west", buff);
3005
3006   memset(buff, 0, sizeof(buff));
3007   assertEqualIntA(a, 0,
3008     archive_seek_data(a, 0, SEEK_SET));
3009   assertEqualIntA(a, (sizeof(buff)-1),
3010     archive_read_data(a, buff, (sizeof(buff)-1)));
3011   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3012                         "Transitional//EN\">\n", buff);
3013
3014   memset(buff, 0, sizeof(buff));
3015   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3016     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
3017   assertEqualIntA(a, (sizeof(buff)-1),
3018     archive_read_data(a, buff, (sizeof(buff)-1)));
3019   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3020                         "</P>\n</BODY>\n</HTML>", buff);
3021
3022   memset(buff, 0, sizeof(buff));
3023   assertEqualIntA(a, 11568,
3024     archive_seek_data(a, 11568, SEEK_SET));
3025   assertEqualIntA(a, (sizeof(buff)-1),
3026     archive_read_data(a, buff, (sizeof(buff)-1)));
3027   assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
3028                         "\n\t<TT CLASS=\"west", buff);
3029
3030   memset(buff, 0, sizeof(buff));
3031   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3032     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
3033   assertEqualIntA(a, (sizeof(buff)-1),
3034     archive_read_data(a, buff, (sizeof(buff)-1)));
3035   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3036                         "</P>\n</BODY>\n</HTML>", buff);
3037
3038   memset(buff, 0, sizeof(buff));
3039   assertEqualIntA(a, 0,
3040     archive_seek_data(a, 0, SEEK_SET));
3041   assertEqualIntA(a, (sizeof(buff)-1),
3042     archive_read_data(a, buff, (sizeof(buff)-1)));
3043   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3044                         "Transitional//EN\">\n", buff);
3045
3046   memset(buff, 0, sizeof(buff));
3047   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3048     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
3049   assertEqualIntA(a, (sizeof(buff)-1),
3050     archive_read_data(a, buff, (sizeof(buff)-1)));
3051   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3052                         "</P>\n</BODY>\n</HTML>", buff);
3053
3054   memset(buff, 0, sizeof(buff));
3055   assertEqualIntA(a, 11568,
3056     archive_seek_data(a, 11568, SEEK_SET));
3057   assertEqualIntA(a, (sizeof(buff)-1),
3058     archive_read_data(a, buff, (sizeof(buff)-1)));
3059   assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
3060                         "\n\t<TT CLASS=\"west", buff);
3061
3062   memset(buff, 0, sizeof(buff));
3063   assertEqualIntA(a, 0,
3064     archive_seek_data(a, 0, SEEK_SET));
3065   assertEqualIntA(a, (sizeof(buff)-1),
3066     archive_read_data(a, buff, (sizeof(buff)-1)));
3067   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3068                         "Transitional//EN\">\n", buff);
3069
3070   /* Test that SEEK_CUR works correctly between data blocks */
3071   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
3072   memset(buff, 0, sizeof(buff));
3073   assertEqualIntA(a, 11568,
3074     archive_seek_data(a, 11568, SEEK_CUR));
3075   assertEqualIntA(a, (sizeof(buff)-1),
3076     archive_read_data(a, buff, (sizeof(buff)-1)));
3077   assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
3078                         "\n\t<TT CLASS=\"west", buff);
3079
3080   memset(buff, 0, sizeof(buff));
3081   assertEqualIntA(a, 0,
3082     archive_seek_data(a, -11631, SEEK_CUR));
3083   assertEqualIntA(a, (sizeof(buff)-1),
3084     archive_read_data(a, buff, (sizeof(buff)-1)));
3085   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3086                         "Transitional//EN\">\n", buff);
3087
3088   memset(buff, 0, sizeof(buff));
3089   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3090     archive_seek_data(a, 19985, SEEK_CUR));
3091   assertEqualIntA(a, (sizeof(buff)-1),
3092     archive_read_data(a, buff, (sizeof(buff)-1)));
3093   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3094                         "</P>\n</BODY>\n</HTML>", buff);
3095
3096   memset(buff, 0, sizeof(buff));
3097   assertEqualIntA(a, 11568,
3098     archive_seek_data(a, -8543, SEEK_CUR));
3099   assertEqualIntA(a, (sizeof(buff)-1),
3100     archive_read_data(a, buff, (sizeof(buff)-1)));
3101   assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
3102                         "\n\t<TT CLASS=\"west", buff);
3103
3104   memset(buff, 0, sizeof(buff));
3105   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3106     archive_seek_data(a, 8417, SEEK_CUR));
3107   assertEqualIntA(a, (sizeof(buff)-1),
3108     archive_read_data(a, buff, (sizeof(buff)-1)));
3109   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3110                         "</P>\n</BODY>\n</HTML>", buff);
3111
3112   memset(buff, 0, sizeof(buff));
3113   assertEqualIntA(a, 0,
3114     archive_seek_data(a, -20111, SEEK_CUR));
3115   assertEqualIntA(a, (sizeof(buff)-1),
3116     archive_read_data(a, buff, (sizeof(buff)-1)));
3117   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3118                         "Transitional//EN\">\n", buff);
3119
3120   memset(buff, 0, sizeof(buff));
3121   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3122     archive_seek_data(a, 19985, SEEK_CUR));
3123   assertEqualIntA(a, (sizeof(buff)-1),
3124     archive_read_data(a, buff, (sizeof(buff)-1)));
3125   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3126                         "</P>\n</BODY>\n</HTML>", buff);
3127
3128   memset(buff, 0, sizeof(buff));
3129   assertEqualIntA(a, 11568,
3130     archive_seek_data(a, -8543, SEEK_CUR));
3131   assertEqualIntA(a, (sizeof(buff)-1),
3132     archive_read_data(a, buff, (sizeof(buff)-1)));
3133   assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
3134                         "\n\t<TT CLASS=\"west", buff);
3135
3136   memset(buff, 0, sizeof(buff));
3137   assertEqualIntA(a, 0,
3138     archive_seek_data(a, -11631, SEEK_CUR));
3139   assertEqualIntA(a, (sizeof(buff)-1),
3140     archive_read_data(a, buff, (sizeof(buff)-1)));
3141   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3142                         "Transitional//EN\">\n", buff);
3143
3144   /* Test that SEEK_END works correctly between data blocks */
3145   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
3146   memset(buff, 0, sizeof(buff));
3147   assertEqualIntA(a, 11568,
3148     archive_seek_data(a, -8543, SEEK_END));
3149   assertEqualIntA(a, (sizeof(buff)-1),
3150     archive_read_data(a, buff, (sizeof(buff)-1)));
3151   assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
3152                         "\n\t<TT CLASS=\"west", buff);
3153
3154   memset(buff, 0, sizeof(buff));
3155   assertEqualIntA(a, 0,
3156     archive_seek_data(a, -20111, SEEK_END));
3157   assertEqualIntA(a, (sizeof(buff)-1),
3158     archive_read_data(a, buff, (sizeof(buff)-1)));
3159   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3160                         "Transitional//EN\">\n", buff);
3161
3162   memset(buff, 0, sizeof(buff));
3163   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3164     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
3165   assertEqualIntA(a, (sizeof(buff)-1),
3166     archive_read_data(a, buff, (sizeof(buff)-1)));
3167   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3168                         "</P>\n</BODY>\n</HTML>", buff);
3169
3170   memset(buff, 0, sizeof(buff));
3171   assertEqualIntA(a, 11568,
3172     archive_seek_data(a, -8543, SEEK_END));
3173   assertEqualIntA(a, (sizeof(buff)-1),
3174     archive_read_data(a, buff, (sizeof(buff)-1)));
3175   assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
3176                         "\n\t<TT CLASS=\"west", buff);
3177
3178   memset(buff, 0, sizeof(buff));
3179   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3180     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
3181   assertEqualIntA(a, (sizeof(buff)-1),
3182     archive_read_data(a, buff, (sizeof(buff)-1)));
3183   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3184                         "</P>\n</BODY>\n</HTML>", buff);
3185
3186   memset(buff, 0, sizeof(buff));
3187   assertEqualIntA(a, 0,
3188     archive_seek_data(a, -20111, SEEK_END));
3189   assertEqualIntA(a, (sizeof(buff)-1),
3190     archive_read_data(a, buff, (sizeof(buff)-1)));
3191   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3192                         "Transitional//EN\">\n", buff);
3193
3194   memset(buff, 0, sizeof(buff));
3195   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3196     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
3197   assertEqualIntA(a, (sizeof(buff)-1),
3198     archive_read_data(a, buff, (sizeof(buff)-1)));
3199   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3200                         "</P>\n</BODY>\n</HTML>", buff);
3201
3202   memset(buff, 0, sizeof(buff));
3203   assertEqualIntA(a, 11568,
3204     archive_seek_data(a, -8543, SEEK_END));
3205   assertEqualIntA(a, (sizeof(buff)-1),
3206     archive_read_data(a, buff, (sizeof(buff)-1)));
3207   assertEqualStringA(a, ", <TT CLASS=\"western\">assertFileContents</TT>,"
3208                         "\n\t<TT CLASS=\"west", buff);
3209
3210   memset(buff, 0, sizeof(buff));
3211   assertEqualIntA(a, 0,
3212     archive_seek_data(a, -20111, SEEK_END));
3213   assertEqualIntA(a, (sizeof(buff)-1),
3214     archive_read_data(a, buff, (sizeof(buff)-1)));
3215   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3216                         "Transitional//EN\">\n", buff);
3217
3218   test_read_format_rar_multivolume_uncompressed_files_helper(a);
3219
3220   /*
3221    * Sixth header.
3222    */
3223   assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
3224   assertEqualStringA(a, "LibarchiveAddingTest.html",
3225                      archive_entry_pathname(ae));
3226   assertA((int)archive_entry_mtime(ae));
3227   assertA((int)archive_entry_ctime(ae));
3228   assertA((int)archive_entry_atime(ae));
3229   assertEqualIntA(a, 20111, archive_entry_size(ae));
3230   assertEqualIntA(a, 33188, archive_entry_mode(ae));
3231   assertEqualInt(archive_entry_is_encrypted(ae), 0);
3232   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
3233
3234   test_read_format_rar_multivolume_uncompressed_files_helper(a);
3235
3236   /* Read from the beginning to the end of the file */
3237   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
3238   do
3239   {
3240     memset(buff, 0, sizeof(buff));
3241     bytes_read = archive_read_data(a, buff, (sizeof(buff)-1));
3242   } while (bytes_read > 0);
3243
3244   /* Seek to the end minus (sizeof(buff)-1) bytes */
3245   memset(buff, 0, sizeof(buff));
3246   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3247     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
3248   assertEqualIntA(a, (sizeof(buff)-1),
3249     archive_read_data(a, buff, (sizeof(buff)-1)));
3250   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3251                         "</P>\n</BODY>\n</HTML>", buff);
3252
3253   /* Seek back to the beginning */
3254   memset(buff, 0, sizeof(buff));
3255   assertEqualIntA(a, 0, archive_seek_data(a, -20111, SEEK_END));
3256   assertEqualIntA(a, (sizeof(buff)-1),
3257     archive_read_data(a, buff, (sizeof(buff)-1)));
3258   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3259                         "Transitional//EN\">\n", buff);
3260
3261   /* Test that SEEK_SET works correctly between data blocks */
3262   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
3263   memset(buff, 0, sizeof(buff));
3264   assertEqualIntA(a, 4576,
3265     archive_seek_data(a, 4576, SEEK_SET));
3266   assertEqualIntA(a, (sizeof(buff)-1),
3267     archive_read_data(a, buff, (sizeof(buff)-1)));
3268   assertEqualStringA(a, "hat was expected. \n</P>\n<H1 CLASS=\"western\"><A "
3269                         "NAME=\"Basic_test", buff);
3270
3271   memset(buff, 0, sizeof(buff));
3272   assertEqualIntA(a, 17749,
3273     archive_seek_data(a, 17749, SEEK_SET));
3274   assertEqualIntA(a, (sizeof(buff)-1),
3275     archive_read_data(a, buff, (sizeof(buff)-1)));
3276   assertEqualStringA(a, "\"></A>Large tar tester</H2>\n<P>The "
3277                         "large tar tester attempts to", buff);
3278
3279   memset(buff, 0, sizeof(buff));
3280   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3281     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
3282   assertEqualIntA(a, (sizeof(buff)-1),
3283     archive_read_data(a, buff, (sizeof(buff)-1)));
3284   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3285                         "</P>\n</BODY>\n</HTML>", buff);
3286
3287   memset(buff, 0, sizeof(buff));
3288   assertEqualIntA(a, 17749,
3289     archive_seek_data(a, 17749, SEEK_SET));
3290   assertEqualIntA(a, (sizeof(buff)-1),
3291     archive_read_data(a, buff, (sizeof(buff)-1)));
3292   assertEqualStringA(a, "\"></A>Large tar tester</H2>\n<P>The "
3293                         "large tar tester attempts to", buff);
3294
3295   memset(buff, 0, sizeof(buff));
3296   assertEqualIntA(a, 4576,
3297     archive_seek_data(a, 4576, SEEK_SET));
3298   assertEqualIntA(a, (sizeof(buff)-1),
3299     archive_read_data(a, buff, (sizeof(buff)-1)));
3300   assertEqualStringA(a, "hat was expected. \n</P>\n<H1 CLASS=\"western\"><A "
3301                         "NAME=\"Basic_test", buff);
3302
3303   memset(buff, 0, sizeof(buff));
3304   assertEqualIntA(a, 0,
3305     archive_seek_data(a, 0, SEEK_SET));
3306   assertEqualIntA(a, (sizeof(buff)-1),
3307     archive_read_data(a, buff, (sizeof(buff)-1)));
3308   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3309                         "Transitional//EN\">\n", buff);
3310
3311   memset(buff, 0, sizeof(buff));
3312   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3313     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
3314   assertEqualIntA(a, (sizeof(buff)-1),
3315     archive_read_data(a, buff, (sizeof(buff)-1)));
3316   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3317                         "</P>\n</BODY>\n</HTML>", buff);
3318
3319   memset(buff, 0, sizeof(buff));
3320   assertEqualIntA(a, 4576,
3321     archive_seek_data(a, 4576, SEEK_SET));
3322   assertEqualIntA(a, (sizeof(buff)-1),
3323     archive_read_data(a, buff, (sizeof(buff)-1)));
3324   assertEqualStringA(a, "hat was expected. \n</P>\n<H1 CLASS=\"western\"><A "
3325                         "NAME=\"Basic_test", buff);
3326
3327   memset(buff, 0, sizeof(buff));
3328   assertEqualIntA(a, 17749,
3329     archive_seek_data(a, 17749, SEEK_SET));
3330   assertEqualIntA(a, (sizeof(buff)-1),
3331     archive_read_data(a, buff, (sizeof(buff)-1)));
3332   assertEqualStringA(a, "\"></A>Large tar tester</H2>\n<P>The "
3333                         "large tar tester attempts to", buff);
3334
3335   memset(buff, 0, sizeof(buff));
3336   assertEqualIntA(a, 0,
3337     archive_seek_data(a, 0, SEEK_SET));
3338   assertEqualIntA(a, (sizeof(buff)-1),
3339     archive_read_data(a, buff, (sizeof(buff)-1)));
3340   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3341                         "Transitional//EN\">\n", buff);
3342
3343   memset(buff, 0, sizeof(buff));
3344   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3345     archive_seek_data(a, 20111 - (int)(sizeof(buff)-1), SEEK_SET));
3346   assertEqualIntA(a, (sizeof(buff)-1),
3347     archive_read_data(a, buff, (sizeof(buff)-1)));
3348   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3349                         "</P>\n</BODY>\n</HTML>", buff);
3350
3351   memset(buff, 0, sizeof(buff));
3352   assertEqualIntA(a, 0,
3353     archive_seek_data(a, 0, SEEK_SET));
3354   assertEqualIntA(a, (sizeof(buff)-1),
3355     archive_read_data(a, buff, (sizeof(buff)-1)));
3356   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3357                         "Transitional//EN\">\n", buff);
3358
3359   memset(buff, 0, sizeof(buff));
3360   assertEqualIntA(a, 17749,
3361     archive_seek_data(a, 17749, SEEK_SET));
3362   assertEqualIntA(a, (sizeof(buff)-1),
3363     archive_read_data(a, buff, (sizeof(buff)-1)));
3364   assertEqualStringA(a, "\"></A>Large tar tester</H2>\n<P>The "
3365                         "large tar tester attempts to", buff);
3366
3367   memset(buff, 0, sizeof(buff));
3368   assertEqualIntA(a, 4576,
3369     archive_seek_data(a, 4576, SEEK_SET));
3370   assertEqualIntA(a, (sizeof(buff)-1),
3371     archive_read_data(a, buff, (sizeof(buff)-1)));
3372   assertEqualStringA(a, "hat was expected. \n</P>\n<H1 CLASS=\"western\"><A "
3373                         "NAME=\"Basic_test", buff);
3374
3375   /* Test that SEEK_CUR works correctly between data blocks */
3376   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
3377   memset(buff, 0, sizeof(buff));
3378   assertEqualIntA(a, 4576,
3379     archive_seek_data(a, 4576, SEEK_CUR));
3380   assertEqualIntA(a, (sizeof(buff)-1),
3381     archive_read_data(a, buff, (sizeof(buff)-1)));
3382   assertEqualStringA(a, "hat was expected. \n</P>\n<H1 CLASS=\"western\"><A "
3383                         "NAME=\"Basic_test", buff);
3384
3385   memset(buff, 0, sizeof(buff));
3386   assertEqualIntA(a, 17749,
3387     archive_seek_data(a, 13110, SEEK_CUR));
3388   assertEqualIntA(a, (sizeof(buff)-1),
3389     archive_read_data(a, buff, (sizeof(buff)-1)));
3390   assertEqualStringA(a, "\"></A>Large tar tester</H2>\n<P>The "
3391                         "large tar tester attempts to", buff);
3392
3393   memset(buff, 0, sizeof(buff));
3394   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3395     archive_seek_data(a, 2236, SEEK_CUR));
3396   assertEqualIntA(a, (sizeof(buff)-1),
3397     archive_read_data(a, buff, (sizeof(buff)-1)));
3398   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3399                         "</P>\n</BODY>\n</HTML>", buff);
3400
3401   memset(buff, 0, sizeof(buff));
3402   assertEqualIntA(a, 17749,
3403     archive_seek_data(a, -2362, SEEK_CUR));
3404   assertEqualIntA(a, (sizeof(buff)-1),
3405     archive_read_data(a, buff, (sizeof(buff)-1)));
3406   assertEqualStringA(a, "\"></A>Large tar tester</H2>\n<P>The "
3407                         "large tar tester attempts to", buff);
3408
3409   memset(buff, 0, sizeof(buff));
3410   assertEqualIntA(a, 4576,
3411     archive_seek_data(a, -13236, SEEK_CUR));
3412   assertEqualIntA(a, (sizeof(buff)-1),
3413     archive_read_data(a, buff, (sizeof(buff)-1)));
3414   assertEqualStringA(a, "hat was expected. \n</P>\n<H1 CLASS=\"western\"><A "
3415                         "NAME=\"Basic_test", buff);
3416
3417   memset(buff, 0, sizeof(buff));
3418   assertEqualIntA(a, 0,
3419     archive_seek_data(a, -4639, SEEK_CUR));
3420   assertEqualIntA(a, (sizeof(buff)-1),
3421     archive_read_data(a, buff, (sizeof(buff)-1)));
3422   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3423                         "Transitional//EN\">\n", buff);
3424
3425   memset(buff, 0, sizeof(buff));
3426   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3427     archive_seek_data(a, 19985, SEEK_CUR));
3428   assertEqualIntA(a, (sizeof(buff)-1),
3429     archive_read_data(a, buff, (sizeof(buff)-1)));
3430   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3431                         "</P>\n</BODY>\n</HTML>", buff);
3432
3433   memset(buff, 0, sizeof(buff));
3434   assertEqualIntA(a, 4576,
3435     archive_seek_data(a, -15535, SEEK_CUR));
3436   assertEqualIntA(a, (sizeof(buff)-1),
3437     archive_read_data(a, buff, (sizeof(buff)-1)));
3438   assertEqualStringA(a, "hat was expected. \n</P>\n<H1 CLASS=\"western\"><A "
3439                         "NAME=\"Basic_test", buff);
3440
3441   memset(buff, 0, sizeof(buff));
3442   assertEqualIntA(a, 17749,
3443     archive_seek_data(a, 13110, SEEK_CUR));
3444   assertEqualIntA(a, (sizeof(buff)-1),
3445     archive_read_data(a, buff, (sizeof(buff)-1)));
3446   assertEqualStringA(a, "\"></A>Large tar tester</H2>\n<P>The "
3447                         "large tar tester attempts to", buff);
3448
3449   memset(buff, 0, sizeof(buff));
3450   assertEqualIntA(a, 0,
3451     archive_seek_data(a, -17812, SEEK_CUR));
3452   assertEqualIntA(a, (sizeof(buff)-1),
3453     archive_read_data(a, buff, (sizeof(buff)-1)));
3454   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3455                         "Transitional//EN\">\n", buff);
3456
3457   memset(buff, 0, sizeof(buff));
3458   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3459     archive_seek_data(a, 19985, SEEK_CUR));
3460   assertEqualIntA(a, (sizeof(buff)-1),
3461     archive_read_data(a, buff, (sizeof(buff)-1)));
3462   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3463                         "</P>\n</BODY>\n</HTML>", buff);
3464
3465   memset(buff, 0, sizeof(buff));
3466   assertEqualIntA(a, 0,
3467     archive_seek_data(a, -20111, SEEK_CUR));
3468   assertEqualIntA(a, (sizeof(buff)-1),
3469     archive_read_data(a, buff, (sizeof(buff)-1)));
3470   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3471                         "Transitional//EN\">\n", buff);
3472
3473   memset(buff, 0, sizeof(buff));
3474   assertEqualIntA(a, 17749,
3475     archive_seek_data(a, 17686, SEEK_CUR));
3476   assertEqualIntA(a, (sizeof(buff)-1),
3477     archive_read_data(a, buff, (sizeof(buff)-1)));
3478   assertEqualStringA(a, "\"></A>Large tar tester</H2>\n<P>The "
3479                         "large tar tester attempts to", buff);
3480
3481   memset(buff, 0, sizeof(buff));
3482   assertEqualIntA(a, 4576,
3483     archive_seek_data(a, -13236, SEEK_CUR));
3484   assertEqualIntA(a, (sizeof(buff)-1),
3485     archive_read_data(a, buff, (sizeof(buff)-1)));
3486   assertEqualStringA(a, "hat was expected. \n</P>\n<H1 CLASS=\"western\"><A "
3487                         "NAME=\"Basic_test", buff);
3488
3489   /* Test that SEEK_END works correctly between data blocks */
3490   assertEqualIntA(a, 0, archive_seek_data(a, 0, SEEK_SET));
3491   memset(buff, 0, sizeof(buff));
3492   assertEqualIntA(a, 4576,
3493     archive_seek_data(a, -15535, SEEK_END));
3494   assertEqualIntA(a, (sizeof(buff)-1),
3495     archive_read_data(a, buff, (sizeof(buff)-1)));
3496   assertEqualStringA(a, "hat was expected. \n</P>\n<H1 CLASS=\"western\"><A "
3497                         "NAME=\"Basic_test", buff);
3498
3499   memset(buff, 0, sizeof(buff));
3500   assertEqualIntA(a, 17749,
3501     archive_seek_data(a, -2362, SEEK_END));
3502   assertEqualIntA(a, (sizeof(buff)-1),
3503     archive_read_data(a, buff, (sizeof(buff)-1)));
3504   assertEqualStringA(a, "\"></A>Large tar tester</H2>\n<P>The "
3505                         "large tar tester attempts to", buff);
3506
3507   memset(buff, 0, sizeof(buff));
3508   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3509     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
3510   assertEqualIntA(a, (sizeof(buff)-1),
3511     archive_read_data(a, buff, (sizeof(buff)-1)));
3512   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3513                         "</P>\n</BODY>\n</HTML>", buff);
3514
3515   memset(buff, 0, sizeof(buff));
3516   assertEqualIntA(a, 17749,
3517     archive_seek_data(a, -2362, SEEK_END));
3518   assertEqualIntA(a, (sizeof(buff)-1),
3519     archive_read_data(a, buff, (sizeof(buff)-1)));
3520   assertEqualStringA(a, "\"></A>Large tar tester</H2>\n<P>The "
3521                         "large tar tester attempts to", buff);
3522
3523   memset(buff, 0, sizeof(buff));
3524   assertEqualIntA(a, 4576,
3525     archive_seek_data(a, -15535, SEEK_END));
3526   assertEqualIntA(a, (sizeof(buff)-1),
3527     archive_read_data(a, buff, (sizeof(buff)-1)));
3528   assertEqualStringA(a, "hat was expected. \n</P>\n<H1 CLASS=\"western\"><A "
3529                         "NAME=\"Basic_test", buff);
3530
3531   memset(buff, 0, sizeof(buff));
3532   assertEqualIntA(a, 0,
3533     archive_seek_data(a, -20111, SEEK_END));
3534   assertEqualIntA(a, (sizeof(buff)-1),
3535     archive_read_data(a, buff, (sizeof(buff)-1)));
3536   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3537                         "Transitional//EN\">\n", buff);
3538
3539   memset(buff, 0, sizeof(buff));
3540   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3541     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
3542   assertEqualIntA(a, (sizeof(buff)-1),
3543     archive_read_data(a, buff, (sizeof(buff)-1)));
3544   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3545                         "</P>\n</BODY>\n</HTML>", buff);
3546
3547   memset(buff, 0, sizeof(buff));
3548   assertEqualIntA(a, 4576,
3549     archive_seek_data(a, -15535, SEEK_END));
3550   assertEqualIntA(a, (sizeof(buff)-1),
3551     archive_read_data(a, buff, (sizeof(buff)-1)));
3552   assertEqualStringA(a, "hat was expected. \n</P>\n<H1 CLASS=\"western\"><A "
3553                         "NAME=\"Basic_test", buff);
3554
3555   memset(buff, 0, sizeof(buff));
3556   assertEqualIntA(a, 17749,
3557     archive_seek_data(a, -2362, SEEK_END));
3558   assertEqualIntA(a, (sizeof(buff)-1),
3559     archive_read_data(a, buff, (sizeof(buff)-1)));
3560   assertEqualStringA(a, "\"></A>Large tar tester</H2>\n<P>The "
3561                         "large tar tester attempts to", buff);
3562
3563   memset(buff, 0, sizeof(buff));
3564   assertEqualIntA(a, 0,
3565     archive_seek_data(a, -20111, SEEK_END));
3566   assertEqualIntA(a, (sizeof(buff)-1),
3567     archive_read_data(a, buff, (sizeof(buff)-1)));
3568   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3569                         "Transitional//EN\">\n", buff);
3570
3571   memset(buff, 0, sizeof(buff));
3572   assertEqualIntA(a, 20111 - (int)(sizeof(buff)-1),
3573     archive_seek_data(a, -((int)sizeof(buff)-1), SEEK_END));
3574   assertEqualIntA(a, (sizeof(buff)-1),
3575     archive_read_data(a, buff, (sizeof(buff)-1)));
3576   assertEqualStringA(a, ". \n</P>\n<P STYLE=\"margin-bottom: 0in\"><BR>\n"
3577                         "</P>\n</BODY>\n</HTML>", buff);
3578
3579   memset(buff, 0, sizeof(buff));
3580   assertEqualIntA(a, 0,
3581     archive_seek_data(a, -20111, SEEK_END));
3582   assertEqualIntA(a, (sizeof(buff)-1),
3583     archive_read_data(a, buff, (sizeof(buff)-1)));
3584   assertEqualStringA(a, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 "
3585                         "Transitional//EN\">\n", buff);
3586
3587   memset(buff, 0, sizeof(buff));
3588   assertEqualIntA(a, 17749,
3589     archive_seek_data(a, -2362, SEEK_END));
3590   assertEqualIntA(a, (sizeof(buff)-1),
3591     archive_read_data(a, buff, (sizeof(buff)-1)));
3592   assertEqualStringA(a, "\"></A>Large tar tester</H2>\n<P>The "
3593                         "large tar tester attempts to", buff);
3594
3595   memset(buff, 0, sizeof(buff));
3596   assertEqualIntA(a, 4576,
3597     archive_seek_data(a, -15535, SEEK_END));
3598   assertEqualIntA(a, (sizeof(buff)-1),
3599     archive_read_data(a, buff, (sizeof(buff)-1)));
3600   assertEqualStringA(a, "hat was expected. \n</P>\n<H1 CLASS=\"western\"><A "
3601                         "NAME=\"Basic_test", buff);
3602
3603   test_read_format_rar_multivolume_uncompressed_files_helper(a);
3604
3605   /*
3606    * Seventh header.
3607    */
3608   assertA(0 == archive_read_next_header(a, &ae));
3609   assertEqualString("testdir/testsymlink5", archive_entry_pathname(ae));
3610   assertA((int)archive_entry_mtime(ae));
3611   assertA((int)archive_entry_ctime(ae));
3612   assertA((int)archive_entry_atime(ae));
3613   assertEqualInt(0, archive_entry_size(ae));
3614   assertEqualInt(41471, archive_entry_mode(ae));
3615   assertEqualString("testsubdir/LibarchiveAddingTest.html",
3616     archive_entry_symlink(ae));
3617   assertEqualInt(archive_entry_is_encrypted(ae), 0);
3618   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
3619   assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));
3620
3621   /*
3622    * Eighth header.
3623    */
3624   assertA(0 == archive_read_next_header(a, &ae));
3625   assertEqualString("testdir/testsymlink6", archive_entry_pathname(ae));
3626   assertA((int)archive_entry_mtime(ae));
3627   assertA((int)archive_entry_ctime(ae));
3628   assertA((int)archive_entry_atime(ae));
3629   assertEqualInt(0, archive_entry_size(ae));
3630   assertEqualInt(41471, archive_entry_mode(ae));
3631   assertEqualString("testsubdir/LibarchiveAddingTest2.html",
3632     archive_entry_symlink(ae));
3633   assertEqualInt(archive_entry_is_encrypted(ae), 0);
3634   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
3635   assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));
3636
3637   /*
3638    * Ninth header.
3639    */
3640   assertA(0 == archive_read_next_header(a, &ae));
3641   assertEqualString("testsymlink", archive_entry_pathname(ae));
3642   assertA((int)archive_entry_mtime(ae));
3643   assertA((int)archive_entry_ctime(ae));
3644   assertA((int)archive_entry_atime(ae));
3645   assertEqualInt(0, archive_entry_size(ae));
3646   assertEqualInt(41471, archive_entry_mode(ae));
3647   assertEqualString("testdir/LibarchiveAddingTest.html",
3648     archive_entry_symlink(ae));
3649   assertEqualInt(archive_entry_is_encrypted(ae), 0);
3650   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
3651   assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));
3652
3653   /*
3654    * Tenth header.
3655    */
3656   assertA(0 == archive_read_next_header(a, &ae));
3657   assertEqualString("testsymlink2", archive_entry_pathname(ae));
3658   assertA((int)archive_entry_mtime(ae));
3659   assertA((int)archive_entry_ctime(ae));
3660   assertA((int)archive_entry_atime(ae));
3661   assertEqualInt(0, archive_entry_size(ae));
3662   assertEqualInt(41471, archive_entry_mode(ae));
3663   assertEqualString("testdir/LibarchiveAddingTest2.html",
3664     archive_entry_symlink(ae));
3665   assertEqualInt(archive_entry_is_encrypted(ae), 0);
3666   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
3667   assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));
3668
3669   /*
3670    * Eleventh header.
3671    */
3672   assertA(0 == archive_read_next_header(a, &ae));
3673   assertEqualString("testsymlink3", archive_entry_pathname(ae));
3674   assertA((int)archive_entry_mtime(ae));
3675   assertA((int)archive_entry_ctime(ae));
3676   assertA((int)archive_entry_atime(ae));
3677   assertEqualInt(0, archive_entry_size(ae));
3678   assertEqualInt(41471, archive_entry_mode(ae));
3679   assertEqualString("testdir/testsubdir/LibarchiveAddingTest.html",
3680     archive_entry_symlink(ae));
3681   assertEqualInt(archive_entry_is_encrypted(ae), 0);
3682   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
3683   assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));
3684
3685   /*
3686    * Twelfth header.
3687    */
3688   assertA(0 == archive_read_next_header(a, &ae));
3689   assertEqualString("testsymlink4", archive_entry_pathname(ae));
3690   assertA((int)archive_entry_mtime(ae));
3691   assertA((int)archive_entry_ctime(ae));
3692   assertA((int)archive_entry_atime(ae));
3693   assertEqualInt(0, archive_entry_size(ae));
3694   assertEqualInt(41471, archive_entry_mode(ae));
3695   assertEqualString("testdir/testsubdir/LibarchiveAddingTest2.html",
3696     archive_entry_symlink(ae));
3697   assertEqualInt(archive_entry_is_encrypted(ae), 0);
3698   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
3699   assertEqualIntA(a, 0, archive_read_data(a, buff, sizeof(buff)));
3700
3701   /*
3702    * Thirteenth header.
3703    */
3704   assertA(0 == archive_read_next_header(a, &ae));
3705   assertEqualString("testdir/testemptysubdir", archive_entry_pathname(ae));
3706   assertA((int)archive_entry_mtime(ae));
3707   assertA((int)archive_entry_ctime(ae));
3708   assertA((int)archive_entry_atime(ae));
3709   assertEqualInt(0, archive_entry_size(ae));
3710   assertEqualInt(16877, archive_entry_mode(ae));
3711   assertEqualInt(archive_entry_is_encrypted(ae), 0);
3712   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
3713
3714   /*
3715    * Fourteenth header.
3716    */
3717   assertA(0 == archive_read_next_header(a, &ae));
3718   assertEqualString("testdir/testsubdir", archive_entry_pathname(ae));
3719   assertA((int)archive_entry_mtime(ae));
3720   assertA((int)archive_entry_ctime(ae));
3721   assertA((int)archive_entry_atime(ae));
3722   assertEqualInt(0, archive_entry_size(ae));
3723   assertEqualInt(16877, archive_entry_mode(ae));
3724   assertEqualInt(archive_entry_is_encrypted(ae), 0);
3725   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
3726
3727   /*
3728    * Fifteenth header.
3729    */
3730   assertA(0 == archive_read_next_header(a, &ae));
3731   assertEqualString("testdir", archive_entry_pathname(ae));
3732   assertA((int)archive_entry_mtime(ae));
3733   assertA((int)archive_entry_ctime(ae));
3734   assertA((int)archive_entry_atime(ae));
3735   assertEqualInt(0, archive_entry_size(ae));
3736   assertEqualInt(16877, archive_entry_mode(ae));
3737   assertEqualInt(archive_entry_is_encrypted(ae), 0);
3738   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
3739
3740   /*
3741    * Sixteenth header.
3742    */
3743   assertA(0 == archive_read_next_header(a, &ae));
3744   assertEqualString("testemptydir", archive_entry_pathname(ae));
3745   assertA((int)archive_entry_mtime(ae));
3746   assertA((int)archive_entry_ctime(ae));
3747   assertA((int)archive_entry_atime(ae));
3748   assertEqualInt(0, archive_entry_size(ae));
3749   assertEqualInt(16877, archive_entry_mode(ae));
3750   assertEqualInt(archive_entry_is_encrypted(ae), 0);
3751   assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
3752
3753   /* Test EOF */
3754   assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
3755   assertEqualIntA(a, 16, archive_file_count(a));
3756   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
3757   assertEqualIntA(a, ARCHIVE_OK, archive_read_free(a));
3758 }
3759
3760 DEFINE_TEST(test_read_format_rar_ppmd_use_after_free)
3761 {
3762   uint8_t buf[16];
3763   const char* reffile = "test_read_format_rar_ppmd_use_after_free.rar";
3764
3765   struct archive_entry *ae;
3766   struct archive *a;
3767
3768   extract_reference_file(reffile);
3769   assert((a = archive_read_new()) != NULL);
3770   assertA(0 == archive_read_support_filter_all(a));
3771   assertA(0 == archive_read_support_format_all(a));
3772   assertA(0 == archive_read_open_filename(a, reffile, 10240));
3773
3774   assertA(ARCHIVE_OK == archive_read_next_header(a, &ae));
3775   assertA(archive_read_data(a, buf, sizeof(buf)) <= 0);
3776   assertA(ARCHIVE_OK == archive_read_next_header(a, &ae));
3777   assertA(archive_read_data(a, buf, sizeof(buf)) <= 0);
3778
3779   /* Test EOF */
3780   assertA(1 == archive_read_next_header(a, &ae));
3781
3782   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
3783   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
3784 }
3785
3786 DEFINE_TEST(test_read_format_rar_ppmd_use_after_free2)
3787 {
3788   uint8_t buf[16];
3789   const char* reffile = "test_read_format_rar_ppmd_use_after_free2.rar";
3790
3791   struct archive_entry *ae;
3792   struct archive *a;
3793
3794   extract_reference_file(reffile);
3795   assert((a = archive_read_new()) != NULL);
3796   assertA(0 == archive_read_support_filter_all(a));
3797   assertA(0 == archive_read_support_format_all(a));
3798   assertA(0 == archive_read_open_filename(a, reffile, 10240));
3799
3800   assertA(ARCHIVE_OK == archive_read_next_header(a, &ae));
3801   assertA(archive_read_data(a, buf, sizeof(buf)) <= 0);
3802   assertA(ARCHIVE_OK == archive_read_next_header(a, &ae));
3803   assertA(archive_read_data(a, buf, sizeof(buf)) <= 0);
3804
3805   /* Test EOF */
3806   assertA(1 == archive_read_next_header(a, &ae));
3807
3808   assertEqualIntA(a, ARCHIVE_OK, archive_read_close(a));
3809   assertEqualInt(ARCHIVE_OK, archive_read_free(a));
3810 }