(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 1.3 and 2.4

version 1.3, 2005/02/04 09:17:22 version 2.4, 2005/02/15 09:34:28
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 <stdlib.h> #include <stdlib.h>
   #include <string.h>
   #include <sys/stat.h>
  
 #ifndef STANDALONE #ifndef STANDALONE
 #include <wine/test.h> #include <wine/test.h>
Line 43 
Line 44 
 #define todo_wine #define todo_wine
 #endif #endif
  
   
 #include <winerror.h> #include <winerror.h>
 #include <fdi.h> #include <fdi.h>
   #include <fcntl.h>
   #include "cabinet_files.h"
   
   /* Do malloc and free output debug messages?
   #define DEBUG_ALLOC
   */
   
   /* What is our "Fake" Filedescriptors? */
   static int fakeFD_simple = 22881;
   static int fakeFD_complexzip2 = 22882;
   static int fakeFD_complexlzw2 = 22883;
   static int fakeFD_broken = 22884;
   
   /*
      This hex data is the output of makecab.exe (Windows Cabinet SDK/bin)
      ****** IS USING THE OUTPUT OF A NON LGPL program okay ******
   
      The cab file is mirrored in the file system as simple.cab
   
      The 'test.txt' in the cab file contains the string 'So long, and thanks for all the fish.'
   
      The files in the "cabinet_files.h" were created with hexify.sh
   */
   /*
           Multiple File Cabs are included, as cabinet.dll supports multiple file archive types.
           The compressed file size had to be greater than 50k, cabarc restricts 'diskette spanning' to
             archives above 50k.
           The peculiar options were selected specifically to test cabinet.dll more throughly.
  
 /*      To do in FDI:                           -from wine/include/fdi.h          complex_lzw.cab         cabarc -m LZX:16 -pr -i 32356 N complex_lzw.cab amontillado.txt lgpl.txt gpl.txt midsummer\*
           complex_lzw2.cab        cabarc -m LZX:17 -d 50000 -pr -i 32356 N complex_lzw*.cab amontillado.txt + lgpl.txt gpl.txt midsummer\*
   
           complex_zip.cab         cabarc -m MSZIP -pr -i 32356 N complex_lzw.cab amontillado.txt lgpl.txt gpl.txt midsummer\*
           complex_zip2.cab        cabarc -m MSZIP -d 50000 -pr -i 32356 N complex_zip*.cab amontillado.txt + lgpl.txt gpl.txt midsummer\*
   
           complex_none.cab        cabarc -m NONE -pr -i 32356 N complex_none.cab amontillado.txt midsummer\act1*
   
   /*
           To do in FDI:                           -from wine/include/fdi.h
         FDICreate         FDICreate
                 Memory Allocation               -FNALLOC(cb)  
                 Memory Free                             -FNFREE(pv)  
                 File Open                               -FNOPEN(pszFile,oflag,pmode)  
                 File Read                               -FNREAD(hf, pv, cb)  
                 File Write                              -FNWRITE(hf, pv, cb)                 File Write                              -FNWRITE(hf, pv, cb)
                 File Close                              -FNCLOSE(hf)  
                 File Seek                               -FNSEEK(hf,dist,seektype)                 File Seek                               -FNSEEK(hf,dist,seektype)
                 Error Structure                 Error Structure
         FDIlsCabinet  
                 FDICabinetInfo Structure  
         FDICopy         FDICopy
                 Notification function                 Notification function
                 Decryption function                 Decryption function
         FDIDestroy         FDIDestroy
 */ */
  
 /* Currently dummy function pointers */  #ifndef DEBUG_ALLOC
   FNALLOC(final_alloc) {
 FNALLOC(dummy_alloc) {          return malloc(cb);
   }
   FNFREE(final_free) {
           free(pv);
           return;
   }
   #else
   FNALLOC(final_alloc) {
         printf("FNALLOC just called with %d\n",cb);         printf("FNALLOC just called with %d\n",cb);
         return 0;          return malloc(cb);
 } }
   FNFREE(final_free) {
 FNFREE(dummy_free) {  
         printf("FNFREE just called with %d\n",pv);         printf("FNFREE just called with %d\n",pv);
           free(pv);
         return;         return;
 } }
   #endif
   
   
   /*
           Match i/o specs of _open, _read, _write, _close, and _lseek.
   */
   
   /*
           http://msdn.microsoft.com/library/en-us/vclib/html/_crt__open.2c_._wopen.asp
           _open           I: const char *filename, int oflag, int pmode   O: int (handler), -1 for err.
           DUMMY  : FUNCTIONAL             FAKE : FUNCTIONAL               REAL : FUNCTIONAL
   */
  
 FNOPEN(dummy_open) { FNOPEN(dummy_open) {
          printf("FNOPEN just called with %d, %d, %d\n",pszFile, oflag, pmode);          printf("  FNOPEN (dummy) just called with %d, %d, %d\n",pszFile, oflag, pmode);
         return 0;         return 0;
 } }
  
   FNOPEN(fake_open) {
           printf("  FNOPEN (virtual) just called with %d, %d, %d\n",pszFile, oflag, pmode);
           printf("  Returning %d as file descriptor\n",12);
           return 12;
   }
   
   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;
   }
   
   /*
           http://msdn.microsoft.com/library/en-us/vclib/html/_CRT__read.asp
           _read           I: int fd, void *buffer, unsigned int count             O:      int (szBuffer)
           DUMMY  : FUNCTIONAL             FAKE : FUNCTIONAL, INCOMPLETE           REAL : FUNCTIONAL
   */
   
 FNREAD(dummy_read) { FNREAD(dummy_read) {
 /*       printf("FNREAD just called with %d, %d, %d\n",hf, pv, cb);          printf("   FNREAD (dummy) just called with %d, %d, %d\n",hf, pv, cb);
          return void;          return 0;
 */      return 0;  
 } }
  
 FNWRITE(dummy_write) {  /* Doesn't keep virtual file location pointer */
 /*       printf("FNWRITE just called with %d, %d, %d\n",hf, pv, cb);  FNREAD(fake_read) {
          return void;          printf("   FNREAD (virtual) just called with %d, %d, %d\n",hf, pv, cb);
 */      return 0;          switch (hf)
           {
                   /* Const int doesnt count as constant for cases --- why? */
                   case 22881:
                           {
                                   printf ("   Called fake file descriptor %d (file_simple_cab),\n\tpopulating buffer and size (%d)\n",hf,cb);
                                   memcpy (pv, file_simple_cab ,cb);
                                   break;
                           }
                   case 22882:
                           {
                                   printf ("   Called fake file descriptor %d (file_complex_zip2_cab),\n\tpopulating buffer and size (%d)\n",hf,cb);
                                   memcpy (pv, file_complex_zip2_cab ,cb);
                                   break;
                           }
                   case 22883:
                           {
                                   printf ("   Called fake file descriptor %d (file_complex_lzw2_cab),\n\tpopulating buffer and size (%d)\n",hf,cb);
                                   memcpy (pv, file_complex_lzw2_cab ,cb);
                                   break;
                           }
                   case 22884:
                           {
                                   printf ("   Called fake file descriptor %d (file_broken_cab),\n\tpopulating buffer and size (%d)\n",hf,cb);
                                   memcpy (pv, file_broken_cab ,cb);
                                   break;
                           }
                   default:
                           {
                                   printf ("   FNREAD (virtual) was called with the unknown file handler. Failed!\n",hf);
                                   return -1;
                           }
           }
           printf("     Returning %d\n",cb);
           return cb;
   }
   
   
   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;
 } }
  
   /*
           http://msdn.microsoft.com/library/en-us/vclib/html/_CRT__close.asp
           _close          I: int fd   O:  int (0=success 1=failure)
           DUMMY  : FUNCTIONAL             FAKE : FUNCTIONAL               REAL : FUNCTIONAL
   */
  
 FNCLOSE(dummy_close) { FNCLOSE(dummy_close) {
 /*       printf("FNCLOSE just called with %d\n",hf);          printf("   FNCLOSE (dummy) just called with %d - returning %d\n",hf,0);
         return void;          return 0;
 */      return 0;  }
   
   FNCLOSE(fake_close) {
           printf("   FNCLOSE (virtual) just called with %d - returning %d\n",hf,0);
           return 0;
   }
   
   FNCLOSE(real_close) {
           int closevalue = _close(hf);
           printf("   FNCLOSE (real) just called with %d - returning %d\n",hf,closevalue);
           return closevalue;
   }
   
   
   
   
   
   FNWRITE(dummy_write) {
           printf("   FNWRITE just called with %d, %d, %d\n",hf, pv, cb);
           return 0;
   }
   
   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(dummy_seek) { FNSEEK(dummy_seek) {
 /*       printf("FNSEEK just called with %d, %d, %d\n",hf, dist, seektype);          printf("   FNSEEK just called with %d, %d, %d\n",hf, dist, seektype);
         return void;          return 0;
 */      return 0;  
 } }
  
 static void TestDestroy(void) {  FNSEEK(real_seek) {
         /* Only two things to check in FDIDestroy          long lseek_value = _lseek(hf, dist, seektype);
            1=> Does it return T if its passed an hfdi          printf("   FNSEEK just called with %d, %d, %d - returning %d\n",hf, dist, seektype,lseek_value);
            2=> Does it return F if its passed a non hfdi          return lseek_value;
   }
   
   
   
   
   
   FNFDINOTIFY(dummy_notification){
           printf("   FNFDINOTIFY just called with %d, %d \n",fdint,pfdin);
           return 0;
   }
   
   FNFDINOTIFY(notification_function)
   {
           printf("   FNFDINOTIFY real just called with %d, %d \n",fdint,pfdin);
           switch (fdint)
           {
                   case fdintCABINET_INFO:
                   {
                           printf("fdintCABINET_INFO\n");
                           return 0;
                   }
                   case fdintPARTIAL_FILE:
                   {
                           printf("dintPARTIAL_FILE\n");
                           return 0;
                   }
                   case fdintCOPY_FILE:
                   {
                           int fih = 0;
                           char target[256];
   
                           printf("fdintCOPY_FILE\n");
                           printf("  file name: %s\n",     pfdin->psz1);
                           sprintf(target, "./%s",pfdin->psz1);
                           printf("%s\n",target);
   
                                   fih = real_open(
                                           target,
                                           _O_BINARY | _O_CREAT | _O_WRONLY | _O_SEQUENTIAL,
                                           _S_IREAD | _S_IWRITE
                                           );
   
                           return fih;
                   }
   
   
                   case fdintCLOSE_FILE_INFO:
                   {
   
                           printf("fdintCLOSE_FILE_INFO\n");
                           return 0;
                   }
                   case fdintNEXT_CABINET:
                   {
   
                           printf("fdintNEXT_CABINET\n");
                           return 0;
                   }
                   case fdintENUMERATE:
                   {
                                   printf("fdintENUMERATE\n");
                                   return 0;
                   }
           }
           return 0;
   }
   
   
   
   
   static void printCabInfo(FDICABINETINFO  cabinfo){
           //printf("INSIDE PRINT CABINFO\n");
                   printf("   Cabinet Data : cbC %d cF %d cFi %d si %d iC %d fr %d hp %d hn %d\n",
                   cabinfo.cbCabinet,
                   cabinfo.cFolders ,
                   cabinfo.cFiles ,
                   cabinfo.setID,
                   cabinfo.iCabinet,
                   cabinfo.fReserve ,
                   cabinfo.hasprev ,
                   cabinfo.hasnext );
   }
   
   
   static void CheckCabInfo(char *  cabname,
                                                    FDICABINETINFO cabinfo,
                                                    long        TcbCabinet,
                                                    USHORT      TcFolders,
                                                    USHORT      TcFiles,
                                                    USHORT      TsetID,
                                                    USHORT      TiCabinet,
                                                    BOOL        TfReserve,
                                                    BOOL        Thasprev,
                                                    BOOL        Thasnext){
                                                            ok2 ( cabinfo.cbCabinet == TcbCabinet, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n", cabname);
                                                            ok2 ( cabinfo.cFolders == TcFolders, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n", cabname);
                                                            ok2 ( cabinfo.cFiles == TcFiles, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n", cabname);
                                                            ok2 ( cabinfo.setID == TsetID, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n", cabname);
                                                            ok2 ( cabinfo.iCabinet == TiCabinet, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n", cabname);
                                                            ok2 ( cabinfo.fReserve == TfReserve, "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);
                                                   }
   
   
   /* Tried to enhance functionality with :
   
   
           ok4 ( cabinfo.cbCabinet == TcbCabinet, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n\tExpected %d, got %d for cbCabinet\n", cabname, TcbCabinet, cabinfo.cbCabinet );
            ok4 ( cabinfo.cFolders == TcFolders, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n\tExpected %d, got %d for cFolders\n", cabname,TcFolders,cabinfo.cFolders);
            ok4 ( cabinfo.cFiles == TcFiles, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n\tExpected %d, got %d for cFiles\n", cabname,TcFiles,cabinfo.cFiles);
            ok4 ( cabinfo.setID == TsetID, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n\tExpected %d, got %d for setID\n", cabname,TsetID.cabinfo.setID);
            ok4 ( cabinfo.iCabinet == TiCabinet, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n\tExpected %d, got %d for iCabinet\n", cabname,TiCabinet,cabinfo.iCabinet);
            ok4 ( cabinfo.fReserve == TfReserve, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n\tExpected %d, got %d for fReserve\n", cabname,TfReserve,cabinfo.fReserve);
            ok4 ( cabinfo.hasprev == Thasprev, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n\tExpected %d, got %d for hasprev\n", cabname,Thasprev,cabinfo.hasprev );
            ok4 ( cabinfo.hasnext == Thasnext, "FDIIsCabinet,cabinfo %s data did not match! Failed!\n\tExpected %d, got %d for Thasnext\n", cabname,Thasnext,cabinfo.hasnext);
           #define ok4(condition, msg, arg, arb, arc) \
           do { if(!(condition)) {  \
                   fprintf(stderr,"failed at %d, msg:" msg "\n",__LINE__, arg, arb, arc); \
                   exit(1);         \
           } } while(0)
   
   
            But it didn't really work, and its too late to fix it for now */
   
   
   
   HFDI hfdi_unknown_dummy, hfdi_unknown_fake,hfdi_unknown_real;
   /* yes its global and ugly */
   
   /* Is CPU386 or Unknown more commonly used? */
   
   static void TestCreate(void) {
   
           ERF error_structure;
   
           printf("Starting TestCreate()\n");
   
           hfdi_unknown_dummy = 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_fake = FDICreate(
                   final_alloc,
                   final_free,
                   fake_open,
                   fake_read,
                   dummy_write,
                   dummy_close,
                   dummy_seek,
                   cpuUNKNOWN,
                   &error_structure
           );
           ok(hfdi_unknown_fake != NULL,"FDICreate (CPU = unknown) (functions=fake) failed!\n");
   
           hfdi_unknown_real = FDICreate(
                   final_alloc,
                   final_free,
                   real_open,
                   real_read,
                   real_write,
                   real_close,
                   real_seek,
                   cpuUNKNOWN,
                   &error_structure
           );
           ok(hfdi_unknown_real != NULL,"FDICreate (CPU = unknown) (functions=real) failed!\n");
   
           printf("Ending TestCreate()\n");
   }
   
   
   
   
   static void TestInfo(void) {
           /* Noticed Behavior :
                   FDIIsCabinet does not open the file on its own, it requires a file open/close to be done externally.
                           WHY?
                   The only functions in HFDI that FDIIsCabinet directly accesses is FNREAD
                   Important cases to check :
                           If the filedescriptor == ERR, does it FAIL?                                                     (dummy_read)
                           If the filedescriptor == NOTCABINET, does it FAIL?                                      (fake_read, real_read)
                           If the filedescriptor == CABINET, does it SUCCEED?                                      (fake_read, real_read)
                           If the filedescriptor == CABINET, does it populate FDICABINETINFO?      (fake_read, real_read)
         */         */
  
         ok( 0 == FDIDestroy(0), "Return true incorrectly in TestDestroy()!\n");          int realfd;
           int sizer;
           FDICABINETINFO  fdi_cabinfo_dummy, fdi_cabinfo_simple, fdi_cabinfo_complex;
   
           printf("Starting TestInfo()\n");
   
           /* TEST : ERR filehandle associated, dummy functions should return FALSE */
           ok ( FDIIsCabinet( hfdi_unknown_dummy, -1, &fdi_cabinfo_dummy) == FALSE,
                           "FDIIsCabinet (File = Error) failed!\n");
   
           /* TEST : Fake filehandle associated, memory manually copied, should return TRUE */
           ok ( FDIIsCabinet( hfdi_unknown_fake, fakeFD_simple, &fdi_cabinfo_simple) == TRUE,
                           "FDIIsCabinet (Virtual File = Cabinet) failed!\n");
   
                   CheckCabInfo("simple.cab",fdi_cabinfo_simple,117,1,1,12345,0,0,0,0);
   
         /*         /*
                 TODO : check if its passed an hfdi             Is it ok to reuse the same hfdi_unknown_real ? */
   
           /* TEST : Opened filehandle associated, corrupted cab loaded, should return FALSE */
           /* We can see that the Windows implementation only reads the first 36 bytes - what if we corrupted a CAB after 36 bytes?*/
   
   
           /* Testing broken cab - using virtual file reads */
           ok ( FDIIsCabinet( hfdi_unknown_fake, fakeFD_broken, &fdi_cabinfo_simple) == FALSE,
                           "FDIIsCabinet (Virtual File = Bad-Cabinet) failed!\n");
   
           realfd = real_open( "cabinet_fdi.c" , _O_BINARY | _O_RDONLY | _O_SEQUENTIAL, 0);
   
           ok ( FDIIsCabinet( hfdi_unknown_real, realfd, &fdi_cabinfo_complex) == FALSE,
                           "FDIIsCabinet (File = Non-Cabinet) cabinet_fdi.c failed!\n");
           real_close(realfd);
   
   
                   CheckCabInfo("simple.cab",fdi_cabinfo_simple,117,1,1,12345,0,0,0,0);
   
   
           /* TEST : Opened filehandle associated, valid cab loaded, should return TRUE */
           realfd = real_open( "complex_lzw.cab" , _O_BINARY | _O_RDONLY | _O_SEQUENTIAL, 0);
   
           ok ( FDIIsCabinet( hfdi_unknown_real, realfd, &fdi_cabinfo_complex) == TRUE,
                           "FDIIsCabinet (File = Cabinet) complex_lzw.cab failed!\n");
           real_close(realfd);
   
           printCabInfo(fdi_cabinfo_complex);
   
   
           ok ( FDIIsCabinet( hfdi_unknown_fake, fakeFD_complexlzw2, &fdi_cabinfo_complex) == TRUE,
                   "FDIIsCabinet (Virtual File = Cabinet) complex_lzw2.cab failed!\n");
   
           printCabInfo(fdi_cabinfo_complex);
   
           CheckCabInfo("complex_lzw2",fdi_cabinfo_complex,3513,1,1,32356,1,0,1,0);
   
   
   
           realfd = real_open( "complex_zip.cab" , _O_BINARY | _O_RDONLY | _O_SEQUENTIAL, 0);
   
           ok ( FDIIsCabinet( hfdi_unknown_real, realfd, &fdi_cabinfo_complex) == TRUE,
                           "FDIIsCabinet (File = Cabinet) complex_zip.cab failed!\n");
           real_close(realfd);
   
           printCabInfo(fdi_cabinfo_complex);
   
   
           ok ( FDIIsCabinet( hfdi_unknown_fake, fakeFD_complexzip2, &fdi_cabinfo_complex) == TRUE,
                   "FDIIsCabinet (Virtual File = Cabinet) complex_zip2.cab failed!\n");
   
           printCabInfo(fdi_cabinfo_complex);
   
           CheckCabInfo("complex_zip2",fdi_cabinfo_complex,6995,1,4,32356,1,0,1,0);
   
   
           realfd = real_open( "complex_none.cab" , _O_BINARY | _O_RDONLY | _O_SEQUENTIAL, 0);
   
           ok ( FDIIsCabinet( hfdi_unknown_real, realfd, &fdi_cabinfo_complex) == TRUE,
                           "FDIIsCabinet (File = Cabinet) complex_zip.cab failed!\n");
           real_close(realfd);
   
   
           printCabInfo(fdi_cabinfo_complex);
   
   
   }
   
   /* Peer cooment : really_shouldn't use relative paths in FDICopy call --- doing // doesn't work as a comment in C fyi
      */
   
   static void TestCopy(void){
           printf("Starting TestCopy()\n");
           printf("---simple.cab\n");
           FDICopy(hfdi_unknown_real,
                           "simple.cab",
                           "./",
                           //"C:\\cygwin\\home\\Administrator\\group3\\wine\\dlls\\cabinet\\tests\\",
                           0,
                           notification_function,
                           NULL,
                           NULL);
           /*printf("---complex_none.cab\n");
           FDICopy(hfdi_unknown_real,
                   "complex_none.cab",
                   "C:\\cygwin\\home\\Administrator\\group3\\wine\\dlls\\cabinet\\tests\\",
                   0,
                   notification_function,
                   NULL,
                   NULL);
           printf("---complex_zip.cab\n");
       FDICopy(hfdi_unknown_real,
                   "complex_zip.cab",
                   "C:\\cygwin\\home\\Administrator\\group3\\wine\\dlls\\cabinet\\tests\\",
                   0,
                   notification_function,
                   NULL,
                   NULL);
           printf("---complex_lzw.cab\n");
           FDICopy(hfdi_unknown_real,
                   "complex_lzw.cab",
                   "C:\\cygwin\\home\\Administrator\\group3\\wine\\dlls\\cabinet\\tests\\",
                   0,
                   notification_function,
                   NULL,
                   NULL);
                 */                 */
   
           printf("Ending TestCopy()\n");
 } }
  
  
   static void TestDestroy(void) {
           printf("Starting TestDestroy()\n");
                   /* Should return TRUE if given a valid hfdi, else FALSE (only due to context errors?) */
   
           ok(FDIDestroy(hfdi_unknown_dummy), "FDIDestroy (CPU = unknown) (functions=fake) failed!\n");
           ok(FDIDestroy(hfdi_unknown_fake), "FDIDestroy (CPU = unknown) (functions=fake) failed!\n");
           ok(FDIDestroy(hfdi_unknown_real), "FDIDestroy (CPU = unknown) (functions=real) failed!\n");
           printf("Ending TestDestroy()\n");
   
   }
   
 START_TEST(paths) START_TEST(paths)
 { {
         /*  
         TestCreate();         TestCreate();
         TestInfo();         TestInfo();
         TestCopy();         TestCopy();
         */  
         TestDestroy();         TestDestroy();
   
 } }

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