contrib/libarchive/libarchive/test/test_read_format_cpio_filename.c

   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
  30 static void
  31 test_read_format_cpio_filename_eucJP_UTF8(const char *refname)
  32 {
  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
  44         assert((a = archive_read_new()) != NULL);
  45         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
  46         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
  47         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=eucJP")) {
  48                 skipping("This system cannot convert character-set"
  49                     " from eucJP to UTF-8.");
  50                 goto cleanup;
  51         }
  52         assertEqualIntA(a, ARCHIVE_OK,
  53             archive_read_open_filename(a, refname, 10240));
  54
  55         /* Verify regular file. */
  56         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
  57         assertEqualString("\xe6\xbc\xa2\xe5\xad\x97.txt",
  58             archive_entry_pathname(ae));
  59         assertEqualInt(8, archive_entry_size(ae));
  60
  61         /* Verify regular file. */
  62         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
  63         assertEqualString("\xe8\xa1\xa8.txt", archive_entry_pathname(ae));
  64         assertEqualInt(4, archive_entry_size(ae));
  65
  66
  67         /* End of archive. */
  68         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
  69
  70         /* Verify archive format. */
  71         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
  72         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
  73
  74         /* Close the archive. */
  75         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
  76 cleanup:
  77         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
  78 }
  79
  80 static void
  81 test_read_format_cpio_filename_UTF8_eucJP(const char *refname)
  82 {
  83         struct archive *a;
  84         struct archive_entry *ae;
  85
  86         /*
  87          * Read UTF-8 filename in ja_JP.eucJP with "hdrcharset=UTF-8" option.
  88          */
  89         if (NULL == setlocale(LC_ALL, "ja_JP.eucJP")) {
  90                 skipping("ja_JP.eucJP locale not available on this system.");
  91                 return;
  92         }
  93         assert((a = archive_read_new()) != NULL);
  94         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
  95         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
  96         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
  97                 skipping("This system cannot convert character-set"
  98                     " from UTF-8 to eucJP.");
  99                 goto cleanup;
 100         }
 101
 102         assertEqualIntA(a, ARCHIVE_OK,
 103             archive_read_open_filename(a, refname, 10240));
 104
 105         /* Verify regular file. */
 106         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 107         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 108         assertEqualString("\xb4\xc1\xbb\xfa.txt", archive_entry_pathname(ae));
 109         assertEqualInt(8, archive_entry_size(ae));
 110
 111         /* Verify regular file. */
 112         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 113         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 114         assertEqualString("\xc9\xbd.txt", archive_entry_pathname(ae));
 115         assertEqualInt(4, archive_entry_size(ae));
 116
 117
 118         /* End of archive. */
 119         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 120
 121         /* Verify archive format. */
 122         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 123         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 124
 125         /* Close the archive. */
 126         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 127 cleanup:
 128         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 129 }
 130
 131 static void
 132 test_read_format_cpio_filename_UTF8_UTF8_jp(const char *refname)
 133 {
 134         struct archive *a;
 135         struct archive_entry *ae;
 136
 137         /*
 138          * Read UTF-8 filename in en_US.UTF-8 without "hdrcharset=UTF-8" option.
 139          */
 140         if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
 141                 skipping("en_US.UTF-8 locale not available on this system.");
 142                 return;
 143         }
 144
 145         assert((a = archive_read_new()) != NULL);
 146         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 147         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 148         assertEqualIntA(a, ARCHIVE_OK,
 149             archive_read_open_filename(a, refname, 10240));
 150
 151         /* Verify regular file. */
 152         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 153         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 154         assertEqualString("\xe6\xbc\xa2\xe5\xad\x97.txt",
 155             archive_entry_pathname(ae));
 156         assertEqualInt(8, archive_entry_size(ae));
 157
 158         /* Verify regular file. */
 159         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 160         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 161         assertEqualString("\xe8\xa1\xa8.txt", archive_entry_pathname(ae));
 162         assertEqualInt(4, archive_entry_size(ae));
 163
 164
 165         /* End of archive. */
 166         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 167
 168         /* Verify archive format. */
 169         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 170         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 171
 172         /* Close the archive. */
 173         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 174         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 175 }
 176
 177 static void
 178 test_read_format_cpio_filename_CP866_KOI8R(const char *refname)
 179 {
 180         struct archive *a;
 181         struct archive_entry *ae;
 182
 183         /*
 184          * Read CP866 filename in ru_RU.KOI8-R with "hdrcharset=CP866" option.
 185          */
 186         if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") &&
 187             NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
 188                 skipping("ru_RU.KOI8-R locale not available on this system.");
 189                 return;
 190         }
 191
 192         assert((a = archive_read_new()) != NULL);
 193         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 194         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 195         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
 196                 skipping("This system cannot convert character-set"
 197                     " from CP866 to KOI8-R.");
 198                 goto cleanup;
 199         }
 200         assertEqualIntA(a, ARCHIVE_OK,
 201             archive_read_open_filename(a, refname, 10240));
 202
 203         /* Verify regular file. */
 204         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 205         assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
 206             archive_entry_pathname(ae));
 207         assertEqualInt(6, archive_entry_size(ae));
 208
 209         /* Verify regular file. */
 210         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 211         assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
 212             archive_entry_pathname(ae));
 213         assertEqualInt(6, archive_entry_size(ae));
 214
 215
 216         /* End of archive. */
 217         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 218
 219         /* Verify archive format. */
 220         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 221         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 222
 223         /* Close the archive. */
 224         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 225 cleanup:
 226         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 227 }
 228
 229 static void
 230 test_read_format_cpio_filename_CP866_UTF8(const char *refname)
 231 {
 232         struct archive *a;
 233         struct archive_entry *ae;
 234
 235         /*
 236          * Read CP866 filename in en_US.UTF-8 with "hdrcharset=CP866" option.
 237          */
 238         if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
 239                 skipping("en_US.UTF-8 locale not available on this system.");
 240                 return;
 241         }
 242
 243         assert((a = archive_read_new()) != NULL);
 244         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 245         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 246         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
 247                 skipping("This system cannot convert character-set"
 248                     " from CP866 to UTF-8.");
 249                 goto cleanup;
 250         }
 251         assertEqualIntA(a, ARCHIVE_OK,
 252             archive_read_open_filename(a, refname, 10240));
 253
 254         /* Verify regular file. */
 255         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 256         assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
 257             archive_entry_pathname(ae));
 258         assertEqualInt(6, archive_entry_size(ae));
 259
 260         /* Verify regular file. */
 261         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 262         assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
 263             archive_entry_pathname(ae));
 264         assertEqualInt(6, archive_entry_size(ae));
 265
 266
 267         /* End of archive. */
 268         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 269
 270         /* Verify archive format. */
 271         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 272         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 273
 274         /* Close the archive. */
 275         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 276 cleanup:
 277         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 278 }
 279
 280 static void
 281 test_read_format_cpio_filename_KOI8R_CP866(const char *refname)
 282 {
 283         struct archive *a;
 284         struct archive_entry *ae;
 285
 286         /*
 287          * Read KOI8-R filename in ru_RU.CP866 with "hdrcharset=KOI8-R" option.
 288          */
 289         if (NULL == setlocale(LC_ALL, "Russian_Russia.866") &&
 290             NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
 291                 skipping("ru_RU.CP866 locale not available on this system.");
 292                 return;
 293         }
 294
 295         assert((a = archive_read_new()) != NULL);
 296         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 297         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 298         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
 299                 skipping("This system cannot convert character-set"
 300                     " from KOI8-R to CP866.");
 301                 goto cleanup;
 302         }
 303         assertEqualIntA(a, ARCHIVE_OK,
 304             archive_read_open_filename(a, refname, 10240));
 305
 306         /* Verify regular file. */
 307         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 308         assertEqualString("\x8f\x90\x88\x82\x85\x92",
 309             archive_entry_pathname(ae));
 310         assertEqualInt(6, archive_entry_size(ae));
 311
 312         /* Verify regular file. */
 313         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 314         assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
 315             archive_entry_pathname(ae));
 316         assertEqualInt(6, archive_entry_size(ae));
 317
 318
 319         /* End of archive. */
 320         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 321
 322         /* Verify archive format. */
 323         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 324         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 325
 326         /* Close the archive. */
 327         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 328 cleanup:
 329         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 330 }
 331
 332 static void
 333 test_read_format_cpio_filename_KOI8R_UTF8(const char *refname)
 334 {
 335         struct archive *a;
 336         struct archive_entry *ae;
 337
 338         /*
 339          * Read KOI8-R filename in en_US.UTF-8 with "hdrcharset=KOI8-R" option.
 340          */
 341         if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
 342                 skipping("en_US.UTF-8 locale not available on this system.");
 343                 return;
 344         }
 345
 346         assert((a = archive_read_new()) != NULL);
 347         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 348         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 349         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
 350                 skipping("This system cannot convert character-set"
 351                     " from KOI8-R to UTF-8.");
 352                 goto cleanup;
 353         }
 354         assertEqualIntA(a, ARCHIVE_OK,
 355             archive_read_open_filename(a, refname, 10240));
 356
 357         /* Verify regular file. */
 358         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 359         assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
 360             archive_entry_pathname(ae));
 361         assertEqualInt(6, archive_entry_size(ae));
 362
 363         /* Verify regular file. */
 364         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 365         assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
 366             archive_entry_pathname(ae));
 367         assertEqualInt(6, archive_entry_size(ae));
 368
 369
 370         /* End of archive. */
 371         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 372
 373         /* Verify archive format. */
 374         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 375         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 376
 377         /* Close the archive. */
 378         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 379 cleanup:
 380         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 381 }
 382
 383 static void
 384 test_read_format_cpio_filename_UTF8_KOI8R(const char *refname)
 385 {
 386         struct archive *a;
 387         struct archive_entry *ae;
 388
 389         /*
 390          * Read UTF-8 filename in ru_RU.KOI8-R with "hdrcharset=UTF-8" option.
 391          */
 392         if (NULL == setlocale(LC_ALL, "Russian_Russia.20866") &&
 393             NULL == setlocale(LC_ALL, "ru_RU.KOI8-R")) {
 394                 skipping("ru_RU.KOI8-R locale not available on this system.");
 395                 return;
 396         }
 397
 398         assert((a = archive_read_new()) != NULL);
 399         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 400         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 401         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
 402                 skipping("This system cannot convert character-set"
 403                     " from UTF-8 to KOI8-R.");
 404                 goto cleanup;
 405         }
 406         assertEqualIntA(a, ARCHIVE_OK,
 407             archive_read_open_filename(a, refname, 10240));
 408
 409         /* Verify regular file. */
 410         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 411         assertEqualString("\xf0\xf2\xe9\xf7\xe5\xf4",
 412             archive_entry_pathname(ae));
 413         assertEqualInt(6, archive_entry_size(ae));
 414
 415         /* Verify regular file. */
 416         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 417         assertEqualString("\xd0\xd2\xc9\xd7\xc5\xd4",
 418             archive_entry_pathname(ae));
 419         assertEqualInt(6, archive_entry_size(ae));
 420
 421
 422         /* End of archive. */
 423         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 424
 425         /* Verify archive format. */
 426         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 427         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 428
 429         /* Close the archive. */
 430         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 431 cleanup:
 432         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 433 }
 434
 435 static void
 436 test_read_format_cpio_filename_UTF8_CP866(const char *refname)
 437 {
 438         struct archive *a;
 439         struct archive_entry *ae;
 440
 441         /*
 442          * Read UTF-8 filename in ru_RU.CP866 with "hdrcharset=UTF-8" option.
 443          */
 444         if (NULL == setlocale(LC_ALL, "Russian_Russia.866") &&
 445                 NULL == setlocale(LC_ALL, "ru_RU.CP866")) {
 446                 skipping("ru_RU.CP866 locale not available on this system.");
 447                 return;
 448         }
 449
 450         assert((a = archive_read_new()) != NULL);
 451         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 452         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 453         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
 454                 skipping("This system cannot convert character-set"
 455                     " from UTF-8 to CP866.");
 456                 goto cleanup;
 457         }
 458         assertEqualIntA(a, ARCHIVE_OK,
 459             archive_read_open_filename(a, refname, 10240));
 460
 461         /* Verify regular file. */
 462         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 463         assertEqualString("\x8f\x90\x88\x82\x85\x92",
 464             archive_entry_pathname(ae));
 465         assertEqualInt(6, archive_entry_size(ae));
 466
 467         /* Verify regular file. */
 468         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 469         assertEqualString("\xaf\xe0\xa8\xa2\xa5\xe2",
 470             archive_entry_pathname(ae));
 471         assertEqualInt(6, archive_entry_size(ae));
 472
 473
 474         /* End of archive. */
 475         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 476
 477         /* Verify archive format. */
 478         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 479         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 480
 481         /* Close the archive. */
 482         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 483 cleanup:
 484         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 485 }
 486
 487 static void
 488 test_read_format_cpio_filename_UTF8_UTF8_ru(const char *refname)
 489 {
 490         struct archive *a;
 491         struct archive_entry *ae;
 492
 493         /*
 494          * Read UTF-8 filename in en_US.UTF-8 without "hdrcharset=UTF-8" option.
 495          */
 496         if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
 497                 skipping("en_US.UTF-8 locale not available on this system.");
 498                 return;
 499         }
 500
 501         assert((a = archive_read_new()) != NULL);
 502         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 503         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 504         assertEqualIntA(a, ARCHIVE_OK,
 505             archive_read_open_filename(a, refname, 10240));
 506
 507         /* Verify regular file. */
 508         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 509         assertEqualString("\xd0\x9f\xd0\xa0\xd0\x98\xd0\x92\xd0\x95\xd0\xa2",
 510             archive_entry_pathname(ae));
 511         assertEqualInt(6, archive_entry_size(ae));
 512
 513         /* Verify regular file. */
 514         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 515         assertEqualString("\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82",
 516             archive_entry_pathname(ae));
 517         assertEqualInt(6, archive_entry_size(ae));
 518
 519
 520         /* End of archive. */
 521         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 522
 523         /* Verify archive format. */
 524         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 525         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 526
 527         /* Close the archive. */
 528         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 529         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 530 }
 531
 532 static void
 533 test_read_format_cpio_filename_eucJP_CP932(const char *refname)
 534 {
 535         struct archive *a;
 536         struct archive_entry *ae;
 537
 538         /*
 539          * Read eucJP filename in CP932/SJIS with "hdrcharset=eucJP" option.
 540          */
 541         if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
 542             NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
 543                 skipping("CP932 locale not available on this system.");
 544                 return;
 545         }
 546
 547         assert((a = archive_read_new()) != NULL);
 548         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 549         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 550         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=eucJP")) {
 551                 skipping("This system cannot convert character-set"
 552                     " from eucJP.");
 553                 goto cleanup;
 554         }
 555         assertEqualIntA(a, ARCHIVE_OK,
 556             archive_read_open_filename(a, refname, 10240));
 557
 558         /* Verify regular file. */
 559         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 560         assertEqualString("\x8a\xbf\x8e\x9a.txt", archive_entry_pathname(ae));
 561         assertEqualInt(8, archive_entry_size(ae));
 562
 563         /* Verify regular file. */
 564         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 565         assertEqualString("\x95\x5c.txt", archive_entry_pathname(ae));
 566         assertEqualInt(4, archive_entry_size(ae));
 567
 568
 569         /* End of archive. */
 570         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 571
 572         /* Verify archive format. */
 573         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 574         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 575
 576         /* Close the archive. */
 577         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 578 cleanup:
 579         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 580 }
 581
 582 static void
 583 test_read_format_cpio_filename_UTF8_CP932(const char *refname)
 584 {
 585         struct archive *a;
 586         struct archive_entry *ae;
 587
 588         /*
 589          * Read UTF-8 filename in CP932/SJIS with "hdrcharset=UTF-8" option.
 590          */
 591         if (NULL == setlocale(LC_ALL, "Japanese_Japan") &&
 592             NULL == setlocale(LC_ALL, "ja_JP.SJIS")) {
 593                 skipping("CP932 locale not available on this system.");
 594                 return;
 595         }
 596
 597         assert((a = archive_read_new()) != NULL);
 598         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 599         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 600         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
 601                 skipping("This system cannot convert character-set"
 602                     " from UTF-8 to CP932.");
 603                 goto cleanup;
 604         }
 605         assertEqualIntA(a, ARCHIVE_OK,
 606             archive_read_open_filename(a, refname, 10240));
 607
 608         /* Verify regular file. */
 609         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 610         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 611         assertEqualString("\x8a\xbf\x8e\x9a.txt", archive_entry_pathname(ae));
 612         assertEqualInt(8, archive_entry_size(ae));
 613
 614         /* Verify regular file. */
 615         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 616         assertEqualInt(AE_IFREG, archive_entry_filetype(ae));
 617         assertEqualString("\x95\x5c.txt", archive_entry_pathname(ae));
 618         assertEqualInt(4, archive_entry_size(ae));
 619
 620         /* End of archive. */
 621         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 622
 623         /* Verify archive format. */
 624         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 625         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 626
 627         /* Close the archive. */
 628         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 629 cleanup:
 630         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 631 }
 632
 633 static void
 634 test_read_format_cpio_filename_CP866_CP1251(const char *refname)
 635 {
 636         struct archive *a;
 637         struct archive_entry *ae;
 638
 639         /*
 640          * Read CP866 filename in CP1251 with "hdrcharset=CP866" option.
 641          */
 642         if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
 643             NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
 644                 skipping("CP1251 locale not available on this system.");
 645                 return;
 646         }
 647
 648         assert((a = archive_read_new()) != NULL);
 649         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 650         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 651         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=CP866")) {
 652                 skipping("This system cannot convert character-set"
 653                     " from CP866 to CP1251.");
 654                 goto cleanup;
 655         }
 656         assertEqualIntA(a, ARCHIVE_OK,
 657             archive_read_open_filename(a, refname, 10240));
 658
 659         /* Verify regular file. */
 660         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 661         assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
 662             archive_entry_pathname(ae));
 663         assertEqualInt(6, archive_entry_size(ae));
 664
 665         /* Verify regular file. */
 666         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 667         assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
 668             archive_entry_pathname(ae));
 669         assertEqualInt(6, archive_entry_size(ae));
 670
 671
 672         /* End of archive. */
 673         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 674
 675         /* Verify archive format. */
 676         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 677         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 678
 679         /* Close the archive. */
 680         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 681 cleanup:
 682         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 683 }
 684
 685 /*
 686  * This test only for Windows platform because other archiver
 687  * applications on Windows translate CP1251 filenames into CP866
 688  * filenames and store it in the cpio file and so we should read
 689  * it by default on Windows.
 690  */
 691 static void
 692 test_read_format_cpio_filename_CP866_CP1251_win(const char *refname)
 693 {
 694         struct archive *a;
 695         struct archive_entry *ae;
 696
 697         /*
 698          * Read CP866 filename in CP1251 without "hdrcharset=CP866" option.
 699          */
 700         if (NULL == setlocale(LC_ALL, "Russian_Russia")) {
 701                 skipping("Russian_Russia locale not available on this system.");
 702                 return;
 703         }
 704
 705         assert((a = archive_read_new()) != NULL);
 706         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 707         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 708         assertEqualIntA(a, ARCHIVE_OK,
 709             archive_read_open_filename(a, refname, 10240));
 710
 711         /* Verify regular file. */
 712         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 713         assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
 714             archive_entry_pathname(ae));
 715         assertEqualInt(6, archive_entry_size(ae));
 716
 717         /* Verify regular file. */
 718         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 719         assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
 720             archive_entry_pathname(ae));
 721         assertEqualInt(6, archive_entry_size(ae));
 722
 723
 724         /* End of archive. */
 725         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 726
 727         /* Verify archive format. */
 728         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 729         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 730
 731         /* Close the archive. */
 732         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 733         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 734 }
 735
 736 static void
 737 test_read_format_cpio_filename_KOI8R_CP1251(const char *refname)
 738 {
 739         struct archive *a;
 740         struct archive_entry *ae;
 741
 742         /*
 743          * Read KOI8-R filename in CP1251 with "hdrcharset=KOI8-R" option.
 744          */
 745         if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
 746             NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
 747                 skipping("CP1251 locale not available on this system.");
 748                 return;
 749         }
 750
 751         assert((a = archive_read_new()) != NULL);
 752         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 753         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 754         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=KOI8-R")) {
 755                 skipping("This system cannot convert character-set"
 756                     " from KOI8-R to CP1251.");
 757                 goto cleanup;
 758         }
 759         assertEqualIntA(a, ARCHIVE_OK,
 760             archive_read_open_filename(a, refname, 10240));
 761
 762         /* Verify regular file. */
 763         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 764         assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
 765             archive_entry_pathname(ae));
 766         assertEqualInt(6, archive_entry_size(ae));
 767
 768         /* Verify regular file. */
 769         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 770         assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
 771             archive_entry_pathname(ae));
 772         assertEqualInt(6, archive_entry_size(ae));
 773
 774
 775         /* End of archive. */
 776         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 777
 778         /* Verify archive format. */
 779         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 780         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 781
 782         /* Close the archive. */
 783         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 784 cleanup:
 785         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 786 }
 787
 788 static void
 789 test_read_format_cpio_filename_UTF8_CP1251(const char *refname)
 790 {
 791         struct archive *a;
 792         struct archive_entry *ae;
 793
 794         /*
 795          * Read KOI8-R filename in CP1251 with "hdrcharset=KOI8-R" option.
 796          */
 797         if (NULL == setlocale(LC_ALL, "Russian_Russia") &&
 798             NULL == setlocale(LC_ALL, "ru_RU.CP1251")) {
 799                 skipping("CP1251 locale not available on this system.");
 800                 return;
 801         }
 802
 803         assert((a = archive_read_new()) != NULL);
 804         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
 805         assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_all(a));
 806         if (ARCHIVE_OK != archive_read_set_options(a, "hdrcharset=UTF-8")) {
 807                 skipping("This system cannot convert character-set"
 808                     " from UTF-8 to CP1251.");
 809                 goto cleanup;
 810         }
 811         assertEqualIntA(a, ARCHIVE_OK,
 812             archive_read_open_filename(a, refname, 10240));
 813
 814         /* Verify regular file. */
 815         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 816         assertEqualString("\xcf\xd0\xc8\xc2\xc5\xd2",
 817             archive_entry_pathname(ae));
 818         assertEqualInt(6, archive_entry_size(ae));
 819
 820         /* Verify regular file. */
 821         assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
 822         assertEqualString("\xef\xf0\xe8\xe2\xe5\xf2",
 823             archive_entry_pathname(ae));
 824         assertEqualInt(6, archive_entry_size(ae));
 825
 826
 827         /* End of archive. */
 828         assertEqualIntA(a, ARCHIVE_EOF, archive_read_next_header(a, &ae));
 829
 830         /* Verify archive format. */
 831         assertEqualIntA(a, ARCHIVE_FILTER_NONE, archive_filter_code(a, 0));
 832         assertEqualIntA(a, ARCHIVE_FORMAT_CPIO_POSIX, archive_format(a));
 833
 834         /* Close the archive. */
 835         assertEqualInt(ARCHIVE_OK, archive_read_close(a));
 836 cleanup:
 837         assertEqualInt(ARCHIVE_OK, archive_read_free(a));
 838 }
 839
 840
 841 DEFINE_TEST(test_read_format_cpio_filename)
 842 {
 843         const char *refname1 = "test_read_format_cpio_filename_eucjp.cpio";
 844         const char *refname2 = "test_read_format_cpio_filename_utf8_jp.cpio";
 845         const char *refname3 = "test_read_format_cpio_filename_cp866.cpio";
 846         const char *refname4 = "test_read_format_cpio_filename_koi8r.cpio";
 847         const char *refname5 = "test_read_format_cpio_filename_utf8_ru.cpio";
 848
 849         extract_reference_file(refname1);
 850         test_read_format_cpio_filename_eucJP_UTF8(refname1);
 851         test_read_format_cpio_filename_eucJP_CP932(refname1);
 852
 853         extract_reference_file(refname2);
 854         test_read_format_cpio_filename_UTF8_eucJP(refname2);
 855         test_read_format_cpio_filename_UTF8_UTF8_jp(refname2);
 856         test_read_format_cpio_filename_UTF8_CP932(refname2);
 857
 858         extract_reference_file(refname3);
 859         test_read_format_cpio_filename_CP866_KOI8R(refname3);
 860         test_read_format_cpio_filename_CP866_UTF8(refname3);
 861         test_read_format_cpio_filename_CP866_CP1251(refname3);
 862         test_read_format_cpio_filename_CP866_CP1251_win(refname3);
 863
 864         extract_reference_file(refname4);
 865         test_read_format_cpio_filename_KOI8R_CP866(refname4);
 866         test_read_format_cpio_filename_KOI8R_UTF8(refname4);
 867         test_read_format_cpio_filename_KOI8R_CP1251(refname4);
 868
 869         extract_reference_file(refname5);
 870         test_read_format_cpio_filename_UTF8_KOI8R(refname5);
 871         test_read_format_cpio_filename_UTF8_CP866(refname5);
 872         test_read_format_cpio_filename_UTF8_UTF8_ru(refname5);
 873         test_read_format_cpio_filename_UTF8_CP1251(refname5);
 874 }