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

version 1.3, 2005/02/04 09:17:22 version 2.15, 2005/03/18 00:28:59
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 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 <stdarg.h>
   #include <malloc.h>
   
   #include <stdarg.h>
   #include <stdio.h>
   
   #include "windef.h"
   #include "winbase.h"
   #include "winerror.h"
   #include "fdi.h"
   
   #ifndef WIN_ENV
   #include <msvcrt/fcntl.h>
   #include <msvcrt/sys/stat.h>
   #else
   #include <sys/stat.h>
   #include <fcntl.h>
   #endif
   
   #define VERBOSE
   
   #include "tvfs.h"
   #include "simplecab.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  #include "standalone.h"
   These are only called if standalone are used, defining ok and START_TEST, which would normally be declared in winetree */  /* To build outside Wine tree, compile with cl -DSTANDALONE -D_X86_ -DWIN_ENV tvfs.c cabinet_fdi.c FDI.lib
 #include <assert.h>    standalone.h is used if standalone are used, defining ok and START_TEST, which would normally be declared in winetree */
 #include <stdio.h>  
 #define START_TEST(name) main(int argc, char **argv)  
 #define ok(condition, msg)       \  
         do { if(!(condition)) {  \  
                 fprintf(stderr,"failed at %d, msg:" msg "\n",__LINE__); \  
                 exit(1);         \  
         } } while(0)  
 #define ok2(condition, msg, arg) \  
         do { if(!(condition)) {  \  
                 fprintf(stderr,"failed at %d, msg:" msg "\n",__LINE__, arg); \  
                 exit(1);         \  
         } } while(0)  
 #define todo_wine  
 #endif #endif
  
   FNALLOC(final_alloc) {
       trace("   FNALLOC just called with %d\n",cb);
       return malloc(cb);
   }
   FNFREE(final_free) {
       trace("   FNFREE just called with %d\n",pv);
       free(pv);
       return;
   }
  
 #include <winerror.h>  /*Possible non trivial addition:
 #include <fdi.h>  Notify receives some information about the cab file(see FDI documentation).
   Since this info is different depending on the value of fdint, and Notify should
 /*      To do in FDI:                           -from wine/include/fdi.h  be generic, it is not simple or nice to check this information.
         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 Close                              -FNCLOSE(hf)  
                 File Seek                               -FNSEEK(hf,dist,seektype)  
                 Error Structure  
         FDIlsCabinet  
                 FDICabinetInfo Structure  
         FDICopy  
                 Notification function  
                 Decryption function  
         FDIDestroy  
 */ */
   FNFDINOTIFY(notification_function)
 /* Currently dummy function pointers */  {
       trace("   FNFDINOTIFY real just called with %d, %d \n",fdint,pfdin);
 FNALLOC(dummy_alloc) {      switch (fdint)
         printf("FNALLOC just called with %d\n",cb);      {
           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:
           {
               trace("dintPARTIAL_FILE\n");
  
 FNFREE(dummy_free) {              return 0;
         printf("FNFREE just called with %d\n",pv);  
         return;  
 } }
           case fdintCOPY_FILE:
           {
               int fih = 0;
               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);
               fih = tvfs_open (target,
                   _O_BINARY | _O_CREAT | _O_WRONLY | _O_SEQUENTIAL,
                   _S_IREAD | _S_IWRITE
               );
               return fih;
           }
           case fdintCLOSE_FILE_INFO:
           {
   #ifdef VERBOSE
               trace(
                   "fdintCLOSE_FILE:\n"
                   "-name: %s\n"
                   "-handle: %d\n"
                   "-date: %d\n"
                   "-time: %d\n"
                   "-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
  
 FNOPEN(dummy_open) {              tvfs_close(pfdin->hf);
          printf("FNOPEN just called with %d, %d, %d\n",pszFile, oflag, pmode);              return TRUE;
           }
           case fdintNEXT_CABINET:
           {
               trace("fdintNEXT_CABINET\n");
               return 0;
           }
           case fdintENUMERATE:
           {
               trace("fdintENUMERATE\n");
               return 0;
           }
       }
         return 0;         return 0;
 } }
  
 FNREAD(dummy_read) {  static void printCabInfo(FDICABINETINFO  cabinfo){
 /*       printf("FNREAD just called with %d, %d, %d\n",hf, pv, cb);      trace("   Cabinet Data : cbC %d cF %d cFi %d si %d iC %d fr %d hp %d hn %d\n",
          return void;          cabinfo.cbCabinet,
 */      return 0;          cabinfo.cFolders ,
           cabinfo.cFiles ,
           cabinfo.setID,
           cabinfo.iCabinet,
           cabinfo.fReserve ,
           cabinfo.hasprev ,
           cabinfo.hasnext );
 } }
  
 FNWRITE(dummy_write) {  static void CheckCabInfo(char *  cabname,
 /*       printf("FNWRITE just called with %d, %d, %d\n",hf, pv, cb);      FDICABINETINFO cabinfo,
          return void;      long    TcbCabinet,
 */      return 0;      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);
 } }
      /* TODO :  Message should contain variable values */
   
   static HFDI hfdi_simple;
   /* yes its global and ugly */
   
   
   static void TestCreate(void) {
   
       ERF error_structure;
  
       trace("Starting TestCreate()\n");
       /* Is CPU386 or Unknown more commonly used? */
       hfdi_simple = FDICreate(
           final_alloc,
           final_free,
           tvfs_open, tvfs_read, tvfs_write, tvfs_close, tvfs_lseek,
           cpuUNKNOWN,
           &error_structure
       );
  
 FNCLOSE(dummy_close) {      ok(hfdi_simple != NULL,"FDICreate (CPU = unknown) (functions=tvfs) failed!\n");
 /*       printf("FNCLOSE just called with %d\n",hf);  
         return void;      trace("Ending TestCreate()\n");
 */      return 0;  
 } }
  
 FNSEEK(dummy_seek) {  static void TestInfo(void) {
 /*       printf("FNSEEK just called with %d, %d, %d\n",hf, dist, seektype);  
         return void;      int fd;
 */      return 0;  
       FDICABINETINFO  fdi_cabinfo_simple;
   
       trace("Starting TestInfo()\n");
   
       tvfs_create( name_simple_cab, file_simple_cab, size_simple_cab);
       fd = tvfs_open( name_simple_cab, _O_BINARY, 0 );
   
       ok( FDIIsCabinet( hfdi_simple, 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);
       tvfs_free();
   
       trace("Ending TestInfo()\n");
 } }
  
 static void TestDestroy(void) {  static void TestCopy(void){
         /* 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  
         */  
  
         ok( 0 == FDIDestroy(0), "Return true incorrectly in TestDestroy()!\n");      char name_file_path[256];
         /*      int result;
                 TODO : check if its passed an hfdi  
                 */      trace("Starting TestCopy()\n");
       trace("---simple.cab\n");
   
       tvfs_create( name_simple_cab, file_simple_cab, size_simple_cab);
       FDICopy(hfdi_simple,
           "simple.cab",
           "",
           0,
           notification_function,
           NULL,
           NULL);
   
       /* Filename when extracted is ./<filename> */
       sprintf(name_file_path, "./%s", name_simple_txt);
       result = tvfs_compare(name_file_path, file_simple_txt, size_simple_txt);
       if (result)
           trace ("File %s compare failed!\n",name_file_path);
       tvfs_free();
   
       trace("Ending TestCopy()\n");
 } }
  
   static void TestDestroy(void) {
       trace("Starting TestDestroy()\n");
       ok(FDIDestroy(hfdi_simple), "FDIDestroy (CPU = unknown) (functions=tvfs) failed!\n");
       trace("Ending TestDestroy()\n");
   }
  
 START_TEST(paths)  START_TEST(cabinet_fdi)
 { {
         /*  
         TestCreate();         TestCreate();
         TestInfo();         TestInfo();
         TestCopy();         TestCopy();
         */  
         TestDestroy();         TestDestroy();
       tvfs_free();
 } }

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