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