// Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // which accompanies this distribution, and is available

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

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include "cdtest.h"

 #include "hashing.h"

 #include "common.h"

 #include<bautils.h>

 //Constants taken from SqlSrvConfig.h

 #ifdef __WINSCW__

 		const TInt KDefaultSoftHeapLimitKb = 1024;

 #else

 		const TInt KDefaultSoftHeapLimitKb = 8192;

 #endif	

 // Includes any code required for 'Code-Driven' testing, generally tests

 // that cannot be data-driven (or not completely).

 CSQLCDT::~CSQLCDT()

     {

     }

 CSQLCDT::CSQLCDT()

     {

     SetTestStepName(KSQLCDT);

     }

 // Look at 'arg' and call whichever function is required.

 void CSQLCDT::ResolveTestFunctionL(const TDesC &acfgblk, const TInt acnnum,

                                   const TPtrC &arg )

     {

     _LIT(KTestFunction, "cdtest::ResolveTestFunction");

     INFO_PRINTF3(_L("In %S, arg is %S"), &KTestFunction, &arg);

     if(arg == _L("WriteBigTable"))

         WriteBigTableL(acfgblk, acnnum);

     else if(arg == _L("ReadBigTable"))

         ReadBigTableL(acfgblk);

     // This assumes that a ParameterIndex and ColumnIndex call has been

     // set up previously - the apidxs/apicxs array access below will

     // certainly PANIC if you haven't done the require preparation..

     else if(arg == _L("CopyCellsUsingStreams"))

         CopyCellsUsingStreamsL(acfgblk);

     else if(arg == _L("WriteIntsToStream"))

         WriteIntsToStream(acfgblk, acnnum);

     else if(arg == _L("NearFillDisk"))

         NearFillDisk(acfgblk);

     else if(arg == _L("ScalarFullSelect"))

         ScalarFullSelectL(acfgblk, acnnum);

     else if(arg == _L("FilesDifferBySize"))

         FilesDifferBySize(acfgblk, acnnum);

     else if(arg == _L("SecurityPolicyCheck"))

         SecurityPolicyCheck(acfgblk, acnnum);

     else if(arg == _L("CollationTest"))

         CollationTest(acfgblk, acnnum);

     else User::Panic(_L("Unknown Function"), 42);

     }

 // ------------------------------------------------------------------------ 

 //

 // There's some hardwired nastiness in here - which we might be able to remove

 // if we can restructure the code (with the parameter index array as a

 // member variable in sqlfn), but until we can get reporting (INFO_PRINTF etc)

 // working in new objects that isn't going to happen.

 // There should have been a 

 // 'Insert into t(what, ever, whatever) values (:FInt, :FReal, :FText)'

 // ... before this is called. Those on the right are the nasty hardwiring,

 // and should correspond to integer, real, and text fields.

 void CSQLCDT::WriteBigTableL(const TDesC &acfgblk, TInt acnnum )

     {

     _LIT(KTestFunction, "WriteBigTable");

     // Parameters for the loop.

     TInt low=1, high=10, step=1, experr = KErrNone;

     TReal mult; TPtrC text, experrS;

     FromConfig(KTestFunction, acfgblk, _L("LowCount"), low);

     FromConfig(KTestFunction, acfgblk, _L("HighCount"), high);

     FromConfig(KTestFunction, acfgblk, _L("CountStep"), step);

     FromConfig(KTestFunction, acfgblk, _L("Multiplier"), mult);

     FromConfig(KTestFunction, acfgblk, _L("Text"), text);

     if( FromConfig(KTestFunction, acfgblk, _L("EventuallyExpectedError"), experrS) )

         experr = ErrStringToEnum(experrS);

     // First work out if out text is actually a filename..

     TInt textfromfile=0;

     textfromfile = BaflUtils::FileExists(irfs, text);

     // Ahoy! Nasty hardwiring ahead!

     TInt pidxi = ParamIndex(_L(":FInt"), acfgblk, 0 );

     TInt pidxr = ParamIndex(_L(":FReal"), acfgblk, 0 );

     TInt pidxt = ParamIndex(_L(":FText"), acfgblk, 0 );

     TInt i;

     for(i=low ; i<=high ; i+=step)

         {

         TInt err=KErrNone;

         // Can use a stream write for speed to write the text to the disk. Don't

         // make the file too big or a memory error (server side) will result.

         if(textfromfile)

             SWBindTextL(pidxt, text, acfgblk, acnnum);

         else

             {

             err = isqlst.BindText(pidxt, text);

             ReportOnError( KTestFunction, _L("BindText"), acfgblk, acnnum, err );

             }

         TReal tr = i * mult;

         err = isqlst.BindInt(pidxi, i);

         ReportOnError( KTestFunction, _L("BindInt"), acfgblk, acnnum, err );

         err = isqlst.BindReal(pidxr, tr);

         ReportOnError( KTestFunction, _L("BindReal"), acfgblk, acnnum, err);

         err = isqlst.Exec();

         if((err != KErrNone) && (err == experr))

             {

             INFO_PRINTF1(HTML_GREEN);

             INFO_PRINTF3(_L("Loop dropped out with expected error %S, i=%d"), &experrS, i );

             INFO_PRINTF1(HTML_COLOUR_OFF);

             break;

             }

         else if(err < 0)  // <0 a real error we weren't expecting.

             {

             ReportOnError( KTestFunction, _L("Exec"), acfgblk, acnnum, err );

             INFO_PRINTF3(_L("%S: counter i is %d"), &KTestFunction, i );

             break;

             }

         err = isqlst.Reset();

         ReportOnError( KTestFunction, _L("Reset"), acfgblk, acnnum, err );

         acnnum++;

         }

     isqlst.Close();

     return;

     }

 void CSQLCDT::ReadBigTableL(const TDesC &acfgblk)

     {

     _LIT(KTestFunction, "ReadBigTable");

     // Parameters for the loop.

     TInt low=1, high=10, step=1, err;

     TReal mult; TPtrC text;

     FromConfig(KTestFunction, acfgblk, _L("LowCount"), low);

     FromConfig(KTestFunction, acfgblk, _L("HighCount"), high);

     FromConfig(KTestFunction, acfgblk, _L("CountStep"), step);

     FromConfig(KTestFunction, acfgblk, _L("Multiplier"), mult);

     FromConfig(KTestFunction, acfgblk, _L("Text"), text);

     // First work out if out text is actually a filename..

     TInt textfromfile=0;

     textfromfile = BaflUtils::FileExists(irfs, text);

     // Ahoy! Nasty hardwiring ahead!

     TInt cidxi = ColumnIndex(_L("Someint"), acfgblk, 0 );

     TInt cidxr = ColumnIndex(_L("Somereal"), acfgblk, 0 );

     TInt cidxt = ColumnIndex(_L("Sometext"), acfgblk, 0 );

     for(TInt i=low ; i<=high ; i+=step)

         {

         TReal tr = i * mult;

 // INFO_PRINTF3(_L("CFGBLK: %S        COUNT: %d"), &acfgblk, i);

         TInt cint = isqlst.ColumnInt(cidxi);

         TReal creal = isqlst.ColumnReal(cidxr);

         if((cint != i) || (creal != tr))

             {

             SetTestStepResult(EFail);

             INFO_PRINTF1(HTML_RED);

             ERR_PRINTF4(_L("%S: ColumnInt gave %d, wanted %d"),

                            &KTestFunction, cint, i );

             ERR_PRINTF4(_L("%S: ColumnReal gave %f, wanted %f"),

                            &KTestFunction, creal, tr );

             INFO_PRINTF1(HTML_COLOUR_OFF);

             break;

             }

         // Now check the text..

         if(textfromfile)

             SRColumnTextL(cidxt, text, acfgblk, -1 );

         else

             ColumnTextL(cidxt, text, acfgblk, -1 );

         if(isqlst.Next()==KSqlAtEnd)

             {

             // This expected error was for *writing* the table - we don't

             // get an error reading it back, just KSqlAtEnd. But lets assume

             // that an expected error on write implies a short table and

             // so no failure if we get KSqlAtEnd early.

             INFO_PRINTF1(HTML_GREEN);

             INFO_PRINTF3(_L("%S: Next gave KSqlAtEnd, i is %d"),

                                                    &KTestFunction, i );

             INFO_PRINTF1(HTML_COLOUR_OFF);

             break;

             }

         }

     if( (err = isqlst.Next()) != KSqlErrMisuse )

         {

         SetTestStepResult(EFail);

         INFO_PRINTF1(HTML_RED);

         ERR_PRINTF3(_L("%S: Next gave %d, is there some table left? Expected KSqlErrMisuse"), &KTestFunction, err );

         INFO_PRINTF1(HTML_COLOUR_OFF);

         }

     return;

     }

 // Copy a single cell in a table using streams. We'll use the BindBinary

 // and ColumnBinary methods of RSqlParamWriteStream and RSqlColumnReadStream

 // respectively. Don't try to copy integers or reals, as the API spec

 // says very clearly in a table, converting most of these to Binary

 // gives KNullDesc8.

 void CSQLCDT::CopyCellsUsingStreamsL(const TDesC &acfgblk) 

     {

     _LIT(KTestFunction, "CopyCellUsingStreams");

     // We only have one RSqlStatement around, and we must have two - a

     // source and destination, so lets get another one - we'll write to

     // this.

     RSqlStatement sqlst2;

     // The prepare statement used to add to the second table.

     TPtrC prep;

     FromConfig(KTestFunction, acfgblk, _L("PrepareStatement"), prep);

     // The parameter name (e.g :freddy) in the above.

     TPtrC paramname;

     FromConfig(KTestFunction, acfgblk, _L("ParamName"), paramname);

     // Prepare and get pidx.

     TInt err = sqlst2.Prepare(isqldb, prep);

     TInt pidx = sqlst2.ParameterIndex(paramname);

     // Whilst we're reading 

     while(isqlst.Next() == KSqlAtRow)

         {

         // First lets find a cell to copy. This assumes there is a single

         // column selected..

         // Set up where we're reading from. ColumnIndex will be zero.

         // Obviously a prepare must already have been done.

         RSqlColumnReadStream sqlr;

         err = sqlr.ColumnText(isqlst, 0);

         // Read a cell from the database as a stream. Pass that stream to

         // another stream, an RSqlParamWriteStream to copy the cell into

         // another db.

         // Get our writable stream..

         RSqlParamWriteStream sqlw;

         // Set up where we're writing to.

         err = sqlw.BindText(sqlst2, pidx);

         // Write.

         sqlw.WriteL(sqlr);

         sqlw.Close();

         err = sqlst2.Exec();

         err = sqlst2.Reset();

         }

     sqlst2.Close();

     return;

     }

 // Write to 32-bit signed integers to a stream (a cell in a table) until

 // the write operation Leaves with a KErrNoMem. A 'prepare' statement

 // must already have been run, and a parameterindex also. We assume

 // that the parameterindex is zero.

 // If the user wants to do an Exec and Reset, that's up to them. That

 // would end up sticking a NULL into the current cell though.

 void CSQLCDT::WriteIntsToStream(const TDesC &acfgblk, const TInt acnnum)

     {

     _LIT(KTestFunction, "WriteIntsToStream");

     // Get our writable stream..

     RSqlParamWriteStream sqlw;

     // Find out how many integers to write..

     TInt count;

     FromConfig(KTestFunction, acfgblk, _L("Count"), count);

     if(count == -1) count = 2000000000;

     // Assume only one 'ParameterIndex' has been run..

     sqlw.BindBinary(isqlst,0);

     TInt i, leavecode;

     for(i=0 ; i<count ; i++)

         {

         // A fast way to send a lot of data down a stream..

         TRAP(leavecode, sqlw.WriteInt32L(i));

         if(leavecode != KErrNone) break;

         }

     // Close the stream immediately. If we've run out of memory (a common test)

     // this will free it up and allow (e.g) LogEngine to function so we get

     // proper error reports.

     sqlw.Close();

     ReportOnError( KTestFunction, _L("Stream Write"), acfgblk, acnnum, leavecode );

     INFO_PRINTF3(_L("%S bound %d integers"), &KTestFunction, i );

     return;

     }

 //This function is needed for drives with more free space than KMaxTUint32 (4GB -1) 

 //This is because in a FAT32 file system, the maximum file size is (4GB-1)

 //In the case where the free space is larger than this limit, this function will create additional 

 //file(s)until the disk is under the (4GB-1) limit. After that CSQLCDT::NearFillDisk will fill the 

 //disk up to the required amount.

 void CSQLCDT::PrepareLargeDisk(const TDesC& /*acfgblk*/, const TDriveUnit atdu, TInt64 &atowrite)

     {

     _LIT(KTestFunction, "PrepareLargeDisk");

     _LIT(KFillDiskName,"\\FillDisk");

     _LIT(KFillDiskExt,".txt");

     TFileName fname;

     TInt count = 1;

     TInt err = 0;

     while(atowrite > KMaxTUint32)

         {

         RFile64 fillDiskFile;

         fname.Copy(atdu.Name());

         fname.Append(KFillDiskName);

         fname.AppendNum(count);

         fname.Append(KFillDiskExt);

         if( (err = fillDiskFile.Create(irfs, fname, EFileWrite)) != KErrNone )

             {

             SetTestStepResult(EFail);

             INFO_PRINTF1(HTML_RED);

             ERR_PRINTF4(_L("%S: Failed to open RFile64 for file %S, err %d"),

                                &KTestFunction, &fname, err );

             INFO_PRINTF1(HTML_COLOUR_OFF);

             return;

             }

         if( (err = fillDiskFile.SetSize(KMaxTUint32)) != KErrNone )

             {

             SetTestStepResult(EFail);

             INFO_PRINTF1(HTML_RED);

             ERR_PRINTF4(_L("%S: Failed on RFile64::SetSize for file %S, err %d"),

                                &KTestFunction, &fname, err );

             INFO_PRINTF1(HTML_COLOUR_OFF);

             fillDiskFile.Close();

             return;

             }

         fillDiskFile.Close();

         atowrite-=KMaxTUint32;

         count++;

         }

     }

 // Create a file specified by 'FillFile' in the config and write to

 // it until 'DiskFree' bytes remain. Note that because files use whole

 // sectors (512/1024/2048/4096 or whatever bytes), that attempting to leave

 // (e.g) 1023 bytes could result in 512 bytes remaining on a file system

 // with 512 byte sectors, or zero bytes remaining if the sectors are bigger.

 void CSQLCDT::NearFillDisk(const TDesC &acfgblk)

     {

     _LIT(KTestFunction, "NearFillDisk");

     // What file should we use? Requires a full path.

     TPtrC fillfile;

     (void)FromConfig(KTestFunction, acfgblk, _L("FillFile"), fillfile);

     irfs.Delete(fillfile);

     // Get the drive number. This method ignores trailing text.

     // Probably wants upper case.

     TDriveUnit tdu(fillfile);

     // Find out how much disk we want left.. 

     TInt free, err;

     (void)FromConfig(KTestFunction, acfgblk, _L("DiskFree"), free);

     // Find out how much disk space currently remains..

     TVolumeInfo vol;

     if((err = irfs.Volume(vol, tdu )) != KErrNone)

         {

         SetTestStepResult(EFail);

         INFO_PRINTF1(HTML_RED);

         ERR_PRINTF4(_L("%S: Failed to get volume info for %S, err %d"),

                            &KTestFunction, &fillfile, err );

         INFO_PRINTF1(HTML_COLOUR_OFF);

         return;

         }

     // So how many bytes do we need to write?

     TInt64 towrite = vol.iFree - free;

     INFO_PRINTF4(_L("%S: Disk writing %Ld, free %Ld"), &KTestFunction, 

                     towrite, vol.iFree );

     INFO_PRINTF3(_L("%S: free %Ld"), &KTestFunction, vol.iFree );

     INFO_PRINTF3(_L("%S: writing %Ld"), &KTestFunction, towrite );

     if( towrite < 0 )

         {

         SetTestStepResult(EFail);

         INFO_PRINTF1(HTML_RED);

         ERR_PRINTF3(_L("%S: Disk wanted remaining less than current(%Ld)"),

                            &KTestFunction, vol.iFree );

         INFO_PRINTF1(HTML_COLOUR_OFF);

         return;

         }

     //In case the disk is large (i.e >4G -1 bytes) we need another function to 

     //create more files to fill it

     PrepareLargeDisk(acfgblk, tdu, towrite);

     // Get a file.

     RFile64 myfile;

     if( (err = myfile.Create(irfs, fillfile, EFileWrite)) != KErrNone )

         {

         SetTestStepResult(EFail);

         INFO_PRINTF1(HTML_RED);

         ERR_PRINTF4(_L("%S: Failed to open RFile64 for file %S, err %d"),

                            &KTestFunction, &fillfile, err );

         INFO_PRINTF1(HTML_COLOUR_OFF);

         return;

         }

     // Write it.

     // We seem to hit trouble if we just try to write 'towrite' bytes, so

     // here we write 50% of them and check the remainder repeatedly until

     // the right amount remains. Actually it is unlikely to be exactly the

     // right amount - depending on sector sizes and other factors the

     // remaining space tends to be a kilobyte or two less than requested.

     // Obviously this is likely to be different between file system types,

     // between hardware and emulator and so on.

     TInt64 size = 0;

     while(towrite > 0)

         {

         if(towrite < 1024) break;

         TInt64 tow = towrite/2;

         if(towrite < 4096) tow = towrite;

 		size += tow;

         if( (err = myfile.SetSize(size)) != KErrNone )

             {

             SetTestStepResult(EFail);

             INFO_PRINTF1(HTML_RED);

             ERR_PRINTF4(_L("%S: Failed on RFile64::SetSize for file %S, err %d"),

                                &KTestFunction, &fillfile, err );

             INFO_PRINTF1(HTML_COLOUR_OFF);

 			break;

             }

         err = irfs.Volume(vol, tdu );

         if(err != KErrNone)

         	{

             SetTestStepResult(EFail);

             INFO_PRINTF1(HTML_RED);

             ERR_PRINTF3(_L("%S: 2-RFs::Volume() has failed, err=%d"),

                                &KTestFunction, err);

             INFO_PRINTF1(HTML_COLOUR_OFF);

             break;

         	}

         towrite = vol.iFree - free;

         }

     err = irfs.Volume(vol, tdu );

     if(err != KErrNone)

     	{

         SetTestStepResult(EFail);

         INFO_PRINTF1(HTML_RED);

         ERR_PRINTF3(_L("%S: 3-RFs::Volume() has failed, err=%d"),

                            &KTestFunction, err);

         INFO_PRINTF1(HTML_COLOUR_OFF);

     	}

     INFO_PRINTF3(_L("%S: Disk remaining is %Ld"), &KTestFunction, vol.iFree );

 	myfile.Close();

     return;

     }

 // This method exercises the TSqlScalarFullSelectQuery class, which is

 // just a wrapper. Its methods expect a select statement whose result will

 // be a single cell. Perhaps this should be in sqlfn.cpp.

 void CSQLCDT::ScalarFullSelectL(const TDesC &acfgblk, const TInt acnnum)

     {

     _LIT(KTestFunction, "ScalarFullSelect");

     // Look for an integer called 'Use_SetNN'.

     TInt useset;

     TBuf<KConfigItemMaxNameLength> conS(_L("Use_Set"));

     conS.AppendNum(acnnum);

     FromConfig(KTestFunction, acfgblk, conS, useset);

     // Look for a string called 'MethodNN'.

     TPtrC meth;

     TBuf<KConfigItemMaxNameLength> methS(_L("Method"));

     methS.AppendNum(acnnum);

     FromConfig(KTestFunction, acfgblk, methS, meth);

     // Look for a string called 'StatementNN'.

     TPtrC stmt;

     TBuf<KConfigItemMaxNameLength> stmtS(_L("Statement"));

     stmtS.AppendNum(acnnum);

     FromConfig(KTestFunction, acfgblk, stmtS, stmt);

     // Convert the SQL statement to an UTF-8 version.

     RBuf8 stmt8;

     stmt8.Create(stmt.Length());

     stmt8.Copy(stmt);

     CleanupClosePushL(stmt8);

     // Look for a string called 'ResultNN'.

     TPtrC res;

     TBuf<KConfigItemMaxNameLength> resS(_L("Result"));

     resS.AppendNum(acnnum);

     FromConfig(KTestFunction, acfgblk, resS, res);

     // We may want to convert the expected result to a real or int or something

     TLex conv = res;

     // Ok, now create a TSqlScalarFullSelectQuery object.

     TSqlScalarFullSelectQuery *asfs;

     TSqlScalarFullSelectQuery one(isqldb);

     TSqlScalarFullSelectQuery two;

     two.SetDatabase(isqldb);

     // Use one of the above objects.

     asfs = useset ? &two : &one;

     // Get the action hash for this..

     CSQLSFSTEFAction *cs = new CSQLSFSTEFAction();

     TInt action = cs->GetNumFromString(meth);

     switch(action)

         {

         case CSQLSFSTEFAction::ESFS_SelectIntL:

             {

             TInt actual;

             if(i8bit)

                 actual = asfs->SelectIntL(stmt8);

             else

                 actual = asfs->SelectIntL(stmt);

             TInt expected;

 			if (res.CompareF(_L("DEFAULT_SOFT_HEAP_LIMIT")) == 0)

 				{

 				expected = KDefaultSoftHeapLimitKb;

 				}

 			else

 				{

 				conv.Val(expected);

 				}

             if( actual != expected )

                 {

                 SetTestStepResult(EFail);

                 INFO_PRINTF1(HTML_RED);

                 ERR_PRINTF4(_L("%S: SelectIntL gave %d, wanted %d"),

                        &KTestFunction, actual,  expected);

                 INFO_PRINTF1(HTML_COLOUR_OFF);

                 }

             else

                 {

                 INFO_PRINTF1(HTML_GREEN);

                 INFO_PRINTF3(_L("%S: SelectIntL gave %d, as expected"),

                        &KTestFunction, actual);

                 INFO_PRINTF1(HTML_COLOUR_OFF);

                 }

             }

             break;

         case CSQLSFSTEFAction::ESFS_SelectInt64L:

             {

             TInt64 actual;

             if(i8bit)

                 actual = asfs->SelectInt64L(stmt8);

             else

                 actual = asfs->SelectInt64L(stmt);

             TInt64 expected;

             conv.Val(expected);

             if( actual != expected )

                 {

                 SetTestStepResult(EFail);

                 INFO_PRINTF1(HTML_RED);

                 ERR_PRINTF4(_L("%S: SelectInt64L gave %d, wanted %d"),

                        &KTestFunction, actual,  expected);

                 INFO_PRINTF1(HTML_COLOUR_OFF);

                 }

             else

                 {

                 INFO_PRINTF1(HTML_GREEN);

                 INFO_PRINTF3(_L("%S: SelectInt64L gave %d, as expected"),

                        &KTestFunction, actual);

                 INFO_PRINTF1(HTML_COLOUR_OFF);

                 }

             }

             break;

         case CSQLSFSTEFAction::ESFS_SelectRealL:

             {

             TReal actual;

             if(i8bit)

                 actual = asfs->SelectRealL(stmt8);

             else

                 actual = asfs->SelectRealL(stmt);

             TReal expected;

             conv.Val(expected);

             if( actual != expected )

                 {

                 SetTestStepResult(EFail);

                 INFO_PRINTF1(HTML_RED);

                 ERR_PRINTF4(_L("%S: SelectRealL gave %f, wanted %f"),

                        &KTestFunction, actual,  expected);

                 INFO_PRINTF1(HTML_COLOUR_OFF);

                 }

             else

                 {

                 INFO_PRINTF1(HTML_GREEN);

                 INFO_PRINTF3(_L("%S: SelectRealL gave %f, as expected"),

                        &KTestFunction, actual);

                 INFO_PRINTF1(HTML_COLOUR_OFF);

                 }

             }

             break;

         case CSQLSFSTEFAction::ESFS_SelectTextL:

             {

             RBuf actual;

             actual.Create(32768);

             CleanupClosePushL(actual);

             TInt rc = KErrNone;

             if(i8bit)

                 rc = asfs->SelectTextL(stmt8, actual);

             else

                 rc = asfs->SelectTextL(stmt, actual);

             if( actual != res )

                 {

                 SetTestStepResult(EFail);

                 INFO_PRINTF1(HTML_RED);

                 ERR_PRINTF4(_L("%S: SelectTextL gave %S, wanted %S"),

                        &KTestFunction, &actual,  &res);

                 INFO_PRINTF1(HTML_COLOUR_OFF);

                 }

             else

                 {

                 INFO_PRINTF1(HTML_GREEN);

                 INFO_PRINTF3(_L("%S: SelectTextL gave %S, as expected"),

                        &KTestFunction, &actual);

                 INFO_PRINTF1(HTML_COLOUR_OFF);

                 }

             ReportOnError( KTestFunction, _L("SelectTextL"), acfgblk, acnnum,

                                                                           rc );

             CleanupStack::PopAndDestroy(1, &actual);

         }

         break;

         case CSQLSFSTEFAction::ESFS_SelectBinaryL:

             {

             RBuf8 actual;

             actual.Create(32768);

             CleanupClosePushL(actual);

             TInt rc = KErrNone;

             if(i8bit)

                 rc = asfs->SelectBinaryL(stmt8, actual);

             else

                 rc = asfs->SelectBinaryL(stmt, actual);

             ReportOnError( KTestFunction, _L("SelectBinaryL"), acfgblk, acnnum, rc );

             if(!rc)

                 {

                 TInt rc2 = CompareBinaryAgainstFileL(actual, res);

                 if(rc2)

                     {

                     SetTestStepResult(EFail);

                     INFO_PRINTF1(HTML_RED);

                     ERR_PRINTF3(_L("%S: File compare gave error %d"),

                                      &KTestFunction, rc2 );

                     INFO_PRINTF1(HTML_COLOUR_OFF);

                     }

                 else

                     {

                     INFO_PRINTF1(HTML_GREEN);

                     _LIT(KSelectBinaryStr, "SelectBinaryL");

                     ERR_PRINTF3(_L("%S: File compare successful, %S"), &KTestFunction, &KSelectBinaryStr);

                     INFO_PRINTF1(HTML_COLOUR_OFF);

                     }

                 }

             CleanupStack::PopAndDestroy(1, &actual);

             }

             break;

         default: User::Panic(_L("Unknown Function"), 49);

         }

     CleanupStack::PopAndDestroy(1, &stmt8);

     }

 // Verifies that two files differ by size.

 void CSQLCDT::FilesDifferBySize(const TDesC &acfgblk, const TInt acnnum)

     {

     _LIT(KTestFunction, "FilesDifferBySize");

     // Look for a string called 'FileANN'.

     TPtrC filea;

     TBuf<KConfigItemMaxNameLength> fileaS(_L("FileA"));

     fileaS.AppendNum(acnnum);

     FromConfig(KTestFunction, acfgblk, fileaS, filea);

     // Look for a string called 'FileBNN'.

     TPtrC fileb;

     TBuf<KConfigItemMaxNameLength> filebS(_L("FileB"));

     filebS.AppendNum(acnnum);

     FromConfig(KTestFunction, acfgblk, filebS, fileb);

     TInt fza = FileSize(filea);

     TInt fzb = FileSize(fileb);

     if(fza == fzb)

         {

         SetTestStepResult(EFail);

         INFO_PRINTF1(HTML_RED);

         ERR_PRINTF4(_L("%S: File A %d, File B %d"), &KTestFunction, fza,  fzb);

         INFO_PRINTF1(HTML_COLOUR_OFF);

         }

     else

         {

         INFO_PRINTF1(HTML_GREEN);

         INFO_PRINTF6(_L("%S: Files %S and %S differ in size as expected, %d, %d"), &KTestFunction, &fileaS, &filebS, fza, fzb);

         INFO_PRINTF1(HTML_COLOUR_OFF);

         }

     }

 // Tests the method that retrive security policies.

 void CSQLCDT::SecurityPolicyCheck(const TDesC &/*acfgblk*/, const TInt /*acnnum*/)

     {

 //    _LIT(KTestFunction, "SecurityPolicyCheck");

     // The methods to be tested here have been tested in the developer test:

     // t_sqlsecurityXX.cpp. The work here has been deferred because it has been 

     // duplicated in the unit tests.

     }

 // Tests for Locale change

 // This test has been deferred pending a defect fix, defect is:

 // DEF091753 "Initialize locale" should be part of the system startup

 void CSQLCDT::CollationTest(const TDesC &/*acfgblk*/, const TInt /*acnnum*/)

     {

     TExtendedLocale myExtendedLocale;

     myExtendedLocale.LoadSystemSettings();

 #ifdef SYMBIAN_DISTINCT_LOCALE_MODEL

     TBuf<100> DllLanguage; 

     DllLanguage.Copy(_L("elocl_lan.003"));

     TBuf<100> DllRegion; 

     DllRegion.Copy(_L("elocl_reg.056"));

     TBuf<100> DllCollation; 

     DllCollation.Copy(_L("elocl_col.003"));

     // Change the locale 

     TInt err = myExtendedLocale.LoadLocale(DllLanguage, DllRegion, DllCollation);

 #else

     TBuf<100> DllName; 

     DllName.Copy(_L("elocl.sc"));

     // Change the locale to Scandinavian Locale 

     TInt err = myExtendedLocale.LoadLocale(DllName);    

 #endif

     if( err != KErrNone )

         {

         _LIT(KTestFunction, "CollationTest");

         SetTestStepResult(EFail);

         INFO_PRINTF1(HTML_RED);

         ERR_PRINTF4(_L("%S: TExtendedLocale::LoadLocale gave %d, wanted %d"),

                           &KTestFunction, err,  KErrNone);

         INFO_PRINTF1(HTML_COLOUR_OFF);

         }

     // Save the changes to system settings

     myExtendedLocale.SaveSystemSettings();

     // Wait

     User::After(1000000);

     }