1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Example CTestStep derived implementation

    15 // 

    16 //

    17 

    18 /**

    19  @file MultipleClientsStep.cpp

    20  @internalTechnology

    21 */

    22 #include "MultipleClientsStep.h"

    23 #include "Te_defproxySuiteDefs.h"

    24 

    25 CMultipleClientsStep::~CMultipleClientsStep()

    26 /**

    27  * Destructor

    28  */

    29 	{

    30 	}

    31 

    32 CMultipleClientsStep::CMultipleClientsStep()

    33 /**

    34  * Constructor

    35  */

    36 	{

    37 	SetTestStepName(KMultipleClientsStep);

    38 	}

    39 

    40 TVerdict CMultipleClientsStep::doTestStepPreambleL()

    41 /**

    42  * @return - TVerdict code

    43  * Override of base class virtual

    44  */

    45 	{

    46 	CTe_defproxySuiteStepBase::doTestStepPreambleL();

    47 	SetTestStepResult(EPass);

    48 	return TestStepResult();

    49 	}

    50 

    51 

    52 TVerdict CMultipleClientsStep::doTestStepL()

    53 /**

    54  * @return - TVerdict code

    55  * Override of base class pure virtual

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

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

    58  */

    59 	{

    60     StandardPrepareL();

    61     InitPsySettingsL(3, 

    62         KExtGpsPsy1, 1, 

    63         KIntGpsPsy1, 1,  

    64         KNetworkPsy2, 1);

    65         

    66     TRequestStatus status;

    67     TPositionInfo posInfo;

    68     TPositionUpdateOptions options;

    69     

    70     TRequestStatus status2;

    71     TPositionInfo posInfo2;

    72     TPositionUpdateOptions options2;

    73 

    74     RPositioner positioner2;

    75     User::LeaveIfError(positioner2.Open(iServer));

    76     CleanupClosePushL(positioner2);

    77     User::LeaveIfError(positioner2.SetRequestor(

    78             CRequestor::ERequestorService,

    79             CRequestor::EFormatApplication,

    80             KTdDefProxyTestName));

    81 

    82     //1. Make location request from both PSYs. All should succeed from ExtGpsPsy1

    83     positioner2.NotifyPositionUpdate(posInfo2,status2);

    84     PositionRequestWithCheck(posInfo, KErrNone, KExtGpsPsy1);

    85     User::WaitForRequest(status2);

    86     CheckExpectedResult(status2.Int(), KErrNone, KWrongRequestResult);                

    87     CheckExpectedResult(posInfo2.ModuleId(), KExtGpsPsy1, KWrongModuleIdReturned);    \

    88     

    89     //2. When all PSYs returns error code, both PSYs shall 

    90     //get error code from the first PSY

    91     ConfigPsyL(KExtGpsPsy1, 1,

    92         KConfigLRErrNoMemory            //KErrNoMemory 1s

    93         );

    94 

    95     ConfigPsyL(KIntGpsPsy1, 1,

    96         KConfigLRErrGeneral1s           //KErrGeneral 1s

    97         );

    98     

    99     ConfigPsyL(KNetworkPsy2, 1,

   100         KConfigLRErrNoMemory            //KErrNoMemory 1s

   101         );

   102         

   103     ConfigPsyL(positioner2, KExtGpsPsy1, 1,

   104         KConfigLRErrNoMemory            //KErrNoMemory 1s

   105         );

   106 

   107     ConfigPsyL(positioner2, KIntGpsPsy1, 1,

   108         KConfigLRErrGeneral1s           //KErrGeneral 1s

   109         );

   110     

   111     ConfigPsyL(positioner2, KNetworkPsy2, 1,

   112         KConfigLRErrNoMemory            //KErrNoMemory 1s

   113         );

   114 

   115     InitPsyListInDefaultProxyL();

   116     

   117     iPositioner.NotifyPositionUpdate(posInfo, status);

   118     positioner2.NotifyPositionUpdate(posInfo2, status2);

   119     User::WaitForRequest(status);

   120     CheckExpectedResult(status.Int(), KErrNoMemory, KWrongRequestResult);                

   121     User::WaitForRequest(status2);

   122     CheckExpectedResult(status2.Int(), KErrNoMemory, KWrongRequestResult);                

   123     

   124     //3. When PSY1 returns error code to to client 1. Location request 

   125     //from PSY2 shall fallback imediately

   126     ConfigPsyL(KExtGpsPsy1, 1,

   127         KConfigLRErrNoMemory            //KErrNoMemory 1s

   128         );

   129 

   130     ConfigPsyL(KIntGpsPsy1, 1,

   131         KConfigLRErrGeneral1s           //KErrGeneral 1s

   132         );

   133     

   134     ConfigPsyL(KNetworkPsy2, 1,

   135         KConfigLRNoError1s            //No error 1s

   136         );

   137         

   138     ConfigPsyL(positioner2, KExtGpsPsy1, 1,

   139         KConfigLRNoError10s            //No error in 10s

   140         );

   141 

   142     ConfigPsyL(positioner2, KIntGpsPsy1, 1,

   143         KConfigLRNoError10s           //KErrGeneral 1s

   144         );

   145     

   146     ConfigPsyL(positioner2, KNetworkPsy2, 1,

   147         KConfigLRNoError1s            //KErrNoMemory 1s

   148         );

   149     

   150     InitPsyListInDefaultProxyL();

   151     User::After(KSecond * 7); //Delay after configuration

   152     SET_TIME

   153     PositionRequestWithCheck(posInfo, KErrNone, KNetworkPsy2);

   154     INFO_PRINTF1(_L("1 3"));

   155     CHECK_TIME(3)

   156     

   157     //LR from second PSY

   158     positioner2.NotifyPositionUpdate(posInfo2, status2);

   159     User::WaitForRequest(status2);

   160     INFO_PRINTF1(_L("2 1"));

   161     CHECK_TIME(1) //PSY1 and PSY2 fallback imediately, LR completed from PSY3 in 1s

   162     CheckExpectedResult(status2.Int(), KErrNone, KWrongRequestResult);                

   163     CheckExpectedResult(posInfo2.ModuleId(), KNetworkPsy2, KWrongModuleIdReturned);

   164     

   165     //4. PSY state change beause of LR for client1 shall affect LR for client2 as well

   166     //

   167     ConfigPsyL(KExtGpsPsy1, 1,

   168         KConfigLRErrNoMemory            //KErrNoMemory 1s

   169         );

   170 

   171     ConfigPsyL(positioner2, KExtGpsPsy1, 1,

   172         KConfigLRNoError10s            //No error in 10s

   173         );

   174         

   175     InitPsyListInDefaultProxyL();

   176     User::After(KSecond * 7); //Delay after configuration

   177 

   178     SET_TIME

   179     positioner2.NotifyPositionUpdate(posInfo2, status2);

   180     PositionRequestWithCheck(posInfo, KErrNone, KIntGpsPsy1);

   181     INFO_PRINTF1(_L("3 1"));

   182     CHECK_TIME(1);

   183     User::WaitForRequest(status2);

   184     CheckExpectedResult(status2.Int(), KErrNone, KWrongRequestResult);                

   185     CheckExpectedResult(posInfo2.ModuleId(), KIntGpsPsy1, KWrongModuleIdReturned);  

   186     INFO_PRINTF1(_L("4 0"));

   187     CHECK_TIME(0);

   188     

   189     //5. Dynamic list change caused by PSY1 shall not affect PSY list orders of client2

   190     //if location request is already made.

   191     ConfigPsyL(KExtGpsPsy1, 1,

   192         KConfigLRErrNoMemory            //KErrNoMemory 1s

   193         );

   194     

   195     ConfigPsyL(KIntGpsPsy1, 2,

   196         KConfigLRNoError1s,             //No error in 10s

   197         KConfigLRErrNoMemory            //KErrNoMemory 1s

   198         );

   199         

   200     ConfigPsyL(positioner2, KIntGpsPsy1, 2,

   201         KConfigLRNoError1s,           //No error in 10s

   202         KConfigLRNoError20s            //No error in 10s

   203         );

   204 

   205     ConfigPsyL(positioner2, KExtGpsPsy1, 1,

   206         KConfigLRNoError45s            //No error in 45s

   207         );

   208 

   209     InitPsyListInDefaultProxyL();

   210     User::After(KSecond * 7); //Delay after configuration

   211 

   212     PositionRequestWithCheck(posInfo, KErrNone, KIntGpsPsy1);

   213     

   214     //Location request from client 2 shall be completed imediatelly, since 

   215     //IntGpsPsy shall be the first on the dynamic list

   216     SET_TIME

   217     positioner2.NotifyPositionUpdate(posInfo2, status2);

   218     User::WaitForRequest(status2);

   219     CheckExpectedResult(status2.Int(), KErrNone, KWrongRequestResult);                

   220     CheckExpectedResult(posInfo2.ModuleId(), KIntGpsPsy1, KWrongModuleIdReturned);  

   221     INFO_PRINTF1(_L("5 1"));

   222     CHECK_TIME(1);

   223     

   224     //Make location request from client 2

   225     positioner2.NotifyPositionUpdate(posInfo2, status2);

   226     SET_TIME

   227     PositionRequestWithCheck(posInfo, KErrNone, KExtGpsPsy1);

   228     INFO_PRINTF1(_L("6 1"));

   229     CHECK_TIME(1)

   230     User::WaitForRequest(status2);

   231     CheckExpectedResult(status2.Int(), KErrNone, KWrongRequestResult);                

   232     CheckExpectedResult(posInfo2.ModuleId(), KNetworkPsy2, KWrongModuleIdReturned);  

   233     INFO_PRINTF1(_L("7 0"));

   234     CHECK_TIME(0)

   235     

   236 

   237     CleanupStack::PopAndDestroy(&positioner2);

   238     //Cleanup

   239     StandardCleanup();

   240     return TestStepResult();

   241 	}

   242 

   243 

   244 

   245 TVerdict CMultipleClientsStep::doTestStepPostambleL()

   246 /**

   247  * @return - TVerdict code

   248  * Override of base class virtual

   249  */

   250 	{

   251 	CTe_defproxySuiteStepBase::doTestStepPostambleL();

   252 	return TestStepResult();

   253 	}