FCL/sf/os/kernelhwsrv: comparison kerneltest/f32test/shostmassstorage/msman/test/cblockdevicetester.cpp

equal deleted inserted replaced

-:94f2adf59133
+:b2826f67641f
-// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+// Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
 // All rights reserved.
 // This component and the accompanying materials are made available
 // under the terms of the License "Eclipse Public License v1.0"
 // which accompanies this distribution, and is available
 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
 #include <e32cmn.h>
 #include <f32file.h>
 #include <e32test.h>
 #include <e32math.h>
-#include "tmslog.h"
 #include "cblockdevicetester.h"
 extern RTest test;
 extern RFs fsSession;
 _LIT8(KTxtTestConfig,       "C");
 void TLocalBuffer::Init()
 {
-__MSFNSLOG
 TInt64 rndSeed = 123456789;
 //-- initialize buffer with random rubbish
 iBuffer.SetMax();
 for (TInt i = 0; i < KSize; ++i)
 RTargetMedia::RTargetMedia(TInt aDriveNumber)
 :   iDriveNumber(aDriveNumber)
 {
-__MSFNSLOG
 }
 void RTargetMedia::OpenL()
 {
-__MSFNSLOG
 User::LeaveIfError(iRawDisk.Open(fsSession, iDriveNumber));
 }
 void RTargetMedia::Close()
 {
-__MSFNSLOG
 iRawDisk.Close();
 }
 TInt RTargetMedia::MediaRawWrite(TPos aPos, const TDesC8& aData)
 {
-__MSFNSLOG
 return iRawDisk.Write(aPos, (TDesC8&)aData);
 }
 TInt RTargetMedia::MediaRawRead(TPos aPos, TUint32 aLen, TDes8& aData)
 {
-__MSFNSLOG
 aData.SetMax();
 TPtr8 ptr = aData.LeftTPtr(aLen);
 TInt err = iRawDisk.Read(aPos, ptr);
 aData.SetLength(aLen);
 return err;
 {
 }
 TInt RTargetDrive::OpenTestAreaL(const TDesC8& aData)
 {
-__MSFNSLOG
 RTargetMedia::OpenL();
 iStartLba = 0x20;
 iSource.Set(aData);
 test.Printf(_L("Test area located @ LBA=%x\n"), iStartLba);
 }
 TInt RTargetDrive::Update(TInt aPos, TUint aLen)
 {
-__MSFNSLOG
 TPtrC8 ptr = iSource.Mid(aPos, aLen);
 TPos targetPos = TargetPos(aPos);
 return MediaRawWrite(targetPos, ptr);
 }
 TInt RTargetDrive::Verify()
 {
-__MSFNLOG
 TInt res = MediaRawRead(StartPos(), iSource.Length(), iTmpBuffer);
 if (res)
 return res;
 res = iTmpBuffer.Compare(iSource);
 return res == 0 ? KErrNone : KErrCorrupt;
 }
 TInt RTargetDrive::Verify(TInt aPos, TUint aLen)
 {
-__MSFNSLOG
 TPos pos = TargetPos(aPos);
 TInt res = MediaRawRead(pos, aLen, iTmpBuffer);
 if (res)
 return res;
 }
 TInt RTargetDrive::VerifyBlock(TLba aLba, TLba aBlocks)
 {
-__MSFNSLOG
 return Verify(TLbaUtils::Pos(aLba), TLbaUtils::Length(aBlocks));
 }
 _LIT(KTxtControlFile, "ControlFile.txt");
 static const TChar KFillChar = 'x';
 TTargetTestArea::TTargetTestArea(RTargetMedia& aMedia)
 :   iTargetMedia(aMedia)
 {
-__MSFNLOG
 }
 void TTargetTestArea::CreateControlFile()
 {
-__MSFNLOG
 iStartLba = -1;
 static const TInt KBlockSize = 0x200;
 static const TInt KFileSize = KBlockSize * 8;
 RFile file;
 }
 void TTargetTestArea::RemoveControlFile()
 {
-__MSFNLOG
 TInt err = fsSession.Delete(KTxtControlFile);
 test(err == KErrNone);
 }
 void TTargetTestArea::FindBlockStartL()
 {
-__MSFNLOG
 iTargetMedia.OpenL();
 // search for first block
 TBuf8<KBlockSize> readBlock;
 TBuf8<KBlockSize> refBlock;
 refBlock.Fill(KFillChar, KBlockSize);
 }
 TInt TTargetTestArea::WriteBlockL(TBuf8<KBlockSize>& aBlock)
 {
-__MSFNLOG
 iTargetMedia.OpenL();
 TInt err = iTargetMedia.MediaRawWrite(iStartLba * KBlockSize, aBlock);
 iTargetMedia.Close();
 return err;
 }
 TInt TTargetTestArea::ReadBlockL(TBuf8<KBlockSize>& aBlock)
 {
-__MSFNLOG
 iTargetMedia.OpenL();
 TInt err = iTargetMedia.MediaRawRead(iStartLba * KBlockSize, KBlockSize, aBlock);
 iTargetMedia.Close();
 return err;
 }
 RBlockTargetMedia::RBlockTargetMedia(TInt aDriveNumber)
 :   RTargetMedia(aDriveNumber)
 {
-__MSFNSLOG
 }
 void RBlockTargetMedia::OpenL()
 {
-__MSFNSLOG
 RTargetMedia::OpenL();
 TInt64 rndSeed = 123456789;
 //-- initialize buffer with random rubbish
 }
 TInt RBlockTargetMedia::WriteBlock(TLba aLba)
 {
-__MSFNSLOG
 TPos pos = TLbaUtils::Pos(aLba);
 return iRawDisk.Write(pos, (TDesC8&)iBlockData);
 }
 TInt RBlockTargetMedia::ReadBlock(TLba aLba)
 {
-__MSFNSLOG
 TBuf8<KBlockSize> blockData;
 TPos pos = TLbaUtils::Pos(aLba);
 blockData.SetMax();
 TInt err = iRawDisk.Read(pos, blockData);
 return err;
 }
 CBlockDeviceTester* CBlockDeviceTester::NewL(TInt aDriveNumber)
 {
-__MSFNSLOG
+CBlockDeviceTester* r = new (ELeave) CBlockDeviceTester(aDriveNumber);
-	CBlockDeviceTester* r = new (ELeave) CBlockDeviceTester(aDriveNumber);
+CleanupStack::PushL(r);
-	CleanupStack::PushL(r);
+r->ConstructL();
-	r->ConstructL();
+CleanupStack::Pop();
-	CleanupStack::Pop();
+return r;
-	return r;
 }
 void CBlockDeviceTester::ConstructL()
 {
-__MSFNLOG
 TVolumeInfo volumeInfo;
 User::LeaveIfError(fsSession.Volume(volumeInfo, iDriveNumber));
 test.Printf(_L("Drive=%d Size = %lx\n"), iDriveNumber, volumeInfo.iSize);
 iDriveSizeInBlocks = volumeInfo.iSize / KBlockSize;
 CBlockDeviceTester::CBlockDeviceTester(TInt aDriveNumber)
 :   iDriveNumber(aDriveNumber),
 iTargetDrive(aDriveNumber)
 {
-__MSFNLOG
 }
 CBlockDeviceTester::~CBlockDeviceTester()
 {
-__MSFNLOG
 iTargetDrive.Close();
 }
 void CBlockDeviceTester::OpenDriveL()
 TInt CBlockDeviceTester::VerifyDrive()
 {
-__MSFNLOG
 return iTargetDrive.Verify();
 }
 TInt CBlockDeviceTester::Update(TPos aPos, TUint aLen)
 {
-__MSFNLOG
 iLocalBuffer.Update(aPos, aLen);
 return iTargetDrive.Update(aPos, aLen);
 }
 TInt CBlockDeviceTester::UpdateBlock(TLba aLba, TLba aBlocks)
 {
-__MSFNLOG
 return Update(TLbaUtils::Pos(aLba), TLbaUtils::Length(aBlocks));
 }
 TInt CBlockDeviceTester::Verify(TPos aPos, TUint aLen)
 {
-__MSFNLOG
 return iTargetDrive.Verify(aPos, aLen);
 }
 TInt CBlockDeviceTester::VerifyBlock(TLba aLba, TLba aBlocks)
 {
-__MSFNLOG
 return iTargetDrive.VerifyBlock(aLba, aBlocks);
 }
 /**
 * CBotTester
 */
 CBotTester* CBotTester::NewL(TInt aDriveNumber)
 {
-__MSFNSLOG
+CBotTester* r = new (ELeave) CBotTester(aDriveNumber);
-	CBotTester* r = new (ELeave) CBotTester(aDriveNumber);
+CleanupStack::PushL(r);
-	CleanupStack::PushL(r);
+r->ConstructL();
-	r->ConstructL();
+CleanupStack::Pop();
-	CleanupStack::Pop();
+return r;
-	return r;
 }
 void CBotTester::ConstructL()
 {
-__MSFNLOG
 CBlockDeviceTester::ConstructL();
 iCmdBuffer.Append(KTxtTestCaseOutPreamble);
 iCmdBuffer.Append(KTxtTestCase);
 CBotTester::CBotTester(TInt aDriveNumber)
 :   CBlockDeviceTester(aDriveNumber)
 {
-__MSFNLOG
 }
 CBotTester::~CBotTester()
 {
-__MSFNLOG
 iTargetDrive.Close();
 }
 TInt CBotTester::SetTest(TTestCase aTestCase)
 {
-__MSFNLOG
 iCmdBuffer[KTestCaseDataOffset] = static_cast<TUint8>(aTestCase);
 TPos pos = KSetTestPos;
 return iTargetDrive.MediaRawWrite(pos, iCmdBuffer);
 }
 TInt CBotTester::WriteEnableFile()
 {
-__MSFNLOG
 TPos pos = KWriteEnableFilePos;
 return iTargetDrive.MediaRawWrite(pos, iOutEnableBuffer);
 }
 TInt CBotTester::InitReadEnableFile()
 {
-__MSFNLOG
 TPos pos = KReadEnableFilePos;
 return iTargetDrive.MediaRawWrite(pos, iInEnableBuffer);
 }
 TInt CBotTester::ReadEnableFile()
 {
-__MSFNLOG
 TBuf8<KInEnableBufferSize> readBuf(KInEnableBufferSize);
 TPos pos = KReadEnableFilePos;
 return iTargetDrive.MediaRawRead(pos, readBuf.Size(), readBuf);
 }
 /**
 * CSbcErrTester
 */
 CSbcErrTester* CSbcErrTester::NewL(TInt aDriveNumber)
 {
-__MSFNSLOG
+CSbcErrTester* r = new (ELeave) CSbcErrTester(aDriveNumber);
-	CSbcErrTester* r = new (ELeave) CSbcErrTester(aDriveNumber);
+CleanupStack::PushL(r);
-	CleanupStack::PushL(r);
+r->ConstructL();
-	r->ConstructL();
+CleanupStack::Pop();
-	CleanupStack::Pop();
+return r;
-	return r;
 }
 void CSbcErrTester::ConstructL()
 {
-__MSFNLOG
 CBlockDeviceTester::ConstructL();
 iCmdBuffer.Append(KTxtTestCaseOutPreamble);
 iCmdBuffer.Append(KTxtTestCase);
 iCmdBuffer.AppendFill('t', iCmdBuffer.MaxLength() - iCmdBuffer.Length());
 CSbcErrTester::CSbcErrTester(TInt aDriveNumber)
 :   CBlockDeviceTester(aDriveNumber)
 {
-__MSFNLOG
 }
 CSbcErrTester::~CSbcErrTester()
 {
-__MSFNLOG
 iTargetDrive.Close();
 }
 TInt CSbcErrTester::WriteTestFile()
 {
-__MSFNLOG
 TPos pos = KWriteTestFilePos;
 return iTargetDrive.MediaRawWrite(pos, iEnableBuffer);
 }
 TInt CSbcErrTester::ReadTestFile()
 {
-__MSFNLOG
 TBuf8<KEnableBufferSize> readBuf(KEnableBufferSize);
 TPos pos = KReadTestFilePos;
 TInt err = iTargetDrive.MediaRawRead(pos, readBuf.Size(), readBuf);
 return err;
 }
 TInt CSbcErrTester::WriteSenseErrorFile(TTestSenseError aTestSenseError)
 {
-__MSFNLOG
 iSenseErrorBuffer[KTestCaseDataOffset] = static_cast<TUint8>(aTestSenseError);
 TPos pos = KSenseErrorFile;
 return iTargetDrive.MediaRawWrite(pos, iSenseErrorBuffer);
 }
 CWrPrTester* CWrPrTester::NewL(TInt aDriveNumber)
 {
-__MSFNSLOG
+CWrPrTester* r = new (ELeave) CWrPrTester(aDriveNumber);
-	CWrPrTester* r = new (ELeave) CWrPrTester(aDriveNumber);
+CleanupStack::PushL(r);
-	CleanupStack::PushL(r);
+r->ConstructL();
-	r->ConstructL();
+CleanupStack::Pop();
-	CleanupStack::Pop();
+return r;
-	return r;
 }
 void CWrPrTester::ConstructL()
 {
-__MSFNLOG
 iCmdBuffer.Append(KTxtTestCaseOutPreamble);
 iCmdBuffer.Append(KTxtTestConfig);
 iCmdBuffer.AppendFill('c', iCmdBuffer.MaxLength() - iCmdBuffer.Length());
 iInCmdBuffer.Append(KTxtTestCaseInPreamble);
 CWrPrTester::CWrPrTester(TInt aDriveNumber)
 :   iTargetMedia(aDriveNumber),
 iTargetTestArea(iTargetMedia)
 {
-__MSFNLOG
 }
 CWrPrTester::~CWrPrTester()
 {
-__MSFNLOG
 iTargetTestArea.RemoveControlFile();
 }
 void CWrPrTester::SetWriteProtectL()
 {
-__MSFNLOG
 // first write WrPr CLR Control block to media to enable setting to be
 // cleared
 iInCmdBuffer[KTestCaseDataOffset] = ETestConfigMediaWpClr;
 TInt err = iTargetTestArea.WriteBlockL(iInCmdBuffer);
 User::LeaveIfError(err);
 }
 void CWrPrTester::ClrWriteProtectL()
 {
-__MSFNLOG
 test.Printf(_L("Clearing WRITE PROTECT"));
 TInt err = KErrNone;
 // Write protect so read the control file from the drive
 TBuf8<KCmdBufferSize> buffer;
 buffer.SetLength(KCmdBufferSize);
 }
 TInt CWrPrTester::SetRemovableL()
 {
-__MSFNLOG
 iCmdBuffer[KTestCaseDataOffset] = ETestConfigMediaRmbSet;
 iTargetMedia.OpenL();
 TInt err = iTargetMedia.MediaRawWrite(KCmdPos, iCmdBuffer);
 iTargetMedia.Close();
 return err;
 }
 TInt CWrPrTester::ClrRemovableL()
 {
-__MSFNLOG
 iCmdBuffer[KTestCaseDataOffset] = ETestConfigMediaRmbClr;
 iTargetMedia.OpenL();
 TInt err = iTargetMedia.MediaRawWrite(KCmdPos, iCmdBuffer);
 iTargetMedia.Close();
 return err;
 }
 TInt CWrPrTester::WriteReadTestL()
 {
-__MSFNLOG
 TInt err = KErrNone;
 TBuf8<KCmdBufferSize> wrBuffer;
 wrBuffer.SetMax();
 for (TInt i = 0; i < KCmdBufferSize; i++)

changeset 297	b2826f67641f
parent 0	a41df078684a