1 // Copyright (c) 2005-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 #include <e32test.h>

    17 #include <bautils.h>

    18 #include <s32buf.h>				//MStreamBuf

    19 #include <sqldb.h>

    20 

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

    22 

    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\\");

    37 

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

    39 

    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 

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

    47 

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

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

    50 _LIT8(KCommitStr8, "COMMIT;");

    51 _LIT16(KCommitStr16, "COMMIT;");

    52 

    53 ///////////////////////////////////////////////////////////////////////////////////////

    54 

    55 void DeleteTestFiles()

    56 	{

    57 	RSqlDatabase::Delete(KTestDbName1);

    58 	RSqlDatabase::Delete(KTestDbName2);

    59 	RSqlDatabase::Delete(KTestDbName3);

    60 	RSqlDatabase::Delete(KTestDbName4);

    61 	RSqlDatabase::Delete(KTestDbName5);

    62 	RSqlDatabase::Delete(KTestDbName6);

    63 	RSqlDatabase::Delete(KTestDbName7);

    64 	RSqlDatabase::Delete(KTestDbName8);

    65 	RSqlDatabase::Delete(KTestDbName9);

    66 	RSqlDatabase::Delete(KTestCfgDbName);

    67 	RSqlDatabase::Delete(KTestCfgDbName2);

    68 	RSqlDatabase::Delete(KDbName7);

    69 	}

    70 

    71 ///////////////////////////////////////////////////////////////////////////////////////

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

    73 //Test macros and functions

    74 void Check(TInt aValue, TInt aLine)

    75 	{

    76 	if(!aValue)

    77 		{

    78 		DeleteTestFiles();

    79 		TheTest(EFalse, aLine);

    80 		}

    81 	}

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

    83 	{

    84 	if(aValue != aExpected)

    85 		{

    86 		DeleteTestFiles();

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

    88 		TheTest(EFalse, aLine);

    89 		}

    90 	}

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

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

    93 

    94 ///////////////////////////////////////////////////////////////////////////////////////

    95 

    96 void CreateTestDir()

    97     {

    98     RFs fs;

    99 	TInt err = fs.Connect();

   100 	TEST2(err, KErrNone);

   101 

   102 	err = fs.MkDir(KTestDir);

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

   104 

   105 	err = fs.CreatePrivatePath(EDriveC);	

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

   107 	

   108 	fs.Close();

   109 	}

   110 

   111 ///////////////////////////////////////////////////////////////////////////////////////

   112 

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

   114 												     TInt aExpectedError)

   115 	{

   116 	BUF sqlBuf;

   117 	sqlBuf.Copy(aSqlString);

   118 	

   119 	TInt rc = aDb.Exec(sqlBuf);

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

   121 		{

   122 		TPtrC msg = aDb.LastErrorMessage();

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

   124 		}

   125 	if(aExpectedError < 0)

   126 		{

   127 		TEST2(rc, aExpectedError);

   128 		}

   129 	else

   130 		{

   131 		TEST(rc >= 0);

   132 		}

   133 	}

   134 

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

   136 															  TInt aExpectedError)

   137 	{

   138 	BUF sqlBuf;

   139 	sqlBuf.Copy(aSqlString);

   140 	

   141 	RSqlStatement stmt;

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

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

   144 		{

   145 		TPtrC msg = aDb.LastErrorMessage();

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

   147 		}

   148 	TEST2(rc, aExpectedError);

   149 	return stmt;

   150 	}

   151 

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

   153 	{

   154 	TInt rc = aStmt.Exec();

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

   156 		{

   157 		TPtrC msg = aDb.LastErrorMessage();

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

   159 		}

   160 	if(aExpectedError < 0)

   161 		{

   162 		TEST2(rc, aExpectedError);

   163 		}

   164 	else

   165 		{

   166 		TEST(rc >= 0);

   167 		}

   168 	}

   169 		

   170 ///////////////////////////////////////////////////////////////////////////////////////

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

   172 

   173 /**

   174 @SYMTestCaseID			SYSLIB-SQL-CT-1601

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

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

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

   178 @SYMTestPriority		High

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

   180 @SYMTestExpectedResults Test must not fail

   181 @SYMREQ					REQ5792

   182                         REQ5793

   183 */	

   184 void OpenCloseDatabaseTest()

   185 	{

   186 	RSqlDatabase db;

   187 	TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);

   188 	RSqlSecurityPolicy securityPolicy;

   189 	TInt rc = securityPolicy.Create(defaultPolicy);

   190 	TEST2(rc, KErrNone);

   191 	

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

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

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

   195 	TEST2(rc, KErrNotReady);

   196 	db.Close();

   197 

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

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

   200 	rc = db.Open(KDbFName);

   201 	TEST2(rc, KErrNotFound);

   202 		

   203 	//Zero length database file name.

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

   205 	TEST2(rc,  KErrBadName);

   206 	db.Close();

   207 	

   208 	//Database file name containing only the drive name

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

   210 	TEST2(rc, KErrBadName);

   211 	db.Close();

   212 	

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

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

   215 	TEST2(rc, KErrBadName);

   216 	db.Close();

   217 	

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

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

   220 	rc = db.Create(KDbPath2);

   221 	TEST2(rc, KErrNotReady);

   222 	db.Close();

   223 

   224 	// create database with good config specified

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

   226 	TEST2(rc, KErrNone);

   227 	db.Close();

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

   229 	TEST2(rc2, KErrNone);

   230 	

   231 	// create database with bad config specified

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

   233 	TEST2(rc, KErrArgument);

   234 	db.Close();

   235 

   236 	// create database with long config specified

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

   238 	TEST2(rc, KErrArgument);

   239 	db.Close();

   240 

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

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

   243 	TEST2(rc, KErrNone);

   244 	db.Close();

   245 	rc2 = RSqlDatabase::Delete(KTestCfgDbName);

   246 	TEST2(rc2, KErrNone);

   247 		

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

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

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

   251 	db.Close();

   252 	rc2 = RSqlDatabase::Delete(KTestDbName4);

   253 	TEST2(rc, KErrNone);

   254 	TEST2(rc2, KErrNone);

   255 

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

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

   258 	//With config

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

   260 	db.Close();

   261 	rc2 = RSqlDatabase::Delete(KTestCfgDbName2);

   262 	TEST2(rc, KErrNone);

   263 	TEST2(rc2, KErrNone);

   264 	

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

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

   267 	rc = db.Create(KTestDbName5);

   268 	db.Close();

   269 	rc2 = RSqlDatabase::Delete(KTestDbName5);

   270 	TEST2(rc, KErrNone);

   271 	TEST2(rc2, KErrNone);

   272 	

   273 	RFs fs;

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

   275 	TFileName privatePath;

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

   277 	fs.Close();

   278 	

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

   280 	//Very long database file name.

   281 	const TInt KMaxFileName2 = KMaxFileName - 40;//"-40" because the SQLITE engine creates a journal file if begins

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

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

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

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

   286 	                                             //file name becomes too long

   287 	TBuf<KMaxFileName2> dbPath;

   288 	_LIT(KExt, ".DB");

   289 	dbPath.Copy(_L("C:"));

   290 	dbPath.Append(KSecureUid.Name());

   291 	TInt len = KMaxFileName2 + 1 - (dbPath.Length() + KExt().Length() + privatePath.Length());

   292 	while(--len)

   293 		{

   294 		dbPath.Append(TChar('A'));	

   295 		}

   296 	dbPath.Append(KExt);	

   297 	TEST(dbPath.Length() == (KMaxFileName2 - privatePath.Length()));

   298 	rc = db.Create(dbPath, securityPolicy);

   299 	db.Close();

   300 	rc2 = RSqlDatabase::Delete(dbPath);

   301 	TEST2(rc, KErrNone);

   302 	TEST2(rc2, KErrNone);

   303 	

   304 	// Private database with config

   305 	TBuf<KMaxFileName> cfgPath;

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

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

   308 	cfgPath.Append(KExt);

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

   310 	db.Close();

   311 	rc2 = RSqlDatabase::Delete(cfgPath);

   312 	TEST2(rc, KErrNone);

   313 	TEST2(rc2, KErrNone);

   314 	

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

   316 	//Very long database file name.

   317 	dbPath.Copy(_L("C:\\TEST\\D"));

   318 	len = KMaxFileName2 + 1 - (dbPath.Length() + KExt().Length());

   319 	while(--len)

   320 		{

   321 		dbPath.Append(TChar('A'));	

   322 		}

   323 	dbPath.Append(KExt);	

   324 	TEST(dbPath.Length() == KMaxFileName2);

   325 	rc = db.Create(dbPath);

   326 	db.Close();

   327 	rc2 = RSqlDatabase::Delete(dbPath);

   328 	TEST2(rc, KErrNone);

   329 	TEST2(rc2, KErrNone);

   330 

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

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

   333 	db.Close();

   334 	rc2 = db.Open(KTestDbName6);

   335 	db.Close();

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

   337 	TEST2(rc, KErrNone);

   338 	TEST2(rc2, KErrNone);

   339 	TEST2(rc3, KErrNone);

   340 	

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

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

   343 	db.Close();

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

   345 	db.Close();

   346 	rc3 = RSqlDatabase::Delete(KTestDbName6);

   347 	TEST2(rc, KErrNone);

   348 	TEST2(rc2, KErrAlreadyExists);

   349 	TEST2(rc3, KErrNone);

   350 	

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

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

   353 	RSqlDatabase db2;	

   354 	rc2 = db2.Open(KTestDbName6);

   355 	db2.Close();

   356 	db.Close();

   357 	rc3 = RSqlDatabase::Delete(KTestDbName6);

   358 	TEST2(rc, KErrNone);

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

   360 	TEST2(rc3, KErrNone);

   361 

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

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

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

   365 	TEST2(rc, KErrAccessDenied);

   366 	db.Close();

   367 

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

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

   370 	rc = db.Create(KDbPath8a);

   371 	TEST2(rc, KErrAccessDenied);

   372 	db.Close();

   373 

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

   375 	rc = db.Open(KDbPath8);

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

   377 	db.Close();

   378 

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

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

   381 	rc = db.Open(KDbPath9);

   382 	TEST2(rc, KErrNone);

   383 	db.Close();

   384 	

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

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

   387 	rc = db.Open(KDbPath10);

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

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

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

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

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

   393 	db.Close();

   394 

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

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

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

   398 	TEST2(rc, KErrNone);

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

   400 	fs.Close();

   401 

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

   403 	rc = db.Open(KTestDbName3);

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

   405 	db.Close();

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

   407 	

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

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

   410 	TEST2(rc, KErrNone);

   411 	db.Close();

   412 	rc = db.Open(KTestDbName2);

   413 	TEST2(rc, KErrNone);

   414 	db.Close();

   415 	rc = db.Open(KTestDbName2);

   416 	TEST2(rc, KErrNone);

   417 	db.Close();

   418 

   419 	//Open two connections to the same database.

   420 	rc = db.Open(KTestDbName2);

   421 	TEST2(rc, KErrNone);

   422 	rc = db2.Open(KTestDbName2);

   423 	TEST2(rc, KErrNone);

   424 	db2.Close();

   425 	db.Close();

   426 	

   427 	rc = RSqlDatabase::Delete(KTestDbName2);

   428 	TEST2(rc, KErrNone);

   429 	

   430 	securityPolicy.Close();

   431 	}

   432 

   433 ///////////////////////////////////////////////////////////////////////////////////////

   434 

   435 /**

   436 @SYMTestCaseID			SYSLIB-SQL-CT-1602

   437 @SYMTestCaseDesc		Setting database isolation level tests.

   438 @SYMTestPriority		High

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

   440 @SYMTestExpectedResults Test must not fail

   441 @SYMREQ					REQ5792

   442                         REQ5793

   443 */	

   444 void SetIsolationLevelTest()

   445 	{

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

   447 

   448 	RSqlDatabase db;		

   449 	TInt err = db.Create(KTestDbName1);

   450 	TEST2(err, KErrNone);

   451 

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

   453 	TEST2(err, KErrNotSupported);

   454 	

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

   456 	TEST2(err, KErrNotSupported);

   457 	

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

   459 	TEST2(err, KErrNone);

   460 	

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

   462 	TEST2(err, KErrNone);

   463 	

   464 	db.Close();

   465 	

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

   467 	}

   468 

   469 ///////////////////////////////////////////////////////////////////////////////////////

   470 

   471 /**

   472 @SYMTestCaseID			SYSLIB-SQL-CT-1603

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

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

   475 						rom drive based database.

   476 @SYMTestPriority		High

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

   478 @SYMTestExpectedResults Test must not fail

   479 @SYMREQ					REQ5792

   480                         REQ5793

   481 */	

   482 void DeleteDatabaseTest()

   483 	{

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

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

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

   487 	TEST2(err, KErrNotFound);

   488 

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

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

   491 	err = RSqlDatabase::Delete(KDbName2);

   492 	TEST2(err, KErrNotFound);

   493 	

   494 	//Zero length database file name.

   495 	_LIT(KDbName3, "");

   496 	err = RSqlDatabase::Delete(KDbName3);

   497 	TEST2(err,  KErrBadName);

   498 	

   499 	//Database file name containing only the drive name

   500 	_LIT(KDbName4, "C:");

   501 	err = RSqlDatabase::Delete(KDbName4);

   502 	TEST2(err, KErrBadName);

   503 	

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

   505 	_LIT(KDbName5, "C:");

   506 	err = RSqlDatabase::Delete(KDbName5);

   507 	TEST2(err, KErrBadName);

   508 	

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

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

   511 	err = RSqlDatabase::Delete(KDbName6);

   512 	TEST2(err, KErrNotReady);

   513 

   514 	//An attempt to delete opened database.

   515 	RSqlDatabase db;	

   516 	err = db.Create(KDbName7);

   517 	TEST2(err, KErrNone);

   518 	err = RSqlDatabase::Delete(KDbName7);

   519 	TEST2(err, KErrInUse);

   520 	db.Close();

   521 	err = RSqlDatabase::Delete(KDbName7);

   522 	TEST2(err, KErrNone);

   523 

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

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

   526 	err = RSqlDatabase::Delete(KDbName8);

   527 	TEST2(err, KErrAccessDenied);

   528 	

   529 	//Create secure database

   530 	TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);

   531 	RSqlSecurityPolicy securityPolicy;

   532 	err = securityPolicy.Create(defaultPolicy);

   533 	TEST2(err, KErrNone);

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

   535 	TEST2(err, KErrNone);

   536 	db.Close();

   537 	securityPolicy.Close();

   538 	

   539 	//Attempt to delete a secure public database.

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

   541 	//private data cage.

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

   543 	TEST2(err, KErrPermissionDenied);

   544 

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

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

   547 	//private data cage.

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

   549 	TEST2(err, KErrPermissionDenied);

   550 

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

   552 	TParse parse;

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

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

   555 	TEST2(err, KErrArgument);

   556 

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

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

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

   560 	TEST2(err, KErrNone);

   561 	}

   562 

   563 ///////////////////////////////////////////////////////////////////////////////////////

   564 

   565 /**

   566 @SYMTestCaseID			SYSLIB-SQL-CT-1640

   567 @SYMTestCaseDesc		Copying database tests. Copying:

   568 						- non-secure to non-secure database;

   569 						- non-secure to secure database;

   570 						- secure to non-secure database;

   571 						- secure to secure database;

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

   573 @SYMTestPriority		High

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

   575 @SYMTestExpectedResults Test must not fail

   576 @SYMREQ					REQ5792

   577                         REQ5793

   578 */	

   579 void CopyDatabaseTest()

   580 	{

   581 	RSqlDatabase db;	

   582 

   583 	//Create secure database

   584 	TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);

   585 	RSqlSecurityPolicy securityPolicy;

   586 	TInt err = securityPolicy.Create(defaultPolicy);

   587 	TEST2(err, KErrNone);

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

   589 	TEST2(err, KErrNone);

   590 	db.Close();

   591 	securityPolicy.Close();

   592 	

   593 	//Create non-secure database

   594 	err = db.Create(KTestDbName1);

   595 	TEST2(err, KErrNone);

   596 	db.Close();

   597 

   598 	//Copy non-secure to non-secure database	

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

   600 	TEST2(err, KErrNone);

   601 

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

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

   604 	TEST2(err, KErrPermissionDenied);

   605 

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

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

   608 	TEST2(err, KErrPermissionDenied);

   609 

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

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

   612 	TEST2(err, KErrNone);

   613 	err = RSqlDatabase::Delete(KTestDbName4);

   614 	TEST2(err, KErrNone);

   615 

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

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

   618 	TEST2(err, KErrPermissionDenied);

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

   620 	TEST2(err, KErrPermissionDenied);

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

   622 	TEST2(err, KErrPermissionDenied);

   623 	

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

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

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

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

   628 	}

   629 

   630 ///////////////////////////////////////////////////////////////////////////////////////

   631 

   632 /**

   633 @SYMTestCaseID			SYSLIB-SQL-CT-1604

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

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

   636 						value is NULL.

   637 @SYMTestPriority		High

   638 @SYMTestActions			Tests mathematical operations with ESqlNull column values.

   639 @SYMTestExpectedResults Test must not fail

   640 @SYMREQ					REQ5792

   641                         REQ5793

   642 */	

   643 void NullColumnValues()

   644 	{

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

   646 	

   647 	RSqlDatabase db;		

   648 	TInt err = db.Create(KTestDbName1);

   649 	TEST2(err, KErrNone);

   650 

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

   652 	TEST(err >= 0);

   653 

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

   655 	TEST2(err, 1);

   656 

   657 	RSqlStatement stmt;

   658 	

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

   660 	TEST2(err, KErrNone);

   661 	

   662 	err = stmt.Next();

   663 	TEST2(err, KSqlAtRow);

   664 

   665 	TSqlColumnType colType = stmt.ColumnType(0);

   666 	TEST(colType == ESqlInt);

   667 	

   668 	colType = stmt.ColumnType(1);

   669 	TEST(colType == ESqlNull);

   670 	

   671 	TInt val = stmt.ColumnInt(0);

   672 	TEST(val == 200);

   673 	

   674 	val = stmt.ColumnInt(1);

   675 	TEST(val == 0);

   676 

   677 	stmt.Close();

   678 	

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

   680 	TEST2(err, KErrNone);

   681 	

   682 	err = stmt.Next();

   683 	TEST2(err, KSqlAtRow);

   684 	

   685 	colType = stmt.ColumnType(0);

   686 	TEST(colType == ESqlNull);

   687 	

   688 	val = stmt.ColumnInt(0);

   689 	TEST(val == 0);

   690 	

   691 	stmt.Close();

   692 	db.Close();

   693 

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

   695 	}

   696 

   697 ///////////////////////////////////////////////////////////////////////////////////////

   698 

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

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

   701 									   CREATE TRIGGER TrgA1Ins BEFORE Insert ON A1\

   702 									   BEGIN\

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

   704 									   END;");

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

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

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

   708 _LIT8(KStmt5, "");

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

   710 _LIT8(KStmt7, "");

   711 _LIT8(KStmt8, ";;;;;");

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

   713 

   714 /**

   715 @SYMTestCaseID			SYSLIB-SQL-CT-1605

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

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

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

   719 @SYMTestPriority		High

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

   721 @SYMTestExpectedResults Test must not fail

   722 @SYMREQ					REQ5792

   723                         REQ5793

   724 */	

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

   726 	{

   727 	RSqlDatabase db;

   728 	TInt rc = db.Create(KTestDbName1);

   729 	TEST2(rc, KErrNone);

   730 

   731 	//Create two tables and a trigger	              	  

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

   733 

   734 	//INSERT sql statement execution

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

   736 

   737 	//SELECT sql statement execution

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

   739 

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

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

   742 

   743 	//Executing zero length SQL statement.

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

   745 	

   746 	//Executing a SQL statement with syntax errors.

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

   748 

   749 	//Executing an empty SQL statement.

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

   751 	

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

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

   754 	

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

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

   757 	

   758 	db.Close();

   759 

   760 	rc = RSqlDatabase::Delete(KTestDbName1);

   761 	TEST2(rc, KErrNone);

   762 	}

   763 

   764 _LIT8(KStmt10, "");

   765 _LIT8(KStmt11, ";   ;  ;;;");

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

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

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

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

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

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

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

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

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

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

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

   777 

   778 /**

   779 @SYMTestCaseID			SYSLIB-SQL-CT-1606

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

   781 						the column types and values. Binding parameter values.

   782 @SYMTestPriority		High

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

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

   785 						RSqlStatement::Column<DataType>().				

   786 @SYMTestExpectedResults Test must not fail

   787 @SYMREQ					REQ5792

   788                         REQ5793

   789 */	

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

   791 	{

   792 	RSqlDatabase db;	

   793 	TInt rc = db.Create(KTestDbName1);

   794 	TEST2(rc, KErrNone);

   795 

   796 	//Executing an empty SQL statement.

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

   798 	stmt.Close();

   799 

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

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

   802 	stmt.Close();

   803 	

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

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

   806 	ExecSqlStmt(db, stmt, KErrNone);

   807 	stmt.Close();

   808 

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

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

   811 	ExecSqlStmt(db, stmt, KErrNone);

   812 	stmt.Close();

   813 		

   814 	//Test RSqlStatement::ColumnIndex().

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

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

   817 	TEST(idx1 == 0);

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

   819 	TEST(idx2 == 1);

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

   821 	TEST(idx3 < 0);

   822 	stmt.Close();

   823 	

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

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

   826 	TEST(idx1 == 1);

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

   828 	TEST(idx2 == 0);

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

   830 	TEST(idx3 < 0);

   831 	

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

   833 	TInt recCnt = 0;

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

   835 		{

   836 		++recCnt;

   837 		

   838 		TInt intVal = stmt.ColumnInt(idx1);

   839 		TEST(intVal == 5);

   840 		

   841 		//Integer column value retrieved as a text.

   842 		TPtrC strVal1;

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

   844 		TEST2(err, KErrNone);

   845 		TEST(strVal1 == KNullDesC);

   846 		

   847 		//Text column value retrieved as a binary

   848 		TBuf8<50> strVal3;

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

   850 		TEST2(err, KErrNone);

   851 		TEST(strVal3 == KNullDesC8);

   852 		

   853 		TPtrC strVal2;

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

   855 		TEST2(err, KErrNone);

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

   857 				

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

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

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

   861 		}

   862 	stmt.Close();

   863 	TEST2(rc, KSqlAtEnd);

   864 	TEST2(SqlRetCodeClass(rc), ESqlInformation);

   865 	TEST(recCnt == 1);

   866 	

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

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

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

   870 	TEST(idx1 == 1);

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

   872 	TEST(idx2 == 0);

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

   874 	TEST(prmIdx1 == 0);

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

   876 	TEST(prmIdx2 == 1);

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

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

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

   880 	TEST2(rc, KErrNone);

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

   882 	TEST2(rc, KErrNone);

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

   884 	recCnt = 0;

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

   886 		{

   887 		++recCnt;

   888 		TInt intVal = stmt.ColumnInt(idx1);

   889 		TEST(intVal == 5);

   890 		TPtrC strVal;

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

   892 		TEST2(err, KErrNone);

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

   894 		}

   895 	stmt.Close();

   896 	TEST2(rc, KSqlAtEnd);

   897 	TEST2(SqlRetCodeClass(rc), ESqlInformation);

   898 	TEST(recCnt == 1);

   899 	

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

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

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

   903 	TEST(prmIdx1 == 1);

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

   905 	TEST(prmIdx2 == 0);

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

   907 	TEST2(rc, KErrNone);

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

   909 	TEST2(rc, KErrNone);

   910 	rc = stmt.Exec();

   911 	TEST2(rc, 1);

   912 	

   913 	stmt.Close();

   914 	

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

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

   917 	ExecSqlStmt(db, stmt, KErrNone);

   918 	stmt.Close();

   919 	

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

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

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

   923 	TInt v32 = 1024;

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

   925 	TReal vReal = 234.75;

   926 	TBuf<10> vText;

   927 	TBuf8<10> vBinary;

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

   929 		{

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

   931 		TEST2(rc, KErrNone);

   932 		

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

   934 		TEST2(rc, KErrNone);

   935 		

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

   937 		TEST2(rc, KErrNone);

   938 		

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

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

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

   942 		TEST2(rc, KErrNone);

   943 

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

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

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

   947 		TEST2(rc, KErrNone);

   948 

   949 		rc = stmt.BindNull(5);

   950 		TEST2(rc, KErrNone);

   951 

   952 		rc = stmt.Exec();

   953 		TEST2(rc, 1);

   954 

   955 		rc = stmt.Reset();

   956 		TEST2(rc, KErrNone);

   957 		}

   958 	stmt.Close();

   959 

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

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

   962 	recCnt = 0;

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

   964 		{

   965 		++recCnt;

   966 		TInt v1 = stmt.ColumnInt(0);

   967 		TEST(v1 == v32 * recCnt);

   968 

   969 		TInt64 v2 = stmt.ColumnInt64(1);

   970 		TEST(v2 == v64 * recCnt);

   971 

   972 		TReal v3 = stmt.ColumnReal(2);

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

   974 		

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

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

   977 		TPtrC v4;

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

   979 		TEST2(err, KErrNone);

   980 		TEST(v4 == vText);

   981 		

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

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

   984 		TPtrC8 v5;

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

   986 		TEST2(err, KErrNone);

   987 		TEST(v5 == vBinary);

   988 		

   989 		TBool b = stmt.IsNull(5);

   990 		TEST(b != 0);

   991 		}

   992 	stmt.Close();

   993 	TEST2(rc, KSqlAtEnd);

   994 	TEST2(SqlRetCodeClass(rc), ESqlInformation);

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

   996 	

   997 	db.Close();

   998 

   999 	rc = RSqlDatabase::Delete(KTestDbName1);

  1000 	TEST2(rc, KErrNone);

  1001 	}

  1002 

  1003 /**

  1004 @SYMTestCaseID			SYSLIB-SQL-CT-1607

  1005 @SYMTestCaseDesc		Retrieving long text column values test.

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

  1007 						is not big enough.

  1008 @SYMTestPriority		High

  1009 @SYMTestActions			RSqlColumnReadStream::ColumnText() test.

  1010 @SYMTestExpectedResults Test must not fail

  1011 @SYMREQ					REQ5792

  1012                         REQ5793

  1013 */	

  1014 void ColumnTextStreamTest()

  1015 	{

  1016 	RSqlDatabase db;	

  1017 	TInt rc = db.Create(KTestDbName1);

  1018 	TEST2(rc, KErrNone);

  1019 

  1020 	enum {KSqlBufSize = 64};

  1021 	

  1022 	//Create a table

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

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

  1025 	

  1026 	const TInt KTextLen = 3101;

  1027 

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

  1029 	

  1030 	//Allocate a buffer for the SQL statement.

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

  1032 	TEST(buf != NULL);

  1033 

  1034 	TPtr sql = buf->Des();

  1035 	

  1036 	//Insert row 1

  1037 	

  1038 	const TChar KChar1('A');

  1039 	sql.Copy(KSqlStmt2);

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

  1041 	TInt i;

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

  1043 		{

  1044 		sql.Append(KChar1);

  1045 		}

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

  1047 

  1048 	rc = db.Exec(sql);

  1049 	TEST2(rc, 1);

  1050 

  1051 	//Insert row 2

  1052 	

  1053 	const TChar KChar2('B');

  1054 	sql.Copy(KSqlStmt2);

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

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

  1057 		{

  1058 		sql.Append(KChar2);

  1059 		}

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

  1061 

  1062 	rc = db.Exec(sql);

  1063 	TEST2(rc, 1);

  1064 

  1065 	//Prepare SELECT SQL statement

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

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

  1068 

  1069 	//Move on row 1

  1070 	rc = stmt.Next();

  1071 	TEST2(rc, KSqlAtRow);

  1072 

  1073 	//Read the long text column using a stream

  1074 	RSqlColumnReadStream columnStream;

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

  1076 	columnStream.Close();

  1077 	TEST2(rc, KErrNone);

  1078 

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

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

  1081 	TEST2(rc, KErrNone);

  1082 	

  1083 	TInt size = stmt.ColumnSize(1);

  1084 	TPtr colData = buf->Des();

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

  1086 	columnStream.Close();

  1087 	TEST2(rc, KErrNone);

  1088 	

  1089 	//Check the column value

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

  1091 		{

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

  1093 		}

  1094 

  1095 	//Move on row 2

  1096 	rc = stmt.Next();

  1097 	TEST2(rc, KSqlAtRow);

  1098 

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

  1100 	TPtrC colDataPtr;

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

  1102 	TEST2(rc, KErrNone);

  1103 	

  1104 	//Check the column value

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

  1106 		{

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

  1108 		}

  1109 

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

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

  1112 	TEST2(rc, KErrNone);

  1113 	

  1114 	//Check the column value

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

  1116 		{

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

  1118 		}

  1119 	

  1120 	//Read row 2 using a stream

  1121 	colData.Zero();

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

  1123 	TEST2(rc, KErrNone);

  1124 	size = stmt.ColumnSize(1);

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

  1126 	columnStream.Close();

  1127 	TEST2(rc, KErrNone);

  1128 	

  1129 	//Check the column value

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

  1131 		{

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

  1133 		}

  1134