// Copyright (c) 2002-2010 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:
// CBoundCLPushStep_xyz derived implementations
//
//
/**
@file
@internalComponent
*/
#include "WapBoundCLPushSteps.h"
#include "WapStackSuiteDefs.h"
#include <simtsy.h>
#include <wapmsgerr.h>
#include <ecom/ecom.h>
CBoundCLPushStepBase::CBoundCLPushStepBase()
/**
* Constructor
*/
{
}
CBoundCLPushStepBase::~CBoundCLPushStepBase()
/**
* Destructor
*/
{
if(iImp)
{
UnloadInterface();
}
}
// Load CWapBoundCLPushService Interface
CWapBoundCLPushService* CBoundCLPushStepBase::LoadInterface()
{
TInt trapValue;
CWapBoundCLPushService* implementation = NULL;
// UID {0x101FBB39} - SWS implementation
TUid KInterfaceUid = {0x101FBB39};
INFO_PRINTF2(_L("Calling new NewL(0x%08X) method"), KInterfaceUid);
TRAP(trapValue, implementation = CWapBoundCLPushService::NewL(KInterfaceUid));
if(!trapValue)
{
INFO_PRINTF2(_L("Interface is loaded: implementation.addr = 0x%08x"), implementation);
return implementation;
}
else return NULL;
}
void CBoundCLPushStepBase::UnloadInterface()
{
INFO_PRINTF2(_L("Interface at implementation.addr = 0x%08x is deleted"), iImp);
delete iImp;
iImp = NULL;
REComSession::FinalClose();
}
CBoundCLPushStep_1::~CBoundCLPushStep_1()
/**
* Destructor
*/
{
}
CBoundCLPushStep_1::CBoundCLPushStep_1()
/**
* Constructor
*/
{
}
TVerdict CBoundCLPushStep_1::doTestStepL()
/**
* @return - TVerdict code
* Override of base class pure virtual
* Our implementation only gets called if the base class doTestStepPreambleL() did
* not leave. That being the case, the current test result value will be EPass.
*/
{
//
// CWapBoundCLPushService
//
INFO_PRINTF1(_L("CreateImplementation - CWapBoundCLPushService"));
INFO_PRINTF1(_L("Calling old NewL() method"));
TInt trapValue;
SetTestStepResult(EFail);
TRAP(trapValue, iImp = CWapBoundCLPushService::NewL());
if(!trapValue)
{
INFO_PRINTF2(_L("Interface is loaded: implementation.addr = 0x%08x"), iImp);
UnloadInterface();
iImp = LoadInterface();
if(iImp)
{
INFO_PRINTF1(_L("CreateImplementation - OK"));
SetTestStepResult(EPass);
UnloadInterface();
}
}
return TestStepResult();
}
CBoundCLPushStep_2::CBoundCLPushStep_2()
/**
* Constructor
*/
{
}
CBoundCLPushStep_2::~CBoundCLPushStep_2()
/**
* Destructor
*/
{
}
TVerdict CBoundCLPushStep_2::doTestStepL()
/**
* Test Connect methoths
* @return - TVerdict code
*
*/
{
INFO_PRINTF1(_L("BOUNDCL-PUSH: Testing Connect"));
if(TestStepResult() == EPass )
{
SetTestStepResult(EFail);
iImp = LoadInterface();
if(iImp)
{
TInt bearer, port;
TInt error = KErrNone;
TBool secure= EFalse;
TBool reconnect= EFalse;
SetLastError(KErrNone);
TBool delay = EFalse;
if(GetIntFromConfig(ConfigSection(), KWapBearer, bearer)) iBearer = (Wap::TBearer)bearer;
if(GetIntFromConfig(ConfigSection(), KWapLocalPort, port)) iLocalPort = (Wap::TPort)port;
if(GetIntFromConfig(ConfigSection(), KWapExError, error)) SetExpectedError(error);
if(GetBoolFromConfig(ConfigSection(), KWapSecure, secure)) iSecure = secure;
if(GetBoolFromConfig(ConfigSection(),_L("Reconnect"), reconnect)) iReconnect = reconnect;
if(GetBoolFromConfig(ConfigSection(),KWapDelayPortClosure, delay)) iDelayPortClosure = delay;
if(UseSimTsy())
{
GetIntFromConfig(ConfigSection(), KWapSIMTSYState, iSimTsyState);
User::LeaveIfError(RProperty::Set(KUidPSSimTsyCategory, KPSSimTsyTestNumber, iSimTsyState));
}
User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidPhonePwr.iUid, ESAPhoneOn));
SetState(EConnect);
iControl->ReStart();
ShowConnectionInfo();
StartScheduler();
UnloadInterface();
}
}
return TestStepResult();
}
TInt CBoundCLPushStep_2::CallStateMachine()
{
TInt err = KErrNone;
INFO_PRINTF2(_L("CallStateMachine: state [%d]"), State());
switch(iState)
{
case EConnect:
INFO_PRINTF1(_L("EConnect"));
err = iImp->Connect(iBearer, (Wap::TPort)iLocalPort, iSecure);
INFO_PRINTF2(_L("Connection completed with code = %d"), err);
if( err == KErrNone)
{
if(iReconnect)
{
INFO_PRINTF1(_L("Second connect"));
iControl->ReStart();
break;
}
}
SetState(EFinish);
SetLastError(err);
iControl->ReStart();
break;
case EFinish:
// it's necessary to delay port closure, let the other concurrent test step
// can fail opening the same port with expected error EPortAlreadyBound (-5498)
if (iDelayPortClosure)
User::After(5000000);
INFO_PRINTF1(_L("EFinish"));
if(GetLastError() == GetExpectedError())
SetTestStepResult(EPass);
else
SetTestStepResult(EFail);
SetState(EIdle);
StopScheduler();
break;
case EIdle:
default:
INFO_PRINTF2(_L("Error: EIdle or unknown state %d"), State());
SetTestStepResult(EFail);
StopScheduler();
break;
}
return (0);
}
CBoundCLPushStep_3::CBoundCLPushStep_3()
/**
* Constructor
*/
{
}
CBoundCLPushStep_3::~CBoundCLPushStep_3()
/**
* Destructor
*/
{
}
TVerdict CBoundCLPushStep_3::doTestStepL()
/*
* Test the BoundCLPush APIs in unconnected state.
*/
{
INFO_PRINTF1(_L("BoundCLPush. Requests without connection"));
// check preamble result
TVerdict verdict = TestStepResult();
if (verdict==EPass)
{
TInt err, ret;
iImp = LoadInterface();
if (!iImp)
{
ERR_PRINTF1(_L("Unable to load BoundCLPush Interface"));
verdict = EFail;
}
else
{
GetIntFromConfig(ConfigSection(),KWapExError,(TInt&)iExError);
ShowConnectionInfo();
TRequestStatus reqStatus;
iImp->AwaitPush(iRecvHeadersBuf, iRecvBodyBuf, iTransactionIdPckg, reqStatus);
TRAP(ret, TEST_CHECKL(reqStatus.Int(), iExError, _L("AwaitPush Fails not as expected")))
if (ret)
verdict = EFail;
else
{
Wap::TPort port;
err=iImp->GetLocalPort(port);
TRAP(ret, TEST_CHECKL(err, iExError, _L("GetLocalPort Fails not as expected")))
if (ret)
verdict = EFail;
else
{
HBufC8* localHost;
err=iImp->GetLocalAddress(localHost);
TRAP(ret, TEST_CHECKL(err, iExError, _L("GetLocalAddress Fails not as expected")))
if (ret)
verdict = EFail;
else
{
err=iImp->GetBearer(iBearer);
TRAP(ret, TEST_CHECKL(err, iExError, _L("GetBearer Fails not as expected")))
if (ret)
verdict = EFail;
else
{
HBufC8* host;
err=iImp->GetServerAddress(host);
TRAP(ret, TEST_CHECKL(err, iExError, _L("GetServerAddress Fails not as expected")))
if (ret)
verdict = EFail;
}
}
}
}
UnloadInterface();
}
}
if (verdict==EPass)
{
INFO_PRINTF1(_L("BoundCLPush. Requests Fail as expected"));
}
SetTestStepResult(verdict);
return TestStepResult();
}
TInt CBoundCLPushStep_3::CallStateMachine()
{
return (0);
}
CBoundCLPushStep_4::CBoundCLPushStep_4()
/**
* Constructor
*/
{
}
CBoundCLPushStep_4::~CBoundCLPushStep_4()
/**
* Destructor
*/
{
}
TVerdict CBoundCLPushStep_4::doTestStepL()
/**
* Test receiving PDU data over UDP
* The test is run concurently with CBoundCLPushStep_9 test. CBoundCLPushStep_4 waits for push message whilst
* CBoundCLPushStep_9 sends a push message over UDP using loopback.
* The test pair is used to test two cases (dependent on configuration read for CBoundCLPushStep_9):
* - sending PDU data that is smaller than the allocated buffer on the receiving side (<=1024)
* - sending PDU data that is larger than the allocated buffer on the receiving side and needs reallocation (>1024)
* @return - TVerdict code
*
*/
{
INFO_PRINTF1(_L("BOUND-CLPUSH: Connect-AwaitPush"));
INFO_PRINTF1(_L("Receiving PDU over UDP from a concurrent test... "));
if(TestStepResult() == EPass )
{
SetTestStepResult(EFail);
iImp = LoadInterface();
if(iImp)
{
SetLastError(KErrNone);
TInt bearer, port;
TInt error = KErrNone;
if(GetIntFromConfig(ConfigSection(),KWapBearer, bearer))
{
iBearer = static_cast<Wap::TBearer>(bearer);
}
if(GetIntFromConfig(ConfigSection(),KWapLocalPort, port))
{
iLocalPort = static_cast<Wap::TPort>(port);
}
if(GetIntFromConfig(ConfigSection(),KWapExError, error))
{
SetExpectedError(error);
}
GetBoolFromConfig(ConfigSection(), KMiddleCancel, iMiddleCancel);
GetBoolFromConfig(ConfigSection(), KMultiReadCancel, iMultiReadCancel);
TInt headerLength, bufLength;
if(GetIntFromConfig(ConfigSection(),KWapWSPRecvHeaderLength, headerLength))
{
iHeaderRecvBufLength=static_cast<TUint16>(headerLength);
}
if(GetIntFromConfig(ConfigSection(),KWapWSPRecvBodyLength, bufLength))
{
iBodyRecvBufLength=static_cast<TUint16>(bufLength);
}
iRecvHeaders = HBufC8::NewL(iHeaderRecvBufLength);
iRecvBody = HBufC8::NewL(iBodyRecvBufLength);
User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidPhonePwr.iUid, ESAPhoneOn));
if(UseSimTsy())
{
GetIntFromConfig(ConfigSection(),KWapSIMTSYState, iSimTsyState);
User::LeaveIfError(RProperty::Set(KUidPSSimTsyCategory, KPSSimTsyTestNumber, iSimTsyState));
}
SetState(EConnect);
iControl->ReStart();
ShowConnectionInfo();
StartScheduler();
delete iRecvBody;
iRecvBody=NULL;
delete iRecvHeaders;
iRecvHeaders=NULL;
UnloadInterface();
}
}
return TestStepResult();
}
TInt CBoundCLPushStep_4::CallStateMachine()
{
TVerdict verdict = EFail;
TInt err = KErrNone;
TInt activate = 0;
INFO_PRINTF2(_L("CallStateMachine: state [%d]"), State());
switch(iState)
{
case EConnect:
INFO_PRINTF1(_L("EConnect"));
err = iImp->Connect(iBearer, iLocalPort, EFalse);
INFO_PRINTF2(_L("Connection completed with code = %d"), err);
if( err == KErrNone)
{
if(iBearer != Wap::EIP)
{
TRAP(err, WaitForInitializeL());
}
iRecvHeadersBuf.Set(iRecvHeaders->Des());
iRecvBodyBuf.Set(iRecvBody->Des());
iImp->AwaitPush(iRecvHeadersBuf, iRecvBodyBuf, iTransactionIdPckg, *iStatus);
INFO_PRINTF1(_L("Start AwaitingPush....."));
activate = 1;
if (!iMiddleCancel)
{
SetState(EAwaitPush);
}
else
{
INFO_PRINTF1(_L("Cancel AwaitPush"));
iImp->CancelAwaitPush();
SetState(EFinish);
}
}
else
{
SetState(EFinish);
iControl->ReStart();
}
SetLastError(err);
break;
case EAwaitPush:
INFO_PRINTF1(_L("EAwaitPush"));
if(iStatus->Int() != KErrNone && iStatus->Int()!=Wap::EMoreData)
// AwaitPush failed
{
INFO_PRINTF1(_L("AwaitPush failed"));
SetLastError(iStatus->Int());
SetState(EFinish);
iControl->ReStart();
}
else
{
iMaxWspHeaderRecvBuffer.Append(iRecvHeadersBuf);
iMaxWspDataRecvBuffer.Append(iRecvBodyBuf);
if (iStatus->Int()==Wap::EMoreData)
{
iImp->AwaitPush(iRecvHeadersBuf, iRecvBodyBuf, iTransactionIdPckg, *iStatus);
activate = 1;
if (!iMultiReadCancel)
{
SetState(EAwaitPush);
}
else
{
INFO_PRINTF1(_L("Cancel Receive in EMutipleReceive state"));
iImp->CancelAwaitPush();
SetState(EFinish);
}
}
else
{
SetLastError(iStatus->Int());
iControl->ReStart();
SetState(EFinish);
}
}
break;
case EFinish:
INFO_PRINTF1(_L("EFinish"));
if(iStatus->Int() != KErrNone)
{
SetLastError(iStatus->Int());
}
verdict = (GetLastError() == GetExpectedError())?EPass:EFail;
if (verdict==EPass && !iMiddleCancel && !iMultiReadCancel)
{
iImp->CancelAwaitPush();
INFO_PRINTF1(_L("Headers:"));
DumpBuf(iMaxWspHeaderRecvBuffer);
INFO_PRINTF1(_L("Body"));
DumpBuf(iMaxWspDataRecvBuffer);
if (verdict==EPass)
{
HBufC8* buf;
iImp->GetServerAddress(buf);
verdict = (buf->Match(iRemoteHost)!=KErrNotFound)?EPass:EFail;
delete buf;
}
if (verdict==EPass)
{
Wap::TPort port;
iImp->GetLocalPort(port);
verdict = (port == iLocalPort)?EPass:EFail;
}
if (verdict==EPass)
{
Wap::TBearer bearer;
iImp->GetBearer(bearer);
verdict = (bearer == iBearer)?EPass:EFail;
}
if (verdict==EPass)
{
//This test can not perform.
HBufC8* buf;
iImp->GetLocalAddress(buf);
delete buf;
}
}
SetTestStepResult(verdict);
SetState(EIdle);
StopScheduler();
break;
case EIdle:
default:
INFO_PRINTF2(_L("Error: EIdle or unknown state %d"), State());
SetTestStepResult(verdict);
StopScheduler();
break;
}
return (activate);
}
CBoundCLPushStep_5::CBoundCLPushStep_5()
/**
* Constructor
*/
{
}
CBoundCLPushStep_5::~CBoundCLPushStep_5()
/**
* Destructor
*/
{
}
TVerdict CBoundCLPushStep_5::doTestStepL()
/**
* Test Cancel
* @return - TVerdict code
*
*/
{
INFO_PRINTF1(_L("BOUNDCL-PUSH: Testing Cancel"));
if(TestStepResult() == EPass )
{
SetTestStepResult(EFail);
iImp = LoadInterface();
if(iImp)
{
TInt bearer, port;
TInt error = KErrNone;
TBool secure= EFalse;
TBool reconnect= EFalse;
SetLastError(KErrNone);
if(GetIntFromConfig(ConfigSection(),KWapBearer, bearer)) iBearer = (Wap::TBearer)bearer;
if(GetIntFromConfig(ConfigSection(),KWapLocalPort, port)) iLocalPort = (Wap::TPort)port;
if(GetIntFromConfig(ConfigSection(), KWapExError, error)) SetExpectedError(error);
if(GetBoolFromConfig(ConfigSection(), KWapSecure, secure)) iSecure = secure;
if(GetBoolFromConfig(ConfigSection(),_L("Reconnect"), reconnect)) iReconnect = reconnect;
ShowConnectionInfo();
error = iImp->Connect(iBearer, iLocalPort, iSecure);
INFO_PRINTF2(_L("Connection completed with code = %d"), error);
if( error == KErrNone)
{
TBuf8<100> header, body;
TPckgBuf<TUint8> pushIdPckg;
TRequestStatus reqStatus;
iImp->AwaitPush(header, body, pushIdPckg, reqStatus);
SetState(EAwaitPush);
StartScheduler();
iControl->ReStart();
if(reqStatus==KErrCancel)
{
SetTestStepResult(EPass);
}
}
}
}
return TestStepResult();
}
TInt CBoundCLPushStep_5::CallStateMachine()
{
INFO_PRINTF2(_L("CallStateMachine: state [%d]"), State());
switch(iState)
{
case EAwaitPush:
INFO_PRINTF1(_L("EAwaitPush"));
iImp->CancelAwaitPush();
SetState(EFinish);
iControl->ReStart();
break;
case EFinish:
INFO_PRINTF1(_L("EFinish"));
SetState(EIdle);
StopScheduler();
break;
case EIdle:
default:
INFO_PRINTF2(_L("Error: EIdle or unknown state %d"), State());
SetTestStepResult(EFail);
StopScheduler();
break;
}
return (0);
}
CBoundCLPushStep_6::CBoundCLPushStep_6()
{
}
CBoundCLPushStep_6::~CBoundCLPushStep_6()
{
}
TVerdict CBoundCLPushStep_6::doTestStepL()
{
return TestStepResult();
}
TInt CBoundCLPushStep_6::CallStateMachine()
{
return (0);
}
CBoundCLPushStep_7::CBoundCLPushStep_7()
{
}
CBoundCLPushStep_7::~CBoundCLPushStep_7()
{
}
TVerdict CBoundCLPushStep_7::doTestStepL()
{
INFO_PRINTF1(_L("BOUND-CLPUSH: Connect-AwaitPush-AwaitPush"));
if(TestStepResult() == EPass )
{
SetTestStepResult(EFail);
iImp = LoadInterface();
if(iImp)
{
SetLastError(KErrNone);
TInt bearer, port;
TInt error = KErrNone;
if(GetIntFromConfig(ConfigSection(),KWapBearer, bearer))
{
iBearer = static_cast<Wap::TBearer>(bearer);
}
if(GetIntFromConfig(ConfigSection(),KWapLocalPort, port))
{
iLocalPort = static_cast<Wap::TPort>(port);
}
if(GetIntFromConfig(ConfigSection(),KWapExError, error))
{
SetExpectedError(error);
}
TInt headerLength, bufLength;
if(GetIntFromConfig(ConfigSection(),KWapWSPRecvHeaderLength, headerLength))
{
iHeaderRecvBufLength=static_cast<TUint16>(headerLength);
}
if(GetIntFromConfig(ConfigSection(),KWapWSPRecvBodyLength, bufLength))
{
iBodyRecvBufLength=static_cast<TUint16>(bufLength);
}
iRecvHeaders = HBufC8::NewL(iHeaderRecvBufLength);
iRecvBody = HBufC8::NewL(iBodyRecvBufLength);
SetState(EConnect);
iControl->ReStart();
ShowConnectionInfo();
StartScheduler();
delete iRecvBody;
iRecvBody=NULL;
delete iRecvHeaders;
iRecvHeaders=NULL;
UnloadInterface();
}
}
return TestStepResult();
}
TInt CBoundCLPushStep_7::CallStateMachine()
{
TVerdict verdict = EFail;
TInt err = KErrNone;
TInt activate = 0;
INFO_PRINTF2(_L("CallStateMachine: state [%d]"), State());
switch(iState)
{
case EConnect:
INFO_PRINTF1(_L("EConnect"));
err = iImp->Connect(iBearer, iLocalPort, EFalse);
INFO_PRINTF2(_L("Connection completed with code = %d"), err);
if( err == KErrNone)
{
iRecvHeadersBuf.Set(iRecvHeaders->Des());
iRecvBodyBuf.Set(iRecvBody->Des());
TRequestStatus reqStatus;
iImp->AwaitPush(iRecvHeadersBuf, iRecvBodyBuf, iTransactionIdPckg, reqStatus);
iImp->AwaitPush(iRecvHeadersBuf, iRecvBodyBuf, iTransactionIdPckg, *iStatus);
INFO_PRINTF1(_L("AwaitPush"));
activate = 1;
}
else
{
iControl->ReStart();
}
SetLastError(err);
SetState(EFinish);
break;
case EFinish:
INFO_PRINTF1(_L("EFinish"));
iImp->CancelAwaitPush();
if(iStatus->Int() != KErrNone)
{
SetLastError(iStatus->Int());
}
verdict = (GetLastError() == GetExpectedError())?EPass:EFail;
SetTestStepResult(verdict);
SetState(EIdle);
StopScheduler();
break;
case EIdle:
default:
INFO_PRINTF2(_L("Error: EIdle or unknown state [%d]"), State());
SetTestStepResult(verdict);
StopScheduler();
break;
}
return (activate);
}
CBoundCLPushStep_8::CBoundCLPushStep_8()
{
}
CBoundCLPushStep_8::~CBoundCLPushStep_8()
{
}
TVerdict CBoundCLPushStep_8::doTestStepL()
/**
* @return - TVerdict code
* Wrong parameter values for Bound CL Push API:
* - Wrong TUid on construction
* - Connect to wrong bearer (already implemented in test 2)
*/
{
INFO_PRINTF1(_L("CreateImplementation with wrong Uid- CWapBoundCLPushService"));
if(TestStepResult() == EPass )
{
TInt error;
if(GetIntFromConfig(ConfigSection(),KWapExError2, error))
{
iExError2=error;
}
TInt trapValue;
TUid invalidInterfaceUid = {0x00000000};
INFO_PRINTF2(_L("Calling new NewL(0x%08X) method"), invalidInterfaceUid);
TRAP(trapValue, iImp = CWapBoundCLPushService::NewL(invalidInterfaceUid));
TVerdict verdict = (trapValue == iExError2)?EPass:EFail;
if (verdict==EPass)
{
INFO_PRINTF2(_L("CreateImplementation with wrong Uid- Failed as expected with error %d"),trapValue);
}
SetTestStepResult(verdict);
}
return TestStepResult();
}
TInt CBoundCLPushStep_8::CallStateMachine()
{
return (0);
}
CBoundCLPushStep_9::CBoundCLPushStep_9()
{
}
CBoundCLPushStep_9::~CBoundCLPushStep_9()
{
}
TVerdict CBoundCLPushStep_9::doTestStepL()
/**
* Test sending PDU data over UDP
* Test should be run concurently with CBoundCLPushStep_4 test. CBoundCLPushStep_4 waits for push message whilst
* CBoundCLPushStep_9 sends a push message over UDP using loopback.
* The test pair is used to test two cases (dependent on configuration read for CBoundCLPushStep_9):
* - sending PDU data that is smaller than the allocated buffer on the receiving side (<=1024)
* - sending PDU data that is larger than the allocated buffer on the receiving side and needs reallocation (>1024)
* @return - TVerdict code
*/
{
INFO_PRINTF1(_L("BOUND-CLPUSH: Sending Push Message"));
if(TestStepResult() == EPass )
{
User::After(20000000);
SetTestStepResult(EFail);
SetLastError(KErrNone);
TInt error = KErrNone;
/**
Getting information from config file
Local port
Remote port
Local address
Remote address
Size of data to be sent
*/
GetIntFromConfig(ConfigSection(),KLocalPort, iLclPort);
GetIntFromConfig(ConfigSection(),KRemotePort, iRmtPort);
TPtrC temp;
if(GetStringFromConfig(ConfigSection(),KWapLocalHost, temp))
{
error = iLocalAddr.Input(temp);
if(error)
{
User::Leave(error);
}
}
if(GetStringFromConfig(ConfigSection(),KWapRemoteHost, temp ))
{
error = iRemoteAddr.Input(temp);
if(error)
{
User::Leave(error);
}
}
// error = GetStringFromConfig(ConfigSection(),KWapData, temp);
RFs fS;
RFile file;
User::LeaveIfError(fS.Connect());
_LIT(KPduFilename,"z:\\testdata\\configs\\pushpdu.bin");
_LIT(KPDUDataSize,"Data_Size");
User::LeaveIfError(file.Open(fS, KPduFilename , EFileStream | EFileRead));
/* Read PDU from the file */
TInt dataSize(1024);
GetIntFromConfig(ConfigSection(),KPDUDataSize, dataSize);
iSendBuffPtr = HBufC8::NewL(dataSize);
TPtr8 tmpbuf = iSendBuffPtr->Des();
User::LeaveIfError(file.Read(tmpbuf));
file.Close();
fS.Close();
/**
Settings
*/
iLocalAddr.SetPort(iLclPort);
iRemoteAddr.SetPort(iRmtPort);
// iSendBuffPtr = HBufC8::NewL(temp.Length());
// TPtr8 tmp = iSendBuffPtr->Des();
// tmp.Copy(temp);
INFO_PRINTF2(_L("Sending PDU of size %d over UDP to a concurrent test... "), dataSize);
/**
socket server
*/
RSocketServ socketServer;
User::LeaveIfError(socketServer.Connect());
CleanupClosePushL(socketServer);
RSocket sock;
User::LeaveIfError(sock.Open(socketServer, KAfInet, KSockDatagram, KProtocolInetUdp));
CleanupClosePushL(sock);
TRequestStatus status;
sock.SendTo(iSendBuffPtr->Des(),iRemoteAddr , 0, status);
User::WaitForRequest(status);
INFO_PRINTF2(_L("Send Push Message - status = %d"), status.Int());
User::LeaveIfError(status.Int());
sock.Close();
socketServer.Close();
CleanupStack::PopAndDestroy(&sock);
CleanupStack::Pop(&socketServer);
TVerdict verdict = (status.Int() == KErrNone)?EPass:EFail;
SetTestStepResult(verdict);
}
return TestStepResult();
}
TInt CBoundCLPushStep_9::CallStateMachine()
{
return (0);
}