Category

Development Platform
Home > SourceCode/Document > Communication-Mobile > Symbian > View Code
ihxfiletest.cpp
Package: helix.src.0812.rar　[view]
Upload User: zhongxx05
Upload Date: 2007-06-06
Package Size: 33641k
Code Size: 21k
Category:

Symbian

Development Platform:

C/C++

ihxfiletest.cpp：Code Content
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #include "hx_ut_debug.h"
  37. #include "datffact.h"
  38. #include "hxbuffer.h"
  40. #include "hlxclib/sys/stat.h"
  42. #include "chxdataf.h"
  43. #include "cihx2chxdataf.h"
  45. #include "ut_param_util.h"
  46. #include "filetestutil.h"
  47. #include "ihxfiletest.h"
  51. HLXIHXFileTest::HLXIHXFileTest(const char* pModeString)
  52.     : m_pIHXDataFile(NULL)
  53.     , m_pCHXDataFile(NULL)
  54.     , m_pCHXDirectory(NULL)
  55.     , m_DataFileMode('i')
  56.     , m_bTestDir(false)
  57. {
  58.     if ((!pModeString) || (strncmp(pModeString, "ihx", 3) == 0))
  59.     {
  60. m_DataFileMode = 'i';
  62. // Use "ihx" file object test
  63. HXDataFileFactory* pDataFileFactory = new HXDataFileFactory;
  64. if (pDataFileFactory)
  65. {
  66.     IUnknown* pPersistentObj = NULL;
  67.     
  68.     pDataFileFactory->AddRef();
  69.     
  70.     pDataFileFactory->CreateFile(m_pIHXDataFile,
  71.  NULL,     // context
  72.  pPersistentObj,
  73.  TRUE,     // mem. mapped I/O
  74.  0,     // page size
  75.  FALSE,     // file locking
  76.  FALSE);    // prefer sync. object
  77.     
  78.     pDataFileFactory->Release();
  79.     
  80.     HX_RELEASE(pPersistentObj);
  81. }
  83. m_bTestDir = (strcmp(pModeString, "ihxdir") == 0);
  84.     }
  85.     else if (strncmp(pModeString, "chx", 3) == 0)
  86.     {
  87. m_DataFileMode = 'c';
  89. CIHX2CHXDataFile* pIHX2CHXDataFile = new CIHX2CHXDataFile();
  90. if (pIHX2CHXDataFile)
  91. {
  92.     pIHX2CHXDataFile->AddRef();
  93.     m_pIHXDataFile = pIHX2CHXDataFile;
  94.     m_pCHXDataFile = pIHX2CHXDataFile->GetCHXDataFile();
  95.     pIHX2CHXDataFile = NULL;
  96. }
  97. HX_RELEASE(pIHX2CHXDataFile);
  99. m_bTestDir = (strcmp(pModeString, "chxdir") == 0);
  100.     }
  102.     if (m_bTestDir)
  103.     {
  104. m_pCHXDirectory = new CHXDirectory();
  105.     }
  106. }
  108. HLXIHXFileTest::~HLXIHXFileTest()
  109. {
  110.     HX_RELEASE(m_pIHXDataFile);
  111.     HX_DELETE(m_pCHXDirectory);
  112. }
  113.     
  114. void HLXIHXFileTest::GetCommandInfo(UTVector<HLXUnitTestCmdInfo*>& cmds)
  115. {
  116.     cmds.Resize(28);
  118.     cmds[0] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  119.     "Bind",
  120.     &HLXIHXFileTest::HandleBindCmd,
  121.     2);
  122.     cmds[1] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  123.     "Create",
  124.     &HLXIHXFileTest::HandleCreateCmd,
  125.     3);
  126.     cmds[2] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  127.     "Open",
  128.     &HLXIHXFileTest::HandleOpenCmd,
  129.     3);
  130.     cmds[3] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  131.     "Close",
  132.     &HLXIHXFileTest::HandleCloseCmd,
  133.     2);
  134.     cmds[4] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  135.     "Name",
  136.     &HLXIHXFileTest::HandleNameCmd,
  137.     2,
  138.     3);
  139.     cmds[5] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  140.     "IsOpen",
  141.     &HLXIHXFileTest::HandleIsOpenCmd,
  142.     2);
  143.     cmds[6] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  144.     "Write",
  145.     &HLXIHXFileTest::HandleWriteCmd,
  146.     3);
  147.     cmds[7] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  148.     "Read",
  149.     &HLXIHXFileTest::HandleReadCmd,
  150.     3,
  151.     4);
  152.     cmds[8] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  153.     "Flush",
  154.     &HLXIHXFileTest::HandleFlushCmd,
  155.     2);
  156.     cmds[9] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  157.     "Seek",
  158.     &HLXIHXFileTest::HandleSeekCmd,
  159.     4);
  160.     cmds[10] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  161.     "Tell",
  162.     &HLXIHXFileTest::HandleTellCmd,
  163.     1,
  164.     2);
  165.     cmds[11] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  166.     "Stat",
  167.     &HLXIHXFileTest::HandleStatCmd,
  168.     2,
  169.     3);
  170.     cmds[12] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  171.     "Delete",
  172.     &HLXIHXFileTest::HandleDeleteCmd,
  173.     2,
  174.     3);
  175.     cmds[13] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  176.     "GetFd",
  177.     &HLXIHXFileTest::HandleGetFdCmd,
  178.     2);
  179.     cmds[14] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  180.     "GetLastErrorCode",
  181.     &HLXIHXFileTest::HandleGetLastErrorCodeCmd,
  182.     2);
  183.     cmds[15] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  184.     "GetLastErrorString",
  185.     &HLXIHXFileTest::HandleGetLastErrorStringCmd,
  186.     1);
  187.     cmds[16] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  188.     "Rewind",
  189.     &HLXIHXFileTest::HandleRewindCmd,
  190.     2);
  191.     cmds[17] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  192.     "GetTempName",
  193.     &HLXIHXFileTest::HandleGetTempNameCmd,
  194.     1);
  196.     cmds[18] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  197.     "SetDirPath",
  198.     &HLXIHXFileTest::HandleSetDirPathCmd,
  199.     2);
  200.     cmds[19] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  201.     "GetDirPath",
  202.     &HLXIHXFileTest::HandleGetDirPathCmd,
  203.     2,
  204.     3);
  205.     cmds[20] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  206.     "CreateDir",
  207.     &HLXIHXFileTest::HandleCreateDirCmd,
  208.     2);
  209.     cmds[21] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  210.     "IsDirValid",
  211.     &HLXIHXFileTest::HandleIsDirValidCmd,
  212.     2);
  213.     cmds[22] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  214.     "DestroyDir",
  215.     &HLXIHXFileTest::HandleDestroyDirCmd,
  216.     2,
  217.     3);
  218.     cmds[23] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  219.     "DeleteDirFile",
  220.     &HLXIHXFileTest::HandleDeleteDirFileCmd,
  221.     3);
  222.     cmds[24] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  223.     "MakeCurrentDir",
  224.     &HLXIHXFileTest::HandleMakeCurrentDirCmd,
  225.     2);
  226.     cmds[25] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  227.     "FindFirstInDir",
  228.     &HLXIHXFileTest::HandleFindFirstInDirCmd,
  229.     4,
  230.     5);
  231.     cmds[26] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  232.     "FindNextInDir",
  233.     &HLXIHXFileTest::HandleFindNextInDirCmd,
  234.     3,
  235.     4);
  236.     cmds[27] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  237.     "Rename",
  238.     &HLXIHXFileTest::HandleRenameCmd,
  239.     4);    
  240. }
  242. HLXCmdBasedTest* HLXIHXFileTest::Clone() const
  243. {
  244.     char pModeString[10]; /* Flawfinder: ignore */
  246.     if (m_DataFileMode == 'c')
  247.     {
  248. strcpy(pModeString, "chx"); /* Flawfinder: ignore */
  249.     }
  250.     else
  251.     {
  252. strcpy(pModeString, "ihx"); /* Flawfinder: ignore */
  253.     }
  255.     if (m_bTestDir)
  256.     {
  257. strcat(pModeString, "dir"); /* Flawfinder: ignore */
  258.     }
  260.     return new HLXIHXFileTest(pModeString);
  261. }
  264. /*****************************************************************************
  265.  *  DataFile Commands
  266.  */ 
  267. bool HLXIHXFileTest::HandleBindCmd(const UTVector<UTString>& info)
  268. {
  269.     bool bRetVal = false;
  271.     if (m_pIHXDataFile)
  272.     {
  273. m_pIHXDataFile->Bind((const char*) info[1]);
  274. bRetVal = true;
  275.     }
  277.     return bRetVal;
  278. }
  280. bool HLXIHXFileTest::HandleCreateCmd(const UTVector<UTString>& info)
  281. {
  282.     bool bRetVal = false;
  284.     if (m_pIHXDataFile)
  285.     {
  286. HX_RESULT retVal = m_pIHXDataFile->Create(
  287.     CFileTestUtil::ParseModeString(info[1]));
  288. bRetVal = (retVal == HXR_OK);
  289. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
  290.     }
  292.     return bRetVal;
  293. }
  295. bool HLXIHXFileTest::HandleOpenCmd(const UTVector<UTString>& info)
  296. {
  297.     bool bRetVal = false;
  299.     if (m_pIHXDataFile)
  300.     {
  301. HX_RESULT retVal = m_pIHXDataFile->Open(
  302.     CFileTestUtil::ParseModeString(info[1]));
  303. bRetVal = (retVal == HXR_OK);
  304. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
  305.     }
  307.     return bRetVal;
  308. }
  310. bool HLXIHXFileTest::HandleCloseCmd(const UTVector<UTString>& info)
  311. {
  312.     bool bRetVal = false;
  314.     if (m_pIHXDataFile)
  315.     {
  316. HX_RESULT retVal = m_pIHXDataFile->Close();
  317. bRetVal = (retVal == HXR_OK);
  318. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  319.     }
  321.     return bRetVal;
  322. }
  324. bool HLXIHXFileTest::HandleFlushCmd(const UTVector<UTString>& info)
  325. {
  326.     bool bRetVal = false;
  328.     if (m_pIHXDataFile)
  329.     {
  330. HX_RESULT retVal = m_pIHXDataFile->Flush();
  331. bRetVal = (retVal == HXR_OK);
  332. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  333.     }
  335.     return bRetVal;
  336. }
  338. bool HLXIHXFileTest::HandleNameCmd(const UTVector<UTString>& info)
  339. {
  340.     bool bRetVal = false;
  342.     if (m_pIHXDataFile)
  343.     {
  344. IHXBuffer* pHXBuffer = NULL;
  345. BOOL bResultVal;
  347. bResultVal = m_pIHXDataFile->Name(pHXBuffer);
  348. bRetVal = (bResultVal ? true : false);
  349. bRetVal = (bRetVal == (CFileTestUtil::ParseResultString(info[1]) ? true : false));
  350. if (bRetVal && bResultVal)
  351. {
  352.     bRetVal = false;
  354.     if (pHXBuffer)
  355.     {
  356. if (info.Nelements() > 2)
  357. {
  358.     bRetVal = CFileTestUtil::CheckString(info[2], pHXBuffer);
  359. }
  360. else
  361. {
  362.     bRetVal = true;
  363. }
  364.     }
  365. }
  367. HX_RELEASE(pHXBuffer);
  368.     }
  370.     return bRetVal;
  371. }
  373. bool HLXIHXFileTest::HandleGetTempNameCmd(const UTVector<UTString>& info)
  374. {
  375.     bool bRetVal = false;
  377.     if (m_pIHXDataFile)
  378.     {
  379. if (m_pCHXDataFile)
  380. {
  381.     char* pTempName = new char [_MAX_PATH + 1];
  383.     if (pTempName)
  384.     {
  385. pTempName[0] = '';
  387. bRetVal = (m_pCHXDataFile->
  388.    GetTemporaryFileName("test", pTempName, _MAX_PATH + 1) != 0);
  390. if (bRetVal)
  391. {
  392.     bRetVal = false;
  394.     if ((strlen(pTempName) > 0) && 
  395. (strlen(pTempName) <= _MAX_PATH))
  396.     {
  397. bRetVal = true;
  398.     }
  399. }
  401. delete [] pTempName;
  402.     }
  403. }
  404. else
  405. {
  406.     bRetVal = true;
  407. }
  408.     }
  410.     return bRetVal;
  411. }
  413. bool HLXIHXFileTest::HandleIsOpenCmd(const UTVector<UTString>& info)
  414. {
  415.     bool bRetVal = false;
  417.     if (m_pIHXDataFile)
  418.     {
  419. bRetVal = (m_pIHXDataFile->IsOpen() != FALSE);
  420. bRetVal = (bRetVal == CFileTestUtil::ParseBoolString(info[1]));
  421.     }
  423.     return bRetVal;
  424. }
  426. bool HLXIHXFileTest::HandleWriteCmd(const UTVector<UTString>& info)
  427. {
  428.     bool bRetVal = false;
  430.     if (m_pIHXDataFile)
  431.     {
  432. IHXBuffer* pHXBuffer = new CHXBuffer();
  434. if (pHXBuffer)
  435. {
  436.     pHXBuffer->AddRef();
  438.     if (pHXBuffer->Set((const UINT8*) ((const char*) info[1]), 
  439.        strlen(info[1])) == HXR_OK)
  440.     {
  441. ULONG32 ulRetSize;
  442. ULONG32 ulInSize;
  444. ulInSize = pHXBuffer->GetSize();
  445. ulRetSize = m_pIHXDataFile->Write(pHXBuffer);
  446. bRetVal = (ulRetSize == ulInSize);
  447. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
  448.     }
  450.     pHXBuffer->Release();
  451. }
  452.     }
  454.     return bRetVal;
  455. }
  457. bool HLXIHXFileTest::HandleReadCmd(const UTVector<UTString>& info)
  458. {
  459.     bool bRetVal = false;
  461.     if (m_pIHXDataFile)
  462.     {
  463. unsigned int uiReadSize = 0;
  465. if (UTParamUtil::GetUInt(info[1], uiReadSize))
  466. {
  467.     IHXBuffer* pHXBuffer = NULL;
  468.     bool bReadOK;
  470.     ULONG32 ulRetSize = m_pIHXDataFile->Read(pHXBuffer, uiReadSize);
  472.     bReadOK = ((ulRetSize != 0) && (ulRetSize != -1));
  473.     bRetVal = (bReadOK == CFileTestUtil::ParseResultString(info[2]));
  475.     if (bRetVal && bReadOK)
  476.     {
  477. bRetVal = false;
  479. if (info.Nelements() > 3)
  480. {
  481.     bRetVal = CFileTestUtil::CheckBuffer(info[3], 
  482.  pHXBuffer);
  483. }
  484.     }
  486.     HX_RELEASE(pHXBuffer);
  487. }
  488.     }
  490.     return bRetVal;
  491. }
  493. bool HLXIHXFileTest::HandleSeekCmd(const UTVector<UTString>& info)
  494. {
  495.     bool bRetVal = false;
  497.     if (m_pIHXDataFile)
  498.     {
  499. unsigned int uiSeekOffset = 0;
  501. if (UTParamUtil::GetUInt(info[1], uiSeekOffset))
  502. {
  503.     HX_RESULT retVal = m_pIHXDataFile->Seek(
  504. uiSeekOffset, 
  505. CFileTestUtil::ParseSeekModeString(info[2]));
  507.     bRetVal = (retVal == HXR_OK);
  508.     bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[3]));
  509. }
  510.     }
  512.     return bRetVal;
  513. }
  515. bool HLXIHXFileTest::HandleRewindCmd(const UTVector<UTString>& info)
  516. {
  517.     bool bRetVal = false;
  519.     if (m_pIHXDataFile)
  520.     {
  521. HX_RESULT retVal = HXR_FAIL;
  523. if (m_pCHXDataFile)
  524. {
  525.     retVal = m_pCHXDataFile->Rewind();
  526. }
  527. else
  528. { 
  529.     retVal = m_pIHXDataFile->Seek(0, SEEK_SET);
  530. }
  532. bRetVal = (retVal == HXR_OK);
  533. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  534.     }
  536.     return bRetVal;
  537. }
  539. bool HLXIHXFileTest::HandleTellCmd(const UTVector<UTString>& info)
  540. {
  541.     bool bRetVal = false;
  543.     if (m_pIHXDataFile)
  544.     {
  545. unsigned int uiFileOffset = 0;
  547. ULONG32 ulRetFileOffset = m_pIHXDataFile->Tell();
  549. bRetVal = true;
  551. if ((info.Nelements() > 1) &&
  552.     UTParamUtil::GetUInt(info[1], uiFileOffset))
  553. {
  554.     bRetVal = (ulRetFileOffset == uiFileOffset);
  555. }
  556.     }
  558.     return bRetVal;
  559. }
  561. bool HLXIHXFileTest::HandleStatCmd(const UTVector<UTString>& info)
  562. {
  563.     bool bRetVal = false;
  565.     if (m_pIHXDataFile)
  566.     {
  567. struct stat statBuffer;
  569. HX_RESULT retVal = m_pIHXDataFile->Stat(&statBuffer);
  571. bRetVal = (retVal == HXR_OK);
  572. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  574. if (bRetVal && (retVal == HXR_OK) && (info.Nelements() > 2))
  575. {
  576.     unsigned int uiFileSize = 0;
  577.     bRetVal = false;
  579.     if (UTParamUtil::GetUInt(info[2], uiFileSize))
  580.     {
  581. bRetVal = (statBuffer.st_size == uiFileSize);
  582.     }
  583. }
  584.     }
  586.     return bRetVal;
  587. }
  589. bool HLXIHXFileTest::HandleDeleteCmd(const UTVector<UTString>& info)
  590. {
  591.     bool bRetVal = false;
  593.     if (m_pIHXDataFile)
  594.     {
  595. if (info.Nelements() == 2)
  596. {
  597.     HX_RESULT retVal = m_pIHXDataFile->Delete();
  598.     bRetVal = (retVal == HXR_OK);
  599.     bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  600. }
  601. else if (info.Nelements() == 3)
  602. {
  603.     HX_RESULT retVal = HXR_FAIL;
  605.     if (m_pCHXDataFile)
  606.     {
  607. retVal = m_pCHXDataFile->Delete((const char*) info[1]);
  608.     }
  609.     else
  610.     {
  611. m_pIHXDataFile->Bind((const char*) info[1]);
  612. retVal = m_pIHXDataFile->Delete();
  613.     }
  615.     bRetVal = (retVal == HXR_OK);
  616.     bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
  617. }
  618.     }
  620.     return bRetVal;
  621. }
  623. bool HLXIHXFileTest::HandleGetFdCmd(const UTVector<UTString>& info)
  624. {
  625.     bool bRetVal = false;
  627.     if (m_pIHXDataFile)
  628.     {
  629. INT16 iFd = m_pIHXDataFile->GetFd();
  630. bRetVal = true;
  631.     }
  633.     return bRetVal;
  634. }
  636. bool HLXIHXFileTest::HandleGetLastErrorCodeCmd(const UTVector<UTString>& info)
  637. {
  638.     bool bRetVal = false;
  640.     if (m_pIHXDataFile)
  641.     {
  642. HX_RESULT retVal = m_pIHXDataFile->GetLastError();
  643. bRetVal = (retVal == HXR_OK);
  644. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  645.     }
  647.     return bRetVal;
  648. }
  650. bool HLXIHXFileTest::HandleGetLastErrorStringCmd(const UTVector<UTString>& info)
  651. {
  652.     bool bRetVal = false;
  654.     if (m_pIHXDataFile)
  655.     {
  656. IHXBuffer* pHXBuffer = NULL;
  658. m_pIHXDataFile->GetLastError(pHXBuffer);
  660. HX_RELEASE(pHXBuffer);
  662. bRetVal = true;
  663.     }
  665.     return bRetVal;
  666. }
  669. /*****************************************************************************
  670.  *    Directory Commands
  671.  */ 
  672. bool HLXIHXFileTest::HandleSetDirPathCmd(const UTVector<UTString>& info)
  673. {
  674.     bool bRetVal = true;
  676.     if (m_bTestDir)
  677.     {
  678. bRetVal = false;
  680. if (m_pCHXDirectory)
  681. {
  682.     m_pCHXDirectory->SetPath((const char*) info[1]);
  683.     bRetVal = true;
  684. }
  685.     }
  687.     return bRetVal;
  688. }
  690. bool HLXIHXFileTest::HandleGetDirPathCmd(const UTVector<UTString>& info)
  691. {
  692.     bool bRetVal = true;
  694.     if (m_bTestDir)
  695.     {
  696. bRetVal = false;
  698. if (m_pCHXDirectory)
  699. {
  700.     const char* pPath;
  701.     
  702.     pPath = m_pCHXDirectory->GetPath();
  704.     bRetVal = (pPath ? true : false);
  705.     bRetVal = (bRetVal == (CFileTestUtil::ParseResultString(info[1]) ? true : false));
  706.     if (bRetVal && pPath)
  707.     {
  708. bRetVal = false;
  710. if (info.Nelements() > 2)
  711. {
  712.     bRetVal = (strcmp(info[2], pPath) == 0);
  713. }
  714. else
  715. {
  716.     bRetVal = true;
  717. }
  718.     }
  719. }
  720.     }
  722.     return bRetVal;
  723. }
  725. bool HLXIHXFileTest::HandleCreateDirCmd(const UTVector<UTString>& info)
  726. {
  727.     bool bRetVal = true;
  729.     if (m_bTestDir)
  730.     {
  731. bRetVal = false;
  733. if (m_pCHXDirectory)
  734. {
  735.     bRetVal = (m_pCHXDirectory->Create() != FALSE);
  736.     bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  737. }
  738.     }
  740.     return bRetVal;
  741. }
  743. bool HLXIHXFileTest::HandleIsDirValidCmd(const UTVector<UTString>& info)
  744. {
  745.     bool bRetVal = false;
  747.     if (m_bTestDir)
  748.     {
  749. bRetVal = false;
  751. if (m_pCHXDirectory)
  752. {
  753.     bRetVal = (m_pCHXDirectory->IsValid() != FALSE);
  754.     bRetVal = (bRetVal == CFileTestUtil::ParseBoolString(info[1]));
  755. }
  756.     }
  758.     return bRetVal;
  759. }
  761. bool HLXIHXFileTest::HandleDestroyDirCmd(const UTVector<UTString>& info)
  762. {
  763.     bool bRetVal = false;
  765.     if (m_bTestDir)
  766.     {
  767. bRetVal = false;
  769. if (m_pCHXDirectory)
  770. {
  771.     bool bDestroyContents = CFileTestUtil::ParseBoolString(info[1]);
  773.     bRetVal = (m_pCHXDirectory->Destroy(bDestroyContents ? TRUE : FALSE) != FALSE);
  774.     if (info.Nelements() > 2)
  775.     {
  776. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
  777.     }
  778.     else
  779.     {
  780. bRetVal = true;
  781.     }
  782. }
  783.     }
  785.     return bRetVal;
  786. }
  788. bool HLXIHXFileTest::HandleDeleteDirFileCmd(const UTVector<UTString>& info)
  789. {
  790.     bool bRetVal = false;
  792.     if (m_bTestDir)
  793.     {
  794. bRetVal = false;
  796. if (m_pCHXDirectory)
  797. {
  798.     bRetVal = (m_pCHXDirectory->DeleteFile((const char*) info[1]) != FALSE);
  799.     bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
  800. }
  801.     }
  803.     return bRetVal;
  804. }
  806. bool HLXIHXFileTest::HandleMakeCurrentDirCmd(const UTVector<UTString>& info)
  807. {
  808.     bool bRetVal = true;
  810.     if (m_bTestDir)
  811.     {
  812. bRetVal = false;
  814. if (m_pCHXDirectory)
  815. {
  816.     bRetVal = (m_pCHXDirectory->MakeCurrentDir() != FALSE);
  817.     bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  818. }
  819.     }
  821.     return bRetVal;
  822. }
  824. bool HLXIHXFileTest::HandleFindFirstInDirCmd(const UTVector<UTString>& info)
  825. {
  826.     bool bRetVal = true;
  828.     if (m_bTestDir)
  829.     {
  830. bRetVal = false;
  832. if (m_pCHXDirectory)
  833. {
  834.     unsigned int uiFileNameSize = 0;
  835.     char* pOutFileName = NULL;
  837.     if (UTParamUtil::GetUInt(info[2], uiFileNameSize))
  838.     {
  839. pOutFileName = new char [uiFileNameSize];
  841. if (pOutFileName)
  842. {
  843.     XHXDirectory::FSOBJ retObj;
  845.     retObj = m_pCHXDirectory->FindFirst((const char*) info[1], // pattern
  846. pOutFileName,
  847. uiFileNameSize);
  849.     bRetVal = (retObj == CFileTestUtil::ParseFSOBJString(
  850.     (const char*) info[3], 
  851.     (retObj != XHXDirectory::FSOBJ_NOTVALID) ? retObj : XHXDirectory::FSOBJ_FILE));
  853.     if (bRetVal && (retObj != XHXDirectory::FSOBJ_NOTVALID))
  854.     {
  855. if (info.Nelements() > 4)
  856. {
  857.     bRetVal = (strcmp(pOutFileName, (const char*) info[4]) == 0);
  858. }
  859.     }
  861.     delete pOutFileName;
  862. }
  863.     }
  864. }
  865.     }
  867.     return bRetVal;
  868. }
  870. bool HLXIHXFileTest::HandleFindNextInDirCmd(const UTVector<UTString>& info)
  871. {
  872.     bool bRetVal = true;
  874.     if (m_bTestDir)
  875.     {
  876. bRetVal = false;
  878. if (m_pCHXDirectory)
  879. {
  880.     unsigned int uiFileNameSize = 0;
  881.     char* pOutFileName = NULL;
  883.     if (UTParamUtil::GetUInt(info[1], uiFileNameSize))
  884.     {
  885. pOutFileName = new char [uiFileNameSize];
  887. if (pOutFileName)
  888. {
  889.     XHXDirectory::FSOBJ retObj;
  891.     retObj = m_pCHXDirectory->FindNext(pOutFileName, // path
  892.        uiFileNameSize);
  894.     bRetVal = (retObj == CFileTestUtil::ParseFSOBJString((const char*) info[2], retObj));
  896.     if (bRetVal && (retObj != XHXDirectory::FSOBJ_NOTVALID))
  897.     {
  898. if (info.Nelements() > 3)
  899. {
  900.     bRetVal = (strcmp(pOutFileName, (const char*) info[3]) == 0);
  901. }
  902.     }
  904.     delete pOutFileName;
  905. }
  906.     }
  907. }
  908.     }
  910.     return bRetVal;
  911. }
  913. bool HLXIHXFileTest::HandleRenameCmd(const UTVector<UTString>& info)
  914. {
  915.     bool bRetVal = false;
  917.     if (m_bTestDir)
  918.     {
  919. bRetVal = false;
  921. if (m_pCHXDirectory)
  922. {
  923.     bRetVal = (m_pCHXDirectory->Rename((const char*) info[1],
  924.        (const char*) info[2]) == HXR_OK);
  925.     bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[3]));
  926. }
  927.     }
  929.     return bRetVal;
  930. }