smsprotocols/smsstack/test/smsstacktestutilities.cpp
branchRCL_3
changeset 14 7ef16719d8cb
parent 0 3553901f7fa8
child 24 6638e7f4bd8f
child 42 3adadc800673
child 65 630d2f34d719
equal deleted inserted replaced
9:962e6306d9d2 14:7ef16719d8cb
    17 
    17 
    18 /**
    18 /**
    19  @file
    19  @file
    20 */
    20 */
    21 
    21 
       
    22 #include "smsstacktestutilities.h"
       
    23 
    22 #include <commsdattypesv1_1.h>
    24 #include <commsdattypesv1_1.h>
       
    25 #include <commsdattypesv1_1_internal.h>
    23 #include <logcli.h>
    26 #include <logcli.h>
    24 
       
    25 #include "smsstacktestutilities.h"
       
    26 #include <e32math.h>
    27 #include <e32math.h>
       
    28 #include <e32test.h>
       
    29 #include <f32file.h>
       
    30 #include <logwraplimits.h>
       
    31 
    27 #include "smsustrm.h"
    32 #include "smsustrm.h"
    28 #include "Gsmumsg.h"
    33 #include "Gsmumsg.h"
    29 #include "smsuaddr.H"
    34 #include "smsuaddr.H"
    30 #include "gsmubuf.h"
    35 #include "gsmubuf.h"
    31 
       
    32 #include "smspdudb.h"
    36 #include "smspdudb.h"
    33 #include <e32test.h>
       
    34 #include <f32file.h>
       
    35 #include "SmsuTimer.h"
    37 #include "SmsuTimer.h"
    36 #include "smsstacklog.h"
    38 #include "smsstacklog.h"
    37 #include <logwraplimits.h>
       
    38 
    39 
    39 using namespace CommsDat;
    40 using namespace CommsDat;
    40 
       
    41 
    41 
    42 // Check a boolean is true
    42 // Check a boolean is true
    43 #define LOCAL_CHECKPOINT(a) iTestStep->testBooleanTrue((a), (TText8*)__FILE__, __LINE__)
    43 #define LOCAL_CHECKPOINT(a) iTestStep->testBooleanTrue((a), (TText8*)__FILE__, __LINE__)
    44 
    44 
    45 // Check a boolean is true if not return error code b
    45 // Check a boolean is true if not return error code b
    53 #define PRINTF4(p1, p2, p3, p4)				iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4))
    53 #define PRINTF4(p1, p2, p3, p4)				iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4))
    54 #define PRINTF5(p1, p2, p3, p4, p5)			iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4), (p5))
    54 #define PRINTF5(p1, p2, p3, p4, p5)			iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4), (p5))
    55 #define PRINTF6(p1, p2, p3, p4, p5, p6)		iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4), (p5), (p6))
    55 #define PRINTF6(p1, p2, p3, p4, p5, p6)		iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4), (p5), (p6))
    56 #define PRINTF7(p1, p2, p3, p4, p5, p6, p7)	iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4), (p5), (p6), (p7))
    56 #define PRINTF7(p1, p2, p3, p4, p5, p6, p7)	iTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2), (p3), (p4), (p5), (p6), (p7))
    57 
    57 
    58 
       
    59 class CTSmsRegTstActive : public CActive
    58 class CTSmsRegTstActive : public CActive
    60 	{
    59 	{
    61 public:
    60 public:
    62 	CTSmsRegTstActive();
    61 	CTSmsRegTstActive();
    63 	~CTSmsRegTstActive();
    62 	~CTSmsRegTstActive();
   117 CSmsStackTestUtils::CSmsStackTestUtils(CTestStep* aTestStep, RFs& aFs)
   116 CSmsStackTestUtils::CSmsStackTestUtils(CTestStep* aTestStep, RFs& aFs)
   118 : iTestStep(aTestStep), iFs(aFs)
   117 : iTestStep(aTestStep), iFs(aFs)
   119 	{
   118 	{
   120 	}
   119 	}
   121 
   120 
   122 EXPORT_C void CSmsStackTestUtils::WaitForInitializeL()
       
   123 /**
       
   124  *  Initialize the phone for the tsy. This will prevent message sends from completing with KErrNotReady
       
   125  */
       
   126 	{
       
   127 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY
       
   128 	CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);
       
   129 #else
       
   130 	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);
       
   131 #endif
       
   132 
       
   133 	CleanupStack::PushL(db);
       
   134 
       
   135 	TName tsy;
       
   136 	TUint32 modemId = 0;
       
   137 
       
   138 	CMDBField<TUint32>* globalSettingsField = new(ELeave) CMDBField<TUint32>(KCDTIdModemPhoneServicesSMS);
       
   139 	CleanupStack::PushL(globalSettingsField);
       
   140 	globalSettingsField->SetRecordId(1);
       
   141 	globalSettingsField->LoadL(*db);
       
   142 	modemId = *globalSettingsField;
       
   143 	CleanupStack::PopAndDestroy(globalSettingsField);
       
   144 
       
   145 	CMDBField<TDesC>* tsyField = new(ELeave) CMDBField<TDesC>(KCDTIdTsyName);
       
   146 	CleanupStack::PushL(tsyField);
       
   147 	tsyField->SetRecordId(modemId);
       
   148 	tsyField->SetMaxLengthL(KMaxTextLength);
       
   149 	tsyField->LoadL(*db);
       
   150 	tsy = *tsyField;
       
   151 	CleanupStack::PopAndDestroy(tsyField);
       
   152 
       
   153 	CleanupStack::PopAndDestroy(db);
       
   154 
       
   155 	PRINTF2(_L("Loading TSY \"%S\"..."), &tsy);
       
   156 
       
   157 	RTelServer server;
       
   158 	User::LeaveIfError(server.Connect());
       
   159 	CleanupClosePushL(server);
       
   160 	User::LeaveIfError(server.LoadPhoneModule(tsy));
       
   161 
       
   162 	// Find the phone corresponding to this TSY and open a number of handles on it
       
   163 	TInt numPhones;
       
   164 	User::LeaveIfError(server.EnumeratePhones(numPhones));
       
   165 	RPhone phone;
       
   166 	TBool found=EFalse;
       
   167 
       
   168 	while (numPhones--)
       
   169 		{
       
   170 		TName phoneTsy;
       
   171 		User::LeaveIfError(server.GetTsyName(numPhones,phoneTsy));
       
   172 		if (phoneTsy.CompareF(tsy)==KErrNone)
       
   173 			{
       
   174 			PRINTF1(_L("Found RPhone..."));
       
   175 			found = ETrue;
       
   176 			RTelServer::TPhoneInfo info;
       
   177 			User::LeaveIfError(server.GetPhoneInfo(numPhones,info));
       
   178 			User::LeaveIfError(phone.Open(server,info.iName));
       
   179 			CleanupClosePushL(phone);
       
   180 			PRINTF1(_L("Initializing..."));
       
   181 			const TInt err = phone.Initialise();
       
   182 			TTimeIntervalMicroSeconds32 InitPause=9000000;  //Required Pause to Allow SMSStack to Complete its Async Init
       
   183 			User::After(InitPause);							//call to the TSY and finish its StartUp.
       
   184 			PRINTF2(_L("Completed Initialize [err=%d]"), err);
       
   185 			User::LeaveIfError(err);
       
   186 			CleanupStack::PopAndDestroy(&phone);
       
   187 			break;
       
   188 			}
       
   189 		}
       
   190 
       
   191 	LOCAL_CHECKPOINT(found);
       
   192 	CleanupStack::PopAndDestroy(&server);
       
   193 	}
       
   194 
   121 
   195 EXPORT_C void CSmsStackTestUtils::OpenSmsSocketLC(RSocketServ& aSocketServer, RSocket& aSocket, TSmsAddrFamily aFamily)
   122 EXPORT_C void CSmsStackTestUtils::OpenSmsSocketLC(RSocketServ& aSocketServer, RSocket& aSocket, TSmsAddrFamily aFamily)
   196 /**
   123 /**
   197  *  Initialise an RSocket for SMS
   124  *  Initialise an RSocket for SMS
   198  *  @note aSocket is pushed to CleanupStack.
   125  *  @note aSocket is pushed to CleanupStack.
   228  */
   155  */
   229 	{
   156 	{
   230 	OpenSmsSocketL(aSocketServer, aSocket, aSmsAddr);
   157 	OpenSmsSocketL(aSocketServer, aSocket, aSmsAddr);
   231 	CleanupClosePushL(aSocket);
   158 	CleanupClosePushL(aSocket);
   232 	}
   159 	}
   233 
       
   234 
   160 
   235 EXPORT_C void CSmsStackTestUtils::OpenSmsSocketL(RSocketServ& aSocketServer, RSocket& aSocket, TSmsAddr& aSmsAddr)
   161 EXPORT_C void CSmsStackTestUtils::OpenSmsSocketL(RSocketServ& aSocketServer, RSocket& aSocket, TSmsAddr& aSmsAddr)
   236 /**
   162 /**
   237  *  Initialise an RSocket for SMS, aSocket is NOT pushed to CleanupStack.
   163  *  Initialise an RSocket for SMS, aSocket is NOT pushed to CleanupStack.
   238  *  @param aSocketServer reference to the socket server object
   164  *  @param aSocketServer reference to the socket server object
   245 	LOCAL_CHECKPOINT(ret == KErrNone);
   171 	LOCAL_CHECKPOINT(ret == KErrNone);
   246 	CleanupClosePushL(aSocket);
   172 	CleanupClosePushL(aSocket);
   247 	ret=aSocket.Bind(aSmsAddr);
   173 	ret=aSocket.Bind(aSmsAddr);
   248 	PRINTF2(_L("Socket Bind Return Value : %d"),ret);
   174 	PRINTF2(_L("Socket Bind Return Value : %d"),ret);
   249 	LOCAL_CHECKPOINT(ret == KErrNone);
   175 	LOCAL_CHECKPOINT(ret == KErrNone);
   250 	WaitForInitializeL();
   176 	
       
   177 	TProtocolDesc desc;
       
   178 	aSocket.Info(desc);
       
   179 	PRINTF2(_L("Protocol name: %S"), &desc.iName);
       
   180 	
       
   181     TTimeIntervalMicroSeconds32 InitPause=9000000;  //Required Pause to Allow SMSStack to Complete its Async Init
       
   182     User::After(InitPause);                         //call to the TSY and finish its StartUp.
       
   183 
   251 	CleanupStack::Pop(&aSocket);
   184 	CleanupStack::Pop(&aSocket);
   252 	}
   185 	}
   253 
   186 
   254 EXPORT_C void CSmsStackTestUtils::SendSmsAndChangeBearerL(CSmsMessage* aSms, RSocket& aSocket, RMobileSmsMessaging::TMobileSmsBearer aBearer)
   187 EXPORT_C void CSmsStackTestUtils::SendSmsAndChangeBearerL(CSmsMessage* aSms, RSocket& aSocket, RMobileSmsMessaging::TMobileSmsBearer aBearer)
   255 /**
   188 /**
   265 	RSmsSocketWriteStream writestream(aSocket);
   198 	RSmsSocketWriteStream writestream(aSocket);
   266 	TRAPD(ret,writestream << *aSms);
   199 	TRAPD(ret,writestream << *aSms);
   267 	LOCAL_CHECKPOINT(ret == KErrNone);
   200 	LOCAL_CHECKPOINT(ret == KErrNone);
   268 	TRAP(ret,writestream.CommitL());
   201 	TRAP(ret,writestream.CommitL());
   269 	LOCAL_CHECKPOINT(ret == KErrNone);
   202 	LOCAL_CHECKPOINT(ret == KErrNone);
   270 
   203 	
   271     // Create comms database object
   204     // Create comms database object
   272 	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);
   205     CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);
   273 	CleanupStack::PushL(db);
   206     CleanupStack::PushL(db);
   274 
   207 
   275  	//Send message and change bearer
   208  	//Send message and change bearer
   276 	TPckgBuf<TUint> sbuf;
   209 	TPckgBuf<TUint> sbuf;
   277 	TRequestStatus status;
   210 	TRequestStatus status;
   278 	aSocket.Ioctl(KIoctlSendSmsMessage,status,&sbuf, KSolSmsProv);
   211 	aSocket.Ioctl(KIoctlSendSmsMessage, status, &sbuf, KSolSmsProv);
   279 
   212 
   280 	//Wait couple of seconds to ensure first pdus of message have been sent
   213 	//Wait couple of seconds to ensure first pdus of message have been sent
   281 	User::After(2500000);
   214 	User::After(2500000);
   282 
   215 
   283 	// Change bearer
   216     // Change bearer
   284 	CMDBField<TUint32>* smsBearerField = new(ELeave) CMDBField<TUint32>(KCDTIdSMSBearer);
   217     CMDBField<TUint32>* smsBearerField = new(ELeave) CMDBField<TUint32>(KCDTIdSMSBearer);
   285 	CleanupStack::PushL(smsBearerField);
   218     CleanupStack::PushL(smsBearerField);
   286 	smsBearerField->SetRecordId(1); //it's GlobalSettingsRecord
   219     smsBearerField->SetRecordId(1); //it's GlobalSettingsRecord
   287 	*smsBearerField = aBearer;
   220     *smsBearerField = aBearer;
   288 	smsBearerField->ModifyL(*db);
   221     smsBearerField->ModifyL(*db);
   289 	CleanupStack::PopAndDestroy(smsBearerField);
   222     CleanupStack::PopAndDestroy(smsBearerField);
   290 	CleanupStack::PopAndDestroy(db);
   223     CleanupStack::PopAndDestroy(db);
   291 
   224 
   292 	User::WaitForRequest(status);
   225 	User::WaitForRequest(status);
   293 	PRINTF2(_L("SendSmsL - sendSmsMessage returned %d"), status.Int());
   226 	PRINTF2(_L("SendSmsL - sendSmsMessage returned %d"), status.Int());
   294 	LOCAL_CHECKPOINT(status.Int() == KErrNone);
   227 	LOCAL_CHECKPOINT(status.Int() == KErrNone);
   295 
   228 
   308 
   241 
   309 @param aBearer The new bearer setting.
   242 @param aBearer The new bearer setting.
   310 @return none
   243 @return none
   311 */
   244 */
   312 	{
   245 	{
   313 	// Start a CommDB session
   246     // Start a CommDB session
   314 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY
   247 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY
   315 	CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);
   248     CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);
   316 #else
   249 #else
   317 	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);
   250     CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);
   318 #endif
   251 #endif
   319 	CleanupStack::PushL(db);
   252     CleanupStack::PushL(db);
   320 	
   253     
   321 	// Change bearer in global settings
   254     // Change bearer in global settings
   322 	CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);
   255     CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);
   323 	TRAPD(err, globalSettingsRecord.LoadL(*db));
   256     TRAPD(err, globalSettingsRecord.LoadL(*db));
   324 	if (err != KErrNone)
   257     if (err != KErrNone)
   325 		{
   258         {
   326 		PRINTF2(_L("Could not load global settings. Error = %d\n"), err);
   259         PRINTF2(_L("Could not load global settings. Error = %d\n"), err);
   327 		User::Leave(err);
   260         User::Leave(err);
   328 		}
   261         }
   329 	((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iSMSBearer = aBearer;
   262     ((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iSMSBearer = aBearer;
   330 	globalSettingsRecord.ModifyL(*db);
   263     globalSettingsRecord.ModifyL(*db);
   331 	
   264     
   332 	PRINTF2(_L("Setting bearer in global settings to %d\n"), aBearer); 
   265     PRINTF2(_L("Setting bearer in global settings to %d\n"), aBearer); 
   333 	
   266     
   334 	CleanupStack::PopAndDestroy(db);
   267     CleanupStack::PopAndDestroy(db);
   335 	}
   268 	}
   336 
   269 
   337 EXPORT_C void CSmsStackTestUtils::GetBearerL(RMobileSmsMessaging::TMobileSmsBearer& aBearer)
   270 EXPORT_C void CSmsStackTestUtils::GetBearerL(RMobileSmsMessaging::TMobileSmsBearer& aBearer)
   338 /**
   271 /**
   339 Get the bearer from CommDB global settings.
   272 Get the bearer from CommDB global settings.
   340 
   273 
   341 @param aBearer The bearer setting retrieved from global settings.
   274 @param aBearer The bearer setting retrieved from global settings.
   342 @return none
   275 @return none
   343 */
   276 */
   344 	{
   277     {
   345 	// Start a CommDB session
   278     // Start a CommDB session
   346 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY
   279 #ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY
   347 	CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);
   280     CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);
   348 #else
   281 #else
   349 	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);
   282     CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);
   350 #endif
   283 #endif
   351 	CleanupStack::PushL(db);
   284     CleanupStack::PushL(db);
   352 	
   285     
   353 	// Load global settings
   286     // Load global settings
   354 	CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);
   287     CMDBRecordSet<CCDGlobalSettingsRecord> globalSettingsRecord(KCDTIdGlobalSettingsRecord);
   355 	TRAPD(err, globalSettingsRecord.LoadL(*db));
   288     TRAPD(err, globalSettingsRecord.LoadL(*db));
   356 	if (err != KErrNone)
   289     if (err != KErrNone)
   357 		{
   290         {
   358 		PRINTF2(_L("Could not load global settings. Error = %d\n"), err);
   291         PRINTF2(_L("Could not load global settings. Error = %d\n"), err);
   359 		User::Leave(err);
   292         User::Leave(err);
   360 		}
   293         }
   361 	TInt tempBearer = ((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iSMSBearer;
   294     TInt tempBearer = ((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iSMSBearer;
   362 	aBearer = static_cast<RMobileSmsMessaging::TMobileSmsBearer>(tempBearer);
   295     aBearer = static_cast<RMobileSmsMessaging::TMobileSmsBearer>(tempBearer);
   363 	PRINTF2(_L("Got bearer from CommDB. Bearer = %d\n"), aBearer);
   296     PRINTF2(_L("Got bearer from CommDB. Bearer = %d\n"), aBearer);
   364 	
   297     
   365 	CleanupStack::PopAndDestroy(db);
   298     CleanupStack::PopAndDestroy(db);
   366 	}
   299     }
   367 
   300 
   368 EXPORT_C void CSmsStackTestUtils::DisableLogging()
   301 EXPORT_C void CSmsStackTestUtils::DisableLogging()
   369  	{
   302  	{
   370  	CTSmsRegTstActive* testActive = new(ELeave)CTSmsRegTstActive();
   303  	CTSmsRegTstActive* testActive = new(ELeave)CTSmsRegTstActive();
   371  	CleanupStack::PushL(testActive);
   304  	CleanupStack::PushL(testActive);
   387  	testActive->StartL();
   320  	testActive->StartL();
   388  	logClient.ChangeConfig(config, testActive->iStatus);
   321  	logClient.ChangeConfig(config, testActive->iStatus);
   389  	CActiveScheduler::Start();
   322  	CActiveScheduler::Start();
   390  	LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);
   323  	LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);
   391  	
   324  	
   392  	CleanupStack::PopAndDestroy(logWrapper);	
   325  	CleanupStack::PopAndDestroy(2, testActive); // testActive, logWrapper
   393  	CleanupStack::PopAndDestroy(testActive);
       
   394 	}
   326 	}
   395  
   327  
   396  EXPORT_C void CSmsStackTestUtils::EnableLogging()
   328  EXPORT_C void CSmsStackTestUtils::EnableLogging()
   397  	{
   329     {
   398  	CTSmsRegTstActive* testActive = new(ELeave)CTSmsRegTstActive();
   330     CTSmsRegTstActive* testActive = new(ELeave)CTSmsRegTstActive();
   399  	CleanupStack::PushL(testActive);
   331     CleanupStack::PushL(testActive);
   400  	testActive->StartL();	
   332     testActive->StartL();	
   401  
   333     
   402  	CLogWrapper* logWrapper=CLogWrapper::NewL(iFs);
   334     CLogWrapper* logWrapper=CLogWrapper::NewL(iFs);
   403  	CleanupStack::PushL(logWrapper);
   335     CleanupStack::PushL(logWrapper);
   404  	CLogClient& logClient = static_cast<CLogClient&> (logWrapper->Log());
   336     CLogClient& logClient = static_cast<CLogClient&> (logWrapper->Log());
   405  	TLogConfig config;
   337     TLogConfig config;
   406  	logClient.GetConfig(config, testActive->iStatus);
   338     logClient.GetConfig(config, testActive->iStatus);
   407  	CActiveScheduler::Start();
   339     CActiveScheduler::Start();
   408  	LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);
   340     LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);
   409  
   341     
   410  	// Enable logging
   342     // Enable logging - default values
   411  	config.iMaxEventAge = 10000;
   343     config.iMaxEventAge = 2592000;
   412  	config.iMaxLogSize  = 10000; 
   344     config.iMaxLogSize  = 1000; 
   413  	config.iMaxRecentLogSize = 127; 
   345     config.iMaxRecentLogSize = 20; 
   414  	
   346     
   415  	testActive->StartL();	
   347     testActive->StartL();	
   416  	logClient.ChangeConfig(config, testActive->iStatus);
   348     logClient.ChangeConfig(config, testActive->iStatus);
   417  	CActiveScheduler::Start();
   349     CActiveScheduler::Start();
   418  	LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);
   350     LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);
   419  	
   351     
   420  	CleanupStack::PopAndDestroy(logWrapper);	
   352     CleanupStack::PopAndDestroy(2, testActive); // testActive, logWrapper
   421  	CleanupStack::PopAndDestroy(testActive);
   353     }		
   422  }		
       
   423 	
       
   424 	
   354 	
   425 EXPORT_C void CSmsStackTestUtils::GetLogEventL(CLogEvent& aLogEvent, TInt aLogServerId)
   355 EXPORT_C void CSmsStackTestUtils::GetLogEventL(CLogEvent& aLogEvent, TInt aLogServerId)
   426 /**
   356 /**
   427  *  Get SMS log event from event logger.
   357  *  Get SMS log event from event logger.
   428  *  @param aLogEvent reference to the CLogEvent object
   358  *  @param aLogEvent reference to the CLogEvent object
   438 	aLogEvent.SetId(aLogServerId);
   368 	aLogEvent.SetId(aLogServerId);
   439 	testActive->StartL();
   369 	testActive->StartL();
   440 	logWrapper->Log().GetEvent(aLogEvent,testActive->iStatus);
   370 	logWrapper->Log().GetEvent(aLogEvent,testActive->iStatus);
   441 	CActiveScheduler::Start();
   371 	CActiveScheduler::Start();
   442 	LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);
   372 	LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);
   443 	CleanupStack::PopAndDestroy(2);	// testActive, logWrapper
   373 	
       
   374     CleanupStack::PopAndDestroy(2, testActive); // testActive, logWrapper
   444 	}
   375 	}
   445 
   376 
   446 EXPORT_C TLogId CSmsStackTestUtils::AddLogEventL(CSmsMessage& aSmsMessage,TLogSmsPduData& aSmsPDUData)
   377 EXPORT_C TLogId CSmsStackTestUtils::AddLogEventL(CSmsMessage& aSmsMessage,TLogSmsPduData& aSmsPDUData)
   447 /**
   378 /**
   448  *  Add SMS log event to the event logger.
   379  *  Add SMS log event to the event logger.
   476 
   407 
   477 		logevent->SetSubject(_L("test"));
   408 		logevent->SetSubject(_L("test"));
   478 		logevent->SetStatus(_L("status"));
   409 		logevent->SetStatus(_L("status"));
   479 		TPckg<TLogSmsPduData> packeddata(aSmsPDUData);
   410 		TPckg<TLogSmsPduData> packeddata(aSmsPDUData);
   480 		logevent->SetDataL(packeddata);
   411 		logevent->SetDataL(packeddata);
   481 
   412 		
       
   413 		PRINTF2(_L("iStatus is %d"), testActive->iStatus.Int());
   482 		logWrapper->Log().AddEvent(*logevent,testActive->iStatus);
   414 		logWrapper->Log().AddEvent(*logevent,testActive->iStatus);
   483 		CActiveScheduler::Start();
   415 		CActiveScheduler::Start();
       
   416 		PRINTF2(_L("iStatus is %d"), testActive->iStatus.Int());
   484 		LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);
   417 		LOCAL_CHECKPOINT(testActive->iStatus.Int() == KErrNone);
   485 		id=logevent->Id();
   418 		id=logevent->Id();
   486 		CleanupStack::PopAndDestroy(logevent);
   419 		CleanupStack::PopAndDestroy(logevent);
   487 	}
   420 	}
   488 
   421 
   489 	CleanupStack::PopAndDestroy(2);	// testActive, logWrapper
   422     CleanupStack::PopAndDestroy(2, testActive); // testActive, logWrapper
   490 	return id;
   423 	return id;
   491 	}
   424 	}
   492 
   425 
   493 
   426 
   494 EXPORT_C void CSmsStackTestUtils::CopyConfigFileL(const TDesC& aFromSmsConfigFile, CSmsPduDatabase* aPduDb)
   427 EXPORT_C void CSmsStackTestUtils::CopyConfigFileL(const TDesC& aFromSmsConfigFile, CSmsPduDatabase* aPduDb)
   618 		smsTx->Des().AppendFormat(KSmspTestUtilsSmsTxFormat, pduBuf, sc, aMsgRef, submitReport, aExpectedError);
   551 		smsTx->Des().AppendFormat(KSmspTestUtilsSmsTxFormat, pduBuf, sc, aMsgRef, submitReport, aExpectedError);
   619 
   552 
   620 		CTestConfigItem* item = CTestConfigItem::NewLC(section, KSmspTestUtilsSmsTx, *smsTx);
   553 		CTestConfigItem* item = CTestConfigItem::NewLC(section, KSmspTestUtilsSmsTx, *smsTx);
   621 
   554 
   622 		User::LeaveIfError(section.Items().Append(item));
   555 		User::LeaveIfError(section.Items().Append(item));
   623 
   556 			
   624 		CleanupStack::Pop(item);
   557 		CleanupStack::Pop(item);
   625 		CleanupStack::PopAndDestroy(smsTx);
   558         CleanupStack::PopAndDestroy(3, pduBuf); // smsTx, sc, pduBuf
   626 		CleanupStack::PopAndDestroy(sc);
       
   627 		CleanupStack::PopAndDestroy(pduBuf);
       
   628 		}
   559 		}
   629 
   560 
   630 	CleanupStack::PopAndDestroy(submitReport);
   561 	CleanupStack::PopAndDestroy(2, pdus); // pdus, submitReport
   631 	CleanupStack::PopAndDestroy(pdus);
       
   632 	}
   562 	}
   633 
   563 
   634 EXPORT_C HBufC8* CSmsStackTestUtils::ConvertToHexLC(const TDesC8& aDes) const
   564 EXPORT_C HBufC8* CSmsStackTestUtils::ConvertToHexLC(const TDesC8& aDes) const
   635 	{
   565 	{
   636 	const TInt len = aDes.Length();
   566 	const TInt len = aDes.Length();
   640 
   570 
   641 	for (TInt i = 0; i < len; i++)
   571 	for (TInt i = 0; i < len; i++)
   642 		{
   572 		{
   643 		value.AppendFormat(_L8("%02X"), aDes[i]);
   573 		value.AppendFormat(_L8("%02X"), aDes[i]);
   644 		}
   574 		}
   645 
       
   646 	return hBuf;
   575 	return hBuf;
   647 	}
   576 	}
   648 
   577 
   649 CArrayFixFlat<TGsmSms>* CSmsStackTestUtils::EncodeMessageLC(CSmsMessage& aMessage) const
   578 CArrayFixFlat<TGsmSms>* CSmsStackTestUtils::EncodeMessageLC(CSmsMessage& aMessage) const
   650 	{
   579 	{
   699 	pdu.SetLength(ptr1 - ptr0);
   628 	pdu.SetLength(ptr1 - ptr0);
   700 	aPdu.SetPdu(pdu);
   629 	aPdu.SetPdu(pdu);
   701 
   630 
   702 	CleanupStack::PopAndDestroy(addr);
   631 	CleanupStack::PopAndDestroy(addr);
   703 	}
   632 	}
   704 
       
   705 
   633 
   706 /**
   634 /**
   707  *  This is a unit test for class TSmsServiceCenterTimeStamp.  It is added to this utility
   635  *  This is a unit test for class TSmsServiceCenterTimeStamp.  It is added to this utility
   708  *  class because it has access to TSmsServiceCenterTimeStamp.  TSmsServiceCenterTimeStamp is not exported
   636  *  class because it has access to TSmsServiceCenterTimeStamp.  TSmsServiceCenterTimeStamp is not exported
   709  *  out of the gsmsu.dll.  This is why this project compiles with gsmsuelem.cpp.
   637  *  out of the gsmsu.dll.  This is why this project compiles with gsmsuelem.cpp.
  1905             break;
  1833             break;
  1906             }
  1834             }
  1907         }
  1835         }
  1908     }
  1836     }
  1909 
  1837 
  1910 
       
  1911 
       
  1912 
       
  1913 //
  1838 //
  1914 //             CTestGetSmsList
  1839 // CTestGetSmsList
  1915 //
  1840 //
  1916 
  1841 
  1917 EXPORT_C CTestGetSmsList* CTestGetSmsList::NewL(TInt aPriority, RSocketServ& aSocketServer, CSmsStackTestUtils& aTestUtils)
  1842 EXPORT_C CTestGetSmsList* CTestGetSmsList::NewL(TInt aPriority, RSocketServ& aSocketServer, CSmsStackTestUtils& aTestUtils)
  1918 	{
  1843 	{
  1919 	CTestGetSmsList* smsListGetter = new(ELeave) CTestGetSmsList(aPriority, aSocketServer, aTestUtils);
  1844 	CTestGetSmsList* smsListGetter = new(ELeave) CTestGetSmsList(aPriority, aSocketServer, aTestUtils);
  1921 	smsListGetter->ConstructL();
  1846 	smsListGetter->ConstructL();
  1922 	CleanupStack::Pop(smsListGetter);
  1847 	CleanupStack::Pop(smsListGetter);
  1923 	return smsListGetter;
  1848 	return smsListGetter;
  1924 	}
  1849 	}
  1925 
  1850 
  1926 CTestGetSmsList::CTestGetSmsList(TInt aPriority, RSocketServ& aSocketServer, CSmsStackTestUtils& aTestUtils)
  1851 EXPORT_C CTestGetSmsList::CTestGetSmsList(TInt aPriority, RSocketServ& aSocketServer, CSmsStackTestUtils& aTestUtils)
  1927 /**
       
  1928  *  Constructor
       
  1929  *  
       
  1930  *   *
       
  1931  */
       
  1932 : CSmsuActiveBase(aPriority), //parent construction
  1852 : CSmsuActiveBase(aPriority), //parent construction
  1933 iSocketServer(aSocketServer),
  1853 iSocketServer(aSocketServer),
  1934 iTestUtils(aTestUtils)
  1854 iTestUtils(aTestUtils)
  1935 	{
  1855 	{
  1936 	}
  1856 	}