1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqlapi2.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1849 @@
1.4 +// Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include <e32test.h>
1.20 +#include <e32math.h>
1.21 +#include <bautils.h>
1.22 +#include <s32buf.h> //MStreamBuf
1.23 +#include <sqldb.h>
1.24 +#include "SqlResourceProfiler.h"
1.25 +
1.26 +///////////////////////////////////////////////////////////////////////////////////////
1.27 +
1.28 +RTest TheTest(_L("t_sqlapi2 test"));
1.29 +RSqlDatabase TheDb;
1.30 +RSqlStatement TheStmt;
1.31 +
1.32 +_LIT(KTestDir, "c:\\test\\");
1.33 +_LIT(KTestDbName1, "c:\\test\\t_sqlapi2_1.db");
1.34 +_LIT(KTestDbName2, "c:\\private\\1111C1EF\\t_sqlapi2_2.db");//t_sqlapi2 app - private database
1.35 +
1.36 +_LIT(KDbInjectedName1, "DELETE FROM symbian_settings;c:\\test\\A.db");
1.37 +_LIT(KDbInjectedName2, "c:\\test\\A.db;DELETE FROM symbian_settings;");
1.38 +
1.39 +const TInt KBufLen = 8192;
1.40 +TBuf<KBufLen> TheBuf;
1.41 +
1.42 +///////////////////////////////////////////////////////////////////////////////////////
1.43 +
1.44 +void DeleteTestFiles()
1.45 + {
1.46 + TheStmt.Close();
1.47 + TheDb.Close();
1.48 + (void)RSqlDatabase::Delete(KDbInjectedName2);
1.49 + (void)RSqlDatabase::Delete(KDbInjectedName1);
1.50 + (void)RSqlDatabase::Delete(KTestDbName2);
1.51 + (void)RSqlDatabase::Delete(KTestDbName1);
1.52 + }
1.53 +
1.54 +///////////////////////////////////////////////////////////////////////////////////////
1.55 +///////////////////////////////////////////////////////////////////////////////////////
1.56 +//Test macros and functions
1.57 +void Check(TInt aValue, TInt aLine)
1.58 + {
1.59 + if(!aValue)
1.60 + {
1.61 + DeleteTestFiles();
1.62 + TheTest(EFalse, aLine);
1.63 + }
1.64 + }
1.65 +void Check(TInt aValue, TInt aExpected, TInt aLine)
1.66 + {
1.67 + if(aValue != aExpected)
1.68 + {
1.69 + DeleteTestFiles();
1.70 + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
1.71 + TheTest(EFalse, aLine);
1.72 + }
1.73 + }
1.74 +#define TEST(arg) ::Check((arg), __LINE__)
1.75 +#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
1.76 +
1.77 +///////////////////////////////////////////////////////////////////////////////////////
1.78 +
1.79 +void CreateTestEnv()
1.80 + {
1.81 + RFs fs;
1.82 + TInt err = fs.Connect();
1.83 + TEST2(err, KErrNone);
1.84 +
1.85 + err = fs.MkDir(KTestDir);
1.86 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.87 +
1.88 + err = fs.CreatePrivatePath(EDriveC);
1.89 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.90 +
1.91 + fs.Close();
1.92 + }
1.93 +
1.94 +///////////////////////////////////////////////////////////////////////////////////////
1.95 +
1.96 +/**
1.97 +@SYMTestCaseID SYSLIB-SQL-UT-3512
1.98 +@SYMTestCaseDesc RSqlStatement::ColumnCount() - SELECT statements test
1.99 + The test creates a database with a table and then checks the ColumnCount()
1.100 + return result for the following statements:
1.101 + - select all columns;
1.102 + - select a subset;
1.103 + - select an expression;
1.104 + - select a constant;
1.105 + - multi-table select;
1.106 + - select a function;
1.107 + - select plus sub-query;
1.108 +@SYMTestPriority High
1.109 +@SYMTestActions RSqlStatement::ColumnCount() test
1.110 +@SYMTestExpectedResults Test must not fail
1.111 +@SYMREQ REQ8035
1.112 +*/
1.113 +void ColumnCountTest()
1.114 + {
1.115 +
1.116 + TInt err = TheDb.Create(KTestDbName1);
1.117 + TEST2(err, KErrNone);
1.118 + //Create table 1
1.119 + err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Name TEXT,Id2 INTEGER,Data BLOB)"));
1.120 + TEST(err >= 0);
1.121 +
1.122 + err = TheDb.Exec(_L("INSERT INTO A VALUES(1,'AAA',6234567890,x'11AAFD0C771188')"));
1.123 + TEST2(err, 1);
1.124 +
1.125 + //Select all columns (SELECT *)
1.126 + err = TheStmt.Prepare(TheDb, _L("SELECT * FROM A"));
1.127 + TEST2(err, KErrNone);
1.128 + TInt cnt = TheStmt.ColumnCount();
1.129 + TEST2(cnt, 4);
1.130 + TheStmt.Close();
1.131 + //Select all columns (SELECT a,b,c...)
1.132 + err = TheStmt.Prepare(TheDb, _L("SELECT Id,Name,Id2,Data FROM A"));
1.133 + TEST2(err, KErrNone);
1.134 + cnt = TheStmt.ColumnCount();
1.135 + TEST2(cnt, 4);
1.136 + TheStmt.Close();
1.137 + //Select column subset
1.138 + err = TheStmt.Prepare(TheDb, _L("SELECT Id,Name,Data FROM A"));
1.139 + TEST2(err, KErrNone);
1.140 + cnt = TheStmt.ColumnCount();
1.141 + TEST2(cnt, 3);
1.142 + TheStmt.Close();
1.143 + //Select column subset + expression
1.144 + err = TheStmt.Prepare(TheDb, _L("SELECT Id,Id+Id2 FROM A"));
1.145 + TEST2(err, KErrNone);
1.146 + cnt = TheStmt.ColumnCount();
1.147 + TEST2(cnt, 2);
1.148 + TheStmt.Close();
1.149 + //Select column subset + constant
1.150 + err = TheStmt.Prepare(TheDb, _L("SELECT Id,Id2,345.78 FROM A"));
1.151 + TEST2(err, KErrNone);
1.152 + cnt = TheStmt.ColumnCount();
1.153 + TEST2(cnt, 3);
1.154 + TheStmt.Close();
1.155 + //Select SQL function
1.156 + err = TheStmt.Prepare(TheDb, _L("SELECT COUNT(*) FROM A"));
1.157 + TEST2(err, KErrNone);
1.158 + cnt = TheStmt.ColumnCount();
1.159 + TEST2(cnt, 1);
1.160 + TheStmt.Close();
1.161 + //Create table 2
1.162 + err = TheDb.Exec(_L("CREATE TABLE B(Id INTEGER, S INTEGER)"));
1.163 + TEST(err >= 0);
1.164 + err = TheDb.Exec(_L("INSERT INTO B VALUES(1,25)"));
1.165 + TEST2(err, 1);
1.166 + //Multitable select
1.167 + err = TheStmt.Prepare(TheDb, _L("SELECT A.Id,B.S FROM A,B WHERE A.Id = B.Id"));
1.168 + TEST2(err, KErrNone);
1.169 + cnt = TheStmt.ColumnCount();
1.170 + TEST2(cnt, 2);
1.171 + TheStmt.Close();
1.172 + //Select + Subquery
1.173 + err = TheStmt.Prepare(TheDb, _L("SELECT Id FROM A WHERE (SELECT S FROM B WHERE A.Id = B.Id) > 10"));
1.174 + TEST2(err, KErrNone);
1.175 + cnt = TheStmt.ColumnCount();
1.176 + TEST2(cnt, 1);
1.177 + TheStmt.Close();
1.178 + //Cleanup
1.179 + TheDb.Close();
1.180 + (void)RSqlDatabase::Delete(KTestDbName1);
1.181 + }
1.182 +
1.183 +/**
1.184 +@SYMTestCaseID SYSLIB-SQL-UT-3513
1.185 +@SYMTestCaseDesc RSqlStatement::ColumnCount() - DDL and DML statements test
1.186 + The test creates a database with a table and then checks the ColumnCount() return result for
1.187 + DML statements (INSERT/UPDATE/DELETE) and DDL statements (CREATE TABLE/INDEX, DROP TABLE?INDEX).
1.188 + The column count for DML and DDL statements should be 0.
1.189 +@SYMTestPriority High
1.190 +@SYMTestActions RSqlStatement::ColumnCount() test
1.191 +@SYMTestExpectedResults Test must not fail
1.192 +@SYMREQ REQ8035
1.193 +*/
1.194 +void ColumnCountTest2()
1.195 + {
1.196 + TInt err = TheDb.Create(KTestDbName1);
1.197 + TEST2(err, KErrNone);
1.198 + //Create table
1.199 + err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Name TEXT,Id2 INTEGER,Data BLOB)"));
1.200 + TEST(err >= 0);
1.201 + err = TheDb.Exec(_L("INSERT INTO A VALUES(1,'AAA',6234567890,x'11AAFD0C771188')"));
1.202 + TEST2(err, 1);
1.203 + //INSERT statement
1.204 + err = TheStmt.Prepare(TheDb, _L("INSERT INTO A(Id,Id2) VALUES(:P1,:P2)"));
1.205 + TEST2(err, KErrNone);
1.206 + TInt cnt = TheStmt.ColumnCount();
1.207 + TEST2(cnt, 0);
1.208 + TheStmt.Close();
1.209 + //UPDATE statement
1.210 + err = TheStmt.Prepare(TheDb, _L("UPDATE A SET Id2=100 WHERE Id=:P1"));
1.211 + TEST2(err, KErrNone);
1.212 + cnt = TheStmt.ColumnCount();
1.213 + TEST2(cnt, 0);
1.214 + TheStmt.Close();
1.215 + //DELETE statement
1.216 + err = TheStmt.Prepare(TheDb, _L("DELETE FROM A WHERE Id=:P1"));
1.217 + TEST2(err, KErrNone);
1.218 + cnt = TheStmt.ColumnCount();
1.219 + TEST2(cnt, 0);
1.220 + TheStmt.Close();
1.221 + //CREATE TABLE statement
1.222 + err = TheStmt.Prepare(TheDb, _L("CREATE TABLE B AS SELECT * FROM A"));
1.223 + TEST2(err, KErrNone);
1.224 + cnt = TheStmt.ColumnCount();
1.225 + TEST2(cnt, 0);
1.226 + TheStmt.Close();
1.227 + //DROP TABLE statement
1.228 + err = TheStmt.Prepare(TheDb, _L("DROP TABLE A"));
1.229 + TEST2(err, KErrNone);
1.230 + cnt = TheStmt.ColumnCount();
1.231 + TEST2(cnt, 0);
1.232 + TheStmt.Close();
1.233 + //CREATE INDEX statement
1.234 + err = TheStmt.Prepare(TheDb, _L("CREATE INDEX I ON A(Id)"));
1.235 + TEST2(err, KErrNone);
1.236 + cnt = TheStmt.ColumnCount();
1.237 + TEST2(cnt, 0);
1.238 + err = TheStmt.Exec();
1.239 + TEST(err >= 0);
1.240 + TheStmt.Close();
1.241 + //DROP INDEX statement
1.242 + err = TheStmt.Prepare(TheDb, _L("DROP INDEX I"));
1.243 + TEST2(err, KErrNone);
1.244 + cnt = TheStmt.ColumnCount();
1.245 + TEST2(cnt, 0);
1.246 + TheStmt.Close();
1.247 + //CREATE TRIGGER statement
1.248 + err = TheStmt.Prepare(TheDb,
1.249 + _L("CREATE TRIGGER Trg BEFORE DELETE ON A \
1.250 + BEGIN \
1.251 + SELECT CASE WHEN ((SELECT Id2 FROM A WHERE A.Id = old.Id) > 0) \
1.252 + THEN RAISE (ABORT, 'Id2 > 0') \
1.253 + END;\
1.254 + END;"));
1.255 + TEST2(err, KErrNone);
1.256 + cnt = TheStmt.ColumnCount();
1.257 + TEST2(cnt, 0);
1.258 + TheStmt.Close();
1.259 + //CREATE VIEW statement
1.260 + err = TheStmt.Prepare(TheDb, _L("CREATE VIEW V AS SELECT * FROM A"));
1.261 + TEST2(err, KErrNone);
1.262 + cnt = TheStmt.ColumnCount();
1.263 + TEST2(cnt, 0);
1.264 + err = TheStmt.Exec();
1.265 + TEST(err >= 0);
1.266 + TheStmt.Close();
1.267 + //DROP VIEW statement
1.268 + err = TheStmt.Prepare(TheDb, _L("DROP VIEW V"));
1.269 + TEST2(err, KErrNone);
1.270 + cnt = TheStmt.ColumnCount();
1.271 + TEST2(cnt, 0);
1.272 + TheStmt.Close();
1.273 + //Cleanup
1.274 + TheDb.Close();
1.275 + (void)RSqlDatabase::Delete(KTestDbName1);
1.276 + }
1.277 +
1.278 +/**
1.279 +@SYMTestCaseID SYSLIB-SQL-UT-3514
1.280 +@SYMTestCaseDesc RSqlStatement::DeclaredColumnType() test
1.281 + The test creates a database with a table and then checks the DeclaredColumnType() return result for:
1.282 + - select all column from the table and check their types;
1.283 + - multi-table select plus column type checks;
1.284 + - select expression - the expected column type is ESqlInt;
1.285 + - select constant - the expected column type is ESqlInt;
1.286 +@SYMTestPriority High
1.287 +@SYMTestActions RSqlStatement::ColumnCount() test
1.288 +@SYMTestExpectedResults Test must not fail
1.289 +@SYMREQ REQ8035
1.290 +*/
1.291 +void DeclaredColumnTypeTest()
1.292 + {
1.293 + TInt err = TheDb.Create(KTestDbName1);
1.294 + TEST2(err, KErrNone);
1.295 + const char* KColTypeNames[] =
1.296 + {"INTEGER", "LONG INTEGER", "INT", "SHORT INT", "SMALL INT", "TINY INT", "SHORT", "INT64",
1.297 + "TEXT", "LONGTEXT", "CLOB", "CHAR", "CHARACTER(20)", "LONG TEXT",
1.298 + "BINARY", "LONG BINARY", "LONGBINARY", "BLOB", "LONGBLOB", "LONG BLOB",
1.299 + "REAL", "FLOAT", "DOUBLE", "LONG DOUBLE",
1.300 + "LONG LONG", "BOO HOO"};
1.301 + const TSqlColumnType KColTypes[] =
1.302 + {ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,
1.303 + ESqlText,ESqlText,ESqlText,ESqlText,ESqlText,ESqlText,
1.304 + ESqlBinary,ESqlBinary,ESqlBinary,ESqlBinary,ESqlBinary,ESqlBinary,
1.305 + ESqlReal,ESqlReal,ESqlReal,ESqlReal,
1.306 + ESqlInt,ESqlInt};
1.307 + const TInt KColTypeCnt = sizeof(KColTypes) / sizeof(KColTypes[0]);
1.308 + TEST2(sizeof(KColTypeNames) / sizeof(KColTypeNames[0]), KColTypeCnt);
1.309 + //Create table 1
1.310 + TBuf8<512> sql;
1.311 + sql.Copy(_L8("CREATE TABLE T("));
1.312 + for(TInt i=0;i<KColTypeCnt;++i)
1.313 + {
1.314 + sql.Append(TChar('A'));
1.315 + sql.AppendNum(i + 1);
1.316 + sql.Append(TChar(' '));
1.317 + sql.Append((TUint8*)KColTypeNames[i], User::StringLength((TUint8*)KColTypeNames[i]));
1.318 + sql.Append(TChar(','));
1.319 + }
1.320 + sql.Replace(sql.Length() - 1, 1, _L8(")"));
1.321 + err = TheDb.Exec(sql);
1.322 + TEST(err >= 0);
1.323 + //Select all columns (SELECT *)
1.324 + err = TheStmt.Prepare(TheDb, _L("SELECT * FROM T"));
1.325 + TEST2(err, KErrNone);
1.326 + TInt cnt = TheStmt.ColumnCount();
1.327 + TEST2(cnt, KColTypeCnt);
1.328 + TSqlColumnType colType;
1.329 + for(TInt i=0;i<KColTypeCnt;++i)
1.330 + {
1.331 + TInt err = TheStmt.DeclaredColumnType(i, colType);
1.332 + TEST2(err, KErrNone);
1.333 + TEST2(colType, KColTypes[i]);
1.334 + }
1.335 + TheStmt.Close();
1.336 + //Create table 2
1.337 + err = TheDb.Exec(_L8("CREATE TABLE T2(Id INTEGER, DATA BLOB)"));
1.338 + TEST(err >= 0);
1.339 + //Multi-table select
1.340 + err = TheStmt.Prepare(TheDb, _L("SELECT T.A1,T2.Id,T.A9,T2.Data FROM T,T2"));
1.341 + TEST2(err, KErrNone);
1.342 + err = TheStmt.DeclaredColumnType(0, colType);
1.343 + TEST2(err, KErrNone);
1.344 + TEST2(colType, ESqlInt);
1.345 + err = TheStmt.DeclaredColumnType(1, colType);
1.346 + TEST2(err, KErrNone);
1.347 + TEST2(colType, ESqlInt);
1.348 + err = TheStmt.DeclaredColumnType(2, colType);
1.349 + TEST2(err, KErrNone);
1.350 + TEST2(colType, ESqlText);
1.351 + err = TheStmt.DeclaredColumnType(3, colType);
1.352 + TEST2(err, KErrNone);
1.353 + TEST2(colType, ESqlBinary);
1.354 + TheStmt.Close();
1.355 + //Select expression
1.356 + err = TheStmt.Prepare(TheDb, _L("SELECT (Id + Data) AS RES FROM t2"));
1.357 + TEST2(err, KErrNone);
1.358 + err = TheStmt.DeclaredColumnType(0, colType);
1.359 + TEST2(err, KErrNone);
1.360 + TEST2(colType, ESqlInt);
1.361 + TheStmt.Close();
1.362 + //Select constant
1.363 + err = TheStmt.Prepare(TheDb, _L("SELECT (Id + Data) AS RES, 55.89 FROM t2"));
1.364 + TEST2(err, KErrNone);
1.365 + err = TheStmt.DeclaredColumnType(1, colType);
1.366 + TEST2(err, KErrNone);
1.367 + TEST2(colType, ESqlInt);
1.368 + TheStmt.Close();
1.369 + //Cleanup
1.370 + TheDb.Close();
1.371 + (void)RSqlDatabase::Delete(KTestDbName1);
1.372 + }
1.373 +
1.374 +/**
1.375 +@SYMTestCaseID SYSLIB-SQL-UT-4017
1.376 +@SYMTestCaseDesc RSqlStatement::ColumnName(TInt, TPtrC&) test
1.377 + The test creates a database with a table and then checks the ColumnName() return result for:
1.378 + - select all column from the table and check their names;
1.379 + - multi-table select plus column name checks;
1.380 + - select expression - the expected column name is RES
1.381 + - select constant - the expected column type is 55.89
1.382 +@SYMTestPriority High
1.383 +@SYMTestActions RSqlStatement::ColumnName() test
1.384 +@SYMTestExpectedResults Test must not fail
1.385 +@SYMCR RMAD-7B7EV5
1.386 + Add SQL Server APIs to retrieve column and parameter names
1.387 +*/
1.388 +void ColumnNameTest()
1.389 + {
1.390 + TInt err = TheDb.Create(KTestDbName1);
1.391 + TEST2(err, KErrNone);
1.392 + const char* KColTypeNames[] =
1.393 + {"INTEGER", "LONG INTEGER", "INT", "SHORT INT", "SMALL INT", "TINY INT", "SHORT", "INT64",
1.394 + "TEXT", "LONGTEXT", "CLOB", "CHAR", "CHARACTER(20)", "LONG TEXT",
1.395 + "BINARY", "LONG BINARY", "LONGBINARY", "BLOB", "LONGBLOB", "LONG BLOB",
1.396 + "REAL", "FLOAT", "DOUBLE", "LONG DOUBLE",
1.397 + "LONG LONG", "BOO HOO"};
1.398 + const TSqlColumnType KColTypes[] =
1.399 + {ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,ESqlInt,
1.400 + ESqlText,ESqlText,ESqlText,ESqlText,ESqlText,ESqlText,
1.401 + ESqlBinary,ESqlBinary,ESqlBinary,ESqlBinary,ESqlBinary,ESqlBinary,
1.402 + ESqlReal,ESqlReal,ESqlReal,ESqlReal,
1.403 + ESqlInt,ESqlInt};
1.404 + const TInt KColTypeCnt = sizeof(KColTypes) / sizeof(KColTypes[0]);
1.405 + TEST2(sizeof(KColTypeNames) / sizeof(KColTypeNames[0]), KColTypeCnt);
1.406 + //Create table 1
1.407 + TBuf8<512> sql;
1.408 + sql.Copy(_L8("CREATE TABLE T("));
1.409 + for(TInt i=0;i<KColTypeCnt;++i)
1.410 + {
1.411 + sql.Append(TChar('A'));
1.412 + sql.AppendNum(i + 1);
1.413 + sql.Append(TChar(' '));
1.414 + sql.Append((TUint8*)KColTypeNames[i], User::StringLength((TUint8*)KColTypeNames[i]));
1.415 + sql.Append(TChar(','));
1.416 + }
1.417 + sql.Replace(sql.Length() - 1, 1, _L8(")"));
1.418 + err = TheDb.Exec(sql);
1.419 + TEST(err >= 0);
1.420 + //Select all columns (SELECT *)
1.421 + err = TheStmt.Prepare(TheDb, _L("SELECT * FROM T"));
1.422 + TEST2(err, KErrNone);
1.423 + TInt cnt = TheStmt.ColumnCount();
1.424 + TEST2(cnt, KColTypeCnt);
1.425 + TPtrC colName;
1.426 + TBuf<128> expectedColName;
1.427 + for(TInt i=0;i<KColTypeCnt;++i)
1.428 + {
1.429 + expectedColName.Zero();
1.430 + expectedColName.Append(TChar('A'));
1.431 + expectedColName.AppendNum(i + 1);
1.432 + TInt err = TheStmt.ColumnName(i, colName);
1.433 + TEST2(err, KErrNone);
1.434 + TEST2(colName.Compare(expectedColName), 0);
1.435 + TSqlColumnType type;
1.436 + err = TheStmt.DeclaredColumnType(i, type);
1.437 + TEST2(err, KErrNone);
1.438 + TEST2(type, KColTypes[i]);
1.439 + }
1.440 + TheStmt.Close();
1.441 + //Create table 2
1.442 + err = TheDb.Exec(_L8("CREATE TABLE T2(Id INTEGER, DATA BLOB)"));
1.443 + TEST(err >= 0);
1.444 + //Multi-table select
1.445 + err = TheStmt.Prepare(TheDb, _L("SELECT T.A1,T2.Id,T.A9,T2.DATA FROM T,T2"));
1.446 + TEST2(err, KErrNone);
1.447 + err = TheStmt.ColumnName(0, colName);
1.448 + TEST2(err, KErrNone);
1.449 + TEST2(colName.Compare(_L("A1")), 0);
1.450 + err = TheStmt.ColumnName(1, colName);
1.451 + TEST2(err, KErrNone);
1.452 + TEST2(colName.Compare(_L("Id")), 0);
1.453 + err = TheStmt.ColumnName(2, colName);
1.454 + TEST2(err, KErrNone);
1.455 + TEST2(colName.Compare(_L("A9")), 0);
1.456 + err = TheStmt.ColumnName(3, colName);
1.457 + TEST2(err, KErrNone);
1.458 + TEST2(colName.Compare(_L("DATA")), 0);
1.459 + TheStmt.Close();
1.460 + //Select expression
1.461 + err = TheStmt.Prepare(TheDb, _L("SELECT (Id + Data) AS RES FROM t2"));
1.462 + TEST2(err, KErrNone);
1.463 + err = TheStmt.ColumnName(0, colName);
1.464 + TEST2(err, KErrNone);
1.465 + TEST2(colName.Compare(_L("RES")), 0);
1.466 + //Too big column index
1.467 + err = TheStmt.ColumnName(1323, colName);
1.468 + TEST2(err, KErrNotFound);
1.469 + //Negative column index
1.470 + err = TheStmt.ColumnName(-100, colName);
1.471 + TEST2(err, KErrNotFound);
1.472 + TheStmt.Close();
1.473 + //Select constant
1.474 + err = TheStmt.Prepare(TheDb, _L("SELECT (Id + Data) AS RES, 55.89 FROM t2"));
1.475 + TEST2(err, KErrNone);
1.476 + err = TheStmt.ColumnName(1, colName);
1.477 + TEST2(err, KErrNone);
1.478 + TEST2(colName.Compare(_L("55.89")), 0);
1.479 + TheStmt.Close();
1.480 + //Cleanup
1.481 + TheDb.Close();
1.482 + (void)RSqlDatabase::Delete(KTestDbName1);
1.483 + }
1.484 +
1.485 +/**
1.486 +@SYMTestCaseID SYSLIB-SQL-UT-4018
1.487 +@SYMTestCaseDesc RSqlStatement::ParameterName(TInt, TPtrC&) and RSqlStatement::ParamName(TInt, TPtrC&) test
1.488 + DML test:
1.489 + The test creates a database with a table and prepares an insert query.
1.490 + The test then checks the ParameterName() and ParamName() return result for:
1.491 + - Named parameters - return the named param
1.492 + - Unnamed parameters - return ?<param-index>
1.493 +@SYMTestPriority High
1.494 +@SYMTestActions RSqlStatement::ParameterName() and RSqlStatement::ParamName() test
1.495 +@SYMTestExpectedResults Test must not fail
1.496 +@SYMCR RMAD-7B7EV5
1.497 + Add SQL Server APIs to retrieve column and parameter names
1.498 +*/
1.499 +void ParamNameTest()
1.500 + {
1.501 + TInt err = TheDb.Create(KTestDbName1);
1.502 + TEST2(err, KErrNone);
1.503 + const char* KColTypeNames[] =
1.504 + {"INTEGER", "TEXT"};
1.505 + const TInt KColTypeCnt = sizeof(KColTypeNames) / sizeof(KColTypeNames[0]);
1.506 + //Create table 1
1.507 + TBuf8<256> sql;
1.508 + sql.Copy(_L8("CREATE TABLE T("));
1.509 + for(TInt i=0;i<KColTypeCnt;++i)
1.510 + {
1.511 + sql.Append(TChar('A'));
1.512 + sql.AppendNum(i + 1);
1.513 + sql.Append(TChar(' '));
1.514 + sql.Append((TUint8*)KColTypeNames[i], User::StringLength((TUint8*)KColTypeNames[i]));
1.515 + sql.Append(TChar(','));
1.516 + }
1.517 + sql.Replace(sql.Length() - 1, 1, _L8(")"));
1.518 + err = TheDb.Exec(sql);
1.519 + TEST(err >= 0);
1.520 + TheStmt.Close();
1.521 +
1.522 + // Create insert statement, then check param names
1.523 + err = TheStmt.Prepare(TheDb, _L("INSERT INTO T (A1, A2) VALUES (:prm1, :prm2)"));
1.524 + TEST2(err, KErrNone);
1.525 + TPtrC paramName;
1.526 + TBuf<128> expectedParamName;
1.527 + for(TInt i=0;i<KColTypeCnt;++i)
1.528 + {
1.529 + expectedParamName.Zero();
1.530 + expectedParamName.Append(_L(":prm"));
1.531 + expectedParamName.AppendNum(i + 1);
1.532 + TInt paramIndex = TheStmt.ParameterIndex(expectedParamName);
1.533 + TEST2(paramIndex, i);
1.534 + TInt err = TheStmt.ParameterName(i, paramName);
1.535 + TEST2(err, KErrNone);
1.536 + TEST2(paramName.Compare(expectedParamName), 0);
1.537 + err = TheStmt.ParamName(i, paramName);
1.538 + TEST2(err, KErrNone);
1.539 + TEST2(paramName.Compare(expectedParamName), 0);
1.540 + }
1.541 + //Too big parameter index
1.542 + err = TheStmt.ParamName(1323, paramName);
1.543 + TEST2(err, KErrNotFound);
1.544 + //Negative parameter index
1.545 + err = TheStmt.ParamName(-100, paramName);
1.546 + TEST2(err, KErrNotFound);
1.547 + TheStmt.Close();
1.548 +
1.549 + //SQL statement without parameters
1.550 + err = TheStmt.Prepare(TheDb, _L("INSERT INTO T (A1, A2) VALUES (1, '1')"));
1.551 + TEST2(err, KErrNone);
1.552 + err = TheStmt.ParamName(0, paramName);
1.553 + TEST2(err, KErrNotFound);
1.554 + TheStmt.Close();
1.555 +
1.556 + // Create insert statement, then check param names
1.557 + err = TheStmt.Prepare(TheDb, _L("INSERT INTO T (A1, A2) VALUES (:prm1, ?)"));
1.558 + TEST2(err, KErrNone);
1.559 +
1.560 + expectedParamName.Zero();
1.561 + expectedParamName.Append(_L(":prm1"));
1.562 + TInt paramIndex = TheStmt.ParameterIndex(expectedParamName);
1.563 + TEST2(paramIndex, 0);
1.564 + err = TheStmt.ParameterName(0, paramName);
1.565 + TEST2(err, KErrNone);
1.566 + TEST2(paramName.Compare(expectedParamName), 0);
1.567 + err = TheStmt.ParamName(0, paramName);
1.568 + TEST2(err, KErrNone);
1.569 + TEST2(paramName.Compare(expectedParamName), 0);
1.570 +
1.571 + expectedParamName.Zero();
1.572 + expectedParamName.Append(_L("?1"));
1.573 + err = TheStmt.ParameterName(1, paramName);
1.574 + TEST2(err, KErrNone);
1.575 + paramIndex = TheStmt.ParameterIndex(expectedParamName);
1.576 + TEST2(paramIndex, 1);
1.577 + TEST2(paramName.Compare(expectedParamName), 0);
1.578 +
1.579 + err = TheStmt.ParamName(1, paramName);
1.580 + TEST2(err, KErrNone);
1.581 + TEST2(paramName.Compare(expectedParamName), 0);
1.582 +
1.583 + TheStmt.Close();
1.584 +
1.585 + //Cleanup
1.586 + TheDb.Close();
1.587 + (void)RSqlDatabase::Delete(KTestDbName1);
1.588 + }
1.589 +
1.590 +
1.591 +/**
1.592 +@SYMTestCaseID SYSLIB-SQL-UT-4006
1.593 +@SYMTestCaseDesc Test for DEF115300 - SqlSrv.EXE::!SQL Server when preparing invalid LEFT JOIN sql query.
1.594 + The test does the following steps:
1.595 + 1) Creates a 16-bit database and using 16-bit queries proves that the "GROUP BY GROUP BY" syntax error
1.596 + does not cause an assert inside the SQLITE code.
1.597 + 2) Creates a 8-bit database and using 8-bit queries proves that the "GROUP BY GROUP BY" syntax error
1.598 + does not cause an assert inside the SQLITE code.
1.599 +@SYMTestPriority Medium
1.600 +@SYMTestActions Test for DEF115300 - SqlSrv.EXE::!SQL Server when preparing invalid LEFT JOIN sql query.
1.601 +@SYMTestExpectedResults Test must not fail
1.602 +@SYMDEF DEF115300
1.603 +*/
1.604 +void DEF115300()
1.605 + {
1.606 +
1.607 + //Step 1: 16-bit statements
1.608 + (void)RSqlDatabase::Delete(KTestDbName1);
1.609 + TInt err = TheDb.Create(KTestDbName1);
1.610 + TEST2(err, KErrNone);
1.611 +
1.612 + err = TheDb.Exec(_L("CREATE TABLE MAIN(Id INTEGER, Id1 INTEGER, F2 BLOB)"));
1.613 + TEST2(err, 1);
1.614 + err = TheDb.Exec(_L("INSERT INTO MAIN(Id,Id1) VALUES(2,3)"));
1.615 + TEST2(err, 1);
1.616 + err = TheDb.Exec(_L("INSERT INTO MAIN(Id,Id1) VALUES(3,4)"));
1.617 + TEST2(err, 1);
1.618 +
1.619 + err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER, Id1 INTEGER, F2 BLOB)"));
1.620 + TEST2(err, 1);
1.621 + err = TheDb.Exec(_L("INSERT INTO A(Id, Id1) VALUES(2,3)"));
1.622 + TEST2(err, 1);
1.623 + err = TheDb.Exec(_L("INSERT INTO A(Id, Id1) VALUES(4,4)"));
1.624 + TEST2(err, 1);
1.625 +
1.626 + err = TheDb.Exec(_L("CREATE TABLE B(Id INTEGER, Id1 INTEGER, F2 BLOB)"));
1.627 + TEST2(err, 1);
1.628 + err = TheDb.Exec(_L("INSERT INTO B(Id, Id1) VALUES(2,3)"));
1.629 + TEST2(err, 1);
1.630 + err = TheDb.Exec(_L("INSERT INTO B(Id, Id1) VALUES(5,4)"));
1.631 + TEST2(err, 1);
1.632 + err = TheDb.Exec(_L("INSERT INTO B(Id, Id1) VALUES(5,4)"));
1.633 + TEST2(err, 1);
1.634 +
1.635 + err = TheDb.Exec(_L("CREATE VIEW v2 AS SELECT Id,Id1,F2 FROM B"));
1.636 + TEST2(err, 1);
1.637 + err = TheDb.Exec(_L("CREATE VIEW v1 AS SELECT Id,Id1,F2 FROM A"));
1.638 + TEST2(err, 1);
1.639 + err = TheDb.Exec(_L("CREATE VIEW v3 AS SELECT Id,Id1,F2 FROM B"));
1.640 + TEST2(err, 1);
1.641 +
1.642 + RSqlStatement stmt;
1.643 + err = stmt.Prepare(TheDb, _L("SELECT * FROM v2 LEFT JOIN MAIN ON v2.Id = MAIN.Id LEFT JOIN A ON MAIN.Id = A.Id GROUP BY GROUP BY MAIN.Id"));
1.644 + stmt.Close();
1.645 + TEST(err != KErrNone && err != KErrServerTerminated);
1.646 +
1.647 + TheDb.Close();
1.648 + err = RSqlDatabase::Delete(KTestDbName1);
1.649 + TEST2(err, KErrNone);
1.650 +
1.651 + //Step 2: 8-bit statements
1.652 + _LIT8(KServerConfigString1, "encoding=\"UTF-8\"");
1.653 + err = TheDb.Create(KTestDbName1, &KServerConfigString1);
1.654 + TEST2(err, KErrNone);
1.655 +
1.656 + err = TheDb.Exec(_L8("CREATE TABLE MAIN(Id INTEGER, Id1 INTEGER, F2 BLOB)"));
1.657 + TEST2(err, 1);
1.658 +
1.659 + err = stmt.Prepare(TheDb, _L8("SELECT * FROM main GROUP BY GROUP BY main.Id"));
1.660 + stmt.Close();
1.661 + TEST(err != KErrNone && err != KErrServerTerminated);
1.662 +
1.663 + TheDb.Close();
1.664 + err = RSqlDatabase::Delete(KTestDbName1);
1.665 + TEST2(err, KErrNone);
1.666 + }
1.667 +
1.668 +/**
1.669 +@SYMTestCaseID SYSLIB-SQL-UT-4007
1.670 +@SYMTestCaseDesc Test for DEF115331 - SQL, bad code coverage for db reindexing if default collation has changed.
1.671 + The test does the following steps, using public shared and private secure database:
1.672 + 1) Creates a test database with a table and one index using one of the collations.
1.673 + 2) Updates the symbian_settings table, setting the collation dll name column value
1.674 + to be a "bbbababz" string (Simulates that there is no valid collation dll name).
1.675 + 3) Reopens the database. This operation should cause a database reindexing, since the index uses
1.676 + one of the user-defined collation methods.
1.677 + The default system collation dll name should be stored in the symbian_settings table.
1.678 + 4) Verifies that symbian_settings table contains only one record and that the collation dll name
1.679 + column value has been updated.
1.680 +@SYMTestPriority Medium
1.681 +@SYMTestActions Test for DEF115331 - SQL, bad code coverage for db reindexing if default collation has changed.
1.682 +@SYMTestExpectedResults Test must not fail
1.683 +@SYMDEF DEF115331
1.684 +*/
1.685 +void DEF115331L()
1.686 + {
1.687 + const TPtrC KDbNames[] = {KTestDbName1(), KTestDbName2()};
1.688 +
1.689 + for(TInt i=0;i<(sizeof(KDbNames)/sizeof(KDbNames[0]));++i)
1.690 + {
1.691 + //Step 1: Create a test database with a table and one index using one of the collations.
1.692 + (void)RSqlDatabase::Delete(KDbNames[i]);
1.693 + TInt err = TheDb.Create(KDbNames[i]);
1.694 + TEST2(err, KErrNone);
1.695 +
1.696 + err = TheDb.Exec(_L("CREATE TABLE A(C TEXT)"));
1.697 + TEST2(err, 1);
1.698 +
1.699 + err = TheDb.Exec(_L("CREATE INDEX I ON A(C COLLATE CompareC1)"));
1.700 + TEST2(err, 1);
1.701 +
1.702 + //Step 2: Make sure that the collation dll name is set and unique (not the default collation).
1.703 + err = TheDb.Exec(_L("UPDATE symbian_settings SET CollationDllName='bbbababz'"));
1.704 + TEST2(err, 1);
1.705 +
1.706 + TheDb.Close();
1.707 +
1.708 + //Step 3: Reopen the database. That step should cause a database reindexing, because the default collation dll
1.709 + // name is not the one stored in the table.
1.710 + err = TheDb.Open(KDbNames[i]);
1.711 + TEST2(err, KErrNone);
1.712 +
1.713 + TSqlScalarFullSelectQuery query(TheDb);
1.714 +
1.715 + //Step 4: Check that the settigns table has only one record.
1.716 + TInt cnt = query.SelectIntL(_L("SELECT COUNT(*) FROM symbian_settings"));
1.717 + TEST2(cnt, 1);
1.718 +
1.719 + //Step 5: Check that the collation dll name in the settings table has been updated.
1.720 + TFileName collationDllName;
1.721 + err = query.SelectTextL(_L("SELECT CollationDllName FROM symbian_settings"), collationDllName);
1.722 + TEST2(err, KErrNone);
1.723 + _LIT(KTestCollationDllName, "bbbababz");//The same as the used in step 2 - above.
1.724 + TEST(collationDllName != KTestCollationDllName);
1.725 +
1.726 + TheDb.Close();
1.727 + err = RSqlDatabase::Delete(KDbNames[i]);
1.728 + TEST2(err, KErrNone);
1.729 + }
1.730 + }
1.731 +
1.732 +/**
1.733 +@SYMTestCaseID SYSLIB-SQL-UT-4079
1.734 +@SYMTestCaseDesc RSqlDatabase::Create() and RSqlDatabase::Open() - injection test
1.735 + The test attempts to create or open a database which name contains
1.736 + "DELETE FROM symbian_settings" statement.If it is possible to open or
1.737 + create a database with that name, the "symbian_settings" table content
1.738 + should stay unchanged.
1.739 +@SYMTestPriority Medium
1.740 +@SYMTestActions RSqlDatabase::Create() and RSqlDatabase::Open() - injection test
1.741 +@SYMTestExpectedResults Test must not fail
1.742 +@SYMREQ REQ5792
1.743 +*/
1.744 +void InjectionTest()
1.745 + {
1.746 + TInt err = TheDb.Create(KDbInjectedName1);
1.747 + TEST(err != KErrNone);
1.748 +
1.749 + err = TheDb.Create(KDbInjectedName2);
1.750 + TEST2(err, KErrNone);
1.751 +
1.752 + TSqlScalarFullSelectQuery query(TheDb);
1.753 + TInt recCount = 0;
1.754 + TRAP(err, recCount = query.SelectIntL(_L("SELECT COUNT(*) FROM symbian_settings")));
1.755 + TEST2(err, KErrNone);
1.756 + TEST2(recCount, 1);
1.757 + TheDb.Close();
1.758 +
1.759 + err = TheDb.Open(KDbInjectedName2);
1.760 + TEST2(err, KErrNone);
1.761 + recCount = 0;
1.762 + query.SetDatabase(TheDb);
1.763 + TRAP(err, recCount = query.SelectIntL(_L("SELECT COUNT(*) FROM symbian_settings")));
1.764 + TEST2(err, KErrNone);
1.765 + TEST2(recCount, 1);
1.766 + TheDb.Close();
1.767 +
1.768 + (void)RSqlDatabase::Delete(KDbInjectedName2);
1.769 + (void)RSqlDatabase::Delete(KDbInjectedName1);
1.770 + }
1.771 +
1.772 +/**
1.773 +@SYMTestCaseID SYSLIB-SQL-UT-4038
1.774 +@SYMTestCaseDesc Background compaction - two connections usability test.
1.775 + The test creates a database connection with a background compaction mode. The the test
1.776 + locks the database in a transaction. Then the test creates a second connection
1.777 + to the same database while the first connection is in a transaction.
1.778 +@SYMTestPriority Medium
1.779 +@SYMTestActions Background compaction - two connections usability test.
1.780 +@SYMTestExpectedResults Test must not fail
1.781 +@SYMREQ REQ10271
1.782 +*/
1.783 +void TwoConnectionsTest()
1.784 + {
1.785 + (void)RSqlDatabase::Delete(KTestDbName1);
1.786 + RSqlDatabase db1, db2;
1.787 + TInt err = db1.Create(KTestDbName1);
1.788 + TEST2(err, KErrNone);
1.789 + err = db1.Exec(_L("CREATE TABLE A(I INTEGER); INSERT INTO A VALUES(1)"));
1.790 + TEST2(err, 1);
1.791 + err = db1.Exec(_L("BEGIN TRANSACTION"));
1.792 + TEST(err >= 0);
1.793 + err = db1.Exec(_L("INSERT INTO A VALUES(2)"));
1.794 + TEST2(err, 1);
1.795 + err = db2.Open(KTestDbName1);
1.796 + TEST2(err, KErrNone);
1.797 + err = db1.Exec(_L("COMMIT TRANSACTION"));
1.798 + TEST(err >= 0);
1.799 + db2.Close();
1.800 + db1.Close();
1.801 + (void)RSqlDatabase::Delete(KTestDbName1);
1.802 + }
1.803 +
1.804 +TInt StackOverflowThreadFunc(void* aData)
1.805 + {
1.806 + CTrapCleanup* tc = CTrapCleanup::New();
1.807 + TEST(tc != NULL);
1.808 +
1.809 + User::SetJustInTime(EFalse); // disable debugger panic handling
1.810 +
1.811 + TInt* cntptr = reinterpret_cast<TInt*> (aData);
1.812 + TEST(cntptr != NULL);
1.813 + TInt cnt = *cntptr;
1.814 +
1.815 + HBufC* buf = HBufC::New(cnt * 12 + 32);//enough for the "SELECT Id FROM A WHERE Id=v1 OR Id=v2 OR ..." string
1.816 + if(!buf)
1.817 + {
1.818 + delete tc;
1.819 + return KErrNoMemory;
1.820 + }
1.821 + TPtr sql = buf->Des();
1.822 +
1.823 + TInt err = TheDb.Open(KTestDbName1);
1.824 + if(err != KErrNone)
1.825 + {
1.826 + delete buf;
1.827 + delete tc;
1.828 + return err;
1.829 + }
1.830 +
1.831 + TTime now;
1.832 + now.UniversalTime();
1.833 + TInt64 seed = now.Int64();
1.834 +
1.835 + sql.Copy(_L("SELECT Id FROM A WHERE "));
1.836 + for(TInt i=0;i<cnt;++i)
1.837 + {
1.838 + sql.Append(_L("Id="));
1.839 + sql.AppendNum(Math::Rand(seed) % cnt);
1.840 + sql.Append(_L(" OR "));
1.841 + }
1.842 + sql.SetLength(sql.Length() - 4);//Remove the last " OR "
1.843 +
1.844 + RSqlStatement stmt;
1.845 + err = stmt.Prepare(TheDb, sql);
1.846 + stmt.Close();
1.847 +
1.848 + TheDb.Close();
1.849 + delete buf;
1.850 + delete tc;
1.851 +
1.852 + return err;
1.853 + }
1.854 +
1.855 +/**
1.856 +@SYMTestCaseID SYSLIB-SQL-UT-4080
1.857 +@SYMTestCaseDesc SQL server stack overflow test
1.858 + The test creates a database and runs a thread. The thread opens the database
1.859 + and attempts to execute a SELECT statement, which format is:
1.860 + "SELECT Id FROM A WHERE Id=1 OR Id=2 OR...OR Id=N",
1.861 + where N is a number passed as an argument from the main thread, starts from 100000
1.862 + and is increased or decreased on each test iteration, depending on the reported result from the thread.
1.863 + Finally, the main thread will report the max number of the OR subexpressions that can be included
1.864 + in the SELECT statement, without an error to be reported.
1.865 + The test should not crash the SQL server, if the server stack size and parsing tree depth has
1.866 + been properly configured.
1.867 +@SYMTestPriority Medium
1.868 +@SYMTestActions SQL server stack overflow test
1.869 +@SYMTestExpectedResults Test must not fail
1.870 +@SYMREQ REQ5792
1.871 +*/
1.872 +void SqlServerStackOverflowTest()
1.873 + {
1.874 + (void)RSqlDatabase::Delete(KTestDbName1);
1.875 + TInt err = TheDb.Create(KTestDbName1);
1.876 + TEST2(err, KErrNone);
1.877 + err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER PRIMARY KEY AUTOINCREMENT)"));
1.878 + TEST2(err, 1);
1.879 + TheDb.Close();
1.880 +
1.881 + TInt prev = 0, next = 100000;
1.882 + while(Abs(next - prev) > 0)
1.883 + {
1.884 + TInt count = next;
1.885 + TheTest.Printf(_L("'OR' expr. count: %d\r\n"), count);
1.886 + RThread thread;
1.887 + _LIT(KThreadName,"ORThread"); //stack minheap maxheap
1.888 + err = thread.Create(KThreadName, &StackOverflowThreadFunc, 0x2000, 0x00100000, 0x02000000, &count);
1.889 + TEST2(err, KErrNone);
1.890 +
1.891 + TRequestStatus status;
1.892 + thread.Logon(status);
1.893 + TEST2(status.Int(), KRequestPending);
1.894 + thread.Resume();
1.895 + User::WaitForRequest(status);
1.896 + User::SetJustInTime(ETrue); // enable debugger panic handling
1.897 +
1.898 + TInt exitType = thread.ExitType();
1.899 + const TDesC& exitCategory = thread.ExitCategory();
1.900 + TInt exitReason = thread.ExitReason();
1.901 + TheTest.Printf(_L("Exit type: %d, exit reason: %d, exit category: %S\r\n"), exitType, exitReason, &exitCategory);
1.902 + thread.Close();
1.903 + TEST(exitReason != KErrServerTerminated);
1.904 + TEST(exitType != EExitPanic);
1.905 +
1.906 + TInt tmp = next;
1.907 + if(status.Int() != KErrNone)
1.908 + {//The number of the OR subexpressions is too big and cannot be parsed. Decrease the number, repeat the test.
1.909 + next -= Abs(next - prev) / 2;
1.910 + }
1.911 + else
1.912 + {//KErrNone: The number of the OR subexpressions has been successfully parsed. Increase the number, repeat the test.
1.913 + next += Abs(next - prev) / 2;
1.914 + }
1.915 + prev = tmp;
1.916 + }
1.917 + TheTest.Printf(_L("The test has succeeded with an expression with %d ORs\r\n"), prev);
1.918 + }
1.919 +
1.920 +void AssertSettingsTable()
1.921 + {
1.922 + TSqlScalarFullSelectQuery query(TheDb);
1.923 + TInt recCount = 0;
1.924 + TRAPD(err, recCount = query.SelectIntL(_L("SELECT COUNT(*) FROM symbian_settings")));
1.925 + TEST2(err, KErrNone);
1.926 + TEST2(recCount, 1);
1.927 + }
1.928 +
1.929 +/**
1.930 +@SYMTestCaseID SYSLIB-SQL-UT-4086
1.931 +@SYMTestCaseDesc RSqlBlobWriteStream::OpenL() and RSqlBlobReadStream::OpenL() - injection test
1.932 + The test attempts to open a blob stream with an attached database name containing
1.933 + "DELETE FROM symbian_settings" statement. The test should not delete the content of the
1.934 + "symbian_settings" table.
1.935 + The test also attempts to open a blob stream with a set of very long database/table/column names.
1.936 +@SYMTestPriority Medium
1.937 +@SYMTestActions RSqlBlobWriteStream::OpenL() and RSqlBlobReadStream::OpenL() - injection test
1.938 +@SYMTestExpectedResults Test must not fail
1.939 +@SYMREQ REQ5792
1.940 + REQ10410
1.941 + REQ10411
1.942 + REQ10418
1.943 +*/
1.944 +void BlobStreamInjectionTest()
1.945 + {
1.946 + (void)RSqlDatabase::Delete(KTestDbName1);
1.947 + TInt err = TheDb.Create(KTestDbName1);
1.948 + TEST2(err, KErrNone);
1.949 + err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Data BLOB)"));
1.950 + TEST2(err, 1);
1.951 + err = TheDb.Exec(_L("INSERT INTO A VALUES(1, x'11223344556677889900')"));
1.952 + TEST2(err, 1);
1.953 + _LIT(KAttachDb, "AttachDb");
1.954 + err = TheDb.Attach(KTestDbName1, KAttachDb);
1.955 + TEST2(err, KErrNone);
1.956 + //RSqlBlobWriteStream::OpenL() - attached database name injected
1.957 + RSqlBlobWriteStream strm1;
1.958 + TRAP(err, strm1.OpenL(TheDb, _L("A"), _L("Data"), 1, _L("Id;DELETE FROM symbian_settings;")));
1.959 + TEST(err != KErrNone);
1.960 + AssertSettingsTable();
1.961 + //RSqlBlobReadStream::OpenL() - attached database name injected
1.962 + RSqlBlobReadStream strm2;
1.963 + TRAP(err, strm2.OpenL(TheDb, _L("A"), _L("Data"), 1, _L("Id;DELETE FROM symbian_settings;")));
1.964 + TEST(err != KErrNone);
1.965 + AssertSettingsTable();
1.966 + //Attempt to open a write blob stream with a set of very long database/table/column names.
1.967 + TBuf<KMaxFileName + 10> longName;
1.968 + longName.SetLength(longName.MaxLength());
1.969 + RSqlBlobWriteStream strm3;
1.970 + TRAP(err, strm3.OpenL(TheDb, longName, longName, 1, longName));
1.971 + TEST(err != KErrNone);
1.972 + //Attempt to open a read blob stream with a set of very long database/table/column names.
1.973 + RSqlBlobReadStream strm4;
1.974 + TRAP(err, strm4.OpenL(TheDb, longName, longName, 1, longName));
1.975 + TEST(err != KErrNone);
1.976 + //Attempt to open a write blob stream with a set of KNullDesC database/table/column names.
1.977 + RSqlBlobWriteStream strm5;
1.978 + TRAP(err, strm5.OpenL(TheDb, KNullDesC, KNullDesC, 1, KNullDesC));
1.979 + TEST(err != KErrNone);
1.980 + //Attempt to open a read blob stream with a set of KNullDesC database/table/column names.
1.981 + RSqlBlobReadStream strm6;
1.982 + TRAP(err, strm6.OpenL(TheDb, KNullDesC, KNullDesC, 1, KNullDesC));
1.983 + TEST(err != KErrNone);
1.984 + //Attempt to open a read blob stream, where the blob column name is invalid and contains non-convertible characters.
1.985 + TBuf<3> invName;
1.986 + invName.SetLength(3);
1.987 + invName[0] = TChar(0xD800);
1.988 + invName[1] = TChar(0xFC00);
1.989 + invName[2] = TChar(0x0000);
1.990 + RSqlBlobReadStream strm7;
1.991 + TRAP(err, strm7.OpenL(TheDb, _L("A"), invName, 1, KNullDesC));
1.992 + TEST(err != KErrNone);
1.993 + //Attempt to open a read blob stream, where the table name is invalid and contains non-convertible characters.
1.994 + RSqlBlobReadStream strm8;
1.995 + TRAP(err, strm8.OpenL(TheDb, invName, _L("Data"), 1, KNullDesC));
1.996 + TEST(err != KErrNone);
1.997 + //Attempt to open a read blob stream, where the attached db name is invalid and contains non-convertible characters.
1.998 + RSqlBlobReadStream strm9;
1.999 + TRAP(err, strm9.OpenL(TheDb, _L("A"), _L("Data"), 1, invName));
1.1000 + TEST(err != KErrNone);
1.1001 + //
1.1002 + err = TheDb.Detach(KAttachDb);
1.1003 + TEST2(err, KErrNone);
1.1004 + TheDb.Close();
1.1005 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1006 + }
1.1007 +
1.1008 +/**
1.1009 +@SYMTestCaseID SYSLIB-SQL-UT-4087
1.1010 +@SYMTestCaseDesc Bound parameter values test.
1.1011 + The test verifies that bound parameters with big text/binary values retain their values after
1.1012 + the RSqlStatement::Reset() call. The old bound paramegter values can be used for the next
1.1013 + RSqlStatement::Exec() call.
1.1014 +@SYMTestActions Bound parameter values test.
1.1015 +@SYMTestExpectedResults Test must not fail
1.1016 +@SYMTestPriority High
1.1017 +@SYMREQ REQ5792
1.1018 +*/
1.1019 +void BoundParameterValuesTest()
1.1020 + {
1.1021 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1022 + TInt err = TheDb.Create(KTestDbName1);
1.1023 + TEST2(err, KErrNone);
1.1024 + err = TheDb.Exec(_L("CREATE TABLE A1(T1 TEXT, T2 TEXT)"));
1.1025 + TEST2(err, 1);
1.1026 + err = TheDb.Exec(_L("CREATE TABLE A2(T1 TEXT, T2 TEXT)"));
1.1027 + TEST2(err, 1);
1.1028 +
1.1029 + RSqlStatement stmt1, stmt2;
1.1030 + err = stmt1.Prepare(TheDb, _L("INSERT INTO A1 VALUES(:Prm1, :Prm2)"));
1.1031 + TEST2(err, KErrNone);
1.1032 + err = stmt2.Prepare(TheDb, _L("INSERT INTO A2 VALUES(:Prm1, :Prm2)"));
1.1033 + TEST2(err, KErrNone);
1.1034 + //Insert 1 record into table "A1". T2 = "ZZZZ.....".
1.1035 + TheBuf.SetLength(KBufLen - 100);
1.1036 + TheBuf.Fill(TChar('Z'));
1.1037 + err = stmt1.BindText(0, TheBuf);
1.1038 + TEST2(err, KErrNone);
1.1039 + err = stmt1.BindText(1, TheBuf);
1.1040 + TEST2(err, KErrNone);
1.1041 + err = stmt1.Exec();
1.1042 + TEST2(err, 1);
1.1043 + err = stmt1.Reset();
1.1044 + TEST2(err, KErrNone);
1.1045 + //Insert 1 record into table "A2". T2 = "AAAAAAA.....".
1.1046 + TheBuf.SetLength(KBufLen);
1.1047 + TheBuf.Fill(TChar('A'));
1.1048 + err = stmt2.BindText(0, TheBuf);
1.1049 + TEST2(err, KErrNone);
1.1050 + err = stmt2.BindText(1, TheBuf);
1.1051 + TEST2(err, KErrNone);
1.1052 + err = stmt2.Exec();
1.1053 + TEST2(err, 1);
1.1054 + err = stmt2.Reset();
1.1055 + TEST2(err, KErrNone);
1.1056 + //Insert 1 record into table "A1". T2 not set. T2 should be initialized with the previous bound value - "ZZZZZZ....".
1.1057 + //If the problem is not fixed, the SQLITE will attempt to access an already deleted region of memory.
1.1058 + TheBuf.SetLength(KBufLen - 100);
1.1059 + TheBuf.Fill(TChar('B'));
1.1060 + err = stmt1.BindText(0, TheBuf);
1.1061 + TEST2(err, KErrNone);
1.1062 + err = stmt1.Exec();
1.1063 + TEST2(err, 1);
1.1064 + err = stmt1.Reset();
1.1065 + TEST2(err, KErrNone);
1.1066 +
1.1067 + stmt2.Close();
1.1068 + stmt1.Close();
1.1069 +
1.1070 + //Check the inserted records.
1.1071 + TSqlScalarFullSelectQuery q(TheDb);
1.1072 + TRAP(err, q.SelectTextL(_L("SELECT T2 FROM A1 WHERE ROWID=1"), TheBuf));
1.1073 + TEST2(err, KErrNone);
1.1074 + TEST2(TheBuf.Length(), (KBufLen - 100));
1.1075 + for(TInt i1=0;i1<(KBufLen - 100);++i1)
1.1076 + {
1.1077 + TEST2(TheBuf[i1], TChar('Z'));
1.1078 + }
1.1079 + TRAP(err, q.SelectTextL(_L("SELECT T2 FROM A1 WHERE ROWID=2"), TheBuf));
1.1080 + TEST2(err, KErrNone);
1.1081 + TEST2(TheBuf.Length(), (KBufLen - 100));
1.1082 + for(TInt i2=0;i2<(KBufLen - 100);++i2)
1.1083 + {
1.1084 + TEST2(TheBuf[i2], TChar('Z'));
1.1085 + }
1.1086 +
1.1087 + TheDb.Close();
1.1088 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1089 + }
1.1090 +
1.1091 +/**
1.1092 +@SYMTestCaseID SYSLIB-SQL-UT-4076
1.1093 +@SYMTestCaseDesc Bound parameter values test.
1.1094 + The test verifies that when a RSqlParamWriteStream object is used for binding parameter values,
1.1095 + it is safe to erverse the order of RSqlParamWriteStream::Close() and RSqlStatement::Close() calls.
1.1096 +@SYMTestActions Bound parameter values test.
1.1097 +@SYMTestExpectedResults Test must not fail
1.1098 +@SYMTestPriority High
1.1099 +@SYMREQ REQ5792
1.1100 +*/
1.1101 +void BoundParameterValuesTest2()
1.1102 + {
1.1103 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1104 + TInt err = TheDb.Create(KTestDbName1);
1.1105 + TEST2(err, KErrNone);
1.1106 + err = TheDb.Exec(_L("CREATE TABLE A1(T1 TEXT, T2 TEXT)"));
1.1107 + TEST2(err, 1);
1.1108 +
1.1109 + RSqlStatement stmt;
1.1110 + err = stmt.Prepare(TheDb, _L("INSERT INTO A1 VALUES(:Prm1, :Prm2)"));
1.1111 + TEST2(err, KErrNone);
1.1112 + RSqlParamWriteStream strm;
1.1113 + err = strm.BindText(stmt, 0);
1.1114 + TEST2(err, KErrNone);
1.1115 + err = stmt.Exec();
1.1116 + TEST2(err, 1);
1.1117 + stmt.Close();
1.1118 + strm.Close();
1.1119 +
1.1120 + TheDb.Close();
1.1121 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1122 + }
1.1123 +
1.1124 +/**
1.1125 +@SYMTestCaseID SYSLIB-SQL-UT-4077
1.1126 +@SYMTestCaseDesc Bound parameter values test.
1.1127 + The test verifies that when a RSqlParamWriteStream object is used for binding parameter values,
1.1128 + it is possible to write the parameter value, then call RSqlParamWriteStream::Close() and finally -
1.1129 + RSqlStatement::Exec() to execute the operation (an INSERT statement). The test verifies that the record
1.1130 + has really been inserted and the column value is equal to the bound parameter value
1.1131 +@SYMTestActions Bound parameter values test.
1.1132 +@SYMTestExpectedResults Test must not fail
1.1133 +@SYMTestPriority High
1.1134 +@SYMREQ REQ5792
1.1135 +*/
1.1136 +void BoundParameterValuesTest3()
1.1137 + {
1.1138 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1139 + TInt err = TheDb.Create(KTestDbName1);
1.1140 + TEST2(err, KErrNone);
1.1141 + err = TheDb.Exec(_L("CREATE TABLE A1(T1 TEXT, T2 TEXT)"));
1.1142 + TEST2(err, 1);
1.1143 +
1.1144 + RSqlStatement stmt;
1.1145 + err = stmt.Prepare(TheDb, _L("INSERT INTO A1 VALUES(:Prm1, :Prm2)"));
1.1146 + TEST2(err, KErrNone);
1.1147 + RSqlParamWriteStream strm;
1.1148 + err = strm.BindText(stmt, 0);
1.1149 + TEST2(err, KErrNone);
1.1150 + _LIT(KText, "AAAA");
1.1151 + TRAP(err, strm.WriteL(KText));
1.1152 + TEST2(err, KErrNone);
1.1153 + TRAP(err, strm.CommitL());
1.1154 + TEST2(err, KErrNone);
1.1155 + strm.Close();
1.1156 + err = stmt.Exec();
1.1157 + TEST2(err, 1);
1.1158 + stmt.Close();
1.1159 +
1.1160 + TSqlScalarFullSelectQuery q(TheDb);
1.1161 + TRAP(err, q.SelectTextL(_L("SELECT T1 FROM A1"), TheBuf));
1.1162 + TEST2(err, KErrNone);
1.1163 + TEST(KText() == TheBuf);
1.1164 +
1.1165 + TheDb.Close();
1.1166 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1167 + }
1.1168 +
1.1169 +/**
1.1170 +@SYMTestCaseID SYSLIB-SQL-UT-4083
1.1171 +@SYMTestCaseDesc Bound parameter values test.
1.1172 + The test prepares an INSERT sql statement and inserts two records using streams to bind the parameter values.
1.1173 + For the second INSERT no parameter value is bound to the first parameter. The expectation is that the value
1.1174 + that has been bound for the first record will be used for the second record also.
1.1175 +@SYMTestActions Bound parameter values test.
1.1176 +@SYMTestExpectedResults Test must not fail
1.1177 +@SYMTestPriority High
1.1178 +@SYMREQ REQ5792
1.1179 +*/
1.1180 +void BoundParameterValuesTest4()
1.1181 + {
1.1182 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1183 + TInt err = TheDb.Create(KTestDbName1);
1.1184 + TEST2(err, KErrNone);
1.1185 + err = TheDb.Exec(_L("CREATE TABLE A1(T1 TEXT, T2 TEXT)"));
1.1186 + TEST2(err, 1);
1.1187 +
1.1188 + RSqlStatement stmt;
1.1189 + err = stmt.Prepare(TheDb, _L("INSERT INTO A1 VALUES(:Prm1, :Prm2)"));
1.1190 + TEST2(err, KErrNone);
1.1191 +
1.1192 + RSqlParamWriteStream strm;
1.1193 + err = strm.BindText(stmt, 0);
1.1194 + TEST2(err, KErrNone);
1.1195 + _LIT(KText1, "AAAA");
1.1196 + TRAP(err, strm.WriteL(KText1));
1.1197 + TEST2(err, KErrNone);
1.1198 + TRAP(err, strm.CommitL());
1.1199 + TEST2(err, KErrNone);
1.1200 + strm.Close();
1.1201 +
1.1202 + err = strm.BindText(stmt, 1);
1.1203 + TEST2(err, KErrNone);
1.1204 + _LIT(KText2, "BBBBBBBBBB");
1.1205 + TRAP(err, strm.WriteL(KText2));
1.1206 + TEST2(err, KErrNone);
1.1207 + TRAP(err, strm.CommitL());
1.1208 + TEST2(err, KErrNone);
1.1209 + strm.Close();
1.1210 +
1.1211 + err = stmt.Exec();
1.1212 + TEST2(err, 1);
1.1213 + err = stmt.Reset();
1.1214 + TEST2(err, KErrNone);
1.1215 +
1.1216 + err = strm.BindText(stmt, 1);
1.1217 + TEST2(err, KErrNone);
1.1218 + _LIT(KText3, "CCCCCCCCCCC");
1.1219 + TRAP(err, strm.WriteL(KText3));
1.1220 + TEST2(err, KErrNone);
1.1221 + TRAP(err, strm.CommitL());
1.1222 + TEST2(err, KErrNone);
1.1223 + strm.Close();
1.1224 +
1.1225 + err = stmt.Exec();
1.1226 + TEST2(err, 1);
1.1227 +
1.1228 + stmt.Close();
1.1229 +
1.1230 + TSqlScalarFullSelectQuery q(TheDb);
1.1231 + TRAP(err, q.SelectTextL(_L("SELECT T1 FROM A1 WHERE ROWID=1"), TheBuf));
1.1232 + TEST2(err, KErrNone);
1.1233 + TEST(KText1() == TheBuf);
1.1234 + TRAP(err, q.SelectTextL(_L("SELECT T2 FROM A1 WHERE ROWID=1"), TheBuf));
1.1235 + TEST2(err, KErrNone);
1.1236 + TEST(KText2() == TheBuf);
1.1237 +
1.1238 + TRAP(err, q.SelectTextL(_L("SELECT T1 FROM A1 WHERE ROWID=2"), TheBuf));
1.1239 + TEST2(err, KErrNone);
1.1240 + TEST(KText1() == TheBuf);
1.1241 + TRAP(err, q.SelectTextL(_L("SELECT T2 FROM A1 WHERE ROWID=2"), TheBuf));
1.1242 + TEST2(err, KErrNone);
1.1243 + TEST(KText3() == TheBuf);
1.1244 +
1.1245 + TheDb.Close();
1.1246 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1247 + }
1.1248 +
1.1249 +/**
1.1250 +@SYMTestCaseID SYSLIB-SQL-UT-4105
1.1251 +@SYMTestCaseDesc Bound parameter values test.
1.1252 + BC test. Even though it is correct to execute only one CommitL() on a parameter stream,
1.1253 + it should be possible to execute more than one CommitL(). It should be possible also
1.1254 + the stream data to be updated after the first commit operation and the expectation is that
1.1255 + the updated parameter data should be used for the column value.
1.1256 +@SYMTestActions Bound parameter values test.
1.1257 +@SYMTestExpectedResults Test must not fail
1.1258 +@SYMTestPriority High
1.1259 +@SYMREQ REQ5792
1.1260 +*/
1.1261 +void BoundParameterValuesTest5()
1.1262 + {
1.1263 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1264 + TInt err = TheDb.Create(KTestDbName1);
1.1265 + TEST2(err, KErrNone);
1.1266 + err = TheDb.Exec(_L("CREATE TABLE A1(T1 TEXT, T2 TEXT)"));
1.1267 + TEST2(err, 1);
1.1268 +
1.1269 + RSqlStatement stmt;
1.1270 + err = stmt.Prepare(TheDb, _L("INSERT INTO A1 VALUES(:Prm1, :Prm2)"));
1.1271 + TEST2(err, KErrNone);
1.1272 +
1.1273 + RSqlParamWriteStream strm;
1.1274 + err = strm.BindText(stmt, 0);
1.1275 + TEST2(err, KErrNone);
1.1276 + _LIT(KText1, "AAAA");
1.1277 + TRAP(err, strm.WriteL(KText1));
1.1278 + TEST2(err, KErrNone);
1.1279 + TRAP(err, strm.CommitL());
1.1280 + TEST2(err, KErrNone);
1.1281 + TRAP(err, strm.Sink()->SeekL(MStreamBuf::EWrite, EStreamBeginning, 0));
1.1282 + TEST2(err, KErrNone);
1.1283 + _LIT(KText2, "DTAA");
1.1284 + TRAP(err, strm.WriteL(KText2));
1.1285 + TEST2(err, KErrNone);
1.1286 + TRAP(err, strm.CommitL());
1.1287 + TEST2(err, KErrNone);
1.1288 + strm.Close();
1.1289 +
1.1290 + err = stmt.Exec();
1.1291 + TEST2(err, 1);
1.1292 +
1.1293 + stmt.Close();
1.1294 +
1.1295 + TSqlScalarFullSelectQuery q(TheDb);
1.1296 + TRAP(err, q.SelectTextL(_L("SELECT T1 FROM A1 WHERE ROWID=1"), TheBuf));
1.1297 + TEST2(err, KErrNone);
1.1298 + TEST(KText2() == TheBuf);
1.1299 +
1.1300 + TheDb.Close();
1.1301 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1302 + }
1.1303 +
1.1304 +void PrintConfig(TSqlResourceProfiler& aProfiler)
1.1305 + {
1.1306 + TBuf8<128> config;
1.1307 + if(aProfiler.Query(TSqlResourceProfiler::ESqlCounterConfig, config) == KErrNone)
1.1308 + {
1.1309 + _LIT(KCacheSize, "Cache size: %S pages\r\n");
1.1310 + _LIT(KPageSize, "Page size: %S bytes\r\n");
1.1311 + _LIT(KEncoding, "Encoding: %S\r\n");
1.1312 + _LIT(KDefaultSoftHeapLimit, "Default soft heap limit: %S Kb\r\n");
1.1313 + _LIT(KVacuumMode, "Vacuum mode: %S\r\n");
1.1314 +
1.1315 + TPtrC KText[] = {KCacheSize(), KPageSize(), KEncoding(), KDefaultSoftHeapLimit(), KVacuumMode()};
1.1316 +
1.1317 + for(TInt i=0;i<config.Length();++i)
1.1318 + {
1.1319 + if(config[i] == TChar(';'))
1.1320 + {
1.1321 + config[i] = TChar(' ');
1.1322 + }
1.1323 + }
1.1324 + TInt idx = 0;
1.1325 + TLex8 lex(config);
1.1326 + while (!lex.Eos() && idx < (sizeof(KText)/sizeof(KText[0])))
1.1327 + {
1.1328 + TPtrC8 num8 = lex.NextToken();
1.1329 + TBuf<20> num;
1.1330 + num.Copy(num8);
1.1331 + TheTest.Printf(KText[idx], &num);
1.1332 + ++idx;
1.1333 + }
1.1334 + }
1.1335 + }
1.1336 +
1.1337 +void PrintFileIo(TSqlResourceProfiler& aProfiler)
1.1338 + {
1.1339 + TBuf8<300> countersValues;
1.1340 + if(aProfiler.Query(TSqlResourceProfiler::ESqlCounterFileIO, countersValues) == KErrNone)
1.1341 + {
1.1342 + TheTest.Printf(_L("=========================\r\n"));
1.1343 + _LIT(KFileCreate, "File Create");
1.1344 + _LIT(KFileOpen, "File Open");
1.1345 + _LIT(KFileClose, "File Close");
1.1346 + _LIT(KFileDelete, "File Delete");
1.1347 + _LIT(KFileRead, "File Read");
1.1348 + _LIT(KFileWrite, "File Write");
1.1349 + _LIT(KFileSeek, "File Seek");
1.1350 + _LIT(KFileSize, "File Size");
1.1351 + _LIT(KFileSetSize, "File SetSize");
1.1352 + _LIT(KFileSync, "File Sync");
1.1353 + _LIT(KFileDrive, "File Drive");
1.1354 + _LIT(KFileAdopt, "File Adopt");
1.1355 + _LIT(KFsClose, "Fs Close");
1.1356 + _LIT(KFsConnect, "Fs Connect");
1.1357 + _LIT(KFsGetSystemDrive, "Fs GetSystemDrive");
1.1358 + _LIT(KFsCreatePrivatePath, "Fs CreatePrivatePath");
1.1359 + _LIT(KFsPrivatePath, "Fs PrivatePath");
1.1360 + _LIT(KFsVolumeIoParam, "Fs VolumeIoParam");
1.1361 + _LIT(KFsEntry, "Fs Entry");
1.1362 + _LIT(KFsAtt, "Fs Att");
1.1363 + _LIT(KFileCreateTemp, "File CreateTemp");
1.1364 + _LIT(KFileAttach, "File Attach");
1.1365 + _LIT(KBytesWritten, "File Bytes Written");
1.1366 + _LIT(KBytesRead, "File Bytes Read");
1.1367 + TPtrC KText[] =
1.1368 + {
1.1369 + KFileCreate(), KFileOpen(), KFileClose(), KFileDelete(), KFileRead(), KFileWrite(), KFileSeek(), KFileSize(),
1.1370 + KFileSetSize(), KFileSync(), KFileDrive(), KFileAdopt(), KFsClose(), KFsConnect(), KFsGetSystemDrive(),
1.1371 + KFsCreatePrivatePath(), KFsPrivatePath(), KFsVolumeIoParam(), KFsEntry(), KFsAtt(), KFileCreateTemp(),
1.1372 + KFileAttach(), KBytesWritten(), KBytesRead()
1.1373 + };
1.1374 +
1.1375 + for(TInt i=0;i<countersValues.Length();++i)
1.1376 + {
1.1377 + if(countersValues[i] == TChar(';'))
1.1378 + {
1.1379 + countersValues[i] = TChar(' ');
1.1380 + }
1.1381 + }
1.1382 + TInt idx = 0;
1.1383 + TLex8 lex(countersValues);
1.1384 + while (!lex.Eos() && idx < (sizeof(KText)/sizeof(KText[0])))
1.1385 + {
1.1386 + TPtrC8 num8 = lex.NextToken();
1.1387 + TBuf<20> num;
1.1388 + num.Copy(num8);
1.1389 + TheTest.Printf(_L("==Operation %S, count %S\r\n"), &KText[idx], &num);
1.1390 + ++idx;
1.1391 + }
1.1392 + }
1.1393 + }
1.1394 +
1.1395 +void PrintOsCall(TSqlResourceProfiler& aProfiler)
1.1396 + {
1.1397 + TBuf8<300> countersValues;
1.1398 + if(aProfiler.Query(TSqlResourceProfiler::ESqlCounterOsCall, countersValues) == KErrNone)
1.1399 + {
1.1400 + TheTest.Printf(_L("=========================\r\n"));
1.1401 + _LIT(KEOsFileClose, "FileClose");
1.1402 + _LIT(KEOsFileRead, "FileRead");
1.1403 + _LIT(KEOsFileWrite, "FileWrite");
1.1404 + _LIT(KEOsFileTruncate, "FileTruncate");
1.1405 + _LIT(KEOsFileSync, "FileSync");
1.1406 + _LIT(KEOsFileFileSize, "FileSize");
1.1407 + _LIT(KEOsFileLock, "FileLock");
1.1408 + _LIT(KEOsFileUnlock, "FileUnlock");
1.1409 + _LIT(KEOsFileCheckReservedLock, "FileCheckReservedLock");
1.1410 + _LIT(KEOsFileFileControl, "FileIoControl");
1.1411 + _LIT(KEOsFileSectorSize, "FileSectorSize");
1.1412 + _LIT(KEOsFileDeviceCharacteristics, "FileDeviceCharacteristics");
1.1413 + _LIT(KEOsVfsOpen, "VfsOpen");
1.1414 + _LIT(KEOsVfsDelete, "VfsDelete");
1.1415 + _LIT(KEOsVfsAccess, "VfsAccess");
1.1416 + _LIT(KEOsVfsFullPathName, "VfsFullPathName");
1.1417 + _LIT(KEOsVfsRandomness, "VfsRandomnes");
1.1418 + _LIT(KEOsVfsSleep, "VfsSleep");
1.1419 + _LIT(KEOsVfsCurrentTime, "VfsCurrentTime");
1.1420 + _LIT(KEOsVfsGetLastError, "VfsGetLastError");
1.1421 + TPtrC KText[] =
1.1422 + {
1.1423 + KEOsFileClose(), KEOsFileRead(), KEOsFileWrite(), KEOsFileTruncate(), KEOsFileSync(),
1.1424 + KEOsFileFileSize(), KEOsFileLock(), KEOsFileUnlock(), KEOsFileCheckReservedLock(), KEOsFileFileControl(),
1.1425 + KEOsFileSectorSize(), KEOsFileDeviceCharacteristics(),
1.1426 + KEOsVfsOpen(), KEOsVfsDelete(), KEOsVfsAccess(), KEOsVfsFullPathName(), KEOsVfsRandomness(), KEOsVfsSleep(),
1.1427 + KEOsVfsCurrentTime(), KEOsVfsGetLastError()};
1.1428 +
1.1429 + for(TInt i=0;i<countersValues.Length();++i)
1.1430 + {
1.1431 + if(countersValues[i] == TChar(';'))
1.1432 + {
1.1433 + countersValues[i] = TChar(' ');
1.1434 + }
1.1435 + }
1.1436 + TInt idx = 0;
1.1437 + TLex8 lex(countersValues);
1.1438 + while (!lex.Eos() && idx < (sizeof(KText)/sizeof(KText[0])))
1.1439 + {
1.1440 + TPtrC8 num8 = lex.NextToken();
1.1441 + TBuf<20> num;
1.1442 + num.Copy(num8);
1.1443 + TheTest.Printf(_L("==Operation %S, count %S\r\n"), &KText[idx], &num);
1.1444 + ++idx;
1.1445 + }
1.1446 + }
1.1447 + }
1.1448 +
1.1449 +void PrintOsCallTime(TSqlResourceProfiler& aProfiler)
1.1450 + {
1.1451 + TBuf8<300> callTimes;
1.1452 + if(aProfiler.Query(TSqlResourceProfiler::ESqlCounterOsCallTime, callTimes) == KErrNone)
1.1453 + {
1.1454 + TheTest.Printf(_L("=========================\r\n"));
1.1455 + _LIT(KEOsFileClose, "FileClose");
1.1456 + _LIT(KEOsFileRead, "FileRead");
1.1457 + _LIT(KEOsFileWrite, "FileWrite");
1.1458 + _LIT(KEOsFileTruncate, "FileTruncate");
1.1459 + _LIT(KEOsFileSync, "FileSync");
1.1460 + _LIT(KEOsFileFileSize, "FileSize");
1.1461 + _LIT(KEOsFileLock, "FileLock");
1.1462 + _LIT(KEOsFileUnlock, "FileUnlock");
1.1463 + _LIT(KEOsFileCheckReservedLock, "FileCheckReservedLock");
1.1464 + _LIT(KEOsFileFileControl, "FileIoControl");
1.1465 + _LIT(KEOsFileSectorSize, "FileSectorSize");
1.1466 + _LIT(KEOsFileDeviceCharacteristics, "FileDeviceCharacteristics");
1.1467 + _LIT(KEOsVfsOpen, "VfsOpen");
1.1468 + _LIT(KEOsVfsDelete, "VfsDelete");
1.1469 + _LIT(KEOsVfsAccess, "VfsAccess");
1.1470 + _LIT(KEOsVfsFullPathName, "VfsFullPathName");
1.1471 + _LIT(KEOsVfsRandomness, "VfsRandomnes");
1.1472 + _LIT(KEOsVfsSleep, "VfsSleep");
1.1473 + _LIT(KEOsVfsCurrentTime, "VfsCurrentTime");
1.1474 + _LIT(KEOsVfsGetLastError, "VfsGetLastError");
1.1475 + TPtrC KText[] =
1.1476 + {
1.1477 + KEOsFileClose(), KEOsFileRead(), KEOsFileWrite(), KEOsFileTruncate(), KEOsFileSync(),
1.1478 + KEOsFileFileSize(), KEOsFileLock(), KEOsFileUnlock(), KEOsFileCheckReservedLock(), KEOsFileFileControl(),
1.1479 + KEOsFileSectorSize(), KEOsFileDeviceCharacteristics(),
1.1480 + KEOsVfsOpen(), KEOsVfsDelete(), KEOsVfsAccess(), KEOsVfsFullPathName(), KEOsVfsRandomness(), KEOsVfsSleep(),
1.1481 + KEOsVfsCurrentTime(), KEOsVfsGetLastError()};
1.1482 +
1.1483 + for(TInt i=0;i<callTimes.Length();++i)
1.1484 + {
1.1485 + if(callTimes[i] == TChar(';'))
1.1486 + {
1.1487 + callTimes[i] = TChar(' ');
1.1488 + }
1.1489 + }
1.1490 + TInt idx = 0;
1.1491 + TLex8 lex(callTimes);
1.1492 + while (!lex.Eos() && idx < (sizeof(KText)/sizeof(KText[0])))
1.1493 + {
1.1494 + TPtrC8 num8 = lex.NextToken();
1.1495 + TBuf<20> num;
1.1496 + num.Copy(num8);
1.1497 + TheTest.Printf(_L("==Operation %S, time %S us\r\n"), &KText[idx], &num);
1.1498 + ++idx;
1.1499 + }
1.1500 + }
1.1501 + }
1.1502 +
1.1503 +void PrintIpc(TSqlResourceProfiler& aProfiler)
1.1504 + {
1.1505 + TBuf8<300> countersValues;
1.1506 + if(aProfiler.Query(TSqlResourceProfiler::ESqlCounterIpc, countersValues) == KErrNone)
1.1507 + {
1.1508 + TheTest.Printf(_L("=========================\r\n"));
1.1509 + _LIT(KIpcRq, "IPC requests");
1.1510 + _LIT(KIpcRead, "IPC read");
1.1511 + _LIT(KIpcWrite, "IPC write");
1.1512 + _LIT(KIpcReadBytes, "IPC read bytes");
1.1513 + _LIT(KIpcWriteBytes, "IPC write bytes");
1.1514 + TPtrC KText[] =
1.1515 + {
1.1516 + KIpcRq(), KIpcRead(), KIpcWrite(), KIpcReadBytes(), KIpcWriteBytes()
1.1517 + };
1.1518 +
1.1519 + for(TInt i=0;i<countersValues.Length();++i)
1.1520 + {
1.1521 + if(countersValues[i] == TChar(';'))
1.1522 + {
1.1523 + countersValues[i] = TChar(' ');
1.1524 + }
1.1525 + }
1.1526 + TInt idx = 0;
1.1527 + TLex8 lex(countersValues);
1.1528 + while (!lex.Eos() && idx < (sizeof(KText)/sizeof(KText[0])))
1.1529 + {
1.1530 + TPtrC8 num8 = lex.NextToken();
1.1531 + TBuf<20> num;
1.1532 + num.Copy(num8);
1.1533 + TheTest.Printf(_L("==Operation %S, count %S\r\n"), &KText[idx], &num);
1.1534 + ++idx;
1.1535 + }
1.1536 + }
1.1537 + }
1.1538 +
1.1539 +void PrintMemory(TSqlResourceProfiler& aProfiler)
1.1540 + {
1.1541 + TBuf8<300> countersValues;
1.1542 + if(aProfiler.Query(TSqlResourceProfiler::ESqlCounterMemory, countersValues) == KErrNone)
1.1543 + {
1.1544 + TheTest.Printf(_L("=========================\r\n"));
1.1545 + _LIT(KMemorySrvAllocatedCnt, "Server allocated cnt");
1.1546 + _LIT(KMemorySrvAllocatedSize, "Server allocated size");
1.1547 + _LIT(KMemorySrvFreeSpace, "Server free space");
1.1548 + _LIT(KMemorySrvLargestBlockSize, "Server larges block size");
1.1549 + _LIT(KMemorySQLiteAllocatedCnt, "SQLite allocated cnt");
1.1550 + _LIT(KMemorySQLiteReallocatedCnt, "SQLite reallocated cnt");
1.1551 + _LIT(KMemorySQLiteFreedCnt, "SQLite freed cnt");
1.1552 + _LIT(KMemorySQLiteAllocatedBytes, "SQLite allocated bytes");
1.1553 + _LIT(KMemorySQLiteFreedBytes, "SQLite freed bytes");
1.1554 + _LIT(KMemorySQLiteAllocTime, "SQLite alloc, us");
1.1555 + _LIT(KMemorySQLiteReallocTime, "SQLite realloc, us");
1.1556 + _LIT(KMemorySQLiteFreeTime, "SQLite free, us");
1.1557 + TPtrC KText[] =
1.1558 + {
1.1559 + KMemorySrvAllocatedCnt(), KMemorySrvAllocatedSize(), KMemorySrvFreeSpace(), KMemorySrvLargestBlockSize(),
1.1560 + KMemorySQLiteAllocatedCnt(), KMemorySQLiteReallocatedCnt(), KMemorySQLiteFreedCnt(),
1.1561 + KMemorySQLiteAllocatedBytes(), KMemorySQLiteFreedBytes(),
1.1562 + KMemorySQLiteAllocTime(), KMemorySQLiteReallocTime(), KMemorySQLiteFreeTime()
1.1563 + };
1.1564 +
1.1565 + for(TInt i=0;i<countersValues.Length();++i)
1.1566 + {
1.1567 + if(countersValues[i] == TChar(';'))
1.1568 + {
1.1569 + countersValues[i] = TChar(' ');
1.1570 + }
1.1571 + }
1.1572 + TInt idx = 0;
1.1573 + TLex8 lex(countersValues);
1.1574 + while (!lex.Eos() && idx < (sizeof(KText)/sizeof(KText[0])))
1.1575 + {
1.1576 + TPtrC8 num8 = lex.NextToken();
1.1577 + TBuf<20> num;
1.1578 + num.Copy(num8);
1.1579 + TheTest.Printf(_L("==%S=%S\r\n"), &KText[idx], &num);
1.1580 + ++idx;
1.1581 + }
1.1582 + }
1.1583 + }
1.1584 +
1.1585 +/**
1.1586 +@SYMTestCaseID SYSLIB-SQL-UT-4088
1.1587 +@SYMTestCaseDesc TSqlResouceProfiler - file I/O and configuration test.
1.1588 + The test enables the file I/O profiling and then executes a simple INSERT statement
1.1589 + and prints out the profiling results. The test also prints the current database configuration.
1.1590 +@SYMTestActions TSqlResouceProfiler - file I/O and configuration test.
1.1591 +@SYMTestExpectedResults Test must not fail
1.1592 +@SYMTestPriority Medium
1.1593 +@SYMREQ REQ5792
1.1594 +*/
1.1595 +void ProfilerTest()
1.1596 + {
1.1597 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1598 + TInt err = TheDb.Create(KTestDbName1);
1.1599 + TEST2(err, KErrNone);
1.1600 + err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER, T TEXT)"));
1.1601 + TEST2(err, 1);
1.1602 +
1.1603 + TSqlResourceProfiler profiler(TheDb);
1.1604 +
1.1605 + PrintConfig(profiler);
1.1606 +
1.1607 + (void)profiler.Start(TSqlResourceProfiler::ESqlCounterFileIO);
1.1608 + (void)profiler.Start(TSqlResourceProfiler::ESqlCounterOsCall);
1.1609 + (void)profiler.Start(TSqlResourceProfiler::ESqlCounterOsCallTime);
1.1610 + (void)profiler.Start(TSqlResourceProfiler::ESqlCounterIpc);
1.1611 + (void)profiler.Start(TSqlResourceProfiler::ESqlCounterMemory);
1.1612 +
1.1613 + (void)profiler.Reset(TSqlResourceProfiler::ESqlCounterFileIO);
1.1614 + (void)profiler.Reset(TSqlResourceProfiler::ESqlCounterOsCall);
1.1615 + (void)profiler.Reset(TSqlResourceProfiler::ESqlCounterOsCallTime);
1.1616 + (void)profiler.Reset(TSqlResourceProfiler::ESqlCounterIpc);
1.1617 + (void)profiler.Reset(TSqlResourceProfiler::ESqlCounterMemory);
1.1618 +
1.1619 + err = TheDb.Exec(_L("INSERT INTO A VALUES(1, 'ABCDEEFGH')"));
1.1620 + TEST2(err, 1);
1.1621 +
1.1622 + PrintFileIo(profiler);
1.1623 + PrintOsCall(profiler);
1.1624 + PrintOsCallTime(profiler);
1.1625 + PrintIpc(profiler);
1.1626 + PrintMemory(profiler);
1.1627 +
1.1628 + (void)profiler.Stop(TSqlResourceProfiler::ESqlCounterIpc);
1.1629 + (void)profiler.Stop(TSqlResourceProfiler::ESqlCounterOsCallTime);
1.1630 + (void)profiler.Stop(TSqlResourceProfiler::ESqlCounterOsCall);
1.1631 + (void)profiler.Stop(TSqlResourceProfiler::ESqlCounterFileIO);
1.1632 + (void)profiler.Stop(TSqlResourceProfiler::ESqlCounterMemory);
1.1633 +
1.1634 + TheDb.Close();
1.1635 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1636 + }
1.1637 +
1.1638 +TInt CompoundSelectStackOverflowThreadFunc(void* aData)
1.1639 + {
1.1640 + CTrapCleanup* tc = CTrapCleanup::New();
1.1641 + TEST(tc != NULL);
1.1642 +
1.1643 + User::SetJustInTime(EFalse); // disable debugger panic handling
1.1644 +
1.1645 + TInt* cntptr = reinterpret_cast<TInt*> (aData);
1.1646 + TEST(cntptr != NULL);
1.1647 + const TInt KSelectStmtCnt = *cntptr;
1.1648 +
1.1649 + HBufC* buf = HBufC::New(KSelectStmtCnt * 25 + 32);//enough for the "SELECT I FROM A UNION SELECT I FROM A..." string
1.1650 + if(!buf)
1.1651 + {
1.1652 + delete tc;
1.1653 + return KErrNoMemory;
1.1654 + }
1.1655 + TPtr sql = buf->Des();
1.1656 +
1.1657 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1658 + RSqlDatabase db;
1.1659 + TInt err = db.Create(KTestDbName1);
1.1660 + if(err != KErrNone)
1.1661 + {
1.1662 + delete buf;
1.1663 + return err;
1.1664 + }
1.1665 + err = db.Exec(_L("CREATE TABLE A(I INTEGER);INSERT INTO A VALUES(1);"));
1.1666 + if(err < 1)
1.1667 + {
1.1668 + delete buf;
1.1669 + return err;
1.1670 + }
1.1671 +
1.1672 + for(TInt i=0;i<KSelectStmtCnt;i++)
1.1673 + {
1.1674 + sql.Append(_L("SELECT I FROM A UNION "));
1.1675 + }
1.1676 + sql.SetLength(sql.Length() - 7);
1.1677 + RSqlStatement stmt;
1.1678 + err = stmt.Prepare(db, sql);//This call can crash the server with "stack overflow"
1.1679 + stmt.Close();
1.1680 +
1.1681 + db.Close();
1.1682 + delete buf;
1.1683 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1684 + return err;
1.1685 + }
1.1686 +
1.1687 +void CompoundSelectStackOverflowTest()
1.1688 + {
1.1689 + const TInt KMaxSelectStmtCnt = 64;
1.1690 + for(TInt cnt=KMaxSelectStmtCnt;cnt>0;--cnt)
1.1691 + {
1.1692 + TheTest.Printf(_L("SELECT statement count: %d\r\n"), cnt);
1.1693 + RThread thread;
1.1694 + _LIT(KThreadName,"S2Thread"); //stack minheap maxheap
1.1695 + TInt err = thread.Create(KThreadName, &CompoundSelectStackOverflowThreadFunc, 0x2000, 0x00100000, 0x02000000, &cnt);
1.1696 + TEST2(err, KErrNone);
1.1697 +
1.1698 + TRequestStatus status;
1.1699 + thread.Logon(status);
1.1700 + TEST2(status.Int(), KRequestPending);
1.1701 + thread.Resume();
1.1702 + User::WaitForRequest(status);
1.1703 + User::SetJustInTime(ETrue); // enable debugger panic handling
1.1704 +
1.1705 + TInt exitType = thread.ExitType();
1.1706 + const TDesC& exitCategory = thread.ExitCategory();
1.1707 + TInt exitReason = thread.ExitReason();
1.1708 + TheTest.Printf(_L("Exit type: %d, exit reason: %d, exit category: %S\r\n"), exitType, exitReason, &exitCategory);
1.1709 + thread.Close();
1.1710 + if(exitReason == KErrServerTerminated) //SQL server --> stack overflow
1.1711 + {
1.1712 + continue;
1.1713 + }
1.1714 + TEST2(exitReason, KErrNone);
1.1715 + TheTest.Printf(_L(" The test has succeeded with SELECT statement count=%d\r\n"), cnt);
1.1716 + break;
1.1717 + }
1.1718 + }
1.1719 +
1.1720 +/**
1.1721 +@SYMTestCaseID PDS-SQL-CT-4198
1.1722 +@SYMTestCaseDesc Expired SQL statements test.
1.1723 + The test creates a database and opens 2 connections to that database.
1.1724 + Connection 2 prepares couple of SELECT and INSERT statements (8-bit and 16-bit).
1.1725 + Then connection 1 renames the table used in the already prepared statements.
1.1726 + Connection 2 attempts to execute the prepared statements. The execution should fail
1.1727 + because the database schema has changed after they were prepared.
1.1728 +@SYMTestActions Expired SQL statements test.
1.1729 +@SYMTestExpectedResults Test must not fail
1.1730 +@SYMTestPriority High
1.1731 +@SYMDEF DEF145236
1.1732 +*/
1.1733 +void ExpiredStmtTest()
1.1734 + {
1.1735 + (void)RSqlDatabase::Delete(KTestDbName1);
1.1736 + //Create a database and create db connection 1.
1.1737 + TInt err = TheDb.Create(KTestDbName1);
1.1738 + TEST2(err, KErrNone);
1.1739 + err = TheDb.Exec(_L("CREATE TABLE A(C1 INTEGER)"));
1.1740 + TEST(err >= 0);
1.1741 + err = TheDb.Exec(_L("INSERT INTO A(C1) VALUES(1)"));
1.1742 + TEST2(err, 1);
1.1743 +
1.1744 + //Create db connection 2 to the same database, as db connection 1.
1.1745 + RSqlDatabase db2;
1.1746 + err = db2.Open(KTestDbName1);
1.1747 + TEST2(err, KErrNone);
1.1748 +
1.1749 + //Db connection 2. Prepare SELECT and INSERT, 8-bit and 16-bit statements.
1.1750 + RSqlStatement stmt1, stmt2, stmt3, stmt4;
1.1751 + err = stmt1.Prepare(db2, _L("SELECT * FROM A"));
1.1752 + TEST2(err, KErrNone);
1.1753 + err = stmt2.Prepare(db2, _L8("SELECT * FROM A"));
1.1754 + TEST2(err, KErrNone);
1.1755 + err = stmt3.Prepare(db2, _L("INSERT INTO A(C1) VALUES(2)"));
1.1756 + TEST2(err, KErrNone);
1.1757 + err = stmt4.Prepare(db2, _L8("INSERT INTO A(C1) VALUES(3)"));
1.1758 + TEST2(err, KErrNone);
1.1759 +
1.1760 + //Modify the A table structure from the other connection
1.1761 + //err = TheDb.Exec(_L("ALTER TABLE A ADD C2 INTEGER"));
1.1762 + err = TheDb.Exec(_L("ALTER TABLE A RENAME TO B"));
1.1763 + TEST(err >= 0);
1.1764 +
1.1765 + //Try to execute the already prepared statements.
1.1766 + err = stmt1.Next();
1.1767 + TEST2(err, KSqlErrSchema);
1.1768 + err = stmt1.Next();
1.1769 + TEST(err != KSqlAtRow);
1.1770 + err = stmt2.Next();
1.1771 + TEST(err != KSqlAtRow);
1.1772 + err = stmt3.Exec();
1.1773 + TEST(err < 0);
1.1774 + err = stmt4.Exec();
1.1775 + TEST(err < 0);
1.1776 + //
1.1777 + stmt4.Close();
1.1778 + stmt3.Close();
1.1779 + stmt2.Close();
1.1780 + stmt1.Close();
1.1781 + db2.Close();
1.1782 + TheDb.Close();
1.1783 + err = RSqlDatabase::Delete(KTestDbName1);
1.1784 + TEST2(err, KErrNone);
1.1785 + }
1.1786 +
1.1787 +void DoTestsL()
1.1788 + {
1.1789 + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3512 RSqlStatement::ColumnCount() tests "));
1.1790 + ColumnCountTest();
1.1791 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3513 RSqlStatement::ColumnCount(), non-SELECT tests "));
1.1792 + ColumnCountTest2();
1.1793 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3514 RSqlStatement::DeclaredColumnType() tests "));
1.1794 + DeclaredColumnTypeTest();
1.1795 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4017 RSqlStatement::ColumnName() tests"));
1.1796 + ColumnNameTest();
1.1797 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4018 RSqlStatement::ParameterName() and RSqlStatement::ParamName() tests"));
1.1798 + ParamNameTest();
1.1799 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4006 DEF115300 - SqlSrv.EXE::!SQL Server when preparing invalid LEFT JOIN sql query "));
1.1800 + DEF115300();
1.1801 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4007 DEF115331 - SQL, bad code coverage for db reindexing if default collation has changed "));
1.1802 + DEF115331L();
1.1803 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4079 RSqlDatabase::Create() and RSqlDatabase::Open() - injection tests"));
1.1804 + InjectionTest();
1.1805 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4038 Two connections test"));
1.1806 + TwoConnectionsTest();
1.1807 + TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4080 SQL server stack overflow test"));
1.1808 + SqlServerStackOverflowTest();
1.1809 + TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4086 RSqlBlobWriteStream/RSqlBlobReadStream injection test"));
1.1810 + BlobStreamInjectionTest();
1.1811 + TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4087 Bound parameter values test 1"));
1.1812 + BoundParameterValuesTest();
1.1813 + TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4076 Bound parameter values test 2"));
1.1814 + BoundParameterValuesTest2();
1.1815 + TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4077 Bound parameter values test 3"));
1.1816 + BoundParameterValuesTest3();
1.1817 + TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4083 Bound parameter values test 4"));
1.1818 + BoundParameterValuesTest4();
1.1819 + TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4105 Bound parameter values test 5"));
1.1820 + BoundParameterValuesTest5();
1.1821 + TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4088 TSqlResourceProfiler - file I/O and configuration test"));
1.1822 + ProfilerTest();
1.1823 + TheTest.Next( _L(" Compound SELECT, stack overflow test"));
1.1824 + CompoundSelectStackOverflowTest();
1.1825 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4198 Expired statements test"));
1.1826 + ExpiredStmtTest();
1.1827 + }
1.1828 +
1.1829 +TInt E32Main()
1.1830 + {
1.1831 + TheTest.Title();
1.1832 +
1.1833 + CTrapCleanup* tc = CTrapCleanup::New();
1.1834 +
1.1835 + __UHEAP_MARK;
1.1836 +
1.1837 + CreateTestEnv();
1.1838 + DeleteTestFiles();
1.1839 + TRAPD(err, DoTestsL());
1.1840 + DeleteTestFiles();
1.1841 + TEST2(err, KErrNone);
1.1842 +
1.1843 + __UHEAP_MARKEND;
1.1844 +
1.1845 + TheTest.End();
1.1846 + TheTest.Close();
1.1847 +
1.1848 + delete tc;
1.1849 +
1.1850 + User::Heap().Check();
1.1851 + return KErrNone;
1.1852 + }