(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.7 and 2.3

version 1.7, 2005/02/11 08:50:58 version 2.3, 2005/02/15 08:21:13
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 <windows.h>
 #include <stdlib.h> #include <stdlib.h>
   #include <string.h>
   //#include <io.h>
   //#include <fcntl.h>
   //#include <dos.h>
   #include <sys/stat.h>
  
 #ifndef STANDALONE #ifndef STANDALONE
 #include <wine/test.h> #include <wine/test.h>
Line 46 
Line 52 
 #include <fdi.h> #include <fdi.h>
 #include <fcntl.h> #include <fcntl.h>
  
 static int fakeFD = 12;  /* Do malloc and free output debug messages?
   #define DEBUG_ALLOC
 /* This is the hex string representation of the file created by compressing  */
    a simple text file with the contents "This is a test file."  
  
    The file was created using COMPRESS.EXE from the Windows Server 2003  /* What is our "Fake" Filedescriptor? */
    Resource Kit from Microsoft.  The resource kit was retrieved from the  static int fakeFD = 22881;
    following URL:  
  
    http://www.microsoft.com/downloads/details.aspx?FamilyID=9d467a69-57ff-4ae7-96ee-b18c4790cffd&displaylang=en  /*
  */     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.'
   */
 static unsigned char compressed_file[] = static unsigned char compressed_file[] =
    {0x4D,0x53,0x43,0x46,0x00,0x00,0x00,0x00,0x75,0x00,    {0x4D,0x53,0x43,0x46,0x00,0x00,0x00,0x00,0x75,0x00,
         0x00,0x00,0x00,0x00,0x00,0x00,0x2C,0x00,0x00,0x00,         0x00,0x00,0x00,0x00,0x00,0x00,0x2C,0x00,0x00,0x00,
Line 75 
Line 83 
 static int szcompressed_file = sizeof(compressed_file); static int szcompressed_file = sizeof(compressed_file);
  
  /*  /*
 static const char uncompressed_data[] = "This is a test file.";          Multiple File Cabs are included, as cabinet.dll supports multiple file archive types.
 static const DWORD uncompressed_data_size = sizeof(uncompressed_data) - 1;          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.
  
 static char *buf;          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\*
  
 /*      To do in FDI:                           -from wine/include/fdi.h          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
                 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
 */ */
  
         FDICABINETINFO  fdici;  #ifndef DEBUG_ALLOC
   FNALLOC(final_alloc) {
           return malloc(cb);
 /* Currently mostly dummy function pointers */  }
   FNFREE(final_free) {
 FNALLOC(debug_alloc) {          free(pv);
           return;
   }
   #else
   FNALLOC(final_alloc) {
         printf("   FNALLOC just called with %d\n",cb);         printf("   FNALLOC just called with %d\n",cb);
         return malloc(cb);         return malloc(cb);
 } }
   FNFREE(final_free) {
 FNFREE(debug_free) {  
         printf("   FNFREE just called with %d\n",pv);         printf("   FNFREE just called with %d\n",pv);
         free(pv);         free(pv);
         return;         return;
 } }
   #endif
  
 /*  
         It is not necessary for these functions to actually call _open etc.;  
         these functions could instead call fopen, fread, fwrite, fclose, and fseek,  
         or CreateFile, ReadFile, WriteFile, CloseHandle, and SetFilePointer, etc.  
         However, the parameters and return codes will have to be translated  
         appropriately (e.g. the file open mode passed in to pfnopen).  
  
   /*
         Match i/o specs of _open, _read, _write, _close, and _lseek.         Match i/o specs of _open, _read, _write, _close, and _lseek.
   
 */ */
  
 /* /*
         http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_crt__open.2c_._wopen.asp          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.         _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) {
Line 147 
Line 157 
         return handler;         return handler;
 } }
  
   
 /* /*
         http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_crt__open.2c_._wopen.asp          http://msdn.microsoft.com/library/en-us/vclib/html/_CRT__read.asp
         _read           I: int fd, void *buffer, unsigned int count             O:      int (szBuffer)         _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) {
Line 158 
Line 168 
         return 0;         return 0;
 } }
  
   /* Doesn't keep virtual file location pointer */
 FNREAD(fake_read) { FNREAD(fake_read) {
          printf("   FNREAD (fake) just called with %d, %d, %d\n",hf, pv, cb);          printf("   FNREAD (fake) just called with %d, %d, %d\n",hf, pv, cb);
          if (hf == fakeFD) {          if (hf == fakeFD) {
                  printf ("   Called with fake file descriptor, populating buffer and size (%d)\n",szcompressed_file);                  printf ("   Called with fake file descriptor, populating buffer and size (%d)\n",cb);
                  memcpy (pv, compressed_file ,cb);                  memcpy (pv, compressed_file ,cb);
                  /* TODO */  
                  }                  }
          else {          else {
                  printf ("   FNREAD (fake) was called with the unknown file handler. Failed!\n",hf);                  printf ("   FNREAD (fake) was called with the unknown file handler. Failed!\n",hf);
          }          }
         return szcompressed_file;          return cb;
 } }
  
 FNREAD(real_read) { FNREAD(real_read) {
Line 178 
Line 188 
         return 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) {
           printf("   FNCLOSE (dummy) just called with %d - returning %d\n",hf,0);
           return 0;
   }
  
 FNWRITE(dummy_write) {  FNCLOSE(fake_close) {
          printf("   FNWRITE just called with %d, %d, %d\n",hf, pv, cb);          printf("   FNCLOSE (fake) just called with %d - returning %d\n",hf,0);
         return 0;         return 0;
 } }
  
   FNCLOSE(real_close) {
           int closevalue = _close(hf);
           printf("   FNCLOSE (real) just called with %d - returning %d\n",hf,closevalue);
           return closevalue;
   }
  
 FNCLOSE(dummy_close) {  
          printf("   FNCLOSE just called with %d\n",hf);  
   
   
   FNWRITE(dummy_write) {
           printf("   FNWRITE just called with %d, %d, %d\n",hf, pv, cb);
         return 0;         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 0;         return 0;
 } }
  
   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;
   }
   
   
   
   
   
   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 %b 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);
                                                   }
   
   
   
   
 HFDI hfdi_unknown_dummy, hfdi_unknown_fake,hfdi_unknown_real; HFDI hfdi_unknown_dummy, hfdi_unknown_fake,hfdi_unknown_real;
 FDICABINETINFO  fdi_cabinfo;  
 /* 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) {
  
Line 208 
Line 356 
         printf("Starting TestCreate()\n");         printf("Starting TestCreate()\n");
  
         hfdi_unknown_dummy = FDICreate(         hfdi_unknown_dummy = FDICreate(
                 debug_alloc,                  final_alloc,
                 debug_free,                  final_free,
                 dummy_open,                 dummy_open,
                 dummy_read,                 dummy_read,
                 dummy_write,                 dummy_write,
Line 221 
Line 369 
         ok(hfdi_unknown_dummy != NULL,"FDICreate (CPU = unknown) (functions=dummy) failed!\n");         ok(hfdi_unknown_dummy != NULL,"FDICreate (CPU = unknown) (functions=dummy) failed!\n");
  
         hfdi_unknown_fake = FDICreate(         hfdi_unknown_fake = FDICreate(
                 debug_alloc,                  final_alloc,
                 debug_free,                  final_free,
                 fake_open,                 fake_open,
                 fake_read,                 fake_read,
                 dummy_write,                 dummy_write,
Line 234 
Line 382 
         ok(hfdi_unknown_fake != NULL,"FDICreate (CPU = unknown) (functions=fake) failed!\n");         ok(hfdi_unknown_fake != NULL,"FDICreate (CPU = unknown) (functions=fake) failed!\n");
  
         hfdi_unknown_real = FDICreate(         hfdi_unknown_real = FDICreate(
                 debug_alloc,                  final_alloc,
                 debug_free,                  final_free,
                 real_open,                 real_open,
                 real_read,                 real_read,
                 dummy_write,                  real_write,
                 dummy_close,                  real_close,
                 dummy_seek,                  real_seek,
                 cpuUNKNOWN,                 cpuUNKNOWN,
                 &error_structure                 &error_structure
         );         );
Line 249 
Line 397 
         printf("Ending TestCreate()\n");         printf("Ending TestCreate()\n");
 } }
  
   
   
   
 static void TestInfo(void) { 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)
           */
   
         int realfd;         int realfd;
         int sizer;         int sizer;
         char *buffer = malloc(szcompressed_file);          FDICABINETINFO  fdi_cabinfo_dummy, fdi_cabinfo_simple, fdi_cabinfo_complex;
  
         printf("Starting TestInfo()\n");         printf("Starting TestInfo()\n");
                 /*  
                 1=> Does it return T (and fill FDICABINETINFO) if the file descriptor=>cabinet?          /* TEST : ERR filehandle associated, dummy functions should return FALSE */
                 2=> Does it return F (and ignore FDICABINETINFO) if the file descriptor != cabinet?          ok ( FDIIsCabinet( hfdi_unknown_dummy, -1, &fdi_cabinfo_dummy) == FALSE,
                 3=> Does it return F (and ignore FDICABINETINFO) if the file descriptor == error?  
                                 */  
         ok ( FDIIsCabinet( hfdi_unknown_dummy, -1, &fdi_cabinfo) == FALSE,  
                         "FDIIsCabinet (File = Error) failed!\n");                         "FDIIsCabinet (File = Error) failed!\n");
  
         ok ( FDIIsCabinet( hfdi_unknown_fake, fakeFD, &fdi_cabinfo) == FALSE,          /* TEST : Fake filehandle associated, memory manually copied, should return TRUE */
                         "FDIIsCabinet (File = WrongType) failed!\n");          ok ( FDIIsCabinet( hfdi_unknown_fake, fakeFD, &fdi_cabinfo_simple) == TRUE,
                           "FDIIsCabinet (FakeFile = Cabinet) failed!\n");
   
                   CheckCabInfo("simple.cab",fdi_cabinfo_simple,117,1,1,12345,0,0,0,0);
  
         sizer = fake_read ( 12,buffer,szcompressed_file );          /* simply this with macros?
         printf(buffer);                 yes, make one macro with inputs (cabname, testname, [expected values] ) --- using lambda notation
              add checks for cabinfo data!
              Is it ok to reuse the same hfdi_unknown_real ? */
  
         realfd = real_open( "TEST1.cab" , _O_BINARY | _O_RDONLY | _O_SEQUENTIAL, 0);          /* TEST : Opened filehandle associated, corrupted cab loaded, should return FALSE */
         ok ( FDIIsCabinet( hfdi_unknown_real, realfd, &fdi_cabinfo) == TRUE,          /* We can see that the Windows implementation only reads the first 36 bytes - what if we corrupted a CAB after 36 bytes?*/
                         "FDIIsCabinet (File = Cabinet) failed!\n");  
  
           realfd = real_open( "broken.cab" , _O_BINARY | _O_RDONLY | _O_SEQUENTIAL, 0);
  
           ok ( FDIIsCabinet( hfdi_unknown_real, realfd, &fdi_cabinfo_complex) == FALSE,
                           "FDIIsCabinet (File = Bad-Cabinet) broken.cab failed!\n");
           real_close(realfd);
   
           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);
   
   
           /* 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);
   
           realfd = real_open( "complex_lzw2.cab" , _O_BINARY | _O_RDONLY | _O_SEQUENTIAL, 0);
   
           ok ( FDIIsCabinet( hfdi_unknown_real, realfd, &fdi_cabinfo_complex) == TRUE,
                           "FDIIsCabinet (File = Cabinet) complex_lzw2.cab failed!\n");
           real_close(realfd);
   
           printCabInfo(fdi_cabinfo_complex);
   
           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);
   
           realfd = real_open( "complex_zip2.cab" , _O_BINARY | _O_RDONLY | _O_SEQUENTIAL, 0);
   
           ok ( FDIIsCabinet( hfdi_unknown_real, realfd, &fdi_cabinfo_complex) == TRUE,
                           "FDIIsCabinet (File = Cabinet) complex_zip2.cab failed!\n");
           real_close(realfd);
   
   
           printCabInfo(fdi_cabinfo_complex);
   
           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);
   
   
   }
   
   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) { static void TestDestroy(void) {
         printf("Starting TestDestroy()\n");         printf("Starting TestDestroy()\n");
                 /* Only two things to check in FDIDestroy                  /* Should return TRUE if given a valid hfdi, else FALSE (only due to context errors?) */
            1=> Does it return T if its passed an hfdi  
            2=> Does it return F if its passed a non hfdi  
                 EDIT : Causes GPL if FDIDestroy is called on an invalid pointer.  
                 ok( 0 == FDIDestroy(0), "Return true incorrectly in TestDestroy()!\n");  
                 */  
  
         ok(FDIDestroy(hfdi_unknown_dummy), "FDIDestroy (CPU = unknown) (functions=fake) failed!\n");         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_fake), "FDIDestroy (CPU = unknown) (functions=fake) failed!\n");
           ok(FDIDestroy(hfdi_unknown_real), "FDIDestroy (CPU = unknown) (functions=real) failed!\n");
         printf("Ending TestDestroy()\n");         printf("Ending TestDestroy()\n");
  
 } }
  
   
 START_TEST(paths) START_TEST(paths)
 { {
   
         TestCreate();         TestCreate();
         TestInfo();         TestInfo();
         /*  
         TestCopy();         TestCopy();
         */  
         TestDestroy();  
  
           TestDestroy();
 } }

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