14 #include <sys/socket.h> 
   15 #include <sys/types.h> 
   20 # define ALLPERMS (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO) 
   24 static char testfile[1024];
 
   25 static char testfile2[1024];
 
   26 static char testdir[1024];
 
   27 static char testdir2[1024];
 
   28 static char testsock[1024];
 
   29 static char subfile[1280];
 
   31 static char testfile_r[1024];
 
   32 static char testfile2_r[1024];
 
   33 static char testdir_r[1024];
 
   34 static char testdir2_r[1024];
 
   35 static char subfile_r[1280];
 
   37 static char testname[256];
 
   38 static char testdata[] = 
"abcdefghijklmnopqrstuvwxyz";
 
   39 static char testdata2[] = 
"1234567890-=qwertyuiop[]\asdfghjkl;'zxcvbnm,./";
 
   40 static const char *testdir_files[] = { 
"f1", 
"f2", NULL};
 
   41 static long seekdir_offsets[4];
 
   42 static char zerodata[4096];
 
   43 static int testdatalen = 
sizeof(testdata) - 1;
 
   44 static int testdata2len = 
sizeof(testdata2) - 1;
 
   45 static unsigned int testnum = 1;
 
   46 static unsigned int select_test = 0;
 
   47 static unsigned int skip_test = 0;
 
   49 #define MAX_ENTRIES 1024 
   51 static void test_perror(
const char *func, 
const char *msg)
 
   53         fprintf(stderr, 
"%s %s() - %s: %s\n", testname, func, msg,
 
   57 static void test_error(
const char *func, 
const char *msg, ...)
 
   58         __attribute__ ((format (printf, 2, 3)));
 
   60 static 
void __start_test(const 
char *fmt, ...)
 
   61         __attribute__ ((format (printf, 1, 2)));
 
   63 static 
void test_error(const 
char *func, const 
char *msg, ...)
 
   66         fprintf(stderr, 
"%s %s() - ", testname, func);
 
   68         vfprintf(stderr, msg, ap);
 
   70         fprintf(stderr, 
"\n");
 
   73 static int is_dot_or_dotdot(
const char *name) {
 
   74     return name[0] == 
'.' &&
 
   75            (name[1] == 
'\0' || (name[1] == 
'.' && name[2] == 
'\0'));
 
   78 static void success(
void)
 
   80         fprintf(stderr, 
"%s OK\n", testname);
 
   83 static void __start_test(
const char *fmt, ...)
 
   87         n = sprintf(testname, 
"%3i [", testnum++);
 
   89         n += vsprintf(testname + n, fmt, ap);
 
   91         sprintf(testname + n, 
"]");
 
   94 #define start_test(msg, args...) { \ 
   95         if ((select_test && testnum != select_test) || \ 
   96             (testnum == skip_test)) { \ 
  100         __start_test(msg, ##args);              \ 
  103 #define PERROR(msg) test_perror(__FUNCTION__, msg) 
  104 #define ERROR(msg, args...) test_error(__FUNCTION__, msg, ##args) 
  106 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) 
  108 static int check_size(
const char *path, 
int len)
 
  111         int res = stat(path, &stbuf);
 
  116         if (stbuf.st_size != len) {
 
  117                 ERROR(
"length %u instead of %u", (
int) stbuf.st_size,
 
  124 static int fcheck_size(
int fd, 
int len)
 
  127         int res = fstat(fd, &stbuf);
 
  132         if (stbuf.st_size != len) {
 
  133                 ERROR(
"length %u instead of %u", (
int) stbuf.st_size,
 
  140 static int check_type(
const char *path, mode_t type)
 
  143         int res = lstat(path, &stbuf);
 
  148         if ((stbuf.st_mode & S_IFMT) != type) {
 
  149                 ERROR(
"type 0%o instead of 0%o", stbuf.st_mode & S_IFMT, type);
 
  155 static int fcheck_type(
int fd, mode_t type)
 
  158         int res = fstat(fd, &stbuf);
 
  163         if ((stbuf.st_mode & S_IFMT) != type) {
 
  164                 ERROR(
"type 0%o instead of 0%o", stbuf.st_mode & S_IFMT, type);
 
  170 static int check_mode(
const char *path, mode_t mode)
 
  173         int res = lstat(path, &stbuf);
 
  178         if ((stbuf.st_mode & ALLPERMS) != mode) {
 
  179                 ERROR(
"mode 0%o instead of 0%o", stbuf.st_mode & ALLPERMS,
 
  186 static int fcheck_mode(
int fd, mode_t mode)
 
  189         int res = fstat(fd, &stbuf);
 
  194         if ((stbuf.st_mode & ALLPERMS) != mode) {
 
  195                 ERROR(
"mode 0%o instead of 0%o", stbuf.st_mode & ALLPERMS,
 
  202 static int check_times(
const char *path, time_t atime, time_t mtime)
 
  206         int res = lstat(path, &stbuf);
 
  211         if (stbuf.st_atime != atime) {
 
  212                 ERROR(
"atime %li instead of %li", stbuf.st_atime, atime);
 
  215         if (stbuf.st_mtime != mtime) {
 
  216                 ERROR(
"mtime %li instead of %li", stbuf.st_mtime, mtime);
 
  226 static int fcheck_times(
int fd, time_t atime, time_t mtime)
 
  230         int res = fstat(fd, &stbuf);
 
  235         if (stbuf.st_atime != atime) {
 
  236                 ERROR(
"atime %li instead of %li", stbuf.st_atime, atime);
 
  239         if (stbuf.st_mtime != mtime) {
 
  240                 ERROR(
"mtime %li instead of %li", stbuf.st_mtime, mtime);
 
  250 static int check_nlink(
const char *path, nlink_t nlink)
 
  253         int res = lstat(path, &stbuf);
 
  258         if (stbuf.st_nlink != nlink) {
 
  259                 ERROR(
"nlink %li instead of %li", (
long) stbuf.st_nlink,
 
  266 static int fcheck_nlink(
int fd, nlink_t nlink)
 
  269         int res = fstat(fd, &stbuf);
 
  274         if (stbuf.st_nlink != nlink) {
 
  275                 ERROR(
"nlink %li instead of %li", (
long) stbuf.st_nlink,
 
  282 static int check_nonexist(
const char *path)
 
  285         int res = lstat(path, &stbuf);
 
  287                 ERROR(
"file should not exist");
 
  290         if (errno != ENOENT) {
 
  291                 ERROR(
"file should not exist: %s", strerror(errno));
 
  297 static int check_buffer(
const char *buf, 
const char *data, 
unsigned len)
 
  299         if (memcmp(buf, data, len) != 0) {
 
  300                 ERROR(
"data mismatch");
 
  306 static int check_data(
const char *path, 
const char *data, 
int offset,
 
  311         int fd = open(path, O_RDONLY);
 
  316         if (lseek(fd, offset, SEEK_SET) == (off_t) -1) {
 
  322                 int rdlen = len < 
sizeof(buf) ? len : 
sizeof(buf);
 
  323                 res = read(fd, buf, rdlen);
 
  330                         ERROR(
"short read: %u instead of %u", res, rdlen);
 
  334                 if (check_buffer(buf, data, rdlen) != 0) {
 
  349 static int fcheck_data(
int fd, 
const char *data, 
int offset,
 
  354         if (lseek(fd, offset, SEEK_SET) == (off_t) -1) {
 
  359                 int rdlen = len < 
sizeof(buf) ? len : 
sizeof(buf);
 
  360                 res = read(fd, buf, rdlen);
 
  366                         ERROR(
"short read: %u instead of %u", res, rdlen);
 
  369                 if (check_buffer(buf, data, rdlen) != 0) {
 
  378 static int check_dir_contents(
const char *path, 
const char **contents)
 
  383         int found[MAX_ENTRIES];
 
  384         const char *cont[MAX_ENTRIES];
 
  387         for (i = 0; contents[i]; i++) {
 
  388                 assert(i < MAX_ENTRIES - 3);
 
  390                 cont[i] = contents[i];
 
  399         memset(found, 0, 
sizeof(found));
 
  412                 if (is_dot_or_dotdot(de->d_name))
 
  414                 for (i = 0; cont[i] != NULL; i++) {
 
  415                         assert(i < MAX_ENTRIES);
 
  416                         if (strcmp(cont[i], de->d_name) == 0) {
 
  418                                         ERROR(
"duplicate entry <%s>",
 
  427                         ERROR(
"unexpected entry <%s>", de->d_name);
 
  431         for (i = 0; cont[i] != NULL; i++) {
 
  433                         ERROR(
"missing entry <%s>", cont[i]);
 
  448 static int create_file(
const char *path, 
const char *data, 
int len)
 
  454         fd = creat(path, 0644);
 
  460                 res = write(fd, data, len);
 
  467                         ERROR(
"write is short: %u instead of %u", res, len);
 
  477         res = check_type(path, S_IFREG);
 
  480         res = check_mode(path, 0644);
 
  483         res = check_nlink(path, 1);
 
  486         res = check_size(path, len);
 
  491                 res = check_data(path, data, 0, len);
 
  499 static int cleanup_dir(
const char *path, 
const char **dir_files, 
int quiet)
 
  504         for (i = 0; dir_files[i]; i++) {
 
  507                 sprintf(fpath, 
"%s/%s", path, dir_files[i]);
 
  509                 if (res == -1 && !quiet) {
 
  520 static int create_dir(
const char *path, 
const char **dir_files)
 
  526         res = mkdir(path, 0755);
 
  531         res = check_type(path, S_IFDIR);
 
  534         res = check_mode(path, 0755);
 
  538         for (i = 0; dir_files[i]; i++) {
 
  540                 sprintf(fpath, 
"%s/%s", path, dir_files[i]);
 
  541                 res = create_file(fpath, 
"", 0);
 
  543                         cleanup_dir(path, dir_files, 1);
 
  547         res = check_dir_contents(path, dir_files);
 
  549                 cleanup_dir(path, dir_files, 1);
 
  556 static int test_truncate(
int len)
 
  558         const char *data = testdata;
 
  559         int datalen = testdatalen;
 
  562         start_test(
"truncate(%u)", (
int) len);
 
  563         res = create_file(testfile, data, datalen);
 
  567         res = truncate(testfile, len);
 
  572         res = check_size(testfile, len);
 
  577                 if (len <= datalen) {
 
  578                         res = check_data(testfile, data, 0, len);
 
  582                         res = check_data(testfile, data, 0, datalen);
 
  585                         res = check_data(testfile, zerodata, datalen,
 
  591         res = unlink(testfile);
 
  596         res = check_nonexist(testfile);
 
  604 static int test_ftruncate(
int len, 
int mode)
 
  606         const char *data = testdata;
 
  607         int datalen = testdatalen;
 
  611         start_test(
"ftruncate(%u) mode: 0%03o", len, mode);
 
  612         res = create_file(testfile, data, datalen);
 
  616         fd = open(testfile, O_WRONLY);
 
  622         res = fchmod(fd, mode);
 
  628         res = check_mode(testfile, mode);
 
  633         res = ftruncate(fd, len);
 
  640         res = check_size(testfile, len);
 
  645                 if (len <= datalen) {
 
  646                         res = check_data(testfile, data, 0, len);
 
  650                         res = check_data(testfile, data, 0, datalen);
 
  653                         res = check_data(testfile, zerodata, datalen,
 
  659         res = unlink(testfile);
 
  664         res = check_nonexist(testfile);
 
  672 static int test_seekdir(
void)
 
  679         start_test(
"seekdir");
 
  680         res = create_dir(testdir, testdir_files);
 
  684         dp = opendir(testdir);
 
  691         for (i = 0; i < ARRAY_SIZE(seekdir_offsets); i++) {
 
  692                 seekdir_offsets[i] = telldir(dp);
 
  709         for (i--; i >= 0; i--) {
 
  710                 seekdir(dp, seekdir_offsets[i]);
 
  713                         ERROR(
"Unexpected end of directory after seekdir()");
 
  719         res = cleanup_dir(testdir, testdir_files, 0);
 
  725         cleanup_dir(testdir, testdir_files, 1);
 
  729 #ifdef HAVE_COPY_FILE_RANGE 
  730 static int test_copy_file_range(
void)
 
  732         const char *data = testdata;
 
  733         int datalen = testdatalen;
 
  737         off_t pos_in = 0, pos_out = 0;
 
  739         start_test(
"copy_file_range");
 
  741         fd_in = open(testfile, O_CREAT | O_RDWR, 0644);
 
  746         res = write(fd_in, data, datalen);
 
  752         if (res != datalen) {
 
  753                 ERROR(
"write is short: %u instead of %u", res, datalen);
 
  759         fd_out = creat(testfile2, 0644);
 
  765         res = copy_file_range(fd_in, &pos_in, fd_out, &pos_out, datalen, 0);
 
  767                 PERROR(
"copy_file_range");
 
  772         if (res != datalen) {
 
  773                 ERROR(
"copy is short: %u instead of %u", res, datalen);
 
  791         err = check_data(testfile2, data, 0, datalen);
 
  793         res = unlink(testfile);
 
  798         res = check_nonexist(testfile);
 
  804         res = unlink(testfile2);
 
  809         res = check_nonexist(testfile2);
 
  819 static int test_copy_file_range(
void)
 
  825 static int test_utime(
void)
 
  828         time_t atime = 987631200;
 
  829         time_t mtime = 123116400;
 
  833         res = create_file(testfile, NULL, 0);
 
  839         res = utime(testfile, &utm);
 
  844         res = check_times(testfile, atime, mtime);
 
  848         res = unlink(testfile);
 
  853         res = check_nonexist(testfile);
 
  861 static int test_create(
void)
 
  863         const char *data = testdata;
 
  864         int datalen = testdatalen;
 
  869         start_test(
"create");
 
  871         fd = creat(testfile, 0644);
 
  876         res = write(fd, data, datalen);
 
  882         if (res != datalen) {
 
  883                 ERROR(
"write is short: %u instead of %u", res, datalen);
 
  892         res = check_type(testfile, S_IFREG);
 
  895         err += check_mode(testfile, 0644);
 
  896         err += check_nlink(testfile, 1);
 
  897         err += check_size(testfile, datalen);
 
  898         err += check_data(testfile, data, 0, datalen);
 
  899         res = unlink(testfile);
 
  904         res = check_nonexist(testfile);
 
  914 static int test_create_unlink(
void)
 
  916         const char *data = testdata;
 
  917         int datalen = testdatalen;
 
  922         start_test(
"create+unlink");
 
  924         fd = open(testfile, O_CREAT | O_RDWR | O_TRUNC, 0644);
 
  929         res = unlink(testfile);
 
  935         res = check_nonexist(testfile);
 
  940         res = write(fd, data, datalen);
 
  946         if (res != datalen) {
 
  947                 ERROR(
"write is short: %u instead of %u", res, datalen);
 
  951         err += fcheck_type(fd, S_IFREG);
 
  952         err += fcheck_mode(fd, 0644);
 
  953         err += fcheck_nlink(fd, 0);
 
  954         err += fcheck_size(fd, datalen);
 
  955         err += fcheck_data(fd, data, 0, datalen);
 
  969 static int test_mknod(
void)
 
  976         res = mknod(testfile, 0644, 0);
 
  981         res = check_type(testfile, S_IFREG);
 
  984         err += check_mode(testfile, 0644);
 
  985         err += check_nlink(testfile, 1);
 
  986         err += check_size(testfile, 0);
 
  987         res = unlink(testfile);
 
  992         res = check_nonexist(testfile);
 
 1003 #define test_open(exist, flags, mode)  do_test_open(exist, flags, #flags, mode) 
 1005 static int do_test_open(
int exist, 
int flags, 
const char *flags_str, 
int mode)
 
 1008         const char *data = testdata;
 
 1009         int datalen = testdatalen;
 
 1010         unsigned currlen = 0;
 
 1016         start_test(
"open(%s, %s, 0%03o)", exist ? 
"+" : 
"-", flags_str, mode);
 
 1019                 res = create_file(testfile_r, testdata2, testdata2len);
 
 1023                 currlen = testdata2len;
 
 1026         fd = open(testfile, flags, mode);
 
 1027         if ((flags & O_CREAT) && (flags & O_EXCL) && exist) {
 
 1029                         ERROR(
"open should have failed");
 
 1032                 } 
else if (errno == EEXIST)
 
 1035         if (!(flags & O_CREAT) && !exist) {
 
 1037                         ERROR(
"open should have failed");
 
 1040                 } 
else if (errno == ENOENT)
 
 1048         if (flags & O_TRUNC)
 
 1051         err += check_type(testfile, S_IFREG);
 
 1053                 err += check_mode(testfile, 0644);
 
 1055                 err += check_mode(testfile, mode);
 
 1056         err += check_nlink(testfile, 1);
 
 1057         err += check_size(testfile, currlen);
 
 1058         if (exist && !(flags & O_TRUNC) && (mode & S_IRUSR))
 
 1059                 err += check_data(testfile, testdata2, 0, testdata2len);
 
 1061         res = write(fd, data, datalen);
 
 1062         if ((flags & O_ACCMODE) != O_RDONLY) {
 
 1066                 } 
else if (res != datalen) {
 
 1067                         ERROR(
"write is short: %u instead of %u", res, datalen);
 
 1070                         if (datalen > (
int) currlen)
 
 1073                         err += check_size(testfile, currlen);
 
 1075                         if (mode & S_IRUSR) {
 
 1076                                 err += check_data(testfile, data, 0, datalen);
 
 1077                                 if (exist && !(flags & O_TRUNC) &&
 
 1078                                     testdata2len > datalen)
 
 1079                                         err += check_data(testfile,
 
 1080                                                           testdata2 + datalen,
 
 1082                                                           testdata2len - datalen);
 
 1087                         ERROR(
"write should have failed");
 
 1089                 } 
else if (errno != EBADF) {
 
 1094         off = lseek(fd, SEEK_SET, 0);
 
 1095         if (off == (off_t) -1) {
 
 1098         } 
else if (off != 0) {
 
 1099                 ERROR(
"offset should have returned 0");
 
 1102         res = read(fd, buf, 
sizeof(buf));
 
 1103         if ((flags & O_ACCMODE) != O_WRONLY) {
 
 1109                                 currlen < 
sizeof(buf) ? currlen : 
sizeof(buf);
 
 1110                         if (res != readsize) {
 
 1111                                 ERROR(
"read is short: %i instead of %u",
 
 1115                                 if ((flags & O_ACCMODE) != O_RDONLY) {
 
 1116                                         err += check_buffer(buf, data, datalen);
 
 1117                                         if (exist && !(flags & O_TRUNC) &&
 
 1118                                             testdata2len > datalen)
 
 1119                                                 err += check_buffer(buf + datalen,
 
 1120                                                                     testdata2 + datalen,
 
 1121                                                                     testdata2len - datalen);
 
 1123                                         err += check_buffer(buf, testdata2,
 
 1129                         ERROR(
"read should have failed");
 
 1131                 } 
else if (errno != EBADF) {
 
 1142         res = unlink(testfile);
 
 1147         res = check_nonexist(testfile);
 
 1150         res = check_nonexist(testfile_r);
 
 1161 #define test_open_acc(flags, mode, err)  \ 
 1162         do_test_open_acc(flags, #flags, mode, err) 
 1164 static int do_test_open_acc(
int flags, 
const char *flags_str, 
int mode, 
int err)
 
 1166         const char *data = testdata;
 
 1167         int datalen = testdatalen;
 
 1171         start_test(
"open_acc(%s) mode: 0%03o message: '%s'", flags_str, mode,
 
 1174         res = create_file(testfile, data, datalen);
 
 1178         res = chmod(testfile, mode);
 
 1184         res = check_mode(testfile, mode);
 
 1188         fd = open(testfile, flags);
 
 1196                         ERROR(
"open should have failed");
 
 1206 static int test_symlink(
void)
 
 1209         const char *data = testdata;
 
 1210         int datalen = testdatalen;
 
 1211         int linklen = strlen(testfile);
 
 1215         start_test(
"symlink");
 
 1216         res = create_file(testfile, data, datalen);
 
 1221         res = symlink(testfile, testfile2);
 
 1226         res = check_type(testfile2, S_IFLNK);
 
 1229         err += check_mode(testfile2, 0777);
 
 1230         err += check_nlink(testfile2, 1);
 
 1231         res = readlink(testfile2, buf, 
sizeof(buf));
 
 1236         if (res != linklen) {
 
 1237                 ERROR(
"short readlink: %u instead of %u", res, linklen);
 
 1240         if (memcmp(buf, testfile, linklen) != 0) {
 
 1241                 ERROR(
"link mismatch");
 
 1244         err += check_size(testfile2, datalen);
 
 1245         err += check_data(testfile2, data, 0, datalen);
 
 1246         res = unlink(testfile2);
 
 1251         res = check_nonexist(testfile2);
 
 1261 static int test_link(
void)
 
 1263         const char *data = testdata;
 
 1264         int datalen = testdatalen;
 
 1269         res = create_file(testfile, data, datalen);
 
 1274         res = link(testfile, testfile2);
 
 1279         res = check_type(testfile2, S_IFREG);
 
 1282         err += check_mode(testfile2, 0644);
 
 1283         err += check_nlink(testfile2, 2);
 
 1284         err += check_size(testfile2, datalen);
 
 1285         err += check_data(testfile2, data, 0, datalen);
 
 1286         res = unlink(testfile);
 
 1291         res = check_nonexist(testfile);
 
 1295         err += check_nlink(testfile2, 1);
 
 1296         res = unlink(testfile2);
 
 1301         res = check_nonexist(testfile2);
 
 1311 static int test_link2(
void)
 
 1313         const char *data = testdata;
 
 1314         int datalen = testdatalen;
 
 1318         start_test(
"link-unlink-link");
 
 1319         res = create_file(testfile, data, datalen);
 
 1324         res = link(testfile, testfile2);
 
 1329         res = unlink(testfile);
 
 1334         res = check_nonexist(testfile);
 
 1337         res = link(testfile2, testfile);
 
 1341         res = check_type(testfile, S_IFREG);
 
 1344         err += check_mode(testfile, 0644);
 
 1345         err += check_nlink(testfile, 2);
 
 1346         err += check_size(testfile, datalen);
 
 1347         err += check_data(testfile, data, 0, datalen);
 
 1349         res = unlink(testfile2);
 
 1354         err += check_nlink(testfile, 1);
 
 1355         res = unlink(testfile);
 
 1360         res = check_nonexist(testfile);
 
 1370 static int test_rename_file(
void)
 
 1372         const char *data = testdata;
 
 1373         int datalen = testdatalen;
 
 1377         start_test(
"rename file");
 
 1378         res = create_file(testfile, data, datalen);
 
 1383         res = rename(testfile, testfile2);
 
 1388         res = check_nonexist(testfile);
 
 1391         res = check_type(testfile2, S_IFREG);
 
 1394         err += check_mode(testfile2, 0644);
 
 1395         err += check_nlink(testfile2, 1);
 
 1396         err += check_size(testfile2, datalen);
 
 1397         err += check_data(testfile2, data, 0, datalen);
 
 1398         res = unlink(testfile2);
 
 1403         res = check_nonexist(testfile2);
 
 1413 static int test_rename_dir(
void)
 
 1418         start_test(
"rename dir");
 
 1419         res = create_dir(testdir, testdir_files);
 
 1424         res = rename(testdir, testdir2);
 
 1427                 cleanup_dir(testdir, testdir_files, 1);
 
 1430         res = check_nonexist(testdir);
 
 1432                 cleanup_dir(testdir, testdir_files, 1);
 
 1435         res = check_type(testdir2, S_IFDIR);
 
 1437                 cleanup_dir(testdir2, testdir_files, 1);
 
 1440         err += check_mode(testdir2, 0755);
 
 1441         err += check_dir_contents(testdir2, testdir_files);
 
 1442         err += cleanup_dir(testdir2, testdir_files, 0);
 
 1443         res = rmdir(testdir2);
 
 1448         res = check_nonexist(testdir2);
 
 1458 static int test_rename_dir_loop(
void)
 
 1460 #define PATH(p)         (snprintf(path, sizeof path, "%s/%s", testdir, p), path)
 
 1461 #define PATH2(p)        (snprintf(path2, sizeof path2, "%s/%s", testdir, p), path2)
 
 1463         char path[1280], path2[1280];
 
 1467         start_test(
"rename dir loop");
 
 1469         res = create_dir(testdir, testdir_files);
 
 1473         res = mkdir(PATH(
"a"), 0755);
 
 1479         res = rename(PATH(
"a"), PATH2(
"a"));
 
 1486         res = rename(PATH(
"a"), PATH2(
"a/b"));
 
 1487         if (res == 0 || errno != EINVAL) {
 
 1492         res = mkdir(PATH(
"a/b"), 0755);
 
 1498         res = mkdir(PATH(
"a/b/c"), 0755);
 
 1505         res = rename(PATH(
"a"), PATH2(
"a/b/c"));
 
 1506         if (res == 0 || errno != EINVAL) {
 
 1512         res = rename(PATH(
"a"), PATH2(
"a/b/c/a"));
 
 1513         if (res == 0 || errno != EINVAL) {
 
 1519         res = rename(PATH(
"a/b/c"), PATH2(
"a"));
 
 1520         if (res == 0 || errno != ENOTEMPTY) {
 
 1525         res = open(PATH(
"a/foo"), O_CREAT, 0644);
 
 1532         res = rename(PATH(
"a/foo"), PATH2(
"a/bar"));
 
 1538         res = rename(PATH(
"a/bar"), PATH2(
"a/foo"));
 
 1544         res = rename(PATH(
"a/foo"), PATH2(
"a/b/bar"));
 
 1550         res = rename(PATH(
"a/b/bar"), PATH2(
"a/foo"));
 
 1556         res = rename(PATH(
"a/foo"), PATH2(
"a/b/c/bar"));
 
 1562         res = rename(PATH(
"a/b/c/bar"), PATH2(
"a/foo"));
 
 1568         res = open(PATH(
"a/bar"), O_CREAT, 0644);
 
 1575         res = rename(PATH(
"a/foo"), PATH2(
"a/bar"));
 
 1581         unlink(PATH(
"a/bar"));
 
 1583         res = rename(PATH(
"a/b"), PATH2(
"a/d"));
 
 1589         res = rename(PATH(
"a/d"), PATH2(
"a/b"));
 
 1595         res = mkdir(PATH(
"a/d"), 0755);
 
 1601         res = rename(PATH(
"a/b"), PATH2(
"a/d"));
 
 1607         res = rename(PATH(
"a/d"), PATH2(
"a/b"));
 
 1613         res = mkdir(PATH(
"a/d"), 0755);
 
 1619         res = mkdir(PATH(
"a/d/e"), 0755);
 
 1626         res = rename(PATH(
"a/b"), PATH2(
"a/d"));
 
 1627         if (res == 0 || (errno != ENOTEMPTY && errno != EEXIST)) {
 
 1632         rmdir(PATH(
"a/d/e"));
 
 1635         rmdir(PATH(
"a/b/c"));
 
 1639         err += cleanup_dir(testdir, testdir_files, 0);
 
 1640         res = rmdir(testdir);
 
 1645         res = check_nonexist(testdir);
 
 1655         unlink(PATH(
"a/bar"));
 
 1657         rmdir(PATH(
"a/d/e"));
 
 1660         rmdir(PATH(
"a/b/c"));
 
 1664         cleanup_dir(testdir, testdir_files, 1);
 
 1674 static int test_mkfifo(
void)
 
 1679         start_test(
"mkfifo");
 
 1681         res = mkfifo(testfile, 0644);
 
 1686         res = check_type(testfile, S_IFIFO);
 
 1689         err += check_mode(testfile, 0644);
 
 1690         err += check_nlink(testfile, 1);
 
 1691         res = unlink(testfile);
 
 1696         res = check_nonexist(testfile);
 
 1707 static int test_mkdir(
void)
 
 1711         const char *dir_contents[] = {NULL};
 
 1713         start_test(
"mkdir");
 
 1715         res = mkdir(testdir, 0755);
 
 1720         res = check_type(testdir, S_IFDIR);
 
 1723         err += check_mode(testdir, 0755);
 
 1727         err += check_dir_contents(testdir, dir_contents);
 
 1728         res = rmdir(testdir);
 
 1733         res = check_nonexist(testdir);
 
 1743 static int test_socket(
void)
 
 1745         struct sockaddr_un su;
 
 1750         start_test(
"socket");
 
 1751         if (strlen(testsock) + 1 > 
sizeof(su.sun_path)) {
 
 1752                 fprintf(stderr, 
"Need to shorten mount point by %zu chars\n",
 
 1753                         strlen(testsock) + 1 - 
sizeof(su.sun_path));
 
 1757         fd = socket(AF_UNIX, SOCK_STREAM, 0);
 
 1762         su.sun_family = AF_UNIX;
 
 1763         strncpy(su.sun_path, testsock, 
sizeof(su.sun_path) - 1);
 
 1764         su.sun_path[
sizeof(su.sun_path) - 1] = 
'\0';
 
 1765         res = bind(fd, (
struct sockaddr*)&su, 
sizeof(su));
 
 1771         res = check_type(testsock, S_IFSOCK);
 
 1776         err += check_nlink(testsock, 1);
 
 1778         res = unlink(testsock);
 
 1783         res = check_nonexist(testsock);
 
 1793 #define test_create_ro_dir(flags)        \ 
 1794         do_test_create_ro_dir(flags, #flags) 
 1796 static int do_test_create_ro_dir(
int flags, 
const char *flags_str)
 
 1802         start_test(
"open(%s) in read-only directory", flags_str);
 
 1804         res = mkdir(testdir, 0555);
 
 1809         fd = open(subfile, flags, 0644);
 
 1813                 ERROR(
"open should have failed");
 
 1816                 res = check_nonexist(subfile);
 
 1821         res = rmdir(testdir);
 
 1826         res = check_nonexist(testdir);
 
 1836 int main(
int argc, 
char *argv[])
 
 1838         const char *basepath;
 
 1839         const char *realpath;
 
 1845         if (argc < 2 || argc > 4) {
 
 1846                 fprintf(stderr, 
"usage: %s testdir [:realdir] [[-]test#]\n", argv[0]);
 
 1850         realpath = basepath;
 
 1851         for (a = 2; a < argc; a++) {
 
 1853                 char *arg = argv[a];
 
 1854                 if (arg[0] == 
':') {
 
 1857                         if (arg[0] == 
'-') {
 
 1859                                 skip_test = strtoul(arg, &endptr, 10);
 
 1861                                 select_test = strtoul(arg, &endptr, 10);
 
 1863                         if (arg[0] == 
'\0' || *endptr != 
'\0') {
 
 1864                                 fprintf(stderr, 
"invalid number: '%s'\n", arg);
 
 1869         assert(strlen(basepath) < 512);
 
 1870         assert(strlen(realpath) < 512);
 
 1871         if (basepath[0] != 
'/') {
 
 1872                 fprintf(stderr, 
"testdir must be an absolute path\n");
 
 1876         sprintf(testfile, 
"%s/testfile", basepath);
 
 1877         sprintf(testfile2, 
"%s/testfile2", basepath);
 
 1878         sprintf(testdir, 
"%s/testdir", basepath);
 
 1879         sprintf(testdir2, 
"%s/testdir2", basepath);
 
 1880         sprintf(subfile, 
"%s/subfile", testdir2);
 
 1881         sprintf(testsock, 
"%s/testsock", basepath);
 
 1883         sprintf(testfile_r, 
"%s/testfile", realpath);
 
 1884         sprintf(testfile2_r, 
"%s/testfile2", realpath);
 
 1885         sprintf(testdir_r, 
"%s/testdir", realpath);
 
 1886         sprintf(testdir2_r, 
"%s/testdir2", realpath);
 
 1887         sprintf(subfile_r, 
"%s/subfile", testdir2_r);
 
 1889         is_root = (geteuid() == 0);
 
 1891         err += test_create();
 
 1892         err += test_create_unlink();
 
 1893         err += test_symlink();
 
 1895         err += test_link2();
 
 1897         err += test_mknod();
 
 1898         err += test_mkfifo();
 
 1900         err += test_mkdir();
 
 1901         err += test_rename_file();
 
 1902         err += test_rename_dir();
 
 1903         err += test_rename_dir_loop();
 
 1904         err += test_seekdir();
 
 1905         err += test_socket();
 
 1906         err += test_utime();
 
 1907         err += test_truncate(0);
 
 1908         err += test_truncate(testdatalen / 2);
 
 1909         err += test_truncate(testdatalen);
 
 1910         err += test_truncate(testdatalen + 100);
 
 1911         err += test_ftruncate(0, 0600);
 
 1912         err += test_ftruncate(testdatalen / 2, 0600);
 
 1913         err += test_ftruncate(testdatalen, 0600);
 
 1914         err += test_ftruncate(testdatalen + 100, 0600);
 
 1915         err += test_ftruncate(0, 0400);
 
 1916         err += test_ftruncate(0, 0200);
 
 1917         err += test_ftruncate(0, 0000);
 
 1918         err += test_open(0, O_RDONLY, 0);
 
 1919         err += test_open(1, O_RDONLY, 0);
 
 1920         err += test_open(1, O_RDWR, 0);
 
 1921         err += test_open(1, O_WRONLY, 0);
 
 1922         err += test_open(0, O_RDWR | O_CREAT, 0600);
 
 1923         err += test_open(1, O_RDWR | O_CREAT, 0600);
 
 1924         err += test_open(0, O_RDWR | O_CREAT | O_TRUNC, 0600);
 
 1925         err += test_open(1, O_RDWR | O_CREAT | O_TRUNC, 0600);
 
 1926         err += test_open(0, O_RDONLY | O_CREAT, 0600);
 
 1927         err += test_open(0, O_RDONLY | O_CREAT, 0400);
 
 1928         err += test_open(0, O_RDONLY | O_CREAT, 0200);
 
 1929         err += test_open(0, O_RDONLY | O_CREAT, 0000);
 
 1930         err += test_open(0, O_WRONLY | O_CREAT, 0600);
 
 1931         err += test_open(0, O_WRONLY | O_CREAT, 0400);
 
 1932         err += test_open(0, O_WRONLY | O_CREAT, 0200);
 
 1933         err += test_open(0, O_WRONLY | O_CREAT, 0000);
 
 1934         err += test_open(0, O_RDWR | O_CREAT, 0400);
 
 1935         err += test_open(0, O_RDWR | O_CREAT, 0200);
 
 1936         err += test_open(0, O_RDWR | O_CREAT, 0000);
 
 1937         err += test_open(0, O_RDWR | O_CREAT | O_EXCL, 0600);
 
 1938         err += test_open(1, O_RDWR | O_CREAT | O_EXCL, 0600);
 
 1939         err += test_open(0, O_RDWR | O_CREAT | O_EXCL, 0000);
 
 1940         err += test_open(1, O_RDWR | O_CREAT | O_EXCL, 0000);
 
 1941         err += test_open_acc(O_RDONLY, 0600, 0);
 
 1942         err += test_open_acc(O_WRONLY, 0600, 0);
 
 1943         err += test_open_acc(O_RDWR,   0600, 0);
 
 1944         err += test_open_acc(O_RDONLY, 0400, 0);
 
 1945         err += test_open_acc(O_WRONLY, 0200, 0);
 
 1947                 err += test_open_acc(O_RDONLY | O_TRUNC, 0400, EACCES);
 
 1948                 err += test_open_acc(O_WRONLY, 0400, EACCES);
 
 1949                 err += test_open_acc(O_RDWR,   0400, EACCES);
 
 1950                 err += test_open_acc(O_RDONLY, 0200, EACCES);
 
 1951                 err += test_open_acc(O_RDWR,   0200, EACCES);
 
 1952                 err += test_open_acc(O_RDONLY, 0000, EACCES);
 
 1953                 err += test_open_acc(O_WRONLY, 0000, EACCES);
 
 1954                 err += test_open_acc(O_RDWR,   0000, EACCES);
 
 1956         err += test_create_ro_dir(O_CREAT);
 
 1957         err += test_create_ro_dir(O_CREAT | O_EXCL);
 
 1958         err += test_create_ro_dir(O_CREAT | O_WRONLY);
 
 1959         err += test_create_ro_dir(O_CREAT | O_TRUNC);
 
 1960         err += test_copy_file_range();
 
 1969                 fprintf(stderr, 
"%i tests failed\n", -err);