Symaptic: os/persistentdata/persistentstorage/dbms/pcdbms/tdbms/src/t

     1 // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #include <d32dbms.h>

    17 #include <s32file.h>

    18 #include <e32test.h>

    19 #include <e32math.h>

    21 #include "crccheck.h"

    23 #undef __UHEAP_MARK

    24 #define __UHEAP_MARK

    25 #undef __UHEAP_MARKEND

    26 #define __UHEAP_MARKEND

    28 LOCAL_D TDBMS_CRCChecks TheCrcChecker;

    30 #ifndef __linux__ //No CRC test on LINUX

    31 #ifdef __TOOLS2__

    32 const TPtrC	KCrcRecord=_L("\\epoc32\\winscw\\c\\dbms-tst\\T_DBMS.CRC");

    33 #else

    34 const TPtrC	KCrcRecord=_L("C:\\dbms-tst\\T_DBMS.CRC");

    35 #endif

    36 #endif

    38 #if defined(__VC32__) && !defined(_DEBUG)

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

    40 #endif

    42 LOCAL_D RTest test(_L("T_DBMS : Test DBMS API"));

    43 LOCAL_D CTrapCleanup* TheTrapCleanup;

    44 LOCAL_D RDbs TheDbs;

    45 LOCAL_D RDbNamedDatabase TheDatabase;

    46 LOCAL_D RDbTable TheTable;

    47 LOCAL_D RDbView TheView;

    48 LOCAL_D RFs TheFs;

    49 LOCAL_D TBuf8<0x200> TheBuf8;

    50 LOCAL_D TBuf16<0x100> TheBuf16;

    52 const TInt KTestCleanupStack=0x40;

    54 #ifdef __TOOLS2__

    55 const TPtrC KTestDatabase=_L(".\\dbms-tst\\T_DBMS.DB");

    56 #else

    57 const TPtrC KTestDatabase=_L("C:\\dbms-tst\\T_DBMS.DB");

    58 #endif

    60 const TPtrC8 KTestText8(_S8("Text used for test columns when testing"));

    61 const TPtrC8 KTestShortText8(_S8("a"));

    62 const TPtrC8 KTestLongText8(_S8("Text which is used to set Long ASCII Text columns and ensure they are not inlined, and therefore needs to be very long indeed............." \

    63 							"Text which is used to set Long ASCII Text columns and ensure they are not inlined, and therefore needs to be very long indeed............."));

    64 const TPtrC16 KTestText16(_S16("Text used for test columns when testing"));

    65 const TPtrC16 KTestShortText16(_S16("a"));

    66 const TPtrC16 KTestLongText16(_S16("Text which is used to set Long UNICODE Text columns and ensure they are not inlined, and therefore needs to be very long indeed............."));

    67 const TPtrC KTableName(_S("TestTable"));

    68 const TPtrC KTableName2(_S("TestTable2"));

    69 const TPtrC KTestViewTable(_L("TestViewTable"));

    70 const TPtrC KTestTypesTable(_L("TestTypesTable"));

    71 const TPtrC KTestFindTable(_L("TestFindTable"));

    72 const TPtrC KTestMultiTable(_L("TestMultiTable"));

    73 const TPtrC KIndexName(_S("Index1"));

    74 const TPtrC KIndexName2(_S("Index2"));

    75 const TPtrC KIndexName3(_S("Index3"));

    76 const TInt KBlobItems=1000;

    78 const TPtrC KNull=TPtrC();

    79 const TPtrC KPass1(_S("wibble"));

    80 const TPtrC KPass2(_S("wobble"));

    82 const TTime KMinTTime=Time::MinTTime();

    83 const TTime KMaxTTime=Time::MaxTTime();

    85 struct SColDef

    86 	{

    87 	const TText* iName;

    88 	TDbColType iType;

    89 	TInt iAttributes;

    90 	};

    91 LOCAL_D SColDef const SingleColumn[]=

    92 	{

    93 	{_S("Column1"),EDbColInt32,0},

    94 	{0}

    95 	};

    96 LOCAL_D SColDef const DoubleColumn[]=

    97 	{

    98 	{_S("Column1"),EDbColInt32,0},

    99 	{_S("c2"),EDbColInt64,0},

   100 	{0}

   101 	};

   102 LOCAL_D SColDef const ViewTestColumns[]=

   103 	{

   104 	{_S("Int"),EDbColInt32,0},

   105 	{_S("Long1"),EDbColLongText8,0},

   106 	{_S("Long2"),EDbColLongText8,0},

   107 	{_S("Long3"),EDbColLongText8,0},

   108 	{_S("Long4"),EDbColLongText8,0},

   109 	{_S("Long5"),EDbColLongText8,0},

   110 	{0}

   111 	};

   112 LOCAL_D SColDef const AllColumns[]=

   113 	{

   114 	{_S("counter"),EDbColInt32,TDbCol::ENotNull|TDbCol::EAutoIncrement},

   115 	{_S("bit"),EDbColBit,TDbCol::ENotNull},

   116 	{_S("int8"),EDbColInt8,TDbCol::ENotNull},

   117 	{_S("uint8"),EDbColUint8,TDbCol::ENotNull},

   118 	{_S("int16"),EDbColInt16,TDbCol::ENotNull},

   119 	{_S("uint16"),EDbColUint16,TDbCol::ENotNull},

   120 	{_S("int32"),EDbColInt32,TDbCol::ENotNull},

   121 	{_S("uint32"),EDbColUint32,TDbCol::ENotNull},

   122 	{_S("int64"),EDbColInt64,TDbCol::ENotNull},

   123 	{_S("real32"),EDbColReal32,TDbCol::ENotNull},

   124 	{_S("real64"),EDbColReal64,TDbCol::ENotNull},

   125 	{_S("date_time"),EDbColDateTime,TDbCol::ENotNull},

   126 	{_S("text8"),EDbColText8,TDbCol::ENotNull},

   127 	{_S("text16"),EDbColText16,TDbCol::ENotNull},

   128 	{_S("binary"),EDbColBinary,TDbCol::ENotNull},

   129 	{_S("longtext8"),EDbColLongText8,TDbCol::ENotNull},

   130 	{_S("longtext16"),EDbColLongText16,TDbCol::ENotNull},

   131 	{_S("longbinary"),EDbColLongBinary,TDbCol::ENotNull},

   132 	{_S("bit_null"),EDbColBit,0},

   133 	{_S("int8_null"),EDbColInt8,0},

   134 	{_S("uint8_null"),EDbColUint8,0},

   135 	{_S("int16_null"),EDbColInt16,0},

   136 	{_S("uint16_null"),EDbColUint16,0},

   137 	{_S("int32_null"),EDbColInt32,0},

   138 	{_S("uint32_null"),EDbColUint32,0},

   139 	{_S("int64_null"),EDbColInt64,0},

   140 	{_S("real32_null"),EDbColReal32,0},

   141 	{_S("real64_null"),EDbColReal64,0},

   142 	{_S("date_time_null"),EDbColDateTime,0},

   143 	{_S("text8_null"),EDbColText8,0},

   144 	{_S("text16_null"),EDbColText16,0},

   145 	{_S("binary_null"),EDbColBinary,0},

   146 	{_S("longtext8_null"),EDbColLongText8,0},

   147 	{_S("longtext16_null"),EDbColLongText16,0},

   148 	{_S("longbinary_null"),EDbColLongBinary,0},

   149 	{_S("force_null"),EDbColInt32,0},

   150 	{0}

   151 	};

   152 const TInt KColumns=sizeof(AllColumns)/sizeof(AllColumns[0])-1;

   153 enum TColumns

   154 	{

   155 	ECounter,

   156 	EBit,EInt8,EUint8,EInt16,EUint16,EInt32,EUint32,EInt64,

   157 	EReal32,EReal64,ETime,EText8,EText16,ETBinary,

   158 	ELongText8,ELongText16,ELongBinary,

   159 	EBitNull,EInt8Null,EUint8Null,EInt16Null,EUint16Null,EInt32Null,EUint32Null,EInt64Null,

   160 	EReal32Null,EReal64Null,ETimeNull,EText8Null,EText16Null,ETBinaryNull,

   161 	ELongText8Null,ELongText16Null,ELongBinaryNull,EForceNull

   162 	};

   163 LOCAL_D TDbColNo TheMap[KColumns];

   165 CDbColSet* ColumnSetL(const SColDef* aDef)

   166 	{

   167 	CDbColSet *set=CDbColSet::NewLC();

   168 	for (;aDef->iName;++aDef)

   169 		{

   170 		TDbCol col(TPtrC(aDef->iName),aDef->iType);

   171 		col.iAttributes=aDef->iAttributes;

   172 		set->AddL(col);

   173 		}

   174 	CleanupStack::Pop();

   175 	return set;

   176 	}

   178 enum TColSet {EAllTypes,ESingleColumn,EDoubleColumn,EViewTestTable};

   179 LOCAL_D const SColDef* const ColSetDef[]=

   180 	{

   181 	AllColumns,

   182 	SingleColumn,

   183 	DoubleColumn,

   184 	ViewTestColumns

   185 	};

   186 LOCAL_C CDbColSet* CreateColSetL(TColSet aType)

   187 	{

   188 	return ColumnSetL(ColSetDef[aType]);

   189 	}

   191 inline TPtrC ColName(const SColDef* aSet,TInt aColumn)

   192 	{return TPtrC(aSet[aColumn].iName);}

   194 enum TKeySet {EKeyAsc,EKeyDesc,EKeyMulti,EKeySingle};

   195 LOCAL_C CDbKey* CreateKeyL(TKeySet aType)

   196 	{

   197 	CDbKey *k=CDbKey::NewLC();

   198 	switch(aType)

   199 		{

   200 	case EKeyAsc:

   201 		k->AddL(ColName(AllColumns,EInt32));

   202 		break;

   203 	case EKeyDesc:

   204 		k->AddL(TDbKeyCol(ColName(AllColumns,EInt32),TDbKeyCol::EDesc));

   205 		k->MakeUnique();

   206 		break;

   207 	case EKeyMulti:

   208 		k->AddL(ColName(AllColumns,EInt32)).AddL(ColName(AllColumns,EText8));

   209 		k->SetComparison(EDbCompareFolded);

   210 		break;

   211 	case EKeySingle:

   212 		k->AddL(ColName(SingleColumn,0));

   213 		break;

   214 		}

   215 	CleanupStack::Pop();

   216 	return k;

   217 	}

   219 LOCAL_C void CloseDatabase()

   220 	{

   221 	TheDatabase.Close();

   222 	TheCrcChecker.GenerateCrcL(KTestDatabase);

   223 	}

   226 //

   227 // Open a shared database (SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version)

   228 //

   229 LOCAL_C TInt OpenSharedDatabase()

   230 	{

   231 	return TheDatabase.Open(TheDbs,KTestDatabase);

   232 	}

   234 //

   235 // Create a local database (SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version)

   236 //

   237 LOCAL_C void CreateClientDatabase()

   238 	{

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

   240 	test (r==KErrNone);

   241 	}

   243 //

   244 // Create a shared database (SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version)

   245 //

   246 LOCAL_C void CreateSharedDatabase()

   247 	{

   248 	CreateClientDatabase();

   249 	CloseDatabase();

   250 	TInt r=OpenSharedDatabase();

   251 	test (r==KErrNone);

   252 	}

   254 //

   255 // Open a shared database (SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version)

   256 //

   257 LOCAL_C void OpenDatabase()

   258 	{

   259 	TInt r=OpenSharedDatabase();

   260 	test (r==KErrNone);

   261 	}

   263 //

   264 // Create a shared database (SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version)

   265 //

   266 LOCAL_C void CreateDatabase()

   267 	{

   268 	CreateSharedDatabase();

   269 	}

   272 LOCAL_C void DestroyDatabase()

   273 	{

   274 	TInt r=TheDatabase.Destroy();

   275 	test (r==KErrNone);

   276 	}

   278 //

   279 // Check the database has this many tables

   280 //

   281 LOCAL_C void CountTables(TInt aCount)

   282 	{

   283 	CDbNames* names=TheDatabase.TableNamesL();

   284 	test (names->Count()==aCount);

   285 	delete names;

   286 	}

   288 //

   289 // Compare two column sets

   290 //

   291 LOCAL_C void Compare(const TDesC& aTable,const CDbColSet& aSet)

   292 	{

   293 	CDbColSet* set=TheDatabase.ColSetL(aTable);

   294 	test(set->Count()==aSet.Count());

   295 	for (TDbColSetIter iter(*set);iter;++iter)

   296 		{

   297 		const TDbCol* pRight=aSet.Col(iter->iName);

   298 		test(pRight!=NULL);

   299 		test(iter->iType==pRight->iType);

   300 		test(iter->iMaxLength==KDbUndefinedLength || pRight->iMaxLength==KDbUndefinedLength || iter->iMaxLength==pRight->iMaxLength);

   301 		test((iter->iAttributes&pRight->iAttributes)==iter->iAttributes);

   302 		}

   303 	delete set;

   304 	}

   306 //

   307 // Check the database has this many tables

   308 //

   309 LOCAL_C void CountIndexes(const TDesC& aTable,TInt aCount)

   310 	{

   311 	CDbNames* names=TheDatabase.IndexNamesL(aTable);

   312 	test (names->Count()==aCount);

   313 	delete names;

   314 	}

   316 //

   317 // Compare index definition

   318 //

   319 LOCAL_C void Compare(const TDesC& aIndex,const TDesC& aTable,const CDbKey& aKey)

   320 	{

   321 	CDbKey* key=TheDatabase.KeyL(aIndex,aTable);

   322 	test(key->Count()==aKey.Count());

   323 	test(key->Comparison()==aKey.Comparison());

   324 	test(key->IsUnique()==aKey.IsUnique());

   325 	for (TInt ii=aKey.Count();--ii>=0;)

   326 		{

   327 		const TDbKeyCol& left=(*key)[ii];

   328 		const TDbKeyCol& right=aKey[ii];

   329 		test (left.iName==right.iName);

   330 		test (left.iOrder==right.iOrder);

   331 		test (left.iLength==right.iLength || right.iLength==KDbUndefinedLength);

   332 		}

   333 	delete key;

   334 	}

   336 /**

   337 @SYMTestCaseID          SYSLIB-DBMS-CT-0594

   338 @SYMTestCaseDesc        Tests the database definition and enquiry functions

   339 @SYMTestPriority        Medium

   340 @SYMTestActions         Tests for creation and opening of a database,creation of a table

   341                         Tests for comparing column and table column sets

   342 						Tests for altering a table and creation of an index.

   343 @SYMTestExpectedResults Test must not fail

   344 @SYMREQ                 REQ0000

   345 */

   346 LOCAL_C void TestDDL()

   347 	{

   348 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0594 Create Database "));

   349 	CreateDatabase();

   350 	CountTables(0);

   351 	CloseDatabase();

   352 	test.Next(_L("Open Database"));

   353 	OpenDatabase();

   354 	CountTables(0);

   355 	test.Next(_L("CreateTable"));

   356 	CDbColSet* cs=CreateColSetL(EAllTypes);

   357 	test(TheDatabase.CreateTable(KTableName,*cs)==KErrNone);

   358 	CountTables(1);

   359 	test.Next(_L("Compare column sets"));

   360 	Compare(KTableName,*cs);

   361 	CloseDatabase();

   362 	test.Next(_L("Re-open database"));

   363 	OpenDatabase();

   364 	CountTables(1);

   365 	test.Next(_L("Compare table column sets"));

   366 	Compare(KTableName,*cs);

   367 	delete cs;

   368 	test.Next(_L("Add another table"));

   369 	cs=CreateColSetL(ESingleColumn);

   370 	test(TheDatabase.CreateTable(KTableName2,*cs)==KErrNone);

   371 	Compare(KTableName2,*cs);

   372 	delete cs;

   373 	CountTables(2);

   374 //

   375 	test.Next(_L("Alter table"));

   376 	cs=CreateColSetL(EDoubleColumn);

   377 	test(TheDatabase.AlterTable(KTableName2,*cs)==KErrNone);

   378 	Compare(KTableName2,*cs);

   379 	delete cs;

   380 	CountTables(2);

   381 //

   382 	test.Next(_L("Test index creation"));

   383 	CountIndexes(KTableName,0);

   384 	CountIndexes(KTableName2,0);

   385 	CDbKey* key=CreateKeyL(EKeyAsc);

   386 	test (TheDatabase.CreateIndex(KIndexName,KTableName,*key)==KErrNone);

   387 	Compare(KIndexName,KTableName,*key);

   388 	delete key;

   389 	key=CreateKeyL(EKeyDesc);

   390 	test (TheDatabase.CreateIndex(KIndexName2,KTableName,*key)==KErrNone);

   391 	Compare(KIndexName2,KTableName,*key);

   392 	delete key;

   393 	key=CreateKeyL(EKeySingle);

   394 	test (TheDatabase.CreateIndex(KIndexName,KTableName2,*key)==KErrNone);

   395 	Compare(KIndexName,KTableName2,*key);

   396 	delete key;

   397 	key=CreateKeyL(EKeyMulti);

   398 	test (TheDatabase.CreateIndex(KIndexName3,KTableName,*key)==KErrNone);

   399 	Compare(KIndexName3,KTableName,*key);

   400 	CountIndexes(KTableName,3);

   401 	CountIndexes(KTableName2,1);

   402 	CloseDatabase();

   403 	OpenDatabase();

   404 	CountIndexes(KTableName,3);

   405 	CountIndexes(KTableName2,1);

   406 	Compare(KIndexName3,KTableName,*key);

   407 	delete key;

   408 	test.Next(_L("Drop indexes"));

   409 	test (TheDatabase.DropIndex(KIndexName,KTableName)==KErrNone);

   410 	CountIndexes(KTableName,2);

   411 	test (TheDatabase.DropIndex(KIndexName2,KTableName)==KErrNone);

   412 	CountIndexes(KTableName,1);

   413 	test (TheDatabase.DropIndex(KIndexName,KTableName2)==KErrNone);

   414 	CountIndexes(KTableName2,0);

   415 	test.Next(_L("Drop table"));

   416 	test(TheDatabase.DropTable(KTableName)==KErrNone);

   417 	CountTables(1);

   418 	test(TheDatabase.DropTable(KTableName2)==KErrNone);

   419 	CountTables(0);

   420 	CloseDatabase();

   421 	OpenDatabase();

   422 	CountTables(0);

   423 	DestroyDatabase();

   424 	test.End();

   425 	}

   428 LOCAL_C void AddRow()

   429 	{

   430 	test(TheView.Prepare(TheDatabase,_L("select * from testviewtable"))==KErrNone);

   431 	test(TheView.EvaluateAll()==KErrNone);

   432 	TheView.InsertL();

   433 	TheView.SetColL(1,(TInt32)12345);

   434 	TheView.PutL();

   435 	TheView.InsertL();

   436 	TheView.Cancel();

   437 	TheView.FirstL();

   438 	TheView.NextL();

   439 	test(TheView.AtEnd());		// should be only 1 row as second insert was cancelled

   440 	TheView.Close();

   441 	}

   443 /**

   444 @SYMTestCaseID          SYSLIB-DBMS-CT-1318

   445 @SYMTestCaseDesc        Tests for RDbView class

   446 @SYMTestPriority        Medium

   447 @SYMTestActions         Tests for navigation of the cursor in the generated row sets.

   448 @SYMTestExpectedResults Test must not fail

   449 @SYMREQ                 REQ0000

   450 */

   451 LOCAL_C void TestEmptyNavigation(const TDesC& aQuery)

   452 	{

   453 	test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-1318 Test navigation states "));

   454 	test(TheView.Prepare(TheDatabase,aQuery,TheView.EReadOnly)==KErrNone);

   455 	test(TheView.EvaluateAll()==KErrNone);

   456 	TheView.FirstL();

   457 	test(!TheView.AtBeginning());

   458 	test(!TheView.AtRow());

   459 	test(TheView.AtEnd());

   460 	TheView.PreviousL();

   461 	test(TheView.AtBeginning());

   462 	test(!TheView.AtRow());

   463 	test(!TheView.AtEnd());

   464 	TheView.NextL();

   465 	test(!TheView.AtBeginning());

   466 	test(!TheView.AtRow());

   467 	test(TheView.AtEnd());

   468 	TheView.LastL();

   469 	test(TheView.AtBeginning());

   470 	test(!TheView.AtRow());

   471 	test(!TheView.AtEnd());

   472 	TheView.NextL();

   473 	test(TheView.AtEnd());

   474 	TheView.Close();

   475 	}

   477 /**

   478 @SYMTestCaseID          SYSLIB-DBMS-CT-1319

   479 @SYMTestCaseDesc        Tests for RDbView class

   480 @SYMTestPriority        Medium

   481 @SYMTestActions         Tests for navigation of the cursor in the generated row sets.

   482 @SYMTestExpectedResults Test must not fail

   483 @SYMREQ                 REQ0000

   484 */

   485 LOCAL_C void TestNavigation(const TDesC& aQuery)

   486 	{

   487 	test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-1319 Test navigation states "));

   488 	test(TheView.Prepare(TheDatabase,aQuery,TheView.EReadOnly)==KErrNone);

   489 	test(TheView.EvaluateAll()==KErrNone);

   490 	TheView.FirstL();

   491 	test(!TheView.AtBeginning());

   492 	test(TheView.AtRow());

   493 	test(!TheView.AtEnd());

   494 	TheView.GetL();

   495 	test(TheView.ColInt32(1)==12345);

   496 	TheView.PreviousL();

   497 	test(TheView.AtBeginning());

   498 	test(!TheView.AtRow());

   499 	test(!TheView.AtEnd());

   500 	TheView.NextL();

   501 	test(!TheView.AtBeginning());

   502 	test(TheView.AtRow());

   503 	test(!TheView.AtEnd());

   504 	TheView.NextL();

   505 	test(!TheView.AtBeginning());

   506 	test(!TheView.AtRow());

   507 	test(TheView.AtEnd());

   508 	TheView.PreviousL();

   509 	test(!TheView.AtBeginning());

   510 	test(TheView.AtRow());

   511 	test(!TheView.AtEnd());

   512 	TheView.LastL();

   513 	test(!TheView.AtBeginning());

   514 	test(TheView.AtRow());

   515 	test(!TheView.AtEnd());

   516 	TheView.NextL();

   517 	test(TheView.AtEnd());

   518 	TheView.Close();

   519 	}

   521 /**

   522 @SYMTestCaseID          SYSLIB-DBMS-CT-1320

   523 @SYMTestCaseDesc        RDbView updation test

   524 @SYMTestPriority        Medium

   525 @SYMTestActions         Tests for updation of row sets

   526 @SYMTestExpectedResults Test must not fail

   527 @SYMREQ                 REQ0000

   528 */

   529 static void TestUpdate()

   530 	{

   531 	test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-1320 Update and delete the row "));

   532 	test(TheView.Prepare(TheDatabase,_L("select * from TestViewTable"))==KErrNone);

   533 	test(TheView.EvaluateAll()==KErrNone);

   534 	TheView.FirstL();

   535 	TheView.UpdateL();

   536 	TheView.SetColL(1,(TInt32)54321);

   537 	TheView.PutL();

   538 	TheView.FirstL();

   539 	TheView.GetL();

   540 	test(TheView.ColInt32(1)==54321);

   541 	TheView.UpdateL();

   542 	TheView.SetColL(1,(TInt32)12345);

   543 	TheView.Cancel();

   544 	TheView.FirstL();

   545 	TheView.GetL();

   546 	test(TheView.ColInt32(1)==54321);

   547 	TheView.DeleteL();

   548 	TheView.PreviousL();

   549 	test(TheView.AtBeginning());

   550 	TheView.NextL();

   551 	test(TheView.AtEnd());

   552 	TheView.Close();

   553 	}

   555 #include <s32mem.h>

   557 void writeBLOB(TDbColNo aCol,const TDesC8& aDes)

   558 	{

   559 	CBufSeg* buf=CBufSeg::NewL(128);

   560 	CleanupStack::PushL(buf);

   561 	buf->InsertL(0,aDes);

   562 	RBufReadStream read(*buf);

   563 	RDbColWriteStream blob;

   564 	blob.OpenLC(TheView,aCol);

   565 //	blob.WriteL(aDes);

   566 	blob.WriteL(read,aDes.Length());

   567 	blob.CommitL();

   568 	CleanupStack::PopAndDestroy();

   569 	CleanupStack::PopAndDestroy();	// buf

   570 	test (TheView.ColLength(aCol)==aDes.Length());

   571 	test (TheView.ColSize(aCol)==aDes.Size());

   572 	}

   574 void checkBLOB(TDbColNo aCol,const TDesC8& aDes)

   575 	{

   576 	RDbColReadStream blob;

   577 	blob.OpenLC(TheView,aCol);

   578 	blob.ReadL(TheBuf8,TheView.ColLength(aCol));

   579 	CleanupStack::PopAndDestroy();

   580 	test(TheBuf8==aDes);

   581 	}

   583 /**

   584 @SYMTestCaseID          SYSLIB-DBMS-CT-1321

   585 @SYMTestCaseDesc        BLOB tests

   586 @SYMTestPriority        Medium

   587 @SYMTestActions         Test long column tracking through insert/put/update/cancel

   588 @SYMTestExpectedResults Test must not fail

   589 @SYMREQ                 REQ0000

   590 */

   591 void TestBLOB()

   592 	{

   593 	test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-1321 Long column tracking "));

   594 	test(TheView.Prepare(TheDatabase,_L("select * from TestViewTable"))==KErrNone);

   595 	test(TheView.EvaluateAll()==KErrNone);

   596 	TheView.InsertL();

   597 	writeBLOB(2,KTestShortText8);

   598 	writeBLOB(3,KTestShortText8);

   599 	TheView.PutL();

   600 	TheView.InsertL();

   601 	writeBLOB(4,KTestShortText8);

   602 	writeBLOB(5,KTestShortText8);

   603 	TheView.Cancel();

   604 // change in behaviour--writing BLOBs forces a true rollback here. So reset

   605 	TheView.Reset();

   606 	test(TheView.EvaluateAll()==KErrNone);

   607 // check the one row we should have

   608 	TheView.FirstL();

   609 	TheView.GetL();

   610 	checkBLOB(2,KTestShortText8);

   611 	checkBLOB(3,KTestShortText8);

   612 	test(TheView.IsColNull(4));

   613 	test(TheView.IsColNull(5));

   614 	test(TheView.IsColNull(6));

   615 	TheView.NextL();

   616 	test(TheView.AtEnd());

   617 // update/cancel the row

   618 	TheView.FirstL();

   619 	TheView.UpdateL();

   620 	TheView.SetColNullL(3);

   621 	writeBLOB(4,KTestLongText8);

   622 	writeBLOB(5,KTestLongText8);

   623 // check pre-cancel

   624 	checkBLOB(2,KTestShortText8);

   625 	test(TheView.IsColNull(3));

   626 	checkBLOB(4,KTestLongText8);

   627 	checkBLOB(5,KTestLongText8);

   628 	test(TheView.IsColNull(6));

   629 // cancel and check

   630 	TheView.Cancel();

   631 // change in behaviour--writing BLOBs forces a true rollback here. So reset

   632 	TheView.Reset();

   633 	test(TheView.EvaluateAll()==KErrNone);

   634 	TheView.FirstL();

   635 	TheView.GetL();

   636 	checkBLOB(2,KTestShortText8);

   637 	checkBLOB(3,KTestShortText8);

   638 	test(TheView.IsColNull(4));

   639 	test(TheView.IsColNull(5));

   640 	test(TheView.IsColNull(6));

   641 	TheView.NextL();

   642 	test(TheView.AtEnd());

   643 // update/put the row

   644 	TheView.FirstL();

   645 	TheView.UpdateL();

   646 	TheView.SetColNullL(3);

   647 	writeBLOB(4,KTestLongText8);

   648 	writeBLOB(5,KTestLongText8);

   649 // check pre-put

   650 	checkBLOB(2,KTestShortText8);

   651 	test(TheView.IsColNull(3));

   652 	checkBLOB(4,KTestLongText8);

   653 	checkBLOB(5,KTestLongText8);

   654 	test(TheView.IsColNull(6));

   655 // put and check

   656 	TheView.PutL();

   657 	TheView.FirstL();

   658 	TheView.GetL();

   659 	checkBLOB(2,KTestShortText8);

   660 	test(TheView.IsColNull(3));

   661 	checkBLOB(4,KTestLongText8);

   662 	checkBLOB(5,KTestLongText8);

   663 	test(TheView.IsColNull(6));

   664 	TheView.NextL();

   665 	test(TheView.AtEnd());

   666 // update/put the row again

   667 	TheView.FirstL();

   668 	TheView.UpdateL();

   669 	TheView.SetColNullL(2);

   670 	writeBLOB(3,KTestShortText8);

   671 	writeBLOB(4,KTestShortText8);

   672 	writeBLOB(5,KTestShortText8);

   673 // check

   674 	test(TheView.IsColNull(2));

   675 	checkBLOB(3,KTestShortText8);

   676 	checkBLOB(4,KTestShortText8);

   677 	checkBLOB(5,KTestShortText8);

   678 	test(TheView.IsColNull(6));

   679 // modify again

   680 	writeBLOB(2,KTestLongText8);

   681 	TheView.SetColNullL(3);

   682 	TheView.SetColNullL(4);

   683 	writeBLOB(5,KTestLongText8);

   684 // check pre-put

   685 	checkBLOB(2,KTestLongText8);

   686 	test(TheView.IsColNull(3));

   687 	test(TheView.IsColNull(4));

   688 	checkBLOB(5,KTestLongText8);

   689 	test(TheView.IsColNull(6));

   690 // put and check

   691 	TheView.PutL();

   692 	TheView.FirstL();

   693 	TheView.GetL();

   694 	checkBLOB(2,KTestLongText8);

   695 	test(TheView.IsColNull(3));

   696 	test(TheView.IsColNull(4));

   697 	checkBLOB(5,KTestLongText8);

   698 	test(TheView.IsColNull(6));

   699 	TheView.NextL();

   700 	test(TheView.AtEnd());

   701 // insert copy

   702 	TheView.LastL();

   703 	TheView.InsertCopyL();

   704 	TheView.SetColNullL(2);

   705 	writeBLOB(3,KTestLongText8);

   706 // check pre-put

   707 	test(TheView.IsColNull(2));

   708 	checkBLOB(3,KTestLongText8);

   709 	test(TheView.IsColNull(4));

   710 	checkBLOB(5,KTestLongText8);

   711 	test(TheView.IsColNull(6));

   712 // put and check

   713 	TheView.PutL();

   714 	TheView.LastL();

   715 	TheView.GetL();

   716 	test(TheView.IsColNull(2));

   717 	checkBLOB(3,KTestLongText8);

   718 	test(TheView.IsColNull(4));

   719 	checkBLOB(5,KTestLongText8);

   720 	test(TheView.IsColNull(6));

   721 // delete previous one and check

   722 	TheView.PreviousL();

   723 	TheView.DeleteL();

   724 	TheView.NextL();

   725 	TheView.GetL();

   726 	test(TheView.IsColNull(2));

   727 	checkBLOB(3,KTestLongText8);

   728 	test(TheView.IsColNull(4));

   729 	checkBLOB(5,KTestLongText8);

   730 	test(TheView.IsColNull(6));

   731 	TheView.NextL();

   732 	test(TheView.AtEnd());

   733 // delete

   734 	TheView.FirstL();

   735 	TheView.DeleteL();

   736 // finish

   737 	TheView.Close();

   738 	}

   740 /**

   741 @SYMTestCaseID          SYSLIB-DBMS-CT-0596

   742 @SYMTestCaseDesc        Tests for navigation states

   743 @SYMTestPriority        Medium

   744 @SYMTestActions         Tests for view state cycle, navigation, Insert/Update/Delete

   745 @SYMTestExpectedResults Test must not fail

   746 @SYMREQ                 REQ0000

   747 */

   748 void TestView()

   749 	{

   750 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0596 Create the Test table "));

   751 	CreateDatabase();

   752 	CDbColSet* cs=CreateColSetL(EViewTestTable);

   753 	test(TheDatabase.CreateTable(KTestViewTable,*cs)==KErrNone);

   754 	delete cs;

   755 	test.Next(_L("Test navigation states"));

   756 	TestEmptyNavigation(_L("select * from TestViewTable"));

   757 	test.Next(_L("Insert and Put/Cancel"));

   758 	AddRow();

   759 	test.Next(_L("Test navigation states"));

   760 	TestNavigation(_L("select * from TestViewTable"));

   761 	TestNavigation(_L("select * from TestViewTable where Int is not null"));

   762 	TestEmptyNavigation(_L("select * from TestViewTable where Int is null"));

   763 	test.Next(_L("Update and delete the row"));

   764 	TestUpdate();

   765 	test.Next(_L("Long column tracking"));

   766 	TestBLOB();

   767 	test.Next(_L("Close"));

   768 	CloseDatabase();

   769 	test.End();

   770 	}

   772 //

   773 // Check the integral set/get functions for different width types

   774 //

   775 LOCAL_C void CheckIntAccessors()

   776 	{

   777 	TheView.InsertL();

   778 // bit column

   779 	TDbColNo ord=TheMap[EBit];

   780 	TheView.SetColL(ord,TUint32(1));

   781 	test (TheView.ColUint(ord)==1);

   782 	TheView.SetColL(ord,TInt32(0));

   783 	test (TheView.ColUint(ord)==0);

   784 	TheView.SetColL(ord,TInt64(1));

   785 	test (TheView.ColUint(ord)==1);

   786 	test (TheView.ColUint8(ord)==1);

   787 	test (TheView.ColUint16(ord)==1);

   788 	test (TheView.ColUint32(ord)==1);

   789 	test (TheView.ColInt8(ord)==1);

   790 	test (TheView.ColInt16(ord)==1);

   791 	test (TheView.ColInt32(ord)==1);

   792 	test (TheView.ColInt64(ord)==1);

   793 // uint8 column

   794 	ord=TheMap[EUint8];

   795 	TheView.SetColL(ord,TUint32(255));

   796 	test (TheView.ColUint(ord)==255);

   797 	TheView.SetColL(ord,TInt32(0));

   798 	test (TheView.ColUint(ord)==0);

   799 	TheView.SetColL(ord,TInt64(1));

   800 	test (TheView.ColUint(ord)==1);

   801 	test (TheView.ColUint8(ord)==1);

   802 	test (TheView.ColUint16(ord)==1);

   803 	test (TheView.ColUint32(ord)==1);

   804 	test (TheView.ColInt16(ord)==1);

   805 	test (TheView.ColInt32(ord)==1);

   806 	test (TheView.ColInt64(ord)==1);

   807 // uint16 column

   808 	ord=TheMap[EUint16];

   809 	TheView.SetColL(ord,TUint32(65535));

   810 	test (TheView.ColUint(ord)==65535);

   811 	TheView.SetColL(ord,TInt32(0));

   812 	test (TheView.ColUint(ord)==0);

   813 	TheView.SetColL(ord,TInt64(1));

   814 	test (TheView.ColUint(ord)==1);

   815 	test (TheView.ColUint16(ord)==1);

   816 	test (TheView.ColUint32(ord)==1);

   817 	test (TheView.ColInt32(ord)==1);

   818 	test (TheView.ColInt64(ord)==1);

   819 // uint32 column

   820 	ord=TheMap[EUint32];

   821 	TheView.SetColL(ord,TUint32(0));

   822 	test (TheView.ColUint(ord)==0);

   823 	TheView.SetColL(ord,TInt32(KMaxTInt));

   824 	test (TInt(TheView.ColUint(ord))==KMaxTInt);

   825 	TheView.SetColL(ord,TInt64(KMaxTUint));

   826 	test (TheView.ColUint(ord)==KMaxTUint);

   827 	test (TheView.ColUint32(ord)==KMaxTUint);

   828 	test (TheView.ColInt64(ord)==KMaxTUint);

   829 // int8 column

   830 	ord=TheMap[EInt8];

   831 	TheView.SetColL(ord,TUint32(127));

   832 	test (TheView.ColInt(ord)==127);

   833 	TheView.SetColL(ord,TInt32(0));

   834 	test (TheView.ColInt(ord)==0);

   835 	TheView.SetColL(ord,TInt64(-128));

   836 	test (TheView.ColInt(ord)==-128);

   837 	test (TheView.ColInt8(ord)==-128);

   838 	test (TheView.ColInt16(ord)==-128);

   839 	test (TheView.ColInt32(ord)==-128);

   840 	test (TheView.ColInt64(ord)==-128);

   841 // int16 column

   842 	ord=TheMap[EInt16];

   843 	TheView.SetColL(ord,TUint32(32767));

   844 	test (TheView.ColInt(ord)==32767);

   845 	TheView.SetColL(ord,TInt32(0));

   846 	test (TheView.ColInt(ord)==0);

   847 	TheView.SetColL(ord,TInt64(-32768));

   848 	test (TheView.ColInt(ord)==-32768);

   849 	test (TheView.ColInt16(ord)==-32768);

   850 	test (TheView.ColInt32(ord)==-32768);

   851 	test (TheView.ColInt64(ord)==-32768);

   852 // int32 column

   853 	ord=TheMap[EInt32];

   854 	TheView.SetColL(ord,TUint32(KMaxTInt));

   855 	test (TheView.ColInt(ord)==KMaxTInt);

   856 	TheView.SetColL(ord,TInt32(0));

   857 	test (TheView.ColInt(ord)==0);

   858 	TheView.SetColL(ord,TInt64(KMinTInt));

   859 	test (TheView.ColInt(ord)==KMinTInt);

   860 	test (TheView.ColInt32(ord)==KMinTInt);

   861 	test (TheView.ColInt64(ord)==KMinTInt);

   862 //

   863 	TheView.Cancel();

   864 	}

   866 //

   867 // Write the values to nullable column types

   868 //

   869 LOCAL_C void WriteMinValues(TInt anOffset)

   870 	{

   871 	TheView.SetColL(TheMap[anOffset+EBit],TUint(0));

   872 	TheView.SetColL(TheMap[anOffset+EInt8],KMinTInt8);

   873 	TheView.SetColL(TheMap[anOffset+EUint8],TUint(0));

   874 	TheView.SetColL(TheMap[anOffset+EInt16],KMinTInt16);

   875 	TheView.SetColL(TheMap[anOffset+EUint16],TUint(0));

   876 	TheView.SetColL(TheMap[anOffset+EInt32],KMinTInt32);

   877 	TheView.SetColL(TheMap[anOffset+EUint32],TUint(0));

   878 	TheView.SetColL(TheMap[anOffset+EInt64],KMinTInt64);

   879 	TheView.SetColL(TheMap[anOffset+EReal32],KMinTReal32);

   880 	TheView.SetColL(TheMap[anOffset+EReal64],KMinTReal64);

   881 	TheView.SetColL(TheMap[anOffset+ETime],KMinTTime);

   882 	TheView.SetColL(TheMap[anOffset+EText8],KTestShortText8);

   883 	TheView.SetColL(TheMap[anOffset+EText16],KTestShortText16);

   884 	{

   885 	TUint8 val=0;

   886 	TheView.SetColL(TheMap[anOffset+ETBinary],TPtrC8(&val,sizeof(val)));

   887 	}

   888 	TheView.SetColL(TheMap[anOffset+ELongText8],KTestShortText8);

   889 	TheView.SetColL(TheMap[anOffset+ELongText16],KTestShortText16);

   890 	RDbColWriteStream out;

   891 	out.OpenLC(TheView,TheMap[anOffset+ELongBinary]);

   892 	out.WriteUint8L(0);

   893 	out.CommitL();

   894 	CleanupStack::PopAndDestroy();

   895 	}

   897 //

   898 // Write a row with the minimum (or small) column values

   899 // return the value in the counter column

   900 //

   901 LOCAL_C TInt WriteMinimum()

   902 	{

   903 	TheView.InsertL();

   904 	WriteMinValues(0);

   905 	WriteMinValues(EBitNull-EBit);

   906 	test(!TheView.IsColNull(TheMap[ECounter]));

   907 	TInt cc=TheView.ColInt(TheMap[ECounter]);

   908 	TheView.PutL();

   909 	return cc;

   910 	}

   912 LOCAL_C void CheckMinValues(TInt anOffset)

   913 	{

   914 	test(TheView.ColUint8(TheMap[anOffset+EBit])==0);

   915 	test(TheView.ColUint16(TheMap[anOffset+EBit])==0);

   916 	test(TheView.ColUint32(TheMap[anOffset+EBit])==0);

   917 	test(TheView.ColUint(TheMap[anOffset+EBit])==0);

   918 	test(TheView.ColInt8(TheMap[anOffset+EInt8])==KMinTInt8);

   919 	test(TheView.ColInt16(TheMap[anOffset+EInt8])==KMinTInt8);

   920 	test(TheView.ColInt32(TheMap[anOffset+EInt8])==KMinTInt8);

   921 	test(TheView.ColInt(TheMap[anOffset+EInt8])==KMinTInt8);

   922 	test(TheView.ColUint8(TheMap[anOffset+EUint8])==0);

   923 	test(TheView.ColUint16(TheMap[anOffset+EUint8])==0);

   924 	test(TheView.ColUint32(TheMap[anOffset+EUint8])==0);

   925 	test(TheView.ColUint(TheMap[anOffset+EUint8])==0);

   926 	test(TheView.ColInt16(TheMap[anOffset+EInt16])==KMinTInt16);

   927 	test(TheView.ColInt32(TheMap[anOffset+EInt16])==KMinTInt16);

   928 	test(TheView.ColInt(TheMap[anOffset+EInt16])==KMinTInt16);

   929 	test(TheView.ColUint16(TheMap[anOffset+EUint16])==0);

   930 	test(TheView.ColUint32(TheMap[anOffset+EUint16])==0);

   931 	test(TheView.ColUint(TheMap[anOffset+EUint16])==0);

   932 	test(TheView.ColInt32(TheMap[anOffset+EInt32])==KMinTInt32);

   933 	test(TheView.ColInt(TheMap[anOffset+EInt32])==KMinTInt32);

   934 	test(TheView.ColUint32(TheMap[anOffset+EUint32])==0);

   935 	test(TheView.ColUint(TheMap[anOffset+EUint32])==0);

   936 	test(TheView.ColInt64(TheMap[anOffset+EInt64])==KMinTInt64);

   937 	test(TheView.ColReal32(TheMap[anOffset+EReal32])==KMinTReal32);

   938 	test(TheView.ColReal64(TheMap[anOffset+EReal64])==KMinTReal64);

   939 	test(TheView.ColReal(TheMap[anOffset+EReal64])==KMinTReal64);

   940 	test(TheView.ColTime(TheMap[anOffset+ETime])==KMinTTime);

   941 	test(TheView.ColDes8(TheMap[anOffset+EText8])==KTestShortText8);

   942 	test(TheView.ColSize(TheMap[anOffset+EText8])==KTestShortText8.Size());

   943 	test(TheView.ColLength(TheMap[anOffset+EText8])==KTestShortText8.Length());

   944 	test(TheView.ColDes16(TheMap[anOffset+EText16])==KTestShortText16);

   945 	test(TheView.ColSize(TheMap[anOffset+EText16])==KTestShortText16.Size());

   946 	test(TheView.ColLength(TheMap[anOffset+EText16])==KTestShortText16.Length());

   947 	{

   948 	TUint8 val=0;

   949 	test(TheView.ColDes8(TheMap[anOffset+ETBinary])==TPtrC8(&val,sizeof(val)));

   950 	}

   951 	test(TheView.ColSize(TheMap[anOffset+ETBinary])==1);

   952 	test(TheView.ColLength(TheMap[anOffset+ETBinary])==1);

   953 //

   954 	test(TheView.ColSize(TheMap[anOffset+ELongText8])==KTestShortText8.Size());

   955 	test(TheView.ColLength(TheMap[anOffset+ELongText8])==KTestShortText8.Length());

   956 	RDbColReadStream in;

   957 	in.OpenLC(TheView,TheMap[anOffset+ELongText8]);

   958 	in.ReadL(TheBuf8,TheView.ColLength(TheMap[anOffset+ELongText8]));

   959 	CleanupStack::PopAndDestroy();

   960 	test(TheBuf8==KTestShortText8);

   961 //

   962 	test(TheView.ColSize(TheMap[anOffset+ELongText16])==KTestShortText16.Size());

   963 	test(TheView.ColLength(TheMap[anOffset+ELongText16])==KTestShortText16.Length());

   964 	in.OpenLC(TheView,TheMap[anOffset+ELongText16]);

   965 	in.ReadL(TheBuf16,TheView.ColLength(TheMap[anOffset+ELongText16]));

   966 	CleanupStack::PopAndDestroy();

   967 	test(TheBuf16==KTestShortText16);

   968 //

   969 	test(TheView.ColSize(TheMap[anOffset+ELongBinary])==1);

   970 	test(TheView.ColLength(TheMap[anOffset+ELongBinary])==1);

   971 	in.OpenLC(TheView,TheMap[anOffset+ELongBinary]);

   972 	test(in.ReadUint8L()==0);

   973 	CleanupStack::PopAndDestroy();

   974 	}

   976 //

   977 // Check the row is the same as was written

   978 //

   979 LOCAL_C void CheckMinimum(TInt aCounter)

   980 	{

   981 	TheView.GetL();

   982 	test(TheView.ColInt32(TheMap[ECounter])==aCounter);

   983 	CheckMinValues(0);

   984 	CheckMinValues(EBitNull-EBit);

   985 	}

   987 LOCAL_C void WriteMaxValues(TInt anOffset)

   988 	{

   989 	TheView.SetColL(TheMap[anOffset+EBit],TUint(1));

   990 	TheView.SetColL(TheMap[anOffset+EInt8],KMaxTInt8);

   991 	TheView.SetColL(TheMap[anOffset+EUint8],TUint(KMaxTUint8));

   992 	TheView.SetColL(TheMap[anOffset+EInt16],KMaxTInt16);

   993 	TheView.SetColL(TheMap[anOffset+EUint16],TUint(KMaxTUint16));

   994 	TheView.SetColL(TheMap[anOffset+EInt32],KMaxTInt32);

   995 	TheView.SetColL(TheMap[anOffset+EUint32],KMaxTUint32);

   996 	TheView.SetColL(TheMap[anOffset+EInt64],KMaxTInt64);

   997 	TheView.SetColL(TheMap[anOffset+EReal32],KMaxTReal32);

   998 	TheView.SetColL(TheMap[anOffset+EReal64],KMaxTReal64);

   999 	TheView.SetColL(TheMap[anOffset+ETime],KMaxTTime);

  1000 	TheView.SetColL(TheMap[anOffset+EText8],KTestText8);

  1001 	TheView.SetColL(TheMap[anOffset+EText16],KTestText16);

  1002 	TheView.SetColL(TheMap[anOffset+ETBinary],TPtrC8((TUint8*)&TheMap[0],sizeof(TheMap)));

  1003 	TheView.SetColL(TheMap[anOffset+ELongText8],KTestLongText8);

  1004 	TheView.SetColL(TheMap[anOffset+ELongText16],KTestLongText16);

  1005 	RDbColWriteStream out;

  1006 	out.OpenLC(TheView,TheMap[anOffset+ELongBinary]);

  1007 	for (TInt ii=0;ii<KBlobItems;++ii)

  1008 		out.WriteInt32L(ii);

  1009 	out.CommitL();

  1010 	CleanupStack::PopAndDestroy();

  1011 	}

  1013 //

  1014 // Write a row with the maximum (or longer) column values

  1015 // return the value in the counter column

  1016 //

  1017 LOCAL_C TInt WriteMaximum()

  1018 	{

  1019 	TheView.InsertL();

  1020 	WriteMaxValues(0);

  1021 	WriteMaxValues(EBitNull-EBit);

  1022 	test(!TheView.IsColNull(TheMap[ECounter]));

  1023 	TInt cc=TheView.ColInt(TheMap[ECounter]);

  1024 	TheView.PutL();

  1025 	return cc;

  1026 	}

  1028 LOCAL_C void CheckMaxValues(TInt anOffset)

  1029 	{

  1030 	test(TheView.ColUint8(TheMap[anOffset+EBit])==1);

  1031 	test(TheView.ColUint16(TheMap[anOffset+EBit])==1);

  1032 	test(TheView.ColUint32(TheMap[anOffset+EBit])==1);

  1033 	test(TheView.ColUint(TheMap[anOffset+EBit])==1);

  1034 	test(TheView.ColInt8(TheMap[anOffset+EInt8])==KMaxTInt8);

  1035 	test(TheView.ColInt16(TheMap[anOffset+EInt8])==KMaxTInt8);

  1036 	test(TheView.ColInt32(TheMap[anOffset+EInt8])==KMaxTInt8);

  1037 	test(TheView.ColInt(TheMap[anOffset+EInt8])==KMaxTInt8);

  1038 	test(TheView.ColUint8(TheMap[anOffset+EUint8])==KMaxTUint8);

  1039 	test(TheView.ColUint16(TheMap[anOffset+EUint8])==KMaxTUint8);

  1040 	test(TheView.ColUint32(TheMap[anOffset+EUint8])==KMaxTUint8);

  1041 	test(TheView.ColUint(TheMap[anOffset+EUint8])==KMaxTUint8);

  1042 	test(TheView.ColInt16(TheMap[anOffset+EInt16])==KMaxTInt16);

  1043 	test(TheView.ColInt32(TheMap[anOffset+EInt16])==KMaxTInt16);

  1044 	test(TheView.ColInt(TheMap[anOffset+EInt16])==KMaxTInt16);

  1045 	test(TheView.ColUint16(TheMap[anOffset+EUint16])==KMaxTUint16);

  1046 	test(TheView.ColUint32(TheMap[anOffset+EUint16])==KMaxTUint16);

  1047 	test(TheView.ColUint(TheMap[anOffset+EUint16])==KMaxTUint16);

  1048 	test(TheView.ColInt32(TheMap[anOffset+EInt32])==KMaxTInt32);

  1049 	test(TheView.ColInt(TheMap[anOffset+EInt32])==KMaxTInt32);

  1050 	test(TheView.ColUint32(TheMap[anOffset+EUint32])==KMaxTUint32);

  1051 	test(TheView.ColUint(TheMap[anOffset+EUint32])==KMaxTUint32);

  1052 	test(TheView.ColInt64(TheMap[anOffset+EInt64])==KMaxTInt64);

  1053 	test(TheView.ColReal32(TheMap[anOffset+EReal32])==KMaxTReal32);

  1054 	test(TheView.ColReal64(TheMap[anOffset+EReal64])==KMaxTReal64);

  1055 	test(TheView.ColReal(TheMap[anOffset+EReal64])==KMaxTReal64);

  1056 	test(TheView.ColTime(TheMap[anOffset+ETime])==KMaxTTime);

  1057 	test(TheView.ColDes8(TheMap[anOffset+EText8])==KTestText8);

  1058 	test(TheView.ColSize(TheMap[anOffset+EText8])==KTestText8.Size());

  1059 	test(TheView.ColLength(TheMap[anOffset+EText8])==KTestText8.Length());

  1060 	test(TheView.ColDes16(TheMap[anOffset+EText16])==KTestText16);

  1061 	test(TheView.ColSize(TheMap[anOffset+EText16])==KTestText16.Size());

  1062 	test(TheView.ColLength(TheMap[anOffset+EText16])==KTestText16.Length());

  1063 	test(TheView.ColDes8(TheMap[anOffset+ETBinary])==TPtrC8((TUint8*)&TheMap[0],sizeof(TheMap)));

  1064 	test(TheView.ColSize(TheMap[anOffset+ETBinary])==sizeof(TheMap));

  1065 	test(TheView.ColLength(TheMap[anOffset+ETBinary])==sizeof(TheMap));

  1066 //

  1067 	test(TheView.ColSize(TheMap[anOffset+ELongText8])==KTestLongText8.Size());

  1068 	test(TheView.ColLength(TheMap[anOffset+ELongText8])==KTestLongText8.Length());

  1069 	RDbColReadStream in;

  1070 	in.OpenLC(TheView,TheMap[anOffset+ELongText8]);

  1071 	in.ReadL(TheBuf8,TheView.ColLength(TheMap[anOffset+ELongText8]));

  1072 	CleanupStack::PopAndDestroy();

  1073 	test(TheBuf8==KTestLongText8);

  1074 //

  1075 	test(TheView.ColSize(TheMap[anOffset+ELongText16])==KTestLongText16.Size());

  1076 	test(TheView.ColLength(TheMap[anOffset+ELongText16])==KTestLongText16.Length());

  1077 	in.OpenLC(TheView,TheMap[anOffset+ELongText16]);

  1078 	in.ReadL(TheBuf16,TheView.ColLength(TheMap[anOffset+ELongText16]));

  1079 	CleanupStack::PopAndDestroy();

  1080 	test(TheBuf16==KTestLongText16);

  1081 //

  1082 	test(TheView.ColSize(TheMap[anOffset+ELongBinary])==KBlobItems*sizeof(TUint32));

  1083 	test(TheView.ColLength(TheMap[anOffset+ELongBinary])==KBlobItems*sizeof(TUint32));

  1084 	in.OpenLC(TheView,TheMap[anOffset+ELongBinary]);

  1085 	for (TInt ii=0;ii<KBlobItems;++ii)

  1086 		test(in.ReadInt32L()==ii);

  1087 	CleanupStack::PopAndDestroy();

  1088 	}

  1090 //

  1091 // Check the row is the same as was written

  1092 //

  1093 LOCAL_C void CheckMaximum(TInt aCounter)

  1094 	{

  1095 	TheView.GetL();

  1096 	test(TheView.ColInt32(TheMap[ECounter])==aCounter);

  1097 	CheckMaxValues(0);

  1098 	CheckMaxValues(EBitNull-EBit);

  1099 	}

  1101 //

  1102 // Write a row with null column values in the nullable columns

  1103 // return the value in the counter column

  1104 //

  1105 LOCAL_C TInt WriteNull()

  1106 	{

  1107 	TheView.InsertL();

  1108 	WriteMinValues(0);

  1109 	test(!TheView.IsColNull(TheMap[ECounter]));

  1110 	TInt cc=TheView.ColInt(TheMap[ECounter]);

  1111 	TheView.PutL();

  1112 	return cc;

  1113 	}

  1115 //

  1116 // Check the row is the same as was written

  1117 //

  1118 LOCAL_C void CheckNull(TInt aCounter)

  1119 	{

  1120 	TheView.GetL();

  1121 	test(TheView.ColInt32(TheMap[ECounter])==aCounter);

  1122 	TInt ii;

  1123 	for (ii=ECounter;ii<EBitNull;ii++)

  1124 		{	// not null columns

  1125 		TDbColNo col=TheMap[ii];

  1126 		test(!TheView.IsColNull(col));

  1127 		test(TheView.ColSize(col)!=0);

  1128 		test(TheView.ColLength(col)!=0);

  1129 		if (ii<ELongText8)

  1130 			test(TheView.ColDes8(col).Length()!=0);

  1131 		}

  1132 	CheckMinValues(0);

  1133 	for (;ii<EForceNull-1;++ii)

  1134 		{	// null columns

  1135 		TDbColNo col=TheMap[ii];

  1136 		test(TheView.IsColNull(col));

  1137 		test(TheView.ColSize(col)==0);

  1138 		test(TheView.ColLength(col)==0);

  1139 		if (ii<ELongText8Null)

  1140 			test(TheView.ColDes8(col).Length()==0);

  1141 		}

  1142 	test(TheView.ColUint(TheMap[EBitNull])==0);

  1143 	test(TheView.ColInt(TheMap[EInt8Null])==0);

  1144 	test(TheView.ColUint(TheMap[EUint8Null])==0);

  1145 	test(TheView.ColInt(TheMap[EInt16Null])==0);

  1146 	test(TheView.ColUint(TheMap[EUint16Null])==0);

  1147 	test(TheView.ColInt(TheMap[EInt32Null])==0);

  1148 	test(TheView.ColUint(TheMap[EUint32Null])==0);

  1149 	test(TheView.ColInt64(TheMap[EInt64Null])==0);

  1150 	test(TheView.ColReal32(TheMap[EReal32Null])==0);

  1151 	test(TheView.ColReal64(TheMap[EReal64Null])==0);

  1152 	test(TheView.ColTime(TheMap[ETimeNull])==TTime(0));

  1153 	}

  1155 //

  1156 // Copy the last row (should have a different auto-inc value)

  1157 //

  1158 LOCAL_C TInt WriteCopy()

  1159 	{

  1160 	TheView.LastL();

  1161 	TheView.InsertCopyL();

  1162 	TheView.SetColL(TheMap[EForceNull],1234567);

  1163 	test(!TheView.IsColNull(TheMap[ECounter]));

  1164 	TInt cc=TheView.ColInt(TheMap[ECounter]);

  1165 	TheView.PutL();

  1166 	return cc;

  1167 	}

  1169 template <class T>

  1170 void TestOverflow(TDbColNo aCol,const T& aValue)

  1171 	{

  1172 	TheView.UpdateL();

  1173 	TheView.SetColL(aCol,aValue);

  1174 	TRAPD(r,TheView.PutL());

  1175 	test(r==KErrOverflow);

  1176 	TheView.Cancel();

  1177 	}

  1179 LOCAL_C void TestWriteNull(TDbColNo aCol)

  1180 	{

  1181 	TheView.UpdateL();

  1182 	TheView.SetColNullL(aCol);

  1183 	TRAPD(r,TheView.PutL());

  1184 	test(r==KErrNotFound);

  1185 	TheView.Cancel();

  1186 	}

  1188 LOCAL_C void TestValidation()

  1189 	{

  1190 	TheView.InsertL();

  1191 	WriteMinValues(0);

  1192 	TheView.PutL();

  1193 	TestOverflow(TheMap[EBit],TUint(2));

  1194 	TestOverflow(TheMap[EBit],TUint(0xffffffffu));

  1195 	TestOverflow(TheMap[EInt8],TInt(-129));

  1196 	TestOverflow(TheMap[EInt8],TInt(128));

  1197 	TestOverflow(TheMap[EUint8],TUint(0xffffffffu));

  1198 	TestOverflow(TheMap[EUint8],TUint(256));

  1199 	TestOverflow(TheMap[EInt16],TInt(-32769));

  1200 	TestOverflow(TheMap[EInt16],TInt(32768));

  1201 	TestOverflow(TheMap[EUint16],TUint(0xffffffffu));

  1202 	TestOverflow(TheMap[EUint16],TUint(65536));

  1203 	{

  1204 	TBuf8<KDbDefaultTextColLength+1> buf;

  1205 	buf.SetMax();

  1206 	buf.Fill('x');

  1207 	TestOverflow(TheMap[EText8],buf);

  1208 	}

  1209 	{

  1210 	TBuf16<KDbDefaultTextColLength+1> buf;

  1211 	buf.SetMax();

  1212 	buf.Fill('x');

  1213 	TestOverflow(TheMap[EText16],buf);

  1214 	}

  1215 	for (TInt ii=EBit;ii<EBitNull;++ii)

  1216 		TestWriteNull(TheMap[ii]);

  1217 	}

  1219 /**

  1220 @SYMTestCaseID          SYSLIB-DBMS-CT-0597

  1221 @SYMTestCaseDesc        Tests the range and values of all columns types

  1222 @SYMTestPriority        Medium

  1223 @SYMTestActions         Tests for integral accessors

  1224 @SYMTestExpectedResults Test must not fail

  1225 @SYMREQ                 REQ0000

  1226 */

  1227 LOCAL_C void TestTypes()

  1228 	{

  1229 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0597 Create table of all types "));

  1230 	OpenDatabase();

  1231 	CDbColSet* cs=CreateColSetL(EAllTypes);

  1232 	test(TheDatabase.CreateTable(KTestTypesTable,*cs)==KErrNone);

  1233 	delete cs;

  1234 	test(TheView.Prepare(TheDatabase,_L("select * from TestTypesTable"))==KErrNone);

  1235 	test(TheView.EvaluateAll()==KErrNone);

  1236 	cs=TheView.ColSetL();

  1237 	for (TInt ii=0;ii<KColumns;ii++)

  1238 		TheMap[ii]=cs->ColNo(TPtrC(AllColumns[ii].iName));

  1239 	delete cs;

  1240 	test.Next(_L("Test integral accessors"));

  1241 	CheckIntAccessors();

  1242 	test.Next(_L("Add row of minimum values"));

  1243 	TInt c1=WriteMinimum();

  1244 	test.Next(_L("Add row of maximum values"));

  1245 	TInt c2=WriteMaximum();

  1246 	test(c2>c1);

  1247 	test.Next(_L("Add row of Null values"));

  1248 	TInt c3=WriteNull();

  1249 	test(c3>c2);

  1250 	test.Next(_L("Add a copy of the last row"));

  1251 	TInt c4=WriteCopy();

  1252 	test(c4>c3);

  1253 	test.Next(_L("Check minimum values"));

  1254 	TheView.FirstL();

  1255 	CheckMinimum(c1);

  1256 	test.Next(_L("Check maximum values"));

  1257 	TheView.NextL();

  1258 	CheckMaximum(c2);

  1259 	test.Next(_L("Check Null values"));

  1260 	TheView.NextL();

  1261 	CheckNull(c3);

  1262 	TheView.NextL();

  1263 	CheckNull(c4);

  1264 	test.Next(_L("Test column value Validation"));

  1265 	TestValidation();

  1266 	TheView.Close();

  1267 	CloseDatabase();

  1268 	test.End();

  1269 	}

  1271 const TPtrC KColumnID(_S("id"));

  1272 const TPtrC KColumnText(_S("txt"));

  1273 const TPtrC KColumnOther(_S("other"));

  1274 const TPtrC KBlobText(_S("text"));

  1275 const TPtrC KFind1(_S("id=1"));

  1276 const TPtrC KFind2(_S("id is null"));

  1278 // records will be:

  1279 // 0: "text"

  1280 // 1: "aaa...aaatext"

  1281 // 2: "textaaa...aaa"

  1282 // 3: "aaa...aaa"

  1283 // 4: "aaa...aaatextaaa...aaa"

  1284 // 5: ""

  1286 struct STest

  1287 	{

  1288 	const TText* iText;

  1289 	TUint iRecs;

  1290 	};

  1292 LOCAL_D STest const Tests[]=

  1293 	{

  1294 		{_S("txt like 'a*'"),0x010110},

  1295 		{_S("txt like 'a*' or other like 'a*'"),0x111111},

  1296 		{_S("txt like 'a*' and other like 'a*'"),0x010110},

  1297 		{_S("txt < 'text'"),0x010111},

  1298 		{_S("txt > 'text'"),0x001000},

  1299 		{_S("txt > ''"),0x111110},

  1300 		{_S("txt like 'text'"),0x100000},

  1301 		{_S("txt like '*TEXT'"),0x110000},

  1302 		{_S("txt like 'text*'"),0x101000},

  1303 		{_S("txt like '*text*'"),0x111010},

  1304 		{_S("txt like '*'"),0x111111},

  1305 		{_S("txt like '?*'"),0x111110},

  1306 		{_S("txt like '*t*t*'"),0x111010},

  1307 		{_S("txt like '*a??t*'"),0x010010},

  1308 		{_S("txt like 'aA*aa'"),0x000110},

  1309 		{_S("txt like 'teXT'"),0x100000},

  1310 		{_S("txt like '*text'"),0x110000},

  1311 		{_S("txt like '*tExt*'"),0x111010},

  1312 		{_S("txt like ''"),0x000001},

  1313 		{_S("txt is null"),0x000001}

  1314 	};

  1316 LOCAL_C void CreateFindTable()

  1317 	{

  1318 	CDbColSet *pC=CDbColSet::NewL();

  1319 	CleanupStack::PushL(pC);

  1320 	pC->AddL(TDbCol(KColumnID,EDbColUint32));

  1321 	pC->AddL(TDbCol(KColumnText,EDbColLongText,200));

  1322 	pC->AddL(TDbCol(KColumnOther,EDbColText,200));

  1323 	test(TheDatabase.CreateTable(KTestFindTable,*pC)==KErrNone);

  1324 	CleanupStack::PopAndDestroy();

  1325 	test(TheTable.Open(TheDatabase,KTestFindTable,TheTable.EInsertOnly)==KErrNone);

  1326 	TBuf<0x40> garbage;

  1327 	garbage.SetMax();

  1328 	garbage.Fill('a');

  1329 	TBuf<0xff> col;

  1330 	for (TUint ii=0;ii<6;++ii)

  1331 		{

  1332 		TheTable.InsertL();

  1333 		TheTable.SetColL(1,ii);

  1334 		TheTable.SetColL(3,_L("abcdef"));

  1336 		switch (ii)

  1337 			{

  1338 		case 0:

  1339 			TheTable.SetColL(2,KBlobText);

  1340 			break;

  1341 		case 1:

  1342 			col=garbage;

  1343 			col+=KBlobText;

  1344 			TheTable.SetColL(2,col);

  1345 			break;

  1346 		case 2:

  1347 			col=KBlobText;

  1348 			col+=garbage;

  1349 			TheTable.SetColL(2,col);

  1350 			break;

  1351 		case 3:

  1352 			TheTable.SetColL(2,garbage);

  1353 			break;

  1354 		case 4:

  1355 			col=garbage;

  1356 			col+=KBlobText;

  1357 			col+=garbage;

  1358 			TheTable.SetColL(2,col);

  1359 			break;

  1360 		case 5:

  1361 			break;

  1362 			}

  1363 		TheTable.PutL();

  1364 		}

  1365 	TheTable.Close();

  1366 	CDbKey* key=CDbKey::NewLC();

  1367 	key->AddL(KColumnID);

  1368 	key->MakeUnique();

  1369 	test(TheDatabase.CreateIndex(KIndexName,KTestFindTable,*key)==KErrNone);

  1370 	key->Clear();

  1371 	key->AddL(TDbKeyCol(KColumnText,100));

  1372 	key->MakeUnique();

  1373 	key->SetComparison(EDbCompareFolded);

  1374 	test(TheDatabase.CreateIndex(KIndexName2,KTestFindTable,*key)==KErrNone);

  1375 	CleanupStack::PopAndDestroy(); //key

  1376 	}

  1378 /**

  1379 @SYMTestCaseID          SYSLIB-DBMS-CT-0598

  1380 @SYMTestCaseDesc        Tests for RDbRowConstraint::Open() function

  1381 @SYMTestPriority        Medium

  1382 @SYMTestActions         Tests for the specified SQL search-condition for matching against rows in the specified rowset

  1383 @SYMTestExpectedResults Test must not fail

  1384 @SYMREQ                 REQ0000

  1385 */

  1386 LOCAL_C void TestMatch()

  1387 	{

  1388 	test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0598 Match "));

  1389 	test(TheTable.Open(TheDatabase,KTestFindTable,TheTable.EReadOnly)==KErrNone);

  1390 	for (TInt ii=0;ii<TInt(sizeof(Tests)/sizeof(Tests[0]));++ii)

  1391 		{

  1392 		RDbRowConstraint match;

  1393 		test(match.Open(TheTable,TDbQuery(TPtrC(Tests[ii].iText),EDbCompareFolded))==KErrNone);

  1394 		TUint mask=0;

  1395 		TheTable.BeginningL();

  1396 		while (TheTable.NextL())

  1397 			{

  1398 			if (TheTable.MatchL(match))

  1399 				{

  1400 				TheTable.GetL();

  1401 				TUint bit=0x100000>>(TheTable.ColUint32(1)*4);

  1402 				test((bit&mask)==0);

  1403 				mask|=bit;

  1404 				}

  1405 			}

  1406 		match.Close();

  1407 		test(mask==Tests[ii].iRecs);

  1408 		}

  1409 	TheTable.Close();

  1410 	}

  1412 /**

  1413 @SYMTestCaseID          SYSLIB-DBMS-CT-0599

  1414 @SYMTestCaseDesc        Tests for RDbRowSet::FindL(),RDbRowSet::GetL() functions

  1415 @SYMTestPriority        Medium

  1416 @SYMTestActions         Tests for finding a match through a rowset

  1417 @SYMTestExpectedResults Test must not fail

  1418 @SYMREQ                 REQ0000

  1419 */

  1420 LOCAL_C void TestFind(RDbRowSet& aSet)

  1421 	{

  1422 	test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0599 "));

  1423 	CDbColSet* cs=aSet.ColSetL();

  1424 	test(cs!=0);

  1425 	TDbColNo col=cs->ColNo(KColumnID);

  1426 	test(col!=KDbNullColNo);

  1427 	delete cs;

  1428 	aSet.FirstL();

  1429 	TInt p1=aSet.FindL(aSet.EForwards,KFind1);

  1430 	test(p1>=0);

  1431 	aSet.GetL();

  1432 	test(aSet.ColUint(col)==1);

  1433 	test(aSet.FindL(aSet.EForwards,KFind1)==0);

  1434 	aSet.GetL();

  1435 	test(aSet.ColUint(col)==1);

  1436 	if (aSet.NextL())

  1437 		test(aSet.FindL(aSet.EForwards,KFind1)==KErrNotFound);

  1438 	aSet.FirstL();

  1439 	test(aSet.FindL(aSet.EForwards,KFind2)==KErrNotFound);

  1440 	aSet.LastL();

  1441 	TInt p2=aSet.FindL(aSet.EBackwards,KFind1);

  1442 	test(p2>=0);

  1443 	aSet.GetL();

  1444 	test(aSet.ColUint(col)==1);

  1445 	test(aSet.FindL(aSet.EBackwards,KFind1)==0);

  1446 	aSet.GetL();

  1447 	test(aSet.ColUint(col)==1);

  1448 	if (aSet.PreviousL())

  1449 		test(aSet.FindL(aSet.EBackwards,KFind1)==KErrNotFound);

  1450 	aSet.LastL();

  1451 	test(aSet.FindL(aSet.EBackwards,KFind2)==KErrNotFound);

  1452 	test(p1+p2+1==aSet.CountL());

  1453 	}

  1455 /**

  1456 @SYMTestCaseID          SYSLIB-DBMS-CT-0600

  1457 @SYMTestCaseDesc        Tests for SQL find

  1458 @SYMTestPriority        Medium

  1459 @SYMTestActions         Tests for SQL querying a table

  1460 @SYMTestExpectedResults Test must not fail

  1461 @SYMREQ                 REQ0000

  1462 */

  1463 LOCAL_C void TestSQLFind(const TText* aSql)

  1464 	{

  1465     test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0600 "));

  1466 	test(TheView.Prepare(TheDatabase,TDbQuery(TPtrC(aSql),EDbCompareFolded),TheView.EReadOnly)==KErrNone);

  1467 	test(TheView.EvaluateAll()==KErrNone);

  1468 	TestFind(TheView);

  1469 	TheView.Close();

  1470 	}

  1472 /**

  1473 @SYMTestCaseID          SYSLIB-DBMS-CT-0601

  1474 @SYMTestCaseDesc        Tests for DBMS limits

  1475 @SYMTestPriority        Medium

  1476 @SYMTestActions         Tests for maximum length boundaries

  1477 @SYMTestExpectedResults Test must not fail

  1478 @SYMREQ                 REQ0000

  1479 */

  1480 LOCAL_C void TestDbmsBoundaries()

  1481 	{

  1482 	test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0601 "));

  1483 	// Test KMaxSegmentLength boundary

  1485 	_LIT(KMaxSegmentLengthMinusOne,"txt like \

  1486 		'*01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567@0.com*' \

  1487 		  or other like \

  1488 		'*01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567@0.com*'");

  1489 	_LIT(KMaxSegmentLengthExact,"txt like \

  1490 		'*012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678@0.com*' \

  1491 		  or other like \

  1492 		'*012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678@0.com*'");

  1493 	_LIT(KMaxSegmentLengthPlusOne,"txt like \

  1494 		'*0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789@0.com*' \

  1495 		  or other like \

  1496 		'*0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789@0.com*'");

  1498 	TInt ret=KErrNone;

  1499 	RDbRowConstraint match;

  1501 	test(TheTable.Open(TheDatabase,KTestFindTable,TheTable.EReadOnly)==KErrNone);

  1503 	// Test one less than the boundary

  1504 	ret = match.Open(TheTable,TDbQuery(KMaxSegmentLengthMinusOne,EDbCompareFolded));

  1505 	match.Close();

  1506 	test(ret==KErrNone);

  1508 	// Test the boundary

  1509 	ret = match.Open(TheTable,TDbQuery(KMaxSegmentLengthExact,EDbCompareFolded));

  1510 	match.Close();

  1511 	test(ret==KErrNone);

  1513 	// Test one more than the boundary

  1514 	ret = match.Open(TheTable,TDbQuery(KMaxSegmentLengthPlusOne,EDbCompareFolded));

  1515 	match.Close();

  1516 	test(ret==KErrArgument);

  1518 	TheTable.Close();

  1519 	}

  1521 /**

  1522 @SYMTestCaseID          SYSLIB-DBMS-CT-0602

  1523 @SYMTestCaseDesc        Tests for table order,SQL query,

  1524 @SYMTestPriority        Medium

  1525 @SYMTestActions         Tests for finding a row in a rowset,dbms boundaries,SQL querying

  1526 @SYMTestExpectedResults Test must not fail

  1527 @SYMREQ                 REQ0000

  1528 */

  1529 LOCAL_C void TestFind()

  1530 	{

  1531 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0602 Table order "));

  1532 	test(TheTable.Open(TheDatabase,KTestFindTable,TheTable.EReadOnly)==KErrNone);

  1533 	TestFind(TheTable);

  1534 	test.Next(_L("Index order"));

  1535 	test(TheTable.SetIndex(KIndexName)==KErrNone);

  1536 	TestFind(TheTable);

  1537 	test(TheTable.SetIndex(KIndexName2)==KErrNone);

  1538 	TestFind(TheTable);

  1539 	TheTable.Close();

  1541 	test.Next(_L("SQL query test boundary"));

  1542 	TestDbmsBoundaries();

  1544 	test.Next(_L("SQL query"));

  1545 	TestSQLFind(_S("select id from TestFindTable where id=1"));

  1546 	TestSQLFind(_S("select * from TestFindTable where id<=2"));

  1547 	TestSQLFind(_S("select txt,id from TestFindTable order by id desc"));

  1548 	TestSQLFind(_S("select id,txt from TestFindTable where id=1 or txt like '*text*'"));

  1549 	TestSQLFind(_S("select * from TestFindTable where id=1 or txt is not null order by id"));

  1550 	TestSQLFind(_S("select id from TestFindTable where id<>3 order by txt"));

  1551 	test.End();

  1552 	}

  1554 LOCAL_C void TestBookmark(RDbRowSet& aSet)

  1555 	{

  1556 	aSet.BeginningL();

  1557 	while (aSet.NextL())

  1558 		{

  1559 		aSet.GetL();

  1560 		TUint id=aSet.ColUint(1);

  1561 		TDbBookmark mark=aSet.Bookmark();

  1562 		aSet.BeginningL();

  1563 		aSet.GotoL(mark);

  1564 		aSet.GetL();

  1565 		test(aSet.ColUint(1)==id);

  1566 		aSet.NextL();

  1567 		aSet.PreviousL();

  1568 		aSet.PreviousL();

  1569 		aSet.NextL();

  1570 		aSet.GetL();

  1571 		test(aSet.ColUint(1)==id);

  1572 		aSet.GotoL(mark);

  1573 		};

  1574 	}

  1576 LOCAL_C void TestSQLBookmark(const TText* aSql)

  1577 	{

  1578 	test(TheView.Prepare(TheDatabase,TDbQuery(TPtrC(aSql),EDbCompareFolded),TheView.EReadOnly)==KErrNone);

  1579 	test(TheView.EvaluateAll()==KErrNone);

  1580 	TestBookmark(TheView);

  1581 	TheView.Close();

  1582 	}

  1584 LOCAL_C void TestBookmark()

  1585 	{

  1586 	test.Start(_L("Table order"));

  1587 	test(TheTable.Open(TheDatabase,KTestFindTable,TheTable.EReadOnly)==KErrNone);

  1588 	TestBookmark(TheTable);

  1589 	test.Next(_L("Index order"));

  1590 	test(TheTable.SetIndex(KIndexName)==KErrNone);

  1591 	TestBookmark(TheTable);

  1592 	test(TheTable.SetIndex(KIndexName2)==KErrNone);

  1593 	TestBookmark(TheTable);

  1594 	TheTable.Close();

  1595 	test.Next(_L("SQL query"));

  1596 	TestSQLBookmark(_S("select * from TestFindTable where id=1"));

  1597 	TestSQLBookmark(_S("select * from TestFindTable where id>2"));

  1598 	TestSQLBookmark(_S("select * from TestFindTable order by id desc"));

  1599 	TestSQLBookmark(_S("select * from TestFindTable where txt like '*text*'"));

  1600 	TestSQLBookmark(_S("select * from TestFindTable where txt is not null order by id"));

  1601 	TestSQLBookmark(_S("select * from TestFindTable where id <> 3 order by txt"));

  1602 	test.End();

  1603 	}

  1605 /**

  1606 @SYMTestCaseID          SYSLIB-DBMS-CT-0603

  1607 @SYMTestCaseDesc        Tests for find and bookmark

  1608 @SYMTestPriority        Medium

  1609 @SYMTestActions         Executes Match,Find,Bookmarks tests

  1610 @SYMTestExpectedResults Test must not fail

  1611 @SYMREQ                 REQ0000

  1612 */

  1613 LOCAL_C void TestFindAndBookmark()

  1614 	{

  1615 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0603 Create Table "));

  1616 	OpenDatabase();

  1617 	CreateFindTable();

  1618 	test.Next(_L("Match"));

  1619 	TestMatch();

  1620 	test.Next(_L("Find"));

  1621 	TestFind();

  1622 	test.Next(_L("Bookmarks"));

  1623 	TestBookmark();

  1624 	test.Next(_L("Close"));

  1625 	CloseDatabase();

  1626 	test.End();

  1627 	}

  1629 /**

  1630 @SYMTestCaseID          SYSLIB-DBMS-CT-0604

  1631 @SYMTestCaseDesc        Tests for multi view

  1632 @SYMTestPriority        Medium

  1633 @SYMTestActions         Tests for adding and deleting rows

  1634 @SYMTestExpectedResults Test must not fail

  1635 @SYMREQ                 REQ0000

  1636 */

  1637 LOCAL_C void TestMultiView()

  1638 	{

  1639 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0604 Create Table "));

  1640 	OpenDatabase();

  1641 	CDbColSet* set=CreateColSetL(ESingleColumn);

  1642 	test(TheDatabase.CreateTable(KTestMultiTable,*set)==KErrNone);

  1643 	delete set;

  1644 	test.Next(_L("Add and modify rows"));

  1645 	test(TheTable.Open(TheDatabase,KTestMultiTable)==KErrNone);

  1646 	test(TheView.Prepare(TheDatabase,_L("select * from TestMultiTable"))==KErrNone);

  1647 	test(TheView.EvaluateAll()==KErrNone);

  1648 	for (TInt ii=1;ii<=10;++ii)

  1649 		{

  1650 		TheTable.InsertL();

  1651 		TheTable.SetColL(1,ii);

  1652 		TheTable.PutL();

  1653 		TheView.NextL();

  1654 		TheView.GetL();

  1655 		test(TheView.ColInt(1)==ii);

  1656 		TheView.UpdateL();

  1657 		TheView.SetColL(1,ii+100);

  1658 		TheView.PutL();

  1659 		test(TheTable.ColInt(1)==ii);

  1660 		TheTable.GetL();

  1661 		test(TheTable.ColInt(1)==ii+100);

  1662 		}

  1663 	test.Next(_L("delete rows"));

  1664 	TheView.FirstL();

  1665 	TheTable.FirstL();

  1666 	TheView.GetL();

  1667 	test (TheView.ColInt(1)==1+100);

  1668 	TheTable.DeleteL();

  1669 	TRAPD(r,TheView.GetL());

  1670 	test(r!=KErrNone);

  1671 	TheView.NextL();

  1672 	TheView.GetL();

  1673 	test (TheView.ColInt(1)==2+100);

  1674 	TheView.DeleteL();

  1675 	test(!TheView.PreviousL());

  1676 	TheTable.NextL();

  1677 	test(!TheTable.PreviousL());

  1678 	test.End();

  1679 	TheView.Close();

  1680 	TheTable.Close();

  1681 	CloseDatabase();

  1682 	}

  1684 LOCAL_C void ValidateUID3(const TDesC& aDbName, const TUid& aUid)

  1685 	{

  1686 	test.Next(_L("Read DB header"));

  1687 	RFile dbFile;

  1688 	TInt err = dbFile.Open(TheFs, aDbName, EFileRead);

  1689 	test(err==KErrNone);

  1690 	TBuf8<100> contents; // header of a new DB is approx 77 bytes

  1691 	err = dbFile.Read(contents);

  1692 	dbFile.Close();

  1693 	test(err==KErrNone);

  1695 	test.Next(_L("Check UID3"));

  1696 	const TPtrC8 ptr((const TUint8*) &aUid.iUid, sizeof(aUid.iUid));

  1697 	TInt pos = contents.Find(ptr);

  1698 	test(pos==8); // UID3 begins at byte pos 8

  1699 	}

  1701 /**

  1702 @SYMTestCaseID          SYSLIB-DBMS-CT-1372

  1703 @SYMTestCaseDesc        Tests for UID3 being set in DB header

  1704 @SYMTestPriority        Medium

  1705 @SYMTestActions         Creates a new DB and checks UID3

  1706 @SYMTestExpectedResults Test must not fail

  1707 @SYMREQ                 REQ0000

  1708 */

  1709 LOCAL_C void TestDbUID3()

  1710 	{

  1711 	const TUid KOrigUid = {0x19768253}; // random UID

  1712 	const TUid KReplaceUid = {0x24731264}; // different random UID

  1713 #ifndef __TOOLS2__

  1714 	const TPtrC KTempDbName(_S("C:\\dbms-tst\\T_DBMS_UID3.DB"));

  1715 #else

  1716 	const TPtrC KTempDbName(_S(".\\dbms-tst\\T_DBMS_UID3.DB"));

  1717 #endif

  1719 	(void)TheFs.Delete(KTempDbName);

  1721 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-1372 Create Database "));

  1722 	RDbNamedDatabase tempDb;

  1723 	TInt err = tempDb.Create(TheFs, KTempDbName, KOrigUid.Name());

  1724 	test(err==KErrNone);

  1725 	tempDb.Close();

  1727 	ValidateUID3(KTempDbName, KOrigUid);

  1729 	test.Next(_L("Replace Database"));

  1730 	err = tempDb.Replace(TheFs, KTempDbName, KReplaceUid.Name());

  1731 	test(err==KErrNone);

  1732 	tempDb.Close();

  1734 	ValidateUID3(KTempDbName, KReplaceUid);

  1736 	test.Next(_L("Replace Database using default UID3"));

  1737 	err = tempDb.Replace(TheFs, KTempDbName);

  1738 	test(err==KErrNone);

  1739 	tempDb.Close();

  1741 	ValidateUID3(KTempDbName, KNullUid);

  1743 	(void)TheFs.Delete(KTempDbName);

  1744 	test.End();

  1745 	}

  1747 LOCAL_C void Test()

  1748 	{

  1749 	__UHEAP_MARK;

  1750 	test.Start(_L("DDL"));

  1751 	TRAPD(r,TestDDL();)

  1752 	test(r==KErrNone);

  1753 	__UHEAP_MARKEND;

  1754 	__UHEAP_MARK;

  1755 	test.Next(_L("Navigation/Edit"));

  1756 	TRAP(r,TestView();)

  1757 	test(r==KErrNone);

  1758 	__UHEAP_MARKEND;

  1759 	__UHEAP_MARK;

  1760 	test.Next(_L("Column Types"));

  1761 	TRAP(r,TestTypes();)

  1762 	test(r==KErrNone);

  1763 	__UHEAP_MARKEND;

  1764 	__UHEAP_MARK;

  1765 	test.Next(_L("Find, Match & Bookmarks"));

  1766 	TRAP(r,TestFindAndBookmark();)

  1767 	test(r==KErrNone);

  1768 	__UHEAP_MARKEND;

  1769 	__UHEAP_MARK;

  1770 	test.Next(_L("Multiple view updates"));

  1771 	TRAP(r,TestMultiView();)

  1772 	test(r==KErrNone);

  1773 	__UHEAP_MARKEND;

  1774 	__UHEAP_MARK;

  1775 	test.Next(_L("Database UID3"));

  1776 	TRAP(r,TestDbUID3();)

  1777 	test(r==KErrNone);

  1778 	test.End();

  1779 	__UHEAP_MARKEND;

  1780 	}

  1782 //

  1783 // Prepare the test directory.

  1784 //

  1785 LOCAL_C void setupTestDirectory()

  1786     {

  1787 	TInt r=TheFs.Connect();

  1788 	test(r==KErrNone);

  1789 //

  1790 	r=TheFs.MkDir(KTestDatabase);

  1791 	test(r==KErrNone || r==KErrAlreadyExists);

  1792 	}

  1794 //

  1795 // Initialise the cleanup stack.

  1796 //

  1797 LOCAL_C void setupCleanup()

  1798     {

  1799 	TheTrapCleanup=CTrapCleanup::New();

  1800 	test(TheTrapCleanup!=NULL);

  1801 	TRAPD(r,\

  1802 		{\

  1803 		for (TInt i=KTestCleanupStack;i>0;i--)\

  1804 			CleanupStack::PushL((TAny*)0);\

  1805 		CleanupStack::Pop(KTestCleanupStack);\

  1806 		});

  1807 	test(r==KErrNone);

  1808 	}

  1810 LOCAL_C void DeleteDataFile(const TDesC& aFullName)

  1811 	{

  1812 	RFs fsSession;

  1813 	TInt err = fsSession.Connect();

  1814 	if(err == KErrNone)

  1815 		{

  1816 		TEntry entry;

  1817 		if(fsSession.Entry(aFullName, entry) == KErrNone)

  1818 			{

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

  1820 			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);

  1821 			if(err != KErrNone)

  1822 				{

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

  1824 				}

  1825 			err = fsSession.Delete(aFullName);

  1826 			if(err != KErrNone)

  1827 				{

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

  1829 				}

  1830 			}

  1831 		fsSession.Close();

  1832 		}

  1833 	else

  1834 		{

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

  1836 		}

  1837 	}

  1839 //

  1840 // Test streaming conversions.

  1841 //

  1842 GLDEF_C TInt E32Main()

  1843     {

  1844 	test.Title();

  1845 	setupTestDirectory();

  1846 	setupCleanup();

  1847 	__UHEAP_MARK;

  1848 //

  1849 #ifndef __TOOLS2__

  1850 	TInt r=TheDbs.Connect();

  1851 	test (r==KErrNone);

  1852 #endif

  1853 	test.Start(_L("Standard database"));

  1854 	Test();

  1855 	test.Next(_L("Secure database"));

  1856 	Test();

  1857 #ifndef __TOOLS2__

  1858 	TheDbs.Close();

  1859 #endif

  1861 #ifndef __linux__

  1862 	TInt err;

  1863 #ifndef __TOOLS2__

  1864 	TRAPD(lc, err = TheCrcChecker.DumpCrcRecordsL(KCrcRecord));

  1865 	test(err==KErrNone);

  1866 	test(lc==KErrNone);

  1867 #else

  1868 	TRAPD(lc, err = TheCrcChecker.ValidateCrcRecordsL(KCrcRecord));

  1869 	TPtrC errmsg;

  1870 	TheCrcChecker.ErrorReportL(err, errmsg);

  1871 	RDebug::Print(errmsg);

  1872 	test(err==KErrNone || err==TDBMS_CRCChecks::ECrcCheckOk);

  1873 #endif // TOOLS2

  1874 #endif // linux

  1876 	test.Next(_L("Waiting for server exit"));

  1877 	const TUint KExitDelay=6*0x100000;	// ~6 seconds

  1878 	User::After(KExitDelay);

  1879 	test.End();

  1880 //

  1881 	__UHEAP_MARKEND;

  1882 	delete TheTrapCleanup;

  1884 	::DeleteDataFile(KTestDatabase);

  1886 	TheFs.Close();

  1887 	test.Close();

  1888 	return 0;

  1889     }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--