This almost builds completely cleanly on VS9 and MinGW; a little more fidgeting is still needed.
SVN-Revision: 1279
#if !defined(__GNUC__)
#include <crtdbg.h>
#endif
+#include <io.h>
#include <windows.h>
#include <winbase.h>
+#ifndef F_OK
+#define F_OK (0)
+#endif
+#ifndef S_ISDIR
+#define S_ISDIR(m) ((m) & _S_IFDIR)
+#endif
+#ifndef S_ISREG
+#define S_ISREG(m) ((m) & _S_IFREG)
+#endif
+#define access _access
+#ifndef fileno
+#define fileno _fileno
+#endif
+//#define fstat _fstat64
+#define getcwd _getcwd
+#define lstat stat
+//#define lstat _stat64
+//#define stat _stat64
+#define rmdir _rmdir
+#define strdup _strdup
+#define umask _umask
#endif
/*
return (value);
}
+int
+test_assert_chdir(const char *file, int line, const char *pathname)
+{
+ count_assertion(file, line);
+ if (chdir(pathname) == 0)
+ return (1);
+ ++failures;
+ if (!verbose && previous_failures(file, line, 1))
+ return (0);
+ fprintf(stderr, "%s:%d: chdir(\"%s\") failed\n",
+ file, line, pathname);
+ return (0);
+
+}
+
/* assertEqualInt() displays the values of the two integers. */
int
test_assert_equal_int(const char *file, int line,
- int v1, const char *e1, int v2, const char *e2, void *extra)
+ long long v1, const char *e1, long long v2, const char *e2, void *extra)
{
count_assertion(file, line);
if (v1 == v2) {
return (0);
fprintf(stderr, "%s:%d: Assertion failed: Ints not equal\n",
file, line);
- fprintf(stderr, " %s=%d\n", e1, v1);
- fprintf(stderr, " %s=%d\n", e2, v2);
+ fprintf(stderr, " %s=%lld\n", e1, v1);
+ fprintf(stderr, " %s=%lld\n", e2, v2);
report_failure(extra);
return (0);
}
vsprintf(f, fpattern, ap);
va_end(ap);
+#if defined(_WIN32) && !defined(__CYGWIN__)
+ if (!_access(f, 0))
+ return (1);
+#else
if (!access(f, F_OK))
return (1);
+#endif
if (!previous_failures(test_filename, test_line, 1)) {
fprintf(stderr, "%s:%d: File doesn't exist\n",
test_filename, test_line);
vsprintf(f, fpattern, ap);
va_end(ap);
+#if defined(_WIN32) && !defined(__CYGWIN__)
+ if (_access(f, 0))
+ return (1);
+#else
if (access(f, F_OK))
return (1);
+#endif
if (!previous_failures(test_filename, test_line, 1)) {
fprintf(stderr, "%s:%d: File exists and shouldn't\n",
test_filename, test_line);
/* assertTextFileContents() asserts the contents of a text file. */
int
-test_assert_text_file_contents(const char *buff, const char *f)
+test_assert_text_file_contents(const char *buff, const char *fn)
{
char *contents;
const char *btxt, *ftxt;
- int fd;
+ FILE *f;
int n, s;
- fd = open(f, O_RDONLY);
+ f = fopen(fn, "r");
s = strlen(buff);
contents = malloc(s * 2 + 128);
- n = read(fd, contents, s * 2 + 128 -1);
+ n = fread(contents, 1, s * 2 + 128 - 1, f);
if (n >= 0)
contents[n] = '\0';
- close(fd);
+ fclose(f);
/* Compare texts. */
btxt = buff;
ftxt = (const char *)contents;
if (!previous_failures(test_filename, test_line, 1)) {
fprintf(stderr, "%s:%d: File contents don't match\n",
test_filename, test_line);
- fprintf(stderr, " file=\"%s\"\n", f);
+ fprintf(stderr, " file=\"%s\"\n", fn);
if (n > 0)
hexdump(contents, buff, n, 0);
else {
return (0);
}
+int
+test_assert_file_hardlinks(const char *file, int line,
+ const char *path1, const char *path2)
+{
+ struct stat st1, st2;
+ int r;
+
+ r = lstat(path1, &st1);
+ if (r != 0) {
+ if (!previous_failures(file, line, 1))
+ fprintf(stderr, "%s:%d: File ``%s'' should exist\n",
+ file, line, path1);
+ return (0);
+ }
+ r = lstat(path2, &st2);
+ if (r != 0) {
+ if (!previous_failures(file, line, 1))
+ fprintf(stderr, "%s:%d: File ``%s'' should exist\n",
+ file, line, path2);
+ return (0);
+ }
+ if (st1.st_ino != st2.st_ino || st1.st_dev != st2.st_dev) {
+ if (!previous_failures(file, line, 1)) {
+ fprintf(stderr,
+ "%s:%d: Files ``%s'' and ``%s'' are not hardlinked\n",
+ file, line, path1, path2);
+ report_failure(NULL);
+ }
+ return (0);
+ }
+ return (1);
+}
+
+int
+test_assert_file_nlinks(const char *file, int line, const char *pathname, int nlinks)
+{
+ struct stat st;
+ int r;
+
+ r = lstat(pathname, &st);
+ if (r == 0 && st.st_nlink == nlinks)
+ return (1);
+ if (!previous_failures(file, line, 1)) {
+ fprintf(stderr, "%s:%d: File ``%s'' has %d links, expected %d\n",
+ file, line, pathname, st.st_nlink, nlinks);
+ report_failure(NULL);
+ }
+ return (0);
+}
+
+int
+test_assert_file_size(const char *file, int line, const char *pathname, long size)
+{
+ struct stat st;
+ int r;
+
+ r = lstat(pathname, &st);
+ if (r == 0 && st.st_size == size)
+ return (1);
+ if (!previous_failures(file, line, 1)) {
+ fprintf(stderr, "%s:%d: File ``%s'' has size %ld, expected %ld\n",
+ file, line, pathname, st.st_size, size);
+ report_failure(NULL);
+ }
+ return (0);
+}
+
+int
+test_assert_is_dir(const char *file, int line, const char *pathname, int mode)
+{
+ struct stat st;
+ int r;
+
+ r = lstat(pathname, &st);
+ if (r == 0 && S_ISDIR(st.st_mode))
+ return (1);
+ if (!previous_failures(test_filename, test_line, 1)) {
+ fprintf(stderr, "%s:%d: Dir ``%s'' doesn't exist\n",
+ test_filename, test_line, pathname);
+ report_failure(NULL);
+ }
+ return (0);
+}
+
+int
+test_assert_is_reg(const char *file, int line, const char *pathname, int mode)
+{
+ struct stat st;
+ int r;
+
+ r = lstat(pathname, &st);
+ if (r == 0 && S_ISREG(st.st_mode))
+ return (1);
+ if (!previous_failures(test_filename, test_line, 1)) {
+ fprintf(stderr, "%s:%d: File ``%s'' doesn't exist\n",
+ test_filename, test_line, pathname);
+ report_failure(NULL);
+ }
+ return (0);
+}
+
int
test_assert_make_dir(const char *file, int line, const char *dirname, int mode)
{
count_assertion(file, line);
#if defined(_WIN32) && !defined(__CYGWIN__)
- r = mkdir(dirname);
+ r = _mkdir(dirname);
#else
r = mkdir(dirname, mode);
#endif
return(0);
}
+int
+test_assert_make_hardlink(const char *file, int line,
+ const char *newpath, const char *linkto)
+{
+ int succeeded;
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+ succeeded = CreateHardLink(newpath, linkto, NULL);
+#else
+ succeeded = !link(linkto, newpath);
+#endif
+ if (succeeded) {
+ msg[0] = '\0';
+ return (1);
+ }
+ failures++;
+ if (verbose || !previous_failures(file, line, 1)) {
+ fprintf(stderr, "%s:%d: Could not create new hardlink\n",
+ file, line);
+ fprintf(stderr, " New link: %s\n", newpath);
+ fprintf(stderr, " Old name: %s\n", linkto);
+ }
+ return(0);
+}
+
+
+int
+test_assert_make_symlink(const char *file, int line,
+ const char *newpath, const char *linkto)
+{
+ int succeeded;
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+ int targetIsDir = 0; /* TODO: Fix this. */
+ succeeded = CreateSymbolicLink(newpath, linkto, targetIsDir);
+#else
+ succeeded = !symlink(linkto, newpath);
+#endif
+ if (succeeded) {
+ msg[0] = '\0';
+ return (1);
+ }
+ failures++;
+ if (verbose || !previous_failures(file, line, 1)) {
+ fprintf(stderr, "%s:%d: Could not create new symlink\n",
+ file, line);
+ fprintf(stderr, " New link: %s\n", newpath);
+ fprintf(stderr, " Old name: %s\n", linkto);
+ }
+ return(0);
+}
+
+int
+test_assert_umask(const char *file, int line, int mask)
+{
+ umask(mask);
+ return (1);
+}
+
/*
* Call standard system() call, but build up the command line using
* sprintf() conventions.
fclose(f);
return (NULL);
}
- p = malloc(st.st_size + 1);
+ p = malloc((size_t)st.st_size + 1);
if (p == NULL) {
fprintf(stderr, "Can't allocate %ld bytes of memory to read file %s\n", (long int)st.st_size, filename);
fclose(f);
return (NULL);
}
- bytes_read = fread(p, 1, st.st_size, f);
+ bytes_read = fread(p, 1, (size_t)st.st_size, f);
if (bytes_read < st.st_size) {
fprintf(stderr, "Can't read file %s\n", filename);
fclose(f);
static int test_run(int i, const char *tmpdir)
{
int failures_before = failures;
+ int oldumask;
if (!quiet_flag) {
printf("%d: %s\n", i, tests[i].name);
* Always explicitly chdir() in case the last test moved us to
* a strange place.
*/
- if (chdir(tmpdir)) {
+ if (!assertChdir(tmpdir)) {
fprintf(stderr,
"ERROR: Couldn't chdir to temp dir %s\n",
tmpdir);
exit(1);
}
/* Chdir() to that work directory. */
- if (chdir(tests[i].name)) {
+ if (!assertChdir(tests[i].name)) {
fprintf(stderr,
"ERROR: Couldn't chdir to temp dir ``%s''\n",
tests[i].name);
}
/* Explicitly reset the locale before each test. */
setlocale(LC_ALL, "C");
+ /* Record the umask before we run the test. */
+ umask(oldumask = umask(0));
/* Run the actual test. */
(*tests[i].func)();
+ /* Restore umask */
+ umask(oldumask);
/* Summarize the results of this test. */
summarize();
/* If there were no failures, we can remove the work dir. */
if (failures == failures_before) {
- if (!keep_temp_files && chdir(tmpdir) == 0) {
+ if (!keep_temp_files && assertChdir(tmpdir)) {
#if defined(_WIN32) && !defined(__CYGWIN__)
systemf("rmdir /S /Q %s", tests[i].name);
#else
/* If the final tmpdir is empty, we can remove it. */
/* This should be the usual case when all tests succeed. */
- chdir("..");
+ assertChdir("..");
rmdir(tmpdir);
return (tests_failed);
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <sys/types.h> /* Windows requires this before sys/stat.h */
#include <sys/stat.h>
#if !defined(_WIN32) || defined(__CYGWIN__)
#include <unistd.h>
/* An implementation of the standard assert() macro */
#define assert(e) test_assert(__FILE__, __LINE__, (e), #e, NULL)
+#define assertChdir(path) \
+ test_assert_chdir(__FILE__, __LINE__, path)
/* Assert two integers are the same. Reports value of each one if not. */
#define assertEqualInt(v1,v2) \
test_assert_equal_int(__FILE__, __LINE__, (v1), #v1, (v2), #v2, NULL)
/* Assert that file contents match a string; supports printf-style arguments. */
#define assertFileContents \
test_setup(__FILE__, __LINE__);test_assert_file_contents
+#define assertFileHardlinks(path1, path2) \
+ test_assert_file_hardlinks(__FILE__, __LINE__, path1, path2)
+#define assertFileNLinks(pathname, nlinks) \
+ test_assert_file_size(__FILE__, __LINE__, pathname, nlinks)
+#define assertFileSize(pathname, size) \
+ test_assert_file_size(__FILE__, __LINE__, pathname, size)
#define assertTextFileContents \
test_setup(__FILE__, __LINE__);test_assert_text_file_contents
+#define assertIsDir(pathname, mode) \
+ test_assert_is_dir(__FILE__, __LINE__, pathname, mode)
+#define assertIsReg(pathname, mode) \
+ test_assert_is_reg(__FILE__, __LINE__, pathname, mode)
/* Create a directory, report error if it fails. */
#define assertMakeDir(dirname, mode) \
test_assert_make_dir(__FILE__, __LINE__, dirname, mode)
+#define assertMakeHardlink(newfile, oldfile) \
+ test_assert_make_hardlink(__FILE__, __LINE__, newfile, oldfile)
+#define assertMakeSymlink(newfile, linkto) \
+ test_assert_make_symlink(__FILE__, __LINE__, newfile, linkto)
+#define assertUmask(mask) \
+ test_assert_umask(__FILE__, __LINE__, mask)
/*
* This would be simple with C99 variadic macros, but I don't want to
void test_setup(const char *, int);
void test_skipping(const char *fmt, ...);
int test_assert(const char *, int, int, const char *, void *);
+int test_assert_chdir(const char *, int, const char *);
int test_assert_empty_file(const char *, ...);
int test_assert_non_empty_file(const char *, ...);
int test_assert_equal_file(const char *, const char *, ...);
-int test_assert_equal_int(const char *, int, int, const char *, int, const char *, void *);
+int test_assert_equal_int(const char *, int, long long, const char *, long long, const char *, void *);
int test_assert_equal_string(const char *, int, const char *v1, const char *, const char *v2, const char *, void *);
int test_assert_equal_wstring(const char *, int, const wchar_t *v1, const char *, const wchar_t *v2, const char *, void *);
int test_assert_equal_mem(const char *, int, const void *, const char *, const void *, const char *, size_t, const char *, void *);
int test_assert_file_contents(const void *, int, const char *, ...);
int test_assert_text_file_contents(const char *buff, const char *f);
int test_assert_file_exists(const char *, ...);
+int test_assert_file_hardlinks(const char *, int, const char *, const char *);
int test_assert_file_not_exists(const char *, ...);
+int test_assert_file_nlinks(const char *, int, const char *, int);
+int test_assert_file_size(const char *, int, const char *, long);
+int test_assert_is_dir(const char *, int, const char *, int);
+int test_assert_is_reg(const char *, int, const char *, int);
int test_assert_make_dir(const char *, int, const char *, int);
+int test_assert_make_hardlink(const char *, int, const char *newpath, const char *);
+int test_assert_make_symlink(const char *, int, const char *newpath, const char *);
+int test_assert_umask(const char *, int, int);
/* Like sprintf, then system() */
int systemf(const char * fmt, ...);
basic_tar(const char *target, const char *pack_options,
const char *unpack_options, const char *flist)
{
- struct stat st, st2;
int r;
- assertEqualInt(0, mkdir(target, 0775));
+ assertMakeDir(target, 0775);
/* Use the tar program to create an archive. */
r = systemf("%s cf - %s %s >%s/archive 2>%s/pack.err", testprog, pack_options, flist, target, target);
failure("Error invoking %s cf -", testprog, pack_options);
assertEqualInt(r, 0);
- chdir(target);
+ assertChdir(target);
/* Verify that nothing went to stderr. */
assertEmptyFile("pack.err");
*/
/* Regular file with 2 links. */
- r = lstat("file", &st);
- failure("Failed to stat file %s/file, errno=%d", target, errno);
- assertEqualInt(r, 0);
- if (r == 0) {
- assert(S_ISREG(st.st_mode));
- assertEqualInt(10, st.st_size);
- failure("file %s/file", target);
- assertEqualInt(2, st.st_nlink);
- }
+ assertIsReg("file", -1);
+ assertFileSize("file", 10);
+ assertFileNLinks("file", 2);
/* Another name for the same file. */
- r = lstat("linkfile", &st2);
- failure("Failed to stat file %s/linkfile, errno=%d", target, errno);
- assertEqualInt(r, 0);
- if (r == 0) {
- assert(S_ISREG(st2.st_mode));
- assertEqualInt(10, st2.st_size);
- failure("file %s/linkfile", target);
- assertEqualInt(2, st2.st_nlink);
- /* Verify that the two are really hardlinked. */
- assertEqualInt(st.st_dev, st2.st_dev);
- failure("%s/linkfile and %s/file aren't really hardlinks", target, target);
- assertEqualInt(st.st_ino, st2.st_ino);
- }
+ assertIsReg("linkfile", -1);
+ assertFileSize("linkfile", 10);
+ assertFileNLinks("linkfile", 2);
+ assertFileHardlinks("file", "linkfile");
#if !defined(_WIN32) || defined(__CYGWIN__)
/* Symlink */
#endif
/* dir */
- r = lstat("dir", &st);
- if (r == 0) {
- assertEqualInt(r, 0);
- assert(S_ISDIR(st.st_mode));
-#if !defined(_WIN32) || defined(__CYGWIN__)
- assertEqualInt(0775, st.st_mode & 0777);
-#else
- assertEqualInt(0700, st.st_mode & 0700);
-#endif
- }
-
- chdir("..");
+ assertIsDir("dir", 0775);
+ assertChdir("..");
}
DEFINE_TEST(test_basic)
{
FILE *f;
- int oldumask;
const char *flist;
- oldumask = umask(0);
+ assertUmask(0);
/* File with 10 bytes content. */
f = fopen("file", "wb");
fclose(f);
/* hardlink to above file. */
- assertEqualInt(0, link("file", "linkfile"));
+ assertMakeHardlink("linkfile", "file");
/* Symlink to above file. */
- assertEqualInt(0, symlink("file", "symlink"));
+ assertMakeSymlink("symlink", "file");
/* Directory. */
- assertEqualInt(0, mkdir("dir", 0775));
+ assertMakeDir("dir", 0775);
flist = "file linkfile symlink dir";
/* Archive/dearchive with a variety of options. */
/* tar doesn't handle cpio symlinks correctly */
/* basic_tar("copy_odc", "--format=odc", ""); */
basic_tar("copy_ustar", "--format=ustar", "", flist);
-
- umask(oldumask);
}
FILE *f;
int LOOP_MAX;
- assertEqualInt(0, mkdir("original", 0775));
+ assertMakeDir("original", 0775);
chdir("original");
LOOP_MAX = compute_loop_max();
- assertEqualInt(0, mkdir("f", 0775));
- assertEqualInt(0, mkdir("l", 0775));
- assertEqualInt(0, mkdir("m", 0775));
- assertEqualInt(0, mkdir("s", 0775));
- assertEqualInt(0, mkdir("d", 0775));
+ assertMakeDir("f", 0775);
+ assertMakeDir("l", 0775);
+ assertMakeDir("m", 0775);
+ assertMakeDir("s", 0775);
+ assertMakeDir("d", 0775);
for (i = 0; i < LOOP_MAX; i++) {
buff[0] = 'f';
/* Create a link named "l/abcdef..." to the above. */
strcpy(buff2, buff);
buff2[0] = 'l';
- assertEqualInt(0, link(buff, buff2));
+ assertMakeHardlink(buff2, buff);
/* Create a link named "m/abcdef..." to the above. */
strcpy(buff2, buff);
buff2[0] = 'm';
- assertEqualInt(0, link(buff, buff2));
+ assertMakeHardlink(buff2, buff);
#if !defined(_WIN32) || defined(__CYGWIN__)
/* Create a symlink named "s/abcdef..." to the above. */
buff2[1] = '.';
buff2[2] = '/';
failure("buff=\"%s\" buff2=\"%s\"", buff, buff2);
- assertEqualInt(0, symlink(buff2, buff));
+ assertMakeSymlink(buff, buff2);
#else
skipping("create a symlink to the above");
#endif
/* Create a dir named "d/abcdef...". */
buff[0] = 'd';
failure("buff=\"%s\"", buff);
- assertEqualInt(0, mkdir(buff, 0775));
+ assertMakeDir(buff, 0775);
}
chdir("..");
static void
verify_tree(int limit)
{
- struct stat st, st2;
char filename[260];
char name1[260];
char name2[260];
char contents[260];
- int i, j, r, LOOP_MAX;
+ int i, j, LOOP_MAX;
FILE *f;
int len;
- const char *p, *dp;
- DIR *d;
- struct dirent *de;
LOOP_MAX = compute_loop_max();
contents[len] = '\0';
failure("Each test file contains its own name");
assertEqualString(name1, contents);
- /* stat() for dev/ino for next check */
- assertEqualInt(0, lstat(name1, &st));
}
}
strcat(name2, filename);
if (limit != LIMIT_USTAR || strlen(name2) <= 100) {
/* Verify hardlink "l/abcdef..." */
- assertEqualInt(0, (r = lstat(name2, &st2)));
- if (r == 0) {
- assertEqualInt(st2.st_dev, st.st_dev);
- assertEqualInt(st2.st_ino, st.st_ino);
- }
-
+ assertFileHardlinks(name1, name2);
/* Verify hardlink "m_abcdef..." */
name2[0] = 'm';
- assertEqualInt(0, (r = lstat(name2, &st2)));
- if (r == 0) {
- assertEqualInt(st2.st_dev, st.st_dev);
- assertEqualInt(st2.st_ino, st.st_ino);
- }
+ assertFileHardlinks(name1, name2);
}
#if !defined(_WIN32) || defined(__CYGWIN__)
strcpy(name1, "d/");
strcat(name1, filename);
if (limit != LIMIT_USTAR || strlen(filename) < 100) {
- /* This is a dir. */
- failure("Couldn't stat %s (length %d)",
- name1, strlen(filename));
- if (assertEqualInt(0, lstat(name1, &st2))) {
- if (assert(S_ISDIR(st2.st_mode))) {
- /* TODO: opendir/readdir this
- * directory and make sure
- * it's empty.
- */
- }
+ if (assertIsDir(name1, -1)) {
+ /* TODO: opendir/readdir this
+ * directory and make sure
+ * it's empty.
+ */
}
}
}
- /* Now make sure nothing is there that shouldn't be. */
- for (dp = "dflms"; *dp != '\0'; ++dp) {
- char dir[2];
- dir[0] = *dp; dir[1] = '\0';
- d = opendir(dir);
- failure("Unable to open dir '%s'", dir);
- if (!assert(d != NULL))
- continue;
- while ((de = readdir(d)) != NULL) {
- p = de->d_name;
- switch(dp[0]) {
- case 'l': case 'm':
- if (limit == LIMIT_USTAR) {
- failure("strlen(p) = %d", strlen(p));
- assert(strlen(p) <= 100);
- }
- case 'd':
- if (limit == LIMIT_USTAR) {
- failure("strlen(p)=%d", strlen(p));
- assert(strlen(p) < 100);
- }
- case 'f': case 's':
- if (limit == LIMIT_USTAR) {
- failure("strlen(p)=%d", strlen(p));
- assert(strlen(p) < 101);
- }
- /* Our files have very particular filename patterns. */
- if (p[0] != '.' || (p[1] != '.' && p[1] != '\0')) {
- for (i = 0; p[i] != '\0' && i < LOOP_MAX; i++) {
- failure("i=%d, p[i]='%c' 'a'+(i%%26)='%c'", i, p[i], 'a' + (i % 26));
- assertEqualInt(p[i], 'a' + (i % 26));
+#if !defined(_WIN32) || defined(__CYGWIN__)
+ {
+ char *dp;
+ /* Now make sure nothing is there that shouldn't be. */
+ for (dp = "dflms"; *dp != '\0'; ++dp) {
+ DIR *d;
+ char dir[2];
+ dir[0] = *dp; dir[1] = '\0';
+ d = opendir(dir);
+ failure("Unable to open dir '%s'", dir);
+ if (!assert(d != NULL))
+ continue;
+ while ((de = readdir(d)) != NULL) {
+ char *p = de->d_name;
+ switch(dp[0]) {
+ case 'l': case 'm':
+ if (limit == LIMIT_USTAR) {
+ failure("strlen(p) = %d", strlen(p));
+ assert(strlen(p) <= 100);
+ }
+ case 'd':
+ if (limit == LIMIT_USTAR) {
+ failure("strlen(p)=%d", strlen(p));
+ assert(strlen(p) < 100);
+ }
+ case 'f': case 's':
+ if (limit == LIMIT_USTAR) {
+ failure("strlen(p)=%d", strlen(p));
+ assert(strlen(p) < 101);
+ }
+ /* Our files have very particular filename patterns. */
+ if (p[0] != '.' || (p[1] != '.' && p[1] != '\0')) {
+ for (i = 0; p[i] != '\0' && i < LOOP_MAX; i++) {
+ failure("i=%d, p[i]='%c' 'a'+(i%%26)='%c'", i, p[i], 'a' + (i % 26));
+ assertEqualInt(p[i], 'a' + (i % 26));
+ }
+ assert(p[i] == '\0');
}
- assert(p[i] == '\0');
+ break;
+ case '.':
+ assert(p[1] == '\0' || (p[1] == '.' && p[2] == '\0'));
+ break;
+ default:
+ failure("File %s shouldn't be here", p);
+ assert(0);
}
- break;
- case '.':
- assert(p[1] == '\0' || (p[1] == '.' && p[2] == '\0'));
- break;
- default:
- failure("File %s shouldn't be here", p);
- assert(0);
}
+ closedir(d);
}
- closedir(d);
}
+#endif
}
static void
* directory, "original" This restriction derives from the
* extremely limited pathname lengths on those platforms.
*/
- assertEqualInt(0, mkdir("plain", 0775));
+ assertMakeDir("plain", 0775);
assertEqualInt(0, chdir("plain"));
/*
* directory, "original" This restriction derives from the
* extremely limited pathname lengths on those platforms.
*/
- assertEqualInt(0, mkdir(target, 0775));
+ assertMakeDir(target, 0775);
assertEqualInt(0, chdir(target));
/*
DEFINE_TEST(test_copy)
{
- int oldumask;
-
- oldumask = umask(0);
+ assertUmask(0);
create_tree(); /* Create sample files in "original" dir. */
/* Same, but constrain to ustar format. */
copy_ustar();
-
- umask(oldumask);
}
static int
touch(const char *fn)
{
- int fd = open(fn, O_RDWR | O_CREAT, 0644);
- failure("Couldn't create file '%s', fd=%d, errno=%d (%s)\n",
- fn, fd, errno, strerror(errno));
- if (!assert(fd > 0))
+ FILE *f = fopen(fn, "w");
+ failure("Couldn't create file '%s', errno=%d (%s)\n",
+ fn, errno, strerror(errno));
+ if (!assert(f != NULL))
return (0); /* Failure. */
- close(fd);
+ fclose(f);
return (1); /* Success */
}
struct stat st;
/* Create a simple dir heirarchy; bail if anything fails. */
- if (!assertEqualInt(0, mkdir("d1", 0755))) return;
- if (!assertEqualInt(0, mkdir("d1/d2", 0755))) return;
+ if (!assertMakeDir("d1", 0755)) return;
+ if (!assertMakeDir("d1/d2", 0755)) return;
if (!touch("d1/f1")) return;
if (!touch("d1/f2")) return;
if (!touch("d1/d2/f3")) return;
assertEmptyFile("test1.err");
/* Use -x -T to dearchive the files */
- if (!assertEqualInt(0, mkdir("test1", 0755))) return;
+ if (!assertMakeDir("test1", 0755)) return;
systemf("%s -x -f test1.tar -T filelist -C test1"
" > test1b.out 2> test1b.err", testprog);
assertEmptyFile("test1b.out");
assertEmptyFile("test2.err");
/* Use -x without -T to dearchive the files (ensure -r worked) */
- if (!assertEqualInt(0, mkdir("test3", 0755))) return;
+ if (!assertMakeDir("test3", 0755)) return;
systemf("%s -x -f test1.tar -C test3"
" > test3.out 2> test3.err", testprog);
assertEmptyFile("test3.out");
assertFileExists("test3/d1/d2/f5");
/* Use -x -T to dearchive the files (verify -x -T together) */
- if (!assertEqualInt(0, mkdir("test2", 0755))) return;
+ if (!assertMakeDir("test2", 0755)) return;
systemf("%s -x -f test1.tar -T filelist -C test2"
" > test2b.out 2> test2b.err", testprog);
assertEmptyFile("test2b.out");
assertFileExists("test2/d1/d2/f4");
assertFileNotExists("test2/d1/d2/f5");
- assertEqualInt(0, mkdir("test4", 0755));
- assertEqualInt(0, mkdir("test4_out", 0755));
- assertEqualInt(0, mkdir("test4_out2", 0755));
- assertEqualInt(0, mkdir("test4/d1", 0755));
+ assertMakeDir("test4", 0755);
+ assertMakeDir("test4_out", 0755);
+ assertMakeDir("test4_out2", 0755);
+ assertMakeDir("test4/d1", 0755);
assertEqualInt(1, touch("test4/d1/foo"));
/* Does bsdtar support -s option ? */
*/
/* Test 1: -q foo should only extract the first foo. */
- assertEqualInt(0, mkdir("test1", 0755));
- assertEqualInt(0, chdir("test1"));
+ assertMakeDir("test1", 0755);
+ assertChdir("test1");
r = systemf("%s -xf ../archive.tar -q foo >test.out 2>test.err",
testprog);
failure("Fatal error trying to use -q option");
assertFileContents("foo1", 4, "foo");
assertEmptyFile("test.out");
assertEmptyFile("test.err");
- assertEqualInt(0, chdir(".."));
+ assertChdir("..");
/* Test 2: -q foo bar should extract up to the first bar. */
- assertEqualInt(0, mkdir("test2", 0755));
- assertEqualInt(0, chdir("test2"));
+ assertMakeDir("test2", 0755);
+ assertChdir("test2");
assertEqualInt(0,
systemf("%s -xf ../archive.tar -q foo bar >test.out 2>test.err", testprog));
assertFileContents("foo2", 4, "foo");
assertFileContents("bar1", 4, "bar");
assertEmptyFile("test.out");
assertEmptyFile("test.err");
- assertEqualInt(0, chdir(".."));
+ assertChdir("..");
/* Test 3: Same as test 2, but use --fast-read spelling. */
- assertEqualInt(0, mkdir("test3", 0755));
- assertEqualInt(0, chdir("test3"));
+ assertMakeDir("test3", 0755);
+ assertChdir("test3");
assertEqualInt(0,
systemf("%s -xf ../archive.tar --fast-read foo bar >test.out 2>test.err", testprog));
assertFileContents("foo2", 4, "foo");
assertFileContents("bar1", 4, "bar");
assertEmptyFile("test.out");
assertEmptyFile("test.err");
- assertEqualInt(0, chdir(".."));
+ assertChdir("..");
/* Test 4: Without -q, should extract everything. */
- assertEqualInt(0, mkdir("test4", 0755));
- assertEqualInt(0, chdir("test4"));
+ assertMakeDir("test4", 0755);
+ assertChdir("test4");
assertEqualInt(0,
systemf("%s -xf ../archive.tar foo bar >test.out 2>test.err", testprog));
assertFileContents("foo3", 4, "foo");
assertFileContents("bar2", 4, "bar");
assertEmptyFile("test.out");
assertEmptyFile("test.err");
- assertEqualInt(0, chdir(".."));
+ assertChdir("..");
}
free(p1);
/* Unpack both items */
- assertEqualInt(0, mkdir("step3", 0775));
- assertEqualInt(0, chdir("step3"));
+ assertMakeDir("step3", 0775);
+ assertChdir("step3");
r = systemf("%s xf ../archive.tar", testprog);
failure("Error invoking %s xf archive.tar", testprog);
assertEqualInt(r, 0);
struct stat st;
/* Create a sample file heirarchy. */
- assertEqualInt(0, mkdir("in", 0755));
- assertEqualInt(0, mkdir("in/d1", 0755));
+ assertMakeDir("in", 0755);
+ assertMakeDir("in/d1", 0755);
assertEqualInt(0, mkfile("in/d1/foo", "foo"));
assertEqualInt(0, mkfile("in/d1/bar", "bar"));
/*
* Test 1: Filename substitution when creating archives.
*/
- assertEqualInt(0, mkdir("test1", 0755));
+ assertMakeDir("test1", 0755);
systemf("%s -cf - -s /foo/bar/ in/d1/foo | %s -xf - -C test1",
testprog, testprog);
assertFileContents("foo", 3, "test1/in/d1/bar");
/*
* Test 2: Basic substitution when extracting archive.
*/
- assertEqualInt(0, mkdir("test2", 0755));
+ assertMakeDir("test2", 0755);
systemf("%s -cf - in/d1/foo | %s -xf - -s /foo/bar/ -C test2",
testprog, testprog);
assertFileContents("foo", 3, "test2/in/d1/bar");
/*
* Test 4: Multiple substitutions when extracting archive.
*/
- assertEqualInt(0, mkdir("test4", 0755));
+ assertMakeDir("test4", 0755);
systemf("%s -cf - in/d1/foo in/d1/bar | %s -xf - -s /foo/bar/ -s }bar}baz} -C test4",
testprog, testprog);
assertFileContents("foo", 3, "test4/in/d1/bar");
/*
* Test 5: Name-switching substitutions when extracting archive.
*/
- assertEqualInt(0, mkdir("test5", 0755));
+ assertMakeDir("test5", 0755);
systemf("%s -cf - in/d1/foo in/d1/bar | %s -xf - -s /foo/bar/ -s }bar}foo} -C test5",
testprog, testprog);
assertFileContents("foo", 3, "test5/in/d1/bar");
DEFINE_TEST(test_patterns)
{
- int fd, r;
+ FILE *f;
+ int r;
const char *reffile2 = "test_patterns_2.tar";
const char *reffile3 = "test_patterns_3.tar";
const char *reffile4 = "test_patterns_4.tar";
*
* John Baldwin reported this problem in PR bin/121598
*/
- fd = open("foo", O_CREAT | O_WRONLY, 0644);
- assert(fd >= 0);
- close(fd);
+ f = fopen("foo", "w");
+ assert(f != NULL);
+ fclose(f);
r = systemf("%s cfv tar1.tgz foo > tar1a.out 2> tar1a.err", testprog);
assertEqualInt(r, 0);
r = systemf("%s xv --no-same-owner -f tar1.tgz foo bar > tar1b.out 2> tar1b.err", testprog);
assertEqualInt(r, 0);
assertEmptyFile("tar3d.out");
assertEmptyFile("tar3d.err");
- assertEqualInt(0, access("tmp/foo/baz/bar", F_OK));
+ assertFileExists("tmp/foo/baz/bar");
/*
* Test 4 archive has some entries starting with windows drive letters
* c:../..\file43
* \/?\UnC\../file54
*/
- assertEqualInt(-1, access(filex, F_OK));
+ assertFileNotExists(filex);
filex = file_c;
xsize = sizeof(file_c);
filex[xsize-3] = '0' + r / 10;
filex[xsize-2] = '0' + r % 10;
- assertEqualInt(-1, access(filex, F_OK));
+ assertFileNotExists(filex);
break;
default:
/* Extracted patterns. */
- assertEqualInt(0, access(filex, F_OK));
+ assertFileExists(filex);
break;
}
}
FILE *filelist;
char *p;
size_t s;
- int oldumask;
int r;
- oldumask = umask(0);
+ assertUmask(0);
/*
* Create a couple of files on disk.
fclose(f);
fprintf(filelist, "f\n");
/* Link to above file. */
- assertEqualInt(0, link("f", "l"));
+ assertMakeHardlink("l", "f");
fprintf(filelist, "l\n");
fclose(filelist);
assertEqualInt(r, 0);
assertEmptyFile("xvf-.out");
/* TODO: Verify xvf-.err */
-
- umask(oldumask);
}
static int
touch(const char *fn)
{
- int fd = open(fn, O_RDWR | O_CREAT, 0644);
- failure("Couldn't create file '%s', fd=%d, errno=%d (%s)\n",
- fn, fd, errno, strerror(errno));
- if (!assert(fd > 0))
+ FILE *f = fopen(fn, "w");
+ failure("Couldn't create file '%s', errno=%d (%s)\n",
+ fn, errno, strerror(errno));
+ if (!assert(f != NULL))
return (0); /* Failure. */
- close(fd);
+ fclose(f);
return (1); /* Success */
}
DEFINE_TEST(test_strip_components)
{
- struct stat st;
-
- assertEqualInt(0, mkdir("d0", 0755));
- assertEqualInt(0, chdir("d0"));
- assertEqualInt(0, mkdir("d1", 0755));
- assertEqualInt(0, mkdir("d1/d2", 0755));
- assertEqualInt(0, mkdir("d1/d2/d3", 0755));
+ assertMakeDir("d0", 0755);
+ assertChdir("d0");
+ assertMakeDir("d1", 0755);
+ assertMakeDir("d1/d2", 0755);
+ assertMakeDir("d1/d2/d3", 0755);
assertEqualInt(1, touch("d1/d2/f1"));
- assertEqualInt(0, link("d1/d2/f1", "l1"));
- assertEqualInt(0, link("d1/d2/f1", "d1/l2"));
- assertEqualInt(0, symlink("d1/d2/f1", "s1"));
- assertEqualInt(0, symlink("d2/f1", "d1/s2"));
- assertEqualInt(0, chdir(".."));
+ assertMakeHardlink("l1", "d1/d2/f1");
+ assertMakeHardlink("d1/l2", "d1/d2/f1");
+ assertMakeSymlink("s1", "d1/d2/f1");
+ assertMakeSymlink("d1/s2", "d2/f1");
+ assertChdir("..");
assertEqualInt(0, systemf("%s -cf test.tar d0", testprog));
- assertEqualInt(0, mkdir("target", 0755));
+ assertMakeDir("target", 0755);
assertEqualInt(0, systemf("%s -x -C target --strip-components 2 "
"-f test.tar", testprog));
failure("d0/ is too short and should not get restored");
- assertEqualInt(-1, lstat("target/d0", &st));
+ assertFileNotExists("target/d0");
failure("d0/d1/ is too short and should not get restored");
- assertEqualInt(-1, lstat("target/d1", &st));
+ assertFileNotExists("target/d1");
failure("d0/d1/s2 is a symlink to something that won't be extracted");
#if !defined(_WIN32) || defined(__CYGWIN__)
- assertEqualInt(-1, stat("target/s2", &st));
+ assertFileNotExists("target/s2");
#else
skipping("symlink with stat()");
#endif
- assertEqualInt(0, lstat("target/s2", &st));
+ assertFileExists("target/s2", -1);
failure("d0/d1/d2 should be extracted");
- assertEqualInt(0, lstat("target/d2", &st));
+ assertIsDir("target/d2", -1);
/*
* This next is a complicated case. d0/l1, d0/d1/l2, and
* parallel tests for cpio and newc formats.
*/
failure("d0/l1 is too short and should not get restored");
- assertEqualInt(-1, lstat("target/l1", &st));
+ assertFileNotExists("target/l1");
failure("d0/d1/l2 is a hardlink to file whose name was too short");
- assertEqualInt(-1, lstat("target/l2", &st));
+ assertFileNotExists("target/l2");
failure("d0/d1/d2/f1 is a hardlink to file whose name was too short");
- assertEqualInt(-1, lstat("target/d2/f1", &st));
+ assertFileNotExists("target/d2/f1");
}
DEFINE_TEST(test_symlink_dir)
{
- struct stat st;
#if !defined(_WIN32) || defined(__CYGWIN__)
+ struct stat st;
struct stat st2;
#endif
- int oldumask;
+ assertUmask(0);
- oldumask = umask(0);
-
- assertEqualInt(0, mkdir("source", 0755));
+ assertMakeDir("source", 0755);
assertEqualInt(0, mkfile("source/file", 0755, "a", 1));
assertEqualInt(0, mkfile("source/file2", 0755, "ab", 2));
- assertEqualInt(0, mkdir("source/dir", 0755));
- assertEqualInt(0, mkdir("source/dir/d", 0755));
+ assertMakeDir("source/dir", 0755);
+ assertMakeDir("source/dir/d", 0755);
assertEqualInt(0, mkfile("source/dir/f", 0755, "abc", 3));
- assertEqualInt(0, mkdir("source/dir2", 0755));
- assertEqualInt(0, mkdir("source/dir2/d2", 0755));
+ assertMakeDir("source/dir2", 0755);
+ assertMakeDir("source/dir2/d2", 0755);
assertEqualInt(0, mkfile("source/dir2/f2", 0755, "abcd", 4));
- assertEqualInt(0, mkdir("source/dir3", 0755));
- assertEqualInt(0, mkdir("source/dir3/d3", 0755));
+ assertMakeDir("source/dir3", 0755);
+ assertMakeDir("source/dir3/d3", 0755);
assertEqualInt(0, mkfile("source/dir3/f3", 0755, "abcde", 5));
assertEqualInt(0,
/*
* Extract with -x and without -P.
*/
- assertEqualInt(0, mkdir("dest1", 0755));
+ assertMakeDir("dest1", 0755);
/* "dir" is a symlink to an existing "real_dir" */
- assertEqualInt(0, mkdir("dest1/real_dir", 0755));
+ assertMakeDir("dest1/real_dir", 0755);
#if !defined(_WIN32) || defined(__CYGWIN__)
assertEqualInt(0, symlink("real_dir", "dest1/dir"));
/* "dir2" is a symlink to a non-existing "real_dir2" */
#endif
/* "dir3" is a symlink to an existing "non_dir3" */
assertEqualInt(0, mkfile("dest1/non_dir3", 0755, "abcdef", 6));
- assertEqualInt(0, symlink("non_dir3", "dest1/dir3"));
+ assertMakeSymlink("dest1/dir3", "non_dir3");
/* "file" is a symlink to existing "real_file" */
assertEqualInt(0, mkfile("dest1/real_file", 0755, "abcdefg", 7));
- assertEqualInt(0, symlink("real_file", "dest1/file"));
+ assertMakeSymlink("dest1/file", "real_file");
#if !defined(_WIN32) || defined(__CYGWIN__)
/* "file2" is a symlink to non-existing "real_file2" */
- assertEqualInt(0, symlink("real_file2", "dest1/file2"));
+ assertMakeSymlink("dest1/file2", "real_file2");
#else
skipping("symlink does not work on this platform");
#endif
assertEqualInt(0, systemf("%s -xf test.tar -C dest1", testprog));
- /* dest1/dir symlink should be removed */
- assertEqualInt(0, lstat("dest1/dir", &st));
+ /* dest1/dir symlink should be replaced */
failure("symlink to dir was followed when it shouldn't be");
- assert(S_ISDIR(st.st_mode));
- /* dest1/dir2 symlink should be removed */
- assertEqualInt(0, lstat("dest1/dir2", &st));
+ assertIsDir("dest1/dir", -1);
+ /* dest1/dir2 symlink should be replaced */
failure("Broken symlink wasn't replaced with dir");
- assert(S_ISDIR(st.st_mode));
- /* dest1/dir3 symlink should be removed */
- assertEqualInt(0, lstat("dest1/dir3", &st));
+ assertIsDir("dest1/dir2", -1);
+ /* dest1/dir3 symlink should be replaced */
failure("Symlink to non-dir wasn't replaced with dir");
- assert(S_ISDIR(st.st_mode));
- /* dest1/file symlink should be removed */
- assertEqualInt(0, lstat("dest1/file", &st));
- failure("Symlink to existing file should be removed");
- assert(S_ISREG(st.st_mode));
- /* dest1/file2 symlink should be removed */
- assertEqualInt(0, lstat("dest1/file2", &st));
- failure("Symlink to non-existing file should be removed");
- assert(S_ISREG(st.st_mode));
+ assertIsDir("dest1/dir3", -1);
+ /* dest1/file symlink should be replaced */
+ failure("Symlink to existing file should be replaced");
+ assertIsReg("dest1/file", -1);
+ /* dest1/file2 symlink should be replaced */
+ failure("Symlink to non-existing file should be replaced");
+ assertIsReg("dest1/file2", -1);
/*
* Extract with both -x and -P
*/
- assertEqualInt(0, mkdir("dest2", 0755));
+ assertMakeDir("dest2", 0755);
/* "dir" is a symlink to existing "real_dir" */
- assertEqualInt(0, mkdir("dest2/real_dir", 0755));
+ assertMakeDir("dest2/real_dir", 0755);
#if !defined(_WIN32) || defined(__CYGWIN__)
- assertEqualInt(0, symlink("real_dir", "dest2/dir"));
+ assertMakeSymlink("dest2/dir", "real_dir");
/* "dir2" is a symlink to a non-existing "real_dir2" */
- assertEqualInt(0, symlink("real_dir2", "dest2/dir2"));
+ assertMakeSymlink("dest2/dir2", "real_dir2");
#else
skipping("symlink does not work on this platform");
#endif
/* "dir3" is a symlink to an existing "non_dir3" */
assertEqualInt(0, mkfile("dest2/non_dir3", 0755, "abcdefgh", 8));
- assertEqualInt(0, symlink("non_dir3", "dest2/dir3"));
+ assertMakeSymlink("dest2/dir3", "non_dir3");
/* "file" is a symlink to existing "real_file" */
assertEqualInt(0, mkfile("dest2/real_file", 0755, "abcdefghi", 9));
- assertEqualInt(0, symlink("real_file", "dest2/file"));
+ assertMakeSymlink("dest2/file", "real_file");
#if !defined(_WIN32) || defined(__CYGWIN__)
/* "file2" is a symlink to non-existing "real_file2" */
- assertEqualInt(0, symlink("real_file2", "dest2/file2"));
+ assertMakeSymlink("dest2/file2", "real_file2");
#else
skipping("symlink does not work on this platform");
#endif
assertEqualInt(0, systemf("%s -xPf test.tar -C dest2", testprog));
/* dest2/dir symlink should be followed */
+#if !defined(_WIN32) || defined(__CYGWIN__)
assertEqualInt(0, lstat("dest2/dir", &st));
failure("tar -xP removed symlink instead of following it");
-#if !defined(_WIN32) || defined(__CYGWIN__)
if (assert(S_ISLNK(st.st_mode))) {
/* Only verify what the symlink points to if it
* really is a symlink. */
skipping("symlink does not work on this platform");
#endif
/* Contents of 'dir' should be restored */
- assertEqualInt(0, lstat("dest2/dir/d", &st));
- assert(S_ISDIR(st.st_mode));
- assertEqualInt(0, lstat("dest2/dir/f", &st));
- assert(S_ISREG(st.st_mode));
- assertEqualInt(3, st.st_size);
+ assertIsDir("dest2/dir/d", -1);
+ assertIsReg("dest2/dir/f", -1);
+ assertFileSize("dest2/dir/f", 3);
/* dest2/dir2 symlink should be removed */
- assertEqualInt(0, lstat("dest2/dir2", &st));
failure("Broken symlink wasn't replaced with dir");
- assert(S_ISDIR(st.st_mode));
+ assertIsDir("dest2/dir2", -1);
/* dest2/dir3 symlink should be removed */
- assertEqualInt(0, lstat("dest2/dir3", &st));
failure("Symlink to non-dir wasn't replaced with dir");
- assert(S_ISDIR(st.st_mode));
+ assertIsDir("dest2/dir3", -1);
/* dest2/file symlink should be removed;
* even -P shouldn't follow symlinks for files */
- assertEqualInt(0, lstat("dest2/file", &st));
failure("Symlink to existing file should be removed");
- assert(S_ISREG(st.st_mode));
+ assertIsReg("dest2/file", -1);
/* dest2/file2 symlink should be removed */
- assertEqualInt(0, lstat("dest2/file2", &st));
failure("Symlink to non-existing file should be removed");
- assert(S_ISREG(st.st_mode));
+ assertIsReg("dest2/file2", -1);
}
#include "test.h"
#if defined(_WIN32) && !defined(__CYGWIN__)
+#include <windows.h>
+
static void
mkfile(const char *name)
{
* Preparre tests.
* Create directories and files.
*/
- assertEqualInt(0, mkdir("tmp", 0775));
- assertEqualInt(0, chdir("tmp"));
+ assertMakeDir("tmp", 0775);
+ assertChdir("tmp");
- assertEqualInt(0, mkdir("aaa", 0775));
- assertEqualInt(0, mkdir("aaa/xxa", 0775));
- assertEqualInt(0, mkdir("aaa/xxb", 0775));
- assertEqualInt(0, mkdir("aaa/zzc", 0775));
+ assertMakeDir("aaa", 0775);
+ assertMakeDir("aaa/xxa", 0775);
+ assertMakeDir("aaa/xxb", 0775);
+ assertMakeDir("aaa/zzc", 0775);
mkfile("aaa/file1");
mkfile("aaa/xxa/file1");
mkfile("aaa/xxb/file1");
mkfile("aaa/zzc/file1");
- assertEqualInt(0, mkdir("aab", 0775));
- assertEqualInt(0, mkdir("aac", 0775));
- assertEqualInt(0, mkdir("abb", 0775));
- assertEqualInt(0, mkdir("abc", 0775));
- assertEqualInt(0, mkdir("abd", 0775));
- assertEqualInt(0, mkdir("bbb", 0775));
- assertEqualInt(0, mkdir("bbb/xxa", 0775));
- assertEqualInt(0, mkdir("bbb/xxb", 0775));
- assertEqualInt(0, mkdir("bbb/zzc", 0775));
+ assertMakeDir("aab", 0775);
+ assertMakeDir("aac", 0775);
+ assertMakeDir("abb", 0775);
+ assertMakeDir("abc", 0775);
+ assertMakeDir("abd", 0775);
+ assertMakeDir("bbb", 0775);
+ assertMakeDir("bbb/xxa", 0775);
+ assertMakeDir("bbb/xxb", 0775);
+ assertMakeDir("bbb/zzc", 0775);
mkfile("bbb/file1");
mkfile("bbb/xxa/file1");
mkfile("bbb/xxb/file1");
mkfile("bbb/zzc/file1");
- assertEqualInt(0, mkdir("bbc", 0775));
- assertEqualInt(0, mkdir("bbd", 0775));
- assertEqualInt(0, mkdir("bcc", 0775));
- assertEqualInt(0, mkdir("bcd", 0775));
- assertEqualInt(0, mkdir("bce", 0775));
- assertEqualInt(0, mkdir("ccc", 0775));
- assertEqualInt(0, mkdir("fff", 0775));
+ assertMakeDir("bbc", 0775);
+ assertMakeDir("bbd", 0775);
+ assertMakeDir("bcc", 0775);
+ assertMakeDir("bcd", 0775);
+ assertEqualInt(0, _mkdir("bce"));
+ assertEqualInt(0, _mkdir("ccc"));
+ assertEqualInt(0, _mkdir("fff"));
mkfile("fff/aaaa");
mkfile("fff/abba");
mkfile("fff/abca");
projects / thirdparty / libarchive.git / commitdiff
