// Copyright (c) 1998-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:

//

// MSVC++ up to 5.0 has problems with expanding inline functions

// This disables the mad warnings for the whole project

#if defined(NDEBUG) && defined(__VC32__) && _MSC_VER<=1100

#pragma warning(disable : 4710)			// function not expanded. MSVC 5.0 is stupid

#endif

#include <d32dbms.h>

#include <f32file.h>

#include <e32test.h>

#include <e32math.h>

// constructing literal TInt64 from compiler 64 bit integer rep

#ifndef I64LIT

#if defined __GCC32__ || defined __EABI__

#define _LINT64(val) MAKE_TINT64(TUint(val##LL>>32),TUint(val##LL&0xffffffffu))

#else

#define _LINT64(val) MAKE_TINT64(TUint(__int64(val)>>32),TUint(__int64(val)&0xffffffffu))

#endif

#else // I64LIT

#define _LINT64 I64LIT

#endif // I64LIT

LOCAL_D RTest TheTest(_L("t_dbsql: DBMS SQL parsing and execution tests"));

LOCAL_D RFs TheFs;

LOCAL_D CTrapCleanup* TheTrapCleanup;

LOCAL_D RDbs TheDbs;

LOCAL_D RDbNamedDatabase TheDatabase;

LOCAL_D RDbTable TheTable;

LOCAL_D RDbView TheView;

LOCAL_D TBuf<1024> TheSql;

const TInt KTestCleanupStack=0x20;

const TPtrC KTestDatabase=_L("c:\\dbms-tst\\t_sql.db");

#define elementsof(array) (sizeof(array)/sizeof(array[0]))

LOCAL_C void TestCleanup()

	{

	TheTable.Close();

	TheView.Close();

	TheDatabase.Close();

	TheDbs.Close();

	TheFs.Close();

	/////////////

	RFs fsSession;

	TInt err = fsSession.Connect();

	if(err == KErrNone)

		{

		TEntry entry;

		if(fsSession.Entry(KTestDatabase, entry) == KErrNone)

			{

			RDebug::Print(_L("Deleting \"%S\" file.\n"), &KTestDatabase);

			err = fsSession.SetAtt(KTestDatabase, 0, KEntryAttReadOnly);

			if(err != KErrNone)

				{

				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &KTestDatabase);

				}

			err = fsSession.Delete(KTestDatabase);

			if(err != KErrNone)

				{

				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &KTestDatabase);

				}

			}

		fsSession.Close();

		}

	else

		{

		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &KTestDatabase);

		}

	}

LOCAL_C void CloseDatabase()

	{

	TheDatabase.Close();

	}

LOCAL_C void Disconnect()

	{

	TheDbs.ResourceCheck();

	TheDbs.Close();

	}

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

//Tests macros and functions.

//If (!aValue) then the test will be panicked, the test data files will be deleted.

static void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

        RDebug::Print(_L("*** Expression evaluated to false\r\n"));

		::TestCleanup();

		TheTest(EFalse, aLine);

		}

	}

//If (aValue != aExpected) then the test will be panicked, the test data files will be deleted.

static void Check(TInt aValue, TInt aExpected, TInt aLine)

	{

	if(aValue != aExpected)

		{

		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

		::TestCleanup();

		TheTest(EFalse, aLine);

		}

	}

//Use these to test conditions.

#define TEST(arg) ::Check((arg), __LINE__)

#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

// Create the database

LOCAL_C void CreateDatabase()

	{

	TInt r=TheDatabase.Replace(TheFs,KTestDatabase);

	TEST2(r, KErrNone);

	}

LOCAL_C void Connect()

	{

	TInt r=TheDbs.Connect();

	TEST2(r, KErrNone);

	TheDbs.ResourceMark();

	}

// Open the database through the server

LOCAL_C void ShareDatabase()

	{

	TInt r=TheDatabase.Open(TheDbs,KTestDatabase);

	TEST2(r, KErrNone);

	}

struct TSelectTest

	{

	const TText* iSearchCondition;

	TUint iResultSet;

	};

#define ROWS(n,m) (((~0u)<<(n))&((2u<<(m))-1))

#define ROW(n) ROWS(n,n)

#define NO_ROWS 0

#define ALL_ROWS (~1u)		// all rows which are not NULL

class TestPredicateBase

	{

protected:

	static void Create(const TText* aType);

	static void Test(const TSelectTest* aTest,TInt aCount,TInt aRows);

	static void TestViewL(const TSelectTest* aTest,TInt aCount,TInt aRows);

	};

// Create the table for the predicate tests

void TestPredicateBase::Create(const TText* aType)

	{

	TheTest.Next(TPtrC(aType));

	TheDatabase.Begin();

	TheSql.Format(_L("CREATE TABLE Compare (Id COUNTER,Test %s)"),aType);

	TInt r=TheDatabase.Execute(TheSql);

	TEST2(r, KErrNone);

	r=TheTable.Open(TheDatabase,_L("Compare"),TheTable.EInsertOnly);

	TEST2(r, KErrNone);

	}

// Test the predicate on the table, then on the indexed table

void TestPredicateBase::Test(const TSelectTest* aTest,TInt aCount,TInt aRows)

	{

	TheTable.Close();

	TInt r=TheDatabase.Commit();

	TEST2(r, KErrNone);

	TRAPD(errCode, TestViewL(aTest,aCount,aRows));

	TEST2(errCode, KErrNone);

	r=TheDatabase.Execute(_L("CREATE INDEX Key ON Compare (Test)"));

	TEST2(r, KErrNone);

	TRAP(errCode,TestViewL(aTest,aCount,aRows));

	TEST2(errCode, KErrNone);

	r=TheDatabase.Execute(_L("DROP TABLE Compare"));

	TEST2(r, KErrNone);

	}

// Test the predicate on the table

void TestPredicateBase::TestViewL(const TSelectTest* aTest,TInt aCount,TInt aRows)

	{

	TUint rowMask=(2u<<aRows)-1;

	for (;--aCount>=0;++aTest)

		{

		TheSql.Format(_L("SELECT Id FROM Compare WHERE Test %s"),aTest->iSearchCondition);

		TInt r=TheView.Prepare(TheDatabase,TheSql,TheView.EReadOnly);

		TBool ignoreRow0=TheView.Unevaluated();

		TEST2(r, KErrNone);

		r=TheView.EvaluateAll();

		TEST2(r, KErrNone);

		TUint rows=0;

		while (TheView.NextL())

			{

			TheView.GetL();

			rows|=1u<<TheView.ColUint(1);

			}

		if (ignoreRow0)

			TEST((rows&~ROW(0))==(aTest->iResultSet&rowMask&~ROW(0)));

		else

			TEST(rows==(aTest->iResultSet&rowMask));

		TheView.Close();

		}

	}

typedef void (*FSetColL)(TDbColNo aCol,const TAny* aVal);

void WriteRowsL(const TAny* aValues,TInt aRows,TInt aSize,FSetColL aSetColL)

	{

	for (TInt row=0;row<=aRows;++row)

		{

		TheTable.InsertL();

		TEST(TheTable.ColUint(1)==TUint(row));

		if (row>0)

			{	// first row is always null

			aSetColL(2,aValues);

			aValues=PtrAdd(aValues,aSize);

			}

		TheTable.PutL();

		}

	}

template <class T>

struct SetCol

	{

	static void SetColL(TDbColNo aCol,const TAny* aVal)

		{

		TheTable.SetColL(aCol,*(const T*)aVal);

		}

	};

template <class T>

inline void WriteRowsL(const T* aValues,TUint aRows)

	{

	WriteRowsL(aValues,aRows,sizeof(T),&SetCol<T>::SetColL);

	}

template <class T>

class TestPredicate : public TestPredicateBase

	{

public:

	static void RunL();

	};

// Test the Predicate operators for all types

template <class T>

void TestPredicate<T>::RunL()

	{

	Create(T::KType);

	WriteRowsL(T::KValues,elementsof(T::KValues));

	Test(T::KTests,elementsof(T::KTests),elementsof(T::KValues));

	}

struct TypeBit

	{

public:

	static const TText* const KType;

	static const TUint KValues[];

	static const TSelectTest KTests[];

	};

const TText* const TypeBit::KType=_S("BIT");

const TUint TypeBit::KValues[]={0,1};

const TSelectTest TypeBit::KTests[]=

	{

	{_S("IS NULL"),ROW(0)},

	{_S("IS NOT NULL"),ALL_ROWS},

	{_S("=0"),ROW(1)},

	{_S("<>0"),ROW(2)},

	{_S(">0"),ROW(2)},

	{_S("<0"),NO_ROWS},

	{_S("<=0"),ROW(1)},

	{_S(">=0"),ALL_ROWS},

	{_S("=1"),ROW(2)},

	{_S("<>1"),ROW(1)},

	{_S(">1"),NO_ROWS},

	{_S("<1"),ROW(1)},

	{_S("<=1"),ALL_ROWS},

	{_S(">=1"),ROW(2)}

	};

struct TypeUint8

	{

public:

	static const TText* const KType;

	static const TUint KValues[];

	static const TSelectTest KTests[];

	};

const TText* const TypeUint8::KType=_S("UNSIGNED TINYINT");

const TUint TypeUint8::KValues[]={0,1,127,128,254,255};

const TSelectTest TypeUint8::KTests[]=

	{

	{_S("IS NULL"),ROW(0)},

	{_S("IS NOT NULL"),ALL_ROWS},

	{_S("=0"),ROW(1)},

	{_S("=3"),NO_ROWS},

	{_S("<2"),ROWS(1,2)},

	{_S(">=0"),ALL_ROWS},

	{_S("<128"),ROWS(1,3)},

	{_S("<>1"),ALL_ROWS-ROW(2)},

	{_S(">255"),NO_ROWS}

	};

struct TypeUint16

	{

public:

	static const TText* const KType;

	static const TUint KValues[];

	static const TSelectTest KTests[];

	};

const TText* const TypeUint16::KType=_S("UNSIGNED SMALLINT");

const TUint TypeUint16::KValues[]={0,1,5000,32767,32768,65534,65535};

const TSelectTest TypeUint16::KTests[]=

	{

	{_S("IS NULL"),ROW(0)},

	{_S("IS NOT NULL"),ALL_ROWS},

	{_S("=0"),ROW(1)},

	{_S("=3"),NO_ROWS},

	{_S("<2"),ROWS(1,2)},

	{_S(">=32768"),ROWS(5,7)},

	{_S("<32767"),ROWS(1,3)},

	{_S("<>1"),ALL_ROWS-ROW(2)},

	{_S(">65535"),NO_ROWS}

	};

struct TypeUint32

	{

public:

	static const TText* const KType;

	static const TUint KValues[];

	static const TSelectTest KTests[];

	};

const TText* const TypeUint32::KType=_S("UNSIGNED INTEGER");

const TUint TypeUint32::KValues[]={0,1,2147483647u,2147483648u,3000000000u,4294967294u,4294967295u};

const TSelectTest TypeUint32::KTests[]=

	{

	{_S("IS NULL"),ROW(0)},

	{_S("IS NOT NULL"),ALL_ROWS},

	{_S("=0"),ROW(1)},

	{_S("=3"),NO_ROWS},

	{_S("<2"),ROWS(1,2)},

	{_S(">=2147483648"),ROWS(4,7)},

	{_S("<2147483647"),ROWS(1,2)},

	{_S("<>3000000000"),ALL_ROWS-ROW(5)},

	{_S(">4294967295"),NO_ROWS}

	};

struct TypeInt8

	{

public:

	static const TText* const KType;

	static const TInt KValues[];

	static const TSelectTest KTests[];

	};

const TText* const TypeInt8::KType=_S("TINYINT");

const TInt TypeInt8::KValues[]={-128,-1,0,1,127};

const TSelectTest TypeInt8::KTests[]=

	{

	{_S("IS NULL"),ROW(0)},

	{_S("IS NOT NULL"),ALL_ROWS},

	{_S("=0"),ROW(3)},

	{_S("=-1"),ROW(2)},

	{_S("<2"),ROWS(1,4)},

	{_S(">=-128"),ALL_ROWS},

	{_S("<128"),ALL_ROWS},

	{_S("<>1"),ALL_ROWS-ROW(4)}

	};

struct TypeInt16

	{

public:

	static const TText* const KType;

	static const TInt KValues[];

	static const TSelectTest KTests[];

	};

const TText* const TypeInt16::KType=_S("SMALLINT");

const TInt TypeInt16::KValues[]={-32768,-32767,-1,0,1,32766,32767};

const TSelectTest TypeInt16::KTests[]=

	{

	{_S("IS NULL"),ROW(0)},

	{_S("IS NOT NULL"),ALL_ROWS},

	{_S("=0"),ROW(4)},

	{_S("<>0"),ALL_ROWS-ROW(4)},

	{_S("=-1"),ROW(3)},

	{_S("<2"),ROWS(1,5)},

	{_S(">=-40000"),ALL_ROWS},

	{_S("<32766"),ROWS(1,5)},

	{_S("=40"),NO_ROWS}

	};

struct TypeInt32

	{

public:

	static const TText* const KType;

	static const TInt KValues[];

	static const TSelectTest KTests[];

	};

const TText* const TypeInt32::KType=_S("INTEGER");

const TInt TypeInt32::KValues[]={0x80000000/*-2147483648*/,-2147483647,-1,0,1,2147483646,2147483647};

const TSelectTest TypeInt32::KTests[]=

	{

	{_S("IS NULL"),ROW(0)},

	{_S("IS NOT NULL"),ALL_ROWS},

	{_S("=0"),ROW(4)},

	{_S("<>0"),ALL_ROWS-ROW(4)},

	{_S("=-1"),ROW(3)},

	{_S("<2"),ROWS(1,5)},

	{_S(">=-2147483648"),ALL_ROWS},

	{_S("<2147483646"),ROWS(1,5)},

	{_S(">2147483647"),NO_ROWS},

	{_S("=40"),NO_ROWS}

	};

struct TypeInt64

	{

public:

	static const TText* const KType;

	static const TInt64 KValues[];

	static const TSelectTest KTests[];

	};

const TText* const TypeInt64::KType=_S("BIGINT");

const TInt64 TypeInt64::KValues[]=

	{

	MAKE_TINT64(0x80000000, 0x00000000), // min int64

	_LINT64(-4294967296),

	TInt(0x80000000),			// -2147483648!

	-1,

	0u,

	1u,

	2147483647u,

	_LINT64(2147483648),

	_LINT64(4294967295),

	_LINT64(4294967296),

	_LINT64(9223372036854775807)		// max int64

	};

const TSelectTest TypeInt64::KTests[]=

	{

	{_S("IS NULL"),ROW(0)},

	{_S("IS NOT NULL"),ALL_ROWS},

	{_S("=0"),ROW(5)},

	{_S("<>0"),ALL_ROWS-ROW(5)},

	{_S("=-1"),ROW(4)},

	{_S("<2"),ROWS(1,6)},

	{_S(">=-9223372036854775808"),ALL_ROWS},

	{_S("<4294967296"),ROWS(1,9)},

	{_S(">9223372036854775806"),ROW(11)},

	{_S("=40"),NO_ROWS}

	};

struct TypeReal32

	{

public:

	static const TText* const KType;

	static const TReal32 KValues[];

	static const TSelectTest KTests[];

	};

const TText* const TypeReal32::KType=_S("REAL");

const TReal32 TypeReal32::KValues[]=

	{

	-KMaxTReal32,

	-1.0f,

	-KMinTReal32,

	0.0f,

	KMinTReal32,

	1.0f,

	KMaxTReal32

	};

const TSelectTest TypeReal32::KTests[]=

	{

	{_S("IS NULL"),ROW(0)},

	{_S("IS NOT NULL"),ALL_ROWS},

	{_S("=0"),ROW(4)},

	{_S("<>0.0"),ALL_ROWS-ROW(4)},

	{_S("=-1"),ROW(2)},

	{_S("<2e1"),ROWS(1,6)},

	{_S(">=-100000000000000"),ROWS(2,7)},

	{_S("<1e-36"),ROWS(1,5)},

	{_S(">1e15"),ROW(7)},

	{_S("=.5"),NO_ROWS},

	{_S("<=-.0"),ROWS(1,4)},

	{_S("<1e40"),ALL_ROWS}

	};

struct TypeReal64

	{

public:

	static const TText* const KType;

	static const TReal64 KValues[];

	static const TSelectTest KTests[];

	};

const TText* const TypeReal64::KType=_S("DOUBLE");

const TReal64 TypeReal64::KValues[]=

	{

	-KMaxTReal64,

	-1.0f,

	-KMinTReal64,

	0.0f,

	KMinTReal64,

	1.0f,

	KMaxTReal64

	};

const TSelectTest TypeReal64::KTests[]=

	{

	{_S("IS NULL"),ROW(0)},

	{_S("IS NOT NULL"),ALL_ROWS},

	{_S("=0"),ROW(4)},

	{_S("<>0"),ALL_ROWS-ROW(4)},

	{_S("=-1"),ROW(2)},

	{_S("<2"),ROWS(1,6)},

	{_S(">=-100000000000000"),ROWS(2,7)},

	{_S("<1e-300"),ROWS(1,5)},