(file) Return to tvfs.c CVS log (file) (dir) Up to [RizwankCVS] / group3 / wine / dlls / cabinet / tests

Diff for /group3/wine/dlls/cabinet/tests/tvfs.c between version 1.7 and 1.13

version 1.7, 2005/02/27 05:21:08 version 1.13, 2005/03/18 00:28:59
Line 7 
Line 7 
 #include "tvfs.h" #include "tvfs.h"
 #include <string.h> #include <string.h>
  
 /* This is extremely cheezy.  Everything is preallocated per file. */  #define MAXFILES 20
   #define MAXHANDLES 20
 #define MAXFILES 10  
 #define MAXHANDLES 10  
 #define MAXFNAME 255 #define MAXFNAME 255
 #define MAXFLEN 65536  #define MAXFLEN 65536*2
  
 /*  
 #define TVFS_MAIN  
 */  
 #include <fcntl.h> #include <fcntl.h>
 #include <stdlib.h> #include <stdlib.h>
 #include <stdio.h> #include <stdio.h>
 #include <malloc.h> #include <malloc.h>
 /*  #include <stdio.h>
 #define DEBUG  #include <stdarg.h>
 */  
 #define SEEK_SET 0 #define SEEK_SET 0
 #define SEEK_CUR 1 #define SEEK_CUR 1
 #define SEEK_END 2 #define SEEK_END 2
  
   #ifndef _O_BINARY
   #define _O_BINARY 0
   #endif
   
   /*
   #define TVFS_MAIN
   */
   
   #ifndef STANDALONE
   #include "wine/test.h"
   #define ok2 ok
   #else
   #include "standalone.h"
   #undef START_TEST
   #endif
   
 struct tvfs_file { struct tvfs_file {
        char fname[MAXFNAME];        char fname[MAXFNAME];
        int bytes_used;        int bytes_used;
        char buf[MAXFLEN];        char buf[MAXFLEN];
 }; };
 static struct tvfs_file *files[MAXFILES]; static struct tvfs_file *files[MAXFILES];
 int nfiles = 0;  
  
 struct tvfs_fcb { struct tvfs_fcb {
        int pos;        int pos;
        int inode;        int inode;
 }; };
 static struct tvfs_fcb *handles[MAXHANDLES]; static struct tvfs_fcb *handles[MAXHANDLES];
   
 int nhandles = 0; int nhandles = 0;
   int nfiles = 0;
  
 /* tvfs_create does NOT correspond to _creat - it is an internal function /* tvfs_create does NOT correspond to _creat - it is an internal function
 use to put a file directly into our virtual filesystem. */ use to put a file directly into our virtual filesystem. */
Line 51 
Line 63 
            int inode;            int inode;
        struct tvfs_file *f;        struct tvfs_file *f;
  
                 #ifdef DEBUG      trace("tvfs_create called with %s, %d, %d\n", fname, buf, len);
                 printf("tvfs_create called with %s, %d, %d\n", fname, buf, len);  
                 #endif  
  
        if (nfiles >= MAXFILES)        if (nfiles >= MAXFILES)
                return -1;                return -1;
        inode = nfiles++;        inode = nfiles++;
                 /* calloc didn't work here, while malloc did */  
            f = malloc(sizeof(struct tvfs_file));            f = malloc(sizeof(struct tvfs_file));
        strcpy(f->fname, fname);        strcpy(f->fname, fname);
        f->bytes_used = len;        f->bytes_used = len;
   
        if (buf)        if (buf)
                memcpy(f->buf, buf, len);                memcpy(f->buf, buf, len);
   
        files[inode] = f;        files[inode] = f;
        return inode;        return inode;
 } }
Line 76 
Line 88 
        int inode;        int inode;
            struct tvfs_fcb *handler;            struct tvfs_fcb *handler;
  
         #ifdef DEBUG      trace("tvfs_open called with %s, %d, %d\n", fname, flags, mode);
         printf("tvfs_open called with %s, %d, %d\n", fname, flags, mode);  
         #endif  
  
            /* Existing file? */            /* Existing file? */
        for (inode=0; inode<nfiles; inode++) {        for (inode=0; inode<nfiles; inode++) {
                if (!files[inode])                if (!files[inode])
                        continue;                        continue;
                if (!strcmp(files[inode]->fname, fname))                if (!strcmp(files[inode]->fname, fname))
                                                 break;       }              break;
       }
   
        if (inode == nfiles) {        if (inode == nfiles) {
                /* File did not exist */                /* File did not exist */
                if ((flags & O_CREAT) == 0) {                if ((flags & O_CREAT) == 0) {
                        /* ENOENT */                        /* ENOENT */
         #ifdef DEBUG              trace("tvfs_open returning -1\n");
         printf("tvfs_open returning -1\n");  
         #endif  
                        return -1;                        return -1;
                }                }
   
                inode = tvfs_create(fname, 0, 0);                inode = tvfs_create(fname, 0, 0);
        }        }
   
            handler = malloc(sizeof(struct tvfs_fcb));            handler = malloc(sizeof(struct tvfs_fcb));
            handler->inode = inode;            handler->inode = inode;
            handler->pos=0;            handler->pos=0;
            h = nfiles++;      h = nhandles++;
            handles[h] = handler;            handles[h] = handler;
         #ifdef DEBUG  
         printf("tvfs_open returning with %d\n", h);      trace("tvfs_open returning with %d\n", h);
         #endif  
  
            return h;            return h;
 } }
Line 115 
Line 126 
        int pos = handles[h]->pos;        int pos = handles[h]->pos;
            int size = files[inode]->bytes_used;            int size = files[inode]->bytes_used;
  
         #ifdef DEBUG      trace("tvfs_read called with %d, %d, %d\n", h, buf, len);
         printf("tvfs_read called with %d, %d, %d\n", h, buf, len);  
         #endif  
  
        /* FIXME: handle edge cases */  
            /* Edge Case 1 : Request beyond boundary of file */            /* Edge Case 1 : Request beyond boundary of file */
            if (pos + len > size) {            if (pos + len > size) {
                    len = size-pos;                    len = size-pos;
Line 131 
Line 139 
        return len;        return len;
 } }
  
 void tvfs_free(){  void tvfs_free()
   {
         int inode;         int inode;
       int handle;
  
         #ifdef DEBUG      trace("tvfs_free\n");
         printf("tvfs_free\n");  
         #endif  
  
         nfiles=0;         nfiles=0;
         nhandles=0;         nhandles=0;
Line 147 
Line 154 
                                 continue;                                 continue;
                         free(files[inode]);                         free(files[inode]);
                 }                 }
   
       for (handle=0; handle<nhandles; handle++) {
           if (!handles[handle])
               continue;
           free(handles[handle]);
       }
   
         }         }
  
 /* Compare given file with given contents, return 0 on equal, else nonzero */ /* Compare given file with given contents, return 0 on equal, else nonzero */
 int tvfs_compare(const char *fname, const char *buf, int len){  int tvfs_compare(const char *fname, const char *buf, int len)
   {
  
         int inode;         int inode;
  
         #ifdef DEBUG      trace("tvfs_compare called with %s, %d, %d\n", fname, buf, len);
         printf("tvfs_compare called with %s, %d, %d\n", fname, buf, len);  
         #endif  
  
         for (inode=0; inode<nfiles; inode++) {         for (inode=0; inode<nfiles; inode++) {
         if (!files[inode])         if (!files[inode])
         continue;         continue;
     if (!strcmp(files[inode]->fname, fname))     if (!strcmp(files[inode]->fname, fname))
                 break;       }          break;
       }
   
     if (inode == nfiles) {     if (inode == nfiles) {
                /* File did not exist */                /* File did not exist */
                 #ifdef DEBUG          trace("tvfs_compare returning -1 (FAILURE)\n");
                 printf("tvfs_compare returning -1 (FAILURE)\n");  
                 #endif  
         return -1;         return -1;
     }     }
  
         return (memcmp(files[inode]->buf,buf,len));         return (memcmp(files[inode]->buf,buf,len));
         /* doesnt check for out of bound */      /* does not check for out of bound */
 } }
  
 long tvfs_lseek(int h, long whence, int whither ){  long tvfs_lseek(int h, long whence, int whither )
   {
  
       int inode = handles[h]->inode;       int inode = handles[h]->inode;
           int size = files[inode]->bytes_used;           int size = files[inode]->bytes_used;
         #ifdef DEBUG      trace("tvfs_lseek called with %d, %d, %d\n", h, whither, whence);
         printf("tvfs_lseek called with %d, %d, %d\n", h, whither, whence);  
         #endif  
 /*                if (whence > size) /*                if (whence > size)
                           whence = size;*/                           whence = size;*/
 /*                      Legit lseek does NOT do boundry checking */  /*  Legit lseek does NOT do boundary checking */
  
           switch(whither) {           switch(whither) {
                   case SEEK_SET: {                   case SEEK_SET: {
Line 203 
Line 216 
                           handles[h]->pos = size+whence;                           handles[h]->pos = size+whence;
                           break;                           break;
                   }                   }
                   case 44: {  
                           handles[h]->pos = size+whence;  
                           break;  
                   }  
                   default:                   default:
                   {                   {
                           printf("lseek was called with an invalid whither %d\n",whither);              trace("lseek was called with an invalid whither %d\n",whither);
                           return -1;                           return -1;
                   }                   }
           }           }
           return handles[h]->pos;           return handles[h]->pos;
   }   }
  
 int tvfs_close(int h){  int tvfs_close(int h)
   {
          int inode = handles[h]->inode;          int inode = handles[h]->inode;
         #ifdef DEBUG      trace("tvfs_close called with %d\n", h);
         printf("tvfs_close called with %d\n", h);  
         #endif  
          if (!files[inode]){          if (!files[inode]){
                  return -1;                  return -1;
          }          }
Line 234 
Line 242 
  
    int inode = handles[h]->inode;    int inode = handles[h]->inode;
    int pos = handles[h]->pos;    int pos = handles[h]->pos;
       trace("tvfs_write called with %d, %d, %d\n", h, buf, len);
         printf("tvfs_write called with %d, %d, %d\n", h, buf, len);  
   
         memcpy(files[inode]->buf+pos, buf, len);         memcpy(files[inode]->buf+pos, buf, len);
         files[inode]->bytes_used += len;         files[inode]->bytes_used += len;
       handles[h]->pos += len;
  
         return len;         return len;
         /* return -1 to simulate diskfull or some other error */         /* return -1 to simulate diskfull or some other error */
 } }
  
  
   START_TEST(tvfs){
      printf("dummy!");
   }
  
  
 #ifdef TVFS_MAIN #ifdef TVFS_MAIN
Line 254 
Line 263 
 const static char file_test_txt[] = "This is a test. Don't Panic!"; const static char file_test_txt[] = "This is a test. Don't Panic!";
 const static int size_test_txt = sizeof(file_test_txt); const static int size_test_txt = sizeof(file_test_txt);
  
 main(){  /* If TVFSMain is defined, this compiles a test of the TVFS suite */
   main()
   {
         int result;         int result;
         int active_handler;         int active_handler;
  
Line 265 
Line 276 
  
         filebuf = malloc(MAXFLEN);         filebuf = malloc(MAXFLEN);
  
         printf("Testing TVFS implementation, creating %s\n",name_test_txt);      trace("Testing TVFS implementation, creating %s\n",name_test_txt);
         result = tvfs_create( dummy_filename, file_test_txt, size_test_txt);         result = tvfs_create( dummy_filename, file_test_txt, size_test_txt);
         result = tvfs_create( name_test_txt, file_test_txt,size_test_txt);         result = tvfs_create( name_test_txt, file_test_txt,size_test_txt);
         printf("Created virtual file with inode %d\n",result);      trace("Created virtual file with inode %d\n",result);
  
         /* This test failes because strcmp returns 0 incorrectly! */      trace("Attempting to open non-existent file\n");
         printf("Attempting to open non-existant file\n");  
         result = tvfs_open(bad_filename, _O_BINARY, 0 );         result = tvfs_open(bad_filename, _O_BINARY, 0 );
         printf("Result code %d\n",result);      trace("Result code %d\n",result);
         printf("Attempting to open existant file\n");      trace("Attempting to open existent file\n");
         result = tvfs_open(name_test_txt, _O_BINARY, 0 );         result = tvfs_open(name_test_txt, _O_BINARY, 0 );
         printf("Result code %d\n",result);      trace("Result code %d\n",result);
  
         active_handler = result;         active_handler = result;
  
         memset (filebuf,0,MAXFLEN);         memset (filebuf,0,MAXFLEN);
  
         printf("Testing reading from file %s\n",name_test_txt);      trace("Testing reading from file %s\n",name_test_txt);
         result = tvfs_read(active_handler, filebuf, 9);         result = tvfs_read(active_handler, filebuf, 9);
         printf("Read _%s_\n", filebuf);      trace("Read _%s_\n", filebuf);
         if ( strcmp(filebuf,"This is a"))         if ( strcmp(filebuf,"This is a"))
                 printf("File read check failed!\n");      trace("File read check failed!\n");
  
         printf("Testing sequential reading from file %s\n",name_test_txt);      trace("Testing sequential reading from file %s\n",name_test_txt);
         result = tvfs_read(active_handler, filebuf, 12);         result = tvfs_read(active_handler, filebuf, 12);
         printf("Read _%s_\n", filebuf);      trace("Read _%s_\n", filebuf);
         if ( strcmp(filebuf," test. Don't"))         if ( strcmp(filebuf," test. Don't"))
                 printf("File read check failed!\n");      trace("File read check failed!\n");
  
         printf("Testing edge reading from file %s\n",name_test_txt);      trace("Testing edge reading from file %s\n",name_test_txt);
         result = tvfs_read(active_handler, filebuf, 42);         result = tvfs_read(active_handler, filebuf, 42);
         printf("Read %d bytes - _%s_\n", result, filebuf);      trace("Read %d bytes - _%s_\n", result, filebuf);
         if ( result != 8 )         if ( result != 8 )
                 printf("File read check failed!\n");      trace("File read check failed!\n");
  
         printf("Testing direct file compare and lseek of %s\n", name_test_txt);      trace("Testing direct file compare and lseek of %s\n", name_test_txt);
         printf("Seeking to 0 (not needed) - ");      trace("Seeking to 0 (not needed) - ");
         tvfs_lseek( active_handler, SEEK_SET, 0);         tvfs_lseek( active_handler, SEEK_SET, 0);
         printf("Comparing file\n");      trace("Comparing file\n");
         result = tvfs_compare( name_test_txt , file_test_txt, size_test_txt);         result = tvfs_compare( name_test_txt , file_test_txt, size_test_txt);
         if (result)         if (result)
                 printf ("File compare failed!\n");      trace ("File compare failed!\n");
  
  
         printf("Closing %s\n",name_test_txt);      trace("Closing %s\n",name_test_txt);
         tvfs_close(active_handler);         tvfs_close(active_handler);
         if (result)         if (result)
                 printf ("File close failed!\n");      trace ("File close failed!\n");
  
         tvfs_free();         tvfs_free();
         free(filebuf);         free(filebuf);

Legend:
Removed from v.1.7  
changed lines
  Added in v.1.13
Rizwan Kassim
 Powered by
ViewCVS 0.9.2