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_zip_filename_CP932_eucJP)
32 const char *refname = "test_read_format_zip_filename_cp932.zip";
34 struct archive_entry *ae;
37 * Read CP932 filename in ja_JP.eucJP with "hdrcharset=CP932" option.
39 if (NULL == setlocale(LC_ALL, "ja_JP.eucJP")) {
40 skipping("ja_JP.eucJP 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=CP932")) {
49 skipping("This system cannot convert character-set"
50 " from CP932 to eucJP.");
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));
59 "\xc9\xbd\xa4\xc0\xa4\xe8\x2f\xb0\xec\xcd\xf7\xc9\xbd\x2e\x74\x78\x74",
60 archive_entry_pathname(ae));
61 assertEqualInt(5, archive_entry_size(ae));
62 assertEqualInt(archive_entry_is_encrypted(ae), 0);
63 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
65 /* Verify regular file. */
66 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
68 "\xc9\xbd\xa4\xc0\xa4\xe8\x2f\xb4\xc1\xbb\xfa\x2e\x74\x78\x74",
69 archive_entry_pathname(ae));
70 assertEqualInt(5, archive_entry_size(ae));
71 assertEqualInt(archive_entry_is_encrypted(ae), 0);
72 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
76 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
77 assertEqualInt(archive_entry_is_encrypted(ae), 0);
78 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
80 /* Verify archive format. */
81 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
82 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
84 /* Close the archive. */
85 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
87 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
90 DEFINE_TEST(test_read_format_zip_filename_CP932_UTF8)
92 const char *refname = "test_read_format_zip_filename_cp932.zip";
94 struct archive_entry *ae;
97 * Read CP932 filename in en_US.UTF-8 with "hdrcharset=CP932" option.
99 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
100 skipping("en_US.UTF-8 locale not available on this system.");
103 extract_reference_file(refname);
105 assert((a = archive_read_new()) != NULL);
106 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
107 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
108 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP932")) {
109 skipping("This system cannot convert character-set"
110 " from CP932 to UTF-8.");
113 assertEqualIntA(a, ARCHIVE_OK,
114 archive_read_open_filename(a, refname, 10240));
116 /* Verify regular file. */
117 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
118 assertEqualInt(archive_entry_is_encrypted(ae), 0);
119 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
120 #if defined(__APPLE__)
121 /* Compare NFD string. */
122 assertEqualUTF8String(
123 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f"
124 "\xe4\xb8\x80\xe8\xa6\xa7\xe8\xa1\xa8\x2e\x74\x78\x74",
125 archive_entry_pathname(ae));
127 /* Compare NFC string. */
128 assertEqualUTF8String(
129 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f"
130 "\xe4\xb8\x80\xe8\xa6\xa7\xe8\xa1\xa8\x2e\x74\x78\x74",
131 archive_entry_pathname(ae));
133 assertEqualInt(5, archive_entry_size(ae));
135 /* Verify regular file. */
136 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
137 assertEqualInt(archive_entry_is_encrypted(ae), 0);
138 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
139 #if defined(__APPLE__)
140 /* Compare NFD string. */
141 assertEqualUTF8String(
142 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f"
143 "\xe6\xbc\xa2\xe5\xad\x97\x2e\x74\x78\x74",
144 archive_entry_pathname(ae));
146 /* Compare NFC string. */
147 assertEqualUTF8String(
148 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f"
149 "\xe6\xbc\xa2\xe5\xad\x97\x2e\x74\x78\x74",
150 archive_entry_pathname(ae));
152 assertEqualInt(5, archive_entry_size(ae));
155 /* End of archive. */
156 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
158 /* Verify archive format. */
159 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
160 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
162 /* Close the archive. */
163 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
165 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
168 DEFINE_TEST(test_read_format_zip_filename_UTF8_eucJP)
170 const char *refname = "test_read_format_zip_filename_utf8_jp.zip";
172 struct archive_entry *ae;
175 * Read UTF-8 filename in ja_JP.eucJP without charset option
176 * because the file name in the sample file is UTF-8 and
177 * Bit 11 of its general purpose bit flag is set.
179 if (NULL == setlocale(LC_ALL, "ja_JP.eucJP")) {
180 skipping("ja_JP.eucJP locale not availablefilename_ on "
184 extract_reference_file(refname);
185 assert((a = archive_read_new()) != NULL);
186 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
187 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
188 skipping("This system cannot convert character-set"
189 " from UTF-8 to eucJP.");
192 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
194 assert((a = archive_read_new()) != NULL);
195 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
196 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
197 assertEqualIntA(a, ARCHIVE_OK,
198 archive_read_open_filename(a, refname, 10240));
200 /* Verify directory file. */
201 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
202 assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
203 assertEqualString("\xc9\xbd\xa4\xc0\xa4\xe8\x2f",
204 archive_entry_pathname(ae));
205 assertEqualInt(0, archive_entry_size(ae));
206 assertEqualInt(archive_entry_is_encrypted(ae), 0);
207 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
209 /* Verify regular file. */
210 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
211 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
213 "\xc9\xbd\xa4\xc0\xa4\xe8\x2f\xb0\xec\xcd\xf7\xc9\xbd\x2e\x74\x78\x74",
214 archive_entry_pathname(ae));
215 assertEqualInt(5, archive_entry_size(ae));
216 assertEqualInt(archive_entry_is_encrypted(ae), 0);
217 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
219 /* Verify regular file. */
220 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
221 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
223 "\xc9\xbd\xa4\xc0\xa4\xe8\x2f\xb4\xc1\xbb\xfa\x2e\x74\x78\x74",
224 archive_entry_pathname(ae));
225 assertEqualInt(5, archive_entry_size(ae));
226 assertEqualInt(archive_entry_is_encrypted(ae), 0);
227 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
230 /* End of archive. */
231 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
233 /* Verify archive format. */
234 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
235 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
237 /* Close the archive. */
238 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
240 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
243 DEFINE_TEST(test_read_format_zip_filename_UTF8_UTF8)
245 const char *refname = "test_read_format_zip_filename_utf8_jp.zip";
247 struct archive_entry *ae;
250 * Read UTF-8 filename in en_US.UTF-8 without charset option
251 * because the file name in the sample file is UTF-8 and
252 * Bit 11 of its general purpose bit flag is set.
254 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
255 skipping("en_US.UTF-8 locale not available on this system.");
258 extract_reference_file(refname);
260 assert((a = archive_read_new()) != NULL);
261 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
262 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
263 assertEqualIntA(a, ARCHIVE_OK,
264 archive_read_open_filename(a, refname, 10240));
266 /* Verify directory file. */
267 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
268 assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
269 #if defined(__APPLE__)
270 /* Compare NFD string. */
271 assertEqualUTF8String(
272 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f",
273 archive_entry_pathname(ae));
275 /* Compare NFC string. */
276 assertEqualUTF8String(
277 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f",
278 archive_entry_pathname(ae));
280 assertEqualInt(0, archive_entry_size(ae));
281 assertEqualInt(archive_entry_is_encrypted(ae), 0);
282 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
284 /* Verify regular file. */
285 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
286 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
287 #if defined(__APPLE__)
288 /* Compare NFD string. */
289 assertEqualUTF8String(
290 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f"
291 "\xe4\xb8\x80\xe8\xa6\xa7\xe8\xa1\xa8\x2e\x74\x78\x74",
292 archive_entry_pathname(ae));
294 /* Compare NFC string. */
295 assertEqualUTF8String(
296 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f"
297 "\xe4\xb8\x80\xe8\xa6\xa7\xe8\xa1\xa8\x2e\x74\x78\x74",
298 archive_entry_pathname(ae));
300 assertEqualInt(5, archive_entry_size(ae));
301 assertEqualInt(archive_entry_is_encrypted(ae), 0);
302 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
304 /* Verify regular file. */
305 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
306 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
307 #if defined(__APPLE__)
308 /* Compare NFD string. */
309 assertEqualUTF8String(
310 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f"
311 "\xe6\xbc\xa2\xe5\xad\x97\x2e\x74\x78\x74",
312 archive_entry_pathname(ae));
314 /* Compare NFC string. */
315 assertEqualUTF8String(
316 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f"
317 "\xe6\xbc\xa2\xe5\xad\x97\x2e\x74\x78\x74",
318 archive_entry_pathname(ae));
320 assertEqualInt(5, archive_entry_size(ae));
321 assertEqualInt(archive_entry_is_encrypted(ae), 0);
322 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
325 /* End of archive. */
326 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
328 /* Verify archive format. */
329 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
330 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
332 /* Close the archive. */
333 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
334 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
337 DEFINE_TEST(test_read_format_zip_filename_CP866_KOI8R)
339 const char *refname = "test_read_format_zip_filename_cp866.zip";
341 struct archive_entry *ae;
344 * Read CP866 filename in ru_RU.KOI8-R with "hdrcharset=CP866" option.
346 if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") &&
347 NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
348 skipping("ru_RU.KOI8-R locale not available on this system.");
351 extract_reference_file(refname);
353 assert((a = archive_read_new()) != NULL);
354 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
355 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
356 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
357 skipping("This system cannot convert character-set"
358 " from CP866 to KOI8-R.");
361 assertEqualIntA(a, ARCHIVE_OK,
362 archive_read_open_filename(a, refname, 10240));
364 /* Verify regular file. */
365 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
366 assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
367 archive_entry_pathname(ae));
368 assertEqualInt(6, archive_entry_size(ae));
369 assertEqualInt(archive_entry_is_encrypted(ae), 0);
370 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
372 /* Verify regular file. */
373 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
374 assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
375 archive_entry_pathname(ae));
376 assertEqualInt(6, archive_entry_size(ae));
377 assertEqualInt(archive_entry_is_encrypted(ae), 0);
378 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
381 /* End of archive. */
382 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
384 /* Verify archive format. */
385 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
386 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
388 /* Close the archive. */
389 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
391 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
394 DEFINE_TEST(test_read_format_zip_filename_CP866_UTF8)
396 const char *refname = "test_read_format_zip_filename_cp866.zip";
398 struct archive_entry *ae;
401 * Read CP866 filename in en_US.UTF-8 with "hdrcharset=CP866" option.
403 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
404 skipping("en_US.UTF-8 locale not available on this system.");
407 extract_reference_file(refname);
409 assert((a = archive_read_new()) != NULL);
410 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
411 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
412 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
413 skipping("This system cannot convert character-set"
414 " from CP866 to UTF-8.");
417 assertEqualIntA(a, ARCHIVE_OK,
418 archive_read_open_filename(a, refname, 10240));
420 /* Verify regular file. */
421 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
422 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
423 archive_entry_pathname(ae));
424 assertEqualInt(6, archive_entry_size(ae));
425 assertEqualInt(archive_entry_is_encrypted(ae), 0);
426 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
428 /* Verify regular file. */
429 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
430 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
431 archive_entry_pathname(ae));
432 assertEqualInt(6, archive_entry_size(ae));
433 assertEqualInt(archive_entry_is_encrypted(ae), 0);
434 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
437 /* End of archive. */
438 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
440 /* Verify archive format. */
441 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
442 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
444 /* Close the archive. */
445 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
447 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
450 DEFINE_TEST(test_read_format_zip_filename_KOI8R_CP866)
452 const char *refname = "test_read_format_zip_filename_koi8r.zip";
454 struct archive_entry *ae;
457 * Read KOI8-R filename in ru_RU.CP866 with "hdrcharset=KOI8-R" option.
459 if (NULL == setlocale(LC_ALL, "Russian_Russia.866") &&
460 NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
461 skipping("ru_RU.CP866 locale not available on this system.");
464 extract_reference_file(refname);
466 assert((a = archive_read_new()) != NULL);
467 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
468 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
469 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
470 skipping("This system cannot convert character-set"
471 " from KOI8-R to CP866.");
474 assertEqualIntA(a, ARCHIVE_OK,
475 archive_read_open_filename(a, refname, 10240));
477 /* Verify regular file. */
478 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
479 assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
480 archive_entry_pathname(ae));
481 assertEqualInt(6, archive_entry_size(ae));
482 assertEqualInt(archive_entry_is_encrypted(ae), 0);
483 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
485 /* Verify regular file. */
486 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
487 assertEqualString("\x8f\x90\x88\x82\x85\x92",
488 archive_entry_pathname(ae));
489 assertEqualInt(6, archive_entry_size(ae));
490 assertEqualInt(archive_entry_is_encrypted(ae), 0);
491 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
494 /* End of archive. */
495 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
497 /* Verify archive format. */
498 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
499 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
501 /* Close the archive. */
502 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
504 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
507 DEFINE_TEST(test_read_format_zip_filename_KOI8R_UTF8)
509 const char *refname = "test_read_format_zip_filename_koi8r.zip";
511 struct archive_entry *ae;
514 * Read KOI8-R filename in en_US.UTF-8 with "hdrcharset=KOI8-R" option.
516 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
517 skipping("en_US.UTF-8 locale not available on this system.");
520 extract_reference_file(refname);
522 assert((a = archive_read_new()) != NULL);
523 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
524 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
525 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
526 skipping("This system cannot convert character-set"
527 " from KOI8-R to UTF-8.");
530 assertEqualIntA(a, ARCHIVE_OK,
531 archive_read_open_filename(a, refname, 10240));
533 /* Verify regular file. */
534 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
535 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
536 archive_entry_pathname(ae));
537 assertEqualInt(6, archive_entry_size(ae));
538 assertEqualInt(archive_entry_is_encrypted(ae), 0);
539 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
541 /* Verify regular file. */
542 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
543 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
544 archive_entry_pathname(ae));
545 assertEqualInt(6, archive_entry_size(ae));
546 assertEqualInt(archive_entry_is_encrypted(ae), 0);
547 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
550 /* End of archive. */
551 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
553 /* Verify archive format. */
554 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
555 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
557 /* Close the archive. */
558 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
560 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
563 DEFINE_TEST(test_read_format_zip_filename_UTF8_KOI8R)
565 const char *refname = "test_read_format_zip_filename_utf8_ru.zip";
567 struct archive_entry *ae;
570 * Read UTF-8 filename in ru_RU.KOI8-R with "hdrcharset=UTF-8" option.
572 if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") &&
573 NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
574 skipping("ru_RU.KOI8-R locale not available on this system.");
577 extract_reference_file(refname);
579 assert((a = archive_read_new()) != NULL);
580 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
581 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
582 skipping("This system cannot convert character-set"
583 " from UTF-8 to KOI8-R.");
586 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
588 /* Re-create a read archive object. */
589 assert((a = archive_read_new()) != NULL);
590 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
591 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
592 assertEqualIntA(a, ARCHIVE_OK,
593 archive_read_open_filename(a, refname, 10240));
595 /* Verify regular file. */
596 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
597 assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
598 archive_entry_pathname(ae));
599 assertEqualInt(6, archive_entry_size(ae));
600 assertEqualInt(archive_entry_is_encrypted(ae), 0);
601 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
603 /* Verify regular file. */
604 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
605 assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
606 archive_entry_pathname(ae));
607 assertEqualInt(6, archive_entry_size(ae));
608 assertEqualInt(archive_entry_is_encrypted(ae), 0);
609 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
612 /* End of archive. */
613 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
615 /* Verify archive format. */
616 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
617 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
619 /* Close the archive. */
620 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
622 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
625 DEFINE_TEST(test_read_format_zip_filename_UTF8_CP866)
627 const char *refname = "test_read_format_zip_filename_utf8_ru.zip";
629 struct archive_entry *ae;
632 * Read UTF-8 filename in ru_RU.CP866 without charset option
633 * because the file name in the sample file is UTF-8 and
634 * Bit 11 of its general purpose bit flag is set.
636 if (NULL == setlocale(LC_ALL, "Russian_Russia.866") &&
637 NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
638 skipping("ru_RU.CP866 locale not available on this system.");
641 extract_reference_file(refname);
643 assert((a = archive_read_new()) != NULL);
644 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
645 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
646 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
647 skipping("This system cannot convert character-set"
648 " from UTF-8 to CP866.");
651 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
653 /* Re-create a read archive object. */
654 assert((a = archive_read_new()) != NULL);
655 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
656 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
657 assertEqualIntA(a, ARCHIVE_OK,
658 archive_read_open_filename(a, refname, 10240));
660 /* Verify regular file. */
661 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
662 assertEqualString("\x8f\x90\x88\x82\x85\x92",
663 archive_entry_pathname(ae));
664 assertEqualInt(6, archive_entry_size(ae));
665 assertEqualInt(archive_entry_is_encrypted(ae), 0);
666 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
668 /* Verify regular file. */
669 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
670 assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
671 archive_entry_pathname(ae));
672 assertEqualInt(6, archive_entry_size(ae));
673 assertEqualInt(archive_entry_is_encrypted(ae), 0);
674 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
677 /* End of archive. */
678 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
680 /* Verify archive format. */
681 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
682 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
684 /* Close the archive. */
685 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
687 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
690 DEFINE_TEST(test_read_format_zip_filename_UTF8_UTF8_ru)
692 const char *refname = "test_read_format_zip_filename_utf8_ru.zip";
694 struct archive_entry *ae;
697 * Read UTF-8 filename in en_US.UTF-8 without charset option
698 * because the file name in the sample file is UTF-8 and
699 * Bit 11 of its general purpose bit flag is set.
701 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
702 skipping("en_US.UTF-8 locale not available on this system.");
705 extract_reference_file(refname);
707 assert((a = archive_read_new()) != NULL);
708 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
709 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
710 assertEqualIntA(a, ARCHIVE_OK,
711 archive_read_open_filename(a, refname, 10240));
713 /* Verify regular file. */
714 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
715 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
716 archive_entry_pathname(ae));
717 assertEqualInt(6, archive_entry_size(ae));
718 assertEqualInt(archive_entry_is_encrypted(ae), 0);
719 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
721 /* Verify regular file. */
722 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
723 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
724 archive_entry_pathname(ae));
725 assertEqualInt(6, archive_entry_size(ae));
726 assertEqualInt(archive_entry_is_encrypted(ae), 0);
727 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
730 /* End of archive. */
731 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
733 /* Verify archive format. */
734 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
735 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
737 /* Close the archive. */
738 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
739 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
742 DEFINE_TEST(test_read_format_zip_filename_CP932_CP932)
744 const char *refname = "test_read_format_zip_filename_cp932.zip";
746 struct archive_entry *ae;
749 * Read CP932 filename in CP932/SJIS with "hdrcharset=CP932" option.
751 if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
752 NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
753 skipping("CP932 locale not available on this system.");
756 extract_reference_file(refname);
758 assert((a = archive_read_new()) != NULL);
759 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
760 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
761 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP932")) {
762 skipping("This system cannot convert character-set"
766 assertEqualIntA(a, ARCHIVE_OK,
767 archive_read_open_filename(a, refname, 10240));
769 /* Verify regular file. */
770 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
772 "\x95\x5c\x82\xbe\x82\xe6\x2f\x88\xea\x97\x97\x95\x5c.txt",
773 archive_entry_pathname(ae));
774 assertEqualInt(5, archive_entry_size(ae));
775 assertEqualInt(archive_entry_is_encrypted(ae), 0);
776 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
778 /* Verify regular file. */
779 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
781 "\x95\x5c\x82\xbe\x82\xe6\x2f\x8a\xbf\x8e\x9a.txt",
782 archive_entry_pathname(ae));
783 assertEqualInt(5, archive_entry_size(ae));
784 assertEqualInt(archive_entry_is_encrypted(ae), 0);
785 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
788 /* End of archive. */
789 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
791 /* Verify archive format. */
792 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
793 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
795 /* Close the archive. */
796 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
798 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
801 DEFINE_TEST(test_read_format_zip_filename_UTF8_CP932)
803 const char *refname = "test_read_format_zip_filename_utf8_jp.zip";
805 struct archive_entry *ae;
808 * Read UTF-8 filename in CP932/SJIS without charset option
809 * because the file name in the sample file is UTF-8 and
810 * Bit 11 of its general purpose bit flag is set.
812 if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
813 NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
814 skipping("CP932 locale not available on this system.");
817 extract_reference_file(refname);
819 assert((a = archive_read_new()) != NULL);
820 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
821 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
822 skipping("This system cannot convert character-set"
823 " from UTF-8 to CP932.");
826 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
828 /* Re-create a read archive object. */
829 assert((a = archive_read_new()) != NULL);
830 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
831 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
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 assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
839 "\x95\x5c\x82\xbe\x82\xe6\x2f",
840 archive_entry_pathname(ae));
841 assertEqualInt(0, archive_entry_size(ae));
842 assertEqualInt(archive_entry_is_encrypted(ae), 0);
843 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
845 /* Verify directory file. */
846 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
847 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
849 "\x95\x5c\x82\xbe\x82\xe6\x2f\x88\xea\x97\x97\x95\x5c.txt",
850 archive_entry_pathname(ae));
851 assertEqualInt(5, archive_entry_size(ae));
852 assertEqualInt(archive_entry_is_encrypted(ae), 0);
853 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
855 /* Verify regular file. */
856 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
857 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
859 "\x95\x5c\x82\xbe\x82\xe6\x2f\x8a\xbf\x8e\x9a.txt",
860 archive_entry_pathname(ae));
861 assertEqualInt(5, archive_entry_size(ae));
862 assertEqualInt(archive_entry_is_encrypted(ae), 0);
863 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
865 /* End of archive. */
866 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
868 /* Verify archive format. */
869 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
870 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
872 /* Close the archive. */
873 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
875 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
878 DEFINE_TEST(test_read_format_zip_filename_CP866_CP1251)
880 const char *refname = "test_read_format_zip_filename_cp866.zip";
882 struct archive_entry *ae;
885 * Read CP866 filename in CP1251 with "hdrcharset=CP866" option.
887 if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
888 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
889 skipping("CP1251 locale not available on this system.");
892 extract_reference_file(refname);
894 assert((a = archive_read_new()) != NULL);
895 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
896 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
897 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
898 skipping("This system cannot convert character-set"
899 " from CP866 to CP1251.");
902 assertEqualIntA(a, ARCHIVE_OK,
903 archive_read_open_filename(a, refname, 10240));
905 /* Verify regular file. */
906 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
907 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
908 archive_entry_pathname(ae));
909 assertEqualInt(6, archive_entry_size(ae));
910 assertEqualInt(archive_entry_is_encrypted(ae), 0);
911 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
913 /* Verify regular file. */
914 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
915 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
916 archive_entry_pathname(ae));
917 assertEqualInt(6, archive_entry_size(ae));
918 assertEqualInt(archive_entry_is_encrypted(ae), 0);
919 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
922 /* End of archive. */
923 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
925 /* Verify archive format. */
926 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
927 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
929 /* Close the archive. */
930 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
932 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
936 * This test only for Windows platform because other archiver
937 * applications on Windows translate CP1251 filenames into CP866
938 * filenames and store it in the zip file and so we should read
939 * it by default on Windows.
941 DEFINE_TEST(test_read_format_zip_filename_CP866_CP1251_win)
943 const char *refname = "test_read_format_zip_filename_cp866.zip";
945 struct archive_entry *ae;
948 * Read CP866 filename in CP1251 without "hdrcharset=CP866" option.
950 if (NULL == setlocale(LC_ALL, "Russian_Russia")) {
951 skipping("Russian_Russia locale not available on this system.");
954 extract_reference_file(refname);
956 assert((a = archive_read_new()) != NULL);
957 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
958 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
959 assertEqualIntA(a, ARCHIVE_OK,
960 archive_read_open_filename(a, refname, 10240));
962 /* Verify regular file. */
963 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
964 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
965 archive_entry_pathname(ae));
966 assertEqualInt(6, archive_entry_size(ae));
967 assertEqualInt(archive_entry_is_encrypted(ae), 0);
968 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
970 /* Verify regular file. */
971 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
972 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
973 archive_entry_pathname(ae));
974 assertEqualInt(6, archive_entry_size(ae));
975 assertEqualInt(archive_entry_is_encrypted(ae), 0);
976 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
979 /* End of archive. */
980 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
982 /* Verify archive format. */
983 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
984 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
986 /* Close the archive. */
987 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
988 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
991 DEFINE_TEST(test_read_format_zip_filename_KOI8R_CP1251)
993 const char *refname = "test_read_format_zip_filename_koi8r.zip";
995 struct archive_entry *ae;
998 * Read KOI8-R filename in CP1251 with "hdrcharset=KOI8-R" option.
1000 if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
1001 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
1002 skipping("CP1251 locale not available on this system.");
1005 extract_reference_file(refname);
1007 assert((a = archive_read_new()) != NULL);
1008 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1009 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1010 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
1011 skipping("This system cannot convert character-set"
1012 " from KOI8-R to CP1251.");
1015 assertEqualIntA(a, ARCHIVE_OK,
1016 archive_read_open_filename(a, refname, 10240));
1018 /* Verify regular file. */
1019 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1020 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
1021 archive_entry_pathname(ae));
1022 assertEqualInt(6, archive_entry_size(ae));
1023 assertEqualInt(archive_entry_is_encrypted(ae), 0);
1024 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1026 /* Verify regular file. */
1027 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1028 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
1029 archive_entry_pathname(ae));
1030 assertEqualInt(6, archive_entry_size(ae));
1031 assertEqualInt(archive_entry_is_encrypted(ae), 0);
1032 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1035 /* End of archive. */
1036 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
1038 /* Verify archive format. */
1039 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
1040 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
1042 /* Close the archive. */
1043 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1045 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1048 DEFINE_TEST(test_read_format_zip_filename_UTF8_CP1251)
1050 const char *refname = "test_read_format_zip_filename_utf8_ru.zip";
1052 struct archive_entry *ae;
1055 * Read UTF-8 filename in CP1251 without charset option
1056 * because the file name in the sample file is UTF-8 and
1057 * Bit 11 of its general purpose bit flag is set.
1059 if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
1060 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
1061 skipping("CP1251 locale not available on this system.");
1064 extract_reference_file(refname);
1066 assert((a = archive_read_new()) != NULL);
1067 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
1068 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
1069 skipping("This system cannot convert character-set"
1070 " from UTF-8 to CP1251.");
1073 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1075 /* Re-create a read archive object. */
1076 assert((a = archive_read_new()) != NULL);
1077 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1078 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1079 assertEqualIntA(a, ARCHIVE_OK,
1080 archive_read_open_filename(a, refname, 10240));
1082 /* Verify regular file. */
1083 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1084 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
1085 archive_entry_pathname(ae));
1086 assertEqualInt(6, archive_entry_size(ae));
1087 assertEqualInt(archive_entry_is_encrypted(ae), 0);
1088 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1090 /* Verify regular file. */
1091 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1092 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
1093 archive_entry_pathname(ae));
1094 assertEqualInt(6, archive_entry_size(ae));
1095 assertEqualInt(archive_entry_is_encrypted(ae), 0);
1096 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1099 /* End of archive. */
1100 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
1102 /* Verify archive format. */
1103 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
1104 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
1106 /* Close the archive. */
1107 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1109 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1113 * The sample zip file was made in LANG=KOI8-R and it contains two
1114 * files the charset of which are different.
1115 * - the filename of first file is stored in KOI8-R.
1116 * - the filename of second file is stored in UTF-8.
1118 * Whenever hdrcharset option is specified, we will correctly read the
1119 * filename of second file, which is stored in UTF-8.
1122 DEFINE_TEST(test_read_format_zip_filename_KOI8R_UTF8_2)
1124 const char *refname = "test_read_format_zip_filename_utf8_ru2.zip";
1126 struct archive_entry *ae;
1129 * Read filename in en_US.UTF-8 with "hdrcharset=KOI8-R" option.
1131 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
1132 skipping("en_US.UTF-8 locale not available on this system.");
1135 extract_reference_file(refname);
1137 assert((a = archive_read_new()) != NULL);
1138 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1139 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1140 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
1141 skipping("This system cannot convert character-set"
1142 " from KOI8-R to UTF-8.");
1145 assertEqualIntA(a, ARCHIVE_OK,
1146 archive_read_open_filename(a, refname, 10240));
1148 /* Verify regular first file. */
1149 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1150 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
1151 archive_entry_pathname(ae));
1152 assertEqualInt(6, archive_entry_size(ae));
1153 assertEqualInt(archive_entry_is_encrypted(ae), 0);
1154 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1157 * Verify regular second file.
1158 * The filename is not translated because Bit 11 of its general
1159 * purpose bit flag is set and so we know the conversion is unneeded.
1161 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1162 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
1163 archive_entry_pathname(ae));
1164 assertEqualInt(6, archive_entry_size(ae));
1165 assertEqualInt(archive_entry_is_encrypted(ae), 0);
1166 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1169 /* End of archive. */
1170 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
1172 /* Verify archive format. */
1173 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
1174 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
1176 /* Close the archive. */
1177 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1179 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1182 * Read filename in en_US.UTF-8 without "hdrcharset=KOI8-R" option.
1183 * The filename we can properly read is only second file.
1185 assert((a = archive_read_new()) != NULL);
1186 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1187 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1188 assertEqualIntA(a, ARCHIVE_OK,
1189 archive_read_open_filename(a, refname, 10240));
1192 * Verify regular first file.
1193 * The filename is not translated to UTF-8 because Bit 11 of
1194 * its general purpose bit flag is *not* set and so there is
1195 * not way to know its charset.
1197 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1198 /* A filename is in KOI8-R. */
1199 assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
1200 archive_entry_pathname(ae));
1201 assertEqualInt(6, archive_entry_size(ae));
1202 assertEqualInt(archive_entry_is_encrypted(ae), 0);
1203 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1205 /* Verify regular file. */
1206 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1207 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
1208 archive_entry_pathname(ae));
1209 assertEqualInt(6, archive_entry_size(ae));
1210 assertEqualInt(archive_entry_is_encrypted(ae), 0);
1211 assertEqualIntA(a, archive_read_has_encrypted_entries(a), 0);
1214 /* End of archive. */
1215 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
1217 /* Verify archive format. */
1218 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
1219 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
1221 /* Close the archive. */
1222 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1223 assertEqualInt(ARCHIVE_OK, archive_read_free(a));