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_cpio_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));
61 /* Verify regular file. */
62 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
63 assertEqualString("\xe8\xa1\xa8.txt", archive_entry_pathname(ae));
64 assertEqualInt(4, archive_entry_size(ae));
68 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
70 /* Verify archive format. */
71 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
72 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
74 /* Close the archive. */
75 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
77 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
81 test_read_format_cpio_filename_UTF8_eucJP(const char *refname)
84 struct archive_entry *ae;
87 * Read UTF-8 filename in ja_JP.eucJP with "hdrcharset=UTF-8" option.
89 if (NULL == setlocale(LC_ALL, "ja_JP.eucJP")) {
90 skipping("ja_JP.eucJP locale not available on this system.");
93 assert((a = archive_read_new()) != NULL);
94 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
95 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
96 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
97 skipping("This system cannot convert character-set"
98 " from UTF-8 to eucJP.");
102 assertEqualIntA(a, ARCHIVE_OK,
103 archive_read_open_filename(a, refname, 10240));
105 /* Verify regular file. */
106 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
107 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
108 assertEqualString("\xb4\xc1\xbb\xfa.txt", archive_entry_pathname(ae));
109 assertEqualInt(8, archive_entry_size(ae));
111 /* Verify regular file. */
112 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
113 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
114 assertEqualString("\xc9\xbd.txt", archive_entry_pathname(ae));
115 assertEqualInt(4, archive_entry_size(ae));
118 /* End of archive. */
119 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
121 /* Verify archive format. */
122 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
123 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
125 /* Close the archive. */
126 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
128 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
132 test_read_format_cpio_filename_UTF8_UTF8_jp(const char *refname)
135 struct archive_entry *ae;
138 * Read UTF-8 filename in en_US.UTF-8 without "hdrcharset=UTF-8" option.
140 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
141 skipping("en_US.UTF-8 locale not available on this system.");
145 assert((a = archive_read_new()) != NULL);
146 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
147 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
148 assertEqualIntA(a, ARCHIVE_OK,
149 archive_read_open_filename(a, refname, 10240));
151 /* Verify regular file. */
152 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
153 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
154 assertEqualString("\xe6\xbc\xa2\xe5\xad\x97.txt",
155 archive_entry_pathname(ae));
156 assertEqualInt(8, archive_entry_size(ae));
158 /* Verify regular file. */
159 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
160 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
161 assertEqualString("\xe8\xa1\xa8.txt", archive_entry_pathname(ae));
162 assertEqualInt(4, archive_entry_size(ae));
165 /* End of archive. */
166 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
168 /* Verify archive format. */
169 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
170 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
172 /* Close the archive. */
173 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
174 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
178 test_read_format_cpio_filename_CP866_KOI8R(const char *refname)
181 struct archive_entry *ae;
184 * Read CP866 filename in ru_RU.KOI8-R with "hdrcharset=CP866" option.
186 if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") &&
187 NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
188 skipping("ru_RU.KOI8-R locale not available on this system.");
192 assert((a = archive_read_new()) != NULL);
193 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
194 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
195 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
196 skipping("This system cannot convert character-set"
197 " from CP866 to KOI8-R.");
200 assertEqualIntA(a, ARCHIVE_OK,
201 archive_read_open_filename(a, refname, 10240));
203 /* Verify regular file. */
204 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
205 assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
206 archive_entry_pathname(ae));
207 assertEqualInt(6, archive_entry_size(ae));
209 /* Verify regular file. */
210 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
211 assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
212 archive_entry_pathname(ae));
213 assertEqualInt(6, archive_entry_size(ae));
216 /* End of archive. */
217 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
219 /* Verify archive format. */
220 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
221 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
223 /* Close the archive. */
224 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
226 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
230 test_read_format_cpio_filename_CP866_UTF8(const char *refname)
233 struct archive_entry *ae;
236 * Read CP866 filename in en_US.UTF-8 with "hdrcharset=CP866" option.
238 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
239 skipping("en_US.UTF-8 locale not available on this system.");
243 assert((a = archive_read_new()) != NULL);
244 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
245 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
246 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
247 skipping("This system cannot convert character-set"
248 " from CP866 to UTF-8.");
251 assertEqualIntA(a, ARCHIVE_OK,
252 archive_read_open_filename(a, refname, 10240));
254 /* Verify regular file. */
255 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
256 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
257 archive_entry_pathname(ae));
258 assertEqualInt(6, archive_entry_size(ae));
260 /* Verify regular file. */
261 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
262 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
263 archive_entry_pathname(ae));
264 assertEqualInt(6, archive_entry_size(ae));
267 /* End of archive. */
268 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
270 /* Verify archive format. */
271 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
272 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
274 /* Close the archive. */
275 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
277 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
281 test_read_format_cpio_filename_KOI8R_CP866(const char *refname)
284 struct archive_entry *ae;
287 * Read KOI8-R filename in ru_RU.CP866 with "hdrcharset=KOI8-R" option.
289 if (NULL == setlocale(LC_ALL, "Russian_Russia.866") &&
290 NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
291 skipping("ru_RU.CP866 locale not available on this system.");
295 assert((a = archive_read_new()) != NULL);
296 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
297 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
298 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
299 skipping("This system cannot convert character-set"
300 " from KOI8-R to CP866.");
303 assertEqualIntA(a, ARCHIVE_OK,
304 archive_read_open_filename(a, refname, 10240));
306 /* Verify regular file. */
307 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
308 assertEqualString("\x8f\x90\x88\x82\x85\x92",
309 archive_entry_pathname(ae));
310 assertEqualInt(6, archive_entry_size(ae));
312 /* Verify regular file. */
313 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
314 assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
315 archive_entry_pathname(ae));
316 assertEqualInt(6, archive_entry_size(ae));
319 /* End of archive. */
320 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
322 /* Verify archive format. */
323 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
324 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
326 /* Close the archive. */
327 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
329 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
333 test_read_format_cpio_filename_KOI8R_UTF8(const char *refname)
336 struct archive_entry *ae;
339 * Read KOI8-R filename in en_US.UTF-8 with "hdrcharset=KOI8-R" option.
341 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
342 skipping("en_US.UTF-8 locale not available on this system.");
346 assert((a = archive_read_new()) != NULL);
347 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
348 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
349 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
350 skipping("This system cannot convert character-set"
351 " from KOI8-R to UTF-8.");
354 assertEqualIntA(a, ARCHIVE_OK,
355 archive_read_open_filename(a, refname, 10240));
357 /* Verify regular file. */
358 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
359 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
360 archive_entry_pathname(ae));
361 assertEqualInt(6, archive_entry_size(ae));
363 /* Verify regular file. */
364 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
365 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
366 archive_entry_pathname(ae));
367 assertEqualInt(6, archive_entry_size(ae));
370 /* End of archive. */
371 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
373 /* Verify archive format. */
374 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
375 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
377 /* Close the archive. */
378 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
380 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
384 test_read_format_cpio_filename_UTF8_KOI8R(const char *refname)
387 struct archive_entry *ae;
390 * Read UTF-8 filename in ru_RU.KOI8-R with "hdrcharset=UTF-8" option.
392 if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") &&
393 NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
394 skipping("ru_RU.KOI8-R locale not available on this system.");
398 assert((a = archive_read_new()) != NULL);
399 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
400 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
401 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
402 skipping("This system cannot convert character-set"
403 " from UTF-8 to KOI8-R.");
406 assertEqualIntA(a, ARCHIVE_OK,
407 archive_read_open_filename(a, refname, 10240));
409 /* Verify regular file. */
410 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
411 assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
412 archive_entry_pathname(ae));
413 assertEqualInt(6, archive_entry_size(ae));
415 /* Verify regular file. */
416 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
417 assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
418 archive_entry_pathname(ae));
419 assertEqualInt(6, archive_entry_size(ae));
422 /* End of archive. */
423 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
425 /* Verify archive format. */
426 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
427 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
429 /* Close the archive. */
430 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
432 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
436 test_read_format_cpio_filename_UTF8_CP866(const char *refname)
439 struct archive_entry *ae;
442 * Read UTF-8 filename in ru_RU.CP866 with "hdrcharset=UTF-8" option.
444 if (NULL == setlocale(LC_ALL, "Russian_Russia.866") &&
445 NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
446 skipping("ru_RU.CP866 locale not available on this system.");
450 assert((a = archive_read_new()) != NULL);
451 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
452 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
453 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
454 skipping("This system cannot convert character-set"
455 " from UTF-8 to CP866.");
458 assertEqualIntA(a, ARCHIVE_OK,
459 archive_read_open_filename(a, refname, 10240));
461 /* Verify regular file. */
462 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
463 assertEqualString("\x8f\x90\x88\x82\x85\x92",
464 archive_entry_pathname(ae));
465 assertEqualInt(6, archive_entry_size(ae));
467 /* Verify regular file. */
468 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
469 assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
470 archive_entry_pathname(ae));
471 assertEqualInt(6, archive_entry_size(ae));
474 /* End of archive. */
475 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
477 /* Verify archive format. */
478 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
479 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
481 /* Close the archive. */
482 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
484 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
488 test_read_format_cpio_filename_UTF8_UTF8_ru(const char *refname)
491 struct archive_entry *ae;
494 * Read UTF-8 filename in en_US.UTF-8 without "hdrcharset=UTF-8" option.
496 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
497 skipping("en_US.UTF-8 locale not available on this system.");
501 assert((a = archive_read_new()) != NULL);
502 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
503 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
504 assertEqualIntA(a, ARCHIVE_OK,
505 archive_read_open_filename(a, refname, 10240));
507 /* Verify regular file. */
508 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
509 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
510 archive_entry_pathname(ae));
511 assertEqualInt(6, archive_entry_size(ae));
513 /* Verify regular file. */
514 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
515 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
516 archive_entry_pathname(ae));
517 assertEqualInt(6, archive_entry_size(ae));
520 /* End of archive. */
521 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
523 /* Verify archive format. */
524 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
525 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
527 /* Close the archive. */
528 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
529 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
533 test_read_format_cpio_filename_eucJP_CP932(const char *refname)
536 struct archive_entry *ae;
539 * Read eucJP filename in CP932/SJIS with "hdrcharset=eucJP" option.
541 if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
542 NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
543 skipping("CP932 locale not available on this system.");
547 assert((a = archive_read_new()) != NULL);
548 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
549 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
550 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=eucJP")) {
551 skipping("This system cannot convert character-set"
555 assertEqualIntA(a, ARCHIVE_OK,
556 archive_read_open_filename(a, refname, 10240));
558 /* Verify regular file. */
559 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
560 assertEqualString("\x8a\xbf\x8e\x9a.txt", archive_entry_pathname(ae));
561 assertEqualInt(8, archive_entry_size(ae));
563 /* Verify regular file. */
564 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
565 assertEqualString("\x95\x5c.txt", archive_entry_pathname(ae));
566 assertEqualInt(4, archive_entry_size(ae));
569 /* End of archive. */
570 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
572 /* Verify archive format. */
573 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
574 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
576 /* Close the archive. */
577 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
579 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
583 test_read_format_cpio_filename_UTF8_CP932(const char *refname)
586 struct archive_entry *ae;
589 * Read UTF-8 filename in CP932/SJIS with "hdrcharset=UTF-8" option.
591 if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
592 NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
593 skipping("CP932 locale not available on this system.");
597 assert((a = archive_read_new()) != NULL);
598 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
599 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
600 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
601 skipping("This system cannot convert character-set"
602 " from UTF-8 to CP932.");
605 assertEqualIntA(a, ARCHIVE_OK,
606 archive_read_open_filename(a, refname, 10240));
608 /* Verify regular file. */
609 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
610 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
611 assertEqualString("\x8a\xbf\x8e\x9a.txt", archive_entry_pathname(ae));
612 assertEqualInt(8, archive_entry_size(ae));
614 /* Verify regular file. */
615 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
616 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
617 assertEqualString("\x95\x5c.txt", archive_entry_pathname(ae));
618 assertEqualInt(4, archive_entry_size(ae));
620 /* End of archive. */
621 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
623 /* Verify archive format. */
624 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
625 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
627 /* Close the archive. */
628 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
630 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
634 test_read_format_cpio_filename_CP866_CP1251(const char *refname)
637 struct archive_entry *ae;
640 * Read CP866 filename in CP1251 with "hdrcharset=CP866" option.
642 if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
643 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
644 skipping("CP1251 locale not available on this system.");
648 assert((a = archive_read_new()) != NULL);
649 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
650 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
651 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
652 skipping("This system cannot convert character-set"
653 " from CP866 to CP1251.");
656 assertEqualIntA(a, ARCHIVE_OK,
657 archive_read_open_filename(a, refname, 10240));
659 /* Verify regular file. */
660 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
661 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
662 archive_entry_pathname(ae));
663 assertEqualInt(6, archive_entry_size(ae));
665 /* Verify regular file. */
666 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
667 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
668 archive_entry_pathname(ae));
669 assertEqualInt(6, archive_entry_size(ae));
672 /* End of archive. */
673 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
675 /* Verify archive format. */
676 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
677 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
679 /* Close the archive. */
680 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
682 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
686 * This test only for Windows platform because other archiver
687 * applications on Windows translate CP1251 filenames into CP866
688 * filenames and store it in the cpio file and so we should read
689 * it by default on Windows.
692 test_read_format_cpio_filename_CP866_CP1251_win(const char *refname)
695 struct archive_entry *ae;
698 * Read CP866 filename in CP1251 without "hdrcharset=CP866" option.
700 if (NULL == setlocale(LC_ALL, "Russian_Russia")) {
701 skipping("Russian_Russia locale not available on this system.");
705 assert((a = archive_read_new()) != NULL);
706 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
707 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
708 assertEqualIntA(a, ARCHIVE_OK,
709 archive_read_open_filename(a, refname, 10240));
711 /* Verify regular file. */
712 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
713 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
714 archive_entry_pathname(ae));
715 assertEqualInt(6, archive_entry_size(ae));
717 /* Verify regular file. */
718 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
719 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
720 archive_entry_pathname(ae));
721 assertEqualInt(6, archive_entry_size(ae));
724 /* End of archive. */
725 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
727 /* Verify archive format. */
728 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
729 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
731 /* Close the archive. */
732 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
733 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
737 test_read_format_cpio_filename_KOI8R_CP1251(const char *refname)
740 struct archive_entry *ae;
743 * Read KOI8-R filename in CP1251 with "hdrcharset=KOI8-R" option.
745 if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
746 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
747 skipping("CP1251 locale not available on this system.");
751 assert((a = archive_read_new()) != NULL);
752 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
753 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
754 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
755 skipping("This system cannot convert character-set"
756 " from KOI8-R to CP1251.");
759 assertEqualIntA(a, ARCHIVE_OK,
760 archive_read_open_filename(a, refname, 10240));
762 /* Verify regular file. */
763 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
764 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
765 archive_entry_pathname(ae));
766 assertEqualInt(6, archive_entry_size(ae));
768 /* Verify regular file. */
769 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
770 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
771 archive_entry_pathname(ae));
772 assertEqualInt(6, archive_entry_size(ae));
775 /* End of archive. */
776 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
778 /* Verify archive format. */
779 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
780 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
782 /* Close the archive. */
783 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
785 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
789 test_read_format_cpio_filename_UTF8_CP1251(const char *refname)
792 struct archive_entry *ae;
795 * Read KOI8-R filename in CP1251 with "hdrcharset=KOI8-R" option.
797 if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
798 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
799 skipping("CP1251 locale not available on this system.");
803 assert((a = archive_read_new()) != NULL);
804 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
805 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
806 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
807 skipping("This system cannot convert character-set"
808 " from UTF-8 to CP1251.");
811 assertEqualIntA(a, ARCHIVE_OK,
812 archive_read_open_filename(a, refname, 10240));
814 /* Verify regular file. */
815 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
816 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
817 archive_entry_pathname(ae));
818 assertEqualInt(6, archive_entry_size(ae));
820 /* Verify regular file. */
821 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
822 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
823 archive_entry_pathname(ae));
824 assertEqualInt(6, archive_entry_size(ae));
827 /* End of archive. */
828 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
830 /* Verify archive format. */
831 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
832 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
834 /* Close the archive. */
835 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
837 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
841 DEFINE_TEST(test_read_format_cpio_filename)
843 const char *refname1 = "test_read_format_cpio_filename_eucjp.cpio";
844 const char *refname2 = "test_read_format_cpio_filename_utf8_jp.cpio";
845 const char *refname3 = "test_read_format_cpio_filename_cp866.cpio";
846 const char *refname4 = "test_read_format_cpio_filename_koi8r.cpio";
847 const char *refname5 = "test_read_format_cpio_filename_utf8_ru.cpio";
849 extract_reference_file(refname1);
850 test_read_format_cpio_filename_eucJP_UTF8(refname1);
851 test_read_format_cpio_filename_eucJP_CP932(refname1);
853 extract_reference_file(refname2);
854 test_read_format_cpio_filename_UTF8_eucJP(refname2);
855 test_read_format_cpio_filename_UTF8_UTF8_jp(refname2);
856 test_read_format_cpio_filename_UTF8_CP932(refname2);
858 extract_reference_file(refname3);
859 test_read_format_cpio_filename_CP866_KOI8R(refname3);
860 test_read_format_cpio_filename_CP866_UTF8(refname3);
861 test_read_format_cpio_filename_CP866_CP1251(refname3);
862 test_read_format_cpio_filename_CP866_CP1251_win(refname3);
864 extract_reference_file(refname4);
865 test_read_format_cpio_filename_KOI8R_CP866(refname4);
866 test_read_format_cpio_filename_KOI8R_UTF8(refname4);
867 test_read_format_cpio_filename_KOI8R_CP1251(refname4);
869 extract_reference_file(refname5);
870 test_read_format_cpio_filename_UTF8_KOI8R(refname5);
871 test_read_format_cpio_filename_UTF8_CP866(refname5);
872 test_read_format_cpio_filename_UTF8_UTF8_ru(refname5);
873 test_read_format_cpio_filename_UTF8_CP1251(refname5);