1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqlscalarfullselect.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,435 @@
1.4 +// Copyright (c) 2006-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 <bautils.h>
1.21 +#include <s32strm.h>
1.22 +#include <e32math.h>
1.23 +#include <sqldb.h>
1.24 +
1.25 +///////////////////////////////////////////////////////////////////////////////////////
1.26 +
1.27 +static RFs TheFs;
1.28 +RTest TheTest(_L("t_sqlscalarfullselect test"));
1.29 +
1.30 +_LIT(KTestDir, "c:\\test\\");
1.31 +_LIT(KTestDatabase1, "c:\\test\\t_sqlscalarfullselect.db");
1.32 +
1.33 +///////////////////////////////////////////////////////////////////////////////////////
1.34 +
1.35 +//Deletes all created test files.
1.36 +void DeleteTestFiles()
1.37 + {
1.38 + (void)RSqlDatabase::Delete(KTestDatabase1);
1.39 + }
1.40 +
1.41 +///////////////////////////////////////////////////////////////////////////////////////
1.42 +///////////////////////////////////////////////////////////////////////////////////////
1.43 +//Test macros and functions
1.44 +void Check1(TInt64 aValue, TInt aLine)
1.45 + {
1.46 + if(!aValue)
1.47 + {
1.48 + DeleteTestFiles();
1.49 + RDebug::Print(_L("*** Line %d\r\n"), aLine);
1.50 + TheTest(EFalse, aLine);
1.51 + }
1.52 + }
1.53 +void Check2(TInt64 aValue, TInt64 aExpected, TInt aLine)
1.54 + {
1.55 + if(aValue != aExpected)
1.56 + {
1.57 + DeleteTestFiles();
1.58 + RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);
1.59 + TheTest(EFalse, aLine);
1.60 + }
1.61 + }
1.62 +#define TEST(arg) ::Check1((arg), __LINE__)
1.63 +#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)
1.64 +
1.65 +///////////////////////////////////////////////////////////////////////////////////////
1.66 +
1.67 +//Creates file session instance and the test directory
1.68 +void CreateTestEnv()
1.69 + {
1.70 + TInt err = TheFs.Connect();
1.71 + TEST2(err, KErrNone);
1.72 +
1.73 + err = TheFs.MkDir(KTestDir);
1.74 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.75 + }
1.76 +
1.77 +void CreateTestDbLC(RSqlDatabase& aDb)
1.78 + {
1.79 + CleanupClosePushL(aDb);
1.80 + TInt rc = aDb.Create(KTestDatabase1);
1.81 + TEST2(rc, KErrNone);
1.82 + rc = aDb.Exec(_L("CREATE TABLE A(F1 INTEGER, F2 INTEGER, F3 FLOAT, F4 TEXT, F5 BLOB)"));
1.83 + TEST(rc >= 0);
1.84 + rc = aDb.Exec(_L("INSERT INTO A(F1, F2, F3, F4, F5) VALUES(1, 10000000000, 2.54, 'NAME1234567890', NULL)"));
1.85 + TEST2(rc, 1);
1.86 + rc = aDb.Exec(_L("INSERT INTO A(F1, F2, F3, F4) VALUES(2, 200, -1.11, 'ADDRESS')"));
1.87 + TEST2(rc, 1);
1.88 + RSqlStatement stmt;
1.89 + CleanupClosePushL(stmt);
1.90 + rc = stmt.Prepare(aDb, _L("UPDATE A SET F5=:P WHERE F1 = 2"));
1.91 + TEST2(rc, KErrNone);
1.92 + RSqlParamWriteStream strm;
1.93 + CleanupClosePushL(strm);
1.94 + rc = strm.BindBinary(stmt, 0);
1.95 + TEST2(rc, KErrNone);
1.96 + for(TInt i=0;i<100;++i)
1.97 + {
1.98 + strm << static_cast <TUint8> (i);
1.99 + }
1.100 + strm.CommitL();
1.101 + rc = stmt.Exec();
1.102 + TEST2(rc, 1);
1.103 + CleanupStack::PopAndDestroy(&strm);
1.104 + CleanupStack::PopAndDestroy(&stmt);
1.105 + }
1.106 +
1.107 +void DestroyTestDb(RSqlDatabase& aDb)
1.108 + {
1.109 + CleanupStack::PopAndDestroy(&aDb);
1.110 + TInt err = RSqlDatabase::Delete(KTestDatabase1);
1.111 + TEST2(err, KErrNone);
1.112 + }
1.113 +
1.114 +/**
1.115 +@SYMTestCaseID SYSLIB-SQL-CT-1809
1.116 +@SYMTestCaseDesc A test database is created, test table created in the database with integer, 64-bit
1.117 + integer, float, text and blob fields.
1.118 + Inserted two records.
1.119 + The test calls TSqlScalarFullSelectQuery functions in all possible
1.120 + "requested value type:real column type" combinations and checks the returned value.
1.121 +@SYMTestPriority High
1.122 +@SYMTestActions SQL, Scalar fullselect test.
1.123 +@SYMTestExpectedResults Test must not fail
1.124 +@SYMREQ REQ5792
1.125 + REQ5793
1.126 +*/
1.127 +template <class BUF> void ScalarFullSelectTestL()
1.128 + {
1.129 + //Create test database.
1.130 + RSqlDatabase db;
1.131 + CreateTestDbLC(db);
1.132 + TSqlScalarFullSelectQuery fullSelectQuery(db);
1.133 +
1.134 + BUF sql;
1.135 +
1.136 + /////////////////// tests with F1 column (integer column) ///////////////////////////
1.137 + _LIT(KSql1, "SELECT F1 FROM A WHERE F2 = 10000000000");
1.138 + sql.Copy(KSql1);
1.139 + //Read F1 as integer. Expected value: 1.
1.140 + TInt valInt = fullSelectQuery.SelectIntL(sql);
1.141 + TEST2(valInt, 1);
1.142 + //Read F1 as 64-bit integer. Expected value: 1.
1.143 + TInt64 valInt64 = fullSelectQuery.SelectInt64L(sql);
1.144 + TEST2(valInt64, 1);
1.145 + //Read F1 as real. Expected value: 1.0.
1.146 + TReal valReal = fullSelectQuery.SelectRealL(sql);
1.147 + TEST(Abs(valReal - 1.0) < 0.0001);
1.148 + TBuf<10> valText;
1.149 + //Read F1 as text. Expected value: zero-length 16-bit descriptor.
1.150 + TInt err = fullSelectQuery.SelectTextL(sql, valText);
1.151 + TEST2(err, KErrNone);
1.152 + TEST2(valText.Length(), 0);
1.153 + //Read F1 as binary. Expected value: zero-length 8-bit descriptor.
1.154 + TBuf8<10> valBinary;
1.155 + err = fullSelectQuery.SelectBinaryL(sql, valBinary);
1.156 + TEST2(err, KErrNone);
1.157 + TEST2(valBinary.Length(), 0);
1.158 + /////////////////// tests with F2 column (64-bit integer column) ///////////////////////////
1.159 + _LIT(KSql2, "SELECT F2 FROM A WHERE F1 = 1");
1.160 + sql.Copy(KSql2);
1.161 + //Read F2 as integer. Expected value: KMaxTInt.
1.162 + valInt = fullSelectQuery.SelectIntL(sql);
1.163 + TEST2(valInt, KMaxTInt);
1.164 + //Read F2 as 64-bit integer. Expected value: 10000000000
1.165 + valInt64 = fullSelectQuery.SelectInt64L(sql);
1.166 + TEST2(valInt64, 10000000000LL);
1.167 + //Read F2 as real. Expected value: 10000000000.0
1.168 + valReal = fullSelectQuery.SelectRealL(sql);
1.169 + TEST(Abs(valReal - 10000000000.0) < 0.0001);
1.170 + //Read F2 as text. Expected value: zero-length 16-bit descriptor.
1.171 + err = fullSelectQuery.SelectTextL(sql, valText);
1.172 + TEST2(err, KErrNone);
1.173 + TEST2(valText.Length(), 0);
1.174 + //Read F2 as binary. Expected value: zero-length 8-bit descriptor.
1.175 + err = fullSelectQuery.SelectBinaryL(sql, valBinary);
1.176 + TEST2(err, KErrNone);
1.177 + TEST2(valBinary.Length(), 0);
1.178 + /////////////////// tests with F3 column (real column) ///////////////////////////
1.179 + _LIT(KSql3, "SELECT F3 FROM A WHERE F1 = 1");
1.180 + sql.Copy(KSql3);
1.181 + //Read F3 as integer. Expected value: 3.
1.182 + valInt = fullSelectQuery.SelectIntL(sql);
1.183 + TEST2(valInt, 3);
1.184 + //Read F3 as 64-bit integer. Expected value: 3.
1.185 + valInt64 = fullSelectQuery.SelectInt64L(sql);
1.186 + TEST2(valInt64, 3);
1.187 + //Read F3 as real. Expected value: 2.54.
1.188 + valReal = fullSelectQuery.SelectRealL(sql);
1.189 + TEST(Abs(valReal - 2.54) < 0.0001);
1.190 + //Read F3 as text. Expected value: zero-length 16-bit descriptor.
1.191 + err = fullSelectQuery.SelectTextL(sql, valText);
1.192 + TEST2(err, KErrNone);
1.193 + TEST2(valText.Length(), 0);
1.194 + //Read F3 as binary. Expected value: zero-length 8-bit descriptor.
1.195 + err = fullSelectQuery.SelectBinaryL(sql, valBinary);
1.196 + TEST2(err, KErrNone);
1.197 + TEST2(valBinary.Length(), 0);
1.198 + /////////////////// tests with F4 column (text column) ///////////////////////////
1.199 + _LIT(KSql4, "SELECT F4 FROM A WHERE F1 = 1");
1.200 + sql.Copy(KSql4);
1.201 + //Read F4 as integer. Expected value: 0.
1.202 + valInt = fullSelectQuery.SelectIntL(sql);
1.203 + TEST2(valInt, 0);
1.204 + //Read F4 as 64-bit integer. Expected value: 0.
1.205 + valInt64 = fullSelectQuery.SelectInt64L(sql);
1.206 + TEST2(valInt64, 0);
1.207 + //Read F4 as real. Expected value: 0.0.
1.208 + valReal = fullSelectQuery.SelectRealL(sql);
1.209 + TEST(Abs(valReal - 0.0) < 0.0001);
1.210 + //Read F4 as text. Small buffer. Expected return code: positive value, which is the column length in characters.
1.211 + err = fullSelectQuery.SelectTextL(sql, valText);
1.212 + TEST(err > 0);
1.213 + TEST2(valText.Length(), 10);
1.214 + _LIT(KColText, "NAME123456");
1.215 + TEST(valText == KColText());
1.216 + //Read F4 as text. Big enough buffer. Expected error: KErrNone.
1.217 + TBuf<32> valText2;
1.218 + err = fullSelectQuery.SelectTextL(sql, valText2);
1.219 + TEST2(err, KErrNone);
1.220 + TEST2(valText2.Length(), 14);
1.221 + _LIT(KColText2, "NAME1234567890");
1.222 + TEST(valText2 == KColText2());
1.223 + //Read F4 as binary. Expected error: KErrNone. Zero-length 8-bit descriptor.
1.224 + err = fullSelectQuery.SelectBinaryL(sql, valBinary);
1.225 + TEST2(err, KErrNone);
1.226 + TEST2(valBinary.Length(), 0);
1.227 + /////////////////// tests with F5 column (binary column) ///////////////////////////
1.228 + _LIT(KSql5, "SELECT F5 FROM A WHERE F1 = 2");
1.229 + sql.Copy(KSql5);
1.230 + //Read F5 as integer. Expected value: 0.
1.231 + valInt = fullSelectQuery.SelectIntL(sql);
1.232 + TEST2(valInt, 0);
1.233 + //Read F5 as 64-bit integer. Expected value: 0.
1.234 + valInt64 = fullSelectQuery.SelectInt64L(sql);
1.235 + TEST2(valInt64, 0);
1.236 + //Read F5 as real. Expected value: 0.0.
1.237 + valReal = fullSelectQuery.SelectRealL(sql);
1.238 + TEST(Abs(valReal - 0.0) < 0.0001);
1.239 + //Read F5 as text. Expected error: KErrNone. Zero-length 16-bit descriptor.
1.240 + err = fullSelectQuery.SelectTextL(sql, valText);
1.241 + TEST2(err, KErrNone);
1.242 + TEST2(valText.Length(), 0);
1.243 + //Read F5 as binary. Small buffer. Expected return code: positive value, which is the column length in bytes.
1.244 + err = fullSelectQuery.SelectBinaryL(sql, valBinary);
1.245 + TEST(err > 0);
1.246 + TEST2(valBinary.Length(), 10);
1.247 + TInt i;
1.248 + for(i=0;i<10;++i)
1.249 + {
1.250 + TEST(valBinary[i] == i);
1.251 + }
1.252 + //Read F5 as binary. Big enough buffer. Expected error: KErrNone.
1.253 + TBuf8<100> valBinary2;
1.254 + err = fullSelectQuery.SelectBinaryL(sql, valBinary2);
1.255 + TEST2(err, KErrNone);
1.256 + TEST2(valBinary2.Length(), 100);
1.257 + for(i=0;i<100;++i)
1.258 + {
1.259 + TEST(valBinary2[i] == i);
1.260 + }
1.261 + /////////////////// Text column value, small buffer, reallocation ///////////////////
1.262 + HBufC* hbuf = HBufC::NewLC(10);
1.263 + TPtr name = hbuf->Des();
1.264 + sql.Copy(KSql4);
1.265 + err = fullSelectQuery.SelectTextL(sql, name);
1.266 + TEST(err >= 0); //the function may return only non-negative values
1.267 + if(err > 0)
1.268 + {
1.269 + hbuf = hbuf->ReAllocL(err);
1.270 + CleanupStack::Pop();
1.271 + CleanupStack::PushL(hbuf);
1.272 + name.Set(hbuf->Des());
1.273 + err = fullSelectQuery.SelectTextL(sql, name);
1.274 + TEST2(err, KErrNone);
1.275 + TEST(name == KColText2());
1.276 + }
1.277 + CleanupStack::PopAndDestroy();//hbuf, can't be put as parameter, because may be reallocated
1.278 + //Close database, delete database file.
1.279 + DestroyTestDb(db);
1.280 + }
1.281 +
1.282 +/**
1.283 +@SYMTestCaseID SYSLIB-SQL-CT-1810
1.284 +@SYMTestCaseDesc A test database is created, test table created in the database with integer, 64-bit
1.285 + integer, float, text and blob fields.
1.286 + Inserted two records.
1.287 + The test calls TSqlScalarFullSelectQuery functions using inappropriate SQL statements:
1.288 + SELECT sql statement with parameters, INSERT sql statement, SELECT sql statement,
1.289 + which does not return records.
1.290 +@SYMTestPriority High
1.291 +@SYMTestActions SQL, Scalar fullselect test.
1.292 +@SYMTestExpectedResults Test must not fail
1.293 +@SYMREQ REQ5792
1.294 + REQ5793
1.295 +*/
1.296 +template <class BUF> void ScalarFullSelectNegativeTestL()
1.297 + {
1.298 + //Create test database.
1.299 + RSqlDatabase db;
1.300 + CreateTestDbLC(db);
1.301 + TSqlScalarFullSelectQuery fullSelectQuery(db);
1.302 +
1.303 + BUF sql;
1.304 +
1.305 + //An attempt to use inappropriate SQL - 1.
1.306 + _LIT(KSql1, "SELECT F1 FROM A WHERE F2 = :P");
1.307 + sql.Copy(KSql1);
1.308 + TRAPD(err, fullSelectQuery.SelectIntL(sql));
1.309 + TEST2(err, KErrArgument);
1.310 +
1.311 + //An attempt to use inappropriate SQL - 2.
1.312 + _LIT(KSql2, "INSERT INTO A(F1) VALUES(2)");
1.313 + sql.Copy(KSql2);
1.314 + TRAP(err, fullSelectQuery.SelectIntL(sql));
1.315 + TEST2(err, KErrArgument);
1.316 +
1.317 + //The SQL statement does not return any rows
1.318 + _LIT(KSql3, "SELECT F1 FROM A WHERE F2 = 456231");
1.319 + sql.Copy(KSql3);
1.320 + TRAP(err, fullSelectQuery.SelectIntL(sql));
1.321 + TEST2(err, KErrNotFound);
1.322 +
1.323 + //Close database, delete database file.
1.324 + DestroyTestDb(db);
1.325 + }
1.326 +
1.327 +/**
1.328 +@SYMTestCaseID PDS-SQL-CT-4204
1.329 +@SYMTestCaseDesc TSqlScalarFullSelectQuery - border test.
1.330 +@SYMTestPriority High
1.331 +@SYMTestActions The test checks some border test cases such as:
1.332 + - retrieving NULL column as integer;
1.333 + - retrieving NULL column as 64-bit integer;
1.334 + - retrieving NULL column as TReal;
1.335 + - retrieving column value smaller than KMinTInt, as integer;
1.336 + - retrieving column value bigger than KMaxTInt, as integer;
1.337 +@SYMTestExpectedResults Test must not fail
1.338 +*/
1.339 +void ScalarFullSelectBorderTest()
1.340 + {
1.341 + (void)RSqlDatabase::Delete(KTestDatabase1);
1.342 + RSqlDatabase db;
1.343 + TInt rc = db.Create(KTestDatabase1);
1.344 + TEST2(rc, KErrNone);
1.345 + rc = db.Exec(_L("CREATE TABLE A(F1 INTEGER NULL, F2 INTEGER NULL, F3 FLOAT NULL, F4 TEXT NULL, F5 BLOB NULL)"));
1.346 + TEST(rc >= 0);
1.347 +
1.348 + TSqlScalarFullSelectQuery q(db);
1.349 +
1.350 + //Insert one record. Bigger than KMaxTInt F1 column value. Smaller than KMinTInt F2 column value.
1.351 + rc = db.Exec(_L("INSERT INTO A(F1,F2,F4) VALUES(5000000000,-5000000000,'aljhsfdlgefberveurfgvefkjgs;kjfgs;kjfsd')"));
1.352 + TEST2(rc, 1);
1.353 + //Select NULL column value as int.
1.354 + TInt res = -1;
1.355 + TRAP(rc, res = q.SelectIntL(_L("SELECT F5 FROM A")));
1.356 + TEST2(rc, KErrNone);
1.357 + TEST2(res, 0);
1.358 + //Select NULL column value as int64.
1.359 + res = -1;
1.360 + TRAP(rc, res = q.SelectInt64L(_L("SELECT F5 FROM A")));
1.361 + TEST2(rc, KErrNone);
1.362 + TEST2(res, 0);
1.363 + //Select NULL column value as TReal.
1.364 + TReal res2 = -1.0;
1.365 + TRAP(rc, res2 = q.SelectRealL(_L("SELECT F5 FROM A")));
1.366 + TEST2(rc, KErrNone);
1.367 + TEST(Abs(res2) < 0.000001);
1.368 + //Select NULL column value as text.
1.369 + TBuf<10> text;
1.370 + TRAP(rc, res = q.SelectTextL(_L("SELECT F5 FROM A"), text));
1.371 + TEST2(rc, KErrNone);
1.372 + TEST2(res, 0);
1.373 + TEST2(text.Length(), 0);
1.374 + //Select NULL column value as binary.
1.375 + TBuf8<10> data;
1.376 + TRAP(rc, res = q.SelectBinaryL(_L("SELECT F5 FROM A"), data));
1.377 + TEST2(rc, KErrNone);
1.378 + TEST2(res, 0);
1.379 + TEST2(data.Length(), 0);
1.380 + //Select column value bigger than KMaxTInt, as int.
1.381 + res = -1;
1.382 + TRAP(rc, res = q.SelectIntL(_L("SELECT F1 FROM A")));
1.383 + TEST2(rc, KErrNone);
1.384 + TEST2(res, KMaxTInt);
1.385 + //Select column value smaller than KMinTInt, as int.
1.386 + res = -1;
1.387 + TRAP(rc, res = q.SelectIntL(_L("SELECT F2 FROM A")));
1.388 + TEST2(rc, KErrNone);
1.389 + TEST2(res, KMinTInt);
1.390 +
1.391 + db.Close();
1.392 + (void)RSqlDatabase::Delete(KTestDatabase1);
1.393 + }
1.394 +
1.395 +
1.396 +void DoTestsL()
1.397 + {
1.398 + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1809 Scalar fullselect test. 16-bit SQL "));
1.399 + ScalarFullSelectTestL< TBuf16<100> >();
1.400 +
1.401 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1809 Scalar fullselect test. 8-bit SQL "));
1.402 + ScalarFullSelectTestL< TBuf8<100> >();
1.403 +
1.404 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1810 Scalar fullselect - negative test. 16-bit SQL "));
1.405 + ScalarFullSelectNegativeTestL< TBuf16<100> >();
1.406 +
1.407 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1810 Scalar fullselect - negative test. 8-bit SQL "));
1.408 + ScalarFullSelectNegativeTestL< TBuf8<100> >();
1.409 +
1.410 + TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4204 Scalar fullselect - border cases "));
1.411 + ScalarFullSelectBorderTest();
1.412 + }
1.413 +
1.414 +TInt E32Main()
1.415 + {
1.416 + TheTest.Title();
1.417 +
1.418 + CTrapCleanup* tc = CTrapCleanup::New();
1.419 +
1.420 + __UHEAP_MARK;
1.421 +
1.422 + CreateTestEnv();
1.423 + DeleteTestFiles();
1.424 + TRAPD(err, DoTestsL());
1.425 + DeleteTestFiles();
1.426 + TheFs.Close();
1.427 + TEST2(err, KErrNone);
1.428 +
1.429 + __UHEAP_MARKEND;
1.430 +
1.431 + TheTest.End();
1.432 + TheTest.Close();
1.433 +
1.434 + delete tc;
1.435 +
1.436 + User::Heap().Check();
1.437 + return KErrNone;
1.438 + }