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

Diff for /group3/wine/dlls/cabinet/tests/cabinet_fdi.c between version 2.10 and 2.15

version 2.10, 2005/02/27 08:31:36 version 2.15, 2005/03/18 00:28:59
Line 18 
Line 18 
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */  */
  
   #include <stdio.h>
 #include <stdlib.h> #include <stdlib.h>
 #include <string.h> #include <string.h>
 #include <sys/stat.h>  #include <stdarg.h>
   #include <malloc.h>
  
 #ifndef STANDALONE  #include <stdarg.h>
 #include <wine/test.h>  
 #define ok2 ok  
 #else  
 /* To build outside Wine tree, compile with cl -DSTANDALONE -D_X86_ tvfs.c cabinet_fdi.c FDI.lib  
   These are only called if standalone are used, defining ok and START_TEST, which would normally be declared in winetree */  
 #include <assert.h>  
 #include <stdio.h> #include <stdio.h>
 #define START_TEST(name) main(int argc, char **argv)  
 #define ok(condition, msg)       \  #include "windef.h"
         do { if(!(condition)) {  \  #include "winbase.h"
                 fprintf(stderr,"failed at %d, msg:" msg "\n",__LINE__); \  #include "winerror.h"
                 exit(1);         \  #include "fdi.h"
         } } while(0)  
 #define ok2(condition, msg, arg) \  #ifndef WIN_ENV
         do { if(!(condition)) {  \  #include <msvcrt/fcntl.h>
                 fprintf(stderr,"failed at %d, msg:" msg "\n",__LINE__, arg); \  #include <msvcrt/sys/stat.h>
                 exit(1);         \  #else
         } } while(0)  #include <sys/stat.h>
 #define todo_wine  #include <fcntl.h>
 #endif #endif
  
 #define TVFS  #define VERBOSE
  
 #include <winerror.h>  
 #include <fdi.h>  
 #include <fcntl.h>  
 #include "tvfs.h" #include "tvfs.h"
 #include "data.h"  #include "simplecab.h"
   
 /* Do malloc and free output debug messages?  
 #define DEBUG_ALLOC  
 */  
  
 #ifndef DEBUG_ALLOC  #ifndef STANDALONE
 FNALLOC(final_alloc) {  #include <wine/test.h>
         return malloc(cb);  #define ok2 ok
 }  
 FNFREE(final_free) {  
         free(pv);  
         return;  
 }  
 #else #else
   #include "standalone.h"
   /* To build outside Wine tree, compile with cl -DSTANDALONE -D_X86_ -DWIN_ENV tvfs.c cabinet_fdi.c FDI.lib
     standalone.h is used if standalone are used, defining ok and START_TEST, which would normally be declared in winetree */
   #endif
   
 FNALLOC(final_alloc) { FNALLOC(final_alloc) {
         printf("   FNALLOC just called with %d\n",cb);      trace("   FNALLOC just called with %d\n",cb);
         return malloc(cb);         return malloc(cb);
 } }
 FNFREE(final_free) { FNFREE(final_free) {
         printf("   FNFREE just called with %d\n",pv);      trace("   FNFREE just called with %d\n",pv);
         free(pv);         free(pv);
         return;         return;
 } }
 #endif  
   
   
 FNOPEN(dummy_open) {  
         printf("  FNOPEN (dummy) just called with %d, %d, %d\n",pszFile, oflag, pmode);  
         return 0;  
 }  
   
 FNREAD(dummy_read) {  
         printf("   FNREAD (dummy) just called with %d, %d, %d\n",hf, pv, cb);  
         return 0;  
 }  
   
 FNCLOSE(dummy_close) {  
         printf("   FNCLOSE (dummy) just called with %d - returning %d\n",hf,0);  
         return 0;  
 }  
   
 FNWRITE(dummy_write) {  
         printf("   FNWRITE just called with %d, %d, %d\n",hf, pv, cb);  
         return 0;  
 }  
   
 FNSEEK(dummy_seek) {  
         printf("   FNSEEK just called with %d, %d, %d\n",hf, dist, seektype);  
         return 0;  
 }  
   
  
 /*Possible non trivial addition: /*Possible non trivial addition:
 Notify receives some information about the cab file(see FDI documentation). Notify receives some information about the cab file(see FDI documentation).
Line 110 
Line 71 
 */ */
 FNFDINOTIFY(notification_function) FNFDINOTIFY(notification_function)
 { {
       trace("   FNFDINOTIFY real just called with %d, %d \n",fdint,pfdin);
         switch (fdint)         switch (fdint)
         {         {
                 case fdintCABINET_INFO:                 case fdintCABINET_INFO:
                 {                 {
               trace(
                   "fdintCABINET_INFO:\n"
                   "-next cab name: %s\n"
                   "-next disk: %s\n"
                   "-path name: %s\n"
                   "-set ID: %d\n"
                   "-number in set: %d\n",
                   pfdin->psz1, pfdin->psz2, pfdin->psz3, pfdin->setID, pfdin->iCabinet
               );
                         return 0;                         return 0;
                 }                 }
                 case fdintPARTIAL_FILE:                 case fdintPARTIAL_FILE:
                 {                 {
               trace("dintPARTIAL_FILE\n");
   
                         return 0;                         return 0;
                 }                 }
                 case fdintCOPY_FILE:                 case fdintCOPY_FILE:
                 {                 {
                         int fih = 0;                         int fih = 0;
                         char target[256];                         char target[256];
               trace(
                   "fdintCOPY_FILE:\n"
                   "-name: %s\n"
                   "-uncompressed size: %d\n"
                   "-date: %d\n"
                   "-time: %d\n"
                   "-attributes: %d\n"
                   "-file's folder index: %d\n",
                   pfdin->psz1, pfdin->cb, pfdin->date, pfdin->time, pfdin->attribs, pfdin->iFolder
               );
                         sprintf(target, "./%s",pfdin->psz1);                         sprintf(target, "./%s",pfdin->psz1);
                         fih = tvfs_open (target,                         fih = tvfs_open (target,
                                         _O_BINARY | _O_CREAT | _O_WRONLY | _O_SEQUENTIAL,                                         _O_BINARY | _O_CREAT | _O_WRONLY | _O_SEQUENTIAL,
Line 133 
Line 116 
                 }                 }
                 case fdintCLOSE_FILE_INFO:                 case fdintCLOSE_FILE_INFO:
                 {                 {
                         char filebuf[256];  #ifdef VERBOSE
                         int result;              trace(
                   "fdintCLOSE_FILE:\n"
 /*                  "-name: %s\n"
         printf("Testing direct file compare and lseek of %s\n", name_simple_txt);                  "-handle: %d\n"
         printf("Reading and comparing file\n");                  "-date: %d\n"
         result = tvfs_read(7, filebuf, size_simple_txt);                  "-time: %d\n"
         result = tvfs_compare( filebuf , file_simple_txt, size_simple_txt);                  "-attributes: %d\n"
                   "-file's folder index: %d\n"
                   "-run: %d\n",
                   pfdin->psz1, pfdin->hf, pfdin->date, pfdin->time, pfdin->attribs, pfdin->iFolder, pfdin->cb
               );
   #endif
  
 */  
                         tvfs_close(pfdin->hf);                         tvfs_close(pfdin->hf);
                         return TRUE;                         return TRUE;
                 }                 }
                 case fdintNEXT_CABINET:                 case fdintNEXT_CABINET:
                 {                 {
               trace("fdintNEXT_CABINET\n");
                         return 0;                         return 0;
                 }                 }
                 case fdintENUMERATE:                 case fdintENUMERATE:
                 {                 {
               trace("fdintENUMERATE\n");
                         return 0;                         return 0;
                 }                 }
         }         }
Line 159 
Line 148 
 } }
  
 static void printCabInfo(FDICABINETINFO  cabinfo){ static void printCabInfo(FDICABINETINFO  cabinfo){
                 printf("   Cabinet Data : cbC %d cF %d cFi %d si %d iC %d fr %d hp %d hn %d\n",      trace("   Cabinet Data : cbC %d cF %d cFi %d si %d iC %d fr %d hp %d hn %d\n",
                 cabinfo.cbCabinet,                 cabinfo.cbCabinet,
                 cabinfo.cFolders ,                 cabinfo.cFolders ,
                 cabinfo.cFiles ,                 cabinfo.cFiles ,
Line 169 
Line 158 
                 cabinfo.hasprev ,                 cabinfo.hasprev ,
                 cabinfo.hasnext );                 cabinfo.hasnext );
 } }
 #ifndef TVFS  
 FNREAD(real_read) {  
         int szBuffer = _read(hf,pv,cb);  
         printf("   FNREAD (read) just called with %d, %d, %d\n",hf, pv, cb);  
         printf("   FNREAD (read) returning size (%d)\n",szBuffer);  
         return szBuffer;  
 }  
 FNCLOSE(real_close) {  
         int closevalue = _close(hf);  
         printf("   FNCLOSE (real) just called with %d - returning %d\n",hf,closevalue);  
         return closevalue;  
 }  
   
 FNWRITE(real_write) {  
         int write_value = _write(hf, pv, cb);  
         printf("   FNWRITE just called with %d, %d, %d - returning %d\n",hf, pv, cb, write_value);  
         return write_value;  
 }  
   
 FNSEEK(real_seek) {  
         long lseek_value = _lseek(hf, dist, seektype);  
         printf("   FNSEEK just called with %d, %d, %d - returning %d\n",hf, dist, seektype,lseek_value);  
         return lseek_value;  
 }  
   
 FNOPEN(real_open) {  
         int handler = _open(pszFile,oflag,pmode);  
         printf("   FNOPEN (real) just called with %s, %d, %d\n",pszFile, oflag, pmode);  
         printf("   FNOPEN (real) returning handler (%d)\n",handler);  
         return handler;  
 }  
 #endif  
  
 static void CheckCabInfo(char *  cabname, static void CheckCabInfo(char *  cabname,
                                                  FDICABINETINFO cabinfo,                                                  FDICABINETINFO cabinfo,
Line 221 
Line 178 
         ok2 ( cabinfo.hasprev == Thasprev, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n", cabname);         ok2 ( cabinfo.hasprev == Thasprev, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n", cabname);
         ok2 ( cabinfo.hasnext == Thasnext, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n", cabname);         ok2 ( cabinfo.hasnext == Thasnext, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n", cabname);
                                                 }                                                 }
 HFDI hfdi_unknown_dummy, hfdi_unknown_tvfs;     /* TODO :  Message should contain variable values */
   
   static HFDI hfdi_simple;
 /* yes its global and ugly */ /* yes its global and ugly */
  
 /* Is CPU386 or Unknown more commonly used? */  
  
 static void TestCreate(void) { static void TestCreate(void) {
  
         ERF error_structure;         ERF error_structure;
  
         printf("Starting TestCreate()\n");      trace("Starting TestCreate()\n");
       /* Is CPU386 or Unknown more commonly used? */
         hfdi_unknown_dummy = FDICreate(      hfdi_simple = FDICreate(
                 final_alloc,  
                 final_free,  
                 dummy_open,  
                 dummy_read,  
                 dummy_write,  
                 dummy_close,  
                 dummy_seek,  
                 cpuUNKNOWN,  
                 &error_structure  
         );  
         ok(hfdi_unknown_dummy != NULL,"FDICreate (CPU = unknown) (functions=dummy) failed!\n");  
   
         hfdi_unknown_tvfs = FDICreate(  
                 final_alloc,                 final_alloc,
                 final_free,                 final_free,
 #ifdef TVFS  
                 tvfs_open, tvfs_read, tvfs_write, tvfs_close, tvfs_lseek,                 tvfs_open, tvfs_read, tvfs_write, tvfs_close, tvfs_lseek,
 #else  
                 real_open, real_read, real_write, real_close,real_seek,  
 #endif  
                 cpuUNKNOWN,                 cpuUNKNOWN,
                 &error_structure                 &error_structure
         );         );
         ok(hfdi_unknown_tvfs != NULL,"FDICreate (CPU = unknown) (functions=tvfs) failed!\n");  
  
         printf("Ending TestCreate()\n");      ok(hfdi_simple != NULL,"FDICreate (CPU = unknown) (functions=tvfs) failed!\n");
   
       trace("Ending TestCreate()\n");
 } }
  
 static void TestInfo(void) { static void TestInfo(void) {
 #ifdef TVFS  
         int fd;  
   
         FDICABINETINFO  fdi_cabinfo_dummy, fdi_cabinfo_simple, fdi_cabinfo_complex;  
  
         printf("Starting TestInfo()\n");      int fd;
  
         /* TEST : ERR filehandle associated, dummy functions should return FALSE */      FDICABINETINFO  fdi_cabinfo_simple;
         ok ( FDIIsCabinet( hfdi_unknown_dummy, -1, &fdi_cabinfo_dummy) == FALSE,  
                         "FDIIsCabinet (File = Error) failed!\n");  
  
       trace("Starting TestInfo()\n");
  
         tvfs_create( name_simple_cab, file_simple_cab, size_simple_cab);         tvfs_create( name_simple_cab, file_simple_cab, size_simple_cab);
         fd = tvfs_open( name_simple_cab, _O_BINARY, 0 );         fd = tvfs_open( name_simple_cab, _O_BINARY, 0 );
  
         ok( FDIIsCabinet( hfdi_unknown_tvfs, fd, &fdi_cabinfo_simple) == TRUE,      ok( FDIIsCabinet( hfdi_simple, fd, &fdi_cabinfo_simple) == TRUE,
                         "FDIIsCabinet (Virtual File = Simple.cab) failed!\n");                         "FDIIsCabinet (Virtual File = Simple.cab) failed!\n");
  
         printCabInfo(fdi_cabinfo_simple);         printCabInfo(fdi_cabinfo_simple);
                 CheckCabInfo("simple.cab",fdi_cabinfo_simple,121,1,1,0,0,0,0,0);                 CheckCabInfo("simple.cab",fdi_cabinfo_simple,121,1,1,0,0,0,0,0);
  
         tvfs_close(fd);         tvfs_close(fd);
   
   
         tvfs_create( name_complex_cab, file_complex_cab, size_complex_cab);  
         fd = tvfs_open( name_complex_cab, _O_BINARY, 0 );  
   
         ok( FDIIsCabinet( hfdi_unknown_tvfs, fd, &fdi_cabinfo_complex) == TRUE,  
                         "FDIIsCabinet (Virtual File = Complex.cab) failed!\n");  
   
         printCabInfo(fdi_cabinfo_complex);  
                 CheckCabInfo("complex.cab",fdi_cabinfo_complex,12918,1,2,0,0,0,0,0);  
   
         tvfs_close(fd);  
         tvfs_free();         tvfs_free();
  
         printf("Ending TestInfo()\n");      trace("Ending TestInfo()\n");
 #endif  
 } }
  
 static void TestCopy(void){ static void TestCopy(void){
Line 307 
Line 231 
         char name_file_path[256];         char name_file_path[256];
         int result;         int result;
  
         printf("Starting TestCopy()\n");      trace("Starting TestCopy()\n");
         printf("---simple.cab\n");      trace("---simple.cab\n");
 #ifdef TVFS  
         tvfs_create( name_simple_cab, file_simple_cab, size_simple_cab);         tvfs_create( name_simple_cab, file_simple_cab, size_simple_cab);
 #endif      FDICopy(hfdi_simple,
         FDICopy(hfdi_unknown_tvfs,  
                         "simple.cab",                         "simple.cab",
                         "",                         "",
                         0,                         0,
Line 320 
Line 243 
                         NULL,                         NULL,
                         NULL);                         NULL);
  
 #ifdef TVFS  
         /* Filename when extracted is ./<filename> */         /* Filename when extracted is ./<filename> */
         sprintf(name_file_path, "./%s", name_simple_txt);         sprintf(name_file_path, "./%s", name_simple_txt);
         result = tvfs_compare(name_file_path, file_simple_txt, size_simple_txt);         result = tvfs_compare(name_file_path, file_simple_txt, size_simple_txt);
         if (result)         if (result)
                 printf ("File compare failed!\n");          trace ("File %s compare failed!\n",name_file_path);
         tvfs_free();         tvfs_free();
 #endif  
   
  
         printf("---complex.cab\n");      trace("Ending TestCopy()\n");
 #ifdef TVFS  
         tvfs_create( name_complex_cab, file_complex_cab, size_complex_cab);  
 #endif  
         FDICopy(hfdi_unknown_tvfs,  
                         "complex.cab",  
                         "",  
                         0,  
                         notification_function,  
                         NULL,  
                         NULL);  
   
 #ifdef TVFS  
         /* Filename when extracted is ./<filename> */  
         sprintf(name_file_path, "./%s", name_README);  
         result = tvfs_compare(name_file_path, file_README, size_README);  
         if (result)  
                 printf ("File compare failed!\n");  
         tvfs_free();  
 #endif  
   
   
   
         printf("Ending TestCopy()\n");  
 } }
  
 static void TestDestroy(void) { static void TestDestroy(void) {
         printf("Starting TestDestroy()\n");      trace("Starting TestDestroy()\n");
       ok(FDIDestroy(hfdi_simple), "FDIDestroy (CPU = unknown) (functions=tvfs) failed!\n");
         ok(FDIDestroy(hfdi_unknown_dummy), "FDIDestroy (CPU = unknown) (functions=fake) failed!\n");      trace("Ending TestDestroy()\n");
         ok(FDIDestroy(hfdi_unknown_tvfs), "FDIDestroy (CPU = unknown) (functions=tvfs) failed!\n");  
         printf("Ending TestDestroy()\n");  
 } }
  
 START_TEST(paths)  START_TEST(cabinet_fdi)
 { {
         TestCreate();         TestCreate();
         TestInfo();         TestInfo();

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