diff -r 4e1aa6a622a0 -r a811597961f0 sysstatemgmt/systemstatemgr/test/tsus/src/tsus_step_adaptionserver.cpp --- a/sysstatemgmt/systemstatemgr/test/tsus/src/tsus_step_adaptionserver.cpp Tue Feb 02 00:53:00 2010 +0200 +++ b/sysstatemgmt/systemstatemgr/test/tsus/src/tsus_step_adaptionserver.cpp Sat Feb 20 00:05:00 2010 +0200 @@ -1,4 +1,4 @@ -// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). +// Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies). // All rights reserved. // This component and the accompanying materials are made available // under the terms of "Eclipse Public License v1.0" @@ -20,9 +20,19 @@ */ #include "susadaptionserver.h" - +#include #include "tsus_step_adaptionserver.h" +#include "tsus_startadaptationserver.h" +#ifdef TEST_SSM_SERVER +/** + * Overloaded function to Connect to the Test Adaptation server + */ +TInt RTestSusAdaptationCli::Connect(const TDesC& aServerName) + { + return RSsmEmergencyCallRfAdaptation::Connect(aServerName); + } +#endif //TEST_SSM_SERVER /** * Client interface to simulate Heap failure at server side */ @@ -46,6 +56,27 @@ } return KErrDisconnected; } + +TInt RTestSusAdaptationCli::SetHeapMark() + { + if(Handle()) + { + return SendReceive(EDebugMarkHeap); + } + return KErrDisconnected; + } + +/** + * Client interface to restore Heap Mark + */ +TInt RTestSusAdaptationCli::UnSetHeapMark() + { + if(Handle()) + { + return SendReceive(EDebugMarkHeapEnd); + } + return KErrDisconnected; + } CSusAdaptionServerTest::~CSusAdaptionServerTest() { @@ -79,11 +110,13 @@ TEST(KErrNone == err || KErrAlreadyExists == err); TRAP(err, doTestOOML()); TEST(err == KErrNone); - +#ifdef TEST_SSM_SERVER doTestForNormalEmergencyCallinOOM(); doTestForEmergencyCallOOM(); doTestForSettingPriorityClient(); - + doTestForMultipleClientinOOMcondition(); + doTestForEmergencyCallOOMIterative(); +#endif //TEST_SSM_SERVER __UHEAP_MARKEND; INFO_PRINTF1(_L("....CSusAdaptionServerTest tests completed!")); @@ -191,7 +224,7 @@ INFO_PRINTF1(_L("Destroy SSM adaptation server.")); delete server; } - +#ifdef TEST_SSM_SERVER /** * Tests for client calling Activate/Deactivate Rf without setting as priorityclient. */ @@ -199,16 +232,20 @@ { INFO_PRINTF1(_L("doTestForNormalEmergencyCallinOOM started.")); __UHEAP_MARK; + RThread thread; + CleanupClosePushL(thread); + TESTL(KErrNone == StartAdaptationServer(thread)); + RTestSusAdaptationCli adaptationclitest; - TInt err = adaptationclitest.Connect(); + TInt err = adaptationclitest.Connect(KTestAdaptationServerName); INFO_PRINTF2(_L("Connect() returned Error %d : Expected Error is KErrNone."),err); TEST(err == KErrNone); TRequestStatus status; // Simulate OOM condition - User::__DbgSetAllocFail(EFalse, RAllocator::EDeterministic, 1); User::__DbgSetAllocFail(ETrue, RAllocator::EDeterministic, 1); //Simulate OOM at Serverside adaptationclitest.SetHeapFailure(1); + adaptationclitest.SetHeapMark(); //Normal client calling ActivateRfForEmergencyCall Rf in OOM condition. This call must fail with KErrNoMemory //as there is no memory reserved. adaptationclitest.ActivateRfForEmergencyCall(status); @@ -216,10 +253,12 @@ User::WaitForRequest(status); //Restore OOM condition adaptationclitest.UnSetHeapFailure(); - adaptationclitest.Close(); - User::__DbgSetAllocFail(EFalse, RAllocator::ENone, 1); + adaptationclitest.UnSetHeapMark(); + adaptationclitest.Close(); User::__DbgSetAllocFail(ETrue, RAllocator::ENone, 1); TEST(status.Int() == KErrNoMemory); + thread.Kill(KErrNone); + CleanupStack::PopAndDestroy(&thread); __UHEAP_MARKEND; INFO_PRINTF1(_L("doTestForNormalEmergencyCallinOOM completed.")); } @@ -233,18 +272,18 @@ { INFO_PRINTF1(_L("doTestForEmergencyCallOOM started.")); __UHEAP_MARK; + RThread thread; + CleanupClosePushL(thread); + TESTL(KErrNone == StartAdaptationServer(thread)); RTestSusAdaptationCli adaptationclitest; - TInt err = adaptationclitest.Connect(); + TInt err = adaptationclitest.Connect(KTestAdaptationServerName); INFO_PRINTF2(_L("Connect() returned Error %d : Expected Error is KErrNone."),err); - TEST(err == KErrNone); + TEST(err == KErrNone); err = adaptationclitest.SetAsPriorityClient(); + adaptationclitest.SetHeapMark(); INFO_PRINTF2(_L("SetAsPriorityClient() returned Error %d : Expected Error is KErrNone."),err); TEST(err == KErrNone); - //Activate Rf + Deactivate Rf during non OOM situation. - //Calls will be queued and processed one after the other. After 3 consecutive requests for - //ActivateRfForEmergencyCall(), first call will be submitted directly to process and other two calls - // will get queued. By end of this process will be having (count + 2) reserved memory in queue.i.e 4 reserved slots - TRequestStatus status1,status2,status3,status4,status5,status6; + TRequestStatus status1,status2,status3,status4,status5,status6,status7; adaptationclitest.ActivateRfForEmergencyCall(status1); adaptationclitest.ActivateRfForEmergencyCall(status2); adaptationclitest.ActivateRfForEmergencyCall(status3); @@ -256,41 +295,47 @@ TEST(status2.Int() == KErrNone); TEST(status3.Int() == KErrNone); // Simulate OOM condition - User::__DbgSetAllocFail(EFalse, RAllocator::EDeterministic, 1); User::__DbgSetAllocFail(ETrue, RAllocator::EDeterministic, 1); //Simulate OOM at Serverside adaptationclitest.SetHeapFailure(1); - //After the above 2 calls to Activate the Rfs, will be left with 4 reserved memory in queue, so in OOM - //condition client can queue 4 activate/deactivate requests.The 5th request will fail with KErrNoMemory + //Two simulataneous calls for Active/deactivate Rf are allowed. The 3rd simultaneous request fail with KErrNoMemory adaptationclitest.ActivateRfForEmergencyCall(status1); - adaptationclitest.ActivateRfForEmergencyCall(status2); - adaptationclitest.DeactivateRfForEmergencyCall(status3); - adaptationclitest.DeactivateRfForEmergencyCall(status4); - adaptationclitest.DeactivateRfForEmergencyCall(status5); - adaptationclitest.DeactivateRfForEmergencyCall(status6); + adaptationclitest.DeactivateRfForEmergencyCall(status2); + adaptationclitest.ActivateRfForEmergencyCall(status3); // Wait for completion of requests User::WaitForRequest(status1); User::WaitForRequest(status2); User::WaitForRequest(status3); + + //If the previous request for Activate/Deactivate is already finished. User can perform 2 more calls. + adaptationclitest.ActivateRfForEmergencyCall(status4); + adaptationclitest.DeactivateRfForEmergencyCall(status5); + User::WaitForRequest(status4); User::WaitForRequest(status5); - User::WaitForRequest(status6); + + adaptationclitest.ActivateRfForEmergencyCall(status6); + adaptationclitest.DeactivateRfForEmergencyCall(status7); + adaptationclitest.Cancel(); + // Wait for completion of requests + User::WaitForRequest(status6); + User::WaitForRequest(status7); //Restore OOM condition adaptationclitest.UnSetHeapFailure(); - User::__DbgSetAllocFail(EFalse, RAllocator::ENone, 1); User::__DbgSetAllocFail(ETrue, RAllocator::ENone, 1); TEST(status1.Int() == KErrNone); TEST(status2.Int() == KErrNone); - TEST(status3.Int() == KErrNone); + TEST(status3.Int() == KErrNoMemory); TEST(status4.Int() == KErrNone); TEST(status5.Int() == KErrNone); - //6th request will fail with KErrNoMemory if, above 5 requests are still queued and there is no reserved slot for - //6th one..otherwise, 6th request will be queued and processed - TEST(status6.Int() == KErrNoMemory || status6.Int() == KErrNone); - + TEST(status6.Int() == KErrNone); + TEST(status7.Int() == KErrCancel); + adaptationclitest.UnSetHeapMark(); adaptationclitest.Close(); + thread.Kill(KErrNone); + CleanupStack::PopAndDestroy(&thread); __UHEAP_MARKEND; INFO_PRINTF1(_L("doTestForEmergencyCallOOM completed.")); } @@ -302,13 +347,16 @@ { INFO_PRINTF1(_L("doTestForSettingPriorityClient started.")); __UHEAP_MARK; + RThread thread; + CleanupClosePushL(thread); + TESTL(KErrNone == StartAdaptationServer(thread)); RTestSusAdaptationCli adaptationclitest1; - TInt err = adaptationclitest1.Connect(); + TInt err = adaptationclitest1.Connect(KTestAdaptationServerName); INFO_PRINTF2(_L("adaptationclitest1.Connect() returned Error %d : Expected Error is KErrNone."),err); TEST(err == KErrNone); RTestSusAdaptationCli adaptationclitest2; - err = adaptationclitest2.Connect(); + err = adaptationclitest2.Connect(KTestAdaptationServerName); INFO_PRINTF2(_L("adaptationclitest2.Connect() returned Error %d : Expected Error is KErrNone."),err); TEST(err == KErrNone); @@ -323,7 +371,152 @@ // Restore OOM condition adaptationclitest1.Close(); adaptationclitest2.Close(); + + thread.Kill(KErrNone); + CleanupStack::PopAndDestroy(&thread); __UHEAP_MARKEND; INFO_PRINTF1(_L("doTestForSettingPriorityClient completed.")); } +/** + * Multiple clients performing Emergency call during OOM situation + */ +void CSusAdaptionServerTest::doTestForMultipleClientinOOMcondition() + { + INFO_PRINTF1(_L("doTestForMultipleClientinOOMcondition started.")); + __UHEAP_MARK; + RThread thread; + CleanupClosePushL(thread); + + TESTL(KErrNone == StartAdaptationServer(thread)); + RTestSusAdaptationCli adaptationclitest1; + TInt err = adaptationclitest1.Connect(KTestAdaptationServerName); + INFO_PRINTF2(_L("adaptationclitest1.Connect() returned Error %d : Expected Error is KErrNone."),err); + TEST(err == KErrNone); + + RTestSusAdaptationCli adaptationclitest2; + err = adaptationclitest2.Connect(KTestAdaptationServerName); + INFO_PRINTF2(_L("adaptationclitest2.Connect() returned Error %d : Expected Error is KErrNone."),err); + TEST(err == KErrNone); + + RTestSusAdaptationCli adaptationclitest3; + err = adaptationclitest3.Connect(KTestAdaptationServerName); + INFO_PRINTF2(_L("adaptationclitest3.Connect() returned Error %d : Expected Error is KErrNone."),err); + TEST(err == KErrNone); + + err = adaptationclitest1.SetAsPriorityClient(); + INFO_PRINTF2(_L("adaptationclitest1.SetAsPriorityClient() returned Error %d : Expected Error is KErrNone."),err); + TEST(err == KErrNone); + + err = adaptationclitest2.SetAsPriorityClient(); + INFO_PRINTF2(_L("adaptationclitest2.SetAsPriorityClient() returned Error %d : Expected Error is KErrAlreadyExists."),err); + TEST(err == KErrAlreadyExists); + + err = adaptationclitest3.SetAsPriorityClient(); + INFO_PRINTF2(_L("adaptationclitest3.SetAsPriorityClient() returned Error %d : Expected Error is KErrAlreadyExists."),err); + TEST(err == KErrAlreadyExists); + + TRequestStatus status1,status2,status3,status4,status5,status6; + // Simulate OOM condition + User::__DbgSetAllocFail(ETrue, RAllocator::EDeterministic, 1); + //Simulate OOM Condition on server side + adaptationclitest1.SetHeapFailure(1); + adaptationclitest1.SetHeapMark(); + adaptationclitest1.ActivateRfForEmergencyCall(status1); + adaptationclitest2.ActivateRfForEmergencyCall(status2); + adaptationclitest3.ActivateRfForEmergencyCall(status3); + adaptationclitest1.DeactivateRfForEmergencyCall(status4); + adaptationclitest2.DeactivateRfForEmergencyCall(status5); + adaptationclitest3.DeactivateRfForEmergencyCall(status6); + + User::WaitForRequest(status1); + User::WaitForRequest(status2); + User::WaitForRequest(status3); + User::WaitForRequest(status4); + User::WaitForRequest(status5); + User::WaitForRequest(status6); + // Restore OOM condition + adaptationclitest1.Close(); + adaptationclitest2.Close(); + adaptationclitest3.Close(); + //Restore OOM condition + adaptationclitest1.UnSetHeapMark(); + adaptationclitest1.UnSetHeapFailure(); + User::__DbgSetAllocFail(ETrue, RAllocator::ENone, 1); + //Priority client Performing Activate Rf returns KErrNone + TEST(status1.Int() == KErrNone); + //Normal clients performing Activate Rf fail with KErrNoMemory in OOM codition + TEST(status2.Int() == KErrNoMemory); + TEST(status3.Int() == KErrNoMemory); + //Priority client Performing Deactivate Rf returns KErrNone + TEST(status4.Int() == KErrNone); + //Normal clients peforming Deactivate Rf fail with KErrNoMemory in OOM codition + TEST(status5.Int() == KErrNoMemory); + TEST(status6.Int() == KErrNoMemory); + thread.Kill(KErrNone); + CleanupStack::PopAndDestroy(&thread); + __UHEAP_MARKEND; + INFO_PRINTF1(_L("doTestForMultipleClientinOOMcondition completed.")); + } + +/** + * Tests for iterating heapfailure in ActivateRfForEmergencyCall and DeactivateRfForEmergencyCall. + */ +void CSusAdaptionServerTest::doTestForEmergencyCallOOMIterative() + { + INFO_PRINTF1(_L("doTestForEmergencyCallOOMIterative started.")); + __UHEAP_MARK; + RThread thread; + CleanupClosePushL(thread); + TESTL(KErrNone == StartAdaptationServer(thread)); + RTestSusAdaptationCli adaptationclitest; + TInt err = adaptationclitest.Connect(KTestAdaptationServerName); + INFO_PRINTF2(_L("Connect() returned Error %d : Expected Error is KErrNone."),err); + TEST(err == KErrNone); + err = adaptationclitest.SetAsPriorityClient(); + INFO_PRINTF2(_L("SetAsPriorityClient() returned Error %d : Expected Error is KErrNone."),err); + TEST(err == KErrNone); + TRequestStatus status1,status2; + //simulate OOM at kernel + User::__DbgSetAllocFail(ETrue, RAllocator::EDeterministic, 1); + TInt maximumAllocation = 3; + //Iterate through the ActivateRfForEmergencyCall. + adaptationclitest.SetHeapMark(); + for(TInt allocFailRate=1; allocFailRate <= 2*maximumAllocation; ++allocFailRate) + { + INFO_PRINTF2(_L("allocFailRateL %d:."), allocFailRate); + adaptationclitest.SetHeapFailure(allocFailRate); + adaptationclitest.ActivateRfForEmergencyCall(status1); + adaptationclitest.ActivateRfForEmergencyCall(status2); + User::WaitForRequest(status1); + User::WaitForRequest(status2); + TEST(status1.Int() == KErrNone); + TEST(status2.Int() == KErrNone); + } + + //Iterate through the DeactivateRfForEmergencyCall. + for(TInt allocFailRate=1; allocFailRate < 2*maximumAllocation; allocFailRate++) + { + INFO_PRINTF2(_L("allocFailRateL %d:."), allocFailRate); + adaptationclitest.SetHeapFailure(allocFailRate); + adaptationclitest.DeactivateRfForEmergencyCall(status1); + adaptationclitest.DeactivateRfForEmergencyCall(status2); + User::WaitForRequest(status1); + User::WaitForRequest(status2); + TEST(status1.Int() == KErrNone); + TEST(status2.Int() == KErrNone); + } + adaptationclitest.UnSetHeapMark(); + //Restore OOM condition + adaptationclitest.UnSetHeapFailure(); + User::__DbgSetAllocFail(ETrue, RAllocator::ENone, 1); + adaptationclitest.Close(); + thread.Kill(KErrNone); + CleanupStack::PopAndDestroy(&thread); + __UHEAP_MARKEND; + INFO_PRINTF1(_L("doTestForEmergencyCallOOMIterative completed.")); + } + +#endif //TEST_SSM_SERVER + +