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_zip_filename_CP932_eucJP(const char *refname)
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.");
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=CP932")) {
48 skipping("This system cannot convert character-set"
49 " from CP932 to eucJP.");
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));
58 "\xc9\xbd\xa4\xc0\xa4\xe8\x2f\xb0\xec\xcd\xf7\xc9\xbd\x2e\x74\x78\x74",
59 archive_entry_pathname(ae));
60 assertEqualInt(5, archive_entry_size(ae));
62 /* Verify regular file. */
63 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
65 "\xc9\xbd\xa4\xc0\xa4\xe8\x2f\xb4\xc1\xbb\xfa\x2e\x74\x78\x74",
66 archive_entry_pathname(ae));
67 assertEqualInt(5, archive_entry_size(ae));
71 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
73 /* Verify archive format. */
74 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
75 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
77 /* Close the archive. */
78 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
80 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
84 test_read_format_zip_filename_CP932_UTF8(const char *refname)
87 struct archive_entry *ae;
90 * Read CP932 filename in en_US.UTF-8 with "hdrcharset=CP932" option.
92 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
93 skipping("en_US.UTF-8 locale not available on this system.");
97 assert((a = archive_read_new()) != NULL);
98 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
99 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
100 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP932")) {
101 skipping("This system cannot convert character-set"
102 " from CP932 to UTF-8.");
105 assertEqualIntA(a, ARCHIVE_OK,
106 archive_read_open_filename(a, refname, 10240));
108 /* Verify regular file. */
109 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
110 #if defined(__APPLE__)
111 /* Compare NFD string. */
112 assertEqualUTF8String(
113 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f"
114 "\xe4\xb8\x80\xe8\xa6\xa7\xe8\xa1\xa8\x2e\x74\x78\x74",
115 archive_entry_pathname(ae));
117 /* Compare NFC string. */
118 assertEqualUTF8String(
119 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f"
120 "\xe4\xb8\x80\xe8\xa6\xa7\xe8\xa1\xa8\x2e\x74\x78\x74",
121 archive_entry_pathname(ae));
123 assertEqualInt(5, archive_entry_size(ae));
125 /* Verify regular file. */
126 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
127 #if defined(__APPLE__)
128 /* Compare NFD string. */
129 assertEqualUTF8String(
130 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f"
131 "\xe6\xbc\xa2\xe5\xad\x97\x2e\x74\x78\x74",
132 archive_entry_pathname(ae));
134 /* Compare NFC string. */
135 assertEqualUTF8String(
136 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f"
137 "\xe6\xbc\xa2\xe5\xad\x97\x2e\x74\x78\x74",
138 archive_entry_pathname(ae));
140 assertEqualInt(5, archive_entry_size(ae));
143 /* End of archive. */
144 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
146 /* Verify archive format. */
147 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
148 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
150 /* Close the archive. */
151 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
153 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
157 test_read_format_zip_filename_UTF8_eucJP(const char *refname)
160 struct archive_entry *ae;
163 * Read UTF-8 filename in ja_JP.eucJP without charset option
164 * because the file name in the sample file is UTF-8 and
165 * Bit 11 of its general purpose bit flag is set.
167 if (NULL == setlocale(LC_ALL, "ja_JP.eucJP")) {
168 skipping("ja_JP.eucJP locale not availablefilename_ on this system.");
171 assert((a = archive_read_new()) != NULL);
172 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
173 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
174 skipping("This system cannot convert character-set"
175 " from UTF-8 to eucJP.");
178 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
180 assert((a = archive_read_new()) != NULL);
181 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
182 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
183 assertEqualIntA(a, ARCHIVE_OK,
184 archive_read_open_filename(a, refname, 10240));
186 /* Verify directory file. */
187 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
188 assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
189 assertEqualString("\xc9\xbd\xa4\xc0\xa4\xe8\x2f",
190 archive_entry_pathname(ae));
191 assertEqualInt(0, archive_entry_size(ae));
193 /* Verify regular file. */
194 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
195 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
197 "\xc9\xbd\xa4\xc0\xa4\xe8\x2f\xb0\xec\xcd\xf7\xc9\xbd\x2e\x74\x78\x74",
198 archive_entry_pathname(ae));
199 assertEqualInt(5, archive_entry_size(ae));
201 /* Verify regular file. */
202 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
203 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
205 "\xc9\xbd\xa4\xc0\xa4\xe8\x2f\xb4\xc1\xbb\xfa\x2e\x74\x78\x74",
206 archive_entry_pathname(ae));
207 assertEqualInt(5, archive_entry_size(ae));
210 /* End of archive. */
211 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
213 /* Verify archive format. */
214 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
215 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
217 /* Close the archive. */
218 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
220 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
224 test_read_format_zip_filename_UTF8_UTF8(const char *refname)
227 struct archive_entry *ae;
230 * Read UTF-8 filename in en_US.UTF-8 without charset option
231 * because the file name in the sample file is UTF-8 and
232 * Bit 11 of its general purpose bit flag is set.
234 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
235 skipping("en_US.UTF-8 locale not available on this system.");
239 assert((a = archive_read_new()) != NULL);
240 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
241 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
242 assertEqualIntA(a, ARCHIVE_OK,
243 archive_read_open_filename(a, refname, 10240));
245 /* Verify directory file. */
246 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
247 assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
248 #if defined(__APPLE__)
249 /* Compare NFD string. */
250 assertEqualUTF8String(
251 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f",
252 archive_entry_pathname(ae));
254 /* Compare NFC string. */
255 assertEqualUTF8String(
256 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f",
257 archive_entry_pathname(ae));
259 assertEqualInt(0, archive_entry_size(ae));
261 /* Verify regular file. */
262 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
263 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
264 #if defined(__APPLE__)
265 /* Compare NFD string. */
266 assertEqualUTF8String(
267 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f"
268 "\xe4\xb8\x80\xe8\xa6\xa7\xe8\xa1\xa8\x2e\x74\x78\x74",
269 archive_entry_pathname(ae));
271 /* Compare NFC string. */
272 assertEqualUTF8String(
273 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f"
274 "\xe4\xb8\x80\xe8\xa6\xa7\xe8\xa1\xa8\x2e\x74\x78\x74",
275 archive_entry_pathname(ae));
277 assertEqualInt(5, archive_entry_size(ae));
279 /* Verify regular file. */
280 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
281 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
282 #if defined(__APPLE__)
283 /* Compare NFD string. */
284 assertEqualUTF8String(
285 "\xe8\xa1\xa8\xe3\x81\x9f\xe3\x82\x99\xe3\x82\x88\x2f"
286 "\xe6\xbc\xa2\xe5\xad\x97\x2e\x74\x78\x74",
287 archive_entry_pathname(ae));
289 /* Compare NFC string. */
290 assertEqualUTF8String(
291 "\xe8\xa1\xa8\xe3\x81\xa0\xe3\x82\x88\x2f"
292 "\xe6\xbc\xa2\xe5\xad\x97\x2e\x74\x78\x74",
293 archive_entry_pathname(ae));
295 assertEqualInt(5, archive_entry_size(ae));
298 /* End of archive. */
299 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
301 /* Verify archive format. */
302 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
303 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
305 /* Close the archive. */
306 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
307 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
311 test_read_format_zip_filename_CP866_KOI8R(const char *refname)
314 struct archive_entry *ae;
317 * Read CP866 filename in ru_RU.KOI8-R with "hdrcharset=CP866" option.
319 if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") &&
320 NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
321 skipping("ru_RU.KOI8-R locale not available on this system.");
325 assert((a = archive_read_new()) != NULL);
326 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
327 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
328 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
329 skipping("This system cannot convert character-set"
330 " from CP866 to KOI8-R.");
333 assertEqualIntA(a, ARCHIVE_OK,
334 archive_read_open_filename(a, refname, 10240));
336 /* Verify regular file. */
337 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
338 assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
339 archive_entry_pathname(ae));
340 assertEqualInt(6, archive_entry_size(ae));
342 /* Verify regular file. */
343 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
344 assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
345 archive_entry_pathname(ae));
346 assertEqualInt(6, archive_entry_size(ae));
349 /* End of archive. */
350 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
352 /* Verify archive format. */
353 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
354 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
356 /* Close the archive. */
357 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
359 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
363 test_read_format_zip_filename_CP866_UTF8(const char *refname)
366 struct archive_entry *ae;
369 * Read CP866 filename in en_US.UTF-8 with "hdrcharset=CP866" option.
371 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
372 skipping("en_US.UTF-8 locale not available on this system.");
376 assert((a = archive_read_new()) != NULL);
377 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
378 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
379 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
380 skipping("This system cannot convert character-set"
381 " from CP866 to UTF-8.");
384 assertEqualIntA(a, ARCHIVE_OK,
385 archive_read_open_filename(a, refname, 10240));
387 /* Verify regular file. */
388 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
389 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
390 archive_entry_pathname(ae));
391 assertEqualInt(6, archive_entry_size(ae));
393 /* Verify regular file. */
394 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
395 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
396 archive_entry_pathname(ae));
397 assertEqualInt(6, archive_entry_size(ae));
400 /* End of archive. */
401 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
403 /* Verify archive format. */
404 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
405 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
407 /* Close the archive. */
408 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
410 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
414 test_read_format_zip_filename_KOI8R_CP866(const char *refname)
417 struct archive_entry *ae;
420 * Read KOI8-R filename in ru_RU.CP866 with "hdrcharset=KOI8-R" option.
422 if (NULL == setlocale(LC_ALL, "Russian_Russia.866") &&
423 NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
424 skipping("ru_RU.CP866 locale not available on this system.");
428 assert((a = archive_read_new()) != NULL);
429 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
430 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
431 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
432 skipping("This system cannot convert character-set"
433 " from KOI8-R to CP866.");
436 assertEqualIntA(a, ARCHIVE_OK,
437 archive_read_open_filename(a, refname, 10240));
439 /* Verify regular file. */
440 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
441 assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
442 archive_entry_pathname(ae));
443 assertEqualInt(6, archive_entry_size(ae));
445 /* Verify regular file. */
446 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
447 assertEqualString("\x8f\x90\x88\x82\x85\x92",
448 archive_entry_pathname(ae));
449 assertEqualInt(6, archive_entry_size(ae));
452 /* End of archive. */
453 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
455 /* Verify archive format. */
456 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
457 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
459 /* Close the archive. */
460 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
462 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
466 test_read_format_zip_filename_KOI8R_UTF8(const char *refname)
469 struct archive_entry *ae;
472 * Read KOI8-R filename in en_US.UTF-8 with "hdrcharset=KOI8-R" option.
474 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
475 skipping("en_US.UTF-8 locale not available on this system.");
479 assert((a = archive_read_new()) != NULL);
480 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
481 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
482 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
483 skipping("This system cannot convert character-set"
484 " from KOI8-R to UTF-8.");
487 assertEqualIntA(a, ARCHIVE_OK,
488 archive_read_open_filename(a, refname, 10240));
490 /* Verify regular file. */
491 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
492 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
493 archive_entry_pathname(ae));
494 assertEqualInt(6, archive_entry_size(ae));
496 /* Verify regular file. */
497 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
498 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
499 archive_entry_pathname(ae));
500 assertEqualInt(6, archive_entry_size(ae));
503 /* End of archive. */
504 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
506 /* Verify archive format. */
507 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
508 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
510 /* Close the archive. */
511 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
513 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
517 test_read_format_zip_filename_UTF8_KOI8R(const char *refname)
520 struct archive_entry *ae;
523 * Read UTF-8 filename in ru_RU.KOI8-R with "hdrcharset=UTF-8" option.
525 if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") &&
526 NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
527 skipping("ru_RU.KOI8-R locale not available on this system.");
531 assert((a = archive_read_new()) != NULL);
532 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
533 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
534 skipping("This system cannot convert character-set"
535 " from UTF-8 to KOI8-R.");
538 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
540 /* Re-create a read archive object. */
541 assert((a = archive_read_new()) != NULL);
542 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
543 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
544 assertEqualIntA(a, ARCHIVE_OK,
545 archive_read_open_filename(a, refname, 10240));
547 /* Verify regular file. */
548 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
549 assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
550 archive_entry_pathname(ae));
551 assertEqualInt(6, archive_entry_size(ae));
553 /* Verify regular file. */
554 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
555 assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
556 archive_entry_pathname(ae));
557 assertEqualInt(6, archive_entry_size(ae));
560 /* End of archive. */
561 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
563 /* Verify archive format. */
564 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
565 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
567 /* Close the archive. */
568 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
570 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
574 test_read_format_zip_filename_UTF8_CP866(const char *refname)
577 struct archive_entry *ae;
580 * Read UTF-8 filename in ru_RU.CP866 without charset option
581 * because the file name in the sample file is UTF-8 and
582 * Bit 11 of its general purpose bit flag is set.
584 if (NULL == setlocale(LC_ALL, "Russian_Russia.866") &&
585 NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
586 skipping("ru_RU.CP866 locale not available on this system.");
590 assert((a = archive_read_new()) != NULL);
591 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
592 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
593 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
594 skipping("This system cannot convert character-set"
595 " from UTF-8 to CP866.");
598 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
600 /* Re-create a read archive object. */
601 assert((a = archive_read_new()) != NULL);
602 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
603 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
604 assertEqualIntA(a, ARCHIVE_OK,
605 archive_read_open_filename(a, refname, 10240));
607 /* Verify regular file. */
608 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
609 assertEqualString("\x8f\x90\x88\x82\x85\x92",
610 archive_entry_pathname(ae));
611 assertEqualInt(6, archive_entry_size(ae));
613 /* Verify regular file. */
614 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
615 assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
616 archive_entry_pathname(ae));
617 assertEqualInt(6, 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_ZIP, 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_zip_filename_UTF8_UTF8_ru(const char *refname)
637 struct archive_entry *ae;
640 * Read UTF-8 filename in en_US.UTF-8 without charset option
641 * because the file name in the sample file is UTF-8 and
642 * Bit 11 of its general purpose bit flag is set.
644 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
645 skipping("en_US.UTF-8 locale not available on this system.");
649 assert((a = archive_read_new()) != NULL);
650 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
651 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
652 assertEqualIntA(a, ARCHIVE_OK,
653 archive_read_open_filename(a, refname, 10240));
655 /* Verify regular file. */
656 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
657 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
658 archive_entry_pathname(ae));
659 assertEqualInt(6, archive_entry_size(ae));
661 /* Verify regular file. */
662 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
663 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
664 archive_entry_pathname(ae));
665 assertEqualInt(6, archive_entry_size(ae));
668 /* End of archive. */
669 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
671 /* Verify archive format. */
672 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
673 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
675 /* Close the archive. */
676 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
677 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
681 test_read_format_zip_filename_CP932_CP932(const char *refname)
684 struct archive_entry *ae;
687 * Read CP932 filename in CP932/SJIS with "hdrcharset=CP932" option.
689 if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
690 NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
691 skipping("CP932 locale not available on this system.");
695 assert((a = archive_read_new()) != NULL);
696 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
697 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
698 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP932")) {
699 skipping("This system cannot convert character-set"
703 assertEqualIntA(a, ARCHIVE_OK,
704 archive_read_open_filename(a, refname, 10240));
706 /* Verify regular file. */
707 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
709 "\x95\x5c\x82\xbe\x82\xe6\x2f\x88\xea\x97\x97\x95\x5c.txt",
710 archive_entry_pathname(ae));
711 assertEqualInt(5, archive_entry_size(ae));
713 /* Verify regular file. */
714 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
716 "\x95\x5c\x82\xbe\x82\xe6\x2f\x8a\xbf\x8e\x9a.txt",
717 archive_entry_pathname(ae));
718 assertEqualInt(5, archive_entry_size(ae));
721 /* End of archive. */
722 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
724 /* Verify archive format. */
725 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
726 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
728 /* Close the archive. */
729 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
731 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
735 test_read_format_zip_filename_UTF8_CP932(const char *refname)
738 struct archive_entry *ae;
741 * Read UTF-8 filename in CP932/SJIS without charset option
742 * because the file name in the sample file is UTF-8 and
743 * Bit 11 of its general purpose bit flag is set.
745 if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
746 NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
747 skipping("CP932 locale not available on this system.");
751 assert((a = archive_read_new()) != NULL);
752 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
753 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
754 skipping("This system cannot convert character-set"
755 " from UTF-8 to CP932.");
758 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
760 /* Re-create a read archive object. */
761 assert((a = archive_read_new()) != NULL);
762 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
763 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
764 assertEqualIntA(a, ARCHIVE_OK,
765 archive_read_open_filename(a, refname, 10240));
767 /* Verify regular file. */
768 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
769 assertEqualInt(AE_IFDIR, archive_entry_filetype(ae));
771 "\x95\x5c\x82\xbe\x82\xe6\x2f",
772 archive_entry_pathname(ae));
773 assertEqualInt(0, archive_entry_size(ae));
775 /* Verify directory file. */
776 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
777 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
779 "\x95\x5c\x82\xbe\x82\xe6\x2f\x88\xea\x97\x97\x95\x5c.txt",
780 archive_entry_pathname(ae));
781 assertEqualInt(5, archive_entry_size(ae));
783 /* Verify regular file. */
784 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
785 assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
787 "\x95\x5c\x82\xbe\x82\xe6\x2f\x8a\xbf\x8e\x9a.txt",
788 archive_entry_pathname(ae));
789 assertEqualInt(5, archive_entry_size(ae));
791 /* End of archive. */
792 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
794 /* Verify archive format. */
795 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
796 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
798 /* Close the archive. */
799 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
801 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
805 test_read_format_zip_filename_CP866_CP1251(const char *refname)
808 struct archive_entry *ae;
811 * Read CP866 filename in CP1251 with "hdrcharset=CP866" option.
813 if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
814 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
815 skipping("CP1251 locale not available on this system.");
819 assert((a = archive_read_new()) != NULL);
820 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
821 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
822 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
823 skipping("This system cannot convert character-set"
824 " from CP866 to CP1251.");
827 assertEqualIntA(a, ARCHIVE_OK,
828 archive_read_open_filename(a, refname, 10240));
830 /* Verify regular file. */
831 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
832 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
833 archive_entry_pathname(ae));
834 assertEqualInt(6, archive_entry_size(ae));
836 /* Verify regular file. */
837 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
838 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
839 archive_entry_pathname(ae));
840 assertEqualInt(6, archive_entry_size(ae));
843 /* End of archive. */
844 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
846 /* Verify archive format. */
847 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
848 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
850 /* Close the archive. */
851 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
853 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
857 * This test only for Windows platform because other archiver
858 * applications on Windows translate CP1251 filenames into CP866
859 * filenames and store it in the zip file and so we should read
860 * it by default on Windows.
863 test_read_format_zip_filename_CP866_CP1251_win(const char *refname)
866 struct archive_entry *ae;
869 * Read CP866 filename in CP1251 without "hdrcharset=CP866" option.
871 if (NULL == setlocale(LC_ALL, "Russian_Russia")) {
872 skipping("Russian_Russia locale not available on this system.");
876 assert((a = archive_read_new()) != NULL);
877 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
878 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
879 assertEqualIntA(a, ARCHIVE_OK,
880 archive_read_open_filename(a, refname, 10240));
882 /* Verify regular file. */
883 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
884 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
885 archive_entry_pathname(ae));
886 assertEqualInt(6, archive_entry_size(ae));
888 /* Verify regular file. */
889 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
890 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
891 archive_entry_pathname(ae));
892 assertEqualInt(6, archive_entry_size(ae));
895 /* End of archive. */
896 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
898 /* Verify archive format. */
899 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
900 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
902 /* Close the archive. */
903 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
904 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
908 test_read_format_zip_filename_KOI8R_CP1251(const char *refname)
911 struct archive_entry *ae;
914 * Read KOI8-R filename in CP1251 with "hdrcharset=KOI8-R" option.
916 if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
917 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
918 skipping("CP1251 locale not available on this system.");
922 assert((a = archive_read_new()) != NULL);
923 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
924 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
925 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
926 skipping("This system cannot convert character-set"
927 " from KOI8-R to CP1251.");
930 assertEqualIntA(a, ARCHIVE_OK,
931 archive_read_open_filename(a, refname, 10240));
933 /* Verify regular file. */
934 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
935 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
936 archive_entry_pathname(ae));
937 assertEqualInt(6, archive_entry_size(ae));
939 /* Verify regular file. */
940 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
941 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
942 archive_entry_pathname(ae));
943 assertEqualInt(6, archive_entry_size(ae));
946 /* End of archive. */
947 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
949 /* Verify archive format. */
950 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
951 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
953 /* Close the archive. */
954 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
956 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
960 test_read_format_zip_filename_UTF8_CP1251(const char *refname)
963 struct archive_entry *ae;
966 * Read UTF-8 filename in CP1251 without charset option
967 * because the file name in the sample file is UTF-8 and
968 * Bit 11 of its general purpose bit flag is set.
970 if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
971 NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
972 skipping("CP1251 locale not available on this system.");
976 assert((a = archive_read_new()) != NULL);
977 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_zip(a));
978 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
979 skipping("This system cannot convert character-set"
980 " from UTF-8 to CP1251.");
983 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
985 /* Re-create a read archive object. */
986 assert((a = archive_read_new()) != NULL);
987 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
988 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
989 assertEqualIntA(a, ARCHIVE_OK,
990 archive_read_open_filename(a, refname, 10240));
992 /* Verify regular file. */
993 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
994 assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
995 archive_entry_pathname(ae));
996 assertEqualInt(6, archive_entry_size(ae));
998 /* Verify regular file. */
999 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1000 assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
1001 archive_entry_pathname(ae));
1002 assertEqualInt(6, archive_entry_size(ae));
1005 /* End of archive. */
1006 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
1008 /* Verify archive format. */
1009 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
1010 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
1012 /* Close the archive. */
1013 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1015 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1019 * The sample zip file was made in LANG=KOI8-R and it contains two
1020 * files the charset of which are different.
1021 * - the filename of first file is stored in KOI8-R.
1022 * - the filename of second file is stored in UTF-8.
1024 * Whenever hdrcharset option is specified, we will correctly read the
1025 * filename of sencod file, which is stored in UTF-8.
1029 test_read_format_zip_filename_KOI8R_UTF8_2(const char *refname)
1032 struct archive_entry *ae;
1035 * Read filename in en_US.UTF-8 with "hdrcharset=KOI8-R" option.
1037 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
1038 skipping("en_US.UTF-8 locale not available on this system.");
1042 assert((a = archive_read_new()) != NULL);
1043 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1044 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1045 if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
1046 skipping("This system cannot convert character-set"
1047 " from KOI8-R to UTF-8.");
1050 assertEqualIntA(a, ARCHIVE_OK,
1051 archive_read_open_filename(a, refname, 10240));
1053 /* Verify regular first file. */
1054 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1055 assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
1056 archive_entry_pathname(ae));
1057 assertEqualInt(6, archive_entry_size(ae));
1060 * Verify regular second file.
1061 * The filename is not translated because Bit 11 of its general
1062 * purpose bit flag is set and so we know the conversion is unneeded.
1064 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1065 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
1066 archive_entry_pathname(ae));
1067 assertEqualInt(6, archive_entry_size(ae));
1070 /* End of archive. */
1071 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
1073 /* Verify archive format. */
1074 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
1075 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
1077 /* Close the archive. */
1078 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1080 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1083 * Read filename in en_US.UTF-8 without "hdrcharset=KOI8-R" option.
1084 * The filename we can properly read is only second file.
1086 assert((a = archive_read_new()) != NULL);
1087 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
1088 assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
1089 assertEqualIntA(a, ARCHIVE_OK,
1090 archive_read_open_filename(a, refname, 10240));
1093 * Verify regular first file.
1094 * The filename is not translated to UTF-8 because Bit 11 of
1095 * its general purpose bit flag is *not* set and so there is
1096 * not way to know its charset.
1098 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1099 /* A filename is in KOI8-R. */
1100 assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
1101 archive_entry_pathname(ae));
1102 assertEqualInt(6, archive_entry_size(ae));
1104 /* Verify regular file. */
1105 assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
1106 assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
1107 archive_entry_pathname(ae));
1108 assertEqualInt(6, archive_entry_size(ae));
1111 /* End of archive. */
1112 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
1114 /* Verify archive format. */
1115 assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
1116 assertEqualIntA(a, ARCHIVE_FORMAT_ZIP, archive_format(a));
1118 /* Close the archive. */
1119 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
1120 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
1123 DEFINE_TEST(test_read_format_zip_filename)
1125 const char *refname1 = "test_read_format_zip_filename_cp932.zip";
1126 const char *refname2 = "test_read_format_zip_filename_utf8_jp.zip";
1127 const char *refname3 = "test_read_format_zip_filename_cp866.zip";
1128 const char *refname4 = "test_read_format_zip_filename_koi8r.zip";
1129 const char *refname5 = "test_read_format_zip_filename_utf8_ru.zip";
1130 const char *refname6 = "test_read_format_zip_filename_utf8_ru2.zip";
1132 extract_reference_file(refname1);
1133 test_read_format_zip_filename_CP932_eucJP(refname1);
1134 test_read_format_zip_filename_CP932_UTF8(refname1);
1135 test_read_format_zip_filename_CP932_CP932(refname1);
1137 extract_reference_file(refname2);
1138 test_read_format_zip_filename_UTF8_eucJP(refname2);
1139 test_read_format_zip_filename_UTF8_UTF8(refname2);
1140 test_read_format_zip_filename_UTF8_CP932(refname2);
1142 extract_reference_file(refname3);
1143 test_read_format_zip_filename_CP866_KOI8R(refname3);
1144 test_read_format_zip_filename_CP866_UTF8(refname3);
1145 test_read_format_zip_filename_CP866_CP1251(refname3);
1146 test_read_format_zip_filename_CP866_CP1251_win(refname3);
1148 extract_reference_file(refname4);
1149 test_read_format_zip_filename_KOI8R_CP866(refname4);
1150 test_read_format_zip_filename_KOI8R_UTF8(refname4);
1151 test_read_format_zip_filename_KOI8R_CP1251(refname4);
1153 extract_reference_file(refname5);
1154 test_read_format_zip_filename_UTF8_KOI8R(refname5);
1155 test_read_format_zip_filename_UTF8_CP866(refname5);
1156 test_read_format_zip_filename_UTF8_UTF8_ru(refname5);
1157 test_read_format_zip_filename_UTF8_CP1251(refname5);
1159 /* The filenames contained in refname6 are different charset. */
1160 extract_reference_file(refname6);
1161 test_read_format_zip_filename_KOI8R_UTF8_2(refname6);