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