/*

* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <wchar.h>

#include <errno.h>

#include <sys/stat.h>

#include <pthread.h>

#include <semaphore.h>

#include <unistd.h>

#include <sqlite3.h>

#include "sqliteTestUtl.h"

static sqlite3* 		TheDb = 0;

static sqlite3* 		TheDb2 = 0;

static sqlite3_stmt*	TheStmt = 0;

static sqlite3_stmt*	TheStmt2 = 0;

const char* const		TheTestDirName = "c:\\test";

const char* const		TheTestDbName  = "c:\\test\\a1.db";

const int 			KTestThreadCount = 2;

static int 			TheInsertRecCnt[KTestThreadCount] = {0, 0};

static int 			TheLockErrCnt[KTestThreadCount] = {0, 0};

const char* const 	KThreadNames[KTestThreadCount] = {"THRD1", "THRD2"};

static sem_t 		TheSemaphores[KTestThreadCount];

#define UNUSED_ARG(a) (a) = (a)

/* ///////////////////////////////////////////////////////////////////////////////////// */

/* The standard C library does not have abs() function with a double argument */

static double dabs(double arg)

	{

	return arg < 0.0 ? -arg : arg;

	}

/* ///////////////////////////////////////////////////////////////////////////////////// */

static void TestEnvDestroy()

	{

	if(TheStmt2)

		{

		(void)sqlite3_finalize(TheStmt2);

		TheStmt2 = 0;

		}

	if(TheStmt)

		{

		(void)sqlite3_finalize(TheStmt);

		TheStmt = 0;

		}

	if(TheDb2)

		{

		(void)sqlite3_close(TheDb2);

		TheDb2 = 0;

		}

	if(TheDb)

		{

		(void)sqlite3_close(TheDb);

		TheDb = 0;

		}

	(void)remove(TheTestDbName);

	}

/* ///////////////////////////////////////////////////////////////////////////////////// */

/* Test macros and functions */

static void Check1(int aValue, int aLine)

	{

	if(!aValue)

		{

		if(TheDb)

			{

			const char* errmsg = sqlite3_errmsg(TheDb);

			PrintS("*** DB1: SQLITE error message: %s\r\n", errmsg);

			}

		if(TheDb2)

			{

			const char* errmsg = sqlite3_errmsg(TheDb2);

			PrintS("*** DB2: SQLITE error message: %s\r\n", errmsg);

			}

		PrintI("*** Test check failed! Line=%d\r\n", aLine);

		TestEnvDestroy();

		TestAbort(aLine);

		}

	}

static void Check2(int aValue, int aExpected, int aLine)

	{

	if(aValue != aExpected)

		{

		if(TheDb)

			{

			const char* errmsg = sqlite3_errmsg(TheDb);

			PrintS("*** DB1: SQLITE error message: %s\r\n", errmsg);

			}

		if(TheDb2)

			{

			const char* errmsg = sqlite3_errmsg(TheDb2);

			PrintS("*** DB2: SQLITE error message: %s\r\n", errmsg);

			}

		PrintIII("*** Test check failed! Line=%d. Expected error: %d, got: %d\r\n", aLine, aExpected, aValue);

		TestEnvDestroy();

		TestAbort(aLine);

		}

	}

static void Check64(sqlite_int64 aValue, sqlite_int64 aExpected, int aLine)

	{

	if(aValue != aExpected)

		{

		if(TheDb)

			{

			const char* errmsg = sqlite3_errmsg(TheDb);

			PrintS("*** DB1: SQLITE error message: %s\r\n", errmsg);

			}

		if(TheDb2)

			{

			const char* errmsg = sqlite3_errmsg(TheDb2);

			PrintS("*** DB2: SQLITE error message: %s\r\n", errmsg);

			}

		PrintII64I64("*** Test check failed! Line=%ld. Expected error: %ld, got: %d\r\n", aLine, aExpected, aValue);

		TestEnvDestroy();

		TestAbort(aLine);

		}

	}

#define TEST(arg) Check1((arg), __LINE__)

#define TEST2(aValue, aExpected) Check2(aValue, aExpected, __LINE__)

#define TEST64(aValue, aExpected) Check64(aValue, aExpected, __LINE__)

/* ///////////////////////////////////////////////////////////////////////////////////// */

static void TestEnvCreate()

	{

	int err; 

	(void)remove(TheTestDbName);

	err = mkdir(TheTestDirName, S_IREAD | S_IWRITE);

	if(err != 0)

		{

		err = errno;	

		}

	TEST(err == 0 || err == EEXIST);

	//Creating the private data cage directory here to suppress a capability warning

	CreatePrivateDir();

	}

/* ///////////////////////////////////////////////////////////////////////////////////// */

/* Callbacks */

static int exec_callback(void* udata, int argc, char** argv, char** colname)

	{

	UNUSED_ARG(udata);

	UNUSED_ARG(argc);

	UNUSED_ARG(argv);

	UNUSED_ARG(colname);

	return 0;

	}

static int authorizer_callback(void* udata, int optype, const char* name1, const char* name2, const char* name, const char* viewname)

	{

	UNUSED_ARG(udata);

	UNUSED_ARG(optype);

	UNUSED_ARG(name1);

	UNUSED_ARG(name2);

	UNUSED_ARG(name);

	UNUSED_ARG(viewname);

	return SQLITE_OK;

	}

static int commit_hook(void* udata)

	{

	UNUSED_ARG(udata);

	return SQLITE_OK;	

	}

static void rollback_hook(void* udata)

	{

	UNUSED_ARG(udata);

	}

static void update_hook(void* udata, int type, char const* dbname, char const* tblname, sqlite_int64 rowid)

	{

	UNUSED_ARG(udata);

	UNUSED_ARG(type);

	UNUSED_ARG(dbname);

	UNUSED_ARG(tblname);

	UNUSED_ARG(rowid);

	}

/* ///////////////////////////////////////////////////////////////////////////////////// */

/**

@SYMTestCaseID			SYSLIB-SQLITE3-UT-4001

@SYMTestCaseDesc		sqlite3_exec() tests.

						List of called SQLITE3 functions:

						 - sqlite3_exec;

						 - sqlite3_errcode;

						 - sqlite3_errmsg;

						 - sqlite3_last_insert_rowid;

						 - sqlite3_changes;

						 - sqlite3_total_changes;

						 - sqlite3_get_autocommit;

@SYMTestPriority		High

@SYMTestActions			sqlite3_exec() tests.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ8782

*/

static void TestExec()

	{

	int err;

	sqlite_int64 lastrowid;

	int val;

	TEST(TheDb != 0);

	err = sqlite3_exec(TheDb, "CREATE TABLE A(F1 INTEGER, F2 BIGINT, F3 REAL, F4 TEXT, F5 BLOB)", &exec_callback, 0, 0);

	TEST2(err, SQLITE_OK);

	err = sqlite3_exec(TheDb, "INSERT INTO A VALUES(1, 1234567891234, 56.12, 'TEXT', x'313233343536')", &exec_callback, 0, 0);

	TEST2(err, SQLITE_OK);

	err = sqlite3_errcode(TheDb);

	TEST2(err, SQLITE_OK);

	(void)sqlite3_errmsg(TheDb);

	lastrowid = sqlite3_last_insert_rowid(TheDb);

	TEST(lastrowid > 0LL);

	val = sqlite3_changes(TheDb);

	TEST2(val, 1);

	val = sqlite3_total_changes(TheDb);

	TEST(val >= 1);

	val = sqlite3_get_autocommit(TheDb);

	TEST(val != 0);

	}

/* ///////////////////////////////////////////////////////////////////////////////////// */

static void DoTestStatement()

	{

	int err, val;

	sqlite_int64 val64;

	double dblval;

	const unsigned char* textval;

	const unsigned short* textval16;

	const unsigned char* blob;

	const char *coltype, *colname;

	const unsigned short *coltype16, *colname16;

	sqlite3* db;

	TEST(TheDb != 0);

	TEST(TheStmt != 0);

	val = sqlite3_column_count(TheStmt);

	TEST2(val, 5);

	db = sqlite3_db_handle(TheStmt);

	TEST2((unsigned int)db, (unsigned int)TheDb);

	err = sqlite3_step(TheStmt);

	TEST2(err, SQLITE_ROW);

#ifdef SQLITE_ENABLE_COLUMN_METADATA

	sqlite3_column_database_name(TheStmt, 0);

	sqlite3_column_database_name16(TheStmt, 1);

	sqlite3_column_table_name(TheStmt, 2);

	sqlite3_column_table_name16(TheStmt, 3);

	sqlite3_column_origin_name(TheStmt, 4);

	sqlite3_column_origin_name16(TheStmt, 0);

#endif	

	coltype = sqlite3_column_decltype(TheStmt, 0);

	TEST2(strcmp(coltype, "INTEGER"), 0);

	coltype16 = (const unsigned short*)sqlite3_column_decltype16(TheStmt, 2);

	TEST2(wcscmp(coltype16, L"REAL"), 0);

	colname = sqlite3_column_name(TheStmt, 1);

	TEST2(strcmp(colname, "F2"), 0);

	colname16 = (const unsigned short *)sqlite3_column_name16(TheStmt, 4);

	TEST2(wcscmp(colname16, L"F5"), 0);

	val = sqlite3_column_int(TheStmt, 0);

	TEST2(val, 1);

	val64 = sqlite3_column_int64(TheStmt, 1);

	TEST64(val64, 1234567891234LL);

	dblval = sqlite3_column_double(TheStmt, 2);

	TEST(dabs(dblval - 56.12) < 0.00001);

	textval = sqlite3_column_text(TheStmt, 3);

	TEST2(strcmp((const char*)textval, "TEXT"), 0);

	textval16 = sqlite3_column_text16(TheStmt, 3);

	TEST2(wcscmp(textval16, L"TEXT"), 0);

	blob = (const unsigned char*)sqlite3_column_blob(TheStmt, 4);

	TEST2(memcmp(blob, "123456", 6), 0);

	err = sqlite3_step(TheStmt);

	TEST2(err, SQLITE_DONE);

	}

/* ///////////////////////////////////////////////////////////////////////////////////// */

/**

@SYMTestCaseID			SYSLIB-SQLITE3-UT-4002

@SYMTestCaseDesc		Statement handle SQLITE3 tests.

						List of called SQLITE3 functions:

						 - sqlite3_complete;

						 - sqlite3_complete16;

						 - sqlite3_prepare;

						 - sqlite3_finalize;

						 - sqlite3_column_count;

						 - sqlite3_db_handle;

						 - sqlite3_step;

						 - sqlite3_column_decltype;

						 - sqlite3_column_decltype16;

						 - sqlite3_column_name;

						 - sqlite3_column_name16;

						 - sqlite3_column_int;

						 - sqlite3_column_int64;

						 - sqlite3_column_double;

						 - sqlite3_column_text;

						 - sqlite3_column_text16;

						 - sqlite3_column_blob;

@SYMTestPriority		High

@SYMTestActions			Statement handle SQLITE3 tests.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ8782

*/

static void TestStatement1()

	{

  	const char* tail = 0;

	int err;

	TEST(TheDb != 0);

	TEST(!TheStmt);

	err = sqlite3_complete("SELECT * FROM A;");

	TEST(err != 0);

	err = sqlite3_complete16(L"SELECT * FROM A;");

	TEST(err != 0);

	err = sqlite3_prepare(TheDb, "SELECT * FROM A", -1, &TheStmt, &tail);

	TEST2(err, SQLITE_OK);

	TEST((unsigned int)TheStmt);

	TEST(!tail || strlen(tail) == 0);

	DoTestStatement();

	err = sqlite3_finalize(TheStmt);

	TEST2(err, SQLITE_OK);

	TheStmt = 0;

	}

/* ///////////////////////////////////////////////////////////////////////////////////// */

/**

@SYMTestCaseID			SYSLIB-SQLITE3-UT-4003

@SYMTestCaseDesc		Statement handle SQLITE3 tests.

						List of called SQLITE3 functions:

						 - sqlite3_prepare;

						 - sqlite3_finalize;

						 - sqlite3_bind_int;

						 - sqlite3_bind_int64;

						 - sqlite3_bind_double;

						 - sqlite3_bind_text;

@SYMTestPriority		High

@SYMTestActions			Statement handle SQLITE3 tests.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ8782

*/

static void TestStatement2()

	{

  	const char* tail = 0;

	int err;

	TEST(TheDb != 0);

	TEST(!TheStmt);

	err = sqlite3_prepare(TheDb, "SELECT * FROM A WHERE F1=? AND F2=? AND F3<? AND F4=?", -1, &TheStmt, &tail);

	TEST2(err, SQLITE_OK);

	TEST((unsigned int)TheStmt);

	TEST(!tail || strlen(tail) == 0);

	err = sqlite3_bind_int(TheStmt, 1, 1);

	TEST2(err, SQLITE_OK);

	err = sqlite3_bind_int64(TheStmt, 2, 1234567891234LL);

	TEST2(err, SQLITE_OK);

	err = sqlite3_bind_double(TheStmt, 3, 70.0);

	TEST2(err, SQLITE_OK);

	err = sqlite3_bind_text(TheStmt, 4, "TEXT", -1, SQLITE_STATIC);

	TEST2(err, SQLITE_OK);

	DoTestStatement();

	err = sqlite3_finalize(TheStmt);

	TEST2(err, SQLITE_OK);

	TheStmt = 0;

	}

/* ///////////////////////////////////////////////////////////////////////////////////// */

/**

@SYMTestCaseID			PDS-SQLITE3-UT-4038

@SYMTestCaseDesc		Database handle SQLITE3 tests.

						List of called SQLITE3 functions:

						 - sqlite3_db_status;

						 - sqlite3_file_control;

						 - sqlite3_limit;

						 - sqlite3_next_stmt;

						 - sqlite3_randomness;

@SYMTestPriority		High

@SYMTestActions			Database handle SQLITE3 tests.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ10424

*/

static void TestSqliteApi2()

	{

	int used = 0;

	int high = 0;

	int lock = -1;

	int limit = 0;

	sqlite3_stmt* next = 0;

	int err;

	unsigned char buf[10];

	TEST(TheDb != 0);

	err = sqlite3_db_status(TheDb, SQLITE_DBSTATUS_LOOKASIDE_USED, &used, &high, 0);

	TEST2(err, SQLITE_OK);

	PrintI("Lookaside slots: %d\r\n", used);

	PrintI("Max used lookaside slots: %d\r\n", high);

	err = sqlite3_file_control(TheDb, "main", SQLITE_FCNTL_LOCKSTATE, &lock);

	TEST2(err, SQLITE_OK);

	TEST2(lock, SQLITE_LOCK_NONE);

	limit = sqlite3_limit(TheDb, SQLITE_LIMIT_LENGTH, -1);

	TEST(limit > 0);

	next = sqlite3_next_stmt(TheDb, 0);

	TEST(!next);

	memset(buf, 0, sizeof(buf));

	sqlite3_randomness(8, buf);

	memset(buf, 0, sizeof(buf));

	sqlite3_randomness(7, buf);

	memset(buf, 0, sizeof(buf));

	sqlite3_randomness(3, buf);

	}

/* ///////////////////////////////////////////////////////////////////////////////////// */

/**

@SYMTestCaseID			PDS-SQLITE3-UT-4039

@SYMTestCaseDesc		SQLITE3 - blob API tests.

						List of called SQLITE3 functions:

						 - sqlite3_bind_zeroblob;

						 - sqlite3_blob_bytes;

						 - sqlite3_blob_close;

						 - sqlite3_blob_open;

						 - sqlite3_blob_read;

						 - sqlite3_blob_write;

						 - sqlite3_sql;

@SYMTestPriority		High

@SYMTestActions			SQLITE3 - blob API tests.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ10424

*/

static void TestSqliteBlobApi()

	{

	int err;

	const char* tail = 0;

	sqlite3_blob* blob = 0;

	int bytes = 0;

	const char KBlobData[] = "ABCDEFGH";

	char sql[100];

	const int KBlobLen = strlen(KBlobData);

	const char* sql2 = 0;

	const char KSqlFmt[] = "UPDATE BlobTbl SET B=:Prm WHERE ROWID=1";

	TEST(TheDb != 0);

	TEST(!TheStmt);

	/* Create the table, insert one record with a blob */

	err = sqlite3_exec(TheDb, "CREATE TABLE BlobTbl(I INTEGER PRIMARY KEY, B BLOB)", 0, 0, 0);

	TEST2(err, SQLITE_OK);

	sprintf(sql, "INSERT INTO BlobTbl VALUES(1, zeroblob(%d))", KBlobLen);

	err = sqlite3_exec(TheDb, sql, 0, 0, 0);

	TEST2(err, SQLITE_OK);

	err = sqlite3_prepare_v2(TheDb, KSqlFmt, -1, &TheStmt, &tail);

	TEST2(err, SQLITE_OK);

	TEST(TheStmt != 0);