diff -r 000000000000 -r 4e1aa6a622a0 sysstatemgmt/systemstatemgr/test/tcmn/src/t_stateawaresession.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sysstatemgmt/systemstatemgr/test/tcmn/src/t_stateawaresession.cpp	Tue Feb 02 00:53:00 2010 +0200
@@ -0,0 +1,458 @@
+// Copyright (c) 2009 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"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+//Contributors:
+//
+// Description: Test wrapper for RSsmStateAwareSession
+
+#include <test/datawrapper.h>
+#include <ssm/ssmdomaindefs.h> 
+#include <ssm/ssmsubstates.hrh>
+#include <ssm/startupdomainpskeys.h>
+
+#include "t_stateawaresession.h"
+
+//
+_LIT(KDomainId,                  "domainId"); 
+_LIT(KAckNotify,                 "AckNotify%d");
+_LIT(KAcknowledge,               "acknowledge");
+_LIT(KExpectedState,             "expectedState"); 
+_LIT(KError,                     "error");     
+
+static TInt AckNotifyCounter = KErrNone;
+//commands
+_LIT(KCmdNewL,                                      "NewL");
+_LIT(KCmdConnect,                                   "Connect");
+_LIT(KCmdRequestStateNotification,                  "RequestStateNotification");
+_LIT(KCmdAcknowledgeStateNotification,              "AcknowledgeStateNotification");
+_LIT(KCmdClose,                                     "Close");
+_LIT(KCmdState,                                     "State");
+_LIT(KCmdRequestStateNotificationCancel,            "RequestStateNotificationCancel");
+_LIT(KCmdAcknowledgeAndRequestStateNotification,    "AcknowledgeAndRequestStateNotification");
+_LIT(KCmdDestructor,                                "~");
+
+/**
+ * Two phase constructor
+ */
+CTestRStateAwareSession* CTestRStateAwareSession::NewL()
+    {
+    CTestRStateAwareSession*  testStateAwareSession = new (ELeave) CTestRStateAwareSession();
+    CleanupStack::PushL(testStateAwareSession);
+    testStateAwareSession->ConstructL();
+    CleanupStack::Pop(testStateAwareSession);
+    return testStateAwareSession; 
+    }
+
+/**
+* @return pointer to the object that the data wraps
+*/
+TAny*  CTestRStateAwareSession::GetObject()
+    {
+    return iSsmStateAwareSession;
+    }
+
+/**
+ * SetObjectL
+ */
+void CTestRStateAwareSession::SetObjectL(TAny* aAny)
+    {
+    DoCleanup();
+    iSsmStateAwareSession=static_cast<RSsmStateAwareSession*> (aAny);
+    }
+
+/**
+ * DisownObjectL
+ */
+void CTestRStateAwareSession::DisownObjectL()
+    {
+    iSsmStateAwareSession=NULL;
+    }
+
+/**
+ * Protected constructor. First phase construction
+ */
+CTestRStateAwareSession::CTestRStateAwareSession():
+CDataWrapper()
+    {
+    }
+
+/**
+ * Protected constructor. Second phase construction
+ */
+void CTestRStateAwareSession::ConstructL()
+    {
+    iActiveNotifyOnChange = CActiveCallback::NewL(*this);
+    }
+
+/**
+ * Destructor.
+ */
+CTestRStateAwareSession::~CTestRStateAwareSession()
+    {
+    DoCleanup();
+    delete iActiveNotifyOnChange;
+    }
+
+/**
+ * Process a command read from the ini file
+ *
+ * @param aCommand  the command to process
+ * @param aSection      the entry in the ini file requiring the command to be processed
+ *
+ * @return ETrue if the command is processed
+ */
+TBool CTestRStateAwareSession::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)
+    {
+    TBool retVal = ETrue;
+    if (aCommand == KCmdNewL)
+        {
+        DoCmdNew();
+        }
+    else if (aCommand == KCmdConnect)
+        {
+        DoCmdConnect(aSection);
+        }
+    else if (aCommand == KCmdRequestStateNotification)
+        {
+        DoCmdRequestStateNotification(aAsyncErrorIndex);
+        }
+    else if (aCommand == KCmdAcknowledgeStateNotification)
+        {
+        DoCmdAcknowledgeStateNotification(aSection);
+        }
+    else if (aCommand == KCmdClose)
+        {
+        DoCmdClose();
+        }
+    else if (aCommand == KCmdState)
+        {
+        DoCmdState(aSection);
+        }
+    else if (aCommand == KCmdRequestStateNotificationCancel)
+        {
+        DoCmdRequestStateNotificationCancel();
+        }
+    else if (aCommand == KCmdAcknowledgeAndRequestStateNotification)
+        {
+        DoCmdAcknowledgeAndRequestStateNotification(aSection, aAsyncErrorIndex);
+        }
+    else if (aCommand == KCmdDestructor)
+        {
+        DoCmdDestructor();
+        }
+    else
+        {
+        retVal = EFalse;
+        }    
+   
+    return retVal;
+    }
+
+/**
+ * Creates RSSmStateAwareSession class instance
+ */
+void CTestRStateAwareSession::DoCmdNew()
+    {
+    INFO_PRINTF1(_L("Create RSsmStateAwareSession class instance"));
+    DoCleanup();
+    
+    TRAPD(err, iSsmStateAwareSession = new (ELeave)RSsmStateAwareSession());
+    
+    if (err != KErrNone)
+        {
+        ERR_PRINTF2(_L("new error %d"), err);
+        SetError(err);
+        }      
+    }
+
+/**
+ * Close RSsmStateAwareSession handle
+ */
+void CTestRStateAwareSession::DoCmdClose()
+    {
+    INFO_PRINTF1(_L("Close RSsmStateAwareSession"));
+    iSsmStateAwareSession->Close();
+    }
+
+/**
+ * Contains cleanup implementation
+ */
+void CTestRStateAwareSession::DoCleanup()
+    {
+    if(iSsmStateAwareSession != NULL)
+        {
+        INFO_PRINTF1(_L("Deleting current RSsmStateAwareSession"));
+        delete iSsmStateAwareSession;
+        iSsmStateAwareSession = NULL;
+        }
+    }
+
+/**
+ * Destroy RStateAwareSession object
+ */
+void CTestRStateAwareSession::DoCmdDestructor()
+    {
+    INFO_PRINTF1(_L("Destroying the RStateAwareSession object"));
+    DoCleanup();
+    }
+
+/**
+ * Connects a client to RStateAwareSession with Domain Id
+ */
+void CTestRStateAwareSession::DoCmdConnect(const TDesC& aSection)
+    {
+    TPtrC domainIdName;
+    if (!GetStringFromConfig(aSection, KDomainId(), domainIdName))
+        {
+        //set default domainId if value is not provided in .ini file
+        domainIdName.Set(_L("KSM2UiServicesDomain1"));        
+        }
+    TDmDomainId domainId;
+    if(MapToDomainId(domainIdName, domainId ))
+       {
+       INFO_PRINTF2(_L(" Calling RSsmStateAwareSession->Connect with domain id %S"), &domainIdName );
+       TInt  err = iSsmStateAwareSession->Connect(domainId);          
+       if (KErrNone != err)
+            {
+            ERR_PRINTF2(_L("Connect() error %d"), err);
+            SetError(err);  
+            }       
+       } 
+    else
+        {
+        ERR_PRINTF2(_L("Could not map %S to domain Id"), &domainIdName );
+        SetBlockResult(EFail);
+        }
+    }
+
+/**
+ * DoCmdRequestStateNotification 
+ */
+void CTestRStateAwareSession::DoCmdRequestStateNotification(const TInt aAsyncErrorIndex)
+    {
+    INFO_PRINTF2(_L("RequestStateNotification with Asyc Error Index: %d"), aAsyncErrorIndex);
+    iSsmStateAwareSession->RequestStateNotification(iActiveNotifyOnChange->iStatus);
+    iActiveNotifyOnChange->Activate(aAsyncErrorIndex);
+    IncOutstanding();    
+    }
+
+/**
+ * DoCmdAcknowledgeStateNotification
+ */
+void CTestRStateAwareSession::DoCmdAcknowledgeStateNotification(const TDesC& aSection)
+    {
+    TInt error;
+    if (!GetIntFromConfig(aSection, KError(), error ))
+        {
+        //set default error value if value is not provided in .ini file
+        error = KErrNone;
+        }
+   iSsmStateAwareSession->AcknowledgeStateNotification(error);    
+    }
+
+/**
+ * DoCmdAcknowledgeAndRequestStateNotification
+ */
+void CTestRStateAwareSession::DoCmdAcknowledgeAndRequestStateNotification(const TDesC& aSection, const TInt aAsyncErrorIndex)
+    {
+    TInt error;
+    if (!GetIntFromConfig(aSection, KError(), error ))
+        {
+        //set default error value if value is not provided in .ini file
+        error = KErrNone;
+        }
+    iSsmStateAwareSession->AcknowledgeAndRequestStateNotification(error, iActiveNotifyOnChange->iStatus );
+    iActiveNotifyOnChange->Activate(aAsyncErrorIndex);
+    IncOutstanding();        
+    }
+
+/**
+ * DoCmdRequestStateNotificationCancel
+ */
+void CTestRStateAwareSession::DoCmdRequestStateNotificationCancel()
+    {
+    INFO_PRINTF1(_L("RequestStateNotificationCancel is called "));
+    iSsmStateAwareSession->RequestStateNotificationCancel();
+    }
+
+/** 
+ * DoCmdState()
+ */
+void CTestRStateAwareSession::DoCmdState(const TDesC& aSection)
+    {   
+    TSsmState state;
+    state = iSsmStateAwareSession->State();
+    INFO_PRINTF3(_L("Call to State() returned MainState %d : Substate %d"),state.MainState(),state.SubState());
+    TPtrC readExpectedState;
+    // Comparision will be done only when value is read from the ini file...other wise expected value is ignored
+    if (GetStringFromConfig(aSection, KExpectedState(), readExpectedState ))
+        {
+        TUint16 expectedState;
+        if (MapToMainState(readExpectedState, expectedState))
+            {
+            if(expectedState!=state.MainState())
+                {
+                ERR_PRINTF3(_L("Expected State is %d : Actual State is %d"), expectedState,state.MainState() );
+                SetBlockResult(EFail);
+                }
+            }
+        else
+            {
+            ERR_PRINTF2(_L("Could not map %S to any state"), &readExpectedState );
+            SetBlockResult(EFail);
+            }
+        }
+    }
+
+/**
+ Virtual RunL - Called on completion of an asynchronous command
+ @see MTPActiveCallback
+ @param aActive Active Object that RunL has been called on
+ @pre N/A
+ @post N/A
+ @leave system wide error code
+*/
+void CTestRStateAwareSession::RunL(CActive* aActive, TInt aIndex)
+    {
+    TInt error = KErrNone;  
+    if (aActive == iActiveNotifyOnChange)
+        {
+        error = iActiveNotifyOnChange->iStatus.Int();
+        if (error == KErrNone)
+            {            
+            TSsmState currentState = iSsmStateAwareSession->State(); 
+            // This component only responds to Offline state events.
+            if (currentState.MainState() == ESsmNormal && currentState.SubState() == ESsmNormalRfOffSubState )
+                {
+                TInt globalSystemState;
+                error =RProperty::Get(KPSUidStartup, KPSGlobalSystemState, globalSystemState);
+                const TInt ackErr = ( error != KErrNone || globalSystemState == ESwStateNormalRfOff )? KErrGeneral : KErrNone;
+                //Acknowledge the state change 
+                INFO_PRINTF2(_L("RunL() called with AsyncIndex %d"), aIndex);
+                TBuf<KMaxTestExecuteCommandLength>  tempStore;
+                tempStore.Format(KAckNotify(),++AckNotifyCounter);
+                TBool acknowledge = ETrue;
+                GetBoolFromConfig(tempStore,KAcknowledge(),acknowledge);
+                //Acknowledge with success/failure
+                if (acknowledge)
+                    {
+                    iSsmStateAwareSession->AcknowledgeStateNotification(ackErr);
+                    }
+                }                  
+            }
+        else
+            {
+            ERR_PRINTF2(_L("RunL Error %d"), error);
+            SetAsyncError(aIndex, error);
+            }       
+        }
+    DecOutstanding();
+    }
+
+/**
+ Virtual DoCancel - Request to cancel the asynchronous command
+ @see - MTPActiveCallback
+ @param aActive Active Object that DoCancel has been called on
+ @pre - N/A
+ @post - N/A
+ @leave system wide error code
+*/
+void CTestRStateAwareSession::DoCancel(CActive* aActive, TInt aIndex)
+    {
+    INFO_PRINTF1(_L("DoCancel"));
+    if(aActive ==  iActiveNotifyOnChange) 
+        {
+        TInt err =  iActiveNotifyOnChange->iStatus.Int(); 
+        if (err!=KErrNone)
+            {
+            ERR_PRINTF2(_L("DoCancel Error %d"), err);
+            SetAsyncError(aIndex, err);
+            }
+        }   
+    DecOutstanding();   
+    }
+/**
+ * Helper method to map the DomainIds. This can be extendable for other domain Ids
+ */
+TBool CTestRStateAwareSession::MapToDomainId(TPtrC& aDomainIdName, TDmDomainId& aDomainId)
+    {
+    TBool ret = ETrue;
+    if (!(aDomainIdName.Compare(_L("KSM2UiServicesDomain1"))))
+        {
+        aDomainId = KSM2UiServicesDomain1;
+        }
+    else if (!(aDomainIdName.Compare(_L("KSM2HALDomain2"))))
+        {
+        aDomainId = KSM2HALDomain2;
+        }
+    else if (!(aDomainIdName.Compare(_L("KSM2HALDomain3"))))
+        {
+        aDomainId = KSM2HALDomain3;  
+        }
+    else if (!(aDomainIdName.Compare(_L("KSM2AppServicesDomain1"))))
+        {
+        aDomainId = KSM2AppServicesDomain1;  
+        }
+    else if (!(aDomainIdName.Compare(_L("KSM2AppServicesDomain2"))))
+        {
+        aDomainId = KSM2AppServicesDomain2;  
+        }
+    else if (!(aDomainIdName.Compare(_L("KSM2AppServicesDomain3"))))
+        {
+        aDomainId = KSM2AppServicesDomain3;  
+        } 
+    else if (!(aDomainIdName.Compare(_L("KSM2AppServicesDomain4"))))
+        {
+        aDomainId = KSM2AppServicesDomain4;  
+        } 
+    else 
+        {
+        ret = EFalse;
+        }   
+    return ret;
+    }
+
+/**
+ * Helper method to Map defined MainState on ssmstates.hrh
+ */
+TBool CTestRStateAwareSession::MapToMainState( TPtrC& aGetMainState, TUint16& aMainState )
+    {
+    TInt ret = ETrue;
+    if(!(aGetMainState.Compare(_L("ESsmStartup"))))
+        {
+        aMainState = ESsmStartup;
+        }
+    else if(!(aGetMainState.Compare(_L("ESsmNormal"))))
+        {
+        aMainState = ESsmNormal;
+        }    
+    else if(!(aGetMainState.Compare(_L("ESsmShutdown"))))
+        {
+        aMainState = ESsmShutdown;
+        }
+    else if(!(aGetMainState.Compare(_L("ESsmFail"))))
+        {
+        aMainState = ESsmFail;
+        }
+    else if(!(aGetMainState.Compare(_L("ESsmRestore"))))
+        {
+        aMainState = ESsmRestore;
+        }
+    else if(!(aGetMainState.Compare(_L("ESsmEmergencyCallsOnly"))))
+        {
+        aMainState = ESsmEmergencyCallsOnly;
+        }    
+    else
+        {
+        ret = EFalse;
+        }
+    return ret;
+    }
+