smsprotocols/smsstack/smsprot/Test/TE_Smsprt/Te_SmsTestSteps.h
changeset 20 244d7c5f118e
parent 0 3553901f7fa8
child 24 6638e7f4bd8f
equal deleted inserted replaced
19:1f776524b15c 20:244d7c5f118e
    15 
    15 
    16 /**
    16 /**
    17  @file
    17  @file
    18 */
    18 */
    19  
    19  
    20 #ifndef __TE_SMS_TEST_STEPS_H__
    20 #ifndef TE_SMSTESTSTEPS_H
    21 #define __TE_SMS_TEST_STEPS_H__
    21 #define TE_SMSTESTSTEPS_H
    22  
    22 
    23 #include "TE_smsprtbase.h"
    23 #include <Gsmumsg.h>
       
    24 #include <gsmubuf.h>
       
    25 
       
    26 #include "smsstackbaseteststeps.h"
    24 
    27 
    25 /**
    28 /**
    26   Test Step to Load SMS Protocol
    29   Test Step to Load SMS Protocol
    27 */
    30 */
    28 class CLoadSMSProtocol : public CSMSTestSteps
    31 class CLoadSMSProtocol : public CSmsBaseTestStep
    29 {
    32 {
    30 public:
    33 public:
    31 	CLoadSMSProtocol(RSocketServ &aSocketServer);
    34 	CLoadSMSProtocol(RSocketServ &aSocketServer);
    32 	
    35 	
    33 	//From CTestStep
    36 	//From CTestStep
    34 	virtual enum TVerdict doTestStepL();
    37 	virtual TVerdict doTestStepL();
    35 
    38     
       
    39 public: 
       
    40     RSocketServ* iSharedSocketServer;   
    36 };
    41 };
    37 
    42 
    38 /**
    43 /**
    39   Test Step to receive a SMS message
    44   Test Step to receive a SMS message
    40 */
    45 */
    41 class CReceiveSMS : public CSMSTestSteps
    46 class CReceiveSMS : public CSmsBaseTestStep
    42 	{
    47 	{
    43 public:
    48 public:
    44 	CReceiveSMS(RSocketServ &aSocketServer);
    49 	CReceiveSMS(RSocketServ &aSocketServer);
    45 
    50 
    46 	//From CTestStep
    51 	//From CTestStep
    47 	virtual enum TVerdict doTestStepL();
    52 	virtual TVerdict doTestStepL();
       
    53     
       
    54 public: 
       
    55     RSocketServ* iSharedSocketServer;   
    48 	};
    56 	};
    49 
    57 
    50 /**
    58 /**
    51   Test Step to send a SMS message
    59   Test Step to send a SMS message
    52 */
    60 */
    53 class CSendSMS : public CSMSTestSteps
    61 class CSendSMS : public CSmsBaseTestStep
    54 {
    62 {
    55 public:
    63 public:
    56 	CSendSMS(RSocketServ &aSocketServer);
    64 	CSendSMS(RSocketServ &aSocketServer);
    57 
    65 
    58 	//From CTestStep
    66 	//From CTestStep
    59 	virtual enum TVerdict doTestStepL();
    67 	virtual TVerdict doTestStepL();
       
    68     
       
    69 public: 
       
    70     RSocketServ* iSharedSocketServer;   
    60 };
    71 };
    61 
    72 
    62 /**
    73 /**
    63   Close the socket and the socket server session
    74   Close the socket and the socket server session
    64 */
    75 */
    65 class CCloseSMSProtocol : public CSMSTestSteps
    76 class CCloseSMSProtocol : public CSmsBaseTestStep
    66 {
    77 {
    67 public:
    78 public:
    68 	CCloseSMSProtocol(RSocketServ &aSocketServer);
    79 	CCloseSMSProtocol(RSocketServ &aSocketServer);
    69 
    80 
    70 	//From CTestStep
    81 	//From CTestStep
    71 	virtual enum TVerdict doTestStepL();
    82 	virtual TVerdict doTestStepL();
       
    83     
       
    84 public: 
       
    85     RSocketServ* iSharedSocketServer;   
    72 };
    86 };
    73 
    87 
    74 
    88 
    75 /**
    89 /**
    76   Delete segmentation and reasembly stores
    90   Delete segmentation and reasembly stores
    77 */
    91 */
    78 class CDeleteSARStores : public CSMSTestSteps
    92 class CDeleteSARStores : public CSmsBaseTestStep
    79 {
    93 {
    80 public:
    94 public:
    81 	//From CTestStep
    95 	//From CTestStep
    82 	virtual enum TVerdict doTestStepL();
    96     CDeleteSARStores();
       
    97 	virtual TVerdict doTestStepL();
    83 };
    98 };
    84 
    99 
    85 /**
   100 /**
    86   Forwards system time by x number of minutes
   101   Forwards system time by x number of minutes
    87 */
   102 */
    88 class CForwardSystemTime : public CSMSTestSteps
   103 class CForwardSystemTime : public CSmsBaseTestStep
    89 {
   104 {
    90 public:
   105 public:
       
   106     CForwardSystemTime();
    91 	//From CTestStep
   107 	//From CTestStep
    92 	virtual enum TVerdict doTestStepL();
   108 	virtual TVerdict doTestStepL();
    93 };
   109 };
    94 
   110 
    95 /**
   111 /**
    96   Tests receive of SMS message while SMSStack Out of Memory (OOM)
   112   Tests receive of SMS message while SMSStack Out of Memory (OOM)
    97 */
   113 */
    98 class CSendReceiveSMSWhileServerInOOM : public CSMSTestSteps
   114 class CSendReceiveSMSWhileServerInOOM : public CSmsBaseTestStep
    99 {
   115 {
   100 public:
   116 public:
   101 	CSendReceiveSMSWhileServerInOOM(RSocketServ &aSocketServer);
   117 	CSendReceiveSMSWhileServerInOOM(RSocketServ &aSocketServer);
   102 
   118 
   103 	//From CTestStep
   119 	//From CTestStep
   104 	virtual enum TVerdict doTestStepL();
   120 	virtual TVerdict doTestStepL();
       
   121     
       
   122 public: 
       
   123     RSocketServ* iSharedSocketServer;   
   105 };
   124 };
   106 
   125 
   107 /**
   126 /**
   108   Compares the text contents of a SMS message with some text
   127   Compares the text contents of a SMS message with some text
   109 */
   128 */
   110 class CCompareSMS : public CSMSTestSteps
   129 class CCompareSMS : public CSmsBaseTestStep
   111 {
   130 {
   112 public:
   131 public:
   113 	CCompareSMS(CSmsMessage &aSmsMessage);
   132 	CCompareSMS(CSmsMessage &aSmsMessage);
   114 	
   133 	
   115 	//From CTestStep
   134 	//From CTestStep
   116 	virtual enum TVerdict doTestStepL();
   135 	virtual TVerdict doTestStepL();
   117 };
   136 };
   118 
   137 
   119 
   138 
   120 /**
   139 /**
   121   Checks if the Class0 Stores have been enabled
   140   Checks if the Class0 Stores have been enabled
   122 */
   141 */
   123 class CClass0StoreEnabled : public CSMSTestSteps
   142 class CClass0StoreEnabled : public CSmsBaseTestStep
   124 {
   143 {
   125 public:
   144 public:
   126 	CClass0StoreEnabled(RSocketServ &aSocketServer);
   145 	CClass0StoreEnabled(RSocketServ &aSocketServer);
   127 
   146 
   128 	//From CTestStep
   147 	//From CTestStep
   129 	virtual enum TVerdict doTestStepL();
   148 	virtual TVerdict doTestStepL();
       
   149 	
       
   150 public:	
       
   151     RSocketServ* iSharedSocketServer;   
   130 };
   152 };
   131 
   153 
   132 /**
   154 /**
   133   Test for Enumeration in an OOD Condition 
   155   Test for Enumeration in an OOD Condition 
   134 */
   156 */
   135 class CEnumerateInOODCondition : public CSMSTestSteps
   157 class CEnumerateInOODCondition : public CSmsBaseTestStep
   136 {
   158 {
   137 public:
   159 public:
   138 	CEnumerateInOODCondition(RSocketServ &aSocketServer);
   160 	CEnumerateInOODCondition(RSocketServ &aSocketServer);
   139 
   161 
   140 	//From CTestStep
   162 	//From CTestStep
   141 	virtual enum TVerdict doTestStepL();
   163 	virtual TVerdict doTestStepL();
   142 };
   164     
   143 
   165 public: 
   144 /**
   166     RSocketServ* iSharedSocketServer;   
   145   Test Esock for any memory leaks
       
   146 */
       
   147 class CESockMemoryLeakTest : public CSMSTestSteps
       
   148 {
       
   149 public:
       
   150 	//From CTestStep
       
   151 	virtual enum TVerdict doTestStepL();
       
   152 };
   167 };
   153 
   168 
   154 
   169 
   155 
   170 #endif // TE_SMSTESTSTEPS_H
   156 #endif
       
   157 
       
   158 
       
   159