Mercurial Mercurial > oss > MCL > sf > os > persistentdata / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
persistentstorage/sqlite3api/TEST/t_sqliteperf.cpp
branchRCL_3
changeset 24 cc28652e0254
parent 23 26645d81f48d
equal deleted inserted replaced
23:26645d81f48d 24:cc28652e0254 
    16 #include <e32test.h>
 
    16 #include <e32test.h>
 
    17 #include <bautils.h>
 
    17 #include <bautils.h>
 
    18 #include <e32math.h>
 
    18 #include <e32math.h>
 
    19 #include <hal.h>
 
    19 #include <hal.h>
 
    20 #include <sqldb.h>
 
    20 #include <sqldb.h>
 
    21 #include "sqliteTestUtl.h"
 
       
    22 #include "t_sqliteperf.h"
 
    21 #include "t_sqliteperf.h"
 
    23 
    22 
    24 ///////////////////////////////////////////////////////////////////////////////////////
 
    23 ///////////////////////////////////////////////////////////////////////////////////////
 
    25 
    24 
    26 const char* const KTestName = "t_sqliteperf test";
 
    25 static RTest TheTest(_L("t_sqliteperf test"));
 
    27 
       
    28 _LIT(KTestDir, "c:\\test\\");
 
    26 _LIT(KTestDir, "c:\\test\\");
 
    29 _LIT(KTestDbName,   "c:\\test\\t_sqliteperf.db");
 
    27 _LIT(KTestDbName,   "c:\\test\\t_sqliteperf.db");
 
    30 _LIT8(KTestDbName8, "c:\\test\\t_sqliteperf.db\x0");
 
    28 _LIT8(KTestDbName8, "c:\\test\\t_sqliteperf.db\x0");
 
    31 
    29 
    32 _LIT(KSqlSrvName, "sqlsrv.exe");
 
    30 _LIT(KSqlSrvName, "sqlsrv.exe");
 
    65 #define UNUSED_VAR(a) (a) = (a)
 
    63 #define UNUSED_VAR(a) (a) = (a)
 
    66 #define UNUSED_PTR(a) a.Set(a)
 
    64 #define UNUSED_PTR(a) a.Set(a)
 
    67 
    65 
    68 ///////////////////////////////////////////////////////////////////////////////////////
 
    66 ///////////////////////////////////////////////////////////////////////////////////////
 
    69 
    67 
       
    68 extern "C" void TestAbort(TInt aLine)
 
       
    69 	{
 
       
    70 	TheTest(0, aLine);
 
       
    71 	}
 
       
    72 
    70 extern "C" const char* TestDbName(void)
 
    73 extern "C" const char* TestDbName(void)
 
    71 	{
 
    74 	{
 
    72 	return (const char*)KTestDbName8().Ptr();
 
    75 	return (const char*)KTestDbName8().Ptr();
 
       
    76 	}
 
       
    77 
       
    78 extern "C" void PrintS(const char* aFmt, const char* aMsg)
 
       
    79 	{
 
       
    80 	TheSqlBuf.Format(TPtrC8((const TUint8*)aFmt), aMsg);
 
       
    81 	ThePrintBuf.Copy(TheSqlBuf);
 
       
    82 	TheTest.Printf(ThePrintBuf);
 
       
    83 	}
 
       
    84 
       
    85 extern "C" void PrintI(const char* aFmt, int a1)
 
       
    86 	{
 
       
    87 	TheSqlBuf.Format(TPtrC8((const TUint8*)aFmt), a1);
 
       
    88 	ThePrintBuf.Copy(TheSqlBuf);
 
       
    89 	TheTest.Printf(ThePrintBuf);
 
       
    90 	}
 
       
    91 
       
    92 extern "C" void PrintIII(const char* aFmt, int a1, int a2, int a3)
 
       
    93 	{
 
       
    94 	TheSqlBuf.Format(TPtrC8((const TUint8*)aFmt), a1, a2, a3);
 
       
    95 	ThePrintBuf.Copy(TheSqlBuf);
 
       
    96 	TheTest.Printf(ThePrintBuf);
 
    73 	}
 
    97 	}
 
    74 
    98 
    75 static void DeleteTestFiles()
 
    99 static void DeleteTestFiles()
 
    76 	{
 
   100 	{
 
    77 	TheDb.Close();
 
   101 	TheDb.Close();
 
    83 static void Check(TInt aValue, TInt aLine)
 
   107 static void Check(TInt aValue, TInt aLine)
 
    84 	{
 
   108 	{
 
    85 	if(!aValue)
 
   109 	if(!aValue)
 
    86 		{
 
   110 		{
 
    87 		DeleteTestFiles();
 
   111 		DeleteTestFiles();
 
    88 		TestTestLine(EFalse, aLine);
 
   112 		TheTest(EFalse, aLine);
 
    89 		}
 
   113 		}
 
    90 	}
 
   114 	}
 
    91 static void Check(TInt aValue, TInt aExpected, TInt aLine)
 
   115 static void Check(TInt aValue, TInt aExpected, TInt aLine)
 
    92 	{
 
   116 	{
 
    93 	if(aValue != aExpected)
 
   117 	if(aValue != aExpected)
 
    94 		{
 
   118 		{
 
    95 		DeleteTestFiles();
 
   119 		DeleteTestFiles();
 
    96 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
 
   120 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
 
    97 		TestTestLine(EFalse, aLine);
 
   121 		TheTest(EFalse, aLine);
 
    98 		}
 
   122 		}
 
    99 	}
 
   123 	}
 
   100 #define TEST(arg) ::Check((arg), __LINE__)
 
   124 #define TEST(arg) ::Check((arg), __LINE__)
 
   101 #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
 
   125 #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
 
   102 
   126 
   149 	}
 
   173 	}
 
   150 
   174 
   151 static void GetFastCounterFrequency()
 
   175 static void GetFastCounterFrequency()
 
   152 	{
 
   176 	{
 
   153 	TEST2(HAL::Get(HAL::EFastCounterFrequency, TheCounterFreq), KErrNone);
 
   177 	TEST2(HAL::Get(HAL::EFastCounterFrequency, TheCounterFreq), KErrNone);
 
   154 	TBuf8<32> printString;
 
   178 	TheTest.Printf(_L("Counter frequency=%d\r\n"), TheCounterFreq);
 
   155 	printString.Format(_L8("Counter frequency=%d\r\n"), TheCounterFreq);
 
       
   156 	TestPrintf((const char*)printString.PtrZ());
 
       
   157 	}
 
   179 	}
 
   158 
   180 
   159 extern "C" unsigned int FastCounterValue(void)
 
   181 extern "C" unsigned int FastCounterValue(void)
 
   160 	{
 
   182 	{
 
   161 	return User::FastCounter();
 
   183 	return User::FastCounter();
 
   169 	ThePerfTestResult[aMode][aType] = aResult;
 
   191 	ThePerfTestResult[aMode][aType] = aResult;
 
   170 	}
 
   192 	}
 
   171 
   193 
   172 static void PrintPerfTestResults()
 
   194 static void PrintPerfTestResults()
 
   173 	{
 
   195 	{
 
   174 	TBuf8<256> printString;
 
       
   175 	TInt r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestMultiInsert]);
 
   196 	TInt r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestMultiInsert]);
 
   176 	TInt r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestMultiInsert]);
 
   197 	TInt r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestMultiInsert]);
 
   177 	TInt r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestMultiInsert]);
 
   198 	TInt r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestMultiInsert]);
 
   178 	TInt r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   199 	TInt r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   179 	TInt r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   200 	TInt r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   180 	TestPrintf("###                 SQL            SQLITE-SQL     SQLITE-DEFAULT\r\n");
 
   201 	TheTest.Printf(_L("###                 SQL            SQLITE-SQL     SQLITE-DEFAULT\r\n"));
 
   181 	printString.Format(_L8("###Multi Insert:  %8dus     %8dus     %8dus   %8d%%%%   %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   202 	TheTest.Printf(_L("###Mutli Insert:  %8dus     %8dus     %8dus   %8d%%   %8d%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   182 	TestPrintf((const char*)printString.PtrZ());
 
       
   183 
   203 
   184 	r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestMultiUpdate]);
 
   204 	r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestMultiUpdate]);
 
   185 	r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestMultiUpdate]);
 
   205 	r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestMultiUpdate]);
 
   186 	r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestMultiUpdate]);
 
   206 	r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestMultiUpdate]);
 
   187 	r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   207 	r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   188 	r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   208 	r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   189 	printString.Format(_L8("###Multi Update:  %8dus     %8dus     %8dus   %8d%%%%   %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   209 	TheTest.Printf(_L("###Mutli Update:  %8dus     %8dus     %8dus   %8d%%   %8d%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   190 	TestPrintf((const char*)printString.PtrZ());
 
       
   191 
   210 
   192 	r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestMultiDelete]);
 
   211 	r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestMultiDelete]);
 
   193 	r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestMultiDelete]);
 
   212 	r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestMultiDelete]);
 
   194 	r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestMultiDelete]);
 
   213 	r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestMultiDelete]);
 
   195 	r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   214 	r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   196 	r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   215 	r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   197 	printString.Format(_L8("###Multi Delete:  %8dus     %8dus     %8dus   %8d%%%%   %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   216 	TheTest.Printf(_L("###Mutli Delete:  %8dus     %8dus     %8dus   %8d%%   %8d%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   198 	TestPrintf((const char*)printString.PtrZ());
 
       
   199 
   217 
   200 	r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestMultiSelect]);
 
   218 	r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestMultiSelect]);
 
   201 	r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestMultiSelect]);
 
   219 	r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestMultiSelect]);
 
   202 	r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestMultiSelect]);
 
   220 	r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestMultiSelect]);
 
   203 	r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   221 	r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   204 	r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   222 	r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   205 	printString.Format(_L8("###Multi Select:  %8dus     %8dus     %8dus   %8d%%%%   %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   223 	TheTest.Printf(_L("###Mutli Select:  %8dus     %8dus     %8dus   %8d%%   %8d%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   206 	TestPrintf((const char*)printString.PtrZ());
 
       
   207 
   224 
   208 	r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestSingleInsert]);
 
   225 	r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestSingleInsert]);
 
   209 	r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestSingleInsert]);
 
   226 	r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestSingleInsert]);
 
   210 	r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestSingleInsert]);
 
   227 	r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestSingleInsert]);
 
   211 	r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   228 	r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   212 	r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   229 	r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   213 	printString.Format(_L8("##Single Insert:  %8dus     %8dus     %8dus   %8d%%%%   %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   230 	TheTest.Printf(_L("##Single Insert:  %8dus     %8dus     %8dus   %8d%%   %8d%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   214 	TestPrintf((const char*)printString.PtrZ());
 
       
   215 
   231 
   216 	r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestSingleUpdate]);
 
   232 	r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestSingleUpdate]);
 
   217 	r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestSingleUpdate]);
 
   233 	r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestSingleUpdate]);
 
   218 	r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestSingleUpdate]);
 
   234 	r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestSingleUpdate]);
 
   219 	r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   235 	r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   220 	r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   236 	r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   221 	printString.Format(_L8("##Single Update:  %8dus     %8dus     %8dus   %8d%%%%   %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   237 	TheTest.Printf(_L("##Single Update:  %8dus     %8dus     %8dus   %8d%%   %8d%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   222 	TestPrintf((const char*)printString.PtrZ());
 
       
   223 
   238 
   224 	r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestSingleDelete]);
 
   239 	r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestSingleDelete]);
 
   225 	r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestSingleDelete]);
 
   240 	r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestSingleDelete]);
 
   226 	r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestSingleDelete]);
 
   241 	r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestSingleDelete]);
 
   227 	r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   242 	r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   228 	r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   243 	r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   229 	printString.Format(_L8("##Single Delete:  %8dus     %8dus     %8dus   %8d%%%%   %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   244 	TheTest.Printf(_L("##Single Delete:  %8dus     %8dus     %8dus   %8d%%   %8d%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   230 	TestPrintf((const char*)printString.PtrZ());
 
       
   231 
   245 
   232 	r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestSingleSelect]);
 
   246 	r1 = FcDiff2Us(ThePerfTestResult[EPerfTestSqlMode]          [EPerfTestSingleSelect]);
 
   233 	r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestSingleSelect]);
 
   247 	r2 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteSqlMode]    [EPerfTestSingleSelect]);
 
   234 	r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestSingleSelect]);
 
   248 	r3 = FcDiff2Us(ThePerfTestResult[EPerfTestSqliteDefaultMode][EPerfTestSingleSelect]);
 
   235 	r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   249 	r4 = (TInt)((Abs(r2 - r1) * 100.0) / r1);
 
   236 	r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   250 	r5 = (TInt)((Abs(r3 - r1) * 100.0) / r1);
 
   237 	printString.Format(_L8("##Single Select:  %8dus     %8dus     %8dus   %8d%%%%   %8d%%%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   251 	TheTest.Printf(_L("##Single Select:  %8dus     %8dus     %8dus   %8d%%   %8d%%\r\n"), r1, r2, r3, r2 > r1 ? -r4 : +r4, r3 > r1 ? -r5 : +r5);
 
   238 	TestPrintf((const char*)printString.PtrZ());
 
       
   239 	}
 
   252 	}
 
   240 
   253 
   241 ///////////////////////////////////////////////////////////////////////////////////////
 
   254 ///////////////////////////////////////////////////////////////////////////////////////
 
   242 
   255 
   243 static void CreateTestDir()
 
   256 static void CreateTestDir()
 
   285 @SYMTestExpectedResults Test must not fail
 
   298 @SYMTestExpectedResults Test must not fail
 
   286 @SYMREQ					REQ8782
 
   299 @SYMREQ					REQ8782
 
   287 */
 
   300 */
 
   288 static void SqlServerMultiInsertTest(const char aInsertSql[], TInt aInsertRecCnt)
 
   301 static void SqlServerMultiInsertTest(const char aInsertSql[], TInt aInsertRecCnt)
 
   289 	{
 
   302 	{
 
   290 	TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4010 ");
 
   303 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4010 "));
 
   291 	(void)KillProcess(KSqlSrvName);
 
   304 	(void)KillProcess(KSqlSrvName);
 
   292 
   305 
   293 	TInt err = TheDb.Open(KTestDbName);
 
   306 	TInt err = TheDb.Open(KTestDbName);
 
   294 	TEST2(err, KErrNone);
 
   307 	TEST2(err, KErrNone);
 
   295 
   308 
   342 @SYMTestExpectedResults Test must not fail
 
   355 @SYMTestExpectedResults Test must not fail
 
   343 @SYMREQ					REQ8782
 
   356 @SYMREQ					REQ8782
 
   344 */
 
   357 */
 
   345 static void SqlServerMultiUpdateTest(const char aUpdateSql[], TInt aUpdateRecIds[], TInt aUpdateRecCnt)
 
   358 static void SqlServerMultiUpdateTest(const char aUpdateSql[], TInt aUpdateRecIds[], TInt aUpdateRecCnt)
 
   346 	{
 
   359 	{
 
   347     TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4011 ");
 
   360     TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4011 "));
 
   348 	(void)KillProcess(KSqlSrvName);
 
   361 	(void)KillProcess(KSqlSrvName);
 
   349 
   362 
   350 	TInt err = TheDb.Open(KTestDbName);
 
   363 	TInt err = TheDb.Open(KTestDbName);
 
   351 	TEST2(err, KErrNone);
 
   364 	TEST2(err, KErrNone);
 
   352 
   365 
   370 @SYMTestExpectedResults Test must not fail
 
   383 @SYMTestExpectedResults Test must not fail
 
   371 @SYMREQ					REQ8782
 
   384 @SYMREQ					REQ8782
 
   372 */
 
   385 */
 
   373 static void SqlServerMultiDeleteTest(const char aDeleteSql[], TInt aDeleteRecIds[], TInt aDeleteRecCnt)
 
   386 static void SqlServerMultiDeleteTest(const char aDeleteSql[], TInt aDeleteRecIds[], TInt aDeleteRecCnt)
 
   374 	{
 
   387 	{
 
   375 	TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4012 ");
 
   388 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4012 "));
 
   376 	(void)KillProcess(KSqlSrvName);
 
   389 	(void)KillProcess(KSqlSrvName);
 
   377 
   390 
   378 	TInt err = TheDb.Open(KTestDbName);
 
   391 	TInt err = TheDb.Open(KTestDbName);
 
   379 	TEST2(err, KErrNone);
 
   392 	TEST2(err, KErrNone);
 
   380 
   393 
   398 @SYMTestExpectedResults Test must not fail
 
   411 @SYMTestExpectedResults Test must not fail
 
   399 @SYMREQ					REQ8782
 
   412 @SYMREQ					REQ8782
 
   400 */
 
   413 */
 
   401 static void SqlServerMultiSelectTest(const char aSelectSql[], TInt aSelectRecIds[], TInt aSelectRecCnt)
 
   414 static void SqlServerMultiSelectTest(const char aSelectSql[], TInt aSelectRecIds[], TInt aSelectRecCnt)
 
   402 	{
 
   415 	{
 
   403 	TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4013 ");
 
   416 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4013 "));
 
   404 	(void)KillProcess(KSqlSrvName);
 
   417 	(void)KillProcess(KSqlSrvName);
 
   405 
   418 
   406 	TInt err = TheDb.Open(KTestDbName);
 
   419 	TInt err = TheDb.Open(KTestDbName);
 
   407 	TEST2(err, KErrNone);
 
   420 	TEST2(err, KErrNone);
 
   408 
   421 
   447 @SYMTestExpectedResults Test must not fail
 
   460 @SYMTestExpectedResults Test must not fail
 
   448 @SYMREQ					REQ8782
 
   461 @SYMREQ					REQ8782
 
   449 */
 
   462 */
 
   450 static void SqlServerSingleInsertTest(const char aSingleInsertSql[], TInt aInsertRecId)
 
   463 static void SqlServerSingleInsertTest(const char aSingleInsertSql[], TInt aInsertRecId)
 
   451 	{
 
   464 	{
 
   452 	TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4014 ");
 
   465 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4014 "));
 
   453 	(void)KillProcess(KSqlSrvName);
 
   466 	(void)KillProcess(KSqlSrvName);
 
   454 
   467 
   455 	TInt err = TheDb.Open(KTestDbName);
 
   468 	TInt err = TheDb.Open(KTestDbName);
 
   456 	TEST2(err, KErrNone);
 
   469 	TEST2(err, KErrNone);
 
   457 
   470 
   474 @SYMTestExpectedResults Test must not fail
 
   487 @SYMTestExpectedResults Test must not fail
 
   475 @SYMREQ					REQ8782
 
   488 @SYMREQ					REQ8782
 
   476 */
 
   489 */
 
   477 static void SqlServerSingleUpdateTest(const char aSingleUpdateSql[], TInt aUpdateRecId)
 
   490 static void SqlServerSingleUpdateTest(const char aSingleUpdateSql[], TInt aUpdateRecId)
 
   478 	{
 
   491 	{
 
   479 	TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4015 ");
 
   492 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4015 "));
 
   480 	(void)KillProcess(KSqlSrvName);
 
   493 	(void)KillProcess(KSqlSrvName);
 
   481 
   494 
   482 	TInt err = TheDb.Open(KTestDbName);
 
   495 	TInt err = TheDb.Open(KTestDbName);
 
   483 	TEST2(err, KErrNone);
 
   496 	TEST2(err, KErrNone);
 
   484 
   497 
   502 @SYMTestExpectedResults Test must not fail
 
   515 @SYMTestExpectedResults Test must not fail
 
   503 @SYMREQ					REQ8782
 
   516 @SYMREQ					REQ8782
 
   504 */
 
   517 */
 
   505 static void SqlServerSingleDeleteTest(const char aSingleDeleteSql[], TInt aDeleteRecId)
 
   518 static void SqlServerSingleDeleteTest(const char aSingleDeleteSql[], TInt aDeleteRecId)
 
   506 	{
 
   519 	{
 
   507 	TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4016 ");
 
   520 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4016 "));
 
   508 	(void)KillProcess(KSqlSrvName);
 
   521 	(void)KillProcess(KSqlSrvName);
 
   509 
   522 
   510 	TInt err = TheDb.Open(KTestDbName);
 
   523 	TInt err = TheDb.Open(KTestDbName);
 
   511 	TEST2(err, KErrNone);
 
   524 	TEST2(err, KErrNone);
 
   512 
   525 
   530 @SYMTestExpectedResults Test must not fail
 
   543 @SYMTestExpectedResults Test must not fail
 
   531 @SYMREQ					REQ8782
 
   544 @SYMREQ					REQ8782
 
   532 */
 
   545 */
 
   533 static void SqlServerSingleSelectTest(const char aSingleSelectSql[], TInt aSelectRecId)
 
   546 static void SqlServerSingleSelectTest(const char aSingleSelectSql[], TInt aSelectRecId)
 
   534 	{
 
   547 	{
 
   535 	TestNext(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4017 ");
 
   548 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQLITE3-UT-4017 "));
 
   536 	(void)KillProcess(KSqlSrvName);
 
   549 	(void)KillProcess(KSqlSrvName);
 
   537 
   550 
   538 	TInt err = TheDb.Open(KTestDbName);
 
   551 	TInt err = TheDb.Open(KTestDbName);
 
   539 	TEST2(err, KErrNone);
 
   552 	TEST2(err, KErrNone);
 
   540 
   553 
   574 ///////////////////////////////////////////////////////////////////////////////////////
 
   587 ///////////////////////////////////////////////////////////////////////////////////////
 
   575 ///////////////////////////////////////////////////////////////////////////////////////
 
   588 ///////////////////////////////////////////////////////////////////////////////////////
 
   576 
   589 
   577 static void DoSqlServerTests()
 
   590 static void DoSqlServerTests()
 
   578 	{
 
   591 	{
 
   579 	TestNext("SQL: Create the test database");
 
   592 	TheTest.Next(_L("SQL: Create the test database"));
 
   580 	CreateTestDatabase();
 
   593 	CreateTestDatabase();
 
   581 
   594 
   582 	TBuf8<100> msgbuf;
 
   595 	TBuf<100> msgbuf;
 
   583 
   596 
   584 	msgbuf.Format(_L8("SQL: insert %d records in a single transaction"), KInsertRecCnt);
 
   597 	msgbuf.Format(_L("SQL: insert %d records in a single transaction"), KInsertRecCnt);
 
   585 	TestNext((const char*)msgbuf.PtrZ());
 
   598 	TheTest.Next(msgbuf);
 
   586 	SqlServerMultiInsertTest(KMultiInsertSql, KInsertRecCnt);
 
   599 	SqlServerMultiInsertTest(KMultiInsertSql, KInsertRecCnt);
 
   587 
   600 
   588 	msgbuf.Format(_L8("SQL: update %d records in a single transaction"), KUpdateRecCnt);
 
   601 	msgbuf.Format(_L("SQL: update %d records in a single transaction"), KUpdateRecCnt);
 
   589 	TestNext((const char*)msgbuf.PtrZ());
 
   602 	TheTest.Next(msgbuf);
 
   590 	SqlServerMultiUpdateTest(KMultiUpdateSql, TheUpdateRecIds, KUpdateRecCnt);
 
   603 	SqlServerMultiUpdateTest(KMultiUpdateSql, TheUpdateRecIds, KUpdateRecCnt);
 
   591 
   604 
   592 	msgbuf.Format(_L8("SQL: delete %d records in a single transaction"), KDeleteRecCnt);
 
   605 	msgbuf.Format(_L("SQL: delete %d records in a single transaction"), KDeleteRecCnt);
 
   593 	TestNext((const char*)msgbuf.PtrZ());
 
   606 	TheTest.Next(msgbuf);
 
   594 	SqlServerMultiDeleteTest(KMultiDeleteSql, TheDeleteRecIds, KDeleteRecCnt);
 
   607 	SqlServerMultiDeleteTest(KMultiDeleteSql, TheDeleteRecIds, KDeleteRecCnt);
 
   595 
   608 
   596 	msgbuf.Format(_L8("SQL: select %d records"), KSelectRecCnt);
 
   609 	msgbuf.Format(_L("SQL: select %d records"), KSelectRecCnt);
 
   597 	msgbuf.Copy(msgbuf);
 
   610 	TheTest.Next(msgbuf);
 
   598 	TestNext((const char*)msgbuf.PtrZ());
 
       
   599 	SqlServerMultiSelectTest(KMultiSelectSql, TheSelectRecIds, KSelectRecCnt);
 
   611 	SqlServerMultiSelectTest(KMultiSelectSql, TheSelectRecIds, KSelectRecCnt);
 
   600 
   612 
   601 	TestNext("SQL: insert a single record");
 
   613 	TheTest.Next(_L("SQL: insert a single record"));
 
   602 	SqlServerSingleInsertTest(KSingleInsertSql, TheInsertRecId);
 
   614 	SqlServerSingleInsertTest(KSingleInsertSql, TheInsertRecId);
 
   603 
   615 
   604 	TestNext("SQL: update a single record");
 
   616 	TheTest.Next(_L("SQL: update a single record"));
 
   605 	SqlServerSingleUpdateTest(KSingleUpdateSql, TheUpdateRecId);
 
   617 	SqlServerSingleUpdateTest(KSingleUpdateSql, TheUpdateRecId);
 
   606 
   618 
   607 	TestNext("SQL: delete a single record");
 
   619 	TheTest.Next(_L("SQL: delete a single record"));
 
   608 	SqlServerSingleDeleteTest(KSingleDeleteSql, TheDeleteRecId);
 
   620 	SqlServerSingleDeleteTest(KSingleDeleteSql, TheDeleteRecId);
 
   609 
   621 
   610 	TestNext("SQL: select a single record");
 
   622 	TheTest.Next(_L("SQL: select a single record"));
 
   611 	SqlServerSingleSelectTest(KSingleSelectSql, TheSelectRecId);
 
   623 	SqlServerSingleSelectTest(KSingleSelectSql, TheSelectRecId);
 
   612 
   624 
   613 	(void)RSqlDatabase::Delete(KTestDbName);
 
   625 	(void)RSqlDatabase::Delete(KTestDbName);
 
   614 	}
 
   626 	}
 
   615 
   627 
   617 	{
 
   629 	{
 
   618 	TEST(aPerfTestMode > EPerfTestSqlMode && aPerfTestMode < EPerfTestModeCnt);
 
   630 	TEST(aPerfTestMode > EPerfTestSqlMode && aPerfTestMode < EPerfTestModeCnt);
 
   619 
   631 
   620 	SqliteInitialize(aPerfTestMode);
 
   632 	SqliteInitialize(aPerfTestMode);
 
   621 
   633 
   622 	TestNext("SQLite: Create the test database");
 
   634 	TheTest.Next( _L("SQLite: Create the test database"));
 
   623 	CreateTestDatabase();
 
   635 	CreateTestDatabase();
 
   624 
   636 
   625 	TBuf8<200> msgbuf;
 
   637 	TBuf<200> msgbuf;
 
   626 	_LIT8(KSqliteConfigSql, "\"SQL\"");
 
   638 	_LIT(KSqliteConfigSql, "\"SQL\"");
 
   627 	_LIT8(KSqliteConfigDefault, "\"Default\"");
 
   639 	_LIT(KSqliteConfigDefault, "\"Default\"");
 
   628 
   640 
   629 	msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4018: SQLite, configuration: %S: insert %d records in a single transaction"),
 
   641 	msgbuf.Format(_L("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4018: SQLite, configuration: %S: insert %d records in a single transaction"),
 
   630 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault, KInsertRecCnt);
 
   642 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault, KInsertRecCnt);
 
   631 	TestNext((const char*)msgbuf.PtrZ());
 
   643 	TheTest.Next(msgbuf);
 
   632 	SqliteMultiInsertTest(aPerfTestMode, KMultiInsertSql, KInsertRecCnt);
 
   644 	SqliteMultiInsertTest(aPerfTestMode, KMultiInsertSql, KInsertRecCnt);
 
   633 
   645 
   634 	msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4019: SQLite, configuration: %S: update %d records in a single transaction"),
 
   646 	msgbuf.Format(_L("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4019: SQLite, configuration: %S: update %d records in a single transaction"),
 
   635 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault, KUpdateRecCnt);
 
   647 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault, KUpdateRecCnt);
 
   636 	TestNext((const char*)msgbuf.PtrZ());
 
   648 	TheTest.Next(msgbuf);
 
   637 	SqliteMultiUpdateTest(aPerfTestMode, KMultiUpdateSql, TheUpdateRecIds, KUpdateRecCnt);
 
   649 	SqliteMultiUpdateTest(aPerfTestMode, KMultiUpdateSql, TheUpdateRecIds, KUpdateRecCnt);
 
   638 
   650 
   639 	msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4020: SQLite, configuration: %S: delete %d records in a single transaction"),
 
   651 	msgbuf.Format(_L("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4020: SQLite, configuration: %S: delete %d records in a single transaction"),
 
   640 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault, KDeleteRecCnt);
 
   652 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault, KDeleteRecCnt);
 
   641 	TestNext((const char*)msgbuf.PtrZ());
 
   653 	TheTest.Next(msgbuf);
 
   642 	SqliteMultiDeleteTest(aPerfTestMode, KMultiDeleteSql, TheDeleteRecIds, KDeleteRecCnt);
 
   654 	SqliteMultiDeleteTest(aPerfTestMode, KMultiDeleteSql, TheDeleteRecIds, KDeleteRecCnt);
 
   643 
   655 
   644 	msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4021: SQLite, configuration: %S: select %d records"),
 
   656 	msgbuf.Format(_L("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4021: SQLite, configuration: %S: select %d records"),
 
   645 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault, KSelectRecCnt);
 
   657 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault, KSelectRecCnt);
 
   646 	TestNext((const char*)msgbuf.PtrZ());
 
   658 	TheTest.Next(msgbuf);
 
   647 	SqliteMultiSelectTest(aPerfTestMode, KMultiSelectSql, TheSelectRecIds, KSelectRecCnt);
 
   659 	SqliteMultiSelectTest(aPerfTestMode, KMultiSelectSql, TheSelectRecIds, KSelectRecCnt);
 
   648 
   660 
   649 	msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4022: SQLite, configuration: %S: insert a single record"),
 
   661 	msgbuf.Format(_L("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4022: SQLite, configuration: %S: insert a single record"),
 
   650 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault);
 
   662 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault);
 
   651 	TestNext((const char*)msgbuf.PtrZ());
 
   663 	TheTest.Next(msgbuf);
 
   652 	SqliteSingleInsertTest(aPerfTestMode, KSingleInsertSql, TheInsertRecId);
 
   664 	SqliteSingleInsertTest(aPerfTestMode, KSingleInsertSql, TheInsertRecId);
 
   653 
   665 
   654 	msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4023: SQLite, configuration: %S: update a single record"),
 
   666 	msgbuf.Format(_L("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4023: SQLite, configuration: %S: update a single record"),
 
   655 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault);
 
   667 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault);
 
   656 	TestNext((const char*)msgbuf.PtrZ());
 
   668 	TheTest.Next(msgbuf);
 
   657 	SqliteSingleUpdateTest(aPerfTestMode, KSingleUpdateSql, TheUpdateRecId);
 
   669 	SqliteSingleUpdateTest(aPerfTestMode, KSingleUpdateSql, TheUpdateRecId);
 
   658 
   670 
   659 	msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4024: SQLite, configuration: %S: delete a single record"),
 
   671 	msgbuf.Format(_L("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4024: SQLite, configuration: %S: delete a single record"),
 
   660 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault);
 
   672 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault);
 
   661 	TestNext((const char*)msgbuf.PtrZ());
 
   673 	TheTest.Next(msgbuf);
 
   662 	SqliteSingleDeleteTest(aPerfTestMode, KSingleDeleteSql, TheDeleteRecId);
 
   674 	SqliteSingleDeleteTest(aPerfTestMode, KSingleDeleteSql, TheDeleteRecId);
 
   663 
   675 
   664 	msgbuf.Format(_L8("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4025: SQLite, configuration: %S: select a single record"),
 
   676 	msgbuf.Format(_L("@SYMTestCaseID:SYSLIB-SQLITE3-UT-4025: SQLite, configuration: %S: select a single record"),
 
   665 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault);
 
   677 							aPerfTestMode == EPerfTestSqliteSqlMode ? &KSqliteConfigSql : &KSqliteConfigDefault);
 
   666 	TestNext((const char*)msgbuf.PtrZ());
 
   678 	TheTest.Next(msgbuf);
 
   667 	SqliteSingleSelectTest(aPerfTestMode, KSingleSelectSql, TheSelectRecId);
 
   679 	SqliteSingleSelectTest(aPerfTestMode, KSingleSelectSql, TheSelectRecId);
 
   668 
   680 
   669 	(void)RSqlDatabase::Delete(KTestDbName);
 
   681 	(void)RSqlDatabase::Delete(KTestDbName);
 
   670 
   682 
   671 	SqliteFinalize(aPerfTestMode);
 
   683 	SqliteFinalize(aPerfTestMode);
 
   805 		}
 
   817 		}
 
   806 	}
 
   818 	}
 
   807 
   819 
   808 static void DoTests()
 
   820 static void DoTests()
 
   809 	{
 
   821 	{
 
   810 	TestStart("Get fast counter frequency");
 
   822 	TheTest.Start(_L("Get fast counter frequency"));
 
   811 	GetFastCounterFrequency();
 
   823 	GetFastCounterFrequency();
 
   812 
   824 
   813 	TestNext("Generate test record ids");
 
   825 	TheTest.Next( _L("Generate test record ids"));
 
   814 	GenerateTestRecIds();
 
   826 	GenerateTestRecIds();
 
   815 
   827 
   816 	TestNext("Verify generated test record ids");
 
   828 	TheTest.Next( _L("Verify generated test record ids"));
 
   817 	VerifyGeneratedRecIds();
 
   829 	VerifyGeneratedRecIds();
 
   818 
   830 
   819 	DoSqlServerTests();
 
   831 	DoSqlServerTests();
 
   820 	(void)KillProcess(KSqlSrvName);
 
   832 	(void)KillProcess(KSqlSrvName);
 
   821 
   833 
   826 	PrintPerfTestResults();
 
   838 	PrintPerfTestResults();
 
   827 	}
 
   839 	}
 
   828 
   840 
   829 TInt E32Main()
 
   841 TInt E32Main()
 
   830 	{
 
   842 	{
 
   831 	TestOpen(KTestName);
 
   843 	TheTest.Title();
 
   832 	TestTitle();
 
       
   833 
   844 
   834 	CTrapCleanup* tc = CTrapCleanup::New();
 
   845 	CTrapCleanup* tc = CTrapCleanup::New();
 
   835 
   846 
   836 	__UHEAP_MARK;
 
   847 	__UHEAP_MARK;
 
   837 
   848 
   840 	DoTests();
 
   851 	DoTests();
 
   841 	DeleteTestFiles();
 
   852 	DeleteTestFiles();
 
   842 
   853 
   843 	__UHEAP_MARKEND;
 
   854 	__UHEAP_MARKEND;
 
   844 
   855 
   845 	TestEnd();
 
   856 	TheTest.End();
 
   846 	TestClose();
 
   857 	TheTest.Close();
 
   847 
   858 
   848 	delete tc;
 
   859 	delete tc;
 
   849 
   860 
   850 	User::Heap().Check();
 
   861 	User::Heap().Check();
 
   851 	return KErrNone;
 
   862 	return KErrNone;
MCL/sf/os/persistentdata