37 CSmsMessage* CSmsEmsPrtTestStep::ConfigCreateSmsMessageLC(const TDesC& aDes,

    38 				TSmsDataCodingScheme::TSmsAlphabet aAlphabet)

    39 	{

    40 	_LIT(KRadiolinjaSC,"+358508771010");	// Radiolinja SC

    41 	_LIT(KPekka,"+358408415528");			// Pekka's telephone number

    42 

    43 	// Set destination and SC numbers

    44 	iTelephoneNumber=KPekka;

    45 	iServiceCenterNumber=KRadiolinjaSC;

    46 

    47 	CSmsMessage* smsMessage = CreateSmsMessageL(aDes, aAlphabet);

    48 	CleanupStack::PushL(smsMessage);

    49 	return smsMessage;

    50 	}

    51 

    52 CSmsMessage* CSmsEmsPrtTestStep::CreateSmsMessageL(const TDesC& aDes, TSmsDataCodingScheme::TSmsAlphabet aAlphabet, CSmsPDU::TSmsPDUType aType)

    53 /**

    54  *  Create a uninitialised SMS message

    55  *  @param aDes contains text that will be inserted to the pdu

    56  *  @param aAlphabet describes the alphabet of the pdu

    57  *  @return CSmsMessage* :Pointer to the created CSmsMessage object.

    58  */

    59 	{

    60 	CSmsBuffer* buffer=CSmsBuffer::NewL();

    61 	CSmsMessage* smsMessage=CSmsMessage::NewL(iFs, aType, buffer);

    62 	CleanupStack::PushL(smsMessage);

    63 

    64 	TSmsUserDataSettings smsSettings;

    65 	smsSettings.SetAlphabet(aAlphabet);

    66 	smsSettings.SetTextCompressed(EFalse);

    67 	smsMessage->SetUserDataSettingsL(smsSettings);

    68 

    69 	smsMessage->SetToFromAddressL(iTelephoneNumber);

    70 	smsMessage->SmsPDU().SetServiceCenterAddressL(iServiceCenterNumber);

    71 	buffer->InsertL(0,aDes);

    72 	CleanupStack::Pop(smsMessage);

    73 	return smsMessage;

    74 	}

    75 

    76 TBool CSmsEmsPrtTestStep::SendReceiveMsgL(CSmsMessage& aMsg)

    77 	{

    78 	// Send SMS

    79 	SendSmsL(&aMsg,iSocket);

    80 

    81 	CSmsMessage* rxMsg;

    82 

    83 	// Now receive and compare

    84 	INFO_PRINTF1(_L("waiting for incoming SMS...") );

    85 	WaitForRecvL(iSocket);

    86 	rxMsg = RecvSmsL(iSocket);

    87 

    88 	CleanupStack::PushL(rxMsg);

    89 	TBool comp = EmsTestUtils::CompareEmsMsgL(aMsg, *rxMsg);

    90 	TEST(comp);

    91 

    92 	// compare OK

    93 	INFO_PRINTF1(_L("Sent and received PDUs compare OK..."));

    94 

    95 	// Now make sure the received message is valid - this can be

    96 	// tested by ensuring that NumMessagePDUsL can be called without

    97 	// leaving

    98 	rxMsg->NumMessagePDUsL();

    99 

   100 	CleanupStack::PopAndDestroy(rxMsg);

   101 

   102 	// return the result of the comparison

   103 	return comp;

   104 	}

   105 

   106 void CSmsEmsPrtTestStep::SendSmsL(const CSmsMessage* aSms, RSocket& aSocket)

   107 /**

   108  *  Stream aSms out to the socket server

   109  *  @param aSms contains the sms tpdu that will be streamed to the sms stack

   110  *  @param aSocket is used to stream the aSms to the sms stack

   111  *  @leave Leaves if streaming the message to the socket server doesn't succeed

   112  *  @leave Leaves if sending is completed with error code

   113  */

   114 	{

   115 	TBool tryAgain = ETrue;

   116 	TInt sendTry (0);

   117 	TRequestStatus status = KErrNone;

   118 

   119 	while (tryAgain && sendTry < 3)

   120 		{

   121 		RSmsSocketWriteStream writestream(aSocket);

   122 		TRAPD(ret,writestream << *aSms);

   123 

   124 		TRAP(ret,writestream.CommitL());

   125 

   126 		TPckgBuf<TUint> sbuf;

   127 		aSocket.Ioctl(KIoctlSendSmsMessage,status,&sbuf, KSolSmsProv);

   128 		User::WaitForRequest(status);

   129 		INFO_PRINTF2(_L("SendSmsL - sendSmsMessage returned %d"),status.Int());

   130 		if (status.Int() )

   131 			{

   132 			tryAgain = ETrue;

   133 			INFO_PRINTF1(_L("Try again... "));

   134 			sendTry++;

   135 			}

   136 		else tryAgain = EFalse;

   137 		}

   138 

   139 	TEST(status.Int() == KErrNone);

   140 

   141     PrintMessageL(aSms);

   142 	}

   143 

   144 void CSmsEmsPrtTestStep::PrintMessageL(const CSmsMessage* aSms)

   145 /**

   146  *  Print the content of SMS to the console

   147  */

   148 	{

   149 	CSmsBuffer& smsbuffer = (CSmsBuffer&)aSms->Buffer();

   150 	const TInt len = smsbuffer.Length();

   151 	HBufC* hbuf = HBufC::NewL(len);

   152 	TPtr ptr = hbuf->Des();

   153 	smsbuffer.Extract(ptr,0,len);

   154 	INFO_PRINTF1(_L("SMS contains..."));

   155 

   156 	for (TInt j = 0; j < len; j++)

   157         ptr[j]=IsCharDisplayable((TText8)ptr[j]);

   158 

   159 

   160     INFO_PRINTF1(ptr);

   161 	INFO_PRINTF1(_L(""));

   162 

   163 	delete hbuf;

   164 	}

   165 

   166 TText8 CSmsEmsPrtTestStep::IsCharDisplayable( const TText8 aChar )

   167 	{

   168 	if(( aChar >= 0x20) && (aChar <= 0x80))

   169 		return aChar;

   170 	else

   171 		return '.';

   172 	}

   173 

   174 

   175 

   176 void CSmsEmsPrtTestStep::WaitForRecvL(RSocket& aSocket)

   177 /**

   178  *  Wait for an Sms to be received

   179  *  @param aSocket The status is return to this socket

   180  *  @leave Leaves if receiving is completed with error code

   181  */

   182 	{

   183 	TPckgBuf<TUint> sbuf;

   184 	sbuf()=KSockSelectRead;

   185 	TRequestStatus status;

   186 	aSocket.Ioctl(KIOctlSelect,status,&sbuf,KSOLSocket);

   187 	User::WaitForRequest(status);

   188 	TEST(status.Int() == KErrNone);

   189 	}

   190 

   191 CSmsMessage* CSmsEmsPrtTestStep::RecvSmsL(RSocket& aSocket, TInt aIoctl)

   192 /**

   193  *  Receive an Sms

   194  *  @param aSocket is used to stream the sms message from the socket server

   195  *  @return CSmsMessage* :Sms message from Sms stack

   196  *  @leave Leaves if streaming the message from the socket server doesn't succeed

   197  */

   198 	{

   199 	CSmsBuffer* buffer=CSmsBuffer::NewL();

   200 	CSmsMessage* smsMessage=CSmsMessage::NewL(iFs, CSmsPDU::ESmsSubmit,buffer);

   201 	CleanupStack::PushL(smsMessage);

   202 

   203 	RSmsSocketReadStream readstream(aSocket);

   204 	TRAPD(ret,readstream >> *smsMessage);

   205 	TEST(ret == KErrNone);

   206 

   207 	TPckgBuf<TUint> sbuf;

   208 	TRequestStatus status;

   209 	aSocket.Ioctl(aIoctl, status, &sbuf, KSolSmsProv);

   210 	User::WaitForRequest(status);

   211 

   212 	CleanupStack::Pop(smsMessage);

   213 	return smsMessage;

   214 	}

   215 

   216 void CSmsEmsPrtTestStep::PrepareRegTestL()

   217 /**

   218  *  Run a specified test.

   219  *  The test number is passed via property KUidPSSimTsyCategory. This will notify the SIM tsy

   220  *  SIM tsy uses test number to parse correct script from config.txt

   221  *  @param aTestNumber The test number corresponding the test case

   222  */

   223 	{

   224 	RProperty testNumberProperty;

   225 	User::LeaveIfError(testNumberProperty.Attach(KUidPSSimTsyCategory, KPSSimTsyTestNumber));

   226 	CleanupClosePushL(testNumberProperty);

   227 

   228 	TRequestStatus status;

   229 	testNumberProperty.Subscribe(status);

   230 	TInt testNumber = GetTestNumber();

   231 	User::LeaveIfError(testNumberProperty.Set(KUidPSSimTsyCategory,KPSSimTsyTestNumber,testNumber));

   232 	User::WaitForRequest(status);

   233 	TEST(status.Int() == KErrNone);

   234 	TInt testNumberCheck;

   235 	User::LeaveIfError(testNumberProperty.Get(testNumberCheck));

   236 	if (testNumber != testNumberCheck)

   237 		User::Leave(KErrNotFound);

   238 

   239 	CleanupStack::PopAndDestroy(&testNumberProperty);

   240 

   241     INFO_PRINTF1(_L("Connecting to SocketServer ..."));

   242 	TInt ret=iSocketServ.Connect(KSocketMessageSlots);

   243     TEST(ret == KErrNone);

   244 

   245 	INFO_PRINTF1(_L("Deleting segmentation and reassembly stores..."));

   246 

   247 	// delete segmentation and reassembly store files before the test

   248 	_LIT(KReassemblyStoreName,"C:\\Private\\101F7989\\sms\\smsreast.dat");

   249 	_LIT(KSegmentationStoreName,"C:\\Private\\101F7989\\sms\\smssegst.dat");

   250 

   251 	iFs.Delete(KReassemblyStoreName);

   252 	iFs.Delete(KSegmentationStoreName);

   253 	}

   254 

   255 void CSmsEmsPrtTestStep::EndRegTest()

   256 /**

   257  *  Closes objects used at test harness

   258  */

   259  	{

   260 	INFO_PRINTF1(_L("Closing Reg Test"));

   261 	User::After(2000000); //Wait a couple of seconds to avoid closing the SMS stack too early

   262 	iSocketServ.Close();

   263 	User::After(2000000); //Wait a couple of seconds to avoid closing the SMS stack too early

   264 	}

   265