1 // Copyright (c) 2005-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 //

    15 

    16 #include "SimConstants.h"

    17 #include "Te_SimSatTest.h"

    18 

    19 CSimSatTest::CSimSatTest() 

    20 	{ 

    21 	SetTestStepName(_L("SatTest"));

    22 	}

    23 

    24 TVerdict CSimSatTest::doTestStepL()

    25 	{

    26 	INFO_PRINTF1(_L("BeginSatTest"));

    27 

    28  	CreateConfigFileL(_L("c:\\config4.txt")); 

    29  	SetTestNumberL(0);

    30 

    31 	TInt ret = iPhone.Open(iTelServer,KPhoneName); 

    32 	INFO_PRINTF2(_L("Result: %d"),ret); 

    33 	TESTL(ret == KErrNone); 

    34 	INFO_PRINTF1(_L("Opened phone object"));

    35 	TESTL(iSat.Open(iPhone)==KErrNone);

    36 	INFO_PRINTF1(_L("Opened Sat object"));

    37 

    38 	// local variables used throughout the sat tests

    39 	TRequestStatus reqStatusPCmd;

    40 	TRequestStatus reqStatusRequired;

    41 	TRequestStatus reqStatusAllowed;

    42 	

    43 

    44 	// Refresh

    45 	RSat::TRefreshV1 refresh;

    46 	RSat::TRefreshV1Pckg refreshPckg(refresh);

    47 	

    48 	iSat.NotifyRefreshPCmd(reqStatusPCmd,refreshPckg);

    49 	User::WaitForRequest(reqStatusPCmd);

    50 	TESTL(reqStatusPCmd.Int()==KErrNone);

    51 

    52 	TESTL(refresh.iType==SIMTSY_REFRESH_TYPE1);

    53 	TESTL(refresh.iFileList.Length()==1);

    54  	TESTL(refresh.iFileList[0]==SIMTSY_REFRESH_FILE1);

    55 	INFO_PRINTF1(_L("SAT Refresh test 1 passed"));

    56 

    57 	// Refresh Cancel

    58 	iSat.NotifyRefreshPCmd(reqStatusPCmd,refreshPckg);

    59 	iSat.CancelAsyncRequest(ESatNotifyRefreshPCmd);

    60 	User::WaitForRequest(reqStatusPCmd);

    61 	TESTL(reqStatusPCmd.Int()==KErrCancel);

    62 	INFO_PRINTF1(_L("SAT Refresh Cancel test passed"));

    63 

    64 	iSat.NotifyRefreshPCmd(reqStatusPCmd,refreshPckg);

    65 	User::WaitForRequest(reqStatusPCmd);

    66 	TESTL(reqStatusPCmd.Int()==KErrNone);

    67 

    68 	TESTL(refresh.iType==SIMTSY_REFRESH_TYPE2);

    69 	TESTL(refresh.iFileList.Length()==1);

    70  	TESTL(refresh.iFileList[0]==SIMTSY_REFRESH_FILE2);

    71 	INFO_PRINTF1(_L("SAT Refresh test 2 passed"));

    72 

    73 	iSat.NotifyRefreshPCmd(reqStatusPCmd,refreshPckg);

    74 	User::WaitForRequest(reqStatusPCmd);

    75 	TESTL(reqStatusPCmd.Int()==KErrNone);

    76 

    77 	TESTL(refresh.iType==SIMTSY_REFRESH_TYPE3);

    78 	TESTL(refresh.iFileList.Length()==2);

    79  	TESTL(refresh.iFileList[0]==SIMTSY_REFRESH_FILE1);

    80  	TESTL(refresh.iFileList[1]==SIMTSY_REFRESH_FILE2);

    81 	INFO_PRINTF1(_L("SAT Refresh test 3 passed"));

    82 

    83 	// Refresh Required successful test

    84 	iSat.NotifyRefreshPCmd(reqStatusPCmd,refreshPckg);

    85 

    86 	iSat.NotifyRefreshRequired(reqStatusRequired);

    87 	User::WaitForRequest(reqStatusRequired);

    88 	TESTL(reqStatusRequired.Int()==KErrNone);

    89 	

    90 	// Refresh Required Response

    91 	RSat::TRefreshRspV1* refreshAllowedRsp = new (ELeave) RSat::TRefreshRspV1;

    92 	CleanupStack::PushL(refreshAllowedRsp);

    93 	RSat::TRefreshRspV1Pckg* refreshAllowedRspPckg = new (ELeave) RSat::TRefreshRspV1Pckg(*refreshAllowedRsp);

    94 	CleanupStack::PushL(refreshAllowedRspPckg);

    95 

    96 	refreshAllowedRsp->iGeneralResult=SIMTSY_REFRESH_RESULT_SUCCESS;

    97 	refreshAllowedRsp->iInfoType=SIMTSY_REFRESH_RSP_NO_INFO;

    98 	refreshAllowedRsp->iAdditionalInfo=SIMTSY_REFRESH_NULL_BUF;

    99 

   100 	iSat.RefreshAllowed(reqStatusAllowed, *refreshAllowedRspPckg);

   101 	User::WaitForRequest(reqStatusAllowed);

   102 	TESTL(reqStatusAllowed.Int()==KErrNone);

   103 

   104 	// Wait for completion of outstanding PCmd now permission given

   105 	User::WaitForRequest(reqStatusPCmd);

   106 	TESTL(reqStatusPCmd.Int()==KErrNone);

   107 

   108 	TESTL(refresh.iType==SIMTSY_REFRESH_TYPE1);

   109 	TESTL(refresh.iFileList.Length()==1);

   110  	TESTL(refresh.iFileList[0]==SIMTSY_REFRESH_FILE1);

   111 	INFO_PRINTF1(_L("SAT NotifyRefreshRequired test 1 passed"));

   112 

   113 	// Refresh Required unsuccessful test

   114 	iSat.NotifyRefreshPCmd(reqStatusPCmd,refreshPckg);

   115 

   116 	iSat.NotifyRefreshRequired(reqStatusRequired);

   117 	User::WaitForRequest(reqStatusRequired);

   118 	TESTL(reqStatusRequired.Int()==KErrNone);

   119 

   120 	// Refresh Required Response

   121 	refreshAllowedRsp->iGeneralResult=SIMTSY_REFRESH_RESULT_FAIL;

   122 

   123 	iSat.RefreshAllowed(reqStatusAllowed, *refreshAllowedRspPckg);

   124 	User::WaitForRequest(reqStatusAllowed);

   125 	TESTL(reqStatusAllowed.Int()==KErrNone);

   126 

   127 	// Cancel ESatNotifyRefreshPCmd due to failing RefreshAllowed

   128 	iSat.CancelAsyncRequest(ESatNotifyRefreshPCmd);

   129 	User::WaitForRequest(reqStatusPCmd);

   130 	TESTL(reqStatusPCmd.Int()==KErrCancel);

   131 	INFO_PRINTF1(_L("SAT NotifyRefreshPCmd Cancel test passed"));

   132 

   133 	// Refresh Required second successful test

   134 	iSat.NotifyRefreshPCmd(reqStatusPCmd,refreshPckg);

   135 

   136 	iSat.NotifyRefreshRequired(reqStatusRequired);

   137 	User::WaitForRequest(reqStatusRequired);

   138 	TESTL(reqStatusRequired.Int()==KErrNone);

   139 

   140 	// Refresh Required Response

   141 	refreshAllowedRsp->iGeneralResult=SIMTSY_REFRESH_RESULT_SUCCESS;

   142 

   143 	iSat.RefreshAllowed(reqStatusAllowed, *refreshAllowedRspPckg);

   144 	User::WaitForRequest(reqStatusAllowed);

   145 	TESTL(reqStatusAllowed.Int()==KErrNone);

   146 

   147 	// Wait for completion of outstanding PCmd now permission given

   148 	User::WaitForRequest(reqStatusPCmd);

   149 	TESTL(reqStatusPCmd.Int()==KErrNone);

   150 

   151 	TESTL(refresh.iType==SIMTSY_REFRESH_TYPE2);

   152 	TESTL(refresh.iFileList.Length()==1);

   153  	TESTL(refresh.iFileList[0]==SIMTSY_REFRESH_FILE2);

   154 	INFO_PRINTF1(_L("SAT NotifyRefreshRequired test 2 passed"));

   155 

   156 	// Refresh Required third successful test

   157 	iSat.NotifyRefreshRequired(reqStatusRequired);

   158 	User::WaitForRequest(reqStatusRequired);

   159 	TESTL(reqStatusRequired.Int()==KErrNone);

   160 

   161 	iSat.NotifyRefreshPCmd(reqStatusPCmd,refreshPckg);

   162 

   163 	// Refresh Required Response

   164 	iSat.RefreshAllowed(reqStatusAllowed, *refreshAllowedRspPckg);

   165 	User::WaitForRequest(reqStatusAllowed);

   166 	TESTL(reqStatusAllowed.Int()==KErrNone);

   167 

   168 	// Wait for completion of outstanding PCmd now permission given

   169 	User::WaitForRequest(reqStatusPCmd);

   170 	TESTL(reqStatusPCmd.Int()==KErrNone);

   171 

   172 	TESTL(refresh.iType==SIMTSY_REFRESH_TYPE3);

   173 	TESTL(refresh.iFileList.Length()==2);

   174  	TESTL(refresh.iFileList[0]==SIMTSY_REFRESH_FILE1);

   175  	TESTL(refresh.iFileList[1]==SIMTSY_REFRESH_FILE2);

   176 	INFO_PRINTF1(_L("SAT NotifyRefreshRequired test 3 passed"));

   177 

   178 	// Refresh Required Cancel test

   179 	iSat.NotifyRefreshRequired(reqStatusRequired);

   180 	iSat.CancelAsyncRequest(ESatNotifyRefreshRequired);

   181 	User::WaitForRequest(reqStatusRequired);

   182 	TESTL(reqStatusRequired.Int()==KErrCancel);

   183 	INFO_PRINTF1(_L("SAT NotifyRefreshRequired Cancel test passed"));

   184 

   185 	// RefreshAllowed Cancel test

   186 	iSat.RefreshAllowed(reqStatusAllowed, *refreshAllowedRspPckg);

   187 	iSat.CancelAsyncRequest(ESatRefreshAllowed);

   188 	User::WaitForRequest(reqStatusAllowed);

   189 	// Test for either KErrNone or KErrCancel since we expect the request to be responded to immediately

   190 	TESTL(reqStatusAllowed.Int()==KErrNone || reqStatusAllowed.Int()==KErrCancel);

   191 	INFO_PRINTF1(_L("SAT RefreshAllowed Cancel test passed"));

   192 

   193 	// Refresh Required test successful repeated with parameterised NotifyRefreshRequired

   194 	iSat.NotifyRefreshPCmd(reqStatusPCmd,refreshPckg);

   195 

   196 	// Refresh

   197 	RSat::TRefreshV1 refreshRequired;

   198 	RSat::TRefreshV1Pckg refreshRequiredPckg(refreshRequired);

   199 

   200 	iSat.NotifyRefreshRequired(reqStatusRequired, refreshRequiredPckg);

   201 	User::WaitForRequest(reqStatusRequired);

   202 	TESTL(reqStatusRequired.Int()==KErrNone);

   203 

   204  	TESTL(refreshRequired.iType==SIMTSY_REFRESH_TYPE1);

   205 	TESTL(refreshRequired.iFileList.Length()==1);

   206  	TESTL(refreshRequired.iFileList[0]==SIMTSY_REFRESH_FILE1);	

   207 

   208 	refreshAllowedRsp->iGeneralResult=SIMTSY_REFRESH_RESULT_SUCCESS;

   209 	refreshAllowedRsp->iInfoType=SIMTSY_REFRESH_RSP_NO_INFO;

   210 	refreshAllowedRsp->iAdditionalInfo=SIMTSY_REFRESH_NULL_BUF;

   211 

   212 	iSat.RefreshAllowed(reqStatusAllowed, *refreshAllowedRspPckg);

   213 

   214 	User::WaitForRequest(reqStatusAllowed);

   215 	TESTL(reqStatusAllowed.Int()==KErrNone);

   216 	

   217 	// Wait for completion of outstanding PCmd now permission given

   218 	User::WaitForRequest(reqStatusPCmd);

   219 	TESTL(reqStatusPCmd.Int()==KErrNone);

   220 

   221 	TESTL(refresh.iType==SIMTSY_REFRESH_TYPE1);

   222 	TESTL(refresh.iFileList.Length()==1);

   223  	TESTL(refresh.iFileList[0]==SIMTSY_REFRESH_FILE1);

   224   

   225 	INFO_PRINTF1(_L("SAT NotifyRefreshRequiredParam test 1 passed"));

   226 

   227 	// Refresh Required unsuccessful test

   228 	iSat.NotifyRefreshPCmd(reqStatusPCmd,refreshPckg);

   229 

   230 	iSat.NotifyRefreshRequired(reqStatusRequired, refreshRequiredPckg);

   231 	User::WaitForRequest(reqStatusRequired);

   232 	TESTL(reqStatusRequired.Int()==KErrNone);

   233 

   234 	// Refresh Required Response

   235 	refreshAllowedRsp->iGeneralResult=SIMTSY_REFRESH_RESULT_FAIL;

   236 

   237 	iSat.RefreshAllowed(reqStatusAllowed, *refreshAllowedRspPckg);

   238 	User::WaitForRequest(reqStatusAllowed);

   239 	TESTL(reqStatusAllowed.Int()==KErrNone);

   240 

   241  	// Cancel ESatNotifyRefreshPCmd due to failing RefreshAllowed

   242 	iSat.CancelAsyncRequest(ESatNotifyRefreshPCmd);

   243 	User::WaitForRequest(reqStatusPCmd);

   244 	TESTL(reqStatusPCmd.Int()==KErrCancel);

   245 	INFO_PRINTF1(_L("SAT NotifyRefreshPCmd Cancel test passed"));

   246 

   247 	// Refresh Required second successful test

   248 	iSat.NotifyRefreshPCmd(reqStatusPCmd,refreshPckg);

   249 

   250 	iSat.NotifyRefreshRequired(reqStatusRequired, refreshRequiredPckg);

   251 	User::WaitForRequest(reqStatusRequired);

   252 	TESTL(reqStatusRequired.Int()==KErrNone);

   253 

   254  	TESTL(refreshRequired.iType==SIMTSY_REFRESH_TYPE2);

   255 	TESTL(refreshRequired.iFileList.Length()==1);

   256  	TESTL(refreshRequired.iFileList[0]==SIMTSY_REFRESH_FILE2);

   257 

   258 	// Refresh Required Response

   259 	refreshAllowedRsp->iGeneralResult=SIMTSY_REFRESH_RESULT_SUCCESS;

   260 

   261 	iSat.RefreshAllowed(reqStatusAllowed, *refreshAllowedRspPckg);

   262 	User::WaitForRequest(reqStatusAllowed);

   263 	TESTL(reqStatusAllowed.Int()==KErrNone);

   264 

   265 	// Wait for completion of outstanding PCmd now permission given

   266 	User::WaitForRequest(reqStatusPCmd);

   267 	TESTL(reqStatusPCmd.Int()==KErrNone);

   268 

   269 	TESTL(refresh.iType==SIMTSY_REFRESH_TYPE2);

   270 	TESTL(refresh.iFileList.Length()==1);

   271  	TESTL(refresh.iFileList[0]==SIMTSY_REFRESH_FILE2);

   272  	 	

   273 	INFO_PRINTF1(_L("SAT NotifyRefreshRequiredParam test 2 passed"));

   274 

   275 	// Refresh Required third successful test

   276 	iSat.NotifyRefreshRequired(reqStatusRequired, refreshRequiredPckg);

   277 	User::WaitForRequest(reqStatusRequired);

   278 	TESTL(reqStatusRequired.Int()==KErrNone);

   279 

   280   	TESTL(refreshRequired.iType==SIMTSY_REFRESH_TYPE3);

   281 	TESTL(refreshRequired.iFileList.Length()==2);

   282  	TESTL(refreshRequired.iFileList[0]==SIMTSY_REFRESH_FILE1);

   283   	TESTL(refreshRequired.iFileList[1]==SIMTSY_REFRESH_FILE2);

   284 

   285 	iSat.NotifyRefreshPCmd(reqStatusPCmd,refreshPckg);

   286 

   287 	// Refresh Required Response

   288 	iSat.RefreshAllowed(reqStatusAllowed, *refreshAllowedRspPckg);

   289 	User::WaitForRequest(reqStatusAllowed);

   290 	TESTL(reqStatusAllowed.Int()==KErrNone);

   291 

   292 	// Wait for completion of outstanding PCmd now permission given

   293 	User::WaitForRequest(reqStatusPCmd);

   294 	TESTL(reqStatusPCmd.Int()==KErrNone);

   295 

   296   	TESTL(refreshRequired.iType==SIMTSY_REFRESH_TYPE3);

   297 	TESTL(refreshRequired.iFileList.Length()==2);

   298  	TESTL(refreshRequired.iFileList[0]==SIMTSY_REFRESH_FILE1);

   299   	TESTL(refreshRequired.iFileList[1]==SIMTSY_REFRESH_FILE2);

   300  	 	

   301 	INFO_PRINTF1(_L("SAT NotifyRefreshRequiredParam test 3 passed"));

   302 

   303 	// Refresh Required Cancel test

   304 	iSat.NotifyRefreshRequired(reqStatusRequired, refreshRequiredPckg);

   305 	iSat.CancelAsyncRequest(ESatNotifyRefreshRequiredParam);

   306 	User::WaitForRequest(reqStatusRequired);

   307 	TESTL(reqStatusRequired.Int()==KErrNone || reqStatusRequired.Int()==KErrCancel);

   308 	INFO_PRINTF1(_L("SAT NotifyRefreshRequired Cancel test passed"));

   309 

   310 	// RefreshAllowed Cancel test

   311 	iSat.RefreshAllowed(reqStatusAllowed, *refreshAllowedRspPckg);

   312 	iSat.CancelAsyncRequest(ESatRefreshAllowed);

   313 	User::WaitForRequest(reqStatusAllowed);

   314 	// Test for either KErrNone or KErrCancel since we expect the request to be responded to immediately

   315 	TESTL(reqStatusAllowed.Int()==KErrNone || reqStatusAllowed.Int()==KErrCancel);

   316 	INFO_PRINTF1(_L("SAT RefreshAllowed Cancel test passed"));

   317 

   318 	CleanupStack::PopAndDestroy(2);

   319 

   320 	iSat.Close();

   321 	iPhone.Close();

   322 	ASSERT(RThread().RequestCount()==0);

   323 

   324 	return TestStepResult();

   325 	}

   326 	

   327 	

   328 CSimSatRetMMPCmdTest::CSimSatRetMMPCmdTest() 

   329 	{ 

   330 	SetTestStepName(_L("SatTestRetMMPCmd"));

   331 	}

   332 

   333 

   334 TVerdict CSimSatRetMMPCmdTest::doTestStepL()

   335 	{

   336 	INFO_PRINTF1(_L("RETRIEVE MULTIMEDIA PCMD TESTING - START"));

   337 

   338  	CreateConfigFileL(_L("c:\\config4.txt"));

   339  	SetTestNumberL(0);

   340 

   341 	TInt ret = iPhone.Open(iTelServer,KPhoneName); 

   342 	TESTL(ret == KErrNone); 

   343 	INFO_PRINTF1(_L("Opened phone object"));

   344 	TESTL(iSat.Open(iPhone)==KErrNone);

   345 	INFO_PRINTF1(_L("Opened Sat object"));

   346 

   347 	testSAT8501L();	// For testing the TEL-SIMTSY-SAT-8501 

   348 	testSAT8502L();	// For testing the TEL-SIMTSY-SAT-8502 

   349 	testSAT8503L();	// For testing the TEL-SIMTSY-SAT-8503 

   350 	testSAT8504L();	// For testing the TEL-SIMTSY-SAT-8504 

   351 	testSAT8505L();	// For testing the TEL-SIMTSY-SAT-8505 

   352 	testSAT8506L();	// For testing the TEL-SIMTSY-SAT-8506 

   353 	testSAT8507L();	// For testing the TEL-SIMTSY-SAT-8507

   354 	testSAT8508L();	// For testing the TEL-SIMTSY-SAT-8508

   355 	

   356 	iSat.Close();

   357 	iPhone.Close();

   358 	ASSERT(RThread().RequestCount()==0);

   359 	

   360 	INFO_PRINTF1(_L("RETRIEVE MULTIMEDIA PCMD TESTING - END"));

   361 

   362 	return TestStepResult();

   363 	

   364 	}

   365 

   366 /*

   367  * 	SYMTestCaseID TEL-SIMTSY-NA-8501

   368  *

   369  *	SYMREQ REQ7329

   370  *

   371  *	SYMTestCaseDesc UICC issues RETRIEVE MULTIMEDIA Proactive command to

   372  *	ME successfully

   373  *

   374  *	SYMTestPriority High

   375  *

   376  *	SYMTestActions 

   377  *		(i) 	Client requests notification for RETRIEVE MM using RSat::NotifyRetrieveMultimediaMsgPCmd() API.

   378  *		(ii)	UICC issues RETRIEVE MULTIMEDIA MESSAGE command to the ME.

   379  *		(iii)	ME sends Terminal Response to the UICC using RSat::TerminalRsp ()

   380  *

   381  *	SYMTestExpectedResults 

   382  *	ME is notified of the request.

   383  *	Upon completion of the proactive command, details are returned in a 

   384  *	packaged version of TRetrieveMultimediaMessageV6 in the command 

   385  *	parameter. 

   386  *	ME responds with KSuccess in the Terminal response command for the 

   387  *	TRequestStatus variable

   388  *

   389  * 	SYMTestType CIT

   390  */

   391 

   392 TInt CSimSatRetMMPCmdTest::testSAT8501L()

   393 	{

   394 

   395 	INFO_PRINTF1(_L("Executing the Test Case TEL-SIMTSY-SAT-8501"));

   396 	

   397 	TRequestStatus reqStatus;

   398 

   399 	RSat::TRetrieveMultimediaMessageV6 *tMMMessageV6 = new (ELeave) RSat::TRetrieveMultimediaMessageV6;

   400 	CleanupStack::PushL(tMMMessageV6);

   401 

   402 	RSat::TRetrieveMultimediaMessageV6Pckg *tMMMessagePckg = new (ELeave) RSat::TRetrieveMultimediaMessageV6Pckg

   403 											(*tMMMessageV6);

   404 	CleanupStack::PushL(tMMMessagePckg);

   405 

   406 	iSat.NotifyRetrieveMultimediaMsgPCmd(reqStatus,*tMMMessagePckg);

   407 	User::WaitForRequest(reqStatus);

   408 	TESTL(reqStatus.Int()==KErrNone);

   409 

   410 	TESTL(tMMMessageV6->iDestination == SIMTSY_DEVICEID_ME);

   411 	TESTL(tMMMessageV6->iAlphaId.iStatus == SIMTSY_ALPHAID_STATUS);

   412 	TESTL(tMMMessageV6->iAlphaId.iAlphaId.Compare(SIMTSY_ALPHAID_BUF) == 0);

   413 	TESTL(tMMMessageV6->iIconId.iQualifier == SIMTSY_ICONID_QLFR);

   414 	TESTL(tMMMessageV6->iIconId.iIdentifier == SIMTSY_ICONID_ID);

   415 	TESTL(tMMMessageV6->iMultimediaMessageRef.Compare(SIMTSY_MMMSG_REF_FILES) ==0);

   416 	TESTL(tMMMessageV6->iReceptionFile.Compare(SIMTSY_RCPTION_FILES) ==0);

   417 	TESTL(tMMMessageV6->iMultimediaContentId.Compare(SIMTSY_MMCONTENT_ID_DATA) ==0);

   418 	TESTL(tMMMessageV6->iMultimediaMessageId.Compare(SIMTSY_MMMSG_ID_DATA) ==0);

   419 	TESTL(tMMMessageV6->iTextAttribute.iStatus == SIMTSY_TXT_ATTR_STATUS);

   420 	TESTL(tMMMessageV6->iTextAttribute.iTextAttributeData.Compare(SIMTSY_TXT_ATTR_DATA) ==0);

   421 	

   422 	RSat::TRetrieveMultimediaMessageRspV6 *tMMMessageRspV6 = new (ELeave) RSat::TRetrieveMultimediaMessageRspV6;

   423 	CleanupStack::PushL(tMMMessageRspV6);

   424 	

   425 	RSat::TRetrieveMultimediaMessageRspV6Pckg *tMMMessageRspPckgV6 = new (ELeave) 

   426 		RSat::TRetrieveMultimediaMessageRspV6Pckg(*tMMMessageRspV6);

   427 	CleanupStack::PushL(tMMMessageRspPckgV6);

   428 	

   429 	tMMMessageRspV6->iGeneralResult = RSat::KSuccess;

   430 	tMMMessageRspV6->iInfoType = RSat::KNoAdditionalInfo;

   431 	tMMMessageRspV6->SetPCmdNumber(SIMTSY_RET_MM_PCMD_NUMBER);

   432 		

   433 	iSat.TerminalRsp(reqStatus,RSat::ERetrieveMultimediaMsg,*(tMMMessageRspPckgV6));

   434 	User::WaitForRequest(reqStatus);

   435 	TESTL(reqStatus.Int()== KErrNone);

   436 	

   437 	CleanupStack::PopAndDestroy(4);

   438 		

   439 	INFO_PRINTF1(_L("Execution of the Test Case TEL-SIMTSY-SAT-8501 - Successful"));

   440 	return KErrNone;

   441 

   442 	}

   443 

   444 /*

   445  * 	SYMTestCaseID TEL-SIMTSY-NA-8502

   446  *

   447  *	SYMREQ REQ7329

   448  *

   449  *	SYMTestCaseDesc Retrieve  Multimedia command rejected by the ME as ME is busy on a MMS transaction.

   450  *

   451  *	SYMTestPriority High

   452  *

   453  *	SYMTestActions 

   454  *	(i)	Client requests notification for RETRIEVE MULTIMEDIA MESSAGE using NotifyRetrieveMultimediaMsgPCmd()

   455  *		API.

   456  *	(ii)	UICC issues RETRIEVE MULTIMEDIA MESSAGE command to the ME.

   457  *	(iii)	ME is unable to execute the command as its busy processing some other MMS transaction.

   458  *	(iv)	ME sends Terminal Response to the UICC using RSat::TerminalRsp ().

   459  *

   460  *	SYMTestExpectedResults 

   461  *	ME is notified of the request.

   462  *	Upon completion of the proactive command, details are returned in a packaged version of 

   463  *	TRetrieveMultimediaMessageV6 in the command parameter. 

   464  *	ME responds with KMMSTemporaryProblem in the Terminal response as the TPCmdResult with the 

   465  *	additional information ‘KNoSpecificMeProblem’.

   466  *

   467  * 	SYMTestType CIT

   468  */

   469  

   470 TInt CSimSatRetMMPCmdTest::testSAT8502L()

   471 	{

   472 

   473 	INFO_PRINTF1(_L("Executing the Test Case TEL-SIMTSY-SAT-8502"));

   474 	

   475 	TRequestStatus reqStatus;

   476 

   477 	RSat::TRetrieveMultimediaMessageV6 *tMMMessageV6 = new (ELeave) RSat::TRetrieveMultimediaMessageV6;

   478 	CleanupStack::PushL(tMMMessageV6);

   479 

   480 	RSat::TRetrieveMultimediaMessageV6Pckg *tMMMessagePckg = new (ELeave) RSat::TRetrieveMultimediaMessageV6Pckg

   481 										(*tMMMessageV6);

   482 	CleanupStack::PushL(tMMMessagePckg);

   483 

   484 	iSat.NotifyRetrieveMultimediaMsgPCmd(reqStatus,*tMMMessagePckg);

   485 	User::WaitForRequest(reqStatus);

   486 	TESTL(reqStatus.Int()==KErrNone);

   487 

   488 	TESTL(tMMMessageV6->iDestination == SIMTSY_DEVICEID_ME);

   489 	TESTL(tMMMessageV6->iAlphaId.iStatus == SIMTSY_ALPHAID_STATUS);

   490 	TESTL(tMMMessageV6->iAlphaId.iAlphaId.Compare(SIMTSY_ALPHAID_BUF) == 0);

   491 	TESTL(tMMMessageV6->iIconId.iQualifier == SIMTSY_ICONID_QLFR);

   492 	TESTL(tMMMessageV6->iIconId.iIdentifier == SIMTSY_ICONID_ID);

   493 	TESTL(tMMMessageV6->iMultimediaMessageRef.Compare(SIMTSY_MMMSG_REF_FILES) ==0);

   494 	TESTL(tMMMessageV6->iReceptionFile.Compare(SIMTSY_RCPTION_FILES) ==0);

   495 	TESTL(tMMMessageV6->iMultimediaContentId.Compare(SIMTSY_MMCONTENT_ID_DATA) ==0);

   496 	TESTL(tMMMessageV6->iMultimediaMessageId.Compare(SIMTSY_MMMSG_ID_DATA_2) ==0);

   497 	TESTL(tMMMessageV6->iTextAttribute.iStatus == SIMTSY_TXT_ATTR_STATUS);

   498 	TESTL(tMMMessageV6->iTextAttribute.iTextAttributeData.Compare(SIMTSY_TXT_ATTR_DATA) ==0);

   499 	

   500 	RSat::TRetrieveMultimediaMessageRspV6 *tMMMessageRspV6 = new (ELeave) RSat::TRetrieveMultimediaMessageRspV6;

   501 	CleanupStack::PushL(tMMMessageRspV6);

   502 	

   503 	RSat::TRetrieveMultimediaMessageRspV6Pckg *tMMMessageRspPckgV6 = 

   504 		new (ELeave) RSat::TRetrieveMultimediaMessageRspV6Pckg(*tMMMessageRspV6);

   505 	CleanupStack::PushL(tMMMessageRspPckgV6);

   506 	

   507 	_LIT(KText,"KNoSpecificMeProblem");

   508 	TBuf<254> buf(KText);

   509 	tMMMessageRspV6->iGeneralResult = RSat::KMMSTemporaryProblem;

   510 	tMMMessageRspV6->iInfoType = RSat::KMeProblem;

   511 	tMMMessageRspV6->iAdditionalInfo = buf;

   512 	tMMMessageRspV6->SetPCmdNumber(SIMTSY_RET_MM_PCMD_NUMBER);

   513 		

   514 	iSat.TerminalRsp(reqStatus,RSat::ERetrieveMultimediaMsg,*(tMMMessageRspPckgV6));

   515 	User::WaitForRequest(reqStatus);

   516 	TESTL(reqStatus.Int() == KErrNone);

   517 	

   518 	CleanupStack::PopAndDestroy(4);

   519 	

   520 	INFO_PRINTF1(_L("Execution of the Test Case TEL-SIMTSY-SAT-8502 - Successful"));

   521 	return KErrNone;

   522 

   523 	}

   524 

   525 

   526 /*

   527  * 	SYMTestCaseID TEL-SIMTSY-NA-8503

   528  *	

   529  *	SYMREQ REQ REQ7329

   530  *	

   531  *	SYMTestCaseDesc 	RETRIEVE MULTIMEDIA MESSAGE command accepted 

   532  *	on the second attempt after the first attempt being replied as 

   533  *	ME busy on MMS transaction.

   534  *	

   535  *	SYMTestPriority High

   536  *

   537  * 	SYMTestActions 

   538  *	(i)	Client requests notification for RETRIEVE MULTIMEDIA MESSAGE 

   539  *		using NotifyRetrieveMultimediaMsgPCmd () API.

   540  *	(ii)	UICC issues RETRIEVE MULTIMEDIA MESSAGE Command to the ME.

   541  *	(iii)	ME is unable to execute the command as its busy processing 

   542  *		some other MMS transaction.

   543  *	(iv)	ME sends Terminal Response to the UICC using 

   544  *		RSat::TerminalRsp ().

   545  *	(v)	Client requests notification for RETRIEVE MULTIMEDIA MESSAGE 

   546  *		using NotifyRetrieveMultimediaMsgPCmd () API again.

   547  *	(vi)	UICC makes another attempt by resending the proactive command.

   548  *		This time Clients responds to execute the command successfully.

   549  *	(vii)	ME sends Terminal Response to the UICC using 

   550  *		RSat::TerminalRsp ().

   551  *	

   552  *	SYMTestExpectedResults 

   553  *	Client is notified of the request.

   554  *	ME responds with KMMSTemporaryProblem in the response parameter. 

   555  *	Upon completion of the proactive command in the second attempt, 

   556  *	details are returned in a packaged version of 

   557  *	TRetrieveMultimediaMessageV6 in the command parameter. 

   558  *	For the second attempt, Client responds with KSuccess in the 

   559  *	response parameter

   560  *

   561  * 	SYMTestType CIT

   562  */

   563 TInt CSimSatRetMMPCmdTest::testSAT8503L()

   564 	{

   565 

   566 	INFO_PRINTF1(_L("Executing the Test Case TEL-SIMTSY-SAT-8503"));

   567 	

   568 	TRequestStatus reqStatus;

   569 

   570 	RSat::TRetrieveMultimediaMessageV6 *tMMMessageV6 = new (ELeave) RSat::TRetrieveMultimediaMessageV6;

   571 	CleanupStack::PushL(tMMMessageV6);

   572 

   573 	RSat::TRetrieveMultimediaMessageV6Pckg *tMMMessagePckg = new (ELeave) RSat::TRetrieveMultimediaMessageV6Pckg

   574 			(*tMMMessageV6);

   575 	CleanupStack::PushL(tMMMessagePckg);

   576 

   577 	iSat.NotifyRetrieveMultimediaMsgPCmd(reqStatus,*tMMMessagePckg);

   578 	User::WaitForRequest(reqStatus);

   579 	TESTL(reqStatus.Int()==KErrNone);

   580 

   581 	RSat::TRetrieveMultimediaMessageRspV6 *tMMMessageRspV6 = new (ELeave) RSat::TRetrieveMultimediaMessageRspV6;

   582 	CleanupStack::PushL(tMMMessageRspV6);

   583 	

   584 	RSat::TRetrieveMultimediaMessageRspV6Pckg *tMMMessageRspPckgV6 =

   585 	       new (ELeave) RSat::TRetrieveMultimediaMessageRspV6Pckg(*tMMMessageRspV6);

   586 	CleanupStack::PushL(tMMMessageRspPckgV6);

   587 	

   588 	reqStatus = KErrNone;

   589 	

   590 	_LIT(KText,"KNoSpecificMeProblem");

   591 	TBuf<254> buf(KText);

   592 	tMMMessageRspV6->iGeneralResult = RSat::KMMSTemporaryProblem;

   593 	tMMMessageRspV6->iInfoType = RSat::KMeProblem;

   594 	tMMMessageRspV6->iAdditionalInfo = buf;

   595 	tMMMessageRspV6->SetPCmdNumber(SIMTSY_RET_MM_PCMD_NUMBER);

   596 		

   597 	iSat.TerminalRsp(reqStatus,RSat::ERetrieveMultimediaMsg,*(tMMMessageRspPckgV6));

   598 	User::WaitForRequest(reqStatus);

   599 	TESTL(reqStatus.Int() == KErrNone);

   600 	

   601 	iSat.NotifyRetrieveMultimediaMsgPCmd(reqStatus,*tMMMessagePckg);

   602 	User::WaitForRequest(reqStatus);

   603 	TESTL(reqStatus.Int()==KErrNone);

   604 	

   605 	tMMMessageRspV6->iGeneralResult = RSat::KSuccess;

   606 	tMMMessageRspV6->iInfoType = RSat::KNoAdditionalInfo;

   607 	tMMMessageRspV6->SetPCmdNumber(SIMTSY_RET_MM_PCMD_NUMBER);

   608 	

   609 	CleanupStack::PopAndDestroy(4);

   610 	

   611 	INFO_PRINTF1(_L("Execution of the Test Case TEL-SIMTSY-SAT-8503 - Successful"));

   612 	return KErrNone;

   613 

   614 	}

   615 

   616 /*

   617  * 	SYMTestCaseID TEL-SIMTSY-NA-8504

   618  *

   619  *	SYMREQ REQ7329

   620  *

   621  *	SYMTestCaseDesc ME rejects  Retrieve  Multimedia command as the ME is unable to process the MMS transaction

   622  *

   623  *	SYMTestPriority High

   624  *

   625  *	SYMTestActions 

   626  *		(i)	Client requests notification for RETRIEVE MULTIMEDIA MESSAGE using 

   627  *			NotifyRetrieveMultimediaMsgPCmd () API.

   628  *		(ii)	UICC issues RETRIEVE MULTIMEDIA MESSAGE Command to the ME.

   629  *		(iii)	Client is unable to process the MMS transaction.

   630  *		(iv)	ME sends Terminal Response to the UICC using RSat::TerminalRsp ().

   631  *

   632  *	SYMTestExpectedResults 

   633  *	Client is notified of the request.

   634  *	Upon completion of the proactive command details are returned in a packaged version of 

   635  *	TRetrieveMultimediaMessageV6 in the command parameter. 

   636  *	ME responds with KMMSError  in the Terminal response as the TPCmdResult with the 

   637  *	additional information ‘KNoSpecificMeProblem’.

   638  *

   639  * 	SYMTestType CIT

   640  */

   641 

   642 TInt CSimSatRetMMPCmdTest::testSAT8504L()

   643 	{

   644 

   645 	INFO_PRINTF1(_L("Executing the Test Case TEL-SIMTSY-SAT-8504"));

   646 	TRequestStatus reqStatus;

   647 

   648 	RSat::TRetrieveMultimediaMessageV6 *tMMMessageV6 = new (ELeave) RSat::TRetrieveMultimediaMessageV6;

   649 	CleanupStack::PushL(tMMMessageV6);

   650 

   651 	RSat::TRetrieveMultimediaMessageV6Pckg *tMMMessagePckg = new (ELeave) 

   652 		RSat::TRetrieveMultimediaMessageV6Pckg(*tMMMessageV6);

   653 	CleanupStack::PushL(tMMMessagePckg);

   654 

   655 	iSat.NotifyRetrieveMultimediaMsgPCmd(reqStatus,*tMMMessagePckg);

   656 	User::WaitForRequest(reqStatus);

   657 	TESTL(reqStatus.Int()==KErrNone);

   658 

   659 	RSat::TRetrieveMultimediaMessageRspV6 *tMMMessageRspV6 = new (ELeave) RSat::TRetrieveMultimediaMessageRspV6;

   660 	CleanupStack::PushL(tMMMessageRspV6);

   661 	

   662 	RSat::TRetrieveMultimediaMessageRspV6Pckg *tMMMessageRspPckgV6 = new (ELeave) 

   663 		RSat::TRetrieveMultimediaMessageRspV6Pckg(*tMMMessageRspV6);

   664 	CleanupStack::PushL(tMMMessageRspPckgV6);

   665 	

   666 	_LIT(KText,"KNoSpecificMeProblem");

   667 	TBuf<254> buf(KText);

   668 	tMMMessageRspV6->iGeneralResult = RSat::KMMSError;

   669 	tMMMessageRspV6->iInfoType = RSat::KMeProblem;

   670 	tMMMessageRspV6->iAdditionalInfo = buf;

   671 	tMMMessageRspV6->SetPCmdNumber(SIMTSY_RET_MM_PCMD_NUMBER);

   672 		

   673 	iSat.TerminalRsp(reqStatus,RSat::ERetrieveMultimediaMsg,*(tMMMessageRspPckgV6));

   674 	User::WaitForRequest(reqStatus);

   675 	TESTL(reqStatus.Int() == KErrNone);

   676 	

   677 	CleanupStack::PopAndDestroy(4);

   678 	

   679 	INFO_PRINTF1(_L("Execution of the Test Case TEL-SIMTSY-SAT-8504 - Successful"));

   680 	return KErrNone;

   681 

   682 	}

   683 

   684 /*

   685  * 	SYMTestCaseID TEL-SIMTSY-NA-8505

   686  *

   687  *	SYMREQ REQ7329

   688  *

   689  *	SYMTestCaseDesc Cancel notification of RETRIEVE MULTIMEDIA MESSAGE request

   690  *

   691  *	SYMTestPriority High

   692  *

   693  *	SYMTestActions 

   694  *		(i)	Register to be notified of RETRIEVE MULTIMEDIA MESSAGE 

   695  *			command using NotifyRetrieveMultimediaMsgPCmd () API.

   696  *		(ii)	Cancel the request by calling CancelAsyncRequest (ESatNotifyRetrieveMultimediaMessagePCmd).

   697  *

   698  *	SYMTestExpectedResults 

   699  *		Client shall be able to cancel the request. The cancel API shall respond with KErrCancel or KErrNone.

   700  * 	SYMTestType CIT

   701  */

   702 

   703 TInt CSimSatRetMMPCmdTest::testSAT8505L()

   704 	{

   705 	

   706 	INFO_PRINTF1(_L("Executing the Test Case TEL-SIMTSY-SAT-8505"));

   707 	

   708 	TRequestStatus reqStatus;

   709 

   710 	RSat::TRetrieveMultimediaMessageV6 *tMMMessageV6 = new (ELeave) RSat::TRetrieveMultimediaMessageV6;

   711 	CleanupStack::PushL(tMMMessageV6);

   712 

   713 	RSat::TRetrieveMultimediaMessageV6Pckg *tMMMessagePckg = new (ELeave) 

   714 		RSat::TRetrieveMultimediaMessageV6Pckg(*tMMMessageV6);

   715 	CleanupStack::PushL(tMMMessagePckg);

   716 

   717 	iSat.NotifyRetrieveMultimediaMsgPCmd(reqStatus,*tMMMessagePckg);

   718 	iSat.CancelAsyncRequest(ESatNotifyRetrieveMultimediaMsgPCmd);

   719 	User::WaitForRequest(reqStatus);

   720 	

   721 	TESTL((reqStatus.Int()==KErrNone) || (reqStatus.Int()==KErrCancel));

   722 

   723 	CleanupStack::PopAndDestroy(2);

   724 

   725 	INFO_PRINTF1(_L("Execution of the Test Case TEL-SIMTSY-SAT-8505 - Successful"));

   726 	return KErrNone;

   727 	

   728 	}

   729 

   730 

   731 /*

   732  * 	SYMTestCaseID TEL-SIMTSY-NA-8506

   733  *

   734  *	SYMREQ REQ7329

   735  *

   736  *	SYMTestCaseDesc Cancel the terminal response for the request placed for notification of 

   737  *			RETRIEVE MULTIMEDIA MESSAGE request

   738  *

   739  *	SYMTestPriority High

   740  *

   741  *	SYMTestActions 

   742  *		(i)	Register to be notified of RETRIEVE MULTIMEDIA MESSAGE 

   743  *			command using NotifyRetrieveMultimediaMsgPCmd () API.

   744  *		(ii)	Call the Terminal response() API with the TPCmd as ERetrieveMultimediaMsg

   745  *		(iii)	Cancel the request by calling CancelAsyncRequest (ESatTerminalRsp).

   746  *

   747  *	SYMTestExpectedResults 

   748  *		Client shall be able to cancel the request. The cancel API shall respond with KErrCancel or KErrNone.

   749  *

   750  * 	SYMTestType CIT

   751  */

   752 

   753 TInt CSimSatRetMMPCmdTest::testSAT8506L()

   754 	{

   755 

   756 	INFO_PRINTF1(_L("Executing the Test Case TEL-SIMTSY-SAT-8506"));

   757 

   758 	TRequestStatus reqStatus;

   759 

   760 	RSat::TRetrieveMultimediaMessageV6 *tMMMessageV6 = new (ELeave) RSat::TRetrieveMultimediaMessageV6;

   761 	CleanupStack::PushL(tMMMessageV6);

   762 

   763 	RSat::TRetrieveMultimediaMessageV6Pckg *tMMMessagePckg = new (ELeave)

   764 	       	RSat::TRetrieveMultimediaMessageV6Pckg(*tMMMessageV6);

   765 	CleanupStack::PushL(tMMMessagePckg);

   766 

   767 	iSat.NotifyRetrieveMultimediaMsgPCmd(reqStatus,*tMMMessagePckg);

   768 	User::WaitForRequest(reqStatus);

   769 	TESTL(reqStatus.Int()==KErrNone);

   770 

   771 	RSat::TRetrieveMultimediaMessageRspV6 *tMMMessageRspV6 = new (ELeave) RSat::TRetrieveMultimediaMessageRspV6;

   772 	CleanupStack::PushL(tMMMessageRspV6);

   773 	

   774 	RSat::TRetrieveMultimediaMessageRspV6Pckg *tMMMessageRspPckgV6 = new (ELeave)

   775 	       	RSat::TRetrieveMultimediaMessageRspV6Pckg(*tMMMessageRspV6);

   776 	CleanupStack::PushL(tMMMessageRspPckgV6);

   777 	

   778 	tMMMessageRspV6->iGeneralResult = RSat::KSuccess;

   779 	tMMMessageRspV6->iInfoType = RSat::KNoAdditionalInfo;

   780 	tMMMessageRspV6->SetPCmdNumber(SIMTSY_RET_MM_PCMD_NUMBER);

   781 		

   782 	iSat.TerminalRsp(reqStatus,RSat::ERetrieveMultimediaMsg,*(tMMMessageRspPckgV6));

   783 	iSat.CancelAsyncRequest(ESatTerminalRsp);

   784 	User::WaitForRequest(reqStatus);

   785 	

   786 	TESTL((reqStatus.Int() == KErrNone) || (reqStatus.Int() ==  KErrCancel));

   787 	

   788 	CleanupStack::PopAndDestroy(4);

   789 

   790 	INFO_PRINTF1(_L("Execution of the Test Case TEL-SIMTSY-SAT-8506 - Successful"));

   791 	return KErrNone;

   792 

   793 	}

   794 

   795 /*

   796  * 	SYMTestCaseID TEL-SIMTSY-NA-8507

   797  *

   798  *	SYMREQ REQ7329 and REQ7334

   799  *

   800  *	SYMTestCaseDesc To verify the event of the envelope command for MMS TRANSFER STATUS envelope command 

   801  *			after the RETRIEVE MULTIMEDIA MESSAGE proactive command.

   802  *

   803  *	SYMTestPriority High

   804  *

   805  *	SYMTestActions 

   806  *	(i)	Call the API RSat::GetMeSideSatProfile using the parameter RSat::TSatProfileV6Pckg as reference.

   807  *	(ii)	Call the API RSat::ClientSatProfileIndication using the TSatProfileV6 with TSatProfileByte22 

   808  *		set to KCapsRetrieveMultimediaMessage and TSatProfileByte25 set to KCapsMmsTransferStatusEvent.

   809  *	(iii)	Client requests notification for RETRIEVE MULTIMEDIA MESSAGE using 

   810  *		NotifyRetrieveMultimediaMsgPCmd () API.

   811  *	(iv)	UICC issues RETRIEVE MULTIMEDIA MESSAGE Command to the ME.

   812  *	(v)	ME is able to process the MMS transaction and the response is sent using RSat::TerminalRsp ()

   813  *		for NotifyRetrieveMultimediaMsgPCmd.

   814  *	(vi)	Call the API RSat::MMSTransferStatus with the parameter as object of TMMTransferStatusV6 

   815  *		to store the MM1_retrieve.RES message on to the UICC.

   816  *

   817  *	SYMTestExpectedResults 

   818  *		GetMeSideSatProfile shall return the RSat::TSatProfileV6 with TSatProfileByte22 set to 

   819  *		KCapsRetrieveMultimediaMessage and TSatProfileByte25 set to KCapsMmsTransferStatusEvent.

   820  *		The ClientSideSatProfile shall return with KErrNone.

   821  *		The envelope command MMS TRANSFER STATUS is passed on from ME to UICC successfully.

   822  *

   823  * 	SYMTestType CIT

   824  */

   825 

   826 TInt CSimSatRetMMPCmdTest::testSAT8507L()

   827 	{

   828 

   829 	INFO_PRINTF1(_L("Executing the Test Case TEL-SIMTSY-SAT-8507"));

   830 	

   831 	TRequestStatus reqStatus;

   832 

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

   834 	CleanupStack::PushL(profileV6);

   835 	

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

   837 	CleanupStack::PushL(profileV6Pckg);

   838 

   839 	iSat.GetMeSideSatProfile(reqStatus, *profileV6Pckg);

   840 	User::WaitForRequest(reqStatus);

   841 	TESTL(reqStatus.Int()==KErrNone);

   842 	

   843 	TESTL(profileV6->iSatProfileByte22 & (RSat::KCapsRetrieveMultimediaMessage));

   844 	TESTL(profileV6->iSatProfileByte25 & (RSat::KCapsMmsTransferStatusEvent));

   845 	

   846 	TRequestStatus  trr = KErrNone;

   847 	trr= iSat.ClientSatProfileIndication(*profileV6Pckg);

   848 	TESTL(trr == KErrNone);

   849 		

   850 	RSat::TRetrieveMultimediaMessageV6 *tMMMessageV6 = new (ELeave) RSat::TRetrieveMultimediaMessageV6;

   851 	CleanupStack::PushL(tMMMessageV6);

   852 

   853 	RSat::TRetrieveMultimediaMessageV6Pckg *tMMMessagePckg = new (ELeave) 

   854 		RSat::TRetrieveMultimediaMessageV6Pckg(*tMMMessageV6);

   855 	CleanupStack::PushL(tMMMessagePckg);

   856 

   857 	iSat.NotifyRetrieveMultimediaMsgPCmd(reqStatus,*tMMMessagePckg);

   858 	User::WaitForRequest(reqStatus);

   859 	TESTL(reqStatus.Int()==KErrNone);

   860 	

   861 	RSat::TRetrieveMultimediaMessageRspV6 *tMMMessageRspV6 = new (ELeave) RSat::TRetrieveMultimediaMessageRspV6;

   862 	CleanupStack::PushL(tMMMessageRspV6);

   863 	

   864 	RSat::TRetrieveMultimediaMessageRspV6Pckg *tMMMessageRspPckgV6 = new (ELeave)

   865 	       	RSat::TRetrieveMultimediaMessageRspV6Pckg(*tMMMessageRspV6);

   866 	CleanupStack::PushL(tMMMessageRspPckgV6);

   867 	

   868 	tMMMessageRspV6->iGeneralResult = RSat::KSuccess;

   869 	tMMMessageRspV6->iInfoType = RSat::KNoAdditionalInfo;

   870 	tMMMessageRspV6->SetPCmdNumber(SIMTSY_RET_MM_PCMD_NUMBER);

   871 		

   872 	iSat.TerminalRsp(reqStatus,RSat::ERetrieveMultimediaMsg,*(tMMMessageRspPckgV6));

   873 	User::WaitForRequest(reqStatus);

   874 	TESTL(reqStatus.Int() == KErrNone);

   875 	

   876 	RSat::TMmsTransferStatusV6 *tMMSTransferStsV6 = new (ELeave) RSat::TMmsTransferStatusV6;

   877 	CleanupStack::PushL(tMMSTransferStsV6);

   878 	

   879 	RSat::TMmsTransferStatusV6Pckg *tMMSTransferStsV6Pckg = new (ELeave)

   880 	       	RSat::TMmsTransferStatusV6Pckg(*tMMSTransferStsV6);

   881 	CleanupStack::PushL(tMMSTransferStsV6Pckg);

   882 	

   883 	_LIT(KText,"TransferFilePath");

   884 	TBuf<255> trfFileBuf(KText);

   885 	_LIT(KText1,"MMMessageBuf");

   886 	TBuf<255> trfFileMMMsgBuf(KText1);

   887 	_LIT(KText2,"MMMessageIdentifier");

   888 	TBuf<255> trfFileMMMsgId(KText2);

   889 	

   890 	tMMSTransferStsV6->iDeviceId = RSat::KME;

   891 	tMMSTransferStsV6->iMMSTransferFile = trfFileBuf;

   892 	tMMSTransferStsV6->iMultimediaMessageStatus = trfFileMMMsgBuf;

   893 	tMMSTransferStsV6->iMultimediaMessageId = trfFileMMMsgId ;

   894 	

   895 	iSat.MmsTransferStatus(reqStatus,*tMMSTransferStsV6Pckg);

   896 	User::WaitForRequest(reqStatus);

   897 	TESTL(reqStatus.Int()==KErrNone);

   898 	

   899 	CleanupStack::PopAndDestroy(8);

   900 

   901 	INFO_PRINTF1(_L("Execution of the Test Case TEL-SIMTSY-SAT-8507 - Successful"));

   902 	return KErrNone;

   903 

   904 	}

   905 

   906 

   907 /*

   908  * 	SYMTestCaseID TEL-SIMTSY-NA-8508

   909  *

   910  *	SYMREQ REQ7329 and REQ7334

   911  *

   912  *	SYMTestCaseDesc To verify the event of cancellation of the envelope command for MMS TRANSFER STATUS 

   913  *			envelope command after the RETRIEVE MULTIMEDIA MESSAGE Proactive command is placed.

   914  *

   915  *	SYMTestPriority High

   916  *

   917  *	SYMTestActions 

   918  *		(i)	Client requests notification for RETRIEVE MULTIMEDIA MESSAGE 

   919  *			using NotifyRetrieveMultimediaMsgPCmd () API.

   920  *		(ii)	UICC issues RETRIEVE MULTIMEDIA MESSAGE Command to the ME.

   921  *		(iii)	ME is able to process the MMS transaction and the response is sent 

   922  *			using RSat::TerminalRsp  for NotifyRetrieveMultimediaMsgPCmd.

   923  *		(iv)	Call the API RSat::MMSTransferStatus with the parameter as object of TMMTransferStatusV6.

   924  *		(v)	Cancel the request for the envelope command API placed using 

   925  *			RSat::CancelAsyncRequest(ESatMMTransferStatus).

   926  *		(vi)	ME is able to send the envelope command MULTIMEDIA TRANSFER STATUS 

   927  *		and the response is sent using RSat::TerminalRsp ().

   928  *

   929  *	SYMTestExpectedResults 

   930  *		Client shall be able to cancel the request. The cancel API shall respond with KErrCancel or KErrNone.

   931  * 	SYMTestType CIT

   932  */

   933 

   934 TInt CSimSatRetMMPCmdTest::testSAT8508L()

   935 	{

   936 	

   937 	INFO_PRINTF1(_L("Executing the Test Case TEL-SIMTSY-SAT-8508"));

   938 	

   939 	TRequestStatus reqStatus;

   940 

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

   942 	CleanupStack::PushL(profileV6);

   943 	

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

   945 	CleanupStack::PushL(profileV6Pckg);

   946 

   947 	iSat.GetMeSideSatProfile(reqStatus, *profileV6Pckg);

   948 	User::WaitForRequest(reqStatus);

   949 	TESTL(reqStatus.Int()==KErrNone);

   950 	

   951 	TESTL(profileV6->iSatProfileByte22 & (RSat::KCapsRetrieveMultimediaMessage));

   952 	TESTL(profileV6->iSatProfileByte25 & (RSat::KCapsMmsTransferStatusEvent));

   953 	

   954 	TRequestStatus  trr = KErrNone;

   955 	trr= iSat.ClientSatProfileIndication(*profileV6Pckg);

   956 	TESTL(trr == KErrNone);

   957 		

   958 	RSat::TRetrieveMultimediaMessageV6 *tMMMessageV6 = new (ELeave) RSat::TRetrieveMultimediaMessageV6;

   959 	CleanupStack::PushL(tMMMessageV6);

   960 

   961 	RSat::TRetrieveMultimediaMessageV6Pckg *tMMMessagePckg = new (ELeave)

   962 	       	RSat::TRetrieveMultimediaMessageV6Pckg(*tMMMessageV6);

   963 	CleanupStack::PushL(tMMMessagePckg);

   964 

   965 	iSat.NotifyRetrieveMultimediaMsgPCmd(reqStatus,*tMMMessagePckg);

   966 	User::WaitForRequest(reqStatus);

   967 	TESTL(reqStatus.Int()==KErrNone);

   968 	

   969 	RSat::TRetrieveMultimediaMessageRspV6 *tMMMessageRspV6 = new (ELeave) RSat::TRetrieveMultimediaMessageRspV6;

   970 	CleanupStack::PushL(tMMMessageRspV6);

   971 	

   972 	RSat::TRetrieveMultimediaMessageRspV6Pckg *tMMMessageRspPckgV6 = new (ELeave)

   973 	       	RSat::TRetrieveMultimediaMessageRspV6Pckg(*tMMMessageRspV6);

   974 	CleanupStack::PushL(tMMMessageRspPckgV6);

   975 	

   976 	tMMMessageRspV6->iGeneralResult = RSat::KSuccess;

   977 	tMMMessageRspV6->iInfoType = RSat::KNoAdditionalInfo;

   978 	tMMMessageRspV6->SetPCmdNumber(SIMTSY_RET_MM_PCMD_NUMBER);

   979 		

   980 	iSat.TerminalRsp(reqStatus,RSat::ERetrieveMultimediaMsg,*(tMMMessageRspPckgV6));

   981 	User::WaitForRequest(reqStatus);

   982 	TESTL(reqStatus.Int() == KErrNone);

   983 	

   984 	RSat::TMmsTransferStatusV6 *tMMSTransferStsV6 = new (ELeave) RSat::TMmsTransferStatusV6;

   985 	CleanupStack::PushL(tMMSTransferStsV6);

   986 	

   987 	RSat::TMmsTransferStatusV6Pckg *tMMSTransferStsV6Pckg = new (ELeave) 

   988 		RSat::TMmsTransferStatusV6Pckg(*tMMSTransferStsV6);

   989 	CleanupStack::PushL(tMMSTransferStsV6Pckg);

   990 	

   991 	_LIT(KText,"TransferFilePath");

   992 	TBuf<255> trfFileBuf(KText);

   993 	_LIT(KText1,"MMMessageBuf");

   994 	TBuf<255> trfFileMMMsgBuf(KText1);

   995 	_LIT(KText2,"MMMessageIdentifier");

   996 	TBuf<255> trfFileMMMsgId(KText2);

   997 	

   998 	tMMSTransferStsV6->iDeviceId = RSat::KME;

   999 	tMMSTransferStsV6->iMMSTransferFile = trfFileBuf;

  1000 	tMMSTransferStsV6->iMultimediaMessageStatus = trfFileMMMsgBuf;

  1001 	tMMSTransferStsV6->iMultimediaMessageId = trfFileMMMsgId ;

  1002 	

  1003 	iSat.MmsTransferStatus(reqStatus,*tMMSTransferStsV6Pckg);

  1004 	iSat.CancelAsyncRequest(ESatMmsTransferStatus);

  1005 	User::WaitForRequest(reqStatus);

  1006 	TESTL((reqStatus.Int()==KErrNone) || (reqStatus.Int()==KErrCancel));

  1007 	

  1008 	CleanupStack::PopAndDestroy(8);

  1009 

  1010 	INFO_PRINTF1(_L("Execution of the Test Case TEL-SIMTSY-SAT-8508 - Successful"));

  1011 	return KErrNone;

  1012 	}

  1013 

  1014 

  1015 CSimSatSubMMPCmdTest::CSimSatSubMMPCmdTest() 

  1016 	{ 

  1017 	SetTestStepName(_L("SatTestSubMMPCmd"));

  1018 	}

  1019 

  1020 TVerdict CSimSatSubMMPCmdTest::doTestStepL()

  1021 	{

  1022 	INFO_PRINTF1(_L("SUBMIT MULTIMEDIA PCMD TESTING - START"));

  1023 

  1024  	CreateConfigFileL(_L("c:\\config4.txt"));

  1025  	SetTestNumberL(0);

  1026 

  1027 	TInt ret = iPhone.Open(iTelServer,KPhoneName); 

  1028 	TESTL(ret == KErrNone); 

  1029 	INFO_PRINTF1(_L("Opened phone object"));

  1030 	TESTL(iSat.Open(iPhone)==KErrNone);

  1031 	INFO_PRINTF1(_L("Opened Sat object"));

  1032 

  1033 	testSAT8509L();	// For testing the TEL-SIMTSY-SAT-8509

  1034 	testSAT8510L();	// For testing the TEL-SIMTSY-SAT-8510 

  1035 	testSAT8511L();	// For testing the TEL-SIMTSY-SAT-8511 

  1036 	testSAT8512L();	// For testing the TEL-SIMTSY-SAT-8512 

  1037 	testSAT8513L();	// For testing the TEL-SIMTSY-SAT-8513 

  1038 	testSAT8514L();	// For testing the TEL-SIMTSY-SAT-8514 

  1039 	testSAT8515L();	// For testing the TEL-SIMTSY-SAT-8515

  1040 			

  1041 	iSat.Close();

  1042 	iPhone.Close();

  1043 	ASSERT(RThread().RequestCount()==0);

  1044 	

  1045 	INFO_PRINTF1(_L("SUBMIT MULTIMEDIA PCMD TESTING - END"));

  1046 

  1047 	return TestStepResult();

  1048 	

  1049 	}

  1050 

  1051 

  1052 /*

  1053  * 	SYMTestCaseID TEL-SIMTSY-NA-8509

  1054  *

  1055  * 	SYMREQ REQ7330

  1056  *

  1057  *	SYMTestCaseDesc UICC issues SUBMIT MULTIMEDIA MESSAGE command to ME successfully.

  1058  *

  1059  *	SYMTestPriority High

  1060  *

  1061  *	SYMTestActions 

  1062  *		(i)	Client requests notification for SUBMIT MULTIMEDIA MESSAGE

  1063  *			using RSat::NotifySubmitMultimediaMsgPCmd () API. 

  1064  *		(ii)	UICC issues SUBMIT MULTIMEDIA MESSAGE command to the ME.

  1065  *		(iii)	ME sends Terminal Response to the UICC using RSat::TerminalRsp ().

  1066  *

  1067  * 	SYMTestExpectedResults 

  1068  * 	Client is notified of the request.

  1069  * 	Upon completion of the proactive command details are returned in a packaged version of 

  1070  * 	TSubmitMultimediaMessageV6 in the command parameter. 

  1071  * 	ME responds with KSuccess as the response parameter

  1072  *

  1073  * 	SYMTestType CIT

  1074  */

  1075 

  1076 TInt CSimSatSubMMPCmdTest::testSAT8509L()

  1077 	{

  1078 	

  1079 	INFO_PRINTF1(_L("Executing the Test Case TEL-SIMTSY-SAT-8509"));

  1080 

  1081 	TRequestStatus reqStatus;

  1082 

  1083 	RSat::TSubmitMultimediaMessageV6 *tMMMessageV6 = new (ELeave) RSat::TSubmitMultimediaMessageV6;

  1084 	CleanupStack::PushL(tMMMessageV6);

  1085 

  1086 	RSat::TSubmitMultimediaMessageV6Pckg *tMMMessagePckg = new (ELeave) 

  1087 		RSat::TSubmitMultimediaMessageV6Pckg(*tMMMessageV6);

  1088 	CleanupStack::PushL(tMMMessagePckg);

  1089 

  1090 	iSat.NotifySubmitMultimediaMsgPCmd(reqStatus,*tMMMessagePckg);

  1091 	User::WaitForRequest(reqStatus);

  1092 	TESTL(reqStatus.Int()==KErrNone);

  1093 

  1094 	TESTL(tMMMessageV6->iDestination == SIMTSY_DEVICEID_ME);

  1095 	TESTL(tMMMessageV6->iAlphaId.iStatus == SIMTSY_ALPHAID_STATUS);

  1096 	TESTL(tMMMessageV6->iAlphaId.iAlphaId.Compare(SIMTSY_ALPHAID_BUF) == 0);

  1097 	TESTL(tMMMessageV6->iIconId.iQualifier == SIMTSY_ICONID_QLFR);

  1098 	TESTL(tMMMessageV6->iIconId.iIdentifier == SIMTSY_ICONID_ID);

  1099 	TESTL(tMMMessageV6->iSubmissionFile.Compare(SIMTSY_SUBMISSION_FILES) ==0);

  1100 	TESTL(tMMMessageV6->iMultimediaMessageId.Compare(SIMTSY_MMMSG_ID_DATA) ==0);

  1101 	TESTL(tMMMessageV6->iTextAttribute.iStatus == SIMTSY_TXT_ATTR_STATUS);

  1102 	TESTL(tMMMessageV6->iTextAttribute.iTextAttributeData.Compare(SIMTSY_TXT_ATTR_DATA) ==0);

  1103 	

  1104 	RSat::TSubmitMultimediaMessageRspV6 *tMMMessageRspV6 = new (ELeave) RSat::TSubmitMultimediaMessageRspV6;

  1105 	CleanupStack::PushL(tMMMessageRspV6);

  1106 	

  1107 	RSat::TSubmitMultimediaMessageRspV6Pckg *tMMMessageRspPckgV6 = new (ELeave) 

  1108 		RSat::TSubmitMultimediaMessageRspV6Pckg(*tMMMessageRspV6);

  1109 	CleanupStack::PushL(tMMMessageRspPckgV6);

  1110 	

  1111 	tMMMessageRspV6->iGeneralResult = RSat::KSuccess;

  1112 	tMMMessageRspV6->iInfoType = RSat::KNoAdditionalInfo;

  1113 	tMMMessageRspV6->SetPCmdNumber(SIMTSY_SUB_MM_PCMD_NUMBER);

  1114 		

  1115 	iSat.TerminalRsp(reqStatus,RSat::ESubmitMultimediaMsg,*(tMMMessageRspPckgV6));

  1116 	User::WaitForRequest(reqStatus);

  1117 	TESTL(reqStatus.Int() == KErrNone);

  1118 	

  1119 	CleanupStack::PopAndDestroy(4);

  1120 		

  1121 	INFO_PRINTF1(_L("Execution of the Test Case TEL-SIMTSY-SAT-8509 - Successful"));

  1122 	return KErrNone;

  1123 

  1124 	}

  1125 

  1126 

  1127 /*

  1128  * 	SYMTestCaseID TEL-SIMTSY-NA-8510

  1129  *

  1130  *	SYMREQ REQ7330

  1131  *

  1132  *	SYMTestCaseDesc Submit  Multimedia command rejected by the client as the ME is busy on a MMS transaction

  1133  *	

  1134  *	SYMTestPriority High

  1135  *