2 * Copyright (c) 2003-2007 Tim Kientzle
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 __FBSDID("$FreeBSD$");
30 #ifdef HAVE_LINUX_FS_H
31 #include <linux/fs.h> /* for Linux file flags */
35 static wchar_t * wcscpy(wchar_t *s1, const wchar_t *s2)
38 while ((*s1 = *s2) != L'\0')
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.
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.
55 DEFINE_TEST(test_entry)
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. */
72 assert((e = archive_entry_new()) != NULL);
75 * Verify that the AE_IF* defines match S_IF* defines
76 * on this platform. See comments in archive_entry.h.
79 assertEqualInt(S_IFREG, AE_IFREG);
82 assertEqualInt(S_IFLNK, AE_IFLNK);
85 assertEqualInt(S_IFSOCK, AE_IFSOCK);
88 assertEqualInt(S_IFCHR, AE_IFCHR);
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);
96 assertEqualInt(S_IFDIR, AE_IFDIR);
99 assertEqualInt(S_IFIFO, AE_IFIFO);
103 * Basic set/read tests for all fields.
104 * We should be able to set any field and read
105 * back the same value.
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.
111 * The following tests are ordered alphabetically by the
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));
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));
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));
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. */
168 archive_entry_set_filetype(e, AE_IFREG);
169 assertEqualInt(archive_entry_filetype(e), AE_IFREG);
171 /* fflags are tested specially below */
174 archive_entry_set_gid(e, 204);
175 assertEqualInt(archive_entry_gid(e), 204);
178 archive_entry_set_gname(e, "group");
179 assertEqualString(archive_entry_gname(e), "group");
180 wcscpy(wbuff, L"wgroup");
181 archive_entry_copy_gname_w(e, wbuff);
182 assertEqualWString(archive_entry_gname_w(e), L"wgroup");
183 memset(wbuff, 0, sizeof(wbuff));
184 assertEqualWString(archive_entry_gname_w(e), L"wgroup");
187 archive_entry_set_hardlink(e, "hardlinkname");
188 assertEqualString(archive_entry_hardlink(e), "hardlinkname");
189 strcpy(buff, "hardlinkname2");
190 archive_entry_copy_hardlink(e, buff);
191 assertEqualString(archive_entry_hardlink(e), "hardlinkname2");
192 memset(buff, 0, sizeof(buff));
193 assertEqualString(archive_entry_hardlink(e), "hardlinkname2");
194 archive_entry_copy_hardlink(e, NULL);
195 assertEqualString(archive_entry_hardlink(e), NULL);
196 assertEqualWString(archive_entry_hardlink_w(e), NULL);
197 wcscpy(wbuff, L"whardlink");
198 archive_entry_copy_hardlink_w(e, wbuff);
199 assertEqualWString(archive_entry_hardlink_w(e), L"whardlink");
200 memset(wbuff, 0, sizeof(wbuff));
201 assertEqualWString(archive_entry_hardlink_w(e), L"whardlink");
202 archive_entry_copy_hardlink_w(e, NULL);
203 assertEqualString(archive_entry_hardlink(e), NULL);
204 assertEqualWString(archive_entry_hardlink_w(e), NULL);
207 assert(!archive_entry_ino_is_set(e));
208 archive_entry_set_ino(e, 8593);
209 assert(archive_entry_ino_is_set(e));
210 assertEqualInt(archive_entry_ino(e), 8593);
211 assertEqualInt(archive_entry_ino64(e), 8593);
212 archive_entry_set_ino64(e, 8594);
213 assert(archive_entry_ino_is_set(e));
214 assertEqualInt(archive_entry_ino(e), 8594);
215 assertEqualInt(archive_entry_ino64(e), 8594);
218 archive_entry_set_hardlink(e, "hardlinkname");
219 archive_entry_set_symlink(e, NULL);
220 archive_entry_set_link(e, "link");
221 assertEqualString(archive_entry_hardlink(e), "link");
222 assertEqualString(archive_entry_symlink(e), NULL);
223 archive_entry_copy_link(e, "link2");
224 assertEqualString(archive_entry_hardlink(e), "link2");
225 assertEqualString(archive_entry_symlink(e), NULL);
226 archive_entry_copy_link_w(e, L"link3");
227 assertEqualString(archive_entry_hardlink(e), "link3");
228 assertEqualString(archive_entry_symlink(e), NULL);
229 archive_entry_set_hardlink(e, NULL);
230 archive_entry_set_symlink(e, "symlink");
231 archive_entry_set_link(e, "link");
232 assertEqualString(archive_entry_hardlink(e), NULL);
233 assertEqualString(archive_entry_symlink(e), "link");
234 archive_entry_copy_link(e, "link2");
235 assertEqualString(archive_entry_hardlink(e), NULL);
236 assertEqualString(archive_entry_symlink(e), "link2");
237 archive_entry_copy_link_w(e, L"link3");
238 assertEqualString(archive_entry_hardlink(e), NULL);
239 assertEqualString(archive_entry_symlink(e), "link3");
240 /* Arbitrarily override symlink if both hardlink and symlink set. */
241 archive_entry_set_hardlink(e, "hardlink");
242 archive_entry_set_symlink(e, "symlink");
243 archive_entry_set_link(e, "link");
244 assertEqualString(archive_entry_hardlink(e), "hardlink");
245 assertEqualString(archive_entry_symlink(e), "link");
248 archive_entry_set_mode(e, 0123456);
249 assertEqualInt(archive_entry_mode(e), 0123456);
252 archive_entry_set_mtime(e, 13581, 24682);
253 assertEqualInt(archive_entry_mtime(e), 13581);
254 assertEqualInt(archive_entry_mtime_nsec(e), 24682);
255 archive_entry_set_mtime(e, 13582, 1358297468);
256 assertEqualInt(archive_entry_mtime(e), 13583);
257 assertEqualInt(archive_entry_mtime_nsec(e), 358297468);
258 archive_entry_set_mtime(e, 13583, -24682);
259 assertEqualInt(archive_entry_mtime(e), 13582);
260 assertEqualInt(archive_entry_mtime_nsec(e), 999975318);
261 archive_entry_unset_mtime(e);
262 assertEqualInt(archive_entry_mtime(e), 0);
263 assertEqualInt(archive_entry_mtime_nsec(e), 0);
264 assert(!archive_entry_mtime_is_set(e));
267 archive_entry_set_nlink(e, 736);
268 assertEqualInt(archive_entry_nlink(e), 736);
271 archive_entry_set_pathname(e, "path");
272 assertEqualString(archive_entry_pathname(e), "path");
273 archive_entry_set_pathname(e, "path");
274 assertEqualString(archive_entry_pathname(e), "path");
275 strcpy(buff, "path2");
276 archive_entry_copy_pathname(e, buff);
277 assertEqualString(archive_entry_pathname(e), "path2");
278 memset(buff, 0, sizeof(buff));
279 assertEqualString(archive_entry_pathname(e), "path2");
280 wcscpy(wbuff, L"wpath");
281 archive_entry_copy_pathname_w(e, wbuff);
282 assertEqualWString(archive_entry_pathname_w(e), L"wpath");
283 memset(wbuff, 0, sizeof(wbuff));
284 assertEqualWString(archive_entry_pathname_w(e), L"wpath");
287 archive_entry_set_rdev(e, 532);
288 assertEqualInt(archive_entry_rdev(e), 532);
289 /* rdevmajor/rdevminor are tested specially below. */
292 archive_entry_set_size(e, 987654321);
293 assertEqualInt(archive_entry_size(e), 987654321);
294 archive_entry_unset_size(e);
295 assertEqualInt(archive_entry_size(e), 0);
296 assert(!archive_entry_size_is_set(e));
299 archive_entry_copy_sourcepath(e, "path1");
300 assertEqualString(archive_entry_sourcepath(e), "path1");
303 archive_entry_set_symlink(e, "symlinkname");
304 assertEqualString(archive_entry_symlink(e), "symlinkname");
305 strcpy(buff, "symlinkname2");
306 archive_entry_copy_symlink(e, buff);
307 assertEqualString(archive_entry_symlink(e), "symlinkname2");
308 memset(buff, 0, sizeof(buff));
309 assertEqualString(archive_entry_symlink(e), "symlinkname2");
310 archive_entry_copy_symlink_w(e, NULL);
311 assertEqualWString(archive_entry_symlink_w(e), NULL);
312 assertEqualString(archive_entry_symlink(e), NULL);
313 archive_entry_copy_symlink_w(e, L"wsymlink");
314 assertEqualWString(archive_entry_symlink_w(e), L"wsymlink");
315 archive_entry_copy_symlink(e, NULL);
316 assertEqualWString(archive_entry_symlink_w(e), NULL);
317 assertEqualString(archive_entry_symlink(e), NULL);
320 archive_entry_set_uid(e, 83);
321 assertEqualInt(archive_entry_uid(e), 83);
324 archive_entry_set_uname(e, "user");
325 assertEqualString(archive_entry_uname(e), "user");
326 wcscpy(wbuff, L"wuser");
327 archive_entry_copy_gname_w(e, wbuff);
328 assertEqualWString(archive_entry_gname_w(e), L"wuser");
329 memset(wbuff, 0, sizeof(wbuff));
330 assertEqualWString(archive_entry_gname_w(e), L"wuser");
332 /* Test fflags interface. */
333 archive_entry_set_fflags(e, 0x55, 0xAA);
334 archive_entry_fflags(e, &set, &clear);
335 failure("Testing set/get of fflags data.");
336 assertEqualInt(set, 0x55);
337 failure("Testing set/get of fflags data.");
338 assertEqualInt(clear, 0xAA);
340 /* Converting fflags bitmap to string is currently system-dependent. */
341 /* TODO: Make this system-independent. */
342 assertEqualString(archive_entry_fflags_text(e),
343 "uappnd,nouchg,nodump,noopaque,uunlnk,nosystem");
346 #if defined(__FreeBSD__) || defined(__APPLE__)
347 /* Test archive_entry_copy_fflags_text_w() */
348 archive_entry_copy_fflags_text_w(e, L" ,nouappnd, nouchg, dump,hidden");
349 archive_entry_fflags(e, &set, &clear);
350 assertEqualInt(UF_HIDDEN, set);
351 assertEqualInt(UF_NODUMP | UF_IMMUTABLE | UF_APPEND, clear);
352 /* Test archive_entry_copy_fflags_text() */
353 archive_entry_copy_fflags_text(e, " ,nouappnd, nouchg, dump,hidden");
354 archive_entry_fflags(e, &set, &clear);
355 assertEqualInt(UF_HIDDEN, set);
356 assertEqualInt(UF_NODUMP | UF_IMMUTABLE | UF_APPEND, clear);
357 #elif defined(_WIN32) && !defined(CYGWIN)
358 archive_entry_copy_fflags_text_w(e, L"rdonly,hidden,nosystem");
359 archive_entry_fflags(e, &set, &clear);
360 assertEqualInt(FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN, set);
361 assertEqualInt(FILE_ATTRIBUTE_SYSTEM, clear);
362 archive_entry_copy_fflags_text(e, "rdonly,hidden,nosystem");
363 archive_entry_fflags(e, &set, &clear);
364 assertEqualInt(FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN, set);
365 assertEqualInt(FILE_ATTRIBUTE_SYSTEM, clear);
366 #elif defined FS_IOC_GETFLAGS /* Linux */
367 archive_entry_copy_fflags_text_w(e, L"sappnd,schg,dump,noundel");
368 archive_entry_fflags(e, &set, &clear);
369 assertEqualInt(FS_APPEND_FL | FS_IMMUTABLE_FL, set);
370 assertEqualInt(FS_NODUMP_FL | FS_UNRM_FL, clear);
371 archive_entry_copy_fflags_text(e, "sappnd,schg,dump,noundel");
372 archive_entry_fflags(e, &set, &clear);
373 assertEqualInt(FS_APPEND_FL | FS_IMMUTABLE_FL, set);
374 assertEqualInt(FS_NODUMP_FL | FS_UNRM_FL, clear);
377 /* See test_acl_basic.c for tests of ACL set/get consistency. */
379 /* Test xattrs set/get consistency. */
380 archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue1", 12);
381 assertEqualInt(1, archive_entry_xattr_reset(e));
382 assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize));
383 assertEqualString(xname, "xattr1");
384 assertEqualString(xval, "xattrvalue1");
385 assertEqualInt((int)xsize, 12);
386 assertEqualInt(1, archive_entry_xattr_count(e));
387 assertEqualInt(ARCHIVE_WARN,
388 archive_entry_xattr_next(e, &xname, &xval, &xsize));
389 assertEqualString(xname, NULL);
390 assertEqualString(xval, NULL);
391 assertEqualInt((int)xsize, 0);
392 archive_entry_xattr_clear(e);
393 assertEqualInt(0, archive_entry_xattr_reset(e));
394 assertEqualInt(ARCHIVE_WARN,
395 archive_entry_xattr_next(e, &xname, &xval, &xsize));
396 assertEqualString(xname, NULL);
397 assertEqualString(xval, NULL);
398 assertEqualInt((int)xsize, 0);
399 archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue1", 12);
400 assertEqualInt(1, archive_entry_xattr_reset(e));
401 archive_entry_xattr_add_entry(e, "xattr2", "xattrvalue2", 12);
402 assertEqualInt(2, archive_entry_xattr_reset(e));
403 assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize));
404 assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize));
405 assertEqualInt(ARCHIVE_WARN,
406 archive_entry_xattr_next(e, &xname, &xval, &xsize));
407 assertEqualString(xname, NULL);
408 assertEqualString(xval, NULL);
409 assertEqualInt((int)xsize, 0);
413 * Test clone() implementation.
416 /* Set values in 'e' */
417 archive_entry_clear(e);
418 archive_entry_set_atime(e, 13579, 24680);
419 archive_entry_set_birthtime(e, 13779, 24990);
420 archive_entry_set_ctime(e, 13580, 24681);
421 archive_entry_set_dev(e, 235);
422 archive_entry_set_fflags(e, 0x55, 0xAA);
423 archive_entry_set_gid(e, 204);
424 archive_entry_set_gname(e, "group");
425 archive_entry_set_hardlink(e, "hardlinkname");
426 archive_entry_set_ino(e, 8593);
427 archive_entry_set_mode(e, 0123456);
428 archive_entry_set_mtime(e, 13581, 24682);
429 archive_entry_set_nlink(e, 736);
430 archive_entry_set_pathname(e, "path");
431 archive_entry_set_rdev(e, 532);
432 archive_entry_set_size(e, 987654321);
433 archive_entry_copy_sourcepath(e, "source");
434 archive_entry_set_symlink(e, "symlinkname");
435 archive_entry_set_uid(e, 83);
436 archive_entry_set_uname(e, "user");
437 /* Add an ACL entry. */
438 archive_entry_acl_add_entry(e, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
439 ARCHIVE_ENTRY_ACL_READ, ARCHIVE_ENTRY_ACL_USER, 77, "user77");
440 /* Add an extended attribute. */
441 archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue", 11);
444 e2 = archive_entry_clone(e);
446 /* Clone should have same contents. */
447 assertEqualInt(archive_entry_atime(e2), 13579);
448 assertEqualInt(archive_entry_atime_nsec(e2), 24680);
449 assertEqualInt(archive_entry_birthtime(e2), 13779);
450 assertEqualInt(archive_entry_birthtime_nsec(e2), 24990);
451 assertEqualInt(archive_entry_ctime(e2), 13580);
452 assertEqualInt(archive_entry_ctime_nsec(e2), 24681);
453 assertEqualInt(archive_entry_dev(e2), 235);
454 archive_entry_fflags(e, &set, &clear);
455 assertEqualInt(clear, 0xAA);
456 assertEqualInt(set, 0x55);
457 assertEqualInt(archive_entry_gid(e2), 204);
458 assertEqualString(archive_entry_gname(e2), "group");
459 assertEqualString(archive_entry_hardlink(e2), "hardlinkname");
460 assertEqualInt(archive_entry_ino(e2), 8593);
461 assertEqualInt(archive_entry_mode(e2), 0123456);
462 assertEqualInt(archive_entry_mtime(e2), 13581);
463 assertEqualInt(archive_entry_mtime_nsec(e2), 24682);
464 assertEqualInt(archive_entry_nlink(e2), 736);
465 assertEqualString(archive_entry_pathname(e2), "path");
466 assertEqualInt(archive_entry_rdev(e2), 532);
467 assertEqualInt(archive_entry_size(e2), 987654321);
468 assertEqualString(archive_entry_sourcepath(e2), "source");
469 assertEqualString(archive_entry_symlink(e2), "symlinkname");
470 assertEqualInt(archive_entry_uid(e2), 83);
471 assertEqualString(archive_entry_uname(e2), "user");
473 /* Verify ACL was copied. */
474 assertEqualInt(4, archive_entry_acl_reset(e2,
475 ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
476 /* First three are standard permission bits. */
477 assertEqualInt(0, archive_entry_acl_next(e2,
478 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
479 &type, &permset, &tag, &qual, &name));
480 assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
481 assertEqualInt(permset, 4);
482 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER_OBJ);
483 assertEqualInt(qual, -1);
484 assertEqualString(name, NULL);
485 assertEqualInt(0, archive_entry_acl_next(e2,
486 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
487 &type, &permset, &tag, &qual, &name));
488 assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
489 assertEqualInt(permset, 5);
490 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_GROUP_OBJ);
491 assertEqualInt(qual, -1);
492 assertEqualString(name, NULL);
493 assertEqualInt(0, archive_entry_acl_next(e2,
494 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
495 &type, &permset, &tag, &qual, &name));
496 assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
497 assertEqualInt(permset, 6);
498 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_OTHER);
499 assertEqualInt(qual, -1);
500 assertEqualString(name, NULL);
501 /* Fourth is custom one. */
502 assertEqualInt(0, archive_entry_acl_next(e2,
503 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
504 &type, &permset, &tag, &qual, &name));
505 assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
506 assertEqualInt(permset, ARCHIVE_ENTRY_ACL_READ);
507 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER);
508 assertEqualInt(qual, 77);
509 assertEqualString(name, "user77");
511 /* Verify xattr was copied. */
512 assertEqualInt(1, archive_entry_xattr_reset(e2));
513 assertEqualInt(0, archive_entry_xattr_next(e2, &xname, &xval, &xsize));
514 assertEqualString(xname, "xattr1");
515 assertEqualString(xval, "xattrvalue");
516 assertEqualInt((int)xsize, 11);
517 assertEqualInt(ARCHIVE_WARN,
518 archive_entry_xattr_next(e2, &xname, &xval, &xsize));
519 assertEqualString(xname, NULL);
520 assertEqualString(xval, NULL);
521 assertEqualInt((int)xsize, 0);
523 /* Change the original */
524 archive_entry_set_atime(e, 13580, 24690);
525 archive_entry_set_birthtime(e, 13980, 24999);
526 archive_entry_set_ctime(e, 13590, 24691);
527 archive_entry_set_dev(e, 245);
528 archive_entry_set_fflags(e, 0x85, 0xDA);
529 archive_entry_set_filetype(e, AE_IFLNK);
530 archive_entry_set_gid(e, 214);
531 archive_entry_set_gname(e, "grouper");
532 archive_entry_set_hardlink(e, "hardlinkpath");
533 archive_entry_set_ino(e, 8763);
534 archive_entry_set_mode(e, 0123654);
535 archive_entry_set_mtime(e, 18351, 28642);
536 archive_entry_set_nlink(e, 73);
537 archive_entry_set_pathname(e, "pathest");
538 archive_entry_set_rdev(e, 132);
539 archive_entry_set_size(e, 987456321);
540 archive_entry_copy_sourcepath(e, "source2");
541 archive_entry_set_symlink(e, "symlinkpath");
542 archive_entry_set_uid(e, 93);
543 archive_entry_set_uname(e, "username");
544 archive_entry_acl_clear(e);
545 archive_entry_xattr_clear(e);
547 /* Clone should still have same contents. */
548 assertEqualInt(archive_entry_atime(e2), 13579);
549 assertEqualInt(archive_entry_atime_nsec(e2), 24680);
550 assertEqualInt(archive_entry_birthtime(e2), 13779);
551 assertEqualInt(archive_entry_birthtime_nsec(e2), 24990);
552 assertEqualInt(archive_entry_ctime(e2), 13580);
553 assertEqualInt(archive_entry_ctime_nsec(e2), 24681);
554 assertEqualInt(archive_entry_dev(e2), 235);
555 archive_entry_fflags(e2, &set, &clear);
556 assertEqualInt(clear, 0xAA);
557 assertEqualInt(set, 0x55);
558 assertEqualInt(archive_entry_gid(e2), 204);
559 assertEqualString(archive_entry_gname(e2), "group");
560 assertEqualString(archive_entry_hardlink(e2), "hardlinkname");
561 assertEqualInt(archive_entry_ino(e2), 8593);
562 assertEqualInt(archive_entry_mode(e2), 0123456);
563 assertEqualInt(archive_entry_mtime(e2), 13581);
564 assertEqualInt(archive_entry_mtime_nsec(e2), 24682);
565 assertEqualInt(archive_entry_nlink(e2), 736);
566 assertEqualString(archive_entry_pathname(e2), "path");
567 assertEqualInt(archive_entry_rdev(e2), 532);
568 assertEqualInt(archive_entry_size(e2), 987654321);
569 assertEqualString(archive_entry_sourcepath(e2), "source");
570 assertEqualString(archive_entry_symlink(e2), "symlinkname");
571 assertEqualInt(archive_entry_uid(e2), 83);
572 assertEqualString(archive_entry_uname(e2), "user");
574 /* Verify ACL was unchanged. */
575 assertEqualInt(4, archive_entry_acl_reset(e2,
576 ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
577 /* First three are standard permission bits. */
578 assertEqualInt(0, archive_entry_acl_next(e2,
579 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
580 &type, &permset, &tag, &qual, &name));
581 assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
582 assertEqualInt(permset, 4);
583 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER_OBJ);
584 assertEqualInt(qual, -1);
585 assertEqualString(name, NULL);
586 assertEqualInt(0, archive_entry_acl_next(e2,
587 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
588 &type, &permset, &tag, &qual, &name));
589 assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
590 assertEqualInt(permset, 5);
591 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_GROUP_OBJ);
592 assertEqualInt(qual, -1);
593 assertEqualString(name, NULL);
594 assertEqualInt(0, archive_entry_acl_next(e2,
595 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
596 &type, &permset, &tag, &qual, &name));
597 assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
598 assertEqualInt(permset, 6);
599 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_OTHER);
600 assertEqualInt(qual, -1);
601 assertEqualString(name, NULL);
602 /* Fourth is custom one. */
603 assertEqualInt(0, archive_entry_acl_next(e2,
604 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
605 &type, &permset, &tag, &qual, &name));
606 assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
607 assertEqualInt(permset, ARCHIVE_ENTRY_ACL_READ);
608 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER);
609 assertEqualInt(qual, 77);
610 assertEqualString(name, "user77");
611 assertEqualInt(1, archive_entry_acl_next(e2,
612 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
613 &type, &permset, &tag, &qual, &name));
614 assertEqualInt(type, 0);
615 assertEqualInt(permset, 0);
616 assertEqualInt(tag, 0);
617 assertEqualInt(qual, -1);
618 assertEqualString(name, NULL);
620 /* Verify xattr was unchanged. */
621 assertEqualInt(1, archive_entry_xattr_reset(e2));
624 archive_entry_free(e2);
627 * Test clear() implementation.
629 archive_entry_clear(e);
630 assertEqualInt(archive_entry_atime(e), 0);
631 assertEqualInt(archive_entry_atime_nsec(e), 0);
632 assertEqualInt(archive_entry_birthtime(e), 0);
633 assertEqualInt(archive_entry_birthtime_nsec(e), 0);
634 assertEqualInt(archive_entry_ctime(e), 0);
635 assertEqualInt(archive_entry_ctime_nsec(e), 0);
636 assertEqualInt(archive_entry_dev(e), 0);
637 archive_entry_fflags(e, &set, &clear);
638 assertEqualInt(clear, 0);
639 assertEqualInt(set, 0);
640 assertEqualInt(archive_entry_filetype(e), 0);
641 assertEqualInt(archive_entry_gid(e), 0);
642 assertEqualString(archive_entry_gname(e), NULL);
643 assertEqualString(archive_entry_hardlink(e), NULL);
644 assertEqualInt(archive_entry_ino(e), 0);
645 assertEqualInt(archive_entry_mode(e), 0);
646 assertEqualInt(archive_entry_mtime(e), 0);
647 assertEqualInt(archive_entry_mtime_nsec(e), 0);
648 assertEqualInt(archive_entry_nlink(e), 0);
649 assertEqualString(archive_entry_pathname(e), NULL);
650 assertEqualInt(archive_entry_rdev(e), 0);
651 assertEqualInt(archive_entry_size(e), 0);
652 assertEqualString(archive_entry_symlink(e), NULL);
653 assertEqualInt(archive_entry_uid(e), 0);
654 assertEqualString(archive_entry_uname(e), NULL);
655 /* ACLs should be cleared. */
656 assertEqualInt(archive_entry_acl_count(e, ARCHIVE_ENTRY_ACL_TYPE_ACCESS), 0);
657 assertEqualInt(archive_entry_acl_count(e, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT), 0);
658 /* Extended attributes should be cleared. */
659 assertEqualInt(archive_entry_xattr_count(e), 0);
662 * Test archive_entry_copy_stat().
664 memset(&st, 0, sizeof(st));
665 /* Set all of the standard 'struct stat' fields. */
666 st.st_atime = 456789;
667 st.st_ctime = 345678;
672 st.st_mtime = 234567;
674 st.st_size = 123456789;
677 /* On FreeBSD, high-res timestamp data should come through. */
678 st.st_atimespec.tv_nsec = 6543210;
679 st.st_ctimespec.tv_nsec = 5432109;
680 st.st_mtimespec.tv_nsec = 3210987;
681 st.st_birthtimespec.tv_nsec = 7459386;
683 /* Copy them into the entry. */
684 archive_entry_copy_stat(e, &st);
685 /* Read each one back separately and compare. */
686 assertEqualInt(archive_entry_atime(e), 456789);
687 assertEqualInt(archive_entry_ctime(e), 345678);
688 assertEqualInt(archive_entry_dev(e), 123);
689 assertEqualInt(archive_entry_gid(e), 34);
690 assertEqualInt(archive_entry_ino(e), 234);
691 assertEqualInt(archive_entry_mode(e), 077777);
692 assertEqualInt(archive_entry_mtime(e), 234567);
693 assertEqualInt(archive_entry_nlink(e), 345);
694 assertEqualInt(archive_entry_size(e), 123456789);
695 assertEqualInt(archive_entry_uid(e), 23);
697 /* On FreeBSD, high-res timestamp data should come through. */
698 assertEqualInt(archive_entry_atime_nsec(e), 6543210);
699 assertEqualInt(archive_entry_ctime_nsec(e), 5432109);
700 assertEqualInt(archive_entry_mtime_nsec(e), 3210987);
701 assertEqualInt(archive_entry_birthtime_nsec(e), 7459386);
705 * Test archive_entry_stat().
707 /* First, clear out any existing stat data. */
708 memset(&st, 0, sizeof(st));
709 archive_entry_copy_stat(e, &st);
710 /* Set a bunch of fields individually. */
711 archive_entry_set_atime(e, 456789, 321);
712 archive_entry_set_ctime(e, 345678, 432);
713 archive_entry_set_dev(e, 123);
714 archive_entry_set_gid(e, 34);
715 archive_entry_set_ino(e, 234);
716 archive_entry_set_mode(e, 012345);
717 archive_entry_set_mode(e, 012345);
718 archive_entry_set_mtime(e, 234567, 543);
719 archive_entry_set_nlink(e, 345);
720 archive_entry_set_size(e, 123456789);
721 archive_entry_set_uid(e, 23);
722 /* Retrieve a stat structure. */
723 assert((pst = archive_entry_stat(e)) != NULL);
726 /* Check that the values match. */
727 assertEqualInt(pst->st_atime, 456789);
728 assertEqualInt(pst->st_ctime, 345678);
729 assertEqualInt(pst->st_dev, 123);
730 assertEqualInt(pst->st_gid, 34);
731 assertEqualInt(pst->st_ino, 234);
732 assertEqualInt(pst->st_mode, 012345);
733 assertEqualInt(pst->st_mtime, 234567);
734 assertEqualInt(pst->st_nlink, 345);
735 assertEqualInt(pst->st_size, 123456789);
736 assertEqualInt(pst->st_uid, 23);
738 /* On FreeBSD, high-res timestamp data should come through. */
739 assertEqualInt(pst->st_atimespec.tv_nsec, 321);
740 assertEqualInt(pst->st_ctimespec.tv_nsec, 432);
741 assertEqualInt(pst->st_mtimespec.tv_nsec, 543);
744 /* Changing any one value should update struct stat. */
745 archive_entry_set_atime(e, 456788, 0);
746 assert((pst = archive_entry_stat(e)) != NULL);
749 assertEqualInt(pst->st_atime, 456788);
750 archive_entry_set_ctime(e, 345677, 431);
751 assert((pst = archive_entry_stat(e)) != NULL);
754 assertEqualInt(pst->st_ctime, 345677);
755 archive_entry_set_dev(e, 122);
756 assert((pst = archive_entry_stat(e)) != NULL);
759 assertEqualInt(pst->st_dev, 122);
760 archive_entry_set_gid(e, 33);
761 assert((pst = archive_entry_stat(e)) != NULL);
764 assertEqualInt(pst->st_gid, 33);
765 archive_entry_set_ino(e, 233);
766 assert((pst = archive_entry_stat(e)) != NULL);
769 assertEqualInt(pst->st_ino, 233);
770 archive_entry_set_mode(e, 012344);
771 assert((pst = archive_entry_stat(e)) != NULL);
774 assertEqualInt(pst->st_mode, 012344);
775 archive_entry_set_mtime(e, 234566, 542);
776 assert((pst = archive_entry_stat(e)) != NULL);
779 assertEqualInt(pst->st_mtime, 234566);
780 archive_entry_set_nlink(e, 344);
781 assert((pst = archive_entry_stat(e)) != NULL);
784 assertEqualInt(pst->st_nlink, 344);
785 archive_entry_set_size(e, 123456788);
786 assert((pst = archive_entry_stat(e)) != NULL);
789 assertEqualInt(pst->st_size, 123456788);
790 archive_entry_set_uid(e, 22);
791 assert((pst = archive_entry_stat(e)) != NULL);
794 assertEqualInt(pst->st_uid, 22);
795 /* We don't need to check high-res fields here. */
798 * Test dev/major/minor interfaces. Setting 'dev' or 'rdev'
799 * should change the corresponding major/minor values, and
802 * The test here is system-specific because it assumes that
803 * makedev(), major(), and minor() are defined in sys/stat.h.
804 * I'm not too worried about it, though, because the code is
805 * simple. If it works on FreeBSD, it's unlikely to be broken
806 * anywhere else. Note: The functionality is present on every
807 * platform even if these tests only run some places;
808 * libarchive's more extensive configuration logic should find
809 * the necessary definitions on every platform.
812 archive_entry_set_dev(e, 0x12345678);
813 assertEqualInt(archive_entry_devmajor(e), major(0x12345678));
814 assertEqualInt(archive_entry_devminor(e), minor(0x12345678));
815 assertEqualInt(archive_entry_dev(e), 0x12345678);
816 archive_entry_set_devmajor(e, 0xfe);
817 archive_entry_set_devminor(e, 0xdcba98);
818 assertEqualInt(archive_entry_devmajor(e), 0xfe);
819 assertEqualInt(archive_entry_devminor(e), 0xdcba98);
820 assertEqualInt(archive_entry_dev(e), makedev(0xfe, 0xdcba98));
821 archive_entry_set_rdev(e, 0x12345678);
822 assertEqualInt(archive_entry_rdevmajor(e), major(0x12345678));
823 assertEqualInt(archive_entry_rdevminor(e), minor(0x12345678));
824 assertEqualInt(archive_entry_rdev(e), 0x12345678);
825 archive_entry_set_rdevmajor(e, 0xfe);
826 archive_entry_set_rdevminor(e, 0xdcba98);
827 assertEqualInt(archive_entry_rdevmajor(e), 0xfe);
828 assertEqualInt(archive_entry_rdevminor(e), 0xdcba98);
829 assertEqualInt(archive_entry_rdev(e), makedev(0xfe, 0xdcba98));
833 * Exercise the character-conversion logic, if we can.
835 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
836 skipping("Can't exercise charset-conversion logic without"
837 " a suitable locale.");
839 /* A filename that cannot be converted to wide characters. */
840 archive_entry_copy_pathname(e, "abc\314\214mno\374xyz");
841 failure("Converting invalid chars to Unicode should fail.");
842 assert(NULL == archive_entry_pathname_w(e));
844 failure("Converting invalid chars to UTF-8 should fail.");
845 assert(NULL == archive_entry_pathname_utf8(e));
848 /* A group name that cannot be converted. */
849 archive_entry_copy_gname(e, "abc\314\214mno\374xyz");
850 failure("Converting invalid chars to Unicode should fail.");
851 assert(NULL == archive_entry_gname_w(e));
853 /* A user name that cannot be converted. */
854 archive_entry_copy_uname(e, "abc\314\214mno\374xyz");
855 failure("Converting invalid chars to Unicode should fail.");
856 assert(NULL == archive_entry_uname_w(e));
858 /* A hardlink target that cannot be converted. */
859 archive_entry_copy_hardlink(e, "abc\314\214mno\374xyz");
860 failure("Converting invalid chars to Unicode should fail.");
861 assert(NULL == archive_entry_hardlink_w(e));
863 /* A symlink target that cannot be converted. */
864 archive_entry_copy_symlink(e, "abc\314\214mno\374xyz");
865 failure("Converting invalid chars to Unicode should fail.");
866 assert(NULL == archive_entry_symlink_w(e));
870 wc = (wchar_t)l; /* Wide character too big for UTF-8. */
871 if (NULL == setlocale(LC_ALL, "C") || (long)wc != l) {
872 skipping("Testing charset conversion failure requires 32-bit wchar_t and support for \"C\" locale.");
875 * Build the string L"xxx\U12345678yyy\u5678zzz" without
876 * using wcscpy or C99 \u#### syntax.
878 name = "xxxAyyyBzzz";
879 for (i = 0; i < (int)strlen(name); ++i)
881 wbuff[3] = (wchar_t)0x12345678;
882 wbuff[7] = (wchar_t)0x5678;
883 /* A Unicode filename that cannot be converted to UTF-8. */
884 archive_entry_copy_pathname_w(e, wbuff);
885 failure("Converting wide characters from Unicode should fail.");
886 assertEqualString(NULL, archive_entry_pathname(e));
889 /* Release the experimental entry. */
890 archive_entry_free(e);