--- /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 <test/testexecutelog.h>
+#include "esocktestutils.h"
+#include <es_sock.h>
+
+#include <e32base.h>
+#include <cinidata.h>
+#include <e32cmn.h>
+#include <f32file.h>
+
+#include <elements/sd_roles.h>
+
+class TTruncateOverflow16 : public TDes16Overflow
+ {
+public:
+ virtual void Overflow(TDes16&)
+ {
+ }
+ };
+
+class TTruncateOverflow8 : public TDes8Overflow
+ {
+public:
+ virtual void Overflow(TDes8&)
+ {
+ }
+ };
+
+void CTestStepESockUtil::Log(TRefByValue<const TDesC16> 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<const TDesC8> 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;
+ }
+