1 // Copyright (c) 2007-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 // Name        : tzlibserver.cpp

    15 // 

    16 //

    17 

    18 

    19 #include <c32comm.h>

    20 

    21 #if defined (__WINS__)

    22 #define PDD_NAME		_L("ECDRV")

    23 #else

    24 #define PDD_NAME		_L("EUART1")

    25 #define PDD2_NAME		_L("EUART2")

    26 #define PDD3_NAME		_L("EUART3")

    27 #define PDD4_NAME		_L("EUART4")

    28 #endif

    29 

    30 #define LDD_NAME		_L("ECOMM")

    31 

    32 /**

    33  * @file

    34  *

    35  * Pipe test server implementation

    36  */

    37 #include "tzlibserver.h"

    38 #include "tzlib.h"

    39 

    40 

    41 _LIT(KServerName, "tzlib");

    42 

    43 CZlibTestServer* CZlibTestServer::NewL()

    44 	{

    45 	CZlibTestServer *server = new(ELeave) CZlibTestServer();

    46 	CleanupStack::PushL(server);

    47 	server->ConstructL(KServerName);

    48 	CleanupStack::Pop(server);

    49 	return server;

    50 	}

    51 

    52 static void InitCommsL()

    53     {

    54     TInt ret = User::LoadPhysicalDevice(PDD_NAME);

    55     User::LeaveIfError(ret == KErrAlreadyExists?KErrNone:ret);

    56 

    57 #ifndef __WINS__

    58     ret = User::LoadPhysicalDevice(PDD2_NAME);

    59     ret = User::LoadPhysicalDevice(PDD3_NAME);

    60     ret = User::LoadPhysicalDevice(PDD4_NAME);

    61 #endif

    62 

    63     ret = User::LoadLogicalDevice(LDD_NAME);

    64     User::LeaveIfError(ret == KErrAlreadyExists?KErrNone:ret);

    65     ret = StartC32();

    66     User::LeaveIfError(ret == KErrAlreadyExists?KErrNone:ret);

    67     }

    68 

    69 LOCAL_C void MainL()

    70 	{

    71 	// Leave the hooks in for platform security

    72 #if (defined __DATA_CAGING__)

    73 	RProcess().DataCaging(RProcess::EDataCagingOn);

    74 	RProcess().SecureApi(RProcess::ESecureApiOn);

    75 #endif

    76 	InitCommsL();

    77 	

    78 	CActiveScheduler* sched=NULL;

    79 	sched=new(ELeave) CActiveScheduler;

    80 	CActiveScheduler::Install(sched);

    81 	CZlibTestServer* server = NULL;

    82 	// Create the CTestServer derived server

    83 	TRAPD(err, server = CZlibTestServer::NewL());

    84 	if(!err)

    85 		{

    86 		// Sync with the client and enter the active scheduler

    87 		RProcess::Rendezvous(KErrNone);

    88 		sched->Start();

    89 		}

    90 	delete server;

    91 	delete sched;

    92 	}

    93 

    94 /**

    95  * Server entry point

    96  * @return Standard Epoc error code on exit

    97  */

    98 TInt main()

    99 	{

   100 	__UHEAP_MARK;

   101 	CTrapCleanup* cleanup = CTrapCleanup::New();

   102 	if(cleanup == NULL) 

   103 		{

   104 		return KErrNoMemory;  

   105 		}

   106 	TRAP_IGNORE(MainL());

   107 	delete cleanup;

   108 	__UHEAP_MARKEND;

   109 	

   110 	return KErrNone;

   111 	}

   112 

   113 CTestStep* CZlibTestServer::CreateTestStep(const TDesC& aStepName)

   114 	{

   115 	CTestStep* testStep = NULL;

   116 

   117 	// This server creates just one step but create as many as you want

   118 	// They are created "just in time" when the worker thread is created

   119 	// install steps

   120 	

   121 	if(aStepName == Ktest_zlibVersion)

   122 		{

   123 		testStep = new CTestZlib(aStepName);

   124 		}

   125 	else if(aStepName == Ktest_compress01)

   126 		{

   127 		testStep = new CTestZlib(aStepName);

   128 		}

   129 	else if(aStepName == Ktest_deflate01)

   130 		{

   131 		testStep = new CTestZlib(aStepName);

   132 		}

   133 	else if(aStepName == Ktest_deflate02)

   134 		{

   135 		testStep = new CTestZlib(aStepName);

   136 		}

   137 	else if(aStepName == Ktest_deflateEnd)

   138 		{

   139 		testStep = new CTestZlib(aStepName);

   140 		}

   141 	else if(aStepName == Ktest_inflate01)

   142 		{

   143 		testStep = new CTestZlib(aStepName);

   144 		}

   145 	else if(aStepName == Ktest_inflate02)

   146 		{

   147 		testStep = new CTestZlib(aStepName);

   148 		}

   149 	else if(aStepName == Ktest_inflate03)

   150 		{

   151 		testStep = new CTestZlib(aStepName);

   152 		}

   153 	else if(aStepName == Ktest_inflate04)

   154 		{

   155 		testStep = new CTestZlib(aStepName);

   156 		}

   157 	else if(aStepName == Ktest_inflate05)

   158 		{

   159 		testStep = new CTestZlib(aStepName);

   160 		}

   161 	else if(aStepName == Ktest_inflate06)

   162 		{

   163 		testStep = new CTestZlib(aStepName);

   164 		}

   165 	else if(aStepName == Ktest_inflateEnd)

   166 		{

   167 		testStep = new CTestZlib(aStepName);

   168 		}

   169 	else if(aStepName == Ktest_deflateSetDictionary01)

   170 		{

   171 		testStep = new CTestZlib(aStepName);

   172 		}

   173 	else if(aStepName == Ktest_deflateSetDictionary02)

   174 		{

   175 		testStep = new CTestZlib(aStepName);

   176 		}

   177 	else if(aStepName == Ktest_deflateSetDictionary03)

   178 		{

   179 		testStep = new CTestZlib(aStepName);

   180 		}

   181 	else if(aStepName == Ktest_deflateSetDictionary04)

   182 		{

   183 		testStep = new CTestZlib(aStepName);

   184 		}

   185 	else if(aStepName == Ktest_deflateSetDictionary05)

   186 		{

   187 		testStep = new CTestZlib(aStepName);

   188 		}

   189 	else if(aStepName == Ktest_gzio)

   190 		{

   191 		testStep = new CTestZlib(aStepName);

   192 		}

   193 	else if(aStepName == Ktest_gzdirect)

   194 		{

   195 		testStep = new CTestZlib(aStepName);

   196 		}	

   197 	else if(aStepName == Ktest_gzdirectnull)

   198 		{

   199 		testStep = new CTestZlib(aStepName);

   200 		}	

   201 	else if(aStepName == Ktest_gzclearerr)

   202 		{

   203 		testStep = new CTestZlib(aStepName);

   204 		}	

   205 	else if(aStepName == Ktest_gzclearerr_null)

   206 		{

   207 		testStep = new CTestZlib(aStepName);

   208 		}	

   209 	else if(aStepName == Ktest_gzerror_streamend)

   210 		{

   211 		testStep = new CTestZlib(aStepName);

   212 		}	

   213 	else if(aStepName == Ktest_gzungetcnegative)

   214 		{

   215 		testStep = new CTestZlib(aStepName);

   216 		}

   217 	else if(aStepName == Ktest_gzseeknegative)

   218 		{

   219 		testStep = new CTestZlib(aStepName);

   220 		}

   221 	else if(aStepName == Ktest_gzdirecttxt)

   222 		{

   223 		testStep = new CTestZlib(aStepName);

   224 		}

   225 	else if(aStepName == KtestGzungetcChain)

   226 		{

   227 		testStep = new CTestZlib(aStepName);

   228 		}

   229 	else if(aStepName == KtestGzseekBack)

   230 		{

   231 		testStep = new CTestZlib(aStepName);

   232 		}

   233 	else if(aStepName == KtestGzseekAppend)

   234 		{

   235 		testStep = new CTestZlib(aStepName);

   236 		}

   237 	else if(aStepName == KtestGzseekHugeOffset)

   238 		{

   239 		testStep = new CTestZlib(aStepName);

   240 		}

   241 	else if(aStepName == KtestGzseekNoSize)

   242 		{

   243 		testStep = new CTestZlib(aStepName);

   244 		}

   245 	else if(aStepName == KtestGzopenLongPath01)

   246 		{

   247 		testStep = new CTestZlib(aStepName);

   248 		}	

   249 	else if(aStepName == KtestGzseekLongPath01)

   250 		{

   251 		testStep = new CTestZlib(aStepName);

   252 		}		

   253 	else if(aStepName == KtestGzopenLongPath02)

   254 		{

   255 		testStep = new CTestZlib(aStepName);

   256 		}

   257 	else if(aStepName == KtestGzseekMixedFile01)

   258 		{

   259 		testStep = new CTestZlib(aStepName);

   260 		}

   261 	else if(aStepName == KtestGzopenNoMode)

   262 		{

   263 		testStep = new CTestZlib(aStepName);

   264 		}

   265 	else if(aStepName == KtestGzopenNoPath)

   266 		{

   267 		testStep = new CTestZlib(aStepName);

   268 		}

   269 	else if(aStepName == KtestGzopenNoPathMode)

   270 		{

   271 		testStep = new CTestZlib(aStepName);

   272 		}

   273 	else if(aStepName == KtestGzseekConcatedFile01)

   274 		{

   275 		testStep = new CTestZlib(aStepName);

   276 		}	

   277 	else if(aStepName == KtestGzopenDiffMode)

   278 		{

   279 		testStep = new CTestZlib(aStepName);

   280 		}	

   281 	else if(aStepName == KtestGzseekConcatedFile02)

   282 		{

   283 		testStep = new CTestZlib(aStepName);

   284 		}

   285 	else if(aStepName == KtestGzprintf01)

   286 		{

   287 		testStep = new CTestZlib(aStepName);

   288 		}

   289 	else if(aStepName == KtestGzprintf02)

   290 		{

   291 		testStep = new CTestZlib(aStepName);

   292 		}

   293 	else if(aStepName == KtestGzflushNull)

   294 		{

   295 		testStep = new CTestZlib(aStepName);

   296 		}

   297 	else if(aStepName == KtestGzflushRepeat)

   298 		{

   299 		testStep = new CTestZlib(aStepName);

   300 		}

   301 	else if(aStepName == KtestGzflushHugeBuf)

   302 		{

   303 		testStep = new CTestZlib(aStepName);

   304 		}

   305 	else if(aStepName == KtestGzrewindNull)

   306 		{

   307 		testStep = new CTestZlib(aStepName);

   308 		}

   309 	else if(aStepName == KtestGzrewindTransparent)

   310 		{

   311 		testStep = new CTestZlib(aStepName);

   312 		}

   313 	else if(aStepName == KtestGzgetsBufNull)

   314 		{

   315 		testStep = new CTestZlib(aStepName);

   316 		}

   317 	else if(aStepName == KtestGzgetsSmallBuf)

   318 		{

   319 		testStep = new CTestZlib(aStepName);

   320 		}

   321 	

   322 	else if(aStepName == KtestDeflateReset)

   323 		{

   324 		testStep = new CTestZlib(aStepName);

   325 		}

   326 	else if(aStepName == KtestDeflateReset_fail)

   327 		{

   328 		testStep = new CTestZlib(aStepName);

   329 		}

   330 	else if(aStepName == KtestDeflateInit2_bits)

   331 		{

   332 		testStep = new CTestZlib(aStepName);

   333 		}

   334 	else if(aStepName == KtestDeflateInit2_level)

   335 		{

   336 		testStep = new CTestZlib(aStepName);

   337 		}

   338 	else if(aStepName == KtestInflateInit2_bits)

   339 		{

   340 		testStep = new CTestZlib(aStepName);

   341 		}

   342 	else if(aStepName == KtestGzread)

   343 		{

   344 		testStep = new CTestZlib(aStepName);

   345 		}

   346 	else if(aStepName == KtestGzread_fail)

   347 		{

   348 		testStep = new CTestZlib(aStepName);

   349 		}

   350 	else if(aStepName == KtestUncompress)

   351 		{

   352 		testStep = new CTestZlib(aStepName);

   353 		}

   354 	else if(aStepName == KtestUncompressfail)

   355 		{

   356 		testStep = new CTestZlib(aStepName);

   357 		}

   358 	else if(aStepName == KtestInflateSetDictionary)

   359 		{

   360 		testStep = new CTestZlib(aStepName);

   361 		}

   362 	else if(aStepName == KtestInflateSetDictionary_size)

   363 		{

   364 		testStep = new CTestZlib(aStepName);

   365 		}

   366 	else if(aStepName == KtestInflateSetDictionary_null)

   367 		{

   368 		testStep = new CTestZlib(aStepName);

   369 		}

   370 	else if(aStepName == KtestGzgets)

   371 		{

   372 		testStep = new CTestZlib(aStepName);

   373 		}	

   374 	else if(aStepName == KtestgzgetsFail)

   375 		{

   376 		testStep = new CTestZlib(aStepName);

   377 		}	

   378 	else if(aStepName == KtestgzgetsopenFail)

   379 		{

   380 		testStep = new CTestZlib(aStepName);

   381 		}

   382 	else if(aStepName == KtestInflate)

   383 		{

   384 		testStep = new CTestZlib(aStepName);

   385 		}	

   386 	else if(aStepName == KtestInflate_fail1)

   387 		{

   388 		testStep = new CTestZlib(aStepName);

   389 		}	

   390 	else if(aStepName == KtestInflate_fail2)

   391 		{

   392 		testStep = new CTestZlib(aStepName);

   393 		}

   394 	else if(aStepName == KtestInflate_fail3)

   395 		{

   396 		testStep = new CTestZlib(aStepName);

   397 		}	

   398 	else if(aStepName == KtestInflateend)

   399 		{

   400 		testStep = new CTestZlib(aStepName);

   401 		}	

   402 	else if(aStepName == KtestInflateend_fail)

   403 		{

   404 		testStep = new CTestZlib(aStepName);

   405 		}

   406 	else if(aStepName == KtestInflateReset)

   407 		{

   408 		testStep = new CTestZlib(aStepName);

   409 		}	

   410 	else if(aStepName == KtestInflateResetfail1)

   411 		{

   412 		testStep = new CTestZlib(aStepName);

   413 		}	

   414 	else if(aStepName == KtestInflateInit2_)

   415 		{

   416 		testStep = new CTestZlib(aStepName);

   417 		}			

   418 	else if(aStepName == KtestInflateInit_)

   419 		{

   420 		testStep = new CTestZlib(aStepName);

   421 		}	

   422 	else if(aStepName == KtestInflateInit2_negative)

   423 		{

   424 		testStep = new CTestZlib(aStepName);

   425 		}	

   426 	else if(aStepName == KtestInflateInit_negative)

   427 		{

   428 		testStep = new CTestZlib(aStepName);

   429 		}	

   430 	else if(aStepName == KtestInflateInit2_versioncheck)

   431 		{

   432 		testStep = new CTestZlib(aStepName);

   433 		}

   434 	else if(aStepName == KtestInflateInit_versioncheck)

   435 		{

   436 		testStep = new CTestZlib(aStepName);

   437 		}	

   438 	else if(aStepName == KtestAdlerinit)

   439 		{

   440 		testStep = new CTestZlib(aStepName);

   441 		}	

   442 	else if(aStepName == KtestAdler)

   443 		{

   444 		testStep = new CTestZlib(aStepName);

   445 		}

   446 	else if(aStepName == KtestCompress)

   447 		{

   448 		testStep = new CTestZlib(aStepName);

   449 		}	

   450 	else if(aStepName == KtestCompress_negative)

   451 		{

   452 		testStep = new CTestZlib(aStepName);

   453 		}	

   454 	else if(aStepName == KtestCompress2_positive)

   455 		{

   456 		testStep = new CTestZlib(aStepName);

   457 		}

   458 	else if(aStepName == KtestCompress2_negative)

   459 		{

   460 		testStep = new CTestZlib(aStepName);

   461 		}	

   462 	else if(aStepName == KtestCompressbound)

   463 		{

   464 		testStep = new CTestZlib(aStepName);

   465 		}

   466 	else if(aStepName == KtestDeflatebound)

   467 		{

   468 		testStep = new CTestZlib(aStepName);

   469 		}	

   470 	else if(aStepName == KtestDeflateparams)

   471 		{

   472 		testStep = new CTestZlib(aStepName);

   473 		}	

   474 	else if(aStepName == KtestDeflateparamsfail1)

   475 		{

   476 		testStep = new CTestZlib(aStepName);

   477 		}	

   478 	else if(aStepName == KtestDeflateparamsfail2)

   479 		{

   480 		testStep = new CTestZlib(aStepName);

   481 		}

   482 	else if(aStepName == KtestCrcinit)

   483 		{

   484 		testStep = new CTestZlib(aStepName);

   485 		}	

   486 	else if(aStepName == KtestCrc)

   487 		{

   488 		testStep = new CTestZlib(aStepName);

   489 		}

   490 	else if(aStepName == KtestGet_crc_table)

   491 		{

   492 		testStep = new CTestZlib(aStepName);

   493 		}	

   494 	else if(aStepName == KtestDeflateInit_)

   495 		{

   496 		testStep = new CTestZlib(aStepName);

   497 		}	

   498 	else if(aStepName == KtestDeflateInit_level)

   499 		{

   500 		testStep = new CTestZlib(aStepName);

   501 		}

   502 	else if(aStepName == KtestDeflateInit2_)

   503 		{

   504 		testStep = new CTestZlib(aStepName);

   505 		}	

   506 	else if(aStepName == KtestDeflatefail)

   507 		{

   508 		testStep = new CTestZlib(aStepName);

   509 		}	

   510 	else if(aStepName == KtestDeflatefail2)

   511 		{

   512 		testStep = new CTestZlib(aStepName);

   513 		}	

   514 	else if(aStepName == KtestZlibversion)

   515 		{

   516 		testStep = new CTestZlib(aStepName);

   517 		}

   518 	else if(aStepName == KtestGzputc)

   519 		{

   520 		testStep = new CTestZlib(aStepName);

   521 		}	

   522 	else if(aStepName == KtestGzopen)

   523 		{

   524 		testStep = new CTestZlib(aStepName);

   525 		}	

   526 	else if(aStepName == KtestGzopenmode)

   527 		{

   528 		testStep = new CTestZlib(aStepName);

   529 		}

   530 	else if(aStepName == KtestGzopenfail)

   531 		{

   532 		testStep = new CTestZlib(aStepName);

   533 		}	

   534 	else if(aStepName == KtestGzputcfail)

   535 		{

   536 		testStep = new CTestZlib(aStepName);

   537 		}							

   538 	else if(aStepName == KtestGzputcreturn)

   539 		{

   540 		testStep = new CTestZlib(aStepName);

   541 		}	

   542 	else if(aStepName == KtestGzputs)

   543 		{

   544 		testStep = new CTestZlib(aStepName);

   545 		}	

   546 	else if(aStepName == KtestGzputsfail)

   547 		{

   548 		testStep = new CTestZlib(aStepName);

   549 		}	

   550 	else if(aStepName == KtestGzprintf)

   551 		{

   552 		testStep = new CTestZlib(aStepName);

   553 		}		

   554 	else if(aStepName == KtestGzprintf_trying)

   555 		{

   556 		testStep = new CTestZlib(aStepName);

   557 		}	

   558 	else if(aStepName == KtestGzwrite)

   559 		{

   560 		testStep = new CTestZlib(aStepName);

   561 		}	

   562 	else if(aStepName == KtestGzwritefail)

   563 		{

   564 		testStep = new CTestZlib(aStepName);

   565 		}	

   566 	else if(aStepName == KtestGztell)

   567 		{

   568 		testStep = new CTestZlib(aStepName);

   569 		}	

   570 	else if(aStepName == KtestGztell1)

   571 		{

   572 		testStep = new CTestZlib(aStepName);

   573 		}	

   574 	else if(aStepName == KtestGztellfail1)

   575 		{

   576 		testStep = new CTestZlib(aStepName);

   577 		}	

   578 	else if(aStepName == KtestDeflatecopy)

   579 		{

   580 		testStep = new CTestZlib(aStepName);

   581 		}	

   582 	else if(aStepName == KtestDeflatecopyfail)

   583 		{

   584 		testStep = new CTestZlib(aStepName);

   585 		}	

   586 	else if(aStepName == KtestGzclose)

   587 		{

   588 		testStep = new CTestZlib(aStepName);

   589 		}	

   590 	else if(aStepName == KtestGzclose_fail)

   591 		{

   592 		testStep = new CTestZlib(aStepName);

   593 		}

   594 	else if(aStepName == KtestGzeof)

   595 		{

   596 		testStep = new CTestZlib(aStepName);

   597 		}	

   598 	else if(aStepName == KtestGzeoffail1)

   599 		{

   600 		testStep = new CTestZlib(aStepName);

   601 		}	

   602 	else if(aStepName == KtestGzeoffail2)

   603 		{

   604 		testStep = new CTestZlib(aStepName);

   605 		}	

   606 	else if(aStepName == KtestGzgetc)

   607 		{

   608 		testStep = new CTestZlib(aStepName);

   609 		}	

   610 	else if(aStepName == KtestGzflush)

   611 		{

   612 		testStep = new CTestZlib(aStepName);

   613 		}

   614 	else if(aStepName == KtestGzflushsync)

   615 		{

   616 		testStep = new CTestZlib(aStepName);

   617 		}	

   618 	else if(aStepName == KtestGzflushfail)

   619 		{

   620 		testStep = new CTestZlib(aStepName);

   621 		}	

   622 	else if(aStepName == KtestGzerror)

   623 		{

   624 		testStep = new CTestZlib(aStepName);

   625 		}	

   626 	else if(aStepName == KtestGzerrorfail1)

   627 		{

   628 		testStep = new CTestZlib(aStepName);

   629 		}	

   630 	else if(aStepName == KtestGzgetcfail)

   631 		{

   632 		testStep = new CTestZlib(aStepName);

   633 		}	

   634 	else if(aStepName == KtestDeflateSetDictionary)

   635 		{

   636 		testStep = new CTestZlib(aStepName);

   637 		}	

   638 	else if(aStepName == KtestDeflateSetDictionary_nodict)

   639 		{

   640 		testStep = new CTestZlib(aStepName);

   641 		}	

   642 	else if(aStepName == KtestDeflateSetDictionary_fail)

   643 		{

   644 		testStep = new CTestZlib(aStepName);

   645 		}

   646 	else if(aStepName == KtestDeflateend)

   647 		{

   648 		testStep = new CTestZlib(aStepName);

   649 		}	

   650 	else if(aStepName == KtestDeflateendfail1)

   651 		{

   652 		testStep = new CTestZlib(aStepName);

   653 		}	

   654 	else if(aStepName == KtestDeflate)

   655 		{

   656 		testStep = new CTestZlib(aStepName);

   657 		}

   658 	else if(aStepName == KtestGzseek)

   659 		{

   660 		testStep = new CTestZlib(aStepName);

   661 		}	

   662 	else if(aStepName == KtestGzseekfail1)

   663 		{

   664 		testStep = new CTestZlib(aStepName);

   665 		}

   666 	else if(aStepName == KtestGzseekfail2)

   667 		{

   668 		testStep = new CTestZlib(aStepName);

   669 		}	

   670 	else if(aStepName == KtestGzsetparams)

   671 		{

   672 		testStep = new CTestZlib(aStepName);

   673 		}		

   674 	else if(aStepName == KtestGzsetparams_fail1)

   675 		{

   676 		testStep = new CTestZlib(aStepName);

   677 		}

   678 	else if(aStepName == KtestGzsetparams_fail2)

   679 		{

   680 		testStep = new CTestZlib(aStepName);

   681 		}	

   682 	else if(aStepName == KtestGzsetparams_fail3)

   683 		{

   684 		testStep = new CTestZlib(aStepName);

   685 		}	

   686 	else if(aStepName == KtestGzrewind)

   687 		{

   688 		testStep = new CTestZlib(aStepName);

   689 		}	

   690 	else if(aStepName == KtestGzrewindfail)

   691 		{

   692 		testStep = new CTestZlib(aStepName);

   693 		}	

   694 	else if(aStepName == KtestGzdopen)

   695 		{

   696 		testStep = new CTestZlib(aStepName);

   697 		}

   698 	else if(aStepName == KtestGzdopen_fail)

   699 		{

   700 		testStep = new CTestZlib(aStepName);

   701 		}	

   702 	else if(aStepName == KtestGzdopen_fail2)

   703 		{

   704 		testStep = new CTestZlib(aStepName);

   705 		}	

   706 	else if(aStepName == KtestInflateSync)

   707 		{

   708 		testStep = new CTestZlib(aStepName);

   709 		}	

   710 	else if(aStepName == KtestinflateSyncfail)

   711 		{

   712 		testStep = new CTestZlib(aStepName);

   713 		}	

   714 	else if(aStepName == KtestInflateSyncPoint)

   715 		{

   716 		testStep = new CTestZlib(aStepName);

   717 		}	

   718 	else if(aStepName == KtestInflateSyncPoint_null)

   719 		{

   720 		testStep = new CTestZlib(aStepName);

   721 		}

   722 	else if(aStepName == KtestZerror)

   723 		{

   724 		testStep = new CTestZlib(aStepName);

   725 		}	

   726 	else if(aStepName == KtestZerror1)

   727 		{

   728 		testStep = new CTestZlib(aStepName);

   729 		}		

   730 	else if(aStepName == KtestZerror2)

   731 		{

   732 		testStep = new CTestZlib(aStepName);

   733 		}

   734 	

   735 	

   736 	else if(aStepName == KTestDeflateTest01)

   737 		{

   738 		testStep = new CTestZlib(aStepName);

   739 		}

   740 	else if(aStepName == KTestDeflatecopyDestNull)

   741 		{

   742 		testStep = new CTestZlib(aStepName);

   743 		}

   744 	else if(aStepName == KTestDeflateCopyStreamStateNull)

   745 		{

   746 		testStep = new CTestZlib(aStepName);

   747 		}

   748 	else if(aStepName == KTestDeflateInit2_WindowBits)

   749 		{

   750 		testStep = new CTestZlib(aStepName);

   751 		}

   752 	else if(aStepName == KTestDeflateInit2_StreamSize)

   753 		{

   754 		testStep = new CTestZlib(aStepName);

   755 		}

   756 	else if(aStepName == KTestDeflateInit2_MemLevel)

   757 		{

   758 		testStep = new CTestZlib(aStepName);

   759 		}

   760 	else if(aStepName == KTestDeflateInit2_Level)

   761 		{

   762 		testStep = new CTestZlib(aStepName);

   763 		}

   764 	else if(aStepName == KTestDeflateInit2_Strategy)

   765 		{

   766 		testStep = new CTestZlib(aStepName);

   767 		}

   768 	else if(aStepName == KTestDeflateInit2_Version)

   769 		{

   770 		testStep = new CTestZlib(aStepName);

   771 		}

   772 	else if(aStepName == KTestDeflateInit2_VersionNull)

   773 		{

   774 		testStep = new CTestZlib(aStepName);

   775 		}

   776 	else if(aStepName == KTestDeflateInit2_StreamNull)

   777 		{

   778 		testStep = new CTestZlib(aStepName);

   779 		}

   780 	else if(aStepName == KTestInflateInit2_Version)

   781 		{

   782 		testStep = new CTestZlib(aStepName);

   783 		}

   784 	else if(aStepName == KTestInflateInit2_VersionNull)

   785 		{

   786 		testStep = new CTestZlib(aStepName);

   787 		}

   788 	else if(aStepName == KTestInflateInit2_WindowBits)

   789 		{

   790 		testStep = new CTestZlib(aStepName);

   791 		}

   792 	else if(aStepName == KTestInflateInit2_StreamNull)

   793 		{

   794 		testStep = new CTestZlib(aStepName);

   795 		}

   796 	else if(aStepName == KTestDeflate_HuffmanStrategy)

   797 		{

   798 		testStep = new CTestZlib(aStepName);

   799 		}

   800 	else if(aStepName == KTestDeflate_AvailInZero)

   801 		{

   802 		testStep = new CTestZlib(aStepName);

   803 		}

   804 	else if(aStepName == KTestGzsetparamDefaultCompression)

   805 		{

   806 		testStep = new CTestZlib(aStepName);

   807 		}

   808 	else if(aStepName == KTestDeflateResetNullStream)

   809 		{

   810 		testStep = new CTestZlib(aStepName);

   811 		}

   812 	else if(aStepName == KTestDeflateResetStreamStateNull)

   813 		{

   814 		testStep = new CTestZlib(aStepName);

   815 		}

   816 	else if(aStepName == KTestDeflate_Scenarios)

   817 		{

   818 		testStep = new CTestZlib(aStepName);

   819 		}

   820 	else if(aStepName == KTestDeflate_NullStream)

   821 		{

   822 		testStep = new CTestZlib(aStepName);

   823 		}

   824 	else if(aStepName == KTestDeflate_StreamStateNull)

   825 		{

   826 		testStep = new CTestZlib(aStepName);

   827 		}

   828 	else if(aStepName == KTestDeflateEndNull)

   829 		{

   830 		testStep = new CTestZlib(aStepName);

   831 		}

   832 	else if(aStepName == KTestDeflateEndStreamStateNull)

   833 		{

   834 		testStep = new CTestZlib(aStepName);

   835 		}

   836 	else if(aStepName == KTestDeflate_WindowBits)

   837 		{

   838 		testStep = new CTestZlib(aStepName);

   839 		}

   840 	else if(aStepName == KTestDeflateBoundStreamNotNull)

   841 		{

   842 		testStep = new CTestZlib(aStepName);

   843 		}

   844 	else if(aStepName == KTestDeflateBoundStreamNull)

   845 		{

   846 		testStep = new CTestZlib(aStepName);

   847 		}

   848 	else if(aStepName == KTestDeflateBoundStreamStateNull)

   849 		{

   850 		testStep = new CTestZlib(aStepName);

   851 		}

   852 	else if(aStepName == KTestDeflateSetDictionaryWrap)

   853 		{

   854 		testStep = new CTestZlib(aStepName);

   855 		}

   856 	else if(aStepName == KTestDeflateSetDictionaryLen)

   857 		{

   858 		testStep = new CTestZlib(aStepName);

   859 		}

   860 	else if(aStepName == KTestDeflateParamsStreamStateNull)

   861 		{

   862 		testStep = new CTestZlib(aStepName);

   863 		}

   864 	else if(aStepName == KTestInflateSyncAvailInNull)

   865 		{

   866 		testStep = new CTestZlib(aStepName);

   867 		}

   868 	else if(aStepName == KTestInflateSyncStreamNull)

   869 		{

   870 		testStep = new CTestZlib(aStepName);

   871 		}

   872 	else if(aStepName == KTestInflateSyncStreamStateNull)

   873 		{

   874 		testStep = new CTestZlib(aStepName);

   875 		}

   876 	else if(aStepName == KTestAdlerScenarios)

   877 		{

   878 		testStep = new CTestZlib(aStepName);

   879 		}

   880 	else if(aStepName == KTestGzsetparamsFileNull)

   881 		{

   882 		testStep = new CTestZlib(aStepName);

   883 		}

   884 	else if(aStepName == KTestDeflateTest01)

   885 		{

   886 		testStep = new CTestZlib(aStepName);

   887 		}

   888 	else if(aStepName == KTestDeflatecopyDestNull)

   889 		{

   890 		testStep = new CTestZlib(aStepName);

   891 		}

   892 	else if(aStepName == KTestDeflateCopyStreamStateNull)

   893 		{

   894 		testStep = new CTestZlib(aStepName);

   895 		}

   896 	else if(aStepName == KTestDeflateInit2_WindowBits)

   897 		{

   898 		testStep = new CTestZlib(aStepName);

   899 		}

   900 	else if(aStepName == KTestDeflateInit2_StreamSize)

   901 		{

   902 		testStep = new CTestZlib(aStepName);

   903 		}

   904 	else if(aStepName == KTestDeflateInit2_MemLevel)

   905 		{

   906 		testStep = new CTestZlib(aStepName);

   907 		}

   908 	else if(aStepName == KTestDeflateInit2_Level)

   909 		{

   910 		testStep = new CTestZlib(aStepName);

   911 		}

   912 	else if(aStepName == KTestDeflateInit2_Strategy)

   913 		{

   914 		testStep = new CTestZlib(aStepName);

   915 		}

   916 	else if(aStepName == KTestDeflateInit2_Version)

   917 		{

   918 		testStep = new CTestZlib(aStepName);

   919 		}

   920 	else if(aStepName == KTestDeflateInit2_VersionNull)

   921 		{

   922 		testStep = new CTestZlib(aStepName);

   923 		}

   924 	else if(aStepName == KTestDeflateInit2_StreamNull)

   925 		{

   926 		testStep = new CTestZlib(aStepName);

   927 		}

   928 	else if(aStepName == KTestInflateInit2_Version)

   929 		{

   930 		testStep = new CTestZlib(aStepName);

   931 		}

   932 	else if(aStepName == KTestInflateInit2_VersionNull)

   933 		{

   934 		testStep = new CTestZlib(aStepName);

   935 		}

   936 	else if(aStepName == KTestInflateInit2_WindowBits)

   937 		{

   938 		testStep = new CTestZlib(aStepName);

   939 		}

   940 	else if(aStepName == KTestInflateInit2_StreamNull)

   941 		{

   942 		testStep = new CTestZlib(aStepName);

   943 		}

   944 	else if(aStepName == KTestDeflate_HuffmanStrategy)

   945 		{

   946 		testStep = new CTestZlib(aStepName);

   947 		}

   948 	else if(aStepName == KTestDeflate_AvailInZero)

   949 		{

   950 		testStep = new CTestZlib(aStepName);

   951 		}

   952 	else if(aStepName == KTestGzsetparamDefaultCompression)

   953 		{

   954 		testStep = new CTestZlib(aStepName);

   955 		}

   956 	else if(aStepName == KTestDeflateResetNullStream)

   957 		{

   958 		testStep = new CTestZlib(aStepName);

   959 		}

   960 	else if(aStepName == KTestDeflateResetStreamStateNull)

   961 		{

   962 		testStep = new CTestZlib(aStepName);

   963 		}

   964 	else if(aStepName == KTestDeflate_Scenarios)

   965 		{

   966 		testStep = new CTestZlib(aStepName);

   967 		}

   968 	else if(aStepName == KTestDeflate_NullStream)

   969 		{

   970 		testStep = new CTestZlib(aStepName);

   971 		}

   972 	else if(aStepName == KTestDeflate_StreamStateNull)

   973 		{

   974 		testStep = new CTestZlib(aStepName);

   975 		}

   976 	else if(aStepName == KTestDeflateEndNull)

   977 		{

   978 		testStep = new CTestZlib(aStepName);

   979 		}

   980 	else if(aStepName == KTestDeflateEndStreamStateNull)

   981 		{

   982 		testStep = new CTestZlib(aStepName);

   983 		}

   984 	else if(aStepName == KTestDeflate_WindowBits)

   985 		{

   986 		testStep = new CTestZlib(aStepName);

   987 		}

   988 	else if(aStepName == KTestDeflateBoundStreamNotNull)

   989 		{

   990 		testStep = new CTestZlib(aStepName);

   991 		}

   992 	else if(aStepName == KTestDeflateBoundStreamNull)

   993 		{

   994 		testStep = new CTestZlib(aStepName);

   995 		}

   996 	else if(aStepName == KTestDeflateBoundStreamStateNull)

   997 		{

   998 		testStep = new CTestZlib(aStepName);

   999 		}

  1000 	else if(aStepName == KTestDeflateSetDictionaryWrap)

  1001 		{

  1002 		testStep = new CTestZlib(aStepName);

  1003 		}

  1004 	else if(aStepName == KTestDeflateSetDictionaryLen)

  1005 		{

  1006 		testStep = new CTestZlib(aStepName);

  1007 		}

  1008 	else if(aStepName == KTestInflateSetDictionaryBadMode)

  1009 		{

  1010 		testStep = new CTestZlib(aStepName);

  1011 		}

  1012 	else if(aStepName == KTestInflateSetDictionaryStreamStateNull)

  1013 		{

  1014 		testStep = new CTestZlib(aStepName);

  1015 		}

  1016 	else if(aStepName == KTestDeflateParamsStreamStateNull)

  1017 		{

  1018 		testStep = new CTestZlib(aStepName);

  1019 		}

  1020 	else if(aStepName == KTestInflateSyncAvailInNull)

  1021 		{

  1022 		testStep = new CTestZlib(aStepName);

  1023 		}

  1024 	else if(aStepName == KTestInflateSyncStreamNull)

  1025 		{

  1026 		testStep = new CTestZlib(aStepName);

  1027 		}

  1028 	else if(aStepName == KTestInflateSyncStreamStateNull)

  1029 		{

  1030 		testStep = new CTestZlib(aStepName);

  1031 		}

  1032 	else if(aStepName == KTestInflateSyncPointStreamStateNull)

  1033 		{

  1034 		testStep = new CTestZlib(aStepName);

  1035 		}

  1036 	else if(aStepName == KTestAdlerScenarios)

  1037 		{

  1038 		testStep = new CTestZlib(aStepName);

  1039 		}

  1040 	else if(aStepName == KTestGzsetparamsFileNull)

  1041 		{

  1042 		testStep = new CTestZlib(aStepName);

  1043 		}

  1044 	else if(aStepName == KTestGzopenWrite)

  1045 		{

  1046 		testStep = new CTestZlib(aStepName);

  1047 		}

  1048 	else if(aStepName == KTestGzreadLargeFile)

  1049 		{

  1050 		testStep = new CTestZlib(aStepName);

  1051 		}

  1052 	else if(aStepName == KTestGzopenWriteNoPath)

  1053 		{

  1054 		testStep = new CTestZlib(aStepName);

  1055 		}

  1056 	else if(aStepName == KTestGzreadLenZero)

  1057 		{

  1058 		testStep = new CTestZlib(aStepName);

  1059 		}

  1060 	else if(aStepName == KTestGzreadBufZero)

  1061 		{

  1062 		testStep = new CTestZlib(aStepName);

  1063 		}

  1064 	else if(aStepName == KTestGzreadNonGzFile)

  1065 		{

  1066 		testStep = new CTestZlib(aStepName);

  1067 		}

  1068 	else if(aStepName == KTestGzrewindNonGzFile)

  1069 		{

  1070 		testStep = new CTestZlib(aStepName);

  1071 		}

  1072 	else if(aStepName == KTestGzrewindFileNull)

  1073 		{

  1074 		testStep = new CTestZlib(aStepName);

  1075 		}

  1076 	else if(aStepName == KTestGzflushWithZFinish)

  1077 		{

  1078 		testStep = new CTestZlib(aStepName);

  1079 		}

  1080 	else if(aStepName == KTestUncompressLenSmall)

  1081 		{

  1082 		testStep = new CTestZlib(aStepName);

  1083 		}

  1084 	else if(aStepName == KTestUncompressBufNull)

  1085 		{

  1086 		testStep = new CTestZlib(aStepName);

  1087 		}

  1088 	else if(aStepName == KTestUncompressLenNull)

  1089 		{

  1090 		testStep = new CTestZlib(aStepName);

  1091 		}

  1092 	else if(aStepName == KTestInflateScenarios)

  1093 		{

  1094 		testStep = new CTestZlib(aStepName);

  1095 		}

  1096 	else if(aStepName == KTestInflateStreamStateNull)

  1097 		{

  1098 		testStep = new CTestZlib(aStepName);

  1099 		}

  1100 	else if(aStepName == KTestInflateResetStreamStateNull)

  1101 		{

  1102 		testStep = new CTestZlib(aStepName);

  1103 		}

  1104 	else if(aStepName == KTestDeflateTuneL)

  1105 		{

  1106 		testStep = new CTestZlib(aStepName);

  1107 		}

  1108 	else if(aStepName == KTestDeflateTuneFailL)

  1109 		{

  1110 		testStep = new CTestZlib(aStepName);

  1111 		}

  1112 	else if(aStepName == KTestDefInfGZipDefaultHeaderIgnoreL)

  1113 		{

  1114 		testStep = new CTestZlib(aStepName);

  1115 		}

  1116 	else if(aStepName == KTestDefInfGZipDefaultHeaderAutoL)

  1117 		{

  1118 		testStep = new CTestZlib(aStepName);

  1119 		}

  1120 	else if(aStepName == KTestDefInfGZipSpecifiedHeaderManualL)

  1121 		{

  1122 		testStep = new CTestZlib(aStepName);

  1123 		}

  1124 	else if(aStepName == KTestDefInfGZipSpecifiedHeaderAutoL)

  1125 		{

  1126 		testStep = new CTestZlib(aStepName);

  1127 		}

  1128 	else if(aStepName == KTestDefInfZlibHeaderAutoL)

  1129 		{

  1130 		testStep = new CTestZlib(aStepName);

  1131 		}

  1132 	else if(aStepName == KTestDeflateSetHeaderFailsL)

  1133 		{

  1134 		testStep = new CTestZlib(aStepName);