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