1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqlpanic.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1739 @@
1.4 +// Copyright (c) 2005-2009 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 <sqldb.h>
1.22 +
1.23 +///////////////////////////////////////////////////////////////////////////////////////
1.24 +
1.25 +#define UNUSED_VAR(a) (a) = (a)
1.26 +#define IGNORE_ERR(a) (a) = (a)
1.27 +
1.28 +RTest TheTest(_L("t_sqlpanic test"));
1.29 +
1.30 +_LIT(KTestDir, "c:\\test\\");
1.31 +_LIT(KTestDbName, "c:\\test\\t_sqlpanic.db");
1.32 +
1.33 +_LIT(KCategory, "SqlDb");
1.34 +
1.35 +///////////////////////////////////////////////////////////////////////////////////////
1.36 +
1.37 +void DeleteTestFiles()
1.38 + {
1.39 + RSqlDatabase::Delete(KTestDbName);
1.40 + }
1.41 +
1.42 +///////////////////////////////////////////////////////////////////////////////////////
1.43 +///////////////////////////////////////////////////////////////////////////////////////
1.44 +//Test macros and functions
1.45 +void Check(TInt aValue, TInt aLine)
1.46 + {
1.47 + if(!aValue)
1.48 + {
1.49 + DeleteTestFiles();
1.50 + TheTest(EFalse, aLine);
1.51 + }
1.52 + }
1.53 +void Check(TInt aValue, TInt aExpected, TInt aLine)
1.54 + {
1.55 + if(aValue != aExpected)
1.56 + {
1.57 + DeleteTestFiles();
1.58 + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
1.59 + TheTest(EFalse, aLine);
1.60 + }
1.61 + }
1.62 +#define TEST(arg) ::Check((arg), __LINE__)
1.63 +#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
1.64 +
1.65 +///////////////////////////////////////////////////////////////////////////////////////
1.66 +
1.67 +void CreateTestDir()
1.68 + {
1.69 + RFs fs;
1.70 + TInt err = fs.Connect();
1.71 + TEST2(err, KErrNone);
1.72 +
1.73 + err = fs.MkDir(KTestDir);
1.74 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.75 +
1.76 + fs.Close();
1.77 + }
1.78 +
1.79 +///////////////////////////////////////////////////////////////////////////////////////
1.80 +
1.81 +//Panic thread function.
1.82 +//It will cast aData parameter to a TFunctor pointer and call it.
1.83 +//The expectation is that the called function will panic and kill the panic thread.
1.84 +TInt ThreadFunc(void* aData)
1.85 + {
1.86 + CTrapCleanup* tc = CTrapCleanup::New();
1.87 + TEST(tc != NULL);
1.88 +
1.89 + User::SetJustInTime(EFalse); // disable debugger panic handling
1.90 +
1.91 + TFunctor* obj = reinterpret_cast<TFunctor*> (aData);
1.92 + TEST(obj != NULL);
1.93 + (*obj)();//call the panic function
1.94 +
1.95 + delete tc;
1.96 +
1.97 + return KErrNone;
1.98 + }
1.99 +
1.100 +//Panic test.
1.101 +//PanicTest function will create a new thread - panic thread, giving it a pointer to the function which has to
1.102 +//be executed and the expectation is that the function will panic and kill the panic thread.
1.103 +//PanicTest function will check the panic thread exit code, exit category and the panic code.
1.104 +void PanicTest(TFunctor& aFunctor, TExitType aExpectedExitType, const TDesC& aExpectedCategory, TInt aExpectedPanicCode)
1.105 + {
1.106 + RThread thread;
1.107 + _LIT(KThreadName,"SqlDbPanicThread");
1.108 + TEST2(thread.Create(KThreadName, &ThreadFunc, 0x2000, 0x1000, 0x10000, (void*)&aFunctor, EOwnerThread), KErrNone);
1.109 +
1.110 + TRequestStatus status;
1.111 + thread.Logon(status);
1.112 + TEST2(status.Int(), KRequestPending);
1.113 + thread.Resume();
1.114 + User::WaitForRequest(status);
1.115 + User::SetJustInTime(ETrue); // enable debugger panic handling
1.116 +
1.117 + TEST2(thread.ExitType(), aExpectedExitType);
1.118 + TEST(thread.ExitCategory() == aExpectedCategory);
1.119 + TEST2(thread.ExitReason(), aExpectedPanicCode);
1.120 +
1.121 + CLOSE_AND_WAIT(thread);
1.122 + }
1.123 +
1.124 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.125 +////////////////////////////// Panic test functions /////////////////////////////////////////////////
1.126 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.127 +
1.128 +//Panic when calling RSqlDatabase::Exec() on an invalid RSqlDatabase object.
1.129 +class TSqlDatabase_NotCreated_Exec8 : public TFunctor
1.130 + {
1.131 +private:
1.132 + virtual void operator()()
1.133 + {
1.134 + RSqlDatabase db;
1.135 + db.Exec(_L8("CREATE TABLE A(f integer)"));//panic here
1.136 + }
1.137 + };
1.138 +static TSqlDatabase_NotCreated_Exec8 TheSqlDatabase_NotCreated_Exec8;
1.139 +
1.140 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.141 +//Panic when calling RSqlDatabase::Exec() on an invalid RSqlDatabase object.
1.142 +class TSqlDatabase_NotCreated_Exec : public TFunctor
1.143 + {
1.144 +private:
1.145 + virtual void operator()()
1.146 + {
1.147 + RSqlDatabase db;
1.148 + db.Exec(_L("CREATE TABLE A(f integer)"));//panic here
1.149 + }
1.150 + };
1.151 +static TSqlDatabase_NotCreated_Exec TheSqlDatabase_NotCreated_Exec;
1.152 +
1.153 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.154 +//Panic when calling RSqlDatabase::GetSecuritySettings() on an invalid RSqlDatabase object.
1.155 +class TSqlDatabase_NotCreated_SecuritySettings : public TFunctor
1.156 + {
1.157 +private:
1.158 + virtual void operator()()
1.159 + {
1.160 + RSqlDatabase db;
1.161 + RSqlSecurityPolicy securityPolicy;
1.162 + (void)db.GetSecurityPolicy(securityPolicy);//panic here
1.163 + }
1.164 + };
1.165 +static TSqlDatabase_NotCreated_SecuritySettings TheSqlDatabase_NotCreated_SecuritySettings;
1.166 +
1.167 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.168 +//Panic when calling RSqlDatabase::SetIsolationLevel() on an invalid RSqlDatabase object.
1.169 +class TSqlDatabase_NotCreated_SetIsolationLevel : public TFunctor
1.170 + {
1.171 +private:
1.172 + virtual void operator()()
1.173 + {
1.174 + RSqlDatabase db;
1.175 + db.SetIsolationLevel(RSqlDatabase::EReadUncommitted);//panic here
1.176 + }
1.177 + };
1.178 +static TSqlDatabase_NotCreated_SetIsolationLevel TheSqlDatabase_NotCreated_SetIsolationLevel;
1.179 +
1.180 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.181 +//Panic when calling RSqlDatabase::LastErrorMessage() on an invalid RSqlDatabase object.
1.182 +class TSqlDatabase_NotCreated_LastErrorMessage : public TFunctor
1.183 + {
1.184 +private:
1.185 + virtual void operator()()
1.186 + {
1.187 + RSqlDatabase db;
1.188 + db.LastErrorMessage();//panic here
1.189 + }
1.190 + };
1.191 +static TSqlDatabase_NotCreated_LastErrorMessage TheSqlDatabase_NotCreated_LastErrorMessage;
1.192 +
1.193 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.194 +//Panic when calling RSqlDatabase::LastInsertedRowId() on an invalid RSqlDatabase object.
1.195 +class TSqlDatabase_NotCreated_LastInsertedRowId : public TFunctor
1.196 + {
1.197 +private:
1.198 + virtual void operator()()
1.199 + {
1.200 + RSqlDatabase db;
1.201 + db.LastInsertedRowId();//panic here
1.202 + }
1.203 + };
1.204 +static TSqlDatabase_NotCreated_LastInsertedRowId TheSqlDatabase_NotCreated_LastInsertedRowId;
1.205 +
1.206 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.207 +//Panic when calling RSqlDatabase::Size() on an invalid RSqlDatabase object.
1.208 +class TSqlDatabase_NotCreated_Size : public TFunctor
1.209 + {
1.210 +private:
1.211 + virtual void operator()()
1.212 + {
1.213 + RSqlDatabase db;
1.214 + (void)db.Size();//panic here
1.215 + }
1.216 + };
1.217 +static TSqlDatabase_NotCreated_Size TheSqlDatabase_NotCreated_Size;
1.218 +
1.219 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.220 +//Panic when calling RSqlDatabase::Size(TSize&) on an invalid RSqlDatabase object.
1.221 +class TSqlDatabase_NotCreated_Size2 : public TFunctor
1.222 + {
1.223 +private:
1.224 + virtual void operator()()
1.225 + {
1.226 + RSqlDatabase db;
1.227 + RSqlDatabase::TSize size;
1.228 + (void)db.Size(size);//panic here
1.229 + }
1.230 + };
1.231 +static TSqlDatabase_NotCreated_Size2 TheSqlDatabase_NotCreated_Size2;
1.232 +
1.233 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.234 +//Panic when calling RSqlDatabase::InTransaction() on an invalid RSqlDatabase object.
1.235 +class TSqlDatabase_NotCreated_InTransaction : public TFunctor
1.236 + {
1.237 +private:
1.238 + virtual void operator()()
1.239 + {
1.240 + RSqlDatabase db;
1.241 + (void)db.InTransaction();//panic here
1.242 + }
1.243 + };
1.244 +static TSqlDatabase_NotCreated_InTransaction TheSqlDatabase_NotCreated_InTransaction;
1.245 +
1.246 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.247 +//Panic when calling RSqlDatabase::Attach() on an invalid RSqlDatabase object.
1.248 +class TSqlDatabase_NotCreated_Attach : public TFunctor
1.249 + {
1.250 +private:
1.251 + virtual void operator()()
1.252 + {
1.253 + RSqlDatabase db;
1.254 + db.Attach(_L("C:\\TEST\\A.DB"), _L("A"));//panic here
1.255 + }
1.256 + };
1.257 +static TSqlDatabase_NotCreated_Attach TheSqlDatabase_NotCreated_Attach;
1.258 +
1.259 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.260 +//Panic when calling RSqlDatabase::Detach() on an invalid RSqlDatabase object.
1.261 +class TSqlDatabase_NotCreated_Detach : public TFunctor
1.262 + {
1.263 +private:
1.264 + virtual void operator()()
1.265 + {
1.266 + RSqlDatabase db;
1.267 + db.Detach(_L("A"));//panic here
1.268 + }
1.269 + };
1.270 +static TSqlDatabase_NotCreated_Detach TheSqlDatabase_NotCreated_Detach;
1.271 +
1.272 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.273 +//Panic when calling RSqlDatabase::Compact() on an invalid RSqlDatabase object.
1.274 +class TSqlDatabase_NotCreated_Compact : public TFunctor
1.275 + {
1.276 +private:
1.277 + virtual void operator()()
1.278 + {
1.279 + RSqlDatabase db;
1.280 + db.Compact(2048);//panic here
1.281 + }
1.282 + };
1.283 +static TSqlDatabase_NotCreated_Compact TheSqlDatabase_NotCreated_Compact;
1.284 +
1.285 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.286 +//Panic when calling async RSqlDatabase::Compact() on an invalid RSqlDatabase object.
1.287 +class TSqlDatabase_NotCreated_Compact2 : public TFunctor
1.288 + {
1.289 +private:
1.290 + virtual void operator()()
1.291 + {
1.292 + RSqlDatabase db;
1.293 + TRequestStatus stat;
1.294 + db.Compact(2048, stat);//panic here
1.295 + }
1.296 + };
1.297 +static TSqlDatabase_NotCreated_Compact2 TheSqlDatabase_NotCreated_Compact2;
1.298 +
1.299 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.300 +//Panic when calling RSqlStatement::Reset() on an invalid RSqlStatement object.
1.301 +class TSqlStatement_NotCreated_Reset : public TFunctor
1.302 + {
1.303 +private:
1.304 + virtual void operator()()
1.305 + {
1.306 + RSqlStatement stmt;
1.307 + stmt.Reset();//panic here
1.308 + }
1.309 + };
1.310 +static TSqlStatement_NotCreated_Reset TheSqlStatement_NotCreated_Reset;
1.311 +
1.312 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.313 +//Panic when calling RSqlStatement::Exec() on an invalid RSqlStatement object.
1.314 +class TSqlStatement_NotCreated_Exec : public TFunctor
1.315 + {
1.316 +private:
1.317 + virtual void operator()()
1.318 + {
1.319 + RSqlStatement stmt;
1.320 + stmt.Exec();//panic here
1.321 + }
1.322 + };
1.323 +static TSqlStatement_NotCreated_Exec TheSqlStatement_NotCreated_Exec;
1.324 +
1.325 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.326 +//Panic when calling RSqlStatement::Next() on an invalid RSqlStatement object.
1.327 +class TSqlStatement_NotCreated_Next : public TFunctor
1.328 + {
1.329 +private:
1.330 + virtual void operator()()
1.331 + {
1.332 + RSqlStatement stmt;
1.333 + stmt.Next();//panic here
1.334 + }
1.335 + };
1.336 +static TSqlStatement_NotCreated_Next TheSqlStatement_NotCreated_Next;
1.337 +
1.338 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.339 +//Panic when calling RSqlStatement::ParameterIndex() on an invalid RSqlStatement object.
1.340 +class TSqlStatement_NotCreated_ParameterIndex : public TFunctor
1.341 + {
1.342 +private:
1.343 + virtual void operator()()
1.344 + {
1.345 + RSqlStatement stmt;
1.346 + stmt.ParameterIndex(_L("ABV"));//panic here
1.347 + }
1.348 + };
1.349 +static TSqlStatement_NotCreated_ParameterIndex TheSqlStatement_NotCreated_ParameterIndex;
1.350 +
1.351 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.352 +//Panic when calling RSqlStatement::ColumnIndex() on an invalid RSqlStatement object.
1.353 +class TSqlStatement_NotCreated_ColumnIndex : public TFunctor
1.354 + {
1.355 +private:
1.356 + virtual void operator()()
1.357 + {
1.358 + RSqlStatement stmt;
1.359 + stmt.ColumnIndex(_L("ABV"));//panic here
1.360 + }
1.361 + };
1.362 +static TSqlStatement_NotCreated_ColumnIndex TheSqlStatement_NotCreated_ColumnIndex;
1.363 +
1.364 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.365 +//Panic when calling RSqlStatement::ColumnType() on an invalid RSqlStatement object.
1.366 +class TSqlStatement_NotCreated_ColumnType : public TFunctor
1.367 + {
1.368 +private:
1.369 + virtual void operator()()
1.370 + {
1.371 + RSqlStatement stmt;
1.372 + stmt.ColumnType(1);//panic here
1.373 + }
1.374 + };
1.375 +static TSqlStatement_NotCreated_ColumnType TheSqlStatement_NotCreated_ColumnType;
1.376 +
1.377 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.378 +//Panic when calling RSqlStatement::ColumnSize() on an invalid RSqlStatement object.
1.379 +class TSqlStatement_NotCreated_ColumnSize : public TFunctor
1.380 + {
1.381 +private:
1.382 + virtual void operator()()
1.383 + {
1.384 + RSqlStatement stmt;
1.385 + stmt.ColumnSize(1);//panic here
1.386 + }
1.387 + };
1.388 +static TSqlStatement_NotCreated_ColumnSize TheSqlStatement_NotCreated_ColumnSize;
1.389 +
1.390 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.391 +//Panic when calling RSqlStatement::BindNull() on an invalid RSqlStatement object.
1.392 +class TSqlStatement_NotCreated_BindNull : public TFunctor
1.393 + {
1.394 +private:
1.395 + virtual void operator()()
1.396 + {
1.397 + RSqlStatement stmt;
1.398 + stmt.BindNull(1);//panic here
1.399 + }
1.400 + };
1.401 +static TSqlStatement_NotCreated_BindNull TheSqlStatement_NotCreated_BindNull;
1.402 +
1.403 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.404 +//Panic when calling RSqlStatement::BindInt() on an invalid RSqlStatement object.
1.405 +class TSqlStatement_NotCreated_BindInt : public TFunctor
1.406 + {
1.407 +private:
1.408 + virtual void operator()()
1.409 + {
1.410 + RSqlStatement stmt;
1.411 + stmt.BindInt(1, 2);//panic here
1.412 + }
1.413 + };
1.414 +static TSqlStatement_NotCreated_BindInt TheSqlStatement_NotCreated_BindInt;
1.415 +
1.416 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.417 +//Panic when calling RSqlStatement::BindInt64() on an invalid RSqlStatement object.
1.418 +class TSqlStatement_NotCreated_BindInt64 : public TFunctor
1.419 + {
1.420 +private:
1.421 + virtual void operator()()
1.422 + {
1.423 + RSqlStatement stmt;
1.424 + stmt.BindInt64(1, TInt64(2));//panic here
1.425 + }
1.426 + };
1.427 +static TSqlStatement_NotCreated_BindInt64 TheSqlStatement_NotCreated_BindInt64;
1.428 +
1.429 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.430 +//Panic when calling RSqlStatement::BindReal() on an invalid RSqlStatement object.
1.431 +class TSqlStatement_NotCreated_BindReal : public TFunctor
1.432 + {
1.433 +private:
1.434 + virtual void operator()()
1.435 + {
1.436 + RSqlStatement stmt;
1.437 + stmt.BindReal(1, 2.5);//panic here
1.438 + }
1.439 + };
1.440 +static TSqlStatement_NotCreated_BindReal TheSqlStatement_NotCreated_BindReal;
1.441 +
1.442 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.443 +//Panic when calling RSqlStatement::BindText() on an invalid RSqlStatement object.
1.444 +class TSqlStatement_NotCreated_BindText : public TFunctor
1.445 + {
1.446 +private:
1.447 + virtual void operator()()
1.448 + {
1.449 + RSqlStatement stmt;
1.450 + stmt.BindText(1, _L("ABV"));//panic here
1.451 + }
1.452 + };
1.453 +static TSqlStatement_NotCreated_BindText TheSqlStatement_NotCreated_BindText;
1.454 +
1.455 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.456 +//Panic when calling RSqlStatement::BindBinary() on an invalid RSqlStatement object.
1.457 +class TSqlStatement_NotCreated_BindBinary : public TFunctor
1.458 + {
1.459 +private:
1.460 + virtual void operator()()
1.461 + {
1.462 + RSqlStatement stmt;
1.463 + stmt.BindBinary(1, _L8("ABV"));//panic here
1.464 + }
1.465 + };
1.466 +static TSqlStatement_NotCreated_BindBinary TheSqlStatement_NotCreated_BindBinary;
1.467 +
1.468 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.469 +//Panic when calling RSqlStatement::BindZeroBlob() on an invalid RSqlStatement object.
1.470 +class TSqlStatement_NotCreated_BindZeroBlob : public TFunctor
1.471 + {
1.472 +private:
1.473 + virtual void operator()()
1.474 + {
1.475 + RSqlStatement stmt;
1.476 + stmt.BindZeroBlob(1, 100);//panic here
1.477 + }
1.478 + };
1.479 +static TSqlStatement_NotCreated_BindZeroBlob TheSqlStatement_NotCreated_BindZeroBlob;
1.480 +
1.481 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.482 +//Panic when an attempt is made to call RSqlStatement::BindZeroBlob() giving an invalid parameter index.
1.483 +class TSqlStatement_OutOfBounds_BindZeroBlob : public TFunctor
1.484 + {
1.485 +private:
1.486 + virtual void operator()()
1.487 + {
1.488 + RSqlDatabase db;
1.489 + TEST2(db.Create(KTestDbName), KErrNone);
1.490 + TEST2(db.Exec(_L8("CREATE TABLE D(A INTEGER, B BLOB)")), 1);
1.491 + RSqlStatement stmt;
1.492 + TEST2(stmt.Prepare(db, _L8("INSERT INTO D VALUES(1, :Prm1)")), KErrNone);
1.493 + stmt.BindZeroBlob(12, 100);//panic here
1.494 + stmt.Close();
1.495 + db.Close();
1.496 + }
1.497 + };
1.498 +static TSqlStatement_OutOfBounds_BindZeroBlob TheSqlStatement_OutOfBounds_BindZeroBlob;
1.499 +
1.500 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.501 +//Panic when calling RSqlStatement::IsNull() on an invalid RSqlStatement object.
1.502 +class TSqlStatement_NotCreated_IsNull : public TFunctor
1.503 + {
1.504 +private:
1.505 + virtual void operator()()
1.506 + {
1.507 + RSqlStatement stmt;
1.508 + stmt.IsNull(1);//panic here
1.509 + }
1.510 + };
1.511 +static TSqlStatement_NotCreated_IsNull TheSqlStatement_NotCreated_IsNull;
1.512 +
1.513 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.514 +//Panic when calling RSqlStatement::ColumnInt() on an invalid RSqlStatement object.
1.515 +class TSqlStatement_NotCreated_ColumnInt : public TFunctor
1.516 + {
1.517 +private:
1.518 + virtual void operator()()
1.519 + {
1.520 + RSqlStatement stmt;
1.521 + stmt.ColumnInt(1);//panic here
1.522 + }
1.523 + };
1.524 +static TSqlStatement_NotCreated_ColumnInt TheSqlStatement_NotCreated_ColumnInt;
1.525 +
1.526 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.527 +//Panic when calling RSqlStatement::ColumnInt64() on an invalid RSqlStatement object.
1.528 +class TSqlStatement_NotCreated_ColumnInt64 : public TFunctor
1.529 + {
1.530 +private:
1.531 + virtual void operator()()
1.532 + {
1.533 + RSqlStatement stmt;
1.534 + stmt.ColumnInt64(1);//panic here
1.535 + }
1.536 + };
1.537 +static TSqlStatement_NotCreated_ColumnInt64 TheSqlStatement_NotCreated_ColumnInt64;
1.538 +
1.539 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.540 +//Panic when calling RSqlStatement::ColumnReal() on an invalid RSqlStatement object.
1.541 +class TSqlStatement_NotCreated_ColumnReal : public TFunctor
1.542 + {
1.543 +private:
1.544 + virtual void operator()()
1.545 + {
1.546 + RSqlStatement stmt;
1.547 + stmt.ColumnReal(1);//panic here
1.548 + }
1.549 + };
1.550 +static TSqlStatement_NotCreated_ColumnReal TheSqlStatement_NotCreated_ColumnReal;
1.551 +
1.552 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.553 +//Panic when calling RSqlStatement::ColumnText() on an invalid RSqlStatement object.
1.554 +class TSqlStatement_NotCreated_ColumnText : public TFunctor
1.555 + {
1.556 +private:
1.557 + virtual void operator()()
1.558 + {
1.559 + RSqlStatement stmt;
1.560 + TPtrC ptr;
1.561 + (void)stmt.ColumnText(1, ptr);//panic here
1.562 + }
1.563 + };
1.564 +static TSqlStatement_NotCreated_ColumnText TheSqlStatement_NotCreated_ColumnText;
1.565 +
1.566 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.567 +//Panic when calling RSqlStatement::ColumnText() on an invalid RSqlStatement object.
1.568 +class TSqlStatement_NotCreated_ColumnText2 : public TFunctor
1.569 + {
1.570 +private:
1.571 + virtual void operator()()
1.572 + {
1.573 + RSqlStatement stmt;
1.574 + TBuf<10> buf;
1.575 + stmt.ColumnText(1, buf);//panic here
1.576 + }
1.577 + };
1.578 +static TSqlStatement_NotCreated_ColumnText2 TheSqlStatement_NotCreated_ColumnText2;
1.579 +
1.580 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.581 +//Panic when calling RSqlStatement::ColumnBinary() on an invalid RSqlStatement object.
1.582 +class TSqlStatement_NotCreated_ColumnBinary : public TFunctor
1.583 + {
1.584 +private:
1.585 + virtual void operator()()
1.586 + {
1.587 + RSqlStatement stmt;
1.588 + TPtrC8 ptr;
1.589 + (void)stmt.ColumnBinary(1, ptr);//panic here
1.590 + }
1.591 + };
1.592 +static TSqlStatement_NotCreated_ColumnBinary TheSqlStatement_NotCreated_ColumnBinary;
1.593 +
1.594 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.595 +//Panic when calling RSqlStatement::ColumnBinary() on an invalid RSqlStatement object.
1.596 +class TSqlStatement_NotCreated_ColumnBinary2 : public TFunctor
1.597 + {
1.598 +private:
1.599 + virtual void operator()()
1.600 + {
1.601 + RSqlStatement stmt;
1.602 + TBuf8<10> buf;
1.603 + stmt.ColumnBinary(1, buf);//panic here
1.604 + }
1.605 + };
1.606 +static TSqlStatement_NotCreated_ColumnBinary2 TheSqlStatement_NotCreated_ColumnBinary2;
1.607 +
1.608 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.609 +//Panic when calling RSqlStatement::Prepare() giving an invalid RSqlDatabase object.
1.610 +class TSqlStatement_DbNotCreated_Prepare : public TFunctor
1.611 + {
1.612 +private:
1.613 + virtual void operator()()
1.614 + {
1.615 + RSqlDatabase db;
1.616 + RSqlStatement stmt;
1.617 + stmt.Prepare(db, _L("CREATE TABLE A(d INTEGER)"));//panic here
1.618 + }
1.619 + };
1.620 +static TSqlStatement_DbNotCreated_Prepare TheSqlStatement_DbNotCreated_Prepare;
1.621 +
1.622 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.623 +//Panic when calling RSqlStatement::Prepare() giving an invalid RSqlDatabase object.
1.624 +class TSqlStatement_DbNotCreated_Prepare8 : public TFunctor
1.625 + {
1.626 +private:
1.627 + virtual void operator()()
1.628 + {
1.629 + RSqlDatabase db;
1.630 + RSqlStatement stmt;
1.631 + stmt.Prepare(db, _L8("CREATE TABLE A(d INTEGER)"));//panic here
1.632 + }
1.633 + };
1.634 +static TSqlStatement_DbNotCreated_Prepare8 TheSqlStatement_DbNotCreated_Prepare8;
1.635 +
1.636 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.637 +/*
1.638 +//Panic when an attempt is made to call RSqlStatement::Prepare() twice on the same RSqlStatement object.
1.639 +class TSqlStatement_CreateTwice : public TFunctor
1.640 + {
1.641 +private:
1.642 + virtual void operator()()
1.643 + {
1.644 + RSqlDatabase db;
1.645 + TEST2(db.Create(KTestDbName), KErrNone);
1.646 + RSqlStatement stmt;
1.647 + TEST2(stmt.Prepare(db, _L("CREATE TABLE A(d INTEGER)")), KErrNone);
1.648 + stmt.Prepare(db, _L("CREATE TABLE A(d INTEGER)"));//panic here
1.649 + stmt.Close();
1.650 + db.Close();
1.651 + }
1.652 + };
1.653 +static TSqlStatement_CreateTwice TheSqlStatement_CreateTwice;
1.654 +
1.655 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.656 +//Panic when an attempt is made to call RSqlStatement::Prepare() twice on the same RSqlStatement object.
1.657 +class TSqlStatement_CreateTwice8 : public TFunctor
1.658 + {
1.659 +private:
1.660 + virtual void operator()()
1.661 + {
1.662 + RSqlDatabase db;
1.663 + TEST2(db.Create(KTestDbName), KErrNone);
1.664 + RSqlStatement stmt;
1.665 + TEST2(stmt.Prepare(db, _L8("CREATE TABLE A(d INTEGER)")), KErrNone);
1.666 + stmt.Prepare(db, _L8("CREATE TABLE A(d INTEGER)"));//panic here
1.667 + stmt.Close();
1.668 + db.Close();
1.669 + }
1.670 + };
1.671 +static TSqlStatement_CreateTwice8 TheSqlStatement_CreateTwice8;
1.672 +*/
1.673 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.674 +//Panic when an attempt is made to call RSqlStatement::ColumnType() giving an invalid column index.
1.675 +class TSqlStatement_OutOfBounds_ColumnType : public TFunctor
1.676 + {
1.677 +private:
1.678 + virtual void operator()()
1.679 + {
1.680 + RSqlDatabase db;
1.681 + TEST2(db.Create(KTestDbName), KErrNone);
1.682 + TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);
1.683 + RSqlStatement stmt;
1.684 + TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D")), KErrNone);
1.685 + stmt.ColumnType(12);//panic here
1.686 + stmt.Close();
1.687 + db.Close();
1.688 + }
1.689 + };
1.690 +static TSqlStatement_OutOfBounds_ColumnType TheSqlStatement_OutOfBounds_ColumnType;
1.691 +
1.692 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.693 +//Panic when an attempt is made to call RSqlStatement::ColumnSize() giving an invalid column index.
1.694 +class TSqlStatement_OutOfBounds_ColumnSize : public TFunctor
1.695 + {
1.696 +private:
1.697 + virtual void operator()()
1.698 + {
1.699 + RSqlDatabase db;
1.700 + TEST2(db.Create(KTestDbName), KErrNone);
1.701 + TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);
1.702 + RSqlStatement stmt;
1.703 + TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D")), KErrNone);
1.704 + stmt.ColumnSize(-25);//panic here
1.705 + stmt.Close();
1.706 + db.Close();
1.707 + }
1.708 + };
1.709 +static TSqlStatement_OutOfBounds_ColumnSize TheSqlStatement_OutOfBounds_ColumnSize;
1.710 +
1.711 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.712 +//Panic when an attempt is made to call RSqlStatement::BindNull() giving an invalid parameter index.
1.713 +class TSqlStatement_OutOfBounds_Bind : public TFunctor
1.714 + {
1.715 +private:
1.716 + virtual void operator()()
1.717 + {
1.718 + RSqlDatabase db;
1.719 + TEST2(db.Create(KTestDbName), KErrNone);
1.720 + TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);
1.721 + RSqlStatement stmt;
1.722 + TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D WHERE A = :V")), KErrNone);
1.723 + stmt.BindNull(2);//panic here
1.724 + stmt.Close();
1.725 + db.Close();
1.726 + }
1.727 + };
1.728 +static TSqlStatement_OutOfBounds_Bind TheSqlStatement_OutOfBounds_Bind;
1.729 +
1.730 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.731 +//Panic when an attempt is made to call RSqlStatement::ColumnInt() giving an invalid column index.
1.732 +class TSqlStatement_OutOfBounds_ColumnValue : public TFunctor
1.733 + {
1.734 +private:
1.735 + virtual void operator()()
1.736 + {
1.737 + RSqlDatabase db;
1.738 + TEST2(db.Create(KTestDbName), KErrNone);
1.739 + TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);
1.740 + RSqlStatement stmt;
1.741 + TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D")), KErrNone);
1.742 + stmt.ColumnInt(56);//panic here
1.743 + stmt.Close();
1.744 + db.Close();
1.745 + }
1.746 + };
1.747 +static TSqlStatement_OutOfBounds_ColumnValue TheSqlStatement_OutOfBounds_ColumnValue;
1.748 +
1.749 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.750 +//Panic when calling RSqlStatement::ColumnCount() on an invalid RSqlStatement object.
1.751 +class TSqlStatement_NotCreated_ColumnCount : public TFunctor
1.752 + {
1.753 +private:
1.754 + virtual void operator()()
1.755 + {
1.756 + RSqlStatement stmt;
1.757 + stmt.ColumnCount();//panic here
1.758 + }
1.759 + };
1.760 +static TSqlStatement_NotCreated_ColumnCount TheSqlStatement_NotCreated_ColumnCount;
1.761 +
1.762 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.763 +//Panic when calling RSqlStatement::DeclaredColumnType() on an invalid RSqlStatement object.
1.764 +class TSqlStatement_NotCreated_DeclaredColumnType : public TFunctor
1.765 + {
1.766 +private:
1.767 + virtual void operator()()
1.768 + {
1.769 + RSqlStatement stmt;
1.770 + TSqlColumnType colType;
1.771 + stmt.DeclaredColumnType(0, colType);//panic here
1.772 + }
1.773 + };
1.774 +static TSqlStatement_NotCreated_DeclaredColumnType TheSqlStatement_NotCreated_DeclaredColumnType;
1.775 +
1.776 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.777 +//Panic when an attempt is made to call RSqlStatement::DeclaredColumnType() giving an invalid column index.
1.778 +class TSqlStatement_OutOfBounds_DeclaredColumnType : public TFunctor
1.779 + {
1.780 +private:
1.781 + virtual void operator()()
1.782 + {
1.783 + RSqlDatabase db;
1.784 + TEST2(db.Create(KTestDbName), KErrNone);
1.785 + TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);
1.786 + RSqlStatement stmt;
1.787 + TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D")), KErrNone);
1.788 + TSqlColumnType colType;
1.789 + stmt.DeclaredColumnType(8, colType);//panic here
1.790 + stmt.Close();
1.791 + db.Close();
1.792 + }
1.793 + };
1.794 +static TSqlStatement_OutOfBounds_DeclaredColumnType TheSqlStatement_OutOfBounds_DeclaredColumnType;
1.795 +
1.796 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.797 +//Panic when an attempt is made to call RSqlStatement::ColumnName() on an invalid RSqlStatement object.
1.798 +class TSqlStatement_NotCreated_ColumnName : public TFunctor
1.799 + {
1.800 +private:
1.801 + virtual void operator()()
1.802 + {
1.803 + RSqlDatabase db;
1.804 + TEST2(db.Create(KTestDbName), KErrNone);
1.805 + RSqlStatement stmt;
1.806 + TPtrC columnName;
1.807 + (void)stmt.ColumnName(0, columnName);//panic here
1.808 + stmt.Close();
1.809 + db.Close();
1.810 + }
1.811 + };
1.812 +static TSqlStatement_NotCreated_ColumnName TheSqlStatement_NotCreated_ColumnName;
1.813 +
1.814 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.815 +//Panic when an attempt is made to call RSqlStatement::ParameterName() on an invalid RSqlStatement object.
1.816 +class TSqlStatement_NotCreated_ParameterName : public TFunctor
1.817 + {
1.818 +private:
1.819 + virtual void operator()()
1.820 + {
1.821 + RSqlDatabase db;
1.822 + TEST2(db.Create(KTestDbName), KErrNone);
1.823 + RSqlStatement stmt;
1.824 + TPtrC parameterName;
1.825 + (void)stmt.ParameterName(0, parameterName);//panic here
1.826 + stmt.Close();
1.827 + db.Close();
1.828 + }
1.829 + };
1.830 +static TSqlStatement_NotCreated_ParameterName TheSqlStatement_NotCreated_ParameterName;
1.831 +
1.832 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.833 +//Panic when an attempt is made to call RSqlStatement::ParamName() on an invalid RSqlStatement object.
1.834 +class TSqlStatement_NotCreated_ParamName : public TFunctor
1.835 + {
1.836 +private:
1.837 + virtual void operator()()
1.838 + {
1.839 + RSqlDatabase db;
1.840 + TEST2(db.Create(KTestDbName), KErrNone);
1.841 + RSqlStatement stmt;
1.842 + TPtrC paramName;
1.843 + (void)stmt.ParamName(0, paramName);//panic here
1.844 + stmt.Close();
1.845 + db.Close();
1.846 + }
1.847 + };
1.848 +static TSqlStatement_NotCreated_ParamName TheSqlStatement_NotCreated_ParamName;
1.849 +
1.850 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.851 +//Panic when an attempt is made to call RSqlColumnReadStream::ColumnText() with an invalid RSqlStatement object.
1.852 +class TColumnReadStream_ColumnText_Statement : public TFunctor
1.853 + {
1.854 +private:
1.855 + virtual void operator()()
1.856 + {
1.857 + RSqlStatement stmt;
1.858 + RSqlColumnReadStream strm;
1.859 + strm.ColumnText(stmt, 0);//panic here
1.860 + strm.Close();
1.861 + }
1.862 + };
1.863 +static TColumnReadStream_ColumnText_Statement TheColumnReadStream_ColumnText_Statement;
1.864 +
1.865 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.866 +//Panic when an attempt is made to call RSqlColumnReadStream::ColumnBinary() with an invalid RSqlStatement object.
1.867 +class TColumnReadStream_ColumnBinary_Statement : public TFunctor
1.868 + {
1.869 +private:
1.870 + virtual void operator()()
1.871 + {
1.872 + RSqlStatement stmt;
1.873 + RSqlColumnReadStream strm;
1.874 + strm.ColumnBinary(stmt, 0);//panic here
1.875 + strm.Close();
1.876 + }
1.877 + };
1.878 +static TColumnReadStream_ColumnBinary_Statement TheColumnReadStream_ColumnBinary_Statement;
1.879 +
1.880 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.881 +//Panic when an attempt is made to call RSqlColumnReadStream::ColumnText() with an invalid column index.
1.882 +class TColumnReadStream_ColumnText_Column : public TFunctor
1.883 + {
1.884 +private:
1.885 + virtual void operator()()
1.886 + {
1.887 + RSqlDatabase db;
1.888 + TEST2(db.Create(KTestDbName), KErrNone);
1.889 + TEST(db.Exec(_L8("CREATE TABLE D(A TEXT)")) >= 0);
1.890 +
1.891 + RSqlStatement stmt;
1.892 + TEST2(stmt.Prepare(db, _L8("SELECT * FROM D")), KErrNone);
1.893 +
1.894 + RSqlColumnReadStream strm;
1.895 + strm.ColumnText(stmt, 8);//panic here
1.896 +
1.897 + strm.Close();
1.898 + stmt.Close();
1.899 + db.Close();
1.900 + }
1.901 + };
1.902 +static TColumnReadStream_ColumnText_Column TheColumnReadStream_ColumnText_Column;
1.903 +
1.904 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.905 +//Panic when an attempt is made to call RSqlColumnReadStream::ColumnBinary() with an invalid column index.
1.906 +class TColumnReadStream_ColumnBinary_Column : public TFunctor
1.907 + {
1.908 +private:
1.909 + virtual void operator()()
1.910 + {
1.911 + RSqlDatabase db;
1.912 + TEST2(db.Create(KTestDbName), KErrNone);
1.913 + TEST(db.Exec(_L8("CREATE TABLE D(A BLOB)")) >= 0);
1.914 +
1.915 + RSqlStatement stmt;
1.916 + TEST2(stmt.Prepare(db, _L8("SELECT * FROM D")), KErrNone);
1.917 +
1.918 + RSqlColumnReadStream strm;
1.919 + strm.ColumnBinary(stmt, 3);//panic here
1.920 +
1.921 + strm.Close();
1.922 + stmt.Close();
1.923 + db.Close();
1.924 + }
1.925 + };
1.926 +static TColumnReadStream_ColumnBinary_Column TheColumnReadStream_ColumnBinary_Column;
1.927 +
1.928 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.929 +//Panic when an attempt is made to call RSqlColumnReadStream::ColumnText() when the statement object is not at row.
1.930 +class TColumnReadStream_ColumnText_AtRow : public TFunctor
1.931 + {
1.932 +private:
1.933 + virtual void operator()()
1.934 + {
1.935 + RSqlDatabase db;
1.936 + TEST2(db.Create(KTestDbName), KErrNone);
1.937 + TEST(db.Exec(_L8("CREATE TABLE D(A TEXT)")) >= 0);
1.938 +
1.939 + RSqlStatement stmt;
1.940 + TEST2(stmt.Prepare(db, _L8("SELECT * FROM D")), KErrNone);
1.941 +
1.942 + RSqlColumnReadStream strm;
1.943 + strm.ColumnText(stmt, 0);//panic here
1.944 +
1.945 + strm.Close();
1.946 + stmt.Close();
1.947 + db.Close();
1.948 + }
1.949 + };
1.950 +static TColumnReadStream_ColumnText_AtRow TheColumnReadStream_ColumnText_AtRow;
1.951 +
1.952 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.953 +//Panic when an attempt is made to call RSqlColumnReadStream::ColumnBinary() when the statement object is not at row.
1.954 +class TColumnReadStream_ColumnBinary_AtRow : public TFunctor
1.955 + {
1.956 +private:
1.957 + virtual void operator()()
1.958 + {
1.959 + RSqlDatabase db;
1.960 + TEST2(db.Create(KTestDbName), KErrNone);
1.961 + TEST(db.Exec(_L8("CREATE TABLE D(A BLOB)")) >= 0);
1.962 +
1.963 + RSqlStatement stmt;
1.964 + TEST2(stmt.Prepare(db, _L8("SELECT * FROM D")), KErrNone);
1.965 +
1.966 + RSqlColumnReadStream strm;
1.967 + strm.ColumnBinary(stmt, 0);//panic here
1.968 +
1.969 + strm.Close();
1.970 + stmt.Close();
1.971 + db.Close();
1.972 + }
1.973 + };
1.974 +static TColumnReadStream_ColumnBinary_AtRow TheColumnReadStream_ColumnBinary_AtRow;
1.975 +
1.976 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.977 +//Panic when an attempt is made to call RSqlParamWriteStream::BindText() with an invalid RSqlStatement object.
1.978 +class TParamWriteStream_BindText_Statement : public TFunctor
1.979 + {
1.980 +private:
1.981 + virtual void operator()()
1.982 + {
1.983 + RSqlStatement stmt;
1.984 + RSqlParamWriteStream strm;
1.985 + strm.BindText(stmt, 0);//panic here
1.986 + strm.Close();
1.987 + }
1.988 + };
1.989 +static TParamWriteStream_BindText_Statement TheParamWriteStream_BindText_Statement;
1.990 +
1.991 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.992 +//Panic when an attempt is made to call RSqlParamWriteStream::BindBinary() with an invalid RSqlStatement object.
1.993 +class TParamWriteStream_BindBinary_Statement : public TFunctor
1.994 + {
1.995 +private:
1.996 + virtual void operator()()
1.997 + {
1.998 + RSqlStatement stmt;
1.999 + RSqlParamWriteStream strm;
1.1000 + strm.BindBinary(stmt, 0);//panic here
1.1001 + strm.Close();
1.1002 + }
1.1003 + };
1.1004 +static TParamWriteStream_BindBinary_Statement TheParamWriteStream_BindBinary_Statement;
1.1005 +
1.1006 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1007 +//Panic when an attempt is made to call RSqlParamWriteStream::BindText() with an invalid parameter index.
1.1008 +class TParamWriteStream_BindText_Column : public TFunctor
1.1009 + {
1.1010 +private:
1.1011 + virtual void operator()()
1.1012 + {
1.1013 + RSqlDatabase db;
1.1014 + TEST2(db.Create(KTestDbName), KErrNone);
1.1015 + TEST(db.Exec(_L8("CREATE TABLE D(A TEXT)")) >= 0);
1.1016 +
1.1017 + RSqlStatement stmt;
1.1018 + TEST2(stmt.Prepare(db, _L8("SELECT * FROM D WHERE A = :Val")), KErrNone);
1.1019 +
1.1020 + RSqlParamWriteStream strm;
1.1021 + strm.BindText(stmt, 8);//panic here
1.1022 +
1.1023 + strm.Close();
1.1024 + stmt.Close();
1.1025 + db.Close();
1.1026 + }
1.1027 + };
1.1028 +static TParamWriteStream_BindText_Column TheParamWriteStream_BindText_Column;
1.1029 +
1.1030 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1031 +//Panic when an attempt is made to call RSqlParamWriteStream::BindBinary() with an invalid parameter index.
1.1032 +class TParamWriteStream_BindBinary_Column : public TFunctor
1.1033 + {
1.1034 +private:
1.1035 + virtual void operator()()
1.1036 + {
1.1037 + RSqlDatabase db;
1.1038 + TEST2(db.Create(KTestDbName), KErrNone);
1.1039 + TEST(db.Exec(_L8("CREATE TABLE D(A BLOB)")) >= 0);
1.1040 +
1.1041 + RSqlStatement stmt;
1.1042 + TEST2(stmt.Prepare(db, _L8("SELECT * FROM D WHERE A = :Val")), KErrNone);
1.1043 +
1.1044 + RSqlParamWriteStream strm;
1.1045 + strm.BindBinary(stmt, 3);//panic here
1.1046 +
1.1047 + strm.Close();
1.1048 + stmt.Close();
1.1049 + db.Close();
1.1050 + }
1.1051 + };
1.1052 +static TParamWriteStream_BindBinary_Column TheParamWriteStream_BindBinary_Column;
1.1053 +
1.1054 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1055 +//Panic when an attempt is made to call RSqlSecurityPolicy::DefaultPolicy() on an invalid object.
1.1056 +class TSqlSecurity_DefaultPolicy : public TFunctor
1.1057 + {
1.1058 +private:
1.1059 + virtual void operator()()
1.1060 + {
1.1061 + RSqlSecurityPolicy securityPolicy;
1.1062 + TSecurityPolicy policy = securityPolicy.DefaultPolicy();//panic here
1.1063 + UNUSED_VAR(policy);
1.1064 + }
1.1065 + };
1.1066 +static TSqlSecurity_DefaultPolicy TheSqlSecurity_DefaultPolicy;
1.1067 +
1.1068 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1069 +//Panic when an attempt is made to call RSqlSecurityPolicy::SetDbPolicy() with an invalid policy type.
1.1070 +class TSqlSecurity_Set1 : public TFunctor
1.1071 + {
1.1072 +private:
1.1073 + virtual void operator()()
1.1074 + {
1.1075 + TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
1.1076 + RSqlSecurityPolicy securityPolicy;
1.1077 + TInt err = securityPolicy.Create(defaultPolicy);
1.1078 + TEST2(err, KErrNone);
1.1079 + RSqlSecurityPolicy::TPolicyType policyType = static_cast <RSqlSecurityPolicy::TPolicyType> (12345);
1.1080 + TSecurityPolicy policy(TSecurityPolicy::EAlwaysFail);
1.1081 + securityPolicy.SetDbPolicy(policyType, policy);//panic here
1.1082 + securityPolicy.Close();
1.1083 + }
1.1084 + };
1.1085 +static TSqlSecurity_Set1 TheSqlSecurity_Set1;
1.1086 +
1.1087 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1088 +//Panic when an attempt is made to call RSqlSecurityPolicy::SetPolicy() with an invalid database object type.
1.1089 +class TSqlSecurity_Set2 : public TFunctor
1.1090 + {
1.1091 +private:
1.1092 + virtual void operator()()
1.1093 + {
1.1094 + TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
1.1095 + RSqlSecurityPolicy securityPolicy;
1.1096 + TInt err = securityPolicy.Create(defaultPolicy);
1.1097 + TEST2(err, KErrNone);
1.1098 + RSqlSecurityPolicy::TObjectType objectType = static_cast <RSqlSecurityPolicy::TObjectType> (-113);
1.1099 + TSecurityPolicy policy(TSecurityPolicy::EAlwaysFail);
1.1100 + securityPolicy.SetPolicy(objectType, _L("ATbl"), RSqlSecurityPolicy::EWritePolicy, policy);//panic here
1.1101 + securityPolicy.Close();
1.1102 + }
1.1103 + };
1.1104 +static TSqlSecurity_Set2 TheSqlSecurity_Set2;
1.1105 +
1.1106 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1107 +//Panic when an attempt is made to call RSqlSecurityPolicy::SetPolicy() with an invalid database object name.
1.1108 +class TSqlSecurity_Set3 : public TFunctor
1.1109 + {
1.1110 +private:
1.1111 + virtual void operator()()
1.1112 + {
1.1113 + TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
1.1114 + RSqlSecurityPolicy securityPolicy;
1.1115 + TInt err = securityPolicy.Create(defaultPolicy);
1.1116 + TEST2(err, KErrNone);
1.1117 + TSecurityPolicy policy(TSecurityPolicy::EAlwaysFail);
1.1118 + securityPolicy.SetPolicy(RSqlSecurityPolicy::ETable, KNullDesC, RSqlSecurityPolicy::EReadPolicy, policy);//panic here
1.1119 + securityPolicy.Close();
1.1120 + }
1.1121 + };
1.1122 +static TSqlSecurity_Set3 TheSqlSecurity_Set3;
1.1123 +
1.1124 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1125 +//Panic when an attempt is made to call RSqlSecurityPolicy::DbPolicy() with an invalid policy type.
1.1126 +class TSqlSecurity_Get1 : public TFunctor
1.1127 + {
1.1128 +private:
1.1129 + virtual void operator()()
1.1130 + {
1.1131 + TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
1.1132 + RSqlSecurityPolicy securityPolicy;
1.1133 + TInt err = securityPolicy.Create(defaultPolicy);
1.1134 + TEST2(err, KErrNone);
1.1135 + RSqlSecurityPolicy::TPolicyType policyType = static_cast <RSqlSecurityPolicy::TPolicyType> (12345);
1.1136 + securityPolicy.DbPolicy(policyType);//panic here
1.1137 + securityPolicy.Close();
1.1138 + }
1.1139 + };
1.1140 +static TSqlSecurity_Get1 TheSqlSecurity_Get1;
1.1141 +
1.1142 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1143 +//Panic when an attempt is made to call RSqlSecurityPolicy::Policy() with an invalid database object type.
1.1144 +class TSqlSecurity_Get2 : public TFunctor
1.1145 + {
1.1146 +private:
1.1147 + virtual void operator()()
1.1148 + {
1.1149 + TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
1.1150 + RSqlSecurityPolicy securityPolicy;
1.1151 + TInt err = securityPolicy.Create(defaultPolicy);
1.1152 + TEST2(err, KErrNone);
1.1153 + RSqlSecurityPolicy::TObjectType objectType = static_cast <RSqlSecurityPolicy::TObjectType> (-113);
1.1154 + securityPolicy.Policy(objectType, _L("BTbl"), RSqlSecurityPolicy::EReadPolicy);//panic here
1.1155 + securityPolicy.Close();
1.1156 + }
1.1157 + };
1.1158 +static TSqlSecurity_Get2 TheSqlSecurity_Get2;
1.1159 +
1.1160 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1161 +//Panic when an attempt is made to call RSqlSecurityPolicy::Policy() with an invalid database object name.
1.1162 +class TSqlSecurity_Get3 : public TFunctor
1.1163 + {
1.1164 +private:
1.1165 + virtual void operator()()
1.1166 + {
1.1167 + TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
1.1168 + RSqlSecurityPolicy securityPolicy;
1.1169 + TInt err = securityPolicy.Create(defaultPolicy);
1.1170 + TEST2(err, KErrNone);
1.1171 + securityPolicy.Policy(RSqlSecurityPolicy::ETable, KNullDesC, RSqlSecurityPolicy::EWritePolicy);//panic here
1.1172 + securityPolicy.Close();
1.1173 + }
1.1174 + };
1.1175 +static TSqlSecurity_Get3 TheSqlSecurity_Get3;
1.1176 +
1.1177 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1178 +/*
1.1179 +//Panic when an attempt is made to call RSqlSecurityPolicy::Create() on an already created object.
1.1180 +class TSqlSecurity_CreateTwice : public TFunctor
1.1181 + {
1.1182 +private:
1.1183 + virtual void operator()()
1.1184 + {
1.1185 + TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
1.1186 + RSqlSecurityPolicy securityPolicy;
1.1187 + TInt err = securityPolicy.Create(defaultPolicy);
1.1188 + TEST2(err, KErrNone);
1.1189 + securityPolicy.Create(defaultPolicy);//panic here
1.1190 + securityPolicy.Close();
1.1191 + }
1.1192 + };
1.1193 +static TSqlSecurity_CreateTwice TheSqlSecurity_CreateTwice;
1.1194 +*/
1.1195 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1196 +//Panic when an attempt is made to call RSqlSecurityPolicy::ExternalizeL() on an invalid object.
1.1197 +class TSqlSecurity_Externalize : public TFunctor
1.1198 + {
1.1199 +private:
1.1200 + virtual void operator()()
1.1201 + {
1.1202 + RSqlSecurityPolicy securityPolicy;
1.1203 + RWriteStream stream;
1.1204 + TRAPD(err, securityPolicy.ExternalizeL(stream));//panic here
1.1205 + IGNORE_ERR(err);
1.1206 + }
1.1207 + };
1.1208 +static TSqlSecurity_Externalize TheSqlSecurity_Externalize;
1.1209 +
1.1210 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1211 +//Panic when an attempt is made to call TSqlScalarFullSelectQuery method and the database is not set.
1.1212 +class TSqlScalarFullSelectQuery_InvalidDatabase : public TFunctor
1.1213 + {
1.1214 +private:
1.1215 + virtual void operator()()
1.1216 + {
1.1217 + TSqlScalarFullSelectQuery query;
1.1218 + TRAP_IGNORE((void)query.SelectIntL(_L("SELECT Id FROM A WHERE Name = 'AAA'")));
1.1219 + }
1.1220 + };
1.1221 +static TSqlScalarFullSelectQuery_InvalidDatabase TheSqlScalarFullSelectQuery_InvalidDatabase;
1.1222 +
1.1223 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1224 +//Panic when an attempt is made to call RSqlBlobReadStream::OpenL() with an invalid RSqlDatabase object.
1.1225 +class TBlobReadStream_Open_Database1 : public TFunctor
1.1226 + {
1.1227 +private:
1.1228 + virtual void operator()()
1.1229 + {
1.1230 + CTrapCleanup* tc = CTrapCleanup::New();
1.1231 +
1.1232 + RSqlDatabase db;
1.1233 + RSqlBlobReadStream strm;
1.1234 + TRAP_IGNORE(strm.OpenL(db, _L("Tbl"),_L("Col"), 1));//panic here
1.1235 + strm.Close();
1.1236 +
1.1237 + delete tc;
1.1238 + }
1.1239 + };
1.1240 +static TBlobReadStream_Open_Database1 TheBlobReadStream_Open_Database1;
1.1241 +
1.1242 +class TBlobReadStream_Open_Database2 : public TFunctor
1.1243 + {
1.1244 +private:
1.1245 + virtual void operator()()
1.1246 + {
1.1247 + CTrapCleanup* tc = CTrapCleanup::New();
1.1248 +
1.1249 + RSqlDatabase db;
1.1250 + RSqlBlobReadStream strm;
1.1251 + TRAP_IGNORE(strm.OpenL(db, _L("Tbl"),_L("Col"), 1, _L("Db")));//panic here
1.1252 + strm.Close();
1.1253 +
1.1254 + delete tc;
1.1255 + }
1.1256 + };
1.1257 +static TBlobReadStream_Open_Database2 TheBlobReadStream_Open_Database2;
1.1258 +
1.1259 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1260 +//Panic when an attempt is made to call RSqlBlobReadStream::SizeL() on a unitialized RSqlBlobReadStream object.
1.1261 +class TBlobReadStream_Size_Stream : public TFunctor
1.1262 + {
1.1263 +private:
1.1264 + virtual void operator()()
1.1265 + {
1.1266 + CTrapCleanup* tc = CTrapCleanup::New();
1.1267 +
1.1268 + RSqlBlobReadStream strm;
1.1269 + TRAP_IGNORE(strm.SizeL());//panic here
1.1270 + strm.Close();
1.1271 +
1.1272 + delete tc;
1.1273 + }
1.1274 + };
1.1275 +TBlobReadStream_Size_Stream TheBlobReadStream_Size_Stream;
1.1276 +
1.1277 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1278 +//Panic when an attempt is made to call RSqlBlobWriteStream::OpenL() with an invalid RSqlDatabase object.
1.1279 +class TBlobWriteStream_Open_Database1 : public TFunctor
1.1280 + {
1.1281 +private:
1.1282 + virtual void operator()()
1.1283 + {
1.1284 + CTrapCleanup* tc = CTrapCleanup::New();
1.1285 +
1.1286 + RSqlDatabase db;
1.1287 + RSqlBlobWriteStream strm;
1.1288 + TRAP_IGNORE(strm.OpenL(db, _L("Tbl"),_L("Col"), 1));//panic here
1.1289 + strm.Close();
1.1290 +
1.1291 + delete tc;
1.1292 + }
1.1293 + };
1.1294 +static TBlobWriteStream_Open_Database1 TheBlobWriteStream_Open_Database1;
1.1295 +
1.1296 +class TBlobWriteStream_Open_Database2 : public TFunctor
1.1297 + {
1.1298 +private:
1.1299 + virtual void operator()()
1.1300 + {
1.1301 + CTrapCleanup* tc = CTrapCleanup::New();
1.1302 +
1.1303 + RSqlDatabase db;
1.1304 + RSqlBlobWriteStream strm;
1.1305 + TRAP_IGNORE(strm.OpenL(db, _L("Tbl"),_L("Col"), 1, _L("Db")));//panic here
1.1306 + strm.Close();
1.1307 +
1.1308 + delete tc;
1.1309 + }
1.1310 + };
1.1311 +static TBlobWriteStream_Open_Database2 TheBlobWriteStream_Open_Database2;
1.1312 +
1.1313 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1314 +//Panic when an attempt is made to call RSqlBlobWriteStream::SizeL() on a unitialized RSqlBlobWriteStream object.
1.1315 +class TBlobWriteStream_Size_Stream : public TFunctor
1.1316 + {
1.1317 +private:
1.1318 + virtual void operator()()
1.1319 + {
1.1320 + CTrapCleanup* tc = CTrapCleanup::New();
1.1321 +
1.1322 + RSqlBlobWriteStream strm;
1.1323 + TRAP_IGNORE(strm.SizeL());//panic here
1.1324 + strm.Close();
1.1325 +
1.1326 + delete tc;
1.1327 + }
1.1328 + };
1.1329 +TBlobWriteStream_Size_Stream TheBlobWriteStream_Size_Stream;
1.1330 +
1.1331 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1332 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1333 +
1.1334 +/**
1.1335 +@SYMTestCaseID SYSLIB-SQL-CT-1619
1.1336 +@SYMTestCaseDesc RSqlDatabase panic tests
1.1337 + Run a second thread. The second thread executes given RSqlDatabase method calling
1.1338 + it with wrong arguments, or in a bad context,...The method panics the second thread.
1.1339 + The main thread captures and checks the panic code.
1.1340 +@SYMTestPriority High
1.1341 +@SYMTestActions RSqlDatabase panic tests
1.1342 +@SYMTestExpectedResults Test must not fail
1.1343 +@SYMREQ REQ5792
1.1344 + REQ5793
1.1345 + REQ10405
1.1346 + REQ10407
1.1347 +*/
1.1348 +void DatabaseTests()
1.1349 + {
1.1350 + TheTest.Printf(_L("'RSqlDatabase object not created - Exec 8' panic\r\n"));
1.1351 + PanicTest(TheSqlDatabase_NotCreated_Exec8, EExitPanic, KCategory, 2);
1.1352 +
1.1353 + TheTest.Printf(_L("'RSqlDatabase object not created - Exec' panic\r\n"));
1.1354 + PanicTest(TheSqlDatabase_NotCreated_Exec, EExitPanic, KCategory, 2);
1.1355 +
1.1356 + TheTest.Printf(_L("'RSqlDatabase object not created - GetSecuritySettings' panic\r\n"));
1.1357 + PanicTest(TheSqlDatabase_NotCreated_SecuritySettings, EExitPanic, KCategory, 2);
1.1358 +
1.1359 + TheTest.Printf(_L("'RSqlDatabase object not created - Attach' panic\r\n"));
1.1360 + PanicTest(TheSqlDatabase_NotCreated_Attach, EExitPanic, KCategory, 2);
1.1361 +
1.1362 + TheTest.Printf(_L("'RSqlDatabase object not created - Detach' panic\r\n"));
1.1363 + PanicTest(TheSqlDatabase_NotCreated_Detach, EExitPanic, KCategory, 2);
1.1364 +
1.1365 + TheTest.Printf(_L("'RSqlDatabase object not created - SetIsolationLevel' panic\r\n"));
1.1366 + PanicTest(TheSqlDatabase_NotCreated_SetIsolationLevel, EExitPanic, KCategory, 2);
1.1367 +
1.1368 + TheTest.Printf(_L("'RSqlDatabase object not created - LastErrorMessage' panic\r\n"));
1.1369 + PanicTest(TheSqlDatabase_NotCreated_LastErrorMessage, EExitPanic, KCategory, 2);
1.1370 +
1.1371 + TheTest.Printf(_L("'RSqlDatabase object not created - LastInsertedRowId' panic\r\n"));
1.1372 + PanicTest(TheSqlDatabase_NotCreated_LastInsertedRowId, EExitPanic, KCategory, 2);
1.1373 +
1.1374 + TheTest.Printf(_L("'RSqlDatabase object not created - Size' panic\r\n"));
1.1375 + PanicTest(TheSqlDatabase_NotCreated_Size, EExitPanic, KCategory, 2);
1.1376 +
1.1377 + TheTest.Printf(_L("'RSqlDatabase object not created - Size(TSize&)' panic\r\n"));
1.1378 + PanicTest(TheSqlDatabase_NotCreated_Size2, EExitPanic, KCategory, 2);
1.1379 +
1.1380 + TheTest.Printf(_L("'RSqlDatabase object not created - InTransaction' panic\r\n"));
1.1381 + PanicTest(TheSqlDatabase_NotCreated_InTransaction, EExitPanic, KCategory, 2);
1.1382 +
1.1383 + TheTest.Printf(_L("'RSqlDatabase object not created - Compact' panic\r\n"));
1.1384 + PanicTest(TheSqlDatabase_NotCreated_Compact, EExitPanic, KCategory, 2);
1.1385 +
1.1386 + TheTest.Printf(_L("'RSqlDatabase object not created - async Compact' panic\r\n"));
1.1387 + PanicTest(TheSqlDatabase_NotCreated_Compact2, EExitPanic, KCategory, 2);
1.1388 + }
1.1389 +
1.1390 +/**
1.1391 +@SYMTestCaseID SYSLIB-SQL-CT-1620
1.1392 +@SYMTestCaseDesc RSqlStatement panic tests
1.1393 + Run a second thread. The second thread executes given RSqlStatement method calling
1.1394 + it with wrong arguments, or in a bad context,...The method panics the second thread.
1.1395 + The main thread captures and checks the panic code.
1.1396 +@SYMTestPriority High
1.1397 +@SYMTestActions RSqlStatement panic tests
1.1398 +@SYMTestExpectedResults Test must not fail
1.1399 +@SYMREQ REQ5792
1.1400 + REQ5793
1.1401 +*/
1.1402 +void StatementTests()
1.1403 + {
1.1404 + TheTest.Printf(_L("'RSqlStatement object not created - Reset' panic\r\n"));
1.1405 + PanicTest(TheSqlStatement_NotCreated_Reset, EExitPanic, KCategory, 2);
1.1406 +
1.1407 + TheTest.Printf(_L("'RSqlStatement object not created - Exec' panic\r\n"));
1.1408 + PanicTest(TheSqlStatement_NotCreated_Exec, EExitPanic, KCategory, 2);
1.1409 +
1.1410 + TheTest.Printf(_L("'RSqlStatement object not created - Next' panic\r\n"));
1.1411 + PanicTest(TheSqlStatement_NotCreated_Next, EExitPanic, KCategory, 2);
1.1412 +
1.1413 + TheTest.Printf(_L("'RSqlStatement object not created - ParameterIndex' panic\r\n"));
1.1414 + PanicTest(TheSqlStatement_NotCreated_ParameterIndex, EExitPanic, KCategory, 2);
1.1415 +
1.1416 + TheTest.Printf(_L("'RSqlStatement object not created - ColumnIndex' panic\r\n"));
1.1417 + PanicTest(TheSqlStatement_NotCreated_ColumnIndex, EExitPanic, KCategory, 2);
1.1418 +
1.1419 + TheTest.Printf(_L("'RSqlStatement object not created - ColumnType' panic\r\n"));
1.1420 + PanicTest(TheSqlStatement_NotCreated_ColumnType, EExitPanic, KCategory, 2);
1.1421 +
1.1422 + TheTest.Printf(_L("'RSqlStatement object not created - ColumnSize' panic\r\n"));
1.1423 + PanicTest(TheSqlStatement_NotCreated_ColumnSize, EExitPanic, KCategory, 2);
1.1424 +
1.1425 + TheTest.Printf(_L("'RSqlStatement object not created - BindNull' panic\r\n"));
1.1426 + PanicTest(TheSqlStatement_NotCreated_BindNull, EExitPanic, KCategory, 2);
1.1427 +
1.1428 + TheTest.Printf(_L("'RSqlStatement object not created - BindInt' panic\r\n"));
1.1429 + PanicTest(TheSqlStatement_NotCreated_BindInt, EExitPanic, KCategory, 2);
1.1430 +
1.1431 + TheTest.Printf(_L("'RSqlStatement object not created - BindInt64' panic\r\n"));
1.1432 + PanicTest(TheSqlStatement_NotCreated_BindInt64, EExitPanic, KCategory, 2);
1.1433 +
1.1434 + TheTest.Printf(_L("'RSqlStatement object not created - BindReal' panic\r\n"));
1.1435 + PanicTest(TheSqlStatement_NotCreated_BindReal, EExitPanic, KCategory, 2);
1.1436 +
1.1437 + TheTest.Printf(_L("'RSqlStatement object not created - BindText' panic\r\n"));
1.1438 + PanicTest(TheSqlStatement_NotCreated_BindText, EExitPanic, KCategory, 2);
1.1439 +
1.1440 + TheTest.Printf(_L("'RSqlStatement object not created - BindBinary' panic\r\n"));
1.1441 + PanicTest(TheSqlStatement_NotCreated_BindBinary, EExitPanic, KCategory, 2);
1.1442 +
1.1443 + TheTest.Printf(_L("'RSqlStatement object not created - BindZeroBlob' panic\r\n"));
1.1444 + PanicTest(TheSqlStatement_NotCreated_BindZeroBlob, EExitPanic, KCategory, 2);
1.1445 +
1.1446 + TheTest.Printf(_L("'RSqlStatement::BindZeroBlob() - invalid parameter index' panic\r\n"));
1.1447 + PanicTest(TheSqlStatement_OutOfBounds_BindZeroBlob, EExitPanic, KCategory, 5);
1.1448 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1449 +
1.1450 + TheTest.Printf(_L("'RSqlStatement object not created - ColumnInt' panic\r\n"));
1.1451 + PanicTest(TheSqlStatement_NotCreated_ColumnInt, EExitPanic, KCategory, 2);
1.1452 +
1.1453 + TheTest.Printf(_L("'RSqlStatement object not created - IsNull' panic\r\n"));
1.1454 + PanicTest(TheSqlStatement_NotCreated_ColumnInt, EExitPanic, KCategory, 2);
1.1455 +
1.1456 + TheTest.Printf(_L("'RSqlStatement object not created - ColumnInt64' panic\r\n"));
1.1457 + PanicTest(TheSqlStatement_NotCreated_ColumnInt64, EExitPanic, KCategory, 2);
1.1458 +
1.1459 + TheTest.Printf(_L("'RSqlStatement object not created - ColumnReal' panic\r\n"));
1.1460 + PanicTest(TheSqlStatement_NotCreated_ColumnReal, EExitPanic, KCategory, 2);
1.1461 +
1.1462 + TheTest.Printf(_L("'RSqlStatement object not created - ColumnText' panic\r\n"));
1.1463 + PanicTest(TheSqlStatement_NotCreated_ColumnText, EExitPanic, KCategory, 2);
1.1464 +
1.1465 + TheTest.Printf(_L("'RSqlStatement object not created - ColumnText2' panic\r\n"));
1.1466 + PanicTest(TheSqlStatement_NotCreated_ColumnText2, EExitPanic, KCategory, 2);
1.1467 +
1.1468 + TheTest.Printf(_L("'RSqlStatement object not created - ColumnBinary' panic\r\n"));
1.1469 + PanicTest(TheSqlStatement_NotCreated_ColumnBinary, EExitPanic, KCategory, 2);
1.1470 +
1.1471 + TheTest.Printf(_L("'RSqlStatement object not created - ColumnBinary2' panic\r\n"));
1.1472 + PanicTest(TheSqlStatement_NotCreated_ColumnBinary2, EExitPanic, KCategory, 2);
1.1473 +
1.1474 + TheTest.Printf(_L("'RSqlStatement - database not created - Prepare' panic\r\n"));
1.1475 + PanicTest(TheSqlStatement_DbNotCreated_Prepare, EExitPanic, KCategory, 2);
1.1476 +
1.1477 + TheTest.Printf(_L("'RSqlStatement - database not created - Prepare 8' panic\r\n"));
1.1478 + PanicTest(TheSqlStatement_DbNotCreated_Prepare8, EExitPanic, KCategory, 2);
1.1479 +
1.1480 + TheTest.Printf(_L("'RSqlStatement - ColumnType - Column index out of bounds' panic\r\n"));
1.1481 + PanicTest(TheSqlStatement_OutOfBounds_ColumnType, EExitPanic, KCategory, 5);
1.1482 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1483 +
1.1484 + TheTest.Printf(_L("'RSqlStatement - ColumnSize - Column index out of bounds' panic\r\n"));
1.1485 + PanicTest(TheSqlStatement_OutOfBounds_ColumnSize, EExitPanic, KCategory, 5);
1.1486 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1487 +
1.1488 + TheTest.Printf(_L("'RSqlStatement - Bind - Parameter index out of bounds' panic\r\n"));
1.1489 + PanicTest(TheSqlStatement_OutOfBounds_Bind, EExitPanic, KCategory, 5);
1.1490 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1491 +
1.1492 + TheTest.Printf(_L("'RSqlStatement - Column value - Parameter index out of bounds' panic\r\n"));
1.1493 + PanicTest(TheSqlStatement_OutOfBounds_ColumnValue, EExitPanic, KCategory, 5);
1.1494 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1495 +
1.1496 + TheTest.Printf(_L("'RSqlStatement object not created - ColumnCount' panic\r\n"));
1.1497 + PanicTest(TheSqlStatement_NotCreated_ColumnCount, EExitPanic, KCategory, 2);
1.1498 +
1.1499 + TheTest.Printf(_L("'RSqlStatement object not created - DeclaredColumnType' panic\r\n"));
1.1500 + PanicTest(TheSqlStatement_NotCreated_DeclaredColumnType, EExitPanic, KCategory, 2);
1.1501 +
1.1502 + TheTest.Printf(_L("'RSqlStatement - DeclaredColumnType - Column index out of bounds' panic\r\n"));
1.1503 + PanicTest(TheSqlStatement_OutOfBounds_DeclaredColumnType, EExitPanic, KCategory, 5);
1.1504 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1505 +
1.1506 + TheTest.Printf(_L("'RSqlStatement - ColumnName' panic\r\n"));
1.1507 + PanicTest(TheSqlStatement_NotCreated_ColumnName, EExitPanic, KCategory, 2);
1.1508 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1509 +
1.1510 + TheTest.Printf(_L("'RSqlStatement - ParameterName' panic\r\n"));
1.1511 + PanicTest(TheSqlStatement_NotCreated_ParameterName, EExitPanic, KCategory, 2);
1.1512 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1513 +
1.1514 + TheTest.Printf(_L("'RSqlStatement - ParamName' panic\r\n"));
1.1515 + PanicTest(TheSqlStatement_NotCreated_ParamName, EExitPanic, KCategory, 2);
1.1516 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1517 + }
1.1518 +
1.1519 +/**
1.1520 +@SYMTestCaseID SYSLIB-SQL-CT-1625
1.1521 +@SYMTestCaseDesc RSqlColumnReadStream panic tests
1.1522 + Run a second thread. The second thread executes given RSqlColumnReadStream method calling
1.1523 + it with wrong arguments, or in a bad context,...The method panics the second thread.
1.1524 + The main thread captures and checks the panic code.
1.1525 +@SYMTestPriority High
1.1526 +@SYMTestActions RSqlColumnReadStream panic tests
1.1527 +@SYMTestExpectedResults Test must not fail
1.1528 +@SYMREQ REQ5792
1.1529 + REQ5793
1.1530 +*/
1.1531 +void ColumnStreamTests()
1.1532 + {
1.1533 + TheTest.Printf(_L("'RSqlColumnReadStream - ColumnText - invalid statement' panic\r\n"));
1.1534 + PanicTest(TheColumnReadStream_ColumnText_Statement, EExitPanic, KCategory, 2);
1.1535 +
1.1536 + TheTest.Printf(_L("'RSqlColumnReadStream - ColumnBinary - invalid statement' panic\r\n"));
1.1537 + PanicTest(TheColumnReadStream_ColumnBinary_Statement, EExitPanic, KCategory, 2);
1.1538 +
1.1539 + TheTest.Printf(_L("'RSqlColumnReadStream - ColumnText - invalid column index' panic\r\n"));
1.1540 + PanicTest(TheColumnReadStream_ColumnText_Column, EExitPanic, KCategory, 5);
1.1541 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1542 +
1.1543 + TheTest.Printf(_L("'RSqlColumnReadStream - ColumnBinary - invalid column index' panic\r\n"));
1.1544 + PanicTest(TheColumnReadStream_ColumnBinary_Column, EExitPanic, KCategory, 5);
1.1545 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1546 +
1.1547 + TheTest.Printf(_L("'RSqlColumnReadStream - ColumnText - not at row' panic\r\n"));
1.1548 + PanicTest(TheColumnReadStream_ColumnText_AtRow, EExitPanic, KCategory, 11);
1.1549 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1550 +
1.1551 + TheTest.Printf(_L("'RSqlColumnReadStream - ColumnBinary - not at row' panic\r\n"));
1.1552 + PanicTest(TheColumnReadStream_ColumnBinary_AtRow, EExitPanic, KCategory, 11);
1.1553 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1554 + }
1.1555 +
1.1556 +/**
1.1557 +@SYMTestCaseID SYSLIB-SQL-CT-1626
1.1558 +@SYMTestCaseDesc RSqlParamWriteStream panic tests
1.1559 + Run a second thread. The second thread executes given RSqlParamWriteStream method calling
1.1560 + it with wrong arguments, or in a bad context,...The method panics the second thread.
1.1561 + The main thread captures and checks the panic code.
1.1562 +@SYMTestPriority High
1.1563 +@SYMTestActions RSqlParamWriteStream panic tests
1.1564 +@SYMTestExpectedResults Test must not fail
1.1565 +@SYMREQ REQ5792
1.1566 + REQ5793
1.1567 +*/
1.1568 +void ParameterStreamTests()
1.1569 + {
1.1570 + TheTest.Printf(_L("'RSqlParamWriteStream - BindText - invalid statement' panic\r\n"));
1.1571 + PanicTest(TheParamWriteStream_BindText_Statement, EExitPanic, KCategory, 2);
1.1572 +
1.1573 + TheTest.Printf(_L("'RSqlParamWriteStream - BindBinary - invalid statement' panic\r\n"));
1.1574 + PanicTest(TheParamWriteStream_BindBinary_Statement, EExitPanic, KCategory, 2);
1.1575 +
1.1576 + TheTest.Printf(_L("'RSqlParamWriteStream - BindText - invalid parameter index' panic\r\n"));
1.1577 + PanicTest(TheParamWriteStream_BindText_Column, EExitPanic, KCategory, 5);
1.1578 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1579 +
1.1580 + TheTest.Printf(_L("'RSqlParamWriteStream - BindBinary - invalid parameter index' panic\r\n"));
1.1581 + PanicTest(TheParamWriteStream_BindBinary_Column, EExitPanic, KCategory, 5);
1.1582 + TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
1.1583 + }
1.1584 +
1.1585 +/**
1.1586 +@SYMTestCaseID SYSLIB-SQL-CT-1638
1.1587 +@SYMTestCaseDesc RSqlSecurityPolicy panic tests
1.1588 + Run a second thread. The second thread executes given RSqlSecurityPolicy method calling
1.1589 + it with wrong arguments, or in a bad context,...The method panics the second thread.
1.1590 + The main thread captures and checks the panic code.
1.1591 +@SYMTestPriority High
1.1592 +@SYMTestActions RSqlSecurityPolicy panic tests
1.1593 +@SYMTestExpectedResults Test must not fail
1.1594 +@SYMREQ REQ5792
1.1595 + REQ5793
1.1596 +*/
1.1597 +void SecuritySettingsTests()
1.1598 + {
1.1599 + TheTest.Printf(_L("'RSqlSecurityPolicy::SetDbPolicy - invalid policy type' panic\r\n"));
1.1600 + PanicTest(TheSqlSecurity_Set1, EExitPanic, KCategory, 4);
1.1601 +
1.1602 + TheTest.Printf(_L("'RSqlSecurityPolicy::SetPolicy - invalid database object type' panic\r\n"));
1.1603 + PanicTest(TheSqlSecurity_Set2, EExitPanic, KCategory, 4);
1.1604 +
1.1605 + TheTest.Printf(_L("'RSqlSecurityPolicy::SetPolicy - invalid database object name' panic\r\n"));
1.1606 + PanicTest(TheSqlSecurity_Set3, EExitPanic, KCategory, 4);
1.1607 +
1.1608 + TheTest.Printf(_L("'RSqlSecurityPolicy::DbPolicy - invalid policy type' panic\r\n"));
1.1609 + PanicTest(TheSqlSecurity_Get1, EExitPanic, KCategory, 4);
1.1610 +
1.1611 + TheTest.Printf(_L("'RSqlSecurityPolicy::Policy - invalid database object type' panic\r\n"));
1.1612 + PanicTest(TheSqlSecurity_Get2, EExitPanic, KCategory, 4);
1.1613 +
1.1614 + TheTest.Printf(_L("'RSqlSecurityPolicy::Policy - invalid database object name' panic\r\n"));
1.1615 + PanicTest(TheSqlSecurity_Get3, EExitPanic, KCategory, 4);
1.1616 +
1.1617 + TheTest.Printf(_L("'RSqlSecurityPolicy::DefaultPolicy - invalid object' panic\r\n"));
1.1618 + PanicTest(TheSqlSecurity_DefaultPolicy, EExitPanic, KCategory, 2);
1.1619 +
1.1620 + TheTest.Printf(_L("'RSqlSecurityPolicy::Externalize - panic\r\n"));
1.1621 + PanicTest(TheSqlSecurity_Externalize, EExitPanic, KCategory, 2);
1.1622 + }
1.1623 +
1.1624 +/**
1.1625 +@SYMTestCaseID SYSLIB-SQL-CT-1812
1.1626 +@SYMTestCaseDesc TSqlScalarFullSelectQuery panic tests
1.1627 + Run a second thread. The second thread executes given TSqlScalarFullSelectQuery method calling
1.1628 + it with wrong arguments, or in a bad context,...The method panics the second thread.
1.1629 + The main thread captures and checks the panic code.
1.1630 +@SYMTestPriority High
1.1631 +@SYMTestActions TSqlScalarFullSelectQuery panic tests
1.1632 +@SYMTestExpectedResults Test must not fail
1.1633 +@SYMREQ REQ5792
1.1634 + REQ5793
1.1635 +*/
1.1636 +void ScalarFullSelectTests()
1.1637 + {
1.1638 + TheTest.Printf(_L("'TheSqlScalarFullSelectQuery, invalid database' - panic\r\n"));
1.1639 + PanicTest(TheSqlScalarFullSelectQuery_InvalidDatabase, EExitPanic, KCategory, 2);
1.1640 + }
1.1641 +
1.1642 +/**
1.1643 +@SYMTestCaseID SYSLIB-SQL-UT-4092
1.1644 +@SYMTestCaseDesc RSqlBlobReadStream panic tests
1.1645 + Run a second thread. The second thread executes a given RSqlBlobReadStream method calling
1.1646 + the method with wrong arguments, or in a bad context,...The method panics the second thread.
1.1647 + The main thread captures and checks the panic code.
1.1648 +@SYMTestPriority High
1.1649 +@SYMTestActions RSqlBlobReadStream panic tests
1.1650 +@SYMTestExpectedResults Test must not fail
1.1651 +@SYMREQ REQ5792
1.1652 + REQ5793
1.1653 + REQ10410
1.1654 + REQ10411
1.1655 +*/
1.1656 +void BlobReadStreamTests()
1.1657 + {
1.1658 + TheTest.Printf(_L("'RSqlBlobReadStream::OpenL(), invalid database' - panic test 1\r\n"));
1.1659 + PanicTest(TheBlobReadStream_Open_Database1, EExitPanic, KCategory, 2);
1.1660 +
1.1661 + TheTest.Printf(_L("'RSqlBlobReadStream::OpenL(), invalid database' - panic test 2\r\n"));
1.1662 + PanicTest(TheBlobReadStream_Open_Database2, EExitPanic, KCategory, 2);
1.1663 +
1.1664 + TheTest.Printf(_L("'RSqlBlobReadStream::SizeL(), invalid stream' - panic test\r\n"));
1.1665 + PanicTest(TheBlobReadStream_Size_Stream, EExitPanic, KCategory, 2);
1.1666 + }
1.1667 +
1.1668 +/**
1.1669 +@SYMTestCaseID SYSLIB-SQL-UT-4093
1.1670 +@SYMTestCaseDesc RSqlBlobWriteStream panic tests
1.1671 + Run a second thread. The second thread executes a given RSqlBlobWriteStream method calling
1.1672 + the method with wrong arguments, or in a bad context,...The method panics the second thread.
1.1673 + The main thread captures and checks the panic code.
1.1674 +@SYMTestPriority High
1.1675 +@SYMTestActions RSqlBlobWriteStream panic tests
1.1676 +@SYMTestExpectedResults Test must not fail
1.1677 +@SYMREQ REQ5792
1.1678 + REQ5793
1.1679 + REQ10418
1.1680 +*/
1.1681 +void BlobWriteStreamTests()
1.1682 + {
1.1683 + TheTest.Printf(_L("'RSqlBlobWriteStream::OpenL(), invalid database' - panic test 1\r\n"));
1.1684 + PanicTest(TheBlobWriteStream_Open_Database1, EExitPanic, KCategory, 2);
1.1685 +
1.1686 + TheTest.Printf(_L("'RSqlBlobWriteStream::OpenL(), invalid database' - panic test 2\r\n"));
1.1687 + PanicTest(TheBlobWriteStream_Open_Database2, EExitPanic, KCategory, 2);
1.1688 +
1.1689 + TheTest.Printf(_L("'RSqlBlobWriteStream::SizeL(), invalid stream' - panic test\r\n"));
1.1690 + PanicTest(TheBlobWriteStream_Size_Stream, EExitPanic, KCategory, 2);
1.1691 + }
1.1692 +
1.1693 +void DoTests()
1.1694 + {
1.1695 + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1619 RSqlDatabase - panic tests"));
1.1696 + DatabaseTests();
1.1697 +
1.1698 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1620 RSqlStatement - panic tests"));
1.1699 + StatementTests();
1.1700 +
1.1701 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1625 RSqlColumnReadStream - panic tests"));
1.1702 + ColumnStreamTests();
1.1703 +
1.1704 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1626 RSqlParamWriteStream - panic tests"));
1.1705 + ParameterStreamTests();
1.1706 +
1.1707 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1638 RSqlSecurityPolicy - panic tests"));
1.1708 + SecuritySettingsTests();
1.1709 +
1.1710 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1812 TheSqlScalarFullSelectQuery - panic tests"));
1.1711 + ScalarFullSelectTests();
1.1712 +
1.1713 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4092 RSqlBlobReadStream - panic tests"));
1.1714 + BlobReadStreamTests();
1.1715 +
1.1716 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4093 RSqlBlobWriteStream - panic tests"));
1.1717 + BlobWriteStreamTests();
1.1718 + }
1.1719 +
1.1720 +TInt E32Main()
1.1721 + {
1.1722 + TheTest.Title();
1.1723 +
1.1724 + CTrapCleanup* tc = CTrapCleanup::New();
1.1725 +
1.1726 + __UHEAP_MARK;
1.1727 +
1.1728 + CreateTestDir();
1.1729 + DeleteTestFiles();
1.1730 + DoTests();
1.1731 + DeleteTestFiles();
1.1732 +
1.1733 + __UHEAP_MARKEND;
1.1734 +
1.1735 + TheTest.End();
1.1736 + TheTest.Close();
1.1737 +
1.1738 + delete tc;
1.1739 +
1.1740 + User::Heap().Check();
1.1741 + return KErrNone;
1.1742 + }