diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/test/util/src/te_esockutilsteps.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/datacommsserver/esockserver/test/util/src/te_esockutilsteps.cpp Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,434 @@ +// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include "te_esockutilsteps.h" +#include +#include "esocktestutils.h" +#include + +#include +#include +#include +#include + +#include + +class TTruncateOverflow16 : public TDes16Overflow + { +public: + virtual void Overflow(TDes16&) + { + } + }; + +class TTruncateOverflow8 : public TDes8Overflow + { +public: + virtual void Overflow(TDes8&) + { + } + }; + +void CTestStepESockUtil::Log(TRefByValue aFormat, ...) + { + VA_LIST vaList; + VA_START( vaList, aFormat ); + + TTruncateOverflow16 truncateOverflow; + TBuf<512> buf; + buf.AppendFormatList( aFormat, vaList, &truncateOverflow ); + Logger().Write(buf); + } + +void CTestStepESockUtil::Log(TRefByValue aFormat, ...) + { + VA_LIST vaList; + VA_START( vaList, aFormat ); + + TTruncateOverflow8 truncateOverflow; + TBuf8<512> buf; + buf.AppendFormatList( aFormat, vaList, &truncateOverflow ); + Logger().Write(buf); + } + + + +CTestStepLoadESock::CTestStepLoadESock() + { + SetTestStepName(KTestStepLoadESock); + } + +/* virtual */ TVerdict CTestStepLoadESock::doTestStepL() + { + SetTestStepResult(EFail); + + TInt err(ESockLoader::LoadESock(this)); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("LoadESock returned error %d"), err); + } + else + { + SetTestStepResult(EPass); + } + return TestStepResult(); + } + + CTestStepUnloadESock::CTestStepUnloadESock(CommsFW::TCFShutdownType aType, TLeak aLeak, + TBool aExpectTimeout): + iType(aType), + iLeak(aLeak), + iExpectTimeout(aExpectTimeout) + { + SetTestStepName(KTestStepUnloadESock); + } + +/* virtual */ TVerdict CTestStepUnloadESock::doTestStepL() + { + SetTestStepResult(EFail); + + TInt err(ESockLoader::UnloadESock(iType, this)); +#ifdef ALWAYS_PASS_UNLOAD + SetTestStepResult(EPass); +#else + switch (err) + { + case KErrNone: + { + if (iLeak == ELeaks) + { + INFO_PRINTF1(_L("We were expecting a leak and non occurred : check that the leak-detecion machnism is working.")); + } + else if (iExpectTimeout) + { + INFO_PRINTF1(_L("We were expecting a timeout and non occurred")); + } + else + { + SetTestStepResult(EPass); + } + break; + } + case KErrSessionClosed: + { + INFO_PRINTF2(_L("UnloadESock returned %d. ESock had still had unclosed sessions when exiting."), err); + break; + } + case ESockLoader::KModuleLeaked: + { + INFO_PRINTF1(_L("A memory leak was detected on shutdown.")); + INFO_PRINTF1(_L("Expect leaks if a panic occurred - Check the epocwind.out.")); + if (iLeak == EMayLeak || iLeak == ELeaks) + { + SetTestStepResult(EPass); + } + break; + } + case KErrTimedOut: + if (iExpectTimeout) + { + SetTestStepResult(EPass); + } + break; + default: + { + INFO_PRINTF2(_L("UnloadESock returned error %d"), err); + } + } +#endif + + return TestStepResult(); + } + +CTestStepStopAllInterfaces::CTestStepStopAllInterfaces() + { + SetTestStepName(KTestStepStopAllInterfaces); + } + +/* virtual */ TVerdict CTestStepStopAllInterfaces::doTestStepL() + { + INFO_PRINTF2(_L("CTestStepStopAllInterfaces::doTestStepL %d"), 0); + SetTestStepResult(EFail); + + TBuf<1000> errDesc; + TInt err(ESockTestUtils::StopAllInterfaces(errDesc)); + if(err!=KErrNone) + { + INFO_PRINTF3(_L("StopAllInterfaces returned error %d:\n%S"), err, &errDesc); + } + else + { + SetTestStepResult(EPass); + } + return TestStepResult(); + } + + +CTestStepDefaultToConfig1::CTestStepDefaultToConfig1() + { + SetTestStepName(KTestStepDefaultToConfig1); + } + +/* virtual */ TVerdict CTestStepDefaultToConfig1::doTestStepL() + { + SetTestStepResult(EFail); + ESockTestUtils::DefaultToConfig1L(); + SetTestStepResult(EPass); + return TestStepResult(); + } + + + + +//IsNetworkNotActive - at first seemingly strange func name- +//the reason is that the "pass" return is wanted if the network +//is not active - this is in keeping with the previous genconn func +//that this replaces called "networknotactive". +//The call in this step to IsNetworkActiveL is a useful func now part of Utils. +CTestStepIsNetworkNotActive::CTestStepIsNetworkNotActive() + { + SetTestStepName(KTestStepIsNetworkNotActive); + } + + +/* virtual */ TVerdict CTestStepIsNetworkNotActive::doTestStepL() + { + SetTestStepResult(EFail); + TBool active = true; + + TRAPD(err, active = ESockTestUtils::IsNetworkActiveL()); + + if(err) + { + INFO_PRINTF2(_L("IsNetworkActive() returned error %d"), err); + } + else + { + //IsNetworkActive() didn't give back error code let's check the + //network status + if (active) + INFO_PRINTF1(_L("Network is active")); + else + SetTestStepResult(EPass); + } + + return TestStepResult(); + } + + +CTestStepDelay::CTestStepDelay() + { + SetTestStepName(KTestStepDelay); + } + +/* virtual */ TVerdict CTestStepDelay::doTestStepL() + { + SetTestStepResult(EFail); + + //get val from config ini file + TInt GuardTimerValue; + TInt returnValue = GetIntFromConfig(_L("Common"),_L("Delay"),GuardTimerValue); + + + TInt err(ESockTestUtils::Delay(GuardTimerValue)); + if(err!=KErrNone) + { + INFO_PRINTF2(_L("Delay() returned error %d"), err); + } + else + { + SetTestStepResult(EPass); + } + return TestStepResult(); + } + +CTestStepAlwaysFail::CTestStepAlwaysFail() + { + SetTestStepName(KTestStepAlwaysFail); + } + +TVerdict CTestStepAlwaysFail::doTestStepL() + { + SetTestStepResult(EFail); + return TestStepResult(); + } + +CTestStepResetAllocFails::CTestStepResetAllocFails() + { + SetTestStepName(KTestStepResetAllocFails); + } + +/* virtual */ TVerdict CTestStepResetAllocFails::doTestStepL() + { + SetTestStepResult(EFail); + RSocketServ ss; + + TInt err = KErrGeneral; + // This loop may repeat until the test step's timeout is exhausted. + do { + err = ss.Connect(); + } while (KErrNone != err); + + err = ss.__DbgFailNext(Den::KResetAllocFails); + if (KErrNone == err) + { + SetTestStepResult(EPass); + } + ss.Close(); + + return TestStepResult(); + } + +CTestStepLoadConfig::CTestStepLoadConfig() + { + SetTestStepName(KTestStepLoadConfig); + } + +/* virtual */ TVerdict CTestStepLoadConfig::doTestStepL() + { + TVerdict verdict = EPass; + // Fetch details of requested changes + TPtrC fileSpec; + TESTL(GetStringFromConfig(ConfigSection(), _L("fileSpec"), fileSpec)); + + TPtrC sectName; + TESTL(GetStringFromConfig(ConfigSection(), _L("sectName"), sectName)); + + TPtrC keyName; + TESTL(GetStringFromConfig(ConfigSection(), _L("keyName"), keyName)); + + TPtrC value; + TESTL(GetStringFromConfig(ConfigSection(), _L("value"), value)); + + // Process files matching supplied file spec + RFs fs; + CleanupClosePushL(fs); + TInt err = fs.Connect(); + TESTEL(KErrNone == err, err); + + CDir* dirList; + err = fs.GetDir(fileSpec, KEntryAttNormal, ESortByName, dirList); + CleanupStack::PushL(dirList); + TESTEL(KErrNone == err, err); + + TParse fullSpec; + fullSpec.Set(fileSpec, NULL, NULL); + TBuf<256> curFileSpec; + + for (TInt i = 0; i < dirList->Count(); i++) + { + curFileSpec = fullSpec.DriveAndPath(); + curFileSpec.Append((*dirList)[i].iName); + Logger().WriteFormat(_L("Processing %S..."), &curFileSpec); + + err = UpdateIniL(curFileSpec, sectName, keyName, value); + TESTEL(KErrNone == err, err); + } + + CleanupStack::PopAndDestroy(2, &fs); + return verdict; + } + +TInt CTestStepLoadConfig::UpdateIniL(const TDesC &aFileSpec, const TDesC &aSectName, const TDesC &aKeyName, const TDesC &aValue) + { + // Ensure file is writeable. + RFs fs; + CleanupClosePushL(fs); + User::LeaveIfError(fs.Connect()); + User::LeaveIfError(fs.SetAtt(aFileSpec, 0, KEntryAttReadOnly)); + + TInt err; + + // Attempt to update the value for the specified key. + CIniData* myIni = CIniData::NewL(aFileSpec); + CleanupStack::PushL(myIni); + + TPtrC result; + if (myIni->FindVar(aSectName, aKeyName, result)) + { + err = myIni->SetValue(aSectName, aKeyName, aValue); + } + else + { + err = myIni->AddValue(aSectName, aKeyName, aValue); + } + User::LeaveIfError(err); + myIni->WriteToFileL(); + CleanupStack::PopAndDestroy(1, myIni); + + // Replace all " =" with "=". + + RFile myFile; + CleanupClosePushL(myFile); + User::LeaveIfError(myFile.Open(fs, aFileSpec, EFileStreamText | EFileWrite)); + + TInt fileSize; + User::LeaveIfError(myFile.Size(fileSize)); + + RBuf8 myBuf; + CleanupClosePushL(myBuf); + User::LeaveIfError(myBuf.Create(fileSize)); + User::LeaveIfError(myFile.Read(myBuf)); + + _LIT8(KSpaceEquals, " ="); + TInt pos = 0; + while (pos >= 0) + { + pos = myBuf.Find(KSpaceEquals); + if (pos >= 0) + { + myBuf.Delete(pos, 1); + } + } + + pos = 0; + User::LeaveIfError(myFile.Write(pos, myBuf)); + User::LeaveIfError(myFile.SetSize(myBuf.Length())); + User::LeaveIfError(myFile.Size(fileSize)); + + CleanupStack::PopAndDestroy(3, &fs); + return err; + } + +CTestStepCopyFiles::CTestStepCopyFiles() + { + SetTestStepName(KTestStepCopyFiles); + } + +TVerdict CTestStepCopyFiles::doTestStepL() + { + TVerdict verdict = EPass; + // Fetch details of files to be copied + TPtrC sourceSpec; + TESTL(GetStringFromConfig(ConfigSection(), _L("sourceSpec"), sourceSpec)); + + TPtrC destPath; + TESTL(GetStringFromConfig(ConfigSection(), _L("destPath"), destPath)); + + RFs fs; + CleanupClosePushL(fs); + TInt err = fs.Connect(); + TESTEL(KErrNone == err, err); + + CFileMan *fm = CFileMan::NewL(fs); + CleanupStack::PushL(fm); + + err = fm->Copy(sourceSpec, destPath); + TESTEL(KErrNone == err, err); + + CleanupStack::PopAndDestroy(2, &fs); + return verdict; + } +