diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/test/TE_EIntsock/TE_EIntSockTestStep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/datacommsserver/esockserver/test/TE_EIntsock/TE_EIntSockTestStep.cpp Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,295 @@ +// 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 +#include +#include +//#include +//#include +#include + +#include "TE_EIntSockTestStep.h" +#include "es_ptestinternalsocket.h" +//#include + +// constructor +CEIntSockTestStep::CEIntSockTestStep() + { + } + +// destructor +CEIntSockTestStep::~CEIntSockTestStep() + { + iESockProxyThread.Close(); + } + +enum TVerdict CEIntSockTestStep::doTestStepPreambleL( void ) + { + return EPass; + } + +enum TVerdict CEIntSockTestStep::doTestStepL() + { + + TRAPD(trapRet,enum TVerdict stepRet = InternalDoTestStepL();\ + if (stepRet !=EPass)\ + {\ + SetTestStepResult(stepRet);\ + }\ + ) + + if (trapRet != KErrNone) + { + SetTestStepResult(EFail); + return EFail; + } + return EPass; + }; + +//This method ensures that any +enum TVerdict CEIntSockTestStep::doTestStepPostambleL( void ) + { + return EPass; + } + +enum TVerdict CEIntSockTestStep::InternalDoTestStepL() + { + RSocketServ ss1; + TInt ret; + ret = ss1.Connect(); + if (ret != KErrNone) + { + Logger().WriteFormat(_L("Connect to socket server failed with %S"),&EpocErrorToText(ret)); + } + CleanupClosePushL(ss1); + TESTL(ret == KErrNone); + RSocket sock1; + ret = sock1.Open(ss1,KProxyAddrFamily,KSockDatagram, KProxy); + //ret = sock1.Open(ss1,KProxyName); + if (ret != KErrNone) + { + Logger().WriteFormat(_L("Opening socket to the Test Internal Socket Protocol failed with %S"),&EpocErrorToText(ret)); + } + TESTL(ret == KErrNone); + Logger().Close(); + TRequestStatus stat; + + TProxyProtocolRequest request; + request.name.Copy(TestStepName()); + + TPckg requestPckg(request); + + _LIT(PanicStep,"Test21"); + if (TestStepName() == PanicStep) + { + doPanicStepTestPreambleL(); + } + + sock1.Ioctl(KProxyProtocolTestRequest,stat,&requestPckg); + User::WaitForRequest(stat); + CleanupStack::Pop(&ss1); + ss1.Close(); + + if (TestStepName() == PanicStep) + { + doPanicStepTestPostambleL(stat); + } + else + { + TESTL(stat == KErrNone); + SetTestStepResult(request.result); + } + return TestStepResult(); + } + +void CEIntSockTestStep::doPanicStepTestPreambleL() + { + // Search for *ESock_Proxy* thread + TFindThread findThread(_L("*ESock_Proxy*")); + TFullName threadName; + TESTL(findThread.Next(threadName) == KErrNone); + + TESTL(iESockProxyThread.Open(findThread) == KErrNone); + + iESockProxyThread.Logon(iESockProxyThreadStatus); + } + +void CEIntSockTestStep::doPanicStepTestPostambleL( TRequestStatus& aStat ) + { + //ESock is expected to have a panic. The Kernel will therefore return KErrAbort + TESTL(aStat == KErrAbort); + + User::WaitForRequest(iESockProxyThreadStatus); + + //Test that ESock_Proxy Paniced + TESTL(iESockProxyThread.ExitType() == EExitPanic); + + // Test that the Panic Category was "InternalSocket" + _LIT(KInternalSocketPanic, "InternalSocket"); + TESTL(iESockProxyThread.ExitCategory() == KInternalSocketPanic); + + // Test that the Panic Reason was EInternalSocketNotNullSocket (12) + TESTL(iESockProxyThread.ExitReason() == ENotNullSocket); + + SetTestStepResult(EPass); + } + +// extra logging methods +const TPtrC& CEIntSockTestStep::EpocErrorToText(const TInt aErrCode) +/** +Convert a Error code to text. + + @param aError error code to display as text. + @return Text describing the error. + */ + { + // TPtr errText; + switch (aErrCode) + { + case KErrNone: + iErrText.Set(_L("KErrNone")); + break; + case KErrNotFound: + iErrText.Set(_L("KErrNotFound")); + break; + case KErrGeneral: + iErrText.Set(_L("KErrGeneral")); + break; + case KErrCancel: + iErrText.Set(_L("KErrCancel")); + break; + case KErrNoMemory: + iErrText.Set(_L("KErrNoMemory")); + break; + case KErrNotSupported: + iErrText.Set(_L("KErrNotSupported")); + break; + case KErrArgument: + iErrText.Set(_L("KErrArgument")); + break; + case KErrTotalLossOfPrecision: + iErrText.Set(_L("KErrTotalLossOfPrecision")); + break; + case KErrBadHandle: + iErrText.Set(_L("KErrBadHandle")); + break; + case KErrOverflow: + iErrText.Set(_L("KErrOverflow")); + break; + case KErrUnderflow: + iErrText.Set(_L("KErrUnderflow")); + break; + case KErrAlreadyExists: + iErrText.Set(_L("KErrAlreadyExists")); + break; + case KErrPathNotFound: + iErrText.Set(_L("KErrPathNotFound")); + break; + case KErrDied: + iErrText.Set(_L("KErrDied")); + break; + case KErrInUse: + iErrText.Set(_L("KErrInUse")); + break; + case KErrServerTerminated: + iErrText.Set(_L("KErrServerTerminated")); + break; + case KErrServerBusy: + iErrText.Set(_L("KErrServerBusy")); + break; + case KErrCompletion: + iErrText.Set(_L("KErrCompletion")); + break; + case KErrNotReady: + iErrText.Set(_L("KErrNotReady")); + break; + case KErrUnknown: + iErrText.Set(_L("KErrUnknown")); + break; + case KErrCorrupt: + iErrText.Set(_L("KErrCorrupt")); + break; + case KErrAccessDenied: + iErrText.Set(_L("KErrAccessDenied")); + break; + case KErrLocked: + iErrText.Set(_L("KErrLocked")); + break; + case KErrWrite: + iErrText.Set(_L("KErrWrite")); + break; + case KErrDisMounted: + iErrText.Set(_L("KErrDisMounted")); + break; + case KErrEof: + iErrText.Set(_L("KErrEof")); + break; + case KErrDiskFull: + iErrText.Set(_L("KErrDiskFull")); + break; + case KErrBadDriver: + iErrText.Set(_L("KErrBadDriver")); + break; + case KErrBadName: + iErrText.Set(_L("KErrBadName")); + break; + case KErrCommsLineFail: + iErrText.Set(_L("KErrCommsLineFail")); + break; + case KErrCommsFrame: + iErrText.Set(_L("KErrCommsFrame")); + break; + case KErrCommsOverrun: + iErrText.Set(_L("KErrCommsOverrun")); + break; + case KErrCommsParity: + iErrText.Set(_L("KErrCommsParity")); + break; + case KErrTimedOut: + iErrText.Set(_L("KErrTimedOut")); + break; + case KErrCouldNotConnect: + iErrText.Set(_L("KErrCouldNotConnect")); + break; + case KErrCouldNotDisconnect: + iErrText.Set(_L("KErrCouldNotDisconnect")); + break; + case KErrDisconnected: + iErrText.Set(_L("KErrDisconnected")); + break; + case KErrBadLibraryEntryPoint: + iErrText.Set(_L("KErrBadLibraryEntryPoint")); + break; + case KErrBadDescriptor: + iErrText.Set(_L("KErrBadDescriptor")); + break; + case KErrAbort: + iErrText.Set(_L("KErrAbort")); + break; + case KErrTooBig: + iErrText.Set(_L("KErrTooBig")); + break; + case KRequestPending: + iErrText.Set(_L("KRequestPending")); + break; + default: + iErrBuff.Format(_L(" %d"),aErrCode); + iErrText.Set(iErrBuff.Ptr()); + break; + } + return iErrText; + } + +