// Copyright (c) 1994-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\prime\t_sem.cpp

 // Overview:

 // Test the RSemaphore type.

 // API Information:

 // RSemaphore

 // Details:

 // - Create two local semaphores, create a new thread, signal and wait on 

 // the semaphores numerous time. Kill the thread and verify results.

 // - Test creating a local semaphore with an initial count of -1. Verify 

 // failure results are as expected.

 // - Attempt to signal a semaphore without having done a create. Verify 

 // failure results are as expected.

 // - Attempt to signal a semaphore with signal count of -1. Verify failure

 // results are as expected.

 // Platforms/Drives/Compatibility:

 // All.

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include <e32test.h>

 #include <e32panic.h>

 const TInt KMaxIterations=0x100;

 const TInt KHeapSize=0x2000;

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

 LOCAL_D RSemaphore consumer;

 LOCAL_D RSemaphore producer;

 LOCAL_C TInt producerThreadEntryPoint(TAny* anArg)

 //

 // The entry point for the producer thread.

 //

 	{

 	anArg=anArg;

 	for (TInt i=0;i<KMaxIterations;i++)

 		{

 		consumer.Signal();

 		producer.Wait();

 		}

 	return(KErrNone);

 	}

 enum {EFuncCreateNeg,EFuncSignalWithoutCreate,EFuncSignalNeg};

 TInt CreateNegativeThread(TAny* aFunc)

 	{

 	RSemaphore sem;

 	switch((TInt)aFunc)

 		{

 	case EFuncCreateNeg:

 		sem.CreateLocal(-1);

 		break;

 	case EFuncSignalWithoutCreate:

 		sem.Signal();

 		break;

 	case EFuncSignalNeg:

 		sem.CreateLocal(1);

 		sem.Signal(-1);

 		break;

 	default:

 		test.Panic(_L("Hit default label"));

 		}

 	return KErrNone;

 	}

 GLDEF_C TInt E32Main()

 //

 // Test the RSemaphore type.

 //

     {

 	test.Title();

 	test.Start(_L("Create semaphores"));

 	TInt r=consumer.CreateLocal(1);

 	test(r==KErrNone);

 	r=producer.CreateLocal(0);

 	test(r==KErrNone);

 	test.Next(_L("Create thread"));

 	RThread producerThread;

 	r=producerThread.Create(_L("Producer"),producerThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,NULL);

 	test(r==KErrNone);

 	test.Next(_L("Logon thread"));

 	TRequestStatus tStat;

 	producerThread.Logon(tStat);

 	test(tStat==KRequestPending);

 	test.Next(_L("Resume thread"));

 	producerThread.Resume();

 	test(ETrue);

 	test.Next(_L("Run semaphores"));

 	for (TInt i=0;i<KMaxIterations;i++)

 		{

 		test.Printf(_L("\r%03d"),i);

 		consumer.Wait();

 		producer.Signal();

 		}

 	test.Printf(_L("\n"));

 	test.Next(_L("Wait for thread to die"));

 	User::WaitForRequest(tStat);

 	test(r==KErrNone);

 	test.Next(_L("Kill thread"));

 	producerThread.Kill(0);

 	TName c=producerThread.ExitCategory();

 	TInt reason=producerThread.ExitReason();

 	switch (producerThread.ExitType())

 		{

 	case EExitKill:

 		test.Printf(_L("KILL: %d [%S]\n"),reason,&c);

 		break;

 	case EExitTerminate:

 		test.Printf(_L("TERMINATE: %d [%S]\n"),reason,&c);

 		break;

 	case EExitPanic:

 		test.Printf(_L("PANIC: %d [%S]\n"),reason,&c);

 		break;

 	default:

 		test.Panic(_L("UNKNOWN: %d [%S]\n"),reason,&c);

 		break;

 		}

 	test.Next(_L("Cleanup"));

 	producerThread.Close();

 	CLOSE_AND_WAIT(producer);

 	CLOSE_AND_WAIT(consumer);

 	test.Next(_L("Create(-1)"));

 	RThread thread;

 	r=thread.Create(_L("SemTests"),CreateNegativeThread,0x1000,NULL,(TAny*)EFuncCreateNeg);

 	test(r==KErrNone);

 	TRequestStatus stat;

 	thread.Logon(stat);

 	TBool justInTime=User::JustInTime();

 	User::SetJustInTime(EFalse);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(stat==ESemCreateCountNegative);

 	User::SetJustInTime(justInTime);

 	test(thread.ExitReason()==ESemCreateCountNegative);

 	test(thread.ExitCategory()==_L("USER"));

 	test(thread.ExitType()==EExitPanic);

 	CLOSE_AND_WAIT(thread);

 	test.Next(_L("Signal without create"));

 	r=thread.Create(_L("SemTests"),CreateNegativeThread,0x1000,NULL,(TAny*)EFuncSignalWithoutCreate);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	User::SetJustInTime(EFalse);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(stat==EBadHandle);

 	User::SetJustInTime(justInTime);

 	test(thread.ExitReason()==EBadHandle);

 	test(thread.ExitCategory()==_L("KERN-EXEC"));

 	test(thread.ExitType()==EExitPanic);

 	CLOSE_AND_WAIT(thread);

 	test.Next(_L("Signal(-1)"));

 	r=thread.Create(_L("SemTests"),CreateNegativeThread,0x1000,NULL,(TAny*)EFuncSignalNeg);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	User::SetJustInTime(EFalse);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(stat==ESemSignalCountNegative);

 	User::SetJustInTime(justInTime);

 	test(thread.ExitReason()==ESemSignalCountNegative);

 	test(thread.ExitCategory()==_L("USER"));

 	test(thread.ExitType()==EExitPanic);

 	CLOSE_AND_WAIT(thread);

 	test.End();

 	return(KErrNone);

     }