persistentstorage/sql/TEST/t_sqlfserr.cpp
changeset 29 cce6680bbf1c
parent 15 3eacc0623088
child 55 44f437012c90
equal deleted inserted replaced
28:7a522c0700d3 29:cce6680bbf1c
     1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
     1 // Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).
     2 // All rights reserved.
     2 // All rights reserved.
     3 // This component and the accompanying materials are made available
     3 // This component and the accompanying materials are made available
     4 // under the terms of "Eclipse Public License v1.0"
     4 // under the terms of "Eclipse Public License v1.0"
     5 // which accompanies this distribution, and is available
     5 // which accompanies this distribution, and is available
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
   163 	TEST2(err, KErrNone);
   163 	TEST2(err, KErrNone);
   164 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Name TEXT)"));
   164 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Name TEXT)"));
   165 	TEST(err >= 0);
   165 	TEST(err >= 0);
   166 	TheDb.Close();
   166 	TheDb.Close();
   167 	err = KErrNotFound;
   167 	err = KErrNotFound;
   168 	for(TInt cnt=1;err<KErrNone;++cnt)
   168 	for(TInt cnt=0;err<KErrNone;++cnt)
   169 		{
   169 		{
   170 		TheTest.Printf(_L("%d \r"), cnt);		
   170 		TheTest.Printf(_L("%d \r"), cnt);		
   171 		for (TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
   171 		for (TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
   172 			{
   172 			{
   173 			//Preprocessing
   173 			//Preprocessing
   223 	TEST2(err, KErrNone);
   223 	TEST2(err, KErrNone);
   224 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Name TEXT)"));
   224 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Name TEXT)"));
   225 	TEST(err >= 0);
   225 	TEST(err >= 0);
   226 	TheDb.Close();
   226 	TheDb.Close();
   227 	err = KErrNotFound;
   227 	err = KErrNotFound;
   228 	for(TInt cnt=1;err<KErrNone;++cnt)
   228 	for(TInt cnt=0;err<KErrNone;++cnt)
   229 		{
   229 		{
   230 		TheTest.Printf(_L("%d \r"), cnt);		
   230 		TheTest.Printf(_L("%d \r"), cnt);		
   231 		for (TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
   231 		for (TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
   232 			{
   232 			{
   233 			//Preprocessing
   233 			//Preprocessing
   282     TEST2(err, KErrNone);
   282     TEST2(err, KErrNone);
   283     err = aSecurityPolicy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, alwaysPassPolicy);
   283     err = aSecurityPolicy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, alwaysPassPolicy);
   284     TEST2(err, KErrNone);
   284     TEST2(err, KErrNone);
   285     }
   285     }
   286 
   286 
       
   287 //Creates public shared, private secure and public secure databases.
       
   288 void DoCreateTestDatabases(const TPtrC aDbName[], TInt aCount)
       
   289     {
       
   290     TEST(aCount > 0);
       
   291     for(TInt i=0;i<aCount;++i)
       
   292         {
       
   293         TheTest.Printf(_L("Database: \"%S\"\r\n"), &aDbName[i]);       
       
   294         (void)RSqlDatabase::Delete(aDbName[i]);
       
   295         TInt err = KErrGeneral;
       
   296         if(i == (aCount - 1))
       
   297             {
       
   298             RSqlSecurityPolicy policy;
       
   299             CreateTestSecurityPolicy(policy);
       
   300             err = TheDb.Create(aDbName[i], policy);
       
   301             policy.Close();
       
   302             }
       
   303         else
       
   304             {
       
   305             err = TheDb.Create(aDbName[i]);
       
   306             }
       
   307         TEST2(err, KErrNone);
       
   308         err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Name TEXT)"));
       
   309         TEST(err >= 0);
       
   310         err = TheDb.Exec(_L("INSERT INTO A(Id,Name) VALUES(1,'Name')"));
       
   311         TEST2(err, 1);
       
   312         TheDb.Close();
       
   313         }
       
   314     }
       
   315 
   287 /**
   316 /**
   288 @SYMTestCaseID			SYSLIB-SQL-UT-3421
   317 @SYMTestCaseID			SYSLIB-SQL-UT-3421
   289 @SYMTestCaseDesc		Test for DEF103859 "SQLITE panic, _DEBUG mode, persistent file I/O error simulation".
   318 @SYMTestCaseDesc		Test for DEF103859 "SQLITE panic, _DEBUG mode, persistent file I/O error simulation".
   290 						The test creates a test database with one table, inserts one record.
   319 						The test creates a test database with one table, inserts one record.
   291 						Then the test attempts to open the database while simulating file I/O failures.
   320 						Then the test attempts to open the database while simulating file I/O failures.
   298 */
   327 */
   299 void OpenDatabaseTest()
   328 void OpenDatabaseTest()
   300 	{
   329 	{
   301     TPtrC dbName[] = {KTestDbName(), KPrivateTestDbName(), KSecureTestDbName()};
   330     TPtrC dbName[] = {KTestDbName(), KPrivateTestDbName(), KSecureTestDbName()};
   302     const TInt KDbNameCnt = sizeof(dbName) / sizeof(dbName[0]);
   331     const TInt KDbNameCnt = sizeof(dbName) / sizeof(dbName[0]);
       
   332     DoCreateTestDatabases(dbName, KDbNameCnt);
   303     for(TInt k=0;k<KDbNameCnt;++k)
   333     for(TInt k=0;k<KDbNameCnt;++k)
   304         {	
   334         {	
   305         TheTest.Printf(_L("Database: \"%S\"\r\n"), &dbName[k]);       
   335         TheTest.Printf(_L("Database: \"%S\"\r\n"), &dbName[k]);       
   306         (void)RSqlDatabase::Delete(dbName[k]);
   336         TInt err = KErrNotFound;
   307         TInt err = KErrGeneral;
   337         for(TInt cnt=0;err<KErrNone;++cnt)
   308         if(k == (KDbNameCnt - 1))
       
   309             {
       
   310             RSqlSecurityPolicy policy;
       
   311             CreateTestSecurityPolicy(policy);
       
   312             err = TheDb.Create(dbName[k], policy);
       
   313             policy.Close();
       
   314             }
       
   315         else
       
   316             {
       
   317             err = TheDb.Create(dbName[k]);
       
   318             }
       
   319         TEST2(err, KErrNone);
       
   320         err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Name TEXT)"));
       
   321         TEST(err >= 0);
       
   322         err = TheDb.Exec(_L("INSERT INTO A(Id,Name) VALUES(1,'Name')"));
       
   323         TEST2(err, 1);
       
   324         TheDb.Close();
       
   325     
       
   326         err = KErrNotFound;
       
   327         for(TInt cnt=1;err<KErrNone;++cnt)
       
   328             {		
   338             {		
   329             TheTest.Printf(_L("%d \r"), cnt);		
   339             TheTest.Printf(_L("%d \r"), cnt);		
   330             for (TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
   340             for (TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
   331                 {
   341                 {
   332                 (void)TheFs.SetErrorCondition(fsError, cnt);
   342                 (void)TheFs.SetErrorCondition(fsError, cnt);
   352         //check the database content is the same as before the operation, after reopening the database.
   362         //check the database content is the same as before the operation, after reopening the database.
   353         TEST(CheckRecord(dbName[k], 1, _L("Name")));
   363         TEST(CheckRecord(dbName[k], 1, _L("Name")));
   354         err = RSqlDatabase::Delete(dbName[k]);
   364         err = RSqlDatabase::Delete(dbName[k]);
   355         TEST2(err, KErrNone);
   365         TEST2(err, KErrNone);
   356         TheTest.Printf(_L("\r\n"));
   366         TheTest.Printf(_L("\r\n"));
   357         }
   367         }//end of: for(TInt k=0;k<KDbNameCnt;++k)
   358 	}
   368 	}
   359 
   369 
   360 /**
   370 /**
   361 @SYMTestCaseID			SYSLIB-SQL-UT-3434
   371 @SYMTestCaseID			SYSLIB-SQL-UT-3434
   362 @SYMTestCaseDesc		Test for DEF104820 "SQL, RSqlDatabase::Create() does not delete the file if fails".
   372 @SYMTestCaseDesc		Test for DEF104820 "SQL, RSqlDatabase::Create() does not delete the file if fails".
   378 	const TInt KDbNameCnt = sizeof(dbName) / sizeof(dbName[0]);
   388 	const TInt KDbNameCnt = sizeof(dbName) / sizeof(dbName[0]);
   379 	for(TInt k=0;k<KDbNameCnt;++k)
   389 	for(TInt k=0;k<KDbNameCnt;++k)
   380 	    {
   390 	    {
   381         TheTest.Printf(_L("Database: \"%S\"\r\n"), &dbName[k]);       
   391         TheTest.Printf(_L("Database: \"%S\"\r\n"), &dbName[k]);       
   382         TInt err = -1;
   392         TInt err = -1;
   383         for(TInt cnt=1;err<KErrNone;++cnt)
   393         for(TInt cnt=0;err<KErrNone;++cnt)
   384             {		
   394             {		
   385             TheTest.Printf(_L("%d \r"), cnt);		
   395             TheTest.Printf(_L("%d \r"), cnt);		
   386             for (TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
   396             for (TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
   387                 {
   397                 {
   388                 //Ideally, the database should be deleted by the SQL server, if RSqlDatabase::Create() fails.
   398                 //Ideally, the database should be deleted by the SQL server, if RSqlDatabase::Create() fails.
   411 	    }
   421 	    }
   412 	policy.Close();
   422 	policy.Close();
   413 	}
   423 	}
   414 
   424 
   415 /**
   425 /**
       
   426 @SYMTestCaseID          PDS-SQL-UT-4189
       
   427 @SYMTestCaseDesc        Test for DEF145125 "SQL, low code coverage".
       
   428                         The test creates public shared, private secure and public secure test databases.
       
   429                         Then the test opens the publich shared database and attempts to attach one of the other two
       
   430                         in a file I/O error simulation loop.
       
   431 @SYMTestPriority        High
       
   432 @SYMTestActions         Test for DEF145125 - "SQL, low code coverage".
       
   433 @SYMTestExpectedResults The test must not fail
       
   434 @SYMDEF                 DEF145125 
       
   435 */
       
   436 void AttachDatabaseTest()
       
   437     {
       
   438     TPtrC dbName[] = {KTestDbName(), KPrivateTestDbName(), KSecureTestDbName()};
       
   439     const TInt KDbNameCnt = sizeof(dbName) / sizeof(dbName[0]);
       
   440     DoCreateTestDatabases(dbName, KDbNameCnt);
       
   441     for(TInt k=1;k<KDbNameCnt;++k)
       
   442         {
       
   443         TheTest.Printf(_L("Database: \"%S\"\r\n"), &dbName[k]);       
       
   444         TInt err = KErrGeneral;
       
   445         for(TInt cnt=0;err<KErrNone;++cnt)
       
   446             {
       
   447             TheTest.Printf(_L("%d \r"), cnt);       
       
   448             for(TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
       
   449                 {
       
   450                 err = TheDb.Open(KTestDbName);
       
   451                 TEST2(err, KErrNone);
       
   452                 (void)TheFs.SetErrorCondition(fsError, cnt);
       
   453                 err = TheDb.Attach(dbName[k], _L("DB2"));
       
   454                 (void)TheFs.SetErrorCondition(KErrNone);
       
   455                 (void)TheDb.Detach(_L("DB2"));
       
   456                 TheDb.Close();//close the database to recover from the last error
       
   457                 }
       
   458             }
       
   459         TEST2(err, KErrNone);
       
   460         err = RSqlDatabase::Delete(dbName[k]);
       
   461         TEST2(err, KErrNone);
       
   462         TheTest.Printf(_L("\r\n"));
       
   463         }
       
   464     }
       
   465 
       
   466 /**
       
   467 @SYMTestCaseID          PDS-SQL-UT-4190
       
   468 @SYMTestCaseDesc        Test for DEF145125 "SQL, low code coverage".
       
   469                         The tests attempts to delete a database in a file I/O error simulation loop.
       
   470 @SYMTestPriority        High
       
   471 @SYMTestActions         Test for DEF145125 - "SQL, low code coverage".
       
   472 @SYMTestExpectedResults The test must not fail
       
   473 @SYMDEF                 DEF145125 
       
   474 */
       
   475 void DeleteDatabaseTest()
       
   476     {
       
   477     TPtrC dbName[] = {KTestDbName(), KPrivateTestDbName(), KSecureTestDbName()};
       
   478     const TInt KDbNameCnt = sizeof(dbName) / sizeof(dbName[0]);
       
   479     DoCreateTestDatabases(dbName, KDbNameCnt);
       
   480     for(TInt k=0;k<KDbNameCnt;++k)
       
   481         {   
       
   482         TheTest.Printf(_L("Database: \"%S\"\r\n"), &dbName[k]);       
       
   483         TInt err = KErrGeneral;
       
   484         for(TInt cnt=1;err<KErrNone;++cnt)
       
   485             {
       
   486             TheTest.Printf(_L("%d \r"), cnt);
       
   487             (void)TheFs.SetErrorCondition(KErrGeneral, cnt);
       
   488             err = RSqlDatabase::Delete(dbName[k]);
       
   489             (void)TheFs.SetErrorCondition(KErrNone);
       
   490             }
       
   491         TEST2(err, KErrNone);
       
   492         err = RSqlDatabase::Delete(KTestDbName);
       
   493         TEST2(err, KErrNotFound);
       
   494         }    
       
   495     }
       
   496 
       
   497 /**
   416 @SYMTestCaseID			SYSLIB-SQL-UT-3462
   498 @SYMTestCaseID			SYSLIB-SQL-UT-3462
   417 @SYMTestCaseDesc		Test for DEF105434 "SQL, persistent file I/O simulation, COMMIT problem".
   499 @SYMTestCaseDesc		Test for DEF105434 "SQL, persistent file I/O simulation, COMMIT problem".
   418 						The test creates a test database with one table, inserts one record.
   500 						The test creates a test database with one table, inserts one record.
   419 						Then the test attempts to retrieve the existing record while simulating file I/O failures.
   501 						Then the test attempts to retrieve the existing record while simulating file I/O failures.
   420 						After each iteration, the database content is tested, that it has not been modified by the operation.
   502 						After each iteration, the database content is tested, that it has not been modified by the operation.
   432 	TEST(err >= 0);
   514 	TEST(err >= 0);
   433 	err = TheDb.Exec(_L("INSERT INTO A(Id,Name) VALUES(1,'Name')"));
   515 	err = TheDb.Exec(_L("INSERT INTO A(Id,Name) VALUES(1,'Name')"));
   434 	TEST2(err, 1);
   516 	TEST2(err, 1);
   435 	TheDb.Close();
   517 	TheDb.Close();
   436 	err = -1;
   518 	err = -1;
   437 	for(TInt cnt=1;err<KErrNone;++cnt)
   519 	for(TInt cnt=0;err<KErrNone;++cnt)
   438 		{		
   520 		{		
   439 		TheTest.Printf(_L("%d \r"), cnt);		
   521 		TheTest.Printf(_L("%d \r"), cnt);		
   440 		err = TheDb.Open(KTestDbName);
   522 		err = TheDb.Open(KTestDbName);
   441 		TEST2(err, KErrNone);
   523 		TEST2(err, KErrNone);
   442 		RSqlStatement stmt;
   524 		RSqlStatement stmt;
   497 	TEST(err >= 0);
   579 	TEST(err >= 0);
   498 	err = TheDb.Exec(_L("INSERT INTO A(Id,Name) VALUES(1,'Name')"));
   580 	err = TheDb.Exec(_L("INSERT INTO A(Id,Name) VALUES(1,'Name')"));
   499 	TEST2(err, 1);
   581 	TEST2(err, 1);
   500 	TheDb.Close();
   582 	TheDb.Close();
   501 	err = -1;
   583 	err = -1;
   502 	for(TInt cnt=1;err<KErrNone;++cnt)
   584 	for(TInt cnt=0;err<KErrNone;++cnt)
   503 		{		
   585 		{		
   504 		TheTest.Printf(_L("%d \r"), cnt);		
   586 		TheTest.Printf(_L("%d \r"), cnt);		
   505 		err = TheDb.Open(KTestDbName);
   587 		err = TheDb.Open(KTestDbName);
   506 		TEST2(err, KErrNone);
   588 		TEST2(err, KErrNone);
   507 		RSqlStatement stmt;
   589 		RSqlStatement stmt;
   715 	{
   797 	{
   716 	TheTest.Printf(_L("Update 1 record in a file I/o simulation loop\r\n"));		
   798 	TheTest.Printf(_L("Update 1 record in a file I/o simulation loop\r\n"));		
   717 	TInt rc = -1;
   799 	TInt rc = -1;
   718 	TBuf8<KMaxFileName + 1> dbFileName8;
   800 	TBuf8<KMaxFileName + 1> dbFileName8;
   719 	dbFileName8.Copy(TheRmvMediaDbFileName);
   801 	dbFileName8.Copy(TheRmvMediaDbFileName);
   720 	for(TInt cnt=1;rc!=SQLITE_OK;++cnt)
   802 	for(TInt cnt=0;rc!=SQLITE_OK;++cnt)
   721 		{		
   803 		{		
   722 		TheTest.Printf(_L("%d \r"), cnt);		
   804 		TheTest.Printf(_L("%d \r"), cnt);		
   723 		sqlite3* dbHandle = NULL;
   805 		sqlite3* dbHandle = NULL;
   724 		rc = sqlite3_open((const char*)dbFileName8.PtrZ(), &dbHandle);
   806 		rc = sqlite3_open((const char*)dbFileName8.PtrZ(), &dbHandle);
   725 		SQLITE_TEST(dbHandle, rc, SQLITE_OK);
   807 		SQLITE_TEST(dbHandle, rc, SQLITE_OK);
   816 	TEST(size1.iSize > 0);
   898 	TEST(size1.iSize > 0);
   817 	TEST2(size1.iFree, 0);
   899 	TEST2(size1.iFree, 0);
   818 	TheDb.Close();
   900 	TheDb.Close();
   819 	//"File I/O" error simulation loop
   901 	//"File I/O" error simulation loop
   820 	err = KErrCorrupt;
   902 	err = KErrCorrupt;
   821 	for(TInt cnt=1;err<KErrNone;++cnt)
   903 	for(TInt cnt=0;err<KErrNone;++cnt)
   822 		{
   904 		{
   823 		TheTest.Printf(_L("%d \r"), cnt);		
   905 		TheTest.Printf(_L("%d \r"), cnt);		
   824 		TEST2(TheDb.Open(KTestDbName), KErrNone);
   906 		TEST2(TheDb.Open(KTestDbName), KErrNone);
   825 		(void)TheFs.SetErrorCondition(KErrCorrupt, cnt);
   907 		(void)TheFs.SetErrorCondition(KErrCorrupt, cnt);
   826 		RSqlDatabase::TSize size2 = {-1, -1};
   908 		RSqlDatabase::TSize size2 = {-1, -1};
   899 	TheDb.Close();
   981 	TheDb.Close();
   900 	TEST(size.iSize > 0);
   982 	TEST(size.iSize > 0);
   901 	TEST(size.iFree > 0);
   983 	TEST(size.iFree > 0);
   902 	//"File I/O" error simulation loop
   984 	//"File I/O" error simulation loop
   903 	err = KErrCorrupt;
   985 	err = KErrCorrupt;
   904 	for(TInt cnt=1;err<KErrNone;++cnt)
   986 	for(TInt cnt=0;err<KErrNone;++cnt)
   905 		{
   987 		{
   906 		TheTest.Printf(_L("%d \r"), cnt);		
   988 		TheTest.Printf(_L("%d \r"), cnt);		
   907 		TEST2(TheDb.Open(KTestDbName), KErrNone);
   989 		TEST2(TheDb.Open(KTestDbName), KErrNone);
   908 		(void)TheFs.SetErrorCondition(KErrCorrupt, cnt);
   990 		(void)TheFs.SetErrorCondition(KErrCorrupt, cnt);
   909 		err = TheDb.Compact(RSqlDatabase::EMaxCompaction);
   991 		err = TheDb.Compact(RSqlDatabase::EMaxCompaction);
   989 	err = TheDb.Exec(sql);
  1071 	err = TheDb.Exec(sql);
   990 	TEST2(err, 1);
  1072 	TEST2(err, 1);
   991 	TheDb.Close();
  1073 	TheDb.Close();
   992 	
  1074 	
   993 	err = KErrCorrupt;
  1075 	err = KErrCorrupt;
   994 	for(TInt cnt=1;err<KErrNone;++cnt)
  1076 	for(TInt cnt=0;err<KErrNone;++cnt)
   995 		{
  1077 		{
   996 		TheTest.Printf(_L("%d \r"), cnt);		
  1078 		TheTest.Printf(_L("%d \r"), cnt);		
   997 		TEST2(TheDb.Open(KTestDbName), KErrNone);
  1079 		TEST2(TheDb.Open(KTestDbName), KErrNone);
   998 		if(aAttachDb)
  1080 		if(aAttachDb)
   999 			{
  1081 			{
  1088 	HBufC8* buf = HBufC8::New(KBlobSize);
  1170 	HBufC8* buf = HBufC8::New(KBlobSize);
  1089 	TEST(buf != NULL);
  1171 	TEST(buf != NULL);
  1090 	TPtr8 bufptr = buf->Des();
  1172 	TPtr8 bufptr = buf->Des();
  1091 	
  1173 	
  1092 	err = KErrCorrupt;
  1174 	err = KErrCorrupt;
  1093 	for(TInt cnt=1;err<KErrNone;++cnt)
  1175 	for(TInt cnt=0;err<KErrNone;++cnt)
  1094 		{
  1176 		{
  1095 		TheTest.Printf(_L("%d \r"), cnt);		
  1177 		TheTest.Printf(_L("%d \r"), cnt);		
  1096 		TEST2(TheDb.Open(KTestDbName), KErrNone);
  1178 		TEST2(TheDb.Open(KTestDbName), KErrNone);
  1097 		if(aAttachDb)
  1179 		if(aAttachDb)
  1098 			{
  1180 			{
  1131 	AlterDatabaseTest2();
  1213 	AlterDatabaseTest2();
  1132 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3421 Open database during file I/O error "));
  1214 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3421 Open database during file I/O error "));
  1133 	OpenDatabaseTest();
  1215 	OpenDatabaseTest();
  1134 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3434 Create database during file I/O error "));
  1216 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3434 Create database during file I/O error "));
  1135 	CreateDatabaseTest();
  1217 	CreateDatabaseTest();
       
  1218     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4189 Attach database during file I/O error "));
       
  1219     AttachDatabaseTest();
       
  1220     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4190 Delete database during file I/O error "));
       
  1221     DeleteDatabaseTest();
  1136 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3462 Select record test during file I/O error "));
  1222 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3462 Select record test during file I/O error "));
  1137 	SelectRecordTest();
  1223 	SelectRecordTest();
  1138 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3463 Insert record test during file I/O error "));
  1224 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3463 Insert record test during file I/O error "));
  1139 	InsertRecordTest();
  1225 	InsertRecordTest();
  1140 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3516 Removable Media robustness test "));
  1226 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3516 Removable Media robustness test "));