// Copyright (c) 2004-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 <d32dbms.h>+
−
#include <e32math.h>+
−
#include <e32test.h>+
−
#include <f32file.h>+
−
#include <s32buf.h>+
−
+
−
LOCAL_D RTest 			TheTest (_L ("t_dbdefect"));+
−
LOCAL_D CTrapCleanup*	TheTrapCleanup = NULL;+
−
LOCAL_D RSemaphore 		TheWaitToStartSem;+
−
LOCAL_D RSemaphore 		TheWaitForThreadsReadySem;+
−
LOCAL_D RFs 			TheFs;+
−
LOCAL_D RDbs			TheDbs1, TheDbs2;+
−
LOCAL_D RDbNamedDatabase TheDb1, TheDb2;+
−
+
−
_LIT (KName,			"ConnectTestThread_");+
−
_LIT (KStart,			"Starting thread %x.\n");+
−
_LIT (KConnect,			"Thread %x: Waiting to connect...\n");+
−
_LIT (KConSuccess,		"Thread %x: Connection succeeded.\n");+
−
_LIT (KConFailed,		"Thread %x: Connection failed. Error %d.\n");+
−
_LIT (KStatus,			"Status of thread %x is %d.\n");+
−
+
−
+
−
_LIT(KTable, 			"TABLE");+
−
_LIT(KColName,			"Fld");+
−
_LIT(KCol2Name, 		"Fld2");+
−
_LIT(KDbName,			"C:\\DBMS-TST\\TESTDB22.DB");+
−
_LIT(KSQLInsert1, 		"INSERT INTO TABLE (Fld, Fld2) VALUES ('ACDC\\','BLAH')");+
−
_LIT(KSQLInsert2, 		"INSERT INTO TABLE   (Fld) VALUES ('ABCDEFGH')");+
−
_LIT(KSQLInsert3, 		"INSERT INTO TABLE   (Fld) VALUES ('A?CDEFGH')");+
−
_LIT(KSQLInsert4, 		"INSERT INTO TABLE   (Fld) VALUES ('A?*?CDEFGH')");+
−
_LIT(KSQLInsert5, 		"INSERT INTO TABLE   (Fld) VALUES ('A*CDEFGH')");+
−
_LIT(KSQLInsert6, 		"INSERT INTO TABLE   (Fld, Fld2) VALUES ('ADCDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOP','ADCB')");+
−
_LIT(KSQLInsert7, 		"INSERT INTO TABLE   (Fld) VALUES ('XZD\\FZX')");+
−
+
−
_LIT(KSqlRequestGranularity, "SELECT Fld FROM test WHERE (Fld LIKE '1' AND Fld LIKE '2') AND Fld LIKE '3'  AND Fld LIKE '4'  AND Fld LIKE '5'  AND Fld LIKE '6'");+
−
+
−
_LIT(KText16Name, 		"text16");+
−
_LIT(KTableName, 		"test");+
−
_LIT(KIndexName, 		"test_index");+
−
_LIT(KMaxStringFormat, 	"%0256d");+
−
+
−
void TestCleanup()+
−
	{+
−
	TheDb2.Close();+
−
	TheDb1.Close();+
−
	TheDbs2.Close();+
−
	TheDbs1.Close();+
−
	(void)TheFs.Delete(KDbName);+
−
	TheFs.Close();+
−
	}+
−
+
−
//-----------------------------------------------------------------------------+
−
//+
−
// Test macros and functions.+
−
//+
−
//-----------------------------------------------------------------------------+
−
// If (!aValue) then the test will be panicked, the test data files will be+
−
// deleted.+
−
LOCAL_C void Check(TInt aValue, TInt aLine)+
−
	{+
−
	if(!aValue)+
−
		{+
−
		TestCleanup();+
−
		TheTest(EFalse, aLine);+
−
		}+
−
	}+
−
+
−
+
−
// If (aValue != aExpected) then the test will be panicked, the test data files+
−
// will be deleted.+
−
LOCAL_C 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__)+
−
//-----------------------------------------------------------------------------+
−
//-----------------------------------------------------------------------------+
−
+
−
struct TTest+
−
	{+
−
	const TText* result;+
−
	const TText* query;+
−
	};+
−
+
−
const TTest KQuery[]=+
−
	{+
−
	{_S("ACDC\\"),_S("SELECT Fld FROM TABLE WHERE  Fld LIKE 'ACDC\\' AND Fld2 LIKE '*BL*'")},+
−
	{_S("A*CDEFGH"),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*A\\*C*' ESCAPE '\\'")},+
−
	{_S("A?CDEFGH"),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*A\\?C*' ESCAPE '\\'")},+
−
	{_S("A?*?CDEFGH"),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*A\\?\\*\\?C*' ESCAPE '\\'")},+
−
	{_S("ADCDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOP"),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*1234*'")},+
−
	{_S("BLAH"),_S("SELECT Fld2 FROM TABLE WHERE  Fld LIKE '*AC*' AND Fld2 LIKE '?LA?'")},+
−
	{_S("BLAH"),_S("SELECT Fld2 FROM TABLE WHERE  Fld LIKE 'NOTINTABLE' OR Fld2 LIKE '?LA?'")},+
−
	{_S("ADCDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOPQRSTUVWXYZ123456789ACDEFGHIJKLMNOP"),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*ADC*' AND Fld2 LIKE 'ADC?'")},+
−
	{_S("A*CDEFGH"),_S("SELECT Fld FROM TABLE WHERE Fld LIKE '*\\*C*' ESCAPE '\\'")},+
−
	{_S("XZD\\FZX"),_S("SELECT Fld FROM TABLE WHERE Fld LIKE '*D\\\\*' ESCAPE '\\'")}+
−
	};+
−
+
−
const TTest KBadQuery[]=+
−
	{+
−
	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE 'A?C' ESCAPE '\\'")},+
−
	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE 'A*C' ESCAPE '\\'")},+
−
	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE '?A\\?C' ESCAPE '\\'")},+
−
	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE '?A\\?C?' ESCAPE '\\'")},+
−
	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*A\\??\\?C*' ESCAPE '\\'")},+
−
	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*A*\\*C*' ESCAPE '\\'")},+
−
	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE 'ABC' ESCAPE '\\'")},+
−
	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE 'ABC*' ESCAPE '\\'")},+
−
	{_S(""),_S("SELECT * FROM TABLE WHERE  Fld LIKE '*ABC' ESCAPE '\\'")}+
−
	};+
−
+
−
const TInt KNumQueries = 10;+
−
const TInt KNumBadQueries = 9;+
−
const TInt KThreadCount	= 3;+
−
const TInt KOneSecond 	= 1000000;+
−
const TInt KDbNameLen   = 255;+
−
const TInt KMaxColName = 32;+
−
+
−
static void DoDbmsConnectThreadSubFunctionL (TInt aThreadNumber)+
−
	{+
−
	// The session+
−
	RDbs TheDbSession;+
−
	CleanupClosePushL (TheDbSession);+
−
+
−
	RDebug::Print (KStart (), aThreadNumber);+
−
	RDebug::Print (KConnect (), aThreadNumber);+
−
+
−
 	// Signal the main thread to continue+
−
 	TheWaitForThreadsReadySem.Signal (1);+
−
+
−
	// Wait until we are signalled+
−
	TheWaitToStartSem.Wait ();+
−
+
−
	// Connect to Dbms+
−
	TInt r = TheDbSession.Connect ();+
−
+
−
	if (r == KErrNone)+
−
		{+
−
		RDebug::Print (KConSuccess (), aThreadNumber);+
−
		TheDbSession.Close ();+
−
		}+
−
	else+
−
		{+
−
		RDebug::Print (KConFailed (), aThreadNumber, r);+
−
		User::Leave (r);+
−
		}+
−
+
−
	CleanupStack::PopAndDestroy (1); // session+
−
	}+
−
+
−
static TInt DoDbmsConnectThread (TAny* aThreadNumber)+
−
	{+
−
	__UHEAP_MARK;+
−
+
−
	CTrapCleanup* trapCleanup = CTrapCleanup::New ();+
−
	__ASSERT_ALWAYS (trapCleanup!=NULL, User::Invariant ());+
−
+
−
	TInt* threadNumber = static_cast <TInt*> (aThreadNumber);+
−
	TRAPD (err, DoDbmsConnectThreadSubFunctionL (*threadNumber));+
−
+
−
	delete trapCleanup;+
−
+
−
	__UHEAP_MARKEND;+
−
+
−
	return err;+
−
	}+
−
+
−
/**+
−
@SYMTestCaseID          SYSLIB-DBMS-CT-0644+
−
@SYMTestCaseDesc        Test for defect no 44697+
−
@SYMTestPriority        Medium+
−
@SYMTestActions         Test for defect fixes+
−
@SYMTestExpectedResults Test must not fail+
−
@SYMREQ                 REQ0000+
−
*/+
−
LOCAL_C void Defect_DEF44697L ()+
−
	{+
−
	TheTest.Next (_L (" @SYMTestCaseID:SYSLIB-DBMS-CT-0644 Defect_DEF44697L "));+
−
+
−
	__UHEAP_MARK;+
−
+
−
  	// find out the number of open handles+
−
	TInt startProcessHandleCount;+
−
	TInt startThreadHandleCount;+
−
	RThread ().HandleCount (startProcessHandleCount, startThreadHandleCount);+
−
+
−
	/////////////////////+
−
	// The Test Begins...+
−
+
−
 	// Create semaphores+
−
 	::CleanupClosePushL (::TheWaitForThreadsReadySem);+
−
 	User::LeaveIfError (::TheWaitForThreadsReadySem.CreateLocal (0));+
−
+
−
 	::CleanupClosePushL (::TheWaitToStartSem);+
−
 	User::LeaveIfError (::TheWaitToStartSem.CreateLocal (0));+
−
+
−
 	// Create the threads.+
−
 	RThread createTestThread_1;+
−
 	RThread createTestThread_2;+
−
 	RThread createTestThread_3;+
−
+
−
 	TBuf<100> thread_name;+
−
	TInt KThreadNumber1 = 1;+
−
	TInt KThreadNumber2 = 2;+
−
	TInt KThreadNumber3 = 3;+
−
+
−
 	// Create the first test thread______________________________+
−
	thread_name = KName ();+
−
	thread_name.AppendNum (KThreadNumber1);+
−
+
−
 	User::LeaveIfError (+
−
 		createTestThread_1.Create (thread_name,+
−
								   (TThreadFunction) DoDbmsConnectThread,+
−
								   KDefaultStackSize,+
−
								   KMinHeapSize,+
−
								   KMinHeapSize,+
−
								   &KThreadNumber1));+
−
+
−
 	// Default priority of Main thread is EPriorityNormal+
−
 	createTestThread_1.SetPriority(EPriorityMore);+
−
+
−
 	TheTest.Printf (_L ("%S thread started\n"), &thread_name);+
−
+
−
 	// Request notification when the thread dies.+
−
 	TRequestStatus threadStatus_1;+
−
 	createTestThread_1.Logon (threadStatus_1);+
−
+
−
	//___________________________________________________________+
−
+
−
 	// Create the second test thread______________________________+
−
	thread_name = KName ();+
−
	thread_name.AppendNum (KThreadNumber2);+
−
+
−
 	User::LeaveIfError (+
−
 		createTestThread_2.Create (thread_name,+
−
								   (TThreadFunction) DoDbmsConnectThread,+
−
								   KDefaultStackSize,+
−
								   KMinHeapSize,+
−
								   KMinHeapSize,+
−
								   &KThreadNumber2));+
−
+
−
  	// Default priority of Main thread is EPriorityNormal+
−
 	createTestThread_2.SetPriority(EPriorityMore);+
−
+
−
 	TheTest.Printf (_L ("%S thread started\n"), &thread_name);+
−
+
−
 	// Request notification when the tread dies.+
−
 	TRequestStatus threadStatus_2;+
−
 	createTestThread_2.Logon (threadStatus_2);+
−
+
−
	//___________________________________________________________+
−
+
−
 	// Create the third test thread______________________________+
−
	thread_name = KName ();+
−
	thread_name.AppendNum (KThreadNumber3);+
−
+
−
 	User::LeaveIfError (+
−
 		createTestThread_3.Create (thread_name,+
−
								   (TThreadFunction) DoDbmsConnectThread,+
−
								   KDefaultStackSize,+
−
								   KMinHeapSize,+
−
								   KMinHeapSize,+
−
								   &KThreadNumber3));+
−
+
−
  	// Default priority of Main thread is EPriorityNormal+
−
 	createTestThread_3.SetPriority(EPriorityMore);+
−
+
−
 	TheTest.Printf (_L ("%S thread started\n"), &thread_name);+
−
+
−
 	// Request notification when the tread dies.+
−
 	TRequestStatus threadStatus_3;+
−
 	createTestThread_3.Logon (threadStatus_3);+
−
+
−
	//___________________________________________________________+
−
+
−
	TheTest (threadStatus_1.Int () == KRequestPending);+
−
	TheTest (threadStatus_2.Int () == KRequestPending);+
−
	TheTest (threadStatus_3.Int () == KRequestPending);+
−
+
−
 	// Make threads eligible for execution+
−
 	createTestThread_1.Resume ();+
−
 	createTestThread_2.Resume ();+
−
 	createTestThread_3.Resume ();+
−
+
−
	// The way this works is that the main thread blocks until all+
−
	// the test threads are ready (semaphore 1) and then signals them+
−
	// (semaphore 2).+
−
	//+
−
	// 1: Main thread Waits for ALL test threads to become ready.+
−
	// 2: Main thread Signals ALL test threads to run.+
−
	//+
−
	// 1: Test thread Signals Main thread+
−
	// 2: Test thread Waits for Main thread+
−
	//+
−
	// There is still a slight race condition between the+
−
	// test thread signalling (semaphore 1) and then waiting+
−
	// (semaphore 2) which is why we use both higher priority test+
−
	// threads and a timer.+
−
	//+
−
	// The problems come with the way Time slicing works due to+
−
	// other threads of higher priority being run.+
−
	//+
−
	// Higher priority: Ensures the test thread runs before the+
−
	// the main thread.+
−
	//+
−
	// Timer: Safeguards when multiple core processors are being used.+
−
	//+
−
	// The Higher priority fixes the problem on single core processors+
−
	// and multiple cores processors (SMP) where each core can run a+
−
	// thread.+
−
	//+
−
	// It should also ensure that if the system is so busy that it+
−
	// affects the test thread execution, the test thread will still+
−
	// get to the Wait state before the Main thread can Signal.+
−
	//+
−
	// However, on multiple cores the Main thread may run at the same+
−
	// time as the test thread, so we need to make sure that when the+
−
	// test thread Signals it can acheive its Wait state before the+
−
	// Main thread Signals. For example, if the timer has elapsed on the+
−
	// Main thread and the sytem is busy, the test thread should still+
−
	// run before the Main thread due to it higher priority.+
−
	//+
−
	// We also have to think about things like priority inheritance+
−
	// where a thread that has a handle on a Mutex inherits the same+
−
	// priority as a thread Waiting on it. This shouldn't happen for+
−
	// Semaphores as there is no one handle, i.e. no critical section.+
−
	//+
−
	// This higher priority inheritance will take affect when a low+
−
	// priority thread that has a handle on the Mutex blocks because of+
−
	// another medium priority running thread. So in effect a high+
−
	// priority thread Waiting on this Mutex is also blocked.+
−
	//+
−
	// It is also worth noting that on EKA1 emulator, scheduling is+
−
	// performed by windows. On EKA2 emulator scheduling is performed+
−
	// by Symbian so that it is the same as hardware.+
−
+
−
	TheWaitForThreadsReadySem.Wait();+
−
	TheWaitForThreadsReadySem.Wait();+
−
	TheWaitForThreadsReadySem.Wait();+
−
+
−
  	// Sleep for a while to allow threads to block on the semaphore+
−
  	User::After (KOneSecond<<2); // 4 seconds+
−
+
−
 	// Signal all the threads to continue+
−
 	TheWaitToStartSem.Signal (KThreadCount);+
−
+
−
 	// Wait for all threads to complete, don't care on the order.+
−
	User::WaitForRequest (threadStatus_1);+
−
	User::WaitForRequest (threadStatus_2);+
−
	User::WaitForRequest (threadStatus_3);+
−
+
−
	TheTest.Printf (KStatus, KThreadNumber1, threadStatus_1.Int ());+
−
	TheTest.Printf (KStatus, KThreadNumber2, threadStatus_2.Int ());+
−
	TheTest.Printf (KStatus, KThreadNumber3, threadStatus_3.Int ());+
−
+
−
	TheTest (threadStatus_1.Int () == KErrNone);+
−
	TheTest (threadStatus_2.Int () == KErrNone);+
−
	TheTest (threadStatus_3.Int () == KErrNone);+
−
+
−
	CleanupStack::PopAndDestroy (&::TheWaitToStartSem);+
−
	CleanupStack::PopAndDestroy (&::TheWaitForThreadsReadySem);+
−
+
−
	// The Test Ends...+
−
	/////////////////////+
−
+
−
	// check that no handles have leaked+
−
	TInt endProcessHandleCount;+
−
	TInt endThreadHandleCount;+
−
	RThread ().HandleCount (endProcessHandleCount, endThreadHandleCount);+
−
+
−
	TheTest (startThreadHandleCount == endThreadHandleCount);+
−
+
−
	__UHEAP_MARKEND;+
−
	}+
−
+
−
+
−
+
−
// Test for LIKE Predicate for EDbColLongText16+
−
LOCAL_C void LikePredicateDbColLongText16TestL()+
−
 	{+
−
 	TheTest.Next (_L ("LikePredicateDbColLongText16TestL"));+
−
 	//Creating database+
−
+
−
	RFs fsSession;+
−
    User::LeaveIfError(fsSession.Connect());+
−
    CleanupClosePushL(fsSession);+
−
	RDbNamedDatabase database;+
−
	User::LeaveIfError(database.Replace(fsSession, KDbName));+
−
	CleanupClosePushL(database);+
−
+
−
	//Create table+
−
+
−
	CDbColSet* columns= CDbColSet::NewLC();+
−
+
−
	TDbCol name(KColName,EDbColLongText16,KDbNameLen);+
−
	name.iAttributes = TDbCol::ENotNull;+
−
+
−
	TDbCol name2(KCol2Name,EDbColLongText16,KDbNameLen);+
−
+
−
	columns->AddL(name);+
−
	columns->AddL(name2);+
−
   	User::LeaveIfError (database.CreateTable (KTable, *columns));+
−
	CleanupStack::PopAndDestroy(); // columns+
−
+
−
    // Insert values into table+
−
    TInt error =	database.Execute(KSQLInsert1);+
−
    TheTest(error>=0);+
−
    error =database.Execute(KSQLInsert2);+
−
    TheTest(error>=0);+
−
    error =database.Execute(KSQLInsert3);+
−
    TheTest(error>=0);+
−
	error =	database.Execute(KSQLInsert4);+
−
	TheTest(error>=0);+
−
	error =	database.Execute(KSQLInsert5);+
−
	TheTest(error>=0);+
−
	error = database.Execute(KSQLInsert6);+
−
	TheTest(error>=0);+
−
	error = database.Execute(KSQLInsert7);+
−
	TheTest(error>=0);+
−
+
−
+
−
	TheTest.Next(_L("Test for valid LIKE predicate queries"));+
−
+
−
+
−
	for(TInt i =0;i<KNumQueries;++i)+
−
		{+
−
		RDebug::Print(_L("Executing statement: %s \n"),(KQuery[i].query));+
−
		RDbView view;+
−
		view.Prepare(database, TDbQuery(TPtrC(KQuery[i].query), EDbCompareFolded), view.EReadOnly);+
−
		view.EvaluateAll();+
−
		view.FirstL();+
−
		typedef TBuf<256> TScriptLine;+
−
		TInt count =0;+
−
		while (view.AtRow())+
−
			{+
−
			view.GetL();+
−
			count++;+
−
			RDbColReadStream rd;+
−
			rd.OpenLC(view,1);+
−
			TScriptLine text;+
−
			rd.ReadL(text,view.ColLength(1));+
−
			CleanupStack::PopAndDestroy();+
−
			RDebug::Print(_L("Expected result: %s Actual Result: %S\n"),(KQuery[i].result),&text);+
−
			TInt err = text.Compare(TPtrC(KQuery[i].result));+
−
			TheTest(err ==0);+
−
			view.NextL();+
−
			}+
−
		view.Close();+
−
		}+
−
+
−
+
−
	// test for illegal statements, check they return KErrArgument+
−
	TheTest.Next(_L("Test that illegal queries return KErrArgument"));+
−
+
−
+
−
	for(TInt j =0;j<KNumBadQueries;++j)+
−
		{+
−
		RDebug::Print(_L("Executing illegal statement: %s \n"),(KBadQuery[j].query));+
−
		RDbView view;+
−
		TInt prepErr = view.Prepare(database, TDbQuery(TPtrC(KBadQuery[j].query), EDbCompareFolded), view.EReadOnly);+
−
		TheTest(prepErr==KErrArgument);+
−
		view.Close();+
−
		}+
−
+
−
    CleanupStack::PopAndDestroy(&database); // database+
−
    CleanupStack::PopAndDestroy(&fsSession); // fsSession+
−
 	}+
−
+
−
+
−
+
−
 //  for LIKE Predicate for EDbColLongText8+
−
LOCAL_C void LikePredicateDbColLongText8TestL()+
−
 	{+
−
	TheTest.Next (_L ("LikePredicate DbColLongText8 TestL"));+
−
+
−
 	//Creating database+
−
+
−
	RFs      fsSession;+
−
    User::LeaveIfError(fsSession.Connect());+
−
    CleanupClosePushL(fsSession);+
−
	RDbNamedDatabase database;+
−
	User::LeaveIfError(database.Replace(fsSession, KDbName));+
−
	CleanupClosePushL(database);+
−
+
−
	//Create table+
−
+
−
	CDbColSet* columns= CDbColSet::NewLC();+
−
+
−
	TDbCol name(KColName,EDbColLongText8,KDbNameLen);+
−
	name.iAttributes = TDbCol::ENotNull;+
−
+
−
	TDbCol name2(KCol2Name,EDbColLongText8,KDbNameLen);+
−
+
−
	columns->AddL(name);+
−
	columns->AddL(name2);+
−
+
−
	User::LeaveIfError (database.CreateTable (KTable, *columns));+
−
	CleanupStack::PopAndDestroy(); // columns+
−
+
−
	// Insert values into the table+
−
 	TInt error =	database.Execute(KSQLInsert1);+
−
    TheTest(error>=0);+
−
    error =database.Execute(KSQLInsert2);+
−
    TheTest(error>=0);+
−
    error =database.Execute(KSQLInsert3);+
−
    TheTest(error>=0);+
−
	error =	database.Execute(KSQLInsert4);+
−
	TheTest(error>=0);+
−
	error =	database.Execute(KSQLInsert5);+
−
	TheTest(error>=0);+
−
	error = database.Execute(KSQLInsert6);+
−
	TheTest(error>=0);+
−
	error = database.Execute(KSQLInsert7);+
−
	TheTest(error>=0);+
−
+
−
	TheTest.Next(_L("Test for valid LIKE predicate queries"));+
−
+
−
+
−
	for(TInt i =0;i<KNumQueries;++i)+
−
		{+
−
		RDebug::Print(_L("Executing statement: %s \n"),(KQuery[i].query));+
−
		RDbView view;+
−
		TInt prepErr = view.Prepare(database, TDbQuery(TPtrC(KQuery[i].query), EDbCompareFolded), view.EReadOnly);+
−
		TheTest(prepErr>=0);+
−
		TInt evErr = view.EvaluateAll();+
−
		TheTest(evErr==0);+
−
		TBuf8<256> result;+
−
		TBuf8<256> colname;+
−
		result.Copy(TPtrC(KQuery[i].result));+
−
		view.FirstL();+
−
+
−
		while (view.AtRow())+
−
			{+
−
			view.GetL();+
−
			RDbColReadStream rd;+
−
			rd.OpenLC(view,1);+
−
			rd.ReadL(colname,view.ColLength(1));+
−
			CleanupStack::PopAndDestroy();+
−
			RDebug::Print(_L("Expected result: %S Actual Result: %S\n"),&result,&colname);+
−
			TInt err = colname.CompareF(result);+
−
			TheTest(err ==0);+
−
+
−
			view.NextL();+
−
			}+
−
+
−
		view.Close();+
−
		}+
−
+
−
		// test for illegal statements, check they return KErrArgument+
−
	TheTest.Next(_L("Test that illegal queries return KErrArgument"));+
−
+
−
+
−
+
−
	for(TInt j =0;j<KNumBadQueries;++j)+
−
		{+
−
		RDebug::Print(_L("Executing illegal statement: %s \n"),(KBadQuery[j].query));+
−
		RDbView view;+
−
		TInt prepErr = view.Prepare(database, TDbQuery(TPtrC(KBadQuery[j].query), EDbCompareFolded), view.EReadOnly);+
−
		TheTest(prepErr==KErrArgument);+
−
+
−
		view.Close();+
−
		}+
−
+
−
   	CleanupStack::PopAndDestroy(&database); // database+
−
    CleanupStack::PopAndDestroy(&fsSession); // fsSession+
−
 	}+
−
+
−
+
−
+
−
// Test for LIKE Predicate for EDbColText+
−
LOCAL_C void LikePredicateDbColTextTestL()+
−
 	{+
−
 	TheTest.Next (_L ("LikePredicate DbColText TestL"));+
−
 	//Creating database+
−
+
−
	RFs      fsSession;+
−
    User::LeaveIfError(fsSession.Connect());+
−
    CleanupClosePushL(fsSession);+
−
	RDbNamedDatabase database;+
−
	User::LeaveIfError(database.Replace(fsSession, KDbName));+
−
	CleanupClosePushL(database);+
−
+
−
	//Create table+
−
+
−
	CDbColSet* columns= CDbColSet::NewLC();+
−
+
−
	TDbCol name(KColName,EDbColText,KDbNameLen);+
−
	name.iAttributes = TDbCol::ENotNull;+
−
+
−
	TDbCol name2(KCol2Name,EDbColText,KDbNameLen);+
−
+
−
	columns->AddL(name);+
−
	columns->AddL(name2);+
−
+
−
	User::LeaveIfError (database.CreateTable (KTable, *columns));+
−
	CleanupStack::PopAndDestroy(); // columns+
−
+
−
 	// Insert values into the table+
−
    TInt error =	database.Execute(KSQLInsert1);+
−
    TheTest(error>=0);+
−
    error =database.Execute(KSQLInsert2);+
−
    TheTest(error>=0);+
−
    error =database.Execute(KSQLInsert3);+
−
    TheTest(error>=0);+
−
	error =	database.Execute(KSQLInsert4);+
−
	TheTest(error>=0);+
−
	error =	database.Execute(KSQLInsert5);+
−
	TheTest(error>=0);+
−
	error = database.Execute(KSQLInsert6);+
−
	TheTest(error>=0);+
−
	error = database.Execute(KSQLInsert7);+
−
	TheTest(error>=0);+
−
+
−
+
−
	TheTest.Next(_L("Test for valid LIKE predicate queries"));+
−
+
−
+
−
	for(TInt i =0;i<KNumQueries;++i)+
−
		{+
−
		RDebug::Print(_L("Executing statement: %s \n"),(KQuery[i].query));+
−
		RDbView view;+
−
		TInt prepErr = view.Prepare(database, TDbQuery(TPtrC(KQuery[i].query), EDbCompareFolded), view.EReadOnly);+
−
		if(TPtrC(KQuery[i].result).Length() == 0)+
−
			{+
−
			TheTest(prepErr != KErrNone);+
−
			continue;+
−
			}+
−
+
−
		view.EvaluateAll();+
−
		TBufC<256> colname;+
−
		TBufC<256> res;+
−
		view.FirstL();+
−
		while (view.AtRow())+
−
			{+
−
			view.GetL();+
−
			colname = view.ColDes(1);+
−
			res= KQuery[i].result;+
−
			RDebug::Print(_L("Expected result: %s Actual Result: %S\n"),(KQuery[i].result),&colname);+
−
			TInt err =	colname.Compare(TPtrC(KQuery[i].result));+
−
			TheTest(err ==0);+
−
			view.NextL();+
−
			}+
−
		view.Close();+
−
		}+
−
+
−
	// test for illegal statements, check they return KErrArgument+
−
	TheTest.Next(_L("Test that illegal queries return KErrArgument"));+
−
+
−
	for(TInt j =0;j<KNumBadQueries;++j)+
−
		{+
−
		RDebug::Print(_L("Executing illegal statement: %s \n"),(KBadQuery[j].query));+
−
		RDbView view;+
−
		TInt prepErr = view.Prepare(database, TDbQuery(TPtrC(KBadQuery[j].query), EDbCompareFolded), view.EReadOnly);+
−
		TheTest(prepErr==KErrArgument);+
−
		view.Close();+
−
		}+
−
+
−
    CleanupStack::PopAndDestroy(&database); // database+
−
    CleanupStack::PopAndDestroy(&fsSession); // fsSession+
−
    }+
−
+
−
+
−
+
−
 /**+
−
@SYMTestCaseID 			SYSLIB-DBMS-UT-1592+
−
@SYMTestCaseDesc     	Testing limited-ESCAPE-clause+
−
@SYMTestPriority     	High+
−
@SYMTestActions      	Execute DBMS query with ESCAPE-clause+
−
@SYMTestExpectedResults The test should not fail.+
−
@SYMDEF INC076370+
−
*/+
−
LOCAL_C void Defect_INC076370L()+
−
	{+
−
	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-1592 Defect INC076370 "));+
−
	LikePredicateDbColTextTestL(); //EDbColText+
−
	LikePredicateDbColLongText16TestL(); //EDbColLongText16+
−
	LikePredicateDbColLongText8TestL();	//EDbColLongText8+
−
	}+
−
+
−
 /**+
−
@SYMTestCaseID 			SYSLIB-DBMS-UT-1667+
−
@SYMTestCaseDesc     	Testing RdbRowSet::DeleteL() with EDbColLongText16 type columns+
−
@SYMTestPriority     	High+
−
@SYMTestActions      	Create a table with a EDbColLongText16 type column and then use+
−
						RdbRowSet::DeleteL() to delete the current row.+
−
@SYMTestExpectedResults The test should not fail.+
−
@SYMDEF INC083027+
−
*/+
−
LOCAL_C void Defect_INC083027L()+
−
	{+
−
	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-1667 Defect INC083027 "));+
−
	RFs fs;+
−
	CleanupClosePushL(fs);+
−
	User::LeaveIfError(fs.Connect());+
−
+
−
	// create database+
−
	RDbNamedDatabase database;+
−
	CleanupClosePushL(database);+
−
	User::LeaveIfError(database.Replace(fs, _L("c:\\test.db")));+
−
+
−
	CDbColSet* columns = CDbColSet::NewLC();+
−
	const TInt maxTextLength = 256;+
−
	TDbCol text16Col(KText16Name, EDbColLongText16, maxTextLength);+
−
	columns->AddL(text16Col);+
−
+
−
	TBuf<KMaxColName> targetColName;+
−
	targetColName = KText16Name;+
−
+
−
	// create table+
−
	User::LeaveIfError(database.CreateTable(KTableName, *columns));+
−
+
−
	//create index+
−
	CDbKey* key = CDbKey::NewLC();+
−
	TInt keyLength = 122;+
−
	TDbKeyCol keyCol(targetColName, keyLength);+
−
	key->AddL(keyCol);+
−
	User::LeaveIfError(database.CreateIndex(KIndexName, KTableName, *key));+
−
	CleanupStack::PopAndDestroy(2);		// key and columns+
−
+
−
	//insert rows+
−
	HBufC* sqlQueryBuf = HBufC::NewLC(512);+
−
	TPtr sqlQuery(sqlQueryBuf->Des());+
−
	_LIT(KSQLInsertFormat, "SELECT %S FROM %S");+
−
	sqlQuery.Format(KSQLInsertFormat, &targetColName, &KTableName);+
−
+
−
	RDbView insertview;+
−
	User::LeaveIfError(insertview.Prepare(database, TDbQuery(sqlQuery), RDbView::EInsertOnly));+
−
+
−
	HBufC* tmpBuf = HBufC::NewLC(maxTextLength);+
−
	TPtr maxString(tmpBuf->Des());+
−
	maxString.Format(KMaxStringFormat, 0);+
−
	insertview.InsertL();+
−
	insertview.SetColL(1, maxString);+
−
	insertview.PutL();+
−
	insertview.Close();+
−
+
−
	//delete the row+
−
	RDbView deleteview;+
−
	User::LeaveIfError(deleteview.Prepare(database, TDbQuery(sqlQuery), RDbView::EUpdatable));+
−
	User::LeaveIfError(deleteview.EvaluateAll());+
−
+
−
	while (deleteview.NextL())+
−
		{+
−
		deleteview.GetL();+
−
		TRAPD(err , deleteview.DeleteL());+
−
		TheTest(err==KErrNone);+
−
		}+
−
	deleteview.Close();+
−
+
−
	CleanupStack::PopAndDestroy(2);  // tmpBuf, sqlQueryBuf+
−
    CleanupStack::PopAndDestroy(&database); // database+
−
    CleanupStack::PopAndDestroy(&fs); // fs+
−
	}+
−
+
−
 /**+
−
@SYMTestCaseID          SYSLIB-DBMS-UT-1894+
−
@SYMTestCaseDesc        Testing memory handling in CSqlMultiNode::Concatenate()+
−
@SYMTestPriority        Medium+
−
@SYMTestActions         Execute a special request to a database which will trigger CSqlMultiNode::Concatenate(), and the size of one of the SQL nodes will be divisible by the CSqlMultiNode granularity+
−
@SYMTestExpectedResults The test should not fail or panic.+
−
@SYMDEF INC093657+
−
*/+
−
LOCAL_C void Defect_INC093657L ()+
−
   {+
−
   TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-1894 Defect INC093657 "));+
−
   RFs fs;+
−
   CleanupClosePushL(fs);+
−
   User::LeaveIfError(fs.Connect());+
−
+
−
   // create database+
−
   RDbNamedDatabase database;+
−
   CleanupClosePushL(database);+
−
   User::LeaveIfError(database.Replace(fs, _L("c:\\test.db")));+
−
+
−
   CDbColSet* columns = CDbColSet::NewLC();+
−
   const TInt maxTextLength = 256;+
−
   TDbCol column(KColName, EDbColLongText16, maxTextLength);+
−
   columns->AddL(column);+
−
+
−
   // create table+
−
   User::LeaveIfError(database.CreateTable(KTableName, *columns));+
−
   CleanupStack::PopAndDestroy();  // columns+
−
+
−
   //execute a pointless request that is intended to detect subtle memory corruptions in CSqlMultiNode::Concatenate+
−
   RDbView view;+
−
   TInt err = view.Prepare(database, TDbQuery(KSqlRequestGranularity));+
−
+
−
   TheTest(err==KErrNone);+
−
+
−
   view.Close();+
−
   database.Destroy();+
−
+
−
   CleanupStack::PopAndDestroy(&database); // database+
−
   CleanupStack::PopAndDestroy(&fs); // fs+
−
   }+
−
+
−
/**+
−
@SYMTestCaseID			SYSLIB-DBMS-UT-3467+
−
@SYMTestCaseDesc		Test for DEF105615 "DBMS, CDbColSet::operator[](TDbColNo) operator may access an invalid memory".+
−
						The test creates a table with 3 coluumns and a multi-column key (3 columns). The column+
−
						names length is such that when RDbRowSet::ColSetL() is called for retrieving the column+
−
						names, the CDbColSet array data member will make just a single memory allocation, where+
−
						all TDbCol elements will be stored. Then the test repeats 100 times, the following statements:+
−
							<retrieve a colset>;+
−
							<create a copy of colset's last TDbCol element using TDbCol's copy constructor>;+
−
							<create a copy of colset's last TDbCol element using TDbCol's "=" operator>;+
−
						If the test uses the compiler generated TDbCol's copy constructor and "=" operator,+
−
						the test crashes at some iteration, because an invalid memory region is accessed and+
−
						the crash is: KERN-EXEC 3.+
−
						The same test is repeated for TDbKeyCol's copy constructor and "=" operator.+
−
@SYMTestPriority		High+
−
@SYMTestActions			Test for DEF105615 "DBMS, CDbColSet::operator[](TDbColNo) operator may access an invalid memory".+
−
@SYMTestExpectedResults The test must not fail+
−
@SYMREQ					DEF105615+
−
*/+
−
void DEF105615L()+
−
	{+
−
   	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-3467 DEF105615 DBMS, CDbColSet::operator[](TDbColNo) operator may access an invalid memory"));+
−
	RFs fs;+
−
	TInt err = fs.Connect();+
−
	TheTest(err == KErrNone);+
−
+
−
	RDbNamedDatabase db;+
−
	err = db.Replace(fs, KDbName);+
−
	TheTest(err == KErrNone);+
−
+
−
	const TInt KColCnt = 3;+
−
+
−
	err = db.Execute(_L("CREATE TABLE A(A1234567890 INTEGER, B1234567890 INTEGER, C12345 INTEGER)"));+
−
	TheTest(err == KErrNone);+
−
	err = db.Execute(_L("CREATE INDEX I1 ON A(A1234567890, B1234567890, C12345)"));+
−
	TheTest(err == KErrNone);+
−
+
−
	RDbTable tbl;+
−
	err = tbl.Open(db, _L("A"));+
−
	TheTest(err == KErrNone);+
−
+
−
	//It is very hard to reproduce the problem, because the memory region after the memory, occupied by+
−
	//CDbColSet's array, may be valid. That is the reason the test is repeated in a loop KTestCnt times,+
−
	//where every  ColSetL() call will allocate a new block of memory for its array and at some point TDbCol's+
−
	//copy constructor and "=" operator may try to access an invalid memory area, if the compiler generated+
−
	//ones are used.+
−
	const TInt KTestCnt = 100;+
−
	TInt i;+
−
	CDbColSet* colset[KTestCnt];+
−
	for(i=0;i<KTestCnt;++i)+
−
		{+
−
		TRAP(err, colset[i] = tbl.ColSetL());+
−
		TheTest(err == KErrNone);+
−
		TDbCol lastCol = (*colset[i])[KColCnt];		//copy constructor+
−
		lastCol = (*colset[i])[KColCnt];			//"=" operator+
−
		}+
−
	for(i=0;i<KTestCnt;++i)+
−
		{+
−
		delete colset[i];+
−
		}+
−
+
−
	tbl.Close();+
−
+
−
	//The same test is repeated for TDbKeyCol's copy constructor and "=" operator+
−
	CDbKey* key[KTestCnt];+
−
	for(i=0;i<KTestCnt;++i)+
−
		{+
−
		TRAP(err, key[i] = db.KeyL(_L("I1"), _L("A")));+
−
		TheTest(err == KErrNone);+
−
		TDbKeyCol lastKeyCol = (*key[i])[KColCnt - 1];	//copy constructor+
−
		lastKeyCol = (*key[i])[KColCnt - 1];			//"=" operator+
−
		}+
−
	for(i=0;i<KTestCnt;++i)+
−
		{+
−
		delete key[i];+
−
		}+
−
+
−
	db.Close();+
−
	err = fs.Delete(KDbName);+
−
	TheTest(err == KErrNone);+
−
	fs.Close();+
−
	}+
−
+
−
/**+
−
@SYMTestCaseID			SYSLIB-DBMS-UT-3469+
−
@SYMTestCaseDesc		Test for DEF105615 "DBMS, CDbColSet::operator[](TDbColNo) operator may access an invalid memory".+
−
						The test creates TDbCol and TDbKeyCol objects, creates their copies using copy constructors+
−
						and "=" operators and checks that the copies were constructed correctly,+
−
@SYMTestPriority		High+
−
@SYMTestActions			Test for DEF105615 "DBMS, CDbColSet::operator[](TDbColNo) operator may access an invalid memory".+
−
@SYMTestExpectedResults The test must not fail+
−
@SYMREQ					DEF105615+
−
*/+
−
void DEF105615_2()+
−
	{+
−
   	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-3469 DEF105615 DBMS, CDbColSet::operator[](TDbColNo) operator may access an invalid memory - 2 "));+
−
+
−
   	const TDbColType KColType = EDbColText16;+
−
   	const TInt KMaxColLen = 73;+
−
   	const TInt KColAttributes = TDbCol::ENotNull;+
−
   	_LIT(KColName, "Name");+
−
+
−
   	TDbCol srcDbCol(KColName, EDbColText16, KMaxColLen);+
−
   	srcDbCol.iAttributes = KColAttributes;+
−
+
−
	//TDbCol - copy constructor+
−
   	TDbCol dbColCopy1(srcDbCol);+
−
   	TheTest(dbColCopy1.iType == srcDbCol.iType && dbColCopy1.iType == KColType);+
−
   	TheTest(dbColCopy1.iMaxLength == srcDbCol.iMaxLength && dbColCopy1.iMaxLength == KMaxColLen);+
−
   	TheTest(dbColCopy1.iAttributes == srcDbCol.iAttributes && dbColCopy1.iAttributes == KColAttributes);+
−
   	TheTest(dbColCopy1.iName == srcDbCol.iName && dbColCopy1.iName == KColName);+
−
+
−
	//TDbCol - "=" operator+
−
   	TDbCol dbColCopy2;+
−
   	dbColCopy2 = srcDbCol;+
−
   	TheTest(dbColCopy2.iType == srcDbCol.iType && dbColCopy2.iType == KColType);+
−
   	TheTest(dbColCopy2.iMaxLength == srcDbCol.iMaxLength && dbColCopy2.iMaxLength == KMaxColLen);+
−
   	TheTest(dbColCopy2.iAttributes == srcDbCol.iAttributes && dbColCopy2.iAttributes == KColAttributes);+
−
   	TheTest(dbColCopy2.iName == srcDbCol.iName && dbColCopy2.iName == KColName);+
−
+
−
	//TDbCol - self assignment+
−
	srcDbCol = srcDbCol;+
−
   	TheTest(srcDbCol.iType == KColType);+
−
   	TheTest(srcDbCol.iMaxLength == KMaxColLen);+
−
   	TheTest(srcDbCol.iAttributes == KColAttributes);+
−
   	TheTest(srcDbCol.iName == KColName);+
−
+
−
   	const TInt KKeyLen = 29;+
−
   	const TDbKeyCol::TOrder KKeyOrder = TDbKeyCol::EDesc;+
−
   	_LIT(KKeyName, "Name22");+
−
+
−
   	TDbKeyCol srcDbKeyCol(KKeyName, KKeyLen, KKeyOrder);+
−
+
−
	//TDbKeyCol - copy constructor+
−
   	TDbKeyCol dbKeyColCopy1(srcDbKeyCol);+
−
   	TheTest(dbKeyColCopy1.iOrder == srcDbKeyCol.iOrder && dbKeyColCopy1.iOrder == KKeyOrder);+
−
   	TheTest(dbKeyColCopy1.iLength == srcDbKeyCol.iLength && dbKeyColCopy1.iLength == KKeyLen);+
−
   	TheTest(dbKeyColCopy1.iName == srcDbKeyCol.iName && dbKeyColCopy1.iName == KKeyName);+
−
+
−
	//TDbKeyCol - "=" operator+
−
   	TDbKeyCol dbKeyColCopy2;+
−
   	dbKeyColCopy2 = srcDbKeyCol;+
−
   	TheTest(dbKeyColCopy2.iOrder == srcDbKeyCol.iOrder && dbKeyColCopy2.iOrder == KKeyOrder);+
−
   	TheTest(dbKeyColCopy2.iLength == srcDbKeyCol.iLength && dbKeyColCopy2.iLength == KKeyLen);+
−
   	TheTest(dbKeyColCopy2.iName == srcDbKeyCol.iName && dbKeyColCopy2.iName == KKeyName);+
−
+
−
	//TDbKeyCol - self assignment+
−
	srcDbKeyCol = srcDbKeyCol;+
−
   	TheTest(srcDbKeyCol.iOrder == KKeyOrder);+
−
   	TheTest(srcDbKeyCol.iLength == KKeyLen);+
−
   	TheTest(srcDbKeyCol.iName == KKeyName);+
−
   	}+
−
+
−
/**+
−
@SYMTestCaseID          SYSLIB-DBMS-UT-3413+
−
@SYMTestCaseDesc        Testing that "incremental update" operations running in one connection does not+
−
						interfere with database operations executed from a second connection+
−
@SYMTestPriority        High+
−
@SYMTestActions         Create a test database with one table and insert some records there (> 100).+
−
						Create 2 database connections.+
−
						Open that database from connection 1 and execute an incremental update operation+
−
						in a transaction. At the same time try to open and close the same table from+
−
						connection 2, mixing these operations with the RDbUpdate::Next() calls from+
−
						connection 1. So the call pattern should be:+
−
						@code+
−
						RDbUpdate dbUpdate;+
−
						....+
−
						while((err = dbUpdate.Next()) > 0)		//from "Conenction 1"+
−
							{+
−
							RDbTable tbl;+
−
							err = tbl.Open(TheDb2, _L("A"));	//from "Conenction 2"+
−
							...+
−
							}+
−
						@endcode+
−
@SYMTestExpectedResults The test should not fail or panic.+
−
@SYMDEF INC101720+
−
*/+
−
void Defect_INC101720()+
−
	{+
−
    TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-3413 "));+
−
	//Create the test database+
−
	TInt err = TheDb1.Replace(TheFs, KDbName);+
−
	TEST2(err, KErrNone);+
−
	TheDb1.Close();+
−
	//Establish the first database connection+
−
	err = TheDbs1.Connect();+
−
	TEST2(err, KErrNone);+
−
	err = TheDb1.Open(TheDbs1, KDbName);+
−
	TEST2(err, KErrNone);+
−
	//Create a test table and fill the table with enough test records (> 100)+
−
	err = TheDb1.Execute(_L("CREATE TABLE A(Id COUNTER, Id2 INTEGER, Name LONG VARCHAR)"));+
−
	TEST2(err, KErrNone);+
−
	const TInt KTestRecCount = 200;+
−
	err = TheDb1.Begin();+
−
	TEST2(err, KErrNone);+
−
	for(TInt i=0;i<KTestRecCount;++i)+
−
		{+
−
		_LIT(KSqlFmtStr, "INSERT INTO A(Id2, Name) VALUES(%d, 'TestNameString')");+
−
		TBuf<100> sql;+
−
		TUint32 id = Math::Random() % KTestRecCount;+
−
		sql.Format(KSqlFmtStr, id + 1);+
−
		err = TheDb1.Execute(sql);+
−
		TEST2(err, 1);+
−
		}+
−
	err = TheDb1.Commit();+
−
	TEST2(err, KErrNone);+
−
	//Establish a second connection with the same test database+
−
	err = TheDbs2.Connect();+
−
	TEST2(err, KErrNone);+
−
	err = TheDb2.Open(TheDbs2, KDbName);+
−
	TEST2(err, KErrNone);+
−
	//The test: Conenction 1 - "incremental update" operation.+
−
	//			Connection 2 - "open table/close table" operations mixed with the incremental Next-s.+
−
	//Expectation: The test must not fail.+
−
	err = TheDb1.Begin();+
−
	TEST2(err, KErrNone);+
−
	RDbUpdate dbUpdate;+
−
	err = dbUpdate.Execute(TheDb1, _L("UPDATE A SET Name = 'ModifiedNameString' WHERE Id2 > 10"));+
−
	TEST2(err, KErrNone);+
−
	TInt step = 0;+
−
	while((err = dbUpdate.Next()) > 0)+
−
		{+
−
		++step;+
−
		RDbTable tbl;+
−
		err = tbl.Open(TheDb2, _L("A"));+
−
		TEST2(err, KErrNone);+
−
		tbl.Close();+
−
		}+
−
	TEST(step > 1);//just to be sure that the test executes dbUpdate.Next() more than once+
−
	TEST2(err, KErrNone);+
−
	dbUpdate.Close();+
−
	err = TheDb1.Commit();+
−
	TEST2(err, KErrNone);+
−
	//Cleanup+
−
	TheDb2.Close();+
−
	TheDbs2.Close();+
−
	TheDb1.Close();+
−
	TheDbs1.Close();+
−
	}+
−
+
−
/**+
−
@SYMTestCaseID          SYSLIB-DBMS-UT-3484+
−
@SYMTestCaseDesc        DBMS Hindi collation doesn't work on long text fields.+
−
@SYMTestPriority        Medium+
−
@SYMTestActions         This test is to check that DBMS correctly sorts columns using Collation, when+
−
						the columns are of type EDbColLongText16.  Previous implementations split the+
−
						strings to be compared into chunks, however this could cause it to be sorted+
−
						incorrectly if it was split on a combining or accent character.  This fault+
−
						occurs on the default locale as well as Hindi.  Test steps:+
−
						* Create a database table and adds several unicode strings to EDbColLongText16+
−
						  column in table.  One set of strings have an ascii character followed by+
−
						  an accent (e + ') and the other set have the combined equivilant ascii+
−
						  character (è).  These should have the same sort order,however if are split+
−
						  then will compare differently.+
−
						* Sort the columns using EDbCompareCollated+
−
						* Check that the columns were sorted in the correct order+
−
@SYMTestExpectedResults The columns should get sorted into ascending order correctly+
−
@SYMDEF INC107268+
−
*/+
−
void Defect_INC107268L()+
−
	{+
−
	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-3484 Defect INC107268 - DBMS Hindi collation doesn't work on long text fields"));+
−
+
−
     // some unicode characters+
−
     const TChar Ka(0x0061); 		// a+
−
     const TChar Kb(0x0062); 		// b+
−
     const TChar Ke(0x0065);			// e+
−
     const TChar Kgrave(0x0060); 	// ' (grave)+
−
     const TChar Kegrave(0x00e8);  	// e with grave+
−
     const TChar K1(0x0031);			// 1+
−
     const TChar K2(0x0032);			// 2+
−
+
−
  	// the maximum characters in a EDbColLongText16 string before dbms stops storing+
−
  	// the string inline, and we need to read it from a stream (see TBlobKey).+
−
  	const TInt KInlineLimit = 127;+
−
+
−
  	// maximum number of characters buffered in TBlobKey when string stored out of line.+
−
  	// (see TBlobKey::ETruncSize which is in bytes)+
−
  	const TInt KTruncLimit = 16;+
−
+
−
  	const TInt KMaxStringSize = 256;+
−
+
−
  	TBuf<KMaxStringSize> inLineBoundryA;+
−
  	TBuf<KMaxStringSize> inLineBoundryB;+
−
  	TBuf<KMaxStringSize> truncBoundryA;+
−
  	TBuf<KMaxStringSize> truncBoundryB;+
−
  	TBuf<KMaxStringSize> padding;+
−
+
−
     // this string will be stored inline.  It should sort to be < stringB+
−
     inLineBoundryA.Fill(Ka, KInlineLimit-2);+
−
     inLineBoundryA.Append(Kegrave);+
−
     inLineBoundryA.Append(K1);+
−
+
−
     // this string is just over the break point, so *is* truncated.+
−
     // this is expected to get sorted incorrecly as combining character is split off (negative test case)+
−
     inLineBoundryB.Fill(Ka, KInlineLimit-2);+
−
     inLineBoundryB.Append(Ke);+
−
     inLineBoundryB.Append(Kgrave);+
−
     inLineBoundryB.Append(K2);+
−
+
−
     padding.Fill(Kb, KInlineLimit);+
−
+
−
     // this string is longger that KInlineLimit so is stored out of line+
−
     truncBoundryA.Fill(Kb, KTruncLimit-2);+
−
     truncBoundryA.Append(Kegrave);+
−
     truncBoundryA.Append(K1);+
−
     truncBoundryA.Append(padding);+
−
+
−
     // this string has combining characters that fall on boundry of ETruncSize value (32 bytes)+
−
     truncBoundryB.Fill(Kb, KTruncLimit-2);+
−
     truncBoundryB.Append(Ke);+
−
     truncBoundryB.Append(Kgrave);+
−
     truncBoundryB.Append(K2);+
−
     truncBoundryB.Append(padding);+
−
+
−
+
−
     // e and '(grave) characters seperately+
−
     TBuf<3> e_grave;+
−
     e_grave.Append( Ke );+
−
     e_grave.Append( Kgrave );+
−
+
−
     // e with grave character - this should sort the same as e_grave+
−
     TBuf<3> egrave;+
−
     egrave.Append( Kegrave );+
−
+
−
     TBuf<1> nullString;+
−
+
−
 	e_grave.Append(K2); // make e_grave sort second+
−
     egrave.Append(K1);  // make egrave sort first+
−
+
−
     // Check with database+
−
     _LIT(KPosLmLandmarkTable, "lmt_landmark");+
−
     _LIT(KPosLmLandmarkIdCol, "lmc_lmid");+
−
     _LIT(KPosLmNameCol, "lmc_name");+
−
+
−
     TInt err = TheDb1.Replace( TheFs, KDbName );+
−
     TEST2 (err, KErrNone);+
−
 	CleanupClosePushL(TheDb1);+
−
+
−
     CDbColSet* columns = CDbColSet::NewLC();+
−
     TDbCol idField( KPosLmLandmarkIdCol, EDbColUint32 );+
−
     idField.iAttributes |= TDbCol::EAutoIncrement;+
−
     columns->AddL( idField );+
−
     columns->AddL( TDbCol( KPosLmNameCol, EDbColLongText16 ) ); // Works with EDbColText16.  Defect only for EDbColLongText16.+
−
+
−
     err = TheDb1.CreateTable( KPosLmLandmarkTable, *columns );+
−
     TEST2 (err, KErrNone);+
−
     CleanupStack::PopAndDestroy(columns);+
−
+
−
     RDbTable table;+
−
     err = table.Open( TheDb1, KPosLmLandmarkTable );+
−
     TEST2 (err, KErrNone);+
−
     CleanupClosePushL(table);+
−
+
−
 	// add rows to table+
−
   	table.InsertL();+
−
     table.SetColL( 2, egrave); // row 0 - sorted 8th+
−
     table.PutL();+
−
+
−
 	table.InsertL();+
−
     table.SetColL( 2, e_grave ); // row 1 - sorted 9th+
−
     table.PutL();+
−
+
−
     table.InsertL();+
−
     table.SetColL( 2, inLineBoundryA ); // row 2 - sorted 3rd (incorrectly - negative test case)+
−
     table.PutL();+
−
+
−
     table.InsertL();+
−
     table.SetColL( 2, inLineBoundryB ); // row 3 - sorted 2nd (incorrectly - negative test case)+
−
     table.PutL();+
−
+
−
     table.InsertL();+
−
     table.SetColL( 2, nullString ); // row 4 - sorted 1st+
−
     table.PutL();+
−
+
−
   	table.InsertL();+
−
     table.SetColL( 2, truncBoundryB ); // row 5 - sorted 5th+
−
     table.PutL();+
−
+
−
     table.InsertL();+
−
     table.SetColL( 2, truncBoundryA ); // row 6 - sorted 4th+
−
     table.PutL();+
−
+
−
+
−
     CleanupStack::PopAndDestroy(); // table.close()+
−
+
−
 	// do an sql select with Order By to sort columns+
−
     _LIT(KPosLmSqlSelectOrderByString, "SELECT %S, %S FROM %S ORDER BY %S");+
−
     TBuf<200> sql;+
−
     sql.Format( KPosLmSqlSelectOrderByString,+
−
                 &KPosLmLandmarkIdCol,+
−
                 &KPosLmNameCol,+
−
                 &KPosLmLandmarkTable,+
−
                 &KPosLmNameCol);+
−
+
−
     RDbView view;+
−
     CleanupClosePushL(view);+
−
     err = view.Prepare( TheDb1, TDbQuery( sql, EDbCompareCollated ) );+
−
     TEST2 (err, KErrNone);+
−
     err = view.EvaluateAll();+
−
     TEST2 (err, KErrNone);+
−
+
−
     // Now check that view is ordered correctly+
−
     const TUint32 ExpectedOrder[] = {4,3,2,6,5,0,1};+
−
     TInt x = 0;+
−
     while (view.NextL())+
−
         {+
−
         view.GetL();+
−
         TEST2(view.ColUint32(1), ExpectedOrder[x]); // check we got the expected order+
−
         x++;+
−
         }+
−
     TEST2(x, 7); // check we got the right number of values+
−
     CleanupStack::PopAndDestroy(2); // TheDb1.Close(); view.Close()+
−
 	}+
−
+
−
+
−
/**+
−
@SYMTestCaseID          PDS-DBMS-UT-4001+
−
@SYMTestCaseDesc        INC128224 SQL statement with ESCAPE panics in DBMS.+
−
@SYMTestPriority        High+
−
@SYMTestActions         The test verifies that SELECT statement with a LIKE redicate with an ESCAPE clause +
−
						followed by another LIKE predicate does not causes a crash in DBMS.+
−
						The test creates a test database, inserts some records and then runs a SELECT+
−
						statement that has one LIKE predicate with an ESCAPE followed by another LIKE.+
−
@SYMTestExpectedResults The test should pass and should not crash the DBMS+
−
@SYMDEF INC128224+
−
*/+
−
void INC128224L()+
−
	{+
−
   	TheTest.Next(_L(" @SYMTestCaseID:PDS-DBMS-UT-4001 INC128224 SQL statement with ESCAPE panics in DBMS"));+
−
	+
−
	TInt err = TheDb1.Replace(TheFs, KDbName);+
−
	TEST2(err, KErrNone);+
−
	+
−
	err = TheDb1.Execute(_L("CREATE TABLE A(T1 VARCHAR(100),T2 VARCHAR(150))"));+
−
	TEST2(err, KErrNone);+
−
	err = TheDb1.Execute(_L("INSERT INTO A(T1,T2) VALUES('AAAAAA','HGS')"));+
−
	TEST2(err, 1);+
−
	err = TheDb1.Execute(_L("INSERT INTO A(T1,T2) VALUES('BBBBBB','RRR')"));+
−
	TEST2(err, 1);+
−
	err = TheDb1.Execute(_L("INSERT INTO A(T1,T2) VALUES('C*CCCCC','AAQWWT')"));+
−
	TEST2(err, 1);+
−
	err = TheDb1.Execute(_L("INSERT INTO A(T1,T2) VALUES('DDDDDD','TUQQPQQQQSSS')"));+
−
	TEST2(err, 1);+
−
	err = TheDb1.Execute(_L("INSERT INTO A(T1,T2) VALUES('C*CABS','IAAAIAAAIA')"));+
−
	TEST2(err, 1);+
−
	+
−
	RDbView view;+
−
	err = view.Prepare(TheDb1, _L("SELECT * FROM A WHERE (T1 LIKE '*C\\*C*' ESCAPE '\\') AND (T2 LIKE 'I?A*')"));+
−
	TEST2(err, KErrNone);+
−
	TInt cnt = 0;+
−
	while(view.NextL())+
−
		{+
−
		view.GetL();+
−
		TPtrC t1 = view.ColDes(1);+
−
		TPtrC t2 = view.ColDes(2);+
−
		RDebug::Print(_L("T1=\"%S\", T2=\"%S\"\r\n"), &t1, &t2);+
−
		++cnt;+
−
		}+
−
	view.Close();+
−
	TEST2(cnt, 1);+
−
	+
−
	TheDb1.Close();+
−
	(void)TheFs.Delete(KDbName);+
−
	}+
−
   +
−
LOCAL_C void DoTestsL ()+
−
	{+
−
	__UHEAP_MARK;+
−
	CleanupClosePushL(TheFs);+
−
	Defect_INC076370L();+
−
	Defect_INC083027L();+
−
	Defect_DEF44697L ();+
−
	Defect_INC093657L();+
−
	Defect_INC101720();+
−
	DEF105615L();+
−
	DEF105615_2();+
−
	Defect_INC107268L();+
−
	INC128224L();+
−
	CleanupStack::PopAndDestroy(); // TheFs.Close()+
−
	__UHEAP_MARKEND;+
−
	}+
−
+
−
+
−
GLDEF_C TInt E32Main ()+
−
	{+
−
	__UHEAP_MARK;+
−
	TheTest.Title ();+
−
	TheTest.Start (_L ("Verify Defect Fixes"));+
−
+
−
	TheTrapCleanup = CTrapCleanup::New ();+
−
	__ASSERT_ALWAYS (TheTrapCleanup!=NULL, User::Invariant ());+
−
+
−
	TInt err = TheFs.Connect();+
−
	TheTest(err == KErrNone);+
−
+
−
	TRAP (err,DoTestsL ());+
−
	TheTest (err==KErrNone);+
−
+
−
	delete TheTrapCleanup;+
−
+
−
	//Wait some time, because DBMS server won't be destroyed right after the last DBMS session+
−
	//being clossed.+
−
	TheTest.Printf(_L("Wait DBMS server shutdown...\n"));+
−
	const TInt KExitDelay = 6000000;+
−
	User::After(KExitDelay);+
−
+
−
	TheTest.End ();+
−
	TheTest.Close ();+
−
+
−
	__UHEAP_MARKEND;+
−
	return (0);+
−
	}+
−