Symaptic: os/persistentdata/persistentstorage/sql/TEST/t

     1 // Copyright (c) 2005-2010 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 //

    16 #include <e32test.h>

    17 #include <bautils.h>

    18 #include <s32buf.h>				//MStreamBuf

    19 #include <sqldb.h>

    21 ///////////////////////////////////////////////////////////////////////////////////////

    23 RTest TheTest(_L("t_sqlapi test"));

    24 _LIT(KTestDir, "c:\\test\\");

    25 _LIT(KTestDbName1, "c:\\test\\t_sqlapi1.db");

    26 _LIT(KTestDbName2, "c:[1111CCCC]t_sqlapi2.db");

    27 _LIT(KTestDbName3, "C:\\TEST\\t_sqlapi3.db");

    28 _LIT(KTestDbName4, "C:[1111CCCC]D012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.db");

    29 _LIT(KTestDbName5, "C:\\TEST\\D012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.db");

    30 _LIT(KTestDbName6, "C:[1111CCCC]t_sqlapi6.db");

    31 _LIT(KTestDbName7, "C:[1111CCCC]t_sqlapi7.db");

    32 _LIT(KTestDbName8, "c:\\test\\t_sqlapi8.db");

    33 _LIT(KTestDbName9, "c:\\private\\1111CCCC\\t_sqlapi9.db");

    34 _LIT(KTestCfgDbName, "c:\\test\\t_sqlapi_cfg.db");

    35 _LIT(KTestCfgDbName2, "c:[1111CCCC]t_sqlapi_cfg.db");

    36 _LIT(KServerPrivateDir, "\\private\\10281e17\\");

    38 _LIT(KDbName7, "C:\\TEST\\t_sqlapi7_2.db");

    40 // used for the config test

    41 _LIT8(KServerConfigString1, "   ;  cache_size =  1024 ; page_size =1024 ;encoding =  \"UTF-8\"   ");

    42 _LIT8(KServerConfigString2, " badconfigstring ");

    43 _LIT8(KServerConfigString3, " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

    44 _LIT8(KServerConfigString4, "");

    45 _LIT8(KServerConfigString5, "dfgdfrgdkfjgjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj43w3wk4jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn");

    47 const TUid KSecureUid = {0x1111CCCC};//The same as the UID in the MMP file

    49 _LIT(KCreateDbScript, "z:\\test\\contacts_schema_to_vendors.sql");

    50 _LIT(KFillDbScript, "z:\\test\\add_simple_contacts.sql");

    51 _LIT8(KCommitStr8, "COMMIT;");

    52 _LIT16(KCommitStr16, "COMMIT;");

    54 ///////////////////////////////////////////////////////////////////////////////////////

    56 void DeleteTestFiles()

    57 	{

    58 	RSqlDatabase::Delete(KTestDbName1);

    59 	RSqlDatabase::Delete(KTestDbName2);

    60 	RSqlDatabase::Delete(KTestDbName3);

    61 	RSqlDatabase::Delete(KTestDbName4);

    62 	RSqlDatabase::Delete(KTestDbName5);

    63 	RSqlDatabase::Delete(KTestDbName6);

    64 	RSqlDatabase::Delete(KTestDbName7);

    65 	RSqlDatabase::Delete(KTestDbName8);

    66 	RSqlDatabase::Delete(KTestDbName9);

    67 	RSqlDatabase::Delete(KTestCfgDbName);

    68 	RSqlDatabase::Delete(KTestCfgDbName2);

    69 	RSqlDatabase::Delete(KDbName7);

    70 	}

    72 ///////////////////////////////////////////////////////////////////////////////////////

    73 ///////////////////////////////////////////////////////////////////////////////////////

    74 //Test macros and functions

    75 void Check(TInt aValue, TInt aLine)

    76 	{

    77 	if(!aValue)

    78 		{

    79 		DeleteTestFiles();

    80 		TheTest(EFalse, aLine);

    81 		}

    82 	}

    83 void Check(TInt aValue, TInt aExpected, TInt aLine)

    84 	{

    85 	if(aValue != aExpected)

    86 		{

    87 		DeleteTestFiles();

    88 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

    89 		TheTest(EFalse, aLine);

    90 		}

    91 	}

    92 #define TEST(arg) ::Check((arg), __LINE__)

    93 #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

    95 ///////////////////////////////////////////////////////////////////////////////////////

    97 void CreateTestDir()

    98     {

    99     RFs fs;

   100 	TInt err = fs.Connect();

   101 	TEST2(err, KErrNone);

   103 	err = fs.MkDir(KTestDir);

   104 	TEST(err == KErrNone || err == KErrAlreadyExists);

   106 	err = fs.CreatePrivatePath(EDriveC);

   107 	TEST(err == KErrNone || err == KErrAlreadyExists);

   109 	fs.Close();

   110 	}

   112 ///////////////////////////////////////////////////////////////////////////////////////

   114 template <class DES, class BUF> void ExecSqlStmtOnDb(RSqlDatabase& aDb, const TDesC8& aSqlString,

   115 												     TInt aExpectedError)

   116 	{

   117 	BUF sqlBuf;

   118 	sqlBuf.Copy(aSqlString);

   120 	TInt rc = aDb.Exec(sqlBuf);

   121 	if(rc < 0 && SqlRetCodeClass(rc) == ESqlDbError)

   122 		{

   123 		TPtrC msg = aDb.LastErrorMessage();

   124 		RDebug::Print(_L("Execute SQL error - '%S'\r\n"), &msg);

   125 		}

   126 	if(aExpectedError < 0)

   127 		{

   128 		TEST2(rc, aExpectedError);

   129 		}

   130 	else

   131 		{

   132 		TEST(rc >= 0);

   133 		}

   134 	}

   136 template <class DES, class BUF>  RSqlStatement PrepareSqlStmt(RSqlDatabase& aDb, const TDesC8& aSqlString,

   137 															  TInt aExpectedError)

   138 	{

   139 	BUF sqlBuf;

   140 	sqlBuf.Copy(aSqlString);

   142 	RSqlStatement stmt;

   143 	TInt rc = stmt.Prepare(aDb, sqlBuf);

   144 	if(rc != KErrNone && SqlRetCodeClass(rc) == ESqlDbError)

   145 		{

   146 		TPtrC msg = aDb.LastErrorMessage();

   147 		RDebug::Print(_L("Execute SQL error - '%S'\r\n"), &msg);

   148 		}

   149 	TEST2(rc, aExpectedError);

   150 	return stmt;

   151 	}

   153 void ExecSqlStmt(RSqlDatabase& aDb, RSqlStatement& aStmt, TInt aExpectedError)

   154 	{

   155 	TInt rc = aStmt.Exec();

   156 	if(rc < 0 && SqlRetCodeClass(rc) == ESqlDbError)

   157 		{

   158 		TPtrC msg = aDb.LastErrorMessage();

   159 		RDebug::Print(_L("Execute SQL error - '%S'\r\n"), &msg);

   160 		}

   161 	if(aExpectedError < 0)

   162 		{

   163 		TEST2(rc, aExpectedError);

   164 		}

   165 	else

   166 		{

   167 		TEST(rc >= 0);

   168 		}

   169 	}

   171 ///////////////////////////////////////////////////////////////////////////////////////

   172 ///////////////////////////////////////////////////////////////////////////////////////

   174 /**

   175 @SYMTestCaseID			SYSLIB-SQL-CT-1601

   176 @SYMTestCaseDesc		Create/Open/Close database tests. Invalid database names, very long database names,

   177 						private databases, public databases, open twice database, create already

   178 						existing database, open non-exisitng database, open corrupted database.

   179 @SYMTestPriority		High

   180 @SYMTestActions			Tests for RSqlDatabase::Create(), RSqlDatabase::Open() methods.

   181 @SYMTestExpectedResults Test must not fail

   182 @SYMREQ					REQ5792

   183                         REQ5793

   184 */

   185 void OpenCloseDatabaseTest()

   186 	{

   187 	RSqlDatabase db;

   188 	TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);

   189 	RSqlSecurityPolicy securityPolicy;

   190 	TInt rc = securityPolicy.Create(defaultPolicy);

   191 	TEST2(rc, KErrNone);

   193 	//Secure shared database file on a non-existing drive (A:)

   194 	_LIT(KDbPath1, "A:[1111CCCC]db1.db");

   195 	rc = db.Create(KDbPath1, securityPolicy);

   196 	TEST2(rc, KErrNotReady);

   197 	db.Close();

   199 	//Attempt to open a non-existing file.

   200 	_LIT(KDbFName, "c:\\test\\nofile.db");

   201 	rc = db.Open(KDbFName);

   202 	TEST2(rc, KErrNotFound);

   204 	//Zero length database file name.

   205 	rc = db.Create(_L(""));

   206 	TEST2(rc,  KErrBadName);

   207 	db.Close();

   209 	//Database file name containing only the drive name

   210 	rc = db.Create(_L("C:"));

   211 	TEST2(rc, KErrBadName);

   212 	db.Close();

   214 	//Database file name containing only the path, without the file name

   215 	rc = db.Create(_L("C:\\TEST\\"));

   216 	TEST2(rc, KErrBadName);

   217 	db.Close();

   219 	//Public shared database file on a non-existing drive (A:)

   220 	_LIT(KDbPath2, "A:\\test\\db1.db");

   221 	rc = db.Create(KDbPath2);

   222 	TEST2(rc, KErrNotReady);

   223 	db.Close();

   225 	// create database with good config specified

   226 	rc = db.Create(KTestCfgDbName,&KServerConfigString1);

   227 	TEST2(rc, KErrNone);

   228 	db.Close();

   229 	TInt rc2 = RSqlDatabase::Delete(KTestCfgDbName);

   230 	TEST2(rc2, KErrNone);

   232 	// create database with bad config specified

   233 	rc = db.Create(KTestCfgDbName,&KServerConfigString2);

   234 	TEST2(rc, KErrArgument);

   235 	db.Close();

   237 	// create database with long config specified

   238 	rc = db.Create(KTestCfgDbName,&KServerConfigString3);

   239 	TEST2(rc, KErrArgument);

   240 	db.Close();

   242 	// create database with empty config specified - not an error

   243 	rc = db.Create(KTestCfgDbName,&KServerConfigString4);

   244 	TEST2(rc, KErrNone);

   245 	db.Close();

   246 	rc2 = RSqlDatabase::Delete(KTestCfgDbName);

   247 	TEST2(rc2, KErrNone);

   249     // create database with very long config specified

   250     rc = db.Create(KTestCfgDbName, &KServerConfigString5);

   251     TEST2(rc, KErrArgument);

   252     db.Close();

   254 	//Secure shared database file on an existing drive (C:).

   255 	//Very long database file name (> 90 characters) but still a valid name.

   256 	rc = db.Create(KTestDbName4, securityPolicy);

   257 	db.Close();

   258 	rc2 = RSqlDatabase::Delete(KTestDbName4);

   259 	TEST2(rc, KErrNone);

   260 	TEST2(rc2, KErrNone);

   262 	//Secure shared database file on an existing drive (C:).

   263 	//Very long database file name (> 90 characters) but still a valid name.

   264 	//With config

   265 	rc = db.Create(KTestCfgDbName2, securityPolicy, &KServerConfigString1);

   266 	db.Close();

   267 	rc2 = RSqlDatabase::Delete(KTestCfgDbName2);

   268 	TEST2(rc, KErrNone);

   269 	TEST2(rc2, KErrNone);

   271 	//Public shared database file on an existing drive (C:).

   272 	//Very long database file name (> 90 characters) but still a valid name.

   273 	rc = db.Create(KTestDbName5);

   274 	db.Close();

   275 	rc2 = RSqlDatabase::Delete(KTestDbName5);

   276 	TEST2(rc, KErrNone);

   277 	TEST2(rc2, KErrNone);

   279 	RFs fs;

   280 	TEST2(fs.Connect(), KErrNone);

   281 	TFileName privatePath;

   282 	TEST2(fs.PrivatePath(privatePath), KErrNone);

   284 	//Private shared database file on an existing drive (C:).

   285 	//Very long database file name.

   286 	TBuf<50>filesysname;

   287 	fs.FileSystemName(filesysname,(TInt) EDriveC);

   288     fs.Close();

   290 	RDebug::Print(_L("file system name = %S"), &filesysname);

   291 	TInt maxFileName = KMaxFileName -40;//"-40" because the SQLITE engine creates a journal file if begins

   292 	                                                 //a transaction. The name of the journal file is

   293 	                                                 //"<dbFileName>-journal.<ext>". It is obvious that if the

   294 	                                                 //database file name is too long but still valid and its creation

   295 	                                                 //succeeds, the journal file creation may fail because the journal

   296 	                                                 //file name becomes too long

   298 	if(filesysname.CompareF(_L("HVFS")) == 0)

   299 	    {

   300         maxFileName = KMaxFileName -150;//The test will panic in PlatSim when the file name is too long. This line should be removed when platsim team fixes the file system defect.

   301 	    }

   302 	HBufC* dbPath = HBufC::New(maxFileName);

   303 	TEST(dbPath != NULL);

   304 	TPtr dbPathPtr = dbPath->Des();

   305 	_LIT(KExt, ".DB");

   306 	dbPathPtr.Copy(_L("C:"));

   307 	dbPathPtr.Append(KSecureUid.Name());

   308 	TInt len = maxFileName + 1 - (dbPathPtr.Length() + KExt().Length() + privatePath.Length());

   310 	while(--len)

   311 		{

   312         dbPathPtr.Append(TChar('A'));

   313 		}

   314 	dbPathPtr.Append(KExt);

   315 	TEST(dbPathPtr.Length() == (maxFileName - privatePath.Length()));

   316 	rc = db.Create(dbPathPtr, securityPolicy);

   317 	TEST2(rc, KErrNone);

   318 	db.Close();

   319 	rc2 = RSqlDatabase::Delete(dbPathPtr);

   320 	TEST2(rc2, KErrNone);

   322 	// Private database with config

   323 	TBuf<KMaxFileName> cfgPath;

   324 	cfgPath.Copy(_L("C:"));

   325 	cfgPath.Append(KSecureUid.Name());

   326 	cfgPath.Append(KExt);

   327 	rc = db.Create(cfgPath,securityPolicy,&KServerConfigString1);

   328 	db.Close();

   329 	rc2 = RSqlDatabase::Delete(cfgPath);

   330 	TEST2(rc, KErrNone);

   331 	TEST2(rc2, KErrNone);

   333 	//Public shared database file on an existing drive (C:).

   334 	//Very long database file name.

   335 	dbPathPtr.Copy(_L("C:\\TEST\\D"));

   336 	len = maxFileName + 1 - (dbPathPtr.Length() + KExt().Length());

   337 	while(--len)

   338 		{

   339         dbPathPtr.Append(TChar('A'));

   340 		}

   341 	dbPathPtr.Append(KExt);

   342 	TEST(dbPathPtr.Length() == maxFileName);

   343 	rc = db.Create(dbPathPtr);

   344 	db.Close();

   345 	rc2 = RSqlDatabase::Delete(dbPathPtr);

   347 	delete dbPath;

   349 	TEST2(rc, KErrNone);

   350 	TEST2(rc2, KErrNone);

   352 	//Create/Close/Open/Close secure shared database test

   353 	rc = db.Create(KTestDbName6, securityPolicy);

   354 	db.Close();

   355 	rc2 = db.Open(KTestDbName6);

   356 	db.Close();

   357 	TInt rc3 = RSqlDatabase::Delete(KTestDbName6);

   358 	TEST2(rc, KErrNone);

   359 	TEST2(rc2, KErrNone);

   360 	TEST2(rc3, KErrNone);

   362 	//An attempt to create already existing secure shared file.

   363 	rc = db.Create(KTestDbName6, securityPolicy);

   364 	db.Close();

   365 	rc2 = db.Create(KTestDbName6, securityPolicy);

   366 	db.Close();

   367 	rc3 = RSqlDatabase::Delete(KTestDbName6);

   368 	TEST2(rc, KErrNone);

   369 	TEST2(rc2, KErrAlreadyExists);

   370 	TEST2(rc3, KErrNone);

   372 	//An attempt to open twice the same database file using different RSqlDatabase objects

   373 	rc = db.Create(KTestDbName6, securityPolicy);

   374 	RSqlDatabase db2;

   375 	rc2 = db2.Open(KTestDbName6);

   376 	db2.Close();

   377 	db.Close();

   378 	rc3 = RSqlDatabase::Delete(KTestDbName6);

   379 	TEST2(rc, KErrNone);

   380 	TEST2(rc2, KErrNone);//-- KErrInUse -- in case EFileRead | EFileWrite file open mode!

   381 	TEST2(rc3, KErrNone);

   383 	//An attempt to create secure shared database file on a read-only drive (Z:)

   384 	_LIT(KDbPath8, "Z:[1111CCCC]db1.db");

   385 	rc = db.Create(KDbPath8, securityPolicy);

   386 	TEST2(rc, KErrAccessDenied);

   387 	db.Close();

   389 	//An attempt to create non-secure shared database file on a read-only drive (Z:)

   390 	_LIT(KDbPath8a, "Z:\\db1.db");

   391 	rc = db.Create(KDbPath8a);

   392 	TEST2(rc, KErrAccessDenied);

   393 	db.Close();

   395 	//An attempt to open non-existing secure shared database file on a read-only drive (Z:)

   396 	rc = db.Open(KDbPath8);

   397 	TEST(rc == KErrNotFound || rc == KErrPathNotFound);

   398 	db.Close();

   400 	//An attempt to open existing public shared database file on a read-only drive (Z:)

   401 	_LIT(KDbPath9, "Z:\\TEST\\TestDb1.db");

   402 	rc = db.Open(KDbPath9);

   403 	TEST2(rc, KErrNone);

   404 	db.Close();

   406 	//An attempt to open corrupted public shared database file on a read-only drive (Z:)

   407 	_LIT(KDbPath10, "Z:\\TEST\\CorruptDb.db");

   408 	rc = db.Open(KDbPath10);

   409 	// it will be KErrNotDb if SqlServer.cfg exists, else KErrNone if it doesn't

   410 	// this is because we can detect a corrupt database when we attempt to

   411 	// set the configuration. If there is no cfg file, then there will be no

   412 	// attempt to set the pragmas and so the corrupt file is undetected

   413 	TEST(rc==KSqlErrNotDb || rc==KErrNone);

   414 	db.Close();

   416 	//An attempt to open database with name containing non-convertible characters.

   417     TBuf<6> invName;

   418     invName.SetLength(6);

   419     invName[0] = TChar('c');

   420     invName[1] = TChar(':');

   421     invName[2] = TChar('\\');

   422     invName[3] = TChar(0xD800);

   423     invName[4] = TChar(0xFC00);

   424     invName[5] = TChar(0x0000);

   425 	rc = db.Open(invName);

   426 	db.Close();

   427 	TEST(rc != KErrNone);

   429 	//Copy the corrupted database file on drive C:

   430 	TEST2(fs.Connect(), KErrNone);

   431 	rc = BaflUtils::CopyFile(fs, KDbPath10, KTestDbName3);

   432 	TEST2(rc, KErrNone);

   433 	(void)fs.SetAtt(KTestDbName3, 0, KEntryAttReadOnly);

   434 	fs.Close();

   436 	//An attempt to open corrupted public shared database file on a drive (C:)

   437 	rc = db.Open(KTestDbName3);

   438 	TEST(rc == KSqlErrNotDb || rc == KErrNone);//Note: but it may be a different error code as well

   439 	db.Close();

   440 	(void)RSqlDatabase::Delete(KTestDbName3);

   442 	//Create, Close, Open, Close and again Open database test

   443 	rc = db.Create(KTestDbName2, securityPolicy);

   444 	TEST2(rc, KErrNone);

   445 	db.Close();

   446 	rc = db.Open(KTestDbName2);

   447 	TEST2(rc, KErrNone);

   448 	db.Close();

   449 	rc = db.Open(KTestDbName2);

   450 	TEST2(rc, KErrNone);

   451 	db.Close();

   453 	//Open two connections to the same database.

   454 	rc = db.Open(KTestDbName2);

   455 	TEST2(rc, KErrNone);

   456 	rc = db2.Open(KTestDbName2);

   457 	TEST2(rc, KErrNone);

   458 	db2.Close();

   459 	db.Close();

   461 	rc = RSqlDatabase::Delete(KTestDbName2);

   462 	TEST2(rc, KErrNone);

   464 	securityPolicy.Close();

   465 	}

   467 ///////////////////////////////////////////////////////////////////////////////////////

   469 /**

   470 @SYMTestCaseID			SYSLIB-SQL-CT-1602

   471 @SYMTestCaseDesc		Setting database isolation level tests.

   472 @SYMTestPriority		High

   473 @SYMTestActions			Tests for RSqlDatabase::SetIsolationLevel() method.

   474 @SYMTestExpectedResults Test must not fail

   475 @SYMREQ					REQ5792

   476                         REQ5793

   477 */

   478 void SetIsolationLevelTest()

   479 	{

   480 	(void)RSqlDatabase::Delete(KTestDbName1);

   482 	RSqlDatabase db;

   483 	TInt err = db.Create(KTestDbName1);

   484 	TEST2(err, KErrNone);

   486 	err = db.SetIsolationLevel(RSqlDatabase::EReadCommitted);

   487 	TEST2(err, KErrNotSupported);

   489 	err = db.SetIsolationLevel(RSqlDatabase::ERepeatableRead);

   490 	TEST2(err, KErrNotSupported);

   492 	err = db.SetIsolationLevel(RSqlDatabase::EReadUncommitted);

   493 	TEST2(err, KErrNone);

   495 	err = db.SetIsolationLevel(RSqlDatabase::ESerializable);

   496 	TEST2(err, KErrNone);

   498 	db.Close();

   500 	(void)RSqlDatabase::Delete(KTestDbName1);

   501 	}

   503 ///////////////////////////////////////////////////////////////////////////////////////

   505 /**

   506 @SYMTestCaseID			SYSLIB-SQL-CT-1603

   507 @SYMTestCaseDesc		Deleting database tests. Deleting non-existing database, opened database,

   508 						database on non-existing drive, zero-length database name, only path (no file name),

   509 						rom drive based database.

   510 @SYMTestPriority		High

   511 @SYMTestActions			Tests for RSqlDatabase::Delete() method.

   512 @SYMTestExpectedResults Test must not fail

   513 @SYMREQ					REQ5792

   514                         REQ5793

   515 */

   516 void DeleteDatabaseTest()

   517 	{

   518 	//An attempt to delete non-existing secure shared database

   519 	_LIT(KDbName1, "C:[1111CCCC]EE__900000.adb");

   520 	TInt err = RSqlDatabase::Delete(KDbName1);

   521 	TEST2(err, KErrNotFound);

   523 	//An attempt to delete non-existing public database

   524 	_LIT(KDbName2, "C:\\TEST\\__900000.adb");

   525 	err = RSqlDatabase::Delete(KDbName2);

   526 	TEST2(err, KErrNotFound);

   528 	//Zero length database file name.

   529 	_LIT(KDbName3, "");

   530 	err = RSqlDatabase::Delete(KDbName3);

   531 	TEST2(err,  KErrBadName);

   533 	//Database file name containing only the drive name

   534 	_LIT(KDbName4, "C:");

   535 	err = RSqlDatabase::Delete(KDbName4);

   536 	TEST2(err, KErrBadName);

   538 	//Database file name containing only the path, without the file name

   539 	_LIT(KDbName5, "C:");

   540 	err = RSqlDatabase::Delete(KDbName5);

   541 	TEST2(err, KErrBadName);

   543 	//Public shared database file on a non-existing drive (A:)

   544 	_LIT(KDbName6, "A:\\test\\db1.db");

   545 	err = RSqlDatabase::Delete(KDbName6);

   546 	TEST2(err, KErrNotReady);

   548 	//An attempt to delete opened database.

   549 	RSqlDatabase db;

   550 	err = db.Create(KDbName7);

   551 	TEST2(err, KErrNone);

   552 	err = RSqlDatabase::Delete(KDbName7);

   553 	TEST2(err, KErrInUse);

   554 	db.Close();

   555 	err = RSqlDatabase::Delete(KDbName7);

   556 	TEST2(err, KErrNone);

   558 	//An attempt to delete existing public shared database file on a read-only drive (Z:)

   559 	_LIT(KDbName8, "Z:\\TEST\\TestDb1.db");

   560 	err = RSqlDatabase::Delete(KDbName8);

   561 	TEST2(err, KErrAccessDenied);

   563 	//Create secure database

   564 	TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);

   565 	RSqlSecurityPolicy securityPolicy;

   566 	err = securityPolicy.Create(defaultPolicy);

   567 	TEST2(err, KErrNone);

   568 	err = db.Create(KTestDbName7, securityPolicy);

   569 	TEST2(err, KErrNone);

   570 	db.Close();

   571 	securityPolicy.Close();

   573 	//Attempt to delete a secure public database.

   574 	//The calling application has no rights to delete a file with that name from the server's

   575 	//private data cage.

   576    	err = RSqlDatabase::Delete(_L("C:[45454545]qq.db"));

   577 	TEST2(err, KErrPermissionDenied);

   579 	//Attempt to delete a secure public database. No drive specified.

   580 	//The calling application has no rights to delete a file with that name from the server's

   581 	//private data cage.

   582 	err = RSqlDatabase::Delete(_L("[45454545]qq.db"));

   583 	TEST2(err, KErrPermissionDenied);

   585 	//Attempt to delete secure database specifying the full database path

   586 	TParse parse;

   587 	parse.Set(KTestDbName7, &KServerPrivateDir(), 0);

   588 	err = RSqlDatabase::Delete(parse.FullName());

   589 	TEST2(err, KErrArgument);

   591 	//Attempt to delete secure database specifying only the database name

   592 	err = RSqlDatabase::Delete(parse.NameAndExt());

   593 	//If C: is the system drive then the operation must pass.

   594 	TEST2(err, KErrNone);

   595 	}

   597 ///////////////////////////////////////////////////////////////////////////////////////

   599 /**

   600 @SYMTestCaseID			SYSLIB-SQL-CT-1640

   601 @SYMTestCaseDesc		Copying database tests. Copying:

   602 						- non-secure to non-secure database;

   603 						- non-secure to secure database;

   604 						- secure to non-secure database;

   605 						- secure to secure database;

   606 						- secure database, when the application is not the database creator (owner);

   607 @SYMTestPriority		High

   608 @SYMTestActions			Tests for RSqlDatabase::Copy() method.

   609 @SYMTestExpectedResults Test must not fail

   610 @SYMREQ					REQ5792

   611                         REQ5793

   612 */

   613 void CopyDatabaseTest()

   614 	{

   615 	RSqlDatabase db;

   617 	//Create secure database

   618 	TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);

   619 	RSqlSecurityPolicy securityPolicy;

   620 	TInt err = securityPolicy.Create(defaultPolicy);

   621 	TEST2(err, KErrNone);

   622 	err = db.Create(KTestDbName7, securityPolicy);

   623 	TEST2(err, KErrNone);

   624 	db.Close();

   625 	securityPolicy.Close();

   627 	//Create non-secure database

   628 	err = db.Create(KTestDbName1);

   629 	TEST2(err, KErrNone);

   630 	db.Close();

   632 	//Copy non-secure to non-secure database

   633 	err = RSqlDatabase::Copy(KTestDbName1, KTestDbName8);

   634 	TEST2(err, KErrNone);

   636 	//Attempt to copy non-secure to secure database

   637 	err = RSqlDatabase::Copy(KTestDbName1, _L("C:[99999999]pkk.db"));

   638 	TEST2(err, KErrPermissionDenied);

   640 	//Attempt to copy secure to non-secure database

   641 	err = RSqlDatabase::Copy(KTestDbName7, _L("C:\\test\\asdf.db"));

   642 	TEST2(err, KErrPermissionDenied);

   644 	//Copy secure to secure database. The test application is the database owner.

   645 	err = RSqlDatabase::Copy(KTestDbName7, KTestDbName4);

   646 	TEST2(err, KErrNone);

   647 	err = RSqlDatabase::Delete(KTestDbName4);

   648 	TEST2(err, KErrNone);

   650 	//Attempt to copy secure to secure database. The test application is not the database owner.

   651 	err = RSqlDatabase::Copy(KTestDbName7, _L("C:[11111111]ff.db"));

   652 	TEST2(err, KErrPermissionDenied);

   653 	err = RSqlDatabase::Copy(_L("C:[11111111]ff.db"), _L("C:[22222222]ff.db"));

   654 	TEST2(err, KErrPermissionDenied);

   655 	err = RSqlDatabase::Copy(_L("C:[11111111]ff.db"), KTestDbName7);

   656 	TEST2(err, KErrPermissionDenied);

   658 	(void)RSqlDatabase::Delete(KTestDbName8);

   659 	(void)RSqlDatabase::Delete(KTestDbName7);

   660 	(void)RSqlDatabase::Delete(KTestDbName4);

   661 	(void)RSqlDatabase::Delete(KTestDbName1);

   662 	}

   664 ///////////////////////////////////////////////////////////////////////////////////////

   666 /**

   667 @SYMTestCaseID			SYSLIB-SQL-CT-1604

   668 @SYMTestCaseDesc		Create a table with two integer columns. The second column has a default value NULL.

   669 						Check what will be the result of "column1 + column2" operation, if "column2"

   670 						value is NULL.

   671 @SYMTestPriority		High

   672 @SYMTestActions			Tests mathematical operations with ESqlNull column values.

   673 @SYMTestExpectedResults Test must not fail

   674 @SYMREQ					REQ5792

   675                         REQ5793

   676 */

   677 void NullColumnValues()

   678 	{

   679 	(void)RSqlDatabase::Delete(KTestDbName1);

   681 	RSqlDatabase db;

   682 	TInt err = db.Create(KTestDbName1);

   683 	TEST2(err, KErrNone);

   685 	err = db.Exec(_L8("CREATE TABLE test(int_fld integer, null_int_fld integer default null)"));

   686 	TEST(err >= 0);

   688 	err = db.Exec(_L8("INSERT INTO test(int_fld) values(200)"));

   689 	TEST2(err, 1);

   691 	RSqlStatement stmt;

   693 	err = stmt.Prepare(db, _L8("SELECT * from test"));

   694 	TEST2(err, KErrNone);

   696 	err = stmt.Next();

   697 	TEST2(err, KSqlAtRow);

   699 	TSqlColumnType colType = stmt.ColumnType(0);

   700 	TEST(colType == ESqlInt);

   702 	colType = stmt.ColumnType(1);

   703 	TEST(colType == ESqlNull);

   705 	TInt val = stmt.ColumnInt(0);

   706 	TEST(val == 200);

   708 	val = stmt.ColumnInt(1);

   709 	TEST(val == 0);

   711 	stmt.Close();

   713 	err = stmt.Prepare(db, _L8("SELECT (int_fld + null_int_fld) as res from test"));

   714 	TEST2(err, KErrNone);

   716 	err = stmt.Next();

   717 	TEST2(err, KSqlAtRow);

   719 	colType = stmt.ColumnType(0);

   720 	TEST(colType == ESqlNull);

   722 	val = stmt.ColumnInt(0);

   723 	TEST(val == 0);

   725 	stmt.Close();

   726 	db.Close();

   728 	(void)RSqlDatabase::Delete(KTestDbName1);

   729 	}

   731 ///////////////////////////////////////////////////////////////////////////////////////

   733 _LIT8(KStmt1, "CREATE TABLE A1(Fld1 INTEGER, Fld2 DOUBLE);\

   734 									   CREATE TABLE A2(Fld1 INTEGER, Fld2 DOUBLE);\

   735 									   CREATE TRIGGER TrgA1Ins BEFORE Insert ON A1\

   736 									   BEGIN\

   737 									      INSERT INTO A2(Fld1, Fld2) VALUES(new.Fld1, new.Fld2);\

   738 									   END;");

   739 _LIT8(KStmt2, "INSERT INTO A1(Fld1, Fld2) VALUES(1, 2.0)");

   740 _LIT8(KStmt3, "SELECT * FROM A2");

   741 _LIT8(KStmt4, "INSERT INTO A1(Fld1, Fld2) VALUES(2, 4.0); UPDATE A2 SET Fld2 = 11.3 WHERE Fld1 = 2");

   742 _LIT8(KStmt5, "");

   743 _LIT8(KStmt6, "INSERT INTO A1(Fld1, Fld2) VALUESa(6, 234.0);");

   744 _LIT8(KStmt7, "");

   745 _LIT8(KStmt8, ";;;;;");

   746 _LIT8(KStmt9, "INSERT INTO A1(Fld1, Fld2) VALUES(:v1, :v2)");

   748 /**

   749 @SYMTestCaseID			SYSLIB-SQL-CT-1605

   750 @SYMTestCaseDesc		SQL statements execution. Valid SQL statements. Empty SQL statement.

   751 						More than one SQL statements, separated with ";". SQL statement which syntax is

   752 						incorrect. SQL statement with parameters. INSERT/SELECT/CREATE TABLE SQL statements.

   753 @SYMTestPriority		High

   754 @SYMTestActions			RSqlDatabase::Exec() tests, 16-bit and 8-bit SQL statements

   755 @SYMTestExpectedResults Test must not fail

   756 @SYMREQ					REQ5792

   757                         REQ5793

   758 */

   759 template <class DES, class BUF> void ExecOnDbTest()

   760 	{

   761 	RSqlDatabase db;

   762 	TInt rc = db.Create(KTestDbName1);

   763 	TEST2(rc, KErrNone);

   765 	//Create two tables and a trigger

   766 	ExecSqlStmtOnDb<DES, BUF>(db, KStmt1, KErrNone);

   768 	//INSERT sql statement execution

   769 	ExecSqlStmtOnDb<DES, BUF>(db, KStmt2, KErrNone);

   771 	//SELECT sql statement execution

   772 	ExecSqlStmtOnDb<DES, BUF>(db, KStmt3, KErrNone);

   774 	//Executing more than one SQL statement in a single Exec() call.

   775 	ExecSqlStmtOnDb<DES, BUF>(db, KStmt4, KErrNone);

   777 	//Executing zero length SQL statement.

   778 	ExecSqlStmtOnDb<DES, BUF>(db, KStmt5, KErrNone);

   780 	//Executing a SQL statement with syntax errors.

   781 	ExecSqlStmtOnDb<DES, BUF>(db, KStmt6, KSqlErrGeneral);

   783 	//Executing an empty SQL statement.

   784 	ExecSqlStmtOnDb<DES, BUF>(db, KStmt7, KErrNone);

   786 	//Executing a SQL string, which does not have any SQL statements inside, but has valid syntax.

   787 	ExecSqlStmtOnDb<DES, BUF>(db, KStmt8, KErrNone);

   789 	//Executing SQL statement with parameters. They will be set with NULL values, if not set explicitly.

   790 	ExecSqlStmtOnDb<DES, BUF>(db, KStmt9, KErrNone);

   792 	db.Close();

   794 	rc = RSqlDatabase::Delete(KTestDbName1);

   795 	TEST2(rc, KErrNone);

   796 	}

   798 _LIT8(KStmt10, "");

   799 _LIT8(KStmt11, ";   ;  ;;;");

   800 _LIT8(KStmt12, "CREATE TABLE AAA(Fld1 INTEGER, Fld2 VARCHAR(100))");

   801 _LIT8(KStmt13, "INSERT INTO AAA(Fld1, Fld2) VALUES(5, 'FldVal1-1234567890')");

   802 _LIT8(KStmt14, "SELECT fld1, fld2 FROM AAA");

   803 _LIT8(KStmt15, "SELECT fld2, fld1 FROM AAA");

   804 _LIT8(KStmt16, "SELECT fld2, fld1 FROM AAA WHERE Fld1 > :Prm1 AND fld2 = :PRM2");

   805 _LIT8(KStmt17, "INSERT INTO AAA(Fld1, Fld2) VALUES(:b, :a);");

   806 _LIT8(KStmt18, "CREATE TABLE BBB(Fld1 INTEGER, Fld2 BIGINT, Fld3 DOUBLE, \

   807 					                       Fld4 TEXT, Fld5 LONGBLOB, Fld6 TEXT NULL)");

   808 _LIT8(KStmt19, "INSERT INTO BBB(Fld1, Fld2, Fld3, Fld4, Fld5, Fld6)\

   809 	                                       VALUES(:V1, :V2, :V3, :V4, :V5, :V6)");

   810 _LIT8(KStmt20, "SELECT * FROM BBB");

   811 _LIT8(KStmt21, "SELECT fld1, fld2 FROM AAA;SELECT fld1, fld2 FROM AAA");

   813 /**

   814 @SYMTestCaseID			SYSLIB-SQL-CT-1606

   815 @SYMTestCaseDesc		Preparing SQL statements. Moving to the next record. Retrieving and verifying

   816 						the column types and values. Binding parameter values.

   817 @SYMTestPriority		High

   818 @SYMTestActions			RSqlStatement::Prepare(), RSqlStatement::Next() tests, 16-bit and 8-bit SQL statements.

   819 						RSqlStatement::ColumnIndex(), RSqlStatement::Column<DataType>(), RSqlStatement::Bind<DataType>(),

   820 						RSqlStatement::Column<DataType>().

   821 @SYMTestExpectedResults Test must not fail

   822 @SYMREQ					REQ5792

   823                         REQ5793

   824 */

   825 template <class DES, class BUF> void StatementTest()

   826 	{

   827 	RSqlDatabase db;

   828 	TInt rc = db.Create(KTestDbName1);

   829 	TEST2(rc, KErrNone);

   831 	//Executing an empty SQL statement.

   832 	RSqlStatement stmt = PrepareSqlStmt<DES, BUF>(db, KStmt10, KErrArgument);

   833 	stmt.Close();

   835 	//Executing a SQL string, which does not have any SQL statements inside, but has valid syntax.

   836 	stmt = PrepareSqlStmt<DES, BUF>(db, KStmt11, KErrArgument);

   837 	stmt.Close();

   839 	//SQL statement without parameters. Create a table.

   840 	stmt = PrepareSqlStmt<DES, BUF>(db, KStmt12, KErrNone);

   841 	ExecSqlStmt(db, stmt, KErrNone);

   842 	stmt.Close();

   844 	//String containg more than one SQL statement.

   845 	stmt = PrepareSqlStmt<DES, BUF>(db, KStmt21, KErrArgument);

   846 	stmt.Close();

   848 	//SQL statement without parameters. Insert a record into the table.

   849 	stmt = PrepareSqlStmt<DES, BUF>(db, KStmt13, KErrNone);

   850 	ExecSqlStmt(db, stmt, KErrNone);

   851 	stmt.Close();

   853 	//Test RSqlStatement::ColumnIndex().

   854 	stmt = PrepareSqlStmt<DES, BUF>(db, KStmt14, KErrNone);

   855 	TInt idx1 = stmt.ColumnIndex(_L("FLD1"));

   856 	TEST(idx1 == 0);

   857 	TInt idx2 = stmt.ColumnIndex(_L("FlD2"));

   858 	TEST(idx2 == 1);

   859 	TInt idx3 = stmt.ColumnIndex(_L("fld3"));

   860 	TEST(idx3 < 0);

   861 	stmt.Close();

   863 	stmt = PrepareSqlStmt<DES, BUF>(db, KStmt15, KErrNone);

   864 	idx1 = stmt.ColumnIndex(_L("FLD1"));

   865 	TEST(idx1 == 1);

   866 	idx2 = stmt.ColumnIndex(_L("FlD2"));

   867 	TEST(idx2 == 0);

   868 	idx3 = stmt.ColumnIndex(_L("fld3"));

   869 	TEST(idx3 < 0);

   871 	//Test RSqlStatement::Column<DataType>() methods.

   872 	TInt recCnt = 0;

   873 	while((rc = stmt.Next()) == KSqlAtRow)

   874 		{

   875 		++recCnt;

   877 		TInt intVal = stmt.ColumnInt(idx1);

   878 		TEST(intVal == 5);

   880 		//Integer column value retrieved as a text.

   881 		TPtrC strVal1;

   882 		TInt err = stmt.ColumnText(idx1, strVal1);

   883 		TEST2(err, KErrNone);

   884 		TEST(strVal1 == KNullDesC);

   886 		//Text column value retrieved as a binary

   887 		TBuf8<50> strVal3;

   888 		err = stmt.ColumnBinary(idx2, strVal3);

   889 		TEST2(err, KErrNone);

   890 		TEST(strVal3 == KNullDesC8);

   892 		TPtrC strVal2;

   893 		err = stmt.ColumnText(idx2, strVal2);

   894 		TEST2(err, KErrNone);

   895 		TEST(strVal2 == _L("FldVal1-1234567890"));

   897 		//Invalid column index. Panic: "SqlDb 5"

   898 		//intVal = stmt.ColumnInt(1002);

   899 		//intVal = stmt.ColumnInt(-24);

   900 		}

   901 	stmt.Close();

   902 	TEST2(rc, KSqlAtEnd);

   903 	TEST2(SqlRetCodeClass(rc), ESqlInformation);

   904 	TEST(recCnt == 1);

   906 	//Test RSqlStatement::Bind<DataType>() methods.

   907 	stmt = PrepareSqlStmt<DES, BUF>(db, KStmt16, KErrNone);

   908 	idx1 = stmt.ColumnIndex(_L("FLD1"));

   909 	TEST(idx1 == 1);

   910 	idx2 = stmt.ColumnIndex(_L("FlD2"));

   911 	TEST(idx2 == 0);

   912 	TInt prmIdx1 = stmt.ParameterIndex(_L(":prm1"));

   913 	TEST(prmIdx1 == 0);

   914 	TInt prmIdx2 = stmt.ParameterIndex(_L(":prm2"));

   915 	TEST(prmIdx2 == 1);

   916 	rc = stmt.BindInt(prmIdx1, -4);

   917 	//No problem to bind whatever value type we like

   918 	//rc = stmt.BindBinary(prmIdx1, KSqlStmt4());

   919 	TEST2(rc, KErrNone);

   920 	rc = stmt.BindText(prmIdx2, _L("FldVal1-1234567890"));

   921 	TEST2(rc, KErrNone);

   922 	//Test RSqlStatement::Column<DataType>() methods.

   923 	recCnt = 0;

   924 	while((rc = stmt.Next()) == KSqlAtRow)

   925 		{

   926 		++recCnt;

   927 		TInt intVal = stmt.ColumnInt(idx1);

   928 		TEST(intVal == 5);

   929 		TPtrC strVal;

   930 		TInt err = stmt.ColumnText(idx2, strVal);

   931 		TEST2(err, KErrNone);

   932 		TEST(strVal == _L("FldVal1-1234567890"));

   933 		}

   934 	stmt.Close();

   935 	TEST2(rc, KSqlAtEnd);

   936 	TEST2(SqlRetCodeClass(rc), ESqlInformation);

   937 	TEST(recCnt == 1);

   939 	//Test an INSERT SQL - prepare, bind, exec.

   940 	stmt = PrepareSqlStmt<DES, BUF>(db, KStmt17, KErrNone);

   941 	prmIdx1 = stmt.ParameterIndex(_L(":A"));

   942 	TEST(prmIdx1 == 1);

   943 	prmIdx2 = stmt.ParameterIndex(_L(":B"));

   944 	TEST(prmIdx2 == 0);

   945 	rc = stmt.BindInt(prmIdx1, 20);

   946 	TEST2(rc, KErrNone);

   947 	rc = stmt.BindText(prmIdx2, _L("FldVal2"));

   948 	TEST2(rc, KErrNone);

   949 	rc = stmt.Exec();

   950 	TEST2(rc, 1);

   952 	stmt.Close();

   954 	//Create a table with INTEGER, INT64, REAL, TEXT, BINARY, NULL, field types

   955 	stmt = PrepareSqlStmt<DES, BUF>(db, KStmt18, KErrNone);

   956 	ExecSqlStmt(db, stmt, KErrNone);

   957 	stmt.Close();

   959 	enum {KLow = 1, KHigh = 2};

   960 	//Insert (KHigh - KLow + 1) records

   961 	stmt = PrepareSqlStmt<DES, BUF>(db, KStmt19, KErrNone);

   962 	TInt v32 = 1024;

   963 	TInt64 v64 = MAKE_TINT64(0x00FF00FF, 0x12345678);

   964 	TReal vReal = 234.75;

   965 	TBuf<10> vText;

   966 	TBuf8<10> vBinary;

   967 	for(TInt i=KLow;i<=KHigh;++i)

   968 		{

   969 		rc = stmt.BindInt(0, v32 * i);

   970 		TEST2(rc, KErrNone);

   972 		rc = stmt.BindInt64(1, v64 * i);

   973 		TEST2(rc, KErrNone);

   975 		rc = stmt.BindReal(2, vReal * i);

   976 		TEST2(rc, KErrNone);

   978 		vText.Copy(_L("TEXT"));

   979 		vText.Append(TChar(i + '0'));

   980 		rc = stmt.BindText(3, vText);

   981 		TEST2(rc, KErrNone);

   983 		vBinary.Copy(_L("BINARY"));

   984 		vBinary.Append(TChar(i + '0'));

   985 		rc = stmt.BindBinary(4, vBinary);

   986 		TEST2(rc, KErrNone);

   988 		rc = stmt.BindNull(5);

   989 		TEST2(rc, KErrNone);

   991 		rc = stmt.Exec();

   992 		TEST2(rc, 1);

   994 		rc = stmt.Reset();

   995 		TEST2(rc, KErrNone);

   996 		}

   997 	stmt.Close();

   999 	//Read and test (KHigh - KLow + 1) records

  1000 	stmt = PrepareSqlStmt<DES, BUF>(db, KStmt20, KErrNone);

  1001 	recCnt = 0;

  1002 	while((rc = stmt.Next()) == KSqlAtRow)

  1003 		{

  1004 		++recCnt;

  1005 		TInt v1 = stmt.ColumnInt(0);

  1006 		TEST(v1 == v32 * recCnt);

  1008 		TInt64 v2 = stmt.ColumnInt64(1);

  1009 		TEST(v2 == v64 * recCnt);

  1011 		TReal v3 = stmt.ColumnReal(2);

  1012 		TEST(Abs(v3 - vReal * recCnt) < 0.000001);

  1014 		vText.Copy(_L("TEXT"));

  1015 		vText.Append(TChar(recCnt + '0'));

  1016 		TPtrC v4;

  1017 		TInt err = stmt.ColumnText(3, v4);

  1018 		TEST2(err, KErrNone);

  1019 		TEST(v4 == vText);

  1021 		vBinary.Copy(_L("BINARY"));

  1022 		vBinary.Append(TChar(recCnt + '0'));

  1023 		TPtrC8 v5;

  1024 		err = stmt.ColumnBinary(4, v5);

  1025 		TEST2(err, KErrNone);

  1026 		TEST(v5 == vBinary);

  1028 		TBool b = stmt.IsNull(5);

  1029 		TEST(b != 0);

  1030 		}

  1031 	stmt.Close();

  1032 	TEST2(rc, KSqlAtEnd);

  1033 	TEST2(SqlRetCodeClass(rc), ESqlInformation);

  1034 	TEST(recCnt == (KHigh - KLow + 1));

  1036 	db.Close();

  1038 	rc = RSqlDatabase::Delete(KTestDbName1);

  1039 	TEST2(rc, KErrNone);

  1040 	}

  1042 /**

  1043 @SYMTestCaseID			SYSLIB-SQL-CT-1607

  1044 @SYMTestCaseDesc		Retrieving long text column values test.

  1045 						Retrieving long column values using RSqlStatement::ColumnText() when the recipient buffer

  1046 						is not big enough.

  1047 @SYMTestPriority		High

  1048 @SYMTestActions			RSqlColumnReadStream::ColumnText() test.

  1049 @SYMTestExpectedResults Test must not fail

  1050 @SYMREQ					REQ5792

  1051                         REQ5793

  1052 */

  1053 void ColumnTextStreamTest()

  1054 	{

  1055 	RSqlDatabase db;

  1056 	TInt rc = db.Create(KTestDbName1);

  1057 	TEST2(rc, KErrNone);

  1059 	enum {KSqlBufSize = 64};

  1061 	//Create a table

  1062 	_LIT8(KSqlStmt1, "CREATE TABLE A(Fld1 INTEGER, Fld2 TEXT);");

  1063 	ExecSqlStmtOnDb<TDesC8, TBuf8<KSqlBufSize> >(db, KSqlStmt1(), KErrNone);

  1065 	const TInt KTextLen = 3101;

  1067 	_LIT(KSqlStmt2, "INSERT INTO A(Fld1, Fld2) VALUES(");

  1069 	//Allocate a buffer for the SQL statement.

  1070 	HBufC* buf = HBufC::New(KSqlStmt2().Length() + KTextLen + 10);

  1071 	TEST(buf != NULL);

  1073 	TPtr sql = buf->Des();

  1075 	//Insert row 1

  1077 	const TChar KChar1('A');

  1078 	sql.Copy(KSqlStmt2);

  1079 	sql.Append(_L("1, '"));

  1080 	TInt i;

  1081 	for(i=0;i<KTextLen;++i)

  1082 		{

  1083 		sql.Append(KChar1);

  1084 		}

  1085 	sql.Append(_L("')"));

  1087 	rc = db.Exec(sql);

  1088 	TEST2(rc, 1);

  1090 	//Insert row 2

  1092 	const TChar KChar2('B');

  1093 	sql.Copy(KSqlStmt2);

  1094 	sql.Append(_L("2, '"));

  1095 	for(i=0;i<KTextLen;++i)

  1096 		{

  1097 		sql.Append(KChar2);

  1098 		}

  1099 	sql.Append(_L("')"));

  1101 	rc = db.Exec(sql);

  1102 	TEST2(rc, 1);

  1104 	//Prepare SELECT SQL statement

  1105 	_LIT8(KSqlStmt3, "SELECT * FROM A");

  1106 	RSqlStatement stmt = PrepareSqlStmt<TDesC, TBuf<KSqlBufSize> >(db, KSqlStmt3, KErrNone);

  1108 	//Move on row 1

  1109 	rc = stmt.Next();

  1110 	TEST2(rc, KSqlAtRow);

  1112 	//An attempt to read integer column using binary stream

  1113 	RSqlColumnReadStream strm2;

  1114 	rc = strm2.ColumnBinary(stmt, 0);

  1115 	strm2.Close();

  1116 	TEST2(rc, KErrArgument);

  1118 	//An attempt to read integer column using text stream

  1119 	rc = strm2.ColumnText(stmt, 0);

  1120 	strm2.Close();

  1121 	TEST2(rc, KErrArgument);

  1123 	//Read the long text column using a stream

  1124 	RSqlColumnReadStream columnStream;

  1125 	rc = columnStream.ColumnText(stmt, 1);

  1126 	columnStream.Close();

  1127 	TEST2(rc, KErrNone);

  1129 	//...and the leaving version of ColumnText()

  1130 	TRAP(rc, columnStream.ColumnTextL(stmt, 1));

  1131 	TEST2(rc, KErrNone);

  1133 	TInt size = stmt.ColumnSize(1);

  1134 	TPtr colData = buf->Des();

  1135 	TRAP(rc, columnStream.ReadL(colData, size));

  1136 	columnStream.Close();

  1137 	TEST2(rc, KErrNone);

  1139 	//Check the column value

  1140 	for(i=0;i<KTextLen;++i)

  1141 		{

  1142 		TEST(colData[i] == (TUint8)KChar1);

  1143 		}

  1145 	//Move on row 2

  1146 	rc = stmt.Next();

  1147 	TEST2(rc, KSqlAtRow);

  1149 	//Read row 2 using ColumnText(TInt aColumnIndex, TPtrC& aPtr).

  1150 	TPtrC colDataPtr;

  1151 	rc = stmt.ColumnText(1, colDataPtr);

  1152 	TEST2(rc, KErrNone);

  1154 	//Check the column value

  1155 	for(i=0;i<KTextLen;++i)

  1156 		{

  1157 		TEST(colDataPtr[i] == (TUint8)KChar2);

  1158 		}

  1160 	//Read row 2 using ColumnText(TInt aColumnIndex, TDes& aDest).

  1161 	rc = stmt.ColumnText(1, colData);

  1162 	TEST2(rc, KErrNone);

  1163 	//Too small target buffer

  1164 	TBuf<3> buf1;

  1165     rc = stmt.ColumnText(1, buf1);

  1166     TEST2(rc, KErrOverflow);

  1168 	//Check the column value

  1169 	for(i=0;i<KTextLen;++i)

  1170 		{

  1171 		TEST(colData[i] == (TUint8)KChar2);

  1172 		}

  1174 	//Read row 2 using a stream

  1175 	colData.Zero();

  1176 	rc = columnStream.ColumnText(stmt, 1);

  1177 	TEST2(rc, KErrNone);

  1178 	size = stmt.ColumnSize(1);

  1179 	TRAP(rc, columnStream.ReadL(colData, size));

  1180 	columnStream.Close();

  1181 	TEST2(rc, KErrNone);

  1183 	//Check the column value

  1184 	for(i=0;i<KTextLen;++i)

  1185 		{

  1186 		TEST(colData[i] == (TUint8)KChar2);

  1187 		}

  1189 	//Read the column value using RSqlStatement::ColumnText().

  1190 	//The recipient buffer max length is smaller than the column value length.

  1191 	rc = stmt.Reset();

  1192 	TEST2(rc, KErrNone);

  1193 	rc = stmt.Next();

  1194 	TEST2(rc, KSqlAtRow);

  1195 	const TInt KBufMaxLen = 100;

  1196 	TBuf<KBufMaxLen> colBuf;

  1197 	rc = stmt.ColumnText(1, colBuf);

  1198 	TEST2(rc, KErrOverflow);

  1199 	//Check the column value

  1200 	for(i=0;i<KBufMaxLen;++i)

  1201 		{

  1202 		TEST(colBuf[i] == (TUint8)KChar1);

  1203 		}

  1205 	stmt.Close();

  1207 	//Deallocate buf

  1208 	delete buf;

  1209 	buf = NULL;

  1211 	db.Close();

  1213 	rc = RSqlDatabase::Delete(KTestDbName1);

  1214 	TEST2(rc, KErrNone);

  1215 	}

  1217 /**

  1218 @SYMTestCaseID			SYSLIB-SQL-CT-1621

  1219 @SYMTestCaseDesc		Retrieving long binary column values test.

  1220 						Retrieving long column values using RSqlStatement::ColumnBinary() when the recipient buffer

  1221 						is not big enough.

  1222 @SYMTestPriority		High

  1223 @SYMTestActions			RSqlColumnReadStream::ColumnBinary() test.

  1224 @SYMTestExpectedResults Test must not fail

  1225 @SYMREQ					REQ5792

  1226                         REQ5793

  1227 */

  1228 void ColumnBinaryStreamTest()

  1229 	{

  1230 	RSqlDatabase db;

  1231 	TInt rc = db.Create(KTestDbName1);

  1232 	TEST2(rc, KErrNone);

  1234 	enum {KSqlBufSize = 64};

  1236 	//Create a table

  1237 	_LIT8(KSqlStmt1, "CREATE TABLE A(Fld1 INTEGER, Fld2 BLOB);");

  1238 	ExecSqlStmtOnDb<TDesC8, TBuf8<KSqlBufSize> >(db, KSqlStmt1(), KErrNone);

  1240 	const TInt KDataLen = 3311;

  1242 	_LIT8(KSqlStmt2, "INSERT INTO A(Fld1, Fld2) VALUES(");

  1244 	//Allocate a buffer for the SQL statement.

  1245 	HBufC8* buf = HBufC8::New(KSqlStmt2().Length() + KDataLen * 2 + 10);//"* 2" - SQL statement with HEX values

  1246 	TEST(buf != NULL);

  1248 	TPtr8 sql = buf->Des();

  1250 	//Insert row 1

  1252 	const TUint8 KHexVal1 = 0x7E;

  1253 	_LIT8(KHexValStr1, "7E");

  1254 	sql.Copy(KSqlStmt2);

  1255 	sql.Append(_L8("1, x'"));

  1256 	TInt i;

  1257 	for(i=0;i<KDataLen;++i)

  1258 		{

  1259 		sql.Append(KHexValStr1);

  1260 		}

  1261 	sql.Append(_L8("')"));

  1263 	rc = db.Exec(sql);

  1264 	TEST2(rc, 1);

  1266 	//Insert row 2

  1268 	const TUint8 KHexVal2 = 0xA3;

  1269 	_LIT8(KHexValStr2, "A3");

  1270 	sql.Copy(KSqlStmt2);

  1271 	sql.Append(_L8("2, x'"));

  1272 	for(i=0;i<KDataLen;++i)

  1273 		{

  1274 		sql.Append(KHexValStr2);

  1275 		}

  1276 	sql.Append(_L8("')"));

  1278 	rc = db.Exec(sql);

  1279 	TEST2(rc, 1);

  1281     //Insert row 3: the binary column length is just 2 bytes

  1282     rc = db.Exec(_L("INSERT INTO A VALUES(3, x'A5D3')"));

  1283     TEST2(rc, 1);

  1285 	//Prepare SELECT SQL statement

  1286 	_LIT8(KSqlStmt3, "SELECT * FROM A");

  1287 	RSqlStatement stmt = PrepareSqlStmt<TDesC8, TBuf8<KSqlBufSize> >(db, KSqlStmt3, KErrNone);

  1289 	//Move on row 1

  1290 	rc = stmt.Next();

  1291 	TEST2(rc, KSqlAtRow);

  1293 	//Read the long binary column using a stream

  1294 	RSqlColumnReadStream columnStream;

  1295 	rc = columnStream.ColumnBinary(stmt, 1);

  1296 	columnStream.Close();

  1297 	TEST2(rc, KErrNone);

  1299 	//...and the leaving version of ColumnBinary()

  1300 	TRAP(rc, columnStream.ColumnBinaryL(stmt, 1));

  1301 	TEST2(rc, KErrNone);

  1303 	TInt size = stmt.ColumnSize(1);

  1304 	TPtr8 colData = buf->Des();

  1305 	TRAP(rc, columnStream.ReadL(colData, size));

  1306 	columnStream.Close();

  1307 	TEST2(rc, KErrNone);

  1309 	//Check the column value

  1310 	for(i=0;i<KDataLen;++i)

  1311 		{

  1312 		TUint8 val = colData[i];

  1313 		TEST(val = KHexVal1);

  1314 		}

  1316 	//Move on row 2

  1317 	rc = stmt.Next();

  1318 	TEST2(rc, KSqlAtRow);

  1320 	//Read row 2 using ColumnBinary(TInt aColumnIndex, TPtrC8& aPtr).

  1321 	TPtrC8 colDataPtr;

  1322 	rc = stmt.ColumnBinary(1, colDataPtr);

  1323 	TEST2(rc, KErrNone);

  1325 	//Check the column value

  1326 	for(i=0;i<KDataLen;++i)

  1327 		{

  1328 		TUint8 val = colDataPtr[i];

  1329 		TEST(val = KHexVal2);

  1330 		}

  1332 	//Read row 2 using ColumnBinary(TInt aColumnIndex, TDes8& aDest).

  1333 	rc = stmt.ColumnBinary(1, colData);

  1334 	TEST2(rc, KErrNone);

  1336 	//Check the column value

  1337 	for(i=0;i<KDataLen;++i)

  1338 		{

  1339 		TUint8 val = colData[i];

  1340 		TEST(val = KHexVal2);

  1341 		}

  1343 	//Read row 2 using a stream

  1344 	colData.Zero();

  1345 	rc = columnStream.ColumnBinary(stmt, 1);

  1346 	TEST2(rc, KErrNone);

  1347 	size = stmt.ColumnSize(1);

  1348 	TRAP(rc, columnStream.ReadL(colData, size));

  1349 	columnStream.Close();

  1350 	TEST2(rc, KErrNone);

  1352 	//Check the column value

  1353 	for(i=0;i<KDataLen;++i)

  1354 		{

  1355 		TUint8 val = colData[i];

  1356 		TEST(val = KHexVal2);

  1357 		}

  1359 	//Read the column value using RSqlStatement::ColumnBinary().

  1360 	//The recipient buffer max length is smaller than the column value length.

  1361 	rc = stmt.Reset();

  1362 	TEST2(rc, KErrNone);

  1363 	rc = stmt.Next();

  1364 	TEST2(rc, KSqlAtRow);

  1365 	const TInt KBufMaxLen = 100;

  1366 	TBuf8<KBufMaxLen> colBuf;

  1367 	rc = stmt.ColumnBinary(1, colBuf);

  1368 	TEST2(rc, KErrOverflow);

  1369 	//Check the column value

  1370 	for(i=0;i<KBufMaxLen;++i)

  1371 		{

  1372 		TUint8 val = colBuf[i];

  1373 		TEST(val = KHexVal2);

  1374 		}

  1376     //Move on row 3. The binary column value length is just 2 bytes.

  1377     rc = stmt.Next();

  1378     TEST2(rc, KSqlAtRow);

  1379     rc = stmt.Next();

  1380     TEST2(rc, KSqlAtRow);

  1381     TBuf8<2> buf1;

  1382     rc = stmt.ColumnBinary(1, buf1);

  1383     TEST2(rc, KErrNone);

  1384     TEST2(buf1.Length(), 2);

  1385     TBuf8<1> buf2;

  1386     rc = stmt.ColumnBinary(1, buf2);

  1387     TEST2(rc, KErrOverflow);

  1389 	stmt.Close();

  1391 	//Deallocate buf

  1392 	delete buf;

  1393 	buf = NULL;

  1395 	db.Close();

  1397 	rc = RSqlDatabase::Delete(KTestDbName1);

  1398 	TEST2(rc, KErrNone);

  1399 	}

  1401 /**

  1402 @SYMTestCaseID          PDS-SQL-CT-4191

  1403 @SYMTestCaseDesc        The test creates a test database and inserts one record using a stream.

  1404                         MStreamBuf::SeekL() is used to modify the parameter data at specific positions.

  1405                         Then the test executes a SELECT statement to read the just written record.

  1406                         MStreamBuf::SeekL() is used to read the column content at specific positions

  1407                         (the same positions used during the record write operation). The read byte values must

  1408                         match the written byte values.

  1409 @SYMTestPriority        High

  1410 @SYMTestActions         RSqlColumnReadStream::ColumnBinary() and RSqlParamWriteStream::BindBinary() - MStreamBuf::SeekL() test.

  1411 @SYMTestExpectedResults Test must not fail

  1412 @SYMDEF                 DEF145125

  1413 */

  1414 void StreamSeekTestL()

  1415     {

  1416     RSqlDatabase db;

  1417     CleanupClosePushL(db);

  1418     TInt rc = db.Create(KTestDbName1);

  1419     TEST2(rc, KErrNone);

  1420     rc = db.Exec(_L("CREATE TABLE A(Fld1 INTEGER, Fld2 BLOB)"));

  1421     TEST(rc >= 0);

  1422     //Write a record to the database using a stream. MStreamBuf::SeekL() is used to modify the content at a specific position.

  1423     RSqlStatement stmt;

  1424     CleanupClosePushL(stmt);

  1425     rc = stmt.Prepare(db, _L("INSERT INTO A(Fld1, Fld2) VALUES(1, ?)"));

  1426     TEST2(rc, KErrNone);

  1428     RSqlParamWriteStream strm1;

  1429     CleanupClosePushL(strm1);

  1430     rc = strm1.BindBinary(stmt, 0);

  1431     TEST2(rc, KErrNone);

  1433     for(TInt i=0;i<256;++i)

  1434         {

  1435         strm1 << (TUint8)i;

  1436         }

  1438     const TInt KStreamOffset = 10;

  1439     const TUint8 KByte = 'z';

  1440     _LIT8(KData, "QWERTYUIOPASDFG");

  1442     MStreamBuf* strm1buf = strm1.Sink();

  1443     TEST(strm1buf != NULL);

  1445     strm1buf->SeekL(MStreamBuf::EWrite, EStreamBeginning, 0);

  1446     strm1buf->WriteL(&KByte, 1);

  1448     strm1buf->SeekL(MStreamBuf::EWrite, EStreamMark, KStreamOffset);

  1449     strm1buf->WriteL(&KByte, 1);

  1451     strm1buf->SeekL(MStreamBuf::EWrite, EStreamEnd, 0);

  1452     strm1buf->WriteL(KData().Ptr(), KData().Length());

  1454     strm1buf->SeekL(MStreamBuf::EWrite, EStreamEnd, -4 * KStreamOffset);

  1455     strm1buf->WriteL(&KByte, 1);

  1457     strm1.CommitL();

  1458     CleanupStack::PopAndDestroy(&strm1);

  1460     rc = stmt.Exec();

  1461     TEST2(rc, 1);

  1462     CleanupStack::PopAndDestroy(&stmt);

  1464     //Read the record using a stream. MStreamBuf::SeekL() is used to read the content at a specific position.

  1465     CleanupClosePushL(stmt);

  1466     rc = stmt.Prepare(db, _L("SELECT Fld2 FROM A WHERE Fld1 = 1"));

  1467     TEST2(rc, KErrNone);

  1468     rc = stmt.Next();

  1469     TEST2(rc, KSqlAtRow);

  1471     RSqlColumnReadStream strm2;

  1472     CleanupClosePushL(strm2);

  1473     rc = strm2.ColumnBinary(stmt, 0);

  1474     TEST2(rc, KErrNone);

  1476     TUint8 byte = 0;

  1477     MStreamBuf* strm2buf = strm2.Source();

  1478     TEST(strm1buf != NULL);

  1480     strm2buf->SeekL(MStreamBuf::ERead, EStreamBeginning, 0);

  1481     rc = strm2buf->ReadL(&byte, 1);

  1482     TEST2(rc, 1);

  1483     TEST2(byte, KByte);

  1485     strm2buf->SeekL(MStreamBuf::ERead, EStreamMark, KStreamOffset);

  1486     rc = strm2buf->ReadL(&byte, 1);

  1487     TEST2(rc, 1);

  1488     TEST2(byte, KByte);

  1490     strm2buf->SeekL(MStreamBuf::ERead, EStreamEnd, -KData().Length());

  1491     TUint8 buf[20];

  1492     rc = strm2buf->ReadL(buf, KData().Length());

  1493     TEST2(rc, KData().Length());

  1494     TPtrC8 bufptr(buf, rc);

  1495     TEST(bufptr == KData);

  1497     strm2buf->SeekL(MStreamBuf::ERead, EStreamEnd, -4 * KStreamOffset);

  1498     rc = strm2buf->ReadL(&byte, 1);

  1499     TEST2(rc, 1);

  1500     TEST2(byte, KByte);

  1502     CleanupStack::PopAndDestroy(&strm2);

  1503     CleanupStack::PopAndDestroy(&stmt);

  1505     CleanupStack::PopAndDestroy(&db);

  1506     rc = RSqlDatabase::Delete(KTestDbName1);

  1507     TEST2(rc, KErrNone);

  1508     }

  1510 /**

  1511 @SYMTestCaseID          PDS-SQL-CT-4174

  1512 @SYMTestCaseDesc        Test for DEF144937: SQL, SQL server, the code coverage can be improved in some areas.

  1513 @SYMTestPriority        High

  1514 @SYMTestActions         The test creates a test database with a table with 3 records.

  1515                         The first record has a BLOB column with 0 length.

  1516                         The second record has a BLOB column with length less than KSqlMaxDesLen

  1517                         (in debug mode) in which case no IPC call is needed to be made in order

  1518                         to access the column value via stream.

  1519                         The third record has a BLOB column with length exactly KSqlMaxDesLen

  1520                         in which case an IPC call will be made in order to retrieve the column value,

  1521                         but the column value will be copied directly to the client - no stream object is created.

  1522 @SYMTestExpectedResults Test must not fail

  1523 @SYMDEF                 DEF144937

  1524 */

  1525 void ColumnBinaryStreamTest2()

  1526     {

  1527     RSqlDatabase db;

  1528     TInt rc = db.Create(KTestDbName1);

  1529     TEST2(rc, KErrNone);

  1531     enum {KSqlBufSize = 128};

  1533     //Create a table

  1534     _LIT8(KSqlStmt1, "CREATE TABLE A(Fld1 INTEGER, Fld2 BLOB);");

  1535     ExecSqlStmtOnDb<TDesC8, TBuf8<KSqlBufSize> >(db, KSqlStmt1(), KErrNone);

  1537     //Insert one record where the BLOB length is 0.

  1538     //Insert second record where the BLOB length is smaller than the max inline column length - KSqlMaxDesLen.

  1539     //Insert third record where the BLOB length is exactly the max inline column length - KSqlMaxDesLen.

  1540     _LIT8(KSqlStmt2, "INSERT INTO A VALUES(1, '');INSERT INTO A VALUES(2, x'0102030405');INSERT INTO A VALUES(3, x'0102030405060708');");

  1541     ExecSqlStmtOnDb<TDesC8, TBuf8<KSqlBufSize> >(db, KSqlStmt2(), KErrNone);

  1543     RSqlStatement stmt;

  1544     rc = stmt.Prepare(db, _L("SELECT Fld2 FROM A"));

  1545     TEST2(rc, KErrNone);

  1547     TBuf8<16> databuf;

  1549     rc = stmt.Next();

  1550     TEST2(rc, KSqlAtRow);

  1551     //ColumnBinary() does not make an IPC call because the BLOB length is 0.

  1552     RSqlColumnReadStream strm;

  1553     rc = strm.ColumnBinary(stmt, 0);

  1554     TEST2(rc, KErrNone);

  1555     TRAP(rc, strm.ReadL(databuf, stmt.ColumnSize(0)));

  1556     strm.Close();

  1557     TEST2(rc, KErrNone);

  1558     TEST2(databuf.Length(), 0);

  1560     rc = stmt.Next();

  1561     TEST2(rc, KSqlAtRow);

  1562     //ColumnBinary() does not make an IPC call because the BLOB length is less than the max inline

  1563     //column length - KSqlMaxDesLen.

  1564     rc = strm.ColumnBinary(stmt, 0);

  1565     TEST2(rc, KErrNone);

  1566     TRAP(rc, strm.ReadL(databuf, stmt.ColumnSize(0)));

  1567     strm.Close();

  1568     TEST2(rc, KErrNone);

  1569     TEST(databuf == _L8("\x1\x2\x3\x4\x5"));

  1571     rc = stmt.Next();

  1572     TEST2(rc, KSqlAtRow);

  1573     //ColumnBinary() makes an IPC call  (in _DEBUG mode) because:

  1574     // - the column length is exactly KSqlMaxDesLen.

  1575     // - but at the same time the column length is equal to KIpcBufSize (in debug mode).

  1576     rc = strm.ColumnBinary(stmt, 0);

  1577     TEST2(rc, KErrNone);

  1578     TRAP(rc, strm.ReadL(databuf, stmt.ColumnSize(0)));

  1579     strm.Close();

  1580     TEST2(rc, KErrNone);

  1581     TEST(databuf == _L8("\x1\x2\x3\x4\x5\x6\x7\x8"));

  1583     stmt.Close();

  1584     db.Close();

  1586     rc = RSqlDatabase::Delete(KTestDbName1);

  1587     TEST2(rc, KErrNone);

  1588     }

  1590 /**

  1591 @SYMTestCaseID			SYSLIB-SQL-CT-1608

  1592 @SYMTestCaseDesc		Setting long text parameter values test.

  1593 @SYMTestPriority		High

  1594 @SYMTestActions			RSqlParamWriteStream::BindText() test.

  1595 @SYMTestExpectedResults Test must not fail

  1596 @SYMREQ					REQ5792

  1597                         REQ5793

  1598 */

  1599 void TextParameterStreamTest()

  1600 	{

  1601 	RSqlDatabase db;

  1602 	TInt rc = db.Create(KTestDbName1);

  1603 	TEST2(rc, KErrNone);

  1605 	enum {KSqlBufSize = 64};

  1607 	//Create a table

  1608 	_LIT8(KSqlStmt1, "CREATE TABLE A(Fld1 INTEGER, Fld2 TEXT);");

  1609 	ExecSqlStmtOnDb<TDesC8, TBuf8<KSqlBufSize> >(db, KSqlStmt1(), KErrNone);

  1611 	const TInt KTextLen = 3001;

  1613 	_LIT(KSqlStmt2, "INSERT INTO A(Fld1, Fld2) VALUES(");

  1615 	//Allocate a buffer for the SQL statement.

  1616 	HBufC* buf = HBufC::New(KSqlStmt2().Length() + KTextLen + 10);

  1617 	TEST(buf != NULL);

  1619 	TPtr sql = buf->Des();

  1621 	//Insert a row

  1623 	const TChar KChar('g');

  1624 	sql.Copy(KSqlStmt2);

  1625 	sql.Append(_L("1, '"));

  1626 	TInt i;

  1627 	for(i=0;i<KTextLen;++i)

  1628 		{

  1629 		sql.Append(KChar);

  1630 		}

  1631 	sql.Append(_L("')"));

  1633 	rc = db.Exec(sql);

  1634 	TEST2(rc, 1);

  1636 	//Prepare parametrized SQL statement

  1637 	_LIT8(KSqlStmt3, "SELECT * FROM A WHERE Fld2 = :Val");

  1638 	RSqlStatement stmt = PrepareSqlStmt<TDesC, TBuf<KSqlBufSize> >(db, KSqlStmt3, KErrNone);

  1640 	//Open the parameter stream

  1641 	RSqlParamWriteStream paramStream;

  1642 	rc = paramStream.BindText(stmt, 0);

  1643 	paramStream.Close();

  1644 	TEST2(rc, KErrNone);

  1646 	//...and the leaving version of BindText()

  1647 	TRAP(rc, paramStream.BindTextL(stmt, 0));

  1648 	TEST2(rc, KErrNone);

  1650 	//Prepare and set the parameter value

  1651 	TPtr val = buf->Des();

  1652 	val.Zero();

  1653 	for(i=0;i<KTextLen;++i)

  1654 		{

  1655 		val.Append(KChar);

  1656 		}

  1657 	TRAP(rc, (paramStream.WriteL(val), paramStream.CommitL()));

  1658 	TEST2(rc, KErrNone);

  1660 	//Move on row 1

  1661 	rc = stmt.Next();

  1662 	TEST2(rc, KSqlAtRow);

  1664 	paramStream.Close();

  1666 	//Read the row using ColumnText(TInt aColumnIndex, TPtrC& aPtr).

  1667 	TPtrC colDataPtr;

  1668 	rc = stmt.ColumnText(1, colDataPtr);

  1669 	TEST2(rc, KErrNone);

  1671 	//Check the column value

  1672 	for(i=0;i<KTextLen;++i)

  1673 		{

  1674 		TEST(colDataPtr[i] == (TUint8)KChar);

  1675 		}

  1677 	stmt.Close();

  1679 	//Deallocate buf

  1680 	delete buf;

  1681 	buf = NULL;

  1683 	///////////////////////////////////////////////////////////////////////////////////////////////

  1684 	//Open a "short" text parameter. The streaming API should work with "short" text parameters too.

  1685 	_LIT(KTextVal, "U012");

  1687 	//Delete all records

  1688 	_LIT8(KSqlStmt4, "DELETE FROM A");

  1689 	ExecSqlStmtOnDb<TDesC8, TBuf8<KSqlBufSize> >(db, KSqlStmt4(), KErrNone);

  1691 	//Prepare INSERT SQL statement.

  1692 	_LIT8(KSqlStmt5, "INSERT INTO A(Fld1, Fld2) VALUES(1, :Val)");

  1693 	stmt = PrepareSqlStmt<TDesC, TBuf<KSqlBufSize> >(db, KSqlStmt5, KErrNone);

  1695 	//Open the parameter stream

  1696 	rc = paramStream.BindText(stmt, 0);

  1697 	TEST2(rc, KErrNone);

  1699 	//Prepare and set the parameter value

  1700 	TRAP(rc, (paramStream.WriteL(KTextVal), paramStream.CommitL()));

  1701 	TEST2(rc, KErrNone);

  1703 	//Execute the prepared SQL statement

  1704 	rc = stmt.Exec();

  1705 	TEST2(rc, 1);

  1707 	paramStream.Close();

  1708 	stmt.Close();

  1710 	//Prepare SELECT SQL statement

  1711 	_LIT8(KSqlStmt6, "SELECT * FROM A WHERE Fld1 = 1");

  1712 	stmt = PrepareSqlStmt<TDesC, TBuf<KSqlBufSize> >(db, KSqlStmt6, KErrNone);

  1714 	//Move on row 1

  1715 	rc = stmt.Next();

  1716 	TEST2(rc, KSqlAtRow);

  1718 	///////////////////////////////////////////////////////////////////////////////////////////////

  1719 	//Open a stream for a "short" text column. The streaming API should work with "short" text columns too.

  1721 	TBuf<20> columnVal;

  1722 	RSqlColumnReadStream columnStream;

  1723 	rc = columnStream.ColumnText(stmt, 1);

  1724 	TEST2(rc, KErrNone);

  1725 	TInt size = stmt.ColumnSize(1);

  1726 	TRAP(rc, columnStream.ReadL(columnVal, size));

  1727 	columnStream.Close();

  1728 	TEST2(rc, KErrNone);

  1730 	//Check the column value

  1731 	TEST(columnVal == KTextVal);

  1733 	stmt.Close();

  1735 	db.Close();

  1737 	rc = RSqlDatabase::Delete(KTestDbName1);

  1738 	TEST2(rc, KErrNone);

  1739 	}

  1741 /**

  1742 @SYMTestCaseID			SYSLIB-SQL-CT-1622

  1743 @SYMTestCaseDesc		Setting long binary parameter values test.

  1744 @SYMTestPriority		High

  1745 @SYMTestActions			RSqlParamWriteStream::BindBinary() test.

  1746 @SYMTestExpectedResults Test must not fail

  1747 @SYMREQ					REQ5792

  1748                         REQ5793

  1749 */

  1750 void BinaryParameterStreamTest()

  1751 	{

  1752 	//Create a test database

  1753 	RSqlDatabase db;

  1754 	TInt rc = db.Create(KTestDbName1);

  1755 	TEST2(rc, KErrNone);

  1757 	enum {KSqlBufSize = 64};

  1759 	//Create a table

  1760 	_LIT8(KSqlStmt1, "CREATE TABLE A(Fld1 INTEGER, Fld2 BLOB);");

  1761 	ExecSqlStmtOnDb<TDesC8, TBuf8<KSqlBufSize> >(db, KSqlStmt1(), KErrNone);

  1763 	const TInt KDataLen = 3731;

  1765 	_LIT8(KSqlStmt2, "INSERT INTO A(Fld1, Fld2) VALUES(");

  1767 	//Allocate a buffer for the SQL statement.

  1768 	HBufC8* buf = HBufC8::New(KSqlStmt2().Length() + KDataLen * 2 + 10);//"* 2" - SQL statement with HEX values

  1769 	TEST(buf != NULL);

  1771 	TPtr8 sql = buf->Des();

  1773 	//Insert a row

  1775 	const TUint8 KHexVal = 0xD3;

  1776 	_LIT8(KHexValStr, "D3");

  1777 	sql.Copy(KSqlStmt2);

  1778 	sql.Append(_L8("1, x'"));

  1779 	TInt i;

  1780 	for(i=0;i<KDataLen;++i)

  1781 		{

  1782 		sql.Append(KHexValStr);

  1783 		}

  1784 	sql.Append(_L8("')"));

  1786 	rc = db.Exec(sql);

  1787 	TEST2(rc, 1);

  1789 	//Prepare parametrized SQL statement

  1790 	_LIT8(KSqlStmt3, "SELECT * FROM A WHERE Fld2 = :Val");

  1791 	RSqlStatement stmt = PrepareSqlStmt<TDesC8, TBuf8<KSqlBufSize> >(db, KSqlStmt3, KErrNone);

  1793 	//Open the parameter stream

  1794 	RSqlParamWriteStream paramStream;

  1795 	rc = paramStream.BindBinary(stmt, 0);

  1796 	TEST2(rc, KErrNone);

  1797 	paramStream.Close();

  1798     //Open the parameter stream with BindBinaryL()

  1799     TRAP(rc, paramStream.BindBinaryL(stmt, 0));

  1800     TEST2(rc, KErrNone);

  1802 	//Prepare and set the parameter value (NULL parameter value)

  1803 	TPtr8 prmVal = buf->Des();

  1804 	prmVal.SetLength(0);

  1806 	TRAP(rc, (paramStream.WriteL(prmVal), paramStream.CommitL()));

  1807 	TEST2(rc, KErrNone);

  1809 	rc = stmt.Next();

  1810 	TEST2(rc, KSqlAtEnd);

  1812 	paramStream.Close();

  1813 	stmt.Reset();

  1815 	//Prepare and set the parameter value (non-NULL binary value)

  1816 	rc = paramStream.BindBinary(stmt, 0);

  1817 	TEST2(rc, KErrNone);

  1819 	prmVal.SetLength(KDataLen);

  1820 	for(i=0;i<KDataLen;++i)

  1821 		{

  1822 		prmVal[i] = KHexVal;

  1823 		}

  1824 	TRAP(rc, (paramStream.WriteL(prmVal), paramStream.CommitL()));

  1825 	TEST2(rc, KErrNone);

  1827 	//Move on row 1

  1828 	rc = stmt.Next();

  1829 	TEST2(rc, KSqlAtRow);

  1831 	paramStream.Close();

  1833 	//Read the row using ColumnBinary(TInt aColumnIndex, TPtrC8& aPtr).

  1834 	TPtrC8 colDataPtr;

  1835 	rc = stmt.ColumnBinary(1, colDataPtr);

  1836 	TEST2(rc, KErrNone);

  1838 	//Check the column value

  1839 	for(i=0;i<KDataLen;++i)

  1840 		{

  1841 		TUint8 byte = colDataPtr[i];

  1842 		TEST(byte == KHexVal);

  1843 		}

  1845 	stmt.Close();

  1847 	//Deallocate buf

  1848 	delete buf;

  1849 	buf = NULL;

  1852 	///////////////////////////////////////////////////////////////////////////////////////////////

  1853 	//Open a "short" binary parameter. The streaming API should work with "short" binary parameters too.

  1854 	_LIT8(KBinVal, "\x1\x2\x3\x4");

  1856 	//Delete all records

  1857 	_LIT8(KSqlStmt4, "DELETE FROM A");

  1858 	ExecSqlStmtOnDb<TDesC8, TBuf8<KSqlBufSize> >(db, KSqlStmt4(), KErrNone);

  1860 	//Prepare INSERT SQL statement.

  1861 	_LIT8(KSqlStmt5, "INSERT INTO A(Fld1, Fld2) VALUES(1, :Val)");

  1862 	stmt = PrepareSqlStmt<TDesC, TBuf<KSqlBufSize> >(db, KSqlStmt5, KErrNone);

  1864 	//Open the parameter stream

  1865 	rc = paramStream.BindBinary(stmt, 0);

  1866 	TEST2(rc, KErrNone);

  1868 	//Prepare and set the parameter value

  1869 	TRAP(rc, (paramStream.WriteL(KBinVal), paramStream.CommitL()));

  1870 	TEST2(rc, KErrNone);

  1872 	//Execute the prepared SQL statement

  1873 	rc = stmt.Exec();

  1874 	TEST2(rc, 1);

  1876 	paramStream.Close();

  1877 	stmt.Close();

  1879 	//Prepare SELECT SQL statement

  1880 	_LIT8(KSqlStmt6, "SELECT * FROM A WHERE Fld1 = 1");

  1881 	stmt = PrepareSqlStmt<TDesC, TBuf<KSqlBufSize> >(db, KSqlStmt6, KErrNone);

  1883 	//Move on row 1

  1884 	rc = stmt.Next();

  1885 	TEST2(rc, KSqlAtRow);

  1887 	///////////////////////////////////////////////////////////////////////////////////////////////

  1888 	//Open a stream for a "short" binary column. The streaming API should work with "short" binary columns too.

  1890 	TBuf8<20> columnVal;

  1891 	RSqlColumnReadStream columnStream;

  1892 	rc = columnStream.ColumnBinary(stmt, 1);

  1893 	TEST2(rc, KErrNone);

  1894 	TInt size = stmt.ColumnSize(1);

  1895 	TRAP(rc, columnStream.ReadL(columnVal, size));

  1896 	columnStream.Close();

  1897 	TEST2(rc, KErrNone);

  1899 	//Check the column value

  1900 	TEST(columnVal == KBinVal);

  1902 	stmt.Close();

  1904 	db.Close();

  1906 	rc = RSqlDatabase::Delete(KTestDbName1);

  1907 	TEST2(rc, KErrNone);

  1908 	}

  1910 /**

  1911 @SYMTestCaseID			SYSLIB-SQL-CT-1634

  1912 @SYMTestCaseDesc		RSqlStatement test - nameless parameter.

  1913 						Tests RSqlStatement behaviour if the prepared statement has nameless parameters.

  1914 @SYMTestPriority		High

  1915 @SYMTestActions			RSqlStatement test - nameless parameter.

  1916 @SYMTestExpectedResults Test must not fail

  1917 @SYMREQ					REQ5792

  1918                         REQ5793

  1919 */

  1920 void NamelessParameterTest()

  1921 	{

  1922 	//Create a test database

  1923 	RSqlDatabase db;

  1924 	TInt rc = db.Create(KTestDbName1);

  1925 	TEST2(rc, KErrNone);

  1927 	rc = db.Exec(_L("CREATE TABLE A(F1 INTEGER, F2 INTEGER, F3 INTEGER)"));

  1928 	TEST(rc >= 0);

  1930 	RSqlStatement stmt;

  1931 	rc = stmt.Prepare(db, _L("SELECT * FROM A WHERE F1 = ? AND F2 = ? AND F3 = :Val"));

  1932 	TEST2(rc, KErrNone);

  1934 	TEST(stmt.ParameterIndex(_L("?0")) == 0);

  1935 	TEST(stmt.ParameterIndex(_L("?1")) == 1);

  1936 	TEST(stmt.ParameterIndex(_L(":VAL")) == 2);

  1938 	stmt.Close();

  1940 	db.Close();

  1941 	rc = RSqlDatabase::Delete(KTestDbName1);

  1942 	TEST2(rc, KErrNone);

  1943 	}

  1945 //Reads a SQL file and returns the file content as HBUFC string.

  1946 //The caller is responsible for destroying the returned HBUFC object.

  1947 template <class HBUFC> HBUFC* ReadSqlScript(const TDesC& aSqlFileName)

  1948 	{

  1949 	RFs fs;

  1950 	TEST2(fs.Connect(), KErrNone);

  1952 	RFile file;

  1953 	TEST2(file.Open(fs, aSqlFileName, EFileRead), KErrNone);

  1955 	TInt size = 0;

  1956 	TEST2(file.Size(size), KErrNone);

  1958 	HBufC8* sql = HBufC8::New(size);

  1959 	TEST(sql != NULL);

  1961 	TPtr8 ptr = sql->Des();

  1962 	TEST2(file.Read(ptr, size), KErrNone);

  1964 	file.Close();

  1965 	fs.Close();

  1967 	HBUFC* sql2 = HBUFC::New(size);

  1968 	TEST(sql2 != NULL);

  1969 	sql2->Des().Copy(sql->Des());

  1970 	delete sql;

  1972 	return sql2;

  1973 	}

  1974 //Explicit ReadSqlScript() template instantiations.

  1975 template HBufC8* ReadSqlScript<HBufC8>(const TDesC&);

  1976 template HBufC16* ReadSqlScript<HBufC16>(const TDesC&);

  1978 //Searches for the next aCommitStr appearance in aSqlScript string and returns a PTRC object holding

  1979 //the SQL strings from the beginning of aSqlScript till the aCommitStr (including it).

  1980 template <class PTRC, class DESC> PTRC GetNextTrans(PTRC& aSqlScript, const DESC& aCommitStr)

  1981 	{

  1982 	PTRC res(NULL, 0);

  1983 	TInt pos = aSqlScript.FindF(aCommitStr);

  1984 	if(pos >= 0)

  1985 		{

  1986 		pos += aCommitStr.Length();

  1987 		res.Set(aSqlScript.Left(pos));

  1988 		aSqlScript.Set(aSqlScript.Mid(pos));

  1989 		}

  1990 	return res;

  1991 	}

  1992 //Explicit GetNextTrans() template instantiations.

  1993 template TPtrC8 GetNextTrans<TPtrC8, TDesC8>(TPtrC8&, const TDesC8&);

  1994 template TPtrC16 GetNextTrans<TPtrC16, TDesC16>(TPtrC16&, const TDesC16&);

  1996 //Creates aDb database schema.

  1997 void CreateDbSchema(RSqlDatabase& aDb)

  1998 	{

  1999 	HBufC8* createDbScript = ReadSqlScript<HBufC8>(KCreateDbScript());

  2000 	TInt err = aDb.Exec(createDbScript->Des());

  2001 	TEST(err >= 0);

  2002 	delete createDbScript;

  2003 	}

  2005 /**

  2006 @SYMTestCaseID			SYSLIB-SQL-CT-1768

  2007 @SYMTestCaseDesc		The test creates a database.

  2008 						Then the test executes 8-bit and 16-bit sql statements asynchronously

  2009 						(using asynchronous versions of RSqlDatabase::Exec() and RSqlStatement::Exec())

  2010 @SYMTestPriority		High

  2011 @SYMTestActions			SQL, Asynchronous sql statements execution.

  2012 @SYMTestExpectedResults Test must not fail

  2013 @SYMREQ					REQ5792

  2014                         REQ5793

  2015 */

  2016 void AsyncTest()

  2017 	{

  2018 	//////////////////////////////////////////////////////////////////////////

  2019 	//Asynchronous execution, 8-bit sql statements

  2020 	//Create the database

  2021 	RSqlDatabase db;

  2022 	TInt err = db.Create(KTestDbName1);

  2023 	TEST2(err, KErrNone);

  2024 	CreateDbSchema(db);

  2025 	//Read the sql script file and execute the statements

  2026 	HBufC8* fillDbScript1 = ReadSqlScript<HBufC8>(KFillDbScript());

  2027 	TPtrC8 ptr1(fillDbScript1->Des());

  2028 	TPtrC8 sql1(GetNextTrans<TPtrC8, TDesC8>(ptr1, KCommitStr8()));

  2029 	TRequestStatus status;

  2030 	db.Exec(sql1, status);

  2031     TEST2(status.Int(), KRequestPending);

  2032     User::WaitForRequest(status);

  2033     TEST(status.Int() >= 0);

  2034 	delete fillDbScript1;

  2035 	//////////////////////////////////////////////////////////////////////////

  2036 	//Asynchronous execution, RSqlStatement::Exec().

  2037 	RSqlStatement stmt;

  2039 	err = stmt.Prepare(db, _L("UPDATE IDENTITYTABLE SET CM_FIRSTNAME=:V1"));

  2040     TEST2(err, KErrNone);

  2041     err = stmt.BindText(0, _L("+++first+++"));

  2042     TEST2(err, KErrNone);

  2043 	stmt.Exec(status);

  2044     TEST2(status.Int(), KRequestPending);

  2045     User::WaitForRequest(status);

  2046     TEST(status.Int() >= 0);

  2047 	stmt.Close();

  2049 	err = stmt.Prepare(db, _L("UPDATE IDENTITYTABLE SET CM_FIRSTNAME='+++first+++'"));

  2050     TEST2(err, KErrNone);

  2051 	stmt.Exec(status);

  2052     TEST2(status.Int(), KRequestPending);

  2053     User::WaitForRequest(status);

  2054     TEST(status.Int() >= 0);

  2055 	stmt.Close();

  2057 	//Verify the UPDATE operation

  2058 	err = stmt.Prepare(db, _L("SELECT COUNT(*) FROM identitytable WHERE cm_firstname = '+++first+++'"));

  2059     TEST2(err, KErrNone);

  2060     err = stmt.Next();

  2061     TEST2(err, KSqlAtRow);

  2062     TInt cnt = stmt.ColumnInt(0);

  2063     TEST2(cnt, 64);

  2064     stmt.Close();

  2065 	//Close and delete the database

  2066 	db.Close();

  2067 	err = RSqlDatabase::Delete(KTestDbName1);

  2068 	TEST2(err, KErrNone);

  2069 	//////////////////////////////////////////////////////////////////////////

  2070 	//Asynchronous execution, 16-bit sql statements

  2071 	//Create the database

  2072 	err = db.Create(KTestDbName1);

  2073 	TEST2(err, KErrNone);

  2074 	CreateDbSchema(db);

  2075 	//Read the sql script file and execute the statements

  2076 	HBufC16* fillDbScript2 = ReadSqlScript<HBufC16>(KFillDbScript());

  2077 	TPtrC16 ptr2(fillDbScript2->Des());

  2078 	TPtrC16 sql2(GetNextTrans<TPtrC16, TDesC16>(ptr2, KCommitStr16()));

  2079 	db.Exec(sql2, status);

  2080     TEST2(status.Int(), KRequestPending);

  2081     User::WaitForRequest(status);

  2082     TEST(status.Int() >= 0);

  2083 	delete fillDbScript2;

  2084 	//Close and delete the database

  2085 	db.Close();

  2086 	err = RSqlDatabase::Delete(KTestDbName1);

  2087 	TEST2(err, KErrNone);

  2088 	}

  2090 /**

  2091 @SYMTestCaseID			SYSLIB-SQL-CT-1816

  2092 @SYMTestCaseDesc		RSqlDatabase::Size() test.

  2093 						Call RSqlDatabase::Size() in various situations and check that the call does not fail.

  2094 @SYMTestPriority		High

  2095 @SYMTestActions			Call RSqlDatabase::Size() in various situations and check that the call does not fail.

  2096 @SYMTestExpectedResults Test must not fail

  2097 @SYMREQ					REQ7141

  2098 */

  2099 void SizeTest()

  2100 	{

  2101 	const TInt KTestDbCnt = 3;

  2102 	TPtrC dbNames[KTestDbCnt];

  2103 	dbNames[0].Set(KTestDbName1); //Non-secure shared database

  2104 	dbNames[1].Set(KTestDbName9); //Private database

  2105 	dbNames[2].Set(KTestDbName7); //Secure shared database

  2107 	TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);

  2108 	RSqlSecurityPolicy securityPolicy;

  2109 	TInt rc = securityPolicy.Create(defaultPolicy);

  2110 	TEST2(rc, KErrNone);

  2112 	for(TInt i=0;i<KTestDbCnt;++i)

  2113 		{

  2114 		(void)RSqlDatabase::Delete(dbNames[i]);

  2115 		RSqlDatabase db;

  2116 		TInt rc = i == 2 ? db.Create(dbNames[i], securityPolicy) : db.Create(dbNames[i]);

  2117 		TEST2(rc, KErrNone);

  2118 		//Check database size

  2119 		TInt size1 = db.Size();

  2120 		TEST(size1 >= 0);

  2121 		//Insert some data and check the size again

  2122 		rc = db.Exec(_L("CREATE TABLE A(Id INTEGER, T TEXT)"));

  2123 		TEST(rc >= 0);

  2124 		rc = db.Exec(_L("INSERT INTO A VALUES(1, '1111111')"));

  2125 		TEST(rc >= 0);

  2126 		rc = db.Exec(_L("INSERT INTO A VALUES(2, '22222222222222')"));

  2127 		TEST(rc >= 0);

  2128 		TInt size2 = db.Size();

  2129 		TEST(size2 > size1);

  2130 		//Check the database size in a transaction

  2131 		rc = db.Exec(_L("BEGIN"));

  2132 		TEST(rc >= 0);

  2133 		TInt size3 = db.Size();

  2134 		TEST(size3 == size2);

  2135 		rc = db.Exec(_L("INSERT INTO A VALUES(3, '3333333333333333333333333333333333333333333333333333333333333')"));

  2136 		TEST(rc >= 0);

  2137 		rc = db.Exec(_L("INSERT INTO A VALUES(4, '4444444444444444444444444444444444444444444444444444444444444')"));

  2138 		TEST(rc >= 0);

  2139 		rc = db.Exec(_L("INSERT INTO A VALUES(5, '5555555555555555555555555555555555555555555555555555555555555')"));

  2140 		TEST(rc >= 0);

  2141 		TInt size4 = db.Size();

  2142 		TEST(size4 == size2);

  2143 		rc = db.Exec(_L("COMMIT"));

  2144 		TEST(rc >= 0);

  2145 		TInt size5 = db.Size();

  2146 		TEST(size5 == size2);

  2147 		//Cleanup

  2148 		db.Close();

  2149 		rc = RSqlDatabase::Delete(dbNames[i]);

  2150 		TEST2(rc, KErrNone);

  2151 		}

  2152 	securityPolicy.Close();

  2153 	}

  2155 /**

  2156 @SYMTestCaseID			SYSLIB-SQL-CT-1817

  2157 @SYMTestCaseDesc		RSqlDatabase::InTransaction() test.

  2158 						Call RSqlDatabase::InTransaction() in various situations and check that the method reports

  2159 						database's transaction state correctly.

  2160 @SYMTestPriority		High

  2161 @SYMTestActions			Call RSqlDatabase::InTransaction() in various situations and check that the method reports

  2162 						database's transaction state correctly.

  2163 @SYMTestExpectedResults Test must not fail

  2164 @SYMREQ					REQ7141

  2165 */

  2166 void InTransactionTest()

  2167 	{

  2168 	(void)RSqlDatabase::Delete(KTestDbName1);

  2169 	RSqlDatabase db;

  2170 	TInt rc = db.Create(KTestDbName1);

  2171 	TEST2(rc, KErrNone);

  2172 	//

  2173 	TBool state = db.InTransaction();

  2174 	TEST(!state);

  2175 	rc = db.Exec(_L("BEGIN"));

  2176 	TEST(rc >= 0);

  2177 	state = db.InTransaction();

  2178 	TEST(!!state);

  2179 	rc = db.Exec(_L("ROLLBACK"));

  2180 	TEST(rc >= 0);

  2181 	state = db.InTransaction();

  2182 	TEST(!state);

  2183 	//Cleanup

  2184 	db.Close();

  2185 	rc = RSqlDatabase::Delete(KTestDbName1);

  2186 	TEST2(rc, KErrNone);

  2187 	}

  2189 /**

  2190 @SYMTestCaseID			SYSLIB-SQL-UT-4039

  2191 @SYMTestCaseDesc		RSqlDatabase::Size(TSize&) functional test.

  2192 						The test creates a non-secure shared database, private database, secure shared database

  2193 						and tests that the new RSqlDatabase::Size(TSize&) can be used on the created databases.

  2194 @SYMTestPriority		High

  2195 @SYMTestActions			RSqlDatabase::Size(TSize&) functional test.

  2196 @SYMTestExpectedResults Test must not fail

  2197 @SYMREQ					REQ10407

  2198 */

  2199 void SizeTest2()

  2200 	{

  2201 	const TInt KTestDbCnt = 3;

  2202 	TPtrC dbNames[KTestDbCnt];

  2203 	dbNames[0].Set(KTestDbName1); //Non-secure shared database

  2204 	dbNames[1].Set(KTestDbName9); //Private database

  2205 	dbNames[2].Set(KTestDbName7); //Secure shared database

  2207 	TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);

  2208 	RSqlSecurityPolicy securityPolicy;

  2209 	TInt rc = securityPolicy.Create(defaultPolicy);

  2210 	TEST2(rc, KErrNone);

  2212 	_LIT8(KConfig, "compaction=background");

  2214 	for(TInt i=0;i<KTestDbCnt;++i)

  2215 		{

  2216 		(void)RSqlDatabase::Delete(dbNames[i]);

  2217 		RSqlDatabase db;

  2218 		TInt rc = i == 2 ? db.Create(dbNames[i], securityPolicy, &KConfig) : db.Create(dbNames[i], &KConfig);

  2219 		TEST2(rc, KErrNone);

  2220 		//Check database size

  2221 		RSqlDatabase::TSize size;

  2222 		rc = db.Size(size);

  2223 		TEST2(rc, KErrNone);

  2224 		TEST(size.iSize > 0);

  2225 		TEST2(size.iFree, 0);

  2226 		//Insert some data and check the size again

  2227 		rc = db.Exec(_L("CREATE TABLE A(Id INTEGER, T TEXT)"));

  2228 		TEST(rc >= 0);

  2229 		const TInt KTestRecCnt = 50;

  2230 		rc = db.Exec(_L("BEGIN"));

  2231 		TEST(rc >= 0);

  2232 		for(TInt k=0;k<KTestRecCnt;++k)

  2233 			{

  2234 			TBuf<100> sql;

  2235 			sql.Format(_L("INSERT INTO A VALUES(%d, 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA')"), k + 1);

  2236 			rc = db.Exec(sql);

  2237 			TEST2(rc, 1);

  2238 			}

  2239 		rc = db.Exec(_L("COMMIT"));

  2240 		TEST(rc >= 0);

  2241 		rc = db.Size(size);

  2242 		TEST2(rc, KErrNone);

  2243 		TEST(size.iSize > 0);

  2244 		TEST2(size.iFree, 0);

  2245 		//Delete the records and check the size again.

  2246 		rc = db.Exec(_L("DELETE FROM A"));

  2247 		rc = db.Size(size);

  2248 		TEST2(rc, KErrNone);

  2249 		TEST(size.iSize > 0);

  2250 		TEST(size.iFree > 0);

  2251 		//Cleanup

  2252 		db.Close();

  2253 		rc = RSqlDatabase::Delete(dbNames[i]);

  2254 		TEST2(rc, KErrNone);

  2255 		}

  2256 	securityPolicy.Close();

  2257 	}

  2259 /**

  2260 @SYMTestCaseID			SYSLIB-SQL-UT-4040

  2261 @SYMTestCaseDesc		RSqlDatabase::Size(TSize&) on an attached database - functional test.

  2262 						The test creates a database and attaches another database. Then the test

  2263 						verifies that the new RSqlDatabase::Size(TSize&) method can be used on the attached

  2264 						database. The test also calls the new method with an invalid attached database

  2265 						name and check that an appropriate error is reported.

  2266 @SYMTestPriority		High

  2267 @SYMTestActions			RSqlDatabase::Size(TSize&) on an attached database - functional test.

  2268 @SYMTestExpectedResults Test must not fail

  2269 @SYMREQ					REQ10407

  2270 */

  2271 void AttachedSizeTest2()

  2272 	{

  2273 	RSqlDatabase db;

  2275 	TInt err = db.Create(KTestDbName1);

  2276 	TEST2(err, KErrNone);

  2277 	err = db.Exec(_L("CREATE TABLE A(I INTEGER)"));

  2278 	TEST(err >= 0);

  2279 	db.Close();

  2280 	err = db.Create(KTestDbName8);

  2281 	TEST2(err, KErrNone);

  2282 	err = db.Exec(_L("CREATE TABLE B(J INTEGER)"));

  2283 	TEST(err >= 0);

  2284 	err = db.Exec(_L("BEGIN"));

  2285 	TEST(err >= 0);

  2286 	for(TInt i=0;i<1000;++i)

  2287 		{

  2288 		err = db.Exec(_L("INSERT INTO B(J) VALUES(1)"));

  2289 		TEST2(err, 1);

  2290 		}

  2291 	err = db.Exec(_L("COMMIT"));

  2292 	TEST(err >= 0);

  2293 	db.Close();

  2295 	err = db.Open(KTestDbName1);

  2296 	TEST2(err, KErrNone);

  2297 	_LIT(KAttachDbName, "B");

  2298 	err = db.Attach(KTestDbName8, KAttachDbName);

  2299 	TEST2(err, KErrNone);

  2301 	//Size(TSize&) - main and the attached databse

  2302 	RSqlDatabase::TSize	size1;

  2303 	err = db.Size(size1);

  2304 	TEST2(err, KErrNone);

  2305 	TEST(size1.iSize > 0);

  2306 	TEST(size1.iFree >= 0);

  2307 	RSqlDatabase::TSize	size2;

  2308 	err = db.Size(size2, KAttachDbName);

  2309 	TEST2(err, KErrNone);

  2310 	TEST(size2.iSize > 0);

  2311 	TEST(size2.iFree >= 0);

  2312 	TEST(size2.iSize > size1.iSize);

  2314 	//Very long attached database name

  2315 	TBuf<KMaxFileName + 10> longDbName;

  2316 	longDbName.SetLength(longDbName.MaxLength());

  2317 	err = db.Size(size1, longDbName);

  2318 	TEST2(err, KErrBadName);

  2320 	//An attempt to get the size of a non-existing attached database

  2321 	err = db.Size(size1, _L("TheDbDoesNotExist"));

  2322 	TEST2(err, KSqlErrGeneral);

  2323 	TPtrC msg = db.LastErrorMessage();

  2324 	TheTest.Printf(_L("Non-existing attached database, error message: %S\r\n"), &msg);

  2326     //An attempt to get the size when the attached database name contains "bad" unicode characters (cannot be converted to UTF8)

  2327     TBuf<2> dbName3;

  2328     dbName3.SetLength(2);

  2329     dbName3[0] = TChar(0xD800);

  2330     dbName3[1] = TChar(0xFC00);

  2331     err = db.Size(size1, dbName3);

  2332     TEST2(err, KErrGeneral);

  2334 	err = db.Detach(KAttachDbName);

  2335 	TEST2(err, KErrNone);

  2336 	db.Close();

  2337 	(void)RSqlDatabase::Delete(KTestDbName8);

  2338 	(void)RSqlDatabase::Delete(KTestDbName1);

  2339 	}

  2341 /**

  2342 @SYMTestCaseID			SYSLIB-SQL-UT-4041

  2343 @SYMTestCaseDesc		RSqlDatabase::Size(TSize&) and different compaction modes - functional test.

  2344 						The test creates databases using all possible compaction modes and

  2345 						verifies that the new RSqlDatabase::Size(TSize&) method can be used on these

  2346 						databases without any problems.

  2347 @SYMTestPriority		High

  2348 @SYMTestActions			RSqlDatabase::Size(TSize&) and different compaction modes - functional test.

  2349 @SYMTestExpectedResults Test must not fail

  2350 @SYMREQ					REQ10407

  2351 */

  2352 void DiffCompactModeSize2Test()

  2353 	{

  2354 	_LIT8(KAutoCompaction, "compaction = auto");

  2355 	RSqlDatabase db;

  2356 	TInt err = db.Create(KTestDbName1, &KAutoCompaction);

  2357 	TEST2(err, KErrNone);

  2358 	err = db.Exec(_L("CREATE TABLE A(I INTEGER)"));

  2359 	TEST(err >= 0);

  2360 	RSqlDatabase::TSize	size;

  2361 	err = db.Size(size);

  2362 	TEST2(err, KErrNone);

  2363 	TEST(size.iSize > 0);

  2364 	TEST(size.iFree >= 0);

  2365 	db.Close();

  2366 	(void)RSqlDatabase::Delete(KTestDbName1);

  2368 	_LIT8(KManualCompaction, "compaction = manual");

  2369 	err = db.Create(KTestDbName1, &KManualCompaction);

  2370 	TEST2(err, KErrNone);

  2371 	err = db.Exec(_L("CREATE TABLE A(I INTEGER)"));

  2372 	TEST(err >= 0);

  2373 	err = db.Size(size);

  2374 	TEST2(err, KErrNone);

  2375 	TEST(size.iSize > 0);

  2376 	TEST(size.iFree >= 0);

  2377 	db.Close();

  2378 	(void)RSqlDatabase::Delete(KTestDbName1);

  2380 	_LIT8(KBackgroundCompaction, "compaction = background");

  2381 	err = db.Create(KTestDbName1, &KBackgroundCompaction);

  2382 	TEST2(err, KErrNone);

  2383 	err = db.Exec(_L("CREATE TABLE A(I INTEGER)"));

  2384 	TEST(err >= 0);

  2385 	err = db.Size(size);

  2386 	TEST2(err, KErrNone);

  2387 	TEST(size.iSize > 0);

  2388 	TEST(size.iFree >= 0);

  2389 	db.Close();

  2390 	(void)RSqlDatabase::Delete(KTestDbName1);

  2391 	}

  2393 /**

  2394 @SYMTestCaseID			PDS-SQL-CT-4205

  2395 @SYMTestCaseDesc		"PRAGMA count_changes" test.

  2396 						When "count_changes" pragma is ON, sqlite3_step() is called two times by the

  2397 						SQL server, before getting the SQLITE_DONE return code.

  2398 						Everything else is the same (statement processing, etc.).

  2399 @SYMTestPriority		High

  2400 @SYMTestActions			"PRAGMA count_changes" test.

  2401 @SYMTestExpectedResults Test must not fail

  2402 */

  2403 void CountChangesTest()

  2404 	{

  2405 	(void)RSqlDatabase::Delete(KTestDbName1);

  2406 	RSqlDatabase db;

  2407 	TInt err = db.Create(KTestDbName1);

  2408 	TEST2(err, KErrNone);

  2409 	err = db.Exec(_L("CREATE TABLE A(I INTEGER)"));

  2410 	TEST(err >= 0);

  2412 	err = db.Exec(_L("PRAGMA count_changes=ON"));

  2413 	TEST(err >= 0);

  2415 	err = db.Exec(_L("INSERT INTO A VALUES(1)"));

  2416 	TEST2(err, 1);

  2418 	err = db.Exec(_L8("INSERT INTO A VALUES(2)"));

  2419 	TEST2(err, 1);

  2421 	RSqlStatement stmt;

  2422 	err = stmt.Prepare(db, _L("DELETE FROM A WHERE I>=1 AND I<=2"));

  2423 	TEST2(err, KErrNone);

  2424 	err = stmt.Exec();

  2425 	TEST2(err, 2);

  2426 	stmt.Close();

  2428 	err = db.Exec(_L("PRAGMA count_changes=OFF"));

  2429 	TEST(err >= 0);

  2431 	db.Close();

  2432 	(void)RSqlDatabase::Delete(KTestDbName1);

  2433 	}

  2435 void DoTestsL()

  2436 	{

  2437 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1601 Create/Open/Close database tests "));

  2438 	OpenCloseDatabaseTest();

  2440 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1602 SetIsolationLevel() database tests "));

  2441 	SetIsolationLevelTest();

  2443 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1603 Delete database tests "));

  2444 	DeleteDatabaseTest();

  2446 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1640 Copy database tests "));

  2447 	CopyDatabaseTest();

  2449 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1604 Operations with NULL column values "));

  2450 	NullColumnValues();

  2452 	enum {KSqlBufSize = 1024};

  2454 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1605 RSqlDatabase::Exec() test. 16-bit SQL strings. "));

  2455 	ExecOnDbTest<TDesC, TBuf<KSqlBufSize> >();

  2457 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1605 RSqlDatabase::Exec() test. 8-bit SQL strings. "));

  2458 	ExecOnDbTest<TDesC8, TBuf8<KSqlBufSize> >();

  2460 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1606 RSqlStatement test. 16-bit SQL strings. "));

  2461 	StatementTest<TDesC, TBuf<KSqlBufSize> >();

  2463 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1606 RSqlStatement test. 8-bit SQL strings. "));

  2464 	StatementTest<TDesC8, TBuf8<KSqlBufSize> >();

  2466 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1607 RSqlColumnReadStream test. Long text column "));

  2467 	ColumnTextStreamTest();

  2469 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1621 RSqlColumnReadStream test. Long binary column "));

  2470 	ColumnBinaryStreamTest();

  2472     TheTest.Next (_L(" @SYMTestCaseID:PDS-SQL-CT-4174 CSqlSrvSession::NewOutputStreamL() coverage test"));

  2473 	ColumnBinaryStreamTest2();

  2475 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1608 RSqlParamWriteStream test. Long text parameter "));

  2476 	TextParameterStreamTest();

  2478 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1622 RSqlParamWriteStream test. Long binary parameter "));

  2479 	BinaryParameterStreamTest();

  2481     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4191 MStreamBuf::SeekL() test"));

  2482     StreamSeekTestL();

  2484 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1634 RSqlStatement test. Nameless parameter "));

  2485 	NamelessParameterTest();

  2487 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1768 Asynchronous execution tests "));

  2488 	AsyncTest();

  2490 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1816 RSqlDatabase::Size() tests "));

  2491 	SizeTest();

  2493 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1817 RSqlDatabase::InTransaction() tests "));

  2494 	InTransactionTest();

  2496 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4039 RSqlDatabase::Size(RSqlDatabase::TSize&) tests"));

  2497 	SizeTest2();

  2499 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4040 RSqlDatabase::Size(RSqlDatabase::TSize&) - attached database tests"));

  2500 	AttachedSizeTest2();

  2502 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4041 RSqlDatabase::Size(RSqlDatabase::TSize&) - different compaction modes tests"));

  2503 	DiffCompactModeSize2Test();

  2505 	TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4205 PRAGMA \"count_changes\" test"));

  2506 	CountChangesTest();

  2507 	}

  2509 TInt E32Main()

  2510 	{

  2511 	TheTest.Title();

  2513 	CTrapCleanup* tc = CTrapCleanup::New();

  2515 	__UHEAP_MARK;

  2517 	CreateTestDir();

  2518 	DeleteTestFiles();

  2519 	TRAPD(err, DoTestsL());

  2520 	DeleteTestFiles();

  2521 	TEST2(err, KErrNone);

  2523 	__UHEAP_MARKEND;

  2525 	TheTest.End();

  2526 	TheTest.Close();

  2528 	delete tc;

  2530 	User::Heap().Check();

  2531 	return KErrNone;

  2532 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--