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

// @file ctlbsclientstep_srvconnectclose.cpp

// This is the class implementation for the Server Connect Close Tests

// 

//

#include "ctlbsclientstepsrvconnectclose.h"

#include <lbs.h>

/**

 * Destructor

 */

CT_LbsClientStep_SrvConnectClose::~CT_LbsClientStep_SrvConnectClose()

	{

	}

/**

 * Constructor

 */

CT_LbsClientStep_SrvConnectClose::CT_LbsClientStep_SrvConnectClose(CT_LbsClientServer& aParent) : CT_LbsClientStep(aParent)

	{

	SetTestStepName(KLbsClientStep_SrvConnectClose);

	}

/**

Static Constructor

*/

CT_LbsClientStep_SrvConnectClose* CT_LbsClientStep_SrvConnectClose::New(CT_LbsClientServer& aParent)

	{

	return new CT_LbsClientStep_SrvConnectClose(aParent);

	// Note the lack of ELeave.

	// This means that having insufficient memory will return NULL;

	}

/**

 * @return - TVerdict code

 * Override of base class pure virtual

 * Our implementation only gets called if the base class doTestStepPreambleL() did

 * not leave. That being the case, the current test result value will be EPass.

 */

TVerdict CT_LbsClientStep_SrvConnectClose::doTestStepL()

	{

	// Generic test step used to test the LBS Client server open and close APIs.

	INFO_PRINTF1(_L(">>CT_LbsClientStep_SrvConnectClose::doTestStepL()"));

	if (TestStepResult() == EPass)

		{

		// Carryout common test action.

		TInt err = KErrNone;

		err = iServer.Connect();	// Function under test.

		CleanupClosePushL(iServer);

		if (KErrNone == err)

			{

			INFO_PRINTF1(_L("server opened"));

			// Carryout unique test actions.

			TInt testCaseId;

			if (GetIntFromConfig(ConfigSection(), KTestCaseId, testCaseId))

				{

					switch (testCaseId)

					{

						// Test case LBS-ConnectClose-0001

						case 1:

							// Only requires create, connect and close for RPositionServer object

							// Connect and close occur outside the switch.

							break;

						// Test case LBS-ConnectClose-0002

						case 2:

							{

							OpenNetSim();

							RPositioner positioner;

							User::LeaveIfError(positioner.Open(iServer));

							TPositionInfo posInfo;

							TRequestStatus status;

							TPositionUpdateOptions optsA;

							TTimeIntervalMicroSeconds interval = 60 * 1000000;	// 1 minute interval

							// note: do 2 NPUDs because the first may complete before we close

							optsA.SetUpdateInterval(interval);

							positioner.NotifyPositionUpdate(posInfo, status);

							User::WaitForRequest(status);

							// this will not complete quickly, so we'll def have an outstanding request when we close

							positioner.NotifyPositionUpdate(posInfo, status);

							positioner.Close();

							CloseNetSim();

							}

							break;

						// Test case LBS-ConnectClose-0003

						case 3:

							{

							// Will panic, not interested in any return err.

							iServer.Connect();

							}

							break;

						// Test case LBS-ConnectClose-0004

						case 4:

							{

							RPositionServer server2;

							err = server2.Connect();	

							if(err != KErrNone)

								{

								INFO_PRINTF1(_L("<FONT><B>Server2 connect() didn't return KErrNone</B></FONT>"));

								SetTestStepResult(EFail);

								}

							else

								{

								server2.Close();

								}

							}

							break;

						//Test case LBS-ConnectClose-0005

						case 5:

						    {

						    // look in the kernels process list for the server

                            _LIT(KLocServerName, "*locserver*"); // NB you MUST use this server name for the location server. 

                                        				   // see KPositionServerName in the location server code (server side)

                            TFindThread serverSearcher(KLocServerName);

                            TFileName matchingFileName;

                            TInt matchCount = 0;

                            while(serverSearcher.Next(matchingFileName) == KErrNone)

	                          {

	                           // we have a match, there should only be one

	                           matchCount++;

	                          }

                            // start checking

                            if(matchCount!=1)

	                          {

	                           /* fail the test - we somehow have more than one location server running. 

	                              May have been one left over from a previous test */	                    

	                           INFO_PRINTF1(_L("somehow have more than one location server running"));

						       SetTestStepResult(EFail); 

	                          }

                            RThread iserverThread;

                            TInt err;

	                        err=iserverThread.Open(matchingFileName);

	                        User::LeaveIfError(err);

                            TThreadId iserverThreadId = iserverThread.Id();

                            // log the thread ID

                            // we now try and explicitly start a 2nd copy of the position server. 

                            //We expect not to get a 2nd copy, but to //connect to the existing copy. 

                            // create an connect to the lcoation server

                            RPositionServer server2;

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

                            CleanupClosePushL(server2);

                            // search again

                            serverSearcher.Find(KLocServerName);

                            matchCount = 0;

                            while(serverSearcher.Next(matchingFileName) == KErrNone)

	                            {

	                            // we have a match, there should only be one

	                             matchCount++;

	                            }

                            // sanity check

                           if(matchCount!=1)

	                        {

	                         /*SDA 3_50 Failure here

	                          fail the test - we have two servers.*/

	                         INFO_PRINTF1(_L("we have two servers"));

					         SetTestStepResult(EFail); 

	                        }

                          else

	                        {

	                        // we have one server so check the thread its match

	                        RThread server2Thread;

	                        err=server2Thread.Open(matchingFileName);

	                        User::LeaveIfError(err);

	                        TThreadId server2ThreadId = server2Thread.Id();

	                        if(iserverThreadId != server2ThreadId)

		                      {

		                       /*different thread ids - somehow

		                         fail the test here */

		                       INFO_PRINTF1(_L("Different thread ids "));

					           SetTestStepResult(EFail); 

		              		  }

	                        }

                            CleanupStack::PopAndDestroy(&server2);

				           }

                	       break;

                    default:

					User::Leave(KErrArgument);

					break;

					}

				}

			else

				{

				INFO_PRINTF1(_L("<FONT><B>Failed to read from ini file correctly</B></FONT>"));

				SetTestStepResult(EFail);

				}

			}

		else

			{

			INFO_PRINTF1(_L("<FONT><B>server failed to open</B></FONT>"));

			SetTestStepResult(EFail);

			}

		// Carryout final common test action.			

		CleanupStack::PopAndDestroy(&iServer);

		}

	INFO_PRINTF1(_L("<<CT_LbsClientStep_SrvConnectClose::doTestStepL()"));

	return TestStepResult();

	}