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