telephonyserverplugins/common_tsy/test/component/ussdtestclient/src/ussdtestclient.cpp
// Copyright (c) 2007-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 "ussdtestclient.h"
#include <ctsy/mmtsy_names.h>
#include <e32debug.h>
#include <e32math.h>
CCTsyUssdMessagingTestClient::CCTsyUssdMessagingTestClient()
{
}
/**
@SYMTestCaseID
@SYMComponent telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::ReceiveMessage
@SYMTestPriority High
@SYMTestActions Invokes RMobileUssdMessaging::ReceiveMessage
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
TInt CCTsyUssdMessagingTestClient::ReceiveMessageL(TBool aAcceptDialogue, TBool aReceiveTimeout, TReal aAfterTimePeriod)
{
// Create a cleanup stack object
CTrapCleanup* cleanup=CTrapCleanup::New();
if (cleanup==NULL)
return KErrNoMemory;
RTelServer server;
RMobilePhone phone;
TInt ret = server.Connect();
if (ret != KErrNone)
{
server.Close();
return ret;
}
ret = phone.Open(server,KMmTsyPhoneName);
if (ret != KErrNone)
{
server.Close();
phone.Close();
return ret;
}
TRequestStatus requestStatus;
RMobileUssdMessaging::TGsmUssdMessageData name;
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging ussdMessaging;
ret = ussdMessaging.Open(phone);
if (ret != KErrNone)
{
server.Close();
phone.Close();
return ret;
}
//RDebug::Printf("%x >> ReceiveMessage", User::Identity());
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
//RDebug::Printf("%x << ReceiveMessage", User::Identity());
if (aReceiveTimeout)
{
// This section of code and the aReceiveTimeout parameter apply
// to the TestReceiveMessageWithTestClient0016L test
// (BA-CTSY-USSDM-URM-0020).
// This test verifies that the second client does not recieve
// a message. As part of the test spec we must call close on
// the RMobileUssdMessaging object.
// Rather than adding a whole ActiveScheduler framework to this
// executable we've put in a wait and check loop. We can't use
// User::WaitForRequest as this would block. We don't want to
// block as we are checking that an event which
// *does not occur* rather than checking for an event which
// does occur.
for (TInt i=0; i<50; ++i)
{
User::After(100000); // 0.1s
if (requestStatus.Int() != KRequestPending)
{
break;
}
}
if (requestStatus.Int() == KRequestPending)
{
ussdMessaging.Close();
phone.Close();
server.Close();
delete cleanup;
return KRequestPending;
}
}
//RDebug::Printf("%x >> WaitForRequest", User::Identity());
User::WaitForRequest(requestStatus);
//RDebug::Printf("%x << WaitForRequest", User::Identity());
//RDebug::Printf("%x requestStatus = %d", User::Identity(), requestStatus.Int());
if (aAfterTimePeriod)
{
//RDebug::Printf("%x Waiting for %f seconds", User::Identity(), aAfterTimePeriod);
// Wait, mimic a bad client taking too long...
User::After(aAfterTimePeriod * 1000000);
}
if (aAcceptDialogue)
{
//RDebug::Printf("%x >> AcceptIncomingDialogue", User::Identity());
// Client wants the dialogue
ret = ussdMessaging.AcceptIncomingDialogue();
//RDebug::Printf("%x << AcceptIncomingDialogue", User::Identity());
}
else
{
// Client not interested
//RDebug::Printf("%x >> RejectIncomingDialogue", User::Identity());
ret = ussdMessaging.RejectIncomingDialogue();
//RDebug::Printf("%x << RejectIncomingDialogue", User::Identity());
}
User::After(2 * 1000000);
ussdMessaging.Close();
phone.Close();
server.Close();
delete cleanup;
return ret;
}
TInt CCTsyUssdMessagingTestClient::SendMessageL()
{
// Create a cleanup stack object
CTrapCleanup* cleanup=CTrapCleanup::New();
if (cleanup==NULL)
return KErrNoMemory;
RTelServer server;
RMobilePhone phone;
TInt ret = server.Connect();
if (ret != KErrNone)
{
server.Close();
return ret;
}
ret = phone.Open(server,KMmTsyPhoneName);
if (ret != KErrNone)
{
server.Close();
phone.Close();
return ret;
}
TRequestStatus requestStatus;
TUint32 flags = 100;
RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;
RMobileUssdMessaging::TMobileUssdMessageType type = RMobileUssdMessaging::EUssdMORequest;
TUint8 dcs = 200;
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
attributes.iFlags = flags;
attributes.iFormat = format;
attributes.iType = type;
attributes.iDcs = dcs;
TName name = _L("Name1");
TPckg<TName> msgData(name);
RMobileUssdMessaging ussdMessaging;
ret = ussdMessaging.Open(phone);
if (ret != KErrNone)
{
server.Close();
phone.Close();
return ret;
}
//RDebug::Printf(">> SendMessage");
ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes);
//RDebug::Printf("<< SendMessage");
//RDebug::Printf(">> WaitForRequest");
User::WaitForRequest(requestStatus);
//RDebug::Printf("<< WaitForRequest");
ret = requestStatus.Int();
//RDebug::Printf("requestStatus = %d", ret);
User::After(2 * 1000000);
ussdMessaging.Close();
phone.Close();
server.Close();
delete cleanup;
return KErrNone;
}
TInt CCTsyUssdMessagingTestClient::RandomLoopL()
{
// Create a cleanup stack object
CTrapCleanup* cleanup=CTrapCleanup::New();
if (cleanup==NULL)
return KErrNoMemory;
RTelServer server;
RMobilePhone phone;
TInt ret = server.Connect();
if (ret != KErrNone)
{
server.Close();
return ret;
}
ret = phone.Open(server,KMmTsyPhoneName);
if (ret != KErrNone)
{
server.Close();
phone.Close();
return ret;
}
TRequestStatus requestStatus;
RMobileUssdMessaging::TGsmUssdMessageData name;
RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;
TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);
RMobileUssdMessaging ussdMessaging;
FOREVER
{
ret = ussdMessaging.Open(phone);
if (ret != KErrNone)
{
server.Close();
phone.Close();
return ret;
}
//RDebug::Printf("%x >> ReceiveMessage", User::Identity());
ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);
//RDebug::Printf("%x << ReceiveMessage", User::Identity());
if (ProbabilityPercent(50))
{
for (TInt i=0; i<10; ++i)
{
User::After(100000); // 0.1s
if (requestStatus.Int() != KRequestPending)
{
break;
}
}
}
else
{
User::WaitForRequest(requestStatus);
}
if (requestStatus.Int() == KErrNone)
{
if (ProbabilityPercent(50))
{
TInt timeout = RandomNumber(1000000);
User::After(timeout);
}
if (ProbabilityPercent(50))
{
ret = ussdMessaging.AcceptIncomingDialogue();
}
else
{
ret = ussdMessaging.RejectIncomingDialogue();
}
}
else
{
ussdMessaging.CancelAsyncRequest(EMobileUssdMessagingReceiveMessage);
}
ussdMessaging.Close();
}
phone.Close();
server.Close();
delete cleanup;
return ret;
}
TBool CCTsyUssdMessagingTestClient::ProbabilityPercent(TInt aPercentTrue)
{
TInt random = RandomNumber(100);
return aPercentTrue < random;
}
// Not properly random but good enough...
TInt CCTsyUssdMessagingTestClient::RandomNumber(TInt aMax)
{
TUint32 rand = Math::Random() % aMax;
return rand;
}
_LIT(KReceiveOption,"-R");
_LIT(KReceiveTimeoutOption,"-RTimeout");
_LIT(KSendOption,"-S");
_LIT(KAcceptOption,"-A");
_LIT(KTimerOption,"-T");
_LIT(KRandomOption,"-Random");
TInt ParseCommandLine(TReal& aAfterTimePeriod)
{
TBuf<256> c;
User::CommandLine(c);
TLex l(c);
// Get options
TInt option = 0;
aAfterTimePeriod = 0;
TPtrC nextToken;
for (;;)
{
nextToken.Set(l.NextToken());
if (nextToken == KReceiveOption)
{
option |= EOptionReceive;
}
else if (nextToken == KReceiveTimeoutOption)
{
option |= EOptionReceiveTimeout;
}
else if (nextToken == KSendOption)
{
option |= EOptionSend;
}
else if (nextToken == KAcceptOption)
{
option |= EOptionAccept;
}
else if (nextToken == KTimerOption)
{
nextToken.Set(l.NextToken());
if (nextToken != KNullDesC)
{
TLex sl(nextToken);
if (sl.Val(aAfterTimePeriod)!=KErrNone)
aAfterTimePeriod = 0.0;
}
}
else if (nextToken == KRandomOption)
{
option |= EOptionRandom;
}
else
{
break;
}
}
return option;
}
TInt E32Main()
/**
Executable entrypoint calls test functions within heap check.
*/
{
//__UHEAP_MARK;
CTrapCleanup* cleanup=CTrapCleanup::New();
TReal afterTimePeriod;
TInt option = ParseCommandLine(afterTimePeriod);
TInt err = KErrNone;
TInt ret = KErrNone;
CCTsyUssdMessagingTestClient ussdClient;
if (option & EOptionReceive)
{
TRAPD(err, ret = ussdClient.ReceiveMessageL((option & EOptionAccept), (option & EOptionReceiveTimeout), afterTimePeriod));
}
if (option & EOptionSend)
{
TRAPD(err, ret = ussdClient.SendMessageL());
}
if (option & EOptionRandom)
{
TRAPD(err, ret = ussdClient.RandomLoopL());
}
delete cleanup;
//__UHEAP_MARKEND;
return err ? err : ret;
}