1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Tests added for new functionality in 9.4

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20 */

    21 

    22 #include "Te_EtelSatTestStepBase.h"

    23 #include "TE_EtelSatpcmds1f.h"

    24 #include <utf.h>

    25 

    26 CTestSatPCmds1f::CTestSatPCmds1f()

    27 /** Each test step initialises it's own name

    28 */

    29 	{

    30 	// store the name of this test case

    31 	// this is the name that is used by the script file

    32 	SetTestStepName(_L("TestSatPCmds1f"));

    33 	}

    34 	

    35 enum TVerdict CTestSatPCmds1f::doTestStepL()

    36 	{

    37     

    38     INFO_PRINTF1(_L("***********************************************"));

    39 	INFO_PRINTF1(_L("RSat Proactive Commands Functionality suite"));

    40 	INFO_PRINTF1(_L("***********************************************"));

    41 	

    42 	TInt ret=phone.Open(iTelServer,DSATTSY_PHONE_NAME);

    43 	TEST(ret==KErrNone);

    44 

    45 	ret=sat.Open(phone);

    46     TEST(ret==KErrNone);

    47     

    48 	/**

    49     Testing Release 6 Features of Universal Subscriber Identity Module(USIM) 

    50     Application ToolKit

    51     

    52     Release6Test1() function call is made to test the newly added Retrieve(\Submit\Display) Multimedia 

    53     proactive commands.

    54     

    55     @test TSAT289

    56     @test TSAT290

    57     @test TSAT291

    58     @test TSAT292

    59 	@test TSAT293

    60 	@test TSAT294

    61     @test TSAT340

    62     @test TSAT341

    63     @test TSAT342

    64     */

    65    

    66 	Release6Test1L();

    67 	

    68 	/**

    69 	Release6Test2() function call is made to test the newly added proactive commands 

    70 	SetFrames and GetFrameStatus.

    71 	

    72 	@test TSAT295

    73 	@test TSAT296

    74 	@test TSAT297

    75 	@test TSAT298

    76 	@test TSAT343

    77     @test TSAT344

    78 	*/

    79 	

    80 	Release6Test2L();

    81 	

    82 	/**

    83 	Release6Test3() function call is made to test the existing proactive commands with the new V6 class added.

    84 	LocalInfo, GetMeSideSatProfile are the existing commands tested here.

    85 	

    86 	@test TSAT304

    87 	@test TSAT307

    88  	@test TSAT306

    89  	@test TSAT308

    90 	@test TSAT309

    91 	@test TSAT366

    92     @test TSAT310

    93     @test TSAT367

    94 	@test TSAT368

    95 	*/

    96 	

    97 	Release6Test3L();

    98 	

    99 	/**

   100 	Release6Test4() function call is made to test the existing proactive commands with the new V6 class added.

   101 	Send Ussd, Play Tone , SetUpEventList, LaunchBrowser, DisplayText are the existing commands tested here.

   102 	

   103 	@test TSAT311

   104 	@test TSAT371

   105     @test TSAT312

   106     @test TSAT372

   107 	@test TSAT320

   108 	@test TSAT338

   109     @test TSAT339

   110 	@test TSAT322

   111     @test TSAT323

   112 	@test TSAT330

   113 	@test TSAT368

   114   	@test TSAT331

   115    	@test TSAT369

   116 	@test TSAT332

   117     @test TSAT333

   118 	*/

   119 	

   120 	Release6Test4L();

   121 	

   122 	/**

   123 	Release6Test5() function call is made to test the existing proactive commands with the new V6 class added.

   124 	GetInkey, GetInput, SelectItem, SendSm, SetUpCall, SetUpIdleModeText are the existing commands tested here.

   125 

   126 	@test TSAT334

   127     @test TSAT335

   128 	@test TSAT336

   129     @test TSAT337

   130 	@test TSAT340

   131     @test TSAT341

   132 	@test TSAT342

   133     @test TSAT343

   134 	@test TSAT344

   135     @test TSAT345

   136 	@test TSAT346

   137 	@test TSAT347

   138 	*/

   139 	

   140 	Release6Test5L();

   141 	

   142 	/**

   143 	Release6Test6() function call is made to test the existing proactive commands with the new V6 class added.

   144 	RunAtCommand, SendDtmf, CloseChannel, ReceiveData are the existing commands tested here.

   145 	

   146 	@test TSAT348

   147 	@test TSAT349

   148 	@test TSAT350	

   149 	@test TSAT351

   150    	@test TSAT352

   151    	@test TSAT353

   152 	@test TSAT354

   153 	@test TSAT355

   154 	*/

   155 	

   156 	Release6Test6L();

   157 	

   158 	/**

   159 	Release6Test7() function call is made to test the existing proactive commands with the new V6 class added.

   160 	SendData, GetServiceSearch , GetServiceInfo, SendSs, Open Channel are the existing commands tested here.

   161 	

   162 	@test TSAT356

   163     @test TSAT357

   164 	@test TSAT358

   165 	@test TSAT359

   166     @test TSAT360

   167     @test TSAT361

   168 	@test TSAT369

   169 	@test TSAT362

   170 	@test TSAT363

   171 	@test TSAT370

   172 	@test TSAT375

   173 	@test TSAT376

   174 	@test TSAT377

   175 	@test TSAT378

   176 	*/

   177 	

   178 	Release6Test7L();

   179 	

   180 	sat.Close();

   181 	phone.Close();

   182 	return TestStepResult();

   183 	}

   184 	

   185 void CTestSatPCmds1f::Release6Test1L()

   186 	{

   187 	/**

   188 	Testing Retrieve Multimedia Message Proactive command which has been newly

   189 	added as part of the Release 6 Features of USIM Application ToolKit

   190 	@test TSAT289

   191 	*/	

   192 	RSat::TRetrieveMultimediaMessageV6* retrieveMM = new (ELeave) RSat::TRetrieveMultimediaMessageV6;

   193 	CleanupStack::PushL(retrieveMM);

   194 	

   195 	RSat::TRetrieveMultimediaMessageV6Pckg* retrieveMMPckg = new (ELeave) RSat::TRetrieveMultimediaMessageV6Pckg(*retrieveMM);

   196 	CleanupStack::PushL(retrieveMMPckg);

   197 

   198 	sat.NotifyRetrieveMultimediaMsgPCmd(reqStatus, *retrieveMMPckg);

   199 	User::WaitForRequest(reqStatus);

   200 	TEST(reqStatus.Int()==KErrNone);

   201 	TEST(retrieveMM->iDestination == DSATTSYV6_DEVICE_ID1);	

   202 	TEST(retrieveMM->iAlphaId.iAlphaId== DSATTSYV6_ALPHAID1);

   203 	TEST(retrieveMM->iAlphaId.iStatus == DSATTSYV6_ALPHAID_STATUS2);

   204 	TEST(retrieveMM->iIconId.iIdentifier  == DSATTSYV6_ICON_ID1);	

   205 	TEST(retrieveMM->iIconId.iQualifier  == DSATTSYV6_ICON_QUALIFIER3);	

   206 	TEST(retrieveMM->iMultimediaContentId  == DSATTSYV6_MULTIMEDIA_CONTENT_ID1);

   207 	TEST(retrieveMM->iMultimediaMessageRef  == DSATTSYV6_MULTIMEDIA_MESSAGE_REF1);

   208 	TEST(retrieveMM->iMultimediaMessageId  == DSATTSYV6_MULTIMEDIA_MESSAGE_ID1);	

   209   	

   210   	RSat::TTextAttribute textAttribute;

   211 	textAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS;

   212 	const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA;

   213 	textAttribute.iTextAttributeData.Append(textAttributeData, DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH);

   214   	

   215   	TEST(retrieveMM->iTextAttribute.iStatus == textAttribute.iStatus);     

   216     TEST(retrieveMM->iTextAttribute.iTextAttributeData == textAttribute.iTextAttributeData);

   217     		

   218     /**

   219     Testing Cancel API for the Retrieve Multimedia Message Proactive command

   220     @test TSAT290

   221     */

   222     

   223     //Cancel	

   224 	sat.NotifyRetrieveMultimediaMsgPCmd(reqStatus, *retrieveMMPckg);

   225 	sat.CancelAsyncRequest(ESatNotifyRetrieveMultimediaMsgPCmd);

   226 	User::WaitForRequest(reqStatus);

   227 	TEST(reqStatus.Int()==KErrCancel);

   228     

   229     /**

   230     Testing Terminal Response for the Retrieve Multimedia Message Proactive command

   231     @test TSAT340

   232     */

   233     

   234     //Response

   235    	RSat::TRetrieveMultimediaMessageRspV6* retrieveMMRsp = new (ELeave) RSat::TRetrieveMultimediaMessageRspV6;

   236 	CleanupStack::PushL(retrieveMMRsp);

   237 	

   238 	RSat::TRetrieveMultimediaMessageRspV6Pckg* retrieveMMRspPckg = new (ELeave) RSat::TRetrieveMultimediaMessageRspV6Pckg(*retrieveMMRsp);

   239 	CleanupStack::PushL(retrieveMMRspPckg);

   240 		

   241 	retrieveMMRsp->SetPCmdNumber(DSATTSY_RETRIEVE_MULTIMEDIA_MESSAGE);

   242 	retrieveMMRsp->iGeneralResult=DSATTSY_PCMD_RESULT_SUCCESS;

   243 	retrieveMMRsp->iInfoType=DSATTSY_PCMD_RSP_NO_INFO;	

   244 	

   245 	sat.NotifyRetrieveMultimediaMsgPCmd(reqStatus, *retrieveMMPckg);

   246 	User::WaitForRequest(reqStatus);

   247 	TEST(reqStatus.Int()==KErrNone);	

   248 

   249 	sat.TerminalRsp(reqStatus,RSat::ERetrieveMultimediaMsg,*retrieveMMRspPckg);

   250 	User::WaitForRequest(reqStatus);

   251 	TEST(reqStatus.Int()==KErrNone);

   252 	INFO_PRINTF2(_L("Test %d - RSat::TerminalRsp - Retrieve Multimedia Message - passed"),iTestCount++);	

   253     

   254     CleanupStack::PopAndDestroy(4);

   255     

   256     /**

   257 	Testing Submit Multimedia Message Proactive command which has been newly

   258 	added as part of the Release 6 Features of USIM Application ToolKit

   259 	@test TSAT291

   260 	*/

   261 	RSat::TSubmitMultimediaMessageV6* submitMM = new (ELeave) RSat::TSubmitMultimediaMessageV6;

   262 	CleanupStack::PushL(submitMM);

   263 	

   264 	RSat::TSubmitMultimediaMessageV6Pckg* submitMMPckg = new (ELeave) RSat::TSubmitMultimediaMessageV6Pckg(*submitMM);

   265 	CleanupStack::PushL(submitMMPckg);

   266 

   267 	sat.NotifySubmitMultimediaMsgPCmd(reqStatus, *submitMMPckg);

   268 

   269 	User::WaitForRequest(reqStatus);

   270 	TEST(reqStatus.Int()==KErrNone);

   271 	TEST(submitMM->iDestination == DSATTSYV6_DEVICE_ID1);	

   272 	TEST(submitMM->iAlphaId.iAlphaId== DSATTSYV6_ALPHAID1);

   273 	TEST(submitMM->iAlphaId.iStatus == DSATTSYV6_ALPHAID_STATUS2);

   274 	TEST(submitMM->iIconId.iIdentifier  == DSATTSYV6_ICON_ID1);	

   275 	TEST(submitMM->iIconId.iQualifier  == DSATTSYV6_ICON_QUALIFIER3);	

   276 	TEST(submitMM->iMultimediaMessageId  == DSATTSYV6_MULTIMEDIA_MESSAGE_ID1);	

   277   	TEST(submitMM->iTextAttribute.iStatus == textAttribute.iStatus);     

   278     TEST(submitMM->iTextAttribute.iTextAttributeData == textAttribute.iTextAttributeData);		

   279     TEST(submitMM->iSubmissionFile == DSATTSYV6_SUBMISSION_FILE1);

   280     

   281     /**

   282     Testing Cancel API for the Submit Multimedia Message Proactive command

   283     @test TSAT292

   284     */

   285     

   286     //Cancel	

   287 	sat.NotifySubmitMultimediaMsgPCmd(reqStatus, *submitMMPckg);

   288 	sat.CancelAsyncRequest(ESatNotifySubmitMultimediaMsgPCmd);

   289 	User::WaitForRequest(reqStatus);

   290 	TEST(reqStatus.Int()==KErrCancel);

   291        

   292     /**

   293     Testing Terminal Response for the Submit Multimedia Message Proactive command

   294     @test TSAT341

   295     */

   296     

   297     //Response

   298    	RSat::TSubmitMultimediaMessageRspV6* submitMMRsp = new (ELeave) RSat::TSubmitMultimediaMessageRspV6;

   299 	CleanupStack::PushL(submitMMRsp);

   300 	

   301 	RSat::TSubmitMultimediaMessageRspV6Pckg* submitMMRspPckg = new (ELeave) RSat::TSubmitMultimediaMessageRspV6Pckg(*submitMMRsp);

   302 	CleanupStack::PushL(submitMMRspPckg);

   303 		

   304 	submitMMRsp->SetPCmdNumber(DSATTSY_SUBMIT_MULTIMEDIA_MESSAGE);

   305 	submitMMRsp->iGeneralResult=DSATTSY_PCMD_RESULT_SUCCESS;

   306 	submitMMRsp->iInfoType=DSATTSY_PCMD_RSP_NO_INFO;	

   307 	

   308 	sat.NotifySubmitMultimediaMsgPCmd(reqStatus, *submitMMPckg);

   309 	User::WaitForRequest(reqStatus);

   310 	TEST(reqStatus.Int()==KErrNone);	

   311 

   312 	sat.TerminalRsp(reqStatus,RSat::ESubmitMultimediaMsg,*submitMMRspPckg);

   313 	User::WaitForRequest(reqStatus);

   314 	TEST(reqStatus.Int()==KErrNone);

   315 	INFO_PRINTF2(_L("Test %d - RSat::TerminalRsp - Submit Multimedia Message - passed"),iTestCount++);

   316 	

   317     CleanupStack::PopAndDestroy(4);

   318     

   319 	/**

   320 	Testing Display Multimedia Message Proactive command which has been newly

   321 	added as part of the Release 6 Features of USIM Application ToolKit

   322 	@test TSAT293

   323 	*/

   324 	RSat::TDisplayMultimediaMessageV6* displayMM = new (ELeave) RSat::TDisplayMultimediaMessageV6;

   325 	CleanupStack::PushL(displayMM);

   326 	

   327 	RSat::TDisplayMultimediaMessageV6Pckg* displayMMPckg = new (ELeave) RSat::TDisplayMultimediaMessageV6Pckg(*displayMM);

   328 	CleanupStack::PushL(displayMMPckg);

   329 

   330 	sat.NotifyDisplayMultimediaMsgPCmd(reqStatus, *displayMMPckg);

   331 

   332 	User::WaitForRequest(reqStatus);

   333 	TEST(reqStatus.Int()==KErrNone);

   334 	TEST(displayMM->iDestination == DSATTSYV6_DEVICE_ID3);

   335 	TEST(displayMM->iDisplayPriority == DSATTSYV6_DISPLAY_PRIORITY1);

   336 	TEST(displayMM->iSubmissionFile == DSATTSYV6_SUBMISSION_FILE1);

   337 	TEST(displayMM->iMultimediaMessageId == DSATTSYV6_MULTIMEDIA_MESSAGE_ID1);

   338 	TEST(displayMM->iImmediateRsp == DSATTSYV6_IMMEDIATE_RESPONSE1);

   339     

   340     /**

   341     Testing Cancel API for the Display Multimedia Message Proactive command

   342     @test TSAT294

   343     */

   344     

   345     //Cancel	

   346 	sat.NotifyDisplayMultimediaMsgPCmd(reqStatus, *displayMMPckg);

   347 	sat.CancelAsyncRequest(ESatNotifyDisplayMultimediaMsgPCmd);

   348 	User::WaitForRequest(reqStatus);

   349 	TEST(reqStatus.Int()==KErrCancel);

   350     

   351     /**

   352     Testing Terminal Response for the Display Multimedia Message Proactive command

   353     @test TSAT342

   354     */

   355     

   356     //Response

   357    	RSat::TDisplayMultimediaMessageRspV6* displayMMRsp = new (ELeave) RSat::TDisplayMultimediaMessageRspV6;

   358 	CleanupStack::PushL(displayMMRsp);

   359 	

   360 	RSat::TDisplayMultimediaMessageRspV6Pckg* displayMMRspPckg = new (ELeave) RSat::TDisplayMultimediaMessageRspV6Pckg(*displayMMRsp);

   361 	CleanupStack::PushL(displayMMRspPckg);

   362 	

   363 	displayMMRsp->SetPCmdNumber(DSATTSY_DISPLAY_MULTIMEDIA_MESSAGE);

   364 	displayMMRsp->iGeneralResult=DSATTSY_PCMD_RESULT_SUCCESS;

   365 	displayMMRsp->iInfoType=DSATTSY_PCMD_RSP_NO_INFO;	

   366 	

   367 	sat.NotifyDisplayMultimediaMsgPCmd(reqStatus, *displayMMPckg);

   368 	User::WaitForRequest(reqStatus);

   369 	TEST(reqStatus.Int()==KErrNone);	

   370 

   371 	sat.TerminalRsp(reqStatus,RSat::EDisplayMultimediaMsg,*displayMMRspPckg);

   372 	User::WaitForRequest(reqStatus);

   373 	TEST(reqStatus.Int()==KErrNone);

   374 	INFO_PRINTF2(_L("Test %d - RSat::TerminalRsp - Display Multimedia Message - passed"),iTestCount++);

   375 	

   376 	CleanupStack::PopAndDestroy(4);

   377 	}

   378 	

   379 void CTestSatPCmds1f::Release6Test2L()

   380 	{

   381 	/**

   382 	Testing Set Frames Proactive command which has been newly

   383 	added as part of the Release 6 Features of USIM Application ToolKit

   384 	@test TSAT295

   385 	*/

   386 	RSat::TSetFramesV6* setFrames = new (ELeave) RSat::TSetFramesV6;

   387 	CleanupStack::PushL(setFrames);

   388 	

   389 	RSat::TSetFramesV6Pckg* setFramesPckg = new (ELeave) RSat::TSetFramesV6Pckg(*setFrames);

   390 	CleanupStack::PushL(setFramesPckg);

   391 

   392 	sat.NotifySetFramesPCmd(reqStatus, *setFramesPckg);

   393 

   394 	User::WaitForRequest(reqStatus);

   395 	TEST(reqStatus.Int()==KErrNone);

   396 	TEST(setFrames->iDestination == DSATTSYV6_DEVICE_ID1);

   397     TEST(setFrames->iDefaultFrameId == DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1);

   398     TEST(setFrames->iFrameId == DSATTSYV6_FRAME_IDENTIFIER1);

   399     TEST(setFrames->iFrameLayout.iFramesLayout == DSATTSYV6_FRAME_LAYOUT_FORMAT1);

   400     TEST(setFrames->iFrameLayout.iFrameLayoutBuf == DSATTSYV6_FRAME_LAYOUT1);

   401     

   402     /**

   403     Testing Cancel API for the Set Frames Proactive command

   404     @test TSAT296

   405     */

   406     

   407     //Cancel	

   408 	sat.NotifySetFramesPCmd(reqStatus, *setFramesPckg);

   409 	sat.CancelAsyncRequest(ESatNotifySetFramesPCmd);

   410 	User::WaitForRequest(reqStatus);

   411 	TEST(reqStatus.Int()==KErrCancel);

   412     

   413     /**

   414     Testing Terminal Response for the Set Frames Proactive command

   415     @test TSAT343

   416     */

   417     

   418     //Response

   419    	RSat::TSetFramesRspV6* setFramesRsp = new (ELeave) RSat::TSetFramesRspV6;

   420 	CleanupStack::PushL(setFramesRsp);

   421 	

   422 	RSat::TSetFramesRspV6Pckg* setFramesRspPckg = new (ELeave) RSat::TSetFramesRspV6Pckg(*setFramesRsp);

   423 	CleanupStack::PushL(setFramesRspPckg);

   424 		

   425 	setFramesRsp->SetPCmdNumber(DSATTSY_SET_FRAMES);

   426 	setFramesRsp->iGeneralResult=DSATTSY_PCMD_RESULT_SUCCESS;

   427 	setFramesRsp->iInfoType=DSATTSY_PCMD_RSP_NO_INFO;	

   428 	setFramesRsp->iFramesInformation.iFrameId=DSATTSY_FRAMES_INFORMATION_FRAMEID;

   429 	setFramesRsp->iFramesInformation.iFrameList=DSATTSY_FRAMES_INFORMATION_FRAME_LIST;

   430 	

   431 	sat.NotifySetFramesPCmd(reqStatus, *setFramesPckg);

   432 	User::WaitForRequest(reqStatus);

   433 	TEST(reqStatus.Int()==KErrNone);	

   434 

   435 	sat.TerminalRsp(reqStatus,RSat::ESetFrames,*setFramesRspPckg);

   436 	User::WaitForRequest(reqStatus);

   437 	TEST(reqStatus.Int()==KErrNone);

   438 	INFO_PRINTF2(_L("Test %d - RSat::TerminalRsp - Set Frames - passed"),iTestCount++);

   439 	

   440 	CleanupStack::PopAndDestroy(4);

   441 		

   442 	/**

   443 	Testing Get Frames Status Proactive command which has been newly

   444 	added as part of the Release 6 Features of USIM Application ToolKit

   445 	@test TSAT297

   446 	*/

   447 	RSat::TGetFramesStatusV6* getFramesStatus = new (ELeave) RSat::TGetFramesStatusV6;

   448 	CleanupStack::PushL(getFramesStatus);

   449 	

   450 	RSat::TGetFramesStatusV6Pckg* getFramesStatusPckg = new (ELeave) RSat::TGetFramesStatusV6Pckg(*getFramesStatus);

   451 	CleanupStack::PushL(getFramesStatusPckg);

   452 

   453 	sat.NotifyGetFramesStatusPCmd(reqStatus, *getFramesStatusPckg);

   454 

   455 	User::WaitForRequest(reqStatus);

   456 	TEST(reqStatus.Int()==KErrNone);

   457 	TEST(getFramesStatus->iDestination == DSATTSYV6_DEVICE_ID1);

   458     

   459     /**

   460     Testing Cancel API for the Get Frames Status Proactive command

   461     @test TSAT298

   462     */

   463     

   464     //Cancel	

   465 	sat.NotifyGetFramesStatusPCmd(reqStatus, *getFramesStatusPckg);

   466 	sat.CancelAsyncRequest(ESatNotifyGetFramesStatusPCmd);

   467 	User::WaitForRequest(reqStatus);

   468 	TEST(reqStatus.Int()==KErrCancel);

   469     

   470     /**

   471     Testing Terminal Response for the Get Frames Status Proactive command

   472     @test TSAT344

   473     */

   474     

   475     //Response

   476    	RSat::TGetFramesStatusRspV6* getFramesStatusRsp = new (ELeave) RSat::TGetFramesStatusRspV6;

   477 	CleanupStack::PushL(getFramesStatusRsp);

   478 	

   479 	RSat::TGetFramesStatusRspV6Pckg* getFramesStatusRspPckg = new (ELeave) RSat::TGetFramesStatusRspV6Pckg(*getFramesStatusRsp);

   480 	CleanupStack::PushL(getFramesStatusRspPckg);

   481 	

   482 	getFramesStatusRsp->SetPCmdNumber(DSATTSY_GET_FRAMES_STATUS);

   483 	getFramesStatusRsp->iGeneralResult=DSATTSY_PCMD_RESULT_SUCCESS;

   484 	getFramesStatusRsp->iInfoType=DSATTSY_PCMD_RSP_NO_INFO;	

   485 	getFramesStatusRsp->iFramesInformation.iFrameId=DSATTSY_FRAMES_INFORMATION_FRAMEID;

   486 	getFramesStatusRsp->iFramesInformation.iFrameList=DSATTSY_FRAMES_INFORMATION_FRAME_LIST;

   487 	

   488 	sat.NotifyGetFramesStatusPCmd(reqStatus, *getFramesStatusPckg);

   489 	User::WaitForRequest(reqStatus);

   490 	TEST(reqStatus.Int()==KErrNone);	

   491 

   492 	sat.TerminalRsp(reqStatus,RSat::EGetFramesStatus,*getFramesStatusRspPckg);

   493 	User::WaitForRequest(reqStatus);

   494 	TEST(reqStatus.Int()==KErrNone);

   495 	INFO_PRINTF2(_L("Test %d - RSat::TerminalRsp - Get Frames Status - passed"),iTestCount++);

   496 	

   497 	CleanupStack::PopAndDestroy(4);

   498 	

   499 	}

   500 	

   501 void CTestSatPCmds1f::Release6Test3L()

   502 	{	

   503 	/**

   504 	Testing the LocalInfo proactive command which has been updated 

   505 	to support the Release 6 Features of USIM ToolKit

   506 	@test TSAT304

   507 	@test TSAT307

   508 	*/

   509 	RSat::TLocalInfoV6* localInfoV6 = new (ELeave) RSat::TLocalInfoV6;

   510 	CleanupStack::PushL(localInfoV6);

   511 	

   512 	RSat::TLocalInfoV6Pckg* localInfoV6Pckg = new (ELeave) RSat::TLocalInfoV6Pckg(*localInfoV6);

   513 	CleanupStack::PushL(localInfoV6Pckg);

   514 

   515 

   516 	sat.NotifyLocalInfoPCmd(reqStatus, *localInfoV6Pckg);

   517 	User::WaitForRequest(reqStatus);

   518 	TEST(reqStatus.Int()==KErrNone);

   519 	TEST(localInfoV6->iUtranMeasurementQualifier=DSATTSYV6_LOCAL_INFOV6); 

   520 	TEST(localInfoV6->iInfoType = RSat::KProvideLocalInfoSearchMode); 

   521 	TEST(localInfoV6->iDevideId = RSat::KKeypad);

   522     INFO_PRINTF2(_L("Test %d - NotifyLocalInfoPCmd -LocalInfo proactive command- passed"),iTestCount++);

   523     

   524     /**

   525     Testing Cancel API for the LocalInfo proactive command

   526     @test TSAT306

   527     @test TSAT308

   528     */

   529     

   530     //Cancel	

   531 	sat.NotifyLocalInfoPCmd(reqStatus, *localInfoV6Pckg);

   532 	sat.CancelAsyncRequest(ESatNotifyLocalInfoPCmd);

   533 	User::WaitForRequest(reqStatus);

   534 	TEST(reqStatus.Int()==KErrCancel);

   535 	

   536 	CleanupStack::PopAndDestroy(2);

   537 		

   538 	/**

   539 	Testing the API GetMeSideSatProfile  which has been updated 

   540 	to support the Release 6 Features of USIM ToolKit

   541 	@test TSAT309

   542 	@test TSAT366

   543 	*/

   544 	RSat::TSatProfileV6* profileV6 = new (ELeave) RSat::TSatProfileV6;

   545 	CleanupStack::PushL(profileV6);

   546 	

   547 	RSat::TSatProfileV6Pckg* profileV6Pckg = new (ELeave) RSat::TSatProfileV6Pckg(*profileV6);

   548 	CleanupStack::PushL(profileV6Pckg);

   549 	

   550 	sat.GetMeSideSatProfile(reqStatus, *profileV6Pckg);

   551 	User::WaitForRequest(reqStatus);

   552 	TEST(reqStatus.Int()==KErrNone);

   553 

   554 		// Pre-version 5 parameters in SAT profile

   555 	TEST(profileV6->iSatProfileByte1==0x01);

   556 	TEST(profileV6->iSatProfileByte2==0x02);

   557 	TEST(profileV6->iSatProfileByte3==0x03);

   558 	TEST(profileV6->iSatProfileByte4==0x04);

   559 	TEST(profileV6->iSatProfileByte5==0x05);

   560 	TEST(profileV6->iSatProfileByte6==0x06);

   561 	TEST(profileV6->iSatProfileByte7==0x07);

   562 	TEST(profileV6->iSatProfileByte8==0x08);

   563 	TEST(profileV6->iSatProfileByte9==0x09);

   564 	TEST(profileV6->iSatProfileByte10==0x0A);

   565 	TEST(profileV6->iSatProfileByte11==0x0B);

   566 	TEST(profileV6->iSatProfileByte12==0x0C);

   567 	TEST(profileV6->iSatProfileByte13==0x0D);

   568 	TEST(profileV6->iSatProfileByte14==0x0E);

   569 	TEST(profileV6->iSatProfileByte15==0x0F);

   570 	TEST(profileV6->iSatProfileByte16==0x10);

   571 	TEST(profileV6->iSatProfileByte17==0x20);

   572 	TEST(profileV6->iSatProfileByte18==0x30);

   573 	TEST(profileV6->iNumOfChannels==DSATTSY_NUMBER_OF_CHANNELS);

   574 	TEST(profileV6->iScreenHeight==DSATTSY_SCREEN_HEIGHT);

   575 	TEST(profileV6->iScreenWidth==DSATTSY_SCREEN_WIDTH);

   576 	TEST(profileV6->iTiaEiaProtoVersion==DSATTSY_PROTO_VERSION);

   577 	TEST(profileV6->iWidthReduction==DSATTSY_WIDTH_REDUCTION);

   578 	// Version 5 parameters in profile

   579 	// (test also that the TSatProfileByte28 and TSatProfileByte29

   580 	// have been defined correctly as each should set a different bit).

   581 	TEST(profileV6->iSatProfileByte28==

   582 			(RSat::KCapsTextAttributeAlignmentLeft | RSat::KCapsTextAttributeAlignmentCentre |

   583 			 RSat::KCapsTextAttributeAlignmentRight | RSat::KCapsTextAttributeFontSizeNormal |

   584 			 RSat::KCapsTextAttributeFontSizeLarge | RSat::KCapsTextAttributeFontSizeSmall)); // 0x3F

   585 	TEST(profileV6->iSatProfileByte29==(RSat::KCapsTextAttributeStyleNormal |

   586 									 RSat::KCapsTextAttributeStyleBold |

   587 									 RSat::KCapsTextAttributeStyleItalic |

   588 									 RSat::KCapsTextAttributeStyleUnderline |

   589 									 RSat::KCapsTextAttributeStyleStrikethrough |

   590 									 RSat::KCapsTextAttributeStyleForeground |

   591 									 RSat::KCapsTextAttributeStyleBackground)); // 0x7F

   592 	TEST(profileV6->iSatProfileByte21==

   593 			(RSat::KCapsWML | RSat::KCapsXHTML |

   594 			 RSat::KCapsHTML | RSat::KCapsCHTML)); // 0x0F

   595 	TEST(profileV6->iSatProfileByte22==(RSat::KCapsProvideLocalInfoUTRAN | RSat::KCapsProvideLocalInfoBatteryState |

   596 			 RSat::KCapsPlayThemedAndMelodyTone | RSat::KCapsSetUpCallMultimediaCall |

   597 			 RSat::KCapsRefreshGBA	| RSat::KCapsRetrieveMultimediaMessage |

   598 			 RSat::KCapsSubmitMultimediaMessage | RSat::KCapsDisplayMultimediaMesage)); // 0xFF

   599 	TEST(profileV6->iSatProfileByte23==

   600 			(RSat::KCapsSetFrames  | RSat::KCapsGetFramesStatus  |

   601 			 RSat::KCapsMmsNotificationDownload | RSat::KCapsProvideLocalInfoMEID |

   602 			 RSat::KCapsProvideLocalInfoNmrUTRAN | RSat::KCapsUssdDataDownload));  //0xE7

   603 	TEST(profileV6->iSatProfileByte24==(RSat::KCapsMaxNumFramesBit1 | RSat::KCapsMaxNumFramesBit2 |

   604 		 RSat::KCapsMaxNumFramesBit3 | RSat::KCapsMaxNumFramesBit4)); // 0x0F								 

   605 	TEST(profileV6->iSatProfileByte25==(RSat::KCapsBrowsingStatusEvent | RSat::KCapsMmsTransferStatusEvent |

   606 	   	RSat::KCapsFrameParametersChangeEvent)); // 0x07

   607 	INFO_PRINTF2(_L("Test %d - RSat::GetMeSideSatProfile with RSat::TSatProfileV6 passed"),iTestCount++);

   608     

   609     /**

   610     Testing Cancel API for the GetMeSideProfile  command

   611     @test TSAT310

   612     @test TSAT367

   613     */

   614     

   615     //Cancel	

   616 	sat.GetMeSideSatProfile(reqStatus, *profileV6Pckg);

   617 	sat.CancelAsyncRequest(ESatGetMeSideSatProfile);

   618 	User::WaitForRequest(reqStatus);

   619 	TEST(reqStatus.Int()==KErrCancel);

   620 

   621 	/**

   622 	Testing the API GetMeSideSatProfile  which has been updated 

   623 	to support the Release 6 Features of USIM ToolKit

   624 	@test TSAT368

   625 	*/

   626 

   627 	TEST(sat.ClientSatProfileIndication(*profileV6Pckg)==KErrNone);

   628 	INFO_PRINTF2(_L("Test %d - RSat::ClientSatProfileIndication RSat::TSatProfileV6 passed"),iTestCount++);

   629 	CleanupStack::PopAndDestroy(2);

   630 	

   631 	}

   632 	

   633 void CTestSatPCmds1f::Release6Test4L()

   634 	{

   635 	/**

   636 	Testing Send Ussd Proactive command which has been updated

   637     as part of the Release 6 Features of USIM Application ToolKit

   638 	@test TSAT311

   639 	@test TSAT371

   640 	*/

   641 	RSat::TSendUssdV6* sendUssd = new (ELeave) RSat::TSendUssdV6;

   642 	CleanupStack::PushL(sendUssd);

   643 	

   644 	RSat::TSendUssdV6Pckg* sendUssdPckg = new (ELeave) RSat::TSendUssdV6Pckg(*sendUssd);

   645 	CleanupStack::PushL(sendUssdPckg);

   646 	

   647 	sat.NotifySendUssdPCmd(reqStatus, *sendUssdPckg);

   648 	User::WaitForRequest(reqStatus);

   649 	TEST(reqStatus.Int()==KErrNone);

   650 	TEST(sendUssd->iAlphaId.iAlphaId		== DSATTSY_ALPHA_ID1);

   651 	TEST(sendUssd->iAlphaId.iStatus		== DSATTSY_ALPHA_ID1_STATUS);

   652 	TEST(sendUssd->iUssdString.iDcs		== DSATTSY_DCS);

   653 	TEST(sendUssd->iUssdString.iUssdString == DSATTSY_USSD_STRING);

   654 	TEST(sendUssd->iIconId.iIdentifier		== DSATTSY_ICON_ID1);

   655 	TEST(sendUssd->iIconId.iQualifier		== DSATTSY_ICON_QUALIFIER1);

   656 

   657   	RSat::TTextAttribute textAttribute;

   658 	textAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS;

   659 	const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA;

   660 	textAttribute.iTextAttributeData.Append(textAttributeData, DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH);

   661 		

   662 	TEST(sendUssd->iTextAttribute.iStatus == textAttribute.iStatus);

   663 	TEST(sendUssd->iTextAttribute.iTextAttributeData == textAttribute.iTextAttributeData);

   664 	

   665     INFO_PRINTF2(_L("Test %d - UssdDataDownload - Ussd Data Download command- passed"),iTestCount++);

   666     

   667     /**

   668     Testing Cancel API for the Send Ussd Proactive command

   669     @test TSAT312

   670     @test TSAT372

   671     */

   672     

   673     //Cancel	

   674 	sat.NotifySendUssdPCmd(reqStatus, *sendUssdPckg);

   675 	sat.CancelAsyncRequest(ESatNotifySendUssdPCmd);

   676 	User::WaitForRequest(reqStatus);

   677 	TEST(reqStatus.Int()==KErrCancel);

   678 	

   679 	CleanupStack::PopAndDestroy(2);

   680 		

   681 	/**

   682 	Testing Play Tone Proactive command which has been updated

   683     as part of the Release 6 Features of USIM Application ToolKit

   684 	@test TSAT320

   685 	@test TSAT338

   686 	*/

   687 	RSat::TPlayToneV6* playTone = new (ELeave) RSat::TPlayToneV6;

   688 	CleanupStack::PushL(playTone);

   689 	

   690 	RSat::TPlayToneV6Pckg* playTonePckg = new (ELeave) RSat::TPlayToneV6Pckg(*playTone);

   691 	CleanupStack::PushL(playTonePckg);

   692 		

   693 	sat.NotifyPlayTonePCmd(reqStatus, *playTonePckg);

   694 	User::WaitForRequest(reqStatus);

   695 	TEST(reqStatus.Int()==KErrNone);

   696 	TEST(playTone->iAlphaId.iAlphaId		== DSATTSY_ALPHA_ID1);

   697 	TEST(playTone->iAlphaId.iStatus		== DSATTSY_ALPHA_ID1_STATUS);

   698 	TEST(playTone->iTone		== DSATTSY_TONEV6);

   699 	TEST(playTone->iDuration.iTimeUnit == DSATTSY_TIME_UNIT);

   700 	TEST(playTone->iDuration.iNumOfUnits	==DSATTSY_NUM_OF_UNITS);

   701 	TEST(playTone->iIconId.iIdentifier		== DSATTSY_ICON_ID1);

   702 	TEST(playTone->iIconId.iQualifier		== DSATTSY_ICON_QUALIFIER1);

   703 	TEST(playTone->iTextAttribute.iStatus == textAttribute.iStatus);

   704 	TEST(playTone->iTextAttribute.iTextAttributeData == textAttribute.iTextAttributeData);

   705 	TEST(playTone->iFrameId==DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1);

   706 	

   707     INFO_PRINTF2(_L("Test %d - NotifyPlayTone - Play Tone command- passed"),iTestCount++);

   708     

   709     /**

   710     Testing Cancel API for the Play Tone command

   711     @test TSAT321

   712     @test TSAT339

   713     */

   714     

   715     //Cancel	

   716 	sat.NotifyPlayTonePCmd(reqStatus, *playTonePckg);

   717 	sat.CancelAsyncRequest(ESatNotifyPlayTonePCmd);

   718 	User::WaitForRequest(reqStatus);

   719 	TEST(reqStatus.Int()==KErrCancel);

   720 	

   721 	CleanupStack::PopAndDestroy(2);

   722 		

   723 	/**

   724 	Testing SetUpEventList Proactive command which has been updated

   725     as part of the Release 6 Features of USIM Application ToolKit

   726 	@test TSAT322

   727 	*/

   728 	RSat::TSetUpEventListV1* setUpEventList = new (ELeave) RSat::TSetUpEventListV1;

   729 	CleanupStack::PushL(setUpEventList);

   730 	

   731 	RSat::TSetUpEventListV1Pckg* setUpEventListPckg = new (ELeave) RSat::TSetUpEventListV1Pckg(*setUpEventList);

   732 	CleanupStack::PushL(setUpEventListPckg);

   733 

   734 	sat.NotifySetUpEventListPCmd(reqStatus, *setUpEventListPckg);

   735 	User::WaitForRequest(reqStatus);

   736 	TEST(reqStatus.Int()==KErrNone);

   737 	

   738     INFO_PRINTF2(_L("Test %d - SetUpEventList - SetUp EventList command- passed"),iTestCount++);

   739     

   740     /**

   741     Testing Cancel API for the SetUpEventList Proactive command

   742     @test TSAT323

   743     */

   744     

   745     //Cancel	

   746 	sat.NotifySetUpEventListPCmd(reqStatus, *setUpEventListPckg);

   747 	sat.CancelAsyncRequest(ESatNotifySetUpEventListPCmd);

   748 	User::WaitForRequest(reqStatus);

   749 	TEST(reqStatus.Int()==KErrCancel);

   750 	

   751 	CleanupStack::PopAndDestroy(2);

   752 			

   753 	/**

   754 	Testing LaunchBrowser Proactive command which has been updated

   755     as part of the Release 6 Features of USIM Application ToolKit

   756 	@test TSAT330

   757 	@test TSAT368

   758 	*/

   759 	RSat::TLaunchBrowserV6* launchBrowser = new (ELeave) RSat::TLaunchBrowserV6;

   760 	CleanupStack::PushL(launchBrowser);

   761 	

   762 	RSat::TLaunchBrowserV6Pckg* launchBrowserPckg = new (ELeave) RSat::TLaunchBrowserV6Pckg(*launchBrowser);

   763 	CleanupStack::PushL(launchBrowserPckg);

   764 	

   765 	sat.NotifyLaunchBrowserPCmd(reqStatus, *launchBrowserPckg);

   766 	User::WaitForRequest(reqStatus);

   767 	TEST(reqStatus.Int()==KErrNone);

   768 	TEST(launchBrowser->iBrowserSel		== DSATTSY_BROWSER_SELECTION_MODE);

   769 	TEST(launchBrowser->iBrowserId		== DSATTSY_BROWSER_ID);

   770 	TEST(launchBrowser->iUrl				== DSATTSY_URL);

   771 	TEST(launchBrowser->iBearerList		== DSATTSY_BEARER_LIST);

   772 	TEST(launchBrowser->iText			== DSATTSY_PROXY_NAME);

   773 	TEST(launchBrowser->iAlphaId.iStatus	== DSATTSY_ALPHA_ID1_STATUS);

   774 	TEST(launchBrowser->iAlphaId.iAlphaId	== DSATTSY_ALPHA_ID1);

   775 	TEST(launchBrowser->iIconId.iIdentifier	== DSATTSY_ICON_ID1);

   776 	TEST(launchBrowser->iIconId.iQualifier  == DSATTSY_ICON_QUALIFIER1);

   777 	TEST(launchBrowser->iTextAttribute.iStatus == textAttribute.iStatus);

   778 	TEST(launchBrowser->iTextAttribute.iTextAttributeData == textAttribute.iTextAttributeData);

   779 	TEST(launchBrowser->iFrameId==DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1);

   780 	

   781     INFO_PRINTF2(_L("Test %d - NotifyLaunchBrowserPCmd - Launch Browser command- passed"),iTestCount++);

   782     

   783     /**

   784     Testing Cancel API for the LauchBrowser Proactive command

   785     @test TSAT331

   786    	@test TSAT369

   787     */

   788     

   789     //Cancel	

   790 	sat.NotifyLaunchBrowserPCmd(reqStatus, *launchBrowserPckg);

   791 	sat.CancelAsyncRequest(ESatNotifyLaunchBrowserPCmd);

   792 	User::WaitForRequest(reqStatus);

   793 	TEST(reqStatus.Int()==KErrCancel);

   794 	

   795 	CleanupStack::PopAndDestroy(2);

   796 	

   797 	/**

   798 	Testing DisplayText Proactive command which has been updated

   799     as part of the Release 6 Features of USIM Application ToolKit

   800 	@test TSAT332

   801 	*/

   802 	RSat::TDisplayTextV6* displayText = new (ELeave) RSat::TDisplayTextV6;

   803 	CleanupStack::PushL(displayText);

   804 	

   805 	RSat::TDisplayTextV6Pckg* displayTextPckg = new (ELeave) RSat::TDisplayTextV6Pckg(*displayText);

   806 	CleanupStack::PushL(displayTextPckg);

   807 	

   808 

   809 	sat.NotifyDisplayTextPCmd(reqStatus, *displayTextPckg);

   810 	User::WaitForRequest(reqStatus);

   811 	TEST(reqStatus.Int()==KErrNone);

   812 	TEST(displayText->iPriority				==DSATTSY_TEXT_PRIORITY);

   813 	TEST(displayText->iClearScreenTrigger	==DSATTSY_CLEAR_SCREEN_TRIGGER);

   814 	TEST(displayText->iText					==DSATTSY_TEXT_TO_DISPLAY);

   815 	TEST(displayText->iIconId.iIdentifier	==DSATTSY_ICON_ID1);

   816 	TEST(displayText->iIconId.iQualifier	==DSATTSY_ICON_QUALIFIER1);

   817 	TEST(displayText->iImmediateRsp			==DSATTSY_IMMEDIATE_RSP);

   818 	TEST(displayText->iDuration.iTimeUnit ==DSATTSY_TIME_UNIT);

   819 	TEST(displayText->iDuration.iNumOfUnits ==DSATTSY_NUM_OF_UNITS);

   820     TEST(displayText->iTextAttribute.iStatus == textAttribute.iStatus);

   821     TEST(displayText->iTextAttribute.iTextAttributeData == textAttribute.iTextAttributeData);

   822 	TEST(displayText->iFrameId==DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1);

   823 	

   824     INFO_PRINTF2(_L("Test %d - NotifyDisplayTextPCmd - DisplayText command- passed"),iTestCount++);

   825     

   826     /**

   827     Testing Cancel API for the DisplayText Proactive command

   828     @test TSAT333

   829     */

   830     

   831     //Cancel	

   832 	sat.NotifyDisplayTextPCmd(reqStatus, *displayTextPckg);

   833 	sat.CancelAsyncRequest(ESatNotifyDisplayTextPCmd);

   834 	User::WaitForRequest(reqStatus);

   835 	TEST(reqStatus.Int()==KErrCancel);

   836 	

   837 	CleanupStack::PopAndDestroy(2);

   838 	

   839 	}

   840 	

   841 void CTestSatPCmds1f::Release6Test5L()

   842 	{

   843 	/**

   844 	Testing GetInkey Proactive command which has been updated

   845     as part of the Release 6 Features of USIM Application ToolKit

   846 	@test TSAT334

   847 	*/

   848 	RSat::TGetInkeyV6* getInkey = new (ELeave) RSat::TGetInkeyV6;

   849 	CleanupStack::PushL(getInkey);

   850 	

   851 	RSat::TGetInkeyV6Pckg* getInkeyPckg = new (ELeave) RSat::TGetInkeyV6Pckg(*getInkey);

   852 	CleanupStack::PushL(getInkeyPckg);

   853 

   854 	sat.NotifyGetInkeyPCmd(reqStatus, *getInkeyPckg);

   855 	User::WaitForRequest(reqStatus);

   856 	TEST(reqStatus.Int()==KErrNone);

   857 	TEST(getInkey->iRspFormat			==DSATTSY_USER_RSP_FORMAT);

   858 	TEST(getInkey->iText				==DSATTSY_TEXT_TO_DISPLAY);

   859 	TEST(getInkey->iIconId.iIdentifier	==DSATTSY_ICON_ID1);

   860 	TEST(getInkey->iIconId.iQualifier	==DSATTSY_ICON_QUALIFIER1);

   861 	TEST(getInkey->iHelp				==DSATTSY_HELP);

   862 	TEST(getInkey->iDuration.iTimeUnit ==DSATTSY_TIME_UNIT);

   863 	TEST(getInkey->iDuration.iNumOfUnits==DSATTSY_NUM_OF_UNITS);

   864 	TEST(getInkey->iMode ==DSATTSY_GET_INKEY_RSP_MODE);

   865     

   866   	RSat::TTextAttribute textAttribute;

   867 	textAttribute.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS;

   868 	const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA;

   869 	textAttribute.iTextAttributeData.Append(textAttributeData, DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH);    

   870     

   871     TEST(getInkey->iTextAttribute.iStatus == textAttribute.iStatus);   

   872     TEST(getInkey->iTextAttribute.iTextAttributeData == textAttribute.iTextAttributeData);

   873 	TEST(getInkey->iFrameId==DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1);

   874 	

   875     INFO_PRINTF2(_L("Test %d - NotifyGetInkeyPCmd - GetInkey command- passed"),iTestCount++);

   876     

   877     /**

   878     Testing Cancel API for the GetInkey Proactive command

   879     @test TSAT335

   880     */

   881     

   882     //Cancel	

   883 	sat.NotifyGetInkeyPCmd(reqStatus, *getInkeyPckg);

   884 	sat.CancelAsyncRequest(ESatNotifyGetInkeyPCmd);

   885 	User::WaitForRequest(reqStatus);

   886 	TEST(reqStatus.Int()==KErrCancel);

   887 	

   888 	CleanupStack::PopAndDestroy(2);

   889 	

   890 	/**

   891 	Testing GetInput Proactive command which has been updated

   892     as part of the Release 6 Features of USIM Application ToolKit

   893 	@test TSAT336

   894 	*/

   895 	RSat::TGetInputV6* getInput = new (ELeave) RSat::TGetInputV6;

   896 	CleanupStack::PushL(getInput);

   897 	

   898 	RSat::TGetInputV6Pckg* getInputPckg = new (ELeave) RSat::TGetInputV6Pckg(*getInput);

   899 	CleanupStack::PushL(getInputPckg);

   900 	

   901 	sat.NotifyGetInputPCmd(reqStatus, *getInputPckg);

   902 	User::WaitForRequest(reqStatus);

   903 	TEST(reqStatus.Int()==KErrNone);

   904 	TEST(getInput->iInputDisplayOption		== DSATTSY_INPUT_DISPLAY_OPTION);

   905 	TEST(getInput->iRspFormat				== DSATTSY_GET_INPUT_RSP_FORMAT);

   906 	TEST(getInput->iText					== DSATTSY_TEXT_TO_DISPLAY);

   907 	TEST(getInput->iRspLength.iMinRspLength	== DSATTSY_MIN_RSP_LENGTH);

   908 	TEST(getInput->iRspLength.iMaxRspLength	== DSATTSY_MAX_RSP_LENGTH);

   909 	TEST(getInput->iDefaultText				== DSATTSY_DEFAULT_TEXT);

   910 	TEST(getInput->iIconId.iIdentifier		== DSATTSY_ICON_ID1);

   911 	TEST(getInput->iIconId.iQualifier		== DSATTSY_ICON_QUALIFIER1);

   912 	TEST(getInput->iHelp					== DSATTSY_HELP);

   913     TEST(getInput->iTextAttribute.iStatus == textAttribute.iStatus);     

   914     TEST(getInput->iTextAttribute.iTextAttributeData == textAttribute.iTextAttributeData);

   915 	TEST(getInput->iFrameId==DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1);

   916 	

   917     INFO_PRINTF2(_L("Test %d - NotifyGetInputPCmd - GetInput command- passed"),iTestCount++);

   918     

   919     /**

   920     Testing Cancel API for the DisplayText Proactive command

   921     @test TSAT337

   922     */

   923     

   924     //Cancel	

   925 	sat.NotifyGetInputPCmd(reqStatus, *getInputPckg);

   926 	sat.CancelAsyncRequest(ESatNotifyGetInputPCmd);

   927 	User::WaitForRequest(reqStatus);

   928 	TEST(reqStatus.Int()==KErrCancel);

   929 	

   930 	CleanupStack::PopAndDestroy(2);

   931 		

   932 	/**

   933 	Testing SelectItem Proactive command which has been updated

   934     as part of the Release 6 Features of USIM Application ToolKit

   935 	@test TSAT340

   936 	*/

   937 	RSat::TSelectItemV6* selectItem = new (ELeave) RSat::TSelectItemV6;

   938 	CleanupStack::PushL(selectItem);

   939 	

   940 	RSat::TSelectItemV6Pckg* selectItemPckg = new (ELeave) RSat::TSelectItemV6Pckg(*selectItem);

   941 	CleanupStack::PushL(selectItemPckg);

   942 	

   943 	sat.NotifySelectItemPCmd(reqStatus, *selectItemPckg);

   944 	User::WaitForRequest(reqStatus);

   945 	TEST(reqStatus.Int()==KErrNone);

   946 	TEST(selectItem->iPresentationType	==DSATTSY_PRESENTATION_TYPE);

   947 	TEST(selectItem->iHelp				==DSATTSY_HELP);

   948 	TEST(selectItem->iAlphaId.iAlphaId	==DSATTSY_ALPHA_ID1);

   949 	TEST(selectItem->iAlphaId.iStatus	==DSATTSY_ALPHA_ID1_STATUS);

   950 	TEST(selectItem->iDefaultItemId		==DSATTSY_DEFAULT_ITEM);

   951 	TEST(selectItem->iIconId.iIdentifier ==DSATTSY_ICON_ID1);

   952 	TEST(selectItem->iIconId.iQualifier	==DSATTSY_ICON_QUALIFIER1);

   953 	TEST(selectItem->iIconListQualifier	==DSATTSY_ICON_QUALIFIER2);

   954 	TEST(selectItem->iPreference=DSATTSY_SELECTION_PREFERENCE);	

   955     TEST(selectItem->iTextAttribute.iStatus == textAttribute.iStatus);     

   956     TEST(selectItem->iTextAttribute.iTextAttributeData == textAttribute.iTextAttributeData);

   957 	TEST(selectItem->iFrameId==DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1);

   958 	

   959     INFO_PRINTF2(_L("Test %d - SelectItemPCmd - SelectItem command- passed"),iTestCount++);

   960     

   961     /**

   962     Testing Cancel API for the SelectItem Proactive command

   963     @test TSAT341

   964     */

   965     

   966     //Cancel	

   967 	sat.NotifySelectItemPCmd(reqStatus, *selectItemPckg);

   968 	sat.CancelAsyncRequest(ESatNotifySelectItemPCmd);

   969 	User::WaitForRequest(reqStatus);

   970 	TEST(reqStatus.Int()==KErrCancel);

   971 	INFO_PRINTF2(_L("Test %d - SelectItemPCmd - SelectItem cancel command- passed"),iTestCount++);

   972 	

   973 	CleanupStack::PopAndDestroy(2);

   974 	

   975 	/**

   976 	Testing SendSm Proactive command which has been updated

   977     as part of the Release 6 Features of USIM Application ToolKit

   978 	@test TSAT342

   979 	*/

   980 	RSat::TSendSmV6* sendSm = new (ELeave) RSat::TSendSmV6;

   981 	CleanupStack::PushL(sendSm);

   982 	

   983 	RSat::TSendSmV6Pckg* sendSmPckg = new (ELeave) RSat::TSendSmV6Pckg(*sendSm);

   984 	CleanupStack::PushL(sendSmPckg);

   985 

   986 	sat.NotifySendSmPCmd(reqStatus, *sendSmPckg);

   987 	User::WaitForRequest(reqStatus);

   988 	TEST(reqStatus.Int()==KErrNone);

   989 	TEST(sendSm->iAlphaId.iAlphaId	==DSATTSY_ALPHA_ID1);

   990 	TEST(sendSm->iAlphaId.iStatus	==DSATTSY_ALPHA_ID1_STATUS);

   991 	TEST(sendSm->iAddress.iTypeOfNumber	==DSATTSY_TON);

   992 	TEST(sendSm->iAddress.iNumberPlan	==DSATTSY_NPI);

   993 	TEST(sendSm->iAddress.iTelNumber	==DSATTSY_TEL_NUMBER);

   994 	TEST(sendSm->iSmsTpdu				==DSATTSY_SMS_TPDU); 

   995 	TEST(sendSm->iIconId.iIdentifier	==DSATTSY_ICON_ID1);

   996 	TEST(sendSm->iIconId.iQualifier		==DSATTSY_ICON_QUALIFIER1);	

   997     TEST(sendSm->iTextAttribute.iStatus == textAttribute.iStatus);     

   998     TEST(sendSm->iTextAttribute.iTextAttributeData == textAttribute.iTextAttributeData);

   999 	TEST(sendSm->iFrameId==DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1);

  1000 	

  1001     INFO_PRINTF2(_L("Test %d - SendSmPCmd - SendSm command- passed"),iTestCount++);

  1002     

  1003     /**

  1004     Testing Cancel API for the SendSm Proactive command

  1005     @test TSAT343

  1006     */

  1007     

  1008     //Cancel	

  1009 	sat.NotifySendSmPCmd(reqStatus, *sendSmPckg);

  1010 	sat.CancelAsyncRequest(ESatNotifySendSmPCmd);

  1011 	User::WaitForRequest(reqStatus);

  1012 	TEST(reqStatus.Int()==KErrCancel);

  1013 	

  1014 	CleanupStack::PopAndDestroy(2);

  1015 	

  1016 	/**

  1017 	Testing SetUpCall Proactive command which has been updated

  1018     as part of the Release 6 Features of USIM Application ToolKit

  1019 	@test TSAT344

  1020 	*/

  1021 	RSat::TSetUpCallV6* setUpCall = new (ELeave) RSat::TSetUpCallV6;

  1022 	CleanupStack::PushL(setUpCall);

  1023 	

  1024 	RSat::TSetUpCallV6Pckg* setUpCallPckg = new (ELeave) RSat::TSetUpCallV6Pckg(*setUpCall);

  1025 	CleanupStack::PushL(setUpCallPckg);

  1026 

  1027 	sat.NotifySetUpCallPCmd(reqStatus, *setUpCallPckg);

  1028 	User::WaitForRequest(reqStatus);

  1029 	TEST(reqStatus.Int()==KErrNone);

  1030 	TEST(setUpCall->iType								==DSATTSY_SET_UP_CALL_TYPE);

  1031 	TEST(setUpCall->iAlphaIdConfirmationPhase.iAlphaId	==DSATTSY_ALPHA_ID1);

  1032 	TEST(setUpCall->iAlphaIdConfirmationPhase.iStatus	==DSATTSY_ALPHA_ID1_STATUS);

  1033 	TEST(setUpCall->iIconIdConfirmationPhase.iIdentifier==DSATTSY_ICON_ID1);

  1034 	TEST(setUpCall->iIconIdConfirmationPhase.iQualifier	==DSATTSY_ICON_QUALIFIER1);

  1035 	TEST(setUpCall->iAddress.iTypeOfNumber				==DSATTSY_TON);

  1036 	TEST(setUpCall->iAddress.iNumberPlan				==DSATTSY_NPI);

  1037 	TEST(setUpCall->iAddress.iTelNumber					==DSATTSY_TEL_NUMBER);

  1038 	TEST(setUpCall->iCapabilityConfigParams			==DSATTSY_CCP1);

  1039 	TEST(setUpCall->iSubAddress							==DSATTSY_SUBADDRESS);

  1040 	TEST(setUpCall->iDuration.iTimeUnit					==DSATTSY_TIME_UNIT);

  1041 	TEST(setUpCall->iDuration.iNumOfUnits				==DSATTSY_NUM_OF_UNITS);

  1042 	TEST(setUpCall->iAlphaIdCallSetUpPhase.iAlphaId		==DSATTSY_ALPHA_ID2);		

  1043 	TEST(setUpCall->iAlphaIdCallSetUpPhase.iStatus		==DSATTSY_ALPHA_ID2_STATUS);		

  1044 	TEST(setUpCall->iIconIdCallSetUpPhase.iIdentifier ==DSATTSY_ICON_ID2);

  1045 	TEST(setUpCall->iIconIdCallSetUpPhase.iQualifier	==DSATTSY_ICON_QUALIFIER2);

  1046 	TEST(setUpCall->iFrameId==DSATTSYV6_DEFAULT_FRAME_IDENTIFIER1);

  1047 	

  1048     INFO_PRINTF2(_L("Test %d - SetUpCall - SetUp Call command- passed"),iTestCount++);

  1049     

  1050     /**

  1051     Testing Cancel API for the SetUpCall Proactive command

  1052     @test TSAT345

  1053     */

  1054     

  1055     //Cancel	

  1056 	sat.NotifySetUpCallPCmd(reqStatus, *setUpCallPckg);

  1057 	sat.CancelAsyncRequest(ESatNotifySetUpCallPCmd);

  1058 	User::WaitForRequest(reqStatus);

  1059 	TEST(reqStatus.Int()==KErrCancel);

  1060 

  1061 	CleanupStack::PopAndDestroy(2);

  1062 	

  1063 	/**

  1064 	Testing SetUpIdleModeText Proactive command which has been updated

  1065     as part of the Release 6 Features of USIM Application ToolKit

  1066 	@test TSAT346

  1067 	@test TSAT347

  1068 	*/

  1069 	RSat::TSetUpIdleModeTextV6* setUpIdleModeText = new (ELeave) RSat::TSetUpIdleModeTextV6;

  1070 	CleanupStack::PushL(setUpIdleModeText);

  1071 	

  1072 	RSat::TSetUpIdleModeTextV6Pckg* setUpIdleModeTextPckg = new (ELeave) RSat::TSetUpIdleModeTextV6Pckg(*setUpIdleModeText);

  1073 	CleanupStack::PushL(setUpIdleModeTextPckg);

  1074 

  1075 	TEST(setUpIdleModeText->ExtensionId() == RSat::KSatV6);

  1076 	TEST(setUpIdleModeText->iTextAttribute.iStatus == RSat::ETextAttributeNotSet);

  1077 

  1078 	sat.NotifySetUpIdleModeTextPCmd(reqStatus,*setUpIdleModeTextPckg);

  1079 	User::WaitForRequest(reqStatus);

  1080 	TEST(reqStatus.Int()==KErrNone);

  1081 

  1082 	TEST(setUpIdleModeText->PCmdNumber()==DSATTSY_SET_UP_IDLE_MODE_TEXT_NUMBER);

  1083 

  1084    	TEST(setUpIdleModeText->iType==DSATTSY_IDLE_MODE_TXT_TYPE);

  1085  	TEST(setUpIdleModeText->iText==DSATTSY_IDLE_MODE_TEXT);

  1086    	TEST(setUpIdleModeText->iIconId.iIdentifier==DSATTSY_ICON_ID1);

  1087    	TEST(setUpIdleModeText->iIconId.iQualifier==DSATTSY_ICON_QUALIFIER1);

  1088    	TEST(setUpIdleModeText->iCodingScheme==DSATTSY_TEXT_ENCODING_SCHEME);

  1089 

  1090 	TEST(setUpIdleModeText->iTextAttribute.iStatus == textAttribute.iStatus);

  1091 	TEST(setUpIdleModeText->iTextAttribute.iTextAttributeData == textAttribute.iTextAttributeData);

  1092 

  1093  	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpIdleModeText (Unicode) with RSat::TSetUpIdleModeTextV6 passed"),iTestCount++);

  1094 

  1095  	// Set Up Idle Mode Text Cancel

  1096  	sat.NotifySetUpIdleModeTextPCmd(reqStatus,*setUpIdleModeTextPckg);

  1097  	sat.CancelAsyncRequest(ESatNotifySetUpIdleModeTextPCmd);

  1098 

  1099  	User::WaitForRequest(reqStatus);

  1100  	TEST(reqStatus.Int()==KErrCancel);

  1101  	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpIdleModeTextPCmdCancel with RSat::TSetUpIdleModeTextV6 passed"),iTestCount++);

  1102 

  1103  	// Issue another request. The DTSY will set the idle text mode to an 8-bit string

  1104  	sat.NotifySetUpIdleModeTextPCmd(reqStatus,*setUpIdleModeTextPckg);

  1105  	User::WaitForRequest(reqStatus);

  1106  	TEST(reqStatus.Int()==KErrNone);

  1107 

  1108  	TEST(setUpIdleModeText->PCmdNumber()==DSATTSY_SET_UP_IDLE_MODE_TEXT_NUMBER);

  1109 

  1110  	TPtrC8 textIdleMode8(DSATTSY_IDLE_MODE_TEXT_8BIT);

  1111    	TEST(setUpIdleModeText->iType==DSATTSY_IDLE_MODE_TXT_TYPE);

  1112    	TBuf8<276> text8;

  1113    	CnvUtfConverter::ConvertFromUnicodeToUtf8(text8,setUpIdleModeText->iText);

  1114  	TEST(text8==DSATTSY_IDLE_MODE_TEXT_8BIT);

  1115    	TEST(setUpIdleModeText->iIconId.iIdentifier==DSATTSY_ICON_ID1);

  1116    	TEST(setUpIdleModeText->iIconId.iQualifier==DSATTSY_ICON_QUALIFIER1);

  1117    	TEST(setUpIdleModeText->iCodingScheme==DSATTSY_TEXT_ENCODING_SCHEME_8);

  1118 

  1119 	TEST(setUpIdleModeText->iTextAttribute.iStatus == textAttribute.iStatus);

  1120 	TEST(setUpIdleModeText->iTextAttribute.iTextAttributeData == textAttribute.iTextAttributeData);

  1121 

  1122 	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpIdleModeText (8-bit) with RSat::TSetUpIdleModeTextV6 passed"),iTestCount++);

  1123 

  1124 	// Set Up Idle Mode Text Cancel

  1125 	sat.NotifySetUpIdleModeTextPCmd(reqStatus,*setUpIdleModeTextPckg);

  1126 	sat.CancelAsyncRequest(ESatNotifySetUpIdleModeTextPCmd);

  1127 

  1128 	User::WaitForRequest(reqStatus);

  1129 	TEST(reqStatus.Int()==KErrCancel);

  1130 	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpIdleModeTextPCmdCancel with RSat::TSetUpIdleModeTextV6 passed"),iTestCount++);

  1131 

  1132     INFO_PRINTF2(_L("Test %d - SetUpCall - SetUp Call command- passed"),iTestCount++);  

  1133 	

  1134 	CleanupStack::PopAndDestroy(2);