// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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:
// e32test\power\t_domain_slave.cpp
// 
//

#include <e32power.h>
#include <e32test.h>
#include <domainmember.h>
#include <domainmanager.h>
#include <e32panic.h>
#include <e32debug.h>

LOCAL_D RTest test(_L(" T_DOMAIN_SLAVE "));

// This will be run in its own thread as part of test #1. It should get killed when trying to connect 
// to the manager without appropriate caps set
TInt IncorrectClient(TAny*)
{
    	RDmDomain domain;
		TInt r = domain.Connect(KDmIdRoot);

		RDmDomainManager manager;
		r = manager.Connect();

        return(r);
}

GLDEF_C TInt E32Main()
	{
	test.Title();
	test.Start(_L("Testing"));

//	test.Next(_L("test security"));

	// Get arguments from the command line
	TInt len = User::CommandLineLength();
	test (len);
	TInt size = len * sizeof(TUint16);
	test (size == sizeof(TInt));
	TInt arg;
	TPtr cmd((TUint16*) &arg, len);
	User::CommandLine(cmd);

	TInt expected_result = PlatSec::IsCapabilityEnforced(ECapabilityPowerMgmt) ? KErrPermissionDenied : KErrNone;

	switch(arg)
		{
	case 0:
		{
        // This is the original t_domain_slave test, minus the panicking parts which now get
        // tested as case 1.

        test.Next(_L("test security -- 0"));       

		RDmDomain domain;
		TInt r = domain.Connect(KDmIdRoot);
		test (r == expected_result);

		break;
		}
    case 1:
        {

        test.Next(_L("test security -- 1")); 
        
        TBool jit = User::JustInTime();

        User::SetJustInTime(EFalse);

        _LIT(KPanicThread, "PanicThread");

        RThread testThread;

        TInt tt=testThread.Create(KPanicThread, IncorrectClient, KDefaultStackSize, 
            NULL, NULL);

        test (KErrNone == tt);

        TRequestStatus tStatus;
  //      testThread.Logon(tStatus);

        RUndertaker deathChecker;
        TInt dcOK = deathChecker.Create();

        test (KErrNone == dcOK);

        TInt nextDeadThread;

        deathChecker.Logon(tStatus, nextDeadThread);

        // threads are created in a suspended state. calling resume here starts the thread.
        testThread.Resume();
        User::WaitForRequest(tStatus);

        // If thread suicided for the correct reason --> successful test
        // NB. KErrPermissionDenied means that the server refused the 
        // connection because of incorrect capabilities

        RThread corpse;
        corpse.SetHandle(nextDeadThread);

        RDebug::Printf("Subthread exit type: %d", corpse.ExitType() );

        RDebug::Printf("Subthread exit reason: %d",corpse.ExitReason() );

        test (corpse.ExitType() == EExitKill);

        test (corpse.ExitReason() == KErrPermissionDenied);

        corpse.Close();
  
        // close the RUndertaker and test thread
        deathChecker.Close();
		CLOSE_AND_WAIT(testThread);

        User::SetJustInTime(jit);

		break;
        }
	default:
		User::Panic(_L("USER"), EInvariantFalse);
		break;
		}

	test.End();

	return KErrNone;
	}