// 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;

	}