contrib/libarchive/libarchive/test/test_entry.c

   1 /*-
   2  * Copyright (c) 2003-2007 Tim Kientzle
   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 #ifdef HAVE_LINUX_FS_H
  31 #include <linux/fs.h>   /* for Linux file flags */
  32 #endif
  33
  34 #ifndef HAVE_WCSCPY
  35 static wchar_t * wcscpy(wchar_t *s1, const wchar_t *s2)
  36 {
  37         wchar_t *dest = s1;
  38         while ((*s1 = *s2) != L'\0')
  39                 ++s1, ++s2;
  40         return dest;
  41 }
  42 #endif
  43
  44 /*
  45  * Most of these tests are system-independent, though a few depend on
  46  * features of the local system.  Such tests are conditionalized on
  47  * the platform name.  On unsupported platforms, only the
  48  * system-independent features will be tested.
  49  *
  50  * No, I don't want to use config.h in the test files because I want
  51  * the tests to also serve as a check on the correctness of config.h.
  52  * A mis-configured library build should cause tests to fail.
  53  */
  54
  55 DEFINE_TEST(test_entry)
  56 {
  57         char buff[128];
  58         wchar_t wbuff[128];
  59         struct stat st;
  60         struct archive_entry *e, *e2;
  61         const struct stat *pst;
  62         unsigned long set, clear; /* For fflag testing. */
  63         int type, permset, tag, qual; /* For ACL testing. */
  64         const char *name; /* For ACL testing. */
  65         const char *xname; /* For xattr tests. */
  66         const void *xval; /* For xattr tests. */
  67         size_t xsize; /* For xattr tests. */
  68         wchar_t wc;
  69         long l;
  70         int i;
  71
  72         assert((e = archive_entry_new()) != NULL);
  73
  74         /*
  75          * Verify that the AE_IF* defines match S_IF* defines
  76          * on this platform. See comments in archive_entry.h.
  77          */
  78 #ifdef S_IFREG
  79         assertEqualInt(S_IFREG, AE_IFREG);
  80 #endif
  81 #ifdef S_IFLNK
  82         assertEqualInt(S_IFLNK, AE_IFLNK);
  83 #endif
  84 #ifdef S_IFSOCK
  85         assertEqualInt(S_IFSOCK, AE_IFSOCK);
  86 #endif
  87 #ifdef S_IFCHR
  88         assertEqualInt(S_IFCHR, AE_IFCHR);
  89 #endif
  90 /* Work around MinGW, which defines S_IFBLK wrong. */
  91 /* sourceforge.net/tracker/?func=detail&atid=102435&aid=1942809&group_id=2435 */
  92 #if defined(S_IFBLK) && !defined(_WIN32)
  93         assertEqualInt(S_IFBLK, AE_IFBLK);
  94 #endif
  95 #ifdef S_IFDIR
  96         assertEqualInt(S_IFDIR, AE_IFDIR);
  97 #endif
  98 #ifdef S_IFIFO
  99         assertEqualInt(S_IFIFO, AE_IFIFO);
 100 #endif
 101
 102         /*
 103          * Basic set/read tests for all fields.
 104          * We should be able to set any field and read
 105          * back the same value.
 106          *
 107          * For methods that "copy" a string, we should be able
 108          * to overwrite the original passed-in string without
 109          * changing the value in the entry.
 110          *
 111          * The following tests are ordered alphabetically by the
 112          * name of the field.
 113          */
 114
 115         /* atime */
 116         archive_entry_set_atime(e, 13579, 24680);
 117         assertEqualInt(archive_entry_atime(e), 13579);
 118         assertEqualInt(archive_entry_atime_nsec(e), 24680);
 119         archive_entry_set_atime(e, 13580, 1000000001L);
 120         assertEqualInt(archive_entry_atime(e), 13581);
 121         assertEqualInt(archive_entry_atime_nsec(e), 1);
 122         archive_entry_set_atime(e, 13580, -7);
 123         assertEqualInt(archive_entry_atime(e), 13579);
 124         assertEqualInt(archive_entry_atime_nsec(e), 999999993);
 125         archive_entry_unset_atime(e);
 126         assertEqualInt(archive_entry_atime(e), 0);
 127         assertEqualInt(archive_entry_atime_nsec(e), 0);
 128         assert(!archive_entry_atime_is_set(e));
 129
 130         /* birthtime */
 131         archive_entry_set_birthtime(e, 17579, 24990);
 132         assertEqualInt(archive_entry_birthtime(e), 17579);
 133         assertEqualInt(archive_entry_birthtime_nsec(e), 24990);
 134         archive_entry_set_birthtime(e, 17580, 1234567890L);
 135         assertEqualInt(archive_entry_birthtime(e), 17581);
 136         assertEqualInt(archive_entry_birthtime_nsec(e), 234567890);
 137         archive_entry_set_birthtime(e, 17581, -24990);
 138         assertEqualInt(archive_entry_birthtime(e), 17580);
 139         assertEqualInt(archive_entry_birthtime_nsec(e), 999975010);
 140         archive_entry_unset_birthtime(e);
 141         assertEqualInt(archive_entry_birthtime(e), 0);
 142         assertEqualInt(archive_entry_birthtime_nsec(e), 0);
 143         assert(!archive_entry_birthtime_is_set(e));
 144
 145         /* ctime */
 146         archive_entry_set_ctime(e, 13580, 24681);
 147         assertEqualInt(archive_entry_ctime(e), 13580);
 148         assertEqualInt(archive_entry_ctime_nsec(e), 24681);
 149         archive_entry_set_ctime(e, 13581, 2008182348L);
 150         assertEqualInt(archive_entry_ctime(e), 13583);
 151         assertEqualInt(archive_entry_ctime_nsec(e), 8182348);
 152         archive_entry_set_ctime(e, 13582, -24681);
 153         assertEqualInt(archive_entry_ctime(e), 13581);
 154         assertEqualInt(archive_entry_ctime_nsec(e), 999975319);
 155         archive_entry_unset_ctime(e);
 156         assertEqualInt(archive_entry_ctime(e), 0);
 157         assertEqualInt(archive_entry_ctime_nsec(e), 0);
 158         assert(!archive_entry_ctime_is_set(e));
 159
 160         /* dev */
 161         assert(!archive_entry_dev_is_set(e));
 162         archive_entry_set_dev(e, 235);
 163         assert(archive_entry_dev_is_set(e));
 164         assertEqualInt(archive_entry_dev(e), 235);
 165         /* devmajor/devminor are tested specially below. */
 166
 167         /* filetype */
 168         archive_entry_set_filetype(e, AE_IFREG);
 169         assertEqualInt(archive_entry_filetype(e), AE_IFREG);
 170
 171         /* fflags are tested specially below */
 172
 173         /* gid */
 174         archive_entry_set_gid(e, 204);
 175         assertEqualInt(archive_entry_gid(e), 204);
 176
 177         /* gname */
 178         archive_entry_set_gname(e, "group");
 179         assertEqualString(archive_entry_gname(e), "group");
 180         assertEqualString(archive_entry_gname_utf8(e), "group");
 181         assertEqualWString(archive_entry_gname_w(e), L"group");
 182         wcscpy(wbuff, L"wgroup");
 183         archive_entry_copy_gname_w(e, wbuff);
 184         assertEqualWString(archive_entry_gname_w(e), L"wgroup");
 185         memset(wbuff, 0, sizeof(wbuff));
 186         assertEqualWString(archive_entry_gname_w(e), L"wgroup");
 187         assertEqualString(archive_entry_gname_utf8(e), "wgroup");
 188         assertEqualString(archive_entry_gname(e), "wgroup");
 189         archive_entry_set_gname_utf8(e, "group");
 190         assertEqualString(archive_entry_gname_utf8(e), "group");
 191         assertEqualWString(archive_entry_gname_w(e), L"group");
 192         assertEqualString(archive_entry_gname(e), "group");
 193         archive_entry_update_gname_utf8(e, "group2");
 194         assertEqualString(archive_entry_gname_utf8(e), "group2");
 195         assertEqualWString(archive_entry_gname_w(e), L"group2");
 196         assertEqualString(archive_entry_gname(e), "group2");
 197
 198         /* hardlink */
 199         archive_entry_set_hardlink(e, "hardlinkname");
 200         assertEqualString(archive_entry_hardlink(e), "hardlinkname");
 201         assertEqualString(archive_entry_hardlink_utf8(e), "hardlinkname");
 202         assertEqualWString(archive_entry_hardlink_w(e), L"hardlinkname");
 203         strcpy(buff, "hardlinkname2");
 204         archive_entry_copy_hardlink(e, buff);
 205         assertEqualString(archive_entry_hardlink(e), "hardlinkname2");
 206         assertEqualWString(archive_entry_hardlink_w(e), L"hardlinkname2");
 207         assertEqualString(archive_entry_hardlink_utf8(e), "hardlinkname2");
 208         memset(buff, 0, sizeof(buff));
 209         assertEqualString(archive_entry_hardlink(e), "hardlinkname2");
 210         assertEqualString(archive_entry_hardlink_utf8(e), "hardlinkname2");
 211         assertEqualWString(archive_entry_hardlink_w(e), L"hardlinkname2");
 212         archive_entry_copy_hardlink(e, NULL);
 213         assertEqualString(archive_entry_hardlink(e), NULL);
 214         assertEqualWString(archive_entry_hardlink_w(e), NULL);
 215         assertEqualString(archive_entry_hardlink_utf8(e), NULL);
 216         wcscpy(wbuff, L"whardlink");
 217         archive_entry_copy_hardlink_w(e, wbuff);
 218         assertEqualWString(archive_entry_hardlink_w(e), L"whardlink");
 219         assertEqualString(archive_entry_hardlink_utf8(e), "whardlink");
 220         assertEqualString(archive_entry_hardlink(e), "whardlink");
 221         memset(wbuff, 0, sizeof(wbuff));
 222         assertEqualWString(archive_entry_hardlink_w(e), L"whardlink");
 223         archive_entry_copy_hardlink_w(e, NULL);
 224         assertEqualString(archive_entry_hardlink(e), NULL);
 225         assertEqualWString(archive_entry_hardlink_w(e), NULL);
 226         archive_entry_set_hardlink_utf8(e, "hardlinkname");
 227         assertEqualString(archive_entry_hardlink_utf8(e), "hardlinkname");
 228         assertEqualWString(archive_entry_hardlink_w(e), L"hardlinkname");
 229         assertEqualString(archive_entry_hardlink(e), "hardlinkname");
 230         archive_entry_update_hardlink_utf8(e, "hardlinkname2");
 231         assertEqualString(archive_entry_hardlink_utf8(e), "hardlinkname2");
 232         assertEqualWString(archive_entry_hardlink_w(e), L"hardlinkname2");
 233         assertEqualString(archive_entry_hardlink(e), "hardlinkname2");
 234
 235         /* ino */
 236         assert(!archive_entry_ino_is_set(e));
 237         archive_entry_set_ino(e, 8593);
 238         assert(archive_entry_ino_is_set(e));
 239         assertEqualInt(archive_entry_ino(e), 8593);
 240         assertEqualInt(archive_entry_ino64(e), 8593);
 241         archive_entry_set_ino64(e, 8594);
 242         assert(archive_entry_ino_is_set(e));
 243         assertEqualInt(archive_entry_ino(e), 8594);
 244         assertEqualInt(archive_entry_ino64(e), 8594);
 245
 246         /* link */
 247         archive_entry_set_hardlink(e, "hardlinkname");
 248         archive_entry_set_symlink(e, NULL);
 249         archive_entry_set_link(e, "link");
 250         assertEqualString(archive_entry_hardlink(e), "link");
 251         assertEqualString(archive_entry_symlink(e), NULL);
 252         archive_entry_copy_link(e, "link2");
 253         assertEqualString(archive_entry_hardlink(e), "link2");
 254         assertEqualString(archive_entry_symlink(e), NULL);
 255         archive_entry_copy_link_w(e, L"link3");
 256         assertEqualString(archive_entry_hardlink(e), "link3");
 257         assertEqualString(archive_entry_symlink(e), NULL);
 258         archive_entry_set_hardlink(e, NULL);
 259         archive_entry_set_symlink(e, "symlink");
 260         archive_entry_set_link(e, "link");
 261         assertEqualString(archive_entry_hardlink(e), NULL);
 262         assertEqualString(archive_entry_symlink(e), "link");
 263         archive_entry_copy_link(e, "link2");
 264         assertEqualString(archive_entry_hardlink(e), NULL);
 265         assertEqualString(archive_entry_symlink(e), "link2");
 266         archive_entry_copy_link_w(e, L"link3");
 267         assertEqualString(archive_entry_hardlink(e), NULL);
 268         assertEqualString(archive_entry_symlink(e), "link3");
 269         /* Arbitrarily override symlink if both hardlink and symlink set. */
 270         archive_entry_set_hardlink(e, "hardlink");
 271         archive_entry_set_symlink(e, "symlink");
 272         archive_entry_set_link(e, "link");
 273         assertEqualString(archive_entry_hardlink(e), "hardlink");
 274         assertEqualString(archive_entry_symlink(e), "link");
 275
 276         /* mode */
 277         archive_entry_set_mode(e, 0123456);
 278         assertEqualInt(archive_entry_mode(e), 0123456);
 279
 280         /* mtime */
 281         archive_entry_set_mtime(e, 13581, 24682);
 282         assertEqualInt(archive_entry_mtime(e), 13581);
 283         assertEqualInt(archive_entry_mtime_nsec(e), 24682);
 284         archive_entry_set_mtime(e, 13582, 1358297468);
 285         assertEqualInt(archive_entry_mtime(e), 13583);
 286         assertEqualInt(archive_entry_mtime_nsec(e), 358297468);
 287         archive_entry_set_mtime(e, 13583, -24682);
 288         assertEqualInt(archive_entry_mtime(e), 13582);
 289         assertEqualInt(archive_entry_mtime_nsec(e), 999975318);
 290         archive_entry_unset_mtime(e);
 291         assertEqualInt(archive_entry_mtime(e), 0);
 292         assertEqualInt(archive_entry_mtime_nsec(e), 0);
 293         assert(!archive_entry_mtime_is_set(e));
 294
 295         /* nlink */
 296         archive_entry_set_nlink(e, 736);
 297         assertEqualInt(archive_entry_nlink(e), 736);
 298
 299         /* pathname */
 300         archive_entry_set_pathname(e, "path");
 301         assertEqualString(archive_entry_pathname(e), "path");
 302         assertEqualString(archive_entry_pathname_utf8(e), "path");
 303         assertEqualWString(archive_entry_pathname_w(e), L"path");
 304         archive_entry_set_pathname(e, "path");
 305         assertEqualString(archive_entry_pathname(e), "path");
 306         assertEqualWString(archive_entry_pathname_w(e), L"path");
 307         assertEqualString(archive_entry_pathname_utf8(e), "path");
 308         strcpy(buff, "path2");
 309         archive_entry_copy_pathname(e, buff);
 310         assertEqualString(archive_entry_pathname(e), "path2");
 311         assertEqualWString(archive_entry_pathname_w(e), L"path2");
 312         assertEqualString(archive_entry_pathname_utf8(e), "path2");
 313         memset(buff, 0, sizeof(buff));
 314         assertEqualString(archive_entry_pathname(e), "path2");
 315         assertEqualString(archive_entry_pathname_utf8(e), "path2");
 316         assertEqualWString(archive_entry_pathname_w(e), L"path2");
 317         wcscpy(wbuff, L"wpath");
 318         archive_entry_copy_pathname_w(e, wbuff);
 319         assertEqualWString(archive_entry_pathname_w(e), L"wpath");
 320         assertEqualString(archive_entry_pathname_utf8(e), "wpath");
 321         assertEqualString(archive_entry_pathname(e), "wpath");
 322         memset(wbuff, 0, sizeof(wbuff));
 323         assertEqualWString(archive_entry_pathname_w(e), L"wpath");
 324         assertEqualString(archive_entry_pathname(e), "wpath");
 325         assertEqualString(archive_entry_pathname_utf8(e), "wpath");
 326         archive_entry_set_pathname_utf8(e, "path");
 327         assertEqualWString(archive_entry_pathname_w(e), L"path");
 328         assertEqualString(archive_entry_pathname(e), "path");
 329         assertEqualString(archive_entry_pathname_utf8(e), "path");
 330         archive_entry_update_pathname_utf8(e, "path2");
 331         assertEqualWString(archive_entry_pathname_w(e), L"path2");
 332         assertEqualString(archive_entry_pathname(e), "path2");
 333         assertEqualString(archive_entry_pathname_utf8(e), "path2");
 334
 335         /* rdev */
 336         archive_entry_set_rdev(e, 532);
 337         assertEqualInt(archive_entry_rdev(e), 532);
 338         /* rdevmajor/rdevminor are tested specially below. */
 339
 340         /* size */
 341         archive_entry_set_size(e, 987654321);
 342         assertEqualInt(archive_entry_size(e), 987654321);
 343         archive_entry_unset_size(e);
 344         assertEqualInt(archive_entry_size(e), 0);
 345         assert(!archive_entry_size_is_set(e));
 346
 347         /* sourcepath */
 348         archive_entry_copy_sourcepath(e, "path1");
 349         assertEqualString(archive_entry_sourcepath(e), "path1");
 350
 351         /* symlink */
 352         archive_entry_set_symlink(e, "symlinkname");
 353         assertEqualString(archive_entry_symlink(e), "symlinkname");
 354         assertEqualString(archive_entry_symlink_utf8(e), "symlinkname");
 355         assertEqualWString(archive_entry_symlink_w(e), L"symlinkname");
 356         strcpy(buff, "symlinkname2");
 357         archive_entry_copy_symlink(e, buff);
 358         assertEqualString(archive_entry_symlink(e), "symlinkname2");
 359         assertEqualWString(archive_entry_symlink_w(e), L"symlinkname2");
 360         assertEqualString(archive_entry_symlink_utf8(e), "symlinkname2");
 361         memset(buff, 0, sizeof(buff));
 362         assertEqualString(archive_entry_symlink(e), "symlinkname2");
 363         assertEqualString(archive_entry_symlink_utf8(e), "symlinkname2");
 364         assertEqualWString(archive_entry_symlink_w(e), L"symlinkname2");
 365         archive_entry_copy_symlink_w(e, NULL);
 366         assertEqualWString(archive_entry_symlink_w(e), NULL);
 367         assertEqualString(archive_entry_symlink(e), NULL);
 368         assertEqualString(archive_entry_symlink_utf8(e), NULL);
 369         archive_entry_copy_symlink_w(e, L"wsymlink");
 370         assertEqualWString(archive_entry_symlink_w(e), L"wsymlink");
 371         assertEqualString(archive_entry_symlink_utf8(e), "wsymlink");
 372         assertEqualString(archive_entry_symlink(e), "wsymlink");
 373         archive_entry_copy_symlink(e, NULL);
 374         assertEqualWString(archive_entry_symlink_w(e), NULL);
 375         assertEqualString(archive_entry_symlink(e), NULL);
 376         assertEqualString(archive_entry_symlink_utf8(e), NULL);
 377         archive_entry_set_symlink_utf8(e, "symlinkname");
 378         assertEqualWString(archive_entry_symlink_w(e), L"symlinkname");
 379         assertEqualString(archive_entry_symlink(e), "symlinkname");
 380         assertEqualString(archive_entry_symlink_utf8(e), "symlinkname");
 381         archive_entry_update_symlink_utf8(e, "symlinkname2");
 382         assertEqualWString(archive_entry_symlink_w(e), L"symlinkname2");
 383         assertEqualString(archive_entry_symlink(e), "symlinkname2");
 384         assertEqualString(archive_entry_symlink_utf8(e), "symlinkname2");
 385
 386         /* uid */
 387         archive_entry_set_uid(e, 83);
 388         assertEqualInt(archive_entry_uid(e), 83);
 389
 390         /* uname */
 391         archive_entry_set_uname(e, "user");
 392         assertEqualString(archive_entry_uname(e), "user");
 393         assertEqualString(archive_entry_uname_utf8(e), "user");
 394         assertEqualWString(archive_entry_uname_w(e), L"user");
 395         wcscpy(wbuff, L"wuser");
 396         archive_entry_copy_uname_w(e, wbuff);
 397         assertEqualWString(archive_entry_uname_w(e), L"wuser");
 398         memset(wbuff, 0, sizeof(wbuff));
 399         assertEqualWString(archive_entry_uname_w(e), L"wuser");
 400         assertEqualString(archive_entry_uname_utf8(e), "wuser");
 401         assertEqualString(archive_entry_uname(e), "wuser");
 402         archive_entry_set_uname_utf8(e, "user");
 403         assertEqualString(archive_entry_uname_utf8(e), "user");
 404         assertEqualWString(archive_entry_uname_w(e), L"user");
 405         assertEqualString(archive_entry_uname(e), "user");
 406         archive_entry_set_uname_utf8(e, "user");
 407         assertEqualWString(archive_entry_uname_w(e), L"user");
 408         assertEqualString(archive_entry_uname(e), "user");
 409         assertEqualString(archive_entry_uname_utf8(e), "user");
 410         archive_entry_update_uname_utf8(e, "user2");
 411         assertEqualWString(archive_entry_uname_w(e), L"user2");
 412         assertEqualString(archive_entry_uname(e), "user2");
 413         assertEqualString(archive_entry_uname_utf8(e), "user2");
 414
 415         /* Test fflags interface. */
 416         archive_entry_set_fflags(e, 0x55, 0xAA);
 417         archive_entry_fflags(e, &set, &clear);
 418         failure("Testing set/get of fflags data.");
 419         assertEqualInt(set, 0x55);
 420         failure("Testing set/get of fflags data.");
 421         assertEqualInt(clear, 0xAA);
 422 #ifdef __FreeBSD__
 423         /* Converting fflags bitmap to string is currently system-dependent. */
 424         /* TODO: Make this system-independent. */
 425         assertEqualString(archive_entry_fflags_text(e),
 426             "uappnd,nouchg,nodump,noopaque,uunlnk,nosystem");
 427 #endif
 428
 429 #if defined(__FreeBSD__) || defined(__APPLE__)
 430         /* Test archive_entry_copy_fflags_text_w() */
 431         archive_entry_copy_fflags_text_w(e, L" ,nouappnd, nouchg, dump,hidden");
 432         archive_entry_fflags(e, &set, &clear);
 433         assertEqualInt(UF_HIDDEN, set);
 434         assertEqualInt(UF_NODUMP | UF_IMMUTABLE | UF_APPEND, clear);
 435         /* Test archive_entry_copy_fflags_text() */
 436         archive_entry_copy_fflags_text(e, " ,nouappnd, nouchg, dump,hidden");
 437         archive_entry_fflags(e, &set, &clear);
 438         assertEqualInt(UF_HIDDEN, set);
 439         assertEqualInt(UF_NODUMP | UF_IMMUTABLE | UF_APPEND, clear);
 440 #elif defined(_WIN32) && !defined(CYGWIN)
 441         archive_entry_copy_fflags_text_w(e, L"rdonly,hidden,nosystem");
 442         archive_entry_fflags(e, &set, &clear);
 443         assertEqualInt(FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN, set);
 444         assertEqualInt(FILE_ATTRIBUTE_SYSTEM, clear);
 445         archive_entry_copy_fflags_text(e, "rdonly,hidden,nosystem");
 446         archive_entry_fflags(e, &set, &clear);
 447         assertEqualInt(FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN, set);
 448         assertEqualInt(FILE_ATTRIBUTE_SYSTEM, clear);
 449 #elif defined FS_IOC_GETFLAGS /* Linux */
 450         archive_entry_copy_fflags_text_w(e, L"sappnd,schg,dump,noundel");
 451         archive_entry_fflags(e, &set, &clear);
 452         assertEqualInt(FS_APPEND_FL | FS_IMMUTABLE_FL, set);
 453         assertEqualInt(FS_NODUMP_FL | FS_UNRM_FL, clear);
 454         archive_entry_copy_fflags_text(e, "sappnd,schg,dump,noundel");
 455         archive_entry_fflags(e, &set, &clear);
 456         assertEqualInt(FS_APPEND_FL | FS_IMMUTABLE_FL, set);
 457         assertEqualInt(FS_NODUMP_FL | FS_UNRM_FL, clear);
 458 #endif
 459
 460         /* See test_acl_basic.c for tests of ACL set/get consistency. */
 461
 462         /* Test xattrs set/get consistency. */
 463         archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue1", 12);
 464         assertEqualInt(1, archive_entry_xattr_reset(e));
 465         assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize));
 466         assertEqualString(xname, "xattr1");
 467         assertEqualString(xval, "xattrvalue1");
 468         assertEqualInt((int)xsize, 12);
 469         assertEqualInt(1, archive_entry_xattr_count(e));
 470         assertEqualInt(ARCHIVE_WARN,
 471             archive_entry_xattr_next(e, &xname, &xval, &xsize));
 472         assertEqualString(xname, NULL);
 473         assertEqualString(xval, NULL);
 474         assertEqualInt((int)xsize, 0);
 475         archive_entry_xattr_clear(e);
 476         assertEqualInt(0, archive_entry_xattr_reset(e));
 477         assertEqualInt(ARCHIVE_WARN,
 478             archive_entry_xattr_next(e, &xname, &xval, &xsize));
 479         assertEqualString(xname, NULL);
 480         assertEqualString(xval, NULL);
 481         assertEqualInt((int)xsize, 0);
 482         archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue1", 12);
 483         assertEqualInt(1, archive_entry_xattr_reset(e));
 484         archive_entry_xattr_add_entry(e, "xattr2", "xattrvalue2", 12);
 485         assertEqualInt(2, archive_entry_xattr_reset(e));
 486         assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize));
 487         assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize));
 488         assertEqualInt(ARCHIVE_WARN,
 489             archive_entry_xattr_next(e, &xname, &xval, &xsize));
 490         assertEqualString(xname, NULL);
 491         assertEqualString(xval, NULL);
 492         assertEqualInt((int)xsize, 0);
 493
 494
 495         /*
 496          * Test clone() implementation.
 497          */
 498
 499         /* Set values in 'e' */
 500         archive_entry_clear(e);
 501         archive_entry_set_atime(e, 13579, 24680);
 502         archive_entry_set_birthtime(e, 13779, 24990);
 503         archive_entry_set_ctime(e, 13580, 24681);
 504         archive_entry_set_dev(e, 235);
 505         archive_entry_set_fflags(e, 0x55, 0xAA);
 506         archive_entry_set_gid(e, 204);
 507         archive_entry_set_gname(e, "group");
 508         archive_entry_set_hardlink(e, "hardlinkname");
 509         archive_entry_set_ino(e, 8593);
 510         archive_entry_set_mode(e, 0123456);
 511         archive_entry_set_mtime(e, 13581, 24682);
 512         archive_entry_set_nlink(e, 736);
 513         archive_entry_set_pathname(e, "path");
 514         archive_entry_set_rdev(e, 532);
 515         archive_entry_set_size(e, 987654321);
 516         archive_entry_copy_sourcepath(e, "source");
 517         archive_entry_set_symlink(e, "symlinkname");
 518         archive_entry_set_uid(e, 83);
 519         archive_entry_set_uname(e, "user");
 520         /* Add an ACL entry. */
 521         archive_entry_acl_add_entry(e, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 522             ARCHIVE_ENTRY_ACL_READ, ARCHIVE_ENTRY_ACL_USER, 77, "user77");
 523         /* Add an extended attribute. */
 524         archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue", 11);
 525
 526         /* Make a clone. */
 527         e2 = archive_entry_clone(e);
 528
 529         /* Clone should have same contents. */
 530         assertEqualInt(archive_entry_atime(e2), 13579);
 531         assertEqualInt(archive_entry_atime_nsec(e2), 24680);
 532         assertEqualInt(archive_entry_birthtime(e2), 13779);
 533         assertEqualInt(archive_entry_birthtime_nsec(e2), 24990);
 534         assertEqualInt(archive_entry_ctime(e2), 13580);
 535         assertEqualInt(archive_entry_ctime_nsec(e2), 24681);
 536         assertEqualInt(archive_entry_dev(e2), 235);
 537         archive_entry_fflags(e, &set, &clear);
 538         assertEqualInt(clear, 0xAA);
 539         assertEqualInt(set, 0x55);
 540         assertEqualInt(archive_entry_gid(e2), 204);
 541         assertEqualString(archive_entry_gname(e2), "group");
 542         assertEqualString(archive_entry_hardlink(e2), "hardlinkname");
 543         assertEqualInt(archive_entry_ino(e2), 8593);
 544         assertEqualInt(archive_entry_mode(e2), 0123456);
 545         assertEqualInt(archive_entry_mtime(e2), 13581);
 546         assertEqualInt(archive_entry_mtime_nsec(e2), 24682);
 547         assertEqualInt(archive_entry_nlink(e2), 736);
 548         assertEqualString(archive_entry_pathname(e2), "path");
 549         assertEqualInt(archive_entry_rdev(e2), 532);
 550         assertEqualInt(archive_entry_size(e2), 987654321);
 551         assertEqualString(archive_entry_sourcepath(e2), "source");
 552         assertEqualString(archive_entry_symlink(e2), "symlinkname");
 553         assertEqualInt(archive_entry_uid(e2), 83);
 554         assertEqualString(archive_entry_uname(e2), "user");
 555
 556         /* Verify ACL was copied. */
 557         assertEqualInt(4, archive_entry_acl_reset(e2,
 558                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 559         /* First three are standard permission bits. */
 560         assertEqualInt(0, archive_entry_acl_next(e2,
 561                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 562                            &type, &permset, &tag, &qual, &name));
 563         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 564         assertEqualInt(permset, 4);
 565         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER_OBJ);
 566         assertEqualInt(qual, -1);
 567         assertEqualString(name, NULL);
 568         assertEqualInt(0, archive_entry_acl_next(e2,
 569                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 570                            &type, &permset, &tag, &qual, &name));
 571         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 572         assertEqualInt(permset, 5);
 573         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_GROUP_OBJ);
 574         assertEqualInt(qual, -1);
 575         assertEqualString(name, NULL);
 576         assertEqualInt(0, archive_entry_acl_next(e2,
 577                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 578                            &type, &permset, &tag, &qual, &name));
 579         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 580         assertEqualInt(permset, 6);
 581         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_OTHER);
 582         assertEqualInt(qual, -1);
 583         assertEqualString(name, NULL);
 584         /* Fourth is custom one. */
 585         assertEqualInt(0, archive_entry_acl_next(e2,
 586                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 587                            &type, &permset, &tag, &qual, &name));
 588         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 589         assertEqualInt(permset, ARCHIVE_ENTRY_ACL_READ);
 590         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER);
 591         assertEqualInt(qual, 77);
 592         assertEqualString(name, "user77");
 593
 594         /* Verify xattr was copied. */
 595         assertEqualInt(1, archive_entry_xattr_reset(e2));
 596         assertEqualInt(0, archive_entry_xattr_next(e2, &xname, &xval, &xsize));
 597         assertEqualString(xname, "xattr1");
 598         assertEqualString(xval, "xattrvalue");
 599         assertEqualInt((int)xsize, 11);
 600         assertEqualInt(ARCHIVE_WARN,
 601             archive_entry_xattr_next(e2, &xname, &xval, &xsize));
 602         assertEqualString(xname, NULL);
 603         assertEqualString(xval, NULL);
 604         assertEqualInt((int)xsize, 0);
 605
 606         /* Change the original */
 607         archive_entry_set_atime(e, 13580, 24690);
 608         archive_entry_set_birthtime(e, 13980, 24999);
 609         archive_entry_set_ctime(e, 13590, 24691);
 610         archive_entry_set_dev(e, 245);
 611         archive_entry_set_fflags(e, 0x85, 0xDA);
 612         archive_entry_set_filetype(e, AE_IFLNK);
 613         archive_entry_set_gid(e, 214);
 614         archive_entry_set_gname(e, "grouper");
 615         archive_entry_set_hardlink(e, "hardlinkpath");
 616         archive_entry_set_ino(e, 8763);
 617         archive_entry_set_mode(e, 0123654);
 618         archive_entry_set_mtime(e, 18351, 28642);
 619         archive_entry_set_nlink(e, 73);
 620         archive_entry_set_pathname(e, "pathest");
 621         archive_entry_set_rdev(e, 132);
 622         archive_entry_set_size(e, 987456321);
 623         archive_entry_copy_sourcepath(e, "source2");
 624         archive_entry_set_symlink(e, "symlinkpath");
 625         archive_entry_set_uid(e, 93);
 626         archive_entry_set_uname(e, "username");
 627         archive_entry_acl_clear(e);
 628         archive_entry_xattr_clear(e);
 629
 630         /* Clone should still have same contents. */
 631         assertEqualInt(archive_entry_atime(e2), 13579);
 632         assertEqualInt(archive_entry_atime_nsec(e2), 24680);
 633         assertEqualInt(archive_entry_birthtime(e2), 13779);
 634         assertEqualInt(archive_entry_birthtime_nsec(e2), 24990);
 635         assertEqualInt(archive_entry_ctime(e2), 13580);
 636         assertEqualInt(archive_entry_ctime_nsec(e2), 24681);
 637         assertEqualInt(archive_entry_dev(e2), 235);
 638         archive_entry_fflags(e2, &set, &clear);
 639         assertEqualInt(clear, 0xAA);
 640         assertEqualInt(set, 0x55);
 641         assertEqualInt(archive_entry_gid(e2), 204);
 642         assertEqualString(archive_entry_gname(e2), "group");
 643         assertEqualString(archive_entry_hardlink(e2), "hardlinkname");
 644         assertEqualInt(archive_entry_ino(e2), 8593);
 645         assertEqualInt(archive_entry_mode(e2), 0123456);
 646         assertEqualInt(archive_entry_mtime(e2), 13581);
 647         assertEqualInt(archive_entry_mtime_nsec(e2), 24682);
 648         assertEqualInt(archive_entry_nlink(e2), 736);
 649         assertEqualString(archive_entry_pathname(e2), "path");
 650         assertEqualInt(archive_entry_rdev(e2), 532);
 651         assertEqualInt(archive_entry_size(e2), 987654321);
 652         assertEqualString(archive_entry_sourcepath(e2), "source");
 653         assertEqualString(archive_entry_symlink(e2), "symlinkname");
 654         assertEqualInt(archive_entry_uid(e2), 83);
 655         assertEqualString(archive_entry_uname(e2), "user");
 656
 657         /* Verify ACL was unchanged. */
 658         assertEqualInt(4, archive_entry_acl_reset(e2,
 659                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
 660         /* First three are standard permission bits. */
 661         assertEqualInt(0, archive_entry_acl_next(e2,
 662                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 663                            &type, &permset, &tag, &qual, &name));
 664         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 665         assertEqualInt(permset, 4);
 666         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER_OBJ);
 667         assertEqualInt(qual, -1);
 668         assertEqualString(name, NULL);
 669         assertEqualInt(0, archive_entry_acl_next(e2,
 670                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 671                            &type, &permset, &tag, &qual, &name));
 672         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 673         assertEqualInt(permset, 5);
 674         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_GROUP_OBJ);
 675         assertEqualInt(qual, -1);
 676         assertEqualString(name, NULL);
 677         assertEqualInt(0, archive_entry_acl_next(e2,
 678                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 679                            &type, &permset, &tag, &qual, &name));
 680         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 681         assertEqualInt(permset, 6);
 682         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_OTHER);
 683         assertEqualInt(qual, -1);
 684         assertEqualString(name, NULL);
 685         /* Fourth is custom one. */
 686         assertEqualInt(0, archive_entry_acl_next(e2,
 687                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 688                            &type, &permset, &tag, &qual, &name));
 689         assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
 690         assertEqualInt(permset, ARCHIVE_ENTRY_ACL_READ);
 691         assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER);
 692         assertEqualInt(qual, 77);
 693         assertEqualString(name, "user77");
 694         assertEqualInt(1, archive_entry_acl_next(e2,
 695                            ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
 696                            &type, &permset, &tag, &qual, &name));
 697         assertEqualInt(type, 0);
 698         assertEqualInt(permset, 0);
 699         assertEqualInt(tag, 0);
 700         assertEqualInt(qual, -1);
 701         assertEqualString(name, NULL);
 702
 703         /* Verify xattr was unchanged. */
 704         assertEqualInt(1, archive_entry_xattr_reset(e2));
 705
 706         /* Release clone. */
 707         archive_entry_free(e2);
 708
 709         /*
 710          * Test clear() implementation.
 711          */
 712         archive_entry_clear(e);
 713         assertEqualInt(archive_entry_atime(e), 0);
 714         assertEqualInt(archive_entry_atime_nsec(e), 0);
 715         assertEqualInt(archive_entry_birthtime(e), 0);
 716         assertEqualInt(archive_entry_birthtime_nsec(e), 0);
 717         assertEqualInt(archive_entry_ctime(e), 0);
 718         assertEqualInt(archive_entry_ctime_nsec(e), 0);
 719         assertEqualInt(archive_entry_dev(e), 0);
 720         archive_entry_fflags(e, &set, &clear);
 721         assertEqualInt(clear, 0);
 722         assertEqualInt(set, 0);
 723         assertEqualInt(archive_entry_filetype(e), 0);
 724         assertEqualInt(archive_entry_gid(e), 0);
 725         assertEqualString(archive_entry_gname(e), NULL);
 726         assertEqualString(archive_entry_hardlink(e), NULL);
 727         assertEqualInt(archive_entry_ino(e), 0);
 728         assertEqualInt(archive_entry_mode(e), 0);
 729         assertEqualInt(archive_entry_mtime(e), 0);
 730         assertEqualInt(archive_entry_mtime_nsec(e), 0);
 731         assertEqualInt(archive_entry_nlink(e), 0);
 732         assertEqualString(archive_entry_pathname(e), NULL);
 733         assertEqualInt(archive_entry_rdev(e), 0);
 734         assertEqualInt(archive_entry_size(e), 0);
 735         assertEqualString(archive_entry_symlink(e), NULL);
 736         assertEqualInt(archive_entry_uid(e), 0);
 737         assertEqualString(archive_entry_uname(e), NULL);
 738         /* ACLs should be cleared. */
 739         assertEqualInt(archive_entry_acl_count(e, ARCHIVE_ENTRY_ACL_TYPE_ACCESS), 0);
 740         assertEqualInt(archive_entry_acl_count(e, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT), 0);
 741         /* Extended attributes should be cleared. */
 742         assertEqualInt(archive_entry_xattr_count(e), 0);
 743
 744         /*
 745          * Test archive_entry_copy_stat().
 746          */
 747         memset(&st, 0, sizeof(st));
 748         /* Set all of the standard 'struct stat' fields. */
 749         st.st_atime = 456789;
 750         st.st_ctime = 345678;
 751         st.st_dev = 123;
 752         st.st_gid = 34;
 753         st.st_ino = 234;
 754         st.st_mode = 077777;
 755         st.st_mtime = 234567;
 756         st.st_nlink = 345;
 757         st.st_size = 123456789;
 758         st.st_uid = 23;
 759 #ifdef __FreeBSD__
 760         /* On FreeBSD, high-res timestamp data should come through. */
 761         st.st_atimespec.tv_nsec = 6543210;
 762         st.st_ctimespec.tv_nsec = 5432109;
 763         st.st_mtimespec.tv_nsec = 3210987;
 764         st.st_birthtimespec.tv_nsec = 7459386;
 765 #endif
 766         /* Copy them into the entry. */
 767         archive_entry_copy_stat(e, &st);
 768         /* Read each one back separately and compare. */
 769         assertEqualInt(archive_entry_atime(e), 456789);
 770         assertEqualInt(archive_entry_ctime(e), 345678);
 771         assertEqualInt(archive_entry_dev(e), 123);
 772         assertEqualInt(archive_entry_gid(e), 34);
 773         assertEqualInt(archive_entry_ino(e), 234);
 774         assertEqualInt(archive_entry_mode(e), 077777);
 775         assertEqualInt(archive_entry_mtime(e), 234567);
 776         assertEqualInt(archive_entry_nlink(e), 345);
 777         assertEqualInt(archive_entry_size(e), 123456789);
 778         assertEqualInt(archive_entry_uid(e), 23);
 779 #if __FreeBSD__
 780         /* On FreeBSD, high-res timestamp data should come through. */
 781         assertEqualInt(archive_entry_atime_nsec(e), 6543210);
 782         assertEqualInt(archive_entry_ctime_nsec(e), 5432109);
 783         assertEqualInt(archive_entry_mtime_nsec(e), 3210987);
 784         assertEqualInt(archive_entry_birthtime_nsec(e), 7459386);
 785 #endif
 786
 787         /*
 788          * Test archive_entry_stat().
 789          */
 790         /* First, clear out any existing stat data. */
 791         memset(&st, 0, sizeof(st));
 792         archive_entry_copy_stat(e, &st);
 793         /* Set a bunch of fields individually. */
 794         archive_entry_set_atime(e, 456789, 321);
 795         archive_entry_set_ctime(e, 345678, 432);
 796         archive_entry_set_dev(e, 123);
 797         archive_entry_set_gid(e, 34);
 798         archive_entry_set_ino(e, 234);
 799         archive_entry_set_mode(e, 012345);
 800         archive_entry_set_mode(e, 012345);
 801         archive_entry_set_mtime(e, 234567, 543);
 802         archive_entry_set_nlink(e, 345);
 803         archive_entry_set_size(e, 123456789);
 804         archive_entry_set_uid(e, 23);
 805         /* Retrieve a stat structure. */
 806         assert((pst = archive_entry_stat(e)) != NULL);
 807         if (pst == NULL)
 808                 return;
 809         /* Check that the values match. */
 810         assertEqualInt(pst->st_atime, 456789);
 811         assertEqualInt(pst->st_ctime, 345678);
 812         assertEqualInt(pst->st_dev, 123);
 813         assertEqualInt(pst->st_gid, 34);
 814         assertEqualInt(pst->st_ino, 234);
 815         assertEqualInt(pst->st_mode, 012345);
 816         assertEqualInt(pst->st_mtime, 234567);
 817         assertEqualInt(pst->st_nlink, 345);
 818         assertEqualInt(pst->st_size, 123456789);
 819         assertEqualInt(pst->st_uid, 23);
 820 #ifdef __FreeBSD__
 821         /* On FreeBSD, high-res timestamp data should come through. */
 822         assertEqualInt(pst->st_atimespec.tv_nsec, 321);
 823         assertEqualInt(pst->st_ctimespec.tv_nsec, 432);
 824         assertEqualInt(pst->st_mtimespec.tv_nsec, 543);
 825 #endif
 826
 827         /* Changing any one value should update struct stat. */
 828         archive_entry_set_atime(e, 456788, 0);
 829         assert((pst = archive_entry_stat(e)) != NULL);
 830         if (pst == NULL)
 831                 return;
 832         assertEqualInt(pst->st_atime, 456788);
 833         archive_entry_set_ctime(e, 345677, 431);
 834         assert((pst = archive_entry_stat(e)) != NULL);
 835         if (pst == NULL)
 836                 return;
 837         assertEqualInt(pst->st_ctime, 345677);
 838         archive_entry_set_dev(e, 122);
 839         assert((pst = archive_entry_stat(e)) != NULL);
 840         if (pst == NULL)
 841                 return;
 842         assertEqualInt(pst->st_dev, 122);
 843         archive_entry_set_gid(e, 33);
 844         assert((pst = archive_entry_stat(e)) != NULL);
 845         if (pst == NULL)
 846                 return;
 847         assertEqualInt(pst->st_gid, 33);
 848         archive_entry_set_ino(e, 233);
 849         assert((pst = archive_entry_stat(e)) != NULL);
 850         if (pst == NULL)
 851                 return;
 852         assertEqualInt(pst->st_ino, 233);
 853         archive_entry_set_mode(e, 012344);
 854         assert((pst = archive_entry_stat(e)) != NULL);
 855         if (pst == NULL)
 856                 return;
 857         assertEqualInt(pst->st_mode, 012344);
 858         archive_entry_set_mtime(e, 234566, 542);
 859         assert((pst = archive_entry_stat(e)) != NULL);
 860         if (pst == NULL)
 861                 return;
 862         assertEqualInt(pst->st_mtime, 234566);
 863         archive_entry_set_nlink(e, 344);
 864         assert((pst = archive_entry_stat(e)) != NULL);
 865         if (pst == NULL)
 866                 return;
 867         assertEqualInt(pst->st_nlink, 344);
 868         archive_entry_set_size(e, 123456788);
 869         assert((pst = archive_entry_stat(e)) != NULL);
 870         if (pst == NULL)
 871                 return;
 872         assertEqualInt(pst->st_size, 123456788);
 873         archive_entry_set_uid(e, 22);
 874         assert((pst = archive_entry_stat(e)) != NULL);
 875         if (pst == NULL)
 876                 return;
 877         assertEqualInt(pst->st_uid, 22);
 878         /* We don't need to check high-res fields here. */
 879
 880         /*
 881          * Test dev/major/minor interfaces.  Setting 'dev' or 'rdev'
 882          * should change the corresponding major/minor values, and
 883          * vice versa.
 884          *
 885          * The test here is system-specific because it assumes that
 886          * makedev(), major(), and minor() are defined in sys/stat.h.
 887          * I'm not too worried about it, though, because the code is
 888          * simple.  If it works on FreeBSD, it's unlikely to be broken
 889          * anywhere else.  Note: The functionality is present on every
 890          * platform even if these tests only run some places;
 891          * libarchive's more extensive configuration logic should find
 892          * the necessary definitions on every platform.
 893          */
 894 #if __FreeBSD__
 895         archive_entry_set_dev(e, 0x12345678);
 896         assertEqualInt(archive_entry_devmajor(e), major(0x12345678));
 897         assertEqualInt(archive_entry_devminor(e), minor(0x12345678));
 898         assertEqualInt(archive_entry_dev(e), 0x12345678);
 899         archive_entry_set_devmajor(e, 0xfe);
 900         archive_entry_set_devminor(e, 0xdcba98);
 901         assertEqualInt(archive_entry_devmajor(e), 0xfe);
 902         assertEqualInt(archive_entry_devminor(e), 0xdcba98);
 903         assertEqualInt(archive_entry_dev(e), makedev(0xfe, 0xdcba98));
 904         archive_entry_set_rdev(e, 0x12345678);
 905         assertEqualInt(archive_entry_rdevmajor(e), major(0x12345678));
 906         assertEqualInt(archive_entry_rdevminor(e), minor(0x12345678));
 907         assertEqualInt(archive_entry_rdev(e), 0x12345678);
 908         archive_entry_set_rdevmajor(e, 0xfe);
 909         archive_entry_set_rdevminor(e, 0xdcba98);
 910         assertEqualInt(archive_entry_rdevmajor(e), 0xfe);
 911         assertEqualInt(archive_entry_rdevminor(e), 0xdcba98);
 912         assertEqualInt(archive_entry_rdev(e), makedev(0xfe, 0xdcba98));
 913 #endif
 914
 915         /*
 916          * Exercise the character-conversion logic, if we can.
 917          */
 918         if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
 919                 skipping("Can't exercise charset-conversion logic without"
 920                         " a suitable locale.");
 921         } else {
 922                 /* A filename that cannot be converted to wide characters. */
 923                 archive_entry_copy_pathname(e, "abc\314\214mno\374xyz");
 924                 failure("Converting invalid chars to Unicode should fail.");
 925                 assert(NULL == archive_entry_pathname_w(e));
 926                 /*
 927                   failure("Converting invalid chars to UTF-8 should fail.");
 928                   assert(NULL == archive_entry_pathname_utf8(e));
 929                 */
 930
 931                 /* A group name that cannot be converted. */
 932                 archive_entry_copy_gname(e, "abc\314\214mno\374xyz");
 933                 failure("Converting invalid chars to Unicode should fail.");
 934                 assert(NULL == archive_entry_gname_w(e));
 935
 936                 /* A user name that cannot be converted. */
 937                 archive_entry_copy_uname(e, "abc\314\214mno\374xyz");
 938                 failure("Converting invalid chars to Unicode should fail.");
 939                 assert(NULL == archive_entry_uname_w(e));
 940
 941                 /* A hardlink target that cannot be converted. */
 942                 archive_entry_copy_hardlink(e, "abc\314\214mno\374xyz");
 943                 failure("Converting invalid chars to Unicode should fail.");
 944                 assert(NULL == archive_entry_hardlink_w(e));
 945
 946                 /* A symlink target that cannot be converted. */
 947                 archive_entry_copy_symlink(e, "abc\314\214mno\374xyz");
 948                 failure("Converting invalid chars to Unicode should fail.");
 949                 assert(NULL == archive_entry_symlink_w(e));
 950         }
 951
 952         l = 0x12345678L;
 953         wc = (wchar_t)l; /* Wide character too big for UTF-8. */
 954         if (NULL == setlocale(LC_ALL, "C") || (long)wc != l) {
 955                 skipping("Testing charset conversion failure requires 32-bit wchar_t and support for \"C\" locale.");
 956         } else {
 957                 /*
 958                  * Build the string L"xxx\U12345678yyy\u5678zzz" without
 959                  * using wcscpy or C99 \u#### syntax.
 960                  */
 961                 name = "xxxAyyyBzzz";
 962                 for (i = 0; i < (int)strlen(name); ++i)
 963                         wbuff[i] = name[i];
 964                 wbuff[3] = (wchar_t)0x12345678;
 965                 wbuff[7] = (wchar_t)0x5678;
 966                 /* A Unicode filename that cannot be converted to UTF-8. */
 967                 archive_entry_copy_pathname_w(e, wbuff);
 968                 failure("Converting wide characters from Unicode should fail.");
 969                 assertEqualString(NULL, archive_entry_pathname(e));
 970         }
 971
 972         /* Release the experimental entry. */
 973         archive_entry_free(e);
 974 }