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        : tzlib.cpp

    15 // 

    16 //

    17 

    18 #include "tzlib.h"

    19 

    20 CTestZlib::CTestZlib(const TDesC& aStepName)

    21 	{

    22 	iParamCnt=0;

    23 	// MANDATORY Call to base class method to set up the human readable name for logging.

    24 	SetTestStepName(aStepName);		

    25 	}

    26 

    27 TVerdict CTestZlib::doTestStepPreambleL()

    28 	{

    29 	__UHEAP_MARK;	

    30 	SetTestStepResult(EPass);

    31 	return TestStepResult();

    32 	}

    33 

    34 

    35 TVerdict CTestZlib::doTestStepPostambleL()

    36 	{

    37 	__UHEAP_MARKEND;	

    38 	return TestStepResult();

    39 	}

    40 

    41 

    42 TVerdict CTestZlib::doTestStepL()

    43 	{

    44 	int err=KErrNone;

    45 

    46 	// BEGIN testcases of tzlib.cpp

    47 	if(TestStepName() == Ktest_zlibVersion)

    48    		{

    49    		INFO_PRINTF1(_L("Test_zlibVersion():"));

    50    		err = Test_zlibVersion();

    51    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    52    		}

    53    	else if(TestStepName() == Ktest_compress01)

    54    		{

    55    		INFO_PRINTF1(_L("Test_compress01():"));

    56    		err = Test_compress01();

    57    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    58    		}

    59    	else if(TestStepName() == Ktest_deflate01)

    60 		{

    61    		INFO_PRINTF1(_L("Test_deflate01():"));

    62    		err = Test_deflate01();

    63    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    64    		}

    65    	else if(TestStepName() == Ktest_deflate02)

    66 		{

    67    		INFO_PRINTF1(_L("Test_deflate02():"));

    68    		err = Test_deflate02();

    69    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    70    		}

    71    	else if(TestStepName() == Ktest_deflateEnd)

    72 		{

    73    		INFO_PRINTF1(_L("Test_deflateEnd():"));

    74    		err = Test_deflateEnd();

    75    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    76    		}

    77    	else if(TestStepName() == Ktest_inflate01)

    78 		{

    79    		INFO_PRINTF1(_L("Test_inflate01():"));

    80    		err = Test_inflate01();

    81    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    82    		}

    83    	else if(TestStepName() == Ktest_inflate02)

    84 		{

    85    		INFO_PRINTF1(_L("Test_inflate02():"));

    86    		err = Test_inflate02();

    87    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    88    		}

    89    	else if(TestStepName() == Ktest_inflate03)

    90 		{

    91    		INFO_PRINTF1(_L("Test_inflate03():"));

    92    		err = Test_inflate03();

    93    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    94    		}

    95    	else if(TestStepName() == Ktest_inflate04)

    96 		{

    97    		INFO_PRINTF1(_L("Test_inflate04():"));

    98    		err = Test_inflate04();

    99    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   100    		}

   101    	else if(TestStepName() == Ktest_inflate05)

   102 		{

   103    		INFO_PRINTF1(_L("Test_inflate05():"));

   104    		err = Test_inflate05();

   105    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   106    		}

   107    	else if(TestStepName() == Ktest_inflate06)

   108 		{

   109    		INFO_PRINTF1(_L("Test_inflate06():"));

   110    		err = Test_inflate06();

   111    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   112    		}

   113    	else if(TestStepName() == Ktest_inflateEnd)

   114 		{

   115    		INFO_PRINTF1(_L("Test_inflateEnd():"));

   116    		err = Test_inflateEnd();

   117    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   118    		}

   119    	else if(TestStepName() == Ktest_deflateSetDictionary01)

   120 		{

   121    		INFO_PRINTF1(_L("Test_deflateSetDictionary01():"));

   122    		err = Test_deflateSetDictionary01();

   123    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   124    		}

   125    	else if(TestStepName() == Ktest_deflateSetDictionary02)

   126 		{

   127    		INFO_PRINTF1(_L("Test_deflateSetDictionary02():"));

   128    		err = Test_deflateSetDictionary02();

   129    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   130    		}

   131    	else if(TestStepName() == Ktest_deflateSetDictionary03)

   132 		{

   133    		INFO_PRINTF1(_L("Test_deflateSetDictionary03():"));

   134    		err = Test_deflateSetDictionary03();

   135    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   136    		}

   137    	else if(TestStepName() == Ktest_deflateSetDictionary04)

   138 		{

   139    		INFO_PRINTF1(_L("Test_deflateSetDictionary04():"));

   140    		err = Test_deflateSetDictionary04();

   141    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   142    		}

   143    	else if(TestStepName() == Ktest_deflateSetDictionary05)

   144 		{

   145    		INFO_PRINTF1(_L("Test_deflateSetDictionary05():"));

   146    		err = Test_deflateSetDictionary05();

   147    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   148    		}

   149    else if(TestStepName() == Ktest_gzio)

   150 		{

   151    		INFO_PRINTF1(_L("Test_gzio():"));

   152    		err = Test_gzio();

   153    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   154    		}

   155    	else if(TestStepName() == Ktest_gzdirect)

   156 		{

   157    		INFO_PRINTF1(_L("Test_gzdirect():"));

   158    		err = Test_gzdirect();

   159    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   160    		}

   161    	else if(TestStepName() == Ktest_gzdirectnull)

   162 		{

   163    		INFO_PRINTF1(_L("Test_gzdirectnull():"));

   164    		err = Test_gzdirectnull();

   165    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   166    		}

   167    	else if(TestStepName() == Ktest_gzclearerr)

   168 		{

   169    		INFO_PRINTF1(_L("Test_gzclearerr():"));

   170    		err = Test_gzclearerr();

   171    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   172    		}

   173    	else if(TestStepName() == Ktest_gzclearerr_null)

   174 		{

   175    		INFO_PRINTF1(_L("Test_gzclearerr_null():"));

   176    		err = Test_gzclearerr_null();

   177    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   178    		}	

   179    	else if(TestStepName() == Ktest_gzerror_streamend)

   180 		{

   181    		INFO_PRINTF1(_L("Test_gzerror_streamend():"));

   182    		err = Test_gzerror_streamend();

   183    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   184    		}	

   185    	else if(TestStepName() == Ktest_gzungetcnegative)

   186 		{

   187    		INFO_PRINTF1(_L("Test_gzungetcnegative():"));

   188    		err = Test_gzungetcnegative();

   189    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   190    		}

   191    	else if(TestStepName() == Ktest_gzseeknegative)

   192 		{

   193    		INFO_PRINTF1(_L("Test_gzseeknegative():"));

   194    		err = Test_gzseeknegative();

   195    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   196    		}

   197    	else if(TestStepName() == Ktest_gzdirecttxt)

   198 		{

   199    		INFO_PRINTF1(_L("Test_gzdirecttxt():"));

   200    		err = Test_gzdirecttxt();

   201    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   202    		}

   203    	else if(TestStepName() == KtestGzungetcChain)

   204 		{

   205    		INFO_PRINTF1(_L("TestGzungetcChain():"));

   206    		err = TestGzungetcChain();

   207    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   208    		}

   209    	else if(TestStepName() == KtestGzseekBack)

   210 		{

   211    		INFO_PRINTF1(_L("TestGzseekBack():"));

   212    		err = TestGzseekBack();

   213    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   214    		}

   215    	else if(TestStepName() == KtestGzseekAppend)

   216 		{

   217    		INFO_PRINTF1(_L("TestGzseekAppend():"));

   218    		err = TestGzseekAppend();

   219    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   220    		}

   221    	else if(TestStepName() == KtestGzseekHugeOffset)

   222 		{

   223    		INFO_PRINTF1(_L("TestGzseekHugeOffset():"));

   224    		err = TestGzseekHugeOffset();

   225    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   226    		}

   227    	else if(TestStepName() == KtestGzseekNoSize)

   228 		{

   229    		INFO_PRINTF1(_L("TestGzseekNoSize():"));

   230    		err = TestGzseekNoSize();

   231    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   232    		}

   233    	else if(TestStepName() == KtestGzopenLongPath01)

   234 		{

   235    		INFO_PRINTF1(_L("TestGzopenLongPath01():"));

   236    		err = TestGzopenLongPath01();

   237    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   238    		}

   239    	else if(TestStepName() == KtestGzseekLongPath01)

   240 		{

   241    		INFO_PRINTF1(_L("TestGzseekLongPath01():"));

   242    		err = TestGzseekLongPath01();

   243    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   244    		}

   245    	else if(TestStepName() == KtestGzopenLongPath02)

   246 		{

   247    		INFO_PRINTF1(_L("TestGzopenLongPath02():"));

   248    		err = TestGzopenLongPath02();

   249    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   250    		}

   251    	else if(TestStepName() == KtestGzseekMixedFile01)

   252 		{

   253    		INFO_PRINTF1(_L("TestGzseekMixedFile01():"));

   254    		err = TestGzseekMixedFile01();

   255    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   256    		}

   257    	else if(TestStepName() == KtestGzopenNoMode)

   258 		{

   259    		INFO_PRINTF1(_L("TestGzopenNoMode():"));

   260    		err = TestGzopenNoMode();

   261    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   262    		}

   263    	else if(TestStepName() == KtestGzopenNoPath)

   264 		{

   265    		INFO_PRINTF1(_L("TestGzopenNoPath():"));

   266    		err = TestGzopenNoPath();

   267    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   268    		}

   269    	else if(TestStepName() == KtestGzopenNoPathMode)

   270 		{

   271    		INFO_PRINTF1(_L("TestGzopenNoPathMode():"));

   272    		err = TestGzopenNoPathMode();

   273    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   274    		}

   275    	else if(TestStepName() == KtestGzseekConcatedFile01)

   276 		{

   277    		INFO_PRINTF1(_L("TestGzseekConcatedFile01():"));

   278    		err = TestGzseekConcatedFile01();

   279    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   280    		}

   281    	else if(TestStepName() == KtestGzopenDiffMode)

   282 		{

   283    		INFO_PRINTF1(_L("TestGzopenDiffMode():"));

   284    		err = TestGzopenDiffMode();

   285    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   286    		}

   287    	else if(TestStepName() == KtestGzseekConcatedFile02)

   288 		{

   289    		INFO_PRINTF1(_L("TestGzseekConcatedFile02():"));

   290    		err = TestGzseekConcatedFile02();

   291    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   292    		}

   293    	else if(TestStepName() == KtestGzprintf01)

   294 		{

   295    		INFO_PRINTF1(_L("TestGzprintf01():"));

   296    		err = TestGzprintf01();

   297    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   298    		}

   299    	else if(TestStepName() == KtestGzprintf02)

   300 		{

   301    		INFO_PRINTF1(_L("TestGzprintf02():"));

   302    		err = TestGzprintf02();

   303    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   304    		}

   305    	else if(TestStepName() == KtestGzflushNull)

   306 		{

   307    		INFO_PRINTF1(_L("TestGzflushNull():"));

   308    		err = TestGzflushNull();

   309    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   310    		}

   311    else if(TestStepName() == KtestGzflushRepeat)

   312 		{

   313    		INFO_PRINTF1(_L("TestGzflushRepeat():"));

   314    		err = TestGzflushRepeat();

   315    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   316    		}

   317    	else if(TestStepName() == KtestGzflushHugeBuf)

   318 		{

   319    		INFO_PRINTF1(_L("TestGzflushHugeBuf():"));

   320    		err = TestGzflushHugeBuf();

   321    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   322    		}

   323    	else if(TestStepName() == KtestGzrewindNull)

   324 		{

   325    		INFO_PRINTF1(_L("TestGzrewindNull():"));

   326    		err = TestGzrewindNull();

   327    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   328    		}

   329    	else if(TestStepName() == KtestGzrewindTransparent)

   330 		{

   331    		INFO_PRINTF1(_L("TestGzrewindTransparent():"));

   332    		err = TestGzrewindTransparent();

   333    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   334    		}

   335    	else if(TestStepName() == KtestGzgetsBufNull)

   336 		{

   337    		INFO_PRINTF1(_L("TestGzgetsBufNull():"));

   338    		err = TestGzgetsBufNull();

   339    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   340    		}

   341    	else if(TestStepName() == KtestGzgetsSmallBuf)

   342 		{

   343    		INFO_PRINTF1(_L("TestGzgetsSmallBuf():"));

   344    		err = TestGzgetsSmallBuf();

   345    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   346    		}			// END testcases of tzlib.cpp

   347    	

   348    	//BEGIN testcases of tzlib_auto.cpp

   349    	else if(TestStepName() == KtestDeflateReset)

   350 		{

   351    		INFO_PRINTF1(_L("TestDeflateReset():"));

   352    		err = TestDeflateReset();

   353    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   354    		}

   355    	else if(TestStepName() == KtestDeflateReset_fail)

   356 		{

   357    		INFO_PRINTF1(_L("TestDeflateReset_fail():"));

   358    		err = TestDeflateReset_fail();

   359    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   360    		}

   361    	else if(TestStepName() == KtestDeflateInit2_bits)

   362 		{

   363    		INFO_PRINTF1(_L("TestDeflateInit2_bits():"));

   364    		err = TestDeflateInit2_bits();

   365    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   366    		}

   367    	else if(TestStepName() == KtestDeflateInit2_level)

   368 		{

   369    		INFO_PRINTF1(_L("TestDeflateInit2_level():"));

   370    		err = TestDeflateInit2_level();

   371    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   372    		}

   373 	else if(TestStepName() == KtestInflateInit2_bits)

   374 		{

   375    		INFO_PRINTF1(_L("TestInflateInit2_bits():"));

   376    		err = TestInflateInit2_bits();

   377    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   378    		}

   379    	else if(TestStepName() == KtestGzread)

   380 		{

   381    		INFO_PRINTF1(_L("TestGzread():"));

   382    		err = TestGzread();

   383    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   384    		}	

   385    	else if(TestStepName() == KtestGzread_fail)

   386 		{

   387    		INFO_PRINTF1(_L("TestGzread_fail():"));

   388    		err = TestGzread_fail();

   389    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   390    		}

   391    		

   392    	else if(TestStepName() == KtestUncompress)

   393 		{

   394    		INFO_PRINTF1(_L("TestUncompress():"));

   395    		err = TestUncompress();

   396    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   397    		}

   398    	else if(TestStepName() == KtestUncompressfail)

   399 		{

   400    		INFO_PRINTF1(_L("TestUncompressfail():"));

   401    		err = TestUncompressfail();

   402    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   403    		}		

   404 	else if(TestStepName() == KtestInflateSetDictionary)

   405 		{

   406    		INFO_PRINTF1(_L("TestInflateSetDictionary():"));

   407    		err = TestInflateSetDictionary();

   408    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   409    		}

   410    	else if(TestStepName() == KtestInflateSetDictionary_size)

   411 		{

   412    		INFO_PRINTF1(_L("TestInflateSetDictionary_size():"));

   413    		err = TestInflateSetDictionary_size();

   414    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   415    		}	

   416    	else if(TestStepName() == KtestInflateSetDictionary_null)

   417 		{

   418    		INFO_PRINTF1(_L("TestInflateSetDictionary_null():"));

   419    		err = TestInflateSetDictionary_null();

   420    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   421    		}

   422    	else if(TestStepName() == KtestGzgets)

   423 		{

   424    		INFO_PRINTF1(_L("TestGzgets():"));

   425    		err = TestGzgets();

   426    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   427    		}	

   428    	else if(TestStepName() == KtestgzgetsFail)

   429 		{

   430    		INFO_PRINTF1(_L("TestgzgetsFail():"));

   431    		err = TestgzgetsFail();

   432    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   433    		}	

   434    	else if(TestStepName() == KtestgzgetsopenFail)

   435 		{

   436    		INFO_PRINTF1(_L("TestgzgetsopenFail():"));

   437    		err = TestgzgetsopenFail();

   438    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   439    		}	

   440    	else if(TestStepName() == KtestInflate)

   441 		{

   442    		INFO_PRINTF1(_L("TestInflate():"));

   443    		err = TestInflate();

   444    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   445    		}

   446    	else if(TestStepName() == KtestInflate_fail1)

   447 		{

   448    		INFO_PRINTF1(_L("TestInflate_fail1():"));

   449    		err = TestInflate_fail1();

   450    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   451    		}	

   452    	else if(TestStepName() == KtestInflate_fail2)

   453 		{

   454    		INFO_PRINTF1(_L("TestInflate_fail2():"));

   455    		err = TestInflate_fail2();

   456    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   457    		}	

   458    	else if(TestStepName() == KtestInflate_fail3)

   459 		{

   460    		INFO_PRINTF1(_L("TestInflate_fail3():"));

   461    		err = TestInflate_fail3();

   462    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   463    		}

   464    	else if(TestStepName() == KtestInflateend)

   465 		{

   466    		INFO_PRINTF1(_L("TestInflateend():"));

   467    		err = TestInflateend();

   468    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   469    		}	

   470    	else if(TestStepName() == KtestInflateend_fail)

   471 		{

   472    		INFO_PRINTF1(_L("TestInflateend_fail():"));

   473    		err = TestInflateend_fail();

   474    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   475    		}	

   476    	else if(TestStepName() == KtestInflateReset)

   477 		{

   478    		INFO_PRINTF1(_L("TestInflateReset():"));

   479    		err = TestInflateReset();

   480    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   481    		}

   482    	else if(TestStepName() == KtestInflateResetfail1)

   483 		{

   484    		INFO_PRINTF1(_L("TestInflateResetfail1():"));

   485    		err = TestInflateResetfail1();

   486    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   487    		}	

   488    	else if(TestStepName() == KtestInflateInit2_)

   489 		{

   490    		INFO_PRINTF1(_L("TestInflateInit2_():"));

   491    		err = TestInflateInit2_();

   492    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   493    		}

   494    	else if(TestStepName() == KtestInflateInit_)

   495 		{

   496    		INFO_PRINTF1(_L("TestInflateInit_():"));

   497    		err = TestInflateInit_();

   498    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   499    		}	

   500    	else if(TestStepName() == KtestInflateInit2_negative)

   501 		{

   502    		INFO_PRINTF1(_L("TestInflateInit2_negative():"));

   503    		err = TestInflateInit2_negative();

   504    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   505    		}		

   506    	else if(TestStepName() == KtestInflateInit_negative)

   507 		{

   508    		INFO_PRINTF1(_L("TestInflateInit_negative():"));

   509    		err = TestInflateInit_negative();

   510    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   511    		}

   512    	else if(TestStepName() == KtestInflateInit2_versioncheck)

   513 		{

   514    		INFO_PRINTF1(_L("TestInflateInit2_versioncheck():"));

   515    		err = TestInflateInit2_versioncheck();

   516    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   517    		}	

   518    	else if(TestStepName() == KtestInflateInit_versioncheck)

   519 		{

   520    		INFO_PRINTF1(_L("TestInflateInit_versioncheck():"));

   521    		err = TestInflateInit_versioncheck();

   522    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   523    		}	

   524    	else if(TestStepName() == KtestAdlerinit)

   525 		{

   526    		INFO_PRINTF1(_L("TestAdlerinit():"));

   527    		err = TestAdlerinit();

   528    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   529    		}

   530    	else if(TestStepName() == KtestAdler)

   531 		{

   532    		INFO_PRINTF1(_L("TestAdler():"));

   533    		err = TestAdler();

   534    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   535    		}	

   536    	else if(TestStepName() == KtestCompress)

   537 		{

   538    		INFO_PRINTF1(_L("TestCompress():"));

   539    		err = TestCompress();

   540    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   541    		}	

   542    	else if(TestStepName() == KtestCompress_negative)

   543 		{

   544    		INFO_PRINTF1(_L("TestCompress_negative():"));

   545    		err = TestCompress_negative();

   546    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   547    		}	

   548    	else if(TestStepName() == KtestCompress2_positive)

   549 		{

   550    		INFO_PRINTF1(_L("TestCompress2_positive():"));

   551    		err = TestCompress2_positive();

   552    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   553    		}

   554    	else if(TestStepName() == KtestCompress2_negative)

   555 		{

   556    		INFO_PRINTF1(_L("TestCompress2_negative():"));

   557    		err = TestCompress2_negative();

   558    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   559    		}	

   560    	else if(TestStepName() == KtestCompressbound)

   561 		{

   562    		INFO_PRINTF1(_L("TestCompressbound():"));

   563    		err = TestCompressbound();

   564    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   565    		}

   566    	else if(TestStepName() == KtestDeflatebound)

   567 		{

   568    		INFO_PRINTF1(_L("TestDeflatebound():"));

   569    		err = TestDeflatebound();

   570    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   571    		}	

   572    	else if(TestStepName() == KtestDeflateparams)

   573 		{

   574    		INFO_PRINTF1(_L("TestDeflateparams():"));

   575    		err = TestDeflateparams();

   576    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   577    		}	

   578    	else if(TestStepName() == KtestDeflateparamsfail1)

   579 		{

   580    		INFO_PRINTF1(_L("TestDeflateparamsfail1():"));

   581    		err = TestDeflateparamsfail1();

   582    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   583    		}

   584    	else if(TestStepName() == KtestDeflateparamsfail2)

   585 		{

   586    		INFO_PRINTF1(_L("TestDeflateparamsfail2():"));

   587    		err = TestDeflateparamsfail2();

   588    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   589    		}	

   590    	else if(TestStepName() == KtestCrcinit)

   591 		{

   592    		INFO_PRINTF1(_L("TestCrcinit():"));

   593    		err = TestCrcinit();

   594    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   595    		}	

   596    	else if(TestStepName() == KtestCrc)

   597 		{

   598    		INFO_PRINTF1(_L("TestCrc():"));

   599    		err = TestCrc();

   600    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   601    		}	

   602    	else if(TestStepName() == KtestGet_crc_table)

   603 		{

   604    		INFO_PRINTF1(_L("TestGet_crc_table():"));

   605    		err = TestGet_crc_table();

   606    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   607    		}	

   608    	else if(TestStepName() == KtestDeflateInit_)

   609 		{

   610    		INFO_PRINTF1(_L("TestDeflateInit_():"));

   611    		err = TestDeflateInit_();

   612    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   613    		}	

   614    	else if(TestStepName() == KtestDeflateInit_level)

   615 		{

   616    		INFO_PRINTF1(_L("TestDeflateInit_level():"));

   617    		err = TestDeflateInit_level();

   618    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   619    		}	

   620    	else if(TestStepName() == KtestDeflateInit2_)

   621 		{

   622    		INFO_PRINTF1(_L("TestDeflateInit2_():"));

   623    		err = TestDeflateInit2_();

   624    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   625    		}	

   626    	else if(TestStepName() == KtestDeflatefail)

   627 		{

   628    		INFO_PRINTF1(_L("TestDeflatefail():"));

   629    		err = TestDeflatefail();

   630    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   631    		}	

   632    	else if(TestStepName() == KtestDeflatefail2)

   633 		{

   634    		INFO_PRINTF1(_L("TestDeflatefail2():"));

   635    		err = TestDeflatefail2();

   636    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   637    		}

   638    	else if(TestStepName() == KtestZlibversion)

   639 		{

   640    		INFO_PRINTF1(_L("TestZlibversion():"));

   641    		err = TestZlibversion();

   642    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   643    		}

   644    else if(TestStepName() == KtestGzputc)

   645 		{

   646    		INFO_PRINTF1(_L("TestGzputc():"));

   647    		err = TestGzputc();

   648    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   649    		}		

   650    	else if(TestStepName() == KtestGzopen)

   651 		{

   652    		INFO_PRINTF1(_L("TestGzopen():"));

   653    		err = TestGzopen();

   654    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   655    		}	

   656    	else if(TestStepName() == KtestGzopenmode)

   657 		{

   658    		INFO_PRINTF1(_L("TestGzopenmode():"));

   659    		err = TestGzopenmode();

   660    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   661    		}

   662    	else if(TestStepName() == KtestGzopenfail)

   663 		{

   664    		INFO_PRINTF1(_L("TestGzopenfail():"));

   665    		err = TestGzopenfail();

   666    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   667    		}	

   668    	else if(TestStepName() == KtestGzputcfail)

   669 		{

   670    		INFO_PRINTF1(_L("TestGzputcfail():"));

   671    		err = TestGzputcfail();

   672    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   673    		}

   674    	else if(TestStepName() == KtestGzputcreturn)

   675 		{

   676    		INFO_PRINTF1(_L("TestGzputcreturn():"));

   677    		err = TestGzputcreturn();

   678    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   679    		}	

   680    	else if(TestStepName() == KtestGzputs)

   681 		{

   682    		INFO_PRINTF1(_L("TestGzputs():"));

   683    		err = TestGzputs();

   684    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   685    		}	

   686    	else if(TestStepName() == KtestGzputsfail)

   687 		{

   688    		INFO_PRINTF1(_L("TestGzputsfail():"));

   689    		err = TestGzputsfail();

   690    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   691    		}	

   692    	else if(TestStepName() == KtestGzprintf)

   693 		{

   694    		INFO_PRINTF1(_L("TestGzprintf():"));

   695    		err = TestGzprintf();

   696    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   697    		}		

   698    	else if(TestStepName() == KtestGzprintf_trying)

   699 		{

   700    		INFO_PRINTF1(_L("TestGzprintf_trying():"));

   701    		err = TestGzprintf_trying();

   702    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   703    		}

   704    	else if(TestStepName() == KtestGzwrite)

   705 		{

   706    		INFO_PRINTF1(_L("TestGzwrite():"));

   707    		err = TestGzwrite();

   708    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   709    		}	

   710    	else if(TestStepName() == KtestGzwritefail)

   711 		{

   712    		INFO_PRINTF1(_L("TestGzwritefail():"));

   713    		err = TestGzwritefail();

   714    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   715    		}

   716    	else if(TestStepName() == KtestGztell)

   717 		{

   718    		INFO_PRINTF1(_L("TestGztell():"));

   719    		err = TestGztell();

   720    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   721    		}	

   722    	else if(TestStepName() == KtestGztell1)

   723 		{

   724    		INFO_PRINTF1(_L("TestGztell1():"));

   725    		err = TestGztell1();

   726    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   727    		}	

   728    	else if(TestStepName() == KtestGztellfail1)

   729 		{

   730    		INFO_PRINTF1(_L("TestGztellfail1():"));

   731    		err = TestGztellfail1();

   732    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   733    		}

   734    	else if(TestStepName() == KtestDeflatecopy)

   735 		{

   736    		INFO_PRINTF1(_L("TestDeflatecopy():"));

   737    		err = TestDeflatecopy();

   738    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   739    		}	

   740    	else if(TestStepName() == KtestDeflatecopyfail)

   741 		{

   742    		INFO_PRINTF1(_L("TestDeflatecopyfail():"));

   743    		err = TestDeflatecopyfail();

   744    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   745    		}	

   746    	else if(TestStepName() == KtestGzclose)

   747 		{

   748    		INFO_PRINTF1(_L("TestGzclose():"));

   749    		err = TestGzclose();

   750    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   751    		}	

   752    	else if(TestStepName() == KtestGzclose_fail)

   753 		{

   754    		INFO_PRINTF1(_L("TestGzclose_fail():"));

   755    		err = TestGzclose_fail();

   756    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   757    		}

   758    	else if(TestStepName() == KtestGzeof)

   759 		{

   760    		INFO_PRINTF1(_L("TestGzeof():"));

   761    		err = TestGzeof();

   762    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   763    		}	

   764    	else if(TestStepName() == KtestGzeoffail1)

   765 		{

   766    		INFO_PRINTF1(_L("TestGzeoffail1():"));

   767    		err = TestGzeoffail1();

   768    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   769    		}	

   770    	else if(TestStepName() == KtestGzeoffail2)

   771 		{

   772    		INFO_PRINTF1(_L("TestGzeoffail2():"));

   773    		err = TestGzeoffail2();

   774    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   775    		}				

   776    	else if(TestStepName() == KtestGzgetc)

   777 		{

   778    		INFO_PRINTF1(_L("TestGzgetc():"));

   779    		err = TestGzgetc();

   780    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   781    		}

   782    	else if(TestStepName() == KtestGzflush)

   783 		{

   784    		INFO_PRINTF1(_L("TestGzflush():"));

   785    		err = TestGzflush();

   786    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   787    		}

   788    	else if(TestStepName() == KtestGzflushsync)

   789 		{

   790    		INFO_PRINTF1(_L("TestGzflushsync():"));

   791    		err = TestGzflushsync();

   792    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   793    		}

   794    	else if(TestStepName() == KtestGzflushfail)

   795 		{

   796    		INFO_PRINTF1(_L("TestGzflushfail():"));

   797    		err = TestGzflushfail();

   798    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   799    		}	

   800    	else if(TestStepName() == KtestGzerror)

   801 		{

   802    		INFO_PRINTF1(_L("TestGzerror():"));

   803    		err = TestGzerror();

   804    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   805    		}	

   806    	else if(TestStepName() == KtestGzerrorfail1)

   807 		{

   808    		INFO_PRINTF1(_L("TestGzerrorfail1():"));

   809    		err = TestGzerrorfail1();

   810    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   811    		}

   812    	else if(TestStepName() == KtestGzgetcfail)

   813 		{

   814    		INFO_PRINTF1(_L("TestGzgetcfail():"));

   815    		err = TestGzgetcfail();

   816    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   817    		}	

   818    	else if(TestStepName() == KtestDeflateSetDictionary)

   819 		{

   820    		INFO_PRINTF1(_L("TestDeflateSetDictionary():"));

   821    		err = TestDeflateSetDictionary();

   822    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   823    		}	

   824    	else if(TestStepName() == KtestDeflateSetDictionary_nodict)

   825 		{

   826    		INFO_PRINTF1(_L("TestDeflateSetDictionary_nodict():"));

   827    		err = TestDeflateSetDictionary_nodict();

   828    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   829    		}

   830    	else if(TestStepName() == KtestDeflateSetDictionary_fail)

   831 		{

   832    		INFO_PRINTF1(_L("TestDeflateSetDictionary_fail():"));

   833    		err = TestDeflateSetDictionary_fail();

   834    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   835    		}	

   836    	else if(TestStepName() == KtestDeflateend)

   837 		{

   838    		INFO_PRINTF1(_L("TestDeflateend():"));

   839    		err = TestDeflateend();

   840    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   841    		}

   842    	else if(TestStepName() == KtestDeflateendfail1)

   843 		{

   844    		INFO_PRINTF1(_L("TestDeflateendfail1():"));

   845    		err = TestDeflateendfail1();

   846    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   847    		}	

   848    	else if(TestStepName() == KtestDeflate)

   849 		{

   850    		INFO_PRINTF1(_L("TestDeflate():"));

   851    		err = TestDeflate();

   852    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   853    		}	

   854    	else if(TestStepName() == KtestGzseek)

   855 		{

   856    		INFO_PRINTF1(_L("TestGzseek():"));

   857    		err = TestGzseek();

   858    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   859    		}

   860    	else if(TestStepName() == KtestGzseekfail1)

   861 		{

   862    		INFO_PRINTF1(_L("TestGzseekfail1():"));

   863    		err = TestGzseekfail1();

   864    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   865    		}	

   866    	else if(TestStepName() == KtestGzseekfail2)

   867 		{

   868    		INFO_PRINTF1(_L("TestGzseekfail2():"));

   869    		err = TestGzseekfail2();

   870    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   871    		}	

   872    	else if(TestStepName() == KtestGzsetparams)

   873 		{

   874    		INFO_PRINTF1(_L("TestGzsetparams():"));

   875    		err = TestGzsetparams();

   876    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   877    		}

   878    	else if(TestStepName() == KtestGzsetparams_fail1)

   879 		{

   880    		INFO_PRINTF1(_L("TestGzsetparams_fail1():"));

   881    		err = TestGzsetparams_fail1();

   882    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   883    		}	

   884    	else if(TestStepName() == KtestGzsetparams_fail2)

   885 		{

   886    		INFO_PRINTF1(_L("TestGzsetparams_fail2():"));

   887    		err = TestGzsetparams_fail2();

   888    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   889    		}	

   890    	else if(TestStepName() == KtestGzsetparams_fail3)

   891 		{

   892    		INFO_PRINTF1(_L("TestGzsetparams_fail3():"));

   893    		err = TestGzsetparams_fail3();

   894    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   895    		}	

   896    	else if(TestStepName() == KtestGzrewind)

   897 		{

   898    		INFO_PRINTF1(_L("TestGzrewind():"));

   899    		err = TestGzrewind();

   900    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   901    		}	

   902    	else if(TestStepName() == KtestGzrewindfail)

   903 		{

   904    		INFO_PRINTF1(_L("TestGzrewindfail():"));

   905    		err = TestGzrewindfail();

   906    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   907    		}	

   908    	else if(TestStepName() == KtestGzdopen)

   909 		{

   910    		INFO_PRINTF1(_L("TestGzdopen():"));

   911    		err = TestGzdopen();

   912    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   913    		}

   914    	else if(TestStepName() == KtestGzdopen_fail)

   915 		{

   916    		INFO_PRINTF1(_L("TestGzdopen_fail():"));

   917    		err = TestGzdopen_fail();

   918    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   919    		}

   920    	else if(TestStepName() == KtestGzdopen_fail2)

   921 		{

   922    		INFO_PRINTF1(_L("TestGzdopen_fail2():"));

   923    		err = TestGzdopen_fail2();

   924    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   925    		}

   926    	else if(TestStepName() == KtestInflateSync)

   927 		{

   928    		INFO_PRINTF1(_L("TestInflateSync():"));

   929    		err = TestInflateSync();

   930    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   931    		}	

   932    	else if(TestStepName() == KtestinflateSyncfail)

   933 		{

   934    		INFO_PRINTF1(_L("TestinflateSyncfail():"));

   935    		err = TestinflateSyncfail();

   936    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   937    		}

   938    	else if(TestStepName() == KtestInflateSyncPoint)

   939 		{

   940    		INFO_PRINTF1(_L("TestInflateSyncPoint():"));

   941    		err = TestInflateSyncPoint();

   942    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   943    		}	

   944    	else if(TestStepName() == KtestInflateSyncPoint_null)

   945 		{

   946    		INFO_PRINTF1(_L("TestInflateSyncPoint_null():"));

   947    		err = TestInflateSyncPoint_null();

   948    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   949    		}

   950    	else if(TestStepName() == KtestZerror)

   951 		{

   952    		INFO_PRINTF1(_L("TestZerror():"));

   953    		err = TestZerror();

   954    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   955    		}	

   956    	else if(TestStepName() == KtestZerror1)

   957 		{

   958    		INFO_PRINTF1(_L("TestZerror1():"));

   959    		err = TestZerror1();

   960    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   961    		}		

   962    	else if(TestStepName() == KtestZerror2)

   963 		{

   964    		INFO_PRINTF1(_L("TestZerror2():"));

   965    		err = TestZerror2();

   966    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   967    		}				//END testcases of tzlib_auto.cpp

   968    	

   969    	// BEGIN testcases of tzlibblocks.cpp

   970    	else if(TestStepName() == KTestDeflateTest01)

   971 		{

   972    		INFO_PRINTF1(_L("TestDeflateTest01():"));

   973    		err = TestDeflateTest01();

   974    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   975    		}

   976    	else if(TestStepName() == KTestDeflatecopyDestNull)

   977 		{

   978    		INFO_PRINTF1(_L("TestDeflatecopyDestNull():"));

   979    		err = TestDeflatecopyDestNull();

   980    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   981    		}

   982    	else if(TestStepName() == KTestDeflateCopyStreamStateNull)

   983 		{

   984    		INFO_PRINTF1(_L("TestDeflateCopyStreamStateNull():"));

   985    		err = TestDeflateCopyStreamStateNull();

   986    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   987    		}

   988    	else if(TestStepName() == KTestDeflateInit2_WindowBits)

   989 		{

   990    		INFO_PRINTF1(_L("TestDeflateInit2_WindowBits():"));

   991    		err = TestDeflateInit2_WindowBits();

   992    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   993    		}

   994    	else if(TestStepName() == KTestDeflateInit2_StreamSize)

   995 		{

   996    		INFO_PRINTF1(_L("TestDeflateInit2_StreamSize():"));

   997    		err = TestDeflateInit2_StreamSize();

   998    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   999    		}

  1000    	else if(TestStepName() == KTestDeflateInit2_MemLevel)

  1001 		{

  1002    		INFO_PRINTF1(_L("TestDeflateInit2_MemLevel():"));

  1003    		err = TestDeflateInit2_MemLevel();

  1004    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1005    		}

  1006    	else if(TestStepName() == KTestDeflateInit2_Level)

  1007 		{

  1008    		INFO_PRINTF1(_L("TestDeflateInit2_Level():"));

  1009    		err = TestDeflateInit2_Level();

  1010    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1011    		}

  1012    	else if(TestStepName() == KTestDeflateInit2_Strategy)

  1013 		{

  1014    		INFO_PRINTF1(_L("TestDeflateInit2_Strategy():"));

  1015    		err = TestDeflateInit2_Strategy();

  1016    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1017    		}

  1018    	else if(TestStepName() == KTestDeflateInit2_Version)

  1019 		{

  1020    		INFO_PRINTF1(_L("TestDeflateInit2_Version():"));

  1021    		err = TestDeflateInit2_Version();

  1022    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1023    		}

  1024    	else if(TestStepName() == KTestDeflateInit2_VersionNull)

  1025 		{

  1026    		INFO_PRINTF1(_L("TestDeflateInit2_VersionNull():"));

  1027    		err = TestDeflateInit2_VersionNull();

  1028    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1029    		}

  1030    	else if(TestStepName() == KTestDeflateInit2_StreamNull)

  1031 		{

  1032    		INFO_PRINTF1(_L("TestDeflateInit2_StreamNull():"));

  1033    		err = TestDeflateInit2_StreamNull();

  1034    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1035    		}

  1036    	else if(TestStepName() == KTestInflateInit2_Version)

  1037 		{

  1038    		INFO_PRINTF1(_L("TestInflateInit2_Version():"));

  1039    		err = TestInflateInit2_Version();

  1040    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1041    		}

  1042    	else if(TestStepName() == KTestInflateInit2_VersionNull)

  1043 		{

  1044    		INFO_PRINTF1(_L("TestInflateInit2_VersionNull():"));

  1045    		err = TestInflateInit2_VersionNull();

  1046    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1047    		}

  1048    	else if(TestStepName() == KTestInflateInit2_WindowBits)

  1049 		{

  1050    		INFO_PRINTF1(_L("TestInflateInit2_WindowBits():"));

  1051    		err = TestInflateInit2_WindowBits();

  1052    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1053    		}

  1054    	else if(TestStepName() == KTestInflateInit2_StreamNull)

  1055 		{

  1056    		INFO_PRINTF1(_L("TestInflateInit2_StreamNull():"));

  1057    		err = TestInflateInit2_StreamNull();

  1058    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1059    		}

  1060    	else if(TestStepName() == KTestDeflate_HuffmanStrategy)

  1061 		{

  1062    		INFO_PRINTF1(_L("TestDeflate_HuffmanStrategy():"));

  1063    		err = TestDeflate_HuffmanStrategy();

  1064    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1065    		}

  1066    	else if(TestStepName() == KTestDeflate_AvailInZero)

  1067 		{

  1068    		INFO_PRINTF1(_L("TestDeflate_AvailInZero():"));

  1069    		err = TestDeflate_AvailInZero();

  1070    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1071    		}

  1072    	else if(TestStepName() == KTestGzsetparamDefaultCompression)

  1073 		{

  1074    		INFO_PRINTF1(_L("TestGzsetparamDefaultCompression():"));

  1075    		err = TestGzsetparamDefaultCompression();

  1076    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1077    		}

  1078    	else if(TestStepName() == KTestDeflateResetNullStream)

  1079 		{

  1080    		INFO_PRINTF1(_L("TestDeflateResetNullStream():"));

  1081    		err = TestDeflateResetNullStream();

  1082    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1083    		}

  1084    	else if(TestStepName() == KTestDeflateResetStreamStateNull)

  1085 		{

  1086    		INFO_PRINTF1(_L("TestDeflateResetStreamStateNull():"));

  1087    		err = TestDeflateResetStreamStateNull();

  1088    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1089    		}

  1090    	else if(TestStepName() == KTestDeflate_Scenarios)

  1091 		{

  1092    		INFO_PRINTF1(_L("TestDeflate_Scenarios():"));

  1093    		err = TestDeflate_Scenarios();

  1094    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1095    		}

  1096    	else if(TestStepName() == KTestDeflate_NullStream)

  1097 		{

  1098    		INFO_PRINTF1(_L("TestDeflate_NullStream():"));

  1099    		err = TestDeflate_NullStream();

  1100    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1101    		}

  1102    	else if(TestStepName() == KTestDeflate_StreamStateNull)

  1103 		{

  1104    		INFO_PRINTF1(_L("TestDeflate_StreamStateNull():"));

  1105    		err = TestDeflate_StreamStateNull();

  1106    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1107    		}

  1108    	else if(TestStepName() == KTestDeflateEndNull)

  1109 		{

  1110    		INFO_PRINTF1(_L("TestDeflateEndNull():"));

  1111    		err = TestDeflateEndNull();

  1112    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1113    		}

  1114    	else if(TestStepName() == KTestDeflateEndStreamStateNull)

  1115 		{

  1116    		INFO_PRINTF1(_L("TestDeflateEndStreamStateNull():"));

  1117    		err = TestDeflateEndStreamStateNull();

  1118    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1119    		}

  1120    	else if(TestStepName() == KTestDeflate_WindowBits)

  1121 		{

  1122    		INFO_PRINTF1(_L("TestDeflate_WindowBits():"));

  1123    		err = TestDeflate_WindowBits();

  1124    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1125    		}

  1126    	else if(TestStepName() == KTestDeflateBoundStreamNotNull)

  1127 		{

  1128    		INFO_PRINTF1(_L("TestDeflateBoundStreamNotNull():"));

  1129    		err = TestDeflateBoundStreamNotNull();

  1130    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

  1131    		}

  1132    	else if(TestStepName() == KTestDeflateBoundStreamNull)

  1133 		{

  1134    		INFO_PRINTF1(_L("TestDeflateBoundStreamNull():"));

  1135    		err = TestDeflateBoundStreamNull();