--- 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 <ssm/ssmadaptationcli.h>
#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
+
+