16 

    16 #ifndef TE_SMSPRT_H

    17 #ifndef __TE_SMSPRT_H_

    17 #define TE_SMSPRT_H

    18 #define __TE_SMSPRT_H_

    19 

    24 

    22 class CSmsEventLogger;

    25 class CTestSimpleTxAndRx : public CSmsPrtTestStep

    23 

    26 	{

    24 class CTestSimpleTxAndRx : public CSmsBaseTestStep

    27 public:

    25 	{

    28 	virtual TVerdict doTestStepL();

    26 public:

    29 	};

    27 	virtual TVerdict doTestStepL();

    30 

    28 	};

    31 

    29 	

    32 class CTestBinaryTxAndRx : public CSmsPrtTestStep

    30 	

    33 	{

    31 class CTestBinaryTxAndRx : public CSmsBaseTestStep

    34 public:

    32 	{

    35 	virtual TVerdict doTestStepL();

    33 public:

    36 	};

    34 	virtual TVerdict doTestStepL();

    37 

    35 	};	

    38 

    36 

    39 class CTestStatusReport : public CSmsPrtTestStep

    37 

    40 	{

    38 class CTestStatusReport : public CSmsBaseTestStep

    41 public:

    39 	{

    42 	virtual TVerdict doTestStepL();

    40 public:

    43 	};

    41 	virtual TVerdict doTestStepL();

    44 

    42 	};

    45 

    43 

    46 class CTestTxWithError : public CSmsPrtTestStep

    44 

    47 	{

    45 class CTestTxWithError : public CSmsBaseTestStep

    48 public:

    46 	{

    49 	virtual TVerdict doTestStepL();

    47 public:

    50 	};

    48 	virtual TVerdict doTestStepL();

    51 

    49 	};

    52 

    50 

    53 class CTestTxFailed : public CSmsPrtTestStep

    51 

    54 	{

    52 class CTestTxFailed : public CSmsBaseTestStep

    55 public:

    53 	{

    56 	virtual TVerdict doTestStepL();

    54 public:

    57 	};

    55 	virtual TVerdict doTestStepL();

    58 

    56 	};

    59 

    57 

    60 class CTestMatchingToObserver : public CSmsPrtTestStep

    58 

    61 	{

    59 class CTestMatchingToObserver : public CSmsBaseTestStep

    62 public:

    60 	{

    63 	virtual TVerdict doTestStepL();

    61 public:

    64 	};

    62 	virtual TVerdict doTestStepL();

    65 

    63 	};

    66 

    64 

    67 class CTestCommandMessages : public CSmsPrtTestStep

    65 

    68 	{

    66 class CTestCommandMessages : public CSmsBaseTestStep

    69 public:

    67 	{

    70 	virtual TVerdict doTestStepL();

    68 public:

    71 	};

    69 	virtual TVerdict doTestStepL();

    72 

    70 	};

    73 

    71 

    74 class CTestSimpleRx : public CSmsPrtTestStep

    72 

    75 	{

    73 class CTestSimpleRx : public CSmsBaseTestStep

    76 public:

    74 	{

    77 	virtual TVerdict doTestStepL();

    75 public:

    78 	};

    76 	virtual TVerdict doTestStepL();

    79 

    77 	};

    80 

    78 

    81 class CTest7bitMessTest : public CSmsPrtTestStep

    79 

    82 	{

    80 class CTest7bitMessTest : public CSmsBaseTestStep

    83 public:

    81 	{

    84 	virtual TVerdict doTestStepL();

    82 public:

    85 	};

    83 	virtual TVerdict doTestStepL();

    86 

    84 	};

    87 

    85 

    88 class CTestClassMessages : public CSmsPrtTestStep

    86 

    89 	{

    87 class CTestClassMessages : public CSmsBaseTestStep

    90 public:

    88 	{

    91 	virtual TVerdict doTestStepL();

    89 public:

    92 	};

    90 	virtual TVerdict doTestStepL();

    93 

    91 	};

    94 

    92 

    95 class CTestRxConcatenated : public CSmsPrtTestStep

    93 

    96 	{

    94 class CTestRxConcatenated : public CSmsBaseTestStep

    97 public:

    95 	{

    98 	virtual TVerdict doTestStepL();

    96 public:

    99 	};

    97 	virtual TVerdict doTestStepL();

   100 

    98 	};

   101 

    99 

   102 class CTestRxDuplicate : public CSmsPrtTestStep

   100 

   103 	{

   101 class CTestRxDuplicate : public CSmsBaseTestStep

   104 public:

   102 	{

   105 	virtual TVerdict doTestStepL();

   103 public:

   106 	};

   104 	virtual TVerdict doTestStepL();

   107 

   105 	};

   108 

   106 

   109 class CTestRxRingToneA : public CSmsPrtTestStep

   107 

   110 	{

   108 class CTestRxRingToneA : public CSmsBaseTestStep

   111 public:

   109 	{

   112 	virtual TVerdict doTestStepL();

   110 public:

   113 	};

   111 	virtual TVerdict doTestStepL();

   114 

   112 	};

   115 

   113 

   116 class CTestTxRxConcatenated : public CSmsPrtTestStep

   114 

   117 	{

   115 class CTestTxRxConcatenated : public CSmsBaseTestStep

   118 public:

   116 	{

   119 	virtual TVerdict doTestStepL();

   117 public:

   120 	};

   118 	virtual TVerdict doTestStepL();

   121 

   119 	};

   122 

   120 

   123 class CTestParamStorage : public CSmsPrtTestStep

   121 

   124 	{

   122 class CTestParamStorage : public CSmsBaseTestStep

   125 public:

   123 	{

   126 	virtual TVerdict doTestStepL();

   124 public:

   127 	};

   125 	virtual TVerdict doTestStepL();

   128 

   126 	};

   129 

   127 

   130 class CTestSmsStore : public CSmsPrtTestStep

   128 

   131 	{

   129 class CTestSmsStore : public CSmsBaseTestStep

   132 public:

   130 	{

   133 	virtual TVerdict doTestStepL();

   131 public:

   134 	};

   132 	virtual TVerdict doTestStepL();

   135 

   133 	};

   136 

   134 

   137 class CTestSmsStoreList : public CSmsPrtTestStep

   135 

   138 	{

   136 class CTestSmsStoreList : public CSmsBaseTestStep

   139 public:

   137 	{

   140 	virtual TVerdict doTestStepL();

   138 public:

   141 	};

   139 	virtual TVerdict doTestStepL();

   142 

   140 	};

   143 

   141 

   144 class CTestDeleteSms : public CSmsPrtTestStep

   142 

   145 	{

   143 class CTestDeleteSms : public CSmsBaseTestStep

   146 public:

   144 	{

   147 	virtual TVerdict doTestStepL();

   145 public:

   148 	};

   146 	virtual TVerdict doTestStepL();

   149 

   147 	};

   150 

   148 

   151 class CTestSocketBinding : public CSmsPrtTestStep

   149 class CTestSmsAddr : public CSmsBaseTestStep

   152 	{

   150     {

   153 public:

   151 public:

   154 	virtual TVerdict doTestStepL();

   152     virtual TVerdict doTestStepL();

   155 	};

   153     };

   156 

   154 

   157 

   155 class CTestSocketBinding : public CSmsBaseTestStep

   158 class CTestSmsEventLogger : public CSmsPrtTestStep

   156 	{

   159 	{

   157 public:

   160 public:

   158 	virtual TVerdict doTestStepL();

   161 	virtual TVerdict doTestStepL();

   159 	};

   162 	};

   160 

   163 

   161 

   164 

   162 class CTestSmsEventLogger : public CSmsBaseTestStep

   165 class CTestBearerChange : public CSmsPrtTestStep

   163 	{

   166 	{

   164 public:

   167 public:

   165 	virtual TVerdict doTestStepL();

   168 	virtual TVerdict doTestStepL();

   166 	};

   169 	};

   167 

   170 

   168 

   171 

   169 class CTestBearerChange : public CSmsBaseTestStep

   172 class CTestRestoreBearer : public CSmsPrtTestStep

   170 	{

   173 	{

   171 public:

   174 public:

   172 	virtual TVerdict doTestStepL();

   175 	virtual TVerdict doTestStepL();

   173 	};

   176 	};

   174 

   177 

   175 

   178 

   176 class CTestRestoreBearer : public CSmsBaseTestStep

   179 class CTestRecvModeChange : public CSmsPrtTestStep

   177 	{

   180 	{

   178 public:

   181 public:

   179 	virtual TVerdict doTestStepL();

   182 	virtual TVerdict doTestStepL();

   180 	};

   183 	};

   181 

   184 

   182 

   185 

   183 class CTestRecvModeChange : public CSmsBaseTestStep

   186 class CTestTsyCaps : public CSmsPrtTestStep

   184 	{

   187 	{

   185 public:

   188 public:

   186 	virtual TVerdict doTestStepL();

   189 	virtual TVerdict doTestStepL();

   187 	};

   190 	};

   188 

   191 

   189 

   192 

   190 class CTestTsyCaps : public CSmsBaseTestStep

   193 class CTestOOMSendSms : public CSmsPrtTestStep

   191 	{

   194 	{

   192 public:

   195 public:

   193 	virtual TVerdict doTestStepL();

   196 	virtual TVerdict doTestStepL();

   194 	};

   197 	};

   195 

   198 

   196 

   199 

   197 class CTestOOMSendSms : public CSmsBaseTestStep

   200 class CTestOOMWriteSms : public CSmsPrtTestStep

   198 	{

   201 	{

   199 public:

   202 public:

   200 	virtual TVerdict doTestStepL();

   203 	virtual TVerdict doTestStepL();

   201 	};

   204 	};

   202 

   205 

   203 

   206 

   204 class CTestOOMWriteSms : public CSmsBaseTestStep

   207 class CTestOOMReadSms : public CSmsPrtTestStep

   205 	{

   208 	{

   206 public:

   209 public:

   207 	virtual TVerdict doTestStepL();

   210 	virtual TVerdict doTestStepL();

   208 	};

   211 	};

   209 

   212 

   210 

   213 

   211 class CTestOOMReadSms : public CSmsBaseTestStep

   214 class CTestOOMReadSmsList : public CSmsPrtTestStep

   212 	{

   215 	{

   213 public:

   216 public:

   214 	virtual TVerdict doTestStepL();

   217 	virtual TVerdict doTestStepL();

   215 	};

   218 	};

   216 

   219 

   217 

   220 

   218 class CTestOOMReadSmsList : public CSmsBaseTestStep

   221 class CTestOOMDeleteSms : public CSmsPrtTestStep

   219 	{

   222 	{

   220 public:

   223 public:

   221 	virtual TVerdict doTestStepL();

   224 	virtual TVerdict doTestStepL();

   222 	};

   225 	};

   223 

   226 

   224 

   227 

   225 class CTestOOMDeleteSms : public CSmsBaseTestStep

   228 class CTestOOMSmsParams : public CSmsPrtTestStep

   226 	{

   229 	{

   227 public:

   230 public:

   228 	virtual TVerdict doTestStepL();

   231 	virtual TVerdict doTestStepL();

   229 	};

   232 	};

   230 

   233 

   231 

   234 

   232 class CTestOOMSmsParams : public CSmsBaseTestStep

   235 class CTestMeStoreDupAndMiss : public CSmsPrtTestStep

   233 	{

   236 	{

   234 public:

   237 public:

   235 	virtual TVerdict doTestStepL();

   238 	virtual TVerdict doTestStepL();

   236 	};

   239 	};

   237 

   240 

   238 

   241 

   239 class CTestMeStoreDupAndMiss : public CSmsBaseTestStep

   242 class CTestSimStoreDupAndMiss : public CSmsPrtTestStep

   240 	{

   243 	{

   241 public:

   244 public:

   242 	virtual TVerdict doTestStepL();

   245 	virtual TVerdict doTestStepL();

   243 	};

   246 	};

   244 

   247 

   245 

   248 

   246 class CTestSimStoreDupAndMiss : public CSmsBaseTestStep

   249 class CTestRxCphs : public CSmsPrtTestStep

   247 	{

   250 	{

   248 public:

   251 public:

   249 	virtual TVerdict doTestStepL();

   252 	virtual TVerdict doTestStepL();

   250 	};

   253 	};

   251 

   254 

   252 

   255 class CTestInvalidPDUs : public CSmsPrtTestStep

   253 class CTestRxCphs : public CSmsBaseTestStep

   256 	{

   254 	{

   257 public:

   255 public:

   258 	virtual TVerdict doTestStepL();

   256 	virtual TVerdict doTestStepL();

   259 	};

   257 	};

   260 

   258 

   261 

   259 class CTestInvalidPDUs : public CSmsBaseTestStep

   262 class CTestStress : public CSmsPrtTestStep

   260 	{

   263 	{

   261 public:

   264 public:

   262 	virtual TVerdict doTestStepL();

   265 	virtual TVerdict doTestStepL();

   263 	};

   266 	};

   264 

   267 

   265 

   268 

   266 class CTestStress : public CSmsBaseTestStep

   269 class CTestCombinedStore : public CSmsPrtTestStep

   267 	{

   270 	{

   268 public:

   271 public:

   269 	virtual TVerdict doTestStepL();

   272 	virtual TVerdict doTestStepL();

   270 	};

   273 	};

   271 

   274 

   272 

   275 

   273 class CTestCombinedStore : public CSmsBaseTestStep

   276 class CTestParamsInter : public CSmsPrtTestStep

   274 	{

   277 	{

   275 public:

   278 public:

   276 	virtual TVerdict doTestStepL();

   279 	virtual TVerdict doTestStepL();

   277 	};

   280 	};

   278 

   281 

   279 

   282 

   280 class CTestParamsInter : public CSmsBaseTestStep

   283 class CTestTxRxAlphanumeric : public CSmsPrtTestStep

   281 	{

   284 	{

   282 public:

   285 public:

   283 	virtual TVerdict doTestStepL();

   286 	virtual TVerdict doTestStepL();

   284 	};

   287 	};

   285 

   288 

   286 

   289 

   287 class CTestTxRxAlphanumeric : public CSmsBaseTestStep

   290 class CTestRxSuspend : public CSmsPrtTestStep

   288 	{

   291 	{

   289 public:

   292 public:

   290 	virtual TVerdict doTestStepL();

   293 	virtual TVerdict doTestStepL();

   291 	};

   294 	};

   292 

   295 

   293 

   296 

   294 class CTestRxSuspend : public CSmsBaseTestStep

   297 class CTestEnumerateCorrupted : public CSmsPrtTestStep

   295 	{

   298 	{

   296 public:

   299 public:

   297 	virtual TVerdict doTestStepL();

   300 	virtual TVerdict doTestStepL();

   298 	};

   301 	};

   299 

   302 

   300 

   303 

   301 class CTestEnumerateCorrupted : public CSmsBaseTestStep

   304 class CTestCancelling : public CSmsPrtTestStep

   302 	{

   305 	{

   303 public:

   306 public:

   304 	virtual TVerdict doTestStepL();

   307 	virtual TVerdict doTestStepL();

   305 	};

   308 	};

   306 

   309 

   307 

   310 

   308 class CTestCancelling : public CSmsBaseTestStep

   311 class CTestSendAndRecvMsgsWithDifferentTON : public CSmsPrtTestStep

   309 	{

   312 	{

   310 public:

   313 public:

   311 	virtual TVerdict doTestStepL();

   314 	virtual TVerdict doTestStepL();

   312 	};

   315 	};

   313 

   316 

   314 

   317 

   315 class CTestSendAndRecvMsgsWithDifferentTON : public CSmsBaseTestStep

   318 class CTestSendAndReceiveIndicatorMsgs : public CSmsPrtTestStep

   316 	{

   319 	{

   317 public:

   320 public:

   318 	virtual TVerdict doTestStepL();

   321 	virtual TVerdict doTestStepL();

   319 	};

   322 	};

   320 

   323 

   321 

   324 

   322 class CTestSendAndReceiveIndicatorMsgs : public CSmsBaseTestStep

   325 class CTestSendRecvMaxLengthMsg : public CSmsPrtTestStep

   323 	{

   326 	{

   324 public:

   327 public:

   325 	virtual TVerdict doTestStepL();

   328 	virtual TVerdict doTestStepL();

   326 	};

   329 	};

   327 

   330 

   328 

   331 

   329 class CTestSendRecvMaxLengthMsg : public CSmsBaseTestStep

   332 class CTestSendAndRecvMsgsWithDifferentPID : public CSmsPrtTestStep

   330 	{

   333 	{

   331 public:

   334 public:

   332 	virtual TVerdict doTestStepL();

   335 	virtual TVerdict doTestStepL();

   333 	};

   336 	};

   334 

   337 

   335 

   338 

   336 class CTestSendAndRecvMsgsWithDifferentPID : public CSmsBaseTestStep

   339 class CSmsParamsErrorCases : public CSmsPrtTestStep

   337 	{

   338 public:

   339 	virtual TVerdict doTestStepL();

   340 	};

   341 

   342 

   343 class CTestSmsParamsErrorCases : public CSmsBaseTestStep

   353 class CTestResendFailedConcatinatedMessage : public CSmsPrtTestStep

   357 class CTestResendFailedConcatinatedMessage : public CSmsBaseTestStep

   354 	{

   358 	{

   355 public:

   359 public:

   356 	virtual TVerdict doTestStepL();

   360 	virtual TVerdict doTestStepL();

   357 	};

   361 	};

   358 

   362 

   359 

   363 

   360 class CTestMultipartWapMessage : public CSmsPrtTestStep

   364 class CTestMultipartWapMessage : public CSmsBaseTestStep

   361 	{

   365 	{

   362 public:

   366 public:

   363 	virtual TVerdict doTestStepL();

   367 	virtual TVerdict doTestStepL();

   364 	};

   368 	};

   365 

   369 

   366 

   370 

   367 class CTestMOSESMessage : public CSmsPrtTestStep

   371 class CTestMOSESMessage : public CSmsBaseTestStep

   368 	{

   372 	{

   369 public:

   373 public:

   370 	virtual TVerdict doTestStepL();

   374 	virtual TVerdict doTestStepL();

   371 	};

   375 	};

   372 

   376 

   373 

   377 

   374 class CTestClockBack : public CSmsPrtTestStep

   378 class CTestClockBack : public CSmsBaseTestStep

   375 	{

   379 	{

   376 public:

   380 public:

   377 	virtual TVerdict doTestStepL();

   381 	virtual TVerdict doTestStepL();

   378 	};

   382 	};

   379 

   383 

   380 

   384 

   381 class CTestEnumerateNoMessages : public CSmsPrtTestStep

   385 class CTestEnumerateNoMessages : public CSmsBaseTestStep

   382 	{

   386 	{

   383 public:

   387 public:

   384 	virtual TVerdict doTestStepL();

   388 	virtual TVerdict doTestStepL();

   385 	};

   389 	};

   386 

   390 

   387 

   391 

   388 class CTestIE : public CSmsPrtTestStep

   392 class CTestIE : public CSmsBaseTestStep

   389 	{

   393 	{

   390 public:

   394 public:

   391 	virtual TVerdict doTestStepL();

   395 	virtual TVerdict doTestStepL();

   392 	};

   396 	};

   393 

   397 

   394 

   398 

   395 class CTestEmailIE : public CSmsPrtTestStep

   399 class CTestEmailIE : public CSmsBaseTestStep

   396 	{

   400 	{

   397 public:

   401 public:

   398 	virtual TVerdict doTestStepL();

   402 	virtual TVerdict doTestStepL();

   399 	};

   403 	};

   400 

   404 

   401 

   405 

   402 class CTestMaxReadTimeForSmsStoreList : public CSmsPrtTestStep

   406 class CTestMaxReadTimeForSmsStoreList : public CSmsBaseTestStep

   403 	{

   407 	{

   404 public:

   408 public:

   405 	virtual TVerdict doTestStepL();

   409 	virtual TVerdict doTestStepL();

   406 	};

   410 	};

   407 

   411 

   408 

   412 

   409 class CTestSameLogIdMultiplePDU	: public CSmsPrtTestStep

   413 class CTestSameLogIdMultiplePDU	: public CSmsBaseTestStep

   410 	{

   414 	{

   411 public:

   415 public:

   412 	virtual TVerdict doTestStepL();

   416 	virtual TVerdict doTestStepL();

   413 	};

   417 	};

   414 

   418 

   415 

   419 

   416 class CTestSameLogIdSinglePDU : public CSmsPrtTestStep

   420 class CTestSameLogIdSinglePDU : public CSmsBaseTestStep

   417 	{

   421 	{

   418 public:

   422 public:

   419 	virtual TVerdict doTestStepL();

   423 	virtual TVerdict doTestStepL();

   420 	};

   424 	};

   421 

   425 

   422 

   426 

   423 class CTestConcatenatedMessageLogging : public CSmsPrtTestStep

   427 class CTestConcatenatedMessageLogging : public CSmsBaseTestStep

   424 	{

   428     {

   425 public:

   429 public:

   426 	virtual TVerdict doTestStepL();

   430     virtual TVerdict doTestStepL();

   427 	};

   431     };

   433 	{

   437     {

   434 	public:

   438 public:

   435 		static CTestLog* NewLC(CSmsStackTestUtils& aUtils, RFs& aFs, CSmsPrtTestStep* aTest, TInt aPriority);

   439     static CTestLog* NewLC(CSmsStackTestUtils& aUtils, RFs& aFs, CSmsBaseTestStep* aTest, TInt aPriority);

   436 		~CTestLog();

   440     ~CTestLog();

   437 

   441 

   438 		void StartL();

   442     void StartL();

   439 

   443 

   440 	private:

   444 private:

   441 

   445     void ConstructL(RFs& aFs);

   442 		void ConstructL(RFs& aFs);

   446     CTestLog(CSmsStackTestUtils& aUtils, CSmsBaseTestStep* aTest, TInt aPriority);

   443 		CTestLog(CSmsStackTestUtils& aUtils, CSmsPrtTestStep* aTest, TInt aPriority);

   447     void RunL();

   444 		void RunL();

   448     void DoCancel() {};

   445 		void DoCancel() {};

   449     TInt RunError(TInt aError) {Complete(aError); return KErrNone;}

   446 		TInt RunError(TInt aError) {Complete(aError); return KErrNone;}

   450     void Complete(TInt aError) {iStatus = aError; CActiveScheduler::Stop();}

   447 		void Complete(TInt aError) {iStatus = aError; CActiveScheduler::Stop();}

   451     void StartOriginalL();

   448 		void StartOriginalL();

   452     void StartCompareL(TInt aExpectError);

   449 		void StartCompareL(TInt aExpectError);

   453 

   450 

   454 private:

   451 	private:

   455     enum TState

   452 

   456         {

   453 		enum TState

   457         EOriginal

   454 			{

   458         } iState;

   455 			EOriginal

   459 

   456 			} iState;

   460     CSmsStackTestUtils& iUtils;

   457 

   461     CSmsBaseTestStep* iTest;

   458 		CSmsStackTestUtils& iUtils;

   462 

   459 		CSmsPrtTestStep* iTest;

   463     CSmsLogChecker* iLogChecker;

   460 

   464     CSmsEventLogger* iEventLogger;

   461 		CSmsLogChecker* iLogChecker;

   465     CSmsMessage* iMessage;

   462 		CSmsEventLogger* iEventLogger;

   466     RSocket iSocket;

   463 		CSmsMessage* iMessage;

   467 

   464 		RSocketServ iSocketServer;

   468     RArray<TLogId> iAddedIds;

   465 		RSocket iSocket;

   469     TInt iNumberToAdd;

   466 

   470     TLogSmsPduData iData;

   467 		RArray<TLogId> iAddedIds;

   471     };

   468 		TInt iNumberToAdd;

   472 

   469 		TLogSmsPduData iData;

   473 

   470 	};

   474 class CTestEnumerationOfStatusReport : public CSmsBaseTestStep

   471 

   475     {

   472 

   476 public:

   473 class CTestEnumerationOfStatusReport : public CSmsPrtTestStep

   477     TVerdict doTestStepL();

   474 	{

   478     };

   475 public:

   479 

   476 	TVerdict doTestStepL();

   480 

   477 	};

   481 class CTestWriteStatusReportToSIM : public CSmsBaseTestStep

   478 

   482     {

   479 

   483 public:

   480 class CTestWriteStatusReportToSIM : public CSmsPrtTestStep

   484 	TVerdict doTestStepL();

   481 	{

   485 	};

   482 public:

   486 

   483 	TVerdict doTestStepL();

   487 

   484 	};

   488 class CTestTxSmsWithDelayedCompletion : public CSmsBaseTestStep

   485 

   489 	{

   486 

   490 public:

   487 class CTestTxSmsWithDelayedCompletion : public CSmsPrtTestStep

   491 	TVerdict doTestStepL();

   488 	{

   492 	};

   489 public:

   493 

   490 	TVerdict doTestStepL();

   494 

   491 	};

   495 class CTestSmsStoreReadCancel : public CSmsBaseTestStep

   492 

   496 	{

   493 

   497 public:

   494 class CTestSmsStoreReadCancel : public CSmsPrtTestStep

   498 	TVerdict doTestStepL();

   495 	{

   499 	};

   496 public:

   500 

   497 	TVerdict doTestStepL();

   501 

   498 	};

   502 class CTestBindWhenPoweredDownWithPublishSubscribe : public CSmsBaseTestStep

   499 

   500 

   501 class CTestBindWhenPoweredDownWithPublishSubscribe : public CSmsPrtTestStep

   508 class CTestObserverNotifiedWhenPoweredDownWithPublishSubscribe : public CSmsPrtTestStep

   509 class CTestObserverNotifiedWhenPoweredDownWithPublishSubscribe : public CSmsBaseTestStep

   515 class CTestSmsCNumberChangeWithPublishSubscribe : public CSmsPrtTestStep

   516 class CTestSmsCNumberChangeWithPublishSubscribe : public CSmsBaseTestStep

   522 class CTestStatusReportTime : public CSmsPrtTestStep

   523 class CTestStatusReportTime : public CSmsBaseTestStep

   523 	{

   524 	{

   524 public:

   525 public:

   525 	TVerdict doTestStepL();

   526 	TVerdict doTestStepL();

   526 	};

   527 	};

   527 

   528 

   528 

   529 

   529 class CTestTx8BitWapWithStatus : public CSmsPrtTestStep

   530 class CTestTx8BitWapWithStatus : public CSmsBaseTestStep

   530 	{

   531 	{

   531 public:

   532 public:

   532 	TVerdict doTestStepL();

   533 	TVerdict doTestStepL();

   533 	};

   534 	};

   534 

   535 

   535 

   536 

   536 class CTestSimStoreCorruptMessage : public CSmsPrtTestStep

   537 class CTestSimStoreCorruptMessage : public CSmsBaseTestStep

   537 	{

   538 	{

   538 public:

   539 public:

   539 	virtual TVerdict doTestStepL();

   540 	virtual TVerdict doTestStepL();

   540 	};

   541 	};

   541 

   542 

   542 

   543 

   543 class CTestCorruptPduWithNegativeResponse : public CSmsPrtTestStep

   544 class CTestCorruptPduWithNegativeResponse : public CSmsBaseTestStep

   550 class CTestBootTimer : public CSmsPrtTestStep

   551 class CTestBootTimer : public CSmsBaseTestStep

   557 class CTestCSmsMessageTimeStamp : public CSmsPrtTestStep

   558 class CTestCSmsMessageTimeStamp : public CSmsBaseTestStep

   564 class CTestCSmsMessageWithDeliverPDU : public CSmsPrtTestStep

   565 class CTestCSmsMessageWithDeliverPDU : public CSmsBaseTestStep

   571 class CTestCSmsMessageWithStatusReportPDU : public CSmsPrtTestStep

   572 class CTestCSmsMessageWithStatusReportPDU : public CSmsBaseTestStep

   578 class CTestCSmsMessageWithSubmitPDU : public CSmsPrtTestStep

   579 class CTestCSmsMessageWithSubmitPDU : public CSmsBaseTestStep

   585 class CTestHandlePID40h : public CSmsPrtTestStep

   586 class CTestHandlePID40h : public CSmsBaseTestStep

   586 	{

   587 	{

   587 public:

   588 public:

   588 	TVerdict doTestStepL();

   589 	TVerdict doTestStepL();

   589 	};

   590 	};

   590 

   591 

   591 

   592 

   592 class CTestDiskSpaceMidRangeClass0Class2 : public CSmsPrtTestStep

   593 class CTestDiskSpaceMidRangeClass0Class2 : public CSmsBaseTestStep

   593 	{

   594 	{

   594 public:	

   595 public:

   595 	TVerdict doTestStepPreambleL();

   596     TVerdict doTestStepPreambleL();

   601 class CTestDiskSpaceLowRangeClass0Class2 : public CSmsPrtTestStep

   602 class CTestDiskSpaceLowRangeClass0Class2 : public CSmsBaseTestStep

   610 class CTestCorruptPDUs : public CSmsPrtTestStep

   611 class CTestCorruptPDUs : public CSmsBaseTestStep

   611 	{

   612 	{

   612 public:

   613 public:

   613 	TVerdict doTestStepL();

   614 	TVerdict doTestStepL();

   614 	};

   615 	};

   615 

   616 

   616 

   617 

   617 class CTestCongestedReceive : public CSmsPrtTestStep

   618 class CTestCongestedReceive : public CSmsBaseTestStep

   618 	{

   619 	{

   619 public:

   620 public:

   620 	TVerdict doTestStepL();

   621 	TVerdict doTestStepL();

   621 	};

   622 	};

   622 

   623 

   623 

   624 

   624 class CTestEncodingPDUonBoundary : public CSmsPrtTestStep

   625 class CTestEncodingPDUonBoundary : public CSmsBaseTestStep

   625 	{

   626 	{

   626 public:

   627 public:

   627 	virtual enum TVerdict doTestStepL();

   628 	virtual enum TVerdict doTestStepL();

   628 	};

   629 	};

   629 

   630 

   630 

   631 

   631 class CTestReceiveInvalidOrReservedIE : public CSmsPrtTestStep

   632 class CTestReceiveInvalidOrReservedIE : public CSmsBaseTestStep

   685 class CTestReceivingMessageWithDifferentEncodings : public CSmsPrtTestStep

   687 

   686 	{

   688 class CTestReceivingMessageWithDifferentEncodings : public CSmsBaseTestStep

   687 public:

   689 	{

   688 	virtual enum TVerdict doTestStepL();

   690 public:

   689 	};

   691 	virtual enum TVerdict doTestStepL();

   690 

   692 	};

   691 class CTestReceivingMessageAfterSocketClosure : public CSmsPrtTestStep

   693 

   692 	{

   694 class CTestReceivingMessageAfterSocketClosure : public CSmsBaseTestStep

   693 public:

   695 	{

   694 	virtual enum TVerdict doTestStepL();

   696 public:

   695 	};

   697 	virtual enum TVerdict doTestStepL();

   696 

   698 	};

   697 class CTestSimpleTxAndRxWithLoggingDisabled : public CSmsPrtTestStep

   699 

   700 class CTestSimpleTxAndRxWithLoggingDisabled : public CSmsBaseTestStep

   739 #endif

   742 #endif // TE_SMSPRT_H