MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/ossrv/lowlevellibsandfws/pluginfw/TestExecute/EComSWITests/src/checkPlugin.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 // Copyright (c) 2006-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 // This File Provides implementations of CCheckListImplementation, which Checks the plugin for availble implementation

    15 // and CCheckCreateImplementation, which uses the method provided the ECom Plugin.

    16 // 

    17 //

    18 

    19 /**

    20  @file

    21 */

    22 

    23 #include <ecom/resolver.h>

    24 #include "checkPlugin.h"

    25 

    26 

    27 CCheckListImplementation::~CCheckListImplementation()

    28 	{

    29 	}

    30 

    31 

    32 CCheckListImplementation::CCheckListImplementation(TOperationType aOperationType)

    33 	: iOperationType(aOperationType)

    34 	{

    35     SetTestStepName(KListImplUidStep);

    36 	}

    37 	

    38 	

    39 	

    40 TVerdict CCheckListImplementation::doTestStepPreambleL()

    41     {

    42     SetTestStepResult(EPass);

    43     // get step parameters

    44 	

    45     TInt tempInterfaceuid=0;

    46  

    47     if (!GetHexFromConfig(ConfigSection(), KInterfaceUID, tempInterfaceuid))

    48 		{

    49 		INFO_PRINTF1(HTML_RED);

    50         ERR_PRINTF1(_L("FAIL: Missing Interface UID"));

    51         INFO_PRINTF1(HTML_RED_OFF);

    52         SetTestStepResult(EFail);

    53         return TestStepResult();

    54 		}    

    55 		

    56 	 iInterfaceUid.iUid = tempInterfaceuid;

    57 	  

    58     return TestStepResult();

    59 	}

    60     

    61     

    62     

    63 TVerdict CCheckListImplementation::doTestStepL()

    64     {

    65  	__UHEAP_MARK; 

    66   	

    67   	//First find out if the Check Plugin step is supposed to be successful.

    68   	TInt testStepOutcome=KErrNone;

    69   	TInt err = GetIntFromConfig(ConfigSection(), KExpectedErrorCheckPlugin, testStepOutcome);

    70   	if(err !=1) testStepOutcome=KErrNone;

    71 

    72 	

    73 	// and leaking thread handles

    74 	TInt startProcessHandleCount;

    75 	TInt startThreadHandleCount;

    76 	TInt endProcessHandleCount;

    77 	TInt endThreadHandleCount;

    78 	

    79 	RThread thisThread;

    80 	thisThread.HandleCount(startProcessHandleCount, startThreadHandleCount);

    81 

    82    

    83     switch (iOperationType)

    84         {

    85         case EUseListImplUid:

    86           	{

    87           	        	

    88 	        REComSession::ListImplementationsL(iInterfaceUid, iImplyArrayPtr);

    89           	

    90           	TInt eImplCount(0);   

    91     		iImplCount = iImplyArrayPtr.Count();

    92 

    93 	    	if(!GetIntFromConfig(ConfigSection(), KExpectedCount, eImplCount))

    94           		{

    95           		INFO_PRINTF1(HTML_RED);

    96 		        ERR_PRINTF1(_L("FAIL: Missing Implementation Count in the INI File"));

    97 		        INFO_PRINTF1(HTML_RED_OFF);

    98 		        SetTestStepResult(EFail);

    99 		        return TestStepResult();

   100                	}

   101 

   102           	if(eImplCount != iImplCount)

   103           		{

   104           		INFO_PRINTF1(HTML_RED);

   105 		       	ERR_PRINTF3( _L("The number Implemenation(s) in this ECom plugin do not match, expected %d implementation(s), got %d implementation(s)."), eImplCount, iImplCount );

   106         		INFO_PRINTF1(HTML_RED_OFF);

   107 		        SetTestStepResult(EFail);

   108 		        return TestStepResult();

   109           		}

   110 

   111           	//Ensuring that the ECom Plugin does have Implementations

   112 	   		if( iImplCount > 0 && testStepOutcome == KErrNone)

   113 	          	{

   114 	          	TInt arrayIndex(0);

   115 	          	//Checking Implementation UID

   116          		TUid eImplUid = KNullUid;

   117 		        TInt tempImplUid(0);

   118 		        

   119 		        if (!GetHexFromConfig(ConfigSection(), KImplUID, tempImplUid))

   120 					{

   121 					INFO_PRINTF1(HTML_RED);

   122 		        	ERR_PRINTF1(_L("FAIL: Missing Implementtaion UID"));

   123 		        	INFO_PRINTF1(HTML_RED_OFF);

   124 		        	SetTestStepResult(EFail);

   125 		        	return TestStepResult();

   126 					}

   127 						

   128 				eImplUid.iUid = tempImplUid;

   129 				

   130 	          	TBool foundImplementationUid(EFalse);

   131 		          			          	

   132 		        for(TInt i = 0; (i < iImplCount)  && !(foundImplementationUid); i++)

   133 		        	{

   134 		          	iImplUid = iImplyArrayPtr[i]->ImplementationUid();

   135 		          		

   136 		          	if(eImplUid == iImplUid)

   137 		          		{

   138 		          		foundImplementationUid = ETrue;

   139 		          		arrayIndex = i;

   140 		          		}

   141 	       			}

   142 		          	

   143 	          	if(eImplUid != iImplUid)

   144 	          		{

   145 	          		INFO_PRINTF1(HTML_RED);

   146 			       	ERR_PRINTF3( _L("The Implemenation UID  in this ECom plugin do not match, expected  %d Implementation UID  , got %d iImplementation UID."), eImplUid, iImplUid );

   147 	        		INFO_PRINTF1(HTML_RED_OFF);

   148 			        SetTestStepResult(EFail);

   149 			        return TestStepResult();

   150 	          		}

   151 		  		

   152 		  		//Checking Implementation's Version Numbers

   153 	          	TInt eVersion(0);

   154 	          		          	

   155 		        if (!GetIntFromConfig(ConfigSection(), KExpectedVersion, eVersion))

   156 		           	{

   157 		         	INFO_PRINTF1(HTML_RED);

   158 				    ERR_PRINTF1(_L("FAIL: Missing Version Number in the INI File"));

   159 				    INFO_PRINTF1(HTML_RED_OFF);

   160 				    SetTestStepResult(EFail);

   161 				    return TestStepResult();

   162 		            }

   163 		            

   164 				iVersion = iImplyArrayPtr[arrayIndex]->Version();

   165 		            

   166 		     	if(eVersion != iVersion)

   167 		         	{

   168 		          	INFO_PRINTF1(HTML_RED);

   169 				   	ERR_PRINTF3( _L("The ECom plugin's implementation versions  do not match, expected %d version, got %d version."), eVersion, iVersion );

   170 		        	INFO_PRINTF1(HTML_RED_OFF);

   171 				    SetTestStepResult(EFail);

   172 				    return TestStepResult();

   173 		          	}

   174 		          	

   175 		          	

   176 		        //Checking Implementation's Drive Letter

   177 		        TDriveUnit eDrive;

   178 		        TPtrC tempDrive;

   179 		        

   180 	        	iDrive = iImplyArrayPtr[arrayIndex]->Drive();

   181 		         

   182 		    	if (!GetStringFromConfig(ConfigSection(), KExpectedDrive, tempDrive))

   183 		           	{

   184 		         	INFO_PRINTF1(HTML_RED);

   185 				    ERR_PRINTF1(_L("FAIL: Missing Plugin Drive Letter in the INI File"));

   186 				    INFO_PRINTF1(HTML_RED_OFF);

   187 				    SetTestStepResult(EFail);

   188 				    return TestStepResult();

   189 		        	}

   190 		          	

   191 		        eDrive = tempDrive;

   192 		        		        

   193 		     	if(eDrive!= iDrive)

   194 		        	{

   195 		        	TPtrC eDrv(eDrive.Name());

   196 			        TPtrC iDrv(iDrive.Name());

   197 		        	INFO_PRINTF1(HTML_RED);

   198 				   	ERR_PRINTF3( _L("The ECom plugin's drive letters do not match, expected %S drive, got %S drive."), &eDrv, &iDrv);

   199 				   	INFO_PRINTF1(HTML_RED_OFF);

   200 				    SetTestStepResult(EFail);

   201 				    return TestStepResult();

   202 		        	}

   203 		          	

   204 		        //Checking Implementation's Vendor ID

   205 		        TInt tempVendorID(0);

   206 		        TUid eVendorID = KNullUid; 

   207 								

   208 		        iVendorID = iImplyArrayPtr[arrayIndex]->VendorId();

   209 				  	    		

   210 	    		if (!GetHexFromConfig(ConfigSection(), KExpectedVendorID, tempVendorID))

   211 	    			{

   212 					INFO_PRINTF1(HTML_RED);

   213 			        ERR_PRINTF1(_L("FAIL: Missing vendor UID In the INI File"));

   214 			        INFO_PRINTF1(HTML_RED_OFF);

   215 			        SetTestStepResult(EFail);

   216 			        return TestStepResult();

   217 					}    

   218 		    		

   219 		    	eVendorID.iUid = tempVendorID;

   220 		    		

   221 		    		if(eVendorID != iVendorID)

   222 		          		{

   223 		          		INFO_PRINTF1(HTML_RED);

   224 				       	ERR_PRINTF3( _L("The ECom Vendor IDs do not match, expected %d VID, got %d VID."), eVendorID, iVendorID );

   225 		        		INFO_PRINTF1(HTML_RED_OFF);

   226 				        SetTestStepResult(EFail);

   227 				        return TestStepResult();

   228 		          		}

   229 		          

   230 	          	}

   231 	          		

   232 	          else

   233 	          	{

   234 	          	INFO_PRINTF1(HTML_RED);

   235 	          	INFO_PRINTF2(_L("This is a Negative test whose expected outcome is %d "), testStepOutcome);

   236 	          	INFO_PRINTF1(HTML_RED_OFF);         	

   237 	          	}

   238           	

   239            	}

   240      

   241         }

   242     

   243    	//Reseting The ECOM Array

   244    	iImplyArrayPtr.ResetAndDestroy();     

   245    	

   246    	//Closing session with ECom Server

   247     REComSession::FinalClose();

   248     

   249    	thisThread.HandleCount(endProcessHandleCount, endThreadHandleCount);

   250  

   251  	if(startThreadHandleCount != endThreadHandleCount)

   252  		{

   253  		INFO_PRINTF1(HTML_RED);

   254 		ERR_PRINTF1( _L("There is a memory leak as the number of thread handles open at the start do not equal the number of handles opened at the end."));

   255         ERR_PRINTF3(_L("At the start there %d handles open and the end there are %d"), startThreadHandleCount, endThreadHandleCount);

   256         INFO_PRINTF1(HTML_RED_OFF);

   257 		SetTestStepResult(EFail);

   258 		return TestStepResult();

   259  		}

   260  

   261     thisThread.Close();

   262     __UHEAP_MARKEND;    

   263 	

   264 	return TestStepResult();

   265 	}

   266     

   267 

   268 

   269 

   270 

   271 TVerdict CCheckListImplementation::doTestStepPostambleL()

   272 	{

   273 	 return TestStepResult();

   274 	}

   275 

   276 

   277 

   278 

   279 CCheckCreateImplementation::CCheckCreateImplementation(TOperationType aOperationType)

   280 	: iOperationType(aOperationType)

   281 	{

   282     SetTestStepName(KCreateImpl_ImpId_DtorId_Step);

   283 	}

   284 

   285 TVerdict CCheckCreateImplementation::doTestStepPreambleL()

   286     {

   287     SetTestStepResult(EPass);

   288    

   289    TInt tempImplUid=0;

   290    

   291     if (!GetHexFromConfig(ConfigSection(), KImplUID, tempImplUid))

   292 		{

   293 		INFO_PRINTF1(HTML_RED);

   294         ERR_PRINTF1(_L("FAIL: Missing Implementation UID"));

   295         INFO_PRINTF1(HTML_RED_OFF);

   296         SetTestStepResult(EFail);

   297         return TestStepResult();

   298 		}    

   299 		

   300 	iImplUid.iUid = tempImplUid;

   301 

   302     return TestStepResult();

   303 	}

   304 

   305 

   306 TVerdict CCheckCreateImplementation::doTestStepL()

   307  	{

   308  	__UHEAP_MARK; 

   309 	

   310 	

   311 	// Check for Memory leaks and also leaking thread handles

   312 	TInt startProcessHandleCount;

   313 	TInt startThreadHandleCount;

   314 	TInt endProcessHandleCount;

   315 	TInt endThreadHandleCount;

   316 	

   317 	RThread thisThread;

   318 	thisThread.HandleCount(startProcessHandleCount, startThreadHandleCount);

   319 

   320 		

   321 	TInt eInt(0);

   322 	

   323 	CEComSwiPluginInterfaceDefiniton* iPluginPtr = CEComSwiPluginInterfaceDefiniton::NewL(iImplUid);

   324 	

   325 	iPluginPtr->ReturnInt(iInt);

   326 	

   327 	

   328 	 if (!GetIntFromConfig(ConfigSection(), KExpectedPluginInt, eInt))

   329        	{

   330      	INFO_PRINTF1(HTML_RED);

   331 	    ERR_PRINTF1(_L("FAIL: Missing ReturnInt value Number in the INI File"));

   332 	    INFO_PRINTF1(HTML_RED_OFF);

   333 	    SetTestStepResult(EFail);

   334 	    return TestStepResult();

   335         }

   336         

   337         

   338       if(eInt != iInt)

   339   		{

   340   		INFO_PRINTF1(HTML_RED);

   341        	ERR_PRINTF3(_L("The values returned from the Plugins ReturnInt() do not match, expected Int Value %d, got %d."), eInt, iInt);

   342 		INFO_PRINTF1(HTML_RED_OFF);

   343         SetTestStepResult(EFail);

   344         return TestStepResult();

   345   		}

   346 

   347   	delete iPluginPtr;		

   348 

   349     REComSession::FinalClose();   

   350 

   351 	thisThread.HandleCount(endProcessHandleCount, endThreadHandleCount);

   352  

   353  	if(startThreadHandleCount != endThreadHandleCount)

   354  		{

   355  		INFO_PRINTF1(HTML_RED);

   356 		ERR_PRINTF1( _L("There is a memory leak as the number of thread handles open at the start do not equal the number of handles opened at the end."));

   357         ERR_PRINTF3(_L("At the start there %d handles open and the end there are %d"), startThreadHandleCount, endThreadHandleCount);

   358         INFO_PRINTF1(HTML_RED_OFF);

   359 		SetTestStepResult(EFail);

   360 		return TestStepResult();

   361  		}

   362  

   363     thisThread.Close();

   364 

   365     __UHEAP_MARKEND;    

   366 	

   367 	return TestStepResult();

   368 	}

   369 

   370 

   371 

   372 TVerdict CCheckCreateImplementation::doTestStepPostambleL()

   373 	{

   374 	 return TestStepResult();

   375 	}

   376 

   377 CCheckCreateImplementation::~CCheckCreateImplementation()

   378 	{

   379 	}

   380 

   381 /** Test step to issue a custom resolver list request so that

   382 the resolver is cached. */

   383 

   384 // constructor

   385 CUseCustomResolver::CUseCustomResolver()

   386 	{

   387     SetTestStepName(KUseCustomResolverStep);

   388 	}

   389 

   390 // destructor

   391 CUseCustomResolver::~CUseCustomResolver()

   392 	{

   393 	}

   394 

   395 // doTestStepL

   396 TVerdict CUseCustomResolver::doTestStepL()

   397 	{

   398 	TUid resolverUid = KNullUid;

   399 	TInt tempImplUid(0);

   400 	TESTL(GetHexFromConfig(ConfigSection(), KImplUID, tempImplUid));

   401 

   402 	resolverUid.iUid = tempImplUid;

   403 	TEComResolverParams resolverparams;

   404 	_LIT8(KDummyData,"dummy");

   405 	resolverparams.SetDataType(KDummyData);

   406 	RImplInfoPtrArray ifArray;

   407 	TRAPD(err, REComSession::ListImplementationsL(KCustomResolverInterfaceUid,

   408 		resolverparams, resolverUid, ifArray) );

   409 	if (err != KErrNone)

   410 		{

   411 		// In particular looking for KEComErrMismatchedTags

   412         INFO_PRINTF1(HTML_RED);

   413 		ERR_PRINTF2( _L("Custom Resolver list request failed with %d"), err);

   414         INFO_PRINTF1(HTML_RED_OFF);

   415 		SetTestStepResult(EFail);

   416 		return EFail;

   417 		}

   418 

   419 	_LIT(KExpectedVersion, "expectedversion");

   420 	TInt expectedVersion;

   421   	if (GetIntFromConfig(ConfigSection(), KExpectedVersion, expectedVersion))

   422 		{

   423 		for (TInt i = 0; i < ifArray.Count(); i++)

   424 			{

   425 			const CImplementationInformation& impl = *ifArray[i];

   426 			if (impl.ImplementationUid() == resolverUid)

   427 				{

   428 				if (impl.Version() !=  expectedVersion)

   429 					{

   430 					INFO_PRINTF1(HTML_RED);

   431 					ERR_PRINTF3( _L("Expecting ver %d, got %d"), expectedVersion, impl.Version());

   432 					INFO_PRINTF1(HTML_RED_OFF);

   433 					SetTestStepResult(EFail);

   434 					}

   435 				break;

   436 				}

   437 			}

   438 		}

   439 	ifArray.ResetAndDestroy();

   440     REComSession::FinalClose();

   441 	return TestStepResult();

   442 	}
Symaptic