// Copyright (c) 1996-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\bench\t_proc2.cpp
// The other half of the process relative type test stuff
// 
//
										
#include <e32test.h>
#include "t_proc.h"

RTest test(_L("T_PROC2"));
RTest testSvr(_L("Server"));

void CMySession::DisplayName(const RMessage2& aMessage, const TDesC& aText)
//
// Display the client's name.
//
	{
	RThread client;
	TInt r = aMessage.Client(client);
	test(r == KErrNone);
	TFullName name = client.FullName();
	client.Close();
	testSvr.Printf(_L("Session %S\n%S\n"), &name, &aText);
	}

void CMySession::ServiceL(const RMessage2& aMessage)
//
// Handle messages for this server.
//
	{

	TInt r=KErrNone;
	TBuf<0x100> b;
	switch (aMessage.Function())
		{
	case CMyServer::EDisplay:
		TRAP(r,aMessage.ReadL(0,b));
		DisplayName(aMessage, b);
		break;
	case CMyServer::ERead:
		TRAP(r,aMessage.ReadL(0,b));
		if (r==KErrNone && b!=_L("Testing read"))
			r=KErrGeneral;
		if (r==KErrNone)
			{
			TRAP(r,aMessage.ReadL(0,b,-1));
			if (r==KErrNone)
				r=KErrGeneral;
			if (r==KErrArgument)
				r=KErrNone;
			}
		if (r==KErrNone)
			{
			TInt i = TInt(0xfefefefe);
			TRAP(r,aMessage.ReadL(i,b));
			if (r==KErrNone)
				r=KErrGeneral;
			if (r==KErrBadDescriptor)
				r=KErrNone;
			}
		break;
	case CMyServer::EWrite:
		TRAP(r,aMessage.WriteL(0,_L("It worked!")));
		if (r==KErrNone)
			{
			TRAP(r,aMessage.WriteL(0,b,-1));
			if (r==KErrNone)
				r=KErrGeneral;
			if (r==KErrArgument)
				r=KErrNone;
			}
		if (r==KErrNone)
			{
			TRAP(r,aMessage.WriteL(1,b));
			if (r==KErrNone)
				r=KErrGeneral;
			if (r==KErrBadDescriptor)
				r=KErrNone;
			}
		break;
	case CMyServer::ETest:
		break;
	case CMyServer::EStop:
		CActiveScheduler::Stop();
		break;
	default:
		r=KErrNotSupported;
		}
	aMessage.Complete(r);
	}

CMyServer* CMyServer::New(TInt aPriority)
//
// Create a new CMyServer.
//
	{

	return new CMyServer(aPriority);
	}

CMyServer::CMyServer(TInt aPriority)
//
// Constructor.
//
	: CServer2(aPriority)
	{}

CSession2* CMyServer::NewSessionL(const TVersion& aVersion, const RMessage2&) const
//
// Create a new client for this server.
//
	{

	TVersion v(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
	if (!User::QueryVersionSupported(v,aVersion))
		User::Leave(KErrNotSupported);
	return(new(ELeave) CMySession());
	}

void CMyActiveScheduler::Error(TInt anError) const
//
// Called if any Run() method leaves.
//
	{

	testSvr.Panic(anError,_L("CMyActiveScheduler::Error"));
	}

LOCAL_C TInt serverThreadEntryPoint(TAny*)
//
// The entry point for the producer thread.
//
	{

//	testSvr.Title();
//	testSvr.Start(_L("Create CActiveScheduler"));
	CMyActiveScheduler* pR=new CMyActiveScheduler;
//	testSvr(pR!=NULL);
	CActiveScheduler::Install(pR);
//
//	testSvr.Next(_L("Create CMyServer"));
	CMyServer* pS=CMyServer::New(0);
//	testSvr(pS!=NULL);
//
//	testSvr.Next(_L("Start CMyServer"));

	pS->Start(KServerName);

//	TInt r=pS->Start();
//	testSvr(r==KErrNone);
//
//	testSvr.Next(_L("Signal to client that we have started"));
//	client.Signal();
//
//	testSvr.Next(_L("Start CActiveScheduler"));
	CActiveScheduler::Start();
//
//	testSvr.Next(_L("Exit server"));
//	testSvr.Close();

	return(KErrNone);
	}


void init()
	{
	// create server thread
	RThread server;
	TInt r=server.Create(_L("Server"),serverThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,NULL);
	test(r==KErrNone);
	server.SetPriority(EPriorityMore);
	server.Resume();

	r=globSem1.OpenGlobal(_L("GlobSem1"));
	test(r==KErrNone);
	r=globSem2.OpenGlobal(_L("GlobSem2"));
	test(r==KErrNone);
	globSem1.Signal(); // finished init
	}

void sharedChunks()
	{

	globSem2.Wait(); // wait for chunk test to be set up

	RChunk c;
	TInt r=c.OpenGlobal(_L("Marmalade"),EFalse);
	test(r==KErrNone);
    test.Printf(_L("Chunk opened\r\n"));
	TUint8* base=c.Base();
    test.Printf(_L("Chunk address %x\r\n"),base);
	for (TInt8 i=0;i<10;i++)
		test(*base++==i); // check the chunk has 0-9
    test.Printf(_L("Chunk contents tested\r\n"));
  	c.Close();
	globSem1.Signal(); // say we've done it
	}

TInt sharedChunks2(TAny* /*aDummy*/)
	{

    RTest test(_L("Shared Chunks 2"));

	globSem2.Wait(); // wait for chunk test to be set up

	RChunk c;
	TInt r=c.OpenGlobal(_L("Marmalade"),EFalse);
	test(r==KErrNone);
    test.Printf(_L("Chunk opened\r\n"));
	TUint8* base=c.Base();
    test.Printf(_L("Chunk address %x\r\n"),base);
	for (TInt8 i=0;i<10;i++)
		test(*base++==i); // check the chunk has 0-9
    test.Printf(_L("Chunk contents tested\r\n"));
  	c.Close();
	globSem1.Signal(); // say we've done it
    return(KErrNone);
	}

TInt E32Main()
	{	
 
	test.Title();

	test.Start(_L("Testing process stuff 2"));

	test.Next(_L("Check that T_PROC1 is running"));
	TFindProcess fProcess(_L("*T_PROC1*"));
	TFullName n;
	TInt r=fProcess.Next(n);
	if (r!=KErrNone)
		{
		test.Printf(_L("This test should not be run from the command line.\n"));
		test.Printf(_L("Run T_PROC1, which loads this test.\n"));
		test.End();
		test.Close();
		return (KErrNone);
		}

	test.Next(_L("Initialize"));
	init();

	test.Next(_L("Shared chunks from primary thread"));
	sharedChunks();
	
	test.Next(_L("Shared chunks from secondary thread"));
	RThread t;
	r=t.Create(_L("Shared chunks 2"),sharedChunks2,KDefaultStackSize,KHeapSize,KHeapSize,NULL);
    test(r==KErrNone);
	TRequestStatus s;
	t.Logon(s);
	t.Resume();
	User::WaitForRequest(s);
	test(s==KErrNone);
	CLOSE_AND_WAIT(t);

	test.Close();
	globSem1.Signal(); // tell proc1 I'm ready

//	test.Next(_L("Wait for first process to do speed tests"));
	globSem2.Wait();
	
	return(KErrNone);
	}