1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sqlite3api/TEST/t_sqliteapi.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1383 @@
1.4 +/*
1.5 +* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
1.6 +* All rights reserved.
1.7 +* This component and the accompanying materials are made available
1.8 +* under the terms of "Eclipse Public License v1.0"
1.9 +* which accompanies this distribution, and is available
1.10 +* at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.11 +*
1.12 +* Initial Contributors:
1.13 +* Nokia Corporation - initial contribution.
1.14 +*
1.15 +* Contributors:
1.16 +*
1.17 +* Description:
1.18 +*
1.19 +*/
1.20 +
1.21 +
1.22 +
1.23 +#include <stdio.h>
1.24 +#include <stdlib.h>
1.25 +#include <string.h>
1.26 +#include <wchar.h>
1.27 +#include <errno.h>
1.28 +#include <sys/stat.h>
1.29 +#include <pthread.h>
1.30 +#include <semaphore.h>
1.31 +#include <unistd.h>
1.32 +#include <sqlite3.h>
1.33 +#include "sqliteTestUtl.h"
1.34 +
1.35 +static sqlite3* TheDb = 0;
1.36 +static sqlite3* TheDb2 = 0;
1.37 +static sqlite3_stmt* TheStmt = 0;
1.38 +static sqlite3_stmt* TheStmt2 = 0;
1.39 +const char* const TheTestDirName = "c:\\test";
1.40 +const char* const TheTestDbName = "c:\\test\\a1.db";
1.41 +
1.42 +const int KTestThreadCount = 2;
1.43 +static int TheInsertRecCnt[KTestThreadCount] = {0, 0};
1.44 +static int TheLockErrCnt[KTestThreadCount] = {0, 0};
1.45 +const char* const KThreadNames[KTestThreadCount] = {"THRD1", "THRD2"};
1.46 +static sem_t TheSemaphores[KTestThreadCount];
1.47 +
1.48 +#define UNUSED_ARG(a) (a) = (a)
1.49 +
1.50 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.51 +
1.52 +/* The standard C library does not have abs() function with a double argument */
1.53 +static double dabs(double arg)
1.54 + {
1.55 + return arg < 0.0 ? -arg : arg;
1.56 + }
1.57 +
1.58 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.59 +
1.60 +static void TestEnvDestroy()
1.61 + {
1.62 + if(TheStmt2)
1.63 + {
1.64 + (void)sqlite3_finalize(TheStmt2);
1.65 + TheStmt2 = 0;
1.66 + }
1.67 + if(TheStmt)
1.68 + {
1.69 + (void)sqlite3_finalize(TheStmt);
1.70 + TheStmt = 0;
1.71 + }
1.72 + if(TheDb2)
1.73 + {
1.74 + (void)sqlite3_close(TheDb2);
1.75 + TheDb2 = 0;
1.76 + }
1.77 + if(TheDb)
1.78 + {
1.79 + (void)sqlite3_close(TheDb);
1.80 + TheDb = 0;
1.81 + }
1.82 + (void)remove(TheTestDbName);
1.83 + }
1.84 +
1.85 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.86 +/* Test macros and functions */
1.87 +
1.88 +static void Check1(int aValue, int aLine)
1.89 + {
1.90 + if(!aValue)
1.91 + {
1.92 + if(TheDb)
1.93 + {
1.94 + const char* errmsg = sqlite3_errmsg(TheDb);
1.95 + PrintS("*** DB1: SQLITE error message: %s\r\n", errmsg);
1.96 + }
1.97 + if(TheDb2)
1.98 + {
1.99 + const char* errmsg = sqlite3_errmsg(TheDb2);
1.100 + PrintS("*** DB2: SQLITE error message: %s\r\n", errmsg);
1.101 + }
1.102 + PrintI("*** Test check failed! Line=%d\r\n", aLine);
1.103 + TestEnvDestroy();
1.104 + TestAbort(aLine);
1.105 + }
1.106 + }
1.107 +
1.108 +static void Check2(int aValue, int aExpected, int aLine)
1.109 + {
1.110 + if(aValue != aExpected)
1.111 + {
1.112 + if(TheDb)
1.113 + {
1.114 + const char* errmsg = sqlite3_errmsg(TheDb);
1.115 + PrintS("*** DB1: SQLITE error message: %s\r\n", errmsg);
1.116 + }
1.117 + if(TheDb2)
1.118 + {
1.119 + const char* errmsg = sqlite3_errmsg(TheDb2);
1.120 + PrintS("*** DB2: SQLITE error message: %s\r\n", errmsg);
1.121 + }
1.122 + PrintIII("*** Test check failed! Line=%d. Expected error: %d, got: %d\r\n", aLine, aExpected, aValue);
1.123 + TestEnvDestroy();
1.124 + TestAbort(aLine);
1.125 + }
1.126 + }
1.127 +
1.128 +static void Check64(sqlite_int64 aValue, sqlite_int64 aExpected, int aLine)
1.129 + {
1.130 + if(aValue != aExpected)
1.131 + {
1.132 + if(TheDb)
1.133 + {
1.134 + const char* errmsg = sqlite3_errmsg(TheDb);
1.135 + PrintS("*** DB1: SQLITE error message: %s\r\n", errmsg);
1.136 + }
1.137 + if(TheDb2)
1.138 + {
1.139 + const char* errmsg = sqlite3_errmsg(TheDb2);
1.140 + PrintS("*** DB2: SQLITE error message: %s\r\n", errmsg);
1.141 + }
1.142 + PrintII64I64("*** Test check failed! Line=%ld. Expected error: %ld, got: %d\r\n", aLine, aExpected, aValue);
1.143 + TestEnvDestroy();
1.144 + TestAbort(aLine);
1.145 + }
1.146 + }
1.147 +#define TEST(arg) Check1((arg), __LINE__)
1.148 +#define TEST2(aValue, aExpected) Check2(aValue, aExpected, __LINE__)
1.149 +#define TEST64(aValue, aExpected) Check64(aValue, aExpected, __LINE__)
1.150 +
1.151 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.152 +
1.153 +static void TestEnvCreate()
1.154 + {
1.155 + int err;
1.156 + (void)remove(TheTestDbName);
1.157 + err = mkdir(TheTestDirName, S_IREAD | S_IWRITE);
1.158 + if(err != 0)
1.159 + {
1.160 + err = errno;
1.161 + }
1.162 + TEST(err == 0 || err == EEXIST);
1.163 +
1.164 + //Creating the private data cage directory here to suppress a capability warning
1.165 + CreatePrivateDir();
1.166 + }
1.167 +
1.168 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.169 +/* Callbacks */
1.170 +
1.171 +static int exec_callback(void* udata, int argc, char** argv, char** colname)
1.172 + {
1.173 + UNUSED_ARG(udata);
1.174 + UNUSED_ARG(argc);
1.175 + UNUSED_ARG(argv);
1.176 + UNUSED_ARG(colname);
1.177 + return 0;
1.178 + }
1.179 +
1.180 +static int authorizer_callback(void* udata, int optype, const char* name1, const char* name2, const char* name, const char* viewname)
1.181 + {
1.182 + UNUSED_ARG(udata);
1.183 + UNUSED_ARG(optype);
1.184 + UNUSED_ARG(name1);
1.185 + UNUSED_ARG(name2);
1.186 + UNUSED_ARG(name);
1.187 + UNUSED_ARG(viewname);
1.188 + return SQLITE_OK;
1.189 + }
1.190 +
1.191 +static int commit_hook(void* udata)
1.192 + {
1.193 + UNUSED_ARG(udata);
1.194 + return SQLITE_OK;
1.195 + }
1.196 +
1.197 +static void rollback_hook(void* udata)
1.198 + {
1.199 + UNUSED_ARG(udata);
1.200 + }
1.201 +
1.202 +static void update_hook(void* udata, int type, char const* dbname, char const* tblname, sqlite_int64 rowid)
1.203 + {
1.204 + UNUSED_ARG(udata);
1.205 + UNUSED_ARG(type);
1.206 + UNUSED_ARG(dbname);
1.207 + UNUSED_ARG(tblname);
1.208 + UNUSED_ARG(rowid);
1.209 + }
1.210 +
1.211 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.212 +
1.213 +/**
1.214 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4001
1.215 +@SYMTestCaseDesc sqlite3_exec() tests.
1.216 + List of called SQLITE3 functions:
1.217 + - sqlite3_exec;
1.218 + - sqlite3_errcode;
1.219 + - sqlite3_errmsg;
1.220 + - sqlite3_last_insert_rowid;
1.221 + - sqlite3_changes;
1.222 + - sqlite3_total_changes;
1.223 + - sqlite3_get_autocommit;
1.224 +@SYMTestPriority High
1.225 +@SYMTestActions sqlite3_exec() tests.
1.226 +@SYMTestExpectedResults Test must not fail
1.227 +@SYMREQ REQ8782
1.228 +*/
1.229 +static void TestExec()
1.230 + {
1.231 + int err;
1.232 + sqlite_int64 lastrowid;
1.233 + int val;
1.234 +
1.235 + TEST(TheDb != 0);
1.236 +
1.237 + err = sqlite3_exec(TheDb, "CREATE TABLE A(F1 INTEGER, F2 BIGINT, F3 REAL, F4 TEXT, F5 BLOB)", &exec_callback, 0, 0);
1.238 + TEST2(err, SQLITE_OK);
1.239 +
1.240 + err = sqlite3_exec(TheDb, "INSERT INTO A VALUES(1, 1234567891234, 56.12, 'TEXT', x'313233343536')", &exec_callback, 0, 0);
1.241 + TEST2(err, SQLITE_OK);
1.242 +
1.243 + err = sqlite3_errcode(TheDb);
1.244 + TEST2(err, SQLITE_OK);
1.245 +
1.246 + (void)sqlite3_errmsg(TheDb);
1.247 +
1.248 + lastrowid = sqlite3_last_insert_rowid(TheDb);
1.249 + TEST(lastrowid > 0LL);
1.250 +
1.251 + val = sqlite3_changes(TheDb);
1.252 + TEST2(val, 1);
1.253 +
1.254 + val = sqlite3_total_changes(TheDb);
1.255 + TEST(val >= 1);
1.256 +
1.257 + val = sqlite3_get_autocommit(TheDb);
1.258 + TEST(val != 0);
1.259 + }
1.260 +
1.261 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.262 +
1.263 +static void DoTestStatement()
1.264 + {
1.265 + int err, val;
1.266 + sqlite_int64 val64;
1.267 + double dblval;
1.268 + const unsigned char* textval;
1.269 + const unsigned short* textval16;
1.270 + const unsigned char* blob;
1.271 + const char *coltype, *colname;
1.272 + const unsigned short *coltype16, *colname16;
1.273 + sqlite3* db;
1.274 +
1.275 + TEST(TheDb != 0);
1.276 + TEST(TheStmt != 0);
1.277 +
1.278 + val = sqlite3_column_count(TheStmt);
1.279 + TEST2(val, 5);
1.280 +
1.281 + db = sqlite3_db_handle(TheStmt);
1.282 + TEST2((unsigned int)db, (unsigned int)TheDb);
1.283 +
1.284 + err = sqlite3_step(TheStmt);
1.285 + TEST2(err, SQLITE_ROW);
1.286 +
1.287 +#ifdef SQLITE_ENABLE_COLUMN_METADATA
1.288 + sqlite3_column_database_name(TheStmt, 0);
1.289 + sqlite3_column_database_name16(TheStmt, 1);
1.290 + sqlite3_column_table_name(TheStmt, 2);
1.291 + sqlite3_column_table_name16(TheStmt, 3);
1.292 + sqlite3_column_origin_name(TheStmt, 4);
1.293 + sqlite3_column_origin_name16(TheStmt, 0);
1.294 +#endif
1.295 +
1.296 + coltype = sqlite3_column_decltype(TheStmt, 0);
1.297 + TEST2(strcmp(coltype, "INTEGER"), 0);
1.298 +
1.299 + coltype16 = (const unsigned short*)sqlite3_column_decltype16(TheStmt, 2);
1.300 + TEST2(wcscmp(coltype16, L"REAL"), 0);
1.301 +
1.302 + colname = sqlite3_column_name(TheStmt, 1);
1.303 + TEST2(strcmp(colname, "F2"), 0);
1.304 +
1.305 + colname16 = (const unsigned short *)sqlite3_column_name16(TheStmt, 4);
1.306 + TEST2(wcscmp(colname16, L"F5"), 0);
1.307 +
1.308 + val = sqlite3_column_int(TheStmt, 0);
1.309 + TEST2(val, 1);
1.310 +
1.311 + val64 = sqlite3_column_int64(TheStmt, 1);
1.312 + TEST64(val64, 1234567891234LL);
1.313 +
1.314 + dblval = sqlite3_column_double(TheStmt, 2);
1.315 + TEST(dabs(dblval - 56.12) < 0.00001);
1.316 +
1.317 + textval = sqlite3_column_text(TheStmt, 3);
1.318 + TEST2(strcmp((const char*)textval, "TEXT"), 0);
1.319 +
1.320 + textval16 = sqlite3_column_text16(TheStmt, 3);
1.321 + TEST2(wcscmp(textval16, L"TEXT"), 0);
1.322 +
1.323 + blob = (const unsigned char*)sqlite3_column_blob(TheStmt, 4);
1.324 + TEST2(memcmp(blob, "123456", 6), 0);
1.325 +
1.326 + err = sqlite3_step(TheStmt);
1.327 + TEST2(err, SQLITE_DONE);
1.328 + }
1.329 +
1.330 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.331 +
1.332 +/**
1.333 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4002
1.334 +@SYMTestCaseDesc Statement handle SQLITE3 tests.
1.335 + List of called SQLITE3 functions:
1.336 + - sqlite3_complete;
1.337 + - sqlite3_complete16;
1.338 + - sqlite3_prepare;
1.339 + - sqlite3_finalize;
1.340 + - sqlite3_column_count;
1.341 + - sqlite3_db_handle;
1.342 + - sqlite3_step;
1.343 + - sqlite3_column_decltype;
1.344 + - sqlite3_column_decltype16;
1.345 + - sqlite3_column_name;
1.346 + - sqlite3_column_name16;
1.347 + - sqlite3_column_int;
1.348 + - sqlite3_column_int64;
1.349 + - sqlite3_column_double;
1.350 + - sqlite3_column_text;
1.351 + - sqlite3_column_text16;
1.352 + - sqlite3_column_blob;
1.353 +@SYMTestPriority High
1.354 +@SYMTestActions Statement handle SQLITE3 tests.
1.355 +@SYMTestExpectedResults Test must not fail
1.356 +@SYMREQ REQ8782
1.357 +*/
1.358 +static void TestStatement1()
1.359 + {
1.360 + const char* tail = 0;
1.361 + int err;
1.362 +
1.363 + TEST(TheDb != 0);
1.364 + TEST(!TheStmt);
1.365 +
1.366 + err = sqlite3_complete("SELECT * FROM A;");
1.367 + TEST(err != 0);
1.368 +
1.369 + err = sqlite3_complete16(L"SELECT * FROM A;");
1.370 + TEST(err != 0);
1.371 +
1.372 + err = sqlite3_prepare(TheDb, "SELECT * FROM A", -1, &TheStmt, &tail);
1.373 + TEST2(err, SQLITE_OK);
1.374 + TEST((unsigned int)TheStmt);
1.375 + TEST(!tail || strlen(tail) == 0);
1.376 +
1.377 + DoTestStatement();
1.378 +
1.379 + err = sqlite3_finalize(TheStmt);
1.380 + TEST2(err, SQLITE_OK);
1.381 + TheStmt = 0;
1.382 + }
1.383 +
1.384 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.385 +
1.386 +/**
1.387 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4003
1.388 +@SYMTestCaseDesc Statement handle SQLITE3 tests.
1.389 + List of called SQLITE3 functions:
1.390 + - sqlite3_prepare;
1.391 + - sqlite3_finalize;
1.392 + - sqlite3_bind_int;
1.393 + - sqlite3_bind_int64;
1.394 + - sqlite3_bind_double;
1.395 + - sqlite3_bind_text;
1.396 +@SYMTestPriority High
1.397 +@SYMTestActions Statement handle SQLITE3 tests.
1.398 +@SYMTestExpectedResults Test must not fail
1.399 +@SYMREQ REQ8782
1.400 +*/
1.401 +static void TestStatement2()
1.402 + {
1.403 + const char* tail = 0;
1.404 + int err;
1.405 +
1.406 + TEST(TheDb != 0);
1.407 + TEST(!TheStmt);
1.408 +
1.409 + err = sqlite3_prepare(TheDb, "SELECT * FROM A WHERE F1=? AND F2=? AND F3<? AND F4=?", -1, &TheStmt, &tail);
1.410 + TEST2(err, SQLITE_OK);
1.411 + TEST((unsigned int)TheStmt);
1.412 + TEST(!tail || strlen(tail) == 0);
1.413 +
1.414 + err = sqlite3_bind_int(TheStmt, 1, 1);
1.415 + TEST2(err, SQLITE_OK);
1.416 +
1.417 + err = sqlite3_bind_int64(TheStmt, 2, 1234567891234LL);
1.418 + TEST2(err, SQLITE_OK);
1.419 +
1.420 + err = sqlite3_bind_double(TheStmt, 3, 70.0);
1.421 + TEST2(err, SQLITE_OK);
1.422 +
1.423 + err = sqlite3_bind_text(TheStmt, 4, "TEXT", -1, SQLITE_STATIC);
1.424 + TEST2(err, SQLITE_OK);
1.425 +
1.426 + DoTestStatement();
1.427 +
1.428 + err = sqlite3_finalize(TheStmt);
1.429 + TEST2(err, SQLITE_OK);
1.430 + TheStmt = 0;
1.431 + }
1.432 +
1.433 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.434 +
1.435 +/**
1.436 +@SYMTestCaseID PDS-SQLITE3-UT-4038
1.437 +@SYMTestCaseDesc Database handle SQLITE3 tests.
1.438 + List of called SQLITE3 functions:
1.439 + - sqlite3_db_status;
1.440 + - sqlite3_file_control;
1.441 + - sqlite3_limit;
1.442 + - sqlite3_next_stmt;
1.443 + - sqlite3_randomness;
1.444 +@SYMTestPriority High
1.445 +@SYMTestActions Database handle SQLITE3 tests.
1.446 +@SYMTestExpectedResults Test must not fail
1.447 +@SYMREQ REQ10424
1.448 +*/
1.449 +static void TestSqliteApi2()
1.450 + {
1.451 + int used = 0;
1.452 + int high = 0;
1.453 + int lock = -1;
1.454 + int limit = 0;
1.455 + sqlite3_stmt* next = 0;
1.456 + int err;
1.457 + unsigned char buf[10];
1.458 +
1.459 + TEST(TheDb != 0);
1.460 +
1.461 + err = sqlite3_db_status(TheDb, SQLITE_DBSTATUS_LOOKASIDE_USED, &used, &high, 0);
1.462 + TEST2(err, SQLITE_OK);
1.463 + PrintI("Lookaside slots: %d\r\n", used);
1.464 + PrintI("Max used lookaside slots: %d\r\n", high);
1.465 +
1.466 + err = sqlite3_file_control(TheDb, "main", SQLITE_FCNTL_LOCKSTATE, &lock);
1.467 + TEST2(err, SQLITE_OK);
1.468 + TEST2(lock, SQLITE_LOCK_NONE);
1.469 +
1.470 + limit = sqlite3_limit(TheDb, SQLITE_LIMIT_LENGTH, -1);
1.471 + TEST(limit > 0);
1.472 +
1.473 + next = sqlite3_next_stmt(TheDb, 0);
1.474 + TEST(!next);
1.475 +
1.476 + memset(buf, 0, sizeof(buf));
1.477 + sqlite3_randomness(8, buf);
1.478 +
1.479 + memset(buf, 0, sizeof(buf));
1.480 + sqlite3_randomness(7, buf);
1.481 +
1.482 + memset(buf, 0, sizeof(buf));
1.483 + sqlite3_randomness(3, buf);
1.484 +
1.485 + }
1.486 +
1.487 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.488 +
1.489 +/**
1.490 +@SYMTestCaseID PDS-SQLITE3-UT-4039
1.491 +@SYMTestCaseDesc SQLITE3 - blob API tests.
1.492 + List of called SQLITE3 functions:
1.493 + - sqlite3_bind_zeroblob;
1.494 + - sqlite3_blob_bytes;
1.495 + - sqlite3_blob_close;
1.496 + - sqlite3_blob_open;
1.497 + - sqlite3_blob_read;
1.498 + - sqlite3_blob_write;
1.499 + - sqlite3_sql;
1.500 +@SYMTestPriority High
1.501 +@SYMTestActions SQLITE3 - blob API tests.
1.502 +@SYMTestExpectedResults Test must not fail
1.503 +@SYMREQ REQ10424
1.504 +*/
1.505 +static void TestSqliteBlobApi()
1.506 + {
1.507 + int err;
1.508 + const char* tail = 0;
1.509 + sqlite3_blob* blob = 0;
1.510 + int bytes = 0;
1.511 + const char KBlobData[] = "ABCDEFGH";
1.512 + char sql[100];
1.513 + const int KBlobLen = strlen(KBlobData);
1.514 + const char* sql2 = 0;
1.515 + const char KSqlFmt[] = "UPDATE BlobTbl SET B=:Prm WHERE ROWID=1";
1.516 +
1.517 + TEST(TheDb != 0);
1.518 + TEST(!TheStmt);
1.519 +
1.520 + /* Create the table, insert one record with a blob */
1.521 +
1.522 + err = sqlite3_exec(TheDb, "CREATE TABLE BlobTbl(I INTEGER PRIMARY KEY, B BLOB)", 0, 0, 0);
1.523 + TEST2(err, SQLITE_OK);
1.524 +
1.525 + sprintf(sql, "INSERT INTO BlobTbl VALUES(1, zeroblob(%d))", KBlobLen);
1.526 + err = sqlite3_exec(TheDb, sql, 0, 0, 0);
1.527 + TEST2(err, SQLITE_OK);
1.528 +
1.529 + err = sqlite3_prepare_v2(TheDb, KSqlFmt, -1, &TheStmt, &tail);
1.530 + TEST2(err, SQLITE_OK);
1.531 + TEST(TheStmt != 0);
1.532 +
1.533 + sql2 = sqlite3_sql(TheStmt);
1.534 + TEST(sql2 != NULL);
1.535 + err = strcmp(sql2, KSqlFmt);
1.536 + TEST2(err, 0);
1.537 +
1.538 + err = sqlite3_bind_zeroblob(TheStmt, 1, KBlobLen);
1.539 + TEST2(err, SQLITE_OK);
1.540 +
1.541 + err = sqlite3_step(TheStmt);
1.542 + TEST2(err, SQLITE_DONE);
1.543 +
1.544 + err = sqlite3_finalize(TheStmt);
1.545 + TEST2(err, SQLITE_OK);
1.546 + TheStmt = 0;
1.547 +
1.548 + /* Open the blob and write to it */
1.549 +
1.550 + err = sqlite3_blob_open(TheDb, "main", "BlobTbl", "B", 1, 1, &blob);
1.551 + TEST2(err, SQLITE_OK);
1.552 + TEST(blob != 0);
1.553 +
1.554 + bytes = sqlite3_blob_bytes(blob);
1.555 + TEST2(bytes, KBlobLen);
1.556 +
1.557 + err = sqlite3_blob_write(blob, KBlobData, KBlobLen, 0);
1.558 + TEST2(err, SQLITE_OK);
1.559 +
1.560 + err = sqlite3_blob_close(blob);
1.561 + TEST2(err, SQLITE_OK);
1.562 + blob = 0;
1.563 +
1.564 + /* Open the blob and read from it */
1.565 +
1.566 + err = sqlite3_blob_open(TheDb, "main", "BlobTbl", "B", 1, 1, &blob);
1.567 + TEST2(err, SQLITE_OK);
1.568 + TEST(blob != 0);
1.569 +
1.570 + bytes = sqlite3_blob_bytes(blob);
1.571 + TEST2(bytes, KBlobLen);
1.572 +
1.573 + err = sqlite3_blob_read(blob, sql, KBlobLen, 0);
1.574 + TEST2(err, SQLITE_OK);
1.575 + sql[bytes] = 0;
1.576 +
1.577 + err = sqlite3_blob_close(blob);
1.578 + TEST2(err, SQLITE_OK);
1.579 + blob = 0;
1.580 +
1.581 + err = strcmp(sql, KBlobData);
1.582 + TEST2(err, 0);
1.583 +
1.584 + err = sqlite3_exec(TheDb, "DROP TABLE BlobTbl", 0, 0, 0);
1.585 + TEST2(err, SQLITE_OK);
1.586 + }
1.587 +
1.588 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.589 +
1.590 +/**
1.591 +@SYMTestCaseID PDS-SQLITE3-UT-4040
1.592 +@SYMTestCaseDesc SQLITE3 - mutex API tests.
1.593 + List of called SQLITE3 functions:
1.594 + - sqlite3_mutex_alloc;
1.595 + - sqlite3_mutex_enter;
1.596 + - sqlite3_mutex_free;
1.597 + - sqlite3_mutex_held;
1.598 + - sqlite3_mutex_leave;
1.599 + - sqlite3_mutex_notheld;
1.600 + - sqlite3_mutex_try;
1.601 +@SYMTestPriority High
1.602 +@SYMTestActions SQLITE3 - mutex API tests.
1.603 +@SYMTestExpectedResults Test must not fail
1.604 +@SYMREQ REQ10424
1.605 +*/
1.606 +static void TestSqliteMutexApi()
1.607 + {
1.608 + sqlite3_mutex* mtx = 0;
1.609 + int err;
1.610 + int type;
1.611 +
1.612 + TEST(TheDb != 0);
1.613 +
1.614 + for(type=SQLITE_MUTEX_FAST;type<=SQLITE_MUTEX_STATIC_LRU2;++type)
1.615 + {
1.616 + mtx = sqlite3_mutex_alloc(type);
1.617 + TEST(mtx != NULL);
1.618 +
1.619 + err = sqlite3_mutex_try(mtx);
1.620 + TEST(err == SQLITE_BUSY || err == SQLITE_OK);
1.621 +
1.622 + sqlite3_mutex_enter(mtx);
1.623 +
1.624 + sqlite3_mutex_leave(mtx);
1.625 +
1.626 + if(type <= SQLITE_MUTEX_RECURSIVE)
1.627 + {
1.628 + sqlite3_mutex_free(mtx);
1.629 + }
1.630 + mtx = 0;
1.631 + }
1.632 + }
1.633 +
1.634 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.635 +
1.636 +/**
1.637 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4004
1.638 +@SYMTestCaseDesc Database handle SQLITE3 tests.
1.639 + List of called SQLITE3 functions:
1.640 + - sqlite3_config;
1.641 + - sqlite3_initialize;
1.642 + - sqlite3_threadsafe;
1.643 + - sqlite3_vfs_find;
1.644 + - sqlite3_open;
1.645 + - sqlite3_db_config;
1.646 + - sqlite3_libversion;
1.647 + - sqlite3_libversion_number;
1.648 + - sqlite3_set_authorizer;
1.649 + - sqlite3_commit_hook;
1.650 + - sqlite3_rollback_hook;
1.651 + - sqlite3_update_hook;
1.652 + - sqlite3_close;
1.653 + - sqlite3_shutdown;
1.654 +@SYMTestPriority High
1.655 +@SYMTestActions Database handle SQLITE3 tests.
1.656 +@SYMTestExpectedResults Test must not fail
1.657 +@SYMREQ REQ8782
1.658 +*/
1.659 +static void TestSqliteApi()
1.660 + {
1.661 + void* prev = 0;
1.662 + const char* libverstr = 0;
1.663 + int libvernum = 0;
1.664 + int err;
1.665 + int threadSafe = -1;
1.666 + sqlite3_vfs* vfs = 0;
1.667 +
1.668 + TEST(!TheDb);
1.669 +
1.670 + TestStart("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4004: Test \"sqlite3_config()\"");
1.671 + err = sqlite3_config(SQLITE_CONFIG_MEMSTATUS, 0);
1.672 + TEST2(err, SQLITE_OK);
1.673 +
1.674 + TestNext("Test \"sqlite3_initialize()\"");
1.675 + err = sqlite3_initialize();
1.676 + TEST2(err, SQLITE_OK);
1.677 +
1.678 + TestNext("Test \"sqlite3_threadsafe()\"");
1.679 + threadSafe = sqlite3_threadsafe();
1.680 + PrintI("SQLITE_THREADSAFE=%d\r\n", threadSafe);
1.681 +
1.682 + vfs = sqlite3_vfs_find(0);
1.683 + TEST(vfs != NULL);
1.684 + PrintS("Vfs name=\"%s\"\r\n", vfs->zName);
1.685 +
1.686 + err = sqlite3_open(TheTestDbName, &TheDb);
1.687 + TEST2(err, SQLITE_OK);
1.688 + TEST(TheDb != 0);
1.689 +
1.690 + err = sqlite3_db_config(TheDb, SQLITE_DBCONFIG_LOOKASIDE, 0, 128, 100);
1.691 + TEST2(err, SQLITE_OK);
1.692 +
1.693 + libverstr = sqlite3_libversion();
1.694 + libvernum = sqlite3_libversion_number();
1.695 + PrintSI("SQLITE version: \"%s\", Number: %d\r\n", libverstr, libvernum);
1.696 +
1.697 + err = sqlite3_set_authorizer(TheDb, &authorizer_callback, 0);
1.698 + TEST2(err, SQLITE_OK);
1.699 +
1.700 + prev = sqlite3_commit_hook(TheDb, &commit_hook, 0);
1.701 + TEST(!prev);
1.702 + prev = sqlite3_rollback_hook(TheDb, &rollback_hook, 0);
1.703 + TEST(!prev);
1.704 + prev = sqlite3_update_hook(TheDb, &update_hook, 0);
1.705 + TEST(!prev);
1.706 +
1.707 + TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4001: Test \"sqlite3\" handle API");
1.708 + TestExec();
1.709 + TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4002: Test \"sqlite3_stmt\" handle API-1");
1.710 + TestStatement1();
1.711 + TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4003: Test \"sqlite3_stmt\" handle API-2");
1.712 + TestStatement2();
1.713 + TestNext("@SYMTestCaseID:PDS-SQLITE3-UT-4038: Test more sqlite3 API");
1.714 + TestSqliteApi2();
1.715 + TestNext("@SYMTestCaseID:PDS-SQLITE3-UT-4039: Test blob API");
1.716 + TestSqliteBlobApi();
1.717 + TestNext("@SYMTestCaseID:PDS-SQLITE3-UT-4040: Test mutex API");
1.718 + TestSqliteMutexApi();
1.719 +
1.720 + err = sqlite3_close(TheDb);
1.721 + TEST2(err, SQLITE_OK);
1.722 + TheDb = 0;
1.723 +
1.724 + TestNext("Test \"sqlite3_shutdown()\"");
1.725 + err = sqlite3_shutdown();
1.726 + TEST2(err, SQLITE_OK);
1.727 +
1.728 + err = remove(TheTestDbName);
1.729 + TEST2(err, 0);
1.730 + }
1.731 +
1.732 +static void CreateTestDb()
1.733 + {
1.734 + int err;
1.735 +
1.736 + err = sqlite3_open(TheTestDbName, &TheDb);
1.737 + TEST2(err, SQLITE_OK);
1.738 + TEST(TheDb != 0);
1.739 +
1.740 + err = sqlite3_exec(TheDb, "CREATE TABLE A(F1 INTEGER, F2 BIGINT, F3 REAL, F4 TEXT, F5 BLOB)", &exec_callback, 0, 0);
1.741 + TEST2(err, SQLITE_OK);
1.742 +
1.743 + err = sqlite3_exec(TheDb, "INSERT INTO A VALUES(1, 1234567891234, 56.12, 'TEXT', x'313233343536')", &exec_callback, 0, 0);
1.744 + TEST2(err, SQLITE_OK);
1.745 +
1.746 + err = sqlite3_close(TheDb);
1.747 + TEST2(err, SQLITE_OK);
1.748 + TheDb = 0;
1.749 + }
1.750 +
1.751 +/**
1.752 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4005
1.753 +@SYMTestCaseDesc Two database connections in the same thread - "read operations" test.
1.754 + The test creates two connections to the same database in the same thread.
1.755 + Both connections prepare a SELECT statement and call sqlite3_step() each
1.756 + thus testing that the file locking in the OS porting layer works properly
1.757 + (the SQLite library permits multiple connections to read from the database simultaneously,
1.758 + using a shared file locking mode).
1.759 + List of called SQLITE3 functions:
1.760 + - sqlite3_open;
1.761 + - sqlite3_prepare;
1.762 + - sqlite3_step;
1.763 + - sqlite3_finalize;
1.764 + - sqlite3_close;
1.765 +@SYMTestPriority High
1.766 +@SYMTestActions Two database connections in the same thread - "read operations" test.
1.767 +@SYMTestExpectedResults Test must not fail
1.768 +@SYMREQ REQ8782
1.769 +*/
1.770 +static void TwoReadersTest()
1.771 + {
1.772 + int err;
1.773 + const char* tail = 0;
1.774 +
1.775 + TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4005: Test two readers");
1.776 +
1.777 + CreateTestDb();
1.778 +
1.779 + err = sqlite3_open(TheTestDbName, &TheDb);
1.780 + TEST2(err, SQLITE_OK);
1.781 + TEST(TheDb != 0);
1.782 +
1.783 + err = sqlite3_open(TheTestDbName, &TheDb2);
1.784 + TEST2(err, SQLITE_OK);
1.785 + TEST(TheDb2 != 0);
1.786 +
1.787 + /* ------------- */
1.788 + err = sqlite3_prepare(TheDb, "SELECT * FROM A", -1, &TheStmt, &tail);
1.789 + TEST2(err, SQLITE_OK);
1.790 + TEST((unsigned int)TheStmt);
1.791 + TEST(!tail || strlen(tail) == 0);
1.792 +
1.793 + err = sqlite3_prepare(TheDb2, "SELECT * FROM A", -1, &TheStmt2, &tail);
1.794 + TEST2(err, SQLITE_OK);
1.795 + TEST((unsigned int)TheStmt2);
1.796 + TEST(!tail || strlen(tail) == 0);
1.797 +
1.798 + err = sqlite3_step(TheStmt);
1.799 + TEST2(err, SQLITE_ROW);
1.800 +
1.801 + err = sqlite3_step(TheStmt2);
1.802 + TEST2(err, SQLITE_ROW);
1.803 +
1.804 + /* ------------- */
1.805 +
1.806 + (void)sqlite3_finalize(TheStmt2);
1.807 + TheStmt2 = 0;
1.808 +
1.809 + (void)sqlite3_finalize(TheStmt);
1.810 + TheStmt = 0;
1.811 +
1.812 + err = sqlite3_close(TheDb2);
1.813 + TEST2(err, SQLITE_OK);
1.814 + TheDb2 = 0;
1.815 +
1.816 + err = sqlite3_close(TheDb);
1.817 + TEST2(err, SQLITE_OK);
1.818 + TheDb = 0;
1.819 +
1.820 + (void)remove(TheTestDbName);
1.821 + }
1.822 +
1.823 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.824 +
1.825 +/**
1.826 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4006
1.827 +@SYMTestCaseDesc Two database connections in the same thread - "write operations" test.
1.828 + The test creates two connections to the same database in the same thread.
1.829 + Both connections attempt to execute INSERT statements using an explicit transaction
1.830 + thus testing that the file locking in the OS porting layer works properly
1.831 + (the SQLite library permits only one connection at a time to write to the database).
1.832 + List of called SQLITE3 functions:
1.833 + - sqlite3_open;
1.834 + - sqlite3_exec;
1.835 + - sqlite3_free;
1.836 + - sqlite3_close;
1.837 + Test case steps:
1.838 + - Two connections to the same database created;
1.839 + - Both connections begin a deferred transaction;
1.840 + - The first connection executes an INSERT statement. The database file should be locked
1.841 + for a writing by this connection;
1.842 + - The second connection attempts to execute an INSERT statement too. The operation should fail,
1.843 + because the database file has been locked by the first connection;
1.844 + - The first connection completes the transaction executing a ROLLBACK statement;
1.845 + - The second connection makes second attempt to execute the INSERT statement. The execution should
1.846 + complete without errors;
1.847 +@SYMTestPriority High
1.848 +@SYMTestActions Two database connections in the same thread - "write operations" test.
1.849 +@SYMTestExpectedResults Test must not fail
1.850 +@SYMREQ REQ8782
1.851 +*/
1.852 +static void TwoWritersTest()
1.853 + {
1.854 + int err;
1.855 + char* errmsg = 0;
1.856 +
1.857 + TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4006: Test two writers");
1.858 +
1.859 + CreateTestDb();
1.860 +
1.861 + err = sqlite3_open(TheTestDbName, &TheDb);
1.862 + TEST2(err, SQLITE_OK);
1.863 + TEST(TheDb != 0);
1.864 +
1.865 + err = sqlite3_open(TheTestDbName, &TheDb2);
1.866 + TEST2(err, SQLITE_OK);
1.867 + TEST(TheDb2 != 0);
1.868 +
1.869 + /* ------------- */
1.870 + Print("Two database connections, begin a transaction in each of them.\r\n");
1.871 + err = sqlite3_exec(TheDb, "BEGIN", 0, 0, 0);
1.872 + TEST2(err, SQLITE_OK);
1.873 +
1.874 + err = sqlite3_exec(TheDb2, "BEGIN", 0, 0, 0);
1.875 + TEST2(err, SQLITE_OK);
1.876 +
1.877 + Print("Connection 1. Execute an \"INSERT\" statement. Success.\r\n");
1.878 + err = sqlite3_exec(TheDb, "INSERT INTO A VALUES(0,0,0.0,'',x'00')", 0, 0, &errmsg);
1.879 + if(errmsg)
1.880 + {
1.881 + PrintSI("Err msg: %s. Err: %d.\r\n", errmsg, err);
1.882 + sqlite3_free(errmsg);
1.883 + }
1.884 + errmsg = 0;
1.885 + TEST2(err, SQLITE_OK);
1.886 +
1.887 + Print("Connection 2. Execute an \"INSERT\" statement. Failure. The database is locked.\r\n");
1.888 + err = sqlite3_exec(TheDb2, "INSERT INTO A VALUES(0,0,0.0,'',x'00')", 0, 0, &errmsg);
1.889 + if(errmsg)
1.890 + {
1.891 + PrintSI("*** %s. Err: %d.\r\n", errmsg, err);
1.892 + sqlite3_free(errmsg);
1.893 + }
1.894 + errmsg = 0;
1.895 + TEST2(err, SQLITE_BUSY);
1.896 +
1.897 + Print("Connection 1. Rollback. The database is unlocked.\r\n");
1.898 + err = sqlite3_exec(TheDb, "ROLLBACK", 0, 0, 0);
1.899 + TEST2(err, SQLITE_OK);
1.900 +
1.901 + Print("Connection 2. Execute an \"INSERT\" statement. Success.\r\n");
1.902 + err = sqlite3_exec(TheDb2, "INSERT INTO A VALUES(0,0,0.0,'',x'00')", 0, 0, &errmsg);
1.903 + if(errmsg)
1.904 + {
1.905 + PrintSI("*** %s. Err: %d.\r\n", errmsg, err);
1.906 + sqlite3_free(errmsg);
1.907 + }
1.908 + errmsg = 0;
1.909 + TEST2(err, SQLITE_OK);
1.910 +
1.911 + err = sqlite3_exec(TheDb2, "ROLLBACK", 0, 0, 0);
1.912 + TEST2(err, SQLITE_OK);
1.913 +
1.914 + Print("Close database connections.\r\n");
1.915 + /* ------------- */
1.916 +
1.917 + err = sqlite3_close(TheDb2);
1.918 + TEST2(err, SQLITE_OK);
1.919 + TheDb2 = 0;
1.920 +
1.921 + err = sqlite3_close(TheDb);
1.922 + TEST2(err, SQLITE_OK);
1.923 + TheDb = 0;
1.924 +
1.925 + (void)remove(TheTestDbName);
1.926 + }
1.927 +
1.928 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.929 +
1.930 +static void* ThreadFunc(void* pname)
1.931 + {
1.932 + int records = 0, err, i;
1.933 + sqlite3* db;
1.934 + char* errmsg = 0;
1.935 + int threadIdx = -1;
1.936 + const int KRecordsCount = 500;
1.937 + const int KCommitRecordsCount = 2;
1.938 +
1.939 + for(i=0;i<KTestThreadCount;++i)
1.940 + {
1.941 + if(strcmp(pname, KThreadNames[i]) == 0)
1.942 + {
1.943 + threadIdx = i;
1.944 + break;
1.945 + }
1.946 + }
1.947 +
1.948 + srand((unsigned)&ThreadFunc);
1.949 +
1.950 + PrintS("Thread \"%s\" - begin\r\n", (char*)pname);
1.951 + err = sqlite3_open(TheTestDbName, &db);
1.952 + TEST2(err, SQLITE_OK);
1.953 + TEST(db != 0);
1.954 +
1.955 + while(records < KRecordsCount)
1.956 + {
1.957 + if((records % 10) == 0)
1.958 + {
1.959 + PrintSI("Thread \"%s\", %d records.\r\n", (char*)pname, records);
1.960 + }
1.961 + err = sqlite3_exec(db, "BEGIN", 0, 0, &errmsg);
1.962 + if(err == SQLITE_OK)
1.963 + {
1.964 + err = sqlite3_exec(db, "INSERT INTO A VALUES(0,0,0.0,'',x'00')", 0, 0, &errmsg);
1.965 + if(err == SQLITE_OK)
1.966 + {
1.967 + err = sqlite3_exec(db, "INSERT INTO A VALUES(0,0,0.0,'',x'00')", 0, 0, &errmsg);
1.968 + if(err == SQLITE_OK)
1.969 + {
1.970 + err = sqlite3_exec(db, "COMMIT", 0, 0, &errmsg);
1.971 + }
1.972 + }
1.973 + }
1.974 + TEST(err == SQLITE_OK || err == SQLITE_BUSY);
1.975 + if(err == SQLITE_OK)
1.976 + {
1.977 + TheInsertRecCnt[threadIdx] += KCommitRecordsCount;
1.978 + records += KCommitRecordsCount;
1.979 + }
1.980 + else if(err == SQLITE_BUSY)
1.981 + {
1.982 + ++TheLockErrCnt[threadIdx];
1.983 + (void)sqlite3_exec(db, "ROLLBACK", 0, 0, 0);
1.984 + if(errmsg)
1.985 + {
1.986 + char fmt[100];
1.987 + strcpy(fmt, "Thread \"");
1.988 + strcat(fmt, (char*)pname);
1.989 + strcat(fmt, "\". Err msg: %s. Err: %d.\r\n");
1.990 + PrintSI(fmt, errmsg, err);
1.991 + sqlite3_free(errmsg);
1.992 + errmsg = 0;
1.993 + }
1.994 + usleep((rand() % 3000) + 500);
1.995 + }
1.996 + }
1.997 +
1.998 + err = sqlite3_close(db);
1.999 + TEST2(err, SQLITE_OK);
1.1000 +
1.1001 + PrintS("Thread \"%s\" - end\r\n", (char*)pname);
1.1002 + return &TheInsertRecCnt[threadIdx];
1.1003 + }
1.1004 +
1.1005 +/**
1.1006 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4007
1.1007 +@SYMTestCaseDesc Two database connections from different threads - "write operations" test.
1.1008 + The test creates two connections to the same database from two different threads.
1.1009 + Both connections attempt to execute INSERT statements using an explicit transaction
1.1010 + thus testing that the file locking in the OS porting layer works properly
1.1011 + (the SQLite library permits only one connection at a time to write to the database).
1.1012 + The threads do not use any thread synchronisation objects (mutexes, critical sections, etc...).
1.1013 + List of called SQLITE3 functions:
1.1014 + - sqlite3_open;
1.1015 + - sqlite3_exec;
1.1016 + - sqlite3_free;
1.1017 + - sqlite3_close;
1.1018 + Test case steps:
1.1019 + - Two threads created;
1.1020 + - Each thread opens a connection to the same database;
1.1021 + - No thread synchronisation is used;
1.1022 + - Each database connection attempts to insert records in a loop using an explicit transaction;
1.1023 + - If the database file is currently locked by the other database connection, the INSERT operation
1.1024 + should fail with SQLITE_BUSY error. Otherwise the operation should complete successfully.
1.1025 +@SYMTestPriority High
1.1026 +@SYMTestActions Two database connections from different threads - "write operations" test.
1.1027 +@SYMTestExpectedResults Test must not fail
1.1028 +@SYMREQ REQ8782
1.1029 +*/
1.1030 +static void ThreadsTest()
1.1031 + {
1.1032 + pthread_t threadIds[KTestThreadCount];
1.1033 + int err, i;
1.1034 +
1.1035 + TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4007: Test two writers in two threads");
1.1036 +
1.1037 + CreateTestDb();
1.1038 +
1.1039 + for(i=0;i<KTestThreadCount;++i)
1.1040 + {
1.1041 + err = pthread_create(&threadIds[i], 0, &ThreadFunc, (void*)KThreadNames[i]);
1.1042 + TEST2(err, 0);
1.1043 + }
1.1044 +
1.1045 + for(i=0;i<KTestThreadCount;++i)
1.1046 + {
1.1047 + (void)pthread_join(threadIds[i], 0);
1.1048 + PrintIII("Thread %d records written: %d, \"db locked\" errors: %d\r\n", i + 1, TheInsertRecCnt[i], TheLockErrCnt[i]);
1.1049 + }
1.1050 +
1.1051 + Print("Test two writers in two threads - end\r\n");
1.1052 + (void)remove(TheTestDbName);
1.1053 + }
1.1054 +
1.1055 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.1056 +
1.1057 +static void* ThreadFunc1(void* parg)
1.1058 + {
1.1059 + int err;
1.1060 + sqlite3* db;
1.1061 +
1.1062 + UNUSED_ARG(parg);
1.1063 + PrintS("Thread \"%s\" - begin\r\n", KThreadNames[0]);
1.1064 +
1.1065 + err = sqlite3_open(TheTestDbName, &db);
1.1066 + TEST2(err, SQLITE_OK);
1.1067 + TEST(db != 0);
1.1068 +
1.1069 + (void)sem_wait(&TheSemaphores[0]);/* Wait for a notification from the main thread to begin */
1.1070 +
1.1071 + err = sqlite3_exec(db, "BEGIN", 0, 0, 0);
1.1072 + TEST2(err, SQLITE_OK);
1.1073 +
1.1074 + err = sqlite3_exec(db, "INSERT INTO A VALUES(0,0,0.0,'',x'00')", 0, 0, 0);
1.1075 + TEST2(err, SQLITE_OK);
1.1076 +
1.1077 + (void)sem_post(&TheSemaphores[1]);/* The database is locked now. Notify thread 2 to attempt an INSERT operation */
1.1078 + (void)sem_wait(&TheSemaphores[0]);/* Wait for a notification from thread 2 to continue with the COMMIT operation */
1.1079 +
1.1080 + err = sqlite3_exec(db, "COMMIT", 0, 0, 0);
1.1081 + TEST2(err, SQLITE_OK);
1.1082 +
1.1083 + (void)sem_post(&TheSemaphores[1]);/* The database is unlocked. Notify thread 2 to attempt the INSERT operation again */
1.1084 +
1.1085 + err = sqlite3_close(db);
1.1086 + TEST2(err, SQLITE_OK);
1.1087 +
1.1088 + PrintS("Thread \"%s\" - end\r\n", KThreadNames[0]);
1.1089 + return 0;
1.1090 + }
1.1091 +
1.1092 +static void* ThreadFunc2(void* parg)
1.1093 + {
1.1094 + int err;
1.1095 + sqlite3* db;
1.1096 +
1.1097 + UNUSED_ARG(parg);
1.1098 + PrintS("Thread \"%s\" - begin\r\n", KThreadNames[1]);
1.1099 +
1.1100 + err = sqlite3_open(TheTestDbName, &db);
1.1101 + TEST2(err, SQLITE_OK);
1.1102 + TEST(db != 0);
1.1103 +
1.1104 + (void)sem_wait(&TheSemaphores[1]);/* Wait for a notification from thread 1 to attempt an INSERT operation */
1.1105 +
1.1106 + err = sqlite3_exec(db, "INSERT INTO A VALUES(0,0,0.0,'',x'00')", 0, 0, 0);
1.1107 + TEST2(err, SQLITE_BUSY);
1.1108 +
1.1109 + (void)sem_post(&TheSemaphores[0]);/* The database is locked. Notify thread 1 to commit and unlock the database */
1.1110 + (void)sem_wait(&TheSemaphores[1]);/* Wait for a notification from thread 1 to attempt the INSERT operation again */
1.1111 +
1.1112 + err = sqlite3_exec(db, "INSERT INTO A VALUES(0,0,0.0,'',x'00')", 0, 0, 0);
1.1113 + TEST2(err, SQLITE_OK);
1.1114 +
1.1115 + err = sqlite3_close(db);
1.1116 + TEST2(err, SQLITE_OK);
1.1117 +
1.1118 + PrintS("Thread \"%s\" - end\r\n", KThreadNames[1]);
1.1119 + return 0;
1.1120 + }
1.1121 +
1.1122 +/**
1.1123 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4008
1.1124 +@SYMTestCaseDesc Two database connections from different threads - synchronised "write operations" test.
1.1125 + The test creates two connections to the same database from two different threads.
1.1126 + Both connections attempt to execute INSERT statements using an explicit transaction
1.1127 + thus testing that the file locking in the OS porting layer works properly
1.1128 + (the SQLite library permits only one connection at a time to write to the database).
1.1129 + The threads use semaphores in order to synchronise the INSERT statements execution.
1.1130 + List of called SQLITE3 functions:
1.1131 + - sqlite3_open;
1.1132 + - sqlite3_exec;
1.1133 + - sqlite3_free;
1.1134 + - sqlite3_close;
1.1135 + Test case steps:
1.1136 + - Two threads created;
1.1137 + - Each thread opens a connection to the same database;
1.1138 + - The first thread begins an explicit transaction and inserts one record to the database.
1.1139 + The database file is locked. The first thread notifies the second thread and blocks
1.1140 + waiting for a notification from the second thread;
1.1141 + - The second thread attempts to execute an INSERT statement. Since the database file is locked
1.1142 + by the first thread the INSERT statement execution fails with SQLITE_BUSY. The second thread
1.1143 + sends a notification to the first thread to continue and blocks waiting for a notification;
1.1144 + - The first thread commits the transaction thus unlocking the database file. A notification is
1.1145 + sent to the second thread;
1.1146 + - The second thread makes second attempt to INSERT a record and this time the operation should
1.1147 + complete successfully;
1.1148 +@SYMTestPriority High
1.1149 +@SYMTestActions Two database connections from different threads - synchronised "write operations" test.
1.1150 +@SYMTestExpectedResults Test must not fail
1.1151 +@SYMREQ REQ8782
1.1152 +*/
1.1153 +static void TwoSyncThreadsTest()
1.1154 + {
1.1155 + const int KTestThreadCount = 2;
1.1156 + int i, err;
1.1157 + pthread_t threadIds[KTestThreadCount] = {0};
1.1158 + thread_begin_routine threadFuncs[KTestThreadCount] = {&ThreadFunc1, &ThreadFunc2};
1.1159 +
1.1160 + TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4008: Test two writers in two synchronized threads");
1.1161 +
1.1162 + CreateTestDb();
1.1163 +
1.1164 + for(i=0;i<KTestThreadCount;++i)
1.1165 + {
1.1166 + err = sem_init(&TheSemaphores[i], 0, 0);
1.1167 + TEST2(err, 0);
1.1168 + }
1.1169 +
1.1170 + for(i=0;i<KTestThreadCount;++i)
1.1171 + {
1.1172 + err = pthread_create(&threadIds[i], 0, threadFuncs[i], 0);
1.1173 + TEST2(err, 0);
1.1174 + }
1.1175 +
1.1176 + (void)sem_post(&TheSemaphores[0]);/* Notify thread 1 to begin */
1.1177 +
1.1178 + for(i=0;i<KTestThreadCount;++i)
1.1179 + {
1.1180 + (void)pthread_join(threadIds[i], 0);
1.1181 + }
1.1182 +
1.1183 + (void)remove(TheTestDbName);
1.1184 +
1.1185 + for(i=0;i<KTestThreadCount;++i)
1.1186 + {
1.1187 + err = sem_destroy(&TheSemaphores[i]);
1.1188 + TEST2(err, 0);
1.1189 + }
1.1190 + }
1.1191 +
1.1192 +/**
1.1193 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4009
1.1194 +@SYMTestCaseDesc Two database connections "RFileBuf64" test.
1.1195 + This test verifies that the file buffer used by the SQLITE OS porting layer works properly.
1.1196 + Test steps (in time order):
1.1197 + 1) Two connections to the same database are created.
1.1198 + 2) The first connection creates a table and executes a couple of INSERT statements.
1.1199 + 3) The second connection prepares a SELECT statement against the table, created in (2)
1.1200 + Now, if the file buffer in the OS porting layer does not work as expected, step (3) fails,
1.1201 + because at step (1) the database size is 0 and that is what the file buffer, used by the second
1.1202 + connection, "knows". The "prepare SQL statement" call will fail with a "no such table" error.
1.1203 + But if the file buffer works properly, the buffer will be flushed during the "lock file" operation
1.1204 + inside the OS porting layer and reloaded with the database data later.
1.1205 +@SYMTestPriority High
1.1206 +@SYMTestActions Two database connections "RFileBuf64" test.
1.1207 +@SYMTestExpectedResults Test must not fail
1.1208 +@SYMREQ REQ8782
1.1209 +*/
1.1210 +static void TwoConnectionsTest(void)
1.1211 + {
1.1212 + int err;
1.1213 + const char* tail = 0;
1.1214 + const char* errmsg = 0;
1.1215 +
1.1216 + TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4009: Two database connections test (OS porting layer, RFileBuf64 related)");
1.1217 + (void)remove(TheTestDbName);
1.1218 +
1.1219 + TEST(!TheDb);
1.1220 + err = sqlite3_open(TheTestDbName, &TheDb);
1.1221 + TEST2(err, SQLITE_OK);
1.1222 + TEST(TheDb != 0);
1.1223 +
1.1224 + TEST(!TheDb2);
1.1225 + err = sqlite3_open(TheTestDbName, &TheDb2);
1.1226 + TEST2(err, SQLITE_OK);
1.1227 + TEST(TheDb2 != 0);
1.1228 +
1.1229 + err = sqlite3_exec(TheDb, "CREATE TABLE t1(x);INSERT INTO t1 VALUES(1);INSERT INTO t1 VALUES(2);SELECT * FROM t1", 0, 0, 0);
1.1230 + TEST2(err, SQLITE_OK);
1.1231 +
1.1232 + TEST(!TheStmt);
1.1233 + err = sqlite3_prepare(TheDb2, "SELECT * FROM t1", -1, &TheStmt, &tail);
1.1234 + if(err != SQLITE_OK)
1.1235 + {
1.1236 + errmsg = sqlite3_errmsg(TheDb2);
1.1237 + PrintSI("*** Stmt prepare err msg: \"%s\". Error: %d\r\n", errmsg, err);
1.1238 + }
1.1239 + TEST2(err, SQLITE_OK);
1.1240 + TEST((unsigned int)TheStmt);
1.1241 + TEST(!tail || strlen(tail) == 0);
1.1242 +
1.1243 + err = sqlite3_step(TheStmt);
1.1244 + TEST2(err, SQLITE_ROW);
1.1245 +
1.1246 + err = sqlite3_finalize(TheStmt);
1.1247 + TEST2(err, SQLITE_OK);
1.1248 + TheStmt = 0;
1.1249 +
1.1250 + err = sqlite3_close(TheDb2);
1.1251 + TEST2(err, SQLITE_OK);
1.1252 + TheDb2 = 0;
1.1253 +
1.1254 + err = sqlite3_close(TheDb);
1.1255 + TEST2(err, SQLITE_OK);
1.1256 + TheDb = 0;
1.1257 + (void)remove(TheTestDbName);
1.1258 + }
1.1259 +
1.1260 +static void UdfInsertFunc(sqlite3_context* aCtx, int aCnt, sqlite3_value** aValues)
1.1261 + {
1.1262 + int err;
1.1263 + const char* tail = 0;
1.1264 + sqlite3* db = 0;
1.1265 +
1.1266 + TEST2(aCnt, 1);
1.1267 +
1.1268 + db = sqlite3_context_db_handle(aCtx);/* to test that sqlite3_context_db_handle() can be called */
1.1269 + TEST(db != 0);
1.1270 +
1.1271 + TEST(!TheStmt);
1.1272 + err = sqlite3_prepare(TheDb, "INSERT INTO t1(x) VALUES(:Val)", -1, &TheStmt, &tail);
1.1273 + if(err == SQLITE_OK)
1.1274 + {
1.1275 + err = sqlite3_bind_value(TheStmt, 1, aValues[0]);
1.1276 + if(err == SQLITE_OK)
1.1277 + {
1.1278 + err = sqlite3_step(TheStmt);
1.1279 + }
1.1280 + }
1.1281 + (void)sqlite3_finalize(TheStmt);
1.1282 + TheStmt = 0;
1.1283 +
1.1284 + sqlite3_result_int(aCtx, err);
1.1285 + }
1.1286 +
1.1287 +/**
1.1288 +@SYMTestCaseID SYSLIB-SQLITE3-UT-4027
1.1289 +@SYMTestCaseDesc sqlite3_bind_value() and sqlite3_column_value() test.
1.1290 + List of covered SQLITE3 functions:
1.1291 + - sqlite3_bind_value();
1.1292 + - sqlite3_column_value();
1.1293 + Test case steps:
1.1294 + - The test creates and calls a user defined function - UdfInsertFunc().
1.1295 + - The user defined function prepares and executes an INSERT statement,
1.1296 + where the sqlite3_bind_value() call is used to bind the passed from the caller
1.1297 + integer column value.
1.1298 + - After the user defined function call completes, the test prepares a SELECT
1.1299 + statement to verify the just inserted column value using sqlite3_column_int()
1.1300 +@SYMTestPriority High
1.1301 +@SYMTestActions sqlite3_bind_value() and sqlite3_column_int() test.
1.1302 +@SYMTestExpectedResults Test must not fail
1.1303 +@SYMREQ REQ8782
1.1304 +*/
1.1305 +static void UdfTest()
1.1306 + {
1.1307 + int err;
1.1308 + int val;
1.1309 + const char* tail = 0;
1.1310 + const int KTestColumnValue = 11234;
1.1311 + char sqlBuf[100];
1.1312 +
1.1313 + TestNext("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4027: User defined function test");
1.1314 +
1.1315 + (void)remove(TheTestDbName);
1.1316 + TEST(!TheDb);
1.1317 + err = sqlite3_open(TheTestDbName, &TheDb);
1.1318 + TEST2(err, SQLITE_OK);
1.1319 + TEST(TheDb != 0);
1.1320 +
1.1321 + err = sqlite3_exec(TheDb, "CREATE TABLE t1(x INTEGER)", 0, 0, 0);
1.1322 + TEST2(err, SQLITE_OK);
1.1323 +
1.1324 + err = sqlite3_create_function(TheDb, "UdfInsert", 1, SQLITE_UTF8, NULL, &UdfInsertFunc, NULL, NULL);
1.1325 + TEST2(err, SQLITE_OK);
1.1326 +
1.1327 + //Execute an INSERT statement via UDF
1.1328 + TEST(!TheStmt2);
1.1329 + sprintf(sqlBuf, "SELECT UdfInsert(%d)", KTestColumnValue);
1.1330 + err = sqlite3_prepare(TheDb, sqlBuf, -1, &TheStmt2, &tail);
1.1331 + TEST2(err, SQLITE_OK);
1.1332 + err = sqlite3_step(TheStmt2);
1.1333 + TEST2(err, SQLITE_ROW);
1.1334 + val = sqlite3_column_int(TheStmt2, 0);
1.1335 + TEST2(val, SQLITE_DONE);
1.1336 + (void)sqlite3_finalize(TheStmt2);
1.1337 + TheStmt2 = 0;
1.1338 +
1.1339 + //Verify the inserted column value
1.1340 + TEST(!TheStmt2);
1.1341 + err = sqlite3_prepare(TheDb, "SELECT x FROM t1", -1, &TheStmt2, &tail);
1.1342 + TEST2(err, SQLITE_OK);
1.1343 + err = sqlite3_step(TheStmt2);
1.1344 + TEST2(err, SQLITE_ROW);
1.1345 + val = sqlite3_column_int(TheStmt2,0);
1.1346 + TEST2(val, KTestColumnValue);
1.1347 + (void)sqlite3_finalize(TheStmt2);
1.1348 + TheStmt2 = 0;
1.1349 +
1.1350 + err = sqlite3_close(TheDb);
1.1351 + TEST2(err, SQLITE_OK);
1.1352 + TheDb = 0;
1.1353 + (void)remove(TheTestDbName);
1.1354 + }
1.1355 +
1.1356 +/* ///////////////////////////////////////////////////////////////////////////////////// */
1.1357 +
1.1358 +int main(int argc, void** argv)
1.1359 + {
1.1360 + UNUSED_ARG(argc);
1.1361 + UNUSED_ARG(argv);
1.1362 +
1.1363 + TestOpen("t_sqliteapi test");
1.1364 + TestTitle();
1.1365 +
1.1366 + TestHeapMark();
1.1367 +
1.1368 + TestEnvCreate();
1.1369 +
1.1370 + TestSqliteApi();
1.1371 + TwoReadersTest();
1.1372 + TwoWritersTest();
1.1373 + ThreadsTest();
1.1374 + TwoSyncThreadsTest();
1.1375 + TwoConnectionsTest();
1.1376 + UdfTest();
1.1377 +
1.1378 + TestEnvDestroy();
1.1379 +
1.1380 + TestHeapMarkEnd();
1.1381 +
1.1382 + TestEnd();
1.1383 + TestClose();
1.1384 +
1.1385 + return 0;
1.1386 + }