开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
ihxfiletest.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：22k
源码类别：

Symbian

开发平台：

Visual C++

ihxfiletest.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: ihxfiletest.cpp,v 1.7.42.3 2004/07/09 01:44:48 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #include "hx_ut_debug.h"
  51. #include "datffact.h"
  52. #include "hxbuffer.h"
  54. #include "hlxclib/sys/stat.h"
  56. #include "chxdataf.h"
  57. #include "cihx2chxdataf.h"
  59. #include "ut_param_util.h"
  60. #include "filetestutil.h"
  61. #include "ihxfiletest.h"
  65. HLXIHXFileTest::HLXIHXFileTest(const char* pModeString)
  66.     : m_pIHXDataFile(NULL)
  67.     , m_pCHXDataFile(NULL)
  68.     , m_pCHXDirectory(NULL)
  69.     , m_DataFileMode('i')
  70.     , m_bTestDir(false)
  71. {
  72.     if ((!pModeString) || (strncmp(pModeString, "ihx", 3) == 0))
  73.     {
  74. m_DataFileMode = 'i';
  76. // Use "ihx" file object test
  77. HXDataFileFactory* pDataFileFactory = new HXDataFileFactory;
  78. if (pDataFileFactory)
  79. {
  80.     IUnknown* pPersistentObj = NULL;
  81.     
  82.     pDataFileFactory->AddRef();
  83.     
  84.     pDataFileFactory->CreateFile(m_pIHXDataFile,
  85.  NULL,     // context
  86.  pPersistentObj,
  87.  TRUE,     // mem. mapped I/O
  88.  0,     // page size
  89.  FALSE,     // file locking
  90.  FALSE);    // prefer sync. object
  91.     
  92.     pDataFileFactory->Release();
  93.     
  94.     HX_RELEASE(pPersistentObj);
  95. }
  97. m_bTestDir = (strcmp(pModeString, "ihxdir") == 0);
  98.     }
  99.     else if (strncmp(pModeString, "chx", 3) == 0)
  100.     {
  101. m_DataFileMode = 'c';
  103. CIHX2CHXDataFile* pIHX2CHXDataFile = new CIHX2CHXDataFile();
  104. if (pIHX2CHXDataFile)
  105. {
  106.     pIHX2CHXDataFile->AddRef();
  107.     m_pIHXDataFile = pIHX2CHXDataFile;
  108.     m_pCHXDataFile = pIHX2CHXDataFile->GetCHXDataFile();
  109.     pIHX2CHXDataFile = NULL;
  110. }
  111. HX_RELEASE(pIHX2CHXDataFile);
  113. m_bTestDir = (strcmp(pModeString, "chxdir") == 0);
  114.     }
  116.     if (m_bTestDir)
  117.     {
  118. m_pCHXDirectory = new CHXDirectory();
  119.     }
  120. }
  122. HLXIHXFileTest::~HLXIHXFileTest()
  123. {
  124.     HX_RELEASE(m_pIHXDataFile);
  125.     HX_DELETE(m_pCHXDirectory);
  126. }
  127.     
  128. void HLXIHXFileTest::GetCommandInfo(UTVector<HLXUnitTestCmdInfo*>& cmds)
  129. {
  130.     cmds.Resize(28);
  132.     cmds[0] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  133.     "Bind",
  134.     &HLXIHXFileTest::HandleBindCmd,
  135.     2);
  136.     cmds[1] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  137.     "Create",
  138.     &HLXIHXFileTest::HandleCreateCmd,
  139.     3);
  140.     cmds[2] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  141.     "Open",
  142.     &HLXIHXFileTest::HandleOpenCmd,
  143.     3);
  144.     cmds[3] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  145.     "Close",
  146.     &HLXIHXFileTest::HandleCloseCmd,
  147.     2);
  148.     cmds[4] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  149.     "Name",
  150.     &HLXIHXFileTest::HandleNameCmd,
  151.     2,
  152.     3);
  153.     cmds[5] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  154.     "IsOpen",
  155.     &HLXIHXFileTest::HandleIsOpenCmd,
  156.     2);
  157.     cmds[6] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  158.     "Write",
  159.     &HLXIHXFileTest::HandleWriteCmd,
  160.     3);
  161.     cmds[7] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  162.     "Read",
  163.     &HLXIHXFileTest::HandleReadCmd,
  164.     3,
  165.     4);
  166.     cmds[8] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  167.     "Flush",
  168.     &HLXIHXFileTest::HandleFlushCmd,
  169.     2);
  170.     cmds[9] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  171.     "Seek",
  172.     &HLXIHXFileTest::HandleSeekCmd,
  173.     4);
  174.     cmds[10] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  175.     "Tell",
  176.     &HLXIHXFileTest::HandleTellCmd,
  177.     1,
  178.     2);
  179.     cmds[11] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  180.     "Stat",
  181.     &HLXIHXFileTest::HandleStatCmd,
  182.     2,
  183.     3);
  184.     cmds[12] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  185.     "Delete",
  186.     &HLXIHXFileTest::HandleDeleteCmd,
  187.     2,
  188.     3);
  189.     cmds[13] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  190.     "GetFd",
  191.     &HLXIHXFileTest::HandleGetFdCmd,
  192.     2);
  193.     cmds[14] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  194.     "GetLastErrorCode",
  195.     &HLXIHXFileTest::HandleGetLastErrorCodeCmd,
  196.     2);
  197.     cmds[15] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  198.     "GetLastErrorString",
  199.     &HLXIHXFileTest::HandleGetLastErrorStringCmd,
  200.     1);
  201.     cmds[16] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  202.     "Rewind",
  203.     &HLXIHXFileTest::HandleRewindCmd,
  204.     2);
  205.     cmds[17] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  206.     "GetTempName",
  207.     &HLXIHXFileTest::HandleGetTempNameCmd,
  208.     1);
  210.     cmds[18] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  211.     "SetDirPath",
  212.     &HLXIHXFileTest::HandleSetDirPathCmd,
  213.     2);
  214.     cmds[19] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  215.     "GetDirPath",
  216.     &HLXIHXFileTest::HandleGetDirPathCmd,
  217.     2,
  218.     3);
  219.     cmds[20] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  220.     "CreateDir",
  221.     &HLXIHXFileTest::HandleCreateDirCmd,
  222.     2);
  223.     cmds[21] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  224.     "IsDirValid",
  225.     &HLXIHXFileTest::HandleIsDirValidCmd,
  226.     2);
  227.     cmds[22] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  228.     "DestroyDir",
  229.     &HLXIHXFileTest::HandleDestroyDirCmd,
  230.     2,
  231.     3);
  232.     cmds[23] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  233.     "DeleteDirFile",
  234.     &HLXIHXFileTest::HandleDeleteDirFileCmd,
  235.     3);
  236.     cmds[24] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  237.     "MakeCurrentDir",
  238.     &HLXIHXFileTest::HandleMakeCurrentDirCmd,
  239.     2);
  240.     cmds[25] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  241.     "FindFirstInDir",
  242.     &HLXIHXFileTest::HandleFindFirstInDirCmd,
  243.     4,
  244.     5);
  245.     cmds[26] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  246.     "FindNextInDir",
  247.     &HLXIHXFileTest::HandleFindNextInDirCmd,
  248.     3,
  249.     4);
  250.     cmds[27] = new HLXUnitTestCmdInfoDisp<HLXIHXFileTest>(this, 
  251.     "Rename",
  252.     &HLXIHXFileTest::HandleRenameCmd,
  253.     4);    
  254. }
  256. HLXCmdBasedTest* HLXIHXFileTest::Clone() const
  257. {
  258.     char pModeString[10]; /* Flawfinder: ignore */
  260.     if (m_DataFileMode == 'c')
  261.     {
  262. strcpy(pModeString, "chx"); /* Flawfinder: ignore */
  263.     }
  264.     else
  265.     {
  266. strcpy(pModeString, "ihx"); /* Flawfinder: ignore */
  267.     }
  269.     if (m_bTestDir)
  270.     {
  271. strcat(pModeString, "dir"); /* Flawfinder: ignore */
  272.     }
  274.     return new HLXIHXFileTest(pModeString);
  275. }
  278. /*****************************************************************************
  279.  *  DataFile Commands
  280.  */ 
  281. bool HLXIHXFileTest::HandleBindCmd(const UTVector<UTString>& info)
  282. {
  283.     bool bRetVal = false;
  285.     if (m_pIHXDataFile)
  286.     {
  287. m_pIHXDataFile->Bind((const char*) info[1]);
  288. bRetVal = true;
  289.     }
  291.     return bRetVal;
  292. }
  294. bool HLXIHXFileTest::HandleCreateCmd(const UTVector<UTString>& info)
  295. {
  296.     bool bRetVal = false;
  298.     if (m_pIHXDataFile)
  299.     {
  300. HX_RESULT retVal = m_pIHXDataFile->Create(
  301.     CFileTestUtil::ParseModeString(info[1]));
  302. bRetVal = (retVal == HXR_OK);
  303. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
  304.     }
  306.     return bRetVal;
  307. }
  309. bool HLXIHXFileTest::HandleOpenCmd(const UTVector<UTString>& info)
  310. {
  311.     bool bRetVal = false;
  313.     if (m_pIHXDataFile)
  314.     {
  315. HX_RESULT retVal = m_pIHXDataFile->Open(
  316.     CFileTestUtil::ParseModeString(info[1]));
  317. bRetVal = (retVal == HXR_OK);
  318. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
  319.     }
  321.     return bRetVal;
  322. }
  324. bool HLXIHXFileTest::HandleCloseCmd(const UTVector<UTString>& info)
  325. {
  326.     bool bRetVal = false;
  328.     if (m_pIHXDataFile)
  329.     {
  330. HX_RESULT retVal = m_pIHXDataFile->Close();
  331. bRetVal = (retVal == HXR_OK);
  332. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  333.     }
  335.     return bRetVal;
  336. }
  338. bool HLXIHXFileTest::HandleFlushCmd(const UTVector<UTString>& info)
  339. {
  340.     bool bRetVal = false;
  342.     if (m_pIHXDataFile)
  343.     {
  344. HX_RESULT retVal = m_pIHXDataFile->Flush();
  345. bRetVal = (retVal == HXR_OK);
  346. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  347.     }
  349.     return bRetVal;
  350. }
  352. bool HLXIHXFileTest::HandleNameCmd(const UTVector<UTString>& info)
  353. {
  354.     bool bRetVal = false;
  356.     if (m_pIHXDataFile)
  357.     {
  358. IHXBuffer* pHXBuffer = NULL;
  359. BOOL bResultVal;
  361. bResultVal = m_pIHXDataFile->Name(pHXBuffer);
  362. bRetVal = (bResultVal ? true : false);
  363. bRetVal = (bRetVal == (CFileTestUtil::ParseResultString(info[1]) ? true : false));
  364. if (bRetVal && bResultVal)
  365. {
  366.     bRetVal = false;
  368.     if (pHXBuffer)
  369.     {
  370. if (info.Nelements() > 2)
  371. {
  372.     bRetVal = CFileTestUtil::CheckString(info[2], pHXBuffer);
  373. }
  374. else
  375. {
  376.     bRetVal = true;
  377. }
  378.     }
  379. }
  381. HX_RELEASE(pHXBuffer);
  382.     }
  384.     return bRetVal;
  385. }
  387. bool HLXIHXFileTest::HandleGetTempNameCmd(const UTVector<UTString>& info)
  388. {
  389.     bool bRetVal = false;
  391.     if (m_pIHXDataFile)
  392.     {
  393. if (m_pCHXDataFile)
  394. {
  395.     char* pTempName = new char [_MAX_PATH + 1];
  397.     if (pTempName)
  398.     {
  399. pTempName[0] = '';
  401. bRetVal = (m_pCHXDataFile->
  402.    GetTemporaryFileName("test", pTempName, _MAX_PATH + 1) != 0);
  404. if (bRetVal)
  405. {
  406.     bRetVal = false;
  408.     if ((strlen(pTempName) > 0) && 
  409. (strlen(pTempName) <= _MAX_PATH))
  410.     {
  411. bRetVal = true;
  412.     }
  413. }
  415. delete [] pTempName;
  416.     }
  417. }
  418. else
  419. {
  420.     bRetVal = true;
  421. }
  422.     }
  424.     return bRetVal;
  425. }
  427. bool HLXIHXFileTest::HandleIsOpenCmd(const UTVector<UTString>& info)
  428. {
  429.     bool bRetVal = false;
  431.     if (m_pIHXDataFile)
  432.     {
  433. bRetVal = (m_pIHXDataFile->IsOpen() != FALSE);
  434. bRetVal = (bRetVal == CFileTestUtil::ParseBoolString(info[1]));
  435.     }
  437.     return bRetVal;
  438. }
  440. bool HLXIHXFileTest::HandleWriteCmd(const UTVector<UTString>& info)
  441. {
  442.     bool bRetVal = false;
  444.     if (m_pIHXDataFile)
  445.     {
  446. IHXBuffer* pHXBuffer = new CHXBuffer();
  448. if (pHXBuffer)
  449. {
  450.     pHXBuffer->AddRef();
  452.     if (pHXBuffer->Set((const UINT8*) ((const char*) info[1]), 
  453.        strlen(info[1])) == HXR_OK)
  454.     {
  455. ULONG32 ulRetSize;
  456. ULONG32 ulInSize;
  458. ulInSize = pHXBuffer->GetSize();
  459. ulRetSize = m_pIHXDataFile->Write(pHXBuffer);
  460. bRetVal = (ulRetSize == ulInSize);
  461. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
  462.     }
  464.     pHXBuffer->Release();
  465. }
  466.     }
  468.     return bRetVal;
  469. }
  471. bool HLXIHXFileTest::HandleReadCmd(const UTVector<UTString>& info)
  472. {
  473.     bool bRetVal = false;
  475.     if (m_pIHXDataFile)
  476.     {
  477. unsigned int uiReadSize = 0;
  479. if (UTParamUtil::GetUInt(info[1], uiReadSize))
  480. {
  481.     IHXBuffer* pHXBuffer = NULL;
  482.     bool bReadOK;
  484.     ULONG32 ulRetSize = m_pIHXDataFile->Read(pHXBuffer, uiReadSize);
  486.     bReadOK = ((ulRetSize != 0) && (ulRetSize != -1));
  487.     bRetVal = (bReadOK == CFileTestUtil::ParseResultString(info[2]));
  489.     if (bRetVal && bReadOK)
  490.     {
  491. bRetVal = false;
  493. if (info.Nelements() > 3)
  494. {
  495.     bRetVal = CFileTestUtil::CheckBuffer(info[3], 
  496.  pHXBuffer);
  497. }
  498.     }
  500.     HX_RELEASE(pHXBuffer);
  501. }
  502.     }
  504.     return bRetVal;
  505. }
  507. bool HLXIHXFileTest::HandleSeekCmd(const UTVector<UTString>& info)
  508. {
  509.     bool bRetVal = false;
  511.     if (m_pIHXDataFile)
  512.     {
  513. unsigned int uiSeekOffset = 0;
  515. if (UTParamUtil::GetUInt(info[1], uiSeekOffset))
  516. {
  517.     HX_RESULT retVal = m_pIHXDataFile->Seek(
  518. uiSeekOffset, 
  519. CFileTestUtil::ParseSeekModeString(info[2]));
  521.     bRetVal = (retVal == HXR_OK);
  522.     bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[3]));
  523. }
  524.     }
  526.     return bRetVal;
  527. }
  529. bool HLXIHXFileTest::HandleRewindCmd(const UTVector<UTString>& info)
  530. {
  531.     bool bRetVal = false;
  533.     if (m_pIHXDataFile)
  534.     {
  535. HX_RESULT retVal = HXR_FAIL;
  537. if (m_pCHXDataFile)
  538. {
  539.     retVal = m_pCHXDataFile->Rewind();
  540. }
  541. else
  542. { 
  543.     retVal = m_pIHXDataFile->Seek(0, SEEK_SET);
  544. }
  546. bRetVal = (retVal == HXR_OK);
  547. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  548.     }
  550.     return bRetVal;
  551. }
  553. bool HLXIHXFileTest::HandleTellCmd(const UTVector<UTString>& info)
  554. {
  555.     bool bRetVal = false;
  557.     if (m_pIHXDataFile)
  558.     {
  559. unsigned int uiFileOffset = 0;
  561. ULONG32 ulRetFileOffset = m_pIHXDataFile->Tell();
  563. bRetVal = true;
  565. if ((info.Nelements() > 1) &&
  566.     UTParamUtil::GetUInt(info[1], uiFileOffset))
  567. {
  568.     bRetVal = (ulRetFileOffset == uiFileOffset);
  569. }
  570.     }
  572.     return bRetVal;
  573. }
  575. bool HLXIHXFileTest::HandleStatCmd(const UTVector<UTString>& info)
  576. {
  577.     bool bRetVal = false;
  579.     if (m_pIHXDataFile)
  580.     {
  581. struct stat statBuffer;
  583. HX_RESULT retVal = m_pIHXDataFile->Stat(&statBuffer);
  585. bRetVal = (retVal == HXR_OK);
  586. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  588. if (bRetVal && (retVal == HXR_OK) && (info.Nelements() > 2))
  589. {
  590.     unsigned int uiFileSize = 0;
  591.     bRetVal = false;
  593.     if (UTParamUtil::GetUInt(info[2], uiFileSize))
  594.     {
  595. bRetVal = (statBuffer.st_size == uiFileSize);
  596.     }
  597. }
  598.     }
  600.     return bRetVal;
  601. }
  603. bool HLXIHXFileTest::HandleDeleteCmd(const UTVector<UTString>& info)
  604. {
  605.     bool bRetVal = false;
  607.     if (m_pIHXDataFile)
  608.     {
  609. if (info.Nelements() == 2)
  610. {
  611.     HX_RESULT retVal = m_pIHXDataFile->Delete();
  612.     bRetVal = (retVal == HXR_OK);
  613.     bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  614. }
  615. else if (info.Nelements() == 3)
  616. {
  617.     HX_RESULT retVal = HXR_FAIL;
  619.     if (m_pCHXDataFile)
  620.     {
  621. retVal = m_pCHXDataFile->Delete((const char*) info[1]);
  622.     }
  623.     else
  624.     {
  625. m_pIHXDataFile->Bind((const char*) info[1]);
  626. retVal = m_pIHXDataFile->Delete();
  627.     }
  629.     bRetVal = (retVal == HXR_OK);
  630.     bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
  631. }
  632.     }
  634.     return bRetVal;
  635. }
  637. bool HLXIHXFileTest::HandleGetFdCmd(const UTVector<UTString>& info)
  638. {
  639.     bool bRetVal = false;
  641.     if (m_pIHXDataFile)
  642.     {
  643. INT16 iFd = m_pIHXDataFile->GetFd();
  644. bRetVal = true;
  645.     }
  647.     return bRetVal;
  648. }
  650. bool HLXIHXFileTest::HandleGetLastErrorCodeCmd(const UTVector<UTString>& info)
  651. {
  652.     bool bRetVal = false;
  654.     if (m_pIHXDataFile)
  655.     {
  656. HX_RESULT retVal = m_pIHXDataFile->GetLastError();
  657. bRetVal = (retVal == HXR_OK);
  658. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  659.     }
  661.     return bRetVal;
  662. }
  664. bool HLXIHXFileTest::HandleGetLastErrorStringCmd(const UTVector<UTString>& info)
  665. {
  666.     bool bRetVal = false;
  668.     if (m_pIHXDataFile)
  669.     {
  670. IHXBuffer* pHXBuffer = NULL;
  672. m_pIHXDataFile->GetLastError(pHXBuffer);
  674. HX_RELEASE(pHXBuffer);
  676. bRetVal = true;
  677.     }
  679.     return bRetVal;
  680. }
  683. /*****************************************************************************
  684.  *    Directory Commands
  685.  */ 
  686. bool HLXIHXFileTest::HandleSetDirPathCmd(const UTVector<UTString>& info)
  687. {
  688.     bool bRetVal = true;
  690.     if (m_bTestDir)
  691.     {
  692. bRetVal = false;
  694. if (m_pCHXDirectory)
  695. {
  696.     m_pCHXDirectory->SetPath((const char*) info[1]);
  697.     bRetVal = true;
  698. }
  699.     }
  701.     return bRetVal;
  702. }
  704. bool HLXIHXFileTest::HandleGetDirPathCmd(const UTVector<UTString>& info)
  705. {
  706.     bool bRetVal = true;
  708.     if (m_bTestDir)
  709.     {
  710. bRetVal = false;
  712. if (m_pCHXDirectory)
  713. {
  714.     const char* pPath;
  715.     
  716.     pPath = m_pCHXDirectory->GetPath();
  718.     bRetVal = (pPath ? true : false);
  719.     bRetVal = (bRetVal == (CFileTestUtil::ParseResultString(info[1]) ? true : false));
  720.     if (bRetVal && pPath)
  721.     {
  722. bRetVal = false;
  724. if (info.Nelements() > 2)
  725. {
  726.     bRetVal = (strcmp(info[2], pPath) == 0);
  727. }
  728. else
  729. {
  730.     bRetVal = true;
  731. }
  732.     }
  733. }
  734.     }
  736.     return bRetVal;
  737. }
  739. bool HLXIHXFileTest::HandleCreateDirCmd(const UTVector<UTString>& info)
  740. {
  741.     bool bRetVal = true;
  743.     if (m_bTestDir)
  744.     {
  745. bRetVal = false;
  747. if (m_pCHXDirectory)
  748. {
  749.     bRetVal = (m_pCHXDirectory->Create() != FALSE);
  750.     bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  751. }
  752.     }
  754.     return bRetVal;
  755. }
  757. bool HLXIHXFileTest::HandleIsDirValidCmd(const UTVector<UTString>& info)
  758. {
  759.     bool bRetVal = false;
  761.     if (m_bTestDir)
  762.     {
  763. bRetVal = false;
  765. if (m_pCHXDirectory)
  766. {
  767.     bRetVal = (m_pCHXDirectory->IsValid() != FALSE);
  768.     bRetVal = (bRetVal == CFileTestUtil::ParseBoolString(info[1]));
  769. }
  770.     }
  772.     return bRetVal;
  773. }
  775. bool HLXIHXFileTest::HandleDestroyDirCmd(const UTVector<UTString>& info)
  776. {
  777.     bool bRetVal = false;
  779.     if (m_bTestDir)
  780.     {
  781. bRetVal = false;
  783. if (m_pCHXDirectory)
  784. {
  785.     bool bDestroyContents = CFileTestUtil::ParseBoolString(info[1]);
  787.     bRetVal = (m_pCHXDirectory->Destroy(bDestroyContents ? TRUE : FALSE) != FALSE);
  788.     if (info.Nelements() > 2)
  789.     {
  790. bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
  791.     }
  792.     else
  793.     {
  794. bRetVal = true;
  795.     }
  796. }
  797.     }
  799.     return bRetVal;
  800. }
  802. bool HLXIHXFileTest::HandleDeleteDirFileCmd(const UTVector<UTString>& info)
  803. {
  804.     bool bRetVal = false;
  806.     if (m_bTestDir)
  807.     {
  808. bRetVal = false;
  810. if (m_pCHXDirectory)
  811. {
  812.     bRetVal = (m_pCHXDirectory->DeleteFile((const char*) info[1]) != FALSE);
  813.     bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
  814. }
  815.     }
  817.     return bRetVal;
  818. }
  820. bool HLXIHXFileTest::HandleMakeCurrentDirCmd(const UTVector<UTString>& info)
  821. {
  822.     bool bRetVal = true;
  824.     if (m_bTestDir)
  825.     {
  826. bRetVal = false;
  828. if (m_pCHXDirectory)
  829. {
  830.     bRetVal = (m_pCHXDirectory->MakeCurrentDir() != FALSE);
  831.     bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
  832. }
  833.     }
  835.     return bRetVal;
  836. }
  838. bool HLXIHXFileTest::HandleFindFirstInDirCmd(const UTVector<UTString>& info)
  839. {
  840.     bool bRetVal = true;
  842.     if (m_bTestDir)
  843.     {
  844. bRetVal = false;
  846. if (m_pCHXDirectory)
  847. {
  848.     unsigned int uiFileNameSize = 0;
  849.     char* pOutFileName = NULL;
  851.     if (UTParamUtil::GetUInt(info[2], uiFileNameSize))
  852.     {
  853. pOutFileName = new char [uiFileNameSize];
  855. if (pOutFileName)
  856. {
  857.     XHXDirectory::FSOBJ retObj;
  859.     retObj = m_pCHXDirectory->FindFirst((const char*) info[1], // pattern
  860. pOutFileName,
  861. uiFileNameSize);
  863.     bRetVal = (retObj == CFileTestUtil::ParseFSOBJString(
  864.     (const char*) info[3], 
  865.     (retObj != XHXDirectory::FSOBJ_NOTVALID) ? retObj : XHXDirectory::FSOBJ_FILE));
  867.     if (bRetVal && (retObj != XHXDirectory::FSOBJ_NOTVALID))
  868.     {
  869. if (info.Nelements() > 4)
  870. {
  871.     bRetVal = (strcmp(pOutFileName, (const char*) info[4]) == 0);
  872. }
  873.     }
  875.     delete pOutFileName;
  876. }
  877.     }
  878. }
  879.     }
  881.     return bRetVal;
  882. }
  884. bool HLXIHXFileTest::HandleFindNextInDirCmd(const UTVector<UTString>& info)
  885. {
  886.     bool bRetVal = true;
  888.     if (m_bTestDir)
  889.     {
  890. bRetVal = false;
  892. if (m_pCHXDirectory)
  893. {
  894.     unsigned int uiFileNameSize = 0;
  895.     char* pOutFileName = NULL;
  897.     if (UTParamUtil::GetUInt(info[1], uiFileNameSize))
  898.     {
  899. pOutFileName = new char [uiFileNameSize];
  901. if (pOutFileName)
  902. {
  903.     XHXDirectory::FSOBJ retObj;
  905.     retObj = m_pCHXDirectory->FindNext(pOutFileName, // path
  906.        uiFileNameSize);
  908.     bRetVal = (retObj == CFileTestUtil::ParseFSOBJString((const char*) info[2], retObj));
  910.     if (bRetVal && (retObj != XHXDirectory::FSOBJ_NOTVALID))
  911.     {
  912. if (info.Nelements() > 3)
  913. {
  914.     bRetVal = (strcmp(pOutFileName, (const char*) info[3]) == 0);
  915. }
  916.     }
  918.     delete pOutFileName;
  919. }
  920.     }
  921. }
  922.     }
  924.     return bRetVal;
  925. }
  927. bool HLXIHXFileTest::HandleRenameCmd(const UTVector<UTString>& info)
  928. {
  929.     bool bRetVal = false;
  931.     if (m_bTestDir)
  932.     {
  933. bRetVal = false;
  935. if (m_pCHXDirectory)
  936. {
  937.     bRetVal = (m_pCHXDirectory->Rename((const char*) info[1],
  938.        (const char*) info[2]) == HXR_OK);
  939.     bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[3]));
  940. }
  941.     }
  943.     return bRetVal;
  944. }