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$");
31 static wchar_t * wcscpy(wchar_t *s1, const wchar_t *s2)
34 while ((*s1 = *s2) != L'\0')
41 * Most of these tests are system-independent, though a few depend on
42 * features of the local system. Such tests are conditionalized on
43 * the platform name. On unsupported platforms, only the
44 * system-independent features will be tested.
46 * No, I don't want to use config.h in the test files because I want
47 * the tests to also serve as a check on the correctness of config.h.
48 * A mis-configured library build should cause tests to fail.
51 DEFINE_TEST(test_entry)
56 struct archive_entry *e, *e2;
57 const struct stat *pst;
58 unsigned long set, clear; /* For fflag testing. */
59 int type, permset, tag, qual; /* For ACL testing. */
60 const char *name; /* For ACL testing. */
61 const char *xname; /* For xattr tests. */
62 const void *xval; /* For xattr tests. */
63 size_t xsize; /* For xattr tests. */
68 assert((e = archive_entry_new()) != NULL);
71 * Verify that the AE_IF* defines match S_IF* defines
72 * on this platform. See comments in archive_entry.h.
75 assertEqualInt(S_IFREG, AE_IFREG);
78 assertEqualInt(S_IFLNK, AE_IFLNK);
81 assertEqualInt(S_IFSOCK, AE_IFSOCK);
84 assertEqualInt(S_IFCHR, AE_IFCHR);
86 /* Work around MinGW, which defines S_IFBLK wrong. */
87 /* sourceforge.net/tracker/?func=detail&atid=102435&aid=1942809&group_id=2435 */
88 #if defined(S_IFBLK) && !defined(_WIN32)
89 assertEqualInt(S_IFBLK, AE_IFBLK);
92 assertEqualInt(S_IFDIR, AE_IFDIR);
95 assertEqualInt(S_IFIFO, AE_IFIFO);
99 * Basic set/read tests for all fields.
100 * We should be able to set any field and read
101 * back the same value.
103 * For methods that "copy" a string, we should be able
104 * to overwrite the original passed-in string without
105 * changing the value in the entry.
107 * The following tests are ordered alphabetically by the
112 archive_entry_set_atime(e, 13579, 24680);
113 assertEqualInt(archive_entry_atime(e), 13579);
114 assertEqualInt(archive_entry_atime_nsec(e), 24680);
115 archive_entry_set_atime(e, 13580, 1000000001L);
116 assertEqualInt(archive_entry_atime(e), 13581);
117 assertEqualInt(archive_entry_atime_nsec(e), 1);
118 archive_entry_set_atime(e, 13580, -7);
119 assertEqualInt(archive_entry_atime(e), 13579);
120 assertEqualInt(archive_entry_atime_nsec(e), 999999993);
121 archive_entry_unset_atime(e);
122 assertEqualInt(archive_entry_atime(e), 0);
123 assertEqualInt(archive_entry_atime_nsec(e), 0);
124 assert(!archive_entry_atime_is_set(e));
127 archive_entry_set_birthtime(e, 17579, 24990);
128 assertEqualInt(archive_entry_birthtime(e), 17579);
129 assertEqualInt(archive_entry_birthtime_nsec(e), 24990);
130 archive_entry_set_birthtime(e, 17580, 1234567890L);
131 assertEqualInt(archive_entry_birthtime(e), 17581);
132 assertEqualInt(archive_entry_birthtime_nsec(e), 234567890);
133 archive_entry_set_birthtime(e, 17581, -24990);
134 assertEqualInt(archive_entry_birthtime(e), 17580);
135 assertEqualInt(archive_entry_birthtime_nsec(e), 999975010);
136 archive_entry_unset_birthtime(e);
137 assertEqualInt(archive_entry_birthtime(e), 0);
138 assertEqualInt(archive_entry_birthtime_nsec(e), 0);
139 assert(!archive_entry_birthtime_is_set(e));
142 archive_entry_set_ctime(e, 13580, 24681);
143 assertEqualInt(archive_entry_ctime(e), 13580);
144 assertEqualInt(archive_entry_ctime_nsec(e), 24681);
145 archive_entry_set_ctime(e, 13581, 2008182348L);
146 assertEqualInt(archive_entry_ctime(e), 13583);
147 assertEqualInt(archive_entry_ctime_nsec(e), 8182348);
148 archive_entry_set_ctime(e, 13582, -24681);
149 assertEqualInt(archive_entry_ctime(e), 13581);
150 assertEqualInt(archive_entry_ctime_nsec(e), 999975319);
151 archive_entry_unset_ctime(e);
152 assertEqualInt(archive_entry_ctime(e), 0);
153 assertEqualInt(archive_entry_ctime_nsec(e), 0);
154 assert(!archive_entry_ctime_is_set(e));
157 assert(!archive_entry_dev_is_set(e));
158 archive_entry_set_dev(e, 235);
159 assert(archive_entry_dev_is_set(e));
160 assertEqualInt(archive_entry_dev(e), 235);
161 /* devmajor/devminor are tested specially below. */
164 archive_entry_set_filetype(e, AE_IFREG);
165 assertEqualInt(archive_entry_filetype(e), AE_IFREG);
167 /* fflags are tested specially below */
170 archive_entry_set_gid(e, 204);
171 assertEqualInt(archive_entry_gid(e), 204);
174 archive_entry_set_gname(e, "group");
175 assertEqualString(archive_entry_gname(e), "group");
176 wcscpy(wbuff, L"wgroup");
177 archive_entry_copy_gname_w(e, wbuff);
178 assertEqualWString(archive_entry_gname_w(e), L"wgroup");
179 memset(wbuff, 0, sizeof(wbuff));
180 assertEqualWString(archive_entry_gname_w(e), L"wgroup");
183 archive_entry_set_hardlink(e, "hardlinkname");
184 assertEqualString(archive_entry_hardlink(e), "hardlinkname");
185 strcpy(buff, "hardlinkname2");
186 archive_entry_copy_hardlink(e, buff);
187 assertEqualString(archive_entry_hardlink(e), "hardlinkname2");
188 memset(buff, 0, sizeof(buff));
189 assertEqualString(archive_entry_hardlink(e), "hardlinkname2");
190 archive_entry_copy_hardlink(e, NULL);
191 assertEqualString(archive_entry_hardlink(e), NULL);
192 assertEqualWString(archive_entry_hardlink_w(e), NULL);
193 wcscpy(wbuff, L"whardlink");
194 archive_entry_copy_hardlink_w(e, wbuff);
195 assertEqualWString(archive_entry_hardlink_w(e), L"whardlink");
196 memset(wbuff, 0, sizeof(wbuff));
197 assertEqualWString(archive_entry_hardlink_w(e), L"whardlink");
198 archive_entry_copy_hardlink_w(e, NULL);
199 assertEqualString(archive_entry_hardlink(e), NULL);
200 assertEqualWString(archive_entry_hardlink_w(e), NULL);
203 assert(!archive_entry_ino_is_set(e));
204 archive_entry_set_ino(e, 8593);
205 assert(archive_entry_ino_is_set(e));
206 assertEqualInt(archive_entry_ino(e), 8593);
207 assertEqualInt(archive_entry_ino64(e), 8593);
208 archive_entry_set_ino64(e, 8594);
209 assert(archive_entry_ino_is_set(e));
210 assertEqualInt(archive_entry_ino(e), 8594);
211 assertEqualInt(archive_entry_ino64(e), 8594);
214 archive_entry_set_hardlink(e, "hardlinkname");
215 archive_entry_set_symlink(e, NULL);
216 archive_entry_set_link(e, "link");
217 assertEqualString(archive_entry_hardlink(e), "link");
218 assertEqualString(archive_entry_symlink(e), NULL);
219 archive_entry_copy_link(e, "link2");
220 assertEqualString(archive_entry_hardlink(e), "link2");
221 assertEqualString(archive_entry_symlink(e), NULL);
222 archive_entry_copy_link_w(e, L"link3");
223 assertEqualString(archive_entry_hardlink(e), "link3");
224 assertEqualString(archive_entry_symlink(e), NULL);
225 archive_entry_set_hardlink(e, NULL);
226 archive_entry_set_symlink(e, "symlink");
227 archive_entry_set_link(e, "link");
228 assertEqualString(archive_entry_hardlink(e), NULL);
229 assertEqualString(archive_entry_symlink(e), "link");
230 archive_entry_copy_link(e, "link2");
231 assertEqualString(archive_entry_hardlink(e), NULL);
232 assertEqualString(archive_entry_symlink(e), "link2");
233 archive_entry_copy_link_w(e, L"link3");
234 assertEqualString(archive_entry_hardlink(e), NULL);
235 assertEqualString(archive_entry_symlink(e), "link3");
236 /* Arbitrarily override symlink if both hardlink and symlink set. */
237 archive_entry_set_hardlink(e, "hardlink");
238 archive_entry_set_symlink(e, "symlink");
239 archive_entry_set_link(e, "link");
240 assertEqualString(archive_entry_hardlink(e), "hardlink");
241 assertEqualString(archive_entry_symlink(e), "link");
244 archive_entry_set_mode(e, 0123456);
245 assertEqualInt(archive_entry_mode(e), 0123456);
248 archive_entry_set_mtime(e, 13581, 24682);
249 assertEqualInt(archive_entry_mtime(e), 13581);
250 assertEqualInt(archive_entry_mtime_nsec(e), 24682);
251 archive_entry_set_mtime(e, 13582, 1358297468);
252 assertEqualInt(archive_entry_mtime(e), 13583);
253 assertEqualInt(archive_entry_mtime_nsec(e), 358297468);
254 archive_entry_set_mtime(e, 13583, -24682);
255 assertEqualInt(archive_entry_mtime(e), 13582);
256 assertEqualInt(archive_entry_mtime_nsec(e), 999975318);
257 archive_entry_unset_mtime(e);
258 assertEqualInt(archive_entry_mtime(e), 0);
259 assertEqualInt(archive_entry_mtime_nsec(e), 0);
260 assert(!archive_entry_mtime_is_set(e));
263 archive_entry_set_nlink(e, 736);
264 assertEqualInt(archive_entry_nlink(e), 736);
267 archive_entry_set_pathname(e, "path");
268 assertEqualString(archive_entry_pathname(e), "path");
269 archive_entry_set_pathname(e, "path");
270 assertEqualString(archive_entry_pathname(e), "path");
271 strcpy(buff, "path2");
272 archive_entry_copy_pathname(e, buff);
273 assertEqualString(archive_entry_pathname(e), "path2");
274 memset(buff, 0, sizeof(buff));
275 assertEqualString(archive_entry_pathname(e), "path2");
276 wcscpy(wbuff, L"wpath");
277 archive_entry_copy_pathname_w(e, wbuff);
278 assertEqualWString(archive_entry_pathname_w(e), L"wpath");
279 memset(wbuff, 0, sizeof(wbuff));
280 assertEqualWString(archive_entry_pathname_w(e), L"wpath");
283 archive_entry_set_rdev(e, 532);
284 assertEqualInt(archive_entry_rdev(e), 532);
285 /* rdevmajor/rdevminor are tested specially below. */
288 archive_entry_set_size(e, 987654321);
289 assertEqualInt(archive_entry_size(e), 987654321);
290 archive_entry_unset_size(e);
291 assertEqualInt(archive_entry_size(e), 0);
292 assert(!archive_entry_size_is_set(e));
295 archive_entry_copy_sourcepath(e, "path1");
296 assertEqualString(archive_entry_sourcepath(e), "path1");
299 archive_entry_set_symlink(e, "symlinkname");
300 assertEqualString(archive_entry_symlink(e), "symlinkname");
301 strcpy(buff, "symlinkname2");
302 archive_entry_copy_symlink(e, buff);
303 assertEqualString(archive_entry_symlink(e), "symlinkname2");
304 memset(buff, 0, sizeof(buff));
305 assertEqualString(archive_entry_symlink(e), "symlinkname2");
306 archive_entry_copy_symlink_w(e, NULL);
307 assertEqualWString(archive_entry_symlink_w(e), NULL);
308 assertEqualString(archive_entry_symlink(e), NULL);
309 archive_entry_copy_symlink_w(e, L"wsymlink");
310 assertEqualWString(archive_entry_symlink_w(e), L"wsymlink");
311 archive_entry_copy_symlink(e, NULL);
312 assertEqualWString(archive_entry_symlink_w(e), NULL);
313 assertEqualString(archive_entry_symlink(e), NULL);
316 archive_entry_set_uid(e, 83);
317 assertEqualInt(archive_entry_uid(e), 83);
320 archive_entry_set_uname(e, "user");
321 assertEqualString(archive_entry_uname(e), "user");
322 wcscpy(wbuff, L"wuser");
323 archive_entry_copy_gname_w(e, wbuff);
324 assertEqualWString(archive_entry_gname_w(e), L"wuser");
325 memset(wbuff, 0, sizeof(wbuff));
326 assertEqualWString(archive_entry_gname_w(e), L"wuser");
328 /* Test fflags interface. */
329 archive_entry_set_fflags(e, 0x55, 0xAA);
330 archive_entry_fflags(e, &set, &clear);
331 failure("Testing set/get of fflags data.");
332 assertEqualInt(set, 0x55);
333 failure("Testing set/get of fflags data.");
334 assertEqualInt(clear, 0xAA);
336 /* Converting fflags bitmap to string is currently system-dependent. */
337 /* TODO: Make this system-independent. */
338 assertEqualString(archive_entry_fflags_text(e),
339 "uappnd,nouchg,nodump,noopaque,uunlnk");
340 /* Test archive_entry_copy_fflags_text_w() */
341 archive_entry_copy_fflags_text_w(e, L" ,nouappnd, nouchg, dump,uunlnk");
342 archive_entry_fflags(e, &set, &clear);
343 assertEqualInt(16, set);
344 assertEqualInt(7, clear);
345 /* Test archive_entry_copy_fflags_text() */
346 archive_entry_copy_fflags_text(e, " ,nouappnd, nouchg, dump,uunlnk");
347 archive_entry_fflags(e, &set, &clear);
348 assertEqualInt(16, set);
349 assertEqualInt(7, clear);
352 /* See test_acl_basic.c for tests of ACL set/get consistency. */
354 /* Test xattrs set/get consistency. */
355 archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue1", 12);
356 assertEqualInt(1, archive_entry_xattr_reset(e));
357 assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize));
358 assertEqualString(xname, "xattr1");
359 assertEqualString(xval, "xattrvalue1");
360 assertEqualInt((int)xsize, 12);
361 assertEqualInt(1, archive_entry_xattr_count(e));
362 assertEqualInt(ARCHIVE_WARN,
363 archive_entry_xattr_next(e, &xname, &xval, &xsize));
364 assertEqualString(xname, NULL);
365 assertEqualString(xval, NULL);
366 assertEqualInt((int)xsize, 0);
367 archive_entry_xattr_clear(e);
368 assertEqualInt(0, archive_entry_xattr_reset(e));
369 assertEqualInt(ARCHIVE_WARN,
370 archive_entry_xattr_next(e, &xname, &xval, &xsize));
371 assertEqualString(xname, NULL);
372 assertEqualString(xval, NULL);
373 assertEqualInt((int)xsize, 0);
374 archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue1", 12);
375 assertEqualInt(1, archive_entry_xattr_reset(e));
376 archive_entry_xattr_add_entry(e, "xattr2", "xattrvalue2", 12);
377 assertEqualInt(2, archive_entry_xattr_reset(e));
378 assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize));
379 assertEqualInt(0, archive_entry_xattr_next(e, &xname, &xval, &xsize));
380 assertEqualInt(ARCHIVE_WARN,
381 archive_entry_xattr_next(e, &xname, &xval, &xsize));
382 assertEqualString(xname, NULL);
383 assertEqualString(xval, NULL);
384 assertEqualInt((int)xsize, 0);
388 * Test clone() implementation.
391 /* Set values in 'e' */
392 archive_entry_clear(e);
393 archive_entry_set_atime(e, 13579, 24680);
394 archive_entry_set_birthtime(e, 13779, 24990);
395 archive_entry_set_ctime(e, 13580, 24681);
396 archive_entry_set_dev(e, 235);
397 archive_entry_set_fflags(e, 0x55, 0xAA);
398 archive_entry_set_gid(e, 204);
399 archive_entry_set_gname(e, "group");
400 archive_entry_set_hardlink(e, "hardlinkname");
401 archive_entry_set_ino(e, 8593);
402 archive_entry_set_mode(e, 0123456);
403 archive_entry_set_mtime(e, 13581, 24682);
404 archive_entry_set_nlink(e, 736);
405 archive_entry_set_pathname(e, "path");
406 archive_entry_set_rdev(e, 532);
407 archive_entry_set_size(e, 987654321);
408 archive_entry_copy_sourcepath(e, "source");
409 archive_entry_set_symlink(e, "symlinkname");
410 archive_entry_set_uid(e, 83);
411 archive_entry_set_uname(e, "user");
412 /* Add an ACL entry. */
413 archive_entry_acl_add_entry(e, ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
414 ARCHIVE_ENTRY_ACL_READ, ARCHIVE_ENTRY_ACL_USER, 77, "user77");
415 /* Add an extended attribute. */
416 archive_entry_xattr_add_entry(e, "xattr1", "xattrvalue", 11);
419 e2 = archive_entry_clone(e);
421 /* Clone should have same contents. */
422 assertEqualInt(archive_entry_atime(e2), 13579);
423 assertEqualInt(archive_entry_atime_nsec(e2), 24680);
424 assertEqualInt(archive_entry_birthtime(e2), 13779);
425 assertEqualInt(archive_entry_birthtime_nsec(e2), 24990);
426 assertEqualInt(archive_entry_ctime(e2), 13580);
427 assertEqualInt(archive_entry_ctime_nsec(e2), 24681);
428 assertEqualInt(archive_entry_dev(e2), 235);
429 archive_entry_fflags(e, &set, &clear);
430 assertEqualInt(clear, 0xAA);
431 assertEqualInt(set, 0x55);
432 assertEqualInt(archive_entry_gid(e2), 204);
433 assertEqualString(archive_entry_gname(e2), "group");
434 assertEqualString(archive_entry_hardlink(e2), "hardlinkname");
435 assertEqualInt(archive_entry_ino(e2), 8593);
436 assertEqualInt(archive_entry_mode(e2), 0123456);
437 assertEqualInt(archive_entry_mtime(e2), 13581);
438 assertEqualInt(archive_entry_mtime_nsec(e2), 24682);
439 assertEqualInt(archive_entry_nlink(e2), 736);
440 assertEqualString(archive_entry_pathname(e2), "path");
441 assertEqualInt(archive_entry_rdev(e2), 532);
442 assertEqualInt(archive_entry_size(e2), 987654321);
443 assertEqualString(archive_entry_sourcepath(e2), "source");
444 assertEqualString(archive_entry_symlink(e2), "symlinkname");
445 assertEqualInt(archive_entry_uid(e2), 83);
446 assertEqualString(archive_entry_uname(e2), "user");
448 /* Verify ACL was copied. */
449 assertEqualInt(4, archive_entry_acl_reset(e2,
450 ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
451 /* First three are standard permission bits. */
452 assertEqualInt(0, archive_entry_acl_next(e2,
453 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
454 &type, &permset, &tag, &qual, &name));
455 assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
456 assertEqualInt(permset, 4);
457 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER_OBJ);
458 assertEqualInt(qual, -1);
459 assertEqualString(name, NULL);
460 assertEqualInt(0, archive_entry_acl_next(e2,
461 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
462 &type, &permset, &tag, &qual, &name));
463 assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
464 assertEqualInt(permset, 5);
465 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_GROUP_OBJ);
466 assertEqualInt(qual, -1);
467 assertEqualString(name, NULL);
468 assertEqualInt(0, archive_entry_acl_next(e2,
469 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
470 &type, &permset, &tag, &qual, &name));
471 assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
472 assertEqualInt(permset, 6);
473 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_OTHER);
474 assertEqualInt(qual, -1);
475 assertEqualString(name, NULL);
476 /* Fourth is custom one. */
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, ARCHIVE_ENTRY_ACL_READ);
482 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER);
483 assertEqualInt(qual, 77);
484 assertEqualString(name, "user77");
486 /* Verify xattr was copied. */
487 assertEqualInt(1, archive_entry_xattr_reset(e2));
488 assertEqualInt(0, archive_entry_xattr_next(e2, &xname, &xval, &xsize));
489 assertEqualString(xname, "xattr1");
490 assertEqualString(xval, "xattrvalue");
491 assertEqualInt((int)xsize, 11);
492 assertEqualInt(ARCHIVE_WARN,
493 archive_entry_xattr_next(e2, &xname, &xval, &xsize));
494 assertEqualString(xname, NULL);
495 assertEqualString(xval, NULL);
496 assertEqualInt((int)xsize, 0);
498 /* Change the original */
499 archive_entry_set_atime(e, 13580, 24690);
500 archive_entry_set_birthtime(e, 13980, 24999);
501 archive_entry_set_ctime(e, 13590, 24691);
502 archive_entry_set_dev(e, 245);
503 archive_entry_set_fflags(e, 0x85, 0xDA);
504 archive_entry_set_filetype(e, AE_IFLNK);
505 archive_entry_set_gid(e, 214);
506 archive_entry_set_gname(e, "grouper");
507 archive_entry_set_hardlink(e, "hardlinkpath");
508 archive_entry_set_ino(e, 8763);
509 archive_entry_set_mode(e, 0123654);
510 archive_entry_set_mtime(e, 18351, 28642);
511 archive_entry_set_nlink(e, 73);
512 archive_entry_set_pathname(e, "pathest");
513 archive_entry_set_rdev(e, 132);
514 archive_entry_set_size(e, 987456321);
515 archive_entry_copy_sourcepath(e, "source2");
516 archive_entry_set_symlink(e, "symlinkpath");
517 archive_entry_set_uid(e, 93);
518 archive_entry_set_uname(e, "username");
519 archive_entry_acl_clear(e);
520 archive_entry_xattr_clear(e);
522 /* Clone should still have same contents. */
523 assertEqualInt(archive_entry_atime(e2), 13579);
524 assertEqualInt(archive_entry_atime_nsec(e2), 24680);
525 assertEqualInt(archive_entry_birthtime(e2), 13779);
526 assertEqualInt(archive_entry_birthtime_nsec(e2), 24990);
527 assertEqualInt(archive_entry_ctime(e2), 13580);
528 assertEqualInt(archive_entry_ctime_nsec(e2), 24681);
529 assertEqualInt(archive_entry_dev(e2), 235);
530 archive_entry_fflags(e2, &set, &clear);
531 assertEqualInt(clear, 0xAA);
532 assertEqualInt(set, 0x55);
533 assertEqualInt(archive_entry_gid(e2), 204);
534 assertEqualString(archive_entry_gname(e2), "group");
535 assertEqualString(archive_entry_hardlink(e2), "hardlinkname");
536 assertEqualInt(archive_entry_ino(e2), 8593);
537 assertEqualInt(archive_entry_mode(e2), 0123456);
538 assertEqualInt(archive_entry_mtime(e2), 13581);
539 assertEqualInt(archive_entry_mtime_nsec(e2), 24682);
540 assertEqualInt(archive_entry_nlink(e2), 736);
541 assertEqualString(archive_entry_pathname(e2), "path");
542 assertEqualInt(archive_entry_rdev(e2), 532);
543 assertEqualInt(archive_entry_size(e2), 987654321);
544 assertEqualString(archive_entry_sourcepath(e2), "source");
545 assertEqualString(archive_entry_symlink(e2), "symlinkname");
546 assertEqualInt(archive_entry_uid(e2), 83);
547 assertEqualString(archive_entry_uname(e2), "user");
549 /* Verify ACL was unchanged. */
550 assertEqualInt(4, archive_entry_acl_reset(e2,
551 ARCHIVE_ENTRY_ACL_TYPE_ACCESS));
552 /* First three are standard permission bits. */
553 assertEqualInt(0, archive_entry_acl_next(e2,
554 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
555 &type, &permset, &tag, &qual, &name));
556 assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
557 assertEqualInt(permset, 4);
558 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER_OBJ);
559 assertEqualInt(qual, -1);
560 assertEqualString(name, NULL);
561 assertEqualInt(0, archive_entry_acl_next(e2,
562 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
563 &type, &permset, &tag, &qual, &name));
564 assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
565 assertEqualInt(permset, 5);
566 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_GROUP_OBJ);
567 assertEqualInt(qual, -1);
568 assertEqualString(name, NULL);
569 assertEqualInt(0, archive_entry_acl_next(e2,
570 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
571 &type, &permset, &tag, &qual, &name));
572 assertEqualInt(type, ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
573 assertEqualInt(permset, 6);
574 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_OTHER);
575 assertEqualInt(qual, -1);
576 assertEqualString(name, NULL);
577 /* Fourth is custom one. */
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, ARCHIVE_ENTRY_ACL_READ);
583 assertEqualInt(tag, ARCHIVE_ENTRY_ACL_USER);
584 assertEqualInt(qual, 77);
585 assertEqualString(name, "user77");
586 assertEqualInt(1, archive_entry_acl_next(e2,
587 ARCHIVE_ENTRY_ACL_TYPE_ACCESS,
588 &type, &permset, &tag, &qual, &name));
589 assertEqualInt(type, 0);
590 assertEqualInt(permset, 0);
591 assertEqualInt(tag, 0);
592 assertEqualInt(qual, -1);
593 assertEqualString(name, NULL);
595 /* Verify xattr was unchanged. */
596 assertEqualInt(1, archive_entry_xattr_reset(e2));
599 archive_entry_free(e2);
602 * Test clear() implementation.
604 archive_entry_clear(e);
605 assertEqualInt(archive_entry_atime(e), 0);
606 assertEqualInt(archive_entry_atime_nsec(e), 0);
607 assertEqualInt(archive_entry_birthtime(e), 0);
608 assertEqualInt(archive_entry_birthtime_nsec(e), 0);
609 assertEqualInt(archive_entry_ctime(e), 0);
610 assertEqualInt(archive_entry_ctime_nsec(e), 0);
611 assertEqualInt(archive_entry_dev(e), 0);
612 archive_entry_fflags(e, &set, &clear);
613 assertEqualInt(clear, 0);
614 assertEqualInt(set, 0);
615 assertEqualInt(archive_entry_filetype(e), 0);
616 assertEqualInt(archive_entry_gid(e), 0);
617 assertEqualString(archive_entry_gname(e), NULL);
618 assertEqualString(archive_entry_hardlink(e), NULL);
619 assertEqualInt(archive_entry_ino(e), 0);
620 assertEqualInt(archive_entry_mode(e), 0);
621 assertEqualInt(archive_entry_mtime(e), 0);
622 assertEqualInt(archive_entry_mtime_nsec(e), 0);
623 assertEqualInt(archive_entry_nlink(e), 0);
624 assertEqualString(archive_entry_pathname(e), NULL);
625 assertEqualInt(archive_entry_rdev(e), 0);
626 assertEqualInt(archive_entry_size(e), 0);
627 assertEqualString(archive_entry_symlink(e), NULL);
628 assertEqualInt(archive_entry_uid(e), 0);
629 assertEqualString(archive_entry_uname(e), NULL);
630 /* ACLs should be cleared. */
631 assertEqualInt(archive_entry_acl_count(e, ARCHIVE_ENTRY_ACL_TYPE_ACCESS), 0);
632 assertEqualInt(archive_entry_acl_count(e, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT), 0);
633 /* Extended attributes should be cleared. */
634 assertEqualInt(archive_entry_xattr_count(e), 0);
637 * Test archive_entry_copy_stat().
639 memset(&st, 0, sizeof(st));
640 /* Set all of the standard 'struct stat' fields. */
641 st.st_atime = 456789;
642 st.st_ctime = 345678;
647 st.st_mtime = 234567;
649 st.st_size = 123456789;
652 /* On FreeBSD, high-res timestamp data should come through. */
653 st.st_atimespec.tv_nsec = 6543210;
654 st.st_ctimespec.tv_nsec = 5432109;
655 st.st_mtimespec.tv_nsec = 3210987;
656 st.st_birthtimespec.tv_nsec = 7459386;
658 /* Copy them into the entry. */
659 archive_entry_copy_stat(e, &st);
660 /* Read each one back separately and compare. */
661 assertEqualInt(archive_entry_atime(e), 456789);
662 assertEqualInt(archive_entry_ctime(e), 345678);
663 assertEqualInt(archive_entry_dev(e), 123);
664 assertEqualInt(archive_entry_gid(e), 34);
665 assertEqualInt(archive_entry_ino(e), 234);
666 assertEqualInt(archive_entry_mode(e), 077777);
667 assertEqualInt(archive_entry_mtime(e), 234567);
668 assertEqualInt(archive_entry_nlink(e), 345);
669 assertEqualInt(archive_entry_size(e), 123456789);
670 assertEqualInt(archive_entry_uid(e), 23);
672 /* On FreeBSD, high-res timestamp data should come through. */
673 assertEqualInt(archive_entry_atime_nsec(e), 6543210);
674 assertEqualInt(archive_entry_ctime_nsec(e), 5432109);
675 assertEqualInt(archive_entry_mtime_nsec(e), 3210987);
676 assertEqualInt(archive_entry_birthtime_nsec(e), 7459386);
680 * Test archive_entry_stat().
682 /* First, clear out any existing stat data. */
683 memset(&st, 0, sizeof(st));
684 archive_entry_copy_stat(e, &st);
685 /* Set a bunch of fields individually. */
686 archive_entry_set_atime(e, 456789, 321);
687 archive_entry_set_ctime(e, 345678, 432);
688 archive_entry_set_dev(e, 123);
689 archive_entry_set_gid(e, 34);
690 archive_entry_set_ino(e, 234);
691 archive_entry_set_mode(e, 012345);
692 archive_entry_set_mode(e, 012345);
693 archive_entry_set_mtime(e, 234567, 543);
694 archive_entry_set_nlink(e, 345);
695 archive_entry_set_size(e, 123456789);
696 archive_entry_set_uid(e, 23);
697 /* Retrieve a stat structure. */
698 assert((pst = archive_entry_stat(e)) != NULL);
701 /* Check that the values match. */
702 assertEqualInt(pst->st_atime, 456789);
703 assertEqualInt(pst->st_ctime, 345678);
704 assertEqualInt(pst->st_dev, 123);
705 assertEqualInt(pst->st_gid, 34);
706 assertEqualInt(pst->st_ino, 234);
707 assertEqualInt(pst->st_mode, 012345);
708 assertEqualInt(pst->st_mtime, 234567);
709 assertEqualInt(pst->st_nlink, 345);
710 assertEqualInt(pst->st_size, 123456789);
711 assertEqualInt(pst->st_uid, 23);
713 /* On FreeBSD, high-res timestamp data should come through. */
714 assertEqualInt(pst->st_atimespec.tv_nsec, 321);
715 assertEqualInt(pst->st_ctimespec.tv_nsec, 432);
716 assertEqualInt(pst->st_mtimespec.tv_nsec, 543);
719 /* Changing any one value should update struct stat. */
720 archive_entry_set_atime(e, 456788, 0);
721 assert((pst = archive_entry_stat(e)) != NULL);
724 assertEqualInt(pst->st_atime, 456788);
725 archive_entry_set_ctime(e, 345677, 431);
726 assert((pst = archive_entry_stat(e)) != NULL);
729 assertEqualInt(pst->st_ctime, 345677);
730 archive_entry_set_dev(e, 122);
731 assert((pst = archive_entry_stat(e)) != NULL);
734 assertEqualInt(pst->st_dev, 122);
735 archive_entry_set_gid(e, 33);
736 assert((pst = archive_entry_stat(e)) != NULL);
739 assertEqualInt(pst->st_gid, 33);
740 archive_entry_set_ino(e, 233);
741 assert((pst = archive_entry_stat(e)) != NULL);
744 assertEqualInt(pst->st_ino, 233);
745 archive_entry_set_mode(e, 012344);
746 assert((pst = archive_entry_stat(e)) != NULL);
749 assertEqualInt(pst->st_mode, 012344);
750 archive_entry_set_mtime(e, 234566, 542);
751 assert((pst = archive_entry_stat(e)) != NULL);
754 assertEqualInt(pst->st_mtime, 234566);
755 archive_entry_set_nlink(e, 344);
756 assert((pst = archive_entry_stat(e)) != NULL);
759 assertEqualInt(pst->st_nlink, 344);
760 archive_entry_set_size(e, 123456788);
761 assert((pst = archive_entry_stat(e)) != NULL);
764 assertEqualInt(pst->st_size, 123456788);
765 archive_entry_set_uid(e, 22);
766 assert((pst = archive_entry_stat(e)) != NULL);
769 assertEqualInt(pst->st_uid, 22);
770 /* We don't need to check high-res fields here. */
773 * Test dev/major/minor interfaces. Setting 'dev' or 'rdev'
774 * should change the corresponding major/minor values, and
777 * The test here is system-specific because it assumes that
778 * makedev(), major(), and minor() are defined in sys/stat.h.
779 * I'm not too worried about it, though, because the code is
780 * simple. If it works on FreeBSD, it's unlikely to be broken
781 * anywhere else. Note: The functionality is present on every
782 * platform even if these tests only run some places;
783 * libarchive's more extensive configuration logic should find
784 * the necessary definitions on every platform.
787 archive_entry_set_dev(e, 0x12345678);
788 assertEqualInt(archive_entry_devmajor(e), major(0x12345678));
789 assertEqualInt(archive_entry_devminor(e), minor(0x12345678));
790 assertEqualInt(archive_entry_dev(e), 0x12345678);
791 archive_entry_set_devmajor(e, 0xfe);
792 archive_entry_set_devminor(e, 0xdcba98);
793 assertEqualInt(archive_entry_devmajor(e), 0xfe);
794 assertEqualInt(archive_entry_devminor(e), 0xdcba98);
795 assertEqualInt(archive_entry_dev(e), makedev(0xfe, 0xdcba98));
796 archive_entry_set_rdev(e, 0x12345678);
797 assertEqualInt(archive_entry_rdevmajor(e), major(0x12345678));
798 assertEqualInt(archive_entry_rdevminor(e), minor(0x12345678));
799 assertEqualInt(archive_entry_rdev(e), 0x12345678);
800 archive_entry_set_rdevmajor(e, 0xfe);
801 archive_entry_set_rdevminor(e, 0xdcba98);
802 assertEqualInt(archive_entry_rdevmajor(e), 0xfe);
803 assertEqualInt(archive_entry_rdevminor(e), 0xdcba98);
804 assertEqualInt(archive_entry_rdev(e), makedev(0xfe, 0xdcba98));
808 * Exercise the character-conversion logic, if we can.
810 if (NULL == setlocale(LC_ALL, "en_US.UTF-8")) {
811 skipping("Can't exercise charset-conversion logic without"
812 " a suitable locale.");
814 /* A filename that cannot be converted to wide characters. */
815 archive_entry_copy_pathname(e, "abc\314\214mno\374xyz");
816 failure("Converting invalid chars to Unicode should fail.");
817 assert(NULL == archive_entry_pathname_w(e));
819 failure("Converting invalid chars to UTF-8 should fail.");
820 assert(NULL == archive_entry_pathname_utf8(e));
823 /* A group name that cannot be converted. */
824 archive_entry_copy_gname(e, "abc\314\214mno\374xyz");
825 failure("Converting invalid chars to Unicode should fail.");
826 assert(NULL == archive_entry_gname_w(e));
828 /* A user name that cannot be converted. */
829 archive_entry_copy_uname(e, "abc\314\214mno\374xyz");
830 failure("Converting invalid chars to Unicode should fail.");
831 assert(NULL == archive_entry_uname_w(e));
833 /* A hardlink target that cannot be converted. */
834 archive_entry_copy_hardlink(e, "abc\314\214mno\374xyz");
835 failure("Converting invalid chars to Unicode should fail.");
836 assert(NULL == archive_entry_hardlink_w(e));
838 /* A symlink target that cannot be converted. */
839 archive_entry_copy_symlink(e, "abc\314\214mno\374xyz");
840 failure("Converting invalid chars to Unicode should fail.");
841 assert(NULL == archive_entry_symlink_w(e));
845 wc = (wchar_t)l; /* Wide character too big for UTF-8. */
846 if (NULL == setlocale(LC_ALL, "C") || (long)wc != l) {
847 skipping("Testing charset conversion failure requires 32-bit wchar_t and support for \"C\" locale.");
850 * Build the string L"xxx\U12345678yyy\u5678zzz" without
851 * using wcscpy or C99 \u#### syntax.
853 name = "xxxAyyyBzzz";
854 for (i = 0; i < (int)strlen(name); ++i)
856 wbuff[3] = (wchar_t)0x12345678;
857 wbuff[7] = (wchar_t)0x5678;
858 /* A Unicode filename that cannot be converted to UTF-8. */
859 archive_entry_copy_pathname_w(e, wbuff);
860 failure("Converting wide characters from Unicode should fail.");
861 assertEqualString(NULL, archive_entry_pathname(e));
864 /* Release the experimental entry. */
865 archive_entry_free(e);