1 // Copyright (c) 2001-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 // StateMachineImpl.cpp

    15 // This is the header file for StateMachine test implementation

    16 // 

    17 //

    18 

    19 #ifndef STATEMACHINESTEP_H_

    20 #define STATEMACHINESTEP_H_

    21 

    22 #include "ElementServer.h"

    23 #include "StateMachineImpl.h"

    24 

    25 #ifdef SYMBIAN_OLD_EXPORT_LOCATION

    26 #include <testexecutestepbase.h>

    27 #else

    28 #include <test/testexecutestepbase.h>

    29 #endif

    30 

    31 /*

    32  * @file StateMachineStep.h

    33  */

    34 

    35 _LIT(KElementStateMachineStep1_1,"ElementStateMachineStep0101");

    36 _LIT(KElementStateMachineStep1_2,"ElementStateMachineStep0102");

    37 _LIT(KElementStateMachineStep1_3,"ElementStateMachineStep0103");

    38 _LIT(KElementStateMachineStep1_4,"ElementStateMachineStep0104");

    39 _LIT(KElementStateMachineStep1_5,"ElementStateMachineStep0105");

    40 _LIT(KElementStateMachineStep2_1,"ElementStateMachineStep0201");

    41 _LIT(KElementStateMachineStep2_2,"ElementStateMachineStep0202");

    42 _LIT(KElementStateMachineStep2_3,"ElementStateMachineStep0203");

    43 _LIT(KElementStateMachineStep2_4,"ElementStateMachineStep0204");

    44 _LIT(KElementStateMachineStep2_5,"ElementStateMachineStep0205");

    45 _LIT(KElementStateMachineStep2_6,"ElementStateMachineStep0206");

    46 _LIT(KElementStateMachineStep2_7,"ElementStateMachineStep0207");

    47 _LIT(KElementStateMachineStep2_8,"ElementStateMachineStep0208");

    48 _LIT(KElementStateMachineHistory,"History");

    49 _LIT(KElementStateMachineLastError,"LastError");

    50 _LIT(KElementStateMachNullRAllcLngth, "NullReAllocLength");

    51 _LIT(KElementStateMachSetRAllocLngth, "SetReAllocLength");

    52 

    53 class CElementStateMachineTestBase

    54     {

    55 protected:

    56     void Setup();

    57     void Destroy();

    58 protected:

    59     TVerdict iResult;

    60     CActiveScheduler* iActiveScheduler;

    61     CStateMachineImpl* iStateMachine;

    62     };

    63 

    64 class CElementStateMachineStep1_1 : public CTestStep, public CElementStateMachineTestBase

    65     {

    66 public:

    67     CElementStateMachineStep1_1();

    68     virtual TVerdict doTestStepPreambleL();

    69     virtual TVerdict doTestStepPostambleL();

    70     virtual TVerdict doTestStepL();

    71 private:

    72     TInt iHistory;

    73     };

    74 

    75 class CElementStateMachineStep1_2 : public CTestStep, public CElementStateMachineTestBase

    76     {

    77 public:

    78     CElementStateMachineStep1_2();

    79     virtual TVerdict doTestStepPreambleL();

    80     virtual TVerdict doTestStepPostambleL();

    81     virtual TVerdict doTestStepL();

    82 private:

    83     TInt iLastError;

    84     };

    85 

    86 class CElementStateMachineStep1_3 : public CTestStep, public CElementStateMachineTestBase

    87     {

    88 public:

    89     CElementStateMachineStep1_3();

    90     virtual TVerdict doTestStepPreambleL();

    91     virtual TVerdict doTestStepPostambleL();

    92     virtual TVerdict doTestStepL();

    93     };

    94 

    95 class CElementStateMachineStep1_4 : public CTestStep, public CElementStateMachineTestBase

    96     {

    97 public:

    98     CElementStateMachineStep1_4();

    99     virtual TVerdict doTestStepPreambleL();

   100     virtual TVerdict doTestStepPostambleL();

   101     virtual TVerdict doTestStepL();

   102 private:

   103     TInt iNullReAllocLength;

   104     TInt iSetReAllocLength;

   105     };

   106 

   107 class CElementStateMachineStep1_5 : public CTestStep, public CElementStateMachineTestBase

   108     {

   109 public:

   110     CElementStateMachineStep1_5();

   111     virtual TVerdict doTestStepPreambleL();

   112     virtual TVerdict doTestStepPostambleL();

   113     virtual TVerdict doTestStepL();

   114 private:

   115     TInt iNullReAllocLength;

   116     TInt iSetReAllocLength;

   117     };

   118 

   119 class CElementStateMachineStep2_1 : public CTestStep, public CElementStateMachineTestBase, public MStateMachineStepLogger

   120     {

   121 public:

   122     CElementStateMachineStep2_1();

   123     virtual TVerdict doTestStepPreambleL();

   124     virtual TVerdict doTestStepPostambleL();

   125     virtual TVerdict doTestStepL();

   126     void LogStateChange(TAsyncEventTest aAsyncEventTest);

   127 private:

   128     TAsyncEventTest iExpectedAsyncEvent;

   129     };

   130 

   131 class CElementStateMachineStep2_2 : public CTestStep, public CElementStateMachineTestBase, public MStateMachineStepLogger

   132     {

   133 public:

   134     CElementStateMachineStep2_2();

   135     virtual TVerdict doTestStepPreambleL();

   136     virtual TVerdict doTestStepPostambleL();

   137     virtual TVerdict doTestStepL();

   138     void LogStateChange(TAsyncEventTest aAsyncEventTest);

   139 private:

   140     TAsyncEventTest iExpectedAsyncEvent;

   141     };

   142 

   143 class CElementStateMachineStep2_3 : public CTestStep, public CElementStateMachineTestBase, public MStateMachineStepLogger

   144     {

   145 public:

   146     CElementStateMachineStep2_3();

   147     virtual TVerdict doTestStepPreambleL();

   148     virtual TVerdict doTestStepPostambleL();

   149     virtual TVerdict doTestStepL();

   150     void LogStateChange(TAsyncEventTest aAsyncEventTest);

   151 private:

   152     TAsyncEventTest iExpectedAsyncEvent;

   153     };

   154 

   155 class CElementStateMachineStep2_4 : public CTestStep, public CElementStateMachineTestBase, public MStateMachineStepLogger

   156     {

   157 public:

   158     CElementStateMachineStep2_4();

   159     virtual TVerdict doTestStepPreambleL();

   160     virtual TVerdict doTestStepPostambleL();

   161     virtual TVerdict doTestStepL();

   162     void LogStateChange(TAsyncEventTest aAsyncEventTest);

   163 private:

   164     TAsyncEventTest iExpectedAsyncEvent;

   165     };

   166 

   167 class CElementStateMachineStep2_5 : public CTestStep, public CElementStateMachineTestBase, public MStateMachineStepLogger

   168     {

   169 public:

   170     CElementStateMachineStep2_5();

   171     virtual TVerdict doTestStepPreambleL();

   172     virtual TVerdict doTestStepPostambleL();

   173     virtual TVerdict doTestStepL();

   174     void LogStateChange(TAsyncEventTest aAsyncEventTest);

   175 private:

   176     TAsyncEventTest iExpectedAsyncEvent;

   177     };

   178 

   179 class CElementStateMachineStep2_6 : public CTestStep, public CElementStateMachineTestBase, public MStateMachineStepLogger

   180     {

   181 public:

   182     CElementStateMachineStep2_6();

   183     virtual TVerdict doTestStepPreambleL();

   184     virtual TVerdict doTestStepPostambleL();

   185     virtual TVerdict doTestStepL();

   186     void LogStateChange(TAsyncEventTest aAsyncEventTest);

   187 private:

   188     TAsyncEventTest iExpectedAsyncEvent;

   189     };

   190 

   191 class CElementStateMachineStep2_7 : public CTestStep, public CElementStateMachineTestBase, public MStateMachineStepLogger

   192     {

   193 public:

   194     CElementStateMachineStep2_7();

   195     virtual TVerdict doTestStepPreambleL();

   196     virtual TVerdict doTestStepPostambleL();

   197     virtual TVerdict doTestStepL();

   198     void LogStateChange(TAsyncEventTest aAsyncEventTest);

   199 private:

   200     TAsyncEventTest iExpectedAsyncEvent;

   201     };

   202 

   203 class CElementStateMachineStep2_8 : public CTestStep, public CElementStateMachineTestBase, public MStateMachineStepLogger

   204     {

   205 public:

   206     CElementStateMachineStep2_8();

   207     virtual TVerdict doTestStepPreambleL();

   208     virtual TVerdict doTestStepPostambleL();

   209     virtual TVerdict doTestStepL();

   210     void LogStateChange(TAsyncEventTest aAsyncEventTest);

   211 private:

   212     TAsyncEventTest iExpectedAsyncEvent;

   213     };

   214 

   215 #endif /* STATEMACHINESTEP_H_ */