Mercurial Mercurial > oss > MCL > sf > os > devicesrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
sysstatemgmt/systemstatemgr/test/tsus/src/tsus_step_adaptionserver.cpp
branchRCL_3
changeset 3 a811597961f0
parent 0 4e1aa6a622a0
equal deleted inserted replaced
0:4e1aa6a622a0 3:a811597961f0 
     1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
 
     1 // Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
 
     2 // All rights reserved.
 
     2 // All rights reserved.
 
     3 // This component and the accompanying materials are made available
 
     3 // This component and the accompanying materials are made available
 
     4 // under the terms of "Eclipse Public License v1.0"
 
     4 // under the terms of "Eclipse Public License v1.0"
 
     5 // which accompanies this distribution, and is available
 
     5 // which accompanies this distribution, and is available
 
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
    18  @test
 
    18  @test
 
    19  @internalComponent - Internal Symbian test code 
    19  @internalComponent - Internal Symbian test code 
    20 */
 
    20 */
 
    21 
    21 
    22 #include "susadaptionserver.h"
 
    22 #include "susadaptionserver.h"
 
    23 
    23 #include <ssm/ssmadaptationcli.h>
 
    24 #include "tsus_step_adaptionserver.h"
 
    24 #include "tsus_step_adaptionserver.h"
 
    25 
    25 #include "tsus_startadaptationserver.h"
 
       
    26 
       
    27 #ifdef TEST_SSM_SERVER
 
       
    28 /**
 
       
    29  * Overloaded function to Connect to the Test Adaptation server
 
       
    30  */
 
       
    31 TInt RTestSusAdaptationCli::Connect(const TDesC& aServerName)
 
       
    32     {
 
       
    33     return RSsmEmergencyCallRfAdaptation::Connect(aServerName);
 
       
    34     }
 
       
    35 #endif //TEST_SSM_SERVER
 
    26 /**
 
    36 /**
 
    27  * Client interface to simulate Heap failure at server side
 
    37  * Client interface to simulate Heap failure at server side
 
    28  */
 
    38  */
 
    29 TInt RTestSusAdaptationCli::SetHeapFailure(TInt aFailureRate)
 
    39 TInt RTestSusAdaptationCli::SetHeapFailure(TInt aFailureRate)
 
    30     {
 
    40     {
 
    44         {
 
    54         {
 
    45         return SendReceive(EDebugUnSetHeapFailure);
 
    55         return SendReceive(EDebugUnSetHeapFailure);
 
    46         }
 
    56         }
 
    47     return KErrDisconnected;
 
    57     return KErrDisconnected;
 
    48     }
 
    58     }
 
       
    59 
       
    60 TInt RTestSusAdaptationCli::SetHeapMark()
 
       
    61     {
 
       
    62     if(Handle())
 
       
    63         {
 
       
    64         return SendReceive(EDebugMarkHeap);
 
       
    65         }
 
       
    66     return KErrDisconnected;
 
       
    67     }
 
       
    68 
       
    69 /**
 
       
    70  * Client interface to restore Heap Mark
 
       
    71  */
 
       
    72 TInt RTestSusAdaptationCli::UnSetHeapMark()
 
       
    73     {
 
       
    74     if(Handle())
 
       
    75         {
 
       
    76         return SendReceive(EDebugMarkHeapEnd);
 
       
    77         }
 
       
    78     return KErrDisconnected;
 
       
    79     }
 
    49  
    80  
    50 CSusAdaptionServerTest::~CSusAdaptionServerTest()
 
    81 CSusAdaptionServerTest::~CSusAdaptionServerTest()
 
    51 	{
 
    82 	{
 
    52 	}
 
    83 	}
 
    53 
    84 
    77 
   108 
    78 	TRAP(err, doTestProcessCriticalL());
 
   109 	TRAP(err, doTestProcessCriticalL());
 
    79 	TEST(KErrNone == err || KErrAlreadyExists == err);
 
   110 	TEST(KErrNone == err || KErrAlreadyExists == err);
 
    80 	TRAP(err, doTestOOML());
 
   111 	TRAP(err, doTestOOML());
 
    81 	TEST(err == KErrNone);	
   112 	TEST(err == KErrNone);	
    82 	
   113 #ifdef TEST_SSM_SERVER	
    83 	doTestForNormalEmergencyCallinOOM();
 
   114 	doTestForNormalEmergencyCallinOOM();
 
    84 	doTestForEmergencyCallOOM();
 
   115 	doTestForEmergencyCallOOM();
 
    85 	doTestForSettingPriorityClient();
 
   116 	doTestForSettingPriorityClient();
 
    86 	
   117 	doTestForMultipleClientinOOMcondition();
 
       
   118 	doTestForEmergencyCallOOMIterative();
 
       
   119 #endif //TEST_SSM_SERVER
 
    87 	__UHEAP_MARKEND;
 
   120 	__UHEAP_MARKEND;
 
    88 	
   121 	
    89 	INFO_PRINTF1(_L("....CSusAdaptionServerTest tests completed!"));
 
   122 	INFO_PRINTF1(_L("....CSusAdaptionServerTest tests completed!"));
 
    90 	return TestStepResult();	
   123 	return TestStepResult();	
    91 	}
 
   124 	}
 
   189 	if(err != KErrNone && err != KErrAlreadyExists)
 
   222 	if(err != KErrNone && err != KErrAlreadyExists)
 
   190 		User::LeaveIfError(err);
 
   223 		User::LeaveIfError(err);
 
   191 	INFO_PRINTF1(_L("Destroy SSM adaptation server."));
 
   224 	INFO_PRINTF1(_L("Destroy SSM adaptation server."));
 
   192 	delete server;
 
   225 	delete server;
 
   193 	}
 
   226 	}
 
   194 
   227 #ifdef TEST_SSM_SERVER
 
   195 /**
 
   228 /**
 
   196  * Tests for client calling Activate/Deactivate Rf without setting as priorityclient.
 
   229  * Tests for client calling Activate/Deactivate Rf without setting as priorityclient.
 
   197  */
 
   230  */
 
   198 void CSusAdaptionServerTest::doTestForNormalEmergencyCallinOOM()
 
   231 void CSusAdaptionServerTest::doTestForNormalEmergencyCallinOOM()
 
   199     {
 
   232     {
 
   200     INFO_PRINTF1(_L("doTestForNormalEmergencyCallinOOM started."));
 
   233     INFO_PRINTF1(_L("doTestForNormalEmergencyCallinOOM started."));
 
   201     __UHEAP_MARK;
 
   234     __UHEAP_MARK;
 
       
   235     RThread thread;
 
       
   236     CleanupClosePushL(thread);
 
       
   237     TESTL(KErrNone == StartAdaptationServer(thread));
 
       
   238       
   202     RTestSusAdaptationCli adaptationclitest;    
   239     RTestSusAdaptationCli adaptationclitest;    
   203     TInt err = adaptationclitest.Connect();
 
   240     TInt err = adaptationclitest.Connect(KTestAdaptationServerName);
 
   204     INFO_PRINTF2(_L("Connect() returned Error %d : Expected Error is KErrNone."),err);
 
   241     INFO_PRINTF2(_L("Connect() returned Error %d : Expected Error is KErrNone."),err);
 
   205     TEST(err == KErrNone);
 
   242     TEST(err == KErrNone);
 
   206     TRequestStatus status;
 
   243     TRequestStatus status;
 
   207     // Simulate OOM condition
 
   244     // Simulate OOM condition
 
   208     User::__DbgSetAllocFail(EFalse, RAllocator::EDeterministic, 1);
 
       
   209     User::__DbgSetAllocFail(ETrue, RAllocator::EDeterministic, 1);
 
   245     User::__DbgSetAllocFail(ETrue, RAllocator::EDeterministic, 1);
 
   210     //Simulate OOM at Serverside
 
   246     //Simulate OOM at Serverside
 
   211     adaptationclitest.SetHeapFailure(1);
 
   247     adaptationclitest.SetHeapFailure(1);
 
       
   248     adaptationclitest.SetHeapMark();
 
   212     //Normal client calling ActivateRfForEmergencyCall Rf in OOM condition. This call must fail with KErrNoMemory 
   249     //Normal client calling ActivateRfForEmergencyCall Rf in OOM condition. This call must fail with KErrNoMemory 
   213     //as there is no memory reserved.
 
   250     //as there is no memory reserved.
 
   214     adaptationclitest.ActivateRfForEmergencyCall(status);
 
   251     adaptationclitest.ActivateRfForEmergencyCall(status);
 
   215     // Wait for completion of requests
 
   252     // Wait for completion of requests
 
   216     User::WaitForRequest(status);    
   253     User::WaitForRequest(status);    
   217     //Restore OOM condition
 
   254     //Restore OOM condition
 
   218     adaptationclitest.UnSetHeapFailure();
 
   255     adaptationclitest.UnSetHeapFailure();
 
   219     adaptationclitest.Close();
 
   256     adaptationclitest.UnSetHeapMark();
 
   220     User::__DbgSetAllocFail(EFalse, RAllocator::ENone, 1);
 
   257     adaptationclitest.Close();    
   221     User::__DbgSetAllocFail(ETrue, RAllocator::ENone, 1);
 
   258     User::__DbgSetAllocFail(ETrue, RAllocator::ENone, 1);
 
   222     TEST(status.Int() == KErrNoMemory);
 
   259     TEST(status.Int() == KErrNoMemory);
 
       
   260     thread.Kill(KErrNone);
 
       
   261     CleanupStack::PopAndDestroy(&thread);
 
   223     __UHEAP_MARKEND;
 
   262     __UHEAP_MARKEND;
 
   224     INFO_PRINTF1(_L("doTestForNormalEmergencyCallinOOM completed.")); 
   263     INFO_PRINTF1(_L("doTestForNormalEmergencyCallinOOM completed.")); 
   225     }
 
   264     }
 
   226 
   265 
   227 
   266 
   231  */
 
   270  */
 
   232 void CSusAdaptionServerTest::doTestForEmergencyCallOOM()
 
   271 void CSusAdaptionServerTest::doTestForEmergencyCallOOM()
 
   233     {
 
   272     {
 
   234     INFO_PRINTF1(_L("doTestForEmergencyCallOOM started."));
 
   273     INFO_PRINTF1(_L("doTestForEmergencyCallOOM started."));
 
   235     __UHEAP_MARK;
 
   274     __UHEAP_MARK;
 
       
   275     RThread thread;
 
       
   276     CleanupClosePushL(thread); 
       
   277     TESTL(KErrNone == StartAdaptationServer(thread));
 
   236     RTestSusAdaptationCli adaptationclitest;    
   278     RTestSusAdaptationCli adaptationclitest;    
   237     TInt err = adaptationclitest.Connect();
 
   279     TInt err = adaptationclitest.Connect(KTestAdaptationServerName);
 
   238     INFO_PRINTF2(_L("Connect() returned Error %d : Expected Error is KErrNone."),err);
 
   280     INFO_PRINTF2(_L("Connect() returned Error %d : Expected Error is KErrNone."),err);
 
   239     TEST(err == KErrNone);
 
   281     TEST(err == KErrNone);    
   240     err = adaptationclitest.SetAsPriorityClient();
 
   282     err = adaptationclitest.SetAsPriorityClient();
 
       
   283     adaptationclitest.SetHeapMark();
 
   241     INFO_PRINTF2(_L("SetAsPriorityClient() returned Error %d : Expected Error is KErrNone."),err);
 
   284     INFO_PRINTF2(_L("SetAsPriorityClient() returned Error %d : Expected Error is KErrNone."),err);
 
   242     TEST(err == KErrNone);
 
   285     TEST(err == KErrNone);
 
   243     //Activate Rf + Deactivate Rf during non OOM situation.
 
   286     TRequestStatus status1,status2,status3,status4,status5,status6,status7; 
   244     //Calls will be queued and processed one after the other. After 3 consecutive requests for 
       
   245     //ActivateRfForEmergencyCall(), first call will be submitted directly to process and other two calls 
       
   246     // will get queued. By end of this process will be having (count + 2) reserved memory in queue.i.e 4 reserved slots
 
       
   247     TRequestStatus status1,status2,status3,status4,status5,status6; 
       
   248     adaptationclitest.ActivateRfForEmergencyCall(status1); 
   287     adaptationclitest.ActivateRfForEmergencyCall(status1); 
   249     adaptationclitest.ActivateRfForEmergencyCall(status2);
 
   288     adaptationclitest.ActivateRfForEmergencyCall(status2);
 
   250     adaptationclitest.ActivateRfForEmergencyCall(status3);
 
   289     adaptationclitest.ActivateRfForEmergencyCall(status3);
 
   251     //Wait for request to complete
 
   290     //Wait for request to complete
 
   252     User::WaitForRequest(status1);
 
   291     User::WaitForRequest(status1);
 
   254     User::WaitForRequest(status3);
 
   293     User::WaitForRequest(status3);
 
   255     TEST(status1.Int() == KErrNone);
 
   294     TEST(status1.Int() == KErrNone);
 
   256     TEST(status2.Int() == KErrNone);
 
   295     TEST(status2.Int() == KErrNone);
 
   257     TEST(status3.Int() == KErrNone);
 
   296     TEST(status3.Int() == KErrNone);
 
   258     // Simulate OOM condition
 
   297     // Simulate OOM condition
 
   259     User::__DbgSetAllocFail(EFalse, RAllocator::EDeterministic, 1);
 
       
   260     User::__DbgSetAllocFail(ETrue, RAllocator::EDeterministic, 1);
 
   298     User::__DbgSetAllocFail(ETrue, RAllocator::EDeterministic, 1);
 
   261     //Simulate OOM at Serverside
 
   299     //Simulate OOM at Serverside
 
   262     adaptationclitest.SetHeapFailure(1);
 
   300     adaptationclitest.SetHeapFailure(1);
 
   263  
   301  
   264     //After the above 2 calls to Activate the Rfs, will be left with 4 reserved memory in queue, so in OOM
 
   302     //Two simulataneous calls for Active/deactivate Rf are allowed. The 3rd simultaneous request fail with KErrNoMemory
 
   265     //condition client can queue 4 activate/deactivate requests.The 5th request will fail with KErrNoMemory
 
       
   266     adaptationclitest.ActivateRfForEmergencyCall(status1); 
   303     adaptationclitest.ActivateRfForEmergencyCall(status1); 
   267     adaptationclitest.ActivateRfForEmergencyCall(status2);
 
   304     adaptationclitest.DeactivateRfForEmergencyCall(status2);    
   268     adaptationclitest.DeactivateRfForEmergencyCall(status3);
 
   305     adaptationclitest.ActivateRfForEmergencyCall(status3);
 
   269     adaptationclitest.DeactivateRfForEmergencyCall(status4);
 
   306     // Wait for completion of requests
 
       
   307     User::WaitForRequest(status1);
 
       
   308     User::WaitForRequest(status2);
 
       
   309     User::WaitForRequest(status3);
 
       
   310   
       
   311     //If the previous request for Activate/Deactivate is already finished. User can perform 2 more calls.
 
       
   312     adaptationclitest.ActivateRfForEmergencyCall(status4); 
   270     adaptationclitest.DeactivateRfForEmergencyCall(status5);
 
   313     adaptationclitest.DeactivateRfForEmergencyCall(status5);
 
   271     adaptationclitest.DeactivateRfForEmergencyCall(status6);
 
   314     
       
   315     User::WaitForRequest(status4);
 
       
   316     User::WaitForRequest(status5);
 
       
   317     
       
   318     adaptationclitest.ActivateRfForEmergencyCall(status6); 
       
   319     adaptationclitest.DeactivateRfForEmergencyCall(status7);  
       
   320     adaptationclitest.Cancel();
 
   272     // Wait for completion of requests
 
   321     // Wait for completion of requests
 
       
   322     User::WaitForRequest(status6);
 
       
   323     User::WaitForRequest(status7);
 
       
   324     
       
   325     //Restore OOM condition
 
       
   326     adaptationclitest.UnSetHeapFailure();
 
       
   327     User::__DbgSetAllocFail(ETrue, RAllocator::ENone, 1);
 
       
   328     TEST(status1.Int() == KErrNone);
 
       
   329     TEST(status2.Int() == KErrNone);
 
       
   330     TEST(status3.Int() == KErrNoMemory);
 
       
   331     TEST(status4.Int() == KErrNone);
 
       
   332     TEST(status5.Int() == KErrNone);
 
       
   333     TEST(status6.Int() == KErrNone);
 
       
   334     TEST(status7.Int() == KErrCancel);    
       
   335     adaptationclitest.UnSetHeapMark();
 
       
   336     adaptationclitest.Close();
 
       
   337     thread.Kill(KErrNone);
 
       
   338     CleanupStack::PopAndDestroy(&thread);
 
       
   339     __UHEAP_MARKEND;
 
       
   340     INFO_PRINTF1(_L("doTestForEmergencyCallOOM completed."));        
       
   341     }
 
       
   342 
       
   343 /**
 
       
   344  * Tests to Set PriorityClient from two different clients.
 
       
   345  */
 
       
   346 void CSusAdaptionServerTest::doTestForSettingPriorityClient()
 
       
   347     {
 
       
   348     INFO_PRINTF1(_L("doTestForSettingPriorityClient started."));
 
       
   349     __UHEAP_MARK;
 
       
   350     RThread thread;
 
       
   351     CleanupClosePushL(thread);
 
       
   352     TESTL(KErrNone == StartAdaptationServer(thread));
 
       
   353     RTestSusAdaptationCli adaptationclitest1;
 
       
   354     TInt err = adaptationclitest1.Connect(KTestAdaptationServerName);
 
       
   355     INFO_PRINTF2(_L("adaptationclitest1.Connect() returned Error %d : Expected Error is KErrNone."),err);   
       
   356     TEST(err == KErrNone);
 
       
   357     
       
   358     RTestSusAdaptationCli adaptationclitest2;
 
       
   359     err = adaptationclitest2.Connect(KTestAdaptationServerName);
 
       
   360     INFO_PRINTF2(_L("adaptationclitest2.Connect() returned Error %d : Expected Error is KErrNone."),err);   
       
   361     TEST(err == KErrNone);
 
       
   362        
       
   363     err = adaptationclitest1.SetAsPriorityClient();
 
       
   364     INFO_PRINTF2(_L("adaptationclitest1.SetAsPriorityClient() returned Error %d : Expected Error is KErrNone."),err);
 
       
   365     TEST(err == KErrNone);
 
       
   366     
       
   367     err = adaptationclitest2.SetAsPriorityClient();
 
       
   368     INFO_PRINTF2(_L("adaptationclitest2.SetAsPriorityClient() returned Error %d : Expected Error is KErrAlreadyExists."),err);
 
       
   369     TEST(err == KErrAlreadyExists);
 
       
   370     
       
   371     // Restore OOM condition
 
       
   372     adaptationclitest1.Close();
 
       
   373     adaptationclitest2.Close();
 
       
   374     
       
   375     thread.Kill(KErrNone);
 
       
   376     CleanupStack::PopAndDestroy(&thread);
 
       
   377     __UHEAP_MARKEND;
 
       
   378     INFO_PRINTF1(_L("doTestForSettingPriorityClient completed."));
 
       
   379     }
 
       
   380 
       
   381 /**
 
       
   382  * Multiple clients performing Emergency call during OOM situation
 
       
   383  */
 
       
   384 void CSusAdaptionServerTest::doTestForMultipleClientinOOMcondition()
 
       
   385     {
 
       
   386     INFO_PRINTF1(_L("doTestForMultipleClientinOOMcondition started."));
 
       
   387     __UHEAP_MARK;
 
       
   388     RThread thread;
 
       
   389     CleanupClosePushL(thread); 
       
   390     
       
   391     TESTL(KErrNone == StartAdaptationServer(thread));
 
       
   392     RTestSusAdaptationCli adaptationclitest1;
 
       
   393     TInt err = adaptationclitest1.Connect(KTestAdaptationServerName);
 
       
   394     INFO_PRINTF2(_L("adaptationclitest1.Connect() returned Error %d : Expected Error is KErrNone."),err);   
       
   395     TEST(err == KErrNone);
 
       
   396     
       
   397     RTestSusAdaptationCli adaptationclitest2;
 
       
   398     err = adaptationclitest2.Connect(KTestAdaptationServerName);
 
       
   399     INFO_PRINTF2(_L("adaptationclitest2.Connect() returned Error %d : Expected Error is KErrNone."),err);   
       
   400     TEST(err == KErrNone);
 
       
   401     
       
   402     RTestSusAdaptationCli adaptationclitest3;
 
       
   403     err = adaptationclitest3.Connect(KTestAdaptationServerName);
 
       
   404     INFO_PRINTF2(_L("adaptationclitest3.Connect() returned Error %d : Expected Error is KErrNone."),err);   
       
   405     TEST(err == KErrNone);
 
       
   406        
       
   407     err = adaptationclitest1.SetAsPriorityClient();
 
       
   408     INFO_PRINTF2(_L("adaptationclitest1.SetAsPriorityClient() returned Error %d : Expected Error is KErrNone."),err);
 
       
   409     TEST(err == KErrNone);
 
       
   410     
       
   411     err = adaptationclitest2.SetAsPriorityClient();
 
       
   412     INFO_PRINTF2(_L("adaptationclitest2.SetAsPriorityClient() returned Error %d : Expected Error is KErrAlreadyExists."),err);
 
       
   413     TEST(err == KErrAlreadyExists);
 
       
   414     
       
   415     err = adaptationclitest3.SetAsPriorityClient();
 
       
   416     INFO_PRINTF2(_L("adaptationclitest3.SetAsPriorityClient() returned Error %d : Expected Error is KErrAlreadyExists."),err);
 
       
   417     TEST(err == KErrAlreadyExists);
 
       
   418     
       
   419     TRequestStatus status1,status2,status3,status4,status5,status6;
 
       
   420     // Simulate OOM condition
 
       
   421     User::__DbgSetAllocFail(ETrue, RAllocator::EDeterministic, 1);
 
       
   422     //Simulate OOM Condition on server side
 
       
   423     adaptationclitest1.SetHeapFailure(1);
 
       
   424     adaptationclitest1.SetHeapMark();
 
       
   425     adaptationclitest1.ActivateRfForEmergencyCall(status1);
 
       
   426     adaptationclitest2.ActivateRfForEmergencyCall(status2);
 
       
   427     adaptationclitest3.ActivateRfForEmergencyCall(status3);
 
       
   428     adaptationclitest1.DeactivateRfForEmergencyCall(status4);
 
       
   429     adaptationclitest2.DeactivateRfForEmergencyCall(status5);
 
       
   430     adaptationclitest3.DeactivateRfForEmergencyCall(status6);
 
       
   431     
   273     User::WaitForRequest(status1);
 
   432     User::WaitForRequest(status1);
 
   274     User::WaitForRequest(status2);
 
   433     User::WaitForRequest(status2);
 
   275     User::WaitForRequest(status3);
 
   434     User::WaitForRequest(status3);
 
   276     User::WaitForRequest(status4);
 
   435     User::WaitForRequest(status4);
 
   277     User::WaitForRequest(status5);
 
   436     User::WaitForRequest(status5);
 
   278     User::WaitForRequest(status6);    
   437     User::WaitForRequest(status6);    
   279     
       
   280     //Restore OOM condition
 
       
   281     adaptationclitest.UnSetHeapFailure();
 
       
   282     User::__DbgSetAllocFail(EFalse, RAllocator::ENone, 1);
 
       
   283     User::__DbgSetAllocFail(ETrue, RAllocator::ENone, 1);
 
       
   284     TEST(status1.Int() == KErrNone);
 
       
   285     TEST(status2.Int() == KErrNone);
 
       
   286     TEST(status3.Int() == KErrNone);
 
       
   287     TEST(status4.Int() == KErrNone);
 
       
   288     TEST(status5.Int() == KErrNone);
 
       
   289     //6th request will fail with KErrNoMemory if, above 5 requests are still queued and there is no reserved slot for
 
       
   290     //6th one..otherwise, 6th request will be queued and processed
 
       
   291     TEST(status6.Int() == KErrNoMemory || status6.Int() == KErrNone);
 
       
   292     
       
   293     adaptationclitest.Close();
 
       
   294     __UHEAP_MARKEND;
 
       
   295     INFO_PRINTF1(_L("doTestForEmergencyCallOOM completed."));        
       
   296     }
 
       
   297 
       
   298 /**
 
       
   299  * Tests to Set PriorityClient from two different clients.
 
       
   300  */
 
       
   301 void CSusAdaptionServerTest::doTestForSettingPriorityClient()
 
       
   302     {
 
       
   303     INFO_PRINTF1(_L("doTestForSettingPriorityClient started."));
 
       
   304     __UHEAP_MARK;
 
       
   305     RTestSusAdaptationCli adaptationclitest1;
 
       
   306     TInt err = adaptationclitest1.Connect();
 
       
   307     INFO_PRINTF2(_L("adaptationclitest1.Connect() returned Error %d : Expected Error is KErrNone."),err);   
       
   308     TEST(err == KErrNone);
 
       
   309     
       
   310     RTestSusAdaptationCli adaptationclitest2;
 
       
   311     err = adaptationclitest2.Connect();
 
       
   312     INFO_PRINTF2(_L("adaptationclitest2.Connect() returned Error %d : Expected Error is KErrNone."),err);   
       
   313     TEST(err == KErrNone);
 
       
   314        
       
   315     err = adaptationclitest1.SetAsPriorityClient();
 
       
   316     INFO_PRINTF2(_L("adaptationclitest1.SetAsPriorityClient() returned Error %d : Expected Error is KErrNone."),err);
 
       
   317     TEST(err == KErrNone);
 
       
   318     
       
   319     err = adaptationclitest2.SetAsPriorityClient();
 
       
   320     INFO_PRINTF2(_L("adaptationclitest2.SetAsPriorityClient() returned Error %d : Expected Error is KErrAlreadyExists."),err);
 
       
   321     TEST(err == KErrAlreadyExists);
 
       
   322     
       
   323     // Restore OOM condition
 
   438     // Restore OOM condition
 
   324     adaptationclitest1.Close();
 
   439     adaptationclitest1.Close();
 
   325     adaptationclitest2.Close();
 
   440     adaptationclitest2.Close();
 
       
   441     adaptationclitest3.Close();
 
       
   442     //Restore OOM condition
 
       
   443     adaptationclitest1.UnSetHeapMark();
 
       
   444     adaptationclitest1.UnSetHeapFailure();
 
       
   445     User::__DbgSetAllocFail(ETrue, RAllocator::ENone, 1);
 
       
   446     //Priority client Performing Activate Rf returns KErrNone
 
       
   447     TEST(status1.Int() == KErrNone);
 
       
   448     //Normal clients performing Activate Rf fail with KErrNoMemory in OOM codition
 
       
   449     TEST(status2.Int() == KErrNoMemory);
 
       
   450     TEST(status3.Int() == KErrNoMemory);
 
       
   451     //Priority client Performing Deactivate Rf returns KErrNone
 
       
   452     TEST(status4.Int() == KErrNone);
 
       
   453     //Normal clients peforming Deactivate Rf fail with KErrNoMemory in OOM codition
 
       
   454     TEST(status5.Int() == KErrNoMemory);
 
       
   455     TEST(status6.Int() == KErrNoMemory);
 
       
   456     thread.Kill(KErrNone);
 
       
   457     CleanupStack::PopAndDestroy(&thread);
 
   326     __UHEAP_MARKEND;
 
   458     __UHEAP_MARKEND;
 
   327     INFO_PRINTF1(_L("doTestForSettingPriorityClient completed."));
 
   459     INFO_PRINTF1(_L("doTestForMultipleClientinOOMcondition completed."));
 
   328     }
 
   460     }
 
   329 
   461 
       
   462 /**
 
       
   463  * Tests for iterating heapfailure in ActivateRfForEmergencyCall and DeactivateRfForEmergencyCall.
 
       
   464  */
 
       
   465 void CSusAdaptionServerTest::doTestForEmergencyCallOOMIterative()
 
       
   466     {
 
       
   467     INFO_PRINTF1(_L("doTestForEmergencyCallOOMIterative started."));
 
       
   468     __UHEAP_MARK;
 
       
   469     RThread thread;
 
       
   470     CleanupClosePushL(thread);
 
       
   471     TESTL(KErrNone == StartAdaptationServer(thread));
 
       
   472     RTestSusAdaptationCli adaptationclitest;    
       
   473     TInt err = adaptationclitest.Connect(KTestAdaptationServerName);
 
       
   474     INFO_PRINTF2(_L("Connect() returned Error %d : Expected Error is KErrNone."),err);
 
       
   475     TEST(err == KErrNone);    
       
   476     err = adaptationclitest.SetAsPriorityClient();
 
       
   477     INFO_PRINTF2(_L("SetAsPriorityClient() returned Error %d : Expected Error is KErrNone."),err);
 
       
   478     TEST(err == KErrNone);
 
       
   479     TRequestStatus status1,status2;
 
       
   480     //simulate OOM at kernel
 
       
   481     User::__DbgSetAllocFail(ETrue, RAllocator::EDeterministic, 1);
 
       
   482     TInt maximumAllocation = 3;
 
       
   483     //Iterate through the ActivateRfForEmergencyCall.
 
       
   484     adaptationclitest.SetHeapMark();
 
       
   485     for(TInt allocFailRate=1; allocFailRate <= 2*maximumAllocation; ++allocFailRate)
 
       
   486         {
 
       
   487         INFO_PRINTF2(_L("allocFailRateL %d:."), allocFailRate);
 
       
   488         adaptationclitest.SetHeapFailure(allocFailRate);
 
       
   489         adaptationclitest.ActivateRfForEmergencyCall(status1);
 
       
   490         adaptationclitest.ActivateRfForEmergencyCall(status2);
 
       
   491         User::WaitForRequest(status1);
 
       
   492         User::WaitForRequest(status2);
 
       
   493         TEST(status1.Int() == KErrNone);
 
       
   494         TEST(status2.Int() == KErrNone);
 
       
   495         }
 
       
   496     
       
   497     //Iterate through the DeactivateRfForEmergencyCall.    
       
   498     for(TInt allocFailRate=1; allocFailRate < 2*maximumAllocation; allocFailRate++)
 
       
   499         {
 
       
   500         INFO_PRINTF2(_L("allocFailRateL %d:."), allocFailRate);
 
       
   501         adaptationclitest.SetHeapFailure(allocFailRate);
 
       
   502         adaptationclitest.DeactivateRfForEmergencyCall(status1);
 
       
   503         adaptationclitest.DeactivateRfForEmergencyCall(status2);
 
       
   504         User::WaitForRequest(status1);
 
       
   505         User::WaitForRequest(status2);
 
       
   506         TEST(status1.Int() == KErrNone);
 
       
   507         TEST(status2.Int() == KErrNone);
 
       
   508         }
 
       
   509     adaptationclitest.UnSetHeapMark();
 
       
   510     //Restore OOM condition
 
       
   511     adaptationclitest.UnSetHeapFailure(); 
       
   512     User::__DbgSetAllocFail(ETrue, RAllocator::ENone, 1);    
       
   513     adaptationclitest.Close();
 
       
   514     thread.Kill(KErrNone);
 
       
   515     CleanupStack::PopAndDestroy(&thread);
 
       
   516     __UHEAP_MARKEND;
 
       
   517     INFO_PRINTF1(_L("doTestForEmergencyCallOOMIterative completed."));        
       
   518     }
 
       
   519 
       
   520 #endif //TEST_SSM_SERVER
 
       
   521 
       
   522
MCL/sf/os/devicesrv