ihxfiletest.cpp

linux下的一款播放器

    if (m_pIHXDataFile)
    {
	unsigned int uiReadSize = 0;

	if (UTParamUtil::GetUInt(info[1], uiReadSize))
	{
	    IHXBuffer* pHXBuffer = NULL;
	    bool bReadOK;

	    ULONG32 ulRetSize = m_pIHXDataFile->Read(pHXBuffer, uiReadSize);

	    bReadOK = ((ulRetSize != 0) && (ulRetSize != -1));
	    bRetVal = (bReadOK == CFileTestUtil::ParseResultString(info[2]));

	    if (bRetVal && bReadOK)
	    {
		bRetVal = false;

		if (info.Nelements() > 3)
		{
		    bRetVal = CFileTestUtil::CheckBuffer(info[3], 
							 pHXBuffer);
		}
	    }

	    HX_RELEASE(pHXBuffer);
	}
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleSeekCmd(const UTVector<UTString>& info)
{
    bool bRetVal = false;

    if (m_pIHXDataFile)
    {
	unsigned int uiSeekOffset = 0;

	if (UTParamUtil::GetUInt(info[1], uiSeekOffset))
	{
	    HX_RESULT retVal = m_pIHXDataFile->Seek(
		uiSeekOffset, 
		CFileTestUtil::ParseSeekModeString(info[2]));

	    bRetVal = (retVal == HXR_OK);
	    bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[3]));
	}
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleRewindCmd(const UTVector<UTString>& info)
{
    bool bRetVal = false;

    if (m_pIHXDataFile)
    {
	HX_RESULT retVal = HXR_FAIL;

	if (m_pCHXDataFile)
	{
	    retVal = m_pCHXDataFile->Rewind();
	}
	else
	{ 
	    retVal = m_pIHXDataFile->Seek(0, SEEK_SET);
	}

	bRetVal = (retVal == HXR_OK);
	bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleTellCmd(const UTVector<UTString>& info)
{
    bool bRetVal = false;

    if (m_pIHXDataFile)
    {
	unsigned int uiFileOffset = 0;

	ULONG32 ulRetFileOffset = m_pIHXDataFile->Tell();

	bRetVal = true;

	if ((info.Nelements() > 1) &&
	    UTParamUtil::GetUInt(info[1], uiFileOffset))
	{
	    bRetVal = (ulRetFileOffset == uiFileOffset);
	}
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleStatCmd(const UTVector<UTString>& info)
{
    bool bRetVal = false;

    if (m_pIHXDataFile)
    {
	struct stat statBuffer;

	HX_RESULT retVal = m_pIHXDataFile->Stat(&statBuffer);

	bRetVal = (retVal == HXR_OK);
	bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));

	if (bRetVal && (retVal == HXR_OK) && (info.Nelements() > 2))
	{
	    unsigned int uiFileSize = 0;
	    bRetVal = false;

	    if (UTParamUtil::GetUInt(info[2], uiFileSize))
	    {
		bRetVal = (statBuffer.st_size == uiFileSize);
	    }
	}
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleDeleteCmd(const UTVector<UTString>& info)
{
    bool bRetVal = false;

    if (m_pIHXDataFile)
    {
	if (info.Nelements() == 2)
	{
	    HX_RESULT retVal = m_pIHXDataFile->Delete();
	    bRetVal = (retVal == HXR_OK);
	    bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
	}
	else if (info.Nelements() == 3)
	{
	    HX_RESULT retVal = HXR_FAIL;

	    if (m_pCHXDataFile)
	    {
		retVal = m_pCHXDataFile->Delete((const char*) info[1]);
	    }
	    else
	    {
		m_pIHXDataFile->Bind((const char*) info[1]);
		retVal = m_pIHXDataFile->Delete();
	    }

	    bRetVal = (retVal == HXR_OK);
	    bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
	}
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleGetFdCmd(const UTVector<UTString>& info)
{
    bool bRetVal = false;

    if (m_pIHXDataFile)
    {
	INT16 iFd = m_pIHXDataFile->GetFd();
	bRetVal = true;
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleGetLastErrorCodeCmd(const UTVector<UTString>& info)
{
    bool bRetVal = false;

    if (m_pIHXDataFile)
    {
	HX_RESULT retVal = m_pIHXDataFile->GetLastError();
	bRetVal = (retVal == HXR_OK);
	bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleGetLastErrorStringCmd(const UTVector<UTString>& info)
{
    bool bRetVal = false;

    if (m_pIHXDataFile)
    {
	IHXBuffer* pHXBuffer = NULL;

	m_pIHXDataFile->GetLastError(pHXBuffer);

	HX_RELEASE(pHXBuffer);

	bRetVal = true;
    }

    return bRetVal;
}


/*****************************************************************************
 *    Directory Commands
 */ 
bool HLXIHXFileTest::HandleSetDirPathCmd(const UTVector<UTString>& info)
{
    bool bRetVal = true;

    if (m_bTestDir)
    {
	bRetVal = false;

	if (m_pCHXDirectory)
	{
	    m_pCHXDirectory->SetPath((const char*) info[1]);
	    bRetVal = true;
	}
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleGetDirPathCmd(const UTVector<UTString>& info)
{
    bool bRetVal = true;

    if (m_bTestDir)
    {
	bRetVal = false;
	
	if (m_pCHXDirectory)
	{
	    const char* pPath;
	    
	    pPath = m_pCHXDirectory->GetPath();

	    bRetVal = (pPath ? true : false);
	    bRetVal = (bRetVal == (CFileTestUtil::ParseResultString(info[1]) ? true : false));
	    if (bRetVal && pPath)
	    {
		bRetVal = false;
		
		if (info.Nelements() > 2)
		{
		    bRetVal = (strcmp(info[2], pPath) == 0);
		}
		else
		{
		    bRetVal = true;
		}
	    }
	}
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleCreateDirCmd(const UTVector<UTString>& info)
{
    bool bRetVal = true;

    if (m_bTestDir)
    {
	bRetVal = false;

	if (m_pCHXDirectory)
	{
	    bRetVal = (m_pCHXDirectory->Create() != FALSE);
	    bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
	}
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleIsDirValidCmd(const UTVector<UTString>& info)
{
    bool bRetVal = false;

    if (m_bTestDir)
    {
	bRetVal = false;

	if (m_pCHXDirectory)
	{
	    bRetVal = (m_pCHXDirectory->IsValid() != FALSE);
	    bRetVal = (bRetVal == CFileTestUtil::ParseBoolString(info[1]));
	}
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleDestroyDirCmd(const UTVector<UTString>& info)
{
    bool bRetVal = false;

    if (m_bTestDir)
    {
	bRetVal = false;

	if (m_pCHXDirectory)
	{
	    bool bDestroyContents = CFileTestUtil::ParseBoolString(info[1]);

	    bRetVal = (m_pCHXDirectory->Destroy(bDestroyContents ? TRUE : FALSE) != FALSE);
	    if (info.Nelements() > 2)
	    {
		bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
	    }
	    else
	    {
		bRetVal = true;
	    }
	}
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleDeleteDirFileCmd(const UTVector<UTString>& info)
{
    bool bRetVal = false;

    if (m_bTestDir)
    {
	bRetVal = false;

	if (m_pCHXDirectory)
	{
	    bRetVal = (m_pCHXDirectory->DeleteFile((const char*) info[1]) != FALSE);
	    bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[2]));
	}
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleMakeCurrentDirCmd(const UTVector<UTString>& info)
{
    bool bRetVal = true;

    if (m_bTestDir)
    {
	bRetVal = false;

	if (m_pCHXDirectory)
	{
	    bRetVal = (m_pCHXDirectory->MakeCurrentDir() != FALSE);
	    bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[1]));
	}
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleFindFirstInDirCmd(const UTVector<UTString>& info)
{
    bool bRetVal = true;

    if (m_bTestDir)
    {
	bRetVal = false;

	if (m_pCHXDirectory)
	{
	    unsigned int uiFileNameSize = 0;
	    char* pOutFileName = NULL;

	    if (UTParamUtil::GetUInt(info[2], uiFileNameSize))
	    {
		pOutFileName = new char [uiFileNameSize];

		if (pOutFileName)
		{
		    XHXDirectory::FSOBJ retObj;

		    retObj = m_pCHXDirectory->FindFirst((const char*) info[1],	// pattern
							pOutFileName,
							uiFileNameSize);

		    bRetVal = (retObj == CFileTestUtil::ParseFSOBJString(
					    (const char*) info[3], 
					    (retObj != XHXDirectory::FSOBJ_NOTVALID) ? retObj : XHXDirectory::FSOBJ_FILE));

		    if (bRetVal && (retObj != XHXDirectory::FSOBJ_NOTVALID))
		    {
			if (info.Nelements() > 4)
			{
			    bRetVal = (strcmp(pOutFileName, (const char*) info[4]) == 0);
			}
		    }

		    delete pOutFileName;
		}
	    }
	}
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleFindNextInDirCmd(const UTVector<UTString>& info)
{
    bool bRetVal = true;

    if (m_bTestDir)
    {
	bRetVal = false;

	if (m_pCHXDirectory)
	{
	    unsigned int uiFileNameSize = 0;
	    char* pOutFileName = NULL;

	    if (UTParamUtil::GetUInt(info[1], uiFileNameSize))
	    {
		pOutFileName = new char [uiFileNameSize];

		if (pOutFileName)
		{
		    XHXDirectory::FSOBJ retObj;

		    retObj = m_pCHXDirectory->FindNext(pOutFileName,	// path
						       uiFileNameSize);

		    bRetVal = (retObj == CFileTestUtil::ParseFSOBJString((const char*) info[2], retObj));

		    if (bRetVal && (retObj != XHXDirectory::FSOBJ_NOTVALID))
		    {
			if (info.Nelements() > 3)
			{
			    bRetVal = (strcmp(pOutFileName, (const char*) info[3]) == 0);
			}
		    }

		    delete pOutFileName;
		}
	    }
	}
    }

    return bRetVal;
}

bool HLXIHXFileTest::HandleRenameCmd(const UTVector<UTString>& info)
{
    bool bRetVal = false;

    if (m_bTestDir)
    {
	bRetVal = false;

	if (m_pCHXDirectory)
	{
	    bRetVal = (m_pCHXDirectory->Rename((const char*) info[1],
					       (const char*) info[2]) == HXR_OK);
	    bRetVal = (bRetVal == CFileTestUtil::ParseResultString(info[3]));
	}
    }

    return bRetVal;
}