Symaptic: os/ossrv/lowlevellibsandfws/apputils/tsrc/t_strings/StringPoolUnitTest.h@bde4ae8d615e

     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 definitions for the RStringPool class.

    15 //

    16 //

    18 #ifndef __STRINGPOOLUNITTEST_H__

    19 #define __STRINGPOOLUNITTEST_H__

    21 #include <ecom/test_bed/testbeddefinitions.h>

    22 #include "StringPoolStateAccessor.h"

    23 #include "StringPoolTransitionValidation.h"

    24 #include "StringPoolTransitions.h"

    25 #include <stringpool.h>

    28 // ______________________________________________________________________________

    29 //

    30 /**

    31 	@internalComponent

    32 	Comments : Unit Test for CaseInsensitive on StringPool, the class under test.

    33  */

    34 class CStringPool_CaseInsensitive_UnitTest : public CUnitTest

    35 	{

    36 public:

    37 	/**

    38 		@fn				NewL(CDataLogger& aDataLogger,

    39 							MUnitTestObserver& aObserver)

    40 		Intended Usage	: Standard two-phase construction which leaves nothing on the

    41 						cleanup stack.

    42 		Error Condition	: Leaves with the error code.

    43 		@leave		KErrNoMemory

    44 		@since			6.0

    45 		@param			aDataLogger The output logging object.

    46 		@param			aObserver The observer of this UnitTest.

    47 		@return			CStringPool_CaseInsensitive_UnitTest* The constructed object.

    48 		@pre 			None.

    49 		@post			CStringPool_CaseInsensitive_UnitTest is fully constructed, and initialised.

    50 	 */

    51 	static CStringPool_CaseInsensitive_UnitTest* NewL(CDataLogger& aDataLogger,

    52 											MUnitTestObserver& aObserver);

    54 	/**

    55 		@fn				RunError(TInt aError)

    56 		Intended Usage	: Intercept the panic caused by a RunL leave,

    57 						to restore the CStringPool_CaseInsensitive_UnitTest

    58 						object to a sensible state.

    59 						(called by the Active Scheduler immediately before the Panic).

    60 		Error Condition	: @see CUnitTest::RunError().

    61 		@since			6.0

    62 		@return			TInt KErrNone if cleanup successful, otherwise

    63 						@see CUnitTest::RunError()

    64 		@pre 			CStringPool_CaseInsensitive_UnitTest is fully constructed, and initialised.

    65 		@post			The object has been restored to a sensible state.

    66 	 */

    67 	inline TInt RunError(TInt aError);

    69 	/**

    70 		@fn				~CStringPool_CaseInsensitive_UnitTest()

    71 		Intended Usage	: Standard Destructor.

    72 		Error Condition	: None.

    73 		@since			6.0

    74 		@pre 			CStringPool_CaseInsensitive_UnitTest is fully constructed.

    75 		@post			CStringPool_CaseInsensitive_UnitTest is fully destroyed.

    76 	*/

    77 	~CStringPool_CaseInsensitive_UnitTest();

    79 private:

    80 	/**

    81 		@fn				CStringPool_CaseInsensitive_UnitTest(CDataLogger& aDataLogger,

    82 														MUnitTestObserver& aObserver)

    83 		Intended Usage	: Default constructor.

    84 		Error Condition	: None.

    85 		@since			6.0

    86 		@param			aDataLogger The output logging object.

    87 		@param			aObserver The observer of this UnitTest.

    88 		@param			aStateAccessor WhiteBox state access to the StringPool class.

    89 		@pre 			None.

    90 		@post			CStringPool_CaseInsensitive_UnitTest is fully constructed.

    91 	*/

    92 	inline CStringPool_CaseInsensitive_UnitTest(CDataLogger& aDataLogger,

    93 											MUnitTestObserver& aObserver);

    95 	/**

    96 		@fn				void ConstructL()

    97 		Intended Usage	: Second phase of safe two phase construction,

    98 		to complete the object initialisation.

    99 		Error Condition	: Leaves with an error code.

   100 		@leave		KErrNoMemory, and @see CUnitTest::BaseNewL().

   101 		@since			6.0

   102 		@return			None

   103 		@pre 			CStringPool_CaseInsensitive_UnitTest is fully constructed.

   104 		@post			CStringPool_CaseInsensitive_UnitTest is fully initialised.

   105 	*/

   106 	void ConstructL();

   108 	/**

   109 	The context of the Unit Test.

   110 	i.e The StringPool class tested by this UnitTest's transitions.

   111 	 */

   112 	CStringPool_UnitTestContext* iUTContext;

   113 	TStringPool_StateAccessor*	iStateAccessor;

   114 	TStringPool_True_TransitionValidator*	iTrueValidator;

   115 	TStringPool_False_TransitionValidator*	iFalseValidator;

   116 	};	// CStringPool_CaseInsensitive_UnitTest

   118 // ______________________________________________________________________________

   119 //

   120 /**

   121 	@internalComponent

   122 	Comments : Unit Test for SmallTable on StringPool, the class under test.

   123  */

   124 class CStringPool_ShortTable_UnitTest : public CUnitTest

   125 	{

   126 public:

   127 	/**

   128 		@fn				NewL(CDataLogger& aDataLogger,

   129 							MUnitTestObserver& aObserver)

   130 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   131 						cleanup stack.

   132 		Error Condition	: Leaves with the error code.

   133 		@leave		KErrNoMemory

   134 		@since			6.0

   135 		@param			aDataLogger The output logging object.

   136 		@param			aObserver The observer of this UnitTest.

   137 		@return			CStringPool_ShortTable_UnitTest* The constructed object.

   138 		@pre 			None.

   139 		@post			CStringPool_ShortTable_UnitTest is fully constructed, and initialised.

   140 	 */

   141 	static CStringPool_ShortTable_UnitTest* NewL(CDataLogger& aDataLogger,

   142 											MUnitTestObserver& aObserver);

   144 	/**

   145 		@fn				RunError(TInt aError)

   146 		Intended Usage	: Intercept the panic caused by a RunL leave,

   147 						to restore the CStringPool_ShortTable_UnitTest

   148 						object to a sensible state.

   149 						(called by the Active Scheduler immediately before the Panic).

   150 		Error Condition	: @see CUnitTest::RunError().

   151 		@since			6.0

   152 		@return			TInt KErrNone if cleanup successful, otherwise

   153 						@see CUnitTest::RunError()

   154 		@pre 			CStringPool_ShortTable_UnitTest is fully constructed, and initialised.

   155 		@post			The object has been restored to a sensible state.

   156 	 */

   157 	inline TInt RunError(TInt aError);

   159 	/**

   160 		@fn				~CStringPool_ShortTable_UnitTest()

   161 		Intended Usage	: Standard Destructor.

   162 		Error Condition	: None.

   163 		@since			6.0

   164 		@pre 			CStringPool_ShortTable_UnitTest is fully constructed.

   165 		@post			CStringPool_ShortTable_UnitTest is fully destroyed.

   166 	*/

   167 	~CStringPool_ShortTable_UnitTest();

   169 private:

   170 	/**

   171 		@fn				CStringPool_ShortTable_UnitTest(CDataLogger& aDataLogger,

   172 														MUnitTestObserver& aObserver)

   173 		Intended Usage	: Default constructor.

   174 		Error Condition	: None.

   175 		@since			6.0

   176 		@param			aDataLogger The output logging object.

   177 		@param			aObserver The observer of this UnitTest.

   178 		@param			aStateAccessor WhiteBox state access to the StringPool class.

   179 		@pre 			None.

   180 		@post			CStringPool_ShortTable_UnitTest is fully constructed.

   181 	*/

   182 	inline CStringPool_ShortTable_UnitTest(CDataLogger& aDataLogger,

   183 											MUnitTestObserver& aObserver);

   185 	/**

   186 		@fn				void ConstructL()

   187 		Intended Usage	: Second phase of safe two phase construction,

   188 		to complete the object initialisation.

   189 		Error Condition	: Leaves with an error code.

   190 		@leave		KErrNoMemory, and @see CUnitTest::BaseNewL().

   191 		@since			6.0

   192 		@return			None

   193 		@pre 			CStringPool_ShortTable_UnitTest is fully constructed.

   194 		@post			CStringPool_ShortTable_UnitTest is fully initialised.

   195 	*/

   196 	void ConstructL();

   198 	/**

   199 	The context of the Unit Test.

   200 	i.e The StringPool class tested by this UnitTest's transitions.

   201 	 */

   202 	CStringPool_UnitTestContext* iUTContext;

   203 	TStringPool_StateAccessor*	iStateAccessor;

   204 	TStringPool_True_TransitionValidator*	iTrueValidator;

   205 	TStringPool_False_TransitionValidator*	iFalseValidator;

   206 	};	// CStringPool_ShortTable_UnitTest

   211 // ______________________________________________________________________________

   212 //

   213 /**

   214 	@internalComponent

   215 	Comments : Unit Test for IrrelevantTable on StringPool, the class under test.

   216  */

   217 class CStringPool_IrrelevantTable_UnitTest : public CUnitTest

   218 	{

   219 public:

   220 	/**

   221 		@fn				NewL(CDataLogger& aDataLogger,

   222 							MUnitTestObserver& aObserver)

   223 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   224 						cleanup stack.

   225 		Error Condition	: Leaves with the error code.

   226 		@leave		KErrNoMemory

   227 		@since			6.0

   228 		@param			aDataLogger The output logging object.

   229 		@param			aObserver The observer of this UnitTest.

   230 		@return			CStringPool_IrrelevantTable_UnitTest* The constructed object.

   231 		@pre 			None.

   232 		@post			CStringPool_IrrelevantTable_UnitTest is fully constructed, and initialised.

   233 	 */

   234 	static CStringPool_IrrelevantTable_UnitTest* NewL(CDataLogger& aDataLogger,

   235 											MUnitTestObserver& aObserver);

   237 	/**

   238 		@fn				RunError(TInt aError)

   239 		Intended Usage	: Intercept the panic caused by a RunL leave,

   240 						to restore the CStringPool_IrrelevantTable_UnitTest

   241 						object to a sensible state.

   242 						(called by the Active Scheduler immediately before the Panic).

   243 		Error Condition	: @see CUnitTest::RunError().

   244 		@since			6.0

   245 		@return			TInt KErrNone if cleanup successful, otherwise

   246 						@see CUnitTest::RunError()

   247 		@pre 			CStringPool_IrrelevantTable_UnitTest is fully constructed, and initialised.

   248 		@post			The object has been restored to a sensible state.

   249 	 */

   250 	inline TInt RunError(TInt aError);

   252 	/**

   253 		@fn				~CStringPool_IrrelevantTable_UnitTest()

   254 		Intended Usage	: Standard Destructor.

   255 		Error Condition	: None.

   256 		@since			6.0

   257 		@pre 			CStringPool_IrrelevantTable_UnitTest is fully constructed.

   258 		@post			CStringPool_IrrelevantTable_UnitTest is fully destroyed.

   259 	*/

   260 	~CStringPool_IrrelevantTable_UnitTest();

   262 private:

   263 	/**

   264 		@fn				CStringPool_IrrelevantTable_UnitTest(CDataLogger& aDataLogger,

   265 														MUnitTestObserver& aObserver)

   266 		Intended Usage	: Default constructor.

   267 		Error Condition	: None.

   268 		@since			6.0

   269 		@param			aDataLogger The output logging object.

   270 		@param			aObserver The observer of this UnitTest.

   271 		@param			aStateAccessor WhiteBox state access to the StringPool class.

   272 		@pre 			None.

   273 		@post			CStringPool_IrrelevantTable_UnitTest is fully constructed.

   274 	*/

   275 	inline CStringPool_IrrelevantTable_UnitTest(CDataLogger& aDataLogger,

   276 											MUnitTestObserver& aObserver);

   278 	/**

   279 		@fn				void ConstructL()

   280 		Intended Usage	: Second phase of safe two phase construction,

   281 		to complete the object initialisation.

   282 		Error Condition	: Leaves with an error code.

   283 		@leave		KErrNoMemory, and @see CUnitTest::BaseNewL().

   284 		@since			6.0

   285 		@return			None

   286 		@pre 			CStringPool_IrrelevantTable_UnitTest is fully constructed.

   287 		@post			CStringPool_IrrelevantTable_UnitTest is fully initialised.

   288 	*/

   289 	void ConstructL();

   291 	/**

   292 	The context of the Unit Test.

   293 	i.e The StringPool class tested by this UnitTest's transitions.

   294 	 */

   295 	CStringPool_UnitTestContext* iUTContext;

   296 	TStringPool_StateAccessor*	iStateAccessor;

   297 	TStringPool_True_TransitionValidator*	iTrueValidator;

   298 	TStringPool_False_TransitionValidator*	iFalseValidator;

   299 	};	// CStringPool_IrrelevantTable_UnitTest

   302 // ______________________________________________________________________________

   303 //

   304 /**

   305 	@internalComponent

   306 	Comments : Unit Test for LargeTable on StringPool, the class under test.

   307  */

   308 class CStringPool_LongTable_UnitTest : public CUnitTest

   309 	{

   310 public:

   311 	/**

   312 		@fn				NewL(CDataLogger& aDataLogger,

   313 							MUnitTestObserver& aObserver)

   314 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   315 						cleanup stack.

   316 		Error Condition	: Leaves with the error code.

   317 		@leave		KErrNoMemory

   318 		@since			6.0

   319 		@param			aDataLogger The output logging object.

   320 		@param			aObserver The observer of this UnitTest.

   321 		@return			CStringPool_LongTable_UnitTest* The constructed object.

   322 		@pre 			None.

   323 		@post			CStringPool_LongTable_UnitTest is fully constructed, and initialised.

   324 	 */

   325 	static CStringPool_LongTable_UnitTest* NewL(CDataLogger& aDataLogger,

   326 											MUnitTestObserver& aObserver);

   328 	/**

   329 		@fn				RunError(TInt aError)

   330 		Intended Usage	: Intercept the panic caused by a RunL leave,

   331 						to restore the CStringPool_LargeTable_UnitTest

   332 						object to a sensible state.

   333 						(called by the Active Scheduler immediately before the Panic).

   334 		Error Condition	: @see CUnitTest::RunError().

   335 		@since			6.0

   336 		@return			TInt KErrNone if cleanup successful, otherwise

   337 						@see CUnitTest::RunError()

   338 		@pre 			CStringPool_LongTable_UnitTest is fully constructed, and initialised.

   339 		@post			The object has been restored to a sensible state.

   340 	 */

   341 	inline TInt RunError(TInt aError);

   343 	/**

   344 		@fn				~CStringPool_LongTable_UnitTest()

   345 		Intended Usage	: Standard Destructor.

   346 		Error Condition	: None.

   347 		@since			6.0

   348 		@pre 			CStringPool_LongTable_UnitTest is fully constructed.

   349 		@post			CStringPool_LongTable_UnitTest is fully destroyed.

   350 	*/

   351 	~CStringPool_LongTable_UnitTest();

   353 private:

   354 	/**

   355 		@fn				CStringPool_LongTable_UnitTest(CDataLogger& aDataLogger,

   356 														MUnitTestObserver& aObserver)

   357 		Intended Usage	: Default constructor.

   358 		Error Condition	: None.

   359 		@since			6.0

   360 		@param			aDataLogger The output logging object.

   361 		@param			aObserver The observer of this UnitTest.

   362 		@param			aStateAccessor WhiteBox state access to the StringPool class.

   363 		@pre 			None.

   364 		@post			CStringPool_LongTable_UnitTest is fully constructed.

   365 	*/

   366 	inline CStringPool_LongTable_UnitTest(CDataLogger& aDataLogger,

   367 											MUnitTestObserver& aObserver);

   369 	/**

   370 		@fn				void ConstructL()

   371 		Intended Usage	: Second phase of safe two phase construction,

   372 		to complete the object initialisation.

   373 		Error Condition	: Leaves with an error code.

   374 		@leave		KErrNoMemory, and @see CUnitTest::BaseNewL().

   375 		@since			6.0

   376 		@return			None

   377 		@pre 			CStringPool_LongTable_UnitTest is fully constructed.

   378 		@post			CStringPool_LongTable_UnitTest is fully initialised.

   379 	*/

   380 	void ConstructL();

   382 	/**

   383 	The context of the Unit Test.

   384 	i.e The StringPool class tested by this UnitTest's transitions.

   385 	 */

   386 	CStringPool_UnitTestContext* iUTContext;

   387 	TStringPool_StateAccessor*	iStateAccessor;

   388 	TStringPool_True_TransitionValidator*	iTrueValidator;

   389 	TStringPool_False_TransitionValidator*	iFalseValidator;

   390 	};	// CStringPool_LongTable_UnitTest

   392 // ______________________________________________________________________________

   393 //

   394 /**

   395 	@internalComponent

   397 	Comments : Unit Test for CaseSensitive on CStringPool, the class under test.

   398  */

   399 class CStringPool_CaseSensitive_UnitTest : public CUnitTest

   400 	{

   401 public:

   402 	/**

   403 		@fn				NewL(CDataLogger& aDataLogger,

   404 							MUnitTestObserver& aObserver)

   405 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   406 						cleanup stack.

   407 		Error Condition	: Leaves with the error code.

   408 		@leave		KErrNoMemory

   409 		@since			7.0

   410 		@param			aDataLogger The output logging object.

   411 		@param			aObserver The observer of this UnitTest.

   412 		@return			CStringPool_CaseSensitive_UnitTest* The constructed object.

   413 		@pre 			None.

   414 		@post			CStringPool_CaseSensitive_UnitTest is fully constructed, and initialized.

   415 	 */

   416 	static CStringPool_CaseSensitive_UnitTest* NewL(CDataLogger& aDataLogger,

   417 											MUnitTestObserver& aObserver);

   419 	/**

   420 		@fn				RunError(TInt aError)

   421 		Intended Usage	: Intercept the panic caused by a RunL leave,

   422 						to restore the CStringPool_CaseSensitive_UnitTest

   423 						object to a sensible state.

   424 						(called by the Active Scheduler immediately before the Panic).

   425 		Error Condition	: @see CUnitTest::RunError().

   426 		@since			7.0

   427 		@return			KErrNone if cleanup successful, otherwise

   428 						@see CUnitTest::RunError()

   429 		@pre 			CStringPool_CaseSensitive_UnitTest is fully constructed, and initialized.

   430 		@post			The object has been restored to a sensible state.

   431 	 */

   432 	inline TInt RunError(TInt aError);

   434 	/**

   435 		@fn				~CStringPool_CaseSensitive_UnitTest()

   436 		Intended Usage	: Standard Destructor.

   437 		Error Condition	: None.

   438 		@since			7.0

   439 		@pre 			CStringPool_CaseSensitive_UnitTest is fully constructed.

   440 		@post			CStringPool_CaseSensitive_UnitTest is fully destroyed.

   441 	*/

   442 	~CStringPool_CaseSensitive_UnitTest();

   444 private:

   445 	/**

   446 		@fn				CStringPool_CaseSensitive_UnitTest(CDataLogger& aDataLogger,

   447 														MUnitTestObserver& aObserver)

   448 		Intended Usage	: Default constructor.

   449 		Error Condition	: None.

   450 		@since			7.0

   451 		@param			aDataLogger The output logging object.

   452 		@param			aObserver The observer of this UnitTest.

   453 		@param			aStateAccessor WhiteBox state access to the CStringPool class.

   454 		@pre 			None.

   455 		@post			CStringPool_CaseSensitive_UnitTest is fully constructed.

   456 	*/

   457 	inline CStringPool_CaseSensitive_UnitTest(CDataLogger& aDataLogger,

   458 											MUnitTestObserver& aObserver);

   460 	/**

   461 		@fn				void ConstructL()

   462 		Intended Usage	: Second phase of safe two phase construction,

   463 		to complete the object initialisation.

   464 		Error Condition	: Leaves with an error code.

   465 		@leave		KErrNoMemory, and @see CUnitTest::BaseNewL().

   466 		@since			7.0

   467 		@return			None

   468 		@pre 			CStringPool_CaseSensitive_UnitTest is fully constructed.

   469 		@post			CStringPool_CaseSensitive_UnitTest is fully initialized.

   470 	*/

   471 	void ConstructL();

   473 	/**

   474 	The context of the Unit Test.

   475 	i.e The CStringPool class tested by this UnitTest's transitions.

   476 	 */

   477 	CStringPool_UnitTestContext* iUTContext;

   478 	TStringPool_StateAccessor*	iStateAccessor;

   479 	TStringPool_True_TransitionValidator*	iTrueValidator;

   480 	TStringPool_False_TransitionValidator*	iFalseValidator;

   481 	};	// CStringPool_CaseSensitive_UnitTest

   483 // ______________________________________________________________________________

   484 //

   485 /**

   486 	@internalAll

   488 	Comments : Unit Test for SmallTableCS on CStringPool, the class under test.

   489  */

   490 class CStringPool_ShortTableCS_UnitTest : public CUnitTest

   491 	{

   492 public:

   493 	/**

   494 		@fn				NewL(CDataLogger& aDataLogger,

   495 							MUnitTestObserver& aObserver)

   496 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   497 						cleanup stack.

   498 		Error Condition	: Leaves with the error code.

   499 		@leave		KErrNoMemory

   500 		@since			7.0

   501 		@param			aDataLogger The output logging object.

   502 		@param			aObserver The observer of this UnitTest.

   503 		@return			CStringPool_ShortTableCS_UnitTest* The constructed object.

   504 		@pre 			None.

   505 		@post			CStringPool_ShortTableCS_UnitTest is fully constructed, and initialized.

   506 	 */

   507 	static CStringPool_ShortTableCS_UnitTest* NewL(CDataLogger& aDataLogger,

   508 											MUnitTestObserver& aObserver);

   510 	/**

   511 		@fn				RunError(TInt aError)

   512 		Intended Usage	: Intercept the panic caused by a RunL leave,

   513 						to restore the CStringPool_ShortTableCS_UnitTest

   514 						object to a sensible state.

   515 						(called by the Active Scheduler immediately before the Panic).

   516 		Error Condition	: @see CUnitTest::RunError().

   517 		@since			7.0

   518 		@return			KErrNone if cleanup successful, otherwise

   519 						@see CUnitTest::RunError()

   520 		@pre 			CStringPool_ShortTableCS_UnitTest is fully constructed, and initialized.

   521 		@post			The object has been restored to a sensible state.

   522 	 */

   523 	inline TInt RunError(TInt aError);

   525 	/**

   526 		@fn				~CStringPool_ShortTableCS_UnitTest()

   527 		Intended Usage	: Standard Destructor.

   528 		Error Condition	: None.

   529 		@since			7.0

   530 		@pre 			CStringPool_ShortTableCS_UnitTest is fully constructed.

   531 		@post			CStringPool_ShortTableCS_UnitTest is fully destroyed.

   532 	*/

   533 	~CStringPool_ShortTableCS_UnitTest();

   535 private:

   536 	/**

   537 		@fn				CStringPool_ShortTableCS_UnitTest(CDataLogger& aDataLogger,

   538 														MUnitTestObserver& aObserver)

   539 		Intended Usage	: Default constructor.

   540 		Error Condition	: None.

   541 		@since			7.0

   542 		@param			aDataLogger The output logging object.

   543 		@param			aObserver The observer of this UnitTest.

   544 		@param			aStateAccessor WhiteBox state access to the CStringPool class.

   545 		@pre 			None.

   546 		@post			CStringPool_ShortTableCS_UnitTest is fully constructed.

   547 	*/

   548 	inline CStringPool_ShortTableCS_UnitTest(CDataLogger& aDataLogger,

   549 											MUnitTestObserver& aObserver);

   551 	/**

   552 		@fn				void ConstructL()

   553 		Intended Usage	: Second phase of safe two phase construction,

   554 		to complete the object initialisation.

   555 		Error Condition	: Leaves with an error code.

   556 		@leave		KErrNoMemory, and @see CUnitTest::BaseNewL().

   557 		@since			7.0

   558 		@return			None

   559 		@pre 			CStringPool_ShortTableCS_UnitTest is fully constructed.

   560 		@post			CStringPool_ShortTableCS_UnitTest is fully initialized.

   561 	*/

   562 	void ConstructL();

   564 	/**

   565 	The context of the Unit Test.

   566 	i.e The CStringPool class tested by this UnitTest's transitions.

   567 	 */

   568 	CStringPool_UnitTestContext* iUTContext;

   569 	TStringPool_StateAccessor*	iStateAccessor;

   570 	TStringPool_True_TransitionValidator*	iTrueValidator;

   571 	TStringPool_False_TransitionValidator*	iFalseValidator;

   572 	};	// CStringPool_ShortTableCS_UnitTest

   574 // ______________________________________________________________________________

   575 //

   576 /**

   577 	@internalAll

   579 	Comments : Unit Test for IrrelevantTableCS on CStringPool, the class under test.

   580  */

   581 class CStringPool_IrrelevantTableCS_UnitTest : public CUnitTest

   582 	{

   583 public:

   584 	/**

   585 		@fn				NewL(CDataLogger& aDataLogger,

   586 							MUnitTestObserver& aObserver)

   587 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   588 						cleanup stack.

   589 		Error Condition	: Leaves with the error code.

   590 		@leave		KErrNoMemory

   591 		@since			7.0

   592 		@param			aDataLogger The output logging object.

   593 		@param			aObserver The observer of this UnitTest.

   594 		@return			CStringPool_IrrelevantTableCS_UnitTest* The constructed object.

   595 		@pre 			None.

   596 		@post			CStringPool_IrrelevantTableCS_UnitTest is fully constructed, and initialized.

   597 	 */

   598 	static CStringPool_IrrelevantTableCS_UnitTest* NewL(CDataLogger& aDataLogger,

   599 											MUnitTestObserver& aObserver);

   601 	/**

   602 		@fn				RunError(TInt aError)

   603 		Intended Usage	: Intercept the panic caused by a RunL leave,

   604 						to restore the CStringPool_IrrelevantTableCS_UnitTest

   605 						object to a sensible state.

   606 						(called by the Active Scheduler immediately before the Panic).

   607 		Error Condition	: @see CUnitTest::RunError().

   608 		@since			7.0

   609 		@return			KErrNone if cleanup successful, otherwise

   610 						@see CUnitTest::RunError()

   611 		@pre 			CStringPool_IrrelevantTableCS_UnitTest is fully constructed, and initialized.

   612 		@post			The object has been restored to a sensible state.

   613 	 */

   614 	inline TInt RunError(TInt aError);

   616 	/**

   617 		@fn				~CStringPool_IrrelevantTableCS_UnitTest()

   618 		Intended Usage	: Standard Destructor.

   619 		Error Condition	: None.

   620 		@since			7.0

   621 		@pre 			CStringPool_IrrelevantTableCS_UnitTest is fully constructed.

   622 		@post			CStringPool_IrrelevantTableCS_UnitTest is fully destroyed.

   623 	*/

   624 	~CStringPool_IrrelevantTableCS_UnitTest();

   626 private:

   627 	/**

   628 		@fn				CStringPool_IrrelevantTableCS_UnitTest(CDataLogger& aDataLogger,

   629 														MUnitTestObserver& aObserver)

   630 		Intended Usage	: Default constructor.

   631 		Error Condition	: None.

   632 		@since			7.0

   633 		@param			aDataLogger The output logging object.

   634 		@param			aObserver The observer of this UnitTest.

   635 		@param			aStateAccessor WhiteBox state access to the CStringPool class.

   636 		@pre 			None.

   637 		@post			CStringPool_IrrelevantTableCS_UnitTest is fully constructed.

   638 	*/

   639 	inline CStringPool_IrrelevantTableCS_UnitTest(CDataLogger& aDataLogger,

   640 											MUnitTestObserver& aObserver);

   642 	/**

   643 		@fn				void ConstructL()

   644 		Intended Usage	: Second phase of safe two phase construction,

   645 		to complete the object initialisation.

   646 		Error Condition	: Leaves with an error code.

   647 		@leave		KErrNoMemory, and @see CUnitTest::BaseNewL().

   648 		@since			7.0

   649 		@return			None

   650 		@pre 			CStringPool_IrrelevantTableCS_UnitTest is fully constructed.

   651 		@post			CStringPool_IrrelevantTableCS_UnitTest is fully initialized.

   652 	*/

   653 	void ConstructL();

   655 	CStringPool_UnitTestContext* iUTContext;

   656 	TStringPool_StateAccessor*	iStateAccessor;

   657 	TStringPool_True_TransitionValidator*	iTrueValidator;

   658 	TStringPool_False_TransitionValidator*	iFalseValidator;

   659 	};	// CStringPool_IrrelevantTableCS_UnitTest

   661 // ______________________________________________________________________________

   662 //

   663 /**

   664 	@internalAll

   666 	Comments : Unit Test for LargeCS on CStringPool, the class under test.

   667  */

   668 class CStringPool_LongTableCS_UnitTest : public CUnitTest

   669 	{

   670 public:

   671 	/**

   672 		@fn				NewL(CDataLogger& aDataLogger,

   673 							MUnitTestObserver& aObserver)

   674 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   675 						cleanup stack.

   676 		Error Condition	: Leaves with the error code.

   677 		@leave		KErrNoMemory

   678 		@since			7.0

   679 		@param			aDataLogger The output logging object.

   680 		@param			aObserver The observer of this UnitTest.

   681 		@return			CStringPool_LongTableCS_UnitTest* The constructed object.

   682 		@pre 			None.

   683 		@post			CStringPool_LongTableCS_UnitTest is fully constructed, and initialized.

   684 	 */

   685 	static CStringPool_LongTableCS_UnitTest* NewL(CDataLogger& aDataLogger,

   686 											MUnitTestObserver& aObserver);

   688 	/**

   689 		@fn				RunError(TInt aError)

   690 		Intended Usage	: Intercept the panic caused by a RunL leave,

   691 						to restore the CStringPool_LongTableCS_UnitTest

   692 						object to a sensible state.

   693 						(called by the Active Scheduler immediately before the Panic).

   694 		Error Condition	: @see CUnitTest::RunError().

   695 		@since			7.0

   696 		@return			KErrNone if cleanup successful, otherwise

   697 						@see CUnitTest::RunError()

   698 		@pre 			CStringPool_LongTableCS_UnitTest is fully constructed, and initialized.

   699 		@post			The object has been restored to a sensible state.

   700 	 */

   701 	inline TInt RunError(TInt aError);

   703 	/**

   704 		@fn				~CStringPool_LongTableCS_UnitTest()

   705 		Intended Usage	: Standard Destructor.

   706 		Error Condition	: None.

   707 		@since			7.0

   708 		@pre 			CStringPool_LongTableCS_UnitTest is fully constructed.

   709 		@post			CStringPool_LongTableCS_UnitTest is fully destroyed.

   710 	*/

   711 	~CStringPool_LongTableCS_UnitTest();

   713 private:

   714 	/**

   715 		@fn				CStringPool_LongTableCS_UnitTest(CDataLogger& aDataLogger,

   716 														MUnitTestObserver& aObserver)

   717 		Intended Usage	: Default constructor.

   718 		Error Condition	: None.

   719 		@since			7.0

   720 		@param			aDataLogger The output logging object.

   721 		@param			aObserver The observer of this UnitTest.

   722 		@param			aStateAccessor WhiteBox state access to the CStringPool class.

   723 		@pre 			None.

   724 		@post			CStringPool_LongTableCS_UnitTest is fully constructed.

   725 	*/

   726 	inline CStringPool_LongTableCS_UnitTest(CDataLogger& aDataLogger,

   727 											MUnitTestObserver& aObserver);

   729 	/**

   730 		@fn				void ConstructL()

   731 		Intended Usage	: Second phase of safe two phase construction,

   732 		to complete the object initialisation.

   733 		Error Condition	: Leaves with an error code.

   734 		@leave		KErrNoMemory, and @see CUnitTest::BaseNewL().

   735 		@since			7.0

   736 		@return			None

   737 		@pre 			CStringPool_LongTableCS_UnitTest is fully constructed.

   738 		@post			CStringPool_LongTableCS_UnitTest is fully initialized.

   739 	*/

   740 	void ConstructL();

   742 	/**

   743 	The context of the Unit Test.

   744 	i.e The CStringPool class tested by this UnitTest's transitions.

   745 	 */

   746 	CStringPool_UnitTestContext* iUTContext;

   747 	TStringPool_StateAccessor*	iStateAccessor;

   748 	TStringPool_True_TransitionValidator*	iTrueValidator;

   749 	TStringPool_False_TransitionValidator*	iFalseValidator;

   750 	};	// CStringPool_LongTableCS_UnitTest

   752 // ______________________________________________________________________________

   753 //

   754 /**

   755 	@internalAll

   757 	Comments : Unit Test for MultipleTableShortCI on RStringPool, the class under test.

   758  */

   759 class CStringPool_MultipleTableShortCI_UnitTest : public CUnitTest

   760 	{

   761 public:

   762 	/**

   763 		@fn				NewL(CDataLogger& aDataLogger,

   764 							MUnitTestObserver& aObserver)

   765 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   766 						cleanup stack.

   767 		Error Condition	: Leaves with the error code.

   768 		@leave		KErrNoMemory

   769 		@since			7.0

   770 		@param			aDataLogger The output logging object.

   771 		@param			aObserver The observer of this UnitTest.

   772 		@return			CStringPool_MultipleTableShortCI_UnitTest* The constructed object.

   773 		@pre 			None.

   774 		@post			CStringPool_MultipleTableShortCI_UnitTest is fully constructed, and initialized.

   775 	 */

   776 	static CStringPool_MultipleTableShortCI_UnitTest* NewL(CDataLogger& aDataLogger,

   777 											MUnitTestObserver& aObserver);

   779 	/**

   780 		@fn				RunError(TInt aError)

   781 		Intended Usage	: Intercept the panic caused by a RunL leave,

   782 						to restore the CStringPool_MultipleTableShortCI_UnitTest

   783 						object to a sensible state.

   784 						(called by the Active Scheduler immediately before the Panic).

   785 		Error Condition	: @see CUnitTest::RunError().

   786 		@since			7.0

   787 		@return			KErrNone if cleanup successful, otherwise

   788 						@see CUnitTest::RunError()

   789 		@pre 			CStringPool_MultipleTableShortCI_UnitTest is fully constructed, and initialized.

   790 		@post			The object has been restored to a sensible state.

   791 	 */

   792 	inline TInt RunError(TInt aError);

   794 	/**

   795 		@fn				~CStringPool_MultipleTableShortCI_UnitTest()

   796 		Intended Usage	: Standard Destructor.

   797 		Error Condition	: None.

   798 		@since			7.0

   799 		@pre 			CStringPool_MultipleTableShortCI_UnitTest is fully constructed.

   800 		@post			CStringPool_MultipleTableShortCI_UnitTest is fully destroyed.

   801 	*/

   802 	~CStringPool_MultipleTableShortCI_UnitTest();

   804 private:

   805 	/**

   806 		@fn				CStringPool_MultipleTableShortCI_UnitTest(CDataLogger& aDataLogger,

   807 														MUnitTestObserver& aObserver)

   808 		Intended Usage	: Default constructor.

   809 		Error Condition	: None.

   810 		@since			7.0

   811 		@param			aDataLogger The output logging object.

   812 		@param			aObserver The observer of this UnitTest.

   813 		@param			aStateAccessor WhiteBox state access to the RStringPool class.

   814 		@pre 			None.

   815 		@post			CStringPool_MultipleTableShortCI_UnitTest is fully constructed.

   816 	*/

   817 	inline CStringPool_MultipleTableShortCI_UnitTest(CDataLogger& aDataLogger,

   818 											MUnitTestObserver& aObserver);

   820 	/**

   821 		@fn				void ConstructL()

   822 		Intended Usage	: Second phase of safe two phase construction,

   823 		to complete the object initialisation.

   824 		Error Condition	: Leaves with an error code.

   825 		@leave		KErrNoMemory, and @see CUnitTest::BaseNewL().

   826 		@since			7.0

   827 		@return			None

   828 		@pre 			CStringPool_MultipleTableShortCI_UnitTest is fully constructed.

   829 		@post			CStringPool_MultipleTableShortCI_UnitTest is fully initialized.

   830 	*/

   831 	void ConstructL();

   833 	/**

   834 	The context of the Unit Test.

   835 	i.e The RStringPool class tested by this UnitTest's transitions.

   836 	 */

   837 	CStringPool_UnitTestContext* iUTContext;

   838 	TStringPool_StateAccessor*	iStateAccessor;

   839 	TStringPool_True_TransitionValidator*	iTrueValidator;

   840 	TStringPool_False_TransitionValidator*	iFalseValidator;

   841 	};	// CStringPool_MultipleTableShortCI_UnitTest

   844 // ______________________________________________________________________________

   845 //

   846 /**

   847 	@internalAll

   849 	Comments : Unit Test for MultipleTableShortCS on RStringPool, the class under test.

   850  */

   851 class CStringPool_MultipleTableShortCS_UnitTest : public CUnitTest

   852 	{

   853 public:

   854 	/**

   855 		@fn				NewL(CDataLogger& aDataLogger,

   856 							MUnitTestObserver& aObserver)

   857 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   858 						cleanup stack.

   859 		Error Condition	: Leaves with the error code.

   860 		@leave		KErrNoMemory

   861 		@since			7.0

   862 		@param			aDataLogger The output logging object.

   863 		@param			aObserver The observer of this UnitTest.

   864 		@return			CStringPool_MultipleTableShortCS_UnitTest* The constructed object.

   865 		@pre 			None.

   866 		@post			CStringPool_MultipleTableShortCS_UnitTest is fully constructed, and initialized.

   867 	 */

   868 	static CStringPool_MultipleTableShortCS_UnitTest* NewL(CDataLogger& aDataLogger,

   869 											MUnitTestObserver& aObserver);

   871 	/**

   872 		@fn				RunError(TInt aError)

   873 		Intended Usage	: Intercept the panic caused by a RunL leave,

   874 						to restore the CStringPool_MultipleTableShortCS_UnitTest

   875 						object to a sensible state.

   876 						(called by the Active Scheduler immediately before the Panic).

   877 		Error Condition	: @see CUnitTest::RunError().

   878 		@since			7.0

   879 		@return			KErrNone if cleanup successful, otherwise

   880 						@see CUnitTest::RunError()

   881 		@pre 			CStringPool_MultipleTableShortCS_UnitTest is fully constructed, and initialized.

   882 		@post			The object has been restored to a sensible state.

   883 	 */

   884 	inline TInt RunError(TInt aError);

   886 	/**

   887 		@fn				~CStringPool_MultipleTableShortCS_UnitTest()

   888 		Intended Usage	: Standard Destructor.

   889 		Error Condition	: None.

   890 		@since			7.0

   891 		@pre 			CStringPool_MultipleTableShortCS_UnitTest is fully constructed.

   892 		@post			CStringPool_MultipleTableShortCS_UnitTest is fully destroyed.

   893 	*/

   894 	~CStringPool_MultipleTableShortCS_UnitTest();

   896 private:

   897 	/**

   898 		@fn				CStringPool_MultipleTableShortCS_UnitTest(CDataLogger& aDataLogger,

   899 														MUnitTestObserver& aObserver)

   900 		Intended Usage	: Default constructor.

   901 		Error Condition	: None.

   902 		@since			7.0

   903 		@param			aDataLogger The output logging object.

   904 		@param			aObserver The observer of this UnitTest.

   905 		@param			aStateAccessor WhiteBox state access to the RStringPool class.

   906 		@pre 			None.

   907 		@post			CStringPool_MultipleTableShortCS_UnitTest is fully constructed.

   908 	*/

   909 	inline CStringPool_MultipleTableShortCS_UnitTest(CDataLogger& aDataLogger,

   910 											MUnitTestObserver& aObserver);

   912 	/**

   913 		@fn				void ConstructL()

   914 		Intended Usage	: Second phase of safe two phase construction,

   915 		to complete the object initialisation.

   916 		Error Condition	: Leaves with an error code.

   917 		@leave		KErrNoMemory, and @see CUnitTest::BaseNewL().

   918 		@since			7.0

   919 		@return			None

   920 		@pre 			CStringPool_MultipleTableShortCS_UnitTest is fully constructed.

   921 		@post			CStringPool_MultipleTableShortCS_UnitTest is fully initialized.

   922 	*/

   923 	void ConstructL();

   925 	/**

   926 	The context of the Unit Test.

   927 	i.e The RStringPool class tested by this UnitTest's transitions.

   928 	 */

   929 	CStringPool_UnitTestContext* iUTContext;

   930 	TStringPool_StateAccessor*	iStateAccessor;

   931 	TStringPool_True_TransitionValidator*	iTrueValidator;

   932 	TStringPool_False_TransitionValidator*	iFalseValidator;

   933 	};	// CStringPool_MultipleTableShortCS_UnitTest

   936 #endif	// __STRINGPOOLUNITTEST_H__

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--