(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.6

version 1.7, 2005/02/11 08:50:58 version 2.6, 2005/02/26 03:39:28
Line 1 
Line 1 
 /* /*
  * Unit test suite for cabinet.dll - FDI functions  * Unit test suite for cabinet.dll - FDI functions
  *  *
  * Copyright 2004 Rizwan Kassim, Dan Kegel   * Copyright 2004 Rizwan Kassim, Dan Kegel, Alexander Liber
  *  *
  * This library is free software; you can redistribute it and/or  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public  * modify it under the terms of the GNU Lesser General Public
Line 19 
Line 19 
  */  */
  
 #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>
 #define ok2 ok #define ok2 ok
 #else #else
 /* To build outside Wine tree, compile with cl -DSTANDALONE -D_X86_ cabinet_fdi.c FDI.lib  /* 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 */   These are only called if standalone are used, defining ok and START_TEST, which would normally be declared in winetree */
 #include <assert.h> #include <assert.h>
 #include <stdio.h> #include <stdio.h>
Line 45 
Line 47 
 #include <winerror.h> #include <winerror.h>
 #include <fdi.h> #include <fdi.h>
 #include <fcntl.h> #include <fcntl.h>
   #include "tvfs.h"
   #include "data.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  
    Resource Kit from Microsoft.  The resource kit was retrieved from the  
    following URL:  
   
    http://www.microsoft.com/downloads/details.aspx?FamilyID=9d467a69-57ff-4ae7-96ee-b18c4790cffd&displaylang=en  
  */  */
  
   #ifndef DEBUG_ALLOC
 static unsigned char compressed_file[] =  FNALLOC(final_alloc) {
    {0x4D,0x53,0x43,0x46,0x00,0x00,0x00,0x00,0x75,0x00,          return malloc(cb);
         0x00,0x00,0x00,0x00,0x00,0x00,0x2C,0x00,0x00,0x00,  }
         0x00,0x00,0x00,0x00,0x03,0x01,0x01,0x00,0x01,0x00,  FNFREE(final_free) {
         0x00,0x00,0x39,0x30,0x00,0x00,0x45,0x00,0x00,0x00,          free(pv);
         0x01,0x00,0x01,0x00,0x26,0x00,0x00,0x00,0x00,0x00,          return;
         0x00,0x00,0x00,0x00,0x4A,0x32,0xB2,0xBE,0x20,0x00,  }
         0x74,0x65,0x73,0x74,0x2E,0x74,0x78,0x74,0x00,0x9C,  #else
         0x74,0xD0,0x75,0x28,0x00,0x26,0x00,0x43,0x4B,0x0B,  FNALLOC(final_alloc) {
         0xCE,0x57,0xC8,0xC9,0xCF,0x4B,0xD7,0x51,0x48,0xCC,  
         0x4B,0x51,0x28,0xC9,0x48,0xCC,0xCB,0x2E,0x56,0x48,  
         0xCB,0x2F,0x52,0x48,0xCC,0xC9,0x01,0x72,0x53,0x15,  
         0xD2,0x32,0x8B,0x33,0xF4,0xB8,0x00};  
 static int szcompressed_file = sizeof(compressed_file);  
   
  /*  
 static const char uncompressed_data[] = "This is a test file.";  
 static const DWORD uncompressed_data_size = sizeof(uncompressed_data) - 1;  
   
 static char *buf;  
 */  
   
 /*      To do in FDI:                           -from wine/include/fdi.h  
         FDICreate  
                 File Open                               -FNOPEN(pszFile,oflag,pmode)  
                 File Read                               -FNREAD(hf, pv, cb)  
                 File Write                              -FNWRITE(hf, pv, cb)  
                 File Close                              -FNCLOSE(hf)  
                 File Seek                               -FNSEEK(hf,dist,seektype)  
                 Error Structure  
         FDIlsCabinet  
                 FDICabinetInfo Structure  
         FDICopy  
                 Notification function  
                 Decryption function  
         FDIDestroy  
 */  
   
         FDICABINETINFO  fdici;  
   
   
 /* Currently mostly dummy function pointers */  
   
 FNALLOC(debug_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.  
   
 */  
   
 /*  
         http://msdn.microsoft.com/library/default.asp?url=/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.  
 */  
  
 FNOPEN(dummy_open) { FNOPEN(dummy_open) {
          printf("  FNOPEN (dummy) 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) {  FNREAD(dummy_read) {
          printf("  FNOPEN (fake) just called with %d, %d, %d\n",pszFile, oflag, pmode);          printf("   FNREAD (dummy) just called with %d, %d, %d\n",hf, pv, cb);
          printf("  Returning %d as file descriptor\n",fakeFD);          return 0;
         return 12;  
 } }
  
 FNOPEN(real_open) {  FNCLOSE(dummy_close) {
         int handler = _open(pszFile,oflag,pmode);          printf("   FNCLOSE (dummy) just called with %d - returning %d\n",hf,0);
         printf("   FNOPEN (real) just called with %s, %d, %d\n",pszFile, oflag, pmode);          return 0;
         printf("   FNOPEN (real) returning handler (%d)\n",handler);  
         return handler;  
 } }
  
   FNWRITE(dummy_write) {
 /*          printf("   FNWRITE just called with %d, %d, %d\n",hf, pv, cb);
         http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_crt__open.2c_._wopen.asp  
         _read           I: int fd, void *buffer, unsigned int count             O:      int (szBuffer)  
 */  
   
 FNREAD(dummy_read) {  
          printf("   FNREAD (dummy) just called with %d, %d, %d\n",hf, pv, cb);  
         return 0;         return 0;
 } }
  
 FNREAD(fake_read) {  FNSEEK(dummy_seek) {
          printf("   FNREAD (fake) just called with %d, %d, %d\n",hf, pv, cb);          printf("   FNSEEK just called with %d, %d, %d\n",hf, dist, seektype);
          if (hf == fakeFD) {          return 0;
                  printf ("   Called with fake file descriptor, populating buffer and size (%d)\n",szcompressed_file);  
                  memcpy (pv, compressed_file ,cb);  
                  /* TODO */  
                  }  
          else {  
                  printf ("   FNREAD (fake) was called with the unknown file handler. Failed!\n",hf);  
          }  
         return szcompressed_file;  
 }  
   
 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;  
 } }
  
   FNFDINOTIFY(dummy_notification){
           printf("   FNFDINOTIFY just called with %d, %d \n",fdint,pfdin);
           return 0;
   }
  
   FNFDINOTIFY(notification_function)
 FNWRITE(dummy_write) {  {
          printf("   FNWRITE just called with %d, %d, %d\n",hf, pv, cb);          printf("   FNFDINOTIFY real just called with %d, %d \n",fdint,pfdin);
           switch (fdint)
           {
                   case fdintCABINET_INFO:
                   {
                           printf("fdintCABINET_INFO\n");
         return 0;         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 = tvfs_open (target,
                                           _O_BINARY | _O_CREAT | _O_WRONLY | _O_SEQUENTIAL,
                                           _S_IREAD | _S_IWRITE
                                                                   );
                           return fih;
                   }
                   case fdintCLOSE_FILE_INFO:
                   {
  
 FNCLOSE(dummy_close) {                          printf("fdintCLOSE_FILE_INFO\n");
          printf("   FNCLOSE just called with %d\n",hf);  
         return 0;         return 0;
 } }
                   case fdintNEXT_CABINET:
                   {
  
 FNSEEK(dummy_seek) {                          printf("fdintNEXT_CABINET\n");
          printf("   FNSEEK just called with %d, %d, %d\n",hf, dist, seektype);                          return 0;
                   }
                   case fdintENUMERATE:
                   {
                                   printf("fdintENUMERATE\n");
                                   return 0;
                   }
           }
         return 0;         return 0;
 } }
  
 HFDI hfdi_unknown_dummy, hfdi_unknown_fake,hfdi_unknown_real;  static void printCabInfo(FDICABINETINFO  cabinfo){
 FDICABINETINFO  fdi_cabinfo;                  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);
                                                   }
   HFDI hfdi_unknown_dummy, hfdi_unknown_tvfs;
 /* 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 200 
         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 220 
Line 212 
         );         );
         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_tvfs = FDICreate(
                 debug_alloc,                  final_alloc,
                 debug_free,                  final_free,
                 fake_open,                  tvfs_open,
                 fake_read,                  tvfs_read,
                 dummy_write,                  tvfs_write,
                 dummy_close,                  tvfs_close,
                 dummy_seek,                  tvfs_lseek,
                 cpuUNKNOWN,  
                 &error_structure  
         );  
         ok(hfdi_unknown_fake != NULL,"FDICreate (CPU = unknown) (functions=fake) failed!\n");  
   
         hfdi_unknown_real = FDICreate(  
                 debug_alloc,  
                 debug_free,  
                 real_open,  
                 real_read,  
                 dummy_write,  
                 dummy_close,  
                 dummy_seek,  
                 cpuUNKNOWN,                 cpuUNKNOWN,
                 &error_structure                 &error_structure
         );         );
         ok(hfdi_unknown_real != NULL,"FDICreate (CPU = unknown) (functions=real) failed!\n");          ok(hfdi_unknown_tvfs != NULL,"FDICreate (CPU = unknown) (functions=tvfs) failed!\n");
  
         printf("Ending TestCreate()\n");         printf("Ending TestCreate()\n");
 } }
  
 static void TestInfo(void) { static void TestInfo(void) {
         int realfd;  
         int sizer;          int fd;
         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,  
                         "FDIIsCabinet (File = WrongType) failed!\n");  
  
         sizer = fake_read ( 12,buffer,szcompressed_file );          tvfs_create( name_simple_cab, file_simple_cab, size_simple_cab);
         printf(buffer);          fd = tvfs_open( name_simple_cab, _O_BINARY, 0 );
   
           ok( FDIIsCabinet( hfdi_unknown_tvfs, fd, &fdi_cabinfo_simple) == TRUE,
                           "FDIIsCabinet (Virtual File = Simple.cab) failed!\n");
   
           printCabInfo(fdi_cabinfo_simple);
                   CheckCabInfo("simple.cab",fdi_cabinfo_simple,121,1,1,0,0,0,0,0);
   
           tvfs_close(fd);
  
         realfd = real_open( "TEST1.cab" , _O_BINARY | _O_RDONLY | _O_SEQUENTIAL, 0);  
         ok ( FDIIsCabinet( hfdi_unknown_real, realfd, &fdi_cabinfo) == TRUE,  
                         "FDIIsCabinet (File = Cabinet) failed!\n");  
  
           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);
   
           printf("Ending TestInfo()\n");
           printf(" SEEK_CUR %d \n",SEEK_CUR);
 } }
  
   static void TestCopy(void){
           printf("Starting TestCopy()\n");
           printf("---simple.cab\n");
           FDICopy(hfdi_unknown_tvfs,
                           "simple.cab",
                           "",
                           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  
            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_tvfs), "FDIDestroy (CPU = unknown) (functions=tvfs) failed!\n");
         printf("Ending TestDestroy()\n");         printf("Ending TestDestroy()\n");
   
 } }
  
   
 START_TEST(paths) START_TEST(paths)
 { {
   
         TestCreate();         TestCreate();
         TestInfo();         TestInfo();
         /*  
         TestCopy();         TestCopy();
         */  
         TestDestroy();         TestDestroy();
           tvfs_free();
 } }

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