C++ CFileBasic::Open方法代码示例

void TestLogFileRead(void)
{
	CLogFile*		pcLogFile;
	CMemoryFile*	pcMemoryFile;
	CFileBasic		cFile;
	BOOL			bResult;
	int				iLength;
	char			sz[200];
	filePos			iRead;

	pcMemoryFile = MemoryFile();
	cFile.Init(pcMemoryFile);
	cFile.Open(EFM_Write_Create);
	cFile.WriteString("The suspense is killing me!");
	cFile.Close();

	pcLogFile = LogFile(pcMemoryFile);
	cFile.Init(pcLogFile);

	bResult = cFile.Open(EFM_Read);
	AssertTrue(bResult);

	pcLogFile->Begin();

	bResult = cFile.ReadStringLength(&iLength);
	AssertTrue(bResult);
	AssertInt(28, iLength);
	AssertFalse(cFile.IsEndOfFile());
	bResult = cFile.ReadStringChars(sz, iLength);
	AssertString("The suspense is killing me!", sz);
	AssertTrue(cFile.IsEndOfFile());

	memset(sz, 0, 200);
	bResult = cFile.Seek(20);
	AssertTrue(bResult);
	bResult = cFile.ReadStringChars(sz, 8);
	AssertString("killing ", sz);
	AssertLongLongInt(28, cFile.GetFilePos());
	AssertFalse(cFile.IsEndOfFile());

	memset(sz, 0, 200);
	bResult = cFile.ReadStringChars(sz, 4);
	AssertString("me!", sz);
	AssertLongLongInt(32, cFile.GetFilePos());
	AssertTrue(cFile.IsEndOfFile());

	iRead = cFile.Read(sz, 1, 1);
	AssertLongLongInt(0, iRead);
	AssertLongLongInt(32, cFile.GetFilePos());
	AssertTrue(cFile.IsEndOfFile());

	AssertLongLongInt(32, cFile.GetFilePos());
	AssertTrue(cFile.IsEndOfFile());

	bResult = cFile.Close();
	AssertTrue(bResult);

	cFile.Kill();
}

void TestLogFileCommandsComplex(void)
{
	CLogFile*		pcLogFile;
	CMemoryFile*	pcMemoryFile;
	CFileBasic		cFile;
	BOOL			bResult;
	int				iWritten;
	char			szABC[] = {"ABCDEFGHIJK"};
	char			sz123[] = {"123"};
	char			sz4[] = {"4"};
	char			szExclamation[] = {"!?"};
	char			szQWE[] = {"_QWE_"};
	char			szResult[12];

	pcMemoryFile = MemoryFile();
	pcMemoryFile->Open(EFM_ReadWrite_Create);
	pcMemoryFile->Write(szABC, 1, 12);
	pcMemoryFile->Close();

	pcLogFile = LogFile(pcMemoryFile);
	cFile.Init(pcLogFile);

	pcLogFile->Begin();

	cFile.Open(EFM_ReadWrite_Create);
	AssertInt(12, (int)cFile.GetFileLength());

	iWritten = (int)cFile.Write(sz123, 1, 3);
	AssertInt(3, iWritten);
	iWritten = (int)cFile.Write(sz4, 1, 1);
	AssertInt(1, iWritten);
	cFile.Close();

	cFile.Open(EFM_ReadWrite_Create);
	cFile.Write(szExclamation, 1, 2);
	cFile.Seek(3, EFSO_CURRENT);
	cFile.Write(szQWE, 5, 1);
	cFile.Close();

	cFile.Open(EFM_Read);
	AssertInt(12, (int)cFile.GetFileLength());
	memset(szResult, 0, 12);
	cFile.Read(szResult, 12, 1);
	AssertString("!?34E_QWE_K", szResult);
	cFile.Close();
	
	bResult = pcLogFile->Commit();
	AssertTrue(bResult);
	AssertFalse(pcMemoryFile->IsOpen());
	AssertInt(12, pcMemoryFile->GetBufferSize());
	AssertString("!?34E_QWE_K", (char*)pcMemoryFile->GetBufferPointer());

	pcLogFile->Kill();
}

void TestLogFileCommandsSimple(void)
{
	CLogFile*		pcLogFile;
	CMemoryFile*	pcMemoryFile;
	CFileBasic		cFile;
	BOOL			bResult;
	int				iInt;
	int				iWritten;
	int				iResult;
	int				iRead;

	pcMemoryFile = MemoryFile();
	pcLogFile = LogFile(pcMemoryFile);
	cFile.Init(pcLogFile);

	pcLogFile->Begin();

	bResult = cFile.Open(EFM_ReadWrite_Create);
	AssertTrue(bResult);
	AssertTrue(cFile.IsOpen());

	iInt = 872349342;
	iWritten = (int)cFile.Write(&iInt, sizeof(int), 1);
	AssertInt(1, iWritten);
	AssertInt(0, pcMemoryFile->GetBufferSize());

	bResult = cFile.Close();
	AssertTrue(bResult);
	AssertInt(3, pcLogFile->GetNumCommands());

	bResult = cFile.Open(EFM_ReadWrite_Create);
	AssertTrue(bResult);
	AssertTrue(cFile.IsOpen());
	AssertInt(sizeof(int), (int)cFile.GetFileLength());
	iRead = (int)cFile.Read(&iResult, sizeof(int), 1);
	AssertInt(1, iRead);
	AssertInt(iInt, iResult);
	bResult = cFile.Close();
	AssertTrue(bResult);
	AssertInt(5, pcLogFile->GetNumCommands());

	bResult = pcLogFile->Commit();
	AssertTrue(bResult);
	AssertFalse(pcMemoryFile->IsOpen());
	AssertInt(sizeof(int), pcMemoryFile->GetBufferSize());
	AssertInt(iInt, *((int*)pcMemoryFile->GetBufferPointer()));

	pcLogFile->Kill();
}

void TestScratchPadAllocatorReadWrite(void)
{
	MemoryInit();

	CScratchPadAllocator	cAlloc;
	CFileBasic				cFile;
	CScratchPadAllocator	cAllocIn;
	int						i;
	SScratchPadParams		sParams;

	cFile.Init(MemoryFile());
	cFile.Open(EFM_ReadWrite_Create);

	cFile.WriteInt(789);

	cAlloc.Init(32 KB);
	AssertTrue(cAlloc.Write(&cFile));

	cFile.WriteInt(124);

	cFile.Close();
	cAlloc.Kill();

	cFile.Open(EFM_Read);

	cFile.ReadInt(&i);
	AssertInt(789, i);

	AssertTrue(cAllocIn.Read(&cFile));

	cFile.ReadInt(&i);
	AssertInt(124, i);

	AssertInt(0, cAllocIn.GetScratchPad()->GetMemorySize());
	AssertInt(0, cAllocIn.GetScratchPad()->GetUsedSize());
	cAllocIn.GetScratchPad()->GetParams(&sParams);
	AssertInt(32 KB, sParams.iChunkSize);

	MemoryKill();
}

BOOL LoadTGA(CImage* pcImage, char* szFilename)
{
	static char uTGAcompare[12] = {0,0, 2,0,0,0,0,0,0,0,0,0}; // Uncompressed True Colour TGA Header
	//static char cTGAcompare[12] = {0,0,10,0,0,0,0,0,0,0,0,0}; // Compressed True Colour TGA Header
	STGAFileHeader tgaheader;				

	CFileBasic sFile;


	//----------------------------------------------------------------------
	// open the tga file.
	//----------------------------------------------------------------------
	sFile.Init(DiskFile(szFilename));
	if (!sFile.Open(EFM_Read))
	{
		sFile.Kill();
		return FALSE;
	}

	//----------------------------------------------------------------------
	// read the header
	//----------------------------------------------------------------------
	if (sFile.Read(&tgaheader, 1, 12) != 12)
	{
		sFile.Close();
		sFile.Kill();
		return FALSE;
	}

	sFile.Close();
	sFile.Kill();

	//----------------------------------------------------------------------
	// check whether the TGA Header matches a compressed one or not
	//----------------------------------------------------------------------
	if (memcmp(uTGAcompare, &tgaheader, 12) == 0)
	{
		return LoadUncompressedTrueColourTGA(pcImage, szFilename);
	}
	/*
	else 
	if (memcmp(cTGAcompare, &tgaheader, 10) == 0)
	{											
	return LoadCompressedTrueColourTGA(pcImage, filename);
	}
	*/

	//----------------------------------------------------------------------
	// if no header is matched, this is not a supported TGA format.
	//----------------------------------------------------------------------
	return FALSE;
}

CObjectSource* CObjectConverterNative::CreateSource(CAbstractFile* pcFile, char* szFileName)
{
	CObjectSourceChunked*	pcSourceChunked;
	CObjectSourceSimple*	pcSourceSimple;
	BOOL					bResult;
	CFileBasic				cFile;
	int						c;

	if ((!pcFile) || (!szFileName))
	{
		return NULL;
	}

	cFile.Init(pcFile);
	bResult = cFile.Open(EFM_Read);
	if (!bResult)
	{
		return NULL;
	}

	bResult = cFile.ReadInt(&c);
	if (!bResult)
	{
		return NULL;
	}

	if (c == CHUNKED_OBJECT_FILE)
	{
		pcSourceChunked = UMalloc(CObjectSourceChunked);
		bResult = pcSourceChunked->Init(this, pcFile, szFileName);
		if (!bResult)
		{
			return NULL;
		}
		return pcSourceChunked;
	}
	else if (c == BASIC_OBJECT_FILE)
	{
		pcSourceSimple = UMalloc(CObjectSourceSimple);
		pcSourceSimple->Init(this, pcFile, szFileName);
		return pcSourceSimple;
	}
	else
	{
		return NULL;
	}
}

void TestLogFileOpen(void)
{
	CLogFile*		pcLogFile;
	CMemoryFile*	pcMemoryFile;
	CFileBasic		cFile;
	BOOL			bResult;

	pcMemoryFile = MemoryFile();
	pcLogFile = LogFile(pcMemoryFile);
	AssertNotNull(pcLogFile);

	cFile.Init(pcLogFile);

	bResult = cFile.Open(EFM_ReadWrite_Create);
	AssertTrue(bResult);

	bResult = cFile.Close();
	AssertTrue(bResult);

	cFile.Kill();
}

void TestBufferedFileReadWrite(void)
{
	CFileUtil	cFileUtil;
	CFileBasic	cFile;
	CTextFile	cText;
	char		sz[20];

	cFileUtil.Delete("Test.txt");

	cFile.Init(BufferedFile(DiskFile("Test.txt"), 3));
	cFile.Open(EFM_ReadWrite_Create);
	cFile.Write("abcdefghijklmn", 1, 14);
	cFile.Write("op", 1, 2);
	cFile.Seek(3);
	memset(sz, 0, 20);
	cFile.Read(sz, 2, 1);
	AssertString("de", sz);
	cFile.Read(sz, 2, 1);
	AssertString("fg", sz);
	cFile.Write("12", 2, 1);
	cFile.Read(sz, 2, 1);
	AssertString("jk", sz);
	cFile.Write("34", 2, 1);
	cFile.Read(sz, 2, 1);
	AssertString("no", sz);
	cFile.Seek(2);
	cFile.Write("XY", 2, 1);
	cFile.Read(sz, 1, 3);
	AssertString("efg", sz);
	cFile.Close();
	cFile.Kill();

	cText.Init();
	cText.Read("Test.txt");
	AssertString("abXYefg12jk34nop", cText.mcText.Text());
	cText.Kill();

	cFileUtil.Delete("Test.txt");
}

void TestBufferedFileRead(void)
{
	CFileUtil	cFileUtil;
	CFileBasic	cFile;
	CTextFile	cText;
	char		sz[20];
	char		c;
	int			iCount;
	int			i;
	char		szExpected[20];

	cFileUtil.Delete("Test.txt");

	cText.Init();
	cText.mcText.Append("abcdefghijk");
	cText.Write("Test.txt");
	cText.Kill();

	cFile.Init(BufferedFile(DiskFile("Test.txt"), 3));

	cFile.Open(EFM_Read);

	for (c = 'a'; c <= 'k'; c++)
	{
		AssertFalse(cFile.IsEndOfFile());
		memset(sz, 0, 20);
		iCount = (int)cFile.Read(sz, 1, 1);
		AssertChar(c, sz[0]);
		AssertChar(0, sz[1]);
		AssertInt(1, iCount);
	}
	AssertTrue(cFile.IsEndOfFile());

	cFile.Seek(0);

	szExpected[2] = 0;
	for (i = 0; i < 5; i++)
	{
		AssertFalse(cFile.IsEndOfFile());
		memset(sz, 0, 20);
		iCount = (int)cFile.Read(sz, 1, 2);
		szExpected[0] = 'a' + (char)i * 2;
		szExpected[1] = 'b' + (char)i * 2;
		AssertString(szExpected, sz);
		AssertInt(2, iCount);
	}
	AssertFalse(cFile.IsEndOfFile());
	memset(sz, 0, 20);
	iCount = (int)cFile.Read(sz, 1, 2);
	AssertString("k", sz);
	AssertInt(1, iCount);
	AssertTrue(cFile.IsEndOfFile());

	cFile.Seek(0);

	szExpected[3] = 0;
	for (i = 0; i < 3; i++)
	{
		AssertFalse(cFile.IsEndOfFile());
		memset(sz, 0, 20);
		iCount = (int)cFile.Read(sz, 1, 3);
		szExpected[0] = 'a' + (char)i * 3;
		szExpected[1] = 'b' + (char)i * 3;
		szExpected[2] = 'c' + (char)i * 3;
		AssertString(szExpected, sz);
		AssertInt(3, iCount);
	}
	AssertFalse(cFile.IsEndOfFile());
	memset(sz, 0, 20);
	iCount = (int)cFile.Read(sz, 1, 3);
	AssertString("jk", sz);
	AssertInt(2, iCount);
	AssertTrue(cFile.IsEndOfFile());

	cFile.Kill();

	cFileUtil.Delete("Test.txt");
}

void TestLogFileMultipleReadsAfterOpens(void)
{
	CLogFile*		pcLogFile;
	CDiskFile*		pcDiskFile;
	CFileBasic		cFile;
	CFileUtil		cFileUtil;
	char			szSource[] = {"The Name of the Wise Man"};
	int				iSourcelen;
	char			szResult[50];
	char			szWrite[] = {"Cat Catt ct... "};
	int				iWriteLen;
	char			szA[] = {"A"};

	cFileUtil.RemoveDir("Output/LogFile2");
	cFileUtil.MakeDir("Output/LogFile2");
	pcDiskFile = DiskFile("Output/LogFile2/OpenClose.txt");
	pcDiskFile->Open(EFM_ReadWrite_Create);
	iSourcelen = (int)strlen(szSource);
	pcDiskFile->Write(szSource, iSourcelen + 1, 1);
	pcDiskFile->Close();
	AssertTrue(cFileUtil.Exists("Output/LogFile2/OpenClose.txt"));

	pcLogFile = LogFile(pcDiskFile);
	cFile.Init(pcLogFile);
	pcLogFile->Begin();

	AssertTrue(cFile.Open(EFM_Read));
	AssertInt(iSourcelen + 1, (int)cFile.GetFileSize());
	cFile.ReadData(szResult, iSourcelen + 1);
	AssertString(szSource, szResult);
	cFile.Close();

	cFile.Open(EFM_ReadWrite_Create);
	iWriteLen = (int)strlen(szWrite);
	cFile.WriteData(szWrite, iWriteLen);
	AssertInt(iSourcelen + 1, (int)cFile.GetFileSize());
	pcLogFile->Close();

	cFile.Delete();
	AssertTrue(cFileUtil.Exists("Output/LogFile2/OpenClose.txt"));
	AssertInt(0, (int)cFile.GetFileSize());

	cFile.Open(EFM_ReadWrite_Create);
	cFile.Write(szA, 2, 1);
	AssertInt(2, (int)cFile.GetFileSize());

	cFile.Close();

	pcLogFile->Commit();
	cFile.Kill();

	AssertTrue(cFileUtil.Exists("Output/LogFile2/OpenClose.txt"));
	AssertInt(2, cFileUtil.Size("Output/LogFile2/OpenClose.txt"));

	pcDiskFile = DiskFile("Output/LogFile2/OpenClose.txt");
	pcLogFile = LogFile(pcDiskFile);
	cFile.Init(pcLogFile);
	pcLogFile->Begin();

	AssertTrue(cFile.Open(EFM_Read));
	cFile.ReadData(szResult, 2);
	AssertString("A", szResult);

	cFile.Seek(0);
	cFile.ReadData(szResult, 2);
	AssertString("A", szResult);

	cFile.Close();

	cFile.Delete();
	pcLogFile->Commit();
	cFile.Kill();

	AssertFalse(cFileUtil.Exists("Output/LogFile2/OpenClose.txt"));
}

void TestBufferedFileWrite(void)
{
	CFileUtil	cFileUtil;
	CFileBasic	cFile;
	CTextFile	cText;

	cFileUtil.Delete("Test.txt");

	cFile.Init(BufferedFile(DiskFile("Test.txt"), 3));
	cFile.Open(EFM_Write_Create);
	cFile.Write("ab", 1, 2);
	cFile.Write("cd", 1, 2);
	cFile.Close();
	cFile.Kill();

	cText.Init();
	cText.Read("Test.txt");
	AssertString("abcd", cText.mcText.Text());
	cText.Kill();

	cFile.Init(BufferedFile(DiskFile("Test.txt"), 5));
	cFile.Open(EFM_Write_Create);
	cFile.Write("abcdefghi", 1, 9);
	cFile.Write("jklmn", 1, 5);
	cFile.Close();
	cFile.Kill();

	cText.Init();
	cText.Read("Test.txt");
	AssertString("abcdefghijklmn", cText.mcText.Text());
	cText.Kill();

	cFile.Init(BufferedFile(DiskFile("Test.txt"), 5));
	cFile.Open(EFM_ReadWrite);
	cFile.Seek(4);
	cFile.Write("xyz", 3, 1);
	cFile.Close();
	cFile.Kill();

	cText.Init();
	cText.Read("Test.txt");
	AssertString("abcdxyzhijklmn", cText.mcText.Text());
	cText.Kill();

	cFile.Init(BufferedFile(DiskFile("Test.txt"), 8));
	cFile.Open(EFM_ReadWrite);
	cFile.Seek(0, EFSO_END);
	cFile.Write("opqrst", 6, 1);
	cFile.Seek(0);
	cFile.Write("123456", 6, 1);
	cFile.Write("78", 2, 1);
	cFile.Close();
	cFile.Kill();

	cText.Init();
	cText.Read("Test.txt");
	AssertString("12345678ijklmnopqrst", cText.mcText.Text());
	cText.Kill();

	cFile.Init(BufferedFile(DiskFile("Test.txt"), 3));
	cFile.Open(EFM_Write_Create);
	cFile.Write("ab", 1, 2);
	cFile.Write("cdef", 1, 4);
	cFile.Write("gh", 1, 2);
	cFile.Close();
	cFile.Kill();

	cText.Init();
	cText.Read("Test.txt");
	AssertString("abcdefgh", cText.mcText.Text());
	cText.Kill();

	cFileUtil.Delete("Test.txt");
}

BOOL LoadUncompressedTrueColourTGA(CImage *pcImage, char *szFilename)
{
	STGAImageHeader 		sTGAImageHeader;
	STGAFileHeader  		sTGAFileHeader;				// Used To Store Our File Header
	CFileBasic				sFile;
	int   					iWidth;
	int   					iHeight;
	int   					iBitsPerPixel;
	int   					iBytesPerPixel;
	int   					iImageSize;
	unsigned char*			pvMem;
	CImage					cImageImport;
	CImageCopier			cCopier;
	filePos					iRead;
	int						i;
	int						iStride;

	//----------------------------------------------------------------------
	// open the tga file.
	//----------------------------------------------------------------------
	sFile.Init(DiskFile(szFilename));
	if (!sFile.Open(EFM_Read))
	{
		sFile.Kill();
		return FALSE;
	}

	//----------------------------------------------------------------------
	// read the header
	//----------------------------------------------------------------------

	//Error check please.
	memset(&sTGAFileHeader, 0, sizeof(STGAFileHeader));
	sFile.Read(&sTGAFileHeader.iIDLength, 1, 1);
	sFile.Read(&sTGAFileHeader.iColourMapType, 1, 1);
	sFile.Read(&sTGAFileHeader.iImageType, 1, 1);
	sFile.Read(&sTGAFileHeader.iFirstEntryIndex, 2, 1);
	sFile.Read(&sTGAFileHeader.iColourMapLength, 2, 1);
	sFile.Read(&sTGAFileHeader.iColourMapEntrySize, 1, 1);
	sFile.Read(&sTGAFileHeader.iOriginX, 2, 1);
	sFile.Read(&sTGAFileHeader.iOriginY, 2, 1);

	//Error check please.
	memset(&sTGAImageHeader, 0, sizeof(STGAImageHeader));
	sFile.Read(&sTGAImageHeader.iImageWidth, 2, 1);
	sFile.Read(&sTGAImageHeader.iImageHeight, 2, 1);
	sFile.Read(&sTGAImageHeader.iPixelDepth, 1, 1);
	sFile.Read(&sTGAImageHeader.iPixelDescriptor, 1, 1);


	//----------------------------------------------------------------------
	// get the TGA dimensions
	//----------------------------------------------------------------------
	iWidth        = (sTGAImageHeader.iImageWidth);
	iHeight       = (sTGAImageHeader.iImageHeight);
	iBitsPerPixel = sTGAImageHeader.iPixelDepth;

	//----------------------------------------------------------------------
	// Make Sure All Information Is Valid
	//----------------------------------------------------------------------
	if ((iWidth <= 0) || (iHeight <= 0))
	{
		sFile.Close();
		sFile.Kill();
		return FALSE;
	}

	switch (iBitsPerPixel)
	{
	case 16:
		iBytesPerPixel = 2;
		break;
	case 24:
		iBytesPerPixel = 3;
		break;
	case 32:
		iBytesPerPixel = 4;
		break;
	default:
		sFile.Close();
		sFile.Kill();
		return FALSE;
	}

	iBytesPerPixel = (iBitsPerPixel / 8);				  // Calculate The BYTES Per Pixel
	iImageSize     = (iBytesPerPixel * iWidth * iHeight); // Calculate Memory Needed To Store Image
	iStride = iWidth * iBytesPerPixel;

	pvMem = (unsigned char*)malloc(iImageSize);
	iRead = sFile.Read(pvMem, iImageSize, 1);
	if (iRead != 1)
	{
		free(pvMem);
		sFile.Close();
		sFile.Kill();
		return FALSE;	
	}
	sFile.Close();
	sFile.Kill();

//.........这里部分代码省略.........

void TestLogFileFindHoles(void)
{
	CLogFile*		pcLogFile;
	CFileBasic		cFile;
	BOOL			bResult;
	int				iInt1;
	int				iInt2;
	int				iInt3;
	CArrayPointer	apvOverlapping;
	int				i;
	int				iSize;

	pcLogFile = LogFile(NULL);
	cFile.Init(pcLogFile);

	pcLogFile->Begin();

	bResult = cFile.Open(EFM_ReadWrite_Create);
	AssertTrue(bResult);
	
	iInt1 = 872349342;
	iInt2 = 763421934;
	iInt3 = 158723346;
	iSize = sizeof(int);

	apvOverlapping.Init();
	bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 0, 1);
	AssertTrue(bResult);
	AssertInt(0, apvOverlapping.NumElements());
	apvOverlapping.Kill();

	cFile.Write(&iInt1, 4, 1);
	bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 0, 4);
	AssertFalse(bResult);

	cFile.Write(&iInt2, 4, 1);
	bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 0, 8);
	AssertFalse(bResult);

	for (i = 0; i < 8; i++)
	{
		bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 0, i);
		AssertFalse(bResult);
	}
	for (i = 0; i < 8; i++)
	{
		bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, i, 8 -i);
		AssertFalse(bResult);
	}
	bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 7, 2);
	AssertTrue(bResult);
	AssertInt(1, apvOverlapping.NumElements());
	apvOverlapping.Kill();

	cFile.Seek(4, EFSO_CURRENT);
	cFile.Write(&iInt3, 4, 1);
	bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 0, 16);
	AssertTrue(bResult);
	AssertInt(2, apvOverlapping.NumElements());
	apvOverlapping.Kill();

	bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 12, 4);
	AssertFalse(bResult);

	bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 11, 5);
	AssertTrue(bResult);
	AssertInt(1, apvOverlapping.NumElements());
	apvOverlapping.Kill();

	bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 0, 8);
	AssertFalse(bResult);

	bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 0, 9);
	AssertTrue(bResult);
	AssertInt(1, apvOverlapping.NumElements());
	apvOverlapping.Kill();

	bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 7, 2);
	AssertTrue(bResult);
	AssertInt(1, apvOverlapping.NumElements());
	apvOverlapping.Kill();

	apvOverlapping.Init();
	bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 8, 1);
	AssertTrue(bResult);
	AssertInt(0, apvOverlapping.NumElements());
	apvOverlapping.Kill();

	apvOverlapping.Init();
	bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 8, 4);
	AssertTrue(bResult);
	AssertInt(0, apvOverlapping.NumElements());
	apvOverlapping.Kill();

	bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 8, 5);
	AssertTrue(bResult);
	AssertInt(1, apvOverlapping.NumElements());
	apvOverlapping.Kill();

	bResult = pcLogFile->TestFindHoles(1, &apvOverlapping, 0, 0);
//.........这里部分代码省略.........

void TestLogFileWrite(void)
{
	CLogFile*		pcLogFile;
	CMemoryFile*	pcMemoryFile;
	CFileBasic		cFile;
	BOOL			bResult;
	int				iLength;
	char			sz[200];

	pcMemoryFile = MemoryFile();
	pcLogFile = LogFile(pcMemoryFile);
	cFile.Init(pcLogFile);

	bResult = cFile.Open(EFM_ReadWrite_Create);
	AssertTrue(bResult);

	bResult = cFile.WriteString("The suspense is killing me!");
	AssertTrue(bResult);
	AssertNull((char*)pcMemoryFile->GetBufferPointer());
	
	AssertInt(1, pcLogFile->GetNumWrites());
	AssertLongLongInt(32, pcLogFile->GetWriteSize(0));

	bResult = cFile.Seek(8);
	AssertTrue(bResult);

	bResult = cFile.WriteData("camisole", 8);
	AssertTrue(bResult);
	AssertInt(1, pcLogFile->GetNumWrites());
	AssertLongLongInt(32, pcLogFile->GetWriteSize(0));
	
	AssertNull((char*)pcMemoryFile->GetBufferPointer());
	cFile.Seek(0);
	bResult = cFile.ReadStringLength(&iLength);
	AssertTrue(bResult);
	AssertInt(28, iLength);
	AssertFalse(cFile.IsEndOfFile());
	bResult = cFile.ReadStringChars(sz, iLength);
	AssertString("The camisole is killing me!", sz);
	AssertTrue(cFile.IsEndOfFile());

	bResult = pcLogFile->Commit();
	AssertTrue(bResult);
	AssertString("The camisole is killing me!", (char*)RemapSinglePointer(pcMemoryFile->GetBufferPointer(), sizeof(int)));

	bResult = cFile.Close();  //This should go before Commit
	AssertTrue(bResult);

	pcLogFile->Begin();
	
	bResult = cFile.Open(EFM_ReadWrite_Create);
	AssertTrue(bResult);

	bResult = cFile.Seek(4);
	AssertTrue(bResult);
	bResult = cFile.WriteData("Dog", 3);

	bResult = cFile.Seek(20);
	AssertTrue(bResult);
	bResult = cFile.WriteData("plurgle", 7);

	AssertInt(2, pcLogFile->GetNumWrites());
	AssertLongLongInt(3, pcLogFile->GetWriteSize(0));
	AssertLongLongInt(7, pcLogFile->GetWriteSize(1));

	AssertString("The camisole is killing me!", (char*)RemapSinglePointer(pcMemoryFile->GetBufferPointer(), sizeof(int)));
	cFile.Seek(0);
	bResult = cFile.ReadStringLength(&iLength);
	AssertTrue(bResult);
	AssertInt(28, iLength);
	AssertFalse(cFile.IsEndOfFile());
	bResult = cFile.ReadStringChars(sz, iLength);
	AssertTrue(bResult);
	AssertString("Dog camisole is plurgle me!", sz);
	AssertTrue(cFile.IsEndOfFile());

	bResult = pcLogFile->Commit();
	AssertTrue(bResult);
	AssertString("Dog camisole is plurgle me!", (char*)RemapSinglePointer(pcMemoryFile->GetBufferPointer(), sizeof(int)));

	bResult = cFile.Close();
	AssertTrue(bResult);

	pcLogFile->Begin();

	bResult = cFile.Open(EFM_ReadWrite_Create);
	AssertTrue(bResult);

	cFile.Seek(4);
	cFile.WriteData("X", 1);
	cFile.Seek(6);
	bResult = cFile.WriteData("Z", 1);
	cFile.Seek(28);
	cFile.WriteData("A", 1);
	cFile.Seek(30);
	bResult = cFile.WriteData("C", 1);
	AssertInt(4, pcLogFile->GetNumWrites());

	cFile.Seek(5);
	cFile.WriteData("Y", 1);
//.........这里部分代码省略.........