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.
30 DEFINE_TEST(test_read_format_cpio_filename_eucJP_UTF8)
32 const char *refname = "test_read_format_cpio_filename_eucjp.cpio";
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.");
43 extract_reference_file(refname);
45 assert((a = archive_read_new()) != NULL);
46 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
47 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
48 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=eucJP")) {
49 skipping("This system cannot convert character-set"
50 " from eucJP to UTF-8.");
53 assertEqualIntA(a, ARCHIVE_OK,
54 archive_read_open_filename(a, refname, 10240));
56 /* Verify regular file. */
57 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
58 assertEqualString("\xe6\xbc\xa2\xe5\xad\x97.txt",
59 archive_entry_pathname(ae));
60 assertEqualInt(8, archive_entry_size(ae));
61 assertEqualInt(archive_entry_is_encrypted(ae), 0);
62 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
64 /* Verify regular file. */
65 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
66 assertEqualString("\xe8\xa1\xa8.txt", archive_entry_pathname(ae));
67 assertEqualInt(4, archive_entry_size(ae));
68 assertEqualInt(archive_entry_is_encrypted(ae), 0);
69 assertEqualIntA(a, archive_read_has_encrypted_entries(a), ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED);
73 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
75 /* Verify archive format. */
76 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
77 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
79 /* Close the archive. */
80 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
82 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
85 DEFINE_TEST(test_read_format_cpio_filename_UTF8_eucJP)
87 const char *refname = "test_read_format_cpio_filename_utf8_jp.cpio";
89 struct archive_entry *ae;
92 * Read UTF-8 filename in ja_JP.eucJP with "hdrcharset=UTF-8" option.
94 if (NULL == setlocale(LC_ALL, "ja_JP.eucJP")) {
95 skipping("ja_JP.eucJP locale not available on this system.");
98 extract_reference_file(refname);
100 assert((a = archive_read_new()) != NULL);
101 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
102 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
103 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
104 skipping("This system cannot convert character-set"
105 " from UTF-8 to eucJP.");
109 assertEqualIntA(a, ARCHIVE_OK,
110 archive_read_open_filename(a, refname, 10240));
112 /* Verify regular file. */
113 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
114 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
115 assertEqualString("\xb4\xc1\xbb\xfa.txt", archive_entry_pathname(ae));
116 assertEqualInt(8, archive_entry_size(ae));
118 /* Verify regular file. */
119 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
120 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
121 assertEqualString("\xc9\xbd.txt", archive_entry_pathname(ae));
122 assertEqualInt(4, archive_entry_size(ae));
125 /* End of archive. */
126 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
128 /* Verify archive format. */
129 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
130 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
132 /* Close the archive. */
133 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
135 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
138 DEFINE_TEST(test_read_format_cpio_filename_UTF8_UTF8_jp)
140 const char *refname = "test_read_format_cpio_filename_utf8_jp.cpio";
142 struct archive_entry *ae;
145 * Read UTF-8 filename in en_US.UTF-8 without "hdrcharset=UTF-8" option.
147 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
148 skipping("en_US.UTF-8 locale not available on this system.");
151 extract_reference_file(refname);
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 assertEqualIntA(a, ARCHIVE_OK,
157 archive_read_open_filename(a, refname, 10240));
159 /* Verify regular file. */
160 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
161 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
162 assertEqualString("\xe6\xbc\xa2\xe5\xad\x97.txt",
163 archive_entry_pathname(ae));
164 assertEqualInt(8, archive_entry_size(ae));
166 /* Verify regular file. */
167 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
168 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
169 assertEqualString("\xe8\xa1\xa8.txt", archive_entry_pathname(ae));
170 assertEqualInt(4, archive_entry_size(ae));
173 /* End of archive. */
174 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
176 /* Verify archive format. */
177 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
178 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
180 /* Close the archive. */
181 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
182 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
185 DEFINE_TEST(test_read_format_cpio_filename_CP866_KOI8R)
187 const char *refname = "test_read_format_cpio_filename_cp866.cpio";
189 struct archive_entry *ae;
192 * Read CP866 filename in ru_RU.KOI8-R with "hdrcharset=CP866" option.
194 if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") &&
195 NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
196 skipping("ru_RU.KOI8-R locale not available on this system.");
199 extract_reference_file(refname);
201 assert((a = archive_read_new()) != NULL);
202 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
203 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
204 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
205 skipping("This system cannot convert character-set"
206 " from CP866 to KOI8-R.");
209 assertEqualIntA(a, ARCHIVE_OK,
210 archive_read_open_filename(a, refname, 10240));
212 /* Verify regular file. */
213 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
214 assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
215 archive_entry_pathname(ae));
216 assertEqualInt(6, archive_entry_size(ae));
218 /* Verify regular file. */
219 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
220 assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
221 archive_entry_pathname(ae));
222 assertEqualInt(6, archive_entry_size(ae));
225 /* End of archive. */
226 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
228 /* Verify archive format. */
229 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
230 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
232 /* Close the archive. */
233 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
235 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
238 DEFINE_TEST(test_read_format_cpio_filename_CP866_UTF8)
240 const char *refname = "test_read_format_cpio_filename_cp866.cpio";
242 struct archive_entry *ae;
245 * Read CP866 filename in en_US.UTF-8 with "hdrcharset=CP866" option.
247 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
248 skipping("en_US.UTF-8 locale not available on this system.");
251 extract_reference_file(refname);
253 assert((a = archive_read_new()) != NULL);
254 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
255 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
256 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
257 skipping("This system cannot convert character-set"
258 " from CP866 to UTF-8.");
261 assertEqualIntA(a, ARCHIVE_OK,
262 archive_read_open_filename(a, refname, 10240));
264 /* Verify regular file. */
265 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
266 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
267 archive_entry_pathname(ae));
268 assertEqualInt(6, archive_entry_size(ae));
270 /* Verify regular file. */
271 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
272 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
273 archive_entry_pathname(ae));
274 assertEqualInt(6, archive_entry_size(ae));
277 /* End of archive. */
278 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
280 /* Verify archive format. */
281 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
282 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
284 /* Close the archive. */
285 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
287 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
290 DEFINE_TEST(test_read_format_cpio_filename_KOI8R_CP866)
292 const char *refname = "test_read_format_cpio_filename_koi8r.cpio";
294 struct archive_entry *ae;
297 * Read KOI8-R filename in ru_RU.CP866 with "hdrcharset=KOI8-R" option.
299 if (NULL == setlocale(LC_ALL, "Russian_Russia.866") &&
300 NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
301 skipping("ru_RU.CP866 locale not available on this system.");
304 extract_reference_file(refname);
306 assert((a = archive_read_new()) != NULL);
307 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
308 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
309 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
310 skipping("This system cannot convert character-set"
311 " from KOI8-R to CP866.");
314 assertEqualIntA(a, ARCHIVE_OK,
315 archive_read_open_filename(a, refname, 10240));
317 /* Verify regular file. */
318 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
319 assertEqualString("\x8f\x90\x88\x82\x85\x92",
320 archive_entry_pathname(ae));
321 assertEqualInt(6, archive_entry_size(ae));
323 /* Verify regular file. */
324 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
325 assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
326 archive_entry_pathname(ae));
327 assertEqualInt(6, archive_entry_size(ae));
330 /* End of archive. */
331 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
333 /* Verify archive format. */
334 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
335 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
337 /* Close the archive. */
338 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
340 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
343 DEFINE_TEST(test_read_format_cpio_filename_KOI8R_UTF8)
345 const char *refname = "test_read_format_cpio_filename_koi8r.cpio";
347 struct archive_entry *ae;
350 * Read KOI8-R filename in en_US.UTF-8 with "hdrcharset=KOI8-R" option.
352 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
353 skipping("en_US.UTF-8 locale not available on this system.");
356 extract_reference_file(refname);
358 assert((a = archive_read_new()) != NULL);
359 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
360 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
361 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
362 skipping("This system cannot convert character-set"
363 " from KOI8-R to UTF-8.");
366 assertEqualIntA(a, ARCHIVE_OK,
367 archive_read_open_filename(a, refname, 10240));
369 /* Verify regular file. */
370 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
371 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
372 archive_entry_pathname(ae));
373 assertEqualInt(6, archive_entry_size(ae));
375 /* Verify regular file. */
376 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
377 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
378 archive_entry_pathname(ae));
379 assertEqualInt(6, archive_entry_size(ae));
382 /* End of archive. */
383 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
385 /* Verify archive format. */
386 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
387 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
389 /* Close the archive. */
390 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
392 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
395 DEFINE_TEST(test_read_format_cpio_filename_UTF8_KOI8R)
397 const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
399 struct archive_entry *ae;
402 * Read UTF-8 filename in ru_RU.KOI8-R with "hdrcharset=UTF-8" option.
404 if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") &&
405 NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
406 skipping("ru_RU.KOI8-R locale not available on this system.");
409 extract_reference_file(refname);
411 assert((a = archive_read_new()) != NULL);
412 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
413 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
414 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
415 skipping("This system cannot convert character-set"
416 " from UTF-8 to KOI8-R.");
419 assertEqualIntA(a, ARCHIVE_OK,
420 archive_read_open_filename(a, refname, 10240));
422 /* Verify regular file. */
423 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
424 assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
425 archive_entry_pathname(ae));
426 assertEqualInt(6, archive_entry_size(ae));
428 /* Verify regular file. */
429 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
430 assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
431 archive_entry_pathname(ae));
432 assertEqualInt(6, archive_entry_size(ae));
435 /* End of archive. */
436 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
438 /* Verify archive format. */
439 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
440 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
442 /* Close the archive. */
443 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
445 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
448 DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP866)
450 const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
452 struct archive_entry *ae;
455 * Read UTF-8 filename in ru_RU.CP866 with "hdrcharset=UTF-8" option.
457 if (NULL == setlocale(LC_ALL, "Russian_Russia.866") &&
458 NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
459 skipping("ru_RU.CP866 locale not available on this system.");
462 extract_reference_file(refname);
464 assert((a = archive_read_new()) != NULL);
465 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
466 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
467 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
468 skipping("This system cannot convert character-set"
469 " from UTF-8 to CP866.");
472 assertEqualIntA(a, ARCHIVE_OK,
473 archive_read_open_filename(a, refname, 10240));
475 /* Verify regular file. */
476 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
477 assertEqualString("\x8f\x90\x88\x82\x85\x92",
478 archive_entry_pathname(ae));
479 assertEqualInt(6, archive_entry_size(ae));
481 /* Verify regular file. */
482 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
483 assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
484 archive_entry_pathname(ae));
485 assertEqualInt(6, archive_entry_size(ae));
488 /* End of archive. */
489 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
491 /* Verify archive format. */
492 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
493 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
495 /* Close the archive. */
496 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
498 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
501 DEFINE_TEST(test_read_format_cpio_filename_UTF8_UTF8_ru)
503 const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
505 struct archive_entry *ae;
508 * Read UTF-8 filename in en_US.UTF-8 without "hdrcharset=UTF-8" option.
510 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
511 skipping("en_US.UTF-8 locale not available on this system.");
514 extract_reference_file(refname);
516 assert((a = archive_read_new()) != NULL);
517 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
518 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
519 assertEqualIntA(a, ARCHIVE_OK,
520 archive_read_open_filename(a, refname, 10240));
522 /* Verify regular file. */
523 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
524 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
525 archive_entry_pathname(ae));
526 assertEqualInt(6, archive_entry_size(ae));
528 /* Verify regular file. */
529 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
530 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
531 archive_entry_pathname(ae));
532 assertEqualInt(6, archive_entry_size(ae));
535 /* End of archive. */
536 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
538 /* Verify archive format. */
539 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
540 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
542 /* Close the archive. */
543 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
544 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
547 DEFINE_TEST(test_read_format_cpio_filename_eucJP_CP932)
549 const char *refname = "test_read_format_cpio_filename_eucjp.cpio";
551 struct archive_entry *ae;
554 * Read eucJP filename in CP932/SJIS with "hdrcharset=eucJP" option.
556 if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
557 NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
558 skipping("CP932 locale not available on this system.");
561 extract_reference_file(refname);
563 assert((a = archive_read_new()) != NULL);
564 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
565 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
566 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=eucJP")) {
567 skipping("This system cannot convert character-set"
571 assertEqualIntA(a, ARCHIVE_OK,
572 archive_read_open_filename(a, refname, 10240));
574 /* Verify regular file. */
575 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
576 assertEqualString("\x8a\xbf\x8e\x9a.txt", archive_entry_pathname(ae));
577 assertEqualInt(8, archive_entry_size(ae));
579 /* Verify regular file. */
580 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
581 assertEqualString("\x95\x5c.txt", archive_entry_pathname(ae));
582 assertEqualInt(4, archive_entry_size(ae));
585 /* End of archive. */
586 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
588 /* Verify archive format. */
589 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
590 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
592 /* Close the archive. */
593 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
595 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
598 DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP932)
600 const char *refname = "test_read_format_cpio_filename_utf8_jp.cpio";
602 struct archive_entry *ae;
605 * Read UTF-8 filename in CP932/SJIS with "hdrcharset=UTF-8" option.
607 if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
608 NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
609 skipping("CP932 locale not available on this system.");
612 extract_reference_file(refname);
614 assert((a = archive_read_new()) != NULL);
615 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
616 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
617 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
618 skipping("This system cannot convert character-set"
619 " from UTF-8 to CP932.");
622 assertEqualIntA(a, ARCHIVE_OK,
623 archive_read_open_filename(a, refname, 10240));
625 /* Verify regular file. */
626 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
627 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
628 assertEqualString("\x8a\xbf\x8e\x9a.txt", archive_entry_pathname(ae));
629 assertEqualInt(8, archive_entry_size(ae));
631 /* Verify regular file. */
632 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
633 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
634 assertEqualString("\x95\x5c.txt", archive_entry_pathname(ae));
635 assertEqualInt(4, archive_entry_size(ae));
637 /* End of archive. */
638 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
640 /* Verify archive format. */
641 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
642 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
644 /* Close the archive. */
645 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
647 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
650 DEFINE_TEST(test_read_format_cpio_filename_CP866_CP1251)
652 const char *refname = "test_read_format_cpio_filename_cp866.cpio";
654 struct archive_entry *ae;
657 * Read CP866 filename in CP1251 with "hdrcharset=CP866" option.
659 if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
660 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
661 skipping("CP1251 locale not available on this system.");
664 extract_reference_file(refname);
666 assert((a = archive_read_new()) != NULL);
667 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
668 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
669 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
670 skipping("This system cannot convert character-set"
671 " from CP866 to CP1251.");
674 assertEqualIntA(a, ARCHIVE_OK,
675 archive_read_open_filename(a, refname, 10240));
677 /* Verify regular file. */
678 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
679 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
680 archive_entry_pathname(ae));
681 assertEqualInt(6, archive_entry_size(ae));
683 /* Verify regular file. */
684 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
685 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
686 archive_entry_pathname(ae));
687 assertEqualInt(6, archive_entry_size(ae));
690 /* End of archive. */
691 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
693 /* Verify archive format. */
694 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
695 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
697 /* Close the archive. */
698 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
700 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
704 * This test only for Windows platform because other archiver
705 * applications on Windows translate CP1251 filenames into CP866
706 * filenames and store it in the cpio file and so we should read
707 * it by default on Windows.
709 DEFINE_TEST(test_read_format_cpio_filename_CP866_CP1251_win)
711 const char *refname = "test_read_format_cpio_filename_cp866.cpio";
713 struct archive_entry *ae;
716 * Read CP866 filename in CP1251 without "hdrcharset=CP866" option.
718 if (NULL == setlocale(LC_ALL, "Russian_Russia")) {
719 skipping("Russian_Russia locale not available on this system.");
722 extract_reference_file(refname);
724 assert((a = archive_read_new()) != NULL);
725 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
726 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
727 assertEqualIntA(a, ARCHIVE_OK,
728 archive_read_open_filename(a, refname, 10240));
730 /* Verify regular file. */
731 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
732 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
733 archive_entry_pathname(ae));
734 assertEqualInt(6, archive_entry_size(ae));
736 /* Verify regular file. */
737 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
738 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
739 archive_entry_pathname(ae));
740 assertEqualInt(6, archive_entry_size(ae));
743 /* End of archive. */
744 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
746 /* Verify archive format. */
747 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
748 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
750 /* Close the archive. */
751 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
752 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
755 DEFINE_TEST(test_read_format_cpio_filename_KOI8R_CP1251)
757 const char *refname = "test_read_format_cpio_filename_koi8r.cpio";
759 struct archive_entry *ae;
762 * Read KOI8-R filename in CP1251 with "hdrcharset=KOI8-R" option.
764 if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
765 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
766 skipping("CP1251 locale not available on this system.");
769 extract_reference_file(refname);
771 assert((a = archive_read_new()) != NULL);
772 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
773 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
774 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
775 skipping("This system cannot convert character-set"
776 " from KOI8-R to CP1251.");
779 assertEqualIntA(a, ARCHIVE_OK,
780 archive_read_open_filename(a, refname, 10240));
782 /* Verify regular file. */
783 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
784 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
785 archive_entry_pathname(ae));
786 assertEqualInt(6, archive_entry_size(ae));
788 /* Verify regular file. */
789 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
790 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
791 archive_entry_pathname(ae));
792 assertEqualInt(6, archive_entry_size(ae));
795 /* End of archive. */
796 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
798 /* Verify archive format. */
799 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
800 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
802 /* Close the archive. */
803 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
805 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
808 DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP1251)
810 const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
812 struct archive_entry *ae;
815 * Read KOI8-R filename in CP1251 with "hdrcharset=KOI8-R" option.
817 if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
818 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
819 skipping("CP1251 locale not available on this system.");
822 extract_reference_file(refname);
824 assert((a = archive_read_new()) != NULL);
825 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
826 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
827 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
828 skipping("This system cannot convert character-set"
829 " from UTF-8 to CP1251.");
832 assertEqualIntA(a, ARCHIVE_OK,
833 archive_read_open_filename(a, refname, 10240));
835 /* Verify regular file. */
836 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
837 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
838 archive_entry_pathname(ae));
839 assertEqualInt(6, archive_entry_size(ae));
841 /* Verify regular file. */
842 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
843 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
844 archive_entry_pathname(ae));
845 assertEqualInt(6, archive_entry_size(ae));
848 /* End of archive. */
849 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
851 /* Verify archive format. */
852 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
853 assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
855 /* Close the archive. */
856 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
858 assertEqualInt(ARCHIVE_OK, archive_read_free(a));