--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/dbms/tdbms/t_dbsrv.cpp Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,1334 @@
+// 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:
+//
+
+#include <d32dbms.h>
+#include <s32file.h>
+#include <e32test.h>
+#include <e32math.h>
+#include <hal.h>
+#include "D32DBAS.H"
+
+LOCAL_D RTest test(_L("t_dbsrv: Test DBMS server"));
+LOCAL_D CTrapCleanup* TheTrapCleanup;
+LOCAL_D RFs TheFs;
+LOCAL_D RDbs TheDbs;
+LOCAL_D RDbNamedDatabase TheDatabase;
+LOCAL_D RDbTable TheTable;
+LOCAL_D RDbView TheView;
+
+const TInt KTestCleanupStack=0x40;
+const TPtrC KTestDatabase(_S("c:\\dbms-tst\\share.db"));
+const TPtrC KTestFormat(_S(""));
+const TPtrC KTable1(_S("Table1"));
+const TPtrC KTable2(_S("Table2"));
+const TInt KRowCount=1000;
+const TUint KExitDelay=6*0x100000; // ~6 seconds
+
+const TPtrC KCreateTable1=_S("CREATE TABLE Table1 (Id INTEGER,Name CHAR(200),Memo LONG VARCHAR,Memo2 LONG VARBINARY)");
+const TPtrC KCreateTable2=_S("CREATE TABLE Table2 (Id INTEGER,Name CHAR(200),Memo LONG VARCHAR)");
+const TPtrC KDropTable1=_S("DROP TABLE Table1");
+const TPtrC KDropTable2=_S("DROP TABLE Table2");
+
+_LIT(KTestSpdFile1, "c:\\dbms-tst\\11335577.spd");
+_LIT(KTestSpdFile2, "c:\\dbms-tst\\11335578.spd");
+_LIT(KTestSpdFile3, "c:\\dbms-tst\\11335579.spd");
+_LIT(KTestSpdFile4, "c:\\dbms-tst\\1133557A.spd");
+
+const TInt KReturnValueForCompare = 10;
+const TInt KReturnValueForFind = 20;
+
+class TTimer
+ {
+public:
+ void Start(const TDesC& aDes);
+ void Stop();
+private:
+ TUint iTicks;
+ };
+
+static TTimer TheTimer;
+
+void TTimer::Start(const TDesC& aDes)
+ {
+ test.Printf(_L(" %S: "),&aDes);
+ iTicks=User::FastCounter();
+ }
+
+void TTimer::Stop()
+ {
+ TUint ticks = User::FastCounter() - iTicks;
+ TInt freq = 0;
+ test(HAL::Get(HAL::EFastCounterFrequency, freq) == KErrNone);
+ const TInt KMicroSecIn1Sec = 1000000;
+ const TInt KMsIn1Sec = 1000;
+ double v = ((double)ticks * KMicroSecIn1Sec) / (double)freq; TInt v2 = (TInt)v;
+ test.Printf(_L("%d ms\r\n"),v2/KMsIn1Sec);
+ }
+
+void DeleteTestFiles()
+ {
+ (void)TheFs.Delete(KTestDatabase);
+ (void)TheFs.Delete(KTestSpdFile1);
+ (void)TheFs.Delete(KTestSpdFile2);
+ (void)TheFs.Delete(KTestSpdFile3);
+ (void)TheFs.Delete(KTestSpdFile4);
+ }
+
+void Check(TInt aValue,TInt aExpected,TInt aLine)
+ {
+ if (aValue!=aExpected)
+ {
+ DeleteTestFiles();
+ test.Printf(_L("*** Expected %d: got %d\r\n"),aExpected,aValue);
+ test.operator()(EFalse,aLine);
+ }
+ }
+#define test2(a,b) Check(a,b,__LINE__)
+
+LOCAL_C void Connect()
+ {
+ test2(TheDbs.Connect(),KErrNone);
+ TheDbs.ResourceMark();
+ }
+
+LOCAL_C void Disconnect()
+ {
+ TheDbs.ResourceCheck();
+ TheDbs.Close();
+ }
+
+LOCAL_C void Execute(const TDesC& aSql)
+ {
+ test2 (TheDatabase.Execute(aSql),KErrNone);
+ }
+
+LOCAL_C void WriteRecordsL(TInt aCount)
+ {
+ TheTimer.Start(_L("writing"));
+ TheDatabase.Begin();
+ TBuf<10> text;
+ TInt jj=0;
+ for (TInt ii=0;ii<aCount;++ii)
+ {
+ TheTable.InsertL();
+ jj=(jj+23);
+ if (jj>=aCount)
+ jj-=aCount;
+ TheTable.SetColL(1,jj);
+ text.Num(jj);
+ TheTable.SetColL(2,text);
+ TheTable.PutL();
+ }
+ test2 (TheDatabase.Commit(),KErrNone);
+ TheTimer.Stop();
+ }
+
+LOCAL_C void Ipc(TInt aCount)
+ {
+ TheTimer.Start(_L("ipc"));
+ while (--aCount>=0)
+ TheDatabase.InTransaction();
+ TheTimer.Stop();
+ }
+
+LOCAL_C void LoopL(RDbTable::TPosition aDirection)
+ {
+ TheTimer.Start(_L("loop"));
+ TInt cc=0;
+ while (TheTable.GotoL(aDirection))
+ ++cc;
+ test2 (cc,TheTable.CountL());
+ TheTimer.Stop();
+ }
+
+LOCAL_C void IterateL(RDbTable::TPosition aDirection)
+ {
+ TheTimer.Start(_L("iterate"));
+ TInt cc=0;
+ while (TheTable.GotoL(aDirection))
+ {
+ ++cc;
+ TheTable.GetL();
+ TBuf<10> text;
+ text.Num(TheTable.ColInt(1));
+ test (text==TheTable.ColDes(2));
+ }
+ test2 (cc,TheTable.CountL());
+ TheTimer.Stop();
+ }
+
+LOCAL_C void LocateL(const TDesC& aSql)
+ {
+ test2 (TheView.Prepare(TheDatabase,aSql),KErrNone);
+ test2 (TheView.EvaluateAll(),KErrNone);
+ TheTimer.Start(_L("locate"));
+ test (!TheView.NextL());
+ TheTimer.Stop();
+ TheView.Close();
+ }
+
+LOCAL_C void Locate1L()
+ {
+ LocateL(_L("select * from Table1 where id is null"));
+ }
+
+LOCAL_C void Locate2L()
+ {
+ LocateL(_L("select * from Table1 where id = -12345"));
+ }
+
+LOCAL_C TInt DeleteL()
+ {
+ TheTimer.Start(_L("deleting"));
+ TheDatabase.Begin();
+ TInt cc=0;
+ TheTable.BeginningL();
+ while (TheTable.NextL())
+ {
+ ++cc;
+ TheTable.DeleteL();
+ }
+ test (TheTable.CountL()==0);
+ test (TheDatabase.Commit()==KErrNone);
+ TheTimer.Stop();
+ return cc;
+ }
+
+LOCAL_C TInt DeleteSQL()
+ {
+ TheTimer.Start(_L("deleting [SQL]"));
+ TInt cc=TheDatabase.Execute(_L("delete from Table1"));
+ test (cc>=KErrNone);
+ test (TheTable.CountL()==0);
+ TheTimer.Stop();
+ return cc;
+ }
+
+LOCAL_C void BenchmarkL()
+ {
+ TInt r=TheTable.Open(TheDatabase,KTable1);
+ TheTable.LastL();
+ test (r==KErrNone);
+ Ipc(KRowCount);
+ TheTable.Reset();
+ LoopL(TheTable.ENext);
+ TheTable.Reset();
+ IterateL(TheTable.ENext);
+ Locate1L();
+ Locate2L();
+ TheTable.Close();
+ }
+
+const TPtrC KSemaphore(_S("Connect-test"));
+
+LOCAL_C TInt ConnectThread(TAny*)
+ {
+ RSemaphore s;
+ s.OpenGlobal(KSemaphore,EOwnerThread);
+ RDbs dbs;
+ dbs.Connect();
+ s.Signal();
+ User::After(0x100000);
+ s.Wait();
+ dbs.Close();
+ s.Signal();
+ s.Close();
+ return KErrNone;
+ }
+
+/**
+@SYMTestCaseID SYSLIB-DBMS-CT-0605
+@SYMTestCaseDesc Single and multiple database connection tests
+@SYMTestPriority Medium
+@SYMTestActions Setup a DBMS server session Search the server for pattern matching
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+LOCAL_C void TestConnect()
+ {
+ test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0605 Single connection "));
+ test (TheDbs.Connect()==KErrNone);
+ TheDbs.Close();
+ test.Next(_L("Deferred exit"));
+ TFindServer find(_L("!DBMS server"));
+ TFullName result;
+ test2 (find.Next(result),KErrNone);
+ test.Next(_L("Multiple connection"));
+ Connect();
+ RDbs dbs;
+ test2 (dbs.Connect(),KErrNone);
+ Disconnect();
+ dbs.Close();
+ test.Next(_L("Deferred exit"));
+ find.Find(_L("!DBMS server"));
+ test2 (find.Next(result),KErrNone);
+ User::After(KExitDelay);
+ find.Find(_L("!DBMS server"));
+ test2 (find.Next(result),KErrNotFound);
+ test.Next(_L("multiple thread connections"));
+ RSemaphore s;
+ test2 (s.CreateGlobal(KSemaphore,0,EOwnerThread),KErrNone);
+ RThread t;
+ test2 (t.Create(KSemaphore,ConnectThread,0x2000,0x1000,0x10000,0,EOwnerThread),KErrNone);
+ t.Resume();
+ TRequestStatus st;
+ t.Logon(st);
+ t.Close();
+ s.Wait();
+ Connect();
+ s.Signal();
+ s.Close();
+ User::WaitForRequest(st);
+ test2 (TheDbs.ResourceCount(),0);
+ Disconnect();
+ test.Next(_L("Deferred exit"));
+ find.Find(_L("!DBMS server"));
+ test2 (find.Next(result),KErrNone);
+ User::After(KExitDelay);
+ find.Find(_L("!DBMS server"));
+ test2 (find.Next(result),KErrNotFound);
+ test.End();
+ }
+
+/**
+@SYMTestCaseID SYSLIB-DBMS-CT-0606
+@SYMTestCaseDesc Tests for benchmark
+@SYMTestPriority Medium
+@SYMTestActions Tests for creating database and writing a table.Test for no error conditions.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+LOCAL_C void TestBenchL()
+ {
+ test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0606 Create database "));
+ TInt r=TheDatabase.Replace(TheFs,KTestDatabase,KTestFormat);
+ test (r==KErrNone);
+ Execute(KCreateTable1);
+ test.Next(_L("write table"));
+ r=TheTable.Open(TheDatabase,KTable1);
+ test (r==KErrNone);
+ WriteRecordsL(KRowCount);
+ TheTable.Close();
+ test.Next(_L("BenchmarkL"));
+ TRAPD(errCode, BenchmarkL());
+ test(errCode == KErrNone);
+ test.Next(_L("Open server-side"));
+ TheDatabase.Close();
+ Connect();
+ r=TheDatabase.Open(TheDbs,KTestDatabase);
+ test (r==KErrNone);
+ test.Next(_L("BenchmarkL"));
+ TRAP(errCode, BenchmarkL());
+ test(errCode == KErrNone);
+ test.Next(_L("Wrap up"));
+ TheDatabase.Close();
+ Disconnect();
+ test.End();
+ }
+
+/**
+@SYMTestCaseID SYSLIB-DBMS-CT-0607
+@SYMTestCaseDesc Tests for opening a shared database
+@SYMTestPriority Medium
+@SYMTestActions Tests for database open,column type,write and drop table
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+LOCAL_C void TestOpenL()
+ {
+ test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0607 Create database "));
+ test2 (TheDatabase.Replace(TheFs,KTestDatabase,KTestFormat),KErrNone);
+ TheDatabase.Close();
+ test.Next(_L("Open as shared"));
+ Connect();
+ test2 (TheDatabase.Open(TheDbs,KTestDatabase),KErrNone);
+ Execute(KCreateTable1);
+ test2 (TheTable.Open(TheDatabase,KTable1),KErrNone);
+ test2 (TheTable.ColCount(),4);
+ test2 (TheTable.ColType(1),EDbColInt32);
+ test2 (TheTable.ColType(2),EDbColText);
+ test2 (TheTable.ColType(3),EDbColLongText);
+ test2 (TheTable.ColType(4),EDbColLongBinary);
+ delete TheTable.ColSetL();
+ test.Next(_L("write table"));
+ WriteRecordsL(KRowCount);
+ test.Next(_L("Check table"));
+ TheTable.Reset();
+ test (TheTable.AtBeginning());
+ test (!TheTable.AtRow());
+ test (!TheTable.AtEnd());
+ test2 (TheTable.CountL(),KRowCount);
+ IterateL(TheTable.ENext);
+ test (!TheTable.AtBeginning());
+ test (!TheTable.AtRow());
+ test (TheTable.AtEnd());
+ test.Next(_L("Delete rows"));
+ test2 (DeleteL(),KRowCount);
+ TheTable.Close();
+ test.Next(_L("Drop table"));
+ Execute(KDropTable1);
+ TheDatabase.Close();
+ Disconnect();
+ test.End();
+ }
+
+/**
+@SYMTestCaseID SYSLIB-DBMS-CT-0608
+@SYMTestCaseDesc Tests for database locking
+@SYMTestPriority Medium
+@SYMTestActions Tests for shared,exclusive locks on database
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+LOCAL_C void TestLocking()
+ {
+ TInt r;
+ RDbNamedDatabase db;
+ test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0608 Open databases "));
+ Connect();
+ test2 (TheDatabase.Open(TheDbs,KTestDatabase),KErrNone);
+ test2 (db.Open(TheDbs,KTestDatabase,KTestFormat),KErrNone);
+ RDbNotifier ob;
+ test2 (ob.Open(TheDatabase),KErrNone);
+//
+ test.Next(_L("Shared locks"));
+ TRequestStatus stat;
+ ob.NotifyUnlock(stat);
+ test2 (TheDatabase.Begin(),KErrNone);
+ test2 (db.Begin(),KErrNone);
+ test2 (TheDatabase.Commit(),KErrNone);
+ User::After(1);
+ test2 (stat.Int(),KRequestPending); // should not report yet
+ test2 (db.Commit(),KErrNone);
+ User::WaitForRequest(stat);
+ test2 (stat.Int(),ob.EUnlock);
+//
+ test.Next(_L("Exclusive locks"));
+ ob.NotifyUnlock(stat);
+ test2 (TheDatabase.Begin(),KErrNone);
+ test2 (db.Begin(),KErrNone);
+ test2 (TheDatabase.Execute(KCreateTable1),KErrLocked); // cannot acquire
+ test2 (db.Commit(),KErrNone); // release lock
+ test2 (TheDatabase.Execute(KCreateTable1),KErrNone); // upgrade to X-lock
+ test2 (db.Begin(),KErrLocked); // cannot share
+ test2 (TheTable.Open(db,KTable1),KErrNone);
+ TRAP(r,TheTable.InsertL()); // cannot lock
+ test2 (r,KErrLocked);
+ TheTable.Close();
+ test2 (db.Execute(KDropTable1),KErrLocked); // cannot lock
+ test2 (TheTable.Open(TheDatabase,KTable1),KErrNone);
+ TRAP(r,TheTable.InsertL()); // we own the lock
+ test2 (r,KErrNone);
+ TheTable.Cancel();
+ TheTable.Close();
+ test2 (TheDatabase.Execute(KDropTable1),KErrNone);
+ test2 (stat.Int(),KRequestPending); // no NotifyUnlock yet
+ test2 (TheDatabase.Commit(),KErrNone);
+ User::WaitForRequest(stat);
+ test2 (stat.Int(),ob.ECommit);
+//
+ ob.Close();
+ db.Close();
+ TheDatabase.Close();
+ Disconnect();
+ test.End();
+ }
+
+/**
+@SYMTestCaseID SYSLIB-DBMS-CT-0609
+@SYMTestCaseDesc Tests for sharing a database
+@SYMTestPriority Medium
+@SYMTestActions Tests for opening a database more than once.
+ Tests the integrity of the table data
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+LOCAL_C void TestShareL()
+ {
+ test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0609 Open database "));
+ Connect();
+ TInt r=TheDatabase.Open(TheDbs,KTestDatabase);
+ test (r==KErrNone);
+ Execute(KCreateTable1);
+ test.Next(_L("Open it again"));
+ RDbNamedDatabase db;
+ test (db.Open(TheDbs,KTestDatabase,KTestFormat)==KErrNone);
+ test (TheTable.Open(db,KTable1)==KErrNone);
+ test2 (TheTable.ColCount(),4);
+ test2 (TheTable.ColType(1),EDbColInt32);
+ test2 (TheTable.ColType(2),EDbColText);
+ test2 (TheTable.ColType(3),EDbColLongText);
+ test2 (TheTable.ColType(4),EDbColLongBinary);
+ delete TheTable.ColSetL();
+ TheTable.Close();
+//
+ test.Next(_L("write table"));
+ test (TheTable.Open(TheDatabase,KTable1)==KErrNone);
+ WriteRecordsL(KRowCount);
+ TheTable.Close();
+ test.Next(_L("Check table"));
+ TheDatabase.Close();
+ TheDatabase=db;
+ test (TheTable.Open(TheDatabase,KTable1)==KErrNone);
+ test (TheTable.AtBeginning());
+ test (!TheTable.AtRow());
+ test (!TheTable.AtEnd());
+ test (TheTable.CountL()==KRowCount);
+ IterateL(TheTable.ENext);
+ test (!TheTable.AtBeginning());
+ test (!TheTable.AtRow());
+ test (TheTable.AtEnd());
+ test.Next(_L("Delete rows"));
+ test (DeleteSQL()==KRowCount);
+ TheTable.Close();
+ test.Next(_L("Drop table"));
+ Execute(KDropTable1);
+ TheDatabase.Close();
+ Disconnect();
+ test.End();
+ }
+
+LOCAL_C void TestScenario1L()
+ {
+ test.Start(_L("Take stream-lock on client 2"));
+ test (TheView.FirstL());
+ TheView.GetL();
+ RDbColReadStream rcol;
+ rcol.OpenLC(TheView,3);
+ test2 (rcol.ReadUint16L(),0);
+ test.Next(_L("Take a [shared] transaction-lock on client 1"));
+ test2 (TheDatabase.Begin(),KErrNone);
+ test.Next(_L("Attempt a write-lock on client 1"));
+ TRAPD(r,TheTable.InsertL());
+ test2 (r,KErrLocked);
+ test2 (rcol.ReadUint16L(),1);
+ test.Next(_L("Release locks on client 1 and then 2"));
+ TheDatabase.Rollback();
+ CleanupStack::PopAndDestroy(); // rcol
+ test.End();
+ }
+
+LOCAL_C void TestScenario2L()
+ {
+ test.Start(_L("Take stream-lock on client 2"));
+ test (TheView.FirstL());
+ TheView.GetL();
+ RDbColReadStream rcol;
+ rcol.OpenLC(TheView,3);
+ test2 (rcol.ReadUint16L(),0);
+ test.Next(_L("Take a [shared] transaction-lock on client 1"));
+ test2 (TheDatabase.Begin(),KErrNone);
+ test.Next(_L("Attempt a write-lock on client 1"));
+ TRAPD(r,TheTable.InsertL());
+ test2 (r,KErrLocked);
+ test2 (rcol.ReadUint16L(),1);
+ test.Next(_L("Release client 2 stream-lock"));
+ CleanupStack::PopAndDestroy(); // rcol
+ test.Next(_L("Take write-lock on client 1"));
+ TheTable.InsertL(); // read-lock removed
+ test.Next(_L("release client 1 locks"));
+ TheTable.Cancel();
+ TheDatabase.Rollback();
+ test.End();
+ }
+
+LOCAL_C void TestScenario3L(RDbDatabase& aClient2)
+ {
+ test.Start(_L("Take transaction-lock on client 1"));
+ test2 (TheDatabase.Begin(),KErrNone);
+ test.Next(_L("Take stream-lock on client 2"));
+ test (TheView.FirstL());
+ TheView.GetL();
+ RDbColReadStream rcol;
+ rcol.OpenLC(TheView,3);
+ test2 (rcol.ReadUint16L(),0);
+ test.Next(_L("Release client 1 lock"));
+ TheDatabase.Rollback();
+ test.Next(_L("Take write-lock on client 2"));
+ RDbTable table2; // need a second cursor (cannot do insert with open streams)
+ test2 (table2.Open(aClient2,KTable1,table2.EInsertOnly),KErrNone);
+ TRAPD(r,table2.InsertL());
+ test2 (r,KErrNone);
+ test.Next(_L("Release stream-lock"));
+ CleanupStack::PopAndDestroy();
+ test.Next(_L("Release write-lock"));
+ table2.PutL();
+ table2.Close();
+ test.Next(_L("check the system is unlocked"));
+ test2 (TheDatabase.Begin(),KErrNone);
+ test2 (TheDatabase.Commit(),KErrNone);
+ test.End();
+ }
+
+LOCAL_C void TestScenario4L()
+ {
+ test.Start(_L("Take transaction-lock on client 1"));
+ test2 (TheDatabase.Begin(),KErrNone);
+ test.Next(_L("Take stream-lock on client 1"));
+ test (TheTable.FirstL());
+ TheTable.GetL();
+ RDbColReadStream rcol;
+ rcol.OpenLC(TheTable,3);
+ test2 (rcol.ReadUint16L(),0);
+ test.Next(_L("Take write-lock on client 1"));
+ RDbTable table2; // need a second cursor (cannot do insert with open streams)
+ test2 (table2.Open(TheDatabase,KTable1,table2.EInsertOnly),KErrNone);
+ TRAPD(r,table2.InsertL());
+ test2 (r,KErrNone);
+ test.Next(_L("Release write-lock"));
+ table2.PutL();
+ table2.Close();
+ test.Next(_L("Release stream-lock"));
+ CleanupStack::PopAndDestroy();
+ test.Next(_L("release transaction-lock"));
+ test2 (TheDatabase.Commit(),KErrNone);
+ test.End();
+ }
+
+LOCAL_C void TestScenario5L()
+ {
+ test.Start(_L("Begin compaction on client 1"));
+ RDbIncremental inc;
+ TInt s;
+ test2 (inc.Compact(TheDatabase,s),KErrNone);
+ test.Next(_L("Attempt a stream-lock on client 2"));
+ test (TheView.FirstL());
+ TheView.GetL();
+ RDbColReadStream rcol;
+ TRAPD(r,rcol.OpenL(TheView,3));
+ test (r==KErrLocked);
+ test.Next(_L("Attempt a stream-lock on client 1"));
+ TRAP(r,rcol.OpenL(TheTable,3));
+ test (r==KErrAccessDenied);
+ test.Next(_L("Release compaction lock"));
+ inc.Close();
+ test.End();
+ }
+
+LOCAL_C void TestScenario6L()
+ {
+ test.Start(_L("Begin compaction on client 1 - open and read columns"));
+ TheTable.Close();
+
+ RDbIncremental inc;
+ TInt s;
+ test2 (inc.Compact(TheDatabase,s),KErrNone);
+
+ test.Next(_L("Attempt to open a table on client 1"));
+ TInt r=TheTable.Open(TheDatabase,KTable1);
+ test (r==KErrNone);
+
+ //read short column data
+ TheTable.FirstL();
+ TheTable.GetL();
+ TheTable.ColInt32(1);
+
+ // We cant write to tables
+ TRAP(r,TheTable.InsertL());
+ test (r==KErrAccessDenied);
+
+ RDbColReadStream rcol;
+ // We can't read long columns
+ TheTable.FirstL();
+ TheTable.GetL();
+ TRAP(r, rcol.OpenL(TheTable,3));
+ test2 (r,KErrAccessDenied);
+
+ // can read other columns
+ TRAP(r, rcol.OpenL(TheTable,4));
+ test2 (r,KErrNone);
+ rcol.Close();
+
+ test.Next(_L("Release compaction lock"));
+ inc.Close();
+ test.End();
+ }
+
+LOCAL_C void TestScenario7L()
+ {
+ test.Start(_L("Open tables on client 1 - Begin compaction on client 1"));
+
+ TheTable.Close();
+ test.Next(_L("Attempt to open a table on client 1"));
+ TInt r=TheTable.Open(TheDatabase,KTable1);
+ test (r==KErrNone);
+
+ test.Next(_L("Begin compaction on client 1"));
+ RDbIncremental inc;
+ TInt s;
+ test2 (inc.Compact(TheDatabase,s),KErrNone);
+
+ //read short column data
+ TheTable.FirstL();
+ TheTable.GetL();
+ TheTable.ColInt32(1);
+
+ // We cant write to tables
+ TRAP(r,TheTable.InsertL());
+ test (r==KErrAccessDenied);
+
+ RDbColReadStream rcol;
+ // cant read 4K text
+ TheTable.FirstL();
+ TheTable.GetL();
+ TRAP(r, rcol.OpenL(TheTable,3));
+ test2 (r,KErrAccessDenied);
+
+ // can read 1K blob
+ TRAP(r, rcol.OpenL(TheTable,4));
+ test2 (r,KErrNone);
+ rcol.Close();
+
+ test.Next(_L("Release compaction lock"));
+ inc.Close();
+ test.End();
+ }
+
+LOCAL_C void TestScenario8L()
+ {
+ test.Start(_L("Take update-lock on client 1"));
+ test2 (TheDatabase.Begin(),KErrNone);
+ TheTable.InsertL();
+ test.Next(_L("Read blob without locking on client 2"));
+ test (TheView.FirstL());
+ TheView.GetL();
+ RDbColReadStream rcol;
+ rcol.OpenLC(TheView,4); // 1K blob
+ test2 (rcol.ReadInt32L(),0);
+ CleanupStack::PopAndDestroy();
+ TRAPD(r,rcol.OpenL(TheView,3)); // 4K text blob
+ test2 (r,KErrLocked);
+ test.Next(_L("Release client 1 lock"));
+ TheTable.Cancel();
+ TheDatabase.Rollback();
+ test.End();
+ }
+
+/**
+@SYMTestCaseID SYSLIB-DBMS-CT-0610
+@SYMTestCaseDesc Tests for a defect on database
+@SYMTestPriority Medium
+@SYMTestActions Tests for database connection
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+LOCAL_C void TestDefectL()
+ {
+ test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0610 Build test database "));
+ Connect();
+ TInt r=TheDatabase.Open(TheDbs,KTestDatabase);
+ test (r==KErrNone);
+ Execute(KCreateTable1);
+ test2 (TheTable.Open(TheDatabase,KTable1),KErrNone);
+ TheTable.InsertL();
+ RDbColWriteStream wcol;
+ wcol.OpenLC(TheTable,3);
+ TInt ii;
+ for (ii=0;ii<2048;++ii)
+ wcol.WriteUint16L(ii);
+ wcol.CommitL();
+ CleanupStack::PopAndDestroy();
+ wcol.OpenLC(TheTable,4);
+ for (ii=0;ii<256;++ii)
+ wcol.WriteInt32L(ii);
+ wcol.CommitL();
+ CleanupStack::PopAndDestroy();
+ TheTable.PutL();
+//
+ test.Next(_L("open client 2 connection"));
+ RDbNamedDatabase db;
+ test2 (db.Open(TheDbs,KTestDatabase,KTestFormat),KErrNone);
+ test2 (TheView.Prepare(db,_L("select * from Table1")),KErrNone);
+ test2 (TheView.EvaluateAll(),KErrNone);
+//
+ test.Next(_L("Scenario 1"));
+ TestScenario1L();
+//
+ test.Next(_L("Scenario 2"));
+ TestScenario2L();
+//
+ test.Next(_L("Scenario 3"));
+ TestScenario3L(db);
+//
+ test.Next(_L("Scenario 4"));
+ TestScenario4L();
+//
+ test.Next(_L("Scenario 5"));
+ TestScenario5L();
+//
+ test.Next(_L("Scenario 6"));
+ TestScenario6L();
+//
+ test.Next(_L("Scenario 7"));
+ TestScenario7L();
+//
+ test.Next(_L("Scenario 8"));
+ TestScenario8L();
+//
+
+ test.Next(_L("tidy up"));
+ test2 (TheDatabase.Begin(),KErrNone);
+ TheView.Close();
+ TheTable.Close();
+ db.Close();
+ Execute(KDropTable1);
+ test2 (TheDatabase.Commit(),KErrNone);
+ TheDatabase.Close();
+ Disconnect();
+ test.End();
+ }
+
+/**
+@SYMTestCaseID PDS-DBMS-CT-4002
+@SYMTestCaseDesc Testing RDbIncremental API
+@SYMTestPriority High
+@SYMTestActions Executing SQL using RDbIncremental, Altering tables, creating and droping indexes
+@SYMTestExpectedResults After execution Table should exist in DB, after altering, table colums should change,
+ creation of index should create index column in table, dropping index should remove
+ it from table
+@SYMDEF DEF135710
+*/
+LOCAL_C void TestRDbIncrementalAPIL()
+ {
+ test.Start(_L(" @SYMTestCaseID:PDS-DBMS-CT-4002 Testing RDbIncremental API"));
+
+ Connect();
+ TInt err = TheDatabase.Open(TheDbs,KTestDatabase);
+ test2(err, KErrNone);
+
+ test.Next(_L("RDbIncremental API"));
+ RDbIncremental inc;
+ TInt step;
+
+ test2(TheDatabase.Begin(), KErrNone);
+ err = inc.Execute(TheDatabase, KCreateTable2, step);
+ test2(err, KErrNone);
+ while(step > 0)
+ {
+ err = inc.Next(step);
+ test2(err, KErrNone);
+ }
+ inc.Close();
+
+ test.Next(_L("AlterTable"));
+ CDbColSet* colSet = CDbColSet::NewLC();
+ colSet->AddL(TDbCol(_L("Id2"), EDbColUint32));
+ colSet->AddL(TDbCol(_L("Memo2"), EDbColText));
+ test2(colSet->Count(), 2);
+ err = inc.AlterTable(TheDatabase, KTable2, *colSet, step);
+ test2(err, KErrNone);
+ while(step > 0)
+ {
+ err = inc.Next(step);
+ test2(err, KErrNone);
+ }
+ inc.Close();
+ err = TheDatabase.Commit();
+ test2(err, KErrNone);
+
+ test.Next(_L("CreateIndex"));
+ TDbKeyCol kcol(_L("Id2"), TDbKeyCol::EAsc);
+ CDbKey* key = CDbKey::NewLC();
+ test2(TheDatabase.Begin(), KErrNone);
+ key->AddL(kcol);
+ err = inc.CreateIndex(TheDatabase, _L("Id2"), KTable2, *key, step);
+ test2(err, KErrNone);
+ while(step > 0)
+ {
+ err = inc.Next(step);
+ test2(err, KErrNone);
+ }
+ inc.Close();
+
+ test.Next(_L("DropIndex"));
+ err = inc.DropIndex(TheDatabase, _L("Id2"), KTable2, step);
+ test2(err, KErrNone);
+ while(step > 0)
+ {
+ err = inc.Next(step);
+ test2(err, KErrNone);
+ }
+ inc.Close();
+ err = inc.Execute(TheDatabase, KDropTable2, step);
+ test2(err, KErrNone);
+ while(step > 0)
+ {
+ err = inc.Next(step);
+ test2(err, KErrNone);
+ }
+ err = TheDatabase.Commit();
+ test2(err, KErrNone);
+ inc.Close();
+
+ CleanupStack::PopAndDestroy(2);
+
+ TheDatabase.Close();
+ Disconnect();
+ test.End();
+ }
+
+/**
+@SYMTestCaseID PDS-DBMS-CT-4003
+@SYMTestCaseDesc Testing RDbUpdate API
+@SYMTestPriority High
+@SYMTestActions Executing DML command using RDbUpdate, checking if rowCount working properly
+@SYMTestExpectedResults After DML execution, rowCount should return proper number of afected rows.
+@SYMDEF DEF135710
+*/
+LOCAL_C void TestRDbUpdate()
+{
+ test.Start(_L(" @SYMTestCaseID:PDS-DBMS-CT-4003 Testing RDbUpdate API"));
+ _LIT(DMLinsert, "INSERT INTO Table2 VALUES (2,'Mietek', 'Mietek ma kota')");
+
+ Connect();
+ TInt err = TheDatabase.Open(TheDbs,KTestDatabase);
+ test2(err, KErrNone);
+
+ err = TheDatabase.Begin();
+ test2(err, KErrNone);
+
+ err = TheDatabase.Execute(KCreateTable2, EDbCompareNormal);
+ test(err >= KErrNone);
+
+ RDbUpdate update;
+ err = update.Execute(TheDatabase, DMLinsert, EDbCompareNormal );
+ if(err != KErrNone)
+ RDebug::Printf("Error on Execute %d",err);
+ test2(err, KErrNone);
+
+ TInt rows = update.RowCount();
+ RDebug::Printf("Afected rows %d",rows);
+ test2(rows, 1);
+ update.Close();
+
+ err = TheDatabase.Commit();
+ test2(err, KErrNone);
+
+ TheDatabase.Close();
+ Disconnect();
+ test.End();
+}
+
+/**
+@SYMTestCaseID PDS-DBMS-CT-4004
+@SYMTestCaseDesc Testing RDbRow API
+@SYMTestPriority High
+@SYMTestActions Test for construction functions for RDbRow
+@SYMTestExpectedResults After Creation/Opening row should be a valid object.
+@SYMDEF DEF135710
+*/
+LOCAL_C void TestRDbRowL()
+{
+ test.Start(_L(" @SYMTestCaseID:PDS-DBMS-CT-4004 Testing RDbRow API"));
+ const TInt KRowSize = 300;
+ const TInt KRealRowSize = 512;
+
+ RDbRow row;
+ row.CreateL(KRowSize);
+ RDebug::Printf("Rows %d %d",row.Size(), row.MaxSize() );
+ test2(row.MaxSize(), KRealRowSize);
+ TAny* rptr = row.First();
+
+ RDbRow row2;
+ row2.Open(rptr, KRowSize, 2*KRowSize);
+ RDebug::Printf("Row2s %d %d", KRowSize, row2.MaxSize());
+ test2(row2.Size(), KRowSize);
+ test2(row2.MaxSize(), 2*KRowSize);
+
+ row.Close();
+ row2.Close();
+ test.End();
+}
+/*
+ * Helper function for SYSLIB-DBMS-CT-4005 Testing TTextOps API
+ */
+LOCAL_C TInt HelperCompareForTestTTextOps(const TText8*,TInt,const TText8*,TInt)
+ {
+ return KReturnValueForCompare;
+ }
+/*
+ * Helper function for SYSLIB-DBMS-CT-4005 Testing TTextOps API
+ */
+LOCAL_C TInt HelperFindForTestTTextOps(const TDesC8&,const TText8*,TInt)
+ {
+ return KReturnValueForFind;
+ }
+/**
+@SYMTestCaseID PDS-DBMS-CT-4005
+@SYMTestCaseDesc Testing TTextOps API
+@SYMTestPriority High
+@SYMTestActions Test for Compare and Find functions for TTextOps
+@SYMTestExpectedResults Test if those functions really calling proper targets.
+@SYMDEF DEF135710
+*/
+LOCAL_C void TestTTextOps()
+{
+ test.Start(_L(" @SYMTestCaseID:PDS-DBMS-CT-4005 Testing TTextOps API"));
+ TTextOps text;
+
+ text.iCompare8 = HelperCompareForTestTTextOps;
+ text.iFind8 = HelperFindForTestTTextOps;
+ TInt ret = text.Compare(_L8("Ala ma kota"), _L8("Ala ma konia"));
+ test2(ret, KReturnValueForCompare);
+ ret = text.Find(_L8("Ala ma kota"), _L8("ma ko"));
+ test2(ret, KReturnValueForFind);
+
+ test.End();
+}
+
+#if defined __WINS__ || defined __WINSCW__
+
+LOCAL_C TInt ExecuteRemoteL(const TDesC& aCommand, const TDesC& aCommandLineArg)
+ {
+ RProcess process;
+ User::LeaveIfError(process.Create(aCommand, aCommandLineArg));
+
+ TRequestStatus status;
+ process.Logon(status);
+ process.Resume();
+
+ User::WaitForRequest(status);
+ TInt exitReason = process.ExitReason();
+
+ process.Close();
+ User::LeaveIfError(exitReason);
+
+ return exitReason;
+ }
+
+#endif //defined __WINS__ || defined __WINSCW__
+
+/**
+@SYMTestCaseID PDS-DBMS-CT-4007
+@SYMTestCaseDesc Testing SPConv - This test case uses the Edbsconv tool
+ so therefore only runs on WINSCW builds
+@SYMTestPriority High
+@SYMTestActions Launch the external tool to generate SPD files
+@SYMTestExpectedResults Should produce SPD files and report no errors
+@SYMDEF DEF135710
+*/
+LOCAL_C void TestSPConvL()
+ {
+ test.Start(_L(" @SYMTestCaseID:PDS-DBMS-CT-4007 Testing SPConv"));
+
+#if defined __WINS__ || defined __WINSCW__
+
+ _LIT(KRomTxtFile1, "z:\\test\\11335577.txt");
+ _LIT(KRomTxtFile2, "z:\\test\\11335578.txt");
+ _LIT(KRomTxtFile3, "z:\\test\\11335579.txt");
+ _LIT(KRomTxtFile4, "z:\\test\\1133557A.txt");
+ _LIT(KCommand,"Edbspconv");
+ _LIT(KCommandParameter, " /f=%S /b=%S /s");
+
+ TBuf<200> commandParameter;
+
+ test.Next(_L("Create SPD File from \"11335577.txt\""));
+ commandParameter.Format(KCommandParameter, &KRomTxtFile1, &KTestSpdFile1);
+ ExecuteRemoteL(KCommand, commandParameter);
+
+ test.Next(_L("Create SPD File from \"11335578.txt\""));
+ commandParameter.Format(KCommandParameter, &KRomTxtFile2, &KTestSpdFile2);
+ ExecuteRemoteL(KCommand, commandParameter);
+
+ test.Next(_L("Create SPD File from \"11335579.txt\""));
+ commandParameter.Format(KCommandParameter, &KRomTxtFile3, &KTestSpdFile3);
+ ExecuteRemoteL(KCommand, commandParameter);
+
+ test.Next(_L("Create SPD File from \"1133557A.txt\""));
+ commandParameter.Format(KCommandParameter, &KRomTxtFile4, &KTestSpdFile4);
+ ExecuteRemoteL(KCommand, commandParameter);
+
+#else
+ RDebug::Print(_L("Testing SPConv - This test case cannot run on hardware"));
+#endif
+
+ test.Next(_L("End"));
+ test.End();
+ }
+
+
+/**
+@SYMTestCaseID SYSLIB-DBMS-CT-0611
+@SYMTestCaseDesc Tests the behaviour of observers
+@SYMTestPriority Medium
+@SYMTestActions Tests for DDL,DML
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+LOCAL_C void TestObserverL()
+ {
+ test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0611 Single connection/observer "));
+ Connect();
+ TInt r=TheDatabase.Open(TheDbs,KTestDatabase);
+ test (r==KErrNone);
+ RDbNotifier ob;
+ r=ob.Open(TheDatabase);
+ test (r==KErrNone);
+//
+ test.Next(_L("Cancel"));
+ TRequestStatus stat;
+ ob.NotifyUnlock(stat);
+ test (stat==KRequestPending);
+ ob.Cancel();
+ User::WaitForRequest(stat);
+ test (stat==KErrCancel);
+//
+ test.Next(_L("Close"));
+ ob.NotifyUnlock(stat);
+ test (stat==KRequestPending);
+ ob.Close();
+ User::WaitForRequest(stat);
+ test (stat==KErrCancel);
+//
+ test.Next(_L("DDL"));
+ r=ob.Open(TheDatabase);
+ test (r==KErrNone);
+ ob.NotifyUnlock(stat);
+ test (stat==KRequestPending);
+ Execute(KCreateTable1);
+ User::WaitForRequest(stat);
+ test (stat==ob.ECommit);
+//
+ test.Next(_L("DML"));
+ ob.NotifyUnlock(stat);
+ test (stat==KRequestPending);
+ r=TheTable.Open(TheDatabase,KTable1);
+ test (r==KErrNone);
+ WriteRecordsL(50);
+ User::WaitForRequest(stat);
+ test (stat==ob.ECommit);
+//
+ test.Next(_L("Locked read"));
+ ob.NotifyUnlock(stat);
+ TheDatabase.Begin();
+ test (stat==KRequestPending);
+ TheDatabase.Commit();
+ User::WaitForRequest(stat);
+ test (stat==ob.EUnlock);
+//
+ test.Next(_L("Database closed"));
+ ob.NotifyUnlock(stat);
+ TheTable.Close();
+ TheDatabase.Close();
+ User::WaitForRequest(stat);
+ test (stat==ob.EClose);
+ ob.NotifyUnlock(stat);
+ User::WaitForRequest(stat);
+ test (stat==ob.EClose);
+//
+ test.Next(_L("Re-open database"));
+ r=TheDatabase.Open(TheDbs,KTestDatabase);
+ test (r==KErrNone);
+ ob.NotifyUnlock(stat);
+ User::WaitForRequest(stat);
+ test (stat==ob.EClose);
+ ob.Close();
+//
+ test.Next(_L("Multiple connections and observers"));
+ r=ob.Open(TheDatabase);
+ test (r==KErrNone);
+ RDbNamedDatabase db2;
+ r=db2.Open(TheDbs,KTestDatabase);
+ test (r==KErrNone);
+ RDbNotifier ob2;
+ r=ob2.Open(db2);
+ test (r==KErrNone);
+//
+ test.Next(_L("Cancel"));
+ ob.NotifyUnlock(stat);
+ TRequestStatus stat2;
+ ob2.NotifyUnlock(stat2);
+ test (stat==KRequestPending);
+ ob.Cancel();
+ User::WaitForRequest(stat);
+ test (stat==KErrCancel);
+ test (stat2==KRequestPending);
+ ob2.Cancel();
+ User::WaitForRequest(stat2);
+ test (stat2==KErrCancel);
+//
+ test.Next(_L("Close"));
+ ob.NotifyUnlock(stat);
+ ob2.NotifyUnlock(stat2);
+ test (stat2==KRequestPending);
+ ob2.Close();
+ User::WaitForRequest(stat2);
+ test (stat2==KErrCancel);
+ test (stat==KRequestPending);
+ ob.Close();
+ User::WaitForRequest(stat);
+ test (stat==KErrCancel);
+//
+ test.Next(_L("NotifyChange"));
+ r=ob.Open(TheDatabase);
+ test (r==KErrNone);
+ r=ob2.Open(db2);
+ test (r==KErrNone);
+ ob.NotifyUnlock(stat);
+ ob2.NotifyChange(stat2);
+ TheDatabase.Begin();
+ r=TheDatabase.Commit();
+ test (r==KErrNone);
+ User::WaitForRequest(stat);
+ test (stat==ob.EUnlock);
+ test (stat2==KRequestPending);
+ ob.NotifyUnlock(stat);
+ db2.Begin();
+ r=db2.Commit();
+ test (r==KErrNone);
+ User::WaitForRequest(stat);
+ test (stat==ob.EUnlock);
+ test (stat2==KRequestPending);
+ Execute(KDropTable1);
+ User::WaitForRequest(stat2);
+ test (stat2==ob.ECommit);
+//
+ test.Next(_L("missed event"));
+ ob.NotifyUnlock(stat);
+ User::WaitForRequest(stat);
+ test (stat==ob.ECommit);
+//
+ test.Next(_L("database close"));
+ ob.NotifyUnlock(stat);
+ test (stat==KRequestPending);
+ ob2.NotifyUnlock(stat2);
+ test (stat2==KRequestPending);
+ TheDatabase.Close();
+ User::After(0x20000); // ~.1s
+ test (stat==KRequestPending);
+ test (stat2==KRequestPending);
+ db2.Close();
+ User::WaitForRequest(stat);
+ test (stat==ob.EClose);
+ User::WaitForRequest(stat2);
+ test (stat2==ob.EClose);
+ ob.NotifyUnlock(stat);
+ User::WaitForRequest(stat);
+ test (stat==ob.EClose);
+ ob.Cancel();
+ ob.Close();
+ ob2.NotifyUnlock(stat2);
+ User::WaitForRequest(stat2);
+ test (stat2==ob.EClose);
+ ob2.Cancel();
+ ob2.Close();
+//
+ Disconnect();
+ test.End();
+ }
+
+LOCAL_C void setupTestDirectory()
+//
+// Prepare the test directory.
+//
+ {
+ TInt r=TheFs.Connect();
+ test(r==KErrNone);
+//
+ r=TheFs.MkDir(KTestDatabase);
+ test(r==KErrNone || r==KErrAlreadyExists);
+ }
+
+LOCAL_C void setupCleanup()
+//
+// Initialise the cleanup stack.
+//
+ {
+ TheTrapCleanup=CTrapCleanup::New();
+ test(TheTrapCleanup!=NULL);
+ TRAPD(r,\
+ {\
+ for (TInt i=KTestCleanupStack;i>0;i--)\
+ CleanupStack::PushL((TAny*)0);\
+ CleanupStack::Pop(KTestCleanupStack);\
+ });
+ test(r==KErrNone);
+ }
+
+void DoTests()
+ {
+ TVersionName n=RDbs::Version().Name();
+ test.Printf(_L("DBMS server v%S\n"),&n);
+ TInt r;
+ test.Start(_L("Connection"));
+ TestConnect();
+
+ test.Next(_L("Open Database"));
+ TRAP(r,TestOpenL());
+ test2 (r,KErrNone);
+
+ test.Next(_L("test defect"));
+ TRAP(r,TestDefectL());
+ test2 (r,KErrNone);
+
+ test.Next(_L("Share Database"));
+ TRAP(r,TestShareL());
+ test2 (r,KErrNone);
+
+ test.Next(_L("Locking"));
+ TRAP(r,TestLocking());
+ test2 (r,KErrNone);
+
+ test.Next(_L("Observers"));
+ TRAP(r,TestObserverL());
+ test2 (r,KErrNone);
+
+ test.Next(_L("Benchmarks"));
+ TRAP(r,TestBenchL());
+ test2 (r,KErrNone);
+
+ test.Next(_L("RDbIncremental"));
+ TRAP(r, TestRDbIncrementalAPIL() );
+ test2 (r,KErrNone);
+
+ test.Next(_L("RDbUpdate"));
+ TestRDbUpdate();
+
+ test.Next(_L("RDbRow"));
+ TRAP(r, TestRDbRowL() );
+ test2 (r,KErrNone);
+
+ test.Next(_L("TTextOpsL"));
+ TestTTextOps();
+
+ test.Next(_L("TestSPConvL"));
+ TRAP(r, TestSPConvL() );
+ test2 (r, KErrNone);
+
+ test.Next(_L("Waiting for server exit"));
+ }
+
+
+GLDEF_C TInt E32Main()
+//
+// Test streaming conversions.
+//
+ {
+ __UHEAP_MARK;
+
+ test.Title();
+ setupTestDirectory();
+ DeleteTestFiles();
+ setupCleanup();
+ DoTests();
+ delete TheTrapCleanup;
+ DeleteTestFiles();
+
+ test.End();
+ TheFs.Close();
+ test.Close();
+ __UHEAP_MARKEND;
+ return 0;
+ }