(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.8 and 1.12

version 1.8, 2005/02/27 09:37:56 version 1.12, 2005/03/13 12:13:17
Line 7 
Line 7 
 #include "tvfs.h" #include "tvfs.h"
 #include <string.h> #include <string.h>
  
 #define MAXFILES 10  #define MAXFILES 20
 #define MAXHANDLES 10  #define MAXHANDLES 20
 #define MAXFNAME 255 #define MAXFNAME 255
 #define MAXFLEN 65536  #define MAXFLEN 65536*2
  
 #include <fcntl.h> #include <fcntl.h>
 #include <stdlib.h> #include <stdlib.h>
Line 19 
Line 19 
 #include <stdio.h> #include <stdio.h>
 #include <stdarg.h> #include <stdarg.h>
  
 /*  
 #define TVFS_MAIN  
 #define TVFS_DEBUG  
 */  
   
 #define SEEK_SET 0 #define SEEK_SET 0
 #define SEEK_CUR 1 #define SEEK_CUR 1
 #define SEEK_END 2 #define SEEK_END 2
Line 32 
Line 27 
 #define _O_BINARY 0 #define _O_BINARY 0
 #endif #endif
  
   
   #undef VERBOSE
   #ifdef TVFS_DEBUG
   #define VERBOSE
   #endif
   
   /*
   Only debug output from tvfs.c IF TVFS_DEBUG is true, not just if VERBOSE is true
   The TVFS debug traces are generally used for debugging TVFS, not cabinet_fdi
   #define TVFS_MAIN
   #define TVFS_DEBUG
   */
   
 #ifndef STANDALONE #ifndef STANDALONE
   #include "wine/test.h"
   #define ok2 ok
 #else #else
 static void trace(const char *s, ...)  #include "standalone.h"
 {  #undef START_TEST
     va_list elipsis;  
     va_start (elipsis, s);  
     vprintf(s, elipsis);  
     va_end(elipsis);  
 }  
 #endif #endif
  
 struct tvfs_file { struct tvfs_file {
Line 67 
Line 72 
     int inode;     int inode;
     struct tvfs_file *f;     struct tvfs_file *f;
  
     #ifdef TVFS_DEBUG  
     trace("tvfs_create called with %s, %d, %d\n", fname, buf, len);     trace("tvfs_create called with %s, %d, %d\n", fname, buf, len);
     #endif  
  
     if (nfiles >= MAXFILES)     if (nfiles >= MAXFILES)
         return -1;         return -1;
Line 94 
Line 97 
     int inode;     int inode;
     struct tvfs_fcb *handler;     struct tvfs_fcb *handler;
  
     #ifdef TVFS_DEBUG  
     trace("tvfs_open called with %s, %d, %d\n", fname, flags, mode);     trace("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++) {
Line 110 
Line 111 
         /* File did not exist */         /* File did not exist */
         if ((flags & O_CREAT) == 0) {         if ((flags & O_CREAT) == 0) {
             /* ENOENT */             /* ENOENT */
             #ifdef TVFS_DEBUG  
             trace("tvfs_open returning -1\n");             trace("tvfs_open returning -1\n");
             #endif  
         return -1;         return -1;
         }         }
  
Line 122 
Line 121 
     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 TVFS_DEBUG  
     trace("tvfs_open returning with %d\n", h);     trace("tvfs_open returning with %d\n", h);
     #endif  
  
     return h;     return h;
 } }
Line 138 
Line 135 
     int pos = handles[h]->pos;     int pos = handles[h]->pos;
     int size = files[inode]->bytes_used;     int size = files[inode]->bytes_used;
  
     #ifdef TVFS_DEBUG  
     trace("tvfs_read called with %d, %d, %d\n", h, buf, len);     trace("tvfs_read called with %d, %d, %d\n", h, buf, len);
     #endif  
  
     /* Edge Case 1 : Request beyond boundary of file */     /* Edge Case 1 : Request beyond boundary of file */
     if (pos + len > size) {     if (pos + len > size) {
Line 155 
Line 150 
  
 void tvfs_free() void tvfs_free()
 { {
   
     int inode;     int inode;
       int handle;
  
     #ifdef TVFS_DEBUG  
     trace("tvfs_free\n");     trace("tvfs_free\n");
     #endif  
  
     nfiles=0;     nfiles=0;
     nhandles=0;     nhandles=0;
Line 170 
Line 163 
             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 */
Line 178 
Line 178 
  
     int inode;     int inode;
  
     #ifdef TVFS_DEBUG  
     trace("tvfs_compare called with %s, %d, %d\n", fname, buf, len);     trace("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])
Line 188 
Line 186 
         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 TVFS_DEBUG  
         trace("tvfs_compare returning -1 (FAILURE)\n");         trace("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 )
Line 205 
Line 202 
  
     int inode = handles[h]->inode;     int inode = handles[h]->inode;
     int size = files[inode]->bytes_used;     int size = files[inode]->bytes_used;
     #ifdef TVFS_DEBUG  
     trace("tvfs_lseek called with %d, %d, %d\n", h, whither, whence);     trace("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 230 
Line 225 
     handles[h]->pos = size+whence;     handles[h]->pos = size+whence;
     break;     break;
     }     }
     case 44: {  
     handles[h]->pos = size+whence;  
     break;  
     }  
     default:     default:
     {     {
     trace("lseek was called with an invalid whither %d\n",whither);     trace("lseek was called with an invalid whither %d\n",whither);
Line 243 
Line 234 
     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 TVFS_DEBUG  
     trace("tvfs_close called with %d\n", h);     trace("tvfs_close called with %d\n", h);
     #endif  
     if (!files[inode]){     if (!files[inode]){
     return -1;     return -1;
     }     }
Line 261 
Line 251 
  
     int inode = handles[h]->inode;     int inode = handles[h]->inode;
     int pos = handles[h]->pos;     int pos = handles[h]->pos;
     #ifdef TVFS_DEBUG  
     trace("tvfs_write called with %d, %d, %d\n", h, buf, len);     trace("tvfs_write called with %d, %d, %d\n", h, buf, len);
     #endif  
     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 281 
Line 272 
 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(){  main()
   {
     int result;     int result;
     int active_handler;     int active_handler;
  
Line 292 
Line 284 
  
     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);
  
     printf("Attempting to open non-existant file\n");      trace("Attempting to open non-existent 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.8  
changed lines
  Added in v.1.12
Rizwan Kassim
 Powered by
ViewCVS 0.9.2