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