2 * Copyright (c) 2011 Michihiro NAKAJIMA
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 test_read_format_ustar_filename_eucJP_UTF8(const char *refname)
34 struct archive_entry *ae;
37 * Read eucJP filename in en_US.UTF-8 with "hdrcharset=eucJP" option.
39 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
40 skipping("en_US.UTF-8 locale not available on this system.");
44 assert((a = archive_read_new()) != NULL);
45 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
46 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
47 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=eucJP")) {
48 skipping("This system cannot convert character-set"
49 " from eucJP to UTF-8.");
52 assertEqualIntA(a, ARCHIVE_OK,
53 archive_read_open_filename(a, refname, 10240));
55 /* Verify regular file. */
56 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
57 assertEqualString("\xe6\xbc\xa2\xe5\xad\x97.txt",
58 archive_entry_pathname(ae));
59 assertEqualInt(8, archive_entry_size(ae));
60 assertEqualInt(archive_entry_is_encrypted(ae), 0);
61 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
63 /* Verify regular file. */
64 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
65 assertEqualString("\xe8\xa1\xa8.txt", archive_entry_pathname(ae));
66 assertEqualInt(4, archive_entry_size(ae));
67 assertEqualInt(archive_entry_is_encrypted(ae), 0);
68 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
72 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
74 /* Verify archive format. */
75 assertEqualIntA(a, ARCHIVE_FILTER_COMPRESS, archive_filter_code(a, 0));
76 assertEqualIntA(a, ARCHIVE_FORMAT_TAR_USTAR, archive_format(a));
78 /* Close the archive. */
79 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
81 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
85 test_read_format_ustar_filename_CP866_KOI8R(const char *refname)
88 struct archive_entry *ae;
91 * Read CP866 filename in ru_RU.KOI8-R with "hdrcharset=CP866" option.
93 if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") &&
94 NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
95 skipping("ru_RU.KOI8-R locale not available on this system.");
99 assert((a = archive_read_new()) != NULL);
100 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
101 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
102 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
103 skipping("This system cannot convert character-set"
104 " from CP866 to KOI8-R.");
107 assertEqualIntA(a, ARCHIVE_OK,
108 archive_read_open_filename(a, refname, 10240));
110 /* Verify regular file. */
111 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
112 assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
113 archive_entry_pathname(ae));
114 assertEqualInt(6, archive_entry_size(ae));
115 assertEqualInt(archive_entry_is_encrypted(ae), 0);
116 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
118 /* Verify regular file. */
119 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
120 assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
121 archive_entry_pathname(ae));
122 assertEqualInt(6, archive_entry_size(ae));
123 assertEqualInt(archive_entry_is_encrypted(ae), 0);
124 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
126 /* End of archive. */
127 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
129 /* Verify archive format. */
130 assertEqualIntA(a, ARCHIVE_FILTER_COMPRESS, archive_filter_code(a, 0));
131 assertEqualIntA(a, ARCHIVE_FORMAT_TAR_USTAR, archive_format(a));
133 /* Close the archive. */
134 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
136 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
140 test_read_format_ustar_filename_CP866_UTF8(const char *refname)
143 struct archive_entry *ae;
146 * Read CP866 filename in en_US.UTF-8 with "hdrcharset=CP866" option.
148 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
149 skipping("en_US.UTF-8 locale not available on this system.");
153 assert((a = archive_read_new()) != NULL);
154 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
155 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
156 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
157 skipping("This system cannot convert character-set"
158 " from CP866 to UTF-8.");
161 assertEqualIntA(a, ARCHIVE_OK,
162 archive_read_open_filename(a, refname, 10240));
164 /* Verify regular file. */
165 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
166 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
167 archive_entry_pathname(ae));
168 assertEqualInt(6, archive_entry_size(ae));
169 assertEqualInt(archive_entry_is_encrypted(ae), 0);
170 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
172 /* Verify regular file. */
173 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
174 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
175 archive_entry_pathname(ae));
176 assertEqualInt(6, archive_entry_size(ae));
177 assertEqualInt(archive_entry_is_encrypted(ae), 0);
178 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
181 /* End of archive. */
182 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
184 /* Verify archive format. */
185 assertEqualIntA(a, ARCHIVE_FILTER_COMPRESS, archive_filter_code(a, 0));
186 assertEqualIntA(a, ARCHIVE_FORMAT_TAR_USTAR, archive_format(a));
188 /* Close the archive. */
189 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
191 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
195 test_read_format_ustar_filename_KOI8R_CP866(const char *refname)
198 struct archive_entry *ae;
201 * Read KOI8-R filename in ru_RU.CP866 with "hdrcharset=KOI8-R" option.
203 if (NULL == setlocale(LC_ALL, "Russian_Russia.866") &&
204 NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
205 skipping("ru_RU.CP866 locale not available on this system.");
209 assert((a = archive_read_new()) != NULL);
210 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
211 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
212 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
213 skipping("This system cannot convert character-set"
214 " from KOI8-R to CP866.");
217 assertEqualIntA(a, ARCHIVE_OK,
218 archive_read_open_filename(a, refname, 10240));
220 /* Verify regular file. */
221 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
222 assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
223 archive_entry_pathname(ae));
224 assertEqualInt(6, archive_entry_size(ae));
225 assertEqualInt(archive_entry_is_encrypted(ae), 0);
226 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
228 /* Verify regular file. */
229 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
230 assertEqualString("\x8f\x90\x88\x82\x85\x92",
231 archive_entry_pathname(ae));
232 assertEqualInt(6, archive_entry_size(ae));
233 assertEqualInt(archive_entry_is_encrypted(ae), 0);
234 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
237 /* End of archive. */
238 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
240 /* Verify archive format. */
241 assertEqualIntA(a, ARCHIVE_FILTER_COMPRESS, archive_filter_code(a, 0));
242 assertEqualIntA(a, ARCHIVE_FORMAT_TAR_USTAR, archive_format(a));
244 /* Close the archive. */
245 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
247 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
251 test_read_format_ustar_filename_KOI8R_UTF8(const char *refname)
254 struct archive_entry *ae;
257 * Read KOI8-R filename in en_US.UTF-8 with "hdrcharset=KOI8-R" option.
259 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
260 skipping("en_US.UTF-8 locale not available on this system.");
264 assert((a = archive_read_new()) != NULL);
265 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
266 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
267 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
268 skipping("This system cannot convert character-set"
269 " from KOI8-R to UTF-8.");
272 assertEqualIntA(a, ARCHIVE_OK,
273 archive_read_open_filename(a, refname, 10240));
275 /* Verify regular file. */
276 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
277 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
278 archive_entry_pathname(ae));
279 assertEqualInt(6, archive_entry_size(ae));
280 assertEqualInt(archive_entry_is_encrypted(ae), 0);
281 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
283 /* Verify regular file. */
284 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
285 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
286 archive_entry_pathname(ae));
287 assertEqualInt(6, archive_entry_size(ae));
288 assertEqualInt(archive_entry_is_encrypted(ae), 0);
289 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
292 /* End of archive. */
293 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
295 /* Verify archive format. */
296 assertEqualIntA(a, ARCHIVE_FILTER_COMPRESS, archive_filter_code(a, 0));
297 assertEqualIntA(a, ARCHIVE_FORMAT_TAR_USTAR, archive_format(a));
299 /* Close the archive. */
300 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
302 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
306 test_read_format_ustar_filename_eucJP_CP932(const char *refname)
309 struct archive_entry *ae;
312 * Read eucJP filename in CP932/SJIS with "hdrcharset=eucJP" option.
314 if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
315 NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
316 skipping("CP932 locale not available on this system.");
320 assert((a = archive_read_new()) != NULL);
321 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
322 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
323 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=eucJP")) {
324 skipping("This system cannot convert character-set"
328 assertEqualIntA(a, ARCHIVE_OK,
329 archive_read_open_filename(a, refname, 10240));
331 /* Verify regular file. */
332 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
333 assertEqualString("\x8a\xbf\x8e\x9a.txt", archive_entry_pathname(ae));
334 assertEqualInt(8, archive_entry_size(ae));
335 assertEqualInt(archive_entry_is_encrypted(ae), 0);
336 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
338 /* Verify regular file. */
339 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
340 assertEqualString("\x95\x5c.txt", archive_entry_pathname(ae));
341 assertEqualInt(4, archive_entry_size(ae));
342 assertEqualInt(archive_entry_is_encrypted(ae), 0);
343 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
346 /* End of archive. */
347 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
349 /* Verify archive format. */
350 assertEqualIntA(a, ARCHIVE_FILTER_COMPRESS, archive_filter_code(a, 0));
351 assertEqualIntA(a, ARCHIVE_FORMAT_TAR_USTAR, archive_format(a));
353 /* Close the archive. */
354 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
356 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
360 test_read_format_ustar_filename_CP866_CP1251(const char *refname)
363 struct archive_entry *ae;
366 * Read CP866 filename in CP1251 with "hdrcharset=CP866" option.
368 if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
369 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
370 skipping("CP1251 locale not available on this system.");
374 assert((a = archive_read_new()) != NULL);
375 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
376 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
377 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
378 skipping("This system cannot convert character-set"
379 " from CP866 to CP1251.");
382 assertEqualIntA(a, ARCHIVE_OK,
383 archive_read_open_filename(a, refname, 10240));
385 /* Verify regular file. */
386 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
387 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
388 archive_entry_pathname(ae));
389 assertEqualInt(6, archive_entry_size(ae));
390 assertEqualInt(archive_entry_is_encrypted(ae), 0);
391 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
393 /* Verify regular file. */
394 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
395 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
396 archive_entry_pathname(ae));
397 assertEqualInt(6, archive_entry_size(ae));
398 assertEqualInt(archive_entry_is_encrypted(ae), 0);
399 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
402 /* End of archive. */
403 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
405 /* Verify archive format. */
406 assertEqualIntA(a, ARCHIVE_FILTER_COMPRESS, archive_filter_code(a, 0));
407 assertEqualIntA(a, ARCHIVE_FORMAT_TAR_USTAR, archive_format(a));
409 /* Close the archive. */
410 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
412 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
416 * This test only for Windows platform because other archiver
417 * applications on Windows translate CP1251 filenames into CP866
418 * filenames and store it in the ustar file and so we should read
419 * it by default on Windows.
422 test_read_format_ustar_filename_CP866_CP1251_win(const char *refname)
425 struct archive_entry *ae;
428 * Read CP866 filename in CP1251 without "hdrcharset=CP866" option.
430 if (NULL == setlocale(LC_ALL, "Russian_Russia")) {
431 skipping("Russian_Russia locale not available on this system.");
435 assert((a = archive_read_new()) != NULL);
436 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
437 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
438 assertEqualIntA(a, ARCHIVE_OK,
439 archive_read_open_filename(a, refname, 10240));
441 /* Verify regular file. */
442 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
443 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
444 archive_entry_pathname(ae));
445 assertEqualInt(6, archive_entry_size(ae));
446 assertEqualInt(archive_entry_is_encrypted(ae), 0);
447 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
449 /* Verify regular file. */
450 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
451 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
452 archive_entry_pathname(ae));
453 assertEqualInt(6, archive_entry_size(ae));
454 assertEqualInt(archive_entry_is_encrypted(ae), 0);
455 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
458 /* End of archive. */
459 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
461 /* Verify archive format. */
462 assertEqualIntA(a, ARCHIVE_FILTER_COMPRESS, archive_filter_code(a, 0));
463 assertEqualIntA(a, ARCHIVE_FORMAT_TAR_USTAR, archive_format(a));
465 /* Close the archive. */
466 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
467 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
471 test_read_format_ustar_filename_KOI8R_CP1251(const char *refname)
474 struct archive_entry *ae;
477 * Read KOI8-R filename in CP1251 with "hdrcharset=KOI8-R" option.
479 if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
480 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
481 skipping("CP1251 locale not available on this system.");
485 assert((a = archive_read_new()) != NULL);
486 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
487 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
488 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
489 skipping("This system cannot convert character-set"
490 " from KOI8-R to CP1251.");
493 assertEqualIntA(a, ARCHIVE_OK,
494 archive_read_open_filename(a, refname, 10240));
496 /* Verify regular file. */
497 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
498 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
499 archive_entry_pathname(ae));
500 assertEqualInt(6, archive_entry_size(ae));
501 assertEqualInt(archive_entry_is_encrypted(ae), 0);
502 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
504 /* Verify regular file. */
505 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
506 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
507 archive_entry_pathname(ae));
508 assertEqualInt(6, archive_entry_size(ae));
509 assertEqualInt(archive_entry_is_encrypted(ae), 0);
510 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
513 /* End of archive. */
514 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
516 /* Verify archive format. */
517 assertEqualIntA(a, ARCHIVE_FILTER_COMPRESS, archive_filter_code(a, 0));
518 assertEqualIntA(a, ARCHIVE_FORMAT_TAR_USTAR, archive_format(a));
520 /* Close the archive. */
521 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
523 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
527 DEFINE_TEST(test_read_format_ustar_filename)
529 const char *refname1 = "test_read_format_ustar_filename_eucjp.tar.Z";
530 const char *refname2 = "test_read_format_ustar_filename_cp866.tar.Z";
531 const char *refname3 = "test_read_format_ustar_filename_koi8r.tar.Z";
533 extract_reference_file(refname1);
534 test_read_format_ustar_filename_eucJP_UTF8(refname1);
535 test_read_format_ustar_filename_eucJP_CP932(refname1);
537 extract_reference_file(refname2);
538 test_read_format_ustar_filename_CP866_KOI8R(refname2);
539 test_read_format_ustar_filename_CP866_UTF8(refname2);
540 test_read_format_ustar_filename_CP866_CP1251(refname2);
541 test_read_format_ustar_filename_CP866_CP1251_win(refname2);
543 extract_reference_file(refname3);
544 test_read_format_ustar_filename_KOI8R_CP866(refname3);
545 test_read_format_ustar_filename_KOI8R_UTF8(refname3);
546 test_read_format_ustar_filename_KOI8R_CP1251(refname3);