1 // Copyright (c) 1997-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 // The unit test class implementations for the CSmsSchemeHandler class.

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20  @SYMCreationDate Created : 01/06/01 14:07:22

    21 */

    22 

    23 #include "SmsSchemeHandlerUnitTest.h"

    24 

    25 // ______________________________________________________________________________

    26 //

    27 _LIT(KSmsSchemeHandlerCreateAndDestroyUnitTest,"CSmsSchemeHandler_CreateAndDestroy_UnitTest");

    28 

    29 CSmsSchemeHandler_CreateAndDestroy_UnitTest* CSmsSchemeHandler_CreateAndDestroy_UnitTest::NewL(CDataLogger& aDataLogger,

    30 											MUnitTestObserver& aObserver)

    31 	{

    32 	CSmsSchemeHandler_CreateAndDestroy_UnitTest* self = 

    33 					new(ELeave) CSmsSchemeHandler_CreateAndDestroy_UnitTest(aDataLogger,

    34 																aObserver);

    35 	CleanupStack::PushL(self);

    36 	self->ConstructL();

    37 	CleanupStack::Pop();

    38 	return self; 

    39 	}

    40 

    41 inline TInt CSmsSchemeHandler_CreateAndDestroy_UnitTest::RunError(TInt aError)

    42 	{

    43 	// The RunL left so chain to the base first and then cleanup

    44 	TInt error = CUnitTest::RunError(aError);	// Chain to base

    45 	delete iUTContext;

    46 	delete iStateAccessor;

    47 	// delete any validators used

    48 	delete iCtorValidator;

    49 	//delete iCreateAndDestroyValidator;

    50 	delete iDtorValidator;

    51 	 

    52 	return error;

    53 	}

    54 

    55 inline CSmsSchemeHandler_CreateAndDestroy_UnitTest::~CSmsSchemeHandler_CreateAndDestroy_UnitTest()

    56 	{

    57 	// Simply delete our test class instance

    58 	delete iUTContext;

    59 	delete iStateAccessor;

    60 	// delete any validators used

    61 	delete iCtorValidator;

    62 	//delete iCreateAndDestroyValidator;

    63 	delete iDtorValidator;

    64 	 

    65 	}

    66 

    67 inline CSmsSchemeHandler_CreateAndDestroy_UnitTest::CSmsSchemeHandler_CreateAndDestroy_UnitTest(CDataLogger& aDataLogger,

    68 																	MUnitTestObserver& aObserver)

    69 : CUnitTest(KSmsSchemeHandlerCreateAndDestroyUnitTest, aDataLogger, aObserver)

    70 	{

    71 	//Do nothing

    72 	}

    73 

    74 // Now the Individual transitions need to be added.

    75 inline void CSmsSchemeHandler_CreateAndDestroy_UnitTest::ConstructL()

    76 	{

    77 	// Perform the base class initialization

    78 	UnitTestConstructL();

    79 

    80 	// Create the Unit test state accessor

    81 	iStateAccessor = new(ELeave) TSmsSchemeHandler_StateAccessor;

    82 	// Construct the Unit test context.

    83 	iUTContext = new(ELeave) CSmsSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

    84 	// Add the Transitions in the order they are to run

    85 	// C'tor first, D'tor last...

    86 	//	Examples of C'tor and D'tor transitions on CSmsSchemeHandler class.

    87 	//	using ctor and dtor validators

    88 	iCtorValidator = new(ELeave) TSmsSchemeHandler_Ctor_TransitionValidator(*iUTContext);

    89 	AddTransitionL(new(ELeave)CSmsSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

    90 	iDtorValidator = new(ELeave) TSmsSchemeHandler_Dtor_TransitionValidator(*iUTContext);

    91 	AddTransitionL(new(ELeave)CSmsSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator)); 

    92 	}

    93 

    94 

    95 

    96 // ______________________________________________________________________________

    97 //

    98 _LIT(KSmsSchemeHandlerParseUrlTest1UnitTest,"CSmsSchemeHandler_ParseUrlTest1_UnitTest");

    99 

   100 CSmsSchemeHandler_ParseUrlTest1_UnitTest* CSmsSchemeHandler_ParseUrlTest1_UnitTest::NewL(CDataLogger& aDataLogger,

   101 											MUnitTestObserver& aObserver)

   102 	{

   103 	CSmsSchemeHandler_ParseUrlTest1_UnitTest* self = 

   104 					new(ELeave) CSmsSchemeHandler_ParseUrlTest1_UnitTest(aDataLogger,

   105 																aObserver);

   106 	CleanupStack::PushL(self);

   107 	self->ConstructL();

   108 	CleanupStack::Pop();

   109 	return self; 

   110 	}

   111 

   112 inline TInt CSmsSchemeHandler_ParseUrlTest1_UnitTest::RunError(TInt aError)

   113 	{

   114 	// The RunL left so chain to the base first and then cleanup

   115 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   116 	delete iUTContext;

   117 	delete iStateAccessor;

   118 	// delete any validators used

   119 	delete iCtorValidator;

   120 	delete iParseUrlTest1Validator;

   121 	delete iDtorValidator;

   122 

   123 	return error;

   124 	}

   125 

   126 inline CSmsSchemeHandler_ParseUrlTest1_UnitTest::~CSmsSchemeHandler_ParseUrlTest1_UnitTest()

   127 	{

   128 	// Simply delete our test class instance

   129 	delete iUTContext;

   130 	delete iStateAccessor;

   131 	// delete any validators used

   132 	delete iCtorValidator;

   133 	delete iParseUrlTest1Validator;

   134 	delete iDtorValidator;

   135 	}

   136 

   137 inline CSmsSchemeHandler_ParseUrlTest1_UnitTest::CSmsSchemeHandler_ParseUrlTest1_UnitTest(CDataLogger& aDataLogger,

   138 																	MUnitTestObserver& aObserver)

   139 : CUnitTest(KSmsSchemeHandlerParseUrlTest1UnitTest, aDataLogger, aObserver)

   140 	{

   141 	//Do nothing

   142 	}

   143 

   144 // Now the Individual transitions need to be added.

   145 inline void CSmsSchemeHandler_ParseUrlTest1_UnitTest::ConstructL()

   146 	{

   147 	// Perform the base class initialization

   148 	UnitTestConstructL();

   149 

   150 	// Create the Unit test state accessor

   151 	iStateAccessor = new(ELeave) TSmsSchemeHandler_StateAccessor;

   152 	// Construct the Unit test context.

   153 	iUTContext = new(ELeave) CSmsSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

   154 	// Add the Transitions in the order they are to run

   155 	// C'tor first, D'tor last...

   156 	//	Examples of C'tor and D'tor transitions on CSmsSchemeHandler class.

   157 	//	using ctor and dtor validators

   158 

   159 	_LIT(KUrl1, "sms: 1234 ");

   160 	//_LIT(KUrl1, "sms: nonsense ");

   161 	iUTContext->iUrl = &KUrl1(); 

   162 

   163 	_LIT(KNumber, "1234");

   164 

   165 	CSmsSchemeHandler_UnitTestContext::SSmsNumber num;

   166 	num.iNumber.Set(KNumber);

   167 

   168 	iUTContext->iPostCheck.Append(num);

   169 

   170 	iCtorValidator = new(ELeave) TSmsSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   171 	iParseUrlTest1Validator = new(ELeave) TSmsSchemeHandler_ParseUrlL_TransitionValidator(*iUTContext);

   172 	iDtorValidator = new(ELeave) TSmsSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   173 

   174 	AddTransitionL(new(ELeave)CSmsSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   175 	AddTransitionL(new(ELeave)CSmsSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest1Validator));

   176 	AddTransitionL(new(ELeave)CSmsSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   177 	}

   178 

   179 // ______________________________________________________________________________

   180 //

   181 _LIT(KSmsSchemeHandlerParseUrlTest2UnitTest,"CSmsSchemeHandler_ParseUrlTest2_UnitTest");

   182 

   183 CSmsSchemeHandler_ParseUrlTest2_UnitTest* CSmsSchemeHandler_ParseUrlTest2_UnitTest::NewL(CDataLogger& aDataLogger,

   184 											MUnitTestObserver& aObserver)

   185 	{

   186 	CSmsSchemeHandler_ParseUrlTest2_UnitTest* self = 

   187 					new(ELeave) CSmsSchemeHandler_ParseUrlTest2_UnitTest(aDataLogger,

   188 																aObserver);

   189 	CleanupStack::PushL(self);

   190 	self->ConstructL();

   191 	CleanupStack::Pop();

   192 	return self; 

   193 	}

   194 

   195 inline TInt CSmsSchemeHandler_ParseUrlTest2_UnitTest::RunError(TInt aError)

   196 	{

   197 	// The RunL left so chain to the base first and then cleanup

   198 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   199 	delete iUTContext;

   200 	delete iStateAccessor;

   201 	// delete any validators used

   202 	delete iCtorValidator;

   203 	delete iParseUrlTest2Validator;

   204 	delete iDtorValidator;

   205 	 

   206 	return error;

   207 	}

   208 

   209 inline CSmsSchemeHandler_ParseUrlTest2_UnitTest::~CSmsSchemeHandler_ParseUrlTest2_UnitTest()

   210 	{

   211 	// Simply delete our test class instance

   212 	delete iUTContext;

   213 	delete iStateAccessor;

   214 	// delete any validators used

   215 	delete iCtorValidator;

   216 	delete iParseUrlTest2Validator;

   217 	delete iDtorValidator;

   218 	 

   219 	}

   220 

   221 inline CSmsSchemeHandler_ParseUrlTest2_UnitTest::CSmsSchemeHandler_ParseUrlTest2_UnitTest(CDataLogger& aDataLogger,

   222 																	MUnitTestObserver& aObserver)

   223 : CUnitTest(KSmsSchemeHandlerParseUrlTest2UnitTest, aDataLogger, aObserver)

   224 	{

   225 	//Do nothing

   226 	}

   227 

   228 // Now the Individual transitions need to be added.

   229 inline void CSmsSchemeHandler_ParseUrlTest2_UnitTest::ConstructL()

   230 	{

   231 	// Perform the base class initialization

   232 	UnitTestConstructL();

   233 

   234 	// Create the Unit test state accessor

   235 	iStateAccessor = new(ELeave) TSmsSchemeHandler_StateAccessor;

   236 	// Construct the Unit test context.

   237 	iUTContext = new(ELeave) CSmsSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

   238 	// Add the Transitions in the order they are to run

   239 	// C'tor first, D'tor last...

   240 	//	Examples of C'tor and D'tor transitions on CSmsSchemeHandler class.

   241 	//	using ctor and dtor validators

   242 	 

   243 	_LIT(KUrl2, "sms: 3452 ; via = 5687 ");

   244 	iUTContext->iUrl = &KUrl2(); 

   245 

   246 	_LIT(KNumber, "3452");

   247 	_LIT(KServiceCentre, "5687");

   248 

   249 	CSmsSchemeHandler_UnitTestContext::SSmsNumber num;

   250 	num.iNumber.Set(KNumber);

   251 	num.iServiceCentre.Set(KServiceCentre);

   252 

   253 	iUTContext->iPostCheck.Append(num);

   254 

   255 	iCtorValidator = new(ELeave) TSmsSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   256 	iParseUrlTest2Validator = new(ELeave) TSmsSchemeHandler_ParseUrlL_TransitionValidator(*iUTContext);

   257 	iDtorValidator = new(ELeave) TSmsSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   258 

   259 	AddTransitionL(new(ELeave)CSmsSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   260 	AddTransitionL(new(ELeave)CSmsSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest2Validator));

   261 	AddTransitionL(new(ELeave)CSmsSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   262 	}

   263 

   264 // ______________________________________________________________________________

   265 //

   266 _LIT(KSmsSchemeHandlerParseUrlTest3UnitTest,"CSmsSchemeHandler_ParseUrlTest3_UnitTest");

   267 

   268 CSmsSchemeHandler_ParseUrlTest3_UnitTest* CSmsSchemeHandler_ParseUrlTest3_UnitTest::NewL(CDataLogger& aDataLogger,

   269 											MUnitTestObserver& aObserver)

   270 	{

   271 	CSmsSchemeHandler_ParseUrlTest3_UnitTest* self = 

   272 					new(ELeave) CSmsSchemeHandler_ParseUrlTest3_UnitTest(aDataLogger,

   273 																aObserver);

   274 	CleanupStack::PushL(self);

   275 	self->ConstructL();

   276 	CleanupStack::Pop();

   277 	return self; 

   278 	}

   279 

   280 inline TInt CSmsSchemeHandler_ParseUrlTest3_UnitTest::RunError(TInt aError)

   281 	{

   282 	// The RunL left so chain to the base first and then cleanup

   283 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   284 	delete iUTContext;

   285 	delete iStateAccessor;

   286 	// delete any validators used

   287 	delete iCtorValidator;

   288 	delete iParseUrlTest3Validator;

   289 	delete iDtorValidator;

   290 	 

   291 	return error;

   292 	}

   293 

   294 inline CSmsSchemeHandler_ParseUrlTest3_UnitTest::~CSmsSchemeHandler_ParseUrlTest3_UnitTest()

   295 	{

   296 	// Simply delete our test class instance

   297 	delete iUTContext;

   298 	delete iStateAccessor;

   299 	// delete any validators used

   300 	delete iCtorValidator;

   301 	delete iParseUrlTest3Validator;

   302 	delete iDtorValidator;

   303 	 

   304 	}

   305 

   306 inline CSmsSchemeHandler_ParseUrlTest3_UnitTest::CSmsSchemeHandler_ParseUrlTest3_UnitTest(CDataLogger& aDataLogger,

   307 																	MUnitTestObserver& aObserver)

   308 : CUnitTest(KSmsSchemeHandlerParseUrlTest3UnitTest, aDataLogger, aObserver)

   309 	{

   310 	//Do nothing

   311 	}

   312 

   313 // Now the Individual transitions need to be added.

   314 inline void CSmsSchemeHandler_ParseUrlTest3_UnitTest::ConstructL()

   315 	{

   316 	// Perform the base class initialization

   317 	UnitTestConstructL();

   318 

   319 	// Create the Unit test state accessor

   320 	iStateAccessor = new(ELeave) TSmsSchemeHandler_StateAccessor;

   321 	// Construct the Unit test context.

   322 	iUTContext = new(ELeave) CSmsSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

   323 	// Add the Transitions in the order they are to run

   324 	// C'tor first, D'tor last...

   325 	//	Examples of C'tor and D'tor transitions on CSmsSchemeHandler class.

   326 	//	using ctor and dtor validators

   327 

   328 	_LIT(KUrl3, "sms: ; via = 5687 ");

   329 	iUTContext->iUrl = &KUrl3(); 

   330 

   331 	_LIT(KServiceCentre, "5687");

   332 

   333 	CSmsSchemeHandler_UnitTestContext::SSmsNumber num;

   334 

   335 	num.iServiceCentre.Set(KServiceCentre);

   336 

   337 	iUTContext->iPostCheck.Append(num);

   338 

   339 	iCtorValidator = new(ELeave) TSmsSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   340 	iParseUrlTest3Validator = new(ELeave) TSmsSchemeHandler_ParseUrlL_TransitionValidator(*iUTContext);

   341 	iDtorValidator = new(ELeave) TSmsSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   342 

   343 	AddTransitionL(new(ELeave)CSmsSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   344 	AddTransitionL(new(ELeave)CSmsSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest3Validator));

   345 	AddTransitionL(new(ELeave)CSmsSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   346 	}

   347 

   348 // ______________________________________________________________________________

   349 //

   350 _LIT(KSmsSchemeHandlerParseUrlTest4UnitTest,"CSmsSchemeHandler_ParseUrlTest4_UnitTest");

   351 

   352 CSmsSchemeHandler_ParseUrlTest4_UnitTest* CSmsSchemeHandler_ParseUrlTest4_UnitTest::NewL(CDataLogger& aDataLogger,

   353 											MUnitTestObserver& aObserver)

   354 	{

   355 	CSmsSchemeHandler_ParseUrlTest4_UnitTest* self = 

   356 					new(ELeave) CSmsSchemeHandler_ParseUrlTest4_UnitTest(aDataLogger,

   357 																aObserver);

   358 	CleanupStack::PushL(self);

   359 	self->ConstructL();

   360 	CleanupStack::Pop();

   361 	return self; 

   362 	}

   363 

   364 inline TInt CSmsSchemeHandler_ParseUrlTest4_UnitTest::RunError(TInt aError)

   365 	{

   366 	// The RunL left so chain to the base first and then cleanup

   367 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   368 	delete iUTContext;

   369 	delete iStateAccessor;

   370 	// delete any validators used

   371 	delete iCtorValidator;

   372 	delete iParseUrlTest4Validator;

   373 	delete iDtorValidator;

   374 	 

   375 	return error;

   376 	}

   377 

   378 inline CSmsSchemeHandler_ParseUrlTest4_UnitTest::~CSmsSchemeHandler_ParseUrlTest4_UnitTest()

   379 	{

   380 	// Simply delete our test class instance

   381 	delete iUTContext;

   382 	delete iStateAccessor;

   383 	// delete any validators used

   384 	delete iCtorValidator;

   385 	delete iParseUrlTest4Validator;

   386 	delete iDtorValidator;

   387 	 

   388 	}

   389 

   390 inline CSmsSchemeHandler_ParseUrlTest4_UnitTest::CSmsSchemeHandler_ParseUrlTest4_UnitTest(CDataLogger& aDataLogger,

   391 																	MUnitTestObserver& aObserver)

   392 : CUnitTest(KSmsSchemeHandlerParseUrlTest4UnitTest, aDataLogger, aObserver)

   393 	{

   394 	//Do nothing

   395 	}

   396 

   397 // Now the Individual transitions need to be added.

   398 inline void CSmsSchemeHandler_ParseUrlTest4_UnitTest::ConstructL()

   399 	{

   400 	// Perform the base class initialization

   401 	UnitTestConstructL();

   402 

   403 	// Create the Unit test state accessor

   404 	iStateAccessor = new(ELeave) TSmsSchemeHandler_StateAccessor;

   405 	// Construct the Unit test context.

   406 	iUTContext = new(ELeave) CSmsSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

   407 	// Add the Transitions in the order they are to run

   408 	// C'tor first, D'tor last...

   409 	//	Examples of C'tor and D'tor transitions on CSmsSchemeHandler class.

   410 	//	using ctor and dtor validators

   411 	

   412 	_LIT(KUrl4, "sms: 4 , +441712081834 , +1800000000 ");

   413 	iUTContext->iUrl = &KUrl4(); 

   414 

   415 	_LIT(KNumber1, "4");

   416 	_LIT(KNumber2, "+441712081834");

   417 	_LIT(KNumber3, "+1800000000");

   418 

   419 	CSmsSchemeHandler_UnitTestContext::SSmsNumber num1;

   420 	CSmsSchemeHandler_UnitTestContext::SSmsNumber num2;

   421 	CSmsSchemeHandler_UnitTestContext::SSmsNumber num3;

   422 

   423 	num1.iNumber.Set(KNumber1);

   424 	num2.iNumber.Set(KNumber2);

   425 	num3.iNumber.Set(KNumber3);

   426 

   427 	iUTContext->iPostCheck.Append(num1);

   428 	iUTContext->iPostCheck.Append(num2);

   429 	iUTContext->iPostCheck.Append(num3);

   430 

   431 	iCtorValidator = new(ELeave) TSmsSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   432 	iParseUrlTest4Validator = new(ELeave) TSmsSchemeHandler_ParseUrlL_TransitionValidator(*iUTContext);

   433 	iDtorValidator = new(ELeave) TSmsSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   434 

   435 	AddTransitionL(new(ELeave)CSmsSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   436 	AddTransitionL(new(ELeave)CSmsSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest4Validator));

   437 	AddTransitionL(new(ELeave)CSmsSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   438 	}

   439 

   440 // ______________________________________________________________________________

   441 //

   442 _LIT(KSmsSchemeHandlerParseUrlTest5UnitTest,"CSmsSchemeHandler_ParseUrlTest5_UnitTest");

   443 

   444 CSmsSchemeHandler_ParseUrlTest5_UnitTest* CSmsSchemeHandler_ParseUrlTest5_UnitTest::NewL(CDataLogger& aDataLogger,

   445 											MUnitTestObserver& aObserver)

   446 	{

   447 	CSmsSchemeHandler_ParseUrlTest5_UnitTest* self = 

   448 					new(ELeave) CSmsSchemeHandler_ParseUrlTest5_UnitTest(aDataLogger,

   449 																aObserver);

   450 	CleanupStack::PushL(self);

   451 	self->ConstructL();

   452 	CleanupStack::Pop();

   453 	return self; 

   454 	}

   455 

   456 inline TInt CSmsSchemeHandler_ParseUrlTest5_UnitTest::RunError(TInt aError)

   457 	{

   458 	// The RunL left so chain to the base first and then cleanup

   459 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   460 	delete iUTContext;

   461 	delete iStateAccessor;

   462 	// delete any validators used

   463 	delete iCtorValidator;

   464 	delete iParseUrlTest5Validator;

   465 	delete iDtorValidator;

   466 	 

   467 	return error;

   468 	}

   469 

   470 inline CSmsSchemeHandler_ParseUrlTest5_UnitTest::~CSmsSchemeHandler_ParseUrlTest5_UnitTest()

   471 	{

   472 	// Simply delete our test class instance

   473 	delete iUTContext;

   474 	delete iStateAccessor;

   475 	// delete any validators used

   476 	delete iCtorValidator;

   477 	delete iParseUrlTest5Validator;

   478 	delete iDtorValidator;

   479 	 

   480 	}

   481 

   482 inline CSmsSchemeHandler_ParseUrlTest5_UnitTest::CSmsSchemeHandler_ParseUrlTest5_UnitTest(CDataLogger& aDataLogger,

   483 																	MUnitTestObserver& aObserver)

   484 : CUnitTest(KSmsSchemeHandlerParseUrlTest5UnitTest, aDataLogger, aObserver)

   485 	{

   486 	//Do nothing

   487 	}

   488 

   489 // Now the Individual transitions need to be added.

   490 inline void CSmsSchemeHandler_ParseUrlTest5_UnitTest::ConstructL()

   491 	{

   492 	// Perform the base class initialization

   493 	UnitTestConstructL();

   494 

   495 	// Create the Unit test state accessor

   496 	iStateAccessor = new(ELeave) TSmsSchemeHandler_StateAccessor;

   497 	// Construct the Unit test context.

   498 	iUTContext = new(ELeave) CSmsSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

   499 	// Add the Transitions in the order they are to run

   500 	// C'tor first, D'tor last...

   501 	//	Examples of C'tor and D'tor transitions on CSmsSchemeHandler class.

   502 	//	using ctor and dtor validators

   503 

   504 	_LIT(KUrl5, "sms: 4 ; via = +44468700700 , +441712081834 , +1800000000 ; via = 909 ");

   505 	iUTContext->iUrl = &KUrl5(); 

   506 

   507 	_LIT(KNumber1, "4");

   508 	_LIT(KServiceCentre1, "+44468700700");

   509 	_LIT(KNumber2, "+441712081834");

   510 	_LIT(KNumber3, "+1800000000");

   511 	_LIT(KServiceCentre3, "909");

   512 

   513 	CSmsSchemeHandler_UnitTestContext::SSmsNumber num1;

   514 	CSmsSchemeHandler_UnitTestContext::SSmsNumber num2;

   515 	CSmsSchemeHandler_UnitTestContext::SSmsNumber num3;

   516 

   517 	num1.iNumber.Set(KNumber1);

   518 	num1.iServiceCentre.Set(KServiceCentre1);

   519 	num2.iNumber.Set(KNumber2);

   520 	num3.iNumber.Set(KNumber3);

   521 	num3.iServiceCentre.Set(KServiceCentre3);

   522 

   523 	iUTContext->iPostCheck.Append(num1);

   524 	iUTContext->iPostCheck.Append(num2);

   525 	iUTContext->iPostCheck.Append(num3);

   526 

   527 	iCtorValidator = new(ELeave) TSmsSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   528 	iParseUrlTest5Validator = new(ELeave) TSmsSchemeHandler_ParseUrlL_TransitionValidator(*iUTContext);

   529 	iDtorValidator = new(ELeave) TSmsSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   530 

   531 	AddTransitionL(new(ELeave)CSmsSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   532 	AddTransitionL(new(ELeave)CSmsSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest5Validator));

   533 	AddTransitionL(new(ELeave)CSmsSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   534 

   535 	}

   536 

   537 // ______________________________________________________________________________

   538 //

   539 _LIT(KSmsSchemeHandlerParseUrlTest6UnitTest,"CSmsSchemeHandler_ParseUrlTest6_UnitTest");

   540 

   541 CSmsSchemeHandler_ParseUrlTest6_UnitTest* CSmsSchemeHandler_ParseUrlTest6_UnitTest::NewL(CDataLogger& aDataLogger,

   542 											MUnitTestObserver& aObserver)

   543 	{

   544 	CSmsSchemeHandler_ParseUrlTest6_UnitTest* self = 

   545 					new(ELeave) CSmsSchemeHandler_ParseUrlTest6_UnitTest(aDataLogger,

   546 																aObserver);

   547 	CleanupStack::PushL(self);

   548 	self->ConstructL();

   549 	CleanupStack::Pop();

   550 	return self; 

   551 	}

   552 

   553 inline TInt CSmsSchemeHandler_ParseUrlTest6_UnitTest::RunError(TInt aError)

   554 	{

   555 	// The RunL left so chain to the base first and then cleanup

   556 	TInt error = CUnitTest::RunError(aError);	// Chain to base

   557 	delete iUTContext;

   558 	delete iStateAccessor;

   559 	// delete any validators used

   560 	delete iCtorValidator;

   561 	delete iParseUrlTest6Validator;

   562 	delete iDtorValidator;

   563 	 

   564 	return error;

   565 	}

   566 

   567 inline CSmsSchemeHandler_ParseUrlTest6_UnitTest::~CSmsSchemeHandler_ParseUrlTest6_UnitTest()

   568 	{

   569 	// Simply delete our test class instance

   570 	delete iUTContext;

   571 	delete iStateAccessor;

   572 	// delete any validators used

   573 	delete iCtorValidator;

   574 	delete iParseUrlTest6Validator;

   575 	delete iDtorValidator;

   576 	 

   577 	}

   578 

   579 inline CSmsSchemeHandler_ParseUrlTest6_UnitTest::CSmsSchemeHandler_ParseUrlTest6_UnitTest(CDataLogger& aDataLogger,

   580 																	MUnitTestObserver& aObserver)

   581 : CUnitTest(KSmsSchemeHandlerParseUrlTest6UnitTest, aDataLogger, aObserver)

   582 	{

   583 	//Do nothing

   584 	}

   585 

   586 // Now the Individual transitions need to be added.

   587 inline void CSmsSchemeHandler_ParseUrlTest6_UnitTest::ConstructL()

   588 	{

   589 	// Perform the base class initialization

   590 	UnitTestConstructL();

   591 

   592 	// Create the Unit test state accessor

   593 	iStateAccessor = new(ELeave) TSmsSchemeHandler_StateAccessor;

   594 	// Construct the Unit test context.

   595 	iUTContext = new(ELeave) CSmsSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

   596 	// Add the Transitions in the order they are to run

   597 	// C'tor first, D'tor last...

   598 

   599 	_LIT(KUrl6, "sms: 4 ; via = +44468700700 , +441712081834 ; via = , +1800000000 ; via = 909 ");

   600 	iUTContext->iUrl = &KUrl6(); 

   601 

   602 	_LIT(KNumber1, "4");

   603 	_LIT(KServiceCentre1, "+44468700700");

   604 	_LIT(KNumber2, "+441712081834");

   605 	_LIT(KNumber3, "+1800000000");

   606 	_LIT(KServiceCentre3, "909");

   607 

   608 	CSmsSchemeHandler_UnitTestContext::SSmsNumber num1;

   609 	CSmsSchemeHandler_UnitTestContext::SSmsNumber num2;

   610 	CSmsSchemeHandler_UnitTestContext::SSmsNumber num3;

   611 

   612 	num1.iNumber.Set(KNumber1);

   613 	num1.iServiceCentre.Set(KServiceCentre1);

   614 	num2.iNumber.Set(KNumber2);

   615 	num3.iNumber.Set(KNumber3);

   616 	num3.iServiceCentre.Set(KServiceCentre3);

   617 

   618 	iUTContext->iPostCheck.Append(num1);

   619 	iUTContext->iPostCheck.Append(num2);

   620 	iUTContext->iPostCheck.Append(num3);

   621 

   622 	iCtorValidator = new(ELeave) TSmsSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   623 	iParseUrlTest6Validator = new(ELeave) TSmsSchemeHandler_ParseUrlL_TransitionValidator(*iUTContext);

   624 	iDtorValidator = new(ELeave) TSmsSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   625 

   626 	AddTransitionL(new(ELeave)CSmsSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   627 	AddTransitionL(new(ELeave)CSmsSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest6Validator));

   628 	AddTransitionL(new(ELeave)CSmsSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   629 

   630 	}

   631