libburnia/libisofs
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Change mocked filesystem implementation, used in unit tests.

Browse Source
This commit is contained in:
Vreixo Formoso 2008-01-08 21:23:24 +01:00
parent 2464455fea
commit 758e2654f8
3 changed files with 107 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

206
test/mocked_fsrc.c
View File

@ -13,87 +13,74 @@
#include <string.h> #include <string.h>
#include <libgen.h> #include <libgen.h>
#include <stdlib.h> #include <stdlib.h>
#include <time.h>
static static
struct mock_file *path_to_node(IsoFilesystem *fs, const char *path); struct mock_file *path_to_node(IsoFilesystem *fs, const char *path);
struct mock_file { static
struct stat info; char *get_path_aux(struct mock_file *file)
char *name;
void *content;
};
struct mock_fs_src
{ {
IsoFilesystem *fs; if (file->parent == NULL) {
char *path; return strdup("");
} _MockedFsFileSource; } else {
char *path = get_path_aux(file->parent);
int pathlen = strlen(path);
path = realloc(path, pathlen + strlen(file->name) + 2);
path[pathlen] = '/';
path[pathlen + 1] = '\0';
return strcat(path, file->name);
}
}
static static
const char* mfs_get_path(IsoFileSource *src) char* mfs_get_path(IsoFileSource *src)
{ {
struct mock_fs_src *data; struct mock_file *data;
data = src->data; data = src->data;
return data->path; return get_path_aux(data);
} }
static static
char* mfs_get_name(IsoFileSource *src) char* mfs_get_name(IsoFileSource *src)
{ {
char *name, *p; struct mock_file *data;
struct mock_fs_src *data;
data = src->data; data = src->data;
p = strdup(data->path); /* because basename() might modify its arg */ return strdup(data->name);
name = strdup(basename(p));
free(p);
return name;
} }
static static
int mfs_lstat(IsoFileSource *src, struct stat *info) int mfs_lstat(IsoFileSource *src, struct stat *info)
{ {
struct mock_fs_src *data; struct mock_file *data;
struct mock_file *node;
if (src == NULL || info == NULL) { if (src == NULL || info == NULL) {
return ISO_NULL_POINTER; return ISO_NULL_POINTER;
} }
data = src->data; data = src->data;
node = path_to_node(data->fs, data->path); *info = data->atts;
if (node == NULL) {
return ISO_FILE_BAD_PATH;
}
*info = node->info;
return ISO_SUCCESS; return ISO_SUCCESS;
} }
static static
int mfs_stat(IsoFileSource *src, struct stat *info) int mfs_stat(IsoFileSource *src, struct stat *info)
{ {
struct mock_fs_src *data;
struct mock_file *node; struct mock_file *node;
if (src == NULL || info == NULL) { if (src == NULL || info == NULL) {
return ISO_NULL_POINTER; return ISO_NULL_POINTER;
} }
data = src->data; node = src->data;
node = path_to_node(data->fs, data->path); while ( S_ISLNK(node->atts.st_mode) ) {
if (node == NULL) {
return ISO_FILE_BAD_PATH;
}
while ( S_ISLNK(node->info.st_mode) ) {
/* the destination is stated */ /* the destination is stated */
node = path_to_node(data->fs, (char *)node->content); node = path_to_node(node->fs, (char *)node->content);
if (node == NULL) { if (node == NULL) {
return ISO_FILE_ERROR; return ISO_FILE_ERROR;
} }
} }
*info = node->info; *info = node->atts;
return ISO_SUCCESS; return ISO_SUCCESS;
} }
@ -101,7 +88,7 @@ static
int mfs_access(IsoFileSource *src) int mfs_access(IsoFileSource *src)
{ {
// TODO not implemented // TODO not implemented
return ISO_SUCCESS; return ISO_ERROR;
} }
static static
@ -135,8 +122,7 @@ int mfs_readdir(IsoFileSource *src, IsoFileSource **child)
static static
int mfs_readlink(IsoFileSource *src, char *buf, size_t bufsiz) int mfs_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
{ {
struct mock_fs_src *data; struct mock_file *data;
struct mock_file *node;
if (src == NULL || buf == NULL) { if (src == NULL || buf == NULL) {
return ISO_NULL_POINTER; return ISO_NULL_POINTER;
@ -147,14 +133,10 @@ int mfs_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
} }
data = src->data; data = src->data;
node = path_to_node(data->fs, data->path); if (!S_ISLNK(data->atts.st_mode)) {
if (node == NULL) {
return ISO_FILE_BAD_PATH;
}
if (!S_ISLNK(node->info.st_mode)) {
return ISO_FILE_IS_NOT_SYMLINK; return ISO_FILE_IS_NOT_SYMLINK;
} }
strncpy(buf, node->content, bufsiz); strncpy(buf, data->content, bufsiz);
buf[bufsiz-1] = '\0'; buf[bufsiz-1] = '\0';
return ISO_SUCCESS; return ISO_SUCCESS;
} }
@ -162,7 +144,7 @@ int mfs_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
static static
IsoFilesystem* mfs_get_filesystem(IsoFileSource *src) IsoFilesystem* mfs_get_filesystem(IsoFileSource *src)
{ {
struct mock_fs_src *data; struct mock_file *data;
data = src->data; data = src->data;
return data->fs; return data->fs;
} }
@ -170,12 +152,7 @@ IsoFilesystem* mfs_get_filesystem(IsoFileSource *src)
static static
void mfs_free(IsoFileSource *src) void mfs_free(IsoFileSource *src)
{ {
struct mock_fs_src *data; /* nothing to do */
data = src->data;
free(data->path);
iso_filesystem_unref(data->fs);
free(data);
} }
IsoFileSourceIface mfs_class = { IsoFileSourceIface mfs_class = {
@ -199,21 +176,15 @@ IsoFileSourceIface mfs_class = {
* 1 success, < 0 error * 1 success, < 0 error
*/ */
static static
int mocked_file_source_new(IsoFilesystem *fs, const char *path, int mocked_file_source_new(struct mock_file *data, IsoFileSource **src)
IsoFileSource **src)
{ {
IsoFileSource *mocked_src; IsoFileSource *mocked_src;
struct mock_fs_src *data;
if (src == NULL || fs == NULL) { if (src == NULL || data == NULL) {
return ISO_NULL_POINTER; return ISO_NULL_POINTER;
} }
/* allocate memory */ /* allocate memory */
data = malloc(sizeof(struct mock_fs_src));
if (data == NULL) {
return ISO_OUT_OF_MEM;
}
mocked_src = malloc(sizeof(IsoFileSource)); mocked_src = malloc(sizeof(IsoFileSource));
if (mocked_src == NULL) { if (mocked_src == NULL) {
free(data); free(data);
@ -221,25 +192,12 @@ int mocked_file_source_new(IsoFilesystem *fs, const char *path,
} }
/* fill struct */ /* fill struct */
data->path = strdup(path);
{
/* remove trailing '/' */
int len = strlen(path);
if (len > 1) {
/* don't remove / for root! */
if (path[len-1] == '/') {
data->path[len-1] = '\0';
}
}
}
data->fs = fs;
mocked_src->refcount = 1; mocked_src->refcount = 1;
mocked_src->data = data; mocked_src->data = data;
mocked_src->class = &mfs_class; mocked_src->class = &mfs_class;
/* take a ref to filesystem */ /* take a ref to filesystem */
iso_filesystem_ref(fs); //iso_filesystem_ref(fs);
/* return */ /* return */
*src = mocked_src; *src = mocked_src;
@ -267,7 +225,7 @@ struct mock_file *path_to_node(IsoFilesystem *fs, const char *path)
while (component) { while (component) {
size_t i; size_t i;
if ( !S_ISDIR(node->info.st_mode) ) { if ( !S_ISDIR(node->atts.st_mode) ) {
node=NULL; node=NULL;
break; break;
} }
@ -298,67 +256,52 @@ struct mock_file *path_to_node(IsoFilesystem *fs, const char *path)
} }
static static
struct mock_file *add_node(IsoFilesystem *fs, const char *path, void add_node(struct mock_file *parent, struct mock_file *node)
struct stat info)
{ {
char *dir, *name, *ptr;
struct mock_file *node, *parent;
int i; int i;
if (!strcmp(path, "/"))
return NULL;
dir = dirname(strdup(path));
ptr = strdup(path);
name = basename(ptr);
/*printf("Added %s to %s\n", name, dir);*/
parent = path_to_node(fs, dir);
if (!S_ISDIR(parent->info.st_mode)) {
return NULL;
}
i = 0; i = 0;
if (parent->content) { if (parent->content) {
while (((struct mock_file**)parent->content)[i]) { while (((struct mock_file**)parent->content)[i]) {
++i; ++i;
} }
} }
parent->content = realloc(parent->content, (i+2) * sizeof(struct mock_file*)); parent->content = realloc(parent->content, (i+2) * sizeof(void*));
node = malloc(sizeof(struct mock_file));
node->info = info;
node->content = NULL;
node->name = strdup(name);
((struct mock_file**)parent->content)[i] = node; ((struct mock_file**)parent->content)[i] = node;
((struct mock_file**)parent->content)[i+1] = NULL; ((struct mock_file**)parent->content)[i+1] = NULL;
free(dir);
free(ptr);
return node;
} }
int test_mocked_fs_add_file(IsoFilesystem *fs, const char *path, struct mock_file *test_mocked_fs_get_root(IsoFilesystem *fs)
struct stat info)
{ {
struct mock_file *node = add_node(fs, path, info); return fs->data;
return (node == NULL) ? -1 : 1;
} }
int test_mocked_fs_add_dir(IsoFilesystem *fs, const char *path, int test_mocked_fs_add_dir(const char *name, struct mock_file *p,
struct stat info) struct stat atts, struct mock_file **node)
{ {
struct mock_file *node = add_node(fs, path, info); struct mock_file *dir = calloc(1, sizeof(struct mock_file));
return (node == NULL) ? -1 : 1; dir->fs = p->fs;
dir->atts = atts;
dir->name = strdup(name);
dir->parent = p;
add_node(p, dir);
*node = dir;
return ISO_SUCCESS;
} }
int test_mocked_fs_add_symlink(IsoFilesystem *fs, const char *path, int test_mocked_fs_add_symlink(const char *name, struct mock_file *p,
struct stat info, const char *dest) struct stat atts, const char *dest, struct mock_file **node)
{ {
struct mock_file *node = add_node(fs, path, info); struct mock_file *link = calloc(1, sizeof(struct mock_file));
if (node == NULL) { link->fs = p->fs;
return -1; link->atts = atts;
} link->name = strdup(name);
node->content = strdup(dest); link->parent = p;
return 1; add_node(p, link);
link->content = strdup(dest);
*node = link;
return ISO_SUCCESS;
} }
static static
@ -367,22 +310,24 @@ int mocked_get_root(IsoFilesystem *fs, IsoFileSource **root)
if (fs == NULL || root == NULL) { if (fs == NULL || root == NULL) {
return ISO_NULL_POINTER; return ISO_NULL_POINTER;
} }
return mocked_file_source_new(fs, "/", root); return mocked_file_source_new(fs->data, root);
} }
static static
int mocked_get_by_path(IsoFilesystem *fs, const char *path, IsoFileSource **file) int mocked_get_by_path(IsoFilesystem *fs, const char *path, IsoFileSource **file)
{ {
struct mock_file *f;
if (fs == NULL || path == NULL || file == NULL) { if (fs == NULL || path == NULL || file == NULL) {
return ISO_NULL_POINTER; return ISO_NULL_POINTER;
} }
return mocked_file_source_new(fs, path, file); f = path_to_node(fs, path);
return mocked_file_source_new(f, file);
} }
static static
void free_mocked_file(struct mock_file *file) void free_mocked_file(struct mock_file *file)
{ {
if (S_ISDIR(file->info.st_mode)) { if (S_ISDIR(file->atts.st_mode)) {
if (file->content) { if (file->content) {
int i = 0; int i = 0;
while (((struct mock_file**)file->content)[i]) { while (((struct mock_file**)file->content)[i]) {
@ -391,6 +336,7 @@ void free_mocked_file(struct mock_file *file)
} }
} }
} }
free(file->content);
free(file->name); free(file->name);
free(file); free(file);
} }
@ -400,19 +346,27 @@ void mocked_fs_free(IsoFilesystem *fs)
{ {
free_mocked_file((struct mock_file *)fs->data); free_mocked_file((struct mock_file *)fs->data);
} }
int test_mocked_filesystem_new(IsoFilesystem **fs) int test_mocked_filesystem_new(IsoFilesystem **fs)
{ {
IsoFilesystem *filesystem;
struct mock_file *root; struct mock_file *root;
IsoFilesystem *filesystem;
if (fs == NULL) { if (fs == NULL) {
return ISO_NULL_POINTER; return ISO_NULL_POINTER;
} }
root = calloc(1, sizeof(struct mock_file));
root->atts.st_atime = time(NULL);
root->atts.st_ctime = time(NULL);
root->atts.st_mtime = time(NULL);
root->atts.st_uid = 0;
root->atts.st_gid = 0;
root->atts.st_mode = S_IFDIR | 0777;
filesystem = malloc(sizeof(IsoFilesystem)); filesystem = malloc(sizeof(IsoFilesystem));
filesystem->refcount = 1; filesystem->refcount = 1;
root = calloc(1, sizeof(struct mock_file)); root->fs = filesystem;
root->info.st_mode = S_IFDIR | 0777;
filesystem->data = root; filesystem->data = root;
filesystem->get_root = mocked_get_root; filesystem->get_root = mocked_get_root;
filesystem->get_by_path = mocked_get_by_path; filesystem->get_by_path = mocked_get_by_path;

24
test/mocked_fsrc.h
View File

@ -5,19 +5,27 @@
#ifndef MOCKED_FSRC_H_ #ifndef MOCKED_FSRC_H_
#define MOCKED_FSRC_H_ #define MOCKED_FSRC_H_
struct mock_file {
IsoFilesystem *fs;
struct mock_file *parent;
struct stat atts;
char *name;
/* for links, link dest. For dirs, children */
void *content;
};
/** /**
* A mocked fs with a registry of files, that you can add via * A mocked fs.
* test_mocked_fs_add_fsrc().
*/ */
int test_mocked_filesystem_new(IsoFilesystem **fs); int test_mocked_filesystem_new(IsoFilesystem **fs);
int test_mocked_fs_add_file(IsoFilesystem *fs, const char *path, struct mock_file *test_mocked_fs_get_root(IsoFilesystem *fs);
struct stat info);
int test_mocked_fs_add_dir(IsoFilesystem *fs, const char *path, int test_mocked_fs_add_dir(const char *name, struct mock_file *parent,
struct stat info); struct stat atts, struct mock_file **dir);
int test_mocked_fs_add_symlink(IsoFilesystem *fs, const char *path, int test_mocked_fs_add_symlink(const char *name, struct mock_file *p,
struct stat info, const char *dest); struct stat atts, const char *dest, struct mock_file **node);
#endif /*MOCKED_FSRC_H_*/ #endif /*MOCKED_FSRC_H_*/

19
test/test_tree.c
View File

@ -258,6 +258,7 @@ void test_iso_tree_add_node_dir()
IsoImage *image; IsoImage *image;
IsoFilesystem *fs; IsoFilesystem *fs;
struct stat info; struct stat info;
struct mock_file *mroot, *dir1, *dir2;
result = iso_image_new("volume_id", &image); result = iso_image_new("volume_id", &image);
CU_ASSERT_EQUAL(result, 1); CU_ASSERT_EQUAL(result, 1);
@ -269,6 +270,7 @@ void test_iso_tree_add_node_dir()
result = test_mocked_filesystem_new(&fs); result = test_mocked_filesystem_new(&fs);
CU_ASSERT_EQUAL(result, 1); CU_ASSERT_EQUAL(result, 1);
image->fs = fs; image->fs = fs;
mroot = test_mocked_fs_get_root(fs);
/* add some files to the filesystem */ /* add some files to the filesystem */
info.st_mode = S_IFDIR | 0550; info.st_mode = S_IFDIR | 0550;
@ -277,7 +279,7 @@ void test_iso_tree_add_node_dir()
info.st_atime = 234523; info.st_atime = 234523;
info.st_ctime = 23432432; info.st_ctime = 23432432;
info.st_mtime = 1111123; info.st_mtime = 1111123;
result = test_mocked_fs_add_dir(fs, "/dir", info); result = test_mocked_fs_add_dir("dir", mroot, info, &dir1);
CU_ASSERT_EQUAL(result, 1); CU_ASSERT_EQUAL(result, 1);
info.st_mode = S_IFDIR | 0555; info.st_mode = S_IFDIR | 0555;
@ -286,7 +288,7 @@ void test_iso_tree_add_node_dir()
info.st_atime = 3234523; info.st_atime = 3234523;
info.st_ctime = 3234432; info.st_ctime = 3234432;
info.st_mtime = 3111123; info.st_mtime = 3111123;
result = test_mocked_fs_add_dir(fs, "/dir/a child node", info); result = test_mocked_fs_add_dir("a child node", dir1, info, &dir2);
CU_ASSERT_EQUAL(result, 1); CU_ASSERT_EQUAL(result, 1);
info.st_mode = S_IFDIR | 0750; info.st_mode = S_IFDIR | 0750;
@ -295,7 +297,7 @@ void test_iso_tree_add_node_dir()
info.st_atime = 4234523; info.st_atime = 4234523;
info.st_ctime = 4234432; info.st_ctime = 4234432;
info.st_mtime = 4111123; info.st_mtime = 4111123;
result = test_mocked_fs_add_dir(fs, "/dir/another one", info); result = test_mocked_fs_add_dir("another one", dir1, info, &dir2);
CU_ASSERT_EQUAL(result, 1); CU_ASSERT_EQUAL(result, 1);
info.st_mode = S_IFDIR | 0755; info.st_mode = S_IFDIR | 0755;
@ -304,7 +306,7 @@ void test_iso_tree_add_node_dir()
info.st_atime = 5234523; info.st_atime = 5234523;
info.st_ctime = 5234432; info.st_ctime = 5234432;
info.st_mtime = 5111123; info.st_mtime = 5111123;
result = test_mocked_fs_add_dir(fs, "/zzzz", info); result = test_mocked_fs_add_dir("zzzz", mroot, info, &dir2);
CU_ASSERT_EQUAL(result, 1); CU_ASSERT_EQUAL(result, 1);
/* and now insert those files to the image */ /* and now insert those files to the image */
@ -400,6 +402,7 @@ void test_iso_tree_add_node_link()
IsoImage *image; IsoImage *image;
IsoFilesystem *fs; IsoFilesystem *fs;
struct stat info; struct stat info;
struct mock_file *mroot, *link;
result = iso_image_new("volume_id", &image); result = iso_image_new("volume_id", &image);
CU_ASSERT_EQUAL(result, 1); CU_ASSERT_EQUAL(result, 1);
@ -411,6 +414,7 @@ void test_iso_tree_add_node_link()
result = test_mocked_filesystem_new(&fs); result = test_mocked_filesystem_new(&fs);
CU_ASSERT_EQUAL(result, 1); CU_ASSERT_EQUAL(result, 1);
image->fs = fs; image->fs = fs;
mroot = test_mocked_fs_get_root(fs);
/* add some files to the filesystem */ /* add some files to the filesystem */
info.st_mode = S_IFLNK | 0777; info.st_mode = S_IFLNK | 0777;
@ -419,7 +423,7 @@ void test_iso_tree_add_node_link()
info.st_atime = 123444; info.st_atime = 123444;
info.st_ctime = 123555; info.st_ctime = 123555;
info.st_mtime = 123666; info.st_mtime = 123666;
result = test_mocked_fs_add_symlink(fs, "/link1", info, "/home/me"); result = test_mocked_fs_add_symlink("link1", mroot, info, "/home/me", &link);
CU_ASSERT_EQUAL(result, 1); CU_ASSERT_EQUAL(result, 1);
info.st_mode = S_IFLNK | 0555; info.st_mode = S_IFLNK | 0555;
@ -428,7 +432,7 @@ void test_iso_tree_add_node_link()
info.st_atime = 223444; info.st_atime = 223444;
info.st_ctime = 223555; info.st_ctime = 223555;
info.st_mtime = 223666; info.st_mtime = 223666;
result = test_mocked_fs_add_symlink(fs, "/another link", info, "/"); result = test_mocked_fs_add_symlink("another link", mroot, info, "/", &link);
CU_ASSERT_EQUAL(result, 1); CU_ASSERT_EQUAL(result, 1);
info.st_mode = S_IFLNK | 0750; info.st_mode = S_IFLNK | 0750;
@ -437,7 +441,7 @@ void test_iso_tree_add_node_link()
info.st_atime = 323444; info.st_atime = 323444;
info.st_ctime = 323555; info.st_ctime = 323555;
info.st_mtime = 323666; info.st_mtime = 323666;
result = test_mocked_fs_add_symlink(fs, "/this will be the last", info, "/etc"); result = test_mocked_fs_add_symlink("this will be the last", mroot, info, "/etc", &link);
CU_ASSERT_EQUAL(result, 1); CU_ASSERT_EQUAL(result, 1);
/* and now insert those files to the image */ /* and now insert those files to the image */
@ -507,7 +511,6 @@ void test_iso_tree_path_to_node()
IsoNode *node; IsoNode *node;
IsoImage *image; IsoImage *image;
IsoFilesystem *fs; IsoFilesystem *fs;
struct stat info;
result = iso_image_new("volume_id", &image); result = iso_image_new("volume_id", &image);
CU_ASSERT_EQUAL(result, 1); CU_ASSERT_EQUAL(result, 1);