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 //

    15 

    16 /**

    17 @SYMTestCaseID      PIM-APPENG-CNTM-CNTDB-106281-0001

    18 @SYMTestCaseDesc    The purpose of this test is to verify the expected behaviour

    19                     of the CContactDatabase public APIs involving invalid database

    20                     file paths (eg. string length exceeds 190 characters,

    21                     and string containing path characters)

    22 @SYMTestActions     Passing an empty string, a string with more than 190 characters,

    23                     and a string containing path into CContactDatabase's public APIs and

    24                     verify if the expected error code is returned

    25 @SYMTestExpectedResults     Expected all test cases to pass.

    26 @SYMDEF                     DEF106281

    27 @SYMTestType                UT

    28 @SYMTestPriority            Low

    29 */

    30 

    31 #include <cntdb.h>

    32 #include "CCntIpcCodes.h"

    33 #include "t_dbnametest.h"

    34 

    35 //===========================================================

    36 // CDbNameTest Class

    37 //===========================================================

    38 CDbNameTest::~CDbNameTest()

    39     {

    40     iLongDbName.Close();

    41     iInvalidDbName.Close();

    42 

    43     if (iActiveSchedulerWait)

    44         {

    45         if (iActiveSchedulerWait->IsStarted())

    46             {

    47             iActiveSchedulerWait->AsyncStop();

    48             }

    49         delete iActiveSchedulerWait;

    50         }

    51 

    52     iTest->Close();

    53     delete iTest;

    54     }

    55 

    56 CDbNameTest::CDbNameTest()

    57     : CActive(EPriorityStandard)

    58     {

    59     CActiveScheduler::Add(this);

    60     }

    61 

    62 CDbNameTest* CDbNameTest::NewLC()

    63     {

    64     CDbNameTest* self = new (ELeave) CDbNameTest();

    65     CleanupStack::PushL(self);

    66     self->ConstructL();

    67     return self;

    68     }

    69 

    70 void CDbNameTest::ConstructL()

    71     {

    72     iTest = new(ELeave) RTest(_L("T_DBNameTest"));

    73 

    74     // Create invalid DB Name (with wildcard & path characters)

    75     iInvalidDbName.Create(_L("c:**"));

    76     }

    77 

    78 void CDbNameTest::RunTestsL()

    79     {

    80     iTest->Start(_L(" ----------- T_DBNameTest ---------- "));

    81 	

    82 	RArray<TInt> errArray;

    83 	CleanupClosePushL(errArray);

    84 	

    85 	//MaxLength	

    86 	errArray.AppendL(KErrNone);  //Create

    87 	errArray.AppendL(KErrNone);     //Open

    88 	errArray.AppendL(KErrNone); //Replace

    89 	errArray.AppendL(KErrNone);    //Delete

    90 	errArray.AppendL(KErrNone);    //Exists

    91 	SetAndTestFileNameL(EMaxLength, errArray);

    92 	

    93 	//ELessThanMaxLength

    94 	errArray.Reset();	

    95 	errArray.AppendL(KErrNone);  //Create

    96 	errArray.AppendL(KErrNone); //Open

    97 	errArray.AppendL(KErrNone); //Replace

    98 	errArray.AppendL(KErrNone); //Delete

    99 	errArray.AppendL(KErrNone); //Exists

   100 	SetAndTestFileNameL(ELessThanMaxLength, errArray);

   101 

   102 	//ENoDriveName

   103 	errArray.Reset();	

   104 	errArray.AppendL(KErrBadName); //Create

   105 	errArray.AppendL(KErrBadName); //Open

   106 	errArray.AppendL(KErrBadName); //Replace

   107 	errArray.AppendL(KErrBadName); //Delete

   108 	errArray.AppendL(KErrBadName); //Exists

   109 	SetAndTestFileNameL(ENoDriveName, errArray);

   110 		

   111 	//EInvalidFileName

   112 	errArray.Reset();

   113 	errArray.AppendL(KErrBadName); //Create

   114 	errArray.AppendL(KErrBadName); //Open

   115 	errArray.AppendL(KErrBadName); //Replace

   116 	errArray.AppendL(KErrBadName); //Delete

   117 	errArray.AppendL(KErrBadName); //Exists

   118 	SetAndTestFileNameL(EInvalidFileName, errArray);

   119 	

   120 	//ENullFileName	

   121 	errArray.Reset();

   122 	errArray.AppendL(KErrBadName);  //Create

   123 	errArray.AppendL(KErrBadName);  //Open

   124 	errArray.AppendL(KErrBadName);  //Replace

   125 	errArray.AppendL(KErrNotFound); //Delete (expects no default database in the private directory) 

   126 	errArray.AppendL(KErrNone);     //Exists

   127 	//deleting default database if exists.

   128 	TRAP_IGNORE(CContactDatabase::DeleteDatabaseL(KNullDesC));

   129 	SetAndTestFileNameL(ENullFileName, errArray);

   130 	

   131 	//EMoreThanMaxLength

   132 	errArray.Reset();

   133 	errArray.AppendL(KErrArgument); //Create

   134 	errArray.AppendL(KErrArgument); //Open

   135 	errArray.AppendL(KErrArgument); //Replace

   136 	errArray.AppendL(KErrArgument); //Delete

   137 	errArray.AppendL(KErrArgument); //Exists

   138 	SetAndTestFileNameL(EMoreThanMaxLength, errArray);

   139    

   140     CleanupStack::PopAndDestroy(); //Releasing memory used by errArray.

   141     

   142     //EMoreThanMaxLength above creates a filename with length more than allowed length, Test Asyncopendatabasetest

   143     //requires such a file name, so it should be run after above test.

   144   

   145     AsyncOpenDatabaseTest();

   146 

   147     (*iTest) (iFailedTests == 0);

   148 

   149     iTest->End();

   150     }

   151 

   152 

   153 void CDbNameTest::AsyncOpenDatabaseTest()

   154     {

   155     // open database with long path name

   156     iTest->Next(_L("TEST 1: CContactDatabase::Open() with long file name"));

   157 

   158     iCurrName.Set(iLongDbName);

   159 

   160     SetActive();

   161     TRequestStatus* status = &iStatus;

   162     iOpenOp = CContactDatabase::Open(iLongDbName, *status);

   163 

   164     iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait();

   165     iActiveSchedulerWait->Start();

   166     }

   167 

   168 void CDbNameTest::AsyncOpenDatabaseNullTestL()

   169     {

   170     // open database with NULL path name

   171     iTest->Next(_L("TEST 2: CContactDatabase::Open() with NULL file name."));

   172 

   173     iCurrName.Set(KNullDesC);

   174 

   175     SetActive();

   176     TRequestStatus* status = &iStatus;

   177     iOpenOp = CContactDatabase::Open(KNullDesC, *status);

   178     }

   179 

   180 void CDbNameTest::AsyncOpenDatabaseInvalidTest()

   181     {

   182     // open database with invalid path name

   183     iTest->Next(_L("TEST 3: CContactDatabase::Open() with file name containing path or wildcard characters."));

   184 

   185     iCurrName.Set(iInvalidDbName);

   186 

   187     SetActive();

   188     TRequestStatus* status = &iStatus;

   189     iOpenOp = CContactDatabase::Open(iInvalidDbName, *status);

   190     }

   191 

   192 void CDbNameTest::RunL()

   193     {

   194     TInt err = iStatus.Int();

   195 

   196     if (iOpenOp)

   197         {

   198         if (err == KErrNone)

   199             {

   200             // if the database has been successfully opened, close it

   201             CContactDatabase* database = iOpenOp->TakeDatabase();

   202             if (database)

   203                 {

   204                 delete database;

   205                 }

   206             }

   207         delete iOpenOp;

   208         iOpenOp = NULL;

   209         }

   210 

   211     if (iLongDbName == iCurrName)

   212         {

   213         if (err != KErrArgument)

   214             {

   215             iFailedTests++;

   216             iTest->Printf(_L("-> FAILED - invalid error code returned-- %d.\n"), err);

   217             }

   218         

   219         // Proceed to test 2

   220         AsyncOpenDatabaseNullTestL();

   221         }

   222     else if (iCurrName.Length() == 0)

   223         {

   224         // Asyc Open treats a NULL database path as the default database.

   225         // Therefore, both KErrNone, (meaning a default database exists), and 

   226         // KErrNotFound, (meaning the default database not yet exist), are acceptable

   227         // error codes.

   228         if (err != KErrNone && err != KErrNotFound)

   229             {

   230             iFailedTests++;

   231             iTest->Printf(_L("-> FAILED - invalid error code returned-- %d.\n"), err);

   232             }

   233 

   234         // Process to last test

   235         AsyncOpenDatabaseInvalidTest();

   236         }

   237     else

   238         {

   239         if (err != KErrBadName)

   240             {

   241             iFailedTests++;

   242             iTest->Printf(_L("-> FAILED - invalid error code returned-- %d.\n"), err);

   243             }

   244 

   245         iActiveSchedulerWait->AsyncStop();

   246         }

   247     }

   248 

   249 

   250 /**

   251 @SYMTestCaseID      		PIM-DBNAMETEST-0001

   252 @SYMTestCaseDesc    		Attempts to test the behaviour of Contactdatabse API's

   253 							while Opening, Deleting, Creating, Replacing a filename of different types. 

   254 @SYMTestActions     		1)Create a filename, it can be of different types.

   255 							2)Try to perform Create,Open,Delete,Replace on that filename.

   256 							3)Check if it returns a correct errorcode.						

   257 @SYMTestExpectedResults     Expected all test cases to pass.

   258 @SYMDEF                     DEF114180

   259 @SYMTestType                UT

   260 @SYMTestPriority            Low

   261 */

   262     

   263 void CDbNameTest::SetAndTestFileNameL(TFileNameType aType, RArray<TInt>& aErrArray)

   264 	{

   265 	_LIT16(KDrive,"c:");

   266 	

   267 	TBool driveName = ETrue;

   268 	TBool invalidFileName = EFalse;

   269 	TBool createFilename = ETrue;

   270 	TBool nullFilename = EFalse;

   271 	TInt nameLength = 0;

   272 	

   273 	

   274 	switch (aType)

   275 		{

   276 		case ENoDriveName:

   277 			{

   278 			iTest->Next(_L("\n*****Operations without Drive name.*****"));

   279 			nameLength = 50;

   280 			driveName = EFalse;	

   281 			}

   282 		break;

   283 		

   284 		case EMoreThanMaxLength:

   285 			{

   286 			iTest->Next(_L("\n*****Operations with Filename more than maximum allowed length.*****"));

   287 			nameLength = 200;	

   288 			}

   289 		break;

   290 		

   291 		case EMaxLength:

   292 			{

   293 			iTest->Next(_L("\n*****Operations with Filename having maximum allowed length.*****"));

   294 			nameLength = 190;	

   295 			}

   296 		break;

   297 		

   298 		case ELessThanMaxLength:

   299 			{

   300 			iTest->Next(_L("\n*****Operations with Filename length less than maximum allowed length.*****"));

   301 			nameLength = 100;	

   302 			}

   303 		break;

   304 		

   305 		case  EInvalidFileName:

   306 			{

   307 			iTest->Next(_L("\n*****Operations with Invalid Filename.*****"));

   308 			invalidFileName = ETrue;

   309 			createFilename = EFalse;

   310 			driveName = EFalse;

   311 			nameLength = 5;	

   312 			}

   313 		break;

   314 		

   315 		case ENullFileName:

   316 			{

   317 			iTest->Next(_L("\n*****Operations with NULL Filename.*****"));			

   318 			nullFilename = ETrue;

   319 			createFilename = EFalse;

   320 			driveName = EFalse;	

   321 			}

   322 		break;	

   323 		

   324 		default:

   325 		User::Leave(KErrArgument);

   326 		

   327 		}

   328 	

   329 	iLongDbName.Close();

   330 	iLongDbName.CreateL(nameLength);

   331 	

   332 	if(driveName)

   333 		{

   334 		iLongDbName.Append(KDrive);	

   335 		}

   336 	

   337 	if(invalidFileName)

   338 		{

   339 		iLongDbName = iInvalidDbName;	

   340 		}

   341 		

   342 	if(nullFilename)

   343 		{

   344 		iLongDbName.Append(KNullDesC);	

   345 		}

   346 		

   347 	if(createFilename)

   348 		{

   349 	    for (TInt i = 1; i < iLongDbName.MaxLength()-2; i++)

   350 	        {

   351 	        TChar ch('a');

   352 	        ch += i % 26;

   353 	        iLongDbName.Append(ch);

   354 	        }		

   355 		}

   356 

   357 	TInt typeOfTests = 5;

   358  	for(TInt loop = 0;loop < typeOfTests ; ++loop)

   359 	 	{

   360 	 	

   361 	 	CContactDatabase* db = NULL;

   362 	 	

   363 	 	TInt err(0);

   364 	 	

   365 	 	TInt typeOfError(0);

   366 	 	

   367 	 	switch(loop)

   368 	 	{

   369 	 		case 0:   // CREATE DATABASE TEST

   370 	 	 		{

   371 		 		iTest->Printf(_L("TEST : CContactDatabase::CreateL() ."));

   372 		    	

   373 		    	TRAP(err, db = CContactDatabase::CreateL(iLongDbName));

   374 		    	

   375 		    	if (err == aErrArray[0])

   376 			    	{

   377 			    	typeOfError = 1;					

   378 			    	}

   379 		    	else if(err == KErrAlreadyExists || err == KErrBadName || err == KErrDiskFull || err == KErrArgument)

   380 			    	{

   381 			     	typeOfError = 2;	

   382 			    	}

   383 				} 

   384 	     	break;

   385 	 

   386 	 		case 1:	  // OPEN DATABASE TEST

   387 		 		{

   388 		 		iTest->Printf(_L("TEST : CContactDatabase::OpenL()."));

   389 		 		

   390 		    	TRAP(err, db = CContactDatabase::OpenL(iLongDbName));

   391 		    	

   392 		    	if (err == aErrArray[1])

   393 			    	{

   394 			    	typeOfError = 1;					

   395 			    	}

   396 		    	else if(err == KErrNotFound || err == KErrLocked || err == KErrBadName || err == KErrDiskFull || err == KErrArgument)

   397 			    	{

   398 			     	typeOfError = 2;	

   399 			    	}		    	

   400 				}    	

   401 	 		break;

   402 	 		

   403 	 		case 2:  // REPLACE DATABASE TEST

   404 		 		{

   405 		 		iTest->Printf(_L("TEST : CContactDatabase::ReplaceL()()."));

   406 		 		

   407 		    	TRAP(err, db = CContactDatabase::ReplaceL(iLongDbName));

   408 		    	

   409 		    	if (err == aErrArray[2])

   410 			    	{

   411 			    	typeOfError = 1;					

   412 			    	}

   413 		    	else if(err == KErrInUse || err == KErrBadName || err == KErrDiskFull || err == KErrArgument)

   414 			    	{

   415 			     	typeOfError = 2;	

   416 			    	}		    	

   417 				}  		

   418 	 		break;

   419 	 		

   420 	 		case 3:  // DELETE DATABASE TEST

   421 	 	 		{

   422 		 		iTest->Printf(_L("TEST : CContactDatabase::DeleteDatabaseL()."));

   423 		 		

   424 		    	TRAP(err, CContactDatabase::DeleteDatabaseL(iLongDbName));

   425 		    	

   426 		    	if (err == aErrArray[3])

   427 			    	{

   428 			    	typeOfError = 1;					

   429 			    	}

   430 		    	else if(err == KErrNotFound || err == KErrBadName || err == KErrInUse || err == KErrArgument)

   431 			    	{

   432 			     	typeOfError = 2;	

   433 			    	}		    	

   434 				} 		

   435 	 		break;

   436 	 		

   437 	 		case 4:  // DATABASE EXISTS TEST

   438 	 	 		{

   439 		 		iTest->Printf(_L("TEST : CContactDatabase::ContactDatabaseExistsL()."));

   440 		 		

   441 		    	TRAP(err, CContactDatabase::ContactDatabaseExistsL(iLongDbName));

   442 		    	

   443 		    	if (err == aErrArray[4])

   444 			    	{

   445 			    	typeOfError = 1;					

   446 			    	}

   447 		    	else if(err == KErrNotReady || err == KErrBadName || err == KErrNotFound || err == KErrArgument || err == KErrCorrupt)

   448 			    	{

   449 			     	typeOfError = 2;	

   450 			    	}		    	

   451 				} 		

   452 	 		break;

   453 	 		

   454 	 		

   455 	 		default:

   456 	 			User::Leave(KErrArgument);

   457 	 		break;	 		

   458 	 		

   459 	 	}

   460 	 	

   461 	 	if(typeOfError == 1)

   462 		 	{

   463 			iTest->Printf(_L("Correct Error Code Returned: %d"), err);

   464 		 	}

   465 	 	else if(typeOfError == 2)

   466 		 	{

   467 			iTest->Printf(_L("Incorrect, but one of the possible error codes returned: %d"), err);

   468 		 	}

   469 	 	else

   470 		 	{

   471 			iTest->Printf(_L("ERROR:- Test Failed, Unexpected Error Code returned: %d"), err);

   472 		 	}

   473  	 

   474 	    if (db)

   475 	        {

   476 	        delete db;

   477 	        }

   478 	  	}  	

   479 				

   480 	}

   481 

   482 

   483 LOCAL_C void DoTestsL()

   484     {

   485     CDbNameTest* test = CDbNameTest::NewLC();

   486     test->RunTestsL();

   487     CleanupStack::PopAndDestroy(test);

   488     }

   489 

   490 GLDEF_C TInt E32Main()

   491     {

   492     // Init

   493     CTrapCleanup* cleanupStack = CTrapCleanup::New();

   494     if (!cleanupStack)

   495         {

   496         return KErrNoMemory;

   497         }

   498 

   499     CActiveScheduler* activeScheduler = new CActiveScheduler;

   500     if (!activeScheduler)

   501         {

   502         return KErrNoMemory;

   503         }

   504     CActiveScheduler::Install(activeScheduler);

   505 

   506     // Run the tests

   507     __UHEAP_MARK;

   508     TRAPD(err, DoTestsL());

   509     __UHEAP_MARKEND;

   510 

   511     // Cleanup

   512     delete activeScheduler;

   513     delete cleanupStack;

   514     return err;

   515     }

   516