1 // Copyright (c) 2000-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 "T_SmcmFail.h"

    17 #include <biodb.h>

    18 

    19 GLDEF_C TInt E32Main()

    20 	{	

    21 	__UHEAP_MARK;

    22 	test.Start(_L("Setup"));

    23 	theCleanup = CTrapCleanup::New();

    24 	TRAPD(ret,doMainL());		

    25 	test(ret==KErrNone);

    26 	delete theCleanup;	

    27 	test.Console()->SetPos(0, 13);

    28 	test.End();

    29 	test.Close();

    30 	__UHEAP_MARKEND;

    31 	return(KErrNone);

    32 	}

    33 

    34 LOCAL_C void doMainL()

    35 	{

    36 	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

    37 	CleanupStack::PushL(scheduler);

    38 	CActiveScheduler::Install(scheduler);

    39 

    40 	CSmsTestUtils* smsTest = CSmsTestUtils::NewL(test);

    41 	CleanupStack::PushL(smsTest);

    42 	TInt nextTest = 0;

    43 

    44 	CSmcmFailTest* SmcmTest = CSmcmFailTest::NewL(*smsTest, KNullDesC, nextTest);

    45 	CleanupStack::PushL(SmcmTest);

    46 

    47 	SmcmTest->StartL();

    48 

    49 	CleanupStack::PopAndDestroy(3); //SmcmTest. scheduler

    50 	}

    51 

    52 CSmcmFailTest::CSmcmFailTest(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aCurrentTest)

    53 : CSmsTestBase(aSmsTest, aScriptFile, aCurrentTest)

    54 	{

    55 	}

    56 

    57 void CSmcmFailTest::RunAutoL()

    58 	{

    59 	iSmsTest.TestStart(++iNextTest, _L("CSmsSettings Fail"));

    60 	TestSettingsFailL();

    61 	iSmsTest.TestFinish(iNextTest);

    62 

    63 	iSmsTest.TestStart(++iNextTest, _L("CSmsNumber Fail"));

    64 	TestNumberFailL();

    65 	iSmsTest.TestFinish(iNextTest);

    66 

    67 	iSmsTest.TestStart(++iNextTest, _L("CSmsHeader Fail"));

    68 	TestHeaderFailL();

    69 	iSmsTest.TestFinish(iNextTest);

    70 

    71 	iSmsTest.TestStart(++iNextTest, _L("Load Fail"));

    72 	TestLoadFailL(); //Cannot be done 'cause of defect in message server

    73 	iSmsTest.TestFinish(iNextTest);

    74 

    75 	iSmsTest.TestStart(++iNextTest, _L("Save Fail"));

    76 	TestSaveFailL(); //Cannot be done 'cause of defect in message server

    77 	iSmsTest.TestFinish(iNextTest);

    78 

    79 	iSmsTest.TestStart(++iNextTest, _L("Addressee Fail"));

    80 	TestAddresseeFailL(); //Cannot be done 'cause of defect in message server

    81 	iSmsTest.TestFinish(iNextTest);

    82 

    83 	iSmsTest.TestStart(++iNextTest, _L("Bio Fail"));

    84 	this->TestBifFailL();

    85 	iSmsTest.TestFinish(iNextTest);

    86 

    87 

    88 	iSmsTest.TestStart(++iNextTest, _L("Reply Fail"));

    89 	TestReplyFailL();

    90 	iSmsTest.TestFinish(iNextTest);

    91 

    92 	iSmsTest.TestStart(++iNextTest, _L("Forward Fail"));

    93 	TestForwardFailL(); //Cannot be done 'cause of defect in message server

    94 	iSmsTest.TestFinish(iNextTest);

    95 	}

    96 

    97 CSmcmFailTest::~CSmcmFailTest()

    98 	{

    99 	delete iRichText;

   100 	delete iParaLayer;

   101 	delete iCharLayer;

   102 	}

   103 

   104 void CSmcmFailTest::ConstructL()

   105 	{

   106 	iSmsTest.SetLogToFile();

   107 	iSmsTest.InstantiateClientMtmsL();

   108 

   109 	iSelection = new (ELeave) CMsvEntrySelection();

   110 	iTimer = CTestTimer::NewL();

   111 

   112 	iParaLayer =CParaFormatLayer::NewL();

   113 	iCharLayer = CCharFormatLayer::NewL();

   114 	iRichText = CRichText::NewL(iParaLayer, iCharLayer, CEditableText::EFlatStorage,256);

   115 

   116 	CActiveScheduler::Add(this);

   117 	}

   118 

   119 CSmcmFailTest* CSmcmFailTest::NewL(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aCurrentTest)

   120 	{

   121 	CSmcmFailTest* self = new (ELeave) CSmcmFailTest(aSmsTest, aScriptFile, aCurrentTest);

   122 	CleanupStack::PushL(self);

   123 

   124 	self->ConstructL();

   125 

   126 	CleanupStack::Pop();

   127 	return self;

   128 	}

   129 

   130 void CSmcmFailTest::ShowMenuL()

   131 	{

   132 	iSmsTest.ResetMenu();

   133 

   134 	iSmsTest.AppendToMenuL(_L("Start"));

   135 

   136 	TInt result = iSmsTest.DisplayMenu(_L("SMS Client MTM Test"));

   137 

   138 	if (result <= 0)

   139 		return;

   140 

   141 	switch (result)

   142 		{

   143 		case 1:

   144 			RunAutoL();

   145 			break;

   146 		default:

   147 			User::Leave(KErrArgument);

   148 			break;

   149 		}

   150 

   151 	if (!iSmsTest.RunAuto())

   152 		{

   153 		iSmsTest.Printf(_L("Press any key to continue...\n"));

   154 		test.Getch();

   155 		}

   156 

   157 	ShowMenuL();

   158 	}

   159 

   160 void CSmcmFailTest::TestSettingsFailL()

   161 	{

   162 	CSmsSettings* settings = NULL;

   163 

   164 	TInt error;

   165 	TInt failCount = 0;

   166 

   167 	//Failure Test CSmsSettings::NewL

   168 	do

   169 		{

   170 		__UHEAP_FAILNEXT(failCount++);

   171 

   172 		TRAP(error, settings = CSmsSettings::NewL());

   173 

   174 		__UHEAP_RESET;

   175 

   176 		if (error)

   177 			{

   178 			test(error == KErrNoMemory);

   179 			}

   180 

   181 		}

   182 	while (error);

   183 

   184 	iSmsTest.Printf(_L("CSmsSettings::NewL Fail Count %d\n"), failCount);

   185 	CleanupStack::PushL(settings);

   186 

   187 	failCount = 0;

   188 

   189 	//Failure Test CSmsSettings::AddServiceCenterL()

   190 	do

   191 		{

   192 		__UHEAP_FAILNEXT(failCount++);

   193 

   194 		TInt scCount = settings->ServiceCenterCount();

   195 		TRAP(error, settings->AddServiceCenterL(_L("Anthony"), _L("+44")));

   196 

   197 		__UHEAP_RESET;

   198 

   199 		if (error)

   200 			{

   201 			test(error == KErrNoMemory);

   202 			test(scCount == settings->ServiceCenterCount());

   203 			}

   204 		else

   205 			{

   206 			test(scCount == settings->ServiceCenterCount() - 1);

   207 			}

   208 		}

   209 	while (error);

   210 

   211 	iSmsTest.Printf(_L("CSmsSettings::AddSCAddress Fail Count %d\n"), failCount);

   212 	CSmsSettings* settings2 = CSmsSettings::NewL();

   213 	CleanupStack::PushL(settings2);

   214 	failCount = 0;

   215 

   216 	//Failure Test CSmsSettings::CopyL()

   217 	do

   218 		{

   219 		__UHEAP_FAILNEXT(failCount++);

   220 

   221 		TRAP(error, settings2->CopyL(*settings));

   222 

   223 		__UHEAP_RESET;

   224 

   225 		if (error)

   226 			{

   227 			test(error == KErrNoMemory);

   228 			}

   229 		}

   230 	while (error);

   231 

   232 	iSmsTest.Printf(_L("CSmsSettings::CopyL Fail Count %d\n"), failCount);

   233 

   234 	CleanupStack::PopAndDestroy(); //settings2

   235 	CleanupStack::PopAndDestroy(); //settings

   236 	}

   237 

   238 void CSmcmFailTest::TestHeaderFailL()

   239 	{

   240 	CSmsHeader* header = NULL;

   241 

   242 	TInt error;

   243 	TInt failCount = 0;

   244 

   245 	//Failure Test CSmsHeader::NewL, Deliver

   246 	do

   247 		{

   248 		__UHEAP_FAILNEXT(failCount++);

   249 

   250 		TRAP(error, header = CSmsHeader::NewL(CSmsPDU::ESmsDeliver,*iRichText));

   251 

   252 		__UHEAP_RESET;

   253 

   254 		if (error)

   255 			{

   256 			test(error == KErrNoMemory);

   257 			}

   258 

   259 		}

   260 	while (error);

   261 

   262 	iSmsTest.Printf(_L("CSmsHeader::NewL (Deliver) Fail Count %d\n"), failCount);

   263 	delete header;

   264 

   265 	failCount = 0;

   266 

   267 	//Failure Test CSmsHeader::NewL, StatusReport

   268 	do

   269 		{

   270 		__UHEAP_FAILNEXT(failCount++);

   271 

   272 		TRAP(error, header = CSmsHeader::NewL(CSmsPDU::ESmsStatusReport,*iRichText));

   273 

   274 		__UHEAP_RESET;

   275 

   276 		if (error)

   277 			{

   278 			test(error == KErrNoMemory);

   279 			}

   280 		}

   281 	while (error);

   282 

   283 	iSmsTest.Printf(_L("CSmsHeader::NewL (StatusReport) Fail Count %d\n"), failCount);

   284 	delete header;

   285 

   286 	failCount = 0;

   287 

   288 	//Failure Test CSmsHeader::NewL, Submit

   289 	do

   290 		{

   291 		__UHEAP_FAILNEXT(failCount++);

   292 

   293 		TRAP(error, header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit,*iRichText));

   294 

   295 		__UHEAP_RESET;

   296 

   297 		if (error)

   298 			{

   299 			test(error == KErrNoMemory);

   300 			}

   301 

   302 		}

   303 	while (error);

   304 

   305 	iSmsTest.Printf(_L("CSmsHeader::NewL (Submit) Fail Count %d\n"), failCount);

   306 	delete header;

   307 	}

   308 

   309 void CSmcmFailTest::TestNumberFailL()

   310 	{

   311 	CSmsNumber* number = NULL;

   312 

   313 	TInt error;

   314 	TInt failCount = 0;

   315 

   316 	//Failure Test CSmsNumber::NewL

   317 	do

   318 		{

   319 		__UHEAP_FAILNEXT(failCount++);

   320 

   321 		TRAP(error, number = CSmsNumber::NewL());

   322 

   323 		__UHEAP_RESET;

   324 

   325 		if (error)

   326 			{

   327 			test(error == KErrNoMemory);

   328 			}

   329 

   330 		}

   331 	while (error);

   332 

   333 	iSmsTest.Printf(_L("CSmsNumber::NewL Fail Count %d\n"), failCount);

   334 	CleanupStack::PushL(number);

   335 	CSmsNumber* number2 = NULL;

   336 

   337 	failCount = 0;

   338 

   339 	//Failure Test CSmsNumber::NewL,2

   340 	do

   341 		{

   342 		__UHEAP_FAILNEXT(failCount++);

   343 

   344 		TRAP(error, number2 = CSmsNumber::NewL(*number));

   345 

   346 		__UHEAP_RESET;

   347 

   348 		if (error)

   349 			{

   350 			test(error == KErrNoMemory);

   351 			}

   352 

   353 		}

   354 	while (error);

   355 

   356 	iSmsTest.Printf(_L("CSmsNumber::NewL (Number) Fail Count %d\n"), failCount);

   357 	CleanupStack::PushL(number2);

   358 

   359 	number->SetAddressL(_L("44"));

   360 	number->SetNameL(_L("AA"));

   361 

   362 	failCount = 0;

   363 

   364 	//Failure Test CSmsNumber::CopyL

   365 	do

   366 		{

   367 		__UHEAP_FAILNEXT(failCount++);

   368 

   369 		TRAP(error, number2->CopyL(*number));

   370 

   371 		__UHEAP_RESET;

   372 

   373 		if (error)

   374 			{

   375 			test(error == KErrNoMemory);

   376 			}

   377 		else

   378 			{

   379 			test(number->Name() == number2->Name());

   380 			test(number->Address() == number2->Address());

   381 			}

   382 		}

   383 	while (error);

   384 

   385 	iSmsTest.Printf(_L("CSmsNumber::CopyL Fail Count %d\n"), failCount);

   386 	CleanupStack::PopAndDestroy(); //number

   387 	CleanupStack::PopAndDestroy(); //number2

   388 	}

   389 

   390 

   391 void CSmcmFailTest::TestReplyFailL()

   392 	{

   393 	iSmsTest.Test().Next(_L("CSmsClientMtm Reply Fail"));

   394 

   395 	CMsvOperationWait* wait = CMsvOperationWait::NewLC();

   396 	CMsvOperation* op = NULL; 

   397 	TInt error;

   398 	TMsvPartList part=0;

   399 	TInt failCount = 0;

   400 

   401 	do

   402 		{

   403 		CleanFolderL(KMsvDraftEntryId);

   404 		CleanFolderL(KMsvGlobalOutBoxIndexEntryId);

   405 		CleanFolderL(KMsvGlobalInBoxIndexEntryId);

   406 

   407 		TMsvId id = iSmsTest.CreateDummyMessageToReceiveL();

   408 		Session().CleanupEntryPushL(id);

   409 		Client().SwitchCurrentEntryL(id); // Lets go to the received area

   410 		Client().LoadMessageL();

   411 	

   412 		__UHEAP_FAILNEXT(failCount++);

   413 

   414 		TRAP(error, op = Client().ReplyL(KMsvDraftEntryId, part, wait->iStatus));

   415 

   416 		__UHEAP_RESET;

   417 

   418 		if (error)

   419 			{

   420 			test(error == KErrNoMemory);

   421 

   422 			if (failCount % 100 == 0)

   423 				iSmsTest.Printf(_L("CSmsClientMtm::ReplyL still failing, count = %d\n"), failCount);

   424 			}

   425 

   426 		CleanupStack::PopAndDestroy(); //id

   427 		}

   428 	while (error);

   429 	

   430 	iSmsTest.Printf(_L("CSmsClientMtm::ReplyL Fail Count %d\n"), failCount);

   431 	CleanupStack::PushL(op);

   432 	wait->Start();

   433 	CActiveScheduler::Start();

   434 

   435 	CleanupStack::PopAndDestroy(2); //op, wait

   436 	}

   437 

   438 void CSmcmFailTest::CleanFolderL(TMsvId aFolder)

   439 	{

   440 	CMsvOperationWait* wait = CMsvOperationWait::NewLC();

   441 	CMsvOperation* op = NULL; 

   442 

   443 	iSmsTest.SetEntryL(aFolder);

   444 	CMsvEntrySelection* sel = MsvEntry().ChildrenL();

   445 

   446 	CleanupStack::PushL(sel);

   447 	if (sel->Count())

   448 		{

   449 		iSmsTest.Printf(_L("Deleting %d existing messages\n"), sel->Count());

   450 		op = MsvEntry().DeleteL(*sel, wait->iStatus);

   451 		CleanupStack::PushL(op);

   452 		wait->Start();

   453 		CActiveScheduler::Start();

   454 		CleanupStack::PopAndDestroy(); //op

   455 		}

   456 	CleanupStack::PopAndDestroy(2); //sel, wait

   457 	}

   458 

   459 void CSmcmFailTest::TestForwardFailL()

   460 	{

   461 	iSmsTest.Test().Next(_L("CSmsClientMtm Forward Fail"));

   462 

   463 	CleanFolderL(KMsvDraftEntryId);

   464 	CleanFolderL(KMsvGlobalOutBoxIndexEntryId);

   465 	CleanFolderL(KMsvGlobalInBoxIndexEntryId);

   466 

   467 	TMsvId id = iSmsTest.CreateDummyMessageToReceiveL();

   468 	Client().SwitchCurrentEntryL(id);

   469 	Client().LoadMessageL();

   470 

   471 	TMsvPartList part=0;

   472 

   473 	TInt error;

   474 	TInt failCount = 0;

   475 	CMsvOperationWait* wait = CMsvOperationWait::NewLC();

   476 	CMsvOperation* op = NULL; 

   477 

   478 	do

   479 		{

   480 		__UHEAP_FAILNEXT(failCount++);

   481 

   482 		TRAP(error, op = Client().ForwardL(KMsvDraftEntryId, part, wait->iStatus));

   483 

   484 		__UHEAP_RESET;

   485 

   486 		if (error)

   487 			{

   488 			test(error == KErrNoMemory);

   489 

   490 			if (failCount % 100 == 0)

   491 				iSmsTest.Printf(_L("CSmsClientMtm::ForwardL still failing, count = %d\n"), failCount);

   492 			}

   493 

   494 		}

   495 	while (error);

   496 

   497 	CleanupStack::PushL(op);

   498 	iSmsTest.Printf(_L("CSmsClientMtm::ForwardL Fail Count %d\n"), failCount);

   499 	wait->Start();

   500 	CActiveScheduler::Start();

   501 

   502 	CleanupStack::PopAndDestroy(2); //op, wait

   503 	}

   504 

   505 void CSmcmFailTest::TestLoadFailL()

   506 	{

   507 	iSmsTest.Test().Next(_L("CSmsClientMtm Load Fail"));

   508 

   509 	CleanFolderL(KMsvDraftEntryId);

   510 	CleanFolderL(KMsvGlobalOutBoxIndexEntryId);

   511 	CleanFolderL(KMsvGlobalInBoxIndexEntryId);

   512 

   513 	TMsvId id = iSmsTest.CreateDummyMessageToSendL();

   514 	Client().SwitchCurrentEntryL(id);

   515 	

   516 	TInt error;

   517 	TInt failCount = 0;

   518 

   519 	do

   520 		{

   521 		__UHEAP_FAILNEXT(failCount++);

   522 

   523 		TRAP(error, Client().LoadMessageL());

   524 

   525 		__UHEAP_RESET;

   526 

   527 		if (error)

   528 			{

   529 			test(error == KErrNoMemory);

   530 			}

   531 		}

   532 	while (error);

   533 

   534 	iSmsTest.Printf(_L("CSmsClientMtm::LoadMessageL Fail Count %d\n"), failCount);

   535 	}

   536 

   537 void CSmcmFailTest::TestSaveFailL()

   538 	{

   539 	iSmsTest.Test().Next(_L("CSmsClientMtm Save Fail"));

   540 

   541 	CleanFolderL(KMsvDraftEntryId);

   542 	CleanFolderL(KMsvGlobalOutBoxIndexEntryId);

   543 	CleanFolderL(KMsvGlobalInBoxIndexEntryId);

   544 

   545 	TMsvId id = iSmsTest.CreateDummyMessageToSendL();

   546 	Client().SwitchCurrentEntryL(id);

   547 	Client().LoadMessageL();

   548 	

   549 	TInt error;

   550 	TInt failCount = 0;

   551 

   552 	do

   553 		{

   554 		__UHEAP_FAILNEXT(failCount++);

   555 

   556 		TRAP(error, Client().SaveMessageL());

   557 

   558 		__UHEAP_RESET;

   559 

   560 		if (error)

   561 			{

   562 			test(error == KErrNoMemory);

   563 			}

   564 		}

   565 	while (error);

   566 

   567 	iSmsTest.Printf(_L("CSmsClientMtm::SaveMessageL Fail Count %d\n"), failCount);

   568 	}

   569 

   570 void CSmcmFailTest::TestAddresseeFailL()

   571 	{

   572 	iSmsTest.Test().Next(_L("CSmsClientMtm Save Fail"));

   573 

   574 	CleanFolderL(KMsvDraftEntryId);

   575 	CleanFolderL(KMsvGlobalOutBoxIndexEntryId);

   576 	CleanFolderL(KMsvGlobalInBoxIndexEntryId);

   577 

   578 	TMsvId id = iSmsTest.CreateDummyMessageToSendL();

   579 	Client().SwitchCurrentEntryL(id);

   580 	Client().LoadMessageL();

   581 	

   582 	TInt error;

   583 	TInt failCount = 0;

   584 

   585 	do

   586 		{

   587 		__UHEAP_FAILNEXT(failCount++);

   588 

   589 		TInt count = Client().AddresseeList().Count();

   590 		TRAP(error, Client().AddAddresseeL(_L("44")));

   591 

   592 		__UHEAP_RESET;

   593 

   594 		if (error)

   595 			{

   596 			test(error == KErrNoMemory);

   597 			test(count == Client().AddresseeList().Count());

   598 			}

   599 		else

   600 			{

   601 			test(count == Client().AddresseeList().Count() - 1);

   602 			}

   603 		}

   604 	while (error);

   605 

   606 	iSmsTest.Printf(_L("CSmsClientMtm Addressee1 Fail Count %d\n"), failCount);

   607 

   608 	failCount = 0;

   609 

   610 	do

   611 		{

   612 		__UHEAP_FAILNEXT(failCount++);

   613 

   614 		TInt count = Client().AddresseeList().Count();

   615 		TRAP(error, Client().AddAddresseeL(_L("44"), _L("AA")));

   616 

   617 		__UHEAP_RESET;

   618 

   619 		if (error)

   620 			{

   621 			test(error == KErrNoMemory);

   622 			test(count == Client().AddresseeList().Count());

   623 			}

   624 		else

   625 			{

   626 			test(count == Client().AddresseeList().Count() - 1);

   627 			}

   628 		}

   629 	while (error);

   630 

   631 	iSmsTest.Printf(_L("CSmsClientMtm Addressee2 Fail Count %d\n"), failCount);

   632 	}

   633 

   634 void CSmcmFailTest::TestBifFailL()

   635 	{

   636 	iSmsTest.Test().Next(_L("CSmsClientMtm Bio Fail"));

   637 

   638 	CleanFolderL(KMsvDraftEntryId);

   639 	CleanFolderL(KMsvGlobalOutBoxIndexEntryId);

   640 	CleanFolderL(KMsvGlobalInBoxIndexEntryId);

   641 

   642 	TMsvId id = iSmsTest.CreateDummyMessageToSendL();

   643 	Client().SwitchCurrentEntryL(id);

   644 	Client().LoadMessageL();

   645 	

   646 	TInt error;

   647 	TInt failCount = 0;

   648 

   649 	CBIODatabase* bdb = CBIODatabase::NewLC(Session().FileSession());

   650 

   651 	if (!bdb->BIOCount())

   652 		{

   653 		CleanupStack::PopAndDestroy(); //bdb

   654 		iSmsTest.Printf(_L("No Bio messages in Bio DB\n"));

   655 		return;

   656 		}

   657 

   658 	// Get the whole bif file class

   659 	const CBioInfoFileReader& reader = bdb->BifReader(0);

   660 

   661 	do

   662 		{

   663 		__UHEAP_FAILNEXT(failCount++);

   664 

   665 		TRAP(error, Client().BioTypeChangedL(reader.MessageTypeUid()));

   666 

   667 		__UHEAP_RESET;

   668 

   669 		if (error)

   670 			{

   671 			test(error == KErrNoMemory || error == KErrNotFound);

   672 			}

   673 		}

   674 	while (error && error != KErrNotFound);

   675 

   676 	iSmsTest.Printf(_L("CSmsClientMtm::BioTypeChangedL Fail Count %d\n"), failCount);

   677 	CleanupStack::PopAndDestroy(); //bdb

   678 	}