1 /*-
2 * Copyright (c) 2011 Michihiro NAKAJIMA
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
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.
13 *
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.
24 */
25 #include "test.h"
26 __FBSDID("$FreeBSD");
27
28 #include <locale.h>
29
DEFINE_TEST(test_read_format_cpio_filename_eucJP_UTF8)30 DEFINE_TEST(test_read_format_cpio_filename_eucJP_UTF8)
31 {
32 const char *refname = "test_read_format_cpio_filename_eucjp.cpio";
33 struct archive *a;
34 struct archive_entry *ae;
35
36 /*
37 * Read eucJP filename in en_US.UTF-8 with "hdrcharset=eucJP" option.
38 */
39 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
40 skipping("en_US.UTF-8 locale not available on this system.");
41 return;
42 }
43 extract_reference_file(refname);
44
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.");
51 goto cleanup;
52 }
53 assertEqualIntA(a, ARCHIVE_OK,
54 archive_read_open_filename(a, refname, 10240));
55
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);
63
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);
70
71
72 /* End of archive. */
73 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
74
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));
78
79 /* Close the archive. */
80 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
81 cleanup:
82 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
83 }
84
DEFINE_TEST(test_read_format_cpio_filename_UTF8_eucJP)85 DEFINE_TEST(test_read_format_cpio_filename_UTF8_eucJP)
86 {
87 const char *refname = "test_read_format_cpio_filename_utf8_jp.cpio";
88 struct archive *a;
89 struct archive_entry *ae;
90
91 /*
92 * Read UTF-8 filename in ja_JP.eucJP with "hdrcharset=UTF-8" option.
93 */
94 if (NULL == setlocale(LC_ALL, "ja_JP.eucJP")) {
95 skipping("ja_JP.eucJP locale not available on this system.");
96 return;
97 }
98 extract_reference_file(refname);
99
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.");
106 goto cleanup;
107 }
108
109 assertEqualIntA(a, ARCHIVE_OK,
110 archive_read_open_filename(a, refname, 10240));
111
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));
117
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));
123
124
125 /* End of archive. */
126 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
127
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));
131
132 /* Close the archive. */
133 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
134 cleanup:
135 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
136 }
137
DEFINE_TEST(test_read_format_cpio_filename_UTF8_UTF8_jp)138 DEFINE_TEST(test_read_format_cpio_filename_UTF8_UTF8_jp)
139 {
140 const char *refname = "test_read_format_cpio_filename_utf8_jp.cpio";
141 struct archive *a;
142 struct archive_entry *ae;
143
144 /*
145 * Read UTF-8 filename in en_US.UTF-8 without "hdrcharset=UTF-8" option.
146 */
147 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
148 skipping("en_US.UTF-8 locale not available on this system.");
149 return;
150 }
151 extract_reference_file(refname);
152
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));
158
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));
165
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));
171
172
173 /* End of archive. */
174 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
175
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));
179
180 /* Close the archive. */
181 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
182 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
183 }
184
DEFINE_TEST(test_read_format_cpio_filename_CP866_KOI8R)185 DEFINE_TEST(test_read_format_cpio_filename_CP866_KOI8R)
186 {
187 const char *refname = "test_read_format_cpio_filename_cp866.cpio";
188 struct archive *a;
189 struct archive_entry *ae;
190
191 /*
192 * Read CP866 filename in ru_RU.KOI8-R with "hdrcharset=CP866" option.
193 */
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.");
197 return;
198 }
199 extract_reference_file(refname);
200
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.");
207 goto cleanup;
208 }
209 assertEqualIntA(a, ARCHIVE_OK,
210 archive_read_open_filename(a, refname, 10240));
211
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));
217
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));
223
224
225 /* End of archive. */
226 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
227
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));
231
232 /* Close the archive. */
233 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
234 cleanup:
235 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
236 }
237
DEFINE_TEST(test_read_format_cpio_filename_CP866_UTF8)238 DEFINE_TEST(test_read_format_cpio_filename_CP866_UTF8)
239 {
240 const char *refname = "test_read_format_cpio_filename_cp866.cpio";
241 struct archive *a;
242 struct archive_entry *ae;
243
244 /*
245 * Read CP866 filename in en_US.UTF-8 with "hdrcharset=CP866" option.
246 */
247 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
248 skipping("en_US.UTF-8 locale not available on this system.");
249 return;
250 }
251 extract_reference_file(refname);
252
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.");
259 goto cleanup;
260 }
261 assertEqualIntA(a, ARCHIVE_OK,
262 archive_read_open_filename(a, refname, 10240));
263
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));
269
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));
275
276
277 /* End of archive. */
278 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
279
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));
283
284 /* Close the archive. */
285 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
286 cleanup:
287 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
288 }
289
DEFINE_TEST(test_read_format_cpio_filename_KOI8R_CP866)290 DEFINE_TEST(test_read_format_cpio_filename_KOI8R_CP866)
291 {
292 const char *refname = "test_read_format_cpio_filename_koi8r.cpio";
293 struct archive *a;
294 struct archive_entry *ae;
295
296 /*
297 * Read KOI8-R filename in ru_RU.CP866 with "hdrcharset=KOI8-R" option.
298 */
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.");
302 return;
303 }
304 extract_reference_file(refname);
305
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.");
312 goto cleanup;
313 }
314 assertEqualIntA(a, ARCHIVE_OK,
315 archive_read_open_filename(a, refname, 10240));
316
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));
322
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));
328
329
330 /* End of archive. */
331 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
332
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));
336
337 /* Close the archive. */
338 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
339 cleanup:
340 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
341 }
342
DEFINE_TEST(test_read_format_cpio_filename_KOI8R_UTF8)343 DEFINE_TEST(test_read_format_cpio_filename_KOI8R_UTF8)
344 {
345 const char *refname = "test_read_format_cpio_filename_koi8r.cpio";
346 struct archive *a;
347 struct archive_entry *ae;
348
349 /*
350 * Read KOI8-R filename in en_US.UTF-8 with "hdrcharset=KOI8-R" option.
351 */
352 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
353 skipping("en_US.UTF-8 locale not available on this system.");
354 return;
355 }
356 extract_reference_file(refname);
357
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.");
364 goto cleanup;
365 }
366 assertEqualIntA(a, ARCHIVE_OK,
367 archive_read_open_filename(a, refname, 10240));
368
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));
374
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));
380
381
382 /* End of archive. */
383 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
384
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));
388
389 /* Close the archive. */
390 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
391 cleanup:
392 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
393 }
394
DEFINE_TEST(test_read_format_cpio_filename_UTF8_KOI8R)395 DEFINE_TEST(test_read_format_cpio_filename_UTF8_KOI8R)
396 {
397 const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
398 struct archive *a;
399 struct archive_entry *ae;
400
401 /*
402 * Read UTF-8 filename in ru_RU.KOI8-R with "hdrcharset=UTF-8" option.
403 */
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.");
407 return;
408 }
409 extract_reference_file(refname);
410
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.");
417 goto cleanup;
418 }
419 assertEqualIntA(a, ARCHIVE_OK,
420 archive_read_open_filename(a, refname, 10240));
421
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));
427
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));
433
434
435 /* End of archive. */
436 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
437
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));
441
442 /* Close the archive. */
443 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
444 cleanup:
445 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
446 }
447
DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP866)448 DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP866)
449 {
450 const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
451 struct archive *a;
452 struct archive_entry *ae;
453
454 /*
455 * Read UTF-8 filename in ru_RU.CP866 with "hdrcharset=UTF-8" option.
456 */
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.");
460 return;
461 }
462 extract_reference_file(refname);
463
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.");
470 goto cleanup;
471 }
472 assertEqualIntA(a, ARCHIVE_OK,
473 archive_read_open_filename(a, refname, 10240));
474
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));
480
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));
486
487
488 /* End of archive. */
489 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
490
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));
494
495 /* Close the archive. */
496 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
497 cleanup:
498 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
499 }
500
DEFINE_TEST(test_read_format_cpio_filename_UTF8_UTF8_ru)501 DEFINE_TEST(test_read_format_cpio_filename_UTF8_UTF8_ru)
502 {
503 const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
504 struct archive *a;
505 struct archive_entry *ae;
506
507 /*
508 * Read UTF-8 filename in en_US.UTF-8 without "hdrcharset=UTF-8" option.
509 */
510 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
511 skipping("en_US.UTF-8 locale not available on this system.");
512 return;
513 }
514 extract_reference_file(refname);
515
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));
521
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));
527
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));
533
534
535 /* End of archive. */
536 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
537
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));
541
542 /* Close the archive. */
543 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
544 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
545 }
546
DEFINE_TEST(test_read_format_cpio_filename_eucJP_CP932)547 DEFINE_TEST(test_read_format_cpio_filename_eucJP_CP932)
548 {
549 const char *refname = "test_read_format_cpio_filename_eucjp.cpio";
550 struct archive *a;
551 struct archive_entry *ae;
552
553 /*
554 * Read eucJP filename in CP932/SJIS with "hdrcharset=eucJP" option.
555 */
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.");
559 return;
560 }
561 extract_reference_file(refname);
562
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"
568 " from eucJP.");
569 goto cleanup;
570 }
571 assertEqualIntA(a, ARCHIVE_OK,
572 archive_read_open_filename(a, refname, 10240));
573
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));
578
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));
583
584
585 /* End of archive. */
586 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
587
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));
591
592 /* Close the archive. */
593 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
594 cleanup:
595 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
596 }
597
DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP932)598 DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP932)
599 {
600 const char *refname = "test_read_format_cpio_filename_utf8_jp.cpio";
601 struct archive *a;
602 struct archive_entry *ae;
603
604 /*
605 * Read UTF-8 filename in CP932/SJIS with "hdrcharset=UTF-8" option.
606 */
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.");
610 return;
611 }
612 extract_reference_file(refname);
613
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.");
620 goto cleanup;
621 }
622 assertEqualIntA(a, ARCHIVE_OK,
623 archive_read_open_filename(a, refname, 10240));
624
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));
630
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));
636
637 /* End of archive. */
638 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
639
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));
643
644 /* Close the archive. */
645 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
646 cleanup:
647 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
648 }
649
DEFINE_TEST(test_read_format_cpio_filename_CP866_CP1251)650 DEFINE_TEST(test_read_format_cpio_filename_CP866_CP1251)
651 {
652 const char *refname = "test_read_format_cpio_filename_cp866.cpio";
653 struct archive *a;
654 struct archive_entry *ae;
655
656 /*
657 * Read CP866 filename in CP1251 with "hdrcharset=CP866" option.
658 */
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.");
662 return;
663 }
664 extract_reference_file(refname);
665
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.");
672 goto cleanup;
673 }
674 assertEqualIntA(a, ARCHIVE_OK,
675 archive_read_open_filename(a, refname, 10240));
676
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));
682
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));
688
689
690 /* End of archive. */
691 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
692
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));
696
697 /* Close the archive. */
698 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
699 cleanup:
700 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
701 }
702
703 /*
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.
708 */
DEFINE_TEST(test_read_format_cpio_filename_CP866_CP1251_win)709 DEFINE_TEST(test_read_format_cpio_filename_CP866_CP1251_win)
710 {
711 const char *refname = "test_read_format_cpio_filename_cp866.cpio";
712 struct archive *a;
713 struct archive_entry *ae;
714
715 /*
716 * Read CP866 filename in CP1251 without "hdrcharset=CP866" option.
717 */
718 if (NULL == setlocale(LC_ALL, "Russian_Russia")) {
719 skipping("Russian_Russia locale not available on this system.");
720 return;
721 }
722 extract_reference_file(refname);
723
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));
729
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));
735
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));
741
742
743 /* End of archive. */
744 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
745
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));
749
750 /* Close the archive. */
751 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
752 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
753 }
754
DEFINE_TEST(test_read_format_cpio_filename_KOI8R_CP1251)755 DEFINE_TEST(test_read_format_cpio_filename_KOI8R_CP1251)
756 {
757 const char *refname = "test_read_format_cpio_filename_koi8r.cpio";
758 struct archive *a;
759 struct archive_entry *ae;
760
761 /*
762 * Read KOI8-R filename in CP1251 with "hdrcharset=KOI8-R" option.
763 */
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.");
767 return;
768 }
769 extract_reference_file(refname);
770
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.");
777 goto cleanup;
778 }
779 assertEqualIntA(a, ARCHIVE_OK,
780 archive_read_open_filename(a, refname, 10240));
781
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));
787
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));
793
794
795 /* End of archive. */
796 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
797
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));
801
802 /* Close the archive. */
803 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
804 cleanup:
805 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
806 }
807
DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP1251)808 DEFINE_TEST(test_read_format_cpio_filename_UTF8_CP1251)
809 {
810 const char *refname = "test_read_format_cpio_filename_utf8_ru.cpio";
811 struct archive *a;
812 struct archive_entry *ae;
813
814 /*
815 * Read KOI8-R filename in CP1251 with "hdrcharset=KOI8-R" option.
816 */
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.");
820 return;
821 }
822 extract_reference_file(refname);
823
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.");
830 goto cleanup;
831 }
832 assertEqualIntA(a, ARCHIVE_OK,
833 archive_read_open_filename(a, refname, 10240));
834
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));
840
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));
846
847
848 /* End of archive. */
849 assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
850
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));
854
855 /* Close the archive. */
856 assertEqualInt(ARCHIVE_OK, archive_read_close(a));
857 cleanup:
858 assertEqualInt(ARCHIVE_OK, archive_read_free(a));
859 }
860
861