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

// Author	Julia Blumin 

// Date		March 2000

// 

//

#include <e32test.h>

#include <e32hal.h>

#include <f32fsys.h>

#include <s32file.h>

#include <barsc.h>

#include <e32uid.h>

//#include <prsreg.h>

//#include <smdef.h>

#include "WapWatcher.h"		

#include <es_sock.h>

#include <e32test.h>

#include "gsmubuf.h"

#include "gsmumsg.h"

#include "smsuaddr.h"

#include "smsustrm.h"

#include "MsvTestUtilsBase.h"

#include "BioTestUtils.h"

#include "WapSocketWatcher.h"

#include "cmstd.h"

_LIT(KTelephoneNumber,"+447747065443");

//_LIT(KTelephoneNumber,"+447771656004");

//_LIT(KTelephoneNumber,"+44802258765");

_LIT(KServiceCenterAddress,"+44385016005");

RTest test(_L("Wap Watcher.dll Harness"));

RSocketServ gSS;

RSocket gSocket;

//----------------------------------------------------------------------------------------

TFileName theLogName;

RFile theLog;

RFs theFs;

RTest gTest(_L("WapWatcher Test Harness"));

CBioTestUtils *theUtils;

//----------------------------------------------------------------------------------------

const TUid KTestUid			= {0x10001270};

const TUid KTestUid1		= {0x10220108};

const TUid KTestUid2		= {0x10220109};

void TestScheduler::Error( TInt anError ) const

	{

	User::Leave( anError );

	}

//----------------------------------------------------------------------------------------

LOCAL_C void InitTestUtils()

//----------------------------------------------------------------------------------------

	{

	testUtils = CBioTestUtils::NewLC(gTest,ETuCleanMessageFolder);

	gTest.Start(_L("CBIODatabase"));

	gTest.Console()->ClearScreen();

	}

//----------------------------------------------------------------------------------------

LOCAL_C void CloseTestUtils()

//----------------------------------------------------------------------------------------

	{

	testUtils->TestHarnessCompleted();

	CleanupStack::PopAndDestroy(testUtils);

	gTest.End();

	gTest.Close();

	}

//----------------------------------------------------------------------------------------

LOCAL_C void SetupSchedulerL()

//----------------------------------------------------------------------------------------

	{

	CActiveScheduler::Install(new(ELeave)CActiveScheduler);

	User::LeaveIfError(theFs.Connect());

	TFileName logName;

	theLogName.Copy(RProcess().FileName());

	TInt start = theLogName.LocateReverse('\\');

	TInt end = theLogName.LocateReverse('.');

	theLogName = theLogName.Mid(start + 1, end - start - 1);

	// create the log filename

	theLogName.Insert(0, _L("C:\\"));

#if defined(__WINS__)

	theLogName.Append(_L(".WINS."));

#else

	theLogName.Append(_L(".MARM."));

#endif

#if defined(_UNICODE)

	theLogName.Append(_L("UNICODE."));

#else

	theLogName.Append(_L("ASCII."));

#endif

#if defined(_DEBUG)

	theLogName.Append(_L("DEB."));

#else

	theLogName.Append(_L("REL."));

#endif

	theLogName.Append(_L("LOG"));

	// create the logfile

	User::LeaveIfError(theLog.Replace(theFs, theLogName, EFileWrite|EFileShareExclusive));

	TBuf8<256> text;

	text.Copy(theLogName);

	theLog.Write(text);

	theLog.Write(_L8("\nTest results\n"));

	}

LOCAL_C void CloseScheduler()

	{

	theLog.Write(_L8("Tests completed\n"));

	test.Printf(_L("Results saved in %S"), &theLogName);

	theLog.Close();

	theFs.Close();

	delete CActiveScheduler::Current();

	}

LOCAL_C void OpenEsock()

	{

    RSocketServ gSS;

	test.Start(_L("Opening socket server"));

	TRAPD(ret,gSS.Connect());

    test(ret==KErrNone);

    test.Next(_L("Finding protocols"));

	TProtocolDesc protoInfo;

	TProtocolName protocolname=KSmsDatagram;

	ret=gSS.FindProtocol(protocolname,protoInfo);

	if(ret!=KErrNone)

		{

		test.Printf(_L("Dummy protocol not loaded"));

		test(EFalse);

		}

	test.Next(_L("Making sockets"));

	TUint numProtocols;

	test(gSS.NumProtocols(numProtocols)==KErrNone);

	test.Printf(_L("Loaded %d protocols\n"),numProtocols);

//	ret=gSS.GetProtocolInfo(1,protoInfo);

//	test(ret==KErrNone);

	test.Printf(_L("Creating Family: %d,Sock: %d,protocol: %d\n\r"),protoInfo.iAddrFamily,protoInfo.iSockType,protoInfo.iProtocol);

	ret=gSocket.Open(gSS,protoInfo.iAddrFamily,protoInfo.iSockType,protoInfo.iProtocol);

	if (ret!=KErrNone)

		test.Printf(_L("Failed %d\n\r"),ret);

	test(ret==KErrNone);

	test.Printf(_L("created %s socket OK\n"),protoInfo.iName.PtrZ());

	}

LOCAL_C void CloseEsock()

	{

	test.Next(_L("Closing socket"));

	gSocket.Close();

	test.Next(_L("Closing ESOCK"));

	gSS.Close();

	}

//----------------------------------------------------------------------------------------

LOCAL_C void SendMessage()

//----------------------------------------------------------------------------------------

	{

//

// Sending message

//

	TSmsAddr smsaddr;

	smsaddr.SetSmsAddrFamily(ESmsAddrSendOnly);

	TRAPD(ret, gSocket.Bind(smsaddr));

    test(ret==KErrNone);

	User::After(10000000);

	test.Next(_L("Sending message"));

	CSmsBuffer* buffer=CSmsBuffer::NewL();

	CSmsMessage* smsmessage=CSmsMessage::NewL(CSmsPDU::ESmsSubmit,buffer);

	CleanupStack::PushL(smsmessage);

	smsmessage->SetToFromAddressL(KTelephoneNumber);

	smsmessage->SmsPDU().SetServiceCenterAddressL(KServiceCenterAddress);

	buffer->InsertL(0,_L("Dis ees a message\n"));

	CSmsSubmit& submit=(CSmsSubmit&) smsmessage->SmsPDU();

	submit.SetStatusReportRequest(EFalse);

//	submit.SetStatusReportRequest(ETrue);

	submit.SetValidityPeriod(TTimeIntervalMinutes(30));

	RSmsSocketWriteStream writestream(gSocket);

	writestream << *smsmessage;

	writestream.CommitL();

	TPckgBuf<TUint> sbuf;

	TRequestStatus status;

	gSocket.Ioctl(KIoctlSendSmsMessage,status,&sbuf, KSolSmsProv);

	User::WaitForRequest(status);

	User::LeaveIfError(status.Int());

	delete smsmessage;

	}

//----------------------------------------------------------------------------------------

LOCAL_C void CreateDestroySocketWatcher(TInt aTestNumber)

//----------------------------------------------------------------------------------------

	{

	testUtils->TestStart(aTestNumber, _L("Create/Destroy Sock Watchers"));

	// reserve some space on the cleanup stack

/*	for (TInt ii=0;ii<1000;++ii)

		CleanupStack::PushL(&ii);

	CleanupStack::Pop(1000);

	CWapWatcher* WapWatcher1 = CWapWatcher::NewL(theFs, log);

	delete SocketWatcher1;

	__UHEAP_RESET;

	__UHEAP_MARK;

	CWapWatcher* WapWatcher2 = CWapWatcher::NewL(theFs, log);

	delete SocketWatcher2;

	__UHEAP_MARKEND;

*/

	testUtils->TestFinish(aTestNumber,0 );

	}

//----------------------------------------------------------------------------------------

LOCAL_C void StartWatchers(TInt aTestNumber)

//----------------------------------------------------------------------------------------

	{ 

	testUtils->TestStart(aTestNumber, _L("Starting Watchers"));

	CWatcher* watcher = NULL;

	SetupSchedulerL();

	CWatcherWait* wait = CWatcherWait::NewLC();

	// Create the watcher

	TRAPD(error, watcher = CWatcher::NewL(CActive::EPriorityStandard));

	if (error)

	{

		testUtils->TestFinish(aTestNumber,error );

		return;

	}

	CleanupStack::PushL(watcher);

	// Make sure watcher starts

	test.Start(_L("Waiting for SMS Messages"));

	wait->Start();

	watcher->Start(wait->iStatus);

	// Just Start and wait...

	CActiveScheduler::Start();

	testUtils->WriteComment(_L("Started Watchers"));

	//TestWatcherL();

	theLog.Write(_L8("Test 1 OK\n"));

	// Close the watcher

	watcher->Cancel();

	test(wait->iStatus.Int() == KErrCancel);

	test.End();

	CleanupStack::PopAndDestroy(2); // watcher, wait

	CloseScheduler();

	testUtils->TestFinish(aTestNumber,0 );

	}

//----------------------------------------------------------------------------------------

LOCAL_C void doMainL()

//----------------------------------------------------------------------------------------

	{

	TInt aTestNumber = 1;

	InitTestUtils();

	test.Start(_L("Create/Destroy Socket Watcher"));

	CreateDestroySocketWatcher(aTestNumber++);

	test.Next(_L("Start Watchers"));

	//SendMessage();

	StartWatchers(aTestNumber++);

	CloseTestUtils();

	}

//----------------------------------------------------------------------------------------

GLDEF_C TInt E32Main()

//----------------------------------------------------------------------------------------

	{	

__UHEAP_MARK;	

	CTrapCleanup* theCleanup = CTrapCleanup::New();

	TRAPD(ret,doMainL());		

	test(ret==KErrNone);

	delete theCleanup;	

__UHEAP_MARKEND;

	return(KErrNone);

	}