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 CMailtoSchemeHandler class.

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20  @SYMCreationDate Created : 24/05/01 15:57:45

    21 */

    22 

    23 #include "MailtoSchemeHandlerUnitTest.h"

    24 

    25 // ______________________________________________________________________________

    26 //

    27 _LIT(KMailtoSchemeHandlerCreateAndDestroyUnitTest,"CMailtoSchemeHandler_CreateAndDestroy_UnitTest");

    28 

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

    30 											MUnitTestObserver& aObserver)

    31 	{

    32 	CMailtoSchemeHandler_CreateAndDestroy_UnitTest* self = 

    33 					new(ELeave) CMailtoSchemeHandler_CreateAndDestroy_UnitTest(aDataLogger,

    34 																aObserver);

    35 	CleanupStack::PushL(self);

    36 	self->ConstructL();

    37 	CleanupStack::Pop();

    38 	return self; 

    39 	}

    40 

    41 inline TInt CMailtoSchemeHandler_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 CMailtoSchemeHandler_CreateAndDestroy_UnitTest::~CMailtoSchemeHandler_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 CMailtoSchemeHandler_CreateAndDestroy_UnitTest::CMailtoSchemeHandler_CreateAndDestroy_UnitTest(CDataLogger& aDataLogger,

    68 																	MUnitTestObserver& aObserver)

    69 : CUnitTest(KMailtoSchemeHandlerCreateAndDestroyUnitTest, aDataLogger, aObserver)

    70 	{

    71 	//Do nothing

    72 	}

    73 

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

    75 inline void CMailtoSchemeHandler_CreateAndDestroy_UnitTest::ConstructL()

    76 	{

    77 	// Perform the base class initialization

    78 	UnitTestConstructL();

    79 

    80 	// Create the Unit test state accessor

    81 	iStateAccessor = new(ELeave) TMailtoSchemeHandler_StateAccessor;

    82 	// Construct the Unit test context.

    83 	iUTContext = new(ELeave) CMailtoSchemeHandler_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 CMailtoSchemeHandler class.

    87 	//	using ctor and dtor validators

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

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

    90 //		iCreateAndDestroyValidator = new(ELeave) TMailtoSchemeHandler_CreateAndDestroy_TransitionValidator(*iUTContext);

    91 //		AddTransitionL(new(ELeave)CMailtoSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

    92 		iDtorValidator = new(ELeave) TMailtoSchemeHandler_Dtor_TransitionValidator(*iUTContext);

    93 		AddTransitionL(new(ELeave)CMailtoSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

    94 	

    95 	}

    96 

    97 // ______________________________________________________________________________

    98 //

    99 _LIT(KMailtoSchemeHandlerParseUrlTest1UnitTest,"CMailtoSchemeHandler_ParseUrlTest1_UnitTest");

   100 

   101 CMailtoSchemeHandler_ParseUrlTest1_UnitTest* CMailtoSchemeHandler_ParseUrlTest1_UnitTest::NewL(CDataLogger& aDataLogger,

   102 											MUnitTestObserver& aObserver)

   103 	{

   104 	CMailtoSchemeHandler_ParseUrlTest1_UnitTest* self = 

   105 					new(ELeave) CMailtoSchemeHandler_ParseUrlTest1_UnitTest(aDataLogger,

   106 																aObserver);

   107 	CleanupStack::PushL(self);

   108 	self->ConstructL();

   109 	CleanupStack::Pop();

   110 	return self; 

   111 	}

   112 

   113 inline TInt CMailtoSchemeHandler_ParseUrlTest1_UnitTest::RunError(TInt aError)

   114 	{

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

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

   117 	delete iUTContext;

   118 	delete iStateAccessor;

   119 	// delete any validators used

   120 	delete iCtorValidator;

   121 	delete iParseUrlTest1Validator;

   122 	delete iDtorValidator;

   123 	 

   124 	return error;

   125 	}

   126 

   127 inline CMailtoSchemeHandler_ParseUrlTest1_UnitTest::~CMailtoSchemeHandler_ParseUrlTest1_UnitTest()

   128 	{

   129 	// Simply delete our test class instance

   130 	delete iUTContext;

   131 	delete iStateAccessor;

   132 	// delete any validators used

   133 	delete iCtorValidator;

   134 	delete iParseUrlTest1Validator;

   135 	delete iDtorValidator;

   136 	

   137 	}

   138 

   139 inline CMailtoSchemeHandler_ParseUrlTest1_UnitTest::CMailtoSchemeHandler_ParseUrlTest1_UnitTest(CDataLogger& aDataLogger,

   140 																	MUnitTestObserver& aObserver)

   141 : CUnitTest(KMailtoSchemeHandlerParseUrlTest1UnitTest, aDataLogger, aObserver)

   142 	{

   143 	//Do nothing

   144 	}

   145 

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

   147 inline void CMailtoSchemeHandler_ParseUrlTest1_UnitTest::ConstructL()

   148 	{

   149 

   150 	// Perform the base class initialization

   151 	UnitTestConstructL();

   152 

   153 	// Create the Unit test state accessor

   154 	iStateAccessor = new(ELeave) TMailtoSchemeHandler_StateAccessor;

   155 	// Construct the Unit test context.

   156 	iUTContext = new(ELeave) CMailtoSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

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

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

   159 	//	Examples of C'tor and D'tor transitions on CMailtoSchemeHandler class.

   160 	//	using ctor and dtor validators

   161 	

   162 	_LIT(KUrl1, "mailto: shahadat@symbian , david@symbian ");

   163 	//_LIT(KUrl1, "mailto: ");

   164 	iUTContext->iUrl = &KUrl1(); 

   165 

   166 	_LIT(KTo1, "shahadat@symbian");

   167 	_LIT(KTo2, "david@symbian");

   168 

   169 	iUTContext->iArray.Append(KTo1());

   170 	iUTContext->iArray.Append(KTo2());

   171 	

   172 	iCtorValidator = new(ELeave) TMailtoSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   173 	iParseUrlTest1Validator = new(ELeave) TMailtoSchemeHandler_ParseUrlTest1_TransitionValidator(*iUTContext);

   174 	iDtorValidator = new(ELeave) TMailtoSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   175 

   176 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   177 	//AddTransitionL(new(ELeave)CMailtoSchemeHandler_ParseUrlAndSendL_Transition(*iUTContext,*iParseUrlTest1Validator));

   178 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest1Validator));

   179 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   180 	}

   181 

   182 

   183 // ______________________________________________________________________________

   184 //

   185 _LIT(KMailtoSchemeHandlerParseUrlTest2UnitTest,"CMailtoSchemeHandler_ParseUrlTest2_UnitTest");

   186 

   187 CMailtoSchemeHandler_ParseUrlTest2_UnitTest* CMailtoSchemeHandler_ParseUrlTest2_UnitTest::NewL(CDataLogger& aDataLogger,

   188 											MUnitTestObserver& aObserver)

   189 	{

   190 	CMailtoSchemeHandler_ParseUrlTest2_UnitTest* self = 

   191 					new(ELeave) CMailtoSchemeHandler_ParseUrlTest2_UnitTest(aDataLogger,

   192 																aObserver);

   193 	CleanupStack::PushL(self);

   194 	self->ConstructL();

   195 	CleanupStack::Pop();

   196 	return self; 

   197 	}

   198 

   199 inline TInt CMailtoSchemeHandler_ParseUrlTest2_UnitTest::RunError(TInt aError)

   200 	{

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

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

   203 	delete iUTContext;

   204 	delete iStateAccessor;

   205 	// delete any validators used

   206 	delete iCtorValidator;

   207 	delete iParseUrlTest2Validator;

   208 	delete iDtorValidator;

   209 	

   210 	return error;

   211 	}

   212 

   213 inline CMailtoSchemeHandler_ParseUrlTest2_UnitTest::~CMailtoSchemeHandler_ParseUrlTest2_UnitTest()

   214 	{

   215 	// Simply delete our test class instance

   216 	delete iUTContext;

   217 	delete iStateAccessor;

   218 	// delete any validators used

   219 	delete iCtorValidator;

   220 	delete iParseUrlTest2Validator;

   221 	delete iDtorValidator;

   222 	}

   223 

   224 inline CMailtoSchemeHandler_ParseUrlTest2_UnitTest::CMailtoSchemeHandler_ParseUrlTest2_UnitTest(CDataLogger& aDataLogger,

   225 																	MUnitTestObserver& aObserver)

   226 : CUnitTest(KMailtoSchemeHandlerParseUrlTest2UnitTest, aDataLogger, aObserver)

   227 	{

   228 	//Do nothing

   229 	}

   230 

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

   232 inline void CMailtoSchemeHandler_ParseUrlTest2_UnitTest::ConstructL()

   233 	{

   234 	// Perform the base class initialization

   235 	UnitTestConstructL();

   236 

   237 	// Create the Unit test state accessor

   238 	iStateAccessor = new(ELeave) TMailtoSchemeHandler_StateAccessor;

   239 	// Construct the Unit test context.

   240 	iUTContext = new(ELeave) CMailtoSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

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

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

   243 	//	Examples of C'tor and D'tor transitions on CMailtoSchemeHandler class.

   244 	//	using ctor and dtor validators

   245 

   246 	_LIT(KUrl2, "mailto: shahadat@symbian%2cdavid@symbian");

   247 	iUTContext->iUrl = &KUrl2(); 

   248 

   249 	_LIT(KTo1, "shahadat@symbian");

   250 	_LIT(KTo2, "david@symbian");

   251 

   252 	iUTContext->iArray.Append(KTo1());

   253 	iUTContext->iArray.Append(KTo2());

   254 

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

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

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

   258 

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

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

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

   262 	}

   263 

   264 // ______________________________________________________________________________

   265 //

   266 _LIT(KMailtoSchemeHandlerParseUrlTest3UnitTest,"CMailtoSchemeHandler_ParseUrlTest3_UnitTest");

   267 

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

   269 											MUnitTestObserver& aObserver)

   270 	{

   271 	CMailtoSchemeHandler_ParseUrlTest3_UnitTest* self = 

   272 					new(ELeave) CMailtoSchemeHandler_ParseUrlTest3_UnitTest(aDataLogger,

   273 																aObserver);

   274 	CleanupStack::PushL(self);

   275 	self->ConstructL();

   276 	CleanupStack::Pop();

   277 	return self; 

   278 	}

   279 

   280 inline TInt CMailtoSchemeHandler_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 CMailtoSchemeHandler_ParseUrlTest3_UnitTest::~CMailtoSchemeHandler_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 inline CMailtoSchemeHandler_ParseUrlTest3_UnitTest::CMailtoSchemeHandler_ParseUrlTest3_UnitTest(CDataLogger& aDataLogger,

   306 																	MUnitTestObserver& aObserver)

   307 : CUnitTest(KMailtoSchemeHandlerParseUrlTest3UnitTest, aDataLogger, aObserver)

   308 	{

   309 	//Do nothing

   310 	}

   311 

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

   313 inline void CMailtoSchemeHandler_ParseUrlTest3_UnitTest::ConstructL()

   314 	{

   315 	// Perform the base class initialization

   316 	UnitTestConstructL();

   317 

   318 	// Create the Unit test state accessor

   319 	iStateAccessor = new(ELeave) TMailtoSchemeHandler_StateAccessor;

   320 	// Construct the Unit test context.

   321 	iUTContext = new(ELeave) CMailtoSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

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

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

   324 	//	Examples of C'tor and D'tor transitions on CMailtoSchemeHandler class.

   325 	//	using ctor and dtor validators

   326 	

   327 	_LIT(KUrl3, "mailto: shahadat@symbian ? to = david@symbian ");

   328 	iUTContext->iUrl = &KUrl3(); 

   329 

   330 	_LIT(KTo1, "shahadat@symbian");

   331 	_LIT(KTo2, "david@symbian");

   332 

   333 	iUTContext->iArray.Append(KTo1());

   334 	iUTContext->iArray.Append(KTo2());

   335 

   336 	iCtorValidator = new(ELeave) TMailtoSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   337 	iParseUrlTest3Validator = new(ELeave) TMailtoSchemeHandler_ParseUrlTest1_TransitionValidator(*iUTContext);

   338 	iDtorValidator = new(ELeave) TMailtoSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   339 

   340 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   341 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest3Validator));

   342 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   343 	}

   344 

   345 

   346 // ______________________________________________________________________________

   347 //

   348 _LIT(KMailtoSchemeHandlerParseUrlTest4UnitTest,"CMailtoSchemeHandler_ParseUrlTest4_UnitTest");

   349 

   350 CMailtoSchemeHandler_ParseUrlTest4_UnitTest* CMailtoSchemeHandler_ParseUrlTest4_UnitTest::NewL(CDataLogger& aDataLogger,

   351 											MUnitTestObserver& aObserver)

   352 	{

   353 	CMailtoSchemeHandler_ParseUrlTest4_UnitTest* self = 

   354 					new(ELeave) CMailtoSchemeHandler_ParseUrlTest4_UnitTest(aDataLogger,

   355 																aObserver);

   356 	CleanupStack::PushL(self);

   357 	self->ConstructL();

   358 	CleanupStack::Pop();

   359 	return self; 

   360 	}

   361 

   362 inline TInt CMailtoSchemeHandler_ParseUrlTest4_UnitTest::RunError(TInt aError)

   363 	{

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

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

   366 	delete iUTContext;

   367 	delete iStateAccessor;

   368 	// delete any validators used

   369 	delete iCtorValidator;

   370 	delete iParseUrlTest4Validator;

   371 	delete iDtorValidator;

   372 	

   373 	return error;

   374 	}

   375 

   376 inline CMailtoSchemeHandler_ParseUrlTest4_UnitTest::~CMailtoSchemeHandler_ParseUrlTest4_UnitTest()

   377 	{

   378 	// Simply delete our test class instance

   379 	delete iUTContext;

   380 	delete iStateAccessor;

   381 	// delete any validators used

   382 	delete iCtorValidator;

   383 	delete iParseUrlTest4Validator;

   384 	delete iDtorValidator;

   385 	

   386 	}

   387 

   388 inline CMailtoSchemeHandler_ParseUrlTest4_UnitTest::CMailtoSchemeHandler_ParseUrlTest4_UnitTest(CDataLogger& aDataLogger,

   389 																	MUnitTestObserver& aObserver)

   390 : CUnitTest(KMailtoSchemeHandlerParseUrlTest4UnitTest, aDataLogger, aObserver)

   391 	{

   392 	//Do nothing

   393 	}

   394 

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

   396 inline void CMailtoSchemeHandler_ParseUrlTest4_UnitTest::ConstructL()

   397 	{

   398 	// Perform the base class initialization

   399 	UnitTestConstructL();

   400 

   401 	// Create the Unit test state accessor

   402 	iStateAccessor = new(ELeave) TMailtoSchemeHandler_StateAccessor;

   403 	// Construct the Unit test context.

   404 	iUTContext = new(ELeave) CMailtoSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

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

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

   407 	//	Examples of C'tor and D'tor transitions on CMailtoSchemeHandler class.

   408 	//	using ctor and dtor validators

   409 	

   410 	_LIT(KUrl4, "mailto: shahadat@symbian ? cc = david@symbian ");

   411 	iUTContext->iUrl = &KUrl4(); 

   412 

   413 	_LIT(KTo1, "shahadat@symbian");

   414 	_LIT(KTo2, "david@symbian");

   415 

   416 	iUTContext->iArray.Append(KTo1());

   417 	iUTContext->iArray.Append(KTo2());

   418 

   419 	iCtorValidator = new(ELeave) TMailtoSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   420 	iParseUrlTest4Validator = new(ELeave) TMailtoSchemeHandler_ParseUrlTest1_TransitionValidator(*iUTContext);

   421 	iDtorValidator = new(ELeave) TMailtoSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   422 

   423 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   424 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest4Validator));

   425 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   426 	}

   427 

   428 

   429 // ______________________________________________________________________________

   430 //

   431 _LIT(KMailtoSchemeHandlerParseUrlTest5UnitTest,"CMailtoSchemeHandler_ParseUrlTest5_UnitTest");

   432 

   433 CMailtoSchemeHandler_ParseUrlTest5_UnitTest* CMailtoSchemeHandler_ParseUrlTest5_UnitTest::NewL(CDataLogger& aDataLogger,

   434 											MUnitTestObserver& aObserver)

   435 	{

   436 	CMailtoSchemeHandler_ParseUrlTest5_UnitTest* self = 

   437 					new(ELeave) CMailtoSchemeHandler_ParseUrlTest5_UnitTest(aDataLogger,

   438 																aObserver);

   439 	CleanupStack::PushL(self);

   440 	self->ConstructL();

   441 	CleanupStack::Pop();

   442 	return self; 

   443 	}

   444 

   445 inline TInt CMailtoSchemeHandler_ParseUrlTest5_UnitTest::RunError(TInt aError)

   446 	{

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

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

   449 	delete iUTContext;

   450 	delete iStateAccessor;

   451 	// delete any validators used

   452 	delete iCtorValidator;

   453 	delete iParseUrlTest5Validator;

   454 	delete iDtorValidator;

   455 

   456 	return error;

   457 	}

   458 

   459 inline CMailtoSchemeHandler_ParseUrlTest5_UnitTest::~CMailtoSchemeHandler_ParseUrlTest5_UnitTest()

   460 	{

   461 	// Simply delete our test class instance

   462 	delete iUTContext;

   463 	delete iStateAccessor;

   464 	// delete any validators used

   465 	delete iCtorValidator;

   466 	delete iParseUrlTest5Validator;

   467 	delete iDtorValidator;

   468 	}

   469 

   470 inline CMailtoSchemeHandler_ParseUrlTest5_UnitTest::CMailtoSchemeHandler_ParseUrlTest5_UnitTest(CDataLogger& aDataLogger,

   471 																	MUnitTestObserver& aObserver)

   472 : CUnitTest(KMailtoSchemeHandlerParseUrlTest5UnitTest, aDataLogger, aObserver)

   473 	{

   474 	//Do nothing

   475 	}

   476 

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

   478 inline void CMailtoSchemeHandler_ParseUrlTest5_UnitTest::ConstructL()

   479 	{

   480 	// Perform the base class initialization

   481 	UnitTestConstructL();

   482 

   483 	// Create the Unit test state accessor

   484 	iStateAccessor = new(ELeave) TMailtoSchemeHandler_StateAccessor;

   485 	// Construct the Unit test context.

   486 	iUTContext = new(ELeave) CMailtoSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

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

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

   489 	//	Examples of C'tor and D'tor transitions on CMailtoSchemeHandler class.

   490 	//	using ctor and dtor validators

   491 

   492 	_LIT(KUrl5, "mailto: shahadat@symbian ? bcc = david@symbian ");

   493 	iUTContext->iUrl = &KUrl5(); 

   494 

   495 	_LIT(KTo1, "shahadat@symbian");

   496 	_LIT(KTo2, "david@symbian");

   497 

   498 	iUTContext->iArray.Append(KTo1());

   499 	iUTContext->iArray.Append(KTo2());

   500 

   501 	iCtorValidator = new(ELeave) TMailtoSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   502 	iParseUrlTest5Validator = new(ELeave) TMailtoSchemeHandler_ParseUrlTest1_TransitionValidator(*iUTContext);

   503 	iDtorValidator = new(ELeave) TMailtoSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   504 

   505 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   506 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest5Validator));

   507 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   508 	}

   509 

   510 

   511 // ______________________________________________________________________________

   512 //

   513 _LIT(KMailtoSchemeHandlerParseUrlTest6UnitTest,"CMailtoSchemeHandler_ParseUrlTest6_UnitTest");

   514 

   515 CMailtoSchemeHandler_ParseUrlTest6_UnitTest* CMailtoSchemeHandler_ParseUrlTest6_UnitTest::NewL(CDataLogger& aDataLogger,

   516 											MUnitTestObserver& aObserver)

   517 	{

   518 	CMailtoSchemeHandler_ParseUrlTest6_UnitTest* self = 

   519 					new(ELeave) CMailtoSchemeHandler_ParseUrlTest6_UnitTest(aDataLogger,

   520 																aObserver);

   521 	CleanupStack::PushL(self);

   522 	self->ConstructL();

   523 	CleanupStack::Pop();

   524 	return self; 

   525 	}

   526 

   527 inline TInt CMailtoSchemeHandler_ParseUrlTest6_UnitTest::RunError(TInt aError)

   528 	{

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

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

   531 	delete iUTContext;

   532 	delete iStateAccessor;

   533 	// delete any validators used

   534 	delete iCtorValidator;

   535 	delete iParseUrlTest6Validator;

   536 	delete iDtorValidator;

   537 	 

   538 	return error;

   539 	}

   540 

   541 inline CMailtoSchemeHandler_ParseUrlTest6_UnitTest::~CMailtoSchemeHandler_ParseUrlTest6_UnitTest()

   542 	{

   543 	// Simply delete our test class instance

   544 	delete iUTContext;

   545 	delete iStateAccessor;

   546 	// delete any validators used

   547 	delete iCtorValidator;

   548 	delete iParseUrlTest6Validator;

   549 	delete iDtorValidator;

   550 	 

   551 	}

   552 

   553 inline CMailtoSchemeHandler_ParseUrlTest6_UnitTest::CMailtoSchemeHandler_ParseUrlTest6_UnitTest(CDataLogger& aDataLogger,

   554 																	MUnitTestObserver& aObserver)

   555 : CUnitTest(KMailtoSchemeHandlerParseUrlTest6UnitTest, aDataLogger, aObserver)

   556 	{

   557 	//Do nothing

   558 	}

   559 

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

   561 inline void CMailtoSchemeHandler_ParseUrlTest6_UnitTest::ConstructL()

   562 	{

   563 	// Perform the base class initialization

   564 	UnitTestConstructL();

   565 

   566 	// Create the Unit test state accessor

   567 	iStateAccessor = new(ELeave) TMailtoSchemeHandler_StateAccessor;

   568 	// Construct the Unit test context.

   569 	iUTContext = new(ELeave) CMailtoSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

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

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

   572 	//	Examples of C'tor and D'tor transitions on CMailtoSchemeHandler class.

   573 	//	using ctor and dtor validators

   574 

   575 	_LIT(KUrl6, "mailto: ? to = david@symbian ");

   576 	iUTContext->iUrl = &KUrl6(); 

   577 

   578 	_LIT(KTo1, "david@symbian");

   579 

   580 	iUTContext->iArray.Append(KTo1());

   581 

   582 	iCtorValidator = new(ELeave) TMailtoSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   583 	iParseUrlTest6Validator = new(ELeave) TMailtoSchemeHandler_ParseUrlTest1_TransitionValidator(*iUTContext);

   584 	iDtorValidator = new(ELeave) TMailtoSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   585 

   586 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   587 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest6Validator));

   588 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   589 

   590 	}

   591 

   592 // ______________________________________________________________________________

   593 //

   594 _LIT(KMailtoSchemeHandlerParseUrlTest7UnitTest,"CMailtoSchemeHandler_ParseUrlTest7_UnitTest");

   595 

   596 CMailtoSchemeHandler_ParseUrlTest7_UnitTest* CMailtoSchemeHandler_ParseUrlTest7_UnitTest::NewL(CDataLogger& aDataLogger,

   597 											MUnitTestObserver& aObserver)

   598 	{

   599 	CMailtoSchemeHandler_ParseUrlTest7_UnitTest* self = 

   600 					new(ELeave) CMailtoSchemeHandler_ParseUrlTest7_UnitTest(aDataLogger,

   601 																aObserver);

   602 	CleanupStack::PushL(self);

   603 	self->ConstructL();

   604 	CleanupStack::Pop();

   605 	return self; 

   606 	}

   607 

   608 inline TInt CMailtoSchemeHandler_ParseUrlTest7_UnitTest::RunError(TInt aError)

   609 	{

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

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

   612 	delete iUTContext;

   613 	delete iStateAccessor;

   614 	// delete any validators used

   615 	delete iCtorValidator;

   616 	delete iParseUrlTest7Validator;

   617 	delete iDtorValidator;

   618 	 

   619 	return error;

   620 	}

   621 

   622 inline CMailtoSchemeHandler_ParseUrlTest7_UnitTest::~CMailtoSchemeHandler_ParseUrlTest7_UnitTest()

   623 	{

   624 	// Simply delete our test class instance

   625 	delete iUTContext;

   626 	delete iStateAccessor;

   627 	// delete any validators used

   628 	delete iCtorValidator;

   629 	delete iParseUrlTest7Validator;

   630 	delete iDtorValidator;

   631 	 

   632 	}

   633 

   634 inline CMailtoSchemeHandler_ParseUrlTest7_UnitTest::CMailtoSchemeHandler_ParseUrlTest7_UnitTest(CDataLogger& aDataLogger,

   635 																	MUnitTestObserver& aObserver)

   636 : CUnitTest(KMailtoSchemeHandlerParseUrlTest7UnitTest, aDataLogger, aObserver)

   637 	{

   638 	//Do nothing

   639 	}

   640 

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

   642 inline void CMailtoSchemeHandler_ParseUrlTest7_UnitTest::ConstructL()

   643 	{

   644 	// Perform the base class initialization

   645 	UnitTestConstructL();

   646 

   647 	// Create the Unit test state accessor

   648 	iStateAccessor = new(ELeave) TMailtoSchemeHandler_StateAccessor;

   649 	// Construct the Unit test context.

   650 	iUTContext = new(ELeave) CMailtoSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

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

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

   653 	//	Examples of C'tor and D'tor transitions on CMailtoSchemeHandler class.

   654 	//	using ctor and dtor validators

   655 

   656 	_LIT(KUrl7, "mailto: ? cc = david@symbian ");

   657 	iUTContext->iUrl = &KUrl7(); 

   658 

   659 	_LIT(KTo1, "david@symbian");

   660 

   661 	iUTContext->iArray.Append(KTo1());

   662 

   663 	iCtorValidator = new(ELeave) TMailtoSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   664 	iParseUrlTest7Validator = new(ELeave) TMailtoSchemeHandler_ParseUrlTest1_TransitionValidator(*iUTContext);

   665 	iDtorValidator = new(ELeave) TMailtoSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   666 

   667 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   668 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest7Validator));

   669 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   670 	}

   671 

   672 

   673 // ______________________________________________________________________________

   674 //

   675 _LIT(KMailtoSchemeHandlerParseUrlTest8UnitTest,"CMailtoSchemeHandler_ParseUrlTest8_UnitTest");

   676 

   677 CMailtoSchemeHandler_ParseUrlTest8_UnitTest* CMailtoSchemeHandler_ParseUrlTest8_UnitTest::NewL(CDataLogger& aDataLogger,

   678 											MUnitTestObserver& aObserver)

   679 	{

   680 	CMailtoSchemeHandler_ParseUrlTest8_UnitTest* self = 

   681 					new(ELeave) CMailtoSchemeHandler_ParseUrlTest8_UnitTest(aDataLogger,

   682 																aObserver);

   683 	CleanupStack::PushL(self);

   684 	self->ConstructL();

   685 	CleanupStack::Pop();

   686 	return self; 

   687 	}

   688 

   689 inline TInt CMailtoSchemeHandler_ParseUrlTest8_UnitTest::RunError(TInt aError)

   690 	{

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

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

   693 	delete iUTContext;

   694 	delete iStateAccessor;

   695 	// delete any validators used

   696 	delete iCtorValidator;

   697 	delete iParseUrlTest8Validator;

   698 	delete iDtorValidator;

   699 

   700 	return error;

   701 	}

   702 

   703 inline CMailtoSchemeHandler_ParseUrlTest8_UnitTest::~CMailtoSchemeHandler_ParseUrlTest8_UnitTest()

   704 	{

   705 	// Simply delete our test class instance

   706 	delete iUTContext;

   707 	delete iStateAccessor;

   708 	// delete any validators used

   709 	delete iCtorValidator;

   710 	delete iParseUrlTest8Validator;

   711 	delete iDtorValidator;

   712 	}

   713 

   714 inline CMailtoSchemeHandler_ParseUrlTest8_UnitTest::CMailtoSchemeHandler_ParseUrlTest8_UnitTest(CDataLogger& aDataLogger,

   715 																	MUnitTestObserver& aObserver)

   716 : CUnitTest(KMailtoSchemeHandlerParseUrlTest8UnitTest, aDataLogger, aObserver)

   717 	{

   718 	//Do nothing

   719 	}

   720 

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

   722 inline void CMailtoSchemeHandler_ParseUrlTest8_UnitTest::ConstructL()

   723 	{

   724 	// Perform the base class initialization

   725 	UnitTestConstructL();

   726 

   727 	// Create the Unit test state accessor

   728 	iStateAccessor = new(ELeave) TMailtoSchemeHandler_StateAccessor;

   729 	// Construct the Unit test context.

   730 	iUTContext = new(ELeave) CMailtoSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

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

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

   733 	//	Examples of C'tor and D'tor transitions on CMailtoSchemeHandler class.

   734 	//	using ctor and dtor validators

   735 

   736 	_LIT(KUrl8, "mailto: ? bcc = david@symbian ");

   737 	iUTContext->iUrl = &KUrl8(); 

   738 

   739 	_LIT(KTo1, "david@symbian");

   740 

   741 	iUTContext->iArray.Append(KTo1());

   742 

   743 	iCtorValidator = new(ELeave) TMailtoSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   744 	iParseUrlTest8Validator = new(ELeave) TMailtoSchemeHandler_ParseUrlTest1_TransitionValidator(*iUTContext);

   745 	iDtorValidator = new(ELeave) TMailtoSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   746 

   747 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   748 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest8Validator));

   749 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   750 	}

   751 

   752 

   753 // ______________________________________________________________________________

   754 //

   755 _LIT(KMailtoSchemeHandlerParseUrlTest9UnitTest,"CMailtoSchemeHandler_ParseUrlTest9_UnitTest");

   756 

   757 CMailtoSchemeHandler_ParseUrlTest9_UnitTest* CMailtoSchemeHandler_ParseUrlTest9_UnitTest::NewL(CDataLogger& aDataLogger,

   758 											MUnitTestObserver& aObserver)

   759 	{

   760 	CMailtoSchemeHandler_ParseUrlTest9_UnitTest* self = 

   761 					new(ELeave) CMailtoSchemeHandler_ParseUrlTest9_UnitTest(aDataLogger,

   762 																aObserver);

   763 	CleanupStack::PushL(self);

   764 	self->ConstructL();

   765 	CleanupStack::Pop();

   766 	return self; 

   767 	}

   768 

   769 inline TInt CMailtoSchemeHandler_ParseUrlTest9_UnitTest::RunError(TInt aError)

   770 	{

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

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

   773 	delete iUTContext;

   774 	delete iStateAccessor;

   775 	// delete any validators used

   776 	delete iCtorValidator;

   777 	delete iParseUrlTest9Validator;

   778 	delete iDtorValidator;

   779 	 

   780 	return error;

   781 	}

   782 

   783 inline CMailtoSchemeHandler_ParseUrlTest9_UnitTest::~CMailtoSchemeHandler_ParseUrlTest9_UnitTest()

   784 	{

   785 	// Simply delete our test class instance

   786 	delete iUTContext;

   787 	delete iStateAccessor;

   788 	// delete any validators used

   789 	delete iCtorValidator;

   790 	delete iParseUrlTest9Validator;

   791 	delete iDtorValidator;

   792 	}

   793 

   794 inline CMailtoSchemeHandler_ParseUrlTest9_UnitTest::CMailtoSchemeHandler_ParseUrlTest9_UnitTest(CDataLogger& aDataLogger,

   795 																	MUnitTestObserver& aObserver)

   796 : CUnitTest(KMailtoSchemeHandlerParseUrlTest9UnitTest, aDataLogger, aObserver)

   797 	{

   798 	//Do nothing

   799 	}

   800 

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

   802 inline void CMailtoSchemeHandler_ParseUrlTest9_UnitTest::ConstructL()

   803 	{

   804 	// Perform the base class initialization

   805 	UnitTestConstructL();

   806 

   807 	// Create the Unit test state accessor

   808 	iStateAccessor = new(ELeave) TMailtoSchemeHandler_StateAccessor;

   809 	// Construct the Unit test context.

   810 	iUTContext = new(ELeave) CMailtoSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

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

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

   813 	//	Examples of C'tor and D'tor transitions on CMailtoSchemeHandler class.

   814 	//	using ctor and dtor validators

   815 

   816 	_LIT(KUrl9, "mailto: ? subject = hello world ");

   817 	iUTContext->iUrl = &KUrl9(); 

   818 

   819 	_LIT(KSubject, "hello world");

   820 	iUTContext->iSubjectCheck = &KSubject(); 	

   821 

   822 	iCtorValidator = new(ELeave) TMailtoSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   823 	iParseUrlTest9Validator = new(ELeave) TMailtoSchemeHandler_ParseUrlTest9_TransitionValidator(*iUTContext);

   824 	iDtorValidator = new(ELeave) TMailtoSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   825 

   826 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   827 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest9Validator));

   828 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   829 	}

   830 

   831 

   832 // ______________________________________________________________________________

   833 //

   834 _LIT(KMailtoSchemeHandlerParseUrlTest10UnitTest,"CMailtoSchemeHandler_ParseUrlTest10_UnitTest");

   835 

   836 CMailtoSchemeHandler_ParseUrlTest10_UnitTest* CMailtoSchemeHandler_ParseUrlTest10_UnitTest::NewL(CDataLogger& aDataLogger,

   837 											MUnitTestObserver& aObserver)

   838 	{

   839 	CMailtoSchemeHandler_ParseUrlTest10_UnitTest* self = 

   840 					new(ELeave) CMailtoSchemeHandler_ParseUrlTest10_UnitTest(aDataLogger,

   841 																aObserver);

   842 	CleanupStack::PushL(self);

   843 	self->ConstructL();

   844 	CleanupStack::Pop();

   845 	return self; 

   846 	}

   847 

   848 inline TInt CMailtoSchemeHandler_ParseUrlTest10_UnitTest::RunError(TInt aError)

   849 	{

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

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

   852 	delete iUTContext;

   853 	delete iStateAccessor;

   854 	// delete any validators used

   855 	delete iCtorValidator;

   856 	delete iParseUrlTest10Validator;

   857 	delete iDtorValidator;

   858 	 

   859 	return error;

   860 	}

   861 

   862 inline CMailtoSchemeHandler_ParseUrlTest10_UnitTest::~CMailtoSchemeHandler_ParseUrlTest10_UnitTest()

   863 	{

   864 	// Simply delete our test class instance

   865 	delete iUTContext;

   866 	delete iStateAccessor;

   867 	// delete any validators used

   868 	delete iCtorValidator;

   869 	delete iParseUrlTest10Validator;

   870 	delete iDtorValidator;

   871 	}

   872 

   873 inline CMailtoSchemeHandler_ParseUrlTest10_UnitTest::CMailtoSchemeHandler_ParseUrlTest10_UnitTest(CDataLogger& aDataLogger,

   874 																	MUnitTestObserver& aObserver)

   875 : CUnitTest(KMailtoSchemeHandlerParseUrlTest10UnitTest, aDataLogger, aObserver)

   876 	{

   877 	//Do nothing

   878 	}

   879 

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

   881 inline void CMailtoSchemeHandler_ParseUrlTest10_UnitTest::ConstructL()

   882 	{

   883 	// Perform the base class initialization

   884 	UnitTestConstructL();

   885 

   886 	// Create the Unit test state accessor

   887 	iStateAccessor = new(ELeave) TMailtoSchemeHandler_StateAccessor;

   888 	// Construct the Unit test context.

   889 	iUTContext = new(ELeave) CMailtoSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

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

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

   892 	//	Examples of C'tor and D'tor transitions on CMailtoSchemeHandler class.

   893 	//	using ctor and dtor validators

   894 

   895 	_LIT(KUrl10, "mailto: ? subject = something & something else ");

   896 	iUTContext->iUrl = &KUrl10(); 

   897 

   898 	_LIT(KSubject, "something");

   899 	iUTContext->iSubjectCheck = &KSubject(); 	

   900 

   901 	iCtorValidator = new(ELeave) TMailtoSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   902 	iParseUrlTest10Validator = new(ELeave) TMailtoSchemeHandler_ParseUrlTest9_TransitionValidator(*iUTContext);

   903 	iDtorValidator = new(ELeave) TMailtoSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   904 

   905 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   906 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest10Validator));

   907 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   908 	}

   909 

   910 // ______________________________________________________________________________

   911 //

   912 _LIT(KMailtoSchemeHandlerParseUrlTest11UnitTest,"CMailtoSchemeHandler_ParseUrlTest11_UnitTest");

   913 

   914 CMailtoSchemeHandler_ParseUrlTest11_UnitTest* CMailtoSchemeHandler_ParseUrlTest11_UnitTest::NewL(CDataLogger& aDataLogger,

   915 											MUnitTestObserver& aObserver)

   916 	{

   917 	CMailtoSchemeHandler_ParseUrlTest11_UnitTest* self = 

   918 					new(ELeave) CMailtoSchemeHandler_ParseUrlTest11_UnitTest(aDataLogger,

   919 																aObserver);

   920 	CleanupStack::PushL(self);

   921 	self->ConstructL();

   922 	CleanupStack::Pop();

   923 	return self; 

   924 	}

   925 

   926 inline TInt CMailtoSchemeHandler_ParseUrlTest11_UnitTest::RunError(TInt aError)

   927 	{

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

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

   930 	delete iUTContext;

   931 	delete iStateAccessor;

   932 	// delete any validators used

   933 	delete iCtorValidator;

   934 	delete iParseUrlTest11Validator;

   935 	delete iDtorValidator;

   936 	 

   937 	return error;

   938 	}

   939 

   940 inline CMailtoSchemeHandler_ParseUrlTest11_UnitTest::~CMailtoSchemeHandler_ParseUrlTest11_UnitTest()

   941 	{

   942 	// Simply delete our test class instance

   943 	delete iUTContext;

   944 	delete iStateAccessor;

   945 	// delete any validators used

   946 	delete iCtorValidator;

   947 	delete iParseUrlTest11Validator;

   948 	delete iDtorValidator;

   949 	}

   950 

   951 inline CMailtoSchemeHandler_ParseUrlTest11_UnitTest::CMailtoSchemeHandler_ParseUrlTest11_UnitTest(CDataLogger& aDataLogger,

   952 																	MUnitTestObserver& aObserver)

   953 : CUnitTest(KMailtoSchemeHandlerParseUrlTest11UnitTest, aDataLogger, aObserver)

   954 	{

   955 	//Do nothing

   956 	}

   957 

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

   959 inline void CMailtoSchemeHandler_ParseUrlTest11_UnitTest::ConstructL()

   960 	{

   961 	// Perform the base class initialization

   962 	UnitTestConstructL();

   963 

   964 	// Create the Unit test state accessor

   965 	iStateAccessor = new(ELeave) TMailtoSchemeHandler_StateAccessor;

   966 	// Construct the Unit test context.

   967 	iUTContext = new(ELeave) CMailtoSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

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

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

   970 	//	Examples of C'tor and D'tor transitions on CMailtoSchemeHandler class.

   971 	//	using ctor and dtor validators

   972 

   973 	_LIT(KUrl11, "mailto: ? subject = something %26 something else ");

   974 	iUTContext->iUrl = &KUrl11(); 

   975 

   976 	_LIT(KSubject, "something");

   977 	iUTContext->iSubjectCheck = &KSubject(); 	

   978 

   979 	iCtorValidator = new(ELeave) TMailtoSchemeHandler_Ctor_TransitionValidator(*iUTContext);

   980 	iParseUrlTest11Validator = new(ELeave) TMailtoSchemeHandler_ParseUrlTest9_TransitionValidator(*iUTContext);

   981 	iDtorValidator = new(ELeave) TMailtoSchemeHandler_Dtor_TransitionValidator(*iUTContext);

   982 

   983 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

   984 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest11Validator));

   985 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));

   986 	}

   987 

   988 // ______________________________________________________________________________

   989 //

   990 _LIT(KMailtoSchemeHandlerParseUrlTest12UnitTest,"CMailtoSchemeHandler_ParseUrlTest12_UnitTest");

   991 

   992 CMailtoSchemeHandler_ParseUrlTest12_UnitTest* CMailtoSchemeHandler_ParseUrlTest12_UnitTest::NewL(CDataLogger& aDataLogger,

   993 											MUnitTestObserver& aObserver)

   994 	{

   995 	CMailtoSchemeHandler_ParseUrlTest12_UnitTest* self = 

   996 					new(ELeave) CMailtoSchemeHandler_ParseUrlTest12_UnitTest(aDataLogger,

   997 																aObserver);

   998 	CleanupStack::PushL(self);

   999 	self->ConstructL();

  1000 	CleanupStack::Pop();

  1001 	return self; 

  1002 	}

  1003 

  1004 inline TInt CMailtoSchemeHandler_ParseUrlTest12_UnitTest::RunError(TInt aError)

  1005 	{

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

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

  1008 	delete iUTContext;

  1009 	delete iStateAccessor;

  1010 	// delete any validators used

  1011 	delete iCtorValidator;

  1012 	delete iParseUrlTest12Validator;

  1013 	delete iDtorValidator;

  1014 	

  1015 	return error;

  1016 	}

  1017 

  1018 inline CMailtoSchemeHandler_ParseUrlTest12_UnitTest::~CMailtoSchemeHandler_ParseUrlTest12_UnitTest()

  1019 	{

  1020 	// Simply delete our test class instance

  1021 	delete iUTContext;

  1022 	delete iStateAccessor;

  1023 	// delete any validators used

  1024 	delete iCtorValidator;

  1025 	delete iParseUrlTest12Validator;

  1026 	delete iDtorValidator;

  1027 	}

  1028 

  1029 inline CMailtoSchemeHandler_ParseUrlTest12_UnitTest::CMailtoSchemeHandler_ParseUrlTest12_UnitTest(CDataLogger& aDataLogger,

  1030 																	MUnitTestObserver& aObserver)

  1031 : CUnitTest(KMailtoSchemeHandlerParseUrlTest12UnitTest, aDataLogger, aObserver)

  1032 	{

  1033 	//Do nothing

  1034 	}

  1035 

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

  1037 inline void CMailtoSchemeHandler_ParseUrlTest12_UnitTest::ConstructL()

  1038 	{

  1039 	// Perform the base class initialization

  1040 	UnitTestConstructL();

  1041 

  1042 	// Create the Unit test state accessor

  1043 	iStateAccessor = new(ELeave) TMailtoSchemeHandler_StateAccessor;

  1044 	// Construct the Unit test context.

  1045 	iUTContext = new(ELeave) CMailtoSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

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

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

  1048 	//	Examples of C'tor and D'tor transitions on CMailtoSchemeHandler class.

  1049 	//	using ctor and dtor validators

  1050 

  1051 	//_LIT(KUrl11, "mailto: ? body = body ");

  1052 	_LIT(KUrl12, "mailto: ? body = This is the message body \n It can be long ");

  1053 	iUTContext->iUrl = &KUrl12(); 

  1054 

  1055 	//_LIT(KBody, "body");

  1056 	_LIT(KBody, "This is the message body \n It can be long");

  1057 	iUTContext->iBodyCheck = &KBody(); 	

  1058 

  1059 	iCtorValidator = new(ELeave) TMailtoSchemeHandler_Ctor_TransitionValidator(*iUTContext);

  1060 	iParseUrlTest12Validator = new(ELeave) TMailtoSchemeHandler_ParseUrlTest12_TransitionValidator(*iUTContext);

  1061 	iDtorValidator = new(ELeave) TMailtoSchemeHandler_Dtor_TransitionValidator(*iUTContext);

  1062 

  1063 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_NewL_Transition(*iUTContext,*iCtorValidator));

  1064 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_ParseUrlL_Transition(*iUTContext,*iParseUrlTest12Validator));

  1065 	AddTransitionL(new(ELeave)CMailtoSchemeHandler_Dtor_Transition(*iUTContext,*iDtorValidator));		

  1066 	}

  1067 

  1068 // ______________________________________________________________________________

  1069 //

  1070 _LIT(KMailtoSchemeHandlerParseUrlTest13UnitTest,"CMailtoSchemeHandler_ParseUrlTest13_UnitTest");

  1071 

  1072 CMailtoSchemeHandler_ParseUrlTest13_UnitTest* CMailtoSchemeHandler_ParseUrlTest13_UnitTest::NewL(CDataLogger& aDataLogger,

  1073 											MUnitTestObserver& aObserver)

  1074 	{

  1075 	CMailtoSchemeHandler_ParseUrlTest13_UnitTest* self = 

  1076 					new(ELeave) CMailtoSchemeHandler_ParseUrlTest13_UnitTest(aDataLogger,

  1077 																aObserver);

  1078 	CleanupStack::PushL(self);

  1079 	self->ConstructL();

  1080 	CleanupStack::Pop();

  1081 	return self; 

  1082 	}

  1083 

  1084 inline TInt CMailtoSchemeHandler_ParseUrlTest13_UnitTest::RunError(TInt aError)

  1085 	{

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

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

  1088 	delete iUTContext;

  1089 	delete iStateAccessor;

  1090 	// delete any validators used

  1091 	delete iCtorValidator;

  1092 	delete iParseUrlTest13Validator;

  1093 	delete iDtorValidator;

  1094 

  1095 	return error;

  1096 	}

  1097 

  1098 inline CMailtoSchemeHandler_ParseUrlTest13_UnitTest::~CMailtoSchemeHandler_ParseUrlTest13_UnitTest()

  1099 	{

  1100 	// Simply delete our test class instance

  1101 	delete iUTContext;

  1102 	delete iStateAccessor;

  1103 	// delete any validators used

  1104 	delete iCtorValidator;

  1105 	delete iParseUrlTest13Validator;

  1106 	delete iDtorValidator;

  1107 	 

  1108 	}

  1109 

  1110 inline CMailtoSchemeHandler_ParseUrlTest13_UnitTest::CMailtoSchemeHandler_ParseUrlTest13_UnitTest(CDataLogger& aDataLogger,

  1111 																	MUnitTestObserver& aObserver)

  1112 : CUnitTest(KMailtoSchemeHandlerParseUrlTest13UnitTest, aDataLogger, aObserver)

  1113 	{

  1114 	//Do nothing

  1115 	}

  1116 

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

  1118 inline void CMailtoSchemeHandler_ParseUrlTest13_UnitTest::ConstructL()

  1119 	{

  1120 	// Perform the base class initialization

  1121 	UnitTestConstructL();

  1122 

  1123 	// Create the Unit test state accessor

  1124 	iStateAccessor = new(ELeave) TMailtoSchemeHandler_StateAccessor;

  1125 	// Construct the Unit test context.

  1126 	iUTContext = new(ELeave) CMailtoSchemeHandler_UnitTestContext(iDataLogger, *iStateAccessor, *this);

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

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

  1129 	//	Examples of C'tor and D'tor transitions on CMailtoSchemeHandler class.

  1130 	//	using ctor and dtor validators

  1131 	

  1132 	_LIT(KUrl13, "mailto:?&&&body=silly message&&&&&");

  1133 	iUTContext->iUrl = &KUrl13(); 

  1134