os/persistentdata/persistentstorage/dbms/pcdbms/tdbms/src/t_dbmsstrcomp.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200 (2014-06-10)
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib.
sl@0
     1
// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0
     2
// All rights reserved.
sl@0
     3
// This component and the accompanying materials are made available
sl@0
     4
// under the terms of "Eclipse Public License v1.0"
sl@0
     5
// which accompanies this distribution, and is available
sl@0
     6
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0
     7
//
sl@0
     8
// Initial Contributors:
sl@0
     9
// Nokia Corporation - initial contribution.
sl@0
    10
//
sl@0
    11
// Contributors:
sl@0
    12
//
sl@0
    13
// Description:
sl@0
    14
// Testing DBMS ordering and searching functionality when the key field is unicode string.
sl@0
    15
// The idea is to verify that collation level 0 is used when doing string based searching 
sl@0
    16
// and collation level > 0 is used when doing string based ordering.
sl@0
    17
// 
sl@0
    18
//
sl@0
    19
sl@0
    20
#include <e32test.h>
sl@0
    21
#include <f32file.h>
sl@0
    22
#include <d32dbms.h>
sl@0
    23
sl@0
    24
#include "crccheck.h"
sl@0
    25
sl@0
    26
#undef __UHEAP_MARK
sl@0
    27
#define __UHEAP_MARK
sl@0
    28
#undef __UHEAP_MARKEND
sl@0
    29
#define __UHEAP_MARKEND
sl@0
    30
sl@0
    31
LOCAL_D TDBMS_CRCChecks TheCrcChecker;
sl@0
    32
sl@0
    33
#ifndef __linux__ //No CRC test on LINUX
sl@0
    34
#ifdef __TOOLS2__
sl@0
    35
const TPtrC	KCrcRecord=_L("\\epoc32\\winscw\\c\\dbms-tst\\T_DBMSSTRCOMP.CRC");
sl@0
    36
#else
sl@0
    37
const TPtrC	KCrcRecord=_L("C:\\dbms-tst\\T_DBMSSTRCOMP.CRC");
sl@0
    38
#endif
sl@0
    39
#endif
sl@0
    40
sl@0
    41
/////////////////////////////////////////////////////////////////
sl@0
    42
//Globals
sl@0
    43
sl@0
    44
#ifdef __TOOLS2__
sl@0
    45
const TPtrC KTestDatabase = _L(".\\dbms-tst\\T_DbmsStrComp.db");
sl@0
    46
#else
sl@0
    47
const TPtrC KTestDatabase = _L("c:\\dbms-tst\\T_DbmsStrComp.db");
sl@0
    48
#endif
sl@0
    49
sl@0
    50
const TUint             KExitDelay = 6 * 1000000;//6 seconds
sl@0
    51
sl@0
    52
static RTest			TheTest(_L("T_DbmsStrComp test"));
sl@0
    53
static RFs				TheFs;
sl@0
    54
static RDbNamedDatabase TheDb;
sl@0
    55
static RDbs				TheDbSession;
sl@0
    56
sl@0
    57
//Test table defs
sl@0
    58
_LIT(KTestTableName1, "TABLE1");//EDbColText16 key field
sl@0
    59
_LIT(KTestTableName2, "TABLE2");//EDbColLongText16 key field
sl@0
    60
sl@0
    61
struct TColDef
sl@0
    62
	{
sl@0
    63
	const TText*	iName;
sl@0
    64
	TDbColType		iType;
sl@0
    65
	TInt			iAttributes;
sl@0
    66
	};
sl@0
    67
static TColDef const KColDefs1[]=
sl@0
    68
	{
sl@0
    69
		{_S("ID"), EDbColText16, 0},
sl@0
    70
		{_S("DATA"), EDbColUint32, 0},
sl@0
    71
		{0}
sl@0
    72
	};
sl@0
    73
static TColDef const KColDefs2[]=
sl@0
    74
	{
sl@0
    75
		{_S("ID"), EDbColLongText16, 0},
sl@0
    76
		{_S("DATA"), EDbColUint32, 0},
sl@0
    77
		{0}
sl@0
    78
	};
sl@0
    79
sl@0
    80
//Test strings
sl@0
    81
const TInt KTestStrLen = 3; //The length of test strings
sl@0
    82
typedef TBuf16<KTestStrLen> TNameBuf;
sl@0
    83
//Test strings array - using upper and lower case - which will force the DBMS server to make
sl@0
    84
//different decisions depending on what is the current case: ordering or searching.
sl@0
    85
const TNameBuf KTestStr[] = 
sl@0
    86
	{
sl@0
    87
	_L16("aaa"),
sl@0
    88
	_L16("aAa"),
sl@0
    89
	_L16("bbB"),
sl@0
    90
	_L16("BbB")
sl@0
    91
	};
sl@0
    92
const TInt KTestStrCnt = sizeof(KTestStr) / sizeof(KTestStr[0]);
sl@0
    93
sl@0
    94
///////////////////////////////////////////////////////////////////////////////////////
sl@0
    95
///////////////////////////////////////////////////////////////////////////////////////
sl@0
    96
//Destroy test environment - global functions
sl@0
    97
sl@0
    98
//Deletes "aFullName" file.
sl@0
    99
static TInt DeleteDataFile(const TDesC& aFullName)
sl@0
   100
	{
sl@0
   101
	RFs fsSession;
sl@0
   102
	TInt err = fsSession.Connect();
sl@0
   103
	if(err == KErrNone)
sl@0
   104
		{
sl@0
   105
		TEntry entry;
sl@0
   106
		err = fsSession.Entry(aFullName, entry);
sl@0
   107
		if(err == KErrNone)
sl@0
   108
			{
sl@0
   109
			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);
sl@0
   110
			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);
sl@0
   111
			if(err != KErrNone) 
sl@0
   112
				{
sl@0
   113
				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);
sl@0
   114
				}
sl@0
   115
			err = fsSession.Delete(aFullName);
sl@0
   116
			if(err != KErrNone) 
sl@0
   117
				{
sl@0
   118
				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);
sl@0
   119
				}
sl@0
   120
			}
sl@0
   121
		fsSession.Close();
sl@0
   122
		}
sl@0
   123
	else
sl@0
   124
		{
sl@0
   125
		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);
sl@0
   126
		}
sl@0
   127
	return err;
sl@0
   128
	}
sl@0
   129
sl@0
   130
///////////////////////////////////////////////////////////////////////////////////////
sl@0
   131
///////////////////////////////////////////////////////////////////////////////////////
sl@0
   132
//Tests macros and functions.
sl@0
   133
//If (!aValue) then the test will be panicked, the test data files will be deleted.
sl@0
   134
static void Check(TInt aValue, TInt aLine)
sl@0
   135
	{
sl@0
   136
	if(!aValue)
sl@0
   137
		{
sl@0
   138
		::DeleteDataFile(KTestDatabase);
sl@0
   139
		TheTest(EFalse, aLine);
sl@0
   140
		}
sl@0
   141
	}
sl@0
   142
//If (aValue != aExpected) then the test will be panicked, the test data files will be deleted.
sl@0
   143
static void Check(TInt aValue, TInt aExpected, TInt aLine)
sl@0
   144
	{
sl@0
   145
	if(aValue != aExpected)
sl@0
   146
		{
sl@0
   147
		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
sl@0
   148
		::DeleteDataFile(KTestDatabase);
sl@0
   149
		TheTest(EFalse, aLine);
sl@0
   150
		}
sl@0
   151
	}
sl@0
   152
//Use these to test conditions.
sl@0
   153
#define TEST(arg) ::Check((arg), __LINE__)
sl@0
   154
#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
sl@0
   155
sl@0
   156
///////////////////////////////////////////////////////////////////////////////////////
sl@0
   157
///////////////////////////////////////////////////////////////////////////////////////
sl@0
   158
//Global functions
sl@0
   159
sl@0
   160
//Prepares the test directory.
sl@0
   161
//TheFs.Connect() has to be called already.
sl@0
   162
static void SetupTestDirectory()
sl@0
   163
    {
sl@0
   164
	TInt err = TheFs.MkDir(KTestDatabase);
sl@0
   165
	TEST(err == KErrNone || err == KErrAlreadyExists);
sl@0
   166
	}
sl@0
   167
sl@0
   168
//Leaves with info message printed out
sl@0
   169
static void Leave(TInt aError, TInt aLine)
sl@0
   170
	{
sl@0
   171
	RDebug::Print(_L("*** Leave. Error: %d, Line: %d\r\n"), aError, aLine);
sl@0
   172
	User::Leave(aError);
sl@0
   173
	}
sl@0
   174
sl@0
   175
//Leaves if aError < 0 with info message printed out
sl@0
   176
static void LeaveIfError(TInt aError, TInt aLine)
sl@0
   177
	{
sl@0
   178
	if(aError < KErrNone)
sl@0
   179
		{
sl@0
   180
		::Leave(aError, aLine);
sl@0
   181
		}
sl@0
   182
	}
sl@0
   183
sl@0
   184
//Use LEAVE() macro instead of User::Leave() and LEAVE_IF_ERROR() macro instead of
sl@0
   185
//User::LeaveIfError(). They will print the line number, where the "leave" was called.
sl@0
   186
#define LEAVE(aError) ::Leave(aError, __LINE__)
sl@0
   187
#define LEAVE_IF_ERROR(aError) ::LeaveIfError(aError, __LINE__)
sl@0
   188
sl@0
   189
//Creates the test DBMS session
sl@0
   190
static void CreateTestDbSession()
sl@0
   191
	{
sl@0
   192
#ifndef __TOOLS2__
sl@0
   193
	RDebug::Print(_L("Create DBMS session\n"));
sl@0
   194
	TInt err = TheDbSession.Connect();
sl@0
   195
	TEST2(err, KErrNone);
sl@0
   196
#endif
sl@0
   197
	}
sl@0
   198
sl@0
   199
sl@0
   200
//Creates the test database
sl@0
   201
//TheDbSession instance has to be connected already.
sl@0
   202
//TheFs.Connect() has to be called already.
sl@0
   203
static void CreateTestDatabase(RDbs& aDbs, RDbNamedDatabase& aDb)
sl@0
   204
	{
sl@0
   205
	RDebug::Print(_L("Create test database\n"));
sl@0
   206
	TInt err = aDb.Replace(TheFs, KTestDatabase);
sl@0
   207
	TEST2(err, KErrNone);
sl@0
   208
	TheDb.Close();
sl@0
   209
	err = aDb.Open(aDbs, KTestDatabase);
sl@0
   210
	TEST2(err, KErrNone);
sl@0
   211
	}
sl@0
   212
sl@0
   213
//Creates test table
sl@0
   214
static void DoCreateTestTableL(RDbNamedDatabase& aDb, const TDesC& aTblName, const TColDef aColDefs[])
sl@0
   215
	{
sl@0
   216
	CDbColSet* colSet = CDbColSet::NewLC();
sl@0
   217
	for(const TColDef* colDef=aColDefs;colDef->iName;++colDef)
sl@0
   218
		{
sl@0
   219
		TDbCol col(TPtrC(colDef->iName), colDef->iType);
sl@0
   220
		col.iAttributes = colDef->iAttributes;
sl@0
   221
		colSet->AddL(col);
sl@0
   222
		}
sl@0
   223
	TEST2(aDb.CreateTable(aTblName, *colSet), KErrNone);
sl@0
   224
	CleanupStack::PopAndDestroy(colSet);
sl@0
   225
	}
sl@0
   226
sl@0
   227
//Creates test tables
sl@0
   228
static void CreateTestTablesL(RDbNamedDatabase& aDb)
sl@0
   229
	{
sl@0
   230
	RDebug::Print(_L("Create test tables\n"));
sl@0
   231
	::DoCreateTestTableL(aDb, KTestTableName1, KColDefs1);
sl@0
   232
	::DoCreateTestTableL(aDb, KTestTableName2, KColDefs2);
sl@0
   233
	}
sl@0
   234
sl@0
   235
//Gets the value of the string field, which type may be EDbColText16 or EDbColLongText16
sl@0
   236
void GetStrFieldValue(RDbRowSet& aTbl, const TDesC& aTblName, TDes& aStrFldVal)
sl@0
   237
	{
sl@0
   238
	if(aTblName.CompareF(KTestTableName1) == 0)
sl@0
   239
		{
sl@0
   240
		aStrFldVal = aTbl.ColDes16(1);
sl@0
   241
		}
sl@0
   242
	else
sl@0
   243
		{
sl@0
   244
		RDbColReadStream blob;
sl@0
   245
		blob.OpenLC(aTbl, 1);
sl@0
   246
		blob.ReadL(aStrFldVal, aTbl.ColLength(1));
sl@0
   247
		CleanupStack::PopAndDestroy();
sl@0
   248
		}
sl@0
   249
	}
sl@0
   250
sl@0
   251
//Prints all table records
sl@0
   252
static TInt PrintRecordsL(RDbRowSet& aTbl, const TDesC& aTblName)
sl@0
   253
	{
sl@0
   254
	RDebug::Print(_L("Table: %S\n"), &aTblName);
sl@0
   255
    aTbl.FirstL();
sl@0
   256
	TInt rec = 0;
sl@0
   257
    while(aTbl.AtRow())
sl@0
   258
        {
sl@0
   259
        aTbl.GetL();
sl@0
   260
		TNameBuf strFldVal;
sl@0
   261
		::GetStrFieldValue(aTbl, aTblName, strFldVal);
sl@0
   262
		TUint32 v = aTbl.ColUint32(2);
sl@0
   263
		RDebug::Print(_L("   Record %d, Str: %S, Val: %d\n"), ++rec, &strFldVal, v);
sl@0
   264
        aTbl.NextL(); 
sl@0
   265
        }
sl@0
   266
	return rec;
sl@0
   267
	}
sl@0
   268
sl@0
   269
//Checks if the records order (based on a string key field comparison) matches the order of the
sl@0
   270
//strings in aTestStrArray
sl@0
   271
static void AssertRecordsOrder(RDbRowSet& aTbl, const TDesC& aTblName, const RArray<TNameBuf>& aTestStrArray)
sl@0
   272
	{
sl@0
   273
    aTbl.FirstL();
sl@0
   274
	TInt rec = 0;
sl@0
   275
    while(aTbl.AtRow())
sl@0
   276
        {
sl@0
   277
        aTbl.GetL();
sl@0
   278
		TNameBuf strFldVal;
sl@0
   279
		::GetStrFieldValue(aTbl, aTblName, strFldVal);
sl@0
   280
		TEST(aTestStrArray[rec] == strFldVal);
sl@0
   281
		++rec;
sl@0
   282
        aTbl.NextL(); 
sl@0
   283
        }
sl@0
   284
	}
sl@0
   285
sl@0
   286
//Adds test data to the specified table. Make sure that the records are not in
sl@0
   287
//order (assuming that the first field will be the key).
sl@0
   288
static void AddTestDataL(RDbNamedDatabase& aDb, const TDesC& aTblName)
sl@0
   289
	{
sl@0
   290
	RDbTable tbl;
sl@0
   291
	CleanupClosePushL(tbl);
sl@0
   292
	TEST2(tbl.Open(aDb, aTblName, RDbRowSet::EUpdatable), KErrNone);
sl@0
   293
	for(TInt i=0;i<KTestStrCnt;++i)
sl@0
   294
		{
sl@0
   295
		tbl.InsertL();
sl@0
   296
		tbl.SetColL(1, KTestStr[KTestStrCnt - i - 1]);
sl@0
   297
		tbl.SetColL(2, i + 1);
sl@0
   298
		tbl.PutL();
sl@0
   299
		}
sl@0
   300
	TEST(tbl.CountL() == KTestStrCnt);
sl@0
   301
	(void)::PrintRecordsL(tbl, aTblName);
sl@0
   302
	CleanupStack::PopAndDestroy(&tbl);
sl@0
   303
	}
sl@0
   304
sl@0
   305
//Adds the test data to test tables
sl@0
   306
static void AddTestDataL(RDbNamedDatabase& aDb)
sl@0
   307
	{
sl@0
   308
	RDebug::Print(_L("Add data to test tables\n"));
sl@0
   309
	::AddTestDataL(aDb, KTestTableName1);
sl@0
   310
	::AddTestDataL(aDb, KTestTableName2);
sl@0
   311
	}
sl@0
   312
sl@0
   313
//Init test environment
sl@0
   314
static void InitEnvL()
sl@0
   315
	{
sl@0
   316
	::CreateTestDbSession();
sl@0
   317
    //Create test database and tables. Add some test data to them.
sl@0
   318
	::CreateTestDatabase(TheDbSession, TheDb);
sl@0
   319
	::CreateTestTablesL(TheDb);
sl@0
   320
	::AddTestDataL(TheDb);
sl@0
   321
	}
sl@0
   322
sl@0
   323
//String comparison function, used in FillStrArraySorted() function.
sl@0
   324
static TInt CompareC(const TNameBuf& aName1, const TNameBuf& aName2)
sl@0
   325
    {
sl@0
   326
    return aName1.CompareC(aName2);
sl@0
   327
    }
sl@0
   328
sl@0
   329
//Inserts all test string into an ordered array - aTestStrArray
sl@0
   330
static void FillStrArraySortedL(RArray<TNameBuf>& aTestStrArray)
sl@0
   331
	{
sl@0
   332
	for(TInt i=0;i<KTestStrCnt;++i)
sl@0
   333
		{
sl@0
   334
    	User::LeaveIfError(aTestStrArray.InsertInOrder(KTestStr[i], TLinearOrder<TNameBuf>(CompareC)));
sl@0
   335
		}
sl@0
   336
	}
sl@0
   337
sl@0
   338
static void CreateIndexL(RDbNamedDatabase& aDb, const TDesC& aTblName, const TDesC& aColumnName)
sl@0
   339
	{
sl@0
   340
	RDebug::Print(_L("Create index. Table: %S, column: %S\n"), &aTblName, &aColumnName);
sl@0
   341
	CDbKey* key = CDbKey::NewLC();
sl@0
   342
	key->AddL(aColumnName);
sl@0
   343
	key->MakeUnique();
sl@0
   344
	key->SetComparison(EDbCompareCollated);
sl@0
   345
	LEAVE_IF_ERROR(aDb.CreateIndex(aColumnName, aTblName, *key));
sl@0
   346
	CleanupStack::PopAndDestroy(key);
sl@0
   347
	}
sl@0
   348
sl@0
   349
///////////////////////////////////////////////////////////////////////////////////////
sl@0
   350
///////////////////////////////////////////////////////////////////////////////////////
sl@0
   351
//Test cases
sl@0
   352
sl@0
   353
//Test case 1. Check SELECT statement with ORDER BY clause when the key field is a string.
sl@0
   354
static void OrderByTestL(RDbNamedDatabase& aDb, const TDesC& aTblName, const RArray<TNameBuf>& aTestStrArray)
sl@0
   355
	{
sl@0
   356
    RDbView view;
sl@0
   357
    CleanupClosePushL(view);
sl@0
   358
    
sl@0
   359
    TBuf<128> sqlStmt;
sl@0
   360
    sqlStmt.Append(_L("SELECT ID, DATA FROM "));
sl@0
   361
    sqlStmt.Append(aTblName);
sl@0
   362
    sqlStmt.Append(_L(" ORDER BY ID"));
sl@0
   363
    User::LeaveIfError(view.Prepare(aDb, TDbQuery(sqlStmt, EDbCompareCollated), TDbWindow::EUnlimited));
sl@0
   364
    User::LeaveIfError(view.EvaluateAll());
sl@0
   365
sl@0
   366
	(void)::PrintRecordsL(view, aTblName);
sl@0
   367
	::AssertRecordsOrder(view, aTblName, aTestStrArray);
sl@0
   368
sl@0
   369
    CleanupStack::PopAndDestroy(&view);
sl@0
   370
	}
sl@0
   371
sl@0
   372
//Test case 2. Check SELECT statement with LIKE keyword when the key field is a string.
sl@0
   373
static void LikeTestL(RDbNamedDatabase& aDb, const TDesC& aTblName)
sl@0
   374
	{
sl@0
   375
    RDbView view;
sl@0
   376
    CleanupClosePushL(view);
sl@0
   377
    
sl@0
   378
    TBuf<128> sqlStmt;
sl@0
   379
    sqlStmt.Append(_L("SELECT ID, DATA FROM "));
sl@0
   380
    sqlStmt.Append(aTblName);
sl@0
   381
    sqlStmt.Append(_L(" WHERE ID LIKE 'B*'"));
sl@0
   382
    User::LeaveIfError(view.Prepare(aDb, TDbQuery(sqlStmt, EDbCompareCollated), TDbWindow::EUnlimited));
sl@0
   383
    User::LeaveIfError(view.EvaluateAll());
sl@0
   384
sl@0
   385
	TInt cnt = ::PrintRecordsL(view, aTblName);
sl@0
   386
	TEST(cnt == 2);
sl@0
   387
sl@0
   388
    CleanupStack::PopAndDestroy(&view);
sl@0
   389
	}
sl@0
   390
sl@0
   391
//Test case 3. Check SELECT statement with LIKE & ORDER BY keywords when the key field is a string.
sl@0
   392
static void LikeOrderTestL(RDbNamedDatabase& aDb, const TDesC& aTblName, const RArray<TNameBuf>& aTestStrArray)
sl@0
   393
	{
sl@0
   394
    RDbView view;
sl@0
   395
    CleanupClosePushL(view);
sl@0
   396
    
sl@0
   397
    TBuf<128> sqlStmt;
sl@0
   398
    sqlStmt.Append(_L("SELECT ID, DATA FROM "));
sl@0
   399
    sqlStmt.Append(aTblName);
sl@0
   400
    sqlStmt.Append(_L(" WHERE ID LIKE 'B*' ORDER BY ID"));
sl@0
   401
    User::LeaveIfError(view.Prepare(aDb, TDbQuery(sqlStmt, EDbCompareCollated), TDbWindow::EUnlimited));
sl@0
   402
    User::LeaveIfError(view.EvaluateAll());
sl@0
   403
sl@0
   404
	TInt cnt = ::PrintRecordsL(view, aTblName);
sl@0
   405
	TEST(cnt == 2);
sl@0
   406
	::AssertRecordsOrder(view, aTblName, aTestStrArray);
sl@0
   407
sl@0
   408
    CleanupStack::PopAndDestroy(&view);
sl@0
   409
	}
sl@0
   410
sl@0
   411
//Test case 4. Indexed table. The index is a string field.
sl@0
   412
static void IndexTestL(RDbNamedDatabase& aDb, const TDesC& aTblName, const RArray<TNameBuf>& aTestStrArray)
sl@0
   413
	{
sl@0
   414
	_LIT(KIdxName, "ID");
sl@0
   415
	::CreateIndexL(aDb, aTblName, KIdxName);
sl@0
   416
	
sl@0
   417
	RDbTable tbl;
sl@0
   418
	CleanupClosePushL(tbl);
sl@0
   419
	TEST2(tbl.Open(aDb, aTblName, RDbRowSet::EReadOnly), KErrNone);
sl@0
   420
	TEST2(tbl.SetIndex(KIdxName), KErrNone);
sl@0
   421
sl@0
   422
	(void)::PrintRecordsL(tbl, aTblName);
sl@0
   423
	::AssertRecordsOrder(tbl, aTblName, aTestStrArray);
sl@0
   424
sl@0
   425
    CleanupStack::PopAndDestroy(&tbl);
sl@0
   426
	}
sl@0
   427
sl@0
   428
///////////////////////////////////////////////////////////////////////////////////////
sl@0
   429
///////////////////////////////////////////////////////////////////////////////////////
sl@0
   430
//The main test function.
sl@0
   431
//Call your new test functions from here
sl@0
   432
static void RunTestsL()
sl@0
   433
	{
sl@0
   434
	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-LEGACY-DBMSSTRCOMP-0001 Init test environment "));
sl@0
   435
	::InitEnvL();
sl@0
   436
sl@0
   437
    RArray<TNameBuf> testStrArray;
sl@0
   438
    CleanupClosePushL(testStrArray);
sl@0
   439
	::FillStrArraySortedL(testStrArray);
sl@0
   440
sl@0
   441
	TheTest.Next(_L("SELECT, ORDER BY, EDbColText16"));
sl@0
   442
	::OrderByTestL(TheDb, KTestTableName1, testStrArray);
sl@0
   443
sl@0
   444
	TheTest.Next(_L("SELECT, ORDER BY, EDbColLongText16"));
sl@0
   445
	::OrderByTestL(TheDb, KTestTableName2, testStrArray);
sl@0
   446
	
sl@0
   447
	TheTest.Next(_L("SELECT, LIKE, EDbColText16"));
sl@0
   448
	::LikeTestL(TheDb, KTestTableName1);
sl@0
   449
sl@0
   450
	TheTest.Next(_L("SELECT, LIKE, EDbColLongText16"));
sl@0
   451
	::LikeTestL(TheDb, KTestTableName2);
sl@0
   452
	
sl@0
   453
    RArray<TNameBuf> testStrArray2;
sl@0
   454
    CleanupClosePushL(testStrArray2);
sl@0
   455
    testStrArray2.AppendL(testStrArray[2]);//"bbB"
sl@0
   456
    testStrArray2.AppendL(testStrArray[3]);//"BbB"
sl@0
   457
sl@0
   458
	TheTest.Next(_L("SELECT, LIKE, ORDER BY, EDbColText16"));
sl@0
   459
	::LikeOrderTestL(TheDb, KTestTableName1, testStrArray2);
sl@0
   460
sl@0
   461
	TheTest.Next(_L("SELECT, LIKE, ORDER BY, EDbColLongText16"));
sl@0
   462
	::LikeOrderTestL(TheDb, KTestTableName2, testStrArray2);
sl@0
   463
	
sl@0
   464
	TheTest.Next(_L("Index, EDbColText16"));
sl@0
   465
	::IndexTestL(TheDb, KTestTableName1, testStrArray);
sl@0
   466
sl@0
   467
// Not possible to create a key with EDbColLongText16
sl@0
   468
//	TheTest.Next(_L("Index, EDbColLongText16"));
sl@0
   469
//	::IndexTestL(TheDb, KTestTableName2, testStrArray);
sl@0
   470
	
sl@0
   471
	//Add tests here!
sl@0
   472
	
sl@0
   473
    CleanupStack::PopAndDestroy(&testStrArray2);
sl@0
   474
    CleanupStack::PopAndDestroy(&testStrArray);
sl@0
   475
	}
sl@0
   476
sl@0
   477
TInt E32Main()
sl@0
   478
	{
sl@0
   479
	TheTest.Title();
sl@0
   480
sl@0
   481
	__UHEAP_MARK;
sl@0
   482
sl@0
   483
	CTrapCleanup* trapCleanup = CTrapCleanup::New();
sl@0
   484
	TEST(trapCleanup != NULL);
sl@0
   485
sl@0
   486
	TInt err = TheFs.Connect();
sl@0
   487
	TEST2(err, KErrNone);
sl@0
   488
	::SetupTestDirectory();
sl@0
   489
sl@0
   490
	::DeleteDataFile(KTestDatabase);
sl@0
   491
sl@0
   492
	TRAP(err, ::RunTestsL());
sl@0
   493
	TheDb.Close();
sl@0
   494
#ifndef __TOOLS2__
sl@0
   495
	TheDbSession.Close();
sl@0
   496
#endif
sl@0
   497
	TheFs.Close();
sl@0
   498
	TEST2(err, KErrNone);
sl@0
   499
sl@0
   500
#ifndef __linux__
sl@0
   501
	TRAP(err, TheCrcChecker.GenerateCrcL(KTestDatabase));
sl@0
   502
	TEST(err==KErrNone);
sl@0
   503
#ifndef __TOOLS2__
sl@0
   504
	TRAPD(lc, err = TheCrcChecker.DumpCrcRecordsL(KCrcRecord));
sl@0
   505
	TEST(err==KErrNone);
sl@0
   506
	TEST(lc==KErrNone);
sl@0
   507
#else
sl@0
   508
	TRAPD(lc, err = TheCrcChecker.ValidateCrcRecordsL(KCrcRecord));
sl@0
   509
	TPtrC errmsg;
sl@0
   510
	TheCrcChecker.ErrorReportL(err, errmsg);
sl@0
   511
	RDebug::Print(errmsg);
sl@0
   512
	TheTest(err==KErrNone || err==TDBMS_CRCChecks::ECrcCheckOk);
sl@0
   513
#endif
sl@0
   514
#endif
sl@0
   515
sl@0
   516
	::DeleteDataFile(KTestDatabase);
sl@0
   517
sl@0
   518
	TheTest.Printf(_L("Wait DBMS server shutdown...\n"));
sl@0
   519
	User::After(KExitDelay);
sl@0
   520
sl@0
   521
	TheTest.End();
sl@0
   522
	TheTest.Close();
sl@0
   523
sl@0
   524
	delete trapCleanup;
sl@0
   525
sl@0
   526
	__UHEAP_MARKEND;
sl@0
   527
sl@0
   528
	return 0;
sl@0
   529
	}
sl@0
   530
sl@0
   531