// Copyright (c) 2008-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:
//

/**
 @file
 @test
 @internalComponent - Internal Symbian test code 
*/

#include "susadaptionserver.h"

#include "tsus_step_adaptionserver.h"

/**
 * Client interface to simulate Heap failure at server side
 */
TInt RTestSusAdaptationCli::SetHeapFailure(TInt aFailureRate)
    {
    if(Handle())
        {
        return SendReceive(EDebugSetHeapFailure, TIpcArgs(aFailureRate));
        }
    return KErrDisconnected;
    }

/**
 * Client interface to restore Heap failure at server side
 */
TInt RTestSusAdaptationCli::UnSetHeapFailure()
    {
    if(Handle())
        {
        return SendReceive(EDebugUnSetHeapFailure);
        }
    return KErrDisconnected;
    }
 
CSusAdaptionServerTest::~CSusAdaptionServerTest()
	{
	}

CSusAdaptionServerTest::CSusAdaptionServerTest()
	{
	SetTestStepName(KTSusAdaptionServerStep);
	}

/** */
TVerdict CSusAdaptionServerTest::doTestStepPreambleL()
	{
	return CTestStep::doTestStepPreambleL();
	}

/** 
 Old Test CaseID 		APPFWK-SUS-0011
 New Test CaseID 		DEVSRVS-SSMA-SUS-0011
 */

TVerdict CSusAdaptionServerTest::doTestStepL()
	{
	INFO_PRINTF1(_L("CSusAdaptionServerTest tests started...."));

	__UHEAP_MARK;		
	TRAPD(err, doTestForMemoryLeaksL());
	TEST(err == KErrNone);

	TRAP(err, doTestProcessCriticalL());
	TEST(KErrNone == err || KErrAlreadyExists == err);
	TRAP(err, doTestOOML());
	TEST(err == KErrNone);	
	
	doTestForNormalEmergencyCallinOOM();
	doTestForEmergencyCallOOM();
	doTestForSettingPriorityClient();
	
	__UHEAP_MARKEND;
	
	INFO_PRINTF1(_L("....CSusAdaptionServerTest tests completed!"));
	return TestStepResult();	
	}

/** */
TVerdict CSusAdaptionServerTest::doTestStepPostambleL()
	{
	return CTestStep::doTestStepPostambleL();
	}


void CSusAdaptionServerTest::doTestForMemoryLeaksL()
	{
	INFO_PRINTF1(_L("doTestForMemoryLeaksL tests started...."));
	
	INFO_PRINTF1(_L("Checking for memoryleaks in SusAdaptionServer destructor"));

	INFO_PRINTF1(_L("Create active scheduler."));
	CActiveScheduler* sched = new(ELeave) CActiveScheduler;
	CleanupStack::PushL (sched );
	CActiveScheduler::Install (sched );
	
	__UHEAP_MARK;
	StartAndDestroyServerL();
	__UHEAP_MARKEND;
	
	INFO_PRINTF1(_L("Destroy active scheduler."));
	CleanupStack::PopAndDestroy(sched);

	INFO_PRINTF1(_L("doTestForMemoryLeaksL tests completed."));
	}


	
void CSusAdaptionServerTest::doTestProcessCriticalL()
	{
	INFO_PRINTF1(_L("doTestProcessCriticalL tests started...."));

	INFO_PRINTF1(_L("Checking that SusAdaptionServer sets it thread to critical"));
	
	INFO_PRINTF1(_L("Get the critical state of the current thread"));
	User::TCritical before = User::Critical();
	INFO_PRINTF3(_L("The critical state of the current thread: expected %d, actual %d"), User::ENotCritical, before);
	TESTL(before == User::ENotCritical);
	
	CActiveScheduler* sched = new(ELeave) CActiveScheduler;
	CleanupStack::PushL (sched );
	CActiveScheduler::Install (sched );
	INFO_PRINTF1(_L("Create SSM adaptation server."));
	CSsmAdaptationServer* server = CSsmAdaptationServer::NewLC();
	
	INFO_PRINTF1(_L("Get the critical state of the current thread"));
	User::TCritical critical = User::Critical();
	INFO_PRINTF3(_L("The critical state of the current thread: expected %d, actual %d"), User::ESystemCritical, critical);
	TEST(critical == User::ESystemCritical);

	INFO_PRINTF1(_L("Destroy SSM adaptation server."));
	CleanupStack::PopAndDestroy(server);
	CleanupStack::PopAndDestroy(sched);
	
	User::TCritical after = User::Critical();
	INFO_PRINTF3(_L("The critical state of the current thread: expected %d, actual %d"), User::ENotCritical, after);
	TESTL(after == User::ENotCritical);

	INFO_PRINTF1(_L("doTestProcessCriticalL tests completed."));
	}
	
void CSusAdaptionServerTest::doTestOOML()
	{
	INFO_PRINTF1(_L("doTestOOML tests started...."));

	INFO_PRINTF1(_L("Create active scheduler."));
	CActiveScheduler* sched = new(ELeave) CActiveScheduler;
	CleanupStack::PushL (sched );
	CActiveScheduler::Install (sched );
	
	TInt ret = KErrNoMemory;
	for(TInt fail=0; ret == KErrNoMemory; fail++)
		{
		__UHEAP_FAILNEXT(fail);
		__UHEAP_MARK;
		INFO_PRINTF2(_L("Iteration #: %d"), fail);
		TRAP(ret, StartAndDestroyServerL());
		INFO_PRINTF2(_L("StartAndDestroyServerL() returned: %d"), ret);
		__UHEAP_SETFAIL(RHeap::ENone,0);// turn failure off
		__UHEAP_MARKEND;
		TEST((ret==KErrNoMemory || ret==KErrNone));
		}

	INFO_PRINTF1(_L("Destroy active scheduler."));
	CleanupStack::PopAndDestroy(sched);
	INFO_PRINTF1(_L("doTestOOML tests completed."));
	}

void CSusAdaptionServerTest::StartAndDestroyServerL()
	{
	INFO_PRINTF1(_L("Create SSM adaptation server."));
	CSsmAdaptationServer* server = NULL;
	TRAPD(err, server = CSsmAdaptationServer::NewLC(); CleanupStack::Pop(server));
	TEST(err == KErrAlreadyExists || err == KErrNone);
	if(err != KErrNone && err != KErrAlreadyExists)
		User::LeaveIfError(err);
	INFO_PRINTF1(_L("Destroy SSM adaptation server."));
	delete server;
	}

/**
 * Tests for client calling Activate/Deactivate Rf without setting as priorityclient.
 */
void CSusAdaptionServerTest::doTestForNormalEmergencyCallinOOM()
    {
    INFO_PRINTF1(_L("doTestForNormalEmergencyCallinOOM started."));
    __UHEAP_MARK;
    RTestSusAdaptationCli adaptationclitest;    
    TInt err = adaptationclitest.Connect();
    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);
    //Normal client calling ActivateRfForEmergencyCall Rf in OOM condition. This call must fail with KErrNoMemory 
    //as there is no memory reserved.
    adaptationclitest.ActivateRfForEmergencyCall(status);
    // Wait for completion of requests
    User::WaitForRequest(status);    
    //Restore OOM condition
    adaptationclitest.UnSetHeapFailure();
    adaptationclitest.Close();
    User::__DbgSetAllocFail(EFalse, RAllocator::ENone, 1);
    User::__DbgSetAllocFail(ETrue, RAllocator::ENone, 1);
    TEST(status.Int() == KErrNoMemory);
    __UHEAP_MARKEND;
    INFO_PRINTF1(_L("doTestForNormalEmergencyCallinOOM completed.")); 
    }


/**
 * Tests for performing ActivateRfForEmergencyCall + DeactivateRfForEmergencyCall 
 *  during OOM condition by priority clients.
 */
void CSusAdaptionServerTest::doTestForEmergencyCallOOM()
    {
    INFO_PRINTF1(_L("doTestForEmergencyCallOOM started."));
    __UHEAP_MARK;
    RTestSusAdaptationCli adaptationclitest;    
    TInt err = adaptationclitest.Connect();
    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);
    //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; 
    adaptationclitest.ActivateRfForEmergencyCall(status1); 
    adaptationclitest.ActivateRfForEmergencyCall(status2);
    adaptationclitest.ActivateRfForEmergencyCall(status3);
    //Wait for request to complete
    User::WaitForRequest(status1);
    User::WaitForRequest(status2);
    User::WaitForRequest(status3);
    TEST(status1.Int() == KErrNone);
    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
    adaptationclitest.ActivateRfForEmergencyCall(status1); 
    adaptationclitest.ActivateRfForEmergencyCall(status2);
    adaptationclitest.DeactivateRfForEmergencyCall(status3);
    adaptationclitest.DeactivateRfForEmergencyCall(status4);
    adaptationclitest.DeactivateRfForEmergencyCall(status5);
    adaptationclitest.DeactivateRfForEmergencyCall(status6);
    // Wait for completion of requests
    User::WaitForRequest(status1);
    User::WaitForRequest(status2);
    User::WaitForRequest(status3);
    User::WaitForRequest(status4);
    User::WaitForRequest(status5);
    User::WaitForRequest(status6);    
    
    //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(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);
    
    adaptationclitest.Close();
    __UHEAP_MARKEND;
    INFO_PRINTF1(_L("doTestForEmergencyCallOOM completed."));        
    }

/**
 * Tests to Set PriorityClient from two different clients.
 */
void CSusAdaptionServerTest::doTestForSettingPriorityClient()
    {
    INFO_PRINTF1(_L("doTestForSettingPriorityClient started."));
    __UHEAP_MARK;
    RTestSusAdaptationCli adaptationclitest1;
    TInt err = adaptationclitest1.Connect();
    INFO_PRINTF2(_L("adaptationclitest1.Connect() returned Error %d : Expected Error is KErrNone."),err);   
    TEST(err == KErrNone);
    
    RTestSusAdaptationCli adaptationclitest2;
    err = adaptationclitest2.Connect();
    INFO_PRINTF2(_L("adaptationclitest2.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);
    
    // Restore OOM condition
    adaptationclitest1.Close();
    adaptationclitest2.Close();
    __UHEAP_MARKEND;
    INFO_PRINTF1(_L("doTestForSettingPriorityClient completed."));
    }